1 // Copyright (C) 2007-2015 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::getDirectChildrenWithNull() 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 * This method put in info format the result of the merge of \a var and \a unit.
427 * The standard format for that is "var [unit]".
428 * Inversely you can retrieve the var part or the unit part of info string using resp. GetVarNameFromInfo and GetUnitFromInfo.
430 std::string DataArray::BuildInfoFromVarAndUnit(const std::string& var, const std::string& unit)
432 std::ostringstream oss;
433 oss << var << " [" << unit << "]";
438 * Returns a new DataArray by concatenating all given arrays, so that (1) the number
439 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
440 * the number of component in the result array is same as that of each of given arrays.
441 * Info on components is copied from the first of the given arrays. Number of components
442 * in the given arrays must be the same.
443 * \param [in] arrs - a sequence of arrays to include in the result array. All arrays must have the same type.
444 * \return DataArray * - the new instance of DataArray (that can be either DataArrayInt, DataArrayDouble, DataArrayChar).
445 * The caller is to delete this result array using decrRef() as it is no more
447 * \throw If all arrays within \a arrs are NULL.
448 * \throw If all not null arrays in \a arrs have not the same type.
449 * \throw If getNumberOfComponents() of arrays within \a arrs.
451 DataArray *DataArray::Aggregate(const std::vector<const DataArray *>& arrs)
453 std::vector<const DataArray *> arr2;
454 for(std::vector<const DataArray *>::const_iterator it=arrs.begin();it!=arrs.end();it++)
458 throw INTERP_KERNEL::Exception("DataArray::Aggregate : only null instance in input vector !");
459 std::vector<const DataArrayDouble *> arrd;
460 std::vector<const DataArrayInt *> arri;
461 std::vector<const DataArrayChar *> arrc;
462 for(std::vector<const DataArray *>::const_iterator it=arr2.begin();it!=arr2.end();it++)
464 const DataArrayDouble *a=dynamic_cast<const DataArrayDouble *>(*it);
466 { arrd.push_back(a); continue; }
467 const DataArrayInt *b=dynamic_cast<const DataArrayInt *>(*it);
469 { arri.push_back(b); continue; }
470 const DataArrayChar *c=dynamic_cast<const DataArrayChar *>(*it);
472 { arrc.push_back(c); continue; }
473 throw INTERP_KERNEL::Exception("DataArray::Aggregate : presence of not null instance in inuput that is not in [DataArrayDouble, DataArrayInt, DataArrayChar] !");
475 if(arr2.size()==arrd.size())
476 return DataArrayDouble::Aggregate(arrd);
477 if(arr2.size()==arri.size())
478 return DataArrayInt::Aggregate(arri);
479 if(arr2.size()==arrc.size())
480 return DataArrayChar::Aggregate(arrc);
481 throw INTERP_KERNEL::Exception("DataArray::Aggregate : all input arrays must have the same type !");
485 * Sets information on a component specified by an index.
486 * To know more on format of this information
487 * see \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
488 * \warning Don't pass NULL as \a info!
489 * \param [in] i - the index (zero based) of the component of interest.
490 * \param [in] info - the string containing the information.
491 * \throw If \a i is not a valid component index.
493 void DataArray::setInfoOnComponent(int i, const std::string& info)
495 if(i<(int)_info_on_compo.size() && i>=0)
496 _info_on_compo[i]=info;
499 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();
500 throw INTERP_KERNEL::Exception(oss.str().c_str());
505 * Sets information on all components. This method can change number of components
506 * at certain conditions; if the conditions are not respected, an exception is thrown.
507 * The number of components can be changed in \a this only if \a this is not allocated.
508 * The condition of number of components must not be changed.
510 * To know more on format of the component information see
511 * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
512 * \param [in] info - a vector of component infos.
513 * \throw If \a this->getNumberOfComponents() != \a info.size() && \a this->isAllocated()
515 void DataArray::setInfoAndChangeNbOfCompo(const std::vector<std::string>& info)
517 if(getNumberOfComponents()!=(int)info.size())
523 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 !";
524 throw INTERP_KERNEL::Exception(oss.str().c_str());
531 void DataArray::checkNbOfTuples(int nbOfTuples, const std::string& msg) const
533 if(getNumberOfTuples()!=nbOfTuples)
535 std::ostringstream oss; oss << msg << " : mismatch number of tuples : expected " << nbOfTuples << " having " << getNumberOfTuples() << " !";
536 throw INTERP_KERNEL::Exception(oss.str().c_str());
540 void DataArray::checkNbOfComps(int nbOfCompo, const std::string& msg) const
542 if(getNumberOfComponents()!=nbOfCompo)
544 std::ostringstream oss; oss << msg << " : mismatch number of components : expected " << nbOfCompo << " having " << getNumberOfComponents() << " !";
545 throw INTERP_KERNEL::Exception(oss.str().c_str());
549 void DataArray::checkNbOfElems(std::size_t nbOfElems, const std::string& msg) const
551 if(getNbOfElems()!=nbOfElems)
553 std::ostringstream oss; oss << msg << " : mismatch number of elems : Expected " << nbOfElems << " having " << getNbOfElems() << " !";
554 throw INTERP_KERNEL::Exception(oss.str().c_str());
558 void DataArray::checkNbOfTuplesAndComp(const DataArray& other, const std::string& msg) const
560 if(getNumberOfTuples()!=other.getNumberOfTuples())
562 std::ostringstream oss; oss << msg << " : mismatch number of tuples : expected " << other.getNumberOfTuples() << " having " << getNumberOfTuples() << " !";
563 throw INTERP_KERNEL::Exception(oss.str().c_str());
565 if(getNumberOfComponents()!=other.getNumberOfComponents())
567 std::ostringstream oss; oss << msg << " : mismatch number of components : expected " << other.getNumberOfComponents() << " having " << getNumberOfComponents() << " !";
568 throw INTERP_KERNEL::Exception(oss.str().c_str());
572 void DataArray::checkNbOfTuplesAndComp(int nbOfTuples, int nbOfCompo, const std::string& msg) const
574 checkNbOfTuples(nbOfTuples,msg);
575 checkNbOfComps(nbOfCompo,msg);
579 * Simply this method checks that \b value is in [0,\b ref).
581 void DataArray::CheckValueInRange(int ref, int value, const std::string& msg)
583 if(value<0 || value>=ref)
585 std::ostringstream oss; oss << "DataArray::CheckValueInRange : " << msg << " ! Expected in range [0," << ref << "[ having " << value << " !";
586 throw INTERP_KERNEL::Exception(oss.str().c_str());
591 * This method checks that [\b start, \b end) is compliant with ref length \b value.
592 * typicaly start in [0,\b value) and end in [0,\b value). If value==start and start==end, it is supported.
594 void DataArray::CheckValueInRangeEx(int value, int start, int end, const std::string& msg)
596 if(start<0 || start>=value)
598 if(value!=start || end!=start)
600 std::ostringstream oss; oss << "DataArray::CheckValueInRangeEx : " << msg << " ! Expected start " << start << " of input range, in [0," << value << "[ !";
601 throw INTERP_KERNEL::Exception(oss.str().c_str());
604 if(end<0 || end>value)
606 std::ostringstream oss; oss << "DataArray::CheckValueInRangeEx : " << msg << " ! Expected end " << end << " of input range, in [0," << value << "] !";
607 throw INTERP_KERNEL::Exception(oss.str().c_str());
611 void DataArray::CheckClosingParInRange(int ref, int value, const std::string& msg)
613 if(value<0 || value>ref)
615 std::ostringstream oss; oss << "DataArray::CheckClosingParInRange : " << msg << " ! Expected input range in [0," << ref << "] having closing open parenthesis " << value << " !";
616 throw INTERP_KERNEL::Exception(oss.str().c_str());
621 * 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,
622 * typically it is a whole slice of tuples of DataArray or cells, nodes of a mesh...
624 * The input \a sliceId should be an id in [0, \a nbOfSlices) that specifies the slice of work.
626 * \param [in] start - the start of the input slice of the whole work to perform splitted into slices.
627 * \param [in] stop - the stop of the input slice of the whole work to perform splitted into slices.
628 * \param [in] step - the step (that can be <0) of the input slice of the whole work to perform splitted into slices.
629 * \param [in] sliceId - the slice id considered
630 * \param [in] nbOfSlices - the number of slices (typically the number of cores on which the work is expected to be sliced)
631 * \param [out] startSlice - the start of the slice considered
632 * \param [out] stopSlice - the stop of the slice consided
634 * \throw If \a step == 0
635 * \throw If \a nbOfSlices not > 0
636 * \throw If \a sliceId not in [0,nbOfSlices)
638 void DataArray::GetSlice(int start, int stop, int step, int sliceId, int nbOfSlices, int& startSlice, int& stopSlice)
642 std::ostringstream oss; oss << "DataArray::GetSlice : nbOfSlices (" << nbOfSlices << ") must be > 0 !";
643 throw INTERP_KERNEL::Exception(oss.str().c_str());
645 if(sliceId<0 || sliceId>=nbOfSlices)
647 std::ostringstream oss; oss << "DataArray::GetSlice : sliceId (" << nbOfSlices << ") must be in [0 , nbOfSlices (" << nbOfSlices << ") ) !";
648 throw INTERP_KERNEL::Exception(oss.str().c_str());
650 int nbElems=GetNumberOfItemGivenBESRelative(start,stop,step,"DataArray::GetSlice");
651 int minNbOfElemsPerSlice=nbElems/nbOfSlices;
652 startSlice=start+minNbOfElemsPerSlice*step*sliceId;
653 if(sliceId<nbOfSlices-1)
654 stopSlice=start+minNbOfElemsPerSlice*step*(sliceId+1);
659 int DataArray::GetNumberOfItemGivenBES(int begin, int end, int step, const std::string& msg)
663 std::ostringstream oss; oss << msg << " : end before begin !";
664 throw INTERP_KERNEL::Exception(oss.str().c_str());
670 std::ostringstream oss; oss << msg << " : invalid step should be > 0 !";
671 throw INTERP_KERNEL::Exception(oss.str().c_str());
673 return (end-1-begin)/step+1;
676 int DataArray::GetNumberOfItemGivenBESRelative(int begin, int end, int step, const std::string& msg)
679 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBES : step=0 is not allowed !");
680 if(end<begin && step>0)
682 std::ostringstream oss; oss << msg << " : end before begin whereas step is positive !";
683 throw INTERP_KERNEL::Exception(oss.str().c_str());
685 if(begin<end && step<0)
687 std::ostringstream oss; oss << msg << " : invalid step should be > 0 !";
688 throw INTERP_KERNEL::Exception(oss.str().c_str());
691 return (std::max(begin,end)-1-std::min(begin,end))/std::abs(step)+1;
696 int DataArray::GetPosOfItemGivenBESRelativeNoThrow(int value, int begin, int end, int step)
702 if(begin<=value && value<end)
704 if((value-begin)%step==0)
705 return (value-begin)/step;
714 if(begin>=value && value>end)
716 if((begin-value)%(-step)==0)
717 return (begin-value)/(-step);
730 * Returns a new instance of DataArrayDouble. The caller is to delete this array
731 * using decrRef() as it is no more needed.
733 DataArrayDouble *DataArrayDouble::New()
735 return new DataArrayDouble;
739 * Checks if raw data is allocated. Read more on the raw data
740 * in \ref MEDCouplingArrayBasicsTuplesAndCompo "DataArrays infos" for more information.
741 * \return bool - \a true if the raw data is allocated, \a false else.
743 bool DataArrayDouble::isAllocated() const
745 return getConstPointer()!=0;
749 * Checks if raw data is allocated and throws an exception if it is not the case.
750 * \throw If the raw data is not allocated.
752 void DataArrayDouble::checkAllocated() const
755 throw INTERP_KERNEL::Exception("DataArrayDouble::checkAllocated : Array is defined but not allocated ! Call alloc or setValues method first !");
759 * This method desallocated \a this without modification of informations relative to the components.
760 * After call of this method, DataArrayDouble::isAllocated will return false.
761 * If \a this is already not allocated, \a this is let unchanged.
763 void DataArrayDouble::desallocate()
768 std::size_t DataArrayDouble::getHeapMemorySizeWithoutChildren() const
770 std::size_t sz(_mem.getNbOfElemAllocated());
772 return DataArray::getHeapMemorySizeWithoutChildren()+sz;
776 * Returns the only one value in \a this, if and only if number of elements
777 * (nb of tuples * nb of components) is equal to 1, and that \a this is allocated.
778 * \return double - the sole value stored in \a this array.
779 * \throw If at least one of conditions stated above is not fulfilled.
781 double DataArrayDouble::doubleValue() const
785 if(getNbOfElems()==1)
787 return *getConstPointer();
790 throw INTERP_KERNEL::Exception("DataArrayDouble::doubleValue : DataArrayDouble instance is allocated but number of elements is not equal to 1 !");
793 throw INTERP_KERNEL::Exception("DataArrayDouble::doubleValue : DataArrayDouble instance is not allocated !");
797 * Checks the number of tuples.
798 * \return bool - \a true if getNumberOfTuples() == 0, \a false else.
799 * \throw If \a this is not allocated.
801 bool DataArrayDouble::empty() const
804 return getNumberOfTuples()==0;
808 * Returns a full copy of \a this. For more info on copying data arrays see
809 * \ref MEDCouplingArrayBasicsCopyDeep.
810 * \return DataArrayDouble * - a new instance of DataArrayDouble. The caller is to
811 * delete this array using decrRef() as it is no more needed.
813 DataArrayDouble *DataArrayDouble::deepCpy() const
815 return new DataArrayDouble(*this);
819 * Returns either a \a deep or \a shallow copy of this array. For more info see
820 * \ref MEDCouplingArrayBasicsCopyDeep and \ref MEDCouplingArrayBasicsCopyShallow.
821 * \param [in] dCpy - if \a true, a deep copy is returned, else, a shallow one.
822 * \return DataArrayDouble * - either a new instance of DataArrayDouble (if \a dCpy
823 * == \a true) or \a this instance (if \a dCpy == \a false).
825 DataArrayDouble *DataArrayDouble::performCpy(bool dCpy) const
832 return const_cast<DataArrayDouble *>(this);
837 * Copies all the data from another DataArrayDouble. For more info see
838 * \ref MEDCouplingArrayBasicsCopyDeepAssign.
839 * \param [in] other - another instance of DataArrayDouble to copy data from.
840 * \throw If the \a other is not allocated.
842 void DataArrayDouble::cpyFrom(const DataArrayDouble& other)
844 other.checkAllocated();
845 int nbOfTuples=other.getNumberOfTuples();
846 int nbOfComp=other.getNumberOfComponents();
847 allocIfNecessary(nbOfTuples,nbOfComp);
848 std::size_t nbOfElems=(std::size_t)nbOfTuples*nbOfComp;
849 double *pt=getPointer();
850 const double *ptI=other.getConstPointer();
851 for(std::size_t i=0;i<nbOfElems;i++)
853 copyStringInfoFrom(other);
857 * This method reserve nbOfElems elements in memory ( nbOfElems*8 bytes ) \b without impacting the number of tuples in \a this.
858 * 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.
859 * If \a this has not already been allocated, number of components is set to one.
860 * This method allows to reduce number of reallocations on invokation of DataArrayDouble::pushBackSilent and DataArrayDouble::pushBackValsSilent on \a this.
862 * \sa DataArrayDouble::pack, DataArrayDouble::pushBackSilent, DataArrayDouble::pushBackValsSilent
864 void DataArrayDouble::reserve(std::size_t nbOfElems)
866 int nbCompo=getNumberOfComponents();
869 _mem.reserve(nbOfElems);
873 _mem.reserve(nbOfElems);
874 _info_on_compo.resize(1);
877 throw INTERP_KERNEL::Exception("DataArrayDouble::reserve : not available for DataArrayDouble with number of components different than 1 !");
881 * 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
882 * of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
884 * \param [in] val the value to be added in \a this
885 * \throw If \a this has already been allocated with number of components different from one.
886 * \sa DataArrayDouble::pushBackValsSilent
888 void DataArrayDouble::pushBackSilent(double val)
890 int nbCompo=getNumberOfComponents();
895 _info_on_compo.resize(1);
899 throw INTERP_KERNEL::Exception("DataArrayDouble::pushBackSilent : not available for DataArrayDouble with number of components different than 1 !");
903 * 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
904 * of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
906 * \param [in] valsBg - an array of values to push at the end of \this.
907 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
908 * the last value of \a valsBg is \a valsEnd[ -1 ].
909 * \throw If \a this has already been allocated with number of components different from one.
910 * \sa DataArrayDouble::pushBackSilent
912 void DataArrayDouble::pushBackValsSilent(const double *valsBg, const double *valsEnd)
914 int nbCompo=getNumberOfComponents();
916 _mem.insertAtTheEnd(valsBg,valsEnd);
919 _info_on_compo.resize(1);
920 _mem.insertAtTheEnd(valsBg,valsEnd);
923 throw INTERP_KERNEL::Exception("DataArrayDouble::pushBackValsSilent : not available for DataArrayDouble with number of components different than 1 !");
927 * This method returns silently ( without updating time label in \a this ) the last value, if any and suppress it.
928 * \throw If \a this is already empty.
929 * \throw If \a this has number of components different from one.
931 double DataArrayDouble::popBackSilent()
933 if(getNumberOfComponents()==1)
934 return _mem.popBack();
936 throw INTERP_KERNEL::Exception("DataArrayDouble::popBackSilent : not available for DataArrayDouble with number of components different than 1 !");
940 * 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.
942 * \sa DataArrayDouble::getHeapMemorySizeWithoutChildren, DataArrayDouble::reserve
944 void DataArrayDouble::pack() const
950 * Allocates the raw data in memory. If exactly same memory as needed already
951 * allocated, it is not re-allocated.
952 * \param [in] nbOfTuple - number of tuples of data to allocate.
953 * \param [in] nbOfCompo - number of components of data to allocate.
954 * \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
956 void DataArrayDouble::allocIfNecessary(int nbOfTuple, int nbOfCompo)
960 if(nbOfTuple!=getNumberOfTuples() || nbOfCompo!=getNumberOfComponents())
961 alloc(nbOfTuple,nbOfCompo);
964 alloc(nbOfTuple,nbOfCompo);
968 * Allocates the raw data in memory. If the memory was already allocated, then it is
969 * freed and re-allocated. See an example of this method use
970 * \ref MEDCouplingArraySteps1WC "here".
971 * \param [in] nbOfTuple - number of tuples of data to allocate.
972 * \param [in] nbOfCompo - number of components of data to allocate.
973 * \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
975 void DataArrayDouble::alloc(int nbOfTuple, int nbOfCompo)
977 if(nbOfTuple<0 || nbOfCompo<0)
978 throw INTERP_KERNEL::Exception("DataArrayDouble::alloc : request for negative length of data !");
979 _info_on_compo.resize(nbOfCompo);
980 _mem.alloc(nbOfCompo*(std::size_t)nbOfTuple);
985 * Assign zero to all values in \a this array. To know more on filling arrays see
986 * \ref MEDCouplingArrayFill.
987 * \throw If \a this is not allocated.
989 void DataArrayDouble::fillWithZero()
992 _mem.fillWithValue(0.);
997 * Assign \a val to all values in \a this array. To know more on filling arrays see
998 * \ref MEDCouplingArrayFill.
999 * \param [in] val - the value to fill with.
1000 * \throw If \a this is not allocated.
1002 void DataArrayDouble::fillWithValue(double val)
1005 _mem.fillWithValue(val);
1010 * Set all values in \a this array so that the i-th element equals to \a init + i
1011 * (i starts from zero). To know more on filling arrays see \ref MEDCouplingArrayFill.
1012 * \param [in] init - value to assign to the first element of array.
1013 * \throw If \a this->getNumberOfComponents() != 1
1014 * \throw If \a this is not allocated.
1016 void DataArrayDouble::iota(double init)
1019 if(getNumberOfComponents()!=1)
1020 throw INTERP_KERNEL::Exception("DataArrayDouble::iota : works only for arrays with only one component, you can call 'rearrange' method before !");
1021 double *ptr=getPointer();
1022 int ntuples=getNumberOfTuples();
1023 for(int i=0;i<ntuples;i++)
1024 ptr[i]=init+double(i);
1029 * Checks if all values in \a this array are equal to \a val at precision \a eps.
1030 * \param [in] val - value to check equality of array values to.
1031 * \param [in] eps - precision to check the equality.
1032 * \return bool - \a true if all values are in range (_val_ - _eps_; _val_ + _eps_),
1034 * \throw If \a this->getNumberOfComponents() != 1
1035 * \throw If \a this is not allocated.
1037 bool DataArrayDouble::isUniform(double val, double eps) const
1040 if(getNumberOfComponents()!=1)
1041 throw INTERP_KERNEL::Exception("DataArrayDouble::isUniform : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
1042 int nbOfTuples=getNumberOfTuples();
1043 const double *w=getConstPointer();
1044 const double *end2=w+nbOfTuples;
1045 const double vmin=val-eps;
1046 const double vmax=val+eps;
1048 if(*w<vmin || *w>vmax)
1054 * Sorts values of the array.
1055 * \param [in] asc - \a true means ascending order, \a false, descending.
1056 * \throw If \a this is not allocated.
1057 * \throw If \a this->getNumberOfComponents() != 1.
1059 void DataArrayDouble::sort(bool asc)
1062 if(getNumberOfComponents()!=1)
1063 throw INTERP_KERNEL::Exception("DataArrayDouble::sort : only supported with 'this' array with ONE component !");
1069 * Reverse the array values.
1070 * \throw If \a this->getNumberOfComponents() < 1.
1071 * \throw If \a this is not allocated.
1073 void DataArrayDouble::reverse()
1076 _mem.reverse(getNumberOfComponents());
1081 * Checks that \a this array is consistently **increasing** or **decreasing** in value,
1082 * with at least absolute difference value of |\a eps| at each step.
1083 * If not an exception is thrown.
1084 * \param [in] increasing - if \a true, the array values should be increasing.
1085 * \param [in] eps - minimal absolute difference between the neighbor values at which
1086 * the values are considered different.
1087 * \throw If sequence of values is not strictly monotonic in agreement with \a
1089 * \throw If \a this->getNumberOfComponents() != 1.
1090 * \throw If \a this is not allocated.
1092 void DataArrayDouble::checkMonotonic(bool increasing, double eps) const
1094 if(!isMonotonic(increasing,eps))
1097 throw INTERP_KERNEL::Exception("DataArrayDouble::checkMonotonic : 'this' is not INCREASING monotonic !");
1099 throw INTERP_KERNEL::Exception("DataArrayDouble::checkMonotonic : 'this' is not DECREASING monotonic !");
1104 * Checks that \a this array is consistently **increasing** or **decreasing** in value,
1105 * with at least absolute difference value of |\a eps| at each step.
1106 * \param [in] increasing - if \a true, array values should be increasing.
1107 * \param [in] eps - minimal absolute difference between the neighbor values at which
1108 * the values are considered different.
1109 * \return bool - \a true if values change in accordance with \a increasing arg.
1110 * \throw If \a this->getNumberOfComponents() != 1.
1111 * \throw If \a this is not allocated.
1113 bool DataArrayDouble::isMonotonic(bool increasing, double eps) const
1116 if(getNumberOfComponents()!=1)
1117 throw INTERP_KERNEL::Exception("DataArrayDouble::isMonotonic : only supported with 'this' array with ONE component !");
1118 int nbOfElements=getNumberOfTuples();
1119 const double *ptr=getConstPointer();
1123 double absEps=fabs(eps);
1126 for(int i=1;i<nbOfElements;i++)
1128 if(ptr[i]<(ref+absEps))
1136 for(int i=1;i<nbOfElements;i++)
1138 if(ptr[i]>(ref-absEps))
1147 * Returns a textual and human readable representation of \a this instance of
1148 * DataArrayDouble. This text is shown when a DataArrayDouble is printed in Python.
1149 * \return std::string - text describing \a this DataArrayDouble.
1151 * \sa reprNotTooLong, reprZip
1153 std::string DataArrayDouble::repr() const
1155 std::ostringstream ret;
1160 std::string DataArrayDouble::reprZip() const
1162 std::ostringstream ret;
1168 * This method is close to repr method except that when \a this has more than 1000 tuples, all tuples are not
1169 * printed out to avoid to consume too much space in interpretor.
1172 std::string DataArrayDouble::reprNotTooLong() const
1174 std::ostringstream ret;
1175 reprNotTooLongStream(ret);
1179 void DataArrayDouble::writeVTK(std::ostream& ofs, int indent, const std::string& nameInFile, DataArrayByte *byteArr) const
1181 static const char SPACE[4]={' ',' ',' ',' '};
1183 std::string idt(indent,' ');
1185 ofs << idt << "<DataArray type=\"Float32\" Name=\"" << nameInFile << "\" NumberOfComponents=\"" << getNumberOfComponents() << "\"";
1187 bool areAllEmpty(true);
1188 for(std::vector<std::string>::const_iterator it=_info_on_compo.begin();it!=_info_on_compo.end();it++)
1192 for(std::size_t i=0;i<_info_on_compo.size();i++)
1193 ofs << " ComponentName" << i << "=\"" << _info_on_compo[i] << "\"";
1197 ofs << " format=\"appended\" offset=\"" << byteArr->getNumberOfTuples() << "\">";
1198 INTERP_KERNEL::AutoPtr<float> tmp(new float[getNbOfElems()]);
1200 // to make Visual C++ happy : instead of std::copy(begin(),end(),(float *)tmp);
1201 for(const double *src=begin();src!=end();src++,pt++)
1203 const char *data(reinterpret_cast<const char *>((float *)tmp));
1204 std::size_t sz(getNbOfElems()*sizeof(float));
1205 byteArr->insertAtTheEnd(data,data+sz);
1206 byteArr->insertAtTheEnd(SPACE,SPACE+4);
1210 ofs << " RangeMin=\"" << getMinValueInArray() << "\" RangeMax=\"" << getMaxValueInArray() << "\" format=\"ascii\">\n" << idt;
1211 std::copy(begin(),end(),std::ostream_iterator<double>(ofs," "));
1213 ofs << std::endl << idt << "</DataArray>\n";
1216 void DataArrayDouble::reprStream(std::ostream& stream) const
1218 stream << "Name of double array : \"" << _name << "\"\n";
1219 reprWithoutNameStream(stream);
1222 void DataArrayDouble::reprZipStream(std::ostream& stream) const
1224 stream << "Name of double array : \"" << _name << "\"\n";
1225 reprZipWithoutNameStream(stream);
1228 void DataArrayDouble::reprNotTooLongStream(std::ostream& stream) const
1230 stream << "Name of double array : \"" << _name << "\"\n";
1231 reprNotTooLongWithoutNameStream(stream);
1234 void DataArrayDouble::reprWithoutNameStream(std::ostream& stream) const
1236 DataArray::reprWithoutNameStream(stream);
1237 stream.precision(17);
1238 _mem.repr(getNumberOfComponents(),stream);
1241 void DataArrayDouble::reprZipWithoutNameStream(std::ostream& stream) const
1243 DataArray::reprWithoutNameStream(stream);
1244 stream.precision(17);
1245 _mem.reprZip(getNumberOfComponents(),stream);
1248 void DataArrayDouble::reprNotTooLongWithoutNameStream(std::ostream& stream) const
1250 DataArray::reprWithoutNameStream(stream);
1251 stream.precision(17);
1252 _mem.reprNotTooLong(getNumberOfComponents(),stream);
1255 void DataArrayDouble::reprCppStream(const std::string& varName, std::ostream& stream) const
1257 int nbTuples=getNumberOfTuples(),nbComp=getNumberOfComponents();
1258 const double *data=getConstPointer();
1259 stream.precision(17);
1260 stream << "DataArrayDouble *" << varName << "=DataArrayDouble::New();" << std::endl;
1261 if(nbTuples*nbComp>=1)
1263 stream << "const double " << varName << "Data[" << nbTuples*nbComp << "]={";
1264 std::copy(data,data+nbTuples*nbComp-1,std::ostream_iterator<double>(stream,","));
1265 stream << data[nbTuples*nbComp-1] << "};" << std::endl;
1266 stream << varName << "->useArray(" << varName << "Data,false,CPP_DEALLOC," << nbTuples << "," << nbComp << ");" << std::endl;
1269 stream << varName << "->alloc(" << nbTuples << "," << nbComp << ");" << std::endl;
1270 stream << varName << "->setName(\"" << getName() << "\");" << std::endl;
1274 * Method that gives a quick overvien of \a this for python.
1276 void DataArrayDouble::reprQuickOverview(std::ostream& stream) const
1278 static const std::size_t MAX_NB_OF_BYTE_IN_REPR=300;
1279 stream << "DataArrayDouble C++ instance at " << this << ". ";
1282 int nbOfCompo=(int)_info_on_compo.size();
1285 int nbOfTuples=getNumberOfTuples();
1286 stream << "Number of tuples : " << nbOfTuples << ". Number of components : " << nbOfCompo << "." << std::endl;
1287 reprQuickOverviewData(stream,MAX_NB_OF_BYTE_IN_REPR);
1290 stream << "Number of components : 0.";
1293 stream << "*** No data allocated ****";
1296 void DataArrayDouble::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const
1298 const double *data=begin();
1299 int nbOfTuples=getNumberOfTuples();
1300 int nbOfCompo=(int)_info_on_compo.size();
1301 std::ostringstream oss2; oss2 << "[";
1303 std::string oss2Str(oss2.str());
1304 bool isFinished=true;
1305 for(int i=0;i<nbOfTuples && isFinished;i++)
1310 for(int j=0;j<nbOfCompo;j++,data++)
1313 if(j!=nbOfCompo-1) oss2 << ", ";
1319 if(i!=nbOfTuples-1) oss2 << ", ";
1320 std::string oss3Str(oss2.str());
1321 if(oss3Str.length()<maxNbOfByteInRepr)
1333 * Equivalent to DataArrayDouble::isEqual except that if false the reason of
1334 * mismatch is given.
1336 * \param [in] other the instance to be compared with \a this
1337 * \param [in] prec the precision to compare numeric data of the arrays.
1338 * \param [out] reason In case of inequality returns the reason.
1339 * \sa DataArrayDouble::isEqual
1341 bool DataArrayDouble::isEqualIfNotWhy(const DataArrayDouble& other, double prec, std::string& reason) const
1343 if(!areInfoEqualsIfNotWhy(other,reason))
1345 return _mem.isEqual(other._mem,prec,reason);
1349 * Checks if \a this and another DataArrayDouble are fully equal. For more info see
1350 * \ref MEDCouplingArrayBasicsCompare.
1351 * \param [in] other - an instance of DataArrayDouble to compare with \a this one.
1352 * \param [in] prec - precision value to compare numeric data of the arrays.
1353 * \return bool - \a true if the two arrays are equal, \a false else.
1355 bool DataArrayDouble::isEqual(const DataArrayDouble& other, double prec) const
1358 return isEqualIfNotWhy(other,prec,tmp);
1362 * Checks if values of \a this and another DataArrayDouble are equal. For more info see
1363 * \ref MEDCouplingArrayBasicsCompare.
1364 * \param [in] other - an instance of DataArrayDouble to compare with \a this one.
1365 * \param [in] prec - precision value to compare numeric data of the arrays.
1366 * \return bool - \a true if the values of two arrays are equal, \a false else.
1368 bool DataArrayDouble::isEqualWithoutConsideringStr(const DataArrayDouble& other, double prec) const
1371 return _mem.isEqual(other._mem,prec,tmp);
1375 * Changes number of tuples in the array. If the new number of tuples is smaller
1376 * than the current number the array is truncated, otherwise the array is extended.
1377 * \param [in] nbOfTuples - new number of tuples.
1378 * \throw If \a this is not allocated.
1379 * \throw If \a nbOfTuples is negative.
1381 void DataArrayDouble::reAlloc(int nbOfTuples)
1384 throw INTERP_KERNEL::Exception("DataArrayDouble::reAlloc : input new number of tuples should be >=0 !");
1386 _mem.reAlloc(getNumberOfComponents()*(std::size_t)nbOfTuples);
1391 * Creates a new DataArrayInt and assigns all (textual and numerical) data of \a this
1392 * array to the new one.
1393 * \return DataArrayInt * - the new instance of DataArrayInt.
1395 DataArrayInt *DataArrayDouble::convertToIntArr() const
1397 DataArrayInt *ret=DataArrayInt::New();
1398 ret->alloc(getNumberOfTuples(),getNumberOfComponents());
1399 int *dest=ret->getPointer();
1400 // to make Visual C++ happy : instead of std::size_t nbOfVals=getNbOfElems(); std::copy(src,src+nbOfVals,dest);
1401 for(const double *src=begin();src!=end();src++,dest++)
1403 ret->copyStringInfoFrom(*this);
1408 * Returns a new DataArrayDouble holding the same values as \a this array but differently
1409 * arranged in memory. If \a this array holds 2 components of 3 values:
1410 * \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$, then the result array holds these values arranged
1411 * as follows: \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$.
1412 * \warning Do not confuse this method with transpose()!
1413 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1414 * is to delete using decrRef() as it is no more needed.
1415 * \throw If \a this is not allocated.
1417 DataArrayDouble *DataArrayDouble::fromNoInterlace() const
1420 throw INTERP_KERNEL::Exception("DataArrayDouble::fromNoInterlace : Not defined array !");
1421 double *tab=_mem.fromNoInterlace(getNumberOfComponents());
1422 DataArrayDouble *ret=DataArrayDouble::New();
1423 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
1428 * Returns a new DataArrayDouble holding the same values as \a this array but differently
1429 * arranged in memory. If \a this array holds 2 components of 3 values:
1430 * \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$, then the result array holds these values arranged
1431 * as follows: \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$.
1432 * \warning Do not confuse this method with transpose()!
1433 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1434 * is to delete using decrRef() as it is no more needed.
1435 * \throw If \a this is not allocated.
1437 DataArrayDouble *DataArrayDouble::toNoInterlace() const
1440 throw INTERP_KERNEL::Exception("DataArrayDouble::toNoInterlace : Not defined array !");
1441 double *tab=_mem.toNoInterlace(getNumberOfComponents());
1442 DataArrayDouble *ret=DataArrayDouble::New();
1443 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
1448 * Permutes values of \a this array as required by \a old2New array. The values are
1449 * permuted so that \c new[ \a old2New[ i ]] = \c old[ i ]. Number of tuples remains
1450 * the same as in \this one.
1451 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
1452 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1453 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
1454 * giving a new position for i-th old value.
1456 void DataArrayDouble::renumberInPlace(const int *old2New)
1459 int nbTuples=getNumberOfTuples();
1460 int nbOfCompo=getNumberOfComponents();
1461 double *tmp=new double[nbTuples*nbOfCompo];
1462 const double *iptr=getConstPointer();
1463 for(int i=0;i<nbTuples;i++)
1466 if(v>=0 && v<nbTuples)
1467 std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),tmp+nbOfCompo*v);
1470 std::ostringstream oss; oss << "DataArrayDouble::renumberInPlace : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
1471 throw INTERP_KERNEL::Exception(oss.str().c_str());
1474 std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
1480 * Permutes values of \a this array as required by \a new2Old array. The values are
1481 * permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of tuples remains
1482 * the same as in \this one.
1483 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1484 * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
1485 * giving a previous position of i-th new value.
1486 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1487 * is to delete using decrRef() as it is no more needed.
1489 void DataArrayDouble::renumberInPlaceR(const int *new2Old)
1492 int nbTuples=getNumberOfTuples();
1493 int nbOfCompo=getNumberOfComponents();
1494 double *tmp=new double[nbTuples*nbOfCompo];
1495 const double *iptr=getConstPointer();
1496 for(int i=0;i<nbTuples;i++)
1499 if(v>=0 && v<nbTuples)
1500 std::copy(iptr+nbOfCompo*v,iptr+nbOfCompo*(v+1),tmp+nbOfCompo*i);
1503 std::ostringstream oss; oss << "DataArrayDouble::renumberInPlaceR : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
1504 throw INTERP_KERNEL::Exception(oss.str().c_str());
1507 std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
1513 * Returns a copy of \a this array with values permuted as required by \a old2New array.
1514 * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ].
1515 * Number of tuples in the result array remains the same as in \this one.
1516 * If a permutation reduction is needed, renumberAndReduce() should be used.
1517 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1518 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
1519 * giving a new position for i-th old value.
1520 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1521 * is to delete using decrRef() as it is no more needed.
1522 * \throw If \a this is not allocated.
1524 DataArrayDouble *DataArrayDouble::renumber(const int *old2New) const
1527 int nbTuples=getNumberOfTuples();
1528 int nbOfCompo=getNumberOfComponents();
1529 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1530 ret->alloc(nbTuples,nbOfCompo);
1531 ret->copyStringInfoFrom(*this);
1532 const double *iptr=getConstPointer();
1533 double *optr=ret->getPointer();
1534 for(int i=0;i<nbTuples;i++)
1535 std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),optr+nbOfCompo*old2New[i]);
1536 ret->copyStringInfoFrom(*this);
1541 * Returns a copy of \a this array with values permuted as required by \a new2Old array.
1542 * The values are permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of
1543 * tuples in the result array remains the same as in \this one.
1544 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
1545 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1546 * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
1547 * giving a previous position of i-th new value.
1548 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1549 * is to delete using decrRef() as it is no more needed.
1551 DataArrayDouble *DataArrayDouble::renumberR(const int *new2Old) const
1554 int nbTuples=getNumberOfTuples();
1555 int nbOfCompo=getNumberOfComponents();
1556 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1557 ret->alloc(nbTuples,nbOfCompo);
1558 ret->copyStringInfoFrom(*this);
1559 const double *iptr=getConstPointer();
1560 double *optr=ret->getPointer();
1561 for(int i=0;i<nbTuples;i++)
1562 std::copy(iptr+nbOfCompo*new2Old[i],iptr+nbOfCompo*(new2Old[i]+1),optr+i*nbOfCompo);
1563 ret->copyStringInfoFrom(*this);
1568 * Returns a shorten and permuted copy of \a this array. The new DataArrayDouble is
1569 * of size \a newNbOfTuple and it's values are permuted as required by \a old2New array.
1570 * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ] for all
1571 * \a old2New[ i ] >= 0. In other words every i-th tuple in \a this array, for which
1572 * \a old2New[ i ] is negative, is missing from the result array.
1573 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1574 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
1575 * giving a new position for i-th old tuple and giving negative position for
1576 * for i-th old tuple that should be omitted.
1577 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1578 * is to delete using decrRef() as it is no more needed.
1580 DataArrayDouble *DataArrayDouble::renumberAndReduce(const int *old2New, int newNbOfTuple) const
1583 int nbTuples=getNumberOfTuples();
1584 int nbOfCompo=getNumberOfComponents();
1585 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1586 ret->alloc(newNbOfTuple,nbOfCompo);
1587 const double *iptr=getConstPointer();
1588 double *optr=ret->getPointer();
1589 for(int i=0;i<nbTuples;i++)
1593 std::copy(iptr+i*nbOfCompo,iptr+(i+1)*nbOfCompo,optr+w*nbOfCompo);
1595 ret->copyStringInfoFrom(*this);
1600 * Returns a shorten and permuted copy of \a this array. The new DataArrayDouble is
1601 * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
1602 * \a new2OldBg array.
1603 * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
1604 * This method is equivalent to renumberAndReduce() except that convention in input is
1605 * \c new2old and \b not \c old2new.
1606 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1607 * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
1608 * tuple index in \a this array to fill the i-th tuple in the new array.
1609 * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
1610 * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
1611 * \a new2OldBg <= \a pi < \a new2OldEnd.
1612 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1613 * is to delete using decrRef() as it is no more needed.
1615 DataArrayDouble *DataArrayDouble::selectByTupleId(const int *new2OldBg, const int *new2OldEnd) const
1618 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1619 int nbComp=getNumberOfComponents();
1620 ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
1621 ret->copyStringInfoFrom(*this);
1622 double *pt=ret->getPointer();
1623 const double *srcPt=getConstPointer();
1625 for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
1626 std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
1627 ret->copyStringInfoFrom(*this);
1632 * Returns a shorten and permuted copy of \a this array. The new DataArrayDouble is
1633 * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
1634 * \a new2OldBg array.
1635 * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
1636 * This method is equivalent to renumberAndReduce() except that convention in input is
1637 * \c new2old and \b not \c old2new.
1638 * This method is equivalent to selectByTupleId() except that it prevents coping data
1639 * from behind the end of \a this array.
1640 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1641 * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
1642 * tuple index in \a this array to fill the i-th tuple in the new array.
1643 * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
1644 * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
1645 * \a new2OldBg <= \a pi < \a new2OldEnd.
1646 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1647 * is to delete using decrRef() as it is no more needed.
1648 * \throw If \a new2OldEnd - \a new2OldBg > \a this->getNumberOfTuples().
1650 DataArrayDouble *DataArrayDouble::selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const
1653 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1654 int nbComp=getNumberOfComponents();
1655 int oldNbOfTuples=getNumberOfTuples();
1656 ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
1657 ret->copyStringInfoFrom(*this);
1658 double *pt=ret->getPointer();
1659 const double *srcPt=getConstPointer();
1661 for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
1662 if(*w>=0 && *w<oldNbOfTuples)
1663 std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
1665 throw INTERP_KERNEL::Exception("DataArrayDouble::selectByTupleIdSafe : some ids has been detected to be out of [0,this->getNumberOfTuples) !");
1666 ret->copyStringInfoFrom(*this);
1671 * Returns a shorten copy of \a this array. The new DataArrayDouble contains every
1672 * (\a bg + \c i * \a step)-th tuple of \a this array located before the \a end2-th
1673 * tuple. Indices of the selected tuples are the same as ones returned by the Python
1674 * command \c range( \a bg, \a end2, \a step ).
1675 * This method is equivalent to selectByTupleIdSafe() except that the input array is
1676 * not constructed explicitly.
1677 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1678 * \param [in] bg - index of the first tuple to copy from \a this array.
1679 * \param [in] end2 - index of the tuple before which the tuples to copy are located.
1680 * \param [in] step - index increment to get index of the next tuple to copy.
1681 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1682 * is to delete using decrRef() as it is no more needed.
1683 * \sa DataArrayDouble::substr.
1685 DataArrayDouble *DataArrayDouble::selectByTupleId2(int bg, int end2, int step) const
1688 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1689 int nbComp=getNumberOfComponents();
1690 int newNbOfTuples=GetNumberOfItemGivenBESRelative(bg,end2,step,"DataArrayDouble::selectByTupleId2 : ");
1691 ret->alloc(newNbOfTuples,nbComp);
1692 double *pt=ret->getPointer();
1693 const double *srcPt=getConstPointer()+bg*nbComp;
1694 for(int i=0;i<newNbOfTuples;i++,srcPt+=step*nbComp)
1695 std::copy(srcPt,srcPt+nbComp,pt+i*nbComp);
1696 ret->copyStringInfoFrom(*this);
1701 * Returns a shorten copy of \a this array. The new DataArrayDouble contains ranges
1702 * of tuples specified by \a ranges parameter.
1703 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1704 * \param [in] ranges - std::vector of std::pair's each of which defines a range
1705 * of tuples in [\c begin,\c end) format.
1706 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1707 * is to delete using decrRef() as it is no more needed.
1708 * \throw If \a end < \a begin.
1709 * \throw If \a end > \a this->getNumberOfTuples().
1710 * \throw If \a this is not allocated.
1712 DataArray *DataArrayDouble::selectByTupleRanges(const std::vector<std::pair<int,int> >& ranges) const
1715 int nbOfComp=getNumberOfComponents();
1716 int nbOfTuplesThis=getNumberOfTuples();
1719 DataArrayDouble *ret=DataArrayDouble::New();
1720 ret->alloc(0,nbOfComp);
1721 ret->copyStringInfoFrom(*this);
1724 int ref=ranges.front().first;
1726 bool isIncreasing=true;
1727 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
1729 if((*it).first<=(*it).second)
1731 if((*it).first>=0 && (*it).second<=nbOfTuplesThis)
1733 nbOfTuples+=(*it).second-(*it).first;
1735 isIncreasing=ref<=(*it).first;
1740 std::ostringstream oss; oss << "DataArrayDouble::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
1741 oss << " (" << (*it).first << "," << (*it).second << ") is greater than number of tuples of this :" << nbOfTuples << " !";
1742 throw INTERP_KERNEL::Exception(oss.str().c_str());
1747 std::ostringstream oss; oss << "DataArrayDouble::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
1748 oss << " (" << (*it).first << "," << (*it).second << ") end is before begin !";
1749 throw INTERP_KERNEL::Exception(oss.str().c_str());
1752 if(isIncreasing && nbOfTuplesThis==nbOfTuples)
1754 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1755 ret->alloc(nbOfTuples,nbOfComp);
1756 ret->copyStringInfoFrom(*this);
1757 const double *src=getConstPointer();
1758 double *work=ret->getPointer();
1759 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
1760 work=std::copy(src+(*it).first*nbOfComp,src+(*it).second*nbOfComp,work);
1765 * Returns a shorten copy of \a this array. The new DataArrayDouble contains all
1766 * tuples starting from the \a tupleIdBg-th tuple and including all tuples located before
1767 * the \a tupleIdEnd-th one. This methods has a similar behavior as std::string::substr().
1768 * This method is a specialization of selectByTupleId2().
1769 * \param [in] tupleIdBg - index of the first tuple to copy from \a this array.
1770 * \param [in] tupleIdEnd - index of the tuple before which the tuples to copy are located.
1771 * If \a tupleIdEnd == -1, all the tuples till the end of \a this array are copied.
1772 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1773 * is to delete using decrRef() as it is no more needed.
1774 * \throw If \a tupleIdBg < 0.
1775 * \throw If \a tupleIdBg > \a this->getNumberOfTuples().
1776 \throw If \a tupleIdEnd != -1 && \a tupleIdEnd < \a this->getNumberOfTuples().
1777 * \sa DataArrayDouble::selectByTupleId2
1779 DataArrayDouble *DataArrayDouble::substr(int tupleIdBg, int tupleIdEnd) const
1782 int nbt=getNumberOfTuples();
1784 throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter must be greater than 0 !");
1786 throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter is greater than number of tuples !");
1787 int trueEnd=tupleIdEnd;
1791 throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter is greater or equal than number of tuples !");
1795 int nbComp=getNumberOfComponents();
1796 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1797 ret->alloc(trueEnd-tupleIdBg,nbComp);
1798 ret->copyStringInfoFrom(*this);
1799 std::copy(getConstPointer()+tupleIdBg*nbComp,getConstPointer()+trueEnd*nbComp,ret->getPointer());
1804 * Returns a shorten or extended copy of \a this array. If \a newNbOfComp is less
1805 * than \a this->getNumberOfComponents() then the result array is shorten as each tuple
1806 * is truncated to have \a newNbOfComp components, keeping first components. If \a
1807 * newNbOfComp is more than \a this->getNumberOfComponents() then the result array is
1808 * expanded as each tuple is populated with \a dftValue to have \a newNbOfComp
1810 * \param [in] newNbOfComp - number of components for the new array to have.
1811 * \param [in] dftValue - value assigned to new values added to the new array.
1812 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1813 * is to delete using decrRef() as it is no more needed.
1814 * \throw If \a this is not allocated.
1816 DataArrayDouble *DataArrayDouble::changeNbOfComponents(int newNbOfComp, double dftValue) const
1819 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1820 ret->alloc(getNumberOfTuples(),newNbOfComp);
1821 const double *oldc=getConstPointer();
1822 double *nc=ret->getPointer();
1823 int nbOfTuples=getNumberOfTuples();
1824 int oldNbOfComp=getNumberOfComponents();
1825 int dim=std::min(oldNbOfComp,newNbOfComp);
1826 for(int i=0;i<nbOfTuples;i++)
1830 nc[newNbOfComp*i+j]=oldc[i*oldNbOfComp+j];
1831 for(;j<newNbOfComp;j++)
1832 nc[newNbOfComp*i+j]=dftValue;
1834 ret->setName(getName());
1835 for(int i=0;i<dim;i++)
1836 ret->setInfoOnComponent(i,getInfoOnComponent(i));
1837 ret->setName(getName());
1842 * Changes the number of components within \a this array so that its raw data **does
1843 * not** change, instead splitting this data into tuples changes.
1844 * \warning This method erases all (name and unit) component info set before!
1845 * \param [in] newNbOfComp - number of components for \a this array to have.
1846 * \throw If \a this is not allocated
1847 * \throw If getNbOfElems() % \a newNbOfCompo != 0.
1848 * \throw If \a newNbOfCompo is lower than 1.
1849 * \throw If the rearrange method would lead to a number of tuples higher than 2147483647 (maximal capacity of int32 !).
1850 * \warning This method erases all (name and unit) component info set before!
1852 void DataArrayDouble::rearrange(int newNbOfCompo)
1856 throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : input newNbOfCompo must be > 0 !");
1857 std::size_t nbOfElems=getNbOfElems();
1858 if(nbOfElems%newNbOfCompo!=0)
1859 throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : nbOfElems%newNbOfCompo!=0 !");
1860 if(nbOfElems/newNbOfCompo>(std::size_t)std::numeric_limits<int>::max())
1861 throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : the rearrangement leads to too high number of tuples (> 2147483647) !");
1862 _info_on_compo.clear();
1863 _info_on_compo.resize(newNbOfCompo);
1868 * Changes the number of components within \a this array to be equal to its number
1869 * of tuples, and inversely its number of tuples to become equal to its number of
1870 * components. So that its raw data **does not** change, instead splitting this
1871 * data into tuples changes.
1872 * \warning This method erases all (name and unit) component info set before!
1873 * \warning Do not confuse this method with fromNoInterlace() and toNoInterlace()!
1874 * \throw If \a this is not allocated.
1877 void DataArrayDouble::transpose()
1880 int nbOfTuples=getNumberOfTuples();
1881 rearrange(nbOfTuples);
1885 * Returns a copy of \a this array composed of selected components.
1886 * The new DataArrayDouble has the same number of tuples but includes components
1887 * specified by \a compoIds parameter. So that getNbOfElems() of the result array
1888 * can be either less, same or more than \a this->getNbOfElems().
1889 * \param [in] compoIds - sequence of zero based indices of components to include
1890 * into the new array.
1891 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1892 * is to delete using decrRef() as it is no more needed.
1893 * \throw If \a this is not allocated.
1894 * \throw If a component index (\a i) is not valid:
1895 * \a i < 0 || \a i >= \a this->getNumberOfComponents().
1897 * \if ENABLE_EXAMPLES
1898 * \ref py_mcdataarraydouble_KeepSelectedComponents "Here is a Python example".
1901 DataArrayDouble *DataArrayDouble::keepSelectedComponents(const std::vector<int>& compoIds) const
1904 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret(DataArrayDouble::New());
1905 std::size_t newNbOfCompo=compoIds.size();
1906 int oldNbOfCompo=getNumberOfComponents();
1907 for(std::vector<int>::const_iterator it=compoIds.begin();it!=compoIds.end();it++)
1908 if((*it)<0 || (*it)>=oldNbOfCompo)
1910 std::ostringstream oss; oss << "DataArrayDouble::keepSelectedComponents : invalid requested component : " << *it << " whereas it should be in [0," << oldNbOfCompo << ") !";
1911 throw INTERP_KERNEL::Exception(oss.str().c_str());
1913 int nbOfTuples=getNumberOfTuples();
1914 ret->alloc(nbOfTuples,(int)newNbOfCompo);
1915 ret->copyPartOfStringInfoFrom(*this,compoIds);
1916 const double *oldc=getConstPointer();
1917 double *nc=ret->getPointer();
1918 for(int i=0;i<nbOfTuples;i++)
1919 for(std::size_t j=0;j<newNbOfCompo;j++,nc++)
1920 *nc=oldc[i*oldNbOfCompo+compoIds[j]];
1925 * Appends components of another array to components of \a this one, tuple by tuple.
1926 * So that the number of tuples of \a this array remains the same and the number of
1927 * components increases.
1928 * \param [in] other - the DataArrayDouble to append to \a this one.
1929 * \throw If \a this is not allocated.
1930 * \throw If \a this and \a other arrays have different number of tuples.
1932 * \if ENABLE_EXAMPLES
1933 * \ref cpp_mcdataarraydouble_meldwith "Here is a C++ example".
1935 * \ref py_mcdataarraydouble_meldwith "Here is a Python example".
1938 void DataArrayDouble::meldWith(const DataArrayDouble *other)
1941 other->checkAllocated();
1942 int nbOfTuples=getNumberOfTuples();
1943 if(nbOfTuples!=other->getNumberOfTuples())
1944 throw INTERP_KERNEL::Exception("DataArrayDouble::meldWith : mismatch of number of tuples !");
1945 int nbOfComp1=getNumberOfComponents();
1946 int nbOfComp2=other->getNumberOfComponents();
1947 double *newArr=(double *)malloc((nbOfTuples*(nbOfComp1+nbOfComp2))*sizeof(double));
1949 const double *inp1=getConstPointer();
1950 const double *inp2=other->getConstPointer();
1951 for(int i=0;i<nbOfTuples;i++,inp1+=nbOfComp1,inp2+=nbOfComp2)
1953 w=std::copy(inp1,inp1+nbOfComp1,w);
1954 w=std::copy(inp2,inp2+nbOfComp2,w);
1956 useArray(newArr,true,C_DEALLOC,nbOfTuples,nbOfComp1+nbOfComp2);
1957 std::vector<int> compIds(nbOfComp2);
1958 for(int i=0;i<nbOfComp2;i++)
1959 compIds[i]=nbOfComp1+i;
1960 copyPartOfStringInfoFrom2(compIds,*other);
1964 * This method checks that all tuples in \a other are in \a this.
1965 * If true, the output param \a tupleIds contains the tuples ids of \a this that correspond to tupes in \a this.
1966 * 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.
1968 * \param [in] other - the array having the same number of components than \a this.
1969 * \param [out] tupleIds - the tuple ids containing the same number of tuples than \a other has.
1970 * \sa DataArrayDouble::findCommonTuples
1972 bool DataArrayDouble::areIncludedInMe(const DataArrayDouble *other, double prec, DataArrayInt *&tupleIds) const
1975 throw INTERP_KERNEL::Exception("DataArrayDouble::areIncludedInMe : input array is NULL !");
1976 checkAllocated(); other->checkAllocated();
1977 if(getNumberOfComponents()!=other->getNumberOfComponents())
1978 throw INTERP_KERNEL::Exception("DataArrayDouble::areIncludedInMe : the number of components does not match !");
1979 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> a=DataArrayDouble::Aggregate(this,other);
1980 DataArrayInt *c=0,*ci=0;
1981 a->findCommonTuples(prec,getNumberOfTuples(),c,ci);
1982 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cSafe(c),ciSafe(ci);
1983 int newNbOfTuples=-1;
1984 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(a->getNumberOfTuples(),c->begin(),ci->begin(),ci->end(),newNbOfTuples);
1985 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=ids->selectByTupleId2(getNumberOfTuples(),a->getNumberOfTuples(),1);
1986 tupleIds=ret1.retn();
1987 return newNbOfTuples==getNumberOfTuples();
1991 * Searches for tuples coincident within \a prec tolerance. Each tuple is considered
1992 * as coordinates of a point in getNumberOfComponents()-dimensional space. The
1993 * distance separating two points is computed with the infinite norm.
1995 * Indices of coincident tuples are stored in output arrays.
1996 * A pair of arrays (\a comm, \a commIndex) is called "Surjective Format 2".
1998 * This method is typically used by MEDCouplingPointSet::findCommonNodes() and
1999 * MEDCouplingUMesh::mergeNodes().
2000 * \param [in] prec - minimal absolute distance between two tuples (infinite norm) at which they are
2001 * considered not coincident.
2002 * \param [in] limitTupleId - limit tuple id. If all tuples within a group of coincident
2003 * tuples have id strictly lower than \a limitTupleId then they are not returned.
2004 * \param [out] comm - the array holding ids (== indices) of coincident tuples.
2005 * \a comm->getNumberOfComponents() == 1.
2006 * \a comm->getNumberOfTuples() == \a commIndex->back().
2007 * \param [out] commIndex - the array dividing all indices stored in \a comm into
2008 * groups of (indices of) coincident tuples. Its every value is a tuple
2009 * index where a next group of tuples begins. For example the second
2010 * group of tuples in \a comm is described by following range of indices:
2011 * [ \a commIndex[1], \a commIndex[2] ). \a commIndex->getNumberOfTuples()-1
2012 * gives the number of groups of coincident tuples.
2013 * \throw If \a this is not allocated.
2014 * \throw If the number of components is not in [1,2,3,4].
2016 * \if ENABLE_EXAMPLES
2017 * \ref cpp_mcdataarraydouble_findcommontuples "Here is a C++ example".
2019 * \ref py_mcdataarraydouble_findcommontuples "Here is a Python example".
2021 * \sa DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(), DataArrayDouble::areIncludedInMe
2023 void DataArrayDouble::findCommonTuples(double prec, int limitTupleId, DataArrayInt *&comm, DataArrayInt *&commIndex) const
2026 int nbOfCompo=getNumberOfComponents();
2027 if ((nbOfCompo<1) || (nbOfCompo>4)) //test before work
2028 throw INTERP_KERNEL::Exception("DataArrayDouble::findCommonTuples : Unexpected spacedim of coords. Must be 1, 2, 3 or 4.");
2030 int nbOfTuples=getNumberOfTuples();
2032 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> c(DataArrayInt::New()),cI(DataArrayInt::New()); c->alloc(0,1); cI->pushBackSilent(0);
2036 findCommonTuplesAlg<4>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
2039 findCommonTuplesAlg<3>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
2042 findCommonTuplesAlg<2>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
2045 findCommonTuplesAlg<1>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
2048 throw INTERP_KERNEL::Exception("DataArrayDouble::findCommonTuples : nb of components managed are 1,2,3 and 4 ! not implemented for other number of components !");
2051 commIndex=cI.retn();
2056 * \param [in] nbTimes specifies the nb of times each tuples in \a this will be duplicated contiguouly in returned DataArrayDouble instance.
2057 * \a nbTimes should be at least equal to 1.
2058 * \return a newly allocated DataArrayDouble having one component and number of tuples equal to \a nbTimes * \c this->getNumberOfTuples.
2059 * \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.
2061 DataArrayDouble *DataArrayDouble::duplicateEachTupleNTimes(int nbTimes) const
2064 if(getNumberOfComponents()!=1)
2065 throw INTERP_KERNEL::Exception("DataArrayDouble::duplicateEachTupleNTimes : this should have only one component !");
2067 throw INTERP_KERNEL::Exception("DataArrayDouble::duplicateEachTupleNTimes : nb times should be >= 1 !");
2068 int nbTuples=getNumberOfTuples();
2069 const double *inPtr=getConstPointer();
2070 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(nbTimes*nbTuples,1);
2071 double *retPtr=ret->getPointer();
2072 for(int i=0;i<nbTuples;i++,inPtr++)
2075 for(int j=0;j<nbTimes;j++,retPtr++)
2078 ret->copyStringInfoFrom(*this);
2083 * This methods returns the minimal distance between the two set of points \a this and \a other.
2084 * So \a this and \a other have to have the same number of components. If not an INTERP_KERNEL::Exception will be thrown.
2085 * This method works only if number of components of \a this (equal to those of \a other) is in 1, 2 or 3.
2087 * \param [out] thisTupleId the tuple id in \a this corresponding to the returned minimal distance
2088 * \param [out] otherTupleId the tuple id in \a other corresponding to the returned minimal distance
2089 * \return the minimal distance between the two set of points \a this and \a other.
2090 * \sa DataArrayDouble::findClosestTupleId
2092 double DataArrayDouble::minimalDistanceTo(const DataArrayDouble *other, int& thisTupleId, int& otherTupleId) const
2094 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> part1=findClosestTupleId(other);
2095 int nbOfCompo(getNumberOfComponents());
2096 int otherNbTuples(other->getNumberOfTuples());
2097 const double *thisPt(begin()),*otherPt(other->begin());
2098 const int *part1Pt(part1->begin());
2099 double ret=std::numeric_limits<double>::max();
2100 for(int i=0;i<otherNbTuples;i++,part1Pt++,otherPt+=nbOfCompo)
2103 for(int j=0;j<nbOfCompo;j++)
2104 tmp+=(otherPt[j]-thisPt[nbOfCompo*(*part1Pt)+j])*(otherPt[j]-thisPt[nbOfCompo*(*part1Pt)+j]);
2106 { ret=tmp; thisTupleId=*part1Pt; otherTupleId=i; }
2112 * This methods returns for each tuple in \a other which tuple in \a this is the closest.
2113 * So \a this and \a other have to have the same number of components. If not an INTERP_KERNEL::Exception will be thrown.
2114 * This method works only if number of components of \a this (equal to those of \a other) is in 1, 2 or 3.
2116 * \return a newly allocated (new object to be dealt by the caller) DataArrayInt having \c other->getNumberOfTuples() tuples and one components.
2117 * \sa DataArrayDouble::minimalDistanceTo
2119 DataArrayInt *DataArrayDouble::findClosestTupleId(const DataArrayDouble *other) const
2122 throw INTERP_KERNEL::Exception("DataArrayDouble::findClosestTupleId : other instance is NULL !");
2123 checkAllocated(); other->checkAllocated();
2124 int nbOfCompo=getNumberOfComponents();
2125 if(nbOfCompo!=other->getNumberOfComponents())
2127 std::ostringstream oss; oss << "DataArrayDouble::findClosestTupleId : number of components in this is " << nbOfCompo;
2128 oss << ", whereas number of components in other is " << other->getNumberOfComponents() << "! Should be equal !";
2129 throw INTERP_KERNEL::Exception(oss.str().c_str());
2131 int nbOfTuples=other->getNumberOfTuples();
2132 int thisNbOfTuples=getNumberOfTuples();
2133 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbOfTuples,1);
2135 getMinMaxPerComponent(bounds);
2140 double xDelta(fabs(bounds[1]-bounds[0])),yDelta(fabs(bounds[3]-bounds[2])),zDelta(fabs(bounds[5]-bounds[4]));
2141 double delta=std::max(xDelta,yDelta); delta=std::max(delta,zDelta);
2142 double characSize=pow((delta*delta*delta)/((double)thisNbOfTuples),1./3.);
2143 BBTreePts<3,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
2144 FindClosestTupleIdAlg<3>(myTree,3.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
2149 double xDelta(fabs(bounds[1]-bounds[0])),yDelta(fabs(bounds[3]-bounds[2]));
2150 double delta=std::max(xDelta,yDelta);
2151 double characSize=sqrt(delta/(double)thisNbOfTuples);
2152 BBTreePts<2,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
2153 FindClosestTupleIdAlg<2>(myTree,2.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
2158 double characSize=fabs(bounds[1]-bounds[0])/thisNbOfTuples;
2159 BBTreePts<1,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
2160 FindClosestTupleIdAlg<1>(myTree,1.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
2164 throw INTERP_KERNEL::Exception("Unexpected spacedim of coords for findClosestTupleId. Must be 1, 2 or 3.");
2170 * This method expects that \a this and \a otherBBoxFrmt arrays are bounding box arrays ( as the output of MEDCouplingPointSet::getBoundingBoxForBBTree method ).
2171 * 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
2172 * how many bounding boxes in \a otherBBoxFrmt.
2173 * So, this method expects that \a this and \a otherBBoxFrmt have the same number of components.
2175 * \param [in] otherBBoxFrmt - It is an array .
2176 * \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.
2177 * \sa MEDCouplingPointSet::getBoundingBoxForBBTree
2178 * \throw If \a this and \a otherBBoxFrmt have not the same number of components.
2179 * \throw If \a this and \a otherBBoxFrmt number of components is not even (BBox format).
2181 DataArrayInt *DataArrayDouble::computeNbOfInteractionsWith(const DataArrayDouble *otherBBoxFrmt, double eps) const
2184 throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : input array is NULL !");
2185 if(!isAllocated() || !otherBBoxFrmt->isAllocated())
2186 throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : this and input array must be allocated !");
2187 int nbOfComp(getNumberOfComponents()),nbOfTuples(getNumberOfTuples());
2188 if(nbOfComp!=otherBBoxFrmt->getNumberOfComponents())
2190 std::ostringstream oss; oss << "DataArrayDouble::computeNbOfInteractionsWith : this number of components (" << nbOfComp << ") must be equal to the number of components of input array (" << otherBBoxFrmt->getNumberOfComponents() << ") !";
2191 throw INTERP_KERNEL::Exception(oss.str().c_str());
2195 std::ostringstream oss; oss << "DataArrayDouble::computeNbOfInteractionsWith : Number of components (" << nbOfComp << ") is not even ! It should be to be compatible with bbox format !";
2196 throw INTERP_KERNEL::Exception(oss.str().c_str());
2198 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(nbOfTuples,1);
2199 const double *thisBBPtr(begin());
2200 int *retPtr(ret->getPointer());
2205 BBTree<3,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
2206 for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
2207 *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
2212 BBTree<2,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
2213 for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
2214 *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
2219 BBTree<1,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
2220 for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
2221 *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
2225 throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : space dimension supported are [1,2,3] !");
2232 * Returns a copy of \a this array by excluding coincident tuples. Each tuple is
2233 * considered as coordinates of a point in getNumberOfComponents()-dimensional
2234 * space. The distance between tuples is computed using norm2. If several tuples are
2235 * not far each from other than \a prec, only one of them remains in the result
2236 * array. The order of tuples in the result array is same as in \a this one except
2237 * that coincident tuples are excluded.
2238 * \param [in] prec - minimal absolute distance between two tuples at which they are
2239 * considered not coincident.
2240 * \param [in] limitTupleId - limit tuple id. If all tuples within a group of coincident
2241 * tuples have id strictly lower than \a limitTupleId then they are not excluded.
2242 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
2243 * is to delete using decrRef() as it is no more needed.
2244 * \throw If \a this is not allocated.
2245 * \throw If the number of components is not in [1,2,3,4].
2247 * \if ENABLE_EXAMPLES
2248 * \ref py_mcdataarraydouble_getdifferentvalues "Here is a Python example".
2251 DataArrayDouble *DataArrayDouble::getDifferentValues(double prec, int limitTupleId) const
2254 DataArrayInt *c0=0,*cI0=0;
2255 findCommonTuples(prec,limitTupleId,c0,cI0);
2256 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> c(c0),cI(cI0);
2257 int newNbOfTuples=-1;
2258 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> o2n=DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(getNumberOfTuples(),c0->begin(),cI0->begin(),cI0->end(),newNbOfTuples);
2259 return renumberAndReduce(o2n->getConstPointer(),newNbOfTuples);
2263 * Copy all components in a specified order from another DataArrayDouble.
2264 * Both numerical and textual data is copied. The number of tuples in \a this and
2265 * the other array can be different.
2266 * \param [in] a - the array to copy data from.
2267 * \param [in] compoIds - sequence of zero based indices of components, data of which is
2269 * \throw If \a a is NULL.
2270 * \throw If \a compoIds.size() != \a a->getNumberOfComponents().
2271 * \throw If \a compoIds[i] < 0 or \a compoIds[i] > \a this->getNumberOfComponents().
2273 * \if ENABLE_EXAMPLES
2274 * \ref py_mcdataarraydouble_setselectedcomponents "Here is a Python example".
2277 void DataArrayDouble::setSelectedComponents(const DataArrayDouble *a, const std::vector<int>& compoIds)
2280 throw INTERP_KERNEL::Exception("DataArrayDouble::setSelectedComponents : input DataArrayDouble is NULL !");
2282 copyPartOfStringInfoFrom2(compoIds,*a);
2283 std::size_t partOfCompoSz=compoIds.size();
2284 int nbOfCompo=getNumberOfComponents();
2285 int nbOfTuples=std::min(getNumberOfTuples(),a->getNumberOfTuples());
2286 const double *ac=a->getConstPointer();
2287 double *nc=getPointer();
2288 for(int i=0;i<nbOfTuples;i++)
2289 for(std::size_t j=0;j<partOfCompoSz;j++,ac++)
2290 nc[nbOfCompo*i+compoIds[j]]=*ac;
2294 * Copy all values from another DataArrayDouble into specified tuples and components
2295 * of \a this array. Textual data is not copied.
2296 * The tree parameters defining set of indices of tuples and components are similar to
2297 * the tree parameters of the Python function \c range(\c start,\c stop,\c step).
2298 * \param [in] a - the array to copy values from.
2299 * \param [in] bgTuples - index of the first tuple of \a this array to assign values to.
2300 * \param [in] endTuples - index of the tuple before which the tuples to assign to
2302 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
2303 * \param [in] bgComp - index of the first component of \a this array to assign values to.
2304 * \param [in] endComp - index of the component before which the components to assign
2306 * \param [in] stepComp - index increment to get index of the next component to assign to.
2307 * \param [in] strictCompoCompare - if \a true (by default), then \a a->getNumberOfComponents()
2308 * must be equal to the number of columns to assign to, else an
2309 * exception is thrown; if \a false, then it is only required that \a
2310 * a->getNbOfElems() equals to number of values to assign to (this condition
2311 * must be respected even if \a strictCompoCompare is \a true). The number of
2312 * values to assign to is given by following Python expression:
2313 * \a nbTargetValues =
2314 * \c len(\c range(\a bgTuples,\a endTuples,\a stepTuples)) *
2315 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2316 * \throw If \a a is NULL.
2317 * \throw If \a a is not allocated.
2318 * \throw If \a this is not allocated.
2319 * \throw If parameters specifying tuples and components to assign to do not give a
2320 * non-empty range of increasing indices.
2321 * \throw If \a a->getNbOfElems() != \a nbTargetValues.
2322 * \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
2323 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2325 * \if ENABLE_EXAMPLES
2326 * \ref py_mcdataarraydouble_setpartofvalues1 "Here is a Python example".
2329 void DataArrayDouble::setPartOfValues1(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
2332 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues1 : input DataArrayDouble is NULL !");
2333 const char msg[]="DataArrayDouble::setPartOfValues1";
2335 a->checkAllocated();
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 bool assignTech=true;
2343 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2345 if(strictCompoCompare)
2346 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2350 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2353 const double *srcPt=a->getConstPointer();
2354 double *pt=getPointer()+bgTuples*nbComp+bgComp;
2357 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2358 for(int j=0;j<newNbOfComp;j++,srcPt++)
2359 pt[j*stepComp]=*srcPt;
2363 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2365 const double *srcPt2=srcPt;
2366 for(int j=0;j<newNbOfComp;j++,srcPt2++)
2367 pt[j*stepComp]=*srcPt2;
2373 * Assign a given value to values at specified tuples and components of \a this array.
2374 * The tree parameters defining set of indices of tuples and components are similar to
2375 * the tree parameters of the Python function \c range(\c start,\c stop,\c step)..
2376 * \param [in] a - the value to assign.
2377 * \param [in] bgTuples - index of the first tuple of \a this array to assign to.
2378 * \param [in] endTuples - index of the tuple before which the tuples to assign to
2380 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
2381 * \param [in] bgComp - index of the first component of \a this array to assign to.
2382 * \param [in] endComp - index of the component before which the components to assign
2384 * \param [in] stepComp - index increment to get index of the next component to assign to.
2385 * \throw If \a this is not allocated.
2386 * \throw If parameters specifying tuples and components to assign to, do not give a
2387 * non-empty range of increasing indices or indices are out of a valid range
2390 * \if ENABLE_EXAMPLES
2391 * \ref py_mcdataarraydouble_setpartofvaluessimple1 "Here is a Python example".
2394 void DataArrayDouble::setPartOfValuesSimple1(double a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp)
2396 const char msg[]="DataArrayDouble::setPartOfValuesSimple1";
2398 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2399 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2400 int nbComp=getNumberOfComponents();
2401 int nbOfTuples=getNumberOfTuples();
2402 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2403 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2404 double *pt=getPointer()+bgTuples*nbComp+bgComp;
2405 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2406 for(int j=0;j<newNbOfComp;j++)
2411 * Copy all values from another DataArrayDouble (\a a) into specified tuples and
2412 * components of \a this array. Textual data is not copied.
2413 * The tuples and components to assign to are defined by C arrays of indices.
2414 * There are two *modes of usage*:
2415 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
2416 * of \a a is assigned to its own location within \a this array.
2417 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
2418 * components of every specified tuple of \a this array. In this mode it is required
2419 * that \a a->getNumberOfComponents() equals to the number of specified components.
2421 * \param [in] a - the array to copy values from.
2422 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2423 * assign values of \a a to.
2424 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2425 * pointer to a tuple index <em>(pi)</em> varies as this:
2426 * \a bgTuples <= \a pi < \a endTuples.
2427 * \param [in] bgComp - pointer to an array of component indices of \a this array to
2428 * assign values of \a a to.
2429 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
2430 * pointer to a component index <em>(pi)</em> varies as this:
2431 * \a bgComp <= \a pi < \a endComp.
2432 * \param [in] strictCompoCompare - this parameter is checked only if the
2433 * *mode of usage* is the first; if it is \a true (default),
2434 * then \a a->getNumberOfComponents() must be equal
2435 * to the number of specified columns, else this is not required.
2436 * \throw If \a a is NULL.
2437 * \throw If \a a is not allocated.
2438 * \throw If \a this is not allocated.
2439 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
2440 * out of a valid range for \a this array.
2441 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
2442 * if <em> a->getNumberOfComponents() != (endComp - bgComp) </em>.
2443 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
2444 * <em> a->getNumberOfComponents() != (endComp - bgComp)</em>.
2446 * \if ENABLE_EXAMPLES
2447 * \ref py_mcdataarraydouble_setpartofvalues2 "Here is a Python example".
2450 void DataArrayDouble::setPartOfValues2(const DataArrayDouble *a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
2453 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues2 : input DataArrayDouble is NULL !");
2454 const char msg[]="DataArrayDouble::setPartOfValues2";
2456 a->checkAllocated();
2457 int nbComp=getNumberOfComponents();
2458 int nbOfTuples=getNumberOfTuples();
2459 for(const int *z=bgComp;z!=endComp;z++)
2460 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2461 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
2462 int newNbOfComp=(int)std::distance(bgComp,endComp);
2463 bool assignTech=true;
2464 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2466 if(strictCompoCompare)
2467 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2471 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2474 double *pt=getPointer();
2475 const double *srcPt=a->getConstPointer();
2478 for(const int *w=bgTuples;w!=endTuples;w++)
2480 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2481 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
2483 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt;
2489 for(const int *w=bgTuples;w!=endTuples;w++)
2491 const double *srcPt2=srcPt;
2492 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2493 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
2495 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt2;
2502 * Assign a given value to values at specified tuples and components of \a this array.
2503 * The tuples and components to assign to are defined by C arrays of indices.
2504 * \param [in] a - the value to assign.
2505 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2507 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2508 * pointer to a tuple index (\a pi) varies as this:
2509 * \a bgTuples <= \a pi < \a endTuples.
2510 * \param [in] bgComp - pointer to an array of component indices of \a this array to
2512 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
2513 * pointer to a component index (\a pi) varies as this:
2514 * \a bgComp <= \a pi < \a endComp.
2515 * \throw If \a this is not allocated.
2516 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
2517 * out of a valid range for \a this array.
2519 * \if ENABLE_EXAMPLES
2520 * \ref py_mcdataarraydouble_setpartofvaluessimple2 "Here is a Python example".
2523 void DataArrayDouble::setPartOfValuesSimple2(double a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp)
2526 int nbComp=getNumberOfComponents();
2527 int nbOfTuples=getNumberOfTuples();
2528 for(const int *z=bgComp;z!=endComp;z++)
2529 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2530 double *pt=getPointer();
2531 for(const int *w=bgTuples;w!=endTuples;w++)
2532 for(const int *z=bgComp;z!=endComp;z++)
2534 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2535 pt[(std::size_t)(*w)*nbComp+(*z)]=a;
2540 * Copy all values from another DataArrayDouble (\a a) into specified tuples and
2541 * components of \a this array. Textual data is not copied.
2542 * The tuples to assign to are defined by a C array of indices.
2543 * The components to assign to are defined by three values similar to parameters of
2544 * the Python function \c range(\c start,\c stop,\c step).
2545 * There are two *modes of usage*:
2546 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
2547 * of \a a is assigned to its own location within \a this array.
2548 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
2549 * components of every specified tuple of \a this array. In this mode it is required
2550 * that \a a->getNumberOfComponents() equals to the number of specified components.
2552 * \param [in] a - the array to copy values from.
2553 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2554 * assign values of \a a to.
2555 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2556 * pointer to a tuple index <em>(pi)</em> varies as this:
2557 * \a bgTuples <= \a pi < \a endTuples.
2558 * \param [in] bgComp - index of the first component of \a this array to assign to.
2559 * \param [in] endComp - index of the component before which the components to assign
2561 * \param [in] stepComp - index increment to get index of the next component to assign to.
2562 * \param [in] strictCompoCompare - this parameter is checked only in the first
2563 * *mode of usage*; if \a strictCompoCompare is \a true (default),
2564 * then \a a->getNumberOfComponents() must be equal
2565 * to the number of specified columns, else this is not required.
2566 * \throw If \a a is NULL.
2567 * \throw If \a a is not allocated.
2568 * \throw If \a this is not allocated.
2569 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
2571 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
2572 * if <em> a->getNumberOfComponents()</em> is unequal to the number of components
2573 * defined by <em>(bgComp,endComp,stepComp)</em>.
2574 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
2575 * <em> a->getNumberOfComponents()</em> is unequal to the number of components
2576 * defined by <em>(bgComp,endComp,stepComp)</em>.
2577 * \throw If parameters specifying components to assign to, do not give a
2578 * non-empty range of increasing indices or indices are out of a valid range
2581 * \if ENABLE_EXAMPLES
2582 * \ref py_mcdataarraydouble_setpartofvalues3 "Here is a Python example".
2585 void DataArrayDouble::setPartOfValues3(const DataArrayDouble *a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
2588 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues3 : input DataArrayDouble is NULL !");
2589 const char msg[]="DataArrayDouble::setPartOfValues3";
2591 a->checkAllocated();
2592 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2593 int nbComp=getNumberOfComponents();
2594 int nbOfTuples=getNumberOfTuples();
2595 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2596 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
2597 bool assignTech=true;
2598 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2600 if(strictCompoCompare)
2601 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2605 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2608 double *pt=getPointer()+bgComp;
2609 const double *srcPt=a->getConstPointer();
2612 for(const int *w=bgTuples;w!=endTuples;w++)
2613 for(int j=0;j<newNbOfComp;j++,srcPt++)
2615 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2616 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt;
2621 for(const int *w=bgTuples;w!=endTuples;w++)
2623 const double *srcPt2=srcPt;
2624 for(int j=0;j<newNbOfComp;j++,srcPt2++)
2626 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2627 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt2;
2634 * Assign a given value to values at specified tuples and components of \a this array.
2635 * The tuples to assign to are defined by a C array of indices.
2636 * The components to assign to are defined by three values similar to parameters of
2637 * the Python function \c range(\c start,\c stop,\c step).
2638 * \param [in] a - the value to assign.
2639 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2641 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2642 * pointer to a tuple index <em>(pi)</em> varies as this:
2643 * \a bgTuples <= \a pi < \a endTuples.
2644 * \param [in] bgComp - index of the first component of \a this array to assign to.
2645 * \param [in] endComp - index of the component before which the components to assign
2647 * \param [in] stepComp - index increment to get index of the next component to assign to.
2648 * \throw If \a this is not allocated.
2649 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
2651 * \throw If parameters specifying components to assign to, do not give a
2652 * non-empty range of increasing indices or indices are out of a valid range
2655 * \if ENABLE_EXAMPLES
2656 * \ref py_mcdataarraydouble_setpartofvaluessimple3 "Here is a Python example".
2659 void DataArrayDouble::setPartOfValuesSimple3(double a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp)
2661 const char msg[]="DataArrayDouble::setPartOfValuesSimple3";
2663 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2664 int nbComp=getNumberOfComponents();
2665 int nbOfTuples=getNumberOfTuples();
2666 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2667 double *pt=getPointer()+bgComp;
2668 for(const int *w=bgTuples;w!=endTuples;w++)
2669 for(int j=0;j<newNbOfComp;j++)
2671 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2672 pt[(std::size_t)(*w)*nbComp+j*stepComp]=a;
2677 * Copy all values from another DataArrayDouble into specified tuples and components
2678 * of \a this array. Textual data is not copied.
2679 * The tree parameters defining set of indices of tuples and components are similar to
2680 * the tree parameters of the Python function \c range(\c start,\c stop,\c step).
2681 * \param [in] a - the array to copy values from.
2682 * \param [in] bgTuples - index of the first tuple of \a this array to assign values to.
2683 * \param [in] endTuples - index of the tuple before which the tuples to assign to
2685 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
2686 * \param [in] bgComp - pointer to an array of component indices of \a this array to
2688 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
2689 * pointer to a component index (\a pi) varies as this:
2690 * \a bgComp <= \a pi < \a endComp.
2691 * \param [in] strictCompoCompare - if \a true (by default), then \a a->getNumberOfComponents()
2692 * must be equal to the number of columns to assign to, else an
2693 * exception is thrown; if \a false, then it is only required that \a
2694 * a->getNbOfElems() equals to number of values to assign to (this condition
2695 * must be respected even if \a strictCompoCompare is \a true). The number of
2696 * values to assign to is given by following Python expression:
2697 * \a nbTargetValues =
2698 * \c len(\c range(\a bgTuples,\a endTuples,\a stepTuples)) *
2699 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2700 * \throw If \a a is NULL.
2701 * \throw If \a a is not allocated.
2702 * \throw If \a this is not allocated.
2703 * \throw If parameters specifying tuples and components to assign to do not give a
2704 * non-empty range of increasing indices.
2705 * \throw If \a a->getNbOfElems() != \a nbTargetValues.
2706 * \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
2707 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2710 void DataArrayDouble::setPartOfValues4(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
2713 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues4 : input DataArrayDouble is NULL !");
2714 const char msg[]="DataArrayDouble::setPartOfValues4";
2716 a->checkAllocated();
2717 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2718 int newNbOfComp=(int)std::distance(bgComp,endComp);
2719 int nbComp=getNumberOfComponents();
2720 for(const int *z=bgComp;z!=endComp;z++)
2721 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2722 int nbOfTuples=getNumberOfTuples();
2723 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2724 bool assignTech=true;
2725 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2727 if(strictCompoCompare)
2728 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2732 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2735 const double *srcPt=a->getConstPointer();
2736 double *pt=getPointer()+bgTuples*nbComp;
2739 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2740 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
2745 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2747 const double *srcPt2=srcPt;
2748 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
2754 void DataArrayDouble::setPartOfValuesSimple4(double a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp)
2756 const char msg[]="DataArrayDouble::setPartOfValuesSimple4";
2758 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2759 int nbComp=getNumberOfComponents();
2760 for(const int *z=bgComp;z!=endComp;z++)
2761 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2762 int nbOfTuples=getNumberOfTuples();
2763 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2764 double *pt=getPointer()+bgTuples*nbComp;
2765 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2766 for(const int *z=bgComp;z!=endComp;z++)
2771 * Copy some tuples from another DataArrayDouble into specified tuples
2772 * of \a this array. Textual data is not copied. Both arrays must have equal number of
2774 * Both the tuples to assign and the tuples to assign to are defined by a DataArrayInt.
2775 * All components of selected tuples are copied.
2776 * \param [in] a - the array to copy values from.
2777 * \param [in] tuplesSelec - the array specifying both source tuples of \a a and
2778 * target tuples of \a this. \a tuplesSelec has two components, and the
2779 * first component specifies index of the source tuple and the second
2780 * one specifies index of the target tuple.
2781 * \throw If \a this is not allocated.
2782 * \throw If \a a is NULL.
2783 * \throw If \a a is not allocated.
2784 * \throw If \a tuplesSelec is NULL.
2785 * \throw If \a tuplesSelec is not allocated.
2786 * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
2787 * \throw If \a tuplesSelec->getNumberOfComponents() != 2.
2788 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
2789 * the corresponding (\a this or \a a) array.
2791 void DataArrayDouble::setPartOfValuesAdv(const DataArrayDouble *a, const DataArrayInt *tuplesSelec)
2793 if(!a || !tuplesSelec)
2794 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValuesAdv : input DataArrayDouble is NULL !");
2796 a->checkAllocated();
2797 tuplesSelec->checkAllocated();
2798 int nbOfComp=getNumberOfComponents();
2799 if(nbOfComp!=a->getNumberOfComponents())
2800 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValuesAdv : This and a do not have the same number of components !");
2801 if(tuplesSelec->getNumberOfComponents()!=2)
2802 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValuesAdv : Expecting to have a tuple selector DataArrayInt instance with exactly 2 components !");
2803 int thisNt=getNumberOfTuples();
2804 int aNt=a->getNumberOfTuples();
2805 double *valsToSet=getPointer();
2806 const double *valsSrc=a->getConstPointer();
2807 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple+=2)
2809 if(tuple[1]>=0 && tuple[1]<aNt)
2811 if(tuple[0]>=0 && tuple[0]<thisNt)
2812 std::copy(valsSrc+nbOfComp*tuple[1],valsSrc+nbOfComp*(tuple[1]+1),valsToSet+nbOfComp*tuple[0]);
2815 std::ostringstream oss; oss << "DataArrayDouble::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
2816 oss << " of 'tuplesSelec' request of tuple id #" << tuple[0] << " in 'this' ! It should be in [0," << thisNt << ") !";
2817 throw INTERP_KERNEL::Exception(oss.str().c_str());
2822 std::ostringstream oss; oss << "DataArrayDouble::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
2823 oss << " of 'tuplesSelec' request of tuple id #" << tuple[1] << " in 'a' ! It should be in [0," << aNt << ") !";
2824 throw INTERP_KERNEL::Exception(oss.str().c_str());
2830 * Copy some tuples from another DataArrayDouble (\a aBase) into contiguous tuples
2831 * of \a this array. Textual data is not copied. Both arrays must have equal number of
2833 * The tuples to assign to are defined by index of the first tuple, and
2834 * their number is defined by \a tuplesSelec->getNumberOfTuples().
2835 * The tuples to copy are defined by values of a DataArrayInt.
2836 * All components of selected tuples are copied.
2837 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
2839 * \param [in] aBase - the array to copy values from.
2840 * \param [in] tuplesSelec - the array specifying tuples of \a a to copy.
2841 * \throw If \a this is not allocated.
2842 * \throw If \a aBase is NULL.
2843 * \throw If \a aBase is not allocated.
2844 * \throw If \a tuplesSelec is NULL.
2845 * \throw If \a tuplesSelec is not allocated.
2846 * \throw If <em>this->getNumberOfComponents() != aBase->getNumberOfComponents()</em>.
2847 * \throw If \a tuplesSelec->getNumberOfComponents() != 1.
2848 * \throw If <em>tupleIdStart + tuplesSelec->getNumberOfTuples() > this->getNumberOfTuples().</em>
2849 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
2852 void DataArrayDouble::setContigPartOfSelectedValues(int tupleIdStart, const DataArray *aBase, const DataArrayInt *tuplesSelec)
2854 if(!aBase || !tuplesSelec)
2855 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : input DataArray is NULL !");
2856 const DataArrayDouble *a=dynamic_cast<const DataArrayDouble *>(aBase);
2858 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : input DataArray aBase is not a DataArrayDouble !");
2860 a->checkAllocated();
2861 tuplesSelec->checkAllocated();
2862 int nbOfComp=getNumberOfComponents();
2863 if(nbOfComp!=a->getNumberOfComponents())
2864 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : This and a do not have the same number of components !");
2865 if(tuplesSelec->getNumberOfComponents()!=1)
2866 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : Expecting to have a tuple selector DataArrayInt instance with exactly 1 component !");
2867 int thisNt=getNumberOfTuples();
2868 int aNt=a->getNumberOfTuples();
2869 int nbOfTupleToWrite=tuplesSelec->getNumberOfTuples();
2870 double *valsToSet=getPointer()+tupleIdStart*nbOfComp;
2871 if(tupleIdStart+nbOfTupleToWrite>thisNt)
2872 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : invalid number range of values to write !");
2873 const double *valsSrc=a->getConstPointer();
2874 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple++,valsToSet+=nbOfComp)
2876 if(*tuple>=0 && *tuple<aNt)
2878 std::copy(valsSrc+nbOfComp*(*tuple),valsSrc+nbOfComp*(*tuple+1),valsToSet);
2882 std::ostringstream oss; oss << "DataArrayDouble::setContigPartOfSelectedValues : Tuple #" << std::distance(tuplesSelec->begin(),tuple);
2883 oss << " of 'tuplesSelec' request of tuple id #" << *tuple << " in 'a' ! It should be in [0," << aNt << ") !";
2884 throw INTERP_KERNEL::Exception(oss.str().c_str());
2890 * Copy some tuples from another DataArrayDouble (\a aBase) into contiguous tuples
2891 * of \a this array. Textual data is not copied. Both arrays must have equal number of
2893 * The tuples to copy are defined by three values similar to parameters of
2894 * the Python function \c range(\c start,\c stop,\c step).
2895 * The tuples to assign to are defined by index of the first tuple, and
2896 * their number is defined by number of tuples to copy.
2897 * All components of selected tuples are copied.
2898 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
2900 * \param [in] aBase - the array to copy values from.
2901 * \param [in] bg - index of the first tuple to copy of the array \a aBase.
2902 * \param [in] end2 - index of the tuple of \a aBase before which the tuples to copy
2904 * \param [in] step - index increment to get index of the next tuple to copy.
2905 * \throw If \a this is not allocated.
2906 * \throw If \a aBase is NULL.
2907 * \throw If \a aBase is not allocated.
2908 * \throw If <em>this->getNumberOfComponents() != aBase->getNumberOfComponents()</em>.
2909 * \throw If <em>tupleIdStart + len(range(bg,end2,step)) > this->getNumberOfTuples().</em>
2910 * \throw If parameters specifying tuples to copy, do not give a
2911 * non-empty range of increasing indices or indices are out of a valid range
2912 * for the array \a aBase.
2914 void DataArrayDouble::setContigPartOfSelectedValues2(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step)
2917 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : input DataArray is NULL !");
2918 const DataArrayDouble *a=dynamic_cast<const DataArrayDouble *>(aBase);
2920 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : input DataArray aBase is not a DataArrayDouble !");
2922 a->checkAllocated();
2923 int nbOfComp=getNumberOfComponents();
2924 const char msg[]="DataArrayDouble::setContigPartOfSelectedValues2";
2925 int nbOfTupleToWrite=DataArray::GetNumberOfItemGivenBES(bg,end2,step,msg);
2926 if(nbOfComp!=a->getNumberOfComponents())
2927 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : This and a do not have the same number of components !");
2928 int thisNt=getNumberOfTuples();
2929 int aNt=a->getNumberOfTuples();
2930 double *valsToSet=getPointer()+tupleIdStart*nbOfComp;
2931 if(tupleIdStart+nbOfTupleToWrite>thisNt)
2932 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : invalid number range of values to write !");
2934 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : invalid range of values to read !");
2935 const double *valsSrc=a->getConstPointer()+bg*nbOfComp;
2936 for(int i=0;i<nbOfTupleToWrite;i++,valsToSet+=nbOfComp,valsSrc+=step*nbOfComp)
2938 std::copy(valsSrc,valsSrc+nbOfComp,valsToSet);
2943 * Returns a value located at specified tuple and component.
2944 * This method is equivalent to DataArrayDouble::getIJ() except that validity of
2945 * parameters is checked. So this method is safe but expensive if used to go through
2946 * all values of \a this.
2947 * \param [in] tupleId - index of tuple of interest.
2948 * \param [in] compoId - index of component of interest.
2949 * \return double - value located by \a tupleId and \a compoId.
2950 * \throw If \a this is not allocated.
2951 * \throw If condition <em>( 0 <= tupleId < this->getNumberOfTuples() )</em> is violated.
2952 * \throw If condition <em>( 0 <= compoId < this->getNumberOfComponents() )</em> is violated.
2954 double DataArrayDouble::getIJSafe(int tupleId, int compoId) const
2957 if(tupleId<0 || tupleId>=getNumberOfTuples())
2959 std::ostringstream oss; oss << "DataArrayDouble::getIJSafe : request for tupleId " << tupleId << " should be in [0," << getNumberOfTuples() << ") !";
2960 throw INTERP_KERNEL::Exception(oss.str().c_str());
2962 if(compoId<0 || compoId>=getNumberOfComponents())
2964 std::ostringstream oss; oss << "DataArrayDouble::getIJSafe : request for compoId " << compoId << " should be in [0," << getNumberOfComponents() << ") !";
2965 throw INTERP_KERNEL::Exception(oss.str().c_str());
2967 return _mem[tupleId*_info_on_compo.size()+compoId];
2971 * Returns the first value of \a this.
2972 * \return double - the last value of \a this array.
2973 * \throw If \a this is not allocated.
2974 * \throw If \a this->getNumberOfComponents() != 1.
2975 * \throw If \a this->getNumberOfTuples() < 1.
2977 double DataArrayDouble::front() const
2980 if(getNumberOfComponents()!=1)
2981 throw INTERP_KERNEL::Exception("DataArrayDouble::front : number of components not equal to one !");
2982 int nbOfTuples=getNumberOfTuples();
2984 throw INTERP_KERNEL::Exception("DataArrayDouble::front : number of tuples must be >= 1 !");
2985 return *(getConstPointer());
2989 * Returns the last value of \a this.
2990 * \return double - the last value of \a this array.
2991 * \throw If \a this is not allocated.
2992 * \throw If \a this->getNumberOfComponents() != 1.
2993 * \throw If \a this->getNumberOfTuples() < 1.
2995 double DataArrayDouble::back() const
2998 if(getNumberOfComponents()!=1)
2999 throw INTERP_KERNEL::Exception("DataArrayDouble::back : number of components not equal to one !");
3000 int nbOfTuples=getNumberOfTuples();
3002 throw INTERP_KERNEL::Exception("DataArrayDouble::back : number of tuples must be >= 1 !");
3003 return *(getConstPointer()+nbOfTuples-1);
3006 void DataArrayDouble::SetArrayIn(DataArrayDouble *newArray, DataArrayDouble* &arrayToSet)
3008 if(newArray!=arrayToSet)
3011 arrayToSet->decrRef();
3012 arrayToSet=newArray;
3014 arrayToSet->incrRef();
3019 * Sets a C array to be used as raw data of \a this. The previously set info
3020 * of components is retained and re-sized.
3021 * For more info see \ref MEDCouplingArraySteps1.
3022 * \param [in] array - the C array to be used as raw data of \a this.
3023 * \param [in] ownership - if \a true, \a array will be deallocated at destruction of \a this.
3024 * \param [in] type - specifies how to deallocate \a array. If \a type == ParaMEDMEM::CPP_DEALLOC,
3025 * \c delete [] \c array; will be called. If \a type == ParaMEDMEM::C_DEALLOC,
3026 * \c free(\c array ) will be called.
3027 * \param [in] nbOfTuple - new number of tuples in \a this.
3028 * \param [in] nbOfCompo - new number of components in \a this.
3030 void DataArrayDouble::useArray(const double *array, bool ownership, DeallocType type, int nbOfTuple, int nbOfCompo)
3032 _info_on_compo.resize(nbOfCompo);
3033 _mem.useArray(array,ownership,type,(std::size_t)nbOfTuple*nbOfCompo);
3037 void DataArrayDouble::useExternalArrayWithRWAccess(const double *array, int nbOfTuple, int nbOfCompo)
3039 _info_on_compo.resize(nbOfCompo);
3040 _mem.useExternalArrayWithRWAccess(array,(std::size_t)nbOfTuple*nbOfCompo);
3045 * Checks if 0.0 value is present in \a this array. If it is the case, an exception
3047 * \throw If zero is found in \a this array.
3049 void DataArrayDouble::checkNoNullValues() const
3051 const double *tmp=getConstPointer();
3052 std::size_t nbOfElems=getNbOfElems();
3053 const double *where=std::find(tmp,tmp+nbOfElems,0.);
3054 if(where!=tmp+nbOfElems)
3055 throw INTERP_KERNEL::Exception("A value 0.0 have been detected !");
3059 * Computes minimal and maximal value in each component. An output array is filled
3060 * with \c 2 * \a this->getNumberOfComponents() values, so the caller is to allocate
3061 * enough memory before calling this method.
3062 * \param [out] bounds - array of size at least 2 *\a this->getNumberOfComponents().
3063 * It is filled as follows:<br>
3064 * \a bounds[0] = \c min_of_component_0 <br>
3065 * \a bounds[1] = \c max_of_component_0 <br>
3066 * \a bounds[2] = \c min_of_component_1 <br>
3067 * \a bounds[3] = \c max_of_component_1 <br>
3070 void DataArrayDouble::getMinMaxPerComponent(double *bounds) const
3073 int dim=getNumberOfComponents();
3074 for (int idim=0; idim<dim; idim++)
3076 bounds[idim*2]=std::numeric_limits<double>::max();
3077 bounds[idim*2+1]=-std::numeric_limits<double>::max();
3079 const double *ptr=getConstPointer();
3080 int nbOfTuples=getNumberOfTuples();
3081 for(int i=0;i<nbOfTuples;i++)
3083 for(int idim=0;idim<dim;idim++)
3085 if(bounds[idim*2]>ptr[i*dim+idim])
3087 bounds[idim*2]=ptr[i*dim+idim];
3089 if(bounds[idim*2+1]<ptr[i*dim+idim])
3091 bounds[idim*2+1]=ptr[i*dim+idim];
3098 * This method retrieves a newly allocated DataArrayDouble instance having same number of tuples than \a this and twice number of components than \a this
3099 * to store both the min and max per component of each tuples.
3100 * \param [in] epsilon the width of the bbox (identical in each direction) - 0.0 by default
3102 * \return a newly created DataArrayDouble instance having \c this->getNumberOfTuples() tuples and 2 * \c this->getNumberOfComponent() components
3104 * \throw If \a this is not allocated yet.
3106 DataArrayDouble *DataArrayDouble::computeBBoxPerTuple(double epsilon) const
3109 const double *dataPtr=getConstPointer();
3110 int nbOfCompo=getNumberOfComponents();
3111 int nbTuples=getNumberOfTuples();
3112 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> bbox=DataArrayDouble::New();
3113 bbox->alloc(nbTuples,2*nbOfCompo);
3114 double *bboxPtr=bbox->getPointer();
3115 for(int i=0;i<nbTuples;i++)
3117 for(int j=0;j<nbOfCompo;j++)
3119 bboxPtr[2*nbOfCompo*i+2*j]=dataPtr[nbOfCompo*i+j]-epsilon;
3120 bboxPtr[2*nbOfCompo*i+2*j+1]=dataPtr[nbOfCompo*i+j]+epsilon;
3127 * For each tuples **t** in \a other, this method retrieves tuples in \a this that are equal to **t**.
3128 * Two tuples are considered equal if the euclidian distance between the two tuples is lower than \a eps.
3130 * \param [in] other a DataArrayDouble having same number of components than \a this.
3131 * \param [in] eps absolute precision representing distance (using infinite norm) between 2 tuples behind which 2 tuples are considered equal.
3132 * \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.
3133 * \a cI allows to extract information in \a c.
3134 * \param [out] cI is an indirection array that allows to extract the data contained in \a c.
3136 * \throw In case of:
3137 * - \a this is not allocated
3138 * - \a other is not allocated or null
3139 * - \a this and \a other do not have the same number of components
3140 * - if number of components of \a this is not in [1,2,3]
3142 * \sa MEDCouplingPointSet::getNodeIdsNearPoints, DataArrayDouble::getDifferentValues
3144 void DataArrayDouble::computeTupleIdsNearTuples(const DataArrayDouble *other, double eps, DataArrayInt *& c, DataArrayInt *& cI) const
3147 throw INTERP_KERNEL::Exception("DataArrayDouble::computeTupleIdsNearTuples : input pointer other is null !");
3149 other->checkAllocated();
3150 int nbOfCompo=getNumberOfComponents();
3151 int otherNbOfCompo=other->getNumberOfComponents();
3152 if(nbOfCompo!=otherNbOfCompo)
3153 throw INTERP_KERNEL::Exception("DataArrayDouble::computeTupleIdsNearTuples : number of components should be equal between this and other !");
3154 int nbOfTuplesOther=other->getNumberOfTuples();
3155 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cArr(DataArrayInt::New()),cIArr(DataArrayInt::New()); cArr->alloc(0,1); cIArr->pushBackSilent(0);
3160 BBTreePts<3,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
3161 FindTupleIdsNearTuplesAlg<3>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
3166 BBTreePts<2,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
3167 FindTupleIdsNearTuplesAlg<2>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
3172 BBTreePts<1,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
3173 FindTupleIdsNearTuplesAlg<1>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
3177 throw INTERP_KERNEL::Exception("Unexpected spacedim of coords for computeTupleIdsNearTuples. Must be 1, 2 or 3.");
3179 c=cArr.retn(); cI=cIArr.retn();
3183 * 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
3184 * around origin of 'radius' 1.
3186 * \param [in] eps absolute epsilon. under that value of delta between max and min no scale is performed.
3188 void DataArrayDouble::recenterForMaxPrecision(double eps)
3191 int dim=getNumberOfComponents();
3192 std::vector<double> bounds(2*dim);
3193 getMinMaxPerComponent(&bounds[0]);
3194 for(int i=0;i<dim;i++)
3196 double delta=bounds[2*i+1]-bounds[2*i];
3197 double offset=(bounds[2*i]+bounds[2*i+1])/2.;
3199 applyLin(1./delta,-offset/delta,i);
3201 applyLin(1.,-offset,i);
3206 * Returns the maximal value and its location within \a this one-dimensional array.
3207 * \param [out] tupleId - index of the tuple holding the maximal value.
3208 * \return double - the maximal value among all values of \a this array.
3209 * \throw If \a this->getNumberOfComponents() != 1
3210 * \throw If \a this->getNumberOfTuples() < 1
3212 double DataArrayDouble::getMaxValue(int& tupleId) const
3215 if(getNumberOfComponents()!=1)
3216 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 !");
3217 int nbOfTuples=getNumberOfTuples();
3219 throw INTERP_KERNEL::Exception("DataArrayDouble::getMaxValue : array exists but number of tuples must be > 0 !");
3220 const double *vals=getConstPointer();
3221 const double *loc=std::max_element(vals,vals+nbOfTuples);
3222 tupleId=(int)std::distance(vals,loc);
3227 * Returns the maximal value within \a this array that is allowed to have more than
3229 * \return double - the maximal value among all values of \a this array.
3230 * \throw If \a this is not allocated.
3232 double DataArrayDouble::getMaxValueInArray() const
3235 const double *loc=std::max_element(begin(),end());
3240 * Returns the maximal value and all its locations within \a this one-dimensional array.
3241 * \param [out] tupleIds - a new instance of DataArrayInt containg indices of
3242 * tuples holding the maximal value. The caller is to delete it using
3243 * decrRef() as it is no more needed.
3244 * \return double - the maximal value among all values of \a this array.
3245 * \throw If \a this->getNumberOfComponents() != 1
3246 * \throw If \a this->getNumberOfTuples() < 1
3248 double DataArrayDouble::getMaxValue2(DataArrayInt*& tupleIds) const
3252 double ret=getMaxValue(tmp);
3253 tupleIds=getIdsInRange(ret,ret);
3258 * Returns the minimal value and its location within \a this one-dimensional array.
3259 * \param [out] tupleId - index of the tuple holding the minimal value.
3260 * \return double - the minimal value among all values of \a this array.
3261 * \throw If \a this->getNumberOfComponents() != 1
3262 * \throw If \a this->getNumberOfTuples() < 1
3264 double DataArrayDouble::getMinValue(int& tupleId) const
3267 if(getNumberOfComponents()!=1)
3268 throw INTERP_KERNEL::Exception("DataArrayDouble::getMinValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before call 'getMinValueInArray' method !");
3269 int nbOfTuples=getNumberOfTuples();
3271 throw INTERP_KERNEL::Exception("DataArrayDouble::getMinValue : array exists but number of tuples must be > 0 !");
3272 const double *vals=getConstPointer();
3273 const double *loc=std::min_element(vals,vals+nbOfTuples);
3274 tupleId=(int)std::distance(vals,loc);
3279 * Returns the minimal value within \a this array that is allowed to have more than
3281 * \return double - the minimal value among all values of \a this array.
3282 * \throw If \a this is not allocated.
3284 double DataArrayDouble::getMinValueInArray() const
3287 const double *loc=std::min_element(begin(),end());
3292 * Returns the minimal value and all its locations within \a this one-dimensional array.
3293 * \param [out] tupleIds - a new instance of DataArrayInt containg indices of
3294 * tuples holding the minimal value. The caller is to delete it using
3295 * decrRef() as it is no more needed.
3296 * \return double - the minimal value among all values of \a this array.
3297 * \throw If \a this->getNumberOfComponents() != 1
3298 * \throw If \a this->getNumberOfTuples() < 1
3300 double DataArrayDouble::getMinValue2(DataArrayInt*& tupleIds) const
3304 double ret=getMinValue(tmp);
3305 tupleIds=getIdsInRange(ret,ret);
3310 * 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.
3311 * This method only works for single component array.
3313 * \return a value in [ 0, \c this->getNumberOfTuples() )
3315 * \throw If \a this is not allocated
3318 int DataArrayDouble::count(double value, double eps) const
3322 if(getNumberOfComponents()!=1)
3323 throw INTERP_KERNEL::Exception("DataArrayDouble::count : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
3324 const double *vals=begin();
3325 int nbOfTuples=getNumberOfTuples();
3326 for(int i=0;i<nbOfTuples;i++,vals++)
3327 if(fabs(*vals-value)<=eps)
3333 * Returns the average value of \a this one-dimensional array.
3334 * \return double - the average value over all values of \a this array.
3335 * \throw If \a this->getNumberOfComponents() != 1
3336 * \throw If \a this->getNumberOfTuples() < 1
3338 double DataArrayDouble::getAverageValue() const
3340 if(getNumberOfComponents()!=1)
3341 throw INTERP_KERNEL::Exception("DataArrayDouble::getAverageValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
3342 int nbOfTuples=getNumberOfTuples();
3344 throw INTERP_KERNEL::Exception("DataArrayDouble::getAverageValue : array exists but number of tuples must be > 0 !");
3345 const double *vals=getConstPointer();
3346 double ret=std::accumulate(vals,vals+nbOfTuples,0.);
3347 return ret/nbOfTuples;
3351 * Returns the Euclidean norm of the vector defined by \a this array.
3352 * \return double - the value of the Euclidean norm, i.e.
3353 * the square root of the inner product of vector.
3354 * \throw If \a this is not allocated.
3356 double DataArrayDouble::norm2() const
3360 std::size_t nbOfElems=getNbOfElems();
3361 const double *pt=getConstPointer();
3362 for(std::size_t i=0;i<nbOfElems;i++,pt++)
3368 * Returns the maximum norm of the vector defined by \a this array.
3369 * This method works even if the number of components is diferent from one.
3370 * If the number of elements in \a this is 0, -1. is returned.
3371 * \return double - the value of the maximum norm, i.e.
3372 * the maximal absolute value among values of \a this array (whatever its number of components).
3373 * \throw If \a this is not allocated.
3375 double DataArrayDouble::normMax() const
3379 std::size_t nbOfElems(getNbOfElems());
3380 const double *pt(getConstPointer());
3381 for(std::size_t i=0;i<nbOfElems;i++,pt++)
3383 double val(std::abs(*pt));
3391 * Returns the minimum norm (absolute value) of the vector defined by \a this array.
3392 * This method works even if the number of components is diferent from one.
3393 * If the number of elements in \a this is 0, std::numeric_limits<double>::max() is returned.
3394 * \return double - the value of the minimum norm, i.e.
3395 * the minimal absolute value among values of \a this array (whatever its number of components).
3396 * \throw If \a this is not allocated.
3398 double DataArrayDouble::normMin() const
3401 double ret(std::numeric_limits<double>::max());
3402 std::size_t nbOfElems(getNbOfElems());
3403 const double *pt(getConstPointer());
3404 for(std::size_t i=0;i<nbOfElems;i++,pt++)
3406 double val(std::abs(*pt));
3414 * Accumulates values of each component of \a this array.
3415 * \param [out] res - an array of length \a this->getNumberOfComponents(), allocated
3416 * by the caller, that is filled by this method with sum value for each
3418 * \throw If \a this is not allocated.
3420 void DataArrayDouble::accumulate(double *res) const
3423 const double *ptr=getConstPointer();
3424 int nbTuple=getNumberOfTuples();
3425 int nbComps=getNumberOfComponents();
3426 std::fill(res,res+nbComps,0.);
3427 for(int i=0;i<nbTuple;i++)
3428 std::transform(ptr+i*nbComps,ptr+(i+1)*nbComps,res,res,std::plus<double>());
3432 * This method returns the min distance from an external tuple defined by [ \a tupleBg , \a tupleEnd ) to \a this and
3433 * the first tuple in \a this that matches the returned distance. If there is no tuples in \a this an exception will be thrown.
3436 * \a this is expected to be allocated and expected to have a number of components equal to the distance from \a tupleBg to
3437 * \a tupleEnd. If not an exception will be thrown.
3439 * \param [in] tupleBg start pointer (included) of input external tuple
3440 * \param [in] tupleEnd end pointer (not included) of input external tuple
3441 * \param [out] tupleId the tuple id in \a this that matches the min of distance between \a this and input external tuple
3442 * \return the min distance.
3443 * \sa MEDCouplingUMesh::distanceToPoint
3445 double DataArrayDouble::distanceToTuple(const double *tupleBg, const double *tupleEnd, int& tupleId) const
3448 int nbTuple=getNumberOfTuples();
3449 int nbComps=getNumberOfComponents();
3450 if(nbComps!=(int)std::distance(tupleBg,tupleEnd))
3451 { 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()); }
3453 throw INTERP_KERNEL::Exception("DataArrayDouble::distanceToTuple : no tuple in this ! No distance to compute !");
3454 double ret0=std::numeric_limits<double>::max();
3456 const double *work=getConstPointer();
3457 for(int i=0;i<nbTuple;i++)
3460 for(int j=0;j<nbComps;j++,work++)
3461 val+=(*work-tupleBg[j])*((*work-tupleBg[j]));
3465 { ret0=val; tupleId=i; }
3471 * Accumulate values of the given component of \a this array.
3472 * \param [in] compId - the index of the component of interest.
3473 * \return double - a sum value of \a compId-th component.
3474 * \throw If \a this is not allocated.
3475 * \throw If \a the condition ( 0 <= \a compId < \a this->getNumberOfComponents() ) is
3478 double DataArrayDouble::accumulate(int compId) const
3481 const double *ptr=getConstPointer();
3482 int nbTuple=getNumberOfTuples();
3483 int nbComps=getNumberOfComponents();
3484 if(compId<0 || compId>=nbComps)
3485 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulate : Invalid compId specified : No such nb of components !");
3487 for(int i=0;i<nbTuple;i++)
3488 ret+=ptr[i*nbComps+compId];
3493 * This method accumulate using addition tuples in \a this using input index array [ \a bgOfIndex, \a endOfIndex ).
3494 * The returned array will have same number of components than \a this and number of tuples equal to
3495 * \c std::distance(bgOfIndex,endOfIndex) \b minus \b one.
3497 * The input index array is expected to be ascendingly sorted in which the all referenced ids should be in [0, \c this->getNumberOfTuples).
3498 * 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.
3500 * \param [in] bgOfIndex - begin (included) of the input index array.
3501 * \param [in] endOfIndex - end (excluded) of the input index array.
3502 * \return DataArrayDouble * - the new instance having the same number of components than \a this.
3504 * \throw If bgOfIndex or end is NULL.
3505 * \throw If input index array is not ascendingly sorted.
3506 * \throw If there is an id in [ \a bgOfIndex, \a endOfIndex ) not in [0, \c this->getNumberOfTuples).
3507 * \throw If std::distance(bgOfIndex,endOfIndex)==0.
3509 DataArrayDouble *DataArrayDouble::accumulatePerChunck(const int *bgOfIndex, const int *endOfIndex) const
3511 if(!bgOfIndex || !endOfIndex)
3512 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : input pointer NULL !");
3514 int nbCompo=getNumberOfComponents();
3515 int nbOfTuples=getNumberOfTuples();
3516 int sz=(int)std::distance(bgOfIndex,endOfIndex);
3518 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : invalid size of input index array !");
3520 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(sz,nbCompo);
3521 const int *w=bgOfIndex;
3522 if(*w<0 || *w>=nbOfTuples)
3523 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : The first element of the input index not in [0,nbOfTuples) !");
3524 const double *srcPt=begin()+(*w)*nbCompo;
3525 double *tmp=ret->getPointer();
3526 for(int i=0;i<sz;i++,tmp+=nbCompo,w++)
3528 std::fill(tmp,tmp+nbCompo,0.);
3531 for(int j=w[0];j<w[1];j++,srcPt+=nbCompo)
3533 if(j>=0 && j<nbOfTuples)
3534 std::transform(srcPt,srcPt+nbCompo,tmp,tmp,std::plus<double>());
3537 std::ostringstream oss; oss << "DataArrayDouble::accumulatePerChunck : At rank #" << i << " the input index array points to id " << j << " should be in [0," << nbOfTuples << ") !";
3538 throw INTERP_KERNEL::Exception(oss.str().c_str());
3544 std::ostringstream oss; oss << "DataArrayDouble::accumulatePerChunck : At rank #" << i << " the input index array is not in ascendingly sorted.";
3545 throw INTERP_KERNEL::Exception(oss.str().c_str());
3548 ret->copyStringInfoFrom(*this);
3553 * Converts each 2D point defined by the tuple of \a this array from the Polar to the
3554 * Cartesian coordinate system. The two components of the tuple of \a this array are
3555 * considered to contain (1) radius and (2) angle of the point in the Polar CS.
3556 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3557 * contains X and Y coordinates of the point in the Cartesian CS. The caller
3558 * is to delete this array using decrRef() as it is no more needed. The array
3559 * does not contain any textual info on components.
3560 * \throw If \a this->getNumberOfComponents() != 2.
3562 DataArrayDouble *DataArrayDouble::fromPolarToCart() const
3565 int nbOfComp=getNumberOfComponents();
3567 throw INTERP_KERNEL::Exception("DataArrayDouble::fromPolarToCart : must be an array with exactly 2 components !");
3568 int nbOfTuple=getNumberOfTuples();
3569 DataArrayDouble *ret=DataArrayDouble::New();
3570 ret->alloc(nbOfTuple,2);
3571 double *w=ret->getPointer();
3572 const double *wIn=getConstPointer();
3573 for(int i=0;i<nbOfTuple;i++,w+=2,wIn+=2)
3575 w[0]=wIn[0]*cos(wIn[1]);
3576 w[1]=wIn[0]*sin(wIn[1]);
3582 * Converts each 3D point defined by the tuple of \a this array from the Cylindrical to
3583 * the Cartesian coordinate system. The three components of the tuple of \a this array
3584 * are considered to contain (1) radius, (2) azimuth and (3) altitude of the point in
3585 * the Cylindrical CS.
3586 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3587 * contains X, Y and Z coordinates of the point in the Cartesian CS. The info
3588 * on the third component is copied from \a this array. The caller
3589 * is to delete this array using decrRef() as it is no more needed.
3590 * \throw If \a this->getNumberOfComponents() != 3.
3592 DataArrayDouble *DataArrayDouble::fromCylToCart() const
3595 int nbOfComp=getNumberOfComponents();
3597 throw INTERP_KERNEL::Exception("DataArrayDouble::fromCylToCart : must be an array with exactly 3 components !");
3598 int nbOfTuple=getNumberOfTuples();
3599 DataArrayDouble *ret=DataArrayDouble::New();
3600 ret->alloc(getNumberOfTuples(),3);
3601 double *w=ret->getPointer();
3602 const double *wIn=getConstPointer();
3603 for(int i=0;i<nbOfTuple;i++,w+=3,wIn+=3)
3605 w[0]=wIn[0]*cos(wIn[1]);
3606 w[1]=wIn[0]*sin(wIn[1]);
3609 ret->setInfoOnComponent(2,getInfoOnComponent(2));
3614 * Converts each 3D point defined by the tuple of \a this array from the Spherical to
3615 * the Cartesian coordinate system. The three components of the tuple of \a this array
3616 * are considered to contain (1) radius, (2) polar angle and (3) azimuthal angle of the
3617 * point in the Cylindrical CS.
3618 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3619 * contains X, Y and Z coordinates of the point in the Cartesian CS. The info
3620 * on the third component is copied from \a this array. The caller
3621 * is to delete this array using decrRef() as it is no more needed.
3622 * \throw If \a this->getNumberOfComponents() != 3.
3624 DataArrayDouble *DataArrayDouble::fromSpherToCart() const
3627 int nbOfComp=getNumberOfComponents();
3629 throw INTERP_KERNEL::Exception("DataArrayDouble::fromSpherToCart : must be an array with exactly 3 components !");
3630 int nbOfTuple=getNumberOfTuples();
3631 DataArrayDouble *ret=DataArrayDouble::New();
3632 ret->alloc(getNumberOfTuples(),3);
3633 double *w=ret->getPointer();
3634 const double *wIn=getConstPointer();
3635 for(int i=0;i<nbOfTuple;i++,w+=3,wIn+=3)
3637 w[0]=wIn[0]*cos(wIn[2])*sin(wIn[1]);
3638 w[1]=wIn[0]*sin(wIn[2])*sin(wIn[1]);
3639 w[2]=wIn[0]*cos(wIn[1]);
3645 * Computes the doubly contracted product of every tensor defined by the tuple of \a this
3646 * array contating 6 components.
3647 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3648 * is calculated from the tuple <em>(t)</em> of \a this array as follows:
3649 * \f$ t[0]^2+t[1]^2+t[2]^2+2*t[3]^2+2*t[4]^2+2*t[5]^2\f$.
3650 * The caller is to delete this result array using decrRef() as it is no more needed.
3651 * \throw If \a this->getNumberOfComponents() != 6.
3653 DataArrayDouble *DataArrayDouble::doublyContractedProduct() const
3656 int nbOfComp=getNumberOfComponents();
3658 throw INTERP_KERNEL::Exception("DataArrayDouble::doublyContractedProduct : must be an array with exactly 6 components !");
3659 DataArrayDouble *ret=DataArrayDouble::New();
3660 int nbOfTuple=getNumberOfTuples();
3661 ret->alloc(nbOfTuple,1);
3662 const double *src=getConstPointer();
3663 double *dest=ret->getPointer();
3664 for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
3665 *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];
3670 * Computes the determinant of every square matrix defined by the tuple of \a this
3671 * array, which contains either 4, 6 or 9 components. The case of 6 components
3672 * corresponds to that of the upper triangular matrix.
3673 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3674 * is the determinant of matrix of the corresponding tuple of \a this array.
3675 * The caller is to delete this result array using decrRef() as it is no more
3677 * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
3679 DataArrayDouble *DataArrayDouble::determinant() const
3682 DataArrayDouble *ret=DataArrayDouble::New();
3683 int nbOfTuple=getNumberOfTuples();
3684 ret->alloc(nbOfTuple,1);
3685 const double *src=getConstPointer();
3686 double *dest=ret->getPointer();
3687 switch(getNumberOfComponents())
3690 for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
3691 *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];
3694 for(int i=0;i<nbOfTuple;i++,dest++,src+=4)
3695 *dest=src[0]*src[3]-src[1]*src[2];
3698 for(int i=0;i<nbOfTuple;i++,dest++,src+=9)
3699 *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];
3703 throw INTERP_KERNEL::Exception("DataArrayDouble::determinant : Invalid number of components ! must be in 4,6,9 !");
3708 * Computes 3 eigenvalues of every upper triangular matrix defined by the tuple of
3709 * \a this array, which contains 6 components.
3710 * \return DataArrayDouble * - the new instance of DataArrayDouble containing 3
3711 * components, whose each tuple contains the eigenvalues of the matrix of
3712 * corresponding tuple of \a this array.
3713 * The caller is to delete this result array using decrRef() as it is no more
3715 * \throw If \a this->getNumberOfComponents() != 6.
3717 DataArrayDouble *DataArrayDouble::eigenValues() const
3720 int nbOfComp=getNumberOfComponents();
3722 throw INTERP_KERNEL::Exception("DataArrayDouble::eigenValues : must be an array with exactly 6 components !");
3723 DataArrayDouble *ret=DataArrayDouble::New();
3724 int nbOfTuple=getNumberOfTuples();
3725 ret->alloc(nbOfTuple,3);
3726 const double *src=getConstPointer();
3727 double *dest=ret->getPointer();
3728 for(int i=0;i<nbOfTuple;i++,dest+=3,src+=6)
3729 INTERP_KERNEL::computeEigenValues6(src,dest);
3734 * Computes 3 eigenvectors of every upper triangular matrix defined by the tuple of
3735 * \a this array, which contains 6 components.
3736 * \return DataArrayDouble * - the new instance of DataArrayDouble containing 9
3737 * components, whose each tuple contains 3 eigenvectors of the matrix of
3738 * corresponding tuple of \a this array.
3739 * The caller is to delete this result array using decrRef() as it is no more
3741 * \throw If \a this->getNumberOfComponents() != 6.
3743 DataArrayDouble *DataArrayDouble::eigenVectors() const
3746 int nbOfComp=getNumberOfComponents();
3748 throw INTERP_KERNEL::Exception("DataArrayDouble::eigenVectors : must be an array with exactly 6 components !");
3749 DataArrayDouble *ret=DataArrayDouble::New();
3750 int nbOfTuple=getNumberOfTuples();
3751 ret->alloc(nbOfTuple,9);
3752 const double *src=getConstPointer();
3753 double *dest=ret->getPointer();
3754 for(int i=0;i<nbOfTuple;i++,src+=6)
3757 INTERP_KERNEL::computeEigenValues6(src,tmp);
3758 for(int j=0;j<3;j++,dest+=3)
3759 INTERP_KERNEL::computeEigenVectorForEigenValue6(src,tmp[j],1e-12,dest);
3765 * Computes the inverse matrix of every matrix defined by the tuple of \a this
3766 * array, which contains either 4, 6 or 9 components. The case of 6 components
3767 * corresponds to that of the upper triangular matrix.
3768 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3769 * same number of components as \a this one, whose each tuple is the inverse
3770 * matrix of the matrix of corresponding tuple of \a this array.
3771 * The caller is to delete this result array using decrRef() as it is no more
3773 * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
3775 DataArrayDouble *DataArrayDouble::inverse() const
3778 int nbOfComp=getNumberOfComponents();
3779 if(nbOfComp!=6 && nbOfComp!=9 && nbOfComp!=4)
3780 throw INTERP_KERNEL::Exception("DataArrayDouble::inversion : must be an array with 4,6 or 9 components !");
3781 DataArrayDouble *ret=DataArrayDouble::New();
3782 int nbOfTuple=getNumberOfTuples();
3783 ret->alloc(nbOfTuple,nbOfComp);
3784 const double *src=getConstPointer();
3785 double *dest=ret->getPointer();
3787 for(int i=0;i<nbOfTuple;i++,dest+=6,src+=6)
3789 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];
3790 dest[0]=(src[1]*src[2]-src[4]*src[4])/det;
3791 dest[1]=(src[0]*src[2]-src[5]*src[5])/det;
3792 dest[2]=(src[0]*src[1]-src[3]*src[3])/det;
3793 dest[3]=(src[5]*src[4]-src[3]*src[2])/det;
3794 dest[4]=(src[5]*src[3]-src[0]*src[4])/det;
3795 dest[5]=(src[3]*src[4]-src[1]*src[5])/det;
3797 else if(nbOfComp==4)
3798 for(int i=0;i<nbOfTuple;i++,dest+=4,src+=4)
3800 double det=src[0]*src[3]-src[1]*src[2];
3802 dest[1]=-src[1]/det;
3803 dest[2]=-src[2]/det;
3807 for(int i=0;i<nbOfTuple;i++,dest+=9,src+=9)
3809 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];
3810 dest[0]=(src[4]*src[8]-src[7]*src[5])/det;
3811 dest[1]=(src[7]*src[2]-src[1]*src[8])/det;
3812 dest[2]=(src[1]*src[5]-src[4]*src[2])/det;
3813 dest[3]=(src[6]*src[5]-src[3]*src[8])/det;
3814 dest[4]=(src[0]*src[8]-src[6]*src[2])/det;
3815 dest[5]=(src[2]*src[3]-src[0]*src[5])/det;
3816 dest[6]=(src[3]*src[7]-src[6]*src[4])/det;
3817 dest[7]=(src[6]*src[1]-src[0]*src[7])/det;
3818 dest[8]=(src[0]*src[4]-src[1]*src[3])/det;
3824 * Computes the trace of every matrix defined by the tuple of \a this
3825 * array, which contains either 4, 6 or 9 components. The case of 6 components
3826 * corresponds to that of the upper triangular matrix.
3827 * \return DataArrayDouble * - the new instance of DataArrayDouble containing
3828 * 1 component, whose each tuple is the trace of
3829 * the matrix of corresponding tuple of \a this array.
3830 * The caller is to delete this result array using decrRef() as it is no more
3832 * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
3834 DataArrayDouble *DataArrayDouble::trace() const
3837 int nbOfComp=getNumberOfComponents();
3838 if(nbOfComp!=6 && nbOfComp!=9 && nbOfComp!=4)
3839 throw INTERP_KERNEL::Exception("DataArrayDouble::trace : must be an array with 4,6 or 9 components !");
3840 DataArrayDouble *ret=DataArrayDouble::New();
3841 int nbOfTuple=getNumberOfTuples();
3842 ret->alloc(nbOfTuple,1);
3843 const double *src=getConstPointer();
3844 double *dest=ret->getPointer();
3846 for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
3847 *dest=src[0]+src[1]+src[2];
3848 else if(nbOfComp==4)
3849 for(int i=0;i<nbOfTuple;i++,dest++,src+=4)
3850 *dest=src[0]+src[3];
3852 for(int i=0;i<nbOfTuple;i++,dest++,src+=9)
3853 *dest=src[0]+src[4]+src[8];
3858 * Computes the stress deviator tensor of every stress tensor defined by the tuple of
3859 * \a this array, which contains 6 components.
3860 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3861 * same number of components and tuples as \a this array.
3862 * The caller is to delete this result array using decrRef() as it is no more
3864 * \throw If \a this->getNumberOfComponents() != 6.
3866 DataArrayDouble *DataArrayDouble::deviator() const
3869 int nbOfComp=getNumberOfComponents();
3871 throw INTERP_KERNEL::Exception("DataArrayDouble::deviator : must be an array with exactly 6 components !");
3872 DataArrayDouble *ret=DataArrayDouble::New();
3873 int nbOfTuple=getNumberOfTuples();
3874 ret->alloc(nbOfTuple,6);
3875 const double *src=getConstPointer();
3876 double *dest=ret->getPointer();
3877 for(int i=0;i<nbOfTuple;i++,dest+=6,src+=6)
3879 double tr=(src[0]+src[1]+src[2])/3.;
3891 * Computes the magnitude of every vector defined by the tuple of
3893 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3894 * same number of tuples as \a this array and one component.
3895 * The caller is to delete this result array using decrRef() as it is no more
3897 * \throw If \a this is not allocated.
3899 DataArrayDouble *DataArrayDouble::magnitude() const
3902 int nbOfComp=getNumberOfComponents();
3903 DataArrayDouble *ret=DataArrayDouble::New();
3904 int nbOfTuple=getNumberOfTuples();
3905 ret->alloc(nbOfTuple,1);
3906 const double *src=getConstPointer();
3907 double *dest=ret->getPointer();
3908 for(int i=0;i<nbOfTuple;i++,dest++)
3911 for(int j=0;j<nbOfComp;j++,src++)
3919 * Computes for each tuple the sum of number of components values in the tuple and return it.
3921 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3922 * same number of tuples as \a this array and one component.
3923 * The caller is to delete this result array using decrRef() as it is no more
3925 * \throw If \a this is not allocated.
3927 DataArrayDouble *DataArrayDouble::sumPerTuple() const
3930 int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
3931 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret(DataArrayDouble::New());
3932 ret->alloc(nbOfTuple,1);
3933 const double *src(getConstPointer());
3934 double *dest(ret->getPointer());
3935 for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
3936 *dest=std::accumulate(src,src+nbOfComp,0.);
3941 * Computes the maximal value within every tuple of \a this array.
3942 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3943 * same number of tuples as \a this array and one component.
3944 * The caller is to delete this result array using decrRef() as it is no more
3946 * \throw If \a this is not allocated.
3947 * \sa DataArrayDouble::maxPerTupleWithCompoId
3949 DataArrayDouble *DataArrayDouble::maxPerTuple() const
3952 int nbOfComp=getNumberOfComponents();
3953 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
3954 int nbOfTuple=getNumberOfTuples();
3955 ret->alloc(nbOfTuple,1);
3956 const double *src=getConstPointer();
3957 double *dest=ret->getPointer();
3958 for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
3959 *dest=*std::max_element(src,src+nbOfComp);
3964 * Computes the maximal value within every tuple of \a this array and it returns the first component
3965 * id for each tuple that corresponds to the maximal value within the tuple.
3967 * \param [out] compoIdOfMaxPerTuple - the new new instance of DataArrayInt containing the
3968 * same number of tuples and only one component.
3969 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3970 * same number of tuples as \a this array and one component.
3971 * The caller is to delete this result array using decrRef() as it is no more
3973 * \throw If \a this is not allocated.
3974 * \sa DataArrayDouble::maxPerTuple
3976 DataArrayDouble *DataArrayDouble::maxPerTupleWithCompoId(DataArrayInt* &compoIdOfMaxPerTuple) const
3979 int nbOfComp=getNumberOfComponents();
3980 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret0=DataArrayDouble::New();
3981 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New();
3982 int nbOfTuple=getNumberOfTuples();
3983 ret0->alloc(nbOfTuple,1); ret1->alloc(nbOfTuple,1);
3984 const double *src=getConstPointer();
3985 double *dest=ret0->getPointer(); int *dest1=ret1->getPointer();
3986 for(int i=0;i<nbOfTuple;i++,dest++,dest1++,src+=nbOfComp)
3988 const double *loc=std::max_element(src,src+nbOfComp);
3990 *dest1=(int)std::distance(src,loc);
3992 compoIdOfMaxPerTuple=ret1.retn();
3997 * This method returns a newly allocated DataArrayDouble instance having one component and \c this->getNumberOfTuples() * \c this->getNumberOfTuples() tuples.
3998 * \n This returned array contains the euclidian distance for each tuple in \a this.
3999 * \n So the returned array can be seen as a dense symmetrical matrix whose diagonal elements are equal to 0.
4000 * \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)
4002 * \warning use this method with care because it can leads to big amount of consumed memory !
4004 * \return A newly allocated (huge) ParaMEDMEM::DataArrayDouble instance that the caller should deal with.
4006 * \throw If \a this is not allocated.
4008 * \sa DataArrayDouble::buildEuclidianDistanceDenseMatrixWith
4010 DataArrayDouble *DataArrayDouble::buildEuclidianDistanceDenseMatrix() const
4013 int nbOfComp=getNumberOfComponents();
4014 int nbOfTuples=getNumberOfTuples();
4015 const double *inData=getConstPointer();
4016 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
4017 ret->alloc(nbOfTuples*nbOfTuples,1);
4018 double *outData=ret->getPointer();
4019 for(int i=0;i<nbOfTuples;i++)
4021 outData[i*nbOfTuples+i]=0.;
4022 for(int j=i+1;j<nbOfTuples;j++)
4025 for(int k=0;k<nbOfComp;k++)
4026 { double delta=inData[i*nbOfComp+k]-inData[j*nbOfComp+k]; dist+=delta*delta; }
4028 outData[i*nbOfTuples+j]=dist;
4029 outData[j*nbOfTuples+i]=dist;
4036 * This method returns a newly allocated DataArrayDouble instance having one component and \c this->getNumberOfTuples() * \c other->getNumberOfTuples() tuples.
4037 * \n This returned array contains the euclidian distance for each tuple in \a other with each tuple in \a this.
4038 * \n So the returned array can be seen as a dense rectangular matrix with \c other->getNumberOfTuples() rows and \c this->getNumberOfTuples() columns.
4039 * \n Output rectangular matrix is sorted along rows.
4040 * \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)
4042 * \warning use this method with care because it can leads to big amount of consumed memory !
4044 * \param [in] other DataArrayDouble instance having same number of components than \a this.
4045 * \return A newly allocated (huge) ParaMEDMEM::DataArrayDouble instance that the caller should deal with.
4047 * \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.
4049 * \sa DataArrayDouble::buildEuclidianDistanceDenseMatrix
4051 DataArrayDouble *DataArrayDouble::buildEuclidianDistanceDenseMatrixWith(const DataArrayDouble *other) const
4054 throw INTERP_KERNEL::Exception("DataArrayDouble::buildEuclidianDistanceDenseMatrixWith : input parameter is null !");
4056 other->checkAllocated();
4057 int nbOfComp=getNumberOfComponents();
4058 int otherNbOfComp=other->getNumberOfComponents();
4059 if(nbOfComp!=otherNbOfComp)
4061 std::ostringstream oss; oss << "DataArrayDouble::buildEuclidianDistanceDenseMatrixWith : this nb of compo=" << nbOfComp << " and other nb of compo=" << otherNbOfComp << ". It should match !";
4062 throw INTERP_KERNEL::Exception(oss.str().c_str());
4064 int nbOfTuples=getNumberOfTuples();
4065 int otherNbOfTuples=other->getNumberOfTuples();
4066 const double *inData=getConstPointer();
4067 const double *inDataOther=other->getConstPointer();
4068 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
4069 ret->alloc(otherNbOfTuples*nbOfTuples,1);
4070 double *outData=ret->getPointer();
4071 for(int i=0;i<otherNbOfTuples;i++,inDataOther+=nbOfComp)
4073 for(int j=0;j<nbOfTuples;j++)
4076 for(int k=0;k<nbOfComp;k++)
4077 { double delta=inDataOther[k]-inData[j*nbOfComp+k]; dist+=delta*delta; }
4079 outData[i*nbOfTuples+j]=dist;
4086 * Sorts value within every tuple of \a this array.
4087 * \param [in] asc - if \a true, the values are sorted in ascending order, else,
4088 * in descending order.
4089 * \throw If \a this is not allocated.
4091 void DataArrayDouble::sortPerTuple(bool asc)
4094 double *pt=getPointer();
4095 int nbOfTuple=getNumberOfTuples();
4096 int nbOfComp=getNumberOfComponents();
4098 for(int i=0;i<nbOfTuple;i++,pt+=nbOfComp)
4099 std::sort(pt,pt+nbOfComp);
4101 for(int i=0;i<nbOfTuple;i++,pt+=nbOfComp)
4102 std::sort(pt,pt+nbOfComp,std::greater<double>());
4107 * Converts every value of \a this array to its absolute value.
4108 * \b WARNING this method is non const. If a new DataArrayDouble instance should be built containing the result of abs DataArrayDouble::computeAbs
4109 * should be called instead.
4111 * \throw If \a this is not allocated.
4112 * \sa DataArrayDouble::computeAbs
4114 void DataArrayDouble::abs()
4117 double *ptr(getPointer());
4118 std::size_t nbOfElems(getNbOfElems());
4119 std::transform(ptr,ptr+nbOfElems,ptr,std::ptr_fun<double,double>(fabs));
4124 * This method builds a new instance of \a this object containing the result of std::abs applied of all elements in \a this.
4125 * This method is a const method (that do not change any values in \a this) contrary to DataArrayDouble::abs method.
4127 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4128 * same number of tuples and component as \a this array.
4129 * The caller is to delete this result array using decrRef() as it is no more
4131 * \throw If \a this is not allocated.
4132 * \sa DataArrayDouble::abs
4134 DataArrayDouble *DataArrayDouble::computeAbs() const
4137 DataArrayDouble *newArr(DataArrayDouble::New());
4138 int nbOfTuples(getNumberOfTuples());
4139 int nbOfComp(getNumberOfComponents());
4140 newArr->alloc(nbOfTuples,nbOfComp);
4141 std::transform(begin(),end(),newArr->getPointer(),std::ptr_fun<double,double>(fabs));
4142 newArr->copyStringInfoFrom(*this);
4147 * Apply a linear function to a given component of \a this array, so that
4148 * an array element <em>(x)</em> becomes \f$ a * x + b \f$.
4149 * \param [in] a - the first coefficient of the function.
4150 * \param [in] b - the second coefficient of the function.
4151 * \param [in] compoId - the index of component to modify.
4152 * \throw If \a this is not allocated, or \a compoId is not in [0,\c this->getNumberOfComponents() ).
4154 void DataArrayDouble::applyLin(double a, double b, int compoId)
4157 double *ptr(getPointer()+compoId);
4158 int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
4159 if(compoId<0 || compoId>=nbOfComp)
4161 std::ostringstream oss; oss << "DataArrayDouble::applyLin : The compoId requested (" << compoId << ") is not valid ! Must be in [0," << nbOfComp << ") !";
4162 throw INTERP_KERNEL::Exception(oss.str().c_str());
4164 for(int i=0;i<nbOfTuple;i++,ptr+=nbOfComp)
4170 * Apply a linear function to all elements of \a this array, so that
4171 * an element _x_ becomes \f$ a * x + b \f$.
4172 * \param [in] a - the first coefficient of the function.
4173 * \param [in] b - the second coefficient of the function.
4174 * \throw If \a this is not allocated.
4176 void DataArrayDouble::applyLin(double a, double b)
4179 double *ptr=getPointer();
4180 std::size_t nbOfElems=getNbOfElems();
4181 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4187 * Modify all elements of \a this array, so that
4188 * an element _x_ becomes \f$ numerator / x \f$.
4189 * \warning If an exception is thrown because of presence of 0.0 element in \a this
4190 * array, all elements processed before detection of the zero element remain
4192 * \param [in] numerator - the numerator used to modify array elements.
4193 * \throw If \a this is not allocated.
4194 * \throw If there is an element equal to 0.0 in \a this array.
4196 void DataArrayDouble::applyInv(double numerator)
4199 double *ptr=getPointer();
4200 std::size_t nbOfElems=getNbOfElems();
4201 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4203 if(std::abs(*ptr)>std::numeric_limits<double>::min())
4205 *ptr=numerator/(*ptr);
4209 std::ostringstream oss; oss << "DataArrayDouble::applyInv : presence of null value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
4211 throw INTERP_KERNEL::Exception(oss.str().c_str());
4218 * Returns a full copy of \a this array except that sign of all elements is reversed.
4219 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4220 * same number of tuples and component as \a this array.
4221 * The caller is to delete this result array using decrRef() as it is no more
4223 * \throw If \a this is not allocated.
4225 DataArrayDouble *DataArrayDouble::negate() const
4228 DataArrayDouble *newArr=DataArrayDouble::New();
4229 int nbOfTuples=getNumberOfTuples();
4230 int nbOfComp=getNumberOfComponents();
4231 newArr->alloc(nbOfTuples,nbOfComp);
4232 const double *cptr=getConstPointer();
4233 std::transform(cptr,cptr+nbOfTuples*nbOfComp,newArr->getPointer(),std::negate<double>());
4234 newArr->copyStringInfoFrom(*this);
4239 * Modify all elements of \a this array, so that
4240 * an element _x_ becomes <em> val ^ x </em>. Contrary to DataArrayInt::applyPow
4241 * all values in \a this have to be >= 0 if val is \b not integer.
4242 * \param [in] val - the value used to apply pow on all array elements.
4243 * \throw If \a this is not allocated.
4244 * \warning If an exception is thrown because of presence of 0 element in \a this
4245 * array and \a val is \b not integer, all elements processed before detection of the zero element remain
4248 void DataArrayDouble::applyPow(double val)
4251 double *ptr=getPointer();
4252 std::size_t nbOfElems=getNbOfElems();
4254 bool isInt=((double)val2)==val;
4257 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4263 std::ostringstream oss; oss << "DataArrayDouble::applyPow (double) : At elem # " << i << " value is " << *ptr << " ! must be >=0. !";
4264 throw INTERP_KERNEL::Exception(oss.str().c_str());
4270 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4271 *ptr=pow(*ptr,val2);
4277 * Modify all elements of \a this array, so that
4278 * an element _x_ becomes \f$ val ^ x \f$.
4279 * \param [in] val - the value used to apply pow on all array elements.
4280 * \throw If \a this is not allocated.
4281 * \throw If \a val < 0.
4282 * \warning If an exception is thrown because of presence of 0 element in \a this
4283 * array, all elements processed before detection of the zero element remain
4286 void DataArrayDouble::applyRPow(double val)
4290 throw INTERP_KERNEL::Exception("DataArrayDouble::applyRPow : the input value has to be >= 0 !");
4291 double *ptr=getPointer();
4292 std::size_t nbOfElems=getNbOfElems();
4293 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4299 * Returns a new DataArrayDouble created from \a this one by applying \a
4300 * FunctionToEvaluate to every tuple of \a this array. Textual data is not copied.
4301 * For more info see \ref MEDCouplingArrayApplyFunc
4302 * \param [in] nbOfComp - number of components in the result array.
4303 * \param [in] func - the \a FunctionToEvaluate declared as
4304 * \c bool (*\a func)(\c const \c double *\a pos, \c double *\a res),
4305 * where \a pos points to the first component of a tuple of \a this array
4306 * and \a res points to the first component of a tuple of the result array.
4307 * Note that length (number of components) of \a pos can differ from
4309 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4310 * same number of tuples as \a this array.
4311 * The caller is to delete this result array using decrRef() as it is no more
4313 * \throw If \a this is not allocated.
4314 * \throw If \a func returns \a false.
4316 DataArrayDouble *DataArrayDouble::applyFunc(int nbOfComp, FunctionToEvaluate func) const
4319 DataArrayDouble *newArr=DataArrayDouble::New();
4320 int nbOfTuples=getNumberOfTuples();
4321 int oldNbOfComp=getNumberOfComponents();
4322 newArr->alloc(nbOfTuples,nbOfComp);
4323 const double *ptr=getConstPointer();
4324 double *ptrToFill=newArr->getPointer();
4325 for(int i=0;i<nbOfTuples;i++)
4327 if(!func(ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp))
4329 std::ostringstream oss; oss << "For tuple # " << i << " with value (";
4330 std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
4331 oss << ") : Evaluation of function failed !";
4333 throw INTERP_KERNEL::Exception(oss.str().c_str());
4340 * Returns a new DataArrayDouble created from \a this one by applying a function to every
4341 * tuple of \a this array. Textual data is not copied.
4342 * For more info see \ref MEDCouplingArrayApplyFunc1.
4343 * \param [in] nbOfComp - number of components in the result array.
4344 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4345 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4346 * \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
4347 * If false the computation is carried on without any notification. When false the evaluation is a little faster.
4348 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4349 * same number of tuples as \a this array and \a nbOfComp components.
4350 * The caller is to delete this result array using decrRef() as it is no more
4352 * \throw If \a this is not allocated.
4353 * \throw If computing \a func fails.
4355 DataArrayDouble *DataArrayDouble::applyFunc(int nbOfComp, const std::string& func, bool isSafe) const
4357 INTERP_KERNEL::ExprParser expr(func);
4359 std::set<std::string> vars;
4360 expr.getTrueSetOfVars(vars);
4361 std::vector<std::string> varsV(vars.begin(),vars.end());
4362 return applyFunc3(nbOfComp,varsV,func,isSafe);
4366 * Returns a new DataArrayDouble created from \a this one by applying a function to every
4367 * tuple of \a this array. Textual data is not copied. This method works by tuples (whatever its size).
4368 * If \a this is a one component array, call applyFuncOnThis instead that performs the same work faster.
4370 * For more info see \ref MEDCouplingArrayApplyFunc0.
4371 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4372 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4373 * \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
4374 * If false the computation is carried on without any notification. When false the evaluation is a little faster.
4375 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4376 * same number of tuples and components as \a this array.
4377 * The caller is to delete this result array using decrRef() as it is no more
4379 * \sa applyFuncOnThis
4380 * \throw If \a this is not allocated.
4381 * \throw If computing \a func fails.
4383 DataArrayDouble *DataArrayDouble::applyFunc(const std::string& func, bool isSafe) const
4385 int nbOfComp(getNumberOfComponents());
4387 throw INTERP_KERNEL::Exception("DataArrayDouble::applyFunc : output number of component must be > 0 !");
4389 int nbOfTuples(getNumberOfTuples());
4390 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> newArr(DataArrayDouble::New());
4391 newArr->alloc(nbOfTuples,nbOfComp);
4392 INTERP_KERNEL::ExprParser expr(func);
4394 std::set<std::string> vars;
4395 expr.getTrueSetOfVars(vars);
4396 if((int)vars.size()>1)
4398 std::ostringstream oss; oss << "DataArrayDouble::applyFunc : this method works only with at most one var func expression ! If you need to map comps on variables please use applyFunc2 or applyFunc3 instead ! Vars in expr are : ";
4399 std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
4400 throw INTERP_KERNEL::Exception(oss.str().c_str());
4404 expr.prepareFastEvaluator();
4405 newArr->rearrange(1);
4406 newArr->fillWithValue(expr.evaluateDouble());
4407 newArr->rearrange(nbOfComp);
4408 return newArr.retn();
4410 std::vector<std::string> vars2(vars.begin(),vars.end());
4411 double buff,*ptrToFill(newArr->getPointer());
4412 const double *ptr(begin());
4413 std::vector<double> stck;
4414 expr.prepareExprEvaluationDouble(vars2,1,1,0,&buff,&buff+1);
4415 expr.prepareFastEvaluator();
4418 for(int i=0;i<nbOfTuples;i++)
4420 for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
4423 expr.evaluateDoubleInternal(stck);
4424 *ptrToFill=stck.back();
4431 for(int i=0;i<nbOfTuples;i++)
4433 for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
4438 expr.evaluateDoubleInternalSafe(stck);
4440 catch(INTERP_KERNEL::Exception& e)
4442 std::ostringstream oss; oss << "For tuple # " << i << " component # " << iComp << " with value (";
4444 oss << ") : Evaluation of function failed !" << e.what();
4445 throw INTERP_KERNEL::Exception(oss.str().c_str());
4447 *ptrToFill=stck.back();
4452 return newArr.retn();
4456 * This method is a non const method that modify the array in \a this.
4457 * This method only works on one component array. It means that function \a func must
4458 * contain at most one variable.
4459 * This method is a specialization of applyFunc method with one parameter on one component array.
4461 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4462 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4463 * \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
4464 * If false the computation is carried on without any notification. When false the evaluation is a little faster.
4468 void DataArrayDouble::applyFuncOnThis(const std::string& func, bool isSafe)
4470 int nbOfComp(getNumberOfComponents());
4472 throw INTERP_KERNEL::Exception("DataArrayDouble::applyFuncOnThis : output number of component must be > 0 !");
4474 int nbOfTuples(getNumberOfTuples());
4475 INTERP_KERNEL::ExprParser expr(func);
4477 std::set<std::string> vars;
4478 expr.getTrueSetOfVars(vars);
4479 if((int)vars.size()>1)
4481 std::ostringstream oss; oss << "DataArrayDouble::applyFuncOnThis : this method works only with at most one var func expression ! If you need to map comps on variables please use applyFunc2 or applyFunc3 instead ! Vars in expr are : ";
4482 std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
4483 throw INTERP_KERNEL::Exception(oss.str().c_str());
4487 expr.prepareFastEvaluator();
4488 std::vector<std::string> compInfo(getInfoOnComponents());
4490 fillWithValue(expr.evaluateDouble());
4491 rearrange(nbOfComp);
4492 setInfoOnComponents(compInfo);
4495 std::vector<std::string> vars2(vars.begin(),vars.end());
4496 double buff,*ptrToFill(getPointer());
4497 const double *ptr(begin());
4498 std::vector<double> stck;
4499 expr.prepareExprEvaluationDouble(vars2,1,1,0,&buff,&buff+1);
4500 expr.prepareFastEvaluator();
4503 for(int i=0;i<nbOfTuples;i++)
4505 for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
4508 expr.evaluateDoubleInternal(stck);
4509 *ptrToFill=stck.back();
4516 for(int i=0;i<nbOfTuples;i++)
4518 for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
4523 expr.evaluateDoubleInternalSafe(stck);
4525 catch(INTERP_KERNEL::Exception& e)
4527 std::ostringstream oss; oss << "For tuple # " << i << " component # " << iComp << " with value (";
4529 oss << ") : Evaluation of function failed !" << e.what();
4530 throw INTERP_KERNEL::Exception(oss.str().c_str());
4532 *ptrToFill=stck.back();
4540 * Returns a new DataArrayDouble created from \a this one by applying a function to every
4541 * tuple of \a this array. Textual data is not copied.
4542 * For more info see \ref MEDCouplingArrayApplyFunc2.
4543 * \param [in] nbOfComp - number of components in the result array.
4544 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4545 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4546 * \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
4547 * If false the computation is carried on without any notification. When false the evaluation is a little faster.
4548 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4549 * same number of tuples as \a this array.
4550 * The caller is to delete this result array using decrRef() as it is no more
4552 * \throw If \a this is not allocated.
4553 * \throw If \a func contains vars that are not in \a this->getInfoOnComponent().
4554 * \throw If computing \a func fails.
4556 DataArrayDouble *DataArrayDouble::applyFunc2(int nbOfComp, const std::string& func, bool isSafe) const
4558 return applyFunc3(nbOfComp,getVarsOnComponent(),func,isSafe);
4562 * Returns a new DataArrayDouble created from \a this one by applying a function to every
4563 * tuple of \a this array. Textual data is not copied.
4564 * For more info see \ref MEDCouplingArrayApplyFunc3.
4565 * \param [in] nbOfComp - number of components in the result array.
4566 * \param [in] varsOrder - sequence of vars defining their order.
4567 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4568 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4569 * \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
4570 * If false the computation is carried on without any notification. When false the evaluation is a little faster.
4571 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4572 * same number of tuples as \a this array.
4573 * The caller is to delete this result array using decrRef() as it is no more
4575 * \throw If \a this is not allocated.
4576 * \throw If \a func contains vars not in \a varsOrder.
4577 * \throw If computing \a func fails.
4579 DataArrayDouble *DataArrayDouble::applyFunc3(int nbOfComp, const std::vector<std::string>& varsOrder, const std::string& func, bool isSafe) const
4582 throw INTERP_KERNEL::Exception("DataArrayDouble::applyFunc3 : output number of component must be > 0 !");
4583 std::vector<std::string> varsOrder2(varsOrder);
4584 int oldNbOfComp(getNumberOfComponents());
4585 for(int i=(int)varsOrder.size();i<oldNbOfComp;i++)
4586 varsOrder2.push_back(std::string());
4588 int nbOfTuples(getNumberOfTuples());
4589 INTERP_KERNEL::ExprParser expr(func);
4591 std::set<std::string> vars;
4592 expr.getTrueSetOfVars(vars);
4593 if((int)vars.size()>oldNbOfComp)
4595 std::ostringstream oss; oss << "The field has " << oldNbOfComp << " components and there are ";
4596 oss << vars.size() << " variables : ";
4597 std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
4598 throw INTERP_KERNEL::Exception(oss.str().c_str());
4600 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> newArr(DataArrayDouble::New());
4601 newArr->alloc(nbOfTuples,nbOfComp);
4602 INTERP_KERNEL::AutoPtr<double> buff(new double[oldNbOfComp]);
4603 double *buffPtr(buff),*ptrToFill;
4604 std::vector<double> stck;
4605 for(int iComp=0;iComp<nbOfComp;iComp++)
4607 expr.prepareExprEvaluationDouble(varsOrder2,oldNbOfComp,nbOfComp,iComp,buffPtr,buffPtr+oldNbOfComp);
4608 expr.prepareFastEvaluator();
4609 const double *ptr(getConstPointer());
4610 ptrToFill=newArr->getPointer()+iComp;
4613 for(int i=0;i<nbOfTuples;i++,ptrToFill+=nbOfComp,ptr+=oldNbOfComp)
4615 std::copy(ptr,ptr+oldNbOfComp,buffPtr);
4616 expr.evaluateDoubleInternal(stck);
4617 *ptrToFill=stck.back();
4623 for(int i=0;i<nbOfTuples;i++,ptrToFill+=nbOfComp,ptr+=oldNbOfComp)
4625 std::copy(ptr,ptr+oldNbOfComp,buffPtr);
4628 expr.evaluateDoubleInternalSafe(stck);
4629 *ptrToFill=stck.back();
4632 catch(INTERP_KERNEL::Exception& e)
4634 std::ostringstream oss; oss << "For tuple # " << i << " with value (";
4635 std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
4636 oss << ") : Evaluation of function failed !" << e.what();
4637 throw INTERP_KERNEL::Exception(oss.str().c_str());
4642 return newArr.retn();
4645 void DataArrayDouble::applyFuncFast32(const std::string& func)
4648 INTERP_KERNEL::ExprParser expr(func);
4650 char *funcStr=expr.compileX86();
4652 *((void **)&funcPtr)=funcStr;//he he...
4654 double *ptr=getPointer();
4655 int nbOfComp=getNumberOfComponents();
4656 int nbOfTuples=getNumberOfTuples();
4657 int nbOfElems=nbOfTuples*nbOfComp;
4658 for(int i=0;i<nbOfElems;i++,ptr++)
4663 void DataArrayDouble::applyFuncFast64(const std::string& func)
4666 INTERP_KERNEL::ExprParser expr(func);
4668 char *funcStr=expr.compileX86_64();
4670 *((void **)&funcPtr)=funcStr;//he he...
4672 double *ptr=getPointer();
4673 int nbOfComp=getNumberOfComponents();
4674 int nbOfTuples=getNumberOfTuples();
4675 int nbOfElems=nbOfTuples*nbOfComp;
4676 for(int i=0;i<nbOfElems;i++,ptr++)
4681 DataArrayDoubleIterator *DataArrayDouble::iterator()
4683 return new DataArrayDoubleIterator(this);
4687 * Returns a new DataArrayInt contating indices of tuples of \a this one-dimensional
4688 * array whose values are within a given range. Textual data is not copied.
4689 * \param [in] vmin - a lowest acceptable value (included).
4690 * \param [in] vmax - a greatest acceptable value (included).
4691 * \return DataArrayInt * - the new instance of DataArrayInt.
4692 * The caller is to delete this result array using decrRef() as it is no more
4694 * \throw If \a this->getNumberOfComponents() != 1.
4696 * \sa DataArrayDouble::getIdsNotInRange
4698 * \if ENABLE_EXAMPLES
4699 * \ref cpp_mcdataarraydouble_getidsinrange "Here is a C++ example".<br>
4700 * \ref py_mcdataarraydouble_getidsinrange "Here is a Python example".
4703 DataArrayInt *DataArrayDouble::getIdsInRange(double vmin, double vmax) const
4706 if(getNumberOfComponents()!=1)
4707 throw INTERP_KERNEL::Exception("DataArrayDouble::getIdsInRange : this must have exactly one component !");
4708 const double *cptr(begin());
4709 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
4710 int nbOfTuples(getNumberOfTuples());
4711 for(int i=0;i<nbOfTuples;i++,cptr++)
4712 if(*cptr>=vmin && *cptr<=vmax)
4713 ret->pushBackSilent(i);
4718 * Returns a new DataArrayInt contating indices of tuples of \a this one-dimensional
4719 * array whose values are not within a given range. Textual data is not copied.
4720 * \param [in] vmin - a lowest not acceptable value (excluded).
4721 * \param [in] vmax - a greatest not acceptable value (excluded).
4722 * \return DataArrayInt * - the new instance of DataArrayInt.
4723 * The caller is to delete this result array using decrRef() as it is no more
4725 * \throw If \a this->getNumberOfComponents() != 1.
4727 * \sa DataArrayDouble::getIdsInRange
4729 DataArrayInt *DataArrayDouble::getIdsNotInRange(double vmin, double vmax) const
4732 if(getNumberOfComponents()!=1)
4733 throw INTERP_KERNEL::Exception("DataArrayDouble::getIdsNotInRange : this must have exactly one component !");
4734 const double *cptr(begin());
4735 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
4736 int nbOfTuples(getNumberOfTuples());
4737 for(int i=0;i<nbOfTuples;i++,cptr++)
4738 if(*cptr<vmin || *cptr>vmax)
4739 ret->pushBackSilent(i);
4744 * Returns a new DataArrayDouble by concatenating two given arrays, so that (1) the number
4745 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
4746 * the number of component in the result array is same as that of each of given arrays.
4747 * Info on components is copied from the first of the given arrays. Number of components
4748 * in the given arrays must be the same.
4749 * \param [in] a1 - an array to include in the result array.
4750 * \param [in] a2 - another array to include in the result array.
4751 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4752 * The caller is to delete this result array using decrRef() as it is no more
4754 * \throw If both \a a1 and \a a2 are NULL.
4755 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents().
4757 DataArrayDouble *DataArrayDouble::Aggregate(const DataArrayDouble *a1, const DataArrayDouble *a2)
4759 std::vector<const DataArrayDouble *> tmp(2);
4760 tmp[0]=a1; tmp[1]=a2;
4761 return Aggregate(tmp);
4765 * Returns a new DataArrayDouble by concatenating all given arrays, so that (1) the number
4766 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
4767 * the number of component in the result array is same as that of each of given arrays.
4768 * Info on components is copied from the first of the given arrays. Number of components
4769 * in the given arrays must be the same.
4770 * If the number of non null of elements in \a arr is equal to one the returned object is a copy of it
4771 * not the object itself.
4772 * \param [in] arr - a sequence of arrays to include in the result array.
4773 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4774 * The caller is to delete this result array using decrRef() as it is no more
4776 * \throw If all arrays within \a arr are NULL.
4777 * \throw If getNumberOfComponents() of arrays within \a arr.
4779 DataArrayDouble *DataArrayDouble::Aggregate(const std::vector<const DataArrayDouble *>& arr)
4781 std::vector<const DataArrayDouble *> a;
4782 for(std::vector<const DataArrayDouble *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
4786 throw INTERP_KERNEL::Exception("DataArrayDouble::Aggregate : input list must contain at least one NON EMPTY DataArrayDouble !");
4787 std::vector<const DataArrayDouble *>::const_iterator it=a.begin();
4788 int nbOfComp=(*it)->getNumberOfComponents();
4789 int nbt=(*it++)->getNumberOfTuples();
4790 for(int i=1;it!=a.end();it++,i++)
4792 if((*it)->getNumberOfComponents()!=nbOfComp)
4793 throw INTERP_KERNEL::Exception("DataArrayDouble::Aggregate : Nb of components mismatch for array aggregation !");
4794 nbt+=(*it)->getNumberOfTuples();
4796 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
4797 ret->alloc(nbt,nbOfComp);
4798 double *pt=ret->getPointer();
4799 for(it=a.begin();it!=a.end();it++)
4800 pt=std::copy((*it)->getConstPointer(),(*it)->getConstPointer()+(*it)->getNbOfElems(),pt);
4801 ret->copyStringInfoFrom(*(a[0]));
4806 * Returns a new DataArrayDouble by aggregating two given arrays, so that (1) the number
4807 * of components in the result array is a sum of the number of components of given arrays
4808 * and (2) the number of tuples in the result array is same as that of each of given
4809 * arrays. In other words the i-th tuple of result array includes all components of
4810 * i-th tuples of all given arrays.
4811 * Number of tuples in the given arrays must be the same.
4812 * \param [in] a1 - an array to include in the result array.
4813 * \param [in] a2 - another array to include in the result array.
4814 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4815 * The caller is to delete this result array using decrRef() as it is no more
4817 * \throw If both \a a1 and \a a2 are NULL.
4818 * \throw If any given array is not allocated.
4819 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4821 DataArrayDouble *DataArrayDouble::Meld(const DataArrayDouble *a1, const DataArrayDouble *a2)
4823 std::vector<const DataArrayDouble *> arr(2);
4824 arr[0]=a1; arr[1]=a2;
4829 * Returns a new DataArrayDouble by aggregating all given arrays, so that (1) the number
4830 * of components in the result array is a sum of the number of components of given arrays
4831 * and (2) the number of tuples in the result array is same as that of each of given
4832 * arrays. In other words the i-th tuple of result array includes all components of
4833 * i-th tuples of all given arrays.
4834 * Number of tuples in the given arrays must be the same.
4835 * \param [in] arr - a sequence of arrays to include in the result array.
4836 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4837 * The caller is to delete this result array using decrRef() as it is no more
4839 * \throw If all arrays within \a arr are NULL.
4840 * \throw If any given array is not allocated.
4841 * \throw If getNumberOfTuples() of arrays within \a arr is different.
4843 DataArrayDouble *DataArrayDouble::Meld(const std::vector<const DataArrayDouble *>& arr)
4845 std::vector<const DataArrayDouble *> a;
4846 for(std::vector<const DataArrayDouble *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
4850 throw INTERP_KERNEL::Exception("DataArrayDouble::Meld : input list must contain at least one NON EMPTY DataArrayDouble !");
4851 std::vector<const DataArrayDouble *>::const_iterator it;
4852 for(it=a.begin();it!=a.end();it++)
4853 (*it)->checkAllocated();
4855 int nbOfTuples=(*it)->getNumberOfTuples();
4856 std::vector<int> nbc(a.size());
4857 std::vector<const double *> pts(a.size());
4858 nbc[0]=(*it)->getNumberOfComponents();
4859 pts[0]=(*it++)->getConstPointer();
4860 for(int i=1;it!=a.end();it++,i++)
4862 if(nbOfTuples!=(*it)->getNumberOfTuples())
4863 throw INTERP_KERNEL::Exception("DataArrayDouble::Meld : mismatch of number of tuples !");
4864 nbc[i]=(*it)->getNumberOfComponents();
4865 pts[i]=(*it)->getConstPointer();
4867 int totalNbOfComp=std::accumulate(nbc.begin(),nbc.end(),0);
4868 DataArrayDouble *ret=DataArrayDouble::New();
4869 ret->alloc(nbOfTuples,totalNbOfComp);
4870 double *retPtr=ret->getPointer();
4871 for(int i=0;i<nbOfTuples;i++)
4872 for(int j=0;j<(int)a.size();j++)
4874 retPtr=std::copy(pts[j],pts[j]+nbc[j],retPtr);
4878 for(int i=0;i<(int)a.size();i++)
4879 for(int j=0;j<nbc[i];j++,k++)
4880 ret->setInfoOnComponent(k,a[i]->getInfoOnComponent(j));
4885 * Returns a new DataArrayDouble containing a dot product of two given arrays, so that
4886 * the i-th tuple of the result array is a sum of products of j-th components of i-th
4887 * tuples of given arrays (\f$ a_i = \sum_{j=1}^n a1_j * a2_j \f$).
4888 * Info on components and name is copied from the first of the given arrays.
4889 * Number of tuples and components in the given arrays must be the same.
4890 * \param [in] a1 - a given array.
4891 * \param [in] a2 - another given array.
4892 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4893 * The caller is to delete this result array using decrRef() as it is no more
4895 * \throw If either \a a1 or \a a2 is NULL.
4896 * \throw If any given array is not allocated.
4897 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4898 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
4900 DataArrayDouble *DataArrayDouble::Dot(const DataArrayDouble *a1, const DataArrayDouble *a2)
4903 throw INTERP_KERNEL::Exception("DataArrayDouble::Dot : input DataArrayDouble instance is NULL !");
4904 a1->checkAllocated();
4905 a2->checkAllocated();
4906 int nbOfComp=a1->getNumberOfComponents();
4907 if(nbOfComp!=a2->getNumberOfComponents())
4908 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Dot !");
4909 int nbOfTuple=a1->getNumberOfTuples();
4910 if(nbOfTuple!=a2->getNumberOfTuples())
4911 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Dot !");
4912 DataArrayDouble *ret=DataArrayDouble::New();
4913 ret->alloc(nbOfTuple,1);
4914 double *retPtr=ret->getPointer();
4915 const double *a1Ptr=a1->getConstPointer();
4916 const double *a2Ptr=a2->getConstPointer();
4917 for(int i=0;i<nbOfTuple;i++)
4920 for(int j=0;j<nbOfComp;j++)
4921 sum+=a1Ptr[i*nbOfComp+j]*a2Ptr[i*nbOfComp+j];
4924 ret->setInfoOnComponent(0,a1->getInfoOnComponent(0));
4925 ret->setName(a1->getName());
4930 * Returns a new DataArrayDouble containing a cross product of two given arrays, so that
4931 * the i-th tuple of the result array contains 3 components of a vector which is a cross
4932 * product of two vectors defined by the i-th tuples of given arrays.
4933 * Info on components is copied from the first of the given arrays.
4934 * Number of tuples in the given arrays must be the same.
4935 * Number of components in the given arrays must be 3.
4936 * \param [in] a1 - a given array.
4937 * \param [in] a2 - another given array.
4938 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4939 * The caller is to delete this result array using decrRef() as it is no more
4941 * \throw If either \a a1 or \a a2 is NULL.
4942 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4943 * \throw If \a a1->getNumberOfComponents() != 3
4944 * \throw If \a a2->getNumberOfComponents() != 3
4946 DataArrayDouble *DataArrayDouble::CrossProduct(const DataArrayDouble *a1, const DataArrayDouble *a2)
4949 throw INTERP_KERNEL::Exception("DataArrayDouble::CrossProduct : input DataArrayDouble instance is NULL !");
4950 int nbOfComp=a1->getNumberOfComponents();
4951 if(nbOfComp!=a2->getNumberOfComponents())
4952 throw INTERP_KERNEL::Exception("Nb of components mismatch for array crossProduct !");
4954 throw INTERP_KERNEL::Exception("Nb of components must be equal to 3 for array crossProduct !");
4955 int nbOfTuple=a1->getNumberOfTuples();
4956 if(nbOfTuple!=a2->getNumberOfTuples())
4957 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array crossProduct !");
4958 DataArrayDouble *ret=DataArrayDouble::New();
4959 ret->alloc(nbOfTuple,3);
4960 double *retPtr=ret->getPointer();
4961 const double *a1Ptr=a1->getConstPointer();
4962 const double *a2Ptr=a2->getConstPointer();
4963 for(int i=0;i<nbOfTuple;i++)
4965 retPtr[3*i]=a1Ptr[3*i+1]*a2Ptr[3*i+2]-a1Ptr[3*i+2]*a2Ptr[3*i+1];
4966 retPtr[3*i+1]=a1Ptr[3*i+2]*a2Ptr[3*i]-a1Ptr[3*i]*a2Ptr[3*i+2];
4967 retPtr[3*i+2]=a1Ptr[3*i]*a2Ptr[3*i+1]-a1Ptr[3*i+1]*a2Ptr[3*i];
4969 ret->copyStringInfoFrom(*a1);
4974 * Returns a new DataArrayDouble containing maximal values of two given arrays.
4975 * Info on components is copied from the first of the given arrays.
4976 * Number of tuples and components in the given arrays must be the same.
4977 * \param [in] a1 - an array to compare values with another one.
4978 * \param [in] a2 - another array to compare values with the first one.
4979 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4980 * The caller is to delete this result array using decrRef() as it is no more
4982 * \throw If either \a a1 or \a a2 is NULL.
4983 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4984 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
4986 DataArrayDouble *DataArrayDouble::Max(const DataArrayDouble *a1, const DataArrayDouble *a2)
4989 throw INTERP_KERNEL::Exception("DataArrayDouble::Max : input DataArrayDouble instance is NULL !");
4990 int nbOfComp=a1->getNumberOfComponents();
4991 if(nbOfComp!=a2->getNumberOfComponents())
4992 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Max !");
4993 int nbOfTuple=a1->getNumberOfTuples();
4994 if(nbOfTuple!=a2->getNumberOfTuples())
4995 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Max !");
4996 DataArrayDouble *ret=DataArrayDouble::New();
4997 ret->alloc(nbOfTuple,nbOfComp);
4998 double *retPtr=ret->getPointer();
4999 const double *a1Ptr=a1->getConstPointer();
5000 const double *a2Ptr=a2->getConstPointer();
5001 int nbElem=nbOfTuple*nbOfComp;
5002 for(int i=0;i<nbElem;i++)
5003 retPtr[i]=std::max(a1Ptr[i],a2Ptr[i]);
5004 ret->copyStringInfoFrom(*a1);
5009 * Returns a new DataArrayDouble containing minimal values of two given arrays.
5010 * Info on components is copied from the first of the given arrays.
5011 * Number of tuples and components in the given arrays must be the same.
5012 * \param [in] a1 - an array to compare values with another one.
5013 * \param [in] a2 - another array to compare values with the first one.
5014 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5015 * The caller is to delete this result array using decrRef() as it is no more
5017 * \throw If either \a a1 or \a a2 is NULL.
5018 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
5019 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
5021 DataArrayDouble *DataArrayDouble::Min(const DataArrayDouble *a1, const DataArrayDouble *a2)
5024 throw INTERP_KERNEL::Exception("DataArrayDouble::Min : input DataArrayDouble instance is NULL !");
5025 int nbOfComp=a1->getNumberOfComponents();
5026 if(nbOfComp!=a2->getNumberOfComponents())
5027 throw INTERP_KERNEL::Exception("Nb of components mismatch for array min !");
5028 int nbOfTuple=a1->getNumberOfTuples();
5029 if(nbOfTuple!=a2->getNumberOfTuples())
5030 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array min !");
5031 DataArrayDouble *ret=DataArrayDouble::New();
5032 ret->alloc(nbOfTuple,nbOfComp);
5033 double *retPtr=ret->getPointer();
5034 const double *a1Ptr=a1->getConstPointer();
5035 const double *a2Ptr=a2->getConstPointer();
5036 int nbElem=nbOfTuple*nbOfComp;
5037 for(int i=0;i<nbElem;i++)
5038 retPtr[i]=std::min(a1Ptr[i],a2Ptr[i]);
5039 ret->copyStringInfoFrom(*a1);
5044 * Returns a new DataArrayDouble that is a sum of two given arrays. There are 3
5046 * 1. The arrays have same number of tuples and components. Then each value of
5047 * the result array (_a_) is a sum of the corresponding values of \a a1 and \a a2,
5048 * i.e.: _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, j ].
5049 * 2. The arrays have same number of tuples and one array, say _a2_, has one
5051 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, 0 ].
5052 * 3. The arrays have same number of components and one array, say _a2_, has one
5054 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ 0, j ].
5056 * Info on components is copied either from the first array (in the first case) or from
5057 * the array with maximal number of elements (getNbOfElems()).
5058 * \param [in] a1 - an array to sum up.
5059 * \param [in] a2 - another array to sum up.
5060 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5061 * The caller is to delete this result array using decrRef() as it is no more
5063 * \throw If either \a a1 or \a a2 is NULL.
5064 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
5065 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
5066 * none of them has number of tuples or components equal to 1.
5068 DataArrayDouble *DataArrayDouble::Add(const DataArrayDouble *a1, const DataArrayDouble *a2)
5071 throw INTERP_KERNEL::Exception("DataArrayDouble::Add : input DataArrayDouble instance is NULL !");
5072 int nbOfTuple=a1->getNumberOfTuples();
5073 int nbOfTuple2=a2->getNumberOfTuples();
5074 int nbOfComp=a1->getNumberOfComponents();
5075 int nbOfComp2=a2->getNumberOfComponents();
5076 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=0;
5077 if(nbOfTuple==nbOfTuple2)
5079 if(nbOfComp==nbOfComp2)
5081 ret=DataArrayDouble::New();
5082 ret->alloc(nbOfTuple,nbOfComp);
5083 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::plus<double>());
5084 ret->copyStringInfoFrom(*a1);
5088 int nbOfCompMin,nbOfCompMax;
5089 const DataArrayDouble *aMin, *aMax;
5090 if(nbOfComp>nbOfComp2)
5092 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
5097 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
5102 ret=DataArrayDouble::New();
5103 ret->alloc(nbOfTuple,nbOfCompMax);
5104 const double *aMinPtr=aMin->getConstPointer();
5105 const double *aMaxPtr=aMax->getConstPointer();
5106 double *res=ret->getPointer();
5107 for(int i=0;i<nbOfTuple;i++)
5108 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::plus<double>(),aMinPtr[i]));
5109 ret->copyStringInfoFrom(*aMax);
5112 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
5115 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
5117 if(nbOfComp==nbOfComp2)
5119 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
5120 const DataArrayDouble *aMin=nbOfTuple>nbOfTuple2?a2:a1;
5121 const DataArrayDouble *aMax=nbOfTuple>nbOfTuple2?a1:a2;
5122 const double *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
5123 ret=DataArrayDouble::New();
5124 ret->alloc(nbOfTupleMax,nbOfComp);
5125 double *res=ret->getPointer();
5126 for(int i=0;i<nbOfTupleMax;i++)
5127 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::plus<double>());
5128 ret->copyStringInfoFrom(*aMax);
5131 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
5134 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Add !");
5139 * Adds values of another DataArrayDouble to values of \a this one. There are 3
5141 * 1. The arrays have same number of tuples and components. Then each value of
5142 * \a other array is added to the corresponding value of \a this array, i.e.:
5143 * _a_ [ i, j ] += _other_ [ i, j ].
5144 * 2. The arrays have same number of tuples and \a other array has one component. Then
5145 * _a_ [ i, j ] += _other_ [ i, 0 ].
5146 * 3. The arrays have same number of components and \a other array has one tuple. Then
5147 * _a_ [ i, j ] += _a2_ [ 0, j ].
5149 * \param [in] other - an array to add to \a this one.
5150 * \throw If \a other is NULL.
5151 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
5152 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
5153 * \a other has number of both tuples and components not equal to 1.
5155 void DataArrayDouble::addEqual(const DataArrayDouble *other)
5158 throw INTERP_KERNEL::Exception("DataArrayDouble::addEqual : input DataArrayDouble instance is NULL !");
5159 const char *msg="Nb of tuples mismatch for DataArrayDouble::addEqual !";
5161 other->checkAllocated();
5162 int nbOfTuple=getNumberOfTuples();
5163 int nbOfTuple2=other->getNumberOfTuples();
5164 int nbOfComp=getNumberOfComponents();
5165 int nbOfComp2=other->getNumberOfComponents();
5166 if(nbOfTuple==nbOfTuple2)
5168 if(nbOfComp==nbOfComp2)
5170 std::transform(begin(),end(),other->begin(),getPointer(),std::plus<double>());
5172 else if(nbOfComp2==1)
5174 double *ptr=getPointer();
5175 const double *ptrc=other->getConstPointer();
5176 for(int i=0;i<nbOfTuple;i++)
5177 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::plus<double>(),*ptrc++));
5180 throw INTERP_KERNEL::Exception(msg);
5182 else if(nbOfTuple2==1)
5184 if(nbOfComp2==nbOfComp)
5186 double *ptr=getPointer();
5187 const double *ptrc=other->getConstPointer();
5188 for(int i=0;i<nbOfTuple;i++)
5189 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::plus<double>());
5192 throw INTERP_KERNEL::Exception(msg);
5195 throw INTERP_KERNEL::Exception(msg);
5200 * Returns a new DataArrayDouble that is a subtraction of two given arrays. There are 3
5202 * 1. The arrays have same number of tuples and components. Then each value of
5203 * the result array (_a_) is a subtraction of the corresponding values of \a a1 and
5204 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, j ].
5205 * 2. The arrays have same number of tuples and one array, say _a2_, has one
5207 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, 0 ].
5208 * 3. The arrays have same number of components and one array, say _a2_, has one
5210 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ 0, j ].
5212 * Info on components is copied either from the first array (in the first case) or from
5213 * the array with maximal number of elements (getNbOfElems()).
5214 * \param [in] a1 - an array to subtract from.
5215 * \param [in] a2 - an array to subtract.
5216 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5217 * The caller is to delete this result array using decrRef() as it is no more
5219 * \throw If either \a a1 or \a a2 is NULL.
5220 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
5221 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
5222 * none of them has number of tuples or components equal to 1.
5224 DataArrayDouble *DataArrayDouble::Substract(const DataArrayDouble *a1, const DataArrayDouble *a2)
5227 throw INTERP_KERNEL::Exception("DataArrayDouble::Substract : input DataArrayDouble instance is NULL !");
5228 int nbOfTuple1=a1->getNumberOfTuples();
5229 int nbOfTuple2=a2->getNumberOfTuples();
5230 int nbOfComp1=a1->getNumberOfComponents();
5231 int nbOfComp2=a2->getNumberOfComponents();
5232 if(nbOfTuple2==nbOfTuple1)
5234 if(nbOfComp1==nbOfComp2)
5236 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5237 ret->alloc(nbOfTuple2,nbOfComp1);
5238 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::minus<double>());
5239 ret->copyStringInfoFrom(*a1);
5242 else if(nbOfComp2==1)
5244 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5245 ret->alloc(nbOfTuple1,nbOfComp1);
5246 const double *a2Ptr=a2->getConstPointer();
5247 const double *a1Ptr=a1->getConstPointer();
5248 double *res=ret->getPointer();
5249 for(int i=0;i<nbOfTuple1;i++)
5250 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::minus<double>(),a2Ptr[i]));
5251 ret->copyStringInfoFrom(*a1);
5256 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
5260 else if(nbOfTuple2==1)
5262 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
5263 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5264 ret->alloc(nbOfTuple1,nbOfComp1);
5265 const double *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
5266 double *pt=ret->getPointer();
5267 for(int i=0;i<nbOfTuple1;i++)
5268 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::minus<double>());
5269 ret->copyStringInfoFrom(*a1);
5274 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Substract !");//will always throw an exception
5280 * Subtract values of another DataArrayDouble from values of \a this one. There are 3
5282 * 1. The arrays have same number of tuples and components. Then each value of
5283 * \a other array is subtracted from the corresponding value of \a this array, i.e.:
5284 * _a_ [ i, j ] -= _other_ [ i, j ].
5285 * 2. The arrays have same number of tuples and \a other array has one component. Then
5286 * _a_ [ i, j ] -= _other_ [ i, 0 ].
5287 * 3. The arrays have same number of components and \a other array has one tuple. Then
5288 * _a_ [ i, j ] -= _a2_ [ 0, j ].
5290 * \param [in] other - an array to subtract from \a this one.
5291 * \throw If \a other is NULL.
5292 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
5293 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
5294 * \a other has number of both tuples and components not equal to 1.
5296 void DataArrayDouble::substractEqual(const DataArrayDouble *other)
5299 throw INTERP_KERNEL::Exception("DataArrayDouble::substractEqual : input DataArrayDouble instance is NULL !");
5300 const char *msg="Nb of tuples mismatch for DataArrayDouble::substractEqual !";
5302 other->checkAllocated();
5303 int nbOfTuple=getNumberOfTuples();
5304 int nbOfTuple2=other->getNumberOfTuples();
5305 int nbOfComp=getNumberOfComponents();
5306 int nbOfComp2=other->getNumberOfComponents();
5307 if(nbOfTuple==nbOfTuple2)
5309 if(nbOfComp==nbOfComp2)
5311 std::transform(begin(),end(),other->begin(),getPointer(),std::minus<double>());
5313 else if(nbOfComp2==1)
5315 double *ptr=getPointer();
5316 const double *ptrc=other->getConstPointer();
5317 for(int i=0;i<nbOfTuple;i++)
5318 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::minus<double>(),*ptrc++));
5321 throw INTERP_KERNEL::Exception(msg);
5323 else if(nbOfTuple2==1)
5325 if(nbOfComp2==nbOfComp)
5327 double *ptr=getPointer();
5328 const double *ptrc=other->getConstPointer();
5329 for(int i=0;i<nbOfTuple;i++)
5330 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::minus<double>());
5333 throw INTERP_KERNEL::Exception(msg);
5336 throw INTERP_KERNEL::Exception(msg);
5341 * Returns a new DataArrayDouble that is a product of two given arrays. There are 3
5343 * 1. The arrays have same number of tuples and components. Then each value of
5344 * the result array (_a_) is a product of the corresponding values of \a a1 and
5345 * \a a2, i.e. _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, j ].
5346 * 2. The arrays have same number of tuples and one array, say _a2_, has one
5348 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, 0 ].
5349 * 3. The arrays have same number of components and one array, say _a2_, has one
5351 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ 0, j ].
5353 * Info on components is copied either from the first array (in the first case) or from
5354 * the array with maximal number of elements (getNbOfElems()).
5355 * \param [in] a1 - a factor array.
5356 * \param [in] a2 - another factor array.
5357 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5358 * The caller is to delete this result array using decrRef() as it is no more
5360 * \throw If either \a a1 or \a a2 is NULL.
5361 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
5362 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
5363 * none of them has number of tuples or components equal to 1.
5365 DataArrayDouble *DataArrayDouble::Multiply(const DataArrayDouble *a1, const DataArrayDouble *a2)
5368 throw INTERP_KERNEL::Exception("DataArrayDouble::Multiply : input DataArrayDouble instance is NULL !");
5369 int nbOfTuple=a1->getNumberOfTuples();
5370 int nbOfTuple2=a2->getNumberOfTuples();
5371 int nbOfComp=a1->getNumberOfComponents();
5372 int nbOfComp2=a2->getNumberOfComponents();
5373 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=0;
5374 if(nbOfTuple==nbOfTuple2)
5376 if(nbOfComp==nbOfComp2)
5378 ret=DataArrayDouble::New();
5379 ret->alloc(nbOfTuple,nbOfComp);
5380 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::multiplies<double>());
5381 ret->copyStringInfoFrom(*a1);
5385 int nbOfCompMin,nbOfCompMax;
5386 const DataArrayDouble *aMin, *aMax;
5387 if(nbOfComp>nbOfComp2)
5389 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
5394 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
5399 ret=DataArrayDouble::New();
5400 ret->alloc(nbOfTuple,nbOfCompMax);
5401 const double *aMinPtr=aMin->getConstPointer();
5402 const double *aMaxPtr=aMax->getConstPointer();
5403 double *res=ret->getPointer();
5404 for(int i=0;i<nbOfTuple;i++)
5405 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::multiplies<double>(),aMinPtr[i]));
5406 ret->copyStringInfoFrom(*aMax);
5409 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
5412 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
5414 if(nbOfComp==nbOfComp2)
5416 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
5417 const DataArrayDouble *aMin=nbOfTuple>nbOfTuple2?a2:a1;
5418 const DataArrayDouble *aMax=nbOfTuple>nbOfTuple2?a1:a2;
5419 const double *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
5420 ret=DataArrayDouble::New();
5421 ret->alloc(nbOfTupleMax,nbOfComp);
5422 double *res=ret->getPointer();
5423 for(int i=0;i<nbOfTupleMax;i++)
5424 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::multiplies<double>());
5425 ret->copyStringInfoFrom(*aMax);
5428 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
5431 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Multiply !");
5436 * Multiply values of another DataArrayDouble to values of \a this one. There are 3
5438 * 1. The arrays have same number of tuples and components. Then each value of
5439 * \a other array is multiplied to the corresponding value of \a this array, i.e.
5440 * _this_ [ i, j ] *= _other_ [ i, j ].
5441 * 2. The arrays have same number of tuples and \a other array has one component. Then
5442 * _this_ [ i, j ] *= _other_ [ i, 0 ].
5443 * 3. The arrays have same number of components and \a other array has one tuple. Then
5444 * _this_ [ i, j ] *= _a2_ [ 0, j ].
5446 * \param [in] other - an array to multiply to \a this one.
5447 * \throw If \a other is NULL.
5448 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
5449 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
5450 * \a other has number of both tuples and components not equal to 1.
5452 void DataArrayDouble::multiplyEqual(const DataArrayDouble *other)
5455 throw INTERP_KERNEL::Exception("DataArrayDouble::multiplyEqual : input DataArrayDouble instance is NULL !");
5456 const char *msg="Nb of tuples mismatch for DataArrayDouble::multiplyEqual !";
5458 other->checkAllocated();
5459 int nbOfTuple=getNumberOfTuples();
5460 int nbOfTuple2=other->getNumberOfTuples();
5461 int nbOfComp=getNumberOfComponents();
5462 int nbOfComp2=other->getNumberOfComponents();
5463 if(nbOfTuple==nbOfTuple2)
5465 if(nbOfComp==nbOfComp2)
5467 std::transform(begin(),end(),other->begin(),getPointer(),std::multiplies<double>());
5469 else if(nbOfComp2==1)
5471 double *ptr=getPointer();
5472 const double *ptrc=other->getConstPointer();
5473 for(int i=0;i<nbOfTuple;i++)
5474 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::multiplies<double>(),*ptrc++));
5477 throw INTERP_KERNEL::Exception(msg);
5479 else if(nbOfTuple2==1)
5481 if(nbOfComp2==nbOfComp)
5483 double *ptr=getPointer();
5484 const double *ptrc=other->getConstPointer();
5485 for(int i=0;i<nbOfTuple;i++)
5486 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::multiplies<double>());
5489 throw INTERP_KERNEL::Exception(msg);
5492 throw INTERP_KERNEL::Exception(msg);
5497 * Returns a new DataArrayDouble that is a division of two given arrays. There are 3
5499 * 1. The arrays have same number of tuples and components. Then each value of
5500 * the result array (_a_) is a division of the corresponding values of \a a1 and
5501 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, j ].
5502 * 2. The arrays have same number of tuples and one array, say _a2_, has one
5504 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, 0 ].
5505 * 3. The arrays have same number of components and one array, say _a2_, has one
5507 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ 0, j ].
5509 * Info on components is copied either from the first array (in the first case) or from
5510 * the array with maximal number of elements (getNbOfElems()).
5511 * \warning No check of division by zero is performed!
5512 * \param [in] a1 - a numerator array.
5513 * \param [in] a2 - a denominator array.
5514 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5515 * The caller is to delete this result array using decrRef() as it is no more
5517 * \throw If either \a a1 or \a a2 is NULL.
5518 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
5519 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
5520 * none of them has number of tuples or components equal to 1.
5522 DataArrayDouble *DataArrayDouble::Divide(const DataArrayDouble *a1, const DataArrayDouble *a2)
5525 throw INTERP_KERNEL::Exception("DataArrayDouble::Divide : input DataArrayDouble instance is NULL !");
5526 int nbOfTuple1=a1->getNumberOfTuples();
5527 int nbOfTuple2=a2->getNumberOfTuples();
5528 int nbOfComp1=a1->getNumberOfComponents();
5529 int nbOfComp2=a2->getNumberOfComponents();
5530 if(nbOfTuple2==nbOfTuple1)
5532 if(nbOfComp1==nbOfComp2)
5534 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5535 ret->alloc(nbOfTuple2,nbOfComp1);
5536 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::divides<double>());
5537 ret->copyStringInfoFrom(*a1);
5540 else if(nbOfComp2==1)
5542 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5543 ret->alloc(nbOfTuple1,nbOfComp1);
5544 const double *a2Ptr=a2->getConstPointer();
5545 const double *a1Ptr=a1->getConstPointer();
5546 double *res=ret->getPointer();
5547 for(int i=0;i<nbOfTuple1;i++)
5548 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::divides<double>(),a2Ptr[i]));
5549 ret->copyStringInfoFrom(*a1);
5554 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
5558 else if(nbOfTuple2==1)
5560 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
5561 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5562 ret->alloc(nbOfTuple1,nbOfComp1);
5563 const double *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
5564 double *pt=ret->getPointer();
5565 for(int i=0;i<nbOfTuple1;i++)
5566 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::divides<double>());
5567 ret->copyStringInfoFrom(*a1);
5572 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Divide !");//will always throw an exception
5578 * Divide values of \a this array by values of another DataArrayDouble. There are 3
5580 * 1. The arrays have same number of tuples and components. Then each value of
5581 * \a this array is divided by the corresponding value of \a other one, i.e.:
5582 * _a_ [ i, j ] /= _other_ [ i, j ].
5583 * 2. The arrays have same number of tuples and \a other array has one component. Then
5584 * _a_ [ i, j ] /= _other_ [ i, 0 ].
5585 * 3. The arrays have same number of components and \a other array has one tuple. Then
5586 * _a_ [ i, j ] /= _a2_ [ 0, j ].
5588 * \warning No check of division by zero is performed!
5589 * \param [in] other - an array to divide \a this one by.
5590 * \throw If \a other is NULL.
5591 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
5592 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
5593 * \a other has number of both tuples and components not equal to 1.
5595 void DataArrayDouble::divideEqual(const DataArrayDouble *other)
5598 throw INTERP_KERNEL::Exception("DataArrayDouble::divideEqual : input DataArrayDouble instance is NULL !");
5599 const char *msg="Nb of tuples mismatch for DataArrayDouble::divideEqual !";
5601 other->checkAllocated();
5602 int nbOfTuple=getNumberOfTuples();
5603 int nbOfTuple2=other->getNumberOfTuples();
5604 int nbOfComp=getNumberOfComponents();
5605 int nbOfComp2=other->getNumberOfComponents();
5606 if(nbOfTuple==nbOfTuple2)
5608 if(nbOfComp==nbOfComp2)
5610 std::transform(begin(),end(),other->begin(),getPointer(),std::divides<double>());
5612 else if(nbOfComp2==1)
5614 double *ptr=getPointer();
5615 const double *ptrc=other->getConstPointer();
5616 for(int i=0;i<nbOfTuple;i++)
5617 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::divides<double>(),*ptrc++));
5620 throw INTERP_KERNEL::Exception(msg);
5622 else if(nbOfTuple2==1)
5624 if(nbOfComp2==nbOfComp)
5626 double *ptr=getPointer();
5627 const double *ptrc=other->getConstPointer();
5628 for(int i=0;i<nbOfTuple;i++)
5629 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::divides<double>());
5632 throw INTERP_KERNEL::Exception(msg);
5635 throw INTERP_KERNEL::Exception(msg);
5640 * Returns a new DataArrayDouble that is the result of pow of two given arrays. There are 3
5643 * \param [in] a1 - an array to pow up.
5644 * \param [in] a2 - another array to sum up.
5645 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5646 * The caller is to delete this result array using decrRef() as it is no more
5648 * \throw If either \a a1 or \a a2 is NULL.
5649 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
5650 * \throw If \a a1->getNumberOfComponents() != 1 or \a a2->getNumberOfComponents() != 1.
5651 * \throw If there is a negative value in \a a1.
5653 DataArrayDouble *DataArrayDouble::Pow(const DataArrayDouble *a1, const DataArrayDouble *a2)
5656 throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : at least one of input instances is null !");
5657 int nbOfTuple=a1->getNumberOfTuples();
5658 int nbOfTuple2=a2->getNumberOfTuples();
5659 int nbOfComp=a1->getNumberOfComponents();
5660 int nbOfComp2=a2->getNumberOfComponents();
5661 if(nbOfTuple!=nbOfTuple2)
5662 throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : number of tuples mismatches !");
5663 if(nbOfComp!=1 || nbOfComp2!=1)
5664 throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : number of components of both arrays must be equal to 1 !");
5665 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(nbOfTuple,1);
5666 const double *ptr1(a1->begin()),*ptr2(a2->begin());
5667 double *ptr=ret->getPointer();
5668 for(int i=0;i<nbOfTuple;i++,ptr1++,ptr2++,ptr++)
5672 *ptr=pow(*ptr1,*ptr2);
5676 std::ostringstream oss; oss << "DataArrayDouble::Pow : on tuple #" << i << " of a1 value is < 0 (" << *ptr1 << ") !";
5677 throw INTERP_KERNEL::Exception(oss.str().c_str());
5684 * Apply pow on values of another DataArrayDouble to values of \a this one.
5686 * \param [in] other - an array to pow to \a this one.
5687 * \throw If \a other is NULL.
5688 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples()
5689 * \throw If \a this->getNumberOfComponents() != 1 or \a other->getNumberOfComponents() != 1
5690 * \throw If there is a negative value in \a this.
5692 void DataArrayDouble::powEqual(const DataArrayDouble *other)
5695 throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : input instance is null !");
5696 int nbOfTuple=getNumberOfTuples();
5697 int nbOfTuple2=other->getNumberOfTuples();
5698 int nbOfComp=getNumberOfComponents();
5699 int nbOfComp2=other->getNumberOfComponents();
5700 if(nbOfTuple!=nbOfTuple2)
5701 throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : number of tuples mismatches !");
5702 if(nbOfComp!=1 || nbOfComp2!=1)
5703 throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : number of components of both arrays must be equal to 1 !");
5704 double *ptr=getPointer();
5705 const double *ptrc=other->begin();
5706 for(int i=0;i<nbOfTuple;i++,ptrc++,ptr++)
5709 *ptr=pow(*ptr,*ptrc);
5712 std::ostringstream oss; oss << "DataArrayDouble::powEqual : on tuple #" << i << " of this value is < 0 (" << *ptr << ") !";
5713 throw INTERP_KERNEL::Exception(oss.str().c_str());
5720 * This method is \b NOT wrapped into python because it can be useful only for performance reasons in C++ context.
5721 * All values in \a this must be 0. or 1. within eps error. 0 means false, 1 means true.
5722 * If an another value than 0 or 1 appear (within eps precision) an INTERP_KERNEL::Exception will be thrown.
5724 * \throw if \a this is not allocated.
5725 * \throw if \a this has not exactly one component.
5727 std::vector<bool> DataArrayDouble::toVectorOfBool(double eps) const
5730 if(getNumberOfComponents()!=1)
5731 throw INTERP_KERNEL::Exception("DataArrayDouble::toVectorOfBool : must be applied on single component array !");
5732 int nbt(getNumberOfTuples());
5733 std::vector<bool> ret(nbt);
5734 const double *pt(begin());
5735 for(int i=0;i<nbt;i++)
5739 else if(fabs(pt[i]-1.)<eps)
5743 std::ostringstream oss; oss << "DataArrayDouble::toVectorOfBool : the tuple #" << i << " has value " << pt[i] << " is invalid ! must be 0. or 1. !";
5744 throw INTERP_KERNEL::Exception(oss.str().c_str());
5751 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5754 void DataArrayDouble::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
5759 tinyInfo[0]=getNumberOfTuples();
5760 tinyInfo[1]=getNumberOfComponents();
5770 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5773 void DataArrayDouble::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
5777 int nbOfCompo=getNumberOfComponents();
5778 tinyInfo.resize(nbOfCompo+1);
5779 tinyInfo[0]=getName();
5780 for(int i=0;i<nbOfCompo;i++)
5781 tinyInfo[i+1]=getInfoOnComponent(i);
5786 tinyInfo[0]=getName();
5791 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5792 * This method returns if a feeding is needed.
5794 bool DataArrayDouble::resizeForUnserialization(const std::vector<int>& tinyInfoI)
5796 int nbOfTuple=tinyInfoI[0];
5797 int nbOfComp=tinyInfoI[1];
5798 if(nbOfTuple!=-1 || nbOfComp!=-1)
5800 alloc(nbOfTuple,nbOfComp);
5807 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5809 void DataArrayDouble::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<std::string>& tinyInfoS)
5811 setName(tinyInfoS[0]);
5814 int nbOfCompo=getNumberOfComponents();
5815 for(int i=0;i<nbOfCompo;i++)
5816 setInfoOnComponent(i,tinyInfoS[i+1]);
5820 DataArrayDoubleIterator::DataArrayDoubleIterator(DataArrayDouble *da):_da(da),_tuple_id(0),_nb_comp(0),_nb_tuple(0)
5825 if(_da->isAllocated())
5827 _nb_comp=da->getNumberOfComponents();
5828 _nb_tuple=da->getNumberOfTuples();
5829 _pt=da->getPointer();
5834 DataArrayDoubleIterator::~DataArrayDoubleIterator()
5840 DataArrayDoubleTuple *DataArrayDoubleIterator::nextt()
5842 if(_tuple_id<_nb_tuple)
5845 DataArrayDoubleTuple *ret=new DataArrayDoubleTuple(_pt,_nb_comp);
5853 DataArrayDoubleTuple::DataArrayDoubleTuple(double *pt, int nbOfComp):_pt(pt),_nb_of_compo(nbOfComp)
5858 std::string DataArrayDoubleTuple::repr() const
5860 std::ostringstream oss; oss.precision(17); oss << "(";
5861 for(int i=0;i<_nb_of_compo-1;i++)
5862 oss << _pt[i] << ", ";
5863 oss << _pt[_nb_of_compo-1] << ")";
5867 double DataArrayDoubleTuple::doubleValue() const
5871 throw INTERP_KERNEL::Exception("DataArrayDoubleTuple::doubleValue : DataArrayDoubleTuple instance has not exactly 1 component -> Not possible to convert it into a double precision float !");
5875 * This method returns a newly allocated instance the caller should dealed with by a ParaMEDMEM::DataArrayDouble::decrRef.
5876 * This method performs \b no copy of data. The content is only referenced using ParaMEDMEM::DataArrayDouble::useArray with ownership set to \b false.
5877 * 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
5878 * \b nbOfCompo=1 and \bnbOfTuples==this->_nb_of_elem.
5880 DataArrayDouble *DataArrayDoubleTuple::buildDADouble(int nbOfTuples, int nbOfCompo) const
5882 if((_nb_of_compo==nbOfCompo && nbOfTuples==1) || (_nb_of_compo==nbOfTuples && nbOfCompo==1))
5884 DataArrayDouble *ret=DataArrayDouble::New();
5885 ret->useExternalArrayWithRWAccess(_pt,nbOfTuples,nbOfCompo);
5890 std::ostringstream oss; oss << "DataArrayDoubleTuple::buildDADouble : unable to build a requested DataArrayDouble instance with nbofTuple=" << nbOfTuples << " and nbOfCompo=" << nbOfCompo;
5891 oss << ".\nBecause the number of elements in this is " << _nb_of_compo << " !";
5892 throw INTERP_KERNEL::Exception(oss.str().c_str());
5897 * Returns a new instance of DataArrayInt. The caller is to delete this array
5898 * using decrRef() as it is no more needed.
5900 DataArrayInt *DataArrayInt::New()
5902 return new DataArrayInt;
5906 * Checks if raw data is allocated. Read more on the raw data
5907 * in \ref MEDCouplingArrayBasicsTuplesAndCompo "DataArrays infos" for more information.
5908 * \return bool - \a true if the raw data is allocated, \a false else.
5910 bool DataArrayInt::isAllocated() const
5912 return getConstPointer()!=0;
5916 * Checks if raw data is allocated and throws an exception if it is not the case.
5917 * \throw If the raw data is not allocated.
5919 void DataArrayInt::checkAllocated() const
5922 throw INTERP_KERNEL::Exception("DataArrayInt::checkAllocated : Array is defined but not allocated ! Call alloc or setValues method first !");
5926 * This method desallocated \a this without modification of informations relative to the components.
5927 * After call of this method, DataArrayInt::isAllocated will return false.
5928 * If \a this is already not allocated, \a this is let unchanged.
5930 void DataArrayInt::desallocate()
5935 std::size_t DataArrayInt::getHeapMemorySizeWithoutChildren() const
5937 std::size_t sz(_mem.getNbOfElemAllocated());
5939 return DataArray::getHeapMemorySizeWithoutChildren()+sz;
5943 * Returns the only one value in \a this, if and only if number of elements
5944 * (nb of tuples * nb of components) is equal to 1, and that \a this is allocated.
5945 * \return double - the sole value stored in \a this array.
5946 * \throw If at least one of conditions stated above is not fulfilled.
5948 int DataArrayInt::intValue() const
5952 if(getNbOfElems()==1)
5954 return *getConstPointer();
5957 throw INTERP_KERNEL::Exception("DataArrayInt::intValue : DataArrayInt instance is allocated but number of elements is not equal to 1 !");
5960 throw INTERP_KERNEL::Exception("DataArrayInt::intValue : DataArrayInt instance is not allocated !");
5964 * Returns an integer value characterizing \a this array, which is useful for a quick
5965 * comparison of many instances of DataArrayInt.
5966 * \return int - the hash value.
5967 * \throw If \a this is not allocated.
5969 int DataArrayInt::getHashCode() const
5972 std::size_t nbOfElems=getNbOfElems();
5973 int ret=nbOfElems*65536;
5978 const int *pt=begin();
5979 for(std::size_t i=0;i<nbOfElems;i+=delta)
5980 ret0+=pt[i] & 0x1FFF;
5985 * Checks the number of tuples.
5986 * \return bool - \a true if getNumberOfTuples() == 0, \a false else.
5987 * \throw If \a this is not allocated.
5989 bool DataArrayInt::empty() const
5992 return getNumberOfTuples()==0;
5996 * Returns a full copy of \a this. For more info on copying data arrays see
5997 * \ref MEDCouplingArrayBasicsCopyDeep.
5998 * \return DataArrayInt * - a new instance of DataArrayInt.
6000 DataArrayInt *DataArrayInt::deepCpy() const
6002 return new DataArrayInt(*this);
6006 * Returns either a \a deep or \a shallow copy of this array. For more info see
6007 * \ref MEDCouplingArrayBasicsCopyDeep and \ref MEDCouplingArrayBasicsCopyShallow.
6008 * \param [in] dCpy - if \a true, a deep copy is returned, else, a shallow one.
6009 * \return DataArrayInt * - either a new instance of DataArrayInt (if \a dCpy
6010 * == \a true) or \a this instance (if \a dCpy == \a false).
6012 DataArrayInt *DataArrayInt::performCpy(bool dCpy) const
6019 return const_cast<DataArrayInt *>(this);
6024 * Copies all the data from another DataArrayInt. For more info see
6025 * \ref MEDCouplingArrayBasicsCopyDeepAssign.
6026 * \param [in] other - another instance of DataArrayInt to copy data from.
6027 * \throw If the \a other is not allocated.
6029 void DataArrayInt::cpyFrom(const DataArrayInt& other)
6031 other.checkAllocated();
6032 int nbOfTuples=other.getNumberOfTuples();
6033 int nbOfComp=other.getNumberOfComponents();
6034 allocIfNecessary(nbOfTuples,nbOfComp);
6035 std::size_t nbOfElems=(std::size_t)nbOfTuples*nbOfComp;
6036 int *pt=getPointer();
6037 const int *ptI=other.getConstPointer();
6038 for(std::size_t i=0;i<nbOfElems;i++)
6040 copyStringInfoFrom(other);
6044 * This method reserve nbOfElems elements in memory ( nbOfElems*4 bytes ) \b without impacting the number of tuples in \a this.
6045 * 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.
6046 * If \a this has not already been allocated, number of components is set to one.
6047 * This method allows to reduce number of reallocations on invokation of DataArrayInt::pushBackSilent and DataArrayInt::pushBackValsSilent on \a this.
6049 * \sa DataArrayInt::pack, DataArrayInt::pushBackSilent, DataArrayInt::pushBackValsSilent
6051 void DataArrayInt::reserve(std::size_t nbOfElems)
6053 int nbCompo=getNumberOfComponents();
6056 _mem.reserve(nbOfElems);
6060 _mem.reserve(nbOfElems);
6061 _info_on_compo.resize(1);
6064 throw INTERP_KERNEL::Exception("DataArrayInt::reserve : not available for DataArrayInt with number of components different than 1 !");
6068 * 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
6069 * of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
6071 * \param [in] val the value to be added in \a this
6072 * \throw If \a this has already been allocated with number of components different from one.
6073 * \sa DataArrayInt::pushBackValsSilent
6075 void DataArrayInt::pushBackSilent(int val)
6077 int nbCompo=getNumberOfComponents();
6082 _info_on_compo.resize(1);
6086 throw INTERP_KERNEL::Exception("DataArrayInt::pushBackSilent : not available for DataArrayInt with number of components different than 1 !");
6090 * 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
6091 * of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
6093 * \param [in] valsBg - an array of values to push at the end of \this.
6094 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
6095 * the last value of \a valsBg is \a valsEnd[ -1 ].
6096 * \throw If \a this has already been allocated with number of components different from one.
6097 * \sa DataArrayInt::pushBackSilent
6099 void DataArrayInt::pushBackValsSilent(const int *valsBg, const int *valsEnd)
6101 int nbCompo=getNumberOfComponents();
6103 _mem.insertAtTheEnd(valsBg,valsEnd);
6106 _info_on_compo.resize(1);
6107 _mem.insertAtTheEnd(valsBg,valsEnd);
6110 throw INTERP_KERNEL::Exception("DataArrayInt::pushBackValsSilent : not available for DataArrayInt with number of components different than 1 !");
6114 * This method returns silently ( without updating time label in \a this ) the last value, if any and suppress it.
6115 * \throw If \a this is already empty.
6116 * \throw If \a this has number of components different from one.
6118 int DataArrayInt::popBackSilent()
6120 if(getNumberOfComponents()==1)
6121 return _mem.popBack();
6123 throw INTERP_KERNEL::Exception("DataArrayInt::popBackSilent : not available for DataArrayInt with number of components different than 1 !");
6127 * 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.
6129 * \sa DataArrayInt::getHeapMemorySizeWithoutChildren, DataArrayInt::reserve
6131 void DataArrayInt::pack() const
6137 * Allocates the raw data in memory. If exactly as same memory as needed already
6138 * allocated, it is not re-allocated.
6139 * \param [in] nbOfTuple - number of tuples of data to allocate.
6140 * \param [in] nbOfCompo - number of components of data to allocate.
6141 * \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
6143 void DataArrayInt::allocIfNecessary(int nbOfTuple, int nbOfCompo)
6147 if(nbOfTuple!=getNumberOfTuples() || nbOfCompo!=getNumberOfComponents())
6148 alloc(nbOfTuple,nbOfCompo);
6151 alloc(nbOfTuple,nbOfCompo);
6155 * Allocates the raw data in memory. If the memory was already allocated, then it is
6156 * freed and re-allocated. See an example of this method use
6157 * \ref MEDCouplingArraySteps1WC "here".
6158 * \param [in] nbOfTuple - number of tuples of data to allocate.
6159 * \param [in] nbOfCompo - number of components of data to allocate.
6160 * \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
6162 void DataArrayInt::alloc(int nbOfTuple, int nbOfCompo)
6164 if(nbOfTuple<0 || nbOfCompo<0)
6165 throw INTERP_KERNEL::Exception("DataArrayInt::alloc : request for negative length of data !");
6166 _info_on_compo.resize(nbOfCompo);
6167 _mem.alloc(nbOfCompo*(std::size_t)nbOfTuple);
6172 * Assign zero to all values in \a this array. To know more on filling arrays see
6173 * \ref MEDCouplingArrayFill.
6174 * \throw If \a this is not allocated.
6176 void DataArrayInt::fillWithZero()
6179 _mem.fillWithValue(0);
6184 * Assign \a val to all values in \a this array. To know more on filling arrays see
6185 * \ref MEDCouplingArrayFill.
6186 * \param [in] val - the value to fill with.
6187 * \throw If \a this is not allocated.
6189 void DataArrayInt::fillWithValue(int val)
6192 _mem.fillWithValue(val);
6197 * Set all values in \a this array so that the i-th element equals to \a init + i
6198 * (i starts from zero). To know more on filling arrays see \ref MEDCouplingArrayFill.
6199 * \param [in] init - value to assign to the first element of array.
6200 * \throw If \a this->getNumberOfComponents() != 1
6201 * \throw If \a this is not allocated.
6203 void DataArrayInt::iota(int init)
6206 if(getNumberOfComponents()!=1)
6207 throw INTERP_KERNEL::Exception("DataArrayInt::iota : works only for arrays with only one component, you can call 'rearrange' method before !");
6208 int *ptr=getPointer();
6209 int ntuples=getNumberOfTuples();
6210 for(int i=0;i<ntuples;i++)
6216 * Returns a textual and human readable representation of \a this instance of
6217 * DataArrayInt. This text is shown when a DataArrayInt is printed in Python.
6218 * \return std::string - text describing \a this DataArrayInt.
6220 * \sa reprNotTooLong, reprZip
6222 std::string DataArrayInt::repr() const
6224 std::ostringstream ret;
6229 std::string DataArrayInt::reprZip() const
6231 std::ostringstream ret;
6237 * This method is close to repr method except that when \a this has more than 1000 tuples, all tuples are not
6238 * printed out to avoid to consume too much space in interpretor.
6241 std::string DataArrayInt::reprNotTooLong() const
6243 std::ostringstream ret;
6244 reprNotTooLongStream(ret);
6248 void DataArrayInt::writeVTK(std::ostream& ofs, int indent, const std::string& type, const std::string& nameInFile, DataArrayByte *byteArr) const
6250 static const char SPACE[4]={' ',' ',' ',' '};
6252 std::string idt(indent,' ');
6253 ofs << idt << "<DataArray type=\"" << type << "\" Name=\"" << nameInFile << "\" NumberOfComponents=\"" << getNumberOfComponents() << "\"";
6256 ofs << " format=\"appended\" offset=\"" << byteArr->getNumberOfTuples() << "\">";
6257 if(std::string(type)=="Int32")
6259 const char *data(reinterpret_cast<const char *>(begin()));
6260 std::size_t sz(getNbOfElems()*sizeof(int));
6261 byteArr->insertAtTheEnd(data,data+sz);
6262 byteArr->insertAtTheEnd(SPACE,SPACE+4);
6264 else if(std::string(type)=="Int8")
6266 INTERP_KERNEL::AutoPtr<char> tmp(new char[getNbOfElems()]);
6267 std::copy(begin(),end(),(char *)tmp);
6268 byteArr->insertAtTheEnd((char *)tmp,(char *)tmp+getNbOfElems());
6269 byteArr->insertAtTheEnd(SPACE,SPACE+4);
6271 else if(std::string(type)=="UInt8")
6273 INTERP_KERNEL::AutoPtr<unsigned char> tmp(new unsigned char[getNbOfElems()]);
6274 std::copy(begin(),end(),(unsigned char *)tmp);
6275 byteArr->insertAtTheEnd((unsigned char *)tmp,(unsigned char *)tmp+getNbOfElems());
6276 byteArr->insertAtTheEnd(SPACE,SPACE+4);
6279 throw INTERP_KERNEL::Exception("DataArrayInt::writeVTK : Only Int32, Int8 and UInt8 supported !");
6283 ofs << " RangeMin=\"" << getMinValueInArray() << "\" RangeMax=\"" << getMaxValueInArray() << "\" format=\"ascii\">\n" << idt;
6284 std::copy(begin(),end(),std::ostream_iterator<int>(ofs," "));
6286 ofs << std::endl << idt << "</DataArray>\n";
6289 void DataArrayInt::reprStream(std::ostream& stream) const
6291 stream << "Name of int array : \"" << _name << "\"\n";
6292 reprWithoutNameStream(stream);
6295 void DataArrayInt::reprZipStream(std::ostream& stream) const
6297 stream << "Name of int array : \"" << _name << "\"\n";
6298 reprZipWithoutNameStream(stream);
6301 void DataArrayInt::reprNotTooLongStream(std::ostream& stream) const
6303 stream << "Name of int array : \"" << _name << "\"\n";
6304 reprNotTooLongWithoutNameStream(stream);
6307 void DataArrayInt::reprWithoutNameStream(std::ostream& stream) const
6309 DataArray::reprWithoutNameStream(stream);
6310 _mem.repr(getNumberOfComponents(),stream);
6313 void DataArrayInt::reprZipWithoutNameStream(std::ostream& stream) const
6315 DataArray::reprWithoutNameStream(stream);
6316 _mem.reprZip(getNumberOfComponents(),stream);
6319 void DataArrayInt::reprNotTooLongWithoutNameStream(std::ostream& stream) const
6321 DataArray::reprWithoutNameStream(stream);
6322 stream.precision(17);
6323 _mem.reprNotTooLong(getNumberOfComponents(),stream);
6326 void DataArrayInt::reprCppStream(const std::string& varName, std::ostream& stream) const
6328 int nbTuples=getNumberOfTuples(),nbComp=getNumberOfComponents();
6329 const int *data=getConstPointer();
6330 stream << "DataArrayInt *" << varName << "=DataArrayInt::New();" << std::endl;
6331 if(nbTuples*nbComp>=1)
6333 stream << "const int " << varName << "Data[" << nbTuples*nbComp << "]={";
6334 std::copy(data,data+nbTuples*nbComp-1,std::ostream_iterator<int>(stream,","));
6335 stream << data[nbTuples*nbComp-1] << "};" << std::endl;
6336 stream << varName << "->useArray(" << varName << "Data,false,CPP_DEALLOC," << nbTuples << "," << nbComp << ");" << std::endl;
6339 stream << varName << "->alloc(" << nbTuples << "," << nbComp << ");" << std::endl;
6340 stream << varName << "->setName(\"" << getName() << "\");" << std::endl;
6344 * Method that gives a quick overvien of \a this for python.
6346 void DataArrayInt::reprQuickOverview(std::ostream& stream) const
6348 static const std::size_t MAX_NB_OF_BYTE_IN_REPR=300;
6349 stream << "DataArrayInt C++ instance at " << this << ". ";
6352 int nbOfCompo=(int)_info_on_compo.size();
6355 int nbOfTuples=getNumberOfTuples();
6356 stream << "Number of tuples : " << nbOfTuples << ". Number of components : " << nbOfCompo << "." << std::endl;
6357 reprQuickOverviewData(stream,MAX_NB_OF_BYTE_IN_REPR);
6360 stream << "Number of components : 0.";
6363 stream << "*** No data allocated ****";
6366 void DataArrayInt::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const
6368 const int *data=begin();
6369 int nbOfTuples=getNumberOfTuples();
6370 int nbOfCompo=(int)_info_on_compo.size();
6371 std::ostringstream oss2; oss2 << "[";
6372 std::string oss2Str(oss2.str());
6373 bool isFinished=true;
6374 for(int i=0;i<nbOfTuples && isFinished;i++)
6379 for(int j=0;j<nbOfCompo;j++,data++)
6382 if(j!=nbOfCompo-1) oss2 << ", ";
6388 if(i!=nbOfTuples-1) oss2 << ", ";
6389 std::string oss3Str(oss2.str());
6390 if(oss3Str.length()<maxNbOfByteInRepr)
6402 * Modifies in place \a this one-dimensional array so that each value \a v = \a indArrBg[ \a v ],
6403 * i.e. a current value is used as in index to get a new value from \a indArrBg.
6404 * \param [in] indArrBg - pointer to the first element of array of new values to assign
6406 * \param [in] indArrEnd - specifies the end of the array \a indArrBg, so that
6407 * the last value of \a indArrBg is \a indArrEnd[ -1 ].
6408 * \throw If \a this->getNumberOfComponents() != 1
6409 * \throw If any value of \a this can't be used as a valid index for
6410 * [\a indArrBg, \a indArrEnd).
6412 * \sa replaceOneValByInThis
6414 void DataArrayInt::transformWithIndArr(const int *indArrBg, const int *indArrEnd)
6417 if(getNumberOfComponents()!=1)
6418 throw INTERP_KERNEL::Exception("Call transformWithIndArr method on DataArrayInt with only one component, you can call 'rearrange' method before !");
6419 int nbElemsIn((int)std::distance(indArrBg,indArrEnd)),nbOfTuples(getNumberOfTuples()),*pt(getPointer());
6420 for(int i=0;i<nbOfTuples;i++,pt++)
6422 if(*pt>=0 && *pt<nbElemsIn)
6426 std::ostringstream oss; oss << "DataArrayInt::transformWithIndArr : error on tuple #" << i << " of this value is " << *pt << ", should be in [0," << nbElemsIn << ") !";
6427 throw INTERP_KERNEL::Exception(oss.str().c_str());
6434 * Modifies in place \a this one-dimensional array like this : each id in \a this so that this[id] equal to \a valToBeReplaced will be replaced at the same place by \a replacedBy.
6436 * \param [in] valToBeReplaced - the value in \a this to be replaced.
6437 * \param [in] replacedBy - the value taken by each tuple previously equal to \a valToBeReplaced.
6439 * \sa DataArrayInt::transformWithIndArr
6441 void DataArrayInt::replaceOneValByInThis(int valToBeReplaced, int replacedBy)
6444 if(getNumberOfComponents()!=1)
6445 throw INTERP_KERNEL::Exception("Call replaceOneValByInThis method on DataArrayInt with only one component, you can call 'rearrange' method before !");
6446 if(valToBeReplaced==replacedBy)
6448 int nbOfTuples(getNumberOfTuples()),*pt(getPointer());
6449 for(int i=0;i<nbOfTuples;i++,pt++)
6451 if(*pt==valToBeReplaced)
6457 * Computes distribution of values of \a this one-dimensional array between given value
6458 * ranges (casts). This method is typically useful for entity number spliting by types,
6460 * \warning The values contained in \a arrBg should be sorted ascendently. No
6461 * check of this is be done. If not, the result is not warranted.
6462 * \param [in] arrBg - the array of ascending values defining the value ranges. The i-th
6463 * value of \a arrBg (\a arrBg[ i ]) gives the lowest value of the i-th range,
6464 * and the greatest value of the i-th range equals to \a arrBg[ i+1 ] - 1. \a
6465 * arrBg containing \a n values defines \a n-1 ranges. The last value of \a arrBg
6466 * should be more than every value in \a this array.
6467 * \param [in] arrEnd - specifies the end of the array \a arrBg, so that
6468 * the last value of \a arrBg is \a arrEnd[ -1 ].
6469 * \param [out] castArr - a new instance of DataArrayInt, of same size as \a this array
6470 * (same number of tuples and components), the caller is to delete
6471 * using decrRef() as it is no more needed.
6472 * This array contains indices of ranges for every value of \a this array. I.e.
6473 * the i-th value of \a castArr gives the index of range the i-th value of \a this
6474 * belongs to. Or, in other words, this parameter contains for each tuple in \a
6475 * this in which cast it holds.
6476 * \param [out] rankInsideCast - a new instance of DataArrayInt, of same size as \a this
6477 * array, the caller is to delete using decrRef() as it is no more needed.
6478 * This array contains ranks of values of \a this array within ranges
6479 * they belongs to. I.e. the i-th value of \a rankInsideCast gives the rank of
6480 * the i-th value of \a this array within the \a castArr[ i ]-th range, to which
6481 * the i-th value of \a this belongs to. Or, in other words, this param contains
6482 * for each tuple its rank inside its cast. The rank is computed as difference
6483 * between the value and the lowest value of range.
6484 * \param [out] castsPresent - a new instance of DataArrayInt, containing indices of
6485 * ranges (casts) to which at least one value of \a this array belongs.
6486 * Or, in other words, this param contains the casts that \a this contains.
6487 * The caller is to delete this array using decrRef() as it is no more needed.
6489 * \b Example: If \a this contains [6,5,0,3,2,7,8,1,4] and \a arrBg contains [0,4,9] then
6490 * the output of this method will be :
6491 * - \a castArr : [1,1,0,0,0,1,1,0,1]
6492 * - \a rankInsideCast: [2,1,0,3,2,3,4,1,0]
6493 * - \a castsPresent : [0,1]
6495 * I.e. values of \a this array belong to 2 ranges: #0 and #1. Value 6 belongs to the
6496 * range #1 and its rank within this range is 2; etc.
6498 * \throw If \a this->getNumberOfComponents() != 1.
6499 * \throw If \a arrEnd - arrBg < 2.
6500 * \throw If any value of \a this is not less than \a arrEnd[-1].
6502 void DataArrayInt::splitByValueRange(const int *arrBg, const int *arrEnd,
6503 DataArrayInt *& castArr, DataArrayInt *& rankInsideCast, DataArrayInt *& castsPresent) const
6506 if(getNumberOfComponents()!=1)
6507 throw INTERP_KERNEL::Exception("Call splitByValueRange method on DataArrayInt with only one component, you can call 'rearrange' method before !");
6508 int nbOfTuples=getNumberOfTuples();
6509 std::size_t nbOfCast=std::distance(arrBg,arrEnd);
6511 throw INTERP_KERNEL::Exception("DataArrayInt::splitByValueRange : The input array giving the cast range values should be of size >=2 !");
6513 const int *work=getConstPointer();
6514 typedef std::reverse_iterator<const int *> rintstart;
6515 rintstart bg(arrEnd);//OK no problem because size of 'arr' is greater or equal 2
6516 rintstart end2(arrBg);
6517 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New();
6518 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret2=DataArrayInt::New();
6519 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret3=DataArrayInt::New();
6520 ret1->alloc(nbOfTuples,1);
6521 ret2->alloc(nbOfTuples,1);
6522 int *ret1Ptr=ret1->getPointer();
6523 int *ret2Ptr=ret2->getPointer();
6524 std::set<std::size_t> castsDetected;
6525 for(int i=0;i<nbOfTuples;i++)
6527 rintstart res=std::find_if(bg,end2,std::bind2nd(std::less_equal<int>(), work[i]));
6528 std::size_t pos=std::distance(bg,res);
6529 std::size_t pos2=nbOfCast-pos;
6532 ret1Ptr[i]=(int)pos2;
6533 ret2Ptr[i]=work[i]-arrBg[pos2];
6534 castsDetected.insert(pos2);
6538 std::ostringstream oss; oss << "DataArrayInt::splitByValueRange : At rank #" << i << " the value is " << work[i] << " should be in [0," << *bg << ") !";
6539 throw INTERP_KERNEL::Exception(oss.str().c_str());
6542 ret3->alloc((int)castsDetected.size(),1);
6543 std::copy(castsDetected.begin(),castsDetected.end(),ret3->getPointer());
6544 castArr=ret1.retn();
6545 rankInsideCast=ret2.retn();
6546 castsPresent=ret3.retn();
6550 * This method look at \a this if it can be considered as a range defined by the 3-tuple ( \a strt , \a sttoopp , \a stteepp ).
6551 * If false is returned the tuple must be ignored. If true is returned \a this can be considered by a range( \a strt , \a sttoopp , \a stteepp ).
6552 * This method works only if \a this is allocated and single component. If not an exception will be thrown.
6554 * \param [out] strt - the start of the range (included) if true is returned.
6555 * \param [out] sttoopp - the end of the range (not included) if true is returned.
6556 * \param [out] stteepp - the step of the range if true is returned.
6557 * \return the verdict of the check.
6559 * \sa DataArray::GetNumberOfItemGivenBES
6561 bool DataArrayInt::isRange(int& strt, int& sttoopp, int& stteepp) const
6564 if(getNumberOfComponents()!=1)
6565 throw INTERP_KERNEL::Exception("DataArrayInt::isRange : this must be single component array !");
6566 int nbTuples(getNumberOfTuples());
6568 { strt=0; sttoopp=0; stteepp=1; return true; }
6569 const int *pt(begin());
6572 { sttoopp=strt+1; stteepp=1; return true; }
6573 strt=*pt; sttoopp=pt[nbTuples-1];
6579 int a(sttoopp-1-strt),tmp(strt);
6580 if(a%(nbTuples-1)!=0)
6582 stteepp=a/(nbTuples-1);
6583 for(int i=0;i<nbTuples;i++,tmp+=stteepp)
6591 int a(strt-sttoopp-1),tmp(strt);
6592 if(a%(nbTuples-1)!=0)
6594 stteepp=-(a/(nbTuples-1));
6595 for(int i=0;i<nbTuples;i++,tmp+=stteepp)
6603 * Creates a one-dimensional DataArrayInt (\a res) whose contents are computed from
6604 * values of \a this (\a a) and the given (\a indArr) arrays as follows:
6605 * \a res[ \a indArr[ \a a[ i ]]] = i. I.e. for each value in place i \a v = \a a[ i ],
6606 * new value in place \a indArr[ \a v ] is i.
6607 * \param [in] indArrBg - the array holding indices within the result array to assign
6608 * indices of values of \a this array pointing to values of \a indArrBg.
6609 * \param [in] indArrEnd - specifies the end of the array \a indArrBg, so that
6610 * the last value of \a indArrBg is \a indArrEnd[ -1 ].
6611 * \return DataArrayInt * - the new instance of DataArrayInt.
6612 * The caller is to delete this result array using decrRef() as it is no more
6614 * \throw If \a this->getNumberOfComponents() != 1.
6615 * \throw If any value of \a this array is not a valid index for \a indArrBg array.
6616 * \throw If any value of \a indArrBg is not a valid index for \a this array.
6618 DataArrayInt *DataArrayInt::transformWithIndArrR(const int *indArrBg, const int *indArrEnd) const
6621 if(getNumberOfComponents()!=1)
6622 throw INTERP_KERNEL::Exception("Call transformWithIndArrR method on DataArrayInt with only one component, you can call 'rearrange' method before !");
6623 int nbElemsIn=(int)std::distance(indArrBg,indArrEnd);
6624 int nbOfTuples=getNumberOfTuples();
6625 const int *pt=getConstPointer();
6626 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6627 ret->alloc(nbOfTuples,1);
6628 ret->fillWithValue(-1);
6629 int *tmp=ret->getPointer();
6630 for(int i=0;i<nbOfTuples;i++,pt++)
6632 if(*pt>=0 && *pt<nbElemsIn)
6634 int pos=indArrBg[*pt];
6635 if(pos>=0 && pos<nbOfTuples)
6639 std::ostringstream oss; oss << "DataArrayInt::transformWithIndArrR : error on tuple #" << i << " value of new pos is " << pos << " ( indArrBg[" << *pt << "]) ! Should be in [0," << nbOfTuples << ") !";
6640 throw INTERP_KERNEL::Exception(oss.str().c_str());
6645 std::ostringstream oss; oss << "DataArrayInt::transformWithIndArrR : error on tuple #" << i << " value is " << *pt << " and indirectionnal array as a size equal to " << nbElemsIn << " !";
6646 throw INTERP_KERNEL::Exception(oss.str().c_str());
6653 * Creates a one-dimensional DataArrayInt of given length, whose contents are computed
6654 * from values of \a this array, which is supposed to contain a renumbering map in
6655 * "Old to New" mode. The result array contains a renumbering map in "New to Old" mode.
6656 * To know how to use the renumbering maps see \ref MEDCouplingArrayRenumbering.
6657 * \param [in] newNbOfElem - the number of tuples in the result array.
6658 * \return DataArrayInt * - the new instance of DataArrayInt.
6659 * The caller is to delete this result array using decrRef() as it is no more
6662 * \if ENABLE_EXAMPLES
6663 * \ref cpp_mcdataarrayint_invertarrayo2n2n2o "Here is a C++ example".<br>
6664 * \ref py_mcdataarrayint_invertarrayo2n2n2o "Here is a Python example".
6667 DataArrayInt *DataArrayInt::invertArrayO2N2N2O(int newNbOfElem) const
6669 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6670 ret->alloc(newNbOfElem,1);
6671 int nbOfOldNodes=getNumberOfTuples();
6672 const int *old2New=getConstPointer();
6673 int *pt=ret->getPointer();
6674 for(int i=0;i!=nbOfOldNodes;i++)
6676 int newp(old2New[i]);
6679 if(newp>=0 && newp<newNbOfElem)
6683 std::ostringstream oss; oss << "DataArrayInt::invertArrayO2N2N2O : At place #" << i << " the newplace is " << newp << " must be in [0," << newNbOfElem << ") !";
6684 throw INTERP_KERNEL::Exception(oss.str().c_str());
6692 * This method is similar to DataArrayInt::invertArrayO2N2N2O except that
6693 * 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]
6695 DataArrayInt *DataArrayInt::invertArrayO2N2N2OBis(int newNbOfElem) const
6697 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6698 ret->alloc(newNbOfElem,1);
6699 int nbOfOldNodes=getNumberOfTuples();
6700 const int *old2New=getConstPointer();
6701 int *pt=ret->getPointer();
6702 for(int i=nbOfOldNodes-1;i>=0;i--)
6704 int newp(old2New[i]);
6707 if(newp>=0 && newp<newNbOfElem)
6711 std::ostringstream oss; oss << "DataArrayInt::invertArrayO2N2N2OBis : At place #" << i << " the newplace is " << newp << " must be in [0," << newNbOfElem << ") !";
6712 throw INTERP_KERNEL::Exception(oss.str().c_str());
6720 * Creates a one-dimensional DataArrayInt of given length, whose contents are computed
6721 * from values of \a this array, which is supposed to contain a renumbering map in
6722 * "New to Old" mode. The result array contains a renumbering map in "Old to New" mode.
6723 * To know how to use the renumbering maps see \ref MEDCouplingArrayRenumbering.
6724 * \param [in] newNbOfElem - the number of tuples in the result array.
6725 * \return DataArrayInt * - the new instance of DataArrayInt.
6726 * The caller is to delete this result array using decrRef() as it is no more
6729 * \if ENABLE_EXAMPLES
6730 * \ref cpp_mcdataarrayint_invertarrayn2o2o2n "Here is a C++ example".
6732 * \ref py_mcdataarrayint_invertarrayn2o2o2n "Here is a Python example".
6735 DataArrayInt *DataArrayInt::invertArrayN2O2O2N(int oldNbOfElem) const
6738 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6739 ret->alloc(oldNbOfElem,1);
6740 const int *new2Old=getConstPointer();
6741 int *pt=ret->getPointer();
6742 std::fill(pt,pt+oldNbOfElem,-1);
6743 int nbOfNewElems=getNumberOfTuples();
6744 for(int i=0;i<nbOfNewElems;i++)
6747 if(v>=0 && v<oldNbOfElem)
6751 std::ostringstream oss; oss << "DataArrayInt::invertArrayN2O2O2N : in new id #" << i << " old value is " << v << " expected to be in [0," << oldNbOfElem << ") !";
6752 throw INTERP_KERNEL::Exception(oss.str().c_str());
6759 * Equivalent to DataArrayInt::isEqual except that if false the reason of
6760 * mismatch is given.
6762 * \param [in] other the instance to be compared with \a this
6763 * \param [out] reason In case of inequality returns the reason.
6764 * \sa DataArrayInt::isEqual
6766 bool DataArrayInt::isEqualIfNotWhy(const DataArrayInt& other, std::string& reason) const
6768 if(!areInfoEqualsIfNotWhy(other,reason))
6770 return _mem.isEqual(other._mem,0,reason);
6774 * Checks if \a this and another DataArrayInt are fully equal. For more info see
6775 * \ref MEDCouplingArrayBasicsCompare.
6776 * \param [in] other - an instance of DataArrayInt to compare with \a this one.
6777 * \return bool - \a true if the two arrays are equal, \a false else.
6779 bool DataArrayInt::isEqual(const DataArrayInt& other) const
6782 return isEqualIfNotWhy(other,tmp);
6786 * Checks if values of \a this and another DataArrayInt are equal. For more info see
6787 * \ref MEDCouplingArrayBasicsCompare.
6788 * \param [in] other - an instance of DataArrayInt to compare with \a this one.
6789 * \return bool - \a true if the values of two arrays are equal, \a false else.
6791 bool DataArrayInt::isEqualWithoutConsideringStr(const DataArrayInt& other) const
6794 return _mem.isEqual(other._mem,0,tmp);
6798 * Checks if values of \a this and another DataArrayInt are equal. Comparison is
6799 * performed on sorted value sequences.
6800 * For more info see\ref MEDCouplingArrayBasicsCompare.
6801 * \param [in] other - an instance of DataArrayInt to compare with \a this one.
6802 * \return bool - \a true if the sorted values of two arrays are equal, \a false else.
6804 bool DataArrayInt::isEqualWithoutConsideringStrAndOrder(const DataArrayInt& other) const
6806 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> a=deepCpy();
6807 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> b=other.deepCpy();
6810 return a->isEqualWithoutConsideringStr(*b);
6814 * This method compares content of input vector \a v and \a this.
6815 * 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.
6816 * For performance reasons \a this is expected to be sorted ascendingly. If not an exception will be thrown.
6818 * \param [in] v - the vector of 'flags' to be compared with \a this.
6820 * \throw If \a this is not sorted ascendingly.
6821 * \throw If \a this has not exactly one component.
6822 * \throw If \a this is not allocated.
6824 bool DataArrayInt::isFittingWith(const std::vector<bool>& v) const
6827 if(getNumberOfComponents()!=1)
6828 throw INTERP_KERNEL::Exception("DataArrayInt::isFittingWith : number of components of this should be equal to one !");
6829 const int *w(begin()),*end2(end());
6830 int refVal=-std::numeric_limits<int>::max();
6832 std::vector<bool>::const_iterator it(v.begin());
6833 for(;it!=v.end();it++,i++)
6845 std::ostringstream oss; oss << "DataArrayInt::isFittingWith : At pos #" << std::distance(begin(),w-1) << " this is not sorted ascendingly !";
6846 throw INTERP_KERNEL::Exception(oss.str().c_str());
6860 * Sorts values of the array.
6861 * \param [in] asc - \a true means ascending order, \a false, descending.
6862 * \throw If \a this is not allocated.
6863 * \throw If \a this->getNumberOfComponents() != 1.
6865 void DataArrayInt::sort(bool asc)
6868 if(getNumberOfComponents()!=1)
6869 throw INTERP_KERNEL::Exception("DataArrayInt::sort : only supported with 'this' array with ONE component !");
6875 * Computes for each tuple the sum of number of components values in the tuple and return it.
6877 * \return DataArrayInt * - the new instance of DataArrayInt containing the
6878 * same number of tuples as \a this array and one component.
6879 * The caller is to delete this result array using decrRef() as it is no more
6881 * \throw If \a this is not allocated.
6883 DataArrayInt *DataArrayInt::sumPerTuple() const
6886 int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
6887 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
6888 ret->alloc(nbOfTuple,1);
6889 const int *src(getConstPointer());
6890 int *dest(ret->getPointer());
6891 for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
6892 *dest=std::accumulate(src,src+nbOfComp,0);
6897 * Reverse the array values.
6898 * \throw If \a this->getNumberOfComponents() < 1.
6899 * \throw If \a this is not allocated.
6901 void DataArrayInt::reverse()
6904 _mem.reverse(getNumberOfComponents());
6909 * Checks that \a this array is consistently **increasing** or **decreasing** in value.
6910 * If not an exception is thrown.
6911 * \param [in] increasing - if \a true, the array values should be increasing.
6912 * \throw If sequence of values is not strictly monotonic in agreement with \a
6914 * \throw If \a this->getNumberOfComponents() != 1.
6915 * \throw If \a this is not allocated.
6917 void DataArrayInt::checkMonotonic(bool increasing) const
6919 if(!isMonotonic(increasing))
6922 throw INTERP_KERNEL::Exception("DataArrayInt::checkMonotonic : 'this' is not INCREASING monotonic !");
6924 throw INTERP_KERNEL::Exception("DataArrayInt::checkMonotonic : 'this' is not DECREASING monotonic !");
6929 * Checks that \a this array is consistently **increasing** or **decreasing** in value.
6930 * \param [in] increasing - if \a true, array values should be increasing.
6931 * \return bool - \a true if values change in accordance with \a increasing arg.
6932 * \throw If \a this->getNumberOfComponents() != 1.
6933 * \throw If \a this is not allocated.
6935 bool DataArrayInt::isMonotonic(bool increasing) const
6938 if(getNumberOfComponents()!=1)
6939 throw INTERP_KERNEL::Exception("DataArrayInt::isMonotonic : only supported with 'this' array with ONE component !");
6940 int nbOfElements=getNumberOfTuples();
6941 const int *ptr=getConstPointer();
6947 for(int i=1;i<nbOfElements;i++)
6957 for(int i=1;i<nbOfElements;i++)
6969 * This method check that array consistently INCREASING or DECREASING in value.
6971 bool DataArrayInt::isStrictlyMonotonic(bool increasing) const
6974 if(getNumberOfComponents()!=1)
6975 throw INTERP_KERNEL::Exception("DataArrayInt::isStrictlyMonotonic : only supported with 'this' array with ONE component !");
6976 int nbOfElements=getNumberOfTuples();
6977 const int *ptr=getConstPointer();
6983 for(int i=1;i<nbOfElements;i++)
6993 for(int i=1;i<nbOfElements;i++)
7005 * This method check that array consistently INCREASING or DECREASING in value.
7007 void DataArrayInt::checkStrictlyMonotonic(bool increasing) const
7009 if(!isStrictlyMonotonic(increasing))
7012 throw INTERP_KERNEL::Exception("DataArrayInt::checkStrictlyMonotonic : 'this' is not strictly INCREASING monotonic !");
7014 throw INTERP_KERNEL::Exception("DataArrayInt::checkStrictlyMonotonic : 'this' is not strictly DECREASING monotonic !");
7019 * Creates a new one-dimensional DataArrayInt of the same size as \a this and a given
7020 * one-dimensional arrays that must be of the same length. The result array describes
7021 * correspondence between \a this and \a other arrays, so that
7022 * <em> other.getIJ(i,0) == this->getIJ(ret->getIJ(i),0)</em>. If such a permutation is
7023 * not possible because some element in \a other is not in \a this, an exception is thrown.
7024 * \param [in] other - an array to compute permutation to.
7025 * \return DataArrayInt * - a new instance of DataArrayInt, which is a permutation array
7026 * from \a this to \a other. The caller is to delete this array using decrRef() as it is
7028 * \throw If \a this->getNumberOfComponents() != 1.
7029 * \throw If \a other->getNumberOfComponents() != 1.
7030 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples().
7031 * \throw If \a other includes a value which is not in \a this array.
7033 * \if ENABLE_EXAMPLES
7034 * \ref cpp_mcdataarrayint_buildpermutationarr "Here is a C++ example".
7036 * \ref py_mcdataarrayint_buildpermutationarr "Here is a Python example".
7039 DataArrayInt *DataArrayInt::buildPermutationArr(const DataArrayInt& other) const
7042 if(getNumberOfComponents()!=1 || other.getNumberOfComponents()!=1)
7043 throw INTERP_KERNEL::Exception("DataArrayInt::buildPermutationArr : 'this' and 'other' have to have exactly ONE component !");
7044 int nbTuple=getNumberOfTuples();
7045 other.checkAllocated();
7046 if(nbTuple!=other.getNumberOfTuples())
7047 throw INTERP_KERNEL::Exception("DataArrayInt::buildPermutationArr : 'this' and 'other' must have the same number of tuple !");
7048 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7049 ret->alloc(nbTuple,1);
7050 ret->fillWithValue(-1);
7051 const int *pt=getConstPointer();
7052 std::map<int,int> mm;
7053 for(int i=0;i<nbTuple;i++)
7055 pt=other.getConstPointer();
7056 int *retToFill=ret->getPointer();
7057 for(int i=0;i<nbTuple;i++)
7059 std::map<int,int>::const_iterator it=mm.find(pt[i]);
7062 std::ostringstream oss; oss << "DataArrayInt::buildPermutationArr : Arrays mismatch : element (" << pt[i] << ") in 'other' not findable in 'this' !";
7063 throw INTERP_KERNEL::Exception(oss.str().c_str());
7065 retToFill[i]=(*it).second;
7071 * Sets a C array to be used as raw data of \a this. The previously set info
7072 * of components is retained and re-sized.
7073 * For more info see \ref MEDCouplingArraySteps1.
7074 * \param [in] array - the C array to be used as raw data of \a this.
7075 * \param [in] ownership - if \a true, \a array will be deallocated at destruction of \a this.
7076 * \param [in] type - specifies how to deallocate \a array. If \a type == ParaMEDMEM::CPP_DEALLOC,
7077 * \c delete [] \c array; will be called. If \a type == ParaMEDMEM::C_DEALLOC,
7078 * \c free(\c array ) will be called.
7079 * \param [in] nbOfTuple - new number of tuples in \a this.
7080 * \param [in] nbOfCompo - new number of components in \a this.
7082 void DataArrayInt::useArray(const int *array, bool ownership, DeallocType type, int nbOfTuple, int nbOfCompo)
7084 _info_on_compo.resize(nbOfCompo);
7085 _mem.useArray(array,ownership,type,nbOfTuple*nbOfCompo);
7089 void DataArrayInt::useExternalArrayWithRWAccess(const int *array, int nbOfTuple, int nbOfCompo)
7091 _info_on_compo.resize(nbOfCompo);
7092 _mem.useExternalArrayWithRWAccess(array,nbOfTuple*nbOfCompo);
7097 * Returns a new DataArrayInt holding the same values as \a this array but differently
7098 * arranged in memory. If \a this array holds 2 components of 3 values:
7099 * \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$, then the result array holds these values arranged
7100 * as follows: \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$.
7101 * \warning Do not confuse this method with transpose()!
7102 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7103 * is to delete using decrRef() as it is no more needed.
7104 * \throw If \a this is not allocated.
7106 DataArrayInt *DataArrayInt::fromNoInterlace() const
7110 throw INTERP_KERNEL::Exception("DataArrayInt::fromNoInterlace : Not defined array !");
7111 int *tab=_mem.fromNoInterlace(getNumberOfComponents());
7112 DataArrayInt *ret=DataArrayInt::New();
7113 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
7118 * Returns a new DataArrayInt holding the same values as \a this array but differently
7119 * arranged in memory. If \a this array holds 2 components of 3 values:
7120 * \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$, then the result array holds these values arranged
7121 * as follows: \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$.
7122 * \warning Do not confuse this method with transpose()!
7123 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7124 * is to delete using decrRef() as it is no more needed.
7125 * \throw If \a this is not allocated.
7127 DataArrayInt *DataArrayInt::toNoInterlace() const
7131 throw INTERP_KERNEL::Exception("DataArrayInt::toNoInterlace : Not defined array !");
7132 int *tab=_mem.toNoInterlace(getNumberOfComponents());
7133 DataArrayInt *ret=DataArrayInt::New();
7134 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
7139 * Permutes values of \a this array as required by \a old2New array. The values are
7140 * permuted so that \c new[ \a old2New[ i ]] = \c old[ i ]. Number of tuples remains
7141 * the same as in \this one.
7142 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
7143 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7144 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
7145 * giving a new position for i-th old value.
7147 void DataArrayInt::renumberInPlace(const int *old2New)
7150 int nbTuples=getNumberOfTuples();
7151 int nbOfCompo=getNumberOfComponents();
7152 int *tmp=new int[nbTuples*nbOfCompo];
7153 const int *iptr=getConstPointer();
7154 for(int i=0;i<nbTuples;i++)
7157 if(v>=0 && v<nbTuples)
7158 std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),tmp+nbOfCompo*v);
7161 std::ostringstream oss; oss << "DataArrayInt::renumberInPlace : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
7162 throw INTERP_KERNEL::Exception(oss.str().c_str());
7165 std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
7171 * Permutes values of \a this array as required by \a new2Old array. The values are
7172 * permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of tuples remains
7173 * the same as in \this one.
7174 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7175 * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
7176 * giving a previous position of i-th new value.
7177 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7178 * is to delete using decrRef() as it is no more needed.
7180 void DataArrayInt::renumberInPlaceR(const int *new2Old)
7183 int nbTuples=getNumberOfTuples();
7184 int nbOfCompo=getNumberOfComponents();
7185 int *tmp=new int[nbTuples*nbOfCompo];
7186 const int *iptr=getConstPointer();
7187 for(int i=0;i<nbTuples;i++)
7190 if(v>=0 && v<nbTuples)
7191 std::copy(iptr+nbOfCompo*v,iptr+nbOfCompo*(v+1),tmp+nbOfCompo*i);
7194 std::ostringstream oss; oss << "DataArrayInt::renumberInPlaceR : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
7195 throw INTERP_KERNEL::Exception(oss.str().c_str());
7198 std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
7204 * Returns a copy of \a this array with values permuted as required by \a old2New array.
7205 * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ].
7206 * Number of tuples in the result array remains the same as in \this one.
7207 * If a permutation reduction is needed, renumberAndReduce() should be used.
7208 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7209 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
7210 * giving a new position for i-th old value.
7211 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7212 * is to delete using decrRef() as it is no more needed.
7213 * \throw If \a this is not allocated.
7215 DataArrayInt *DataArrayInt::renumber(const int *old2New) const
7218 int nbTuples=getNumberOfTuples();
7219 int nbOfCompo=getNumberOfComponents();
7220 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7221 ret->alloc(nbTuples,nbOfCompo);
7222 ret->copyStringInfoFrom(*this);
7223 const int *iptr=getConstPointer();
7224 int *optr=ret->getPointer();
7225 for(int i=0;i<nbTuples;i++)
7226 std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),optr+nbOfCompo*old2New[i]);
7227 ret->copyStringInfoFrom(*this);
7232 * Returns a copy of \a this array with values permuted as required by \a new2Old array.
7233 * The values are permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of
7234 * tuples in the result array remains the same as in \this one.
7235 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
7236 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7237 * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
7238 * giving a previous position of i-th new value.
7239 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7240 * is to delete using decrRef() as it is no more needed.
7242 DataArrayInt *DataArrayInt::renumberR(const int *new2Old) const
7245 int nbTuples=getNumberOfTuples();
7246 int nbOfCompo=getNumberOfComponents();
7247 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7248 ret->alloc(nbTuples,nbOfCompo);
7249 ret->copyStringInfoFrom(*this);
7250 const int *iptr=getConstPointer();
7251 int *optr=ret->getPointer();
7252 for(int i=0;i<nbTuples;i++)
7253 std::copy(iptr+nbOfCompo*new2Old[i],iptr+nbOfCompo*(new2Old[i]+1),optr+nbOfCompo*i);
7254 ret->copyStringInfoFrom(*this);
7259 * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
7260 * of size \a newNbOfTuple and it's values are permuted as required by \a old2New array.
7261 * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ] for all
7262 * \a old2New[ i ] >= 0. In other words every i-th tuple in \a this array, for which
7263 * \a old2New[ i ] is negative, is missing from the result array.
7264 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7265 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
7266 * giving a new position for i-th old tuple and giving negative position for
7267 * for i-th old tuple that should be omitted.
7268 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7269 * is to delete using decrRef() as it is no more needed.
7271 DataArrayInt *DataArrayInt::renumberAndReduce(const int *old2New, int newNbOfTuple) const
7274 int nbTuples=getNumberOfTuples();
7275 int nbOfCompo=getNumberOfComponents();
7276 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7277 ret->alloc(newNbOfTuple,nbOfCompo);
7278 const int *iptr=getConstPointer();
7279 int *optr=ret->getPointer();
7280 for(int i=0;i<nbTuples;i++)
7284 std::copy(iptr+i*nbOfCompo,iptr+(i+1)*nbOfCompo,optr+w*nbOfCompo);
7286 ret->copyStringInfoFrom(*this);
7291 * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
7292 * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
7293 * \a new2OldBg array.
7294 * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
7295 * This method is equivalent to renumberAndReduce() except that convention in input is
7296 * \c new2old and \b not \c old2new.
7297 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7298 * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
7299 * tuple index in \a this array to fill the i-th tuple in the new array.
7300 * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
7301 * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
7302 * \a new2OldBg <= \a pi < \a new2OldEnd.
7303 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7304 * is to delete using decrRef() as it is no more needed.
7306 DataArrayInt *DataArrayInt::selectByTupleId(const int *new2OldBg, const int *new2OldEnd) const
7309 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7310 int nbComp=getNumberOfComponents();
7311 ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
7312 ret->copyStringInfoFrom(*this);
7313 int *pt=ret->getPointer();
7314 const int *srcPt=getConstPointer();
7316 for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
7317 std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
7318 ret->copyStringInfoFrom(*this);
7323 * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
7324 * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
7325 * \a new2OldBg array.
7326 * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
7327 * This method is equivalent to renumberAndReduce() except that convention in input is
7328 * \c new2old and \b not \c old2new.
7329 * This method is equivalent to selectByTupleId() except that it prevents coping data
7330 * from behind the end of \a this array.
7331 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7332 * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
7333 * tuple index in \a this array to fill the i-th tuple in the new array.
7334 * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
7335 * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
7336 * \a new2OldBg <= \a pi < \a new2OldEnd.
7337 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7338 * is to delete using decrRef() as it is no more needed.
7339 * \throw If \a new2OldEnd - \a new2OldBg > \a this->getNumberOfTuples().
7341 DataArrayInt *DataArrayInt::selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const
7344 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7345 int nbComp=getNumberOfComponents();
7346 int oldNbOfTuples=getNumberOfTuples();
7347 ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
7348 ret->copyStringInfoFrom(*this);
7349 int *pt=ret->getPointer();
7350 const int *srcPt=getConstPointer();
7352 for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
7353 if(*w>=0 && *w<oldNbOfTuples)
7354 std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
7356 throw INTERP_KERNEL::Exception("DataArrayInt::selectByTupleIdSafe : some ids has been detected to be out of [0,this->getNumberOfTuples) !");
7357 ret->copyStringInfoFrom(*this);
7362 * Returns a shorten copy of \a this array. The new DataArrayInt contains every
7363 * (\a bg + \c i * \a step)-th tuple of \a this array located before the \a end2-th
7364 * tuple. Indices of the selected tuples are the same as ones returned by the Python
7365 * command \c range( \a bg, \a end2, \a step ).
7366 * This method is equivalent to selectByTupleIdSafe() except that the input array is
7367 * not constructed explicitly.
7368 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7369 * \param [in] bg - index of the first tuple to copy from \a this array.
7370 * \param [in] end2 - index of the tuple before which the tuples to copy are located.
7371 * \param [in] step - index increment to get index of the next tuple to copy.
7372 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7373 * is to delete using decrRef() as it is no more needed.
7374 * \sa DataArrayInt::substr.
7376 DataArrayInt *DataArrayInt::selectByTupleId2(int bg, int end2, int step) const
7379 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7380 int nbComp=getNumberOfComponents();
7381 int newNbOfTuples=GetNumberOfItemGivenBESRelative(bg,end2,step,"DataArrayInt::selectByTupleId2 : ");
7382 ret->alloc(newNbOfTuples,nbComp);
7383 int *pt=ret->getPointer();
7384 const int *srcPt=getConstPointer()+bg*nbComp;
7385 for(int i=0;i<newNbOfTuples;i++,srcPt+=step*nbComp)
7386 std::copy(srcPt,srcPt+nbComp,pt+i*nbComp);
7387 ret->copyStringInfoFrom(*this);
7392 * Returns a shorten copy of \a this array. The new DataArrayInt contains ranges
7393 * of tuples specified by \a ranges parameter.
7394 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7395 * \param [in] ranges - std::vector of std::pair's each of which defines a range
7396 * of tuples in [\c begin,\c end) format.
7397 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7398 * is to delete using decrRef() as it is no more needed.
7399 * \throw If \a end < \a begin.
7400 * \throw If \a end > \a this->getNumberOfTuples().
7401 * \throw If \a this is not allocated.
7403 DataArray *DataArrayInt::selectByTupleRanges(const std::vector<std::pair<int,int> >& ranges) const
7406 int nbOfComp=getNumberOfComponents();
7407 int nbOfTuplesThis=getNumberOfTuples();
7410 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7411 ret->alloc(0,nbOfComp);
7412 ret->copyStringInfoFrom(*this);
7415 int ref=ranges.front().first;
7417 bool isIncreasing=true;
7418 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
7420 if((*it).first<=(*it).second)
7422 if((*it).first>=0 && (*it).second<=nbOfTuplesThis)
7424 nbOfTuples+=(*it).second-(*it).first;
7426 isIncreasing=ref<=(*it).first;
7431 std::ostringstream oss; oss << "DataArrayInt::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
7432 oss << " (" << (*it).first << "," << (*it).second << ") is greater than number of tuples of this :" << nbOfTuples << " !";
7433 throw INTERP_KERNEL::Exception(oss.str().c_str());
7438 std::ostringstream oss; oss << "DataArrayInt::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
7439 oss << " (" << (*it).first << "," << (*it).second << ") end is before begin !";
7440 throw INTERP_KERNEL::Exception(oss.str().c_str());
7443 if(isIncreasing && nbOfTuplesThis==nbOfTuples)
7445 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7446 ret->alloc(nbOfTuples,nbOfComp);
7447 ret->copyStringInfoFrom(*this);
7448 const int *src=getConstPointer();
7449 int *work=ret->getPointer();
7450 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
7451 work=std::copy(src+(*it).first*nbOfComp,src+(*it).second*nbOfComp,work);
7456 * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode.
7457 * This map, if applied to \a this array, would make it sorted. For example, if
7458 * \a this array contents are [9,10,0,6,4,11,3,7] then the contents of the result array
7459 * are [5,6,0,3,2,7,1,4]; if this result array (\a res) is used as an argument in call
7460 * \a this->renumber(\a res) then the returned array contains [0,3,4,6,7,9,10,11].
7461 * This method is useful for renumbering (in MED file for example). For more info
7462 * on renumbering see \ref MEDCouplingArrayRenumbering.
7463 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7464 * array using decrRef() as it is no more needed.
7465 * \throw If \a this is not allocated.
7466 * \throw If \a this->getNumberOfComponents() != 1.
7467 * \throw If there are equal values in \a this array.
7469 DataArrayInt *DataArrayInt::checkAndPreparePermutation() const
7472 if(getNumberOfComponents()!=1)
7473 throw INTERP_KERNEL::Exception("DataArrayInt::checkAndPreparePermutation : number of components must == 1 !");
7474 int nbTuples=getNumberOfTuples();
7475 const int *pt=getConstPointer();
7476 int *pt2=CheckAndPreparePermutation(pt,pt+nbTuples);
7477 DataArrayInt *ret=DataArrayInt::New();
7478 ret->useArray(pt2,true,C_DEALLOC,nbTuples,1);
7483 * 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
7484 * input array \a ids2.
7485 * \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.
7486 * 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
7488 * In case of success (no throw) : \c ids1->renumber(ret)->isEqual(ids2) where \a ret is the return of this method.
7490 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7491 * array using decrRef() as it is no more needed.
7492 * \throw If either ids1 or ids2 is null not allocated or not with one components.
7495 DataArrayInt *DataArrayInt::FindPermutationFromFirstToSecond(const DataArrayInt *ids1, const DataArrayInt *ids2)
7498 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays must be not null !");
7499 if(!ids1->isAllocated() || !ids2->isAllocated())
7500 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays must be allocated !");
7501 if(ids1->getNumberOfComponents()!=1 || ids2->getNumberOfComponents()!=1)
7502 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays have exactly one component !");
7503 if(ids1->getNumberOfTuples()!=ids2->getNumberOfTuples())
7505 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 !";
7506 throw INTERP_KERNEL::Exception(oss.str().c_str());
7508 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(ids1->deepCpy());
7509 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p2(ids2->deepCpy());
7510 p1->sort(true); p2->sort(true);
7511 if(!p1->isEqualWithoutConsideringStr(*p2))
7512 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two arrays are not lying on same ids ! Impossible to find a permutation between the 2 arrays !");
7513 p1=ids1->checkAndPreparePermutation();
7514 p2=ids2->checkAndPreparePermutation();
7515 p2=p2->invertArrayO2N2N2O(p2->getNumberOfTuples());
7516 p2=p2->selectByTupleIdSafe(p1->begin(),p1->end());
7521 * Returns two arrays describing a surjective mapping from \a this set of values (\a A)
7522 * onto a set of values of size \a targetNb (\a B). The surjective function is
7523 * \a B[ \a A[ i ]] = i. That is to say that for each \a id in [0,\a targetNb), where \a
7524 * targetNb < \a this->getNumberOfTuples(), there exists at least one tupleId (\a tid) so
7525 * that <em> this->getIJ( tid, 0 ) == id</em>. <br>
7526 * The first of out arrays returns indices of elements of \a this array, grouped by their
7527 * place in the set \a B. The second out array is the index of the first one; it shows how
7528 * many elements of \a A are mapped into each element of \a B. <br>
7530 * mapping and its usage in renumbering see \ref MEDCouplingArrayRenumbering. <br>
7532 * - \a this: [0,3,2,3,2,2,1,2]
7534 * - \a arr: [0, 6, 2,4,5,7, 1,3]
7535 * - \a arrI: [0,1,2,6,8]
7537 * This result means: <br>
7538 * the element of \a B 0 encounters within \a A once (\a arrI[ 0+1 ] - \a arrI[ 0 ]) and
7539 * its index within \a A is 0 ( \a arr[ 0:1 ] == \a arr[ \a arrI[ 0 ] : \a arrI[ 0+1 ]]);<br>
7540 * the element of \a B 2 encounters within \a A 4 times (\a arrI[ 2+1 ] - \a arrI[ 2 ]) and
7541 * its indices within \a A are [2,4,5,7] ( \a arr[ 2:6 ] == \a arr[ \a arrI[ 2 ] :
7542 * \a arrI[ 2+1 ]]); <br> etc.
7543 * \param [in] targetNb - the size of the set \a B. \a targetNb must be equal or more
7544 * than the maximal value of \a A.
7545 * \param [out] arr - a new instance of DataArrayInt returning indices of
7546 * elements of \a this, grouped by their place in the set \a B. The caller is to delete
7547 * this array using decrRef() as it is no more needed.
7548 * \param [out] arrI - a new instance of DataArrayInt returning size of groups of equal
7549 * elements of \a this. The caller is to delete this array using decrRef() as it
7550 * is no more needed.
7551 * \throw If \a this is not allocated.
7552 * \throw If \a this->getNumberOfComponents() != 1.
7553 * \throw If any value in \a this is more or equal to \a targetNb.
7555 void DataArrayInt::changeSurjectiveFormat(int targetNb, DataArrayInt *&arr, DataArrayInt *&arrI) const
7558 if(getNumberOfComponents()!=1)
7559 throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : number of components must == 1 !");
7560 int nbOfTuples=getNumberOfTuples();
7561 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
7562 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> retI(DataArrayInt::New());
7563 retI->alloc(targetNb+1,1);
7564 const int *input=getConstPointer();
7565 std::vector< std::vector<int> > tmp(targetNb);
7566 for(int i=0;i<nbOfTuples;i++)
7569 if(tmp2>=0 && tmp2<targetNb)
7570 tmp[tmp2].push_back(i);
7573 std::ostringstream oss; oss << "DataArrayInt::changeSurjectiveFormat : At pos " << i << " presence of element " << tmp2 << " ! should be in [0," << targetNb << ") !";
7574 throw INTERP_KERNEL::Exception(oss.str().c_str());
7577 int *retIPtr=retI->getPointer();
7579 for(std::vector< std::vector<int> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++,retIPtr++)
7580 retIPtr[1]=retIPtr[0]+(int)((*it1).size());
7581 if(nbOfTuples!=retI->getIJ(targetNb,0))
7582 throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : big problem should never happen !");
7583 ret->alloc(nbOfTuples,1);
7584 int *retPtr=ret->getPointer();
7585 for(std::vector< std::vector<int> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++)
7586 retPtr=std::copy((*it1).begin(),(*it1).end(),retPtr);
7593 * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode computed
7594 * from a zip representation of a surjective format (returned e.g. by
7595 * \ref ParaMEDMEM::DataArrayDouble::findCommonTuples() "DataArrayDouble::findCommonTuples()"
7596 * for example). The result array minimizes the permutation. <br>
7597 * For more info on renumbering see \ref MEDCouplingArrayRenumbering. <br>
7599 * - \a nbOfOldTuples: 10
7600 * - \a arr : [0,3, 5,7,9]
7601 * - \a arrIBg : [0,2,5]
7602 * - \a newNbOfTuples: 7
7603 * - result array : [0,1,2,0,3,4,5,4,6,4]
7605 * \param [in] nbOfOldTuples - number of tuples in the initial array \a arr.
7606 * \param [in] arr - the array of tuple indices grouped by \a arrIBg array.
7607 * \param [in] arrIBg - the array dividing all indices stored in \a arr into groups of
7608 * (indices of) equal values. Its every element (except the last one) points to
7609 * the first element of a group of equal values.
7610 * \param [in] arrIEnd - specifies the end of \a arrIBg, so that the last element of \a
7611 * arrIBg is \a arrIEnd[ -1 ].
7612 * \param [out] newNbOfTuples - number of tuples after surjection application.
7613 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7614 * array using decrRef() as it is no more needed.
7615 * \throw If any value of \a arr breaks condition ( 0 <= \a arr[ i ] < \a nbOfOldTuples ).
7617 DataArrayInt *DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(int nbOfOldTuples, const int *arr, const int *arrIBg, const int *arrIEnd, int &newNbOfTuples)
7619 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7620 ret->alloc(nbOfOldTuples,1);
7621 int *pt=ret->getPointer();
7622 std::fill(pt,pt+nbOfOldTuples,-1);
7623 int nbOfGrps=((int)std::distance(arrIBg,arrIEnd))-1;
7624 const int *cIPtr=arrIBg;
7625 for(int i=0;i<nbOfGrps;i++)
7626 pt[arr[cIPtr[i]]]=-(i+2);
7628 for(int iNode=0;iNode<nbOfOldTuples;iNode++)
7636 int grpId=-(pt[iNode]+2);
7637 for(int j=cIPtr[grpId];j<cIPtr[grpId+1];j++)
7639 if(arr[j]>=0 && arr[j]<nbOfOldTuples)
7643 std::ostringstream oss; oss << "DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2 : With element #" << j << " value is " << arr[j] << " should be in [0," << nbOfOldTuples << ") !";
7644 throw INTERP_KERNEL::Exception(oss.str().c_str());
7651 newNbOfTuples=newNb;
7656 * Returns a new DataArrayInt containing a renumbering map in "New to Old" mode,
7657 * which if applied to \a this array would make it sorted ascendingly.
7658 * For more info on renumbering see \ref MEDCouplingArrayRenumbering. <br>
7660 * - \a this: [2,0,1,1,0,1,2,0,1,1,0,0]
7661 * - result: [10,0,5,6,1,7,11,2,8,9,3,4]
7662 * - after applying result to \a this: [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2]
7664 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7665 * array using decrRef() as it is no more needed.
7666 * \throw If \a this is not allocated.
7667 * \throw If \a this->getNumberOfComponents() != 1.
7669 DataArrayInt *DataArrayInt::buildPermArrPerLevel() const
7672 if(getNumberOfComponents()!=1)
7673 throw INTERP_KERNEL::Exception("DataArrayInt::buildPermArrPerLevel : number of components must == 1 !");
7674 int nbOfTuples=getNumberOfTuples();
7675 const int *pt=getConstPointer();
7676 std::map<int,int> m;
7677 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7678 ret->alloc(nbOfTuples,1);
7679 int *opt=ret->getPointer();
7680 for(int i=0;i<nbOfTuples;i++,pt++,opt++)
7683 std::map<int,int>::iterator it=m.find(val);
7692 m.insert(std::pair<int,int>(val,1));
7696 for(std::map<int,int>::iterator it=m.begin();it!=m.end();it++)
7698 int vt=(*it).second;
7702 pt=getConstPointer();
7703 opt=ret->getPointer();
7704 for(int i=0;i<nbOfTuples;i++,pt++,opt++)
7711 * Checks if contents of \a this array are equal to that of an array filled with
7712 * iota(). This method is particularly useful for DataArrayInt instances that represent
7713 * a renumbering array to check the real need in renumbering.
7714 * \return bool - \a true if \a this array contents == \a range( \a this->getNumberOfTuples())
7715 * \throw If \a this is not allocated.
7716 * \throw If \a this->getNumberOfComponents() != 1.
7718 bool DataArrayInt::isIdentity() const
7721 if(getNumberOfComponents()!=1)
7723 int nbOfTuples=getNumberOfTuples();
7724 const int *pt=getConstPointer();
7725 for(int i=0;i<nbOfTuples;i++,pt++)
7732 * Checks if all values in \a this array are equal to \a val.
7733 * \param [in] val - value to check equality of array values to.
7734 * \return bool - \a true if all values are \a val.
7735 * \throw If \a this is not allocated.
7736 * \throw If \a this->getNumberOfComponents() != 1
7738 bool DataArrayInt::isUniform(int val) const
7741 if(getNumberOfComponents()!=1)
7742 throw INTERP_KERNEL::Exception("DataArrayInt::isUniform : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
7743 int nbOfTuples=getNumberOfTuples();
7744 const int *w=getConstPointer();
7745 const int *end2=w+nbOfTuples;
7753 * Creates a new DataArrayDouble and assigns all (textual and numerical) data of \a this
7754 * array to the new one.
7755 * \return DataArrayDouble * - the new instance of DataArrayInt.
7757 DataArrayDouble *DataArrayInt::convertToDblArr() const
7760 DataArrayDouble *ret=DataArrayDouble::New();
7761 ret->alloc(getNumberOfTuples(),getNumberOfComponents());
7762 std::size_t nbOfVals=getNbOfElems();
7763 const int *src=getConstPointer();
7764 double *dest=ret->getPointer();
7765 std::copy(src,src+nbOfVals,dest);
7766 ret->copyStringInfoFrom(*this);
7771 * Returns a shorten copy of \a this array. The new DataArrayInt contains all
7772 * tuples starting from the \a tupleIdBg-th tuple and including all tuples located before
7773 * the \a tupleIdEnd-th one. This methods has a similar behavior as std::string::substr().
7774 * This method is a specialization of selectByTupleId2().
7775 * \param [in] tupleIdBg - index of the first tuple to copy from \a this array.
7776 * \param [in] tupleIdEnd - index of the tuple before which the tuples to copy are located.
7777 * If \a tupleIdEnd == -1, all the tuples till the end of \a this array are copied.
7778 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7779 * is to delete using decrRef() as it is no more needed.
7780 * \throw If \a tupleIdBg < 0.
7781 * \throw If \a tupleIdBg > \a this->getNumberOfTuples().
7782 \throw If \a tupleIdEnd != -1 && \a tupleIdEnd < \a this->getNumberOfTuples().
7783 * \sa DataArrayInt::selectByTupleId2
7785 DataArrayInt *DataArrayInt::substr(int tupleIdBg, int tupleIdEnd) const
7788 int nbt=getNumberOfTuples();
7790 throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter must be greater than 0 !");
7792 throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter is greater than number of tuples !");
7793 int trueEnd=tupleIdEnd;
7797 throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter is greater or equal than number of tuples !");
7801 int nbComp=getNumberOfComponents();
7802 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7803 ret->alloc(trueEnd-tupleIdBg,nbComp);
7804 ret->copyStringInfoFrom(*this);
7805 std::copy(getConstPointer()+tupleIdBg*nbComp,getConstPointer()+trueEnd*nbComp,ret->getPointer());
7810 * Changes the number of components within \a this array so that its raw data **does
7811 * not** change, instead splitting this data into tuples changes.
7812 * \warning This method erases all (name and unit) component info set before!
7813 * \param [in] newNbOfComp - number of components for \a this array to have.
7814 * \throw If \a this is not allocated
7815 * \throw If getNbOfElems() % \a newNbOfCompo != 0.
7816 * \throw If \a newNbOfCompo is lower than 1.
7817 * \throw If the rearrange method would lead to a number of tuples higher than 2147483647 (maximal capacity of int32 !).
7818 * \warning This method erases all (name and unit) component info set before!
7820 void DataArrayInt::rearrange(int newNbOfCompo)
7824 throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : input newNbOfCompo must be > 0 !");
7825 std::size_t nbOfElems=getNbOfElems();
7826 if(nbOfElems%newNbOfCompo!=0)
7827 throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : nbOfElems%newNbOfCompo!=0 !");
7828 if(nbOfElems/newNbOfCompo>(std::size_t)std::numeric_limits<int>::max())
7829 throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : the rearrangement leads to too high number of tuples (> 2147483647) !");
7830 _info_on_compo.clear();
7831 _info_on_compo.resize(newNbOfCompo);
7836 * Changes the number of components within \a this array to be equal to its number
7837 * of tuples, and inversely its number of tuples to become equal to its number of
7838 * components. So that its raw data **does not** change, instead splitting this
7839 * data into tuples changes.
7840 * \warning This method erases all (name and unit) component info set before!
7841 * \warning Do not confuse this method with fromNoInterlace() and toNoInterlace()!
7842 * \throw If \a this is not allocated.
7845 void DataArrayInt::transpose()
7848 int nbOfTuples=getNumberOfTuples();
7849 rearrange(nbOfTuples);
7853 * Returns a shorten or extended copy of \a this array. If \a newNbOfComp is less
7854 * than \a this->getNumberOfComponents() then the result array is shorten as each tuple
7855 * is truncated to have \a newNbOfComp components, keeping first components. If \a
7856 * newNbOfComp is more than \a this->getNumberOfComponents() then the result array is
7857 * expanded as each tuple is populated with \a dftValue to have \a newNbOfComp
7859 * \param [in] newNbOfComp - number of components for the new array to have.
7860 * \param [in] dftValue - value assigned to new values added to the new array.
7861 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
7862 * is to delete using decrRef() as it is no more needed.
7863 * \throw If \a this is not allocated.
7865 DataArrayInt *DataArrayInt::changeNbOfComponents(int newNbOfComp, int dftValue) const
7868 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7869 ret->alloc(getNumberOfTuples(),newNbOfComp);
7870 const int *oldc=getConstPointer();
7871 int *nc=ret->getPointer();
7872 int nbOfTuples=getNumberOfTuples();
7873 int oldNbOfComp=getNumberOfComponents();
7874 int dim=std::min(oldNbOfComp,newNbOfComp);
7875 for(int i=0;i<nbOfTuples;i++)
7879 nc[newNbOfComp*i+j]=oldc[i*oldNbOfComp+j];
7880 for(;j<newNbOfComp;j++)
7881 nc[newNbOfComp*i+j]=dftValue;
7883 ret->setName(getName());
7884 for(int i=0;i<dim;i++)
7885 ret->setInfoOnComponent(i,getInfoOnComponent(i));
7886 ret->setName(getName());
7891 * Changes number of tuples in the array. If the new number of tuples is smaller
7892 * than the current number the array is truncated, otherwise the array is extended.
7893 * \param [in] nbOfTuples - new number of tuples.
7894 * \throw If \a this is not allocated.
7895 * \throw If \a nbOfTuples is negative.
7897 void DataArrayInt::reAlloc(int nbOfTuples)
7900 throw INTERP_KERNEL::Exception("DataArrayInt::reAlloc : input new number of tuples should be >=0 !");
7902 _mem.reAlloc(getNumberOfComponents()*(std::size_t)nbOfTuples);
7908 * Returns a copy of \a this array composed of selected components.
7909 * The new DataArrayInt has the same number of tuples but includes components
7910 * specified by \a compoIds parameter. So that getNbOfElems() of the result array
7911 * can be either less, same or more than \a this->getNbOfElems().
7912 * \param [in] compoIds - sequence of zero based indices of components to include
7913 * into the new array.
7914 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7915 * is to delete using decrRef() as it is no more needed.
7916 * \throw If \a this is not allocated.
7917 * \throw If a component index (\a i) is not valid:
7918 * \a i < 0 || \a i >= \a this->getNumberOfComponents().
7920 * \if ENABLE_EXAMPLES
7921 * \ref py_mcdataarrayint_keepselectedcomponents "Here is a Python example".
7924 DataArrayInt *DataArrayInt::keepSelectedComponents(const std::vector<int>& compoIds) const
7927 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
7928 int newNbOfCompo=(int)compoIds.size();
7929 int oldNbOfCompo=getNumberOfComponents();
7930 for(std::vector<int>::const_iterator it=compoIds.begin();it!=compoIds.end();it++)
7931 DataArray::CheckValueInRange(oldNbOfCompo,(*it),"keepSelectedComponents invalid requested component");
7932 int nbOfTuples=getNumberOfTuples();
7933 ret->alloc(nbOfTuples,newNbOfCompo);
7934 ret->copyPartOfStringInfoFrom(*this,compoIds);
7935 const int *oldc=getConstPointer();
7936 int *nc=ret->getPointer();
7937 for(int i=0;i<nbOfTuples;i++)
7938 for(int j=0;j<newNbOfCompo;j++,nc++)
7939 *nc=oldc[i*oldNbOfCompo+compoIds[j]];
7944 * Appends components of another array to components of \a this one, tuple by tuple.
7945 * So that the number of tuples of \a this array remains the same and the number of
7946 * components increases.
7947 * \param [in] other - the DataArrayInt to append to \a this one.
7948 * \throw If \a this is not allocated.
7949 * \throw If \a this and \a other arrays have different number of tuples.
7951 * \if ENABLE_EXAMPLES
7952 * \ref cpp_mcdataarrayint_meldwith "Here is a C++ example".
7954 * \ref py_mcdataarrayint_meldwith "Here is a Python example".
7957 void DataArrayInt::meldWith(const DataArrayInt *other)
7960 throw INTERP_KERNEL::Exception("DataArrayInt::meldWith : DataArrayInt pointer in input is NULL !");
7962 other->checkAllocated();
7963 int nbOfTuples=getNumberOfTuples();
7964 if(nbOfTuples!=other->getNumberOfTuples())
7965 throw INTERP_KERNEL::Exception("DataArrayInt::meldWith : mismatch of number of tuples !");
7966 int nbOfComp1=getNumberOfComponents();
7967 int nbOfComp2=other->getNumberOfComponents();
7968 int *newArr=(int *)malloc(nbOfTuples*(nbOfComp1+nbOfComp2)*sizeof(int));
7970 const int *inp1=getConstPointer();
7971 const int *inp2=other->getConstPointer();
7972 for(int i=0;i<nbOfTuples;i++,inp1+=nbOfComp1,inp2+=nbOfComp2)
7974 w=std::copy(inp1,inp1+nbOfComp1,w);
7975 w=std::copy(inp2,inp2+nbOfComp2,w);
7977 useArray(newArr,true,C_DEALLOC,nbOfTuples,nbOfComp1+nbOfComp2);
7978 std::vector<int> compIds(nbOfComp2);
7979 for(int i=0;i<nbOfComp2;i++)
7980 compIds[i]=nbOfComp1+i;
7981 copyPartOfStringInfoFrom2(compIds,*other);
7985 * Copy all components in a specified order from another DataArrayInt.
7986 * The specified components become the first ones in \a this array.
7987 * Both numerical and textual data is copied. The number of tuples in \a this and
7988 * the other array can be different.
7989 * \param [in] a - the array to copy data from.
7990 * \param [in] compoIds - sequence of zero based indices of components, data of which is
7992 * \throw If \a a is NULL.
7993 * \throw If \a compoIds.size() != \a a->getNumberOfComponents().
7994 * \throw If \a compoIds[i] < 0 or \a compoIds[i] > \a this->getNumberOfComponents().
7996 * \if ENABLE_EXAMPLES
7997 * \ref py_mcdataarrayint_setselectedcomponents "Here is a Python example".
8000 void DataArrayInt::setSelectedComponents(const DataArrayInt *a, const std::vector<int>& compoIds)
8003 throw INTERP_KERNEL::Exception("DataArrayInt::setSelectedComponents : input DataArrayInt is NULL !");
8005 a->checkAllocated();
8006 copyPartOfStringInfoFrom2(compoIds,*a);
8007 std::size_t partOfCompoSz=compoIds.size();
8008 int nbOfCompo=getNumberOfComponents();
8009 int nbOfTuples=std::min(getNumberOfTuples(),a->getNumberOfTuples());
8010 const int *ac=a->getConstPointer();
8011 int *nc=getPointer();
8012 for(int i=0;i<nbOfTuples;i++)
8013 for(std::size_t j=0;j<partOfCompoSz;j++,ac++)
8014 nc[nbOfCompo*i+compoIds[j]]=*ac;
8018 * Copy all values from another DataArrayInt into specified tuples and components
8019 * of \a this array. Textual data is not copied.
8020 * The tree parameters defining set of indices of tuples and components are similar to
8021 * the tree parameters of the Python function \c range(\c start,\c stop,\c step).
8022 * \param [in] a - the array to copy values from.
8023 * \param [in] bgTuples - index of the first tuple of \a this array to assign values to.
8024 * \param [in] endTuples - index of the tuple before which the tuples to assign to
8026 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
8027 * \param [in] bgComp - index of the first component of \a this array to assign values to.
8028 * \param [in] endComp - index of the component before which the components to assign
8030 * \param [in] stepComp - index increment to get index of the next component to assign to.
8031 * \param [in] strictCompoCompare - if \a true (by default), then \a a->getNumberOfComponents()
8032 * must be equal to the number of columns to assign to, else an
8033 * exception is thrown; if \a false, then it is only required that \a
8034 * a->getNbOfElems() equals to number of values to assign to (this condition
8035 * must be respected even if \a strictCompoCompare is \a true). The number of
8036 * values to assign to is given by following Python expression:
8037 * \a nbTargetValues =
8038 * \c len(\c range(\a bgTuples,\a endTuples,\a stepTuples)) *
8039 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
8040 * \throw If \a a is NULL.
8041 * \throw If \a a is not allocated.
8042 * \throw If \a this is not allocated.
8043 * \throw If parameters specifying tuples and components to assign to do not give a
8044 * non-empty range of increasing indices.
8045 * \throw If \a a->getNbOfElems() != \a nbTargetValues.
8046 * \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
8047 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
8049 * \if ENABLE_EXAMPLES
8050 * \ref py_mcdataarrayint_setpartofvalues1 "Here is a Python example".
8053 void DataArrayInt::setPartOfValues1(const DataArrayInt *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
8056 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues1 : DataArrayInt pointer in input is NULL !");
8057 const char msg[]="DataArrayInt::setPartOfValues1";
8059 a->checkAllocated();
8060 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
8061 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
8062 int nbComp=getNumberOfComponents();
8063 int nbOfTuples=getNumberOfTuples();
8064 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
8065 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
8066 bool assignTech=true;
8067 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
8069 if(strictCompoCompare)
8070 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
8074 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
8077 int *pt=getPointer()+bgTuples*nbComp+bgComp;
8078 const int *srcPt=a->getConstPointer();
8081 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8082 for(int j=0;j<newNbOfComp;j++,srcPt++)
8083 pt[j*stepComp]=*srcPt;
8087 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8089 const int *srcPt2=srcPt;
8090 for(int j=0;j<newNbOfComp;j++,srcPt2++)
8091 pt[j*stepComp]=*srcPt2;
8097 * Assign a given value to values at specified tuples and components of \a this array.
8098 * The tree parameters defining set of indices of tuples and components are similar to
8099 * the tree parameters of the Python function \c range(\c start,\c stop,\c step)..
8100 * \param [in] a - the value to assign.
8101 * \param [in] bgTuples - index of the first tuple of \a this array to assign to.
8102 * \param [in] endTuples - index of the tuple before which the tuples to assign to
8104 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
8105 * \param [in] bgComp - index of the first component of \a this array to assign to.
8106 * \param [in] endComp - index of the component before which the components to assign
8108 * \param [in] stepComp - index increment to get index of the next component to assign to.
8109 * \throw If \a this is not allocated.
8110 * \throw If parameters specifying tuples and components to assign to, do not give a
8111 * non-empty range of increasing indices or indices are out of a valid range
8114 * \if ENABLE_EXAMPLES
8115 * \ref py_mcdataarrayint_setpartofvaluessimple1 "Here is a Python example".
8118 void DataArrayInt::setPartOfValuesSimple1(int a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp)
8120 const char msg[]="DataArrayInt::setPartOfValuesSimple1";
8122 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
8123 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
8124 int nbComp=getNumberOfComponents();
8125 int nbOfTuples=getNumberOfTuples();
8126 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
8127 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
8128 int *pt=getPointer()+bgTuples*nbComp+bgComp;
8129 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8130 for(int j=0;j<newNbOfComp;j++)
8136 * Copy all values from another DataArrayInt (\a a) into specified tuples and
8137 * components of \a this array. Textual data is not copied.
8138 * The tuples and components to assign to are defined by C arrays of indices.
8139 * There are two *modes of usage*:
8140 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
8141 * of \a a is assigned to its own location within \a this array.
8142 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
8143 * components of every specified tuple of \a this array. In this mode it is required
8144 * that \a a->getNumberOfComponents() equals to the number of specified components.
8146 * \param [in] a - the array to copy values from.
8147 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
8148 * assign values of \a a to.
8149 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
8150 * pointer to a tuple index <em>(pi)</em> varies as this:
8151 * \a bgTuples <= \a pi < \a endTuples.
8152 * \param [in] bgComp - pointer to an array of component indices of \a this array to
8153 * assign values of \a a to.
8154 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
8155 * pointer to a component index <em>(pi)</em> varies as this:
8156 * \a bgComp <= \a pi < \a endComp.
8157 * \param [in] strictCompoCompare - this parameter is checked only if the
8158 * *mode of usage* is the first; if it is \a true (default),
8159 * then \a a->getNumberOfComponents() must be equal
8160 * to the number of specified columns, else this is not required.
8161 * \throw If \a a is NULL.
8162 * \throw If \a a is not allocated.
8163 * \throw If \a this is not allocated.
8164 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
8165 * out of a valid range for \a this array.
8166 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
8167 * if <em> a->getNumberOfComponents() != (endComp - bgComp) </em>.
8168 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
8169 * <em> a->getNumberOfComponents() != (endComp - bgComp)</em>.
8171 * \if ENABLE_EXAMPLES
8172 * \ref py_mcdataarrayint_setpartofvalues2 "Here is a Python example".
8175 void DataArrayInt::setPartOfValues2(const DataArrayInt *a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
8178 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues2 : DataArrayInt pointer in input is NULL !");
8179 const char msg[]="DataArrayInt::setPartOfValues2";
8181 a->checkAllocated();
8182 int nbComp=getNumberOfComponents();
8183 int nbOfTuples=getNumberOfTuples();
8184 for(const int *z=bgComp;z!=endComp;z++)
8185 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
8186 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
8187 int newNbOfComp=(int)std::distance(bgComp,endComp);
8188 bool assignTech=true;
8189 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
8191 if(strictCompoCompare)
8192 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
8196 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
8199 int *pt=getPointer();
8200 const int *srcPt=a->getConstPointer();
8203 for(const int *w=bgTuples;w!=endTuples;w++)
8205 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8206 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
8208 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt;
8214 for(const int *w=bgTuples;w!=endTuples;w++)
8216 const int *srcPt2=srcPt;
8217 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8218 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
8220 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt2;
8227 * Assign a given value to values at specified tuples and components of \a this array.
8228 * The tuples and components to assign to are defined by C arrays of indices.
8229 * \param [in] a - the value to assign.
8230 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
8232 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
8233 * pointer to a tuple index (\a pi) varies as this:
8234 * \a bgTuples <= \a pi < \a endTuples.
8235 * \param [in] bgComp - pointer to an array of component indices of \a this array to
8237 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
8238 * pointer to a component index (\a pi) varies as this:
8239 * \a bgComp <= \a pi < \a endComp.
8240 * \throw If \a this is not allocated.
8241 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
8242 * out of a valid range for \a this array.
8244 * \if ENABLE_EXAMPLES
8245 * \ref py_mcdataarrayint_setpartofvaluessimple2 "Here is a Python example".
8248 void DataArrayInt::setPartOfValuesSimple2(int a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp)
8251 int nbComp=getNumberOfComponents();
8252 int nbOfTuples=getNumberOfTuples();
8253 for(const int *z=bgComp;z!=endComp;z++)
8254 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
8255 int *pt=getPointer();
8256 for(const int *w=bgTuples;w!=endTuples;w++)
8257 for(const int *z=bgComp;z!=endComp;z++)
8259 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8260 pt[(std::size_t)(*w)*nbComp+(*z)]=a;
8265 * Copy all values from another DataArrayInt (\a a) into specified tuples and
8266 * components of \a this array. Textual data is not copied.
8267 * The tuples to assign to are defined by a C array of indices.
8268 * The components to assign to are defined by three values similar to parameters of
8269 * the Python function \c range(\c start,\c stop,\c step).
8270 * There are two *modes of usage*:
8271 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
8272 * of \a a is assigned to its own location within \a this array.
8273 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
8274 * components of every specified tuple of \a this array. In this mode it is required
8275 * that \a a->getNumberOfComponents() equals to the number of specified components.
8277 * \param [in] a - the array to copy values from.
8278 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
8279 * assign values of \a a to.
8280 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
8281 * pointer to a tuple index <em>(pi)</em> varies as this:
8282 * \a bgTuples <= \a pi < \a endTuples.
8283 * \param [in] bgComp - index of the first component of \a this array to assign to.
8284 * \param [in] endComp - index of the component before which the components to assign
8286 * \param [in] stepComp - index increment to get index of the next component to assign to.
8287 * \param [in] strictCompoCompare - this parameter is checked only in the first
8288 * *mode of usage*; if \a strictCompoCompare is \a true (default),
8289 * then \a a->getNumberOfComponents() must be equal
8290 * to the number of specified columns, else this is not required.
8291 * \throw If \a a is NULL.
8292 * \throw If \a a is not allocated.
8293 * \throw If \a this is not allocated.
8294 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
8296 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
8297 * if <em> a->getNumberOfComponents()</em> is unequal to the number of components
8298 * defined by <em>(bgComp,endComp,stepComp)</em>.
8299 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
8300 * <em> a->getNumberOfComponents()</em> is unequal to the number of components
8301 * defined by <em>(bgComp,endComp,stepComp)</em>.
8302 * \throw If parameters specifying components to assign to, do not give a
8303 * non-empty range of increasing indices or indices are out of a valid range
8306 * \if ENABLE_EXAMPLES
8307 * \ref py_mcdataarrayint_setpartofvalues3 "Here is a Python example".
8310 void DataArrayInt::setPartOfValues3(const DataArrayInt *a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
8313 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues3 : DataArrayInt pointer in input is NULL !");
8314 const char msg[]="DataArrayInt::setPartOfValues3";
8316 a->checkAllocated();
8317 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
8318 int nbComp=getNumberOfComponents();
8319 int nbOfTuples=getNumberOfTuples();
8320 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
8321 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
8322 bool assignTech=true;
8323 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
8325 if(strictCompoCompare)
8326 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
8330 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
8333 int *pt=getPointer()+bgComp;
8334 const int *srcPt=a->getConstPointer();
8337 for(const int *w=bgTuples;w!=endTuples;w++)
8338 for(int j=0;j<newNbOfComp;j++,srcPt++)
8340 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8341 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt;
8346 for(const int *w=bgTuples;w!=endTuples;w++)
8348 const int *srcPt2=srcPt;
8349 for(int j=0;j<newNbOfComp;j++,srcPt2++)
8351 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8352 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt2;
8359 * Assign a given value to values at specified tuples and components of \a this array.
8360 * The tuples to assign to are defined by a C array of indices.
8361 * The components to assign to are defined by three values similar to parameters of
8362 * the Python function \c range(\c start,\c stop,\c step).
8363 * \param [in] a - the value to assign.
8364 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
8366 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
8367 * pointer to a tuple index <em>(pi)</em> varies as this:
8368 * \a bgTuples <= \a pi < \a endTuples.
8369 * \param [in] bgComp - index of the first component of \a this array to assign to.
8370 * \param [in] endComp - index of the component before which the components to assign
8372 * \param [in] stepComp - index increment to get index of the next component to assign to.
8373 * \throw If \a this is not allocated.
8374 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
8376 * \throw If parameters specifying components to assign to, do not give a
8377 * non-empty range of increasing indices or indices are out of a valid range
8380 * \if ENABLE_EXAMPLES
8381 * \ref py_mcdataarrayint_setpartofvaluessimple3 "Here is a Python example".
8384 void DataArrayInt::setPartOfValuesSimple3(int a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp)
8386 const char msg[]="DataArrayInt::setPartOfValuesSimple3";
8388 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
8389 int nbComp=getNumberOfComponents();
8390 int nbOfTuples=getNumberOfTuples();
8391 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
8392 int *pt=getPointer()+bgComp;
8393 for(const int *w=bgTuples;w!=endTuples;w++)
8394 for(int j=0;j<newNbOfComp;j++)
8396 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8397 pt[(std::size_t)(*w)*nbComp+j*stepComp]=a;
8401 void DataArrayInt::setPartOfValues4(const DataArrayInt *a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
8404 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues4 : input DataArrayInt is NULL !");
8405 const char msg[]="DataArrayInt::setPartOfValues4";
8407 a->checkAllocated();
8408 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
8409 int newNbOfComp=(int)std::distance(bgComp,endComp);
8410 int nbComp=getNumberOfComponents();
8411 for(const int *z=bgComp;z!=endComp;z++)
8412 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
8413 int nbOfTuples=getNumberOfTuples();
8414 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
8415 bool assignTech=true;
8416 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
8418 if(strictCompoCompare)
8419 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
8423 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
8426 const int *srcPt=a->getConstPointer();
8427 int *pt=getPointer()+bgTuples*nbComp;
8430 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8431 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
8436 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8438 const int *srcPt2=srcPt;
8439 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
8445 void DataArrayInt::setPartOfValuesSimple4(int a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp)
8447 const char msg[]="DataArrayInt::setPartOfValuesSimple4";
8449 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
8450 int nbComp=getNumberOfComponents();
8451 for(const int *z=bgComp;z!=endComp;z++)
8452 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
8453 int nbOfTuples=getNumberOfTuples();
8454 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
8455 int *pt=getPointer()+bgTuples*nbComp;
8456 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8457 for(const int *z=bgComp;z!=endComp;z++)
8462 * Copy some tuples from another DataArrayInt into specified tuples
8463 * of \a this array. Textual data is not copied. Both arrays must have equal number of
8465 * Both the tuples to assign and the tuples to assign to are defined by a DataArrayInt.
8466 * All components of selected tuples are copied.
8467 * \param [in] a - the array to copy values from.
8468 * \param [in] tuplesSelec - the array specifying both source tuples of \a a and
8469 * target tuples of \a this. \a tuplesSelec has two components, and the
8470 * first component specifies index of the source tuple and the second
8471 * one specifies index of the target tuple.
8472 * \throw If \a this is not allocated.
8473 * \throw If \a a is NULL.
8474 * \throw If \a a is not allocated.
8475 * \throw If \a tuplesSelec is NULL.
8476 * \throw If \a tuplesSelec is not allocated.
8477 * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
8478 * \throw If \a tuplesSelec->getNumberOfComponents() != 2.
8479 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
8480 * the corresponding (\a this or \a a) array.
8482 void DataArrayInt::setPartOfValuesAdv(const DataArrayInt *a, const DataArrayInt *tuplesSelec)
8484 if(!a || !tuplesSelec)
8485 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : DataArrayInt pointer in input is NULL !");
8487 a->checkAllocated();
8488 tuplesSelec->checkAllocated();
8489 int nbOfComp=getNumberOfComponents();
8490 if(nbOfComp!=a->getNumberOfComponents())
8491 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : This and a do not have the same number of components !");
8492 if(tuplesSelec->getNumberOfComponents()!=2)
8493 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : Expecting to have a tuple selector DataArrayInt instance with exactly 2 components !");
8494 int thisNt=getNumberOfTuples();
8495 int aNt=a->getNumberOfTuples();
8496 int *valsToSet=getPointer();
8497 const int *valsSrc=a->getConstPointer();
8498 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple+=2)
8500 if(tuple[1]>=0 && tuple[1]<aNt)
8502 if(tuple[0]>=0 && tuple[0]<thisNt)
8503 std::copy(valsSrc+nbOfComp*tuple[1],valsSrc+nbOfComp*(tuple[1]+1),valsToSet+nbOfComp*tuple[0]);
8506 std::ostringstream oss; oss << "DataArrayInt::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
8507 oss << " of 'tuplesSelec' request of tuple id #" << tuple[0] << " in 'this' ! It should be in [0," << thisNt << ") !";
8508 throw INTERP_KERNEL::Exception(oss.str().c_str());
8513 std::ostringstream oss; oss << "DataArrayInt::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
8514 oss << " of 'tuplesSelec' request of tuple id #" << tuple[1] << " in 'a' ! It should be in [0," << aNt << ") !";
8515 throw INTERP_KERNEL::Exception(oss.str().c_str());
8521 * Copy some tuples from another DataArrayInt (\a aBase) into contiguous tuples
8522 * of \a this array. Textual data is not copied. Both arrays must have equal number of
8524 * The tuples to assign to are defined by index of the first tuple, and
8525 * their number is defined by \a tuplesSelec->getNumberOfTuples().
8526 * The tuples to copy are defined by values of a DataArrayInt.
8527 * All components of selected tuples are copied.
8528 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
8530 * \param [in] aBase - the array to copy values from.
8531 * \param [in] tuplesSelec - the array specifying tuples of \a aBase to copy.
8532 * \throw If \a this is not allocated.
8533 * \throw If \a aBase is NULL.
8534 * \throw If \a aBase is not allocated.
8535 * \throw If \a tuplesSelec is NULL.
8536 * \throw If \a tuplesSelec is not allocated.
8537 * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
8538 * \throw If \a tuplesSelec->getNumberOfComponents() != 1.
8539 * \throw If <em>tupleIdStart + tuplesSelec->getNumberOfTuples() > this->getNumberOfTuples().</em>
8540 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
8543 void DataArrayInt::setContigPartOfSelectedValues(int tupleIdStart, const DataArray *aBase, const DataArrayInt *tuplesSelec)
8545 if(!aBase || !tuplesSelec)
8546 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : input DataArray is NULL !");
8547 const DataArrayInt *a=dynamic_cast<const DataArrayInt *>(aBase);
8549 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : input DataArray aBase is not a DataArrayInt !");
8551 a->checkAllocated();
8552 tuplesSelec->checkAllocated();
8553 int nbOfComp=getNumberOfComponents();
8554 if(nbOfComp!=a->getNumberOfComponents())
8555 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : This and a do not have the same number of components !");
8556 if(tuplesSelec->getNumberOfComponents()!=1)
8557 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : Expecting to have a tuple selector DataArrayInt instance with exactly 1 component !");
8558 int thisNt=getNumberOfTuples();
8559 int aNt=a->getNumberOfTuples();
8560 int nbOfTupleToWrite=tuplesSelec->getNumberOfTuples();
8561 int *valsToSet=getPointer()+tupleIdStart*nbOfComp;
8562 if(tupleIdStart+nbOfTupleToWrite>thisNt)
8563 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : invalid number range of values to write !");
8564 const int *valsSrc=a->getConstPointer();
8565 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple++,valsToSet+=nbOfComp)
8567 if(*tuple>=0 && *tuple<aNt)
8569 std::copy(valsSrc+nbOfComp*(*tuple),valsSrc+nbOfComp*(*tuple+1),valsToSet);
8573 std::ostringstream oss; oss << "DataArrayInt::setContigPartOfSelectedValues : Tuple #" << std::distance(tuplesSelec->begin(),tuple);
8574 oss << " of 'tuplesSelec' request of tuple id #" << *tuple << " in 'a' ! It should be in [0," << aNt << ") !";
8575 throw INTERP_KERNEL::Exception(oss.str().c_str());
8581 * Copy some tuples from another DataArrayInt (\a aBase) into contiguous tuples
8582 * of \a this array. Textual data is not copied. Both arrays must have equal number of
8584 * The tuples to copy are defined by three values similar to parameters of
8585 * the Python function \c range(\c start,\c stop,\c step).
8586 * The tuples to assign to are defined by index of the first tuple, and
8587 * their number is defined by number of tuples to copy.
8588 * All components of selected tuples are copied.
8589 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
8591 * \param [in] aBase - the array to copy values from.
8592 * \param [in] bg - index of the first tuple to copy of the array \a aBase.
8593 * \param [in] end2 - index of the tuple of \a aBase before which the tuples to copy
8595 * \param [in] step - index increment to get index of the next tuple to copy.
8596 * \throw If \a this is not allocated.
8597 * \throw If \a aBase is NULL.
8598 * \throw If \a aBase is not allocated.
8599 * \throw If <em>this->getNumberOfComponents() != aBase->getNumberOfComponents()</em>.
8600 * \throw If <em>tupleIdStart + len(range(bg,end2,step)) > this->getNumberOfTuples().</em>
8601 * \throw If parameters specifying tuples to copy, do not give a
8602 * non-empty range of increasing indices or indices are out of a valid range
8603 * for the array \a aBase.
8605 void DataArrayInt::setContigPartOfSelectedValues2(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step)
8608 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : input DataArray is NULL !");
8609 const DataArrayInt *a=dynamic_cast<const DataArrayInt *>(aBase);
8611 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : input DataArray aBase is not a DataArrayInt !");
8613 a->checkAllocated();
8614 int nbOfComp=getNumberOfComponents();
8615 const char msg[]="DataArrayInt::setContigPartOfSelectedValues2";
8616 int nbOfTupleToWrite=DataArray::GetNumberOfItemGivenBES(bg,end2,step,msg);
8617 if(nbOfComp!=a->getNumberOfComponents())
8618 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : This and a do not have the same number of components !");
8619 int thisNt=getNumberOfTuples();
8620 int aNt=a->getNumberOfTuples();
8621 int *valsToSet=getPointer()+tupleIdStart*nbOfComp;
8622 if(tupleIdStart+nbOfTupleToWrite>thisNt)
8623 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : invalid number range of values to write !");
8625 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : invalid range of values to read !");
8626 const int *valsSrc=a->getConstPointer()+bg*nbOfComp;
8627 for(int i=0;i<nbOfTupleToWrite;i++,valsToSet+=nbOfComp,valsSrc+=step*nbOfComp)
8629 std::copy(valsSrc,valsSrc+nbOfComp,valsToSet);
8634 * Returns a value located at specified tuple and component.
8635 * This method is equivalent to DataArrayInt::getIJ() except that validity of
8636 * parameters is checked. So this method is safe but expensive if used to go through
8637 * all values of \a this.
8638 * \param [in] tupleId - index of tuple of interest.
8639 * \param [in] compoId - index of component of interest.
8640 * \return double - value located by \a tupleId and \a compoId.
8641 * \throw If \a this is not allocated.
8642 * \throw If condition <em>( 0 <= tupleId < this->getNumberOfTuples() )</em> is violated.
8643 * \throw If condition <em>( 0 <= compoId < this->getNumberOfComponents() )</em> is violated.
8645 int DataArrayInt::getIJSafe(int tupleId, int compoId) const
8648 if(tupleId<0 || tupleId>=getNumberOfTuples())
8650 std::ostringstream oss; oss << "DataArrayInt::getIJSafe : request for tupleId " << tupleId << " should be in [0," << getNumberOfTuples() << ") !";
8651 throw INTERP_KERNEL::Exception(oss.str().c_str());
8653 if(compoId<0 || compoId>=getNumberOfComponents())
8655 std::ostringstream oss; oss << "DataArrayInt::getIJSafe : request for compoId " << compoId << " should be in [0," << getNumberOfComponents() << ") !";
8656 throw INTERP_KERNEL::Exception(oss.str().c_str());
8658 return _mem[tupleId*_info_on_compo.size()+compoId];
8662 * Returns the first value of \a this.
8663 * \return int - the last value of \a this array.
8664 * \throw If \a this is not allocated.
8665 * \throw If \a this->getNumberOfComponents() != 1.
8666 * \throw If \a this->getNumberOfTuples() < 1.
8668 int DataArrayInt::front() const
8671 if(getNumberOfComponents()!=1)
8672 throw INTERP_KERNEL::Exception("DataArrayInt::front : number of components not equal to one !");
8673 int nbOfTuples=getNumberOfTuples();
8675 throw INTERP_KERNEL::Exception("DataArrayInt::front : number of tuples must be >= 1 !");
8676 return *(getConstPointer());
8680 * Returns the last value of \a this.
8681 * \return int - the last value of \a this array.
8682 * \throw If \a this is not allocated.
8683 * \throw If \a this->getNumberOfComponents() != 1.
8684 * \throw If \a this->getNumberOfTuples() < 1.
8686 int DataArrayInt::back() const
8689 if(getNumberOfComponents()!=1)
8690 throw INTERP_KERNEL::Exception("DataArrayInt::back : number of components not equal to one !");
8691 int nbOfTuples=getNumberOfTuples();
8693 throw INTERP_KERNEL::Exception("DataArrayInt::back : number of tuples must be >= 1 !");
8694 return *(getConstPointer()+nbOfTuples-1);
8698 * Assign pointer to one array to a pointer to another appay. Reference counter of
8699 * \a arrayToSet is incremented / decremented.
8700 * \param [in] newArray - the pointer to array to assign to \a arrayToSet.
8701 * \param [in,out] arrayToSet - the pointer to array to assign to.
8703 void DataArrayInt::SetArrayIn(DataArrayInt *newArray, DataArrayInt* &arrayToSet)
8705 if(newArray!=arrayToSet)
8708 arrayToSet->decrRef();
8709 arrayToSet=newArray;
8711 arrayToSet->incrRef();
8715 DataArrayIntIterator *DataArrayInt::iterator()
8717 return new DataArrayIntIterator(this);
8721 * Creates a new DataArrayInt containing IDs (indices) of tuples holding value equal to a
8722 * given one. The ids are sorted in the ascending order.
8723 * \param [in] val - the value to find within \a this.
8724 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8725 * array using decrRef() as it is no more needed.
8726 * \throw If \a this is not allocated.
8727 * \throw If \a this->getNumberOfComponents() != 1.
8728 * \sa DataArrayInt::getIdsEqualTuple
8730 DataArrayInt *DataArrayInt::getIdsEqual(int val) const
8733 if(getNumberOfComponents()!=1)
8734 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqual : the array must have only one component, you can call 'rearrange' method before !");
8735 const int *cptr(getConstPointer());
8736 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8737 int nbOfTuples=getNumberOfTuples();
8738 for(int i=0;i<nbOfTuples;i++,cptr++)
8740 ret->pushBackSilent(i);
8745 * Creates a new DataArrayInt containing IDs (indices) of tuples holding value \b not
8746 * equal to a given one.
8747 * \param [in] val - the value to ignore within \a this.
8748 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8749 * array using decrRef() as it is no more needed.
8750 * \throw If \a this is not allocated.
8751 * \throw If \a this->getNumberOfComponents() != 1.
8753 DataArrayInt *DataArrayInt::getIdsNotEqual(int val) const
8756 if(getNumberOfComponents()!=1)
8757 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotEqual : the array must have only one component, you can call 'rearrange' method before !");
8758 const int *cptr(getConstPointer());
8759 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8760 int nbOfTuples=getNumberOfTuples();
8761 for(int i=0;i<nbOfTuples;i++,cptr++)
8763 ret->pushBackSilent(i);
8768 * Creates a new DataArrayInt containing IDs (indices) of tuples holding tuple equal to those defined by [ \a tupleBg , \a tupleEnd )
8769 * This method is an extension of DataArrayInt::getIdsEqual method.
8771 * \param [in] tupleBg - the begin (included) of the input tuple to find within \a this.
8772 * \param [in] tupleEnd - the end (excluded) of the input tuple to find within \a this.
8773 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8774 * array using decrRef() as it is no more needed.
8775 * \throw If \a this is not allocated.
8776 * \throw If \a this->getNumberOfComponents() != std::distance(tupleBg,tupleEnd).
8777 * \throw If \a this->getNumberOfComponents() is equal to 0.
8778 * \sa DataArrayInt::getIdsEqual
8780 DataArrayInt *DataArrayInt::getIdsEqualTuple(const int *tupleBg, const int *tupleEnd) const
8782 std::size_t nbOfCompoExp(std::distance(tupleBg,tupleEnd));
8784 if(getNumberOfComponents()!=(int)nbOfCompoExp)
8786 std::ostringstream oss; oss << "DataArrayInt::getIdsEqualTuple : mismatch of number of components. Input tuple has " << nbOfCompoExp << " whereas this array has " << getNumberOfComponents() << " components !";
8787 throw INTERP_KERNEL::Exception(oss.str().c_str());
8790 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqualTuple : number of components should be > 0 !");
8791 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8792 const int *bg(begin()),*end2(end()),*work(begin());
8795 work=std::search(work,end2,tupleBg,tupleEnd);
8798 std::size_t pos(std::distance(bg,work));
8799 if(pos%nbOfCompoExp==0)
8800 ret->pushBackSilent(pos/nbOfCompoExp);
8808 * Assigns \a newValue to all elements holding \a oldValue within \a this
8809 * one-dimensional array.
8810 * \param [in] oldValue - the value to replace.
8811 * \param [in] newValue - the value to assign.
8812 * \return int - number of replacements performed.
8813 * \throw If \a this is not allocated.
8814 * \throw If \a this->getNumberOfComponents() != 1.
8816 int DataArrayInt::changeValue(int oldValue, int newValue)
8819 if(getNumberOfComponents()!=1)
8820 throw INTERP_KERNEL::Exception("DataArrayInt::changeValue : the array must have only one component, you can call 'rearrange' method before !");
8821 int *start=getPointer();
8822 int *end2=start+getNbOfElems();
8824 for(int *val=start;val!=end2;val++)
8836 * Creates a new DataArrayInt containing IDs (indices) of tuples holding value equal to
8837 * one of given values.
8838 * \param [in] valsBg - an array of values to find within \a this array.
8839 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
8840 * the last value of \a valsBg is \a valsEnd[ -1 ].
8841 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8842 * array using decrRef() as it is no more needed.
8843 * \throw If \a this->getNumberOfComponents() != 1.
8845 DataArrayInt *DataArrayInt::getIdsEqualList(const int *valsBg, const int *valsEnd) const
8847 if(getNumberOfComponents()!=1)
8848 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqualList : the array must have only one component, you can call 'rearrange' method before !");
8849 std::set<int> vals2(valsBg,valsEnd);
8850 const int *cptr=getConstPointer();
8851 std::vector<int> res;
8852 int nbOfTuples=getNumberOfTuples();
8853 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8854 for(int i=0;i<nbOfTuples;i++,cptr++)
8855 if(vals2.find(*cptr)!=vals2.end())
8856 ret->pushBackSilent(i);
8861 * Creates a new DataArrayInt containing IDs (indices) of tuples holding values \b not
8862 * equal to any of given values.
8863 * \param [in] valsBg - an array of values to ignore within \a this array.
8864 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
8865 * the last value of \a valsBg is \a valsEnd[ -1 ].
8866 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8867 * array using decrRef() as it is no more needed.
8868 * \throw If \a this->getNumberOfComponents() != 1.
8870 DataArrayInt *DataArrayInt::getIdsNotEqualList(const int *valsBg, const int *valsEnd) const
8872 if(getNumberOfComponents()!=1)
8873 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotEqualList : the array must have only one component, you can call 'rearrange' method before !");
8874 std::set<int> vals2(valsBg,valsEnd);
8875 const int *cptr=getConstPointer();
8876 std::vector<int> res;
8877 int nbOfTuples=getNumberOfTuples();
8878 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8879 for(int i=0;i<nbOfTuples;i++,cptr++)
8880 if(vals2.find(*cptr)==vals2.end())
8881 ret->pushBackSilent(i);
8886 * This method is an extension of DataArrayInt::locateValue method because this method works for DataArrayInt with
8887 * any number of components excepted 0 (an INTERP_KERNEL::Exception is thrown in this case).
8888 * This method searches in \b this is there is a tuple that matched the input parameter \b tupl.
8889 * If any the tuple id is returned. If not -1 is returned.
8891 * This method throws an INTERP_KERNEL::Exception if the number of components in \b this mismatches with the size of
8892 * the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
8894 * \return tuple id where \b tupl is. -1 if no such tuple exists in \b this.
8895 * \sa DataArrayInt::search, DataArrayInt::presenceOfTuple.
8897 int DataArrayInt::locateTuple(const std::vector<int>& tupl) const
8900 int nbOfCompo=getNumberOfComponents();
8902 throw INTERP_KERNEL::Exception("DataArrayInt::locateTuple : 0 components in 'this' !");
8903 if(nbOfCompo!=(int)tupl.size())
8905 std::ostringstream oss; oss << "DataArrayInt::locateTuple : 'this' contains " << nbOfCompo << " components and searching for a tuple of length " << tupl.size() << " !";
8906 throw INTERP_KERNEL::Exception(oss.str().c_str());
8908 const int *cptr=getConstPointer();
8909 std::size_t nbOfVals=getNbOfElems();
8910 for(const int *work=cptr;work!=cptr+nbOfVals;)
8912 work=std::search(work,cptr+nbOfVals,tupl.begin(),tupl.end());
8913 if(work!=cptr+nbOfVals)
8915 if(std::distance(cptr,work)%nbOfCompo!=0)
8918 return std::distance(cptr,work)/nbOfCompo;
8925 * This method searches the sequence specified in input parameter \b vals in \b this.
8926 * This works only for DataArrayInt having number of components equal to one (if not an INTERP_KERNEL::Exception will be thrown).
8927 * This method differs from DataArrayInt::locateTuple in that the position is internal raw data is not considered here contrary to DataArrayInt::locateTuple.
8928 * \sa DataArrayInt::locateTuple
8930 int DataArrayInt::search(const std::vector<int>& vals) const
8933 int nbOfCompo=getNumberOfComponents();
8935 throw INTERP_KERNEL::Exception("DataArrayInt::search : works only for DataArrayInt instance with one component !");
8936 const int *cptr=getConstPointer();
8937 std::size_t nbOfVals=getNbOfElems();
8938 const int *loc=std::search(cptr,cptr+nbOfVals,vals.begin(),vals.end());
8939 if(loc!=cptr+nbOfVals)
8940 return std::distance(cptr,loc);
8945 * This method expects to be called when number of components of this is equal to one.
8946 * This method returns the tuple id, if it exists, of the first tuple equal to \b value.
8947 * If not any tuple contains \b value -1 is returned.
8948 * \sa DataArrayInt::presenceOfValue
8950 int DataArrayInt::locateValue(int value) const
8953 if(getNumberOfComponents()!=1)
8954 throw INTERP_KERNEL::Exception("DataArrayInt::presenceOfValue : the array must have only one component, you can call 'rearrange' method before !");
8955 const int *cptr=getConstPointer();
8956 int nbOfTuples=getNumberOfTuples();
8957 const int *ret=std::find(cptr,cptr+nbOfTuples,value);
8958 if(ret!=cptr+nbOfTuples)
8959 return std::distance(cptr,ret);
8964 * This method expects to be called when number of components of this is equal to one.
8965 * This method returns the tuple id, if it exists, of the first tuple so that the value is contained in \b vals.
8966 * If not any tuple contains one of the values contained in 'vals' false is returned.
8967 * \sa DataArrayInt::presenceOfValue
8969 int DataArrayInt::locateValue(const std::vector<int>& vals) const
8972 if(getNumberOfComponents()!=1)
8973 throw INTERP_KERNEL::Exception("DataArrayInt::presenceOfValue : the array must have only one component, you can call 'rearrange' method before !");
8974 std::set<int> vals2(vals.begin(),vals.end());
8975 const int *cptr=getConstPointer();
8976 int nbOfTuples=getNumberOfTuples();
8977 for(const int *w=cptr;w!=cptr+nbOfTuples;w++)
8978 if(vals2.find(*w)!=vals2.end())
8979 return std::distance(cptr,w);
8984 * This method returns the number of values in \a this that are equals to input parameter \a value.
8985 * This method only works for single component array.
8987 * \return a value in [ 0, \c this->getNumberOfTuples() )
8989 * \throw If \a this is not allocated
8992 int DataArrayInt::count(int value) const
8996 if(getNumberOfComponents()!=1)
8997 throw INTERP_KERNEL::Exception("DataArrayInt::count : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
8998 const int *vals=begin();
8999 int nbOfTuples=getNumberOfTuples();
9000 for(int i=0;i<nbOfTuples;i++,vals++)
9007 * This method is an extension of DataArrayInt::presenceOfValue method because this method works for DataArrayInt with
9008 * any number of components excepted 0 (an INTERP_KERNEL::Exception is thrown in this case).
9009 * This method searches in \b this is there is a tuple that matched the input parameter \b tupl.
9010 * This method throws an INTERP_KERNEL::Exception if the number of components in \b this mismatches with the size of
9011 * the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
9012 * \sa DataArrayInt::locateTuple
9014 bool DataArrayInt::presenceOfTuple(const std::vector<int>& tupl) const
9016 return locateTuple(tupl)!=-1;
9021 * Returns \a true if a given value is present within \a this one-dimensional array.
9022 * \param [in] value - the value to find within \a this array.
9023 * \return bool - \a true in case if \a value is present within \a this array.
9024 * \throw If \a this is not allocated.
9025 * \throw If \a this->getNumberOfComponents() != 1.
9028 bool DataArrayInt::presenceOfValue(int value) const
9030 return locateValue(value)!=-1;
9034 * This method expects to be called when number of components of this is equal to one.
9035 * This method returns true if it exists a tuple so that the value is contained in \b vals.
9036 * If not any tuple contains one of the values contained in 'vals' false is returned.
9037 * \sa DataArrayInt::locateValue
9039 bool DataArrayInt::presenceOfValue(const std::vector<int>& vals) const
9041 return locateValue(vals)!=-1;
9045 * Accumulates values of each component of \a this array.
9046 * \param [out] res - an array of length \a this->getNumberOfComponents(), allocated
9047 * by the caller, that is filled by this method with sum value for each
9049 * \throw If \a this is not allocated.
9051 void DataArrayInt::accumulate(int *res) const
9054 const int *ptr=getConstPointer();
9055 int nbTuple=getNumberOfTuples();
9056 int nbComps=getNumberOfComponents();
9057 std::fill(res,res+nbComps,0);
9058 for(int i=0;i<nbTuple;i++)
9059 std::transform(ptr+i*nbComps,ptr+(i+1)*nbComps,res,res,std::plus<int>());
9062 int DataArrayInt::accumulate(int compId) const
9065 const int *ptr=getConstPointer();
9066 int nbTuple=getNumberOfTuples();
9067 int nbComps=getNumberOfComponents();
9068 if(compId<0 || compId>=nbComps)
9069 throw INTERP_KERNEL::Exception("DataArrayInt::accumulate : Invalid compId specified : No such nb of components !");
9071 for(int i=0;i<nbTuple;i++)
9072 ret+=ptr[i*nbComps+compId];
9077 * This method accumulate using addition tuples in \a this using input index array [ \a bgOfIndex, \a endOfIndex ).
9078 * The returned array will have same number of components than \a this and number of tuples equal to
9079 * \c std::distance(bgOfIndex,endOfIndex) \b minus \b one.
9081 * The input index array is expected to be ascendingly sorted in which the all referenced ids should be in [0, \c this->getNumberOfTuples).
9083 * \param [in] bgOfIndex - begin (included) of the input index array.
9084 * \param [in] endOfIndex - end (excluded) of the input index array.
9085 * \return DataArrayInt * - the new instance having the same number of components than \a this.
9087 * \throw If bgOfIndex or end is NULL.
9088 * \throw If input index array is not ascendingly sorted.
9089 * \throw If there is an id in [ \a bgOfIndex, \a endOfIndex ) not in [0, \c this->getNumberOfTuples).
9090 * \throw If std::distance(bgOfIndex,endOfIndex)==0.
9092 DataArrayInt *DataArrayInt::accumulatePerChunck(const int *bgOfIndex, const int *endOfIndex) const
9094 if(!bgOfIndex || !endOfIndex)
9095 throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : input pointer NULL !");
9097 int nbCompo=getNumberOfComponents();
9098 int nbOfTuples=getNumberOfTuples();
9099 int sz=(int)std::distance(bgOfIndex,endOfIndex);
9101 throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : invalid size of input index array !");
9103 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(sz,nbCompo);
9104 const int *w=bgOfIndex;
9105 if(*w<0 || *w>=nbOfTuples)
9106 throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : The first element of the input index not in [0,nbOfTuples) !");
9107 const int *srcPt=begin()+(*w)*nbCompo;
9108 int *tmp=ret->getPointer();
9109 for(int i=0;i<sz;i++,tmp+=nbCompo,w++)
9111 std::fill(tmp,tmp+nbCompo,0);
9114 for(int j=w[0];j<w[1];j++,srcPt+=nbCompo)
9116 if(j>=0 && j<nbOfTuples)
9117 std::transform(srcPt,srcPt+nbCompo,tmp,tmp,std::plus<int>());
9120 std::ostringstream oss; oss << "DataArrayInt::accumulatePerChunck : At rank #" << i << " the input index array points to id " << j << " should be in [0," << nbOfTuples << ") !";
9121 throw INTERP_KERNEL::Exception(oss.str().c_str());
9127 std::ostringstream oss; oss << "DataArrayInt::accumulatePerChunck : At rank #" << i << " the input index array is not in ascendingly sorted.";
9128 throw INTERP_KERNEL::Exception(oss.str().c_str());
9131 ret->copyStringInfoFrom(*this);
9136 * Returns a new DataArrayInt by concatenating two given arrays, so that (1) the number
9137 * of tuples in the result array is <em> a1->getNumberOfTuples() + a2->getNumberOfTuples() -
9138 * offsetA2</em> and (2)
9139 * the number of component in the result array is same as that of each of given arrays.
9140 * First \a offsetA2 tuples of \a a2 are skipped and thus are missing from the result array.
9141 * Info on components is copied from the first of the given arrays. Number of components
9142 * in the given arrays must be the same.
9143 * \param [in] a1 - an array to include in the result array.
9144 * \param [in] a2 - another array to include in the result array.
9145 * \param [in] offsetA2 - number of tuples of \a a2 to skip.
9146 * \return DataArrayInt * - the new instance of DataArrayInt.
9147 * The caller is to delete this result array using decrRef() as it is no more
9149 * \throw If either \a a1 or \a a2 is NULL.
9150 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents().
9152 DataArrayInt *DataArrayInt::Aggregate(const DataArrayInt *a1, const DataArrayInt *a2, int offsetA2)
9155 throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : input DataArrayInt instance is NULL !");
9156 int nbOfComp=a1->getNumberOfComponents();
9157 if(nbOfComp!=a2->getNumberOfComponents())
9158 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Aggregation !");
9159 int nbOfTuple1=a1->getNumberOfTuples();
9160 int nbOfTuple2=a2->getNumberOfTuples();
9161 DataArrayInt *ret=DataArrayInt::New();
9162 ret->alloc(nbOfTuple1+nbOfTuple2-offsetA2,nbOfComp);
9163 int *pt=std::copy(a1->getConstPointer(),a1->getConstPointer()+nbOfTuple1*nbOfComp,ret->getPointer());
9164 std::copy(a2->getConstPointer()+offsetA2*nbOfComp,a2->getConstPointer()+nbOfTuple2*nbOfComp,pt);
9165 ret->copyStringInfoFrom(*a1);
9170 * Returns a new DataArrayInt by concatenating all given arrays, so that (1) the number
9171 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
9172 * the number of component in the result array is same as that of each of given arrays.
9173 * Info on components is copied from the first of the given arrays. Number of components
9174 * in the given arrays must be the same.
9175 * If the number of non null of elements in \a arr is equal to one the returned object is a copy of it
9176 * not the object itself.
9177 * \param [in] arr - a sequence of arrays to include in the result array.
9178 * \return DataArrayInt * - the new instance of DataArrayInt.
9179 * The caller is to delete this result array using decrRef() as it is no more
9181 * \throw If all arrays within \a arr are NULL.
9182 * \throw If getNumberOfComponents() of arrays within \a arr.
9184 DataArrayInt *DataArrayInt::Aggregate(const std::vector<const DataArrayInt *>& arr)
9186 std::vector<const DataArrayInt *> a;
9187 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9191 throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : input list must be NON EMPTY !");
9192 std::vector<const DataArrayInt *>::const_iterator it=a.begin();
9193 int nbOfComp=(*it)->getNumberOfComponents();
9194 int nbt=(*it++)->getNumberOfTuples();
9195 for(int i=1;it!=a.end();it++,i++)
9197 if((*it)->getNumberOfComponents()!=nbOfComp)
9198 throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : Nb of components mismatch for array aggregation !");
9199 nbt+=(*it)->getNumberOfTuples();
9201 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9202 ret->alloc(nbt,nbOfComp);
9203 int *pt=ret->getPointer();
9204 for(it=a.begin();it!=a.end();it++)
9205 pt=std::copy((*it)->getConstPointer(),(*it)->getConstPointer()+(*it)->getNbOfElems(),pt);
9206 ret->copyStringInfoFrom(*(a[0]));
9211 * This method takes as input a list of DataArrayInt instances \a arrs that represent each a packed index arrays.
9212 * A packed index array is an allocated array with one component, and at least one tuple. The first element
9213 * of each array in \a arrs must be 0. Each array in \a arrs is expected to be increasingly monotonic.
9214 * 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.
9216 * \return DataArrayInt * - a new object to be managed by the caller.
9218 DataArrayInt *DataArrayInt::AggregateIndexes(const std::vector<const DataArrayInt *>& arrs)
9221 for(std::vector<const DataArrayInt *>::const_iterator it4=arrs.begin();it4!=arrs.end();it4++)
9225 (*it4)->checkAllocated();
9226 if((*it4)->getNumberOfComponents()!=1)
9228 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with nb of compo != 1 at pos " << std::distance(arrs.begin(),it4) << " !";
9229 throw INTERP_KERNEL::Exception(oss.str().c_str());
9231 int nbTupl=(*it4)->getNumberOfTuples();
9234 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with nb of tuples < 1 at pos " << std::distance(arrs.begin(),it4) << " !";
9235 throw INTERP_KERNEL::Exception(oss.str().c_str());
9237 if((*it4)->front()!=0)
9239 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with front value != 0 at pos " << std::distance(arrs.begin(),it4) << " !";
9240 throw INTERP_KERNEL::Exception(oss.str().c_str());
9246 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a null instance at pos " << std::distance(arrs.begin(),it4) << " !";
9247 throw INTERP_KERNEL::Exception(oss.str().c_str());
9251 throw INTERP_KERNEL::Exception("DataArrayInt::AggregateIndexes : input list must be NON EMPTY !");
9252 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9253 ret->alloc(retSz,1);
9254 int *pt=ret->getPointer(); *pt++=0;
9255 for(std::vector<const DataArrayInt *>::const_iterator it=arrs.begin();it!=arrs.end();it++)
9256 pt=std::transform((*it)->begin()+1,(*it)->end(),pt,std::bind2nd(std::plus<int>(),pt[-1]));
9257 ret->copyStringInfoFrom(*(arrs[0]));
9262 * Returns the maximal value and its location within \a this one-dimensional array.
9263 * \param [out] tupleId - index of the tuple holding the maximal value.
9264 * \return int - the maximal value among all values of \a this array.
9265 * \throw If \a this->getNumberOfComponents() != 1
9266 * \throw If \a this->getNumberOfTuples() < 1
9268 int DataArrayInt::getMaxValue(int& tupleId) const
9271 if(getNumberOfComponents()!=1)
9272 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : must be applied on DataArrayInt with only one component !");
9273 int nbOfTuples=getNumberOfTuples();
9275 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : array exists but number of tuples must be > 0 !");
9276 const int *vals=getConstPointer();
9277 const int *loc=std::max_element(vals,vals+nbOfTuples);
9278 tupleId=(int)std::distance(vals,loc);
9283 * Returns the maximal value within \a this array that is allowed to have more than
9285 * \return int - the maximal value among all values of \a this array.
9286 * \throw If \a this is not allocated.
9288 int DataArrayInt::getMaxValueInArray() const
9291 const int *loc=std::max_element(begin(),end());
9296 * Returns the minimal value and its location within \a this one-dimensional array.
9297 * \param [out] tupleId - index of the tuple holding the minimal value.
9298 * \return int - the minimal value among all values of \a this array.
9299 * \throw If \a this->getNumberOfComponents() != 1
9300 * \throw If \a this->getNumberOfTuples() < 1
9302 int DataArrayInt::getMinValue(int& tupleId) const
9305 if(getNumberOfComponents()!=1)
9306 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : must be applied on DataArrayInt with only one component !");
9307 int nbOfTuples=getNumberOfTuples();
9309 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : array exists but number of tuples must be > 0 !");
9310 const int *vals=getConstPointer();
9311 const int *loc=std::min_element(vals,vals+nbOfTuples);
9312 tupleId=(int)std::distance(vals,loc);
9317 * Returns the minimal value within \a this array that is allowed to have more than
9319 * \return int - the minimal value among all values of \a this array.
9320 * \throw If \a this is not allocated.
9322 int DataArrayInt::getMinValueInArray() const
9325 const int *loc=std::min_element(begin(),end());
9330 * Returns in a single walk in \a this the min value and the max value in \a this.
9331 * \a this is expected to be single component array.
9333 * \param [out] minValue - the min value in \a this.
9334 * \param [out] maxValue - the max value in \a this.
9336 * \sa getMinValueInArray, getMinValue, getMaxValueInArray, getMaxValue
9338 void DataArrayInt::getMinMaxValues(int& minValue, int& maxValue) const
9341 if(getNumberOfComponents()!=1)
9342 throw INTERP_KERNEL::Exception("DataArrayInt::getMinMaxValues : must be applied on DataArrayInt with only one component !");
9343 int nbTuples(getNumberOfTuples());
9344 const int *pt(begin());
9345 minValue=std::numeric_limits<int>::max(); maxValue=-std::numeric_limits<int>::max();
9346 for(int i=0;i<nbTuples;i++,pt++)
9356 * Converts every value of \a this array to its absolute value.
9357 * \b WARNING this method is non const. If a new DataArrayInt instance should be built containing the result of abs DataArrayInt::computeAbs
9358 * should be called instead.
9360 * \throw If \a this is not allocated.
9361 * \sa DataArrayInt::computeAbs
9363 void DataArrayInt::abs()
9366 int *ptr(getPointer());
9367 std::size_t nbOfElems(getNbOfElems());
9368 std::transform(ptr,ptr+nbOfElems,ptr,std::ptr_fun<int,int>(std::abs));
9373 * This method builds a new instance of \a this object containing the result of std::abs applied of all elements in \a this.
9374 * This method is a const method (that do not change any values in \a this) contrary to DataArrayInt::abs method.
9376 * \return DataArrayInt * - the new instance of DataArrayInt containing the
9377 * same number of tuples and component as \a this array.
9378 * The caller is to delete this result array using decrRef() as it is no more
9380 * \throw If \a this is not allocated.
9381 * \sa DataArrayInt::abs
9383 DataArrayInt *DataArrayInt::computeAbs() const
9386 DataArrayInt *newArr(DataArrayInt::New());
9387 int nbOfTuples(getNumberOfTuples());
9388 int nbOfComp(getNumberOfComponents());
9389 newArr->alloc(nbOfTuples,nbOfComp);
9390 std::transform(begin(),end(),newArr->getPointer(),std::ptr_fun<int,int>(std::abs));
9391 newArr->copyStringInfoFrom(*this);
9396 * Apply a liner function to a given component of \a this array, so that
9397 * an array element <em>(x)</em> becomes \f$ a * x + b \f$.
9398 * \param [in] a - the first coefficient of the function.
9399 * \param [in] b - the second coefficient of the function.
9400 * \param [in] compoId - the index of component to modify.
9401 * \throw If \a this is not allocated.
9403 void DataArrayInt::applyLin(int a, int b, int compoId)
9406 int *ptr=getPointer()+compoId;
9407 int nbOfComp=getNumberOfComponents();
9408 int nbOfTuple=getNumberOfTuples();
9409 for(int i=0;i<nbOfTuple;i++,ptr+=nbOfComp)
9415 * Apply a liner function to all elements of \a this array, so that
9416 * an element _x_ becomes \f$ a * x + b \f$.
9417 * \param [in] a - the first coefficient of the function.
9418 * \param [in] b - the second coefficient of the function.
9419 * \throw If \a this is not allocated.
9421 void DataArrayInt::applyLin(int a, int b)
9424 int *ptr=getPointer();
9425 std::size_t nbOfElems=getNbOfElems();
9426 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9432 * Returns a full copy of \a this array except that sign of all elements is reversed.
9433 * \return DataArrayInt * - the new instance of DataArrayInt containing the
9434 * same number of tuples and component as \a this array.
9435 * The caller is to delete this result array using decrRef() as it is no more
9437 * \throw If \a this is not allocated.
9439 DataArrayInt *DataArrayInt::negate() const
9442 DataArrayInt *newArr=DataArrayInt::New();
9443 int nbOfTuples=getNumberOfTuples();
9444 int nbOfComp=getNumberOfComponents();
9445 newArr->alloc(nbOfTuples,nbOfComp);
9446 const int *cptr=getConstPointer();
9447 std::transform(cptr,cptr+nbOfTuples*nbOfComp,newArr->getPointer(),std::negate<int>());
9448 newArr->copyStringInfoFrom(*this);
9453 * Modify all elements of \a this array, so that
9454 * an element _x_ becomes \f$ numerator / x \f$.
9455 * \warning If an exception is thrown because of presence of 0 element in \a this
9456 * array, all elements processed before detection of the zero element remain
9458 * \param [in] numerator - the numerator used to modify array elements.
9459 * \throw If \a this is not allocated.
9460 * \throw If there is an element equal to 0 in \a this array.
9462 void DataArrayInt::applyInv(int numerator)
9465 int *ptr=getPointer();
9466 std::size_t nbOfElems=getNbOfElems();
9467 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9471 *ptr=numerator/(*ptr);
9475 std::ostringstream oss; oss << "DataArrayInt::applyInv : presence of null value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
9477 throw INTERP_KERNEL::Exception(oss.str().c_str());
9484 * Modify all elements of \a this array, so that
9485 * an element _x_ becomes \f$ x / val \f$.
9486 * \param [in] val - the denominator used to modify array elements.
9487 * \throw If \a this is not allocated.
9488 * \throw If \a val == 0.
9490 void DataArrayInt::applyDivideBy(int val)
9493 throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to divide by 0 !");
9495 int *ptr=getPointer();
9496 std::size_t nbOfElems=getNbOfElems();
9497 std::transform(ptr,ptr+nbOfElems,ptr,std::bind2nd(std::divides<int>(),val));
9502 * Modify all elements of \a this array, so that
9503 * an element _x_ becomes <em> x % val </em>.
9504 * \param [in] val - the divisor used to modify array elements.
9505 * \throw If \a this is not allocated.
9506 * \throw If \a val <= 0.
9508 void DataArrayInt::applyModulus(int val)
9511 throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to operate modulus on value <= 0 !");
9513 int *ptr=getPointer();
9514 std::size_t nbOfElems=getNbOfElems();
9515 std::transform(ptr,ptr+nbOfElems,ptr,std::bind2nd(std::modulus<int>(),val));
9520 * This method works only on data array with one component.
9521 * This method returns a newly allocated array storing stored ascendantly tuple ids in \b this so that
9522 * this[*id] in [\b vmin,\b vmax)
9524 * \param [in] vmin begin of range. This value is included in range (included).
9525 * \param [in] vmax end of range. This value is \b not included in range (excluded).
9526 * \return a newly allocated data array that the caller should deal with.
9528 * \sa DataArrayInt::getIdsNotInRange , DataArrayInt::getIdsStrictlyNegative
9530 DataArrayInt *DataArrayInt::getIdsInRange(int vmin, int vmax) const
9533 if(getNumberOfComponents()!=1)
9534 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsInRange : this must have exactly one component !");
9535 const int *cptr(begin());
9536 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
9537 int nbOfTuples(getNumberOfTuples());
9538 for(int i=0;i<nbOfTuples;i++,cptr++)
9539 if(*cptr>=vmin && *cptr<vmax)
9540 ret->pushBackSilent(i);
9545 * This method works only on data array with one component.
9546 * This method returns a newly allocated array storing stored ascendantly tuple ids in \b this so that
9547 * this[*id] \b not in [\b vmin,\b vmax)
9549 * \param [in] vmin begin of range. This value is \b not included in range (excluded).
9550 * \param [in] vmax end of range. This value is included in range (included).
9551 * \return a newly allocated data array that the caller should deal with.
9553 * \sa DataArrayInt::getIdsInRange , DataArrayInt::getIdsStrictlyNegative
9555 DataArrayInt *DataArrayInt::getIdsNotInRange(int vmin, int vmax) const
9558 if(getNumberOfComponents()!=1)
9559 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotInRange : this must have exactly one component !");
9560 const int *cptr(getConstPointer());
9561 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
9562 int nbOfTuples(getNumberOfTuples());
9563 for(int i=0;i<nbOfTuples;i++,cptr++)
9564 if(*cptr<vmin || *cptr>=vmax)
9565 ret->pushBackSilent(i);
9570 * This method works only on data array with one component. This method returns a newly allocated array storing stored ascendantly of tuple ids in \a this so that this[id]<0.
9572 * \return a newly allocated data array that the caller should deal with.
9573 * \sa DataArrayInt::getIdsInRange
9575 DataArrayInt *DataArrayInt::getIdsStrictlyNegative() const
9578 if(getNumberOfComponents()!=1)
9579 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsStrictlyNegative : this must have exactly one component !");
9580 const int *cptr(getConstPointer());
9581 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
9582 int nbOfTuples(getNumberOfTuples());
9583 for(int i=0;i<nbOfTuples;i++,cptr++)
9585 ret->pushBackSilent(i);
9590 * This method works only on data array with one component.
9591 * 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.
9593 * \param [in] vmin begin of range. This value is included in range (included).
9594 * \param [in] vmax end of range. This value is \b not included in range (excluded).
9595 * \return if all ids in \a this are so that (*this)[i]==i for all i in [ 0, \c this->getNumberOfTuples() ). */
9596 bool DataArrayInt::checkAllIdsInRange(int vmin, int vmax) const
9599 if(getNumberOfComponents()!=1)
9600 throw INTERP_KERNEL::Exception("DataArrayInt::checkAllIdsInRange : this must have exactly one component !");
9601 int nbOfTuples=getNumberOfTuples();
9603 const int *cptr=getConstPointer();
9604 for(int i=0;i<nbOfTuples;i++,cptr++)
9606 if(*cptr>=vmin && *cptr<vmax)
9607 { ret=ret && *cptr==i; }
9610 std::ostringstream oss; oss << "DataArrayInt::checkAllIdsInRange : tuple #" << i << " has value " << *cptr << " should be in [" << vmin << "," << vmax << ") !";
9611 throw INTERP_KERNEL::Exception(oss.str().c_str());
9618 * Modify all elements of \a this array, so that
9619 * an element _x_ becomes <em> val % x </em>.
9620 * \warning If an exception is thrown because of presence of an element <= 0 in \a this
9621 * array, all elements processed before detection of the zero element remain
9623 * \param [in] val - the divident used to modify array elements.
9624 * \throw If \a this is not allocated.
9625 * \throw If there is an element equal to or less than 0 in \a this array.
9627 void DataArrayInt::applyRModulus(int val)
9630 int *ptr=getPointer();
9631 std::size_t nbOfElems=getNbOfElems();
9632 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9640 std::ostringstream oss; oss << "DataArrayInt::applyRModulus : presence of value <=0 in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
9642 throw INTERP_KERNEL::Exception(oss.str().c_str());
9649 * Modify all elements of \a this array, so that
9650 * an element _x_ becomes <em> val ^ x </em>.
9651 * \param [in] val - the value used to apply pow on all array elements.
9652 * \throw If \a this is not allocated.
9653 * \throw If \a val < 0.
9655 void DataArrayInt::applyPow(int val)
9659 throw INTERP_KERNEL::Exception("DataArrayInt::applyPow : input pow in < 0 !");
9660 int *ptr=getPointer();
9661 std::size_t nbOfElems=getNbOfElems();
9664 std::fill(ptr,ptr+nbOfElems,1);
9667 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9670 for(int j=0;j<val;j++)
9678 * Modify all elements of \a this array, so that
9679 * an element _x_ becomes \f$ val ^ x \f$.
9680 * \param [in] val - the value used to apply pow on all array elements.
9681 * \throw If \a this is not allocated.
9682 * \throw If there is an element < 0 in \a this array.
9683 * \warning If an exception is thrown because of presence of 0 element in \a this
9684 * array, all elements processed before detection of the zero element remain
9687 void DataArrayInt::applyRPow(int val)
9690 int *ptr=getPointer();
9691 std::size_t nbOfElems=getNbOfElems();
9692 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9697 for(int j=0;j<*ptr;j++)
9703 std::ostringstream oss; oss << "DataArrayInt::applyRPow : presence of negative value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
9705 throw INTERP_KERNEL::Exception(oss.str().c_str());
9712 * Returns a new DataArrayInt by aggregating two given arrays, so that (1) the number
9713 * of components in the result array is a sum of the number of components of given arrays
9714 * and (2) the number of tuples in the result array is same as that of each of given
9715 * arrays. In other words the i-th tuple of result array includes all components of
9716 * i-th tuples of all given arrays.
9717 * Number of tuples in the given arrays must be the same.
9718 * \param [in] a1 - an array to include in the result array.
9719 * \param [in] a2 - another array to include in the result array.
9720 * \return DataArrayInt * - the new instance of DataArrayInt.
9721 * The caller is to delete this result array using decrRef() as it is no more
9723 * \throw If both \a a1 and \a a2 are NULL.
9724 * \throw If any given array is not allocated.
9725 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
9727 DataArrayInt *DataArrayInt::Meld(const DataArrayInt *a1, const DataArrayInt *a2)
9729 std::vector<const DataArrayInt *> arr(2);
9730 arr[0]=a1; arr[1]=a2;
9735 * Returns a new DataArrayInt by aggregating all given arrays, so that (1) the number
9736 * of components in the result array is a sum of the number of components of given arrays
9737 * and (2) the number of tuples in the result array is same as that of each of given
9738 * arrays. In other words the i-th tuple of result array includes all components of
9739 * i-th tuples of all given arrays.
9740 * Number of tuples in the given arrays must be the same.
9741 * \param [in] arr - a sequence of arrays to include in the result array.
9742 * \return DataArrayInt * - the new instance of DataArrayInt.
9743 * The caller is to delete this result array using decrRef() as it is no more
9745 * \throw If all arrays within \a arr are NULL.
9746 * \throw If any given array is not allocated.
9747 * \throw If getNumberOfTuples() of arrays within \a arr is different.
9749 DataArrayInt *DataArrayInt::Meld(const std::vector<const DataArrayInt *>& arr)
9751 std::vector<const DataArrayInt *> a;
9752 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9756 throw INTERP_KERNEL::Exception("DataArrayInt::Meld : array must be NON empty !");
9757 std::vector<const DataArrayInt *>::const_iterator it;
9758 for(it=a.begin();it!=a.end();it++)
9759 (*it)->checkAllocated();
9761 int nbOfTuples=(*it)->getNumberOfTuples();
9762 std::vector<int> nbc(a.size());
9763 std::vector<const int *> pts(a.size());
9764 nbc[0]=(*it)->getNumberOfComponents();
9765 pts[0]=(*it++)->getConstPointer();
9766 for(int i=1;it!=a.end();it++,i++)
9768 if(nbOfTuples!=(*it)->getNumberOfTuples())
9769 throw INTERP_KERNEL::Exception("DataArrayInt::meld : mismatch of number of tuples !");
9770 nbc[i]=(*it)->getNumberOfComponents();
9771 pts[i]=(*it)->getConstPointer();
9773 int totalNbOfComp=std::accumulate(nbc.begin(),nbc.end(),0);
9774 DataArrayInt *ret=DataArrayInt::New();
9775 ret->alloc(nbOfTuples,totalNbOfComp);
9776 int *retPtr=ret->getPointer();
9777 for(int i=0;i<nbOfTuples;i++)
9778 for(int j=0;j<(int)a.size();j++)
9780 retPtr=std::copy(pts[j],pts[j]+nbc[j],retPtr);
9784 for(int i=0;i<(int)a.size();i++)
9785 for(int j=0;j<nbc[i];j++,k++)
9786 ret->setInfoOnComponent(k,a[i]->getInfoOnComponent(j));
9791 * Returns a new DataArrayInt which is a minimal partition of elements of \a groups.
9792 * The i-th item of the result array is an ID of a set of elements belonging to a
9793 * unique set of groups, which the i-th element is a part of. This set of elements
9794 * belonging to a unique set of groups is called \a family, so the result array contains
9795 * IDs of families each element belongs to.
9797 * \b Example: if we have two groups of elements: \a group1 [0,4] and \a group2 [ 0,1,2 ],
9798 * then there are 3 families:
9799 * - \a family1 (with ID 1) contains element [0] belonging to ( \a group1 + \a group2 ),
9800 * - \a family2 (with ID 2) contains elements [4] belonging to ( \a group1 ),
9801 * - \a family3 (with ID 3) contains element [1,2] belonging to ( \a group2 ), <br>
9802 * and the result array contains IDs of families [ 1,3,3,0,2 ]. <br> Note a family ID 0 which
9803 * stands for the element #3 which is in none of groups.
9805 * \param [in] groups - sequence of groups of element IDs.
9806 * \param [in] newNb - total number of elements; it must be more than max ID of element
9808 * \param [out] fidsOfGroups - IDs of families the elements of each group belong to.
9809 * \return DataArrayInt * - a new instance of DataArrayInt containing IDs of families
9810 * each element with ID from range [0, \a newNb ) belongs to. The caller is to
9811 * delete this array using decrRef() as it is no more needed.
9812 * \throw If any element ID in \a groups violates condition ( 0 <= ID < \a newNb ).
9814 DataArrayInt *DataArrayInt::MakePartition(const std::vector<const DataArrayInt *>& groups, int newNb, std::vector< std::vector<int> >& fidsOfGroups)
9816 std::vector<const DataArrayInt *> groups2;
9817 for(std::vector<const DataArrayInt *>::const_iterator it4=groups.begin();it4!=groups.end();it4++)
9819 groups2.push_back(*it4);
9820 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9821 ret->alloc(newNb,1);
9822 int *retPtr=ret->getPointer();
9823 std::fill(retPtr,retPtr+newNb,0);
9825 for(std::vector<const DataArrayInt *>::const_iterator iter=groups2.begin();iter!=groups2.end();iter++)
9827 const int *ptr=(*iter)->getConstPointer();
9828 std::size_t nbOfElem=(*iter)->getNbOfElems();
9830 for(int j=0;j<sfid;j++)
9833 for(std::size_t i=0;i<nbOfElem;i++)
9835 if(ptr[i]>=0 && ptr[i]<newNb)
9837 if(retPtr[ptr[i]]==j)
9845 std::ostringstream oss; oss << "DataArrayInt::MakePartition : In group \"" << (*iter)->getName() << "\" in tuple #" << i << " value = " << ptr[i] << " ! Should be in [0," << newNb;
9847 throw INTERP_KERNEL::Exception(oss.str().c_str());
9854 fidsOfGroups.clear();
9855 fidsOfGroups.resize(groups2.size());
9857 for(std::vector<const DataArrayInt *>::const_iterator iter=groups2.begin();iter!=groups2.end();iter++,grId++)
9860 const int *ptr=(*iter)->getConstPointer();
9861 std::size_t nbOfElem=(*iter)->getNbOfElems();
9862 for(const int *p=ptr;p!=ptr+nbOfElem;p++)
9863 tmp.insert(retPtr[*p]);
9864 fidsOfGroups[grId].insert(fidsOfGroups[grId].end(),tmp.begin(),tmp.end());
9870 * Returns a new DataArrayInt which contains all elements of given one-dimensional
9871 * arrays. The result array does not contain any duplicates and its values
9872 * are sorted in ascending order.
9873 * \param [in] arr - sequence of DataArrayInt's to unite.
9874 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9875 * array using decrRef() as it is no more needed.
9876 * \throw If any \a arr[i] is not allocated.
9877 * \throw If \a arr[i]->getNumberOfComponents() != 1.
9879 DataArrayInt *DataArrayInt::BuildUnion(const std::vector<const DataArrayInt *>& arr)
9881 std::vector<const DataArrayInt *> a;
9882 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9885 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9887 (*it)->checkAllocated();
9888 if((*it)->getNumberOfComponents()!=1)
9889 throw INTERP_KERNEL::Exception("DataArrayInt::BuildUnion : only single component allowed !");
9893 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9895 const int *pt=(*it)->getConstPointer();
9896 int nbOfTuples=(*it)->getNumberOfTuples();
9897 r.insert(pt,pt+nbOfTuples);
9899 DataArrayInt *ret=DataArrayInt::New();
9900 ret->alloc((int)r.size(),1);
9901 std::copy(r.begin(),r.end(),ret->getPointer());
9906 * Returns a new DataArrayInt which contains elements present in each of given one-dimensional
9907 * arrays. The result array does not contain any duplicates and its values
9908 * are sorted in ascending order.
9909 * \param [in] arr - sequence of DataArrayInt's to intersect.
9910 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9911 * array using decrRef() as it is no more needed.
9912 * \throw If any \a arr[i] is not allocated.
9913 * \throw If \a arr[i]->getNumberOfComponents() != 1.
9915 DataArrayInt *DataArrayInt::BuildIntersection(const std::vector<const DataArrayInt *>& arr)
9917 std::vector<const DataArrayInt *> a;
9918 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9921 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9923 (*it)->checkAllocated();
9924 if((*it)->getNumberOfComponents()!=1)
9925 throw INTERP_KERNEL::Exception("DataArrayInt::BuildIntersection : only single component allowed !");
9929 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9931 const int *pt=(*it)->getConstPointer();
9932 int nbOfTuples=(*it)->getNumberOfTuples();
9933 std::set<int> s1(pt,pt+nbOfTuples);
9937 std::set_intersection(r.begin(),r.end(),s1.begin(),s1.end(),inserter(r2,r2.end()));
9943 DataArrayInt *ret(DataArrayInt::New());
9944 ret->alloc((int)r.size(),1);
9945 std::copy(r.begin(),r.end(),ret->getPointer());
9950 namespace ParaMEDMEMImpl
9955 OpSwitchedOn(int *pt):_pt(pt),_cnt(0) { }
9956 void operator()(const bool& b) { if(b) *_pt++=_cnt; _cnt++; }
9965 OpSwitchedOff(int *pt):_pt(pt),_cnt(0) { }
9966 void operator()(const bool& b) { if(!b) *_pt++=_cnt; _cnt++; }
9975 * This method returns the list of ids in ascending mode so that v[id]==true.
9977 DataArrayInt *DataArrayInt::BuildListOfSwitchedOn(const std::vector<bool>& v)
9979 int sz((int)std::count(v.begin(),v.end(),true));
9980 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
9981 std::for_each(v.begin(),v.end(),ParaMEDMEMImpl::OpSwitchedOn(ret->getPointer()));
9986 * This method returns the list of ids in ascending mode so that v[id]==false.
9988 DataArrayInt *DataArrayInt::BuildListOfSwitchedOff(const std::vector<bool>& v)
9990 int sz((int)std::count(v.begin(),v.end(),false));
9991 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
9992 std::for_each(v.begin(),v.end(),ParaMEDMEMImpl::OpSwitchedOff(ret->getPointer()));
9997 * This method allows to put a vector of vector of integer into a more compact data stucture (skyline).
9998 * This method is not available into python because no available optimized data structure available to map std::vector< std::vector<int> >.
10000 * \param [in] v the input data structure to be translate into skyline format.
10001 * \param [out] data the first element of the skyline format. The user is expected to deal with newly allocated array.
10002 * \param [out] dataIndex the second element of the skyline format.
10004 void DataArrayInt::PutIntoToSkylineFrmt(const std::vector< std::vector<int> >& v, DataArrayInt *& data, DataArrayInt *& dataIndex)
10006 int sz((int)v.size());
10007 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret0(DataArrayInt::New()),ret1(DataArrayInt::New());
10008 ret1->alloc(sz+1,1);
10009 int *pt(ret1->getPointer()); *pt=0;
10010 for(int i=0;i<sz;i++,pt++)
10011 pt[1]=pt[0]+(int)v[i].size();
10012 ret0->alloc(ret1->back(),1);
10013 pt=ret0->getPointer();
10014 for(int i=0;i<sz;i++)
10015 pt=std::copy(v[i].begin(),v[i].end(),pt);
10016 data=ret0.retn(); dataIndex=ret1.retn();
10020 * Returns a new DataArrayInt which contains a complement of elements of \a this
10021 * one-dimensional array. I.e. the result array contains all elements from the range [0,
10022 * \a nbOfElement) not present in \a this array.
10023 * \param [in] nbOfElement - maximal size of the result array.
10024 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
10025 * array using decrRef() as it is no more needed.
10026 * \throw If \a this is not allocated.
10027 * \throw If \a this->getNumberOfComponents() != 1.
10028 * \throw If any element \a x of \a this array violates condition ( 0 <= \a x < \a
10031 DataArrayInt *DataArrayInt::buildComplement(int nbOfElement) const
10034 if(getNumberOfComponents()!=1)
10035 throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : only single component allowed !");
10036 std::vector<bool> tmp(nbOfElement);
10037 const int *pt=getConstPointer();
10038 int nbOfTuples=getNumberOfTuples();
10039 for(const int *w=pt;w!=pt+nbOfTuples;w++)
10040 if(*w>=0 && *w<nbOfElement)
10043 throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : an element is not in valid range : [0,nbOfElement) !");
10044 int nbOfRetVal=(int)std::count(tmp.begin(),tmp.end(),false);
10045 DataArrayInt *ret=DataArrayInt::New();
10046 ret->alloc(nbOfRetVal,1);
10048 int *retPtr=ret->getPointer();
10049 for(int i=0;i<nbOfElement;i++)
10056 * Returns a new DataArrayInt containing elements of \a this one-dimensional missing
10057 * from an \a other one-dimensional array.
10058 * \param [in] other - a DataArrayInt containing elements not to include in the result array.
10059 * \return DataArrayInt * - a new instance of DataArrayInt with one component. The
10060 * caller is to delete this array using decrRef() as it is no more needed.
10061 * \throw If \a other is NULL.
10062 * \throw If \a other is not allocated.
10063 * \throw If \a other->getNumberOfComponents() != 1.
10064 * \throw If \a this is not allocated.
10065 * \throw If \a this->getNumberOfComponents() != 1.
10066 * \sa DataArrayInt::buildSubstractionOptimized()
10068 DataArrayInt *DataArrayInt::buildSubstraction(const DataArrayInt *other) const
10071 throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : DataArrayInt pointer in input is NULL !");
10073 other->checkAllocated();
10074 if(getNumberOfComponents()!=1)
10075 throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed !");
10076 if(other->getNumberOfComponents()!=1)
10077 throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed for other type !");
10078 const int *pt=getConstPointer();
10079 int nbOfTuples=getNumberOfTuples();
10080 std::set<int> s1(pt,pt+nbOfTuples);
10081 pt=other->getConstPointer();
10082 nbOfTuples=other->getNumberOfTuples();
10083 std::set<int> s2(pt,pt+nbOfTuples);
10084 std::vector<int> r;
10085 std::set_difference(s1.begin(),s1.end(),s2.begin(),s2.end(),std::back_insert_iterator< std::vector<int> >(r));
10086 DataArrayInt *ret=DataArrayInt::New();
10087 ret->alloc((int)r.size(),1);
10088 std::copy(r.begin(),r.end(),ret->getPointer());
10093 * \a this is expected to have one component and to be sorted ascendingly (as for \a other).
10094 * \a other is expected to be a part of \a this. If not DataArrayInt::buildSubstraction should be called instead.
10096 * \param [in] other an array with one component and expected to be sorted ascendingly.
10097 * \ret list of ids in \a this but not in \a other.
10098 * \sa DataArrayInt::buildSubstraction
10100 DataArrayInt *DataArrayInt::buildSubstractionOptimized(const DataArrayInt *other) const
10102 static const char *MSG="DataArrayInt::buildSubstractionOptimized : only single component allowed !";
10103 if(!other) throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstractionOptimized : NULL input array !");
10104 checkAllocated(); other->checkAllocated();
10105 if(getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception(MSG);
10106 if(other->getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception(MSG);
10107 const int *pt1Bg(begin()),*pt1End(end()),*pt2Bg(other->begin()),*pt2End(other->end());
10108 const int *work1(pt1Bg),*work2(pt2Bg);
10109 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
10110 for(;work1!=pt1End;work1++)
10112 if(work2!=pt2End && *work1==*work2)
10115 ret->pushBackSilent(*work1);
10122 * Returns a new DataArrayInt which contains all elements of \a this and a given
10123 * one-dimensional arrays. The result array does not contain any duplicates
10124 * and its values are sorted in ascending order.
10125 * \param [in] other - an array to unite with \a this one.
10126 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
10127 * array using decrRef() as it is no more needed.
10128 * \throw If \a this or \a other is not allocated.
10129 * \throw If \a this->getNumberOfComponents() != 1.
10130 * \throw If \a other->getNumberOfComponents() != 1.
10132 DataArrayInt *DataArrayInt::buildUnion(const DataArrayInt *other) const
10134 std::vector<const DataArrayInt *>arrs(2);
10135 arrs[0]=this; arrs[1]=other;
10136 return BuildUnion(arrs);
10141 * Returns a new DataArrayInt which contains elements present in both \a this and a given
10142 * one-dimensional arrays. The result array does not contain any duplicates
10143 * and its values are sorted in ascending order.
10144 * \param [in] other - an array to intersect with \a this one.
10145 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
10146 * array using decrRef() as it is no more needed.
10147 * \throw If \a this or \a other is not allocated.
10148 * \throw If \a this->getNumberOfComponents() != 1.
10149 * \throw If \a other->getNumberOfComponents() != 1.
10151 DataArrayInt *DataArrayInt::buildIntersection(const DataArrayInt *other) const
10153 std::vector<const DataArrayInt *>arrs(2);
10154 arrs[0]=this; arrs[1]=other;
10155 return BuildIntersection(arrs);
10159 * This method can be applied on allocated with one component DataArrayInt instance.
10160 * This method is typically relevant for sorted arrays. All consecutive duplicated items in \a this will appear only once in returned DataArrayInt instance.
10161 * 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]
10163 * \return a newly allocated array that contain the result of the unique operation applied on \a this.
10164 * \throw if \a this is not allocated or if \a this has not exactly one component.
10165 * \sa DataArrayInt::buildUniqueNotSorted
10167 DataArrayInt *DataArrayInt::buildUnique() const
10170 if(getNumberOfComponents()!=1)
10171 throw INTERP_KERNEL::Exception("DataArrayInt::buildUnique : only single component allowed !");
10172 int nbOfTuples=getNumberOfTuples();
10173 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=deepCpy();
10174 int *data=tmp->getPointer();
10175 int *last=std::unique(data,data+nbOfTuples);
10176 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10177 ret->alloc(std::distance(data,last),1);
10178 std::copy(data,last,ret->getPointer());
10183 * This method can be applied on allocated with one component DataArrayInt instance.
10184 * This method keep elements only once by keeping the same order in \a this that is not expected to be sorted.
10186 * \return a newly allocated array that contain the result of the unique operation applied on \a this.
10188 * \throw if \a this is not allocated or if \a this has not exactly one component.
10190 * \sa DataArrayInt::buildUnique
10192 DataArrayInt *DataArrayInt::buildUniqueNotSorted() const
10195 if(getNumberOfComponents()!=1)
10196 throw INTERP_KERNEL::Exception("DataArrayInt::buildUniqueNotSorted : only single component allowed !");
10198 getMinMaxValues(minVal,maxVal);
10199 std::vector<bool> b(maxVal-minVal+1,false);
10200 const int *ptBg(begin()),*endBg(end());
10201 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
10202 for(const int *pt=ptBg;pt!=endBg;pt++)
10206 ret->pushBackSilent(*pt);
10207 b[*pt-minVal]=true;
10210 ret->copyStringInfoFrom(*this);
10215 * Returns a new DataArrayInt which contains size of every of groups described by \a this
10216 * "index" array. Such "index" array is returned for example by
10217 * \ref ParaMEDMEM::MEDCouplingUMesh::buildDescendingConnectivity
10218 * "MEDCouplingUMesh::buildDescendingConnectivity" and
10219 * \ref ParaMEDMEM::MEDCouplingUMesh::getNodalConnectivityIndex
10220 * "MEDCouplingUMesh::getNodalConnectivityIndex" etc.
10221 * This method preforms the reverse operation of DataArrayInt::computeOffsets2.
10222 * \return DataArrayInt * - a new instance of DataArrayInt, whose number of tuples
10223 * equals to \a this->getNumberOfComponents() - 1, and number of components is 1.
10224 * The caller is to delete this array using decrRef() as it is no more needed.
10225 * \throw If \a this is not allocated.
10226 * \throw If \a this->getNumberOfComponents() != 1.
10227 * \throw If \a this->getNumberOfTuples() < 2.
10230 * - this contains [1,3,6,7,7,9,15]
10231 * - result array contains [2,3,1,0,2,6],
10232 * where 2 = 3 - 1, 3 = 6 - 3, 1 = 7 - 6 etc.
10234 * \sa DataArrayInt::computeOffsets2
10236 DataArrayInt *DataArrayInt::deltaShiftIndex() const
10239 if(getNumberOfComponents()!=1)
10240 throw INTERP_KERNEL::Exception("DataArrayInt::deltaShiftIndex : only single component allowed !");
10241 int nbOfTuples=getNumberOfTuples();
10243 throw INTERP_KERNEL::Exception("DataArrayInt::deltaShiftIndex : 1 tuple at least must be present in 'this' !");
10244 const int *ptr=getConstPointer();
10245 DataArrayInt *ret=DataArrayInt::New();
10246 ret->alloc(nbOfTuples-1,1);
10247 int *out=ret->getPointer();
10248 std::transform(ptr+1,ptr+nbOfTuples,ptr,out,std::minus<int>());
10253 * Modifies \a this one-dimensional array so that value of each element \a x
10254 * of \a this array (\a a) is computed as \f$ x_i = \sum_{j=0}^{i-1} a[ j ] \f$.
10255 * Or: for each i>0 new[i]=new[i-1]+old[i-1] for i==0 new[i]=0. Number of tuples
10256 * and components remains the same.<br>
10257 * This method is useful for allToAllV in MPI with contiguous policy. This method
10258 * differs from computeOffsets2() in that the number of tuples is \b not changed by
10260 * \throw If \a this is not allocated.
10261 * \throw If \a this->getNumberOfComponents() != 1.
10264 * - Before \a this contains [3,5,1,2,0,8]
10265 * - After \a this contains [0,3,8,9,11,11]<br>
10266 * Note that the last element 19 = 11 + 8 is missing because size of \a this
10267 * array is retained and thus there is no space to store the last element.
10269 void DataArrayInt::computeOffsets()
10272 if(getNumberOfComponents()!=1)
10273 throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsets : only single component allowed !");
10274 int nbOfTuples=getNumberOfTuples();
10277 int *work=getPointer();
10280 for(int i=1;i<nbOfTuples;i++)
10283 work[i]=work[i-1]+tmp;
10291 * Modifies \a this one-dimensional array so that value of each element \a x
10292 * of \a this array (\a a) is computed as \f$ x_i = \sum_{j=0}^{i-1} a[ j ] \f$.
10293 * Or: for each i>0 new[i]=new[i-1]+old[i-1] for i==0 new[i]=0. Number
10294 * components remains the same and number of tuples is inceamented by one.<br>
10295 * This method is useful for allToAllV in MPI with contiguous policy. This method
10296 * differs from computeOffsets() in that the number of tuples is changed by this one.
10297 * This method preforms the reverse operation of DataArrayInt::deltaShiftIndex.
10298 * \throw If \a this is not allocated.
10299 * \throw If \a this->getNumberOfComponents() != 1.
10302 * - Before \a this contains [3,5,1,2,0,8]
10303 * - After \a this contains [0,3,8,9,11,11,19]<br>
10304 * \sa DataArrayInt::deltaShiftIndex
10306 void DataArrayInt::computeOffsets2()
10309 if(getNumberOfComponents()!=1)
10310 throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsets2 : only single component allowed !");
10311 int nbOfTuples=getNumberOfTuples();
10312 int *ret=(int *)malloc((nbOfTuples+1)*sizeof(int));
10315 const int *work=getConstPointer();
10317 for(int i=0;i<nbOfTuples;i++)
10318 ret[i+1]=work[i]+ret[i];
10319 useArray(ret,true,C_DEALLOC,nbOfTuples+1,1);
10324 * Returns two new DataArrayInt instances whose contents is computed from that of \a this and \a listOfIds arrays as follows.
10325 * \a this is expected to be an offset format ( as returned by DataArrayInt::computeOffsets2 ) that is to say with one component
10326 * and ** sorted strictly increasingly **. \a listOfIds is expected to be sorted ascendingly (not strictly needed for \a listOfIds).
10327 * This methods searches in \a this, considered as a set of contiguous \c this->getNumberOfComponents() ranges, all ids in \a listOfIds
10328 * filling completely one of the ranges in \a this.
10330 * \param [in] listOfIds a list of ids that has to be sorted ascendingly.
10331 * \param [out] rangeIdsFetched the range ids fetched
10332 * \param [out] idsInInputListThatFetch contains the list of ids in \a listOfIds that are \b fully included in a range in \a this. So
10333 * \a idsInInputListThatFetch is a part of input \a listOfIds.
10335 * \sa DataArrayInt::computeOffsets2
10338 * - \a this : [0,3,7,9,15,18]
10339 * - \a listOfIds contains [0,1,2,3,7,8,15,16,17]
10340 * - \a rangeIdsFetched result array: [0,2,4]
10341 * - \a idsInInputListThatFetch result array: [0,1,2,7,8,15,16,17]
10342 * In this example id 3 in input \a listOfIds is alone so it do not appear in output \a idsInInputListThatFetch.
10345 void DataArrayInt::searchRangesInListOfIds(const DataArrayInt *listOfIds, DataArrayInt *& rangeIdsFetched, DataArrayInt *& idsInInputListThatFetch) const
10348 throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : input list of ids is null !");
10349 listOfIds->checkAllocated(); checkAllocated();
10350 if(listOfIds->getNumberOfComponents()!=1)
10351 throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : input list of ids must have exactly one component !");
10352 if(getNumberOfComponents()!=1)
10353 throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : this must have exactly one component !");
10354 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret0=DataArrayInt::New(); ret0->alloc(0,1);
10355 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New(); ret1->alloc(0,1);
10356 const int *tupEnd(listOfIds->end()),*offBg(begin()),*offEnd(end()-1);
10357 const int *tupPtr(listOfIds->begin()),*offPtr(offBg);
10358 while(tupPtr!=tupEnd && offPtr!=offEnd)
10360 if(*tupPtr==*offPtr)
10363 while(i<offPtr[1] && *tupPtr==i && tupPtr!=tupEnd) { i++; tupPtr++; }
10366 ret0->pushBackSilent((int)std::distance(offBg,offPtr));
10367 ret1->pushBackValsSilent(tupPtr-(offPtr[1]-offPtr[0]),tupPtr);
10372 { if(*tupPtr<*offPtr) tupPtr++; else offPtr++; }
10374 rangeIdsFetched=ret0.retn();
10375 idsInInputListThatFetch=ret1.retn();
10379 * Returns a new DataArrayInt whose contents is computed from that of \a this and \a
10380 * offsets arrays as follows. \a offsets is a one-dimensional array considered as an
10381 * "index" array of a "iota" array, thus, whose each element gives an index of a group
10382 * beginning within the "iota" array. And \a this is a one-dimensional array
10383 * considered as a selector of groups described by \a offsets to include into the result array.
10384 * \throw If \a offsets is NULL.
10385 * \throw If \a offsets is not allocated.
10386 * \throw If \a offsets->getNumberOfComponents() != 1.
10387 * \throw If \a offsets is not monotonically increasing.
10388 * \throw If \a this is not allocated.
10389 * \throw If \a this->getNumberOfComponents() != 1.
10390 * \throw If any element of \a this is not a valid index for \a offsets array.
10393 * - \a this: [0,2,3]
10394 * - \a offsets: [0,3,6,10,14,20]
10395 * - result array: [0,1,2,6,7,8,9,10,11,12,13] == <br>
10396 * \c range(0,3) + \c range(6,10) + \c range(10,14) ==<br>
10397 * \c range( \a offsets[ \a this[0] ], offsets[ \a this[0]+1 ]) +
10398 * \c range( \a offsets[ \a this[1] ], offsets[ \a this[1]+1 ]) +
10399 * \c range( \a offsets[ \a this[2] ], offsets[ \a this[2]+1 ])
10401 DataArrayInt *DataArrayInt::buildExplicitArrByRanges(const DataArrayInt *offsets) const
10404 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : DataArrayInt pointer in input is NULL !");
10406 if(getNumberOfComponents()!=1)
10407 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : only single component allowed !");
10408 offsets->checkAllocated();
10409 if(offsets->getNumberOfComponents()!=1)
10410 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : input array should have only single component !");
10411 int othNbTuples=offsets->getNumberOfTuples()-1;
10412 int nbOfTuples=getNumberOfTuples();
10413 int retNbOftuples=0;
10414 const int *work=getConstPointer();
10415 const int *offPtr=offsets->getConstPointer();
10416 for(int i=0;i<nbOfTuples;i++)
10419 if(val>=0 && val<othNbTuples)
10421 int delta=offPtr[val+1]-offPtr[val];
10423 retNbOftuples+=delta;
10426 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrByRanges : Tuple #" << val << " of offset array has a delta < 0 !";
10427 throw INTERP_KERNEL::Exception(oss.str().c_str());
10432 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrByRanges : Tuple #" << i << " in this contains " << val;
10433 oss << " whereas offsets array is of size " << othNbTuples+1 << " !";
10434 throw INTERP_KERNEL::Exception(oss.str().c_str());
10437 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10438 ret->alloc(retNbOftuples,1);
10439 int *retPtr=ret->getPointer();
10440 for(int i=0;i<nbOfTuples;i++)
10443 int start=offPtr[val];
10444 int off=offPtr[val+1]-start;
10445 for(int j=0;j<off;j++,retPtr++)
10452 * Returns a new DataArrayInt whose contents is computed using \a this that must be a
10453 * scaled array (monotonically increasing).
10454 from that of \a this and \a
10455 * offsets arrays as follows. \a offsets is a one-dimensional array considered as an
10456 * "index" array of a "iota" array, thus, whose each element gives an index of a group
10457 * beginning within the "iota" array. And \a this is a one-dimensional array
10458 * considered as a selector of groups described by \a offsets to include into the result array.
10459 * \throw If \a is NULL.
10460 * \throw If \a this is not allocated.
10461 * \throw If \a this->getNumberOfComponents() != 1.
10462 * \throw If \a this->getNumberOfTuples() == 0.
10463 * \throw If \a this is not monotonically increasing.
10464 * \throw If any element of ids in ( \a bg \a stop \a step ) points outside the scale in \a this.
10467 * - \a bg , \a stop and \a step : (0,5,2)
10468 * - \a this: [0,3,6,10,14,20]
10469 * - result array: [0,0,0, 2,2,2,2, 4,4,4,4,4,4] == <br>
10471 DataArrayInt *DataArrayInt::buildExplicitArrOfSliceOnScaledArr(int bg, int stop, int step) const
10474 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : not allocated array !");
10475 if(getNumberOfComponents()!=1)
10476 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : number of components is expected to be equal to one !");
10477 int nbOfTuples(getNumberOfTuples());
10479 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : number of tuples must be != 0 !");
10480 const int *ids(begin());
10481 int nbOfEltsInSlc(GetNumberOfItemGivenBESRelative(bg,stop,step,"DataArrayInt::buildExplicitArrOfSliceOnScaledArr")),sz(0),pos(bg);
10482 for(int i=0;i<nbOfEltsInSlc;i++,pos+=step)
10484 if(pos>=0 && pos<nbOfTuples-1)
10486 int delta(ids[pos+1]-ids[pos]);
10490 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrOfSliceOnScaledArr : At pos #" << i << " of input slice, value is " << pos << " and at this pos this is not monotonically increasing !";
10491 throw INTERP_KERNEL::Exception(oss.str().c_str());
10496 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrOfSliceOnScaledArr : At pos #" << i << " of input slice, value is " << pos << " should be in [0," << nbOfTuples-1 << ") !";
10497 throw INTERP_KERNEL::Exception(oss.str().c_str());
10500 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
10501 int *retPtr(ret->getPointer());
10503 for(int i=0;i<nbOfEltsInSlc;i++,pos+=step)
10505 int delta(ids[pos+1]-ids[pos]);
10506 for(int j=0;j<delta;j++,retPtr++)
10513 * 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.
10514 * 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
10515 * in tuple **i** of returned DataArrayInt.
10516 * If ranges overlapped (in theory it should not) this method do not detect it and always returns the first range.
10518 * 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)]
10519 * The return DataArrayInt will contain : **[0,4,1,2,2,3]**
10521 * \param [in] ranges typically come from output of MEDCouplingUMesh::ComputeRangesFromTypeDistribution. Each range is specified like this : 1st component is
10522 * for lower value included and 2nd component is the upper value of corresponding range **excluded**.
10523 * \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
10524 * is thrown if no ranges in \a ranges contains value in \a this.
10526 * \sa DataArrayInt::findIdInRangeForEachTuple
10528 DataArrayInt *DataArrayInt::findRangeIdForEachTuple(const DataArrayInt *ranges) const
10531 throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : null input pointer !");
10532 if(ranges->getNumberOfComponents()!=2)
10533 throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : input DataArrayInt instance should have 2 components !");
10535 if(getNumberOfComponents()!=1)
10536 throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : this should have only one component !");
10537 int nbTuples=getNumberOfTuples();
10538 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTuples,1);
10539 int nbOfRanges=ranges->getNumberOfTuples();
10540 const int *rangesPtr=ranges->getConstPointer();
10541 int *retPtr=ret->getPointer();
10542 const int *inPtr=getConstPointer();
10543 for(int i=0;i<nbTuples;i++,retPtr++)
10547 for(int j=0;j<nbOfRanges && !found;j++)
10548 if(val>=rangesPtr[2*j] && val<rangesPtr[2*j+1])
10549 { *retPtr=j; found=true; }
10554 std::ostringstream oss; oss << "DataArrayInt::findRangeIdForEachTuple : tuple #" << i << " not found by any ranges !";
10555 throw INTERP_KERNEL::Exception(oss.str().c_str());
10562 * 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.
10563 * 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
10564 * in tuple **i** of returned DataArrayInt.
10565 * If ranges overlapped (in theory it should not) this method do not detect it and always returns the sub position of the first range.
10567 * 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)]
10568 * The return DataArrayInt will contain : **[1,2,4,0,2,2]**
10569 * This method is often called in pair with DataArrayInt::findRangeIdForEachTuple method.
10571 * \param [in] ranges typically come from output of MEDCouplingUMesh::ComputeRangesFromTypeDistribution. Each range is specified like this : 1st component is
10572 * for lower value included and 2nd component is the upper value of corresponding range **excluded**.
10573 * \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
10574 * is thrown if no ranges in \a ranges contains value in \a this.
10575 * \sa DataArrayInt::findRangeIdForEachTuple
10577 DataArrayInt *DataArrayInt::findIdInRangeForEachTuple(const DataArrayInt *ranges) const
10580 throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : null input pointer !");
10581 if(ranges->getNumberOfComponents()!=2)
10582 throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : input DataArrayInt instance should have 2 components !");
10584 if(getNumberOfComponents()!=1)
10585 throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : this should have only one component !");
10586 int nbTuples=getNumberOfTuples();
10587 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTuples,1);
10588 int nbOfRanges=ranges->getNumberOfTuples();
10589 const int *rangesPtr=ranges->getConstPointer();
10590 int *retPtr=ret->getPointer();
10591 const int *inPtr=getConstPointer();
10592 for(int i=0;i<nbTuples;i++,retPtr++)
10596 for(int j=0;j<nbOfRanges && !found;j++)
10597 if(val>=rangesPtr[2*j] && val<rangesPtr[2*j+1])
10598 { *retPtr=val-rangesPtr[2*j]; found=true; }
10603 std::ostringstream oss; oss << "DataArrayInt::findIdInRangeForEachTuple : tuple #" << i << " not found by any ranges !";
10604 throw INTERP_KERNEL::Exception(oss.str().c_str());
10611 * \b WARNING this method is a \b non \a const \b method. This method works tuple by tuple. Each tuple is expected to be pairs (number of components must be equal to 2).
10612 * This method rearrange each pair in \a this so that, tuple with id \b tid will be after the call \c this->getIJ(tid,0)==this->getIJ(tid-1,1) and \c this->getIJ(tid,1)==this->getIJ(tid+1,0).
10613 * If it is impossible to reach such condition an exception will be thrown ! \b WARNING In case of throw \a this can be partially modified !
10614 * If this method has correctly worked, \a this will be able to be considered as a linked list.
10615 * This method does nothing if number of tuples is lower of equal to 1.
10617 * This method is useful for users having an unstructured mesh having only SEG2 to rearrange internaly the connectibity without any coordinates consideration.
10619 * \sa MEDCouplingUMesh::orderConsecutiveCells1D
10621 void DataArrayInt::sortEachPairToMakeALinkedList()
10624 if(getNumberOfComponents()!=2)
10625 throw INTERP_KERNEL::Exception("DataArrayInt::sortEachPairToMakeALinkedList : Only works on DataArrayInt instance with nb of components equal to 2 !");
10626 int nbOfTuples(getNumberOfTuples());
10629 int *conn(getPointer());
10630 for(int i=1;i<nbOfTuples;i++,conn+=2)
10634 if(conn[2]==conn[3])
10636 std::ostringstream oss; oss << "DataArrayInt::sortEachPairToMakeALinkedList : In the tuple #" << i << " presence of a pair filled with same ids !";
10637 throw INTERP_KERNEL::Exception(oss.str().c_str());
10639 if(conn[2]!=conn[1] && conn[3]==conn[1] && conn[2]!=conn[0])
10640 std::swap(conn[2],conn[3]);
10641 //not(conn[2]==conn[1] && conn[3]!=conn[1] && conn[3]!=conn[0])
10642 if(conn[2]!=conn[1] || conn[3]==conn[1] || conn[3]==conn[0])
10644 std::ostringstream oss; oss << "DataArrayInt::sortEachPairToMakeALinkedList : In the tuple #" << i << " something is invalid !";
10645 throw INTERP_KERNEL::Exception(oss.str().c_str());
10650 if(conn[0]==conn[1] || conn[2]==conn[3])
10651 throw INTERP_KERNEL::Exception("DataArrayInt::sortEachPairToMakeALinkedList : In the 2 first tuples presence of a pair filled with same ids !");
10654 s.insert(conn,conn+4);
10656 throw INTERP_KERNEL::Exception("DataArrayInt::sortEachPairToMakeALinkedList : This can't be considered as a linked list regarding 2 first tuples !");
10657 if(std::count(conn,conn+4,conn[0])==2)
10662 if(conn[2]==conn[0])
10663 { tmp[3]=conn[3]; }
10666 std::copy(tmp,tmp+4,conn);
10674 * \param [in] nbTimes specifies the nb of times each tuples in \a this will be duplicated contiguouly in returned DataArrayInt instance.
10675 * \a nbTimes should be at least equal to 1.
10676 * \return a newly allocated DataArrayInt having one component and number of tuples equal to \a nbTimes * \c this->getNumberOfTuples.
10677 * \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.
10679 DataArrayInt *DataArrayInt::duplicateEachTupleNTimes(int nbTimes) const
10682 if(getNumberOfComponents()!=1)
10683 throw INTERP_KERNEL::Exception("DataArrayInt::duplicateEachTupleNTimes : this should have only one component !");
10685 throw INTERP_KERNEL::Exception("DataArrayInt::duplicateEachTupleNTimes : nb times should be >= 1 !");
10686 int nbTuples=getNumberOfTuples();
10687 const int *inPtr=getConstPointer();
10688 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTimes*nbTuples,1);
10689 int *retPtr=ret->getPointer();
10690 for(int i=0;i<nbTuples;i++,inPtr++)
10693 for(int j=0;j<nbTimes;j++,retPtr++)
10696 ret->copyStringInfoFrom(*this);
10701 * This method returns all different values found in \a this. This method throws if \a this has not been allocated.
10702 * But the number of components can be different from one.
10703 * \return a newly allocated array (that should be dealt by the caller) containing different values in \a this.
10705 DataArrayInt *DataArrayInt::getDifferentValues() const
10709 ret.insert(begin(),end());
10710 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret2=DataArrayInt::New(); ret2->alloc((int)ret.size(),1);
10711 std::copy(ret.begin(),ret.end(),ret2->getPointer());
10712 return ret2.retn();
10716 * This method is a refinement of DataArrayInt::getDifferentValues because it returns not only different values in \a this but also, for each of
10717 * them it tells which tuple id have this id.
10718 * This method works only on arrays with one component (if it is not the case call DataArrayInt::rearrange(1) ).
10719 * This method returns two arrays having same size.
10720 * 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.
10721 * 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]]
10723 std::vector<DataArrayInt *> DataArrayInt::partitionByDifferentValues(std::vector<int>& differentIds) const
10726 if(getNumberOfComponents()!=1)
10727 throw INTERP_KERNEL::Exception("DataArrayInt::partitionByDifferentValues : this should have only one component !");
10729 std::map<int,int> m,m2,m3;
10730 for(const int *w=begin();w!=end();w++)
10732 differentIds.resize(m.size());
10733 std::vector<DataArrayInt *> ret(m.size());
10734 std::vector<int *> retPtr(m.size());
10735 for(std::map<int,int>::const_iterator it=m.begin();it!=m.end();it++,id++)
10737 m2[(*it).first]=id;
10738 ret[id]=DataArrayInt::New();
10739 ret[id]->alloc((*it).second,1);
10740 retPtr[id]=ret[id]->getPointer();
10741 differentIds[id]=(*it).first;
10744 for(const int *w=begin();w!=end();w++,id++)
10746 retPtr[m2[*w]][m3[*w]++]=id;
10752 * This method split ids in [0, \c this->getNumberOfTuples() ) using \a this array as a field of weight (>=0 each).
10753 * The aim of this method is to return a set of \a nbOfSlices chunk of contiguous ids as balanced as possible.
10755 * \param [in] nbOfSlices - number of slices expected.
10756 * \return - a vector having a size equal to \a nbOfSlices giving the start (included) and the stop (excluded) of each chunks.
10758 * \sa DataArray::GetSlice
10759 * \throw If \a this is not allocated or not with exactly one component.
10760 * \throw If an element in \a this if < 0.
10762 std::vector< std::pair<int,int> > DataArrayInt::splitInBalancedSlices(int nbOfSlices) const
10764 if(!isAllocated() || getNumberOfComponents()!=1)
10765 throw INTERP_KERNEL::Exception("DataArrayInt::splitInBalancedSlices : this array should have number of components equal to one and must be allocated !");
10767 throw INTERP_KERNEL::Exception("DataArrayInt::splitInBalancedSlices : number of slices must be >= 1 !");
10768 int sum(accumulate(0)),nbOfTuples(getNumberOfTuples());
10769 int sumPerSlc(sum/nbOfSlices),pos(0);
10770 const int *w(begin());
10771 std::vector< std::pair<int,int> > ret(nbOfSlices);
10772 for(int i=0;i<nbOfSlices;i++)
10774 std::pair<int,int> p(pos,-1);
10776 while(locSum<sumPerSlc && pos<nbOfTuples) { pos++; locSum+=*w++; }
10777 if(i!=nbOfSlices-1)
10780 p.second=nbOfTuples;
10787 * Returns a new DataArrayInt that is a sum of two given arrays. There are 3
10789 * 1. The arrays have same number of tuples and components. Then each value of
10790 * the result array (_a_) is a sum of the corresponding values of \a a1 and \a a2,
10791 * i.e.: _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, j ].
10792 * 2. The arrays have same number of tuples and one array, say _a2_, has one
10794 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, 0 ].
10795 * 3. The arrays have same number of components and one array, say _a2_, has one
10797 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ 0, j ].
10799 * Info on components is copied either from the first array (in the first case) or from
10800 * the array with maximal number of elements (getNbOfElems()).
10801 * \param [in] a1 - an array to sum up.
10802 * \param [in] a2 - another array to sum up.
10803 * \return DataArrayInt * - the new instance of DataArrayInt.
10804 * The caller is to delete this result array using decrRef() as it is no more
10806 * \throw If either \a a1 or \a a2 is NULL.
10807 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
10808 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
10809 * none of them has number of tuples or components equal to 1.
10811 DataArrayInt *DataArrayInt::Add(const DataArrayInt *a1, const DataArrayInt *a2)
10814 throw INTERP_KERNEL::Exception("DataArrayInt::Add : input DataArrayInt instance is NULL !");
10815 int nbOfTuple=a1->getNumberOfTuples();
10816 int nbOfTuple2=a2->getNumberOfTuples();
10817 int nbOfComp=a1->getNumberOfComponents();
10818 int nbOfComp2=a2->getNumberOfComponents();
10819 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=0;
10820 if(nbOfTuple==nbOfTuple2)
10822 if(nbOfComp==nbOfComp2)
10824 ret=DataArrayInt::New();
10825 ret->alloc(nbOfTuple,nbOfComp);
10826 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::plus<int>());
10827 ret->copyStringInfoFrom(*a1);
10831 int nbOfCompMin,nbOfCompMax;
10832 const DataArrayInt *aMin, *aMax;
10833 if(nbOfComp>nbOfComp2)
10835 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
10840 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
10845 ret=DataArrayInt::New();
10846 ret->alloc(nbOfTuple,nbOfCompMax);
10847 const int *aMinPtr=aMin->getConstPointer();
10848 const int *aMaxPtr=aMax->getConstPointer();
10849 int *res=ret->getPointer();
10850 for(int i=0;i<nbOfTuple;i++)
10851 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::plus<int>(),aMinPtr[i]));
10852 ret->copyStringInfoFrom(*aMax);
10855 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
10858 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
10860 if(nbOfComp==nbOfComp2)
10862 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
10863 const DataArrayInt *aMin=nbOfTuple>nbOfTuple2?a2:a1;
10864 const DataArrayInt *aMax=nbOfTuple>nbOfTuple2?a1:a2;
10865 const int *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
10866 ret=DataArrayInt::New();
10867 ret->alloc(nbOfTupleMax,nbOfComp);
10868 int *res=ret->getPointer();
10869 for(int i=0;i<nbOfTupleMax;i++)
10870 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::plus<int>());
10871 ret->copyStringInfoFrom(*aMax);
10874 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
10877 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Add !");
10882 * Adds values of another DataArrayInt to values of \a this one. There are 3
10884 * 1. The arrays have same number of tuples and components. Then each value of
10885 * \a other array is added to the corresponding value of \a this array, i.e.:
10886 * _a_ [ i, j ] += _other_ [ i, j ].
10887 * 2. The arrays have same number of tuples and \a other array has one component. Then
10888 * _a_ [ i, j ] += _other_ [ i, 0 ].
10889 * 3. The arrays have same number of components and \a other array has one tuple. Then
10890 * _a_ [ i, j ] += _a2_ [ 0, j ].
10892 * \param [in] other - an array to add to \a this one.
10893 * \throw If \a other is NULL.
10894 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
10895 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
10896 * \a other has number of both tuples and components not equal to 1.
10898 void DataArrayInt::addEqual(const DataArrayInt *other)
10901 throw INTERP_KERNEL::Exception("DataArrayInt::addEqual : input DataArrayInt instance is NULL !");
10902 const char *msg="Nb of tuples mismatch for DataArrayInt::addEqual !";
10903 checkAllocated(); other->checkAllocated();
10904 int nbOfTuple=getNumberOfTuples();
10905 int nbOfTuple2=other->getNumberOfTuples();
10906 int nbOfComp=getNumberOfComponents();
10907 int nbOfComp2=other->getNumberOfComponents();
10908 if(nbOfTuple==nbOfTuple2)
10910 if(nbOfComp==nbOfComp2)
10912 std::transform(begin(),end(),other->begin(),getPointer(),std::plus<int>());
10914 else if(nbOfComp2==1)
10916 int *ptr=getPointer();
10917 const int *ptrc=other->getConstPointer();
10918 for(int i=0;i<nbOfTuple;i++)
10919 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::plus<int>(),*ptrc++));
10922 throw INTERP_KERNEL::Exception(msg);
10924 else if(nbOfTuple2==1)
10926 if(nbOfComp2==nbOfComp)
10928 int *ptr=getPointer();
10929 const int *ptrc=other->getConstPointer();
10930 for(int i=0;i<nbOfTuple;i++)
10931 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::plus<int>());
10934 throw INTERP_KERNEL::Exception(msg);
10937 throw INTERP_KERNEL::Exception(msg);
10942 * Returns a new DataArrayInt that is a subtraction of two given arrays. There are 3
10944 * 1. The arrays have same number of tuples and components. Then each value of
10945 * the result array (_a_) is a subtraction of the corresponding values of \a a1 and
10946 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, j ].
10947 * 2. The arrays have same number of tuples and one array, say _a2_, has one
10949 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, 0 ].
10950 * 3. The arrays have same number of components and one array, say _a2_, has one
10952 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ 0, j ].
10954 * Info on components is copied either from the first array (in the first case) or from
10955 * the array with maximal number of elements (getNbOfElems()).
10956 * \param [in] a1 - an array to subtract from.
10957 * \param [in] a2 - an array to subtract.
10958 * \return DataArrayInt * - the new instance of DataArrayInt.
10959 * The caller is to delete this result array using decrRef() as it is no more
10961 * \throw If either \a a1 or \a a2 is NULL.
10962 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
10963 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
10964 * none of them has number of tuples or components equal to 1.
10966 DataArrayInt *DataArrayInt::Substract(const DataArrayInt *a1, const DataArrayInt *a2)
10969 throw INTERP_KERNEL::Exception("DataArrayInt::Substract : input DataArrayInt instance is NULL !");
10970 int nbOfTuple1=a1->getNumberOfTuples();
10971 int nbOfTuple2=a2->getNumberOfTuples();
10972 int nbOfComp1=a1->getNumberOfComponents();
10973 int nbOfComp2=a2->getNumberOfComponents();
10974 if(nbOfTuple2==nbOfTuple1)
10976 if(nbOfComp1==nbOfComp2)
10978 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10979 ret->alloc(nbOfTuple2,nbOfComp1);
10980 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::minus<int>());
10981 ret->copyStringInfoFrom(*a1);
10984 else if(nbOfComp2==1)
10986 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10987 ret->alloc(nbOfTuple1,nbOfComp1);
10988 const int *a2Ptr=a2->getConstPointer();
10989 const int *a1Ptr=a1->getConstPointer();
10990 int *res=ret->getPointer();
10991 for(int i=0;i<nbOfTuple1;i++)
10992 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::minus<int>(),a2Ptr[i]));
10993 ret->copyStringInfoFrom(*a1);
10998 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
11002 else if(nbOfTuple2==1)
11004 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
11005 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11006 ret->alloc(nbOfTuple1,nbOfComp1);
11007 const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
11008 int *pt=ret->getPointer();
11009 for(int i=0;i<nbOfTuple1;i++)
11010 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::minus<int>());
11011 ret->copyStringInfoFrom(*a1);
11016 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Substract !");//will always throw an exception
11022 * Subtract values of another DataArrayInt from values of \a this one. There are 3
11024 * 1. The arrays have same number of tuples and components. Then each value of
11025 * \a other array is subtracted from the corresponding value of \a this array, i.e.:
11026 * _a_ [ i, j ] -= _other_ [ i, j ].
11027 * 2. The arrays have same number of tuples and \a other array has one component. Then
11028 * _a_ [ i, j ] -= _other_ [ i, 0 ].
11029 * 3. The arrays have same number of components and \a other array has one tuple. Then
11030 * _a_ [ i, j ] -= _a2_ [ 0, j ].
11032 * \param [in] other - an array to subtract from \a this one.
11033 * \throw If \a other is NULL.
11034 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
11035 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
11036 * \a other has number of both tuples and components not equal to 1.
11038 void DataArrayInt::substractEqual(const DataArrayInt *other)
11041 throw INTERP_KERNEL::Exception("DataArrayInt::substractEqual : input DataArrayInt instance is NULL !");
11042 const char *msg="Nb of tuples mismatch for DataArrayInt::substractEqual !";
11043 checkAllocated(); other->checkAllocated();
11044 int nbOfTuple=getNumberOfTuples();
11045 int nbOfTuple2=other->getNumberOfTuples();
11046 int nbOfComp=getNumberOfComponents();
11047 int nbOfComp2=other->getNumberOfComponents();
11048 if(nbOfTuple==nbOfTuple2)
11050 if(nbOfComp==nbOfComp2)
11052 std::transform(begin(),end(),other->begin(),getPointer(),std::minus<int>());
11054 else if(nbOfComp2==1)
11056 int *ptr=getPointer();
11057 const int *ptrc=other->getConstPointer();
11058 for(int i=0;i<nbOfTuple;i++)
11059 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::minus<int>(),*ptrc++));
11062 throw INTERP_KERNEL::Exception(msg);
11064 else if(nbOfTuple2==1)
11066 int *ptr=getPointer();
11067 const int *ptrc=other->getConstPointer();
11068 for(int i=0;i<nbOfTuple;i++)
11069 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::minus<int>());
11072 throw INTERP_KERNEL::Exception(msg);
11077 * Returns a new DataArrayInt that is a product of two given arrays. There are 3
11079 * 1. The arrays have same number of tuples and components. Then each value of
11080 * the result array (_a_) is a product of the corresponding values of \a a1 and
11081 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, j ].
11082 * 2. The arrays have same number of tuples and one array, say _a2_, has one
11084 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, 0 ].
11085 * 3. The arrays have same number of components and one array, say _a2_, has one
11087 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ 0, j ].
11089 * Info on components is copied either from the first array (in the first case) or from
11090 * the array with maximal number of elements (getNbOfElems()).
11091 * \param [in] a1 - a factor array.
11092 * \param [in] a2 - another factor array.
11093 * \return DataArrayInt * - the new instance of DataArrayInt.
11094 * The caller is to delete this result array using decrRef() as it is no more
11096 * \throw If either \a a1 or \a a2 is NULL.
11097 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
11098 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
11099 * none of them has number of tuples or components equal to 1.
11101 DataArrayInt *DataArrayInt::Multiply(const DataArrayInt *a1, const DataArrayInt *a2)
11104 throw INTERP_KERNEL::Exception("DataArrayInt::Multiply : input DataArrayInt instance is NULL !");
11105 int nbOfTuple=a1->getNumberOfTuples();
11106 int nbOfTuple2=a2->getNumberOfTuples();
11107 int nbOfComp=a1->getNumberOfComponents();
11108 int nbOfComp2=a2->getNumberOfComponents();
11109 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=0;
11110 if(nbOfTuple==nbOfTuple2)
11112 if(nbOfComp==nbOfComp2)
11114 ret=DataArrayInt::New();
11115 ret->alloc(nbOfTuple,nbOfComp);
11116 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::multiplies<int>());
11117 ret->copyStringInfoFrom(*a1);
11121 int nbOfCompMin,nbOfCompMax;
11122 const DataArrayInt *aMin, *aMax;
11123 if(nbOfComp>nbOfComp2)
11125 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
11130 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
11135 ret=DataArrayInt::New();
11136 ret->alloc(nbOfTuple,nbOfCompMax);
11137 const int *aMinPtr=aMin->getConstPointer();
11138 const int *aMaxPtr=aMax->getConstPointer();
11139 int *res=ret->getPointer();
11140 for(int i=0;i<nbOfTuple;i++)
11141 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::multiplies<int>(),aMinPtr[i]));
11142 ret->copyStringInfoFrom(*aMax);
11145 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
11148 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
11150 if(nbOfComp==nbOfComp2)
11152 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
11153 const DataArrayInt *aMin=nbOfTuple>nbOfTuple2?a2:a1;
11154 const DataArrayInt *aMax=nbOfTuple>nbOfTuple2?a1:a2;
11155 const int *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
11156 ret=DataArrayInt::New();
11157 ret->alloc(nbOfTupleMax,nbOfComp);
11158 int *res=ret->getPointer();
11159 for(int i=0;i<nbOfTupleMax;i++)
11160 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::multiplies<int>());
11161 ret->copyStringInfoFrom(*aMax);
11164 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
11167 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Multiply !");
11173 * Multiply values of another DataArrayInt to values of \a this one. There are 3
11175 * 1. The arrays have same number of tuples and components. Then each value of
11176 * \a other array is multiplied to the corresponding value of \a this array, i.e.:
11177 * _a_ [ i, j ] *= _other_ [ i, j ].
11178 * 2. The arrays have same number of tuples and \a other array has one component. Then
11179 * _a_ [ i, j ] *= _other_ [ i, 0 ].
11180 * 3. The arrays have same number of components and \a other array has one tuple. Then
11181 * _a_ [ i, j ] *= _a2_ [ 0, j ].
11183 * \param [in] other - an array to multiply to \a this one.
11184 * \throw If \a other is NULL.
11185 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
11186 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
11187 * \a other has number of both tuples and components not equal to 1.
11189 void DataArrayInt::multiplyEqual(const DataArrayInt *other)
11192 throw INTERP_KERNEL::Exception("DataArrayInt::multiplyEqual : input DataArrayInt instance is NULL !");
11193 const char *msg="Nb of tuples mismatch for DataArrayInt::multiplyEqual !";
11194 checkAllocated(); other->checkAllocated();
11195 int nbOfTuple=getNumberOfTuples();
11196 int nbOfTuple2=other->getNumberOfTuples();
11197 int nbOfComp=getNumberOfComponents();
11198 int nbOfComp2=other->getNumberOfComponents();
11199 if(nbOfTuple==nbOfTuple2)
11201 if(nbOfComp==nbOfComp2)
11203 std::transform(begin(),end(),other->begin(),getPointer(),std::multiplies<int>());
11205 else if(nbOfComp2==1)
11207 int *ptr=getPointer();
11208 const int *ptrc=other->getConstPointer();
11209 for(int i=0;i<nbOfTuple;i++)
11210 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::multiplies<int>(),*ptrc++));
11213 throw INTERP_KERNEL::Exception(msg);
11215 else if(nbOfTuple2==1)
11217 if(nbOfComp2==nbOfComp)
11219 int *ptr=getPointer();
11220 const int *ptrc=other->getConstPointer();
11221 for(int i=0;i<nbOfTuple;i++)
11222 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::multiplies<int>());
11225 throw INTERP_KERNEL::Exception(msg);
11228 throw INTERP_KERNEL::Exception(msg);
11234 * Returns a new DataArrayInt that is a division of two given arrays. There are 3
11236 * 1. The arrays have same number of tuples and components. Then each value of
11237 * the result array (_a_) is a division of the corresponding values of \a a1 and
11238 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, j ].
11239 * 2. The arrays have same number of tuples and one array, say _a2_, has one
11241 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, 0 ].
11242 * 3. The arrays have same number of components and one array, say _a2_, has one
11244 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ 0, j ].
11246 * Info on components is copied either from the first array (in the first case) or from
11247 * the array with maximal number of elements (getNbOfElems()).
11248 * \warning No check of division by zero is performed!
11249 * \param [in] a1 - a numerator array.
11250 * \param [in] a2 - a denominator array.
11251 * \return DataArrayInt * - the new instance of DataArrayInt.
11252 * The caller is to delete this result array using decrRef() as it is no more
11254 * \throw If either \a a1 or \a a2 is NULL.
11255 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
11256 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
11257 * none of them has number of tuples or components equal to 1.
11259 DataArrayInt *DataArrayInt::Divide(const DataArrayInt *a1, const DataArrayInt *a2)
11262 throw INTERP_KERNEL::Exception("DataArrayInt::Divide : input DataArrayInt instance is NULL !");
11263 int nbOfTuple1=a1->getNumberOfTuples();
11264 int nbOfTuple2=a2->getNumberOfTuples();
11265 int nbOfComp1=a1->getNumberOfComponents();
11266 int nbOfComp2=a2->getNumberOfComponents();
11267 if(nbOfTuple2==nbOfTuple1)
11269 if(nbOfComp1==nbOfComp2)
11271 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11272 ret->alloc(nbOfTuple2,nbOfComp1);
11273 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::divides<int>());
11274 ret->copyStringInfoFrom(*a1);
11277 else if(nbOfComp2==1)
11279 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11280 ret->alloc(nbOfTuple1,nbOfComp1);
11281 const int *a2Ptr=a2->getConstPointer();
11282 const int *a1Ptr=a1->getConstPointer();
11283 int *res=ret->getPointer();
11284 for(int i=0;i<nbOfTuple1;i++)
11285 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::divides<int>(),a2Ptr[i]));
11286 ret->copyStringInfoFrom(*a1);
11291 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
11295 else if(nbOfTuple2==1)
11297 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
11298 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11299 ret->alloc(nbOfTuple1,nbOfComp1);
11300 const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
11301 int *pt=ret->getPointer();
11302 for(int i=0;i<nbOfTuple1;i++)
11303 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::divides<int>());
11304 ret->copyStringInfoFrom(*a1);
11309 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Divide !");//will always throw an exception
11315 * Divide values of \a this array by values of another DataArrayInt. There are 3
11317 * 1. The arrays have same number of tuples and components. Then each value of
11318 * \a this array is divided by the corresponding value of \a other one, i.e.:
11319 * _a_ [ i, j ] /= _other_ [ i, j ].
11320 * 2. The arrays have same number of tuples and \a other array has one component. Then
11321 * _a_ [ i, j ] /= _other_ [ i, 0 ].
11322 * 3. The arrays have same number of components and \a other array has one tuple. Then
11323 * _a_ [ i, j ] /= _a2_ [ 0, j ].
11325 * \warning No check of division by zero is performed!
11326 * \param [in] other - an array to divide \a this one by.
11327 * \throw If \a other is NULL.
11328 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
11329 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
11330 * \a other has number of both tuples and components not equal to 1.
11332 void DataArrayInt::divideEqual(const DataArrayInt *other)
11335 throw INTERP_KERNEL::Exception("DataArrayInt::divideEqual : input DataArrayInt instance is NULL !");
11336 const char *msg="Nb of tuples mismatch for DataArrayInt::divideEqual !";
11337 checkAllocated(); other->checkAllocated();
11338 int nbOfTuple=getNumberOfTuples();
11339 int nbOfTuple2=other->getNumberOfTuples();
11340 int nbOfComp=getNumberOfComponents();
11341 int nbOfComp2=other->getNumberOfComponents();
11342 if(nbOfTuple==nbOfTuple2)
11344 if(nbOfComp==nbOfComp2)
11346 std::transform(begin(),end(),other->begin(),getPointer(),std::divides<int>());
11348 else if(nbOfComp2==1)
11350 int *ptr=getPointer();
11351 const int *ptrc=other->getConstPointer();
11352 for(int i=0;i<nbOfTuple;i++)
11353 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::divides<int>(),*ptrc++));
11356 throw INTERP_KERNEL::Exception(msg);
11358 else if(nbOfTuple2==1)
11360 if(nbOfComp2==nbOfComp)
11362 int *ptr=getPointer();
11363 const int *ptrc=other->getConstPointer();
11364 for(int i=0;i<nbOfTuple;i++)
11365 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::divides<int>());
11368 throw INTERP_KERNEL::Exception(msg);
11371 throw INTERP_KERNEL::Exception(msg);
11377 * Returns a new DataArrayInt that is a modulus of two given arrays. There are 3
11379 * 1. The arrays have same number of tuples and components. Then each value of
11380 * the result array (_a_) is a division of the corresponding values of \a a1 and
11381 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ i, j ].
11382 * 2. The arrays have same number of tuples and one array, say _a2_, has one
11384 * _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ i, 0 ].
11385 * 3. The arrays have same number of components and one array, say _a2_, has one
11387 * _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ 0, j ].
11389 * Info on components is copied either from the first array (in the first case) or from
11390 * the array with maximal number of elements (getNbOfElems()).
11391 * \warning No check of division by zero is performed!
11392 * \param [in] a1 - a dividend array.
11393 * \param [in] a2 - a divisor array.
11394 * \return DataArrayInt * - the new instance of DataArrayInt.
11395 * The caller is to delete this result array using decrRef() as it is no more
11397 * \throw If either \a a1 or \a a2 is NULL.
11398 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
11399 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
11400 * none of them has number of tuples or components equal to 1.
11402 DataArrayInt *DataArrayInt::Modulus(const DataArrayInt *a1, const DataArrayInt *a2)
11405 throw INTERP_KERNEL::Exception("DataArrayInt::Modulus : input DataArrayInt instance is NULL !");
11406 int nbOfTuple1=a1->getNumberOfTuples();
11407 int nbOfTuple2=a2->getNumberOfTuples();
11408 int nbOfComp1=a1->getNumberOfComponents();
11409 int nbOfComp2=a2->getNumberOfComponents();
11410 if(nbOfTuple2==nbOfTuple1)
11412 if(nbOfComp1==nbOfComp2)
11414 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11415 ret->alloc(nbOfTuple2,nbOfComp1);
11416 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::modulus<int>());
11417 ret->copyStringInfoFrom(*a1);
11420 else if(nbOfComp2==1)
11422 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11423 ret->alloc(nbOfTuple1,nbOfComp1);
11424 const int *a2Ptr=a2->getConstPointer();
11425 const int *a1Ptr=a1->getConstPointer();
11426 int *res=ret->getPointer();
11427 for(int i=0;i<nbOfTuple1;i++)
11428 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::modulus<int>(),a2Ptr[i]));
11429 ret->copyStringInfoFrom(*a1);
11434 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Modulus !");
11438 else if(nbOfTuple2==1)
11440 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Modulus !");
11441 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11442 ret->alloc(nbOfTuple1,nbOfComp1);
11443 const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
11444 int *pt=ret->getPointer();
11445 for(int i=0;i<nbOfTuple1;i++)
11446 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::modulus<int>());
11447 ret->copyStringInfoFrom(*a1);
11452 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Modulus !");//will always throw an exception
11458 * Modify \a this array so that each value becomes a modulus of division of this value by
11459 * a value of another DataArrayInt. There are 3 valid cases.
11460 * 1. The arrays have same number of tuples and components. Then each value of
11461 * \a this array is divided by the corresponding value of \a other one, i.e.:
11462 * _a_ [ i, j ] %= _other_ [ i, j ].
11463 * 2. The arrays have same number of tuples and \a other array has one component. Then
11464 * _a_ [ i, j ] %= _other_ [ i, 0 ].
11465 * 3. The arrays have same number of components and \a other array has one tuple. Then
11466 * _a_ [ i, j ] %= _a2_ [ 0, j ].
11468 * \warning No check of division by zero is performed!
11469 * \param [in] other - a divisor array.
11470 * \throw If \a other is NULL.
11471 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
11472 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
11473 * \a other has number of both tuples and components not equal to 1.
11475 void DataArrayInt::modulusEqual(const DataArrayInt *other)
11478 throw INTERP_KERNEL::Exception("DataArrayInt::modulusEqual : input DataArrayInt instance is NULL !");
11479 const char *msg="Nb of tuples mismatch for DataArrayInt::modulusEqual !";
11480 checkAllocated(); other->checkAllocated();
11481 int nbOfTuple=getNumberOfTuples();
11482 int nbOfTuple2=other->getNumberOfTuples();
11483 int nbOfComp=getNumberOfComponents();
11484 int nbOfComp2=other->getNumberOfComponents();
11485 if(nbOfTuple==nbOfTuple2)
11487 if(nbOfComp==nbOfComp2)
11489 std::transform(begin(),end(),other->begin(),getPointer(),std::modulus<int>());
11491 else if(nbOfComp2==1)
11493 if(nbOfComp2==nbOfComp)
11495 int *ptr=getPointer();
11496 const int *ptrc=other->getConstPointer();
11497 for(int i=0;i<nbOfTuple;i++)
11498 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::modulus<int>(),*ptrc++));
11501 throw INTERP_KERNEL::Exception(msg);
11504 throw INTERP_KERNEL::Exception(msg);
11506 else if(nbOfTuple2==1)
11508 int *ptr=getPointer();
11509 const int *ptrc=other->getConstPointer();
11510 for(int i=0;i<nbOfTuple;i++)
11511 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::modulus<int>());
11514 throw INTERP_KERNEL::Exception(msg);
11519 * Returns a new DataArrayInt that is the result of pow of two given arrays. There are 3
11522 * \param [in] a1 - an array to pow up.
11523 * \param [in] a2 - another array to sum up.
11524 * \return DataArrayInt * - the new instance of DataArrayInt.
11525 * The caller is to delete this result array using decrRef() as it is no more
11527 * \throw If either \a a1 or \a a2 is NULL.
11528 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
11529 * \throw If \a a1->getNumberOfComponents() != 1 or \a a2->getNumberOfComponents() != 1.
11530 * \throw If there is a negative value in \a a2.
11532 DataArrayInt *DataArrayInt::Pow(const DataArrayInt *a1, const DataArrayInt *a2)
11535 throw INTERP_KERNEL::Exception("DataArrayInt::Pow : at least one of input instances is null !");
11536 int nbOfTuple=a1->getNumberOfTuples();
11537 int nbOfTuple2=a2->getNumberOfTuples();
11538 int nbOfComp=a1->getNumberOfComponents();
11539 int nbOfComp2=a2->getNumberOfComponents();
11540 if(nbOfTuple!=nbOfTuple2)
11541 throw INTERP_KERNEL::Exception("DataArrayInt::Pow : number of tuples mismatches !");
11542 if(nbOfComp!=1 || nbOfComp2!=1)
11543 throw INTERP_KERNEL::Exception("DataArrayInt::Pow : number of components of both arrays must be equal to 1 !");
11544 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbOfTuple,1);
11545 const int *ptr1(a1->begin()),*ptr2(a2->begin());
11546 int *ptr=ret->getPointer();
11547 for(int i=0;i<nbOfTuple;i++,ptr1++,ptr2++,ptr++)
11552 for(int j=0;j<*ptr2;j++)
11558 std::ostringstream oss; oss << "DataArrayInt::Pow : on tuple #" << i << " of a2 value is < 0 (" << *ptr2 << ") !";
11559 throw INTERP_KERNEL::Exception(oss.str().c_str());
11566 * Apply pow on values of another DataArrayInt to values of \a this one.
11568 * \param [in] other - an array to pow to \a this one.
11569 * \throw If \a other is NULL.
11570 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples()
11571 * \throw If \a this->getNumberOfComponents() != 1 or \a other->getNumberOfComponents() != 1
11572 * \throw If there is a negative value in \a other.
11574 void DataArrayInt::powEqual(const DataArrayInt *other)
11577 throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : input instance is null !");
11578 int nbOfTuple=getNumberOfTuples();
11579 int nbOfTuple2=other->getNumberOfTuples();
11580 int nbOfComp=getNumberOfComponents();
11581 int nbOfComp2=other->getNumberOfComponents();
11582 if(nbOfTuple!=nbOfTuple2)
11583 throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : number of tuples mismatches !");
11584 if(nbOfComp!=1 || nbOfComp2!=1)
11585 throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : number of components of both arrays must be equal to 1 !");
11586 int *ptr=getPointer();
11587 const int *ptrc=other->begin();
11588 for(int i=0;i<nbOfTuple;i++,ptrc++,ptr++)
11593 for(int j=0;j<*ptrc;j++)
11599 std::ostringstream oss; oss << "DataArrayInt::powEqual : on tuple #" << i << " of other value is < 0 (" << *ptrc << ") !";
11600 throw INTERP_KERNEL::Exception(oss.str().c_str());
11607 * Returns a C array which is a renumbering map in "Old to New" mode for the input array.
11608 * This map, if applied to \a start array, would make it sorted. For example, if
11609 * \a start array contents are [9,10,0,6,4,11,3,7] then the contents of the result array is
11610 * [5,6,0,3,2,7,1,4].
11611 * \param [in] start - pointer to the first element of the array for which the
11612 * permutation map is computed.
11613 * \param [in] end - pointer specifying the end of the array \a start, so that
11614 * the last value of \a start is \a end[ -1 ].
11615 * \return int * - the result permutation array that the caller is to delete as it is no
11617 * \throw If there are equal values in the input array.
11619 int *DataArrayInt::CheckAndPreparePermutation(const int *start, const int *end)
11621 std::size_t sz=std::distance(start,end);
11622 int *ret=(int *)malloc(sz*sizeof(int));
11623 int *work=new int[sz];
11624 std::copy(start,end,work);
11625 std::sort(work,work+sz);
11626 if(std::unique(work,work+sz)!=work+sz)
11630 throw INTERP_KERNEL::Exception("Some elements are equals in the specified array !");
11632 std::map<int,int> m;
11633 for(int *workPt=work;workPt!=work+sz;workPt++)
11634 m[*workPt]=(int)std::distance(work,workPt);
11636 for(const int *iter=start;iter!=end;iter++,iter2++)
11643 * Returns a new DataArrayInt containing an arithmetic progression
11644 * that is equal to the sequence returned by Python \c range(\a begin,\a end,\a step )
11646 * \param [in] begin - the start value of the result sequence.
11647 * \param [in] end - limiting value, so that every value of the result array is less than
11649 * \param [in] step - specifies the increment or decrement.
11650 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
11651 * array using decrRef() as it is no more needed.
11652 * \throw If \a step == 0.
11653 * \throw If \a end < \a begin && \a step > 0.
11654 * \throw If \a end > \a begin && \a step < 0.
11656 DataArrayInt *DataArrayInt::Range(int begin, int end, int step)
11658 int nbOfTuples=GetNumberOfItemGivenBESRelative(begin,end,step,"DataArrayInt::Range");
11659 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11660 ret->alloc(nbOfTuples,1);
11661 int *ptr=ret->getPointer();
11664 for(int i=begin;i<end;i+=step,ptr++)
11669 for(int i=begin;i>end;i+=step,ptr++)
11676 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
11679 void DataArrayInt::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
11681 tinyInfo.resize(2);
11684 tinyInfo[0]=getNumberOfTuples();
11685 tinyInfo[1]=getNumberOfComponents();
11695 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
11698 void DataArrayInt::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
11702 int nbOfCompo=getNumberOfComponents();
11703 tinyInfo.resize(nbOfCompo+1);
11704 tinyInfo[0]=getName();
11705 for(int i=0;i<nbOfCompo;i++)
11706 tinyInfo[i+1]=getInfoOnComponent(i);
11710 tinyInfo.resize(1);
11711 tinyInfo[0]=getName();
11716 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
11717 * This method returns if a feeding is needed.
11719 bool DataArrayInt::resizeForUnserialization(const std::vector<int>& tinyInfoI)
11721 int nbOfTuple=tinyInfoI[0];
11722 int nbOfComp=tinyInfoI[1];
11723 if(nbOfTuple!=-1 || nbOfComp!=-1)
11725 alloc(nbOfTuple,nbOfComp);
11732 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
11733 * This method returns if a feeding is needed.
11735 void DataArrayInt::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<std::string>& tinyInfoS)
11737 setName(tinyInfoS[0]);
11740 int nbOfCompo=tinyInfoI[1];
11741 for(int i=0;i<nbOfCompo;i++)
11742 setInfoOnComponent(i,tinyInfoS[i+1]);
11746 DataArrayIntIterator::DataArrayIntIterator(DataArrayInt *da):_da(da),_pt(0),_tuple_id(0),_nb_comp(0),_nb_tuple(0)
11751 if(_da->isAllocated())
11753 _nb_comp=da->getNumberOfComponents();
11754 _nb_tuple=da->getNumberOfTuples();
11755 _pt=da->getPointer();
11760 DataArrayIntIterator::~DataArrayIntIterator()
11766 DataArrayIntTuple *DataArrayIntIterator::nextt()
11768 if(_tuple_id<_nb_tuple)
11771 DataArrayIntTuple *ret=new DataArrayIntTuple(_pt,_nb_comp);
11779 DataArrayIntTuple::DataArrayIntTuple(int *pt, int nbOfComp):_pt(pt),_nb_of_compo(nbOfComp)
11783 std::string DataArrayIntTuple::repr() const
11785 std::ostringstream oss; oss << "(";
11786 for(int i=0;i<_nb_of_compo-1;i++)
11787 oss << _pt[i] << ", ";
11788 oss << _pt[_nb_of_compo-1] << ")";
11792 int DataArrayIntTuple::intValue() const
11794 if(_nb_of_compo==1)
11796 throw INTERP_KERNEL::Exception("DataArrayIntTuple::intValue : DataArrayIntTuple instance has not exactly 1 component -> Not possible to convert it into an integer !");
11800 * This method returns a newly allocated instance the caller should dealed with by a ParaMEDMEM::DataArrayInt::decrRef.
11801 * This method performs \b no copy of data. The content is only referenced using ParaMEDMEM::DataArrayInt::useArray with ownership set to \b false.
11802 * 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
11803 * \b nbOfCompo=1 and \bnbOfTuples==this->_nb_of_elem.
11805 DataArrayInt *DataArrayIntTuple::buildDAInt(int nbOfTuples, int nbOfCompo) const
11807 if((_nb_of_compo==nbOfCompo && nbOfTuples==1) || (_nb_of_compo==nbOfTuples && nbOfCompo==1))
11809 DataArrayInt *ret=DataArrayInt::New();
11810 ret->useExternalArrayWithRWAccess(_pt,nbOfTuples,nbOfCompo);
11815 std::ostringstream oss; oss << "DataArrayIntTuple::buildDAInt : unable to build a requested DataArrayInt instance with nbofTuple=" << nbOfTuples << " and nbOfCompo=" << nbOfCompo;
11816 oss << ".\nBecause the number of elements in this is " << _nb_of_compo << " !";
11817 throw INTERP_KERNEL::Exception(oss.str().c_str());