1 // Copyright (C) 2007-2013 CEA/DEN, EDF R&D
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License.
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 // Lesser General Public License for more details.
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
19 // Author : Anthony Geay (CEA/DEN)
21 #include "MEDCouplingMemArray.txx"
22 #include "MEDCouplingAutoRefCountObjectPtr.hxx"
24 #include "GenMathFormulae.hxx"
25 #include "InterpKernelExprParser.hxx"
34 typedef double (*MYFUNCPTR)(double);
36 using namespace ParaMEDMEM;
38 template<int SPACEDIM>
39 void DataArrayDouble::findCommonTuplesAlg(const double *bbox, int nbNodes, int limitNodeId, double prec, DataArrayInt *c, DataArrayInt *cI) const
41 const double *coordsPtr=getConstPointer();
42 BBTreePts<SPACEDIM,int> myTree(bbox,0,0,nbNodes,prec);
43 std::vector<bool> isDone(nbNodes);
44 for(int i=0;i<nbNodes;i++)
48 std::vector<int> intersectingElems;
49 myTree.getElementsAroundPoint(coordsPtr+i*SPACEDIM,intersectingElems);
50 if(intersectingElems.size()>1)
52 std::vector<int> commonNodes;
53 for(std::vector<int>::const_iterator it=intersectingElems.begin();it!=intersectingElems.end();it++)
57 commonNodes.push_back(*it);
60 if(!commonNodes.empty())
62 cI->pushBackSilent(cI->back()+(int)commonNodes.size()+1);
64 c->insertAtTheEnd(commonNodes.begin(),commonNodes.end());
71 template<int SPACEDIM>
72 void DataArrayDouble::FindTupleIdsNearTuplesAlg(const BBTreePts<SPACEDIM,int>& myTree, const double *pos, int nbOfTuples, double eps,
73 DataArrayInt *c, DataArrayInt *cI)
75 for(int i=0;i<nbOfTuples;i++)
77 std::vector<int> intersectingElems;
78 myTree.getElementsAroundPoint(pos+i*SPACEDIM,intersectingElems);
79 std::vector<int> commonNodes;
80 for(std::vector<int>::const_iterator it=intersectingElems.begin();it!=intersectingElems.end();it++)
81 commonNodes.push_back(*it);
82 cI->pushBackSilent(cI->back()+(int)commonNodes.size());
83 c->insertAtTheEnd(commonNodes.begin(),commonNodes.end());
87 template<int SPACEDIM>
88 void DataArrayDouble::FindClosestTupleIdAlg(const BBTreePts<SPACEDIM,int>& myTree, double dist, const double *pos, int nbOfTuples, const double *thisPt, int thisNbOfTuples, int *res)
93 for(int i=0;i<nbOfTuples;i++,p+=SPACEDIM,r++)
98 double ret=myTree.getElementsAroundPoint2(p,distOpt,elem);
99 if(ret!=std::numeric_limits<double>::max())
101 distOpt=std::max(ret,1e-4);
106 { distOpt=2*distOpt; continue; }
111 std::size_t DataArray::getHeapMemorySize() const
113 std::size_t sz1=_name.capacity();
114 std::size_t sz2=_info_on_compo.capacity();
116 for(std::vector<std::string>::const_iterator it=_info_on_compo.begin();it!=_info_on_compo.end();it++)
117 sz3+=(*it).capacity();
122 * Sets the attribute \a _name of \a this array.
123 * See \ref MEDCouplingArrayBasicsName "DataArrays infos" for more information.
124 * \param [in] name - new array name
126 void DataArray::setName(const char *name)
132 * Copies textual data from an \a other DataArray. The copied data are
133 * - the name attribute,
134 * - the information of components.
136 * For more information on these data see \ref MEDCouplingArrayBasicsName "DataArrays infos".
138 * \param [in] other - another instance of DataArray to copy the textual data from.
139 * \throw If number of components of \a this array differs from that of the \a other.
141 void DataArray::copyStringInfoFrom(const DataArray& other) throw(INTERP_KERNEL::Exception)
143 if(_info_on_compo.size()!=other._info_on_compo.size())
144 throw INTERP_KERNEL::Exception("Size of arrays mismatches on copyStringInfoFrom !");
146 _info_on_compo=other._info_on_compo;
149 void DataArray::copyPartOfStringInfoFrom(const DataArray& other, const std::vector<int>& compoIds) throw(INTERP_KERNEL::Exception)
151 int nbOfCompoOth=other.getNumberOfComponents();
152 std::size_t newNbOfCompo=compoIds.size();
153 for(std::size_t i=0;i<newNbOfCompo;i++)
154 if(compoIds[i]>=nbOfCompoOth || compoIds[i]<0)
156 std::ostringstream oss; oss << "Specified component id is out of range (" << compoIds[i] << ") compared with nb of actual components (" << nbOfCompoOth << ")";
157 throw INTERP_KERNEL::Exception(oss.str().c_str());
159 for(std::size_t i=0;i<newNbOfCompo;i++)
160 setInfoOnComponent((int)i,other.getInfoOnComponent(compoIds[i]).c_str());
163 void DataArray::copyPartOfStringInfoFrom2(const std::vector<int>& compoIds, const DataArray& other) throw(INTERP_KERNEL::Exception)
165 int nbOfCompo=getNumberOfComponents();
166 std::size_t partOfCompoToSet=compoIds.size();
167 if((int)partOfCompoToSet!=other.getNumberOfComponents())
168 throw INTERP_KERNEL::Exception("Given compoIds has not the same size as number of components of given array !");
169 for(std::size_t i=0;i<partOfCompoToSet;i++)
170 if(compoIds[i]>=nbOfCompo || compoIds[i]<0)
172 std::ostringstream oss; oss << "Specified component id is out of range (" << compoIds[i] << ") compared with nb of actual components (" << nbOfCompo << ")";
173 throw INTERP_KERNEL::Exception(oss.str().c_str());
175 for(std::size_t i=0;i<partOfCompoToSet;i++)
176 setInfoOnComponent(compoIds[i],other.getInfoOnComponent((int)i).c_str());
179 bool DataArray::areInfoEqualsIfNotWhy(const DataArray& other, std::string& reason) const throw(INTERP_KERNEL::Exception)
181 std::ostringstream oss;
182 if(_name!=other._name)
184 oss << "Names DataArray mismatch : this name=\"" << _name << " other name=\"" << other._name << "\" !";
188 if(_info_on_compo!=other._info_on_compo)
190 oss << "Components DataArray mismatch : \nThis components=";
191 for(std::vector<std::string>::const_iterator it=_info_on_compo.begin();it!=_info_on_compo.end();it++)
192 oss << "\"" << *it << "\",";
193 oss << "\nOther components=";
194 for(std::vector<std::string>::const_iterator it=other._info_on_compo.begin();it!=other._info_on_compo.end();it++)
195 oss << "\"" << *it << "\",";
203 * Compares textual information of \a this DataArray with that of an \a other one.
204 * The compared data are
205 * - the name attribute,
206 * - the information of components.
208 * For more information on these data see \ref MEDCouplingArrayBasicsName "DataArrays infos".
209 * \param [in] other - another instance of DataArray to compare the textual data of.
210 * \return bool - \a true if the textual information is same, \a false else.
212 bool DataArray::areInfoEquals(const DataArray& other) const throw(INTERP_KERNEL::Exception)
215 return areInfoEqualsIfNotWhy(other,tmp);
218 void DataArray::reprWithoutNameStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
220 stream << "Number of components : "<< getNumberOfComponents() << "\n";
221 stream << "Info of these components : ";
222 for(std::vector<std::string>::const_iterator iter=_info_on_compo.begin();iter!=_info_on_compo.end();iter++)
223 stream << "\"" << *iter << "\" ";
227 std::string DataArray::cppRepr(const char *varName) const throw(INTERP_KERNEL::Exception)
229 std::ostringstream ret;
230 reprCppStream(varName,ret);
235 * Sets information on all components. To know more on format of this information
236 * see \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
237 * \param [in] info - a vector of strings.
238 * \throw If size of \a info differs from the number of components of \a this.
240 void DataArray::setInfoOnComponents(const std::vector<std::string>& info) throw(INTERP_KERNEL::Exception)
242 if(getNumberOfComponents()!=(int)info.size())
244 std::ostringstream oss; oss << "DataArray::setInfoOnComponents : input is of size " << info.size() << " whereas number of components is equal to " << getNumberOfComponents() << " !";
245 throw INTERP_KERNEL::Exception(oss.str().c_str());
250 std::vector<std::string> DataArray::getVarsOnComponent() const throw(INTERP_KERNEL::Exception)
252 int nbOfCompo=(int)_info_on_compo.size();
253 std::vector<std::string> ret(nbOfCompo);
254 for(int i=0;i<nbOfCompo;i++)
255 ret[i]=getVarOnComponent(i);
259 std::vector<std::string> DataArray::getUnitsOnComponent() const throw(INTERP_KERNEL::Exception)
261 int nbOfCompo=(int)_info_on_compo.size();
262 std::vector<std::string> ret(nbOfCompo);
263 for(int i=0;i<nbOfCompo;i++)
264 ret[i]=getUnitOnComponent(i);
269 * Returns information on a component specified by an index.
270 * To know more on format of this information
271 * see \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
272 * \param [in] i - the index (zero based) of the component of interest.
273 * \return std::string - a string containing the information on \a i-th component.
274 * \throw If \a i is not a valid component index.
276 std::string DataArray::getInfoOnComponent(int i) const throw(INTERP_KERNEL::Exception)
278 if(i<(int)_info_on_compo.size() && i>=0)
279 return _info_on_compo[i];
282 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();
283 throw INTERP_KERNEL::Exception(oss.str().c_str());
288 * Returns the var part of the full information of the \a i-th component.
289 * For example, if \c getInfoOnComponent(0) returns "SIGXY [N/m^2]", then
290 * \c getVarOnComponent(0) returns "SIGXY".
291 * If a unit part of information is not detected by presence of
292 * two square brackets, then the full information is returned.
293 * To read more about the component information format, see
294 * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
295 * \param [in] i - the index (zero based) of the component of interest.
296 * \return std::string - a string containing the var information, or the full info.
297 * \throw If \a i is not a valid component index.
299 std::string DataArray::getVarOnComponent(int i) const throw(INTERP_KERNEL::Exception)
301 if(i<(int)_info_on_compo.size() && i>=0)
303 return GetVarNameFromInfo(_info_on_compo[i]);
307 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();
308 throw INTERP_KERNEL::Exception(oss.str().c_str());
313 * Returns the unit part of the full information of the \a i-th component.
314 * For example, if \c getInfoOnComponent(0) returns "SIGXY [ N/m^2]", then
315 * \c getUnitOnComponent(0) returns " N/m^2".
316 * If a unit part of information is not detected by presence of
317 * two square brackets, then an empty string is returned.
318 * To read more about the component information format, see
319 * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
320 * \param [in] i - the index (zero based) of the component of interest.
321 * \return std::string - a string containing the unit information, if any, or "".
322 * \throw If \a i is not a valid component index.
324 std::string DataArray::getUnitOnComponent(int i) const throw(INTERP_KERNEL::Exception)
326 if(i<(int)_info_on_compo.size() && i>=0)
328 return GetUnitFromInfo(_info_on_compo[i]);
332 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();
333 throw INTERP_KERNEL::Exception(oss.str().c_str());
338 * Returns the var part of the full component information.
339 * For example, if \a info == "SIGXY [N/m^2]", then this method returns "SIGXY".
340 * If a unit part of information is not detected by presence of
341 * two square brackets, then the whole \a info is returned.
342 * To read more about the component information format, see
343 * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
344 * \param [in] info - the full component information.
345 * \return std::string - a string containing only var information, or the \a info.
347 std::string DataArray::GetVarNameFromInfo(const std::string& info) throw(INTERP_KERNEL::Exception)
349 std::size_t p1=info.find_last_of('[');
350 std::size_t p2=info.find_last_of(']');
351 if(p1==std::string::npos || p2==std::string::npos)
356 return std::string();
357 std::size_t p3=info.find_last_not_of(' ',p1-1);
358 return info.substr(0,p3+1);
362 * Returns the unit part of the full component information.
363 * For example, if \a info == "SIGXY [ N/m^2]", then this method returns " N/m^2".
364 * If a unit part of information is not detected by presence of
365 * two square brackets, then an empty string is returned.
366 * To read more about the component information format, see
367 * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
368 * \param [in] info - the full component information.
369 * \return std::string - a string containing only unit information, if any, or "".
371 std::string DataArray::GetUnitFromInfo(const std::string& info) throw(INTERP_KERNEL::Exception)
373 std::size_t p1=info.find_last_of('[');
374 std::size_t p2=info.find_last_of(']');
375 if(p1==std::string::npos || p2==std::string::npos)
376 return std::string();
378 return std::string();
379 return info.substr(p1+1,p2-p1-1);
383 * Returns a new DataArray by concatenating all given arrays, so that (1) the number
384 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
385 * the number of component in the result array is same as that of each of given arrays.
386 * Info on components is copied from the first of the given arrays. Number of components
387 * in the given arrays must be the same.
388 * \param [in] arrs - a sequence of arrays to include in the result array. All arrays must have the same type.
389 * \return DataArray * - the new instance of DataArray (that can be either DataArrayInt, DataArrayDouble, DataArrayChar).
390 * The caller is to delete this result array using decrRef() as it is no more
392 * \throw If all arrays within \a arrs are NULL.
393 * \throw If all not null arrays in \a arrs have not the same type.
394 * \throw If getNumberOfComponents() of arrays within \a arrs.
396 DataArray *DataArray::Aggregate(const std::vector<const DataArray *>& arrs) throw(INTERP_KERNEL::Exception)
398 std::vector<const DataArray *> arr2;
399 for(std::vector<const DataArray *>::const_iterator it=arrs.begin();it!=arrs.end();it++)
403 throw INTERP_KERNEL::Exception("DataArray::Aggregate : only null instance in input vector !");
404 std::vector<const DataArrayDouble *> arrd;
405 std::vector<const DataArrayInt *> arri;
406 std::vector<const DataArrayChar *> arrc;
407 for(std::vector<const DataArray *>::const_iterator it=arr2.begin();it!=arr2.end();it++)
409 const DataArrayDouble *a=dynamic_cast<const DataArrayDouble *>(*it);
411 { arrd.push_back(a); continue; }
412 const DataArrayInt *b=dynamic_cast<const DataArrayInt *>(*it);
414 { arri.push_back(b); continue; }
415 const DataArrayChar *c=dynamic_cast<const DataArrayChar *>(*it);
417 { arrc.push_back(c); continue; }
418 throw INTERP_KERNEL::Exception("DataArray::Aggregate : presence of not null instance in inuput that is not in [DataArrayDouble, DataArrayInt, DataArrayChar] !");
420 if(arr2.size()==arrd.size())
421 return DataArrayDouble::Aggregate(arrd);
422 if(arr2.size()==arri.size())
423 return DataArrayInt::Aggregate(arri);
424 if(arr2.size()==arrc.size())
425 return DataArrayChar::Aggregate(arrc);
426 throw INTERP_KERNEL::Exception("DataArray::Aggregate : all input arrays must have the same type !");
430 * Sets information on a component specified by an index.
431 * To know more on format of this information
432 * see \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
433 * \warning Don't pass NULL as \a info!
434 * \param [in] i - the index (zero based) of the component of interest.
435 * \param [in] info - the string containing the information.
436 * \throw If \a i is not a valid component index.
438 void DataArray::setInfoOnComponent(int i, const char *info) throw(INTERP_KERNEL::Exception)
440 if(i<(int)_info_on_compo.size() && i>=0)
441 _info_on_compo[i]=info;
444 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();
445 throw INTERP_KERNEL::Exception(oss.str().c_str());
450 * Sets information on all components. This method can change number of components
451 * at certain conditions; if the conditions are not respected, an exception is thrown.
452 * The number of components can be changed in \a this only if \a this is not allocated.
453 * The condition of number of components must not be changed.
455 * To know more on format of the component information see
456 * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
457 * \param [in] info - a vector of component infos.
458 * \throw If \a this->getNumberOfComponents() != \a info.size() && \a this->isAllocated()
460 void DataArray::setInfoAndChangeNbOfCompo(const std::vector<std::string>& info) throw(INTERP_KERNEL::Exception)
462 if(getNumberOfComponents()!=(int)info.size())
468 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 !";
469 throw INTERP_KERNEL::Exception(oss.str().c_str());
476 void DataArray::checkNbOfTuples(int nbOfTuples, const char *msg) const throw(INTERP_KERNEL::Exception)
478 if(getNumberOfTuples()!=nbOfTuples)
480 std::ostringstream oss; oss << msg << " : mismatch number of tuples : expected " << nbOfTuples << " having " << getNumberOfTuples() << " !";
481 throw INTERP_KERNEL::Exception(oss.str().c_str());
485 void DataArray::checkNbOfComps(int nbOfCompo, const char *msg) const throw(INTERP_KERNEL::Exception)
487 if(getNumberOfComponents()!=nbOfCompo)
489 std::ostringstream oss; oss << msg << " : mismatch number of components : expected " << nbOfCompo << " having " << getNumberOfComponents() << " !";
490 throw INTERP_KERNEL::Exception(oss.str().c_str());
494 void DataArray::checkNbOfElems(std::size_t nbOfElems, const char *msg) const throw(INTERP_KERNEL::Exception)
496 if(getNbOfElems()!=nbOfElems)
498 std::ostringstream oss; oss << msg << " : mismatch number of elems : Expected " << nbOfElems << " having " << getNbOfElems() << " !";
499 throw INTERP_KERNEL::Exception(oss.str().c_str());
503 void DataArray::checkNbOfTuplesAndComp(const DataArray& other, const char *msg) const throw(INTERP_KERNEL::Exception)
505 if(getNumberOfTuples()!=other.getNumberOfTuples())
507 std::ostringstream oss; oss << msg << " : mismatch number of tuples : expected " << other.getNumberOfTuples() << " having " << getNumberOfTuples() << " !";
508 throw INTERP_KERNEL::Exception(oss.str().c_str());
510 if(getNumberOfComponents()!=other.getNumberOfComponents())
512 std::ostringstream oss; oss << msg << " : mismatch number of components : expected " << other.getNumberOfComponents() << " having " << getNumberOfComponents() << " !";
513 throw INTERP_KERNEL::Exception(oss.str().c_str());
517 void DataArray::checkNbOfTuplesAndComp(int nbOfTuples, int nbOfCompo, const char *msg) const throw(INTERP_KERNEL::Exception)
519 checkNbOfTuples(nbOfTuples,msg);
520 checkNbOfComps(nbOfCompo,msg);
524 * Simply this method checks that \b value is in [0,\b ref).
526 void DataArray::CheckValueInRange(int ref, int value, const char *msg) throw(INTERP_KERNEL::Exception)
528 if(value<0 || value>=ref)
530 std::ostringstream oss; oss << "DataArray::CheckValueInRange : " << msg << " ! Expected in range [0," << ref << "[ having " << value << " !";
531 throw INTERP_KERNEL::Exception(oss.str().c_str());
536 * This method checks that [\b start, \b end) is compliant with ref length \b value.
537 * typicaly start in [0,\b value) and end in [0,\b value). If value==start and start==end, it is supported.
539 void DataArray::CheckValueInRangeEx(int value, int start, int end, const char *msg) throw(INTERP_KERNEL::Exception)
541 if(start<0 || start>=value)
543 if(value!=start || end!=start)
545 std::ostringstream oss; oss << "DataArray::CheckValueInRangeEx : " << msg << " ! Expected start " << start << " of input range, in [0," << value << "[ !";
546 throw INTERP_KERNEL::Exception(oss.str().c_str());
549 if(end<0 || end>value)
551 std::ostringstream oss; oss << "DataArray::CheckValueInRangeEx : " << msg << " ! Expected end " << end << " of input range, in [0," << value << "] !";
552 throw INTERP_KERNEL::Exception(oss.str().c_str());
556 void DataArray::CheckClosingParInRange(int ref, int value, const char *msg) throw(INTERP_KERNEL::Exception)
558 if(value<0 || value>ref)
560 std::ostringstream oss; oss << "DataArray::CheckClosingParInRange : " << msg << " ! Expected input range in [0," << ref << "] having closing open parenthesis " << value << " !";
561 throw INTERP_KERNEL::Exception(oss.str().c_str());
566 * 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,
567 * typically it is a whole slice of tuples of DataArray or cells, nodes of a mesh...
569 * The input \a sliceId should be an id in [0, \a nbOfSlices) that specifies the slice of work.
571 * \param [in] start - the start of the input slice of the whole work to perform splitted into slices.
572 * \param [in] stop - the stop of the input slice of the whole work to perform splitted into slices.
573 * \param [in] step - the step (that can be <0) of the input slice of the whole work to perform splitted into slices.
574 * \param [in] sliceId - the slice id considered
575 * \param [in] nbOfSlices - the number of slices (typically the number of cores on which the work is expected to be sliced)
576 * \param [out] startSlice - the start of the slice considered
577 * \param [out] stopSlice - the stop of the slice consided
579 * \throw If \a step == 0
580 * \throw If \a nbOfSlices not > 0
581 * \throw If \a sliceId not in [0,nbOfSlices)
583 void DataArray::GetSlice(int start, int stop, int step, int sliceId, int nbOfSlices, int& startSlice, int& stopSlice) throw(INTERP_KERNEL::Exception)
587 std::ostringstream oss; oss << "DataArray::GetSlice : nbOfSlices (" << nbOfSlices << ") must be > 0 !";
588 throw INTERP_KERNEL::Exception(oss.str().c_str());
590 if(sliceId<0 || sliceId>=nbOfSlices)
592 std::ostringstream oss; oss << "DataArray::GetSlice : sliceId (" << nbOfSlices << ") must be in [0 , nbOfSlices (" << nbOfSlices << ") ) !";
593 throw INTERP_KERNEL::Exception(oss.str().c_str());
595 int nbElems=GetNumberOfItemGivenBESRelative(start,stop,step,"DataArray::GetSlice");
596 int minNbOfElemsPerSlice=nbElems/nbOfSlices;
597 startSlice=start+minNbOfElemsPerSlice*step*sliceId;
598 if(sliceId<nbOfSlices-1)
599 stopSlice=start+minNbOfElemsPerSlice*step*(sliceId+1);
604 int DataArray::GetNumberOfItemGivenBES(int begin, int end, int step, const char *msg) throw(INTERP_KERNEL::Exception)
608 std::ostringstream oss; oss << msg << " : end before begin !";
609 throw INTERP_KERNEL::Exception(oss.str().c_str());
615 std::ostringstream oss; oss << msg << " : invalid step should be > 0 !";
616 throw INTERP_KERNEL::Exception(oss.str().c_str());
618 return (end-1-begin)/step+1;
621 int DataArray::GetNumberOfItemGivenBESRelative(int begin, int end, int step, const char *msg) throw(INTERP_KERNEL::Exception)
624 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBES : step=0 is not allowed !");
625 if(end<begin && step>0)
627 std::ostringstream oss; oss << msg << " : end before begin whereas step is positive !";
628 throw INTERP_KERNEL::Exception(oss.str().c_str());
630 if(begin<end && step<0)
632 std::ostringstream oss; oss << msg << " : invalid step should be > 0 !";
633 throw INTERP_KERNEL::Exception(oss.str().c_str());
636 return (std::max(begin,end)-1-std::min(begin,end))/std::abs(step)+1;
641 int DataArray::GetPosOfItemGivenBESRelativeNoThrow(int value, int begin, int end, int step) throw(INTERP_KERNEL::Exception)
647 if(begin<=value && value<end)
649 if((value-begin)%step==0)
650 return (value-begin)/step;
659 if(begin>=value && value>end)
661 if((begin-value)%(-step)==0)
662 return (begin-value)/(-step);
675 * Returns a new instance of DataArrayDouble. The caller is to delete this array
676 * using decrRef() as it is no more needed.
678 DataArrayDouble *DataArrayDouble::New()
680 return new DataArrayDouble;
684 * Checks if raw data is allocated. Read more on the raw data
685 * in \ref MEDCouplingArrayBasicsTuplesAndCompo "DataArrays infos" for more information.
686 * \return bool - \a true if the raw data is allocated, \a false else.
688 bool DataArrayDouble::isAllocated() const throw(INTERP_KERNEL::Exception)
690 return getConstPointer()!=0;
694 * Checks if raw data is allocated and throws an exception if it is not the case.
695 * \throw If the raw data is not allocated.
697 void DataArrayDouble::checkAllocated() const throw(INTERP_KERNEL::Exception)
700 throw INTERP_KERNEL::Exception("DataArrayDouble::checkAllocated : Array is defined but not allocated ! Call alloc or setValues method first !");
704 * This method desallocated \a this without modification of informations relative to the components.
705 * After call of this method, DataArrayDouble::isAllocated will return false.
706 * If \a this is already not allocated, \a this is let unchanged.
708 void DataArrayDouble::desallocate() throw(INTERP_KERNEL::Exception)
713 std::size_t DataArrayDouble::getHeapMemorySize() const
715 std::size_t sz=_mem.getNbOfElemAllocated();
717 return DataArray::getHeapMemorySize()+sz;
721 * Returns the only one value in \a this, if and only if number of elements
722 * (nb of tuples * nb of components) is equal to 1, and that \a this is allocated.
723 * \return double - the sole value stored in \a this array.
724 * \throw If at least one of conditions stated above is not fulfilled.
726 double DataArrayDouble::doubleValue() const throw(INTERP_KERNEL::Exception)
730 if(getNbOfElems()==1)
732 return *getConstPointer();
735 throw INTERP_KERNEL::Exception("DataArrayDouble::doubleValue : DataArrayDouble instance is allocated but number of elements is not equal to 1 !");
738 throw INTERP_KERNEL::Exception("DataArrayDouble::doubleValue : DataArrayDouble instance is not allocated !");
742 * Checks the number of tuples.
743 * \return bool - \a true if getNumberOfTuples() == 0, \a false else.
744 * \throw If \a this is not allocated.
746 bool DataArrayDouble::empty() const throw(INTERP_KERNEL::Exception)
749 return getNumberOfTuples()==0;
753 * Returns a full copy of \a this. For more info on copying data arrays see
754 * \ref MEDCouplingArrayBasicsCopyDeep.
755 * \return DataArrayDouble * - a new instance of DataArrayDouble. The caller is to
756 * delete this array using decrRef() as it is no more needed.
758 DataArrayDouble *DataArrayDouble::deepCpy() const throw(INTERP_KERNEL::Exception)
760 return new DataArrayDouble(*this);
764 * Returns either a \a deep or \a shallow copy of this array. For more info see
765 * \ref MEDCouplingArrayBasicsCopyDeep and \ref MEDCouplingArrayBasicsCopyShallow.
766 * \param [in] dCpy - if \a true, a deep copy is returned, else, a shallow one.
767 * \return DataArrayDouble * - either a new instance of DataArrayDouble (if \a dCpy
768 * == \a true) or \a this instance (if \a dCpy == \a false).
770 DataArrayDouble *DataArrayDouble::performCpy(bool dCpy) const throw(INTERP_KERNEL::Exception)
777 return const_cast<DataArrayDouble *>(this);
782 * Copies all the data from another DataArrayDouble. For more info see
783 * \ref MEDCouplingArrayBasicsCopyDeepAssign.
784 * \param [in] other - another instance of DataArrayDouble to copy data from.
785 * \throw If the \a other is not allocated.
787 void DataArrayDouble::cpyFrom(const DataArrayDouble& other) throw(INTERP_KERNEL::Exception)
789 other.checkAllocated();
790 int nbOfTuples=other.getNumberOfTuples();
791 int nbOfComp=other.getNumberOfComponents();
792 allocIfNecessary(nbOfTuples,nbOfComp);
793 std::size_t nbOfElems=(std::size_t)nbOfTuples*nbOfComp;
794 double *pt=getPointer();
795 const double *ptI=other.getConstPointer();
796 for(std::size_t i=0;i<nbOfElems;i++)
798 copyStringInfoFrom(other);
802 * This method reserve nbOfElems elements in memory ( nbOfElems*8 bytes ) \b without impacting the number of tuples in \a this.
803 * 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.
804 * If \a this has not already been allocated, number of components is set to one.
805 * This method allows to reduce number of reallocations on invokation of DataArrayDouble::pushBackSilent and DataArrayDouble::pushBackValsSilent on \a this.
807 * \sa DataArrayDouble::pack, DataArrayDouble::pushBackSilent, DataArrayDouble::pushBackValsSilent
809 void DataArrayDouble::reserve(std::size_t nbOfElems) throw(INTERP_KERNEL::Exception)
811 int nbCompo=getNumberOfComponents();
814 _mem.reserve(nbOfElems);
818 _mem.reserve(nbOfElems);
819 _info_on_compo.resize(1);
822 throw INTERP_KERNEL::Exception("DataArrayDouble::reserve : not available for DataArrayDouble with number of components different than 1 !");
826 * 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
827 * of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
829 * \param [in] val the value to be added in \a this
830 * \throw If \a this has already been allocated with number of components different from one.
831 * \sa DataArrayDouble::pushBackValsSilent
833 void DataArrayDouble::pushBackSilent(double val) throw(INTERP_KERNEL::Exception)
835 int nbCompo=getNumberOfComponents();
840 _info_on_compo.resize(1);
844 throw INTERP_KERNEL::Exception("DataArrayDouble::pushBackSilent : not available for DataArrayDouble with number of components different than 1 !");
848 * 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
849 * of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
851 * \param [in] valsBg - an array of values to push at the end of \this.
852 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
853 * the last value of \a valsBg is \a valsEnd[ -1 ].
854 * \throw If \a this has already been allocated with number of components different from one.
855 * \sa DataArrayDouble::pushBackSilent
857 void DataArrayDouble::pushBackValsSilent(const double *valsBg, const double *valsEnd) throw(INTERP_KERNEL::Exception)
859 int nbCompo=getNumberOfComponents();
861 _mem.insertAtTheEnd(valsBg,valsEnd);
864 _info_on_compo.resize(1);
865 _mem.insertAtTheEnd(valsBg,valsEnd);
868 throw INTERP_KERNEL::Exception("DataArrayDouble::pushBackValsSilent : not available for DataArrayDouble with number of components different than 1 !");
872 * This method returns silently ( without updating time label in \a this ) the last value, if any and suppress it.
873 * \throw If \a this is already empty.
874 * \throw If \a this has number of components different from one.
876 double DataArrayDouble::popBackSilent() throw(INTERP_KERNEL::Exception)
878 if(getNumberOfComponents()==1)
879 return _mem.popBack();
881 throw INTERP_KERNEL::Exception("DataArrayDouble::popBackSilent : not available for DataArrayDouble with number of components different than 1 !");
885 * 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.
887 * \sa DataArrayDouble::getHeapMemorySize, DataArrayDouble::reserve
889 void DataArrayDouble::pack() const throw(INTERP_KERNEL::Exception)
895 * Allocates the raw data in memory. If exactly same memory as needed already
896 * allocated, it is not re-allocated.
897 * \param [in] nbOfTuple - number of tuples of data to allocate.
898 * \param [in] nbOfCompo - number of components of data to allocate.
899 * \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
901 void DataArrayDouble::allocIfNecessary(int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception)
905 if(nbOfTuple!=getNumberOfTuples() || nbOfCompo!=getNumberOfComponents())
906 alloc(nbOfTuple,nbOfCompo);
909 alloc(nbOfTuple,nbOfCompo);
913 * Allocates the raw data in memory. If the memory was already allocated, then it is
914 * freed and re-allocated. See an example of this method use
915 * \ref MEDCouplingArraySteps1WC "here".
916 * \param [in] nbOfTuple - number of tuples of data to allocate.
917 * \param [in] nbOfCompo - number of components of data to allocate.
918 * \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
920 void DataArrayDouble::alloc(int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception)
922 if(nbOfTuple<0 || nbOfCompo<0)
923 throw INTERP_KERNEL::Exception("DataArrayDouble::alloc : request for negative length of data !");
924 _info_on_compo.resize(nbOfCompo);
925 _mem.alloc(nbOfCompo*(std::size_t)nbOfTuple);
930 * Assign zero to all values in \a this array. To know more on filling arrays see
931 * \ref MEDCouplingArrayFill.
932 * \throw If \a this is not allocated.
934 void DataArrayDouble::fillWithZero() throw(INTERP_KERNEL::Exception)
937 _mem.fillWithValue(0.);
942 * Assign \a val to all values in \a this array. To know more on filling arrays see
943 * \ref MEDCouplingArrayFill.
944 * \param [in] val - the value to fill with.
945 * \throw If \a this is not allocated.
947 void DataArrayDouble::fillWithValue(double val) throw(INTERP_KERNEL::Exception)
950 _mem.fillWithValue(val);
955 * Set all values in \a this array so that the i-th element equals to \a init + i
956 * (i starts from zero). To know more on filling arrays see \ref MEDCouplingArrayFill.
957 * \param [in] init - value to assign to the first element of array.
958 * \throw If \a this->getNumberOfComponents() != 1
959 * \throw If \a this is not allocated.
961 void DataArrayDouble::iota(double init) throw(INTERP_KERNEL::Exception)
964 if(getNumberOfComponents()!=1)
965 throw INTERP_KERNEL::Exception("DataArrayDouble::iota : works only for arrays with only one component, you can call 'rearrange' method before !");
966 double *ptr=getPointer();
967 int ntuples=getNumberOfTuples();
968 for(int i=0;i<ntuples;i++)
969 ptr[i]=init+double(i);
974 * Checks if all values in \a this array are equal to \a val at precision \a eps.
975 * \param [in] val - value to check equality of array values to.
976 * \param [in] eps - precision to check the equality.
977 * \return bool - \a true if all values are in range (_val_ - _eps_; _val_ + _eps_),
979 * \throw If \a this->getNumberOfComponents() != 1
980 * \throw If \a this is not allocated.
982 bool DataArrayDouble::isUniform(double val, double eps) const throw(INTERP_KERNEL::Exception)
985 if(getNumberOfComponents()!=1)
986 throw INTERP_KERNEL::Exception("DataArrayDouble::isUniform : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
987 int nbOfTuples=getNumberOfTuples();
988 const double *w=getConstPointer();
989 const double *end2=w+nbOfTuples;
990 const double vmin=val-eps;
991 const double vmax=val+eps;
993 if(*w<vmin || *w>vmax)
999 * Sorts values of the array.
1000 * \param [in] asc - \a true means ascending order, \a false, descending.
1001 * \throw If \a this is not allocated.
1002 * \throw If \a this->getNumberOfComponents() != 1.
1004 void DataArrayDouble::sort(bool asc) throw(INTERP_KERNEL::Exception)
1007 if(getNumberOfComponents()!=1)
1008 throw INTERP_KERNEL::Exception("DataArrayDouble::sort : only supported with 'this' array with ONE component !");
1014 * Reverse the array values.
1015 * \throw If \a this->getNumberOfComponents() < 1.
1016 * \throw If \a this is not allocated.
1018 void DataArrayDouble::reverse() throw(INTERP_KERNEL::Exception)
1021 _mem.reverse(getNumberOfComponents());
1026 * Checks that \a this array is consistently **increasing** or **decreasing** in value,
1027 * with at least absolute difference value of |\a eps| at each step.
1028 * If not an exception is thrown.
1029 * \param [in] increasing - if \a true, the array values should be increasing.
1030 * \param [in] eps - minimal absolute difference between the neighbor values at which
1031 * the values are considered different.
1032 * \throw If sequence of values is not strictly monotonic in agreement with \a
1034 * \throw If \a this->getNumberOfComponents() != 1.
1035 * \throw If \a this is not allocated.
1037 void DataArrayDouble::checkMonotonic(bool increasing, double eps) const throw(INTERP_KERNEL::Exception)
1039 if(!isMonotonic(increasing,eps))
1042 throw INTERP_KERNEL::Exception("DataArrayDouble::checkMonotonic : 'this' is not INCREASING monotonic !");
1044 throw INTERP_KERNEL::Exception("DataArrayDouble::checkMonotonic : 'this' is not DECREASING monotonic !");
1049 * Checks that \a this array is consistently **increasing** or **decreasing** in value,
1050 * with at least absolute difference value of |\a eps| at each step.
1051 * \param [in] increasing - if \a true, array values should be increasing.
1052 * \param [in] eps - minimal absolute difference between the neighbor values at which
1053 * the values are considered different.
1054 * \return bool - \a true if values change in accordance with \a increasing arg.
1055 * \throw If \a this->getNumberOfComponents() != 1.
1056 * \throw If \a this is not allocated.
1058 bool DataArrayDouble::isMonotonic(bool increasing, double eps) const throw(INTERP_KERNEL::Exception)
1061 if(getNumberOfComponents()!=1)
1062 throw INTERP_KERNEL::Exception("DataArrayDouble::isMonotonic : only supported with 'this' array with ONE component !");
1063 int nbOfElements=getNumberOfTuples();
1064 const double *ptr=getConstPointer();
1068 double absEps=fabs(eps);
1071 for(int i=1;i<nbOfElements;i++)
1073 if(ptr[i]<(ref+absEps))
1081 for(int i=1;i<nbOfElements;i++)
1083 if(ptr[i]>(ref-absEps))
1092 * Returns a textual and human readable representation of \a this instance of
1093 * DataArrayDouble. This text is shown when a DataArrayDouble is printed in Python.
1094 * \return std::string - text describing \a this DataArrayDouble.
1096 std::string DataArrayDouble::repr() const throw(INTERP_KERNEL::Exception)
1098 std::ostringstream ret;
1103 std::string DataArrayDouble::reprZip() const throw(INTERP_KERNEL::Exception)
1105 std::ostringstream ret;
1110 void DataArrayDouble::writeVTK(std::ostream& ofs, int indent, const char *nameInFile) const throw(INTERP_KERNEL::Exception)
1112 std::string idt(indent,' ');
1114 ofs << idt << "<DataArray type=\"Float32\" Name=\"" << nameInFile << "\" NumberOfComponents=\"" << getNumberOfComponents() << "\"";
1115 ofs << " format=\"ascii\" RangeMin=\"" << getMinValueInArray() << "\" RangeMax=\"" << getMaxValueInArray() << "\">\n" << idt;
1116 std::copy(begin(),end(),std::ostream_iterator<double>(ofs," "));
1117 ofs << std::endl << idt << "</DataArray>\n";
1120 void DataArrayDouble::reprStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
1122 stream << "Name of double array : \"" << _name << "\"\n";
1123 reprWithoutNameStream(stream);
1126 void DataArrayDouble::reprZipStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
1128 stream << "Name of double array : \"" << _name << "\"\n";
1129 reprZipWithoutNameStream(stream);
1132 void DataArrayDouble::reprWithoutNameStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
1134 DataArray::reprWithoutNameStream(stream);
1135 stream.precision(17);
1136 _mem.repr(getNumberOfComponents(),stream);
1139 void DataArrayDouble::reprZipWithoutNameStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
1141 DataArray::reprWithoutNameStream(stream);
1142 stream.precision(17);
1143 _mem.reprZip(getNumberOfComponents(),stream);
1146 void DataArrayDouble::reprCppStream(const char *varName, std::ostream& stream) const throw(INTERP_KERNEL::Exception)
1148 int nbTuples=getNumberOfTuples(),nbComp=getNumberOfComponents();
1149 const double *data=getConstPointer();
1150 stream.precision(17);
1151 stream << "DataArrayDouble *" << varName << "=DataArrayDouble::New();" << std::endl;
1152 if(nbTuples*nbComp>=1)
1154 stream << "const double " << varName << "Data[" << nbTuples*nbComp << "]={";
1155 std::copy(data,data+nbTuples*nbComp-1,std::ostream_iterator<double>(stream,","));
1156 stream << data[nbTuples*nbComp-1] << "};" << std::endl;
1157 stream << varName << "->useArray(" << varName << "Data,false,CPP_DEALLOC," << nbTuples << "," << nbComp << ");" << std::endl;
1160 stream << varName << "->alloc(" << nbTuples << "," << nbComp << ");" << std::endl;
1161 stream << varName << "->setName(\"" << getName() << "\");" << std::endl;
1165 * Method that gives a quick overvien of \a this for python.
1167 void DataArrayDouble::reprQuickOverview(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
1169 static const std::size_t MAX_NB_OF_BYTE_IN_REPR=300;
1170 stream << "DataArrayDouble C++ instance at " << this << ". ";
1173 int nbOfCompo=(int)_info_on_compo.size();
1176 int nbOfTuples=getNumberOfTuples();
1177 stream << "Number of tuples : " << nbOfTuples << ". Number of components : " << nbOfCompo << "." << std::endl;
1178 reprQuickOverviewData(stream,MAX_NB_OF_BYTE_IN_REPR);
1181 stream << "Number of components : 0.";
1184 stream << "*** No data allocated ****";
1187 void DataArrayDouble::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const throw(INTERP_KERNEL::Exception)
1189 const double *data=begin();
1190 int nbOfTuples=getNumberOfTuples();
1191 int nbOfCompo=(int)_info_on_compo.size();
1192 std::ostringstream oss2; oss2 << "[";
1194 std::string oss2Str(oss2.str());
1195 bool isFinished=true;
1196 for(int i=0;i<nbOfTuples && isFinished;i++)
1201 for(int j=0;j<nbOfCompo;j++,data++)
1204 if(j!=nbOfCompo-1) oss2 << ", ";
1210 if(i!=nbOfTuples-1) oss2 << ", ";
1211 std::string oss3Str(oss2.str());
1212 if(oss3Str.length()<maxNbOfByteInRepr)
1224 * Equivalent to DataArrayDouble::isEqual except that if false the reason of
1225 * mismatch is given.
1227 * \param [in] other the instance to be compared with \a this
1228 * \param [in] prec the precision to compare numeric data of the arrays.
1229 * \param [out] reason In case of inequality returns the reason.
1230 * \sa DataArrayDouble::isEqual
1232 bool DataArrayDouble::isEqualIfNotWhy(const DataArrayDouble& other, double prec, std::string& reason) const throw(INTERP_KERNEL::Exception)
1234 if(!areInfoEqualsIfNotWhy(other,reason))
1236 return _mem.isEqual(other._mem,prec,reason);
1240 * Checks if \a this and another DataArrayDouble are fully equal. For more info see
1241 * \ref MEDCouplingArrayBasicsCompare.
1242 * \param [in] other - an instance of DataArrayDouble to compare with \a this one.
1243 * \param [in] prec - precision value to compare numeric data of the arrays.
1244 * \return bool - \a true if the two arrays are equal, \a false else.
1246 bool DataArrayDouble::isEqual(const DataArrayDouble& other, double prec) const throw(INTERP_KERNEL::Exception)
1249 return isEqualIfNotWhy(other,prec,tmp);
1253 * Checks if values of \a this and another DataArrayDouble are equal. For more info see
1254 * \ref MEDCouplingArrayBasicsCompare.
1255 * \param [in] other - an instance of DataArrayDouble to compare with \a this one.
1256 * \param [in] prec - precision value to compare numeric data of the arrays.
1257 * \return bool - \a true if the values of two arrays are equal, \a false else.
1259 bool DataArrayDouble::isEqualWithoutConsideringStr(const DataArrayDouble& other, double prec) const throw(INTERP_KERNEL::Exception)
1262 return _mem.isEqual(other._mem,prec,tmp);
1266 * Changes number of tuples in the array. If the new number of tuples is smaller
1267 * than the current number the array is truncated, otherwise the array is extended.
1268 * \param [in] nbOfTuples - new number of tuples.
1269 * \throw If \a this is not allocated.
1270 * \throw If \a nbOfTuples is negative.
1272 void DataArrayDouble::reAlloc(int nbOfTuples) throw(INTERP_KERNEL::Exception)
1275 throw INTERP_KERNEL::Exception("DataArrayDouble::reAlloc : input new number of tuples should be >=0 !");
1277 _mem.reAlloc(getNumberOfComponents()*(std::size_t)nbOfTuples);
1282 * Creates a new DataArrayInt and assigns all (textual and numerical) data of \a this
1283 * array to the new one.
1284 * \return DataArrayInt * - the new instance of DataArrayInt.
1286 DataArrayInt *DataArrayDouble::convertToIntArr() const
1288 DataArrayInt *ret=DataArrayInt::New();
1289 ret->alloc(getNumberOfTuples(),getNumberOfComponents());
1290 std::size_t nbOfVals=getNbOfElems();
1291 const double *src=getConstPointer();
1292 int *dest=ret->getPointer();
1293 std::copy(src,src+nbOfVals,dest);
1294 ret->copyStringInfoFrom(*this);
1299 * Returns a new DataArrayDouble holding the same values as \a this array but differently
1300 * arranged in memory. If \a this array holds 2 components of 3 values:
1301 * \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$, then the result array holds these values arranged
1302 * as follows: \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$.
1303 * \warning Do not confuse this method with transpose()!
1304 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1305 * is to delete using decrRef() as it is no more needed.
1306 * \throw If \a this is not allocated.
1308 DataArrayDouble *DataArrayDouble::fromNoInterlace() const throw(INTERP_KERNEL::Exception)
1311 throw INTERP_KERNEL::Exception("DataArrayDouble::fromNoInterlace : Not defined array !");
1312 double *tab=_mem.fromNoInterlace(getNumberOfComponents());
1313 DataArrayDouble *ret=DataArrayDouble::New();
1314 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
1319 * Returns a new DataArrayDouble holding the same values as \a this array but differently
1320 * arranged in memory. If \a this array holds 2 components of 3 values:
1321 * \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$, then the result array holds these values arranged
1322 * as follows: \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$.
1323 * \warning Do not confuse this method with transpose()!
1324 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1325 * is to delete using decrRef() as it is no more needed.
1326 * \throw If \a this is not allocated.
1328 DataArrayDouble *DataArrayDouble::toNoInterlace() const throw(INTERP_KERNEL::Exception)
1331 throw INTERP_KERNEL::Exception("DataArrayDouble::toNoInterlace : Not defined array !");
1332 double *tab=_mem.toNoInterlace(getNumberOfComponents());
1333 DataArrayDouble *ret=DataArrayDouble::New();
1334 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
1339 * Permutes values of \a this array as required by \a old2New array. The values are
1340 * permuted so that \c new[ \a old2New[ i ]] = \c old[ i ]. Number of tuples remains
1341 * the same as in \this one.
1342 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
1343 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1344 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
1345 * giving a new position for i-th old value.
1347 void DataArrayDouble::renumberInPlace(const int *old2New) throw(INTERP_KERNEL::Exception)
1350 int nbTuples=getNumberOfTuples();
1351 int nbOfCompo=getNumberOfComponents();
1352 double *tmp=new double[nbTuples*nbOfCompo];
1353 const double *iptr=getConstPointer();
1354 for(int i=0;i<nbTuples;i++)
1357 if(v>=0 && v<nbTuples)
1358 std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),tmp+nbOfCompo*v);
1361 std::ostringstream oss; oss << "DataArrayDouble::renumberInPlace : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
1362 throw INTERP_KERNEL::Exception(oss.str().c_str());
1365 std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
1371 * Permutes values of \a this array as required by \a new2Old array. The values are
1372 * permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of tuples remains
1373 * the same as in \this one.
1374 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1375 * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
1376 * giving a previous position of i-th new value.
1377 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1378 * is to delete using decrRef() as it is no more needed.
1380 void DataArrayDouble::renumberInPlaceR(const int *new2Old) throw(INTERP_KERNEL::Exception)
1383 int nbTuples=getNumberOfTuples();
1384 int nbOfCompo=getNumberOfComponents();
1385 double *tmp=new double[nbTuples*nbOfCompo];
1386 const double *iptr=getConstPointer();
1387 for(int i=0;i<nbTuples;i++)
1390 if(v>=0 && v<nbTuples)
1391 std::copy(iptr+nbOfCompo*v,iptr+nbOfCompo*(v+1),tmp+nbOfCompo*i);
1394 std::ostringstream oss; oss << "DataArrayDouble::renumberInPlaceR : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
1395 throw INTERP_KERNEL::Exception(oss.str().c_str());
1398 std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
1404 * Returns a copy of \a this array with values permuted as required by \a old2New array.
1405 * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ].
1406 * Number of tuples in the result array remains the same as in \this one.
1407 * If a permutation reduction is needed, renumberAndReduce() should be used.
1408 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1409 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
1410 * giving a new position for i-th old value.
1411 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1412 * is to delete using decrRef() as it is no more needed.
1413 * \throw If \a this is not allocated.
1415 DataArrayDouble *DataArrayDouble::renumber(const int *old2New) const throw(INTERP_KERNEL::Exception)
1418 int nbTuples=getNumberOfTuples();
1419 int nbOfCompo=getNumberOfComponents();
1420 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1421 ret->alloc(nbTuples,nbOfCompo);
1422 ret->copyStringInfoFrom(*this);
1423 const double *iptr=getConstPointer();
1424 double *optr=ret->getPointer();
1425 for(int i=0;i<nbTuples;i++)
1426 std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),optr+nbOfCompo*old2New[i]);
1427 ret->copyStringInfoFrom(*this);
1432 * Returns a copy of \a this array with values permuted as required by \a new2Old array.
1433 * The values are permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of
1434 * tuples in the result array remains the same as in \this one.
1435 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
1436 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1437 * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
1438 * giving a previous position of i-th new value.
1439 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1440 * is to delete using decrRef() as it is no more needed.
1442 DataArrayDouble *DataArrayDouble::renumberR(const int *new2Old) const throw(INTERP_KERNEL::Exception)
1445 int nbTuples=getNumberOfTuples();
1446 int nbOfCompo=getNumberOfComponents();
1447 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1448 ret->alloc(nbTuples,nbOfCompo);
1449 ret->copyStringInfoFrom(*this);
1450 const double *iptr=getConstPointer();
1451 double *optr=ret->getPointer();
1452 for(int i=0;i<nbTuples;i++)
1453 std::copy(iptr+nbOfCompo*new2Old[i],iptr+nbOfCompo*(new2Old[i]+1),optr+i*nbOfCompo);
1454 ret->copyStringInfoFrom(*this);
1459 * Returns a shorten and permuted copy of \a this array. The new DataArrayDouble is
1460 * of size \a newNbOfTuple and it's values are permuted as required by \a old2New array.
1461 * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ] for all
1462 * \a old2New[ i ] >= 0. In other words every i-th tuple in \a this array, for which
1463 * \a old2New[ i ] is negative, is missing from the result array.
1464 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1465 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
1466 * giving a new position for i-th old tuple and giving negative position for
1467 * for i-th old tuple that should be omitted.
1468 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1469 * is to delete using decrRef() as it is no more needed.
1471 DataArrayDouble *DataArrayDouble::renumberAndReduce(const int *old2New, int newNbOfTuple) const throw(INTERP_KERNEL::Exception)
1474 int nbTuples=getNumberOfTuples();
1475 int nbOfCompo=getNumberOfComponents();
1476 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1477 ret->alloc(newNbOfTuple,nbOfCompo);
1478 const double *iptr=getConstPointer();
1479 double *optr=ret->getPointer();
1480 for(int i=0;i<nbTuples;i++)
1484 std::copy(iptr+i*nbOfCompo,iptr+(i+1)*nbOfCompo,optr+w*nbOfCompo);
1486 ret->copyStringInfoFrom(*this);
1491 * Returns a shorten and permuted copy of \a this array. The new DataArrayDouble is
1492 * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
1493 * \a new2OldBg array.
1494 * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
1495 * This method is equivalent to renumberAndReduce() except that convention in input is
1496 * \c new2old and \b not \c old2new.
1497 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1498 * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
1499 * tuple index in \a this array to fill the i-th tuple in the new array.
1500 * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
1501 * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
1502 * \a new2OldBg <= \a pi < \a new2OldEnd.
1503 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1504 * is to delete using decrRef() as it is no more needed.
1506 DataArrayDouble *DataArrayDouble::selectByTupleId(const int *new2OldBg, const int *new2OldEnd) const
1509 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1510 int nbComp=getNumberOfComponents();
1511 ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
1512 ret->copyStringInfoFrom(*this);
1513 double *pt=ret->getPointer();
1514 const double *srcPt=getConstPointer();
1516 for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
1517 std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
1518 ret->copyStringInfoFrom(*this);
1523 * Returns a shorten and permuted copy of \a this array. The new DataArrayDouble is
1524 * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
1525 * \a new2OldBg array.
1526 * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
1527 * This method is equivalent to renumberAndReduce() except that convention in input is
1528 * \c new2old and \b not \c old2new.
1529 * This method is equivalent to selectByTupleId() except that it prevents coping data
1530 * from behind the end of \a this array.
1531 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1532 * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
1533 * tuple index in \a this array to fill the i-th tuple in the new array.
1534 * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
1535 * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
1536 * \a new2OldBg <= \a pi < \a new2OldEnd.
1537 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1538 * is to delete using decrRef() as it is no more needed.
1539 * \throw If \a new2OldEnd - \a new2OldBg > \a this->getNumberOfTuples().
1541 DataArrayDouble *DataArrayDouble::selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const throw(INTERP_KERNEL::Exception)
1544 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1545 int nbComp=getNumberOfComponents();
1546 int oldNbOfTuples=getNumberOfTuples();
1547 ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
1548 ret->copyStringInfoFrom(*this);
1549 double *pt=ret->getPointer();
1550 const double *srcPt=getConstPointer();
1552 for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
1553 if(*w>=0 && *w<oldNbOfTuples)
1554 std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
1556 throw INTERP_KERNEL::Exception("DataArrayDouble::selectByTupleIdSafe : some ids has been detected to be out of [0,this->getNumberOfTuples) !");
1557 ret->copyStringInfoFrom(*this);
1562 * Returns a shorten copy of \a this array. The new DataArrayDouble contains every
1563 * (\a bg + \c i * \a step)-th tuple of \a this array located before the \a end2-th
1564 * tuple. Indices of the selected tuples are the same as ones returned by the Python
1565 * command \c range( \a bg, \a end2, \a step ).
1566 * This method is equivalent to selectByTupleIdSafe() except that the input array is
1567 * not constructed explicitly.
1568 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1569 * \param [in] bg - index of the first tuple to copy from \a this array.
1570 * \param [in] end2 - index of the tuple before which the tuples to copy are located.
1571 * \param [in] step - index increment to get index of the next tuple to copy.
1572 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1573 * is to delete using decrRef() as it is no more needed.
1574 * \sa DataArrayDouble::substr.
1576 DataArrayDouble *DataArrayDouble::selectByTupleId2(int bg, int end2, int step) const throw(INTERP_KERNEL::Exception)
1579 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1580 int nbComp=getNumberOfComponents();
1581 int newNbOfTuples=GetNumberOfItemGivenBESRelative(bg,end2,step,"DataArrayDouble::selectByTupleId2 : ");
1582 ret->alloc(newNbOfTuples,nbComp);
1583 double *pt=ret->getPointer();
1584 const double *srcPt=getConstPointer()+bg*nbComp;
1585 for(int i=0;i<newNbOfTuples;i++,srcPt+=step*nbComp)
1586 std::copy(srcPt,srcPt+nbComp,pt+i*nbComp);
1587 ret->copyStringInfoFrom(*this);
1592 * Returns a shorten copy of \a this array. The new DataArrayDouble contains ranges
1593 * of tuples specified by \a ranges parameter.
1594 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1595 * \param [in] ranges - std::vector of std::pair's each of which defines a range
1596 * of tuples in [\c begin,\c end) format.
1597 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1598 * is to delete using decrRef() as it is no more needed.
1599 * \throw If \a end < \a begin.
1600 * \throw If \a end > \a this->getNumberOfTuples().
1601 * \throw If \a this is not allocated.
1603 DataArray *DataArrayDouble::selectByTupleRanges(const std::vector<std::pair<int,int> >& ranges) const throw(INTERP_KERNEL::Exception)
1606 int nbOfComp=getNumberOfComponents();
1607 int nbOfTuplesThis=getNumberOfTuples();
1610 DataArrayDouble *ret=DataArrayDouble::New();
1611 ret->alloc(0,nbOfComp);
1612 ret->copyStringInfoFrom(*this);
1615 int ref=ranges.front().first;
1617 bool isIncreasing=true;
1618 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
1620 if((*it).first<=(*it).second)
1622 if((*it).first>=0 && (*it).second<=nbOfTuplesThis)
1624 nbOfTuples+=(*it).second-(*it).first;
1626 isIncreasing=ref<=(*it).first;
1631 std::ostringstream oss; oss << "DataArrayDouble::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
1632 oss << " (" << (*it).first << "," << (*it).second << ") is greater than number of tuples of this :" << nbOfTuples << " !";
1633 throw INTERP_KERNEL::Exception(oss.str().c_str());
1638 std::ostringstream oss; oss << "DataArrayDouble::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
1639 oss << " (" << (*it).first << "," << (*it).second << ") end is before begin !";
1640 throw INTERP_KERNEL::Exception(oss.str().c_str());
1643 if(isIncreasing && nbOfTuplesThis==nbOfTuples)
1645 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1646 ret->alloc(nbOfTuples,nbOfComp);
1647 ret->copyStringInfoFrom(*this);
1648 const double *src=getConstPointer();
1649 double *work=ret->getPointer();
1650 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
1651 work=std::copy(src+(*it).first*nbOfComp,src+(*it).second*nbOfComp,work);
1656 * Returns a shorten copy of \a this array. The new DataArrayDouble contains all
1657 * tuples starting from the \a tupleIdBg-th tuple and including all tuples located before
1658 * the \a tupleIdEnd-th one. This methods has a similar behavior as std::string::substr().
1659 * This method is a specialization of selectByTupleId2().
1660 * \param [in] tupleIdBg - index of the first tuple to copy from \a this array.
1661 * \param [in] tupleIdEnd - index of the tuple before which the tuples to copy are located.
1662 * If \a tupleIdEnd == -1, all the tuples till the end of \a this array are copied.
1663 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1664 * is to delete using decrRef() as it is no more needed.
1665 * \throw If \a tupleIdBg < 0.
1666 * \throw If \a tupleIdBg > \a this->getNumberOfTuples().
1667 \throw If \a tupleIdEnd != -1 && \a tupleIdEnd < \a this->getNumberOfTuples().
1668 * \sa DataArrayDouble::selectByTupleId2
1670 DataArrayDouble *DataArrayDouble::substr(int tupleIdBg, int tupleIdEnd) const throw(INTERP_KERNEL::Exception)
1673 int nbt=getNumberOfTuples();
1675 throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter must be greater than 0 !");
1677 throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter is greater than number of tuples !");
1678 int trueEnd=tupleIdEnd;
1682 throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter is greater or equal than number of tuples !");
1686 int nbComp=getNumberOfComponents();
1687 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1688 ret->alloc(trueEnd-tupleIdBg,nbComp);
1689 ret->copyStringInfoFrom(*this);
1690 std::copy(getConstPointer()+tupleIdBg*nbComp,getConstPointer()+trueEnd*nbComp,ret->getPointer());
1695 * Returns a shorten or extended copy of \a this array. If \a newNbOfComp is less
1696 * than \a this->getNumberOfComponents() then the result array is shorten as each tuple
1697 * is truncated to have \a newNbOfComp components, keeping first components. If \a
1698 * newNbOfComp is more than \a this->getNumberOfComponents() then the result array is
1699 * expanded as each tuple is populated with \a dftValue to have \a newNbOfComp
1701 * \param [in] newNbOfComp - number of components for the new array to have.
1702 * \param [in] dftValue - value assigned to new values added to the new array.
1703 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1704 * is to delete using decrRef() as it is no more needed.
1705 * \throw If \a this is not allocated.
1707 DataArrayDouble *DataArrayDouble::changeNbOfComponents(int newNbOfComp, double dftValue) const throw(INTERP_KERNEL::Exception)
1710 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1711 ret->alloc(getNumberOfTuples(),newNbOfComp);
1712 const double *oldc=getConstPointer();
1713 double *nc=ret->getPointer();
1714 int nbOfTuples=getNumberOfTuples();
1715 int oldNbOfComp=getNumberOfComponents();
1716 int dim=std::min(oldNbOfComp,newNbOfComp);
1717 for(int i=0;i<nbOfTuples;i++)
1721 nc[newNbOfComp*i+j]=oldc[i*oldNbOfComp+j];
1722 for(;j<newNbOfComp;j++)
1723 nc[newNbOfComp*i+j]=dftValue;
1725 ret->setName(getName().c_str());
1726 for(int i=0;i<dim;i++)
1727 ret->setInfoOnComponent(i,getInfoOnComponent(i).c_str());
1728 ret->setName(getName().c_str());
1733 * Changes the number of components within \a this array so that its raw data **does
1734 * not** change, instead splitting this data into tuples changes.
1735 * \warning This method erases all (name and unit) component info set before!
1736 * \param [in] newNbOfComp - number of components for \a this array to have.
1737 * \throw If \a this is not allocated
1738 * \throw If getNbOfElems() % \a newNbOfCompo != 0.
1739 * \throw If \a newNbOfCompo is lower than 1.
1740 * \throw If the rearrange method would lead to a number of tuples higher than 2147483647 (maximal capacity of int32 !).
1741 * \warning This method erases all (name and unit) component info set before!
1743 void DataArrayDouble::rearrange(int newNbOfCompo) throw(INTERP_KERNEL::Exception)
1747 throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : input newNbOfCompo must be > 0 !");
1748 std::size_t nbOfElems=getNbOfElems();
1749 if(nbOfElems%newNbOfCompo!=0)
1750 throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : nbOfElems%newNbOfCompo!=0 !");
1751 if(nbOfElems/newNbOfCompo>(std::size_t)std::numeric_limits<int>::max())
1752 throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : the rearrangement leads to too high number of tuples (> 2147483647) !");
1753 _info_on_compo.clear();
1754 _info_on_compo.resize(newNbOfCompo);
1759 * Changes the number of components within \a this array to be equal to its number
1760 * of tuples, and inversely its number of tuples to become equal to its number of
1761 * components. So that its raw data **does not** change, instead splitting this
1762 * data into tuples changes.
1763 * \warning This method erases all (name and unit) component info set before!
1764 * \warning Do not confuse this method with fromNoInterlace() and toNoInterlace()!
1765 * \throw If \a this is not allocated.
1768 void DataArrayDouble::transpose() throw(INTERP_KERNEL::Exception)
1771 int nbOfTuples=getNumberOfTuples();
1772 rearrange(nbOfTuples);
1776 * Returns a copy of \a this array composed of selected components.
1777 * The new DataArrayDouble has the same number of tuples but includes components
1778 * specified by \a compoIds parameter. So that getNbOfElems() of the result array
1779 * can be either less, same or more than \a this->getNbOfElems().
1780 * \param [in] compoIds - sequence of zero based indices of components to include
1781 * into the new array.
1782 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1783 * is to delete using decrRef() as it is no more needed.
1784 * \throw If \a this is not allocated.
1785 * \throw If a component index (\a i) is not valid:
1786 * \a i < 0 || \a i >= \a this->getNumberOfComponents().
1788 * \ref py_mcdataarraydouble_KeepSelectedComponents "Here is a Python example".
1790 DataArray *DataArrayDouble::keepSelectedComponents(const std::vector<int>& compoIds) const throw(INTERP_KERNEL::Exception)
1793 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret(DataArrayDouble::New());
1794 std::size_t newNbOfCompo=compoIds.size();
1795 int oldNbOfCompo=getNumberOfComponents();
1796 for(std::vector<int>::const_iterator it=compoIds.begin();it!=compoIds.end();it++)
1797 if((*it)<0 || (*it)>=oldNbOfCompo)
1799 std::ostringstream oss; oss << "DataArrayDouble::keepSelectedComponents : invalid requested component : " << *it << " whereas it should be in [0," << oldNbOfCompo << ") !";
1800 throw INTERP_KERNEL::Exception(oss.str().c_str());
1802 int nbOfTuples=getNumberOfTuples();
1803 ret->alloc(nbOfTuples,(int)newNbOfCompo);
1804 ret->copyPartOfStringInfoFrom(*this,compoIds);
1805 const double *oldc=getConstPointer();
1806 double *nc=ret->getPointer();
1807 for(int i=0;i<nbOfTuples;i++)
1808 for(std::size_t j=0;j<newNbOfCompo;j++,nc++)
1809 *nc=oldc[i*oldNbOfCompo+compoIds[j]];
1814 * Appends components of another array to components of \a this one, tuple by tuple.
1815 * So that the number of tuples of \a this array remains the same and the number of
1816 * components increases.
1817 * \param [in] other - the DataArrayDouble to append to \a this one.
1818 * \throw If \a this is not allocated.
1819 * \throw If \a this and \a other arrays have different number of tuples.
1821 * \ref cpp_mcdataarraydouble_meldwith "Here is a C++ example".
1823 * \ref py_mcdataarraydouble_meldwith "Here is a Python example".
1825 void DataArrayDouble::meldWith(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception)
1828 other->checkAllocated();
1829 int nbOfTuples=getNumberOfTuples();
1830 if(nbOfTuples!=other->getNumberOfTuples())
1831 throw INTERP_KERNEL::Exception("DataArrayDouble::meldWith : mismatch of number of tuples !");
1832 int nbOfComp1=getNumberOfComponents();
1833 int nbOfComp2=other->getNumberOfComponents();
1834 double *newArr=(double *)malloc((nbOfTuples*(nbOfComp1+nbOfComp2))*sizeof(double));
1836 const double *inp1=getConstPointer();
1837 const double *inp2=other->getConstPointer();
1838 for(int i=0;i<nbOfTuples;i++,inp1+=nbOfComp1,inp2+=nbOfComp2)
1840 w=std::copy(inp1,inp1+nbOfComp1,w);
1841 w=std::copy(inp2,inp2+nbOfComp2,w);
1843 useArray(newArr,true,C_DEALLOC,nbOfTuples,nbOfComp1+nbOfComp2);
1844 std::vector<int> compIds(nbOfComp2);
1845 for(int i=0;i<nbOfComp2;i++)
1846 compIds[i]=nbOfComp1+i;
1847 copyPartOfStringInfoFrom2(compIds,*other);
1851 * This method checks that all tuples in \a other are in \a this.
1852 * If true, the output param \a tupleIds contains the tuples ids of \a this that correspond to tupes in \a this.
1853 * 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.
1855 * \param [in] other - the array having the same number of components than \a this.
1856 * \param [out] tupleIds - the tuple ids containing the same number of tuples than \a other has.
1857 * \sa DataArrayDouble::findCommonTuples
1859 bool DataArrayDouble::areIncludedInMe(const DataArrayDouble *other, double prec, DataArrayInt *&tupleIds) const throw(INTERP_KERNEL::Exception)
1862 throw INTERP_KERNEL::Exception("DataArrayDouble::areIncludedInMe : input array is NULL !");
1863 checkAllocated(); other->checkAllocated();
1864 if(getNumberOfComponents()!=other->getNumberOfComponents())
1865 throw INTERP_KERNEL::Exception("DataArrayDouble::areIncludedInMe : the number of components does not match !");
1866 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> a=DataArrayDouble::Aggregate(this,other);
1867 DataArrayInt *c=0,*ci=0;
1868 a->findCommonTuples(prec,getNumberOfTuples(),c,ci);
1869 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cSafe(c),ciSafe(ci);
1870 int newNbOfTuples=-1;
1871 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(a->getNumberOfTuples(),c->begin(),ci->begin(),ci->end(),newNbOfTuples);
1872 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=ids->selectByTupleId2(getNumberOfTuples(),a->getNumberOfTuples(),1);
1873 tupleIds=ret1.retn();
1874 return newNbOfTuples==getNumberOfTuples();
1878 * Searches for tuples coincident within \a prec tolerance. Each tuple is considered
1879 * as coordinates of a point in getNumberOfComponents()-dimensional space. The
1880 * distance separating two points is computed with the infinite norm.
1882 * Indices of coincident tuples are stored in output arrays.
1883 * A pair of arrays (\a comm, \a commIndex) is called "Surjective Format 2".
1885 * This method is typically used by MEDCouplingPointSet::findCommonNodes() and
1886 * MEDCouplingUMesh::mergeNodes().
1887 * \param [in] prec - minimal absolute distance between two tuples (infinite norm) at which they are
1888 * considered not coincident.
1889 * \param [in] limitTupleId - limit tuple id. If all tuples within a group of coincident
1890 * tuples have id strictly lower than \a limitTupleId then they are not returned.
1891 * \param [out] comm - the array holding ids (== indices) of coincident tuples.
1892 * \a comm->getNumberOfComponents() == 1.
1893 * \a comm->getNumberOfTuples() == \a commIndex->back().
1894 * \param [out] commIndex - the array dividing all indices stored in \a comm into
1895 * groups of (indices of) coincident tuples. Its every value is a tuple
1896 * index where a next group of tuples begins. For example the second
1897 * group of tuples in \a comm is described by following range of indices:
1898 * [ \a commIndex[1], \a commIndex[2] ). \a commIndex->getNumberOfTuples()-1
1899 * gives the number of groups of coincident tuples.
1900 * \throw If \a this is not allocated.
1901 * \throw If the number of components is not in [1,2,3].
1903 * \ref cpp_mcdataarraydouble_findcommontuples "Here is a C++ example".
1905 * \ref py_mcdataarraydouble_findcommontuples "Here is a Python example".
1906 * \sa DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(), DataArrayDouble::areIncludedInMe
1908 void DataArrayDouble::findCommonTuples(double prec, int limitTupleId, DataArrayInt *&comm, DataArrayInt *&commIndex) const throw(INTERP_KERNEL::Exception)
1911 int nbOfCompo=getNumberOfComponents();
1912 if ((nbOfCompo<1) || (nbOfCompo>3)) //test before work
1913 throw INTERP_KERNEL::Exception("DataArrayDouble::findCommonTuples : Unexpected spacedim of coords. Must be 1, 2 or 3.");
1915 int nbOfTuples=getNumberOfTuples();
1917 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> c(DataArrayInt::New()),cI(DataArrayInt::New()); c->alloc(0,1); cI->pushBackSilent(0);
1921 findCommonTuplesAlg<3>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
1924 findCommonTuplesAlg<2>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
1927 findCommonTuplesAlg<1>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
1930 throw INTERP_KERNEL::Exception("DataArrayDouble::findCommonTuples : nb of components managed are 1,2 and 3 ! not implemented for other number of components !");
1933 commIndex=cI.retn();
1938 * \param [in] nbTimes specifies the nb of times each tuples in \a this will be duplicated contiguouly in returned DataArrayDouble instance.
1939 * \a nbTimes should be at least equal to 1.
1940 * \return a newly allocated DataArrayDouble having one component and number of tuples equal to \a nbTimes * \c this->getNumberOfTuples.
1941 * \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.
1943 DataArrayDouble *DataArrayDouble::duplicateEachTupleNTimes(int nbTimes) const throw(INTERP_KERNEL::Exception)
1946 if(getNumberOfComponents()!=1)
1947 throw INTERP_KERNEL::Exception("DataArrayDouble::duplicateEachTupleNTimes : this should have only one component !");
1949 throw INTERP_KERNEL::Exception("DataArrayDouble::duplicateEachTupleNTimes : nb times should be >= 1 !");
1950 int nbTuples=getNumberOfTuples();
1951 const double *inPtr=getConstPointer();
1952 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(nbTimes*nbTuples,1);
1953 double *retPtr=ret->getPointer();
1954 for(int i=0;i<nbTuples;i++,inPtr++)
1957 for(int j=0;j<nbTimes;j++,retPtr++)
1960 ret->copyStringInfoFrom(*this);
1965 * This methods returns the minimal distance between the two set of points \a this and \a other.
1966 * So \a this and \a other have to have the same number of components. If not an INTERP_KERNEL::Exception will be thrown.
1967 * This method works only if number of components of \a this (equal to those of \a other) is in 1, 2 or 3.
1969 * \param [out] thisTupleId the tuple id in \a this corresponding to the returned minimal distance
1970 * \param [out] otherTupleId the tuple id in \a other corresponding to the returned minimal distance
1971 * \return the minimal distance between the two set of points \a this and \a other.
1972 * \sa DataArrayDouble::findClosestTupleId
1974 double DataArrayDouble::minimalDistanceTo(const DataArrayDouble *other, int& thisTupleId, int& otherTupleId) const throw(INTERP_KERNEL::Exception)
1976 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> part1=findClosestTupleId(other);
1977 int nbOfCompo(getNumberOfComponents());
1978 int otherNbTuples(other->getNumberOfTuples());
1979 const double *thisPt(begin()),*otherPt(other->begin());
1980 const int *part1Pt(part1->begin());
1981 double ret=std::numeric_limits<double>::max();
1982 for(int i=0;i<otherNbTuples;i++,part1Pt++,otherPt+=nbOfCompo)
1985 for(int j=0;j<nbOfCompo;j++)
1986 tmp+=(otherPt[j]-thisPt[nbOfCompo*(*part1Pt)+j])*(otherPt[j]-thisPt[nbOfCompo*(*part1Pt)+j]);
1988 { ret=tmp; thisTupleId=*part1Pt; otherTupleId=i; }
1994 * This methods returns for each tuple in \a other which tuple in \a this is the closest.
1995 * So \a this and \a other have to have the same number of components. If not an INTERP_KERNEL::Exception will be thrown.
1996 * This method works only if number of components of \a this (equal to those of \a other) is in 1, 2 or 3.
1998 * \return a newly allocated (new object to be dealt by the caller) DataArrayInt having \c other->getNumberOfTuples() tuples and one components.
1999 * \sa DataArrayDouble::minimalDistanceTo
2001 DataArrayInt *DataArrayDouble::findClosestTupleId(const DataArrayDouble *other) const throw(INTERP_KERNEL::Exception)
2004 throw INTERP_KERNEL::Exception("DataArrayDouble::findClosestTupleId : other instance is NULL !");
2005 checkAllocated(); other->checkAllocated();
2006 int nbOfCompo=getNumberOfComponents();
2007 if(nbOfCompo!=other->getNumberOfComponents())
2009 std::ostringstream oss; oss << "DataArrayDouble::findClosestTupleId : number of components in this is " << nbOfCompo;
2010 oss << ", whereas number of components in other is " << other->getNumberOfComponents() << "! Should be equal !";
2011 throw INTERP_KERNEL::Exception(oss.str().c_str());
2013 int nbOfTuples=other->getNumberOfTuples();
2014 int thisNbOfTuples=getNumberOfTuples();
2015 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbOfTuples,1);
2017 getMinMaxPerComponent(bounds);
2022 double xDelta(fabs(bounds[1]-bounds[0])),yDelta(fabs(bounds[3]-bounds[2])),zDelta(fabs(bounds[5]-bounds[4]));
2023 double delta=std::max(xDelta,yDelta); delta=std::max(delta,zDelta);
2024 double characSize=pow((delta*delta*delta)/((double)thisNbOfTuples),1./3.);
2025 BBTreePts<3,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
2026 FindClosestTupleIdAlg<3>(myTree,3.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
2031 double xDelta(fabs(bounds[1]-bounds[0])),yDelta(fabs(bounds[3]-bounds[2]));
2032 double delta=std::max(xDelta,yDelta);
2033 double characSize=sqrt(delta/(double)thisNbOfTuples);
2034 BBTreePts<2,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
2035 FindClosestTupleIdAlg<2>(myTree,2.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
2040 double characSize=fabs(bounds[1]-bounds[0])/thisNbOfTuples;
2041 BBTreePts<1,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
2042 FindClosestTupleIdAlg<1>(myTree,1.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
2046 throw INTERP_KERNEL::Exception("Unexpected spacedim of coords for findClosestTupleId. Must be 1, 2 or 3.");
2052 * Returns a copy of \a this array by excluding coincident tuples. Each tuple is
2053 * considered as coordinates of a point in getNumberOfComponents()-dimensional
2054 * space. The distance between tuples is computed using norm2. If several tuples are
2055 * not far each from other than \a prec, only one of them remains in the result
2056 * array. The order of tuples in the result array is same as in \a this one except
2057 * that coincident tuples are excluded.
2058 * \param [in] prec - minimal absolute distance between two tuples at which they are
2059 * considered not coincident.
2060 * \param [in] limitTupleId - limit tuple id. If all tuples within a group of coincident
2061 * tuples have id strictly lower than \a limitTupleId then they are not excluded.
2062 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
2063 * is to delete using decrRef() as it is no more needed.
2064 * \throw If \a this is not allocated.
2065 * \throw If the number of components is not in [1,2,3].
2067 * \ref py_mcdataarraydouble_getdifferentvalues "Here is a Python example".
2069 DataArrayDouble *DataArrayDouble::getDifferentValues(double prec, int limitTupleId) const throw(INTERP_KERNEL::Exception)
2072 DataArrayInt *c0=0,*cI0=0;
2073 findCommonTuples(prec,limitTupleId,c0,cI0);
2074 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> c(c0),cI(cI0);
2075 int newNbOfTuples=-1;
2076 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> o2n=DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(getNumberOfTuples(),c0->begin(),cI0->begin(),cI0->end(),newNbOfTuples);
2077 return renumberAndReduce(o2n->getConstPointer(),newNbOfTuples);
2081 * Copy all components in a specified order from another DataArrayDouble.
2082 * Both numerical and textual data is copied. The number of tuples in \a this and
2083 * the other array can be different.
2084 * \param [in] a - the array to copy data from.
2085 * \param [in] compoIds - sequence of zero based indices of components, data of which is
2087 * \throw If \a a is NULL.
2088 * \throw If \a compoIds.size() != \a a->getNumberOfComponents().
2089 * \throw If \a compoIds[i] < 0 or \a compoIds[i] > \a this->getNumberOfComponents().
2091 * \ref py_mcdataarraydouble_setselectedcomponents "Here is a Python example".
2093 void DataArrayDouble::setSelectedComponents(const DataArrayDouble *a, const std::vector<int>& compoIds) throw(INTERP_KERNEL::Exception)
2096 throw INTERP_KERNEL::Exception("DataArrayDouble::setSelectedComponents : input DataArrayDouble is NULL !");
2098 copyPartOfStringInfoFrom2(compoIds,*a);
2099 std::size_t partOfCompoSz=compoIds.size();
2100 int nbOfCompo=getNumberOfComponents();
2101 int nbOfTuples=std::min(getNumberOfTuples(),a->getNumberOfTuples());
2102 const double *ac=a->getConstPointer();
2103 double *nc=getPointer();
2104 for(int i=0;i<nbOfTuples;i++)
2105 for(std::size_t j=0;j<partOfCompoSz;j++,ac++)
2106 nc[nbOfCompo*i+compoIds[j]]=*ac;
2110 * Copy all values from another DataArrayDouble into specified tuples and components
2111 * of \a this array. Textual data is not copied.
2112 * The tree parameters defining set of indices of tuples and components are similar to
2113 * the tree parameters of the Python function \c range(\c start,\c stop,\c step).
2114 * \param [in] a - the array to copy values from.
2115 * \param [in] bgTuples - index of the first tuple of \a this array to assign values to.
2116 * \param [in] endTuples - index of the tuple before which the tuples to assign to
2118 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
2119 * \param [in] bgComp - index of the first component of \a this array to assign values to.
2120 * \param [in] endComp - index of the component before which the components to assign
2122 * \param [in] stepComp - index increment to get index of the next component to assign to.
2123 * \param [in] strictCompoCompare - if \a true (by default), then \a a->getNumberOfComponents()
2124 * must be equal to the number of columns to assign to, else an
2125 * exception is thrown; if \a false, then it is only required that \a
2126 * a->getNbOfElems() equals to number of values to assign to (this condition
2127 * must be respected even if \a strictCompoCompare is \a true). The number of
2128 * values to assign to is given by following Python expression:
2129 * \a nbTargetValues =
2130 * \c len(\c range(\a bgTuples,\a endTuples,\a stepTuples)) *
2131 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2132 * \throw If \a a is NULL.
2133 * \throw If \a a is not allocated.
2134 * \throw If \a this is not allocated.
2135 * \throw If parameters specifying tuples and components to assign to do not give a
2136 * non-empty range of increasing indices.
2137 * \throw If \a a->getNbOfElems() != \a nbTargetValues.
2138 * \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
2139 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2141 * \ref py_mcdataarraydouble_setpartofvalues1 "Here is a Python example".
2143 void DataArrayDouble::setPartOfValues1(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare) throw(INTERP_KERNEL::Exception)
2146 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues1 : input DataArrayDouble is NULL !");
2147 const char msg[]="DataArrayDouble::setPartOfValues1";
2149 a->checkAllocated();
2150 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2151 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2152 int nbComp=getNumberOfComponents();
2153 int nbOfTuples=getNumberOfTuples();
2154 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2155 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2156 bool assignTech=true;
2157 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2159 if(strictCompoCompare)
2160 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2164 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2167 const double *srcPt=a->getConstPointer();
2168 double *pt=getPointer()+bgTuples*nbComp+bgComp;
2171 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2172 for(int j=0;j<newNbOfComp;j++,srcPt++)
2173 pt[j*stepComp]=*srcPt;
2177 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2179 const double *srcPt2=srcPt;
2180 for(int j=0;j<newNbOfComp;j++,srcPt2++)
2181 pt[j*stepComp]=*srcPt2;
2187 * Assign a given value to values at specified tuples and components of \a this array.
2188 * The tree parameters defining set of indices of tuples and components are similar to
2189 * the tree parameters of the Python function \c range(\c start,\c stop,\c step)..
2190 * \param [in] a - the value to assign.
2191 * \param [in] bgTuples - index of the first tuple of \a this array to assign to.
2192 * \param [in] endTuples - index of the tuple before which the tuples to assign to
2194 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
2195 * \param [in] bgComp - index of the first component of \a this array to assign to.
2196 * \param [in] endComp - index of the component before which the components to assign
2198 * \param [in] stepComp - index increment to get index of the next component to assign to.
2199 * \throw If \a this is not allocated.
2200 * \throw If parameters specifying tuples and components to assign to, do not give a
2201 * non-empty range of increasing indices or indices are out of a valid range
2204 * \ref py_mcdataarraydouble_setpartofvaluessimple1 "Here is a Python example".
2206 void DataArrayDouble::setPartOfValuesSimple1(double a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp) throw(INTERP_KERNEL::Exception)
2208 const char msg[]="DataArrayDouble::setPartOfValuesSimple1";
2210 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2211 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2212 int nbComp=getNumberOfComponents();
2213 int nbOfTuples=getNumberOfTuples();
2214 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2215 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2216 double *pt=getPointer()+bgTuples*nbComp+bgComp;
2217 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2218 for(int j=0;j<newNbOfComp;j++)
2223 * Copy all values from another DataArrayDouble (\a a) into specified tuples and
2224 * components of \a this array. Textual data is not copied.
2225 * The tuples and components to assign to are defined by C arrays of indices.
2226 * There are two *modes of usage*:
2227 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
2228 * of \a a is assigned to its own location within \a this array.
2229 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
2230 * components of every specified tuple of \a this array. In this mode it is required
2231 * that \a a->getNumberOfComponents() equals to the number of specified components.
2233 * \param [in] a - the array to copy values from.
2234 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2235 * assign values of \a a to.
2236 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2237 * pointer to a tuple index <em>(pi)</em> varies as this:
2238 * \a bgTuples <= \a pi < \a endTuples.
2239 * \param [in] bgComp - pointer to an array of component indices of \a this array to
2240 * assign values of \a a to.
2241 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
2242 * pointer to a component index <em>(pi)</em> varies as this:
2243 * \a bgComp <= \a pi < \a endComp.
2244 * \param [in] strictCompoCompare - this parameter is checked only if the
2245 * *mode of usage* is the first; if it is \a true (default),
2246 * then \a a->getNumberOfComponents() must be equal
2247 * to the number of specified columns, else this is not required.
2248 * \throw If \a a is NULL.
2249 * \throw If \a a is not allocated.
2250 * \throw If \a this is not allocated.
2251 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
2252 * out of a valid range for \a this array.
2253 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
2254 * if <em> a->getNumberOfComponents() != (endComp - bgComp) </em>.
2255 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
2256 * <em> a->getNumberOfComponents() != (endComp - bgComp)</em>.
2258 * \ref py_mcdataarraydouble_setpartofvalues2 "Here is a Python example".
2260 void DataArrayDouble::setPartOfValues2(const DataArrayDouble *a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp, bool strictCompoCompare) throw(INTERP_KERNEL::Exception)
2263 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues2 : input DataArrayDouble is NULL !");
2264 const char msg[]="DataArrayDouble::setPartOfValues2";
2266 a->checkAllocated();
2267 int nbComp=getNumberOfComponents();
2268 int nbOfTuples=getNumberOfTuples();
2269 for(const int *z=bgComp;z!=endComp;z++)
2270 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2271 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
2272 int newNbOfComp=(int)std::distance(bgComp,endComp);
2273 bool assignTech=true;
2274 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2276 if(strictCompoCompare)
2277 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2281 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2284 double *pt=getPointer();
2285 const double *srcPt=a->getConstPointer();
2288 for(const int *w=bgTuples;w!=endTuples;w++)
2290 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2291 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
2293 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt;
2299 for(const int *w=bgTuples;w!=endTuples;w++)
2301 const double *srcPt2=srcPt;
2302 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2303 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
2305 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt2;
2312 * Assign a given value to values at specified tuples and components of \a this array.
2313 * The tuples and components to assign to are defined by C arrays of indices.
2314 * \param [in] a - the value to assign.
2315 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2317 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2318 * pointer to a tuple index (\a pi) varies as this:
2319 * \a bgTuples <= \a pi < \a endTuples.
2320 * \param [in] bgComp - pointer to an array of component indices of \a this array to
2322 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
2323 * pointer to a component index (\a pi) varies as this:
2324 * \a bgComp <= \a pi < \a endComp.
2325 * \throw If \a this is not allocated.
2326 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
2327 * out of a valid range for \a this array.
2329 * \ref py_mcdataarraydouble_setpartofvaluessimple2 "Here is a Python example".
2331 void DataArrayDouble::setPartOfValuesSimple2(double a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp) throw(INTERP_KERNEL::Exception)
2334 int nbComp=getNumberOfComponents();
2335 int nbOfTuples=getNumberOfTuples();
2336 for(const int *z=bgComp;z!=endComp;z++)
2337 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2338 double *pt=getPointer();
2339 for(const int *w=bgTuples;w!=endTuples;w++)
2340 for(const int *z=bgComp;z!=endComp;z++)
2342 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2343 pt[(std::size_t)(*w)*nbComp+(*z)]=a;
2348 * Copy all values from another DataArrayDouble (\a a) into specified tuples and
2349 * components of \a this array. Textual data is not copied.
2350 * The tuples to assign to are defined by a C array of indices.
2351 * The components to assign to are defined by three values similar to parameters of
2352 * the Python function \c range(\c start,\c stop,\c step).
2353 * There are two *modes of usage*:
2354 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
2355 * of \a a is assigned to its own location within \a this array.
2356 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
2357 * components of every specified tuple of \a this array. In this mode it is required
2358 * that \a a->getNumberOfComponents() equals to the number of specified components.
2360 * \param [in] a - the array to copy values from.
2361 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2362 * assign values of \a a to.
2363 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2364 * pointer to a tuple index <em>(pi)</em> varies as this:
2365 * \a bgTuples <= \a pi < \a endTuples.
2366 * \param [in] bgComp - index of the first component of \a this array to assign to.
2367 * \param [in] endComp - index of the component before which the components to assign
2369 * \param [in] stepComp - index increment to get index of the next component to assign to.
2370 * \param [in] strictCompoCompare - this parameter is checked only in the first
2371 * *mode of usage*; if \a strictCompoCompare is \a true (default),
2372 * then \a a->getNumberOfComponents() must be equal
2373 * to the number of specified columns, else this is not required.
2374 * \throw If \a a is NULL.
2375 * \throw If \a a is not allocated.
2376 * \throw If \a this is not allocated.
2377 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
2379 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
2380 * if <em> a->getNumberOfComponents()</em> is unequal to the number of components
2381 * defined by <em>(bgComp,endComp,stepComp)</em>.
2382 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
2383 * <em> a->getNumberOfComponents()</em> is unequal to the number of components
2384 * defined by <em>(bgComp,endComp,stepComp)</em>.
2385 * \throw If parameters specifying components to assign to, do not give a
2386 * non-empty range of increasing indices or indices are out of a valid range
2389 * \ref py_mcdataarraydouble_setpartofvalues3 "Here is a Python example".
2391 void DataArrayDouble::setPartOfValues3(const DataArrayDouble *a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare) throw(INTERP_KERNEL::Exception)
2394 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues3 : input DataArrayDouble is NULL !");
2395 const char msg[]="DataArrayDouble::setPartOfValues3";
2397 a->checkAllocated();
2398 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2399 int nbComp=getNumberOfComponents();
2400 int nbOfTuples=getNumberOfTuples();
2401 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2402 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
2403 bool assignTech=true;
2404 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2406 if(strictCompoCompare)
2407 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2411 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2414 double *pt=getPointer()+bgComp;
2415 const double *srcPt=a->getConstPointer();
2418 for(const int *w=bgTuples;w!=endTuples;w++)
2419 for(int j=0;j<newNbOfComp;j++,srcPt++)
2421 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2422 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt;
2427 for(const int *w=bgTuples;w!=endTuples;w++)
2429 const double *srcPt2=srcPt;
2430 for(int j=0;j<newNbOfComp;j++,srcPt2++)
2432 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2433 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt2;
2440 * Assign a given value to values at specified tuples and components of \a this array.
2441 * The tuples to assign to are defined by a C array of indices.
2442 * The components to assign to are defined by three values similar to parameters of
2443 * the Python function \c range(\c start,\c stop,\c step).
2444 * \param [in] a - the value to assign.
2445 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2447 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2448 * pointer to a tuple index <em>(pi)</em> varies as this:
2449 * \a bgTuples <= \a pi < \a endTuples.
2450 * \param [in] bgComp - index of the first component of \a this array to assign to.
2451 * \param [in] endComp - index of the component before which the components to assign
2453 * \param [in] stepComp - index increment to get index of the next component to assign to.
2454 * \throw If \a this is not allocated.
2455 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
2457 * \throw If parameters specifying components to assign to, do not give a
2458 * non-empty range of increasing indices or indices are out of a valid range
2461 * \ref py_mcdataarraydouble_setpartofvaluessimple3 "Here is a Python example".
2463 void DataArrayDouble::setPartOfValuesSimple3(double a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp) throw(INTERP_KERNEL::Exception)
2465 const char msg[]="DataArrayDouble::setPartOfValuesSimple3";
2467 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2468 int nbComp=getNumberOfComponents();
2469 int nbOfTuples=getNumberOfTuples();
2470 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2471 double *pt=getPointer()+bgComp;
2472 for(const int *w=bgTuples;w!=endTuples;w++)
2473 for(int j=0;j<newNbOfComp;j++)
2475 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2476 pt[(std::size_t)(*w)*nbComp+j*stepComp]=a;
2481 * Copy all values from another DataArrayDouble into specified tuples and components
2482 * of \a this array. Textual data is not copied.
2483 * The tree parameters defining set of indices of tuples and components are similar to
2484 * the tree parameters of the Python function \c range(\c start,\c stop,\c step).
2485 * \param [in] a - the array to copy values from.
2486 * \param [in] bgTuples - index of the first tuple of \a this array to assign values to.
2487 * \param [in] endTuples - index of the tuple before which the tuples to assign to
2489 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
2490 * \param [in] bgComp - pointer to an array of component indices of \a this array to
2492 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
2493 * pointer to a component index (\a pi) varies as this:
2494 * \a bgComp <= \a pi < \a endComp.
2495 * \param [in] strictCompoCompare - if \a true (by default), then \a a->getNumberOfComponents()
2496 * must be equal to the number of columns to assign to, else an
2497 * exception is thrown; if \a false, then it is only required that \a
2498 * a->getNbOfElems() equals to number of values to assign to (this condition
2499 * must be respected even if \a strictCompoCompare is \a true). The number of
2500 * values to assign to is given by following Python expression:
2501 * \a nbTargetValues =
2502 * \c len(\c range(\a bgTuples,\a endTuples,\a stepTuples)) *
2503 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2504 * \throw If \a a is NULL.
2505 * \throw If \a a is not allocated.
2506 * \throw If \a this is not allocated.
2507 * \throw If parameters specifying tuples and components to assign to do not give a
2508 * non-empty range of increasing indices.
2509 * \throw If \a a->getNbOfElems() != \a nbTargetValues.
2510 * \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
2511 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2514 void DataArrayDouble::setPartOfValues4(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp, bool strictCompoCompare) throw(INTERP_KERNEL::Exception)
2517 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues4 : input DataArrayDouble is NULL !");
2518 const char msg[]="DataArrayDouble::setPartOfValues4";
2520 a->checkAllocated();
2521 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2522 int newNbOfComp=(int)std::distance(bgComp,endComp);
2523 int nbComp=getNumberOfComponents();
2524 for(const int *z=bgComp;z!=endComp;z++)
2525 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2526 int nbOfTuples=getNumberOfTuples();
2527 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2528 bool assignTech=true;
2529 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2531 if(strictCompoCompare)
2532 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2536 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2539 const double *srcPt=a->getConstPointer();
2540 double *pt=getPointer()+bgTuples*nbComp;
2543 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2544 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
2549 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2551 const double *srcPt2=srcPt;
2552 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
2558 void DataArrayDouble::setPartOfValuesSimple4(double a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp) throw(INTERP_KERNEL::Exception)
2560 const char msg[]="DataArrayDouble::setPartOfValuesSimple4";
2562 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2563 int nbComp=getNumberOfComponents();
2564 for(const int *z=bgComp;z!=endComp;z++)
2565 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2566 int nbOfTuples=getNumberOfTuples();
2567 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2568 double *pt=getPointer()+bgTuples*nbComp;
2569 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2570 for(const int *z=bgComp;z!=endComp;z++)
2575 * Copy some tuples from another DataArrayDouble into specified tuples
2576 * of \a this array. Textual data is not copied. Both arrays must have equal number of
2578 * Both the tuples to assign and the tuples to assign to are defined by a DataArrayInt.
2579 * All components of selected tuples are copied.
2580 * \param [in] a - the array to copy values from.
2581 * \param [in] tuplesSelec - the array specifying both source tuples of \a a and
2582 * target tuples of \a this. \a tuplesSelec has two components, and the
2583 * first component specifies index of the source tuple and the second
2584 * one specifies index of the target tuple.
2585 * \throw If \a this is not allocated.
2586 * \throw If \a a is NULL.
2587 * \throw If \a a is not allocated.
2588 * \throw If \a tuplesSelec is NULL.
2589 * \throw If \a tuplesSelec is not allocated.
2590 * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
2591 * \throw If \a tuplesSelec->getNumberOfComponents() != 2.
2592 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
2593 * the corresponding (\a this or \a a) array.
2595 void DataArrayDouble::setPartOfValuesAdv(const DataArrayDouble *a, const DataArrayInt *tuplesSelec) throw(INTERP_KERNEL::Exception)
2597 if(!a || !tuplesSelec)
2598 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValuesAdv : input DataArrayDouble is NULL !");
2600 a->checkAllocated();
2601 tuplesSelec->checkAllocated();
2602 int nbOfComp=getNumberOfComponents();
2603 if(nbOfComp!=a->getNumberOfComponents())
2604 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValuesAdv : This and a do not have the same number of components !");
2605 if(tuplesSelec->getNumberOfComponents()!=2)
2606 throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValuesAdv : Expecting to have a tuple selector DataArrayInt instance with exactly 2 components !");
2607 int thisNt=getNumberOfTuples();
2608 int aNt=a->getNumberOfTuples();
2609 double *valsToSet=getPointer();
2610 const double *valsSrc=a->getConstPointer();
2611 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple+=2)
2613 if(tuple[1]>=0 && tuple[1]<aNt)
2615 if(tuple[0]>=0 && tuple[0]<thisNt)
2616 std::copy(valsSrc+nbOfComp*tuple[1],valsSrc+nbOfComp*(tuple[1]+1),valsToSet+nbOfComp*tuple[0]);
2619 std::ostringstream oss; oss << "DataArrayDouble::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
2620 oss << " of 'tuplesSelec' request of tuple id #" << tuple[0] << " in 'this' ! It should be in [0," << thisNt << ") !";
2621 throw INTERP_KERNEL::Exception(oss.str().c_str());
2626 std::ostringstream oss; oss << "DataArrayDouble::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
2627 oss << " of 'tuplesSelec' request of tuple id #" << tuple[1] << " in 'a' ! It should be in [0," << aNt << ") !";
2628 throw INTERP_KERNEL::Exception(oss.str().c_str());
2634 * Copy some tuples from another DataArrayDouble (\a a) into contiguous tuples
2635 * of \a this array. Textual data is not copied. Both arrays must have equal number of
2637 * The tuples to assign to are defined by index of the first tuple, and
2638 * their number is defined by \a tuplesSelec->getNumberOfTuples().
2639 * The tuples to copy are defined by values of a DataArrayInt.
2640 * All components of selected tuples are copied.
2641 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
2643 * \param [in] a - the array to copy values from.
2644 * \param [in] tuplesSelec - the array specifying tuples of \a a to copy.
2645 * \throw If \a this is not allocated.
2646 * \throw If \a a is NULL.
2647 * \throw If \a a is not allocated.
2648 * \throw If \a tuplesSelec is NULL.
2649 * \throw If \a tuplesSelec is not allocated.
2650 * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
2651 * \throw If \a tuplesSelec->getNumberOfComponents() != 1.
2652 * \throw If <em>tupleIdStart + tuplesSelec->getNumberOfTuples() > this->getNumberOfTuples().</em>
2653 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
2656 void DataArrayDouble::setContigPartOfSelectedValues(int tupleIdStart, const DataArray *aBase, const DataArrayInt *tuplesSelec) throw(INTERP_KERNEL::Exception)
2658 if(!aBase || !tuplesSelec)
2659 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : input DataArray is NULL !");
2660 const DataArrayDouble *a=dynamic_cast<const DataArrayDouble *>(aBase);
2662 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : input DataArray aBase is not a DataArrayDouble !");
2664 a->checkAllocated();
2665 tuplesSelec->checkAllocated();
2666 int nbOfComp=getNumberOfComponents();
2667 if(nbOfComp!=a->getNumberOfComponents())
2668 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : This and a do not have the same number of components !");
2669 if(tuplesSelec->getNumberOfComponents()!=1)
2670 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : Expecting to have a tuple selector DataArrayInt instance with exactly 1 component !");
2671 int thisNt=getNumberOfTuples();
2672 int aNt=a->getNumberOfTuples();
2673 int nbOfTupleToWrite=tuplesSelec->getNumberOfTuples();
2674 double *valsToSet=getPointer()+tupleIdStart*nbOfComp;
2675 if(tupleIdStart+nbOfTupleToWrite>thisNt)
2676 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : invalid number range of values to write !");
2677 const double *valsSrc=a->getConstPointer();
2678 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple++,valsToSet+=nbOfComp)
2680 if(*tuple>=0 && *tuple<aNt)
2682 std::copy(valsSrc+nbOfComp*(*tuple),valsSrc+nbOfComp*(*tuple+1),valsToSet);
2686 std::ostringstream oss; oss << "DataArrayDouble::setContigPartOfSelectedValues : Tuple #" << std::distance(tuplesSelec->begin(),tuple);
2687 oss << " of 'tuplesSelec' request of tuple id #" << *tuple << " in 'a' ! It should be in [0," << aNt << ") !";
2688 throw INTERP_KERNEL::Exception(oss.str().c_str());
2694 * Copy some tuples from another DataArrayDouble (\a a) into contiguous tuples
2695 * of \a this array. Textual data is not copied. Both arrays must have equal number of
2697 * The tuples to copy are defined by three values similar to parameters of
2698 * the Python function \c range(\c start,\c stop,\c step).
2699 * The tuples to assign to are defined by index of the first tuple, and
2700 * their number is defined by number of tuples to copy.
2701 * All components of selected tuples are copied.
2702 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
2704 * \param [in] a - the array to copy values from.
2705 * \param [in] bg - index of the first tuple to copy of the array \a a.
2706 * \param [in] end2 - index of the tuple of \a a before which the tuples to copy
2708 * \param [in] step - index increment to get index of the next tuple to copy.
2709 * \throw If \a this is not allocated.
2710 * \throw If \a a is NULL.
2711 * \throw If \a a is not allocated.
2712 * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
2713 * \throw If <em>tupleIdStart + len(range(bg,end2,step)) > this->getNumberOfTuples().</em>
2714 * \throw If parameters specifying tuples to copy, do not give a
2715 * non-empty range of increasing indices or indices are out of a valid range
2716 * for the array \a a.
2718 void DataArrayDouble::setContigPartOfSelectedValues2(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step) throw(INTERP_KERNEL::Exception)
2721 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : input DataArray is NULL !");
2722 const DataArrayDouble *a=dynamic_cast<const DataArrayDouble *>(aBase);
2724 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : input DataArray aBase is not a DataArrayDouble !");
2726 a->checkAllocated();
2727 int nbOfComp=getNumberOfComponents();
2728 const char msg[]="DataArrayDouble::setContigPartOfSelectedValues2";
2729 int nbOfTupleToWrite=DataArray::GetNumberOfItemGivenBES(bg,end2,step,msg);
2730 if(nbOfComp!=a->getNumberOfComponents())
2731 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : This and a do not have the same number of components !");
2732 int thisNt=getNumberOfTuples();
2733 int aNt=a->getNumberOfTuples();
2734 double *valsToSet=getPointer()+tupleIdStart*nbOfComp;
2735 if(tupleIdStart+nbOfTupleToWrite>thisNt)
2736 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : invalid number range of values to write !");
2738 throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : invalid range of values to read !");
2739 const double *valsSrc=a->getConstPointer()+bg*nbOfComp;
2740 for(int i=0;i<nbOfTupleToWrite;i++,valsToSet+=nbOfComp,valsSrc+=step*nbOfComp)
2742 std::copy(valsSrc,valsSrc+nbOfComp,valsToSet);
2747 * Returns a value located at specified tuple and component.
2748 * This method is equivalent to DataArrayDouble::getIJ() except that validity of
2749 * parameters is checked. So this method is safe but expensive if used to go through
2750 * all values of \a this.
2751 * \param [in] tupleId - index of tuple of interest.
2752 * \param [in] compoId - index of component of interest.
2753 * \return double - value located by \a tupleId and \a compoId.
2754 * \throw If \a this is not allocated.
2755 * \throw If condition <em>( 0 <= tupleId < this->getNumberOfTuples() )</em> is violated.
2756 * \throw If condition <em>( 0 <= compoId < this->getNumberOfComponents() )</em> is violated.
2758 double DataArrayDouble::getIJSafe(int tupleId, int compoId) const throw(INTERP_KERNEL::Exception)
2761 if(tupleId<0 || tupleId>=getNumberOfTuples())
2763 std::ostringstream oss; oss << "DataArrayDouble::getIJSafe : request for tupleId " << tupleId << " should be in [0," << getNumberOfTuples() << ") !";
2764 throw INTERP_KERNEL::Exception(oss.str().c_str());
2766 if(compoId<0 || compoId>=getNumberOfComponents())
2768 std::ostringstream oss; oss << "DataArrayDouble::getIJSafe : request for compoId " << compoId << " should be in [0," << getNumberOfComponents() << ") !";
2769 throw INTERP_KERNEL::Exception(oss.str().c_str());
2771 return _mem[tupleId*_info_on_compo.size()+compoId];
2775 * Returns the first value of \a this.
2776 * \return double - the last value of \a this array.
2777 * \throw If \a this is not allocated.
2778 * \throw If \a this->getNumberOfComponents() != 1.
2779 * \throw If \a this->getNumberOfTuples() < 1.
2781 double DataArrayDouble::front() const throw(INTERP_KERNEL::Exception)
2784 if(getNumberOfComponents()!=1)
2785 throw INTERP_KERNEL::Exception("DataArrayDouble::front : number of components not equal to one !");
2786 int nbOfTuples=getNumberOfTuples();
2788 throw INTERP_KERNEL::Exception("DataArrayDouble::front : number of tuples must be >= 1 !");
2789 return *(getConstPointer());
2793 * Returns the last value of \a this.
2794 * \return double - the last value of \a this array.
2795 * \throw If \a this is not allocated.
2796 * \throw If \a this->getNumberOfComponents() != 1.
2797 * \throw If \a this->getNumberOfTuples() < 1.
2799 double DataArrayDouble::back() const throw(INTERP_KERNEL::Exception)
2802 if(getNumberOfComponents()!=1)
2803 throw INTERP_KERNEL::Exception("DataArrayDouble::back : number of components not equal to one !");
2804 int nbOfTuples=getNumberOfTuples();
2806 throw INTERP_KERNEL::Exception("DataArrayDouble::back : number of tuples must be >= 1 !");
2807 return *(getConstPointer()+nbOfTuples-1);
2810 void DataArrayDouble::SetArrayIn(DataArrayDouble *newArray, DataArrayDouble* &arrayToSet)
2812 if(newArray!=arrayToSet)
2815 arrayToSet->decrRef();
2816 arrayToSet=newArray;
2818 arrayToSet->incrRef();
2823 * Sets a C array to be used as raw data of \a this. The previously set info
2824 * of components is retained and re-sized.
2825 * For more info see \ref MEDCouplingArraySteps1.
2826 * \param [in] array - the C array to be used as raw data of \a this.
2827 * \param [in] ownership - if \a true, \a array will be deallocated at destruction of \a this.
2828 * \param [in] type - specifies how to deallocate \a array. If \a type == ParaMEDMEM::CPP_DEALLOC,
2829 * \c delete [] \c array; will be called. If \a type == ParaMEDMEM::C_DEALLOC,
2830 * \c free(\c array ) will be called.
2831 * \param [in] nbOfTuple - new number of tuples in \a this.
2832 * \param [in] nbOfCompo - new number of components in \a this.
2834 void DataArrayDouble::useArray(const double *array, bool ownership, DeallocType type, int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception)
2836 _info_on_compo.resize(nbOfCompo);
2837 _mem.useArray(array,ownership,type,(std::size_t)nbOfTuple*nbOfCompo);
2841 void DataArrayDouble::useExternalArrayWithRWAccess(const double *array, int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception)
2843 _info_on_compo.resize(nbOfCompo);
2844 _mem.useExternalArrayWithRWAccess(array,(std::size_t)nbOfTuple*nbOfCompo);
2849 * Checks if 0.0 value is present in \a this array. If it is the case, an exception
2851 * \throw If zero is found in \a this array.
2853 void DataArrayDouble::checkNoNullValues() const throw(INTERP_KERNEL::Exception)
2855 const double *tmp=getConstPointer();
2856 std::size_t nbOfElems=getNbOfElems();
2857 const double *where=std::find(tmp,tmp+nbOfElems,0.);
2858 if(where!=tmp+nbOfElems)
2859 throw INTERP_KERNEL::Exception("A value 0.0 have been detected !");
2863 * Computes minimal and maximal value in each component. An output array is filled
2864 * with \c 2 * \a this->getNumberOfComponents() values, so the caller is to allocate
2865 * enough memory before calling this method.
2866 * \param [out] bounds - array of size at least 2 *\a this->getNumberOfComponents().
2867 * It is filled as follows:<br>
2868 * \a bounds[0] = \c min_of_component_0 <br>
2869 * \a bounds[1] = \c max_of_component_0 <br>
2870 * \a bounds[2] = \c min_of_component_1 <br>
2871 * \a bounds[3] = \c max_of_component_1 <br>
2874 void DataArrayDouble::getMinMaxPerComponent(double *bounds) const throw(INTERP_KERNEL::Exception)
2877 int dim=getNumberOfComponents();
2878 for (int idim=0; idim<dim; idim++)
2880 bounds[idim*2]=std::numeric_limits<double>::max();
2881 bounds[idim*2+1]=-std::numeric_limits<double>::max();
2883 const double *ptr=getConstPointer();
2884 int nbOfTuples=getNumberOfTuples();
2885 for(int i=0;i<nbOfTuples;i++)
2887 for(int idim=0;idim<dim;idim++)
2889 if(bounds[idim*2]>ptr[i*dim+idim])
2891 bounds[idim*2]=ptr[i*dim+idim];
2893 if(bounds[idim*2+1]<ptr[i*dim+idim])
2895 bounds[idim*2+1]=ptr[i*dim+idim];
2902 * This method retrieves a newly allocated DataArrayDouble instance having same number of tuples than \a this and twice number of components than \a this
2903 * to store both the min and max per component of each tuples.
2904 * \param [in] epsilon the width of the bbox (identical in each direction) - 0.0 by default
2906 * \return a newly created DataArrayDouble instance having \c this->getNumberOfTuples() tuples and 2 * \c this->getNumberOfComponent() components
2908 * \throw If \a this is not allocated yet.
2910 DataArrayDouble *DataArrayDouble::computeBBoxPerTuple(double epsilon)const throw(INTERP_KERNEL::Exception)
2913 const double *dataPtr=getConstPointer();
2914 int nbOfCompo=getNumberOfComponents();
2915 int nbTuples=getNumberOfTuples();
2916 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> bbox=DataArrayDouble::New();
2917 bbox->alloc(nbTuples,2*nbOfCompo);
2918 double *bboxPtr=bbox->getPointer();
2919 for(int i=0;i<nbTuples;i++)
2921 for(int j=0;j<nbOfCompo;j++)
2923 bboxPtr[2*nbOfCompo*i+2*j]=dataPtr[nbOfCompo*i+j]-epsilon;
2924 bboxPtr[2*nbOfCompo*i+2*j+1]=dataPtr[nbOfCompo*i+j]+epsilon;
2931 * For each tuples **t** in \a other, this method retrieves tuples in \a this that are equal to **t**.
2932 * Two tuples are considered equal if the euclidian distance between the two tuples is lower than \a eps.
2934 * \param [in] other a DataArrayDouble having same number of components than \a this.
2935 * \param [in] eps absolute precision representing distance (using infinite norm) between 2 tuples behind which 2 tuples are considered equal.
2936 * \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.
2937 * \a cI allows to extract information in \a c.
2938 * \param [out] cI is an indirection array that allows to extract the data contained in \a c.
2940 * \throw In case of:
2941 * - \a this is not allocated
2942 * - \a other is not allocated or null
2943 * - \a this and \a other do not have the same number of components
2944 * - if number of components of \a this is not in [1,2,3]
2946 * \sa MEDCouplingPointSet::getNodeIdsNearPoints, DataArrayDouble::getDifferentValues
2948 void DataArrayDouble::computeTupleIdsNearTuples(const DataArrayDouble *other, double eps, DataArrayInt *& c, DataArrayInt *& cI) const throw(INTERP_KERNEL::Exception)
2951 throw INTERP_KERNEL::Exception("DataArrayDouble::computeTupleIdsNearTuples : input pointer other is null !");
2953 other->checkAllocated();
2954 int nbOfCompo=getNumberOfComponents();
2955 int otherNbOfCompo=other->getNumberOfComponents();
2956 if(nbOfCompo!=otherNbOfCompo)
2957 throw INTERP_KERNEL::Exception("DataArrayDouble::computeTupleIdsNearTuples : number of components should be equal between this and other !");
2958 int nbOfTuplesOther=other->getNumberOfTuples();
2959 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cArr(DataArrayInt::New()),cIArr(DataArrayInt::New()); cArr->alloc(0,1); cIArr->pushBackSilent(0);
2964 BBTreePts<3,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
2965 FindTupleIdsNearTuplesAlg<3>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
2970 BBTreePts<2,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
2971 FindTupleIdsNearTuplesAlg<2>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
2976 BBTreePts<1,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
2977 FindTupleIdsNearTuplesAlg<1>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
2981 throw INTERP_KERNEL::Exception("Unexpected spacedim of coords for computeTupleIdsNearTuples. Must be 1, 2 or 3.");
2983 c=cArr.retn(); cI=cIArr.retn();
2987 * 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
2988 * around origin of 'radius' 1.
2990 * \param [in] eps absolute epsilon. under that value of delta between max and min no scale is performed.
2992 void DataArrayDouble::recenterForMaxPrecision(double eps) throw(INTERP_KERNEL::Exception)
2995 int dim=getNumberOfComponents();
2996 std::vector<double> bounds(2*dim);
2997 getMinMaxPerComponent(&bounds[0]);
2998 for(int i=0;i<dim;i++)
3000 double delta=bounds[2*i+1]-bounds[2*i];
3001 double offset=(bounds[2*i]+bounds[2*i+1])/2.;
3003 applyLin(1./delta,-offset/delta,i);
3005 applyLin(1.,-offset,i);
3010 * Returns the maximal value and its location within \a this one-dimensional array.
3011 * \param [out] tupleId - index of the tuple holding the maximal value.
3012 * \return double - the maximal value among all values of \a this array.
3013 * \throw If \a this->getNumberOfComponents() != 1
3014 * \throw If \a this->getNumberOfTuples() < 1
3016 double DataArrayDouble::getMaxValue(int& tupleId) const throw(INTERP_KERNEL::Exception)
3019 if(getNumberOfComponents()!=1)
3020 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 !");
3021 int nbOfTuples=getNumberOfTuples();
3023 throw INTERP_KERNEL::Exception("DataArrayDouble::getMaxValue : array exists but number of tuples must be > 0 !");
3024 const double *vals=getConstPointer();
3025 const double *loc=std::max_element(vals,vals+nbOfTuples);
3026 tupleId=(int)std::distance(vals,loc);
3031 * Returns the maximal value within \a this array that is allowed to have more than
3033 * \return double - the maximal value among all values of \a this array.
3034 * \throw If \a this is not allocated.
3036 double DataArrayDouble::getMaxValueInArray() const throw(INTERP_KERNEL::Exception)
3039 const double *loc=std::max_element(begin(),end());
3044 * Returns the maximal value and all its locations within \a this one-dimensional array.
3045 * \param [out] tupleIds - a new instance of DataArrayInt containg indices of
3046 * tuples holding the maximal value. The caller is to delete it using
3047 * decrRef() as it is no more needed.
3048 * \return double - the maximal value among all values of \a this array.
3049 * \throw If \a this->getNumberOfComponents() != 1
3050 * \throw If \a this->getNumberOfTuples() < 1
3052 double DataArrayDouble::getMaxValue2(DataArrayInt*& tupleIds) const throw(INTERP_KERNEL::Exception)
3056 double ret=getMaxValue(tmp);
3057 tupleIds=getIdsInRange(ret,ret);
3062 * Returns the minimal value and its location within \a this one-dimensional array.
3063 * \param [out] tupleId - index of the tuple holding the minimal value.
3064 * \return double - the minimal value among all values of \a this array.
3065 * \throw If \a this->getNumberOfComponents() != 1
3066 * \throw If \a this->getNumberOfTuples() < 1
3068 double DataArrayDouble::getMinValue(int& tupleId) const throw(INTERP_KERNEL::Exception)
3071 if(getNumberOfComponents()!=1)
3072 throw INTERP_KERNEL::Exception("DataArrayDouble::getMinValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before call 'getMinValueInArray' method !");
3073 int nbOfTuples=getNumberOfTuples();
3075 throw INTERP_KERNEL::Exception("DataArrayDouble::getMinValue : array exists but number of tuples must be > 0 !");
3076 const double *vals=getConstPointer();
3077 const double *loc=std::min_element(vals,vals+nbOfTuples);
3078 tupleId=(int)std::distance(vals,loc);
3083 * Returns the minimal value within \a this array that is allowed to have more than
3085 * \return double - the minimal value among all values of \a this array.
3086 * \throw If \a this is not allocated.
3088 double DataArrayDouble::getMinValueInArray() const throw(INTERP_KERNEL::Exception)
3091 const double *loc=std::min_element(begin(),end());
3096 * Returns the minimal value and all its locations within \a this one-dimensional array.
3097 * \param [out] tupleIds - a new instance of DataArrayInt containg indices of
3098 * tuples holding the minimal value. The caller is to delete it using
3099 * decrRef() as it is no more needed.
3100 * \return double - the minimal value among all values of \a this array.
3101 * \throw If \a this->getNumberOfComponents() != 1
3102 * \throw If \a this->getNumberOfTuples() < 1
3104 double DataArrayDouble::getMinValue2(DataArrayInt*& tupleIds) const throw(INTERP_KERNEL::Exception)
3108 double ret=getMinValue(tmp);
3109 tupleIds=getIdsInRange(ret,ret);
3114 * 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.
3115 * This method only works for single component array.
3117 * \return a value in [ 0, \c this->getNumberOfTuples() )
3119 * \throw If \a this is not allocated
3122 int DataArrayDouble::count(double value, double eps) const throw(INTERP_KERNEL::Exception)
3126 if(getNumberOfComponents()!=1)
3127 throw INTERP_KERNEL::Exception("DataArrayDouble::count : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
3128 const double *vals=begin();
3129 int nbOfTuples=getNumberOfTuples();
3130 for(int i=0;i<nbOfTuples;i++,vals++)
3131 if(fabs(*vals-value)<=eps)
3137 * Returns the average value of \a this one-dimensional array.
3138 * \return double - the average value over all values of \a this array.
3139 * \throw If \a this->getNumberOfComponents() != 1
3140 * \throw If \a this->getNumberOfTuples() < 1
3142 double DataArrayDouble::getAverageValue() const throw(INTERP_KERNEL::Exception)
3144 if(getNumberOfComponents()!=1)
3145 throw INTERP_KERNEL::Exception("DataArrayDouble::getAverageValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
3146 int nbOfTuples=getNumberOfTuples();
3148 throw INTERP_KERNEL::Exception("DataArrayDouble::getAverageValue : array exists but number of tuples must be > 0 !");
3149 const double *vals=getConstPointer();
3150 double ret=std::accumulate(vals,vals+nbOfTuples,0.);
3151 return ret/nbOfTuples;
3155 * Returns the Euclidean norm of the vector defined by \a this array.
3156 * \return double - the value of the Euclidean norm, i.e.
3157 * the square root of the inner product of vector.
3158 * \throw If \a this is not allocated.
3160 double DataArrayDouble::norm2() const throw(INTERP_KERNEL::Exception)
3164 std::size_t nbOfElems=getNbOfElems();
3165 const double *pt=getConstPointer();
3166 for(std::size_t i=0;i<nbOfElems;i++,pt++)
3172 * Returns the maximum norm of the vector defined by \a this array.
3173 * \return double - the value of the maximum norm, i.e.
3174 * the maximal absolute value among values of \a this array.
3175 * \throw If \a this is not allocated.
3177 double DataArrayDouble::normMax() const throw(INTERP_KERNEL::Exception)
3181 std::size_t nbOfElems=getNbOfElems();
3182 const double *pt=getConstPointer();
3183 for(std::size_t i=0;i<nbOfElems;i++,pt++)
3185 double val=std::abs(*pt);
3193 * Accumulates values of each component of \a this array.
3194 * \param [out] res - an array of length \a this->getNumberOfComponents(), allocated
3195 * by the caller, that is filled by this method with sum value for each
3197 * \throw If \a this is not allocated.
3199 void DataArrayDouble::accumulate(double *res) const throw(INTERP_KERNEL::Exception)
3202 const double *ptr=getConstPointer();
3203 int nbTuple=getNumberOfTuples();
3204 int nbComps=getNumberOfComponents();
3205 std::fill(res,res+nbComps,0.);
3206 for(int i=0;i<nbTuple;i++)
3207 std::transform(ptr+i*nbComps,ptr+(i+1)*nbComps,res,res,std::plus<double>());
3211 * This method returns the min distance from an external tuple defined by [ \a tupleBg , \a tupleEnd ) to \a this and
3212 * the first tuple in \a this that matches the returned distance. If there is no tuples in \a this an exception will be thrown.
3215 * \a this is expected to be allocated and expected to have a number of components equal to the distance from \a tupleBg to
3216 * \a tupleEnd. If not an exception will be thrown.
3218 * \param [in] tupleBg start pointer (included) of input external tuple
3219 * \param [in] tupleEnd end pointer (not included) of input external tuple
3220 * \param [out] tupleId the tuple id in \a this that matches the min of distance between \a this and input external tuple
3221 * \return the min distance.
3222 * \sa MEDCouplingUMesh::distanceToPoint
3224 double DataArrayDouble::distanceToTuple(const double *tupleBg, const double *tupleEnd, int& tupleId) const throw(INTERP_KERNEL::Exception)
3227 int nbTuple=getNumberOfTuples();
3228 int nbComps=getNumberOfComponents();
3229 if(nbComps!=(int)std::distance(tupleBg,tupleEnd))
3230 { 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()); }
3232 throw INTERP_KERNEL::Exception("DataArrayDouble::distanceToTuple : no tuple in this ! No distance to compute !");
3233 double ret0=std::numeric_limits<double>::max();
3235 const double *work=getConstPointer();
3236 for(int i=0;i<nbTuple;i++)
3239 for(int j=0;j<nbComps;j++,work++)
3240 val+=(*work-tupleBg[j])*((*work-tupleBg[j]));
3244 { ret0=val; tupleId=i; }
3250 * Accumulate values of the given component of \a this array.
3251 * \param [in] compId - the index of the component of interest.
3252 * \return double - a sum value of \a compId-th component.
3253 * \throw If \a this is not allocated.
3254 * \throw If \a the condition ( 0 <= \a compId < \a this->getNumberOfComponents() ) is
3257 double DataArrayDouble::accumulate(int compId) const throw(INTERP_KERNEL::Exception)
3260 const double *ptr=getConstPointer();
3261 int nbTuple=getNumberOfTuples();
3262 int nbComps=getNumberOfComponents();
3263 if(compId<0 || compId>=nbComps)
3264 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulate : Invalid compId specified : No such nb of components !");
3266 for(int i=0;i<nbTuple;i++)
3267 ret+=ptr[i*nbComps+compId];
3272 * This method accumulate using addition tuples in \a this using input index array [ \a bgOfIndex, \a endOfIndex ).
3273 * The returned array will have same number of components than \a this and number of tuples equal to
3274 * \c std::distance(bgOfIndex,endOfIndex) \b minus \b one.
3276 * The input index array is expected to be ascendingly sorted in which the all referenced ids should be in [0, \c this->getNumberOfTuples).
3277 * 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.
3279 * \param [in] bgOfIndex - begin (included) of the input index array.
3280 * \param [in] endOfIndex - end (excluded) of the input index array.
3281 * \return DataArrayDouble * - the new instance having the same number of components than \a this.
3283 * \throw If bgOfIndex or end is NULL.
3284 * \throw If input index array is not ascendingly sorted.
3285 * \throw If there is an id in [ \a bgOfIndex, \a endOfIndex ) not in [0, \c this->getNumberOfTuples).
3286 * \throw If std::distance(bgOfIndex,endOfIndex)==0.
3288 DataArrayDouble *DataArrayDouble::accumulatePerChunck(const int *bgOfIndex, const int *endOfIndex) const throw(INTERP_KERNEL::Exception)
3290 if(!bgOfIndex || !endOfIndex)
3291 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : input pointer NULL !");
3293 int nbCompo=getNumberOfComponents();
3294 int nbOfTuples=getNumberOfTuples();
3295 int sz=(int)std::distance(bgOfIndex,endOfIndex);
3297 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : invalid size of input index array !");
3299 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(sz,nbCompo);
3300 const int *w=bgOfIndex;
3301 if(*w<0 || *w>=nbOfTuples)
3302 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : The first element of the input index not in [0,nbOfTuples) !");
3303 const double *srcPt=begin()+(*w)*nbCompo;
3304 double *tmp=ret->getPointer();
3305 for(int i=0;i<sz;i++,tmp+=nbCompo,w++)
3307 std::fill(tmp,tmp+nbCompo,0.);
3310 for(int j=w[0];j<w[1];j++,srcPt+=nbCompo)
3312 if(j>=0 && j<nbOfTuples)
3313 std::transform(srcPt,srcPt+nbCompo,tmp,tmp,std::plus<double>());
3316 std::ostringstream oss; oss << "DataArrayDouble::accumulatePerChunck : At rank #" << i << " the input index array points to id " << j << " should be in [0," << nbOfTuples << ") !";
3317 throw INTERP_KERNEL::Exception(oss.str().c_str());
3323 std::ostringstream oss; oss << "DataArrayDouble::accumulatePerChunck : At rank #" << i << " the input index array is not in ascendingly sorted.";
3324 throw INTERP_KERNEL::Exception(oss.str().c_str());
3327 ret->copyStringInfoFrom(*this);
3332 * Converts each 2D point defined by the tuple of \a this array from the Polar to the
3333 * Cartesian coordinate system. The two components of the tuple of \a this array are
3334 * considered to contain (1) radius and (2) angle of the point in the Polar CS.
3335 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3336 * contains X and Y coordinates of the point in the Cartesian CS. The caller
3337 * is to delete this array using decrRef() as it is no more needed. The array
3338 * does not contain any textual info on components.
3339 * \throw If \a this->getNumberOfComponents() != 2.
3341 DataArrayDouble *DataArrayDouble::fromPolarToCart() const throw(INTERP_KERNEL::Exception)
3344 int nbOfComp=getNumberOfComponents();
3346 throw INTERP_KERNEL::Exception("DataArrayDouble::fromPolarToCart : must be an array with exactly 2 components !");
3347 int nbOfTuple=getNumberOfTuples();
3348 DataArrayDouble *ret=DataArrayDouble::New();
3349 ret->alloc(nbOfTuple,2);
3350 double *w=ret->getPointer();
3351 const double *wIn=getConstPointer();
3352 for(int i=0;i<nbOfTuple;i++,w+=2,wIn+=2)
3354 w[0]=wIn[0]*cos(wIn[1]);
3355 w[1]=wIn[0]*sin(wIn[1]);
3361 * Converts each 3D point defined by the tuple of \a this array from the Cylindrical to
3362 * the Cartesian coordinate system. The three components of the tuple of \a this array
3363 * are considered to contain (1) radius, (2) azimuth and (3) altitude of the point in
3364 * the Cylindrical CS.
3365 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3366 * contains X, Y and Z coordinates of the point in the Cartesian CS. The info
3367 * on the third component is copied from \a this array. The caller
3368 * is to delete this array using decrRef() as it is no more needed.
3369 * \throw If \a this->getNumberOfComponents() != 3.
3371 DataArrayDouble *DataArrayDouble::fromCylToCart() const throw(INTERP_KERNEL::Exception)
3374 int nbOfComp=getNumberOfComponents();
3376 throw INTERP_KERNEL::Exception("DataArrayDouble::fromCylToCart : must be an array with exactly 3 components !");
3377 int nbOfTuple=getNumberOfTuples();
3378 DataArrayDouble *ret=DataArrayDouble::New();
3379 ret->alloc(getNumberOfTuples(),3);
3380 double *w=ret->getPointer();
3381 const double *wIn=getConstPointer();
3382 for(int i=0;i<nbOfTuple;i++,w+=3,wIn+=3)
3384 w[0]=wIn[0]*cos(wIn[1]);
3385 w[1]=wIn[0]*sin(wIn[1]);
3388 ret->setInfoOnComponent(2,getInfoOnComponent(2).c_str());
3393 * Converts each 3D point defined by the tuple of \a this array from the Spherical to
3394 * the Cartesian coordinate system. The three components of the tuple of \a this array
3395 * are considered to contain (1) radius, (2) polar angle and (3) azimuthal angle of the
3396 * point in the Cylindrical CS.
3397 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3398 * contains X, Y and Z coordinates of the point in the Cartesian CS. The info
3399 * on the third component is copied from \a this array. The caller
3400 * is to delete this array using decrRef() as it is no more needed.
3401 * \throw If \a this->getNumberOfComponents() != 3.
3403 DataArrayDouble *DataArrayDouble::fromSpherToCart() const throw(INTERP_KERNEL::Exception)
3406 int nbOfComp=getNumberOfComponents();
3408 throw INTERP_KERNEL::Exception("DataArrayDouble::fromSpherToCart : must be an array with exactly 3 components !");
3409 int nbOfTuple=getNumberOfTuples();
3410 DataArrayDouble *ret=DataArrayDouble::New();
3411 ret->alloc(getNumberOfTuples(),3);
3412 double *w=ret->getPointer();
3413 const double *wIn=getConstPointer();
3414 for(int i=0;i<nbOfTuple;i++,w+=3,wIn+=3)
3416 w[0]=wIn[0]*cos(wIn[2])*sin(wIn[1]);
3417 w[1]=wIn[0]*sin(wIn[2])*sin(wIn[1]);
3418 w[2]=wIn[0]*cos(wIn[1]);
3424 * Computes the doubly contracted product of every tensor defined by the tuple of \a this
3425 * array contating 6 components.
3426 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3427 * is calculated from the tuple <em>(t)</em> of \a this array as follows:
3428 * \f$ t[0]^2+t[1]^2+t[2]^2+2*t[3]^2+2*t[4]^2+2*t[5]^2\f$.
3429 * The caller is to delete this result array using decrRef() as it is no more needed.
3430 * \throw If \a this->getNumberOfComponents() != 6.
3432 DataArrayDouble *DataArrayDouble::doublyContractedProduct() const throw(INTERP_KERNEL::Exception)
3435 int nbOfComp=getNumberOfComponents();
3437 throw INTERP_KERNEL::Exception("DataArrayDouble::doublyContractedProduct : must be an array with exactly 6 components !");
3438 DataArrayDouble *ret=DataArrayDouble::New();
3439 int nbOfTuple=getNumberOfTuples();
3440 ret->alloc(nbOfTuple,1);
3441 const double *src=getConstPointer();
3442 double *dest=ret->getPointer();
3443 for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
3444 *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];
3449 * Computes the determinant of every square matrix defined by the tuple of \a this
3450 * array, which contains either 4, 6 or 9 components. The case of 6 components
3451 * corresponds to that of the upper triangular matrix.
3452 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3453 * is the determinant of matrix of the corresponding tuple of \a this array.
3454 * The caller is to delete this result array using decrRef() as it is no more
3456 * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
3458 DataArrayDouble *DataArrayDouble::determinant() const throw(INTERP_KERNEL::Exception)
3461 DataArrayDouble *ret=DataArrayDouble::New();
3462 int nbOfTuple=getNumberOfTuples();
3463 ret->alloc(nbOfTuple,1);
3464 const double *src=getConstPointer();
3465 double *dest=ret->getPointer();
3466 switch(getNumberOfComponents())
3469 for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
3470 *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];
3473 for(int i=0;i<nbOfTuple;i++,dest++,src+=4)
3474 *dest=src[0]*src[3]-src[1]*src[2];
3477 for(int i=0;i<nbOfTuple;i++,dest++,src+=9)
3478 *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];
3482 throw INTERP_KERNEL::Exception("DataArrayDouble::determinant : Invalid number of components ! must be in 4,6,9 !");
3487 * Computes 3 eigenvalues of every upper triangular matrix defined by the tuple of
3488 * \a this array, which contains 6 components.
3489 * \return DataArrayDouble * - the new instance of DataArrayDouble containing 3
3490 * components, whose each tuple contains the eigenvalues of the matrix of
3491 * corresponding tuple of \a this array.
3492 * The caller is to delete this result array using decrRef() as it is no more
3494 * \throw If \a this->getNumberOfComponents() != 6.
3496 DataArrayDouble *DataArrayDouble::eigenValues() const throw(INTERP_KERNEL::Exception)
3499 int nbOfComp=getNumberOfComponents();
3501 throw INTERP_KERNEL::Exception("DataArrayDouble::eigenValues : must be an array with exactly 6 components !");
3502 DataArrayDouble *ret=DataArrayDouble::New();
3503 int nbOfTuple=getNumberOfTuples();
3504 ret->alloc(nbOfTuple,3);
3505 const double *src=getConstPointer();
3506 double *dest=ret->getPointer();
3507 for(int i=0;i<nbOfTuple;i++,dest+=3,src+=6)
3508 INTERP_KERNEL::computeEigenValues6(src,dest);
3513 * Computes 3 eigenvectors of every upper triangular matrix defined by the tuple of
3514 * \a this array, which contains 6 components.
3515 * \return DataArrayDouble * - the new instance of DataArrayDouble containing 9
3516 * components, whose each tuple contains 3 eigenvectors of the matrix of
3517 * corresponding tuple of \a this array.
3518 * The caller is to delete this result array using decrRef() as it is no more
3520 * \throw If \a this->getNumberOfComponents() != 6.
3522 DataArrayDouble *DataArrayDouble::eigenVectors() const throw(INTERP_KERNEL::Exception)
3525 int nbOfComp=getNumberOfComponents();
3527 throw INTERP_KERNEL::Exception("DataArrayDouble::eigenVectors : must be an array with exactly 6 components !");
3528 DataArrayDouble *ret=DataArrayDouble::New();
3529 int nbOfTuple=getNumberOfTuples();
3530 ret->alloc(nbOfTuple,9);
3531 const double *src=getConstPointer();
3532 double *dest=ret->getPointer();
3533 for(int i=0;i<nbOfTuple;i++,src+=6)
3536 INTERP_KERNEL::computeEigenValues6(src,tmp);
3537 for(int j=0;j<3;j++,dest+=3)
3538 INTERP_KERNEL::computeEigenVectorForEigenValue6(src,tmp[j],1e-12,dest);
3544 * Computes the inverse matrix of every matrix defined by the tuple of \a this
3545 * array, which contains either 4, 6 or 9 components. The case of 6 components
3546 * corresponds to that of the upper triangular matrix.
3547 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3548 * same number of components as \a this one, whose each tuple is the inverse
3549 * matrix of the matrix of corresponding tuple of \a this array.
3550 * The caller is to delete this result array using decrRef() as it is no more
3552 * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
3554 DataArrayDouble *DataArrayDouble::inverse() const throw(INTERP_KERNEL::Exception)
3557 int nbOfComp=getNumberOfComponents();
3558 if(nbOfComp!=6 && nbOfComp!=9 && nbOfComp!=4)
3559 throw INTERP_KERNEL::Exception("DataArrayDouble::inversion : must be an array with 4,6 or 9 components !");
3560 DataArrayDouble *ret=DataArrayDouble::New();
3561 int nbOfTuple=getNumberOfTuples();
3562 ret->alloc(nbOfTuple,nbOfComp);
3563 const double *src=getConstPointer();
3564 double *dest=ret->getPointer();
3566 for(int i=0;i<nbOfTuple;i++,dest+=6,src+=6)
3568 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];
3569 dest[0]=(src[1]*src[2]-src[4]*src[4])/det;
3570 dest[1]=(src[0]*src[2]-src[5]*src[5])/det;
3571 dest[2]=(src[0]*src[1]-src[3]*src[3])/det;
3572 dest[3]=(src[5]*src[4]-src[3]*src[2])/det;
3573 dest[4]=(src[5]*src[3]-src[0]*src[4])/det;
3574 dest[5]=(src[3]*src[4]-src[1]*src[5])/det;
3576 else if(nbOfComp==4)
3577 for(int i=0;i<nbOfTuple;i++,dest+=4,src+=4)
3579 double det=src[0]*src[3]-src[1]*src[2];
3581 dest[1]=-src[1]/det;
3582 dest[2]=-src[2]/det;
3586 for(int i=0;i<nbOfTuple;i++,dest+=9,src+=9)
3588 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];
3589 dest[0]=(src[4]*src[8]-src[7]*src[5])/det;
3590 dest[1]=(src[7]*src[2]-src[1]*src[8])/det;
3591 dest[2]=(src[1]*src[5]-src[4]*src[2])/det;
3592 dest[3]=(src[6]*src[5]-src[3]*src[8])/det;
3593 dest[4]=(src[0]*src[8]-src[6]*src[2])/det;
3594 dest[5]=(src[2]*src[3]-src[0]*src[5])/det;
3595 dest[6]=(src[3]*src[7]-src[6]*src[4])/det;
3596 dest[7]=(src[6]*src[1]-src[0]*src[7])/det;
3597 dest[8]=(src[0]*src[4]-src[1]*src[3])/det;
3603 * Computes the trace of every matrix defined by the tuple of \a this
3604 * array, which contains either 4, 6 or 9 components. The case of 6 components
3605 * corresponds to that of the upper triangular matrix.
3606 * \return DataArrayDouble * - the new instance of DataArrayDouble containing
3607 * 1 component, whose each tuple is the trace of
3608 * the matrix of corresponding tuple of \a this array.
3609 * The caller is to delete this result array using decrRef() as it is no more
3611 * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
3613 DataArrayDouble *DataArrayDouble::trace() const throw(INTERP_KERNEL::Exception)
3616 int nbOfComp=getNumberOfComponents();
3617 if(nbOfComp!=6 && nbOfComp!=9 && nbOfComp!=4)
3618 throw INTERP_KERNEL::Exception("DataArrayDouble::trace : must be an array with 4,6 or 9 components !");
3619 DataArrayDouble *ret=DataArrayDouble::New();
3620 int nbOfTuple=getNumberOfTuples();
3621 ret->alloc(nbOfTuple,1);
3622 const double *src=getConstPointer();
3623 double *dest=ret->getPointer();
3625 for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
3626 *dest=src[0]+src[1]+src[2];
3627 else if(nbOfComp==4)
3628 for(int i=0;i<nbOfTuple;i++,dest++,src+=4)
3629 *dest=src[0]+src[3];
3631 for(int i=0;i<nbOfTuple;i++,dest++,src+=9)
3632 *dest=src[0]+src[4]+src[8];
3637 * Computes the stress deviator tensor of every stress tensor defined by the tuple of
3638 * \a this array, which contains 6 components.
3639 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3640 * same number of components and tuples as \a this array.
3641 * The caller is to delete this result array using decrRef() as it is no more
3643 * \throw If \a this->getNumberOfComponents() != 6.
3645 DataArrayDouble *DataArrayDouble::deviator() const throw(INTERP_KERNEL::Exception)
3648 int nbOfComp=getNumberOfComponents();
3650 throw INTERP_KERNEL::Exception("DataArrayDouble::deviator : must be an array with exactly 6 components !");
3651 DataArrayDouble *ret=DataArrayDouble::New();
3652 int nbOfTuple=getNumberOfTuples();
3653 ret->alloc(nbOfTuple,6);
3654 const double *src=getConstPointer();
3655 double *dest=ret->getPointer();
3656 for(int i=0;i<nbOfTuple;i++,dest+=6,src+=6)
3658 double tr=(src[0]+src[1]+src[2])/3.;
3670 * Computes the magnitude of every vector defined by the tuple of
3672 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3673 * same number of tuples as \a this array and one component.
3674 * The caller is to delete this result array using decrRef() as it is no more
3676 * \throw If \a this is not allocated.
3678 DataArrayDouble *DataArrayDouble::magnitude() const throw(INTERP_KERNEL::Exception)
3681 int nbOfComp=getNumberOfComponents();
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 for(int i=0;i<nbOfTuple;i++,dest++)
3690 for(int j=0;j<nbOfComp;j++,src++)
3698 * Computes the maximal value within every tuple of \a this array.
3699 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3700 * same number of tuples as \a this array and one component.
3701 * The caller is to delete this result array using decrRef() as it is no more
3703 * \throw If \a this is not allocated.
3704 * \sa DataArrayDouble::maxPerTupleWithCompoId
3706 DataArrayDouble *DataArrayDouble::maxPerTuple() const throw(INTERP_KERNEL::Exception)
3709 int nbOfComp=getNumberOfComponents();
3710 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
3711 int nbOfTuple=getNumberOfTuples();
3712 ret->alloc(nbOfTuple,1);
3713 const double *src=getConstPointer();
3714 double *dest=ret->getPointer();
3715 for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
3716 *dest=*std::max_element(src,src+nbOfComp);
3721 * Computes the maximal value within every tuple of \a this array and it returns the first component
3722 * id for each tuple that corresponds to the maximal value within the tuple.
3724 * \param [out] compoIdOfMaxPerTuple - the new new instance of DataArrayInt containing the
3725 * same number of tuples and only one component.
3726 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3727 * same number of tuples as \a this array and one component.
3728 * The caller is to delete this result array using decrRef() as it is no more
3730 * \throw If \a this is not allocated.
3731 * \sa DataArrayDouble::maxPerTuple
3733 DataArrayDouble *DataArrayDouble::maxPerTupleWithCompoId(DataArrayInt* &compoIdOfMaxPerTuple) const throw(INTERP_KERNEL::Exception)
3736 int nbOfComp=getNumberOfComponents();
3737 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret0=DataArrayDouble::New();
3738 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New();
3739 int nbOfTuple=getNumberOfTuples();
3740 ret0->alloc(nbOfTuple,1); ret1->alloc(nbOfTuple,1);
3741 const double *src=getConstPointer();
3742 double *dest=ret0->getPointer(); int *dest1=ret1->getPointer();
3743 for(int i=0;i<nbOfTuple;i++,dest++,dest1++,src+=nbOfComp)
3745 const double *loc=std::max_element(src,src+nbOfComp);
3747 *dest1=(int)std::distance(src,loc);
3749 compoIdOfMaxPerTuple=ret1.retn();
3754 * This method returns a newly allocated DataArrayDouble instance having one component and \c this->getNumberOfTuples() * \c this->getNumberOfTuples() tuples.
3755 * \n This returned array contains the euclidian distance for each tuple in \a this.
3756 * \n So the returned array can be seen as a dense symmetrical matrix whose diagonal elements are equal to 0.
3757 * \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)
3759 * \warning use this method with care because it can leads to big amount of consumed memory !
3761 * \return A newly allocated (huge) ParaMEDMEM::DataArrayDouble instance that the caller should deal with.
3763 * \throw If \a this is not allocated.
3765 * \sa DataArrayDouble::buildEuclidianDistanceDenseMatrixWith
3767 DataArrayDouble *DataArrayDouble::buildEuclidianDistanceDenseMatrix() const throw(INTERP_KERNEL::Exception)
3770 int nbOfComp=getNumberOfComponents();
3771 int nbOfTuples=getNumberOfTuples();
3772 const double *inData=getConstPointer();
3773 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
3774 ret->alloc(nbOfTuples*nbOfTuples,1);
3775 double *outData=ret->getPointer();
3776 for(int i=0;i<nbOfTuples;i++)
3778 outData[i*nbOfTuples+i]=0.;
3779 for(int j=i+1;j<nbOfTuples;j++)
3782 for(int k=0;k<nbOfComp;k++)
3783 { double delta=inData[i*nbOfComp+k]-inData[j*nbOfComp+k]; dist+=delta*delta; }
3785 outData[i*nbOfTuples+j]=dist;
3786 outData[j*nbOfTuples+i]=dist;
3793 * This method returns a newly allocated DataArrayDouble instance having one component and \c this->getNumberOfTuples() * \c other->getNumberOfTuples() tuples.
3794 * \n This returned array contains the euclidian distance for each tuple in \a other with each tuple in \a this.
3795 * \n So the returned array can be seen as a dense rectangular matrix with \c other->getNumberOfTuples() rows and \c this->getNumberOfTuples() columns.
3796 * \n Output rectangular matrix is sorted along rows.
3797 * \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)
3799 * \warning use this method with care because it can leads to big amount of consumed memory !
3801 * \param [in] other DataArrayDouble instance having same number of components than \a this.
3802 * \return A newly allocated (huge) ParaMEDMEM::DataArrayDouble instance that the caller should deal with.
3804 * \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.
3806 * \sa DataArrayDouble::buildEuclidianDistanceDenseMatrix
3808 DataArrayDouble *DataArrayDouble::buildEuclidianDistanceDenseMatrixWith(const DataArrayDouble *other) const throw(INTERP_KERNEL::Exception)
3811 throw INTERP_KERNEL::Exception("DataArrayDouble::buildEuclidianDistanceDenseMatrixWith : input parameter is null !");
3813 other->checkAllocated();
3814 int nbOfComp=getNumberOfComponents();
3815 int otherNbOfComp=other->getNumberOfComponents();
3816 if(nbOfComp!=otherNbOfComp)
3818 std::ostringstream oss; oss << "DataArrayDouble::buildEuclidianDistanceDenseMatrixWith : this nb of compo=" << nbOfComp << " and other nb of compo=" << otherNbOfComp << ". It should match !";
3819 throw INTERP_KERNEL::Exception(oss.str().c_str());
3821 int nbOfTuples=getNumberOfTuples();
3822 int otherNbOfTuples=other->getNumberOfTuples();
3823 const double *inData=getConstPointer();
3824 const double *inDataOther=other->getConstPointer();
3825 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
3826 ret->alloc(otherNbOfTuples*nbOfTuples,1);
3827 double *outData=ret->getPointer();
3828 for(int i=0;i<otherNbOfTuples;i++,inDataOther+=nbOfComp)
3830 for(int j=0;j<nbOfTuples;j++)
3833 for(int k=0;k<nbOfComp;k++)
3834 { double delta=inDataOther[k]-inData[j*nbOfComp+k]; dist+=delta*delta; }
3836 outData[i*nbOfTuples+j]=dist;
3843 * Sorts value within every tuple of \a this array.
3844 * \param [in] asc - if \a true, the values are sorted in ascending order, else,
3845 * in descending order.
3846 * \throw If \a this is not allocated.
3848 void DataArrayDouble::sortPerTuple(bool asc) throw(INTERP_KERNEL::Exception)
3851 double *pt=getPointer();
3852 int nbOfTuple=getNumberOfTuples();
3853 int nbOfComp=getNumberOfComponents();
3855 for(int i=0;i<nbOfTuple;i++,pt+=nbOfComp)
3856 std::sort(pt,pt+nbOfComp);
3858 for(int i=0;i<nbOfTuple;i++,pt+=nbOfComp)
3859 std::sort(pt,pt+nbOfComp,std::greater<double>());
3864 * Converts every value of \a this array to its absolute value.
3865 * \throw If \a this is not allocated.
3867 void DataArrayDouble::abs() throw(INTERP_KERNEL::Exception)
3870 double *ptr=getPointer();
3871 std::size_t nbOfElems=getNbOfElems();
3872 std::transform(ptr,ptr+nbOfElems,ptr,std::ptr_fun<double,double>(fabs));
3877 * Apply a liner function to a given component of \a this array, so that
3878 * an array element <em>(x)</em> becomes \f$ a * x + b \f$.
3879 * \param [in] a - the first coefficient of the function.
3880 * \param [in] b - the second coefficient of the function.
3881 * \param [in] compoId - the index of component to modify.
3882 * \throw If \a this is not allocated.
3884 void DataArrayDouble::applyLin(double a, double b, int compoId) throw(INTERP_KERNEL::Exception)
3887 double *ptr=getPointer()+compoId;
3888 int nbOfComp=getNumberOfComponents();
3889 int nbOfTuple=getNumberOfTuples();
3890 for(int i=0;i<nbOfTuple;i++,ptr+=nbOfComp)
3896 * Apply a liner function to all elements of \a this array, so that
3897 * an element _x_ becomes \f$ a * x + b \f$.
3898 * \param [in] a - the first coefficient of the function.
3899 * \param [in] b - the second coefficient of the function.
3900 * \throw If \a this is not allocated.
3902 void DataArrayDouble::applyLin(double a, double b) throw(INTERP_KERNEL::Exception)
3905 double *ptr=getPointer();
3906 std::size_t nbOfElems=getNbOfElems();
3907 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
3913 * Modify all elements of \a this array, so that
3914 * an element _x_ becomes \f$ numerator / x \f$.
3915 * \warning If an exception is thrown because of presence of 0.0 element in \a this
3916 * array, all elements processed before detection of the zero element remain
3918 * \param [in] numerator - the numerator used to modify array elements.
3919 * \throw If \a this is not allocated.
3920 * \throw If there is an element equal to 0.0 in \a this array.
3922 void DataArrayDouble::applyInv(double numerator) throw(INTERP_KERNEL::Exception)
3925 double *ptr=getPointer();
3926 std::size_t nbOfElems=getNbOfElems();
3927 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
3929 if(std::abs(*ptr)>std::numeric_limits<double>::min())
3931 *ptr=numerator/(*ptr);
3935 std::ostringstream oss; oss << "DataArrayDouble::applyInv : presence of null value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
3937 throw INTERP_KERNEL::Exception(oss.str().c_str());
3944 * Returns a full copy of \a this array except that sign of all elements is reversed.
3945 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3946 * same number of tuples and component as \a this array.
3947 * The caller is to delete this result array using decrRef() as it is no more
3949 * \throw If \a this is not allocated.
3951 DataArrayDouble *DataArrayDouble::negate() const throw(INTERP_KERNEL::Exception)
3954 DataArrayDouble *newArr=DataArrayDouble::New();
3955 int nbOfTuples=getNumberOfTuples();
3956 int nbOfComp=getNumberOfComponents();
3957 newArr->alloc(nbOfTuples,nbOfComp);
3958 const double *cptr=getConstPointer();
3959 std::transform(cptr,cptr+nbOfTuples*nbOfComp,newArr->getPointer(),std::negate<double>());
3960 newArr->copyStringInfoFrom(*this);
3965 * Modify all elements of \a this array, so that
3966 * an element _x_ becomes <em> val ^ x </em>. Contrary to DataArrayInt::applyPow
3967 * all values in \a this have to be >= 0 if val is \b not integer.
3968 * \param [in] val - the value used to apply pow on all array elements.
3969 * \throw If \a this is not allocated.
3970 * \warning If an exception is thrown because of presence of 0 element in \a this
3971 * array and \a val is \b not integer, all elements processed before detection of the zero element remain
3974 void DataArrayDouble::applyPow(double val) throw(INTERP_KERNEL::Exception)
3977 double *ptr=getPointer();
3978 std::size_t nbOfElems=getNbOfElems();
3980 bool isInt=((double)val2)==val;
3983 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
3989 std::ostringstream oss; oss << "DataArrayDouble::applyPow (double) : At elem # " << i << " value is " << *ptr << " ! must be >=0. !";
3990 throw INTERP_KERNEL::Exception(oss.str().c_str());
3996 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
3997 *ptr=pow(*ptr,val2);
4003 * Modify all elements of \a this array, so that
4004 * an element _x_ becomes \f$ val ^ x \f$.
4005 * \param [in] val - the value used to apply pow on all array elements.
4006 * \throw If \a this is not allocated.
4007 * \throw If \a val < 0.
4008 * \warning If an exception is thrown because of presence of 0 element in \a this
4009 * array, all elements processed before detection of the zero element remain
4012 void DataArrayDouble::applyRPow(double val) throw(INTERP_KERNEL::Exception)
4016 throw INTERP_KERNEL::Exception("DataArrayDouble::applyRPow : the input value has to be >= 0 !");
4017 double *ptr=getPointer();
4018 std::size_t nbOfElems=getNbOfElems();
4019 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4025 * Returns a new DataArrayDouble created from \a this one by applying \a
4026 * FunctionToEvaluate to every tuple of \a this array. Textual data is not copied.
4027 * For more info see \ref MEDCouplingArrayApplyFunc
4028 * \param [in] nbOfComp - number of components in the result array.
4029 * \param [in] func - the \a FunctionToEvaluate declared as
4030 * \c bool (*\a func)(\c const \c double *\a pos, \c double *\a res),
4031 * where \a pos points to the first component of a tuple of \a this array
4032 * and \a res points to the first component of a tuple of the result array.
4033 * Note that length (number of components) of \a pos can differ from
4035 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4036 * same number of tuples as \a this array.
4037 * The caller is to delete this result array using decrRef() as it is no more
4039 * \throw If \a this is not allocated.
4040 * \throw If \a func returns \a false.
4042 DataArrayDouble *DataArrayDouble::applyFunc(int nbOfComp, FunctionToEvaluate func) const throw(INTERP_KERNEL::Exception)
4045 DataArrayDouble *newArr=DataArrayDouble::New();
4046 int nbOfTuples=getNumberOfTuples();
4047 int oldNbOfComp=getNumberOfComponents();
4048 newArr->alloc(nbOfTuples,nbOfComp);
4049 const double *ptr=getConstPointer();
4050 double *ptrToFill=newArr->getPointer();
4051 for(int i=0;i<nbOfTuples;i++)
4053 if(!func(ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp))
4055 std::ostringstream oss; oss << "For tuple # " << i << " with value (";
4056 std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
4057 oss << ") : Evaluation of function failed !";
4059 throw INTERP_KERNEL::Exception(oss.str().c_str());
4066 * Returns a new DataArrayDouble created from \a this one by applying a function to every
4067 * tuple of \a this array. Textual data is not copied.
4068 * For more info see \ref MEDCouplingArrayApplyFunc1.
4069 * \param [in] nbOfComp - number of components in the result array.
4070 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4071 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4072 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4073 * same number of tuples as \a this array and \a nbOfComp components.
4074 * The caller is to delete this result array using decrRef() as it is no more
4076 * \throw If \a this is not allocated.
4077 * \throw If computing \a func fails.
4079 DataArrayDouble *DataArrayDouble::applyFunc(int nbOfComp, const char *func) const throw(INTERP_KERNEL::Exception)
4082 INTERP_KERNEL::ExprParser expr(func);
4084 std::set<std::string> vars;
4085 expr.getTrueSetOfVars(vars);
4086 int oldNbOfComp=getNumberOfComponents();
4087 if((int)vars.size()>oldNbOfComp)
4089 std::ostringstream oss; oss << "The field has " << oldNbOfComp << " components and there are ";
4090 oss << vars.size() << " variables : ";
4091 std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
4092 throw INTERP_KERNEL::Exception(oss.str().c_str());
4094 std::vector<std::string> varsV(vars.begin(),vars.end());
4095 expr.prepareExprEvaluation(varsV,oldNbOfComp,nbOfComp);
4097 DataArrayDouble *newArr=DataArrayDouble::New();
4098 int nbOfTuples=getNumberOfTuples();
4099 newArr->alloc(nbOfTuples,nbOfComp);
4100 const double *ptr=getConstPointer();
4101 double *ptrToFill=newArr->getPointer();
4102 for(int i=0;i<nbOfTuples;i++)
4106 expr.evaluateExpr(nbOfComp,ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp);
4108 catch(INTERP_KERNEL::Exception& e)
4110 std::ostringstream oss; oss << "For tuple # " << i << " with value (";
4111 std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
4112 oss << ") : Evaluation of function failed !" << e.what();
4114 throw INTERP_KERNEL::Exception(oss.str().c_str());
4121 * Returns a new DataArrayDouble created from \a this one by applying a function to every
4122 * tuple of \a this array. Textual data is not copied.
4123 * For more info see \ref MEDCouplingArrayApplyFunc0.
4124 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4125 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4126 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4127 * same number of tuples and components as \a this array.
4128 * The caller is to delete this result array using decrRef() as it is no more
4130 * \throw If \a this is not allocated.
4131 * \throw If computing \a func fails.
4133 DataArrayDouble *DataArrayDouble::applyFunc(const char *func) const throw(INTERP_KERNEL::Exception)
4136 INTERP_KERNEL::ExprParser expr(func);
4138 expr.prepareExprEvaluationVec();
4140 DataArrayDouble *newArr=DataArrayDouble::New();
4141 int nbOfTuples=getNumberOfTuples();
4142 int nbOfComp=getNumberOfComponents();
4143 newArr->alloc(nbOfTuples,nbOfComp);
4144 const double *ptr=getConstPointer();
4145 double *ptrToFill=newArr->getPointer();
4146 for(int i=0;i<nbOfTuples;i++)
4150 expr.evaluateExpr(nbOfComp,ptr+i*nbOfComp,ptrToFill+i*nbOfComp);
4152 catch(INTERP_KERNEL::Exception& e)
4154 std::ostringstream oss; oss << "For tuple # " << i << " with value (";
4155 std::copy(ptr+nbOfComp*i,ptr+nbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
4156 oss << ") : Evaluation of function failed ! " << e.what();
4158 throw INTERP_KERNEL::Exception(oss.str().c_str());
4165 * Returns a new DataArrayDouble created from \a this one by applying a function to every
4166 * tuple of \a this array. Textual data is not copied.
4167 * For more info see \ref MEDCouplingArrayApplyFunc2.
4168 * \param [in] nbOfComp - number of components in the result array.
4169 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4170 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4171 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4172 * same number of tuples as \a this array.
4173 * The caller is to delete this result array using decrRef() as it is no more
4175 * \throw If \a this is not allocated.
4176 * \throw If \a func contains vars that are not in \a this->getInfoOnComponent().
4177 * \throw If computing \a func fails.
4179 DataArrayDouble *DataArrayDouble::applyFunc2(int nbOfComp, const char *func) const throw(INTERP_KERNEL::Exception)
4182 INTERP_KERNEL::ExprParser expr(func);
4184 std::set<std::string> vars;
4185 expr.getTrueSetOfVars(vars);
4186 int oldNbOfComp=getNumberOfComponents();
4187 if((int)vars.size()>oldNbOfComp)
4189 std::ostringstream oss; oss << "The field has " << oldNbOfComp << " components and there are ";
4190 oss << vars.size() << " variables : ";
4191 std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
4192 throw INTERP_KERNEL::Exception(oss.str().c_str());
4194 expr.prepareExprEvaluation(getVarsOnComponent(),oldNbOfComp,nbOfComp);
4196 DataArrayDouble *newArr=DataArrayDouble::New();
4197 int nbOfTuples=getNumberOfTuples();
4198 newArr->alloc(nbOfTuples,nbOfComp);
4199 const double *ptr=getConstPointer();
4200 double *ptrToFill=newArr->getPointer();
4201 for(int i=0;i<nbOfTuples;i++)
4205 expr.evaluateExpr(nbOfComp,ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp);
4207 catch(INTERP_KERNEL::Exception& e)
4209 std::ostringstream oss; oss << "For tuple # " << i << " with value (";
4210 std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
4211 oss << ") : Evaluation of function failed !" << e.what();
4213 throw INTERP_KERNEL::Exception(oss.str().c_str());
4220 * Returns a new DataArrayDouble created from \a this one by applying a function to every
4221 * tuple of \a this array. Textual data is not copied.
4222 * For more info see \ref MEDCouplingArrayApplyFunc3.
4223 * \param [in] nbOfComp - number of components in the result array.
4224 * \param [in] varsOrder - sequence of vars defining their order.
4225 * \param [in] func - the expression defining how to transform a tuple of \a this array.
4226 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4227 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4228 * same number of tuples as \a this array.
4229 * The caller is to delete this result array using decrRef() as it is no more
4231 * \throw If \a this is not allocated.
4232 * \throw If \a func contains vars not in \a varsOrder.
4233 * \throw If computing \a func fails.
4235 DataArrayDouble *DataArrayDouble::applyFunc3(int nbOfComp, const std::vector<std::string>& varsOrder, const char *func) const throw(INTERP_KERNEL::Exception)
4238 INTERP_KERNEL::ExprParser expr(func);
4240 std::set<std::string> vars;
4241 expr.getTrueSetOfVars(vars);
4242 int oldNbOfComp=getNumberOfComponents();
4243 if((int)vars.size()>oldNbOfComp)
4245 std::ostringstream oss; oss << "The field has " << oldNbOfComp << " components and there are ";
4246 oss << vars.size() << " variables : ";
4247 std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
4248 throw INTERP_KERNEL::Exception(oss.str().c_str());
4250 expr.prepareExprEvaluation(varsOrder,oldNbOfComp,nbOfComp);
4252 DataArrayDouble *newArr=DataArrayDouble::New();
4253 int nbOfTuples=getNumberOfTuples();
4254 newArr->alloc(nbOfTuples,nbOfComp);
4255 const double *ptr=getConstPointer();
4256 double *ptrToFill=newArr->getPointer();
4257 for(int i=0;i<nbOfTuples;i++)
4261 expr.evaluateExpr(nbOfComp,ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp);
4263 catch(INTERP_KERNEL::Exception& e)
4265 std::ostringstream oss; oss << "For tuple # " << i << " with value (";
4266 std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
4267 oss << ") : Evaluation of function failed !" << e.what();
4269 throw INTERP_KERNEL::Exception(oss.str().c_str());
4275 void DataArrayDouble::applyFuncFast32(const char *func) throw(INTERP_KERNEL::Exception)
4278 INTERP_KERNEL::ExprParser expr(func);
4280 char *funcStr=expr.compileX86();
4282 *((void **)&funcPtr)=funcStr;//he he...
4284 double *ptr=getPointer();
4285 int nbOfComp=getNumberOfComponents();
4286 int nbOfTuples=getNumberOfTuples();
4287 int nbOfElems=nbOfTuples*nbOfComp;
4288 for(int i=0;i<nbOfElems;i++,ptr++)
4293 void DataArrayDouble::applyFuncFast64(const char *func) throw(INTERP_KERNEL::Exception)
4296 INTERP_KERNEL::ExprParser expr(func);
4298 char *funcStr=expr.compileX86_64();
4300 *((void **)&funcPtr)=funcStr;//he he...
4302 double *ptr=getPointer();
4303 int nbOfComp=getNumberOfComponents();
4304 int nbOfTuples=getNumberOfTuples();
4305 int nbOfElems=nbOfTuples*nbOfComp;
4306 for(int i=0;i<nbOfElems;i++,ptr++)
4311 DataArrayDoubleIterator *DataArrayDouble::iterator() throw(INTERP_KERNEL::Exception)
4313 return new DataArrayDoubleIterator(this);
4317 * Returns a new DataArrayInt contating indices of tuples of \a this one-dimensional
4318 * array whose values are within a given range. Textual data is not copied.
4319 * \param [in] vmin - a lowest acceptable value (included).
4320 * \param [in] vmax - a greatest acceptable value (included).
4321 * \return DataArrayInt * - the new instance of DataArrayInt.
4322 * The caller is to delete this result array using decrRef() as it is no more
4324 * \throw If \a this->getNumberOfComponents() != 1.
4326 * \ref cpp_mcdataarraydouble_getidsinrange "Here is a C++ example".<br>
4327 * \ref py_mcdataarraydouble_getidsinrange "Here is a Python example".
4329 DataArrayInt *DataArrayDouble::getIdsInRange(double vmin, double vmax) const throw(INTERP_KERNEL::Exception)
4332 if(getNumberOfComponents()!=1)
4333 throw INTERP_KERNEL::Exception("DataArrayDouble::getIdsInRange : this must have exactly one component !");
4334 const double *cptr=getConstPointer();
4335 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(0,1);
4336 int nbOfTuples=getNumberOfTuples();
4337 for(int i=0;i<nbOfTuples;i++,cptr++)
4338 if(*cptr>=vmin && *cptr<=vmax)
4339 ret->pushBackSilent(i);
4344 * Returns a new DataArrayDouble by concatenating two given arrays, so that (1) the number
4345 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
4346 * the number of component in the result array is same as that of each of given arrays.
4347 * Info on components is copied from the first of the given arrays. Number of components
4348 * in the given arrays must be the same.
4349 * \param [in] a1 - an array to include in the result array.
4350 * \param [in] a2 - another array to include in the result array.
4351 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4352 * The caller is to delete this result array using decrRef() as it is no more
4354 * \throw If both \a a1 and \a a2 are NULL.
4355 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents().
4357 DataArrayDouble *DataArrayDouble::Aggregate(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception)
4359 std::vector<const DataArrayDouble *> tmp(2);
4360 tmp[0]=a1; tmp[1]=a2;
4361 return Aggregate(tmp);
4365 * Returns a new DataArrayDouble by concatenating all given arrays, so that (1) the number
4366 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
4367 * the number of component in the result array is same as that of each of given arrays.
4368 * Info on components is copied from the first of the given arrays. Number of components
4369 * in the given arrays must be the same.
4370 * \param [in] arr - a sequence of arrays to include in the result array.
4371 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4372 * The caller is to delete this result array using decrRef() as it is no more
4374 * \throw If all arrays within \a arr are NULL.
4375 * \throw If getNumberOfComponents() of arrays within \a arr.
4377 DataArrayDouble *DataArrayDouble::Aggregate(const std::vector<const DataArrayDouble *>& arr) throw(INTERP_KERNEL::Exception)
4379 std::vector<const DataArrayDouble *> a;
4380 for(std::vector<const DataArrayDouble *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
4384 throw INTERP_KERNEL::Exception("DataArrayDouble::Aggregate : input list must contain at least one NON EMPTY DataArrayDouble !");
4385 std::vector<const DataArrayDouble *>::const_iterator it=a.begin();
4386 int nbOfComp=(*it)->getNumberOfComponents();
4387 int nbt=(*it++)->getNumberOfTuples();
4388 for(int i=1;it!=a.end();it++,i++)
4390 if((*it)->getNumberOfComponents()!=nbOfComp)
4391 throw INTERP_KERNEL::Exception("DataArrayDouble::Aggregate : Nb of components mismatch for array aggregation !");
4392 nbt+=(*it)->getNumberOfTuples();
4394 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
4395 ret->alloc(nbt,nbOfComp);
4396 double *pt=ret->getPointer();
4397 for(it=a.begin();it!=a.end();it++)
4398 pt=std::copy((*it)->getConstPointer(),(*it)->getConstPointer()+(*it)->getNbOfElems(),pt);
4399 ret->copyStringInfoFrom(*(a[0]));
4404 * Returns a new DataArrayDouble by aggregating two given arrays, so that (1) the number
4405 * of components in the result array is a sum of the number of components of given arrays
4406 * and (2) the number of tuples in the result array is same as that of each of given
4407 * arrays. In other words the i-th tuple of result array includes all components of
4408 * i-th tuples of all given arrays.
4409 * Number of tuples in the given arrays must be the same.
4410 * \param [in] a1 - an array to include in the result array.
4411 * \param [in] a2 - another array to include in the result array.
4412 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4413 * The caller is to delete this result array using decrRef() as it is no more
4415 * \throw If both \a a1 and \a a2 are NULL.
4416 * \throw If any given array is not allocated.
4417 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4419 DataArrayDouble *DataArrayDouble::Meld(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception)
4421 std::vector<const DataArrayDouble *> arr(2);
4422 arr[0]=a1; arr[1]=a2;
4427 * Returns a new DataArrayDouble by aggregating all given arrays, so that (1) the number
4428 * of components in the result array is a sum of the number of components of given arrays
4429 * and (2) the number of tuples in the result array is same as that of each of given
4430 * arrays. In other words the i-th tuple of result array includes all components of
4431 * i-th tuples of all given arrays.
4432 * Number of tuples in the given arrays must be the same.
4433 * \param [in] arr - a sequence of arrays to include in the result array.
4434 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4435 * The caller is to delete this result array using decrRef() as it is no more
4437 * \throw If all arrays within \a arr are NULL.
4438 * \throw If any given array is not allocated.
4439 * \throw If getNumberOfTuples() of arrays within \a arr is different.
4441 DataArrayDouble *DataArrayDouble::Meld(const std::vector<const DataArrayDouble *>& arr) throw(INTERP_KERNEL::Exception)
4443 std::vector<const DataArrayDouble *> a;
4444 for(std::vector<const DataArrayDouble *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
4448 throw INTERP_KERNEL::Exception("DataArrayDouble::Meld : input list must contain at least one NON EMPTY DataArrayDouble !");
4449 std::vector<const DataArrayDouble *>::const_iterator it;
4450 for(it=a.begin();it!=a.end();it++)
4451 (*it)->checkAllocated();
4453 int nbOfTuples=(*it)->getNumberOfTuples();
4454 std::vector<int> nbc(a.size());
4455 std::vector<const double *> pts(a.size());
4456 nbc[0]=(*it)->getNumberOfComponents();
4457 pts[0]=(*it++)->getConstPointer();
4458 for(int i=1;it!=a.end();it++,i++)
4460 if(nbOfTuples!=(*it)->getNumberOfTuples())
4461 throw INTERP_KERNEL::Exception("DataArrayDouble::Meld : mismatch of number of tuples !");
4462 nbc[i]=(*it)->getNumberOfComponents();
4463 pts[i]=(*it)->getConstPointer();
4465 int totalNbOfComp=std::accumulate(nbc.begin(),nbc.end(),0);
4466 DataArrayDouble *ret=DataArrayDouble::New();
4467 ret->alloc(nbOfTuples,totalNbOfComp);
4468 double *retPtr=ret->getPointer();
4469 for(int i=0;i<nbOfTuples;i++)
4470 for(int j=0;j<(int)a.size();j++)
4472 retPtr=std::copy(pts[j],pts[j]+nbc[j],retPtr);
4476 for(int i=0;i<(int)a.size();i++)
4477 for(int j=0;j<nbc[i];j++,k++)
4478 ret->setInfoOnComponent(k,a[i]->getInfoOnComponent(j).c_str());
4483 * Returns a new DataArrayDouble containing a dot product of two given arrays, so that
4484 * the i-th tuple of the result array is a sum of products of j-th components of i-th
4485 * tuples of given arrays (\f$ a_i = \sum_{j=1}^n a1_j * a2_j \f$).
4486 * Info on components and name is copied from the first of the given arrays.
4487 * Number of tuples and components in the given arrays must be the same.
4488 * \param [in] a1 - a given array.
4489 * \param [in] a2 - another given array.
4490 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4491 * The caller is to delete this result array using decrRef() as it is no more
4493 * \throw If either \a a1 or \a a2 is NULL.
4494 * \throw If any given array is not allocated.
4495 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4496 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
4498 DataArrayDouble *DataArrayDouble::Dot(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception)
4501 throw INTERP_KERNEL::Exception("DataArrayDouble::Dot : input DataArrayDouble instance is NULL !");
4502 a1->checkAllocated();
4503 a2->checkAllocated();
4504 int nbOfComp=a1->getNumberOfComponents();
4505 if(nbOfComp!=a2->getNumberOfComponents())
4506 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Dot !");
4507 int nbOfTuple=a1->getNumberOfTuples();
4508 if(nbOfTuple!=a2->getNumberOfTuples())
4509 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Dot !");
4510 DataArrayDouble *ret=DataArrayDouble::New();
4511 ret->alloc(nbOfTuple,1);
4512 double *retPtr=ret->getPointer();
4513 const double *a1Ptr=a1->getConstPointer();
4514 const double *a2Ptr=a2->getConstPointer();
4515 for(int i=0;i<nbOfTuple;i++)
4518 for(int j=0;j<nbOfComp;j++)
4519 sum+=a1Ptr[i*nbOfComp+j]*a2Ptr[i*nbOfComp+j];
4522 ret->setInfoOnComponent(0,a1->getInfoOnComponent(0).c_str());
4523 ret->setName(a1->getName().c_str());
4528 * Returns a new DataArrayDouble containing a cross product of two given arrays, so that
4529 * the i-th tuple of the result array contains 3 components of a vector which is a cross
4530 * product of two vectors defined by the i-th tuples of given arrays.
4531 * Info on components is copied from the first of the given arrays.
4532 * Number of tuples in the given arrays must be the same.
4533 * Number of components in the given arrays must be 3.
4534 * \param [in] a1 - a given array.
4535 * \param [in] a2 - another given array.
4536 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4537 * The caller is to delete this result array using decrRef() as it is no more
4539 * \throw If either \a a1 or \a a2 is NULL.
4540 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4541 * \throw If \a a1->getNumberOfComponents() != 3
4542 * \throw If \a a2->getNumberOfComponents() != 3
4544 DataArrayDouble *DataArrayDouble::CrossProduct(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception)
4547 throw INTERP_KERNEL::Exception("DataArrayDouble::CrossProduct : input DataArrayDouble instance is NULL !");
4548 int nbOfComp=a1->getNumberOfComponents();
4549 if(nbOfComp!=a2->getNumberOfComponents())
4550 throw INTERP_KERNEL::Exception("Nb of components mismatch for array crossProduct !");
4552 throw INTERP_KERNEL::Exception("Nb of components must be equal to 3 for array crossProduct !");
4553 int nbOfTuple=a1->getNumberOfTuples();
4554 if(nbOfTuple!=a2->getNumberOfTuples())
4555 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array crossProduct !");
4556 DataArrayDouble *ret=DataArrayDouble::New();
4557 ret->alloc(nbOfTuple,3);
4558 double *retPtr=ret->getPointer();
4559 const double *a1Ptr=a1->getConstPointer();
4560 const double *a2Ptr=a2->getConstPointer();
4561 for(int i=0;i<nbOfTuple;i++)
4563 retPtr[3*i]=a1Ptr[3*i+1]*a2Ptr[3*i+2]-a1Ptr[3*i+2]*a2Ptr[3*i+1];
4564 retPtr[3*i+1]=a1Ptr[3*i+2]*a2Ptr[3*i]-a1Ptr[3*i]*a2Ptr[3*i+2];
4565 retPtr[3*i+2]=a1Ptr[3*i]*a2Ptr[3*i+1]-a1Ptr[3*i+1]*a2Ptr[3*i];
4567 ret->copyStringInfoFrom(*a1);
4572 * Returns a new DataArrayDouble containing maximal values of two given arrays.
4573 * Info on components is copied from the first of the given arrays.
4574 * Number of tuples and components in the given arrays must be the same.
4575 * \param [in] a1 - an array to compare values with another one.
4576 * \param [in] a2 - another array to compare values with the first one.
4577 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4578 * The caller is to delete this result array using decrRef() as it is no more
4580 * \throw If either \a a1 or \a a2 is NULL.
4581 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4582 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
4584 DataArrayDouble *DataArrayDouble::Max(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception)
4587 throw INTERP_KERNEL::Exception("DataArrayDouble::Max : input DataArrayDouble instance is NULL !");
4588 int nbOfComp=a1->getNumberOfComponents();
4589 if(nbOfComp!=a2->getNumberOfComponents())
4590 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Max !");
4591 int nbOfTuple=a1->getNumberOfTuples();
4592 if(nbOfTuple!=a2->getNumberOfTuples())
4593 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Max !");
4594 DataArrayDouble *ret=DataArrayDouble::New();
4595 ret->alloc(nbOfTuple,nbOfComp);
4596 double *retPtr=ret->getPointer();
4597 const double *a1Ptr=a1->getConstPointer();
4598 const double *a2Ptr=a2->getConstPointer();
4599 int nbElem=nbOfTuple*nbOfComp;
4600 for(int i=0;i<nbElem;i++)
4601 retPtr[i]=std::max(a1Ptr[i],a2Ptr[i]);
4602 ret->copyStringInfoFrom(*a1);
4607 * Returns a new DataArrayDouble containing minimal values of two given arrays.
4608 * Info on components is copied from the first of the given arrays.
4609 * Number of tuples and components in the given arrays must be the same.
4610 * \param [in] a1 - an array to compare values with another one.
4611 * \param [in] a2 - another array to compare values with the first one.
4612 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4613 * The caller is to delete this result array using decrRef() as it is no more
4615 * \throw If either \a a1 or \a a2 is NULL.
4616 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4617 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
4619 DataArrayDouble *DataArrayDouble::Min(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception)
4622 throw INTERP_KERNEL::Exception("DataArrayDouble::Min : input DataArrayDouble instance is NULL !");
4623 int nbOfComp=a1->getNumberOfComponents();
4624 if(nbOfComp!=a2->getNumberOfComponents())
4625 throw INTERP_KERNEL::Exception("Nb of components mismatch for array min !");
4626 int nbOfTuple=a1->getNumberOfTuples();
4627 if(nbOfTuple!=a2->getNumberOfTuples())
4628 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array min !");
4629 DataArrayDouble *ret=DataArrayDouble::New();
4630 ret->alloc(nbOfTuple,nbOfComp);
4631 double *retPtr=ret->getPointer();
4632 const double *a1Ptr=a1->getConstPointer();
4633 const double *a2Ptr=a2->getConstPointer();
4634 int nbElem=nbOfTuple*nbOfComp;
4635 for(int i=0;i<nbElem;i++)
4636 retPtr[i]=std::min(a1Ptr[i],a2Ptr[i]);
4637 ret->copyStringInfoFrom(*a1);
4642 * Returns a new DataArrayDouble that is a sum of two given arrays. There are 3
4644 * 1. The arrays have same number of tuples and components. Then each value of
4645 * the result array (_a_) is a sum of the corresponding values of \a a1 and \a a2,
4646 * i.e.: _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, j ].
4647 * 2. The arrays have same number of tuples and one array, say _a2_, has one
4649 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, 0 ].
4650 * 3. The arrays have same number of components and one array, say _a2_, has one
4652 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ 0, j ].
4654 * Info on components is copied either from the first array (in the first case) or from
4655 * the array with maximal number of elements (getNbOfElems()).
4656 * \param [in] a1 - an array to sum up.
4657 * \param [in] a2 - another array to sum up.
4658 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4659 * The caller is to delete this result array using decrRef() as it is no more
4661 * \throw If either \a a1 or \a a2 is NULL.
4662 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
4663 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
4664 * none of them has number of tuples or components equal to 1.
4666 DataArrayDouble *DataArrayDouble::Add(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception)
4669 throw INTERP_KERNEL::Exception("DataArrayDouble::Add : input DataArrayDouble instance is NULL !");
4670 int nbOfTuple=a1->getNumberOfTuples();
4671 int nbOfTuple2=a2->getNumberOfTuples();
4672 int nbOfComp=a1->getNumberOfComponents();
4673 int nbOfComp2=a2->getNumberOfComponents();
4674 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=0;
4675 if(nbOfTuple==nbOfTuple2)
4677 if(nbOfComp==nbOfComp2)
4679 ret=DataArrayDouble::New();
4680 ret->alloc(nbOfTuple,nbOfComp);
4681 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::plus<double>());
4682 ret->copyStringInfoFrom(*a1);
4686 int nbOfCompMin,nbOfCompMax;
4687 const DataArrayDouble *aMin, *aMax;
4688 if(nbOfComp>nbOfComp2)
4690 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
4695 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
4700 ret=DataArrayDouble::New();
4701 ret->alloc(nbOfTuple,nbOfCompMax);
4702 const double *aMinPtr=aMin->getConstPointer();
4703 const double *aMaxPtr=aMax->getConstPointer();
4704 double *res=ret->getPointer();
4705 for(int i=0;i<nbOfTuple;i++)
4706 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::plus<double>(),aMinPtr[i]));
4707 ret->copyStringInfoFrom(*aMax);
4710 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
4713 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
4715 if(nbOfComp==nbOfComp2)
4717 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
4718 const DataArrayDouble *aMin=nbOfTuple>nbOfTuple2?a2:a1;
4719 const DataArrayDouble *aMax=nbOfTuple>nbOfTuple2?a1:a2;
4720 const double *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
4721 ret=DataArrayDouble::New();
4722 ret->alloc(nbOfTupleMax,nbOfComp);
4723 double *res=ret->getPointer();
4724 for(int i=0;i<nbOfTupleMax;i++)
4725 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::plus<double>());
4726 ret->copyStringInfoFrom(*aMax);
4729 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
4732 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Add !");
4737 * Adds values of another DataArrayDouble to values of \a this one. There are 3
4739 * 1. The arrays have same number of tuples and components. Then each value of
4740 * \a other array is added to the corresponding value of \a this array, i.e.:
4741 * _a_ [ i, j ] += _other_ [ i, j ].
4742 * 2. The arrays have same number of tuples and \a other array has one component. Then
4743 * _a_ [ i, j ] += _other_ [ i, 0 ].
4744 * 3. The arrays have same number of components and \a other array has one tuple. Then
4745 * _a_ [ i, j ] += _a2_ [ 0, j ].
4747 * \param [in] other - an array to add to \a this one.
4748 * \throw If \a other is NULL.
4749 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
4750 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
4751 * \a other has number of both tuples and components not equal to 1.
4753 void DataArrayDouble::addEqual(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception)
4756 throw INTERP_KERNEL::Exception("DataArrayDouble::addEqual : input DataArrayDouble instance is NULL !");
4757 const char *msg="Nb of tuples mismatch for DataArrayDouble::addEqual !";
4759 other->checkAllocated();
4760 int nbOfTuple=getNumberOfTuples();
4761 int nbOfTuple2=other->getNumberOfTuples();
4762 int nbOfComp=getNumberOfComponents();
4763 int nbOfComp2=other->getNumberOfComponents();
4764 if(nbOfTuple==nbOfTuple2)
4766 if(nbOfComp==nbOfComp2)
4768 std::transform(begin(),end(),other->begin(),getPointer(),std::plus<double>());
4770 else if(nbOfComp2==1)
4772 double *ptr=getPointer();
4773 const double *ptrc=other->getConstPointer();
4774 for(int i=0;i<nbOfTuple;i++)
4775 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::plus<double>(),*ptrc++));
4778 throw INTERP_KERNEL::Exception(msg);
4780 else if(nbOfTuple2==1)
4782 if(nbOfComp2==nbOfComp)
4784 double *ptr=getPointer();
4785 const double *ptrc=other->getConstPointer();
4786 for(int i=0;i<nbOfTuple;i++)
4787 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::plus<double>());
4790 throw INTERP_KERNEL::Exception(msg);
4793 throw INTERP_KERNEL::Exception(msg);
4798 * Returns a new DataArrayDouble that is a subtraction of two given arrays. There are 3
4800 * 1. The arrays have same number of tuples and components. Then each value of
4801 * the result array (_a_) is a subtraction of the corresponding values of \a a1 and
4802 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, j ].
4803 * 2. The arrays have same number of tuples and one array, say _a2_, has one
4805 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, 0 ].
4806 * 3. The arrays have same number of components and one array, say _a2_, has one
4808 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ 0, j ].
4810 * Info on components is copied either from the first array (in the first case) or from
4811 * the array with maximal number of elements (getNbOfElems()).
4812 * \param [in] a1 - an array to subtract from.
4813 * \param [in] a2 - an array to subtract.
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 either \a a1 or \a a2 is NULL.
4818 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
4819 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
4820 * none of them has number of tuples or components equal to 1.
4822 DataArrayDouble *DataArrayDouble::Substract(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception)
4825 throw INTERP_KERNEL::Exception("DataArrayDouble::Substract : input DataArrayDouble instance is NULL !");
4826 int nbOfTuple1=a1->getNumberOfTuples();
4827 int nbOfTuple2=a2->getNumberOfTuples();
4828 int nbOfComp1=a1->getNumberOfComponents();
4829 int nbOfComp2=a2->getNumberOfComponents();
4830 if(nbOfTuple2==nbOfTuple1)
4832 if(nbOfComp1==nbOfComp2)
4834 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
4835 ret->alloc(nbOfTuple2,nbOfComp1);
4836 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::minus<double>());
4837 ret->copyStringInfoFrom(*a1);
4840 else if(nbOfComp2==1)
4842 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
4843 ret->alloc(nbOfTuple1,nbOfComp1);
4844 const double *a2Ptr=a2->getConstPointer();
4845 const double *a1Ptr=a1->getConstPointer();
4846 double *res=ret->getPointer();
4847 for(int i=0;i<nbOfTuple1;i++)
4848 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::minus<double>(),a2Ptr[i]));
4849 ret->copyStringInfoFrom(*a1);
4854 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
4858 else if(nbOfTuple2==1)
4860 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
4861 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
4862 ret->alloc(nbOfTuple1,nbOfComp1);
4863 const double *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
4864 double *pt=ret->getPointer();
4865 for(int i=0;i<nbOfTuple1;i++)
4866 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::minus<double>());
4867 ret->copyStringInfoFrom(*a1);
4872 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Substract !");//will always throw an exception
4878 * Subtract values of another DataArrayDouble from values of \a this one. There are 3
4880 * 1. The arrays have same number of tuples and components. Then each value of
4881 * \a other array is subtracted from the corresponding value of \a this array, i.e.:
4882 * _a_ [ i, j ] -= _other_ [ i, j ].
4883 * 2. The arrays have same number of tuples and \a other array has one component. Then
4884 * _a_ [ i, j ] -= _other_ [ i, 0 ].
4885 * 3. The arrays have same number of components and \a other array has one tuple. Then
4886 * _a_ [ i, j ] -= _a2_ [ 0, j ].
4888 * \param [in] other - an array to subtract from \a this one.
4889 * \throw If \a other is NULL.
4890 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
4891 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
4892 * \a other has number of both tuples and components not equal to 1.
4894 void DataArrayDouble::substractEqual(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception)
4897 throw INTERP_KERNEL::Exception("DataArrayDouble::substractEqual : input DataArrayDouble instance is NULL !");
4898 const char *msg="Nb of tuples mismatch for DataArrayDouble::substractEqual !";
4900 other->checkAllocated();
4901 int nbOfTuple=getNumberOfTuples();
4902 int nbOfTuple2=other->getNumberOfTuples();
4903 int nbOfComp=getNumberOfComponents();
4904 int nbOfComp2=other->getNumberOfComponents();
4905 if(nbOfTuple==nbOfTuple2)
4907 if(nbOfComp==nbOfComp2)
4909 std::transform(begin(),end(),other->begin(),getPointer(),std::minus<double>());
4911 else if(nbOfComp2==1)
4913 double *ptr=getPointer();
4914 const double *ptrc=other->getConstPointer();
4915 for(int i=0;i<nbOfTuple;i++)
4916 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::minus<double>(),*ptrc++));
4919 throw INTERP_KERNEL::Exception(msg);
4921 else if(nbOfTuple2==1)
4923 if(nbOfComp2==nbOfComp)
4925 double *ptr=getPointer();
4926 const double *ptrc=other->getConstPointer();
4927 for(int i=0;i<nbOfTuple;i++)
4928 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::minus<double>());
4931 throw INTERP_KERNEL::Exception(msg);
4934 throw INTERP_KERNEL::Exception(msg);
4939 * Returns a new DataArrayDouble that is a product of two given arrays. There are 3
4941 * 1. The arrays have same number of tuples and components. Then each value of
4942 * the result array (_a_) is a product of the corresponding values of \a a1 and
4943 * \a a2, i.e. _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, j ].
4944 * 2. The arrays have same number of tuples and one array, say _a2_, has one
4946 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, 0 ].
4947 * 3. The arrays have same number of components and one array, say _a2_, has one
4949 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ 0, j ].
4951 * Info on components is copied either from the first array (in the first case) or from
4952 * the array with maximal number of elements (getNbOfElems()).
4953 * \param [in] a1 - a factor array.
4954 * \param [in] a2 - another factor array.
4955 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4956 * The caller is to delete this result array using decrRef() as it is no more
4958 * \throw If either \a a1 or \a a2 is NULL.
4959 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
4960 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
4961 * none of them has number of tuples or components equal to 1.
4963 DataArrayDouble *DataArrayDouble::Multiply(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception)
4966 throw INTERP_KERNEL::Exception("DataArrayDouble::Multiply : input DataArrayDouble instance is NULL !");
4967 int nbOfTuple=a1->getNumberOfTuples();
4968 int nbOfTuple2=a2->getNumberOfTuples();
4969 int nbOfComp=a1->getNumberOfComponents();
4970 int nbOfComp2=a2->getNumberOfComponents();
4971 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=0;
4972 if(nbOfTuple==nbOfTuple2)
4974 if(nbOfComp==nbOfComp2)
4976 ret=DataArrayDouble::New();
4977 ret->alloc(nbOfTuple,nbOfComp);
4978 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::multiplies<double>());
4979 ret->copyStringInfoFrom(*a1);
4983 int nbOfCompMin,nbOfCompMax;
4984 const DataArrayDouble *aMin, *aMax;
4985 if(nbOfComp>nbOfComp2)
4987 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
4992 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
4997 ret=DataArrayDouble::New();
4998 ret->alloc(nbOfTuple,nbOfCompMax);
4999 const double *aMinPtr=aMin->getConstPointer();
5000 const double *aMaxPtr=aMax->getConstPointer();
5001 double *res=ret->getPointer();
5002 for(int i=0;i<nbOfTuple;i++)
5003 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::multiplies<double>(),aMinPtr[i]));
5004 ret->copyStringInfoFrom(*aMax);
5007 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
5010 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
5012 if(nbOfComp==nbOfComp2)
5014 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
5015 const DataArrayDouble *aMin=nbOfTuple>nbOfTuple2?a2:a1;
5016 const DataArrayDouble *aMax=nbOfTuple>nbOfTuple2?a1:a2;
5017 const double *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
5018 ret=DataArrayDouble::New();
5019 ret->alloc(nbOfTupleMax,nbOfComp);
5020 double *res=ret->getPointer();
5021 for(int i=0;i<nbOfTupleMax;i++)
5022 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::multiplies<double>());
5023 ret->copyStringInfoFrom(*aMax);
5026 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
5029 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Multiply !");
5034 * Multiply values of another DataArrayDouble to values of \a this one. There are 3
5036 * 1. The arrays have same number of tuples and components. Then each value of
5037 * \a other array is multiplied to the corresponding value of \a this array, i.e.
5038 * _this_ [ i, j ] *= _other_ [ i, j ].
5039 * 2. The arrays have same number of tuples and \a other array has one component. Then
5040 * _this_ [ i, j ] *= _other_ [ i, 0 ].
5041 * 3. The arrays have same number of components and \a other array has one tuple. Then
5042 * _this_ [ i, j ] *= _a2_ [ 0, j ].
5044 * \param [in] other - an array to multiply to \a this one.
5045 * \throw If \a other is NULL.
5046 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
5047 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
5048 * \a other has number of both tuples and components not equal to 1.
5050 void DataArrayDouble::multiplyEqual(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception)
5053 throw INTERP_KERNEL::Exception("DataArrayDouble::multiplyEqual : input DataArrayDouble instance is NULL !");
5054 const char *msg="Nb of tuples mismatch for DataArrayDouble::multiplyEqual !";
5056 other->checkAllocated();
5057 int nbOfTuple=getNumberOfTuples();
5058 int nbOfTuple2=other->getNumberOfTuples();
5059 int nbOfComp=getNumberOfComponents();
5060 int nbOfComp2=other->getNumberOfComponents();
5061 if(nbOfTuple==nbOfTuple2)
5063 if(nbOfComp==nbOfComp2)
5065 std::transform(begin(),end(),other->begin(),getPointer(),std::multiplies<double>());
5067 else if(nbOfComp2==1)
5069 double *ptr=getPointer();
5070 const double *ptrc=other->getConstPointer();
5071 for(int i=0;i<nbOfTuple;i++)
5072 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::multiplies<double>(),*ptrc++));
5075 throw INTERP_KERNEL::Exception(msg);
5077 else if(nbOfTuple2==1)
5079 if(nbOfComp2==nbOfComp)
5081 double *ptr=getPointer();
5082 const double *ptrc=other->getConstPointer();
5083 for(int i=0;i<nbOfTuple;i++)
5084 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::multiplies<double>());
5087 throw INTERP_KERNEL::Exception(msg);
5090 throw INTERP_KERNEL::Exception(msg);
5095 * Returns a new DataArrayDouble that is a division of two given arrays. There are 3
5097 * 1. The arrays have same number of tuples and components. Then each value of
5098 * the result array (_a_) is a division of the corresponding values of \a a1 and
5099 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, j ].
5100 * 2. The arrays have same number of tuples and one array, say _a2_, has one
5102 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, 0 ].
5103 * 3. The arrays have same number of components and one array, say _a2_, has one
5105 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ 0, j ].
5107 * Info on components is copied either from the first array (in the first case) or from
5108 * the array with maximal number of elements (getNbOfElems()).
5109 * \warning No check of division by zero is performed!
5110 * \param [in] a1 - a numerator array.
5111 * \param [in] a2 - a denominator array.
5112 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5113 * The caller is to delete this result array using decrRef() as it is no more
5115 * \throw If either \a a1 or \a a2 is NULL.
5116 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
5117 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
5118 * none of them has number of tuples or components equal to 1.
5120 DataArrayDouble *DataArrayDouble::Divide(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception)
5123 throw INTERP_KERNEL::Exception("DataArrayDouble::Divide : input DataArrayDouble instance is NULL !");
5124 int nbOfTuple1=a1->getNumberOfTuples();
5125 int nbOfTuple2=a2->getNumberOfTuples();
5126 int nbOfComp1=a1->getNumberOfComponents();
5127 int nbOfComp2=a2->getNumberOfComponents();
5128 if(nbOfTuple2==nbOfTuple1)
5130 if(nbOfComp1==nbOfComp2)
5132 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5133 ret->alloc(nbOfTuple2,nbOfComp1);
5134 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::divides<double>());
5135 ret->copyStringInfoFrom(*a1);
5138 else if(nbOfComp2==1)
5140 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5141 ret->alloc(nbOfTuple1,nbOfComp1);
5142 const double *a2Ptr=a2->getConstPointer();
5143 const double *a1Ptr=a1->getConstPointer();
5144 double *res=ret->getPointer();
5145 for(int i=0;i<nbOfTuple1;i++)
5146 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::divides<double>(),a2Ptr[i]));
5147 ret->copyStringInfoFrom(*a1);
5152 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
5156 else if(nbOfTuple2==1)
5158 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
5159 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5160 ret->alloc(nbOfTuple1,nbOfComp1);
5161 const double *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
5162 double *pt=ret->getPointer();
5163 for(int i=0;i<nbOfTuple1;i++)
5164 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::divides<double>());
5165 ret->copyStringInfoFrom(*a1);
5170 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Divide !");//will always throw an exception
5176 * Divide values of \a this array by values of another DataArrayDouble. There are 3
5178 * 1. The arrays have same number of tuples and components. Then each value of
5179 * \a this array is divided by the corresponding value of \a other one, i.e.:
5180 * _a_ [ i, j ] /= _other_ [ i, j ].
5181 * 2. The arrays have same number of tuples and \a other array has one component. Then
5182 * _a_ [ i, j ] /= _other_ [ i, 0 ].
5183 * 3. The arrays have same number of components and \a other array has one tuple. Then
5184 * _a_ [ i, j ] /= _a2_ [ 0, j ].
5186 * \warning No check of division by zero is performed!
5187 * \param [in] other - an array to divide \a this one by.
5188 * \throw If \a other is NULL.
5189 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
5190 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
5191 * \a other has number of both tuples and components not equal to 1.
5193 void DataArrayDouble::divideEqual(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception)
5196 throw INTERP_KERNEL::Exception("DataArrayDouble::divideEqual : input DataArrayDouble instance is NULL !");
5197 const char *msg="Nb of tuples mismatch for DataArrayDouble::divideEqual !";
5199 other->checkAllocated();
5200 int nbOfTuple=getNumberOfTuples();
5201 int nbOfTuple2=other->getNumberOfTuples();
5202 int nbOfComp=getNumberOfComponents();
5203 int nbOfComp2=other->getNumberOfComponents();
5204 if(nbOfTuple==nbOfTuple2)
5206 if(nbOfComp==nbOfComp2)
5208 std::transform(begin(),end(),other->begin(),getPointer(),std::divides<double>());
5210 else if(nbOfComp2==1)
5212 double *ptr=getPointer();
5213 const double *ptrc=other->getConstPointer();
5214 for(int i=0;i<nbOfTuple;i++)
5215 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::divides<double>(),*ptrc++));
5218 throw INTERP_KERNEL::Exception(msg);
5220 else if(nbOfTuple2==1)
5222 if(nbOfComp2==nbOfComp)
5224 double *ptr=getPointer();
5225 const double *ptrc=other->getConstPointer();
5226 for(int i=0;i<nbOfTuple;i++)
5227 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::divides<double>());
5230 throw INTERP_KERNEL::Exception(msg);
5233 throw INTERP_KERNEL::Exception(msg);
5238 * Returns a new DataArrayDouble that is the result of pow of two given arrays. There are 3
5241 * \param [in] a1 - an array to pow up.
5242 * \param [in] a2 - another array to sum up.
5243 * \return DataArrayDouble * - the new instance of DataArrayDouble.
5244 * The caller is to delete this result array using decrRef() as it is no more
5246 * \throw If either \a a1 or \a a2 is NULL.
5247 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
5248 * \throw If \a a1->getNumberOfComponents() != 1 or \a a2->getNumberOfComponents() != 1.
5249 * \throw If there is a negative value in \a a1.
5251 DataArrayDouble *DataArrayDouble::Pow(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception)
5254 throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : at least one of input instances is null !");
5255 int nbOfTuple=a1->getNumberOfTuples();
5256 int nbOfTuple2=a2->getNumberOfTuples();
5257 int nbOfComp=a1->getNumberOfComponents();
5258 int nbOfComp2=a2->getNumberOfComponents();
5259 if(nbOfTuple!=nbOfTuple2)
5260 throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : number of tuples mismatches !");
5261 if(nbOfComp!=1 || nbOfComp2!=1)
5262 throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : number of components of both arrays must be equal to 1 !");
5263 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(nbOfTuple,1);
5264 const double *ptr1(a1->begin()),*ptr2(a2->begin());
5265 double *ptr=ret->getPointer();
5266 for(int i=0;i<nbOfTuple;i++,ptr1++,ptr2++,ptr++)
5270 *ptr=pow(*ptr1,*ptr2);
5274 std::ostringstream oss; oss << "DataArrayDouble::Pow : on tuple #" << i << " of a1 value is < 0 (" << *ptr1 << ") !";
5275 throw INTERP_KERNEL::Exception(oss.str().c_str());
5282 * Apply pow on values of another DataArrayDouble to values of \a this one.
5284 * \param [in] other - an array to pow to \a this one.
5285 * \throw If \a other is NULL.
5286 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples()
5287 * \throw If \a this->getNumberOfComponents() != 1 or \a other->getNumberOfComponents() != 1
5288 * \throw If there is a negative value in \a this.
5290 void DataArrayDouble::powEqual(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception)
5293 throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : input instance is null !");
5294 int nbOfTuple=getNumberOfTuples();
5295 int nbOfTuple2=other->getNumberOfTuples();
5296 int nbOfComp=getNumberOfComponents();
5297 int nbOfComp2=other->getNumberOfComponents();
5298 if(nbOfTuple!=nbOfTuple2)
5299 throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : number of tuples mismatches !");
5300 if(nbOfComp!=1 || nbOfComp2!=1)
5301 throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : number of components of both arrays must be equal to 1 !");
5302 double *ptr=getPointer();
5303 const double *ptrc=other->begin();
5304 for(int i=0;i<nbOfTuple;i++,ptrc++,ptr++)
5307 *ptr=pow(*ptr,*ptrc);
5310 std::ostringstream oss; oss << "DataArrayDouble::powEqual : on tuple #" << i << " of this value is < 0 (" << *ptr << ") !";
5311 throw INTERP_KERNEL::Exception(oss.str().c_str());
5318 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5321 void DataArrayDouble::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
5326 tinyInfo[0]=getNumberOfTuples();
5327 tinyInfo[1]=getNumberOfComponents();
5337 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5340 void DataArrayDouble::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
5344 int nbOfCompo=getNumberOfComponents();
5345 tinyInfo.resize(nbOfCompo+1);
5346 tinyInfo[0]=getName();
5347 for(int i=0;i<nbOfCompo;i++)
5348 tinyInfo[i+1]=getInfoOnComponent(i);
5353 tinyInfo[0]=getName();
5358 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5359 * This method returns if a feeding is needed.
5361 bool DataArrayDouble::resizeForUnserialization(const std::vector<int>& tinyInfoI)
5363 int nbOfTuple=tinyInfoI[0];
5364 int nbOfComp=tinyInfoI[1];
5365 if(nbOfTuple!=-1 || nbOfComp!=-1)
5367 alloc(nbOfTuple,nbOfComp);
5374 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5376 void DataArrayDouble::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<std::string>& tinyInfoS)
5378 setName(tinyInfoS[0].c_str());
5381 int nbOfCompo=getNumberOfComponents();
5382 for(int i=0;i<nbOfCompo;i++)
5383 setInfoOnComponent(i,tinyInfoS[i+1].c_str());
5387 DataArrayDoubleIterator::DataArrayDoubleIterator(DataArrayDouble *da):_da(da),_tuple_id(0),_nb_comp(0),_nb_tuple(0)
5392 if(_da->isAllocated())
5394 _nb_comp=da->getNumberOfComponents();
5395 _nb_tuple=da->getNumberOfTuples();
5396 _pt=da->getPointer();
5401 DataArrayDoubleIterator::~DataArrayDoubleIterator()
5407 DataArrayDoubleTuple *DataArrayDoubleIterator::nextt() throw(INTERP_KERNEL::Exception)
5409 if(_tuple_id<_nb_tuple)
5412 DataArrayDoubleTuple *ret=new DataArrayDoubleTuple(_pt,_nb_comp);
5420 DataArrayDoubleTuple::DataArrayDoubleTuple(double *pt, int nbOfComp):_pt(pt),_nb_of_compo(nbOfComp)
5425 std::string DataArrayDoubleTuple::repr() const throw(INTERP_KERNEL::Exception)
5427 std::ostringstream oss; oss.precision(17); oss << "(";
5428 for(int i=0;i<_nb_of_compo-1;i++)
5429 oss << _pt[i] << ", ";
5430 oss << _pt[_nb_of_compo-1] << ")";
5434 double DataArrayDoubleTuple::doubleValue() const throw(INTERP_KERNEL::Exception)
5438 throw INTERP_KERNEL::Exception("DataArrayDoubleTuple::doubleValue : DataArrayDoubleTuple instance has not exactly 1 component -> Not possible to convert it into a double precision float !");
5442 * This method returns a newly allocated instance the caller should dealed with by a ParaMEDMEM::DataArrayDouble::decrRef.
5443 * This method performs \b no copy of data. The content is only referenced using ParaMEDMEM::DataArrayDouble::useArray with ownership set to \b false.
5444 * 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
5445 * \b nbOfCompo=1 and \bnbOfTuples==this->_nb_of_elem.
5447 DataArrayDouble *DataArrayDoubleTuple::buildDADouble(int nbOfTuples, int nbOfCompo) const throw(INTERP_KERNEL::Exception)
5449 if((_nb_of_compo==nbOfCompo && nbOfTuples==1) || (_nb_of_compo==nbOfTuples && nbOfCompo==1))
5451 DataArrayDouble *ret=DataArrayDouble::New();
5452 ret->useExternalArrayWithRWAccess(_pt,nbOfTuples,nbOfCompo);
5457 std::ostringstream oss; oss << "DataArrayDoubleTuple::buildDADouble : unable to build a requested DataArrayDouble instance with nbofTuple=" << nbOfTuples << " and nbOfCompo=" << nbOfCompo;
5458 oss << ".\nBecause the number of elements in this is " << _nb_of_compo << " !";
5459 throw INTERP_KERNEL::Exception(oss.str().c_str());
5464 * Returns a new instance of DataArrayInt. The caller is to delete this array
5465 * using decrRef() as it is no more needed.
5467 DataArrayInt *DataArrayInt::New()
5469 return new DataArrayInt;
5473 * Checks if raw data is allocated. Read more on the raw data
5474 * in \ref MEDCouplingArrayBasicsTuplesAndCompo "DataArrays infos" for more information.
5475 * \return bool - \a true if the raw data is allocated, \a false else.
5477 bool DataArrayInt::isAllocated() const throw(INTERP_KERNEL::Exception)
5479 return getConstPointer()!=0;
5483 * Checks if raw data is allocated and throws an exception if it is not the case.
5484 * \throw If the raw data is not allocated.
5486 void DataArrayInt::checkAllocated() const throw(INTERP_KERNEL::Exception)
5489 throw INTERP_KERNEL::Exception("DataArrayInt::checkAllocated : Array is defined but not allocated ! Call alloc or setValues method first !");
5493 * This method desallocated \a this without modification of informations relative to the components.
5494 * After call of this method, DataArrayInt::isAllocated will return false.
5495 * If \a this is already not allocated, \a this is let unchanged.
5497 void DataArrayInt::desallocate() throw(INTERP_KERNEL::Exception)
5502 std::size_t DataArrayInt::getHeapMemorySize() const
5504 std::size_t sz=_mem.getNbOfElemAllocated();
5506 return DataArray::getHeapMemorySize()+sz;
5510 * Returns the only one value in \a this, if and only if number of elements
5511 * (nb of tuples * nb of components) is equal to 1, and that \a this is allocated.
5512 * \return double - the sole value stored in \a this array.
5513 * \throw If at least one of conditions stated above is not fulfilled.
5515 int DataArrayInt::intValue() const throw(INTERP_KERNEL::Exception)
5519 if(getNbOfElems()==1)
5521 return *getConstPointer();
5524 throw INTERP_KERNEL::Exception("DataArrayInt::intValue : DataArrayInt instance is allocated but number of elements is not equal to 1 !");
5527 throw INTERP_KERNEL::Exception("DataArrayInt::intValue : DataArrayInt instance is not allocated !");
5531 * Returns an integer value characterizing \a this array, which is useful for a quick
5532 * comparison of many instances of DataArrayInt.
5533 * \return int - the hash value.
5534 * \throw If \a this is not allocated.
5536 int DataArrayInt::getHashCode() const throw(INTERP_KERNEL::Exception)
5539 std::size_t nbOfElems=getNbOfElems();
5540 int ret=nbOfElems*65536;
5545 const int *pt=begin();
5546 for(std::size_t i=0;i<nbOfElems;i+=delta)
5547 ret0+=pt[i] & 0x1FFF;
5552 * Checks the number of tuples.
5553 * \return bool - \a true if getNumberOfTuples() == 0, \a false else.
5554 * \throw If \a this is not allocated.
5556 bool DataArrayInt::empty() const throw(INTERP_KERNEL::Exception)
5559 return getNumberOfTuples()==0;
5563 * Returns a full copy of \a this. For more info on copying data arrays see
5564 * \ref MEDCouplingArrayBasicsCopyDeep.
5565 * \return DataArrayInt * - a new instance of DataArrayInt.
5567 DataArrayInt *DataArrayInt::deepCpy() const throw(INTERP_KERNEL::Exception)
5569 return new DataArrayInt(*this);
5573 * Returns either a \a deep or \a shallow copy of this array. For more info see
5574 * \ref MEDCouplingArrayBasicsCopyDeep and \ref MEDCouplingArrayBasicsCopyShallow.
5575 * \param [in] dCpy - if \a true, a deep copy is returned, else, a shallow one.
5576 * \return DataArrayInt * - either a new instance of DataArrayInt (if \a dCpy
5577 * == \a true) or \a this instance (if \a dCpy == \a false).
5579 DataArrayInt *DataArrayInt::performCpy(bool dCpy) const throw(INTERP_KERNEL::Exception)
5586 return const_cast<DataArrayInt *>(this);
5591 * Copies all the data from another DataArrayInt. For more info see
5592 * \ref MEDCouplingArrayBasicsCopyDeepAssign.
5593 * \param [in] other - another instance of DataArrayInt to copy data from.
5594 * \throw If the \a other is not allocated.
5596 void DataArrayInt::cpyFrom(const DataArrayInt& other) throw(INTERP_KERNEL::Exception)
5598 other.checkAllocated();
5599 int nbOfTuples=other.getNumberOfTuples();
5600 int nbOfComp=other.getNumberOfComponents();
5601 allocIfNecessary(nbOfTuples,nbOfComp);
5602 std::size_t nbOfElems=(std::size_t)nbOfTuples*nbOfComp;
5603 int *pt=getPointer();
5604 const int *ptI=other.getConstPointer();
5605 for(std::size_t i=0;i<nbOfElems;i++)
5607 copyStringInfoFrom(other);
5611 * This method reserve nbOfElems elements in memory ( nbOfElems*4 bytes ) \b without impacting the number of tuples in \a this.
5612 * 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.
5613 * If \a this has not already been allocated, number of components is set to one.
5614 * This method allows to reduce number of reallocations on invokation of DataArrayInt::pushBackSilent and DataArrayInt::pushBackValsSilent on \a this.
5616 * \sa DataArrayInt::pack, DataArrayInt::pushBackSilent, DataArrayInt::pushBackValsSilent
5618 void DataArrayInt::reserve(std::size_t nbOfElems) throw(INTERP_KERNEL::Exception)
5620 int nbCompo=getNumberOfComponents();
5623 _mem.reserve(nbOfElems);
5627 _mem.reserve(nbOfElems);
5628 _info_on_compo.resize(1);
5631 throw INTERP_KERNEL::Exception("DataArrayInt::reserve : not available for DataArrayInt with number of components different than 1 !");
5635 * 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
5636 * of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
5638 * \param [in] val the value to be added in \a this
5639 * \throw If \a this has already been allocated with number of components different from one.
5640 * \sa DataArrayInt::pushBackValsSilent
5642 void DataArrayInt::pushBackSilent(int val) throw(INTERP_KERNEL::Exception)
5644 int nbCompo=getNumberOfComponents();
5649 _info_on_compo.resize(1);
5653 throw INTERP_KERNEL::Exception("DataArrayInt::pushBackSilent : not available for DataArrayInt with number of components different than 1 !");
5657 * 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
5658 * of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
5660 * \param [in] valsBg - an array of values to push at the end of \this.
5661 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
5662 * the last value of \a valsBg is \a valsEnd[ -1 ].
5663 * \throw If \a this has already been allocated with number of components different from one.
5664 * \sa DataArrayInt::pushBackSilent
5666 void DataArrayInt::pushBackValsSilent(const int *valsBg, const int *valsEnd) throw(INTERP_KERNEL::Exception)
5668 int nbCompo=getNumberOfComponents();
5670 _mem.insertAtTheEnd(valsBg,valsEnd);
5673 _info_on_compo.resize(1);
5674 _mem.insertAtTheEnd(valsBg,valsEnd);
5677 throw INTERP_KERNEL::Exception("DataArrayInt::pushBackValsSilent : not available for DataArrayInt with number of components different than 1 !");
5681 * This method returns silently ( without updating time label in \a this ) the last value, if any and suppress it.
5682 * \throw If \a this is already empty.
5683 * \throw If \a this has number of components different from one.
5685 int DataArrayInt::popBackSilent() throw(INTERP_KERNEL::Exception)
5687 if(getNumberOfComponents()==1)
5688 return _mem.popBack();
5690 throw INTERP_KERNEL::Exception("DataArrayInt::popBackSilent : not available for DataArrayInt with number of components different than 1 !");
5694 * 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.
5696 * \sa DataArrayInt::getHeapMemorySize, DataArrayInt::reserve
5698 void DataArrayInt::pack() const throw(INTERP_KERNEL::Exception)
5704 * Allocates the raw data in memory. If exactly as same memory as needed already
5705 * allocated, it is not re-allocated.
5706 * \param [in] nbOfTuple - number of tuples of data to allocate.
5707 * \param [in] nbOfCompo - number of components of data to allocate.
5708 * \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
5710 void DataArrayInt::allocIfNecessary(int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception)
5714 if(nbOfTuple!=getNumberOfTuples() || nbOfCompo!=getNumberOfComponents())
5715 alloc(nbOfTuple,nbOfCompo);
5718 alloc(nbOfTuple,nbOfCompo);
5722 * Allocates the raw data in memory. If the memory was already allocated, then it is
5723 * freed and re-allocated. See an example of this method use
5724 * \ref MEDCouplingArraySteps1WC "here".
5725 * \param [in] nbOfTuple - number of tuples of data to allocate.
5726 * \param [in] nbOfCompo - number of components of data to allocate.
5727 * \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
5729 void DataArrayInt::alloc(int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception)
5731 if(nbOfTuple<0 || nbOfCompo<0)
5732 throw INTERP_KERNEL::Exception("DataArrayInt::alloc : request for negative length of data !");
5733 _info_on_compo.resize(nbOfCompo);
5734 _mem.alloc(nbOfCompo*(std::size_t)nbOfTuple);
5739 * Assign zero to all values in \a this array. To know more on filling arrays see
5740 * \ref MEDCouplingArrayFill.
5741 * \throw If \a this is not allocated.
5743 void DataArrayInt::fillWithZero() throw(INTERP_KERNEL::Exception)
5746 _mem.fillWithValue(0);
5751 * Assign \a val to all values in \a this array. To know more on filling arrays see
5752 * \ref MEDCouplingArrayFill.
5753 * \param [in] val - the value to fill with.
5754 * \throw If \a this is not allocated.
5756 void DataArrayInt::fillWithValue(int val) throw(INTERP_KERNEL::Exception)
5759 _mem.fillWithValue(val);
5764 * Set all values in \a this array so that the i-th element equals to \a init + i
5765 * (i starts from zero). To know more on filling arrays see \ref MEDCouplingArrayFill.
5766 * \param [in] init - value to assign to the first element of array.
5767 * \throw If \a this->getNumberOfComponents() != 1
5768 * \throw If \a this is not allocated.
5770 void DataArrayInt::iota(int init) throw(INTERP_KERNEL::Exception)
5773 if(getNumberOfComponents()!=1)
5774 throw INTERP_KERNEL::Exception("DataArrayInt::iota : works only for arrays with only one component, you can call 'rearrange' method before !");
5775 int *ptr=getPointer();
5776 int ntuples=getNumberOfTuples();
5777 for(int i=0;i<ntuples;i++)
5783 * Returns a textual and human readable representation of \a this instance of
5784 * DataArrayInt. This text is shown when a DataArrayInt is printed in Python.
5785 * \return std::string - text describing \a this DataArrayInt.
5787 std::string DataArrayInt::repr() const throw(INTERP_KERNEL::Exception)
5789 std::ostringstream ret;
5794 std::string DataArrayInt::reprZip() const throw(INTERP_KERNEL::Exception)
5796 std::ostringstream ret;
5801 void DataArrayInt::writeVTK(std::ostream& ofs, int indent, const char *type, const char *nameInFile) const throw(INTERP_KERNEL::Exception)
5804 std::string idt(indent,' ');
5805 ofs << idt << "<DataArray type=\"" << type << "\" Name=\"" << nameInFile << "\" NumberOfComponents=\"" << getNumberOfComponents() << "\"";
5806 ofs << " format=\"ascii\" RangeMin=\"" << getMinValueInArray() << "\" RangeMax=\"" << getMaxValueInArray() << "\">\n" << idt;
5807 std::copy(begin(),end(),std::ostream_iterator<int>(ofs," "));
5808 ofs << std::endl << idt << "</DataArray>\n";
5811 void DataArrayInt::reprStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
5813 stream << "Name of int array : \"" << _name << "\"\n";
5814 reprWithoutNameStream(stream);
5817 void DataArrayInt::reprZipStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
5819 stream << "Name of int array : \"" << _name << "\"\n";
5820 reprZipWithoutNameStream(stream);
5823 void DataArrayInt::reprWithoutNameStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
5825 DataArray::reprWithoutNameStream(stream);
5826 _mem.repr(getNumberOfComponents(),stream);
5829 void DataArrayInt::reprZipWithoutNameStream(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
5831 DataArray::reprWithoutNameStream(stream);
5832 _mem.reprZip(getNumberOfComponents(),stream);
5835 void DataArrayInt::reprCppStream(const char *varName, std::ostream& stream) const throw(INTERP_KERNEL::Exception)
5837 int nbTuples=getNumberOfTuples(),nbComp=getNumberOfComponents();
5838 const int *data=getConstPointer();
5839 stream << "DataArrayInt *" << varName << "=DataArrayInt::New();" << std::endl;
5840 if(nbTuples*nbComp>=1)
5842 stream << "const int " << varName << "Data[" << nbTuples*nbComp << "]={";
5843 std::copy(data,data+nbTuples*nbComp-1,std::ostream_iterator<int>(stream,","));
5844 stream << data[nbTuples*nbComp-1] << "};" << std::endl;
5845 stream << varName << "->useArray(" << varName << "Data,false,CPP_DEALLOC," << nbTuples << "," << nbComp << ");" << std::endl;
5848 stream << varName << "->alloc(" << nbTuples << "," << nbComp << ");" << std::endl;
5849 stream << varName << "->setName(\"" << getName() << "\");" << std::endl;
5853 * Method that gives a quick overvien of \a this for python.
5855 void DataArrayInt::reprQuickOverview(std::ostream& stream) const throw(INTERP_KERNEL::Exception)
5857 static const std::size_t MAX_NB_OF_BYTE_IN_REPR=300;
5858 stream << "DataArrayInt C++ instance at " << this << ". ";
5861 int nbOfCompo=(int)_info_on_compo.size();
5864 int nbOfTuples=getNumberOfTuples();
5865 stream << "Number of tuples : " << nbOfTuples << ". Number of components : " << nbOfCompo << "." << std::endl;
5866 reprQuickOverviewData(stream,MAX_NB_OF_BYTE_IN_REPR);
5869 stream << "Number of components : 0.";
5872 stream << "*** No data allocated ****";
5875 void DataArrayInt::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const throw(INTERP_KERNEL::Exception)
5877 const int *data=begin();
5878 int nbOfTuples=getNumberOfTuples();
5879 int nbOfCompo=(int)_info_on_compo.size();
5880 std::ostringstream oss2; oss2 << "[";
5881 std::string oss2Str(oss2.str());
5882 bool isFinished=true;
5883 for(int i=0;i<nbOfTuples && isFinished;i++)
5888 for(int j=0;j<nbOfCompo;j++,data++)
5891 if(j!=nbOfCompo-1) oss2 << ", ";
5897 if(i!=nbOfTuples-1) oss2 << ", ";
5898 std::string oss3Str(oss2.str());
5899 if(oss3Str.length()<maxNbOfByteInRepr)
5911 * Modifies \a this one-dimensional array so that each value \a v = \a indArrBg[ \a v ],
5912 * i.e. a current value is used as in index to get a new value from \a indArrBg.
5913 * \param [in] indArrBg - pointer to the first element of array of new values to assign
5915 * \param [in] indArrEnd - specifies the end of the array \a indArrBg, so that
5916 * the last value of \a indArrBg is \a indArrEnd[ -1 ].
5917 * \throw If \a this->getNumberOfComponents() != 1
5918 * \throw If any value of \a this can't be used as a valid index for
5919 * [\a indArrBg, \a indArrEnd).
5921 void DataArrayInt::transformWithIndArr(const int *indArrBg, const int *indArrEnd) throw(INTERP_KERNEL::Exception)
5924 if(getNumberOfComponents()!=1)
5925 throw INTERP_KERNEL::Exception("Call transformWithIndArr method on DataArrayInt with only one component, you can call 'rearrange' method before !");
5926 int nbElemsIn=(int)std::distance(indArrBg,indArrEnd);
5927 int nbOfTuples=getNumberOfTuples();
5928 int *pt=getPointer();
5929 for(int i=0;i<nbOfTuples;i++,pt++)
5931 if(*pt>=0 && *pt<nbElemsIn)
5935 std::ostringstream oss; oss << "DataArrayInt::transformWithIndArr : error on tuple #" << i << " of this value is " << *pt << ", should be in [0," << nbElemsIn << ") !";
5936 throw INTERP_KERNEL::Exception(oss.str().c_str());
5943 * Computes distribution of values of \a this one-dimensional array between given value
5944 * ranges (casts). This method is typically useful for entity number spliting by types,
5946 * \warning The values contained in \a arrBg should be sorted ascendently. No
5947 * check of this is be done. If not, the result is not warranted.
5948 * \param [in] arrBg - the array of ascending values defining the value ranges. The i-th
5949 * value of \a arrBg (\a arrBg[ i ]) gives the lowest value of the i-th range,
5950 * and the greatest value of the i-th range equals to \a arrBg[ i+1 ] - 1. \a
5951 * arrBg containing \a n values defines \a n-1 ranges. The last value of \a arrBg
5952 * should be more than every value in \a this array.
5953 * \param [in] arrEnd - specifies the end of the array \a arrBg, so that
5954 * the last value of \a arrBg is \a arrEnd[ -1 ].
5955 * \param [out] castArr - a new instance of DataArrayInt, of same size as \a this array
5956 * (same number of tuples and components), the caller is to delete
5957 * using decrRef() as it is no more needed.
5958 * This array contains indices of ranges for every value of \a this array. I.e.
5959 * the i-th value of \a castArr gives the index of range the i-th value of \a this
5960 * belongs to. Or, in other words, this parameter contains for each tuple in \a
5961 * this in which cast it holds.
5962 * \param [out] rankInsideCast - a new instance of DataArrayInt, of same size as \a this
5963 * array, the caller is to delete using decrRef() as it is no more needed.
5964 * This array contains ranks of values of \a this array within ranges
5965 * they belongs to. I.e. the i-th value of \a rankInsideCast gives the rank of
5966 * the i-th value of \a this array within the \a castArr[ i ]-th range, to which
5967 * the i-th value of \a this belongs to. Or, in other words, this param contains
5968 * for each tuple its rank inside its cast. The rank is computed as difference
5969 * between the value and the lowest value of range.
5970 * \param [out] castsPresent - a new instance of DataArrayInt, containing indices of
5971 * ranges (casts) to which at least one value of \a this array belongs.
5972 * Or, in other words, this param contains the casts that \a this contains.
5973 * The caller is to delete this array using decrRef() as it is no more needed.
5975 * \b Example: If \a this contains [6,5,0,3,2,7,8,1,4] and \a arrBg contains [0,4,9] then
5976 * the output of this method will be :
5977 * - \a castArr : [1,1,0,0,0,1,1,0,1]
5978 * - \a rankInsideCast: [2,1,0,3,2,3,4,1,0]
5979 * - \a castsPresent : [0,1]
5981 * I.e. values of \a this array belong to 2 ranges: #0 and #1. Value 6 belongs to the
5982 * range #1 and its rank within this range is 2; etc.
5984 * \throw If \a this->getNumberOfComponents() != 1.
5985 * \throw If \a arrEnd - arrBg < 2.
5986 * \throw If any value of \a this is not less than \a arrEnd[-1].
5988 void DataArrayInt::splitByValueRange(const int *arrBg, const int *arrEnd,
5989 DataArrayInt *& castArr, DataArrayInt *& rankInsideCast, DataArrayInt *& castsPresent) const throw(INTERP_KERNEL::Exception)
5992 if(getNumberOfComponents()!=1)
5993 throw INTERP_KERNEL::Exception("Call splitByValueRange method on DataArrayInt with only one component, you can call 'rearrange' method before !");
5994 int nbOfTuples=getNumberOfTuples();
5995 std::size_t nbOfCast=std::distance(arrBg,arrEnd);
5997 throw INTERP_KERNEL::Exception("DataArrayInt::splitByValueRange : The input array giving the cast range values should be of size >=2 !");
5999 const int *work=getConstPointer();
6000 typedef std::reverse_iterator<const int *> rintstart;
6001 rintstart bg(arrEnd);//OK no problem because size of 'arr' is greater or equal 2
6002 rintstart end2(arrBg);
6003 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New();
6004 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret2=DataArrayInt::New();
6005 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret3=DataArrayInt::New();
6006 ret1->alloc(nbOfTuples,1);
6007 ret2->alloc(nbOfTuples,1);
6008 int *ret1Ptr=ret1->getPointer();
6009 int *ret2Ptr=ret2->getPointer();
6010 std::set<std::size_t> castsDetected;
6011 for(int i=0;i<nbOfTuples;i++)
6013 rintstart res=std::find_if(bg,end2,std::bind2nd(std::less_equal<int>(), work[i]));
6014 std::size_t pos=std::distance(bg,res);
6015 std::size_t pos2=nbOfCast-pos;
6018 ret1Ptr[i]=(int)pos2;
6019 ret2Ptr[i]=work[i]-arrBg[pos2];
6020 castsDetected.insert(pos2);
6024 std::ostringstream oss; oss << "DataArrayInt::splitByValueRange : At rank #" << i << " the value is " << work[i] << " should be in [0," << *bg << ") !";
6025 throw INTERP_KERNEL::Exception(oss.str().c_str());
6028 ret3->alloc((int)castsDetected.size(),1);
6029 std::copy(castsDetected.begin(),castsDetected.end(),ret3->getPointer());
6030 castArr=ret1.retn();
6031 rankInsideCast=ret2.retn();
6032 castsPresent=ret3.retn();
6036 * Creates a one-dimensional DataArrayInt (\a res) whose contents are computed from
6037 * values of \a this (\a a) and the given (\a indArr) arrays as follows:
6038 * \a res[ \a indArr[ \a a[ i ]]] = i. I.e. for each value in place i \a v = \a a[ i ],
6039 * new value in place \a indArr[ \a v ] is i.
6040 * \param [in] indArrBg - the array holding indices within the result array to assign
6041 * indices of values of \a this array pointing to values of \a indArrBg.
6042 * \param [in] indArrEnd - specifies the end of the array \a indArrBg, so that
6043 * the last value of \a indArrBg is \a indArrEnd[ -1 ].
6044 * \return DataArrayInt * - the new instance of DataArrayInt.
6045 * The caller is to delete this result array using decrRef() as it is no more
6047 * \throw If \a this->getNumberOfComponents() != 1.
6048 * \throw If any value of \a this array is not a valid index for \a indArrBg array.
6049 * \throw If any value of \a indArrBg is not a valid index for \a this array.
6051 DataArrayInt *DataArrayInt::transformWithIndArrR(const int *indArrBg, const int *indArrEnd) const throw(INTERP_KERNEL::Exception)
6054 if(getNumberOfComponents()!=1)
6055 throw INTERP_KERNEL::Exception("Call transformWithIndArrR method on DataArrayInt with only one component, you can call 'rearrange' method before !");
6056 int nbElemsIn=(int)std::distance(indArrBg,indArrEnd);
6057 int nbOfTuples=getNumberOfTuples();
6058 const int *pt=getConstPointer();
6059 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6060 ret->alloc(nbOfTuples,1);
6061 ret->fillWithValue(-1);
6062 int *tmp=ret->getPointer();
6063 for(int i=0;i<nbOfTuples;i++,pt++)
6065 if(*pt>=0 && *pt<nbElemsIn)
6067 int pos=indArrBg[*pt];
6068 if(pos>=0 && pos<nbOfTuples)
6072 std::ostringstream oss; oss << "DataArrayInt::transformWithIndArrR : error on tuple #" << i << " value of new pos is " << pos << " ( indArrBg[" << *pt << "]) ! Should be in [0," << nbOfTuples << ") !";
6073 throw INTERP_KERNEL::Exception(oss.str().c_str());
6078 std::ostringstream oss; oss << "DataArrayInt::transformWithIndArrR : error on tuple #" << i << " value is " << *pt << " and indirectionnal array as a size equal to " << nbElemsIn << " !";
6079 throw INTERP_KERNEL::Exception(oss.str().c_str());
6086 * Creates a one-dimensional DataArrayInt of given length, whose contents are computed
6087 * from values of \a this array, which is supposed to contain a renumbering map in
6088 * "Old to New" mode. The result array contains a renumbering map in "New to Old" mode.
6089 * To know how to use the renumbering maps see \ref MEDCouplingArrayRenumbering.
6090 * \param [in] newNbOfElem - the number of tuples in the result array.
6091 * \return DataArrayInt * - the new instance of DataArrayInt.
6092 * The caller is to delete this result array using decrRef() as it is no more
6095 * \ref cpp_mcdataarrayint_invertarrayo2n2n2o "Here is a C++ example".<br>
6096 * \ref py_mcdataarrayint_invertarrayo2n2n2o "Here is a Python example".
6098 DataArrayInt *DataArrayInt::invertArrayO2N2N2O(int newNbOfElem) const
6100 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6101 ret->alloc(newNbOfElem,1);
6102 int nbOfOldNodes=getNumberOfTuples();
6103 const int *old2New=getConstPointer();
6104 int *pt=ret->getPointer();
6105 for(int i=0;i!=nbOfOldNodes;i++)
6112 * This method is similar to DataArrayInt::invertArrayO2N2N2O except that
6113 * 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]
6115 DataArrayInt *DataArrayInt::invertArrayO2N2N2OBis(int newNbOfElem) const throw(INTERP_KERNEL::Exception)
6117 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6118 ret->alloc(newNbOfElem,1);
6119 int nbOfOldNodes=getNumberOfTuples();
6120 const int *old2New=getConstPointer();
6121 int *pt=ret->getPointer();
6122 for(int i=nbOfOldNodes-1;i>=0;i--)
6129 * Creates a one-dimensional DataArrayInt of given length, whose contents are computed
6130 * from values of \a this array, which is supposed to contain a renumbering map in
6131 * "New to Old" mode. The result array contains a renumbering map in "Old to New" mode.
6132 * To know how to use the renumbering maps see \ref MEDCouplingArrayRenumbering.
6133 * \param [in] newNbOfElem - the number of tuples in the result array.
6134 * \return DataArrayInt * - the new instance of DataArrayInt.
6135 * The caller is to delete this result array using decrRef() as it is no more
6138 * \ref cpp_mcdataarrayint_invertarrayn2o2o2n "Here is a C++ example".
6140 * \ref py_mcdataarrayint_invertarrayn2o2o2n "Here is a Python example".
6142 DataArrayInt *DataArrayInt::invertArrayN2O2O2N(int oldNbOfElem) const
6145 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6146 ret->alloc(oldNbOfElem,1);
6147 const int *new2Old=getConstPointer();
6148 int *pt=ret->getPointer();
6149 std::fill(pt,pt+oldNbOfElem,-1);
6150 int nbOfNewElems=getNumberOfTuples();
6151 for(int i=0;i<nbOfNewElems;i++)
6157 * Equivalent to DataArrayInt::isEqual except that if false the reason of
6158 * mismatch is given.
6160 * \param [in] other the instance to be compared with \a this
6161 * \param [out] reason In case of inequality returns the reason.
6162 * \sa DataArrayInt::isEqual
6164 bool DataArrayInt::isEqualIfNotWhy(const DataArrayInt& other, std::string& reason) const throw(INTERP_KERNEL::Exception)
6166 if(!areInfoEqualsIfNotWhy(other,reason))
6168 return _mem.isEqual(other._mem,0,reason);
6172 * Checks if \a this and another DataArrayInt are fully equal. For more info see
6173 * \ref MEDCouplingArrayBasicsCompare.
6174 * \param [in] other - an instance of DataArrayInt to compare with \a this one.
6175 * \return bool - \a true if the two arrays are equal, \a false else.
6177 bool DataArrayInt::isEqual(const DataArrayInt& other) const throw(INTERP_KERNEL::Exception)
6180 return isEqualIfNotWhy(other,tmp);
6184 * Checks if values of \a this and another DataArrayInt are equal. For more info see
6185 * \ref MEDCouplingArrayBasicsCompare.
6186 * \param [in] other - an instance of DataArrayInt to compare with \a this one.
6187 * \return bool - \a true if the values of two arrays are equal, \a false else.
6189 bool DataArrayInt::isEqualWithoutConsideringStr(const DataArrayInt& other) const throw(INTERP_KERNEL::Exception)
6192 return _mem.isEqual(other._mem,0,tmp);
6196 * Checks if values of \a this and another DataArrayInt are equal. Comparison is
6197 * performed on sorted value sequences.
6198 * For more info see\ref MEDCouplingArrayBasicsCompare.
6199 * \param [in] other - an instance of DataArrayInt to compare with \a this one.
6200 * \return bool - \a true if the sorted values of two arrays are equal, \a false else.
6202 bool DataArrayInt::isEqualWithoutConsideringStrAndOrder(const DataArrayInt& other) const throw(INTERP_KERNEL::Exception)
6204 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> a=deepCpy();
6205 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> b=other.deepCpy();
6208 return a->isEqualWithoutConsideringStr(*b);
6212 * This method compares content of input vector \a v and \a this.
6213 * 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.
6214 * For performance reasons \a this is expected to be sorted ascendingly. If not an exception will be thrown.
6216 * \param [in] v - the vector of 'flags' to be compared with \a this.
6218 * \throw If \a this is not sorted ascendingly.
6219 * \throw If \a this has not exactly one component.
6220 * \throw If \a this is not allocated.
6222 bool DataArrayInt::isFittingWith(const std::vector<bool>& v) const throw(INTERP_KERNEL::Exception)
6225 if(getNumberOfComponents()!=1)
6226 throw INTERP_KERNEL::Exception("DataArrayInt::isFittingWith : number of components of this should be equal to one !");
6227 int nbOfTuples(getNumberOfTuples());
6228 const int *w(begin()),*end2(end());
6229 int refVal=-std::numeric_limits<int>::max();
6231 std::vector<bool>::const_iterator it(v.begin());
6232 for(;it!=v.end();it++,i++)
6244 std::ostringstream oss; oss << "DataArrayInt::isFittingWith : At pos #" << std::distance(begin(),w-1) << " this is not sorted ascendingly !";
6245 throw INTERP_KERNEL::Exception(oss.str().c_str());
6258 * Sorts values of the array.
6259 * \param [in] asc - \a true means ascending order, \a false, descending.
6260 * \throw If \a this is not allocated.
6261 * \throw If \a this->getNumberOfComponents() != 1.
6263 void DataArrayInt::sort(bool asc) throw(INTERP_KERNEL::Exception)
6266 if(getNumberOfComponents()!=1)
6267 throw INTERP_KERNEL::Exception("DataArrayInt::sort : only supported with 'this' array with ONE component !");
6273 * Reverse the array values.
6274 * \throw If \a this->getNumberOfComponents() < 1.
6275 * \throw If \a this is not allocated.
6277 void DataArrayInt::reverse() throw(INTERP_KERNEL::Exception)
6280 _mem.reverse(getNumberOfComponents());
6285 * Checks that \a this array is consistently **increasing** or **decreasing** in value.
6286 * If not an exception is thrown.
6287 * \param [in] increasing - if \a true, the array values should be increasing.
6288 * \throw If sequence of values is not strictly monotonic in agreement with \a
6290 * \throw If \a this->getNumberOfComponents() != 1.
6291 * \throw If \a this is not allocated.
6293 void DataArrayInt::checkMonotonic(bool increasing) const throw(INTERP_KERNEL::Exception)
6295 if(!isMonotonic(increasing))
6298 throw INTERP_KERNEL::Exception("DataArrayInt::checkMonotonic : 'this' is not INCREASING monotonic !");
6300 throw INTERP_KERNEL::Exception("DataArrayInt::checkMonotonic : 'this' is not DECREASING monotonic !");
6305 * Checks that \a this array is consistently **increasing** or **decreasing** in value.
6306 * \param [in] increasing - if \a true, array values should be increasing.
6307 * \return bool - \a true if values change in accordance with \a increasing arg.
6308 * \throw If \a this->getNumberOfComponents() != 1.
6309 * \throw If \a this is not allocated.
6311 bool DataArrayInt::isMonotonic(bool increasing) const throw(INTERP_KERNEL::Exception)
6314 if(getNumberOfComponents()!=1)
6315 throw INTERP_KERNEL::Exception("DataArrayInt::isMonotonic : only supported with 'this' array with ONE component !");
6316 int nbOfElements=getNumberOfTuples();
6317 const int *ptr=getConstPointer();
6323 for(int i=1;i<nbOfElements;i++)
6333 for(int i=1;i<nbOfElements;i++)
6345 * This method check that array consistently INCREASING or DECREASING in value.
6347 bool DataArrayInt::isStrictlyMonotonic(bool increasing) const throw(INTERP_KERNEL::Exception)
6350 if(getNumberOfComponents()!=1)
6351 throw INTERP_KERNEL::Exception("DataArrayInt::isStrictlyMonotonic : only supported with 'this' array with ONE component !");
6352 int nbOfElements=getNumberOfTuples();
6353 const int *ptr=getConstPointer();
6359 for(int i=1;i<nbOfElements;i++)
6369 for(int i=1;i<nbOfElements;i++)
6381 * This method check that array consistently INCREASING or DECREASING in value.
6383 void DataArrayInt::checkStrictlyMonotonic(bool increasing) const throw(INTERP_KERNEL::Exception)
6385 if(!isStrictlyMonotonic(increasing))
6388 throw INTERP_KERNEL::Exception("DataArrayInt::checkStrictlyMonotonic : 'this' is not strictly INCREASING monotonic !");
6390 throw INTERP_KERNEL::Exception("DataArrayInt::checkStrictlyMonotonic : 'this' is not strictly DECREASING monotonic !");
6395 * Creates a new one-dimensional DataArrayInt of the same size as \a this and a given
6396 * one-dimensional arrays that must be of the same length. The result array describes
6397 * correspondence between \a this and \a other arrays, so that
6398 * <em> other.getIJ(i,0) == this->getIJ(ret->getIJ(i),0)</em>. If such a permutation is
6399 * not possible because some element in \a other is not in \a this, an exception is thrown.
6400 * \param [in] other - an array to compute permutation to.
6401 * \return DataArrayInt * - a new instance of DataArrayInt, which is a permutation array
6402 * from \a this to \a other. The caller is to delete this array using decrRef() as it is
6404 * \throw If \a this->getNumberOfComponents() != 1.
6405 * \throw If \a other->getNumberOfComponents() != 1.
6406 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples().
6407 * \throw If \a other includes a value which is not in \a this array.
6409 * \ref cpp_mcdataarrayint_buildpermutationarr "Here is a C++ example".
6411 * \ref py_mcdataarrayint_buildpermutationarr "Here is a Python example".
6413 DataArrayInt *DataArrayInt::buildPermutationArr(const DataArrayInt& other) const throw(INTERP_KERNEL::Exception)
6416 if(getNumberOfComponents()!=1 || other.getNumberOfComponents()!=1)
6417 throw INTERP_KERNEL::Exception("DataArrayInt::buildPermutationArr : 'this' and 'other' have to have exactly ONE component !");
6418 int nbTuple=getNumberOfTuples();
6419 other.checkAllocated();
6420 if(nbTuple!=other.getNumberOfTuples())
6421 throw INTERP_KERNEL::Exception("DataArrayInt::buildPermutationArr : 'this' and 'other' must have the same number of tuple !");
6422 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6423 ret->alloc(nbTuple,1);
6424 ret->fillWithValue(-1);
6425 const int *pt=getConstPointer();
6426 std::map<int,int> mm;
6427 for(int i=0;i<nbTuple;i++)
6429 pt=other.getConstPointer();
6430 int *retToFill=ret->getPointer();
6431 for(int i=0;i<nbTuple;i++)
6433 std::map<int,int>::const_iterator it=mm.find(pt[i]);
6436 std::ostringstream oss; oss << "DataArrayInt::buildPermutationArr : Arrays mismatch : element (" << pt[i] << ") in 'other' not findable in 'this' !";
6437 throw INTERP_KERNEL::Exception(oss.str().c_str());
6439 retToFill[i]=(*it).second;
6445 * Sets a C array to be used as raw data of \a this. The previously set info
6446 * of components is retained and re-sized.
6447 * For more info see \ref MEDCouplingArraySteps1.
6448 * \param [in] array - the C array to be used as raw data of \a this.
6449 * \param [in] ownership - if \a true, \a array will be deallocated at destruction of \a this.
6450 * \param [in] type - specifies how to deallocate \a array. If \a type == ParaMEDMEM::CPP_DEALLOC,
6451 * \c delete [] \c array; will be called. If \a type == ParaMEDMEM::C_DEALLOC,
6452 * \c free(\c array ) will be called.
6453 * \param [in] nbOfTuple - new number of tuples in \a this.
6454 * \param [in] nbOfCompo - new number of components in \a this.
6456 void DataArrayInt::useArray(const int *array, bool ownership, DeallocType type, int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception)
6458 _info_on_compo.resize(nbOfCompo);
6459 _mem.useArray(array,ownership,type,nbOfTuple*nbOfCompo);
6463 void DataArrayInt::useExternalArrayWithRWAccess(const int *array, int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception)
6465 _info_on_compo.resize(nbOfCompo);
6466 _mem.useExternalArrayWithRWAccess(array,nbOfTuple*nbOfCompo);
6471 * Returns a new DataArrayInt holding the same values as \a this array but differently
6472 * arranged in memory. If \a this array holds 2 components of 3 values:
6473 * \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$, then the result array holds these values arranged
6474 * as follows: \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$.
6475 * \warning Do not confuse this method with transpose()!
6476 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6477 * is to delete using decrRef() as it is no more needed.
6478 * \throw If \a this is not allocated.
6480 DataArrayInt *DataArrayInt::fromNoInterlace() const throw(INTERP_KERNEL::Exception)
6484 throw INTERP_KERNEL::Exception("DataArrayInt::fromNoInterlace : Not defined array !");
6485 int *tab=_mem.fromNoInterlace(getNumberOfComponents());
6486 DataArrayInt *ret=DataArrayInt::New();
6487 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
6492 * Returns a new DataArrayInt holding the same values as \a this array but differently
6493 * arranged in memory. If \a this array holds 2 components of 3 values:
6494 * \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$, then the result array holds these values arranged
6495 * as follows: \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$.
6496 * \warning Do not confuse this method with transpose()!
6497 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6498 * is to delete using decrRef() as it is no more needed.
6499 * \throw If \a this is not allocated.
6501 DataArrayInt *DataArrayInt::toNoInterlace() const throw(INTERP_KERNEL::Exception)
6505 throw INTERP_KERNEL::Exception("DataArrayInt::toNoInterlace : Not defined array !");
6506 int *tab=_mem.toNoInterlace(getNumberOfComponents());
6507 DataArrayInt *ret=DataArrayInt::New();
6508 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
6513 * Permutes values of \a this array as required by \a old2New array. The values are
6514 * permuted so that \c new[ \a old2New[ i ]] = \c old[ i ]. Number of tuples remains
6515 * the same as in \this one.
6516 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
6517 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6518 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
6519 * giving a new position for i-th old value.
6521 void DataArrayInt::renumberInPlace(const int *old2New) throw(INTERP_KERNEL::Exception)
6524 int nbTuples=getNumberOfTuples();
6525 int nbOfCompo=getNumberOfComponents();
6526 int *tmp=new int[nbTuples*nbOfCompo];
6527 const int *iptr=getConstPointer();
6528 for(int i=0;i<nbTuples;i++)
6531 if(v>=0 && v<nbTuples)
6532 std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),tmp+nbOfCompo*v);
6535 std::ostringstream oss; oss << "DataArrayInt::renumberInPlace : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
6536 throw INTERP_KERNEL::Exception(oss.str().c_str());
6539 std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
6545 * Permutes values of \a this array as required by \a new2Old array. The values are
6546 * permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of tuples remains
6547 * the same as in \this one.
6548 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6549 * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
6550 * giving a previous position of i-th new value.
6551 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6552 * is to delete using decrRef() as it is no more needed.
6554 void DataArrayInt::renumberInPlaceR(const int *new2Old) throw(INTERP_KERNEL::Exception)
6557 int nbTuples=getNumberOfTuples();
6558 int nbOfCompo=getNumberOfComponents();
6559 int *tmp=new int[nbTuples*nbOfCompo];
6560 const int *iptr=getConstPointer();
6561 for(int i=0;i<nbTuples;i++)
6564 if(v>=0 && v<nbTuples)
6565 std::copy(iptr+nbOfCompo*v,iptr+nbOfCompo*(v+1),tmp+nbOfCompo*i);
6568 std::ostringstream oss; oss << "DataArrayInt::renumberInPlaceR : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
6569 throw INTERP_KERNEL::Exception(oss.str().c_str());
6572 std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
6578 * Returns a copy of \a this array with values permuted as required by \a old2New array.
6579 * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ].
6580 * Number of tuples in the result array remains the same as in \this one.
6581 * If a permutation reduction is needed, renumberAndReduce() should be used.
6582 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6583 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
6584 * giving a new position for i-th old value.
6585 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6586 * is to delete using decrRef() as it is no more needed.
6587 * \throw If \a this is not allocated.
6589 DataArrayInt *DataArrayInt::renumber(const int *old2New) const throw(INTERP_KERNEL::Exception)
6592 int nbTuples=getNumberOfTuples();
6593 int nbOfCompo=getNumberOfComponents();
6594 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6595 ret->alloc(nbTuples,nbOfCompo);
6596 ret->copyStringInfoFrom(*this);
6597 const int *iptr=getConstPointer();
6598 int *optr=ret->getPointer();
6599 for(int i=0;i<nbTuples;i++)
6600 std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),optr+nbOfCompo*old2New[i]);
6601 ret->copyStringInfoFrom(*this);
6606 * Returns a copy of \a this array with values permuted as required by \a new2Old array.
6607 * The values are permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of
6608 * tuples in the result array remains the same as in \this one.
6609 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
6610 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6611 * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
6612 * giving a previous position of i-th new value.
6613 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6614 * is to delete using decrRef() as it is no more needed.
6616 DataArrayInt *DataArrayInt::renumberR(const int *new2Old) const throw(INTERP_KERNEL::Exception)
6619 int nbTuples=getNumberOfTuples();
6620 int nbOfCompo=getNumberOfComponents();
6621 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6622 ret->alloc(nbTuples,nbOfCompo);
6623 ret->copyStringInfoFrom(*this);
6624 const int *iptr=getConstPointer();
6625 int *optr=ret->getPointer();
6626 for(int i=0;i<nbTuples;i++)
6627 std::copy(iptr+nbOfCompo*new2Old[i],iptr+nbOfCompo*(new2Old[i]+1),optr+nbOfCompo*i);
6628 ret->copyStringInfoFrom(*this);
6633 * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
6634 * of size \a newNbOfTuple and it's values are permuted as required by \a old2New array.
6635 * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ] for all
6636 * \a old2New[ i ] >= 0. In other words every i-th tuple in \a this array, for which
6637 * \a old2New[ i ] is negative, is missing from the result array.
6638 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6639 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
6640 * giving a new position for i-th old tuple and giving negative position for
6641 * for i-th old tuple that should be omitted.
6642 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6643 * is to delete using decrRef() as it is no more needed.
6645 DataArrayInt *DataArrayInt::renumberAndReduce(const int *old2New, int newNbOfTuple) const throw(INTERP_KERNEL::Exception)
6648 int nbTuples=getNumberOfTuples();
6649 int nbOfCompo=getNumberOfComponents();
6650 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6651 ret->alloc(newNbOfTuple,nbOfCompo);
6652 const int *iptr=getConstPointer();
6653 int *optr=ret->getPointer();
6654 for(int i=0;i<nbTuples;i++)
6658 std::copy(iptr+i*nbOfCompo,iptr+(i+1)*nbOfCompo,optr+w*nbOfCompo);
6660 ret->copyStringInfoFrom(*this);
6665 * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
6666 * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
6667 * \a new2OldBg array.
6668 * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
6669 * This method is equivalent to renumberAndReduce() except that convention in input is
6670 * \c new2old and \b not \c old2new.
6671 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6672 * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
6673 * tuple index in \a this array to fill the i-th tuple in the new array.
6674 * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
6675 * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
6676 * \a new2OldBg <= \a pi < \a new2OldEnd.
6677 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6678 * is to delete using decrRef() as it is no more needed.
6680 DataArrayInt *DataArrayInt::selectByTupleId(const int *new2OldBg, const int *new2OldEnd) const
6683 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6684 int nbComp=getNumberOfComponents();
6685 ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
6686 ret->copyStringInfoFrom(*this);
6687 int *pt=ret->getPointer();
6688 const int *srcPt=getConstPointer();
6690 for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
6691 std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
6692 ret->copyStringInfoFrom(*this);
6697 * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
6698 * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
6699 * \a new2OldBg array.
6700 * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
6701 * This method is equivalent to renumberAndReduce() except that convention in input is
6702 * \c new2old and \b not \c old2new.
6703 * This method is equivalent to selectByTupleId() except that it prevents coping data
6704 * from behind the end of \a this array.
6705 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6706 * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
6707 * tuple index in \a this array to fill the i-th tuple in the new array.
6708 * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
6709 * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
6710 * \a new2OldBg <= \a pi < \a new2OldEnd.
6711 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6712 * is to delete using decrRef() as it is no more needed.
6713 * \throw If \a new2OldEnd - \a new2OldBg > \a this->getNumberOfTuples().
6715 DataArrayInt *DataArrayInt::selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const throw(INTERP_KERNEL::Exception)
6718 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6719 int nbComp=getNumberOfComponents();
6720 int oldNbOfTuples=getNumberOfTuples();
6721 ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
6722 ret->copyStringInfoFrom(*this);
6723 int *pt=ret->getPointer();
6724 const int *srcPt=getConstPointer();
6726 for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
6727 if(*w>=0 && *w<oldNbOfTuples)
6728 std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
6730 throw INTERP_KERNEL::Exception("DataArrayInt::selectByTupleIdSafe : some ids has been detected to be out of [0,this->getNumberOfTuples) !");
6731 ret->copyStringInfoFrom(*this);
6736 * Returns a shorten copy of \a this array. The new DataArrayInt contains every
6737 * (\a bg + \c i * \a step)-th tuple of \a this array located before the \a end2-th
6738 * tuple. Indices of the selected tuples are the same as ones returned by the Python
6739 * command \c range( \a bg, \a end2, \a step ).
6740 * This method is equivalent to selectByTupleIdSafe() except that the input array is
6741 * not constructed explicitly.
6742 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6743 * \param [in] bg - index of the first tuple to copy from \a this array.
6744 * \param [in] end2 - index of the tuple before which the tuples to copy are located.
6745 * \param [in] step - index increment to get index of the next tuple to copy.
6746 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6747 * is to delete using decrRef() as it is no more needed.
6748 * \sa DataArrayInt::substr.
6750 DataArrayInt *DataArrayInt::selectByTupleId2(int bg, int end2, int step) const throw(INTERP_KERNEL::Exception)
6753 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6754 int nbComp=getNumberOfComponents();
6755 int newNbOfTuples=GetNumberOfItemGivenBESRelative(bg,end2,step,"DataArrayInt::selectByTupleId2 : ");
6756 ret->alloc(newNbOfTuples,nbComp);
6757 int *pt=ret->getPointer();
6758 const int *srcPt=getConstPointer()+bg*nbComp;
6759 for(int i=0;i<newNbOfTuples;i++,srcPt+=step*nbComp)
6760 std::copy(srcPt,srcPt+nbComp,pt+i*nbComp);
6761 ret->copyStringInfoFrom(*this);
6766 * Returns a shorten copy of \a this array. The new DataArrayInt contains ranges
6767 * of tuples specified by \a ranges parameter.
6768 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6769 * \param [in] ranges - std::vector of std::pair's each of which defines a range
6770 * of tuples in [\c begin,\c end) format.
6771 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6772 * is to delete using decrRef() as it is no more needed.
6773 * \throw If \a end < \a begin.
6774 * \throw If \a end > \a this->getNumberOfTuples().
6775 * \throw If \a this is not allocated.
6777 DataArray *DataArrayInt::selectByTupleRanges(const std::vector<std::pair<int,int> >& ranges) const throw(INTERP_KERNEL::Exception)
6780 int nbOfComp=getNumberOfComponents();
6781 int nbOfTuplesThis=getNumberOfTuples();
6784 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6785 ret->alloc(0,nbOfComp);
6786 ret->copyStringInfoFrom(*this);
6789 int ref=ranges.front().first;
6791 bool isIncreasing=true;
6792 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
6794 if((*it).first<=(*it).second)
6796 if((*it).first>=0 && (*it).second<=nbOfTuplesThis)
6798 nbOfTuples+=(*it).second-(*it).first;
6800 isIncreasing=ref<=(*it).first;
6805 std::ostringstream oss; oss << "DataArrayInt::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
6806 oss << " (" << (*it).first << "," << (*it).second << ") is greater than number of tuples of this :" << nbOfTuples << " !";
6807 throw INTERP_KERNEL::Exception(oss.str().c_str());
6812 std::ostringstream oss; oss << "DataArrayInt::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
6813 oss << " (" << (*it).first << "," << (*it).second << ") end is before begin !";
6814 throw INTERP_KERNEL::Exception(oss.str().c_str());
6817 if(isIncreasing && nbOfTuplesThis==nbOfTuples)
6819 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6820 ret->alloc(nbOfTuples,nbOfComp);
6821 ret->copyStringInfoFrom(*this);
6822 const int *src=getConstPointer();
6823 int *work=ret->getPointer();
6824 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
6825 work=std::copy(src+(*it).first*nbOfComp,src+(*it).second*nbOfComp,work);
6830 * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode.
6831 * This map, if applied to \a this array, would make it sorted. For example, if
6832 * \a this array contents are [9,10,0,6,4,11,3,7] then the contents of the result array
6833 * are [5,6,0,3,2,7,1,4]; if this result array (\a res) is used as an argument in call
6834 * \a this->renumber(\a res) then the returned array contains [0,3,4,6,7,9,10,11].
6835 * This method is useful for renumbering (in MED file for example). For more info
6836 * on renumbering see \ref MEDCouplingArrayRenumbering.
6837 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
6838 * array using decrRef() as it is no more needed.
6839 * \throw If \a this is not allocated.
6840 * \throw If \a this->getNumberOfComponents() != 1.
6841 * \throw If there are equal values in \a this array.
6843 DataArrayInt *DataArrayInt::checkAndPreparePermutation() const throw(INTERP_KERNEL::Exception)
6846 if(getNumberOfComponents()!=1)
6847 throw INTERP_KERNEL::Exception("DataArrayInt::checkAndPreparePermutation : number of components must == 1 !");
6848 int nbTuples=getNumberOfTuples();
6849 const int *pt=getConstPointer();
6850 int *pt2=CheckAndPreparePermutation(pt,pt+nbTuples);
6851 DataArrayInt *ret=DataArrayInt::New();
6852 ret->useArray(pt2,true,C_DEALLOC,nbTuples,1);
6857 * Returns two arrays describing a surjective mapping from \a this set of values (\a A)
6858 * onto a set of values of size \a targetNb (\a B). The surjective function is
6859 * \a B[ \a A[ i ]] = i. That is to say that for each \a id in [0,\a targetNb), where \a
6860 * targetNb < \a this->getNumberOfTuples(), there exists at least one tupleId (\a tid) so
6861 * that <em> this->getIJ( tid, 0 ) == id</em>. <br>
6862 * The first of out arrays returns indices of elements of \a this array, grouped by their
6863 * place in the set \a B. The second out array is the index of the first one; it shows how
6864 * many elements of \a A are mapped into each element of \a B. <br>
6866 * mapping and its usage in renumbering see \ref MEDCouplingArrayRenumbering. <br>
6868 * - \a this: [0,3,2,3,2,2,1,2]
6870 * - \a arr: [0, 6, 2,4,5,7, 1,3]
6871 * - \a arrI: [0,1,2,6,8]
6873 * This result means: <br>
6874 * the element of \a B 0 encounters within \a A once (\a arrI[ 0+1 ] - \a arrI[ 0 ]) and
6875 * its index within \a A is 0 ( \a arr[ 0:1 ] == \a arr[ \a arrI[ 0 ] : \a arrI[ 0+1 ]]);<br>
6876 * the element of \a B 2 encounters within \a A 4 times (\a arrI[ 2+1 ] - \a arrI[ 2 ]) and
6877 * its indices within \a A are [2,4,5,7] ( \a arr[ 2:6 ] == \a arr[ \a arrI[ 2 ] :
6878 * \a arrI[ 2+1 ]]); <br> etc.
6879 * \param [in] targetNb - the size of the set \a B. \a targetNb must be equal or more
6880 * than the maximal value of \a A.
6881 * \param [out] arr - a new instance of DataArrayInt returning indices of
6882 * elements of \a this, grouped by their place in the set \a B. The caller is to delete
6883 * this array using decrRef() as it is no more needed.
6884 * \param [out] arrI - a new instance of DataArrayInt returning size of groups of equal
6885 * elements of \a this. The caller is to delete this array using decrRef() as it
6886 * is no more needed.
6887 * \throw If \a this is not allocated.
6888 * \throw If \a this->getNumberOfComponents() != 1.
6889 * \throw If any value in \a this is more or equal to \a targetNb.
6891 void DataArrayInt::changeSurjectiveFormat(int targetNb, DataArrayInt *&arr, DataArrayInt *&arrI) const throw(INTERP_KERNEL::Exception)
6894 if(getNumberOfComponents()!=1)
6895 throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : number of components must == 1 !");
6896 int nbOfTuples=getNumberOfTuples();
6897 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
6898 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> retI(DataArrayInt::New());
6899 retI->alloc(targetNb+1,1);
6900 const int *input=getConstPointer();
6901 std::vector< std::vector<int> > tmp(targetNb);
6902 for(int i=0;i<nbOfTuples;i++)
6905 if(tmp2>=0 && tmp2<targetNb)
6906 tmp[tmp2].push_back(i);
6909 std::ostringstream oss; oss << "DataArrayInt::changeSurjectiveFormat : At pos " << i << " presence of element " << tmp2 << " ! should be in [0," << targetNb << ") !";
6910 throw INTERP_KERNEL::Exception(oss.str().c_str());
6913 int *retIPtr=retI->getPointer();
6915 for(std::vector< std::vector<int> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++,retIPtr++)
6916 retIPtr[1]=retIPtr[0]+(int)((*it1).size());
6917 if(nbOfTuples!=retI->getIJ(targetNb,0))
6918 throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : big problem should never happen !");
6919 ret->alloc(nbOfTuples,1);
6920 int *retPtr=ret->getPointer();
6921 for(std::vector< std::vector<int> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++)
6922 retPtr=std::copy((*it1).begin(),(*it1).end(),retPtr);
6929 * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode computed
6930 * from a zip representation of a surjective format (returned e.g. by
6931 * \ref ParaMEDMEM::DataArrayDouble::findCommonTuples() "DataArrayDouble::findCommonTuples()"
6932 * for example). The result array minimizes the permutation. <br>
6933 * For more info on renumbering see \ref MEDCouplingArrayRenumbering. <br>
6935 * - \a nbOfOldTuples: 10
6936 * - \a arr : [0,3, 5,7,9]
6937 * - \a arrIBg : [0,2,5]
6938 * - \a newNbOfTuples: 7
6939 * - result array : [0,1,2,0,3,4,5,4,6,4]
6941 * \param [in] nbOfOldTuples - number of tuples in the initial array \a arr.
6942 * \param [in] arr - the array of tuple indices grouped by \a arrIBg array.
6943 * \param [in] arrIBg - the array dividing all indices stored in \a arr into groups of
6944 * (indices of) equal values. Its every element (except the last one) points to
6945 * the first element of a group of equal values.
6946 * \param [in] arrIEnd - specifies the end of \a arrIBg, so that the last element of \a
6947 * arrIBg is \a arrIEnd[ -1 ].
6948 * \param [out] newNbOfTuples - number of tuples after surjection application.
6949 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
6950 * array using decrRef() as it is no more needed.
6951 * \throw If any value of \a arr breaks condition ( 0 <= \a arr[ i ] < \a nbOfOldTuples ).
6953 DataArrayInt *DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(int nbOfOldTuples, const int *arr, const int *arrIBg, const int *arrIEnd, int &newNbOfTuples) throw(INTERP_KERNEL::Exception)
6955 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6956 ret->alloc(nbOfOldTuples,1);
6957 int *pt=ret->getPointer();
6958 std::fill(pt,pt+nbOfOldTuples,-1);
6959 int nbOfGrps=((int)std::distance(arrIBg,arrIEnd))-1;
6960 const int *cIPtr=arrIBg;
6961 for(int i=0;i<nbOfGrps;i++)
6962 pt[arr[cIPtr[i]]]=-(i+2);
6964 for(int iNode=0;iNode<nbOfOldTuples;iNode++)
6972 int grpId=-(pt[iNode]+2);
6973 for(int j=cIPtr[grpId];j<cIPtr[grpId+1];j++)
6975 if(arr[j]>=0 && arr[j]<nbOfOldTuples)
6979 std::ostringstream oss; oss << "DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2 : With element #" << j << " value is " << arr[j] << " should be in [0," << nbOfOldTuples << ") !";
6980 throw INTERP_KERNEL::Exception(oss.str().c_str());
6987 newNbOfTuples=newNb;
6992 * Returns a new DataArrayInt containing a renumbering map in "New to Old" mode,
6993 * which if applied to \a this array would make it sorted ascendingly.
6994 * For more info on renumbering see \ref MEDCouplingArrayRenumbering. <br>
6996 * - \a this: [2,0,1,1,0,1,2,0,1,1,0,0]
6997 * - result: [10,0,5,6,1,7,11,2,8,9,3,4]
6998 * - after applying result to \a this: [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2]
7000 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7001 * array using decrRef() as it is no more needed.
7002 * \throw If \a this is not allocated.
7003 * \throw If \a this->getNumberOfComponents() != 1.
7005 DataArrayInt *DataArrayInt::buildPermArrPerLevel() const throw(INTERP_KERNEL::Exception)
7008 if(getNumberOfComponents()!=1)
7009 throw INTERP_KERNEL::Exception("DataArrayInt::buildPermArrPerLevel : number of components must == 1 !");
7010 int nbOfTuples=getNumberOfTuples();
7011 const int *pt=getConstPointer();
7012 std::map<int,int> m;
7013 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7014 ret->alloc(nbOfTuples,1);
7015 int *opt=ret->getPointer();
7016 for(int i=0;i<nbOfTuples;i++,pt++,opt++)
7019 std::map<int,int>::iterator it=m.find(val);
7028 m.insert(std::pair<int,int>(val,1));
7032 for(std::map<int,int>::iterator it=m.begin();it!=m.end();it++)
7034 int vt=(*it).second;
7038 pt=getConstPointer();
7039 opt=ret->getPointer();
7040 for(int i=0;i<nbOfTuples;i++,pt++,opt++)
7047 * Checks if contents of \a this array are equal to that of an array filled with
7048 * iota(). This method is particularly useful for DataArrayInt instances that represent
7049 * a renumbering array to check the real need in renumbering.
7050 * \return bool - \a true if \a this array contents == \a range( \a this->getNumberOfTuples())
7051 * \throw If \a this is not allocated.
7052 * \throw If \a this->getNumberOfComponents() != 1.
7054 bool DataArrayInt::isIdentity() const throw(INTERP_KERNEL::Exception)
7057 if(getNumberOfComponents()!=1)
7059 int nbOfTuples=getNumberOfTuples();
7060 const int *pt=getConstPointer();
7061 for(int i=0;i<nbOfTuples;i++,pt++)
7068 * Checks if all values in \a this array are equal to \a val.
7069 * \param [in] val - value to check equality of array values to.
7070 * \return bool - \a true if all values are \a val.
7071 * \throw If \a this is not allocated.
7072 * \throw If \a this->getNumberOfComponents() != 1
7074 bool DataArrayInt::isUniform(int val) const throw(INTERP_KERNEL::Exception)
7077 if(getNumberOfComponents()!=1)
7078 throw INTERP_KERNEL::Exception("DataArrayInt::isUniform : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
7079 int nbOfTuples=getNumberOfTuples();
7080 const int *w=getConstPointer();
7081 const int *end2=w+nbOfTuples;
7089 * Creates a new DataArrayDouble and assigns all (textual and numerical) data of \a this
7090 * array to the new one.
7091 * \return DataArrayDouble * - the new instance of DataArrayInt.
7093 DataArrayDouble *DataArrayInt::convertToDblArr() const
7096 DataArrayDouble *ret=DataArrayDouble::New();
7097 ret->alloc(getNumberOfTuples(),getNumberOfComponents());
7098 std::size_t nbOfVals=getNbOfElems();
7099 const int *src=getConstPointer();
7100 double *dest=ret->getPointer();
7101 std::copy(src,src+nbOfVals,dest);
7102 ret->copyStringInfoFrom(*this);
7107 * Returns a shorten copy of \a this array. The new DataArrayInt contains all
7108 * tuples starting from the \a tupleIdBg-th tuple and including all tuples located before
7109 * the \a tupleIdEnd-th one. This methods has a similar behavior as std::string::substr().
7110 * This method is a specialization of selectByTupleId2().
7111 * \param [in] tupleIdBg - index of the first tuple to copy from \a this array.
7112 * \param [in] tupleIdEnd - index of the tuple before which the tuples to copy are located.
7113 * If \a tupleIdEnd == -1, all the tuples till the end of \a this array are copied.
7114 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7115 * is to delete using decrRef() as it is no more needed.
7116 * \throw If \a tupleIdBg < 0.
7117 * \throw If \a tupleIdBg > \a this->getNumberOfTuples().
7118 \throw If \a tupleIdEnd != -1 && \a tupleIdEnd < \a this->getNumberOfTuples().
7119 * \sa DataArrayInt::selectByTupleId2
7121 DataArrayInt *DataArrayInt::substr(int tupleIdBg, int tupleIdEnd) const throw(INTERP_KERNEL::Exception)
7124 int nbt=getNumberOfTuples();
7126 throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter must be greater than 0 !");
7128 throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter is greater than number of tuples !");
7129 int trueEnd=tupleIdEnd;
7133 throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter is greater or equal than number of tuples !");
7137 int nbComp=getNumberOfComponents();
7138 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7139 ret->alloc(trueEnd-tupleIdBg,nbComp);
7140 ret->copyStringInfoFrom(*this);
7141 std::copy(getConstPointer()+tupleIdBg*nbComp,getConstPointer()+trueEnd*nbComp,ret->getPointer());
7146 * Changes the number of components within \a this array so that its raw data **does
7147 * not** change, instead splitting this data into tuples changes.
7148 * \warning This method erases all (name and unit) component info set before!
7149 * \param [in] newNbOfComp - number of components for \a this array to have.
7150 * \throw If \a this is not allocated
7151 * \throw If getNbOfElems() % \a newNbOfCompo != 0.
7152 * \throw If \a newNbOfCompo is lower than 1.
7153 * \throw If the rearrange method would lead to a number of tuples higher than 2147483647 (maximal capacity of int32 !).
7154 * \warning This method erases all (name and unit) component info set before!
7156 void DataArrayInt::rearrange(int newNbOfCompo) throw(INTERP_KERNEL::Exception)
7160 throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : input newNbOfCompo must be > 0 !");
7161 std::size_t nbOfElems=getNbOfElems();
7162 if(nbOfElems%newNbOfCompo!=0)
7163 throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : nbOfElems%newNbOfCompo!=0 !");
7164 if(nbOfElems/newNbOfCompo>(std::size_t)std::numeric_limits<int>::max())
7165 throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : the rearrangement leads to too high number of tuples (> 2147483647) !");
7166 _info_on_compo.clear();
7167 _info_on_compo.resize(newNbOfCompo);
7172 * Changes the number of components within \a this array to be equal to its number
7173 * of tuples, and inversely its number of tuples to become equal to its number of
7174 * components. So that its raw data **does not** change, instead splitting this
7175 * data into tuples changes.
7176 * \warning This method erases all (name and unit) component info set before!
7177 * \warning Do not confuse this method with fromNoInterlace() and toNoInterlace()!
7178 * \throw If \a this is not allocated.
7181 void DataArrayInt::transpose() throw(INTERP_KERNEL::Exception)
7184 int nbOfTuples=getNumberOfTuples();
7185 rearrange(nbOfTuples);
7189 * Returns a shorten or extended copy of \a this array. If \a newNbOfComp is less
7190 * than \a this->getNumberOfComponents() then the result array is shorten as each tuple
7191 * is truncated to have \a newNbOfComp components, keeping first components. If \a
7192 * newNbOfComp is more than \a this->getNumberOfComponents() then the result array is
7193 * expanded as each tuple is populated with \a dftValue to have \a newNbOfComp
7195 * \param [in] newNbOfComp - number of components for the new array to have.
7196 * \param [in] dftValue - value assigned to new values added to the new array.
7197 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
7198 * is to delete using decrRef() as it is no more needed.
7199 * \throw If \a this is not allocated.
7201 DataArrayInt *DataArrayInt::changeNbOfComponents(int newNbOfComp, int dftValue) const throw(INTERP_KERNEL::Exception)
7204 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7205 ret->alloc(getNumberOfTuples(),newNbOfComp);
7206 const int *oldc=getConstPointer();
7207 int *nc=ret->getPointer();
7208 int nbOfTuples=getNumberOfTuples();
7209 int oldNbOfComp=getNumberOfComponents();
7210 int dim=std::min(oldNbOfComp,newNbOfComp);
7211 for(int i=0;i<nbOfTuples;i++)
7215 nc[newNbOfComp*i+j]=oldc[i*oldNbOfComp+j];
7216 for(;j<newNbOfComp;j++)
7217 nc[newNbOfComp*i+j]=dftValue;
7219 ret->setName(getName().c_str());
7220 for(int i=0;i<dim;i++)
7221 ret->setInfoOnComponent(i,getInfoOnComponent(i).c_str());
7222 ret->setName(getName().c_str());
7227 * Changes number of tuples in the array. If the new number of tuples is smaller
7228 * than the current number the array is truncated, otherwise the array is extended.
7229 * \param [in] nbOfTuples - new number of tuples.
7230 * \throw If \a this is not allocated.
7231 * \throw If \a nbOfTuples is negative.
7233 void DataArrayInt::reAlloc(int nbOfTuples) throw(INTERP_KERNEL::Exception)
7236 throw INTERP_KERNEL::Exception("DataArrayInt::reAlloc : input new number of tuples should be >=0 !");
7238 _mem.reAlloc(getNumberOfComponents()*(std::size_t)nbOfTuples);
7244 * Returns a copy of \a this array composed of selected components.
7245 * The new DataArrayInt has the same number of tuples but includes components
7246 * specified by \a compoIds parameter. So that getNbOfElems() of the result array
7247 * can be either less, same or more than \a this->getNbOfElems().
7248 * \param [in] compoIds - sequence of zero based indices of components to include
7249 * into the new array.
7250 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7251 * is to delete using decrRef() as it is no more needed.
7252 * \throw If \a this is not allocated.
7253 * \throw If a component index (\a i) is not valid:
7254 * \a i < 0 || \a i >= \a this->getNumberOfComponents().
7256 * \ref py_mcdataarrayint_keepselectedcomponents "Here is a Python example".
7258 DataArray *DataArrayInt::keepSelectedComponents(const std::vector<int>& compoIds) const throw(INTERP_KERNEL::Exception)
7261 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
7262 int newNbOfCompo=(int)compoIds.size();
7263 int oldNbOfCompo=getNumberOfComponents();
7264 for(std::vector<int>::const_iterator it=compoIds.begin();it!=compoIds.end();it++)
7265 DataArray::CheckValueInRange(oldNbOfCompo,(*it),"keepSelectedComponents invalid requested component");
7266 int nbOfTuples=getNumberOfTuples();
7267 ret->alloc(nbOfTuples,newNbOfCompo);
7268 ret->copyPartOfStringInfoFrom(*this,compoIds);
7269 const int *oldc=getConstPointer();
7270 int *nc=ret->getPointer();
7271 for(int i=0;i<nbOfTuples;i++)
7272 for(int j=0;j<newNbOfCompo;j++,nc++)
7273 *nc=oldc[i*oldNbOfCompo+compoIds[j]];
7278 * Appends components of another array to components of \a this one, tuple by tuple.
7279 * So that the number of tuples of \a this array remains the same and the number of
7280 * components increases.
7281 * \param [in] other - the DataArrayInt to append to \a this one.
7282 * \throw If \a this is not allocated.
7283 * \throw If \a this and \a other arrays have different number of tuples.
7285 * \ref cpp_mcdataarrayint_meldwith "Here is a C++ example".
7287 * \ref py_mcdataarrayint_meldwith "Here is a Python example".
7289 void DataArrayInt::meldWith(const DataArrayInt *other) throw(INTERP_KERNEL::Exception)
7292 throw INTERP_KERNEL::Exception("DataArrayInt::meldWith : DataArrayInt pointer in input is NULL !");
7294 other->checkAllocated();
7295 int nbOfTuples=getNumberOfTuples();
7296 if(nbOfTuples!=other->getNumberOfTuples())
7297 throw INTERP_KERNEL::Exception("DataArrayInt::meldWith : mismatch of number of tuples !");
7298 int nbOfComp1=getNumberOfComponents();
7299 int nbOfComp2=other->getNumberOfComponents();
7300 int *newArr=(int *)malloc(nbOfTuples*(nbOfComp1+nbOfComp2)*sizeof(int));
7302 const int *inp1=getConstPointer();
7303 const int *inp2=other->getConstPointer();
7304 for(int i=0;i<nbOfTuples;i++,inp1+=nbOfComp1,inp2+=nbOfComp2)
7306 w=std::copy(inp1,inp1+nbOfComp1,w);
7307 w=std::copy(inp2,inp2+nbOfComp2,w);
7309 useArray(newArr,true,C_DEALLOC,nbOfTuples,nbOfComp1+nbOfComp2);
7310 std::vector<int> compIds(nbOfComp2);
7311 for(int i=0;i<nbOfComp2;i++)
7312 compIds[i]=nbOfComp1+i;
7313 copyPartOfStringInfoFrom2(compIds,*other);
7317 * Copy all components in a specified order from another DataArrayInt.
7318 * The specified components become the first ones in \a this array.
7319 * Both numerical and textual data is copied. The number of tuples in \a this and
7320 * the other array can be different.
7321 * \param [in] a - the array to copy data from.
7322 * \param [in] compoIds - sequence of zero based indices of components, data of which is
7324 * \throw If \a a is NULL.
7325 * \throw If \a compoIds.size() != \a a->getNumberOfComponents().
7326 * \throw If \a compoIds[i] < 0 or \a compoIds[i] > \a this->getNumberOfComponents().
7328 * \ref py_mcdataarrayint_setselectedcomponents "Here is a Python example".
7330 void DataArrayInt::setSelectedComponents(const DataArrayInt *a, const std::vector<int>& compoIds) throw(INTERP_KERNEL::Exception)
7333 throw INTERP_KERNEL::Exception("DataArrayInt::setSelectedComponents : input DataArrayInt is NULL !");
7335 a->checkAllocated();
7336 copyPartOfStringInfoFrom2(compoIds,*a);
7337 std::size_t partOfCompoSz=compoIds.size();
7338 int nbOfCompo=getNumberOfComponents();
7339 int nbOfTuples=std::min(getNumberOfTuples(),a->getNumberOfTuples());
7340 const int *ac=a->getConstPointer();
7341 int *nc=getPointer();
7342 for(int i=0;i<nbOfTuples;i++)
7343 for(std::size_t j=0;j<partOfCompoSz;j++,ac++)
7344 nc[nbOfCompo*i+compoIds[j]]=*ac;
7348 * Copy all values from another DataArrayInt into specified tuples and components
7349 * of \a this array. Textual data is not copied.
7350 * The tree parameters defining set of indices of tuples and components are similar to
7351 * the tree parameters of the Python function \c range(\c start,\c stop,\c step).
7352 * \param [in] a - the array to copy values from.
7353 * \param [in] bgTuples - index of the first tuple of \a this array to assign values to.
7354 * \param [in] endTuples - index of the tuple before which the tuples to assign to
7356 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
7357 * \param [in] bgComp - index of the first component of \a this array to assign values to.
7358 * \param [in] endComp - index of the component before which the components to assign
7360 * \param [in] stepComp - index increment to get index of the next component to assign to.
7361 * \param [in] strictCompoCompare - if \a true (by default), then \a a->getNumberOfComponents()
7362 * must be equal to the number of columns to assign to, else an
7363 * exception is thrown; if \a false, then it is only required that \a
7364 * a->getNbOfElems() equals to number of values to assign to (this condition
7365 * must be respected even if \a strictCompoCompare is \a true). The number of
7366 * values to assign to is given by following Python expression:
7367 * \a nbTargetValues =
7368 * \c len(\c range(\a bgTuples,\a endTuples,\a stepTuples)) *
7369 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
7370 * \throw If \a a is NULL.
7371 * \throw If \a a is not allocated.
7372 * \throw If \a this is not allocated.
7373 * \throw If parameters specifying tuples and components to assign to do not give a
7374 * non-empty range of increasing indices.
7375 * \throw If \a a->getNbOfElems() != \a nbTargetValues.
7376 * \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
7377 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
7379 * \ref py_mcdataarrayint_setpartofvalues1 "Here is a Python example".
7381 void DataArrayInt::setPartOfValues1(const DataArrayInt *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare) throw(INTERP_KERNEL::Exception)
7384 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues1 : DataArrayInt pointer in input is NULL !");
7385 const char msg[]="DataArrayInt::setPartOfValues1";
7387 a->checkAllocated();
7388 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
7389 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
7390 int nbComp=getNumberOfComponents();
7391 int nbOfTuples=getNumberOfTuples();
7392 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
7393 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
7394 bool assignTech=true;
7395 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
7397 if(strictCompoCompare)
7398 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
7402 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
7405 int *pt=getPointer()+bgTuples*nbComp+bgComp;
7406 const int *srcPt=a->getConstPointer();
7409 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
7410 for(int j=0;j<newNbOfComp;j++,srcPt++)
7411 pt[j*stepComp]=*srcPt;
7415 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
7417 const int *srcPt2=srcPt;
7418 for(int j=0;j<newNbOfComp;j++,srcPt2++)
7419 pt[j*stepComp]=*srcPt2;
7425 * Assign a given value to values at specified tuples and components of \a this array.
7426 * The tree parameters defining set of indices of tuples and components are similar to
7427 * the tree parameters of the Python function \c range(\c start,\c stop,\c step)..
7428 * \param [in] a - the value to assign.
7429 * \param [in] bgTuples - index of the first tuple of \a this array to assign to.
7430 * \param [in] endTuples - index of the tuple before which the tuples to assign to
7432 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
7433 * \param [in] bgComp - index of the first component of \a this array to assign to.
7434 * \param [in] endComp - index of the component before which the components to assign
7436 * \param [in] stepComp - index increment to get index of the next component to assign to.
7437 * \throw If \a this is not allocated.
7438 * \throw If parameters specifying tuples and components to assign to, do not give a
7439 * non-empty range of increasing indices or indices are out of a valid range
7442 * \ref py_mcdataarrayint_setpartofvaluessimple1 "Here is a Python example".
7444 void DataArrayInt::setPartOfValuesSimple1(int a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp) throw(INTERP_KERNEL::Exception)
7446 const char msg[]="DataArrayInt::setPartOfValuesSimple1";
7448 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
7449 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
7450 int nbComp=getNumberOfComponents();
7451 int nbOfTuples=getNumberOfTuples();
7452 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
7453 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
7454 int *pt=getPointer()+bgTuples*nbComp+bgComp;
7455 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
7456 for(int j=0;j<newNbOfComp;j++)
7462 * Copy all values from another DataArrayInt (\a a) into specified tuples and
7463 * components of \a this array. Textual data is not copied.
7464 * The tuples and components to assign to are defined by C arrays of indices.
7465 * There are two *modes of usage*:
7466 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
7467 * of \a a is assigned to its own location within \a this array.
7468 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
7469 * components of every specified tuple of \a this array. In this mode it is required
7470 * that \a a->getNumberOfComponents() equals to the number of specified components.
7472 * \param [in] a - the array to copy values from.
7473 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
7474 * assign values of \a a to.
7475 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
7476 * pointer to a tuple index <em>(pi)</em> varies as this:
7477 * \a bgTuples <= \a pi < \a endTuples.
7478 * \param [in] bgComp - pointer to an array of component indices of \a this array to
7479 * assign values of \a a to.
7480 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
7481 * pointer to a component index <em>(pi)</em> varies as this:
7482 * \a bgComp <= \a pi < \a endComp.
7483 * \param [in] strictCompoCompare - this parameter is checked only if the
7484 * *mode of usage* is the first; if it is \a true (default),
7485 * then \a a->getNumberOfComponents() must be equal
7486 * to the number of specified columns, else this is not required.
7487 * \throw If \a a is NULL.
7488 * \throw If \a a is not allocated.
7489 * \throw If \a this is not allocated.
7490 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
7491 * out of a valid range for \a this array.
7492 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
7493 * if <em> a->getNumberOfComponents() != (endComp - bgComp) </em>.
7494 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
7495 * <em> a->getNumberOfComponents() != (endComp - bgComp)</em>.
7497 * \ref py_mcdataarrayint_setpartofvalues2 "Here is a Python example".
7499 void DataArrayInt::setPartOfValues2(const DataArrayInt *a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp, bool strictCompoCompare) throw(INTERP_KERNEL::Exception)
7502 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues2 : DataArrayInt pointer in input is NULL !");
7503 const char msg[]="DataArrayInt::setPartOfValues2";
7505 a->checkAllocated();
7506 int nbComp=getNumberOfComponents();
7507 int nbOfTuples=getNumberOfTuples();
7508 for(const int *z=bgComp;z!=endComp;z++)
7509 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
7510 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
7511 int newNbOfComp=(int)std::distance(bgComp,endComp);
7512 bool assignTech=true;
7513 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
7515 if(strictCompoCompare)
7516 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
7520 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
7523 int *pt=getPointer();
7524 const int *srcPt=a->getConstPointer();
7527 for(const int *w=bgTuples;w!=endTuples;w++)
7529 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
7530 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
7532 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt;
7538 for(const int *w=bgTuples;w!=endTuples;w++)
7540 const int *srcPt2=srcPt;
7541 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
7542 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
7544 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt2;
7551 * Assign a given value to values at specified tuples and components of \a this array.
7552 * The tuples and components to assign to are defined by C arrays of indices.
7553 * \param [in] a - the value to assign.
7554 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
7556 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
7557 * pointer to a tuple index (\a pi) varies as this:
7558 * \a bgTuples <= \a pi < \a endTuples.
7559 * \param [in] bgComp - pointer to an array of component indices of \a this array to
7561 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
7562 * pointer to a component index (\a pi) varies as this:
7563 * \a bgComp <= \a pi < \a endComp.
7564 * \throw If \a this is not allocated.
7565 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
7566 * out of a valid range for \a this array.
7568 * \ref py_mcdataarrayint_setpartofvaluessimple2 "Here is a Python example".
7570 void DataArrayInt::setPartOfValuesSimple2(int a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp) throw(INTERP_KERNEL::Exception)
7573 int nbComp=getNumberOfComponents();
7574 int nbOfTuples=getNumberOfTuples();
7575 for(const int *z=bgComp;z!=endComp;z++)
7576 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
7577 int *pt=getPointer();
7578 for(const int *w=bgTuples;w!=endTuples;w++)
7579 for(const int *z=bgComp;z!=endComp;z++)
7581 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
7582 pt[(std::size_t)(*w)*nbComp+(*z)]=a;
7587 * Copy all values from another DataArrayInt (\a a) into specified tuples and
7588 * components of \a this array. Textual data is not copied.
7589 * The tuples to assign to are defined by a C array of indices.
7590 * The components to assign to are defined by three values similar to parameters of
7591 * the Python function \c range(\c start,\c stop,\c step).
7592 * There are two *modes of usage*:
7593 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
7594 * of \a a is assigned to its own location within \a this array.
7595 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
7596 * components of every specified tuple of \a this array. In this mode it is required
7597 * that \a a->getNumberOfComponents() equals to the number of specified components.
7599 * \param [in] a - the array to copy values from.
7600 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
7601 * assign values of \a a to.
7602 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
7603 * pointer to a tuple index <em>(pi)</em> varies as this:
7604 * \a bgTuples <= \a pi < \a endTuples.
7605 * \param [in] bgComp - index of the first component of \a this array to assign to.
7606 * \param [in] endComp - index of the component before which the components to assign
7608 * \param [in] stepComp - index increment to get index of the next component to assign to.
7609 * \param [in] strictCompoCompare - this parameter is checked only in the first
7610 * *mode of usage*; if \a strictCompoCompare is \a true (default),
7611 * then \a a->getNumberOfComponents() must be equal
7612 * to the number of specified columns, else this is not required.
7613 * \throw If \a a is NULL.
7614 * \throw If \a a is not allocated.
7615 * \throw If \a this is not allocated.
7616 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
7618 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
7619 * if <em> a->getNumberOfComponents()</em> is unequal to the number of components
7620 * defined by <em>(bgComp,endComp,stepComp)</em>.
7621 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
7622 * <em> a->getNumberOfComponents()</em> is unequal to the number of components
7623 * defined by <em>(bgComp,endComp,stepComp)</em>.
7624 * \throw If parameters specifying components to assign to, do not give a
7625 * non-empty range of increasing indices or indices are out of a valid range
7628 * \ref py_mcdataarrayint_setpartofvalues3 "Here is a Python example".
7630 void DataArrayInt::setPartOfValues3(const DataArrayInt *a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare) throw(INTERP_KERNEL::Exception)
7633 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues3 : DataArrayInt pointer in input is NULL !");
7634 const char msg[]="DataArrayInt::setPartOfValues3";
7636 a->checkAllocated();
7637 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
7638 int nbComp=getNumberOfComponents();
7639 int nbOfTuples=getNumberOfTuples();
7640 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
7641 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
7642 bool assignTech=true;
7643 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
7645 if(strictCompoCompare)
7646 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
7650 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
7653 int *pt=getPointer()+bgComp;
7654 const int *srcPt=a->getConstPointer();
7657 for(const int *w=bgTuples;w!=endTuples;w++)
7658 for(int j=0;j<newNbOfComp;j++,srcPt++)
7660 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
7661 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt;
7666 for(const int *w=bgTuples;w!=endTuples;w++)
7668 const int *srcPt2=srcPt;
7669 for(int j=0;j<newNbOfComp;j++,srcPt2++)
7671 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
7672 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt2;
7679 * Assign a given value to values at specified tuples and components of \a this array.
7680 * The tuples to assign to are defined by a C array of indices.
7681 * The components to assign to are defined by three values similar to parameters of
7682 * the Python function \c range(\c start,\c stop,\c step).
7683 * \param [in] a - the value to assign.
7684 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
7686 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
7687 * pointer to a tuple index <em>(pi)</em> varies as this:
7688 * \a bgTuples <= \a pi < \a endTuples.
7689 * \param [in] bgComp - index of the first component of \a this array to assign to.
7690 * \param [in] endComp - index of the component before which the components to assign
7692 * \param [in] stepComp - index increment to get index of the next component to assign to.
7693 * \throw If \a this is not allocated.
7694 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
7696 * \throw If parameters specifying components to assign to, do not give a
7697 * non-empty range of increasing indices or indices are out of a valid range
7700 * \ref py_mcdataarrayint_setpartofvaluessimple3 "Here is a Python example".
7702 void DataArrayInt::setPartOfValuesSimple3(int a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp) throw(INTERP_KERNEL::Exception)
7704 const char msg[]="DataArrayInt::setPartOfValuesSimple3";
7706 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
7707 int nbComp=getNumberOfComponents();
7708 int nbOfTuples=getNumberOfTuples();
7709 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
7710 int *pt=getPointer()+bgComp;
7711 for(const int *w=bgTuples;w!=endTuples;w++)
7712 for(int j=0;j<newNbOfComp;j++)
7714 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
7715 pt[(std::size_t)(*w)*nbComp+j*stepComp]=a;
7719 void DataArrayInt::setPartOfValues4(const DataArrayInt *a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp, bool strictCompoCompare) throw(INTERP_KERNEL::Exception)
7722 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues4 : input DataArrayInt is NULL !");
7723 const char msg[]="DataArrayInt::setPartOfValues4";
7725 a->checkAllocated();
7726 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
7727 int newNbOfComp=(int)std::distance(bgComp,endComp);
7728 int nbComp=getNumberOfComponents();
7729 for(const int *z=bgComp;z!=endComp;z++)
7730 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
7731 int nbOfTuples=getNumberOfTuples();
7732 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
7733 bool assignTech=true;
7734 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
7736 if(strictCompoCompare)
7737 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
7741 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
7744 const int *srcPt=a->getConstPointer();
7745 int *pt=getPointer()+bgTuples*nbComp;
7748 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
7749 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
7754 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
7756 const int *srcPt2=srcPt;
7757 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
7763 void DataArrayInt::setPartOfValuesSimple4(int a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp) throw(INTERP_KERNEL::Exception)
7765 const char msg[]="DataArrayInt::setPartOfValuesSimple4";
7767 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
7768 int nbComp=getNumberOfComponents();
7769 for(const int *z=bgComp;z!=endComp;z++)
7770 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
7771 int nbOfTuples=getNumberOfTuples();
7772 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
7773 int *pt=getPointer()+bgTuples*nbComp;
7774 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
7775 for(const int *z=bgComp;z!=endComp;z++)
7780 * Copy some tuples from another DataArrayInt into specified tuples
7781 * of \a this array. Textual data is not copied. Both arrays must have equal number of
7783 * Both the tuples to assign and the tuples to assign to are defined by a DataArrayInt.
7784 * All components of selected tuples are copied.
7785 * \param [in] a - the array to copy values from.
7786 * \param [in] tuplesSelec - the array specifying both source tuples of \a a and
7787 * target tuples of \a this. \a tuplesSelec has two components, and the
7788 * first component specifies index of the source tuple and the second
7789 * one specifies index of the target tuple.
7790 * \throw If \a this is not allocated.
7791 * \throw If \a a is NULL.
7792 * \throw If \a a is not allocated.
7793 * \throw If \a tuplesSelec is NULL.
7794 * \throw If \a tuplesSelec is not allocated.
7795 * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
7796 * \throw If \a tuplesSelec->getNumberOfComponents() != 2.
7797 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
7798 * the corresponding (\a this or \a a) array.
7800 void DataArrayInt::setPartOfValuesAdv(const DataArrayInt *a, const DataArrayInt *tuplesSelec) throw(INTERP_KERNEL::Exception)
7802 if(!a || !tuplesSelec)
7803 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : DataArrayInt pointer in input is NULL !");
7805 a->checkAllocated();
7806 tuplesSelec->checkAllocated();
7807 int nbOfComp=getNumberOfComponents();
7808 if(nbOfComp!=a->getNumberOfComponents())
7809 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : This and a do not have the same number of components !");
7810 if(tuplesSelec->getNumberOfComponents()!=2)
7811 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : Expecting to have a tuple selector DataArrayInt instance with exactly 2 components !");
7812 int thisNt=getNumberOfTuples();
7813 int aNt=a->getNumberOfTuples();
7814 int *valsToSet=getPointer();
7815 const int *valsSrc=a->getConstPointer();
7816 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple+=2)
7818 if(tuple[1]>=0 && tuple[1]<aNt)
7820 if(tuple[0]>=0 && tuple[0]<thisNt)
7821 std::copy(valsSrc+nbOfComp*tuple[1],valsSrc+nbOfComp*(tuple[1]+1),valsToSet+nbOfComp*tuple[0]);
7824 std::ostringstream oss; oss << "DataArrayInt::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
7825 oss << " of 'tuplesSelec' request of tuple id #" << tuple[0] << " in 'this' ! It should be in [0," << thisNt << ") !";
7826 throw INTERP_KERNEL::Exception(oss.str().c_str());
7831 std::ostringstream oss; oss << "DataArrayInt::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
7832 oss << " of 'tuplesSelec' request of tuple id #" << tuple[1] << " in 'a' ! It should be in [0," << aNt << ") !";
7833 throw INTERP_KERNEL::Exception(oss.str().c_str());
7839 * Copy some tuples from another DataArrayInt (\a a) into contiguous tuples
7840 * of \a this array. Textual data is not copied. Both arrays must have equal number of
7842 * The tuples to assign to are defined by index of the first tuple, and
7843 * their number is defined by \a tuplesSelec->getNumberOfTuples().
7844 * The tuples to copy are defined by values of a DataArrayInt.
7845 * All components of selected tuples are copied.
7846 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
7848 * \param [in] a - the array to copy values from.
7849 * \param [in] tuplesSelec - the array specifying tuples of \a a to copy.
7850 * \throw If \a this is not allocated.
7851 * \throw If \a a is NULL.
7852 * \throw If \a a is not allocated.
7853 * \throw If \a tuplesSelec is NULL.
7854 * \throw If \a tuplesSelec is not allocated.
7855 * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
7856 * \throw If \a tuplesSelec->getNumberOfComponents() != 1.
7857 * \throw If <em>tupleIdStart + tuplesSelec->getNumberOfTuples() > this->getNumberOfTuples().</em>
7858 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
7861 void DataArrayInt::setContigPartOfSelectedValues(int tupleIdStart, const DataArray *aBase, const DataArrayInt *tuplesSelec) throw(INTERP_KERNEL::Exception)
7863 if(!aBase || !tuplesSelec)
7864 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : input DataArray is NULL !");
7865 const DataArrayInt *a=dynamic_cast<const DataArrayInt *>(aBase);
7867 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : input DataArray aBase is not a DataArrayInt !");
7869 a->checkAllocated();
7870 tuplesSelec->checkAllocated();
7871 int nbOfComp=getNumberOfComponents();
7872 if(nbOfComp!=a->getNumberOfComponents())
7873 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : This and a do not have the same number of components !");
7874 if(tuplesSelec->getNumberOfComponents()!=1)
7875 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : Expecting to have a tuple selector DataArrayInt instance with exactly 1 component !");
7876 int thisNt=getNumberOfTuples();
7877 int aNt=a->getNumberOfTuples();
7878 int nbOfTupleToWrite=tuplesSelec->getNumberOfTuples();
7879 int *valsToSet=getPointer()+tupleIdStart*nbOfComp;
7880 if(tupleIdStart+nbOfTupleToWrite>thisNt)
7881 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : invalid number range of values to write !");
7882 const int *valsSrc=a->getConstPointer();
7883 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple++,valsToSet+=nbOfComp)
7885 if(*tuple>=0 && *tuple<aNt)
7887 std::copy(valsSrc+nbOfComp*(*tuple),valsSrc+nbOfComp*(*tuple+1),valsToSet);
7891 std::ostringstream oss; oss << "DataArrayInt::setContigPartOfSelectedValues : Tuple #" << std::distance(tuplesSelec->begin(),tuple);
7892 oss << " of 'tuplesSelec' request of tuple id #" << *tuple << " in 'a' ! It should be in [0," << aNt << ") !";
7893 throw INTERP_KERNEL::Exception(oss.str().c_str());
7899 * Copy some tuples from another DataArrayInt (\a a) into contiguous tuples
7900 * of \a this array. Textual data is not copied. Both arrays must have equal number of
7902 * The tuples to copy are defined by three values similar to parameters of
7903 * the Python function \c range(\c start,\c stop,\c step).
7904 * The tuples to assign to are defined by index of the first tuple, and
7905 * their number is defined by number of tuples to copy.
7906 * All components of selected tuples are copied.
7907 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
7909 * \param [in] a - the array to copy values from.
7910 * \param [in] bg - index of the first tuple to copy of the array \a a.
7911 * \param [in] end2 - index of the tuple of \a a before which the tuples to copy
7913 * \param [in] step - index increment to get index of the next tuple to copy.
7914 * \throw If \a this is not allocated.
7915 * \throw If \a a is NULL.
7916 * \throw If \a a is not allocated.
7917 * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
7918 * \throw If <em>tupleIdStart + len(range(bg,end2,step)) > this->getNumberOfTuples().</em>
7919 * \throw If parameters specifying tuples to copy, do not give a
7920 * non-empty range of increasing indices or indices are out of a valid range
7921 * for the array \a a.
7923 void DataArrayInt::setContigPartOfSelectedValues2(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step) throw(INTERP_KERNEL::Exception)
7926 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : input DataArray is NULL !");
7927 const DataArrayInt *a=dynamic_cast<const DataArrayInt *>(aBase);
7929 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : input DataArray aBase is not a DataArrayInt !");
7931 a->checkAllocated();
7932 int nbOfComp=getNumberOfComponents();
7933 const char msg[]="DataArrayInt::setContigPartOfSelectedValues2";
7934 int nbOfTupleToWrite=DataArray::GetNumberOfItemGivenBES(bg,end2,step,msg);
7935 if(nbOfComp!=a->getNumberOfComponents())
7936 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : This and a do not have the same number of components !");
7937 int thisNt=getNumberOfTuples();
7938 int aNt=a->getNumberOfTuples();
7939 int *valsToSet=getPointer()+tupleIdStart*nbOfComp;
7940 if(tupleIdStart+nbOfTupleToWrite>thisNt)
7941 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : invalid number range of values to write !");
7943 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : invalid range of values to read !");
7944 const int *valsSrc=a->getConstPointer()+bg*nbOfComp;
7945 for(int i=0;i<nbOfTupleToWrite;i++,valsToSet+=nbOfComp,valsSrc+=step*nbOfComp)
7947 std::copy(valsSrc,valsSrc+nbOfComp,valsToSet);
7952 * Returns a value located at specified tuple and component.
7953 * This method is equivalent to DataArrayInt::getIJ() except that validity of
7954 * parameters is checked. So this method is safe but expensive if used to go through
7955 * all values of \a this.
7956 * \param [in] tupleId - index of tuple of interest.
7957 * \param [in] compoId - index of component of interest.
7958 * \return double - value located by \a tupleId and \a compoId.
7959 * \throw If \a this is not allocated.
7960 * \throw If condition <em>( 0 <= tupleId < this->getNumberOfTuples() )</em> is violated.
7961 * \throw If condition <em>( 0 <= compoId < this->getNumberOfComponents() )</em> is violated.
7963 int DataArrayInt::getIJSafe(int tupleId, int compoId) const throw(INTERP_KERNEL::Exception)
7966 if(tupleId<0 || tupleId>=getNumberOfTuples())
7968 std::ostringstream oss; oss << "DataArrayInt::getIJSafe : request for tupleId " << tupleId << " should be in [0," << getNumberOfTuples() << ") !";
7969 throw INTERP_KERNEL::Exception(oss.str().c_str());
7971 if(compoId<0 || compoId>=getNumberOfComponents())
7973 std::ostringstream oss; oss << "DataArrayInt::getIJSafe : request for compoId " << compoId << " should be in [0," << getNumberOfComponents() << ") !";
7974 throw INTERP_KERNEL::Exception(oss.str().c_str());
7976 return _mem[tupleId*_info_on_compo.size()+compoId];
7980 * Returns the first value of \a this.
7981 * \return int - the last value of \a this array.
7982 * \throw If \a this is not allocated.
7983 * \throw If \a this->getNumberOfComponents() != 1.
7984 * \throw If \a this->getNumberOfTuples() < 1.
7986 int DataArrayInt::front() const throw(INTERP_KERNEL::Exception)
7989 if(getNumberOfComponents()!=1)
7990 throw INTERP_KERNEL::Exception("DataArrayInt::front : number of components not equal to one !");
7991 int nbOfTuples=getNumberOfTuples();
7993 throw INTERP_KERNEL::Exception("DataArrayInt::front : number of tuples must be >= 1 !");
7994 return *(getConstPointer());
7998 * Returns the last value of \a this.
7999 * \return int - the last value of \a this array.
8000 * \throw If \a this is not allocated.
8001 * \throw If \a this->getNumberOfComponents() != 1.
8002 * \throw If \a this->getNumberOfTuples() < 1.
8004 int DataArrayInt::back() const throw(INTERP_KERNEL::Exception)
8007 if(getNumberOfComponents()!=1)
8008 throw INTERP_KERNEL::Exception("DataArrayInt::back : number of components not equal to one !");
8009 int nbOfTuples=getNumberOfTuples();
8011 throw INTERP_KERNEL::Exception("DataArrayInt::back : number of tuples must be >= 1 !");
8012 return *(getConstPointer()+nbOfTuples-1);
8016 * Assign pointer to one array to a pointer to another appay. Reference counter of
8017 * \a arrayToSet is incremented / decremented.
8018 * \param [in] newArray - the pointer to array to assign to \a arrayToSet.
8019 * \param [in,out] arrayToSet - the pointer to array to assign to.
8021 void DataArrayInt::SetArrayIn(DataArrayInt *newArray, DataArrayInt* &arrayToSet)
8023 if(newArray!=arrayToSet)
8026 arrayToSet->decrRef();
8027 arrayToSet=newArray;
8029 arrayToSet->incrRef();
8033 DataArrayIntIterator *DataArrayInt::iterator() throw(INTERP_KERNEL::Exception)
8035 return new DataArrayIntIterator(this);
8039 * Creates a new DataArrayInt containing IDs (indices) of tuples holding value equal to a
8041 * \param [in] val - the value to find within \a this.
8042 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8043 * array using decrRef() as it is no more needed.
8044 * \throw If \a this is not allocated.
8045 * \throw If \a this->getNumberOfComponents() != 1.
8047 DataArrayInt *DataArrayInt::getIdsEqual(int val) const throw(INTERP_KERNEL::Exception)
8050 if(getNumberOfComponents()!=1)
8051 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqual : the array must have only one component, you can call 'rearrange' method before !");
8052 const int *cptr=getConstPointer();
8053 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8054 int nbOfTuples=getNumberOfTuples();
8055 for(int i=0;i<nbOfTuples;i++,cptr++)
8057 ret->pushBackSilent(i);
8062 * Creates a new DataArrayInt containing IDs (indices) of tuples holding value \b not
8063 * equal to a given one.
8064 * \param [in] val - the value to ignore within \a this.
8065 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8066 * array using decrRef() as it is no more needed.
8067 * \throw If \a this is not allocated.
8068 * \throw If \a this->getNumberOfComponents() != 1.
8070 DataArrayInt *DataArrayInt::getIdsNotEqual(int val) const throw(INTERP_KERNEL::Exception)
8073 if(getNumberOfComponents()!=1)
8074 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotEqual : the array must have only one component, you can call 'rearrange' method before !");
8075 const int *cptr=getConstPointer();
8076 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8077 int nbOfTuples=getNumberOfTuples();
8078 for(int i=0;i<nbOfTuples;i++,cptr++)
8080 ret->pushBackSilent(i);
8086 * Assigns \a newValue to all elements holding \a oldValue within \a this
8087 * one-dimensional array.
8088 * \param [in] oldValue - the value to replace.
8089 * \param [in] newValue - the value to assign.
8090 * \return int - number of replacements performed.
8091 * \throw If \a this is not allocated.
8092 * \throw If \a this->getNumberOfComponents() != 1.
8094 int DataArrayInt::changeValue(int oldValue, int newValue) throw(INTERP_KERNEL::Exception)
8097 if(getNumberOfComponents()!=1)
8098 throw INTERP_KERNEL::Exception("DataArrayInt::changeValue : the array must have only one component, you can call 'rearrange' method before !");
8099 int *start=getPointer();
8100 int *end2=start+getNbOfElems();
8102 for(int *val=start;val!=end2;val++)
8114 * Creates a new DataArrayInt containing IDs (indices) of tuples holding value equal to
8115 * one of given values.
8116 * \param [in] valsBg - an array of values to find within \a this array.
8117 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
8118 * the last value of \a valsBg is \a valsEnd[ -1 ].
8119 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8120 * array using decrRef() as it is no more needed.
8121 * \throw If \a this->getNumberOfComponents() != 1.
8123 DataArrayInt *DataArrayInt::getIdsEqualList(const int *valsBg, const int *valsEnd) const throw(INTERP_KERNEL::Exception)
8125 if(getNumberOfComponents()!=1)
8126 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqualList : the array must have only one component, you can call 'rearrange' method before !");
8127 std::set<int> vals2(valsBg,valsEnd);
8128 const int *cptr=getConstPointer();
8129 std::vector<int> res;
8130 int nbOfTuples=getNumberOfTuples();
8131 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8132 for(int i=0;i<nbOfTuples;i++,cptr++)
8133 if(vals2.find(*cptr)!=vals2.end())
8134 ret->pushBackSilent(i);
8139 * Creates a new DataArrayInt containing IDs (indices) of tuples holding values \b not
8140 * equal to any of given values.
8141 * \param [in] valsBg - an array of values to ignore within \a this array.
8142 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
8143 * the last value of \a valsBg is \a valsEnd[ -1 ].
8144 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8145 * array using decrRef() as it is no more needed.
8146 * \throw If \a this->getNumberOfComponents() != 1.
8148 DataArrayInt *DataArrayInt::getIdsNotEqualList(const int *valsBg, const int *valsEnd) const throw(INTERP_KERNEL::Exception)
8150 if(getNumberOfComponents()!=1)
8151 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotEqualList : the array must have only one component, you can call 'rearrange' method before !");
8152 std::set<int> vals2(valsBg,valsEnd);
8153 const int *cptr=getConstPointer();
8154 std::vector<int> res;
8155 int nbOfTuples=getNumberOfTuples();
8156 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8157 for(int i=0;i<nbOfTuples;i++,cptr++)
8158 if(vals2.find(*cptr)==vals2.end())
8159 ret->pushBackSilent(i);
8164 * This method is an extension of DataArrayInt::locateValue method because this method works for DataArrayInt with
8165 * any number of components excepted 0 (an INTERP_KERNEL::Exception is thrown in this case).
8166 * This method searches in \b this is there is a tuple that matched the input parameter \b tupl.
8167 * If any the tuple id is returned. If not -1 is returned.
8169 * This method throws an INTERP_KERNEL::Exception if the number of components in \b this mismatches with the size of
8170 * the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
8172 * \return tuple id where \b tupl is. -1 if no such tuple exists in \b this.
8173 * \sa DataArrayInt::search, DataArrayInt::presenceOfTuple.
8175 int DataArrayInt::locateTuple(const std::vector<int>& tupl) const throw(INTERP_KERNEL::Exception)
8178 int nbOfCompo=getNumberOfComponents();
8180 throw INTERP_KERNEL::Exception("DataArrayInt::locateTuple : 0 components in 'this' !");
8181 if(nbOfCompo!=(int)tupl.size())
8183 std::ostringstream oss; oss << "DataArrayInt::locateTuple : 'this' contains " << nbOfCompo << " components and searching for a tuple of length " << tupl.size() << " !";
8184 throw INTERP_KERNEL::Exception(oss.str().c_str());
8186 const int *cptr=getConstPointer();
8187 std::size_t nbOfVals=getNbOfElems();
8188 for(const int *work=cptr;work!=cptr+nbOfVals;)
8190 work=std::search(work,cptr+nbOfVals,tupl.begin(),tupl.end());
8191 if(work!=cptr+nbOfVals)
8193 if(std::distance(cptr,work)%nbOfCompo!=0)
8196 return std::distance(cptr,work)/nbOfCompo;
8203 * This method searches the sequence specified in input parameter \b vals in \b this.
8204 * This works only for DataArrayInt having number of components equal to one (if not an INTERP_KERNEL::Exception will be thrown).
8205 * This method differs from DataArrayInt::locateTuple in that the position is internal raw data is not considered here contrary to DataArrayInt::locateTuple.
8206 * \sa DataArrayInt::locateTuple
8208 int DataArrayInt::search(const std::vector<int>& vals) const throw(INTERP_KERNEL::Exception)
8211 int nbOfCompo=getNumberOfComponents();
8213 throw INTERP_KERNEL::Exception("DataArrayInt::search : works only for DataArrayInt instance with one component !");
8214 const int *cptr=getConstPointer();
8215 std::size_t nbOfVals=getNbOfElems();
8216 const int *loc=std::search(cptr,cptr+nbOfVals,vals.begin(),vals.end());
8217 if(loc!=cptr+nbOfVals)
8218 return std::distance(cptr,loc);
8223 * This method expects to be called when number of components of this is equal to one.
8224 * This method returns the tuple id, if it exists, of the first tuple equal to \b value.
8225 * If not any tuple contains \b value -1 is returned.
8226 * \sa DataArrayInt::presenceOfValue
8228 int DataArrayInt::locateValue(int value) const throw(INTERP_KERNEL::Exception)
8231 if(getNumberOfComponents()!=1)
8232 throw INTERP_KERNEL::Exception("DataArrayInt::presenceOfValue : the array must have only one component, you can call 'rearrange' method before !");
8233 const int *cptr=getConstPointer();
8234 int nbOfTuples=getNumberOfTuples();
8235 const int *ret=std::find(cptr,cptr+nbOfTuples,value);
8236 if(ret!=cptr+nbOfTuples)
8237 return std::distance(cptr,ret);
8242 * This method expects to be called when number of components of this is equal to one.
8243 * This method returns the tuple id, if it exists, of the first tuple so that the value is contained in \b vals.
8244 * If not any tuple contains one of the values contained in 'vals' false is returned.
8245 * \sa DataArrayInt::presenceOfValue
8247 int DataArrayInt::locateValue(const std::vector<int>& vals) const throw(INTERP_KERNEL::Exception)
8250 if(getNumberOfComponents()!=1)
8251 throw INTERP_KERNEL::Exception("DataArrayInt::presenceOfValue : the array must have only one component, you can call 'rearrange' method before !");
8252 std::set<int> vals2(vals.begin(),vals.end());
8253 const int *cptr=getConstPointer();
8254 int nbOfTuples=getNumberOfTuples();
8255 for(const int *w=cptr;w!=cptr+nbOfTuples;w++)
8256 if(vals2.find(*w)!=vals2.end())
8257 return std::distance(cptr,w);
8262 * This method returns the number of values in \a this that are equals to input parameter \a value.
8263 * This method only works for single component array.
8265 * \return a value in [ 0, \c this->getNumberOfTuples() )
8267 * \throw If \a this is not allocated
8270 int DataArrayInt::count(int value) const throw(INTERP_KERNEL::Exception)
8274 if(getNumberOfComponents()!=1)
8275 throw INTERP_KERNEL::Exception("DataArrayInt::count : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
8276 const int *vals=begin();
8277 int nbOfTuples=getNumberOfTuples();
8278 for(int i=0;i<nbOfTuples;i++,vals++)
8285 * This method is an extension of DataArrayInt::presenceOfValue method because this method works for DataArrayInt with
8286 * any number of components excepted 0 (an INTERP_KERNEL::Exception is thrown in this case).
8287 * This method searches in \b this is there is a tuple that matched the input parameter \b tupl.
8288 * This method throws an INTERP_KERNEL::Exception if the number of components in \b this mismatches with the size of
8289 * the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
8290 * \sa DataArrayInt::locateTuple
8292 bool DataArrayInt::presenceOfTuple(const std::vector<int>& tupl) const throw(INTERP_KERNEL::Exception)
8294 return locateTuple(tupl)!=-1;
8299 * Returns \a true if a given value is present within \a this one-dimensional array.
8300 * \param [in] value - the value to find within \a this array.
8301 * \return bool - \a true in case if \a value is present within \a this array.
8302 * \throw If \a this is not allocated.
8303 * \throw If \a this->getNumberOfComponents() != 1.
8306 bool DataArrayInt::presenceOfValue(int value) const throw(INTERP_KERNEL::Exception)
8308 return locateValue(value)!=-1;
8312 * This method expects to be called when number of components of this is equal to one.
8313 * This method returns true if it exists a tuple so that the value is contained in \b vals.
8314 * If not any tuple contains one of the values contained in 'vals' false is returned.
8315 * \sa DataArrayInt::locateValue
8317 bool DataArrayInt::presenceOfValue(const std::vector<int>& vals) const throw(INTERP_KERNEL::Exception)
8319 return locateValue(vals)!=-1;
8323 * Accumulates values of each component of \a this array.
8324 * \param [out] res - an array of length \a this->getNumberOfComponents(), allocated
8325 * by the caller, that is filled by this method with sum value for each
8327 * \throw If \a this is not allocated.
8329 void DataArrayInt::accumulate(int *res) const throw(INTERP_KERNEL::Exception)
8332 const int *ptr=getConstPointer();
8333 int nbTuple=getNumberOfTuples();
8334 int nbComps=getNumberOfComponents();
8335 std::fill(res,res+nbComps,0);
8336 for(int i=0;i<nbTuple;i++)
8337 std::transform(ptr+i*nbComps,ptr+(i+1)*nbComps,res,res,std::plus<int>());
8340 int DataArrayInt::accumulate(int compId) const throw(INTERP_KERNEL::Exception)
8343 const int *ptr=getConstPointer();
8344 int nbTuple=getNumberOfTuples();
8345 int nbComps=getNumberOfComponents();
8346 if(compId<0 || compId>=nbComps)
8347 throw INTERP_KERNEL::Exception("DataArrayInt::accumulate : Invalid compId specified : No such nb of components !");
8349 for(int i=0;i<nbTuple;i++)
8350 ret+=ptr[i*nbComps+compId];
8355 * This method accumulate using addition tuples in \a this using input index array [ \a bgOfIndex, \a endOfIndex ).
8356 * The returned array will have same number of components than \a this and number of tuples equal to
8357 * \c std::distance(bgOfIndex,endOfIndex) \b minus \b one.
8359 * The input index array is expected to be ascendingly sorted in which the all referenced ids should be in [0, \c this->getNumberOfTuples).
8361 * \param [in] bgOfIndex - begin (included) of the input index array.
8362 * \param [in] endOfIndex - end (excluded) of the input index array.
8363 * \return DataArrayInt * - the new instance having the same number of components than \a this.
8365 * \throw If bgOfIndex or end is NULL.
8366 * \throw If input index array is not ascendingly sorted.
8367 * \throw If there is an id in [ \a bgOfIndex, \a endOfIndex ) not in [0, \c this->getNumberOfTuples).
8368 * \throw If std::distance(bgOfIndex,endOfIndex)==0.
8370 DataArrayInt *DataArrayInt::accumulatePerChunck(const int *bgOfIndex, const int *endOfIndex) const throw(INTERP_KERNEL::Exception)
8372 if(!bgOfIndex || !endOfIndex)
8373 throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : input pointer NULL !");
8375 int nbCompo=getNumberOfComponents();
8376 int nbOfTuples=getNumberOfTuples();
8377 int sz=(int)std::distance(bgOfIndex,endOfIndex);
8379 throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : invalid size of input index array !");
8381 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(sz,nbCompo);
8382 const int *w=bgOfIndex;
8383 if(*w<0 || *w>=nbOfTuples)
8384 throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : The first element of the input index not in [0,nbOfTuples) !");
8385 const int *srcPt=begin()+(*w)*nbCompo;
8386 int *tmp=ret->getPointer();
8387 for(int i=0;i<sz;i++,tmp+=nbCompo,w++)
8389 std::fill(tmp,tmp+nbCompo,0.);
8392 for(int j=w[0];j<w[1];j++,srcPt+=nbCompo)
8394 if(j>=0 && j<nbOfTuples)
8395 std::transform(srcPt,srcPt+nbCompo,tmp,tmp,std::plus<int>());
8398 std::ostringstream oss; oss << "DataArrayInt::accumulatePerChunck : At rank #" << i << " the input index array points to id " << j << " should be in [0," << nbOfTuples << ") !";
8399 throw INTERP_KERNEL::Exception(oss.str().c_str());
8405 std::ostringstream oss; oss << "DataArrayInt::accumulatePerChunck : At rank #" << i << " the input index array is not in ascendingly sorted.";
8406 throw INTERP_KERNEL::Exception(oss.str().c_str());
8409 ret->copyStringInfoFrom(*this);
8414 * Returns a new DataArrayInt by concatenating two given arrays, so that (1) the number
8415 * of tuples in the result array is <em> a1->getNumberOfTuples() + a2->getNumberOfTuples() -
8416 * offsetA2</em> and (2)
8417 * the number of component in the result array is same as that of each of given arrays.
8418 * First \a offsetA2 tuples of \a a2 are skipped and thus are missing from the result array.
8419 * Info on components is copied from the first of the given arrays. Number of components
8420 * in the given arrays must be the same.
8421 * \param [in] a1 - an array to include in the result array.
8422 * \param [in] a2 - another array to include in the result array.
8423 * \param [in] offsetA2 - number of tuples of \a a2 to skip.
8424 * \return DataArrayInt * - the new instance of DataArrayInt.
8425 * The caller is to delete this result array using decrRef() as it is no more
8427 * \throw If either \a a1 or \a a2 is NULL.
8428 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents().
8430 DataArrayInt *DataArrayInt::Aggregate(const DataArrayInt *a1, const DataArrayInt *a2, int offsetA2)
8433 throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : input DataArrayInt instance is NULL !");
8434 int nbOfComp=a1->getNumberOfComponents();
8435 if(nbOfComp!=a2->getNumberOfComponents())
8436 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Aggregation !");
8437 int nbOfTuple1=a1->getNumberOfTuples();
8438 int nbOfTuple2=a2->getNumberOfTuples();
8439 DataArrayInt *ret=DataArrayInt::New();
8440 ret->alloc(nbOfTuple1+nbOfTuple2-offsetA2,nbOfComp);
8441 int *pt=std::copy(a1->getConstPointer(),a1->getConstPointer()+nbOfTuple1*nbOfComp,ret->getPointer());
8442 std::copy(a2->getConstPointer()+offsetA2*nbOfComp,a2->getConstPointer()+nbOfTuple2*nbOfComp,pt);
8443 ret->copyStringInfoFrom(*a1);
8448 * Returns a new DataArrayInt by concatenating all given arrays, so that (1) the number
8449 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
8450 * the number of component in the result array is same as that of each of given arrays.
8451 * Info on components is copied from the first of the given arrays. Number of components
8452 * in the given arrays must be the same.
8453 * \param [in] arr - a sequence of arrays to include in the result array.
8454 * \return DataArrayInt * - the new instance of DataArrayInt.
8455 * The caller is to delete this result array using decrRef() as it is no more
8457 * \throw If all arrays within \a arr are NULL.
8458 * \throw If getNumberOfComponents() of arrays within \a arr.
8460 DataArrayInt *DataArrayInt::Aggregate(const std::vector<const DataArrayInt *>& arr) throw(INTERP_KERNEL::Exception)
8462 std::vector<const DataArrayInt *> a;
8463 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
8467 throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : input list must be NON EMPTY !");
8468 std::vector<const DataArrayInt *>::const_iterator it=a.begin();
8469 int nbOfComp=(*it)->getNumberOfComponents();
8470 int nbt=(*it++)->getNumberOfTuples();
8471 for(int i=1;it!=a.end();it++,i++)
8473 if((*it)->getNumberOfComponents()!=nbOfComp)
8474 throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : Nb of components mismatch for array aggregation !");
8475 nbt+=(*it)->getNumberOfTuples();
8477 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
8478 ret->alloc(nbt,nbOfComp);
8479 int *pt=ret->getPointer();
8480 for(it=a.begin();it!=a.end();it++)
8481 pt=std::copy((*it)->getConstPointer(),(*it)->getConstPointer()+(*it)->getNbOfElems(),pt);
8482 ret->copyStringInfoFrom(*(a[0]));
8487 * This method takes as input a list of DataArrayInt instances \a arrs that represent each a packed index arrays.
8488 * A packed index array is an allocated array with one component, and at least one tuple. The first element
8489 * of each array in \a arrs must be 0. Each array in \a arrs is expected to be increasingly monotonic.
8490 * 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.
8492 * \return DataArrayInt * - a new object to be managed by the caller.
8494 DataArrayInt *DataArrayInt::AggregateIndexes(const std::vector<const DataArrayInt *>& arrs) throw(INTERP_KERNEL::Exception)
8497 for(std::vector<const DataArrayInt *>::const_iterator it4=arrs.begin();it4!=arrs.end();it4++)
8501 (*it4)->checkAllocated();
8502 if((*it4)->getNumberOfComponents()!=1)
8504 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with nb of compo != 1 at pos " << std::distance(arrs.begin(),it4) << " !";
8505 throw INTERP_KERNEL::Exception(oss.str().c_str());
8507 int nbTupl=(*it4)->getNumberOfTuples();
8510 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with nb of tuples < 1 at pos " << std::distance(arrs.begin(),it4) << " !";
8511 throw INTERP_KERNEL::Exception(oss.str().c_str());
8513 if((*it4)->front()!=0)
8515 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with front value != 0 at pos " << std::distance(arrs.begin(),it4) << " !";
8516 throw INTERP_KERNEL::Exception(oss.str().c_str());
8522 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a null instance at pos " << std::distance(arrs.begin(),it4) << " !";
8523 throw INTERP_KERNEL::Exception(oss.str().c_str());
8527 throw INTERP_KERNEL::Exception("DataArrayInt::AggregateIndexes : input list must be NON EMPTY !");
8528 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
8529 ret->alloc(retSz,1);
8530 int *pt=ret->getPointer(); *pt++=0;
8531 for(std::vector<const DataArrayInt *>::const_iterator it=arrs.begin();it!=arrs.end();it++)
8532 pt=std::transform((*it)->begin()+1,(*it)->end(),pt,std::bind2nd(std::plus<int>(),pt[-1]));
8533 ret->copyStringInfoFrom(*(arrs[0]));
8538 * Returns the maximal value and its location within \a this one-dimensional array.
8539 * \param [out] tupleId - index of the tuple holding the maximal value.
8540 * \return int - the maximal value among all values of \a this array.
8541 * \throw If \a this->getNumberOfComponents() != 1
8542 * \throw If \a this->getNumberOfTuples() < 1
8544 int DataArrayInt::getMaxValue(int& tupleId) const throw(INTERP_KERNEL::Exception)
8547 if(getNumberOfComponents()!=1)
8548 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : must be applied on DataArrayInt with only one component !");
8549 int nbOfTuples=getNumberOfTuples();
8551 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : array exists but number of tuples must be > 0 !");
8552 const int *vals=getConstPointer();
8553 const int *loc=std::max_element(vals,vals+nbOfTuples);
8554 tupleId=(int)std::distance(vals,loc);
8559 * Returns the maximal value within \a this array that is allowed to have more than
8561 * \return int - the maximal value among all values of \a this array.
8562 * \throw If \a this is not allocated.
8564 int DataArrayInt::getMaxValueInArray() const throw(INTERP_KERNEL::Exception)
8567 const int *loc=std::max_element(begin(),end());
8572 * Returns the minimal value and its location within \a this one-dimensional array.
8573 * \param [out] tupleId - index of the tuple holding the minimal value.
8574 * \return int - the minimal value among all values of \a this array.
8575 * \throw If \a this->getNumberOfComponents() != 1
8576 * \throw If \a this->getNumberOfTuples() < 1
8578 int DataArrayInt::getMinValue(int& tupleId) const throw(INTERP_KERNEL::Exception)
8581 if(getNumberOfComponents()!=1)
8582 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : must be applied on DataArrayInt with only one component !");
8583 int nbOfTuples=getNumberOfTuples();
8585 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : array exists but number of tuples must be > 0 !");
8586 const int *vals=getConstPointer();
8587 const int *loc=std::min_element(vals,vals+nbOfTuples);
8588 tupleId=(int)std::distance(vals,loc);
8593 * Returns the minimal value within \a this array that is allowed to have more than
8595 * \return int - the minimal value among all values of \a this array.
8596 * \throw If \a this is not allocated.
8598 int DataArrayInt::getMinValueInArray() const throw(INTERP_KERNEL::Exception)
8601 const int *loc=std::min_element(begin(),end());
8606 * Converts every value of \a this array to its absolute value.
8607 * \throw If \a this is not allocated.
8609 void DataArrayInt::abs() throw(INTERP_KERNEL::Exception)
8612 int *ptr=getPointer();
8613 std::size_t nbOfElems=getNbOfElems();
8614 std::transform(ptr,ptr+nbOfElems,ptr,std::ptr_fun<int,int>(std::abs));
8619 * Apply a liner function to a given component of \a this array, so that
8620 * an array element <em>(x)</em> becomes \f$ a * x + b \f$.
8621 * \param [in] a - the first coefficient of the function.
8622 * \param [in] b - the second coefficient of the function.
8623 * \param [in] compoId - the index of component to modify.
8624 * \throw If \a this is not allocated.
8626 void DataArrayInt::applyLin(int a, int b, int compoId) throw(INTERP_KERNEL::Exception)
8629 int *ptr=getPointer()+compoId;
8630 int nbOfComp=getNumberOfComponents();
8631 int nbOfTuple=getNumberOfTuples();
8632 for(int i=0;i<nbOfTuple;i++,ptr+=nbOfComp)
8638 * Apply a liner function to all elements of \a this array, so that
8639 * an element _x_ becomes \f$ a * x + b \f$.
8640 * \param [in] a - the first coefficient of the function.
8641 * \param [in] b - the second coefficient of the function.
8642 * \throw If \a this is not allocated.
8644 void DataArrayInt::applyLin(int a, int b) throw(INTERP_KERNEL::Exception)
8647 int *ptr=getPointer();
8648 std::size_t nbOfElems=getNbOfElems();
8649 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
8655 * Returns a full copy of \a this array except that sign of all elements is reversed.
8656 * \return DataArrayInt * - the new instance of DataArrayInt containing the
8657 * same number of tuples and component as \a this array.
8658 * The caller is to delete this result array using decrRef() as it is no more
8660 * \throw If \a this is not allocated.
8662 DataArrayInt *DataArrayInt::negate() const throw(INTERP_KERNEL::Exception)
8665 DataArrayInt *newArr=DataArrayInt::New();
8666 int nbOfTuples=getNumberOfTuples();
8667 int nbOfComp=getNumberOfComponents();
8668 newArr->alloc(nbOfTuples,nbOfComp);
8669 const int *cptr=getConstPointer();
8670 std::transform(cptr,cptr+nbOfTuples*nbOfComp,newArr->getPointer(),std::negate<int>());
8671 newArr->copyStringInfoFrom(*this);
8676 * Modify all elements of \a this array, so that
8677 * an element _x_ becomes \f$ numerator / x \f$.
8678 * \warning If an exception is thrown because of presence of 0 element in \a this
8679 * array, all elements processed before detection of the zero element remain
8681 * \param [in] numerator - the numerator used to modify array elements.
8682 * \throw If \a this is not allocated.
8683 * \throw If there is an element equal to 0 in \a this array.
8685 void DataArrayInt::applyInv(int numerator) throw(INTERP_KERNEL::Exception)
8688 int *ptr=getPointer();
8689 std::size_t nbOfElems=getNbOfElems();
8690 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
8694 *ptr=numerator/(*ptr);
8698 std::ostringstream oss; oss << "DataArrayInt::applyInv : presence of null value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
8700 throw INTERP_KERNEL::Exception(oss.str().c_str());
8707 * Modify all elements of \a this array, so that
8708 * an element _x_ becomes \f$ x / val \f$.
8709 * \param [in] val - the denominator used to modify array elements.
8710 * \throw If \a this is not allocated.
8711 * \throw If \a val == 0.
8713 void DataArrayInt::applyDivideBy(int val) throw(INTERP_KERNEL::Exception)
8716 throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to divide by 0 !");
8718 int *ptr=getPointer();
8719 std::size_t nbOfElems=getNbOfElems();
8720 std::transform(ptr,ptr+nbOfElems,ptr,std::bind2nd(std::divides<int>(),val));
8725 * Modify all elements of \a this array, so that
8726 * an element _x_ becomes <em> x % val </em>.
8727 * \param [in] val - the divisor used to modify array elements.
8728 * \throw If \a this is not allocated.
8729 * \throw If \a val <= 0.
8731 void DataArrayInt::applyModulus(int val) throw(INTERP_KERNEL::Exception)
8734 throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to operate modulus on value <= 0 !");
8736 int *ptr=getPointer();
8737 std::size_t nbOfElems=getNbOfElems();
8738 std::transform(ptr,ptr+nbOfElems,ptr,std::bind2nd(std::modulus<int>(),val));
8743 * This method works only on data array with one component.
8744 * This method returns a newly allocated array storing stored ascendantly tuple ids in \b this so that
8745 * this[*id] in [\b vmin,\b vmax)
8747 * \param [in] vmin begin of range. This value is included in range (included).
8748 * \param [in] vmax end of range. This value is \b not included in range (excluded).
8749 * \return a newly allocated data array that the caller should deal with.
8751 DataArrayInt *DataArrayInt::getIdsInRange(int vmin, int vmax) const throw(INTERP_KERNEL::Exception)
8754 if(getNumberOfComponents()!=1)
8755 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsInRange : this must have exactly one component !");
8756 const int *cptr=getConstPointer();
8757 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(0,1);
8758 int nbOfTuples=getNumberOfTuples();
8759 for(int i=0;i<nbOfTuples;i++,cptr++)
8760 if(*cptr>=vmin && *cptr<vmax)
8761 ret->pushBackSilent(i);
8766 * This method works only on data array with one component.
8767 * 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.
8769 * \param [in] vmin begin of range. This value is included in range (included).
8770 * \param [in] vmax end of range. This value is \b not included in range (excluded).
8771 * \return if all ids in \a this are so that (*this)[i]==i for all i in [ 0, \c this->getNumberOfTuples() ).
8773 bool DataArrayInt::checkAllIdsInRange(int vmin, int vmax) const throw(INTERP_KERNEL::Exception)
8776 if(getNumberOfComponents()!=1)
8777 throw INTERP_KERNEL::Exception("DataArrayInt::checkAllIdsInRange : this must have exactly one component !");
8778 int nbOfTuples=getNumberOfTuples();
8780 const int *cptr=getConstPointer();
8781 for(int i=0;i<nbOfTuples;i++,cptr++)
8783 if(*cptr>=vmin && *cptr<vmax)
8784 { ret=ret && *cptr==i; }
8787 std::ostringstream oss; oss << "DataArrayInt::checkAllIdsInRange : tuple #" << i << " has value " << *cptr << " should be in [" << vmin << "," << vmax << ") !";
8788 throw INTERP_KERNEL::Exception(oss.str().c_str());
8795 * Modify all elements of \a this array, so that
8796 * an element _x_ becomes <em> val % x </em>.
8797 * \warning If an exception is thrown because of presence of an element <= 0 in \a this
8798 * array, all elements processed before detection of the zero element remain
8800 * \param [in] val - the divident used to modify array elements.
8801 * \throw If \a this is not allocated.
8802 * \throw If there is an element equal to or less than 0 in \a this array.
8804 void DataArrayInt::applyRModulus(int val) throw(INTERP_KERNEL::Exception)
8807 int *ptr=getPointer();
8808 std::size_t nbOfElems=getNbOfElems();
8809 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
8817 std::ostringstream oss; oss << "DataArrayInt::applyRModulus : presence of value <=0 in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
8819 throw INTERP_KERNEL::Exception(oss.str().c_str());
8826 * Modify all elements of \a this array, so that
8827 * an element _x_ becomes <em> val ^ x </em>.
8828 * \param [in] val - the value used to apply pow on all array elements.
8829 * \throw If \a this is not allocated.
8830 * \throw If \a val < 0.
8832 void DataArrayInt::applyPow(int val) throw(INTERP_KERNEL::Exception)
8836 throw INTERP_KERNEL::Exception("DataArrayInt::applyPow : input pow in < 0 !");
8837 int *ptr=getPointer();
8838 std::size_t nbOfElems=getNbOfElems();
8841 std::fill(ptr,ptr+nbOfElems,1.);
8844 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
8847 for(int j=0;j<val;j++)
8855 * Modify all elements of \a this array, so that
8856 * an element _x_ becomes \f$ val ^ x \f$.
8857 * \param [in] val - the value used to apply pow on all array elements.
8858 * \throw If \a this is not allocated.
8859 * \throw If there is an element < 0 in \a this array.
8860 * \warning If an exception is thrown because of presence of 0 element in \a this
8861 * array, all elements processed before detection of the zero element remain
8864 void DataArrayInt::applyRPow(int val) throw(INTERP_KERNEL::Exception)
8867 int *ptr=getPointer();
8868 std::size_t nbOfElems=getNbOfElems();
8869 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
8874 for(int j=0;j<*ptr;j++)
8880 std::ostringstream oss; oss << "DataArrayInt::applyRPow : presence of negative value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
8882 throw INTERP_KERNEL::Exception(oss.str().c_str());
8889 * Returns a new DataArrayInt by aggregating two given arrays, so that (1) the number
8890 * of components in the result array is a sum of the number of components of given arrays
8891 * and (2) the number of tuples in the result array is same as that of each of given
8892 * arrays. In other words the i-th tuple of result array includes all components of
8893 * i-th tuples of all given arrays.
8894 * Number of tuples in the given arrays must be the same.
8895 * \param [in] a1 - an array to include in the result array.
8896 * \param [in] a2 - another array to include in the result array.
8897 * \return DataArrayInt * - the new instance of DataArrayInt.
8898 * The caller is to delete this result array using decrRef() as it is no more
8900 * \throw If both \a a1 and \a a2 are NULL.
8901 * \throw If any given array is not allocated.
8902 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
8904 DataArrayInt *DataArrayInt::Meld(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception)
8906 std::vector<const DataArrayInt *> arr(2);
8907 arr[0]=a1; arr[1]=a2;
8912 * Returns a new DataArrayInt by aggregating all given arrays, so that (1) the number
8913 * of components in the result array is a sum of the number of components of given arrays
8914 * and (2) the number of tuples in the result array is same as that of each of given
8915 * arrays. In other words the i-th tuple of result array includes all components of
8916 * i-th tuples of all given arrays.
8917 * Number of tuples in the given arrays must be the same.
8918 * \param [in] arr - a sequence of arrays to include in the result array.
8919 * \return DataArrayInt * - the new instance of DataArrayInt.
8920 * The caller is to delete this result array using decrRef() as it is no more
8922 * \throw If all arrays within \a arr are NULL.
8923 * \throw If any given array is not allocated.
8924 * \throw If getNumberOfTuples() of arrays within \a arr is different.
8926 DataArrayInt *DataArrayInt::Meld(const std::vector<const DataArrayInt *>& arr) throw(INTERP_KERNEL::Exception)
8928 std::vector<const DataArrayInt *> a;
8929 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
8933 throw INTERP_KERNEL::Exception("DataArrayInt::Meld : array must be NON empty !");
8934 std::vector<const DataArrayInt *>::const_iterator it;
8935 for(it=a.begin();it!=a.end();it++)
8936 (*it)->checkAllocated();
8938 int nbOfTuples=(*it)->getNumberOfTuples();
8939 std::vector<int> nbc(a.size());
8940 std::vector<const int *> pts(a.size());
8941 nbc[0]=(*it)->getNumberOfComponents();
8942 pts[0]=(*it++)->getConstPointer();
8943 for(int i=1;it!=a.end();it++,i++)
8945 if(nbOfTuples!=(*it)->getNumberOfTuples())
8946 throw INTERP_KERNEL::Exception("DataArrayInt::meld : mismatch of number of tuples !");
8947 nbc[i]=(*it)->getNumberOfComponents();
8948 pts[i]=(*it)->getConstPointer();
8950 int totalNbOfComp=std::accumulate(nbc.begin(),nbc.end(),0);
8951 DataArrayInt *ret=DataArrayInt::New();
8952 ret->alloc(nbOfTuples,totalNbOfComp);
8953 int *retPtr=ret->getPointer();
8954 for(int i=0;i<nbOfTuples;i++)
8955 for(int j=0;j<(int)a.size();j++)
8957 retPtr=std::copy(pts[j],pts[j]+nbc[j],retPtr);
8961 for(int i=0;i<(int)a.size();i++)
8962 for(int j=0;j<nbc[i];j++,k++)
8963 ret->setInfoOnComponent(k,a[i]->getInfoOnComponent(j).c_str());
8968 * Returns a new DataArrayInt which is a minimal partition of elements of \a groups.
8969 * The i-th item of the result array is an ID of a set of elements belonging to a
8970 * unique set of groups, which the i-th element is a part of. This set of elements
8971 * belonging to a unique set of groups is called \a family, so the result array contains
8972 * IDs of families each element belongs to.
8974 * \b Example: if we have two groups of elements: \a group1 [0,4] and \a group2 [ 0,1,2 ],
8975 * then there are 3 families:
8976 * - \a family1 (with ID 1) contains element [0] belonging to ( \a group1 + \a group2 ),
8977 * - \a family2 (with ID 2) contains elements [4] belonging to ( \a group1 ),
8978 * - \a family3 (with ID 3) contains element [1,2] belonging to ( \a group2 ), <br>
8979 * and the result array contains IDs of families [ 1,3,3,0,2 ]. <br> Note a family ID 0 which
8980 * stands for the element #3 which is in none of groups.
8982 * \param [in] groups - sequence of groups of element IDs.
8983 * \param [in] newNb - total number of elements; it must be more than max ID of element
8985 * \param [out] fidsOfGroups - IDs of families the elements of each group belong to.
8986 * \return DataArrayInt * - a new instance of DataArrayInt containing IDs of families
8987 * each element with ID from range [0, \a newNb ) belongs to. The caller is to
8988 * delete this array using decrRef() as it is no more needed.
8989 * \throw If any element ID in \a groups violates condition ( 0 <= ID < \a newNb ).
8991 DataArrayInt *DataArrayInt::MakePartition(const std::vector<const DataArrayInt *>& groups, int newNb, std::vector< std::vector<int> >& fidsOfGroups) throw(INTERP_KERNEL::Exception)
8993 std::vector<const DataArrayInt *> groups2;
8994 for(std::vector<const DataArrayInt *>::const_iterator it4=groups.begin();it4!=groups.end();it4++)
8996 groups2.push_back(*it4);
8997 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
8998 ret->alloc(newNb,1);
8999 int *retPtr=ret->getPointer();
9000 std::fill(retPtr,retPtr+newNb,0);
9002 for(std::vector<const DataArrayInt *>::const_iterator iter=groups2.begin();iter!=groups2.end();iter++)
9004 const int *ptr=(*iter)->getConstPointer();
9005 std::size_t nbOfElem=(*iter)->getNbOfElems();
9007 for(int j=0;j<sfid;j++)
9010 for(std::size_t i=0;i<nbOfElem;i++)
9012 if(ptr[i]>=0 && ptr[i]<newNb)
9014 if(retPtr[ptr[i]]==j)
9022 std::ostringstream oss; oss << "DataArrayInt::MakePartition : In group \"" << (*iter)->getName() << "\" in tuple #" << i << " value = " << ptr[i] << " ! Should be in [0," << newNb;
9024 throw INTERP_KERNEL::Exception(oss.str().c_str());
9031 fidsOfGroups.clear();
9032 fidsOfGroups.resize(groups2.size());
9034 for(std::vector<const DataArrayInt *>::const_iterator iter=groups2.begin();iter!=groups2.end();iter++,grId++)
9037 const int *ptr=(*iter)->getConstPointer();
9038 std::size_t nbOfElem=(*iter)->getNbOfElems();
9039 for(const int *p=ptr;p!=ptr+nbOfElem;p++)
9040 tmp.insert(retPtr[*p]);
9041 fidsOfGroups[grId].insert(fidsOfGroups[grId].end(),tmp.begin(),tmp.end());
9047 * Returns a new DataArrayInt which contains all elements of given one-dimensional
9048 * arrays. The result array does not contain any duplicates and its values
9049 * are sorted in ascending order.
9050 * \param [in] arr - sequence of DataArrayInt's to unite.
9051 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9052 * array using decrRef() as it is no more needed.
9053 * \throw If any \a arr[i] is not allocated.
9054 * \throw If \a arr[i]->getNumberOfComponents() != 1.
9056 DataArrayInt *DataArrayInt::BuildUnion(const std::vector<const DataArrayInt *>& arr) throw(INTERP_KERNEL::Exception)
9058 std::vector<const DataArrayInt *> a;
9059 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9062 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9064 (*it)->checkAllocated();
9065 if((*it)->getNumberOfComponents()!=1)
9066 throw INTERP_KERNEL::Exception("DataArrayInt::BuildUnion : only single component allowed !");
9070 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9072 const int *pt=(*it)->getConstPointer();
9073 int nbOfTuples=(*it)->getNumberOfTuples();
9074 r.insert(pt,pt+nbOfTuples);
9076 DataArrayInt *ret=DataArrayInt::New();
9077 ret->alloc((int)r.size(),1);
9078 std::copy(r.begin(),r.end(),ret->getPointer());
9083 * Returns a new DataArrayInt which contains elements present in each of given one-dimensional
9084 * arrays. The result array does not contain any duplicates and its values
9085 * are sorted in ascending order.
9086 * \param [in] arr - sequence of DataArrayInt's to intersect.
9087 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9088 * array using decrRef() as it is no more needed.
9089 * \throw If any \a arr[i] is not allocated.
9090 * \throw If \a arr[i]->getNumberOfComponents() != 1.
9092 DataArrayInt *DataArrayInt::BuildIntersection(const std::vector<const DataArrayInt *>& arr) throw(INTERP_KERNEL::Exception)
9094 std::vector<const DataArrayInt *> a;
9095 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9098 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9100 (*it)->checkAllocated();
9101 if((*it)->getNumberOfComponents()!=1)
9102 throw INTERP_KERNEL::Exception("DataArrayInt::BuildIntersection : only single component allowed !");
9106 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9108 const int *pt=(*it)->getConstPointer();
9109 int nbOfTuples=(*it)->getNumberOfTuples();
9110 std::set<int> s1(pt,pt+nbOfTuples);
9114 std::set_intersection(r.begin(),r.end(),s1.begin(),s1.end(),inserter(r2,r2.end()));
9120 DataArrayInt *ret=DataArrayInt::New();
9121 ret->alloc((int)r.size(),1);
9122 std::copy(r.begin(),r.end(),ret->getPointer());
9127 * Returns a new DataArrayInt which contains a complement of elements of \a this
9128 * one-dimensional array. I.e. the result array contains all elements from the range [0,
9129 * \a nbOfElement) not present in \a this array.
9130 * \param [in] nbOfElement - maximal size of the result array.
9131 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9132 * array using decrRef() as it is no more needed.
9133 * \throw If \a this is not allocated.
9134 * \throw If \a this->getNumberOfComponents() != 1.
9135 * \throw If any element \a x of \a this array violates condition ( 0 <= \a x < \a
9138 DataArrayInt *DataArrayInt::buildComplement(int nbOfElement) const throw(INTERP_KERNEL::Exception)
9141 if(getNumberOfComponents()!=1)
9142 throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : only single component allowed !");
9143 std::vector<bool> tmp(nbOfElement);
9144 const int *pt=getConstPointer();
9145 int nbOfTuples=getNumberOfTuples();
9146 for(const int *w=pt;w!=pt+nbOfTuples;w++)
9147 if(*w>=0 && *w<nbOfElement)
9150 throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : an element is not in valid range : [0,nbOfElement) !");
9151 int nbOfRetVal=(int)std::count(tmp.begin(),tmp.end(),false);
9152 DataArrayInt *ret=DataArrayInt::New();
9153 ret->alloc(nbOfRetVal,1);
9155 int *retPtr=ret->getPointer();
9156 for(int i=0;i<nbOfElement;i++)
9163 * Returns a new DataArrayInt containing elements of \a this one-dimensional missing
9164 * from an \a other one-dimensional array.
9165 * \param [in] other - a DataArrayInt containing elements not to include in the result array.
9166 * \return DataArrayInt * - a new instance of DataArrayInt with one component. The
9167 * caller is to delete this array using decrRef() as it is no more needed.
9168 * \throw If \a other is NULL.
9169 * \throw If \a other is not allocated.
9170 * \throw If \a other->getNumberOfComponents() != 1.
9171 * \throw If \a this is not allocated.
9172 * \throw If \a this->getNumberOfComponents() != 1.
9173 * \sa DataArrayInt::buildSubstractionOptimized()
9175 DataArrayInt *DataArrayInt::buildSubstraction(const DataArrayInt *other) const throw(INTERP_KERNEL::Exception)
9178 throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : DataArrayInt pointer in input is NULL !");
9180 other->checkAllocated();
9181 if(getNumberOfComponents()!=1)
9182 throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed !");
9183 if(other->getNumberOfComponents()!=1)
9184 throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed for other type !");
9185 const int *pt=getConstPointer();
9186 int nbOfTuples=getNumberOfTuples();
9187 std::set<int> s1(pt,pt+nbOfTuples);
9188 pt=other->getConstPointer();
9189 nbOfTuples=other->getNumberOfTuples();
9190 std::set<int> s2(pt,pt+nbOfTuples);
9192 std::set_difference(s1.begin(),s1.end(),s2.begin(),s2.end(),std::back_insert_iterator< std::vector<int> >(r));
9193 DataArrayInt *ret=DataArrayInt::New();
9194 ret->alloc((int)r.size(),1);
9195 std::copy(r.begin(),r.end(),ret->getPointer());
9200 * \a this is expected to have one component and to be sorted ascendingly (as for \a other).
9201 * \a other is expected to be a part of \a this. If not DataArrayInt::buildSubstraction should be called instead.
9203 * \param [in] other an array with one component and expected to be sorted ascendingly.
9204 * \ret list of ids in \a this but not in \a other.
9205 * \sa DataArrayInt::buildSubstraction
9207 DataArrayInt *DataArrayInt::buildSubstractionOptimized(const DataArrayInt *other) const throw(INTERP_KERNEL::Exception)
9209 static const char *MSG="DataArrayInt::buildSubstractionOptimized : only single component allowed !";
9210 if(!other) throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstractionOptimized : NULL input array !");
9211 checkAllocated(); other->checkAllocated();
9212 if(getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception(MSG);
9213 if(other->getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception(MSG);
9214 const int *pt1Bg(begin()),*pt1End(end()),*pt2Bg(other->begin()),*pt2End(other->end()),*work1(pt1Bg),*work2(pt2Bg);
9215 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
9216 for(;work1!=pt1End;work1++)
9218 if(work2!=pt2End && *work1==*work2)
9221 ret->pushBackSilent(*work1);
9228 * Returns a new DataArrayInt which contains all elements of \a this and a given
9229 * one-dimensional arrays. The result array does not contain any duplicates
9230 * and its values are sorted in ascending order.
9231 * \param [in] other - an array to unite with \a this one.
9232 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9233 * array using decrRef() as it is no more needed.
9234 * \throw If \a this or \a other is not allocated.
9235 * \throw If \a this->getNumberOfComponents() != 1.
9236 * \throw If \a other->getNumberOfComponents() != 1.
9238 DataArrayInt *DataArrayInt::buildUnion(const DataArrayInt *other) const throw(INTERP_KERNEL::Exception)
9240 std::vector<const DataArrayInt *>arrs(2);
9241 arrs[0]=this; arrs[1]=other;
9242 return BuildUnion(arrs);
9247 * Returns a new DataArrayInt which contains elements present in both \a this and a given
9248 * one-dimensional arrays. The result array does not contain any duplicates
9249 * and its values are sorted in ascending order.
9250 * \param [in] other - an array to intersect with \a this one.
9251 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9252 * array using decrRef() as it is no more needed.
9253 * \throw If \a this or \a other is not allocated.
9254 * \throw If \a this->getNumberOfComponents() != 1.
9255 * \throw If \a other->getNumberOfComponents() != 1.
9257 DataArrayInt *DataArrayInt::buildIntersection(const DataArrayInt *other) const throw(INTERP_KERNEL::Exception)
9259 std::vector<const DataArrayInt *>arrs(2);
9260 arrs[0]=this; arrs[1]=other;
9261 return BuildIntersection(arrs);
9265 * This method can be applied on allocated with one component DataArrayInt instance.
9266 * This method is typically relevant for sorted arrays. All consecutive duplicated items in \a this will appear only once in returned DataArrayInt instance.
9267 * 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]
9269 * \return a newly allocated array that contain the result of the unique operation applied on \a this.
9270 * \throw if \a this is not allocated or if \a this has not exactly one component.
9272 DataArrayInt *DataArrayInt::buildUnique() const throw(INTERP_KERNEL::Exception)
9275 if(getNumberOfComponents()!=1)
9276 throw INTERP_KERNEL::Exception("DataArrayInt::buildUnique : only single component allowed !");
9277 int nbOfTuples=getNumberOfTuples();
9278 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=deepCpy();
9279 int *data=tmp->getPointer();
9280 int *last=std::unique(data,data+nbOfTuples);
9281 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9282 ret->alloc(std::distance(data,last),1);
9283 std::copy(data,last,ret->getPointer());
9288 * Returns a new DataArrayInt which contains size of every of groups described by \a this
9289 * "index" array. Such "index" array is returned for example by
9290 * \ref ParaMEDMEM::MEDCouplingUMesh::buildDescendingConnectivity
9291 * "MEDCouplingUMesh::buildDescendingConnectivity" and
9292 * \ref ParaMEDMEM::MEDCouplingUMesh::getNodalConnectivityIndex
9293 * "MEDCouplingUMesh::getNodalConnectivityIndex" etc.
9294 * This method preforms the reverse operation of DataArrayInt::computeOffsets2.
9295 * \return DataArrayInt * - a new instance of DataArrayInt, whose number of tuples
9296 * equals to \a this->getNumberOfComponents() - 1, and number of components is 1.
9297 * The caller is to delete this array using decrRef() as it is no more needed.
9298 * \throw If \a this is not allocated.
9299 * \throw If \a this->getNumberOfComponents() != 1.
9300 * \throw If \a this->getNumberOfTuples() < 2.
9303 * - this contains [1,3,6,7,7,9,15]
9304 * - result array contains [2,3,1,0,2,6],
9305 * where 2 = 3 - 1, 3 = 6 - 3, 1 = 7 - 6 etc.
9307 * \sa DataArrayInt::computeOffsets2
9309 DataArrayInt *DataArrayInt::deltaShiftIndex() const throw(INTERP_KERNEL::Exception)
9312 if(getNumberOfComponents()!=1)
9313 throw INTERP_KERNEL::Exception("DataArrayInt::deltaShiftIndex : only single component allowed !");
9314 int nbOfTuples=getNumberOfTuples();
9316 throw INTERP_KERNEL::Exception("DataArrayInt::deltaShiftIndex : 1 tuple at least must be present in 'this' !");
9317 const int *ptr=getConstPointer();
9318 DataArrayInt *ret=DataArrayInt::New();
9319 ret->alloc(nbOfTuples-1,1);
9320 int *out=ret->getPointer();
9321 std::transform(ptr+1,ptr+nbOfTuples,ptr,out,std::minus<int>());
9326 * Modifies \a this one-dimensional array so that value of each element \a x
9327 * of \a this array (\a a) is computed as \f$ x_i = \sum_{j=0}^{i-1} a[ j ] \f$.
9328 * Or: for each i>0 new[i]=new[i-1]+old[i-1] for i==0 new[i]=0. Number of tuples
9329 * and components remains the same.<br>
9330 * This method is useful for allToAllV in MPI with contiguous policy. This method
9331 * differs from computeOffsets2() in that the number of tuples is \b not changed by
9333 * \throw If \a this is not allocated.
9334 * \throw If \a this->getNumberOfComponents() != 1.
9337 * - Before \a this contains [3,5,1,2,0,8]
9338 * - After \a this contains [0,3,8,9,11,11]<br>
9339 * Note that the last element 19 = 11 + 8 is missing because size of \a this
9340 * array is retained and thus there is no space to store the last element.
9342 void DataArrayInt::computeOffsets() throw(INTERP_KERNEL::Exception)
9345 if(getNumberOfComponents()!=1)
9346 throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsets : only single component allowed !");
9347 int nbOfTuples=getNumberOfTuples();
9350 int *work=getPointer();
9353 for(int i=1;i<nbOfTuples;i++)
9356 work[i]=work[i-1]+tmp;
9364 * Modifies \a this one-dimensional array so that value of each element \a x
9365 * of \a this array (\a a) is computed as \f$ x_i = \sum_{j=0}^{i-1} a[ j ] \f$.
9366 * Or: for each i>0 new[i]=new[i-1]+old[i-1] for i==0 new[i]=0. Number
9367 * components remains the same and number of tuples is inceamented by one.<br>
9368 * This method is useful for allToAllV in MPI with contiguous policy. This method
9369 * differs from computeOffsets() in that the number of tuples is changed by this one.
9370 * This method preforms the reverse operation of DataArrayInt::deltaShiftIndex.
9371 * \throw If \a this is not allocated.
9372 * \throw If \a this->getNumberOfComponents() != 1.
9375 * - Before \a this contains [3,5,1,2,0,8]
9376 * - After \a this contains [0,3,8,9,11,11,19]<br>
9377 * \sa DataArrayInt::deltaShiftIndex
9379 void DataArrayInt::computeOffsets2() throw(INTERP_KERNEL::Exception)
9382 if(getNumberOfComponents()!=1)
9383 throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsets2 : only single component allowed !");
9384 int nbOfTuples=getNumberOfTuples();
9385 int *ret=(int *)malloc((nbOfTuples+1)*sizeof(int));
9388 const int *work=getConstPointer();
9390 for(int i=0;i<nbOfTuples;i++)
9391 ret[i+1]=work[i]+ret[i];
9392 useArray(ret,true,C_DEALLOC,nbOfTuples+1,1);
9397 * Returns two new DataArrayInt instances whose contents is computed from that of \a this and \a listOfIds arrays as follows.
9398 * \a this is expected to be an offset format ( as returned by DataArrayInt::computeOffsets2 ) that is to say with one component
9399 * and ** sorted strictly increasingly **. \a listOfIds is expected to be sorted ascendingly (not strictly needed for \a listOfIds).
9400 * This methods searches in \a this, considered as a set of contiguous \c this->getNumberOfComponents() ranges, all ids in \a listOfIds
9401 * filling completely one of the ranges in \a this.
9403 * \param [in] listOfIds a list of ids that has to be sorted ascendingly.
9404 * \param [out] rangeIdsFetched the range ids fetched
9405 * \param [out] idsInInputListThatFetch contains the list of ids in \a listOfIds that are \b fully included in a range in \a this. So
9406 * \a idsInInputListThatFetch is a part of input \a listOfIds.
9408 * \sa DataArrayInt::computeOffsets2
9411 * - \a this : [0,3,7,9,15,18]
9412 * - \a listOfIds contains [0,1,2,3,7,8,15,16,17]
9413 * - \a rangeIdsFetched result array: [0,2,4]
9414 * - \a idsInInputListThatFetch result array: [0,1,2,7,8,15,16,17]
9415 * In this example id 3 in input \a listOfIds is alone so it do not appear in output \a idsInInputListThatFetch.
9418 void DataArrayInt::searchRangesInListOfIds(const DataArrayInt *listOfIds, DataArrayInt *& rangeIdsFetched, DataArrayInt *& idsInInputListThatFetch) const throw(INTERP_KERNEL::Exception)
9421 throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : input list of ids is null !");
9422 listOfIds->checkAllocated(); checkAllocated();
9423 if(listOfIds->getNumberOfComponents()!=1)
9424 throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : input list of ids must have exactly one component !");
9425 if(getNumberOfComponents()!=1)
9426 throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : this must have exactly one component !");
9427 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret0=DataArrayInt::New(); ret0->alloc(0,1);
9428 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New(); ret1->alloc(0,1);
9429 const int *tupEnd(listOfIds->end()),*offBg(begin()),*offEnd(end()-1);
9430 const int *tupPtr(listOfIds->begin()),*offPtr(offBg);
9431 while(tupPtr!=tupEnd && offPtr!=offEnd)
9433 if(*tupPtr==*offPtr)
9436 while(i<offPtr[1] && *tupPtr==i && tupPtr!=tupEnd) { i++; tupPtr++; }
9439 ret0->pushBackSilent((int)std::distance(offBg,offPtr));
9440 ret1->pushBackValsSilent(tupPtr-(offPtr[1]-offPtr[0]),tupPtr);
9445 { if(*tupPtr<*offPtr) tupPtr++; else offPtr++; }
9447 rangeIdsFetched=ret0.retn();
9448 idsInInputListThatFetch=ret1.retn();
9452 * Returns a new DataArrayInt whose contents is computed from that of \a this and \a
9453 * offsets arrays as follows. \a offsets is a one-dimensional array considered as an
9454 * "index" array of a "iota" array, thus, whose each element gives an index of a group
9455 * beginning within the "iota" array. And \a this is a one-dimensional array
9456 * considered as a selector of groups described by \a offsets to include into the result array.
9457 * \throw If \a offsets is NULL.
9458 * \throw If \a offsets is not allocated.
9459 * \throw If \a offsets->getNumberOfComponents() != 1.
9460 * \throw If \a offsets is not monotonically increasing.
9461 * \throw If \a this is not allocated.
9462 * \throw If \a this->getNumberOfComponents() != 1.
9463 * \throw If any element of \a this is not a valid index for \a offsets array.
9466 * - \a this: [0,2,3]
9467 * - \a offsets: [0,3,6,10,14,20]
9468 * - result array: [0,1,2,6,7,8,9,10,11,12,13] == <br>
9469 * \c range(0,3) + \c range(6,10) + \c range(10,14) ==<br>
9470 * \c range( \a offsets[ \a this[0] ], offsets[ \a this[0]+1 ]) +
9471 * \c range( \a offsets[ \a this[1] ], offsets[ \a this[1]+1 ]) +
9472 * \c range( \a offsets[ \a this[2] ], offsets[ \a this[2]+1 ])
9474 DataArrayInt *DataArrayInt::buildExplicitArrByRanges(const DataArrayInt *offsets) const throw(INTERP_KERNEL::Exception)
9477 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : DataArrayInt pointer in input is NULL !");
9479 if(getNumberOfComponents()!=1)
9480 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : only single component allowed !");
9481 offsets->checkAllocated();
9482 if(offsets->getNumberOfComponents()!=1)
9483 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : input array should have only single component !");
9484 int othNbTuples=offsets->getNumberOfTuples()-1;
9485 int nbOfTuples=getNumberOfTuples();
9486 int retNbOftuples=0;
9487 const int *work=getConstPointer();
9488 const int *offPtr=offsets->getConstPointer();
9489 for(int i=0;i<nbOfTuples;i++)
9492 if(val>=0 && val<othNbTuples)
9494 int delta=offPtr[val+1]-offPtr[val];
9496 retNbOftuples+=delta;
9499 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrByRanges : Tuple #" << val << " of offset array has a delta < 0 !";
9500 throw INTERP_KERNEL::Exception(oss.str().c_str());
9505 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrByRanges : Tuple #" << i << " in this contains " << val;
9506 oss << " whereas offsets array is of size " << othNbTuples+1 << " !";
9507 throw INTERP_KERNEL::Exception(oss.str().c_str());
9510 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9511 ret->alloc(retNbOftuples,1);
9512 int *retPtr=ret->getPointer();
9513 for(int i=0;i<nbOfTuples;i++)
9516 int start=offPtr[val];
9517 int off=offPtr[val+1]-start;
9518 for(int j=0;j<off;j++,retPtr++)
9525 * 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.
9526 * 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
9527 * in tuple **i** of returned DataArrayInt.
9528 * If ranges overlapped (in theory it should not) this method do not detect it and always returns the first range.
9530 * 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)]
9531 * The return DataArrayInt will contain : **[0,4,1,2,2,3]**
9533 * \param [in] ranges typically come from output of MEDCouplingUMesh::ComputeRangesFromTypeDistribution. Each range is specified like this : 1st component is
9534 * for lower value included and 2nd component is the upper value of corresponding range **excluded**.
9535 * \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
9536 * is thrown if no ranges in \a ranges contains value in \a this.
9538 * \sa DataArrayInt::findIdInRangeForEachTuple
9540 DataArrayInt *DataArrayInt::findRangeIdForEachTuple(const DataArrayInt *ranges) const throw(INTERP_KERNEL::Exception)
9543 throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : null input pointer !");
9544 if(ranges->getNumberOfComponents()!=2)
9545 throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : input DataArrayInt instance should have 2 components !");
9547 if(getNumberOfComponents()!=1)
9548 throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : this should have only one component !");
9549 int nbTuples=getNumberOfTuples();
9550 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTuples,1);
9551 int nbOfRanges=ranges->getNumberOfTuples();
9552 const int *rangesPtr=ranges->getConstPointer();
9553 int *retPtr=ret->getPointer();
9554 const int *inPtr=getConstPointer();
9555 for(int i=0;i<nbTuples;i++,retPtr++)
9559 for(int j=0;j<nbOfRanges && !found;j++)
9560 if(val>=rangesPtr[2*j] && val<rangesPtr[2*j+1])
9561 { *retPtr=j; found=true; }
9566 std::ostringstream oss; oss << "DataArrayInt::findRangeIdForEachTuple : tuple #" << i << " not found by any ranges !";
9567 throw INTERP_KERNEL::Exception(oss.str().c_str());
9574 * 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.
9575 * 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
9576 * in tuple **i** of returned DataArrayInt.
9577 * If ranges overlapped (in theory it should not) this method do not detect it and always returns the sub position of the first range.
9579 * 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)]
9580 * The return DataArrayInt will contain : **[1,2,4,0,2,2]**
9581 * This method is often called in pair with DataArrayInt::findRangeIdForEachTuple method.
9583 * \param [in] ranges typically come from output of MEDCouplingUMesh::ComputeRangesFromTypeDistribution. Each range is specified like this : 1st component is
9584 * for lower value included and 2nd component is the upper value of corresponding range **excluded**.
9585 * \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
9586 * is thrown if no ranges in \a ranges contains value in \a this.
9587 * \sa DataArrayInt::findRangeIdForEachTuple
9589 DataArrayInt *DataArrayInt::findIdInRangeForEachTuple(const DataArrayInt *ranges) const throw(INTERP_KERNEL::Exception)
9592 throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : null input pointer !");
9593 if(ranges->getNumberOfComponents()!=2)
9594 throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : input DataArrayInt instance should have 2 components !");
9596 if(getNumberOfComponents()!=1)
9597 throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : this should have only one component !");
9598 int nbTuples=getNumberOfTuples();
9599 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTuples,1);
9600 int nbOfRanges=ranges->getNumberOfTuples();
9601 const int *rangesPtr=ranges->getConstPointer();
9602 int *retPtr=ret->getPointer();
9603 const int *inPtr=getConstPointer();
9604 for(int i=0;i<nbTuples;i++,retPtr++)
9608 for(int j=0;j<nbOfRanges && !found;j++)
9609 if(val>=rangesPtr[2*j] && val<rangesPtr[2*j+1])
9610 { *retPtr=val-rangesPtr[2*j]; found=true; }
9615 std::ostringstream oss; oss << "DataArrayInt::findIdInRangeForEachTuple : tuple #" << i << " not found by any ranges !";
9616 throw INTERP_KERNEL::Exception(oss.str().c_str());
9624 * \param [in] nbTimes specifies the nb of times each tuples in \a this will be duplicated contiguouly in returned DataArrayInt instance.
9625 * \a nbTimes should be at least equal to 1.
9626 * \return a newly allocated DataArrayInt having one component and number of tuples equal to \a nbTimes * \c this->getNumberOfTuples.
9627 * \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.
9629 DataArrayInt *DataArrayInt::duplicateEachTupleNTimes(int nbTimes) const throw(INTERP_KERNEL::Exception)
9632 if(getNumberOfComponents()!=1)
9633 throw INTERP_KERNEL::Exception("DataArrayInt::duplicateEachTupleNTimes : this should have only one component !");
9635 throw INTERP_KERNEL::Exception("DataArrayInt::duplicateEachTupleNTimes : nb times should be >= 1 !");
9636 int nbTuples=getNumberOfTuples();
9637 const int *inPtr=getConstPointer();
9638 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTimes*nbTuples,1);
9639 int *retPtr=ret->getPointer();
9640 for(int i=0;i<nbTuples;i++,inPtr++)
9643 for(int j=0;j<nbTimes;j++,retPtr++)
9646 ret->copyStringInfoFrom(*this);
9651 * This method returns all different values found in \a this. This method throws if \a this has not been allocated.
9652 * But the number of components can be different from one.
9653 * \return a newly allocated array (that should be dealt by the caller) containing different values in \a this.
9655 DataArrayInt *DataArrayInt::getDifferentValues() const throw(INTERP_KERNEL::Exception)
9659 ret.insert(begin(),end());
9660 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret2=DataArrayInt::New(); ret2->alloc((int)ret.size(),1);
9661 std::copy(ret.begin(),ret.end(),ret2->getPointer());
9666 * This method is a refinement of DataArrayInt::getDifferentValues because it returns not only different values in \a this but also, for each of
9667 * them it tells which tuple id have this id.
9668 * This method works only on arrays with one component (if it is not the case call DataArrayInt::rearrange(1) ).
9669 * This method returns two arrays having same size.
9670 * 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.
9671 * 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]]
9673 std::vector<DataArrayInt *> DataArrayInt::partitionByDifferentValues(std::vector<int>& differentIds) const throw(INTERP_KERNEL::Exception)
9676 if(getNumberOfComponents()!=1)
9677 throw INTERP_KERNEL::Exception("DataArrayInt::partitionByDifferentValues : this should have only one component !");
9679 std::map<int,int> m,m2,m3;
9680 for(const int *w=begin();w!=end();w++)
9682 differentIds.resize(m.size());
9683 std::vector<DataArrayInt *> ret(m.size());
9684 std::vector<int *> retPtr(m.size());
9685 for(std::map<int,int>::const_iterator it=m.begin();it!=m.end();it++,id++)
9688 ret[id]=DataArrayInt::New();
9689 ret[id]->alloc((*it).second,1);
9690 retPtr[id]=ret[id]->getPointer();
9691 differentIds[id]=(*it).first;
9694 for(const int *w=begin();w!=end();w++,id++)
9696 retPtr[m2[*w]][m3[*w]++]=id;
9702 * Returns a new DataArrayInt that is a sum of two given arrays. There are 3
9704 * 1. The arrays have same number of tuples and components. Then each value of
9705 * the result array (_a_) is a sum of the corresponding values of \a a1 and \a a2,
9706 * i.e.: _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, j ].
9707 * 2. The arrays have same number of tuples and one array, say _a2_, has one
9709 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, 0 ].
9710 * 3. The arrays have same number of components and one array, say _a2_, has one
9712 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ 0, j ].
9714 * Info on components is copied either from the first array (in the first case) or from
9715 * the array with maximal number of elements (getNbOfElems()).
9716 * \param [in] a1 - an array to sum up.
9717 * \param [in] a2 - another array to sum up.
9718 * \return DataArrayInt * - the new instance of DataArrayInt.
9719 * The caller is to delete this result array using decrRef() as it is no more
9721 * \throw If either \a a1 or \a a2 is NULL.
9722 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
9723 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
9724 * none of them has number of tuples or components equal to 1.
9726 DataArrayInt *DataArrayInt::Add(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception)
9729 throw INTERP_KERNEL::Exception("DataArrayInt::Add : input DataArrayInt instance is NULL !");
9730 int nbOfTuple=a1->getNumberOfTuples();
9731 int nbOfTuple2=a2->getNumberOfTuples();
9732 int nbOfComp=a1->getNumberOfComponents();
9733 int nbOfComp2=a2->getNumberOfComponents();
9734 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=0;
9735 if(nbOfTuple==nbOfTuple2)
9737 if(nbOfComp==nbOfComp2)
9739 ret=DataArrayInt::New();
9740 ret->alloc(nbOfTuple,nbOfComp);
9741 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::plus<int>());
9742 ret->copyStringInfoFrom(*a1);
9746 int nbOfCompMin,nbOfCompMax;
9747 const DataArrayInt *aMin, *aMax;
9748 if(nbOfComp>nbOfComp2)
9750 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
9755 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
9760 ret=DataArrayInt::New();
9761 ret->alloc(nbOfTuple,nbOfCompMax);
9762 const int *aMinPtr=aMin->getConstPointer();
9763 const int *aMaxPtr=aMax->getConstPointer();
9764 int *res=ret->getPointer();
9765 for(int i=0;i<nbOfTuple;i++)
9766 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::plus<int>(),aMinPtr[i]));
9767 ret->copyStringInfoFrom(*aMax);
9770 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
9773 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
9775 if(nbOfComp==nbOfComp2)
9777 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
9778 const DataArrayInt *aMin=nbOfTuple>nbOfTuple2?a2:a1;
9779 const DataArrayInt *aMax=nbOfTuple>nbOfTuple2?a1:a2;
9780 const int *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
9781 ret=DataArrayInt::New();
9782 ret->alloc(nbOfTupleMax,nbOfComp);
9783 int *res=ret->getPointer();
9784 for(int i=0;i<nbOfTupleMax;i++)
9785 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::plus<int>());
9786 ret->copyStringInfoFrom(*aMax);
9789 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
9792 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Add !");
9797 * Adds values of another DataArrayInt to values of \a this one. There are 3
9799 * 1. The arrays have same number of tuples and components. Then each value of
9800 * \a other array is added to the corresponding value of \a this array, i.e.:
9801 * _a_ [ i, j ] += _other_ [ i, j ].
9802 * 2. The arrays have same number of tuples and \a other array has one component. Then
9803 * _a_ [ i, j ] += _other_ [ i, 0 ].
9804 * 3. The arrays have same number of components and \a other array has one tuple. Then
9805 * _a_ [ i, j ] += _a2_ [ 0, j ].
9807 * \param [in] other - an array to add to \a this one.
9808 * \throw If \a other is NULL.
9809 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
9810 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
9811 * \a other has number of both tuples and components not equal to 1.
9813 void DataArrayInt::addEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception)
9816 throw INTERP_KERNEL::Exception("DataArrayInt::addEqual : input DataArrayInt instance is NULL !");
9817 const char *msg="Nb of tuples mismatch for DataArrayInt::addEqual !";
9818 checkAllocated(); other->checkAllocated();
9819 int nbOfTuple=getNumberOfTuples();
9820 int nbOfTuple2=other->getNumberOfTuples();
9821 int nbOfComp=getNumberOfComponents();
9822 int nbOfComp2=other->getNumberOfComponents();
9823 if(nbOfTuple==nbOfTuple2)
9825 if(nbOfComp==nbOfComp2)
9827 std::transform(begin(),end(),other->begin(),getPointer(),std::plus<int>());
9829 else if(nbOfComp2==1)
9831 int *ptr=getPointer();
9832 const int *ptrc=other->getConstPointer();
9833 for(int i=0;i<nbOfTuple;i++)
9834 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::plus<int>(),*ptrc++));
9837 throw INTERP_KERNEL::Exception(msg);
9839 else if(nbOfTuple2==1)
9841 if(nbOfComp2==nbOfComp)
9843 int *ptr=getPointer();
9844 const int *ptrc=other->getConstPointer();
9845 for(int i=0;i<nbOfTuple;i++)
9846 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::plus<int>());
9849 throw INTERP_KERNEL::Exception(msg);
9852 throw INTERP_KERNEL::Exception(msg);
9857 * Returns a new DataArrayInt that is a subtraction of two given arrays. There are 3
9859 * 1. The arrays have same number of tuples and components. Then each value of
9860 * the result array (_a_) is a subtraction of the corresponding values of \a a1 and
9861 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, j ].
9862 * 2. The arrays have same number of tuples and one array, say _a2_, has one
9864 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, 0 ].
9865 * 3. The arrays have same number of components and one array, say _a2_, has one
9867 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ 0, j ].
9869 * Info on components is copied either from the first array (in the first case) or from
9870 * the array with maximal number of elements (getNbOfElems()).
9871 * \param [in] a1 - an array to subtract from.
9872 * \param [in] a2 - an array to subtract.
9873 * \return DataArrayInt * - the new instance of DataArrayInt.
9874 * The caller is to delete this result array using decrRef() as it is no more
9876 * \throw If either \a a1 or \a a2 is NULL.
9877 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
9878 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
9879 * none of them has number of tuples or components equal to 1.
9881 DataArrayInt *DataArrayInt::Substract(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception)
9884 throw INTERP_KERNEL::Exception("DataArrayInt::Substract : input DataArrayInt instance is NULL !");
9885 int nbOfTuple1=a1->getNumberOfTuples();
9886 int nbOfTuple2=a2->getNumberOfTuples();
9887 int nbOfComp1=a1->getNumberOfComponents();
9888 int nbOfComp2=a2->getNumberOfComponents();
9889 if(nbOfTuple2==nbOfTuple1)
9891 if(nbOfComp1==nbOfComp2)
9893 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9894 ret->alloc(nbOfTuple2,nbOfComp1);
9895 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::minus<int>());
9896 ret->copyStringInfoFrom(*a1);
9899 else if(nbOfComp2==1)
9901 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9902 ret->alloc(nbOfTuple1,nbOfComp1);
9903 const int *a2Ptr=a2->getConstPointer();
9904 const int *a1Ptr=a1->getConstPointer();
9905 int *res=ret->getPointer();
9906 for(int i=0;i<nbOfTuple1;i++)
9907 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::minus<int>(),a2Ptr[i]));
9908 ret->copyStringInfoFrom(*a1);
9913 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
9917 else if(nbOfTuple2==1)
9919 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
9920 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9921 ret->alloc(nbOfTuple1,nbOfComp1);
9922 const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
9923 int *pt=ret->getPointer();
9924 for(int i=0;i<nbOfTuple1;i++)
9925 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::minus<int>());
9926 ret->copyStringInfoFrom(*a1);
9931 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Substract !");//will always throw an exception
9937 * Subtract values of another DataArrayInt from values of \a this one. There are 3
9939 * 1. The arrays have same number of tuples and components. Then each value of
9940 * \a other array is subtracted from the corresponding value of \a this array, i.e.:
9941 * _a_ [ i, j ] -= _other_ [ i, j ].
9942 * 2. The arrays have same number of tuples and \a other array has one component. Then
9943 * _a_ [ i, j ] -= _other_ [ i, 0 ].
9944 * 3. The arrays have same number of components and \a other array has one tuple. Then
9945 * _a_ [ i, j ] -= _a2_ [ 0, j ].
9947 * \param [in] other - an array to subtract from \a this one.
9948 * \throw If \a other is NULL.
9949 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
9950 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
9951 * \a other has number of both tuples and components not equal to 1.
9953 void DataArrayInt::substractEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception)
9956 throw INTERP_KERNEL::Exception("DataArrayInt::substractEqual : input DataArrayInt instance is NULL !");
9957 const char *msg="Nb of tuples mismatch for DataArrayInt::substractEqual !";
9958 checkAllocated(); other->checkAllocated();
9959 int nbOfTuple=getNumberOfTuples();
9960 int nbOfTuple2=other->getNumberOfTuples();
9961 int nbOfComp=getNumberOfComponents();
9962 int nbOfComp2=other->getNumberOfComponents();
9963 if(nbOfTuple==nbOfTuple2)
9965 if(nbOfComp==nbOfComp2)
9967 std::transform(begin(),end(),other->begin(),getPointer(),std::minus<int>());
9969 else if(nbOfComp2==1)
9971 int *ptr=getPointer();
9972 const int *ptrc=other->getConstPointer();
9973 for(int i=0;i<nbOfTuple;i++)
9974 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::minus<int>(),*ptrc++));
9977 throw INTERP_KERNEL::Exception(msg);
9979 else if(nbOfTuple2==1)
9981 int *ptr=getPointer();
9982 const int *ptrc=other->getConstPointer();
9983 for(int i=0;i<nbOfTuple;i++)
9984 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::minus<int>());
9987 throw INTERP_KERNEL::Exception(msg);
9992 * Returns a new DataArrayInt that is a product of two given arrays. There are 3
9994 * 1. The arrays have same number of tuples and components. Then each value of
9995 * the result array (_a_) is a product of the corresponding values of \a a1 and
9996 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, j ].
9997 * 2. The arrays have same number of tuples and one array, say _a2_, has one
9999 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, 0 ].
10000 * 3. The arrays have same number of components and one array, say _a2_, has one
10002 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ 0, j ].
10004 * Info on components is copied either from the first array (in the first case) or from
10005 * the array with maximal number of elements (getNbOfElems()).
10006 * \param [in] a1 - a factor array.
10007 * \param [in] a2 - another factor array.
10008 * \return DataArrayInt * - the new instance of DataArrayInt.
10009 * The caller is to delete this result array using decrRef() as it is no more
10011 * \throw If either \a a1 or \a a2 is NULL.
10012 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
10013 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
10014 * none of them has number of tuples or components equal to 1.
10016 DataArrayInt *DataArrayInt::Multiply(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception)
10019 throw INTERP_KERNEL::Exception("DataArrayInt::Multiply : input DataArrayInt instance is NULL !");
10020 int nbOfTuple=a1->getNumberOfTuples();
10021 int nbOfTuple2=a2->getNumberOfTuples();
10022 int nbOfComp=a1->getNumberOfComponents();
10023 int nbOfComp2=a2->getNumberOfComponents();
10024 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=0;
10025 if(nbOfTuple==nbOfTuple2)
10027 if(nbOfComp==nbOfComp2)
10029 ret=DataArrayInt::New();
10030 ret->alloc(nbOfTuple,nbOfComp);
10031 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::multiplies<int>());
10032 ret->copyStringInfoFrom(*a1);
10036 int nbOfCompMin,nbOfCompMax;
10037 const DataArrayInt *aMin, *aMax;
10038 if(nbOfComp>nbOfComp2)
10040 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
10045 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
10050 ret=DataArrayInt::New();
10051 ret->alloc(nbOfTuple,nbOfCompMax);
10052 const int *aMinPtr=aMin->getConstPointer();
10053 const int *aMaxPtr=aMax->getConstPointer();
10054 int *res=ret->getPointer();
10055 for(int i=0;i<nbOfTuple;i++)
10056 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::multiplies<int>(),aMinPtr[i]));
10057 ret->copyStringInfoFrom(*aMax);
10060 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
10063 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
10065 if(nbOfComp==nbOfComp2)
10067 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
10068 const DataArrayInt *aMin=nbOfTuple>nbOfTuple2?a2:a1;
10069 const DataArrayInt *aMax=nbOfTuple>nbOfTuple2?a1:a2;
10070 const int *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
10071 ret=DataArrayInt::New();
10072 ret->alloc(nbOfTupleMax,nbOfComp);
10073 int *res=ret->getPointer();
10074 for(int i=0;i<nbOfTupleMax;i++)
10075 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::multiplies<int>());
10076 ret->copyStringInfoFrom(*aMax);
10079 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
10082 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Multiply !");
10088 * Multiply values of another DataArrayInt to values of \a this one. There are 3
10090 * 1. The arrays have same number of tuples and components. Then each value of
10091 * \a other array is multiplied to the corresponding value of \a this array, i.e.:
10092 * _a_ [ i, j ] *= _other_ [ i, j ].
10093 * 2. The arrays have same number of tuples and \a other array has one component. Then
10094 * _a_ [ i, j ] *= _other_ [ i, 0 ].
10095 * 3. The arrays have same number of components and \a other array has one tuple. Then
10096 * _a_ [ i, j ] *= _a2_ [ 0, j ].
10098 * \param [in] other - an array to multiply to \a this one.
10099 * \throw If \a other is NULL.
10100 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
10101 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
10102 * \a other has number of both tuples and components not equal to 1.
10104 void DataArrayInt::multiplyEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception)
10107 throw INTERP_KERNEL::Exception("DataArrayInt::multiplyEqual : input DataArrayInt instance is NULL !");
10108 const char *msg="Nb of tuples mismatch for DataArrayInt::multiplyEqual !";
10109 checkAllocated(); other->checkAllocated();
10110 int nbOfTuple=getNumberOfTuples();
10111 int nbOfTuple2=other->getNumberOfTuples();
10112 int nbOfComp=getNumberOfComponents();
10113 int nbOfComp2=other->getNumberOfComponents();
10114 if(nbOfTuple==nbOfTuple2)
10116 if(nbOfComp==nbOfComp2)
10118 std::transform(begin(),end(),other->begin(),getPointer(),std::multiplies<int>());
10120 else if(nbOfComp2==1)
10122 int *ptr=getPointer();
10123 const int *ptrc=other->getConstPointer();
10124 for(int i=0;i<nbOfTuple;i++)
10125 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::multiplies<int>(),*ptrc++));
10128 throw INTERP_KERNEL::Exception(msg);
10130 else if(nbOfTuple2==1)
10132 if(nbOfComp2==nbOfComp)
10134 int *ptr=getPointer();
10135 const int *ptrc=other->getConstPointer();
10136 for(int i=0;i<nbOfTuple;i++)
10137 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::multiplies<int>());
10140 throw INTERP_KERNEL::Exception(msg);
10143 throw INTERP_KERNEL::Exception(msg);
10149 * Returns a new DataArrayInt that is a division of two given arrays. There are 3
10151 * 1. The arrays have same number of tuples and components. Then each value of
10152 * the result array (_a_) is a division of the corresponding values of \a a1 and
10153 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, j ].
10154 * 2. The arrays have same number of tuples and one array, say _a2_, has one
10156 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, 0 ].
10157 * 3. The arrays have same number of components and one array, say _a2_, has one
10159 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ 0, j ].
10161 * Info on components is copied either from the first array (in the first case) or from
10162 * the array with maximal number of elements (getNbOfElems()).
10163 * \warning No check of division by zero is performed!
10164 * \param [in] a1 - a numerator array.
10165 * \param [in] a2 - a denominator array.
10166 * \return DataArrayInt * - the new instance of DataArrayInt.
10167 * The caller is to delete this result array using decrRef() as it is no more
10169 * \throw If either \a a1 or \a a2 is NULL.
10170 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
10171 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
10172 * none of them has number of tuples or components equal to 1.
10174 DataArrayInt *DataArrayInt::Divide(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception)
10177 throw INTERP_KERNEL::Exception("DataArrayInt::Divide : input DataArrayInt instance is NULL !");
10178 int nbOfTuple1=a1->getNumberOfTuples();
10179 int nbOfTuple2=a2->getNumberOfTuples();
10180 int nbOfComp1=a1->getNumberOfComponents();
10181 int nbOfComp2=a2->getNumberOfComponents();
10182 if(nbOfTuple2==nbOfTuple1)
10184 if(nbOfComp1==nbOfComp2)
10186 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10187 ret->alloc(nbOfTuple2,nbOfComp1);
10188 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::divides<int>());
10189 ret->copyStringInfoFrom(*a1);
10192 else if(nbOfComp2==1)
10194 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10195 ret->alloc(nbOfTuple1,nbOfComp1);
10196 const int *a2Ptr=a2->getConstPointer();
10197 const int *a1Ptr=a1->getConstPointer();
10198 int *res=ret->getPointer();
10199 for(int i=0;i<nbOfTuple1;i++)
10200 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::divides<int>(),a2Ptr[i]));
10201 ret->copyStringInfoFrom(*a1);
10206 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
10210 else if(nbOfTuple2==1)
10212 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
10213 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10214 ret->alloc(nbOfTuple1,nbOfComp1);
10215 const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
10216 int *pt=ret->getPointer();
10217 for(int i=0;i<nbOfTuple1;i++)
10218 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::divides<int>());
10219 ret->copyStringInfoFrom(*a1);
10224 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Divide !");//will always throw an exception
10230 * Divide values of \a this array by values of another DataArrayInt. There are 3
10232 * 1. The arrays have same number of tuples and components. Then each value of
10233 * \a this array is divided by the corresponding value of \a other one, i.e.:
10234 * _a_ [ i, j ] /= _other_ [ i, j ].
10235 * 2. The arrays have same number of tuples and \a other array has one component. Then
10236 * _a_ [ i, j ] /= _other_ [ i, 0 ].
10237 * 3. The arrays have same number of components and \a other array has one tuple. Then
10238 * _a_ [ i, j ] /= _a2_ [ 0, j ].
10240 * \warning No check of division by zero is performed!
10241 * \param [in] other - an array to divide \a this one by.
10242 * \throw If \a other is NULL.
10243 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
10244 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
10245 * \a other has number of both tuples and components not equal to 1.
10247 void DataArrayInt::divideEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception)
10250 throw INTERP_KERNEL::Exception("DataArrayInt::divideEqual : input DataArrayInt instance is NULL !");
10251 const char *msg="Nb of tuples mismatch for DataArrayInt::divideEqual !";
10252 checkAllocated(); other->checkAllocated();
10253 int nbOfTuple=getNumberOfTuples();
10254 int nbOfTuple2=other->getNumberOfTuples();
10255 int nbOfComp=getNumberOfComponents();
10256 int nbOfComp2=other->getNumberOfComponents();
10257 if(nbOfTuple==nbOfTuple2)
10259 if(nbOfComp==nbOfComp2)
10261 std::transform(begin(),end(),other->begin(),getPointer(),std::divides<int>());
10263 else if(nbOfComp2==1)
10265 int *ptr=getPointer();
10266 const int *ptrc=other->getConstPointer();
10267 for(int i=0;i<nbOfTuple;i++)
10268 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::divides<int>(),*ptrc++));
10271 throw INTERP_KERNEL::Exception(msg);
10273 else if(nbOfTuple2==1)
10275 if(nbOfComp2==nbOfComp)
10277 int *ptr=getPointer();
10278 const int *ptrc=other->getConstPointer();
10279 for(int i=0;i<nbOfTuple;i++)
10280 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::divides<int>());
10283 throw INTERP_KERNEL::Exception(msg);
10286 throw INTERP_KERNEL::Exception(msg);
10292 * Returns a new DataArrayInt that is a modulus of two given arrays. There are 3
10294 * 1. The arrays have same number of tuples and components. Then each value of
10295 * the result array (_a_) is a division of the corresponding values of \a a1 and
10296 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ i, j ].
10297 * 2. The arrays have same number of tuples and one array, say _a2_, has one
10299 * _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ i, 0 ].
10300 * 3. The arrays have same number of components and one array, say _a2_, has one
10302 * _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ 0, j ].
10304 * Info on components is copied either from the first array (in the first case) or from
10305 * the array with maximal number of elements (getNbOfElems()).
10306 * \warning No check of division by zero is performed!
10307 * \param [in] a1 - a dividend array.
10308 * \param [in] a2 - a divisor array.
10309 * \return DataArrayInt * - the new instance of DataArrayInt.
10310 * The caller is to delete this result array using decrRef() as it is no more
10312 * \throw If either \a a1 or \a a2 is NULL.
10313 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
10314 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
10315 * none of them has number of tuples or components equal to 1.
10317 DataArrayInt *DataArrayInt::Modulus(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception)
10320 throw INTERP_KERNEL::Exception("DataArrayInt::Modulus : input DataArrayInt instance is NULL !");
10321 int nbOfTuple1=a1->getNumberOfTuples();
10322 int nbOfTuple2=a2->getNumberOfTuples();
10323 int nbOfComp1=a1->getNumberOfComponents();
10324 int nbOfComp2=a2->getNumberOfComponents();
10325 if(nbOfTuple2==nbOfTuple1)
10327 if(nbOfComp1==nbOfComp2)
10329 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10330 ret->alloc(nbOfTuple2,nbOfComp1);
10331 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::modulus<int>());
10332 ret->copyStringInfoFrom(*a1);
10335 else if(nbOfComp2==1)
10337 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10338 ret->alloc(nbOfTuple1,nbOfComp1);
10339 const int *a2Ptr=a2->getConstPointer();
10340 const int *a1Ptr=a1->getConstPointer();
10341 int *res=ret->getPointer();
10342 for(int i=0;i<nbOfTuple1;i++)
10343 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::modulus<int>(),a2Ptr[i]));
10344 ret->copyStringInfoFrom(*a1);
10349 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Modulus !");
10353 else if(nbOfTuple2==1)
10355 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Modulus !");
10356 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10357 ret->alloc(nbOfTuple1,nbOfComp1);
10358 const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
10359 int *pt=ret->getPointer();
10360 for(int i=0;i<nbOfTuple1;i++)
10361 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::modulus<int>());
10362 ret->copyStringInfoFrom(*a1);
10367 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Modulus !");//will always throw an exception
10373 * Modify \a this array so that each value becomes a modulus of division of this value by
10374 * a value of another DataArrayInt. There are 3 valid cases.
10375 * 1. The arrays have same number of tuples and components. Then each value of
10376 * \a this array is divided by the corresponding value of \a other one, i.e.:
10377 * _a_ [ i, j ] %= _other_ [ i, j ].
10378 * 2. The arrays have same number of tuples and \a other array has one component. Then
10379 * _a_ [ i, j ] %= _other_ [ i, 0 ].
10380 * 3. The arrays have same number of components and \a other array has one tuple. Then
10381 * _a_ [ i, j ] %= _a2_ [ 0, j ].
10383 * \warning No check of division by zero is performed!
10384 * \param [in] other - a divisor array.
10385 * \throw If \a other is NULL.
10386 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
10387 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
10388 * \a other has number of both tuples and components not equal to 1.
10390 void DataArrayInt::modulusEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception)
10393 throw INTERP_KERNEL::Exception("DataArrayInt::modulusEqual : input DataArrayInt instance is NULL !");
10394 const char *msg="Nb of tuples mismatch for DataArrayInt::modulusEqual !";
10395 checkAllocated(); other->checkAllocated();
10396 int nbOfTuple=getNumberOfTuples();
10397 int nbOfTuple2=other->getNumberOfTuples();
10398 int nbOfComp=getNumberOfComponents();
10399 int nbOfComp2=other->getNumberOfComponents();
10400 if(nbOfTuple==nbOfTuple2)
10402 if(nbOfComp==nbOfComp2)
10404 std::transform(begin(),end(),other->begin(),getPointer(),std::modulus<int>());
10406 else if(nbOfComp2==1)
10408 if(nbOfComp2==nbOfComp)
10410 int *ptr=getPointer();
10411 const int *ptrc=other->getConstPointer();
10412 for(int i=0;i<nbOfTuple;i++)
10413 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::modulus<int>(),*ptrc++));
10416 throw INTERP_KERNEL::Exception(msg);
10419 throw INTERP_KERNEL::Exception(msg);
10421 else if(nbOfTuple2==1)
10423 int *ptr=getPointer();
10424 const int *ptrc=other->getConstPointer();
10425 for(int i=0;i<nbOfTuple;i++)
10426 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::modulus<int>());
10429 throw INTERP_KERNEL::Exception(msg);
10434 * Returns a new DataArrayInt that is the result of pow of two given arrays. There are 3
10437 * \param [in] a1 - an array to pow up.
10438 * \param [in] a2 - another array to sum up.
10439 * \return DataArrayInt * - the new instance of DataArrayInt.
10440 * The caller is to delete this result array using decrRef() as it is no more
10442 * \throw If either \a a1 or \a a2 is NULL.
10443 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
10444 * \throw If \a a1->getNumberOfComponents() != 1 or \a a2->getNumberOfComponents() != 1.
10445 * \throw If there is a negative value in \a a2.
10447 DataArrayInt *DataArrayInt::Pow(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception)
10450 throw INTERP_KERNEL::Exception("DataArrayInt::Pow : at least one of input instances is null !");
10451 int nbOfTuple=a1->getNumberOfTuples();
10452 int nbOfTuple2=a2->getNumberOfTuples();
10453 int nbOfComp=a1->getNumberOfComponents();
10454 int nbOfComp2=a2->getNumberOfComponents();
10455 if(nbOfTuple!=nbOfTuple2)
10456 throw INTERP_KERNEL::Exception("DataArrayInt::Pow : number of tuples mismatches !");
10457 if(nbOfComp!=1 || nbOfComp2!=1)
10458 throw INTERP_KERNEL::Exception("DataArrayInt::Pow : number of components of both arrays must be equal to 1 !");
10459 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbOfTuple,1);
10460 const int *ptr1(a1->begin()),*ptr2(a2->begin());
10461 int *ptr=ret->getPointer();
10462 for(int i=0;i<nbOfTuple;i++,ptr1++,ptr2++,ptr++)
10467 for(int j=0;j<*ptr2;j++)
10473 std::ostringstream oss; oss << "DataArrayInt::Pow : on tuple #" << i << " of a2 value is < 0 (" << *ptr2 << ") !";
10474 throw INTERP_KERNEL::Exception(oss.str().c_str());
10481 * Apply pow on values of another DataArrayInt to values of \a this one.
10483 * \param [in] other - an array to pow to \a this one.
10484 * \throw If \a other is NULL.
10485 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples()
10486 * \throw If \a this->getNumberOfComponents() != 1 or \a other->getNumberOfComponents() != 1
10487 * \throw If there is a negative value in \a other.
10489 void DataArrayInt::powEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception)
10492 throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : input instance is null !");
10493 int nbOfTuple=getNumberOfTuples();
10494 int nbOfTuple2=other->getNumberOfTuples();
10495 int nbOfComp=getNumberOfComponents();
10496 int nbOfComp2=other->getNumberOfComponents();
10497 if(nbOfTuple!=nbOfTuple2)
10498 throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : number of tuples mismatches !");
10499 if(nbOfComp!=1 || nbOfComp2!=1)
10500 throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : number of components of both arrays must be equal to 1 !");
10501 int *ptr=getPointer();
10502 const int *ptrc=other->begin();
10503 for(int i=0;i<nbOfTuple;i++,ptrc++,ptr++)
10508 for(int j=0;j<*ptrc;j++)
10514 std::ostringstream oss; oss << "DataArrayInt::powEqual : on tuple #" << i << " of other value is < 0 (" << *ptrc << ") !";
10515 throw INTERP_KERNEL::Exception(oss.str().c_str());
10522 * Returns a C array which is a renumbering map in "Old to New" mode for the input array.
10523 * This map, if applied to \a start array, would make it sorted. For example, if
10524 * \a start array contents are [9,10,0,6,4,11,3,7] then the contents of the result array is
10525 * [5,6,0,3,2,7,1,4].
10526 * \param [in] start - pointer to the first element of the array for which the
10527 * permutation map is computed.
10528 * \param [in] end - pointer specifying the end of the array \a start, so that
10529 * the last value of \a start is \a end[ -1 ].
10530 * \return int * - the result permutation array that the caller is to delete as it is no
10532 * \throw If there are equal values in the input array.
10534 int *DataArrayInt::CheckAndPreparePermutation(const int *start, const int *end)
10536 std::size_t sz=std::distance(start,end);
10537 int *ret=(int *)malloc(sz*sizeof(int));
10538 int *work=new int[sz];
10539 std::copy(start,end,work);
10540 std::sort(work,work+sz);
10541 if(std::unique(work,work+sz)!=work+sz)
10545 throw INTERP_KERNEL::Exception("Some elements are equals in the specified array !");
10547 std::map<int,int> m;
10548 for(int *workPt=work;workPt!=work+sz;workPt++)
10549 m[*workPt]=(int)std::distance(work,workPt);
10551 for(const int *iter=start;iter!=end;iter++,iter2++)
10558 * Returns a new DataArrayInt containing an arithmetic progression
10559 * that is equal to the sequence returned by Python \c range(\a begin,\a end,\a step )
10561 * \param [in] begin - the start value of the result sequence.
10562 * \param [in] end - limiting value, so that every value of the result array is less than
10564 * \param [in] step - specifies the increment or decrement.
10565 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
10566 * array using decrRef() as it is no more needed.
10567 * \throw If \a step == 0.
10568 * \throw If \a end < \a begin && \a step > 0.
10569 * \throw If \a end > \a begin && \a step < 0.
10571 DataArrayInt *DataArrayInt::Range(int begin, int end, int step) throw(INTERP_KERNEL::Exception)
10573 int nbOfTuples=GetNumberOfItemGivenBESRelative(begin,end,step,"DataArrayInt::Range");
10574 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10575 ret->alloc(nbOfTuples,1);
10576 int *ptr=ret->getPointer();
10579 for(int i=begin;i<end;i+=step,ptr++)
10584 for(int i=begin;i>end;i+=step,ptr++)
10591 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
10594 void DataArrayInt::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
10596 tinyInfo.resize(2);
10599 tinyInfo[0]=getNumberOfTuples();
10600 tinyInfo[1]=getNumberOfComponents();
10610 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
10613 void DataArrayInt::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
10617 int nbOfCompo=getNumberOfComponents();
10618 tinyInfo.resize(nbOfCompo+1);
10619 tinyInfo[0]=getName();
10620 for(int i=0;i<nbOfCompo;i++)
10621 tinyInfo[i+1]=getInfoOnComponent(i);
10625 tinyInfo.resize(1);
10626 tinyInfo[0]=getName();
10631 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
10632 * This method returns if a feeding is needed.
10634 bool DataArrayInt::resizeForUnserialization(const std::vector<int>& tinyInfoI)
10636 int nbOfTuple=tinyInfoI[0];
10637 int nbOfComp=tinyInfoI[1];
10638 if(nbOfTuple!=-1 || nbOfComp!=-1)
10640 alloc(nbOfTuple,nbOfComp);
10647 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
10648 * This method returns if a feeding is needed.
10650 void DataArrayInt::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<std::string>& tinyInfoS)
10652 setName(tinyInfoS[0].c_str());
10655 int nbOfCompo=getNumberOfComponents();
10656 for(int i=0;i<nbOfCompo;i++)
10657 setInfoOnComponent(i,tinyInfoS[i+1].c_str());
10661 DataArrayIntIterator::DataArrayIntIterator(DataArrayInt *da):_da(da),_pt(0),_tuple_id(0),_nb_comp(0),_nb_tuple(0)
10666 if(_da->isAllocated())
10668 _nb_comp=da->getNumberOfComponents();
10669 _nb_tuple=da->getNumberOfTuples();
10670 _pt=da->getPointer();
10675 DataArrayIntIterator::~DataArrayIntIterator()
10681 DataArrayIntTuple *DataArrayIntIterator::nextt() throw(INTERP_KERNEL::Exception)
10683 if(_tuple_id<_nb_tuple)
10686 DataArrayIntTuple *ret=new DataArrayIntTuple(_pt,_nb_comp);
10694 DataArrayIntTuple::DataArrayIntTuple(int *pt, int nbOfComp):_pt(pt),_nb_of_compo(nbOfComp)
10698 std::string DataArrayIntTuple::repr() const throw(INTERP_KERNEL::Exception)
10700 std::ostringstream oss; oss << "(";
10701 for(int i=0;i<_nb_of_compo-1;i++)
10702 oss << _pt[i] << ", ";
10703 oss << _pt[_nb_of_compo-1] << ")";
10707 int DataArrayIntTuple::intValue() const throw(INTERP_KERNEL::Exception)
10709 if(_nb_of_compo==1)
10711 throw INTERP_KERNEL::Exception("DataArrayIntTuple::intValue : DataArrayIntTuple instance has not exactly 1 component -> Not possible to convert it into an integer !");
10715 * This method returns a newly allocated instance the caller should dealed with by a ParaMEDMEM::DataArrayInt::decrRef.
10716 * This method performs \b no copy of data. The content is only referenced using ParaMEDMEM::DataArrayInt::useArray with ownership set to \b false.
10717 * 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
10718 * \b nbOfCompo=1 and \bnbOfTuples==this->_nb_of_elem.
10720 DataArrayInt *DataArrayIntTuple::buildDAInt(int nbOfTuples, int nbOfCompo) const throw(INTERP_KERNEL::Exception)
10722 if((_nb_of_compo==nbOfCompo && nbOfTuples==1) || (_nb_of_compo==nbOfTuples && nbOfCompo==1))
10724 DataArrayInt *ret=DataArrayInt::New();
10725 ret->useExternalArrayWithRWAccess(_pt,nbOfTuples,nbOfCompo);
10730 std::ostringstream oss; oss << "DataArrayIntTuple::buildDAInt : unable to build a requested DataArrayInt instance with nbofTuple=" << nbOfTuples << " and nbOfCompo=" << nbOfCompo;
10731 oss << ".\nBecause the number of elements in this is " << _nb_of_compo << " !";
10732 throw INTERP_KERNEL::Exception(oss.str().c_str());