1 // Copyright (C) 2007-2015 CEA/DEN, EDF R&D
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 // Lesser General Public License for more details.
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
19 // Author : Anthony Geay (CEA/DEN)
21 #include "MEDCouplingMemArray.txx"
22 #include "MEDCouplingAutoRefCountObjectPtr.hxx"
25 #include "GenMathFormulae.hxx"
26 #include "InterpKernelAutoPtr.hxx"
27 #include "InterpKernelExprParser.hxx"
36 typedef double (*MYFUNCPTR)(double);
38 using namespace ParaMEDMEM;
40 template<int SPACEDIM>
41 void DataArrayDouble::findCommonTuplesAlg(const double *bbox, int nbNodes, int limitNodeId, double prec, DataArrayInt *c, DataArrayInt *cI) const
43 const double *coordsPtr=getConstPointer();
44 BBTreePts<SPACEDIM,int> myTree(bbox,0,0,nbNodes,prec);
45 std::vector<bool> isDone(nbNodes);
46 for(int i=0;i<nbNodes;i++)
50 std::vector<int> intersectingElems;
51 myTree.getElementsAroundPoint(coordsPtr+i*SPACEDIM,intersectingElems);
52 if(intersectingElems.size()>1)
54 std::vector<int> commonNodes;
55 for(std::vector<int>::const_iterator it=intersectingElems.begin();it!=intersectingElems.end();it++)
59 commonNodes.push_back(*it);
62 if(!commonNodes.empty())
64 cI->pushBackSilent(cI->back()+(int)commonNodes.size()+1);
66 c->insertAtTheEnd(commonNodes.begin(),commonNodes.end());
73 template<int SPACEDIM>
74 void DataArrayDouble::FindTupleIdsNearTuplesAlg(const BBTreePts<SPACEDIM,int>& myTree, const double *pos, int nbOfTuples, double eps,
75 DataArrayInt *c, DataArrayInt *cI)
77 for(int i=0;i<nbOfTuples;i++)
79 std::vector<int> intersectingElems;
80 myTree.getElementsAroundPoint(pos+i*SPACEDIM,intersectingElems);
81 std::vector<int> commonNodes;
82 for(std::vector<int>::const_iterator it=intersectingElems.begin();it!=intersectingElems.end();it++)
83 commonNodes.push_back(*it);
84 cI->pushBackSilent(cI->back()+(int)commonNodes.size());
85 c->insertAtTheEnd(commonNodes.begin(),commonNodes.end());
89 template<int SPACEDIM>
90 void DataArrayDouble::FindClosestTupleIdAlg(const BBTreePts<SPACEDIM,int>& myTree, double dist, const double *pos, int nbOfTuples, const double *thisPt, int thisNbOfTuples, int *res)
95 for(int i=0;i<nbOfTuples;i++,p+=SPACEDIM,r++)
100 double ret=myTree.getElementsAroundPoint2(p,distOpt,elem);
101 if(ret!=std::numeric_limits<double>::max())
103 distOpt=std::max(ret,1e-4);
108 { distOpt=2*distOpt; continue; }
113 std::size_t DataArray::getHeapMemorySizeWithoutChildren() const
115 std::size_t sz1=_name.capacity();
116 std::size_t sz2=_info_on_compo.capacity();
118 for(std::vector<std::string>::const_iterator it=_info_on_compo.begin();it!=_info_on_compo.end();it++)
119 sz3+=(*it).capacity();
123 std::vector<const BigMemoryObject *> DataArray::getDirectChildrenWithNull() const
125 return std::vector<const BigMemoryObject *>();
129 * Sets the attribute \a _name of \a this array.
130 * See \ref MEDCouplingArrayBasicsName "DataArrays infos" for more information.
131 * \param [in] name - new array name
133 void DataArray::setName(const std::string& name)
139 * Copies textual data from an \a other DataArray. The copied data are
140 * - the name attribute,
141 * - the information of components.
143 * For more information on these data see \ref MEDCouplingArrayBasicsName "DataArrays infos".
145 * \param [in] other - another instance of DataArray to copy the textual data from.
146 * \throw If number of components of \a this array differs from that of the \a other.
148 void DataArray::copyStringInfoFrom(const DataArray& other)
150 if(_info_on_compo.size()!=other._info_on_compo.size())
151 throw INTERP_KERNEL::Exception("Size of arrays mismatches on copyStringInfoFrom !");
153 _info_on_compo=other._info_on_compo;
156 void DataArray::copyPartOfStringInfoFrom(const DataArray& other, const std::vector<int>& compoIds)
158 int nbOfCompoOth=other.getNumberOfComponents();
159 std::size_t newNbOfCompo=compoIds.size();
160 for(std::size_t i=0;i<newNbOfCompo;i++)
161 if(compoIds[i]>=nbOfCompoOth || compoIds[i]<0)
163 std::ostringstream oss; oss << "Specified component id is out of range (" << compoIds[i] << ") compared with nb of actual components (" << nbOfCompoOth << ")";
164 throw INTERP_KERNEL::Exception(oss.str().c_str());
166 for(std::size_t i=0;i<newNbOfCompo;i++)
167 setInfoOnComponent((int)i,other.getInfoOnComponent(compoIds[i]));
170 void DataArray::copyPartOfStringInfoFrom2(const std::vector<int>& compoIds, const DataArray& other)
172 int nbOfCompo=getNumberOfComponents();
173 std::size_t partOfCompoToSet=compoIds.size();
174 if((int)partOfCompoToSet!=other.getNumberOfComponents())
175 throw INTERP_KERNEL::Exception("Given compoIds has not the same size as number of components of given array !");
176 for(std::size_t i=0;i<partOfCompoToSet;i++)
177 if(compoIds[i]>=nbOfCompo || compoIds[i]<0)
179 std::ostringstream oss; oss << "Specified component id is out of range (" << compoIds[i] << ") compared with nb of actual components (" << nbOfCompo << ")";
180 throw INTERP_KERNEL::Exception(oss.str().c_str());
182 for(std::size_t i=0;i<partOfCompoToSet;i++)
183 setInfoOnComponent(compoIds[i],other.getInfoOnComponent((int)i));
186 bool DataArray::areInfoEqualsIfNotWhy(const DataArray& other, std::string& reason) const
188 std::ostringstream oss;
189 if(_name!=other._name)
191 oss << "Names DataArray mismatch : this name=\"" << _name << " other name=\"" << other._name << "\" !";
195 if(_info_on_compo!=other._info_on_compo)
197 oss << "Components DataArray mismatch : \nThis components=";
198 for(std::vector<std::string>::const_iterator it=_info_on_compo.begin();it!=_info_on_compo.end();it++)
199 oss << "\"" << *it << "\",";
200 oss << "\nOther components=";
201 for(std::vector<std::string>::const_iterator it=other._info_on_compo.begin();it!=other._info_on_compo.end();it++)
202 oss << "\"" << *it << "\",";
210 * Compares textual information of \a this DataArray with that of an \a other one.
211 * The compared data are
212 * - the name attribute,
213 * - the information of components.
215 * For more information on these data see \ref MEDCouplingArrayBasicsName "DataArrays infos".
216 * \param [in] other - another instance of DataArray to compare the textual data of.
217 * \return bool - \a true if the textual information is same, \a false else.
219 bool DataArray::areInfoEquals(const DataArray& other) const
222 return areInfoEqualsIfNotWhy(other,tmp);
225 void DataArray::reprWithoutNameStream(std::ostream& stream) const
227 stream << "Number of components : "<< getNumberOfComponents() << "\n";
228 stream << "Info of these components : ";
229 for(std::vector<std::string>::const_iterator iter=_info_on_compo.begin();iter!=_info_on_compo.end();iter++)
230 stream << "\"" << *iter << "\" ";
234 std::string DataArray::cppRepr(const std::string& varName) const
236 std::ostringstream ret;
237 reprCppStream(varName,ret);
242 * Sets information on all components. To know more on format of this information
243 * see \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
244 * \param [in] info - a vector of strings.
245 * \throw If size of \a info differs from the number of components of \a this.
247 void DataArray::setInfoOnComponents(const std::vector<std::string>& info)
249 if(getNumberOfComponents()!=(int)info.size())
251 std::ostringstream oss; oss << "DataArray::setInfoOnComponents : input is of size " << info.size() << " whereas number of components is equal to " << getNumberOfComponents() << " !";
252 throw INTERP_KERNEL::Exception(oss.str().c_str());
258 * This method is only a dispatcher towards DataArrayDouble::setPartOfValues3, DataArrayInt::setPartOfValues3, DataArrayChar::setPartOfValues3 depending on the true
259 * type of \a this and \a aBase.
261 * \throw If \a aBase and \a this do not have the same type.
263 * \sa DataArrayDouble::setPartOfValues3, DataArrayInt::setPartOfValues3, DataArrayChar::setPartOfValues3.
265 void DataArray::setPartOfValuesBase3(const DataArray *aBase, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
268 throw INTERP_KERNEL::Exception("DataArray::setPartOfValuesBase3 : input aBase object is NULL !");
269 DataArrayDouble *this1(dynamic_cast<DataArrayDouble *>(this));
270 DataArrayInt *this2(dynamic_cast<DataArrayInt *>(this));
271 DataArrayChar *this3(dynamic_cast<DataArrayChar *>(this));
272 const DataArrayDouble *a1(dynamic_cast<const DataArrayDouble *>(aBase));
273 const DataArrayInt *a2(dynamic_cast<const DataArrayInt *>(aBase));
274 const DataArrayChar *a3(dynamic_cast<const DataArrayChar *>(aBase));
277 this1->setPartOfValues3(a1,bgTuples,endTuples,bgComp,endComp,stepComp,strictCompoCompare);
282 this2->setPartOfValues3(a2,bgTuples,endTuples,bgComp,endComp,stepComp,strictCompoCompare);
287 this3->setPartOfValues3(a3,bgTuples,endTuples,bgComp,endComp,stepComp,strictCompoCompare);
290 throw INTERP_KERNEL::Exception("DataArray::setPartOfValuesBase3 : input aBase object and this do not have the same type !");
293 std::vector<std::string> DataArray::getVarsOnComponent() const
295 int nbOfCompo=(int)_info_on_compo.size();
296 std::vector<std::string> ret(nbOfCompo);
297 for(int i=0;i<nbOfCompo;i++)
298 ret[i]=getVarOnComponent(i);
302 std::vector<std::string> DataArray::getUnitsOnComponent() const
304 int nbOfCompo=(int)_info_on_compo.size();
305 std::vector<std::string> ret(nbOfCompo);
306 for(int i=0;i<nbOfCompo;i++)
307 ret[i]=getUnitOnComponent(i);
312 * Returns information on a component specified by an index.
313 * To know more on format of this information
314 * see \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
315 * \param [in] i - the index (zero based) of the component of interest.
316 * \return std::string - a string containing the information on \a i-th component.
317 * \throw If \a i is not a valid component index.
319 std::string DataArray::getInfoOnComponent(int i) const
321 if(i<(int)_info_on_compo.size() && i>=0)
322 return _info_on_compo[i];
325 std::ostringstream oss; oss << "DataArray::getInfoOnComponent : Specified component id is out of range (" << i << ") compared with nb of actual components (" << (int) _info_on_compo.size();
326 throw INTERP_KERNEL::Exception(oss.str().c_str());
331 * Returns the var part of the full information of the \a i-th component.
332 * For example, if \c getInfoOnComponent(0) returns "SIGXY [N/m^2]", then
333 * \c getVarOnComponent(0) returns "SIGXY".
334 * If a unit part of information is not detected by presence of
335 * two square brackets, then the full information is returned.
336 * To read more about the component information format, see
337 * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
338 * \param [in] i - the index (zero based) of the component of interest.
339 * \return std::string - a string containing the var information, or the full info.
340 * \throw If \a i is not a valid component index.
342 std::string DataArray::getVarOnComponent(int i) const
344 if(i<(int)_info_on_compo.size() && i>=0)
346 return GetVarNameFromInfo(_info_on_compo[i]);
350 std::ostringstream oss; oss << "DataArray::getVarOnComponent : Specified component id is out of range (" << i << ") compared with nb of actual components (" << (int) _info_on_compo.size();
351 throw INTERP_KERNEL::Exception(oss.str().c_str());
356 * Returns the unit part of the full information of the \a i-th component.
357 * For example, if \c getInfoOnComponent(0) returns "SIGXY [ N/m^2]", then
358 * \c getUnitOnComponent(0) returns " N/m^2".
359 * If a unit part of information is not detected by presence of
360 * two square brackets, then an empty string is returned.
361 * To read more about the component information format, see
362 * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
363 * \param [in] i - the index (zero based) of the component of interest.
364 * \return std::string - a string containing the unit information, if any, or "".
365 * \throw If \a i is not a valid component index.
367 std::string DataArray::getUnitOnComponent(int i) const
369 if(i<(int)_info_on_compo.size() && i>=0)
371 return GetUnitFromInfo(_info_on_compo[i]);
375 std::ostringstream oss; oss << "DataArray::getUnitOnComponent : Specified component id is out of range (" << i << ") compared with nb of actual components (" << (int) _info_on_compo.size();
376 throw INTERP_KERNEL::Exception(oss.str().c_str());
381 * Returns the var part of the full component information.
382 * For example, if \a info == "SIGXY [N/m^2]", then this method returns "SIGXY".
383 * If a unit part of information is not detected by presence of
384 * two square brackets, then the whole \a info is returned.
385 * To read more about the component information format, see
386 * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
387 * \param [in] info - the full component information.
388 * \return std::string - a string containing only var information, or the \a info.
390 std::string DataArray::GetVarNameFromInfo(const std::string& info)
392 std::size_t p1=info.find_last_of('[');
393 std::size_t p2=info.find_last_of(']');
394 if(p1==std::string::npos || p2==std::string::npos)
399 return std::string();
400 std::size_t p3=info.find_last_not_of(' ',p1-1);
401 return info.substr(0,p3+1);
405 * Returns the unit part of the full component information.
406 * For example, if \a info == "SIGXY [ N/m^2]", then this method returns " N/m^2".
407 * If a unit part of information is not detected by presence of
408 * two square brackets, then an empty string is returned.
409 * To read more about the component information format, see
410 * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
411 * \param [in] info - the full component information.
412 * \return std::string - a string containing only unit information, if any, or "".
414 std::string DataArray::GetUnitFromInfo(const std::string& info)
416 std::size_t p1=info.find_last_of('[');
417 std::size_t p2=info.find_last_of(']');
418 if(p1==std::string::npos || p2==std::string::npos)
419 return std::string();
421 return std::string();
422 return info.substr(p1+1,p2-p1-1);
426 * This method put in info format the result of the merge of \a var and \a unit.
427 * The standard format for that is "var [unit]".
428 * Inversely you can retrieve the var part or the unit part of info string using resp. GetVarNameFromInfo and GetUnitFromInfo.
430 std::string DataArray::BuildInfoFromVarAndUnit(const std::string& var, const std::string& unit)
432 std::ostringstream oss;
433 oss << var << " [" << unit << "]";
438 * Returns a new DataArray by concatenating all given arrays, so that (1) the number
439 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
440 * the number of component in the result array is same as that of each of given arrays.
441 * Info on components is copied from the first of the given arrays. Number of components
442 * in the given arrays must be the same.
443 * \param [in] arrs - a sequence of arrays to include in the result array. All arrays must have the same type.
444 * \return DataArray * - the new instance of DataArray (that can be either DataArrayInt, DataArrayDouble, DataArrayChar).
445 * The caller is to delete this result array using decrRef() as it is no more
447 * \throw If all arrays within \a arrs are NULL.
448 * \throw If all not null arrays in \a arrs have not the same type.
449 * \throw If getNumberOfComponents() of arrays within \a arrs.
451 DataArray *DataArray::Aggregate(const std::vector<const DataArray *>& arrs)
453 std::vector<const DataArray *> arr2;
454 for(std::vector<const DataArray *>::const_iterator it=arrs.begin();it!=arrs.end();it++)
458 throw INTERP_KERNEL::Exception("DataArray::Aggregate : only null instance in input vector !");
459 std::vector<const DataArrayDouble *> arrd;
460 std::vector<const DataArrayInt *> arri;
461 std::vector<const DataArrayChar *> arrc;
462 for(std::vector<const DataArray *>::const_iterator it=arr2.begin();it!=arr2.end();it++)
464 const DataArrayDouble *a=dynamic_cast<const DataArrayDouble *>(*it);
466 { arrd.push_back(a); continue; }
467 const DataArrayInt *b=dynamic_cast<const DataArrayInt *>(*it);
469 { arri.push_back(b); continue; }
470 const DataArrayChar *c=dynamic_cast<const DataArrayChar *>(*it);
472 { arrc.push_back(c); continue; }
473 throw INTERP_KERNEL::Exception("DataArray::Aggregate : presence of not null instance in inuput that is not in [DataArrayDouble, DataArrayInt, DataArrayChar] !");
475 if(arr2.size()==arrd.size())
476 return DataArrayDouble::Aggregate(arrd);
477 if(arr2.size()==arri.size())
478 return DataArrayInt::Aggregate(arri);
479 if(arr2.size()==arrc.size())
480 return DataArrayChar::Aggregate(arrc);
481 throw INTERP_KERNEL::Exception("DataArray::Aggregate : all input arrays must have the same type !");
485 * Sets information on a component specified by an index.
486 * To know more on format of this information
487 * see \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
488 * \warning Don't pass NULL as \a info!
489 * \param [in] i - the index (zero based) of the component of interest.
490 * \param [in] info - the string containing the information.
491 * \throw If \a i is not a valid component index.
493 void DataArray::setInfoOnComponent(int i, const std::string& info)
495 if(i<(int)_info_on_compo.size() && i>=0)
496 _info_on_compo[i]=info;
499 std::ostringstream oss; oss << "DataArray::setInfoOnComponent : Specified component id is out of range (" << i << ") compared with nb of actual components (" << (int) _info_on_compo.size();
500 throw INTERP_KERNEL::Exception(oss.str().c_str());
505 * Sets information on all components. This method can change number of components
506 * at certain conditions; if the conditions are not respected, an exception is thrown.
507 * The number of components can be changed in \a this only if \a this is not allocated.
508 * The condition of number of components must not be changed.
510 * To know more on format of the component information see
511 * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
512 * \param [in] info - a vector of component infos.
513 * \throw If \a this->getNumberOfComponents() != \a info.size() && \a this->isAllocated()
515 void DataArray::setInfoAndChangeNbOfCompo(const std::vector<std::string>& info)
517 if(getNumberOfComponents()!=(int)info.size())
523 std::ostringstream oss; oss << "DataArray::setInfoAndChangeNbOfCompo : input is of size " << info.size() << " whereas number of components is equal to " << getNumberOfComponents() << " and this is already allocated !";
524 throw INTERP_KERNEL::Exception(oss.str().c_str());
531 void DataArray::checkNbOfTuples(int nbOfTuples, const std::string& msg) const
533 if(getNumberOfTuples()!=nbOfTuples)
535 std::ostringstream oss; oss << msg << " : mismatch number of tuples : expected " << nbOfTuples << " having " << getNumberOfTuples() << " !";
536 throw INTERP_KERNEL::Exception(oss.str().c_str());
540 void DataArray::checkNbOfComps(int nbOfCompo, const std::string& msg) const
542 if(getNumberOfComponents()!=nbOfCompo)
544 std::ostringstream oss; oss << msg << " : mismatch number of components : expected " << nbOfCompo << " having " << getNumberOfComponents() << " !";
545 throw INTERP_KERNEL::Exception(oss.str().c_str());
549 void DataArray::checkNbOfElems(std::size_t nbOfElems, const std::string& msg) const
551 if(getNbOfElems()!=nbOfElems)
553 std::ostringstream oss; oss << msg << " : mismatch number of elems : Expected " << nbOfElems << " having " << getNbOfElems() << " !";
554 throw INTERP_KERNEL::Exception(oss.str().c_str());
558 void DataArray::checkNbOfTuplesAndComp(const DataArray& other, const std::string& msg) const
560 if(getNumberOfTuples()!=other.getNumberOfTuples())
562 std::ostringstream oss; oss << msg << " : mismatch number of tuples : expected " << other.getNumberOfTuples() << " having " << getNumberOfTuples() << " !";
563 throw INTERP_KERNEL::Exception(oss.str().c_str());
565 if(getNumberOfComponents()!=other.getNumberOfComponents())
567 std::ostringstream oss; oss << msg << " : mismatch number of components : expected " << other.getNumberOfComponents() << " having " << getNumberOfComponents() << " !";
568 throw INTERP_KERNEL::Exception(oss.str().c_str());
572 void DataArray::checkNbOfTuplesAndComp(int nbOfTuples, int nbOfCompo, const std::string& msg) const
574 checkNbOfTuples(nbOfTuples,msg);
575 checkNbOfComps(nbOfCompo,msg);
579 * Simply this method checks that \b value is in [0,\b ref).
581 void DataArray::CheckValueInRange(int ref, int value, const std::string& msg)
583 if(value<0 || value>=ref)
585 std::ostringstream oss; oss << "DataArray::CheckValueInRange : " << msg << " ! Expected in range [0," << ref << "[ having " << value << " !";
586 throw INTERP_KERNEL::Exception(oss.str().c_str());
591 * This method checks that [\b start, \b end) is compliant with ref length \b value.
592 * typicaly start in [0,\b value) and end in [0,\b value). If value==start and start==end, it is supported.
594 void DataArray::CheckValueInRangeEx(int value, int start, int end, const std::string& msg)
596 if(start<0 || start>=value)
598 if(value!=start || end!=start)
600 std::ostringstream oss; oss << "DataArray::CheckValueInRangeEx : " << msg << " ! Expected start " << start << " of input range, in [0," << value << "[ !";
601 throw INTERP_KERNEL::Exception(oss.str().c_str());
604 if(end<0 || end>value)
606 std::ostringstream oss; oss << "DataArray::CheckValueInRangeEx : " << msg << " ! Expected end " << end << " of input range, in [0," << value << "] !";
607 throw INTERP_KERNEL::Exception(oss.str().c_str());
611 void DataArray::CheckClosingParInRange(int ref, int value, const std::string& msg)
613 if(value<0 || value>ref)
615 std::ostringstream oss; oss << "DataArray::CheckClosingParInRange : " << msg << " ! Expected input range in [0," << ref << "] having closing open parenthesis " << value << " !";
616 throw INTERP_KERNEL::Exception(oss.str().c_str());
621 * This method is useful to slice work among a pool of threads or processes. \a begin, \a end \a step is the input whole slice of work to perform,
622 * typically it is a whole slice of tuples of DataArray or cells, nodes of a mesh...
624 * The input \a sliceId should be an id in [0, \a nbOfSlices) that specifies the slice of work.
626 * \param [in] start - the start of the input slice of the whole work to perform splitted into slices.
627 * \param [in] stop - the stop of the input slice of the whole work to perform splitted into slices.
628 * \param [in] step - the step (that can be <0) of the input slice of the whole work to perform splitted into slices.
629 * \param [in] sliceId - the slice id considered
630 * \param [in] nbOfSlices - the number of slices (typically the number of cores on which the work is expected to be sliced)
631 * \param [out] startSlice - the start of the slice considered
632 * \param [out] stopSlice - the stop of the slice consided
634 * \throw If \a step == 0
635 * \throw If \a nbOfSlices not > 0
636 * \throw If \a sliceId not in [0,nbOfSlices)
638 void DataArray::GetSlice(int start, int stop, int step, int sliceId, int nbOfSlices, int& startSlice, int& stopSlice)
642 std::ostringstream oss; oss << "DataArray::GetSlice : nbOfSlices (" << nbOfSlices << ") must be > 0 !";
643 throw INTERP_KERNEL::Exception(oss.str().c_str());
645 if(sliceId<0 || sliceId>=nbOfSlices)
647 std::ostringstream oss; oss << "DataArray::GetSlice : sliceId (" << nbOfSlices << ") must be in [0 , nbOfSlices (" << nbOfSlices << ") ) !";
648 throw INTERP_KERNEL::Exception(oss.str().c_str());
650 int nbElems=GetNumberOfItemGivenBESRelative(start,stop,step,"DataArray::GetSlice");
651 int minNbOfElemsPerSlice=nbElems/nbOfSlices;
652 startSlice=start+minNbOfElemsPerSlice*step*sliceId;
653 if(sliceId<nbOfSlices-1)
654 stopSlice=start+minNbOfElemsPerSlice*step*(sliceId+1);
659 int DataArray::GetNumberOfItemGivenBES(int begin, int end, int step, const std::string& msg)
663 std::ostringstream oss; oss << msg << " : end before begin !";
664 throw INTERP_KERNEL::Exception(oss.str().c_str());
670 std::ostringstream oss; oss << msg << " : invalid step should be > 0 !";
671 throw INTERP_KERNEL::Exception(oss.str().c_str());
673 return (end-1-begin)/step+1;
676 int DataArray::GetNumberOfItemGivenBESRelative(int begin, int end, int step, const std::string& msg)
679 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBES : step=0 is not allowed !");
680 if(end<begin && step>0)
682 std::ostringstream oss; oss << msg << " : end before begin whereas step is positive !";
683 throw INTERP_KERNEL::Exception(oss.str().c_str());
685 if(begin<end && step<0)
687 std::ostringstream oss; oss << msg << " : invalid step should be > 0 !";
688 throw INTERP_KERNEL::Exception(oss.str().c_str());
691 return (std::max(begin,end)-1-std::min(begin,end))/std::abs(step)+1;
696 int DataArray::GetPosOfItemGivenBESRelativeNoThrow(int value, int begin, int end, int step)
702 if(begin<=value && value<end)
704 if((value-begin)%step==0)
705 return (value-begin)/step;
714 if(begin>=value && value>end)
716 if((begin-value)%(-step)==0)
717 return (begin-value)/(-step);
730 * Returns a new instance of DataArrayDouble. The caller is to delete this array
731 * using decrRef() as it is no more needed.
733 DataArrayDouble *DataArrayDouble::New()
735 return new DataArrayDouble;
739 * Checks if raw data is allocated. Read more on the raw data
740 * in \ref MEDCouplingArrayBasicsTuplesAndCompo "DataArrays infos" for more information.
741 * \return bool - \a true if the raw data is allocated, \a false else.
743 bool DataArrayDouble::isAllocated() const
745 return getConstPointer()!=0;
749 * Checks if raw data is allocated and throws an exception if it is not the case.
750 * \throw If the raw data is not allocated.
752 void DataArrayDouble::checkAllocated() const
755 throw INTERP_KERNEL::Exception("DataArrayDouble::checkAllocated : Array is defined but not allocated ! Call alloc or setValues method first !");
759 * This method desallocated \a this without modification of informations relative to the components.
760 * After call of this method, DataArrayDouble::isAllocated will return false.
761 * If \a this is already not allocated, \a this is let unchanged.
763 void DataArrayDouble::desallocate()
768 std::size_t DataArrayDouble::getHeapMemorySizeWithoutChildren() const
770 std::size_t sz(_mem.getNbOfElemAllocated());
772 return DataArray::getHeapMemorySizeWithoutChildren()+sz;
776 * Returns the only one value in \a this, if and only if number of elements
777 * (nb of tuples * nb of components) is equal to 1, and that \a this is allocated.
778 * \return double - the sole value stored in \a this array.
779 * \throw If at least one of conditions stated above is not fulfilled.
781 double DataArrayDouble::doubleValue() const
785 if(getNbOfElems()==1)
787 return *getConstPointer();
790 throw INTERP_KERNEL::Exception("DataArrayDouble::doubleValue : DataArrayDouble instance is allocated but number of elements is not equal to 1 !");
793 throw INTERP_KERNEL::Exception("DataArrayDouble::doubleValue : DataArrayDouble instance is not allocated !");
797 * Checks the number of tuples.
798 * \return bool - \a true if getNumberOfTuples() == 0, \a false else.
799 * \throw If \a this is not allocated.
801 bool DataArrayDouble::empty() const
804 return getNumberOfTuples()==0;
808 * Returns a full copy of \a this. For more info on copying data arrays see
809 * \ref MEDCouplingArrayBasicsCopyDeep.
810 * \return DataArrayDouble * - a new instance of DataArrayDouble. The caller is to
811 * delete this array using decrRef() as it is no more needed.
813 DataArrayDouble *DataArrayDouble::deepCpy() const
815 return new DataArrayDouble(*this);
819 * Returns either a \a deep or \a shallow copy of this array. For more info see
820 * \ref MEDCouplingArrayBasicsCopyDeep and \ref MEDCouplingArrayBasicsCopyShallow.
821 * \param [in] dCpy - if \a true, a deep copy is returned, else, a shallow one.
822 * \return DataArrayDouble * - either a new instance of DataArrayDouble (if \a dCpy
823 * == \a true) or \a this instance (if \a dCpy == \a false).
825 DataArrayDouble *DataArrayDouble::performCpy(bool dCpy) const
832 return const_cast<DataArrayDouble *>(this);
837 * Copies all the data from another DataArrayDouble. For more info see
838 * \ref MEDCouplingArrayBasicsCopyDeepAssign.
839 * \param [in] other - another instance of DataArrayDouble to copy data from.
840 * \throw If the \a other is not allocated.
842 void DataArrayDouble::cpyFrom(const DataArrayDouble& other)
844 other.checkAllocated();
845 int nbOfTuples=other.getNumberOfTuples();
846 int nbOfComp=other.getNumberOfComponents();
847 allocIfNecessary(nbOfTuples,nbOfComp);
848 std::size_t nbOfElems=(std::size_t)nbOfTuples*nbOfComp;
849 double *pt=getPointer();
850 const double *ptI=other.getConstPointer();
851 for(std::size_t i=0;i<nbOfElems;i++)
853 copyStringInfoFrom(other);
857 * This method reserve nbOfElems elements in memory ( nbOfElems*8 bytes ) \b without impacting the number of tuples in \a this.
858 * If \a this has already been allocated, this method checks that \a this has only one component. If not an INTERP_KERNEL::Exception will be thrown.
859 * If \a this has not already been allocated, number of components is set to one.
860 * This method allows to reduce number of reallocations on invokation of DataArrayDouble::pushBackSilent and DataArrayDouble::pushBackValsSilent on \a this.
862 * \sa DataArrayDouble::pack, DataArrayDouble::pushBackSilent, DataArrayDouble::pushBackValsSilent
864 void DataArrayDouble::reserve(std::size_t nbOfElems)
866 int nbCompo=getNumberOfComponents();
869 _mem.reserve(nbOfElems);
873 _mem.reserve(nbOfElems);
874 _info_on_compo.resize(1);
877 throw INTERP_KERNEL::Exception("DataArrayDouble::reserve : not available for DataArrayDouble with number of components different than 1 !");
881 * This method adds at the end of \a this the single value \a val. This method do \b not update its time label to avoid useless incrementation
882 * of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
884 * \param [in] val the value to be added in \a this
885 * \throw If \a this has already been allocated with number of components different from one.
886 * \sa DataArrayDouble::pushBackValsSilent
888 void DataArrayDouble::pushBackSilent(double val)
890 int nbCompo=getNumberOfComponents();
895 _info_on_compo.resize(1);
899 throw INTERP_KERNEL::Exception("DataArrayDouble::pushBackSilent : not available for DataArrayDouble with number of components different than 1 !");
903 * This method adds at the end of \a this a serie of values [\c valsBg,\c valsEnd). This method do \b not update its time label to avoid useless incrementation
904 * of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
906 * \param [in] valsBg - an array of values to push at the end of \this.
907 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
908 * the last value of \a valsBg is \a valsEnd[ -1 ].
909 * \throw If \a this has already been allocated with number of components different from one.
910 * \sa DataArrayDouble::pushBackSilent
912 void DataArrayDouble::pushBackValsSilent(const double *valsBg, const double *valsEnd)
914 int nbCompo=getNumberOfComponents();
916 _mem.insertAtTheEnd(valsBg,valsEnd);
919 _info_on_compo.resize(1);
920 _mem.insertAtTheEnd(valsBg,valsEnd);
923 throw INTERP_KERNEL::Exception("DataArrayDouble::pushBackValsSilent : not available for DataArrayDouble with number of components different than 1 !");
927 * This method returns silently ( without updating time label in \a this ) the last value, if any and suppress it.
928 * \throw If \a this is already empty.
929 * \throw If \a this has number of components different from one.
931 double DataArrayDouble::popBackSilent()
933 if(getNumberOfComponents()==1)
934 return _mem.popBack();
936 throw INTERP_KERNEL::Exception("DataArrayDouble::popBackSilent : not available for DataArrayDouble with number of components different than 1 !");
940 * This method \b do \b not modify content of \a this. It only modify its memory footprint if the allocated memory is to high regarding real data to store.
942 * \sa DataArrayDouble::getHeapMemorySizeWithoutChildren, DataArrayDouble::reserve
944 void DataArrayDouble::pack() const
950 * Allocates the raw data in memory. If exactly same memory as needed already
951 * allocated, it is not re-allocated.
952 * \param [in] nbOfTuple - number of tuples of data to allocate.
953 * \param [in] nbOfCompo - number of components of data to allocate.
954 * \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
956 void DataArrayDouble::allocIfNecessary(int nbOfTuple, int nbOfCompo)
960 if(nbOfTuple!=getNumberOfTuples() || nbOfCompo!=getNumberOfComponents())
961 alloc(nbOfTuple,nbOfCompo);
964 alloc(nbOfTuple,nbOfCompo);
968 * Allocates the raw data in memory. If the memory was already allocated, then it is
969 * freed and re-allocated. See an example of this method use
970 * \ref MEDCouplingArraySteps1WC "here".
971 * \param [in] nbOfTuple - number of tuples of data to allocate.
972 * \param [in] nbOfCompo - number of components of data to allocate.
973 * \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
975 void DataArrayDouble::alloc(int nbOfTuple, int nbOfCompo)
977 if(nbOfTuple<0 || nbOfCompo<0)
978 throw INTERP_KERNEL::Exception("DataArrayDouble::alloc : request for negative length of data !");
979 _info_on_compo.resize(nbOfCompo);
980 _mem.alloc(nbOfCompo*(std::size_t)nbOfTuple);
985 * Assign zero to all values in \a this array. To know more on filling arrays see
986 * \ref MEDCouplingArrayFill.
987 * \throw If \a this is not allocated.
989 void DataArrayDouble::fillWithZero()
992 _mem.fillWithValue(0.);
997 * Assign \a val to all values in \a this array. To know more on filling arrays see
998 * \ref MEDCouplingArrayFill.
999 * \param [in] val - the value to fill with.
1000 * \throw If \a this is not allocated.
1002 void DataArrayDouble::fillWithValue(double val)
1005 _mem.fillWithValue(val);
1010 * Set all values in \a this array so that the i-th element equals to \a init + i
1011 * (i starts from zero). To know more on filling arrays see \ref MEDCouplingArrayFill.
1012 * \param [in] init - value to assign to the first element of array.
1013 * \throw If \a this->getNumberOfComponents() != 1
1014 * \throw If \a this is not allocated.
1016 void DataArrayDouble::iota(double init)
1019 if(getNumberOfComponents()!=1)
1020 throw INTERP_KERNEL::Exception("DataArrayDouble::iota : works only for arrays with only one component, you can call 'rearrange' method before !");
1021 double *ptr=getPointer();
1022 int ntuples=getNumberOfTuples();
1023 for(int i=0;i<ntuples;i++)
1024 ptr[i]=init+double(i);
1029 * Checks if all values in \a this array are equal to \a val at precision \a eps.
1030 * \param [in] val - value to check equality of array values to.
1031 * \param [in] eps - precision to check the equality.
1032 * \return bool - \a true if all values are in range (_val_ - _eps_; _val_ + _eps_),
1034 * \throw If \a this->getNumberOfComponents() != 1
1035 * \throw If \a this is not allocated.
1037 bool DataArrayDouble::isUniform(double val, double eps) const
1040 if(getNumberOfComponents()!=1)
1041 throw INTERP_KERNEL::Exception("DataArrayDouble::isUniform : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
1042 int nbOfTuples=getNumberOfTuples();
1043 const double *w=getConstPointer();
1044 const double *end2=w+nbOfTuples;
1045 const double vmin=val-eps;
1046 const double vmax=val+eps;
1048 if(*w<vmin || *w>vmax)
1054 * Sorts values of the array.
1055 * \param [in] asc - \a true means ascending order, \a false, descending.
1056 * \throw If \a this is not allocated.
1057 * \throw If \a this->getNumberOfComponents() != 1.
1059 void DataArrayDouble::sort(bool asc)
1062 if(getNumberOfComponents()!=1)
1063 throw INTERP_KERNEL::Exception("DataArrayDouble::sort : only supported with 'this' array with ONE component !");
1069 * Reverse the array values.
1070 * \throw If \a this->getNumberOfComponents() < 1.
1071 * \throw If \a this is not allocated.
1073 void DataArrayDouble::reverse()
1076 _mem.reverse(getNumberOfComponents());
1081 * Checks that \a this array is consistently **increasing** or **decreasing** in value,
1082 * with at least absolute difference value of |\a eps| at each step.
1083 * If not an exception is thrown.
1084 * \param [in] increasing - if \a true, the array values should be increasing.
1085 * \param [in] eps - minimal absolute difference between the neighbor values at which
1086 * the values are considered different.
1087 * \throw If sequence of values is not strictly monotonic in agreement with \a
1089 * \throw If \a this->getNumberOfComponents() != 1.
1090 * \throw If \a this is not allocated.
1092 void DataArrayDouble::checkMonotonic(bool increasing, double eps) const
1094 if(!isMonotonic(increasing,eps))
1097 throw INTERP_KERNEL::Exception("DataArrayDouble::checkMonotonic : 'this' is not INCREASING monotonic !");
1099 throw INTERP_KERNEL::Exception("DataArrayDouble::checkMonotonic : 'this' is not DECREASING monotonic !");
1104 * Checks that \a this array is consistently **increasing** or **decreasing** in value,
1105 * with at least absolute difference value of |\a eps| at each step.
1106 * \param [in] increasing - if \a true, array values should be increasing.
1107 * \param [in] eps - minimal absolute difference between the neighbor values at which
1108 * the values are considered different.
1109 * \return bool - \a true if values change in accordance with \a increasing arg.
1110 * \throw If \a this->getNumberOfComponents() != 1.
1111 * \throw If \a this is not allocated.
1113 bool DataArrayDouble::isMonotonic(bool increasing, double eps) const
1116 if(getNumberOfComponents()!=1)
1117 throw INTERP_KERNEL::Exception("DataArrayDouble::isMonotonic : only supported with 'this' array with ONE component !");
1118 int nbOfElements=getNumberOfTuples();
1119 const double *ptr=getConstPointer();
1123 double absEps=fabs(eps);
1126 for(int i=1;i<nbOfElements;i++)
1128 if(ptr[i]<(ref+absEps))
1136 for(int i=1;i<nbOfElements;i++)
1138 if(ptr[i]>(ref-absEps))
1147 * Returns a textual and human readable representation of \a this instance of
1148 * DataArrayDouble. This text is shown when a DataArrayDouble is printed in Python.
1149 * \return std::string - text describing \a this DataArrayDouble.
1151 * \sa reprNotTooLong, reprZip
1153 std::string DataArrayDouble::repr() const
1155 std::ostringstream ret;
1160 std::string DataArrayDouble::reprZip() const
1162 std::ostringstream ret;
1168 * This method is close to repr method except that when \a this has more than 1000 tuples, all tuples are not
1169 * printed out to avoid to consume too much space in interpretor.
1172 std::string DataArrayDouble::reprNotTooLong() const
1174 std::ostringstream ret;
1175 reprNotTooLongStream(ret);
1179 void DataArrayDouble::writeVTK(std::ostream& ofs, int indent, const std::string& nameInFile, DataArrayByte *byteArr) const
1181 static const char SPACE[4]={' ',' ',' ',' '};
1183 std::string idt(indent,' ');
1185 ofs << idt << "<DataArray type=\"Float32\" Name=\"" << nameInFile << "\" NumberOfComponents=\"" << getNumberOfComponents() << "\"";
1187 bool areAllEmpty(true);
1188 for(std::vector<std::string>::const_iterator it=_info_on_compo.begin();it!=_info_on_compo.end();it++)
1192 for(std::size_t i=0;i<_info_on_compo.size();i++)
1193 ofs << " ComponentName" << i << "=\"" << _info_on_compo[i] << "\"";
1197 ofs << " format=\"appended\" offset=\"" << byteArr->getNumberOfTuples() << "\">";
1198 INTERP_KERNEL::AutoPtr<float> tmp(new float[getNbOfElems()]);
1200 // to make Visual C++ happy : instead of std::copy(begin(),end(),(float *)tmp);
1201 for(const double *src=begin();src!=end();src++,pt++)
1203 const char *data(reinterpret_cast<const char *>((float *)tmp));
1204 std::size_t sz(getNbOfElems()*sizeof(float));
1205 byteArr->insertAtTheEnd(data,data+sz);
1206 byteArr->insertAtTheEnd(SPACE,SPACE+4);
1210 ofs << " RangeMin=\"" << getMinValueInArray() << "\" RangeMax=\"" << getMaxValueInArray() << "\" format=\"ascii\">\n" << idt;
1211 std::copy(begin(),end(),std::ostream_iterator<double>(ofs," "));
1213 ofs << std::endl << idt << "</DataArray>\n";
1216 void DataArrayDouble::reprStream(std::ostream& stream) const
1218 stream << "Name of double array : \"" << _name << "\"\n";
1219 reprWithoutNameStream(stream);
1222 void DataArrayDouble::reprZipStream(std::ostream& stream) const
1224 stream << "Name of double array : \"" << _name << "\"\n";
1225 reprZipWithoutNameStream(stream);
1228 void DataArrayDouble::reprNotTooLongStream(std::ostream& stream) const
1230 stream << "Name of double array : \"" << _name << "\"\n";
1231 reprNotTooLongWithoutNameStream(stream);
1234 void DataArrayDouble::reprWithoutNameStream(std::ostream& stream) const
1236 DataArray::reprWithoutNameStream(stream);
1237 stream.precision(17);
1238 _mem.repr(getNumberOfComponents(),stream);
1241 void DataArrayDouble::reprZipWithoutNameStream(std::ostream& stream) const
1243 DataArray::reprWithoutNameStream(stream);
1244 stream.precision(17);
1245 _mem.reprZip(getNumberOfComponents(),stream);
1248 void DataArrayDouble::reprNotTooLongWithoutNameStream(std::ostream& stream) const
1250 DataArray::reprWithoutNameStream(stream);
1251 stream.precision(17);
1252 _mem.reprNotTooLong(getNumberOfComponents(),stream);
1255 void DataArrayDouble::reprCppStream(const std::string& varName, std::ostream& stream) const
1257 int nbTuples=getNumberOfTuples(),nbComp=getNumberOfComponents();
1258 const double *data=getConstPointer();
1259 stream.precision(17);
1260 stream << "DataArrayDouble *" << varName << "=DataArrayDouble::New();" << std::endl;
1261 if(nbTuples*nbComp>=1)
1263 stream << "const double " << varName << "Data[" << nbTuples*nbComp << "]={";
1264 std::copy(data,data+nbTuples*nbComp-1,std::ostream_iterator<double>(stream,","));
1265 stream << data[nbTuples*nbComp-1] << "};" << std::endl;
1266 stream << varName << "->useArray(" << varName << "Data,false,CPP_DEALLOC," << nbTuples << "," << nbComp << ");" << std::endl;
1269 stream << varName << "->alloc(" << nbTuples << "," << nbComp << ");" << std::endl;
1270 stream << varName << "->setName(\"" << getName() << "\");" << std::endl;
1274 * Method that gives a quick overvien of \a this for python.
1276 void DataArrayDouble::reprQuickOverview(std::ostream& stream) const
1278 static const std::size_t MAX_NB_OF_BYTE_IN_REPR=300;
1279 stream << "DataArrayDouble C++ instance at " << this << ". ";
1282 int nbOfCompo=(int)_info_on_compo.size();
1285 int nbOfTuples=getNumberOfTuples();
1286 stream << "Number of tuples : " << nbOfTuples << ". Number of components : " << nbOfCompo << "." << std::endl;
1287 reprQuickOverviewData(stream,MAX_NB_OF_BYTE_IN_REPR);
1290 stream << "Number of components : 0.";
1293 stream << "*** No data allocated ****";
1296 void DataArrayDouble::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const
1298 const double *data=begin();
1299 int nbOfTuples=getNumberOfTuples();
1300 int nbOfCompo=(int)_info_on_compo.size();
1301 std::ostringstream oss2; oss2 << "[";
1303 std::string oss2Str(oss2.str());
1304 bool isFinished=true;
1305 for(int i=0;i<nbOfTuples && isFinished;i++)
1310 for(int j=0;j<nbOfCompo;j++,data++)
1313 if(j!=nbOfCompo-1) oss2 << ", ";
1319 if(i!=nbOfTuples-1) oss2 << ", ";
1320 std::string oss3Str(oss2.str());
1321 if(oss3Str.length()<maxNbOfByteInRepr)
1333 * Equivalent to DataArrayDouble::isEqual except that if false the reason of
1334 * mismatch is given.
1336 * \param [in] other the instance to be compared with \a this
1337 * \param [in] prec the precision to compare numeric data of the arrays.
1338 * \param [out] reason In case of inequality returns the reason.
1339 * \sa DataArrayDouble::isEqual
1341 bool DataArrayDouble::isEqualIfNotWhy(const DataArrayDouble& other, double prec, std::string& reason) const
1343 if(!areInfoEqualsIfNotWhy(other,reason))
1345 return _mem.isEqual(other._mem,prec,reason);
1349 * Checks if \a this and another DataArrayDouble are fully equal. For more info see
1350 * \ref MEDCouplingArrayBasicsCompare.
1351 * \param [in] other - an instance of DataArrayDouble to compare with \a this one.
1352 * \param [in] prec - precision value to compare numeric data of the arrays.
1353 * \return bool - \a true if the two arrays are equal, \a false else.
1355 bool DataArrayDouble::isEqual(const DataArrayDouble& other, double prec) const
1358 return isEqualIfNotWhy(other,prec,tmp);
1362 * Checks if values of \a this and another DataArrayDouble are equal. For more info see
1363 * \ref MEDCouplingArrayBasicsCompare.
1364 * \param [in] other - an instance of DataArrayDouble to compare with \a this one.
1365 * \param [in] prec - precision value to compare numeric data of the arrays.
1366 * \return bool - \a true if the values of two arrays are equal, \a false else.
1368 bool DataArrayDouble::isEqualWithoutConsideringStr(const DataArrayDouble& other, double prec) const
1371 return _mem.isEqual(other._mem,prec,tmp);
1375 * Changes number of tuples in the array. If the new number of tuples is smaller
1376 * than the current number the array is truncated, otherwise the array is extended.
1377 * \param [in] nbOfTuples - new number of tuples.
1378 * \throw If \a this is not allocated.
1379 * \throw If \a nbOfTuples is negative.
1381 void DataArrayDouble::reAlloc(int nbOfTuples)
1384 throw INTERP_KERNEL::Exception("DataArrayDouble::reAlloc : input new number of tuples should be >=0 !");
1386 _mem.reAlloc(getNumberOfComponents()*(std::size_t)nbOfTuples);
1391 * Creates a new DataArrayInt and assigns all (textual and numerical) data of \a this
1392 * array to the new one.
1393 * \return DataArrayInt * - the new instance of DataArrayInt.
1395 DataArrayInt *DataArrayDouble::convertToIntArr() const
1397 DataArrayInt *ret=DataArrayInt::New();
1398 ret->alloc(getNumberOfTuples(),getNumberOfComponents());
1399 int *dest=ret->getPointer();
1400 // to make Visual C++ happy : instead of std::size_t nbOfVals=getNbOfElems(); std::copy(src,src+nbOfVals,dest);
1401 for(const double *src=begin();src!=end();src++,dest++)
1403 ret->copyStringInfoFrom(*this);
1408 * Returns a new DataArrayDouble holding the same values as \a this array but differently
1409 * arranged in memory. If \a this array holds 2 components of 3 values:
1410 * \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$, then the result array holds these values arranged
1411 * as follows: \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$.
1412 * \warning Do not confuse this method with transpose()!
1413 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1414 * is to delete using decrRef() as it is no more needed.
1415 * \throw If \a this is not allocated.
1417 DataArrayDouble *DataArrayDouble::fromNoInterlace() const
1420 throw INTERP_KERNEL::Exception("DataArrayDouble::fromNoInterlace : Not defined array !");
1421 double *tab=_mem.fromNoInterlace(getNumberOfComponents());
1422 DataArrayDouble *ret=DataArrayDouble::New();
1423 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
1428 * Returns a new DataArrayDouble holding the same values as \a this array but differently
1429 * arranged in memory. If \a this array holds 2 components of 3 values:
1430 * \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$, then the result array holds these values arranged
1431 * as follows: \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$.
1432 * \warning Do not confuse this method with transpose()!
1433 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1434 * is to delete using decrRef() as it is no more needed.
1435 * \throw If \a this is not allocated.
1437 DataArrayDouble *DataArrayDouble::toNoInterlace() const
1440 throw INTERP_KERNEL::Exception("DataArrayDouble::toNoInterlace : Not defined array !");
1441 double *tab=_mem.toNoInterlace(getNumberOfComponents());
1442 DataArrayDouble *ret=DataArrayDouble::New();
1443 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
1448 * Permutes values of \a this array as required by \a old2New array. The values are
1449 * permuted so that \c new[ \a old2New[ i ]] = \c old[ i ]. Number of tuples remains
1450 * the same as in \this one.
1451 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
1452 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1453 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
1454 * giving a new position for i-th old value.
1456 void DataArrayDouble::renumberInPlace(const int *old2New)
1459 int nbTuples=getNumberOfTuples();
1460 int nbOfCompo=getNumberOfComponents();
1461 double *tmp=new double[nbTuples*nbOfCompo];
1462 const double *iptr=getConstPointer();
1463 for(int i=0;i<nbTuples;i++)
1466 if(v>=0 && v<nbTuples)
1467 std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),tmp+nbOfCompo*v);
1470 std::ostringstream oss; oss << "DataArrayDouble::renumberInPlace : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
1471 throw INTERP_KERNEL::Exception(oss.str().c_str());
1474 std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
1480 * Permutes values of \a this array as required by \a new2Old array. The values are
1481 * permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of tuples remains
1482 * the same as in \this one.
1483 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1484 * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
1485 * giving a previous position of i-th new value.
1486 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1487 * is to delete using decrRef() as it is no more needed.
1489 void DataArrayDouble::renumberInPlaceR(const int *new2Old)
1492 int nbTuples=getNumberOfTuples();
1493 int nbOfCompo=getNumberOfComponents();
1494 double *tmp=new double[nbTuples*nbOfCompo];
1495 const double *iptr=getConstPointer();
1496 for(int i=0;i<nbTuples;i++)
1499 if(v>=0 && v<nbTuples)
1500 std::copy(iptr+nbOfCompo*v,iptr+nbOfCompo*(v+1),tmp+nbOfCompo*i);
1503 std::ostringstream oss; oss << "DataArrayDouble::renumberInPlaceR : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
1504 throw INTERP_KERNEL::Exception(oss.str().c_str());
1507 std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
1513 * Returns a copy of \a this array with values permuted as required by \a old2New array.
1514 * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ].
1515 * Number of tuples in the result array remains the same as in \this one.
1516 * If a permutation reduction is needed, renumberAndReduce() should be used.
1517 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1518 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
1519 * giving a new position for i-th old value.
1520 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1521 * is to delete using decrRef() as it is no more needed.
1522 * \throw If \a this is not allocated.
1524 DataArrayDouble *DataArrayDouble::renumber(const int *old2New) const
1527 int nbTuples=getNumberOfTuples();
1528 int nbOfCompo=getNumberOfComponents();
1529 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1530 ret->alloc(nbTuples,nbOfCompo);
1531 ret->copyStringInfoFrom(*this);
1532 const double *iptr=getConstPointer();
1533 double *optr=ret->getPointer();
1534 for(int i=0;i<nbTuples;i++)
1535 std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),optr+nbOfCompo*old2New[i]);
1536 ret->copyStringInfoFrom(*this);
1541 * Returns a copy of \a this array with values permuted as required by \a new2Old array.
1542 * The values are permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of
1543 * tuples in the result array remains the same as in \this one.
1544 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
1545 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1546 * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
1547 * giving a previous position of i-th new value.
1548 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1549 * is to delete using decrRef() as it is no more needed.
1551 DataArrayDouble *DataArrayDouble::renumberR(const int *new2Old) const
1554 int nbTuples=getNumberOfTuples();
1555 int nbOfCompo=getNumberOfComponents();
1556 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1557 ret->alloc(nbTuples,nbOfCompo);
1558 ret->copyStringInfoFrom(*this);
1559 const double *iptr=getConstPointer();
1560 double *optr=ret->getPointer();
1561 for(int i=0;i<nbTuples;i++)
1562 std::copy(iptr+nbOfCompo*new2Old[i],iptr+nbOfCompo*(new2Old[i]+1),optr+i*nbOfCompo);
1563 ret->copyStringInfoFrom(*this);
1568 * Returns a shorten and permuted copy of \a this array. The new DataArrayDouble is
1569 * of size \a newNbOfTuple and it's values are permuted as required by \a old2New array.
1570 * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ] for all
1571 * \a old2New[ i ] >= 0. In other words every i-th tuple in \a this array, for which
1572 * \a old2New[ i ] is negative, is missing from the result array.
1573 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1574 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
1575 * giving a new position for i-th old tuple and giving negative position for
1576 * for i-th old tuple that should be omitted.
1577 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1578 * is to delete using decrRef() as it is no more needed.
1580 DataArrayDouble *DataArrayDouble::renumberAndReduce(const int *old2New, int newNbOfTuple) const
1583 int nbTuples=getNumberOfTuples();
1584 int nbOfCompo=getNumberOfComponents();
1585 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1586 ret->alloc(newNbOfTuple,nbOfCompo);
1587 const double *iptr=getConstPointer();
1588 double *optr=ret->getPointer();
1589 for(int i=0;i<nbTuples;i++)
1593 std::copy(iptr+i*nbOfCompo,iptr+(i+1)*nbOfCompo,optr+w*nbOfCompo);
1595 ret->copyStringInfoFrom(*this);
1600 * Returns a shorten and permuted copy of \a this array. The new DataArrayDouble is
1601 * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
1602 * \a new2OldBg array.
1603 * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
1604 * This method is equivalent to renumberAndReduce() except that convention in input is
1605 * \c new2old and \b not \c old2new.
1606 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1607 * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
1608 * tuple index in \a this array to fill the i-th tuple in the new array.
1609 * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
1610 * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
1611 * \a new2OldBg <= \a pi < \a new2OldEnd.
1612 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1613 * is to delete using decrRef() as it is no more needed.
1615 DataArrayDouble *DataArrayDouble::selectByTupleId(const int *new2OldBg, const int *new2OldEnd) const
1618 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1619 int nbComp=getNumberOfComponents();
1620 ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
1621 ret->copyStringInfoFrom(*this);
1622 double *pt=ret->getPointer();
1623 const double *srcPt=getConstPointer();
1625 for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
1626 std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
1627 ret->copyStringInfoFrom(*this);
1632 * Returns a shorten and permuted copy of \a this array. The new DataArrayDouble is
1633 * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
1634 * \a new2OldBg array.
1635 * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
1636 * This method is equivalent to renumberAndReduce() except that convention in input is
1637 * \c new2old and \b not \c old2new.
1638 * This method is equivalent to selectByTupleId() except that it prevents coping data
1639 * from behind the end of \a this array.
1640 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1641 * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
1642 * tuple index in \a this array to fill the i-th tuple in the new array.
1643 * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
1644 * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
1645 * \a new2OldBg <= \a pi < \a new2OldEnd.
1646 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1647 * is to delete using decrRef() as it is no more needed.
1648 * \throw If \a new2OldEnd - \a new2OldBg > \a this->getNumberOfTuples().
1650 DataArrayDouble *DataArrayDouble::selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const
1653 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1654 int nbComp=getNumberOfComponents();
1655 int oldNbOfTuples=getNumberOfTuples();
1656 ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
1657 ret->copyStringInfoFrom(*this);
1658 double *pt=ret->getPointer();
1659 const double *srcPt=getConstPointer();
1661 for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
1662 if(*w>=0 && *w<oldNbOfTuples)
1663 std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
1665 throw INTERP_KERNEL::Exception("DataArrayDouble::selectByTupleIdSafe : some ids has been detected to be out of [0,this->getNumberOfTuples) !");
1666 ret->copyStringInfoFrom(*this);
1671 * Returns a shorten copy of \a this array. The new DataArrayDouble contains every
1672 * (\a bg + \c i * \a step)-th tuple of \a this array located before the \a end2-th
1673 * tuple. Indices of the selected tuples are the same as ones returned by the Python
1674 * command \c range( \a bg, \a end2, \a step ).
1675 * This method is equivalent to selectByTupleIdSafe() except that the input array is
1676 * not constructed explicitly.
1677 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1678 * \param [in] bg - index of the first tuple to copy from \a this array.
1679 * \param [in] end2 - index of the tuple before which the tuples to copy are located.
1680 * \param [in] step - index increment to get index of the next tuple to copy.
1681 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1682 * is to delete using decrRef() as it is no more needed.
1683 * \sa DataArrayDouble::substr.
1685 DataArrayDouble *DataArrayDouble::selectByTupleId2(int bg, int end2, int step) const
1688 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1689 int nbComp=getNumberOfComponents();
1690 int newNbOfTuples=GetNumberOfItemGivenBESRelative(bg,end2,step,"DataArrayDouble::selectByTupleId2 : ");
1691 ret->alloc(newNbOfTuples,nbComp);
1692 double *pt=ret->getPointer();
1693 const double *srcPt=getConstPointer()+bg*nbComp;
1694 for(int i=0;i<newNbOfTuples;i++,srcPt+=step*nbComp)
1695 std::copy(srcPt,srcPt+nbComp,pt+i*nbComp);
1696 ret->copyStringInfoFrom(*this);
1701 * Returns a shorten copy of \a this array. The new DataArrayDouble contains ranges
1702 * of tuples specified by \a ranges parameter.
1703 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1704 * \param [in] ranges - std::vector of std::pair's each of which defines a range
1705 * of tuples in [\c begin,\c end) format.
1706 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1707 * is to delete using decrRef() as it is no more needed.
1708 * \throw If \a end < \a begin.
1709 * \throw If \a end > \a this->getNumberOfTuples().
1710 * \throw If \a this is not allocated.
1712 DataArray *DataArrayDouble::selectByTupleRanges(const std::vector<std::pair<int,int> >& ranges) const
1715 int nbOfComp=getNumberOfComponents();
1716 int nbOfTuplesThis=getNumberOfTuples();
1719 DataArrayDouble *ret=DataArrayDouble::New();
1720 ret->alloc(0,nbOfComp);
1721 ret->copyStringInfoFrom(*this);
1724 int ref=ranges.front().first;
1726 bool isIncreasing=true;
1727 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
1729 if((*it).first<=(*it).second)
1731 if((*it).first>=0 && (*it).second<=nbOfTuplesThis)
1733 nbOfTuples+=(*it).second-(*it).first;
1735 isIncreasing=ref<=(*it).first;
1740 std::ostringstream oss; oss << "DataArrayDouble::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
1741 oss << " (" << (*it).first << "," << (*it).second << ") is greater than number of tuples of this :" << nbOfTuples << " !";
1742 throw INTERP_KERNEL::Exception(oss.str().c_str());
1747 std::ostringstream oss; oss << "DataArrayDouble::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
1748 oss << " (" << (*it).first << "," << (*it).second << ") end is before begin !";
1749 throw INTERP_KERNEL::Exception(oss.str().c_str());
1752 if(isIncreasing && nbOfTuplesThis==nbOfTuples)
1754 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1755 ret->alloc(nbOfTuples,nbOfComp);
1756 ret->copyStringInfoFrom(*this);
1757 const double *src=getConstPointer();
1758 double *work=ret->getPointer();
1759 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
1760 work=std::copy(src+(*it).first*nbOfComp,src+(*it).second*nbOfComp,work);
1765 * Returns a shorten copy of \a this array. The new DataArrayDouble contains all
1766 * tuples starting from the \a tupleIdBg-th tuple and including all tuples located before
1767 * the \a tupleIdEnd-th one. This methods has a similar behavior as std::string::substr().
1768 * This method is a specialization of selectByTupleId2().
1769 * \param [in] tupleIdBg - index of the first tuple to copy from \a this array.
1770 * \param [in] tupleIdEnd - index of the tuple before which the tuples to copy are located.
1771 * If \a tupleIdEnd == -1, all the tuples till the end of \a this array are copied.
1772 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1773 * is to delete using decrRef() as it is no more needed.
1774 * \throw If \a tupleIdBg < 0.
1775 * \throw If \a tupleIdBg > \a this->getNumberOfTuples().
1776 \throw If \a tupleIdEnd != -1 && \a tupleIdEnd < \a this->getNumberOfTuples().
1777 * \sa DataArrayDouble::selectByTupleId2
1779 DataArrayDouble *DataArrayDouble::substr(int tupleIdBg, int tupleIdEnd) const
1782 int nbt=getNumberOfTuples();
1784 throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter must be greater than 0 !");
1786 throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter is greater than number of tuples !");
1787 int trueEnd=tupleIdEnd;
1791 throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter is greater or equal than number of tuples !");
1795 int nbComp=getNumberOfComponents();
1796 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1797 ret->alloc(trueEnd-tupleIdBg,nbComp);
1798 ret->copyStringInfoFrom(*this);
1799 std::copy(getConstPointer()+tupleIdBg*nbComp,getConstPointer()+trueEnd*nbComp,ret->getPointer());
1804 * Returns a shorten or extended copy of \a this array. If \a newNbOfComp is less
1805 * than \a this->getNumberOfComponents() then the result array is shorten as each tuple
1806 * is truncated to have \a newNbOfComp components, keeping first components. If \a
1807 * newNbOfComp is more than \a this->getNumberOfComponents() then the result array is
1808 * expanded as each tuple is populated with \a dftValue to have \a newNbOfComp
1810 * \param [in] newNbOfComp - number of components for the new array to have.
1811 * \param [in] dftValue - value assigned to new values added to the new array.
1812 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1813 * is to delete using decrRef() as it is no more needed.
1814 * \throw If \a this is not allocated.
1816 DataArrayDouble *DataArrayDouble::changeNbOfComponents(int newNbOfComp, double dftValue) const
1819 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1820 ret->alloc(getNumberOfTuples(),newNbOfComp);
1821 const double *oldc=getConstPointer();
1822 double *nc=ret->getPointer();
1823 int nbOfTuples=getNumberOfTuples();
1824 int oldNbOfComp=getNumberOfComponents();
1825 int dim=std::min(oldNbOfComp,newNbOfComp);
1826 for(int i=0;i<nbOfTuples;i++)
1830 nc[newNbOfComp*i+j]=oldc[i*oldNbOfComp+j];
1831 for(;j<newNbOfComp;j++)
1832 nc[newNbOfComp*i+j]=dftValue;
1834 ret->setName(getName());
1835 for(int i=0;i<dim;i++)
1836 ret->setInfoOnComponent(i,getInfoOnComponent(i));
1837 ret->setName(getName());
1842 * Changes the number of components within \a this array so that its raw data **does
1843 * not** change, instead splitting this data into tuples changes.
1844 * \warning This method erases all (name and unit) component info set before!
1845 * \param [in] newNbOfComp - number of components for \a this array to have.
1846 * \throw If \a this is not allocated
1847 * \throw If getNbOfElems() % \a newNbOfCompo != 0.
1848 * \throw If \a newNbOfCompo is lower than 1.
1849 * \throw If the rearrange method would lead to a number of tuples higher than 2147483647 (maximal capacity of int32 !).
1850 * \warning This method erases all (name and unit) component info set before!
1852 void DataArrayDouble::rearrange(int newNbOfCompo)
1856 throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : input newNbOfCompo must be > 0 !");
1857 std::size_t nbOfElems=getNbOfElems();
1858 if(nbOfElems%newNbOfCompo!=0)
1859 throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : nbOfElems%newNbOfCompo!=0 !");
1860 if(nbOfElems/newNbOfCompo>(std::size_t)std::numeric_limits<int>::max())
1861 throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : the rearrangement leads to too high number of tuples (> 2147483647) !");
1862 _info_on_compo.clear();
1863 _info_on_compo.resize(newNbOfCompo);
1868 * Changes the number of components within \a this array to be equal to its number
1869 * of tuples, and inversely its number of tuples to become equal to its number of
1870 * components. So that its raw data **does not** change, instead splitting this
1871 * data into tuples changes.
1872 * \warning This method erases all (name and unit) component info set before!
1873 * \warning Do not confuse this method with fromNoInterlace() and toNoInterlace()!
1874 * \throw If \a this is not allocated.
1877 void DataArrayDouble::transpose()
1880 int nbOfTuples=getNumberOfTuples();
1881 rearrange(nbOfTuples);
1885 * Returns a copy of \a this array composed of selected components.
1886 * The new DataArrayDouble has the same number of tuples but includes components
1887 * specified by \a compoIds parameter. So that getNbOfElems() of the result array
1888 * can be either less, same or more than \a this->getNbOfElems().
1889 * \param [in] compoIds - sequence of zero based indices of components to include
1890 * into the new array.
1891 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1892 * is to delete using decrRef() as it is no more needed.
1893 * \throw If \a this is not allocated.
1894 * \throw If a component index (\a i) is not valid:
1895 * \a i < 0 || \a i >= \a this->getNumberOfComponents().
1897 * \if ENABLE_EXAMPLES
1898 * \ref py_mcdataarraydouble_KeepSelectedComponents "Here is a Python example".
1901 DataArrayDouble *DataArrayDouble::keepSelectedComponents(const std::vector<int>& compoIds) const
1904 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret(DataArrayDouble::New());
1905 std::size_t newNbOfCompo=compoIds.size();
1906 int oldNbOfCompo=getNumberOfComponents();
1907 for(std::vector<int>::const_iterator it=compoIds.begin();it!=compoIds.end();it++)
1908 if((*it)<0 || (*it)>=oldNbOfCompo)
1910 std::ostringstream oss; oss << "DataArrayDouble::keepSelectedComponents : invalid requested component : " << *it << " whereas it should be in [0," << oldNbOfCompo << ") !";
1911 throw INTERP_KERNEL::Exception(oss.str().c_str());
1913 int nbOfTuples=getNumberOfTuples();
1914 ret->alloc(nbOfTuples,(int)newNbOfCompo);
1915 ret->copyPartOfStringInfoFrom(*this,compoIds);
1916 const double *oldc=getConstPointer();
1917 double *nc=ret->getPointer();
1918 for(int i=0;i<nbOfTuples;i++)
1919 for(std::size_t j=0;j<newNbOfCompo;j++,nc++)
1920 *nc=oldc[i*oldNbOfCompo+compoIds[j]];
1925 * Appends components of another array to components of \a this one, tuple by tuple.
1926 * So that the number of tuples of \a this array remains the same and the number of
1927 * components increases.
1928 * \param [in] other - the DataArrayDouble to append to \a this one.
1929 * \throw If \a this is not allocated.
1930 * \throw If \a this and \a other arrays have different number of tuples.
1932 * \if ENABLE_EXAMPLES
1933 * \ref cpp_mcdataarraydouble_meldwith "Here is a C++ example".
1935 * \ref py_mcdataarraydouble_meldwith "Here is a Python example".
1938 void DataArrayDouble::meldWith(const DataArrayDouble *other)
1941 other->checkAllocated();
1942 int nbOfTuples=getNumberOfTuples();
1943 if(nbOfTuples!=other->getNumberOfTuples())
1944 throw INTERP_KERNEL::Exception("DataArrayDouble::meldWith : mismatch of number of tuples !");
1945 int nbOfComp1=getNumberOfComponents();
1946 int nbOfComp2=other->getNumberOfComponents();
1947 double *newArr=(double *)malloc((nbOfTuples*(nbOfComp1+nbOfComp2))*sizeof(double));
1949 const double *inp1=getConstPointer();
1950 const double *inp2=other->getConstPointer();
1951 for(int i=0;i<nbOfTuples;i++,inp1+=nbOfComp1,inp2+=nbOfComp2)
1953 w=std::copy(inp1,inp1+nbOfComp1,w);
1954 w=std::copy(inp2,inp2+nbOfComp2,w);
1956 useArray(newArr,true,C_DEALLOC,nbOfTuples,nbOfComp1+nbOfComp2);
1957 std::vector<int> compIds(nbOfComp2);
1958 for(int i=0;i<nbOfComp2;i++)
1959 compIds[i]=nbOfComp1+i;
1960 copyPartOfStringInfoFrom2(compIds,*other);
1964 * This method checks that all tuples in \a other are in \a this.
1965 * If true, the output param \a tupleIds contains the tuples ids of \a this that correspond to tupes in \a this.
1966 * For each i in [ 0 , other->getNumberOfTuples() ) tuple #i in \a other is equal ( regarding input precision \a prec ) to tuple tupleIds[i] in \a this.
1968 * \param [in] other - the array having the same number of components than \a this.
1969 * \param [out] tupleIds - the tuple ids containing the same number of tuples than \a other has.
1970 * \sa DataArrayDouble::findCommonTuples
1972 bool DataArrayDouble::areIncludedInMe(const DataArrayDouble *other, double prec, DataArrayInt *&tupleIds) const
1975 throw INTERP_KERNEL::Exception("DataArrayDouble::areIncludedInMe : input array is NULL !");
1976 checkAllocated(); other->checkAllocated();
1977 if(getNumberOfComponents()!=other->getNumberOfComponents())
1978 throw INTERP_KERNEL::Exception("DataArrayDouble::areIncludedInMe : the number of components does not match !");
1979 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> a=DataArrayDouble::Aggregate(this,other);
1980 DataArrayInt *c=0,*ci=0;
1981 a->findCommonTuples(prec,getNumberOfTuples(),c,ci);
1982 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cSafe(c),ciSafe(ci);
1983 int newNbOfTuples=-1;
1984 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(a->getNumberOfTuples(),c->begin(),ci->begin(),ci->end(),newNbOfTuples);
1985 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=ids->selectByTupleId2(getNumberOfTuples(),a->getNumberOfTuples(),1);
1986 tupleIds=ret1.retn();
1987 return newNbOfTuples==getNumberOfTuples();
1991 * Searches for tuples coincident within \a prec tolerance. Each tuple is considered
1992 * as coordinates of a point in getNumberOfComponents()-dimensional space. The
1993 * distance separating two points is computed with the infinite norm.
1995 * Indices of coincident tuples are stored in output arrays.
1996 * A pair of arrays (\a comm, \a commIndex) is called "Surjective Format 2".
1998 * This method is typically used by MEDCouplingPointSet::findCommonNodes() and
1999 * MEDCouplingUMesh::mergeNodes().
2000 * \param [in] prec - minimal absolute distance between two tuples (infinite norm) at which they are
2001 * considered not coincident.
2002 * \param [in] limitTupleId - limit tuple id. If all tuples within a group of coincident
2003 * tuples have id strictly lower than \a limitTupleId then they are not returned.
2004 * \param [out] comm - the array holding ids (== indices) of coincident tuples.
2005 * \a comm->getNumberOfComponents() == 1.
2006 * \a comm->getNumberOfTuples() == \a commIndex->back().
2007 * \param [out] commIndex - the array dividing all indices stored in \a comm into
2008 * groups of (indices of) coincident tuples. Its every value is a tuple
2009 * index where a next group of tuples begins. For example the second
2010 * group of tuples in \a comm is described by following range of indices:
2011 * [ \a commIndex[1], \a commIndex[2] ). \a commIndex->getNumberOfTuples()-1
2012 * gives the number of groups of coincident tuples.
2013 * \throw If \a this is not allocated.
2014 * \throw If the number of components is not in [1,2,3,4].
2016 * \if ENABLE_EXAMPLES
2017 * \ref cpp_mcdataarraydouble_findcommontuples "Here is a C++ example".
2019 * \ref py_mcdataarraydouble_findcommontuples "Here is a Python example".
2021 * \sa DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(), DataArrayDouble::areIncludedInMe
2023 void DataArrayDouble::findCommonTuples(double prec, int limitTupleId, DataArrayInt *&comm, DataArrayInt *&commIndex) const
2026 int nbOfCompo=getNumberOfComponents();
2027 if ((nbOfCompo<1) || (nbOfCompo>4)) //test before work
2028 throw INTERP_KERNEL::Exception("DataArrayDouble::findCommonTuples : Unexpected spacedim of coords. Must be 1, 2, 3 or 4.");
2030 int nbOfTuples=getNumberOfTuples();
2032 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> c(DataArrayInt::New()),cI(DataArrayInt::New()); c->alloc(0,1); cI->pushBackSilent(0);
2036 findCommonTuplesAlg<4>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
2039 findCommonTuplesAlg<3>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
2042 findCommonTuplesAlg<2>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
2045 findCommonTuplesAlg<1>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
2048 throw INTERP_KERNEL::Exception("DataArrayDouble::findCommonTuples : nb of components managed are 1,2,3 and 4 ! not implemented for other number of components !");
2051 commIndex=cI.retn();
2056 * \param [in] nbTimes specifies the nb of times each tuples in \a this will be duplicated contiguouly in returned DataArrayDouble instance.
2057 * \a nbTimes should be at least equal to 1.
2058 * \return a newly allocated DataArrayDouble having one component and number of tuples equal to \a nbTimes * \c this->getNumberOfTuples.
2059 * \throw if \a this is not allocated or if \a this has not number of components set to one or if \a nbTimes is lower than 1.
2061 DataArrayDouble *DataArrayDouble::duplicateEachTupleNTimes(int nbTimes) const
2064 if(getNumberOfComponents()!=1)
2065 throw INTERP_KERNEL::Exception("DataArrayDouble::duplicateEachTupleNTimes : this should have only one component !");
2067 throw INTERP_KERNEL::Exception("DataArrayDouble::duplicateEachTupleNTimes : nb times should be >= 1 !");
2068 int nbTuples=getNumberOfTuples();
2069 const double *inPtr=getConstPointer();
2070 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(nbTimes*nbTuples,1);
2071 double *retPtr=ret->getPointer();
2072 for(int i=0;i<nbTuples;i++,inPtr++)
2075 for(int j=0;j<nbTimes;j++,retPtr++)
2078 ret->copyStringInfoFrom(*this);
2083 * This methods returns the minimal distance between the two set of points \a this and \a other.
2084 * So \a this and \a other have to have the same number of components. If not an INTERP_KERNEL::Exception will be thrown.
2085 * This method works only if number of components of \a this (equal to those of \a other) is in 1, 2 or 3.
2087 * \param [out] thisTupleId the tuple id in \a this corresponding to the returned minimal distance
2088 * \param [out] otherTupleId the tuple id in \a other corresponding to the returned minimal distance
2089 * \return the minimal distance between the two set of points \a this and \a other.
2090 * \sa DataArrayDouble::findClosestTupleId
2092 double DataArrayDouble::minimalDistanceTo(const DataArrayDouble *other, int& thisTupleId, int& otherTupleId) const
2094 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> part1=findClosestTupleId(other);
2095 int nbOfCompo(getNumberOfComponents());
2096 int otherNbTuples(other->getNumberOfTuples());
2097 const double *thisPt(begin()),*otherPt(other->begin());
2098 const int *part1Pt(part1->begin());
2099 double ret=std::numeric_limits<double>::max();
2100 for(int i=0;i<otherNbTuples;i++,part1Pt++,otherPt+=nbOfCompo)
2103 for(int j=0;j<nbOfCompo;j++)
2104 tmp+=(otherPt[j]-thisPt[nbOfCompo*(*part1Pt)+j])*(otherPt[j]-thisPt[nbOfCompo*(*part1Pt)+j]);
2106 { ret=tmp; thisTupleId=*part1Pt; otherTupleId=i; }
2112 * This methods returns for each tuple in \a other which tuple in \a this is the closest.
2113 * So \a this and \a other have to have the same number of components. If not an INTERP_KERNEL::Exception will be thrown.
2114 * This method works only if number of components of \a this (equal to those of \a other) is in 1, 2 or 3.
2116 * \return a newly allocated (new object to be dealt by the caller) DataArrayInt having \c other->getNumberOfTuples() tuples and one components.
2117 * \sa DataArrayDouble::minimalDistanceTo
2119 DataArrayInt *DataArrayDouble::findClosestTupleId(const DataArrayDouble *other) const
2122 throw INTERP_KERNEL::Exception("DataArrayDouble::findClosestTupleId : other instance is NULL !");
2123 checkAllocated(); other->checkAllocated();
2124 int nbOfCompo=getNumberOfComponents();
2125 if(nbOfCompo!=other->getNumberOfComponents())
2127 std::ostringstream oss; oss << "DataArrayDouble::findClosestTupleId : number of components in this is " << nbOfCompo;
2128 oss << ", whereas number of components in other is " << other->getNumberOfComponents() << "! Should be equal !";
2129 throw INTERP_KERNEL::Exception(oss.str().c_str());
2131 int nbOfTuples=other->getNumberOfTuples();
2132 int thisNbOfTuples=getNumberOfTuples();
2133 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbOfTuples,1);
2135 getMinMaxPerComponent(bounds);
2140 double xDelta(fabs(bounds[1]-bounds[0])),yDelta(fabs(bounds[3]-bounds[2])),zDelta(fabs(bounds[5]-bounds[4]));
2141 double delta=std::max(xDelta,yDelta); delta=std::max(delta,zDelta);
2142 double characSize=pow((delta*delta*delta)/((double)thisNbOfTuples),1./3.);
2143 BBTreePts<3,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
2144 FindClosestTupleIdAlg<3>(myTree,3.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
2149 double xDelta(fabs(bounds[1]-bounds[0])),yDelta(fabs(bounds[3]-bounds[2]));
2150 double delta=std::max(xDelta,yDelta);
2151 double characSize=sqrt(delta/(double)thisNbOfTuples);
2152 BBTreePts<2,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
2153 FindClosestTupleIdAlg<2>(myTree,2.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
2158 double characSize=fabs(bounds[1]-bounds[0])/thisNbOfTuples;
2159 BBTreePts<1,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
2160 FindClosestTupleIdAlg<1>(myTree,1.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
2164 throw INTERP_KERNEL::Exception("Unexpected spacedim of coords for findClosestTupleId. Must be 1, 2 or 3.");
2170 * This method expects that \a this and \a otherBBoxFrmt arrays are bounding box arrays ( as the output of MEDCouplingPointSet::getBoundingBoxForBBTree method ).
2171 * This method will return a DataArrayInt array having the same number of tuples than \a this. This returned array tells for each cell in \a this
2172 * how many bounding boxes in \a otherBBoxFrmt.
2173 * So, this method expects that \a this and \a otherBBoxFrmt have the same number of components.
2175 * \param [in] otherBBoxFrmt - It is an array .
2176 * \param [in] eps - the absolute precision of the detection. when eps < 0 the bboxes are enlarged so more interactions are detected. Inversely when > 0 the bboxes are stretched.
2177 * \sa MEDCouplingPointSet::getBoundingBoxForBBTree
2178 * \throw If \a this and \a otherBBoxFrmt have not the same number of components.
2179 * \throw If \a this and \a otherBBoxFrmt number of components is not even (BBox format).
2181 DataArrayInt *DataArrayDouble::computeNbOfInteractionsWith(const DataArrayDouble *otherBBoxFrmt, double eps) const
2184 throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : input array is NULL !");
2185 if(!isAllocated() || !otherBBoxFrmt->isAllocated())
2186 throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : this and input array must be allocated !");
2187 int nbOfComp(getNumberOfComponents()),nbOfTuples(getNumberOfTuples());
2188 if(nbOfComp!=otherBBoxFrmt->getNumberOfComponents())
2190 std::ostringstream oss; oss << "DataArrayDouble::computeNbOfInteractionsWith : this number of components (" << nbOfComp << ") must be equal to the number of components of input array (" << otherBBoxFrmt->getNumberOfComponents() << ") !";
2191 throw INTERP_KERNEL::Exception(oss.str().c_str());
2195 std::ostringstream oss; oss << "DataArrayDouble::computeNbOfInteractionsWith : Number of components (" << nbOfComp << ") is not even ! It should be to be compatible with bbox format !";
2196 throw INTERP_KERNEL::Exception(oss.str().c_str());
2198 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(nbOfTuples,1);
2199 const double *thisBBPtr(begin());
2200 int *retPtr(ret->getPointer());
2205 BBTree<3,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
2206 for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
2207 *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
2212 BBTree<2,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
2213 for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
2214 *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
2219 BBTree<1,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
2220 for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
2221 *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
2225 throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : space dimension supported are [1,2,3] !");
2232 * Returns a copy of \a this array by excluding coincident tuples. Each tuple is
2233 * considered as coordinates of a point in getNumberOfComponents()-dimensional
2234 * space. The distance between tuples is computed using norm2. If several tuples are
2235 * not far each from other than \a prec, only one of them remains in the result
2236 * array. The order of tuples in the result array is same as in \a this one except
2237 * that coincident tuples are excluded.
2238 * \param [in] prec - minimal absolute distance between two tuples at which they are
2239 * considered not coincident.
2240 * \param [in] limitTupleId - limit tuple id. If all tuples within a group of coincident
2241 * tuples have id strictly lower than \a limitTupleId then they are not excluded.
2242 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
2243 * is to delete using decrRef() as it is no more needed.
2244 * \throw If \a this is not allocated.
2245 * \throw If the number of components is not in [1,2,3,4].
2247 * \if ENABLE_EXAMPLES
2248 * \ref py_mcdataarraydouble_getdifferentvalues "Here is a Python example".
2251 DataArrayDouble *DataArrayDouble::getDifferentValues(double prec, int limitTupleId) const
2254 DataArrayInt *c0=0,*cI0=0;
2255 findCommonTuples(prec,limitTupleId,c0,cI0);
2256 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> c(c0),cI(cI0);
2257 int newNbOfTuples=-1;
2258 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> o2n=DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(getNumberOfTuples(),c0->begin(),cI0->begin(),cI0->end(),newNbOfTuples);
2259 return renumberAndReduce(o2n->getConstPointer(),newNbOfTuples);
2263 * Copy all components in a specified order from another DataArrayDouble.
2264 * Both numerical and textual data is copied. The number of tuples in \a this and
2265 * the other array can be different.
2266 * \param [in] a - the array to copy data from.
2267 * \param [in] compoIds - sequence of zero based indices of components, data of which is
2269 * \throw If \a a is NULL.
2270 * \throw If \a compoIds.size() != \a a->getNumberOfComponents().
2271 * \throw If \a compoIds[i] < 0 or \a compoIds[i] > \a this->getNumberOfComponents().
2273 * \if ENABLE_EXAMPLES
2274 * \ref py_mcdataarraydouble_setselectedcomponents "Here is a Python example".
2277 void DataArrayDouble::setSelectedComponents(const DataArrayDouble *a, const std::vector<int>& compoIds)
2280 throw INTERP_KERNEL::Exception("DataArrayDouble::setSelectedComponents : input DataArrayDouble is NULL !");
2282 copyPartOfStringInfoFrom2(compoIds,*a);
2283 std::size_t partOfCompoSz=compoIds.size();
2284 int nbOfCompo=getNumberOfComponents();
2285 int nbOfTuples=std::min(getNumberOfTuples(),a->getNumberOfTuples());
2286 const double *ac=a->getConstPointer();
2287 double *nc=getPointer();
2288 for(int i=0;i<nbOfTuples;i++)
2289 for(std::size_t j=0;j<partOfCompoSz;j++,ac++)
2290 nc[nbOfCompo*i+compoIds[j]]=*ac;
2294 * Copy all values from another DataArrayDouble into specified tuples and components
2295 * of \a this array. Textual data is not copied.
2296 * The tree parameters defining set of indices of tuples and components are similar to
2297 * the tree parameters of the Python function \c range(\c start,\c stop,\c step).
2298 * \param [in] a - the array to copy values from.
2299 * \param [in] bgTuples - index of the first tuple of \a this array to assign values to.
2300 * \param [in] endTuples - index of the tuple before which the tuples to assign to
2302 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
2303 * \param [in] bgComp - index of the first component of \a this array to assign values to.
2304 * \param [in] endComp - index of the component before which the components to assign
2306 * \param [in] stepComp - index increment to get index of the next component to assign to.
2307 * \param [in] strictCompoCompare - if \a true (by default), then \a a->getNumberOfComponents()
2308 * must be equal to the number of columns to assign to, else an
2309 * exception is thrown; if \a false, then it is only required that \a
2310 * a->getNbOfElems() equals to number of values to assign to (this condition
2311 * must be respected even if \a strictCompoCompare is \a true). The number of
2312 * values to assign to is given by following Python expression:
2313 * \a nbTargetValues =
2314 * \c len(\c range(\a bgTuples,\a endTuples,\a stepTuples)) *
2315 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2316 * \throw If \a a is NULL.
2317 * \throw If \a a is not allocated.
2318 * \throw If \a this is not allocated.
2319 * \throw If parameters specifying tuples and components to assign to do not give a
2320 * non-empty range of increasing indices.
2321 * \throw If \a a->getNbOfElems() != \a nbTargetValues.
2322 * \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
2323 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2325 * \if ENABLE_EXAMPLES
2326 * \ref py_mcdataarraydouble_setpartofvalues1 "Here is a Python example".
2329 void DataArrayDouble::setPartOfValues1(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
2332 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues1 : input DataArrayDouble is NULL !");
2333 const char msg[]="DataArrayDouble::setPartOfValues1";
2335 a->checkAllocated();
2336 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2337 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2338 int nbComp=getNumberOfComponents();
2339 int nbOfTuples=getNumberOfTuples();
2340 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2341 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2342 bool assignTech=true;
2343 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2345 if(strictCompoCompare)
2346 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2350 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2353 const double *srcPt=a->getConstPointer();
2354 double *pt=getPointer()+bgTuples*nbComp+bgComp;
2357 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2358 for(int j=0;j<newNbOfComp;j++,srcPt++)
2359 pt[j*stepComp]=*srcPt;
2363 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2365 const double *srcPt2=srcPt;
2366 for(int j=0;j<newNbOfComp;j++,srcPt2++)
2367 pt[j*stepComp]=*srcPt2;
2373 * Assign a given value to values at specified tuples and components of \a this array.
2374 * The tree parameters defining set of indices of tuples and components are similar to
2375 * the tree parameters of the Python function \c range(\c start,\c stop,\c step)..
2376 * \param [in] a - the value to assign.
2377 * \param [in] bgTuples - index of the first tuple of \a this array to assign to.
2378 * \param [in] endTuples - index of the tuple before which the tuples to assign to
2380 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
2381 * \param [in] bgComp - index of the first component of \a this array to assign to.
2382 * \param [in] endComp - index of the component before which the components to assign
2384 * \param [in] stepComp - index increment to get index of the next component to assign to.
2385 * \throw If \a this is not allocated.
2386 * \throw If parameters specifying tuples and components to assign to, do not give a
2387 * non-empty range of increasing indices or indices are out of a valid range
2390 * \if ENABLE_EXAMPLES
2391 * \ref py_mcdataarraydouble_setpartofvaluessimple1 "Here is a Python example".
2394 void DataArrayDouble::setPartOfValuesSimple1(double a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp)
2396 const char msg[]="DataArrayDouble::setPartOfValuesSimple1";
2398 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2399 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2400 int nbComp=getNumberOfComponents();
2401 int nbOfTuples=getNumberOfTuples();
2402 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2403 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2404 double *pt=getPointer()+bgTuples*nbComp+bgComp;
2405 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2406 for(int j=0;j<newNbOfComp;j++)
2411 * Copy all values from another DataArrayDouble (\a a) into specified tuples and
2412 * components of \a this array. Textual data is not copied.
2413 * The tuples and components to assign to are defined by C arrays of indices.
2414 * There are two *modes of usage*:
2415 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
2416 * of \a a is assigned to its own location within \a this array.
2417 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
2418 * components of every specified tuple of \a this array. In this mode it is required
2419 * that \a a->getNumberOfComponents() equals to the number of specified components.
2421 * \param [in] a - the array to copy values from.
2422 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2423 * assign values of \a a to.
2424 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2425 * pointer to a tuple index <em>(pi)</em> varies as this:
2426 * \a bgTuples <= \a pi < \a endTuples.
2427 * \param [in] bgComp - pointer to an array of component indices of \a this array to
2428 * assign values of \a a to.
2429 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
2430 * pointer to a component index <em>(pi)</em> varies as this:
2431 * \a bgComp <= \a pi < \a endComp.
2432 * \param [in] strictCompoCompare - this parameter is checked only if the
2433 * *mode of usage* is the first; if it is \a true (default),
2434 * then \a a->getNumberOfComponents() must be equal
2435 * to the number of specified columns, else this is not required.
2436 * \throw If \a a is NULL.
2437 * \throw If \a a is not allocated.
2438 * \throw If \a this is not allocated.
2439 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
2440 * out of a valid range for \a this array.
2441 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
2442 * if <em> a->getNumberOfComponents() != (endComp - bgComp) </em>.
2443 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
2444 * <em> a->getNumberOfComponents() != (endComp - bgComp)</em>.
2446 * \if ENABLE_EXAMPLES
2447 * \ref py_mcdataarraydouble_setpartofvalues2 "Here is a Python example".
2450 void DataArrayDouble::setPartOfValues2(const DataArrayDouble *a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
2453 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues2 : input DataArrayDouble is NULL !");
2454 const char msg[]="DataArrayDouble::setPartOfValues2";
2456 a->checkAllocated();
2457 int nbComp=getNumberOfComponents();
2458 int nbOfTuples=getNumberOfTuples();
2459 for(const int *z=bgComp;z!=endComp;z++)
2460 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2461 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
2462 int newNbOfComp=(int)std::distance(bgComp,endComp);
2463 bool assignTech=true;
2464 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2466 if(strictCompoCompare)
2467 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2471 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2474 double *pt=getPointer();
2475 const double *srcPt=a->getConstPointer();
2478 for(const int *w=bgTuples;w!=endTuples;w++)
2480 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2481 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
2483 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt;
2489 for(const int *w=bgTuples;w!=endTuples;w++)
2491 const double *srcPt2=srcPt;
2492 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2493 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
2495 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt2;
2502 * Assign a given value to values at specified tuples and components of \a this array.
2503 * The tuples and components to assign to are defined by C arrays of indices.
2504 * \param [in] a - the value to assign.
2505 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2507 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2508 * pointer to a tuple index (\a pi) varies as this:
2509 * \a bgTuples <= \a pi < \a endTuples.
2510 * \param [in] bgComp - pointer to an array of component indices of \a this array to
2512 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
2513 * pointer to a component index (\a pi) varies as this:
2514 * \a bgComp <= \a pi < \a endComp.
2515 * \throw If \a this is not allocated.
2516 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
2517 * out of a valid range for \a this array.
2519 * \if ENABLE_EXAMPLES
2520 * \ref py_mcdataarraydouble_setpartofvaluessimple2 "Here is a Python example".
2523 void DataArrayDouble::setPartOfValuesSimple2(double a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp)
2526 int nbComp=getNumberOfComponents();
2527 int nbOfTuples=getNumberOfTuples();
2528 for(const int *z=bgComp;z!=endComp;z++)
2529 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2530 double *pt=getPointer();
2531 for(const int *w=bgTuples;w!=endTuples;w++)
2532 for(const int *z=bgComp;z!=endComp;z++)
2534 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2535 pt[(std::size_t)(*w)*nbComp+(*z)]=a;
2540 * Copy all values from another DataArrayDouble (\a a) into specified tuples and
2541 * components of \a this array. Textual data is not copied.
2542 * The tuples to assign to are defined by a C array of indices.
2543 * The components to assign to are defined by three values similar to parameters of
2544 * the Python function \c range(\c start,\c stop,\c step).
2545 * There are two *modes of usage*:
2546 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
2547 * of \a a is assigned to its own location within \a this array.
2548 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
2549 * components of every specified tuple of \a this array. In this mode it is required
2550 * that \a a->getNumberOfComponents() equals to the number of specified components.
2552 * \param [in] a - the array to copy values from.
2553 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2554 * assign values of \a a to.
2555 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2556 * pointer to a tuple index <em>(pi)</em> varies as this:
2557 * \a bgTuples <= \a pi < \a endTuples.
2558 * \param [in] bgComp - index of the first component of \a this array to assign to.
2559 * \param [in] endComp - index of the component before which the components to assign
2561 * \param [in] stepComp - index increment to get index of the next component to assign to.
2562 * \param [in] strictCompoCompare - this parameter is checked only in the first
2563 * *mode of usage*; if \a strictCompoCompare is \a true (default),
2564 * then \a a->getNumberOfComponents() must be equal
2565 * to the number of specified columns, else this is not required.
2566 * \throw If \a a is NULL.
2567 * \throw If \a a is not allocated.
2568 * \throw If \a this is not allocated.
2569 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
2571 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
2572 * if <em> a->getNumberOfComponents()</em> is unequal to the number of components
2573 * defined by <em>(bgComp,endComp,stepComp)</em>.
2574 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
2575 * <em> a->getNumberOfComponents()</em> is unequal to the number of components
2576 * defined by <em>(bgComp,endComp,stepComp)</em>.
2577 * \throw If parameters specifying components to assign to, do not give a
2578 * non-empty range of increasing indices or indices are out of a valid range
2581 * \if ENABLE_EXAMPLES
2582 * \ref py_mcdataarraydouble_setpartofvalues3 "Here is a Python example".
2585 void DataArrayDouble::setPartOfValues3(const DataArrayDouble *a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
2588 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues3 : input DataArrayDouble is NULL !");
2589 const char msg[]="DataArrayDouble::setPartOfValues3";
2591 a->checkAllocated();
2592 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2593 int nbComp=getNumberOfComponents();
2594 int nbOfTuples=getNumberOfTuples();
2595 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2596 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
2597 bool assignTech=true;
2598 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2600 if(strictCompoCompare)
2601 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2605 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2608 double *pt=getPointer()+bgComp;
2609 const double *srcPt=a->getConstPointer();
2612 for(const int *w=bgTuples;w!=endTuples;w++)
2613 for(int j=0;j<newNbOfComp;j++,srcPt++)
2615 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2616 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt;
2621 for(const int *w=bgTuples;w!=endTuples;w++)
2623 const double *srcPt2=srcPt;
2624 for(int j=0;j<newNbOfComp;j++,srcPt2++)
2626 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2627 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt2;
2634 * Assign a given value to values at specified tuples and components of \a this array.
2635 * The tuples to assign to are defined by a C array of indices.
2636 * The components to assign to are defined by three values similar to parameters of
2637 * the Python function \c range(\c start,\c stop,\c step).
2638 * \param [in] a - the value to assign.
2639 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2641 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2642 * pointer to a tuple index <em>(pi)</em> varies as this:
2643 * \a bgTuples <= \a pi < \a endTuples.
2644 * \param [in] bgComp - index of the first component of \a this array to assign to.
2645 * \param [in] endComp - index of the component before which the components to assign
2647 * \param [in] stepComp - index increment to get index of the next component to assign to.
2648 * \throw If \a this is not allocated.
2649 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
2651 * \throw If parameters specifying components to assign to, do not give a
2652 * non-empty range of increasing indices or indices are out of a valid range
2655 * \if ENABLE_EXAMPLES
2656 * \ref py_mcdataarraydouble_setpartofvaluessimple3 "Here is a Python example".
2659 void DataArrayDouble::setPartOfValuesSimple3(double a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp)
2661 const char msg[]="DataArrayDouble::setPartOfValuesSimple3";
2663 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2664 int nbComp=getNumberOfComponents();
2665 int nbOfTuples=getNumberOfTuples();
2666 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2667 double *pt=getPointer()+bgComp;
2668 for(const int *w=bgTuples;w!=endTuples;w++)
2669 for(int j=0;j<newNbOfComp;j++)
2671 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2672 pt[(std::size_t)(*w)*nbComp+j*stepComp]=a;
2677 * Copy all values from another DataArrayDouble into specified tuples and components
2678 * of \a this array. Textual data is not copied.
2679 * The tree parameters defining set of indices of tuples and components are similar to
2680 * the tree parameters of the Python function \c range(\c start,\c stop,\c step).
2681 * \param [in] a - the array to copy values from.
2682 * \param [in] bgTuples - index of the first tuple of \a this array to assign values to.
2683 * \param [in] endTuples - index of the tuple before which the tuples to assign to
2685 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
2686 * \param [in] bgComp - pointer to an array of component indices of \a this array to
2688 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
2689 * pointer to a component index (\a pi) varies as this:
2690 * \a bgComp <= \a pi < \a endComp.
2691 * \param [in] strictCompoCompare - if \a true (by default), then \a a->getNumberOfComponents()
2692 * must be equal to the number of columns to assign to, else an
2693 * exception is thrown; if \a false, then it is only required that \a
2694 * a->getNbOfElems() equals to number of values to assign to (this condition
2695 * must be respected even if \a strictCompoCompare is \a true). The number of
2696 * values to assign to is given by following Python expression:
2697 * \a nbTargetValues =
2698 * \c len(\c range(\a bgTuples,\a endTuples,\a stepTuples)) *
2699 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2700 * \throw If \a a is NULL.
2701 * \throw If \a a is not allocated.
2702 * \throw If \a this is not allocated.
2703 * \throw If parameters specifying tuples and components to assign to do not give a
2704 * non-empty range of increasing indices.
2705 * \throw If \a a->getNbOfElems() != \a nbTargetValues.
2706 * \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
2707 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2710 void DataArrayDouble::setPartOfValues4(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
2713 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues4 : input DataArrayDouble is NULL !");
2714 const char msg[]="DataArrayDouble::setPartOfValues4";
2716 a->checkAllocated();
2717 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2718 int newNbOfComp=(int)std::distance(bgComp,endComp);
2719 int nbComp=getNumberOfComponents();
2720 for(const int *z=bgComp;z!=endComp;z++)
2721 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2722 int nbOfTuples=getNumberOfTuples();
2723 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2724 bool assignTech=true;
2725 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2727 if(strictCompoCompare)
2728 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2732 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2735 const double *srcPt=a->getConstPointer();
2736 double *pt=getPointer()+bgTuples*nbComp;
2739 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2740 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
2745 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2747 const double *srcPt2=srcPt;
2748 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
2754 void DataArrayDouble::setPartOfValuesSimple4(double a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp)
2756 const char msg[]="DataArrayDouble::setPartOfValuesSimple4";
2758 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2759 int nbComp=getNumberOfComponents();
2760 for(const int *z=bgComp;z!=endComp;z++)
2761 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2762 int nbOfTuples=getNumberOfTuples();
2763 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2764 double *pt=getPointer()+bgTuples*nbComp;
2765 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2766 for(const int *z=bgComp;z!=endComp;z++)
2771 * Copy some tuples from another DataArrayDouble into specified tuples
2772 * of \a this array. Textual data is not copied. Both arrays must have equal number of
2774 * Both the tuples to assign and the tuples to assign to are defined by a DataArrayInt.
2775 * All components of selected tuples are copied.
2776 * \param [in] a - the array to copy values from.
2777 * \param [in] tuplesSelec - the array specifying both source tuples of \a a and
2778 * target tuples of \a this. \a tuplesSelec has two components, and the
2779 * first component specifies index of the source tuple and the second
2780 * one specifies index of the target tuple.
2781 * \throw If \a this is not allocated.
2782 * \throw If \a a is NULL.
2783 * \throw If \a a is not allocated.
2784 * \throw If \a tuplesSelec is NULL.
2785 * \throw If \a tuplesSelec is not allocated.
2786 * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
2787 * \throw If \a tuplesSelec->getNumberOfComponents() != 2.
2788 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
2789 * the corresponding (\a this or \a a) array.
2791 void DataArrayDouble::setPartOfValuesAdv(const DataArrayDouble *a, const DataArrayInt *tuplesSelec)
2793 if(!a || !tuplesSelec)
2794 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValuesAdv : input DataArrayDouble is NULL !");
2796 a->checkAllocated();
2797 tuplesSelec->checkAllocated();
2798 int nbOfComp=getNumberOfComponents();
2799 if(nbOfComp!=a->getNumberOfComponents())
2800 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValuesAdv : This and a do not have the same number of components !");
2801 if(tuplesSelec->getNumberOfComponents()!=2)
2802 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValuesAdv : Expecting to have a tuple selector DataArrayInt instance with exactly 2 components !");
2803 int thisNt=getNumberOfTuples();
2804 int aNt=a->getNumberOfTuples();
2805 double *valsToSet=getPointer();
2806 const double *valsSrc=a->getConstPointer();
2807 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple+=2)
2809 if(tuple[1]>=0 && tuple[1]<aNt)
2811 if(tuple[0]>=0 && tuple[0]<thisNt)
2812 std::copy(valsSrc+nbOfComp*tuple[1],valsSrc+nbOfComp*(tuple[1]+1),valsToSet+nbOfComp*tuple[0]);
2815 std::ostringstream oss; oss << "DataArrayDouble::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
2816 oss << " of 'tuplesSelec' request of tuple id #" << tuple[0] << " in 'this' ! It should be in [0," << thisNt << ") !";
2817 throw INTERP_KERNEL::Exception(oss.str().c_str());
2822 std::ostringstream oss; oss << "DataArrayDouble::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
2823 oss << " of 'tuplesSelec' request of tuple id #" << tuple[1] << " in 'a' ! It should be in [0," << aNt << ") !";
2824 throw INTERP_KERNEL::Exception(oss.str().c_str());
2830 * Copy some tuples from another DataArrayDouble (\a aBase) into contiguous tuples
2831 * of \a this array. Textual data is not copied. Both arrays must have equal number of
2833 * The tuples to assign to are defined by index of the first tuple, and
2834 * their number is defined by \a tuplesSelec->getNumberOfTuples().
2835 * The tuples to copy are defined by values of a DataArrayInt.
2836 * All components of selected tuples are copied.
2837 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
2839 * \param [in] aBase - the array to copy values from.
2840 * \param [in] tuplesSelec - the array specifying tuples of \a a to copy.
2841 * \throw If \a this is not allocated.
2842 * \throw If \a aBase is NULL.
2843 * \throw If \a aBase is not allocated.
2844 * \throw If \a tuplesSelec is NULL.
2845 * \throw If \a tuplesSelec is not allocated.
2846 * \throw If <em>this->getNumberOfComponents() != aBase->getNumberOfComponents()</em>.
2847 * \throw If \a tuplesSelec->getNumberOfComponents() != 1.
2848 * \throw If <em>tupleIdStart + tuplesSelec->getNumberOfTuples() > this->getNumberOfTuples().</em>
2849 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
2852 void DataArrayDouble::setContigPartOfSelectedValues(int tupleIdStart, const DataArray *aBase, const DataArrayInt *tuplesSelec)
2854 if(!aBase || !tuplesSelec)
2855 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : input DataArray is NULL !");
2856 const DataArrayDouble *a=dynamic_cast<const DataArrayDouble *>(aBase);
2858 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : input DataArray aBase is not a DataArrayDouble !");
2860 a->checkAllocated();
2861 tuplesSelec->checkAllocated();
2862 int nbOfComp=getNumberOfComponents();
2863 if(nbOfComp!=a->getNumberOfComponents())
2864 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : This and a do not have the same number of components !");
2865 if(tuplesSelec->getNumberOfComponents()!=1)
2866 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : Expecting to have a tuple selector DataArrayInt instance with exactly 1 component !");
2867 int thisNt=getNumberOfTuples();
2868 int aNt=a->getNumberOfTuples();
2869 int nbOfTupleToWrite=tuplesSelec->getNumberOfTuples();
2870 double *valsToSet=getPointer()+tupleIdStart*nbOfComp;
2871 if(tupleIdStart+nbOfTupleToWrite>thisNt)
2872 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : invalid number range of values to write !");
2873 const double *valsSrc=a->getConstPointer();
2874 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple++,valsToSet+=nbOfComp)
2876 if(*tuple>=0 && *tuple<aNt)
2878 std::copy(valsSrc+nbOfComp*(*tuple),valsSrc+nbOfComp*(*tuple+1),valsToSet);
2882 std::ostringstream oss; oss << "DataArrayDouble::setContigPartOfSelectedValues : Tuple #" << std::distance(tuplesSelec->begin(),tuple);
2883 oss << " of 'tuplesSelec' request of tuple id #" << *tuple << " in 'a' ! It should be in [0," << aNt << ") !";
2884 throw INTERP_KERNEL::Exception(oss.str().c_str());
2890 * Copy some tuples from another DataArrayDouble (\a aBase) into contiguous tuples
2891 * of \a this array. Textual data is not copied. Both arrays must have equal number of
2893 * The tuples to copy are defined by three values similar to parameters of
2894 * the Python function \c range(\c start,\c stop,\c step).
2895 * The tuples to assign to are defined by index of the first tuple, and
2896 * their number is defined by number of tuples to copy.
2897 * All components of selected tuples are copied.
2898 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
2900 * \param [in] aBase - the array to copy values from.
2901 * \param [in] bg - index of the first tuple to copy of the array \a aBase.
2902 * \param [in] end2 - index of the tuple of \a aBase before which the tuples to copy
2904 * \param [in] step - index increment to get index of the next tuple to copy.
2905 * \throw If \a this is not allocated.
2906 * \throw If \a aBase is NULL.
2907 * \throw If \a aBase is not allocated.
2908 * \throw If <em>this->getNumberOfComponents() != aBase->getNumberOfComponents()</em>.
2909 * \throw If <em>tupleIdStart + len(range(bg,end2,step)) > this->getNumberOfTuples().</em>
2910 * \throw If parameters specifying tuples to copy, do not give a
2911 * non-empty range of increasing indices or indices are out of a valid range
2912 * for the array \a aBase.
2914 void DataArrayDouble::setContigPartOfSelectedValues2(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step)
2917 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : input DataArray is NULL !");
2918 const DataArrayDouble *a=dynamic_cast<const DataArrayDouble *>(aBase);
2920 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : input DataArray aBase is not a DataArrayDouble !");
2922 a->checkAllocated();
2923 int nbOfComp=getNumberOfComponents();
2924 const char msg[]="DataArrayDouble::setContigPartOfSelectedValues2";
2925 int nbOfTupleToWrite=DataArray::GetNumberOfItemGivenBES(bg,end2,step,msg);
2926 if(nbOfComp!=a->getNumberOfComponents())
2927 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : This and a do not have the same number of components !");
2928 int thisNt=getNumberOfTuples();
2929 int aNt=a->getNumberOfTuples();
2930 double *valsToSet=getPointer()+tupleIdStart*nbOfComp;
2931 if(tupleIdStart+nbOfTupleToWrite>thisNt)
2932 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : invalid number range of values to write !");
2934 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : invalid range of values to read !");
2935 const double *valsSrc=a->getConstPointer()+bg*nbOfComp;
2936 for(int i=0;i<nbOfTupleToWrite;i++,valsToSet+=nbOfComp,valsSrc+=step*nbOfComp)
2938 std::copy(valsSrc,valsSrc+nbOfComp,valsToSet);
2943 * Returns a value located at specified tuple and component.
2944 * This method is equivalent to DataArrayDouble::getIJ() except that validity of
2945 * parameters is checked. So this method is safe but expensive if used to go through
2946 * all values of \a this.
2947 * \param [in] tupleId - index of tuple of interest.
2948 * \param [in] compoId - index of component of interest.
2949 * \return double - value located by \a tupleId and \a compoId.
2950 * \throw If \a this is not allocated.
2951 * \throw If condition <em>( 0 <= tupleId < this->getNumberOfTuples() )</em> is violated.
2952 * \throw If condition <em>( 0 <= compoId < this->getNumberOfComponents() )</em> is violated.
2954 double DataArrayDouble::getIJSafe(int tupleId, int compoId) const
2957 if(tupleId<0 || tupleId>=getNumberOfTuples())
2959 std::ostringstream oss; oss << "DataArrayDouble::getIJSafe : request for tupleId " << tupleId << " should be in [0," << getNumberOfTuples() << ") !";
2960 throw INTERP_KERNEL::Exception(oss.str().c_str());
2962 if(compoId<0 || compoId>=getNumberOfComponents())
2964 std::ostringstream oss; oss << "DataArrayDouble::getIJSafe : request for compoId " << compoId << " should be in [0," << getNumberOfComponents() << ") !";
2965 throw INTERP_KERNEL::Exception(oss.str().c_str());
2967 return _mem[tupleId*_info_on_compo.size()+compoId];
2971 * Returns the first value of \a this.
2972 * \return double - the last value of \a this array.
2973 * \throw If \a this is not allocated.
2974 * \throw If \a this->getNumberOfComponents() != 1.
2975 * \throw If \a this->getNumberOfTuples() < 1.
2977 double DataArrayDouble::front() const
2980 if(getNumberOfComponents()!=1)
2981 throw INTERP_KERNEL::Exception("DataArrayDouble::front : number of components not equal to one !");
2982 int nbOfTuples=getNumberOfTuples();
2984 throw INTERP_KERNEL::Exception("DataArrayDouble::front : number of tuples must be >= 1 !");
2985 return *(getConstPointer());
2989 * Returns the last value of \a this.
2990 * \return double - the last value of \a this array.
2991 * \throw If \a this is not allocated.
2992 * \throw If \a this->getNumberOfComponents() != 1.
2993 * \throw If \a this->getNumberOfTuples() < 1.
2995 double DataArrayDouble::back() const
2998 if(getNumberOfComponents()!=1)
2999 throw INTERP_KERNEL::Exception("DataArrayDouble::back : number of components not equal to one !");
3000 int nbOfTuples=getNumberOfTuples();
3002 throw INTERP_KERNEL::Exception("DataArrayDouble::back : number of tuples must be >= 1 !");
3003 return *(getConstPointer()+nbOfTuples-1);
3006 void DataArrayDouble::SetArrayIn(DataArrayDouble *newArray, DataArrayDouble* &arrayToSet)
3008 if(newArray!=arrayToSet)
3011 arrayToSet->decrRef();
3012 arrayToSet=newArray;
3014 arrayToSet->incrRef();
3019 * Sets a C array to be used as raw data of \a this. The previously set info
3020 * of components is retained and re-sized.
3021 * For more info see \ref MEDCouplingArraySteps1.
3022 * \param [in] array - the C array to be used as raw data of \a this.
3023 * \param [in] ownership - if \a true, \a array will be deallocated at destruction of \a this.
3024 * \param [in] type - specifies how to deallocate \a array. If \a type == ParaMEDMEM::CPP_DEALLOC,
3025 * \c delete [] \c array; will be called. If \a type == ParaMEDMEM::C_DEALLOC,
3026 * \c free(\c array ) will be called.
3027 * \param [in] nbOfTuple - new number of tuples in \a this.
3028 * \param [in] nbOfCompo - new number of components in \a this.
3030 void DataArrayDouble::useArray(const double *array, bool ownership, DeallocType type, int nbOfTuple, int nbOfCompo)
3032 _info_on_compo.resize(nbOfCompo);
3033 _mem.useArray(array,ownership,type,(std::size_t)nbOfTuple*nbOfCompo);
3037 void DataArrayDouble::useExternalArrayWithRWAccess(const double *array, int nbOfTuple, int nbOfCompo)
3039 _info_on_compo.resize(nbOfCompo);
3040 _mem.useExternalArrayWithRWAccess(array,(std::size_t)nbOfTuple*nbOfCompo);
3045 * Checks if 0.0 value is present in \a this array. If it is the case, an exception
3047 * \throw If zero is found in \a this array.
3049 void DataArrayDouble::checkNoNullValues() const
3051 const double *tmp=getConstPointer();
3052 std::size_t nbOfElems=getNbOfElems();
3053 const double *where=std::find(tmp,tmp+nbOfElems,0.);
3054 if(where!=tmp+nbOfElems)
3055 throw INTERP_KERNEL::Exception("A value 0.0 have been detected !");
3059 * Computes minimal and maximal value in each component. An output array is filled
3060 * with \c 2 * \a this->getNumberOfComponents() values, so the caller is to allocate
3061 * enough memory before calling this method.
3062 * \param [out] bounds - array of size at least 2 *\a this->getNumberOfComponents().
3063 * It is filled as follows:<br>
3064 * \a bounds[0] = \c min_of_component_0 <br>
3065 * \a bounds[1] = \c max_of_component_0 <br>
3066 * \a bounds[2] = \c min_of_component_1 <br>
3067 * \a bounds[3] = \c max_of_component_1 <br>
3070 void DataArrayDouble::getMinMaxPerComponent(double *bounds) const
3073 int dim=getNumberOfComponents();
3074 for (int idim=0; idim<dim; idim++)
3076 bounds[idim*2]=std::numeric_limits<double>::max();
3077 bounds[idim*2+1]=-std::numeric_limits<double>::max();
3079 const double *ptr=getConstPointer();
3080 int nbOfTuples=getNumberOfTuples();
3081 for(int i=0;i<nbOfTuples;i++)
3083 for(int idim=0;idim<dim;idim++)
3085 if(bounds[idim*2]>ptr[i*dim+idim])
3087 bounds[idim*2]=ptr[i*dim+idim];
3089 if(bounds[idim*2+1]<ptr[i*dim+idim])
3091 bounds[idim*2+1]=ptr[i*dim+idim];
3098 * This method retrieves a newly allocated DataArrayDouble instance having same number of tuples than \a this and twice number of components than \a this
3099 * to store both the min and max per component of each tuples.
3100 * \param [in] epsilon the width of the bbox (identical in each direction) - 0.0 by default
3102 * \return a newly created DataArrayDouble instance having \c this->getNumberOfTuples() tuples and 2 * \c this->getNumberOfComponent() components
3104 * \throw If \a this is not allocated yet.
3106 DataArrayDouble *DataArrayDouble::computeBBoxPerTuple(double epsilon) const
3109 const double *dataPtr=getConstPointer();
3110 int nbOfCompo=getNumberOfComponents();
3111 int nbTuples=getNumberOfTuples();
3112 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> bbox=DataArrayDouble::New();
3113 bbox->alloc(nbTuples,2*nbOfCompo);
3114 double *bboxPtr=bbox->getPointer();
3115 for(int i=0;i<nbTuples;i++)
3117 for(int j=0;j<nbOfCompo;j++)
3119 bboxPtr[2*nbOfCompo*i+2*j]=dataPtr[nbOfCompo*i+j]-epsilon;
3120 bboxPtr[2*nbOfCompo*i+2*j+1]=dataPtr[nbOfCompo*i+j]+epsilon;
3127 * For each tuples **t** in \a other, this method retrieves tuples in \a this that are equal to **t**.
3128 * Two tuples are considered equal if the euclidian distance between the two tuples is lower than \a eps.
3130 * \param [in] other a DataArrayDouble having same number of components than \a this.
3131 * \param [in] eps absolute precision representing distance (using infinite norm) between 2 tuples behind which 2 tuples are considered equal.
3132 * \param [out] c will contain the set of tuple ids in \a this that are equal to to the tuple ids in \a other contiguously.
3133 * \a cI allows to extract information in \a c.
3134 * \param [out] cI is an indirection array that allows to extract the data contained in \a c.
3136 * \throw In case of:
3137 * - \a this is not allocated
3138 * - \a other is not allocated or null
3139 * - \a this and \a other do not have the same number of components
3140 * - if number of components of \a this is not in [1,2,3]
3142 * \sa MEDCouplingPointSet::getNodeIdsNearPoints, DataArrayDouble::getDifferentValues
3144 void DataArrayDouble::computeTupleIdsNearTuples(const DataArrayDouble *other, double eps, DataArrayInt *& c, DataArrayInt *& cI) const
3147 throw INTERP_KERNEL::Exception("DataArrayDouble::computeTupleIdsNearTuples : input pointer other is null !");
3149 other->checkAllocated();
3150 int nbOfCompo=getNumberOfComponents();
3151 int otherNbOfCompo=other->getNumberOfComponents();
3152 if(nbOfCompo!=otherNbOfCompo)
3153 throw INTERP_KERNEL::Exception("DataArrayDouble::computeTupleIdsNearTuples : number of components should be equal between this and other !");
3154 int nbOfTuplesOther=other->getNumberOfTuples();
3155 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cArr(DataArrayInt::New()),cIArr(DataArrayInt::New()); cArr->alloc(0,1); cIArr->pushBackSilent(0);
3160 BBTreePts<3,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
3161 FindTupleIdsNearTuplesAlg<3>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
3166 BBTreePts<2,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
3167 FindTupleIdsNearTuplesAlg<2>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
3172 BBTreePts<1,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
3173 FindTupleIdsNearTuplesAlg<1>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
3177 throw INTERP_KERNEL::Exception("Unexpected spacedim of coords for computeTupleIdsNearTuples. Must be 1, 2 or 3.");
3179 c=cArr.retn(); cI=cIArr.retn();
3183 * This method recenter tuples in \b this in order to be centered at the origin to benefit about the advantages of maximal precision to be around the box
3184 * around origin of 'radius' 1.
3186 * \param [in] eps absolute epsilon. under that value of delta between max and min no scale is performed.
3188 void DataArrayDouble::recenterForMaxPrecision(double eps)
3191 int dim=getNumberOfComponents();
3192 std::vector<double> bounds(2*dim);
3193 getMinMaxPerComponent(&bounds[0]);
3194 for(int i=0;i<dim;i++)
3196 double delta=bounds[2*i+1]-bounds[2*i];
3197 double offset=(bounds[2*i]+bounds[2*i+1])/2.;
3199 applyLin(1./delta,-offset/delta,i);
3201 applyLin(1.,-offset,i);
3206 * Returns the maximal value and its location within \a this one-dimensional array.
3207 * \param [out] tupleId - index of the tuple holding the maximal value.
3208 * \return double - the maximal value among all values of \a this array.
3209 * \throw If \a this->getNumberOfComponents() != 1
3210 * \throw If \a this->getNumberOfTuples() < 1
3212 double DataArrayDouble::getMaxValue(int& tupleId) const
3215 if(getNumberOfComponents()!=1)
3216 throw INTERP_KERNEL::Exception("DataArrayDouble::getMaxValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before or call 'getMaxValueInArray' method !");
3217 int nbOfTuples=getNumberOfTuples();
3219 throw INTERP_KERNEL::Exception("DataArrayDouble::getMaxValue : array exists but number of tuples must be > 0 !");
3220 const double *vals=getConstPointer();
3221 const double *loc=std::max_element(vals,vals+nbOfTuples);
3222 tupleId=(int)std::distance(vals,loc);
3227 * Returns the maximal value within \a this array that is allowed to have more than
3229 * \return double - the maximal value among all values of \a this array.
3230 * \throw If \a this is not allocated.
3232 double DataArrayDouble::getMaxValueInArray() const
3235 const double *loc=std::max_element(begin(),end());
3240 * Returns the maximal value and all its locations within \a this one-dimensional array.
3241 * \param [out] tupleIds - a new instance of DataArrayInt containg indices of
3242 * tuples holding the maximal value. The caller is to delete it using
3243 * decrRef() as it is no more needed.
3244 * \return double - the maximal value among all values of \a this array.
3245 * \throw If \a this->getNumberOfComponents() != 1
3246 * \throw If \a this->getNumberOfTuples() < 1
3248 double DataArrayDouble::getMaxValue2(DataArrayInt*& tupleIds) const
3252 double ret=getMaxValue(tmp);
3253 tupleIds=getIdsInRange(ret,ret);
3258 * Returns the minimal value and its location within \a this one-dimensional array.
3259 * \param [out] tupleId - index of the tuple holding the minimal value.
3260 * \return double - the minimal value among all values of \a this array.
3261 * \throw If \a this->getNumberOfComponents() != 1
3262 * \throw If \a this->getNumberOfTuples() < 1
3264 double DataArrayDouble::getMinValue(int& tupleId) const
3267 if(getNumberOfComponents()!=1)
3268 throw INTERP_KERNEL::Exception("DataArrayDouble::getMinValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before call 'getMinValueInArray' method !");
3269 int nbOfTuples=getNumberOfTuples();
3271 throw INTERP_KERNEL::Exception("DataArrayDouble::getMinValue : array exists but number of tuples must be > 0 !");
3272 const double *vals=getConstPointer();
3273 const double *loc=std::min_element(vals,vals+nbOfTuples);
3274 tupleId=(int)std::distance(vals,loc);
3279 * Returns the minimal value within \a this array that is allowed to have more than
3281 * \return double - the minimal value among all values of \a this array.
3282 * \throw If \a this is not allocated.
3284 double DataArrayDouble::getMinValueInArray() const
3287 const double *loc=std::min_element(begin(),end());
3292 * Returns the minimal value and all its locations within \a this one-dimensional array.
3293 * \param [out] tupleIds - a new instance of DataArrayInt containg indices of
3294 * tuples holding the minimal value. The caller is to delete it using
3295 * decrRef() as it is no more needed.
3296 * \return double - the minimal value among all values of \a this array.
3297 * \throw If \a this->getNumberOfComponents() != 1
3298 * \throw If \a this->getNumberOfTuples() < 1
3300 double DataArrayDouble::getMinValue2(DataArrayInt*& tupleIds) const
3304 double ret=getMinValue(tmp);
3305 tupleIds=getIdsInRange(ret,ret);
3310 * This method returns the number of values in \a this that are equals ( within an absolute precision of \a eps ) to input parameter \a value.
3311 * This method only works for single component array.
3313 * \return a value in [ 0, \c this->getNumberOfTuples() )
3315 * \throw If \a this is not allocated
3318 int DataArrayDouble::count(double value, double eps) const
3322 if(getNumberOfComponents()!=1)
3323 throw INTERP_KERNEL::Exception("DataArrayDouble::count : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
3324 const double *vals=begin();
3325 int nbOfTuples=getNumberOfTuples();
3326 for(int i=0;i<nbOfTuples;i++,vals++)
3327 if(fabs(*vals-value)<=eps)
3333 * Returns the average value of \a this one-dimensional array.
3334 * \return double - the average value over all values of \a this array.
3335 * \throw If \a this->getNumberOfComponents() != 1
3336 * \throw If \a this->getNumberOfTuples() < 1
3338 double DataArrayDouble::getAverageValue() const
3340 if(getNumberOfComponents()!=1)
3341 throw INTERP_KERNEL::Exception("DataArrayDouble::getAverageValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
3342 int nbOfTuples=getNumberOfTuples();
3344 throw INTERP_KERNEL::Exception("DataArrayDouble::getAverageValue : array exists but number of tuples must be > 0 !");
3345 const double *vals=getConstPointer();
3346 double ret=std::accumulate(vals,vals+nbOfTuples,0.);
3347 return ret/nbOfTuples;
3351 * Returns the Euclidean norm of the vector defined by \a this array.
3352 * \return double - the value of the Euclidean norm, i.e.
3353 * the square root of the inner product of vector.
3354 * \throw If \a this is not allocated.
3356 double DataArrayDouble::norm2() const
3360 std::size_t nbOfElems=getNbOfElems();
3361 const double *pt=getConstPointer();
3362 for(std::size_t i=0;i<nbOfElems;i++,pt++)
3368 * Returns the maximum norm of the vector defined by \a this array.
3369 * This method works even if the number of components is diferent from one.
3370 * If the number of elements in \a this is 0, -1. is returned.
3371 * \return double - the value of the maximum norm, i.e.
3372 * the maximal absolute value among values of \a this array (whatever its number of components).
3373 * \throw If \a this is not allocated.
3375 double DataArrayDouble::normMax() const
3379 std::size_t nbOfElems(getNbOfElems());
3380 const double *pt(getConstPointer());
3381 for(std::size_t i=0;i<nbOfElems;i++,pt++)
3383 double val(std::abs(*pt));
3391 * Returns the minimum norm (absolute value) of the vector defined by \a this array.
3392 * This method works even if the number of components is diferent from one.
3393 * If the number of elements in \a this is 0, std::numeric_limits<double>::max() is returned.
3394 * \return double - the value of the minimum norm, i.e.
3395 * the minimal absolute value among values of \a this array (whatever its number of components).
3396 * \throw If \a this is not allocated.
3398 double DataArrayDouble::normMin() const
3401 double ret(std::numeric_limits<double>::max());
3402 std::size_t nbOfElems(getNbOfElems());
3403 const double *pt(getConstPointer());
3404 for(std::size_t i=0;i<nbOfElems;i++,pt++)
3406 double val(std::abs(*pt));
3414 * Accumulates values of each component of \a this array.
3415 * \param [out] res - an array of length \a this->getNumberOfComponents(), allocated
3416 * by the caller, that is filled by this method with sum value for each
3418 * \throw If \a this is not allocated.
3420 void DataArrayDouble::accumulate(double *res) const
3423 const double *ptr=getConstPointer();
3424 int nbTuple=getNumberOfTuples();
3425 int nbComps=getNumberOfComponents();
3426 std::fill(res,res+nbComps,0.);
3427 for(int i=0;i<nbTuple;i++)
3428 std::transform(ptr+i*nbComps,ptr+(i+1)*nbComps,res,res,std::plus<double>());
3432 * This method returns the min distance from an external tuple defined by [ \a tupleBg , \a tupleEnd ) to \a this and
3433 * the first tuple in \a this that matches the returned distance. If there is no tuples in \a this an exception will be thrown.
3436 * \a this is expected to be allocated and expected to have a number of components equal to the distance from \a tupleBg to
3437 * \a tupleEnd. If not an exception will be thrown.
3439 * \param [in] tupleBg start pointer (included) of input external tuple
3440 * \param [in] tupleEnd end pointer (not included) of input external tuple
3441 * \param [out] tupleId the tuple id in \a this that matches the min of distance between \a this and input external tuple
3442 * \return the min distance.
3443 * \sa MEDCouplingUMesh::distanceToPoint
3445 double DataArrayDouble::distanceToTuple(const double *tupleBg, const double *tupleEnd, int& tupleId) const
3448 int nbTuple=getNumberOfTuples();
3449 int nbComps=getNumberOfComponents();
3450 if(nbComps!=(int)std::distance(tupleBg,tupleEnd))
3451 { std::ostringstream oss; oss << "DataArrayDouble::distanceToTuple : size of input tuple is " << std::distance(tupleBg,tupleEnd) << " should be equal to the number of components in this : " << nbComps << " !"; throw INTERP_KERNEL::Exception(oss.str().c_str()); }
3453 throw INTERP_KERNEL::Exception("DataArrayDouble::distanceToTuple : no tuple in this ! No distance to compute !");
3454 double ret0=std::numeric_limits<double>::max();
3456 const double *work=getConstPointer();
3457 for(int i=0;i<nbTuple;i++)
3460 for(int j=0;j<nbComps;j++,work++)
3461 val+=(*work-tupleBg[j])*((*work-tupleBg[j]));
3465 { ret0=val; tupleId=i; }
3471 * Accumulate values of the given component of \a this array.
3472 * \param [in] compId - the index of the component of interest.
3473 * \return double - a sum value of \a compId-th component.
3474 * \throw If \a this is not allocated.
3475 * \throw If \a the condition ( 0 <= \a compId < \a this->getNumberOfComponents() ) is
3478 double DataArrayDouble::accumulate(int compId) const
3481 const double *ptr=getConstPointer();
3482 int nbTuple=getNumberOfTuples();
3483 int nbComps=getNumberOfComponents();
3484 if(compId<0 || compId>=nbComps)
3485 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulate : Invalid compId specified : No such nb of components !");
3487 for(int i=0;i<nbTuple;i++)
3488 ret+=ptr[i*nbComps+compId];
3493 * This method accumulate using addition tuples in \a this using input index array [ \a bgOfIndex, \a endOfIndex ).
3494 * The returned array will have same number of components than \a this and number of tuples equal to
3495 * \c std::distance(bgOfIndex,endOfIndex) \b minus \b one.
3497 * The input index array is expected to be ascendingly sorted in which the all referenced ids should be in [0, \c this->getNumberOfTuples).
3498 * This method is quite useful for users that need to put a field on cells to field on nodes on the same mesh without a need of conservation.
3500 * \param [in] bgOfIndex - begin (included) of the input index array.
3501 * \param [in] endOfIndex - end (excluded) of the input index array.
3502 * \return DataArrayDouble * - the new instance having the same number of components than \a this.
3504 * \throw If bgOfIndex or end is NULL.
3505 * \throw If input index array is not ascendingly sorted.
3506 * \throw If there is an id in [ \a bgOfIndex, \a endOfIndex ) not in [0, \c this->getNumberOfTuples).
3507 * \throw If std::distance(bgOfIndex,endOfIndex)==0.
3509 DataArrayDouble *DataArrayDouble::accumulatePerChunck(const int *bgOfIndex, const int *endOfIndex) const
3511 if(!bgOfIndex || !endOfIndex)
3512 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : input pointer NULL !");
3514 int nbCompo=getNumberOfComponents();
3515 int nbOfTuples=getNumberOfTuples();
3516 int sz=(int)std::distance(bgOfIndex,endOfIndex);
3518 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : invalid size of input index array !");
3520 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(sz,nbCompo);
3521 const int *w=bgOfIndex;
3522 if(*w<0 || *w>=nbOfTuples)
3523 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : The first element of the input index not in [0,nbOfTuples) !");
3524 const double *srcPt=begin()+(*w)*nbCompo;
3525 double *tmp=ret->getPointer();
3526 for(int i=0;i<sz;i++,tmp+=nbCompo,w++)
3528 std::fill(tmp,tmp+nbCompo,0.);
3531 for(int j=w[0];j<w[1];j++,srcPt+=nbCompo)
3533 if(j>=0 && j<nbOfTuples)
3534 std::transform(srcPt,srcPt+nbCompo,tmp,tmp,std::plus<double>());
3537 std::ostringstream oss; oss << "DataArrayDouble::accumulatePerChunck : At rank #" << i << " the input index array points to id " << j << " should be in [0," << nbOfTuples << ") !";
3538 throw INTERP_KERNEL::Exception(oss.str().c_str());
3544 std::ostringstream oss; oss << "DataArrayDouble::accumulatePerChunck : At rank #" << i << " the input index array is not in ascendingly sorted.";
3545 throw INTERP_KERNEL::Exception(oss.str().c_str());
3548 ret->copyStringInfoFrom(*this);
3553 * Converts each 2D point defined by the tuple of \a this array from the Polar to the
3554 * Cartesian coordinate system. The two components of the tuple of \a this array are
3555 * considered to contain (1) radius and (2) angle of the point in the Polar CS.
3556 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3557 * contains X and Y coordinates of the point in the Cartesian CS. The caller
3558 * is to delete this array using decrRef() as it is no more needed. The array
3559 * does not contain any textual info on components.
3560 * \throw If \a this->getNumberOfComponents() != 2.
3562 DataArrayDouble *DataArrayDouble::fromPolarToCart() const
3565 int nbOfComp=getNumberOfComponents();
3567 throw INTERP_KERNEL::Exception("DataArrayDouble::fromPolarToCart : must be an array with exactly 2 components !");
3568 int nbOfTuple=getNumberOfTuples();
3569 DataArrayDouble *ret=DataArrayDouble::New();
3570 ret->alloc(nbOfTuple,2);
3571 double *w=ret->getPointer();
3572 const double *wIn=getConstPointer();
3573 for(int i=0;i<nbOfTuple;i++,w+=2,wIn+=2)
3575 w[0]=wIn[0]*cos(wIn[1]);
3576 w[1]=wIn[0]*sin(wIn[1]);
3582 * Converts each 3D point defined by the tuple of \a this array from the Cylindrical to
3583 * the Cartesian coordinate system. The three components of the tuple of \a this array
3584 * are considered to contain (1) radius, (2) azimuth and (3) altitude of the point in
3585 * the Cylindrical CS.
3586 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3587 * contains X, Y and Z coordinates of the point in the Cartesian CS. The info
3588 * on the third component is copied from \a this array. The caller
3589 * is to delete this array using decrRef() as it is no more needed.
3590 * \throw If \a this->getNumberOfComponents() != 3.
3592 DataArrayDouble *DataArrayDouble::fromCylToCart() const
3595 int nbOfComp=getNumberOfComponents();
3597 throw INTERP_KERNEL::Exception("DataArrayDouble::fromCylToCart : must be an array with exactly 3 components !");
3598 int nbOfTuple=getNumberOfTuples();
3599 DataArrayDouble *ret=DataArrayDouble::New();
3600 ret->alloc(getNumberOfTuples(),3);
3601 double *w=ret->getPointer();
3602 const double *wIn=getConstPointer();
3603 for(int i=0;i<nbOfTuple;i++,w+=3,wIn+=3)
3605 w[0]=wIn[0]*cos(wIn[1]);
3606 w[1]=wIn[0]*sin(wIn[1]);
3609 ret->setInfoOnComponent(2,getInfoOnComponent(2));
3614 * Converts each 3D point defined by the tuple of \a this array from the Spherical to
3615 * the Cartesian coordinate system. The three components of the tuple of \a this array
3616 * are considered to contain (1) radius, (2) polar angle and (3) azimuthal angle of the
3617 * point in the Cylindrical CS.
3618 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3619 * contains X, Y and Z coordinates of the point in the Cartesian CS. The info
3620 * on the third component is copied from \a this array. The caller
3621 * is to delete this array using decrRef() as it is no more needed.
3622 * \throw If \a this->getNumberOfComponents() != 3.
3624 DataArrayDouble *DataArrayDouble::fromSpherToCart() const
3627 int nbOfComp=getNumberOfComponents();
3629 throw INTERP_KERNEL::Exception("DataArrayDouble::fromSpherToCart : must be an array with exactly 3 components !");
3630 int nbOfTuple=getNumberOfTuples();
3631 DataArrayDouble *ret=DataArrayDouble::New();
3632 ret->alloc(getNumberOfTuples(),3);
3633 double *w=ret->getPointer();
3634 const double *wIn=getConstPointer();
3635 for(int i=0;i<nbOfTuple;i++,w+=3,wIn+=3)
3637 w[0]=wIn[0]*cos(wIn[2])*sin(wIn[1]);
3638 w[1]=wIn[0]*sin(wIn[2])*sin(wIn[1]);
3639 w[2]=wIn[0]*cos(wIn[1]);
3645 * Computes the doubly contracted product of every tensor defined by the tuple of \a this
3646 * array contating 6 components.
3647 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3648 * is calculated from the tuple <em>(t)</em> of \a this array as follows:
3649 * \f$ t[0]^2+t[1]^2+t[2]^2+2*t[3]^2+2*t[4]^2+2*t[5]^2\f$.
3650 * The caller is to delete this result array using decrRef() as it is no more needed.
3651 * \throw If \a this->getNumberOfComponents() != 6.
3653 DataArrayDouble *DataArrayDouble::doublyContractedProduct() const
3656 int nbOfComp=getNumberOfComponents();
3658 throw INTERP_KERNEL::Exception("DataArrayDouble::doublyContractedProduct : must be an array with exactly 6 components !");
3659 DataArrayDouble *ret=DataArrayDouble::New();
3660 int nbOfTuple=getNumberOfTuples();
3661 ret->alloc(nbOfTuple,1);
3662 const double *src=getConstPointer();
3663 double *dest=ret->getPointer();
3664 for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
3665 *dest=src[0]*src[0]+src[1]*src[1]+src[2]*src[2]+2.*src[3]*src[3]+2.*src[4]*src[4]+2.*src[5]*src[5];
3670 * Computes the determinant of every square matrix defined by the tuple of \a this
3671 * array, which contains either 4, 6 or 9 components. The case of 6 components
3672 * corresponds to that of the upper triangular matrix.
3673 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3674 * is the determinant of matrix of the corresponding tuple of \a this array.
3675 * The caller is to delete this result array using decrRef() as it is no more
3677 * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
3679 DataArrayDouble *DataArrayDouble::determinant() const
3682 DataArrayDouble *ret=DataArrayDouble::New();
3683 int nbOfTuple=getNumberOfTuples();
3684 ret->alloc(nbOfTuple,1);
3685 const double *src=getConstPointer();
3686 double *dest=ret->getPointer();
3687 switch(getNumberOfComponents())
3690 for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
3691 *dest=src[0]*src[1]*src[2]+2.*src[4]*src[5]*src[3]-src[0]*src[4]*src[4]-src[2]*src[3]*src[3]-src[1]*src[5]*src[5];
3694 for(int i=0;i<nbOfTuple;i++,dest++,src+=4)
3695 *dest=src[0]*src[3]-src[1]*src[2];
3698 for(int i=0;i<nbOfTuple;i++,dest++,src+=9)
3699 *dest=src[0]*src[4]*src[8]+src[1]*src[5]*src[6]+src[2]*src[3]*src[7]-src[0]*src[5]*src[7]-src[1]*src[3]*src[8]-src[2]*src[4]*src[6];
3703 throw INTERP_KERNEL::Exception("DataArrayDouble::determinant : Invalid number of components ! must be in 4,6,9 !");
3708 * Computes 3 eigenvalues of every upper triangular matrix defined by the tuple of
3709 * \a this array, which contains 6 components.
3710 * \return DataArrayDouble * - the new instance of DataArrayDouble containing 3
3711 * components, whose each tuple contains the eigenvalues of the matrix of
3712 * corresponding tuple of \a this array.
3713 * The caller is to delete this result array using decrRef() as it is no more
3715 * \throw If \a this->getNumberOfComponents() != 6.
3717 DataArrayDouble *DataArrayDouble::eigenValues() const
3720 int nbOfComp=getNumberOfComponents();
3722 throw INTERP_KERNEL::Exception("DataArrayDouble::eigenValues : must be an array with exactly 6 components !");
3723 DataArrayDouble *ret=DataArrayDouble::New();
3724 int nbOfTuple=getNumberOfTuples();
3725 ret->alloc(nbOfTuple,3);
3726 const double *src=getConstPointer();
3727 double *dest=ret->getPointer();
3728 for(int i=0;i<nbOfTuple;i++,dest+=3,src+=6)
3729 INTERP_KERNEL::computeEigenValues6(src,dest);
3734 * Computes 3 eigenvectors of every upper triangular matrix defined by the tuple of
3735 * \a this array, which contains 6 components.
3736 * \return DataArrayDouble * - the new instance of DataArrayDouble containing 9
3737 * components, whose each tuple contains 3 eigenvectors of the matrix of
3738 * corresponding tuple of \a this array.
3739 * The caller is to delete this result array using decrRef() as it is no more
3741 * \throw If \a this->getNumberOfComponents() != 6.
3743 DataArrayDouble *DataArrayDouble::eigenVectors() const
3746 int nbOfComp=getNumberOfComponents();
3748 throw INTERP_KERNEL::Exception("DataArrayDouble::eigenVectors : must be an array with exactly 6 components !");
3749 DataArrayDouble *ret=DataArrayDouble::New();
3750 int nbOfTuple=getNumberOfTuples();
3751 ret->alloc(nbOfTuple,9);
3752 const double *src=getConstPointer();
3753 double *dest=ret->getPointer();
3754 for(int i=0;i<nbOfTuple;i++,src+=6)
3757 INTERP_KERNEL::computeEigenValues6(src,tmp);
3758 for(int j=0;j<3;j++,dest+=3)
3759 INTERP_KERNEL::computeEigenVectorForEigenValue6(src,tmp[j],1e-12,dest);
3765 * Computes the inverse matrix of every matrix defined by the tuple of \a this
3766 * array, which contains either 4, 6 or 9 components. The case of 6 components
3767 * corresponds to that of the upper triangular matrix.
3768 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3769 * same number of components as \a this one, whose each tuple is the inverse
3770 * matrix of the matrix of corresponding tuple of \a this array.
3771 * The caller is to delete this result array using decrRef() as it is no more
3773 * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
3775 DataArrayDouble *DataArrayDouble::inverse() const
3778 int nbOfComp=getNumberOfComponents();
3779 if(nbOfComp!=6 && nbOfComp!=9 && nbOfComp!=4)
3780 throw INTERP_KERNEL::Exception("DataArrayDouble::inversion : must be an array with 4,6 or 9 components !");
3781 DataArrayDouble *ret=DataArrayDouble::New();
3782 int nbOfTuple=getNumberOfTuples();
3783 ret->alloc(nbOfTuple,nbOfComp);
3784 const double *src=getConstPointer();
3785 double *dest=ret->getPointer();
3787 for(int i=0;i<nbOfTuple;i++,dest+=6,src+=6)
3789 double det=src[0]*src[1]*src[2]+2.*src[4]*src[5]*src[3]-src[0]*src[4]*src[4]-src[2]*src[3]*src[3]-src[1]*src[5]*src[5];
3790 dest[0]=(src[1]*src[2]-src[4]*src[4])/det;
3791 dest[1]=(src[0]*src[2]-src[5]*src[5])/det;
3792 dest[2]=(src[0]*src[1]-src[3]*src[3])/det;
3793 dest[3]=(src[5]*src[4]-src[3]*src[2])/det;
3794 dest[4]=(src[5]*src[3]-src[0]*src[4])/det;
3795 dest[5]=(src[3]*src[4]-src[1]*src[5])/det;
3797 else if(nbOfComp==4)
3798 for(int i=0;i<nbOfTuple;i++,dest+=4,src+=4)
3800 double det=src[0]*src[3]-src[1]*src[2];
3802 dest[1]=-src[1]/det;
3803 dest[2]=-src[2]/det;
3807 for(int i=0;i<nbOfTuple;i++,dest+=9,src+=9)
3809 double det=src[0]*src[4]*src[8]+src[1]*src[5]*src[6]+src[2]*src[3]*src[7]-src[0]*src[5]*src[7]-src[1]*src[3]*src[8]-src[2]*src[4]*src[6];
3810 dest[0]=(src[4]*src[8]-src[7]*src[5])/det;
3811 dest[1]=(src[7]*src[2]-src[1]*src[8])/det;
3812 dest[2]=(src[1]*src[5]-src[4]*src[2])/det;
3813 dest[3]=(src[6]*src[5]-src[3]*src[8])/det;
3814 dest[4]=(src[0]*src[8]-src[6]*src[2])/det;
3815 dest[5]=(src[2]*src[3]-src[0]*src[5])/det;
3816 dest[6]=(src[3]*src[7]-src[6]*src[4])/det;
3817 dest[7]=(src[6]*src[1]-src[0]*src[7])/det;
3818 dest[8]=(src[0]*src[4]-src[1]*src[3])/det;
3824 * Computes the trace of every matrix defined by the tuple of \a this
3825 * array, which contains either 4, 6 or 9 components. The case of 6 components
3826 * corresponds to that of the upper triangular matrix.
3827 * \return DataArrayDouble * - the new instance of DataArrayDouble containing
3828 * 1 component, whose each tuple is the trace of
3829 * the matrix of corresponding tuple of \a this array.
3830 * The caller is to delete this result array using decrRef() as it is no more
3832 * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
3834 DataArrayDouble *DataArrayDouble::trace() const
3837 int nbOfComp=getNumberOfComponents();
3838 if(nbOfComp!=6 && nbOfComp!=9 && nbOfComp!=4)
3839 throw INTERP_KERNEL::Exception("DataArrayDouble::trace : must be an array with 4,6 or 9 components !");
3840 DataArrayDouble *ret=DataArrayDouble::New();
3841 int nbOfTuple=getNumberOfTuples();
3842 ret->alloc(nbOfTuple,1);
3843 const double *src=getConstPointer();
3844 double *dest=ret->getPointer();
3846 for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
3847 *dest=src[0]+src[1]+src[2];
3848 else if(nbOfComp==4)
3849 for(int i=0;i<nbOfTuple;i++,dest++,src+=4)
3850 *dest=src[0]+src[3];
3852 for(int i=0;i<nbOfTuple;i++,dest++,src+=9)
3853 *dest=src[0]+src[4]+src[8];
3858 * Computes the stress deviator tensor of every stress tensor defined by the tuple of
3859 * \a this array, which contains 6 components.
3860 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3861 * same number of components and tuples as \a this array.
3862 * The caller is to delete this result array using decrRef() as it is no more
3864 * \throw If \a this->getNumberOfComponents() != 6.
3866 DataArrayDouble *DataArrayDouble::deviator() const
3869 int nbOfComp=getNumberOfComponents();
3871 throw INTERP_KERNEL::Exception("DataArrayDouble::deviator : must be an array with exactly 6 components !");
3872 DataArrayDouble *ret=DataArrayDouble::New();
3873 int nbOfTuple=getNumberOfTuples();
3874 ret->alloc(nbOfTuple,6);
3875 const double *src=getConstPointer();
3876 double *dest=ret->getPointer();
3877 for(int i=0;i<nbOfTuple;i++,dest+=6,src+=6)
3879 double tr=(src[0]+src[1]+src[2])/3.;
3891 * Computes the magnitude of every vector defined by the tuple of
3893 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3894 * same number of tuples as \a this array and one component.
3895 * The caller is to delete this result array using decrRef() as it is no more
3897 * \throw If \a this is not allocated.
3899 DataArrayDouble *DataArrayDouble::magnitude() const
3902 int nbOfComp=getNumberOfComponents();
3903 DataArrayDouble *ret=DataArrayDouble::New();
3904 int nbOfTuple=getNumberOfTuples();
3905 ret->alloc(nbOfTuple,1);
3906 const double *src=getConstPointer();
3907 double *dest=ret->getPointer();
3908 for(int i=0;i<nbOfTuple;i++,dest++)
3911 for(int j=0;j<nbOfComp;j++,src++)
3919 * Computes for each tuple the sum of number of components values in the tuple and return it.
3921 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3922 * same number of tuples as \a this array and one component.
3923 * The caller is to delete this result array using decrRef() as it is no more
3925 * \throw If \a this is not allocated.
3927 DataArrayDouble *DataArrayDouble::sumPerTuple() const
3930 int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
3931 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret(DataArrayDouble::New());
3932 ret->alloc(nbOfTuple,1);
3933 const double *src(getConstPointer());
3934 double *dest(ret->getPointer());
3935 for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
3936 *dest=std::accumulate(src,src+nbOfComp,0.);
3941 * Computes the maximal value within every tuple of \a this array.
3942 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3943 * same number of tuples as \a this array and one component.
3944 * The caller is to delete this result array using decrRef() as it is no more
3946 * \throw If \a this is not allocated.
3947 * \sa DataArrayDouble::maxPerTupleWithCompoId
3949 DataArrayDouble *DataArrayDouble::maxPerTuple() const
3952 int nbOfComp=getNumberOfComponents();
3953 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
3954 int nbOfTuple=getNumberOfTuples();
3955 ret->alloc(nbOfTuple,1);
3956 const double *src=getConstPointer();
3957 double *dest=ret->getPointer();
3958 for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
3959 *dest=*std::max_element(src,src+nbOfComp);
3964 * Computes the maximal value within every tuple of \a this array and it returns the first component
3965 * id for each tuple that corresponds to the maximal value within the tuple.
3967 * \param [out] compoIdOfMaxPerTuple - the new new instance of DataArrayInt containing the
3968 * same number of tuples and only one component.
3969 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3970 * same number of tuples as \a this array and one component.
3971 * The caller is to delete this result array using decrRef() as it is no more
3973 * \throw If \a this is not allocated.
3974 * \sa DataArrayDouble::maxPerTuple
3976 DataArrayDouble *DataArrayDouble::maxPerTupleWithCompoId(DataArrayInt* &compoIdOfMaxPerTuple) const
3979 int nbOfComp=getNumberOfComponents();
3980 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret0=DataArrayDouble::New();
3981 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New();
3982 int nbOfTuple=getNumberOfTuples();
3983 ret0->alloc(nbOfTuple,1); ret1->alloc(nbOfTuple,1);
3984 const double *src=getConstPointer();
3985 double *dest=ret0->getPointer(); int *dest1=ret1->getPointer();
3986 for(int i=0;i<nbOfTuple;i++,dest++,dest1++,src+=nbOfComp)
3988 const double *loc=std::max_element(src,src+nbOfComp);
3990 *dest1=(int)std::distance(src,loc);
3992 compoIdOfMaxPerTuple=ret1.retn();
3997 * This method returns a newly allocated DataArrayDouble instance having one component and \c this->getNumberOfTuples() * \c this->getNumberOfTuples() tuples.
3998 * \n This returned array contains the euclidian distance for each tuple in \a this.
3999 * \n So the returned array can be seen as a dense symmetrical matrix whose diagonal elements are equal to 0.
4000 * \n The returned array has only one component (and **not** \c this->getNumberOfTuples() components to avoid the useless memory consumption due to components info in returned DataArrayDouble)
4002 * \warning use this method with care because it can leads to big amount of consumed memory !
4004 * \return A newly allocated (huge) ParaMEDMEM::DataArrayDouble instance that the caller should deal with.
4006 * \throw If \a this is not allocated.
4008 * \sa DataArrayDouble::buildEuclidianDistanceDenseMatrixWith
4010 DataArrayDouble *DataArrayDouble::buildEuclidianDistanceDenseMatrix() const
4013 int nbOfComp=getNumberOfComponents();
4014 int nbOfTuples=getNumberOfTuples();
4015 const double *inData=getConstPointer();
4016 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
4017 ret->alloc(nbOfTuples*nbOfTuples,1);
4018 double *outData=ret->getPointer();
4019 for(int i=0;i<nbOfTuples;i++)
4021 outData[i*nbOfTuples+i]=0.;
4022 for(int j=i+1;j<nbOfTuples;j++)
4025 for(int k=0;k<nbOfComp;k++)
4026 { double delta=inData[i*nbOfComp+k]-inData[j*nbOfComp+k]; dist+=delta*delta; }
4028 outData[i*nbOfTuples+j]=dist;
4029 outData[j*nbOfTuples+i]=dist;
4036 * This method returns a newly allocated DataArrayDouble instance having one component and \c this->getNumberOfTuples() * \c other->getNumberOfTuples() tuples.
4037 * \n This returned array contains the euclidian distance for each tuple in \a other with each tuple in \a this.
4038 * \n So the returned array can be seen as a dense rectangular matrix with \c other->getNumberOfTuples() rows and \c this->getNumberOfTuples() columns.
4039 * \n Output rectangular matrix is sorted along rows.
4040 * \n The returned array has only one component (and **not** \c this->getNumberOfTuples() components to avoid the useless memory consumption due to components info in returned DataArrayDouble)
4042 * \warning use this method with care because it can leads to big amount of consumed memory !
4044 * \param [in] other DataArrayDouble instance having same number of components than \a this.
4045 * \return A newly allocated (huge) ParaMEDMEM::DataArrayDouble instance that the caller should deal with.
4047 * \throw If \a this is not allocated, or if \a other is null or if \a other is not allocated, or if number of components of \a other and \a this differs.
4049 * \sa DataArrayDouble::buildEuclidianDistanceDenseMatrix
4051 DataArrayDouble *DataArrayDouble::buildEuclidianDistanceDenseMatrixWith(const DataArrayDouble *other) const
4054 throw INTERP_KERNEL::Exception("DataArrayDouble::buildEuclidianDistanceDenseMatrixWith : input parameter is null !");
4056 other->checkAllocated();
4057 int nbOfComp=getNumberOfComponents();
4058 int otherNbOfComp=other->getNumberOfComponents();
4059 if(nbOfComp!=otherNbOfComp)
4061 std::ostringstream oss; oss << "DataArrayDouble::buildEuclidianDistanceDenseMatrixWith : this nb of compo=" << nbOfComp << " and other nb of compo=" << otherNbOfComp << ". It should match !";
4062 throw INTERP_KERNEL::Exception(oss.str().c_str());
4064 int nbOfTuples=getNumberOfTuples();
4065 int otherNbOfTuples=other->getNumberOfTuples();
4066 const double *inData=getConstPointer();
4067 const double *inDataOther=other->getConstPointer();
4068 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
4069 ret->alloc(otherNbOfTuples*nbOfTuples,1);
4070 double *outData=ret->getPointer();
4071 for(int i=0;i<otherNbOfTuples;i++,inDataOther+=nbOfComp)
4073 for(int j=0;j<nbOfTuples;j++)
4076 for(int k=0;k<nbOfComp;k++)
4077 { double delta=inDataOther[k]-inData[j*nbOfComp+k]; dist+=delta*delta; }
4079 outData[i*nbOfTuples+j]=dist;
4086 * Sorts value within every tuple of \a this array.
4087 * \param [in] asc - if \a true, the values are sorted in ascending order, else,
4088 * in descending order.
4089 * \throw If \a this is not allocated.
4091 void DataArrayDouble::sortPerTuple(bool asc)
4094 double *pt=getPointer();
4095 int nbOfTuple=getNumberOfTuples();
4096 int nbOfComp=getNumberOfComponents();
4098 for(int i=0;i<nbOfTuple;i++,pt+=nbOfComp)
4099 std::sort(pt,pt+nbOfComp);
4101 for(int i=0;i<nbOfTuple;i++,pt+=nbOfComp)
4102 std::sort(pt,pt+nbOfComp,std::greater<double>());
4107 * Converts every value of \a this array to its absolute value.
4108 * \b WARNING this method is non const. If a new DataArrayDouble instance should be built containing the result of abs DataArrayDouble::computeAbs
4109 * should be called instead.
4111 * \throw If \a this is not allocated.
4112 * \sa DataArrayDouble::computeAbs
4114 void DataArrayDouble::abs()
4117 double *ptr(getPointer());
4118 std::size_t nbOfElems(getNbOfElems());
4119 std::transform(ptr,ptr+nbOfElems,ptr,std::ptr_fun<double,double>(fabs));
4124 * This method builds a new instance of \a this object containing the result of std::abs applied of all elements in \a this.
4125 * This method is a const method (that do not change any values in \a this) contrary to DataArrayDouble::abs method.
4127 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4128 * same number of tuples and component as \a this array.
4129 * The caller is to delete this result array using decrRef() as it is no more
4131 * \throw If \a this is not allocated.
4132 * \sa DataArrayDouble::abs
4134 DataArrayDouble *DataArrayDouble::computeAbs() const
4137 DataArrayDouble *newArr(DataArrayDouble::New());
4138 int nbOfTuples(getNumberOfTuples());
4139 int nbOfComp(getNumberOfComponents());
4140 newArr->alloc(nbOfTuples,nbOfComp);
4141 std::transform(begin(),end(),newArr->getPointer(),std::ptr_fun<double,double>(fabs));
4142 newArr->copyStringInfoFrom(*this);
4147 * Apply a linear function to a given component of \a this array, so that
4148 * an array element <em>(x)</em> becomes \f$ a * x + b \f$.
4149 * \param [in] a - the first coefficient of the function.
4150 * \param [in] b - the second coefficient of the function.
4151 * \param [in] compoId - the index of component to modify.
4152 * \throw If \a this is not allocated, or \a compoId is not in [0,\c this->getNumberOfComponents() ).
4154 void DataArrayDouble::applyLin(double a, double b, int compoId)
4157 double *ptr(getPointer()+compoId);
4158 int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
4159 if(compoId<0 || compoId>=nbOfComp)
4161 std::ostringstream oss; oss << "DataArrayDouble::applyLin : The compoId requested (" << compoId << ") is not valid ! Must be in [0," << nbOfComp << ") !";
4162 throw INTERP_KERNEL::Exception(oss.str().c_str());
4164 for(int i=0;i<nbOfTuple;i++,ptr+=nbOfComp)
4170 * Apply a linear function to all elements of \a this array, so that
4171 * an element _x_ becomes \f$ a * x + b \f$.
4172 * \param [in] a - the first coefficient of the function.
4173 * \param [in] b - the second coefficient of the function.
4174 * \throw If \a this is not allocated.
4176 void DataArrayDouble::applyLin(double a, double b)
4179 double *ptr=getPointer();
4180 std::size_t nbOfElems=getNbOfElems();
4181 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4187 * Modify all elements of \a this array, so that
4188 * an element _x_ becomes \f$ numerator / x \f$.
4189 * \warning If an exception is thrown because of presence of 0.0 element in \a this
4190 * array, all elements processed before detection of the zero element remain
4192 * \param [in] numerator - the numerator used to modify array elements.
4193 * \throw If \a this is not allocated.
4194 * \throw If there is an element equal to 0.0 in \a this array.
4196 void DataArrayDouble::applyInv(double numerator)
4199 double *ptr=getPointer();
4200 std::size_t nbOfElems=getNbOfElems();
4201 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4203 if(std::abs(*ptr)>std::numeric_limits<double>::min())
4205 *ptr=numerator/(*ptr);
4209 std::ostringstream oss; oss << "DataArrayDouble::applyInv : presence of null value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
4211 throw INTERP_KERNEL::Exception(oss.str().c_str());
4218 * Returns a full copy of \a this array except that sign of all elements is reversed.
4219 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4220 * same number of tuples and component as \a this array.
4221 * The caller is to delete this result array using decrRef() as it is no more
4223 * \throw If \a this is not allocated.
4225 DataArrayDouble *DataArrayDouble::negate() const
4228 DataArrayDouble *newArr=DataArrayDouble::New();
4229 int nbOfTuples=getNumberOfTuples();
4230 int nbOfComp=getNumberOfComponents();
4231 newArr->alloc(nbOfTuples,nbOfComp);
4232 const double *cptr=getConstPointer();
4233 std::transform(cptr,cptr+nbOfTuples*nbOfComp,newArr->getPointer(),std::negate<double>());
4234 newArr->copyStringInfoFrom(*this);
4239 * Modify all elements of \a this array, so that
4240 * an element _x_ becomes <em> val ^ x </em>. Contrary to DataArrayInt::applyPow
4241 * all values in \a this have to be >= 0 if val is \b not integer.
4242 * \param [in] val - the value used to apply pow on all array elements.
4243 * \throw If \a this is not allocated.
4244 * \warning If an exception is thrown because of presence of 0 element in \a this
4245 * array and \a val is \b not integer, all elements processed before detection of the zero element remain
4248 void DataArrayDouble::applyPow(double val)
4251 double *ptr=getPointer();
4252 std::size_t nbOfElems=getNbOfElems();
4254 bool isInt=((double)val2)==val;
4257 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4263 std::ostringstream oss; oss << "DataArrayDouble::applyPow (double) : At elem # " << i << " value is " << *ptr << " ! must be >=0. !";
4264 throw INTERP_KERNEL::Exception(oss.str().c_str());
4270 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4271 *ptr=pow(*ptr,val2);
4277 * Modify all elements of \a this array, so that
4278 * an element _x_ becomes \f$ val ^ x \f$.
4279 * \param [in] val - the value used to apply pow on all array elements.
4280 * \throw If \a this is not allocated.
4281 * \throw If \a val < 0.
4282 * \warning If an exception is thrown because of presence of 0 element in \a this
4283 * array, all elements processed before detection of the zero element remain
4286 void DataArrayDouble::applyRPow(double val)
4290 throw INTERP_KERNEL::Exception("DataArrayDouble::applyRPow : the input value has to be >= 0 !");
4291 double *ptr=getPointer();
4292 std::size_t nbOfElems=getNbOfElems();
4293 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4299 * Returns a new DataArrayDouble created from \a this one by applying \a
4300 * FunctionToEvaluate to every tuple of \a this array. Textual data is not copied.
4301 * For more info see \ref MEDCouplingArrayApplyFunc
4302 * \param [in] nbOfComp - number of components in the result array.
4303 * \param [in] func - the \a FunctionToEvaluate declared as
4304 * \c bool (*\a func)(\c const \c double *\a pos, \c double *\a res),
4305 * where \a pos points to the first component of a tuple of \a this array
4306 * and \a res points to the first component of a tuple of the result array.
4307 * Note that length (number of components) of \a pos can differ from
4309 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4310 * same number of tuples as \a this array.
4311 * The caller is to delete this result array using decrRef() as it is no more
4313 * \throw If \a this is not allocated.
4314 * \throw If \a func returns \a false.
4316 DataArrayDouble *DataArrayDouble::applyFunc(int nbOfComp, FunctionToEvaluate func) const
4319 DataArrayDouble *newArr=DataArrayDouble::New();
4320 int nbOfTuples=getNumberOfTuples();
4321 int oldNbOfComp=getNumberOfComponents();
4322 newArr->alloc(nbOfTuples,nbOfComp);
4323 const double *ptr=getConstPointer();
4324 double *ptrToFill=newArr->getPointer();
4325 for(int i=0;i<nbOfTuples;i++)
4327 if(!func(ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp))
4329 std::ostringstream oss; oss << "For tuple # " << i << " with value (";
4330 std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
4331 oss << ") : Evaluation of function failed !";
4333 throw INTERP_KERNEL::Exception(oss.str().c_str());
4340 * Returns a new DataArrayDouble created from \a this one by applying a function to every
4341 * tuple of \a this array. Textual data is not copied.
4342 * For more info see \ref MEDCouplingArrayApplyFunc1.
4343 * \param [in] nbOfComp - number of components in the result array.
4344 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4345 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4346 * \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
4347 * If false the computation is carried on without any notification. When false the evaluation is a little faster.
4348 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4349 * same number of tuples as \a this array and \a nbOfComp components.
4350 * The caller is to delete this result array using decrRef() as it is no more
4352 * \throw If \a this is not allocated.
4353 * \throw If computing \a func fails.
4355 DataArrayDouble *DataArrayDouble::applyFunc(int nbOfComp, const std::string& func, bool isSafe) const
4357 INTERP_KERNEL::ExprParser expr(func);
4359 std::set<std::string> vars;
4360 expr.getTrueSetOfVars(vars);
4361 std::vector<std::string> varsV(vars.begin(),vars.end());
4362 return applyFunc3(nbOfComp,varsV,func,isSafe);
4366 * Returns a new DataArrayDouble created from \a this one by applying a function to every
4367 * tuple of \a this array. Textual data is not copied. This method works by tuples (whatever its size).
4368 * If \a this is a one component array, call applyFuncOnThis instead that performs the same work faster.
4370 * For more info see \ref MEDCouplingArrayApplyFunc0.
4371 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4372 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4373 * \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
4374 * If false the computation is carried on without any notification. When false the evaluation is a little faster.
4375 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4376 * same number of tuples and components as \a this array.
4377 * The caller is to delete this result array using decrRef() as it is no more
4379 * \sa applyFuncOnThis
4380 * \throw If \a this is not allocated.
4381 * \throw If computing \a func fails.
4383 DataArrayDouble *DataArrayDouble::applyFunc(const std::string& func, bool isSafe) const
4385 int nbOfComp(getNumberOfComponents());
4387 throw INTERP_KERNEL::Exception("DataArrayDouble::applyFunc : output number of component must be > 0 !");
4389 int nbOfTuples(getNumberOfTuples());
4390 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> newArr(DataArrayDouble::New());
4391 newArr->alloc(nbOfTuples,nbOfComp);
4392 INTERP_KERNEL::ExprParser expr(func);
4394 std::set<std::string> vars;
4395 expr.getTrueSetOfVars(vars);
4396 if((int)vars.size()>1)
4398 std::ostringstream oss; oss << "DataArrayDouble::applyFunc : this method works only with at most one var func expression ! If you need to map comps on variables please use applyFunc2 or applyFunc3 instead ! Vars in expr are : ";
4399 std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
4400 throw INTERP_KERNEL::Exception(oss.str().c_str());
4404 expr.prepareFastEvaluator();
4405 newArr->rearrange(1);
4406 newArr->fillWithValue(expr.evaluateDouble());
4407 newArr->rearrange(nbOfComp);
4408 return newArr.retn();
4410 std::vector<std::string> vars2(vars.begin(),vars.end());
4411 double buff,*ptrToFill(newArr->getPointer());
4412 const double *ptr(begin());
4413 std::vector<double> stck;
4414 expr.prepareExprEvaluationDouble(vars2,1,1,0,&buff,&buff+1);
4415 expr.prepareFastEvaluator();
4418 for(int i=0;i<nbOfTuples;i++)
4420 for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
4423 expr.evaluateDoubleInternal(stck);
4424 *ptrToFill=stck.back();
4431 for(int i=0;i<nbOfTuples;i++)
4433 for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
4438 expr.evaluateDoubleInternalSafe(stck);
4440 catch(INTERP_KERNEL::Exception& e)
4442 std::ostringstream oss; oss << "For tuple # " << i << " component # " << iComp << " with value (";
4444 oss << ") : Evaluation of function failed !" << e.what();
4445 throw INTERP_KERNEL::Exception(oss.str().c_str());
4447 *ptrToFill=stck.back();
4452 return newArr.retn();
4456 * This method is a non const method that modify the array in \a this.
4457 * This method only works on one component array. It means that function \a func must
4458 * contain at most one variable.
4459 * This method is a specialization of applyFunc method with one parameter on one component array.
4461 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4462 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4463 * \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
4464 * If false the computation is carried on without any notification. When false the evaluation is a little faster.
4468 void DataArrayDouble::applyFuncOnThis(const std::string& func, bool isSafe)
4470 int nbOfComp(getNumberOfComponents());
4472 throw INTERP_KERNEL::Exception("DataArrayDouble::applyFuncOnThis : output number of component must be > 0 !");
4474 int nbOfTuples(getNumberOfTuples());
4475 INTERP_KERNEL::ExprParser expr(func);
4477 std::set<std::string> vars;
4478 expr.getTrueSetOfVars(vars);
4479 if((int)vars.size()>1)
4481 std::ostringstream oss; oss << "DataArrayDouble::applyFuncOnThis : this method works only with at most one var func expression ! If you need to map comps on variables please use applyFunc2 or applyFunc3 instead ! Vars in expr are : ";
4482 std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
4483 throw INTERP_KERNEL::Exception(oss.str().c_str());
4487 expr.prepareFastEvaluator();
4488 std::vector<std::string> compInfo(getInfoOnComponents());
4490 fillWithValue(expr.evaluateDouble());
4491 rearrange(nbOfComp);
4492 setInfoOnComponents(compInfo);
4495 std::vector<std::string> vars2(vars.begin(),vars.end());
4496 double buff,*ptrToFill(getPointer());
4497 const double *ptr(begin());
4498 std::vector<double> stck;
4499 expr.prepareExprEvaluationDouble(vars2,1,1,0,&buff,&buff+1);
4500 expr.prepareFastEvaluator();
4503 for(int i=0;i<nbOfTuples;i++)
4505 for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
4508 expr.evaluateDoubleInternal(stck);
4509 *ptrToFill=stck.back();
4516 for(int i=0;i<nbOfTuples;i++)
4518 for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
4523 expr.evaluateDoubleInternalSafe(stck);
4525 catch(INTERP_KERNEL::Exception& e)
4527 std::ostringstream oss; oss << "For tuple # " << i << " component # " << iComp << " with value (";
4529 oss << ") : Evaluation of function failed !" << e.what();
4530 throw INTERP_KERNEL::Exception(oss.str().c_str());
4532 *ptrToFill=stck.back();
4540 * Returns a new DataArrayDouble created from \a this one by applying a function to every
4541 * tuple of \a this array. Textual data is not copied.
4542 * For more info see \ref MEDCouplingArrayApplyFunc2.
4543 * \param [in] nbOfComp - number of components in the result array.
4544 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4545 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4546 * \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
4547 * If false the computation is carried on without any notification. When false the evaluation is a little faster.
4548 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4549 * same number of tuples as \a this array.
4550 * The caller is to delete this result array using decrRef() as it is no more
4552 * \throw If \a this is not allocated.
4553 * \throw If \a func contains vars that are not in \a this->getInfoOnComponent().
4554 * \throw If computing \a func fails.
4556 DataArrayDouble *DataArrayDouble::applyFunc2(int nbOfComp, const std::string& func, bool isSafe) const
4558 return applyFunc3(nbOfComp,getVarsOnComponent(),func,isSafe);
4562 * Returns a new DataArrayDouble created from \a this one by applying a function to every
4563 * tuple of \a this array. Textual data is not copied.
4564 * For more info see \ref MEDCouplingArrayApplyFunc3.
4565 * \param [in] nbOfComp - number of components in the result array.
4566 * \param [in] varsOrder - sequence of vars defining their order.
4567 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4568 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4569 * \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
4570 * If false the computation is carried on without any notification. When false the evaluation is a little faster.
4571 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4572 * same number of tuples as \a this array.
4573 * The caller is to delete this result array using decrRef() as it is no more
4575 * \throw If \a this is not allocated.
4576 * \throw If \a func contains vars not in \a varsOrder.
4577 * \throw If computing \a func fails.
4579 DataArrayDouble *DataArrayDouble::applyFunc3(int nbOfComp, const std::vector<std::string>& varsOrder, const std::string& func, bool isSafe) const
4582 throw INTERP_KERNEL::Exception("DataArrayDouble::applyFunc3 : output number of component must be > 0 !");
4583 std::vector<std::string> varsOrder2(varsOrder);
4584 int oldNbOfComp(getNumberOfComponents());
4585 for(int i=(int)varsOrder.size();i<oldNbOfComp;i++)
4586 varsOrder2.push_back(std::string());
4588 int nbOfTuples(getNumberOfTuples());
4589 INTERP_KERNEL::ExprParser expr(func);
4591 std::set<std::string> vars;
4592 expr.getTrueSetOfVars(vars);
4593 if((int)vars.size()>oldNbOfComp)
4595 std::ostringstream oss; oss << "The field has " << oldNbOfComp << " components and there are ";
4596 oss << vars.size() << " variables : ";
4597 std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
4598 throw INTERP_KERNEL::Exception(oss.str().c_str());
4600 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> newArr(DataArrayDouble::New());
4601 newArr->alloc(nbOfTuples,nbOfComp);
4602 INTERP_KERNEL::AutoPtr<double> buff(new double[oldNbOfComp]);
4603 double *buffPtr(buff),*ptrToFill;
4604 std::vector<double> stck;
4605 for(int iComp=0;iComp<nbOfComp;iComp++)
4607 expr.prepareExprEvaluationDouble(varsOrder2,oldNbOfComp,nbOfComp,iComp,buffPtr,buffPtr+oldNbOfComp);
4608 expr.prepareFastEvaluator();
4609 const double *ptr(getConstPointer());
4610 ptrToFill=newArr->getPointer()+iComp;
4613 for(int i=0;i<nbOfTuples;i++,ptrToFill+=nbOfComp,ptr+=oldNbOfComp)
4615 std::copy(ptr,ptr+oldNbOfComp,buffPtr);
4616 expr.evaluateDoubleInternal(stck);
4617 *ptrToFill=stck.back();
4623 for(int i=0;i<nbOfTuples;i++,ptrToFill+=nbOfComp,ptr+=oldNbOfComp)
4625 std::copy(ptr,ptr+oldNbOfComp,buffPtr);
4628 expr.evaluateDoubleInternalSafe(stck);
4629 *ptrToFill=stck.back();
4632 catch(INTERP_KERNEL::Exception& e)
4634 std::ostringstream oss; oss << "For tuple # " << i << " with value (";
4635 std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
4636 oss << ") : Evaluation of function failed !" << e.what();
4637 throw INTERP_KERNEL::Exception(oss.str().c_str());
4642 return newArr.retn();
4645 void DataArrayDouble::applyFuncFast32(const std::string& func)
4648 INTERP_KERNEL::ExprParser expr(func);
4650 char *funcStr=expr.compileX86();
4652 *((void **)&funcPtr)=funcStr;//he he...
4654 double *ptr=getPointer();
4655 int nbOfComp=getNumberOfComponents();
4656 int nbOfTuples=getNumberOfTuples();
4657 int nbOfElems=nbOfTuples*nbOfComp;
4658 for(int i=0;i<nbOfElems;i++,ptr++)
4663 void DataArrayDouble::applyFuncFast64(const std::string& func)
4666 INTERP_KERNEL::ExprParser expr(func);
4668 char *funcStr=expr.compileX86_64();
4670 *((void **)&funcPtr)=funcStr;//he he...
4672 double *ptr=getPointer();
4673 int nbOfComp=getNumberOfComponents();
4674 int nbOfTuples=getNumberOfTuples();
4675 int nbOfElems=nbOfTuples*nbOfComp;
4676 for(int i=0;i<nbOfElems;i++,ptr++)
4681 DataArrayDoubleIterator *DataArrayDouble::iterator()
4683 return new DataArrayDoubleIterator(this);
4687 * Returns a new DataArrayInt contating indices of tuples of \a this one-dimensional
4688 * array whose values are within a given range. Textual data is not copied.
4689 * \param [in] vmin - a lowest acceptable value (included).
4690 * \param [in] vmax - a greatest acceptable value (included).
4691 * \return DataArrayInt * - the new instance of DataArrayInt.
4692 * The caller is to delete this result array using decrRef() as it is no more
4694 * \throw If \a this->getNumberOfComponents() != 1.
4696 * \sa DataArrayDouble::getIdsNotInRange
4698 * \if ENABLE_EXAMPLES
4699 * \ref cpp_mcdataarraydouble_getidsinrange "Here is a C++ example".<br>
4700 * \ref py_mcdataarraydouble_getidsinrange "Here is a Python example".
4703 DataArrayInt *DataArrayDouble::getIdsInRange(double vmin, double vmax) const
4706 if(getNumberOfComponents()!=1)
4707 throw INTERP_KERNEL::Exception("DataArrayDouble::getIdsInRange : this must have exactly one component !");
4708 const double *cptr(begin());
4709 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
4710 int nbOfTuples(getNumberOfTuples());
4711 for(int i=0;i<nbOfTuples;i++,cptr++)
4712 if(*cptr>=vmin && *cptr<=vmax)
4713 ret->pushBackSilent(i);
4718 * Returns a new DataArrayInt contating indices of tuples of \a this one-dimensional
4719 * array whose values are not within a given range. Textual data is not copied.
4720 * \param [in] vmin - a lowest not acceptable value (excluded).
4721 * \param [in] vmax - a greatest not acceptable value (excluded).
4722 * \return DataArrayInt * - the new instance of DataArrayInt.
4723 * The caller is to delete this result array using decrRef() as it is no more
4725 * \throw If \a this->getNumberOfComponents() != 1.
4727 * \sa DataArrayDouble::getIdsInRange
4729 DataArrayInt *DataArrayDouble::getIdsNotInRange(double vmin, double vmax) const
4732 if(getNumberOfComponents()!=1)
4733 throw INTERP_KERNEL::Exception("DataArrayDouble::getIdsNotInRange : this must have exactly one component !");
4734 const double *cptr(begin());
4735 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
4736 int nbOfTuples(getNumberOfTuples());
4737 for(int i=0;i<nbOfTuples;i++,cptr++)
4738 if(*cptr<vmin || *cptr>vmax)
4739 ret->pushBackSilent(i);
4744 * Returns a new DataArrayDouble by concatenating two given arrays, so that (1) the number
4745 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
4746 * the number of component in the result array is same as that of each of given arrays.
4747 * Info on components is copied from the first of the given arrays. Number of components
4748 * in the given arrays must be the same.
4749 * \param [in] a1 - an array to include in the result array.
4750 * \param [in] a2 - another array to include in the result array.
4751 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4752 * The caller is to delete this result array using decrRef() as it is no more
4754 * \throw If both \a a1 and \a a2 are NULL.
4755 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents().
4757 DataArrayDouble *DataArrayDouble::Aggregate(const DataArrayDouble *a1, const DataArrayDouble *a2)
4759 std::vector<const DataArrayDouble *> tmp(2);
4760 tmp[0]=a1; tmp[1]=a2;
4761 return Aggregate(tmp);
4765 * Returns a new DataArrayDouble by concatenating all given arrays, so that (1) the number
4766 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
4767 * the number of component in the result array is same as that of each of given arrays.
4768 * Info on components is copied from the first of the given arrays. Number of components
4769 * in the given arrays must be the same.
4770 * If the number of non null of elements in \a arr is equal to one the returned object is a copy of it
4771 * not the object itself.
4772 * \param [in] arr - a sequence of arrays to include in the result array.
4773 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4774 * The caller is to delete this result array using decrRef() as it is no more
4776 * \throw If all arrays within \a arr are NULL.
4777 * \throw If getNumberOfComponents() of arrays within \a arr.
4779 DataArrayDouble *DataArrayDouble::Aggregate(const std::vector<const DataArrayDouble *>& arr)
4781 std::vector<const DataArrayDouble *> a;
4782 for(std::vector<const DataArrayDouble *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
4786 throw INTERP_KERNEL::Exception("DataArrayDouble::Aggregate : input list must contain at least one NON EMPTY DataArrayDouble !");
4787 std::vector<const DataArrayDouble *>::const_iterator it=a.begin();
4788 int nbOfComp=(*it)->getNumberOfComponents();
4789 int nbt=(*it++)->getNumberOfTuples();
4790 for(int i=1;it!=a.end();it++,i++)
4792 if((*it)->getNumberOfComponents()!=nbOfComp)
4793 throw INTERP_KERNEL::Exception("DataArrayDouble::Aggregate : Nb of components mismatch for array aggregation !");
4794 nbt+=(*it)->getNumberOfTuples();
4796 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
4797 ret->alloc(nbt,nbOfComp);
4798 double *pt=ret->getPointer();
4799 for(it=a.begin();it!=a.end();it++)
4800 pt=std::copy((*it)->getConstPointer(),(*it)->getConstPointer()+(*it)->getNbOfElems(),pt);
4801 ret->copyStringInfoFrom(*(a[0]));
4806 * Returns a new DataArrayDouble by aggregating two given arrays, so that (1) the number
4807 * of components in the result array is a sum of the number of components of given arrays
4808 * and (2) the number of tuples in the result array is same as that of each of given
4809 * arrays. In other words the i-th tuple of result array includes all components of
4810 * i-th tuples of all given arrays.
4811 * Number of tuples in the given arrays must be the same.
4812 * \param [in] a1 - an array to include in the result array.
4813 * \param [in] a2 - another array to include in the result array.
4814 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4815 * The caller is to delete this result array using decrRef() as it is no more
4817 * \throw If both \a a1 and \a a2 are NULL.
4818 * \throw If any given array is not allocated.
4819 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4821 DataArrayDouble *DataArrayDouble::Meld(const DataArrayDouble *a1, const DataArrayDouble *a2)
4823 std::vector<const DataArrayDouble *> arr(2);
4824 arr[0]=a1; arr[1]=a2;
4829 * Returns a new DataArrayDouble by aggregating all given arrays, so that (1) the number
4830 * of components in the result array is a sum of the number of components of given arrays
4831 * and (2) the number of tuples in the result array is same as that of each of given
4832 * arrays. In other words the i-th tuple of result array includes all components of
4833 * i-th tuples of all given arrays.
4834 * Number of tuples in the given arrays must be the same.
4835 * \param [in] arr - a sequence of arrays to include in the result array.
4836 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4837 * The caller is to delete this result array using decrRef() as it is no more
4839 * \throw If all arrays within \a arr are NULL.
4840 * \throw If any given array is not allocated.
4841 * \throw If getNumberOfTuples() of arrays within \a arr is different.
4843 DataArrayDouble *DataArrayDouble::Meld(const std::vector<const DataArrayDouble *>& arr)
4845 std::vector<const DataArrayDouble *> a;
4846 for(std::vector<const DataArrayDouble *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
4850 throw INTERP_KERNEL::Exception("DataArrayDouble::Meld : input list must contain at least one NON EMPTY DataArrayDouble !");
4851 std::vector<const DataArrayDouble *>::const_iterator it;
4852 for(it=a.begin();it!=a.end();it++)
4853 (*it)->checkAllocated();
4855 int nbOfTuples=(*it)->getNumberOfTuples();
4856 std::vector<int> nbc(a.size());
4857 std::vector<const double *> pts(a.size());
4858 nbc[0]=(*it)->getNumberOfComponents();
4859 pts[0]=(*it++)->getConstPointer();
4860 for(int i=1;it!=a.end();it++,i++)
4862 if(nbOfTuples!=(*it)->getNumberOfTuples())
4863 throw INTERP_KERNEL::Exception("DataArrayDouble::Meld : mismatch of number of tuples !");
4864 nbc[i]=(*it)->getNumberOfComponents();
4865 pts[i]=(*it)->getConstPointer();
4867 int totalNbOfComp=std::accumulate(nbc.begin(),nbc.end(),0);
4868 DataArrayDouble *ret=DataArrayDouble::New();
4869 ret->alloc(nbOfTuples,totalNbOfComp);
4870 double *retPtr=ret->getPointer();
4871 for(int i=0;i<nbOfTuples;i++)
4872 for(int j=0;j<(int)a.size();j++)
4874 retPtr=std::copy(pts[j],pts[j]+nbc[j],retPtr);
4878 for(int i=0;i<(int)a.size();i++)
4879 for(int j=0;j<nbc[i];j++,k++)
4880 ret->setInfoOnComponent(k,a[i]->getInfoOnComponent(j));
4885 * Returns a new DataArrayDouble containing a dot product of two given arrays, so that
4886 * the i-th tuple of the result array is a sum of products of j-th components of i-th
4887 * tuples of given arrays (\f$ a_i = \sum_{j=1}^n a1_j * a2_j \f$).
4888 * Info on components and name is copied from the first of the given arrays.
4889 * Number of tuples and components in the given arrays must be the same.
4890 * \param [in] a1 - a given array.
4891 * \param [in] a2 - another given array.
4892 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4893 * The caller is to delete this result array using decrRef() as it is no more
4895 * \throw If either \a a1 or \a a2 is NULL.
4896 * \throw If any given array is not allocated.
4897 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4898 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
4900 DataArrayDouble *DataArrayDouble::Dot(const DataArrayDouble *a1, const DataArrayDouble *a2)
4903 throw INTERP_KERNEL::Exception("DataArrayDouble::Dot : input DataArrayDouble instance is NULL !");
4904 a1->checkAllocated();
4905 a2->checkAllocated();
4906 int nbOfComp=a1->getNumberOfComponents();
4907 if(nbOfComp!=a2->getNumberOfComponents())
4908 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Dot !");
4909 int nbOfTuple=a1->getNumberOfTuples();
4910 if(nbOfTuple!=a2->getNumberOfTuples())
4911 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Dot !");
4912 DataArrayDouble *ret=DataArrayDouble::New();
4913 ret->alloc(nbOfTuple,1);
4914 double *retPtr=ret->getPointer();
4915 const double *a1Ptr=a1->getConstPointer();
4916 const double *a2Ptr=a2->getConstPointer();
4917 for(int i=0;i<nbOfTuple;i++)
4920 for(int j=0;j<nbOfComp;j++)
4921 sum+=a1Ptr[i*nbOfComp+j]*a2Ptr[i*nbOfComp+j];
4924 ret->setInfoOnComponent(0,a1->getInfoOnComponent(0));
4925 ret->setName(a1->getName());
4930 * Returns a new DataArrayDouble containing a cross product of two given arrays, so that
4931 * the i-th tuple of the result array contains 3 components of a vector which is a cross
4932 * product of two vectors defined by the i-th tuples of given arrays.
4933 * Info on components is copied from the first of the given arrays.
4934 * Number of tuples in the given arrays must be the same.
4935 * Number of components in the given arrays must be 3.
4936 * \param [in] a1 - a given array.
4937 * \param [in] a2 - another given array.
4938 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4939 * The caller is to delete this result array using decrRef() as it is no more
4941 * \throw If either \a a1 or \a a2 is NULL.
4942 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4943 * \throw If \a a1->getNumberOfComponents() != 3
4944 * \throw If \a a2->getNumberOfComponents() != 3
4946 DataArrayDouble *DataArrayDouble::CrossProduct(const DataArrayDouble *a1, const DataArrayDouble *a2)
4949 throw INTERP_KERNEL::Exception("DataArrayDouble::CrossProduct : input DataArrayDouble instance is NULL !");
4950 int nbOfComp=a1->getNumberOfComponents();
4951 if(nbOfComp!=a2->getNumberOfComponents())
4952 throw INTERP_KERNEL::Exception("Nb of components mismatch for array crossProduct !");
4954 throw INTERP_KERNEL::Exception("Nb of components must be equal to 3 for array crossProduct !");
4955 int nbOfTuple=a1->getNumberOfTuples();
4956 if(nbOfTuple!=a2->getNumberOfTuples())
4957 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array crossProduct !");
4958 DataArrayDouble *ret=DataArrayDouble::New();
4959 ret->alloc(nbOfTuple,3);
4960 double *retPtr=ret->getPointer();
4961 const double *a1Ptr=a1->getConstPointer();
4962 const double *a2Ptr=a2->getConstPointer();
4963 for(int i=0;i<nbOfTuple;i++)
4965 retPtr[3*i]=a1Ptr[3*i+1]*a2Ptr[3*i+2]-a1Ptr[3*i+2]*a2Ptr[3*i+1];
4966 retPtr[3*i+1]=a1Ptr[3*i+2]*a2Ptr[3*i]-a1Ptr[3*i]*a2Ptr[3*i+2];
4967 retPtr[3*i+2]=a1Ptr[3*i]*a2Ptr[3*i+1]-a1Ptr[3*i+1]*a2Ptr[3*i];
4969 ret->copyStringInfoFrom(*a1);
4974 * Returns a new DataArrayDouble containing maximal values of two given arrays.
4975 * Info on components is copied from the first of the given arrays.
4976 * Number of tuples and components in the given arrays must be the same.
4977 * \param [in] a1 - an array to compare values with another one.
4978 * \param [in] a2 - another array to compare values with the first one.
4979 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4980 * The caller is to delete this result array using decrRef() as it is no more
4982 * \throw If either \a a1 or \a a2 is NULL.
4983 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4984 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
4986 DataArrayDouble *DataArrayDouble::Max(const DataArrayDouble *a1, const DataArrayDouble *a2)
4989 throw INTERP_KERNEL::Exception("DataArrayDouble::Max : input DataArrayDouble instance is NULL !");
4990 int nbOfComp=a1->getNumberOfComponents();
4991 if(nbOfComp!=a2->getNumberOfComponents())
4992 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Max !");
4993 int nbOfTuple=a1->getNumberOfTuples();
4994 if(nbOfTuple!=a2->getNumberOfTuples())
4995 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Max !");
4996 DataArrayDouble *ret=DataArrayDouble::New();
4997 ret->alloc(nbOfTuple,nbOfComp);
4998 double *retPtr=ret->getPointer();
4999 const double *a1Ptr=a1->getConstPointer();
5000 const double *a2Ptr=a2->getConstPointer();
5001 int nbElem=nbOfTuple*nbOfComp;
5002 for(int i=0;i<nbElem;i++)
5003 retPtr[i]=std::max(a1Ptr[i],a2Ptr[i]);
5004 ret->copyStringInfoFrom(*a1);
5009 * Returns a new DataArrayDouble containing minimal values of two given arrays.
5010 * Info on components is copied from the first of the given arrays.
5011 * Number of tuples and components in the given arrays must be the same.
5012 * \param [in] a1 - an array to compare values with another one.
5013 * \param [in] a2 - another array to compare values with the first one.
5014 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5015 * The caller is to delete this result array using decrRef() as it is no more
5017 * \throw If either \a a1 or \a a2 is NULL.
5018 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
5019 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
5021 DataArrayDouble *DataArrayDouble::Min(const DataArrayDouble *a1, const DataArrayDouble *a2)
5024 throw INTERP_KERNEL::Exception("DataArrayDouble::Min : input DataArrayDouble instance is NULL !");
5025 int nbOfComp=a1->getNumberOfComponents();
5026 if(nbOfComp!=a2->getNumberOfComponents())
5027 throw INTERP_KERNEL::Exception("Nb of components mismatch for array min !");
5028 int nbOfTuple=a1->getNumberOfTuples();
5029 if(nbOfTuple!=a2->getNumberOfTuples())
5030 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array min !");
5031 DataArrayDouble *ret=DataArrayDouble::New();
5032 ret->alloc(nbOfTuple,nbOfComp);
5033 double *retPtr=ret->getPointer();
5034 const double *a1Ptr=a1->getConstPointer();
5035 const double *a2Ptr=a2->getConstPointer();
5036 int nbElem=nbOfTuple*nbOfComp;
5037 for(int i=0;i<nbElem;i++)
5038 retPtr[i]=std::min(a1Ptr[i],a2Ptr[i]);
5039 ret->copyStringInfoFrom(*a1);
5044 * Returns a new DataArrayDouble that is a sum of two given arrays. There are 3
5046 * 1. The arrays have same number of tuples and components. Then each value of
5047 * the result array (_a_) is a sum of the corresponding values of \a a1 and \a a2,
5048 * i.e.: _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, j ].
5049 * 2. The arrays have same number of tuples and one array, say _a2_, has one
5051 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, 0 ].
5052 * 3. The arrays have same number of components and one array, say _a2_, has one
5054 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ 0, j ].
5056 * Info on components is copied either from the first array (in the first case) or from
5057 * the array with maximal number of elements (getNbOfElems()).
5058 * \param [in] a1 - an array to sum up.
5059 * \param [in] a2 - another array to sum up.
5060 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5061 * The caller is to delete this result array using decrRef() as it is no more
5063 * \throw If either \a a1 or \a a2 is NULL.
5064 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
5065 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
5066 * none of them has number of tuples or components equal to 1.
5068 DataArrayDouble *DataArrayDouble::Add(const DataArrayDouble *a1, const DataArrayDouble *a2)
5071 throw INTERP_KERNEL::Exception("DataArrayDouble::Add : input DataArrayDouble instance is NULL !");
5072 int nbOfTuple=a1->getNumberOfTuples();
5073 int nbOfTuple2=a2->getNumberOfTuples();
5074 int nbOfComp=a1->getNumberOfComponents();
5075 int nbOfComp2=a2->getNumberOfComponents();
5076 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=0;
5077 if(nbOfTuple==nbOfTuple2)
5079 if(nbOfComp==nbOfComp2)
5081 ret=DataArrayDouble::New();
5082 ret->alloc(nbOfTuple,nbOfComp);
5083 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::plus<double>());
5084 ret->copyStringInfoFrom(*a1);
5088 int nbOfCompMin,nbOfCompMax;
5089 const DataArrayDouble *aMin, *aMax;
5090 if(nbOfComp>nbOfComp2)
5092 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
5097 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
5102 ret=DataArrayDouble::New();
5103 ret->alloc(nbOfTuple,nbOfCompMax);
5104 const double *aMinPtr=aMin->getConstPointer();
5105 const double *aMaxPtr=aMax->getConstPointer();
5106 double *res=ret->getPointer();
5107 for(int i=0;i<nbOfTuple;i++)
5108 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::plus<double>(),aMinPtr[i]));
5109 ret->copyStringInfoFrom(*aMax);
5112 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
5115 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
5117 if(nbOfComp==nbOfComp2)
5119 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
5120 const DataArrayDouble *aMin=nbOfTuple>nbOfTuple2?a2:a1;
5121 const DataArrayDouble *aMax=nbOfTuple>nbOfTuple2?a1:a2;
5122 const double *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
5123 ret=DataArrayDouble::New();
5124 ret->alloc(nbOfTupleMax,nbOfComp);
5125 double *res=ret->getPointer();
5126 for(int i=0;i<nbOfTupleMax;i++)
5127 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::plus<double>());
5128 ret->copyStringInfoFrom(*aMax);
5131 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
5134 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Add !");
5139 * Adds values of another DataArrayDouble to values of \a this one. There are 3
5141 * 1. The arrays have same number of tuples and components. Then each value of
5142 * \a other array is added to the corresponding value of \a this array, i.e.:
5143 * _a_ [ i, j ] += _other_ [ i, j ].
5144 * 2. The arrays have same number of tuples and \a other array has one component. Then
5145 * _a_ [ i, j ] += _other_ [ i, 0 ].
5146 * 3. The arrays have same number of components and \a other array has one tuple. Then
5147 * _a_ [ i, j ] += _a2_ [ 0, j ].
5149 * \param [in] other - an array to add to \a this one.
5150 * \throw If \a other is NULL.
5151 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
5152 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
5153 * \a other has number of both tuples and components not equal to 1.
5155 void DataArrayDouble::addEqual(const DataArrayDouble *other)
5158 throw INTERP_KERNEL::Exception("DataArrayDouble::addEqual : input DataArrayDouble instance is NULL !");
5159 const char *msg="Nb of tuples mismatch for DataArrayDouble::addEqual !";
5161 other->checkAllocated();
5162 int nbOfTuple=getNumberOfTuples();
5163 int nbOfTuple2=other->getNumberOfTuples();
5164 int nbOfComp=getNumberOfComponents();
5165 int nbOfComp2=other->getNumberOfComponents();
5166 if(nbOfTuple==nbOfTuple2)
5168 if(nbOfComp==nbOfComp2)
5170 std::transform(begin(),end(),other->begin(),getPointer(),std::plus<double>());
5172 else if(nbOfComp2==1)
5174 double *ptr=getPointer();
5175 const double *ptrc=other->getConstPointer();
5176 for(int i=0;i<nbOfTuple;i++)
5177 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::plus<double>(),*ptrc++));
5180 throw INTERP_KERNEL::Exception(msg);
5182 else if(nbOfTuple2==1)
5184 if(nbOfComp2==nbOfComp)
5186 double *ptr=getPointer();
5187 const double *ptrc=other->getConstPointer();
5188 for(int i=0;i<nbOfTuple;i++)
5189 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::plus<double>());
5192 throw INTERP_KERNEL::Exception(msg);
5195 throw INTERP_KERNEL::Exception(msg);
5200 * Returns a new DataArrayDouble that is a subtraction of two given arrays. There are 3
5202 * 1. The arrays have same number of tuples and components. Then each value of
5203 * the result array (_a_) is a subtraction of the corresponding values of \a a1 and
5204 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, j ].
5205 * 2. The arrays have same number of tuples and one array, say _a2_, has one
5207 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, 0 ].
5208 * 3. The arrays have same number of components and one array, say _a2_, has one
5210 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ 0, j ].
5212 * Info on components is copied either from the first array (in the first case) or from
5213 * the array with maximal number of elements (getNbOfElems()).
5214 * \param [in] a1 - an array to subtract from.
5215 * \param [in] a2 - an array to subtract.
5216 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5217 * The caller is to delete this result array using decrRef() as it is no more
5219 * \throw If either \a a1 or \a a2 is NULL.
5220 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
5221 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
5222 * none of them has number of tuples or components equal to 1.
5224 DataArrayDouble *DataArrayDouble::Substract(const DataArrayDouble *a1, const DataArrayDouble *a2)
5227 throw INTERP_KERNEL::Exception("DataArrayDouble::Substract : input DataArrayDouble instance is NULL !");
5228 int nbOfTuple1=a1->getNumberOfTuples();
5229 int nbOfTuple2=a2->getNumberOfTuples();
5230 int nbOfComp1=a1->getNumberOfComponents();
5231 int nbOfComp2=a2->getNumberOfComponents();
5232 if(nbOfTuple2==nbOfTuple1)
5234 if(nbOfComp1==nbOfComp2)
5236 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5237 ret->alloc(nbOfTuple2,nbOfComp1);
5238 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::minus<double>());
5239 ret->copyStringInfoFrom(*a1);
5242 else if(nbOfComp2==1)
5244 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5245 ret->alloc(nbOfTuple1,nbOfComp1);
5246 const double *a2Ptr=a2->getConstPointer();
5247 const double *a1Ptr=a1->getConstPointer();
5248 double *res=ret->getPointer();
5249 for(int i=0;i<nbOfTuple1;i++)
5250 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::minus<double>(),a2Ptr[i]));
5251 ret->copyStringInfoFrom(*a1);
5256 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
5260 else if(nbOfTuple2==1)
5262 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
5263 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5264 ret->alloc(nbOfTuple1,nbOfComp1);
5265 const double *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
5266 double *pt=ret->getPointer();
5267 for(int i=0;i<nbOfTuple1;i++)
5268 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::minus<double>());
5269 ret->copyStringInfoFrom(*a1);
5274 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Substract !");//will always throw an exception
5280 * Subtract values of another DataArrayDouble from values of \a this one. There are 3
5282 * 1. The arrays have same number of tuples and components. Then each value of
5283 * \a other array is subtracted from the corresponding value of \a this array, i.e.:
5284 * _a_ [ i, j ] -= _other_ [ i, j ].
5285 * 2. The arrays have same number of tuples and \a other array has one component. Then
5286 * _a_ [ i, j ] -= _other_ [ i, 0 ].
5287 * 3. The arrays have same number of components and \a other array has one tuple. Then
5288 * _a_ [ i, j ] -= _a2_ [ 0, j ].
5290 * \param [in] other - an array to subtract from \a this one.
5291 * \throw If \a other is NULL.
5292 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
5293 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
5294 * \a other has number of both tuples and components not equal to 1.
5296 void DataArrayDouble::substractEqual(const DataArrayDouble *other)
5299 throw INTERP_KERNEL::Exception("DataArrayDouble::substractEqual : input DataArrayDouble instance is NULL !");
5300 const char *msg="Nb of tuples mismatch for DataArrayDouble::substractEqual !";
5302 other->checkAllocated();
5303 int nbOfTuple=getNumberOfTuples();
5304 int nbOfTuple2=other->getNumberOfTuples();
5305 int nbOfComp=getNumberOfComponents();
5306 int nbOfComp2=other->getNumberOfComponents();
5307 if(nbOfTuple==nbOfTuple2)
5309 if(nbOfComp==nbOfComp2)
5311 std::transform(begin(),end(),other->begin(),getPointer(),std::minus<double>());
5313 else if(nbOfComp2==1)
5315 double *ptr=getPointer();
5316 const double *ptrc=other->getConstPointer();
5317 for(int i=0;i<nbOfTuple;i++)
5318 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::minus<double>(),*ptrc++));
5321 throw INTERP_KERNEL::Exception(msg);
5323 else if(nbOfTuple2==1)
5325 if(nbOfComp2==nbOfComp)
5327 double *ptr=getPointer();
5328 const double *ptrc=other->getConstPointer();
5329 for(int i=0;i<nbOfTuple;i++)
5330 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::minus<double>());
5333 throw INTERP_KERNEL::Exception(msg);
5336 throw INTERP_KERNEL::Exception(msg);
5341 * Returns a new DataArrayDouble that is a product of two given arrays. There are 3
5343 * 1. The arrays have same number of tuples and components. Then each value of
5344 * the result array (_a_) is a product of the corresponding values of \a a1 and
5345 * \a a2, i.e. _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, j ].
5346 * 2. The arrays have same number of tuples and one array, say _a2_, has one
5348 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, 0 ].
5349 * 3. The arrays have same number of components and one array, say _a2_, has one
5351 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ 0, j ].
5353 * Info on components is copied either from the first array (in the first case) or from
5354 * the array with maximal number of elements (getNbOfElems()).
5355 * \param [in] a1 - a factor array.
5356 * \param [in] a2 - another factor array.
5357 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5358 * The caller is to delete this result array using decrRef() as it is no more
5360 * \throw If either \a a1 or \a a2 is NULL.
5361 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
5362 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
5363 * none of them has number of tuples or components equal to 1.
5365 DataArrayDouble *DataArrayDouble::Multiply(const DataArrayDouble *a1, const DataArrayDouble *a2)
5368 throw INTERP_KERNEL::Exception("DataArrayDouble::Multiply : input DataArrayDouble instance is NULL !");
5369 int nbOfTuple=a1->getNumberOfTuples();
5370 int nbOfTuple2=a2->getNumberOfTuples();
5371 int nbOfComp=a1->getNumberOfComponents();
5372 int nbOfComp2=a2->getNumberOfComponents();
5373 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=0;
5374 if(nbOfTuple==nbOfTuple2)
5376 if(nbOfComp==nbOfComp2)
5378 ret=DataArrayDouble::New();
5379 ret->alloc(nbOfTuple,nbOfComp);
5380 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::multiplies<double>());
5381 ret->copyStringInfoFrom(*a1);
5385 int nbOfCompMin,nbOfCompMax;
5386 const DataArrayDouble *aMin, *aMax;
5387 if(nbOfComp>nbOfComp2)
5389 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
5394 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
5399 ret=DataArrayDouble::New();
5400 ret->alloc(nbOfTuple,nbOfCompMax);
5401 const double *aMinPtr=aMin->getConstPointer();
5402 const double *aMaxPtr=aMax->getConstPointer();
5403 double *res=ret->getPointer();
5404 for(int i=0;i<nbOfTuple;i++)
5405 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::multiplies<double>(),aMinPtr[i]));
5406 ret->copyStringInfoFrom(*aMax);
5409 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
5412 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
5414 if(nbOfComp==nbOfComp2)
5416 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
5417 const DataArrayDouble *aMin=nbOfTuple>nbOfTuple2?a2:a1;
5418 const DataArrayDouble *aMax=nbOfTuple>nbOfTuple2?a1:a2;
5419 const double *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
5420 ret=DataArrayDouble::New();
5421 ret->alloc(nbOfTupleMax,nbOfComp);
5422 double *res=ret->getPointer();
5423 for(int i=0;i<nbOfTupleMax;i++)
5424 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::multiplies<double>());
5425 ret->copyStringInfoFrom(*aMax);
5428 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
5431 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Multiply !");
5436 * Multiply values of another DataArrayDouble to values of \a this one. There are 3
5438 * 1. The arrays have same number of tuples and components. Then each value of
5439 * \a other array is multiplied to the corresponding value of \a this array, i.e.
5440 * _this_ [ i, j ] *= _other_ [ i, j ].
5441 * 2. The arrays have same number of tuples and \a other array has one component. Then
5442 * _this_ [ i, j ] *= _other_ [ i, 0 ].
5443 * 3. The arrays have same number of components and \a other array has one tuple. Then
5444 * _this_ [ i, j ] *= _a2_ [ 0, j ].
5446 * \param [in] other - an array to multiply to \a this one.
5447 * \throw If \a other is NULL.
5448 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
5449 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
5450 * \a other has number of both tuples and components not equal to 1.
5452 void DataArrayDouble::multiplyEqual(const DataArrayDouble *other)
5455 throw INTERP_KERNEL::Exception("DataArrayDouble::multiplyEqual : input DataArrayDouble instance is NULL !");
5456 const char *msg="Nb of tuples mismatch for DataArrayDouble::multiplyEqual !";
5458 other->checkAllocated();
5459 int nbOfTuple=getNumberOfTuples();
5460 int nbOfTuple2=other->getNumberOfTuples();
5461 int nbOfComp=getNumberOfComponents();
5462 int nbOfComp2=other->getNumberOfComponents();
5463 if(nbOfTuple==nbOfTuple2)
5465 if(nbOfComp==nbOfComp2)
5467 std::transform(begin(),end(),other->begin(),getPointer(),std::multiplies<double>());
5469 else if(nbOfComp2==1)
5471 double *ptr=getPointer();
5472 const double *ptrc=other->getConstPointer();
5473 for(int i=0;i<nbOfTuple;i++)
5474 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::multiplies<double>(),*ptrc++));
5477 throw INTERP_KERNEL::Exception(msg);
5479 else if(nbOfTuple2==1)
5481 if(nbOfComp2==nbOfComp)
5483 double *ptr=getPointer();
5484 const double *ptrc=other->getConstPointer();
5485 for(int i=0;i<nbOfTuple;i++)
5486 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::multiplies<double>());
5489 throw INTERP_KERNEL::Exception(msg);
5492 throw INTERP_KERNEL::Exception(msg);
5497 * Returns a new DataArrayDouble that is a division of two given arrays. There are 3
5499 * 1. The arrays have same number of tuples and components. Then each value of
5500 * the result array (_a_) is a division of the corresponding values of \a a1 and
5501 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, j ].
5502 * 2. The arrays have same number of tuples and one array, say _a2_, has one
5504 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, 0 ].
5505 * 3. The arrays have same number of components and one array, say _a2_, has one
5507 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ 0, j ].
5509 * Info on components is copied either from the first array (in the first case) or from
5510 * the array with maximal number of elements (getNbOfElems()).
5511 * \warning No check of division by zero is performed!
5512 * \param [in] a1 - a numerator array.
5513 * \param [in] a2 - a denominator array.
5514 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5515 * The caller is to delete this result array using decrRef() as it is no more
5517 * \throw If either \a a1 or \a a2 is NULL.
5518 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
5519 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
5520 * none of them has number of tuples or components equal to 1.
5522 DataArrayDouble *DataArrayDouble::Divide(const DataArrayDouble *a1, const DataArrayDouble *a2)
5525 throw INTERP_KERNEL::Exception("DataArrayDouble::Divide : input DataArrayDouble instance is NULL !");
5526 int nbOfTuple1=a1->getNumberOfTuples();
5527 int nbOfTuple2=a2->getNumberOfTuples();
5528 int nbOfComp1=a1->getNumberOfComponents();
5529 int nbOfComp2=a2->getNumberOfComponents();
5530 if(nbOfTuple2==nbOfTuple1)
5532 if(nbOfComp1==nbOfComp2)
5534 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5535 ret->alloc(nbOfTuple2,nbOfComp1);
5536 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::divides<double>());
5537 ret->copyStringInfoFrom(*a1);
5540 else if(nbOfComp2==1)
5542 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5543 ret->alloc(nbOfTuple1,nbOfComp1);
5544 const double *a2Ptr=a2->getConstPointer();
5545 const double *a1Ptr=a1->getConstPointer();
5546 double *res=ret->getPointer();
5547 for(int i=0;i<nbOfTuple1;i++)
5548 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::divides<double>(),a2Ptr[i]));
5549 ret->copyStringInfoFrom(*a1);
5554 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
5558 else if(nbOfTuple2==1)
5560 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
5561 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5562 ret->alloc(nbOfTuple1,nbOfComp1);
5563 const double *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
5564 double *pt=ret->getPointer();
5565 for(int i=0;i<nbOfTuple1;i++)
5566 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::divides<double>());
5567 ret->copyStringInfoFrom(*a1);
5572 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Divide !");//will always throw an exception
5578 * Divide values of \a this array by values of another DataArrayDouble. There are 3
5580 * 1. The arrays have same number of tuples and components. Then each value of
5581 * \a this array is divided by the corresponding value of \a other one, i.e.:
5582 * _a_ [ i, j ] /= _other_ [ i, j ].
5583 * 2. The arrays have same number of tuples and \a other array has one component. Then
5584 * _a_ [ i, j ] /= _other_ [ i, 0 ].
5585 * 3. The arrays have same number of components and \a other array has one tuple. Then
5586 * _a_ [ i, j ] /= _a2_ [ 0, j ].
5588 * \warning No check of division by zero is performed!
5589 * \param [in] other - an array to divide \a this one by.
5590 * \throw If \a other is NULL.
5591 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
5592 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
5593 * \a other has number of both tuples and components not equal to 1.
5595 void DataArrayDouble::divideEqual(const DataArrayDouble *other)
5598 throw INTERP_KERNEL::Exception("DataArrayDouble::divideEqual : input DataArrayDouble instance is NULL !");
5599 const char *msg="Nb of tuples mismatch for DataArrayDouble::divideEqual !";
5601 other->checkAllocated();
5602 int nbOfTuple=getNumberOfTuples();
5603 int nbOfTuple2=other->getNumberOfTuples();
5604 int nbOfComp=getNumberOfComponents();
5605 int nbOfComp2=other->getNumberOfComponents();
5606 if(nbOfTuple==nbOfTuple2)
5608 if(nbOfComp==nbOfComp2)
5610 std::transform(begin(),end(),other->begin(),getPointer(),std::divides<double>());
5612 else if(nbOfComp2==1)
5614 double *ptr=getPointer();
5615 const double *ptrc=other->getConstPointer();
5616 for(int i=0;i<nbOfTuple;i++)
5617 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::divides<double>(),*ptrc++));
5620 throw INTERP_KERNEL::Exception(msg);
5622 else if(nbOfTuple2==1)
5624 if(nbOfComp2==nbOfComp)
5626 double *ptr=getPointer();
5627 const double *ptrc=other->getConstPointer();
5628 for(int i=0;i<nbOfTuple;i++)
5629 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::divides<double>());
5632 throw INTERP_KERNEL::Exception(msg);
5635 throw INTERP_KERNEL::Exception(msg);
5640 * Returns a new DataArrayDouble that is the result of pow of two given arrays. There are 3
5643 * \param [in] a1 - an array to pow up.
5644 * \param [in] a2 - another array to sum up.
5645 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5646 * The caller is to delete this result array using decrRef() as it is no more
5648 * \throw If either \a a1 or \a a2 is NULL.
5649 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
5650 * \throw If \a a1->getNumberOfComponents() != 1 or \a a2->getNumberOfComponents() != 1.
5651 * \throw If there is a negative value in \a a1.
5653 DataArrayDouble *DataArrayDouble::Pow(const DataArrayDouble *a1, const DataArrayDouble *a2)
5656 throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : at least one of input instances is null !");
5657 int nbOfTuple=a1->getNumberOfTuples();
5658 int nbOfTuple2=a2->getNumberOfTuples();
5659 int nbOfComp=a1->getNumberOfComponents();
5660 int nbOfComp2=a2->getNumberOfComponents();
5661 if(nbOfTuple!=nbOfTuple2)
5662 throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : number of tuples mismatches !");
5663 if(nbOfComp!=1 || nbOfComp2!=1)
5664 throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : number of components of both arrays must be equal to 1 !");
5665 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(nbOfTuple,1);
5666 const double *ptr1(a1->begin()),*ptr2(a2->begin());
5667 double *ptr=ret->getPointer();
5668 for(int i=0;i<nbOfTuple;i++,ptr1++,ptr2++,ptr++)
5672 *ptr=pow(*ptr1,*ptr2);
5676 std::ostringstream oss; oss << "DataArrayDouble::Pow : on tuple #" << i << " of a1 value is < 0 (" << *ptr1 << ") !";
5677 throw INTERP_KERNEL::Exception(oss.str().c_str());
5684 * Apply pow on values of another DataArrayDouble to values of \a this one.
5686 * \param [in] other - an array to pow to \a this one.
5687 * \throw If \a other is NULL.
5688 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples()
5689 * \throw If \a this->getNumberOfComponents() != 1 or \a other->getNumberOfComponents() != 1
5690 * \throw If there is a negative value in \a this.
5692 void DataArrayDouble::powEqual(const DataArrayDouble *other)
5695 throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : input instance is null !");
5696 int nbOfTuple=getNumberOfTuples();
5697 int nbOfTuple2=other->getNumberOfTuples();
5698 int nbOfComp=getNumberOfComponents();
5699 int nbOfComp2=other->getNumberOfComponents();
5700 if(nbOfTuple!=nbOfTuple2)
5701 throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : number of tuples mismatches !");
5702 if(nbOfComp!=1 || nbOfComp2!=1)
5703 throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : number of components of both arrays must be equal to 1 !");
5704 double *ptr=getPointer();
5705 const double *ptrc=other->begin();
5706 for(int i=0;i<nbOfTuple;i++,ptrc++,ptr++)
5709 *ptr=pow(*ptr,*ptrc);
5712 std::ostringstream oss; oss << "DataArrayDouble::powEqual : on tuple #" << i << " of this value is < 0 (" << *ptr << ") !";
5713 throw INTERP_KERNEL::Exception(oss.str().c_str());
5720 * This method is \b NOT wrapped into python because it can be useful only for performance reasons in C++ context.
5721 * All values in \a this must be 0. or 1. within eps error. 0 means false, 1 means true.
5722 * If an another value than 0 or 1 appear (within eps precision) an INTERP_KERNEL::Exception will be thrown.
5724 * \throw if \a this is not allocated.
5725 * \throw if \a this has not exactly one component.
5727 std::vector<bool> DataArrayDouble::toVectorOfBool(double eps) const
5730 if(getNumberOfComponents()!=1)
5731 throw INTERP_KERNEL::Exception("DataArrayDouble::toVectorOfBool : must be applied on single component array !");
5732 int nbt(getNumberOfTuples());
5733 std::vector<bool> ret(nbt);
5734 const double *pt(begin());
5735 for(int i=0;i<nbt;i++)
5739 else if(fabs(pt[i]-1.)<eps)
5743 std::ostringstream oss; oss << "DataArrayDouble::toVectorOfBool : the tuple #" << i << " has value " << pt[i] << " is invalid ! must be 0. or 1. !";
5744 throw INTERP_KERNEL::Exception(oss.str().c_str());
5751 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5754 void DataArrayDouble::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
5759 tinyInfo[0]=getNumberOfTuples();
5760 tinyInfo[1]=getNumberOfComponents();
5770 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5773 void DataArrayDouble::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
5777 int nbOfCompo=getNumberOfComponents();
5778 tinyInfo.resize(nbOfCompo+1);
5779 tinyInfo[0]=getName();
5780 for(int i=0;i<nbOfCompo;i++)
5781 tinyInfo[i+1]=getInfoOnComponent(i);
5786 tinyInfo[0]=getName();
5791 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5792 * This method returns if a feeding is needed.
5794 bool DataArrayDouble::resizeForUnserialization(const std::vector<int>& tinyInfoI)
5796 int nbOfTuple=tinyInfoI[0];
5797 int nbOfComp=tinyInfoI[1];
5798 if(nbOfTuple!=-1 || nbOfComp!=-1)
5800 alloc(nbOfTuple,nbOfComp);
5807 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5809 void DataArrayDouble::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<std::string>& tinyInfoS)
5811 setName(tinyInfoS[0]);
5814 int nbOfCompo=getNumberOfComponents();
5815 for(int i=0;i<nbOfCompo;i++)
5816 setInfoOnComponent(i,tinyInfoS[i+1]);
5820 DataArrayDoubleIterator::DataArrayDoubleIterator(DataArrayDouble *da):_da(da),_tuple_id(0),_nb_comp(0),_nb_tuple(0)
5825 if(_da->isAllocated())
5827 _nb_comp=da->getNumberOfComponents();
5828 _nb_tuple=da->getNumberOfTuples();
5829 _pt=da->getPointer();
5834 DataArrayDoubleIterator::~DataArrayDoubleIterator()
5840 DataArrayDoubleTuple *DataArrayDoubleIterator::nextt()
5842 if(_tuple_id<_nb_tuple)
5845 DataArrayDoubleTuple *ret=new DataArrayDoubleTuple(_pt,_nb_comp);
5853 DataArrayDoubleTuple::DataArrayDoubleTuple(double *pt, int nbOfComp):_pt(pt),_nb_of_compo(nbOfComp)
5858 std::string DataArrayDoubleTuple::repr() const
5860 std::ostringstream oss; oss.precision(17); oss << "(";
5861 for(int i=0;i<_nb_of_compo-1;i++)
5862 oss << _pt[i] << ", ";
5863 oss << _pt[_nb_of_compo-1] << ")";
5867 double DataArrayDoubleTuple::doubleValue() const
5871 throw INTERP_KERNEL::Exception("DataArrayDoubleTuple::doubleValue : DataArrayDoubleTuple instance has not exactly 1 component -> Not possible to convert it into a double precision float !");
5875 * This method returns a newly allocated instance the caller should dealed with by a ParaMEDMEM::DataArrayDouble::decrRef.
5876 * This method performs \b no copy of data. The content is only referenced using ParaMEDMEM::DataArrayDouble::useArray with ownership set to \b false.
5877 * This method throws an INTERP_KERNEL::Exception is it is impossible to match sizes of \b this that is too say \b nbOfCompo=this->_nb_of_elem and \bnbOfTuples==1 or
5878 * \b nbOfCompo=1 and \bnbOfTuples==this->_nb_of_elem.
5880 DataArrayDouble *DataArrayDoubleTuple::buildDADouble(int nbOfTuples, int nbOfCompo) const
5882 if((_nb_of_compo==nbOfCompo && nbOfTuples==1) || (_nb_of_compo==nbOfTuples && nbOfCompo==1))
5884 DataArrayDouble *ret=DataArrayDouble::New();
5885 ret->useExternalArrayWithRWAccess(_pt,nbOfTuples,nbOfCompo);
5890 std::ostringstream oss; oss << "DataArrayDoubleTuple::buildDADouble : unable to build a requested DataArrayDouble instance with nbofTuple=" << nbOfTuples << " and nbOfCompo=" << nbOfCompo;
5891 oss << ".\nBecause the number of elements in this is " << _nb_of_compo << " !";
5892 throw INTERP_KERNEL::Exception(oss.str().c_str());
5897 * Returns a new instance of DataArrayInt. The caller is to delete this array
5898 * using decrRef() as it is no more needed.
5900 DataArrayInt *DataArrayInt::New()
5902 return new DataArrayInt;
5906 * Checks if raw data is allocated. Read more on the raw data
5907 * in \ref MEDCouplingArrayBasicsTuplesAndCompo "DataArrays infos" for more information.
5908 * \return bool - \a true if the raw data is allocated, \a false else.
5910 bool DataArrayInt::isAllocated() const
5912 return getConstPointer()!=0;
5916 * Checks if raw data is allocated and throws an exception if it is not the case.
5917 * \throw If the raw data is not allocated.
5919 void DataArrayInt::checkAllocated() const
5922 throw INTERP_KERNEL::Exception("DataArrayInt::checkAllocated : Array is defined but not allocated ! Call alloc or setValues method first !");
5926 * This method desallocated \a this without modification of informations relative to the components.
5927 * After call of this method, DataArrayInt::isAllocated will return false.
5928 * If \a this is already not allocated, \a this is let unchanged.
5930 void DataArrayInt::desallocate()
5935 std::size_t DataArrayInt::getHeapMemorySizeWithoutChildren() const
5937 std::size_t sz(_mem.getNbOfElemAllocated());
5939 return DataArray::getHeapMemorySizeWithoutChildren()+sz;
5943 * Returns the only one value in \a this, if and only if number of elements
5944 * (nb of tuples * nb of components) is equal to 1, and that \a this is allocated.
5945 * \return double - the sole value stored in \a this array.
5946 * \throw If at least one of conditions stated above is not fulfilled.
5948 int DataArrayInt::intValue() const
5952 if(getNbOfElems()==1)
5954 return *getConstPointer();
5957 throw INTERP_KERNEL::Exception("DataArrayInt::intValue : DataArrayInt instance is allocated but number of elements is not equal to 1 !");
5960 throw INTERP_KERNEL::Exception("DataArrayInt::intValue : DataArrayInt instance is not allocated !");
5964 * Returns an integer value characterizing \a this array, which is useful for a quick
5965 * comparison of many instances of DataArrayInt.
5966 * \return int - the hash value.
5967 * \throw If \a this is not allocated.
5969 int DataArrayInt::getHashCode() const
5972 std::size_t nbOfElems=getNbOfElems();
5973 int ret=nbOfElems*65536;
5978 const int *pt=begin();
5979 for(std::size_t i=0;i<nbOfElems;i+=delta)
5980 ret0+=pt[i] & 0x1FFF;
5985 * Checks the number of tuples.
5986 * \return bool - \a true if getNumberOfTuples() == 0, \a false else.
5987 * \throw If \a this is not allocated.
5989 bool DataArrayInt::empty() const
5992 return getNumberOfTuples()==0;
5996 * Returns a full copy of \a this. For more info on copying data arrays see
5997 * \ref MEDCouplingArrayBasicsCopyDeep.
5998 * \return DataArrayInt * - a new instance of DataArrayInt.
6000 DataArrayInt *DataArrayInt::deepCpy() const
6002 return new DataArrayInt(*this);
6006 * Returns either a \a deep or \a shallow copy of this array. For more info see
6007 * \ref MEDCouplingArrayBasicsCopyDeep and \ref MEDCouplingArrayBasicsCopyShallow.
6008 * \param [in] dCpy - if \a true, a deep copy is returned, else, a shallow one.
6009 * \return DataArrayInt * - either a new instance of DataArrayInt (if \a dCpy
6010 * == \a true) or \a this instance (if \a dCpy == \a false).
6012 DataArrayInt *DataArrayInt::performCpy(bool dCpy) const
6019 return const_cast<DataArrayInt *>(this);
6024 * Copies all the data from another DataArrayInt. For more info see
6025 * \ref MEDCouplingArrayBasicsCopyDeepAssign.
6026 * \param [in] other - another instance of DataArrayInt to copy data from.
6027 * \throw If the \a other is not allocated.
6029 void DataArrayInt::cpyFrom(const DataArrayInt& other)
6031 other.checkAllocated();
6032 int nbOfTuples=other.getNumberOfTuples();
6033 int nbOfComp=other.getNumberOfComponents();
6034 allocIfNecessary(nbOfTuples,nbOfComp);
6035 std::size_t nbOfElems=(std::size_t)nbOfTuples*nbOfComp;
6036 int *pt=getPointer();
6037 const int *ptI=other.getConstPointer();
6038 for(std::size_t i=0;i<nbOfElems;i++)
6040 copyStringInfoFrom(other);
6044 * This method reserve nbOfElems elements in memory ( nbOfElems*4 bytes ) \b without impacting the number of tuples in \a this.
6045 * If \a this has already been allocated, this method checks that \a this has only one component. If not an INTERP_KERNEL::Exception will be thrown.
6046 * If \a this has not already been allocated, number of components is set to one.
6047 * This method allows to reduce number of reallocations on invokation of DataArrayInt::pushBackSilent and DataArrayInt::pushBackValsSilent on \a this.
6049 * \sa DataArrayInt::pack, DataArrayInt::pushBackSilent, DataArrayInt::pushBackValsSilent
6051 void DataArrayInt::reserve(std::size_t nbOfElems)
6053 int nbCompo=getNumberOfComponents();
6056 _mem.reserve(nbOfElems);
6060 _mem.reserve(nbOfElems);
6061 _info_on_compo.resize(1);
6064 throw INTERP_KERNEL::Exception("DataArrayInt::reserve : not available for DataArrayInt with number of components different than 1 !");
6068 * This method adds at the end of \a this the single value \a val. This method do \b not update its time label to avoid useless incrementation
6069 * of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
6071 * \param [in] val the value to be added in \a this
6072 * \throw If \a this has already been allocated with number of components different from one.
6073 * \sa DataArrayInt::pushBackValsSilent
6075 void DataArrayInt::pushBackSilent(int val)
6077 int nbCompo=getNumberOfComponents();
6082 _info_on_compo.resize(1);
6086 throw INTERP_KERNEL::Exception("DataArrayInt::pushBackSilent : not available for DataArrayInt with number of components different than 1 !");
6090 * This method adds at the end of \a this a serie of values [\c valsBg,\c valsEnd). This method do \b not update its time label to avoid useless incrementation
6091 * of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
6093 * \param [in] valsBg - an array of values to push at the end of \this.
6094 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
6095 * the last value of \a valsBg is \a valsEnd[ -1 ].
6096 * \throw If \a this has already been allocated with number of components different from one.
6097 * \sa DataArrayInt::pushBackSilent
6099 void DataArrayInt::pushBackValsSilent(const int *valsBg, const int *valsEnd)
6101 int nbCompo=getNumberOfComponents();
6103 _mem.insertAtTheEnd(valsBg,valsEnd);
6106 _info_on_compo.resize(1);
6107 _mem.insertAtTheEnd(valsBg,valsEnd);
6110 throw INTERP_KERNEL::Exception("DataArrayInt::pushBackValsSilent : not available for DataArrayInt with number of components different than 1 !");
6114 * This method returns silently ( without updating time label in \a this ) the last value, if any and suppress it.
6115 * \throw If \a this is already empty.
6116 * \throw If \a this has number of components different from one.
6118 int DataArrayInt::popBackSilent()
6120 if(getNumberOfComponents()==1)
6121 return _mem.popBack();
6123 throw INTERP_KERNEL::Exception("DataArrayInt::popBackSilent : not available for DataArrayInt with number of components different than 1 !");
6127 * This method \b do \b not modify content of \a this. It only modify its memory footprint if the allocated memory is to high regarding real data to store.
6129 * \sa DataArrayInt::getHeapMemorySizeWithoutChildren, DataArrayInt::reserve
6131 void DataArrayInt::pack() const
6137 * Allocates the raw data in memory. If exactly as same memory as needed already
6138 * allocated, it is not re-allocated.
6139 * \param [in] nbOfTuple - number of tuples of data to allocate.
6140 * \param [in] nbOfCompo - number of components of data to allocate.
6141 * \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
6143 void DataArrayInt::allocIfNecessary(int nbOfTuple, int nbOfCompo)
6147 if(nbOfTuple!=getNumberOfTuples() || nbOfCompo!=getNumberOfComponents())
6148 alloc(nbOfTuple,nbOfCompo);
6151 alloc(nbOfTuple,nbOfCompo);
6155 * Allocates the raw data in memory. If the memory was already allocated, then it is
6156 * freed and re-allocated. See an example of this method use
6157 * \ref MEDCouplingArraySteps1WC "here".
6158 * \param [in] nbOfTuple - number of tuples of data to allocate.
6159 * \param [in] nbOfCompo - number of components of data to allocate.
6160 * \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
6162 void DataArrayInt::alloc(int nbOfTuple, int nbOfCompo)
6164 if(nbOfTuple<0 || nbOfCompo<0)
6165 throw INTERP_KERNEL::Exception("DataArrayInt::alloc : request for negative length of data !");
6166 _info_on_compo.resize(nbOfCompo);
6167 _mem.alloc(nbOfCompo*(std::size_t)nbOfTuple);
6172 * Assign zero to all values in \a this array. To know more on filling arrays see
6173 * \ref MEDCouplingArrayFill.
6174 * \throw If \a this is not allocated.
6176 void DataArrayInt::fillWithZero()
6179 _mem.fillWithValue(0);
6184 * Assign \a val to all values in \a this array. To know more on filling arrays see
6185 * \ref MEDCouplingArrayFill.
6186 * \param [in] val - the value to fill with.
6187 * \throw If \a this is not allocated.
6189 void DataArrayInt::fillWithValue(int val)
6192 _mem.fillWithValue(val);
6197 * Set all values in \a this array so that the i-th element equals to \a init + i
6198 * (i starts from zero). To know more on filling arrays see \ref MEDCouplingArrayFill.
6199 * \param [in] init - value to assign to the first element of array.
6200 * \throw If \a this->getNumberOfComponents() != 1
6201 * \throw If \a this is not allocated.
6203 void DataArrayInt::iota(int init)
6206 if(getNumberOfComponents()!=1)
6207 throw INTERP_KERNEL::Exception("DataArrayInt::iota : works only for arrays with only one component, you can call 'rearrange' method before !");
6208 int *ptr=getPointer();
6209 int ntuples=getNumberOfTuples();
6210 for(int i=0;i<ntuples;i++)
6216 * Returns a textual and human readable representation of \a this instance of
6217 * DataArrayInt. This text is shown when a DataArrayInt is printed in Python.
6218 * \return std::string - text describing \a this DataArrayInt.
6220 * \sa reprNotTooLong, reprZip
6222 std::string DataArrayInt::repr() const
6224 std::ostringstream ret;
6229 std::string DataArrayInt::reprZip() const
6231 std::ostringstream ret;
6237 * This method is close to repr method except that when \a this has more than 1000 tuples, all tuples are not
6238 * printed out to avoid to consume too much space in interpretor.
6241 std::string DataArrayInt::reprNotTooLong() const
6243 std::ostringstream ret;
6244 reprNotTooLongStream(ret);
6248 void DataArrayInt::writeVTK(std::ostream& ofs, int indent, const std::string& type, const std::string& nameInFile, DataArrayByte *byteArr) const
6250 static const char SPACE[4]={' ',' ',' ',' '};
6252 std::string idt(indent,' ');
6253 ofs << idt << "<DataArray type=\"" << type << "\" Name=\"" << nameInFile << "\" NumberOfComponents=\"" << getNumberOfComponents() << "\"";
6256 ofs << " format=\"appended\" offset=\"" << byteArr->getNumberOfTuples() << "\">";
6257 if(std::string(type)=="Int32")
6259 const char *data(reinterpret_cast<const char *>(begin()));
6260 std::size_t sz(getNbOfElems()*sizeof(int));
6261 byteArr->insertAtTheEnd(data,data+sz);
6262 byteArr->insertAtTheEnd(SPACE,SPACE+4);
6264 else if(std::string(type)=="Int8")
6266 INTERP_KERNEL::AutoPtr<char> tmp(new char[getNbOfElems()]);
6267 std::copy(begin(),end(),(char *)tmp);
6268 byteArr->insertAtTheEnd((char *)tmp,(char *)tmp+getNbOfElems());
6269 byteArr->insertAtTheEnd(SPACE,SPACE+4);
6271 else if(std::string(type)=="UInt8")
6273 INTERP_KERNEL::AutoPtr<unsigned char> tmp(new unsigned char[getNbOfElems()]);
6274 std::copy(begin(),end(),(unsigned char *)tmp);
6275 byteArr->insertAtTheEnd((unsigned char *)tmp,(unsigned char *)tmp+getNbOfElems());
6276 byteArr->insertAtTheEnd(SPACE,SPACE+4);
6279 throw INTERP_KERNEL::Exception("DataArrayInt::writeVTK : Only Int32, Int8 and UInt8 supported !");
6283 ofs << " RangeMin=\"" << getMinValueInArray() << "\" RangeMax=\"" << getMaxValueInArray() << "\" format=\"ascii\">\n" << idt;
6284 std::copy(begin(),end(),std::ostream_iterator<int>(ofs," "));
6286 ofs << std::endl << idt << "</DataArray>\n";
6289 void DataArrayInt::reprStream(std::ostream& stream) const
6291 stream << "Name of int array : \"" << _name << "\"\n";
6292 reprWithoutNameStream(stream);
6295 void DataArrayInt::reprZipStream(std::ostream& stream) const
6297 stream << "Name of int array : \"" << _name << "\"\n";
6298 reprZipWithoutNameStream(stream);
6301 void DataArrayInt::reprNotTooLongStream(std::ostream& stream) const
6303 stream << "Name of int array : \"" << _name << "\"\n";
6304 reprNotTooLongWithoutNameStream(stream);
6307 void DataArrayInt::reprWithoutNameStream(std::ostream& stream) const
6309 DataArray::reprWithoutNameStream(stream);
6310 _mem.repr(getNumberOfComponents(),stream);
6313 void DataArrayInt::reprZipWithoutNameStream(std::ostream& stream) const
6315 DataArray::reprWithoutNameStream(stream);
6316 _mem.reprZip(getNumberOfComponents(),stream);
6319 void DataArrayInt::reprNotTooLongWithoutNameStream(std::ostream& stream) const
6321 DataArray::reprWithoutNameStream(stream);
6322 stream.precision(17);
6323 _mem.reprNotTooLong(getNumberOfComponents(),stream);
6326 void DataArrayInt::reprCppStream(const std::string& varName, std::ostream& stream) const
6328 int nbTuples=getNumberOfTuples(),nbComp=getNumberOfComponents();
6329 const int *data=getConstPointer();
6330 stream << "DataArrayInt *" << varName << "=DataArrayInt::New();" << std::endl;
6331 if(nbTuples*nbComp>=1)
6333 stream << "const int " << varName << "Data[" << nbTuples*nbComp << "]={";
6334 std::copy(data,data+nbTuples*nbComp-1,std::ostream_iterator<int>(stream,","));
6335 stream << data[nbTuples*nbComp-1] << "};" << std::endl;
6336 stream << varName << "->useArray(" << varName << "Data,false,CPP_DEALLOC," << nbTuples << "," << nbComp << ");" << std::endl;
6339 stream << varName << "->alloc(" << nbTuples << "," << nbComp << ");" << std::endl;
6340 stream << varName << "->setName(\"" << getName() << "\");" << std::endl;
6344 * Method that gives a quick overvien of \a this for python.
6346 void DataArrayInt::reprQuickOverview(std::ostream& stream) const
6348 static const std::size_t MAX_NB_OF_BYTE_IN_REPR=300;
6349 stream << "DataArrayInt C++ instance at " << this << ". ";
6352 int nbOfCompo=(int)_info_on_compo.size();
6355 int nbOfTuples=getNumberOfTuples();
6356 stream << "Number of tuples : " << nbOfTuples << ". Number of components : " << nbOfCompo << "." << std::endl;
6357 reprQuickOverviewData(stream,MAX_NB_OF_BYTE_IN_REPR);
6360 stream << "Number of components : 0.";
6363 stream << "*** No data allocated ****";
6366 void DataArrayInt::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const
6368 const int *data=begin();
6369 int nbOfTuples=getNumberOfTuples();
6370 int nbOfCompo=(int)_info_on_compo.size();
6371 std::ostringstream oss2; oss2 << "[";
6372 std::string oss2Str(oss2.str());
6373 bool isFinished=true;
6374 for(int i=0;i<nbOfTuples && isFinished;i++)
6379 for(int j=0;j<nbOfCompo;j++,data++)
6382 if(j!=nbOfCompo-1) oss2 << ", ";
6388 if(i!=nbOfTuples-1) oss2 << ", ";
6389 std::string oss3Str(oss2.str());
6390 if(oss3Str.length()<maxNbOfByteInRepr)
6402 * Modifies in place \a this one-dimensional array so that each value \a v = \a indArrBg[ \a v ],
6403 * i.e. a current value is used as in index to get a new value from \a indArrBg.
6404 * \param [in] indArrBg - pointer to the first element of array of new values to assign
6406 * \param [in] indArrEnd - specifies the end of the array \a indArrBg, so that
6407 * the last value of \a indArrBg is \a indArrEnd[ -1 ].
6408 * \throw If \a this->getNumberOfComponents() != 1
6409 * \throw If any value of \a this can't be used as a valid index for
6410 * [\a indArrBg, \a indArrEnd).
6412 * \sa replaceOneValByInThis
6414 void DataArrayInt::transformWithIndArr(const int *indArrBg, const int *indArrEnd)
6417 if(getNumberOfComponents()!=1)
6418 throw INTERP_KERNEL::Exception("Call transformWithIndArr method on DataArrayInt with only one component, you can call 'rearrange' method before !");
6419 int nbElemsIn((int)std::distance(indArrBg,indArrEnd)),nbOfTuples(getNumberOfTuples()),*pt(getPointer());
6420 for(int i=0;i<nbOfTuples;i++,pt++)
6422 if(*pt>=0 && *pt<nbElemsIn)
6426 std::ostringstream oss; oss << "DataArrayInt::transformWithIndArr : error on tuple #" << i << " of this value is " << *pt << ", should be in [0," << nbElemsIn << ") !";
6427 throw INTERP_KERNEL::Exception(oss.str().c_str());
6434 * Modifies in place \a this one-dimensional array like this : each id in \a this so that this[id] equal to \a valToBeReplaced will be replaced at the same place by \a replacedBy.
6436 * \param [in] valToBeReplaced - the value in \a this to be replaced.
6437 * \param [in] replacedBy - the value taken by each tuple previously equal to \a valToBeReplaced.
6439 * \sa DataArrayInt::transformWithIndArr
6441 void DataArrayInt::replaceOneValByInThis(int valToBeReplaced, int replacedBy)
6444 if(getNumberOfComponents()!=1)
6445 throw INTERP_KERNEL::Exception("Call replaceOneValByInThis method on DataArrayInt with only one component, you can call 'rearrange' method before !");
6446 if(valToBeReplaced==replacedBy)
6448 int nbOfTuples(getNumberOfTuples()),*pt(getPointer());
6449 for(int i=0;i<nbOfTuples;i++,pt++)
6451 if(*pt==valToBeReplaced)
6457 * Computes distribution of values of \a this one-dimensional array between given value
6458 * ranges (casts). This method is typically useful for entity number spliting by types,
6460 * \warning The values contained in \a arrBg should be sorted ascendently. No
6461 * check of this is be done. If not, the result is not warranted.
6462 * \param [in] arrBg - the array of ascending values defining the value ranges. The i-th
6463 * value of \a arrBg (\a arrBg[ i ]) gives the lowest value of the i-th range,
6464 * and the greatest value of the i-th range equals to \a arrBg[ i+1 ] - 1. \a
6465 * arrBg containing \a n values defines \a n-1 ranges. The last value of \a arrBg
6466 * should be more than every value in \a this array.
6467 * \param [in] arrEnd - specifies the end of the array \a arrBg, so that
6468 * the last value of \a arrBg is \a arrEnd[ -1 ].
6469 * \param [out] castArr - a new instance of DataArrayInt, of same size as \a this array
6470 * (same number of tuples and components), the caller is to delete
6471 * using decrRef() as it is no more needed.
6472 * This array contains indices of ranges for every value of \a this array. I.e.
6473 * the i-th value of \a castArr gives the index of range the i-th value of \a this
6474 * belongs to. Or, in other words, this parameter contains for each tuple in \a
6475 * this in which cast it holds.
6476 * \param [out] rankInsideCast - a new instance of DataArrayInt, of same size as \a this
6477 * array, the caller is to delete using decrRef() as it is no more needed.
6478 * This array contains ranks of values of \a this array within ranges
6479 * they belongs to. I.e. the i-th value of \a rankInsideCast gives the rank of
6480 * the i-th value of \a this array within the \a castArr[ i ]-th range, to which
6481 * the i-th value of \a this belongs to. Or, in other words, this param contains
6482 * for each tuple its rank inside its cast. The rank is computed as difference
6483 * between the value and the lowest value of range.
6484 * \param [out] castsPresent - a new instance of DataArrayInt, containing indices of
6485 * ranges (casts) to which at least one value of \a this array belongs.
6486 * Or, in other words, this param contains the casts that \a this contains.
6487 * The caller is to delete this array using decrRef() as it is no more needed.
6489 * \b Example: If \a this contains [6,5,0,3,2,7,8,1,4] and \a arrBg contains [0,4,9] then
6490 * the output of this method will be :
6491 * - \a castArr : [1,1,0,0,0,1,1,0,1]
6492 * - \a rankInsideCast: [2,1,0,3,2,3,4,1,0]
6493 * - \a castsPresent : [0,1]
6495 * I.e. values of \a this array belong to 2 ranges: #0 and #1. Value 6 belongs to the
6496 * range #1 and its rank within this range is 2; etc.
6498 * \throw If \a this->getNumberOfComponents() != 1.
6499 * \throw If \a arrEnd - arrBg < 2.
6500 * \throw If any value of \a this is not less than \a arrEnd[-1].
6502 void DataArrayInt::splitByValueRange(const int *arrBg, const int *arrEnd,
6503 DataArrayInt *& castArr, DataArrayInt *& rankInsideCast, DataArrayInt *& castsPresent) const
6506 if(getNumberOfComponents()!=1)
6507 throw INTERP_KERNEL::Exception("Call splitByValueRange method on DataArrayInt with only one component, you can call 'rearrange' method before !");
6508 int nbOfTuples=getNumberOfTuples();
6509 std::size_t nbOfCast=std::distance(arrBg,arrEnd);
6511 throw INTERP_KERNEL::Exception("DataArrayInt::splitByValueRange : The input array giving the cast range values should be of size >=2 !");
6513 const int *work=getConstPointer();
6514 typedef std::reverse_iterator<const int *> rintstart;
6515 rintstart bg(arrEnd);//OK no problem because size of 'arr' is greater or equal 2
6516 rintstart end2(arrBg);
6517 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New();
6518 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret2=DataArrayInt::New();
6519 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret3=DataArrayInt::New();
6520 ret1->alloc(nbOfTuples,1);
6521 ret2->alloc(nbOfTuples,1);
6522 int *ret1Ptr=ret1->getPointer();
6523 int *ret2Ptr=ret2->getPointer();
6524 std::set<std::size_t> castsDetected;
6525 for(int i=0;i<nbOfTuples;i++)
6527 rintstart res=std::find_if(bg,end2,std::bind2nd(std::less_equal<int>(), work[i]));
6528 std::size_t pos=std::distance(bg,res);
6529 std::size_t pos2=nbOfCast-pos;
6532 ret1Ptr[i]=(int)pos2;
6533 ret2Ptr[i]=work[i]-arrBg[pos2];
6534 castsDetected.insert(pos2);
6538 std::ostringstream oss; oss << "DataArrayInt::splitByValueRange : At rank #" << i << " the value is " << work[i] << " should be in [0," << *bg << ") !";
6539 throw INTERP_KERNEL::Exception(oss.str().c_str());
6542 ret3->alloc((int)castsDetected.size(),1);
6543 std::copy(castsDetected.begin(),castsDetected.end(),ret3->getPointer());
6544 castArr=ret1.retn();
6545 rankInsideCast=ret2.retn();
6546 castsPresent=ret3.retn();
6550 * This method look at \a this if it can be considered as a range defined by the 3-tuple ( \a strt , \a sttoopp , \a stteepp ).
6551 * If false is returned the tuple must be ignored. If true is returned \a this can be considered by a range( \a strt , \a sttoopp , \a stteepp ).
6552 * This method works only if \a this is allocated and single component. If not an exception will be thrown.
6554 * \param [out] strt - the start of the range (included) if true is returned.
6555 * \param [out] sttoopp - the end of the range (not included) if true is returned.
6556 * \param [out] stteepp - the step of the range if true is returned.
6557 * \return the verdict of the check.
6559 * \sa DataArray::GetNumberOfItemGivenBES
6561 bool DataArrayInt::isRange(int& strt, int& sttoopp, int& stteepp) const
6564 if(getNumberOfComponents()!=1)
6565 throw INTERP_KERNEL::Exception("DataArrayInt::isRange : this must be single component array !");
6566 int nbTuples(getNumberOfTuples());
6568 { strt=0; sttoopp=0; stteepp=1; return true; }
6569 const int *pt(begin());
6572 { sttoopp=strt+1; stteepp=1; return true; }
6573 strt=*pt; sttoopp=pt[nbTuples-1];
6579 int a(sttoopp-1-strt),tmp(strt);
6580 if(a%(nbTuples-1)!=0)
6582 stteepp=a/(nbTuples-1);
6583 for(int i=0;i<nbTuples;i++,tmp+=stteepp)
6591 int a(strt-sttoopp-1),tmp(strt);
6592 if(a%(nbTuples-1)!=0)
6594 stteepp=-(a/(nbTuples-1));
6595 for(int i=0;i<nbTuples;i++,tmp+=stteepp)
6603 * Creates a one-dimensional DataArrayInt (\a res) whose contents are computed from
6604 * values of \a this (\a a) and the given (\a indArr) arrays as follows:
6605 * \a res[ \a indArr[ \a a[ i ]]] = i. I.e. for each value in place i \a v = \a a[ i ],
6606 * new value in place \a indArr[ \a v ] is i.
6607 * \param [in] indArrBg - the array holding indices within the result array to assign
6608 * indices of values of \a this array pointing to values of \a indArrBg.
6609 * \param [in] indArrEnd - specifies the end of the array \a indArrBg, so that
6610 * the last value of \a indArrBg is \a indArrEnd[ -1 ].
6611 * \return DataArrayInt * - the new instance of DataArrayInt.
6612 * The caller is to delete this result array using decrRef() as it is no more
6614 * \throw If \a this->getNumberOfComponents() != 1.
6615 * \throw If any value of \a this array is not a valid index for \a indArrBg array.
6616 * \throw If any value of \a indArrBg is not a valid index for \a this array.
6618 DataArrayInt *DataArrayInt::transformWithIndArrR(const int *indArrBg, const int *indArrEnd) const
6621 if(getNumberOfComponents()!=1)
6622 throw INTERP_KERNEL::Exception("Call transformWithIndArrR method on DataArrayInt with only one component, you can call 'rearrange' method before !");
6623 int nbElemsIn=(int)std::distance(indArrBg,indArrEnd);
6624 int nbOfTuples=getNumberOfTuples();
6625 const int *pt=getConstPointer();
6626 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6627 ret->alloc(nbOfTuples,1);
6628 ret->fillWithValue(-1);
6629 int *tmp=ret->getPointer();
6630 for(int i=0;i<nbOfTuples;i++,pt++)
6632 if(*pt>=0 && *pt<nbElemsIn)
6634 int pos=indArrBg[*pt];
6635 if(pos>=0 && pos<nbOfTuples)
6639 std::ostringstream oss; oss << "DataArrayInt::transformWithIndArrR : error on tuple #" << i << " value of new pos is " << pos << " ( indArrBg[" << *pt << "]) ! Should be in [0," << nbOfTuples << ") !";
6640 throw INTERP_KERNEL::Exception(oss.str().c_str());
6645 std::ostringstream oss; oss << "DataArrayInt::transformWithIndArrR : error on tuple #" << i << " value is " << *pt << " and indirectionnal array as a size equal to " << nbElemsIn << " !";
6646 throw INTERP_KERNEL::Exception(oss.str().c_str());
6653 * Creates a one-dimensional DataArrayInt of given length, whose contents are computed
6654 * from values of \a this array, which is supposed to contain a renumbering map in
6655 * "Old to New" mode. The result array contains a renumbering map in "New to Old" mode.
6656 * To know how to use the renumbering maps see \ref MEDCouplingArrayRenumbering.
6657 * \param [in] newNbOfElem - the number of tuples in the result array.
6658 * \return DataArrayInt * - the new instance of DataArrayInt.
6659 * The caller is to delete this result array using decrRef() as it is no more
6662 * \if ENABLE_EXAMPLES
6663 * \ref cpp_mcdataarrayint_invertarrayo2n2n2o "Here is a C++ example".<br>
6664 * \ref py_mcdataarrayint_invertarrayo2n2n2o "Here is a Python example".
6667 DataArrayInt *DataArrayInt::invertArrayO2N2N2O(int newNbOfElem) const
6669 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6670 ret->alloc(newNbOfElem,1);
6671 int nbOfOldNodes=getNumberOfTuples();
6672 const int *old2New=getConstPointer();
6673 int *pt=ret->getPointer();
6674 for(int i=0;i!=nbOfOldNodes;i++)
6676 int newp(old2New[i]);
6679 if(newp>=0 && newp<newNbOfElem)
6683 std::ostringstream oss; oss << "DataArrayInt::invertArrayO2N2N2O : At place #" << i << " the newplace is " << newp << " must be in [0," << newNbOfElem << ") !";
6684 throw INTERP_KERNEL::Exception(oss.str().c_str());
6692 * This method is similar to DataArrayInt::invertArrayO2N2N2O except that
6693 * Example : If \a this contains [0,1,2,0,3,4,5,4,6,4] this method will return [0,1,2,4,5,6,8] whereas DataArrayInt::invertArrayO2N2N2O returns [3,1,2,4,9,6,8]
6695 DataArrayInt *DataArrayInt::invertArrayO2N2N2OBis(int newNbOfElem) const
6697 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6698 ret->alloc(newNbOfElem,1);
6699 int nbOfOldNodes=getNumberOfTuples();
6700 const int *old2New=getConstPointer();
6701 int *pt=ret->getPointer();
6702 for(int i=nbOfOldNodes-1;i>=0;i--)
6704 int newp(old2New[i]);
6707 if(newp>=0 && newp<newNbOfElem)
6711 std::ostringstream oss; oss << "DataArrayInt::invertArrayO2N2N2OBis : At place #" << i << " the newplace is " << newp << " must be in [0," << newNbOfElem << ") !";
6712 throw INTERP_KERNEL::Exception(oss.str().c_str());
6720 * Creates a one-dimensional DataArrayInt of given length, whose contents are computed
6721 * from values of \a this array, which is supposed to contain a renumbering map in
6722 * "New to Old" mode. The result array contains a renumbering map in "Old to New" mode.
6723 * To know how to use the renumbering maps see \ref MEDCouplingArrayRenumbering.
6724 * \param [in] newNbOfElem - the number of tuples in the result array.
6725 * \return DataArrayInt * - the new instance of DataArrayInt.
6726 * The caller is to delete this result array using decrRef() as it is no more
6729 * \if ENABLE_EXAMPLES
6730 * \ref cpp_mcdataarrayint_invertarrayn2o2o2n "Here is a C++ example".
6732 * \ref py_mcdataarrayint_invertarrayn2o2o2n "Here is a Python example".
6735 DataArrayInt *DataArrayInt::invertArrayN2O2O2N(int oldNbOfElem) const
6738 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6739 ret->alloc(oldNbOfElem,1);
6740 const int *new2Old=getConstPointer();
6741 int *pt=ret->getPointer();
6742 std::fill(pt,pt+oldNbOfElem,-1);
6743 int nbOfNewElems=getNumberOfTuples();
6744 for(int i=0;i<nbOfNewElems;i++)
6747 if(v>=0 && v<oldNbOfElem)
6751 std::ostringstream oss; oss << "DataArrayInt::invertArrayN2O2O2N : in new id #" << i << " old value is " << v << " expected to be in [0," << oldNbOfElem << ") !";
6752 throw INTERP_KERNEL::Exception(oss.str().c_str());
6759 * Equivalent to DataArrayInt::isEqual except that if false the reason of
6760 * mismatch is given.
6762 * \param [in] other the instance to be compared with \a this
6763 * \param [out] reason In case of inequality returns the reason.
6764 * \sa DataArrayInt::isEqual
6766 bool DataArrayInt::isEqualIfNotWhy(const DataArrayInt& other, std::string& reason) const
6768 if(!areInfoEqualsIfNotWhy(other,reason))
6770 return _mem.isEqual(other._mem,0,reason);
6774 * Checks if \a this and another DataArrayInt are fully equal. For more info see
6775 * \ref MEDCouplingArrayBasicsCompare.
6776 * \param [in] other - an instance of DataArrayInt to compare with \a this one.
6777 * \return bool - \a true if the two arrays are equal, \a false else.
6779 bool DataArrayInt::isEqual(const DataArrayInt& other) const
6782 return isEqualIfNotWhy(other,tmp);
6786 * Checks if values of \a this and another DataArrayInt are equal. For more info see
6787 * \ref MEDCouplingArrayBasicsCompare.
6788 * \param [in] other - an instance of DataArrayInt to compare with \a this one.
6789 * \return bool - \a true if the values of two arrays are equal, \a false else.
6791 bool DataArrayInt::isEqualWithoutConsideringStr(const DataArrayInt& other) const
6794 return _mem.isEqual(other._mem,0,tmp);
6798 * Checks if values of \a this and another DataArrayInt are equal. Comparison is
6799 * performed on sorted value sequences.
6800 * For more info see\ref MEDCouplingArrayBasicsCompare.
6801 * \param [in] other - an instance of DataArrayInt to compare with \a this one.
6802 * \return bool - \a true if the sorted values of two arrays are equal, \a false else.
6804 bool DataArrayInt::isEqualWithoutConsideringStrAndOrder(const DataArrayInt& other) const
6806 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> a=deepCpy();
6807 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> b=other.deepCpy();
6810 return a->isEqualWithoutConsideringStr(*b);
6814 * This method compares content of input vector \a v and \a this.
6815 * If for each id in \a this v[id]==True and for all other ids id2 not in \a this v[id2]==False, true is returned.
6816 * For performance reasons \a this is expected to be sorted ascendingly. If not an exception will be thrown.
6818 * \param [in] v - the vector of 'flags' to be compared with \a this.
6820 * \throw If \a this is not sorted ascendingly.
6821 * \throw If \a this has not exactly one component.
6822 * \throw If \a this is not allocated.
6824 bool DataArrayInt::isFittingWith(const std::vector<bool>& v) const
6827 if(getNumberOfComponents()!=1)
6828 throw INTERP_KERNEL::Exception("DataArrayInt::isFittingWith : number of components of this should be equal to one !");
6829 const int *w(begin()),*end2(end());
6830 int refVal=-std::numeric_limits<int>::max();
6832 std::vector<bool>::const_iterator it(v.begin());
6833 for(;it!=v.end();it++,i++)
6845 std::ostringstream oss; oss << "DataArrayInt::isFittingWith : At pos #" << std::distance(begin(),w-1) << " this is not sorted ascendingly !";
6846 throw INTERP_KERNEL::Exception(oss.str().c_str());
6860 * 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
6861 * put True to the corresponding entry in \a vec.
6862 * \a vec is expected to be with the same size than the number of tuples of \a this.
6864 void DataArrayInt::switchOnTupleEqualTo(int val, std::vector<bool>& vec) const
6867 if(getNumberOfComponents()!=1)
6868 throw INTERP_KERNEL::Exception("DataArrayInt::switchOnTupleEqualTo : number of components of this should be equal to one !");
6869 int nbOfTuples(getNumberOfTuples());
6870 if(nbOfTuples!=(int)vec.size())
6871 throw INTERP_KERNEL::Exception("DataArrayInt::switchOnTupleEqualTo : number of tuples of this should be equal to size of input vector of bool !");
6872 const int *pt(begin());
6873 for(int i=0;i<nbOfTuples;i++)
6879 * Sorts values of the array.
6880 * \param [in] asc - \a true means ascending order, \a false, descending.
6881 * \throw If \a this is not allocated.
6882 * \throw If \a this->getNumberOfComponents() != 1.
6884 void DataArrayInt::sort(bool asc)
6887 if(getNumberOfComponents()!=1)
6888 throw INTERP_KERNEL::Exception("DataArrayInt::sort : only supported with 'this' array with ONE component !");
6894 * Computes for each tuple the sum of number of components values in the tuple and return it.
6896 * \return DataArrayInt * - the new instance of DataArrayInt containing the
6897 * same number of tuples as \a this array and one component.
6898 * The caller is to delete this result array using decrRef() as it is no more
6900 * \throw If \a this is not allocated.
6902 DataArrayInt *DataArrayInt::sumPerTuple() const
6905 int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
6906 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
6907 ret->alloc(nbOfTuple,1);
6908 const int *src(getConstPointer());
6909 int *dest(ret->getPointer());
6910 for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
6911 *dest=std::accumulate(src,src+nbOfComp,0);
6916 * Reverse the array values.
6917 * \throw If \a this->getNumberOfComponents() < 1.
6918 * \throw If \a this is not allocated.
6920 void DataArrayInt::reverse()
6923 _mem.reverse(getNumberOfComponents());
6928 * Checks that \a this array is consistently **increasing** or **decreasing** in value.
6929 * If not an exception is thrown.
6930 * \param [in] increasing - if \a true, the array values should be increasing.
6931 * \throw If sequence of values is not strictly monotonic in agreement with \a
6933 * \throw If \a this->getNumberOfComponents() != 1.
6934 * \throw If \a this is not allocated.
6936 void DataArrayInt::checkMonotonic(bool increasing) const
6938 if(!isMonotonic(increasing))
6941 throw INTERP_KERNEL::Exception("DataArrayInt::checkMonotonic : 'this' is not INCREASING monotonic !");
6943 throw INTERP_KERNEL::Exception("DataArrayInt::checkMonotonic : 'this' is not DECREASING monotonic !");
6948 * Checks that \a this array is consistently **increasing** or **decreasing** in value.
6949 * \param [in] increasing - if \a true, array values should be increasing.
6950 * \return bool - \a true if values change in accordance with \a increasing arg.
6951 * \throw If \a this->getNumberOfComponents() != 1.
6952 * \throw If \a this is not allocated.
6954 bool DataArrayInt::isMonotonic(bool increasing) const
6957 if(getNumberOfComponents()!=1)
6958 throw INTERP_KERNEL::Exception("DataArrayInt::isMonotonic : only supported with 'this' array with ONE component !");
6959 int nbOfElements=getNumberOfTuples();
6960 const int *ptr=getConstPointer();
6966 for(int i=1;i<nbOfElements;i++)
6976 for(int i=1;i<nbOfElements;i++)
6988 * This method check that array consistently INCREASING or DECREASING in value.
6990 bool DataArrayInt::isStrictlyMonotonic(bool increasing) const
6993 if(getNumberOfComponents()!=1)
6994 throw INTERP_KERNEL::Exception("DataArrayInt::isStrictlyMonotonic : only supported with 'this' array with ONE component !");
6995 int nbOfElements=getNumberOfTuples();
6996 const int *ptr=getConstPointer();
7002 for(int i=1;i<nbOfElements;i++)
7012 for(int i=1;i<nbOfElements;i++)
7024 * This method check that array consistently INCREASING or DECREASING in value.
7026 void DataArrayInt::checkStrictlyMonotonic(bool increasing) const
7028 if(!isStrictlyMonotonic(increasing))
7031 throw INTERP_KERNEL::Exception("DataArrayInt::checkStrictlyMonotonic : 'this' is not strictly INCREASING monotonic !");
7033 throw INTERP_KERNEL::Exception("DataArrayInt::checkStrictlyMonotonic : 'this' is not strictly DECREASING monotonic !");
7038 * Creates a new one-dimensional DataArrayInt of the same size as \a this and a given
7039 * one-dimensional arrays that must be of the same length. The result array describes
7040 * correspondence between \a this and \a other arrays, so that
7041 * <em> other.getIJ(i,0) == this->getIJ(ret->getIJ(i),0)</em>. If such a permutation is
7042 * not possible because some element in \a other is not in \a this, an exception is thrown.
7043 * \param [in] other - an array to compute permutation to.
7044 * \return DataArrayInt * - a new instance of DataArrayInt, which is a permutation array
7045 * from \a this to \a other. The caller is to delete this array using decrRef() as it is
7047 * \throw If \a this->getNumberOfComponents() != 1.
7048 * \throw If \a other->getNumberOfComponents() != 1.
7049 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples().
7050 * \throw If \a other includes a value which is not in \a this array.
7052 * \if ENABLE_EXAMPLES
7053 * \ref cpp_mcdataarrayint_buildpermutationarr "Here is a C++ example".
7055 * \ref py_mcdataarrayint_buildpermutationarr "Here is a Python example".
7058 DataArrayInt *DataArrayInt::buildPermutationArr(const DataArrayInt& other) const
7061 if(getNumberOfComponents()!=1 || other.getNumberOfComponents()!=1)
7062 throw INTERP_KERNEL::Exception("DataArrayInt::buildPermutationArr : 'this' and 'other' have to have exactly ONE component !");
7063 int nbTuple=getNumberOfTuples();
7064 other.checkAllocated();
7065 if(nbTuple!=other.getNumberOfTuples())
7066 throw INTERP_KERNEL::Exception("DataArrayInt::buildPermutationArr : 'this' and 'other' must have the same number of tuple !");
7067 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7068 ret->alloc(nbTuple,1);
7069 ret->fillWithValue(-1);
7070 const int *pt=getConstPointer();
7071 std::map<int,int> mm;
7072 for(int i=0;i<nbTuple;i++)
7074 pt=other.getConstPointer();
7075 int *retToFill=ret->getPointer();
7076 for(int i=0;i<nbTuple;i++)
7078 std::map<int,int>::const_iterator it=mm.find(pt[i]);
7081 std::ostringstream oss; oss << "DataArrayInt::buildPermutationArr : Arrays mismatch : element (" << pt[i] << ") in 'other' not findable in 'this' !";
7082 throw INTERP_KERNEL::Exception(oss.str().c_str());
7084 retToFill[i]=(*it).second;
7090 * Sets a C array to be used as raw data of \a this. The previously set info
7091 * of components is retained and re-sized.
7092 * For more info see \ref MEDCouplingArraySteps1.
7093 * \param [in] array - the C array to be used as raw data of \a this.
7094 * \param [in] ownership - if \a true, \a array will be deallocated at destruction of \a this.
7095 * \param [in] type - specifies how to deallocate \a array. If \a type == ParaMEDMEM::CPP_DEALLOC,
7096 * \c delete [] \c array; will be called. If \a type == ParaMEDMEM::C_DEALLOC,
7097 * \c free(\c array ) will be called.
7098 * \param [in] nbOfTuple - new number of tuples in \a this.
7099 * \param [in] nbOfCompo - new number of components in \a this.
7101 void DataArrayInt::useArray(const int *array, bool ownership, DeallocType type, int nbOfTuple, int nbOfCompo)
7103 _info_on_compo.resize(nbOfCompo);
7104 _mem.useArray(array,ownership,type,nbOfTuple*nbOfCompo);
7108 void DataArrayInt::useExternalArrayWithRWAccess(const int *array, int nbOfTuple, int nbOfCompo)
7110 _info_on_compo.resize(nbOfCompo);
7111 _mem.useExternalArrayWithRWAccess(array,nbOfTuple*nbOfCompo);
7116 * Returns a new DataArrayInt holding the same values as \a this array but differently
7117 * arranged in memory. If \a this array holds 2 components of 3 values:
7118 * \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$, then the result array holds these values arranged
7119 * as follows: \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$.
7120 * \warning Do not confuse this method with transpose()!
7121 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7122 * is to delete using decrRef() as it is no more needed.
7123 * \throw If \a this is not allocated.
7125 DataArrayInt *DataArrayInt::fromNoInterlace() const
7129 throw INTERP_KERNEL::Exception("DataArrayInt::fromNoInterlace : Not defined array !");
7130 int *tab=_mem.fromNoInterlace(getNumberOfComponents());
7131 DataArrayInt *ret=DataArrayInt::New();
7132 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
7137 * Returns a new DataArrayInt holding the same values as \a this array but differently
7138 * arranged in memory. If \a this array holds 2 components of 3 values:
7139 * \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$, then the result array holds these values arranged
7140 * as follows: \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$.
7141 * \warning Do not confuse this method with transpose()!
7142 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7143 * is to delete using decrRef() as it is no more needed.
7144 * \throw If \a this is not allocated.
7146 DataArrayInt *DataArrayInt::toNoInterlace() const
7150 throw INTERP_KERNEL::Exception("DataArrayInt::toNoInterlace : Not defined array !");
7151 int *tab=_mem.toNoInterlace(getNumberOfComponents());
7152 DataArrayInt *ret=DataArrayInt::New();
7153 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
7158 * Permutes values of \a this array as required by \a old2New array. The values are
7159 * permuted so that \c new[ \a old2New[ i ]] = \c old[ i ]. Number of tuples remains
7160 * the same as in \this one.
7161 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
7162 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7163 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
7164 * giving a new position for i-th old value.
7166 void DataArrayInt::renumberInPlace(const int *old2New)
7169 int nbTuples=getNumberOfTuples();
7170 int nbOfCompo=getNumberOfComponents();
7171 int *tmp=new int[nbTuples*nbOfCompo];
7172 const int *iptr=getConstPointer();
7173 for(int i=0;i<nbTuples;i++)
7176 if(v>=0 && v<nbTuples)
7177 std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),tmp+nbOfCompo*v);
7180 std::ostringstream oss; oss << "DataArrayInt::renumberInPlace : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
7181 throw INTERP_KERNEL::Exception(oss.str().c_str());
7184 std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
7190 * Permutes values of \a this array as required by \a new2Old array. The values are
7191 * permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of tuples remains
7192 * the same as in \this one.
7193 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7194 * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
7195 * giving a previous position of i-th new value.
7196 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7197 * is to delete using decrRef() as it is no more needed.
7199 void DataArrayInt::renumberInPlaceR(const int *new2Old)
7202 int nbTuples=getNumberOfTuples();
7203 int nbOfCompo=getNumberOfComponents();
7204 int *tmp=new int[nbTuples*nbOfCompo];
7205 const int *iptr=getConstPointer();
7206 for(int i=0;i<nbTuples;i++)
7209 if(v>=0 && v<nbTuples)
7210 std::copy(iptr+nbOfCompo*v,iptr+nbOfCompo*(v+1),tmp+nbOfCompo*i);
7213 std::ostringstream oss; oss << "DataArrayInt::renumberInPlaceR : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
7214 throw INTERP_KERNEL::Exception(oss.str().c_str());
7217 std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
7223 * Returns a copy of \a this array with values permuted as required by \a old2New array.
7224 * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ].
7225 * Number of tuples in the result array remains the same as in \this one.
7226 * If a permutation reduction is needed, renumberAndReduce() should be used.
7227 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7228 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
7229 * giving a new position for i-th old value.
7230 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7231 * is to delete using decrRef() as it is no more needed.
7232 * \throw If \a this is not allocated.
7234 DataArrayInt *DataArrayInt::renumber(const int *old2New) const
7237 int nbTuples=getNumberOfTuples();
7238 int nbOfCompo=getNumberOfComponents();
7239 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7240 ret->alloc(nbTuples,nbOfCompo);
7241 ret->copyStringInfoFrom(*this);
7242 const int *iptr=getConstPointer();
7243 int *optr=ret->getPointer();
7244 for(int i=0;i<nbTuples;i++)
7245 std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),optr+nbOfCompo*old2New[i]);
7246 ret->copyStringInfoFrom(*this);
7251 * Returns a copy of \a this array with values permuted as required by \a new2Old array.
7252 * The values are permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of
7253 * tuples in the result array remains the same as in \this one.
7254 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
7255 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7256 * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
7257 * giving a previous position of i-th new value.
7258 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7259 * is to delete using decrRef() as it is no more needed.
7261 DataArrayInt *DataArrayInt::renumberR(const int *new2Old) const
7264 int nbTuples=getNumberOfTuples();
7265 int nbOfCompo=getNumberOfComponents();
7266 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7267 ret->alloc(nbTuples,nbOfCompo);
7268 ret->copyStringInfoFrom(*this);
7269 const int *iptr=getConstPointer();
7270 int *optr=ret->getPointer();
7271 for(int i=0;i<nbTuples;i++)
7272 std::copy(iptr+nbOfCompo*new2Old[i],iptr+nbOfCompo*(new2Old[i]+1),optr+nbOfCompo*i);
7273 ret->copyStringInfoFrom(*this);
7278 * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
7279 * of size \a newNbOfTuple and it's values are permuted as required by \a old2New array.
7280 * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ] for all
7281 * \a old2New[ i ] >= 0. In other words every i-th tuple in \a this array, for which
7282 * \a old2New[ i ] is negative, is missing from the result array.
7283 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7284 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
7285 * giving a new position for i-th old tuple and giving negative position for
7286 * for i-th old tuple that should be omitted.
7287 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7288 * is to delete using decrRef() as it is no more needed.
7290 DataArrayInt *DataArrayInt::renumberAndReduce(const int *old2New, int newNbOfTuple) const
7293 int nbTuples=getNumberOfTuples();
7294 int nbOfCompo=getNumberOfComponents();
7295 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7296 ret->alloc(newNbOfTuple,nbOfCompo);
7297 const int *iptr=getConstPointer();
7298 int *optr=ret->getPointer();
7299 for(int i=0;i<nbTuples;i++)
7303 std::copy(iptr+i*nbOfCompo,iptr+(i+1)*nbOfCompo,optr+w*nbOfCompo);
7305 ret->copyStringInfoFrom(*this);
7310 * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
7311 * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
7312 * \a new2OldBg array.
7313 * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
7314 * This method is equivalent to renumberAndReduce() except that convention in input is
7315 * \c new2old and \b not \c old2new.
7316 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7317 * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
7318 * tuple index in \a this array to fill the i-th tuple in the new array.
7319 * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
7320 * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
7321 * \a new2OldBg <= \a pi < \a new2OldEnd.
7322 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7323 * is to delete using decrRef() as it is no more needed.
7325 DataArrayInt *DataArrayInt::selectByTupleId(const int *new2OldBg, const int *new2OldEnd) const
7328 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7329 int nbComp=getNumberOfComponents();
7330 ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
7331 ret->copyStringInfoFrom(*this);
7332 int *pt=ret->getPointer();
7333 const int *srcPt=getConstPointer();
7335 for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
7336 std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
7337 ret->copyStringInfoFrom(*this);
7342 * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
7343 * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
7344 * \a new2OldBg array.
7345 * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
7346 * This method is equivalent to renumberAndReduce() except that convention in input is
7347 * \c new2old and \b not \c old2new.
7348 * This method is equivalent to selectByTupleId() except that it prevents coping data
7349 * from behind the end of \a this array.
7350 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7351 * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
7352 * tuple index in \a this array to fill the i-th tuple in the new array.
7353 * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
7354 * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
7355 * \a new2OldBg <= \a pi < \a new2OldEnd.
7356 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7357 * is to delete using decrRef() as it is no more needed.
7358 * \throw If \a new2OldEnd - \a new2OldBg > \a this->getNumberOfTuples().
7360 DataArrayInt *DataArrayInt::selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const
7363 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7364 int nbComp=getNumberOfComponents();
7365 int oldNbOfTuples=getNumberOfTuples();
7366 ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
7367 ret->copyStringInfoFrom(*this);
7368 int *pt=ret->getPointer();
7369 const int *srcPt=getConstPointer();
7371 for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
7372 if(*w>=0 && *w<oldNbOfTuples)
7373 std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
7375 throw INTERP_KERNEL::Exception("DataArrayInt::selectByTupleIdSafe : some ids has been detected to be out of [0,this->getNumberOfTuples) !");
7376 ret->copyStringInfoFrom(*this);
7381 * Returns a shorten copy of \a this array. The new DataArrayInt contains every
7382 * (\a bg + \c i * \a step)-th tuple of \a this array located before the \a end2-th
7383 * tuple. Indices of the selected tuples are the same as ones returned by the Python
7384 * command \c range( \a bg, \a end2, \a step ).
7385 * This method is equivalent to selectByTupleIdSafe() except that the input array is
7386 * not constructed explicitly.
7387 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7388 * \param [in] bg - index of the first tuple to copy from \a this array.
7389 * \param [in] end2 - index of the tuple before which the tuples to copy are located.
7390 * \param [in] step - index increment to get index of the next tuple to copy.
7391 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7392 * is to delete using decrRef() as it is no more needed.
7393 * \sa DataArrayInt::substr.
7395 DataArrayInt *DataArrayInt::selectByTupleId2(int bg, int end2, int step) const
7398 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7399 int nbComp=getNumberOfComponents();
7400 int newNbOfTuples=GetNumberOfItemGivenBESRelative(bg,end2,step,"DataArrayInt::selectByTupleId2 : ");
7401 ret->alloc(newNbOfTuples,nbComp);
7402 int *pt=ret->getPointer();
7403 const int *srcPt=getConstPointer()+bg*nbComp;
7404 for(int i=0;i<newNbOfTuples;i++,srcPt+=step*nbComp)
7405 std::copy(srcPt,srcPt+nbComp,pt+i*nbComp);
7406 ret->copyStringInfoFrom(*this);
7411 * Returns a shorten copy of \a this array. The new DataArrayInt contains ranges
7412 * of tuples specified by \a ranges parameter.
7413 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7414 * \param [in] ranges - std::vector of std::pair's each of which defines a range
7415 * of tuples in [\c begin,\c end) format.
7416 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7417 * is to delete using decrRef() as it is no more needed.
7418 * \throw If \a end < \a begin.
7419 * \throw If \a end > \a this->getNumberOfTuples().
7420 * \throw If \a this is not allocated.
7422 DataArray *DataArrayInt::selectByTupleRanges(const std::vector<std::pair<int,int> >& ranges) const
7425 int nbOfComp=getNumberOfComponents();
7426 int nbOfTuplesThis=getNumberOfTuples();
7429 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7430 ret->alloc(0,nbOfComp);
7431 ret->copyStringInfoFrom(*this);
7434 int ref=ranges.front().first;
7436 bool isIncreasing=true;
7437 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
7439 if((*it).first<=(*it).second)
7441 if((*it).first>=0 && (*it).second<=nbOfTuplesThis)
7443 nbOfTuples+=(*it).second-(*it).first;
7445 isIncreasing=ref<=(*it).first;
7450 std::ostringstream oss; oss << "DataArrayInt::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
7451 oss << " (" << (*it).first << "," << (*it).second << ") is greater than number of tuples of this :" << nbOfTuples << " !";
7452 throw INTERP_KERNEL::Exception(oss.str().c_str());
7457 std::ostringstream oss; oss << "DataArrayInt::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
7458 oss << " (" << (*it).first << "," << (*it).second << ") end is before begin !";
7459 throw INTERP_KERNEL::Exception(oss.str().c_str());
7462 if(isIncreasing && nbOfTuplesThis==nbOfTuples)
7464 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7465 ret->alloc(nbOfTuples,nbOfComp);
7466 ret->copyStringInfoFrom(*this);
7467 const int *src=getConstPointer();
7468 int *work=ret->getPointer();
7469 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
7470 work=std::copy(src+(*it).first*nbOfComp,src+(*it).second*nbOfComp,work);
7475 * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode.
7476 * This map, if applied to \a this array, would make it sorted. For example, if
7477 * \a this array contents are [9,10,0,6,4,11,3,7] then the contents of the result array
7478 * are [5,6,0,3,2,7,1,4]; if this result array (\a res) is used as an argument in call
7479 * \a this->renumber(\a res) then the returned array contains [0,3,4,6,7,9,10,11].
7480 * This method is useful for renumbering (in MED file for example). For more info
7481 * on renumbering see \ref MEDCouplingArrayRenumbering.
7482 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7483 * array using decrRef() as it is no more needed.
7484 * \throw If \a this is not allocated.
7485 * \throw If \a this->getNumberOfComponents() != 1.
7486 * \throw If there are equal values in \a this array.
7488 DataArrayInt *DataArrayInt::checkAndPreparePermutation() const
7491 if(getNumberOfComponents()!=1)
7492 throw INTERP_KERNEL::Exception("DataArrayInt::checkAndPreparePermutation : number of components must == 1 !");
7493 int nbTuples=getNumberOfTuples();
7494 const int *pt=getConstPointer();
7495 int *pt2=CheckAndPreparePermutation(pt,pt+nbTuples);
7496 DataArrayInt *ret=DataArrayInt::New();
7497 ret->useArray(pt2,true,C_DEALLOC,nbTuples,1);
7502 * 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
7503 * input array \a ids2.
7504 * \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.
7505 * 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
7507 * In case of success (no throw) : \c ids1->renumber(ret)->isEqual(ids2) where \a ret is the return of this method.
7509 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7510 * array using decrRef() as it is no more needed.
7511 * \throw If either ids1 or ids2 is null not allocated or not with one components.
7514 DataArrayInt *DataArrayInt::FindPermutationFromFirstToSecond(const DataArrayInt *ids1, const DataArrayInt *ids2)
7517 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays must be not null !");
7518 if(!ids1->isAllocated() || !ids2->isAllocated())
7519 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays must be allocated !");
7520 if(ids1->getNumberOfComponents()!=1 || ids2->getNumberOfComponents()!=1)
7521 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays have exactly one component !");
7522 if(ids1->getNumberOfTuples()!=ids2->getNumberOfTuples())
7524 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 !";
7525 throw INTERP_KERNEL::Exception(oss.str().c_str());
7527 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(ids1->deepCpy());
7528 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p2(ids2->deepCpy());
7529 p1->sort(true); p2->sort(true);
7530 if(!p1->isEqualWithoutConsideringStr(*p2))
7531 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two arrays are not lying on same ids ! Impossible to find a permutation between the 2 arrays !");
7532 p1=ids1->checkAndPreparePermutation();
7533 p2=ids2->checkAndPreparePermutation();
7534 p2=p2->invertArrayO2N2N2O(p2->getNumberOfTuples());
7535 p2=p2->selectByTupleIdSafe(p1->begin(),p1->end());
7540 * Returns two arrays describing a surjective mapping from \a this set of values (\a A)
7541 * onto a set of values of size \a targetNb (\a B). The surjective function is
7542 * \a B[ \a A[ i ]] = i. That is to say that for each \a id in [0,\a targetNb), where \a
7543 * targetNb < \a this->getNumberOfTuples(), there exists at least one tupleId (\a tid) so
7544 * that <em> this->getIJ( tid, 0 ) == id</em>. <br>
7545 * The first of out arrays returns indices of elements of \a this array, grouped by their
7546 * place in the set \a B. The second out array is the index of the first one; it shows how
7547 * many elements of \a A are mapped into each element of \a B. <br>
7549 * mapping and its usage in renumbering see \ref MEDCouplingArrayRenumbering. <br>
7551 * - \a this: [0,3,2,3,2,2,1,2]
7553 * - \a arr: [0, 6, 2,4,5,7, 1,3]
7554 * - \a arrI: [0,1,2,6,8]
7556 * This result means: <br>
7557 * the element of \a B 0 encounters within \a A once (\a arrI[ 0+1 ] - \a arrI[ 0 ]) and
7558 * its index within \a A is 0 ( \a arr[ 0:1 ] == \a arr[ \a arrI[ 0 ] : \a arrI[ 0+1 ]]);<br>
7559 * the element of \a B 2 encounters within \a A 4 times (\a arrI[ 2+1 ] - \a arrI[ 2 ]) and
7560 * its indices within \a A are [2,4,5,7] ( \a arr[ 2:6 ] == \a arr[ \a arrI[ 2 ] :
7561 * \a arrI[ 2+1 ]]); <br> etc.
7562 * \param [in] targetNb - the size of the set \a B. \a targetNb must be equal or more
7563 * than the maximal value of \a A.
7564 * \param [out] arr - a new instance of DataArrayInt returning indices of
7565 * elements of \a this, grouped by their place in the set \a B. The caller is to delete
7566 * this array using decrRef() as it is no more needed.
7567 * \param [out] arrI - a new instance of DataArrayInt returning size of groups of equal
7568 * elements of \a this. The caller is to delete this array using decrRef() as it
7569 * is no more needed.
7570 * \throw If \a this is not allocated.
7571 * \throw If \a this->getNumberOfComponents() != 1.
7572 * \throw If any value in \a this is more or equal to \a targetNb.
7574 void DataArrayInt::changeSurjectiveFormat(int targetNb, DataArrayInt *&arr, DataArrayInt *&arrI) const
7577 if(getNumberOfComponents()!=1)
7578 throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : number of components must == 1 !");
7579 int nbOfTuples=getNumberOfTuples();
7580 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
7581 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> retI(DataArrayInt::New());
7582 retI->alloc(targetNb+1,1);
7583 const int *input=getConstPointer();
7584 std::vector< std::vector<int> > tmp(targetNb);
7585 for(int i=0;i<nbOfTuples;i++)
7588 if(tmp2>=0 && tmp2<targetNb)
7589 tmp[tmp2].push_back(i);
7592 std::ostringstream oss; oss << "DataArrayInt::changeSurjectiveFormat : At pos " << i << " presence of element " << tmp2 << " ! should be in [0," << targetNb << ") !";
7593 throw INTERP_KERNEL::Exception(oss.str().c_str());
7596 int *retIPtr=retI->getPointer();
7598 for(std::vector< std::vector<int> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++,retIPtr++)
7599 retIPtr[1]=retIPtr[0]+(int)((*it1).size());
7600 if(nbOfTuples!=retI->getIJ(targetNb,0))
7601 throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : big problem should never happen !");
7602 ret->alloc(nbOfTuples,1);
7603 int *retPtr=ret->getPointer();
7604 for(std::vector< std::vector<int> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++)
7605 retPtr=std::copy((*it1).begin(),(*it1).end(),retPtr);
7612 * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode computed
7613 * from a zip representation of a surjective format (returned e.g. by
7614 * \ref ParaMEDMEM::DataArrayDouble::findCommonTuples() "DataArrayDouble::findCommonTuples()"
7615 * for example). The result array minimizes the permutation. <br>
7616 * For more info on renumbering see \ref MEDCouplingArrayRenumbering. <br>
7618 * - \a nbOfOldTuples: 10
7619 * - \a arr : [0,3, 5,7,9]
7620 * - \a arrIBg : [0,2,5]
7621 * - \a newNbOfTuples: 7
7622 * - result array : [0,1,2,0,3,4,5,4,6,4]
7624 * \param [in] nbOfOldTuples - number of tuples in the initial array \a arr.
7625 * \param [in] arr - the array of tuple indices grouped by \a arrIBg array.
7626 * \param [in] arrIBg - the array dividing all indices stored in \a arr into groups of
7627 * (indices of) equal values. Its every element (except the last one) points to
7628 * the first element of a group of equal values.
7629 * \param [in] arrIEnd - specifies the end of \a arrIBg, so that the last element of \a
7630 * arrIBg is \a arrIEnd[ -1 ].
7631 * \param [out] newNbOfTuples - number of tuples after surjection application.
7632 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7633 * array using decrRef() as it is no more needed.
7634 * \throw If any value of \a arr breaks condition ( 0 <= \a arr[ i ] < \a nbOfOldTuples ).
7636 DataArrayInt *DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(int nbOfOldTuples, const int *arr, const int *arrIBg, const int *arrIEnd, int &newNbOfTuples)
7638 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7639 ret->alloc(nbOfOldTuples,1);
7640 int *pt=ret->getPointer();
7641 std::fill(pt,pt+nbOfOldTuples,-1);
7642 int nbOfGrps=((int)std::distance(arrIBg,arrIEnd))-1;
7643 const int *cIPtr=arrIBg;
7644 for(int i=0;i<nbOfGrps;i++)
7645 pt[arr[cIPtr[i]]]=-(i+2);
7647 for(int iNode=0;iNode<nbOfOldTuples;iNode++)
7655 int grpId=-(pt[iNode]+2);
7656 for(int j=cIPtr[grpId];j<cIPtr[grpId+1];j++)
7658 if(arr[j]>=0 && arr[j]<nbOfOldTuples)
7662 std::ostringstream oss; oss << "DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2 : With element #" << j << " value is " << arr[j] << " should be in [0," << nbOfOldTuples << ") !";
7663 throw INTERP_KERNEL::Exception(oss.str().c_str());
7670 newNbOfTuples=newNb;
7675 * Returns a new DataArrayInt containing a renumbering map in "New to Old" mode,
7676 * which if applied to \a this array would make it sorted ascendingly.
7677 * For more info on renumbering see \ref MEDCouplingArrayRenumbering. <br>
7679 * - \a this: [2,0,1,1,0,1,2,0,1,1,0,0]
7680 * - result: [10,0,5,6,1,7,11,2,8,9,3,4]
7681 * - after applying result to \a this: [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2]
7683 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7684 * array using decrRef() as it is no more needed.
7685 * \throw If \a this is not allocated.
7686 * \throw If \a this->getNumberOfComponents() != 1.
7688 DataArrayInt *DataArrayInt::buildPermArrPerLevel() const
7691 if(getNumberOfComponents()!=1)
7692 throw INTERP_KERNEL::Exception("DataArrayInt::buildPermArrPerLevel : number of components must == 1 !");
7693 int nbOfTuples=getNumberOfTuples();
7694 const int *pt=getConstPointer();
7695 std::map<int,int> m;
7696 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7697 ret->alloc(nbOfTuples,1);
7698 int *opt=ret->getPointer();
7699 for(int i=0;i<nbOfTuples;i++,pt++,opt++)
7702 std::map<int,int>::iterator it=m.find(val);
7711 m.insert(std::pair<int,int>(val,1));
7715 for(std::map<int,int>::iterator it=m.begin();it!=m.end();it++)
7717 int vt=(*it).second;
7721 pt=getConstPointer();
7722 opt=ret->getPointer();
7723 for(int i=0;i<nbOfTuples;i++,pt++,opt++)
7730 * Checks if contents of \a this array are equal to that of an array filled with
7731 * iota(). This method is particularly useful for DataArrayInt instances that represent
7732 * a renumbering array to check the real need in renumbering.
7733 * \return bool - \a true if \a this array contents == \a range( \a this->getNumberOfTuples())
7734 * \throw If \a this is not allocated.
7735 * \throw If \a this->getNumberOfComponents() != 1.
7737 bool DataArrayInt::isIdentity() const
7740 if(getNumberOfComponents()!=1)
7742 int nbOfTuples=getNumberOfTuples();
7743 const int *pt=getConstPointer();
7744 for(int i=0;i<nbOfTuples;i++,pt++)
7751 * Checks if all values in \a this array are equal to \a val.
7752 * \param [in] val - value to check equality of array values to.
7753 * \return bool - \a true if all values are \a val.
7754 * \throw If \a this is not allocated.
7755 * \throw If \a this->getNumberOfComponents() != 1
7757 bool DataArrayInt::isUniform(int val) const
7760 if(getNumberOfComponents()!=1)
7761 throw INTERP_KERNEL::Exception("DataArrayInt::isUniform : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
7762 int nbOfTuples=getNumberOfTuples();
7763 const int *w=getConstPointer();
7764 const int *end2=w+nbOfTuples;
7772 * Creates a new DataArrayDouble and assigns all (textual and numerical) data of \a this
7773 * array to the new one.
7774 * \return DataArrayDouble * - the new instance of DataArrayInt.
7776 DataArrayDouble *DataArrayInt::convertToDblArr() const
7779 DataArrayDouble *ret=DataArrayDouble::New();
7780 ret->alloc(getNumberOfTuples(),getNumberOfComponents());
7781 std::size_t nbOfVals=getNbOfElems();
7782 const int *src=getConstPointer();
7783 double *dest=ret->getPointer();
7784 std::copy(src,src+nbOfVals,dest);
7785 ret->copyStringInfoFrom(*this);
7790 * Returns a shorten copy of \a this array. The new DataArrayInt contains all
7791 * tuples starting from the \a tupleIdBg-th tuple and including all tuples located before
7792 * the \a tupleIdEnd-th one. This methods has a similar behavior as std::string::substr().
7793 * This method is a specialization of selectByTupleId2().
7794 * \param [in] tupleIdBg - index of the first tuple to copy from \a this array.
7795 * \param [in] tupleIdEnd - index of the tuple before which the tuples to copy are located.
7796 * If \a tupleIdEnd == -1, all the tuples till the end of \a this array are copied.
7797 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7798 * is to delete using decrRef() as it is no more needed.
7799 * \throw If \a tupleIdBg < 0.
7800 * \throw If \a tupleIdBg > \a this->getNumberOfTuples().
7801 \throw If \a tupleIdEnd != -1 && \a tupleIdEnd < \a this->getNumberOfTuples().
7802 * \sa DataArrayInt::selectByTupleId2
7804 DataArrayInt *DataArrayInt::substr(int tupleIdBg, int tupleIdEnd) const
7807 int nbt=getNumberOfTuples();
7809 throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter must be greater than 0 !");
7811 throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter is greater than number of tuples !");
7812 int trueEnd=tupleIdEnd;
7816 throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter is greater or equal than number of tuples !");
7820 int nbComp=getNumberOfComponents();
7821 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7822 ret->alloc(trueEnd-tupleIdBg,nbComp);
7823 ret->copyStringInfoFrom(*this);
7824 std::copy(getConstPointer()+tupleIdBg*nbComp,getConstPointer()+trueEnd*nbComp,ret->getPointer());
7829 * Changes the number of components within \a this array so that its raw data **does
7830 * not** change, instead splitting this data into tuples changes.
7831 * \warning This method erases all (name and unit) component info set before!
7832 * \param [in] newNbOfComp - number of components for \a this array to have.
7833 * \throw If \a this is not allocated
7834 * \throw If getNbOfElems() % \a newNbOfCompo != 0.
7835 * \throw If \a newNbOfCompo is lower than 1.
7836 * \throw If the rearrange method would lead to a number of tuples higher than 2147483647 (maximal capacity of int32 !).
7837 * \warning This method erases all (name and unit) component info set before!
7839 void DataArrayInt::rearrange(int newNbOfCompo)
7843 throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : input newNbOfCompo must be > 0 !");
7844 std::size_t nbOfElems=getNbOfElems();
7845 if(nbOfElems%newNbOfCompo!=0)
7846 throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : nbOfElems%newNbOfCompo!=0 !");
7847 if(nbOfElems/newNbOfCompo>(std::size_t)std::numeric_limits<int>::max())
7848 throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : the rearrangement leads to too high number of tuples (> 2147483647) !");
7849 _info_on_compo.clear();
7850 _info_on_compo.resize(newNbOfCompo);
7855 * Changes the number of components within \a this array to be equal to its number
7856 * of tuples, and inversely its number of tuples to become equal to its number of
7857 * components. So that its raw data **does not** change, instead splitting this
7858 * data into tuples changes.
7859 * \warning This method erases all (name and unit) component info set before!
7860 * \warning Do not confuse this method with fromNoInterlace() and toNoInterlace()!
7861 * \throw If \a this is not allocated.
7864 void DataArrayInt::transpose()
7867 int nbOfTuples=getNumberOfTuples();
7868 rearrange(nbOfTuples);
7872 * Returns a shorten or extended copy of \a this array. If \a newNbOfComp is less
7873 * than \a this->getNumberOfComponents() then the result array is shorten as each tuple
7874 * is truncated to have \a newNbOfComp components, keeping first components. If \a
7875 * newNbOfComp is more than \a this->getNumberOfComponents() then the result array is
7876 * expanded as each tuple is populated with \a dftValue to have \a newNbOfComp
7878 * \param [in] newNbOfComp - number of components for the new array to have.
7879 * \param [in] dftValue - value assigned to new values added to the new array.
7880 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
7881 * is to delete using decrRef() as it is no more needed.
7882 * \throw If \a this is not allocated.
7884 DataArrayInt *DataArrayInt::changeNbOfComponents(int newNbOfComp, int dftValue) const
7887 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7888 ret->alloc(getNumberOfTuples(),newNbOfComp);
7889 const int *oldc=getConstPointer();
7890 int *nc=ret->getPointer();
7891 int nbOfTuples=getNumberOfTuples();
7892 int oldNbOfComp=getNumberOfComponents();
7893 int dim=std::min(oldNbOfComp,newNbOfComp);
7894 for(int i=0;i<nbOfTuples;i++)
7898 nc[newNbOfComp*i+j]=oldc[i*oldNbOfComp+j];
7899 for(;j<newNbOfComp;j++)
7900 nc[newNbOfComp*i+j]=dftValue;
7902 ret->setName(getName());
7903 for(int i=0;i<dim;i++)
7904 ret->setInfoOnComponent(i,getInfoOnComponent(i));
7905 ret->setName(getName());
7910 * Changes number of tuples in the array. If the new number of tuples is smaller
7911 * than the current number the array is truncated, otherwise the array is extended.
7912 * \param [in] nbOfTuples - new number of tuples.
7913 * \throw If \a this is not allocated.
7914 * \throw If \a nbOfTuples is negative.
7916 void DataArrayInt::reAlloc(int nbOfTuples)
7919 throw INTERP_KERNEL::Exception("DataArrayInt::reAlloc : input new number of tuples should be >=0 !");
7921 _mem.reAlloc(getNumberOfComponents()*(std::size_t)nbOfTuples);
7927 * Returns a copy of \a this array composed of selected components.
7928 * The new DataArrayInt has the same number of tuples but includes components
7929 * specified by \a compoIds parameter. So that getNbOfElems() of the result array
7930 * can be either less, same or more than \a this->getNbOfElems().
7931 * \param [in] compoIds - sequence of zero based indices of components to include
7932 * into the new array.
7933 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7934 * is to delete using decrRef() as it is no more needed.
7935 * \throw If \a this is not allocated.
7936 * \throw If a component index (\a i) is not valid:
7937 * \a i < 0 || \a i >= \a this->getNumberOfComponents().
7939 * \if ENABLE_EXAMPLES
7940 * \ref py_mcdataarrayint_keepselectedcomponents "Here is a Python example".
7943 DataArrayInt *DataArrayInt::keepSelectedComponents(const std::vector<int>& compoIds) const
7946 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
7947 int newNbOfCompo=(int)compoIds.size();
7948 int oldNbOfCompo=getNumberOfComponents();
7949 for(std::vector<int>::const_iterator it=compoIds.begin();it!=compoIds.end();it++)
7950 DataArray::CheckValueInRange(oldNbOfCompo,(*it),"keepSelectedComponents invalid requested component");
7951 int nbOfTuples=getNumberOfTuples();
7952 ret->alloc(nbOfTuples,newNbOfCompo);
7953 ret->copyPartOfStringInfoFrom(*this,compoIds);
7954 const int *oldc=getConstPointer();
7955 int *nc=ret->getPointer();
7956 for(int i=0;i<nbOfTuples;i++)
7957 for(int j=0;j<newNbOfCompo;j++,nc++)
7958 *nc=oldc[i*oldNbOfCompo+compoIds[j]];
7963 * Appends components of another array to components of \a this one, tuple by tuple.
7964 * So that the number of tuples of \a this array remains the same and the number of
7965 * components increases.
7966 * \param [in] other - the DataArrayInt to append to \a this one.
7967 * \throw If \a this is not allocated.
7968 * \throw If \a this and \a other arrays have different number of tuples.
7970 * \if ENABLE_EXAMPLES
7971 * \ref cpp_mcdataarrayint_meldwith "Here is a C++ example".
7973 * \ref py_mcdataarrayint_meldwith "Here is a Python example".
7976 void DataArrayInt::meldWith(const DataArrayInt *other)
7979 throw INTERP_KERNEL::Exception("DataArrayInt::meldWith : DataArrayInt pointer in input is NULL !");
7981 other->checkAllocated();
7982 int nbOfTuples=getNumberOfTuples();
7983 if(nbOfTuples!=other->getNumberOfTuples())
7984 throw INTERP_KERNEL::Exception("DataArrayInt::meldWith : mismatch of number of tuples !");
7985 int nbOfComp1=getNumberOfComponents();
7986 int nbOfComp2=other->getNumberOfComponents();
7987 int *newArr=(int *)malloc(nbOfTuples*(nbOfComp1+nbOfComp2)*sizeof(int));
7989 const int *inp1=getConstPointer();
7990 const int *inp2=other->getConstPointer();
7991 for(int i=0;i<nbOfTuples;i++,inp1+=nbOfComp1,inp2+=nbOfComp2)
7993 w=std::copy(inp1,inp1+nbOfComp1,w);
7994 w=std::copy(inp2,inp2+nbOfComp2,w);
7996 useArray(newArr,true,C_DEALLOC,nbOfTuples,nbOfComp1+nbOfComp2);
7997 std::vector<int> compIds(nbOfComp2);
7998 for(int i=0;i<nbOfComp2;i++)
7999 compIds[i]=nbOfComp1+i;
8000 copyPartOfStringInfoFrom2(compIds,*other);
8004 * Copy all components in a specified order from another DataArrayInt.
8005 * The specified components become the first ones in \a this array.
8006 * Both numerical and textual data is copied. The number of tuples in \a this and
8007 * the other array can be different.
8008 * \param [in] a - the array to copy data from.
8009 * \param [in] compoIds - sequence of zero based indices of components, data of which is
8011 * \throw If \a a is NULL.
8012 * \throw If \a compoIds.size() != \a a->getNumberOfComponents().
8013 * \throw If \a compoIds[i] < 0 or \a compoIds[i] > \a this->getNumberOfComponents().
8015 * \if ENABLE_EXAMPLES
8016 * \ref py_mcdataarrayint_setselectedcomponents "Here is a Python example".
8019 void DataArrayInt::setSelectedComponents(const DataArrayInt *a, const std::vector<int>& compoIds)
8022 throw INTERP_KERNEL::Exception("DataArrayInt::setSelectedComponents : input DataArrayInt is NULL !");
8024 a->checkAllocated();
8025 copyPartOfStringInfoFrom2(compoIds,*a);
8026 std::size_t partOfCompoSz=compoIds.size();
8027 int nbOfCompo=getNumberOfComponents();
8028 int nbOfTuples=std::min(getNumberOfTuples(),a->getNumberOfTuples());
8029 const int *ac=a->getConstPointer();
8030 int *nc=getPointer();
8031 for(int i=0;i<nbOfTuples;i++)
8032 for(std::size_t j=0;j<partOfCompoSz;j++,ac++)
8033 nc[nbOfCompo*i+compoIds[j]]=*ac;
8037 * Copy all values from another DataArrayInt into specified tuples and components
8038 * of \a this array. Textual data is not copied.
8039 * The tree parameters defining set of indices of tuples and components are similar to
8040 * the tree parameters of the Python function \c range(\c start,\c stop,\c step).
8041 * \param [in] a - the array to copy values from.
8042 * \param [in] bgTuples - index of the first tuple of \a this array to assign values to.
8043 * \param [in] endTuples - index of the tuple before which the tuples to assign to
8045 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
8046 * \param [in] bgComp - index of the first component of \a this array to assign values to.
8047 * \param [in] endComp - index of the component before which the components to assign
8049 * \param [in] stepComp - index increment to get index of the next component to assign to.
8050 * \param [in] strictCompoCompare - if \a true (by default), then \a a->getNumberOfComponents()
8051 * must be equal to the number of columns to assign to, else an
8052 * exception is thrown; if \a false, then it is only required that \a
8053 * a->getNbOfElems() equals to number of values to assign to (this condition
8054 * must be respected even if \a strictCompoCompare is \a true). The number of
8055 * values to assign to is given by following Python expression:
8056 * \a nbTargetValues =
8057 * \c len(\c range(\a bgTuples,\a endTuples,\a stepTuples)) *
8058 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
8059 * \throw If \a a is NULL.
8060 * \throw If \a a is not allocated.
8061 * \throw If \a this is not allocated.
8062 * \throw If parameters specifying tuples and components to assign to do not give a
8063 * non-empty range of increasing indices.
8064 * \throw If \a a->getNbOfElems() != \a nbTargetValues.
8065 * \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
8066 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
8068 * \if ENABLE_EXAMPLES
8069 * \ref py_mcdataarrayint_setpartofvalues1 "Here is a Python example".
8072 void DataArrayInt::setPartOfValues1(const DataArrayInt *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
8075 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues1 : DataArrayInt pointer in input is NULL !");
8076 const char msg[]="DataArrayInt::setPartOfValues1";
8078 a->checkAllocated();
8079 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
8080 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
8081 int nbComp=getNumberOfComponents();
8082 int nbOfTuples=getNumberOfTuples();
8083 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
8084 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
8085 bool assignTech=true;
8086 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
8088 if(strictCompoCompare)
8089 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
8093 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
8096 int *pt=getPointer()+bgTuples*nbComp+bgComp;
8097 const int *srcPt=a->getConstPointer();
8100 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8101 for(int j=0;j<newNbOfComp;j++,srcPt++)
8102 pt[j*stepComp]=*srcPt;
8106 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8108 const int *srcPt2=srcPt;
8109 for(int j=0;j<newNbOfComp;j++,srcPt2++)
8110 pt[j*stepComp]=*srcPt2;
8116 * Assign a given value to values at specified tuples and components of \a this array.
8117 * The tree parameters defining set of indices of tuples and components are similar to
8118 * the tree parameters of the Python function \c range(\c start,\c stop,\c step)..
8119 * \param [in] a - the value to assign.
8120 * \param [in] bgTuples - index of the first tuple of \a this array to assign to.
8121 * \param [in] endTuples - index of the tuple before which the tuples to assign to
8123 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
8124 * \param [in] bgComp - index of the first component of \a this array to assign to.
8125 * \param [in] endComp - index of the component before which the components to assign
8127 * \param [in] stepComp - index increment to get index of the next component to assign to.
8128 * \throw If \a this is not allocated.
8129 * \throw If parameters specifying tuples and components to assign to, do not give a
8130 * non-empty range of increasing indices or indices are out of a valid range
8133 * \if ENABLE_EXAMPLES
8134 * \ref py_mcdataarrayint_setpartofvaluessimple1 "Here is a Python example".
8137 void DataArrayInt::setPartOfValuesSimple1(int a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp)
8139 const char msg[]="DataArrayInt::setPartOfValuesSimple1";
8141 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
8142 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
8143 int nbComp=getNumberOfComponents();
8144 int nbOfTuples=getNumberOfTuples();
8145 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
8146 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
8147 int *pt=getPointer()+bgTuples*nbComp+bgComp;
8148 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8149 for(int j=0;j<newNbOfComp;j++)
8155 * Copy all values from another DataArrayInt (\a a) into specified tuples and
8156 * components of \a this array. Textual data is not copied.
8157 * The tuples and components to assign to are defined by C arrays of indices.
8158 * There are two *modes of usage*:
8159 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
8160 * of \a a is assigned to its own location within \a this array.
8161 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
8162 * components of every specified tuple of \a this array. In this mode it is required
8163 * that \a a->getNumberOfComponents() equals to the number of specified components.
8165 * \param [in] a - the array to copy values from.
8166 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
8167 * assign values of \a a to.
8168 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
8169 * pointer to a tuple index <em>(pi)</em> varies as this:
8170 * \a bgTuples <= \a pi < \a endTuples.
8171 * \param [in] bgComp - pointer to an array of component indices of \a this array to
8172 * assign values of \a a to.
8173 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
8174 * pointer to a component index <em>(pi)</em> varies as this:
8175 * \a bgComp <= \a pi < \a endComp.
8176 * \param [in] strictCompoCompare - this parameter is checked only if the
8177 * *mode of usage* is the first; if it is \a true (default),
8178 * then \a a->getNumberOfComponents() must be equal
8179 * to the number of specified columns, else this is not required.
8180 * \throw If \a a is NULL.
8181 * \throw If \a a is not allocated.
8182 * \throw If \a this is not allocated.
8183 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
8184 * out of a valid range for \a this array.
8185 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
8186 * if <em> a->getNumberOfComponents() != (endComp - bgComp) </em>.
8187 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
8188 * <em> a->getNumberOfComponents() != (endComp - bgComp)</em>.
8190 * \if ENABLE_EXAMPLES
8191 * \ref py_mcdataarrayint_setpartofvalues2 "Here is a Python example".
8194 void DataArrayInt::setPartOfValues2(const DataArrayInt *a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
8197 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues2 : DataArrayInt pointer in input is NULL !");
8198 const char msg[]="DataArrayInt::setPartOfValues2";
8200 a->checkAllocated();
8201 int nbComp=getNumberOfComponents();
8202 int nbOfTuples=getNumberOfTuples();
8203 for(const int *z=bgComp;z!=endComp;z++)
8204 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
8205 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
8206 int newNbOfComp=(int)std::distance(bgComp,endComp);
8207 bool assignTech=true;
8208 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
8210 if(strictCompoCompare)
8211 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
8215 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
8218 int *pt=getPointer();
8219 const int *srcPt=a->getConstPointer();
8222 for(const int *w=bgTuples;w!=endTuples;w++)
8224 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8225 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
8227 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt;
8233 for(const int *w=bgTuples;w!=endTuples;w++)
8235 const int *srcPt2=srcPt;
8236 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8237 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
8239 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt2;
8246 * Assign a given value to values at specified tuples and components of \a this array.
8247 * The tuples and components to assign to are defined by C arrays of indices.
8248 * \param [in] a - the value to assign.
8249 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
8251 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
8252 * pointer to a tuple index (\a pi) varies as this:
8253 * \a bgTuples <= \a pi < \a endTuples.
8254 * \param [in] bgComp - pointer to an array of component indices of \a this array to
8256 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
8257 * pointer to a component index (\a pi) varies as this:
8258 * \a bgComp <= \a pi < \a endComp.
8259 * \throw If \a this is not allocated.
8260 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
8261 * out of a valid range for \a this array.
8263 * \if ENABLE_EXAMPLES
8264 * \ref py_mcdataarrayint_setpartofvaluessimple2 "Here is a Python example".
8267 void DataArrayInt::setPartOfValuesSimple2(int a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp)
8270 int nbComp=getNumberOfComponents();
8271 int nbOfTuples=getNumberOfTuples();
8272 for(const int *z=bgComp;z!=endComp;z++)
8273 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
8274 int *pt=getPointer();
8275 for(const int *w=bgTuples;w!=endTuples;w++)
8276 for(const int *z=bgComp;z!=endComp;z++)
8278 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8279 pt[(std::size_t)(*w)*nbComp+(*z)]=a;
8284 * Copy all values from another DataArrayInt (\a a) into specified tuples and
8285 * components of \a this array. Textual data is not copied.
8286 * The tuples to assign to are defined by a C array of indices.
8287 * The components to assign to are defined by three values similar to parameters of
8288 * the Python function \c range(\c start,\c stop,\c step).
8289 * There are two *modes of usage*:
8290 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
8291 * of \a a is assigned to its own location within \a this array.
8292 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
8293 * components of every specified tuple of \a this array. In this mode it is required
8294 * that \a a->getNumberOfComponents() equals to the number of specified components.
8296 * \param [in] a - the array to copy values from.
8297 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
8298 * assign values of \a a to.
8299 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
8300 * pointer to a tuple index <em>(pi)</em> varies as this:
8301 * \a bgTuples <= \a pi < \a endTuples.
8302 * \param [in] bgComp - index of the first component of \a this array to assign to.
8303 * \param [in] endComp - index of the component before which the components to assign
8305 * \param [in] stepComp - index increment to get index of the next component to assign to.
8306 * \param [in] strictCompoCompare - this parameter is checked only in the first
8307 * *mode of usage*; if \a strictCompoCompare is \a true (default),
8308 * then \a a->getNumberOfComponents() must be equal
8309 * to the number of specified columns, else this is not required.
8310 * \throw If \a a is NULL.
8311 * \throw If \a a is not allocated.
8312 * \throw If \a this is not allocated.
8313 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
8315 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
8316 * if <em> a->getNumberOfComponents()</em> is unequal to the number of components
8317 * defined by <em>(bgComp,endComp,stepComp)</em>.
8318 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
8319 * <em> a->getNumberOfComponents()</em> is unequal to the number of components
8320 * defined by <em>(bgComp,endComp,stepComp)</em>.
8321 * \throw If parameters specifying components to assign to, do not give a
8322 * non-empty range of increasing indices or indices are out of a valid range
8325 * \if ENABLE_EXAMPLES
8326 * \ref py_mcdataarrayint_setpartofvalues3 "Here is a Python example".
8329 void DataArrayInt::setPartOfValues3(const DataArrayInt *a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
8332 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues3 : DataArrayInt pointer in input is NULL !");
8333 const char msg[]="DataArrayInt::setPartOfValues3";
8335 a->checkAllocated();
8336 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
8337 int nbComp=getNumberOfComponents();
8338 int nbOfTuples=getNumberOfTuples();
8339 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
8340 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
8341 bool assignTech=true;
8342 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
8344 if(strictCompoCompare)
8345 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
8349 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
8352 int *pt=getPointer()+bgComp;
8353 const int *srcPt=a->getConstPointer();
8356 for(const int *w=bgTuples;w!=endTuples;w++)
8357 for(int j=0;j<newNbOfComp;j++,srcPt++)
8359 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8360 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt;
8365 for(const int *w=bgTuples;w!=endTuples;w++)
8367 const int *srcPt2=srcPt;
8368 for(int j=0;j<newNbOfComp;j++,srcPt2++)
8370 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8371 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt2;
8378 * Assign a given value to values at specified tuples and components of \a this array.
8379 * The tuples to assign to are defined by a C array of indices.
8380 * The components to assign to are defined by three values similar to parameters of
8381 * the Python function \c range(\c start,\c stop,\c step).
8382 * \param [in] a - the value to assign.
8383 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
8385 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
8386 * pointer to a tuple index <em>(pi)</em> varies as this:
8387 * \a bgTuples <= \a pi < \a endTuples.
8388 * \param [in] bgComp - index of the first component of \a this array to assign to.
8389 * \param [in] endComp - index of the component before which the components to assign
8391 * \param [in] stepComp - index increment to get index of the next component to assign to.
8392 * \throw If \a this is not allocated.
8393 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
8395 * \throw If parameters specifying components to assign to, do not give a
8396 * non-empty range of increasing indices or indices are out of a valid range
8399 * \if ENABLE_EXAMPLES
8400 * \ref py_mcdataarrayint_setpartofvaluessimple3 "Here is a Python example".
8403 void DataArrayInt::setPartOfValuesSimple3(int a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp)
8405 const char msg[]="DataArrayInt::setPartOfValuesSimple3";
8407 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
8408 int nbComp=getNumberOfComponents();
8409 int nbOfTuples=getNumberOfTuples();
8410 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
8411 int *pt=getPointer()+bgComp;
8412 for(const int *w=bgTuples;w!=endTuples;w++)
8413 for(int j=0;j<newNbOfComp;j++)
8415 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8416 pt[(std::size_t)(*w)*nbComp+j*stepComp]=a;
8420 void DataArrayInt::setPartOfValues4(const DataArrayInt *a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
8423 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues4 : input DataArrayInt is NULL !");
8424 const char msg[]="DataArrayInt::setPartOfValues4";
8426 a->checkAllocated();
8427 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
8428 int newNbOfComp=(int)std::distance(bgComp,endComp);
8429 int nbComp=getNumberOfComponents();
8430 for(const int *z=bgComp;z!=endComp;z++)
8431 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
8432 int nbOfTuples=getNumberOfTuples();
8433 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
8434 bool assignTech=true;
8435 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
8437 if(strictCompoCompare)
8438 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
8442 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
8445 const int *srcPt=a->getConstPointer();
8446 int *pt=getPointer()+bgTuples*nbComp;
8449 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8450 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
8455 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8457 const int *srcPt2=srcPt;
8458 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
8464 void DataArrayInt::setPartOfValuesSimple4(int a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp)
8466 const char msg[]="DataArrayInt::setPartOfValuesSimple4";
8468 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
8469 int nbComp=getNumberOfComponents();
8470 for(const int *z=bgComp;z!=endComp;z++)
8471 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
8472 int nbOfTuples=getNumberOfTuples();
8473 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
8474 int *pt=getPointer()+bgTuples*nbComp;
8475 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8476 for(const int *z=bgComp;z!=endComp;z++)
8481 * Copy some tuples from another DataArrayInt into specified tuples
8482 * of \a this array. Textual data is not copied. Both arrays must have equal number of
8484 * Both the tuples to assign and the tuples to assign to are defined by a DataArrayInt.
8485 * All components of selected tuples are copied.
8486 * \param [in] a - the array to copy values from.
8487 * \param [in] tuplesSelec - the array specifying both source tuples of \a a and
8488 * target tuples of \a this. \a tuplesSelec has two components, and the
8489 * first component specifies index of the source tuple and the second
8490 * one specifies index of the target tuple.
8491 * \throw If \a this is not allocated.
8492 * \throw If \a a is NULL.
8493 * \throw If \a a is not allocated.
8494 * \throw If \a tuplesSelec is NULL.
8495 * \throw If \a tuplesSelec is not allocated.
8496 * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
8497 * \throw If \a tuplesSelec->getNumberOfComponents() != 2.
8498 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
8499 * the corresponding (\a this or \a a) array.
8501 void DataArrayInt::setPartOfValuesAdv(const DataArrayInt *a, const DataArrayInt *tuplesSelec)
8503 if(!a || !tuplesSelec)
8504 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : DataArrayInt pointer in input is NULL !");
8506 a->checkAllocated();
8507 tuplesSelec->checkAllocated();
8508 int nbOfComp=getNumberOfComponents();
8509 if(nbOfComp!=a->getNumberOfComponents())
8510 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : This and a do not have the same number of components !");
8511 if(tuplesSelec->getNumberOfComponents()!=2)
8512 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : Expecting to have a tuple selector DataArrayInt instance with exactly 2 components !");
8513 int thisNt=getNumberOfTuples();
8514 int aNt=a->getNumberOfTuples();
8515 int *valsToSet=getPointer();
8516 const int *valsSrc=a->getConstPointer();
8517 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple+=2)
8519 if(tuple[1]>=0 && tuple[1]<aNt)
8521 if(tuple[0]>=0 && tuple[0]<thisNt)
8522 std::copy(valsSrc+nbOfComp*tuple[1],valsSrc+nbOfComp*(tuple[1]+1),valsToSet+nbOfComp*tuple[0]);
8525 std::ostringstream oss; oss << "DataArrayInt::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
8526 oss << " of 'tuplesSelec' request of tuple id #" << tuple[0] << " in 'this' ! It should be in [0," << thisNt << ") !";
8527 throw INTERP_KERNEL::Exception(oss.str().c_str());
8532 std::ostringstream oss; oss << "DataArrayInt::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
8533 oss << " of 'tuplesSelec' request of tuple id #" << tuple[1] << " in 'a' ! It should be in [0," << aNt << ") !";
8534 throw INTERP_KERNEL::Exception(oss.str().c_str());
8540 * Copy some tuples from another DataArrayInt (\a aBase) into contiguous tuples
8541 * of \a this array. Textual data is not copied. Both arrays must have equal number of
8543 * The tuples to assign to are defined by index of the first tuple, and
8544 * their number is defined by \a tuplesSelec->getNumberOfTuples().
8545 * The tuples to copy are defined by values of a DataArrayInt.
8546 * All components of selected tuples are copied.
8547 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
8549 * \param [in] aBase - the array to copy values from.
8550 * \param [in] tuplesSelec - the array specifying tuples of \a aBase to copy.
8551 * \throw If \a this is not allocated.
8552 * \throw If \a aBase is NULL.
8553 * \throw If \a aBase is not allocated.
8554 * \throw If \a tuplesSelec is NULL.
8555 * \throw If \a tuplesSelec is not allocated.
8556 * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
8557 * \throw If \a tuplesSelec->getNumberOfComponents() != 1.
8558 * \throw If <em>tupleIdStart + tuplesSelec->getNumberOfTuples() > this->getNumberOfTuples().</em>
8559 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
8562 void DataArrayInt::setContigPartOfSelectedValues(int tupleIdStart, const DataArray *aBase, const DataArrayInt *tuplesSelec)
8564 if(!aBase || !tuplesSelec)
8565 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : input DataArray is NULL !");
8566 const DataArrayInt *a=dynamic_cast<const DataArrayInt *>(aBase);
8568 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : input DataArray aBase is not a DataArrayInt !");
8570 a->checkAllocated();
8571 tuplesSelec->checkAllocated();
8572 int nbOfComp=getNumberOfComponents();
8573 if(nbOfComp!=a->getNumberOfComponents())
8574 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : This and a do not have the same number of components !");
8575 if(tuplesSelec->getNumberOfComponents()!=1)
8576 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : Expecting to have a tuple selector DataArrayInt instance with exactly 1 component !");
8577 int thisNt=getNumberOfTuples();
8578 int aNt=a->getNumberOfTuples();
8579 int nbOfTupleToWrite=tuplesSelec->getNumberOfTuples();
8580 int *valsToSet=getPointer()+tupleIdStart*nbOfComp;
8581 if(tupleIdStart+nbOfTupleToWrite>thisNt)
8582 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : invalid number range of values to write !");
8583 const int *valsSrc=a->getConstPointer();
8584 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple++,valsToSet+=nbOfComp)
8586 if(*tuple>=0 && *tuple<aNt)
8588 std::copy(valsSrc+nbOfComp*(*tuple),valsSrc+nbOfComp*(*tuple+1),valsToSet);
8592 std::ostringstream oss; oss << "DataArrayInt::setContigPartOfSelectedValues : Tuple #" << std::distance(tuplesSelec->begin(),tuple);
8593 oss << " of 'tuplesSelec' request of tuple id #" << *tuple << " in 'a' ! It should be in [0," << aNt << ") !";
8594 throw INTERP_KERNEL::Exception(oss.str().c_str());
8600 * Copy some tuples from another DataArrayInt (\a aBase) into contiguous tuples
8601 * of \a this array. Textual data is not copied. Both arrays must have equal number of
8603 * The tuples to copy are defined by three values similar to parameters of
8604 * the Python function \c range(\c start,\c stop,\c step).
8605 * The tuples to assign to are defined by index of the first tuple, and
8606 * their number is defined by number of tuples to copy.
8607 * All components of selected tuples are copied.
8608 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
8610 * \param [in] aBase - the array to copy values from.
8611 * \param [in] bg - index of the first tuple to copy of the array \a aBase.
8612 * \param [in] end2 - index of the tuple of \a aBase before which the tuples to copy
8614 * \param [in] step - index increment to get index of the next tuple to copy.
8615 * \throw If \a this is not allocated.
8616 * \throw If \a aBase is NULL.
8617 * \throw If \a aBase is not allocated.
8618 * \throw If <em>this->getNumberOfComponents() != aBase->getNumberOfComponents()</em>.
8619 * \throw If <em>tupleIdStart + len(range(bg,end2,step)) > this->getNumberOfTuples().</em>
8620 * \throw If parameters specifying tuples to copy, do not give a
8621 * non-empty range of increasing indices or indices are out of a valid range
8622 * for the array \a aBase.
8624 void DataArrayInt::setContigPartOfSelectedValues2(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step)
8627 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : input DataArray is NULL !");
8628 const DataArrayInt *a=dynamic_cast<const DataArrayInt *>(aBase);
8630 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : input DataArray aBase is not a DataArrayInt !");
8632 a->checkAllocated();
8633 int nbOfComp=getNumberOfComponents();
8634 const char msg[]="DataArrayInt::setContigPartOfSelectedValues2";
8635 int nbOfTupleToWrite=DataArray::GetNumberOfItemGivenBES(bg,end2,step,msg);
8636 if(nbOfComp!=a->getNumberOfComponents())
8637 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : This and a do not have the same number of components !");
8638 int thisNt=getNumberOfTuples();
8639 int aNt=a->getNumberOfTuples();
8640 int *valsToSet=getPointer()+tupleIdStart*nbOfComp;
8641 if(tupleIdStart+nbOfTupleToWrite>thisNt)
8642 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : invalid number range of values to write !");
8644 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : invalid range of values to read !");
8645 const int *valsSrc=a->getConstPointer()+bg*nbOfComp;
8646 for(int i=0;i<nbOfTupleToWrite;i++,valsToSet+=nbOfComp,valsSrc+=step*nbOfComp)
8648 std::copy(valsSrc,valsSrc+nbOfComp,valsToSet);
8653 * Returns a value located at specified tuple and component.
8654 * This method is equivalent to DataArrayInt::getIJ() except that validity of
8655 * parameters is checked. So this method is safe but expensive if used to go through
8656 * all values of \a this.
8657 * \param [in] tupleId - index of tuple of interest.
8658 * \param [in] compoId - index of component of interest.
8659 * \return double - value located by \a tupleId and \a compoId.
8660 * \throw If \a this is not allocated.
8661 * \throw If condition <em>( 0 <= tupleId < this->getNumberOfTuples() )</em> is violated.
8662 * \throw If condition <em>( 0 <= compoId < this->getNumberOfComponents() )</em> is violated.
8664 int DataArrayInt::getIJSafe(int tupleId, int compoId) const
8667 if(tupleId<0 || tupleId>=getNumberOfTuples())
8669 std::ostringstream oss; oss << "DataArrayInt::getIJSafe : request for tupleId " << tupleId << " should be in [0," << getNumberOfTuples() << ") !";
8670 throw INTERP_KERNEL::Exception(oss.str().c_str());
8672 if(compoId<0 || compoId>=getNumberOfComponents())
8674 std::ostringstream oss; oss << "DataArrayInt::getIJSafe : request for compoId " << compoId << " should be in [0," << getNumberOfComponents() << ") !";
8675 throw INTERP_KERNEL::Exception(oss.str().c_str());
8677 return _mem[tupleId*_info_on_compo.size()+compoId];
8681 * Returns the first value of \a this.
8682 * \return int - the last value of \a this array.
8683 * \throw If \a this is not allocated.
8684 * \throw If \a this->getNumberOfComponents() != 1.
8685 * \throw If \a this->getNumberOfTuples() < 1.
8687 int DataArrayInt::front() const
8690 if(getNumberOfComponents()!=1)
8691 throw INTERP_KERNEL::Exception("DataArrayInt::front : number of components not equal to one !");
8692 int nbOfTuples=getNumberOfTuples();
8694 throw INTERP_KERNEL::Exception("DataArrayInt::front : number of tuples must be >= 1 !");
8695 return *(getConstPointer());
8699 * Returns the last value of \a this.
8700 * \return int - the last value of \a this array.
8701 * \throw If \a this is not allocated.
8702 * \throw If \a this->getNumberOfComponents() != 1.
8703 * \throw If \a this->getNumberOfTuples() < 1.
8705 int DataArrayInt::back() const
8708 if(getNumberOfComponents()!=1)
8709 throw INTERP_KERNEL::Exception("DataArrayInt::back : number of components not equal to one !");
8710 int nbOfTuples=getNumberOfTuples();
8712 throw INTERP_KERNEL::Exception("DataArrayInt::back : number of tuples must be >= 1 !");
8713 return *(getConstPointer()+nbOfTuples-1);
8717 * Assign pointer to one array to a pointer to another appay. Reference counter of
8718 * \a arrayToSet is incremented / decremented.
8719 * \param [in] newArray - the pointer to array to assign to \a arrayToSet.
8720 * \param [in,out] arrayToSet - the pointer to array to assign to.
8722 void DataArrayInt::SetArrayIn(DataArrayInt *newArray, DataArrayInt* &arrayToSet)
8724 if(newArray!=arrayToSet)
8727 arrayToSet->decrRef();
8728 arrayToSet=newArray;
8730 arrayToSet->incrRef();
8734 DataArrayIntIterator *DataArrayInt::iterator()
8736 return new DataArrayIntIterator(this);
8740 * Creates a new DataArrayInt containing IDs (indices) of tuples holding value equal to a
8741 * given one. The ids are sorted in the ascending order.
8742 * \param [in] val - the value to find within \a this.
8743 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8744 * array using decrRef() as it is no more needed.
8745 * \throw If \a this is not allocated.
8746 * \throw If \a this->getNumberOfComponents() != 1.
8747 * \sa DataArrayInt::getIdsEqualTuple
8749 DataArrayInt *DataArrayInt::getIdsEqual(int val) const
8752 if(getNumberOfComponents()!=1)
8753 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqual : the array must have only one component, you can call 'rearrange' method before !");
8754 const int *cptr(getConstPointer());
8755 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8756 int nbOfTuples=getNumberOfTuples();
8757 for(int i=0;i<nbOfTuples;i++,cptr++)
8759 ret->pushBackSilent(i);
8764 * Creates a new DataArrayInt containing IDs (indices) of tuples holding value \b not
8765 * equal to a given one.
8766 * \param [in] val - the value to ignore within \a this.
8767 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8768 * array using decrRef() as it is no more needed.
8769 * \throw If \a this is not allocated.
8770 * \throw If \a this->getNumberOfComponents() != 1.
8772 DataArrayInt *DataArrayInt::getIdsNotEqual(int val) const
8775 if(getNumberOfComponents()!=1)
8776 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotEqual : the array must have only one component, you can call 'rearrange' method before !");
8777 const int *cptr(getConstPointer());
8778 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8779 int nbOfTuples=getNumberOfTuples();
8780 for(int i=0;i<nbOfTuples;i++,cptr++)
8782 ret->pushBackSilent(i);
8787 * Creates a new DataArrayInt containing IDs (indices) of tuples holding tuple equal to those defined by [ \a tupleBg , \a tupleEnd )
8788 * This method is an extension of DataArrayInt::getIdsEqual method.
8790 * \param [in] tupleBg - the begin (included) of the input tuple to find within \a this.
8791 * \param [in] tupleEnd - the end (excluded) of the input tuple to find within \a this.
8792 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8793 * array using decrRef() as it is no more needed.
8794 * \throw If \a this is not allocated.
8795 * \throw If \a this->getNumberOfComponents() != std::distance(tupleBg,tupleEnd).
8796 * \throw If \a this->getNumberOfComponents() is equal to 0.
8797 * \sa DataArrayInt::getIdsEqual
8799 DataArrayInt *DataArrayInt::getIdsEqualTuple(const int *tupleBg, const int *tupleEnd) const
8801 std::size_t nbOfCompoExp(std::distance(tupleBg,tupleEnd));
8803 if(getNumberOfComponents()!=(int)nbOfCompoExp)
8805 std::ostringstream oss; oss << "DataArrayInt::getIdsEqualTuple : mismatch of number of components. Input tuple has " << nbOfCompoExp << " whereas this array has " << getNumberOfComponents() << " components !";
8806 throw INTERP_KERNEL::Exception(oss.str().c_str());
8809 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqualTuple : number of components should be > 0 !");
8810 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8811 const int *bg(begin()),*end2(end()),*work(begin());
8814 work=std::search(work,end2,tupleBg,tupleEnd);
8817 std::size_t pos(std::distance(bg,work));
8818 if(pos%nbOfCompoExp==0)
8819 ret->pushBackSilent(pos/nbOfCompoExp);
8827 * Assigns \a newValue to all elements holding \a oldValue within \a this
8828 * one-dimensional array.
8829 * \param [in] oldValue - the value to replace.
8830 * \param [in] newValue - the value to assign.
8831 * \return int - number of replacements performed.
8832 * \throw If \a this is not allocated.
8833 * \throw If \a this->getNumberOfComponents() != 1.
8835 int DataArrayInt::changeValue(int oldValue, int newValue)
8838 if(getNumberOfComponents()!=1)
8839 throw INTERP_KERNEL::Exception("DataArrayInt::changeValue : the array must have only one component, you can call 'rearrange' method before !");
8840 int *start=getPointer();
8841 int *end2=start+getNbOfElems();
8843 for(int *val=start;val!=end2;val++)
8855 * Creates a new DataArrayInt containing IDs (indices) of tuples holding value equal to
8856 * one of given values.
8857 * \param [in] valsBg - an array of values to find within \a this array.
8858 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
8859 * the last value of \a valsBg is \a valsEnd[ -1 ].
8860 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8861 * array using decrRef() as it is no more needed.
8862 * \throw If \a this->getNumberOfComponents() != 1.
8864 DataArrayInt *DataArrayInt::getIdsEqualList(const int *valsBg, const int *valsEnd) const
8866 if(getNumberOfComponents()!=1)
8867 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqualList : the array must have only one component, you can call 'rearrange' method before !");
8868 std::set<int> vals2(valsBg,valsEnd);
8869 const int *cptr=getConstPointer();
8870 std::vector<int> res;
8871 int nbOfTuples=getNumberOfTuples();
8872 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8873 for(int i=0;i<nbOfTuples;i++,cptr++)
8874 if(vals2.find(*cptr)!=vals2.end())
8875 ret->pushBackSilent(i);
8880 * Creates a new DataArrayInt containing IDs (indices) of tuples holding values \b not
8881 * equal to any of given values.
8882 * \param [in] valsBg - an array of values to ignore within \a this array.
8883 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
8884 * the last value of \a valsBg is \a valsEnd[ -1 ].
8885 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8886 * array using decrRef() as it is no more needed.
8887 * \throw If \a this->getNumberOfComponents() != 1.
8889 DataArrayInt *DataArrayInt::getIdsNotEqualList(const int *valsBg, const int *valsEnd) const
8891 if(getNumberOfComponents()!=1)
8892 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotEqualList : the array must have only one component, you can call 'rearrange' method before !");
8893 std::set<int> vals2(valsBg,valsEnd);
8894 const int *cptr=getConstPointer();
8895 std::vector<int> res;
8896 int nbOfTuples=getNumberOfTuples();
8897 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8898 for(int i=0;i<nbOfTuples;i++,cptr++)
8899 if(vals2.find(*cptr)==vals2.end())
8900 ret->pushBackSilent(i);
8905 * This method is an extension of DataArrayInt::locateValue method because this method works for DataArrayInt with
8906 * any number of components excepted 0 (an INTERP_KERNEL::Exception is thrown in this case).
8907 * This method searches in \b this is there is a tuple that matched the input parameter \b tupl.
8908 * If any the tuple id is returned. If not -1 is returned.
8910 * This method throws an INTERP_KERNEL::Exception if the number of components in \b this mismatches with the size of
8911 * the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
8913 * \return tuple id where \b tupl is. -1 if no such tuple exists in \b this.
8914 * \sa DataArrayInt::search, DataArrayInt::presenceOfTuple.
8916 int DataArrayInt::locateTuple(const std::vector<int>& tupl) const
8919 int nbOfCompo=getNumberOfComponents();
8921 throw INTERP_KERNEL::Exception("DataArrayInt::locateTuple : 0 components in 'this' !");
8922 if(nbOfCompo!=(int)tupl.size())
8924 std::ostringstream oss; oss << "DataArrayInt::locateTuple : 'this' contains " << nbOfCompo << " components and searching for a tuple of length " << tupl.size() << " !";
8925 throw INTERP_KERNEL::Exception(oss.str().c_str());
8927 const int *cptr=getConstPointer();
8928 std::size_t nbOfVals=getNbOfElems();
8929 for(const int *work=cptr;work!=cptr+nbOfVals;)
8931 work=std::search(work,cptr+nbOfVals,tupl.begin(),tupl.end());
8932 if(work!=cptr+nbOfVals)
8934 if(std::distance(cptr,work)%nbOfCompo!=0)
8937 return std::distance(cptr,work)/nbOfCompo;
8944 * This method searches the sequence specified in input parameter \b vals in \b this.
8945 * This works only for DataArrayInt having number of components equal to one (if not an INTERP_KERNEL::Exception will be thrown).
8946 * This method differs from DataArrayInt::locateTuple in that the position is internal raw data is not considered here contrary to DataArrayInt::locateTuple.
8947 * \sa DataArrayInt::locateTuple
8949 int DataArrayInt::search(const std::vector<int>& vals) const
8952 int nbOfCompo=getNumberOfComponents();
8954 throw INTERP_KERNEL::Exception("DataArrayInt::search : works only for DataArrayInt instance with one component !");
8955 const int *cptr=getConstPointer();
8956 std::size_t nbOfVals=getNbOfElems();
8957 const int *loc=std::search(cptr,cptr+nbOfVals,vals.begin(),vals.end());
8958 if(loc!=cptr+nbOfVals)
8959 return std::distance(cptr,loc);
8964 * This method expects to be called when number of components of this is equal to one.
8965 * This method returns the tuple id, if it exists, of the first tuple equal to \b value.
8966 * If not any tuple contains \b value -1 is returned.
8967 * \sa DataArrayInt::presenceOfValue
8969 int DataArrayInt::locateValue(int value) const
8972 if(getNumberOfComponents()!=1)
8973 throw INTERP_KERNEL::Exception("DataArrayInt::presenceOfValue : the array must have only one component, you can call 'rearrange' method before !");
8974 const int *cptr=getConstPointer();
8975 int nbOfTuples=getNumberOfTuples();
8976 const int *ret=std::find(cptr,cptr+nbOfTuples,value);
8977 if(ret!=cptr+nbOfTuples)
8978 return std::distance(cptr,ret);
8983 * This method expects to be called when number of components of this is equal to one.
8984 * This method returns the tuple id, if it exists, of the first tuple so that the value is contained in \b vals.
8985 * If not any tuple contains one of the values contained in 'vals' false is returned.
8986 * \sa DataArrayInt::presenceOfValue
8988 int DataArrayInt::locateValue(const std::vector<int>& vals) const
8991 if(getNumberOfComponents()!=1)
8992 throw INTERP_KERNEL::Exception("DataArrayInt::presenceOfValue : the array must have only one component, you can call 'rearrange' method before !");
8993 std::set<int> vals2(vals.begin(),vals.end());
8994 const int *cptr=getConstPointer();
8995 int nbOfTuples=getNumberOfTuples();
8996 for(const int *w=cptr;w!=cptr+nbOfTuples;w++)
8997 if(vals2.find(*w)!=vals2.end())
8998 return std::distance(cptr,w);
9003 * This method returns the number of values in \a this that are equals to input parameter \a value.
9004 * This method only works for single component array.
9006 * \return a value in [ 0, \c this->getNumberOfTuples() )
9008 * \throw If \a this is not allocated
9011 int DataArrayInt::count(int value) const
9015 if(getNumberOfComponents()!=1)
9016 throw INTERP_KERNEL::Exception("DataArrayInt::count : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
9017 const int *vals=begin();
9018 int nbOfTuples=getNumberOfTuples();
9019 for(int i=0;i<nbOfTuples;i++,vals++)
9026 * This method is an extension of DataArrayInt::presenceOfValue method because this method works for DataArrayInt with
9027 * any number of components excepted 0 (an INTERP_KERNEL::Exception is thrown in this case).
9028 * This method searches in \b this is there is a tuple that matched the input parameter \b tupl.
9029 * This method throws an INTERP_KERNEL::Exception if the number of components in \b this mismatches with the size of
9030 * the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
9031 * \sa DataArrayInt::locateTuple
9033 bool DataArrayInt::presenceOfTuple(const std::vector<int>& tupl) const
9035 return locateTuple(tupl)!=-1;
9040 * Returns \a true if a given value is present within \a this one-dimensional array.
9041 * \param [in] value - the value to find within \a this array.
9042 * \return bool - \a true in case if \a value is present within \a this array.
9043 * \throw If \a this is not allocated.
9044 * \throw If \a this->getNumberOfComponents() != 1.
9047 bool DataArrayInt::presenceOfValue(int value) const
9049 return locateValue(value)!=-1;
9053 * This method expects to be called when number of components of this is equal to one.
9054 * This method returns true if it exists a tuple so that the value is contained in \b vals.
9055 * If not any tuple contains one of the values contained in 'vals' false is returned.
9056 * \sa DataArrayInt::locateValue
9058 bool DataArrayInt::presenceOfValue(const std::vector<int>& vals) const
9060 return locateValue(vals)!=-1;
9064 * Accumulates values of each component of \a this array.
9065 * \param [out] res - an array of length \a this->getNumberOfComponents(), allocated
9066 * by the caller, that is filled by this method with sum value for each
9068 * \throw If \a this is not allocated.
9070 void DataArrayInt::accumulate(int *res) const
9073 const int *ptr=getConstPointer();
9074 int nbTuple=getNumberOfTuples();
9075 int nbComps=getNumberOfComponents();
9076 std::fill(res,res+nbComps,0);
9077 for(int i=0;i<nbTuple;i++)
9078 std::transform(ptr+i*nbComps,ptr+(i+1)*nbComps,res,res,std::plus<int>());
9081 int DataArrayInt::accumulate(int compId) const
9084 const int *ptr=getConstPointer();
9085 int nbTuple=getNumberOfTuples();
9086 int nbComps=getNumberOfComponents();
9087 if(compId<0 || compId>=nbComps)
9088 throw INTERP_KERNEL::Exception("DataArrayInt::accumulate : Invalid compId specified : No such nb of components !");
9090 for(int i=0;i<nbTuple;i++)
9091 ret+=ptr[i*nbComps+compId];
9096 * This method accumulate using addition tuples in \a this using input index array [ \a bgOfIndex, \a endOfIndex ).
9097 * The returned array will have same number of components than \a this and number of tuples equal to
9098 * \c std::distance(bgOfIndex,endOfIndex) \b minus \b one.
9100 * The input index array is expected to be ascendingly sorted in which the all referenced ids should be in [0, \c this->getNumberOfTuples).
9102 * \param [in] bgOfIndex - begin (included) of the input index array.
9103 * \param [in] endOfIndex - end (excluded) of the input index array.
9104 * \return DataArrayInt * - the new instance having the same number of components than \a this.
9106 * \throw If bgOfIndex or end is NULL.
9107 * \throw If input index array is not ascendingly sorted.
9108 * \throw If there is an id in [ \a bgOfIndex, \a endOfIndex ) not in [0, \c this->getNumberOfTuples).
9109 * \throw If std::distance(bgOfIndex,endOfIndex)==0.
9111 DataArrayInt *DataArrayInt::accumulatePerChunck(const int *bgOfIndex, const int *endOfIndex) const
9113 if(!bgOfIndex || !endOfIndex)
9114 throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : input pointer NULL !");
9116 int nbCompo=getNumberOfComponents();
9117 int nbOfTuples=getNumberOfTuples();
9118 int sz=(int)std::distance(bgOfIndex,endOfIndex);
9120 throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : invalid size of input index array !");
9122 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(sz,nbCompo);
9123 const int *w=bgOfIndex;
9124 if(*w<0 || *w>=nbOfTuples)
9125 throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : The first element of the input index not in [0,nbOfTuples) !");
9126 const int *srcPt=begin()+(*w)*nbCompo;
9127 int *tmp=ret->getPointer();
9128 for(int i=0;i<sz;i++,tmp+=nbCompo,w++)
9130 std::fill(tmp,tmp+nbCompo,0);
9133 for(int j=w[0];j<w[1];j++,srcPt+=nbCompo)
9135 if(j>=0 && j<nbOfTuples)
9136 std::transform(srcPt,srcPt+nbCompo,tmp,tmp,std::plus<int>());
9139 std::ostringstream oss; oss << "DataArrayInt::accumulatePerChunck : At rank #" << i << " the input index array points to id " << j << " should be in [0," << nbOfTuples << ") !";
9140 throw INTERP_KERNEL::Exception(oss.str().c_str());
9146 std::ostringstream oss; oss << "DataArrayInt::accumulatePerChunck : At rank #" << i << " the input index array is not in ascendingly sorted.";
9147 throw INTERP_KERNEL::Exception(oss.str().c_str());
9150 ret->copyStringInfoFrom(*this);
9155 * Returns a new DataArrayInt by concatenating two given arrays, so that (1) the number
9156 * of tuples in the result array is <em> a1->getNumberOfTuples() + a2->getNumberOfTuples() -
9157 * offsetA2</em> and (2)
9158 * the number of component in the result array is same as that of each of given arrays.
9159 * First \a offsetA2 tuples of \a a2 are skipped and thus are missing from the result array.
9160 * Info on components is copied from the first of the given arrays. Number of components
9161 * in the given arrays must be the same.
9162 * \param [in] a1 - an array to include in the result array.
9163 * \param [in] a2 - another array to include in the result array.
9164 * \param [in] offsetA2 - number of tuples of \a a2 to skip.
9165 * \return DataArrayInt * - the new instance of DataArrayInt.
9166 * The caller is to delete this result array using decrRef() as it is no more
9168 * \throw If either \a a1 or \a a2 is NULL.
9169 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents().
9171 DataArrayInt *DataArrayInt::Aggregate(const DataArrayInt *a1, const DataArrayInt *a2, int offsetA2)
9174 throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : input DataArrayInt instance is NULL !");
9175 int nbOfComp=a1->getNumberOfComponents();
9176 if(nbOfComp!=a2->getNumberOfComponents())
9177 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Aggregation !");
9178 int nbOfTuple1=a1->getNumberOfTuples();
9179 int nbOfTuple2=a2->getNumberOfTuples();
9180 DataArrayInt *ret=DataArrayInt::New();
9181 ret->alloc(nbOfTuple1+nbOfTuple2-offsetA2,nbOfComp);
9182 int *pt=std::copy(a1->getConstPointer(),a1->getConstPointer()+nbOfTuple1*nbOfComp,ret->getPointer());
9183 std::copy(a2->getConstPointer()+offsetA2*nbOfComp,a2->getConstPointer()+nbOfTuple2*nbOfComp,pt);
9184 ret->copyStringInfoFrom(*a1);
9189 * Returns a new DataArrayInt by concatenating all given arrays, so that (1) the number
9190 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
9191 * the number of component in the result array is same as that of each of given arrays.
9192 * Info on components is copied from the first of the given arrays. Number of components
9193 * in the given arrays must be the same.
9194 * If the number of non null of elements in \a arr is equal to one the returned object is a copy of it
9195 * not the object itself.
9196 * \param [in] arr - a sequence of arrays to include in the result array.
9197 * \return DataArrayInt * - the new instance of DataArrayInt.
9198 * The caller is to delete this result array using decrRef() as it is no more
9200 * \throw If all arrays within \a arr are NULL.
9201 * \throw If getNumberOfComponents() of arrays within \a arr.
9203 DataArrayInt *DataArrayInt::Aggregate(const std::vector<const DataArrayInt *>& arr)
9205 std::vector<const DataArrayInt *> a;
9206 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9210 throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : input list must be NON EMPTY !");
9211 std::vector<const DataArrayInt *>::const_iterator it=a.begin();
9212 int nbOfComp=(*it)->getNumberOfComponents();
9213 int nbt=(*it++)->getNumberOfTuples();
9214 for(int i=1;it!=a.end();it++,i++)
9216 if((*it)->getNumberOfComponents()!=nbOfComp)
9217 throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : Nb of components mismatch for array aggregation !");
9218 nbt+=(*it)->getNumberOfTuples();
9220 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9221 ret->alloc(nbt,nbOfComp);
9222 int *pt=ret->getPointer();
9223 for(it=a.begin();it!=a.end();it++)
9224 pt=std::copy((*it)->getConstPointer(),(*it)->getConstPointer()+(*it)->getNbOfElems(),pt);
9225 ret->copyStringInfoFrom(*(a[0]));
9230 * This method takes as input a list of DataArrayInt instances \a arrs that represent each a packed index arrays.
9231 * A packed index array is an allocated array with one component, and at least one tuple. The first element
9232 * of each array in \a arrs must be 0. Each array in \a arrs is expected to be increasingly monotonic.
9233 * 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.
9235 * \return DataArrayInt * - a new object to be managed by the caller.
9237 DataArrayInt *DataArrayInt::AggregateIndexes(const std::vector<const DataArrayInt *>& arrs)
9240 for(std::vector<const DataArrayInt *>::const_iterator it4=arrs.begin();it4!=arrs.end();it4++)
9244 (*it4)->checkAllocated();
9245 if((*it4)->getNumberOfComponents()!=1)
9247 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with nb of compo != 1 at pos " << std::distance(arrs.begin(),it4) << " !";
9248 throw INTERP_KERNEL::Exception(oss.str().c_str());
9250 int nbTupl=(*it4)->getNumberOfTuples();
9253 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with nb of tuples < 1 at pos " << std::distance(arrs.begin(),it4) << " !";
9254 throw INTERP_KERNEL::Exception(oss.str().c_str());
9256 if((*it4)->front()!=0)
9258 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with front value != 0 at pos " << std::distance(arrs.begin(),it4) << " !";
9259 throw INTERP_KERNEL::Exception(oss.str().c_str());
9265 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a null instance at pos " << std::distance(arrs.begin(),it4) << " !";
9266 throw INTERP_KERNEL::Exception(oss.str().c_str());
9270 throw INTERP_KERNEL::Exception("DataArrayInt::AggregateIndexes : input list must be NON EMPTY !");
9271 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9272 ret->alloc(retSz,1);
9273 int *pt=ret->getPointer(); *pt++=0;
9274 for(std::vector<const DataArrayInt *>::const_iterator it=arrs.begin();it!=arrs.end();it++)
9275 pt=std::transform((*it)->begin()+1,(*it)->end(),pt,std::bind2nd(std::plus<int>(),pt[-1]));
9276 ret->copyStringInfoFrom(*(arrs[0]));
9281 * Returns the maximal value and its location within \a this one-dimensional array.
9282 * \param [out] tupleId - index of the tuple holding the maximal value.
9283 * \return int - the maximal value among all values of \a this array.
9284 * \throw If \a this->getNumberOfComponents() != 1
9285 * \throw If \a this->getNumberOfTuples() < 1
9287 int DataArrayInt::getMaxValue(int& tupleId) const
9290 if(getNumberOfComponents()!=1)
9291 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : must be applied on DataArrayInt with only one component !");
9292 int nbOfTuples=getNumberOfTuples();
9294 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : array exists but number of tuples must be > 0 !");
9295 const int *vals=getConstPointer();
9296 const int *loc=std::max_element(vals,vals+nbOfTuples);
9297 tupleId=(int)std::distance(vals,loc);
9302 * Returns the maximal value within \a this array that is allowed to have more than
9304 * \return int - the maximal value among all values of \a this array.
9305 * \throw If \a this is not allocated.
9307 int DataArrayInt::getMaxValueInArray() const
9310 const int *loc=std::max_element(begin(),end());
9315 * Returns the minimal value and its location within \a this one-dimensional array.
9316 * \param [out] tupleId - index of the tuple holding the minimal value.
9317 * \return int - the minimal value among all values of \a this array.
9318 * \throw If \a this->getNumberOfComponents() != 1
9319 * \throw If \a this->getNumberOfTuples() < 1
9321 int DataArrayInt::getMinValue(int& tupleId) const
9324 if(getNumberOfComponents()!=1)
9325 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : must be applied on DataArrayInt with only one component !");
9326 int nbOfTuples=getNumberOfTuples();
9328 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : array exists but number of tuples must be > 0 !");
9329 const int *vals=getConstPointer();
9330 const int *loc=std::min_element(vals,vals+nbOfTuples);
9331 tupleId=(int)std::distance(vals,loc);
9336 * Returns the minimal value within \a this array that is allowed to have more than
9338 * \return int - the minimal value among all values of \a this array.
9339 * \throw If \a this is not allocated.
9341 int DataArrayInt::getMinValueInArray() const
9344 const int *loc=std::min_element(begin(),end());
9349 * Returns in a single walk in \a this the min value and the max value in \a this.
9350 * \a this is expected to be single component array.
9352 * \param [out] minValue - the min value in \a this.
9353 * \param [out] maxValue - the max value in \a this.
9355 * \sa getMinValueInArray, getMinValue, getMaxValueInArray, getMaxValue
9357 void DataArrayInt::getMinMaxValues(int& minValue, int& maxValue) const
9360 if(getNumberOfComponents()!=1)
9361 throw INTERP_KERNEL::Exception("DataArrayInt::getMinMaxValues : must be applied on DataArrayInt with only one component !");
9362 int nbTuples(getNumberOfTuples());
9363 const int *pt(begin());
9364 minValue=std::numeric_limits<int>::max(); maxValue=-std::numeric_limits<int>::max();
9365 for(int i=0;i<nbTuples;i++,pt++)
9375 * Converts every value of \a this array to its absolute value.
9376 * \b WARNING this method is non const. If a new DataArrayInt instance should be built containing the result of abs DataArrayInt::computeAbs
9377 * should be called instead.
9379 * \throw If \a this is not allocated.
9380 * \sa DataArrayInt::computeAbs
9382 void DataArrayInt::abs()
9385 int *ptr(getPointer());
9386 std::size_t nbOfElems(getNbOfElems());
9387 std::transform(ptr,ptr+nbOfElems,ptr,std::ptr_fun<int,int>(std::abs));
9392 * This method builds a new instance of \a this object containing the result of std::abs applied of all elements in \a this.
9393 * This method is a const method (that do not change any values in \a this) contrary to DataArrayInt::abs method.
9395 * \return DataArrayInt * - the new instance of DataArrayInt containing the
9396 * same number of tuples and component as \a this array.
9397 * The caller is to delete this result array using decrRef() as it is no more
9399 * \throw If \a this is not allocated.
9400 * \sa DataArrayInt::abs
9402 DataArrayInt *DataArrayInt::computeAbs() const
9405 DataArrayInt *newArr(DataArrayInt::New());
9406 int nbOfTuples(getNumberOfTuples());
9407 int nbOfComp(getNumberOfComponents());
9408 newArr->alloc(nbOfTuples,nbOfComp);
9409 std::transform(begin(),end(),newArr->getPointer(),std::ptr_fun<int,int>(std::abs));
9410 newArr->copyStringInfoFrom(*this);
9415 * Apply a liner function to a given component of \a this array, so that
9416 * an array element <em>(x)</em> becomes \f$ a * x + b \f$.
9417 * \param [in] a - the first coefficient of the function.
9418 * \param [in] b - the second coefficient of the function.
9419 * \param [in] compoId - the index of component to modify.
9420 * \throw If \a this is not allocated.
9422 void DataArrayInt::applyLin(int a, int b, int compoId)
9425 int *ptr=getPointer()+compoId;
9426 int nbOfComp=getNumberOfComponents();
9427 int nbOfTuple=getNumberOfTuples();
9428 for(int i=0;i<nbOfTuple;i++,ptr+=nbOfComp)
9434 * Apply a liner function to all elements of \a this array, so that
9435 * an element _x_ becomes \f$ a * x + b \f$.
9436 * \param [in] a - the first coefficient of the function.
9437 * \param [in] b - the second coefficient of the function.
9438 * \throw If \a this is not allocated.
9440 void DataArrayInt::applyLin(int a, int b)
9443 int *ptr=getPointer();
9444 std::size_t nbOfElems=getNbOfElems();
9445 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9451 * Returns a full copy of \a this array except that sign of all elements is reversed.
9452 * \return DataArrayInt * - the new instance of DataArrayInt containing the
9453 * same number of tuples and component as \a this array.
9454 * The caller is to delete this result array using decrRef() as it is no more
9456 * \throw If \a this is not allocated.
9458 DataArrayInt *DataArrayInt::negate() const
9461 DataArrayInt *newArr=DataArrayInt::New();
9462 int nbOfTuples=getNumberOfTuples();
9463 int nbOfComp=getNumberOfComponents();
9464 newArr->alloc(nbOfTuples,nbOfComp);
9465 const int *cptr=getConstPointer();
9466 std::transform(cptr,cptr+nbOfTuples*nbOfComp,newArr->getPointer(),std::negate<int>());
9467 newArr->copyStringInfoFrom(*this);
9472 * Modify all elements of \a this array, so that
9473 * an element _x_ becomes \f$ numerator / x \f$.
9474 * \warning If an exception is thrown because of presence of 0 element in \a this
9475 * array, all elements processed before detection of the zero element remain
9477 * \param [in] numerator - the numerator used to modify array elements.
9478 * \throw If \a this is not allocated.
9479 * \throw If there is an element equal to 0 in \a this array.
9481 void DataArrayInt::applyInv(int numerator)
9484 int *ptr=getPointer();
9485 std::size_t nbOfElems=getNbOfElems();
9486 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9490 *ptr=numerator/(*ptr);
9494 std::ostringstream oss; oss << "DataArrayInt::applyInv : presence of null value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
9496 throw INTERP_KERNEL::Exception(oss.str().c_str());
9503 * Modify all elements of \a this array, so that
9504 * an element _x_ becomes \f$ x / val \f$.
9505 * \param [in] val - the denominator used to modify array elements.
9506 * \throw If \a this is not allocated.
9507 * \throw If \a val == 0.
9509 void DataArrayInt::applyDivideBy(int val)
9512 throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to divide by 0 !");
9514 int *ptr=getPointer();
9515 std::size_t nbOfElems=getNbOfElems();
9516 std::transform(ptr,ptr+nbOfElems,ptr,std::bind2nd(std::divides<int>(),val));
9521 * Modify all elements of \a this array, so that
9522 * an element _x_ becomes <em> x % val </em>.
9523 * \param [in] val - the divisor used to modify array elements.
9524 * \throw If \a this is not allocated.
9525 * \throw If \a val <= 0.
9527 void DataArrayInt::applyModulus(int val)
9530 throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to operate modulus on value <= 0 !");
9532 int *ptr=getPointer();
9533 std::size_t nbOfElems=getNbOfElems();
9534 std::transform(ptr,ptr+nbOfElems,ptr,std::bind2nd(std::modulus<int>(),val));
9539 * This method works only on data array with one component.
9540 * This method returns a newly allocated array storing stored ascendantly tuple ids in \b this so that
9541 * this[*id] in [\b vmin,\b vmax)
9543 * \param [in] vmin begin of range. This value is included in range (included).
9544 * \param [in] vmax end of range. This value is \b not included in range (excluded).
9545 * \return a newly allocated data array that the caller should deal with.
9547 * \sa DataArrayInt::getIdsNotInRange , DataArrayInt::getIdsStrictlyNegative
9549 DataArrayInt *DataArrayInt::getIdsInRange(int vmin, int vmax) const
9552 if(getNumberOfComponents()!=1)
9553 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsInRange : this must have exactly one component !");
9554 const int *cptr(begin());
9555 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
9556 int nbOfTuples(getNumberOfTuples());
9557 for(int i=0;i<nbOfTuples;i++,cptr++)
9558 if(*cptr>=vmin && *cptr<vmax)
9559 ret->pushBackSilent(i);
9564 * This method works only on data array with one component.
9565 * This method returns a newly allocated array storing stored ascendantly tuple ids in \b this so that
9566 * this[*id] \b not in [\b vmin,\b vmax)
9568 * \param [in] vmin begin of range. This value is \b not included in range (excluded).
9569 * \param [in] vmax end of range. This value is included in range (included).
9570 * \return a newly allocated data array that the caller should deal with.
9572 * \sa DataArrayInt::getIdsInRange , DataArrayInt::getIdsStrictlyNegative
9574 DataArrayInt *DataArrayInt::getIdsNotInRange(int vmin, int vmax) const
9577 if(getNumberOfComponents()!=1)
9578 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotInRange : this must have exactly one component !");
9579 const int *cptr(getConstPointer());
9580 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
9581 int nbOfTuples(getNumberOfTuples());
9582 for(int i=0;i<nbOfTuples;i++,cptr++)
9583 if(*cptr<vmin || *cptr>=vmax)
9584 ret->pushBackSilent(i);
9589 * 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.
9591 * \return a newly allocated data array that the caller should deal with.
9592 * \sa DataArrayInt::getIdsInRange
9594 DataArrayInt *DataArrayInt::getIdsStrictlyNegative() const
9597 if(getNumberOfComponents()!=1)
9598 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsStrictlyNegative : this must have exactly one component !");
9599 const int *cptr(getConstPointer());
9600 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
9601 int nbOfTuples(getNumberOfTuples());
9602 for(int i=0;i<nbOfTuples;i++,cptr++)
9604 ret->pushBackSilent(i);
9609 * This method works only on data array with one component.
9610 * 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.
9612 * \param [in] vmin begin of range. This value is included in range (included).
9613 * \param [in] vmax end of range. This value is \b not included in range (excluded).
9614 * \return if all ids in \a this are so that (*this)[i]==i for all i in [ 0, \c this->getNumberOfTuples() ). */
9615 bool DataArrayInt::checkAllIdsInRange(int vmin, int vmax) const
9618 if(getNumberOfComponents()!=1)
9619 throw INTERP_KERNEL::Exception("DataArrayInt::checkAllIdsInRange : this must have exactly one component !");
9620 int nbOfTuples=getNumberOfTuples();
9622 const int *cptr=getConstPointer();
9623 for(int i=0;i<nbOfTuples;i++,cptr++)
9625 if(*cptr>=vmin && *cptr<vmax)
9626 { ret=ret && *cptr==i; }
9629 std::ostringstream oss; oss << "DataArrayInt::checkAllIdsInRange : tuple #" << i << " has value " << *cptr << " should be in [" << vmin << "," << vmax << ") !";
9630 throw INTERP_KERNEL::Exception(oss.str().c_str());
9637 * Modify all elements of \a this array, so that
9638 * an element _x_ becomes <em> val % x </em>.
9639 * \warning If an exception is thrown because of presence of an element <= 0 in \a this
9640 * array, all elements processed before detection of the zero element remain
9642 * \param [in] val - the divident used to modify array elements.
9643 * \throw If \a this is not allocated.
9644 * \throw If there is an element equal to or less than 0 in \a this array.
9646 void DataArrayInt::applyRModulus(int val)
9649 int *ptr=getPointer();
9650 std::size_t nbOfElems=getNbOfElems();
9651 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9659 std::ostringstream oss; oss << "DataArrayInt::applyRModulus : presence of value <=0 in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
9661 throw INTERP_KERNEL::Exception(oss.str().c_str());
9668 * Modify all elements of \a this array, so that
9669 * an element _x_ becomes <em> val ^ x </em>.
9670 * \param [in] val - the value used to apply pow on all array elements.
9671 * \throw If \a this is not allocated.
9672 * \throw If \a val < 0.
9674 void DataArrayInt::applyPow(int val)
9678 throw INTERP_KERNEL::Exception("DataArrayInt::applyPow : input pow in < 0 !");
9679 int *ptr=getPointer();
9680 std::size_t nbOfElems=getNbOfElems();
9683 std::fill(ptr,ptr+nbOfElems,1);
9686 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9689 for(int j=0;j<val;j++)
9697 * Modify all elements of \a this array, so that
9698 * an element _x_ becomes \f$ val ^ x \f$.
9699 * \param [in] val - the value used to apply pow on all array elements.
9700 * \throw If \a this is not allocated.
9701 * \throw If there is an element < 0 in \a this array.
9702 * \warning If an exception is thrown because of presence of 0 element in \a this
9703 * array, all elements processed before detection of the zero element remain
9706 void DataArrayInt::applyRPow(int val)
9709 int *ptr=getPointer();
9710 std::size_t nbOfElems=getNbOfElems();
9711 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9716 for(int j=0;j<*ptr;j++)
9722 std::ostringstream oss; oss << "DataArrayInt::applyRPow : presence of negative value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
9724 throw INTERP_KERNEL::Exception(oss.str().c_str());
9731 * Returns a new DataArrayInt by aggregating two given arrays, so that (1) the number
9732 * of components in the result array is a sum of the number of components of given arrays
9733 * and (2) the number of tuples in the result array is same as that of each of given
9734 * arrays. In other words the i-th tuple of result array includes all components of
9735 * i-th tuples of all given arrays.
9736 * Number of tuples in the given arrays must be the same.
9737 * \param [in] a1 - an array to include in the result array.
9738 * \param [in] a2 - another array to include in the result array.
9739 * \return DataArrayInt * - the new instance of DataArrayInt.
9740 * The caller is to delete this result array using decrRef() as it is no more
9742 * \throw If both \a a1 and \a a2 are NULL.
9743 * \throw If any given array is not allocated.
9744 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
9746 DataArrayInt *DataArrayInt::Meld(const DataArrayInt *a1, const DataArrayInt *a2)
9748 std::vector<const DataArrayInt *> arr(2);
9749 arr[0]=a1; arr[1]=a2;
9754 * Returns a new DataArrayInt by aggregating all given arrays, so that (1) the number
9755 * of components in the result array is a sum of the number of components of given arrays
9756 * and (2) the number of tuples in the result array is same as that of each of given
9757 * arrays. In other words the i-th tuple of result array includes all components of
9758 * i-th tuples of all given arrays.
9759 * Number of tuples in the given arrays must be the same.
9760 * \param [in] arr - a sequence of arrays to include in the result array.
9761 * \return DataArrayInt * - the new instance of DataArrayInt.
9762 * The caller is to delete this result array using decrRef() as it is no more
9764 * \throw If all arrays within \a arr are NULL.
9765 * \throw If any given array is not allocated.
9766 * \throw If getNumberOfTuples() of arrays within \a arr is different.
9768 DataArrayInt *DataArrayInt::Meld(const std::vector<const DataArrayInt *>& arr)
9770 std::vector<const DataArrayInt *> a;
9771 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9775 throw INTERP_KERNEL::Exception("DataArrayInt::Meld : array must be NON empty !");
9776 std::vector<const DataArrayInt *>::const_iterator it;
9777 for(it=a.begin();it!=a.end();it++)
9778 (*it)->checkAllocated();
9780 int nbOfTuples=(*it)->getNumberOfTuples();
9781 std::vector<int> nbc(a.size());
9782 std::vector<const int *> pts(a.size());
9783 nbc[0]=(*it)->getNumberOfComponents();
9784 pts[0]=(*it++)->getConstPointer();
9785 for(int i=1;it!=a.end();it++,i++)
9787 if(nbOfTuples!=(*it)->getNumberOfTuples())
9788 throw INTERP_KERNEL::Exception("DataArrayInt::meld : mismatch of number of tuples !");
9789 nbc[i]=(*it)->getNumberOfComponents();
9790 pts[i]=(*it)->getConstPointer();
9792 int totalNbOfComp=std::accumulate(nbc.begin(),nbc.end(),0);
9793 DataArrayInt *ret=DataArrayInt::New();
9794 ret->alloc(nbOfTuples,totalNbOfComp);
9795 int *retPtr=ret->getPointer();
9796 for(int i=0;i<nbOfTuples;i++)
9797 for(int j=0;j<(int)a.size();j++)
9799 retPtr=std::copy(pts[j],pts[j]+nbc[j],retPtr);
9803 for(int i=0;i<(int)a.size();i++)
9804 for(int j=0;j<nbc[i];j++,k++)
9805 ret->setInfoOnComponent(k,a[i]->getInfoOnComponent(j));
9810 * Returns a new DataArrayInt which is a minimal partition of elements of \a groups.
9811 * The i-th item of the result array is an ID of a set of elements belonging to a
9812 * unique set of groups, which the i-th element is a part of. This set of elements
9813 * belonging to a unique set of groups is called \a family, so the result array contains
9814 * IDs of families each element belongs to.
9816 * \b Example: if we have two groups of elements: \a group1 [0,4] and \a group2 [ 0,1,2 ],
9817 * then there are 3 families:
9818 * - \a family1 (with ID 1) contains element [0] belonging to ( \a group1 + \a group2 ),
9819 * - \a family2 (with ID 2) contains elements [4] belonging to ( \a group1 ),
9820 * - \a family3 (with ID 3) contains element [1,2] belonging to ( \a group2 ), <br>
9821 * and the result array contains IDs of families [ 1,3,3,0,2 ]. <br> Note a family ID 0 which
9822 * stands for the element #3 which is in none of groups.
9824 * \param [in] groups - sequence of groups of element IDs.
9825 * \param [in] newNb - total number of elements; it must be more than max ID of element
9827 * \param [out] fidsOfGroups - IDs of families the elements of each group belong to.
9828 * \return DataArrayInt * - a new instance of DataArrayInt containing IDs of families
9829 * each element with ID from range [0, \a newNb ) belongs to. The caller is to
9830 * delete this array using decrRef() as it is no more needed.
9831 * \throw If any element ID in \a groups violates condition ( 0 <= ID < \a newNb ).
9833 DataArrayInt *DataArrayInt::MakePartition(const std::vector<const DataArrayInt *>& groups, int newNb, std::vector< std::vector<int> >& fidsOfGroups)
9835 std::vector<const DataArrayInt *> groups2;
9836 for(std::vector<const DataArrayInt *>::const_iterator it4=groups.begin();it4!=groups.end();it4++)
9838 groups2.push_back(*it4);
9839 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9840 ret->alloc(newNb,1);
9841 int *retPtr=ret->getPointer();
9842 std::fill(retPtr,retPtr+newNb,0);
9844 for(std::vector<const DataArrayInt *>::const_iterator iter=groups2.begin();iter!=groups2.end();iter++)
9846 const int *ptr=(*iter)->getConstPointer();
9847 std::size_t nbOfElem=(*iter)->getNbOfElems();
9849 for(int j=0;j<sfid;j++)
9852 for(std::size_t i=0;i<nbOfElem;i++)
9854 if(ptr[i]>=0 && ptr[i]<newNb)
9856 if(retPtr[ptr[i]]==j)
9864 std::ostringstream oss; oss << "DataArrayInt::MakePartition : In group \"" << (*iter)->getName() << "\" in tuple #" << i << " value = " << ptr[i] << " ! Should be in [0," << newNb;
9866 throw INTERP_KERNEL::Exception(oss.str().c_str());
9873 fidsOfGroups.clear();
9874 fidsOfGroups.resize(groups2.size());
9876 for(std::vector<const DataArrayInt *>::const_iterator iter=groups2.begin();iter!=groups2.end();iter++,grId++)
9879 const int *ptr=(*iter)->getConstPointer();
9880 std::size_t nbOfElem=(*iter)->getNbOfElems();
9881 for(const int *p=ptr;p!=ptr+nbOfElem;p++)
9882 tmp.insert(retPtr[*p]);
9883 fidsOfGroups[grId].insert(fidsOfGroups[grId].end(),tmp.begin(),tmp.end());
9889 * Returns a new DataArrayInt which contains all elements of given one-dimensional
9890 * arrays. The result array does not contain any duplicates and its values
9891 * are sorted in ascending order.
9892 * \param [in] arr - sequence of DataArrayInt's to unite.
9893 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9894 * array using decrRef() as it is no more needed.
9895 * \throw If any \a arr[i] is not allocated.
9896 * \throw If \a arr[i]->getNumberOfComponents() != 1.
9898 DataArrayInt *DataArrayInt::BuildUnion(const std::vector<const DataArrayInt *>& arr)
9900 std::vector<const DataArrayInt *> a;
9901 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9904 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9906 (*it)->checkAllocated();
9907 if((*it)->getNumberOfComponents()!=1)
9908 throw INTERP_KERNEL::Exception("DataArrayInt::BuildUnion : only single component allowed !");
9912 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9914 const int *pt=(*it)->getConstPointer();
9915 int nbOfTuples=(*it)->getNumberOfTuples();
9916 r.insert(pt,pt+nbOfTuples);
9918 DataArrayInt *ret=DataArrayInt::New();
9919 ret->alloc((int)r.size(),1);
9920 std::copy(r.begin(),r.end(),ret->getPointer());
9925 * Returns a new DataArrayInt which contains elements present in each of given one-dimensional
9926 * arrays. The result array does not contain any duplicates and its values
9927 * are sorted in ascending order.
9928 * \param [in] arr - sequence of DataArrayInt's to intersect.
9929 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9930 * array using decrRef() as it is no more needed.
9931 * \throw If any \a arr[i] is not allocated.
9932 * \throw If \a arr[i]->getNumberOfComponents() != 1.
9934 DataArrayInt *DataArrayInt::BuildIntersection(const std::vector<const DataArrayInt *>& arr)
9936 std::vector<const DataArrayInt *> a;
9937 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9940 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9942 (*it)->checkAllocated();
9943 if((*it)->getNumberOfComponents()!=1)
9944 throw INTERP_KERNEL::Exception("DataArrayInt::BuildIntersection : only single component allowed !");
9948 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9950 const int *pt=(*it)->getConstPointer();
9951 int nbOfTuples=(*it)->getNumberOfTuples();
9952 std::set<int> s1(pt,pt+nbOfTuples);
9956 std::set_intersection(r.begin(),r.end(),s1.begin(),s1.end(),inserter(r2,r2.end()));
9962 DataArrayInt *ret(DataArrayInt::New());
9963 ret->alloc((int)r.size(),1);
9964 std::copy(r.begin(),r.end(),ret->getPointer());
9969 namespace ParaMEDMEMImpl
9974 OpSwitchedOn(int *pt):_pt(pt),_cnt(0) { }
9975 void operator()(const bool& b) { if(b) *_pt++=_cnt; _cnt++; }
9984 OpSwitchedOff(int *pt):_pt(pt),_cnt(0) { }
9985 void operator()(const bool& b) { if(!b) *_pt++=_cnt; _cnt++; }
9994 * This method returns the list of ids in ascending mode so that v[id]==true.
9996 DataArrayInt *DataArrayInt::BuildListOfSwitchedOn(const std::vector<bool>& v)
9998 int sz((int)std::count(v.begin(),v.end(),true));
9999 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
10000 std::for_each(v.begin(),v.end(),ParaMEDMEMImpl::OpSwitchedOn(ret->getPointer()));
10005 * This method returns the list of ids in ascending mode so that v[id]==false.
10007 DataArrayInt *DataArrayInt::BuildListOfSwitchedOff(const std::vector<bool>& v)
10009 int sz((int)std::count(v.begin(),v.end(),false));
10010 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
10011 std::for_each(v.begin(),v.end(),ParaMEDMEMImpl::OpSwitchedOff(ret->getPointer()));
10016 * This method allows to put a vector of vector of integer into a more compact data stucture (skyline).
10017 * This method is not available into python because no available optimized data structure available to map std::vector< std::vector<int> >.
10019 * \param [in] v the input data structure to be translate into skyline format.
10020 * \param [out] data the first element of the skyline format. The user is expected to deal with newly allocated array.
10021 * \param [out] dataIndex the second element of the skyline format.
10023 void DataArrayInt::PutIntoToSkylineFrmt(const std::vector< std::vector<int> >& v, DataArrayInt *& data, DataArrayInt *& dataIndex)
10025 int sz((int)v.size());
10026 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret0(DataArrayInt::New()),ret1(DataArrayInt::New());
10027 ret1->alloc(sz+1,1);
10028 int *pt(ret1->getPointer()); *pt=0;
10029 for(int i=0;i<sz;i++,pt++)
10030 pt[1]=pt[0]+(int)v[i].size();
10031 ret0->alloc(ret1->back(),1);
10032 pt=ret0->getPointer();
10033 for(int i=0;i<sz;i++)
10034 pt=std::copy(v[i].begin(),v[i].end(),pt);
10035 data=ret0.retn(); dataIndex=ret1.retn();
10039 * Returns a new DataArrayInt which contains a complement of elements of \a this
10040 * one-dimensional array. I.e. the result array contains all elements from the range [0,
10041 * \a nbOfElement) not present in \a this array.
10042 * \param [in] nbOfElement - maximal size of the result array.
10043 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
10044 * array using decrRef() as it is no more needed.
10045 * \throw If \a this is not allocated.
10046 * \throw If \a this->getNumberOfComponents() != 1.
10047 * \throw If any element \a x of \a this array violates condition ( 0 <= \a x < \a
10050 DataArrayInt *DataArrayInt::buildComplement(int nbOfElement) const
10053 if(getNumberOfComponents()!=1)
10054 throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : only single component allowed !");
10055 std::vector<bool> tmp(nbOfElement);
10056 const int *pt=getConstPointer();
10057 int nbOfTuples=getNumberOfTuples();
10058 for(const int *w=pt;w!=pt+nbOfTuples;w++)
10059 if(*w>=0 && *w<nbOfElement)
10062 throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : an element is not in valid range : [0,nbOfElement) !");
10063 int nbOfRetVal=(int)std::count(tmp.begin(),tmp.end(),false);
10064 DataArrayInt *ret=DataArrayInt::New();
10065 ret->alloc(nbOfRetVal,1);
10067 int *retPtr=ret->getPointer();
10068 for(int i=0;i<nbOfElement;i++)
10075 * Returns a new DataArrayInt containing elements of \a this one-dimensional missing
10076 * from an \a other one-dimensional array.
10077 * \param [in] other - a DataArrayInt containing elements not to include in the result array.
10078 * \return DataArrayInt * - a new instance of DataArrayInt with one component. The
10079 * caller is to delete this array using decrRef() as it is no more needed.
10080 * \throw If \a other is NULL.
10081 * \throw If \a other is not allocated.
10082 * \throw If \a other->getNumberOfComponents() != 1.
10083 * \throw If \a this is not allocated.
10084 * \throw If \a this->getNumberOfComponents() != 1.
10085 * \sa DataArrayInt::buildSubstractionOptimized()
10087 DataArrayInt *DataArrayInt::buildSubstraction(const DataArrayInt *other) const
10090 throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : DataArrayInt pointer in input is NULL !");
10092 other->checkAllocated();
10093 if(getNumberOfComponents()!=1)
10094 throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed !");
10095 if(other->getNumberOfComponents()!=1)
10096 throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed for other type !");
10097 const int *pt=getConstPointer();
10098 int nbOfTuples=getNumberOfTuples();
10099 std::set<int> s1(pt,pt+nbOfTuples);
10100 pt=other->getConstPointer();
10101 nbOfTuples=other->getNumberOfTuples();
10102 std::set<int> s2(pt,pt+nbOfTuples);
10103 std::vector<int> r;
10104 std::set_difference(s1.begin(),s1.end(),s2.begin(),s2.end(),std::back_insert_iterator< std::vector<int> >(r));
10105 DataArrayInt *ret=DataArrayInt::New();
10106 ret->alloc((int)r.size(),1);
10107 std::copy(r.begin(),r.end(),ret->getPointer());
10112 * \a this is expected to have one component and to be sorted ascendingly (as for \a other).
10113 * \a other is expected to be a part of \a this. If not DataArrayInt::buildSubstraction should be called instead.
10115 * \param [in] other an array with one component and expected to be sorted ascendingly.
10116 * \ret list of ids in \a this but not in \a other.
10117 * \sa DataArrayInt::buildSubstraction
10119 DataArrayInt *DataArrayInt::buildSubstractionOptimized(const DataArrayInt *other) const
10121 static const char *MSG="DataArrayInt::buildSubstractionOptimized : only single component allowed !";
10122 if(!other) throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstractionOptimized : NULL input array !");
10123 checkAllocated(); other->checkAllocated();
10124 if(getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception(MSG);
10125 if(other->getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception(MSG);
10126 const int *pt1Bg(begin()),*pt1End(end()),*pt2Bg(other->begin()),*pt2End(other->end());
10127 const int *work1(pt1Bg),*work2(pt2Bg);
10128 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
10129 for(;work1!=pt1End;work1++)
10131 if(work2!=pt2End && *work1==*work2)
10134 ret->pushBackSilent(*work1);
10141 * Returns a new DataArrayInt which contains all elements of \a this and a given
10142 * one-dimensional arrays. The result array does not contain any duplicates
10143 * and its values are sorted in ascending order.
10144 * \param [in] other - an array to unite with \a this one.
10145 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
10146 * array using decrRef() as it is no more needed.
10147 * \throw If \a this or \a other is not allocated.
10148 * \throw If \a this->getNumberOfComponents() != 1.
10149 * \throw If \a other->getNumberOfComponents() != 1.
10151 DataArrayInt *DataArrayInt::buildUnion(const DataArrayInt *other) const
10153 std::vector<const DataArrayInt *>arrs(2);
10154 arrs[0]=this; arrs[1]=other;
10155 return BuildUnion(arrs);
10160 * Returns a new DataArrayInt which contains elements present in both \a this and a given
10161 * one-dimensional arrays. The result array does not contain any duplicates
10162 * and its values are sorted in ascending order.
10163 * \param [in] other - an array to intersect with \a this one.
10164 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
10165 * array using decrRef() as it is no more needed.
10166 * \throw If \a this or \a other is not allocated.
10167 * \throw If \a this->getNumberOfComponents() != 1.
10168 * \throw If \a other->getNumberOfComponents() != 1.
10170 DataArrayInt *DataArrayInt::buildIntersection(const DataArrayInt *other) const
10172 std::vector<const DataArrayInt *>arrs(2);
10173 arrs[0]=this; arrs[1]=other;
10174 return BuildIntersection(arrs);
10178 * This method can be applied on allocated with one component DataArrayInt instance.
10179 * This method is typically relevant for sorted arrays. All consecutive duplicated items in \a this will appear only once in returned DataArrayInt instance.
10180 * 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]
10182 * \return a newly allocated array that contain the result of the unique operation applied on \a this.
10183 * \throw if \a this is not allocated or if \a this has not exactly one component.
10184 * \sa DataArrayInt::buildUniqueNotSorted
10186 DataArrayInt *DataArrayInt::buildUnique() const
10189 if(getNumberOfComponents()!=1)
10190 throw INTERP_KERNEL::Exception("DataArrayInt::buildUnique : only single component allowed !");
10191 int nbOfTuples=getNumberOfTuples();
10192 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=deepCpy();
10193 int *data=tmp->getPointer();
10194 int *last=std::unique(data,data+nbOfTuples);
10195 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10196 ret->alloc(std::distance(data,last),1);
10197 std::copy(data,last,ret->getPointer());
10202 * This method can be applied on allocated with one component DataArrayInt instance.
10203 * This method keep elements only once by keeping the same order in \a this that is not expected to be sorted.
10205 * \return a newly allocated array that contain the result of the unique operation applied on \a this.
10207 * \throw if \a this is not allocated or if \a this has not exactly one component.
10209 * \sa DataArrayInt::buildUnique
10211 DataArrayInt *DataArrayInt::buildUniqueNotSorted() const
10214 if(getNumberOfComponents()!=1)
10215 throw INTERP_KERNEL::Exception("DataArrayInt::buildUniqueNotSorted : only single component allowed !");
10217 getMinMaxValues(minVal,maxVal);
10218 std::vector<bool> b(maxVal-minVal+1,false);
10219 const int *ptBg(begin()),*endBg(end());
10220 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
10221 for(const int *pt=ptBg;pt!=endBg;pt++)
10225 ret->pushBackSilent(*pt);
10226 b[*pt-minVal]=true;
10229 ret->copyStringInfoFrom(*this);
10234 * Returns a new DataArrayInt which contains size of every of groups described by \a this
10235 * "index" array. Such "index" array is returned for example by
10236 * \ref ParaMEDMEM::MEDCouplingUMesh::buildDescendingConnectivity
10237 * "MEDCouplingUMesh::buildDescendingConnectivity" and
10238 * \ref ParaMEDMEM::MEDCouplingUMesh::getNodalConnectivityIndex
10239 * "MEDCouplingUMesh::getNodalConnectivityIndex" etc.
10240 * This method preforms the reverse operation of DataArrayInt::computeOffsets2.
10241 * \return DataArrayInt * - a new instance of DataArrayInt, whose number of tuples
10242 * equals to \a this->getNumberOfComponents() - 1, and number of components is 1.
10243 * The caller is to delete this array using decrRef() as it is no more needed.
10244 * \throw If \a this is not allocated.
10245 * \throw If \a this->getNumberOfComponents() != 1.
10246 * \throw If \a this->getNumberOfTuples() < 2.
10249 * - this contains [1,3,6,7,7,9,15]
10250 * - result array contains [2,3,1,0,2,6],
10251 * where 2 = 3 - 1, 3 = 6 - 3, 1 = 7 - 6 etc.
10253 * \sa DataArrayInt::computeOffsets2
10255 DataArrayInt *DataArrayInt::deltaShiftIndex() const
10258 if(getNumberOfComponents()!=1)
10259 throw INTERP_KERNEL::Exception("DataArrayInt::deltaShiftIndex : only single component allowed !");
10260 int nbOfTuples=getNumberOfTuples();
10262 throw INTERP_KERNEL::Exception("DataArrayInt::deltaShiftIndex : 1 tuple at least must be present in 'this' !");
10263 const int *ptr=getConstPointer();
10264 DataArrayInt *ret=DataArrayInt::New();
10265 ret->alloc(nbOfTuples-1,1);
10266 int *out=ret->getPointer();
10267 std::transform(ptr+1,ptr+nbOfTuples,ptr,out,std::minus<int>());
10272 * Modifies \a this one-dimensional array so that value of each element \a x
10273 * of \a this array (\a a) is computed as \f$ x_i = \sum_{j=0}^{i-1} a[ j ] \f$.
10274 * Or: for each i>0 new[i]=new[i-1]+old[i-1] for i==0 new[i]=0. Number of tuples
10275 * and components remains the same.<br>
10276 * This method is useful for allToAllV in MPI with contiguous policy. This method
10277 * differs from computeOffsets2() in that the number of tuples is \b not changed by
10279 * \throw If \a this is not allocated.
10280 * \throw If \a this->getNumberOfComponents() != 1.
10283 * - Before \a this contains [3,5,1,2,0,8]
10284 * - After \a this contains [0,3,8,9,11,11]<br>
10285 * Note that the last element 19 = 11 + 8 is missing because size of \a this
10286 * array is retained and thus there is no space to store the last element.
10288 void DataArrayInt::computeOffsets()
10291 if(getNumberOfComponents()!=1)
10292 throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsets : only single component allowed !");
10293 int nbOfTuples=getNumberOfTuples();
10296 int *work=getPointer();
10299 for(int i=1;i<nbOfTuples;i++)
10302 work[i]=work[i-1]+tmp;
10310 * Modifies \a this one-dimensional array so that value of each element \a x
10311 * of \a this array (\a a) is computed as \f$ x_i = \sum_{j=0}^{i-1} a[ j ] \f$.
10312 * Or: for each i>0 new[i]=new[i-1]+old[i-1] for i==0 new[i]=0. Number
10313 * components remains the same and number of tuples is inceamented by one.<br>
10314 * This method is useful for allToAllV in MPI with contiguous policy. This method
10315 * differs from computeOffsets() in that the number of tuples is changed by this one.
10316 * This method preforms the reverse operation of DataArrayInt::deltaShiftIndex.
10317 * \throw If \a this is not allocated.
10318 * \throw If \a this->getNumberOfComponents() != 1.
10321 * - Before \a this contains [3,5,1,2,0,8]
10322 * - After \a this contains [0,3,8,9,11,11,19]<br>
10323 * \sa DataArrayInt::deltaShiftIndex
10325 void DataArrayInt::computeOffsets2()
10328 if(getNumberOfComponents()!=1)
10329 throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsets2 : only single component allowed !");
10330 int nbOfTuples=getNumberOfTuples();
10331 int *ret=(int *)malloc((nbOfTuples+1)*sizeof(int));
10334 const int *work=getConstPointer();
10336 for(int i=0;i<nbOfTuples;i++)
10337 ret[i+1]=work[i]+ret[i];
10338 useArray(ret,true,C_DEALLOC,nbOfTuples+1,1);
10343 * Returns two new DataArrayInt instances whose contents is computed from that of \a this and \a listOfIds arrays as follows.
10344 * \a this is expected to be an offset format ( as returned by DataArrayInt::computeOffsets2 ) that is to say with one component
10345 * and ** sorted strictly increasingly **. \a listOfIds is expected to be sorted ascendingly (not strictly needed for \a listOfIds).
10346 * This methods searches in \a this, considered as a set of contiguous \c this->getNumberOfComponents() ranges, all ids in \a listOfIds
10347 * filling completely one of the ranges in \a this.
10349 * \param [in] listOfIds a list of ids that has to be sorted ascendingly.
10350 * \param [out] rangeIdsFetched the range ids fetched
10351 * \param [out] idsInInputListThatFetch contains the list of ids in \a listOfIds that are \b fully included in a range in \a this. So
10352 * \a idsInInputListThatFetch is a part of input \a listOfIds.
10354 * \sa DataArrayInt::computeOffsets2
10357 * - \a this : [0,3,7,9,15,18]
10358 * - \a listOfIds contains [0,1,2,3,7,8,15,16,17]
10359 * - \a rangeIdsFetched result array: [0,2,4]
10360 * - \a idsInInputListThatFetch result array: [0,1,2,7,8,15,16,17]
10361 * In this example id 3 in input \a listOfIds is alone so it do not appear in output \a idsInInputListThatFetch.
10364 void DataArrayInt::searchRangesInListOfIds(const DataArrayInt *listOfIds, DataArrayInt *& rangeIdsFetched, DataArrayInt *& idsInInputListThatFetch) const
10367 throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : input list of ids is null !");
10368 listOfIds->checkAllocated(); checkAllocated();
10369 if(listOfIds->getNumberOfComponents()!=1)
10370 throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : input list of ids must have exactly one component !");
10371 if(getNumberOfComponents()!=1)
10372 throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : this must have exactly one component !");
10373 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret0=DataArrayInt::New(); ret0->alloc(0,1);
10374 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New(); ret1->alloc(0,1);
10375 const int *tupEnd(listOfIds->end()),*offBg(begin()),*offEnd(end()-1);
10376 const int *tupPtr(listOfIds->begin()),*offPtr(offBg);
10377 while(tupPtr!=tupEnd && offPtr!=offEnd)
10379 if(*tupPtr==*offPtr)
10382 while(i<offPtr[1] && *tupPtr==i && tupPtr!=tupEnd) { i++; tupPtr++; }
10385 ret0->pushBackSilent((int)std::distance(offBg,offPtr));
10386 ret1->pushBackValsSilent(tupPtr-(offPtr[1]-offPtr[0]),tupPtr);
10391 { if(*tupPtr<*offPtr) tupPtr++; else offPtr++; }
10393 rangeIdsFetched=ret0.retn();
10394 idsInInputListThatFetch=ret1.retn();
10398 * Returns a new DataArrayInt whose contents is computed from that of \a this and \a
10399 * offsets arrays as follows. \a offsets is a one-dimensional array considered as an
10400 * "index" array of a "iota" array, thus, whose each element gives an index of a group
10401 * beginning within the "iota" array. And \a this is a one-dimensional array
10402 * considered as a selector of groups described by \a offsets to include into the result array.
10403 * \throw If \a offsets is NULL.
10404 * \throw If \a offsets is not allocated.
10405 * \throw If \a offsets->getNumberOfComponents() != 1.
10406 * \throw If \a offsets is not monotonically increasing.
10407 * \throw If \a this is not allocated.
10408 * \throw If \a this->getNumberOfComponents() != 1.
10409 * \throw If any element of \a this is not a valid index for \a offsets array.
10412 * - \a this: [0,2,3]
10413 * - \a offsets: [0,3,6,10,14,20]
10414 * - result array: [0,1,2,6,7,8,9,10,11,12,13] == <br>
10415 * \c range(0,3) + \c range(6,10) + \c range(10,14) ==<br>
10416 * \c range( \a offsets[ \a this[0] ], offsets[ \a this[0]+1 ]) +
10417 * \c range( \a offsets[ \a this[1] ], offsets[ \a this[1]+1 ]) +
10418 * \c range( \a offsets[ \a this[2] ], offsets[ \a this[2]+1 ])
10420 DataArrayInt *DataArrayInt::buildExplicitArrByRanges(const DataArrayInt *offsets) const
10423 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : DataArrayInt pointer in input is NULL !");
10425 if(getNumberOfComponents()!=1)
10426 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : only single component allowed !");
10427 offsets->checkAllocated();
10428 if(offsets->getNumberOfComponents()!=1)
10429 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : input array should have only single component !");
10430 int othNbTuples=offsets->getNumberOfTuples()-1;
10431 int nbOfTuples=getNumberOfTuples();
10432 int retNbOftuples=0;
10433 const int *work=getConstPointer();
10434 const int *offPtr=offsets->getConstPointer();
10435 for(int i=0;i<nbOfTuples;i++)
10438 if(val>=0 && val<othNbTuples)
10440 int delta=offPtr[val+1]-offPtr[val];
10442 retNbOftuples+=delta;
10445 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrByRanges : Tuple #" << val << " of offset array has a delta < 0 !";
10446 throw INTERP_KERNEL::Exception(oss.str().c_str());
10451 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrByRanges : Tuple #" << i << " in this contains " << val;
10452 oss << " whereas offsets array is of size " << othNbTuples+1 << " !";
10453 throw INTERP_KERNEL::Exception(oss.str().c_str());
10456 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10457 ret->alloc(retNbOftuples,1);
10458 int *retPtr=ret->getPointer();
10459 for(int i=0;i<nbOfTuples;i++)
10462 int start=offPtr[val];
10463 int off=offPtr[val+1]-start;
10464 for(int j=0;j<off;j++,retPtr++)
10471 * Returns a new DataArrayInt whose contents is computed using \a this that must be a
10472 * scaled array (monotonically increasing).
10473 from that of \a this and \a
10474 * offsets arrays as follows. \a offsets is a one-dimensional array considered as an
10475 * "index" array of a "iota" array, thus, whose each element gives an index of a group
10476 * beginning within the "iota" array. And \a this is a one-dimensional array
10477 * considered as a selector of groups described by \a offsets to include into the result array.
10478 * \throw If \a is NULL.
10479 * \throw If \a this is not allocated.
10480 * \throw If \a this->getNumberOfComponents() != 1.
10481 * \throw If \a this->getNumberOfTuples() == 0.
10482 * \throw If \a this is not monotonically increasing.
10483 * \throw If any element of ids in ( \a bg \a stop \a step ) points outside the scale in \a this.
10486 * - \a bg , \a stop and \a step : (0,5,2)
10487 * - \a this: [0,3,6,10,14,20]
10488 * - result array: [0,0,0, 2,2,2,2, 4,4,4,4,4,4] == <br>
10490 DataArrayInt *DataArrayInt::buildExplicitArrOfSliceOnScaledArr(int bg, int stop, int step) const
10493 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : not allocated array !");
10494 if(getNumberOfComponents()!=1)
10495 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : number of components is expected to be equal to one !");
10496 int nbOfTuples(getNumberOfTuples());
10498 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : number of tuples must be != 0 !");
10499 const int *ids(begin());
10500 int nbOfEltsInSlc(GetNumberOfItemGivenBESRelative(bg,stop,step,"DataArrayInt::buildExplicitArrOfSliceOnScaledArr")),sz(0),pos(bg);
10501 for(int i=0;i<nbOfEltsInSlc;i++,pos+=step)
10503 if(pos>=0 && pos<nbOfTuples-1)
10505 int delta(ids[pos+1]-ids[pos]);
10509 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrOfSliceOnScaledArr : At pos #" << i << " of input slice, value is " << pos << " and at this pos this is not monotonically increasing !";
10510 throw INTERP_KERNEL::Exception(oss.str().c_str());
10515 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrOfSliceOnScaledArr : At pos #" << i << " of input slice, value is " << pos << " should be in [0," << nbOfTuples-1 << ") !";
10516 throw INTERP_KERNEL::Exception(oss.str().c_str());
10519 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
10520 int *retPtr(ret->getPointer());
10522 for(int i=0;i<nbOfEltsInSlc;i++,pos+=step)
10524 int delta(ids[pos+1]-ids[pos]);
10525 for(int j=0;j<delta;j++,retPtr++)
10532 * 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.
10533 * 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
10534 * in tuple **i** of returned DataArrayInt.
10535 * If ranges overlapped (in theory it should not) this method do not detect it and always returns the first range.
10537 * 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)]
10538 * The return DataArrayInt will contain : **[0,4,1,2,2,3]**
10540 * \param [in] ranges typically come from output of MEDCouplingUMesh::ComputeRangesFromTypeDistribution. Each range is specified like this : 1st component is
10541 * for lower value included and 2nd component is the upper value of corresponding range **excluded**.
10542 * \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
10543 * is thrown if no ranges in \a ranges contains value in \a this.
10545 * \sa DataArrayInt::findIdInRangeForEachTuple
10547 DataArrayInt *DataArrayInt::findRangeIdForEachTuple(const DataArrayInt *ranges) const
10550 throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : null input pointer !");
10551 if(ranges->getNumberOfComponents()!=2)
10552 throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : input DataArrayInt instance should have 2 components !");
10554 if(getNumberOfComponents()!=1)
10555 throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : this should have only one component !");
10556 int nbTuples=getNumberOfTuples();
10557 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTuples,1);
10558 int nbOfRanges=ranges->getNumberOfTuples();
10559 const int *rangesPtr=ranges->getConstPointer();
10560 int *retPtr=ret->getPointer();
10561 const int *inPtr=getConstPointer();
10562 for(int i=0;i<nbTuples;i++,retPtr++)
10566 for(int j=0;j<nbOfRanges && !found;j++)
10567 if(val>=rangesPtr[2*j] && val<rangesPtr[2*j+1])
10568 { *retPtr=j; found=true; }
10573 std::ostringstream oss; oss << "DataArrayInt::findRangeIdForEachTuple : tuple #" << i << " not found by any ranges !";
10574 throw INTERP_KERNEL::Exception(oss.str().c_str());
10581 * 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.
10582 * 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
10583 * in tuple **i** of returned DataArrayInt.
10584 * If ranges overlapped (in theory it should not) this method do not detect it and always returns the sub position of the first range.
10586 * 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)]
10587 * The return DataArrayInt will contain : **[1,2,4,0,2,2]**
10588 * This method is often called in pair with DataArrayInt::findRangeIdForEachTuple method.
10590 * \param [in] ranges typically come from output of MEDCouplingUMesh::ComputeRangesFromTypeDistribution. Each range is specified like this : 1st component is
10591 * for lower value included and 2nd component is the upper value of corresponding range **excluded**.
10592 * \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
10593 * is thrown if no ranges in \a ranges contains value in \a this.
10594 * \sa DataArrayInt::findRangeIdForEachTuple
10596 DataArrayInt *DataArrayInt::findIdInRangeForEachTuple(const DataArrayInt *ranges) const
10599 throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : null input pointer !");
10600 if(ranges->getNumberOfComponents()!=2)
10601 throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : input DataArrayInt instance should have 2 components !");
10603 if(getNumberOfComponents()!=1)
10604 throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : this should have only one component !");
10605 int nbTuples=getNumberOfTuples();
10606 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTuples,1);
10607 int nbOfRanges=ranges->getNumberOfTuples();
10608 const int *rangesPtr=ranges->getConstPointer();
10609 int *retPtr=ret->getPointer();
10610 const int *inPtr=getConstPointer();
10611 for(int i=0;i<nbTuples;i++,retPtr++)
10615 for(int j=0;j<nbOfRanges && !found;j++)
10616 if(val>=rangesPtr[2*j] && val<rangesPtr[2*j+1])
10617 { *retPtr=val-rangesPtr[2*j]; found=true; }
10622 std::ostringstream oss; oss << "DataArrayInt::findIdInRangeForEachTuple : tuple #" << i << " not found by any ranges !";
10623 throw INTERP_KERNEL::Exception(oss.str().c_str());
10630 * \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).
10631 * 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).
10632 * 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 !
10633 * If this method has correctly worked, \a this will be able to be considered as a linked list.
10634 * This method does nothing if number of tuples is lower of equal to 1.
10636 * This method is useful for users having an unstructured mesh having only SEG2 to rearrange internaly the connectibity without any coordinates consideration.
10638 * \sa MEDCouplingUMesh::orderConsecutiveCells1D
10640 void DataArrayInt::sortEachPairToMakeALinkedList()
10643 if(getNumberOfComponents()!=2)
10644 throw INTERP_KERNEL::Exception("DataArrayInt::sortEachPairToMakeALinkedList : Only works on DataArrayInt instance with nb of components equal to 2 !");
10645 int nbOfTuples(getNumberOfTuples());
10648 int *conn(getPointer());
10649 for(int i=1;i<nbOfTuples;i++,conn+=2)
10653 if(conn[2]==conn[3])
10655 std::ostringstream oss; oss << "DataArrayInt::sortEachPairToMakeALinkedList : In the tuple #" << i << " presence of a pair filled with same ids !";
10656 throw INTERP_KERNEL::Exception(oss.str().c_str());
10658 if(conn[2]!=conn[1] && conn[3]==conn[1] && conn[2]!=conn[0])
10659 std::swap(conn[2],conn[3]);
10660 //not(conn[2]==conn[1] && conn[3]!=conn[1] && conn[3]!=conn[0])
10661 if(conn[2]!=conn[1] || conn[3]==conn[1] || conn[3]==conn[0])
10663 std::ostringstream oss; oss << "DataArrayInt::sortEachPairToMakeALinkedList : In the tuple #" << i << " something is invalid !";
10664 throw INTERP_KERNEL::Exception(oss.str().c_str());
10669 if(conn[0]==conn[1] || conn[2]==conn[3])
10670 throw INTERP_KERNEL::Exception("DataArrayInt::sortEachPairToMakeALinkedList : In the 2 first tuples presence of a pair filled with same ids !");
10673 s.insert(conn,conn+4);
10675 throw INTERP_KERNEL::Exception("DataArrayInt::sortEachPairToMakeALinkedList : This can't be considered as a linked list regarding 2 first tuples !");
10676 if(std::count(conn,conn+4,conn[0])==2)
10681 if(conn[2]==conn[0])
10682 { tmp[3]=conn[3]; }
10685 std::copy(tmp,tmp+4,conn);
10693 * \param [in] nbTimes specifies the nb of times each tuples in \a this will be duplicated contiguouly in returned DataArrayInt instance.
10694 * \a nbTimes should be at least equal to 1.
10695 * \return a newly allocated DataArrayInt having one component and number of tuples equal to \a nbTimes * \c this->getNumberOfTuples.
10696 * \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.
10698 DataArrayInt *DataArrayInt::duplicateEachTupleNTimes(int nbTimes) const
10701 if(getNumberOfComponents()!=1)
10702 throw INTERP_KERNEL::Exception("DataArrayInt::duplicateEachTupleNTimes : this should have only one component !");
10704 throw INTERP_KERNEL::Exception("DataArrayInt::duplicateEachTupleNTimes : nb times should be >= 1 !");
10705 int nbTuples=getNumberOfTuples();
10706 const int *inPtr=getConstPointer();
10707 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTimes*nbTuples,1);
10708 int *retPtr=ret->getPointer();
10709 for(int i=0;i<nbTuples;i++,inPtr++)
10712 for(int j=0;j<nbTimes;j++,retPtr++)
10715 ret->copyStringInfoFrom(*this);
10720 * This method returns all different values found in \a this. This method throws if \a this has not been allocated.
10721 * But the number of components can be different from one.
10722 * \return a newly allocated array (that should be dealt by the caller) containing different values in \a this.
10724 DataArrayInt *DataArrayInt::getDifferentValues() const
10728 ret.insert(begin(),end());
10729 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret2=DataArrayInt::New(); ret2->alloc((int)ret.size(),1);
10730 std::copy(ret.begin(),ret.end(),ret2->getPointer());
10731 return ret2.retn();
10735 * This method is a refinement of DataArrayInt::getDifferentValues because it returns not only different values in \a this but also, for each of
10736 * them it tells which tuple id have this id.
10737 * This method works only on arrays with one component (if it is not the case call DataArrayInt::rearrange(1) ).
10738 * This method returns two arrays having same size.
10739 * 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.
10740 * 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]]
10742 std::vector<DataArrayInt *> DataArrayInt::partitionByDifferentValues(std::vector<int>& differentIds) const
10745 if(getNumberOfComponents()!=1)
10746 throw INTERP_KERNEL::Exception("DataArrayInt::partitionByDifferentValues : this should have only one component !");
10748 std::map<int,int> m,m2,m3;
10749 for(const int *w=begin();w!=end();w++)
10751 differentIds.resize(m.size());
10752 std::vector<DataArrayInt *> ret(m.size());
10753 std::vector<int *> retPtr(m.size());
10754 for(std::map<int,int>::const_iterator it=m.begin();it!=m.end();it++,id++)
10756 m2[(*it).first]=id;
10757 ret[id]=DataArrayInt::New();
10758 ret[id]->alloc((*it).second,1);
10759 retPtr[id]=ret[id]->getPointer();
10760 differentIds[id]=(*it).first;
10763 for(const int *w=begin();w!=end();w++,id++)
10765 retPtr[m2[*w]][m3[*w]++]=id;
10771 * This method split ids in [0, \c this->getNumberOfTuples() ) using \a this array as a field of weight (>=0 each).
10772 * The aim of this method is to return a set of \a nbOfSlices chunk of contiguous ids as balanced as possible.
10774 * \param [in] nbOfSlices - number of slices expected.
10775 * \return - a vector having a size equal to \a nbOfSlices giving the start (included) and the stop (excluded) of each chunks.
10777 * \sa DataArray::GetSlice
10778 * \throw If \a this is not allocated or not with exactly one component.
10779 * \throw If an element in \a this if < 0.
10781 std::vector< std::pair<int,int> > DataArrayInt::splitInBalancedSlices(int nbOfSlices) const
10783 if(!isAllocated() || getNumberOfComponents()!=1)
10784 throw INTERP_KERNEL::Exception("DataArrayInt::splitInBalancedSlices : this array should have number of components equal to one and must be allocated !");
10786 throw INTERP_KERNEL::Exception("DataArrayInt::splitInBalancedSlices : number of slices must be >= 1 !");
10787 int sum(accumulate(0)),nbOfTuples(getNumberOfTuples());
10788 int sumPerSlc(sum/nbOfSlices),pos(0);
10789 const int *w(begin());
10790 std::vector< std::pair<int,int> > ret(nbOfSlices);
10791 for(int i=0;i<nbOfSlices;i++)
10793 std::pair<int,int> p(pos,-1);
10795 while(locSum<sumPerSlc && pos<nbOfTuples) { pos++; locSum+=*w++; }
10796 if(i!=nbOfSlices-1)
10799 p.second=nbOfTuples;
10806 * Returns a new DataArrayInt that is a sum of two given arrays. There are 3
10808 * 1. The arrays have same number of tuples and components. Then each value of
10809 * the result array (_a_) is a sum of the corresponding values of \a a1 and \a a2,
10810 * i.e.: _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, j ].
10811 * 2. The arrays have same number of tuples and one array, say _a2_, has one
10813 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, 0 ].
10814 * 3. The arrays have same number of components and one array, say _a2_, has one
10816 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ 0, j ].
10818 * Info on components is copied either from the first array (in the first case) or from
10819 * the array with maximal number of elements (getNbOfElems()).
10820 * \param [in] a1 - an array to sum up.
10821 * \param [in] a2 - another array to sum up.
10822 * \return DataArrayInt * - the new instance of DataArrayInt.
10823 * The caller is to delete this result array using decrRef() as it is no more
10825 * \throw If either \a a1 or \a a2 is NULL.
10826 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
10827 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
10828 * none of them has number of tuples or components equal to 1.
10830 DataArrayInt *DataArrayInt::Add(const DataArrayInt *a1, const DataArrayInt *a2)
10833 throw INTERP_KERNEL::Exception("DataArrayInt::Add : input DataArrayInt instance is NULL !");
10834 int nbOfTuple=a1->getNumberOfTuples();
10835 int nbOfTuple2=a2->getNumberOfTuples();
10836 int nbOfComp=a1->getNumberOfComponents();
10837 int nbOfComp2=a2->getNumberOfComponents();
10838 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=0;
10839 if(nbOfTuple==nbOfTuple2)
10841 if(nbOfComp==nbOfComp2)
10843 ret=DataArrayInt::New();
10844 ret->alloc(nbOfTuple,nbOfComp);
10845 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::plus<int>());
10846 ret->copyStringInfoFrom(*a1);
10850 int nbOfCompMin,nbOfCompMax;
10851 const DataArrayInt *aMin, *aMax;
10852 if(nbOfComp>nbOfComp2)
10854 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
10859 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
10864 ret=DataArrayInt::New();
10865 ret->alloc(nbOfTuple,nbOfCompMax);
10866 const int *aMinPtr=aMin->getConstPointer();
10867 const int *aMaxPtr=aMax->getConstPointer();
10868 int *res=ret->getPointer();
10869 for(int i=0;i<nbOfTuple;i++)
10870 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::plus<int>(),aMinPtr[i]));
10871 ret->copyStringInfoFrom(*aMax);
10874 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
10877 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
10879 if(nbOfComp==nbOfComp2)
10881 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
10882 const DataArrayInt *aMin=nbOfTuple>nbOfTuple2?a2:a1;
10883 const DataArrayInt *aMax=nbOfTuple>nbOfTuple2?a1:a2;
10884 const int *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
10885 ret=DataArrayInt::New();
10886 ret->alloc(nbOfTupleMax,nbOfComp);
10887 int *res=ret->getPointer();
10888 for(int i=0;i<nbOfTupleMax;i++)
10889 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::plus<int>());
10890 ret->copyStringInfoFrom(*aMax);
10893 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
10896 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Add !");
10901 * Adds values of another DataArrayInt to values of \a this one. There are 3
10903 * 1. The arrays have same number of tuples and components. Then each value of
10904 * \a other array is added to the corresponding value of \a this array, i.e.:
10905 * _a_ [ i, j ] += _other_ [ i, j ].
10906 * 2. The arrays have same number of tuples and \a other array has one component. Then
10907 * _a_ [ i, j ] += _other_ [ i, 0 ].
10908 * 3. The arrays have same number of components and \a other array has one tuple. Then
10909 * _a_ [ i, j ] += _a2_ [ 0, j ].
10911 * \param [in] other - an array to add to \a this one.
10912 * \throw If \a other is NULL.
10913 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
10914 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
10915 * \a other has number of both tuples and components not equal to 1.
10917 void DataArrayInt::addEqual(const DataArrayInt *other)
10920 throw INTERP_KERNEL::Exception("DataArrayInt::addEqual : input DataArrayInt instance is NULL !");
10921 const char *msg="Nb of tuples mismatch for DataArrayInt::addEqual !";
10922 checkAllocated(); other->checkAllocated();
10923 int nbOfTuple=getNumberOfTuples();
10924 int nbOfTuple2=other->getNumberOfTuples();
10925 int nbOfComp=getNumberOfComponents();
10926 int nbOfComp2=other->getNumberOfComponents();
10927 if(nbOfTuple==nbOfTuple2)
10929 if(nbOfComp==nbOfComp2)
10931 std::transform(begin(),end(),other->begin(),getPointer(),std::plus<int>());
10933 else if(nbOfComp2==1)
10935 int *ptr=getPointer();
10936 const int *ptrc=other->getConstPointer();
10937 for(int i=0;i<nbOfTuple;i++)
10938 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::plus<int>(),*ptrc++));
10941 throw INTERP_KERNEL::Exception(msg);
10943 else if(nbOfTuple2==1)
10945 if(nbOfComp2==nbOfComp)
10947 int *ptr=getPointer();
10948 const int *ptrc=other->getConstPointer();
10949 for(int i=0;i<nbOfTuple;i++)
10950 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::plus<int>());
10953 throw INTERP_KERNEL::Exception(msg);
10956 throw INTERP_KERNEL::Exception(msg);
10961 * Returns a new DataArrayInt that is a subtraction of two given arrays. There are 3
10963 * 1. The arrays have same number of tuples and components. Then each value of
10964 * the result array (_a_) is a subtraction of the corresponding values of \a a1 and
10965 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, j ].
10966 * 2. The arrays have same number of tuples and one array, say _a2_, has one
10968 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, 0 ].
10969 * 3. The arrays have same number of components and one array, say _a2_, has one
10971 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ 0, j ].
10973 * Info on components is copied either from the first array (in the first case) or from
10974 * the array with maximal number of elements (getNbOfElems()).
10975 * \param [in] a1 - an array to subtract from.
10976 * \param [in] a2 - an array to subtract.
10977 * \return DataArrayInt * - the new instance of DataArrayInt.
10978 * The caller is to delete this result array using decrRef() as it is no more
10980 * \throw If either \a a1 or \a a2 is NULL.
10981 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
10982 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
10983 * none of them has number of tuples or components equal to 1.
10985 DataArrayInt *DataArrayInt::Substract(const DataArrayInt *a1, const DataArrayInt *a2)
10988 throw INTERP_KERNEL::Exception("DataArrayInt::Substract : input DataArrayInt instance is NULL !");
10989 int nbOfTuple1=a1->getNumberOfTuples();
10990 int nbOfTuple2=a2->getNumberOfTuples();
10991 int nbOfComp1=a1->getNumberOfComponents();
10992 int nbOfComp2=a2->getNumberOfComponents();
10993 if(nbOfTuple2==nbOfTuple1)
10995 if(nbOfComp1==nbOfComp2)
10997 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10998 ret->alloc(nbOfTuple2,nbOfComp1);
10999 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::minus<int>());
11000 ret->copyStringInfoFrom(*a1);
11003 else if(nbOfComp2==1)
11005 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11006 ret->alloc(nbOfTuple1,nbOfComp1);
11007 const int *a2Ptr=a2->getConstPointer();
11008 const int *a1Ptr=a1->getConstPointer();
11009 int *res=ret->getPointer();
11010 for(int i=0;i<nbOfTuple1;i++)
11011 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::minus<int>(),a2Ptr[i]));
11012 ret->copyStringInfoFrom(*a1);
11017 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
11021 else if(nbOfTuple2==1)
11023 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
11024 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11025 ret->alloc(nbOfTuple1,nbOfComp1);
11026 const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
11027 int *pt=ret->getPointer();
11028 for(int i=0;i<nbOfTuple1;i++)
11029 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::minus<int>());
11030 ret->copyStringInfoFrom(*a1);
11035 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Substract !");//will always throw an exception
11041 * Subtract values of another DataArrayInt from values of \a this one. There are 3
11043 * 1. The arrays have same number of tuples and components. Then each value of
11044 * \a other array is subtracted from the corresponding value of \a this array, i.e.:
11045 * _a_ [ i, j ] -= _other_ [ i, j ].
11046 * 2. The arrays have same number of tuples and \a other array has one component. Then
11047 * _a_ [ i, j ] -= _other_ [ i, 0 ].
11048 * 3. The arrays have same number of components and \a other array has one tuple. Then
11049 * _a_ [ i, j ] -= _a2_ [ 0, j ].
11051 * \param [in] other - an array to subtract from \a this one.
11052 * \throw If \a other is NULL.
11053 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
11054 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
11055 * \a other has number of both tuples and components not equal to 1.
11057 void DataArrayInt::substractEqual(const DataArrayInt *other)
11060 throw INTERP_KERNEL::Exception("DataArrayInt::substractEqual : input DataArrayInt instance is NULL !");
11061 const char *msg="Nb of tuples mismatch for DataArrayInt::substractEqual !";
11062 checkAllocated(); other->checkAllocated();
11063 int nbOfTuple=getNumberOfTuples();
11064 int nbOfTuple2=other->getNumberOfTuples();
11065 int nbOfComp=getNumberOfComponents();
11066 int nbOfComp2=other->getNumberOfComponents();
11067 if(nbOfTuple==nbOfTuple2)
11069 if(nbOfComp==nbOfComp2)
11071 std::transform(begin(),end(),other->begin(),getPointer(),std::minus<int>());
11073 else if(nbOfComp2==1)
11075 int *ptr=getPointer();
11076 const int *ptrc=other->getConstPointer();
11077 for(int i=0;i<nbOfTuple;i++)
11078 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::minus<int>(),*ptrc++));
11081 throw INTERP_KERNEL::Exception(msg);
11083 else if(nbOfTuple2==1)
11085 int *ptr=getPointer();
11086 const int *ptrc=other->getConstPointer();
11087 for(int i=0;i<nbOfTuple;i++)
11088 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::minus<int>());
11091 throw INTERP_KERNEL::Exception(msg);
11096 * Returns a new DataArrayInt that is a product of two given arrays. There are 3
11098 * 1. The arrays have same number of tuples and components. Then each value of
11099 * the result array (_a_) is a product of the corresponding values of \a a1 and
11100 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, j ].
11101 * 2. The arrays have same number of tuples and one array, say _a2_, has one
11103 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, 0 ].
11104 * 3. The arrays have same number of components and one array, say _a2_, has one
11106 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ 0, j ].
11108 * Info on components is copied either from the first array (in the first case) or from
11109 * the array with maximal number of elements (getNbOfElems()).
11110 * \param [in] a1 - a factor array.
11111 * \param [in] a2 - another factor array.
11112 * \return DataArrayInt * - the new instance of DataArrayInt.
11113 * The caller is to delete this result array using decrRef() as it is no more
11115 * \throw If either \a a1 or \a a2 is NULL.
11116 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
11117 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
11118 * none of them has number of tuples or components equal to 1.
11120 DataArrayInt *DataArrayInt::Multiply(const DataArrayInt *a1, const DataArrayInt *a2)
11123 throw INTERP_KERNEL::Exception("DataArrayInt::Multiply : input DataArrayInt instance is NULL !");
11124 int nbOfTuple=a1->getNumberOfTuples();
11125 int nbOfTuple2=a2->getNumberOfTuples();
11126 int nbOfComp=a1->getNumberOfComponents();
11127 int nbOfComp2=a2->getNumberOfComponents();
11128 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=0;
11129 if(nbOfTuple==nbOfTuple2)
11131 if(nbOfComp==nbOfComp2)
11133 ret=DataArrayInt::New();
11134 ret->alloc(nbOfTuple,nbOfComp);
11135 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::multiplies<int>());
11136 ret->copyStringInfoFrom(*a1);
11140 int nbOfCompMin,nbOfCompMax;
11141 const DataArrayInt *aMin, *aMax;
11142 if(nbOfComp>nbOfComp2)
11144 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
11149 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
11154 ret=DataArrayInt::New();
11155 ret->alloc(nbOfTuple,nbOfCompMax);
11156 const int *aMinPtr=aMin->getConstPointer();
11157 const int *aMaxPtr=aMax->getConstPointer();
11158 int *res=ret->getPointer();
11159 for(int i=0;i<nbOfTuple;i++)
11160 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::multiplies<int>(),aMinPtr[i]));
11161 ret->copyStringInfoFrom(*aMax);
11164 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
11167 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
11169 if(nbOfComp==nbOfComp2)
11171 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
11172 const DataArrayInt *aMin=nbOfTuple>nbOfTuple2?a2:a1;
11173 const DataArrayInt *aMax=nbOfTuple>nbOfTuple2?a1:a2;
11174 const int *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
11175 ret=DataArrayInt::New();
11176 ret->alloc(nbOfTupleMax,nbOfComp);
11177 int *res=ret->getPointer();
11178 for(int i=0;i<nbOfTupleMax;i++)
11179 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::multiplies<int>());
11180 ret->copyStringInfoFrom(*aMax);
11183 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
11186 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Multiply !");
11192 * Multiply values of another DataArrayInt to values of \a this one. There are 3
11194 * 1. The arrays have same number of tuples and components. Then each value of
11195 * \a other array is multiplied to the corresponding value of \a this array, i.e.:
11196 * _a_ [ i, j ] *= _other_ [ i, j ].
11197 * 2. The arrays have same number of tuples and \a other array has one component. Then
11198 * _a_ [ i, j ] *= _other_ [ i, 0 ].
11199 * 3. The arrays have same number of components and \a other array has one tuple. Then
11200 * _a_ [ i, j ] *= _a2_ [ 0, j ].
11202 * \param [in] other - an array to multiply to \a this one.
11203 * \throw If \a other is NULL.
11204 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
11205 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
11206 * \a other has number of both tuples and components not equal to 1.
11208 void DataArrayInt::multiplyEqual(const DataArrayInt *other)
11211 throw INTERP_KERNEL::Exception("DataArrayInt::multiplyEqual : input DataArrayInt instance is NULL !");
11212 const char *msg="Nb of tuples mismatch for DataArrayInt::multiplyEqual !";
11213 checkAllocated(); other->checkAllocated();
11214 int nbOfTuple=getNumberOfTuples();
11215 int nbOfTuple2=other->getNumberOfTuples();
11216 int nbOfComp=getNumberOfComponents();
11217 int nbOfComp2=other->getNumberOfComponents();
11218 if(nbOfTuple==nbOfTuple2)
11220 if(nbOfComp==nbOfComp2)
11222 std::transform(begin(),end(),other->begin(),getPointer(),std::multiplies<int>());
11224 else if(nbOfComp2==1)
11226 int *ptr=getPointer();
11227 const int *ptrc=other->getConstPointer();
11228 for(int i=0;i<nbOfTuple;i++)
11229 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::multiplies<int>(),*ptrc++));
11232 throw INTERP_KERNEL::Exception(msg);
11234 else if(nbOfTuple2==1)
11236 if(nbOfComp2==nbOfComp)
11238 int *ptr=getPointer();
11239 const int *ptrc=other->getConstPointer();
11240 for(int i=0;i<nbOfTuple;i++)
11241 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::multiplies<int>());
11244 throw INTERP_KERNEL::Exception(msg);
11247 throw INTERP_KERNEL::Exception(msg);
11253 * Returns a new DataArrayInt that is a division of two given arrays. There are 3
11255 * 1. The arrays have same number of tuples and components. Then each value of
11256 * the result array (_a_) is a division of the corresponding values of \a a1 and
11257 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, j ].
11258 * 2. The arrays have same number of tuples and one array, say _a2_, has one
11260 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, 0 ].
11261 * 3. The arrays have same number of components and one array, say _a2_, has one
11263 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ 0, j ].
11265 * Info on components is copied either from the first array (in the first case) or from
11266 * the array with maximal number of elements (getNbOfElems()).
11267 * \warning No check of division by zero is performed!
11268 * \param [in] a1 - a numerator array.
11269 * \param [in] a2 - a denominator array.
11270 * \return DataArrayInt * - the new instance of DataArrayInt.
11271 * The caller is to delete this result array using decrRef() as it is no more
11273 * \throw If either \a a1 or \a a2 is NULL.
11274 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
11275 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
11276 * none of them has number of tuples or components equal to 1.
11278 DataArrayInt *DataArrayInt::Divide(const DataArrayInt *a1, const DataArrayInt *a2)
11281 throw INTERP_KERNEL::Exception("DataArrayInt::Divide : input DataArrayInt instance is NULL !");
11282 int nbOfTuple1=a1->getNumberOfTuples();
11283 int nbOfTuple2=a2->getNumberOfTuples();
11284 int nbOfComp1=a1->getNumberOfComponents();
11285 int nbOfComp2=a2->getNumberOfComponents();
11286 if(nbOfTuple2==nbOfTuple1)
11288 if(nbOfComp1==nbOfComp2)
11290 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11291 ret->alloc(nbOfTuple2,nbOfComp1);
11292 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::divides<int>());
11293 ret->copyStringInfoFrom(*a1);
11296 else if(nbOfComp2==1)
11298 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11299 ret->alloc(nbOfTuple1,nbOfComp1);
11300 const int *a2Ptr=a2->getConstPointer();
11301 const int *a1Ptr=a1->getConstPointer();
11302 int *res=ret->getPointer();
11303 for(int i=0;i<nbOfTuple1;i++)
11304 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::divides<int>(),a2Ptr[i]));
11305 ret->copyStringInfoFrom(*a1);
11310 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
11314 else if(nbOfTuple2==1)
11316 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
11317 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11318 ret->alloc(nbOfTuple1,nbOfComp1);
11319 const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
11320 int *pt=ret->getPointer();
11321 for(int i=0;i<nbOfTuple1;i++)
11322 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::divides<int>());
11323 ret->copyStringInfoFrom(*a1);
11328 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Divide !");//will always throw an exception
11334 * Divide values of \a this array by values of another DataArrayInt. There are 3
11336 * 1. The arrays have same number of tuples and components. Then each value of
11337 * \a this array is divided by the corresponding value of \a other one, i.e.:
11338 * _a_ [ i, j ] /= _other_ [ i, j ].
11339 * 2. The arrays have same number of tuples and \a other array has one component. Then
11340 * _a_ [ i, j ] /= _other_ [ i, 0 ].
11341 * 3. The arrays have same number of components and \a other array has one tuple. Then
11342 * _a_ [ i, j ] /= _a2_ [ 0, j ].
11344 * \warning No check of division by zero is performed!
11345 * \param [in] other - an array to divide \a this one by.
11346 * \throw If \a other is NULL.
11347 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
11348 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
11349 * \a other has number of both tuples and components not equal to 1.
11351 void DataArrayInt::divideEqual(const DataArrayInt *other)
11354 throw INTERP_KERNEL::Exception("DataArrayInt::divideEqual : input DataArrayInt instance is NULL !");
11355 const char *msg="Nb of tuples mismatch for DataArrayInt::divideEqual !";
11356 checkAllocated(); other->checkAllocated();
11357 int nbOfTuple=getNumberOfTuples();
11358 int nbOfTuple2=other->getNumberOfTuples();
11359 int nbOfComp=getNumberOfComponents();
11360 int nbOfComp2=other->getNumberOfComponents();
11361 if(nbOfTuple==nbOfTuple2)
11363 if(nbOfComp==nbOfComp2)
11365 std::transform(begin(),end(),other->begin(),getPointer(),std::divides<int>());
11367 else if(nbOfComp2==1)
11369 int *ptr=getPointer();
11370 const int *ptrc=other->getConstPointer();
11371 for(int i=0;i<nbOfTuple;i++)
11372 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::divides<int>(),*ptrc++));
11375 throw INTERP_KERNEL::Exception(msg);
11377 else if(nbOfTuple2==1)
11379 if(nbOfComp2==nbOfComp)
11381 int *ptr=getPointer();
11382 const int *ptrc=other->getConstPointer();
11383 for(int i=0;i<nbOfTuple;i++)
11384 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::divides<int>());
11387 throw INTERP_KERNEL::Exception(msg);
11390 throw INTERP_KERNEL::Exception(msg);
11396 * Returns a new DataArrayInt that is a modulus of two given arrays. There are 3
11398 * 1. The arrays have same number of tuples and components. Then each value of
11399 * the result array (_a_) is a division of the corresponding values of \a a1 and
11400 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ i, j ].
11401 * 2. The arrays have same number of tuples and one array, say _a2_, has one
11403 * _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ i, 0 ].
11404 * 3. The arrays have same number of components and one array, say _a2_, has one
11406 * _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ 0, j ].
11408 * Info on components is copied either from the first array (in the first case) or from
11409 * the array with maximal number of elements (getNbOfElems()).
11410 * \warning No check of division by zero is performed!
11411 * \param [in] a1 - a dividend array.
11412 * \param [in] a2 - a divisor array.
11413 * \return DataArrayInt * - the new instance of DataArrayInt.
11414 * The caller is to delete this result array using decrRef() as it is no more
11416 * \throw If either \a a1 or \a a2 is NULL.
11417 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
11418 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
11419 * none of them has number of tuples or components equal to 1.
11421 DataArrayInt *DataArrayInt::Modulus(const DataArrayInt *a1, const DataArrayInt *a2)
11424 throw INTERP_KERNEL::Exception("DataArrayInt::Modulus : input DataArrayInt instance is NULL !");
11425 int nbOfTuple1=a1->getNumberOfTuples();
11426 int nbOfTuple2=a2->getNumberOfTuples();
11427 int nbOfComp1=a1->getNumberOfComponents();
11428 int nbOfComp2=a2->getNumberOfComponents();
11429 if(nbOfTuple2==nbOfTuple1)
11431 if(nbOfComp1==nbOfComp2)
11433 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11434 ret->alloc(nbOfTuple2,nbOfComp1);
11435 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::modulus<int>());
11436 ret->copyStringInfoFrom(*a1);
11439 else if(nbOfComp2==1)
11441 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11442 ret->alloc(nbOfTuple1,nbOfComp1);
11443 const int *a2Ptr=a2->getConstPointer();
11444 const int *a1Ptr=a1->getConstPointer();
11445 int *res=ret->getPointer();
11446 for(int i=0;i<nbOfTuple1;i++)
11447 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::modulus<int>(),a2Ptr[i]));
11448 ret->copyStringInfoFrom(*a1);
11453 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Modulus !");
11457 else if(nbOfTuple2==1)
11459 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Modulus !");
11460 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11461 ret->alloc(nbOfTuple1,nbOfComp1);
11462 const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
11463 int *pt=ret->getPointer();
11464 for(int i=0;i<nbOfTuple1;i++)
11465 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::modulus<int>());
11466 ret->copyStringInfoFrom(*a1);
11471 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Modulus !");//will always throw an exception
11477 * Modify \a this array so that each value becomes a modulus of division of this value by
11478 * a value of another DataArrayInt. There are 3 valid cases.
11479 * 1. The arrays have same number of tuples and components. Then each value of
11480 * \a this array is divided by the corresponding value of \a other one, i.e.:
11481 * _a_ [ i, j ] %= _other_ [ i, j ].
11482 * 2. The arrays have same number of tuples and \a other array has one component. Then
11483 * _a_ [ i, j ] %= _other_ [ i, 0 ].
11484 * 3. The arrays have same number of components and \a other array has one tuple. Then
11485 * _a_ [ i, j ] %= _a2_ [ 0, j ].
11487 * \warning No check of division by zero is performed!
11488 * \param [in] other - a divisor array.
11489 * \throw If \a other is NULL.
11490 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
11491 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
11492 * \a other has number of both tuples and components not equal to 1.
11494 void DataArrayInt::modulusEqual(const DataArrayInt *other)
11497 throw INTERP_KERNEL::Exception("DataArrayInt::modulusEqual : input DataArrayInt instance is NULL !");
11498 const char *msg="Nb of tuples mismatch for DataArrayInt::modulusEqual !";
11499 checkAllocated(); other->checkAllocated();
11500 int nbOfTuple=getNumberOfTuples();
11501 int nbOfTuple2=other->getNumberOfTuples();
11502 int nbOfComp=getNumberOfComponents();
11503 int nbOfComp2=other->getNumberOfComponents();
11504 if(nbOfTuple==nbOfTuple2)
11506 if(nbOfComp==nbOfComp2)
11508 std::transform(begin(),end(),other->begin(),getPointer(),std::modulus<int>());
11510 else if(nbOfComp2==1)
11512 if(nbOfComp2==nbOfComp)
11514 int *ptr=getPointer();
11515 const int *ptrc=other->getConstPointer();
11516 for(int i=0;i<nbOfTuple;i++)
11517 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::modulus<int>(),*ptrc++));
11520 throw INTERP_KERNEL::Exception(msg);
11523 throw INTERP_KERNEL::Exception(msg);
11525 else if(nbOfTuple2==1)
11527 int *ptr=getPointer();
11528 const int *ptrc=other->getConstPointer();
11529 for(int i=0;i<nbOfTuple;i++)
11530 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::modulus<int>());
11533 throw INTERP_KERNEL::Exception(msg);
11538 * Returns a new DataArrayInt that is the result of pow of two given arrays. There are 3
11541 * \param [in] a1 - an array to pow up.
11542 * \param [in] a2 - another array to sum up.
11543 * \return DataArrayInt * - the new instance of DataArrayInt.
11544 * The caller is to delete this result array using decrRef() as it is no more
11546 * \throw If either \a a1 or \a a2 is NULL.
11547 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
11548 * \throw If \a a1->getNumberOfComponents() != 1 or \a a2->getNumberOfComponents() != 1.
11549 * \throw If there is a negative value in \a a2.
11551 DataArrayInt *DataArrayInt::Pow(const DataArrayInt *a1, const DataArrayInt *a2)
11554 throw INTERP_KERNEL::Exception("DataArrayInt::Pow : at least one of input instances is null !");
11555 int nbOfTuple=a1->getNumberOfTuples();
11556 int nbOfTuple2=a2->getNumberOfTuples();
11557 int nbOfComp=a1->getNumberOfComponents();
11558 int nbOfComp2=a2->getNumberOfComponents();
11559 if(nbOfTuple!=nbOfTuple2)
11560 throw INTERP_KERNEL::Exception("DataArrayInt::Pow : number of tuples mismatches !");
11561 if(nbOfComp!=1 || nbOfComp2!=1)
11562 throw INTERP_KERNEL::Exception("DataArrayInt::Pow : number of components of both arrays must be equal to 1 !");
11563 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbOfTuple,1);
11564 const int *ptr1(a1->begin()),*ptr2(a2->begin());
11565 int *ptr=ret->getPointer();
11566 for(int i=0;i<nbOfTuple;i++,ptr1++,ptr2++,ptr++)
11571 for(int j=0;j<*ptr2;j++)
11577 std::ostringstream oss; oss << "DataArrayInt::Pow : on tuple #" << i << " of a2 value is < 0 (" << *ptr2 << ") !";
11578 throw INTERP_KERNEL::Exception(oss.str().c_str());
11585 * Apply pow on values of another DataArrayInt to values of \a this one.
11587 * \param [in] other - an array to pow to \a this one.
11588 * \throw If \a other is NULL.
11589 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples()
11590 * \throw If \a this->getNumberOfComponents() != 1 or \a other->getNumberOfComponents() != 1
11591 * \throw If there is a negative value in \a other.
11593 void DataArrayInt::powEqual(const DataArrayInt *other)
11596 throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : input instance is null !");
11597 int nbOfTuple=getNumberOfTuples();
11598 int nbOfTuple2=other->getNumberOfTuples();
11599 int nbOfComp=getNumberOfComponents();
11600 int nbOfComp2=other->getNumberOfComponents();
11601 if(nbOfTuple!=nbOfTuple2)
11602 throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : number of tuples mismatches !");
11603 if(nbOfComp!=1 || nbOfComp2!=1)
11604 throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : number of components of both arrays must be equal to 1 !");
11605 int *ptr=getPointer();
11606 const int *ptrc=other->begin();
11607 for(int i=0;i<nbOfTuple;i++,ptrc++,ptr++)
11612 for(int j=0;j<*ptrc;j++)
11618 std::ostringstream oss; oss << "DataArrayInt::powEqual : on tuple #" << i << " of other value is < 0 (" << *ptrc << ") !";
11619 throw INTERP_KERNEL::Exception(oss.str().c_str());
11626 * Returns a C array which is a renumbering map in "Old to New" mode for the input array.
11627 * This map, if applied to \a start array, would make it sorted. For example, if
11628 * \a start array contents are [9,10,0,6,4,11,3,7] then the contents of the result array is
11629 * [5,6,0,3,2,7,1,4].
11630 * \param [in] start - pointer to the first element of the array for which the
11631 * permutation map is computed.
11632 * \param [in] end - pointer specifying the end of the array \a start, so that
11633 * the last value of \a start is \a end[ -1 ].
11634 * \return int * - the result permutation array that the caller is to delete as it is no
11636 * \throw If there are equal values in the input array.
11638 int *DataArrayInt::CheckAndPreparePermutation(const int *start, const int *end)
11640 std::size_t sz=std::distance(start,end);
11641 int *ret=(int *)malloc(sz*sizeof(int));
11642 int *work=new int[sz];
11643 std::copy(start,end,work);
11644 std::sort(work,work+sz);
11645 if(std::unique(work,work+sz)!=work+sz)
11649 throw INTERP_KERNEL::Exception("Some elements are equals in the specified array !");
11651 std::map<int,int> m;
11652 for(int *workPt=work;workPt!=work+sz;workPt++)
11653 m[*workPt]=(int)std::distance(work,workPt);
11655 for(const int *iter=start;iter!=end;iter++,iter2++)
11662 * Returns a new DataArrayInt containing an arithmetic progression
11663 * that is equal to the sequence returned by Python \c range(\a begin,\a end,\a step )
11665 * \param [in] begin - the start value of the result sequence.
11666 * \param [in] end - limiting value, so that every value of the result array is less than
11668 * \param [in] step - specifies the increment or decrement.
11669 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
11670 * array using decrRef() as it is no more needed.
11671 * \throw If \a step == 0.
11672 * \throw If \a end < \a begin && \a step > 0.
11673 * \throw If \a end > \a begin && \a step < 0.
11675 DataArrayInt *DataArrayInt::Range(int begin, int end, int step)
11677 int nbOfTuples=GetNumberOfItemGivenBESRelative(begin,end,step,"DataArrayInt::Range");
11678 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11679 ret->alloc(nbOfTuples,1);
11680 int *ptr=ret->getPointer();
11683 for(int i=begin;i<end;i+=step,ptr++)
11688 for(int i=begin;i>end;i+=step,ptr++)
11695 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
11698 void DataArrayInt::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
11700 tinyInfo.resize(2);
11703 tinyInfo[0]=getNumberOfTuples();
11704 tinyInfo[1]=getNumberOfComponents();
11714 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
11717 void DataArrayInt::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
11721 int nbOfCompo=getNumberOfComponents();
11722 tinyInfo.resize(nbOfCompo+1);
11723 tinyInfo[0]=getName();
11724 for(int i=0;i<nbOfCompo;i++)
11725 tinyInfo[i+1]=getInfoOnComponent(i);
11729 tinyInfo.resize(1);
11730 tinyInfo[0]=getName();
11735 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
11736 * This method returns if a feeding is needed.
11738 bool DataArrayInt::resizeForUnserialization(const std::vector<int>& tinyInfoI)
11740 int nbOfTuple=tinyInfoI[0];
11741 int nbOfComp=tinyInfoI[1];
11742 if(nbOfTuple!=-1 || nbOfComp!=-1)
11744 alloc(nbOfTuple,nbOfComp);
11751 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
11752 * This method returns if a feeding is needed.
11754 void DataArrayInt::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<std::string>& tinyInfoS)
11756 setName(tinyInfoS[0]);
11759 int nbOfCompo=tinyInfoI[1];
11760 for(int i=0;i<nbOfCompo;i++)
11761 setInfoOnComponent(i,tinyInfoS[i+1]);
11765 DataArrayIntIterator::DataArrayIntIterator(DataArrayInt *da):_da(da),_pt(0),_tuple_id(0),_nb_comp(0),_nb_tuple(0)
11770 if(_da->isAllocated())
11772 _nb_comp=da->getNumberOfComponents();
11773 _nb_tuple=da->getNumberOfTuples();
11774 _pt=da->getPointer();
11779 DataArrayIntIterator::~DataArrayIntIterator()
11785 DataArrayIntTuple *DataArrayIntIterator::nextt()
11787 if(_tuple_id<_nb_tuple)
11790 DataArrayIntTuple *ret=new DataArrayIntTuple(_pt,_nb_comp);
11798 DataArrayIntTuple::DataArrayIntTuple(int *pt, int nbOfComp):_pt(pt),_nb_of_compo(nbOfComp)
11802 std::string DataArrayIntTuple::repr() const
11804 std::ostringstream oss; oss << "(";
11805 for(int i=0;i<_nb_of_compo-1;i++)
11806 oss << _pt[i] << ", ";
11807 oss << _pt[_nb_of_compo-1] << ")";
11811 int DataArrayIntTuple::intValue() const
11813 if(_nb_of_compo==1)
11815 throw INTERP_KERNEL::Exception("DataArrayIntTuple::intValue : DataArrayIntTuple instance has not exactly 1 component -> Not possible to convert it into an integer !");
11819 * This method returns a newly allocated instance the caller should dealed with by a ParaMEDMEM::DataArrayInt::decrRef.
11820 * This method performs \b no copy of data. The content is only referenced using ParaMEDMEM::DataArrayInt::useArray with ownership set to \b false.
11821 * 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
11822 * \b nbOfCompo=1 and \bnbOfTuples==this->_nb_of_elem.
11824 DataArrayInt *DataArrayIntTuple::buildDAInt(int nbOfTuples, int nbOfCompo) const
11826 if((_nb_of_compo==nbOfCompo && nbOfTuples==1) || (_nb_of_compo==nbOfTuples && nbOfCompo==1))
11828 DataArrayInt *ret=DataArrayInt::New();
11829 ret->useExternalArrayWithRWAccess(_pt,nbOfTuples,nbOfCompo);
11834 std::ostringstream oss; oss << "DataArrayIntTuple::buildDAInt : unable to build a requested DataArrayInt instance with nbofTuple=" << nbOfTuples << " and nbOfCompo=" << nbOfCompo;
11835 oss << ".\nBecause the number of elements in this is " << _nb_of_compo << " !";
11836 throw INTERP_KERNEL::Exception(oss.str().c_str());