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());
6259 * Sorts values of the array.
6260 * \param [in] asc - \a true means ascending order, \a false, descending.
6261 * \throw If \a this is not allocated.
6262 * \throw If \a this->getNumberOfComponents() != 1.
6264 void DataArrayInt::sort(bool asc) throw(INTERP_KERNEL::Exception)
6267 if(getNumberOfComponents()!=1)
6268 throw INTERP_KERNEL::Exception("DataArrayInt::sort : only supported with 'this' array with ONE component !");
6274 * Reverse the array values.
6275 * \throw If \a this->getNumberOfComponents() < 1.
6276 * \throw If \a this is not allocated.
6278 void DataArrayInt::reverse() throw(INTERP_KERNEL::Exception)
6281 _mem.reverse(getNumberOfComponents());
6286 * Checks that \a this array is consistently **increasing** or **decreasing** in value.
6287 * If not an exception is thrown.
6288 * \param [in] increasing - if \a true, the array values should be increasing.
6289 * \throw If sequence of values is not strictly monotonic in agreement with \a
6291 * \throw If \a this->getNumberOfComponents() != 1.
6292 * \throw If \a this is not allocated.
6294 void DataArrayInt::checkMonotonic(bool increasing) const throw(INTERP_KERNEL::Exception)
6296 if(!isMonotonic(increasing))
6299 throw INTERP_KERNEL::Exception("DataArrayInt::checkMonotonic : 'this' is not INCREASING monotonic !");
6301 throw INTERP_KERNEL::Exception("DataArrayInt::checkMonotonic : 'this' is not DECREASING monotonic !");
6306 * Checks that \a this array is consistently **increasing** or **decreasing** in value.
6307 * \param [in] increasing - if \a true, array values should be increasing.
6308 * \return bool - \a true if values change in accordance with \a increasing arg.
6309 * \throw If \a this->getNumberOfComponents() != 1.
6310 * \throw If \a this is not allocated.
6312 bool DataArrayInt::isMonotonic(bool increasing) const throw(INTERP_KERNEL::Exception)
6315 if(getNumberOfComponents()!=1)
6316 throw INTERP_KERNEL::Exception("DataArrayInt::isMonotonic : only supported with 'this' array with ONE component !");
6317 int nbOfElements=getNumberOfTuples();
6318 const int *ptr=getConstPointer();
6324 for(int i=1;i<nbOfElements;i++)
6334 for(int i=1;i<nbOfElements;i++)
6346 * This method check that array consistently INCREASING or DECREASING in value.
6348 bool DataArrayInt::isStrictlyMonotonic(bool increasing) const throw(INTERP_KERNEL::Exception)
6351 if(getNumberOfComponents()!=1)
6352 throw INTERP_KERNEL::Exception("DataArrayInt::isStrictlyMonotonic : only supported with 'this' array with ONE component !");
6353 int nbOfElements=getNumberOfTuples();
6354 const int *ptr=getConstPointer();
6360 for(int i=1;i<nbOfElements;i++)
6370 for(int i=1;i<nbOfElements;i++)
6382 * This method check that array consistently INCREASING or DECREASING in value.
6384 void DataArrayInt::checkStrictlyMonotonic(bool increasing) const throw(INTERP_KERNEL::Exception)
6386 if(!isStrictlyMonotonic(increasing))
6389 throw INTERP_KERNEL::Exception("DataArrayInt::checkStrictlyMonotonic : 'this' is not strictly INCREASING monotonic !");
6391 throw INTERP_KERNEL::Exception("DataArrayInt::checkStrictlyMonotonic : 'this' is not strictly DECREASING monotonic !");
6396 * Creates a new one-dimensional DataArrayInt of the same size as \a this and a given
6397 * one-dimensional arrays that must be of the same length. The result array describes
6398 * correspondence between \a this and \a other arrays, so that
6399 * <em> other.getIJ(i,0) == this->getIJ(ret->getIJ(i),0)</em>. If such a permutation is
6400 * not possible because some element in \a other is not in \a this, an exception is thrown.
6401 * \param [in] other - an array to compute permutation to.
6402 * \return DataArrayInt * - a new instance of DataArrayInt, which is a permutation array
6403 * from \a this to \a other. The caller is to delete this array using decrRef() as it is
6405 * \throw If \a this->getNumberOfComponents() != 1.
6406 * \throw If \a other->getNumberOfComponents() != 1.
6407 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples().
6408 * \throw If \a other includes a value which is not in \a this array.
6410 * \ref cpp_mcdataarrayint_buildpermutationarr "Here is a C++ example".
6412 * \ref py_mcdataarrayint_buildpermutationarr "Here is a Python example".
6414 DataArrayInt *DataArrayInt::buildPermutationArr(const DataArrayInt& other) const throw(INTERP_KERNEL::Exception)
6417 if(getNumberOfComponents()!=1 || other.getNumberOfComponents()!=1)
6418 throw INTERP_KERNEL::Exception("DataArrayInt::buildPermutationArr : 'this' and 'other' have to have exactly ONE component !");
6419 int nbTuple=getNumberOfTuples();
6420 other.checkAllocated();
6421 if(nbTuple!=other.getNumberOfTuples())
6422 throw INTERP_KERNEL::Exception("DataArrayInt::buildPermutationArr : 'this' and 'other' must have the same number of tuple !");
6423 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6424 ret->alloc(nbTuple,1);
6425 ret->fillWithValue(-1);
6426 const int *pt=getConstPointer();
6427 std::map<int,int> mm;
6428 for(int i=0;i<nbTuple;i++)
6430 pt=other.getConstPointer();
6431 int *retToFill=ret->getPointer();
6432 for(int i=0;i<nbTuple;i++)
6434 std::map<int,int>::const_iterator it=mm.find(pt[i]);
6437 std::ostringstream oss; oss << "DataArrayInt::buildPermutationArr : Arrays mismatch : element (" << pt[i] << ") in 'other' not findable in 'this' !";
6438 throw INTERP_KERNEL::Exception(oss.str().c_str());
6440 retToFill[i]=(*it).second;
6446 * Sets a C array to be used as raw data of \a this. The previously set info
6447 * of components is retained and re-sized.
6448 * For more info see \ref MEDCouplingArraySteps1.
6449 * \param [in] array - the C array to be used as raw data of \a this.
6450 * \param [in] ownership - if \a true, \a array will be deallocated at destruction of \a this.
6451 * \param [in] type - specifies how to deallocate \a array. If \a type == ParaMEDMEM::CPP_DEALLOC,
6452 * \c delete [] \c array; will be called. If \a type == ParaMEDMEM::C_DEALLOC,
6453 * \c free(\c array ) will be called.
6454 * \param [in] nbOfTuple - new number of tuples in \a this.
6455 * \param [in] nbOfCompo - new number of components in \a this.
6457 void DataArrayInt::useArray(const int *array, bool ownership, DeallocType type, int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception)
6459 _info_on_compo.resize(nbOfCompo);
6460 _mem.useArray(array,ownership,type,nbOfTuple*nbOfCompo);
6464 void DataArrayInt::useExternalArrayWithRWAccess(const int *array, int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception)
6466 _info_on_compo.resize(nbOfCompo);
6467 _mem.useExternalArrayWithRWAccess(array,nbOfTuple*nbOfCompo);
6472 * Returns a new DataArrayInt holding the same values as \a this array but differently
6473 * arranged in memory. If \a this array holds 2 components of 3 values:
6474 * \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$, then the result array holds these values arranged
6475 * as follows: \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$.
6476 * \warning Do not confuse this method with transpose()!
6477 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6478 * is to delete using decrRef() as it is no more needed.
6479 * \throw If \a this is not allocated.
6481 DataArrayInt *DataArrayInt::fromNoInterlace() const throw(INTERP_KERNEL::Exception)
6485 throw INTERP_KERNEL::Exception("DataArrayInt::fromNoInterlace : Not defined array !");
6486 int *tab=_mem.fromNoInterlace(getNumberOfComponents());
6487 DataArrayInt *ret=DataArrayInt::New();
6488 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
6493 * Returns a new DataArrayInt holding the same values as \a this array but differently
6494 * arranged in memory. If \a this array holds 2 components of 3 values:
6495 * \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$, then the result array holds these values arranged
6496 * as follows: \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$.
6497 * \warning Do not confuse this method with transpose()!
6498 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6499 * is to delete using decrRef() as it is no more needed.
6500 * \throw If \a this is not allocated.
6502 DataArrayInt *DataArrayInt::toNoInterlace() const throw(INTERP_KERNEL::Exception)
6506 throw INTERP_KERNEL::Exception("DataArrayInt::toNoInterlace : Not defined array !");
6507 int *tab=_mem.toNoInterlace(getNumberOfComponents());
6508 DataArrayInt *ret=DataArrayInt::New();
6509 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
6514 * Permutes values of \a this array as required by \a old2New array. The values are
6515 * permuted so that \c new[ \a old2New[ i ]] = \c old[ i ]. Number of tuples remains
6516 * the same as in \this one.
6517 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
6518 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6519 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
6520 * giving a new position for i-th old value.
6522 void DataArrayInt::renumberInPlace(const int *old2New) throw(INTERP_KERNEL::Exception)
6525 int nbTuples=getNumberOfTuples();
6526 int nbOfCompo=getNumberOfComponents();
6527 int *tmp=new int[nbTuples*nbOfCompo];
6528 const int *iptr=getConstPointer();
6529 for(int i=0;i<nbTuples;i++)
6532 if(v>=0 && v<nbTuples)
6533 std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),tmp+nbOfCompo*v);
6536 std::ostringstream oss; oss << "DataArrayInt::renumberInPlace : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
6537 throw INTERP_KERNEL::Exception(oss.str().c_str());
6540 std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
6546 * Permutes values of \a this array as required by \a new2Old array. The values are
6547 * permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of tuples remains
6548 * the same as in \this one.
6549 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6550 * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
6551 * giving a previous position of i-th new value.
6552 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6553 * is to delete using decrRef() as it is no more needed.
6555 void DataArrayInt::renumberInPlaceR(const int *new2Old) throw(INTERP_KERNEL::Exception)
6558 int nbTuples=getNumberOfTuples();
6559 int nbOfCompo=getNumberOfComponents();
6560 int *tmp=new int[nbTuples*nbOfCompo];
6561 const int *iptr=getConstPointer();
6562 for(int i=0;i<nbTuples;i++)
6565 if(v>=0 && v<nbTuples)
6566 std::copy(iptr+nbOfCompo*v,iptr+nbOfCompo*(v+1),tmp+nbOfCompo*i);
6569 std::ostringstream oss; oss << "DataArrayInt::renumberInPlaceR : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
6570 throw INTERP_KERNEL::Exception(oss.str().c_str());
6573 std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
6579 * Returns a copy of \a this array with values permuted as required by \a old2New array.
6580 * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ].
6581 * Number of tuples in the result array remains the same as in \this one.
6582 * If a permutation reduction is needed, renumberAndReduce() should be used.
6583 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6584 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
6585 * giving a new position for i-th old value.
6586 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6587 * is to delete using decrRef() as it is no more needed.
6588 * \throw If \a this is not allocated.
6590 DataArrayInt *DataArrayInt::renumber(const int *old2New) const throw(INTERP_KERNEL::Exception)
6593 int nbTuples=getNumberOfTuples();
6594 int nbOfCompo=getNumberOfComponents();
6595 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6596 ret->alloc(nbTuples,nbOfCompo);
6597 ret->copyStringInfoFrom(*this);
6598 const int *iptr=getConstPointer();
6599 int *optr=ret->getPointer();
6600 for(int i=0;i<nbTuples;i++)
6601 std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),optr+nbOfCompo*old2New[i]);
6602 ret->copyStringInfoFrom(*this);
6607 * Returns a copy of \a this array with values permuted as required by \a new2Old array.
6608 * The values are permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of
6609 * tuples in the result array remains the same as in \this one.
6610 * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
6611 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6612 * \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
6613 * giving a previous position of i-th new value.
6614 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6615 * is to delete using decrRef() as it is no more needed.
6617 DataArrayInt *DataArrayInt::renumberR(const int *new2Old) const throw(INTERP_KERNEL::Exception)
6620 int nbTuples=getNumberOfTuples();
6621 int nbOfCompo=getNumberOfComponents();
6622 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6623 ret->alloc(nbTuples,nbOfCompo);
6624 ret->copyStringInfoFrom(*this);
6625 const int *iptr=getConstPointer();
6626 int *optr=ret->getPointer();
6627 for(int i=0;i<nbTuples;i++)
6628 std::copy(iptr+nbOfCompo*new2Old[i],iptr+nbOfCompo*(new2Old[i]+1),optr+nbOfCompo*i);
6629 ret->copyStringInfoFrom(*this);
6634 * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
6635 * of size \a newNbOfTuple and it's values are permuted as required by \a old2New array.
6636 * The values are permuted so that \c new[ \a old2New[ i ]] = \c old[ i ] for all
6637 * \a old2New[ i ] >= 0. In other words every i-th tuple in \a this array, for which
6638 * \a old2New[ i ] is negative, is missing from the result array.
6639 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6640 * \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
6641 * giving a new position for i-th old tuple and giving negative position for
6642 * for i-th old tuple that should be omitted.
6643 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6644 * is to delete using decrRef() as it is no more needed.
6646 DataArrayInt *DataArrayInt::renumberAndReduce(const int *old2New, int newNbOfTuple) const throw(INTERP_KERNEL::Exception)
6649 int nbTuples=getNumberOfTuples();
6650 int nbOfCompo=getNumberOfComponents();
6651 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6652 ret->alloc(newNbOfTuple,nbOfCompo);
6653 const int *iptr=getConstPointer();
6654 int *optr=ret->getPointer();
6655 for(int i=0;i<nbTuples;i++)
6659 std::copy(iptr+i*nbOfCompo,iptr+(i+1)*nbOfCompo,optr+w*nbOfCompo);
6661 ret->copyStringInfoFrom(*this);
6666 * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
6667 * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
6668 * \a new2OldBg array.
6669 * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
6670 * This method is equivalent to renumberAndReduce() except that convention in input is
6671 * \c new2old and \b not \c old2new.
6672 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6673 * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
6674 * tuple index in \a this array to fill the i-th tuple in the new array.
6675 * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
6676 * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
6677 * \a new2OldBg <= \a pi < \a new2OldEnd.
6678 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6679 * is to delete using decrRef() as it is no more needed.
6681 DataArrayInt *DataArrayInt::selectByTupleId(const int *new2OldBg, const int *new2OldEnd) const
6684 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6685 int nbComp=getNumberOfComponents();
6686 ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
6687 ret->copyStringInfoFrom(*this);
6688 int *pt=ret->getPointer();
6689 const int *srcPt=getConstPointer();
6691 for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
6692 std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
6693 ret->copyStringInfoFrom(*this);
6698 * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
6699 * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
6700 * \a new2OldBg array.
6701 * The values are permuted so that \c new[ i ] = \c old[ \a new2OldBg[ i ]].
6702 * This method is equivalent to renumberAndReduce() except that convention in input is
6703 * \c new2old and \b not \c old2new.
6704 * This method is equivalent to selectByTupleId() except that it prevents coping data
6705 * from behind the end of \a this array.
6706 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6707 * \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
6708 * tuple index in \a this array to fill the i-th tuple in the new array.
6709 * \param [in] new2OldEnd - specifies the end of the permutation array that starts at
6710 * \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
6711 * \a new2OldBg <= \a pi < \a new2OldEnd.
6712 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6713 * is to delete using decrRef() as it is no more needed.
6714 * \throw If \a new2OldEnd - \a new2OldBg > \a this->getNumberOfTuples().
6716 DataArrayInt *DataArrayInt::selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const throw(INTERP_KERNEL::Exception)
6719 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6720 int nbComp=getNumberOfComponents();
6721 int oldNbOfTuples=getNumberOfTuples();
6722 ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
6723 ret->copyStringInfoFrom(*this);
6724 int *pt=ret->getPointer();
6725 const int *srcPt=getConstPointer();
6727 for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
6728 if(*w>=0 && *w<oldNbOfTuples)
6729 std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
6731 throw INTERP_KERNEL::Exception("DataArrayInt::selectByTupleIdSafe : some ids has been detected to be out of [0,this->getNumberOfTuples) !");
6732 ret->copyStringInfoFrom(*this);
6737 * Returns a shorten copy of \a this array. The new DataArrayInt contains every
6738 * (\a bg + \c i * \a step)-th tuple of \a this array located before the \a end2-th
6739 * tuple. Indices of the selected tuples are the same as ones returned by the Python
6740 * command \c range( \a bg, \a end2, \a step ).
6741 * This method is equivalent to selectByTupleIdSafe() except that the input array is
6742 * not constructed explicitly.
6743 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6744 * \param [in] bg - index of the first tuple to copy from \a this array.
6745 * \param [in] end2 - index of the tuple before which the tuples to copy are located.
6746 * \param [in] step - index increment to get index of the next tuple to copy.
6747 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6748 * is to delete using decrRef() as it is no more needed.
6749 * \sa DataArrayInt::substr.
6751 DataArrayInt *DataArrayInt::selectByTupleId2(int bg, int end2, int step) const throw(INTERP_KERNEL::Exception)
6754 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6755 int nbComp=getNumberOfComponents();
6756 int newNbOfTuples=GetNumberOfItemGivenBESRelative(bg,end2,step,"DataArrayInt::selectByTupleId2 : ");
6757 ret->alloc(newNbOfTuples,nbComp);
6758 int *pt=ret->getPointer();
6759 const int *srcPt=getConstPointer()+bg*nbComp;
6760 for(int i=0;i<newNbOfTuples;i++,srcPt+=step*nbComp)
6761 std::copy(srcPt,srcPt+nbComp,pt+i*nbComp);
6762 ret->copyStringInfoFrom(*this);
6767 * Returns a shorten copy of \a this array. The new DataArrayInt contains ranges
6768 * of tuples specified by \a ranges parameter.
6769 * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
6770 * \param [in] ranges - std::vector of std::pair's each of which defines a range
6771 * of tuples in [\c begin,\c end) format.
6772 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
6773 * is to delete using decrRef() as it is no more needed.
6774 * \throw If \a end < \a begin.
6775 * \throw If \a end > \a this->getNumberOfTuples().
6776 * \throw If \a this is not allocated.
6778 DataArray *DataArrayInt::selectByTupleRanges(const std::vector<std::pair<int,int> >& ranges) const throw(INTERP_KERNEL::Exception)
6781 int nbOfComp=getNumberOfComponents();
6782 int nbOfTuplesThis=getNumberOfTuples();
6785 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6786 ret->alloc(0,nbOfComp);
6787 ret->copyStringInfoFrom(*this);
6790 int ref=ranges.front().first;
6792 bool isIncreasing=true;
6793 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
6795 if((*it).first<=(*it).second)
6797 if((*it).first>=0 && (*it).second<=nbOfTuplesThis)
6799 nbOfTuples+=(*it).second-(*it).first;
6801 isIncreasing=ref<=(*it).first;
6806 std::ostringstream oss; oss << "DataArrayInt::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
6807 oss << " (" << (*it).first << "," << (*it).second << ") is greater than number of tuples of this :" << nbOfTuples << " !";
6808 throw INTERP_KERNEL::Exception(oss.str().c_str());
6813 std::ostringstream oss; oss << "DataArrayInt::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
6814 oss << " (" << (*it).first << "," << (*it).second << ") end is before begin !";
6815 throw INTERP_KERNEL::Exception(oss.str().c_str());
6818 if(isIncreasing && nbOfTuplesThis==nbOfTuples)
6820 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6821 ret->alloc(nbOfTuples,nbOfComp);
6822 ret->copyStringInfoFrom(*this);
6823 const int *src=getConstPointer();
6824 int *work=ret->getPointer();
6825 for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
6826 work=std::copy(src+(*it).first*nbOfComp,src+(*it).second*nbOfComp,work);
6831 * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode.
6832 * This map, if applied to \a this array, would make it sorted. For example, if
6833 * \a this array contents are [9,10,0,6,4,11,3,7] then the contents of the result array
6834 * are [5,6,0,3,2,7,1,4]; if this result array (\a res) is used as an argument in call
6835 * \a this->renumber(\a res) then the returned array contains [0,3,4,6,7,9,10,11].
6836 * This method is useful for renumbering (in MED file for example). For more info
6837 * on renumbering see \ref MEDCouplingArrayRenumbering.
6838 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
6839 * array using decrRef() as it is no more needed.
6840 * \throw If \a this is not allocated.
6841 * \throw If \a this->getNumberOfComponents() != 1.
6842 * \throw If there are equal values in \a this array.
6844 DataArrayInt *DataArrayInt::checkAndPreparePermutation() const throw(INTERP_KERNEL::Exception)
6847 if(getNumberOfComponents()!=1)
6848 throw INTERP_KERNEL::Exception("DataArrayInt::checkAndPreparePermutation : number of components must == 1 !");
6849 int nbTuples=getNumberOfTuples();
6850 const int *pt=getConstPointer();
6851 int *pt2=CheckAndPreparePermutation(pt,pt+nbTuples);
6852 DataArrayInt *ret=DataArrayInt::New();
6853 ret->useArray(pt2,true,C_DEALLOC,nbTuples,1);
6858 * This method tries to find the permutation to apply to the first input \a ids1 to obtain the same array (without considering strings informations) the second
6859 * input array \a ids2.
6860 * \a ids1 and \a ids2 are expected to be both a list of ids (both with number of components equal to one) not sorted and with values that can be negative.
6861 * This method will throw an exception is no such permutation array can be obtained. It is typically the case if there is some ids in \a ids1 not in \a ids2 or
6863 * In case of success (no throw) : \c ids1->renumber(ret)->isEqual(ids2) where \a ret is the return of this method.
6865 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
6866 * array using decrRef() as it is no more needed.
6867 * \throw If either ids1 or ids2 is null not allocated or not with one components.
6870 DataArrayInt *DataArrayInt::FindPermutationFromFirstToSecond(const DataArrayInt *ids1, const DataArrayInt *ids2) throw(INTERP_KERNEL::Exception)
6873 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays must be not null !");
6874 if(!ids1->isAllocated() || !ids2->isAllocated())
6875 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays must be allocated !");
6876 if(ids1->getNumberOfComponents()!=1 || ids2->getNumberOfComponents()!=1)
6877 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays have exactly one component !");
6878 if(ids1->getNumberOfTuples()!=ids2->getNumberOfTuples())
6880 std::ostringstream oss; oss << "DataArrayInt::FindPermutationFromFirstToSecond : first array has " << ids1->getNumberOfTuples() << " tuples and the second one " << ids2->getNumberOfTuples() << " tuples ! No chance to find a permutation between the 2 arrays !";
6881 throw INTERP_KERNEL::Exception(oss.str().c_str());
6883 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(ids1->deepCpy());
6884 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p2(ids2->deepCpy());
6885 p1->sort(true); p2->sort(true);
6886 if(!p1->isEqualWithoutConsideringStr(*p2))
6887 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two arrays are not lying on same ids ! Impossible to find a permutation betwenn the 2 arrays !");
6888 p1=ids1->checkAndPreparePermutation();
6889 p2=ids2->checkAndPreparePermutation();
6890 p2=p2->invertArrayO2N2N2O(p2->getNumberOfTuples());
6891 p2=p2->selectByTupleIdSafe(p1->begin(),p1->end());
6896 * Returns two arrays describing a surjective mapping from \a this set of values (\a A)
6897 * onto a set of values of size \a targetNb (\a B). The surjective function is
6898 * \a B[ \a A[ i ]] = i. That is to say that for each \a id in [0,\a targetNb), where \a
6899 * targetNb < \a this->getNumberOfTuples(), there exists at least one tupleId (\a tid) so
6900 * that <em> this->getIJ( tid, 0 ) == id</em>. <br>
6901 * The first of out arrays returns indices of elements of \a this array, grouped by their
6902 * place in the set \a B. The second out array is the index of the first one; it shows how
6903 * many elements of \a A are mapped into each element of \a B. <br>
6905 * mapping and its usage in renumbering see \ref MEDCouplingArrayRenumbering. <br>
6907 * - \a this: [0,3,2,3,2,2,1,2]
6909 * - \a arr: [0, 6, 2,4,5,7, 1,3]
6910 * - \a arrI: [0,1,2,6,8]
6912 * This result means: <br>
6913 * the element of \a B 0 encounters within \a A once (\a arrI[ 0+1 ] - \a arrI[ 0 ]) and
6914 * its index within \a A is 0 ( \a arr[ 0:1 ] == \a arr[ \a arrI[ 0 ] : \a arrI[ 0+1 ]]);<br>
6915 * the element of \a B 2 encounters within \a A 4 times (\a arrI[ 2+1 ] - \a arrI[ 2 ]) and
6916 * its indices within \a A are [2,4,5,7] ( \a arr[ 2:6 ] == \a arr[ \a arrI[ 2 ] :
6917 * \a arrI[ 2+1 ]]); <br> etc.
6918 * \param [in] targetNb - the size of the set \a B. \a targetNb must be equal or more
6919 * than the maximal value of \a A.
6920 * \param [out] arr - a new instance of DataArrayInt returning indices of
6921 * elements of \a this, grouped by their place in the set \a B. The caller is to delete
6922 * this array using decrRef() as it is no more needed.
6923 * \param [out] arrI - a new instance of DataArrayInt returning size of groups of equal
6924 * elements of \a this. The caller is to delete this array using decrRef() as it
6925 * is no more needed.
6926 * \throw If \a this is not allocated.
6927 * \throw If \a this->getNumberOfComponents() != 1.
6928 * \throw If any value in \a this is more or equal to \a targetNb.
6930 void DataArrayInt::changeSurjectiveFormat(int targetNb, DataArrayInt *&arr, DataArrayInt *&arrI) const throw(INTERP_KERNEL::Exception)
6933 if(getNumberOfComponents()!=1)
6934 throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : number of components must == 1 !");
6935 int nbOfTuples=getNumberOfTuples();
6936 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
6937 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> retI(DataArrayInt::New());
6938 retI->alloc(targetNb+1,1);
6939 const int *input=getConstPointer();
6940 std::vector< std::vector<int> > tmp(targetNb);
6941 for(int i=0;i<nbOfTuples;i++)
6944 if(tmp2>=0 && tmp2<targetNb)
6945 tmp[tmp2].push_back(i);
6948 std::ostringstream oss; oss << "DataArrayInt::changeSurjectiveFormat : At pos " << i << " presence of element " << tmp2 << " ! should be in [0," << targetNb << ") !";
6949 throw INTERP_KERNEL::Exception(oss.str().c_str());
6952 int *retIPtr=retI->getPointer();
6954 for(std::vector< std::vector<int> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++,retIPtr++)
6955 retIPtr[1]=retIPtr[0]+(int)((*it1).size());
6956 if(nbOfTuples!=retI->getIJ(targetNb,0))
6957 throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : big problem should never happen !");
6958 ret->alloc(nbOfTuples,1);
6959 int *retPtr=ret->getPointer();
6960 for(std::vector< std::vector<int> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++)
6961 retPtr=std::copy((*it1).begin(),(*it1).end(),retPtr);
6968 * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode computed
6969 * from a zip representation of a surjective format (returned e.g. by
6970 * \ref ParaMEDMEM::DataArrayDouble::findCommonTuples() "DataArrayDouble::findCommonTuples()"
6971 * for example). The result array minimizes the permutation. <br>
6972 * For more info on renumbering see \ref MEDCouplingArrayRenumbering. <br>
6974 * - \a nbOfOldTuples: 10
6975 * - \a arr : [0,3, 5,7,9]
6976 * - \a arrIBg : [0,2,5]
6977 * - \a newNbOfTuples: 7
6978 * - result array : [0,1,2,0,3,4,5,4,6,4]
6980 * \param [in] nbOfOldTuples - number of tuples in the initial array \a arr.
6981 * \param [in] arr - the array of tuple indices grouped by \a arrIBg array.
6982 * \param [in] arrIBg - the array dividing all indices stored in \a arr into groups of
6983 * (indices of) equal values. Its every element (except the last one) points to
6984 * the first element of a group of equal values.
6985 * \param [in] arrIEnd - specifies the end of \a arrIBg, so that the last element of \a
6986 * arrIBg is \a arrIEnd[ -1 ].
6987 * \param [out] newNbOfTuples - number of tuples after surjection application.
6988 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
6989 * array using decrRef() as it is no more needed.
6990 * \throw If any value of \a arr breaks condition ( 0 <= \a arr[ i ] < \a nbOfOldTuples ).
6992 DataArrayInt *DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(int nbOfOldTuples, const int *arr, const int *arrIBg, const int *arrIEnd, int &newNbOfTuples) throw(INTERP_KERNEL::Exception)
6994 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6995 ret->alloc(nbOfOldTuples,1);
6996 int *pt=ret->getPointer();
6997 std::fill(pt,pt+nbOfOldTuples,-1);
6998 int nbOfGrps=((int)std::distance(arrIBg,arrIEnd))-1;
6999 const int *cIPtr=arrIBg;
7000 for(int i=0;i<nbOfGrps;i++)
7001 pt[arr[cIPtr[i]]]=-(i+2);
7003 for(int iNode=0;iNode<nbOfOldTuples;iNode++)
7011 int grpId=-(pt[iNode]+2);
7012 for(int j=cIPtr[grpId];j<cIPtr[grpId+1];j++)
7014 if(arr[j]>=0 && arr[j]<nbOfOldTuples)
7018 std::ostringstream oss; oss << "DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2 : With element #" << j << " value is " << arr[j] << " should be in [0," << nbOfOldTuples << ") !";
7019 throw INTERP_KERNEL::Exception(oss.str().c_str());
7026 newNbOfTuples=newNb;
7031 * Returns a new DataArrayInt containing a renumbering map in "New to Old" mode,
7032 * which if applied to \a this array would make it sorted ascendingly.
7033 * For more info on renumbering see \ref MEDCouplingArrayRenumbering. <br>
7035 * - \a this: [2,0,1,1,0,1,2,0,1,1,0,0]
7036 * - result: [10,0,5,6,1,7,11,2,8,9,3,4]
7037 * - after applying result to \a this: [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2]
7039 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7040 * array using decrRef() as it is no more needed.
7041 * \throw If \a this is not allocated.
7042 * \throw If \a this->getNumberOfComponents() != 1.
7044 DataArrayInt *DataArrayInt::buildPermArrPerLevel() const throw(INTERP_KERNEL::Exception)
7047 if(getNumberOfComponents()!=1)
7048 throw INTERP_KERNEL::Exception("DataArrayInt::buildPermArrPerLevel : number of components must == 1 !");
7049 int nbOfTuples=getNumberOfTuples();
7050 const int *pt=getConstPointer();
7051 std::map<int,int> m;
7052 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7053 ret->alloc(nbOfTuples,1);
7054 int *opt=ret->getPointer();
7055 for(int i=0;i<nbOfTuples;i++,pt++,opt++)
7058 std::map<int,int>::iterator it=m.find(val);
7067 m.insert(std::pair<int,int>(val,1));
7071 for(std::map<int,int>::iterator it=m.begin();it!=m.end();it++)
7073 int vt=(*it).second;
7077 pt=getConstPointer();
7078 opt=ret->getPointer();
7079 for(int i=0;i<nbOfTuples;i++,pt++,opt++)
7086 * Checks if contents of \a this array are equal to that of an array filled with
7087 * iota(). This method is particularly useful for DataArrayInt instances that represent
7088 * a renumbering array to check the real need in renumbering.
7089 * \return bool - \a true if \a this array contents == \a range( \a this->getNumberOfTuples())
7090 * \throw If \a this is not allocated.
7091 * \throw If \a this->getNumberOfComponents() != 1.
7093 bool DataArrayInt::isIdentity() const throw(INTERP_KERNEL::Exception)
7096 if(getNumberOfComponents()!=1)
7098 int nbOfTuples=getNumberOfTuples();
7099 const int *pt=getConstPointer();
7100 for(int i=0;i<nbOfTuples;i++,pt++)
7107 * Checks if all values in \a this array are equal to \a val.
7108 * \param [in] val - value to check equality of array values to.
7109 * \return bool - \a true if all values are \a val.
7110 * \throw If \a this is not allocated.
7111 * \throw If \a this->getNumberOfComponents() != 1
7113 bool DataArrayInt::isUniform(int val) const throw(INTERP_KERNEL::Exception)
7116 if(getNumberOfComponents()!=1)
7117 throw INTERP_KERNEL::Exception("DataArrayInt::isUniform : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
7118 int nbOfTuples=getNumberOfTuples();
7119 const int *w=getConstPointer();
7120 const int *end2=w+nbOfTuples;
7128 * Creates a new DataArrayDouble and assigns all (textual and numerical) data of \a this
7129 * array to the new one.
7130 * \return DataArrayDouble * - the new instance of DataArrayInt.
7132 DataArrayDouble *DataArrayInt::convertToDblArr() const
7135 DataArrayDouble *ret=DataArrayDouble::New();
7136 ret->alloc(getNumberOfTuples(),getNumberOfComponents());
7137 std::size_t nbOfVals=getNbOfElems();
7138 const int *src=getConstPointer();
7139 double *dest=ret->getPointer();
7140 std::copy(src,src+nbOfVals,dest);
7141 ret->copyStringInfoFrom(*this);
7146 * Returns a shorten copy of \a this array. The new DataArrayInt contains all
7147 * tuples starting from the \a tupleIdBg-th tuple and including all tuples located before
7148 * the \a tupleIdEnd-th one. This methods has a similar behavior as std::string::substr().
7149 * This method is a specialization of selectByTupleId2().
7150 * \param [in] tupleIdBg - index of the first tuple to copy from \a this array.
7151 * \param [in] tupleIdEnd - index of the tuple before which the tuples to copy are located.
7152 * If \a tupleIdEnd == -1, all the tuples till the end of \a this array are copied.
7153 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7154 * is to delete using decrRef() as it is no more needed.
7155 * \throw If \a tupleIdBg < 0.
7156 * \throw If \a tupleIdBg > \a this->getNumberOfTuples().
7157 \throw If \a tupleIdEnd != -1 && \a tupleIdEnd < \a this->getNumberOfTuples().
7158 * \sa DataArrayInt::selectByTupleId2
7160 DataArrayInt *DataArrayInt::substr(int tupleIdBg, int tupleIdEnd) const throw(INTERP_KERNEL::Exception)
7163 int nbt=getNumberOfTuples();
7165 throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter must be greater than 0 !");
7167 throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter is greater than number of tuples !");
7168 int trueEnd=tupleIdEnd;
7172 throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter is greater or equal than number of tuples !");
7176 int nbComp=getNumberOfComponents();
7177 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7178 ret->alloc(trueEnd-tupleIdBg,nbComp);
7179 ret->copyStringInfoFrom(*this);
7180 std::copy(getConstPointer()+tupleIdBg*nbComp,getConstPointer()+trueEnd*nbComp,ret->getPointer());
7185 * Changes the number of components within \a this array so that its raw data **does
7186 * not** change, instead splitting this data into tuples changes.
7187 * \warning This method erases all (name and unit) component info set before!
7188 * \param [in] newNbOfComp - number of components for \a this array to have.
7189 * \throw If \a this is not allocated
7190 * \throw If getNbOfElems() % \a newNbOfCompo != 0.
7191 * \throw If \a newNbOfCompo is lower than 1.
7192 * \throw If the rearrange method would lead to a number of tuples higher than 2147483647 (maximal capacity of int32 !).
7193 * \warning This method erases all (name and unit) component info set before!
7195 void DataArrayInt::rearrange(int newNbOfCompo) throw(INTERP_KERNEL::Exception)
7199 throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : input newNbOfCompo must be > 0 !");
7200 std::size_t nbOfElems=getNbOfElems();
7201 if(nbOfElems%newNbOfCompo!=0)
7202 throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : nbOfElems%newNbOfCompo!=0 !");
7203 if(nbOfElems/newNbOfCompo>(std::size_t)std::numeric_limits<int>::max())
7204 throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : the rearrangement leads to too high number of tuples (> 2147483647) !");
7205 _info_on_compo.clear();
7206 _info_on_compo.resize(newNbOfCompo);
7211 * Changes the number of components within \a this array to be equal to its number
7212 * of tuples, and inversely its number of tuples to become equal to its number of
7213 * components. So that its raw data **does not** change, instead splitting this
7214 * data into tuples changes.
7215 * \warning This method erases all (name and unit) component info set before!
7216 * \warning Do not confuse this method with fromNoInterlace() and toNoInterlace()!
7217 * \throw If \a this is not allocated.
7220 void DataArrayInt::transpose() throw(INTERP_KERNEL::Exception)
7223 int nbOfTuples=getNumberOfTuples();
7224 rearrange(nbOfTuples);
7228 * Returns a shorten or extended copy of \a this array. If \a newNbOfComp is less
7229 * than \a this->getNumberOfComponents() then the result array is shorten as each tuple
7230 * is truncated to have \a newNbOfComp components, keeping first components. If \a
7231 * newNbOfComp is more than \a this->getNumberOfComponents() then the result array is
7232 * expanded as each tuple is populated with \a dftValue to have \a newNbOfComp
7234 * \param [in] newNbOfComp - number of components for the new array to have.
7235 * \param [in] dftValue - value assigned to new values added to the new array.
7236 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
7237 * is to delete using decrRef() as it is no more needed.
7238 * \throw If \a this is not allocated.
7240 DataArrayInt *DataArrayInt::changeNbOfComponents(int newNbOfComp, int dftValue) const throw(INTERP_KERNEL::Exception)
7243 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7244 ret->alloc(getNumberOfTuples(),newNbOfComp);
7245 const int *oldc=getConstPointer();
7246 int *nc=ret->getPointer();
7247 int nbOfTuples=getNumberOfTuples();
7248 int oldNbOfComp=getNumberOfComponents();
7249 int dim=std::min(oldNbOfComp,newNbOfComp);
7250 for(int i=0;i<nbOfTuples;i++)
7254 nc[newNbOfComp*i+j]=oldc[i*oldNbOfComp+j];
7255 for(;j<newNbOfComp;j++)
7256 nc[newNbOfComp*i+j]=dftValue;
7258 ret->setName(getName().c_str());
7259 for(int i=0;i<dim;i++)
7260 ret->setInfoOnComponent(i,getInfoOnComponent(i).c_str());
7261 ret->setName(getName().c_str());
7266 * Changes number of tuples in the array. If the new number of tuples is smaller
7267 * than the current number the array is truncated, otherwise the array is extended.
7268 * \param [in] nbOfTuples - new number of tuples.
7269 * \throw If \a this is not allocated.
7270 * \throw If \a nbOfTuples is negative.
7272 void DataArrayInt::reAlloc(int nbOfTuples) throw(INTERP_KERNEL::Exception)
7275 throw INTERP_KERNEL::Exception("DataArrayInt::reAlloc : input new number of tuples should be >=0 !");
7277 _mem.reAlloc(getNumberOfComponents()*(std::size_t)nbOfTuples);
7283 * Returns a copy of \a this array composed of selected components.
7284 * The new DataArrayInt has the same number of tuples but includes components
7285 * specified by \a compoIds parameter. So that getNbOfElems() of the result array
7286 * can be either less, same or more than \a this->getNbOfElems().
7287 * \param [in] compoIds - sequence of zero based indices of components to include
7288 * into the new array.
7289 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
7290 * is to delete using decrRef() as it is no more needed.
7291 * \throw If \a this is not allocated.
7292 * \throw If a component index (\a i) is not valid:
7293 * \a i < 0 || \a i >= \a this->getNumberOfComponents().
7295 * \ref py_mcdataarrayint_keepselectedcomponents "Here is a Python example".
7297 DataArray *DataArrayInt::keepSelectedComponents(const std::vector<int>& compoIds) const throw(INTERP_KERNEL::Exception)
7300 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
7301 int newNbOfCompo=(int)compoIds.size();
7302 int oldNbOfCompo=getNumberOfComponents();
7303 for(std::vector<int>::const_iterator it=compoIds.begin();it!=compoIds.end();it++)
7304 DataArray::CheckValueInRange(oldNbOfCompo,(*it),"keepSelectedComponents invalid requested component");
7305 int nbOfTuples=getNumberOfTuples();
7306 ret->alloc(nbOfTuples,newNbOfCompo);
7307 ret->copyPartOfStringInfoFrom(*this,compoIds);
7308 const int *oldc=getConstPointer();
7309 int *nc=ret->getPointer();
7310 for(int i=0;i<nbOfTuples;i++)
7311 for(int j=0;j<newNbOfCompo;j++,nc++)
7312 *nc=oldc[i*oldNbOfCompo+compoIds[j]];
7317 * Appends components of another array to components of \a this one, tuple by tuple.
7318 * So that the number of tuples of \a this array remains the same and the number of
7319 * components increases.
7320 * \param [in] other - the DataArrayInt to append to \a this one.
7321 * \throw If \a this is not allocated.
7322 * \throw If \a this and \a other arrays have different number of tuples.
7324 * \ref cpp_mcdataarrayint_meldwith "Here is a C++ example".
7326 * \ref py_mcdataarrayint_meldwith "Here is a Python example".
7328 void DataArrayInt::meldWith(const DataArrayInt *other) throw(INTERP_KERNEL::Exception)
7331 throw INTERP_KERNEL::Exception("DataArrayInt::meldWith : DataArrayInt pointer in input is NULL !");
7333 other->checkAllocated();
7334 int nbOfTuples=getNumberOfTuples();
7335 if(nbOfTuples!=other->getNumberOfTuples())
7336 throw INTERP_KERNEL::Exception("DataArrayInt::meldWith : mismatch of number of tuples !");
7337 int nbOfComp1=getNumberOfComponents();
7338 int nbOfComp2=other->getNumberOfComponents();
7339 int *newArr=(int *)malloc(nbOfTuples*(nbOfComp1+nbOfComp2)*sizeof(int));
7341 const int *inp1=getConstPointer();
7342 const int *inp2=other->getConstPointer();
7343 for(int i=0;i<nbOfTuples;i++,inp1+=nbOfComp1,inp2+=nbOfComp2)
7345 w=std::copy(inp1,inp1+nbOfComp1,w);
7346 w=std::copy(inp2,inp2+nbOfComp2,w);
7348 useArray(newArr,true,C_DEALLOC,nbOfTuples,nbOfComp1+nbOfComp2);
7349 std::vector<int> compIds(nbOfComp2);
7350 for(int i=0;i<nbOfComp2;i++)
7351 compIds[i]=nbOfComp1+i;
7352 copyPartOfStringInfoFrom2(compIds,*other);
7356 * Copy all components in a specified order from another DataArrayInt.
7357 * The specified components become the first ones in \a this array.
7358 * Both numerical and textual data is copied. The number of tuples in \a this and
7359 * the other array can be different.
7360 * \param [in] a - the array to copy data from.
7361 * \param [in] compoIds - sequence of zero based indices of components, data of which is
7363 * \throw If \a a is NULL.
7364 * \throw If \a compoIds.size() != \a a->getNumberOfComponents().
7365 * \throw If \a compoIds[i] < 0 or \a compoIds[i] > \a this->getNumberOfComponents().
7367 * \ref py_mcdataarrayint_setselectedcomponents "Here is a Python example".
7369 void DataArrayInt::setSelectedComponents(const DataArrayInt *a, const std::vector<int>& compoIds) throw(INTERP_KERNEL::Exception)
7372 throw INTERP_KERNEL::Exception("DataArrayInt::setSelectedComponents : input DataArrayInt is NULL !");
7374 a->checkAllocated();
7375 copyPartOfStringInfoFrom2(compoIds,*a);
7376 std::size_t partOfCompoSz=compoIds.size();
7377 int nbOfCompo=getNumberOfComponents();
7378 int nbOfTuples=std::min(getNumberOfTuples(),a->getNumberOfTuples());
7379 const int *ac=a->getConstPointer();
7380 int *nc=getPointer();
7381 for(int i=0;i<nbOfTuples;i++)
7382 for(std::size_t j=0;j<partOfCompoSz;j++,ac++)
7383 nc[nbOfCompo*i+compoIds[j]]=*ac;
7387 * Copy all values from another DataArrayInt into specified tuples and components
7388 * of \a this array. Textual data is not copied.
7389 * The tree parameters defining set of indices of tuples and components are similar to
7390 * the tree parameters of the Python function \c range(\c start,\c stop,\c step).
7391 * \param [in] a - the array to copy values from.
7392 * \param [in] bgTuples - index of the first tuple of \a this array to assign values to.
7393 * \param [in] endTuples - index of the tuple before which the tuples to assign to
7395 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
7396 * \param [in] bgComp - index of the first component of \a this array to assign values to.
7397 * \param [in] endComp - index of the component before which the components to assign
7399 * \param [in] stepComp - index increment to get index of the next component to assign to.
7400 * \param [in] strictCompoCompare - if \a true (by default), then \a a->getNumberOfComponents()
7401 * must be equal to the number of columns to assign to, else an
7402 * exception is thrown; if \a false, then it is only required that \a
7403 * a->getNbOfElems() equals to number of values to assign to (this condition
7404 * must be respected even if \a strictCompoCompare is \a true). The number of
7405 * values to assign to is given by following Python expression:
7406 * \a nbTargetValues =
7407 * \c len(\c range(\a bgTuples,\a endTuples,\a stepTuples)) *
7408 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
7409 * \throw If \a a is NULL.
7410 * \throw If \a a is not allocated.
7411 * \throw If \a this is not allocated.
7412 * \throw If parameters specifying tuples and components to assign to do not give a
7413 * non-empty range of increasing indices.
7414 * \throw If \a a->getNbOfElems() != \a nbTargetValues.
7415 * \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
7416 * \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
7418 * \ref py_mcdataarrayint_setpartofvalues1 "Here is a Python example".
7420 void DataArrayInt::setPartOfValues1(const DataArrayInt *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare) throw(INTERP_KERNEL::Exception)
7423 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues1 : DataArrayInt pointer in input is NULL !");
7424 const char msg[]="DataArrayInt::setPartOfValues1";
7426 a->checkAllocated();
7427 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
7428 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
7429 int nbComp=getNumberOfComponents();
7430 int nbOfTuples=getNumberOfTuples();
7431 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
7432 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
7433 bool assignTech=true;
7434 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
7436 if(strictCompoCompare)
7437 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
7441 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
7444 int *pt=getPointer()+bgTuples*nbComp+bgComp;
7445 const int *srcPt=a->getConstPointer();
7448 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
7449 for(int j=0;j<newNbOfComp;j++,srcPt++)
7450 pt[j*stepComp]=*srcPt;
7454 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
7456 const int *srcPt2=srcPt;
7457 for(int j=0;j<newNbOfComp;j++,srcPt2++)
7458 pt[j*stepComp]=*srcPt2;
7464 * Assign a given value to values at specified tuples and components of \a this array.
7465 * The tree parameters defining set of indices of tuples and components are similar to
7466 * the tree parameters of the Python function \c range(\c start,\c stop,\c step)..
7467 * \param [in] a - the value to assign.
7468 * \param [in] bgTuples - index of the first tuple of \a this array to assign to.
7469 * \param [in] endTuples - index of the tuple before which the tuples to assign to
7471 * \param [in] stepTuples - index increment to get index of the next tuple to assign to.
7472 * \param [in] bgComp - index of the first component of \a this array to assign to.
7473 * \param [in] endComp - index of the component before which the components to assign
7475 * \param [in] stepComp - index increment to get index of the next component to assign to.
7476 * \throw If \a this is not allocated.
7477 * \throw If parameters specifying tuples and components to assign to, do not give a
7478 * non-empty range of increasing indices or indices are out of a valid range
7481 * \ref py_mcdataarrayint_setpartofvaluessimple1 "Here is a Python example".
7483 void DataArrayInt::setPartOfValuesSimple1(int a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp) throw(INTERP_KERNEL::Exception)
7485 const char msg[]="DataArrayInt::setPartOfValuesSimple1";
7487 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
7488 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
7489 int nbComp=getNumberOfComponents();
7490 int nbOfTuples=getNumberOfTuples();
7491 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
7492 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
7493 int *pt=getPointer()+bgTuples*nbComp+bgComp;
7494 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
7495 for(int j=0;j<newNbOfComp;j++)
7501 * Copy all values from another DataArrayInt (\a a) into specified tuples and
7502 * components of \a this array. Textual data is not copied.
7503 * The tuples and components to assign to are defined by C arrays of indices.
7504 * There are two *modes of usage*:
7505 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
7506 * of \a a is assigned to its own location within \a this array.
7507 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
7508 * components of every specified tuple of \a this array. In this mode it is required
7509 * that \a a->getNumberOfComponents() equals to the number of specified components.
7511 * \param [in] a - the array to copy values from.
7512 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
7513 * assign values of \a a to.
7514 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
7515 * pointer to a tuple index <em>(pi)</em> varies as this:
7516 * \a bgTuples <= \a pi < \a endTuples.
7517 * \param [in] bgComp - pointer to an array of component indices of \a this array to
7518 * assign values of \a a to.
7519 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
7520 * pointer to a component index <em>(pi)</em> varies as this:
7521 * \a bgComp <= \a pi < \a endComp.
7522 * \param [in] strictCompoCompare - this parameter is checked only if the
7523 * *mode of usage* is the first; if it is \a true (default),
7524 * then \a a->getNumberOfComponents() must be equal
7525 * to the number of specified columns, else this is not required.
7526 * \throw If \a a is NULL.
7527 * \throw If \a a is not allocated.
7528 * \throw If \a this is not allocated.
7529 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
7530 * out of a valid range for \a this array.
7531 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
7532 * if <em> a->getNumberOfComponents() != (endComp - bgComp) </em>.
7533 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
7534 * <em> a->getNumberOfComponents() != (endComp - bgComp)</em>.
7536 * \ref py_mcdataarrayint_setpartofvalues2 "Here is a Python example".
7538 void DataArrayInt::setPartOfValues2(const DataArrayInt *a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp, bool strictCompoCompare) throw(INTERP_KERNEL::Exception)
7541 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues2 : DataArrayInt pointer in input is NULL !");
7542 const char msg[]="DataArrayInt::setPartOfValues2";
7544 a->checkAllocated();
7545 int nbComp=getNumberOfComponents();
7546 int nbOfTuples=getNumberOfTuples();
7547 for(const int *z=bgComp;z!=endComp;z++)
7548 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
7549 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
7550 int newNbOfComp=(int)std::distance(bgComp,endComp);
7551 bool assignTech=true;
7552 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
7554 if(strictCompoCompare)
7555 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
7559 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
7562 int *pt=getPointer();
7563 const int *srcPt=a->getConstPointer();
7566 for(const int *w=bgTuples;w!=endTuples;w++)
7568 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
7569 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
7571 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt;
7577 for(const int *w=bgTuples;w!=endTuples;w++)
7579 const int *srcPt2=srcPt;
7580 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
7581 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
7583 pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt2;
7590 * Assign a given value to values at specified tuples and components of \a this array.
7591 * The tuples and components to assign to are defined by C arrays of indices.
7592 * \param [in] a - the value to assign.
7593 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
7595 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
7596 * pointer to a tuple index (\a pi) varies as this:
7597 * \a bgTuples <= \a pi < \a endTuples.
7598 * \param [in] bgComp - pointer to an array of component indices of \a this array to
7600 * \param [in] endComp - specifies the end of the array \a bgTuples, so that
7601 * pointer to a component index (\a pi) varies as this:
7602 * \a bgComp <= \a pi < \a endComp.
7603 * \throw If \a this is not allocated.
7604 * \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
7605 * out of a valid range for \a this array.
7607 * \ref py_mcdataarrayint_setpartofvaluessimple2 "Here is a Python example".
7609 void DataArrayInt::setPartOfValuesSimple2(int a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp) throw(INTERP_KERNEL::Exception)
7612 int nbComp=getNumberOfComponents();
7613 int nbOfTuples=getNumberOfTuples();
7614 for(const int *z=bgComp;z!=endComp;z++)
7615 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
7616 int *pt=getPointer();
7617 for(const int *w=bgTuples;w!=endTuples;w++)
7618 for(const int *z=bgComp;z!=endComp;z++)
7620 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
7621 pt[(std::size_t)(*w)*nbComp+(*z)]=a;
7626 * Copy all values from another DataArrayInt (\a a) into specified tuples and
7627 * components of \a this array. Textual data is not copied.
7628 * The tuples to assign to are defined by a C array of indices.
7629 * The components to assign to are defined by three values similar to parameters of
7630 * the Python function \c range(\c start,\c stop,\c step).
7631 * There are two *modes of usage*:
7632 * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
7633 * of \a a is assigned to its own location within \a this array.
7634 * - If \a a includes one tuple, then all values of \a a are assigned to the specified
7635 * components of every specified tuple of \a this array. In this mode it is required
7636 * that \a a->getNumberOfComponents() equals to the number of specified components.
7638 * \param [in] a - the array to copy values from.
7639 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
7640 * assign values of \a a to.
7641 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
7642 * pointer to a tuple index <em>(pi)</em> varies as this:
7643 * \a bgTuples <= \a pi < \a endTuples.
7644 * \param [in] bgComp - index of the first component of \a this array to assign to.
7645 * \param [in] endComp - index of the component before which the components to assign
7647 * \param [in] stepComp - index increment to get index of the next component to assign to.
7648 * \param [in] strictCompoCompare - this parameter is checked only in the first
7649 * *mode of usage*; if \a strictCompoCompare is \a true (default),
7650 * then \a a->getNumberOfComponents() must be equal
7651 * to the number of specified columns, else this is not required.
7652 * \throw If \a a is NULL.
7653 * \throw If \a a is not allocated.
7654 * \throw If \a this is not allocated.
7655 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
7657 * \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
7658 * if <em> a->getNumberOfComponents()</em> is unequal to the number of components
7659 * defined by <em>(bgComp,endComp,stepComp)</em>.
7660 * \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
7661 * <em> a->getNumberOfComponents()</em> is unequal to the number of components
7662 * defined by <em>(bgComp,endComp,stepComp)</em>.
7663 * \throw If parameters specifying components to assign to, do not give a
7664 * non-empty range of increasing indices or indices are out of a valid range
7667 * \ref py_mcdataarrayint_setpartofvalues3 "Here is a Python example".
7669 void DataArrayInt::setPartOfValues3(const DataArrayInt *a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare) throw(INTERP_KERNEL::Exception)
7672 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues3 : DataArrayInt pointer in input is NULL !");
7673 const char msg[]="DataArrayInt::setPartOfValues3";
7675 a->checkAllocated();
7676 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
7677 int nbComp=getNumberOfComponents();
7678 int nbOfTuples=getNumberOfTuples();
7679 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
7680 int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
7681 bool assignTech=true;
7682 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
7684 if(strictCompoCompare)
7685 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
7689 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
7692 int *pt=getPointer()+bgComp;
7693 const int *srcPt=a->getConstPointer();
7696 for(const int *w=bgTuples;w!=endTuples;w++)
7697 for(int j=0;j<newNbOfComp;j++,srcPt++)
7699 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
7700 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt;
7705 for(const int *w=bgTuples;w!=endTuples;w++)
7707 const int *srcPt2=srcPt;
7708 for(int j=0;j<newNbOfComp;j++,srcPt2++)
7710 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
7711 pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt2;
7718 * Assign a given value to values at specified tuples and components of \a this array.
7719 * The tuples to assign to are defined by a C array of indices.
7720 * The components to assign to are defined by three values similar to parameters of
7721 * the Python function \c range(\c start,\c stop,\c step).
7722 * \param [in] a - the value to assign.
7723 * \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
7725 * \param [in] endTuples - specifies the end of the array \a bgTuples, so that
7726 * pointer to a tuple index <em>(pi)</em> varies as this:
7727 * \a bgTuples <= \a pi < \a endTuples.
7728 * \param [in] bgComp - index of the first component of \a this array to assign to.
7729 * \param [in] endComp - index of the component before which the components to assign
7731 * \param [in] stepComp - index increment to get index of the next component to assign to.
7732 * \throw If \a this is not allocated.
7733 * \throw If any index of tuple given by \a bgTuples is out of a valid range for
7735 * \throw If parameters specifying components to assign to, do not give a
7736 * non-empty range of increasing indices or indices are out of a valid range
7739 * \ref py_mcdataarrayint_setpartofvaluessimple3 "Here is a Python example".
7741 void DataArrayInt::setPartOfValuesSimple3(int a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp) throw(INTERP_KERNEL::Exception)
7743 const char msg[]="DataArrayInt::setPartOfValuesSimple3";
7745 int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
7746 int nbComp=getNumberOfComponents();
7747 int nbOfTuples=getNumberOfTuples();
7748 DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
7749 int *pt=getPointer()+bgComp;
7750 for(const int *w=bgTuples;w!=endTuples;w++)
7751 for(int j=0;j<newNbOfComp;j++)
7753 DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
7754 pt[(std::size_t)(*w)*nbComp+j*stepComp]=a;
7758 void DataArrayInt::setPartOfValues4(const DataArrayInt *a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp, bool strictCompoCompare) throw(INTERP_KERNEL::Exception)
7761 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues4 : input DataArrayInt is NULL !");
7762 const char msg[]="DataArrayInt::setPartOfValues4";
7764 a->checkAllocated();
7765 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
7766 int newNbOfComp=(int)std::distance(bgComp,endComp);
7767 int nbComp=getNumberOfComponents();
7768 for(const int *z=bgComp;z!=endComp;z++)
7769 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
7770 int nbOfTuples=getNumberOfTuples();
7771 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
7772 bool assignTech=true;
7773 if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
7775 if(strictCompoCompare)
7776 a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
7780 a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
7783 const int *srcPt=a->getConstPointer();
7784 int *pt=getPointer()+bgTuples*nbComp;
7787 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
7788 for(const int *z=bgComp;z!=endComp;z++,srcPt++)
7793 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
7795 const int *srcPt2=srcPt;
7796 for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
7802 void DataArrayInt::setPartOfValuesSimple4(int a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp) throw(INTERP_KERNEL::Exception)
7804 const char msg[]="DataArrayInt::setPartOfValuesSimple4";
7806 int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
7807 int nbComp=getNumberOfComponents();
7808 for(const int *z=bgComp;z!=endComp;z++)
7809 DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
7810 int nbOfTuples=getNumberOfTuples();
7811 DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
7812 int *pt=getPointer()+bgTuples*nbComp;
7813 for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
7814 for(const int *z=bgComp;z!=endComp;z++)
7819 * Copy some tuples from another DataArrayInt into specified tuples
7820 * of \a this array. Textual data is not copied. Both arrays must have equal number of
7822 * Both the tuples to assign and the tuples to assign to are defined by a DataArrayInt.
7823 * All components of selected tuples are copied.
7824 * \param [in] a - the array to copy values from.
7825 * \param [in] tuplesSelec - the array specifying both source tuples of \a a and
7826 * target tuples of \a this. \a tuplesSelec has two components, and the
7827 * first component specifies index of the source tuple and the second
7828 * one specifies index of the target tuple.
7829 * \throw If \a this is not allocated.
7830 * \throw If \a a is NULL.
7831 * \throw If \a a is not allocated.
7832 * \throw If \a tuplesSelec is NULL.
7833 * \throw If \a tuplesSelec is not allocated.
7834 * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
7835 * \throw If \a tuplesSelec->getNumberOfComponents() != 2.
7836 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
7837 * the corresponding (\a this or \a a) array.
7839 void DataArrayInt::setPartOfValuesAdv(const DataArrayInt *a, const DataArrayInt *tuplesSelec) throw(INTERP_KERNEL::Exception)
7841 if(!a || !tuplesSelec)
7842 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : DataArrayInt pointer in input is NULL !");
7844 a->checkAllocated();
7845 tuplesSelec->checkAllocated();
7846 int nbOfComp=getNumberOfComponents();
7847 if(nbOfComp!=a->getNumberOfComponents())
7848 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : This and a do not have the same number of components !");
7849 if(tuplesSelec->getNumberOfComponents()!=2)
7850 throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : Expecting to have a tuple selector DataArrayInt instance with exactly 2 components !");
7851 int thisNt=getNumberOfTuples();
7852 int aNt=a->getNumberOfTuples();
7853 int *valsToSet=getPointer();
7854 const int *valsSrc=a->getConstPointer();
7855 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple+=2)
7857 if(tuple[1]>=0 && tuple[1]<aNt)
7859 if(tuple[0]>=0 && tuple[0]<thisNt)
7860 std::copy(valsSrc+nbOfComp*tuple[1],valsSrc+nbOfComp*(tuple[1]+1),valsToSet+nbOfComp*tuple[0]);
7863 std::ostringstream oss; oss << "DataArrayInt::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
7864 oss << " of 'tuplesSelec' request of tuple id #" << tuple[0] << " in 'this' ! It should be in [0," << thisNt << ") !";
7865 throw INTERP_KERNEL::Exception(oss.str().c_str());
7870 std::ostringstream oss; oss << "DataArrayInt::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
7871 oss << " of 'tuplesSelec' request of tuple id #" << tuple[1] << " in 'a' ! It should be in [0," << aNt << ") !";
7872 throw INTERP_KERNEL::Exception(oss.str().c_str());
7878 * Copy some tuples from another DataArrayInt (\a a) into contiguous tuples
7879 * of \a this array. Textual data is not copied. Both arrays must have equal number of
7881 * The tuples to assign to are defined by index of the first tuple, and
7882 * their number is defined by \a tuplesSelec->getNumberOfTuples().
7883 * The tuples to copy are defined by values of a DataArrayInt.
7884 * All components of selected tuples are copied.
7885 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
7887 * \param [in] a - the array to copy values from.
7888 * \param [in] tuplesSelec - the array specifying tuples of \a a to copy.
7889 * \throw If \a this is not allocated.
7890 * \throw If \a a is NULL.
7891 * \throw If \a a is not allocated.
7892 * \throw If \a tuplesSelec is NULL.
7893 * \throw If \a tuplesSelec is not allocated.
7894 * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
7895 * \throw If \a tuplesSelec->getNumberOfComponents() != 1.
7896 * \throw If <em>tupleIdStart + tuplesSelec->getNumberOfTuples() > this->getNumberOfTuples().</em>
7897 * \throw If any tuple index given by \a tuplesSelec is out of a valid range for
7900 void DataArrayInt::setContigPartOfSelectedValues(int tupleIdStart, const DataArray *aBase, const DataArrayInt *tuplesSelec) throw(INTERP_KERNEL::Exception)
7902 if(!aBase || !tuplesSelec)
7903 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : input DataArray is NULL !");
7904 const DataArrayInt *a=dynamic_cast<const DataArrayInt *>(aBase);
7906 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : input DataArray aBase is not a DataArrayInt !");
7908 a->checkAllocated();
7909 tuplesSelec->checkAllocated();
7910 int nbOfComp=getNumberOfComponents();
7911 if(nbOfComp!=a->getNumberOfComponents())
7912 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : This and a do not have the same number of components !");
7913 if(tuplesSelec->getNumberOfComponents()!=1)
7914 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : Expecting to have a tuple selector DataArrayInt instance with exactly 1 component !");
7915 int thisNt=getNumberOfTuples();
7916 int aNt=a->getNumberOfTuples();
7917 int nbOfTupleToWrite=tuplesSelec->getNumberOfTuples();
7918 int *valsToSet=getPointer()+tupleIdStart*nbOfComp;
7919 if(tupleIdStart+nbOfTupleToWrite>thisNt)
7920 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : invalid number range of values to write !");
7921 const int *valsSrc=a->getConstPointer();
7922 for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple++,valsToSet+=nbOfComp)
7924 if(*tuple>=0 && *tuple<aNt)
7926 std::copy(valsSrc+nbOfComp*(*tuple),valsSrc+nbOfComp*(*tuple+1),valsToSet);
7930 std::ostringstream oss; oss << "DataArrayInt::setContigPartOfSelectedValues : Tuple #" << std::distance(tuplesSelec->begin(),tuple);
7931 oss << " of 'tuplesSelec' request of tuple id #" << *tuple << " in 'a' ! It should be in [0," << aNt << ") !";
7932 throw INTERP_KERNEL::Exception(oss.str().c_str());
7938 * Copy some tuples from another DataArrayInt (\a a) into contiguous tuples
7939 * of \a this array. Textual data is not copied. Both arrays must have equal number of
7941 * The tuples to copy are defined by three values similar to parameters of
7942 * the Python function \c range(\c start,\c stop,\c step).
7943 * The tuples to assign to are defined by index of the first tuple, and
7944 * their number is defined by number of tuples to copy.
7945 * All components of selected tuples are copied.
7946 * \param [in] tupleIdStart - index of the first tuple of \a this array to assign
7948 * \param [in] a - the array to copy values from.
7949 * \param [in] bg - index of the first tuple to copy of the array \a a.
7950 * \param [in] end2 - index of the tuple of \a a before which the tuples to copy
7952 * \param [in] step - index increment to get index of the next tuple to copy.
7953 * \throw If \a this is not allocated.
7954 * \throw If \a a is NULL.
7955 * \throw If \a a is not allocated.
7956 * \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
7957 * \throw If <em>tupleIdStart + len(range(bg,end2,step)) > this->getNumberOfTuples().</em>
7958 * \throw If parameters specifying tuples to copy, do not give a
7959 * non-empty range of increasing indices or indices are out of a valid range
7960 * for the array \a a.
7962 void DataArrayInt::setContigPartOfSelectedValues2(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step) throw(INTERP_KERNEL::Exception)
7965 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : input DataArray is NULL !");
7966 const DataArrayInt *a=dynamic_cast<const DataArrayInt *>(aBase);
7968 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : input DataArray aBase is not a DataArrayInt !");
7970 a->checkAllocated();
7971 int nbOfComp=getNumberOfComponents();
7972 const char msg[]="DataArrayInt::setContigPartOfSelectedValues2";
7973 int nbOfTupleToWrite=DataArray::GetNumberOfItemGivenBES(bg,end2,step,msg);
7974 if(nbOfComp!=a->getNumberOfComponents())
7975 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : This and a do not have the same number of components !");
7976 int thisNt=getNumberOfTuples();
7977 int aNt=a->getNumberOfTuples();
7978 int *valsToSet=getPointer()+tupleIdStart*nbOfComp;
7979 if(tupleIdStart+nbOfTupleToWrite>thisNt)
7980 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : invalid number range of values to write !");
7982 throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : invalid range of values to read !");
7983 const int *valsSrc=a->getConstPointer()+bg*nbOfComp;
7984 for(int i=0;i<nbOfTupleToWrite;i++,valsToSet+=nbOfComp,valsSrc+=step*nbOfComp)
7986 std::copy(valsSrc,valsSrc+nbOfComp,valsToSet);
7991 * Returns a value located at specified tuple and component.
7992 * This method is equivalent to DataArrayInt::getIJ() except that validity of
7993 * parameters is checked. So this method is safe but expensive if used to go through
7994 * all values of \a this.
7995 * \param [in] tupleId - index of tuple of interest.
7996 * \param [in] compoId - index of component of interest.
7997 * \return double - value located by \a tupleId and \a compoId.
7998 * \throw If \a this is not allocated.
7999 * \throw If condition <em>( 0 <= tupleId < this->getNumberOfTuples() )</em> is violated.
8000 * \throw If condition <em>( 0 <= compoId < this->getNumberOfComponents() )</em> is violated.
8002 int DataArrayInt::getIJSafe(int tupleId, int compoId) const throw(INTERP_KERNEL::Exception)
8005 if(tupleId<0 || tupleId>=getNumberOfTuples())
8007 std::ostringstream oss; oss << "DataArrayInt::getIJSafe : request for tupleId " << tupleId << " should be in [0," << getNumberOfTuples() << ") !";
8008 throw INTERP_KERNEL::Exception(oss.str().c_str());
8010 if(compoId<0 || compoId>=getNumberOfComponents())
8012 std::ostringstream oss; oss << "DataArrayInt::getIJSafe : request for compoId " << compoId << " should be in [0," << getNumberOfComponents() << ") !";
8013 throw INTERP_KERNEL::Exception(oss.str().c_str());
8015 return _mem[tupleId*_info_on_compo.size()+compoId];
8019 * Returns the first value of \a this.
8020 * \return int - the last value of \a this array.
8021 * \throw If \a this is not allocated.
8022 * \throw If \a this->getNumberOfComponents() != 1.
8023 * \throw If \a this->getNumberOfTuples() < 1.
8025 int DataArrayInt::front() const throw(INTERP_KERNEL::Exception)
8028 if(getNumberOfComponents()!=1)
8029 throw INTERP_KERNEL::Exception("DataArrayInt::front : number of components not equal to one !");
8030 int nbOfTuples=getNumberOfTuples();
8032 throw INTERP_KERNEL::Exception("DataArrayInt::front : number of tuples must be >= 1 !");
8033 return *(getConstPointer());
8037 * Returns the last value of \a this.
8038 * \return int - the last value of \a this array.
8039 * \throw If \a this is not allocated.
8040 * \throw If \a this->getNumberOfComponents() != 1.
8041 * \throw If \a this->getNumberOfTuples() < 1.
8043 int DataArrayInt::back() const throw(INTERP_KERNEL::Exception)
8046 if(getNumberOfComponents()!=1)
8047 throw INTERP_KERNEL::Exception("DataArrayInt::back : number of components not equal to one !");
8048 int nbOfTuples=getNumberOfTuples();
8050 throw INTERP_KERNEL::Exception("DataArrayInt::back : number of tuples must be >= 1 !");
8051 return *(getConstPointer()+nbOfTuples-1);
8055 * Assign pointer to one array to a pointer to another appay. Reference counter of
8056 * \a arrayToSet is incremented / decremented.
8057 * \param [in] newArray - the pointer to array to assign to \a arrayToSet.
8058 * \param [in,out] arrayToSet - the pointer to array to assign to.
8060 void DataArrayInt::SetArrayIn(DataArrayInt *newArray, DataArrayInt* &arrayToSet)
8062 if(newArray!=arrayToSet)
8065 arrayToSet->decrRef();
8066 arrayToSet=newArray;
8068 arrayToSet->incrRef();
8072 DataArrayIntIterator *DataArrayInt::iterator() throw(INTERP_KERNEL::Exception)
8074 return new DataArrayIntIterator(this);
8078 * Creates a new DataArrayInt containing IDs (indices) of tuples holding value equal to a
8080 * \param [in] val - the value to find within \a this.
8081 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8082 * array using decrRef() as it is no more needed.
8083 * \throw If \a this is not allocated.
8084 * \throw If \a this->getNumberOfComponents() != 1.
8086 DataArrayInt *DataArrayInt::getIdsEqual(int val) const throw(INTERP_KERNEL::Exception)
8089 if(getNumberOfComponents()!=1)
8090 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqual : the array must have only one component, you can call 'rearrange' method before !");
8091 const int *cptr=getConstPointer();
8092 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8093 int nbOfTuples=getNumberOfTuples();
8094 for(int i=0;i<nbOfTuples;i++,cptr++)
8096 ret->pushBackSilent(i);
8101 * Creates a new DataArrayInt containing IDs (indices) of tuples holding value \b not
8102 * equal to a given one.
8103 * \param [in] val - the value to ignore within \a this.
8104 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8105 * array using decrRef() as it is no more needed.
8106 * \throw If \a this is not allocated.
8107 * \throw If \a this->getNumberOfComponents() != 1.
8109 DataArrayInt *DataArrayInt::getIdsNotEqual(int val) const throw(INTERP_KERNEL::Exception)
8112 if(getNumberOfComponents()!=1)
8113 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotEqual : the array must have only one component, you can call 'rearrange' method before !");
8114 const int *cptr=getConstPointer();
8115 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8116 int nbOfTuples=getNumberOfTuples();
8117 for(int i=0;i<nbOfTuples;i++,cptr++)
8119 ret->pushBackSilent(i);
8125 * Assigns \a newValue to all elements holding \a oldValue within \a this
8126 * one-dimensional array.
8127 * \param [in] oldValue - the value to replace.
8128 * \param [in] newValue - the value to assign.
8129 * \return int - number of replacements performed.
8130 * \throw If \a this is not allocated.
8131 * \throw If \a this->getNumberOfComponents() != 1.
8133 int DataArrayInt::changeValue(int oldValue, int newValue) throw(INTERP_KERNEL::Exception)
8136 if(getNumberOfComponents()!=1)
8137 throw INTERP_KERNEL::Exception("DataArrayInt::changeValue : the array must have only one component, you can call 'rearrange' method before !");
8138 int *start=getPointer();
8139 int *end2=start+getNbOfElems();
8141 for(int *val=start;val!=end2;val++)
8153 * Creates a new DataArrayInt containing IDs (indices) of tuples holding value equal to
8154 * one of given values.
8155 * \param [in] valsBg - an array of values to find within \a this array.
8156 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
8157 * the last value of \a valsBg is \a valsEnd[ -1 ].
8158 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8159 * array using decrRef() as it is no more needed.
8160 * \throw If \a this->getNumberOfComponents() != 1.
8162 DataArrayInt *DataArrayInt::getIdsEqualList(const int *valsBg, const int *valsEnd) const throw(INTERP_KERNEL::Exception)
8164 if(getNumberOfComponents()!=1)
8165 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqualList : the array must have only one component, you can call 'rearrange' method before !");
8166 std::set<int> vals2(valsBg,valsEnd);
8167 const int *cptr=getConstPointer();
8168 std::vector<int> res;
8169 int nbOfTuples=getNumberOfTuples();
8170 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8171 for(int i=0;i<nbOfTuples;i++,cptr++)
8172 if(vals2.find(*cptr)!=vals2.end())
8173 ret->pushBackSilent(i);
8178 * Creates a new DataArrayInt containing IDs (indices) of tuples holding values \b not
8179 * equal to any of given values.
8180 * \param [in] valsBg - an array of values to ignore within \a this array.
8181 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
8182 * the last value of \a valsBg is \a valsEnd[ -1 ].
8183 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8184 * array using decrRef() as it is no more needed.
8185 * \throw If \a this->getNumberOfComponents() != 1.
8187 DataArrayInt *DataArrayInt::getIdsNotEqualList(const int *valsBg, const int *valsEnd) const throw(INTERP_KERNEL::Exception)
8189 if(getNumberOfComponents()!=1)
8190 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotEqualList : the array must have only one component, you can call 'rearrange' method before !");
8191 std::set<int> vals2(valsBg,valsEnd);
8192 const int *cptr=getConstPointer();
8193 std::vector<int> res;
8194 int nbOfTuples=getNumberOfTuples();
8195 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8196 for(int i=0;i<nbOfTuples;i++,cptr++)
8197 if(vals2.find(*cptr)==vals2.end())
8198 ret->pushBackSilent(i);
8203 * This method is an extension of DataArrayInt::locateValue method because this method works for DataArrayInt with
8204 * any number of components excepted 0 (an INTERP_KERNEL::Exception is thrown in this case).
8205 * This method searches in \b this is there is a tuple that matched the input parameter \b tupl.
8206 * If any the tuple id is returned. If not -1 is returned.
8208 * This method throws an INTERP_KERNEL::Exception if the number of components in \b this mismatches with the size of
8209 * the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
8211 * \return tuple id where \b tupl is. -1 if no such tuple exists in \b this.
8212 * \sa DataArrayInt::search, DataArrayInt::presenceOfTuple.
8214 int DataArrayInt::locateTuple(const std::vector<int>& tupl) const throw(INTERP_KERNEL::Exception)
8217 int nbOfCompo=getNumberOfComponents();
8219 throw INTERP_KERNEL::Exception("DataArrayInt::locateTuple : 0 components in 'this' !");
8220 if(nbOfCompo!=(int)tupl.size())
8222 std::ostringstream oss; oss << "DataArrayInt::locateTuple : 'this' contains " << nbOfCompo << " components and searching for a tuple of length " << tupl.size() << " !";
8223 throw INTERP_KERNEL::Exception(oss.str().c_str());
8225 const int *cptr=getConstPointer();
8226 std::size_t nbOfVals=getNbOfElems();
8227 for(const int *work=cptr;work!=cptr+nbOfVals;)
8229 work=std::search(work,cptr+nbOfVals,tupl.begin(),tupl.end());
8230 if(work!=cptr+nbOfVals)
8232 if(std::distance(cptr,work)%nbOfCompo!=0)
8235 return std::distance(cptr,work)/nbOfCompo;
8242 * This method searches the sequence specified in input parameter \b vals in \b this.
8243 * This works only for DataArrayInt having number of components equal to one (if not an INTERP_KERNEL::Exception will be thrown).
8244 * This method differs from DataArrayInt::locateTuple in that the position is internal raw data is not considered here contrary to DataArrayInt::locateTuple.
8245 * \sa DataArrayInt::locateTuple
8247 int DataArrayInt::search(const std::vector<int>& vals) const throw(INTERP_KERNEL::Exception)
8250 int nbOfCompo=getNumberOfComponents();
8252 throw INTERP_KERNEL::Exception("DataArrayInt::search : works only for DataArrayInt instance with one component !");
8253 const int *cptr=getConstPointer();
8254 std::size_t nbOfVals=getNbOfElems();
8255 const int *loc=std::search(cptr,cptr+nbOfVals,vals.begin(),vals.end());
8256 if(loc!=cptr+nbOfVals)
8257 return std::distance(cptr,loc);
8262 * This method expects to be called when number of components of this is equal to one.
8263 * This method returns the tuple id, if it exists, of the first tuple equal to \b value.
8264 * If not any tuple contains \b value -1 is returned.
8265 * \sa DataArrayInt::presenceOfValue
8267 int DataArrayInt::locateValue(int value) const throw(INTERP_KERNEL::Exception)
8270 if(getNumberOfComponents()!=1)
8271 throw INTERP_KERNEL::Exception("DataArrayInt::presenceOfValue : the array must have only one component, you can call 'rearrange' method before !");
8272 const int *cptr=getConstPointer();
8273 int nbOfTuples=getNumberOfTuples();
8274 const int *ret=std::find(cptr,cptr+nbOfTuples,value);
8275 if(ret!=cptr+nbOfTuples)
8276 return std::distance(cptr,ret);
8281 * This method expects to be called when number of components of this is equal to one.
8282 * This method returns the tuple id, if it exists, of the first tuple so that the value is contained in \b vals.
8283 * If not any tuple contains one of the values contained in 'vals' false is returned.
8284 * \sa DataArrayInt::presenceOfValue
8286 int DataArrayInt::locateValue(const std::vector<int>& vals) const throw(INTERP_KERNEL::Exception)
8289 if(getNumberOfComponents()!=1)
8290 throw INTERP_KERNEL::Exception("DataArrayInt::presenceOfValue : the array must have only one component, you can call 'rearrange' method before !");
8291 std::set<int> vals2(vals.begin(),vals.end());
8292 const int *cptr=getConstPointer();
8293 int nbOfTuples=getNumberOfTuples();
8294 for(const int *w=cptr;w!=cptr+nbOfTuples;w++)
8295 if(vals2.find(*w)!=vals2.end())
8296 return std::distance(cptr,w);
8301 * This method returns the number of values in \a this that are equals to input parameter \a value.
8302 * This method only works for single component array.
8304 * \return a value in [ 0, \c this->getNumberOfTuples() )
8306 * \throw If \a this is not allocated
8309 int DataArrayInt::count(int value) const throw(INTERP_KERNEL::Exception)
8313 if(getNumberOfComponents()!=1)
8314 throw INTERP_KERNEL::Exception("DataArrayInt::count : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
8315 const int *vals=begin();
8316 int nbOfTuples=getNumberOfTuples();
8317 for(int i=0;i<nbOfTuples;i++,vals++)
8324 * This method is an extension of DataArrayInt::presenceOfValue method because this method works for DataArrayInt with
8325 * any number of components excepted 0 (an INTERP_KERNEL::Exception is thrown in this case).
8326 * This method searches in \b this is there is a tuple that matched the input parameter \b tupl.
8327 * This method throws an INTERP_KERNEL::Exception if the number of components in \b this mismatches with the size of
8328 * the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
8329 * \sa DataArrayInt::locateTuple
8331 bool DataArrayInt::presenceOfTuple(const std::vector<int>& tupl) const throw(INTERP_KERNEL::Exception)
8333 return locateTuple(tupl)!=-1;
8338 * Returns \a true if a given value is present within \a this one-dimensional array.
8339 * \param [in] value - the value to find within \a this array.
8340 * \return bool - \a true in case if \a value is present within \a this array.
8341 * \throw If \a this is not allocated.
8342 * \throw If \a this->getNumberOfComponents() != 1.
8345 bool DataArrayInt::presenceOfValue(int value) const throw(INTERP_KERNEL::Exception)
8347 return locateValue(value)!=-1;
8351 * This method expects to be called when number of components of this is equal to one.
8352 * This method returns true if it exists a tuple so that the value is contained in \b vals.
8353 * If not any tuple contains one of the values contained in 'vals' false is returned.
8354 * \sa DataArrayInt::locateValue
8356 bool DataArrayInt::presenceOfValue(const std::vector<int>& vals) const throw(INTERP_KERNEL::Exception)
8358 return locateValue(vals)!=-1;
8362 * Accumulates values of each component of \a this array.
8363 * \param [out] res - an array of length \a this->getNumberOfComponents(), allocated
8364 * by the caller, that is filled by this method with sum value for each
8366 * \throw If \a this is not allocated.
8368 void DataArrayInt::accumulate(int *res) const throw(INTERP_KERNEL::Exception)
8371 const int *ptr=getConstPointer();
8372 int nbTuple=getNumberOfTuples();
8373 int nbComps=getNumberOfComponents();
8374 std::fill(res,res+nbComps,0);
8375 for(int i=0;i<nbTuple;i++)
8376 std::transform(ptr+i*nbComps,ptr+(i+1)*nbComps,res,res,std::plus<int>());
8379 int DataArrayInt::accumulate(int compId) const throw(INTERP_KERNEL::Exception)
8382 const int *ptr=getConstPointer();
8383 int nbTuple=getNumberOfTuples();
8384 int nbComps=getNumberOfComponents();
8385 if(compId<0 || compId>=nbComps)
8386 throw INTERP_KERNEL::Exception("DataArrayInt::accumulate : Invalid compId specified : No such nb of components !");
8388 for(int i=0;i<nbTuple;i++)
8389 ret+=ptr[i*nbComps+compId];
8394 * This method accumulate using addition tuples in \a this using input index array [ \a bgOfIndex, \a endOfIndex ).
8395 * The returned array will have same number of components than \a this and number of tuples equal to
8396 * \c std::distance(bgOfIndex,endOfIndex) \b minus \b one.
8398 * The input index array is expected to be ascendingly sorted in which the all referenced ids should be in [0, \c this->getNumberOfTuples).
8400 * \param [in] bgOfIndex - begin (included) of the input index array.
8401 * \param [in] endOfIndex - end (excluded) of the input index array.
8402 * \return DataArrayInt * - the new instance having the same number of components than \a this.
8404 * \throw If bgOfIndex or end is NULL.
8405 * \throw If input index array is not ascendingly sorted.
8406 * \throw If there is an id in [ \a bgOfIndex, \a endOfIndex ) not in [0, \c this->getNumberOfTuples).
8407 * \throw If std::distance(bgOfIndex,endOfIndex)==0.
8409 DataArrayInt *DataArrayInt::accumulatePerChunck(const int *bgOfIndex, const int *endOfIndex) const throw(INTERP_KERNEL::Exception)
8411 if(!bgOfIndex || !endOfIndex)
8412 throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : input pointer NULL !");
8414 int nbCompo=getNumberOfComponents();
8415 int nbOfTuples=getNumberOfTuples();
8416 int sz=(int)std::distance(bgOfIndex,endOfIndex);
8418 throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : invalid size of input index array !");
8420 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(sz,nbCompo);
8421 const int *w=bgOfIndex;
8422 if(*w<0 || *w>=nbOfTuples)
8423 throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : The first element of the input index not in [0,nbOfTuples) !");
8424 const int *srcPt=begin()+(*w)*nbCompo;
8425 int *tmp=ret->getPointer();
8426 for(int i=0;i<sz;i++,tmp+=nbCompo,w++)
8428 std::fill(tmp,tmp+nbCompo,0.);
8431 for(int j=w[0];j<w[1];j++,srcPt+=nbCompo)
8433 if(j>=0 && j<nbOfTuples)
8434 std::transform(srcPt,srcPt+nbCompo,tmp,tmp,std::plus<int>());
8437 std::ostringstream oss; oss << "DataArrayInt::accumulatePerChunck : At rank #" << i << " the input index array points to id " << j << " should be in [0," << nbOfTuples << ") !";
8438 throw INTERP_KERNEL::Exception(oss.str().c_str());
8444 std::ostringstream oss; oss << "DataArrayInt::accumulatePerChunck : At rank #" << i << " the input index array is not in ascendingly sorted.";
8445 throw INTERP_KERNEL::Exception(oss.str().c_str());
8448 ret->copyStringInfoFrom(*this);
8453 * Returns a new DataArrayInt by concatenating two given arrays, so that (1) the number
8454 * of tuples in the result array is <em> a1->getNumberOfTuples() + a2->getNumberOfTuples() -
8455 * offsetA2</em> and (2)
8456 * the number of component in the result array is same as that of each of given arrays.
8457 * First \a offsetA2 tuples of \a a2 are skipped and thus are missing from the result array.
8458 * Info on components is copied from the first of the given arrays. Number of components
8459 * in the given arrays must be the same.
8460 * \param [in] a1 - an array to include in the result array.
8461 * \param [in] a2 - another array to include in the result array.
8462 * \param [in] offsetA2 - number of tuples of \a a2 to skip.
8463 * \return DataArrayInt * - the new instance of DataArrayInt.
8464 * The caller is to delete this result array using decrRef() as it is no more
8466 * \throw If either \a a1 or \a a2 is NULL.
8467 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents().
8469 DataArrayInt *DataArrayInt::Aggregate(const DataArrayInt *a1, const DataArrayInt *a2, int offsetA2)
8472 throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : input DataArrayInt instance is NULL !");
8473 int nbOfComp=a1->getNumberOfComponents();
8474 if(nbOfComp!=a2->getNumberOfComponents())
8475 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Aggregation !");
8476 int nbOfTuple1=a1->getNumberOfTuples();
8477 int nbOfTuple2=a2->getNumberOfTuples();
8478 DataArrayInt *ret=DataArrayInt::New();
8479 ret->alloc(nbOfTuple1+nbOfTuple2-offsetA2,nbOfComp);
8480 int *pt=std::copy(a1->getConstPointer(),a1->getConstPointer()+nbOfTuple1*nbOfComp,ret->getPointer());
8481 std::copy(a2->getConstPointer()+offsetA2*nbOfComp,a2->getConstPointer()+nbOfTuple2*nbOfComp,pt);
8482 ret->copyStringInfoFrom(*a1);
8487 * Returns a new DataArrayInt by concatenating all given arrays, so that (1) the number
8488 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
8489 * the number of component in the result array is same as that of each of given arrays.
8490 * Info on components is copied from the first of the given arrays. Number of components
8491 * in the given arrays must be the same.
8492 * \param [in] arr - a sequence of arrays to include in the result array.
8493 * \return DataArrayInt * - the new instance of DataArrayInt.
8494 * The caller is to delete this result array using decrRef() as it is no more
8496 * \throw If all arrays within \a arr are NULL.
8497 * \throw If getNumberOfComponents() of arrays within \a arr.
8499 DataArrayInt *DataArrayInt::Aggregate(const std::vector<const DataArrayInt *>& arr) throw(INTERP_KERNEL::Exception)
8501 std::vector<const DataArrayInt *> a;
8502 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
8506 throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : input list must be NON EMPTY !");
8507 std::vector<const DataArrayInt *>::const_iterator it=a.begin();
8508 int nbOfComp=(*it)->getNumberOfComponents();
8509 int nbt=(*it++)->getNumberOfTuples();
8510 for(int i=1;it!=a.end();it++,i++)
8512 if((*it)->getNumberOfComponents()!=nbOfComp)
8513 throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : Nb of components mismatch for array aggregation !");
8514 nbt+=(*it)->getNumberOfTuples();
8516 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
8517 ret->alloc(nbt,nbOfComp);
8518 int *pt=ret->getPointer();
8519 for(it=a.begin();it!=a.end();it++)
8520 pt=std::copy((*it)->getConstPointer(),(*it)->getConstPointer()+(*it)->getNbOfElems(),pt);
8521 ret->copyStringInfoFrom(*(a[0]));
8526 * This method takes as input a list of DataArrayInt instances \a arrs that represent each a packed index arrays.
8527 * A packed index array is an allocated array with one component, and at least one tuple. The first element
8528 * of each array in \a arrs must be 0. Each array in \a arrs is expected to be increasingly monotonic.
8529 * 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.
8531 * \return DataArrayInt * - a new object to be managed by the caller.
8533 DataArrayInt *DataArrayInt::AggregateIndexes(const std::vector<const DataArrayInt *>& arrs) throw(INTERP_KERNEL::Exception)
8536 for(std::vector<const DataArrayInt *>::const_iterator it4=arrs.begin();it4!=arrs.end();it4++)
8540 (*it4)->checkAllocated();
8541 if((*it4)->getNumberOfComponents()!=1)
8543 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with nb of compo != 1 at pos " << std::distance(arrs.begin(),it4) << " !";
8544 throw INTERP_KERNEL::Exception(oss.str().c_str());
8546 int nbTupl=(*it4)->getNumberOfTuples();
8549 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with nb of tuples < 1 at pos " << std::distance(arrs.begin(),it4) << " !";
8550 throw INTERP_KERNEL::Exception(oss.str().c_str());
8552 if((*it4)->front()!=0)
8554 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with front value != 0 at pos " << std::distance(arrs.begin(),it4) << " !";
8555 throw INTERP_KERNEL::Exception(oss.str().c_str());
8561 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a null instance at pos " << std::distance(arrs.begin(),it4) << " !";
8562 throw INTERP_KERNEL::Exception(oss.str().c_str());
8566 throw INTERP_KERNEL::Exception("DataArrayInt::AggregateIndexes : input list must be NON EMPTY !");
8567 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
8568 ret->alloc(retSz,1);
8569 int *pt=ret->getPointer(); *pt++=0;
8570 for(std::vector<const DataArrayInt *>::const_iterator it=arrs.begin();it!=arrs.end();it++)
8571 pt=std::transform((*it)->begin()+1,(*it)->end(),pt,std::bind2nd(std::plus<int>(),pt[-1]));
8572 ret->copyStringInfoFrom(*(arrs[0]));
8577 * Returns the maximal value and its location within \a this one-dimensional array.
8578 * \param [out] tupleId - index of the tuple holding the maximal value.
8579 * \return int - the maximal value among all values of \a this array.
8580 * \throw If \a this->getNumberOfComponents() != 1
8581 * \throw If \a this->getNumberOfTuples() < 1
8583 int DataArrayInt::getMaxValue(int& tupleId) const throw(INTERP_KERNEL::Exception)
8586 if(getNumberOfComponents()!=1)
8587 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : must be applied on DataArrayInt with only one component !");
8588 int nbOfTuples=getNumberOfTuples();
8590 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : array exists but number of tuples must be > 0 !");
8591 const int *vals=getConstPointer();
8592 const int *loc=std::max_element(vals,vals+nbOfTuples);
8593 tupleId=(int)std::distance(vals,loc);
8598 * Returns the maximal value within \a this array that is allowed to have more than
8600 * \return int - the maximal value among all values of \a this array.
8601 * \throw If \a this is not allocated.
8603 int DataArrayInt::getMaxValueInArray() const throw(INTERP_KERNEL::Exception)
8606 const int *loc=std::max_element(begin(),end());
8611 * Returns the minimal value and its location within \a this one-dimensional array.
8612 * \param [out] tupleId - index of the tuple holding the minimal value.
8613 * \return int - the minimal value among all values of \a this array.
8614 * \throw If \a this->getNumberOfComponents() != 1
8615 * \throw If \a this->getNumberOfTuples() < 1
8617 int DataArrayInt::getMinValue(int& tupleId) const throw(INTERP_KERNEL::Exception)
8620 if(getNumberOfComponents()!=1)
8621 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : must be applied on DataArrayInt with only one component !");
8622 int nbOfTuples=getNumberOfTuples();
8624 throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : array exists but number of tuples must be > 0 !");
8625 const int *vals=getConstPointer();
8626 const int *loc=std::min_element(vals,vals+nbOfTuples);
8627 tupleId=(int)std::distance(vals,loc);
8632 * Returns the minimal value within \a this array that is allowed to have more than
8634 * \return int - the minimal value among all values of \a this array.
8635 * \throw If \a this is not allocated.
8637 int DataArrayInt::getMinValueInArray() const throw(INTERP_KERNEL::Exception)
8640 const int *loc=std::min_element(begin(),end());
8645 * Converts every value of \a this array to its absolute value.
8646 * \throw If \a this is not allocated.
8648 void DataArrayInt::abs() throw(INTERP_KERNEL::Exception)
8651 int *ptr=getPointer();
8652 std::size_t nbOfElems=getNbOfElems();
8653 std::transform(ptr,ptr+nbOfElems,ptr,std::ptr_fun<int,int>(std::abs));
8658 * Apply a liner function to a given component of \a this array, so that
8659 * an array element <em>(x)</em> becomes \f$ a * x + b \f$.
8660 * \param [in] a - the first coefficient of the function.
8661 * \param [in] b - the second coefficient of the function.
8662 * \param [in] compoId - the index of component to modify.
8663 * \throw If \a this is not allocated.
8665 void DataArrayInt::applyLin(int a, int b, int compoId) throw(INTERP_KERNEL::Exception)
8668 int *ptr=getPointer()+compoId;
8669 int nbOfComp=getNumberOfComponents();
8670 int nbOfTuple=getNumberOfTuples();
8671 for(int i=0;i<nbOfTuple;i++,ptr+=nbOfComp)
8677 * Apply a liner function to all elements of \a this array, so that
8678 * an element _x_ becomes \f$ a * x + b \f$.
8679 * \param [in] a - the first coefficient of the function.
8680 * \param [in] b - the second coefficient of the function.
8681 * \throw If \a this is not allocated.
8683 void DataArrayInt::applyLin(int a, int b) throw(INTERP_KERNEL::Exception)
8686 int *ptr=getPointer();
8687 std::size_t nbOfElems=getNbOfElems();
8688 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
8694 * Returns a full copy of \a this array except that sign of all elements is reversed.
8695 * \return DataArrayInt * - the new instance of DataArrayInt containing the
8696 * same number of tuples and component as \a this array.
8697 * The caller is to delete this result array using decrRef() as it is no more
8699 * \throw If \a this is not allocated.
8701 DataArrayInt *DataArrayInt::negate() const throw(INTERP_KERNEL::Exception)
8704 DataArrayInt *newArr=DataArrayInt::New();
8705 int nbOfTuples=getNumberOfTuples();
8706 int nbOfComp=getNumberOfComponents();
8707 newArr->alloc(nbOfTuples,nbOfComp);
8708 const int *cptr=getConstPointer();
8709 std::transform(cptr,cptr+nbOfTuples*nbOfComp,newArr->getPointer(),std::negate<int>());
8710 newArr->copyStringInfoFrom(*this);
8715 * Modify all elements of \a this array, so that
8716 * an element _x_ becomes \f$ numerator / x \f$.
8717 * \warning If an exception is thrown because of presence of 0 element in \a this
8718 * array, all elements processed before detection of the zero element remain
8720 * \param [in] numerator - the numerator used to modify array elements.
8721 * \throw If \a this is not allocated.
8722 * \throw If there is an element equal to 0 in \a this array.
8724 void DataArrayInt::applyInv(int numerator) throw(INTERP_KERNEL::Exception)
8727 int *ptr=getPointer();
8728 std::size_t nbOfElems=getNbOfElems();
8729 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
8733 *ptr=numerator/(*ptr);
8737 std::ostringstream oss; oss << "DataArrayInt::applyInv : presence of null value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
8739 throw INTERP_KERNEL::Exception(oss.str().c_str());
8746 * Modify all elements of \a this array, so that
8747 * an element _x_ becomes \f$ x / val \f$.
8748 * \param [in] val - the denominator used to modify array elements.
8749 * \throw If \a this is not allocated.
8750 * \throw If \a val == 0.
8752 void DataArrayInt::applyDivideBy(int val) throw(INTERP_KERNEL::Exception)
8755 throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to divide by 0 !");
8757 int *ptr=getPointer();
8758 std::size_t nbOfElems=getNbOfElems();
8759 std::transform(ptr,ptr+nbOfElems,ptr,std::bind2nd(std::divides<int>(),val));
8764 * Modify all elements of \a this array, so that
8765 * an element _x_ becomes <em> x % val </em>.
8766 * \param [in] val - the divisor used to modify array elements.
8767 * \throw If \a this is not allocated.
8768 * \throw If \a val <= 0.
8770 void DataArrayInt::applyModulus(int val) throw(INTERP_KERNEL::Exception)
8773 throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to operate modulus on value <= 0 !");
8775 int *ptr=getPointer();
8776 std::size_t nbOfElems=getNbOfElems();
8777 std::transform(ptr,ptr+nbOfElems,ptr,std::bind2nd(std::modulus<int>(),val));
8782 * This method works only on data array with one component.
8783 * This method returns a newly allocated array storing stored ascendantly tuple ids in \b this so that
8784 * this[*id] in [\b vmin,\b vmax)
8786 * \param [in] vmin begin of range. This value is included in range (included).
8787 * \param [in] vmax end of range. This value is \b not included in range (excluded).
8788 * \return a newly allocated data array that the caller should deal with.
8790 DataArrayInt *DataArrayInt::getIdsInRange(int vmin, int vmax) const throw(INTERP_KERNEL::Exception)
8793 if(getNumberOfComponents()!=1)
8794 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsInRange : this must have exactly one component !");
8795 const int *cptr=getConstPointer();
8796 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(0,1);
8797 int nbOfTuples=getNumberOfTuples();
8798 for(int i=0;i<nbOfTuples;i++,cptr++)
8799 if(*cptr>=vmin && *cptr<vmax)
8800 ret->pushBackSilent(i);
8805 * This method works only on data array with one component.
8806 * 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.
8808 * \param [in] vmin begin of range. This value is included in range (included).
8809 * \param [in] vmax end of range. This value is \b not included in range (excluded).
8810 * \return if all ids in \a this are so that (*this)[i]==i for all i in [ 0, \c this->getNumberOfTuples() ).
8812 bool DataArrayInt::checkAllIdsInRange(int vmin, int vmax) const throw(INTERP_KERNEL::Exception)
8815 if(getNumberOfComponents()!=1)
8816 throw INTERP_KERNEL::Exception("DataArrayInt::checkAllIdsInRange : this must have exactly one component !");
8817 int nbOfTuples=getNumberOfTuples();
8819 const int *cptr=getConstPointer();
8820 for(int i=0;i<nbOfTuples;i++,cptr++)
8822 if(*cptr>=vmin && *cptr<vmax)
8823 { ret=ret && *cptr==i; }
8826 std::ostringstream oss; oss << "DataArrayInt::checkAllIdsInRange : tuple #" << i << " has value " << *cptr << " should be in [" << vmin << "," << vmax << ") !";
8827 throw INTERP_KERNEL::Exception(oss.str().c_str());
8834 * Modify all elements of \a this array, so that
8835 * an element _x_ becomes <em> val % x </em>.
8836 * \warning If an exception is thrown because of presence of an element <= 0 in \a this
8837 * array, all elements processed before detection of the zero element remain
8839 * \param [in] val - the divident used to modify array elements.
8840 * \throw If \a this is not allocated.
8841 * \throw If there is an element equal to or less than 0 in \a this array.
8843 void DataArrayInt::applyRModulus(int val) throw(INTERP_KERNEL::Exception)
8846 int *ptr=getPointer();
8847 std::size_t nbOfElems=getNbOfElems();
8848 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
8856 std::ostringstream oss; oss << "DataArrayInt::applyRModulus : presence of value <=0 in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
8858 throw INTERP_KERNEL::Exception(oss.str().c_str());
8865 * Modify all elements of \a this array, so that
8866 * an element _x_ becomes <em> val ^ x </em>.
8867 * \param [in] val - the value used to apply pow on all array elements.
8868 * \throw If \a this is not allocated.
8869 * \throw If \a val < 0.
8871 void DataArrayInt::applyPow(int val) throw(INTERP_KERNEL::Exception)
8875 throw INTERP_KERNEL::Exception("DataArrayInt::applyPow : input pow in < 0 !");
8876 int *ptr=getPointer();
8877 std::size_t nbOfElems=getNbOfElems();
8880 std::fill(ptr,ptr+nbOfElems,1.);
8883 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
8886 for(int j=0;j<val;j++)
8894 * Modify all elements of \a this array, so that
8895 * an element _x_ becomes \f$ val ^ x \f$.
8896 * \param [in] val - the value used to apply pow on all array elements.
8897 * \throw If \a this is not allocated.
8898 * \throw If there is an element < 0 in \a this array.
8899 * \warning If an exception is thrown because of presence of 0 element in \a this
8900 * array, all elements processed before detection of the zero element remain
8903 void DataArrayInt::applyRPow(int val) throw(INTERP_KERNEL::Exception)
8906 int *ptr=getPointer();
8907 std::size_t nbOfElems=getNbOfElems();
8908 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
8913 for(int j=0;j<*ptr;j++)
8919 std::ostringstream oss; oss << "DataArrayInt::applyRPow : presence of negative value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
8921 throw INTERP_KERNEL::Exception(oss.str().c_str());
8928 * Returns a new DataArrayInt by aggregating two given arrays, so that (1) the number
8929 * of components in the result array is a sum of the number of components of given arrays
8930 * and (2) the number of tuples in the result array is same as that of each of given
8931 * arrays. In other words the i-th tuple of result array includes all components of
8932 * i-th tuples of all given arrays.
8933 * Number of tuples in the given arrays must be the same.
8934 * \param [in] a1 - an array to include in the result array.
8935 * \param [in] a2 - another array to include in the result array.
8936 * \return DataArrayInt * - the new instance of DataArrayInt.
8937 * The caller is to delete this result array using decrRef() as it is no more
8939 * \throw If both \a a1 and \a a2 are NULL.
8940 * \throw If any given array is not allocated.
8941 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
8943 DataArrayInt *DataArrayInt::Meld(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception)
8945 std::vector<const DataArrayInt *> arr(2);
8946 arr[0]=a1; arr[1]=a2;
8951 * Returns a new DataArrayInt by aggregating all given arrays, so that (1) the number
8952 * of components in the result array is a sum of the number of components of given arrays
8953 * and (2) the number of tuples in the result array is same as that of each of given
8954 * arrays. In other words the i-th tuple of result array includes all components of
8955 * i-th tuples of all given arrays.
8956 * Number of tuples in the given arrays must be the same.
8957 * \param [in] arr - a sequence of arrays to include in the result array.
8958 * \return DataArrayInt * - the new instance of DataArrayInt.
8959 * The caller is to delete this result array using decrRef() as it is no more
8961 * \throw If all arrays within \a arr are NULL.
8962 * \throw If any given array is not allocated.
8963 * \throw If getNumberOfTuples() of arrays within \a arr is different.
8965 DataArrayInt *DataArrayInt::Meld(const std::vector<const DataArrayInt *>& arr) throw(INTERP_KERNEL::Exception)
8967 std::vector<const DataArrayInt *> a;
8968 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
8972 throw INTERP_KERNEL::Exception("DataArrayInt::Meld : array must be NON empty !");
8973 std::vector<const DataArrayInt *>::const_iterator it;
8974 for(it=a.begin();it!=a.end();it++)
8975 (*it)->checkAllocated();
8977 int nbOfTuples=(*it)->getNumberOfTuples();
8978 std::vector<int> nbc(a.size());
8979 std::vector<const int *> pts(a.size());
8980 nbc[0]=(*it)->getNumberOfComponents();
8981 pts[0]=(*it++)->getConstPointer();
8982 for(int i=1;it!=a.end();it++,i++)
8984 if(nbOfTuples!=(*it)->getNumberOfTuples())
8985 throw INTERP_KERNEL::Exception("DataArrayInt::meld : mismatch of number of tuples !");
8986 nbc[i]=(*it)->getNumberOfComponents();
8987 pts[i]=(*it)->getConstPointer();
8989 int totalNbOfComp=std::accumulate(nbc.begin(),nbc.end(),0);
8990 DataArrayInt *ret=DataArrayInt::New();
8991 ret->alloc(nbOfTuples,totalNbOfComp);
8992 int *retPtr=ret->getPointer();
8993 for(int i=0;i<nbOfTuples;i++)
8994 for(int j=0;j<(int)a.size();j++)
8996 retPtr=std::copy(pts[j],pts[j]+nbc[j],retPtr);
9000 for(int i=0;i<(int)a.size();i++)
9001 for(int j=0;j<nbc[i];j++,k++)
9002 ret->setInfoOnComponent(k,a[i]->getInfoOnComponent(j).c_str());
9007 * Returns a new DataArrayInt which is a minimal partition of elements of \a groups.
9008 * The i-th item of the result array is an ID of a set of elements belonging to a
9009 * unique set of groups, which the i-th element is a part of. This set of elements
9010 * belonging to a unique set of groups is called \a family, so the result array contains
9011 * IDs of families each element belongs to.
9013 * \b Example: if we have two groups of elements: \a group1 [0,4] and \a group2 [ 0,1,2 ],
9014 * then there are 3 families:
9015 * - \a family1 (with ID 1) contains element [0] belonging to ( \a group1 + \a group2 ),
9016 * - \a family2 (with ID 2) contains elements [4] belonging to ( \a group1 ),
9017 * - \a family3 (with ID 3) contains element [1,2] belonging to ( \a group2 ), <br>
9018 * and the result array contains IDs of families [ 1,3,3,0,2 ]. <br> Note a family ID 0 which
9019 * stands for the element #3 which is in none of groups.
9021 * \param [in] groups - sequence of groups of element IDs.
9022 * \param [in] newNb - total number of elements; it must be more than max ID of element
9024 * \param [out] fidsOfGroups - IDs of families the elements of each group belong to.
9025 * \return DataArrayInt * - a new instance of DataArrayInt containing IDs of families
9026 * each element with ID from range [0, \a newNb ) belongs to. The caller is to
9027 * delete this array using decrRef() as it is no more needed.
9028 * \throw If any element ID in \a groups violates condition ( 0 <= ID < \a newNb ).
9030 DataArrayInt *DataArrayInt::MakePartition(const std::vector<const DataArrayInt *>& groups, int newNb, std::vector< std::vector<int> >& fidsOfGroups) throw(INTERP_KERNEL::Exception)
9032 std::vector<const DataArrayInt *> groups2;
9033 for(std::vector<const DataArrayInt *>::const_iterator it4=groups.begin();it4!=groups.end();it4++)
9035 groups2.push_back(*it4);
9036 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9037 ret->alloc(newNb,1);
9038 int *retPtr=ret->getPointer();
9039 std::fill(retPtr,retPtr+newNb,0);
9041 for(std::vector<const DataArrayInt *>::const_iterator iter=groups2.begin();iter!=groups2.end();iter++)
9043 const int *ptr=(*iter)->getConstPointer();
9044 std::size_t nbOfElem=(*iter)->getNbOfElems();
9046 for(int j=0;j<sfid;j++)
9049 for(std::size_t i=0;i<nbOfElem;i++)
9051 if(ptr[i]>=0 && ptr[i]<newNb)
9053 if(retPtr[ptr[i]]==j)
9061 std::ostringstream oss; oss << "DataArrayInt::MakePartition : In group \"" << (*iter)->getName() << "\" in tuple #" << i << " value = " << ptr[i] << " ! Should be in [0," << newNb;
9063 throw INTERP_KERNEL::Exception(oss.str().c_str());
9070 fidsOfGroups.clear();
9071 fidsOfGroups.resize(groups2.size());
9073 for(std::vector<const DataArrayInt *>::const_iterator iter=groups2.begin();iter!=groups2.end();iter++,grId++)
9076 const int *ptr=(*iter)->getConstPointer();
9077 std::size_t nbOfElem=(*iter)->getNbOfElems();
9078 for(const int *p=ptr;p!=ptr+nbOfElem;p++)
9079 tmp.insert(retPtr[*p]);
9080 fidsOfGroups[grId].insert(fidsOfGroups[grId].end(),tmp.begin(),tmp.end());
9086 * Returns a new DataArrayInt which contains all elements of given one-dimensional
9087 * arrays. The result array does not contain any duplicates and its values
9088 * are sorted in ascending order.
9089 * \param [in] arr - sequence of DataArrayInt's to unite.
9090 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9091 * array using decrRef() as it is no more needed.
9092 * \throw If any \a arr[i] is not allocated.
9093 * \throw If \a arr[i]->getNumberOfComponents() != 1.
9095 DataArrayInt *DataArrayInt::BuildUnion(const std::vector<const DataArrayInt *>& arr) throw(INTERP_KERNEL::Exception)
9097 std::vector<const DataArrayInt *> a;
9098 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9101 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9103 (*it)->checkAllocated();
9104 if((*it)->getNumberOfComponents()!=1)
9105 throw INTERP_KERNEL::Exception("DataArrayInt::BuildUnion : only single component allowed !");
9109 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9111 const int *pt=(*it)->getConstPointer();
9112 int nbOfTuples=(*it)->getNumberOfTuples();
9113 r.insert(pt,pt+nbOfTuples);
9115 DataArrayInt *ret=DataArrayInt::New();
9116 ret->alloc((int)r.size(),1);
9117 std::copy(r.begin(),r.end(),ret->getPointer());
9122 * Returns a new DataArrayInt which contains elements present in each of given one-dimensional
9123 * arrays. The result array does not contain any duplicates and its values
9124 * are sorted in ascending order.
9125 * \param [in] arr - sequence of DataArrayInt's to intersect.
9126 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9127 * array using decrRef() as it is no more needed.
9128 * \throw If any \a arr[i] is not allocated.
9129 * \throw If \a arr[i]->getNumberOfComponents() != 1.
9131 DataArrayInt *DataArrayInt::BuildIntersection(const std::vector<const DataArrayInt *>& arr) throw(INTERP_KERNEL::Exception)
9133 std::vector<const DataArrayInt *> a;
9134 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9137 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9139 (*it)->checkAllocated();
9140 if((*it)->getNumberOfComponents()!=1)
9141 throw INTERP_KERNEL::Exception("DataArrayInt::BuildIntersection : only single component allowed !");
9145 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9147 const int *pt=(*it)->getConstPointer();
9148 int nbOfTuples=(*it)->getNumberOfTuples();
9149 std::set<int> s1(pt,pt+nbOfTuples);
9153 std::set_intersection(r.begin(),r.end(),s1.begin(),s1.end(),inserter(r2,r2.end()));
9159 DataArrayInt *ret=DataArrayInt::New();
9160 ret->alloc((int)r.size(),1);
9161 std::copy(r.begin(),r.end(),ret->getPointer());
9166 * Returns a new DataArrayInt which contains a complement of elements of \a this
9167 * one-dimensional array. I.e. the result array contains all elements from the range [0,
9168 * \a nbOfElement) not present in \a this array.
9169 * \param [in] nbOfElement - maximal size of the result array.
9170 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9171 * array using decrRef() as it is no more needed.
9172 * \throw If \a this is not allocated.
9173 * \throw If \a this->getNumberOfComponents() != 1.
9174 * \throw If any element \a x of \a this array violates condition ( 0 <= \a x < \a
9177 DataArrayInt *DataArrayInt::buildComplement(int nbOfElement) const throw(INTERP_KERNEL::Exception)
9180 if(getNumberOfComponents()!=1)
9181 throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : only single component allowed !");
9182 std::vector<bool> tmp(nbOfElement);
9183 const int *pt=getConstPointer();
9184 int nbOfTuples=getNumberOfTuples();
9185 for(const int *w=pt;w!=pt+nbOfTuples;w++)
9186 if(*w>=0 && *w<nbOfElement)
9189 throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : an element is not in valid range : [0,nbOfElement) !");
9190 int nbOfRetVal=(int)std::count(tmp.begin(),tmp.end(),false);
9191 DataArrayInt *ret=DataArrayInt::New();
9192 ret->alloc(nbOfRetVal,1);
9194 int *retPtr=ret->getPointer();
9195 for(int i=0;i<nbOfElement;i++)
9202 * Returns a new DataArrayInt containing elements of \a this one-dimensional missing
9203 * from an \a other one-dimensional array.
9204 * \param [in] other - a DataArrayInt containing elements not to include in the result array.
9205 * \return DataArrayInt * - a new instance of DataArrayInt with one component. The
9206 * caller is to delete this array using decrRef() as it is no more needed.
9207 * \throw If \a other is NULL.
9208 * \throw If \a other is not allocated.
9209 * \throw If \a other->getNumberOfComponents() != 1.
9210 * \throw If \a this is not allocated.
9211 * \throw If \a this->getNumberOfComponents() != 1.
9212 * \sa DataArrayInt::buildSubstractionOptimized()
9214 DataArrayInt *DataArrayInt::buildSubstraction(const DataArrayInt *other) const throw(INTERP_KERNEL::Exception)
9217 throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : DataArrayInt pointer in input is NULL !");
9219 other->checkAllocated();
9220 if(getNumberOfComponents()!=1)
9221 throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed !");
9222 if(other->getNumberOfComponents()!=1)
9223 throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed for other type !");
9224 const int *pt=getConstPointer();
9225 int nbOfTuples=getNumberOfTuples();
9226 std::set<int> s1(pt,pt+nbOfTuples);
9227 pt=other->getConstPointer();
9228 nbOfTuples=other->getNumberOfTuples();
9229 std::set<int> s2(pt,pt+nbOfTuples);
9231 std::set_difference(s1.begin(),s1.end(),s2.begin(),s2.end(),std::back_insert_iterator< std::vector<int> >(r));
9232 DataArrayInt *ret=DataArrayInt::New();
9233 ret->alloc((int)r.size(),1);
9234 std::copy(r.begin(),r.end(),ret->getPointer());
9239 * \a this is expected to have one component and to be sorted ascendingly (as for \a other).
9240 * \a other is expected to be a part of \a this. If not DataArrayInt::buildSubstraction should be called instead.
9242 * \param [in] other an array with one component and expected to be sorted ascendingly.
9243 * \ret list of ids in \a this but not in \a other.
9244 * \sa DataArrayInt::buildSubstraction
9246 DataArrayInt *DataArrayInt::buildSubstractionOptimized(const DataArrayInt *other) const throw(INTERP_KERNEL::Exception)
9248 static const char *MSG="DataArrayInt::buildSubstractionOptimized : only single component allowed !";
9249 if(!other) throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstractionOptimized : NULL input array !");
9250 checkAllocated(); other->checkAllocated();
9251 if(getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception(MSG);
9252 if(other->getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception(MSG);
9253 const int *pt1Bg(begin()),*pt1End(end()),*pt2Bg(other->begin()),*pt2End(other->end()),*work1(pt1Bg),*work2(pt2Bg);
9254 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
9255 for(;work1!=pt1End;work1++)
9257 if(work2!=pt2End && *work1==*work2)
9260 ret->pushBackSilent(*work1);
9267 * Returns a new DataArrayInt which contains all elements of \a this and a given
9268 * one-dimensional arrays. The result array does not contain any duplicates
9269 * and its values are sorted in ascending order.
9270 * \param [in] other - an array to unite with \a this one.
9271 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9272 * array using decrRef() as it is no more needed.
9273 * \throw If \a this or \a other is not allocated.
9274 * \throw If \a this->getNumberOfComponents() != 1.
9275 * \throw If \a other->getNumberOfComponents() != 1.
9277 DataArrayInt *DataArrayInt::buildUnion(const DataArrayInt *other) const throw(INTERP_KERNEL::Exception)
9279 std::vector<const DataArrayInt *>arrs(2);
9280 arrs[0]=this; arrs[1]=other;
9281 return BuildUnion(arrs);
9286 * Returns a new DataArrayInt which contains elements present in both \a this and a given
9287 * one-dimensional arrays. The result array does not contain any duplicates
9288 * and its values are sorted in ascending order.
9289 * \param [in] other - an array to intersect with \a this one.
9290 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9291 * array using decrRef() as it is no more needed.
9292 * \throw If \a this or \a other is not allocated.
9293 * \throw If \a this->getNumberOfComponents() != 1.
9294 * \throw If \a other->getNumberOfComponents() != 1.
9296 DataArrayInt *DataArrayInt::buildIntersection(const DataArrayInt *other) const throw(INTERP_KERNEL::Exception)
9298 std::vector<const DataArrayInt *>arrs(2);
9299 arrs[0]=this; arrs[1]=other;
9300 return BuildIntersection(arrs);
9304 * This method can be applied on allocated with one component DataArrayInt instance.
9305 * This method is typically relevant for sorted arrays. All consecutive duplicated items in \a this will appear only once in returned DataArrayInt instance.
9306 * 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]
9308 * \return a newly allocated array that contain the result of the unique operation applied on \a this.
9309 * \throw if \a this is not allocated or if \a this has not exactly one component.
9311 DataArrayInt *DataArrayInt::buildUnique() const throw(INTERP_KERNEL::Exception)
9314 if(getNumberOfComponents()!=1)
9315 throw INTERP_KERNEL::Exception("DataArrayInt::buildUnique : only single component allowed !");
9316 int nbOfTuples=getNumberOfTuples();
9317 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=deepCpy();
9318 int *data=tmp->getPointer();
9319 int *last=std::unique(data,data+nbOfTuples);
9320 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9321 ret->alloc(std::distance(data,last),1);
9322 std::copy(data,last,ret->getPointer());
9327 * Returns a new DataArrayInt which contains size of every of groups described by \a this
9328 * "index" array. Such "index" array is returned for example by
9329 * \ref ParaMEDMEM::MEDCouplingUMesh::buildDescendingConnectivity
9330 * "MEDCouplingUMesh::buildDescendingConnectivity" and
9331 * \ref ParaMEDMEM::MEDCouplingUMesh::getNodalConnectivityIndex
9332 * "MEDCouplingUMesh::getNodalConnectivityIndex" etc.
9333 * This method preforms the reverse operation of DataArrayInt::computeOffsets2.
9334 * \return DataArrayInt * - a new instance of DataArrayInt, whose number of tuples
9335 * equals to \a this->getNumberOfComponents() - 1, and number of components is 1.
9336 * The caller is to delete this array using decrRef() as it is no more needed.
9337 * \throw If \a this is not allocated.
9338 * \throw If \a this->getNumberOfComponents() != 1.
9339 * \throw If \a this->getNumberOfTuples() < 2.
9342 * - this contains [1,3,6,7,7,9,15]
9343 * - result array contains [2,3,1,0,2,6],
9344 * where 2 = 3 - 1, 3 = 6 - 3, 1 = 7 - 6 etc.
9346 * \sa DataArrayInt::computeOffsets2
9348 DataArrayInt *DataArrayInt::deltaShiftIndex() const throw(INTERP_KERNEL::Exception)
9351 if(getNumberOfComponents()!=1)
9352 throw INTERP_KERNEL::Exception("DataArrayInt::deltaShiftIndex : only single component allowed !");
9353 int nbOfTuples=getNumberOfTuples();
9355 throw INTERP_KERNEL::Exception("DataArrayInt::deltaShiftIndex : 1 tuple at least must be present in 'this' !");
9356 const int *ptr=getConstPointer();
9357 DataArrayInt *ret=DataArrayInt::New();
9358 ret->alloc(nbOfTuples-1,1);
9359 int *out=ret->getPointer();
9360 std::transform(ptr+1,ptr+nbOfTuples,ptr,out,std::minus<int>());
9365 * Modifies \a this one-dimensional array so that value of each element \a x
9366 * of \a this array (\a a) is computed as \f$ x_i = \sum_{j=0}^{i-1} a[ j ] \f$.
9367 * Or: for each i>0 new[i]=new[i-1]+old[i-1] for i==0 new[i]=0. Number of tuples
9368 * and components remains the same.<br>
9369 * This method is useful for allToAllV in MPI with contiguous policy. This method
9370 * differs from computeOffsets2() in that the number of tuples is \b not changed by
9372 * \throw If \a this is not allocated.
9373 * \throw If \a this->getNumberOfComponents() != 1.
9376 * - Before \a this contains [3,5,1,2,0,8]
9377 * - After \a this contains [0,3,8,9,11,11]<br>
9378 * Note that the last element 19 = 11 + 8 is missing because size of \a this
9379 * array is retained and thus there is no space to store the last element.
9381 void DataArrayInt::computeOffsets() throw(INTERP_KERNEL::Exception)
9384 if(getNumberOfComponents()!=1)
9385 throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsets : only single component allowed !");
9386 int nbOfTuples=getNumberOfTuples();
9389 int *work=getPointer();
9392 for(int i=1;i<nbOfTuples;i++)
9395 work[i]=work[i-1]+tmp;
9403 * Modifies \a this one-dimensional array so that value of each element \a x
9404 * of \a this array (\a a) is computed as \f$ x_i = \sum_{j=0}^{i-1} a[ j ] \f$.
9405 * Or: for each i>0 new[i]=new[i-1]+old[i-1] for i==0 new[i]=0. Number
9406 * components remains the same and number of tuples is inceamented by one.<br>
9407 * This method is useful for allToAllV in MPI with contiguous policy. This method
9408 * differs from computeOffsets() in that the number of tuples is changed by this one.
9409 * This method preforms the reverse operation of DataArrayInt::deltaShiftIndex.
9410 * \throw If \a this is not allocated.
9411 * \throw If \a this->getNumberOfComponents() != 1.
9414 * - Before \a this contains [3,5,1,2,0,8]
9415 * - After \a this contains [0,3,8,9,11,11,19]<br>
9416 * \sa DataArrayInt::deltaShiftIndex
9418 void DataArrayInt::computeOffsets2() throw(INTERP_KERNEL::Exception)
9421 if(getNumberOfComponents()!=1)
9422 throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsets2 : only single component allowed !");
9423 int nbOfTuples=getNumberOfTuples();
9424 int *ret=(int *)malloc((nbOfTuples+1)*sizeof(int));
9427 const int *work=getConstPointer();
9429 for(int i=0;i<nbOfTuples;i++)
9430 ret[i+1]=work[i]+ret[i];
9431 useArray(ret,true,C_DEALLOC,nbOfTuples+1,1);
9436 * Returns two new DataArrayInt instances whose contents is computed from that of \a this and \a listOfIds arrays as follows.
9437 * \a this is expected to be an offset format ( as returned by DataArrayInt::computeOffsets2 ) that is to say with one component
9438 * and ** sorted strictly increasingly **. \a listOfIds is expected to be sorted ascendingly (not strictly needed for \a listOfIds).
9439 * This methods searches in \a this, considered as a set of contiguous \c this->getNumberOfComponents() ranges, all ids in \a listOfIds
9440 * filling completely one of the ranges in \a this.
9442 * \param [in] listOfIds a list of ids that has to be sorted ascendingly.
9443 * \param [out] rangeIdsFetched the range ids fetched
9444 * \param [out] idsInInputListThatFetch contains the list of ids in \a listOfIds that are \b fully included in a range in \a this. So
9445 * \a idsInInputListThatFetch is a part of input \a listOfIds.
9447 * \sa DataArrayInt::computeOffsets2
9450 * - \a this : [0,3,7,9,15,18]
9451 * - \a listOfIds contains [0,1,2,3,7,8,15,16,17]
9452 * - \a rangeIdsFetched result array: [0,2,4]
9453 * - \a idsInInputListThatFetch result array: [0,1,2,7,8,15,16,17]
9454 * In this example id 3 in input \a listOfIds is alone so it do not appear in output \a idsInInputListThatFetch.
9457 void DataArrayInt::searchRangesInListOfIds(const DataArrayInt *listOfIds, DataArrayInt *& rangeIdsFetched, DataArrayInt *& idsInInputListThatFetch) const throw(INTERP_KERNEL::Exception)
9460 throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : input list of ids is null !");
9461 listOfIds->checkAllocated(); checkAllocated();
9462 if(listOfIds->getNumberOfComponents()!=1)
9463 throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : input list of ids must have exactly one component !");
9464 if(getNumberOfComponents()!=1)
9465 throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : this must have exactly one component !");
9466 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret0=DataArrayInt::New(); ret0->alloc(0,1);
9467 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New(); ret1->alloc(0,1);
9468 const int *tupEnd(listOfIds->end()),*offBg(begin()),*offEnd(end()-1);
9469 const int *tupPtr(listOfIds->begin()),*offPtr(offBg);
9470 while(tupPtr!=tupEnd && offPtr!=offEnd)
9472 if(*tupPtr==*offPtr)
9475 while(i<offPtr[1] && *tupPtr==i && tupPtr!=tupEnd) { i++; tupPtr++; }
9478 ret0->pushBackSilent((int)std::distance(offBg,offPtr));
9479 ret1->pushBackValsSilent(tupPtr-(offPtr[1]-offPtr[0]),tupPtr);
9484 { if(*tupPtr<*offPtr) tupPtr++; else offPtr++; }
9486 rangeIdsFetched=ret0.retn();
9487 idsInInputListThatFetch=ret1.retn();
9491 * Returns a new DataArrayInt whose contents is computed from that of \a this and \a
9492 * offsets arrays as follows. \a offsets is a one-dimensional array considered as an
9493 * "index" array of a "iota" array, thus, whose each element gives an index of a group
9494 * beginning within the "iota" array. And \a this is a one-dimensional array
9495 * considered as a selector of groups described by \a offsets to include into the result array.
9496 * \throw If \a offsets is NULL.
9497 * \throw If \a offsets is not allocated.
9498 * \throw If \a offsets->getNumberOfComponents() != 1.
9499 * \throw If \a offsets is not monotonically increasing.
9500 * \throw If \a this is not allocated.
9501 * \throw If \a this->getNumberOfComponents() != 1.
9502 * \throw If any element of \a this is not a valid index for \a offsets array.
9505 * - \a this: [0,2,3]
9506 * - \a offsets: [0,3,6,10,14,20]
9507 * - result array: [0,1,2,6,7,8,9,10,11,12,13] == <br>
9508 * \c range(0,3) + \c range(6,10) + \c range(10,14) ==<br>
9509 * \c range( \a offsets[ \a this[0] ], offsets[ \a this[0]+1 ]) +
9510 * \c range( \a offsets[ \a this[1] ], offsets[ \a this[1]+1 ]) +
9511 * \c range( \a offsets[ \a this[2] ], offsets[ \a this[2]+1 ])
9513 DataArrayInt *DataArrayInt::buildExplicitArrByRanges(const DataArrayInt *offsets) const throw(INTERP_KERNEL::Exception)
9516 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : DataArrayInt pointer in input is NULL !");
9518 if(getNumberOfComponents()!=1)
9519 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : only single component allowed !");
9520 offsets->checkAllocated();
9521 if(offsets->getNumberOfComponents()!=1)
9522 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : input array should have only single component !");
9523 int othNbTuples=offsets->getNumberOfTuples()-1;
9524 int nbOfTuples=getNumberOfTuples();
9525 int retNbOftuples=0;
9526 const int *work=getConstPointer();
9527 const int *offPtr=offsets->getConstPointer();
9528 for(int i=0;i<nbOfTuples;i++)
9531 if(val>=0 && val<othNbTuples)
9533 int delta=offPtr[val+1]-offPtr[val];
9535 retNbOftuples+=delta;
9538 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrByRanges : Tuple #" << val << " of offset array has a delta < 0 !";
9539 throw INTERP_KERNEL::Exception(oss.str().c_str());
9544 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrByRanges : Tuple #" << i << " in this contains " << val;
9545 oss << " whereas offsets array is of size " << othNbTuples+1 << " !";
9546 throw INTERP_KERNEL::Exception(oss.str().c_str());
9549 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9550 ret->alloc(retNbOftuples,1);
9551 int *retPtr=ret->getPointer();
9552 for(int i=0;i<nbOfTuples;i++)
9555 int start=offPtr[val];
9556 int off=offPtr[val+1]-start;
9557 for(int j=0;j<off;j++,retPtr++)
9564 * 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.
9565 * 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
9566 * in tuple **i** of returned DataArrayInt.
9567 * If ranges overlapped (in theory it should not) this method do not detect it and always returns the first range.
9569 * 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)]
9570 * The return DataArrayInt will contain : **[0,4,1,2,2,3]**
9572 * \param [in] ranges typically come from output of MEDCouplingUMesh::ComputeRangesFromTypeDistribution. Each range is specified like this : 1st component is
9573 * for lower value included and 2nd component is the upper value of corresponding range **excluded**.
9574 * \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
9575 * is thrown if no ranges in \a ranges contains value in \a this.
9577 * \sa DataArrayInt::findIdInRangeForEachTuple
9579 DataArrayInt *DataArrayInt::findRangeIdForEachTuple(const DataArrayInt *ranges) const throw(INTERP_KERNEL::Exception)
9582 throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : null input pointer !");
9583 if(ranges->getNumberOfComponents()!=2)
9584 throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : input DataArrayInt instance should have 2 components !");
9586 if(getNumberOfComponents()!=1)
9587 throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : this should have only one component !");
9588 int nbTuples=getNumberOfTuples();
9589 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTuples,1);
9590 int nbOfRanges=ranges->getNumberOfTuples();
9591 const int *rangesPtr=ranges->getConstPointer();
9592 int *retPtr=ret->getPointer();
9593 const int *inPtr=getConstPointer();
9594 for(int i=0;i<nbTuples;i++,retPtr++)
9598 for(int j=0;j<nbOfRanges && !found;j++)
9599 if(val>=rangesPtr[2*j] && val<rangesPtr[2*j+1])
9600 { *retPtr=j; found=true; }
9605 std::ostringstream oss; oss << "DataArrayInt::findRangeIdForEachTuple : tuple #" << i << " not found by any ranges !";
9606 throw INTERP_KERNEL::Exception(oss.str().c_str());
9613 * 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.
9614 * 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
9615 * in tuple **i** of returned DataArrayInt.
9616 * If ranges overlapped (in theory it should not) this method do not detect it and always returns the sub position of the first range.
9618 * 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)]
9619 * The return DataArrayInt will contain : **[1,2,4,0,2,2]**
9620 * This method is often called in pair with DataArrayInt::findRangeIdForEachTuple method.
9622 * \param [in] ranges typically come from output of MEDCouplingUMesh::ComputeRangesFromTypeDistribution. Each range is specified like this : 1st component is
9623 * for lower value included and 2nd component is the upper value of corresponding range **excluded**.
9624 * \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
9625 * is thrown if no ranges in \a ranges contains value in \a this.
9626 * \sa DataArrayInt::findRangeIdForEachTuple
9628 DataArrayInt *DataArrayInt::findIdInRangeForEachTuple(const DataArrayInt *ranges) const throw(INTERP_KERNEL::Exception)
9631 throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : null input pointer !");
9632 if(ranges->getNumberOfComponents()!=2)
9633 throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : input DataArrayInt instance should have 2 components !");
9635 if(getNumberOfComponents()!=1)
9636 throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : this should have only one component !");
9637 int nbTuples=getNumberOfTuples();
9638 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTuples,1);
9639 int nbOfRanges=ranges->getNumberOfTuples();
9640 const int *rangesPtr=ranges->getConstPointer();
9641 int *retPtr=ret->getPointer();
9642 const int *inPtr=getConstPointer();
9643 for(int i=0;i<nbTuples;i++,retPtr++)
9647 for(int j=0;j<nbOfRanges && !found;j++)
9648 if(val>=rangesPtr[2*j] && val<rangesPtr[2*j+1])
9649 { *retPtr=val-rangesPtr[2*j]; found=true; }
9654 std::ostringstream oss; oss << "DataArrayInt::findIdInRangeForEachTuple : tuple #" << i << " not found by any ranges !";
9655 throw INTERP_KERNEL::Exception(oss.str().c_str());
9663 * \param [in] nbTimes specifies the nb of times each tuples in \a this will be duplicated contiguouly in returned DataArrayInt instance.
9664 * \a nbTimes should be at least equal to 1.
9665 * \return a newly allocated DataArrayInt having one component and number of tuples equal to \a nbTimes * \c this->getNumberOfTuples.
9666 * \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.
9668 DataArrayInt *DataArrayInt::duplicateEachTupleNTimes(int nbTimes) const throw(INTERP_KERNEL::Exception)
9671 if(getNumberOfComponents()!=1)
9672 throw INTERP_KERNEL::Exception("DataArrayInt::duplicateEachTupleNTimes : this should have only one component !");
9674 throw INTERP_KERNEL::Exception("DataArrayInt::duplicateEachTupleNTimes : nb times should be >= 1 !");
9675 int nbTuples=getNumberOfTuples();
9676 const int *inPtr=getConstPointer();
9677 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTimes*nbTuples,1);
9678 int *retPtr=ret->getPointer();
9679 for(int i=0;i<nbTuples;i++,inPtr++)
9682 for(int j=0;j<nbTimes;j++,retPtr++)
9685 ret->copyStringInfoFrom(*this);
9690 * This method returns all different values found in \a this. This method throws if \a this has not been allocated.
9691 * But the number of components can be different from one.
9692 * \return a newly allocated array (that should be dealt by the caller) containing different values in \a this.
9694 DataArrayInt *DataArrayInt::getDifferentValues() const throw(INTERP_KERNEL::Exception)
9698 ret.insert(begin(),end());
9699 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret2=DataArrayInt::New(); ret2->alloc((int)ret.size(),1);
9700 std::copy(ret.begin(),ret.end(),ret2->getPointer());
9705 * This method is a refinement of DataArrayInt::getDifferentValues because it returns not only different values in \a this but also, for each of
9706 * them it tells which tuple id have this id.
9707 * This method works only on arrays with one component (if it is not the case call DataArrayInt::rearrange(1) ).
9708 * This method returns two arrays having same size.
9709 * 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.
9710 * 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]]
9712 std::vector<DataArrayInt *> DataArrayInt::partitionByDifferentValues(std::vector<int>& differentIds) const throw(INTERP_KERNEL::Exception)
9715 if(getNumberOfComponents()!=1)
9716 throw INTERP_KERNEL::Exception("DataArrayInt::partitionByDifferentValues : this should have only one component !");
9718 std::map<int,int> m,m2,m3;
9719 for(const int *w=begin();w!=end();w++)
9721 differentIds.resize(m.size());
9722 std::vector<DataArrayInt *> ret(m.size());
9723 std::vector<int *> retPtr(m.size());
9724 for(std::map<int,int>::const_iterator it=m.begin();it!=m.end();it++,id++)
9727 ret[id]=DataArrayInt::New();
9728 ret[id]->alloc((*it).second,1);
9729 retPtr[id]=ret[id]->getPointer();
9730 differentIds[id]=(*it).first;
9733 for(const int *w=begin();w!=end();w++,id++)
9735 retPtr[m2[*w]][m3[*w]++]=id;
9741 * Returns a new DataArrayInt that is a sum of two given arrays. There are 3
9743 * 1. The arrays have same number of tuples and components. Then each value of
9744 * the result array (_a_) is a sum of the corresponding values of \a a1 and \a a2,
9745 * i.e.: _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, j ].
9746 * 2. The arrays have same number of tuples and one array, say _a2_, has one
9748 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, 0 ].
9749 * 3. The arrays have same number of components and one array, say _a2_, has one
9751 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ 0, j ].
9753 * Info on components is copied either from the first array (in the first case) or from
9754 * the array with maximal number of elements (getNbOfElems()).
9755 * \param [in] a1 - an array to sum up.
9756 * \param [in] a2 - another array to sum up.
9757 * \return DataArrayInt * - the new instance of DataArrayInt.
9758 * The caller is to delete this result array using decrRef() as it is no more
9760 * \throw If either \a a1 or \a a2 is NULL.
9761 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
9762 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
9763 * none of them has number of tuples or components equal to 1.
9765 DataArrayInt *DataArrayInt::Add(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception)
9768 throw INTERP_KERNEL::Exception("DataArrayInt::Add : input DataArrayInt instance is NULL !");
9769 int nbOfTuple=a1->getNumberOfTuples();
9770 int nbOfTuple2=a2->getNumberOfTuples();
9771 int nbOfComp=a1->getNumberOfComponents();
9772 int nbOfComp2=a2->getNumberOfComponents();
9773 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=0;
9774 if(nbOfTuple==nbOfTuple2)
9776 if(nbOfComp==nbOfComp2)
9778 ret=DataArrayInt::New();
9779 ret->alloc(nbOfTuple,nbOfComp);
9780 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::plus<int>());
9781 ret->copyStringInfoFrom(*a1);
9785 int nbOfCompMin,nbOfCompMax;
9786 const DataArrayInt *aMin, *aMax;
9787 if(nbOfComp>nbOfComp2)
9789 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
9794 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
9799 ret=DataArrayInt::New();
9800 ret->alloc(nbOfTuple,nbOfCompMax);
9801 const int *aMinPtr=aMin->getConstPointer();
9802 const int *aMaxPtr=aMax->getConstPointer();
9803 int *res=ret->getPointer();
9804 for(int i=0;i<nbOfTuple;i++)
9805 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::plus<int>(),aMinPtr[i]));
9806 ret->copyStringInfoFrom(*aMax);
9809 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
9812 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
9814 if(nbOfComp==nbOfComp2)
9816 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
9817 const DataArrayInt *aMin=nbOfTuple>nbOfTuple2?a2:a1;
9818 const DataArrayInt *aMax=nbOfTuple>nbOfTuple2?a1:a2;
9819 const int *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
9820 ret=DataArrayInt::New();
9821 ret->alloc(nbOfTupleMax,nbOfComp);
9822 int *res=ret->getPointer();
9823 for(int i=0;i<nbOfTupleMax;i++)
9824 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::plus<int>());
9825 ret->copyStringInfoFrom(*aMax);
9828 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
9831 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Add !");
9836 * Adds values of another DataArrayInt to values of \a this one. There are 3
9838 * 1. The arrays have same number of tuples and components. Then each value of
9839 * \a other array is added to the corresponding value of \a this array, i.e.:
9840 * _a_ [ i, j ] += _other_ [ i, j ].
9841 * 2. The arrays have same number of tuples and \a other array has one component. Then
9842 * _a_ [ i, j ] += _other_ [ i, 0 ].
9843 * 3. The arrays have same number of components and \a other array has one tuple. Then
9844 * _a_ [ i, j ] += _a2_ [ 0, j ].
9846 * \param [in] other - an array to add to \a this one.
9847 * \throw If \a other is NULL.
9848 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
9849 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
9850 * \a other has number of both tuples and components not equal to 1.
9852 void DataArrayInt::addEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception)
9855 throw INTERP_KERNEL::Exception("DataArrayInt::addEqual : input DataArrayInt instance is NULL !");
9856 const char *msg="Nb of tuples mismatch for DataArrayInt::addEqual !";
9857 checkAllocated(); other->checkAllocated();
9858 int nbOfTuple=getNumberOfTuples();
9859 int nbOfTuple2=other->getNumberOfTuples();
9860 int nbOfComp=getNumberOfComponents();
9861 int nbOfComp2=other->getNumberOfComponents();
9862 if(nbOfTuple==nbOfTuple2)
9864 if(nbOfComp==nbOfComp2)
9866 std::transform(begin(),end(),other->begin(),getPointer(),std::plus<int>());
9868 else if(nbOfComp2==1)
9870 int *ptr=getPointer();
9871 const int *ptrc=other->getConstPointer();
9872 for(int i=0;i<nbOfTuple;i++)
9873 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::plus<int>(),*ptrc++));
9876 throw INTERP_KERNEL::Exception(msg);
9878 else if(nbOfTuple2==1)
9880 if(nbOfComp2==nbOfComp)
9882 int *ptr=getPointer();
9883 const int *ptrc=other->getConstPointer();
9884 for(int i=0;i<nbOfTuple;i++)
9885 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::plus<int>());
9888 throw INTERP_KERNEL::Exception(msg);
9891 throw INTERP_KERNEL::Exception(msg);
9896 * Returns a new DataArrayInt that is a subtraction of two given arrays. There are 3
9898 * 1. The arrays have same number of tuples and components. Then each value of
9899 * the result array (_a_) is a subtraction of the corresponding values of \a a1 and
9900 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, j ].
9901 * 2. The arrays have same number of tuples and one array, say _a2_, has one
9903 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, 0 ].
9904 * 3. The arrays have same number of components and one array, say _a2_, has one
9906 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ 0, j ].
9908 * Info on components is copied either from the first array (in the first case) or from
9909 * the array with maximal number of elements (getNbOfElems()).
9910 * \param [in] a1 - an array to subtract from.
9911 * \param [in] a2 - an array to subtract.
9912 * \return DataArrayInt * - the new instance of DataArrayInt.
9913 * The caller is to delete this result array using decrRef() as it is no more
9915 * \throw If either \a a1 or \a a2 is NULL.
9916 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
9917 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
9918 * none of them has number of tuples or components equal to 1.
9920 DataArrayInt *DataArrayInt::Substract(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception)
9923 throw INTERP_KERNEL::Exception("DataArrayInt::Substract : input DataArrayInt instance is NULL !");
9924 int nbOfTuple1=a1->getNumberOfTuples();
9925 int nbOfTuple2=a2->getNumberOfTuples();
9926 int nbOfComp1=a1->getNumberOfComponents();
9927 int nbOfComp2=a2->getNumberOfComponents();
9928 if(nbOfTuple2==nbOfTuple1)
9930 if(nbOfComp1==nbOfComp2)
9932 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9933 ret->alloc(nbOfTuple2,nbOfComp1);
9934 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::minus<int>());
9935 ret->copyStringInfoFrom(*a1);
9938 else if(nbOfComp2==1)
9940 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9941 ret->alloc(nbOfTuple1,nbOfComp1);
9942 const int *a2Ptr=a2->getConstPointer();
9943 const int *a1Ptr=a1->getConstPointer();
9944 int *res=ret->getPointer();
9945 for(int i=0;i<nbOfTuple1;i++)
9946 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::minus<int>(),a2Ptr[i]));
9947 ret->copyStringInfoFrom(*a1);
9952 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
9956 else if(nbOfTuple2==1)
9958 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
9959 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9960 ret->alloc(nbOfTuple1,nbOfComp1);
9961 const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
9962 int *pt=ret->getPointer();
9963 for(int i=0;i<nbOfTuple1;i++)
9964 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::minus<int>());
9965 ret->copyStringInfoFrom(*a1);
9970 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Substract !");//will always throw an exception
9976 * Subtract values of another DataArrayInt from values of \a this one. There are 3
9978 * 1. The arrays have same number of tuples and components. Then each value of
9979 * \a other array is subtracted from the corresponding value of \a this array, i.e.:
9980 * _a_ [ i, j ] -= _other_ [ i, j ].
9981 * 2. The arrays have same number of tuples and \a other array has one component. Then
9982 * _a_ [ i, j ] -= _other_ [ i, 0 ].
9983 * 3. The arrays have same number of components and \a other array has one tuple. Then
9984 * _a_ [ i, j ] -= _a2_ [ 0, j ].
9986 * \param [in] other - an array to subtract from \a this one.
9987 * \throw If \a other is NULL.
9988 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
9989 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
9990 * \a other has number of both tuples and components not equal to 1.
9992 void DataArrayInt::substractEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception)
9995 throw INTERP_KERNEL::Exception("DataArrayInt::substractEqual : input DataArrayInt instance is NULL !");
9996 const char *msg="Nb of tuples mismatch for DataArrayInt::substractEqual !";
9997 checkAllocated(); other->checkAllocated();
9998 int nbOfTuple=getNumberOfTuples();
9999 int nbOfTuple2=other->getNumberOfTuples();
10000 int nbOfComp=getNumberOfComponents();
10001 int nbOfComp2=other->getNumberOfComponents();
10002 if(nbOfTuple==nbOfTuple2)
10004 if(nbOfComp==nbOfComp2)
10006 std::transform(begin(),end(),other->begin(),getPointer(),std::minus<int>());
10008 else if(nbOfComp2==1)
10010 int *ptr=getPointer();
10011 const int *ptrc=other->getConstPointer();
10012 for(int i=0;i<nbOfTuple;i++)
10013 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::minus<int>(),*ptrc++));
10016 throw INTERP_KERNEL::Exception(msg);
10018 else if(nbOfTuple2==1)
10020 int *ptr=getPointer();
10021 const int *ptrc=other->getConstPointer();
10022 for(int i=0;i<nbOfTuple;i++)
10023 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::minus<int>());
10026 throw INTERP_KERNEL::Exception(msg);
10031 * Returns a new DataArrayInt that is a product of two given arrays. There are 3
10033 * 1. The arrays have same number of tuples and components. Then each value of
10034 * the result array (_a_) is a product of the corresponding values of \a a1 and
10035 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, j ].
10036 * 2. The arrays have same number of tuples and one array, say _a2_, has one
10038 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, 0 ].
10039 * 3. The arrays have same number of components and one array, say _a2_, has one
10041 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ 0, j ].
10043 * Info on components is copied either from the first array (in the first case) or from
10044 * the array with maximal number of elements (getNbOfElems()).
10045 * \param [in] a1 - a factor array.
10046 * \param [in] a2 - another factor array.
10047 * \return DataArrayInt * - the new instance of DataArrayInt.
10048 * The caller is to delete this result array using decrRef() as it is no more
10050 * \throw If either \a a1 or \a a2 is NULL.
10051 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
10052 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
10053 * none of them has number of tuples or components equal to 1.
10055 DataArrayInt *DataArrayInt::Multiply(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception)
10058 throw INTERP_KERNEL::Exception("DataArrayInt::Multiply : input DataArrayInt instance is NULL !");
10059 int nbOfTuple=a1->getNumberOfTuples();
10060 int nbOfTuple2=a2->getNumberOfTuples();
10061 int nbOfComp=a1->getNumberOfComponents();
10062 int nbOfComp2=a2->getNumberOfComponents();
10063 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=0;
10064 if(nbOfTuple==nbOfTuple2)
10066 if(nbOfComp==nbOfComp2)
10068 ret=DataArrayInt::New();
10069 ret->alloc(nbOfTuple,nbOfComp);
10070 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::multiplies<int>());
10071 ret->copyStringInfoFrom(*a1);
10075 int nbOfCompMin,nbOfCompMax;
10076 const DataArrayInt *aMin, *aMax;
10077 if(nbOfComp>nbOfComp2)
10079 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
10084 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
10089 ret=DataArrayInt::New();
10090 ret->alloc(nbOfTuple,nbOfCompMax);
10091 const int *aMinPtr=aMin->getConstPointer();
10092 const int *aMaxPtr=aMax->getConstPointer();
10093 int *res=ret->getPointer();
10094 for(int i=0;i<nbOfTuple;i++)
10095 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::multiplies<int>(),aMinPtr[i]));
10096 ret->copyStringInfoFrom(*aMax);
10099 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
10102 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
10104 if(nbOfComp==nbOfComp2)
10106 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
10107 const DataArrayInt *aMin=nbOfTuple>nbOfTuple2?a2:a1;
10108 const DataArrayInt *aMax=nbOfTuple>nbOfTuple2?a1:a2;
10109 const int *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
10110 ret=DataArrayInt::New();
10111 ret->alloc(nbOfTupleMax,nbOfComp);
10112 int *res=ret->getPointer();
10113 for(int i=0;i<nbOfTupleMax;i++)
10114 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::multiplies<int>());
10115 ret->copyStringInfoFrom(*aMax);
10118 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
10121 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Multiply !");
10127 * Multiply values of another DataArrayInt to values of \a this one. There are 3
10129 * 1. The arrays have same number of tuples and components. Then each value of
10130 * \a other array is multiplied to the corresponding value of \a this array, i.e.:
10131 * _a_ [ i, j ] *= _other_ [ i, j ].
10132 * 2. The arrays have same number of tuples and \a other array has one component. Then
10133 * _a_ [ i, j ] *= _other_ [ i, 0 ].
10134 * 3. The arrays have same number of components and \a other array has one tuple. Then
10135 * _a_ [ i, j ] *= _a2_ [ 0, j ].
10137 * \param [in] other - an array to multiply to \a this one.
10138 * \throw If \a other is NULL.
10139 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
10140 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
10141 * \a other has number of both tuples and components not equal to 1.
10143 void DataArrayInt::multiplyEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception)
10146 throw INTERP_KERNEL::Exception("DataArrayInt::multiplyEqual : input DataArrayInt instance is NULL !");
10147 const char *msg="Nb of tuples mismatch for DataArrayInt::multiplyEqual !";
10148 checkAllocated(); other->checkAllocated();
10149 int nbOfTuple=getNumberOfTuples();
10150 int nbOfTuple2=other->getNumberOfTuples();
10151 int nbOfComp=getNumberOfComponents();
10152 int nbOfComp2=other->getNumberOfComponents();
10153 if(nbOfTuple==nbOfTuple2)
10155 if(nbOfComp==nbOfComp2)
10157 std::transform(begin(),end(),other->begin(),getPointer(),std::multiplies<int>());
10159 else if(nbOfComp2==1)
10161 int *ptr=getPointer();
10162 const int *ptrc=other->getConstPointer();
10163 for(int i=0;i<nbOfTuple;i++)
10164 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::multiplies<int>(),*ptrc++));
10167 throw INTERP_KERNEL::Exception(msg);
10169 else if(nbOfTuple2==1)
10171 if(nbOfComp2==nbOfComp)
10173 int *ptr=getPointer();
10174 const int *ptrc=other->getConstPointer();
10175 for(int i=0;i<nbOfTuple;i++)
10176 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::multiplies<int>());
10179 throw INTERP_KERNEL::Exception(msg);
10182 throw INTERP_KERNEL::Exception(msg);
10188 * Returns a new DataArrayInt that is a division of two given arrays. There are 3
10190 * 1. The arrays have same number of tuples and components. Then each value of
10191 * the result array (_a_) is a division of the corresponding values of \a a1 and
10192 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, j ].
10193 * 2. The arrays have same number of tuples and one array, say _a2_, has one
10195 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, 0 ].
10196 * 3. The arrays have same number of components and one array, say _a2_, has one
10198 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ 0, j ].
10200 * Info on components is copied either from the first array (in the first case) or from
10201 * the array with maximal number of elements (getNbOfElems()).
10202 * \warning No check of division by zero is performed!
10203 * \param [in] a1 - a numerator array.
10204 * \param [in] a2 - a denominator array.
10205 * \return DataArrayInt * - the new instance of DataArrayInt.
10206 * The caller is to delete this result array using decrRef() as it is no more
10208 * \throw If either \a a1 or \a a2 is NULL.
10209 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
10210 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
10211 * none of them has number of tuples or components equal to 1.
10213 DataArrayInt *DataArrayInt::Divide(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception)
10216 throw INTERP_KERNEL::Exception("DataArrayInt::Divide : input DataArrayInt instance is NULL !");
10217 int nbOfTuple1=a1->getNumberOfTuples();
10218 int nbOfTuple2=a2->getNumberOfTuples();
10219 int nbOfComp1=a1->getNumberOfComponents();
10220 int nbOfComp2=a2->getNumberOfComponents();
10221 if(nbOfTuple2==nbOfTuple1)
10223 if(nbOfComp1==nbOfComp2)
10225 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10226 ret->alloc(nbOfTuple2,nbOfComp1);
10227 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::divides<int>());
10228 ret->copyStringInfoFrom(*a1);
10231 else if(nbOfComp2==1)
10233 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10234 ret->alloc(nbOfTuple1,nbOfComp1);
10235 const int *a2Ptr=a2->getConstPointer();
10236 const int *a1Ptr=a1->getConstPointer();
10237 int *res=ret->getPointer();
10238 for(int i=0;i<nbOfTuple1;i++)
10239 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::divides<int>(),a2Ptr[i]));
10240 ret->copyStringInfoFrom(*a1);
10245 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
10249 else if(nbOfTuple2==1)
10251 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
10252 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10253 ret->alloc(nbOfTuple1,nbOfComp1);
10254 const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
10255 int *pt=ret->getPointer();
10256 for(int i=0;i<nbOfTuple1;i++)
10257 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::divides<int>());
10258 ret->copyStringInfoFrom(*a1);
10263 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Divide !");//will always throw an exception
10269 * Divide values of \a this array by values of another DataArrayInt. There are 3
10271 * 1. The arrays have same number of tuples and components. Then each value of
10272 * \a this array is divided by the corresponding value of \a other one, i.e.:
10273 * _a_ [ i, j ] /= _other_ [ i, j ].
10274 * 2. The arrays have same number of tuples and \a other array has one component. Then
10275 * _a_ [ i, j ] /= _other_ [ i, 0 ].
10276 * 3. The arrays have same number of components and \a other array has one tuple. Then
10277 * _a_ [ i, j ] /= _a2_ [ 0, j ].
10279 * \warning No check of division by zero is performed!
10280 * \param [in] other - an array to divide \a this one by.
10281 * \throw If \a other is NULL.
10282 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
10283 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
10284 * \a other has number of both tuples and components not equal to 1.
10286 void DataArrayInt::divideEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception)
10289 throw INTERP_KERNEL::Exception("DataArrayInt::divideEqual : input DataArrayInt instance is NULL !");
10290 const char *msg="Nb of tuples mismatch for DataArrayInt::divideEqual !";
10291 checkAllocated(); other->checkAllocated();
10292 int nbOfTuple=getNumberOfTuples();
10293 int nbOfTuple2=other->getNumberOfTuples();
10294 int nbOfComp=getNumberOfComponents();
10295 int nbOfComp2=other->getNumberOfComponents();
10296 if(nbOfTuple==nbOfTuple2)
10298 if(nbOfComp==nbOfComp2)
10300 std::transform(begin(),end(),other->begin(),getPointer(),std::divides<int>());
10302 else if(nbOfComp2==1)
10304 int *ptr=getPointer();
10305 const int *ptrc=other->getConstPointer();
10306 for(int i=0;i<nbOfTuple;i++)
10307 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::divides<int>(),*ptrc++));
10310 throw INTERP_KERNEL::Exception(msg);
10312 else if(nbOfTuple2==1)
10314 if(nbOfComp2==nbOfComp)
10316 int *ptr=getPointer();
10317 const int *ptrc=other->getConstPointer();
10318 for(int i=0;i<nbOfTuple;i++)
10319 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::divides<int>());
10322 throw INTERP_KERNEL::Exception(msg);
10325 throw INTERP_KERNEL::Exception(msg);
10331 * Returns a new DataArrayInt that is a modulus of two given arrays. There are 3
10333 * 1. The arrays have same number of tuples and components. Then each value of
10334 * the result array (_a_) is a division of the corresponding values of \a a1 and
10335 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ i, j ].
10336 * 2. The arrays have same number of tuples and one array, say _a2_, has one
10338 * _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ i, 0 ].
10339 * 3. The arrays have same number of components and one array, say _a2_, has one
10341 * _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ 0, j ].
10343 * Info on components is copied either from the first array (in the first case) or from
10344 * the array with maximal number of elements (getNbOfElems()).
10345 * \warning No check of division by zero is performed!
10346 * \param [in] a1 - a dividend array.
10347 * \param [in] a2 - a divisor array.
10348 * \return DataArrayInt * - the new instance of DataArrayInt.
10349 * The caller is to delete this result array using decrRef() as it is no more
10351 * \throw If either \a a1 or \a a2 is NULL.
10352 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
10353 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
10354 * none of them has number of tuples or components equal to 1.
10356 DataArrayInt *DataArrayInt::Modulus(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception)
10359 throw INTERP_KERNEL::Exception("DataArrayInt::Modulus : input DataArrayInt instance is NULL !");
10360 int nbOfTuple1=a1->getNumberOfTuples();
10361 int nbOfTuple2=a2->getNumberOfTuples();
10362 int nbOfComp1=a1->getNumberOfComponents();
10363 int nbOfComp2=a2->getNumberOfComponents();
10364 if(nbOfTuple2==nbOfTuple1)
10366 if(nbOfComp1==nbOfComp2)
10368 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10369 ret->alloc(nbOfTuple2,nbOfComp1);
10370 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::modulus<int>());
10371 ret->copyStringInfoFrom(*a1);
10374 else if(nbOfComp2==1)
10376 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10377 ret->alloc(nbOfTuple1,nbOfComp1);
10378 const int *a2Ptr=a2->getConstPointer();
10379 const int *a1Ptr=a1->getConstPointer();
10380 int *res=ret->getPointer();
10381 for(int i=0;i<nbOfTuple1;i++)
10382 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::modulus<int>(),a2Ptr[i]));
10383 ret->copyStringInfoFrom(*a1);
10388 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Modulus !");
10392 else if(nbOfTuple2==1)
10394 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Modulus !");
10395 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10396 ret->alloc(nbOfTuple1,nbOfComp1);
10397 const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
10398 int *pt=ret->getPointer();
10399 for(int i=0;i<nbOfTuple1;i++)
10400 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::modulus<int>());
10401 ret->copyStringInfoFrom(*a1);
10406 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Modulus !");//will always throw an exception
10412 * Modify \a this array so that each value becomes a modulus of division of this value by
10413 * a value of another DataArrayInt. There are 3 valid cases.
10414 * 1. The arrays have same number of tuples and components. Then each value of
10415 * \a this array is divided by the corresponding value of \a other one, i.e.:
10416 * _a_ [ i, j ] %= _other_ [ i, j ].
10417 * 2. The arrays have same number of tuples and \a other array has one component. Then
10418 * _a_ [ i, j ] %= _other_ [ i, 0 ].
10419 * 3. The arrays have same number of components and \a other array has one tuple. Then
10420 * _a_ [ i, j ] %= _a2_ [ 0, j ].
10422 * \warning No check of division by zero is performed!
10423 * \param [in] other - a divisor array.
10424 * \throw If \a other is NULL.
10425 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
10426 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
10427 * \a other has number of both tuples and components not equal to 1.
10429 void DataArrayInt::modulusEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception)
10432 throw INTERP_KERNEL::Exception("DataArrayInt::modulusEqual : input DataArrayInt instance is NULL !");
10433 const char *msg="Nb of tuples mismatch for DataArrayInt::modulusEqual !";
10434 checkAllocated(); other->checkAllocated();
10435 int nbOfTuple=getNumberOfTuples();
10436 int nbOfTuple2=other->getNumberOfTuples();
10437 int nbOfComp=getNumberOfComponents();
10438 int nbOfComp2=other->getNumberOfComponents();
10439 if(nbOfTuple==nbOfTuple2)
10441 if(nbOfComp==nbOfComp2)
10443 std::transform(begin(),end(),other->begin(),getPointer(),std::modulus<int>());
10445 else if(nbOfComp2==1)
10447 if(nbOfComp2==nbOfComp)
10449 int *ptr=getPointer();
10450 const int *ptrc=other->getConstPointer();
10451 for(int i=0;i<nbOfTuple;i++)
10452 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::modulus<int>(),*ptrc++));
10455 throw INTERP_KERNEL::Exception(msg);
10458 throw INTERP_KERNEL::Exception(msg);
10460 else if(nbOfTuple2==1)
10462 int *ptr=getPointer();
10463 const int *ptrc=other->getConstPointer();
10464 for(int i=0;i<nbOfTuple;i++)
10465 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::modulus<int>());
10468 throw INTERP_KERNEL::Exception(msg);
10473 * Returns a new DataArrayInt that is the result of pow of two given arrays. There are 3
10476 * \param [in] a1 - an array to pow up.
10477 * \param [in] a2 - another array to sum up.
10478 * \return DataArrayInt * - the new instance of DataArrayInt.
10479 * The caller is to delete this result array using decrRef() as it is no more
10481 * \throw If either \a a1 or \a a2 is NULL.
10482 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
10483 * \throw If \a a1->getNumberOfComponents() != 1 or \a a2->getNumberOfComponents() != 1.
10484 * \throw If there is a negative value in \a a2.
10486 DataArrayInt *DataArrayInt::Pow(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception)
10489 throw INTERP_KERNEL::Exception("DataArrayInt::Pow : at least one of input instances is null !");
10490 int nbOfTuple=a1->getNumberOfTuples();
10491 int nbOfTuple2=a2->getNumberOfTuples();
10492 int nbOfComp=a1->getNumberOfComponents();
10493 int nbOfComp2=a2->getNumberOfComponents();
10494 if(nbOfTuple!=nbOfTuple2)
10495 throw INTERP_KERNEL::Exception("DataArrayInt::Pow : number of tuples mismatches !");
10496 if(nbOfComp!=1 || nbOfComp2!=1)
10497 throw INTERP_KERNEL::Exception("DataArrayInt::Pow : number of components of both arrays must be equal to 1 !");
10498 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbOfTuple,1);
10499 const int *ptr1(a1->begin()),*ptr2(a2->begin());
10500 int *ptr=ret->getPointer();
10501 for(int i=0;i<nbOfTuple;i++,ptr1++,ptr2++,ptr++)
10506 for(int j=0;j<*ptr2;j++)
10512 std::ostringstream oss; oss << "DataArrayInt::Pow : on tuple #" << i << " of a2 value is < 0 (" << *ptr2 << ") !";
10513 throw INTERP_KERNEL::Exception(oss.str().c_str());
10520 * Apply pow on values of another DataArrayInt to values of \a this one.
10522 * \param [in] other - an array to pow to \a this one.
10523 * \throw If \a other is NULL.
10524 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples()
10525 * \throw If \a this->getNumberOfComponents() != 1 or \a other->getNumberOfComponents() != 1
10526 * \throw If there is a negative value in \a other.
10528 void DataArrayInt::powEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception)
10531 throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : input instance is null !");
10532 int nbOfTuple=getNumberOfTuples();
10533 int nbOfTuple2=other->getNumberOfTuples();
10534 int nbOfComp=getNumberOfComponents();
10535 int nbOfComp2=other->getNumberOfComponents();
10536 if(nbOfTuple!=nbOfTuple2)
10537 throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : number of tuples mismatches !");
10538 if(nbOfComp!=1 || nbOfComp2!=1)
10539 throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : number of components of both arrays must be equal to 1 !");
10540 int *ptr=getPointer();
10541 const int *ptrc=other->begin();
10542 for(int i=0;i<nbOfTuple;i++,ptrc++,ptr++)
10547 for(int j=0;j<*ptrc;j++)
10553 std::ostringstream oss; oss << "DataArrayInt::powEqual : on tuple #" << i << " of other value is < 0 (" << *ptrc << ") !";
10554 throw INTERP_KERNEL::Exception(oss.str().c_str());
10561 * Returns a C array which is a renumbering map in "Old to New" mode for the input array.
10562 * This map, if applied to \a start array, would make it sorted. For example, if
10563 * \a start array contents are [9,10,0,6,4,11,3,7] then the contents of the result array is
10564 * [5,6,0,3,2,7,1,4].
10565 * \param [in] start - pointer to the first element of the array for which the
10566 * permutation map is computed.
10567 * \param [in] end - pointer specifying the end of the array \a start, so that
10568 * the last value of \a start is \a end[ -1 ].
10569 * \return int * - the result permutation array that the caller is to delete as it is no
10571 * \throw If there are equal values in the input array.
10573 int *DataArrayInt::CheckAndPreparePermutation(const int *start, const int *end)
10575 std::size_t sz=std::distance(start,end);
10576 int *ret=(int *)malloc(sz*sizeof(int));
10577 int *work=new int[sz];
10578 std::copy(start,end,work);
10579 std::sort(work,work+sz);
10580 if(std::unique(work,work+sz)!=work+sz)
10584 throw INTERP_KERNEL::Exception("Some elements are equals in the specified array !");
10586 std::map<int,int> m;
10587 for(int *workPt=work;workPt!=work+sz;workPt++)
10588 m[*workPt]=(int)std::distance(work,workPt);
10590 for(const int *iter=start;iter!=end;iter++,iter2++)
10597 * Returns a new DataArrayInt containing an arithmetic progression
10598 * that is equal to the sequence returned by Python \c range(\a begin,\a end,\a step )
10600 * \param [in] begin - the start value of the result sequence.
10601 * \param [in] end - limiting value, so that every value of the result array is less than
10603 * \param [in] step - specifies the increment or decrement.
10604 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
10605 * array using decrRef() as it is no more needed.
10606 * \throw If \a step == 0.
10607 * \throw If \a end < \a begin && \a step > 0.
10608 * \throw If \a end > \a begin && \a step < 0.
10610 DataArrayInt *DataArrayInt::Range(int begin, int end, int step) throw(INTERP_KERNEL::Exception)
10612 int nbOfTuples=GetNumberOfItemGivenBESRelative(begin,end,step,"DataArrayInt::Range");
10613 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10614 ret->alloc(nbOfTuples,1);
10615 int *ptr=ret->getPointer();
10618 for(int i=begin;i<end;i+=step,ptr++)
10623 for(int i=begin;i>end;i+=step,ptr++)
10630 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
10633 void DataArrayInt::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
10635 tinyInfo.resize(2);
10638 tinyInfo[0]=getNumberOfTuples();
10639 tinyInfo[1]=getNumberOfComponents();
10649 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
10652 void DataArrayInt::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
10656 int nbOfCompo=getNumberOfComponents();
10657 tinyInfo.resize(nbOfCompo+1);
10658 tinyInfo[0]=getName();
10659 for(int i=0;i<nbOfCompo;i++)
10660 tinyInfo[i+1]=getInfoOnComponent(i);
10664 tinyInfo.resize(1);
10665 tinyInfo[0]=getName();
10670 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
10671 * This method returns if a feeding is needed.
10673 bool DataArrayInt::resizeForUnserialization(const std::vector<int>& tinyInfoI)
10675 int nbOfTuple=tinyInfoI[0];
10676 int nbOfComp=tinyInfoI[1];
10677 if(nbOfTuple!=-1 || nbOfComp!=-1)
10679 alloc(nbOfTuple,nbOfComp);
10686 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
10687 * This method returns if a feeding is needed.
10689 void DataArrayInt::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<std::string>& tinyInfoS)
10691 setName(tinyInfoS[0].c_str());
10694 int nbOfCompo=getNumberOfComponents();
10695 for(int i=0;i<nbOfCompo;i++)
10696 setInfoOnComponent(i,tinyInfoS[i+1].c_str());
10700 DataArrayIntIterator::DataArrayIntIterator(DataArrayInt *da):_da(da),_pt(0),_tuple_id(0),_nb_comp(0),_nb_tuple(0)
10705 if(_da->isAllocated())
10707 _nb_comp=da->getNumberOfComponents();
10708 _nb_tuple=da->getNumberOfTuples();
10709 _pt=da->getPointer();
10714 DataArrayIntIterator::~DataArrayIntIterator()
10720 DataArrayIntTuple *DataArrayIntIterator::nextt() throw(INTERP_KERNEL::Exception)
10722 if(_tuple_id<_nb_tuple)
10725 DataArrayIntTuple *ret=new DataArrayIntTuple(_pt,_nb_comp);
10733 DataArrayIntTuple::DataArrayIntTuple(int *pt, int nbOfComp):_pt(pt),_nb_of_compo(nbOfComp)
10737 std::string DataArrayIntTuple::repr() const throw(INTERP_KERNEL::Exception)
10739 std::ostringstream oss; oss << "(";
10740 for(int i=0;i<_nb_of_compo-1;i++)
10741 oss << _pt[i] << ", ";
10742 oss << _pt[_nb_of_compo-1] << ")";
10746 int DataArrayIntTuple::intValue() const throw(INTERP_KERNEL::Exception)
10748 if(_nb_of_compo==1)
10750 throw INTERP_KERNEL::Exception("DataArrayIntTuple::intValue : DataArrayIntTuple instance has not exactly 1 component -> Not possible to convert it into an integer !");
10754 * This method returns a newly allocated instance the caller should dealed with by a ParaMEDMEM::DataArrayInt::decrRef.
10755 * This method performs \b no copy of data. The content is only referenced using ParaMEDMEM::DataArrayInt::useArray with ownership set to \b false.
10756 * 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
10757 * \b nbOfCompo=1 and \bnbOfTuples==this->_nb_of_elem.
10759 DataArrayInt *DataArrayIntTuple::buildDAInt(int nbOfTuples, int nbOfCompo) const throw(INTERP_KERNEL::Exception)
10761 if((_nb_of_compo==nbOfCompo && nbOfTuples==1) || (_nb_of_compo==nbOfTuples && nbOfCompo==1))
10763 DataArrayInt *ret=DataArrayInt::New();
10764 ret->useExternalArrayWithRWAccess(_pt,nbOfTuples,nbOfCompo);
10769 std::ostringstream oss; oss << "DataArrayIntTuple::buildDAInt : unable to build a requested DataArrayInt instance with nbofTuple=" << nbOfTuples << " and nbOfCompo=" << nbOfCompo;
10770 oss << ".\nBecause the number of elements in this is " << _nb_of_compo << " !";
10771 throw INTERP_KERNEL::Exception(oss.str().c_str());