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 \c 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 \c this one.
1451 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
1452 * For more info on renumbering see \ref numbering.
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 \c this one.
1483 * For more info on renumbering see \ref numbering.
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 \c this one.
1516 * If a permutation reduction is needed, renumberAndReduce() should be used.
1517 * For more info on renumbering see \ref numbering.
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 \c this one.
1544 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
1545 * For more info on renumbering see \ref numbering.
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 numbering.
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 numbering.
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);
1631 DataArrayDouble *DataArrayDouble::selectByTupleId(const DataArrayInt & di) const
1633 return selectByTupleId(di.getConstPointer(), di.getConstPointer()+di.getNumberOfTuples());
1637 * Returns a shorten and permuted copy of \a this array. The new DataArrayDouble is
1638 * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
1639 * \a new2OldBg array.
1640 * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
1641 * This method is equivalent to renumberAndReduce() except that convention in input is
1642 * \c new2old and \b not \c old2new.
1643 * This method is equivalent to selectByTupleId() except that it prevents coping data
1644 * from behind the end of \a this array.
1645 * For more info on renumbering see \ref numbering.
1646 * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
1647 * tuple index in \a this array to fill the i-th tuple in the new array.
1648 * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
1649 * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
1650 * \a new2OldBg <= \a pi < \a new2OldEnd.
1651 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1652 * is to delete using decrRef() as it is no more needed.
1653 * \throw If \a new2OldEnd - \a new2OldBg > \a this->getNumberOfTuples().
1655 DataArrayDouble *DataArrayDouble::selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const
1658 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1659 int nbComp=getNumberOfComponents();
1660 int oldNbOfTuples=getNumberOfTuples();
1661 ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
1662 ret->copyStringInfoFrom(*this);
1663 double *pt=ret->getPointer();
1664 const double *srcPt=getConstPointer();
1666 for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
1667 if(*w>=0 && *w<oldNbOfTuples)
1668 std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
1670 throw INTERP_KERNEL::Exception("DataArrayDouble::selectByTupleIdSafe : some ids has been detected to be out of [0,this->getNumberOfTuples) !");
1671 ret->copyStringInfoFrom(*this);
1676 * Returns a shorten copy of \a this array. The new DataArrayDouble contains every
1677 * (\a bg + \c i * \a step)-th tuple of \a this array located before the \a end2-th
1678 * tuple. Indices of the selected tuples are the same as ones returned by the Python
1679 * command \c range( \a bg, \a end2, \a step ).
1680 * This method is equivalent to selectByTupleIdSafe() except that the input array is
1681 * not constructed explicitly.
1682 * For more info on renumbering see \ref numbering.
1683 * \param [in] bg - index of the first tuple to copy from \a this array.
1684 * \param [in] end2 - index of the tuple before which the tuples to copy are located.
1685 * \param [in] step - index increment to get index of the next tuple to copy.
1686 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1687 * is to delete using decrRef() as it is no more needed.
1688 * \sa DataArrayDouble::substr.
1690 DataArrayDouble *DataArrayDouble::selectByTupleId2(int bg, int end2, int step) const
1693 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1694 int nbComp=getNumberOfComponents();
1695 int newNbOfTuples=GetNumberOfItemGivenBESRelative(bg,end2,step,"DataArrayDouble::selectByTupleId2 : ");
1696 ret->alloc(newNbOfTuples,nbComp);
1697 double *pt=ret->getPointer();
1698 const double *srcPt=getConstPointer()+bg*nbComp;
1699 for(int i=0;i<newNbOfTuples;i++,srcPt+=step*nbComp)
1700 std::copy(srcPt,srcPt+nbComp,pt+i*nbComp);
1701 ret->copyStringInfoFrom(*this);
1706 * Returns a shorten copy of \a this array. The new DataArrayDouble contains ranges
1707 * of tuples specified by \a ranges parameter.
1708 * For more info on renumbering see \ref numbering.
1709 * \param [in] ranges - std::vector of std::pair's each of which defines a range
1710 * of tuples in [\c begin,\c end) format.
1711 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1712 * is to delete using decrRef() as it is no more needed.
1713 * \throw If \a end < \a begin.
1714 * \throw If \a end > \a this->getNumberOfTuples().
1715 * \throw If \a this is not allocated.
1717 DataArray *DataArrayDouble::selectByTupleRanges(const std::vector<std::pair<int,int> >& ranges) const
1720 int nbOfComp=getNumberOfComponents();
1721 int nbOfTuplesThis=getNumberOfTuples();
1724 DataArrayDouble *ret=DataArrayDouble::New();
1725 ret->alloc(0,nbOfComp);
1726 ret->copyStringInfoFrom(*this);
1729 int ref=ranges.front().first;
1731 bool isIncreasing=true;
1732 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
1734 if((*it).first<=(*it).second)
1736 if((*it).first>=0 && (*it).second<=nbOfTuplesThis)
1738 nbOfTuples+=(*it).second-(*it).first;
1740 isIncreasing=ref<=(*it).first;
1745 std::ostringstream oss; oss << "DataArrayDouble::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
1746 oss << " (" << (*it).first << "," << (*it).second << ") is greater than number of tuples of this :" << nbOfTuples << " !";
1747 throw INTERP_KERNEL::Exception(oss.str().c_str());
1752 std::ostringstream oss; oss << "DataArrayDouble::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
1753 oss << " (" << (*it).first << "," << (*it).second << ") end is before begin !";
1754 throw INTERP_KERNEL::Exception(oss.str().c_str());
1757 if(isIncreasing && nbOfTuplesThis==nbOfTuples)
1759 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1760 ret->alloc(nbOfTuples,nbOfComp);
1761 ret->copyStringInfoFrom(*this);
1762 const double *src=getConstPointer();
1763 double *work=ret->getPointer();
1764 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
1765 work=std::copy(src+(*it).first*nbOfComp,src+(*it).second*nbOfComp,work);
1770 * Returns a shorten copy of \a this array. The new DataArrayDouble contains all
1771 * tuples starting from the \a tupleIdBg-th tuple and including all tuples located before
1772 * the \a tupleIdEnd-th one. This methods has a similar behavior as std::string::substr().
1773 * This method is a specialization of selectByTupleId2().
1774 * \param [in] tupleIdBg - index of the first tuple to copy from \a this array.
1775 * \param [in] tupleIdEnd - index of the tuple before which the tuples to copy are located.
1776 * If \a tupleIdEnd == -1, all the tuples till the end of \a this array are copied.
1777 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1778 * is to delete using decrRef() as it is no more needed.
1779 * \throw If \a tupleIdBg < 0.
1780 * \throw If \a tupleIdBg > \a this->getNumberOfTuples().
1781 \throw If \a tupleIdEnd != -1 && \a tupleIdEnd < \a this->getNumberOfTuples().
1782 * \sa DataArrayDouble::selectByTupleId2
1784 DataArrayDouble *DataArrayDouble::substr(int tupleIdBg, int tupleIdEnd) const
1787 int nbt=getNumberOfTuples();
1789 throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter must be greater than 0 !");
1791 throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter is greater than number of tuples !");
1792 int trueEnd=tupleIdEnd;
1796 throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter is greater or equal than number of tuples !");
1800 int nbComp=getNumberOfComponents();
1801 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1802 ret->alloc(trueEnd-tupleIdBg,nbComp);
1803 ret->copyStringInfoFrom(*this);
1804 std::copy(getConstPointer()+tupleIdBg*nbComp,getConstPointer()+trueEnd*nbComp,ret->getPointer());
1809 * Returns a shorten or extended copy of \a this array. If \a newNbOfComp is less
1810 * than \a this->getNumberOfComponents() then the result array is shorten as each tuple
1811 * is truncated to have \a newNbOfComp components, keeping first components. If \a
1812 * newNbOfComp is more than \a this->getNumberOfComponents() then the result array is
1813 * expanded as each tuple is populated with \a dftValue to have \a newNbOfComp
1815 * \param [in] newNbOfComp - number of components for the new array to have.
1816 * \param [in] dftValue - value assigned to new values added to the new array.
1817 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1818 * is to delete using decrRef() as it is no more needed.
1819 * \throw If \a this is not allocated.
1821 DataArrayDouble *DataArrayDouble::changeNbOfComponents(int newNbOfComp, double dftValue) const
1824 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1825 ret->alloc(getNumberOfTuples(),newNbOfComp);
1826 const double *oldc=getConstPointer();
1827 double *nc=ret->getPointer();
1828 int nbOfTuples=getNumberOfTuples();
1829 int oldNbOfComp=getNumberOfComponents();
1830 int dim=std::min(oldNbOfComp,newNbOfComp);
1831 for(int i=0;i<nbOfTuples;i++)
1835 nc[newNbOfComp*i+j]=oldc[i*oldNbOfComp+j];
1836 for(;j<newNbOfComp;j++)
1837 nc[newNbOfComp*i+j]=dftValue;
1839 ret->setName(getName());
1840 for(int i=0;i<dim;i++)
1841 ret->setInfoOnComponent(i,getInfoOnComponent(i));
1842 ret->setName(getName());
1847 * Changes the number of components within \a this array so that its raw data **does
1848 * not** change, instead splitting this data into tuples changes.
1849 * \warning This method erases all (name and unit) component info set before!
1850 * \param [in] newNbOfComp - number of components for \a this array to have.
1851 * \throw If \a this is not allocated
1852 * \throw If getNbOfElems() % \a newNbOfCompo != 0.
1853 * \throw If \a newNbOfCompo is lower than 1.
1854 * \throw If the rearrange method would lead to a number of tuples higher than 2147483647 (maximal capacity of int32 !).
1855 * \warning This method erases all (name and unit) component info set before!
1857 void DataArrayDouble::rearrange(int newNbOfCompo)
1861 throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : input newNbOfCompo must be > 0 !");
1862 std::size_t nbOfElems=getNbOfElems();
1863 if(nbOfElems%newNbOfCompo!=0)
1864 throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : nbOfElems%newNbOfCompo!=0 !");
1865 if(nbOfElems/newNbOfCompo>(std::size_t)std::numeric_limits<int>::max())
1866 throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : the rearrangement leads to too high number of tuples (> 2147483647) !");
1867 _info_on_compo.clear();
1868 _info_on_compo.resize(newNbOfCompo);
1873 * Changes the number of components within \a this array to be equal to its number
1874 * of tuples, and inversely its number of tuples to become equal to its number of
1875 * components. So that its raw data **does not** change, instead splitting this
1876 * data into tuples changes.
1877 * \warning This method erases all (name and unit) component info set before!
1878 * \warning Do not confuse this method with fromNoInterlace() and toNoInterlace()!
1879 * \throw If \a this is not allocated.
1882 void DataArrayDouble::transpose()
1885 int nbOfTuples=getNumberOfTuples();
1886 rearrange(nbOfTuples);
1890 * Returns a copy of \a this array composed of selected components.
1891 * The new DataArrayDouble has the same number of tuples but includes components
1892 * specified by \a compoIds parameter. So that getNbOfElems() of the result array
1893 * can be either less, same or more than \a this->getNbOfElems().
1894 * \param [in] compoIds - sequence of zero based indices of components to include
1895 * into the new array.
1896 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1897 * is to delete using decrRef() as it is no more needed.
1898 * \throw If \a this is not allocated.
1899 * \throw If a component index (\a i) is not valid:
1900 * \a i < 0 || \a i >= \a this->getNumberOfComponents().
1902 * \if ENABLE_EXAMPLES
1903 * \ref py_mcdataarraydouble_KeepSelectedComponents "Here is a Python example".
1906 DataArrayDouble *DataArrayDouble::keepSelectedComponents(const std::vector<int>& compoIds) const
1909 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret(DataArrayDouble::New());
1910 std::size_t newNbOfCompo=compoIds.size();
1911 int oldNbOfCompo=getNumberOfComponents();
1912 for(std::vector<int>::const_iterator it=compoIds.begin();it!=compoIds.end();it++)
1913 if((*it)<0 || (*it)>=oldNbOfCompo)
1915 std::ostringstream oss; oss << "DataArrayDouble::keepSelectedComponents : invalid requested component : " << *it << " whereas it should be in [0," << oldNbOfCompo << ") !";
1916 throw INTERP_KERNEL::Exception(oss.str().c_str());
1918 int nbOfTuples=getNumberOfTuples();
1919 ret->alloc(nbOfTuples,(int)newNbOfCompo);
1920 ret->copyPartOfStringInfoFrom(*this,compoIds);
1921 const double *oldc=getConstPointer();
1922 double *nc=ret->getPointer();
1923 for(int i=0;i<nbOfTuples;i++)
1924 for(std::size_t j=0;j<newNbOfCompo;j++,nc++)
1925 *nc=oldc[i*oldNbOfCompo+compoIds[j]];
1930 * Appends components of another array to components of \a this one, tuple by tuple.
1931 * So that the number of tuples of \a this array remains the same and the number of
1932 * components increases.
1933 * \param [in] other - the DataArrayDouble to append to \a this one.
1934 * \throw If \a this is not allocated.
1935 * \throw If \a this and \a other arrays have different number of tuples.
1937 * \if ENABLE_EXAMPLES
1938 * \ref cpp_mcdataarraydouble_meldwith "Here is a C++ example".
1940 * \ref py_mcdataarraydouble_meldwith "Here is a Python example".
1943 void DataArrayDouble::meldWith(const DataArrayDouble *other)
1946 other->checkAllocated();
1947 int nbOfTuples=getNumberOfTuples();
1948 if(nbOfTuples!=other->getNumberOfTuples())
1949 throw INTERP_KERNEL::Exception("DataArrayDouble::meldWith : mismatch of number of tuples !");
1950 int nbOfComp1=getNumberOfComponents();
1951 int nbOfComp2=other->getNumberOfComponents();
1952 double *newArr=(double *)malloc((nbOfTuples*(nbOfComp1+nbOfComp2))*sizeof(double));
1954 const double *inp1=getConstPointer();
1955 const double *inp2=other->getConstPointer();
1956 for(int i=0;i<nbOfTuples;i++,inp1+=nbOfComp1,inp2+=nbOfComp2)
1958 w=std::copy(inp1,inp1+nbOfComp1,w);
1959 w=std::copy(inp2,inp2+nbOfComp2,w);
1961 useArray(newArr,true,C_DEALLOC,nbOfTuples,nbOfComp1+nbOfComp2);
1962 std::vector<int> compIds(nbOfComp2);
1963 for(int i=0;i<nbOfComp2;i++)
1964 compIds[i]=nbOfComp1+i;
1965 copyPartOfStringInfoFrom2(compIds,*other);
1969 * This method checks that all tuples in \a other are in \a this.
1970 * If true, the output param \a tupleIds contains the tuples ids of \a this that correspond to tupes in \a this.
1971 * 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.
1973 * \param [in] other - the array having the same number of components than \a this.
1974 * \param [out] tupleIds - the tuple ids containing the same number of tuples than \a other has.
1975 * \sa DataArrayDouble::findCommonTuples
1977 bool DataArrayDouble::areIncludedInMe(const DataArrayDouble *other, double prec, DataArrayInt *&tupleIds) const
1980 throw INTERP_KERNEL::Exception("DataArrayDouble::areIncludedInMe : input array is NULL !");
1981 checkAllocated(); other->checkAllocated();
1982 if(getNumberOfComponents()!=other->getNumberOfComponents())
1983 throw INTERP_KERNEL::Exception("DataArrayDouble::areIncludedInMe : the number of components does not match !");
1984 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> a=DataArrayDouble::Aggregate(this,other);
1985 DataArrayInt *c=0,*ci=0;
1986 a->findCommonTuples(prec,getNumberOfTuples(),c,ci);
1987 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cSafe(c),ciSafe(ci);
1988 int newNbOfTuples=-1;
1989 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(a->getNumberOfTuples(),c->begin(),ci->begin(),ci->end(),newNbOfTuples);
1990 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=ids->selectByTupleId2(getNumberOfTuples(),a->getNumberOfTuples(),1);
1991 tupleIds=ret1.retn();
1992 return newNbOfTuples==getNumberOfTuples();
1996 * Searches for tuples coincident within \a prec tolerance. Each tuple is considered
1997 * as coordinates of a point in getNumberOfComponents()-dimensional space. The
1998 * distance separating two points is computed with the infinite norm.
2000 * Indices of coincident tuples are stored in output arrays.
2001 * A pair of arrays (\a comm, \a commIndex) is called "Surjective Format 2".
2003 * This method is typically used by MEDCouplingPointSet::findCommonNodes() and
2004 * MEDCouplingUMesh::mergeNodes().
2005 * \param [in] prec - minimal absolute distance between two tuples (infinite norm) at which they are
2006 * considered not coincident.
2007 * \param [in] limitTupleId - limit tuple id. If all tuples within a group of coincident
2008 * tuples have id strictly lower than \a limitTupleId then they are not returned.
2009 * \param [out] comm - the array holding ids (== indices) of coincident tuples.
2010 * \a comm->getNumberOfComponents() == 1.
2011 * \a comm->getNumberOfTuples() == \a commIndex->back().
2012 * \param [out] commIndex - the array dividing all indices stored in \a comm into
2013 * groups of (indices of) coincident tuples. Its every value is a tuple
2014 * index where a next group of tuples begins. For example the second
2015 * group of tuples in \a comm is described by following range of indices:
2016 * [ \a commIndex[1], \a commIndex[2] ). \a commIndex->getNumberOfTuples()-1
2017 * gives the number of groups of coincident tuples.
2018 * \throw If \a this is not allocated.
2019 * \throw If the number of components is not in [1,2,3,4].
2021 * \if ENABLE_EXAMPLES
2022 * \ref cpp_mcdataarraydouble_findcommontuples "Here is a C++ example".
2024 * \ref py_mcdataarraydouble_findcommontuples "Here is a Python example".
2026 * \sa DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(), DataArrayDouble::areIncludedInMe
2028 void DataArrayDouble::findCommonTuples(double prec, int limitTupleId, DataArrayInt *&comm, DataArrayInt *&commIndex) const
2031 int nbOfCompo=getNumberOfComponents();
2032 if ((nbOfCompo<1) || (nbOfCompo>4)) //test before work
2033 throw INTERP_KERNEL::Exception("DataArrayDouble::findCommonTuples : Unexpected spacedim of coords. Must be 1, 2, 3 or 4.");
2035 int nbOfTuples=getNumberOfTuples();
2037 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> c(DataArrayInt::New()),cI(DataArrayInt::New()); c->alloc(0,1); cI->pushBackSilent(0);
2041 findCommonTuplesAlg<4>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
2044 findCommonTuplesAlg<3>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
2047 findCommonTuplesAlg<2>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
2050 findCommonTuplesAlg<1>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
2053 throw INTERP_KERNEL::Exception("DataArrayDouble::findCommonTuples : nb of components managed are 1,2,3 and 4 ! not implemented for other number of components !");
2056 commIndex=cI.retn();
2061 * \param [in] nbTimes specifies the nb of times each tuples in \a this will be duplicated contiguouly in returned DataArrayDouble instance.
2062 * \a nbTimes should be at least equal to 1.
2063 * \return a newly allocated DataArrayDouble having one component and number of tuples equal to \a nbTimes * \c this->getNumberOfTuples.
2064 * \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.
2066 DataArrayDouble *DataArrayDouble::duplicateEachTupleNTimes(int nbTimes) const
2069 if(getNumberOfComponents()!=1)
2070 throw INTERP_KERNEL::Exception("DataArrayDouble::duplicateEachTupleNTimes : this should have only one component !");
2072 throw INTERP_KERNEL::Exception("DataArrayDouble::duplicateEachTupleNTimes : nb times should be >= 1 !");
2073 int nbTuples=getNumberOfTuples();
2074 const double *inPtr=getConstPointer();
2075 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(nbTimes*nbTuples,1);
2076 double *retPtr=ret->getPointer();
2077 for(int i=0;i<nbTuples;i++,inPtr++)
2080 for(int j=0;j<nbTimes;j++,retPtr++)
2083 ret->copyStringInfoFrom(*this);
2088 * This methods returns the minimal distance between the two set of points \a this and \a other.
2089 * So \a this and \a other have to have the same number of components. If not an INTERP_KERNEL::Exception will be thrown.
2090 * This method works only if number of components of \a this (equal to those of \a other) is in 1, 2 or 3.
2092 * \param [out] thisTupleId the tuple id in \a this corresponding to the returned minimal distance
2093 * \param [out] otherTupleId the tuple id in \a other corresponding to the returned minimal distance
2094 * \return the minimal distance between the two set of points \a this and \a other.
2095 * \sa DataArrayDouble::findClosestTupleId
2097 double DataArrayDouble::minimalDistanceTo(const DataArrayDouble *other, int& thisTupleId, int& otherTupleId) const
2099 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> part1=findClosestTupleId(other);
2100 int nbOfCompo(getNumberOfComponents());
2101 int otherNbTuples(other->getNumberOfTuples());
2102 const double *thisPt(begin()),*otherPt(other->begin());
2103 const int *part1Pt(part1->begin());
2104 double ret=std::numeric_limits<double>::max();
2105 for(int i=0;i<otherNbTuples;i++,part1Pt++,otherPt+=nbOfCompo)
2108 for(int j=0;j<nbOfCompo;j++)
2109 tmp+=(otherPt[j]-thisPt[nbOfCompo*(*part1Pt)+j])*(otherPt[j]-thisPt[nbOfCompo*(*part1Pt)+j]);
2111 { ret=tmp; thisTupleId=*part1Pt; otherTupleId=i; }
2117 * This methods returns for each tuple in \a other which tuple in \a this is the closest.
2118 * So \a this and \a other have to have the same number of components. If not an INTERP_KERNEL::Exception will be thrown.
2119 * This method works only if number of components of \a this (equal to those of \a other) is in 1, 2 or 3.
2121 * \return a newly allocated (new object to be dealt by the caller) DataArrayInt having \c other->getNumberOfTuples() tuples and one components.
2122 * \sa DataArrayDouble::minimalDistanceTo
2124 DataArrayInt *DataArrayDouble::findClosestTupleId(const DataArrayDouble *other) const
2127 throw INTERP_KERNEL::Exception("DataArrayDouble::findClosestTupleId : other instance is NULL !");
2128 checkAllocated(); other->checkAllocated();
2129 int nbOfCompo=getNumberOfComponents();
2130 if(nbOfCompo!=other->getNumberOfComponents())
2132 std::ostringstream oss; oss << "DataArrayDouble::findClosestTupleId : number of components in this is " << nbOfCompo;
2133 oss << ", whereas number of components in other is " << other->getNumberOfComponents() << "! Should be equal !";
2134 throw INTERP_KERNEL::Exception(oss.str().c_str());
2136 int nbOfTuples=other->getNumberOfTuples();
2137 int thisNbOfTuples=getNumberOfTuples();
2138 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbOfTuples,1);
2140 getMinMaxPerComponent(bounds);
2145 double xDelta(fabs(bounds[1]-bounds[0])),yDelta(fabs(bounds[3]-bounds[2])),zDelta(fabs(bounds[5]-bounds[4]));
2146 double delta=std::max(xDelta,yDelta); delta=std::max(delta,zDelta);
2147 double characSize=pow((delta*delta*delta)/((double)thisNbOfTuples),1./3.);
2148 BBTreePts<3,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
2149 FindClosestTupleIdAlg<3>(myTree,3.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
2154 double xDelta(fabs(bounds[1]-bounds[0])),yDelta(fabs(bounds[3]-bounds[2]));
2155 double delta=std::max(xDelta,yDelta);
2156 double characSize=sqrt(delta/(double)thisNbOfTuples);
2157 BBTreePts<2,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
2158 FindClosestTupleIdAlg<2>(myTree,2.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
2163 double characSize=fabs(bounds[1]-bounds[0])/thisNbOfTuples;
2164 BBTreePts<1,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
2165 FindClosestTupleIdAlg<1>(myTree,1.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
2169 throw INTERP_KERNEL::Exception("Unexpected spacedim of coords for findClosestTupleId. Must be 1, 2 or 3.");
2175 * This method expects that \a this and \a otherBBoxFrmt arrays are bounding box arrays ( as the output of MEDCouplingPointSet::getBoundingBoxForBBTree method ).
2176 * 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
2177 * how many bounding boxes in \a otherBBoxFrmt.
2178 * So, this method expects that \a this and \a otherBBoxFrmt have the same number of components.
2180 * \param [in] otherBBoxFrmt - It is an array .
2181 * \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.
2182 * \sa MEDCouplingPointSet::getBoundingBoxForBBTree
2183 * \throw If \a this and \a otherBBoxFrmt have not the same number of components.
2184 * \throw If \a this and \a otherBBoxFrmt number of components is not even (BBox format).
2186 DataArrayInt *DataArrayDouble::computeNbOfInteractionsWith(const DataArrayDouble *otherBBoxFrmt, double eps) const
2189 throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : input array is NULL !");
2190 if(!isAllocated() || !otherBBoxFrmt->isAllocated())
2191 throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : this and input array must be allocated !");
2192 int nbOfComp(getNumberOfComponents()),nbOfTuples(getNumberOfTuples());
2193 if(nbOfComp!=otherBBoxFrmt->getNumberOfComponents())
2195 std::ostringstream oss; oss << "DataArrayDouble::computeNbOfInteractionsWith : this number of components (" << nbOfComp << ") must be equal to the number of components of input array (" << otherBBoxFrmt->getNumberOfComponents() << ") !";
2196 throw INTERP_KERNEL::Exception(oss.str().c_str());
2200 std::ostringstream oss; oss << "DataArrayDouble::computeNbOfInteractionsWith : Number of components (" << nbOfComp << ") is not even ! It should be to be compatible with bbox format !";
2201 throw INTERP_KERNEL::Exception(oss.str().c_str());
2203 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(nbOfTuples,1);
2204 const double *thisBBPtr(begin());
2205 int *retPtr(ret->getPointer());
2210 BBTree<3,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
2211 for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
2212 *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
2217 BBTree<2,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
2218 for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
2219 *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
2224 BBTree<1,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
2225 for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
2226 *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
2230 throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : space dimension supported are [1,2,3] !");
2237 * Returns a copy of \a this array by excluding coincident tuples. Each tuple is
2238 * considered as coordinates of a point in getNumberOfComponents()-dimensional
2239 * space. The distance between tuples is computed using norm2. If several tuples are
2240 * not far each from other than \a prec, only one of them remains in the result
2241 * array. The order of tuples in the result array is same as in \a this one except
2242 * that coincident tuples are excluded.
2243 * \param [in] prec - minimal absolute distance between two tuples at which they are
2244 * considered not coincident.
2245 * \param [in] limitTupleId - limit tuple id. If all tuples within a group of coincident
2246 * tuples have id strictly lower than \a limitTupleId then they are not excluded.
2247 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
2248 * is to delete using decrRef() as it is no more needed.
2249 * \throw If \a this is not allocated.
2250 * \throw If the number of components is not in [1,2,3,4].
2252 * \if ENABLE_EXAMPLES
2253 * \ref py_mcdataarraydouble_getdifferentvalues "Here is a Python example".
2256 DataArrayDouble *DataArrayDouble::getDifferentValues(double prec, int limitTupleId) const
2259 DataArrayInt *c0=0,*cI0=0;
2260 findCommonTuples(prec,limitTupleId,c0,cI0);
2261 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> c(c0),cI(cI0);
2262 int newNbOfTuples=-1;
2263 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> o2n=DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(getNumberOfTuples(),c0->begin(),cI0->begin(),cI0->end(),newNbOfTuples);
2264 return renumberAndReduce(o2n->getConstPointer(),newNbOfTuples);
2268 * Copy all components in a specified order from another DataArrayDouble.
2269 * Both numerical and textual data is copied. The number of tuples in \a this and
2270 * the other array can be different.
2271 * \param [in] a - the array to copy data from.
2272 * \param [in] compoIds - sequence of zero based indices of components, data of which is
2274 * \throw If \a a is NULL.
2275 * \throw If \a compoIds.size() != \a a->getNumberOfComponents().
2276 * \throw If \a compoIds[i] < 0 or \a compoIds[i] > \a this->getNumberOfComponents().
2278 * \if ENABLE_EXAMPLES
2279 * \ref py_mcdataarraydouble_setselectedcomponents "Here is a Python example".
2282 void DataArrayDouble::setSelectedComponents(const DataArrayDouble *a, const std::vector<int>& compoIds)
2285 throw INTERP_KERNEL::Exception("DataArrayDouble::setSelectedComponents : input DataArrayDouble is NULL !");
2287 copyPartOfStringInfoFrom2(compoIds,*a);
2288 std::size_t partOfCompoSz=compoIds.size();
2289 int nbOfCompo=getNumberOfComponents();
2290 int nbOfTuples=std::min(getNumberOfTuples(),a->getNumberOfTuples());
2291 const double *ac=a->getConstPointer();
2292 double *nc=getPointer();
2293 for(int i=0;i<nbOfTuples;i++)
2294 for(std::size_t j=0;j<partOfCompoSz;j++,ac++)
2295 nc[nbOfCompo*i+compoIds[j]]=*ac;
2299 * Copy all values from another DataArrayDouble into specified tuples and components
2300 * of \a this array. Textual data is not copied.
2301 * The tree parameters defining set of indices of tuples and components are similar to
2302 * the tree parameters of the Python function \c range(\c start,\c stop,\c step).
2303 * \param [in] a - the array to copy values from.
2304 * \param [in] bgTuples - index of the first tuple of \a this array to assign values to.
2305 * \param [in] endTuples - index of the tuple before which the tuples to assign to
2307 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
2308 * \param [in] bgComp - index of the first component of \a this array to assign values to.
2309 * \param [in] endComp - index of the component before which the components to assign
2311 * \param [in] stepComp - index increment to get index of the next component to assign to.
2312 * \param [in] strictCompoCompare - if \a true (by default), then \a a->getNumberOfComponents()
2313 * must be equal to the number of columns to assign to, else an
2314 * exception is thrown; if \a false, then it is only required that \a
2315 * a->getNbOfElems() equals to number of values to assign to (this condition
2316 * must be respected even if \a strictCompoCompare is \a true). The number of
2317 * values to assign to is given by following Python expression:
2318 * \a nbTargetValues =
2319 * \c len(\c range(\a bgTuples,\a endTuples,\a stepTuples)) *
2320 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2321 * \throw If \a a is NULL.
2322 * \throw If \a a is not allocated.
2323 * \throw If \a this is not allocated.
2324 * \throw If parameters specifying tuples and components to assign to do not give a
2325 * non-empty range of increasing indices.
2326 * \throw If \a a->getNbOfElems() != \a nbTargetValues.
2327 * \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
2328 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2330 * \if ENABLE_EXAMPLES
2331 * \ref py_mcdataarraydouble_setpartofvalues1 "Here is a Python example".
2334 void DataArrayDouble::setPartOfValues1(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
2337 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues1 : input DataArrayDouble is NULL !");
2338 const char msg[]="DataArrayDouble::setPartOfValues1";
2340 a->checkAllocated();
2341 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2342 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2343 int nbComp=getNumberOfComponents();
2344 int nbOfTuples=getNumberOfTuples();
2345 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2346 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2347 bool assignTech=true;
2348 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2350 if(strictCompoCompare)
2351 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2355 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2358 const double *srcPt=a->getConstPointer();
2359 double *pt=getPointer()+bgTuples*nbComp+bgComp;
2362 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2363 for(int j=0;j<newNbOfComp;j++,srcPt++)
2364 pt[j*stepComp]=*srcPt;
2368 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2370 const double *srcPt2=srcPt;
2371 for(int j=0;j<newNbOfComp;j++,srcPt2++)
2372 pt[j*stepComp]=*srcPt2;
2378 * Assign a given value to values at specified tuples and components of \a this array.
2379 * The tree parameters defining set of indices of tuples and components are similar to
2380 * the tree parameters of the Python function \c range(\c start,\c stop,\c step)..
2381 * \param [in] a - the value to assign.
2382 * \param [in] bgTuples - index of the first tuple of \a this array to assign to.
2383 * \param [in] endTuples - index of the tuple before which the tuples to assign to
2385 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
2386 * \param [in] bgComp - index of the first component of \a this array to assign to.
2387 * \param [in] endComp - index of the component before which the components to assign
2389 * \param [in] stepComp - index increment to get index of the next component to assign to.
2390 * \throw If \a this is not allocated.
2391 * \throw If parameters specifying tuples and components to assign to, do not give a
2392 * non-empty range of increasing indices or indices are out of a valid range
2393 * for \c this array.
2395 * \if ENABLE_EXAMPLES
2396 * \ref py_mcdataarraydouble_setpartofvaluessimple1 "Here is a Python example".
2399 void DataArrayDouble::setPartOfValuesSimple1(double a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp)
2401 const char msg[]="DataArrayDouble::setPartOfValuesSimple1";
2403 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2404 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2405 int nbComp=getNumberOfComponents();
2406 int nbOfTuples=getNumberOfTuples();
2407 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2408 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2409 double *pt=getPointer()+bgTuples*nbComp+bgComp;
2410 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2411 for(int j=0;j<newNbOfComp;j++)
2416 * Copy all values from another DataArrayDouble (\a a) into specified tuples and
2417 * components of \a this array. Textual data is not copied.
2418 * The tuples and components to assign to are defined by C arrays of indices.
2419 * There are two *modes of usage*:
2420 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
2421 * of \a a is assigned to its own location within \a this array.
2422 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
2423 * components of every specified tuple of \a this array. In this mode it is required
2424 * that \a a->getNumberOfComponents() equals to the number of specified components.
2426 * \param [in] a - the array to copy values from.
2427 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2428 * assign values of \a a to.
2429 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2430 * pointer to a tuple index <em>(pi)</em> varies as this:
2431 * \a bgTuples <= \a pi < \a endTuples.
2432 * \param [in] bgComp - pointer to an array of component indices of \a this array to
2433 * assign values of \a a to.
2434 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
2435 * pointer to a component index <em>(pi)</em> varies as this:
2436 * \a bgComp <= \a pi < \a endComp.
2437 * \param [in] strictCompoCompare - this parameter is checked only if the
2438 * *mode of usage* is the first; if it is \a true (default),
2439 * then \a a->getNumberOfComponents() must be equal
2440 * to the number of specified columns, else this is not required.
2441 * \throw If \a a is NULL.
2442 * \throw If \a a is not allocated.
2443 * \throw If \a this is not allocated.
2444 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
2445 * out of a valid range for \a this array.
2446 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
2447 * if <em> a->getNumberOfComponents() != (endComp - bgComp) </em>.
2448 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
2449 * <em> a->getNumberOfComponents() != (endComp - bgComp)</em>.
2451 * \if ENABLE_EXAMPLES
2452 * \ref py_mcdataarraydouble_setpartofvalues2 "Here is a Python example".
2455 void DataArrayDouble::setPartOfValues2(const DataArrayDouble *a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
2458 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues2 : input DataArrayDouble is NULL !");
2459 const char msg[]="DataArrayDouble::setPartOfValues2";
2461 a->checkAllocated();
2462 int nbComp=getNumberOfComponents();
2463 int nbOfTuples=getNumberOfTuples();
2464 for(const int *z=bgComp;z!=endComp;z++)
2465 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2466 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
2467 int newNbOfComp=(int)std::distance(bgComp,endComp);
2468 bool assignTech=true;
2469 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2471 if(strictCompoCompare)
2472 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2476 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2479 double *pt=getPointer();
2480 const double *srcPt=a->getConstPointer();
2483 for(const int *w=bgTuples;w!=endTuples;w++)
2485 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2486 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
2488 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt;
2494 for(const int *w=bgTuples;w!=endTuples;w++)
2496 const double *srcPt2=srcPt;
2497 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2498 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
2500 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt2;
2507 * Assign a given value to values at specified tuples and components of \a this array.
2508 * The tuples and components to assign to are defined by C arrays of indices.
2509 * \param [in] a - the value to assign.
2510 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2512 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2513 * pointer to a tuple index (\a pi) varies as this:
2514 * \a bgTuples <= \a pi < \a endTuples.
2515 * \param [in] bgComp - pointer to an array of component indices of \a this array to
2517 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
2518 * pointer to a component index (\a pi) varies as this:
2519 * \a bgComp <= \a pi < \a endComp.
2520 * \throw If \a this is not allocated.
2521 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
2522 * out of a valid range for \a this array.
2524 * \if ENABLE_EXAMPLES
2525 * \ref py_mcdataarraydouble_setpartofvaluessimple2 "Here is a Python example".
2528 void DataArrayDouble::setPartOfValuesSimple2(double a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp)
2531 int nbComp=getNumberOfComponents();
2532 int nbOfTuples=getNumberOfTuples();
2533 for(const int *z=bgComp;z!=endComp;z++)
2534 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2535 double *pt=getPointer();
2536 for(const int *w=bgTuples;w!=endTuples;w++)
2537 for(const int *z=bgComp;z!=endComp;z++)
2539 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2540 pt[(std::size_t)(*w)*nbComp+(*z)]=a;
2545 * Copy all values from another DataArrayDouble (\a a) into specified tuples and
2546 * components of \a this array. Textual data is not copied.
2547 * The tuples to assign to are defined by a C array of indices.
2548 * The components to assign to are defined by three values similar to parameters of
2549 * the Python function \c range(\c start,\c stop,\c step).
2550 * There are two *modes of usage*:
2551 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
2552 * of \a a is assigned to its own location within \a this array.
2553 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
2554 * components of every specified tuple of \a this array. In this mode it is required
2555 * that \a a->getNumberOfComponents() equals to the number of specified components.
2557 * \param [in] a - the array to copy values from.
2558 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2559 * assign values of \a a to.
2560 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2561 * pointer to a tuple index <em>(pi)</em> varies as this:
2562 * \a bgTuples <= \a pi < \a endTuples.
2563 * \param [in] bgComp - index of the first component of \a this array to assign to.
2564 * \param [in] endComp - index of the component before which the components to assign
2566 * \param [in] stepComp - index increment to get index of the next component to assign to.
2567 * \param [in] strictCompoCompare - this parameter is checked only in the first
2568 * *mode of usage*; if \a strictCompoCompare is \a true (default),
2569 * then \a a->getNumberOfComponents() must be equal
2570 * to the number of specified columns, else this is not required.
2571 * \throw If \a a is NULL.
2572 * \throw If \a a is not allocated.
2573 * \throw If \a this is not allocated.
2574 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
2576 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
2577 * if <em> a->getNumberOfComponents()</em> is unequal to the number of components
2578 * defined by <em>(bgComp,endComp,stepComp)</em>.
2579 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
2580 * <em> a->getNumberOfComponents()</em> is unequal to the number of components
2581 * defined by <em>(bgComp,endComp,stepComp)</em>.
2582 * \throw If parameters specifying components to assign to, do not give a
2583 * non-empty range of increasing indices or indices are out of a valid range
2584 * for \c this array.
2586 * \if ENABLE_EXAMPLES
2587 * \ref py_mcdataarraydouble_setpartofvalues3 "Here is a Python example".
2590 void DataArrayDouble::setPartOfValues3(const DataArrayDouble *a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
2593 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues3 : input DataArrayDouble is NULL !");
2594 const char msg[]="DataArrayDouble::setPartOfValues3";
2596 a->checkAllocated();
2597 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2598 int nbComp=getNumberOfComponents();
2599 int nbOfTuples=getNumberOfTuples();
2600 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2601 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
2602 bool assignTech=true;
2603 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2605 if(strictCompoCompare)
2606 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2610 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2613 double *pt=getPointer()+bgComp;
2614 const double *srcPt=a->getConstPointer();
2617 for(const int *w=bgTuples;w!=endTuples;w++)
2618 for(int j=0;j<newNbOfComp;j++,srcPt++)
2620 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2621 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt;
2626 for(const int *w=bgTuples;w!=endTuples;w++)
2628 const double *srcPt2=srcPt;
2629 for(int j=0;j<newNbOfComp;j++,srcPt2++)
2631 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2632 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt2;
2639 * Assign a given value to values at specified tuples and components of \a this array.
2640 * The tuples to assign to are defined by a C array of indices.
2641 * The components to assign to are defined by three values similar to parameters of
2642 * the Python function \c range(\c start,\c stop,\c step).
2643 * \param [in] a - the value to assign.
2644 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2646 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2647 * pointer to a tuple index <em>(pi)</em> varies as this:
2648 * \a bgTuples <= \a pi < \a endTuples.
2649 * \param [in] bgComp - index of the first component of \a this array to assign to.
2650 * \param [in] endComp - index of the component before which the components to assign
2652 * \param [in] stepComp - index increment to get index of the next component to assign to.
2653 * \throw If \a this is not allocated.
2654 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
2656 * \throw If parameters specifying components to assign to, do not give a
2657 * non-empty range of increasing indices or indices are out of a valid range
2658 * for \c this array.
2660 * \if ENABLE_EXAMPLES
2661 * \ref py_mcdataarraydouble_setpartofvaluessimple3 "Here is a Python example".
2664 void DataArrayDouble::setPartOfValuesSimple3(double a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp)
2666 const char msg[]="DataArrayDouble::setPartOfValuesSimple3";
2668 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2669 int nbComp=getNumberOfComponents();
2670 int nbOfTuples=getNumberOfTuples();
2671 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2672 double *pt=getPointer()+bgComp;
2673 for(const int *w=bgTuples;w!=endTuples;w++)
2674 for(int j=0;j<newNbOfComp;j++)
2676 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2677 pt[(std::size_t)(*w)*nbComp+j*stepComp]=a;
2682 * Copy all values from another DataArrayDouble into specified tuples and components
2683 * of \a this array. Textual data is not copied.
2684 * The tree parameters defining set of indices of tuples and components are similar to
2685 * the tree parameters of the Python function \c range(\c start,\c stop,\c step).
2686 * \param [in] a - the array to copy values from.
2687 * \param [in] bgTuples - index of the first tuple of \a this array to assign values to.
2688 * \param [in] endTuples - index of the tuple before which the tuples to assign to
2690 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
2691 * \param [in] bgComp - pointer to an array of component indices of \a this array to
2693 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
2694 * pointer to a component index (\a pi) varies as this:
2695 * \a bgComp <= \a pi < \a endComp.
2696 * \param [in] strictCompoCompare - if \a true (by default), then \a a->getNumberOfComponents()
2697 * must be equal to the number of columns to assign to, else an
2698 * exception is thrown; if \a false, then it is only required that \a
2699 * a->getNbOfElems() equals to number of values to assign to (this condition
2700 * must be respected even if \a strictCompoCompare is \a true). The number of
2701 * values to assign to is given by following Python expression:
2702 * \a nbTargetValues =
2703 * \c len(\c range(\a bgTuples,\a endTuples,\a stepTuples)) *
2704 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2705 * \throw If \a a is NULL.
2706 * \throw If \a a is not allocated.
2707 * \throw If \a this is not allocated.
2708 * \throw If parameters specifying tuples and components to assign to do not give a
2709 * non-empty range of increasing indices.
2710 * \throw If \a a->getNbOfElems() != \a nbTargetValues.
2711 * \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
2712 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2715 void DataArrayDouble::setPartOfValues4(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
2718 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues4 : input DataArrayDouble is NULL !");
2719 const char msg[]="DataArrayDouble::setPartOfValues4";
2721 a->checkAllocated();
2722 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2723 int newNbOfComp=(int)std::distance(bgComp,endComp);
2724 int nbComp=getNumberOfComponents();
2725 for(const int *z=bgComp;z!=endComp;z++)
2726 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2727 int nbOfTuples=getNumberOfTuples();
2728 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2729 bool assignTech=true;
2730 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2732 if(strictCompoCompare)
2733 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2737 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2740 const double *srcPt=a->getConstPointer();
2741 double *pt=getPointer()+bgTuples*nbComp;
2744 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2745 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
2750 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2752 const double *srcPt2=srcPt;
2753 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
2759 void DataArrayDouble::setPartOfValuesSimple4(double a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp)
2761 const char msg[]="DataArrayDouble::setPartOfValuesSimple4";
2763 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2764 int nbComp=getNumberOfComponents();
2765 for(const int *z=bgComp;z!=endComp;z++)
2766 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2767 int nbOfTuples=getNumberOfTuples();
2768 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2769 double *pt=getPointer()+bgTuples*nbComp;
2770 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2771 for(const int *z=bgComp;z!=endComp;z++)
2776 * Copy some tuples from another DataArrayDouble into specified tuples
2777 * of \a this array. Textual data is not copied. Both arrays must have equal number of
2779 * Both the tuples to assign and the tuples to assign to are defined by a DataArrayInt.
2780 * All components of selected tuples are copied.
2781 * \param [in] a - the array to copy values from.
2782 * \param [in] tuplesSelec - the array specifying both source tuples of \a a and
2783 * target tuples of \a this. \a tuplesSelec has two components, and the
2784 * first component specifies index of the source tuple and the second
2785 * one specifies index of the target tuple.
2786 * \throw If \a this is not allocated.
2787 * \throw If \a a is NULL.
2788 * \throw If \a a is not allocated.
2789 * \throw If \a tuplesSelec is NULL.
2790 * \throw If \a tuplesSelec is not allocated.
2791 * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
2792 * \throw If \a tuplesSelec->getNumberOfComponents() != 2.
2793 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
2794 * the corresponding (\a this or \a a) array.
2796 void DataArrayDouble::setPartOfValuesAdv(const DataArrayDouble *a, const DataArrayInt *tuplesSelec)
2798 if(!a || !tuplesSelec)
2799 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValuesAdv : input DataArrayDouble is NULL !");
2801 a->checkAllocated();
2802 tuplesSelec->checkAllocated();
2803 int nbOfComp=getNumberOfComponents();
2804 if(nbOfComp!=a->getNumberOfComponents())
2805 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValuesAdv : This and a do not have the same number of components !");
2806 if(tuplesSelec->getNumberOfComponents()!=2)
2807 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValuesAdv : Expecting to have a tuple selector DataArrayInt instance with exactly 2 components !");
2808 int thisNt=getNumberOfTuples();
2809 int aNt=a->getNumberOfTuples();
2810 double *valsToSet=getPointer();
2811 const double *valsSrc=a->getConstPointer();
2812 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple+=2)
2814 if(tuple[1]>=0 && tuple[1]<aNt)
2816 if(tuple[0]>=0 && tuple[0]<thisNt)
2817 std::copy(valsSrc+nbOfComp*tuple[1],valsSrc+nbOfComp*(tuple[1]+1),valsToSet+nbOfComp*tuple[0]);
2820 std::ostringstream oss; oss << "DataArrayDouble::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
2821 oss << " of 'tuplesSelec' request of tuple id #" << tuple[0] << " in 'this' ! It should be in [0," << thisNt << ") !";
2822 throw INTERP_KERNEL::Exception(oss.str().c_str());
2827 std::ostringstream oss; oss << "DataArrayDouble::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
2828 oss << " of 'tuplesSelec' request of tuple id #" << tuple[1] << " in 'a' ! It should be in [0," << aNt << ") !";
2829 throw INTERP_KERNEL::Exception(oss.str().c_str());
2835 * Copy some tuples from another DataArrayDouble (\a aBase) into contiguous tuples
2836 * of \a this array. Textual data is not copied. Both arrays must have equal number of
2838 * The tuples to assign to are defined by index of the first tuple, and
2839 * their number is defined by \a tuplesSelec->getNumberOfTuples().
2840 * The tuples to copy are defined by values of a DataArrayInt.
2841 * All components of selected tuples are copied.
2842 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
2844 * \param [in] aBase - the array to copy values from.
2845 * \param [in] tuplesSelec - the array specifying tuples of \a a to copy.
2846 * \throw If \a this is not allocated.
2847 * \throw If \a aBase is NULL.
2848 * \throw If \a aBase is not allocated.
2849 * \throw If \a tuplesSelec is NULL.
2850 * \throw If \a tuplesSelec is not allocated.
2851 * \throw If <em>this->getNumberOfComponents() != aBase->getNumberOfComponents()</em>.
2852 * \throw If \a tuplesSelec->getNumberOfComponents() != 1.
2853 * \throw If <em>tupleIdStart + tuplesSelec->getNumberOfTuples() > this->getNumberOfTuples().</em>
2854 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
2857 void DataArrayDouble::setContigPartOfSelectedValues(int tupleIdStart, const DataArray *aBase, const DataArrayInt *tuplesSelec)
2859 if(!aBase || !tuplesSelec)
2860 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : input DataArray is NULL !");
2861 const DataArrayDouble *a=dynamic_cast<const DataArrayDouble *>(aBase);
2863 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : input DataArray aBase is not a DataArrayDouble !");
2865 a->checkAllocated();
2866 tuplesSelec->checkAllocated();
2867 int nbOfComp=getNumberOfComponents();
2868 if(nbOfComp!=a->getNumberOfComponents())
2869 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : This and a do not have the same number of components !");
2870 if(tuplesSelec->getNumberOfComponents()!=1)
2871 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : Expecting to have a tuple selector DataArrayInt instance with exactly 1 component !");
2872 int thisNt=getNumberOfTuples();
2873 int aNt=a->getNumberOfTuples();
2874 int nbOfTupleToWrite=tuplesSelec->getNumberOfTuples();
2875 double *valsToSet=getPointer()+tupleIdStart*nbOfComp;
2876 if(tupleIdStart+nbOfTupleToWrite>thisNt)
2877 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : invalid number range of values to write !");
2878 const double *valsSrc=a->getConstPointer();
2879 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple++,valsToSet+=nbOfComp)
2881 if(*tuple>=0 && *tuple<aNt)
2883 std::copy(valsSrc+nbOfComp*(*tuple),valsSrc+nbOfComp*(*tuple+1),valsToSet);
2887 std::ostringstream oss; oss << "DataArrayDouble::setContigPartOfSelectedValues : Tuple #" << std::distance(tuplesSelec->begin(),tuple);
2888 oss << " of 'tuplesSelec' request of tuple id #" << *tuple << " in 'a' ! It should be in [0," << aNt << ") !";
2889 throw INTERP_KERNEL::Exception(oss.str().c_str());
2895 * Copy some tuples from another DataArrayDouble (\a aBase) into contiguous tuples
2896 * of \a this array. Textual data is not copied. Both arrays must have equal number of
2898 * The tuples to copy are defined by three values similar to parameters of
2899 * the Python function \c range(\c start,\c stop,\c step).
2900 * The tuples to assign to are defined by index of the first tuple, and
2901 * their number is defined by number of tuples to copy.
2902 * All components of selected tuples are copied.
2903 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
2905 * \param [in] aBase - the array to copy values from.
2906 * \param [in] bg - index of the first tuple to copy of the array \a aBase.
2907 * \param [in] end2 - index of the tuple of \a aBase before which the tuples to copy
2909 * \param [in] step - index increment to get index of the next tuple to copy.
2910 * \throw If \a this is not allocated.
2911 * \throw If \a aBase is NULL.
2912 * \throw If \a aBase is not allocated.
2913 * \throw If <em>this->getNumberOfComponents() != aBase->getNumberOfComponents()</em>.
2914 * \throw If <em>tupleIdStart + len(range(bg,end2,step)) > this->getNumberOfTuples().</em>
2915 * \throw If parameters specifying tuples to copy, do not give a
2916 * non-empty range of increasing indices or indices are out of a valid range
2917 * for the array \a aBase.
2919 void DataArrayDouble::setContigPartOfSelectedValues2(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step)
2922 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : input DataArray is NULL !");
2923 const DataArrayDouble *a=dynamic_cast<const DataArrayDouble *>(aBase);
2925 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : input DataArray aBase is not a DataArrayDouble !");
2927 a->checkAllocated();
2928 int nbOfComp=getNumberOfComponents();
2929 const char msg[]="DataArrayDouble::setContigPartOfSelectedValues2";
2930 int nbOfTupleToWrite=DataArray::GetNumberOfItemGivenBES(bg,end2,step,msg);
2931 if(nbOfComp!=a->getNumberOfComponents())
2932 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : This and a do not have the same number of components !");
2933 int thisNt=getNumberOfTuples();
2934 int aNt=a->getNumberOfTuples();
2935 double *valsToSet=getPointer()+tupleIdStart*nbOfComp;
2936 if(tupleIdStart+nbOfTupleToWrite>thisNt)
2937 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : invalid number range of values to write !");
2939 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : invalid range of values to read !");
2940 const double *valsSrc=a->getConstPointer()+bg*nbOfComp;
2941 for(int i=0;i<nbOfTupleToWrite;i++,valsToSet+=nbOfComp,valsSrc+=step*nbOfComp)
2943 std::copy(valsSrc,valsSrc+nbOfComp,valsToSet);
2948 * Returns a value located at specified tuple and component.
2949 * This method is equivalent to DataArrayDouble::getIJ() except that validity of
2950 * parameters is checked. So this method is safe but expensive if used to go through
2951 * all values of \a this.
2952 * \param [in] tupleId - index of tuple of interest.
2953 * \param [in] compoId - index of component of interest.
2954 * \return double - value located by \a tupleId and \a compoId.
2955 * \throw If \a this is not allocated.
2956 * \throw If condition <em>( 0 <= tupleId < this->getNumberOfTuples() )</em> is violated.
2957 * \throw If condition <em>( 0 <= compoId < this->getNumberOfComponents() )</em> is violated.
2959 double DataArrayDouble::getIJSafe(int tupleId, int compoId) const
2962 if(tupleId<0 || tupleId>=getNumberOfTuples())
2964 std::ostringstream oss; oss << "DataArrayDouble::getIJSafe : request for tupleId " << tupleId << " should be in [0," << getNumberOfTuples() << ") !";
2965 throw INTERP_KERNEL::Exception(oss.str().c_str());
2967 if(compoId<0 || compoId>=getNumberOfComponents())
2969 std::ostringstream oss; oss << "DataArrayDouble::getIJSafe : request for compoId " << compoId << " should be in [0," << getNumberOfComponents() << ") !";
2970 throw INTERP_KERNEL::Exception(oss.str().c_str());
2972 return _mem[tupleId*_info_on_compo.size()+compoId];
2976 * Returns the first value of \a this.
2977 * \return double - the last value of \a this array.
2978 * \throw If \a this is not allocated.
2979 * \throw If \a this->getNumberOfComponents() != 1.
2980 * \throw If \a this->getNumberOfTuples() < 1.
2982 double DataArrayDouble::front() const
2985 if(getNumberOfComponents()!=1)
2986 throw INTERP_KERNEL::Exception("DataArrayDouble::front : number of components not equal to one !");
2987 int nbOfTuples=getNumberOfTuples();
2989 throw INTERP_KERNEL::Exception("DataArrayDouble::front : number of tuples must be >= 1 !");
2990 return *(getConstPointer());
2994 * Returns the last value of \a this.
2995 * \return double - the last value of \a this array.
2996 * \throw If \a this is not allocated.
2997 * \throw If \a this->getNumberOfComponents() != 1.
2998 * \throw If \a this->getNumberOfTuples() < 1.
3000 double DataArrayDouble::back() const
3003 if(getNumberOfComponents()!=1)
3004 throw INTERP_KERNEL::Exception("DataArrayDouble::back : number of components not equal to one !");
3005 int nbOfTuples=getNumberOfTuples();
3007 throw INTERP_KERNEL::Exception("DataArrayDouble::back : number of tuples must be >= 1 !");
3008 return *(getConstPointer()+nbOfTuples-1);
3011 void DataArrayDouble::SetArrayIn(DataArrayDouble *newArray, DataArrayDouble* &arrayToSet)
3013 if(newArray!=arrayToSet)
3016 arrayToSet->decrRef();
3017 arrayToSet=newArray;
3019 arrayToSet->incrRef();
3024 * Sets a C array to be used as raw data of \a this. The previously set info
3025 * of components is retained and re-sized.
3026 * For more info see \ref MEDCouplingArraySteps1.
3027 * \param [in] array - the C array to be used as raw data of \a this.
3028 * \param [in] ownership - if \a true, \a array will be deallocated at destruction of \a this.
3029 * \param [in] type - specifies how to deallocate \a array. If \a type == ParaMEDMEM::CPP_DEALLOC,
3030 * \c delete [] \c array; will be called. If \a type == ParaMEDMEM::C_DEALLOC,
3031 * \c free(\c array ) will be called.
3032 * \param [in] nbOfTuple - new number of tuples in \a this.
3033 * \param [in] nbOfCompo - new number of components in \a this.
3035 void DataArrayDouble::useArray(const double *array, bool ownership, DeallocType type, int nbOfTuple, int nbOfCompo)
3037 _info_on_compo.resize(nbOfCompo);
3038 _mem.useArray(array,ownership,type,(std::size_t)nbOfTuple*nbOfCompo);
3042 void DataArrayDouble::useExternalArrayWithRWAccess(const double *array, int nbOfTuple, int nbOfCompo)
3044 _info_on_compo.resize(nbOfCompo);
3045 _mem.useExternalArrayWithRWAccess(array,(std::size_t)nbOfTuple*nbOfCompo);
3050 * Checks if 0.0 value is present in \a this array. If it is the case, an exception
3052 * \throw If zero is found in \a this array.
3054 void DataArrayDouble::checkNoNullValues() const
3056 const double *tmp=getConstPointer();
3057 std::size_t nbOfElems=getNbOfElems();
3058 const double *where=std::find(tmp,tmp+nbOfElems,0.);
3059 if(where!=tmp+nbOfElems)
3060 throw INTERP_KERNEL::Exception("A value 0.0 have been detected !");
3064 * Computes minimal and maximal value in each component. An output array is filled
3065 * with \c 2 * \a this->getNumberOfComponents() values, so the caller is to allocate
3066 * enough memory before calling this method.
3067 * \param [out] bounds - array of size at least 2 *\a this->getNumberOfComponents().
3068 * It is filled as follows:<br>
3069 * \a bounds[0] = \c min_of_component_0 <br>
3070 * \a bounds[1] = \c max_of_component_0 <br>
3071 * \a bounds[2] = \c min_of_component_1 <br>
3072 * \a bounds[3] = \c max_of_component_1 <br>
3075 void DataArrayDouble::getMinMaxPerComponent(double *bounds) const
3078 int dim=getNumberOfComponents();
3079 for (int idim=0; idim<dim; idim++)
3081 bounds[idim*2]=std::numeric_limits<double>::max();
3082 bounds[idim*2+1]=-std::numeric_limits<double>::max();
3084 const double *ptr=getConstPointer();
3085 int nbOfTuples=getNumberOfTuples();
3086 for(int i=0;i<nbOfTuples;i++)
3088 for(int idim=0;idim<dim;idim++)
3090 if(bounds[idim*2]>ptr[i*dim+idim])
3092 bounds[idim*2]=ptr[i*dim+idim];
3094 if(bounds[idim*2+1]<ptr[i*dim+idim])
3096 bounds[idim*2+1]=ptr[i*dim+idim];
3103 * This method retrieves a newly allocated DataArrayDouble instance having same number of tuples than \a this and twice number of components than \a this
3104 * to store both the min and max per component of each tuples.
3105 * \param [in] epsilon the width of the bbox (identical in each direction) - 0.0 by default
3107 * \return a newly created DataArrayDouble instance having \c this->getNumberOfTuples() tuples and 2 * \c this->getNumberOfComponent() components
3109 * \throw If \a this is not allocated yet.
3111 DataArrayDouble *DataArrayDouble::computeBBoxPerTuple(double epsilon) const
3114 const double *dataPtr=getConstPointer();
3115 int nbOfCompo=getNumberOfComponents();
3116 int nbTuples=getNumberOfTuples();
3117 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> bbox=DataArrayDouble::New();
3118 bbox->alloc(nbTuples,2*nbOfCompo);
3119 double *bboxPtr=bbox->getPointer();
3120 for(int i=0;i<nbTuples;i++)
3122 for(int j=0;j<nbOfCompo;j++)
3124 bboxPtr[2*nbOfCompo*i+2*j]=dataPtr[nbOfCompo*i+j]-epsilon;
3125 bboxPtr[2*nbOfCompo*i+2*j+1]=dataPtr[nbOfCompo*i+j]+epsilon;
3132 * For each tuples **t** in \a other, this method retrieves tuples in \a this that are equal to **t**.
3133 * Two tuples are considered equal if the euclidian distance between the two tuples is lower than \a eps.
3135 * \param [in] other a DataArrayDouble having same number of components than \a this.
3136 * \param [in] eps absolute precision representing distance (using infinite norm) between 2 tuples behind which 2 tuples are considered equal.
3137 * \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.
3138 * \a cI allows to extract information in \a c.
3139 * \param [out] cI is an indirection array that allows to extract the data contained in \a c.
3141 * \throw In case of:
3142 * - \a this is not allocated
3143 * - \a other is not allocated or null
3144 * - \a this and \a other do not have the same number of components
3145 * - if number of components of \a this is not in [1,2,3]
3147 * \sa MEDCouplingPointSet::getNodeIdsNearPoints, DataArrayDouble::getDifferentValues
3149 void DataArrayDouble::computeTupleIdsNearTuples(const DataArrayDouble *other, double eps, DataArrayInt *& c, DataArrayInt *& cI) const
3152 throw INTERP_KERNEL::Exception("DataArrayDouble::computeTupleIdsNearTuples : input pointer other is null !");
3154 other->checkAllocated();
3155 int nbOfCompo=getNumberOfComponents();
3156 int otherNbOfCompo=other->getNumberOfComponents();
3157 if(nbOfCompo!=otherNbOfCompo)
3158 throw INTERP_KERNEL::Exception("DataArrayDouble::computeTupleIdsNearTuples : number of components should be equal between this and other !");
3159 int nbOfTuplesOther=other->getNumberOfTuples();
3160 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cArr(DataArrayInt::New()),cIArr(DataArrayInt::New()); cArr->alloc(0,1); cIArr->pushBackSilent(0);
3165 BBTreePts<3,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
3166 FindTupleIdsNearTuplesAlg<3>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
3171 BBTreePts<2,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
3172 FindTupleIdsNearTuplesAlg<2>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
3177 BBTreePts<1,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
3178 FindTupleIdsNearTuplesAlg<1>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
3182 throw INTERP_KERNEL::Exception("Unexpected spacedim of coords for computeTupleIdsNearTuples. Must be 1, 2 or 3.");
3184 c=cArr.retn(); cI=cIArr.retn();
3188 * 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
3189 * around origin of 'radius' 1.
3191 * \param [in] eps absolute epsilon. under that value of delta between max and min no scale is performed.
3193 void DataArrayDouble::recenterForMaxPrecision(double eps)
3196 int dim=getNumberOfComponents();
3197 std::vector<double> bounds(2*dim);
3198 getMinMaxPerComponent(&bounds[0]);
3199 for(int i=0;i<dim;i++)
3201 double delta=bounds[2*i+1]-bounds[2*i];
3202 double offset=(bounds[2*i]+bounds[2*i+1])/2.;
3204 applyLin(1./delta,-offset/delta,i);
3206 applyLin(1.,-offset,i);
3211 * Returns the maximal value and its location within \a this one-dimensional array.
3212 * \param [out] tupleId - index of the tuple holding the maximal value.
3213 * \return double - the maximal value among all values of \a this array.
3214 * \throw If \a this->getNumberOfComponents() != 1
3215 * \throw If \a this->getNumberOfTuples() < 1
3217 double DataArrayDouble::getMaxValue(int& tupleId) const
3220 if(getNumberOfComponents()!=1)
3221 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 !");
3222 int nbOfTuples=getNumberOfTuples();
3224 throw INTERP_KERNEL::Exception("DataArrayDouble::getMaxValue : array exists but number of tuples must be > 0 !");
3225 const double *vals=getConstPointer();
3226 const double *loc=std::max_element(vals,vals+nbOfTuples);
3227 tupleId=(int)std::distance(vals,loc);
3232 * Returns the maximal value within \a this array that is allowed to have more than
3234 * \return double - the maximal value among all values of \a this array.
3235 * \throw If \a this is not allocated.
3237 double DataArrayDouble::getMaxValueInArray() const
3240 const double *loc=std::max_element(begin(),end());
3245 * Returns the maximal value and all its locations within \a this one-dimensional array.
3246 * \param [out] tupleIds - a new instance of DataArrayInt containg indices of
3247 * tuples holding the maximal value. The caller is to delete it using
3248 * decrRef() as it is no more needed.
3249 * \return double - the maximal value among all values of \a this array.
3250 * \throw If \a this->getNumberOfComponents() != 1
3251 * \throw If \a this->getNumberOfTuples() < 1
3253 double DataArrayDouble::getMaxValue2(DataArrayInt*& tupleIds) const
3257 double ret=getMaxValue(tmp);
3258 tupleIds=getIdsInRange(ret,ret);
3263 * Returns the minimal value and its location within \a this one-dimensional array.
3264 * \param [out] tupleId - index of the tuple holding the minimal value.
3265 * \return double - the minimal value among all values of \a this array.
3266 * \throw If \a this->getNumberOfComponents() != 1
3267 * \throw If \a this->getNumberOfTuples() < 1
3269 double DataArrayDouble::getMinValue(int& tupleId) const
3272 if(getNumberOfComponents()!=1)
3273 throw INTERP_KERNEL::Exception("DataArrayDouble::getMinValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before call 'getMinValueInArray' method !");
3274 int nbOfTuples=getNumberOfTuples();
3276 throw INTERP_KERNEL::Exception("DataArrayDouble::getMinValue : array exists but number of tuples must be > 0 !");
3277 const double *vals=getConstPointer();
3278 const double *loc=std::min_element(vals,vals+nbOfTuples);
3279 tupleId=(int)std::distance(vals,loc);
3284 * Returns the minimal value within \a this array that is allowed to have more than
3286 * \return double - the minimal value among all values of \a this array.
3287 * \throw If \a this is not allocated.
3289 double DataArrayDouble::getMinValueInArray() const
3292 const double *loc=std::min_element(begin(),end());
3297 * Returns the minimal value and all its locations within \a this one-dimensional array.
3298 * \param [out] tupleIds - a new instance of DataArrayInt containg indices of
3299 * tuples holding the minimal value. The caller is to delete it using
3300 * decrRef() as it is no more needed.
3301 * \return double - the minimal value among all values of \a this array.
3302 * \throw If \a this->getNumberOfComponents() != 1
3303 * \throw If \a this->getNumberOfTuples() < 1
3305 double DataArrayDouble::getMinValue2(DataArrayInt*& tupleIds) const
3309 double ret=getMinValue(tmp);
3310 tupleIds=getIdsInRange(ret,ret);
3315 * 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.
3316 * This method only works for single component array.
3318 * \return a value in [ 0, \c this->getNumberOfTuples() )
3320 * \throw If \a this is not allocated
3323 int DataArrayDouble::count(double value, double eps) const
3327 if(getNumberOfComponents()!=1)
3328 throw INTERP_KERNEL::Exception("DataArrayDouble::count : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
3329 const double *vals=begin();
3330 int nbOfTuples=getNumberOfTuples();
3331 for(int i=0;i<nbOfTuples;i++,vals++)
3332 if(fabs(*vals-value)<=eps)
3338 * Returns the average value of \a this one-dimensional array.
3339 * \return double - the average value over all values of \a this array.
3340 * \throw If \a this->getNumberOfComponents() != 1
3341 * \throw If \a this->getNumberOfTuples() < 1
3343 double DataArrayDouble::getAverageValue() const
3345 if(getNumberOfComponents()!=1)
3346 throw INTERP_KERNEL::Exception("DataArrayDouble::getAverageValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
3347 int nbOfTuples=getNumberOfTuples();
3349 throw INTERP_KERNEL::Exception("DataArrayDouble::getAverageValue : array exists but number of tuples must be > 0 !");
3350 const double *vals=getConstPointer();
3351 double ret=std::accumulate(vals,vals+nbOfTuples,0.);
3352 return ret/nbOfTuples;
3356 * Returns the Euclidean norm of the vector defined by \a this array.
3357 * \return double - the value of the Euclidean norm, i.e.
3358 * the square root of the inner product of vector.
3359 * \throw If \a this is not allocated.
3361 double DataArrayDouble::norm2() const
3365 std::size_t nbOfElems=getNbOfElems();
3366 const double *pt=getConstPointer();
3367 for(std::size_t i=0;i<nbOfElems;i++,pt++)
3373 * Returns the maximum norm of the vector defined by \a this array.
3374 * This method works even if the number of components is diferent from one.
3375 * If the number of elements in \a this is 0, -1. is returned.
3376 * \return double - the value of the maximum norm, i.e.
3377 * the maximal absolute value among values of \a this array (whatever its number of components).
3378 * \throw If \a this is not allocated.
3380 double DataArrayDouble::normMax() const
3384 std::size_t nbOfElems(getNbOfElems());
3385 const double *pt(getConstPointer());
3386 for(std::size_t i=0;i<nbOfElems;i++,pt++)
3388 double val(std::abs(*pt));
3396 * Returns the minimum norm (absolute value) of the vector defined by \a this array.
3397 * This method works even if the number of components is diferent from one.
3398 * If the number of elements in \a this is 0, std::numeric_limits<double>::max() is returned.
3399 * \return double - the value of the minimum norm, i.e.
3400 * the minimal absolute value among values of \a this array (whatever its number of components).
3401 * \throw If \a this is not allocated.
3403 double DataArrayDouble::normMin() const
3406 double ret(std::numeric_limits<double>::max());
3407 std::size_t nbOfElems(getNbOfElems());
3408 const double *pt(getConstPointer());
3409 for(std::size_t i=0;i<nbOfElems;i++,pt++)
3411 double val(std::abs(*pt));
3419 * Accumulates values of each component of \a this array.
3420 * \param [out] res - an array of length \a this->getNumberOfComponents(), allocated
3421 * by the caller, that is filled by this method with sum value for each
3423 * \throw If \a this is not allocated.
3425 void DataArrayDouble::accumulate(double *res) const
3428 const double *ptr=getConstPointer();
3429 int nbTuple=getNumberOfTuples();
3430 int nbComps=getNumberOfComponents();
3431 std::fill(res,res+nbComps,0.);
3432 for(int i=0;i<nbTuple;i++)
3433 std::transform(ptr+i*nbComps,ptr+(i+1)*nbComps,res,res,std::plus<double>());
3437 * This method returns the min distance from an external tuple defined by [ \a tupleBg , \a tupleEnd ) to \a this and
3438 * the first tuple in \a this that matches the returned distance. If there is no tuples in \a this an exception will be thrown.
3441 * \a this is expected to be allocated and expected to have a number of components equal to the distance from \a tupleBg to
3442 * \a tupleEnd. If not an exception will be thrown.
3444 * \param [in] tupleBg start pointer (included) of input external tuple
3445 * \param [in] tupleEnd end pointer (not included) of input external tuple
3446 * \param [out] tupleId the tuple id in \a this that matches the min of distance between \a this and input external tuple
3447 * \return the min distance.
3448 * \sa MEDCouplingUMesh::distanceToPoint
3450 double DataArrayDouble::distanceToTuple(const double *tupleBg, const double *tupleEnd, int& tupleId) const
3453 int nbTuple=getNumberOfTuples();
3454 int nbComps=getNumberOfComponents();
3455 if(nbComps!=(int)std::distance(tupleBg,tupleEnd))
3456 { 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()); }
3458 throw INTERP_KERNEL::Exception("DataArrayDouble::distanceToTuple : no tuple in this ! No distance to compute !");
3459 double ret0=std::numeric_limits<double>::max();
3461 const double *work=getConstPointer();
3462 for(int i=0;i<nbTuple;i++)
3465 for(int j=0;j<nbComps;j++,work++)
3466 val+=(*work-tupleBg[j])*((*work-tupleBg[j]));
3470 { ret0=val; tupleId=i; }
3476 * Accumulate values of the given component of \a this array.
3477 * \param [in] compId - the index of the component of interest.
3478 * \return double - a sum value of \a compId-th component.
3479 * \throw If \a this is not allocated.
3480 * \throw If \a the condition ( 0 <= \a compId < \a this->getNumberOfComponents() ) is
3483 double DataArrayDouble::accumulate(int compId) const
3486 const double *ptr=getConstPointer();
3487 int nbTuple=getNumberOfTuples();
3488 int nbComps=getNumberOfComponents();
3489 if(compId<0 || compId>=nbComps)
3490 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulate : Invalid compId specified : No such nb of components !");
3492 for(int i=0;i<nbTuple;i++)
3493 ret+=ptr[i*nbComps+compId];
3498 * This method accumulate using addition tuples in \a this using input index array [ \a bgOfIndex, \a endOfIndex ).
3499 * The returned array will have same number of components than \a this and number of tuples equal to
3500 * \c std::distance(bgOfIndex,endOfIndex) \b minus \b one.
3502 * The input index array is expected to be ascendingly sorted in which the all referenced ids should be in [0, \c this->getNumberOfTuples).
3503 * 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.
3505 * \param [in] bgOfIndex - begin (included) of the input index array.
3506 * \param [in] endOfIndex - end (excluded) of the input index array.
3507 * \return DataArrayDouble * - the new instance having the same number of components than \a this.
3509 * \throw If bgOfIndex or end is NULL.
3510 * \throw If input index array is not ascendingly sorted.
3511 * \throw If there is an id in [ \a bgOfIndex, \a endOfIndex ) not in [0, \c this->getNumberOfTuples).
3512 * \throw If std::distance(bgOfIndex,endOfIndex)==0.
3514 DataArrayDouble *DataArrayDouble::accumulatePerChunck(const int *bgOfIndex, const int *endOfIndex) const
3516 if(!bgOfIndex || !endOfIndex)
3517 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : input pointer NULL !");
3519 int nbCompo=getNumberOfComponents();
3520 int nbOfTuples=getNumberOfTuples();
3521 int sz=(int)std::distance(bgOfIndex,endOfIndex);
3523 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : invalid size of input index array !");
3525 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(sz,nbCompo);
3526 const int *w=bgOfIndex;
3527 if(*w<0 || *w>=nbOfTuples)
3528 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : The first element of the input index not in [0,nbOfTuples) !");
3529 const double *srcPt=begin()+(*w)*nbCompo;
3530 double *tmp=ret->getPointer();
3531 for(int i=0;i<sz;i++,tmp+=nbCompo,w++)
3533 std::fill(tmp,tmp+nbCompo,0.);
3536 for(int j=w[0];j<w[1];j++,srcPt+=nbCompo)
3538 if(j>=0 && j<nbOfTuples)
3539 std::transform(srcPt,srcPt+nbCompo,tmp,tmp,std::plus<double>());
3542 std::ostringstream oss; oss << "DataArrayDouble::accumulatePerChunck : At rank #" << i << " the input index array points to id " << j << " should be in [0," << nbOfTuples << ") !";
3543 throw INTERP_KERNEL::Exception(oss.str().c_str());
3549 std::ostringstream oss; oss << "DataArrayDouble::accumulatePerChunck : At rank #" << i << " the input index array is not in ascendingly sorted.";
3550 throw INTERP_KERNEL::Exception(oss.str().c_str());
3553 ret->copyStringInfoFrom(*this);
3558 * Converts each 2D point defined by the tuple of \a this array from the Polar to the
3559 * Cartesian coordinate system. The two components of the tuple of \a this array are
3560 * considered to contain (1) radius and (2) angle of the point in the Polar CS.
3561 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3562 * contains X and Y coordinates of the point in the Cartesian CS. The caller
3563 * is to delete this array using decrRef() as it is no more needed. The array
3564 * does not contain any textual info on components.
3565 * \throw If \a this->getNumberOfComponents() != 2.
3567 DataArrayDouble *DataArrayDouble::fromPolarToCart() const
3570 int nbOfComp=getNumberOfComponents();
3572 throw INTERP_KERNEL::Exception("DataArrayDouble::fromPolarToCart : must be an array with exactly 2 components !");
3573 int nbOfTuple=getNumberOfTuples();
3574 DataArrayDouble *ret=DataArrayDouble::New();
3575 ret->alloc(nbOfTuple,2);
3576 double *w=ret->getPointer();
3577 const double *wIn=getConstPointer();
3578 for(int i=0;i<nbOfTuple;i++,w+=2,wIn+=2)
3580 w[0]=wIn[0]*cos(wIn[1]);
3581 w[1]=wIn[0]*sin(wIn[1]);
3587 * Converts each 3D point defined by the tuple of \a this array from the Cylindrical to
3588 * the Cartesian coordinate system. The three components of the tuple of \a this array
3589 * are considered to contain (1) radius, (2) azimuth and (3) altitude of the point in
3590 * the Cylindrical CS.
3591 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3592 * contains X, Y and Z coordinates of the point in the Cartesian CS. The info
3593 * on the third component is copied from \a this array. The caller
3594 * is to delete this array using decrRef() as it is no more needed.
3595 * \throw If \a this->getNumberOfComponents() != 3.
3597 DataArrayDouble *DataArrayDouble::fromCylToCart() const
3600 int nbOfComp=getNumberOfComponents();
3602 throw INTERP_KERNEL::Exception("DataArrayDouble::fromCylToCart : must be an array with exactly 3 components !");
3603 int nbOfTuple=getNumberOfTuples();
3604 DataArrayDouble *ret=DataArrayDouble::New();
3605 ret->alloc(getNumberOfTuples(),3);
3606 double *w=ret->getPointer();
3607 const double *wIn=getConstPointer();
3608 for(int i=0;i<nbOfTuple;i++,w+=3,wIn+=3)
3610 w[0]=wIn[0]*cos(wIn[1]);
3611 w[1]=wIn[0]*sin(wIn[1]);
3614 ret->setInfoOnComponent(2,getInfoOnComponent(2));
3619 * Converts each 3D point defined by the tuple of \a this array from the Spherical to
3620 * the Cartesian coordinate system. The three components of the tuple of \a this array
3621 * are considered to contain (1) radius, (2) polar angle and (3) azimuthal angle of the
3622 * point in the Cylindrical CS.
3623 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3624 * contains X, Y and Z coordinates of the point in the Cartesian CS. The info
3625 * on the third component is copied from \a this array. The caller
3626 * is to delete this array using decrRef() as it is no more needed.
3627 * \throw If \a this->getNumberOfComponents() != 3.
3629 DataArrayDouble *DataArrayDouble::fromSpherToCart() const
3632 int nbOfComp=getNumberOfComponents();
3634 throw INTERP_KERNEL::Exception("DataArrayDouble::fromSpherToCart : must be an array with exactly 3 components !");
3635 int nbOfTuple=getNumberOfTuples();
3636 DataArrayDouble *ret=DataArrayDouble::New();
3637 ret->alloc(getNumberOfTuples(),3);
3638 double *w=ret->getPointer();
3639 const double *wIn=getConstPointer();
3640 for(int i=0;i<nbOfTuple;i++,w+=3,wIn+=3)
3642 w[0]=wIn[0]*cos(wIn[2])*sin(wIn[1]);
3643 w[1]=wIn[0]*sin(wIn[2])*sin(wIn[1]);
3644 w[2]=wIn[0]*cos(wIn[1]);
3650 * Computes the doubly contracted product of every tensor defined by the tuple of \a this
3651 * array contating 6 components.
3652 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3653 * is calculated from the tuple <em>(t)</em> of \a this array as follows:
3654 * \f$ t[0]^2+t[1]^2+t[2]^2+2*t[3]^2+2*t[4]^2+2*t[5]^2\f$.
3655 * The caller is to delete this result array using decrRef() as it is no more needed.
3656 * \throw If \a this->getNumberOfComponents() != 6.
3658 DataArrayDouble *DataArrayDouble::doublyContractedProduct() const
3661 int nbOfComp=getNumberOfComponents();
3663 throw INTERP_KERNEL::Exception("DataArrayDouble::doublyContractedProduct : must be an array with exactly 6 components !");
3664 DataArrayDouble *ret=DataArrayDouble::New();
3665 int nbOfTuple=getNumberOfTuples();
3666 ret->alloc(nbOfTuple,1);
3667 const double *src=getConstPointer();
3668 double *dest=ret->getPointer();
3669 for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
3670 *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];
3675 * Computes the determinant of every square matrix defined by the tuple of \a this
3676 * array, which contains either 4, 6 or 9 components. The case of 6 components
3677 * corresponds to that of the upper triangular matrix.
3678 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3679 * is the determinant of matrix of the corresponding tuple of \a this array.
3680 * The caller is to delete this result array using decrRef() as it is no more
3682 * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
3684 DataArrayDouble *DataArrayDouble::determinant() const
3687 DataArrayDouble *ret=DataArrayDouble::New();
3688 int nbOfTuple=getNumberOfTuples();
3689 ret->alloc(nbOfTuple,1);
3690 const double *src=getConstPointer();
3691 double *dest=ret->getPointer();
3692 switch(getNumberOfComponents())
3695 for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
3696 *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];
3699 for(int i=0;i<nbOfTuple;i++,dest++,src+=4)
3700 *dest=src[0]*src[3]-src[1]*src[2];
3703 for(int i=0;i<nbOfTuple;i++,dest++,src+=9)
3704 *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];
3708 throw INTERP_KERNEL::Exception("DataArrayDouble::determinant : Invalid number of components ! must be in 4,6,9 !");
3713 * Computes 3 eigenvalues of every upper triangular matrix defined by the tuple of
3714 * \a this array, which contains 6 components.
3715 * \return DataArrayDouble * - the new instance of DataArrayDouble containing 3
3716 * components, whose each tuple contains the eigenvalues of the matrix of
3717 * corresponding tuple of \a this array.
3718 * The caller is to delete this result array using decrRef() as it is no more
3720 * \throw If \a this->getNumberOfComponents() != 6.
3722 DataArrayDouble *DataArrayDouble::eigenValues() const
3725 int nbOfComp=getNumberOfComponents();
3727 throw INTERP_KERNEL::Exception("DataArrayDouble::eigenValues : must be an array with exactly 6 components !");
3728 DataArrayDouble *ret=DataArrayDouble::New();
3729 int nbOfTuple=getNumberOfTuples();
3730 ret->alloc(nbOfTuple,3);
3731 const double *src=getConstPointer();
3732 double *dest=ret->getPointer();
3733 for(int i=0;i<nbOfTuple;i++,dest+=3,src+=6)
3734 INTERP_KERNEL::computeEigenValues6(src,dest);
3739 * Computes 3 eigenvectors of every upper triangular matrix defined by the tuple of
3740 * \a this array, which contains 6 components.
3741 * \return DataArrayDouble * - the new instance of DataArrayDouble containing 9
3742 * components, whose each tuple contains 3 eigenvectors of the matrix of
3743 * corresponding tuple of \a this array.
3744 * The caller is to delete this result array using decrRef() as it is no more
3746 * \throw If \a this->getNumberOfComponents() != 6.
3748 DataArrayDouble *DataArrayDouble::eigenVectors() const
3751 int nbOfComp=getNumberOfComponents();
3753 throw INTERP_KERNEL::Exception("DataArrayDouble::eigenVectors : must be an array with exactly 6 components !");
3754 DataArrayDouble *ret=DataArrayDouble::New();
3755 int nbOfTuple=getNumberOfTuples();
3756 ret->alloc(nbOfTuple,9);
3757 const double *src=getConstPointer();
3758 double *dest=ret->getPointer();
3759 for(int i=0;i<nbOfTuple;i++,src+=6)
3762 INTERP_KERNEL::computeEigenValues6(src,tmp);
3763 for(int j=0;j<3;j++,dest+=3)
3764 INTERP_KERNEL::computeEigenVectorForEigenValue6(src,tmp[j],1e-12,dest);
3770 * Computes the inverse matrix of every matrix defined by the tuple of \a this
3771 * array, which contains either 4, 6 or 9 components. The case of 6 components
3772 * corresponds to that of the upper triangular matrix.
3773 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3774 * same number of components as \a this one, whose each tuple is the inverse
3775 * matrix of the matrix of corresponding tuple of \a this array.
3776 * The caller is to delete this result array using decrRef() as it is no more
3778 * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
3780 DataArrayDouble *DataArrayDouble::inverse() const
3783 int nbOfComp=getNumberOfComponents();
3784 if(nbOfComp!=6 && nbOfComp!=9 && nbOfComp!=4)
3785 throw INTERP_KERNEL::Exception("DataArrayDouble::inversion : must be an array with 4,6 or 9 components !");
3786 DataArrayDouble *ret=DataArrayDouble::New();
3787 int nbOfTuple=getNumberOfTuples();
3788 ret->alloc(nbOfTuple,nbOfComp);
3789 const double *src=getConstPointer();
3790 double *dest=ret->getPointer();
3792 for(int i=0;i<nbOfTuple;i++,dest+=6,src+=6)
3794 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];
3795 dest[0]=(src[1]*src[2]-src[4]*src[4])/det;
3796 dest[1]=(src[0]*src[2]-src[5]*src[5])/det;
3797 dest[2]=(src[0]*src[1]-src[3]*src[3])/det;
3798 dest[3]=(src[5]*src[4]-src[3]*src[2])/det;
3799 dest[4]=(src[5]*src[3]-src[0]*src[4])/det;
3800 dest[5]=(src[3]*src[4]-src[1]*src[5])/det;
3802 else if(nbOfComp==4)
3803 for(int i=0;i<nbOfTuple;i++,dest+=4,src+=4)
3805 double det=src[0]*src[3]-src[1]*src[2];
3807 dest[1]=-src[1]/det;
3808 dest[2]=-src[2]/det;
3812 for(int i=0;i<nbOfTuple;i++,dest+=9,src+=9)
3814 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];
3815 dest[0]=(src[4]*src[8]-src[7]*src[5])/det;
3816 dest[1]=(src[7]*src[2]-src[1]*src[8])/det;
3817 dest[2]=(src[1]*src[5]-src[4]*src[2])/det;
3818 dest[3]=(src[6]*src[5]-src[3]*src[8])/det;
3819 dest[4]=(src[0]*src[8]-src[6]*src[2])/det;
3820 dest[5]=(src[2]*src[3]-src[0]*src[5])/det;
3821 dest[6]=(src[3]*src[7]-src[6]*src[4])/det;
3822 dest[7]=(src[6]*src[1]-src[0]*src[7])/det;
3823 dest[8]=(src[0]*src[4]-src[1]*src[3])/det;
3829 * Computes the trace of every matrix defined by the tuple of \a this
3830 * array, which contains either 4, 6 or 9 components. The case of 6 components
3831 * corresponds to that of the upper triangular matrix.
3832 * \return DataArrayDouble * - the new instance of DataArrayDouble containing
3833 * 1 component, whose each tuple is the trace of
3834 * the matrix of corresponding tuple of \a this array.
3835 * The caller is to delete this result array using decrRef() as it is no more
3837 * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
3839 DataArrayDouble *DataArrayDouble::trace() const
3842 int nbOfComp=getNumberOfComponents();
3843 if(nbOfComp!=6 && nbOfComp!=9 && nbOfComp!=4)
3844 throw INTERP_KERNEL::Exception("DataArrayDouble::trace : must be an array with 4,6 or 9 components !");
3845 DataArrayDouble *ret=DataArrayDouble::New();
3846 int nbOfTuple=getNumberOfTuples();
3847 ret->alloc(nbOfTuple,1);
3848 const double *src=getConstPointer();
3849 double *dest=ret->getPointer();
3851 for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
3852 *dest=src[0]+src[1]+src[2];
3853 else if(nbOfComp==4)
3854 for(int i=0;i<nbOfTuple;i++,dest++,src+=4)
3855 *dest=src[0]+src[3];
3857 for(int i=0;i<nbOfTuple;i++,dest++,src+=9)
3858 *dest=src[0]+src[4]+src[8];
3863 * Computes the stress deviator tensor of every stress tensor defined by the tuple of
3864 * \a this array, which contains 6 components.
3865 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3866 * same number of components and tuples as \a this array.
3867 * The caller is to delete this result array using decrRef() as it is no more
3869 * \throw If \a this->getNumberOfComponents() != 6.
3871 DataArrayDouble *DataArrayDouble::deviator() const
3874 int nbOfComp=getNumberOfComponents();
3876 throw INTERP_KERNEL::Exception("DataArrayDouble::deviator : must be an array with exactly 6 components !");
3877 DataArrayDouble *ret=DataArrayDouble::New();
3878 int nbOfTuple=getNumberOfTuples();
3879 ret->alloc(nbOfTuple,6);
3880 const double *src=getConstPointer();
3881 double *dest=ret->getPointer();
3882 for(int i=0;i<nbOfTuple;i++,dest+=6,src+=6)
3884 double tr=(src[0]+src[1]+src[2])/3.;
3896 * Computes the magnitude of every vector defined by the tuple of
3898 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3899 * same number of tuples as \a this array and one component.
3900 * The caller is to delete this result array using decrRef() as it is no more
3902 * \throw If \a this is not allocated.
3904 DataArrayDouble *DataArrayDouble::magnitude() const
3907 int nbOfComp=getNumberOfComponents();
3908 DataArrayDouble *ret=DataArrayDouble::New();
3909 int nbOfTuple=getNumberOfTuples();
3910 ret->alloc(nbOfTuple,1);
3911 const double *src=getConstPointer();
3912 double *dest=ret->getPointer();
3913 for(int i=0;i<nbOfTuple;i++,dest++)
3916 for(int j=0;j<nbOfComp;j++,src++)
3924 * Computes for each tuple the sum of number of components values in the tuple and return it.
3926 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3927 * same number of tuples as \a this array and one component.
3928 * The caller is to delete this result array using decrRef() as it is no more
3930 * \throw If \a this is not allocated.
3932 DataArrayDouble *DataArrayDouble::sumPerTuple() const
3935 int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
3936 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret(DataArrayDouble::New());
3937 ret->alloc(nbOfTuple,1);
3938 const double *src(getConstPointer());
3939 double *dest(ret->getPointer());
3940 for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
3941 *dest=std::accumulate(src,src+nbOfComp,0.);
3946 * Computes the maximal value within every tuple of \a this array.
3947 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3948 * same number of tuples as \a this array and one component.
3949 * The caller is to delete this result array using decrRef() as it is no more
3951 * \throw If \a this is not allocated.
3952 * \sa DataArrayDouble::maxPerTupleWithCompoId
3954 DataArrayDouble *DataArrayDouble::maxPerTuple() const
3957 int nbOfComp=getNumberOfComponents();
3958 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
3959 int nbOfTuple=getNumberOfTuples();
3960 ret->alloc(nbOfTuple,1);
3961 const double *src=getConstPointer();
3962 double *dest=ret->getPointer();
3963 for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
3964 *dest=*std::max_element(src,src+nbOfComp);
3969 * Computes the maximal value within every tuple of \a this array and it returns the first component
3970 * id for each tuple that corresponds to the maximal value within the tuple.
3972 * \param [out] compoIdOfMaxPerTuple - the new new instance of DataArrayInt containing the
3973 * same number of tuples and only one component.
3974 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3975 * same number of tuples as \a this array and one component.
3976 * The caller is to delete this result array using decrRef() as it is no more
3978 * \throw If \a this is not allocated.
3979 * \sa DataArrayDouble::maxPerTuple
3981 DataArrayDouble *DataArrayDouble::maxPerTupleWithCompoId(DataArrayInt* &compoIdOfMaxPerTuple) const
3984 int nbOfComp=getNumberOfComponents();
3985 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret0=DataArrayDouble::New();
3986 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New();
3987 int nbOfTuple=getNumberOfTuples();
3988 ret0->alloc(nbOfTuple,1); ret1->alloc(nbOfTuple,1);
3989 const double *src=getConstPointer();
3990 double *dest=ret0->getPointer(); int *dest1=ret1->getPointer();
3991 for(int i=0;i<nbOfTuple;i++,dest++,dest1++,src+=nbOfComp)
3993 const double *loc=std::max_element(src,src+nbOfComp);
3995 *dest1=(int)std::distance(src,loc);
3997 compoIdOfMaxPerTuple=ret1.retn();
4002 * This method returns a newly allocated DataArrayDouble instance having one component and \c this->getNumberOfTuples() * \c this->getNumberOfTuples() tuples.
4003 * \n This returned array contains the euclidian distance for each tuple in \a this.
4004 * \n So the returned array can be seen as a dense symmetrical matrix whose diagonal elements are equal to 0.
4005 * \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)
4007 * \warning use this method with care because it can leads to big amount of consumed memory !
4009 * \return A newly allocated (huge) ParaMEDMEM::DataArrayDouble instance that the caller should deal with.
4011 * \throw If \a this is not allocated.
4013 * \sa DataArrayDouble::buildEuclidianDistanceDenseMatrixWith
4015 DataArrayDouble *DataArrayDouble::buildEuclidianDistanceDenseMatrix() const
4018 int nbOfComp=getNumberOfComponents();
4019 int nbOfTuples=getNumberOfTuples();
4020 const double *inData=getConstPointer();
4021 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
4022 ret->alloc(nbOfTuples*nbOfTuples,1);
4023 double *outData=ret->getPointer();
4024 for(int i=0;i<nbOfTuples;i++)
4026 outData[i*nbOfTuples+i]=0.;
4027 for(int j=i+1;j<nbOfTuples;j++)
4030 for(int k=0;k<nbOfComp;k++)
4031 { double delta=inData[i*nbOfComp+k]-inData[j*nbOfComp+k]; dist+=delta*delta; }
4033 outData[i*nbOfTuples+j]=dist;
4034 outData[j*nbOfTuples+i]=dist;
4041 * This method returns a newly allocated DataArrayDouble instance having one component and \c this->getNumberOfTuples() * \c other->getNumberOfTuples() tuples.
4042 * \n This returned array contains the euclidian distance for each tuple in \a other with each tuple in \a this.
4043 * \n So the returned array can be seen as a dense rectangular matrix with \c other->getNumberOfTuples() rows and \c this->getNumberOfTuples() columns.
4044 * \n Output rectangular matrix is sorted along rows.
4045 * \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)
4047 * \warning use this method with care because it can leads to big amount of consumed memory !
4049 * \param [in] other DataArrayDouble instance having same number of components than \a this.
4050 * \return A newly allocated (huge) ParaMEDMEM::DataArrayDouble instance that the caller should deal with.
4052 * \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.
4054 * \sa DataArrayDouble::buildEuclidianDistanceDenseMatrix
4056 DataArrayDouble *DataArrayDouble::buildEuclidianDistanceDenseMatrixWith(const DataArrayDouble *other) const
4059 throw INTERP_KERNEL::Exception("DataArrayDouble::buildEuclidianDistanceDenseMatrixWith : input parameter is null !");
4061 other->checkAllocated();
4062 int nbOfComp=getNumberOfComponents();
4063 int otherNbOfComp=other->getNumberOfComponents();
4064 if(nbOfComp!=otherNbOfComp)
4066 std::ostringstream oss; oss << "DataArrayDouble::buildEuclidianDistanceDenseMatrixWith : this nb of compo=" << nbOfComp << " and other nb of compo=" << otherNbOfComp << ". It should match !";
4067 throw INTERP_KERNEL::Exception(oss.str().c_str());
4069 int nbOfTuples=getNumberOfTuples();
4070 int otherNbOfTuples=other->getNumberOfTuples();
4071 const double *inData=getConstPointer();
4072 const double *inDataOther=other->getConstPointer();
4073 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
4074 ret->alloc(otherNbOfTuples*nbOfTuples,1);
4075 double *outData=ret->getPointer();
4076 for(int i=0;i<otherNbOfTuples;i++,inDataOther+=nbOfComp)
4078 for(int j=0;j<nbOfTuples;j++)
4081 for(int k=0;k<nbOfComp;k++)
4082 { double delta=inDataOther[k]-inData[j*nbOfComp+k]; dist+=delta*delta; }
4084 outData[i*nbOfTuples+j]=dist;
4091 * Sorts value within every tuple of \a this array.
4092 * \param [in] asc - if \a true, the values are sorted in ascending order, else,
4093 * in descending order.
4094 * \throw If \a this is not allocated.
4096 void DataArrayDouble::sortPerTuple(bool asc)
4099 double *pt=getPointer();
4100 int nbOfTuple=getNumberOfTuples();
4101 int nbOfComp=getNumberOfComponents();
4103 for(int i=0;i<nbOfTuple;i++,pt+=nbOfComp)
4104 std::sort(pt,pt+nbOfComp);
4106 for(int i=0;i<nbOfTuple;i++,pt+=nbOfComp)
4107 std::sort(pt,pt+nbOfComp,std::greater<double>());
4112 * Converts every value of \a this array to its absolute value.
4113 * \b WARNING this method is non const. If a new DataArrayDouble instance should be built containing the result of abs DataArrayDouble::computeAbs
4114 * should be called instead.
4116 * \throw If \a this is not allocated.
4117 * \sa DataArrayDouble::computeAbs
4119 void DataArrayDouble::abs()
4122 double *ptr(getPointer());
4123 std::size_t nbOfElems(getNbOfElems());
4124 std::transform(ptr,ptr+nbOfElems,ptr,std::ptr_fun<double,double>(fabs));
4129 * This method builds a new instance of \a this object containing the result of std::abs applied of all elements in \a this.
4130 * This method is a const method (that do not change any values in \a this) contrary to DataArrayDouble::abs method.
4132 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4133 * same number of tuples and component as \a this array.
4134 * The caller is to delete this result array using decrRef() as it is no more
4136 * \throw If \a this is not allocated.
4137 * \sa DataArrayDouble::abs
4139 DataArrayDouble *DataArrayDouble::computeAbs() const
4142 DataArrayDouble *newArr(DataArrayDouble::New());
4143 int nbOfTuples(getNumberOfTuples());
4144 int nbOfComp(getNumberOfComponents());
4145 newArr->alloc(nbOfTuples,nbOfComp);
4146 std::transform(begin(),end(),newArr->getPointer(),std::ptr_fun<double,double>(fabs));
4147 newArr->copyStringInfoFrom(*this);
4152 * Apply a linear function to a given component of \a this array, so that
4153 * an array element <em>(x)</em> becomes \f$ a * x + b \f$.
4154 * \param [in] a - the first coefficient of the function.
4155 * \param [in] b - the second coefficient of the function.
4156 * \param [in] compoId - the index of component to modify.
4157 * \throw If \a this is not allocated, or \a compoId is not in [0,\c this->getNumberOfComponents() ).
4159 void DataArrayDouble::applyLin(double a, double b, int compoId)
4162 double *ptr(getPointer()+compoId);
4163 int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
4164 if(compoId<0 || compoId>=nbOfComp)
4166 std::ostringstream oss; oss << "DataArrayDouble::applyLin : The compoId requested (" << compoId << ") is not valid ! Must be in [0," << nbOfComp << ") !";
4167 throw INTERP_KERNEL::Exception(oss.str().c_str());
4169 for(int i=0;i<nbOfTuple;i++,ptr+=nbOfComp)
4175 * Apply a linear function to all elements of \a this array, so that
4176 * an element _x_ becomes \f$ a * x + b \f$.
4177 * \param [in] a - the first coefficient of the function.
4178 * \param [in] b - the second coefficient of the function.
4179 * \throw If \a this is not allocated.
4181 void DataArrayDouble::applyLin(double a, double b)
4184 double *ptr=getPointer();
4185 std::size_t nbOfElems=getNbOfElems();
4186 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4192 * Modify all elements of \a this array, so that
4193 * an element _x_ becomes \f$ numerator / x \f$.
4194 * \warning If an exception is thrown because of presence of 0.0 element in \a this
4195 * array, all elements processed before detection of the zero element remain
4197 * \param [in] numerator - the numerator used to modify array elements.
4198 * \throw If \a this is not allocated.
4199 * \throw If there is an element equal to 0.0 in \a this array.
4201 void DataArrayDouble::applyInv(double numerator)
4204 double *ptr=getPointer();
4205 std::size_t nbOfElems=getNbOfElems();
4206 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4208 if(std::abs(*ptr)>std::numeric_limits<double>::min())
4210 *ptr=numerator/(*ptr);
4214 std::ostringstream oss; oss << "DataArrayDouble::applyInv : presence of null value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
4216 throw INTERP_KERNEL::Exception(oss.str().c_str());
4223 * Returns a full copy of \a this array except that sign of all elements is reversed.
4224 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4225 * same number of tuples and component as \a this array.
4226 * The caller is to delete this result array using decrRef() as it is no more
4228 * \throw If \a this is not allocated.
4230 DataArrayDouble *DataArrayDouble::negate() const
4233 DataArrayDouble *newArr=DataArrayDouble::New();
4234 int nbOfTuples=getNumberOfTuples();
4235 int nbOfComp=getNumberOfComponents();
4236 newArr->alloc(nbOfTuples,nbOfComp);
4237 const double *cptr=getConstPointer();
4238 std::transform(cptr,cptr+nbOfTuples*nbOfComp,newArr->getPointer(),std::negate<double>());
4239 newArr->copyStringInfoFrom(*this);
4244 * Modify all elements of \a this array, so that
4245 * an element _x_ becomes <em> val ^ x </em>. Contrary to DataArrayInt::applyPow
4246 * all values in \a this have to be >= 0 if val is \b not integer.
4247 * \param [in] val - the value used to apply pow on all array elements.
4248 * \throw If \a this is not allocated.
4249 * \warning If an exception is thrown because of presence of 0 element in \a this
4250 * array and \a val is \b not integer, all elements processed before detection of the zero element remain
4253 void DataArrayDouble::applyPow(double val)
4256 double *ptr=getPointer();
4257 std::size_t nbOfElems=getNbOfElems();
4259 bool isInt=((double)val2)==val;
4262 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4268 std::ostringstream oss; oss << "DataArrayDouble::applyPow (double) : At elem # " << i << " value is " << *ptr << " ! must be >=0. !";
4269 throw INTERP_KERNEL::Exception(oss.str().c_str());
4275 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4276 *ptr=pow(*ptr,val2);
4282 * Modify all elements of \a this array, so that
4283 * an element _x_ becomes \f$ val ^ x \f$.
4284 * \param [in] val - the value used to apply pow on all array elements.
4285 * \throw If \a this is not allocated.
4286 * \throw If \a val < 0.
4287 * \warning If an exception is thrown because of presence of 0 element in \a this
4288 * array, all elements processed before detection of the zero element remain
4291 void DataArrayDouble::applyRPow(double val)
4295 throw INTERP_KERNEL::Exception("DataArrayDouble::applyRPow : the input value has to be >= 0 !");
4296 double *ptr=getPointer();
4297 std::size_t nbOfElems=getNbOfElems();
4298 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4304 * Returns a new DataArrayDouble created from \a this one by applying \a
4305 * FunctionToEvaluate to every tuple of \a this array. Textual data is not copied.
4306 * For more info see \ref MEDCouplingArrayApplyFunc
4307 * \param [in] nbOfComp - number of components in the result array.
4308 * \param [in] func - the \a FunctionToEvaluate declared as
4309 * \c bool (*\a func)(\c const \c double *\a pos, \c double *\a res),
4310 * where \a pos points to the first component of a tuple of \a this array
4311 * and \a res points to the first component of a tuple of the result array.
4312 * Note that length (number of components) of \a pos can differ from
4314 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4315 * same number of tuples as \a this array.
4316 * The caller is to delete this result array using decrRef() as it is no more
4318 * \throw If \a this is not allocated.
4319 * \throw If \a func returns \a false.
4321 DataArrayDouble *DataArrayDouble::applyFunc(int nbOfComp, FunctionToEvaluate func) const
4324 DataArrayDouble *newArr=DataArrayDouble::New();
4325 int nbOfTuples=getNumberOfTuples();
4326 int oldNbOfComp=getNumberOfComponents();
4327 newArr->alloc(nbOfTuples,nbOfComp);
4328 const double *ptr=getConstPointer();
4329 double *ptrToFill=newArr->getPointer();
4330 for(int i=0;i<nbOfTuples;i++)
4332 if(!func(ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp))
4334 std::ostringstream oss; oss << "For tuple # " << i << " with value (";
4335 std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
4336 oss << ") : Evaluation of function failed !";
4338 throw INTERP_KERNEL::Exception(oss.str().c_str());
4345 * Returns a new DataArrayDouble created from \a this one by applying a function to every
4346 * tuple of \a this array. Textual data is not copied.
4347 * For more info see \ref MEDCouplingArrayApplyFunc1.
4348 * \param [in] nbOfComp - number of components in the result array.
4349 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4350 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4351 * \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
4352 * If false the computation is carried on without any notification. When false the evaluation is a little faster.
4353 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4354 * same number of tuples as \a this array and \a nbOfComp components.
4355 * The caller is to delete this result array using decrRef() as it is no more
4357 * \throw If \a this is not allocated.
4358 * \throw If computing \a func fails.
4360 DataArrayDouble *DataArrayDouble::applyFunc(int nbOfComp, const std::string& func, bool isSafe) const
4362 INTERP_KERNEL::ExprParser expr(func);
4364 std::set<std::string> vars;
4365 expr.getTrueSetOfVars(vars);
4366 std::vector<std::string> varsV(vars.begin(),vars.end());
4367 return applyFunc3(nbOfComp,varsV,func,isSafe);
4371 * Returns a new DataArrayDouble created from \a this one by applying a function to every
4372 * tuple of \a this array. Textual data is not copied. This method works by tuples (whatever its size).
4373 * If \a this is a one component array, call applyFuncOnThis instead that performs the same work faster.
4375 * For more info see \ref MEDCouplingArrayApplyFunc0.
4376 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4377 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4378 * \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
4379 * If false the computation is carried on without any notification. When false the evaluation is a little faster.
4380 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4381 * same number of tuples and components as \a this array.
4382 * The caller is to delete this result array using decrRef() as it is no more
4384 * \sa applyFuncOnThis
4385 * \throw If \a this is not allocated.
4386 * \throw If computing \a func fails.
4388 DataArrayDouble *DataArrayDouble::applyFunc(const std::string& func, bool isSafe) const
4390 int nbOfComp(getNumberOfComponents());
4392 throw INTERP_KERNEL::Exception("DataArrayDouble::applyFunc : output number of component must be > 0 !");
4394 int nbOfTuples(getNumberOfTuples());
4395 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> newArr(DataArrayDouble::New());
4396 newArr->alloc(nbOfTuples,nbOfComp);
4397 INTERP_KERNEL::ExprParser expr(func);
4399 std::set<std::string> vars;
4400 expr.getTrueSetOfVars(vars);
4401 if((int)vars.size()>1)
4403 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 : ";
4404 std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
4405 throw INTERP_KERNEL::Exception(oss.str().c_str());
4409 expr.prepareFastEvaluator();
4410 newArr->rearrange(1);
4411 newArr->fillWithValue(expr.evaluateDouble());
4412 newArr->rearrange(nbOfComp);
4413 return newArr.retn();
4415 std::vector<std::string> vars2(vars.begin(),vars.end());
4416 double buff,*ptrToFill(newArr->getPointer());
4417 const double *ptr(begin());
4418 std::vector<double> stck;
4419 expr.prepareExprEvaluationDouble(vars2,1,1,0,&buff,&buff+1);
4420 expr.prepareFastEvaluator();
4423 for(int i=0;i<nbOfTuples;i++)
4425 for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
4428 expr.evaluateDoubleInternal(stck);
4429 *ptrToFill=stck.back();
4436 for(int i=0;i<nbOfTuples;i++)
4438 for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
4443 expr.evaluateDoubleInternalSafe(stck);
4445 catch(INTERP_KERNEL::Exception& e)
4447 std::ostringstream oss; oss << "For tuple # " << i << " component # " << iComp << " with value (";
4449 oss << ") : Evaluation of function failed !" << e.what();
4450 throw INTERP_KERNEL::Exception(oss.str().c_str());
4452 *ptrToFill=stck.back();
4457 return newArr.retn();
4461 * This method is a non const method that modify the array in \a this.
4462 * This method only works on one component array. It means that function \a func must
4463 * contain at most one variable.
4464 * This method is a specialization of applyFunc method with one parameter on one component array.
4466 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4467 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4468 * \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
4469 * If false the computation is carried on without any notification. When false the evaluation is a little faster.
4473 void DataArrayDouble::applyFuncOnThis(const std::string& func, bool isSafe)
4475 int nbOfComp(getNumberOfComponents());
4477 throw INTERP_KERNEL::Exception("DataArrayDouble::applyFuncOnThis : output number of component must be > 0 !");
4479 int nbOfTuples(getNumberOfTuples());
4480 INTERP_KERNEL::ExprParser expr(func);
4482 std::set<std::string> vars;
4483 expr.getTrueSetOfVars(vars);
4484 if((int)vars.size()>1)
4486 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 : ";
4487 std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
4488 throw INTERP_KERNEL::Exception(oss.str().c_str());
4492 expr.prepareFastEvaluator();
4493 std::vector<std::string> compInfo(getInfoOnComponents());
4495 fillWithValue(expr.evaluateDouble());
4496 rearrange(nbOfComp);
4497 setInfoOnComponents(compInfo);
4500 std::vector<std::string> vars2(vars.begin(),vars.end());
4501 double buff,*ptrToFill(getPointer());
4502 const double *ptr(begin());
4503 std::vector<double> stck;
4504 expr.prepareExprEvaluationDouble(vars2,1,1,0,&buff,&buff+1);
4505 expr.prepareFastEvaluator();
4508 for(int i=0;i<nbOfTuples;i++)
4510 for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
4513 expr.evaluateDoubleInternal(stck);
4514 *ptrToFill=stck.back();
4521 for(int i=0;i<nbOfTuples;i++)
4523 for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
4528 expr.evaluateDoubleInternalSafe(stck);
4530 catch(INTERP_KERNEL::Exception& e)
4532 std::ostringstream oss; oss << "For tuple # " << i << " component # " << iComp << " with value (";
4534 oss << ") : Evaluation of function failed !" << e.what();
4535 throw INTERP_KERNEL::Exception(oss.str().c_str());
4537 *ptrToFill=stck.back();
4545 * Returns a new DataArrayDouble created from \a this one by applying a function to every
4546 * tuple of \a this array. Textual data is not copied.
4547 * For more info see \ref MEDCouplingArrayApplyFunc2.
4548 * \param [in] nbOfComp - number of components in the result array.
4549 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4550 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4551 * \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
4552 * If false the computation is carried on without any notification. When false the evaluation is a little faster.
4553 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4554 * same number of tuples as \a this array.
4555 * The caller is to delete this result array using decrRef() as it is no more
4557 * \throw If \a this is not allocated.
4558 * \throw If \a func contains vars that are not in \a this->getInfoOnComponent().
4559 * \throw If computing \a func fails.
4561 DataArrayDouble *DataArrayDouble::applyFunc2(int nbOfComp, const std::string& func, bool isSafe) const
4563 return applyFunc3(nbOfComp,getVarsOnComponent(),func,isSafe);
4567 * Returns a new DataArrayDouble created from \a this one by applying a function to every
4568 * tuple of \a this array. Textual data is not copied.
4569 * For more info see \ref MEDCouplingArrayApplyFunc3.
4570 * \param [in] nbOfComp - number of components in the result array.
4571 * \param [in] varsOrder - sequence of vars defining their order.
4572 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4573 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4574 * \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
4575 * If false the computation is carried on without any notification. When false the evaluation is a little faster.
4576 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4577 * same number of tuples as \a this array.
4578 * The caller is to delete this result array using decrRef() as it is no more
4580 * \throw If \a this is not allocated.
4581 * \throw If \a func contains vars not in \a varsOrder.
4582 * \throw If computing \a func fails.
4584 DataArrayDouble *DataArrayDouble::applyFunc3(int nbOfComp, const std::vector<std::string>& varsOrder, const std::string& func, bool isSafe) const
4587 throw INTERP_KERNEL::Exception("DataArrayDouble::applyFunc3 : output number of component must be > 0 !");
4588 std::vector<std::string> varsOrder2(varsOrder);
4589 int oldNbOfComp(getNumberOfComponents());
4590 for(int i=(int)varsOrder.size();i<oldNbOfComp;i++)
4591 varsOrder2.push_back(std::string());
4593 int nbOfTuples(getNumberOfTuples());
4594 INTERP_KERNEL::ExprParser expr(func);
4596 std::set<std::string> vars;
4597 expr.getTrueSetOfVars(vars);
4598 if((int)vars.size()>oldNbOfComp)
4600 std::ostringstream oss; oss << "The field has " << oldNbOfComp << " components and there are ";
4601 oss << vars.size() << " variables : ";
4602 std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
4603 throw INTERP_KERNEL::Exception(oss.str().c_str());
4605 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> newArr(DataArrayDouble::New());
4606 newArr->alloc(nbOfTuples,nbOfComp);
4607 INTERP_KERNEL::AutoPtr<double> buff(new double[oldNbOfComp]);
4608 double *buffPtr(buff),*ptrToFill;
4609 std::vector<double> stck;
4610 for(int iComp=0;iComp<nbOfComp;iComp++)
4612 expr.prepareExprEvaluationDouble(varsOrder2,oldNbOfComp,nbOfComp,iComp,buffPtr,buffPtr+oldNbOfComp);
4613 expr.prepareFastEvaluator();
4614 const double *ptr(getConstPointer());
4615 ptrToFill=newArr->getPointer()+iComp;
4618 for(int i=0;i<nbOfTuples;i++,ptrToFill+=nbOfComp,ptr+=oldNbOfComp)
4620 std::copy(ptr,ptr+oldNbOfComp,buffPtr);
4621 expr.evaluateDoubleInternal(stck);
4622 *ptrToFill=stck.back();
4628 for(int i=0;i<nbOfTuples;i++,ptrToFill+=nbOfComp,ptr+=oldNbOfComp)
4630 std::copy(ptr,ptr+oldNbOfComp,buffPtr);
4633 expr.evaluateDoubleInternalSafe(stck);
4634 *ptrToFill=stck.back();
4637 catch(INTERP_KERNEL::Exception& e)
4639 std::ostringstream oss; oss << "For tuple # " << i << " with value (";
4640 std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
4641 oss << ") : Evaluation of function failed !" << e.what();
4642 throw INTERP_KERNEL::Exception(oss.str().c_str());
4647 return newArr.retn();
4650 void DataArrayDouble::applyFuncFast32(const std::string& func)
4653 INTERP_KERNEL::ExprParser expr(func);
4655 char *funcStr=expr.compileX86();
4657 *((void **)&funcPtr)=funcStr;//he he...
4659 double *ptr=getPointer();
4660 int nbOfComp=getNumberOfComponents();
4661 int nbOfTuples=getNumberOfTuples();
4662 int nbOfElems=nbOfTuples*nbOfComp;
4663 for(int i=0;i<nbOfElems;i++,ptr++)
4668 void DataArrayDouble::applyFuncFast64(const std::string& func)
4671 INTERP_KERNEL::ExprParser expr(func);
4673 char *funcStr=expr.compileX86_64();
4675 *((void **)&funcPtr)=funcStr;//he he...
4677 double *ptr=getPointer();
4678 int nbOfComp=getNumberOfComponents();
4679 int nbOfTuples=getNumberOfTuples();
4680 int nbOfElems=nbOfTuples*nbOfComp;
4681 for(int i=0;i<nbOfElems;i++,ptr++)
4686 DataArrayDoubleIterator *DataArrayDouble::iterator()
4688 return new DataArrayDoubleIterator(this);
4692 * Returns a new DataArrayInt contating indices of tuples of \a this one-dimensional
4693 * array whose values are within a given range. Textual data is not copied.
4694 * \param [in] vmin - a lowest acceptable value (included).
4695 * \param [in] vmax - a greatest acceptable value (included).
4696 * \return DataArrayInt * - the new instance of DataArrayInt.
4697 * The caller is to delete this result array using decrRef() as it is no more
4699 * \throw If \a this->getNumberOfComponents() != 1.
4701 * \sa DataArrayDouble::getIdsNotInRange
4703 * \if ENABLE_EXAMPLES
4704 * \ref cpp_mcdataarraydouble_getidsinrange "Here is a C++ example".<br>
4705 * \ref py_mcdataarraydouble_getidsinrange "Here is a Python example".
4708 DataArrayInt *DataArrayDouble::getIdsInRange(double vmin, double vmax) const
4711 if(getNumberOfComponents()!=1)
4712 throw INTERP_KERNEL::Exception("DataArrayDouble::getIdsInRange : this must have exactly one component !");
4713 const double *cptr(begin());
4714 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
4715 int nbOfTuples(getNumberOfTuples());
4716 for(int i=0;i<nbOfTuples;i++,cptr++)
4717 if(*cptr>=vmin && *cptr<=vmax)
4718 ret->pushBackSilent(i);
4723 * Returns a new DataArrayInt contating indices of tuples of \a this one-dimensional
4724 * array whose values are not within a given range. Textual data is not copied.
4725 * \param [in] vmin - a lowest not acceptable value (excluded).
4726 * \param [in] vmax - a greatest not acceptable value (excluded).
4727 * \return DataArrayInt * - the new instance of DataArrayInt.
4728 * The caller is to delete this result array using decrRef() as it is no more
4730 * \throw If \a this->getNumberOfComponents() != 1.
4732 * \sa DataArrayDouble::getIdsInRange
4734 DataArrayInt *DataArrayDouble::getIdsNotInRange(double vmin, double vmax) const
4737 if(getNumberOfComponents()!=1)
4738 throw INTERP_KERNEL::Exception("DataArrayDouble::getIdsNotInRange : this must have exactly one component !");
4739 const double *cptr(begin());
4740 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
4741 int nbOfTuples(getNumberOfTuples());
4742 for(int i=0;i<nbOfTuples;i++,cptr++)
4743 if(*cptr<vmin || *cptr>vmax)
4744 ret->pushBackSilent(i);
4749 * Returns a new DataArrayDouble by concatenating two given arrays, so that (1) the number
4750 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
4751 * the number of component in the result array is same as that of each of given arrays.
4752 * Info on components is copied from the first of the given arrays. Number of components
4753 * in the given arrays must be the same.
4754 * \param [in] a1 - an array to include in the result array.
4755 * \param [in] a2 - another array to include in the result array.
4756 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4757 * The caller is to delete this result array using decrRef() as it is no more
4759 * \throw If both \a a1 and \a a2 are NULL.
4760 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents().
4762 DataArrayDouble *DataArrayDouble::Aggregate(const DataArrayDouble *a1, const DataArrayDouble *a2)
4764 std::vector<const DataArrayDouble *> tmp(2);
4765 tmp[0]=a1; tmp[1]=a2;
4766 return Aggregate(tmp);
4770 * Returns a new DataArrayDouble by concatenating all given arrays, so that (1) the number
4771 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
4772 * the number of component in the result array is same as that of each of given arrays.
4773 * Info on components is copied from the first of the given arrays. Number of components
4774 * in the given arrays must be the same.
4775 * If the number of non null of elements in \a arr is equal to one the returned object is a copy of it
4776 * not the object itself.
4777 * \param [in] arr - a sequence of arrays to include in the result array.
4778 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4779 * The caller is to delete this result array using decrRef() as it is no more
4781 * \throw If all arrays within \a arr are NULL.
4782 * \throw If getNumberOfComponents() of arrays within \a arr.
4784 DataArrayDouble *DataArrayDouble::Aggregate(const std::vector<const DataArrayDouble *>& arr)
4786 std::vector<const DataArrayDouble *> a;
4787 for(std::vector<const DataArrayDouble *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
4791 throw INTERP_KERNEL::Exception("DataArrayDouble::Aggregate : input list must contain at least one NON EMPTY DataArrayDouble !");
4792 std::vector<const DataArrayDouble *>::const_iterator it=a.begin();
4793 int nbOfComp=(*it)->getNumberOfComponents();
4794 int nbt=(*it++)->getNumberOfTuples();
4795 for(int i=1;it!=a.end();it++,i++)
4797 if((*it)->getNumberOfComponents()!=nbOfComp)
4798 throw INTERP_KERNEL::Exception("DataArrayDouble::Aggregate : Nb of components mismatch for array aggregation !");
4799 nbt+=(*it)->getNumberOfTuples();
4801 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
4802 ret->alloc(nbt,nbOfComp);
4803 double *pt=ret->getPointer();
4804 for(it=a.begin();it!=a.end();it++)
4805 pt=std::copy((*it)->getConstPointer(),(*it)->getConstPointer()+(*it)->getNbOfElems(),pt);
4806 ret->copyStringInfoFrom(*(a[0]));
4811 * Returns a new DataArrayDouble by aggregating two given arrays, so that (1) the number
4812 * of components in the result array is a sum of the number of components of given arrays
4813 * and (2) the number of tuples in the result array is same as that of each of given
4814 * arrays. In other words the i-th tuple of result array includes all components of
4815 * i-th tuples of all given arrays.
4816 * Number of tuples in the given arrays must be the same.
4817 * \param [in] a1 - an array to include in the result array.
4818 * \param [in] a2 - another array to include in the result array.
4819 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4820 * The caller is to delete this result array using decrRef() as it is no more
4822 * \throw If both \a a1 and \a a2 are NULL.
4823 * \throw If any given array is not allocated.
4824 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4826 DataArrayDouble *DataArrayDouble::Meld(const DataArrayDouble *a1, const DataArrayDouble *a2)
4828 std::vector<const DataArrayDouble *> arr(2);
4829 arr[0]=a1; arr[1]=a2;
4834 * Returns a new DataArrayDouble by aggregating all given arrays, so that (1) the number
4835 * of components in the result array is a sum of the number of components of given arrays
4836 * and (2) the number of tuples in the result array is same as that of each of given
4837 * arrays. In other words the i-th tuple of result array includes all components of
4838 * i-th tuples of all given arrays.
4839 * Number of tuples in the given arrays must be the same.
4840 * \param [in] arr - a sequence of arrays to include in the result array.
4841 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4842 * The caller is to delete this result array using decrRef() as it is no more
4844 * \throw If all arrays within \a arr are NULL.
4845 * \throw If any given array is not allocated.
4846 * \throw If getNumberOfTuples() of arrays within \a arr is different.
4848 DataArrayDouble *DataArrayDouble::Meld(const std::vector<const DataArrayDouble *>& arr)
4850 std::vector<const DataArrayDouble *> a;
4851 for(std::vector<const DataArrayDouble *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
4855 throw INTERP_KERNEL::Exception("DataArrayDouble::Meld : input list must contain at least one NON EMPTY DataArrayDouble !");
4856 std::vector<const DataArrayDouble *>::const_iterator it;
4857 for(it=a.begin();it!=a.end();it++)
4858 (*it)->checkAllocated();
4860 int nbOfTuples=(*it)->getNumberOfTuples();
4861 std::vector<int> nbc(a.size());
4862 std::vector<const double *> pts(a.size());
4863 nbc[0]=(*it)->getNumberOfComponents();
4864 pts[0]=(*it++)->getConstPointer();
4865 for(int i=1;it!=a.end();it++,i++)
4867 if(nbOfTuples!=(*it)->getNumberOfTuples())
4868 throw INTERP_KERNEL::Exception("DataArrayDouble::Meld : mismatch of number of tuples !");
4869 nbc[i]=(*it)->getNumberOfComponents();
4870 pts[i]=(*it)->getConstPointer();
4872 int totalNbOfComp=std::accumulate(nbc.begin(),nbc.end(),0);
4873 DataArrayDouble *ret=DataArrayDouble::New();
4874 ret->alloc(nbOfTuples,totalNbOfComp);
4875 double *retPtr=ret->getPointer();
4876 for(int i=0;i<nbOfTuples;i++)
4877 for(int j=0;j<(int)a.size();j++)
4879 retPtr=std::copy(pts[j],pts[j]+nbc[j],retPtr);
4883 for(int i=0;i<(int)a.size();i++)
4884 for(int j=0;j<nbc[i];j++,k++)
4885 ret->setInfoOnComponent(k,a[i]->getInfoOnComponent(j));
4890 * Returns a new DataArrayDouble containing a dot product of two given arrays, so that
4891 * the i-th tuple of the result array is a sum of products of j-th components of i-th
4892 * tuples of given arrays (\f$ a_i = \sum_{j=1}^n a1_j * a2_j \f$).
4893 * Info on components and name is copied from the first of the given arrays.
4894 * Number of tuples and components in the given arrays must be the same.
4895 * \param [in] a1 - a given array.
4896 * \param [in] a2 - another given array.
4897 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4898 * The caller is to delete this result array using decrRef() as it is no more
4900 * \throw If either \a a1 or \a a2 is NULL.
4901 * \throw If any given array is not allocated.
4902 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4903 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
4905 DataArrayDouble *DataArrayDouble::Dot(const DataArrayDouble *a1, const DataArrayDouble *a2)
4908 throw INTERP_KERNEL::Exception("DataArrayDouble::Dot : input DataArrayDouble instance is NULL !");
4909 a1->checkAllocated();
4910 a2->checkAllocated();
4911 int nbOfComp=a1->getNumberOfComponents();
4912 if(nbOfComp!=a2->getNumberOfComponents())
4913 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Dot !");
4914 int nbOfTuple=a1->getNumberOfTuples();
4915 if(nbOfTuple!=a2->getNumberOfTuples())
4916 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Dot !");
4917 DataArrayDouble *ret=DataArrayDouble::New();
4918 ret->alloc(nbOfTuple,1);
4919 double *retPtr=ret->getPointer();
4920 const double *a1Ptr=a1->getConstPointer();
4921 const double *a2Ptr=a2->getConstPointer();
4922 for(int i=0;i<nbOfTuple;i++)
4925 for(int j=0;j<nbOfComp;j++)
4926 sum+=a1Ptr[i*nbOfComp+j]*a2Ptr[i*nbOfComp+j];
4929 ret->setInfoOnComponent(0,a1->getInfoOnComponent(0));
4930 ret->setName(a1->getName());
4935 * Returns a new DataArrayDouble containing a cross product of two given arrays, so that
4936 * the i-th tuple of the result array contains 3 components of a vector which is a cross
4937 * product of two vectors defined by the i-th tuples of given arrays.
4938 * Info on components is copied from the first of the given arrays.
4939 * Number of tuples in the given arrays must be the same.
4940 * Number of components in the given arrays must be 3.
4941 * \param [in] a1 - a given array.
4942 * \param [in] a2 - another given array.
4943 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4944 * The caller is to delete this result array using decrRef() as it is no more
4946 * \throw If either \a a1 or \a a2 is NULL.
4947 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4948 * \throw If \a a1->getNumberOfComponents() != 3
4949 * \throw If \a a2->getNumberOfComponents() != 3
4951 DataArrayDouble *DataArrayDouble::CrossProduct(const DataArrayDouble *a1, const DataArrayDouble *a2)
4954 throw INTERP_KERNEL::Exception("DataArrayDouble::CrossProduct : input DataArrayDouble instance is NULL !");
4955 int nbOfComp=a1->getNumberOfComponents();
4956 if(nbOfComp!=a2->getNumberOfComponents())
4957 throw INTERP_KERNEL::Exception("Nb of components mismatch for array crossProduct !");
4959 throw INTERP_KERNEL::Exception("Nb of components must be equal to 3 for array crossProduct !");
4960 int nbOfTuple=a1->getNumberOfTuples();
4961 if(nbOfTuple!=a2->getNumberOfTuples())
4962 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array crossProduct !");
4963 DataArrayDouble *ret=DataArrayDouble::New();
4964 ret->alloc(nbOfTuple,3);
4965 double *retPtr=ret->getPointer();
4966 const double *a1Ptr=a1->getConstPointer();
4967 const double *a2Ptr=a2->getConstPointer();
4968 for(int i=0;i<nbOfTuple;i++)
4970 retPtr[3*i]=a1Ptr[3*i+1]*a2Ptr[3*i+2]-a1Ptr[3*i+2]*a2Ptr[3*i+1];
4971 retPtr[3*i+1]=a1Ptr[3*i+2]*a2Ptr[3*i]-a1Ptr[3*i]*a2Ptr[3*i+2];
4972 retPtr[3*i+2]=a1Ptr[3*i]*a2Ptr[3*i+1]-a1Ptr[3*i+1]*a2Ptr[3*i];
4974 ret->copyStringInfoFrom(*a1);
4979 * Returns a new DataArrayDouble containing maximal values of two given arrays.
4980 * Info on components is copied from the first of the given arrays.
4981 * Number of tuples and components in the given arrays must be the same.
4982 * \param [in] a1 - an array to compare values with another one.
4983 * \param [in] a2 - another array to compare values with the first one.
4984 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4985 * The caller is to delete this result array using decrRef() as it is no more
4987 * \throw If either \a a1 or \a a2 is NULL.
4988 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4989 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
4991 DataArrayDouble *DataArrayDouble::Max(const DataArrayDouble *a1, const DataArrayDouble *a2)
4994 throw INTERP_KERNEL::Exception("DataArrayDouble::Max : input DataArrayDouble instance is NULL !");
4995 int nbOfComp=a1->getNumberOfComponents();
4996 if(nbOfComp!=a2->getNumberOfComponents())
4997 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Max !");
4998 int nbOfTuple=a1->getNumberOfTuples();
4999 if(nbOfTuple!=a2->getNumberOfTuples())
5000 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Max !");
5001 DataArrayDouble *ret=DataArrayDouble::New();
5002 ret->alloc(nbOfTuple,nbOfComp);
5003 double *retPtr=ret->getPointer();
5004 const double *a1Ptr=a1->getConstPointer();
5005 const double *a2Ptr=a2->getConstPointer();
5006 int nbElem=nbOfTuple*nbOfComp;
5007 for(int i=0;i<nbElem;i++)
5008 retPtr[i]=std::max(a1Ptr[i],a2Ptr[i]);
5009 ret->copyStringInfoFrom(*a1);
5014 * Returns a new DataArrayDouble containing minimal values of two given arrays.
5015 * Info on components is copied from the first of the given arrays.
5016 * Number of tuples and components in the given arrays must be the same.
5017 * \param [in] a1 - an array to compare values with another one.
5018 * \param [in] a2 - another array to compare values with the first one.
5019 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5020 * The caller is to delete this result array using decrRef() as it is no more
5022 * \throw If either \a a1 or \a a2 is NULL.
5023 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
5024 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
5026 DataArrayDouble *DataArrayDouble::Min(const DataArrayDouble *a1, const DataArrayDouble *a2)
5029 throw INTERP_KERNEL::Exception("DataArrayDouble::Min : input DataArrayDouble instance is NULL !");
5030 int nbOfComp=a1->getNumberOfComponents();
5031 if(nbOfComp!=a2->getNumberOfComponents())
5032 throw INTERP_KERNEL::Exception("Nb of components mismatch for array min !");
5033 int nbOfTuple=a1->getNumberOfTuples();
5034 if(nbOfTuple!=a2->getNumberOfTuples())
5035 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array min !");
5036 DataArrayDouble *ret=DataArrayDouble::New();
5037 ret->alloc(nbOfTuple,nbOfComp);
5038 double *retPtr=ret->getPointer();
5039 const double *a1Ptr=a1->getConstPointer();
5040 const double *a2Ptr=a2->getConstPointer();
5041 int nbElem=nbOfTuple*nbOfComp;
5042 for(int i=0;i<nbElem;i++)
5043 retPtr[i]=std::min(a1Ptr[i],a2Ptr[i]);
5044 ret->copyStringInfoFrom(*a1);
5049 * Returns a new DataArrayDouble that is a sum of two given arrays. There are 3
5051 * 1. The arrays have same number of tuples and components. Then each value of
5052 * the result array (_a_) is a sum of the corresponding values of \a a1 and \a a2,
5053 * i.e.: _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, j ].
5054 * 2. The arrays have same number of tuples and one array, say _a2_, has one
5056 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, 0 ].
5057 * 3. The arrays have same number of components and one array, say _a2_, has one
5059 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ 0, j ].
5061 * Info on components is copied either from the first array (in the first case) or from
5062 * the array with maximal number of elements (getNbOfElems()).
5063 * \param [in] a1 - an array to sum up.
5064 * \param [in] a2 - another array to sum up.
5065 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5066 * The caller is to delete this result array using decrRef() as it is no more
5068 * \throw If either \a a1 or \a a2 is NULL.
5069 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
5070 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
5071 * none of them has number of tuples or components equal to 1.
5073 DataArrayDouble *DataArrayDouble::Add(const DataArrayDouble *a1, const DataArrayDouble *a2)
5076 throw INTERP_KERNEL::Exception("DataArrayDouble::Add : input DataArrayDouble instance is NULL !");
5077 int nbOfTuple=a1->getNumberOfTuples();
5078 int nbOfTuple2=a2->getNumberOfTuples();
5079 int nbOfComp=a1->getNumberOfComponents();
5080 int nbOfComp2=a2->getNumberOfComponents();
5081 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=0;
5082 if(nbOfTuple==nbOfTuple2)
5084 if(nbOfComp==nbOfComp2)
5086 ret=DataArrayDouble::New();
5087 ret->alloc(nbOfTuple,nbOfComp);
5088 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::plus<double>());
5089 ret->copyStringInfoFrom(*a1);
5093 int nbOfCompMin,nbOfCompMax;
5094 const DataArrayDouble *aMin, *aMax;
5095 if(nbOfComp>nbOfComp2)
5097 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
5102 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
5107 ret=DataArrayDouble::New();
5108 ret->alloc(nbOfTuple,nbOfCompMax);
5109 const double *aMinPtr=aMin->getConstPointer();
5110 const double *aMaxPtr=aMax->getConstPointer();
5111 double *res=ret->getPointer();
5112 for(int i=0;i<nbOfTuple;i++)
5113 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::plus<double>(),aMinPtr[i]));
5114 ret->copyStringInfoFrom(*aMax);
5117 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
5120 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
5122 if(nbOfComp==nbOfComp2)
5124 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
5125 const DataArrayDouble *aMin=nbOfTuple>nbOfTuple2?a2:a1;
5126 const DataArrayDouble *aMax=nbOfTuple>nbOfTuple2?a1:a2;
5127 const double *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
5128 ret=DataArrayDouble::New();
5129 ret->alloc(nbOfTupleMax,nbOfComp);
5130 double *res=ret->getPointer();
5131 for(int i=0;i<nbOfTupleMax;i++)
5132 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::plus<double>());
5133 ret->copyStringInfoFrom(*aMax);
5136 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
5139 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Add !");
5144 * Adds values of another DataArrayDouble to values of \a this one. There are 3
5146 * 1. The arrays have same number of tuples and components. Then each value of
5147 * \a other array is added to the corresponding value of \a this array, i.e.:
5148 * _a_ [ i, j ] += _other_ [ i, j ].
5149 * 2. The arrays have same number of tuples and \a other array has one component. Then
5150 * _a_ [ i, j ] += _other_ [ i, 0 ].
5151 * 3. The arrays have same number of components and \a other array has one tuple. Then
5152 * _a_ [ i, j ] += _a2_ [ 0, j ].
5154 * \param [in] other - an array to add to \a this one.
5155 * \throw If \a other is NULL.
5156 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
5157 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
5158 * \a other has number of both tuples and components not equal to 1.
5160 void DataArrayDouble::addEqual(const DataArrayDouble *other)
5163 throw INTERP_KERNEL::Exception("DataArrayDouble::addEqual : input DataArrayDouble instance is NULL !");
5164 const char *msg="Nb of tuples mismatch for DataArrayDouble::addEqual !";
5166 other->checkAllocated();
5167 int nbOfTuple=getNumberOfTuples();
5168 int nbOfTuple2=other->getNumberOfTuples();
5169 int nbOfComp=getNumberOfComponents();
5170 int nbOfComp2=other->getNumberOfComponents();
5171 if(nbOfTuple==nbOfTuple2)
5173 if(nbOfComp==nbOfComp2)
5175 std::transform(begin(),end(),other->begin(),getPointer(),std::plus<double>());
5177 else if(nbOfComp2==1)
5179 double *ptr=getPointer();
5180 const double *ptrc=other->getConstPointer();
5181 for(int i=0;i<nbOfTuple;i++)
5182 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::plus<double>(),*ptrc++));
5185 throw INTERP_KERNEL::Exception(msg);
5187 else if(nbOfTuple2==1)
5189 if(nbOfComp2==nbOfComp)
5191 double *ptr=getPointer();
5192 const double *ptrc=other->getConstPointer();
5193 for(int i=0;i<nbOfTuple;i++)
5194 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::plus<double>());
5197 throw INTERP_KERNEL::Exception(msg);
5200 throw INTERP_KERNEL::Exception(msg);
5205 * Returns a new DataArrayDouble that is a subtraction of two given arrays. There are 3
5207 * 1. The arrays have same number of tuples and components. Then each value of
5208 * the result array (_a_) is a subtraction of the corresponding values of \a a1 and
5209 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, j ].
5210 * 2. The arrays have same number of tuples and one array, say _a2_, has one
5212 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, 0 ].
5213 * 3. The arrays have same number of components and one array, say _a2_, has one
5215 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ 0, j ].
5217 * Info on components is copied either from the first array (in the first case) or from
5218 * the array with maximal number of elements (getNbOfElems()).
5219 * \param [in] a1 - an array to subtract from.
5220 * \param [in] a2 - an array to subtract.
5221 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5222 * The caller is to delete this result array using decrRef() as it is no more
5224 * \throw If either \a a1 or \a a2 is NULL.
5225 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
5226 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
5227 * none of them has number of tuples or components equal to 1.
5229 DataArrayDouble *DataArrayDouble::Substract(const DataArrayDouble *a1, const DataArrayDouble *a2)
5232 throw INTERP_KERNEL::Exception("DataArrayDouble::Substract : input DataArrayDouble instance is NULL !");
5233 int nbOfTuple1=a1->getNumberOfTuples();
5234 int nbOfTuple2=a2->getNumberOfTuples();
5235 int nbOfComp1=a1->getNumberOfComponents();
5236 int nbOfComp2=a2->getNumberOfComponents();
5237 if(nbOfTuple2==nbOfTuple1)
5239 if(nbOfComp1==nbOfComp2)
5241 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5242 ret->alloc(nbOfTuple2,nbOfComp1);
5243 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::minus<double>());
5244 ret->copyStringInfoFrom(*a1);
5247 else if(nbOfComp2==1)
5249 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5250 ret->alloc(nbOfTuple1,nbOfComp1);
5251 const double *a2Ptr=a2->getConstPointer();
5252 const double *a1Ptr=a1->getConstPointer();
5253 double *res=ret->getPointer();
5254 for(int i=0;i<nbOfTuple1;i++)
5255 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::minus<double>(),a2Ptr[i]));
5256 ret->copyStringInfoFrom(*a1);
5261 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
5265 else if(nbOfTuple2==1)
5267 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
5268 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5269 ret->alloc(nbOfTuple1,nbOfComp1);
5270 const double *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
5271 double *pt=ret->getPointer();
5272 for(int i=0;i<nbOfTuple1;i++)
5273 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::minus<double>());
5274 ret->copyStringInfoFrom(*a1);
5279 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Substract !");//will always throw an exception
5285 * Subtract values of another DataArrayDouble from values of \a this one. There are 3
5287 * 1. The arrays have same number of tuples and components. Then each value of
5288 * \a other array is subtracted from the corresponding value of \a this array, i.e.:
5289 * _a_ [ i, j ] -= _other_ [ i, j ].
5290 * 2. The arrays have same number of tuples and \a other array has one component. Then
5291 * _a_ [ i, j ] -= _other_ [ i, 0 ].
5292 * 3. The arrays have same number of components and \a other array has one tuple. Then
5293 * _a_ [ i, j ] -= _a2_ [ 0, j ].
5295 * \param [in] other - an array to subtract from \a this one.
5296 * \throw If \a other is NULL.
5297 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
5298 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
5299 * \a other has number of both tuples and components not equal to 1.
5301 void DataArrayDouble::substractEqual(const DataArrayDouble *other)
5304 throw INTERP_KERNEL::Exception("DataArrayDouble::substractEqual : input DataArrayDouble instance is NULL !");
5305 const char *msg="Nb of tuples mismatch for DataArrayDouble::substractEqual !";
5307 other->checkAllocated();
5308 int nbOfTuple=getNumberOfTuples();
5309 int nbOfTuple2=other->getNumberOfTuples();
5310 int nbOfComp=getNumberOfComponents();
5311 int nbOfComp2=other->getNumberOfComponents();
5312 if(nbOfTuple==nbOfTuple2)
5314 if(nbOfComp==nbOfComp2)
5316 std::transform(begin(),end(),other->begin(),getPointer(),std::minus<double>());
5318 else if(nbOfComp2==1)
5320 double *ptr=getPointer();
5321 const double *ptrc=other->getConstPointer();
5322 for(int i=0;i<nbOfTuple;i++)
5323 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::minus<double>(),*ptrc++));
5326 throw INTERP_KERNEL::Exception(msg);
5328 else if(nbOfTuple2==1)
5330 if(nbOfComp2==nbOfComp)
5332 double *ptr=getPointer();
5333 const double *ptrc=other->getConstPointer();
5334 for(int i=0;i<nbOfTuple;i++)
5335 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::minus<double>());
5338 throw INTERP_KERNEL::Exception(msg);
5341 throw INTERP_KERNEL::Exception(msg);
5346 * Returns a new DataArrayDouble that is a product of two given arrays. There are 3
5348 * 1. The arrays have same number of tuples and components. Then each value of
5349 * the result array (_a_) is a product of the corresponding values of \a a1 and
5350 * \a a2, i.e. _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, j ].
5351 * 2. The arrays have same number of tuples and one array, say _a2_, has one
5353 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, 0 ].
5354 * 3. The arrays have same number of components and one array, say _a2_, has one
5356 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ 0, j ].
5358 * Info on components is copied either from the first array (in the first case) or from
5359 * the array with maximal number of elements (getNbOfElems()).
5360 * \param [in] a1 - a factor array.
5361 * \param [in] a2 - another factor array.
5362 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5363 * The caller is to delete this result array using decrRef() as it is no more
5365 * \throw If either \a a1 or \a a2 is NULL.
5366 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
5367 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
5368 * none of them has number of tuples or components equal to 1.
5370 DataArrayDouble *DataArrayDouble::Multiply(const DataArrayDouble *a1, const DataArrayDouble *a2)
5373 throw INTERP_KERNEL::Exception("DataArrayDouble::Multiply : input DataArrayDouble instance is NULL !");
5374 int nbOfTuple=a1->getNumberOfTuples();
5375 int nbOfTuple2=a2->getNumberOfTuples();
5376 int nbOfComp=a1->getNumberOfComponents();
5377 int nbOfComp2=a2->getNumberOfComponents();
5378 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=0;
5379 if(nbOfTuple==nbOfTuple2)
5381 if(nbOfComp==nbOfComp2)
5383 ret=DataArrayDouble::New();
5384 ret->alloc(nbOfTuple,nbOfComp);
5385 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::multiplies<double>());
5386 ret->copyStringInfoFrom(*a1);
5390 int nbOfCompMin,nbOfCompMax;
5391 const DataArrayDouble *aMin, *aMax;
5392 if(nbOfComp>nbOfComp2)
5394 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
5399 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
5404 ret=DataArrayDouble::New();
5405 ret->alloc(nbOfTuple,nbOfCompMax);
5406 const double *aMinPtr=aMin->getConstPointer();
5407 const double *aMaxPtr=aMax->getConstPointer();
5408 double *res=ret->getPointer();
5409 for(int i=0;i<nbOfTuple;i++)
5410 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::multiplies<double>(),aMinPtr[i]));
5411 ret->copyStringInfoFrom(*aMax);
5414 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
5417 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
5419 if(nbOfComp==nbOfComp2)
5421 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
5422 const DataArrayDouble *aMin=nbOfTuple>nbOfTuple2?a2:a1;
5423 const DataArrayDouble *aMax=nbOfTuple>nbOfTuple2?a1:a2;
5424 const double *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
5425 ret=DataArrayDouble::New();
5426 ret->alloc(nbOfTupleMax,nbOfComp);
5427 double *res=ret->getPointer();
5428 for(int i=0;i<nbOfTupleMax;i++)
5429 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::multiplies<double>());
5430 ret->copyStringInfoFrom(*aMax);
5433 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
5436 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Multiply !");
5441 * Multiply values of another DataArrayDouble to values of \a this one. There are 3
5443 * 1. The arrays have same number of tuples and components. Then each value of
5444 * \a other array is multiplied to the corresponding value of \a this array, i.e.
5445 * _this_ [ i, j ] *= _other_ [ i, j ].
5446 * 2. The arrays have same number of tuples and \a other array has one component. Then
5447 * _this_ [ i, j ] *= _other_ [ i, 0 ].
5448 * 3. The arrays have same number of components and \a other array has one tuple. Then
5449 * _this_ [ i, j ] *= _a2_ [ 0, j ].
5451 * \param [in] other - an array to multiply to \a this one.
5452 * \throw If \a other is NULL.
5453 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
5454 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
5455 * \a other has number of both tuples and components not equal to 1.
5457 void DataArrayDouble::multiplyEqual(const DataArrayDouble *other)
5460 throw INTERP_KERNEL::Exception("DataArrayDouble::multiplyEqual : input DataArrayDouble instance is NULL !");
5461 const char *msg="Nb of tuples mismatch for DataArrayDouble::multiplyEqual !";
5463 other->checkAllocated();
5464 int nbOfTuple=getNumberOfTuples();
5465 int nbOfTuple2=other->getNumberOfTuples();
5466 int nbOfComp=getNumberOfComponents();
5467 int nbOfComp2=other->getNumberOfComponents();
5468 if(nbOfTuple==nbOfTuple2)
5470 if(nbOfComp==nbOfComp2)
5472 std::transform(begin(),end(),other->begin(),getPointer(),std::multiplies<double>());
5474 else if(nbOfComp2==1)
5476 double *ptr=getPointer();
5477 const double *ptrc=other->getConstPointer();
5478 for(int i=0;i<nbOfTuple;i++)
5479 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::multiplies<double>(),*ptrc++));
5482 throw INTERP_KERNEL::Exception(msg);
5484 else if(nbOfTuple2==1)
5486 if(nbOfComp2==nbOfComp)
5488 double *ptr=getPointer();
5489 const double *ptrc=other->getConstPointer();
5490 for(int i=0;i<nbOfTuple;i++)
5491 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::multiplies<double>());
5494 throw INTERP_KERNEL::Exception(msg);
5497 throw INTERP_KERNEL::Exception(msg);
5502 * Returns a new DataArrayDouble that is a division of two given arrays. There are 3
5504 * 1. The arrays have same number of tuples and components. Then each value of
5505 * the result array (_a_) is a division of the corresponding values of \a a1 and
5506 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, j ].
5507 * 2. The arrays have same number of tuples and one array, say _a2_, has one
5509 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, 0 ].
5510 * 3. The arrays have same number of components and one array, say _a2_, has one
5512 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ 0, j ].
5514 * Info on components is copied either from the first array (in the first case) or from
5515 * the array with maximal number of elements (getNbOfElems()).
5516 * \warning No check of division by zero is performed!
5517 * \param [in] a1 - a numerator array.
5518 * \param [in] a2 - a denominator array.
5519 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5520 * The caller is to delete this result array using decrRef() as it is no more
5522 * \throw If either \a a1 or \a a2 is NULL.
5523 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
5524 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
5525 * none of them has number of tuples or components equal to 1.
5527 DataArrayDouble *DataArrayDouble::Divide(const DataArrayDouble *a1, const DataArrayDouble *a2)
5530 throw INTERP_KERNEL::Exception("DataArrayDouble::Divide : input DataArrayDouble instance is NULL !");
5531 int nbOfTuple1=a1->getNumberOfTuples();
5532 int nbOfTuple2=a2->getNumberOfTuples();
5533 int nbOfComp1=a1->getNumberOfComponents();
5534 int nbOfComp2=a2->getNumberOfComponents();
5535 if(nbOfTuple2==nbOfTuple1)
5537 if(nbOfComp1==nbOfComp2)
5539 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5540 ret->alloc(nbOfTuple2,nbOfComp1);
5541 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::divides<double>());
5542 ret->copyStringInfoFrom(*a1);
5545 else if(nbOfComp2==1)
5547 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5548 ret->alloc(nbOfTuple1,nbOfComp1);
5549 const double *a2Ptr=a2->getConstPointer();
5550 const double *a1Ptr=a1->getConstPointer();
5551 double *res=ret->getPointer();
5552 for(int i=0;i<nbOfTuple1;i++)
5553 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::divides<double>(),a2Ptr[i]));
5554 ret->copyStringInfoFrom(*a1);
5559 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
5563 else if(nbOfTuple2==1)
5565 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
5566 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5567 ret->alloc(nbOfTuple1,nbOfComp1);
5568 const double *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
5569 double *pt=ret->getPointer();
5570 for(int i=0;i<nbOfTuple1;i++)
5571 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::divides<double>());
5572 ret->copyStringInfoFrom(*a1);
5577 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Divide !");//will always throw an exception
5583 * Divide values of \a this array by values of another DataArrayDouble. There are 3
5585 * 1. The arrays have same number of tuples and components. Then each value of
5586 * \a this array is divided by the corresponding value of \a other one, i.e.:
5587 * _a_ [ i, j ] /= _other_ [ i, j ].
5588 * 2. The arrays have same number of tuples and \a other array has one component. Then
5589 * _a_ [ i, j ] /= _other_ [ i, 0 ].
5590 * 3. The arrays have same number of components and \a other array has one tuple. Then
5591 * _a_ [ i, j ] /= _a2_ [ 0, j ].
5593 * \warning No check of division by zero is performed!
5594 * \param [in] other - an array to divide \a this one by.
5595 * \throw If \a other is NULL.
5596 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
5597 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
5598 * \a other has number of both tuples and components not equal to 1.
5600 void DataArrayDouble::divideEqual(const DataArrayDouble *other)
5603 throw INTERP_KERNEL::Exception("DataArrayDouble::divideEqual : input DataArrayDouble instance is NULL !");
5604 const char *msg="Nb of tuples mismatch for DataArrayDouble::divideEqual !";
5606 other->checkAllocated();
5607 int nbOfTuple=getNumberOfTuples();
5608 int nbOfTuple2=other->getNumberOfTuples();
5609 int nbOfComp=getNumberOfComponents();
5610 int nbOfComp2=other->getNumberOfComponents();
5611 if(nbOfTuple==nbOfTuple2)
5613 if(nbOfComp==nbOfComp2)
5615 std::transform(begin(),end(),other->begin(),getPointer(),std::divides<double>());
5617 else if(nbOfComp2==1)
5619 double *ptr=getPointer();
5620 const double *ptrc=other->getConstPointer();
5621 for(int i=0;i<nbOfTuple;i++)
5622 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::divides<double>(),*ptrc++));
5625 throw INTERP_KERNEL::Exception(msg);
5627 else if(nbOfTuple2==1)
5629 if(nbOfComp2==nbOfComp)
5631 double *ptr=getPointer();
5632 const double *ptrc=other->getConstPointer();
5633 for(int i=0;i<nbOfTuple;i++)
5634 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::divides<double>());
5637 throw INTERP_KERNEL::Exception(msg);
5640 throw INTERP_KERNEL::Exception(msg);
5645 * Returns a new DataArrayDouble that is the result of pow of two given arrays. There are 3
5648 * \param [in] a1 - an array to pow up.
5649 * \param [in] a2 - another array to sum up.
5650 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5651 * The caller is to delete this result array using decrRef() as it is no more
5653 * \throw If either \a a1 or \a a2 is NULL.
5654 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
5655 * \throw If \a a1->getNumberOfComponents() != 1 or \a a2->getNumberOfComponents() != 1.
5656 * \throw If there is a negative value in \a a1.
5658 DataArrayDouble *DataArrayDouble::Pow(const DataArrayDouble *a1, const DataArrayDouble *a2)
5661 throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : at least one of input instances is null !");
5662 int nbOfTuple=a1->getNumberOfTuples();
5663 int nbOfTuple2=a2->getNumberOfTuples();
5664 int nbOfComp=a1->getNumberOfComponents();
5665 int nbOfComp2=a2->getNumberOfComponents();
5666 if(nbOfTuple!=nbOfTuple2)
5667 throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : number of tuples mismatches !");
5668 if(nbOfComp!=1 || nbOfComp2!=1)
5669 throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : number of components of both arrays must be equal to 1 !");
5670 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(nbOfTuple,1);
5671 const double *ptr1(a1->begin()),*ptr2(a2->begin());
5672 double *ptr=ret->getPointer();
5673 for(int i=0;i<nbOfTuple;i++,ptr1++,ptr2++,ptr++)
5677 *ptr=pow(*ptr1,*ptr2);
5681 std::ostringstream oss; oss << "DataArrayDouble::Pow : on tuple #" << i << " of a1 value is < 0 (" << *ptr1 << ") !";
5682 throw INTERP_KERNEL::Exception(oss.str().c_str());
5689 * Apply pow on values of another DataArrayDouble to values of \a this one.
5691 * \param [in] other - an array to pow to \a this one.
5692 * \throw If \a other is NULL.
5693 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples()
5694 * \throw If \a this->getNumberOfComponents() != 1 or \a other->getNumberOfComponents() != 1
5695 * \throw If there is a negative value in \a this.
5697 void DataArrayDouble::powEqual(const DataArrayDouble *other)
5700 throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : input instance is null !");
5701 int nbOfTuple=getNumberOfTuples();
5702 int nbOfTuple2=other->getNumberOfTuples();
5703 int nbOfComp=getNumberOfComponents();
5704 int nbOfComp2=other->getNumberOfComponents();
5705 if(nbOfTuple!=nbOfTuple2)
5706 throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : number of tuples mismatches !");
5707 if(nbOfComp!=1 || nbOfComp2!=1)
5708 throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : number of components of both arrays must be equal to 1 !");
5709 double *ptr=getPointer();
5710 const double *ptrc=other->begin();
5711 for(int i=0;i<nbOfTuple;i++,ptrc++,ptr++)
5714 *ptr=pow(*ptr,*ptrc);
5717 std::ostringstream oss; oss << "DataArrayDouble::powEqual : on tuple #" << i << " of this value is < 0 (" << *ptr << ") !";
5718 throw INTERP_KERNEL::Exception(oss.str().c_str());
5725 * This method is \b NOT wrapped into python because it can be useful only for performance reasons in C++ context.
5726 * All values in \a this must be 0. or 1. within eps error. 0 means false, 1 means true.
5727 * If an another value than 0 or 1 appear (within eps precision) an INTERP_KERNEL::Exception will be thrown.
5729 * \throw if \a this is not allocated.
5730 * \throw if \a this has not exactly one component.
5732 std::vector<bool> DataArrayDouble::toVectorOfBool(double eps) const
5735 if(getNumberOfComponents()!=1)
5736 throw INTERP_KERNEL::Exception("DataArrayDouble::toVectorOfBool : must be applied on single component array !");
5737 int nbt(getNumberOfTuples());
5738 std::vector<bool> ret(nbt);
5739 const double *pt(begin());
5740 for(int i=0;i<nbt;i++)
5744 else if(fabs(pt[i]-1.)<eps)
5748 std::ostringstream oss; oss << "DataArrayDouble::toVectorOfBool : the tuple #" << i << " has value " << pt[i] << " is invalid ! must be 0. or 1. !";
5749 throw INTERP_KERNEL::Exception(oss.str().c_str());
5756 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5759 void DataArrayDouble::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
5764 tinyInfo[0]=getNumberOfTuples();
5765 tinyInfo[1]=getNumberOfComponents();
5775 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5778 void DataArrayDouble::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
5782 int nbOfCompo=getNumberOfComponents();
5783 tinyInfo.resize(nbOfCompo+1);
5784 tinyInfo[0]=getName();
5785 for(int i=0;i<nbOfCompo;i++)
5786 tinyInfo[i+1]=getInfoOnComponent(i);
5791 tinyInfo[0]=getName();
5796 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5797 * This method returns if a feeding is needed.
5799 bool DataArrayDouble::resizeForUnserialization(const std::vector<int>& tinyInfoI)
5801 int nbOfTuple=tinyInfoI[0];
5802 int nbOfComp=tinyInfoI[1];
5803 if(nbOfTuple!=-1 || nbOfComp!=-1)
5805 alloc(nbOfTuple,nbOfComp);
5812 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5814 void DataArrayDouble::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<std::string>& tinyInfoS)
5816 setName(tinyInfoS[0]);
5819 int nbOfCompo=getNumberOfComponents();
5820 for(int i=0;i<nbOfCompo;i++)
5821 setInfoOnComponent(i,tinyInfoS[i+1]);
5825 DataArrayDoubleIterator::DataArrayDoubleIterator(DataArrayDouble *da):_da(da),_tuple_id(0),_nb_comp(0),_nb_tuple(0)
5830 if(_da->isAllocated())
5832 _nb_comp=da->getNumberOfComponents();
5833 _nb_tuple=da->getNumberOfTuples();
5834 _pt=da->getPointer();
5839 DataArrayDoubleIterator::~DataArrayDoubleIterator()
5845 DataArrayDoubleTuple *DataArrayDoubleIterator::nextt()
5847 if(_tuple_id<_nb_tuple)
5850 DataArrayDoubleTuple *ret=new DataArrayDoubleTuple(_pt,_nb_comp);
5858 DataArrayDoubleTuple::DataArrayDoubleTuple(double *pt, int nbOfComp):_pt(pt),_nb_of_compo(nbOfComp)
5863 std::string DataArrayDoubleTuple::repr() const
5865 std::ostringstream oss; oss.precision(17); oss << "(";
5866 for(int i=0;i<_nb_of_compo-1;i++)
5867 oss << _pt[i] << ", ";
5868 oss << _pt[_nb_of_compo-1] << ")";
5872 double DataArrayDoubleTuple::doubleValue() const
5876 throw INTERP_KERNEL::Exception("DataArrayDoubleTuple::doubleValue : DataArrayDoubleTuple instance has not exactly 1 component -> Not possible to convert it into a double precision float !");
5880 * This method returns a newly allocated instance the caller should dealed with by a ParaMEDMEM::DataArrayDouble::decrRef.
5881 * This method performs \b no copy of data. The content is only referenced using ParaMEDMEM::DataArrayDouble::useArray with ownership set to \b false.
5882 * 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
5883 * \b nbOfCompo=1 and \bnbOfTuples==this->_nb_of_elem.
5885 DataArrayDouble *DataArrayDoubleTuple::buildDADouble(int nbOfTuples, int nbOfCompo) const
5887 if((_nb_of_compo==nbOfCompo && nbOfTuples==1) || (_nb_of_compo==nbOfTuples && nbOfCompo==1))
5889 DataArrayDouble *ret=DataArrayDouble::New();
5890 ret->useExternalArrayWithRWAccess(_pt,nbOfTuples,nbOfCompo);
5895 std::ostringstream oss; oss << "DataArrayDoubleTuple::buildDADouble : unable to build a requested DataArrayDouble instance with nbofTuple=" << nbOfTuples << " and nbOfCompo=" << nbOfCompo;
5896 oss << ".\nBecause the number of elements in this is " << _nb_of_compo << " !";
5897 throw INTERP_KERNEL::Exception(oss.str().c_str());
5902 * Returns a new instance of DataArrayInt. The caller is to delete this array
5903 * using decrRef() as it is no more needed.
5905 DataArrayInt *DataArrayInt::New()
5907 return new DataArrayInt;
5911 * Checks if raw data is allocated. Read more on the raw data
5912 * in \ref MEDCouplingArrayBasicsTuplesAndCompo "DataArrays infos" for more information.
5913 * \return bool - \a true if the raw data is allocated, \a false else.
5915 bool DataArrayInt::isAllocated() const
5917 return getConstPointer()!=0;
5921 * Checks if raw data is allocated and throws an exception if it is not the case.
5922 * \throw If the raw data is not allocated.
5924 void DataArrayInt::checkAllocated() const
5927 throw INTERP_KERNEL::Exception("DataArrayInt::checkAllocated : Array is defined but not allocated ! Call alloc or setValues method first !");
5931 * This method desallocated \a this without modification of informations relative to the components.
5932 * After call of this method, DataArrayInt::isAllocated will return false.
5933 * If \a this is already not allocated, \a this is let unchanged.
5935 void DataArrayInt::desallocate()
5940 std::size_t DataArrayInt::getHeapMemorySizeWithoutChildren() const
5942 std::size_t sz(_mem.getNbOfElemAllocated());
5944 return DataArray::getHeapMemorySizeWithoutChildren()+sz;
5948 * Returns the only one value in \a this, if and only if number of elements
5949 * (nb of tuples * nb of components) is equal to 1, and that \a this is allocated.
5950 * \return double - the sole value stored in \a this array.
5951 * \throw If at least one of conditions stated above is not fulfilled.
5953 int DataArrayInt::intValue() const
5957 if(getNbOfElems()==1)
5959 return *getConstPointer();
5962 throw INTERP_KERNEL::Exception("DataArrayInt::intValue : DataArrayInt instance is allocated but number of elements is not equal to 1 !");
5965 throw INTERP_KERNEL::Exception("DataArrayInt::intValue : DataArrayInt instance is not allocated !");
5969 * Returns an integer value characterizing \a this array, which is useful for a quick
5970 * comparison of many instances of DataArrayInt.
5971 * \return int - the hash value.
5972 * \throw If \a this is not allocated.
5974 int DataArrayInt::getHashCode() const
5977 std::size_t nbOfElems=getNbOfElems();
5978 int ret=nbOfElems*65536;
5983 const int *pt=begin();
5984 for(std::size_t i=0;i<nbOfElems;i+=delta)
5985 ret0+=pt[i] & 0x1FFF;
5990 * Checks the number of tuples.
5991 * \return bool - \a true if getNumberOfTuples() == 0, \a false else.
5992 * \throw If \a this is not allocated.
5994 bool DataArrayInt::empty() const
5997 return getNumberOfTuples()==0;
6001 * Returns a full copy of \a this. For more info on copying data arrays see
6002 * \ref MEDCouplingArrayBasicsCopyDeep.
6003 * \return DataArrayInt * - a new instance of DataArrayInt.
6005 DataArrayInt *DataArrayInt::deepCpy() const
6007 return new DataArrayInt(*this);
6011 * Returns either a \a deep or \a shallow copy of this array. For more info see
6012 * \ref MEDCouplingArrayBasicsCopyDeep and \ref MEDCouplingArrayBasicsCopyShallow.
6013 * \param [in] dCpy - if \a true, a deep copy is returned, else, a shallow one.
6014 * \return DataArrayInt * - either a new instance of DataArrayInt (if \a dCpy
6015 * == \a true) or \a this instance (if \a dCpy == \a false).
6017 DataArrayInt *DataArrayInt::performCpy(bool dCpy) const
6024 return const_cast<DataArrayInt *>(this);
6029 * Copies all the data from another DataArrayInt. For more info see
6030 * \ref MEDCouplingArrayBasicsCopyDeepAssign.
6031 * \param [in] other - another instance of DataArrayInt to copy data from.
6032 * \throw If the \a other is not allocated.
6034 void DataArrayInt::cpyFrom(const DataArrayInt& other)
6036 other.checkAllocated();
6037 int nbOfTuples=other.getNumberOfTuples();
6038 int nbOfComp=other.getNumberOfComponents();
6039 allocIfNecessary(nbOfTuples,nbOfComp);
6040 std::size_t nbOfElems=(std::size_t)nbOfTuples*nbOfComp;
6041 int *pt=getPointer();
6042 const int *ptI=other.getConstPointer();
6043 for(std::size_t i=0;i<nbOfElems;i++)
6045 copyStringInfoFrom(other);
6049 * This method reserve nbOfElems elements in memory ( nbOfElems*4 bytes ) \b without impacting the number of tuples in \a this.
6050 * 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.
6051 * If \a this has not already been allocated, number of components is set to one.
6052 * This method allows to reduce number of reallocations on invokation of DataArrayInt::pushBackSilent and DataArrayInt::pushBackValsSilent on \a this.
6054 * \sa DataArrayInt::pack, DataArrayInt::pushBackSilent, DataArrayInt::pushBackValsSilent
6056 void DataArrayInt::reserve(std::size_t nbOfElems)
6058 int nbCompo=getNumberOfComponents();
6061 _mem.reserve(nbOfElems);
6065 _mem.reserve(nbOfElems);
6066 _info_on_compo.resize(1);
6069 throw INTERP_KERNEL::Exception("DataArrayInt::reserve : not available for DataArrayInt with number of components different than 1 !");
6073 * 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
6074 * of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
6076 * \param [in] val the value to be added in \a this
6077 * \throw If \a this has already been allocated with number of components different from one.
6078 * \sa DataArrayInt::pushBackValsSilent
6080 void DataArrayInt::pushBackSilent(int val)
6082 int nbCompo=getNumberOfComponents();
6087 _info_on_compo.resize(1);
6091 throw INTERP_KERNEL::Exception("DataArrayInt::pushBackSilent : not available for DataArrayInt with number of components different than 1 !");
6095 * 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
6096 * of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
6098 * \param [in] valsBg - an array of values to push at the end of \c this.
6099 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
6100 * the last value of \a valsBg is \a valsEnd[ -1 ].
6101 * \throw If \a this has already been allocated with number of components different from one.
6102 * \sa DataArrayInt::pushBackSilent
6104 void DataArrayInt::pushBackValsSilent(const int *valsBg, const int *valsEnd)
6106 int nbCompo=getNumberOfComponents();
6108 _mem.insertAtTheEnd(valsBg,valsEnd);
6111 _info_on_compo.resize(1);
6112 _mem.insertAtTheEnd(valsBg,valsEnd);
6115 throw INTERP_KERNEL::Exception("DataArrayInt::pushBackValsSilent : not available for DataArrayInt with number of components different than 1 !");
6119 * This method returns silently ( without updating time label in \a this ) the last value, if any and suppress it.
6120 * \throw If \a this is already empty.
6121 * \throw If \a this has number of components different from one.
6123 int DataArrayInt::popBackSilent()
6125 if(getNumberOfComponents()==1)
6126 return _mem.popBack();
6128 throw INTERP_KERNEL::Exception("DataArrayInt::popBackSilent : not available for DataArrayInt with number of components different than 1 !");
6132 * 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.
6134 * \sa DataArrayInt::getHeapMemorySizeWithoutChildren, DataArrayInt::reserve
6136 void DataArrayInt::pack() const
6142 * Allocates the raw data in memory. If exactly as same memory as needed already
6143 * allocated, it is not re-allocated.
6144 * \param [in] nbOfTuple - number of tuples of data to allocate.
6145 * \param [in] nbOfCompo - number of components of data to allocate.
6146 * \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
6148 void DataArrayInt::allocIfNecessary(int nbOfTuple, int nbOfCompo)
6152 if(nbOfTuple!=getNumberOfTuples() || nbOfCompo!=getNumberOfComponents())
6153 alloc(nbOfTuple,nbOfCompo);
6156 alloc(nbOfTuple,nbOfCompo);
6160 * Allocates the raw data in memory. If the memory was already allocated, then it is
6161 * freed and re-allocated. See an example of this method use
6162 * \ref MEDCouplingArraySteps1WC "here".
6163 * \param [in] nbOfTuple - number of tuples of data to allocate.
6164 * \param [in] nbOfCompo - number of components of data to allocate.
6165 * \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
6167 void DataArrayInt::alloc(int nbOfTuple, int nbOfCompo)
6169 if(nbOfTuple<0 || nbOfCompo<0)
6170 throw INTERP_KERNEL::Exception("DataArrayInt::alloc : request for negative length of data !");
6171 _info_on_compo.resize(nbOfCompo);
6172 _mem.alloc(nbOfCompo*(std::size_t)nbOfTuple);
6177 * Assign zero to all values in \a this array. To know more on filling arrays see
6178 * \ref MEDCouplingArrayFill.
6179 * \throw If \a this is not allocated.
6181 void DataArrayInt::fillWithZero()
6184 _mem.fillWithValue(0);
6189 * Assign \a val to all values in \a this array. To know more on filling arrays see
6190 * \ref MEDCouplingArrayFill.
6191 * \param [in] val - the value to fill with.
6192 * \throw If \a this is not allocated.
6194 void DataArrayInt::fillWithValue(int val)
6197 _mem.fillWithValue(val);
6202 * Set all values in \a this array so that the i-th element equals to \a init + i
6203 * (i starts from zero). To know more on filling arrays see \ref MEDCouplingArrayFill.
6204 * \param [in] init - value to assign to the first element of array.
6205 * \throw If \a this->getNumberOfComponents() != 1
6206 * \throw If \a this is not allocated.
6208 void DataArrayInt::iota(int init)
6211 if(getNumberOfComponents()!=1)
6212 throw INTERP_KERNEL::Exception("DataArrayInt::iota : works only for arrays with only one component, you can call 'rearrange' method before !");
6213 int *ptr=getPointer();
6214 int ntuples=getNumberOfTuples();
6215 for(int i=0;i<ntuples;i++)
6221 * Returns a textual and human readable representation of \a this instance of
6222 * DataArrayInt. This text is shown when a DataArrayInt is printed in Python.
6223 * \return std::string - text describing \a this DataArrayInt.
6225 * \sa reprNotTooLong, reprZip
6227 std::string DataArrayInt::repr() const
6229 std::ostringstream ret;
6234 std::string DataArrayInt::reprZip() const
6236 std::ostringstream ret;
6242 * This method is close to repr method except that when \a this has more than 1000 tuples, all tuples are not
6243 * printed out to avoid to consume too much space in interpretor.
6246 std::string DataArrayInt::reprNotTooLong() const
6248 std::ostringstream ret;
6249 reprNotTooLongStream(ret);
6253 void DataArrayInt::writeVTK(std::ostream& ofs, int indent, const std::string& type, const std::string& nameInFile, DataArrayByte *byteArr) const
6255 static const char SPACE[4]={' ',' ',' ',' '};
6257 std::string idt(indent,' ');
6258 ofs << idt << "<DataArray type=\"" << type << "\" Name=\"" << nameInFile << "\" NumberOfComponents=\"" << getNumberOfComponents() << "\"";
6261 ofs << " format=\"appended\" offset=\"" << byteArr->getNumberOfTuples() << "\">";
6262 if(std::string(type)=="Int32")
6264 const char *data(reinterpret_cast<const char *>(begin()));
6265 std::size_t sz(getNbOfElems()*sizeof(int));
6266 byteArr->insertAtTheEnd(data,data+sz);
6267 byteArr->insertAtTheEnd(SPACE,SPACE+4);
6269 else if(std::string(type)=="Int8")
6271 INTERP_KERNEL::AutoPtr<char> tmp(new char[getNbOfElems()]);
6272 std::copy(begin(),end(),(char *)tmp);
6273 byteArr->insertAtTheEnd((char *)tmp,(char *)tmp+getNbOfElems());
6274 byteArr->insertAtTheEnd(SPACE,SPACE+4);
6276 else if(std::string(type)=="UInt8")
6278 INTERP_KERNEL::AutoPtr<unsigned char> tmp(new unsigned char[getNbOfElems()]);
6279 std::copy(begin(),end(),(unsigned char *)tmp);
6280 byteArr->insertAtTheEnd((unsigned char *)tmp,(unsigned char *)tmp+getNbOfElems());
6281 byteArr->insertAtTheEnd(SPACE,SPACE+4);
6284 throw INTERP_KERNEL::Exception("DataArrayInt::writeVTK : Only Int32, Int8 and UInt8 supported !");
6288 ofs << " RangeMin=\"" << getMinValueInArray() << "\" RangeMax=\"" << getMaxValueInArray() << "\" format=\"ascii\">\n" << idt;
6289 std::copy(begin(),end(),std::ostream_iterator<int>(ofs," "));
6291 ofs << std::endl << idt << "</DataArray>\n";
6294 void DataArrayInt::reprStream(std::ostream& stream) const
6296 stream << "Name of int array : \"" << _name << "\"\n";
6297 reprWithoutNameStream(stream);
6300 void DataArrayInt::reprZipStream(std::ostream& stream) const
6302 stream << "Name of int array : \"" << _name << "\"\n";
6303 reprZipWithoutNameStream(stream);
6306 void DataArrayInt::reprNotTooLongStream(std::ostream& stream) const
6308 stream << "Name of int array : \"" << _name << "\"\n";
6309 reprNotTooLongWithoutNameStream(stream);
6312 void DataArrayInt::reprWithoutNameStream(std::ostream& stream) const
6314 DataArray::reprWithoutNameStream(stream);
6315 _mem.repr(getNumberOfComponents(),stream);
6318 void DataArrayInt::reprZipWithoutNameStream(std::ostream& stream) const
6320 DataArray::reprWithoutNameStream(stream);
6321 _mem.reprZip(getNumberOfComponents(),stream);
6324 void DataArrayInt::reprNotTooLongWithoutNameStream(std::ostream& stream) const
6326 DataArray::reprWithoutNameStream(stream);
6327 stream.precision(17);
6328 _mem.reprNotTooLong(getNumberOfComponents(),stream);
6331 void DataArrayInt::reprCppStream(const std::string& varName, std::ostream& stream) const
6333 int nbTuples=getNumberOfTuples(),nbComp=getNumberOfComponents();
6334 const int *data=getConstPointer();
6335 stream << "DataArrayInt *" << varName << "=DataArrayInt::New();" << std::endl;
6336 if(nbTuples*nbComp>=1)
6338 stream << "const int " << varName << "Data[" << nbTuples*nbComp << "]={";
6339 std::copy(data,data+nbTuples*nbComp-1,std::ostream_iterator<int>(stream,","));
6340 stream << data[nbTuples*nbComp-1] << "};" << std::endl;
6341 stream << varName << "->useArray(" << varName << "Data,false,CPP_DEALLOC," << nbTuples << "," << nbComp << ");" << std::endl;
6344 stream << varName << "->alloc(" << nbTuples << "," << nbComp << ");" << std::endl;
6345 stream << varName << "->setName(\"" << getName() << "\");" << std::endl;
6349 * Method that gives a quick overvien of \a this for python.
6351 void DataArrayInt::reprQuickOverview(std::ostream& stream) const
6353 static const std::size_t MAX_NB_OF_BYTE_IN_REPR=300;
6354 stream << "DataArrayInt C++ instance at " << this << ". ";
6357 int nbOfCompo=(int)_info_on_compo.size();
6360 int nbOfTuples=getNumberOfTuples();
6361 stream << "Number of tuples : " << nbOfTuples << ". Number of components : " << nbOfCompo << "." << std::endl;
6362 reprQuickOverviewData(stream,MAX_NB_OF_BYTE_IN_REPR);
6365 stream << "Number of components : 0.";
6368 stream << "*** No data allocated ****";
6371 void DataArrayInt::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const
6373 const int *data=begin();
6374 int nbOfTuples=getNumberOfTuples();
6375 int nbOfCompo=(int)_info_on_compo.size();
6376 std::ostringstream oss2; oss2 << "[";
6377 std::string oss2Str(oss2.str());
6378 bool isFinished=true;
6379 for(int i=0;i<nbOfTuples && isFinished;i++)
6384 for(int j=0;j<nbOfCompo;j++,data++)
6387 if(j!=nbOfCompo-1) oss2 << ", ";
6393 if(i!=nbOfTuples-1) oss2 << ", ";
6394 std::string oss3Str(oss2.str());
6395 if(oss3Str.length()<maxNbOfByteInRepr)
6407 * Modifies in place \a this one-dimensional array so that each value \a v = \a indArrBg[ \a v ],
6408 * i.e. a current value is used as in index to get a new value from \a indArrBg.
6409 * \param [in] indArrBg - pointer to the first element of array of new values to assign
6411 * \param [in] indArrEnd - specifies the end of the array \a indArrBg, so that
6412 * the last value of \a indArrBg is \a indArrEnd[ -1 ].
6413 * \throw If \a this->getNumberOfComponents() != 1
6414 * \throw If any value of \a this can't be used as a valid index for
6415 * [\a indArrBg, \a indArrEnd).
6417 * \sa replaceOneValByInThis
6419 void DataArrayInt::transformWithIndArr(const int *indArrBg, const int *indArrEnd)
6422 if(getNumberOfComponents()!=1)
6423 throw INTERP_KERNEL::Exception("Call transformWithIndArr method on DataArrayInt with only one component, you can call 'rearrange' method before !");
6424 int nbElemsIn((int)std::distance(indArrBg,indArrEnd)),nbOfTuples(getNumberOfTuples()),*pt(getPointer());
6425 for(int i=0;i<nbOfTuples;i++,pt++)
6427 if(*pt>=0 && *pt<nbElemsIn)
6431 std::ostringstream oss; oss << "DataArrayInt::transformWithIndArr : error on tuple #" << i << " of this value is " << *pt << ", should be in [0," << nbElemsIn << ") !";
6432 throw INTERP_KERNEL::Exception(oss.str().c_str());
6439 * 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.
6441 * \param [in] valToBeReplaced - the value in \a this to be replaced.
6442 * \param [in] replacedBy - the value taken by each tuple previously equal to \a valToBeReplaced.
6444 * \sa DataArrayInt::transformWithIndArr
6446 void DataArrayInt::replaceOneValByInThis(int valToBeReplaced, int replacedBy)
6449 if(getNumberOfComponents()!=1)
6450 throw INTERP_KERNEL::Exception("Call replaceOneValByInThis method on DataArrayInt with only one component, you can call 'rearrange' method before !");
6451 if(valToBeReplaced==replacedBy)
6453 int nbOfTuples(getNumberOfTuples()),*pt(getPointer());
6454 for(int i=0;i<nbOfTuples;i++,pt++)
6456 if(*pt==valToBeReplaced)
6462 * Computes distribution of values of \a this one-dimensional array between given value
6463 * ranges (casts). This method is typically useful for entity number spliting by types,
6465 * \warning The values contained in \a arrBg should be sorted ascendently. No
6466 * check of this is be done. If not, the result is not warranted.
6467 * \param [in] arrBg - the array of ascending values defining the value ranges. The i-th
6468 * value of \a arrBg (\a arrBg[ i ]) gives the lowest value of the i-th range,
6469 * and the greatest value of the i-th range equals to \a arrBg[ i+1 ] - 1. \a
6470 * arrBg containing \a n values defines \a n-1 ranges. The last value of \a arrBg
6471 * should be more than every value in \a this array.
6472 * \param [in] arrEnd - specifies the end of the array \a arrBg, so that
6473 * the last value of \a arrBg is \a arrEnd[ -1 ].
6474 * \param [out] castArr - a new instance of DataArrayInt, of same size as \a this array
6475 * (same number of tuples and components), the caller is to delete
6476 * using decrRef() as it is no more needed.
6477 * This array contains indices of ranges for every value of \a this array. I.e.
6478 * the i-th value of \a castArr gives the index of range the i-th value of \a this
6479 * belongs to. Or, in other words, this parameter contains for each tuple in \a
6480 * this in which cast it holds.
6481 * \param [out] rankInsideCast - a new instance of DataArrayInt, of same size as \a this
6482 * array, the caller is to delete using decrRef() as it is no more needed.
6483 * This array contains ranks of values of \a this array within ranges
6484 * they belongs to. I.e. the i-th value of \a rankInsideCast gives the rank of
6485 * the i-th value of \a this array within the \a castArr[ i ]-th range, to which
6486 * the i-th value of \a this belongs to. Or, in other words, this param contains
6487 * for each tuple its rank inside its cast. The rank is computed as difference
6488 * between the value and the lowest value of range.
6489 * \param [out] castsPresent - a new instance of DataArrayInt, containing indices of
6490 * ranges (casts) to which at least one value of \a this array belongs.
6491 * Or, in other words, this param contains the casts that \a this contains.
6492 * The caller is to delete this array using decrRef() as it is no more needed.
6494 * \b Example: If \a this contains [6,5,0,3,2,7,8,1,4] and \a arrBg contains [0,4,9] then
6495 * the output of this method will be :
6496 * - \a castArr : [1,1,0,0,0,1,1,0,1]
6497 * - \a rankInsideCast: [2,1,0,3,2,3,4,1,0]
6498 * - \a castsPresent : [0,1]
6500 * I.e. values of \a this array belong to 2 ranges: #0 and #1. Value 6 belongs to the
6501 * range #1 and its rank within this range is 2; etc.
6503 * \throw If \a this->getNumberOfComponents() != 1.
6504 * \throw If \a arrEnd - arrBg < 2.
6505 * \throw If any value of \a this is not less than \a arrEnd[-1].
6507 void DataArrayInt::splitByValueRange(const int *arrBg, const int *arrEnd,
6508 DataArrayInt *& castArr, DataArrayInt *& rankInsideCast, DataArrayInt *& castsPresent) const
6511 if(getNumberOfComponents()!=1)
6512 throw INTERP_KERNEL::Exception("Call splitByValueRange method on DataArrayInt with only one component, you can call 'rearrange' method before !");
6513 int nbOfTuples=getNumberOfTuples();
6514 std::size_t nbOfCast=std::distance(arrBg,arrEnd);
6516 throw INTERP_KERNEL::Exception("DataArrayInt::splitByValueRange : The input array giving the cast range values should be of size >=2 !");
6518 const int *work=getConstPointer();
6519 typedef std::reverse_iterator<const int *> rintstart;
6520 rintstart bg(arrEnd);//OK no problem because size of 'arr' is greater or equal 2
6521 rintstart end2(arrBg);
6522 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New();
6523 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret2=DataArrayInt::New();
6524 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret3=DataArrayInt::New();
6525 ret1->alloc(nbOfTuples,1);
6526 ret2->alloc(nbOfTuples,1);
6527 int *ret1Ptr=ret1->getPointer();
6528 int *ret2Ptr=ret2->getPointer();
6529 std::set<std::size_t> castsDetected;
6530 for(int i=0;i<nbOfTuples;i++)
6532 rintstart res=std::find_if(bg,end2,std::bind2nd(std::less_equal<int>(), work[i]));
6533 std::size_t pos=std::distance(bg,res);
6534 std::size_t pos2=nbOfCast-pos;
6537 ret1Ptr[i]=(int)pos2;
6538 ret2Ptr[i]=work[i]-arrBg[pos2];
6539 castsDetected.insert(pos2);
6543 std::ostringstream oss; oss << "DataArrayInt::splitByValueRange : At rank #" << i << " the value is " << work[i] << " should be in [0," << *bg << ") !";
6544 throw INTERP_KERNEL::Exception(oss.str().c_str());
6547 ret3->alloc((int)castsDetected.size(),1);
6548 std::copy(castsDetected.begin(),castsDetected.end(),ret3->getPointer());
6549 castArr=ret1.retn();
6550 rankInsideCast=ret2.retn();
6551 castsPresent=ret3.retn();
6555 * 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 ).
6556 * 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 ).
6557 * This method works only if \a this is allocated and single component. If not an exception will be thrown.
6559 * \param [out] strt - the start of the range (included) if true is returned.
6560 * \param [out] sttoopp - the end of the range (not included) if true is returned.
6561 * \param [out] stteepp - the step of the range if true is returned.
6562 * \return the verdict of the check.
6564 * \sa DataArray::GetNumberOfItemGivenBES
6566 bool DataArrayInt::isRange(int& strt, int& sttoopp, int& stteepp) const
6569 if(getNumberOfComponents()!=1)
6570 throw INTERP_KERNEL::Exception("DataArrayInt::isRange : this must be single component array !");
6571 int nbTuples(getNumberOfTuples());
6573 { strt=0; sttoopp=0; stteepp=1; return true; }
6574 const int *pt(begin());
6577 { sttoopp=strt+1; stteepp=1; return true; }
6578 strt=*pt; sttoopp=pt[nbTuples-1];
6584 int a(sttoopp-1-strt),tmp(strt);
6585 if(a%(nbTuples-1)!=0)
6587 stteepp=a/(nbTuples-1);
6588 for(int i=0;i<nbTuples;i++,tmp+=stteepp)
6596 int a(strt-sttoopp-1),tmp(strt);
6597 if(a%(nbTuples-1)!=0)
6599 stteepp=-(a/(nbTuples-1));
6600 for(int i=0;i<nbTuples;i++,tmp+=stteepp)
6608 * Creates a one-dimensional DataArrayInt (\a res) whose contents are computed from
6609 * values of \a this (\a a) and the given (\a indArr) arrays as follows:
6610 * \a res[ \a indArr[ \a a[ i ]]] = i. I.e. for each value in place i \a v = \a a[ i ],
6611 * new value in place \a indArr[ \a v ] is i.
6612 * \param [in] indArrBg - the array holding indices within the result array to assign
6613 * indices of values of \a this array pointing to values of \a indArrBg.
6614 * \param [in] indArrEnd - specifies the end of the array \a indArrBg, so that
6615 * the last value of \a indArrBg is \a indArrEnd[ -1 ].
6616 * \return DataArrayInt * - the new instance of DataArrayInt.
6617 * The caller is to delete this result array using decrRef() as it is no more
6619 * \throw If \a this->getNumberOfComponents() != 1.
6620 * \throw If any value of \a this array is not a valid index for \a indArrBg array.
6621 * \throw If any value of \a indArrBg is not a valid index for \a this array.
6623 DataArrayInt *DataArrayInt::transformWithIndArrR(const int *indArrBg, const int *indArrEnd) const
6626 if(getNumberOfComponents()!=1)
6627 throw INTERP_KERNEL::Exception("Call transformWithIndArrR method on DataArrayInt with only one component, you can call 'rearrange' method before !");
6628 int nbElemsIn=(int)std::distance(indArrBg,indArrEnd);
6629 int nbOfTuples=getNumberOfTuples();
6630 const int *pt=getConstPointer();
6631 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6632 ret->alloc(nbOfTuples,1);
6633 ret->fillWithValue(-1);
6634 int *tmp=ret->getPointer();
6635 for(int i=0;i<nbOfTuples;i++,pt++)
6637 if(*pt>=0 && *pt<nbElemsIn)
6639 int pos=indArrBg[*pt];
6640 if(pos>=0 && pos<nbOfTuples)
6644 std::ostringstream oss; oss << "DataArrayInt::transformWithIndArrR : error on tuple #" << i << " value of new pos is " << pos << " ( indArrBg[" << *pt << "]) ! Should be in [0," << nbOfTuples << ") !";
6645 throw INTERP_KERNEL::Exception(oss.str().c_str());
6650 std::ostringstream oss; oss << "DataArrayInt::transformWithIndArrR : error on tuple #" << i << " value is " << *pt << " and indirectionnal array as a size equal to " << nbElemsIn << " !";
6651 throw INTERP_KERNEL::Exception(oss.str().c_str());
6658 * Creates a one-dimensional DataArrayInt of given length, whose contents are computed
6659 * from values of \a this array, which is supposed to contain a renumbering map in
6660 * "Old to New" mode. The result array contains a renumbering map in "New to Old" mode.
6661 * To know how to use the renumbering maps see \ref numbering.
6662 * \param [in] newNbOfElem - the number of tuples in the result array.
6663 * \return DataArrayInt * - the new instance of DataArrayInt.
6664 * The caller is to delete this result array using decrRef() as it is no more
6667 * \if ENABLE_EXAMPLES
6668 * \ref cpp_mcdataarrayint_invertarrayo2n2n2o "Here is a C++ example".<br>
6669 * \ref py_mcdataarrayint_invertarrayo2n2n2o "Here is a Python example".
6672 DataArrayInt *DataArrayInt::invertArrayO2N2N2O(int newNbOfElem) const
6674 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6675 ret->alloc(newNbOfElem,1);
6676 int nbOfOldNodes=getNumberOfTuples();
6677 const int *old2New=getConstPointer();
6678 int *pt=ret->getPointer();
6679 for(int i=0;i!=nbOfOldNodes;i++)
6681 int newp(old2New[i]);
6684 if(newp>=0 && newp<newNbOfElem)
6688 std::ostringstream oss; oss << "DataArrayInt::invertArrayO2N2N2O : At place #" << i << " the newplace is " << newp << " must be in [0," << newNbOfElem << ") !";
6689 throw INTERP_KERNEL::Exception(oss.str().c_str());
6697 * This method is similar to DataArrayInt::invertArrayO2N2N2O except that
6698 * 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]
6700 DataArrayInt *DataArrayInt::invertArrayO2N2N2OBis(int newNbOfElem) const
6702 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6703 ret->alloc(newNbOfElem,1);
6704 int nbOfOldNodes=getNumberOfTuples();
6705 const int *old2New=getConstPointer();
6706 int *pt=ret->getPointer();
6707 for(int i=nbOfOldNodes-1;i>=0;i--)
6709 int newp(old2New[i]);
6712 if(newp>=0 && newp<newNbOfElem)
6716 std::ostringstream oss; oss << "DataArrayInt::invertArrayO2N2N2OBis : At place #" << i << " the newplace is " << newp << " must be in [0," << newNbOfElem << ") !";
6717 throw INTERP_KERNEL::Exception(oss.str().c_str());
6725 * Creates a one-dimensional DataArrayInt of given length, whose contents are computed
6726 * from values of \a this array, which is supposed to contain a renumbering map in
6727 * "New to Old" mode. The result array contains a renumbering map in "Old to New" mode.
6728 * To know how to use the renumbering maps see \ref numbering.
6729 * \param [in] newNbOfElem - the number of tuples in the result array.
6730 * \return DataArrayInt * - the new instance of DataArrayInt.
6731 * The caller is to delete this result array using decrRef() as it is no more
6734 * \if ENABLE_EXAMPLES
6735 * \ref cpp_mcdataarrayint_invertarrayn2o2o2n "Here is a C++ example".
6737 * \ref py_mcdataarrayint_invertarrayn2o2o2n "Here is a Python example".
6740 DataArrayInt *DataArrayInt::invertArrayN2O2O2N(int oldNbOfElem) const
6743 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6744 ret->alloc(oldNbOfElem,1);
6745 const int *new2Old=getConstPointer();
6746 int *pt=ret->getPointer();
6747 std::fill(pt,pt+oldNbOfElem,-1);
6748 int nbOfNewElems=getNumberOfTuples();
6749 for(int i=0;i<nbOfNewElems;i++)
6752 if(v>=0 && v<oldNbOfElem)
6756 std::ostringstream oss; oss << "DataArrayInt::invertArrayN2O2O2N : in new id #" << i << " old value is " << v << " expected to be in [0," << oldNbOfElem << ") !";
6757 throw INTERP_KERNEL::Exception(oss.str().c_str());
6764 * Equivalent to DataArrayInt::isEqual except that if false the reason of
6765 * mismatch is given.
6767 * \param [in] other the instance to be compared with \a this
6768 * \param [out] reason In case of inequality returns the reason.
6769 * \sa DataArrayInt::isEqual
6771 bool DataArrayInt::isEqualIfNotWhy(const DataArrayInt& other, std::string& reason) const
6773 if(!areInfoEqualsIfNotWhy(other,reason))
6775 return _mem.isEqual(other._mem,0,reason);
6779 * Checks if \a this and another DataArrayInt are fully equal. For more info see
6780 * \ref MEDCouplingArrayBasicsCompare.
6781 * \param [in] other - an instance of DataArrayInt to compare with \a this one.
6782 * \return bool - \a true if the two arrays are equal, \a false else.
6784 bool DataArrayInt::isEqual(const DataArrayInt& other) const
6787 return isEqualIfNotWhy(other,tmp);
6791 * Checks if values of \a this and another DataArrayInt are equal. For more info see
6792 * \ref MEDCouplingArrayBasicsCompare.
6793 * \param [in] other - an instance of DataArrayInt to compare with \a this one.
6794 * \return bool - \a true if the values of two arrays are equal, \a false else.
6796 bool DataArrayInt::isEqualWithoutConsideringStr(const DataArrayInt& other) const
6799 return _mem.isEqual(other._mem,0,tmp);
6803 * Checks if values of \a this and another DataArrayInt are equal. Comparison is
6804 * performed on sorted value sequences.
6805 * For more info see\ref MEDCouplingArrayBasicsCompare.
6806 * \param [in] other - an instance of DataArrayInt to compare with \a this one.
6807 * \return bool - \a true if the sorted values of two arrays are equal, \a false else.
6809 bool DataArrayInt::isEqualWithoutConsideringStrAndOrder(const DataArrayInt& other) const
6811 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> a=deepCpy();
6812 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> b=other.deepCpy();
6815 return a->isEqualWithoutConsideringStr(*b);
6819 * This method compares content of input vector \a v and \a this.
6820 * 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.
6821 * For performance reasons \a this is expected to be sorted ascendingly. If not an exception will be thrown.
6823 * \param [in] v - the vector of 'flags' to be compared with \a this.
6825 * \throw If \a this is not sorted ascendingly.
6826 * \throw If \a this has not exactly one component.
6827 * \throw If \a this is not allocated.
6829 bool DataArrayInt::isFittingWith(const std::vector<bool>& v) const
6832 if(getNumberOfComponents()!=1)
6833 throw INTERP_KERNEL::Exception("DataArrayInt::isFittingWith : number of components of this should be equal to one !");
6834 const int *w(begin()),*end2(end());
6835 int refVal=-std::numeric_limits<int>::max();
6837 std::vector<bool>::const_iterator it(v.begin());
6838 for(;it!=v.end();it++,i++)
6850 std::ostringstream oss; oss << "DataArrayInt::isFittingWith : At pos #" << std::distance(begin(),w-1) << " this is not sorted ascendingly !";
6851 throw INTERP_KERNEL::Exception(oss.str().c_str());
6865 * This method assumes that \a this has one component and is allocated. This method scans all tuples in \a this and for all tuple equal to \a val
6866 * put True to the corresponding entry in \a vec.
6867 * \a vec is expected to be with the same size than the number of tuples of \a this.
6869 void DataArrayInt::switchOnTupleEqualTo(int val, std::vector<bool>& vec) const
6872 if(getNumberOfComponents()!=1)
6873 throw INTERP_KERNEL::Exception("DataArrayInt::switchOnTupleEqualTo : number of components of this should be equal to one !");
6874 int nbOfTuples(getNumberOfTuples());
6875 if(nbOfTuples!=(int)vec.size())
6876 throw INTERP_KERNEL::Exception("DataArrayInt::switchOnTupleEqualTo : number of tuples of this should be equal to size of input vector of bool !");
6877 const int *pt(begin());
6878 for(int i=0;i<nbOfTuples;i++)
6884 * Sorts values of the array.
6885 * \param [in] asc - \a true means ascending order, \a false, descending.
6886 * \throw If \a this is not allocated.
6887 * \throw If \a this->getNumberOfComponents() != 1.
6889 void DataArrayInt::sort(bool asc)
6892 if(getNumberOfComponents()!=1)
6893 throw INTERP_KERNEL::Exception("DataArrayInt::sort : only supported with 'this' array with ONE component !");
6899 * Computes for each tuple the sum of number of components values in the tuple and return it.
6901 * \return DataArrayInt * - the new instance of DataArrayInt containing the
6902 * same number of tuples as \a this array and one component.
6903 * The caller is to delete this result array using decrRef() as it is no more
6905 * \throw If \a this is not allocated.
6907 DataArrayInt *DataArrayInt::sumPerTuple() const
6910 int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
6911 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
6912 ret->alloc(nbOfTuple,1);
6913 const int *src(getConstPointer());
6914 int *dest(ret->getPointer());
6915 for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
6916 *dest=std::accumulate(src,src+nbOfComp,0);
6921 * Reverse the array values.
6922 * \throw If \a this->getNumberOfComponents() < 1.
6923 * \throw If \a this is not allocated.
6925 void DataArrayInt::reverse()
6928 _mem.reverse(getNumberOfComponents());
6933 * Checks that \a this array is consistently **increasing** or **decreasing** in value.
6934 * If not an exception is thrown.
6935 * \param [in] increasing - if \a true, the array values should be increasing.
6936 * \throw If sequence of values is not strictly monotonic in agreement with \a
6938 * \throw If \a this->getNumberOfComponents() != 1.
6939 * \throw If \a this is not allocated.
6941 void DataArrayInt::checkMonotonic(bool increasing) const
6943 if(!isMonotonic(increasing))
6946 throw INTERP_KERNEL::Exception("DataArrayInt::checkMonotonic : 'this' is not INCREASING monotonic !");
6948 throw INTERP_KERNEL::Exception("DataArrayInt::checkMonotonic : 'this' is not DECREASING monotonic !");
6953 * Checks that \a this array is consistently **increasing** or **decreasing** in value.
6954 * \param [in] increasing - if \a true, array values should be increasing.
6955 * \return bool - \a true if values change in accordance with \a increasing arg.
6956 * \throw If \a this->getNumberOfComponents() != 1.
6957 * \throw If \a this is not allocated.
6959 bool DataArrayInt::isMonotonic(bool increasing) const
6962 if(getNumberOfComponents()!=1)
6963 throw INTERP_KERNEL::Exception("DataArrayInt::isMonotonic : only supported with 'this' array with ONE component !");
6964 int nbOfElements=getNumberOfTuples();
6965 const int *ptr=getConstPointer();
6971 for(int i=1;i<nbOfElements;i++)
6981 for(int i=1;i<nbOfElements;i++)
6993 * This method check that array consistently INCREASING or DECREASING in value.
6995 bool DataArrayInt::isStrictlyMonotonic(bool increasing) const
6998 if(getNumberOfComponents()!=1)
6999 throw INTERP_KERNEL::Exception("DataArrayInt::isStrictlyMonotonic : only supported with 'this' array with ONE component !");
7000 int nbOfElements=getNumberOfTuples();
7001 const int *ptr=getConstPointer();
7007 for(int i=1;i<nbOfElements;i++)
7017 for(int i=1;i<nbOfElements;i++)
7029 * This method check that array consistently INCREASING or DECREASING in value.
7031 void DataArrayInt::checkStrictlyMonotonic(bool increasing) const
7033 if(!isStrictlyMonotonic(increasing))
7036 throw INTERP_KERNEL::Exception("DataArrayInt::checkStrictlyMonotonic : 'this' is not strictly INCREASING monotonic !");
7038 throw INTERP_KERNEL::Exception("DataArrayInt::checkStrictlyMonotonic : 'this' is not strictly DECREASING monotonic !");
7043 * Creates a new one-dimensional DataArrayInt of the same size as \a this and a given
7044 * one-dimensional arrays that must be of the same length. The result array describes
7045 * correspondence between \a this and \a other arrays, so that
7046 * <em> other.getIJ(i,0) == this->getIJ(ret->getIJ(i),0)</em>. If such a permutation is
7047 * not possible because some element in \a other is not in \a this, an exception is thrown.
7048 * \param [in] other - an array to compute permutation to.
7049 * \return DataArrayInt * - a new instance of DataArrayInt, which is a permutation array
7050 * from \a this to \a other. The caller is to delete this array using decrRef() as it is
7052 * \throw If \a this->getNumberOfComponents() != 1.
7053 * \throw If \a other->getNumberOfComponents() != 1.
7054 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples().
7055 * \throw If \a other includes a value which is not in \a this array.
7057 * \if ENABLE_EXAMPLES
7058 * \ref cpp_mcdataarrayint_buildpermutationarr "Here is a C++ example".
7060 * \ref py_mcdataarrayint_buildpermutationarr "Here is a Python example".
7063 DataArrayInt *DataArrayInt::buildPermutationArr(const DataArrayInt& other) const
7066 if(getNumberOfComponents()!=1 || other.getNumberOfComponents()!=1)
7067 throw INTERP_KERNEL::Exception("DataArrayInt::buildPermutationArr : 'this' and 'other' have to have exactly ONE component !");
7068 int nbTuple=getNumberOfTuples();
7069 other.checkAllocated();
7070 if(nbTuple!=other.getNumberOfTuples())
7071 throw INTERP_KERNEL::Exception("DataArrayInt::buildPermutationArr : 'this' and 'other' must have the same number of tuple !");
7072 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7073 ret->alloc(nbTuple,1);
7074 ret->fillWithValue(-1);
7075 const int *pt=getConstPointer();
7076 std::map<int,int> mm;
7077 for(int i=0;i<nbTuple;i++)
7079 pt=other.getConstPointer();
7080 int *retToFill=ret->getPointer();
7081 for(int i=0;i<nbTuple;i++)
7083 std::map<int,int>::const_iterator it=mm.find(pt[i]);
7086 std::ostringstream oss; oss << "DataArrayInt::buildPermutationArr : Arrays mismatch : element (" << pt[i] << ") in 'other' not findable in 'this' !";
7087 throw INTERP_KERNEL::Exception(oss.str().c_str());
7089 retToFill[i]=(*it).second;
7095 * Sets a C array to be used as raw data of \a this. The previously set info
7096 * of components is retained and re-sized.
7097 * For more info see \ref MEDCouplingArraySteps1.
7098 * \param [in] array - the C array to be used as raw data of \a this.
7099 * \param [in] ownership - if \a true, \a array will be deallocated at destruction of \a this.
7100 * \param [in] type - specifies how to deallocate \a array. If \a type == ParaMEDMEM::CPP_DEALLOC,
7101 * \c delete [] \c array; will be called. If \a type == ParaMEDMEM::C_DEALLOC,
7102 * \c free(\c array ) will be called.
7103 * \param [in] nbOfTuple - new number of tuples in \a this.
7104 * \param [in] nbOfCompo - new number of components in \a this.
7106 void DataArrayInt::useArray(const int *array, bool ownership, DeallocType type, int nbOfTuple, int nbOfCompo)
7108 _info_on_compo.resize(nbOfCompo);
7109 _mem.useArray(array,ownership,type,nbOfTuple*nbOfCompo);
7113 void DataArrayInt::useExternalArrayWithRWAccess(const int *array, int nbOfTuple, int nbOfCompo)
7115 _info_on_compo.resize(nbOfCompo);
7116 _mem.useExternalArrayWithRWAccess(array,nbOfTuple*nbOfCompo);
7121 * Returns a new DataArrayInt holding the same values as \a this array but differently
7122 * arranged in memory. If \a this array holds 2 components of 3 values:
7123 * \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$, then the result array holds these values arranged
7124 * as follows: \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$.
7125 * \warning Do not confuse this method with transpose()!
7126 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7127 * is to delete using decrRef() as it is no more needed.
7128 * \throw If \a this is not allocated.
7130 DataArrayInt *DataArrayInt::fromNoInterlace() const
7134 throw INTERP_KERNEL::Exception("DataArrayInt::fromNoInterlace : Not defined array !");
7135 int *tab=_mem.fromNoInterlace(getNumberOfComponents());
7136 DataArrayInt *ret=DataArrayInt::New();
7137 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
7142 * Returns a new DataArrayInt holding the same values as \a this array but differently
7143 * arranged in memory. If \a this array holds 2 components of 3 values:
7144 * \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$, then the result array holds these values arranged
7145 * as follows: \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$.
7146 * \warning Do not confuse this method with transpose()!
7147 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7148 * is to delete using decrRef() as it is no more needed.
7149 * \throw If \a this is not allocated.
7151 DataArrayInt *DataArrayInt::toNoInterlace() const
7155 throw INTERP_KERNEL::Exception("DataArrayInt::toNoInterlace : Not defined array !");
7156 int *tab=_mem.toNoInterlace(getNumberOfComponents());
7157 DataArrayInt *ret=DataArrayInt::New();
7158 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
7163 * Permutes values of \a this array as required by \a old2New array. The values are
7164 * permuted so that \c new[ \a old2New[ i ]] = \c old[ i ]. Number of tuples remains
7165 * the same as in \c this one.
7166 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
7167 * For more info on renumbering see \ref numbering.
7168 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
7169 * giving a new position for i-th old value.
7171 void DataArrayInt::renumberInPlace(const int *old2New)
7174 int nbTuples=getNumberOfTuples();
7175 int nbOfCompo=getNumberOfComponents();
7176 int *tmp=new int[nbTuples*nbOfCompo];
7177 const int *iptr=getConstPointer();
7178 for(int i=0;i<nbTuples;i++)
7181 if(v>=0 && v<nbTuples)
7182 std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),tmp+nbOfCompo*v);
7185 std::ostringstream oss; oss << "DataArrayInt::renumberInPlace : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
7186 throw INTERP_KERNEL::Exception(oss.str().c_str());
7189 std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
7195 * Permutes values of \a this array as required by \a new2Old array. The values are
7196 * permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of tuples remains
7197 * the same as in \c this one.
7198 * For more info on renumbering see \ref numbering.
7199 * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
7200 * giving a previous position of i-th new value.
7201 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7202 * is to delete using decrRef() as it is no more needed.
7204 void DataArrayInt::renumberInPlaceR(const int *new2Old)
7207 int nbTuples=getNumberOfTuples();
7208 int nbOfCompo=getNumberOfComponents();
7209 int *tmp=new int[nbTuples*nbOfCompo];
7210 const int *iptr=getConstPointer();
7211 for(int i=0;i<nbTuples;i++)
7214 if(v>=0 && v<nbTuples)
7215 std::copy(iptr+nbOfCompo*v,iptr+nbOfCompo*(v+1),tmp+nbOfCompo*i);
7218 std::ostringstream oss; oss << "DataArrayInt::renumberInPlaceR : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
7219 throw INTERP_KERNEL::Exception(oss.str().c_str());
7222 std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
7228 * Returns a copy of \a this array with values permuted as required by \a old2New array.
7229 * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ].
7230 * Number of tuples in the result array remains the same as in \c this one.
7231 * If a permutation reduction is needed, renumberAndReduce() should be used.
7232 * For more info on renumbering see \ref numbering.
7233 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
7234 * giving a new position for i-th old value.
7235 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7236 * is to delete using decrRef() as it is no more needed.
7237 * \throw If \a this is not allocated.
7239 DataArrayInt *DataArrayInt::renumber(const int *old2New) const
7242 int nbTuples=getNumberOfTuples();
7243 int nbOfCompo=getNumberOfComponents();
7244 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7245 ret->alloc(nbTuples,nbOfCompo);
7246 ret->copyStringInfoFrom(*this);
7247 const int *iptr=getConstPointer();
7248 int *optr=ret->getPointer();
7249 for(int i=0;i<nbTuples;i++)
7250 std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),optr+nbOfCompo*old2New[i]);
7251 ret->copyStringInfoFrom(*this);
7256 * Returns a copy of \a this array with values permuted as required by \a new2Old array.
7257 * The values are permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of
7258 * tuples in the result array remains the same as in \c this one.
7259 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
7260 * For more info on renumbering see \ref numbering.
7261 * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
7262 * giving a previous position of i-th new value.
7263 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7264 * is to delete using decrRef() as it is no more needed.
7266 DataArrayInt *DataArrayInt::renumberR(const int *new2Old) const
7269 int nbTuples=getNumberOfTuples();
7270 int nbOfCompo=getNumberOfComponents();
7271 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7272 ret->alloc(nbTuples,nbOfCompo);
7273 ret->copyStringInfoFrom(*this);
7274 const int *iptr=getConstPointer();
7275 int *optr=ret->getPointer();
7276 for(int i=0;i<nbTuples;i++)
7277 std::copy(iptr+nbOfCompo*new2Old[i],iptr+nbOfCompo*(new2Old[i]+1),optr+nbOfCompo*i);
7278 ret->copyStringInfoFrom(*this);
7283 * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
7284 * of size \a newNbOfTuple and it's values are permuted as required by \a old2New array.
7285 * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ] for all
7286 * \a old2New[ i ] >= 0. In other words every i-th tuple in \a this array, for which
7287 * \a old2New[ i ] is negative, is missing from the result array.
7288 * For more info on renumbering see \ref numbering.
7289 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
7290 * giving a new position for i-th old tuple and giving negative position for
7291 * for i-th old tuple that should be omitted.
7292 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7293 * is to delete using decrRef() as it is no more needed.
7295 DataArrayInt *DataArrayInt::renumberAndReduce(const int *old2New, int newNbOfTuple) const
7298 int nbTuples=getNumberOfTuples();
7299 int nbOfCompo=getNumberOfComponents();
7300 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7301 ret->alloc(newNbOfTuple,nbOfCompo);
7302 const int *iptr=getConstPointer();
7303 int *optr=ret->getPointer();
7304 for(int i=0;i<nbTuples;i++)
7308 std::copy(iptr+i*nbOfCompo,iptr+(i+1)*nbOfCompo,optr+w*nbOfCompo);
7310 ret->copyStringInfoFrom(*this);
7315 * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
7316 * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
7317 * \a new2OldBg array.
7318 * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
7319 * This method is equivalent to renumberAndReduce() except that convention in input is
7320 * \c new2old and \b not \c old2new.
7321 * For more info on renumbering see \ref numbering.
7322 * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
7323 * tuple index in \a this array to fill the i-th tuple in the new array.
7324 * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
7325 * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
7326 * \a new2OldBg <= \a pi < \a new2OldEnd.
7327 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7328 * is to delete using decrRef() as it is no more needed.
7330 DataArrayInt *DataArrayInt::selectByTupleId(const int *new2OldBg, const int *new2OldEnd) const
7333 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7334 int nbComp=getNumberOfComponents();
7335 ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
7336 ret->copyStringInfoFrom(*this);
7337 int *pt=ret->getPointer();
7338 const int *srcPt=getConstPointer();
7340 for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
7341 std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
7342 ret->copyStringInfoFrom(*this);
7347 * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
7348 * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
7349 * \a new2OldBg array.
7350 * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
7351 * This method is equivalent to renumberAndReduce() except that convention in input is
7352 * \c new2old and \b not \c old2new.
7353 * This method is equivalent to selectByTupleId() except that it prevents coping data
7354 * from behind the end of \a this array.
7355 * For more info on renumbering see \ref numbering.
7356 * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
7357 * tuple index in \a this array to fill the i-th tuple in the new array.
7358 * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
7359 * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
7360 * \a new2OldBg <= \a pi < \a new2OldEnd.
7361 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7362 * is to delete using decrRef() as it is no more needed.
7363 * \throw If \a new2OldEnd - \a new2OldBg > \a this->getNumberOfTuples().
7365 DataArrayInt *DataArrayInt::selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const
7368 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7369 int nbComp=getNumberOfComponents();
7370 int oldNbOfTuples=getNumberOfTuples();
7371 ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
7372 ret->copyStringInfoFrom(*this);
7373 int *pt=ret->getPointer();
7374 const int *srcPt=getConstPointer();
7376 for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
7377 if(*w>=0 && *w<oldNbOfTuples)
7378 std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
7380 throw INTERP_KERNEL::Exception("DataArrayInt::selectByTupleIdSafe : some ids has been detected to be out of [0,this->getNumberOfTuples) !");
7381 ret->copyStringInfoFrom(*this);
7386 * Returns a shorten copy of \a this array. The new DataArrayInt contains every
7387 * (\a bg + \c i * \a step)-th tuple of \a this array located before the \a end2-th
7388 * tuple. Indices of the selected tuples are the same as ones returned by the Python
7389 * command \c range( \a bg, \a end2, \a step ).
7390 * This method is equivalent to selectByTupleIdSafe() except that the input array is
7391 * not constructed explicitly.
7392 * For more info on renumbering see \ref numbering.
7393 * \param [in] bg - index of the first tuple to copy from \a this array.
7394 * \param [in] end2 - index of the tuple before which the tuples to copy are located.
7395 * \param [in] step - index increment to get index of the next tuple to copy.
7396 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7397 * is to delete using decrRef() as it is no more needed.
7398 * \sa DataArrayInt::substr.
7400 DataArrayInt *DataArrayInt::selectByTupleId2(int bg, int end2, int step) const
7403 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7404 int nbComp=getNumberOfComponents();
7405 int newNbOfTuples=GetNumberOfItemGivenBESRelative(bg,end2,step,"DataArrayInt::selectByTupleId2 : ");
7406 ret->alloc(newNbOfTuples,nbComp);
7407 int *pt=ret->getPointer();
7408 const int *srcPt=getConstPointer()+bg*nbComp;
7409 for(int i=0;i<newNbOfTuples;i++,srcPt+=step*nbComp)
7410 std::copy(srcPt,srcPt+nbComp,pt+i*nbComp);
7411 ret->copyStringInfoFrom(*this);
7416 * Returns a shorten copy of \a this array. The new DataArrayInt contains ranges
7417 * of tuples specified by \a ranges parameter.
7418 * For more info on renumbering see \ref numbering.
7419 * \param [in] ranges - std::vector of std::pair's each of which defines a range
7420 * of tuples in [\c begin,\c end) format.
7421 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7422 * is to delete using decrRef() as it is no more needed.
7423 * \throw If \a end < \a begin.
7424 * \throw If \a end > \a this->getNumberOfTuples().
7425 * \throw If \a this is not allocated.
7427 DataArray *DataArrayInt::selectByTupleRanges(const std::vector<std::pair<int,int> >& ranges) const
7430 int nbOfComp=getNumberOfComponents();
7431 int nbOfTuplesThis=getNumberOfTuples();
7434 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7435 ret->alloc(0,nbOfComp);
7436 ret->copyStringInfoFrom(*this);
7439 int ref=ranges.front().first;
7441 bool isIncreasing=true;
7442 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
7444 if((*it).first<=(*it).second)
7446 if((*it).first>=0 && (*it).second<=nbOfTuplesThis)
7448 nbOfTuples+=(*it).second-(*it).first;
7450 isIncreasing=ref<=(*it).first;
7455 std::ostringstream oss; oss << "DataArrayInt::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
7456 oss << " (" << (*it).first << "," << (*it).second << ") is greater than number of tuples of this :" << nbOfTuples << " !";
7457 throw INTERP_KERNEL::Exception(oss.str().c_str());
7462 std::ostringstream oss; oss << "DataArrayInt::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
7463 oss << " (" << (*it).first << "," << (*it).second << ") end is before begin !";
7464 throw INTERP_KERNEL::Exception(oss.str().c_str());
7467 if(isIncreasing && nbOfTuplesThis==nbOfTuples)
7469 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7470 ret->alloc(nbOfTuples,nbOfComp);
7471 ret->copyStringInfoFrom(*this);
7472 const int *src=getConstPointer();
7473 int *work=ret->getPointer();
7474 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
7475 work=std::copy(src+(*it).first*nbOfComp,src+(*it).second*nbOfComp,work);
7480 * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode.
7481 * This map, if applied to \a this array, would make it sorted. For example, if
7482 * \a this array contents are [9,10,0,6,4,11,3,7] then the contents of the result array
7483 * are [5,6,0,3,2,7,1,4]; if this result array (\a res) is used as an argument in call
7484 * \a this->renumber(\a res) then the returned array contains [0,3,4,6,7,9,10,11].
7485 * This method is useful for renumbering (in MED file for example). For more info
7486 * on renumbering see \ref numbering.
7487 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7488 * array using decrRef() as it is no more needed.
7489 * \throw If \a this is not allocated.
7490 * \throw If \a this->getNumberOfComponents() != 1.
7491 * \throw If there are equal values in \a this array.
7493 DataArrayInt *DataArrayInt::checkAndPreparePermutation() const
7496 if(getNumberOfComponents()!=1)
7497 throw INTERP_KERNEL::Exception("DataArrayInt::checkAndPreparePermutation : number of components must == 1 !");
7498 int nbTuples=getNumberOfTuples();
7499 const int *pt=getConstPointer();
7500 int *pt2=CheckAndPreparePermutation(pt,pt+nbTuples);
7501 DataArrayInt *ret=DataArrayInt::New();
7502 ret->useArray(pt2,true,C_DEALLOC,nbTuples,1);
7507 * 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
7508 * input array \a ids2.
7509 * \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.
7510 * 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
7512 * In case of success (no throw) : \c ids1->renumber(ret)->isEqual(ids2) where \a ret is the return of this method.
7514 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7515 * array using decrRef() as it is no more needed.
7516 * \throw If either ids1 or ids2 is null not allocated or not with one components.
7519 DataArrayInt *DataArrayInt::FindPermutationFromFirstToSecond(const DataArrayInt *ids1, const DataArrayInt *ids2)
7522 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays must be not null !");
7523 if(!ids1->isAllocated() || !ids2->isAllocated())
7524 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays must be allocated !");
7525 if(ids1->getNumberOfComponents()!=1 || ids2->getNumberOfComponents()!=1)
7526 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays have exactly one component !");
7527 if(ids1->getNumberOfTuples()!=ids2->getNumberOfTuples())
7529 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 !";
7530 throw INTERP_KERNEL::Exception(oss.str().c_str());
7532 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(ids1->deepCpy());
7533 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p2(ids2->deepCpy());
7534 p1->sort(true); p2->sort(true);
7535 if(!p1->isEqualWithoutConsideringStr(*p2))
7536 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two arrays are not lying on same ids ! Impossible to find a permutation between the 2 arrays !");
7537 p1=ids1->checkAndPreparePermutation();
7538 p2=ids2->checkAndPreparePermutation();
7539 p2=p2->invertArrayO2N2N2O(p2->getNumberOfTuples());
7540 p2=p2->selectByTupleIdSafe(p1->begin(),p1->end());
7545 * Returns two arrays describing a surjective mapping from \a this set of values (\a A)
7546 * onto a set of values of size \a targetNb (\a B). The surjective function is
7547 * \a B[ \a A[ i ]] = i. That is to say that for each \a id in [0,\a targetNb), where \a
7548 * targetNb < \a this->getNumberOfTuples(), there exists at least one tupleId (\a tid) so
7549 * that <em> this->getIJ( tid, 0 ) == id</em>. <br>
7550 * The first of out arrays returns indices of elements of \a this array, grouped by their
7551 * place in the set \a B. The second out array is the index of the first one; it shows how
7552 * many elements of \a A are mapped into each element of \a B. <br>
7554 * mapping and its usage in renumbering see \ref numbering. <br>
7556 * - \a this: [0,3,2,3,2,2,1,2]
7558 * - \a arr: [0, 6, 2,4,5,7, 1,3]
7559 * - \a arrI: [0,1,2,6,8]
7561 * This result means: <br>
7562 * the element of \a B 0 encounters within \a A once (\a arrI[ 0+1 ] - \a arrI[ 0 ]) and
7563 * its index within \a A is 0 ( \a arr[ 0:1 ] == \a arr[ \a arrI[ 0 ] : \a arrI[ 0+1 ]]);<br>
7564 * the element of \a B 2 encounters within \a A 4 times (\a arrI[ 2+1 ] - \a arrI[ 2 ]) and
7565 * its indices within \a A are [2,4,5,7] ( \a arr[ 2:6 ] == \a arr[ \a arrI[ 2 ] :
7566 * \a arrI[ 2+1 ]]); <br> etc.
7567 * \param [in] targetNb - the size of the set \a B. \a targetNb must be equal or more
7568 * than the maximal value of \a A.
7569 * \param [out] arr - a new instance of DataArrayInt returning indices of
7570 * elements of \a this, grouped by their place in the set \a B. The caller is to delete
7571 * this array using decrRef() as it is no more needed.
7572 * \param [out] arrI - a new instance of DataArrayInt returning size of groups of equal
7573 * elements of \a this. The caller is to delete this array using decrRef() as it
7574 * is no more needed.
7575 * \throw If \a this is not allocated.
7576 * \throw If \a this->getNumberOfComponents() != 1.
7577 * \throw If any value in \a this is more or equal to \a targetNb.
7579 void DataArrayInt::changeSurjectiveFormat(int targetNb, DataArrayInt *&arr, DataArrayInt *&arrI) const
7582 if(getNumberOfComponents()!=1)
7583 throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : number of components must == 1 !");
7584 int nbOfTuples=getNumberOfTuples();
7585 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
7586 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> retI(DataArrayInt::New());
7587 retI->alloc(targetNb+1,1);
7588 const int *input=getConstPointer();
7589 std::vector< std::vector<int> > tmp(targetNb);
7590 for(int i=0;i<nbOfTuples;i++)
7593 if(tmp2>=0 && tmp2<targetNb)
7594 tmp[tmp2].push_back(i);
7597 std::ostringstream oss; oss << "DataArrayInt::changeSurjectiveFormat : At pos " << i << " presence of element " << tmp2 << " ! should be in [0," << targetNb << ") !";
7598 throw INTERP_KERNEL::Exception(oss.str().c_str());
7601 int *retIPtr=retI->getPointer();
7603 for(std::vector< std::vector<int> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++,retIPtr++)
7604 retIPtr[1]=retIPtr[0]+(int)((*it1).size());
7605 if(nbOfTuples!=retI->getIJ(targetNb,0))
7606 throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : big problem should never happen !");
7607 ret->alloc(nbOfTuples,1);
7608 int *retPtr=ret->getPointer();
7609 for(std::vector< std::vector<int> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++)
7610 retPtr=std::copy((*it1).begin(),(*it1).end(),retPtr);
7617 * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode computed
7618 * from a zip representation of a surjective format (returned e.g. by
7619 * \ref ParaMEDMEM::DataArrayDouble::findCommonTuples() "DataArrayDouble::findCommonTuples()"
7620 * for example). The result array minimizes the permutation. <br>
7621 * For more info on renumbering see \ref numbering. <br>
7623 * - \a nbOfOldTuples: 10
7624 * - \a arr : [0,3, 5,7,9]
7625 * - \a arrIBg : [0,2,5]
7626 * - \a newNbOfTuples: 7
7627 * - result array : [0,1,2,0,3,4,5,4,6,4]
7629 * \param [in] nbOfOldTuples - number of tuples in the initial array \a arr.
7630 * \param [in] arr - the array of tuple indices grouped by \a arrIBg array.
7631 * \param [in] arrIBg - the array dividing all indices stored in \a arr into groups of
7632 * (indices of) equal values. Its every element (except the last one) points to
7633 * the first element of a group of equal values.
7634 * \param [in] arrIEnd - specifies the end of \a arrIBg, so that the last element of \a
7635 * arrIBg is \a arrIEnd[ -1 ].
7636 * \param [out] newNbOfTuples - number of tuples after surjection application.
7637 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7638 * array using decrRef() as it is no more needed.
7639 * \throw If any value of \a arr breaks condition ( 0 <= \a arr[ i ] < \a nbOfOldTuples ).
7641 DataArrayInt *DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(int nbOfOldTuples, const int *arr, const int *arrIBg, const int *arrIEnd, int &newNbOfTuples)
7643 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7644 ret->alloc(nbOfOldTuples,1);
7645 int *pt=ret->getPointer();
7646 std::fill(pt,pt+nbOfOldTuples,-1);
7647 int nbOfGrps=((int)std::distance(arrIBg,arrIEnd))-1;
7648 const int *cIPtr=arrIBg;
7649 for(int i=0;i<nbOfGrps;i++)
7650 pt[arr[cIPtr[i]]]=-(i+2);
7652 for(int iNode=0;iNode<nbOfOldTuples;iNode++)
7660 int grpId=-(pt[iNode]+2);
7661 for(int j=cIPtr[grpId];j<cIPtr[grpId+1];j++)
7663 if(arr[j]>=0 && arr[j]<nbOfOldTuples)
7667 std::ostringstream oss; oss << "DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2 : With element #" << j << " value is " << arr[j] << " should be in [0," << nbOfOldTuples << ") !";
7668 throw INTERP_KERNEL::Exception(oss.str().c_str());
7675 newNbOfTuples=newNb;
7680 * Returns a new DataArrayInt containing a renumbering map in "New to Old" mode,
7681 * which if applied to \a this array would make it sorted ascendingly.
7682 * For more info on renumbering see \ref numbering. <br>
7684 * - \a this: [2,0,1,1,0,1,2,0,1,1,0,0]
7685 * - result: [10,0,5,6,1,7,11,2,8,9,3,4]
7686 * - after applying result to \a this: [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2]
7688 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7689 * array using decrRef() as it is no more needed.
7690 * \throw If \a this is not allocated.
7691 * \throw If \a this->getNumberOfComponents() != 1.
7693 DataArrayInt *DataArrayInt::buildPermArrPerLevel() const
7696 if(getNumberOfComponents()!=1)
7697 throw INTERP_KERNEL::Exception("DataArrayInt::buildPermArrPerLevel : number of components must == 1 !");
7698 int nbOfTuples=getNumberOfTuples();
7699 const int *pt=getConstPointer();
7700 std::map<int,int> m;
7701 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7702 ret->alloc(nbOfTuples,1);
7703 int *opt=ret->getPointer();
7704 for(int i=0;i<nbOfTuples;i++,pt++,opt++)
7707 std::map<int,int>::iterator it=m.find(val);
7716 m.insert(std::pair<int,int>(val,1));
7720 for(std::map<int,int>::iterator it=m.begin();it!=m.end();it++)
7722 int vt=(*it).second;
7726 pt=getConstPointer();
7727 opt=ret->getPointer();
7728 for(int i=0;i<nbOfTuples;i++,pt++,opt++)
7735 * Checks if contents of \a this array are equal to that of an array filled with
7736 * iota(). This method is particularly useful for DataArrayInt instances that represent
7737 * a renumbering array to check the real need in renumbering. In this case it is better to use isIdentity2
7738 * method of isIdentity method.
7740 * \return bool - \a true if \a this array contents == \a range( \a this->getNumberOfTuples())
7741 * \throw If \a this is not allocated.
7742 * \throw If \a this->getNumberOfComponents() != 1.
7745 bool DataArrayInt::isIdentity() const
7748 if(getNumberOfComponents()!=1)
7750 int nbOfTuples(getNumberOfTuples());
7751 const int *pt=getConstPointer();
7752 for(int i=0;i<nbOfTuples;i++,pt++)
7759 * This method is stronger than isIdentity method. This method checks than \a this can be considered as an identity function
7760 * of a set having \a sizeExpected elements into itself.
7762 * \param [in] sizeExpected - The number of elements
7763 * \return bool - \a true if \a this array contents == \a range( \a this->getNumberOfTuples()) and if \a this has \a sizeExpected tuples in it.
7765 * \throw If \a this is not allocated.
7766 * \throw If \a this->getNumberOfComponents() != 1.
7769 bool DataArrayInt::isIdentity2(int sizeExpected) const
7771 bool ret0(isIdentity());
7774 return getNumberOfTuples()==sizeExpected;
7778 * Checks if all values in \a this array are equal to \a val.
7779 * \param [in] val - value to check equality of array values to.
7780 * \return bool - \a true if all values are \a val.
7781 * \throw If \a this is not allocated.
7782 * \throw If \a this->getNumberOfComponents() != 1
7784 bool DataArrayInt::isUniform(int val) const
7787 if(getNumberOfComponents()!=1)
7788 throw INTERP_KERNEL::Exception("DataArrayInt::isUniform : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
7789 int nbOfTuples=getNumberOfTuples();
7790 const int *w=getConstPointer();
7791 const int *end2=w+nbOfTuples;
7799 * Creates a new DataArrayDouble and assigns all (textual and numerical) data of \a this
7800 * array to the new one.
7801 * \return DataArrayDouble * - the new instance of DataArrayInt.
7803 DataArrayDouble *DataArrayInt::convertToDblArr() const
7806 DataArrayDouble *ret=DataArrayDouble::New();
7807 ret->alloc(getNumberOfTuples(),getNumberOfComponents());
7808 std::size_t nbOfVals=getNbOfElems();
7809 const int *src=getConstPointer();
7810 double *dest=ret->getPointer();
7811 std::copy(src,src+nbOfVals,dest);
7812 ret->copyStringInfoFrom(*this);
7817 * Returns a shorten copy of \a this array. The new DataArrayInt contains all
7818 * tuples starting from the \a tupleIdBg-th tuple and including all tuples located before
7819 * the \a tupleIdEnd-th one. This methods has a similar behavior as std::string::substr().
7820 * This method is a specialization of selectByTupleId2().
7821 * \param [in] tupleIdBg - index of the first tuple to copy from \a this array.
7822 * \param [in] tupleIdEnd - index of the tuple before which the tuples to copy are located.
7823 * If \a tupleIdEnd == -1, all the tuples till the end of \a this array are copied.
7824 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7825 * is to delete using decrRef() as it is no more needed.
7826 * \throw If \a tupleIdBg < 0.
7827 * \throw If \a tupleIdBg > \a this->getNumberOfTuples().
7828 \throw If \a tupleIdEnd != -1 && \a tupleIdEnd < \a this->getNumberOfTuples().
7829 * \sa DataArrayInt::selectByTupleId2
7831 DataArrayInt *DataArrayInt::substr(int tupleIdBg, int tupleIdEnd) const
7834 int nbt=getNumberOfTuples();
7836 throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter must be greater than 0 !");
7838 throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter is greater than number of tuples !");
7839 int trueEnd=tupleIdEnd;
7843 throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter is greater or equal than number of tuples !");
7847 int nbComp=getNumberOfComponents();
7848 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7849 ret->alloc(trueEnd-tupleIdBg,nbComp);
7850 ret->copyStringInfoFrom(*this);
7851 std::copy(getConstPointer()+tupleIdBg*nbComp,getConstPointer()+trueEnd*nbComp,ret->getPointer());
7856 * Changes the number of components within \a this array so that its raw data **does
7857 * not** change, instead splitting this data into tuples changes.
7858 * \warning This method erases all (name and unit) component info set before!
7859 * \param [in] newNbOfComp - number of components for \a this array to have.
7860 * \throw If \a this is not allocated
7861 * \throw If getNbOfElems() % \a newNbOfCompo != 0.
7862 * \throw If \a newNbOfCompo is lower than 1.
7863 * \throw If the rearrange method would lead to a number of tuples higher than 2147483647 (maximal capacity of int32 !).
7864 * \warning This method erases all (name and unit) component info set before!
7866 void DataArrayInt::rearrange(int newNbOfCompo)
7870 throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : input newNbOfCompo must be > 0 !");
7871 std::size_t nbOfElems=getNbOfElems();
7872 if(nbOfElems%newNbOfCompo!=0)
7873 throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : nbOfElems%newNbOfCompo!=0 !");
7874 if(nbOfElems/newNbOfCompo>(std::size_t)std::numeric_limits<int>::max())
7875 throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : the rearrangement leads to too high number of tuples (> 2147483647) !");
7876 _info_on_compo.clear();
7877 _info_on_compo.resize(newNbOfCompo);
7882 * Changes the number of components within \a this array to be equal to its number
7883 * of tuples, and inversely its number of tuples to become equal to its number of
7884 * components. So that its raw data **does not** change, instead splitting this
7885 * data into tuples changes.
7886 * \warning This method erases all (name and unit) component info set before!
7887 * \warning Do not confuse this method with fromNoInterlace() and toNoInterlace()!
7888 * \throw If \a this is not allocated.
7891 void DataArrayInt::transpose()
7894 int nbOfTuples=getNumberOfTuples();
7895 rearrange(nbOfTuples);
7899 * Returns a shorten or extended copy of \a this array. If \a newNbOfComp is less
7900 * than \a this->getNumberOfComponents() then the result array is shorten as each tuple
7901 * is truncated to have \a newNbOfComp components, keeping first components. If \a
7902 * newNbOfComp is more than \a this->getNumberOfComponents() then the result array is
7903 * expanded as each tuple is populated with \a dftValue to have \a newNbOfComp
7905 * \param [in] newNbOfComp - number of components for the new array to have.
7906 * \param [in] dftValue - value assigned to new values added to the new array.
7907 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
7908 * is to delete using decrRef() as it is no more needed.
7909 * \throw If \a this is not allocated.
7911 DataArrayInt *DataArrayInt::changeNbOfComponents(int newNbOfComp, int dftValue) const
7914 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7915 ret->alloc(getNumberOfTuples(),newNbOfComp);
7916 const int *oldc=getConstPointer();
7917 int *nc=ret->getPointer();
7918 int nbOfTuples=getNumberOfTuples();
7919 int oldNbOfComp=getNumberOfComponents();
7920 int dim=std::min(oldNbOfComp,newNbOfComp);
7921 for(int i=0;i<nbOfTuples;i++)
7925 nc[newNbOfComp*i+j]=oldc[i*oldNbOfComp+j];
7926 for(;j<newNbOfComp;j++)
7927 nc[newNbOfComp*i+j]=dftValue;
7929 ret->setName(getName());
7930 for(int i=0;i<dim;i++)
7931 ret->setInfoOnComponent(i,getInfoOnComponent(i));
7932 ret->setName(getName());
7937 * Changes number of tuples in the array. If the new number of tuples is smaller
7938 * than the current number the array is truncated, otherwise the array is extended.
7939 * \param [in] nbOfTuples - new number of tuples.
7940 * \throw If \a this is not allocated.
7941 * \throw If \a nbOfTuples is negative.
7943 void DataArrayInt::reAlloc(int nbOfTuples)
7946 throw INTERP_KERNEL::Exception("DataArrayInt::reAlloc : input new number of tuples should be >=0 !");
7948 _mem.reAlloc(getNumberOfComponents()*(std::size_t)nbOfTuples);
7954 * Returns a copy of \a this array composed of selected components.
7955 * The new DataArrayInt has the same number of tuples but includes components
7956 * specified by \a compoIds parameter. So that getNbOfElems() of the result array
7957 * can be either less, same or more than \a this->getNbOfElems().
7958 * \param [in] compoIds - sequence of zero based indices of components to include
7959 * into the new array.
7960 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7961 * is to delete using decrRef() as it is no more needed.
7962 * \throw If \a this is not allocated.
7963 * \throw If a component index (\a i) is not valid:
7964 * \a i < 0 || \a i >= \a this->getNumberOfComponents().
7966 * \if ENABLE_EXAMPLES
7967 * \ref py_mcdataarrayint_keepselectedcomponents "Here is a Python example".
7970 DataArrayInt *DataArrayInt::keepSelectedComponents(const std::vector<int>& compoIds) const
7973 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
7974 int newNbOfCompo=(int)compoIds.size();
7975 int oldNbOfCompo=getNumberOfComponents();
7976 for(std::vector<int>::const_iterator it=compoIds.begin();it!=compoIds.end();it++)
7977 DataArray::CheckValueInRange(oldNbOfCompo,(*it),"keepSelectedComponents invalid requested component");
7978 int nbOfTuples=getNumberOfTuples();
7979 ret->alloc(nbOfTuples,newNbOfCompo);
7980 ret->copyPartOfStringInfoFrom(*this,compoIds);
7981 const int *oldc=getConstPointer();
7982 int *nc=ret->getPointer();
7983 for(int i=0;i<nbOfTuples;i++)
7984 for(int j=0;j<newNbOfCompo;j++,nc++)
7985 *nc=oldc[i*oldNbOfCompo+compoIds[j]];
7990 * Appends components of another array to components of \a this one, tuple by tuple.
7991 * So that the number of tuples of \a this array remains the same and the number of
7992 * components increases.
7993 * \param [in] other - the DataArrayInt to append to \a this one.
7994 * \throw If \a this is not allocated.
7995 * \throw If \a this and \a other arrays have different number of tuples.
7997 * \if ENABLE_EXAMPLES
7998 * \ref cpp_mcdataarrayint_meldwith "Here is a C++ example".
8000 * \ref py_mcdataarrayint_meldwith "Here is a Python example".
8003 void DataArrayInt::meldWith(const DataArrayInt *other)
8006 throw INTERP_KERNEL::Exception("DataArrayInt::meldWith : DataArrayInt pointer in input is NULL !");
8008 other->checkAllocated();
8009 int nbOfTuples=getNumberOfTuples();
8010 if(nbOfTuples!=other->getNumberOfTuples())
8011 throw INTERP_KERNEL::Exception("DataArrayInt::meldWith : mismatch of number of tuples !");
8012 int nbOfComp1=getNumberOfComponents();
8013 int nbOfComp2=other->getNumberOfComponents();
8014 int *newArr=(int *)malloc(nbOfTuples*(nbOfComp1+nbOfComp2)*sizeof(int));
8016 const int *inp1=getConstPointer();
8017 const int *inp2=other->getConstPointer();
8018 for(int i=0;i<nbOfTuples;i++,inp1+=nbOfComp1,inp2+=nbOfComp2)
8020 w=std::copy(inp1,inp1+nbOfComp1,w);
8021 w=std::copy(inp2,inp2+nbOfComp2,w);
8023 useArray(newArr,true,C_DEALLOC,nbOfTuples,nbOfComp1+nbOfComp2);
8024 std::vector<int> compIds(nbOfComp2);
8025 for(int i=0;i<nbOfComp2;i++)
8026 compIds[i]=nbOfComp1+i;
8027 copyPartOfStringInfoFrom2(compIds,*other);
8031 * Copy all components in a specified order from another DataArrayInt.
8032 * The specified components become the first ones in \a this array.
8033 * Both numerical and textual data is copied. The number of tuples in \a this and
8034 * the other array can be different.
8035 * \param [in] a - the array to copy data from.
8036 * \param [in] compoIds - sequence of zero based indices of components, data of which is
8038 * \throw If \a a is NULL.
8039 * \throw If \a compoIds.size() != \a a->getNumberOfComponents().
8040 * \throw If \a compoIds[i] < 0 or \a compoIds[i] > \a this->getNumberOfComponents().
8042 * \if ENABLE_EXAMPLES
8043 * \ref py_mcdataarrayint_setselectedcomponents "Here is a Python example".
8046 void DataArrayInt::setSelectedComponents(const DataArrayInt *a, const std::vector<int>& compoIds)
8049 throw INTERP_KERNEL::Exception("DataArrayInt::setSelectedComponents : input DataArrayInt is NULL !");
8051 a->checkAllocated();
8052 copyPartOfStringInfoFrom2(compoIds,*a);
8053 std::size_t partOfCompoSz=compoIds.size();
8054 int nbOfCompo=getNumberOfComponents();
8055 int nbOfTuples=std::min(getNumberOfTuples(),a->getNumberOfTuples());
8056 const int *ac=a->getConstPointer();
8057 int *nc=getPointer();
8058 for(int i=0;i<nbOfTuples;i++)
8059 for(std::size_t j=0;j<partOfCompoSz;j++,ac++)
8060 nc[nbOfCompo*i+compoIds[j]]=*ac;
8064 * Copy all values from another DataArrayInt into specified tuples and components
8065 * of \a this array. Textual data is not copied.
8066 * The tree parameters defining set of indices of tuples and components are similar to
8067 * the tree parameters of the Python function \c range(\c start,\c stop,\c step).
8068 * \param [in] a - the array to copy values from.
8069 * \param [in] bgTuples - index of the first tuple of \a this array to assign values to.
8070 * \param [in] endTuples - index of the tuple before which the tuples to assign to
8072 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
8073 * \param [in] bgComp - index of the first component of \a this array to assign values to.
8074 * \param [in] endComp - index of the component before which the components to assign
8076 * \param [in] stepComp - index increment to get index of the next component to assign to.
8077 * \param [in] strictCompoCompare - if \a true (by default), then \a a->getNumberOfComponents()
8078 * must be equal to the number of columns to assign to, else an
8079 * exception is thrown; if \a false, then it is only required that \a
8080 * a->getNbOfElems() equals to number of values to assign to (this condition
8081 * must be respected even if \a strictCompoCompare is \a true). The number of
8082 * values to assign to is given by following Python expression:
8083 * \a nbTargetValues =
8084 * \c len(\c range(\a bgTuples,\a endTuples,\a stepTuples)) *
8085 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
8086 * \throw If \a a is NULL.
8087 * \throw If \a a is not allocated.
8088 * \throw If \a this is not allocated.
8089 * \throw If parameters specifying tuples and components to assign to do not give a
8090 * non-empty range of increasing indices.
8091 * \throw If \a a->getNbOfElems() != \a nbTargetValues.
8092 * \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
8093 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
8095 * \if ENABLE_EXAMPLES
8096 * \ref py_mcdataarrayint_setpartofvalues1 "Here is a Python example".
8099 void DataArrayInt::setPartOfValues1(const DataArrayInt *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
8102 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues1 : DataArrayInt pointer in input is NULL !");
8103 const char msg[]="DataArrayInt::setPartOfValues1";
8105 a->checkAllocated();
8106 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
8107 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
8108 int nbComp=getNumberOfComponents();
8109 int nbOfTuples=getNumberOfTuples();
8110 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
8111 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
8112 bool assignTech=true;
8113 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
8115 if(strictCompoCompare)
8116 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
8120 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
8123 int *pt=getPointer()+bgTuples*nbComp+bgComp;
8124 const int *srcPt=a->getConstPointer();
8127 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8128 for(int j=0;j<newNbOfComp;j++,srcPt++)
8129 pt[j*stepComp]=*srcPt;
8133 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8135 const int *srcPt2=srcPt;
8136 for(int j=0;j<newNbOfComp;j++,srcPt2++)
8137 pt[j*stepComp]=*srcPt2;
8143 * Assign a given value to values at specified tuples and components of \a this array.
8144 * The tree parameters defining set of indices of tuples and components are similar to
8145 * the tree parameters of the Python function \c range(\c start,\c stop,\c step)..
8146 * \param [in] a - the value to assign.
8147 * \param [in] bgTuples - index of the first tuple of \a this array to assign to.
8148 * \param [in] endTuples - index of the tuple before which the tuples to assign to
8150 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
8151 * \param [in] bgComp - index of the first component of \a this array to assign to.
8152 * \param [in] endComp - index of the component before which the components to assign
8154 * \param [in] stepComp - index increment to get index of the next component to assign to.
8155 * \throw If \a this is not allocated.
8156 * \throw If parameters specifying tuples and components to assign to, do not give a
8157 * non-empty range of increasing indices or indices are out of a valid range
8158 * for \c this array.
8160 * \if ENABLE_EXAMPLES
8161 * \ref py_mcdataarrayint_setpartofvaluessimple1 "Here is a Python example".
8164 void DataArrayInt::setPartOfValuesSimple1(int a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp)
8166 const char msg[]="DataArrayInt::setPartOfValuesSimple1";
8168 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
8169 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
8170 int nbComp=getNumberOfComponents();
8171 int nbOfTuples=getNumberOfTuples();
8172 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
8173 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
8174 int *pt=getPointer()+bgTuples*nbComp+bgComp;
8175 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8176 for(int j=0;j<newNbOfComp;j++)
8182 * Copy all values from another DataArrayInt (\a a) into specified tuples and
8183 * components of \a this array. Textual data is not copied.
8184 * The tuples and components to assign to are defined by C arrays of indices.
8185 * There are two *modes of usage*:
8186 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
8187 * of \a a is assigned to its own location within \a this array.
8188 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
8189 * components of every specified tuple of \a this array. In this mode it is required
8190 * that \a a->getNumberOfComponents() equals to the number of specified components.
8192 * \param [in] a - the array to copy values from.
8193 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
8194 * assign values of \a a to.
8195 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
8196 * pointer to a tuple index <em>(pi)</em> varies as this:
8197 * \a bgTuples <= \a pi < \a endTuples.
8198 * \param [in] bgComp - pointer to an array of component indices of \a this array to
8199 * assign values of \a a to.
8200 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
8201 * pointer to a component index <em>(pi)</em> varies as this:
8202 * \a bgComp <= \a pi < \a endComp.
8203 * \param [in] strictCompoCompare - this parameter is checked only if the
8204 * *mode of usage* is the first; if it is \a true (default),
8205 * then \a a->getNumberOfComponents() must be equal
8206 * to the number of specified columns, else this is not required.
8207 * \throw If \a a is NULL.
8208 * \throw If \a a is not allocated.
8209 * \throw If \a this is not allocated.
8210 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
8211 * out of a valid range for \a this array.
8212 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
8213 * if <em> a->getNumberOfComponents() != (endComp - bgComp) </em>.
8214 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
8215 * <em> a->getNumberOfComponents() != (endComp - bgComp)</em>.
8217 * \if ENABLE_EXAMPLES
8218 * \ref py_mcdataarrayint_setpartofvalues2 "Here is a Python example".
8221 void DataArrayInt::setPartOfValues2(const DataArrayInt *a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
8224 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues2 : DataArrayInt pointer in input is NULL !");
8225 const char msg[]="DataArrayInt::setPartOfValues2";
8227 a->checkAllocated();
8228 int nbComp=getNumberOfComponents();
8229 int nbOfTuples=getNumberOfTuples();
8230 for(const int *z=bgComp;z!=endComp;z++)
8231 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
8232 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
8233 int newNbOfComp=(int)std::distance(bgComp,endComp);
8234 bool assignTech=true;
8235 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
8237 if(strictCompoCompare)
8238 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
8242 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
8245 int *pt=getPointer();
8246 const int *srcPt=a->getConstPointer();
8249 for(const int *w=bgTuples;w!=endTuples;w++)
8251 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8252 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
8254 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt;
8260 for(const int *w=bgTuples;w!=endTuples;w++)
8262 const int *srcPt2=srcPt;
8263 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8264 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
8266 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt2;
8273 * Assign a given value to values at specified tuples and components of \a this array.
8274 * The tuples and components to assign to are defined by C arrays of indices.
8275 * \param [in] a - the value to assign.
8276 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
8278 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
8279 * pointer to a tuple index (\a pi) varies as this:
8280 * \a bgTuples <= \a pi < \a endTuples.
8281 * \param [in] bgComp - pointer to an array of component indices of \a this array to
8283 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
8284 * pointer to a component index (\a pi) varies as this:
8285 * \a bgComp <= \a pi < \a endComp.
8286 * \throw If \a this is not allocated.
8287 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
8288 * out of a valid range for \a this array.
8290 * \if ENABLE_EXAMPLES
8291 * \ref py_mcdataarrayint_setpartofvaluessimple2 "Here is a Python example".
8294 void DataArrayInt::setPartOfValuesSimple2(int a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp)
8297 int nbComp=getNumberOfComponents();
8298 int nbOfTuples=getNumberOfTuples();
8299 for(const int *z=bgComp;z!=endComp;z++)
8300 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
8301 int *pt=getPointer();
8302 for(const int *w=bgTuples;w!=endTuples;w++)
8303 for(const int *z=bgComp;z!=endComp;z++)
8305 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8306 pt[(std::size_t)(*w)*nbComp+(*z)]=a;
8311 * Copy all values from another DataArrayInt (\a a) into specified tuples and
8312 * components of \a this array. Textual data is not copied.
8313 * The tuples to assign to are defined by a C array of indices.
8314 * The components to assign to are defined by three values similar to parameters of
8315 * the Python function \c range(\c start,\c stop,\c step).
8316 * There are two *modes of usage*:
8317 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
8318 * of \a a is assigned to its own location within \a this array.
8319 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
8320 * components of every specified tuple of \a this array. In this mode it is required
8321 * that \a a->getNumberOfComponents() equals to the number of specified components.
8323 * \param [in] a - the array to copy values from.
8324 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
8325 * assign values of \a a to.
8326 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
8327 * pointer to a tuple index <em>(pi)</em> varies as this:
8328 * \a bgTuples <= \a pi < \a endTuples.
8329 * \param [in] bgComp - index of the first component of \a this array to assign to.
8330 * \param [in] endComp - index of the component before which the components to assign
8332 * \param [in] stepComp - index increment to get index of the next component to assign to.
8333 * \param [in] strictCompoCompare - this parameter is checked only in the first
8334 * *mode of usage*; if \a strictCompoCompare is \a true (default),
8335 * then \a a->getNumberOfComponents() must be equal
8336 * to the number of specified columns, else this is not required.
8337 * \throw If \a a is NULL.
8338 * \throw If \a a is not allocated.
8339 * \throw If \a this is not allocated.
8340 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
8342 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
8343 * if <em> a->getNumberOfComponents()</em> is unequal to the number of components
8344 * defined by <em>(bgComp,endComp,stepComp)</em>.
8345 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
8346 * <em> a->getNumberOfComponents()</em> is unequal to the number of components
8347 * defined by <em>(bgComp,endComp,stepComp)</em>.
8348 * \throw If parameters specifying components to assign to, do not give a
8349 * non-empty range of increasing indices or indices are out of a valid range
8350 * for \c this array.
8352 * \if ENABLE_EXAMPLES
8353 * \ref py_mcdataarrayint_setpartofvalues3 "Here is a Python example".
8356 void DataArrayInt::setPartOfValues3(const DataArrayInt *a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
8359 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues3 : DataArrayInt pointer in input is NULL !");
8360 const char msg[]="DataArrayInt::setPartOfValues3";
8362 a->checkAllocated();
8363 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
8364 int nbComp=getNumberOfComponents();
8365 int nbOfTuples=getNumberOfTuples();
8366 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
8367 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
8368 bool assignTech=true;
8369 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
8371 if(strictCompoCompare)
8372 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
8376 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
8379 int *pt=getPointer()+bgComp;
8380 const int *srcPt=a->getConstPointer();
8383 for(const int *w=bgTuples;w!=endTuples;w++)
8384 for(int j=0;j<newNbOfComp;j++,srcPt++)
8386 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8387 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt;
8392 for(const int *w=bgTuples;w!=endTuples;w++)
8394 const int *srcPt2=srcPt;
8395 for(int j=0;j<newNbOfComp;j++,srcPt2++)
8397 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8398 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt2;
8405 * Assign a given value to values at specified tuples and components of \a this array.
8406 * The tuples to assign to are defined by a C array of indices.
8407 * The components to assign to are defined by three values similar to parameters of
8408 * the Python function \c range(\c start,\c stop,\c step).
8409 * \param [in] a - the value to assign.
8410 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
8412 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
8413 * pointer to a tuple index <em>(pi)</em> varies as this:
8414 * \a bgTuples <= \a pi < \a endTuples.
8415 * \param [in] bgComp - index of the first component of \a this array to assign to.
8416 * \param [in] endComp - index of the component before which the components to assign
8418 * \param [in] stepComp - index increment to get index of the next component to assign to.
8419 * \throw If \a this is not allocated.
8420 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
8422 * \throw If parameters specifying components to assign to, do not give a
8423 * non-empty range of increasing indices or indices are out of a valid range
8424 * for \c this array.
8426 * \if ENABLE_EXAMPLES
8427 * \ref py_mcdataarrayint_setpartofvaluessimple3 "Here is a Python example".
8430 void DataArrayInt::setPartOfValuesSimple3(int a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp)
8432 const char msg[]="DataArrayInt::setPartOfValuesSimple3";
8434 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
8435 int nbComp=getNumberOfComponents();
8436 int nbOfTuples=getNumberOfTuples();
8437 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
8438 int *pt=getPointer()+bgComp;
8439 for(const int *w=bgTuples;w!=endTuples;w++)
8440 for(int j=0;j<newNbOfComp;j++)
8442 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8443 pt[(std::size_t)(*w)*nbComp+j*stepComp]=a;
8447 void DataArrayInt::setPartOfValues4(const DataArrayInt *a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
8450 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues4 : input DataArrayInt is NULL !");
8451 const char msg[]="DataArrayInt::setPartOfValues4";
8453 a->checkAllocated();
8454 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
8455 int newNbOfComp=(int)std::distance(bgComp,endComp);
8456 int nbComp=getNumberOfComponents();
8457 for(const int *z=bgComp;z!=endComp;z++)
8458 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
8459 int nbOfTuples=getNumberOfTuples();
8460 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
8461 bool assignTech=true;
8462 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
8464 if(strictCompoCompare)
8465 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
8469 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
8472 const int *srcPt=a->getConstPointer();
8473 int *pt=getPointer()+bgTuples*nbComp;
8476 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8477 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
8482 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8484 const int *srcPt2=srcPt;
8485 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
8491 void DataArrayInt::setPartOfValuesSimple4(int a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp)
8493 const char msg[]="DataArrayInt::setPartOfValuesSimple4";
8495 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
8496 int nbComp=getNumberOfComponents();
8497 for(const int *z=bgComp;z!=endComp;z++)
8498 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
8499 int nbOfTuples=getNumberOfTuples();
8500 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
8501 int *pt=getPointer()+bgTuples*nbComp;
8502 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8503 for(const int *z=bgComp;z!=endComp;z++)
8508 * Copy some tuples from another DataArrayInt into specified tuples
8509 * of \a this array. Textual data is not copied. Both arrays must have equal number of
8511 * Both the tuples to assign and the tuples to assign to are defined by a DataArrayInt.
8512 * All components of selected tuples are copied.
8513 * \param [in] a - the array to copy values from.
8514 * \param [in] tuplesSelec - the array specifying both source tuples of \a a and
8515 * target tuples of \a this. \a tuplesSelec has two components, and the
8516 * first component specifies index of the source tuple and the second
8517 * one specifies index of the target tuple.
8518 * \throw If \a this is not allocated.
8519 * \throw If \a a is NULL.
8520 * \throw If \a a is not allocated.
8521 * \throw If \a tuplesSelec is NULL.
8522 * \throw If \a tuplesSelec is not allocated.
8523 * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
8524 * \throw If \a tuplesSelec->getNumberOfComponents() != 2.
8525 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
8526 * the corresponding (\a this or \a a) array.
8528 void DataArrayInt::setPartOfValuesAdv(const DataArrayInt *a, const DataArrayInt *tuplesSelec)
8530 if(!a || !tuplesSelec)
8531 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : DataArrayInt pointer in input is NULL !");
8533 a->checkAllocated();
8534 tuplesSelec->checkAllocated();
8535 int nbOfComp=getNumberOfComponents();
8536 if(nbOfComp!=a->getNumberOfComponents())
8537 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : This and a do not have the same number of components !");
8538 if(tuplesSelec->getNumberOfComponents()!=2)
8539 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : Expecting to have a tuple selector DataArrayInt instance with exactly 2 components !");
8540 int thisNt=getNumberOfTuples();
8541 int aNt=a->getNumberOfTuples();
8542 int *valsToSet=getPointer();
8543 const int *valsSrc=a->getConstPointer();
8544 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple+=2)
8546 if(tuple[1]>=0 && tuple[1]<aNt)
8548 if(tuple[0]>=0 && tuple[0]<thisNt)
8549 std::copy(valsSrc+nbOfComp*tuple[1],valsSrc+nbOfComp*(tuple[1]+1),valsToSet+nbOfComp*tuple[0]);
8552 std::ostringstream oss; oss << "DataArrayInt::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
8553 oss << " of 'tuplesSelec' request of tuple id #" << tuple[0] << " in 'this' ! It should be in [0," << thisNt << ") !";
8554 throw INTERP_KERNEL::Exception(oss.str().c_str());
8559 std::ostringstream oss; oss << "DataArrayInt::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
8560 oss << " of 'tuplesSelec' request of tuple id #" << tuple[1] << " in 'a' ! It should be in [0," << aNt << ") !";
8561 throw INTERP_KERNEL::Exception(oss.str().c_str());
8567 * Copy some tuples from another DataArrayInt (\a aBase) into contiguous tuples
8568 * of \a this array. Textual data is not copied. Both arrays must have equal number of
8570 * The tuples to assign to are defined by index of the first tuple, and
8571 * their number is defined by \a tuplesSelec->getNumberOfTuples().
8572 * The tuples to copy are defined by values of a DataArrayInt.
8573 * All components of selected tuples are copied.
8574 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
8576 * \param [in] aBase - the array to copy values from.
8577 * \param [in] tuplesSelec - the array specifying tuples of \a aBase to copy.
8578 * \throw If \a this is not allocated.
8579 * \throw If \a aBase is NULL.
8580 * \throw If \a aBase is not allocated.
8581 * \throw If \a tuplesSelec is NULL.
8582 * \throw If \a tuplesSelec is not allocated.
8583 * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
8584 * \throw If \a tuplesSelec->getNumberOfComponents() != 1.
8585 * \throw If <em>tupleIdStart + tuplesSelec->getNumberOfTuples() > this->getNumberOfTuples().</em>
8586 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
8589 void DataArrayInt::setContigPartOfSelectedValues(int tupleIdStart, const DataArray *aBase, const DataArrayInt *tuplesSelec)
8591 if(!aBase || !tuplesSelec)
8592 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : input DataArray is NULL !");
8593 const DataArrayInt *a=dynamic_cast<const DataArrayInt *>(aBase);
8595 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : input DataArray aBase is not a DataArrayInt !");
8597 a->checkAllocated();
8598 tuplesSelec->checkAllocated();
8599 int nbOfComp=getNumberOfComponents();
8600 if(nbOfComp!=a->getNumberOfComponents())
8601 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : This and a do not have the same number of components !");
8602 if(tuplesSelec->getNumberOfComponents()!=1)
8603 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : Expecting to have a tuple selector DataArrayInt instance with exactly 1 component !");
8604 int thisNt=getNumberOfTuples();
8605 int aNt=a->getNumberOfTuples();
8606 int nbOfTupleToWrite=tuplesSelec->getNumberOfTuples();
8607 int *valsToSet=getPointer()+tupleIdStart*nbOfComp;
8608 if(tupleIdStart+nbOfTupleToWrite>thisNt)
8609 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : invalid number range of values to write !");
8610 const int *valsSrc=a->getConstPointer();
8611 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple++,valsToSet+=nbOfComp)
8613 if(*tuple>=0 && *tuple<aNt)
8615 std::copy(valsSrc+nbOfComp*(*tuple),valsSrc+nbOfComp*(*tuple+1),valsToSet);
8619 std::ostringstream oss; oss << "DataArrayInt::setContigPartOfSelectedValues : Tuple #" << std::distance(tuplesSelec->begin(),tuple);
8620 oss << " of 'tuplesSelec' request of tuple id #" << *tuple << " in 'a' ! It should be in [0," << aNt << ") !";
8621 throw INTERP_KERNEL::Exception(oss.str().c_str());
8627 * Copy some tuples from another DataArrayInt (\a aBase) into contiguous tuples
8628 * of \a this array. Textual data is not copied. Both arrays must have equal number of
8630 * The tuples to copy are defined by three values similar to parameters of
8631 * the Python function \c range(\c start,\c stop,\c step).
8632 * The tuples to assign to are defined by index of the first tuple, and
8633 * their number is defined by number of tuples to copy.
8634 * All components of selected tuples are copied.
8635 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
8637 * \param [in] aBase - the array to copy values from.
8638 * \param [in] bg - index of the first tuple to copy of the array \a aBase.
8639 * \param [in] end2 - index of the tuple of \a aBase before which the tuples to copy
8641 * \param [in] step - index increment to get index of the next tuple to copy.
8642 * \throw If \a this is not allocated.
8643 * \throw If \a aBase is NULL.
8644 * \throw If \a aBase is not allocated.
8645 * \throw If <em>this->getNumberOfComponents() != aBase->getNumberOfComponents()</em>.
8646 * \throw If <em>tupleIdStart + len(range(bg,end2,step)) > this->getNumberOfTuples().</em>
8647 * \throw If parameters specifying tuples to copy, do not give a
8648 * non-empty range of increasing indices or indices are out of a valid range
8649 * for the array \a aBase.
8651 void DataArrayInt::setContigPartOfSelectedValues2(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step)
8654 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : input DataArray is NULL !");
8655 const DataArrayInt *a=dynamic_cast<const DataArrayInt *>(aBase);
8657 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : input DataArray aBase is not a DataArrayInt !");
8659 a->checkAllocated();
8660 int nbOfComp=getNumberOfComponents();
8661 const char msg[]="DataArrayInt::setContigPartOfSelectedValues2";
8662 int nbOfTupleToWrite=DataArray::GetNumberOfItemGivenBES(bg,end2,step,msg);
8663 if(nbOfComp!=a->getNumberOfComponents())
8664 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : This and a do not have the same number of components !");
8665 int thisNt=getNumberOfTuples();
8666 int aNt=a->getNumberOfTuples();
8667 int *valsToSet=getPointer()+tupleIdStart*nbOfComp;
8668 if(tupleIdStart+nbOfTupleToWrite>thisNt)
8669 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : invalid number range of values to write !");
8671 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : invalid range of values to read !");
8672 const int *valsSrc=a->getConstPointer()+bg*nbOfComp;
8673 for(int i=0;i<nbOfTupleToWrite;i++,valsToSet+=nbOfComp,valsSrc+=step*nbOfComp)
8675 std::copy(valsSrc,valsSrc+nbOfComp,valsToSet);
8680 * Returns a value located at specified tuple and component.
8681 * This method is equivalent to DataArrayInt::getIJ() except that validity of
8682 * parameters is checked. So this method is safe but expensive if used to go through
8683 * all values of \a this.
8684 * \param [in] tupleId - index of tuple of interest.
8685 * \param [in] compoId - index of component of interest.
8686 * \return double - value located by \a tupleId and \a compoId.
8687 * \throw If \a this is not allocated.
8688 * \throw If condition <em>( 0 <= tupleId < this->getNumberOfTuples() )</em> is violated.
8689 * \throw If condition <em>( 0 <= compoId < this->getNumberOfComponents() )</em> is violated.
8691 int DataArrayInt::getIJSafe(int tupleId, int compoId) const
8694 if(tupleId<0 || tupleId>=getNumberOfTuples())
8696 std::ostringstream oss; oss << "DataArrayInt::getIJSafe : request for tupleId " << tupleId << " should be in [0," << getNumberOfTuples() << ") !";
8697 throw INTERP_KERNEL::Exception(oss.str().c_str());
8699 if(compoId<0 || compoId>=getNumberOfComponents())
8701 std::ostringstream oss; oss << "DataArrayInt::getIJSafe : request for compoId " << compoId << " should be in [0," << getNumberOfComponents() << ") !";
8702 throw INTERP_KERNEL::Exception(oss.str().c_str());
8704 return _mem[tupleId*_info_on_compo.size()+compoId];
8708 * Returns the first value of \a this.
8709 * \return int - the last value of \a this array.
8710 * \throw If \a this is not allocated.
8711 * \throw If \a this->getNumberOfComponents() != 1.
8712 * \throw If \a this->getNumberOfTuples() < 1.
8714 int DataArrayInt::front() const
8717 if(getNumberOfComponents()!=1)
8718 throw INTERP_KERNEL::Exception("DataArrayInt::front : number of components not equal to one !");
8719 int nbOfTuples=getNumberOfTuples();
8721 throw INTERP_KERNEL::Exception("DataArrayInt::front : number of tuples must be >= 1 !");
8722 return *(getConstPointer());
8726 * Returns the last value of \a this.
8727 * \return int - the last value of \a this array.
8728 * \throw If \a this is not allocated.
8729 * \throw If \a this->getNumberOfComponents() != 1.
8730 * \throw If \a this->getNumberOfTuples() < 1.
8732 int DataArrayInt::back() const
8735 if(getNumberOfComponents()!=1)
8736 throw INTERP_KERNEL::Exception("DataArrayInt::back : number of components not equal to one !");
8737 int nbOfTuples=getNumberOfTuples();
8739 throw INTERP_KERNEL::Exception("DataArrayInt::back : number of tuples must be >= 1 !");
8740 return *(getConstPointer()+nbOfTuples-1);
8744 * Assign pointer to one array to a pointer to another appay. Reference counter of
8745 * \a arrayToSet is incremented / decremented.
8746 * \param [in] newArray - the pointer to array to assign to \a arrayToSet.
8747 * \param [in,out] arrayToSet - the pointer to array to assign to.
8749 void DataArrayInt::SetArrayIn(DataArrayInt *newArray, DataArrayInt* &arrayToSet)
8751 if(newArray!=arrayToSet)
8754 arrayToSet->decrRef();
8755 arrayToSet=newArray;
8757 arrayToSet->incrRef();
8761 DataArrayIntIterator *DataArrayInt::iterator()
8763 return new DataArrayIntIterator(this);
8767 * Creates a new DataArrayInt containing IDs (indices) of tuples holding value equal to a
8768 * given one. The ids are sorted in the ascending order.
8769 * \param [in] val - the value to find within \a this.
8770 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8771 * array using decrRef() as it is no more needed.
8772 * \throw If \a this is not allocated.
8773 * \throw If \a this->getNumberOfComponents() != 1.
8774 * \sa DataArrayInt::getIdsEqualTuple
8776 DataArrayInt *DataArrayInt::getIdsEqual(int val) const
8779 if(getNumberOfComponents()!=1)
8780 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqual : the array must have only one component, you can call 'rearrange' method before !");
8781 const int *cptr(getConstPointer());
8782 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8783 int nbOfTuples=getNumberOfTuples();
8784 for(int i=0;i<nbOfTuples;i++,cptr++)
8786 ret->pushBackSilent(i);
8791 * Creates a new DataArrayInt containing IDs (indices) of tuples holding value \b not
8792 * equal to a given one.
8793 * \param [in] val - the value to ignore within \a this.
8794 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8795 * array using decrRef() as it is no more needed.
8796 * \throw If \a this is not allocated.
8797 * \throw If \a this->getNumberOfComponents() != 1.
8799 DataArrayInt *DataArrayInt::getIdsNotEqual(int val) const
8802 if(getNumberOfComponents()!=1)
8803 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotEqual : the array must have only one component, you can call 'rearrange' method before !");
8804 const int *cptr(getConstPointer());
8805 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8806 int nbOfTuples=getNumberOfTuples();
8807 for(int i=0;i<nbOfTuples;i++,cptr++)
8809 ret->pushBackSilent(i);
8814 * Creates a new DataArrayInt containing IDs (indices) of tuples holding tuple equal to those defined by [ \a tupleBg , \a tupleEnd )
8815 * This method is an extension of DataArrayInt::getIdsEqual method.
8817 * \param [in] tupleBg - the begin (included) of the input tuple to find within \a this.
8818 * \param [in] tupleEnd - the end (excluded) of the input tuple to find within \a this.
8819 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8820 * array using decrRef() as it is no more needed.
8821 * \throw If \a this is not allocated.
8822 * \throw If \a this->getNumberOfComponents() != std::distance(tupleBg,tupleEnd).
8823 * \throw If \a this->getNumberOfComponents() is equal to 0.
8824 * \sa DataArrayInt::getIdsEqual
8826 DataArrayInt *DataArrayInt::getIdsEqualTuple(const int *tupleBg, const int *tupleEnd) const
8828 std::size_t nbOfCompoExp(std::distance(tupleBg,tupleEnd));
8830 if(getNumberOfComponents()!=(int)nbOfCompoExp)
8832 std::ostringstream oss; oss << "DataArrayInt::getIdsEqualTuple : mismatch of number of components. Input tuple has " << nbOfCompoExp << " whereas this array has " << getNumberOfComponents() << " components !";
8833 throw INTERP_KERNEL::Exception(oss.str().c_str());
8836 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqualTuple : number of components should be > 0 !");
8837 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8838 const int *bg(begin()),*end2(end()),*work(begin());
8841 work=std::search(work,end2,tupleBg,tupleEnd);
8844 std::size_t pos(std::distance(bg,work));
8845 if(pos%nbOfCompoExp==0)
8846 ret->pushBackSilent(pos/nbOfCompoExp);
8854 * Assigns \a newValue to all elements holding \a oldValue within \a this
8855 * one-dimensional array.
8856 * \param [in] oldValue - the value to replace.
8857 * \param [in] newValue - the value to assign.
8858 * \return int - number of replacements performed.
8859 * \throw If \a this is not allocated.
8860 * \throw If \a this->getNumberOfComponents() != 1.
8862 int DataArrayInt::changeValue(int oldValue, int newValue)
8865 if(getNumberOfComponents()!=1)
8866 throw INTERP_KERNEL::Exception("DataArrayInt::changeValue : the array must have only one component, you can call 'rearrange' method before !");
8867 int *start=getPointer();
8868 int *end2=start+getNbOfElems();
8870 for(int *val=start;val!=end2;val++)
8882 * Creates a new DataArrayInt containing IDs (indices) of tuples holding value equal to
8883 * one of given values.
8884 * \param [in] valsBg - an array of values to find within \a this array.
8885 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
8886 * the last value of \a valsBg is \a valsEnd[ -1 ].
8887 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8888 * array using decrRef() as it is no more needed.
8889 * \throw If \a this->getNumberOfComponents() != 1.
8891 DataArrayInt *DataArrayInt::getIdsEqualList(const int *valsBg, const int *valsEnd) const
8893 if(getNumberOfComponents()!=1)
8894 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqualList : the array must have only one component, you can call 'rearrange' method before !");
8895 std::set<int> vals2(valsBg,valsEnd);
8896 const int *cptr=getConstPointer();
8897 std::vector<int> res;
8898 int nbOfTuples=getNumberOfTuples();
8899 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8900 for(int i=0;i<nbOfTuples;i++,cptr++)
8901 if(vals2.find(*cptr)!=vals2.end())
8902 ret->pushBackSilent(i);
8907 * Creates a new DataArrayInt containing IDs (indices) of tuples holding values \b not
8908 * equal to any of given values.
8909 * \param [in] valsBg - an array of values to ignore within \a this array.
8910 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
8911 * the last value of \a valsBg is \a valsEnd[ -1 ].
8912 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8913 * array using decrRef() as it is no more needed.
8914 * \throw If \a this->getNumberOfComponents() != 1.
8916 DataArrayInt *DataArrayInt::getIdsNotEqualList(const int *valsBg, const int *valsEnd) const
8918 if(getNumberOfComponents()!=1)
8919 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotEqualList : the array must have only one component, you can call 'rearrange' method before !");
8920 std::set<int> vals2(valsBg,valsEnd);
8921 const int *cptr=getConstPointer();
8922 std::vector<int> res;
8923 int nbOfTuples=getNumberOfTuples();
8924 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8925 for(int i=0;i<nbOfTuples;i++,cptr++)
8926 if(vals2.find(*cptr)==vals2.end())
8927 ret->pushBackSilent(i);
8932 * This method is an extension of DataArrayInt::locateValue method because this method works for DataArrayInt with
8933 * any number of components excepted 0 (an INTERP_KERNEL::Exception is thrown in this case).
8934 * This method searches in \b this is there is a tuple that matched the input parameter \b tupl.
8935 * If any the tuple id is returned. If not -1 is returned.
8937 * This method throws an INTERP_KERNEL::Exception if the number of components in \b this mismatches with the size of
8938 * the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
8940 * \return tuple id where \b tupl is. -1 if no such tuple exists in \b this.
8941 * \sa DataArrayInt::search, DataArrayInt::presenceOfTuple.
8943 int DataArrayInt::locateTuple(const std::vector<int>& tupl) const
8946 int nbOfCompo=getNumberOfComponents();
8948 throw INTERP_KERNEL::Exception("DataArrayInt::locateTuple : 0 components in 'this' !");
8949 if(nbOfCompo!=(int)tupl.size())
8951 std::ostringstream oss; oss << "DataArrayInt::locateTuple : 'this' contains " << nbOfCompo << " components and searching for a tuple of length " << tupl.size() << " !";
8952 throw INTERP_KERNEL::Exception(oss.str().c_str());
8954 const int *cptr=getConstPointer();
8955 std::size_t nbOfVals=getNbOfElems();
8956 for(const int *work=cptr;work!=cptr+nbOfVals;)
8958 work=std::search(work,cptr+nbOfVals,tupl.begin(),tupl.end());
8959 if(work!=cptr+nbOfVals)
8961 if(std::distance(cptr,work)%nbOfCompo!=0)
8964 return std::distance(cptr,work)/nbOfCompo;
8971 * This method searches the sequence specified in input parameter \b vals in \b this.
8972 * This works only for DataArrayInt having number of components equal to one (if not an INTERP_KERNEL::Exception will be thrown).
8973 * This method differs from DataArrayInt::locateTuple in that the position is internal raw data is not considered here contrary to DataArrayInt::locateTuple.
8974 * \sa DataArrayInt::locateTuple
8976 int DataArrayInt::search(const std::vector<int>& vals) const
8979 int nbOfCompo=getNumberOfComponents();
8981 throw INTERP_KERNEL::Exception("DataArrayInt::search : works only for DataArrayInt instance with one component !");
8982 const int *cptr=getConstPointer();
8983 std::size_t nbOfVals=getNbOfElems();
8984 const int *loc=std::search(cptr,cptr+nbOfVals,vals.begin(),vals.end());
8985 if(loc!=cptr+nbOfVals)
8986 return std::distance(cptr,loc);
8991 * This method expects to be called when number of components of this is equal to one.
8992 * This method returns the tuple id, if it exists, of the first tuple equal to \b value.
8993 * If not any tuple contains \b value -1 is returned.
8994 * \sa DataArrayInt::presenceOfValue
8996 int DataArrayInt::locateValue(int value) const
8999 if(getNumberOfComponents()!=1)
9000 throw INTERP_KERNEL::Exception("DataArrayInt::presenceOfValue : the array must have only one component, you can call 'rearrange' method before !");
9001 const int *cptr=getConstPointer();
9002 int nbOfTuples=getNumberOfTuples();
9003 const int *ret=std::find(cptr,cptr+nbOfTuples,value);
9004 if(ret!=cptr+nbOfTuples)
9005 return std::distance(cptr,ret);
9010 * This method expects to be called when number of components of this is equal to one.
9011 * This method returns the tuple id, if it exists, of the first tuple so that the value is contained in \b vals.
9012 * If not any tuple contains one of the values contained in 'vals' false is returned.
9013 * \sa DataArrayInt::presenceOfValue
9015 int DataArrayInt::locateValue(const std::vector<int>& vals) const
9018 if(getNumberOfComponents()!=1)
9019 throw INTERP_KERNEL::Exception("DataArrayInt::presenceOfValue : the array must have only one component, you can call 'rearrange' method before !");
9020 std::set<int> vals2(vals.begin(),vals.end());
9021 const int *cptr=getConstPointer();
9022 int nbOfTuples=getNumberOfTuples();
9023 for(const int *w=cptr;w!=cptr+nbOfTuples;w++)
9024 if(vals2.find(*w)!=vals2.end())
9025 return std::distance(cptr,w);
9030 * This method returns the number of values in \a this that are equals to input parameter \a value.
9031 * This method only works for single component array.
9033 * \return a value in [ 0, \c this->getNumberOfTuples() )
9035 * \throw If \a this is not allocated
9038 int DataArrayInt::count(int value) const
9042 if(getNumberOfComponents()!=1)
9043 throw INTERP_KERNEL::Exception("DataArrayInt::count : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
9044 const int *vals=begin();
9045 int nbOfTuples=getNumberOfTuples();
9046 for(int i=0;i<nbOfTuples;i++,vals++)
9053 * This method is an extension of DataArrayInt::presenceOfValue method because this method works for DataArrayInt with
9054 * any number of components excepted 0 (an INTERP_KERNEL::Exception is thrown in this case).
9055 * This method searches in \b this is there is a tuple that matched the input parameter \b tupl.
9056 * This method throws an INTERP_KERNEL::Exception if the number of components in \b this mismatches with the size of
9057 * the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
9058 * \sa DataArrayInt::locateTuple
9060 bool DataArrayInt::presenceOfTuple(const std::vector<int>& tupl) const
9062 return locateTuple(tupl)!=-1;
9067 * Returns \a true if a given value is present within \a this one-dimensional array.
9068 * \param [in] value - the value to find within \a this array.
9069 * \return bool - \a true in case if \a value is present within \a this array.
9070 * \throw If \a this is not allocated.
9071 * \throw If \a this->getNumberOfComponents() != 1.
9074 bool DataArrayInt::presenceOfValue(int value) const
9076 return locateValue(value)!=-1;
9080 * This method expects to be called when number of components of this is equal to one.
9081 * This method returns true if it exists a tuple so that the value is contained in \b vals.
9082 * If not any tuple contains one of the values contained in 'vals' false is returned.
9083 * \sa DataArrayInt::locateValue
9085 bool DataArrayInt::presenceOfValue(const std::vector<int>& vals) const
9087 return locateValue(vals)!=-1;
9091 * Accumulates values of each component of \a this array.
9092 * \param [out] res - an array of length \a this->getNumberOfComponents(), allocated
9093 * by the caller, that is filled by this method with sum value for each
9095 * \throw If \a this is not allocated.
9097 void DataArrayInt::accumulate(int *res) const
9100 const int *ptr=getConstPointer();
9101 int nbTuple=getNumberOfTuples();
9102 int nbComps=getNumberOfComponents();
9103 std::fill(res,res+nbComps,0);
9104 for(int i=0;i<nbTuple;i++)
9105 std::transform(ptr+i*nbComps,ptr+(i+1)*nbComps,res,res,std::plus<int>());
9108 int DataArrayInt::accumulate(int compId) const
9111 const int *ptr=getConstPointer();
9112 int nbTuple=getNumberOfTuples();
9113 int nbComps=getNumberOfComponents();
9114 if(compId<0 || compId>=nbComps)
9115 throw INTERP_KERNEL::Exception("DataArrayInt::accumulate : Invalid compId specified : No such nb of components !");
9117 for(int i=0;i<nbTuple;i++)
9118 ret+=ptr[i*nbComps+compId];
9123 * This method accumulate using addition tuples in \a this using input index array [ \a bgOfIndex, \a endOfIndex ).
9124 * The returned array will have same number of components than \a this and number of tuples equal to
9125 * \c std::distance(bgOfIndex,endOfIndex) \b minus \b one.
9127 * The input index array is expected to be ascendingly sorted in which the all referenced ids should be in [0, \c this->getNumberOfTuples).
9129 * \param [in] bgOfIndex - begin (included) of the input index array.
9130 * \param [in] endOfIndex - end (excluded) of the input index array.
9131 * \return DataArrayInt * - the new instance having the same number of components than \a this.
9133 * \throw If bgOfIndex or end is NULL.
9134 * \throw If input index array is not ascendingly sorted.
9135 * \throw If there is an id in [ \a bgOfIndex, \a endOfIndex ) not in [0, \c this->getNumberOfTuples).
9136 * \throw If std::distance(bgOfIndex,endOfIndex)==0.
9138 DataArrayInt *DataArrayInt::accumulatePerChunck(const int *bgOfIndex, const int *endOfIndex) const
9140 if(!bgOfIndex || !endOfIndex)
9141 throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : input pointer NULL !");
9143 int nbCompo=getNumberOfComponents();
9144 int nbOfTuples=getNumberOfTuples();
9145 int sz=(int)std::distance(bgOfIndex,endOfIndex);
9147 throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : invalid size of input index array !");
9149 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(sz,nbCompo);
9150 const int *w=bgOfIndex;
9151 if(*w<0 || *w>=nbOfTuples)
9152 throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : The first element of the input index not in [0,nbOfTuples) !");
9153 const int *srcPt=begin()+(*w)*nbCompo;
9154 int *tmp=ret->getPointer();
9155 for(int i=0;i<sz;i++,tmp+=nbCompo,w++)
9157 std::fill(tmp,tmp+nbCompo,0);
9160 for(int j=w[0];j<w[1];j++,srcPt+=nbCompo)
9162 if(j>=0 && j<nbOfTuples)
9163 std::transform(srcPt,srcPt+nbCompo,tmp,tmp,std::plus<int>());
9166 std::ostringstream oss; oss << "DataArrayInt::accumulatePerChunck : At rank #" << i << " the input index array points to id " << j << " should be in [0," << nbOfTuples << ") !";
9167 throw INTERP_KERNEL::Exception(oss.str().c_str());
9173 std::ostringstream oss; oss << "DataArrayInt::accumulatePerChunck : At rank #" << i << " the input index array is not in ascendingly sorted.";
9174 throw INTERP_KERNEL::Exception(oss.str().c_str());
9177 ret->copyStringInfoFrom(*this);
9182 * Returns a new DataArrayInt by concatenating two given arrays, so that (1) the number
9183 * of tuples in the result array is <em> a1->getNumberOfTuples() + a2->getNumberOfTuples() -
9184 * offsetA2</em> and (2)
9185 * the number of component in the result array is same as that of each of given arrays.
9186 * First \a offsetA2 tuples of \a a2 are skipped and thus are missing from the result array.
9187 * Info on components is copied from the first of the given arrays. Number of components
9188 * in the given arrays must be the same.
9189 * \param [in] a1 - an array to include in the result array.
9190 * \param [in] a2 - another array to include in the result array.
9191 * \param [in] offsetA2 - number of tuples of \a a2 to skip.
9192 * \return DataArrayInt * - the new instance of DataArrayInt.
9193 * The caller is to delete this result array using decrRef() as it is no more
9195 * \throw If either \a a1 or \a a2 is NULL.
9196 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents().
9198 DataArrayInt *DataArrayInt::Aggregate(const DataArrayInt *a1, const DataArrayInt *a2, int offsetA2)
9201 throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : input DataArrayInt instance is NULL !");
9202 int nbOfComp=a1->getNumberOfComponents();
9203 if(nbOfComp!=a2->getNumberOfComponents())
9204 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Aggregation !");
9205 int nbOfTuple1=a1->getNumberOfTuples();
9206 int nbOfTuple2=a2->getNumberOfTuples();
9207 DataArrayInt *ret=DataArrayInt::New();
9208 ret->alloc(nbOfTuple1+nbOfTuple2-offsetA2,nbOfComp);
9209 int *pt=std::copy(a1->getConstPointer(),a1->getConstPointer()+nbOfTuple1*nbOfComp,ret->getPointer());
9210 std::copy(a2->getConstPointer()+offsetA2*nbOfComp,a2->getConstPointer()+nbOfTuple2*nbOfComp,pt);
9211 ret->copyStringInfoFrom(*a1);
9216 * Returns a new DataArrayInt by concatenating all given arrays, so that (1) the number
9217 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
9218 * the number of component in the result array is same as that of each of given arrays.
9219 * Info on components is copied from the first of the given arrays. Number of components
9220 * in the given arrays must be the same.
9221 * If the number of non null of elements in \a arr is equal to one the returned object is a copy of it
9222 * not the object itself.
9223 * \param [in] arr - a sequence of arrays to include in the result array.
9224 * \return DataArrayInt * - the new instance of DataArrayInt.
9225 * The caller is to delete this result array using decrRef() as it is no more
9227 * \throw If all arrays within \a arr are NULL.
9228 * \throw If getNumberOfComponents() of arrays within \a arr.
9230 DataArrayInt *DataArrayInt::Aggregate(const std::vector<const DataArrayInt *>& arr)
9232 std::vector<const DataArrayInt *> a;
9233 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9237 throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : input list must be NON EMPTY !");
9238 std::vector<const DataArrayInt *>::const_iterator it=a.begin();
9239 int nbOfComp=(*it)->getNumberOfComponents();
9240 int nbt=(*it++)->getNumberOfTuples();
9241 for(int i=1;it!=a.end();it++,i++)
9243 if((*it)->getNumberOfComponents()!=nbOfComp)
9244 throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : Nb of components mismatch for array aggregation !");
9245 nbt+=(*it)->getNumberOfTuples();
9247 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9248 ret->alloc(nbt,nbOfComp);
9249 int *pt=ret->getPointer();
9250 for(it=a.begin();it!=a.end();it++)
9251 pt=std::copy((*it)->getConstPointer(),(*it)->getConstPointer()+(*it)->getNbOfElems(),pt);
9252 ret->copyStringInfoFrom(*(a[0]));
9257 * This method takes as input a list of DataArrayInt instances \a arrs that represent each a packed index arrays.
9258 * A packed index array is an allocated array with one component, and at least one tuple. The first element
9259 * of each array in \a arrs must be 0. Each array in \a arrs is expected to be increasingly monotonic.
9260 * 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.
9262 * \return DataArrayInt * - a new object to be managed by the caller.
9264 DataArrayInt *DataArrayInt::AggregateIndexes(const std::vector<const DataArrayInt *>& arrs)
9267 for(std::vector<const DataArrayInt *>::const_iterator it4=arrs.begin();it4!=arrs.end();it4++)
9271 (*it4)->checkAllocated();
9272 if((*it4)->getNumberOfComponents()!=1)
9274 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with nb of compo != 1 at pos " << std::distance(arrs.begin(),it4) << " !";
9275 throw INTERP_KERNEL::Exception(oss.str().c_str());
9277 int nbTupl=(*it4)->getNumberOfTuples();
9280 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with nb of tuples < 1 at pos " << std::distance(arrs.begin(),it4) << " !";
9281 throw INTERP_KERNEL::Exception(oss.str().c_str());
9283 if((*it4)->front()!=0)
9285 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with front value != 0 at pos " << std::distance(arrs.begin(),it4) << " !";
9286 throw INTERP_KERNEL::Exception(oss.str().c_str());
9292 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a null instance at pos " << std::distance(arrs.begin(),it4) << " !";
9293 throw INTERP_KERNEL::Exception(oss.str().c_str());
9297 throw INTERP_KERNEL::Exception("DataArrayInt::AggregateIndexes : input list must be NON EMPTY !");
9298 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9299 ret->alloc(retSz,1);
9300 int *pt=ret->getPointer(); *pt++=0;
9301 for(std::vector<const DataArrayInt *>::const_iterator it=arrs.begin();it!=arrs.end();it++)
9302 pt=std::transform((*it)->begin()+1,(*it)->end(),pt,std::bind2nd(std::plus<int>(),pt[-1]));
9303 ret->copyStringInfoFrom(*(arrs[0]));
9308 * Returns the maximal value and its location within \a this one-dimensional array.
9309 * \param [out] tupleId - index of the tuple holding the maximal value.
9310 * \return int - the maximal value among all values of \a this array.
9311 * \throw If \a this->getNumberOfComponents() != 1
9312 * \throw If \a this->getNumberOfTuples() < 1
9314 int DataArrayInt::getMaxValue(int& tupleId) const
9317 if(getNumberOfComponents()!=1)
9318 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : must be applied on DataArrayInt with only one component !");
9319 int nbOfTuples=getNumberOfTuples();
9321 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : array exists but number of tuples must be > 0 !");
9322 const int *vals=getConstPointer();
9323 const int *loc=std::max_element(vals,vals+nbOfTuples);
9324 tupleId=(int)std::distance(vals,loc);
9329 * Returns the maximal value within \a this array that is allowed to have more than
9331 * \return int - the maximal value among all values of \a this array.
9332 * \throw If \a this is not allocated.
9334 int DataArrayInt::getMaxValueInArray() const
9337 const int *loc=std::max_element(begin(),end());
9342 * Returns the minimal value and its location within \a this one-dimensional array.
9343 * \param [out] tupleId - index of the tuple holding the minimal value.
9344 * \return int - the minimal value among all values of \a this array.
9345 * \throw If \a this->getNumberOfComponents() != 1
9346 * \throw If \a this->getNumberOfTuples() < 1
9348 int DataArrayInt::getMinValue(int& tupleId) const
9351 if(getNumberOfComponents()!=1)
9352 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : must be applied on DataArrayInt with only one component !");
9353 int nbOfTuples=getNumberOfTuples();
9355 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : array exists but number of tuples must be > 0 !");
9356 const int *vals=getConstPointer();
9357 const int *loc=std::min_element(vals,vals+nbOfTuples);
9358 tupleId=(int)std::distance(vals,loc);
9363 * Returns the minimal value within \a this array that is allowed to have more than
9365 * \return int - the minimal value among all values of \a this array.
9366 * \throw If \a this is not allocated.
9368 int DataArrayInt::getMinValueInArray() const
9371 const int *loc=std::min_element(begin(),end());
9376 * Returns in a single walk in \a this the min value and the max value in \a this.
9377 * \a this is expected to be single component array.
9379 * \param [out] minValue - the min value in \a this.
9380 * \param [out] maxValue - the max value in \a this.
9382 * \sa getMinValueInArray, getMinValue, getMaxValueInArray, getMaxValue
9384 void DataArrayInt::getMinMaxValues(int& minValue, int& maxValue) const
9387 if(getNumberOfComponents()!=1)
9388 throw INTERP_KERNEL::Exception("DataArrayInt::getMinMaxValues : must be applied on DataArrayInt with only one component !");
9389 int nbTuples(getNumberOfTuples());
9390 const int *pt(begin());
9391 minValue=std::numeric_limits<int>::max(); maxValue=-std::numeric_limits<int>::max();
9392 for(int i=0;i<nbTuples;i++,pt++)
9402 * Converts every value of \a this array to its absolute value.
9403 * \b WARNING this method is non const. If a new DataArrayInt instance should be built containing the result of abs DataArrayInt::computeAbs
9404 * should be called instead.
9406 * \throw If \a this is not allocated.
9407 * \sa DataArrayInt::computeAbs
9409 void DataArrayInt::abs()
9412 int *ptr(getPointer());
9413 std::size_t nbOfElems(getNbOfElems());
9414 std::transform(ptr,ptr+nbOfElems,ptr,std::ptr_fun<int,int>(std::abs));
9419 * This method builds a new instance of \a this object containing the result of std::abs applied of all elements in \a this.
9420 * This method is a const method (that do not change any values in \a this) contrary to DataArrayInt::abs method.
9422 * \return DataArrayInt * - the new instance of DataArrayInt containing the
9423 * same number of tuples and component as \a this array.
9424 * The caller is to delete this result array using decrRef() as it is no more
9426 * \throw If \a this is not allocated.
9427 * \sa DataArrayInt::abs
9429 DataArrayInt *DataArrayInt::computeAbs() const
9432 DataArrayInt *newArr(DataArrayInt::New());
9433 int nbOfTuples(getNumberOfTuples());
9434 int nbOfComp(getNumberOfComponents());
9435 newArr->alloc(nbOfTuples,nbOfComp);
9436 std::transform(begin(),end(),newArr->getPointer(),std::ptr_fun<int,int>(std::abs));
9437 newArr->copyStringInfoFrom(*this);
9442 * Apply a liner function to a given component of \a this array, so that
9443 * an array element <em>(x)</em> becomes \f$ a * x + b \f$.
9444 * \param [in] a - the first coefficient of the function.
9445 * \param [in] b - the second coefficient of the function.
9446 * \param [in] compoId - the index of component to modify.
9447 * \throw If \a this is not allocated.
9449 void DataArrayInt::applyLin(int a, int b, int compoId)
9452 int *ptr=getPointer()+compoId;
9453 int nbOfComp=getNumberOfComponents();
9454 int nbOfTuple=getNumberOfTuples();
9455 for(int i=0;i<nbOfTuple;i++,ptr+=nbOfComp)
9461 * Apply a liner function to all elements of \a this array, so that
9462 * an element _x_ becomes \f$ a * x + b \f$.
9463 * \param [in] a - the first coefficient of the function.
9464 * \param [in] b - the second coefficient of the function.
9465 * \throw If \a this is not allocated.
9467 void DataArrayInt::applyLin(int a, int b)
9470 int *ptr=getPointer();
9471 std::size_t nbOfElems=getNbOfElems();
9472 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9478 * Returns a full copy of \a this array except that sign of all elements is reversed.
9479 * \return DataArrayInt * - the new instance of DataArrayInt containing the
9480 * same number of tuples and component as \a this array.
9481 * The caller is to delete this result array using decrRef() as it is no more
9483 * \throw If \a this is not allocated.
9485 DataArrayInt *DataArrayInt::negate() const
9488 DataArrayInt *newArr=DataArrayInt::New();
9489 int nbOfTuples=getNumberOfTuples();
9490 int nbOfComp=getNumberOfComponents();
9491 newArr->alloc(nbOfTuples,nbOfComp);
9492 const int *cptr=getConstPointer();
9493 std::transform(cptr,cptr+nbOfTuples*nbOfComp,newArr->getPointer(),std::negate<int>());
9494 newArr->copyStringInfoFrom(*this);
9499 * Modify all elements of \a this array, so that
9500 * an element _x_ becomes \f$ numerator / x \f$.
9501 * \warning If an exception is thrown because of presence of 0 element in \a this
9502 * array, all elements processed before detection of the zero element remain
9504 * \param [in] numerator - the numerator used to modify array elements.
9505 * \throw If \a this is not allocated.
9506 * \throw If there is an element equal to 0 in \a this array.
9508 void DataArrayInt::applyInv(int numerator)
9511 int *ptr=getPointer();
9512 std::size_t nbOfElems=getNbOfElems();
9513 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9517 *ptr=numerator/(*ptr);
9521 std::ostringstream oss; oss << "DataArrayInt::applyInv : presence of null value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
9523 throw INTERP_KERNEL::Exception(oss.str().c_str());
9530 * Modify all elements of \a this array, so that
9531 * an element _x_ becomes \f$ x / val \f$.
9532 * \param [in] val - the denominator used to modify array elements.
9533 * \throw If \a this is not allocated.
9534 * \throw If \a val == 0.
9536 void DataArrayInt::applyDivideBy(int val)
9539 throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to divide by 0 !");
9541 int *ptr=getPointer();
9542 std::size_t nbOfElems=getNbOfElems();
9543 std::transform(ptr,ptr+nbOfElems,ptr,std::bind2nd(std::divides<int>(),val));
9548 * Modify all elements of \a this array, so that
9549 * an element _x_ becomes <em> x % val </em>.
9550 * \param [in] val - the divisor used to modify array elements.
9551 * \throw If \a this is not allocated.
9552 * \throw If \a val <= 0.
9554 void DataArrayInt::applyModulus(int val)
9557 throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to operate modulus on value <= 0 !");
9559 int *ptr=getPointer();
9560 std::size_t nbOfElems=getNbOfElems();
9561 std::transform(ptr,ptr+nbOfElems,ptr,std::bind2nd(std::modulus<int>(),val));
9566 * This method works only on data array with one component.
9567 * This method returns a newly allocated array storing stored ascendantly tuple ids in \b this so that
9568 * this[*id] in [\b vmin,\b vmax)
9570 * \param [in] vmin begin of range. This value is included in range (included).
9571 * \param [in] vmax end of range. This value is \b not included in range (excluded).
9572 * \return a newly allocated data array that the caller should deal with.
9574 * \sa DataArrayInt::getIdsNotInRange , DataArrayInt::getIdsStrictlyNegative
9576 DataArrayInt *DataArrayInt::getIdsInRange(int vmin, int vmax) const
9579 if(getNumberOfComponents()!=1)
9580 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsInRange : this must have exactly one component !");
9581 const int *cptr(begin());
9582 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
9583 int nbOfTuples(getNumberOfTuples());
9584 for(int i=0;i<nbOfTuples;i++,cptr++)
9585 if(*cptr>=vmin && *cptr<vmax)
9586 ret->pushBackSilent(i);
9591 * This method works only on data array with one component.
9592 * This method returns a newly allocated array storing stored ascendantly tuple ids in \b this so that
9593 * this[*id] \b not in [\b vmin,\b vmax)
9595 * \param [in] vmin begin of range. This value is \b not included in range (excluded).
9596 * \param [in] vmax end of range. This value is included in range (included).
9597 * \return a newly allocated data array that the caller should deal with.
9599 * \sa DataArrayInt::getIdsInRange , DataArrayInt::getIdsStrictlyNegative
9601 DataArrayInt *DataArrayInt::getIdsNotInRange(int vmin, int vmax) const
9604 if(getNumberOfComponents()!=1)
9605 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotInRange : this must have exactly one component !");
9606 const int *cptr(getConstPointer());
9607 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
9608 int nbOfTuples(getNumberOfTuples());
9609 for(int i=0;i<nbOfTuples;i++,cptr++)
9610 if(*cptr<vmin || *cptr>=vmax)
9611 ret->pushBackSilent(i);
9616 * 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.
9618 * \return a newly allocated data array that the caller should deal with.
9619 * \sa DataArrayInt::getIdsInRange
9621 DataArrayInt *DataArrayInt::getIdsStrictlyNegative() const
9624 if(getNumberOfComponents()!=1)
9625 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsStrictlyNegative : this must have exactly one component !");
9626 const int *cptr(getConstPointer());
9627 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
9628 int nbOfTuples(getNumberOfTuples());
9629 for(int i=0;i<nbOfTuples;i++,cptr++)
9631 ret->pushBackSilent(i);
9636 * This method works only on data array with one component.
9637 * 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.
9639 * \param [in] vmin begin of range. This value is included in range (included).
9640 * \param [in] vmax end of range. This value is \b not included in range (excluded).
9641 * \return if all ids in \a this are so that (*this)[i]==i for all i in [ 0, \c this->getNumberOfTuples() ). */
9642 bool DataArrayInt::checkAllIdsInRange(int vmin, int vmax) const
9645 if(getNumberOfComponents()!=1)
9646 throw INTERP_KERNEL::Exception("DataArrayInt::checkAllIdsInRange : this must have exactly one component !");
9647 int nbOfTuples=getNumberOfTuples();
9649 const int *cptr=getConstPointer();
9650 for(int i=0;i<nbOfTuples;i++,cptr++)
9652 if(*cptr>=vmin && *cptr<vmax)
9653 { ret=ret && *cptr==i; }
9656 std::ostringstream oss; oss << "DataArrayInt::checkAllIdsInRange : tuple #" << i << " has value " << *cptr << " should be in [" << vmin << "," << vmax << ") !";
9657 throw INTERP_KERNEL::Exception(oss.str().c_str());
9664 * Modify all elements of \a this array, so that
9665 * an element _x_ becomes <em> val % x </em>.
9666 * \warning If an exception is thrown because of presence of an element <= 0 in \a this
9667 * array, all elements processed before detection of the zero element remain
9669 * \param [in] val - the divident used to modify array elements.
9670 * \throw If \a this is not allocated.
9671 * \throw If there is an element equal to or less than 0 in \a this array.
9673 void DataArrayInt::applyRModulus(int val)
9676 int *ptr=getPointer();
9677 std::size_t nbOfElems=getNbOfElems();
9678 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9686 std::ostringstream oss; oss << "DataArrayInt::applyRModulus : presence of value <=0 in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
9688 throw INTERP_KERNEL::Exception(oss.str().c_str());
9695 * Modify all elements of \a this array, so that
9696 * an element _x_ becomes <em> val ^ x </em>.
9697 * \param [in] val - the value used to apply pow on all array elements.
9698 * \throw If \a this is not allocated.
9699 * \throw If \a val < 0.
9701 void DataArrayInt::applyPow(int val)
9705 throw INTERP_KERNEL::Exception("DataArrayInt::applyPow : input pow in < 0 !");
9706 int *ptr=getPointer();
9707 std::size_t nbOfElems=getNbOfElems();
9710 std::fill(ptr,ptr+nbOfElems,1);
9713 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9716 for(int j=0;j<val;j++)
9724 * Modify all elements of \a this array, so that
9725 * an element _x_ becomes \f$ val ^ x \f$.
9726 * \param [in] val - the value used to apply pow on all array elements.
9727 * \throw If \a this is not allocated.
9728 * \throw If there is an element < 0 in \a this array.
9729 * \warning If an exception is thrown because of presence of 0 element in \a this
9730 * array, all elements processed before detection of the zero element remain
9733 void DataArrayInt::applyRPow(int val)
9736 int *ptr=getPointer();
9737 std::size_t nbOfElems=getNbOfElems();
9738 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9743 for(int j=0;j<*ptr;j++)
9749 std::ostringstream oss; oss << "DataArrayInt::applyRPow : presence of negative value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
9751 throw INTERP_KERNEL::Exception(oss.str().c_str());
9758 * Returns a new DataArrayInt by aggregating two given arrays, so that (1) the number
9759 * of components in the result array is a sum of the number of components of given arrays
9760 * and (2) the number of tuples in the result array is same as that of each of given
9761 * arrays. In other words the i-th tuple of result array includes all components of
9762 * i-th tuples of all given arrays.
9763 * Number of tuples in the given arrays must be the same.
9764 * \param [in] a1 - an array to include in the result array.
9765 * \param [in] a2 - another array to include in the result array.
9766 * \return DataArrayInt * - the new instance of DataArrayInt.
9767 * The caller is to delete this result array using decrRef() as it is no more
9769 * \throw If both \a a1 and \a a2 are NULL.
9770 * \throw If any given array is not allocated.
9771 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
9773 DataArrayInt *DataArrayInt::Meld(const DataArrayInt *a1, const DataArrayInt *a2)
9775 std::vector<const DataArrayInt *> arr(2);
9776 arr[0]=a1; arr[1]=a2;
9781 * Returns a new DataArrayInt by aggregating all given arrays, so that (1) the number
9782 * of components in the result array is a sum of the number of components of given arrays
9783 * and (2) the number of tuples in the result array is same as that of each of given
9784 * arrays. In other words the i-th tuple of result array includes all components of
9785 * i-th tuples of all given arrays.
9786 * Number of tuples in the given arrays must be the same.
9787 * \param [in] arr - a sequence of arrays to include in the result array.
9788 * \return DataArrayInt * - the new instance of DataArrayInt.
9789 * The caller is to delete this result array using decrRef() as it is no more
9791 * \throw If all arrays within \a arr are NULL.
9792 * \throw If any given array is not allocated.
9793 * \throw If getNumberOfTuples() of arrays within \a arr is different.
9795 DataArrayInt *DataArrayInt::Meld(const std::vector<const DataArrayInt *>& arr)
9797 std::vector<const DataArrayInt *> a;
9798 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9802 throw INTERP_KERNEL::Exception("DataArrayInt::Meld : array must be NON empty !");
9803 std::vector<const DataArrayInt *>::const_iterator it;
9804 for(it=a.begin();it!=a.end();it++)
9805 (*it)->checkAllocated();
9807 int nbOfTuples=(*it)->getNumberOfTuples();
9808 std::vector<int> nbc(a.size());
9809 std::vector<const int *> pts(a.size());
9810 nbc[0]=(*it)->getNumberOfComponents();
9811 pts[0]=(*it++)->getConstPointer();
9812 for(int i=1;it!=a.end();it++,i++)
9814 if(nbOfTuples!=(*it)->getNumberOfTuples())
9815 throw INTERP_KERNEL::Exception("DataArrayInt::meld : mismatch of number of tuples !");
9816 nbc[i]=(*it)->getNumberOfComponents();
9817 pts[i]=(*it)->getConstPointer();
9819 int totalNbOfComp=std::accumulate(nbc.begin(),nbc.end(),0);
9820 DataArrayInt *ret=DataArrayInt::New();
9821 ret->alloc(nbOfTuples,totalNbOfComp);
9822 int *retPtr=ret->getPointer();
9823 for(int i=0;i<nbOfTuples;i++)
9824 for(int j=0;j<(int)a.size();j++)
9826 retPtr=std::copy(pts[j],pts[j]+nbc[j],retPtr);
9830 for(int i=0;i<(int)a.size();i++)
9831 for(int j=0;j<nbc[i];j++,k++)
9832 ret->setInfoOnComponent(k,a[i]->getInfoOnComponent(j));
9837 * Returns a new DataArrayInt which is a minimal partition of elements of \a groups.
9838 * The i-th item of the result array is an ID of a set of elements belonging to a
9839 * unique set of groups, which the i-th element is a part of. This set of elements
9840 * belonging to a unique set of groups is called \a family, so the result array contains
9841 * IDs of families each element belongs to.
9843 * \b Example: if we have two groups of elements: \a group1 [0,4] and \a group2 [ 0,1,2 ],
9844 * then there are 3 families:
9845 * - \a family1 (with ID 1) contains element [0] belonging to ( \a group1 + \a group2 ),
9846 * - \a family2 (with ID 2) contains elements [4] belonging to ( \a group1 ),
9847 * - \a family3 (with ID 3) contains element [1,2] belonging to ( \a group2 ), <br>
9848 * and the result array contains IDs of families [ 1,3,3,0,2 ]. <br> Note a family ID 0 which
9849 * stands for the element #3 which is in none of groups.
9851 * \param [in] groups - sequence of groups of element IDs.
9852 * \param [in] newNb - total number of elements; it must be more than max ID of element
9854 * \param [out] fidsOfGroups - IDs of families the elements of each group belong to.
9855 * \return DataArrayInt * - a new instance of DataArrayInt containing IDs of families
9856 * each element with ID from range [0, \a newNb ) belongs to. The caller is to
9857 * delete this array using decrRef() as it is no more needed.
9858 * \throw If any element ID in \a groups violates condition ( 0 <= ID < \a newNb ).
9860 DataArrayInt *DataArrayInt::MakePartition(const std::vector<const DataArrayInt *>& groups, int newNb, std::vector< std::vector<int> >& fidsOfGroups)
9862 std::vector<const DataArrayInt *> groups2;
9863 for(std::vector<const DataArrayInt *>::const_iterator it4=groups.begin();it4!=groups.end();it4++)
9865 groups2.push_back(*it4);
9866 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9867 ret->alloc(newNb,1);
9868 int *retPtr=ret->getPointer();
9869 std::fill(retPtr,retPtr+newNb,0);
9871 for(std::vector<const DataArrayInt *>::const_iterator iter=groups2.begin();iter!=groups2.end();iter++)
9873 const int *ptr=(*iter)->getConstPointer();
9874 std::size_t nbOfElem=(*iter)->getNbOfElems();
9876 for(int j=0;j<sfid;j++)
9879 for(std::size_t i=0;i<nbOfElem;i++)
9881 if(ptr[i]>=0 && ptr[i]<newNb)
9883 if(retPtr[ptr[i]]==j)
9891 std::ostringstream oss; oss << "DataArrayInt::MakePartition : In group \"" << (*iter)->getName() << "\" in tuple #" << i << " value = " << ptr[i] << " ! Should be in [0," << newNb;
9893 throw INTERP_KERNEL::Exception(oss.str().c_str());
9900 fidsOfGroups.clear();
9901 fidsOfGroups.resize(groups2.size());
9903 for(std::vector<const DataArrayInt *>::const_iterator iter=groups2.begin();iter!=groups2.end();iter++,grId++)
9906 const int *ptr=(*iter)->getConstPointer();
9907 std::size_t nbOfElem=(*iter)->getNbOfElems();
9908 for(const int *p=ptr;p!=ptr+nbOfElem;p++)
9909 tmp.insert(retPtr[*p]);
9910 fidsOfGroups[grId].insert(fidsOfGroups[grId].end(),tmp.begin(),tmp.end());
9916 * Returns a new DataArrayInt which contains all elements of given one-dimensional
9917 * arrays. The result array does not contain any duplicates and its values
9918 * are sorted in ascending order.
9919 * \param [in] arr - sequence of DataArrayInt's to unite.
9920 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9921 * array using decrRef() as it is no more needed.
9922 * \throw If any \a arr[i] is not allocated.
9923 * \throw If \a arr[i]->getNumberOfComponents() != 1.
9925 DataArrayInt *DataArrayInt::BuildUnion(const std::vector<const DataArrayInt *>& arr)
9927 std::vector<const DataArrayInt *> a;
9928 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9931 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9933 (*it)->checkAllocated();
9934 if((*it)->getNumberOfComponents()!=1)
9935 throw INTERP_KERNEL::Exception("DataArrayInt::BuildUnion : only single component allowed !");
9939 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9941 const int *pt=(*it)->getConstPointer();
9942 int nbOfTuples=(*it)->getNumberOfTuples();
9943 r.insert(pt,pt+nbOfTuples);
9945 DataArrayInt *ret=DataArrayInt::New();
9946 ret->alloc((int)r.size(),1);
9947 std::copy(r.begin(),r.end(),ret->getPointer());
9952 * Returns a new DataArrayInt which contains elements present in each of given one-dimensional
9953 * arrays. The result array does not contain any duplicates and its values
9954 * are sorted in ascending order.
9955 * \param [in] arr - sequence of DataArrayInt's to intersect.
9956 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9957 * array using decrRef() as it is no more needed.
9958 * \throw If any \a arr[i] is not allocated.
9959 * \throw If \a arr[i]->getNumberOfComponents() != 1.
9961 DataArrayInt *DataArrayInt::BuildIntersection(const std::vector<const DataArrayInt *>& arr)
9963 std::vector<const DataArrayInt *> a;
9964 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9967 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9969 (*it)->checkAllocated();
9970 if((*it)->getNumberOfComponents()!=1)
9971 throw INTERP_KERNEL::Exception("DataArrayInt::BuildIntersection : only single component allowed !");
9975 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9977 const int *pt=(*it)->getConstPointer();
9978 int nbOfTuples=(*it)->getNumberOfTuples();
9979 std::set<int> s1(pt,pt+nbOfTuples);
9983 std::set_intersection(r.begin(),r.end(),s1.begin(),s1.end(),inserter(r2,r2.end()));
9989 DataArrayInt *ret(DataArrayInt::New());
9990 ret->alloc((int)r.size(),1);
9991 std::copy(r.begin(),r.end(),ret->getPointer());
9996 namespace ParaMEDMEMImpl
10001 OpSwitchedOn(int *pt):_pt(pt),_cnt(0) { }
10002 void operator()(const bool& b) { if(b) *_pt++=_cnt; _cnt++; }
10008 class OpSwitchedOff
10011 OpSwitchedOff(int *pt):_pt(pt),_cnt(0) { }
10012 void operator()(const bool& b) { if(!b) *_pt++=_cnt; _cnt++; }
10021 * This method returns the list of ids in ascending mode so that v[id]==true.
10023 DataArrayInt *DataArrayInt::BuildListOfSwitchedOn(const std::vector<bool>& v)
10025 int sz((int)std::count(v.begin(),v.end(),true));
10026 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
10027 std::for_each(v.begin(),v.end(),ParaMEDMEMImpl::OpSwitchedOn(ret->getPointer()));
10032 * This method returns the list of ids in ascending mode so that v[id]==false.
10034 DataArrayInt *DataArrayInt::BuildListOfSwitchedOff(const std::vector<bool>& v)
10036 int sz((int)std::count(v.begin(),v.end(),false));
10037 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
10038 std::for_each(v.begin(),v.end(),ParaMEDMEMImpl::OpSwitchedOff(ret->getPointer()));
10043 * This method allows to put a vector of vector of integer into a more compact data stucture (skyline).
10044 * This method is not available into python because no available optimized data structure available to map std::vector< std::vector<int> >.
10046 * \param [in] v the input data structure to be translate into skyline format.
10047 * \param [out] data the first element of the skyline format. The user is expected to deal with newly allocated array.
10048 * \param [out] dataIndex the second element of the skyline format.
10050 void DataArrayInt::PutIntoToSkylineFrmt(const std::vector< std::vector<int> >& v, DataArrayInt *& data, DataArrayInt *& dataIndex)
10052 int sz((int)v.size());
10053 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret0(DataArrayInt::New()),ret1(DataArrayInt::New());
10054 ret1->alloc(sz+1,1);
10055 int *pt(ret1->getPointer()); *pt=0;
10056 for(int i=0;i<sz;i++,pt++)
10057 pt[1]=pt[0]+(int)v[i].size();
10058 ret0->alloc(ret1->back(),1);
10059 pt=ret0->getPointer();
10060 for(int i=0;i<sz;i++)
10061 pt=std::copy(v[i].begin(),v[i].end(),pt);
10062 data=ret0.retn(); dataIndex=ret1.retn();
10066 * Returns a new DataArrayInt which contains a complement of elements of \a this
10067 * one-dimensional array. I.e. the result array contains all elements from the range [0,
10068 * \a nbOfElement) not present in \a this array.
10069 * \param [in] nbOfElement - maximal size of the result array.
10070 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
10071 * array using decrRef() as it is no more needed.
10072 * \throw If \a this is not allocated.
10073 * \throw If \a this->getNumberOfComponents() != 1.
10074 * \throw If any element \a x of \a this array violates condition ( 0 <= \a x < \a
10077 DataArrayInt *DataArrayInt::buildComplement(int nbOfElement) const
10080 if(getNumberOfComponents()!=1)
10081 throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : only single component allowed !");
10082 std::vector<bool> tmp(nbOfElement);
10083 const int *pt=getConstPointer();
10084 int nbOfTuples=getNumberOfTuples();
10085 for(const int *w=pt;w!=pt+nbOfTuples;w++)
10086 if(*w>=0 && *w<nbOfElement)
10089 throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : an element is not in valid range : [0,nbOfElement) !");
10090 int nbOfRetVal=(int)std::count(tmp.begin(),tmp.end(),false);
10091 DataArrayInt *ret=DataArrayInt::New();
10092 ret->alloc(nbOfRetVal,1);
10094 int *retPtr=ret->getPointer();
10095 for(int i=0;i<nbOfElement;i++)
10102 * Returns a new DataArrayInt containing elements of \a this one-dimensional missing
10103 * from an \a other one-dimensional array.
10104 * \param [in] other - a DataArrayInt containing elements not to include in the result array.
10105 * \return DataArrayInt * - a new instance of DataArrayInt with one component. The
10106 * caller is to delete this array using decrRef() as it is no more needed.
10107 * \throw If \a other is NULL.
10108 * \throw If \a other is not allocated.
10109 * \throw If \a other->getNumberOfComponents() != 1.
10110 * \throw If \a this is not allocated.
10111 * \throw If \a this->getNumberOfComponents() != 1.
10112 * \sa DataArrayInt::buildSubstractionOptimized()
10114 DataArrayInt *DataArrayInt::buildSubstraction(const DataArrayInt *other) const
10117 throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : DataArrayInt pointer in input is NULL !");
10119 other->checkAllocated();
10120 if(getNumberOfComponents()!=1)
10121 throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed !");
10122 if(other->getNumberOfComponents()!=1)
10123 throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed for other type !");
10124 const int *pt=getConstPointer();
10125 int nbOfTuples=getNumberOfTuples();
10126 std::set<int> s1(pt,pt+nbOfTuples);
10127 pt=other->getConstPointer();
10128 nbOfTuples=other->getNumberOfTuples();
10129 std::set<int> s2(pt,pt+nbOfTuples);
10130 std::vector<int> r;
10131 std::set_difference(s1.begin(),s1.end(),s2.begin(),s2.end(),std::back_insert_iterator< std::vector<int> >(r));
10132 DataArrayInt *ret=DataArrayInt::New();
10133 ret->alloc((int)r.size(),1);
10134 std::copy(r.begin(),r.end(),ret->getPointer());
10139 * \a this is expected to have one component and to be sorted ascendingly (as for \a other).
10140 * \a other is expected to be a part of \a this. If not DataArrayInt::buildSubstraction should be called instead.
10142 * \param [in] other an array with one component and expected to be sorted ascendingly.
10143 * \ret list of ids in \a this but not in \a other.
10144 * \sa DataArrayInt::buildSubstraction
10146 DataArrayInt *DataArrayInt::buildSubstractionOptimized(const DataArrayInt *other) const
10148 static const char *MSG="DataArrayInt::buildSubstractionOptimized : only single component allowed !";
10149 if(!other) throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstractionOptimized : NULL input array !");
10150 checkAllocated(); other->checkAllocated();
10151 if(getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception(MSG);
10152 if(other->getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception(MSG);
10153 const int *pt1Bg(begin()),*pt1End(end()),*pt2Bg(other->begin()),*pt2End(other->end());
10154 const int *work1(pt1Bg),*work2(pt2Bg);
10155 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
10156 for(;work1!=pt1End;work1++)
10158 if(work2!=pt2End && *work1==*work2)
10161 ret->pushBackSilent(*work1);
10168 * Returns a new DataArrayInt which contains all elements of \a this and a given
10169 * one-dimensional arrays. The result array does not contain any duplicates
10170 * and its values are sorted in ascending order.
10171 * \param [in] other - an array to unite with \a this one.
10172 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
10173 * array using decrRef() as it is no more needed.
10174 * \throw If \a this or \a other is not allocated.
10175 * \throw If \a this->getNumberOfComponents() != 1.
10176 * \throw If \a other->getNumberOfComponents() != 1.
10178 DataArrayInt *DataArrayInt::buildUnion(const DataArrayInt *other) const
10180 std::vector<const DataArrayInt *>arrs(2);
10181 arrs[0]=this; arrs[1]=other;
10182 return BuildUnion(arrs);
10187 * Returns a new DataArrayInt which contains elements present in both \a this and a given
10188 * one-dimensional arrays. The result array does not contain any duplicates
10189 * and its values are sorted in ascending order.
10190 * \param [in] other - an array to intersect with \a this one.
10191 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
10192 * array using decrRef() as it is no more needed.
10193 * \throw If \a this or \a other is not allocated.
10194 * \throw If \a this->getNumberOfComponents() != 1.
10195 * \throw If \a other->getNumberOfComponents() != 1.
10197 DataArrayInt *DataArrayInt::buildIntersection(const DataArrayInt *other) const
10199 std::vector<const DataArrayInt *>arrs(2);
10200 arrs[0]=this; arrs[1]=other;
10201 return BuildIntersection(arrs);
10205 * This method can be applied on allocated with one component DataArrayInt instance.
10206 * This method is typically relevant for sorted arrays. All consecutive duplicated items in \a this will appear only once in returned DataArrayInt instance.
10207 * 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]
10209 * \return a newly allocated array that contain the result of the unique operation applied on \a this.
10210 * \throw if \a this is not allocated or if \a this has not exactly one component.
10211 * \sa DataArrayInt::buildUniqueNotSorted
10213 DataArrayInt *DataArrayInt::buildUnique() const
10216 if(getNumberOfComponents()!=1)
10217 throw INTERP_KERNEL::Exception("DataArrayInt::buildUnique : only single component allowed !");
10218 int nbOfTuples=getNumberOfTuples();
10219 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=deepCpy();
10220 int *data=tmp->getPointer();
10221 int *last=std::unique(data,data+nbOfTuples);
10222 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10223 ret->alloc(std::distance(data,last),1);
10224 std::copy(data,last,ret->getPointer());
10229 * This method can be applied on allocated with one component DataArrayInt instance.
10230 * This method keep elements only once by keeping the same order in \a this that is not expected to be sorted.
10232 * \return a newly allocated array that contain the result of the unique operation applied on \a this.
10234 * \throw if \a this is not allocated or if \a this has not exactly one component.
10236 * \sa DataArrayInt::buildUnique
10238 DataArrayInt *DataArrayInt::buildUniqueNotSorted() const
10241 if(getNumberOfComponents()!=1)
10242 throw INTERP_KERNEL::Exception("DataArrayInt::buildUniqueNotSorted : only single component allowed !");
10244 getMinMaxValues(minVal,maxVal);
10245 std::vector<bool> b(maxVal-minVal+1,false);
10246 const int *ptBg(begin()),*endBg(end());
10247 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
10248 for(const int *pt=ptBg;pt!=endBg;pt++)
10252 ret->pushBackSilent(*pt);
10253 b[*pt-minVal]=true;
10256 ret->copyStringInfoFrom(*this);
10261 * Returns a new DataArrayInt which contains size of every of groups described by \a this
10262 * "index" array. Such "index" array is returned for example by
10263 * \ref ParaMEDMEM::MEDCouplingUMesh::buildDescendingConnectivity
10264 * "MEDCouplingUMesh::buildDescendingConnectivity" and
10265 * \ref ParaMEDMEM::MEDCouplingUMesh::getNodalConnectivityIndex
10266 * "MEDCouplingUMesh::getNodalConnectivityIndex" etc.
10267 * This method preforms the reverse operation of DataArrayInt::computeOffsets2.
10268 * \return DataArrayInt * - a new instance of DataArrayInt, whose number of tuples
10269 * equals to \a this->getNumberOfComponents() - 1, and number of components is 1.
10270 * The caller is to delete this array using decrRef() as it is no more needed.
10271 * \throw If \a this is not allocated.
10272 * \throw If \a this->getNumberOfComponents() != 1.
10273 * \throw If \a this->getNumberOfTuples() < 2.
10276 * - this contains [1,3,6,7,7,9,15]
10277 * - result array contains [2,3,1,0,2,6],
10278 * where 2 = 3 - 1, 3 = 6 - 3, 1 = 7 - 6 etc.
10280 * \sa DataArrayInt::computeOffsets2
10282 DataArrayInt *DataArrayInt::deltaShiftIndex() const
10285 if(getNumberOfComponents()!=1)
10286 throw INTERP_KERNEL::Exception("DataArrayInt::deltaShiftIndex : only single component allowed !");
10287 int nbOfTuples=getNumberOfTuples();
10289 throw INTERP_KERNEL::Exception("DataArrayInt::deltaShiftIndex : 1 tuple at least must be present in 'this' !");
10290 const int *ptr=getConstPointer();
10291 DataArrayInt *ret=DataArrayInt::New();
10292 ret->alloc(nbOfTuples-1,1);
10293 int *out=ret->getPointer();
10294 std::transform(ptr+1,ptr+nbOfTuples,ptr,out,std::minus<int>());
10299 * Modifies \a this one-dimensional array so that value of each element \a x
10300 * of \a this array (\a a) is computed as \f$ x_i = \sum_{j=0}^{i-1} a[ j ] \f$.
10301 * Or: for each i>0 new[i]=new[i-1]+old[i-1] for i==0 new[i]=0. Number of tuples
10302 * and components remains the same.<br>
10303 * This method is useful for allToAllV in MPI with contiguous policy. This method
10304 * differs from computeOffsets2() in that the number of tuples is \b not changed by
10306 * \throw If \a this is not allocated.
10307 * \throw If \a this->getNumberOfComponents() != 1.
10310 * - Before \a this contains [3,5,1,2,0,8]
10311 * - After \a this contains [0,3,8,9,11,11]<br>
10312 * Note that the last element 19 = 11 + 8 is missing because size of \a this
10313 * array is retained and thus there is no space to store the last element.
10315 void DataArrayInt::computeOffsets()
10318 if(getNumberOfComponents()!=1)
10319 throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsets : only single component allowed !");
10320 int nbOfTuples=getNumberOfTuples();
10323 int *work=getPointer();
10326 for(int i=1;i<nbOfTuples;i++)
10329 work[i]=work[i-1]+tmp;
10337 * Modifies \a this one-dimensional array so that value of each element \a x
10338 * of \a this array (\a a) is computed as \f$ x_i = \sum_{j=0}^{i-1} a[ j ] \f$.
10339 * Or: for each i>0 new[i]=new[i-1]+old[i-1] for i==0 new[i]=0. Number
10340 * components remains the same and number of tuples is inceamented by one.<br>
10341 * This method is useful for allToAllV in MPI with contiguous policy. This method
10342 * differs from computeOffsets() in that the number of tuples is changed by this one.
10343 * This method preforms the reverse operation of DataArrayInt::deltaShiftIndex.
10344 * \throw If \a this is not allocated.
10345 * \throw If \a this->getNumberOfComponents() != 1.
10348 * - Before \a this contains [3,5,1,2,0,8]
10349 * - After \a this contains [0,3,8,9,11,11,19]<br>
10350 * \sa DataArrayInt::deltaShiftIndex
10352 void DataArrayInt::computeOffsets2()
10355 if(getNumberOfComponents()!=1)
10356 throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsets2 : only single component allowed !");
10357 int nbOfTuples=getNumberOfTuples();
10358 int *ret=(int *)malloc((nbOfTuples+1)*sizeof(int));
10361 const int *work=getConstPointer();
10363 for(int i=0;i<nbOfTuples;i++)
10364 ret[i+1]=work[i]+ret[i];
10365 useArray(ret,true,C_DEALLOC,nbOfTuples+1,1);
10370 * Returns two new DataArrayInt instances whose contents is computed from that of \a this and \a listOfIds arrays as follows.
10371 * \a this is expected to be an offset format ( as returned by DataArrayInt::computeOffsets2 ) that is to say with one component
10372 * and ** sorted strictly increasingly **. \a listOfIds is expected to be sorted ascendingly (not strictly needed for \a listOfIds).
10373 * This methods searches in \a this, considered as a set of contiguous \c this->getNumberOfComponents() ranges, all ids in \a listOfIds
10374 * filling completely one of the ranges in \a this.
10376 * \param [in] listOfIds a list of ids that has to be sorted ascendingly.
10377 * \param [out] rangeIdsFetched the range ids fetched
10378 * \param [out] idsInInputListThatFetch contains the list of ids in \a listOfIds that are \b fully included in a range in \a this. So
10379 * \a idsInInputListThatFetch is a part of input \a listOfIds.
10381 * \sa DataArrayInt::computeOffsets2
10384 * - \a this : [0,3,7,9,15,18]
10385 * - \a listOfIds contains [0,1,2,3,7,8,15,16,17]
10386 * - \a rangeIdsFetched result array: [0,2,4]
10387 * - \a idsInInputListThatFetch result array: [0,1,2,7,8,15,16,17]
10388 * In this example id 3 in input \a listOfIds is alone so it do not appear in output \a idsInInputListThatFetch.
10391 void DataArrayInt::searchRangesInListOfIds(const DataArrayInt *listOfIds, DataArrayInt *& rangeIdsFetched, DataArrayInt *& idsInInputListThatFetch) const
10394 throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : input list of ids is null !");
10395 listOfIds->checkAllocated(); checkAllocated();
10396 if(listOfIds->getNumberOfComponents()!=1)
10397 throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : input list of ids must have exactly one component !");
10398 if(getNumberOfComponents()!=1)
10399 throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : this must have exactly one component !");
10400 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret0=DataArrayInt::New(); ret0->alloc(0,1);
10401 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New(); ret1->alloc(0,1);
10402 const int *tupEnd(listOfIds->end()),*offBg(begin()),*offEnd(end()-1);
10403 const int *tupPtr(listOfIds->begin()),*offPtr(offBg);
10404 while(tupPtr!=tupEnd && offPtr!=offEnd)
10406 if(*tupPtr==*offPtr)
10409 while(i<offPtr[1] && *tupPtr==i && tupPtr!=tupEnd) { i++; tupPtr++; }
10412 ret0->pushBackSilent((int)std::distance(offBg,offPtr));
10413 ret1->pushBackValsSilent(tupPtr-(offPtr[1]-offPtr[0]),tupPtr);
10418 { if(*tupPtr<*offPtr) tupPtr++; else offPtr++; }
10420 rangeIdsFetched=ret0.retn();
10421 idsInInputListThatFetch=ret1.retn();
10425 * Returns a new DataArrayInt whose contents is computed from that of \a this and \a
10426 * offsets arrays as follows. \a offsets is a one-dimensional array considered as an
10427 * "index" array of a "iota" array, thus, whose each element gives an index of a group
10428 * beginning within the "iota" array. And \a this is a one-dimensional array
10429 * considered as a selector of groups described by \a offsets to include into the result array.
10430 * \throw If \a offsets is NULL.
10431 * \throw If \a offsets is not allocated.
10432 * \throw If \a offsets->getNumberOfComponents() != 1.
10433 * \throw If \a offsets is not monotonically increasing.
10434 * \throw If \a this is not allocated.
10435 * \throw If \a this->getNumberOfComponents() != 1.
10436 * \throw If any element of \a this is not a valid index for \a offsets array.
10439 * - \a this: [0,2,3]
10440 * - \a offsets: [0,3,6,10,14,20]
10441 * - result array: [0,1,2,6,7,8,9,10,11,12,13] == <br>
10442 * \c range(0,3) + \c range(6,10) + \c range(10,14) ==<br>
10443 * \c range( \a offsets[ \a this[0] ], offsets[ \a this[0]+1 ]) +
10444 * \c range( \a offsets[ \a this[1] ], offsets[ \a this[1]+1 ]) +
10445 * \c range( \a offsets[ \a this[2] ], offsets[ \a this[2]+1 ])
10447 DataArrayInt *DataArrayInt::buildExplicitArrByRanges(const DataArrayInt *offsets) const
10450 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : DataArrayInt pointer in input is NULL !");
10452 if(getNumberOfComponents()!=1)
10453 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : only single component allowed !");
10454 offsets->checkAllocated();
10455 if(offsets->getNumberOfComponents()!=1)
10456 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : input array should have only single component !");
10457 int othNbTuples=offsets->getNumberOfTuples()-1;
10458 int nbOfTuples=getNumberOfTuples();
10459 int retNbOftuples=0;
10460 const int *work=getConstPointer();
10461 const int *offPtr=offsets->getConstPointer();
10462 for(int i=0;i<nbOfTuples;i++)
10465 if(val>=0 && val<othNbTuples)
10467 int delta=offPtr[val+1]-offPtr[val];
10469 retNbOftuples+=delta;
10472 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrByRanges : Tuple #" << val << " of offset array has a delta < 0 !";
10473 throw INTERP_KERNEL::Exception(oss.str().c_str());
10478 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrByRanges : Tuple #" << i << " in this contains " << val;
10479 oss << " whereas offsets array is of size " << othNbTuples+1 << " !";
10480 throw INTERP_KERNEL::Exception(oss.str().c_str());
10483 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10484 ret->alloc(retNbOftuples,1);
10485 int *retPtr=ret->getPointer();
10486 for(int i=0;i<nbOfTuples;i++)
10489 int start=offPtr[val];
10490 int off=offPtr[val+1]-start;
10491 for(int j=0;j<off;j++,retPtr++)
10498 * Returns a new DataArrayInt whose contents is computed using \a this that must be a
10499 * scaled array (monotonically increasing).
10500 from that of \a this and \a
10501 * offsets arrays as follows. \a offsets is a one-dimensional array considered as an
10502 * "index" array of a "iota" array, thus, whose each element gives an index of a group
10503 * beginning within the "iota" array. And \a this is a one-dimensional array
10504 * considered as a selector of groups described by \a offsets to include into the result array.
10505 * \throw If \a is NULL.
10506 * \throw If \a this is not allocated.
10507 * \throw If \a this->getNumberOfComponents() != 1.
10508 * \throw If \a this->getNumberOfTuples() == 0.
10509 * \throw If \a this is not monotonically increasing.
10510 * \throw If any element of ids in ( \a bg \a stop \a step ) points outside the scale in \a this.
10513 * - \a bg , \a stop and \a step : (0,5,2)
10514 * - \a this: [0,3,6,10,14,20]
10515 * - result array: [0,0,0, 2,2,2,2, 4,4,4,4,4,4] == <br>
10517 DataArrayInt *DataArrayInt::buildExplicitArrOfSliceOnScaledArr(int bg, int stop, int step) const
10520 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : not allocated array !");
10521 if(getNumberOfComponents()!=1)
10522 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : number of components is expected to be equal to one !");
10523 int nbOfTuples(getNumberOfTuples());
10525 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : number of tuples must be != 0 !");
10526 const int *ids(begin());
10527 int nbOfEltsInSlc(GetNumberOfItemGivenBESRelative(bg,stop,step,"DataArrayInt::buildExplicitArrOfSliceOnScaledArr")),sz(0),pos(bg);
10528 for(int i=0;i<nbOfEltsInSlc;i++,pos+=step)
10530 if(pos>=0 && pos<nbOfTuples-1)
10532 int delta(ids[pos+1]-ids[pos]);
10536 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrOfSliceOnScaledArr : At pos #" << i << " of input slice, value is " << pos << " and at this pos this is not monotonically increasing !";
10537 throw INTERP_KERNEL::Exception(oss.str().c_str());
10542 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrOfSliceOnScaledArr : At pos #" << i << " of input slice, value is " << pos << " should be in [0," << nbOfTuples-1 << ") !";
10543 throw INTERP_KERNEL::Exception(oss.str().c_str());
10546 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
10547 int *retPtr(ret->getPointer());
10549 for(int i=0;i<nbOfEltsInSlc;i++,pos+=step)
10551 int delta(ids[pos+1]-ids[pos]);
10552 for(int j=0;j<delta;j++,retPtr++)
10559 * 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.
10560 * 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
10561 * in tuple **i** of returned DataArrayInt.
10562 * If ranges overlapped (in theory it should not) this method do not detect it and always returns the first range.
10564 * 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)]
10565 * The return DataArrayInt will contain : **[0,4,1,2,2,3]**
10567 * \param [in] ranges typically come from output of MEDCouplingUMesh::ComputeRangesFromTypeDistribution. Each range is specified like this : 1st component is
10568 * for lower value included and 2nd component is the upper value of corresponding range **excluded**.
10569 * \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
10570 * is thrown if no ranges in \a ranges contains value in \a this.
10572 * \sa DataArrayInt::findIdInRangeForEachTuple
10574 DataArrayInt *DataArrayInt::findRangeIdForEachTuple(const DataArrayInt *ranges) const
10577 throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : null input pointer !");
10578 if(ranges->getNumberOfComponents()!=2)
10579 throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : input DataArrayInt instance should have 2 components !");
10581 if(getNumberOfComponents()!=1)
10582 throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : this should have only one component !");
10583 int nbTuples=getNumberOfTuples();
10584 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTuples,1);
10585 int nbOfRanges=ranges->getNumberOfTuples();
10586 const int *rangesPtr=ranges->getConstPointer();
10587 int *retPtr=ret->getPointer();
10588 const int *inPtr=getConstPointer();
10589 for(int i=0;i<nbTuples;i++,retPtr++)
10593 for(int j=0;j<nbOfRanges && !found;j++)
10594 if(val>=rangesPtr[2*j] && val<rangesPtr[2*j+1])
10595 { *retPtr=j; found=true; }
10600 std::ostringstream oss; oss << "DataArrayInt::findRangeIdForEachTuple : tuple #" << i << " not found by any ranges !";
10601 throw INTERP_KERNEL::Exception(oss.str().c_str());
10608 * 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.
10609 * 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
10610 * in tuple **i** of returned DataArrayInt.
10611 * If ranges overlapped (in theory it should not) this method do not detect it and always returns the sub position of the first range.
10613 * 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)]
10614 * The return DataArrayInt will contain : **[1,2,4,0,2,2]**
10615 * This method is often called in pair with DataArrayInt::findRangeIdForEachTuple method.
10617 * \param [in] ranges typically come from output of MEDCouplingUMesh::ComputeRangesFromTypeDistribution. Each range is specified like this : 1st component is
10618 * for lower value included and 2nd component is the upper value of corresponding range **excluded**.
10619 * \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
10620 * is thrown if no ranges in \a ranges contains value in \a this.
10621 * \sa DataArrayInt::findRangeIdForEachTuple
10623 DataArrayInt *DataArrayInt::findIdInRangeForEachTuple(const DataArrayInt *ranges) const
10626 throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : null input pointer !");
10627 if(ranges->getNumberOfComponents()!=2)
10628 throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : input DataArrayInt instance should have 2 components !");
10630 if(getNumberOfComponents()!=1)
10631 throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : this should have only one component !");
10632 int nbTuples=getNumberOfTuples();
10633 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTuples,1);
10634 int nbOfRanges=ranges->getNumberOfTuples();
10635 const int *rangesPtr=ranges->getConstPointer();
10636 int *retPtr=ret->getPointer();
10637 const int *inPtr=getConstPointer();
10638 for(int i=0;i<nbTuples;i++,retPtr++)
10642 for(int j=0;j<nbOfRanges && !found;j++)
10643 if(val>=rangesPtr[2*j] && val<rangesPtr[2*j+1])
10644 { *retPtr=val-rangesPtr[2*j]; found=true; }
10649 std::ostringstream oss; oss << "DataArrayInt::findIdInRangeForEachTuple : tuple #" << i << " not found by any ranges !";
10650 throw INTERP_KERNEL::Exception(oss.str().c_str());
10657 * \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).
10658 * 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).
10659 * 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 !
10660 * If this method has correctly worked, \a this will be able to be considered as a linked list.
10661 * This method does nothing if number of tuples is lower of equal to 1.
10663 * This method is useful for users having an unstructured mesh having only SEG2 to rearrange internaly the connectibity without any coordinates consideration.
10665 * \sa MEDCouplingUMesh::orderConsecutiveCells1D
10667 void DataArrayInt::sortEachPairToMakeALinkedList()
10670 if(getNumberOfComponents()!=2)
10671 throw INTERP_KERNEL::Exception("DataArrayInt::sortEachPairToMakeALinkedList : Only works on DataArrayInt instance with nb of components equal to 2 !");
10672 int nbOfTuples(getNumberOfTuples());
10675 int *conn(getPointer());
10676 for(int i=1;i<nbOfTuples;i++,conn+=2)
10680 if(conn[2]==conn[3])
10682 std::ostringstream oss; oss << "DataArrayInt::sortEachPairToMakeALinkedList : In the tuple #" << i << " presence of a pair filled with same ids !";
10683 throw INTERP_KERNEL::Exception(oss.str().c_str());
10685 if(conn[2]!=conn[1] && conn[3]==conn[1] && conn[2]!=conn[0])
10686 std::swap(conn[2],conn[3]);
10687 //not(conn[2]==conn[1] && conn[3]!=conn[1] && conn[3]!=conn[0])
10688 if(conn[2]!=conn[1] || conn[3]==conn[1] || conn[3]==conn[0])
10690 std::ostringstream oss; oss << "DataArrayInt::sortEachPairToMakeALinkedList : In the tuple #" << i << " something is invalid !";
10691 throw INTERP_KERNEL::Exception(oss.str().c_str());
10696 if(conn[0]==conn[1] || conn[2]==conn[3])
10697 throw INTERP_KERNEL::Exception("DataArrayInt::sortEachPairToMakeALinkedList : In the 2 first tuples presence of a pair filled with same ids !");
10700 s.insert(conn,conn+4);
10702 throw INTERP_KERNEL::Exception("DataArrayInt::sortEachPairToMakeALinkedList : This can't be considered as a linked list regarding 2 first tuples !");
10703 if(std::count(conn,conn+4,conn[0])==2)
10708 if(conn[2]==conn[0])
10709 { tmp[3]=conn[3]; }
10712 std::copy(tmp,tmp+4,conn);
10720 * \param [in] nbTimes specifies the nb of times each tuples in \a this will be duplicated contiguouly in returned DataArrayInt instance.
10721 * \a nbTimes should be at least equal to 1.
10722 * \return a newly allocated DataArrayInt having one component and number of tuples equal to \a nbTimes * \c this->getNumberOfTuples.
10723 * \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.
10725 DataArrayInt *DataArrayInt::duplicateEachTupleNTimes(int nbTimes) const
10728 if(getNumberOfComponents()!=1)
10729 throw INTERP_KERNEL::Exception("DataArrayInt::duplicateEachTupleNTimes : this should have only one component !");
10731 throw INTERP_KERNEL::Exception("DataArrayInt::duplicateEachTupleNTimes : nb times should be >= 1 !");
10732 int nbTuples=getNumberOfTuples();
10733 const int *inPtr=getConstPointer();
10734 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTimes*nbTuples,1);
10735 int *retPtr=ret->getPointer();
10736 for(int i=0;i<nbTuples;i++,inPtr++)
10739 for(int j=0;j<nbTimes;j++,retPtr++)
10742 ret->copyStringInfoFrom(*this);
10747 * This method returns all different values found in \a this. This method throws if \a this has not been allocated.
10748 * But the number of components can be different from one.
10749 * \return a newly allocated array (that should be dealt by the caller) containing different values in \a this.
10751 DataArrayInt *DataArrayInt::getDifferentValues() const
10755 ret.insert(begin(),end());
10756 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret2=DataArrayInt::New(); ret2->alloc((int)ret.size(),1);
10757 std::copy(ret.begin(),ret.end(),ret2->getPointer());
10758 return ret2.retn();
10762 * This method is a refinement of DataArrayInt::getDifferentValues because it returns not only different values in \a this but also, for each of
10763 * them it tells which tuple id have this id.
10764 * This method works only on arrays with one component (if it is not the case call DataArrayInt::rearrange(1) ).
10765 * This method returns two arrays having same size.
10766 * 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.
10767 * 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]]
10769 std::vector<DataArrayInt *> DataArrayInt::partitionByDifferentValues(std::vector<int>& differentIds) const
10772 if(getNumberOfComponents()!=1)
10773 throw INTERP_KERNEL::Exception("DataArrayInt::partitionByDifferentValues : this should have only one component !");
10775 std::map<int,int> m,m2,m3;
10776 for(const int *w=begin();w!=end();w++)
10778 differentIds.resize(m.size());
10779 std::vector<DataArrayInt *> ret(m.size());
10780 std::vector<int *> retPtr(m.size());
10781 for(std::map<int,int>::const_iterator it=m.begin();it!=m.end();it++,id++)
10783 m2[(*it).first]=id;
10784 ret[id]=DataArrayInt::New();
10785 ret[id]->alloc((*it).second,1);
10786 retPtr[id]=ret[id]->getPointer();
10787 differentIds[id]=(*it).first;
10790 for(const int *w=begin();w!=end();w++,id++)
10792 retPtr[m2[*w]][m3[*w]++]=id;
10798 * This method split ids in [0, \c this->getNumberOfTuples() ) using \a this array as a field of weight (>=0 each).
10799 * The aim of this method is to return a set of \a nbOfSlices chunk of contiguous ids as balanced as possible.
10801 * \param [in] nbOfSlices - number of slices expected.
10802 * \return - a vector having a size equal to \a nbOfSlices giving the start (included) and the stop (excluded) of each chunks.
10804 * \sa DataArray::GetSlice
10805 * \throw If \a this is not allocated or not with exactly one component.
10806 * \throw If an element in \a this if < 0.
10808 std::vector< std::pair<int,int> > DataArrayInt::splitInBalancedSlices(int nbOfSlices) const
10810 if(!isAllocated() || getNumberOfComponents()!=1)
10811 throw INTERP_KERNEL::Exception("DataArrayInt::splitInBalancedSlices : this array should have number of components equal to one and must be allocated !");
10813 throw INTERP_KERNEL::Exception("DataArrayInt::splitInBalancedSlices : number of slices must be >= 1 !");
10814 int sum(accumulate(0)),nbOfTuples(getNumberOfTuples());
10815 int sumPerSlc(sum/nbOfSlices),pos(0);
10816 const int *w(begin());
10817 std::vector< std::pair<int,int> > ret(nbOfSlices);
10818 for(int i=0;i<nbOfSlices;i++)
10820 std::pair<int,int> p(pos,-1);
10822 while(locSum<sumPerSlc && pos<nbOfTuples) { pos++; locSum+=*w++; }
10823 if(i!=nbOfSlices-1)
10826 p.second=nbOfTuples;
10833 * Returns a new DataArrayInt that is a sum of two given arrays. There are 3
10835 * 1. The arrays have same number of tuples and components. Then each value of
10836 * the result array (_a_) is a sum of the corresponding values of \a a1 and \a a2,
10837 * i.e.: _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, j ].
10838 * 2. The arrays have same number of tuples and one array, say _a2_, has one
10840 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, 0 ].
10841 * 3. The arrays have same number of components and one array, say _a2_, has one
10843 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ 0, j ].
10845 * Info on components is copied either from the first array (in the first case) or from
10846 * the array with maximal number of elements (getNbOfElems()).
10847 * \param [in] a1 - an array to sum up.
10848 * \param [in] a2 - another array to sum up.
10849 * \return DataArrayInt * - the new instance of DataArrayInt.
10850 * The caller is to delete this result array using decrRef() as it is no more
10852 * \throw If either \a a1 or \a a2 is NULL.
10853 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
10854 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
10855 * none of them has number of tuples or components equal to 1.
10857 DataArrayInt *DataArrayInt::Add(const DataArrayInt *a1, const DataArrayInt *a2)
10860 throw INTERP_KERNEL::Exception("DataArrayInt::Add : input DataArrayInt instance is NULL !");
10861 int nbOfTuple=a1->getNumberOfTuples();
10862 int nbOfTuple2=a2->getNumberOfTuples();
10863 int nbOfComp=a1->getNumberOfComponents();
10864 int nbOfComp2=a2->getNumberOfComponents();
10865 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=0;
10866 if(nbOfTuple==nbOfTuple2)
10868 if(nbOfComp==nbOfComp2)
10870 ret=DataArrayInt::New();
10871 ret->alloc(nbOfTuple,nbOfComp);
10872 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::plus<int>());
10873 ret->copyStringInfoFrom(*a1);
10877 int nbOfCompMin,nbOfCompMax;
10878 const DataArrayInt *aMin, *aMax;
10879 if(nbOfComp>nbOfComp2)
10881 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
10886 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
10891 ret=DataArrayInt::New();
10892 ret->alloc(nbOfTuple,nbOfCompMax);
10893 const int *aMinPtr=aMin->getConstPointer();
10894 const int *aMaxPtr=aMax->getConstPointer();
10895 int *res=ret->getPointer();
10896 for(int i=0;i<nbOfTuple;i++)
10897 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::plus<int>(),aMinPtr[i]));
10898 ret->copyStringInfoFrom(*aMax);
10901 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
10904 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
10906 if(nbOfComp==nbOfComp2)
10908 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
10909 const DataArrayInt *aMin=nbOfTuple>nbOfTuple2?a2:a1;
10910 const DataArrayInt *aMax=nbOfTuple>nbOfTuple2?a1:a2;
10911 const int *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
10912 ret=DataArrayInt::New();
10913 ret->alloc(nbOfTupleMax,nbOfComp);
10914 int *res=ret->getPointer();
10915 for(int i=0;i<nbOfTupleMax;i++)
10916 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::plus<int>());
10917 ret->copyStringInfoFrom(*aMax);
10920 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
10923 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Add !");
10928 * Adds values of another DataArrayInt to values of \a this one. There are 3
10930 * 1. The arrays have same number of tuples and components. Then each value of
10931 * \a other array is added to the corresponding value of \a this array, i.e.:
10932 * _a_ [ i, j ] += _other_ [ i, j ].
10933 * 2. The arrays have same number of tuples and \a other array has one component. Then
10934 * _a_ [ i, j ] += _other_ [ i, 0 ].
10935 * 3. The arrays have same number of components and \a other array has one tuple. Then
10936 * _a_ [ i, j ] += _a2_ [ 0, j ].
10938 * \param [in] other - an array to add to \a this one.
10939 * \throw If \a other is NULL.
10940 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
10941 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
10942 * \a other has number of both tuples and components not equal to 1.
10944 void DataArrayInt::addEqual(const DataArrayInt *other)
10947 throw INTERP_KERNEL::Exception("DataArrayInt::addEqual : input DataArrayInt instance is NULL !");
10948 const char *msg="Nb of tuples mismatch for DataArrayInt::addEqual !";
10949 checkAllocated(); other->checkAllocated();
10950 int nbOfTuple=getNumberOfTuples();
10951 int nbOfTuple2=other->getNumberOfTuples();
10952 int nbOfComp=getNumberOfComponents();
10953 int nbOfComp2=other->getNumberOfComponents();
10954 if(nbOfTuple==nbOfTuple2)
10956 if(nbOfComp==nbOfComp2)
10958 std::transform(begin(),end(),other->begin(),getPointer(),std::plus<int>());
10960 else if(nbOfComp2==1)
10962 int *ptr=getPointer();
10963 const int *ptrc=other->getConstPointer();
10964 for(int i=0;i<nbOfTuple;i++)
10965 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::plus<int>(),*ptrc++));
10968 throw INTERP_KERNEL::Exception(msg);
10970 else if(nbOfTuple2==1)
10972 if(nbOfComp2==nbOfComp)
10974 int *ptr=getPointer();
10975 const int *ptrc=other->getConstPointer();
10976 for(int i=0;i<nbOfTuple;i++)
10977 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::plus<int>());
10980 throw INTERP_KERNEL::Exception(msg);
10983 throw INTERP_KERNEL::Exception(msg);
10988 * Returns a new DataArrayInt that is a subtraction of two given arrays. There are 3
10990 * 1. The arrays have same number of tuples and components. Then each value of
10991 * the result array (_a_) is a subtraction of the corresponding values of \a a1 and
10992 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, j ].
10993 * 2. The arrays have same number of tuples and one array, say _a2_, has one
10995 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, 0 ].
10996 * 3. The arrays have same number of components and one array, say _a2_, has one
10998 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ 0, j ].
11000 * Info on components is copied either from the first array (in the first case) or from
11001 * the array with maximal number of elements (getNbOfElems()).
11002 * \param [in] a1 - an array to subtract from.
11003 * \param [in] a2 - an array to subtract.
11004 * \return DataArrayInt * - the new instance of DataArrayInt.
11005 * The caller is to delete this result array using decrRef() as it is no more
11007 * \throw If either \a a1 or \a a2 is NULL.
11008 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
11009 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
11010 * none of them has number of tuples or components equal to 1.
11012 DataArrayInt *DataArrayInt::Substract(const DataArrayInt *a1, const DataArrayInt *a2)
11015 throw INTERP_KERNEL::Exception("DataArrayInt::Substract : input DataArrayInt instance is NULL !");
11016 int nbOfTuple1=a1->getNumberOfTuples();
11017 int nbOfTuple2=a2->getNumberOfTuples();
11018 int nbOfComp1=a1->getNumberOfComponents();
11019 int nbOfComp2=a2->getNumberOfComponents();
11020 if(nbOfTuple2==nbOfTuple1)
11022 if(nbOfComp1==nbOfComp2)
11024 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11025 ret->alloc(nbOfTuple2,nbOfComp1);
11026 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::minus<int>());
11027 ret->copyStringInfoFrom(*a1);
11030 else if(nbOfComp2==1)
11032 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11033 ret->alloc(nbOfTuple1,nbOfComp1);
11034 const int *a2Ptr=a2->getConstPointer();
11035 const int *a1Ptr=a1->getConstPointer();
11036 int *res=ret->getPointer();
11037 for(int i=0;i<nbOfTuple1;i++)
11038 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::minus<int>(),a2Ptr[i]));
11039 ret->copyStringInfoFrom(*a1);
11044 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
11048 else if(nbOfTuple2==1)
11050 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
11051 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11052 ret->alloc(nbOfTuple1,nbOfComp1);
11053 const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
11054 int *pt=ret->getPointer();
11055 for(int i=0;i<nbOfTuple1;i++)
11056 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::minus<int>());
11057 ret->copyStringInfoFrom(*a1);
11062 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Substract !");//will always throw an exception
11068 * Subtract values of another DataArrayInt from values of \a this one. There are 3
11070 * 1. The arrays have same number of tuples and components. Then each value of
11071 * \a other array is subtracted from the corresponding value of \a this array, i.e.:
11072 * _a_ [ i, j ] -= _other_ [ i, j ].
11073 * 2. The arrays have same number of tuples and \a other array has one component. Then
11074 * _a_ [ i, j ] -= _other_ [ i, 0 ].
11075 * 3. The arrays have same number of components and \a other array has one tuple. Then
11076 * _a_ [ i, j ] -= _a2_ [ 0, j ].
11078 * \param [in] other - an array to subtract from \a this one.
11079 * \throw If \a other is NULL.
11080 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
11081 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
11082 * \a other has number of both tuples and components not equal to 1.
11084 void DataArrayInt::substractEqual(const DataArrayInt *other)
11087 throw INTERP_KERNEL::Exception("DataArrayInt::substractEqual : input DataArrayInt instance is NULL !");
11088 const char *msg="Nb of tuples mismatch for DataArrayInt::substractEqual !";
11089 checkAllocated(); other->checkAllocated();
11090 int nbOfTuple=getNumberOfTuples();
11091 int nbOfTuple2=other->getNumberOfTuples();
11092 int nbOfComp=getNumberOfComponents();
11093 int nbOfComp2=other->getNumberOfComponents();
11094 if(nbOfTuple==nbOfTuple2)
11096 if(nbOfComp==nbOfComp2)
11098 std::transform(begin(),end(),other->begin(),getPointer(),std::minus<int>());
11100 else if(nbOfComp2==1)
11102 int *ptr=getPointer();
11103 const int *ptrc=other->getConstPointer();
11104 for(int i=0;i<nbOfTuple;i++)
11105 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::minus<int>(),*ptrc++));
11108 throw INTERP_KERNEL::Exception(msg);
11110 else if(nbOfTuple2==1)
11112 int *ptr=getPointer();
11113 const int *ptrc=other->getConstPointer();
11114 for(int i=0;i<nbOfTuple;i++)
11115 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::minus<int>());
11118 throw INTERP_KERNEL::Exception(msg);
11123 * Returns a new DataArrayInt that is a product of two given arrays. There are 3
11125 * 1. The arrays have same number of tuples and components. Then each value of
11126 * the result array (_a_) is a product of the corresponding values of \a a1 and
11127 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, j ].
11128 * 2. The arrays have same number of tuples and one array, say _a2_, has one
11130 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, 0 ].
11131 * 3. The arrays have same number of components and one array, say _a2_, has one
11133 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ 0, j ].
11135 * Info on components is copied either from the first array (in the first case) or from
11136 * the array with maximal number of elements (getNbOfElems()).
11137 * \param [in] a1 - a factor array.
11138 * \param [in] a2 - another factor array.
11139 * \return DataArrayInt * - the new instance of DataArrayInt.
11140 * The caller is to delete this result array using decrRef() as it is no more
11142 * \throw If either \a a1 or \a a2 is NULL.
11143 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
11144 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
11145 * none of them has number of tuples or components equal to 1.
11147 DataArrayInt *DataArrayInt::Multiply(const DataArrayInt *a1, const DataArrayInt *a2)
11150 throw INTERP_KERNEL::Exception("DataArrayInt::Multiply : input DataArrayInt instance is NULL !");
11151 int nbOfTuple=a1->getNumberOfTuples();
11152 int nbOfTuple2=a2->getNumberOfTuples();
11153 int nbOfComp=a1->getNumberOfComponents();
11154 int nbOfComp2=a2->getNumberOfComponents();
11155 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=0;
11156 if(nbOfTuple==nbOfTuple2)
11158 if(nbOfComp==nbOfComp2)
11160 ret=DataArrayInt::New();
11161 ret->alloc(nbOfTuple,nbOfComp);
11162 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::multiplies<int>());
11163 ret->copyStringInfoFrom(*a1);
11167 int nbOfCompMin,nbOfCompMax;
11168 const DataArrayInt *aMin, *aMax;
11169 if(nbOfComp>nbOfComp2)
11171 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
11176 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
11181 ret=DataArrayInt::New();
11182 ret->alloc(nbOfTuple,nbOfCompMax);
11183 const int *aMinPtr=aMin->getConstPointer();
11184 const int *aMaxPtr=aMax->getConstPointer();
11185 int *res=ret->getPointer();
11186 for(int i=0;i<nbOfTuple;i++)
11187 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::multiplies<int>(),aMinPtr[i]));
11188 ret->copyStringInfoFrom(*aMax);
11191 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
11194 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
11196 if(nbOfComp==nbOfComp2)
11198 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
11199 const DataArrayInt *aMin=nbOfTuple>nbOfTuple2?a2:a1;
11200 const DataArrayInt *aMax=nbOfTuple>nbOfTuple2?a1:a2;
11201 const int *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
11202 ret=DataArrayInt::New();
11203 ret->alloc(nbOfTupleMax,nbOfComp);
11204 int *res=ret->getPointer();
11205 for(int i=0;i<nbOfTupleMax;i++)
11206 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::multiplies<int>());
11207 ret->copyStringInfoFrom(*aMax);
11210 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
11213 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Multiply !");
11219 * Multiply values of another DataArrayInt to values of \a this one. There are 3
11221 * 1. The arrays have same number of tuples and components. Then each value of
11222 * \a other array is multiplied to the corresponding value of \a this array, i.e.:
11223 * _a_ [ i, j ] *= _other_ [ i, j ].
11224 * 2. The arrays have same number of tuples and \a other array has one component. Then
11225 * _a_ [ i, j ] *= _other_ [ i, 0 ].
11226 * 3. The arrays have same number of components and \a other array has one tuple. Then
11227 * _a_ [ i, j ] *= _a2_ [ 0, j ].
11229 * \param [in] other - an array to multiply to \a this one.
11230 * \throw If \a other is NULL.
11231 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
11232 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
11233 * \a other has number of both tuples and components not equal to 1.
11235 void DataArrayInt::multiplyEqual(const DataArrayInt *other)
11238 throw INTERP_KERNEL::Exception("DataArrayInt::multiplyEqual : input DataArrayInt instance is NULL !");
11239 const char *msg="Nb of tuples mismatch for DataArrayInt::multiplyEqual !";
11240 checkAllocated(); other->checkAllocated();
11241 int nbOfTuple=getNumberOfTuples();
11242 int nbOfTuple2=other->getNumberOfTuples();
11243 int nbOfComp=getNumberOfComponents();
11244 int nbOfComp2=other->getNumberOfComponents();
11245 if(nbOfTuple==nbOfTuple2)
11247 if(nbOfComp==nbOfComp2)
11249 std::transform(begin(),end(),other->begin(),getPointer(),std::multiplies<int>());
11251 else if(nbOfComp2==1)
11253 int *ptr=getPointer();
11254 const int *ptrc=other->getConstPointer();
11255 for(int i=0;i<nbOfTuple;i++)
11256 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::multiplies<int>(),*ptrc++));
11259 throw INTERP_KERNEL::Exception(msg);
11261 else if(nbOfTuple2==1)
11263 if(nbOfComp2==nbOfComp)
11265 int *ptr=getPointer();
11266 const int *ptrc=other->getConstPointer();
11267 for(int i=0;i<nbOfTuple;i++)
11268 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::multiplies<int>());
11271 throw INTERP_KERNEL::Exception(msg);
11274 throw INTERP_KERNEL::Exception(msg);
11280 * Returns a new DataArrayInt that is a division of two given arrays. There are 3
11282 * 1. The arrays have same number of tuples and components. Then each value of
11283 * the result array (_a_) is a division of the corresponding values of \a a1 and
11284 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, j ].
11285 * 2. The arrays have same number of tuples and one array, say _a2_, has one
11287 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, 0 ].
11288 * 3. The arrays have same number of components and one array, say _a2_, has one
11290 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ 0, j ].
11292 * Info on components is copied either from the first array (in the first case) or from
11293 * the array with maximal number of elements (getNbOfElems()).
11294 * \warning No check of division by zero is performed!
11295 * \param [in] a1 - a numerator array.
11296 * \param [in] a2 - a denominator array.
11297 * \return DataArrayInt * - the new instance of DataArrayInt.
11298 * The caller is to delete this result array using decrRef() as it is no more
11300 * \throw If either \a a1 or \a a2 is NULL.
11301 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
11302 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
11303 * none of them has number of tuples or components equal to 1.
11305 DataArrayInt *DataArrayInt::Divide(const DataArrayInt *a1, const DataArrayInt *a2)
11308 throw INTERP_KERNEL::Exception("DataArrayInt::Divide : input DataArrayInt instance is NULL !");
11309 int nbOfTuple1=a1->getNumberOfTuples();
11310 int nbOfTuple2=a2->getNumberOfTuples();
11311 int nbOfComp1=a1->getNumberOfComponents();
11312 int nbOfComp2=a2->getNumberOfComponents();
11313 if(nbOfTuple2==nbOfTuple1)
11315 if(nbOfComp1==nbOfComp2)
11317 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11318 ret->alloc(nbOfTuple2,nbOfComp1);
11319 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::divides<int>());
11320 ret->copyStringInfoFrom(*a1);
11323 else if(nbOfComp2==1)
11325 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11326 ret->alloc(nbOfTuple1,nbOfComp1);
11327 const int *a2Ptr=a2->getConstPointer();
11328 const int *a1Ptr=a1->getConstPointer();
11329 int *res=ret->getPointer();
11330 for(int i=0;i<nbOfTuple1;i++)
11331 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::divides<int>(),a2Ptr[i]));
11332 ret->copyStringInfoFrom(*a1);
11337 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
11341 else if(nbOfTuple2==1)
11343 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
11344 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11345 ret->alloc(nbOfTuple1,nbOfComp1);
11346 const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
11347 int *pt=ret->getPointer();
11348 for(int i=0;i<nbOfTuple1;i++)
11349 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::divides<int>());
11350 ret->copyStringInfoFrom(*a1);
11355 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Divide !");//will always throw an exception
11361 * Divide values of \a this array by values of another DataArrayInt. There are 3
11363 * 1. The arrays have same number of tuples and components. Then each value of
11364 * \a this array is divided by the corresponding value of \a other one, i.e.:
11365 * _a_ [ i, j ] /= _other_ [ i, j ].
11366 * 2. The arrays have same number of tuples and \a other array has one component. Then
11367 * _a_ [ i, j ] /= _other_ [ i, 0 ].
11368 * 3. The arrays have same number of components and \a other array has one tuple. Then
11369 * _a_ [ i, j ] /= _a2_ [ 0, j ].
11371 * \warning No check of division by zero is performed!
11372 * \param [in] other - an array to divide \a this one by.
11373 * \throw If \a other is NULL.
11374 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
11375 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
11376 * \a other has number of both tuples and components not equal to 1.
11378 void DataArrayInt::divideEqual(const DataArrayInt *other)
11381 throw INTERP_KERNEL::Exception("DataArrayInt::divideEqual : input DataArrayInt instance is NULL !");
11382 const char *msg="Nb of tuples mismatch for DataArrayInt::divideEqual !";
11383 checkAllocated(); other->checkAllocated();
11384 int nbOfTuple=getNumberOfTuples();
11385 int nbOfTuple2=other->getNumberOfTuples();
11386 int nbOfComp=getNumberOfComponents();
11387 int nbOfComp2=other->getNumberOfComponents();
11388 if(nbOfTuple==nbOfTuple2)
11390 if(nbOfComp==nbOfComp2)
11392 std::transform(begin(),end(),other->begin(),getPointer(),std::divides<int>());
11394 else if(nbOfComp2==1)
11396 int *ptr=getPointer();
11397 const int *ptrc=other->getConstPointer();
11398 for(int i=0;i<nbOfTuple;i++)
11399 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::divides<int>(),*ptrc++));
11402 throw INTERP_KERNEL::Exception(msg);
11404 else if(nbOfTuple2==1)
11406 if(nbOfComp2==nbOfComp)
11408 int *ptr=getPointer();
11409 const int *ptrc=other->getConstPointer();
11410 for(int i=0;i<nbOfTuple;i++)
11411 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::divides<int>());
11414 throw INTERP_KERNEL::Exception(msg);
11417 throw INTERP_KERNEL::Exception(msg);
11423 * Returns a new DataArrayInt that is a modulus of two given arrays. There are 3
11425 * 1. The arrays have same number of tuples and components. Then each value of
11426 * the result array (_a_) is a division of the corresponding values of \a a1 and
11427 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ i, j ].
11428 * 2. The arrays have same number of tuples and one array, say _a2_, has one
11430 * _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ i, 0 ].
11431 * 3. The arrays have same number of components and one array, say _a2_, has one
11433 * _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ 0, j ].
11435 * Info on components is copied either from the first array (in the first case) or from
11436 * the array with maximal number of elements (getNbOfElems()).
11437 * \warning No check of division by zero is performed!
11438 * \param [in] a1 - a dividend array.
11439 * \param [in] a2 - a divisor array.
11440 * \return DataArrayInt * - the new instance of DataArrayInt.
11441 * The caller is to delete this result array using decrRef() as it is no more
11443 * \throw If either \a a1 or \a a2 is NULL.
11444 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
11445 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
11446 * none of them has number of tuples or components equal to 1.
11448 DataArrayInt *DataArrayInt::Modulus(const DataArrayInt *a1, const DataArrayInt *a2)
11451 throw INTERP_KERNEL::Exception("DataArrayInt::Modulus : input DataArrayInt instance is NULL !");
11452 int nbOfTuple1=a1->getNumberOfTuples();
11453 int nbOfTuple2=a2->getNumberOfTuples();
11454 int nbOfComp1=a1->getNumberOfComponents();
11455 int nbOfComp2=a2->getNumberOfComponents();
11456 if(nbOfTuple2==nbOfTuple1)
11458 if(nbOfComp1==nbOfComp2)
11460 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11461 ret->alloc(nbOfTuple2,nbOfComp1);
11462 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::modulus<int>());
11463 ret->copyStringInfoFrom(*a1);
11466 else if(nbOfComp2==1)
11468 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11469 ret->alloc(nbOfTuple1,nbOfComp1);
11470 const int *a2Ptr=a2->getConstPointer();
11471 const int *a1Ptr=a1->getConstPointer();
11472 int *res=ret->getPointer();
11473 for(int i=0;i<nbOfTuple1;i++)
11474 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::modulus<int>(),a2Ptr[i]));
11475 ret->copyStringInfoFrom(*a1);
11480 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Modulus !");
11484 else if(nbOfTuple2==1)
11486 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Modulus !");
11487 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11488 ret->alloc(nbOfTuple1,nbOfComp1);
11489 const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
11490 int *pt=ret->getPointer();
11491 for(int i=0;i<nbOfTuple1;i++)
11492 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::modulus<int>());
11493 ret->copyStringInfoFrom(*a1);
11498 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Modulus !");//will always throw an exception
11504 * Modify \a this array so that each value becomes a modulus of division of this value by
11505 * a value of another DataArrayInt. There are 3 valid cases.
11506 * 1. The arrays have same number of tuples and components. Then each value of
11507 * \a this array is divided by the corresponding value of \a other one, i.e.:
11508 * _a_ [ i, j ] %= _other_ [ i, j ].
11509 * 2. The arrays have same number of tuples and \a other array has one component. Then
11510 * _a_ [ i, j ] %= _other_ [ i, 0 ].
11511 * 3. The arrays have same number of components and \a other array has one tuple. Then
11512 * _a_ [ i, j ] %= _a2_ [ 0, j ].
11514 * \warning No check of division by zero is performed!
11515 * \param [in] other - a divisor array.
11516 * \throw If \a other is NULL.
11517 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
11518 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
11519 * \a other has number of both tuples and components not equal to 1.
11521 void DataArrayInt::modulusEqual(const DataArrayInt *other)
11524 throw INTERP_KERNEL::Exception("DataArrayInt::modulusEqual : input DataArrayInt instance is NULL !");
11525 const char *msg="Nb of tuples mismatch for DataArrayInt::modulusEqual !";
11526 checkAllocated(); other->checkAllocated();
11527 int nbOfTuple=getNumberOfTuples();
11528 int nbOfTuple2=other->getNumberOfTuples();
11529 int nbOfComp=getNumberOfComponents();
11530 int nbOfComp2=other->getNumberOfComponents();
11531 if(nbOfTuple==nbOfTuple2)
11533 if(nbOfComp==nbOfComp2)
11535 std::transform(begin(),end(),other->begin(),getPointer(),std::modulus<int>());
11537 else if(nbOfComp2==1)
11539 if(nbOfComp2==nbOfComp)
11541 int *ptr=getPointer();
11542 const int *ptrc=other->getConstPointer();
11543 for(int i=0;i<nbOfTuple;i++)
11544 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::modulus<int>(),*ptrc++));
11547 throw INTERP_KERNEL::Exception(msg);
11550 throw INTERP_KERNEL::Exception(msg);
11552 else if(nbOfTuple2==1)
11554 int *ptr=getPointer();
11555 const int *ptrc=other->getConstPointer();
11556 for(int i=0;i<nbOfTuple;i++)
11557 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::modulus<int>());
11560 throw INTERP_KERNEL::Exception(msg);
11565 * Returns a new DataArrayInt that is the result of pow of two given arrays. There are 3
11568 * \param [in] a1 - an array to pow up.
11569 * \param [in] a2 - another array to sum up.
11570 * \return DataArrayInt * - the new instance of DataArrayInt.
11571 * The caller is to delete this result array using decrRef() as it is no more
11573 * \throw If either \a a1 or \a a2 is NULL.
11574 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
11575 * \throw If \a a1->getNumberOfComponents() != 1 or \a a2->getNumberOfComponents() != 1.
11576 * \throw If there is a negative value in \a a2.
11578 DataArrayInt *DataArrayInt::Pow(const DataArrayInt *a1, const DataArrayInt *a2)
11581 throw INTERP_KERNEL::Exception("DataArrayInt::Pow : at least one of input instances is null !");
11582 int nbOfTuple=a1->getNumberOfTuples();
11583 int nbOfTuple2=a2->getNumberOfTuples();
11584 int nbOfComp=a1->getNumberOfComponents();
11585 int nbOfComp2=a2->getNumberOfComponents();
11586 if(nbOfTuple!=nbOfTuple2)
11587 throw INTERP_KERNEL::Exception("DataArrayInt::Pow : number of tuples mismatches !");
11588 if(nbOfComp!=1 || nbOfComp2!=1)
11589 throw INTERP_KERNEL::Exception("DataArrayInt::Pow : number of components of both arrays must be equal to 1 !");
11590 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbOfTuple,1);
11591 const int *ptr1(a1->begin()),*ptr2(a2->begin());
11592 int *ptr=ret->getPointer();
11593 for(int i=0;i<nbOfTuple;i++,ptr1++,ptr2++,ptr++)
11598 for(int j=0;j<*ptr2;j++)
11604 std::ostringstream oss; oss << "DataArrayInt::Pow : on tuple #" << i << " of a2 value is < 0 (" << *ptr2 << ") !";
11605 throw INTERP_KERNEL::Exception(oss.str().c_str());
11612 * Apply pow on values of another DataArrayInt to values of \a this one.
11614 * \param [in] other - an array to pow to \a this one.
11615 * \throw If \a other is NULL.
11616 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples()
11617 * \throw If \a this->getNumberOfComponents() != 1 or \a other->getNumberOfComponents() != 1
11618 * \throw If there is a negative value in \a other.
11620 void DataArrayInt::powEqual(const DataArrayInt *other)
11623 throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : input instance is null !");
11624 int nbOfTuple=getNumberOfTuples();
11625 int nbOfTuple2=other->getNumberOfTuples();
11626 int nbOfComp=getNumberOfComponents();
11627 int nbOfComp2=other->getNumberOfComponents();
11628 if(nbOfTuple!=nbOfTuple2)
11629 throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : number of tuples mismatches !");
11630 if(nbOfComp!=1 || nbOfComp2!=1)
11631 throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : number of components of both arrays must be equal to 1 !");
11632 int *ptr=getPointer();
11633 const int *ptrc=other->begin();
11634 for(int i=0;i<nbOfTuple;i++,ptrc++,ptr++)
11639 for(int j=0;j<*ptrc;j++)
11645 std::ostringstream oss; oss << "DataArrayInt::powEqual : on tuple #" << i << " of other value is < 0 (" << *ptrc << ") !";
11646 throw INTERP_KERNEL::Exception(oss.str().c_str());
11653 * Returns a C array which is a renumbering map in "Old to New" mode for the input array.
11654 * This map, if applied to \a start array, would make it sorted. For example, if
11655 * \a start array contents are [9,10,0,6,4,11,3,7] then the contents of the result array is
11656 * [5,6,0,3,2,7,1,4].
11657 * \param [in] start - pointer to the first element of the array for which the
11658 * permutation map is computed.
11659 * \param [in] end - pointer specifying the end of the array \a start, so that
11660 * the last value of \a start is \a end[ -1 ].
11661 * \return int * - the result permutation array that the caller is to delete as it is no
11663 * \throw If there are equal values in the input array.
11665 int *DataArrayInt::CheckAndPreparePermutation(const int *start, const int *end)
11667 std::size_t sz=std::distance(start,end);
11668 int *ret=(int *)malloc(sz*sizeof(int));
11669 int *work=new int[sz];
11670 std::copy(start,end,work);
11671 std::sort(work,work+sz);
11672 if(std::unique(work,work+sz)!=work+sz)
11676 throw INTERP_KERNEL::Exception("Some elements are equals in the specified array !");
11678 std::map<int,int> m;
11679 for(int *workPt=work;workPt!=work+sz;workPt++)
11680 m[*workPt]=(int)std::distance(work,workPt);
11682 for(const int *iter=start;iter!=end;iter++,iter2++)
11689 * Returns a new DataArrayInt containing an arithmetic progression
11690 * that is equal to the sequence returned by Python \c range(\a begin,\a end,\a step )
11692 * \param [in] begin - the start value of the result sequence.
11693 * \param [in] end - limiting value, so that every value of the result array is less than
11695 * \param [in] step - specifies the increment or decrement.
11696 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
11697 * array using decrRef() as it is no more needed.
11698 * \throw If \a step == 0.
11699 * \throw If \a end < \a begin && \a step > 0.
11700 * \throw If \a end > \a begin && \a step < 0.
11702 DataArrayInt *DataArrayInt::Range(int begin, int end, int step)
11704 int nbOfTuples=GetNumberOfItemGivenBESRelative(begin,end,step,"DataArrayInt::Range");
11705 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11706 ret->alloc(nbOfTuples,1);
11707 int *ptr=ret->getPointer();
11710 for(int i=begin;i<end;i+=step,ptr++)
11715 for(int i=begin;i>end;i+=step,ptr++)
11722 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
11725 void DataArrayInt::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
11727 tinyInfo.resize(2);
11730 tinyInfo[0]=getNumberOfTuples();
11731 tinyInfo[1]=getNumberOfComponents();
11741 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
11744 void DataArrayInt::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
11748 int nbOfCompo=getNumberOfComponents();
11749 tinyInfo.resize(nbOfCompo+1);
11750 tinyInfo[0]=getName();
11751 for(int i=0;i<nbOfCompo;i++)
11752 tinyInfo[i+1]=getInfoOnComponent(i);
11756 tinyInfo.resize(1);
11757 tinyInfo[0]=getName();
11762 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
11763 * This method returns if a feeding is needed.
11765 bool DataArrayInt::resizeForUnserialization(const std::vector<int>& tinyInfoI)
11767 int nbOfTuple=tinyInfoI[0];
11768 int nbOfComp=tinyInfoI[1];
11769 if(nbOfTuple!=-1 || nbOfComp!=-1)
11771 alloc(nbOfTuple,nbOfComp);
11778 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
11779 * This method returns if a feeding is needed.
11781 void DataArrayInt::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<std::string>& tinyInfoS)
11783 setName(tinyInfoS[0]);
11786 int nbOfCompo=tinyInfoI[1];
11787 for(int i=0;i<nbOfCompo;i++)
11788 setInfoOnComponent(i,tinyInfoS[i+1]);
11792 DataArrayIntIterator::DataArrayIntIterator(DataArrayInt *da):_da(da),_pt(0),_tuple_id(0),_nb_comp(0),_nb_tuple(0)
11797 if(_da->isAllocated())
11799 _nb_comp=da->getNumberOfComponents();
11800 _nb_tuple=da->getNumberOfTuples();
11801 _pt=da->getPointer();
11806 DataArrayIntIterator::~DataArrayIntIterator()
11812 DataArrayIntTuple *DataArrayIntIterator::nextt()
11814 if(_tuple_id<_nb_tuple)
11817 DataArrayIntTuple *ret=new DataArrayIntTuple(_pt,_nb_comp);
11825 DataArrayIntTuple::DataArrayIntTuple(int *pt, int nbOfComp):_pt(pt),_nb_of_compo(nbOfComp)
11829 std::string DataArrayIntTuple::repr() const
11831 std::ostringstream oss; oss << "(";
11832 for(int i=0;i<_nb_of_compo-1;i++)
11833 oss << _pt[i] << ", ";
11834 oss << _pt[_nb_of_compo-1] << ")";
11838 int DataArrayIntTuple::intValue() const
11840 if(_nb_of_compo==1)
11842 throw INTERP_KERNEL::Exception("DataArrayIntTuple::intValue : DataArrayIntTuple instance has not exactly 1 component -> Not possible to convert it into an integer !");
11846 * This method returns a newly allocated instance the caller should dealed with by a ParaMEDMEM::DataArrayInt::decrRef.
11847 * This method performs \b no copy of data. The content is only referenced using ParaMEDMEM::DataArrayInt::useArray with ownership set to \b false.
11848 * 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
11849 * \b nbOfCompo=1 and \bnbOfTuples==this->_nb_of_elem.
11851 DataArrayInt *DataArrayIntTuple::buildDAInt(int nbOfTuples, int nbOfCompo) const
11853 if((_nb_of_compo==nbOfCompo && nbOfTuples==1) || (_nb_of_compo==nbOfTuples && nbOfCompo==1))
11855 DataArrayInt *ret=DataArrayInt::New();
11856 ret->useExternalArrayWithRWAccess(_pt,nbOfTuples,nbOfCompo);
11861 std::ostringstream oss; oss << "DataArrayIntTuple::buildDAInt : unable to build a requested DataArrayInt instance with nbofTuple=" << nbOfTuples << " and nbOfCompo=" << nbOfCompo;
11862 oss << ".\nBecause the number of elements in this is " << _nb_of_compo << " !";
11863 throw INTERP_KERNEL::Exception(oss.str().c_str());