1 // Copyright (C) 2007-2016 CEA/DEN, EDF R&D
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 // Lesser General Public License for more details.
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
19 // Author : Anthony Geay (CEA/DEN)
21 #include "MEDCouplingMemArray.txx"
24 #include "GenMathFormulae.hxx"
25 #include "InterpKernelAutoPtr.hxx"
26 #include "InterpKernelExprParser.hxx"
35 typedef double (*MYFUNCPTR)(double);
37 using namespace MEDCoupling;
39 template class DataArrayTemplate<int>;
40 template class DataArrayTemplate<double>;
42 template<int SPACEDIM>
43 void DataArrayDouble::findCommonTuplesAlg(const double *bbox, int nbNodes, int limitNodeId, double prec, DataArrayInt *c, DataArrayInt *cI) const
45 const double *coordsPtr=getConstPointer();
46 BBTreePts<SPACEDIM,int> myTree(bbox,0,0,nbNodes,prec);
47 std::vector<bool> isDone(nbNodes);
48 for(int i=0;i<nbNodes;i++)
52 std::vector<int> intersectingElems;
53 myTree.getElementsAroundPoint(coordsPtr+i*SPACEDIM,intersectingElems);
54 if(intersectingElems.size()>1)
56 std::vector<int> commonNodes;
57 for(std::vector<int>::const_iterator it=intersectingElems.begin();it!=intersectingElems.end();it++)
61 commonNodes.push_back(*it);
64 if(!commonNodes.empty())
66 cI->pushBackSilent(cI->back()+(int)commonNodes.size()+1);
68 c->insertAtTheEnd(commonNodes.begin(),commonNodes.end());
75 template<int SPACEDIM>
76 void DataArrayDouble::FindTupleIdsNearTuplesAlg(const BBTreePts<SPACEDIM,int>& myTree, const double *pos, int nbOfTuples, double eps,
77 DataArrayInt *c, DataArrayInt *cI)
79 for(int i=0;i<nbOfTuples;i++)
81 std::vector<int> intersectingElems;
82 myTree.getElementsAroundPoint(pos+i*SPACEDIM,intersectingElems);
83 std::vector<int> commonNodes;
84 for(std::vector<int>::const_iterator it=intersectingElems.begin();it!=intersectingElems.end();it++)
85 commonNodes.push_back(*it);
86 cI->pushBackSilent(cI->back()+(int)commonNodes.size());
87 c->insertAtTheEnd(commonNodes.begin(),commonNodes.end());
91 template<int SPACEDIM>
92 void DataArrayDouble::FindClosestTupleIdAlg(const BBTreePts<SPACEDIM,int>& myTree, double dist, const double *pos, int nbOfTuples, const double *thisPt, int thisNbOfTuples, int *res)
97 for(int i=0;i<nbOfTuples;i++,p+=SPACEDIM,r++)
102 double ret=myTree.getElementsAroundPoint2(p,distOpt,elem);
103 if(ret!=std::numeric_limits<double>::max())
105 distOpt=std::max(ret,1e-4);
110 { distOpt=2*distOpt; continue; }
115 std::size_t DataArray::getHeapMemorySizeWithoutChildren() const
117 std::size_t sz1=_name.capacity();
118 std::size_t sz2=_info_on_compo.capacity();
120 for(std::vector<std::string>::const_iterator it=_info_on_compo.begin();it!=_info_on_compo.end();it++)
121 sz3+=(*it).capacity();
125 std::vector<const BigMemoryObject *> DataArray::getDirectChildrenWithNull() const
127 return std::vector<const BigMemoryObject *>();
131 * Sets the attribute \a _name of \a this array.
132 * See \ref MEDCouplingArrayBasicsName "DataArrays infos" for more information.
133 * \param [in] name - new array name
135 void DataArray::setName(const std::string& name)
141 * Copies textual data from an \a other DataArray. The copied data are
142 * - the name attribute,
143 * - the information of components.
145 * For more information on these data see \ref MEDCouplingArrayBasicsName "DataArrays infos".
147 * \param [in] other - another instance of DataArray to copy the textual data from.
148 * \throw If number of components of \a this array differs from that of the \a other.
150 void DataArray::copyStringInfoFrom(const DataArray& other)
152 if(_info_on_compo.size()!=other._info_on_compo.size())
153 throw INTERP_KERNEL::Exception("Size of arrays mismatches on copyStringInfoFrom !");
155 _info_on_compo=other._info_on_compo;
158 void DataArray::copyPartOfStringInfoFrom(const DataArray& other, const std::vector<int>& compoIds)
160 int nbOfCompoOth=other.getNumberOfComponents();
161 std::size_t newNbOfCompo=compoIds.size();
162 for(std::size_t i=0;i<newNbOfCompo;i++)
163 if(compoIds[i]>=nbOfCompoOth || compoIds[i]<0)
165 std::ostringstream oss; oss << "Specified component id is out of range (" << compoIds[i] << ") compared with nb of actual components (" << nbOfCompoOth << ")";
166 throw INTERP_KERNEL::Exception(oss.str().c_str());
168 for(std::size_t i=0;i<newNbOfCompo;i++)
169 setInfoOnComponent((int)i,other.getInfoOnComponent(compoIds[i]));
172 void DataArray::copyPartOfStringInfoFrom2(const std::vector<int>& compoIds, const DataArray& other)
174 int nbOfCompo=getNumberOfComponents();
175 std::size_t partOfCompoToSet=compoIds.size();
176 if((int)partOfCompoToSet!=other.getNumberOfComponents())
177 throw INTERP_KERNEL::Exception("Given compoIds has not the same size as number of components of given array !");
178 for(std::size_t i=0;i<partOfCompoToSet;i++)
179 if(compoIds[i]>=nbOfCompo || compoIds[i]<0)
181 std::ostringstream oss; oss << "Specified component id is out of range (" << compoIds[i] << ") compared with nb of actual components (" << nbOfCompo << ")";
182 throw INTERP_KERNEL::Exception(oss.str().c_str());
184 for(std::size_t i=0;i<partOfCompoToSet;i++)
185 setInfoOnComponent(compoIds[i],other.getInfoOnComponent((int)i));
188 bool DataArray::areInfoEqualsIfNotWhy(const DataArray& other, std::string& reason) const
190 std::ostringstream oss;
191 if(_name!=other._name)
193 oss << "Names DataArray mismatch : this name=\"" << _name << " other name=\"" << other._name << "\" !";
197 if(_info_on_compo!=other._info_on_compo)
199 oss << "Components DataArray mismatch : \nThis components=";
200 for(std::vector<std::string>::const_iterator it=_info_on_compo.begin();it!=_info_on_compo.end();it++)
201 oss << "\"" << *it << "\",";
202 oss << "\nOther components=";
203 for(std::vector<std::string>::const_iterator it=other._info_on_compo.begin();it!=other._info_on_compo.end();it++)
204 oss << "\"" << *it << "\",";
212 * Compares textual information of \a this DataArray with that of an \a other one.
213 * The compared data are
214 * - the name attribute,
215 * - the information of components.
217 * For more information on these data see \ref MEDCouplingArrayBasicsName "DataArrays infos".
218 * \param [in] other - another instance of DataArray to compare the textual data of.
219 * \return bool - \a true if the textual information is same, \a false else.
221 bool DataArray::areInfoEquals(const DataArray& other) const
224 return areInfoEqualsIfNotWhy(other,tmp);
227 void DataArray::reprWithoutNameStream(std::ostream& stream) const
229 stream << "Number of components : "<< getNumberOfComponents() << "\n";
230 stream << "Info of these components : ";
231 for(std::vector<std::string>::const_iterator iter=_info_on_compo.begin();iter!=_info_on_compo.end();iter++)
232 stream << "\"" << *iter << "\" ";
236 std::string DataArray::cppRepr(const std::string& varName) const
238 std::ostringstream ret;
239 reprCppStream(varName,ret);
244 * Sets information on all components. To know more on format of this information
245 * see \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
246 * \param [in] info - a vector of strings.
247 * \throw If size of \a info differs from the number of components of \a this.
249 void DataArray::setInfoOnComponents(const std::vector<std::string>& info)
251 if(getNumberOfComponents()!=(int)info.size())
253 std::ostringstream oss; oss << "DataArray::setInfoOnComponents : input is of size " << info.size() << " whereas number of components is equal to " << getNumberOfComponents() << " !";
254 throw INTERP_KERNEL::Exception(oss.str().c_str());
260 * This method is only a dispatcher towards DataArrayDouble::setPartOfValues3, DataArrayInt::setPartOfValues3, DataArrayChar::setPartOfValues3 depending on the true
261 * type of \a this and \a aBase.
263 * \throw If \a aBase and \a this do not have the same type.
265 * \sa DataArrayDouble::setPartOfValues3, DataArrayInt::setPartOfValues3, DataArrayChar::setPartOfValues3.
267 void DataArray::setPartOfValuesBase3(const DataArray *aBase, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
270 throw INTERP_KERNEL::Exception("DataArray::setPartOfValuesBase3 : input aBase object is NULL !");
271 DataArrayDouble *this1(dynamic_cast<DataArrayDouble *>(this));
272 DataArrayInt *this2(dynamic_cast<DataArrayInt *>(this));
273 DataArrayChar *this3(dynamic_cast<DataArrayChar *>(this));
274 const DataArrayDouble *a1(dynamic_cast<const DataArrayDouble *>(aBase));
275 const DataArrayInt *a2(dynamic_cast<const DataArrayInt *>(aBase));
276 const DataArrayChar *a3(dynamic_cast<const DataArrayChar *>(aBase));
279 this1->setPartOfValues3(a1,bgTuples,endTuples,bgComp,endComp,stepComp,strictCompoCompare);
284 this2->setPartOfValues3(a2,bgTuples,endTuples,bgComp,endComp,stepComp,strictCompoCompare);
289 this3->setPartOfValues3(a3,bgTuples,endTuples,bgComp,endComp,stepComp,strictCompoCompare);
292 throw INTERP_KERNEL::Exception("DataArray::setPartOfValuesBase3 : input aBase object and this do not have the same type !");
295 std::vector<std::string> DataArray::getVarsOnComponent() const
297 int nbOfCompo=(int)_info_on_compo.size();
298 std::vector<std::string> ret(nbOfCompo);
299 for(int i=0;i<nbOfCompo;i++)
300 ret[i]=getVarOnComponent(i);
304 std::vector<std::string> DataArray::getUnitsOnComponent() const
306 int nbOfCompo=(int)_info_on_compo.size();
307 std::vector<std::string> ret(nbOfCompo);
308 for(int i=0;i<nbOfCompo;i++)
309 ret[i]=getUnitOnComponent(i);
314 * Returns information on a component specified by an index.
315 * To know more on format of this information
316 * see \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
317 * \param [in] i - the index (zero based) of the component of interest.
318 * \return std::string - a string containing the information on \a i-th component.
319 * \throw If \a i is not a valid component index.
321 std::string DataArray::getInfoOnComponent(int i) const
323 if(i<(int)_info_on_compo.size() && i>=0)
324 return _info_on_compo[i];
327 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();
328 throw INTERP_KERNEL::Exception(oss.str().c_str());
333 * Returns the var part of the full information of the \a i-th component.
334 * For example, if \c getInfoOnComponent(0) returns "SIGXY [N/m^2]", then
335 * \c getVarOnComponent(0) returns "SIGXY".
336 * If a unit part of information is not detected by presence of
337 * two square brackets, then the full information is returned.
338 * To read more about the component information format, see
339 * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
340 * \param [in] i - the index (zero based) of the component of interest.
341 * \return std::string - a string containing the var information, or the full info.
342 * \throw If \a i is not a valid component index.
344 std::string DataArray::getVarOnComponent(int i) const
346 if(i<(int)_info_on_compo.size() && i>=0)
348 return GetVarNameFromInfo(_info_on_compo[i]);
352 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();
353 throw INTERP_KERNEL::Exception(oss.str().c_str());
358 * Returns the unit part of the full information of the \a i-th component.
359 * For example, if \c getInfoOnComponent(0) returns "SIGXY [ N/m^2]", then
360 * \c getUnitOnComponent(0) returns " N/m^2".
361 * If a unit part of information is not detected by presence of
362 * two square brackets, then an empty string is returned.
363 * To read more about the component information format, see
364 * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
365 * \param [in] i - the index (zero based) of the component of interest.
366 * \return std::string - a string containing the unit information, if any, or "".
367 * \throw If \a i is not a valid component index.
369 std::string DataArray::getUnitOnComponent(int i) const
371 if(i<(int)_info_on_compo.size() && i>=0)
373 return GetUnitFromInfo(_info_on_compo[i]);
377 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();
378 throw INTERP_KERNEL::Exception(oss.str().c_str());
383 * Returns the var part of the full component information.
384 * For example, if \a info == "SIGXY [N/m^2]", then this method returns "SIGXY".
385 * If a unit part of information is not detected by presence of
386 * two square brackets, then the whole \a info is returned.
387 * To read more about the component information format, see
388 * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
389 * \param [in] info - the full component information.
390 * \return std::string - a string containing only var information, or the \a info.
392 std::string DataArray::GetVarNameFromInfo(const std::string& info)
394 std::size_t p1=info.find_last_of('[');
395 std::size_t p2=info.find_last_of(']');
396 if(p1==std::string::npos || p2==std::string::npos)
401 return std::string();
402 std::size_t p3=info.find_last_not_of(' ',p1-1);
403 return info.substr(0,p3+1);
407 * Returns the unit part of the full component information.
408 * For example, if \a info == "SIGXY [ N/m^2]", then this method returns " N/m^2".
409 * If a unit part of information is not detected by presence of
410 * two square brackets, then an empty string is returned.
411 * To read more about the component information format, see
412 * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
413 * \param [in] info - the full component information.
414 * \return std::string - a string containing only unit information, if any, or "".
416 std::string DataArray::GetUnitFromInfo(const std::string& info)
418 std::size_t p1=info.find_last_of('[');
419 std::size_t p2=info.find_last_of(']');
420 if(p1==std::string::npos || p2==std::string::npos)
421 return std::string();
423 return std::string();
424 return info.substr(p1+1,p2-p1-1);
428 * This method put in info format the result of the merge of \a var and \a unit.
429 * The standard format for that is "var [unit]".
430 * Inversely you can retrieve the var part or the unit part of info string using resp. GetVarNameFromInfo and GetUnitFromInfo.
432 std::string DataArray::BuildInfoFromVarAndUnit(const std::string& var, const std::string& unit)
434 std::ostringstream oss;
435 oss << var << " [" << unit << "]";
439 std::string DataArray::GetAxisTypeRepr(MEDCouplingAxisType at)
444 return std::string("AX_CART");
446 return std::string("AX_CYL");
448 return std::string("AX_SPHER");
450 throw INTERP_KERNEL::Exception("DataArray::GetAxisTypeRepr : unrecognized axis type enum !");
455 * Returns a new DataArray by concatenating all given arrays, so that (1) the number
456 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
457 * the number of component in the result array is same as that of each of given arrays.
458 * Info on components is copied from the first of the given arrays. Number of components
459 * in the given arrays must be the same.
460 * \param [in] arrs - a sequence of arrays to include in the result array. All arrays must have the same type.
461 * \return DataArray * - the new instance of DataArray (that can be either DataArrayInt, DataArrayDouble, DataArrayChar).
462 * The caller is to delete this result array using decrRef() as it is no more
464 * \throw If all arrays within \a arrs are NULL.
465 * \throw If all not null arrays in \a arrs have not the same type.
466 * \throw If getNumberOfComponents() of arrays within \a arrs.
468 DataArray *DataArray::Aggregate(const std::vector<const DataArray *>& arrs)
470 std::vector<const DataArray *> arr2;
471 for(std::vector<const DataArray *>::const_iterator it=arrs.begin();it!=arrs.end();it++)
475 throw INTERP_KERNEL::Exception("DataArray::Aggregate : only null instance in input vector !");
476 std::vector<const DataArrayDouble *> arrd;
477 std::vector<const DataArrayInt *> arri;
478 std::vector<const DataArrayChar *> arrc;
479 for(std::vector<const DataArray *>::const_iterator it=arr2.begin();it!=arr2.end();it++)
481 const DataArrayDouble *a=dynamic_cast<const DataArrayDouble *>(*it);
483 { arrd.push_back(a); continue; }
484 const DataArrayInt *b=dynamic_cast<const DataArrayInt *>(*it);
486 { arri.push_back(b); continue; }
487 const DataArrayChar *c=dynamic_cast<const DataArrayChar *>(*it);
489 { arrc.push_back(c); continue; }
490 throw INTERP_KERNEL::Exception("DataArray::Aggregate : presence of not null instance in inuput that is not in [DataArrayDouble, DataArrayInt, DataArrayChar] !");
492 if(arr2.size()==arrd.size())
493 return DataArrayDouble::Aggregate(arrd);
494 if(arr2.size()==arri.size())
495 return DataArrayInt::Aggregate(arri);
496 if(arr2.size()==arrc.size())
497 return DataArrayChar::Aggregate(arrc);
498 throw INTERP_KERNEL::Exception("DataArray::Aggregate : all input arrays must have the same type !");
502 * Sets information on a component specified by an index.
503 * To know more on format of this information
504 * see \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
505 * \warning Don't pass NULL as \a info!
506 * \param [in] i - the index (zero based) of the component of interest.
507 * \param [in] info - the string containing the information.
508 * \throw If \a i is not a valid component index.
510 void DataArray::setInfoOnComponent(int i, const std::string& info)
512 if(i<(int)_info_on_compo.size() && i>=0)
513 _info_on_compo[i]=info;
516 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();
517 throw INTERP_KERNEL::Exception(oss.str().c_str());
522 * Sets information on all components. This method can change number of components
523 * at certain conditions; if the conditions are not respected, an exception is thrown.
524 * The number of components can be changed in \a this only if \a this is not allocated.
525 * The condition of number of components must not be changed.
527 * To know more on format of the component information see
528 * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
529 * \param [in] info - a vector of component infos.
530 * \throw If \a this->getNumberOfComponents() != \a info.size() && \a this->isAllocated()
532 void DataArray::setInfoAndChangeNbOfCompo(const std::vector<std::string>& info)
534 if(getNumberOfComponents()!=(int)info.size())
540 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 !";
541 throw INTERP_KERNEL::Exception(oss.str().c_str());
548 void DataArray::checkNbOfTuples(int nbOfTuples, const std::string& msg) const
550 if(getNumberOfTuples()!=nbOfTuples)
552 std::ostringstream oss; oss << msg << " : mismatch number of tuples : expected " << nbOfTuples << " having " << getNumberOfTuples() << " !";
553 throw INTERP_KERNEL::Exception(oss.str().c_str());
557 void DataArray::checkNbOfComps(int nbOfCompo, const std::string& msg) const
559 if(getNumberOfComponents()!=nbOfCompo)
561 std::ostringstream oss; oss << msg << " : mismatch number of components : expected " << nbOfCompo << " having " << getNumberOfComponents() << " !";
562 throw INTERP_KERNEL::Exception(oss.str().c_str());
566 void DataArray::checkNbOfElems(std::size_t nbOfElems, const std::string& msg) const
568 if(getNbOfElems()!=nbOfElems)
570 std::ostringstream oss; oss << msg << " : mismatch number of elems : Expected " << nbOfElems << " having " << getNbOfElems() << " !";
571 throw INTERP_KERNEL::Exception(oss.str().c_str());
575 void DataArray::checkNbOfTuplesAndComp(const DataArray& other, const std::string& msg) const
577 if(getNumberOfTuples()!=other.getNumberOfTuples())
579 std::ostringstream oss; oss << msg << " : mismatch number of tuples : expected " << other.getNumberOfTuples() << " having " << getNumberOfTuples() << " !";
580 throw INTERP_KERNEL::Exception(oss.str().c_str());
582 if(getNumberOfComponents()!=other.getNumberOfComponents())
584 std::ostringstream oss; oss << msg << " : mismatch number of components : expected " << other.getNumberOfComponents() << " having " << getNumberOfComponents() << " !";
585 throw INTERP_KERNEL::Exception(oss.str().c_str());
589 void DataArray::checkNbOfTuplesAndComp(int nbOfTuples, int nbOfCompo, const std::string& msg) const
591 checkNbOfTuples(nbOfTuples,msg);
592 checkNbOfComps(nbOfCompo,msg);
596 * Simply this method checks that \b value is in [0,\b ref).
598 void DataArray::CheckValueInRange(int ref, int value, const std::string& msg)
600 if(value<0 || value>=ref)
602 std::ostringstream oss; oss << "DataArray::CheckValueInRange : " << msg << " ! Expected in range [0," << ref << "[ having " << value << " !";
603 throw INTERP_KERNEL::Exception(oss.str().c_str());
608 * This method checks that [\b start, \b end) is compliant with ref length \b value.
609 * typicaly start in [0,\b value) and end in [0,\b value). If value==start and start==end, it is supported.
611 void DataArray::CheckValueInRangeEx(int value, int start, int end, const std::string& msg)
613 if(start<0 || start>=value)
615 if(value!=start || end!=start)
617 std::ostringstream oss; oss << "DataArray::CheckValueInRangeEx : " << msg << " ! Expected start " << start << " of input range, in [0," << value << "[ !";
618 throw INTERP_KERNEL::Exception(oss.str().c_str());
621 if(end<0 || end>value)
623 std::ostringstream oss; oss << "DataArray::CheckValueInRangeEx : " << msg << " ! Expected end " << end << " of input range, in [0," << value << "] !";
624 throw INTERP_KERNEL::Exception(oss.str().c_str());
628 void DataArray::CheckClosingParInRange(int ref, int value, const std::string& msg)
630 if(value<0 || value>ref)
632 std::ostringstream oss; oss << "DataArray::CheckClosingParInRange : " << msg << " ! Expected input range in [0," << ref << "] having closing open parenthesis " << value << " !";
633 throw INTERP_KERNEL::Exception(oss.str().c_str());
638 * 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,
639 * typically it is a whole slice of tuples of DataArray or cells, nodes of a mesh...
641 * The input \a sliceId should be an id in [0, \a nbOfSlices) that specifies the slice of work.
643 * \param [in] start - the start of the input slice of the whole work to perform splitted into slices.
644 * \param [in] stop - the stop of the input slice of the whole work to perform splitted into slices.
645 * \param [in] step - the step (that can be <0) of the input slice of the whole work to perform splitted into slices.
646 * \param [in] sliceId - the slice id considered
647 * \param [in] nbOfSlices - the number of slices (typically the number of cores on which the work is expected to be sliced)
648 * \param [out] startSlice - the start of the slice considered
649 * \param [out] stopSlice - the stop of the slice consided
651 * \throw If \a step == 0
652 * \throw If \a nbOfSlices not > 0
653 * \throw If \a sliceId not in [0,nbOfSlices)
655 void DataArray::GetSlice(int start, int stop, int step, int sliceId, int nbOfSlices, int& startSlice, int& stopSlice)
659 std::ostringstream oss; oss << "DataArray::GetSlice : nbOfSlices (" << nbOfSlices << ") must be > 0 !";
660 throw INTERP_KERNEL::Exception(oss.str().c_str());
662 if(sliceId<0 || sliceId>=nbOfSlices)
664 std::ostringstream oss; oss << "DataArray::GetSlice : sliceId (" << nbOfSlices << ") must be in [0 , nbOfSlices (" << nbOfSlices << ") ) !";
665 throw INTERP_KERNEL::Exception(oss.str().c_str());
667 int nbElems=GetNumberOfItemGivenBESRelative(start,stop,step,"DataArray::GetSlice");
668 int minNbOfElemsPerSlice=nbElems/nbOfSlices;
669 startSlice=start+minNbOfElemsPerSlice*step*sliceId;
670 if(sliceId<nbOfSlices-1)
671 stopSlice=start+minNbOfElemsPerSlice*step*(sliceId+1);
676 int DataArray::GetNumberOfItemGivenBES(int begin, int end, int step, const std::string& msg)
680 std::ostringstream oss; oss << msg << " : end before begin !";
681 throw INTERP_KERNEL::Exception(oss.str().c_str());
687 std::ostringstream oss; oss << msg << " : invalid step should be > 0 !";
688 throw INTERP_KERNEL::Exception(oss.str().c_str());
690 return (end-1-begin)/step+1;
693 int DataArray::GetNumberOfItemGivenBESRelative(int begin, int end, int step, const std::string& msg)
696 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBES : step=0 is not allowed !");
697 if(end<begin && step>0)
699 std::ostringstream oss; oss << msg << " : end before begin whereas step is positive !";
700 throw INTERP_KERNEL::Exception(oss.str().c_str());
702 if(begin<end && step<0)
704 std::ostringstream oss; oss << msg << " : invalid step should be > 0 !";
705 throw INTERP_KERNEL::Exception(oss.str().c_str());
708 return (std::max(begin,end)-1-std::min(begin,end))/std::abs(step)+1;
713 int DataArray::GetPosOfItemGivenBESRelativeNoThrow(int value, int begin, int end, int step)
719 if(begin<=value && value<end)
721 if((value-begin)%step==0)
722 return (value-begin)/step;
731 if(begin>=value && value>end)
733 if((begin-value)%(-step)==0)
734 return (begin-value)/(-step);
747 * Returns a new instance of DataArrayDouble. The caller is to delete this array
748 * using decrRef() as it is no more needed.
750 DataArrayDouble *DataArrayDouble::New()
752 return new DataArrayDouble;
756 * Returns the only one value in \a this, if and only if number of elements
757 * (nb of tuples * nb of components) is equal to 1, and that \a this is allocated.
758 * \return double - the sole value stored in \a this array.
759 * \throw If at least one of conditions stated above is not fulfilled.
761 double DataArrayDouble::doubleValue() const
765 if(getNbOfElems()==1)
767 return *getConstPointer();
770 throw INTERP_KERNEL::Exception("DataArrayDouble::doubleValue : DataArrayDouble instance is allocated but number of elements is not equal to 1 !");
773 throw INTERP_KERNEL::Exception("DataArrayDouble::doubleValue : DataArrayDouble instance is not allocated !");
777 * Returns a full copy of \a this. For more info on copying data arrays see
778 * \ref MEDCouplingArrayBasicsCopyDeep.
779 * \return DataArrayDouble * - a new instance of DataArrayDouble. The caller is to
780 * delete this array using decrRef() as it is no more needed.
782 DataArrayDouble *DataArrayDouble::deepCopy() const
784 return new DataArrayDouble(*this);
788 * Returns either a \a deep or \a shallow copy of this array. For more info see
789 * \ref MEDCouplingArrayBasicsCopyDeep and \ref MEDCouplingArrayBasicsCopyShallow.
790 * \param [in] dCpy - if \a true, a deep copy is returned, else, a shallow one.
791 * \return DataArrayDouble * - either a new instance of DataArrayDouble (if \a dCpy
792 * == \a true) or \a this instance (if \a dCpy == \a false).
794 DataArrayDouble *DataArrayDouble::performCopyOrIncrRef(bool dCpy) const
801 return const_cast<DataArrayDouble *>(this);
806 * Assign zero to all values in \a this array. To know more on filling arrays see
807 * \ref MEDCouplingArrayFill.
808 * \throw If \a this is not allocated.
810 void DataArrayDouble::fillWithZero()
816 * Set all values in \a this array so that the i-th element equals to \a init + i
817 * (i starts from zero). To know more on filling arrays see \ref MEDCouplingArrayFill.
818 * \param [in] init - value to assign to the first element of array.
819 * \throw If \a this->getNumberOfComponents() != 1
820 * \throw If \a this is not allocated.
822 void DataArrayDouble::iota(double init)
825 if(getNumberOfComponents()!=1)
826 throw INTERP_KERNEL::Exception("DataArrayDouble::iota : works only for arrays with only one component, you can call 'rearrange' method before !");
827 double *ptr=getPointer();
828 int ntuples=getNumberOfTuples();
829 for(int i=0;i<ntuples;i++)
830 ptr[i]=init+double(i);
835 * Checks if all values in \a this array are equal to \a val at precision \a eps.
836 * \param [in] val - value to check equality of array values to.
837 * \param [in] eps - precision to check the equality.
838 * \return bool - \a true if all values are in range (_val_ - _eps_; _val_ + _eps_),
840 * \throw If \a this->getNumberOfComponents() != 1
841 * \throw If \a this is not allocated.
843 bool DataArrayDouble::isUniform(double val, double eps) const
846 if(getNumberOfComponents()!=1)
847 throw INTERP_KERNEL::Exception("DataArrayDouble::isUniform : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
848 int nbOfTuples=getNumberOfTuples();
849 const double *w=getConstPointer();
850 const double *end2=w+nbOfTuples;
851 const double vmin=val-eps;
852 const double vmax=val+eps;
854 if(*w<vmin || *w>vmax)
860 * Checks that \a this array is consistently **increasing** or **decreasing** in value,
861 * with at least absolute difference value of |\a eps| at each step.
862 * If not an exception is thrown.
863 * \param [in] increasing - if \a true, the array values should be increasing.
864 * \param [in] eps - minimal absolute difference between the neighbor values at which
865 * the values are considered different.
866 * \throw If sequence of values is not strictly monotonic in agreement with \a
868 * \throw If \a this->getNumberOfComponents() != 1.
869 * \throw If \a this is not allocated.
871 void DataArrayDouble::checkMonotonic(bool increasing, double eps) const
873 if(!isMonotonic(increasing,eps))
876 throw INTERP_KERNEL::Exception("DataArrayDouble::checkMonotonic : 'this' is not INCREASING monotonic !");
878 throw INTERP_KERNEL::Exception("DataArrayDouble::checkMonotonic : 'this' is not DECREASING monotonic !");
883 * Checks that \a this array is consistently **increasing** or **decreasing** in value,
884 * with at least absolute difference value of |\a eps| at each step.
885 * \param [in] increasing - if \a true, array values should be increasing.
886 * \param [in] eps - minimal absolute difference between the neighbor values at which
887 * the values are considered different.
888 * \return bool - \a true if values change in accordance with \a increasing arg.
889 * \throw If \a this->getNumberOfComponents() != 1.
890 * \throw If \a this is not allocated.
892 bool DataArrayDouble::isMonotonic(bool increasing, double eps) const
895 if(getNumberOfComponents()!=1)
896 throw INTERP_KERNEL::Exception("DataArrayDouble::isMonotonic : only supported with 'this' array with ONE component !");
897 int nbOfElements=getNumberOfTuples();
898 const double *ptr=getConstPointer();
902 double absEps=fabs(eps);
905 for(int i=1;i<nbOfElements;i++)
907 if(ptr[i]<(ref+absEps))
915 for(int i=1;i<nbOfElements;i++)
917 if(ptr[i]>(ref-absEps))
926 * Returns a textual and human readable representation of \a this instance of
927 * DataArrayDouble. This text is shown when a DataArrayDouble is printed in Python.
928 * \return std::string - text describing \a this DataArrayDouble.
930 * \sa reprNotTooLong, reprZip
932 std::string DataArrayDouble::repr() const
934 std::ostringstream ret;
939 std::string DataArrayDouble::reprZip() const
941 std::ostringstream ret;
947 * This method is close to repr method except that when \a this has more than 1000 tuples, all tuples are not
948 * printed out to avoid to consume too much space in interpretor.
951 std::string DataArrayDouble::reprNotTooLong() const
953 std::ostringstream ret;
954 reprNotTooLongStream(ret);
958 void DataArrayDouble::writeVTK(std::ostream& ofs, int indent, const std::string& nameInFile, DataArrayByte *byteArr) const
960 static const char SPACE[4]={' ',' ',' ',' '};
962 std::string idt(indent,' ');
964 ofs << idt << "<DataArray type=\"Float32\" Name=\"" << nameInFile << "\" NumberOfComponents=\"" << getNumberOfComponents() << "\"";
966 bool areAllEmpty(true);
967 for(std::vector<std::string>::const_iterator it=_info_on_compo.begin();it!=_info_on_compo.end();it++)
971 for(std::size_t i=0;i<_info_on_compo.size();i++)
972 ofs << " ComponentName" << i << "=\"" << _info_on_compo[i] << "\"";
976 ofs << " format=\"appended\" offset=\"" << byteArr->getNumberOfTuples() << "\">";
977 INTERP_KERNEL::AutoPtr<float> tmp(new float[getNbOfElems()]);
979 // to make Visual C++ happy : instead of std::copy(begin(),end(),(float *)tmp);
980 for(const double *src=begin();src!=end();src++,pt++)
982 const char *data(reinterpret_cast<const char *>((float *)tmp));
983 std::size_t sz(getNbOfElems()*sizeof(float));
984 byteArr->insertAtTheEnd(data,data+sz);
985 byteArr->insertAtTheEnd(SPACE,SPACE+4);
989 ofs << " RangeMin=\"" << getMinValueInArray() << "\" RangeMax=\"" << getMaxValueInArray() << "\" format=\"ascii\">\n" << idt;
990 std::copy(begin(),end(),std::ostream_iterator<double>(ofs," "));
992 ofs << std::endl << idt << "</DataArray>\n";
995 void DataArrayDouble::reprStream(std::ostream& stream) const
997 stream << "Name of double array : \"" << _name << "\"\n";
998 reprWithoutNameStream(stream);
1001 void DataArrayDouble::reprZipStream(std::ostream& stream) const
1003 stream << "Name of double array : \"" << _name << "\"\n";
1004 reprZipWithoutNameStream(stream);
1007 void DataArrayDouble::reprNotTooLongStream(std::ostream& stream) const
1009 stream << "Name of double array : \"" << _name << "\"\n";
1010 reprNotTooLongWithoutNameStream(stream);
1013 void DataArrayDouble::reprWithoutNameStream(std::ostream& stream) const
1015 DataArray::reprWithoutNameStream(stream);
1016 stream.precision(17);
1017 _mem.repr(getNumberOfComponents(),stream);
1020 void DataArrayDouble::reprZipWithoutNameStream(std::ostream& stream) const
1022 DataArray::reprWithoutNameStream(stream);
1023 stream.precision(17);
1024 _mem.reprZip(getNumberOfComponents(),stream);
1027 void DataArrayDouble::reprNotTooLongWithoutNameStream(std::ostream& stream) const
1029 DataArray::reprWithoutNameStream(stream);
1030 stream.precision(17);
1031 _mem.reprNotTooLong(getNumberOfComponents(),stream);
1034 void DataArrayDouble::reprCppStream(const std::string& varName, std::ostream& stream) const
1036 int nbTuples=getNumberOfTuples(),nbComp=getNumberOfComponents();
1037 const double *data=getConstPointer();
1038 stream.precision(17);
1039 stream << "DataArrayDouble *" << varName << "=DataArrayDouble::New();" << std::endl;
1040 if(nbTuples*nbComp>=1)
1042 stream << "const double " << varName << "Data[" << nbTuples*nbComp << "]={";
1043 std::copy(data,data+nbTuples*nbComp-1,std::ostream_iterator<double>(stream,","));
1044 stream << data[nbTuples*nbComp-1] << "};" << std::endl;
1045 stream << varName << "->useArray(" << varName << "Data,false,CPP_DEALLOC," << nbTuples << "," << nbComp << ");" << std::endl;
1048 stream << varName << "->alloc(" << nbTuples << "," << nbComp << ");" << std::endl;
1049 stream << varName << "->setName(\"" << getName() << "\");" << std::endl;
1053 * Method that gives a quick overvien of \a this for python.
1055 void DataArrayDouble::reprQuickOverview(std::ostream& stream) const
1057 static const std::size_t MAX_NB_OF_BYTE_IN_REPR=300;
1058 stream << "DataArrayDouble C++ instance at " << this << ". ";
1061 int nbOfCompo=(int)_info_on_compo.size();
1064 int nbOfTuples=getNumberOfTuples();
1065 stream << "Number of tuples : " << nbOfTuples << ". Number of components : " << nbOfCompo << "." << std::endl;
1066 reprQuickOverviewData(stream,MAX_NB_OF_BYTE_IN_REPR);
1069 stream << "Number of components : 0.";
1072 stream << "*** No data allocated ****";
1075 void DataArrayDouble::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const
1077 const double *data=begin();
1078 int nbOfTuples=getNumberOfTuples();
1079 int nbOfCompo=(int)_info_on_compo.size();
1080 std::ostringstream oss2; oss2 << "[";
1082 std::string oss2Str(oss2.str());
1083 bool isFinished=true;
1084 for(int i=0;i<nbOfTuples && isFinished;i++)
1089 for(int j=0;j<nbOfCompo;j++,data++)
1092 if(j!=nbOfCompo-1) oss2 << ", ";
1098 if(i!=nbOfTuples-1) oss2 << ", ";
1099 std::string oss3Str(oss2.str());
1100 if(oss3Str.length()<maxNbOfByteInRepr)
1112 * Equivalent to DataArrayDouble::isEqual except that if false the reason of
1113 * mismatch is given.
1115 * \param [in] other the instance to be compared with \a this
1116 * \param [in] prec the precision to compare numeric data of the arrays.
1117 * \param [out] reason In case of inequality returns the reason.
1118 * \sa DataArrayDouble::isEqual
1120 bool DataArrayDouble::isEqualIfNotWhy(const DataArrayDouble& other, double prec, std::string& reason) const
1122 if(!areInfoEqualsIfNotWhy(other,reason))
1124 return _mem.isEqual(other._mem,prec,reason);
1128 * Checks if \a this and another DataArrayDouble are fully equal. For more info see
1129 * \ref MEDCouplingArrayBasicsCompare.
1130 * \param [in] other - an instance of DataArrayDouble to compare with \a this one.
1131 * \param [in] prec - precision value to compare numeric data of the arrays.
1132 * \return bool - \a true if the two arrays are equal, \a false else.
1134 bool DataArrayDouble::isEqual(const DataArrayDouble& other, double prec) const
1137 return isEqualIfNotWhy(other,prec,tmp);
1141 * Checks if values of \a this and another DataArrayDouble are equal. For more info see
1142 * \ref MEDCouplingArrayBasicsCompare.
1143 * \param [in] other - an instance of DataArrayDouble to compare with \a this one.
1144 * \param [in] prec - precision value to compare numeric data of the arrays.
1145 * \return bool - \a true if the values of two arrays are equal, \a false else.
1147 bool DataArrayDouble::isEqualWithoutConsideringStr(const DataArrayDouble& other, double prec) const
1150 return _mem.isEqual(other._mem,prec,tmp);
1154 * Creates a new DataArrayInt and assigns all (textual and numerical) data of \a this
1155 * array to the new one.
1156 * \return DataArrayInt * - the new instance of DataArrayInt.
1158 DataArrayInt *DataArrayDouble::convertToIntArr() const
1160 DataArrayInt *ret=DataArrayInt::New();
1161 ret->alloc(getNumberOfTuples(),getNumberOfComponents());
1162 int *dest=ret->getPointer();
1163 // to make Visual C++ happy : instead of std::size_t nbOfVals=getNbOfElems(); std::copy(src,src+nbOfVals,dest);
1164 for(const double *src=begin();src!=end();src++,dest++)
1166 ret->copyStringInfoFrom(*this);
1171 * Returns a new DataArrayDouble holding the same values as \a this array but differently
1172 * arranged in memory. If \a this array holds 2 components of 3 values:
1173 * \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$, then the result array holds these values arranged
1174 * as follows: \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$.
1175 * \warning Do not confuse this method with transpose()!
1176 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1177 * is to delete using decrRef() as it is no more needed.
1178 * \throw If \a this is not allocated.
1180 DataArrayDouble *DataArrayDouble::fromNoInterlace() const
1183 throw INTERP_KERNEL::Exception("DataArrayDouble::fromNoInterlace : Not defined array !");
1184 double *tab=_mem.fromNoInterlace(getNumberOfComponents());
1185 DataArrayDouble *ret=DataArrayDouble::New();
1186 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
1191 * Returns a new DataArrayDouble holding the same values as \a this array but differently
1192 * arranged in memory. If \a this array holds 2 components of 3 values:
1193 * \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$, then the result array holds these values arranged
1194 * as follows: \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$.
1195 * \warning Do not confuse this method with transpose()!
1196 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1197 * is to delete using decrRef() as it is no more needed.
1198 * \throw If \a this is not allocated.
1200 DataArrayDouble *DataArrayDouble::toNoInterlace() const
1203 throw INTERP_KERNEL::Exception("DataArrayDouble::toNoInterlace : Not defined array !");
1204 double *tab=_mem.toNoInterlace(getNumberOfComponents());
1205 DataArrayDouble *ret=DataArrayDouble::New();
1206 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
1211 * Appends components of another array to components of \a this one, tuple by tuple.
1212 * So that the number of tuples of \a this array remains the same and the number of
1213 * components increases.
1214 * \param [in] other - the DataArrayDouble to append to \a this one.
1215 * \throw If \a this is not allocated.
1216 * \throw If \a this and \a other arrays have different number of tuples.
1218 * \if ENABLE_EXAMPLES
1219 * \ref cpp_mcdataarraydouble_meldwith "Here is a C++ example".
1221 * \ref py_mcdataarraydouble_meldwith "Here is a Python example".
1224 void DataArrayDouble::meldWith(const DataArrayDouble *other)
1227 other->checkAllocated();
1228 int nbOfTuples=getNumberOfTuples();
1229 if(nbOfTuples!=other->getNumberOfTuples())
1230 throw INTERP_KERNEL::Exception("DataArrayDouble::meldWith : mismatch of number of tuples !");
1231 int nbOfComp1=getNumberOfComponents();
1232 int nbOfComp2=other->getNumberOfComponents();
1233 double *newArr=(double *)malloc((nbOfTuples*(nbOfComp1+nbOfComp2))*sizeof(double));
1235 const double *inp1=getConstPointer();
1236 const double *inp2=other->getConstPointer();
1237 for(int i=0;i<nbOfTuples;i++,inp1+=nbOfComp1,inp2+=nbOfComp2)
1239 w=std::copy(inp1,inp1+nbOfComp1,w);
1240 w=std::copy(inp2,inp2+nbOfComp2,w);
1242 useArray(newArr,true,C_DEALLOC,nbOfTuples,nbOfComp1+nbOfComp2);
1243 std::vector<int> compIds(nbOfComp2);
1244 for(int i=0;i<nbOfComp2;i++)
1245 compIds[i]=nbOfComp1+i;
1246 copyPartOfStringInfoFrom2(compIds,*other);
1250 * This method checks that all tuples in \a other are in \a this.
1251 * If true, the output param \a tupleIds contains the tuples ids of \a this that correspond to tupes in \a this.
1252 * 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.
1254 * \param [in] other - the array having the same number of components than \a this.
1255 * \param [out] tupleIds - the tuple ids containing the same number of tuples than \a other has.
1256 * \sa DataArrayDouble::findCommonTuples
1258 bool DataArrayDouble::areIncludedInMe(const DataArrayDouble *other, double prec, DataArrayInt *&tupleIds) const
1261 throw INTERP_KERNEL::Exception("DataArrayDouble::areIncludedInMe : input array is NULL !");
1262 checkAllocated(); other->checkAllocated();
1263 if(getNumberOfComponents()!=other->getNumberOfComponents())
1264 throw INTERP_KERNEL::Exception("DataArrayDouble::areIncludedInMe : the number of components does not match !");
1265 MCAuto<DataArrayDouble> a=DataArrayDouble::Aggregate(this,other);
1266 DataArrayInt *c=0,*ci=0;
1267 a->findCommonTuples(prec,getNumberOfTuples(),c,ci);
1268 MCAuto<DataArrayInt> cSafe(c),ciSafe(ci);
1269 int newNbOfTuples=-1;
1270 MCAuto<DataArrayInt> ids=DataArrayInt::ConvertIndexArrayToO2N(a->getNumberOfTuples(),c->begin(),ci->begin(),ci->end(),newNbOfTuples);
1271 MCAuto<DataArrayInt> ret1=ids->selectByTupleIdSafeSlice(getNumberOfTuples(),a->getNumberOfTuples(),1);
1272 tupleIds=ret1.retn();
1273 return newNbOfTuples==getNumberOfTuples();
1277 * Searches for tuples coincident within \a prec tolerance. Each tuple is considered
1278 * as coordinates of a point in getNumberOfComponents()-dimensional space. The
1279 * distance separating two points is computed with the infinite norm.
1281 * Indices of coincident tuples are stored in output arrays.
1282 * A pair of arrays (\a comm, \a commIndex) is called "Surjective Format 2".
1284 * This method is typically used by MEDCouplingPointSet::findCommonNodes() and
1285 * MEDCouplingUMesh::mergeNodes().
1286 * \param [in] prec - minimal absolute distance between two tuples (infinite norm) at which they are
1287 * considered not coincident.
1288 * \param [in] limitTupleId - limit tuple id. If all tuples within a group of coincident
1289 * tuples have id strictly lower than \a limitTupleId then they are not returned.
1290 * \param [out] comm - the array holding ids (== indices) of coincident tuples.
1291 * \a comm->getNumberOfComponents() == 1.
1292 * \a comm->getNumberOfTuples() == \a commIndex->back().
1293 * \param [out] commIndex - the array dividing all indices stored in \a comm into
1294 * groups of (indices of) coincident tuples. Its every value is a tuple
1295 * index where a next group of tuples begins. For example the second
1296 * group of tuples in \a comm is described by following range of indices:
1297 * [ \a commIndex[1], \a commIndex[2] ). \a commIndex->getNumberOfTuples()-1
1298 * gives the number of groups of coincident tuples.
1299 * \throw If \a this is not allocated.
1300 * \throw If the number of components is not in [1,2,3,4].
1302 * \if ENABLE_EXAMPLES
1303 * \ref cpp_mcdataarraydouble_findcommontuples "Here is a C++ example".
1305 * \ref py_mcdataarraydouble_findcommontuples "Here is a Python example".
1307 * \sa DataArrayInt::ConvertIndexArrayToO2N(), DataArrayDouble::areIncludedInMe
1309 void DataArrayDouble::findCommonTuples(double prec, int limitTupleId, DataArrayInt *&comm, DataArrayInt *&commIndex) const
1312 int nbOfCompo=getNumberOfComponents();
1313 if ((nbOfCompo<1) || (nbOfCompo>4)) //test before work
1314 throw INTERP_KERNEL::Exception("DataArrayDouble::findCommonTuples : Unexpected spacedim of coords. Must be 1, 2, 3 or 4.");
1316 int nbOfTuples=getNumberOfTuples();
1318 MCAuto<DataArrayInt> c(DataArrayInt::New()),cI(DataArrayInt::New()); c->alloc(0,1); cI->pushBackSilent(0);
1322 findCommonTuplesAlg<4>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
1325 findCommonTuplesAlg<3>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
1328 findCommonTuplesAlg<2>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
1331 findCommonTuplesAlg<1>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
1334 throw INTERP_KERNEL::Exception("DataArrayDouble::findCommonTuples : nb of components managed are 1,2,3 and 4 ! not implemented for other number of components !");
1337 commIndex=cI.retn();
1342 * \param [in] nbTimes specifies the nb of times each tuples in \a this will be duplicated contiguouly in returned DataArrayDouble instance.
1343 * \a nbTimes should be at least equal to 1.
1344 * \return a newly allocated DataArrayDouble having one component and number of tuples equal to \a nbTimes * \c this->getNumberOfTuples.
1345 * \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.
1347 DataArrayDouble *DataArrayDouble::duplicateEachTupleNTimes(int nbTimes) const
1350 if(getNumberOfComponents()!=1)
1351 throw INTERP_KERNEL::Exception("DataArrayDouble::duplicateEachTupleNTimes : this should have only one component !");
1353 throw INTERP_KERNEL::Exception("DataArrayDouble::duplicateEachTupleNTimes : nb times should be >= 1 !");
1354 int nbTuples=getNumberOfTuples();
1355 const double *inPtr=getConstPointer();
1356 MCAuto<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(nbTimes*nbTuples,1);
1357 double *retPtr=ret->getPointer();
1358 for(int i=0;i<nbTuples;i++,inPtr++)
1361 for(int j=0;j<nbTimes;j++,retPtr++)
1364 ret->copyStringInfoFrom(*this);
1369 * This methods returns the minimal distance between the two set of points \a this and \a other.
1370 * So \a this and \a other have to have the same number of components. If not an INTERP_KERNEL::Exception will be thrown.
1371 * This method works only if number of components of \a this (equal to those of \a other) is in 1, 2 or 3.
1373 * \param [out] thisTupleId the tuple id in \a this corresponding to the returned minimal distance
1374 * \param [out] otherTupleId the tuple id in \a other corresponding to the returned minimal distance
1375 * \return the minimal distance between the two set of points \a this and \a other.
1376 * \sa DataArrayDouble::findClosestTupleId
1378 double DataArrayDouble::minimalDistanceTo(const DataArrayDouble *other, int& thisTupleId, int& otherTupleId) const
1380 MCAuto<DataArrayInt> part1=findClosestTupleId(other);
1381 int nbOfCompo(getNumberOfComponents());
1382 int otherNbTuples(other->getNumberOfTuples());
1383 const double *thisPt(begin()),*otherPt(other->begin());
1384 const int *part1Pt(part1->begin());
1385 double ret=std::numeric_limits<double>::max();
1386 for(int i=0;i<otherNbTuples;i++,part1Pt++,otherPt+=nbOfCompo)
1389 for(int j=0;j<nbOfCompo;j++)
1390 tmp+=(otherPt[j]-thisPt[nbOfCompo*(*part1Pt)+j])*(otherPt[j]-thisPt[nbOfCompo*(*part1Pt)+j]);
1392 { ret=tmp; thisTupleId=*part1Pt; otherTupleId=i; }
1398 * This methods returns for each tuple in \a other which tuple in \a this is the closest.
1399 * So \a this and \a other have to have the same number of components. If not an INTERP_KERNEL::Exception will be thrown.
1400 * This method works only if number of components of \a this (equal to those of \a other) is in 1, 2 or 3.
1402 * \return a newly allocated (new object to be dealt by the caller) DataArrayInt having \c other->getNumberOfTuples() tuples and one components.
1403 * \sa DataArrayDouble::minimalDistanceTo
1405 DataArrayInt *DataArrayDouble::findClosestTupleId(const DataArrayDouble *other) const
1408 throw INTERP_KERNEL::Exception("DataArrayDouble::findClosestTupleId : other instance is NULL !");
1409 checkAllocated(); other->checkAllocated();
1410 int nbOfCompo=getNumberOfComponents();
1411 if(nbOfCompo!=other->getNumberOfComponents())
1413 std::ostringstream oss; oss << "DataArrayDouble::findClosestTupleId : number of components in this is " << nbOfCompo;
1414 oss << ", whereas number of components in other is " << other->getNumberOfComponents() << "! Should be equal !";
1415 throw INTERP_KERNEL::Exception(oss.str().c_str());
1417 int nbOfTuples=other->getNumberOfTuples();
1418 int thisNbOfTuples=getNumberOfTuples();
1419 MCAuto<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbOfTuples,1);
1421 getMinMaxPerComponent(bounds);
1426 double xDelta(fabs(bounds[1]-bounds[0])),yDelta(fabs(bounds[3]-bounds[2])),zDelta(fabs(bounds[5]-bounds[4]));
1427 double delta=std::max(xDelta,yDelta); delta=std::max(delta,zDelta);
1428 double characSize=pow((delta*delta*delta)/((double)thisNbOfTuples),1./3.);
1429 BBTreePts<3,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
1430 FindClosestTupleIdAlg<3>(myTree,3.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
1435 double xDelta(fabs(bounds[1]-bounds[0])),yDelta(fabs(bounds[3]-bounds[2]));
1436 double delta=std::max(xDelta,yDelta);
1437 double characSize=sqrt(delta/(double)thisNbOfTuples);
1438 BBTreePts<2,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
1439 FindClosestTupleIdAlg<2>(myTree,2.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
1444 double characSize=fabs(bounds[1]-bounds[0])/thisNbOfTuples;
1445 BBTreePts<1,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
1446 FindClosestTupleIdAlg<1>(myTree,1.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
1450 throw INTERP_KERNEL::Exception("Unexpected spacedim of coords for findClosestTupleId. Must be 1, 2 or 3.");
1456 * This method expects that \a this and \a otherBBoxFrmt arrays are bounding box arrays ( as the output of MEDCouplingPointSet::getBoundingBoxForBBTree method ).
1457 * This method will return a DataArrayInt array having the same number of tuples than \a this. This returned array tells for each cell in \a this
1458 * how many bounding boxes in \a otherBBoxFrmt.
1459 * So, this method expects that \a this and \a otherBBoxFrmt have the same number of components.
1461 * \param [in] otherBBoxFrmt - It is an array .
1462 * \param [in] eps - the absolute precision of the detection. when eps < 0 the bboxes are enlarged so more interactions are detected. Inversely when > 0 the bboxes are stretched.
1463 * \sa MEDCouplingPointSet::getBoundingBoxForBBTree
1464 * \throw If \a this and \a otherBBoxFrmt have not the same number of components.
1465 * \throw If \a this and \a otherBBoxFrmt number of components is not even (BBox format).
1467 DataArrayInt *DataArrayDouble::computeNbOfInteractionsWith(const DataArrayDouble *otherBBoxFrmt, double eps) const
1470 throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : input array is NULL !");
1471 if(!isAllocated() || !otherBBoxFrmt->isAllocated())
1472 throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : this and input array must be allocated !");
1473 int nbOfComp(getNumberOfComponents()),nbOfTuples(getNumberOfTuples());
1474 if(nbOfComp!=otherBBoxFrmt->getNumberOfComponents())
1476 std::ostringstream oss; oss << "DataArrayDouble::computeNbOfInteractionsWith : this number of components (" << nbOfComp << ") must be equal to the number of components of input array (" << otherBBoxFrmt->getNumberOfComponents() << ") !";
1477 throw INTERP_KERNEL::Exception(oss.str().c_str());
1481 std::ostringstream oss; oss << "DataArrayDouble::computeNbOfInteractionsWith : Number of components (" << nbOfComp << ") is not even ! It should be to be compatible with bbox format !";
1482 throw INTERP_KERNEL::Exception(oss.str().c_str());
1484 MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(nbOfTuples,1);
1485 const double *thisBBPtr(begin());
1486 int *retPtr(ret->getPointer());
1491 BBTree<3,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
1492 for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
1493 *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
1498 BBTree<2,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
1499 for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
1500 *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
1505 BBTree<1,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
1506 for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
1507 *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
1511 throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : space dimension supported are [1,2,3] !");
1518 * Returns a copy of \a this array by excluding coincident tuples. Each tuple is
1519 * considered as coordinates of a point in getNumberOfComponents()-dimensional
1520 * space. The distance between tuples is computed using norm2. If several tuples are
1521 * not far each from other than \a prec, only one of them remains in the result
1522 * array. The order of tuples in the result array is same as in \a this one except
1523 * that coincident tuples are excluded.
1524 * \param [in] prec - minimal absolute distance between two tuples at which they are
1525 * considered not coincident.
1526 * \param [in] limitTupleId - limit tuple id. If all tuples within a group of coincident
1527 * tuples have id strictly lower than \a limitTupleId then they are not excluded.
1528 * \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1529 * is to delete using decrRef() as it is no more needed.
1530 * \throw If \a this is not allocated.
1531 * \throw If the number of components is not in [1,2,3,4].
1533 * \if ENABLE_EXAMPLES
1534 * \ref py_mcdataarraydouble_getdifferentvalues "Here is a Python example".
1537 DataArrayDouble *DataArrayDouble::getDifferentValues(double prec, int limitTupleId) const
1540 DataArrayInt *c0=0,*cI0=0;
1541 findCommonTuples(prec,limitTupleId,c0,cI0);
1542 MCAuto<DataArrayInt> c(c0),cI(cI0);
1543 int newNbOfTuples=-1;
1544 MCAuto<DataArrayInt> o2n=DataArrayInt::ConvertIndexArrayToO2N(getNumberOfTuples(),c0->begin(),cI0->begin(),cI0->end(),newNbOfTuples);
1545 return renumberAndReduce(o2n->getConstPointer(),newNbOfTuples);
1549 * Copy all components in a specified order from another DataArrayDouble.
1550 * Both numerical and textual data is copied. The number of tuples in \a this and
1551 * the other array can be different.
1552 * \param [in] a - the array to copy data from.
1553 * \param [in] compoIds - sequence of zero based indices of components, data of which is
1555 * \throw If \a a is NULL.
1556 * \throw If \a compoIds.size() != \a a->getNumberOfComponents().
1557 * \throw If \a compoIds[i] < 0 or \a compoIds[i] > \a this->getNumberOfComponents().
1559 * \if ENABLE_EXAMPLES
1560 * \ref py_mcdataarraydouble_setselectedcomponents "Here is a Python example".
1563 void DataArrayDouble::setSelectedComponents(const DataArrayDouble *a, const std::vector<int>& compoIds)
1566 throw INTERP_KERNEL::Exception("DataArrayDouble::setSelectedComponents : input DataArrayDouble is NULL !");
1568 copyPartOfStringInfoFrom2(compoIds,*a);
1569 std::size_t partOfCompoSz=compoIds.size();
1570 int nbOfCompo=getNumberOfComponents();
1571 int nbOfTuples=std::min(getNumberOfTuples(),a->getNumberOfTuples());
1572 const double *ac=a->getConstPointer();
1573 double *nc=getPointer();
1574 for(int i=0;i<nbOfTuples;i++)
1575 for(std::size_t j=0;j<partOfCompoSz;j++,ac++)
1576 nc[nbOfCompo*i+compoIds[j]]=*ac;
1579 void DataArrayDouble::SetArrayIn(DataArrayDouble *newArray, DataArrayDouble* &arrayToSet)
1581 if(newArray!=arrayToSet)
1584 arrayToSet->decrRef();
1585 arrayToSet=newArray;
1587 arrayToSet->incrRef();
1591 void DataArrayDouble::aggregate(const DataArrayDouble *other)
1594 throw INTERP_KERNEL::Exception("DataArrayDouble::aggregate : null pointer !");
1595 if(getNumberOfComponents()!=other->getNumberOfComponents())
1596 throw INTERP_KERNEL::Exception("DataArrayDouble::aggregate : mismatch number of components !");
1597 _mem.insertAtTheEnd(other->begin(),other->end());
1601 * Checks if 0.0 value is present in \a this array. If it is the case, an exception
1603 * \throw If zero is found in \a this array.
1605 void DataArrayDouble::checkNoNullValues() const
1607 const double *tmp=getConstPointer();
1608 std::size_t nbOfElems=getNbOfElems();
1609 const double *where=std::find(tmp,tmp+nbOfElems,0.);
1610 if(where!=tmp+nbOfElems)
1611 throw INTERP_KERNEL::Exception("A value 0.0 have been detected !");
1615 * Computes minimal and maximal value in each component. An output array is filled
1616 * with \c 2 * \a this->getNumberOfComponents() values, so the caller is to allocate
1617 * enough memory before calling this method.
1618 * \param [out] bounds - array of size at least 2 *\a this->getNumberOfComponents().
1619 * It is filled as follows:<br>
1620 * \a bounds[0] = \c min_of_component_0 <br>
1621 * \a bounds[1] = \c max_of_component_0 <br>
1622 * \a bounds[2] = \c min_of_component_1 <br>
1623 * \a bounds[3] = \c max_of_component_1 <br>
1626 void DataArrayDouble::getMinMaxPerComponent(double *bounds) const
1629 int dim=getNumberOfComponents();
1630 for (int idim=0; idim<dim; idim++)
1632 bounds[idim*2]=std::numeric_limits<double>::max();
1633 bounds[idim*2+1]=-std::numeric_limits<double>::max();
1635 const double *ptr=getConstPointer();
1636 int nbOfTuples=getNumberOfTuples();
1637 for(int i=0;i<nbOfTuples;i++)
1639 for(int idim=0;idim<dim;idim++)
1641 if(bounds[idim*2]>ptr[i*dim+idim])
1643 bounds[idim*2]=ptr[i*dim+idim];
1645 if(bounds[idim*2+1]<ptr[i*dim+idim])
1647 bounds[idim*2+1]=ptr[i*dim+idim];
1654 * This method retrieves a newly allocated DataArrayDouble instance having same number of tuples than \a this and twice number of components than \a this
1655 * to store both the min and max per component of each tuples.
1656 * \param [in] epsilon the width of the bbox (identical in each direction) - 0.0 by default
1658 * \return a newly created DataArrayDouble instance having \c this->getNumberOfTuples() tuples and 2 * \c this->getNumberOfComponent() components
1660 * \throw If \a this is not allocated yet.
1662 DataArrayDouble *DataArrayDouble::computeBBoxPerTuple(double epsilon) const
1665 const double *dataPtr=getConstPointer();
1666 int nbOfCompo=getNumberOfComponents();
1667 int nbTuples=getNumberOfTuples();
1668 MCAuto<DataArrayDouble> bbox=DataArrayDouble::New();
1669 bbox->alloc(nbTuples,2*nbOfCompo);
1670 double *bboxPtr=bbox->getPointer();
1671 for(int i=0;i<nbTuples;i++)
1673 for(int j=0;j<nbOfCompo;j++)
1675 bboxPtr[2*nbOfCompo*i+2*j]=dataPtr[nbOfCompo*i+j]-epsilon;
1676 bboxPtr[2*nbOfCompo*i+2*j+1]=dataPtr[nbOfCompo*i+j]+epsilon;
1683 * For each tuples **t** in \a other, this method retrieves tuples in \a this that are equal to **t**.
1684 * Two tuples are considered equal if the euclidian distance between the two tuples is lower than \a eps.
1686 * \param [in] other a DataArrayDouble having same number of components than \a this.
1687 * \param [in] eps absolute precision representing distance (using infinite norm) between 2 tuples behind which 2 tuples are considered equal.
1688 * \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.
1689 * \a cI allows to extract information in \a c.
1690 * \param [out] cI is an indirection array that allows to extract the data contained in \a c.
1692 * \throw In case of:
1693 * - \a this is not allocated
1694 * - \a other is not allocated or null
1695 * - \a this and \a other do not have the same number of components
1696 * - if number of components of \a this is not in [1,2,3]
1698 * \sa MEDCouplingPointSet::getNodeIdsNearPoints, DataArrayDouble::getDifferentValues
1700 void DataArrayDouble::computeTupleIdsNearTuples(const DataArrayDouble *other, double eps, DataArrayInt *& c, DataArrayInt *& cI) const
1703 throw INTERP_KERNEL::Exception("DataArrayDouble::computeTupleIdsNearTuples : input pointer other is null !");
1705 other->checkAllocated();
1706 int nbOfCompo=getNumberOfComponents();
1707 int otherNbOfCompo=other->getNumberOfComponents();
1708 if(nbOfCompo!=otherNbOfCompo)
1709 throw INTERP_KERNEL::Exception("DataArrayDouble::computeTupleIdsNearTuples : number of components should be equal between this and other !");
1710 int nbOfTuplesOther=other->getNumberOfTuples();
1711 MCAuto<DataArrayInt> cArr(DataArrayInt::New()),cIArr(DataArrayInt::New()); cArr->alloc(0,1); cIArr->pushBackSilent(0);
1716 BBTreePts<3,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
1717 FindTupleIdsNearTuplesAlg<3>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
1722 BBTreePts<2,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
1723 FindTupleIdsNearTuplesAlg<2>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
1728 BBTreePts<1,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
1729 FindTupleIdsNearTuplesAlg<1>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
1733 throw INTERP_KERNEL::Exception("Unexpected spacedim of coords for computeTupleIdsNearTuples. Must be 1, 2 or 3.");
1735 c=cArr.retn(); cI=cIArr.retn();
1739 * 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
1740 * around origin of 'radius' 1.
1742 * \param [in] eps absolute epsilon. under that value of delta between max and min no scale is performed.
1744 void DataArrayDouble::recenterForMaxPrecision(double eps)
1747 int dim=getNumberOfComponents();
1748 std::vector<double> bounds(2*dim);
1749 getMinMaxPerComponent(&bounds[0]);
1750 for(int i=0;i<dim;i++)
1752 double delta=bounds[2*i+1]-bounds[2*i];
1753 double offset=(bounds[2*i]+bounds[2*i+1])/2.;
1755 applyLin(1./delta,-offset/delta,i);
1757 applyLin(1.,-offset,i);
1762 * Returns the maximal value and all its locations within \a this one-dimensional array.
1763 * \param [out] tupleIds - a new instance of DataArrayInt containg indices of
1764 * tuples holding the maximal value. The caller is to delete it using
1765 * decrRef() as it is no more needed.
1766 * \return double - the maximal value among all values of \a this array.
1767 * \throw If \a this->getNumberOfComponents() != 1
1768 * \throw If \a this->getNumberOfTuples() < 1
1770 double DataArrayDouble::getMaxValue2(DataArrayInt*& tupleIds) const
1774 double ret=getMaxValue(tmp);
1775 tupleIds=findIdsInRange(ret,ret);
1780 * Returns the minimal value and all its locations within \a this one-dimensional array.
1781 * \param [out] tupleIds - a new instance of DataArrayInt containg indices of
1782 * tuples holding the minimal value. The caller is to delete it using
1783 * decrRef() as it is no more needed.
1784 * \return double - the minimal value among all values of \a this array.
1785 * \throw If \a this->getNumberOfComponents() != 1
1786 * \throw If \a this->getNumberOfTuples() < 1
1788 double DataArrayDouble::getMinValue2(DataArrayInt*& tupleIds) const
1792 double ret=getMinValue(tmp);
1793 tupleIds=findIdsInRange(ret,ret);
1798 * 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.
1799 * This method only works for single component array.
1801 * \return a value in [ 0, \c this->getNumberOfTuples() )
1803 * \throw If \a this is not allocated
1806 int DataArrayDouble::count(double value, double eps) const
1810 if(getNumberOfComponents()!=1)
1811 throw INTERP_KERNEL::Exception("DataArrayDouble::count : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
1812 const double *vals=begin();
1813 int nbOfTuples=getNumberOfTuples();
1814 for(int i=0;i<nbOfTuples;i++,vals++)
1815 if(fabs(*vals-value)<=eps)
1821 * Returns the average value of \a this one-dimensional array.
1822 * \return double - the average value over all values of \a this array.
1823 * \throw If \a this->getNumberOfComponents() != 1
1824 * \throw If \a this->getNumberOfTuples() < 1
1826 double DataArrayDouble::getAverageValue() const
1828 if(getNumberOfComponents()!=1)
1829 throw INTERP_KERNEL::Exception("DataArrayDouble::getAverageValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
1830 int nbOfTuples=getNumberOfTuples();
1832 throw INTERP_KERNEL::Exception("DataArrayDouble::getAverageValue : array exists but number of tuples must be > 0 !");
1833 const double *vals=getConstPointer();
1834 double ret=std::accumulate(vals,vals+nbOfTuples,0.);
1835 return ret/nbOfTuples;
1839 * Returns the Euclidean norm of the vector defined by \a this array.
1840 * \return double - the value of the Euclidean norm, i.e.
1841 * the square root of the inner product of vector.
1842 * \throw If \a this is not allocated.
1844 double DataArrayDouble::norm2() const
1848 std::size_t nbOfElems=getNbOfElems();
1849 const double *pt=getConstPointer();
1850 for(std::size_t i=0;i<nbOfElems;i++,pt++)
1856 * Returns the maximum norm of the vector defined by \a this array.
1857 * This method works even if the number of components is diferent from one.
1858 * If the number of elements in \a this is 0, -1. is returned.
1859 * \return double - the value of the maximum norm, i.e.
1860 * the maximal absolute value among values of \a this array (whatever its number of components).
1861 * \throw If \a this is not allocated.
1863 double DataArrayDouble::normMax() const
1867 std::size_t nbOfElems(getNbOfElems());
1868 const double *pt(getConstPointer());
1869 for(std::size_t i=0;i<nbOfElems;i++,pt++)
1871 double val(std::abs(*pt));
1879 * Returns the minimum norm (absolute value) of the vector defined by \a this array.
1880 * This method works even if the number of components is diferent from one.
1881 * If the number of elements in \a this is 0, std::numeric_limits<double>::max() is returned.
1882 * \return double - the value of the minimum norm, i.e.
1883 * the minimal absolute value among values of \a this array (whatever its number of components).
1884 * \throw If \a this is not allocated.
1886 double DataArrayDouble::normMin() const
1889 double ret(std::numeric_limits<double>::max());
1890 std::size_t nbOfElems(getNbOfElems());
1891 const double *pt(getConstPointer());
1892 for(std::size_t i=0;i<nbOfElems;i++,pt++)
1894 double val(std::abs(*pt));
1902 * Accumulates values of each component of \a this array.
1903 * \param [out] res - an array of length \a this->getNumberOfComponents(), allocated
1904 * by the caller, that is filled by this method with sum value for each
1906 * \throw If \a this is not allocated.
1908 void DataArrayDouble::accumulate(double *res) const
1911 const double *ptr=getConstPointer();
1912 int nbTuple=getNumberOfTuples();
1913 int nbComps=getNumberOfComponents();
1914 std::fill(res,res+nbComps,0.);
1915 for(int i=0;i<nbTuple;i++)
1916 std::transform(ptr+i*nbComps,ptr+(i+1)*nbComps,res,res,std::plus<double>());
1920 * This method returns the min distance from an external tuple defined by [ \a tupleBg , \a tupleEnd ) to \a this and
1921 * the first tuple in \a this that matches the returned distance. If there is no tuples in \a this an exception will be thrown.
1924 * \a this is expected to be allocated and expected to have a number of components equal to the distance from \a tupleBg to
1925 * \a tupleEnd. If not an exception will be thrown.
1927 * \param [in] tupleBg start pointer (included) of input external tuple
1928 * \param [in] tupleEnd end pointer (not included) of input external tuple
1929 * \param [out] tupleId the tuple id in \a this that matches the min of distance between \a this and input external tuple
1930 * \return the min distance.
1931 * \sa MEDCouplingUMesh::distanceToPoint
1933 double DataArrayDouble::distanceToTuple(const double *tupleBg, const double *tupleEnd, int& tupleId) const
1936 int nbTuple=getNumberOfTuples();
1937 int nbComps=getNumberOfComponents();
1938 if(nbComps!=(int)std::distance(tupleBg,tupleEnd))
1939 { 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()); }
1941 throw INTERP_KERNEL::Exception("DataArrayDouble::distanceToTuple : no tuple in this ! No distance to compute !");
1942 double ret0=std::numeric_limits<double>::max();
1944 const double *work=getConstPointer();
1945 for(int i=0;i<nbTuple;i++)
1948 for(int j=0;j<nbComps;j++,work++)
1949 val+=(*work-tupleBg[j])*((*work-tupleBg[j]));
1953 { ret0=val; tupleId=i; }
1959 * Accumulate values of the given component of \a this array.
1960 * \param [in] compId - the index of the component of interest.
1961 * \return double - a sum value of \a compId-th component.
1962 * \throw If \a this is not allocated.
1963 * \throw If \a the condition ( 0 <= \a compId < \a this->getNumberOfComponents() ) is
1966 double DataArrayDouble::accumulate(int compId) const
1969 const double *ptr=getConstPointer();
1970 int nbTuple=getNumberOfTuples();
1971 int nbComps=getNumberOfComponents();
1972 if(compId<0 || compId>=nbComps)
1973 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulate : Invalid compId specified : No such nb of components !");
1975 for(int i=0;i<nbTuple;i++)
1976 ret+=ptr[i*nbComps+compId];
1981 * This method accumulate using addition tuples in \a this using input index array [ \a bgOfIndex, \a endOfIndex ).
1982 * The returned array will have same number of components than \a this and number of tuples equal to
1983 * \c std::distance(bgOfIndex,endOfIndex) \b minus \b one.
1985 * The input index array is expected to be ascendingly sorted in which the all referenced ids should be in [0, \c this->getNumberOfTuples).
1986 * 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.
1988 * \param [in] bgOfIndex - begin (included) of the input index array.
1989 * \param [in] endOfIndex - end (excluded) of the input index array.
1990 * \return DataArrayDouble * - the new instance having the same number of components than \a this.
1992 * \throw If bgOfIndex or end is NULL.
1993 * \throw If input index array is not ascendingly sorted.
1994 * \throw If there is an id in [ \a bgOfIndex, \a endOfIndex ) not in [0, \c this->getNumberOfTuples).
1995 * \throw If std::distance(bgOfIndex,endOfIndex)==0.
1997 DataArrayDouble *DataArrayDouble::accumulatePerChunck(const int *bgOfIndex, const int *endOfIndex) const
1999 if(!bgOfIndex || !endOfIndex)
2000 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : input pointer NULL !");
2002 int nbCompo=getNumberOfComponents();
2003 int nbOfTuples=getNumberOfTuples();
2004 int sz=(int)std::distance(bgOfIndex,endOfIndex);
2006 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : invalid size of input index array !");
2008 MCAuto<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(sz,nbCompo);
2009 const int *w=bgOfIndex;
2010 if(*w<0 || *w>=nbOfTuples)
2011 throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : The first element of the input index not in [0,nbOfTuples) !");
2012 const double *srcPt=begin()+(*w)*nbCompo;
2013 double *tmp=ret->getPointer();
2014 for(int i=0;i<sz;i++,tmp+=nbCompo,w++)
2016 std::fill(tmp,tmp+nbCompo,0.);
2019 for(int j=w[0];j<w[1];j++,srcPt+=nbCompo)
2021 if(j>=0 && j<nbOfTuples)
2022 std::transform(srcPt,srcPt+nbCompo,tmp,tmp,std::plus<double>());
2025 std::ostringstream oss; oss << "DataArrayDouble::accumulatePerChunck : At rank #" << i << " the input index array points to id " << j << " should be in [0," << nbOfTuples << ") !";
2026 throw INTERP_KERNEL::Exception(oss.str().c_str());
2032 std::ostringstream oss; oss << "DataArrayDouble::accumulatePerChunck : At rank #" << i << " the input index array is not in ascendingly sorted.";
2033 throw INTERP_KERNEL::Exception(oss.str().c_str());
2036 ret->copyStringInfoFrom(*this);
2041 * Converts each 2D point defined by the tuple of \a this array from the Polar to the
2042 * Cartesian coordinate system. The two components of the tuple of \a this array are
2043 * considered to contain (1) radius and (2) angle of the point in the Polar CS.
2044 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
2045 * contains X and Y coordinates of the point in the Cartesian CS. The caller
2046 * is to delete this array using decrRef() as it is no more needed. The array
2047 * does not contain any textual info on components.
2048 * \throw If \a this->getNumberOfComponents() != 2.
2049 * \sa fromCartToPolar
2051 DataArrayDouble *DataArrayDouble::fromPolarToCart() const
2054 int nbOfComp(getNumberOfComponents());
2056 throw INTERP_KERNEL::Exception("DataArrayDouble::fromPolarToCart : must be an array with exactly 2 components !");
2057 int nbOfTuple(getNumberOfTuples());
2058 DataArrayDouble *ret(DataArrayDouble::New());
2059 ret->alloc(nbOfTuple,2);
2060 double *w(ret->getPointer());
2061 const double *wIn(getConstPointer());
2062 for(int i=0;i<nbOfTuple;i++,w+=2,wIn+=2)
2064 w[0]=wIn[0]*cos(wIn[1]);
2065 w[1]=wIn[0]*sin(wIn[1]);
2071 * Converts each 3D point defined by the tuple of \a this array from the Cylindrical to
2072 * the Cartesian coordinate system. The three components of the tuple of \a this array
2073 * are considered to contain (1) radius, (2) azimuth and (3) altitude of the point in
2074 * the Cylindrical CS.
2075 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
2076 * contains X, Y and Z coordinates of the point in the Cartesian CS. The info
2077 * on the third component is copied from \a this array. The caller
2078 * is to delete this array using decrRef() as it is no more needed.
2079 * \throw If \a this->getNumberOfComponents() != 3.
2082 DataArrayDouble *DataArrayDouble::fromCylToCart() const
2085 int nbOfComp(getNumberOfComponents());
2087 throw INTERP_KERNEL::Exception("DataArrayDouble::fromCylToCart : must be an array with exactly 3 components !");
2088 int nbOfTuple(getNumberOfTuples());
2089 DataArrayDouble *ret(DataArrayDouble::New());
2090 ret->alloc(getNumberOfTuples(),3);
2091 double *w(ret->getPointer());
2092 const double *wIn(getConstPointer());
2093 for(int i=0;i<nbOfTuple;i++,w+=3,wIn+=3)
2095 w[0]=wIn[0]*cos(wIn[1]);
2096 w[1]=wIn[0]*sin(wIn[1]);
2099 ret->setInfoOnComponent(2,getInfoOnComponent(2));
2104 * Converts each 3D point defined by the tuple of \a this array from the Spherical to
2105 * the Cartesian coordinate system. The three components of the tuple of \a this array
2106 * are considered to contain (1) radius, (2) polar angle and (3) azimuthal angle of the
2107 * point in the Cylindrical CS.
2108 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
2109 * contains X, Y and Z coordinates of the point in the Cartesian CS. The info
2110 * on the third component is copied from \a this array. The caller
2111 * is to delete this array using decrRef() as it is no more needed.
2112 * \throw If \a this->getNumberOfComponents() != 3.
2113 * \sa fromCartToSpher
2115 DataArrayDouble *DataArrayDouble::fromSpherToCart() const
2118 int nbOfComp(getNumberOfComponents());
2120 throw INTERP_KERNEL::Exception("DataArrayDouble::fromSpherToCart : must be an array with exactly 3 components !");
2121 int nbOfTuple(getNumberOfTuples());
2122 DataArrayDouble *ret(DataArrayDouble::New());
2123 ret->alloc(getNumberOfTuples(),3);
2124 double *w(ret->getPointer());
2125 const double *wIn(getConstPointer());
2126 for(int i=0;i<nbOfTuple;i++,w+=3,wIn+=3)
2128 w[0]=wIn[0]*cos(wIn[2])*sin(wIn[1]);
2129 w[1]=wIn[0]*sin(wIn[2])*sin(wIn[1]);
2130 w[2]=wIn[0]*cos(wIn[1]);
2136 * This method returns a new array containing the same number of tuples than \a this. To do this, this method needs \a at parameter to specify the convention of \a this.
2137 * All the tuples of the returned array will be in cartesian sense. So if \a at equals to AX_CART the returned array is basically a deep copy of \a this.
2138 * If \a at equals to AX_CYL the returned array will be the result of operation cylindric to cartesian of \a this...
2140 * \param [in] atOfThis - The axis type of \a this.
2141 * \return DataArrayDouble * - the new instance of DataArrayDouble (that must be dealed by caller) containing the result of the cartesianizification of \a this.
2143 DataArrayDouble *DataArrayDouble::cartesianize(MEDCouplingAxisType atOfThis) const
2146 int nbOfComp(getNumberOfComponents());
2147 MCAuto<DataArrayDouble> ret;
2155 ret=fromCylToCart();
2160 ret=fromPolarToCart();
2164 throw INTERP_KERNEL::Exception("DataArrayDouble::cartesianize : For AX_CYL, number of components must be in [2,3] !");
2168 ret=fromSpherToCart();
2173 ret=fromPolarToCart();
2177 throw INTERP_KERNEL::Exception("DataArrayDouble::cartesianize : For AX_CYL, number of components must be in [2,3] !");
2179 throw INTERP_KERNEL::Exception("DataArrayDouble::cartesianize : not recognized axis type ! Only AX_CART, AX_CYL and AX_SPHER supported !");
2181 ret->copyStringInfoFrom(*this);
2186 * This method returns a newly created array to be deallocated that contains the result of conversion from cartesian to polar.
2187 * This method expects that \a this has exactly 2 components.
2188 * \sa fromPolarToCart
2190 DataArrayDouble *DataArrayDouble::fromCartToPolar() const
2192 MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
2194 int nbOfComp(getNumberOfComponents()),nbTuples(getNumberOfTuples());
2196 throw INTERP_KERNEL::Exception("DataArrayDouble::fromCartToPolar : must be an array with exactly 2 components !");
2197 ret->alloc(nbTuples,2);
2198 double *retPtr(ret->getPointer());
2199 const double *ptr(begin());
2200 for(int i=0;i<nbTuples;i++,ptr+=2,retPtr+=2)
2202 retPtr[0]=sqrt(ptr[0]*ptr[0]+ptr[1]*ptr[1]);
2203 retPtr[1]=atan2(ptr[1],ptr[0]);
2209 * This method returns a newly created array to be deallocated that contains the result of conversion from cartesian to cylindrical.
2210 * This method expects that \a this has exactly 3 components.
2213 DataArrayDouble *DataArrayDouble::fromCartToCyl() const
2215 MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
2217 int nbOfComp(getNumberOfComponents()),nbTuples(getNumberOfTuples());
2219 throw INTERP_KERNEL::Exception("DataArrayDouble::fromCartToCyl : must be an array with exactly 3 components !");
2220 ret->alloc(nbTuples,3);
2221 double *retPtr(ret->getPointer());
2222 const double *ptr(begin());
2223 for(int i=0;i<nbTuples;i++,ptr+=3,retPtr+=3)
2225 retPtr[0]=sqrt(ptr[0]*ptr[0]+ptr[1]*ptr[1]);
2226 retPtr[1]=atan2(ptr[1],ptr[0]);
2233 * This method returns a newly created array to be deallocated that contains the result of conversion from cartesian to spherical coordinates.
2234 * \sa fromSpherToCart
2236 DataArrayDouble *DataArrayDouble::fromCartToSpher() const
2238 MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
2240 int nbOfComp(getNumberOfComponents()),nbTuples(getNumberOfTuples());
2242 throw INTERP_KERNEL::Exception("DataArrayDouble::fromCartToSpher : must be an array with exactly 3 components !");
2243 ret->alloc(nbTuples,3);
2244 double *retPtr(ret->getPointer());
2245 const double *ptr(begin());
2246 for(int i=0;i<nbTuples;i++,ptr+=3,retPtr+=3)
2248 retPtr[0]=sqrt(ptr[0]*ptr[0]+ptr[1]*ptr[1]+ptr[2]*ptr[2]);
2249 retPtr[1]=acos(ptr[2]/retPtr[0]);
2250 retPtr[2]=atan2(ptr[1],ptr[0]);
2256 * This method returns a newly created array to be deallocated that contains the result of conversion from cartesian to cylindrical relative to the given \a center and a \a vector.
2257 * This method expects that \a this has exactly 3 components.
2258 * \sa MEDCouplingFieldDouble::computeVectorFieldCyl
2260 DataArrayDouble *DataArrayDouble::fromCartToCylGiven(const DataArrayDouble *coords, const double center[3], const double vect[3]) const
2263 throw INTERP_KERNEL::Exception("DataArrayDouble::fromCartToCylGiven : input coords are NULL !");
2264 MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
2265 checkAllocated(); coords->checkAllocated();
2266 int nbOfComp(getNumberOfComponents()),nbTuples(getNumberOfTuples());
2268 throw INTERP_KERNEL::Exception("DataArrayDouble::fromCartToCylGiven : must be an array with exactly 3 components !");
2269 if(coords->getNumberOfComponents()!=3)
2270 throw INTERP_KERNEL::Exception("DataArrayDouble::fromCartToCylGiven : coords array must have exactly 3 components !");
2271 if(coords->getNumberOfTuples()!=nbTuples)
2272 throw INTERP_KERNEL::Exception("DataArrayDouble::fromCartToCylGiven : coords array must have the same number of tuples !");
2273 ret->alloc(nbTuples,nbOfComp);
2274 double magOfVect(sqrt(vect[0]*vect[0]+vect[1]*vect[1]+vect[2]*vect[2]));
2276 throw INTERP_KERNEL::Exception("DataArrayDouble::fromCartToCylGiven : magnitude of vect is too low !");
2277 double Ur[3],Uteta[3],Uz[3],*retPtr(ret->getPointer());
2278 const double *coo(coords->begin()),*vectField(begin());
2279 std::transform(vect,vect+3,Uz,std::bind2nd(std::multiplies<double>(),1./magOfVect));
2280 for(int i=0;i<nbTuples;i++,vectField+=3,retPtr+=3,coo+=3)
2282 std::transform(coo,coo+3,center,Ur,std::minus<double>());
2283 Uteta[0]=Uz[1]*Ur[2]-Uz[2]*Ur[1]; Uteta[1]=Uz[2]*Ur[0]-Uz[0]*Ur[2]; Uteta[2]=Uz[0]*Ur[1]-Uz[1]*Ur[0];
2284 double magOfTeta(sqrt(Uteta[0]*Uteta[0]+Uteta[1]*Uteta[1]+Uteta[2]*Uteta[2]));
2285 std::transform(Uteta,Uteta+3,Uteta,std::bind2nd(std::multiplies<double>(),1./magOfTeta));
2286 Ur[0]=Uteta[1]*Uz[2]-Uteta[2]*Uz[1]; Ur[1]=Uteta[2]*Uz[0]-Uteta[0]*Uz[2]; Ur[2]=Uteta[0]*Uz[1]-Uteta[1]*Uz[0];
2287 retPtr[0]=Ur[0]*vectField[0]+Ur[1]*vectField[1]+Ur[2]*vectField[2];
2288 retPtr[1]=Uteta[0]*vectField[0]+Uteta[1]*vectField[1]+Uteta[2]*vectField[2];
2289 retPtr[2]=Uz[0]*vectField[0]+Uz[1]*vectField[1]+Uz[2]*vectField[2];
2291 ret->copyStringInfoFrom(*this);
2296 * Computes the doubly contracted product of every tensor defined by the tuple of \a this
2297 * array contating 6 components.
2298 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
2299 * is calculated from the tuple <em>(t)</em> of \a this array as follows:
2300 * \f$ t[0]^2+t[1]^2+t[2]^2+2*t[3]^2+2*t[4]^2+2*t[5]^2\f$.
2301 * The caller is to delete this result array using decrRef() as it is no more needed.
2302 * \throw If \a this->getNumberOfComponents() != 6.
2304 DataArrayDouble *DataArrayDouble::doublyContractedProduct() const
2307 int nbOfComp(getNumberOfComponents());
2309 throw INTERP_KERNEL::Exception("DataArrayDouble::doublyContractedProduct : must be an array with exactly 6 components !");
2310 DataArrayDouble *ret=DataArrayDouble::New();
2311 int nbOfTuple=getNumberOfTuples();
2312 ret->alloc(nbOfTuple,1);
2313 const double *src=getConstPointer();
2314 double *dest=ret->getPointer();
2315 for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
2316 *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];
2321 * Computes the determinant of every square matrix defined by the tuple of \a this
2322 * array, which contains either 4, 6 or 9 components. The case of 6 components
2323 * corresponds to that of the upper triangular matrix.
2324 * \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
2325 * is the determinant of matrix of the corresponding tuple of \a this array.
2326 * The caller is to delete this result array using decrRef() as it is no more
2328 * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
2330 DataArrayDouble *DataArrayDouble::determinant() const
2333 DataArrayDouble *ret=DataArrayDouble::New();
2334 int nbOfTuple=getNumberOfTuples();
2335 ret->alloc(nbOfTuple,1);
2336 const double *src=getConstPointer();
2337 double *dest=ret->getPointer();
2338 switch(getNumberOfComponents())
2341 for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
2342 *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];
2345 for(int i=0;i<nbOfTuple;i++,dest++,src+=4)
2346 *dest=src[0]*src[3]-src[1]*src[2];
2349 for(int i=0;i<nbOfTuple;i++,dest++,src+=9)
2350 *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];
2354 throw INTERP_KERNEL::Exception("DataArrayDouble::determinant : Invalid number of components ! must be in 4,6,9 !");
2359 * Computes 3 eigenvalues of every upper triangular matrix defined by the tuple of
2360 * \a this array, which contains 6 components.
2361 * \return DataArrayDouble * - the new instance of DataArrayDouble containing 3
2362 * components, whose each tuple contains the eigenvalues of the matrix of
2363 * corresponding tuple of \a this array.
2364 * The caller is to delete this result array using decrRef() as it is no more
2366 * \throw If \a this->getNumberOfComponents() != 6.
2368 DataArrayDouble *DataArrayDouble::eigenValues() const
2371 int nbOfComp=getNumberOfComponents();
2373 throw INTERP_KERNEL::Exception("DataArrayDouble::eigenValues : must be an array with exactly 6 components !");
2374 DataArrayDouble *ret=DataArrayDouble::New();
2375 int nbOfTuple=getNumberOfTuples();
2376 ret->alloc(nbOfTuple,3);
2377 const double *src=getConstPointer();
2378 double *dest=ret->getPointer();
2379 for(int i=0;i<nbOfTuple;i++,dest+=3,src+=6)
2380 INTERP_KERNEL::computeEigenValues6(src,dest);
2385 * Computes 3 eigenvectors of every upper triangular matrix defined by the tuple of
2386 * \a this array, which contains 6 components.
2387 * \return DataArrayDouble * - the new instance of DataArrayDouble containing 9
2388 * components, whose each tuple contains 3 eigenvectors of the matrix of
2389 * corresponding tuple of \a this array.
2390 * The caller is to delete this result array using decrRef() as it is no more
2392 * \throw If \a this->getNumberOfComponents() != 6.
2394 DataArrayDouble *DataArrayDouble::eigenVectors() const
2397 int nbOfComp=getNumberOfComponents();
2399 throw INTERP_KERNEL::Exception("DataArrayDouble::eigenVectors : must be an array with exactly 6 components !");
2400 DataArrayDouble *ret=DataArrayDouble::New();
2401 int nbOfTuple=getNumberOfTuples();
2402 ret->alloc(nbOfTuple,9);
2403 const double *src=getConstPointer();
2404 double *dest=ret->getPointer();
2405 for(int i=0;i<nbOfTuple;i++,src+=6)
2408 INTERP_KERNEL::computeEigenValues6(src,tmp);
2409 for(int j=0;j<3;j++,dest+=3)
2410 INTERP_KERNEL::computeEigenVectorForEigenValue6(src,tmp[j],1e-12,dest);
2416 * Computes the inverse matrix of every matrix defined by the tuple of \a this
2417 * array, which contains either 4, 6 or 9 components. The case of 6 components
2418 * corresponds to that of the upper triangular matrix.
2419 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
2420 * same number of components as \a this one, whose each tuple is the inverse
2421 * matrix of the matrix of corresponding tuple of \a this array.
2422 * The caller is to delete this result array using decrRef() as it is no more
2424 * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
2426 DataArrayDouble *DataArrayDouble::inverse() const
2429 int nbOfComp=getNumberOfComponents();
2430 if(nbOfComp!=6 && nbOfComp!=9 && nbOfComp!=4)
2431 throw INTERP_KERNEL::Exception("DataArrayDouble::inversion : must be an array with 4,6 or 9 components !");
2432 DataArrayDouble *ret=DataArrayDouble::New();
2433 int nbOfTuple=getNumberOfTuples();
2434 ret->alloc(nbOfTuple,nbOfComp);
2435 const double *src=getConstPointer();
2436 double *dest=ret->getPointer();
2438 for(int i=0;i<nbOfTuple;i++,dest+=6,src+=6)
2440 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];
2441 dest[0]=(src[1]*src[2]-src[4]*src[4])/det;
2442 dest[1]=(src[0]*src[2]-src[5]*src[5])/det;
2443 dest[2]=(src[0]*src[1]-src[3]*src[3])/det;
2444 dest[3]=(src[5]*src[4]-src[3]*src[2])/det;
2445 dest[4]=(src[5]*src[3]-src[0]*src[4])/det;
2446 dest[5]=(src[3]*src[4]-src[1]*src[5])/det;
2448 else if(nbOfComp==4)
2449 for(int i=0;i<nbOfTuple;i++,dest+=4,src+=4)
2451 double det=src[0]*src[3]-src[1]*src[2];
2453 dest[1]=-src[1]/det;
2454 dest[2]=-src[2]/det;
2458 for(int i=0;i<nbOfTuple;i++,dest+=9,src+=9)
2460 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];
2461 dest[0]=(src[4]*src[8]-src[7]*src[5])/det;
2462 dest[1]=(src[7]*src[2]-src[1]*src[8])/det;
2463 dest[2]=(src[1]*src[5]-src[4]*src[2])/det;
2464 dest[3]=(src[6]*src[5]-src[3]*src[8])/det;
2465 dest[4]=(src[0]*src[8]-src[6]*src[2])/det;
2466 dest[5]=(src[2]*src[3]-src[0]*src[5])/det;
2467 dest[6]=(src[3]*src[7]-src[6]*src[4])/det;
2468 dest[7]=(src[6]*src[1]-src[0]*src[7])/det;
2469 dest[8]=(src[0]*src[4]-src[1]*src[3])/det;
2475 * Computes the trace of every matrix defined by the tuple of \a this
2476 * array, which contains either 4, 6 or 9 components. The case of 6 components
2477 * corresponds to that of the upper triangular matrix.
2478 * \return DataArrayDouble * - the new instance of DataArrayDouble containing
2479 * 1 component, whose each tuple is the trace of
2480 * the matrix of corresponding tuple of \a this array.
2481 * The caller is to delete this result array using decrRef() as it is no more
2483 * \throw If \a this->getNumberOfComponents() is not in [4,6,9].
2485 DataArrayDouble *DataArrayDouble::trace() const
2488 int nbOfComp=getNumberOfComponents();
2489 if(nbOfComp!=6 && nbOfComp!=9 && nbOfComp!=4)
2490 throw INTERP_KERNEL::Exception("DataArrayDouble::trace : must be an array with 4,6 or 9 components !");
2491 DataArrayDouble *ret=DataArrayDouble::New();
2492 int nbOfTuple=getNumberOfTuples();
2493 ret->alloc(nbOfTuple,1);
2494 const double *src=getConstPointer();
2495 double *dest=ret->getPointer();
2497 for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
2498 *dest=src[0]+src[1]+src[2];
2499 else if(nbOfComp==4)
2500 for(int i=0;i<nbOfTuple;i++,dest++,src+=4)
2501 *dest=src[0]+src[3];
2503 for(int i=0;i<nbOfTuple;i++,dest++,src+=9)
2504 *dest=src[0]+src[4]+src[8];
2509 * Computes the stress deviator tensor of every stress tensor defined by the tuple of
2510 * \a this array, which contains 6 components.
2511 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
2512 * same number of components and tuples as \a this array.
2513 * The caller is to delete this result array using decrRef() as it is no more
2515 * \throw If \a this->getNumberOfComponents() != 6.
2517 DataArrayDouble *DataArrayDouble::deviator() const
2520 int nbOfComp=getNumberOfComponents();
2522 throw INTERP_KERNEL::Exception("DataArrayDouble::deviator : must be an array with exactly 6 components !");
2523 DataArrayDouble *ret=DataArrayDouble::New();
2524 int nbOfTuple=getNumberOfTuples();
2525 ret->alloc(nbOfTuple,6);
2526 const double *src=getConstPointer();
2527 double *dest=ret->getPointer();
2528 for(int i=0;i<nbOfTuple;i++,dest+=6,src+=6)
2530 double tr=(src[0]+src[1]+src[2])/3.;
2542 * Computes the magnitude of every vector defined by the tuple of
2544 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
2545 * same number of tuples as \a this array and one component.
2546 * The caller is to delete this result array using decrRef() as it is no more
2548 * \throw If \a this is not allocated.
2550 DataArrayDouble *DataArrayDouble::magnitude() const
2553 int nbOfComp=getNumberOfComponents();
2554 DataArrayDouble *ret=DataArrayDouble::New();
2555 int nbOfTuple=getNumberOfTuples();
2556 ret->alloc(nbOfTuple,1);
2557 const double *src=getConstPointer();
2558 double *dest=ret->getPointer();
2559 for(int i=0;i<nbOfTuple;i++,dest++)
2562 for(int j=0;j<nbOfComp;j++,src++)
2570 * Computes for each tuple the sum of number of components values in the tuple and return it.
2572 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
2573 * same number of tuples as \a this array and one component.
2574 * The caller is to delete this result array using decrRef() as it is no more
2576 * \throw If \a this is not allocated.
2578 DataArrayDouble *DataArrayDouble::sumPerTuple() const
2581 int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
2582 MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
2583 ret->alloc(nbOfTuple,1);
2584 const double *src(getConstPointer());
2585 double *dest(ret->getPointer());
2586 for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
2587 *dest=std::accumulate(src,src+nbOfComp,0.);
2592 * Computes the maximal value within every tuple of \a this array.
2593 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
2594 * same number of tuples as \a this array and one component.
2595 * The caller is to delete this result array using decrRef() as it is no more
2597 * \throw If \a this is not allocated.
2598 * \sa DataArrayDouble::maxPerTupleWithCompoId
2600 DataArrayDouble *DataArrayDouble::maxPerTuple() const
2603 int nbOfComp=getNumberOfComponents();
2604 MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
2605 int nbOfTuple=getNumberOfTuples();
2606 ret->alloc(nbOfTuple,1);
2607 const double *src=getConstPointer();
2608 double *dest=ret->getPointer();
2609 for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
2610 *dest=*std::max_element(src,src+nbOfComp);
2615 * Computes the maximal value within every tuple of \a this array and it returns the first component
2616 * id for each tuple that corresponds to the maximal value within the tuple.
2618 * \param [out] compoIdOfMaxPerTuple - the new new instance of DataArrayInt containing the
2619 * same number of tuples and only one component.
2620 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
2621 * same number of tuples as \a this array and one component.
2622 * The caller is to delete this result array using decrRef() as it is no more
2624 * \throw If \a this is not allocated.
2625 * \sa DataArrayDouble::maxPerTuple
2627 DataArrayDouble *DataArrayDouble::maxPerTupleWithCompoId(DataArrayInt* &compoIdOfMaxPerTuple) const
2630 int nbOfComp=getNumberOfComponents();
2631 MCAuto<DataArrayDouble> ret0=DataArrayDouble::New();
2632 MCAuto<DataArrayInt> ret1=DataArrayInt::New();
2633 int nbOfTuple=getNumberOfTuples();
2634 ret0->alloc(nbOfTuple,1); ret1->alloc(nbOfTuple,1);
2635 const double *src=getConstPointer();
2636 double *dest=ret0->getPointer(); int *dest1=ret1->getPointer();
2637 for(int i=0;i<nbOfTuple;i++,dest++,dest1++,src+=nbOfComp)
2639 const double *loc=std::max_element(src,src+nbOfComp);
2641 *dest1=(int)std::distance(src,loc);
2643 compoIdOfMaxPerTuple=ret1.retn();
2648 * This method returns a newly allocated DataArrayDouble instance having one component and \c this->getNumberOfTuples() * \c this->getNumberOfTuples() tuples.
2649 * \n This returned array contains the euclidian distance for each tuple in \a this.
2650 * \n So the returned array can be seen as a dense symmetrical matrix whose diagonal elements are equal to 0.
2651 * \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)
2653 * \warning use this method with care because it can leads to big amount of consumed memory !
2655 * \return A newly allocated (huge) MEDCoupling::DataArrayDouble instance that the caller should deal with.
2657 * \throw If \a this is not allocated.
2659 * \sa DataArrayDouble::buildEuclidianDistanceDenseMatrixWith
2661 DataArrayDouble *DataArrayDouble::buildEuclidianDistanceDenseMatrix() const
2664 int nbOfComp=getNumberOfComponents();
2665 int nbOfTuples=getNumberOfTuples();
2666 const double *inData=getConstPointer();
2667 MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
2668 ret->alloc(nbOfTuples*nbOfTuples,1);
2669 double *outData=ret->getPointer();
2670 for(int i=0;i<nbOfTuples;i++)
2672 outData[i*nbOfTuples+i]=0.;
2673 for(int j=i+1;j<nbOfTuples;j++)
2676 for(int k=0;k<nbOfComp;k++)
2677 { double delta=inData[i*nbOfComp+k]-inData[j*nbOfComp+k]; dist+=delta*delta; }
2679 outData[i*nbOfTuples+j]=dist;
2680 outData[j*nbOfTuples+i]=dist;
2687 * This method returns a newly allocated DataArrayDouble instance having one component and \c this->getNumberOfTuples() * \c other->getNumberOfTuples() tuples.
2688 * \n This returned array contains the euclidian distance for each tuple in \a other with each tuple in \a this.
2689 * \n So the returned array can be seen as a dense rectangular matrix with \c other->getNumberOfTuples() rows and \c this->getNumberOfTuples() columns.
2690 * \n Output rectangular matrix is sorted along rows.
2691 * \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)
2693 * \warning use this method with care because it can leads to big amount of consumed memory !
2695 * \param [in] other DataArrayDouble instance having same number of components than \a this.
2696 * \return A newly allocated (huge) MEDCoupling::DataArrayDouble instance that the caller should deal with.
2698 * \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.
2700 * \sa DataArrayDouble::buildEuclidianDistanceDenseMatrix
2702 DataArrayDouble *DataArrayDouble::buildEuclidianDistanceDenseMatrixWith(const DataArrayDouble *other) const
2705 throw INTERP_KERNEL::Exception("DataArrayDouble::buildEuclidianDistanceDenseMatrixWith : input parameter is null !");
2707 other->checkAllocated();
2708 int nbOfComp=getNumberOfComponents();
2709 int otherNbOfComp=other->getNumberOfComponents();
2710 if(nbOfComp!=otherNbOfComp)
2712 std::ostringstream oss; oss << "DataArrayDouble::buildEuclidianDistanceDenseMatrixWith : this nb of compo=" << nbOfComp << " and other nb of compo=" << otherNbOfComp << ". It should match !";
2713 throw INTERP_KERNEL::Exception(oss.str().c_str());
2715 int nbOfTuples=getNumberOfTuples();
2716 int otherNbOfTuples=other->getNumberOfTuples();
2717 const double *inData=getConstPointer();
2718 const double *inDataOther=other->getConstPointer();
2719 MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
2720 ret->alloc(otherNbOfTuples*nbOfTuples,1);
2721 double *outData=ret->getPointer();
2722 for(int i=0;i<otherNbOfTuples;i++,inDataOther+=nbOfComp)
2724 for(int j=0;j<nbOfTuples;j++)
2727 for(int k=0;k<nbOfComp;k++)
2728 { double delta=inDataOther[k]-inData[j*nbOfComp+k]; dist+=delta*delta; }
2730 outData[i*nbOfTuples+j]=dist;
2737 * Sorts value within every tuple of \a this array.
2738 * \param [in] asc - if \a true, the values are sorted in ascending order, else,
2739 * in descending order.
2740 * \throw If \a this is not allocated.
2742 void DataArrayDouble::sortPerTuple(bool asc)
2745 double *pt=getPointer();
2746 int nbOfTuple=getNumberOfTuples();
2747 int nbOfComp=getNumberOfComponents();
2749 for(int i=0;i<nbOfTuple;i++,pt+=nbOfComp)
2750 std::sort(pt,pt+nbOfComp);
2752 for(int i=0;i<nbOfTuple;i++,pt+=nbOfComp)
2753 std::sort(pt,pt+nbOfComp,std::greater<double>());
2758 * Converts every value of \a this array to its absolute value.
2759 * \b WARNING this method is non const. If a new DataArrayDouble instance should be built containing the result of abs DataArrayDouble::computeAbs
2760 * should be called instead.
2762 * \throw If \a this is not allocated.
2763 * \sa DataArrayDouble::computeAbs
2765 void DataArrayDouble::abs()
2768 double *ptr(getPointer());
2769 std::size_t nbOfElems(getNbOfElems());
2770 std::transform(ptr,ptr+nbOfElems,ptr,std::ptr_fun<double,double>(fabs));
2775 * This method builds a new instance of \a this object containing the result of std::abs applied of all elements in \a this.
2776 * This method is a const method (that do not change any values in \a this) contrary to DataArrayDouble::abs method.
2778 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
2779 * same number of tuples and component as \a this array.
2780 * The caller is to delete this result array using decrRef() as it is no more
2782 * \throw If \a this is not allocated.
2783 * \sa DataArrayDouble::abs
2785 DataArrayDouble *DataArrayDouble::computeAbs() const
2788 DataArrayDouble *newArr(DataArrayDouble::New());
2789 int nbOfTuples(getNumberOfTuples());
2790 int nbOfComp(getNumberOfComponents());
2791 newArr->alloc(nbOfTuples,nbOfComp);
2792 std::transform(begin(),end(),newArr->getPointer(),std::ptr_fun<double,double>(fabs));
2793 newArr->copyStringInfoFrom(*this);
2798 * Apply a linear function to a given component of \a this array, so that
2799 * an array element <em>(x)</em> becomes \f$ a * x + b \f$.
2800 * \param [in] a - the first coefficient of the function.
2801 * \param [in] b - the second coefficient of the function.
2802 * \param [in] compoId - the index of component to modify.
2803 * \throw If \a this is not allocated, or \a compoId is not in [0,\c this->getNumberOfComponents() ).
2805 void DataArrayDouble::applyLin(double a, double b, int compoId)
2808 double *ptr(getPointer()+compoId);
2809 int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
2810 if(compoId<0 || compoId>=nbOfComp)
2812 std::ostringstream oss; oss << "DataArrayDouble::applyLin : The compoId requested (" << compoId << ") is not valid ! Must be in [0," << nbOfComp << ") !";
2813 throw INTERP_KERNEL::Exception(oss.str().c_str());
2815 for(int i=0;i<nbOfTuple;i++,ptr+=nbOfComp)
2821 * Apply a linear function to all elements of \a this array, so that
2822 * an element _x_ becomes \f$ a * x + b \f$.
2823 * \param [in] a - the first coefficient of the function.
2824 * \param [in] b - the second coefficient of the function.
2825 * \throw If \a this is not allocated.
2827 void DataArrayDouble::applyLin(double a, double b)
2830 double *ptr=getPointer();
2831 std::size_t nbOfElems=getNbOfElems();
2832 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
2838 * Modify all elements of \a this array, so that
2839 * an element _x_ becomes \f$ numerator / x \f$.
2840 * \warning If an exception is thrown because of presence of 0.0 element in \a this
2841 * array, all elements processed before detection of the zero element remain
2843 * \param [in] numerator - the numerator used to modify array elements.
2844 * \throw If \a this is not allocated.
2845 * \throw If there is an element equal to 0.0 in \a this array.
2847 void DataArrayDouble::applyInv(double numerator)
2850 double *ptr=getPointer();
2851 std::size_t nbOfElems=getNbOfElems();
2852 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
2854 if(std::abs(*ptr)>std::numeric_limits<double>::min())
2856 *ptr=numerator/(*ptr);
2860 std::ostringstream oss; oss << "DataArrayDouble::applyInv : presence of null value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
2862 throw INTERP_KERNEL::Exception(oss.str().c_str());
2869 * Returns a full copy of \a this array except that sign of all elements is reversed.
2870 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
2871 * same number of tuples and component as \a this array.
2872 * The caller is to delete this result array using decrRef() as it is no more
2874 * \throw If \a this is not allocated.
2876 DataArrayDouble *DataArrayDouble::negate() const
2879 DataArrayDouble *newArr=DataArrayDouble::New();
2880 int nbOfTuples=getNumberOfTuples();
2881 int nbOfComp=getNumberOfComponents();
2882 newArr->alloc(nbOfTuples,nbOfComp);
2883 const double *cptr=getConstPointer();
2884 std::transform(cptr,cptr+nbOfTuples*nbOfComp,newArr->getPointer(),std::negate<double>());
2885 newArr->copyStringInfoFrom(*this);
2890 * Modify all elements of \a this array, so that
2891 * an element _x_ becomes <em> val ^ x </em>. Contrary to DataArrayInt::applyPow
2892 * all values in \a this have to be >= 0 if val is \b not integer.
2893 * \param [in] val - the value used to apply pow on all array elements.
2894 * \throw If \a this is not allocated.
2895 * \warning If an exception is thrown because of presence of 0 element in \a this
2896 * array and \a val is \b not integer, all elements processed before detection of the zero element remain
2899 void DataArrayDouble::applyPow(double val)
2902 double *ptr=getPointer();
2903 std::size_t nbOfElems=getNbOfElems();
2905 bool isInt=((double)val2)==val;
2908 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
2914 std::ostringstream oss; oss << "DataArrayDouble::applyPow (double) : At elem # " << i << " value is " << *ptr << " ! must be >=0. !";
2915 throw INTERP_KERNEL::Exception(oss.str().c_str());
2921 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
2922 *ptr=pow(*ptr,val2);
2928 * Modify all elements of \a this array, so that
2929 * an element _x_ becomes \f$ val ^ x \f$.
2930 * \param [in] val - the value used to apply pow on all array elements.
2931 * \throw If \a this is not allocated.
2932 * \throw If \a val < 0.
2933 * \warning If an exception is thrown because of presence of 0 element in \a this
2934 * array, all elements processed before detection of the zero element remain
2937 void DataArrayDouble::applyRPow(double val)
2941 throw INTERP_KERNEL::Exception("DataArrayDouble::applyRPow : the input value has to be >= 0 !");
2942 double *ptr=getPointer();
2943 std::size_t nbOfElems=getNbOfElems();
2944 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
2950 * Returns a new DataArrayDouble created from \a this one by applying \a
2951 * FunctionToEvaluate to every tuple of \a this array. Textual data is not copied.
2952 * For more info see \ref MEDCouplingArrayApplyFunc
2953 * \param [in] nbOfComp - number of components in the result array.
2954 * \param [in] func - the \a FunctionToEvaluate declared as
2955 * \c bool (*\a func)(\c const \c double *\a pos, \c double *\a res),
2956 * where \a pos points to the first component of a tuple of \a this array
2957 * and \a res points to the first component of a tuple of the result array.
2958 * Note that length (number of components) of \a pos can differ from
2960 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
2961 * same number of tuples as \a this array.
2962 * The caller is to delete this result array using decrRef() as it is no more
2964 * \throw If \a this is not allocated.
2965 * \throw If \a func returns \a false.
2967 DataArrayDouble *DataArrayDouble::applyFunc(int nbOfComp, FunctionToEvaluate func) const
2970 DataArrayDouble *newArr=DataArrayDouble::New();
2971 int nbOfTuples=getNumberOfTuples();
2972 int oldNbOfComp=getNumberOfComponents();
2973 newArr->alloc(nbOfTuples,nbOfComp);
2974 const double *ptr=getConstPointer();
2975 double *ptrToFill=newArr->getPointer();
2976 for(int i=0;i<nbOfTuples;i++)
2978 if(!func(ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp))
2980 std::ostringstream oss; oss << "For tuple # " << i << " with value (";
2981 std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
2982 oss << ") : Evaluation of function failed !";
2984 throw INTERP_KERNEL::Exception(oss.str().c_str());
2991 * Returns a new DataArrayDouble created from \a this one by applying a function to every
2992 * tuple of \a this array. Textual data is not copied.
2993 * For more info see \ref MEDCouplingArrayApplyFunc1.
2994 * \param [in] nbOfComp - number of components in the result array.
2995 * \param [in] func - the expression defining how to transform a tuple of \a this array.
2996 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
2997 * \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
2998 * If false the computation is carried on without any notification. When false the evaluation is a little faster.
2999 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3000 * same number of tuples as \a this array and \a nbOfComp components.
3001 * The caller is to delete this result array using decrRef() as it is no more
3003 * \throw If \a this is not allocated.
3004 * \throw If computing \a func fails.
3006 DataArrayDouble *DataArrayDouble::applyFunc(int nbOfComp, const std::string& func, bool isSafe) const
3008 INTERP_KERNEL::ExprParser expr(func);
3010 std::set<std::string> vars;
3011 expr.getTrueSetOfVars(vars);
3012 std::vector<std::string> varsV(vars.begin(),vars.end());
3013 return applyFuncNamedCompo(nbOfComp,varsV,func,isSafe);
3017 * Returns a new DataArrayDouble created from \a this one by applying a function to every
3018 * tuple of \a this array. Textual data is not copied. This method works by tuples (whatever its size).
3019 * If \a this is a one component array, call applyFuncOnThis instead that performs the same work faster.
3021 * For more info see \ref MEDCouplingArrayApplyFunc0.
3022 * \param [in] func - the expression defining how to transform a tuple of \a this array.
3023 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
3024 * \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
3025 * If false the computation is carried on without any notification. When false the evaluation is a little faster.
3026 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3027 * same number of tuples and components as \a this array.
3028 * The caller is to delete this result array using decrRef() as it is no more
3030 * \sa applyFuncOnThis
3031 * \throw If \a this is not allocated.
3032 * \throw If computing \a func fails.
3034 DataArrayDouble *DataArrayDouble::applyFunc(const std::string& func, bool isSafe) const
3036 int nbOfComp(getNumberOfComponents());
3038 throw INTERP_KERNEL::Exception("DataArrayDouble::applyFunc : output number of component must be > 0 !");
3040 int nbOfTuples(getNumberOfTuples());
3041 MCAuto<DataArrayDouble> newArr(DataArrayDouble::New());
3042 newArr->alloc(nbOfTuples,nbOfComp);
3043 INTERP_KERNEL::ExprParser expr(func);
3045 std::set<std::string> vars;
3046 expr.getTrueSetOfVars(vars);
3047 if((int)vars.size()>1)
3049 std::ostringstream oss; oss << "DataArrayDouble::applyFunc : this method works only with at most one var func expression ! If you need to map comps on variables please use applyFuncCompo or applyFuncNamedCompo instead ! Vars in expr are : ";
3050 std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
3051 throw INTERP_KERNEL::Exception(oss.str().c_str());
3055 expr.prepareFastEvaluator();
3056 newArr->rearrange(1);
3057 newArr->fillWithValue(expr.evaluateDouble());
3058 newArr->rearrange(nbOfComp);
3059 return newArr.retn();
3061 std::vector<std::string> vars2(vars.begin(),vars.end());
3062 double buff,*ptrToFill(newArr->getPointer());
3063 const double *ptr(begin());
3064 std::vector<double> stck;
3065 expr.prepareExprEvaluationDouble(vars2,1,1,0,&buff,&buff+1);
3066 expr.prepareFastEvaluator();
3069 for(int i=0;i<nbOfTuples;i++)
3071 for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
3074 expr.evaluateDoubleInternal(stck);
3075 *ptrToFill=stck.back();
3082 for(int i=0;i<nbOfTuples;i++)
3084 for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
3089 expr.evaluateDoubleInternalSafe(stck);
3091 catch(INTERP_KERNEL::Exception& e)
3093 std::ostringstream oss; oss << "For tuple # " << i << " component # " << iComp << " with value (";
3095 oss << ") : Evaluation of function failed !" << e.what();
3096 throw INTERP_KERNEL::Exception(oss.str().c_str());
3098 *ptrToFill=stck.back();
3103 return newArr.retn();
3107 * This method is a non const method that modify the array in \a this.
3108 * This method only works on one component array. It means that function \a func must
3109 * contain at most one variable.
3110 * This method is a specialization of applyFunc method with one parameter on one component array.
3112 * \param [in] func - the expression defining how to transform a tuple of \a this array.
3113 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
3114 * \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
3115 * If false the computation is carried on without any notification. When false the evaluation is a little faster.
3119 void DataArrayDouble::applyFuncOnThis(const std::string& func, bool isSafe)
3121 int nbOfComp(getNumberOfComponents());
3123 throw INTERP_KERNEL::Exception("DataArrayDouble::applyFuncOnThis : output number of component must be > 0 !");
3125 int nbOfTuples(getNumberOfTuples());
3126 INTERP_KERNEL::ExprParser expr(func);
3128 std::set<std::string> vars;
3129 expr.getTrueSetOfVars(vars);
3130 if((int)vars.size()>1)
3132 std::ostringstream oss; oss << "DataArrayDouble::applyFuncOnThis : this method works only with at most one var func expression ! If you need to map comps on variables please use applyFuncCompo or applyFuncNamedCompo instead ! Vars in expr are : ";
3133 std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
3134 throw INTERP_KERNEL::Exception(oss.str().c_str());
3138 expr.prepareFastEvaluator();
3139 std::vector<std::string> compInfo(getInfoOnComponents());
3141 fillWithValue(expr.evaluateDouble());
3142 rearrange(nbOfComp);
3143 setInfoOnComponents(compInfo);
3146 std::vector<std::string> vars2(vars.begin(),vars.end());
3147 double buff,*ptrToFill(getPointer());
3148 const double *ptr(begin());
3149 std::vector<double> stck;
3150 expr.prepareExprEvaluationDouble(vars2,1,1,0,&buff,&buff+1);
3151 expr.prepareFastEvaluator();
3154 for(int i=0;i<nbOfTuples;i++)
3156 for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
3159 expr.evaluateDoubleInternal(stck);
3160 *ptrToFill=stck.back();
3167 for(int i=0;i<nbOfTuples;i++)
3169 for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
3174 expr.evaluateDoubleInternalSafe(stck);
3176 catch(INTERP_KERNEL::Exception& e)
3178 std::ostringstream oss; oss << "For tuple # " << i << " component # " << iComp << " with value (";
3180 oss << ") : Evaluation of function failed !" << e.what();
3181 throw INTERP_KERNEL::Exception(oss.str().c_str());
3183 *ptrToFill=stck.back();
3191 * Returns a new DataArrayDouble created from \a this one by applying a function to every
3192 * tuple of \a this array. Textual data is not copied.
3193 * For more info see \ref MEDCouplingArrayApplyFunc2.
3194 * \param [in] nbOfComp - number of components in the result array.
3195 * \param [in] func - the expression defining how to transform a tuple of \a this array.
3196 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
3197 * \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
3198 * If false the computation is carried on without any notification. When false the evaluation is a little faster.
3199 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3200 * same number of tuples as \a this array.
3201 * The caller is to delete this result array using decrRef() as it is no more
3203 * \throw If \a this is not allocated.
3204 * \throw If \a func contains vars that are not in \a this->getInfoOnComponent().
3205 * \throw If computing \a func fails.
3207 DataArrayDouble *DataArrayDouble::applyFuncCompo(int nbOfComp, const std::string& func, bool isSafe) const
3209 return applyFuncNamedCompo(nbOfComp,getVarsOnComponent(),func,isSafe);
3213 * Returns a new DataArrayDouble created from \a this one by applying a function to every
3214 * tuple of \a this array. Textual data is not copied.
3215 * For more info see \ref MEDCouplingArrayApplyFunc3.
3216 * \param [in] nbOfComp - number of components in the result array.
3217 * \param [in] varsOrder - sequence of vars defining their order.
3218 * \param [in] func - the expression defining how to transform a tuple of \a this array.
3219 * Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
3220 * \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
3221 * If false the computation is carried on without any notification. When false the evaluation is a little faster.
3222 * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3223 * same number of tuples as \a this array.
3224 * The caller is to delete this result array using decrRef() as it is no more
3226 * \throw If \a this is not allocated.
3227 * \throw If \a func contains vars not in \a varsOrder.
3228 * \throw If computing \a func fails.
3230 DataArrayDouble *DataArrayDouble::applyFuncNamedCompo(int nbOfComp, const std::vector<std::string>& varsOrder, const std::string& func, bool isSafe) const
3233 throw INTERP_KERNEL::Exception("DataArrayDouble::applyFuncNamedCompo : output number of component must be > 0 !");
3234 std::vector<std::string> varsOrder2(varsOrder);
3235 int oldNbOfComp(getNumberOfComponents());
3236 for(int i=(int)varsOrder.size();i<oldNbOfComp;i++)
3237 varsOrder2.push_back(std::string());
3239 int nbOfTuples(getNumberOfTuples());
3240 INTERP_KERNEL::ExprParser expr(func);
3242 std::set<std::string> vars;
3243 expr.getTrueSetOfVars(vars);
3244 if((int)vars.size()>oldNbOfComp)
3246 std::ostringstream oss; oss << "The field has " << oldNbOfComp << " components and there are ";
3247 oss << vars.size() << " variables : ";
3248 std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
3249 throw INTERP_KERNEL::Exception(oss.str().c_str());
3251 MCAuto<DataArrayDouble> newArr(DataArrayDouble::New());
3252 newArr->alloc(nbOfTuples,nbOfComp);
3253 INTERP_KERNEL::AutoPtr<double> buff(new double[oldNbOfComp]);
3254 double *buffPtr(buff),*ptrToFill;
3255 std::vector<double> stck;
3256 for(int iComp=0;iComp<nbOfComp;iComp++)
3258 expr.prepareExprEvaluationDouble(varsOrder2,oldNbOfComp,nbOfComp,iComp,buffPtr,buffPtr+oldNbOfComp);
3259 expr.prepareFastEvaluator();
3260 const double *ptr(getConstPointer());
3261 ptrToFill=newArr->getPointer()+iComp;
3264 for(int i=0;i<nbOfTuples;i++,ptrToFill+=nbOfComp,ptr+=oldNbOfComp)
3266 std::copy(ptr,ptr+oldNbOfComp,buffPtr);
3267 expr.evaluateDoubleInternal(stck);
3268 *ptrToFill=stck.back();
3274 for(int i=0;i<nbOfTuples;i++,ptrToFill+=nbOfComp,ptr+=oldNbOfComp)
3276 std::copy(ptr,ptr+oldNbOfComp,buffPtr);
3279 expr.evaluateDoubleInternalSafe(stck);
3280 *ptrToFill=stck.back();
3283 catch(INTERP_KERNEL::Exception& e)
3285 std::ostringstream oss; oss << "For tuple # " << i << " with value (";
3286 std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
3287 oss << ") : Evaluation of function failed !" << e.what();
3288 throw INTERP_KERNEL::Exception(oss.str().c_str());
3293 return newArr.retn();
3296 void DataArrayDouble::applyFuncFast32(const std::string& func)
3299 INTERP_KERNEL::ExprParser expr(func);
3301 char *funcStr=expr.compileX86();
3303 *((void **)&funcPtr)=funcStr;//he he...
3305 double *ptr=getPointer();
3306 int nbOfComp=getNumberOfComponents();
3307 int nbOfTuples=getNumberOfTuples();
3308 int nbOfElems=nbOfTuples*nbOfComp;
3309 for(int i=0;i<nbOfElems;i++,ptr++)
3314 void DataArrayDouble::applyFuncFast64(const std::string& func)
3317 INTERP_KERNEL::ExprParser expr(func);
3319 char *funcStr=expr.compileX86_64();
3321 *((void **)&funcPtr)=funcStr;//he he...
3323 double *ptr=getPointer();
3324 int nbOfComp=getNumberOfComponents();
3325 int nbOfTuples=getNumberOfTuples();
3326 int nbOfElems=nbOfTuples*nbOfComp;
3327 for(int i=0;i<nbOfElems;i++,ptr++)
3333 * \return a new object that is the result of the symmetry along 3D plane defined by its normal vector \a normalVector and a point \a point.
3335 MCAuto<DataArrayDouble> DataArrayDouble::symmetry3DPlane(const double point[3], const double normalVector[3]) const
3338 if(getNumberOfComponents()!=3)
3339 throw INTERP_KERNEL::Exception("DataArrayDouble::symmetry3DPlane : this is excepted to have 3 components !");
3340 int nbTuples(getNumberOfTuples());
3341 MCAuto<DataArrayDouble> ret(DataArrayDouble::New());
3342 ret->alloc(nbTuples,3);
3343 Symmetry3DPlane(point,normalVector,nbTuples,begin(),ret->getPointer());
3347 DataArrayDoubleIterator *DataArrayDouble::iterator()
3349 return new DataArrayDoubleIterator(this);
3353 * Returns a new DataArrayInt contating indices of tuples of \a this one-dimensional
3354 * array whose values are within a given range. Textual data is not copied.
3355 * \param [in] vmin - a lowest acceptable value (included).
3356 * \param [in] vmax - a greatest acceptable value (included).
3357 * \return DataArrayInt * - the new instance of DataArrayInt.
3358 * The caller is to delete this result array using decrRef() as it is no more
3360 * \throw If \a this->getNumberOfComponents() != 1.
3362 * \sa DataArrayDouble::findIdsNotInRange
3364 * \if ENABLE_EXAMPLES
3365 * \ref cpp_mcdataarraydouble_getidsinrange "Here is a C++ example".<br>
3366 * \ref py_mcdataarraydouble_getidsinrange "Here is a Python example".
3369 DataArrayInt *DataArrayDouble::findIdsInRange(double vmin, double vmax) const
3372 if(getNumberOfComponents()!=1)
3373 throw INTERP_KERNEL::Exception("DataArrayDouble::findIdsInRange : this must have exactly one component !");
3374 const double *cptr(begin());
3375 MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
3376 int nbOfTuples(getNumberOfTuples());
3377 for(int i=0;i<nbOfTuples;i++,cptr++)
3378 if(*cptr>=vmin && *cptr<=vmax)
3379 ret->pushBackSilent(i);
3384 * Returns a new DataArrayInt contating indices of tuples of \a this one-dimensional
3385 * array whose values are not within a given range. Textual data is not copied.
3386 * \param [in] vmin - a lowest not acceptable value (excluded).
3387 * \param [in] vmax - a greatest not acceptable value (excluded).
3388 * \return DataArrayInt * - the new instance of DataArrayInt.
3389 * The caller is to delete this result array using decrRef() as it is no more
3391 * \throw If \a this->getNumberOfComponents() != 1.
3393 * \sa DataArrayDouble::findIdsInRange
3395 DataArrayInt *DataArrayDouble::findIdsNotInRange(double vmin, double vmax) const
3398 if(getNumberOfComponents()!=1)
3399 throw INTERP_KERNEL::Exception("DataArrayDouble::findIdsNotInRange : this must have exactly one component !");
3400 const double *cptr(begin());
3401 MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
3402 int nbOfTuples(getNumberOfTuples());
3403 for(int i=0;i<nbOfTuples;i++,cptr++)
3404 if(*cptr<vmin || *cptr>vmax)
3405 ret->pushBackSilent(i);
3410 * Returns a new DataArrayDouble by concatenating two given arrays, so that (1) the number
3411 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
3412 * the number of component in the result array is same as that of each of given arrays.
3413 * Info on components is copied from the first of the given arrays. Number of components
3414 * in the given arrays must be the same.
3415 * \param [in] a1 - an array to include in the result array.
3416 * \param [in] a2 - another array to include in the result array.
3417 * \return DataArrayDouble * - the new instance of DataArrayDouble.
3418 * The caller is to delete this result array using decrRef() as it is no more
3420 * \throw If both \a a1 and \a a2 are NULL.
3421 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents().
3423 DataArrayDouble *DataArrayDouble::Aggregate(const DataArrayDouble *a1, const DataArrayDouble *a2)
3425 std::vector<const DataArrayDouble *> tmp(2);
3426 tmp[0]=a1; tmp[1]=a2;
3427 return Aggregate(tmp);
3431 * Returns a new DataArrayDouble by concatenating all given arrays, so that (1) the number
3432 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
3433 * the number of component in the result array is same as that of each of given arrays.
3434 * Info on components is copied from the first of the given arrays. Number of components
3435 * in the given arrays must be the same.
3436 * If the number of non null of elements in \a arr is equal to one the returned object is a copy of it
3437 * not the object itself.
3438 * \param [in] arr - a sequence of arrays to include in the result array.
3439 * \return DataArrayDouble * - the new instance of DataArrayDouble.
3440 * The caller is to delete this result array using decrRef() as it is no more
3442 * \throw If all arrays within \a arr are NULL.
3443 * \throw If getNumberOfComponents() of arrays within \a arr.
3445 DataArrayDouble *DataArrayDouble::Aggregate(const std::vector<const DataArrayDouble *>& arr)
3447 std::vector<const DataArrayDouble *> a;
3448 for(std::vector<const DataArrayDouble *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
3452 throw INTERP_KERNEL::Exception("DataArrayDouble::Aggregate : input list must contain at least one NON EMPTY DataArrayDouble !");
3453 std::vector<const DataArrayDouble *>::const_iterator it=a.begin();
3454 int nbOfComp=(*it)->getNumberOfComponents();
3455 int nbt=(*it++)->getNumberOfTuples();
3456 for(int i=1;it!=a.end();it++,i++)
3458 if((*it)->getNumberOfComponents()!=nbOfComp)
3459 throw INTERP_KERNEL::Exception("DataArrayDouble::Aggregate : Nb of components mismatch for array aggregation !");
3460 nbt+=(*it)->getNumberOfTuples();
3462 MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
3463 ret->alloc(nbt,nbOfComp);
3464 double *pt=ret->getPointer();
3465 for(it=a.begin();it!=a.end();it++)
3466 pt=std::copy((*it)->getConstPointer(),(*it)->getConstPointer()+(*it)->getNbOfElems(),pt);
3467 ret->copyStringInfoFrom(*(a[0]));
3472 * Returns a new DataArrayDouble by aggregating two given arrays, so that (1) the number
3473 * of components in the result array is a sum of the number of components of given arrays
3474 * and (2) the number of tuples in the result array is same as that of each of given
3475 * arrays. In other words the i-th tuple of result array includes all components of
3476 * i-th tuples of all given arrays.
3477 * Number of tuples in the given arrays must be the same.
3478 * \param [in] a1 - an array to include in the result array.
3479 * \param [in] a2 - another array to include in the result array.
3480 * \return DataArrayDouble * - the new instance of DataArrayDouble.
3481 * The caller is to delete this result array using decrRef() as it is no more
3483 * \throw If both \a a1 and \a a2 are NULL.
3484 * \throw If any given array is not allocated.
3485 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
3487 DataArrayDouble *DataArrayDouble::Meld(const DataArrayDouble *a1, const DataArrayDouble *a2)
3489 std::vector<const DataArrayDouble *> arr(2);
3490 arr[0]=a1; arr[1]=a2;
3495 * Returns a new DataArrayDouble by aggregating all given arrays, so that (1) the number
3496 * of components in the result array is a sum of the number of components of given arrays
3497 * and (2) the number of tuples in the result array is same as that of each of given
3498 * arrays. In other words the i-th tuple of result array includes all components of
3499 * i-th tuples of all given arrays.
3500 * Number of tuples in the given arrays must be the same.
3501 * \param [in] arr - a sequence of arrays to include in the result array.
3502 * \return DataArrayDouble * - the new instance of DataArrayDouble.
3503 * The caller is to delete this result array using decrRef() as it is no more
3505 * \throw If all arrays within \a arr are NULL.
3506 * \throw If any given array is not allocated.
3507 * \throw If getNumberOfTuples() of arrays within \a arr is different.
3509 DataArrayDouble *DataArrayDouble::Meld(const std::vector<const DataArrayDouble *>& arr)
3511 std::vector<const DataArrayDouble *> a;
3512 for(std::vector<const DataArrayDouble *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
3516 throw INTERP_KERNEL::Exception("DataArrayDouble::Meld : input list must contain at least one NON EMPTY DataArrayDouble !");
3517 std::vector<const DataArrayDouble *>::const_iterator it;
3518 for(it=a.begin();it!=a.end();it++)
3519 (*it)->checkAllocated();
3521 int nbOfTuples=(*it)->getNumberOfTuples();
3522 std::vector<int> nbc(a.size());
3523 std::vector<const double *> pts(a.size());
3524 nbc[0]=(*it)->getNumberOfComponents();
3525 pts[0]=(*it++)->getConstPointer();
3526 for(int i=1;it!=a.end();it++,i++)
3528 if(nbOfTuples!=(*it)->getNumberOfTuples())
3529 throw INTERP_KERNEL::Exception("DataArrayDouble::Meld : mismatch of number of tuples !");
3530 nbc[i]=(*it)->getNumberOfComponents();
3531 pts[i]=(*it)->getConstPointer();
3533 int totalNbOfComp=std::accumulate(nbc.begin(),nbc.end(),0);
3534 DataArrayDouble *ret=DataArrayDouble::New();
3535 ret->alloc(nbOfTuples,totalNbOfComp);
3536 double *retPtr=ret->getPointer();
3537 for(int i=0;i<nbOfTuples;i++)
3538 for(int j=0;j<(int)a.size();j++)
3540 retPtr=std::copy(pts[j],pts[j]+nbc[j],retPtr);
3544 for(int i=0;i<(int)a.size();i++)
3545 for(int j=0;j<nbc[i];j++,k++)
3546 ret->setInfoOnComponent(k,a[i]->getInfoOnComponent(j));
3551 * Returns a new DataArrayDouble containing a dot product of two given arrays, so that
3552 * the i-th tuple of the result array is a sum of products of j-th components of i-th
3553 * tuples of given arrays (\f$ a_i = \sum_{j=1}^n a1_j * a2_j \f$).
3554 * Info on components and name is copied from the first of the given arrays.
3555 * Number of tuples and components in the given arrays must be the same.
3556 * \param [in] a1 - a given array.
3557 * \param [in] a2 - another given array.
3558 * \return DataArrayDouble * - the new instance of DataArrayDouble.
3559 * The caller is to delete this result array using decrRef() as it is no more
3561 * \throw If either \a a1 or \a a2 is NULL.
3562 * \throw If any given array is not allocated.
3563 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
3564 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
3566 DataArrayDouble *DataArrayDouble::Dot(const DataArrayDouble *a1, const DataArrayDouble *a2)
3569 throw INTERP_KERNEL::Exception("DataArrayDouble::Dot : input DataArrayDouble instance is NULL !");
3570 a1->checkAllocated();
3571 a2->checkAllocated();
3572 int nbOfComp=a1->getNumberOfComponents();
3573 if(nbOfComp!=a2->getNumberOfComponents())
3574 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Dot !");
3575 int nbOfTuple=a1->getNumberOfTuples();
3576 if(nbOfTuple!=a2->getNumberOfTuples())
3577 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Dot !");
3578 DataArrayDouble *ret=DataArrayDouble::New();
3579 ret->alloc(nbOfTuple,1);
3580 double *retPtr=ret->getPointer();
3581 const double *a1Ptr=a1->getConstPointer();
3582 const double *a2Ptr=a2->getConstPointer();
3583 for(int i=0;i<nbOfTuple;i++)
3586 for(int j=0;j<nbOfComp;j++)
3587 sum+=a1Ptr[i*nbOfComp+j]*a2Ptr[i*nbOfComp+j];
3590 ret->setInfoOnComponent(0,a1->getInfoOnComponent(0));
3591 ret->setName(a1->getName());
3596 * Returns a new DataArrayDouble containing a cross product of two given arrays, so that
3597 * the i-th tuple of the result array contains 3 components of a vector which is a cross
3598 * product of two vectors defined by the i-th tuples of given arrays.
3599 * Info on components is copied from the first of the given arrays.
3600 * Number of tuples in the given arrays must be the same.
3601 * Number of components in the given arrays must be 3.
3602 * \param [in] a1 - a given array.
3603 * \param [in] a2 - another given array.
3604 * \return DataArrayDouble * - the new instance of DataArrayDouble.
3605 * The caller is to delete this result array using decrRef() as it is no more
3607 * \throw If either \a a1 or \a a2 is NULL.
3608 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
3609 * \throw If \a a1->getNumberOfComponents() != 3
3610 * \throw If \a a2->getNumberOfComponents() != 3
3612 DataArrayDouble *DataArrayDouble::CrossProduct(const DataArrayDouble *a1, const DataArrayDouble *a2)
3615 throw INTERP_KERNEL::Exception("DataArrayDouble::CrossProduct : input DataArrayDouble instance is NULL !");
3616 int nbOfComp=a1->getNumberOfComponents();
3617 if(nbOfComp!=a2->getNumberOfComponents())
3618 throw INTERP_KERNEL::Exception("Nb of components mismatch for array crossProduct !");
3620 throw INTERP_KERNEL::Exception("Nb of components must be equal to 3 for array crossProduct !");
3621 int nbOfTuple=a1->getNumberOfTuples();
3622 if(nbOfTuple!=a2->getNumberOfTuples())
3623 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array crossProduct !");
3624 DataArrayDouble *ret=DataArrayDouble::New();
3625 ret->alloc(nbOfTuple,3);
3626 double *retPtr=ret->getPointer();
3627 const double *a1Ptr=a1->getConstPointer();
3628 const double *a2Ptr=a2->getConstPointer();
3629 for(int i=0;i<nbOfTuple;i++)
3631 retPtr[3*i]=a1Ptr[3*i+1]*a2Ptr[3*i+2]-a1Ptr[3*i+2]*a2Ptr[3*i+1];
3632 retPtr[3*i+1]=a1Ptr[3*i+2]*a2Ptr[3*i]-a1Ptr[3*i]*a2Ptr[3*i+2];
3633 retPtr[3*i+2]=a1Ptr[3*i]*a2Ptr[3*i+1]-a1Ptr[3*i+1]*a2Ptr[3*i];
3635 ret->copyStringInfoFrom(*a1);
3640 * Returns a new DataArrayDouble containing maximal values of two given arrays.
3641 * Info on components is copied from the first of the given arrays.
3642 * Number of tuples and components in the given arrays must be the same.
3643 * \param [in] a1 - an array to compare values with another one.
3644 * \param [in] a2 - another array to compare values with the first one.
3645 * \return DataArrayDouble * - the new instance of DataArrayDouble.
3646 * The caller is to delete this result array using decrRef() as it is no more
3648 * \throw If either \a a1 or \a a2 is NULL.
3649 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
3650 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
3652 DataArrayDouble *DataArrayDouble::Max(const DataArrayDouble *a1, const DataArrayDouble *a2)
3655 throw INTERP_KERNEL::Exception("DataArrayDouble::Max : input DataArrayDouble instance is NULL !");
3656 int nbOfComp=a1->getNumberOfComponents();
3657 if(nbOfComp!=a2->getNumberOfComponents())
3658 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Max !");
3659 int nbOfTuple=a1->getNumberOfTuples();
3660 if(nbOfTuple!=a2->getNumberOfTuples())
3661 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Max !");
3662 DataArrayDouble *ret=DataArrayDouble::New();
3663 ret->alloc(nbOfTuple,nbOfComp);
3664 double *retPtr=ret->getPointer();
3665 const double *a1Ptr=a1->getConstPointer();
3666 const double *a2Ptr=a2->getConstPointer();
3667 int nbElem=nbOfTuple*nbOfComp;
3668 for(int i=0;i<nbElem;i++)
3669 retPtr[i]=std::max(a1Ptr[i],a2Ptr[i]);
3670 ret->copyStringInfoFrom(*a1);
3675 * Returns a new DataArrayDouble containing minimal values of two given arrays.
3676 * Info on components is copied from the first of the given arrays.
3677 * Number of tuples and components in the given arrays must be the same.
3678 * \param [in] a1 - an array to compare values with another one.
3679 * \param [in] a2 - another array to compare values with the first one.
3680 * \return DataArrayDouble * - the new instance of DataArrayDouble.
3681 * The caller is to delete this result array using decrRef() as it is no more
3683 * \throw If either \a a1 or \a a2 is NULL.
3684 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
3685 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
3687 DataArrayDouble *DataArrayDouble::Min(const DataArrayDouble *a1, const DataArrayDouble *a2)
3690 throw INTERP_KERNEL::Exception("DataArrayDouble::Min : input DataArrayDouble instance is NULL !");
3691 int nbOfComp=a1->getNumberOfComponents();
3692 if(nbOfComp!=a2->getNumberOfComponents())
3693 throw INTERP_KERNEL::Exception("Nb of components mismatch for array min !");
3694 int nbOfTuple=a1->getNumberOfTuples();
3695 if(nbOfTuple!=a2->getNumberOfTuples())
3696 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array min !");
3697 DataArrayDouble *ret=DataArrayDouble::New();
3698 ret->alloc(nbOfTuple,nbOfComp);
3699 double *retPtr=ret->getPointer();
3700 const double *a1Ptr=a1->getConstPointer();
3701 const double *a2Ptr=a2->getConstPointer();
3702 int nbElem=nbOfTuple*nbOfComp;
3703 for(int i=0;i<nbElem;i++)
3704 retPtr[i]=std::min(a1Ptr[i],a2Ptr[i]);
3705 ret->copyStringInfoFrom(*a1);
3710 * Returns a new DataArrayDouble that is a sum of two given arrays. There are 3
3712 * 1. The arrays have same number of tuples and components. Then each value of
3713 * the result array (_a_) is a sum of the corresponding values of \a a1 and \a a2,
3714 * i.e.: _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, j ].
3715 * 2. The arrays have same number of tuples and one array, say _a2_, has one
3717 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, 0 ].
3718 * 3. The arrays have same number of components and one array, say _a2_, has one
3720 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ 0, j ].
3722 * Info on components is copied either from the first array (in the first case) or from
3723 * the array with maximal number of elements (getNbOfElems()).
3724 * \param [in] a1 - an array to sum up.
3725 * \param [in] a2 - another array to sum up.
3726 * \return DataArrayDouble * - the new instance of DataArrayDouble.
3727 * The caller is to delete this result array using decrRef() as it is no more
3729 * \throw If either \a a1 or \a a2 is NULL.
3730 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
3731 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
3732 * none of them has number of tuples or components equal to 1.
3734 DataArrayDouble *DataArrayDouble::Add(const DataArrayDouble *a1, const DataArrayDouble *a2)
3737 throw INTERP_KERNEL::Exception("DataArrayDouble::Add : input DataArrayDouble instance is NULL !");
3738 int nbOfTuple=a1->getNumberOfTuples();
3739 int nbOfTuple2=a2->getNumberOfTuples();
3740 int nbOfComp=a1->getNumberOfComponents();
3741 int nbOfComp2=a2->getNumberOfComponents();
3742 MCAuto<DataArrayDouble> ret=0;
3743 if(nbOfTuple==nbOfTuple2)
3745 if(nbOfComp==nbOfComp2)
3747 ret=DataArrayDouble::New();
3748 ret->alloc(nbOfTuple,nbOfComp);
3749 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::plus<double>());
3750 ret->copyStringInfoFrom(*a1);
3754 int nbOfCompMin,nbOfCompMax;
3755 const DataArrayDouble *aMin, *aMax;
3756 if(nbOfComp>nbOfComp2)
3758 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
3763 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
3768 ret=DataArrayDouble::New();
3769 ret->alloc(nbOfTuple,nbOfCompMax);
3770 const double *aMinPtr=aMin->getConstPointer();
3771 const double *aMaxPtr=aMax->getConstPointer();
3772 double *res=ret->getPointer();
3773 for(int i=0;i<nbOfTuple;i++)
3774 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::plus<double>(),aMinPtr[i]));
3775 ret->copyStringInfoFrom(*aMax);
3778 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
3781 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
3783 if(nbOfComp==nbOfComp2)
3785 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
3786 const DataArrayDouble *aMin=nbOfTuple>nbOfTuple2?a2:a1;
3787 const DataArrayDouble *aMax=nbOfTuple>nbOfTuple2?a1:a2;
3788 const double *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
3789 ret=DataArrayDouble::New();
3790 ret->alloc(nbOfTupleMax,nbOfComp);
3791 double *res=ret->getPointer();
3792 for(int i=0;i<nbOfTupleMax;i++)
3793 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::plus<double>());
3794 ret->copyStringInfoFrom(*aMax);
3797 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
3800 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Add !");
3805 * Adds values of another DataArrayDouble to values of \a this one. There are 3
3807 * 1. The arrays have same number of tuples and components. Then each value of
3808 * \a other array is added to the corresponding value of \a this array, i.e.:
3809 * _a_ [ i, j ] += _other_ [ i, j ].
3810 * 2. The arrays have same number of tuples and \a other array has one component. Then
3811 * _a_ [ i, j ] += _other_ [ i, 0 ].
3812 * 3. The arrays have same number of components and \a other array has one tuple. Then
3813 * _a_ [ i, j ] += _a2_ [ 0, j ].
3815 * \param [in] other - an array to add to \a this one.
3816 * \throw If \a other is NULL.
3817 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
3818 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
3819 * \a other has number of both tuples and components not equal to 1.
3821 void DataArrayDouble::addEqual(const DataArrayDouble *other)
3824 throw INTERP_KERNEL::Exception("DataArrayDouble::addEqual : input DataArrayDouble instance is NULL !");
3825 const char *msg="Nb of tuples mismatch for DataArrayDouble::addEqual !";
3827 other->checkAllocated();
3828 int nbOfTuple=getNumberOfTuples();
3829 int nbOfTuple2=other->getNumberOfTuples();
3830 int nbOfComp=getNumberOfComponents();
3831 int nbOfComp2=other->getNumberOfComponents();
3832 if(nbOfTuple==nbOfTuple2)
3834 if(nbOfComp==nbOfComp2)
3836 std::transform(begin(),end(),other->begin(),getPointer(),std::plus<double>());
3838 else if(nbOfComp2==1)
3840 double *ptr=getPointer();
3841 const double *ptrc=other->getConstPointer();
3842 for(int i=0;i<nbOfTuple;i++)
3843 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::plus<double>(),*ptrc++));
3846 throw INTERP_KERNEL::Exception(msg);
3848 else if(nbOfTuple2==1)
3850 if(nbOfComp2==nbOfComp)
3852 double *ptr=getPointer();
3853 const double *ptrc=other->getConstPointer();
3854 for(int i=0;i<nbOfTuple;i++)
3855 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::plus<double>());
3858 throw INTERP_KERNEL::Exception(msg);
3861 throw INTERP_KERNEL::Exception(msg);
3866 * Returns a new DataArrayDouble that is a subtraction of two given arrays. There are 3
3868 * 1. The arrays have same number of tuples and components. Then each value of
3869 * the result array (_a_) is a subtraction of the corresponding values of \a a1 and
3870 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, j ].
3871 * 2. The arrays have same number of tuples and one array, say _a2_, has one
3873 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, 0 ].
3874 * 3. The arrays have same number of components and one array, say _a2_, has one
3876 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ 0, j ].
3878 * Info on components is copied either from the first array (in the first case) or from
3879 * the array with maximal number of elements (getNbOfElems()).
3880 * \param [in] a1 - an array to subtract from.
3881 * \param [in] a2 - an array to subtract.
3882 * \return DataArrayDouble * - the new instance of DataArrayDouble.
3883 * The caller is to delete this result array using decrRef() as it is no more
3885 * \throw If either \a a1 or \a a2 is NULL.
3886 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
3887 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
3888 * none of them has number of tuples or components equal to 1.
3890 DataArrayDouble *DataArrayDouble::Substract(const DataArrayDouble *a1, const DataArrayDouble *a2)
3893 throw INTERP_KERNEL::Exception("DataArrayDouble::Substract : input DataArrayDouble instance is NULL !");
3894 int nbOfTuple1=a1->getNumberOfTuples();
3895 int nbOfTuple2=a2->getNumberOfTuples();
3896 int nbOfComp1=a1->getNumberOfComponents();
3897 int nbOfComp2=a2->getNumberOfComponents();
3898 if(nbOfTuple2==nbOfTuple1)
3900 if(nbOfComp1==nbOfComp2)
3902 MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
3903 ret->alloc(nbOfTuple2,nbOfComp1);
3904 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::minus<double>());
3905 ret->copyStringInfoFrom(*a1);
3908 else if(nbOfComp2==1)
3910 MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
3911 ret->alloc(nbOfTuple1,nbOfComp1);
3912 const double *a2Ptr=a2->getConstPointer();
3913 const double *a1Ptr=a1->getConstPointer();
3914 double *res=ret->getPointer();
3915 for(int i=0;i<nbOfTuple1;i++)
3916 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::minus<double>(),a2Ptr[i]));
3917 ret->copyStringInfoFrom(*a1);
3922 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
3926 else if(nbOfTuple2==1)
3928 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
3929 MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
3930 ret->alloc(nbOfTuple1,nbOfComp1);
3931 const double *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
3932 double *pt=ret->getPointer();
3933 for(int i=0;i<nbOfTuple1;i++)
3934 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::minus<double>());
3935 ret->copyStringInfoFrom(*a1);
3940 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Substract !");//will always throw an exception
3946 * Subtract values of another DataArrayDouble from values of \a this one. There are 3
3948 * 1. The arrays have same number of tuples and components. Then each value of
3949 * \a other array is subtracted from the corresponding value of \a this array, i.e.:
3950 * _a_ [ i, j ] -= _other_ [ i, j ].
3951 * 2. The arrays have same number of tuples and \a other array has one component. Then
3952 * _a_ [ i, j ] -= _other_ [ i, 0 ].
3953 * 3. The arrays have same number of components and \a other array has one tuple. Then
3954 * _a_ [ i, j ] -= _a2_ [ 0, j ].
3956 * \param [in] other - an array to subtract from \a this one.
3957 * \throw If \a other is NULL.
3958 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
3959 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
3960 * \a other has number of both tuples and components not equal to 1.
3962 void DataArrayDouble::substractEqual(const DataArrayDouble *other)
3965 throw INTERP_KERNEL::Exception("DataArrayDouble::substractEqual : input DataArrayDouble instance is NULL !");
3966 const char *msg="Nb of tuples mismatch for DataArrayDouble::substractEqual !";
3968 other->checkAllocated();
3969 int nbOfTuple=getNumberOfTuples();
3970 int nbOfTuple2=other->getNumberOfTuples();
3971 int nbOfComp=getNumberOfComponents();
3972 int nbOfComp2=other->getNumberOfComponents();
3973 if(nbOfTuple==nbOfTuple2)
3975 if(nbOfComp==nbOfComp2)
3977 std::transform(begin(),end(),other->begin(),getPointer(),std::minus<double>());
3979 else if(nbOfComp2==1)
3981 double *ptr=getPointer();
3982 const double *ptrc=other->getConstPointer();
3983 for(int i=0;i<nbOfTuple;i++)
3984 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::minus<double>(),*ptrc++));
3987 throw INTERP_KERNEL::Exception(msg);
3989 else if(nbOfTuple2==1)
3991 if(nbOfComp2==nbOfComp)
3993 double *ptr=getPointer();
3994 const double *ptrc=other->getConstPointer();
3995 for(int i=0;i<nbOfTuple;i++)
3996 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::minus<double>());
3999 throw INTERP_KERNEL::Exception(msg);
4002 throw INTERP_KERNEL::Exception(msg);
4007 * Returns a new DataArrayDouble that is a product of two given arrays. There are 3
4009 * 1. The arrays have same number of tuples and components. Then each value of
4010 * the result array (_a_) is a product of the corresponding values of \a a1 and
4011 * \a a2, i.e. _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, j ].
4012 * 2. The arrays have same number of tuples and one array, say _a2_, has one
4014 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, 0 ].
4015 * 3. The arrays have same number of components and one array, say _a2_, has one
4017 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ 0, j ].
4019 * Info on components is copied either from the first array (in the first case) or from
4020 * the array with maximal number of elements (getNbOfElems()).
4021 * \param [in] a1 - a factor array.
4022 * \param [in] a2 - another factor array.
4023 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4024 * The caller is to delete this result array using decrRef() as it is no more
4026 * \throw If either \a a1 or \a a2 is NULL.
4027 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
4028 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
4029 * none of them has number of tuples or components equal to 1.
4031 DataArrayDouble *DataArrayDouble::Multiply(const DataArrayDouble *a1, const DataArrayDouble *a2)
4034 throw INTERP_KERNEL::Exception("DataArrayDouble::Multiply : input DataArrayDouble instance is NULL !");
4035 int nbOfTuple=a1->getNumberOfTuples();
4036 int nbOfTuple2=a2->getNumberOfTuples();
4037 int nbOfComp=a1->getNumberOfComponents();
4038 int nbOfComp2=a2->getNumberOfComponents();
4039 MCAuto<DataArrayDouble> ret=0;
4040 if(nbOfTuple==nbOfTuple2)
4042 if(nbOfComp==nbOfComp2)
4044 ret=DataArrayDouble::New();
4045 ret->alloc(nbOfTuple,nbOfComp);
4046 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::multiplies<double>());
4047 ret->copyStringInfoFrom(*a1);
4051 int nbOfCompMin,nbOfCompMax;
4052 const DataArrayDouble *aMin, *aMax;
4053 if(nbOfComp>nbOfComp2)
4055 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
4060 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
4065 ret=DataArrayDouble::New();
4066 ret->alloc(nbOfTuple,nbOfCompMax);
4067 const double *aMinPtr=aMin->getConstPointer();
4068 const double *aMaxPtr=aMax->getConstPointer();
4069 double *res=ret->getPointer();
4070 for(int i=0;i<nbOfTuple;i++)
4071 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::multiplies<double>(),aMinPtr[i]));
4072 ret->copyStringInfoFrom(*aMax);
4075 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
4078 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
4080 if(nbOfComp==nbOfComp2)
4082 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
4083 const DataArrayDouble *aMin=nbOfTuple>nbOfTuple2?a2:a1;
4084 const DataArrayDouble *aMax=nbOfTuple>nbOfTuple2?a1:a2;
4085 const double *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
4086 ret=DataArrayDouble::New();
4087 ret->alloc(nbOfTupleMax,nbOfComp);
4088 double *res=ret->getPointer();
4089 for(int i=0;i<nbOfTupleMax;i++)
4090 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::multiplies<double>());
4091 ret->copyStringInfoFrom(*aMax);
4094 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
4097 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Multiply !");
4102 * Multiply values of another DataArrayDouble to values of \a this one. There are 3
4104 * 1. The arrays have same number of tuples and components. Then each value of
4105 * \a other array is multiplied to the corresponding value of \a this array, i.e.
4106 * _this_ [ i, j ] *= _other_ [ i, j ].
4107 * 2. The arrays have same number of tuples and \a other array has one component. Then
4108 * _this_ [ i, j ] *= _other_ [ i, 0 ].
4109 * 3. The arrays have same number of components and \a other array has one tuple. Then
4110 * _this_ [ i, j ] *= _a2_ [ 0, j ].
4112 * \param [in] other - an array to multiply to \a this one.
4113 * \throw If \a other is NULL.
4114 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
4115 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
4116 * \a other has number of both tuples and components not equal to 1.
4118 void DataArrayDouble::multiplyEqual(const DataArrayDouble *other)
4121 throw INTERP_KERNEL::Exception("DataArrayDouble::multiplyEqual : input DataArrayDouble instance is NULL !");
4122 const char *msg="Nb of tuples mismatch for DataArrayDouble::multiplyEqual !";
4124 other->checkAllocated();
4125 int nbOfTuple=getNumberOfTuples();
4126 int nbOfTuple2=other->getNumberOfTuples();
4127 int nbOfComp=getNumberOfComponents();
4128 int nbOfComp2=other->getNumberOfComponents();
4129 if(nbOfTuple==nbOfTuple2)
4131 if(nbOfComp==nbOfComp2)
4133 std::transform(begin(),end(),other->begin(),getPointer(),std::multiplies<double>());
4135 else if(nbOfComp2==1)
4137 double *ptr=getPointer();
4138 const double *ptrc=other->getConstPointer();
4139 for(int i=0;i<nbOfTuple;i++)
4140 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::multiplies<double>(),*ptrc++));
4143 throw INTERP_KERNEL::Exception(msg);
4145 else if(nbOfTuple2==1)
4147 if(nbOfComp2==nbOfComp)
4149 double *ptr=getPointer();
4150 const double *ptrc=other->getConstPointer();
4151 for(int i=0;i<nbOfTuple;i++)
4152 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::multiplies<double>());
4155 throw INTERP_KERNEL::Exception(msg);
4158 throw INTERP_KERNEL::Exception(msg);
4163 * Returns a new DataArrayDouble that is a division of two given arrays. There are 3
4165 * 1. The arrays have same number of tuples and components. Then each value of
4166 * the result array (_a_) is a division of the corresponding values of \a a1 and
4167 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, j ].
4168 * 2. The arrays have same number of tuples and one array, say _a2_, has one
4170 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, 0 ].
4171 * 3. The arrays have same number of components and one array, say _a2_, has one
4173 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ 0, j ].
4175 * Info on components is copied either from the first array (in the first case) or from
4176 * the array with maximal number of elements (getNbOfElems()).
4177 * \warning No check of division by zero is performed!
4178 * \param [in] a1 - a numerator array.
4179 * \param [in] a2 - a denominator array.
4180 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4181 * The caller is to delete this result array using decrRef() as it is no more
4183 * \throw If either \a a1 or \a a2 is NULL.
4184 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
4185 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
4186 * none of them has number of tuples or components equal to 1.
4188 DataArrayDouble *DataArrayDouble::Divide(const DataArrayDouble *a1, const DataArrayDouble *a2)
4191 throw INTERP_KERNEL::Exception("DataArrayDouble::Divide : input DataArrayDouble instance is NULL !");
4192 int nbOfTuple1=a1->getNumberOfTuples();
4193 int nbOfTuple2=a2->getNumberOfTuples();
4194 int nbOfComp1=a1->getNumberOfComponents();
4195 int nbOfComp2=a2->getNumberOfComponents();
4196 if(nbOfTuple2==nbOfTuple1)
4198 if(nbOfComp1==nbOfComp2)
4200 MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
4201 ret->alloc(nbOfTuple2,nbOfComp1);
4202 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::divides<double>());
4203 ret->copyStringInfoFrom(*a1);
4206 else if(nbOfComp2==1)
4208 MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
4209 ret->alloc(nbOfTuple1,nbOfComp1);
4210 const double *a2Ptr=a2->getConstPointer();
4211 const double *a1Ptr=a1->getConstPointer();
4212 double *res=ret->getPointer();
4213 for(int i=0;i<nbOfTuple1;i++)
4214 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::divides<double>(),a2Ptr[i]));
4215 ret->copyStringInfoFrom(*a1);
4220 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
4224 else if(nbOfTuple2==1)
4226 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
4227 MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
4228 ret->alloc(nbOfTuple1,nbOfComp1);
4229 const double *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
4230 double *pt=ret->getPointer();
4231 for(int i=0;i<nbOfTuple1;i++)
4232 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::divides<double>());
4233 ret->copyStringInfoFrom(*a1);
4238 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Divide !");//will always throw an exception
4244 * Divide values of \a this array by values of another DataArrayDouble. There are 3
4246 * 1. The arrays have same number of tuples and components. Then each value of
4247 * \a this array is divided by the corresponding value of \a other one, i.e.:
4248 * _a_ [ i, j ] /= _other_ [ i, j ].
4249 * 2. The arrays have same number of tuples and \a other array has one component. Then
4250 * _a_ [ i, j ] /= _other_ [ i, 0 ].
4251 * 3. The arrays have same number of components and \a other array has one tuple. Then
4252 * _a_ [ i, j ] /= _a2_ [ 0, j ].
4254 * \warning No check of division by zero is performed!
4255 * \param [in] other - an array to divide \a this one by.
4256 * \throw If \a other is NULL.
4257 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
4258 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
4259 * \a other has number of both tuples and components not equal to 1.
4261 void DataArrayDouble::divideEqual(const DataArrayDouble *other)
4264 throw INTERP_KERNEL::Exception("DataArrayDouble::divideEqual : input DataArrayDouble instance is NULL !");
4265 const char *msg="Nb of tuples mismatch for DataArrayDouble::divideEqual !";
4267 other->checkAllocated();
4268 int nbOfTuple=getNumberOfTuples();
4269 int nbOfTuple2=other->getNumberOfTuples();
4270 int nbOfComp=getNumberOfComponents();
4271 int nbOfComp2=other->getNumberOfComponents();
4272 if(nbOfTuple==nbOfTuple2)
4274 if(nbOfComp==nbOfComp2)
4276 std::transform(begin(),end(),other->begin(),getPointer(),std::divides<double>());
4278 else if(nbOfComp2==1)
4280 double *ptr=getPointer();
4281 const double *ptrc=other->getConstPointer();
4282 for(int i=0;i<nbOfTuple;i++)
4283 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::divides<double>(),*ptrc++));
4286 throw INTERP_KERNEL::Exception(msg);
4288 else if(nbOfTuple2==1)
4290 if(nbOfComp2==nbOfComp)
4292 double *ptr=getPointer();
4293 const double *ptrc=other->getConstPointer();
4294 for(int i=0;i<nbOfTuple;i++)
4295 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::divides<double>());
4298 throw INTERP_KERNEL::Exception(msg);
4301 throw INTERP_KERNEL::Exception(msg);
4306 * Returns a new DataArrayDouble that is the result of pow of two given arrays. There are 3
4309 * \param [in] a1 - an array to pow up.
4310 * \param [in] a2 - another array to sum up.
4311 * \return DataArrayDouble * - the new instance of DataArrayDouble.
4312 * The caller is to delete this result array using decrRef() as it is no more
4314 * \throw If either \a a1 or \a a2 is NULL.
4315 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4316 * \throw If \a a1->getNumberOfComponents() != 1 or \a a2->getNumberOfComponents() != 1.
4317 * \throw If there is a negative value in \a a1.
4319 DataArrayDouble *DataArrayDouble::Pow(const DataArrayDouble *a1, const DataArrayDouble *a2)
4322 throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : at least one of input instances is null !");
4323 int nbOfTuple=a1->getNumberOfTuples();
4324 int nbOfTuple2=a2->getNumberOfTuples();
4325 int nbOfComp=a1->getNumberOfComponents();
4326 int nbOfComp2=a2->getNumberOfComponents();
4327 if(nbOfTuple!=nbOfTuple2)
4328 throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : number of tuples mismatches !");
4329 if(nbOfComp!=1 || nbOfComp2!=1)
4330 throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : number of components of both arrays must be equal to 1 !");
4331 MCAuto<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(nbOfTuple,1);
4332 const double *ptr1(a1->begin()),*ptr2(a2->begin());
4333 double *ptr=ret->getPointer();
4334 for(int i=0;i<nbOfTuple;i++,ptr1++,ptr2++,ptr++)
4338 *ptr=pow(*ptr1,*ptr2);
4342 std::ostringstream oss; oss << "DataArrayDouble::Pow : on tuple #" << i << " of a1 value is < 0 (" << *ptr1 << ") !";
4343 throw INTERP_KERNEL::Exception(oss.str().c_str());
4350 * Apply pow on values of another DataArrayDouble to values of \a this one.
4352 * \param [in] other - an array to pow to \a this one.
4353 * \throw If \a other is NULL.
4354 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples()
4355 * \throw If \a this->getNumberOfComponents() != 1 or \a other->getNumberOfComponents() != 1
4356 * \throw If there is a negative value in \a this.
4358 void DataArrayDouble::powEqual(const DataArrayDouble *other)
4361 throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : input instance is null !");
4362 int nbOfTuple=getNumberOfTuples();
4363 int nbOfTuple2=other->getNumberOfTuples();
4364 int nbOfComp=getNumberOfComponents();
4365 int nbOfComp2=other->getNumberOfComponents();
4366 if(nbOfTuple!=nbOfTuple2)
4367 throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : number of tuples mismatches !");
4368 if(nbOfComp!=1 || nbOfComp2!=1)
4369 throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : number of components of both arrays must be equal to 1 !");
4370 double *ptr=getPointer();
4371 const double *ptrc=other->begin();
4372 for(int i=0;i<nbOfTuple;i++,ptrc++,ptr++)
4375 *ptr=pow(*ptr,*ptrc);
4378 std::ostringstream oss; oss << "DataArrayDouble::powEqual : on tuple #" << i << " of this value is < 0 (" << *ptr << ") !";
4379 throw INTERP_KERNEL::Exception(oss.str().c_str());
4386 * This method is \b NOT wrapped into python because it can be useful only for performance reasons in C++ context.
4387 * All values in \a this must be 0. or 1. within eps error. 0 means false, 1 means true.
4388 * If an another value than 0 or 1 appear (within eps precision) an INTERP_KERNEL::Exception will be thrown.
4390 * \throw if \a this is not allocated.
4391 * \throw if \a this has not exactly one component.
4393 std::vector<bool> DataArrayDouble::toVectorOfBool(double eps) const
4396 if(getNumberOfComponents()!=1)
4397 throw INTERP_KERNEL::Exception("DataArrayDouble::toVectorOfBool : must be applied on single component array !");
4398 int nbt(getNumberOfTuples());
4399 std::vector<bool> ret(nbt);
4400 const double *pt(begin());
4401 for(int i=0;i<nbt;i++)
4405 else if(fabs(pt[i]-1.)<eps)
4409 std::ostringstream oss; oss << "DataArrayDouble::toVectorOfBool : the tuple #" << i << " has value " << pt[i] << " is invalid ! must be 0. or 1. !";
4410 throw INTERP_KERNEL::Exception(oss.str().c_str());
4417 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
4420 void DataArrayDouble::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
4425 tinyInfo[0]=getNumberOfTuples();
4426 tinyInfo[1]=getNumberOfComponents();
4436 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
4439 void DataArrayDouble::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
4443 int nbOfCompo=getNumberOfComponents();
4444 tinyInfo.resize(nbOfCompo+1);
4445 tinyInfo[0]=getName();
4446 for(int i=0;i<nbOfCompo;i++)
4447 tinyInfo[i+1]=getInfoOnComponent(i);
4452 tinyInfo[0]=getName();
4457 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
4458 * This method returns if a feeding is needed.
4460 bool DataArrayDouble::resizeForUnserialization(const std::vector<int>& tinyInfoI)
4462 int nbOfTuple=tinyInfoI[0];
4463 int nbOfComp=tinyInfoI[1];
4464 if(nbOfTuple!=-1 || nbOfComp!=-1)
4466 alloc(nbOfTuple,nbOfComp);
4473 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
4475 void DataArrayDouble::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<std::string>& tinyInfoS)
4477 setName(tinyInfoS[0]);
4480 int nbOfCompo=getNumberOfComponents();
4481 for(int i=0;i<nbOfCompo;i++)
4482 setInfoOnComponent(i,tinyInfoS[i+1]);
4487 * Low static method that operates 3D rotation of 'nbNodes' 3D nodes whose coordinates are arranged in \a coordsIn
4488 * around an axe ( \a center, \a vect) and with angle \a angle.
4490 void DataArrayDouble::Rotate3DAlg(const double *center, const double *vect, double angle, int nbNodes, const double *coordsIn, double *coordsOut)
4492 if(!center || !vect)
4493 throw INTERP_KERNEL::Exception("DataArrayDouble::Rotate3DAlg : null vector in input !");
4494 double sina(sin(angle));
4495 double cosa(cos(angle));
4496 double vectorNorm[3];
4498 double matrixTmp[9];
4499 double norm(sqrt(vect[0]*vect[0]+vect[1]*vect[1]+vect[2]*vect[2]));
4500 if(norm<std::numeric_limits<double>::min())
4501 throw INTERP_KERNEL::Exception("DataArrayDouble::Rotate3DAlg : magnitude of input vector is too close of 0. !");
4502 std::transform(vect,vect+3,vectorNorm,std::bind2nd(std::multiplies<double>(),1/norm));
4503 //rotation matrix computation
4504 matrix[0]=cosa; matrix[1]=0.; matrix[2]=0.; matrix[3]=0.; matrix[4]=cosa; matrix[5]=0.; matrix[6]=0.; matrix[7]=0.; matrix[8]=cosa;
4505 matrixTmp[0]=vectorNorm[0]*vectorNorm[0]; matrixTmp[1]=vectorNorm[0]*vectorNorm[1]; matrixTmp[2]=vectorNorm[0]*vectorNorm[2];
4506 matrixTmp[3]=vectorNorm[1]*vectorNorm[0]; matrixTmp[4]=vectorNorm[1]*vectorNorm[1]; matrixTmp[5]=vectorNorm[1]*vectorNorm[2];
4507 matrixTmp[6]=vectorNorm[2]*vectorNorm[0]; matrixTmp[7]=vectorNorm[2]*vectorNorm[1]; matrixTmp[8]=vectorNorm[2]*vectorNorm[2];
4508 std::transform(matrixTmp,matrixTmp+9,matrixTmp,std::bind2nd(std::multiplies<double>(),1-cosa));
4509 std::transform(matrix,matrix+9,matrixTmp,matrix,std::plus<double>());
4510 matrixTmp[0]=0.; matrixTmp[1]=-vectorNorm[2]; matrixTmp[2]=vectorNorm[1];
4511 matrixTmp[3]=vectorNorm[2]; matrixTmp[4]=0.; matrixTmp[5]=-vectorNorm[0];
4512 matrixTmp[6]=-vectorNorm[1]; matrixTmp[7]=vectorNorm[0]; matrixTmp[8]=0.;
4513 std::transform(matrixTmp,matrixTmp+9,matrixTmp,std::bind2nd(std::multiplies<double>(),sina));
4514 std::transform(matrix,matrix+9,matrixTmp,matrix,std::plus<double>());
4515 //rotation matrix computed.
4517 for(int i=0; i<nbNodes; i++)
4519 std::transform(coordsIn+i*3,coordsIn+(i+1)*3,center,tmp,std::minus<double>());
4520 coordsOut[i*3]=matrix[0]*tmp[0]+matrix[1]*tmp[1]+matrix[2]*tmp[2]+center[0];
4521 coordsOut[i*3+1]=matrix[3]*tmp[0]+matrix[4]*tmp[1]+matrix[5]*tmp[2]+center[1];
4522 coordsOut[i*3+2]=matrix[6]*tmp[0]+matrix[7]*tmp[1]+matrix[8]*tmp[2]+center[2];
4526 void DataArrayDouble::Symmetry3DPlane(const double point[3], const double normalVector[3], int nbNodes, const double *coordsIn, double *coordsOut)
4528 double matrix[9],matrix2[9],matrix3[9];
4529 double vect[3],crossVect[3];
4530 INTERP_KERNEL::orthogonalVect3(normalVector,vect);
4531 crossVect[0]=normalVector[1]*vect[2]-normalVector[2]*vect[1];
4532 crossVect[1]=normalVector[2]*vect[0]-normalVector[0]*vect[2];
4533 crossVect[2]=normalVector[0]*vect[1]-normalVector[1]*vect[0];
4534 double nv(INTERP_KERNEL::norm<3>(vect)),ni(INTERP_KERNEL::norm<3>(normalVector)),nc(INTERP_KERNEL::norm<3>(crossVect));
4535 matrix[0]=vect[0]/nv; matrix[1]=crossVect[0]/nc; matrix[2]=-normalVector[0]/ni;
4536 matrix[3]=vect[1]/nv; matrix[4]=crossVect[1]/nc; matrix[5]=-normalVector[1]/ni;
4537 matrix[6]=vect[2]/nv; matrix[7]=crossVect[2]/nc; matrix[8]=-normalVector[2]/ni;
4538 matrix2[0]=vect[0]/nv; matrix2[1]=vect[1]/nv; matrix2[2]=vect[2]/nv;
4539 matrix2[3]=crossVect[0]/nc; matrix2[4]=crossVect[1]/nc; matrix2[5]=crossVect[2]/nc;
4540 matrix2[6]=normalVector[0]/ni; matrix2[7]=normalVector[1]/ni; matrix2[8]=normalVector[2]/ni;
4541 for(int i=0;i<3;i++)
4542 for(int j=0;j<3;j++)
4545 for(int k=0;k<3;k++)
4546 val+=matrix[3*i+k]*matrix2[3*k+j];
4549 //rotation matrix computed.
4551 for(int i=0; i<nbNodes; i++)
4553 std::transform(coordsIn+i*3,coordsIn+(i+1)*3,point,tmp,std::minus<double>());
4554 coordsOut[i*3]=matrix3[0]*tmp[0]+matrix3[1]*tmp[1]+matrix3[2]*tmp[2]+point[0];
4555 coordsOut[i*3+1]=matrix3[3]*tmp[0]+matrix3[4]*tmp[1]+matrix3[5]*tmp[2]+point[1];
4556 coordsOut[i*3+2]=matrix3[6]*tmp[0]+matrix3[7]*tmp[1]+matrix3[8]*tmp[2]+point[2];
4560 void DataArrayDouble::GiveBaseForPlane(const double normalVector[3], double baseOfPlane[9])
4562 double vect[3],crossVect[3];
4563 INTERP_KERNEL::orthogonalVect3(normalVector,vect);
4564 crossVect[0]=normalVector[1]*vect[2]-normalVector[2]*vect[1];
4565 crossVect[1]=normalVector[2]*vect[0]-normalVector[0]*vect[2];
4566 crossVect[2]=normalVector[0]*vect[1]-normalVector[1]*vect[0];
4567 double nv(INTERP_KERNEL::norm<3>(vect)),ni(INTERP_KERNEL::norm<3>(normalVector)),nc(INTERP_KERNEL::norm<3>(crossVect));
4568 baseOfPlane[0]=vect[0]/nv; baseOfPlane[1]=vect[1]/nv; baseOfPlane[2]=vect[2]/nv;
4569 baseOfPlane[3]=crossVect[0]/nc; baseOfPlane[4]=crossVect[1]/nc; baseOfPlane[5]=crossVect[2]/nc;
4570 baseOfPlane[6]=normalVector[0]/ni; baseOfPlane[7]=normalVector[1]/ni; baseOfPlane[8]=normalVector[2]/ni;
4574 * Low static method that operates 3D rotation of \a nbNodes 3D nodes whose coordinates are arranged in \a coords
4575 * around the center point \a center and with angle \a angle.
4577 void DataArrayDouble::Rotate2DAlg(const double *center, double angle, int nbNodes, const double *coordsIn, double *coordsOut)
4579 double cosa=cos(angle);
4580 double sina=sin(angle);
4582 matrix[0]=cosa; matrix[1]=-sina; matrix[2]=sina; matrix[3]=cosa;
4584 for(int i=0; i<nbNodes; i++)
4586 std::transform(coordsIn+i*2,coordsIn+(i+1)*2,center,tmp,std::minus<double>());
4587 coordsOut[i*2]=matrix[0]*tmp[0]+matrix[1]*tmp[1]+center[0];
4588 coordsOut[i*2+1]=matrix[2]*tmp[0]+matrix[3]*tmp[1]+center[1];
4592 DataArrayDoubleIterator::DataArrayDoubleIterator(DataArrayDouble *da):_da(da),_tuple_id(0),_nb_comp(0),_nb_tuple(0)
4597 if(_da->isAllocated())
4599 _nb_comp=da->getNumberOfComponents();
4600 _nb_tuple=da->getNumberOfTuples();
4601 _pt=da->getPointer();
4606 DataArrayDoubleIterator::~DataArrayDoubleIterator()
4612 DataArrayDoubleTuple *DataArrayDoubleIterator::nextt()
4614 if(_tuple_id<_nb_tuple)
4617 DataArrayDoubleTuple *ret=new DataArrayDoubleTuple(_pt,_nb_comp);
4625 DataArrayDoubleTuple::DataArrayDoubleTuple(double *pt, int nbOfComp):_pt(pt),_nb_of_compo(nbOfComp)
4630 std::string DataArrayDoubleTuple::repr() const
4632 std::ostringstream oss; oss.precision(17); oss << "(";
4633 for(int i=0;i<_nb_of_compo-1;i++)
4634 oss << _pt[i] << ", ";
4635 oss << _pt[_nb_of_compo-1] << ")";
4639 double DataArrayDoubleTuple::doubleValue() const
4643 throw INTERP_KERNEL::Exception("DataArrayDoubleTuple::doubleValue : DataArrayDoubleTuple instance has not exactly 1 component -> Not possible to convert it into a double precision float !");
4647 * This method returns a newly allocated instance the caller should dealed with by a MEDCoupling::DataArrayDouble::decrRef.
4648 * This method performs \b no copy of data. The content is only referenced using MEDCoupling::DataArrayDouble::useArray with ownership set to \b false.
4649 * 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
4650 * \b nbOfCompo=1 and \bnbOfTuples==this->_nb_of_elem.
4652 DataArrayDouble *DataArrayDoubleTuple::buildDADouble(int nbOfTuples, int nbOfCompo) const
4654 if((_nb_of_compo==nbOfCompo && nbOfTuples==1) || (_nb_of_compo==nbOfTuples && nbOfCompo==1))
4656 DataArrayDouble *ret=DataArrayDouble::New();
4657 ret->useExternalArrayWithRWAccess(_pt,nbOfTuples,nbOfCompo);
4662 std::ostringstream oss; oss << "DataArrayDoubleTuple::buildDADouble : unable to build a requested DataArrayDouble instance with nbofTuple=" << nbOfTuples << " and nbOfCompo=" << nbOfCompo;
4663 oss << ".\nBecause the number of elements in this is " << _nb_of_compo << " !";
4664 throw INTERP_KERNEL::Exception(oss.str().c_str());
4669 * Returns a new instance of DataArrayInt. The caller is to delete this array
4670 * using decrRef() as it is no more needed.
4672 DataArrayInt *DataArrayInt::New()
4674 return new DataArrayInt;
4678 * Returns the only one value in \a this, if and only if number of elements
4679 * (nb of tuples * nb of components) is equal to 1, and that \a this is allocated.
4680 * \return double - the sole value stored in \a this array.
4681 * \throw If at least one of conditions stated above is not fulfilled.
4683 int DataArrayInt::intValue() const
4687 if(getNbOfElems()==1)
4689 return *getConstPointer();
4692 throw INTERP_KERNEL::Exception("DataArrayInt::intValue : DataArrayInt instance is allocated but number of elements is not equal to 1 !");
4695 throw INTERP_KERNEL::Exception("DataArrayInt::intValue : DataArrayInt instance is not allocated !");
4699 * Returns an integer value characterizing \a this array, which is useful for a quick
4700 * comparison of many instances of DataArrayInt.
4701 * \return int - the hash value.
4702 * \throw If \a this is not allocated.
4704 int DataArrayInt::getHashCode() const
4707 std::size_t nbOfElems=getNbOfElems();
4708 int ret=nbOfElems*65536;
4713 const int *pt=begin();
4714 for(std::size_t i=0;i<nbOfElems;i+=delta)
4715 ret0+=pt[i] & 0x1FFF;
4720 * Returns a full copy of \a this. For more info on copying data arrays see
4721 * \ref MEDCouplingArrayBasicsCopyDeep.
4722 * \return DataArrayInt * - a new instance of DataArrayInt.
4724 DataArrayInt *DataArrayInt::deepCopy() const
4726 return new DataArrayInt(*this);
4730 * Returns either a \a deep or \a shallow copy of this array. For more info see
4731 * \ref MEDCouplingArrayBasicsCopyDeep and \ref MEDCouplingArrayBasicsCopyShallow.
4732 * \param [in] dCpy - if \a true, a deep copy is returned, else, a shallow one.
4733 * \return DataArrayInt * - either a new instance of DataArrayInt (if \a dCpy
4734 * == \a true) or \a this instance (if \a dCpy == \a false).
4736 DataArrayInt *DataArrayInt::performCopyOrIncrRef(bool dCpy) const
4743 return const_cast<DataArrayInt *>(this);
4748 * Assign zero to all values in \a this array. To know more on filling arrays see
4749 * \ref MEDCouplingArrayFill.
4750 * \throw If \a this is not allocated.
4752 void DataArrayInt::fillWithZero()
4758 * Set all values in \a this array so that the i-th element equals to \a init + i
4759 * (i starts from zero). To know more on filling arrays see \ref MEDCouplingArrayFill.
4760 * \param [in] init - value to assign to the first element of array.
4761 * \throw If \a this->getNumberOfComponents() != 1
4762 * \throw If \a this is not allocated.
4764 void DataArrayInt::iota(int init)
4767 if(getNumberOfComponents()!=1)
4768 throw INTERP_KERNEL::Exception("DataArrayInt::iota : works only for arrays with only one component, you can call 'rearrange' method before !");
4769 int *ptr=getPointer();
4770 int ntuples=getNumberOfTuples();
4771 for(int i=0;i<ntuples;i++)
4777 * Returns a textual and human readable representation of \a this instance of
4778 * DataArrayInt. This text is shown when a DataArrayInt is printed in Python.
4779 * \return std::string - text describing \a this DataArrayInt.
4781 * \sa reprNotTooLong, reprZip
4783 std::string DataArrayInt::repr() const
4785 std::ostringstream ret;
4790 std::string DataArrayInt::reprZip() const
4792 std::ostringstream ret;
4798 * This method is close to repr method except that when \a this has more than 1000 tuples, all tuples are not
4799 * printed out to avoid to consume too much space in interpretor.
4802 std::string DataArrayInt::reprNotTooLong() const
4804 std::ostringstream ret;
4805 reprNotTooLongStream(ret);
4809 void DataArrayInt::writeVTK(std::ostream& ofs, int indent, const std::string& type, const std::string& nameInFile, DataArrayByte *byteArr) const
4811 static const char SPACE[4]={' ',' ',' ',' '};
4813 std::string idt(indent,' ');
4814 ofs << idt << "<DataArray type=\"" << type << "\" Name=\"" << nameInFile << "\" NumberOfComponents=\"" << getNumberOfComponents() << "\"";
4817 ofs << " format=\"appended\" offset=\"" << byteArr->getNumberOfTuples() << "\">";
4818 if(std::string(type)=="Int32")
4820 const char *data(reinterpret_cast<const char *>(begin()));
4821 std::size_t sz(getNbOfElems()*sizeof(int));
4822 byteArr->insertAtTheEnd(data,data+sz);
4823 byteArr->insertAtTheEnd(SPACE,SPACE+4);
4825 else if(std::string(type)=="Int8")
4827 INTERP_KERNEL::AutoPtr<char> tmp(new char[getNbOfElems()]);
4828 std::copy(begin(),end(),(char *)tmp);
4829 byteArr->insertAtTheEnd((char *)tmp,(char *)tmp+getNbOfElems());
4830 byteArr->insertAtTheEnd(SPACE,SPACE+4);
4832 else if(std::string(type)=="UInt8")
4834 INTERP_KERNEL::AutoPtr<unsigned char> tmp(new unsigned char[getNbOfElems()]);
4835 std::copy(begin(),end(),(unsigned char *)tmp);
4836 byteArr->insertAtTheEnd((unsigned char *)tmp,(unsigned char *)tmp+getNbOfElems());
4837 byteArr->insertAtTheEnd(SPACE,SPACE+4);
4840 throw INTERP_KERNEL::Exception("DataArrayInt::writeVTK : Only Int32, Int8 and UInt8 supported !");
4844 ofs << " RangeMin=\"" << getMinValueInArray() << "\" RangeMax=\"" << getMaxValueInArray() << "\" format=\"ascii\">\n" << idt;
4845 std::copy(begin(),end(),std::ostream_iterator<int>(ofs," "));
4847 ofs << std::endl << idt << "</DataArray>\n";
4850 void DataArrayInt::reprStream(std::ostream& stream) const
4852 stream << "Name of int array : \"" << _name << "\"\n";
4853 reprWithoutNameStream(stream);
4856 void DataArrayInt::reprZipStream(std::ostream& stream) const
4858 stream << "Name of int array : \"" << _name << "\"\n";
4859 reprZipWithoutNameStream(stream);
4862 void DataArrayInt::reprNotTooLongStream(std::ostream& stream) const
4864 stream << "Name of int array : \"" << _name << "\"\n";
4865 reprNotTooLongWithoutNameStream(stream);
4868 void DataArrayInt::reprWithoutNameStream(std::ostream& stream) const
4870 DataArray::reprWithoutNameStream(stream);
4871 _mem.repr(getNumberOfComponents(),stream);
4874 void DataArrayInt::reprZipWithoutNameStream(std::ostream& stream) const
4876 DataArray::reprWithoutNameStream(stream);
4877 _mem.reprZip(getNumberOfComponents(),stream);
4880 void DataArrayInt::reprNotTooLongWithoutNameStream(std::ostream& stream) const
4882 DataArray::reprWithoutNameStream(stream);
4883 stream.precision(17);
4884 _mem.reprNotTooLong(getNumberOfComponents(),stream);
4887 void DataArrayInt::reprCppStream(const std::string& varName, std::ostream& stream) const
4889 int nbTuples=getNumberOfTuples(),nbComp=getNumberOfComponents();
4890 const int *data=getConstPointer();
4891 stream << "DataArrayInt *" << varName << "=DataArrayInt::New();" << std::endl;
4892 if(nbTuples*nbComp>=1)
4894 stream << "const int " << varName << "Data[" << nbTuples*nbComp << "]={";
4895 std::copy(data,data+nbTuples*nbComp-1,std::ostream_iterator<int>(stream,","));
4896 stream << data[nbTuples*nbComp-1] << "};" << std::endl;
4897 stream << varName << "->useArray(" << varName << "Data,false,CPP_DEALLOC," << nbTuples << "," << nbComp << ");" << std::endl;
4900 stream << varName << "->alloc(" << nbTuples << "," << nbComp << ");" << std::endl;
4901 stream << varName << "->setName(\"" << getName() << "\");" << std::endl;
4905 * Method that gives a quick overvien of \a this for python.
4907 void DataArrayInt::reprQuickOverview(std::ostream& stream) const
4909 static const std::size_t MAX_NB_OF_BYTE_IN_REPR=300;
4910 stream << "DataArrayInt C++ instance at " << this << ". ";
4913 int nbOfCompo=(int)_info_on_compo.size();
4916 int nbOfTuples=getNumberOfTuples();
4917 stream << "Number of tuples : " << nbOfTuples << ". Number of components : " << nbOfCompo << "." << std::endl;
4918 reprQuickOverviewData(stream,MAX_NB_OF_BYTE_IN_REPR);
4921 stream << "Number of components : 0.";
4924 stream << "*** No data allocated ****";
4927 void DataArrayInt::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const
4929 const int *data=begin();
4930 int nbOfTuples=getNumberOfTuples();
4931 int nbOfCompo=(int)_info_on_compo.size();
4932 std::ostringstream oss2; oss2 << "[";
4933 std::string oss2Str(oss2.str());
4934 bool isFinished=true;
4935 for(int i=0;i<nbOfTuples && isFinished;i++)
4940 for(int j=0;j<nbOfCompo;j++,data++)
4943 if(j!=nbOfCompo-1) oss2 << ", ";
4949 if(i!=nbOfTuples-1) oss2 << ", ";
4950 std::string oss3Str(oss2.str());
4951 if(oss3Str.length()<maxNbOfByteInRepr)
4963 * Modifies in place \a this one-dimensional array so that each value \a v = \a indArrBg[ \a v ],
4964 * i.e. a current value is used as in index to get a new value from \a indArrBg.
4965 * \param [in] indArrBg - pointer to the first element of array of new values to assign
4967 * \param [in] indArrEnd - specifies the end of the array \a indArrBg, so that
4968 * the last value of \a indArrBg is \a indArrEnd[ -1 ].
4969 * \throw If \a this->getNumberOfComponents() != 1
4970 * \throw If any value of \a this can't be used as a valid index for
4971 * [\a indArrBg, \a indArrEnd).
4975 void DataArrayInt::transformWithIndArr(const int *indArrBg, const int *indArrEnd)
4978 if(getNumberOfComponents()!=1)
4979 throw INTERP_KERNEL::Exception("Call transformWithIndArr method on DataArrayInt with only one component, you can call 'rearrange' method before !");
4980 int nbElemsIn((int)std::distance(indArrBg,indArrEnd)),nbOfTuples(getNumberOfTuples()),*pt(getPointer());
4981 for(int i=0;i<nbOfTuples;i++,pt++)
4983 if(*pt>=0 && *pt<nbElemsIn)
4987 std::ostringstream oss; oss << "DataArrayInt::transformWithIndArr : error on tuple #" << i << " of this value is " << *pt << ", should be in [0," << nbElemsIn << ") !";
4988 throw INTERP_KERNEL::Exception(oss.str().c_str());
4995 * Computes distribution of values of \a this one-dimensional array between given value
4996 * ranges (casts). This method is typically useful for entity number spliting by types,
4998 * \warning The values contained in \a arrBg should be sorted ascendently. No
4999 * check of this is be done. If not, the result is not warranted.
5000 * \param [in] arrBg - the array of ascending values defining the value ranges. The i-th
5001 * value of \a arrBg (\a arrBg[ i ]) gives the lowest value of the i-th range,
5002 * and the greatest value of the i-th range equals to \a arrBg[ i+1 ] - 1. \a
5003 * arrBg containing \a n values defines \a n-1 ranges. The last value of \a arrBg
5004 * should be more than every value in \a this array.
5005 * \param [in] arrEnd - specifies the end of the array \a arrBg, so that
5006 * the last value of \a arrBg is \a arrEnd[ -1 ].
5007 * \param [out] castArr - a new instance of DataArrayInt, of same size as \a this array
5008 * (same number of tuples and components), the caller is to delete
5009 * using decrRef() as it is no more needed.
5010 * This array contains indices of ranges for every value of \a this array. I.e.
5011 * the i-th value of \a castArr gives the index of range the i-th value of \a this
5012 * belongs to. Or, in other words, this parameter contains for each tuple in \a
5013 * this in which cast it holds.
5014 * \param [out] rankInsideCast - a new instance of DataArrayInt, of same size as \a this
5015 * array, the caller is to delete using decrRef() as it is no more needed.
5016 * This array contains ranks of values of \a this array within ranges
5017 * they belongs to. I.e. the i-th value of \a rankInsideCast gives the rank of
5018 * the i-th value of \a this array within the \a castArr[ i ]-th range, to which
5019 * the i-th value of \a this belongs to. Or, in other words, this param contains
5020 * for each tuple its rank inside its cast. The rank is computed as difference
5021 * between the value and the lowest value of range.
5022 * \param [out] castsPresent - a new instance of DataArrayInt, containing indices of
5023 * ranges (casts) to which at least one value of \a this array belongs.
5024 * Or, in other words, this param contains the casts that \a this contains.
5025 * The caller is to delete this array using decrRef() as it is no more needed.
5027 * \b Example: If \a this contains [6,5,0,3,2,7,8,1,4] and \a arrBg contains [0,4,9] then
5028 * the output of this method will be :
5029 * - \a castArr : [1,1,0,0,0,1,1,0,1]
5030 * - \a rankInsideCast: [2,1,0,3,2,3,4,1,0]
5031 * - \a castsPresent : [0,1]
5033 * I.e. values of \a this array belong to 2 ranges: #0 and #1. Value 6 belongs to the
5034 * range #1 and its rank within this range is 2; etc.
5036 * \throw If \a this->getNumberOfComponents() != 1.
5037 * \throw If \a arrEnd - arrBg < 2.
5038 * \throw If any value of \a this is not less than \a arrEnd[-1].
5040 void DataArrayInt::splitByValueRange(const int *arrBg, const int *arrEnd,
5041 DataArrayInt *& castArr, DataArrayInt *& rankInsideCast, DataArrayInt *& castsPresent) const
5044 if(getNumberOfComponents()!=1)
5045 throw INTERP_KERNEL::Exception("Call splitByValueRange method on DataArrayInt with only one component, you can call 'rearrange' method before !");
5046 int nbOfTuples=getNumberOfTuples();
5047 std::size_t nbOfCast=std::distance(arrBg,arrEnd);
5049 throw INTERP_KERNEL::Exception("DataArrayInt::splitByValueRange : The input array giving the cast range values should be of size >=2 !");
5051 const int *work=getConstPointer();
5052 typedef std::reverse_iterator<const int *> rintstart;
5053 rintstart bg(arrEnd);//OK no problem because size of 'arr' is greater or equal 2
5054 rintstart end2(arrBg);
5055 MCAuto<DataArrayInt> ret1=DataArrayInt::New();
5056 MCAuto<DataArrayInt> ret2=DataArrayInt::New();
5057 MCAuto<DataArrayInt> ret3=DataArrayInt::New();
5058 ret1->alloc(nbOfTuples,1);
5059 ret2->alloc(nbOfTuples,1);
5060 int *ret1Ptr=ret1->getPointer();
5061 int *ret2Ptr=ret2->getPointer();
5062 std::set<std::size_t> castsDetected;
5063 for(int i=0;i<nbOfTuples;i++)
5065 rintstart res=std::find_if(bg,end2,std::bind2nd(std::less_equal<int>(), work[i]));
5066 std::size_t pos=std::distance(bg,res);
5067 std::size_t pos2=nbOfCast-pos;
5070 ret1Ptr[i]=(int)pos2;
5071 ret2Ptr[i]=work[i]-arrBg[pos2];
5072 castsDetected.insert(pos2);
5076 std::ostringstream oss; oss << "DataArrayInt::splitByValueRange : At rank #" << i << " the value is " << work[i] << " should be in [0," << *bg << ") !";
5077 throw INTERP_KERNEL::Exception(oss.str().c_str());
5080 ret3->alloc((int)castsDetected.size(),1);
5081 std::copy(castsDetected.begin(),castsDetected.end(),ret3->getPointer());
5082 castArr=ret1.retn();
5083 rankInsideCast=ret2.retn();
5084 castsPresent=ret3.retn();
5088 * This method look at \a this if it can be considered as a range defined by the 3-tuple ( \a strt , \a sttoopp , \a stteepp ).
5089 * If false is returned the tuple must be ignored. If true is returned \a this can be considered by a range( \a strt , \a sttoopp , \a stteepp ).
5090 * This method works only if \a this is allocated and single component. If not an exception will be thrown.
5092 * \param [out] strt - the start of the range (included) if true is returned.
5093 * \param [out] sttoopp - the end of the range (not included) if true is returned.
5094 * \param [out] stteepp - the step of the range if true is returned.
5095 * \return the verdict of the check.
5097 * \sa DataArray::GetNumberOfItemGivenBES
5099 bool DataArrayInt::isRange(int& strt, int& sttoopp, int& stteepp) const
5102 if(getNumberOfComponents()!=1)
5103 throw INTERP_KERNEL::Exception("DataArrayInt::isRange : this must be single component array !");
5104 int nbTuples(getNumberOfTuples());
5106 { strt=0; sttoopp=0; stteepp=1; return true; }
5107 const int *pt(begin());
5110 { sttoopp=strt+1; stteepp=1; return true; }
5111 strt=*pt; sttoopp=pt[nbTuples-1];
5117 int a(sttoopp-1-strt),tmp(strt);
5118 if(a%(nbTuples-1)!=0)
5120 stteepp=a/(nbTuples-1);
5121 for(int i=0;i<nbTuples;i++,tmp+=stteepp)
5129 int a(strt-sttoopp-1),tmp(strt);
5130 if(a%(nbTuples-1)!=0)
5132 stteepp=-(a/(nbTuples-1));
5133 for(int i=0;i<nbTuples;i++,tmp+=stteepp)
5141 * Creates a one-dimensional DataArrayInt (\a res) whose contents are computed from
5142 * values of \a this (\a a) and the given (\a indArr) arrays as follows:
5143 * \a res[ \a indArr[ \a a[ i ]]] = i. I.e. for each value in place i \a v = \a a[ i ],
5144 * new value in place \a indArr[ \a v ] is i.
5145 * \param [in] indArrBg - the array holding indices within the result array to assign
5146 * indices of values of \a this array pointing to values of \a indArrBg.
5147 * \param [in] indArrEnd - specifies the end of the array \a indArrBg, so that
5148 * the last value of \a indArrBg is \a indArrEnd[ -1 ].
5149 * \return DataArrayInt * - the new instance of DataArrayInt.
5150 * The caller is to delete this result array using decrRef() as it is no more
5152 * \throw If \a this->getNumberOfComponents() != 1.
5153 * \throw If any value of \a this array is not a valid index for \a indArrBg array.
5154 * \throw If any value of \a indArrBg is not a valid index for \a this array.
5156 DataArrayInt *DataArrayInt::transformWithIndArrR(const int *indArrBg, const int *indArrEnd) const
5159 if(getNumberOfComponents()!=1)
5160 throw INTERP_KERNEL::Exception("Call transformWithIndArrR method on DataArrayInt with only one component, you can call 'rearrange' method before !");
5161 int nbElemsIn=(int)std::distance(indArrBg,indArrEnd);
5162 int nbOfTuples=getNumberOfTuples();
5163 const int *pt=getConstPointer();
5164 MCAuto<DataArrayInt> ret=DataArrayInt::New();
5165 ret->alloc(nbOfTuples,1);
5166 ret->fillWithValue(-1);
5167 int *tmp=ret->getPointer();
5168 for(int i=0;i<nbOfTuples;i++,pt++)
5170 if(*pt>=0 && *pt<nbElemsIn)
5172 int pos=indArrBg[*pt];
5173 if(pos>=0 && pos<nbOfTuples)
5177 std::ostringstream oss; oss << "DataArrayInt::transformWithIndArrR : error on tuple #" << i << " value of new pos is " << pos << " ( indArrBg[" << *pt << "]) ! Should be in [0," << nbOfTuples << ") !";
5178 throw INTERP_KERNEL::Exception(oss.str().c_str());
5183 std::ostringstream oss; oss << "DataArrayInt::transformWithIndArrR : error on tuple #" << i << " value is " << *pt << " and indirectionnal array as a size equal to " << nbElemsIn << " !";
5184 throw INTERP_KERNEL::Exception(oss.str().c_str());
5191 * Creates a one-dimensional DataArrayInt of given length, whose contents are computed
5192 * from values of \a this array, which is supposed to contain a renumbering map in
5193 * "Old to New" mode. The result array contains a renumbering map in "New to Old" mode.
5194 * To know how to use the renumbering maps see \ref numbering.
5195 * \param [in] newNbOfElem - the number of tuples in the result array.
5196 * \return DataArrayInt * - the new instance of DataArrayInt.
5197 * The caller is to delete this result array using decrRef() as it is no more
5200 * \if ENABLE_EXAMPLES
5201 * \ref cpp_mcdataarrayint_invertarrayo2n2n2o "Here is a C++ example".<br>
5202 * \ref py_mcdataarrayint_invertarrayo2n2n2o "Here is a Python example".
5205 DataArrayInt *DataArrayInt::invertArrayO2N2N2O(int newNbOfElem) const
5207 MCAuto<DataArrayInt> ret=DataArrayInt::New();
5208 ret->alloc(newNbOfElem,1);
5209 int nbOfOldNodes=getNumberOfTuples();
5210 const int *old2New=getConstPointer();
5211 int *pt=ret->getPointer();
5212 for(int i=0;i!=nbOfOldNodes;i++)
5214 int newp(old2New[i]);
5217 if(newp>=0 && newp<newNbOfElem)
5221 std::ostringstream oss; oss << "DataArrayInt::invertArrayO2N2N2O : At place #" << i << " the newplace is " << newp << " must be in [0," << newNbOfElem << ") !";
5222 throw INTERP_KERNEL::Exception(oss.str().c_str());
5230 * This method is similar to DataArrayInt::invertArrayO2N2N2O except that
5231 * 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]
5233 DataArrayInt *DataArrayInt::invertArrayO2N2N2OBis(int newNbOfElem) const
5235 MCAuto<DataArrayInt> ret=DataArrayInt::New();
5236 ret->alloc(newNbOfElem,1);
5237 int nbOfOldNodes=getNumberOfTuples();
5238 const int *old2New=getConstPointer();
5239 int *pt=ret->getPointer();
5240 for(int i=nbOfOldNodes-1;i>=0;i--)
5242 int newp(old2New[i]);
5245 if(newp>=0 && newp<newNbOfElem)
5249 std::ostringstream oss; oss << "DataArrayInt::invertArrayO2N2N2OBis : At place #" << i << " the newplace is " << newp << " must be in [0," << newNbOfElem << ") !";
5250 throw INTERP_KERNEL::Exception(oss.str().c_str());
5258 * Creates a one-dimensional DataArrayInt of given length, whose contents are computed
5259 * from values of \a this array, which is supposed to contain a renumbering map in
5260 * "New to Old" mode. The result array contains a renumbering map in "Old to New" mode.
5261 * To know how to use the renumbering maps see \ref numbering.
5262 * \param [in] newNbOfElem - the number of tuples in the result array.
5263 * \return DataArrayInt * - the new instance of DataArrayInt.
5264 * The caller is to delete this result array using decrRef() as it is no more
5267 * \if ENABLE_EXAMPLES
5268 * \ref cpp_mcdataarrayint_invertarrayn2o2o2n "Here is a C++ example".
5270 * \ref py_mcdataarrayint_invertarrayn2o2o2n "Here is a Python example".
5273 DataArrayInt *DataArrayInt::invertArrayN2O2O2N(int oldNbOfElem) const
5276 MCAuto<DataArrayInt> ret=DataArrayInt::New();
5277 ret->alloc(oldNbOfElem,1);
5278 const int *new2Old=getConstPointer();
5279 int *pt=ret->getPointer();
5280 std::fill(pt,pt+oldNbOfElem,-1);
5281 int nbOfNewElems=getNumberOfTuples();
5282 for(int i=0;i<nbOfNewElems;i++)
5285 if(v>=0 && v<oldNbOfElem)
5289 std::ostringstream oss; oss << "DataArrayInt::invertArrayN2O2O2N : in new id #" << i << " old value is " << v << " expected to be in [0," << oldNbOfElem << ") !";
5290 throw INTERP_KERNEL::Exception(oss.str().c_str());
5297 * Equivalent to DataArrayInt::isEqual except that if false the reason of
5298 * mismatch is given.
5300 * \param [in] other the instance to be compared with \a this
5301 * \param [out] reason In case of inequality returns the reason.
5302 * \sa DataArrayInt::isEqual
5304 bool DataArrayInt::isEqualIfNotWhy(const DataArrayInt& other, std::string& reason) const
5306 if(!areInfoEqualsIfNotWhy(other,reason))
5308 return _mem.isEqual(other._mem,0,reason);
5312 * Checks if \a this and another DataArrayInt are fully equal. For more info see
5313 * \ref MEDCouplingArrayBasicsCompare.
5314 * \param [in] other - an instance of DataArrayInt to compare with \a this one.
5315 * \return bool - \a true if the two arrays are equal, \a false else.
5317 bool DataArrayInt::isEqual(const DataArrayInt& other) const
5320 return isEqualIfNotWhy(other,tmp);
5324 * Checks if values of \a this and another DataArrayInt are equal. For more info see
5325 * \ref MEDCouplingArrayBasicsCompare.
5326 * \param [in] other - an instance of DataArrayInt to compare with \a this one.
5327 * \return bool - \a true if the values of two arrays are equal, \a false else.
5329 bool DataArrayInt::isEqualWithoutConsideringStr(const DataArrayInt& other) const
5332 return _mem.isEqual(other._mem,0,tmp);
5336 * Checks if values of \a this and another DataArrayInt are equal. Comparison is
5337 * performed on sorted value sequences.
5338 * For more info see\ref MEDCouplingArrayBasicsCompare.
5339 * \param [in] other - an instance of DataArrayInt to compare with \a this one.
5340 * \return bool - \a true if the sorted values of two arrays are equal, \a false else.
5342 bool DataArrayInt::isEqualWithoutConsideringStrAndOrder(const DataArrayInt& other) const
5344 MCAuto<DataArrayInt> a=deepCopy();
5345 MCAuto<DataArrayInt> b=other.deepCopy();
5348 return a->isEqualWithoutConsideringStr(*b);
5352 * This method compares content of input vector \a v and \a this.
5353 * 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.
5354 * For performance reasons \a this is expected to be sorted ascendingly. If not an exception will be thrown.
5356 * \param [in] v - the vector of 'flags' to be compared with \a this.
5358 * \throw If \a this is not sorted ascendingly.
5359 * \throw If \a this has not exactly one component.
5360 * \throw If \a this is not allocated.
5362 bool DataArrayInt::isFittingWith(const std::vector<bool>& v) const
5365 if(getNumberOfComponents()!=1)
5366 throw INTERP_KERNEL::Exception("DataArrayInt::isFittingWith : number of components of this should be equal to one !");
5367 const int *w(begin()),*end2(end());
5368 int refVal=-std::numeric_limits<int>::max();
5370 std::vector<bool>::const_iterator it(v.begin());
5371 for(;it!=v.end();it++,i++)
5383 std::ostringstream oss; oss << "DataArrayInt::isFittingWith : At pos #" << std::distance(begin(),w-1) << " this is not sorted ascendingly !";
5384 throw INTERP_KERNEL::Exception(oss.str().c_str());
5398 * This method assumes that \a this has one component and is allocated. This method scans all tuples in \a this and for all tuple equal to \a val
5399 * put True to the corresponding entry in \a vec.
5400 * \a vec is expected to be with the same size than the number of tuples of \a this.
5402 * \sa DataArrayInt::switchOnTupleNotEqualTo.
5404 void DataArrayInt::switchOnTupleEqualTo(int val, std::vector<bool>& vec) const
5407 if(getNumberOfComponents()!=1)
5408 throw INTERP_KERNEL::Exception("DataArrayInt::switchOnTupleEqualTo : number of components of this should be equal to one !");
5409 int nbOfTuples(getNumberOfTuples());
5410 if(nbOfTuples!=(int)vec.size())
5411 throw INTERP_KERNEL::Exception("DataArrayInt::switchOnTupleEqualTo : number of tuples of this should be equal to size of input vector of bool !");
5412 const int *pt(begin());
5413 for(int i=0;i<nbOfTuples;i++)
5419 * This method assumes that \a this has one component and is allocated. This method scans all tuples in \a this and for all tuple different from \a val
5420 * put True to the corresponding entry in \a vec.
5421 * \a vec is expected to be with the same size than the number of tuples of \a this.
5423 * \sa DataArrayInt::switchOnTupleEqualTo.
5425 void DataArrayInt::switchOnTupleNotEqualTo(int val, std::vector<bool>& vec) const
5428 if(getNumberOfComponents()!=1)
5429 throw INTERP_KERNEL::Exception("DataArrayInt::switchOnTupleNotEqualTo : number of components of this should be equal to one !");
5430 int nbOfTuples(getNumberOfTuples());
5431 if(nbOfTuples!=(int)vec.size())
5432 throw INTERP_KERNEL::Exception("DataArrayInt::switchOnTupleNotEqualTo : number of tuples of this should be equal to size of input vector of bool !");
5433 const int *pt(begin());
5434 for(int i=0;i<nbOfTuples;i++)
5440 * Computes for each tuple the sum of number of components values in the tuple and return it.
5442 * \return DataArrayInt * - the new instance of DataArrayInt containing the
5443 * same number of tuples as \a this array and one component.
5444 * The caller is to delete this result array using decrRef() as it is no more
5446 * \throw If \a this is not allocated.
5448 DataArrayInt *DataArrayInt::sumPerTuple() const
5451 int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
5452 MCAuto<DataArrayInt> ret(DataArrayInt::New());
5453 ret->alloc(nbOfTuple,1);
5454 const int *src(getConstPointer());
5455 int *dest(ret->getPointer());
5456 for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
5457 *dest=std::accumulate(src,src+nbOfComp,0);
5462 * Checks that \a this array is consistently **increasing** or **decreasing** in value.
5463 * If not an exception is thrown.
5464 * \param [in] increasing - if \a true, the array values should be increasing.
5465 * \throw If sequence of values is not strictly monotonic in agreement with \a
5467 * \throw If \a this->getNumberOfComponents() != 1.
5468 * \throw If \a this is not allocated.
5470 void DataArrayInt::checkMonotonic(bool increasing) const
5472 if(!isMonotonic(increasing))
5475 throw INTERP_KERNEL::Exception("DataArrayInt::checkMonotonic : 'this' is not INCREASING monotonic !");
5477 throw INTERP_KERNEL::Exception("DataArrayInt::checkMonotonic : 'this' is not DECREASING monotonic !");
5482 * Checks that \a this array is consistently **increasing** or **decreasing** in value.
5483 * \param [in] increasing - if \a true, array values should be increasing.
5484 * \return bool - \a true if values change in accordance with \a increasing arg.
5485 * \throw If \a this->getNumberOfComponents() != 1.
5486 * \throw If \a this is not allocated.
5488 bool DataArrayInt::isMonotonic(bool increasing) const
5491 if(getNumberOfComponents()!=1)
5492 throw INTERP_KERNEL::Exception("DataArrayInt::isMonotonic : only supported with 'this' array with ONE component !");
5493 int nbOfElements=getNumberOfTuples();
5494 const int *ptr=getConstPointer();
5500 for(int i=1;i<nbOfElements;i++)
5510 for(int i=1;i<nbOfElements;i++)
5522 * This method check that array consistently INCREASING or DECREASING in value.
5524 bool DataArrayInt::isStrictlyMonotonic(bool increasing) const
5527 if(getNumberOfComponents()!=1)
5528 throw INTERP_KERNEL::Exception("DataArrayInt::isStrictlyMonotonic : only supported with 'this' array with ONE component !");
5529 int nbOfElements=getNumberOfTuples();
5530 const int *ptr=getConstPointer();
5536 for(int i=1;i<nbOfElements;i++)
5546 for(int i=1;i<nbOfElements;i++)
5558 * This method check that array consistently INCREASING or DECREASING in value.
5560 void DataArrayInt::checkStrictlyMonotonic(bool increasing) const
5562 if(!isStrictlyMonotonic(increasing))
5565 throw INTERP_KERNEL::Exception("DataArrayInt::checkStrictlyMonotonic : 'this' is not strictly INCREASING monotonic !");
5567 throw INTERP_KERNEL::Exception("DataArrayInt::checkStrictlyMonotonic : 'this' is not strictly DECREASING monotonic !");
5572 * Creates a new one-dimensional DataArrayInt of the same size as \a this and a given
5573 * one-dimensional arrays that must be of the same length. The result array describes
5574 * correspondence between \a this and \a other arrays, so that
5575 * <em> other.getIJ(i,0) == this->getIJ(ret->getIJ(i),0)</em>. If such a permutation is
5576 * not possible because some element in \a other is not in \a this, an exception is thrown.
5577 * \param [in] other - an array to compute permutation to.
5578 * \return DataArrayInt * - a new instance of DataArrayInt, which is a permutation array
5579 * from \a this to \a other. The caller is to delete this array using decrRef() as it is
5581 * \throw If \a this->getNumberOfComponents() != 1.
5582 * \throw If \a other->getNumberOfComponents() != 1.
5583 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples().
5584 * \throw If \a other includes a value which is not in \a this array.
5586 * \if ENABLE_EXAMPLES
5587 * \ref cpp_mcdataarrayint_buildpermutationarr "Here is a C++ example".
5589 * \ref py_mcdataarrayint_buildpermutationarr "Here is a Python example".
5592 DataArrayInt *DataArrayInt::buildPermutationArr(const DataArrayInt& other) const
5595 if(getNumberOfComponents()!=1 || other.getNumberOfComponents()!=1)
5596 throw INTERP_KERNEL::Exception("DataArrayInt::buildPermutationArr : 'this' and 'other' have to have exactly ONE component !");
5597 int nbTuple=getNumberOfTuples();
5598 other.checkAllocated();
5599 if(nbTuple!=other.getNumberOfTuples())
5600 throw INTERP_KERNEL::Exception("DataArrayInt::buildPermutationArr : 'this' and 'other' must have the same number of tuple !");
5601 MCAuto<DataArrayInt> ret=DataArrayInt::New();
5602 ret->alloc(nbTuple,1);
5603 ret->fillWithValue(-1);
5604 const int *pt=getConstPointer();
5605 std::map<int,int> mm;
5606 for(int i=0;i<nbTuple;i++)
5608 pt=other.getConstPointer();
5609 int *retToFill=ret->getPointer();
5610 for(int i=0;i<nbTuple;i++)
5612 std::map<int,int>::const_iterator it=mm.find(pt[i]);
5615 std::ostringstream oss; oss << "DataArrayInt::buildPermutationArr : Arrays mismatch : element (" << pt[i] << ") in 'other' not findable in 'this' !";
5616 throw INTERP_KERNEL::Exception(oss.str().c_str());
5618 retToFill[i]=(*it).second;
5624 * Elements of \a partOfThis are expected to be included in \a this.
5625 * The returned array \a ret is so that this[ret]==partOfThis
5627 * For example, if \a this array contents are [9,10,0,6,4,11,3,8] and if \a partOfThis contains [6,0,11,8]
5628 * the return array will contain [3,2,5,7].
5630 * \a this is expected to be a 1 compo allocated array.
5631 * \param [in] partOfThis - A 1 compo allocated array
5632 * \return - A newly allocated array to be dealed by caller having the same number of tuples than \a partOfThis.
5633 * \throw if two same element is present twice in \a this
5634 * \throw if an element in \a partOfThis is \b NOT in \a this.
5636 DataArrayInt *DataArrayInt::indicesOfSubPart(const DataArrayInt& partOfThis) const
5638 if(getNumberOfComponents()!=1 || partOfThis.getNumberOfComponents()!=1)
5639 throw INTERP_KERNEL::Exception("DataArrayInt::indicesOfSubPart : this and input array must be one component array !");
5640 checkAllocated(); partOfThis.checkAllocated();
5641 int thisNbTuples(getNumberOfTuples()),nbTuples(partOfThis.getNumberOfTuples());
5642 const int *thisPt(begin()),*pt(partOfThis.begin());
5643 MCAuto<DataArrayInt> ret(DataArrayInt::New());
5644 ret->alloc(nbTuples,1);
5645 int *retPt(ret->getPointer());
5646 std::map<int,int> m;
5647 for(int i=0;i<thisNbTuples;i++,thisPt++)
5649 if(m.size()!=thisNbTuples)
5650 throw INTERP_KERNEL::Exception("DataArrayInt::indicesOfSubPart : some elements appears more than once !");
5651 for(int i=0;i<nbTuples;i++,retPt++,pt++)
5653 std::map<int,int>::const_iterator it(m.find(*pt));
5655 *retPt=(*it).second;
5658 std::ostringstream oss; oss << "DataArrayInt::indicesOfSubPart : At pos #" << i << " of input array value is " << *pt << " not in this !";
5659 throw INTERP_KERNEL::Exception(oss.str());
5665 void DataArrayInt::aggregate(const DataArrayInt *other)
5668 throw INTERP_KERNEL::Exception("DataArrayInt::aggregate : null pointer !");
5669 if(getNumberOfComponents()!=other->getNumberOfComponents())
5670 throw INTERP_KERNEL::Exception("DataArrayInt::aggregate : mismatch number of components !");
5671 _mem.insertAtTheEnd(other->begin(),other->end());
5675 * Returns a new DataArrayInt holding the same values as \a this array but differently
5676 * arranged in memory. If \a this array holds 2 components of 3 values:
5677 * \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$, then the result array holds these values arranged
5678 * as follows: \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$.
5679 * \warning Do not confuse this method with transpose()!
5680 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
5681 * is to delete using decrRef() as it is no more needed.
5682 * \throw If \a this is not allocated.
5684 DataArrayInt *DataArrayInt::fromNoInterlace() const
5688 throw INTERP_KERNEL::Exception("DataArrayInt::fromNoInterlace : Not defined array !");
5689 int *tab=_mem.fromNoInterlace(getNumberOfComponents());
5690 DataArrayInt *ret=DataArrayInt::New();
5691 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
5696 * Returns a new DataArrayInt holding the same values as \a this array but differently
5697 * arranged in memory. If \a this array holds 2 components of 3 values:
5698 * \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$, then the result array holds these values arranged
5699 * as follows: \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$.
5700 * \warning Do not confuse this method with transpose()!
5701 * \return DataArrayInt * - the new instance of DataArrayInt that the caller
5702 * is to delete using decrRef() as it is no more needed.
5703 * \throw If \a this is not allocated.
5705 DataArrayInt *DataArrayInt::toNoInterlace() const
5709 throw INTERP_KERNEL::Exception("DataArrayInt::toNoInterlace : Not defined array !");
5710 int *tab=_mem.toNoInterlace(getNumberOfComponents());
5711 DataArrayInt *ret=DataArrayInt::New();
5712 ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
5717 * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode.
5718 * This map, if applied to \a this array, would make it sorted. For example, if
5719 * \a this array contents are [9,10,0,6,4,11,3,7] then the contents of the result array
5720 * are [5,6,0,3,2,7,1,4]; if this result array (\a res) is used as an argument in call
5721 * \a this->renumber(\a res) then the returned array contains [0,3,4,6,7,9,10,11].
5722 * This method is useful for renumbering (in MED file for example). For more info
5723 * on renumbering see \ref numbering.
5724 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
5725 * array using decrRef() as it is no more needed.
5726 * \throw If \a this is not allocated.
5727 * \throw If \a this->getNumberOfComponents() != 1.
5728 * \throw If there are equal values in \a this array.
5730 DataArrayInt *DataArrayInt::checkAndPreparePermutation() const
5733 if(getNumberOfComponents()!=1)
5734 throw INTERP_KERNEL::Exception("DataArrayInt::checkAndPreparePermutation : number of components must == 1 !");
5735 int nbTuples=getNumberOfTuples();
5736 const int *pt=getConstPointer();
5737 int *pt2=CheckAndPreparePermutation(pt,pt+nbTuples);
5738 DataArrayInt *ret=DataArrayInt::New();
5739 ret->useArray(pt2,true,C_DEALLOC,nbTuples,1);
5744 * 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
5745 * input array \a ids2.
5746 * \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.
5747 * 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
5749 * In case of success (no throw) : \c ids1->renumber(ret)->isEqual(ids2) where \a ret is the return of this method.
5751 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
5752 * array using decrRef() as it is no more needed.
5753 * \throw If either ids1 or ids2 is null not allocated or not with one components.
5756 DataArrayInt *DataArrayInt::FindPermutationFromFirstToSecond(const DataArrayInt *ids1, const DataArrayInt *ids2)
5759 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays must be not null !");
5760 if(!ids1->isAllocated() || !ids2->isAllocated())
5761 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays must be allocated !");
5762 if(ids1->getNumberOfComponents()!=1 || ids2->getNumberOfComponents()!=1)
5763 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays have exactly one component !");
5764 if(ids1->getNumberOfTuples()!=ids2->getNumberOfTuples())
5766 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 !";
5767 throw INTERP_KERNEL::Exception(oss.str().c_str());
5769 MCAuto<DataArrayInt> p1(ids1->deepCopy());
5770 MCAuto<DataArrayInt> p2(ids2->deepCopy());
5771 p1->sort(true); p2->sort(true);
5772 if(!p1->isEqualWithoutConsideringStr(*p2))
5773 throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two arrays are not lying on same ids ! Impossible to find a permutation between the 2 arrays !");
5774 p1=ids1->checkAndPreparePermutation();
5775 p2=ids2->checkAndPreparePermutation();
5776 p2=p2->invertArrayO2N2N2O(p2->getNumberOfTuples());
5777 p2=p2->selectByTupleIdSafe(p1->begin(),p1->end());
5782 * Returns two arrays describing a surjective mapping from \a this set of values (\a A)
5783 * onto a set of values of size \a targetNb (\a B). The surjective function is
5784 * \a B[ \a A[ i ]] = i. That is to say that for each \a id in [0,\a targetNb), where \a
5785 * targetNb < \a this->getNumberOfTuples(), there exists at least one tupleId (\a tid) so
5786 * that <em> this->getIJ( tid, 0 ) == id</em>. <br>
5787 * The first of out arrays returns indices of elements of \a this array, grouped by their
5788 * place in the set \a B. The second out array is the index of the first one; it shows how
5789 * many elements of \a A are mapped into each element of \a B. <br>
5791 * mapping and its usage in renumbering see \ref numbering. <br>
5793 * - \a this: [0,3,2,3,2,2,1,2]
5795 * - \a arr: [0, 6, 2,4,5,7, 1,3]
5796 * - \a arrI: [0,1,2,6,8]
5798 * This result means: <br>
5799 * the element of \a B 0 encounters within \a A once (\a arrI[ 0+1 ] - \a arrI[ 0 ]) and
5800 * its index within \a A is 0 ( \a arr[ 0:1 ] == \a arr[ \a arrI[ 0 ] : \a arrI[ 0+1 ]]);<br>
5801 * the element of \a B 2 encounters within \a A 4 times (\a arrI[ 2+1 ] - \a arrI[ 2 ]) and
5802 * its indices within \a A are [2,4,5,7] ( \a arr[ 2:6 ] == \a arr[ \a arrI[ 2 ] :
5803 * \a arrI[ 2+1 ]]); <br> etc.
5804 * \param [in] targetNb - the size of the set \a B. \a targetNb must be equal or more
5805 * than the maximal value of \a A.
5806 * \param [out] arr - a new instance of DataArrayInt returning indices of
5807 * elements of \a this, grouped by their place in the set \a B. The caller is to delete
5808 * this array using decrRef() as it is no more needed.
5809 * \param [out] arrI - a new instance of DataArrayInt returning size of groups of equal
5810 * elements of \a this. The caller is to delete this array using decrRef() as it
5811 * is no more needed.
5812 * \throw If \a this is not allocated.
5813 * \throw If \a this->getNumberOfComponents() != 1.
5814 * \throw If any value in \a this is more or equal to \a targetNb.
5816 void DataArrayInt::changeSurjectiveFormat(int targetNb, DataArrayInt *&arr, DataArrayInt *&arrI) const
5819 if(getNumberOfComponents()!=1)
5820 throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : number of components must == 1 !");
5821 int nbOfTuples=getNumberOfTuples();
5822 MCAuto<DataArrayInt> ret(DataArrayInt::New());
5823 MCAuto<DataArrayInt> retI(DataArrayInt::New());
5824 retI->alloc(targetNb+1,1);
5825 const int *input=getConstPointer();
5826 std::vector< std::vector<int> > tmp(targetNb);
5827 for(int i=0;i<nbOfTuples;i++)
5830 if(tmp2>=0 && tmp2<targetNb)
5831 tmp[tmp2].push_back(i);
5834 std::ostringstream oss; oss << "DataArrayInt::changeSurjectiveFormat : At pos " << i << " presence of element " << tmp2 << " ! should be in [0," << targetNb << ") !";
5835 throw INTERP_KERNEL::Exception(oss.str().c_str());
5838 int *retIPtr=retI->getPointer();
5840 for(std::vector< std::vector<int> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++,retIPtr++)
5841 retIPtr[1]=retIPtr[0]+(int)((*it1).size());
5842 if(nbOfTuples!=retI->getIJ(targetNb,0))
5843 throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : big problem should never happen !");
5844 ret->alloc(nbOfTuples,1);
5845 int *retPtr=ret->getPointer();
5846 for(std::vector< std::vector<int> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++)
5847 retPtr=std::copy((*it1).begin(),(*it1).end(),retPtr);
5854 * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode computed
5855 * from a zip representation of a surjective format (returned e.g. by
5856 * \ref MEDCoupling::DataArrayDouble::findCommonTuples() "DataArrayDouble::findCommonTuples()"
5857 * for example). The result array minimizes the permutation. <br>
5858 * For more info on renumbering see \ref numbering. <br>
5860 * - \a nbOfOldTuples: 10
5861 * - \a arr : [0,3, 5,7,9]
5862 * - \a arrIBg : [0,2,5]
5863 * - \a newNbOfTuples: 7
5864 * - result array : [0,1,2,0,3,4,5,4,6,4]
5866 * \param [in] nbOfOldTuples - number of tuples in the initial array \a arr.
5867 * \param [in] arr - the array of tuple indices grouped by \a arrIBg array.
5868 * \param [in] arrIBg - the array dividing all indices stored in \a arr into groups of
5869 * (indices of) equal values. Its every element (except the last one) points to
5870 * the first element of a group of equal values.
5871 * \param [in] arrIEnd - specifies the end of \a arrIBg, so that the last element of \a
5872 * arrIBg is \a arrIEnd[ -1 ].
5873 * \param [out] newNbOfTuples - number of tuples after surjection application.
5874 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
5875 * array using decrRef() as it is no more needed.
5876 * \throw If any value of \a arr breaks condition ( 0 <= \a arr[ i ] < \a nbOfOldTuples ).
5878 DataArrayInt *DataArrayInt::ConvertIndexArrayToO2N(int nbOfOldTuples, const int *arr, const int *arrIBg, const int *arrIEnd, int &newNbOfTuples)
5880 MCAuto<DataArrayInt> ret=DataArrayInt::New();
5881 ret->alloc(nbOfOldTuples,1);
5882 int *pt=ret->getPointer();
5883 std::fill(pt,pt+nbOfOldTuples,-1);
5884 int nbOfGrps=((int)std::distance(arrIBg,arrIEnd))-1;
5885 const int *cIPtr=arrIBg;
5886 for(int i=0;i<nbOfGrps;i++)
5887 pt[arr[cIPtr[i]]]=-(i+2);
5889 for(int iNode=0;iNode<nbOfOldTuples;iNode++)
5897 int grpId=-(pt[iNode]+2);
5898 for(int j=cIPtr[grpId];j<cIPtr[grpId+1];j++)
5900 if(arr[j]>=0 && arr[j]<nbOfOldTuples)
5904 std::ostringstream oss; oss << "DataArrayInt::ConvertIndexArrayToO2N : With element #" << j << " value is " << arr[j] << " should be in [0," << nbOfOldTuples << ") !";
5905 throw INTERP_KERNEL::Exception(oss.str().c_str());
5912 newNbOfTuples=newNb;
5917 * Returns a new DataArrayInt containing a renumbering map in "New to Old" mode,
5918 * which if applied to \a this array would make it sorted ascendingly.
5919 * For more info on renumbering see \ref numbering. <br>
5921 * - \a this: [2,0,1,1,0,1,2,0,1,1,0,0]
5922 * - result: [10,0,5,6,1,7,11,2,8,9,3,4]
5923 * - after applying result to \a this: [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2]
5925 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
5926 * array using decrRef() as it is no more needed.
5927 * \throw If \a this is not allocated.
5928 * \throw If \a this->getNumberOfComponents() != 1.
5930 DataArrayInt *DataArrayInt::buildPermArrPerLevel() const
5933 if(getNumberOfComponents()!=1)
5934 throw INTERP_KERNEL::Exception("DataArrayInt::buildPermArrPerLevel : number of components must == 1 !");
5935 int nbOfTuples=getNumberOfTuples();
5936 const int *pt=getConstPointer();
5937 std::map<int,int> m;
5938 MCAuto<DataArrayInt> ret=DataArrayInt::New();
5939 ret->alloc(nbOfTuples,1);
5940 int *opt=ret->getPointer();
5941 for(int i=0;i<nbOfTuples;i++,pt++,opt++)
5944 std::map<int,int>::iterator it=m.find(val);
5953 m.insert(std::pair<int,int>(val,1));
5957 for(std::map<int,int>::iterator it=m.begin();it!=m.end();it++)
5959 int vt=(*it).second;
5963 pt=getConstPointer();
5964 opt=ret->getPointer();
5965 for(int i=0;i<nbOfTuples;i++,pt++,opt++)
5972 * Checks if \a this array has the given size, and if its contents is equal to an array filled with
5973 * iota(). This method is particularly useful for DataArrayInt instances that represent
5974 * a renumbering array, to check if there is a real need in renumbering.
5975 * This method checks than \a this can be considered as an identity mapping
5976 * of a set having \a sizeExpected elements into itself.
5978 * \param [in] sizeExpected - The number of elements expected.
5979 * \return bool - \a true if \a this array contents == \a range( \a this->getNumberOfTuples())
5980 * \throw If \a this is not allocated.
5981 * \throw If \a this->getNumberOfComponents() != 1.
5983 bool DataArrayInt::isIota(int sizeExpected) const
5986 if(getNumberOfComponents()!=1)
5988 int nbOfTuples(getNumberOfTuples());
5989 if(nbOfTuples!=sizeExpected)
5991 const int *pt=getConstPointer();
5992 for(int i=0;i<nbOfTuples;i++,pt++)
5999 * Checks if all values in \a this array are equal to \a val.
6000 * \param [in] val - value to check equality of array values to.
6001 * \return bool - \a true if all values are \a val.
6002 * \throw If \a this is not allocated.
6003 * \throw If \a this->getNumberOfComponents() != 1
6005 bool DataArrayInt::isUniform(int val) const
6008 if(getNumberOfComponents()!=1)
6009 throw INTERP_KERNEL::Exception("DataArrayInt::isUniform : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
6010 int nbOfTuples=getNumberOfTuples();
6011 const int *w=getConstPointer();
6012 const int *end2=w+nbOfTuples;
6020 * Checks if all values in \a this array are unique.
6021 * \return bool - \a true if condition above is true
6022 * \throw If \a this is not allocated.
6023 * \throw If \a this->getNumberOfComponents() != 1
6025 bool DataArrayInt::hasUniqueValues() const
6028 if(getNumberOfComponents()!=1)
6029 throw INTERP_KERNEL::Exception("DataArrayInt::hasOnlyUniqueValues: must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
6030 int nbOfTuples(getNumberOfTuples());
6031 std::set<int> s(begin(),end()); // in C++11, should use unordered_set (O(1) complexity)
6032 if (s.size() != nbOfTuples)
6038 * Creates a new DataArrayDouble and assigns all (textual and numerical) data of \a this
6039 * array to the new one.
6040 * \return DataArrayDouble * - the new instance of DataArrayInt.
6042 DataArrayDouble *DataArrayInt::convertToDblArr() const
6045 DataArrayDouble *ret=DataArrayDouble::New();
6046 ret->alloc(getNumberOfTuples(),getNumberOfComponents());
6047 std::size_t nbOfVals=getNbOfElems();
6048 const int *src=getConstPointer();
6049 double *dest=ret->getPointer();
6050 std::copy(src,src+nbOfVals,dest);
6051 ret->copyStringInfoFrom(*this);
6056 * Appends components of another array to components of \a this one, tuple by tuple.
6057 * So that the number of tuples of \a this array remains the same and the number of
6058 * components increases.
6059 * \param [in] other - the DataArrayInt to append to \a this one.
6060 * \throw If \a this is not allocated.
6061 * \throw If \a this and \a other arrays have different number of tuples.
6063 * \if ENABLE_EXAMPLES
6064 * \ref cpp_mcdataarrayint_meldwith "Here is a C++ example".
6066 * \ref py_mcdataarrayint_meldwith "Here is a Python example".
6069 void DataArrayInt::meldWith(const DataArrayInt *other)
6072 throw INTERP_KERNEL::Exception("DataArrayInt::meldWith : DataArrayInt pointer in input is NULL !");
6074 other->checkAllocated();
6075 int nbOfTuples=getNumberOfTuples();
6076 if(nbOfTuples!=other->getNumberOfTuples())
6077 throw INTERP_KERNEL::Exception("DataArrayInt::meldWith : mismatch of number of tuples !");
6078 int nbOfComp1=getNumberOfComponents();
6079 int nbOfComp2=other->getNumberOfComponents();
6080 int *newArr=(int *)malloc(nbOfTuples*(nbOfComp1+nbOfComp2)*sizeof(int));
6082 const int *inp1=getConstPointer();
6083 const int *inp2=other->getConstPointer();
6084 for(int i=0;i<nbOfTuples;i++,inp1+=nbOfComp1,inp2+=nbOfComp2)
6086 w=std::copy(inp1,inp1+nbOfComp1,w);
6087 w=std::copy(inp2,inp2+nbOfComp2,w);
6089 useArray(newArr,true,C_DEALLOC,nbOfTuples,nbOfComp1+nbOfComp2);
6090 std::vector<int> compIds(nbOfComp2);
6091 for(int i=0;i<nbOfComp2;i++)
6092 compIds[i]=nbOfComp1+i;
6093 copyPartOfStringInfoFrom2(compIds,*other);
6097 * Copy all components in a specified order from another DataArrayInt.
6098 * The specified components become the first ones in \a this array.
6099 * Both numerical and textual data is copied. The number of tuples in \a this and
6100 * the other array can be different.
6101 * \param [in] a - the array to copy data from.
6102 * \param [in] compoIds - sequence of zero based indices of components, data of which is
6104 * \throw If \a a is NULL.
6105 * \throw If \a compoIds.size() != \a a->getNumberOfComponents().
6106 * \throw If \a compoIds[i] < 0 or \a compoIds[i] > \a this->getNumberOfComponents().
6108 * \if ENABLE_EXAMPLES
6109 * \ref py_mcdataarrayint_setselectedcomponents "Here is a Python example".
6112 void DataArrayInt::setSelectedComponents(const DataArrayInt *a, const std::vector<int>& compoIds)
6115 throw INTERP_KERNEL::Exception("DataArrayInt::setSelectedComponents : input DataArrayInt is NULL !");
6117 a->checkAllocated();
6118 copyPartOfStringInfoFrom2(compoIds,*a);
6119 std::size_t partOfCompoSz=compoIds.size();
6120 int nbOfCompo=getNumberOfComponents();
6121 int nbOfTuples=std::min(getNumberOfTuples(),a->getNumberOfTuples());
6122 const int *ac=a->getConstPointer();
6123 int *nc=getPointer();
6124 for(int i=0;i<nbOfTuples;i++)
6125 for(std::size_t j=0;j<partOfCompoSz;j++,ac++)
6126 nc[nbOfCompo*i+compoIds[j]]=*ac;
6130 * Assign pointer to one array to a pointer to another appay. Reference counter of
6131 * \a arrayToSet is incremented / decremented.
6132 * \param [in] newArray - the pointer to array to assign to \a arrayToSet.
6133 * \param [in,out] arrayToSet - the pointer to array to assign to.
6135 void DataArrayInt::SetArrayIn(DataArrayInt *newArray, DataArrayInt* &arrayToSet)
6137 if(newArray!=arrayToSet)
6140 arrayToSet->decrRef();
6141 arrayToSet=newArray;
6143 arrayToSet->incrRef();
6147 DataArrayIntIterator *DataArrayInt::iterator()
6149 return new DataArrayIntIterator(this);
6153 * Creates a new DataArrayInt containing IDs (indices) of tuples holding value equal to a
6154 * given one. The ids are sorted in the ascending order.
6155 * \param [in] val - the value to find within \a this.
6156 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
6157 * array using decrRef() as it is no more needed.
6158 * \throw If \a this is not allocated.
6159 * \throw If \a this->getNumberOfComponents() != 1.
6160 * \sa DataArrayInt::findIdsEqualTuple
6162 DataArrayInt *DataArrayInt::findIdsEqual(int val) const
6165 if(getNumberOfComponents()!=1)
6166 throw INTERP_KERNEL::Exception("DataArrayInt::findIdsEqual : the array must have only one component, you can call 'rearrange' method before !");
6167 const int *cptr(getConstPointer());
6168 MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
6169 int nbOfTuples=getNumberOfTuples();
6170 for(int i=0;i<nbOfTuples;i++,cptr++)
6172 ret->pushBackSilent(i);
6177 * Creates a new DataArrayInt containing IDs (indices) of tuples holding value \b not
6178 * equal to a given one.
6179 * \param [in] val - the value to ignore within \a this.
6180 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
6181 * array using decrRef() as it is no more needed.
6182 * \throw If \a this is not allocated.
6183 * \throw If \a this->getNumberOfComponents() != 1.
6185 DataArrayInt *DataArrayInt::findIdsNotEqual(int val) const
6188 if(getNumberOfComponents()!=1)
6189 throw INTERP_KERNEL::Exception("DataArrayInt::findIdsNotEqual : the array must have only one component, you can call 'rearrange' method before !");
6190 const int *cptr(getConstPointer());
6191 MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
6192 int nbOfTuples=getNumberOfTuples();
6193 for(int i=0;i<nbOfTuples;i++,cptr++)
6195 ret->pushBackSilent(i);
6200 * Creates a new DataArrayInt containing IDs (indices) of tuples holding tuple equal to those defined by [ \a tupleBg , \a tupleEnd )
6201 * This method is an extension of DataArrayInt::findIdsEqual method.
6203 * \param [in] tupleBg - the begin (included) of the input tuple to find within \a this.
6204 * \param [in] tupleEnd - the end (excluded) of the input tuple to find within \a this.
6205 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
6206 * array using decrRef() as it is no more needed.
6207 * \throw If \a this is not allocated.
6208 * \throw If \a this->getNumberOfComponents() != std::distance(tupleBg,tupleEnd).
6209 * \throw If \a this->getNumberOfComponents() is equal to 0.
6210 * \sa DataArrayInt::findIdsEqual
6212 DataArrayInt *DataArrayInt::findIdsEqualTuple(const int *tupleBg, const int *tupleEnd) const
6214 std::size_t nbOfCompoExp(std::distance(tupleBg,tupleEnd));
6216 if(getNumberOfComponents()!=(int)nbOfCompoExp)
6218 std::ostringstream oss; oss << "DataArrayInt::findIdsEqualTuple : mismatch of number of components. Input tuple has " << nbOfCompoExp << " whereas this array has " << getNumberOfComponents() << " components !";
6219 throw INTERP_KERNEL::Exception(oss.str().c_str());
6222 throw INTERP_KERNEL::Exception("DataArrayInt::findIdsEqualTuple : number of components should be > 0 !");
6223 MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
6224 const int *bg(begin()),*end2(end()),*work(begin());
6227 work=std::search(work,end2,tupleBg,tupleEnd);
6230 std::size_t pos(std::distance(bg,work));
6231 if(pos%nbOfCompoExp==0)
6232 ret->pushBackSilent(pos/nbOfCompoExp);
6240 * Assigns \a newValue to all elements holding \a oldValue within \a this
6241 * one-dimensional array.
6242 * \param [in] oldValue - the value to replace.
6243 * \param [in] newValue - the value to assign.
6244 * \return int - number of replacements performed.
6245 * \throw If \a this is not allocated.
6246 * \throw If \a this->getNumberOfComponents() != 1.
6248 int DataArrayInt::changeValue(int oldValue, int newValue)
6251 if(getNumberOfComponents()!=1)
6252 throw INTERP_KERNEL::Exception("DataArrayInt::changeValue : the array must have only one component, you can call 'rearrange' method before !");
6253 if(oldValue==newValue)
6255 int *start(getPointer()),*end2(start+getNbOfElems());
6257 for(int *val=start;val!=end2;val++)
6271 * Creates a new DataArrayInt containing IDs (indices) of tuples holding value equal to
6272 * one of given values.
6273 * \param [in] valsBg - an array of values to find within \a this array.
6274 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
6275 * the last value of \a valsBg is \a valsEnd[ -1 ].
6276 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
6277 * array using decrRef() as it is no more needed.
6278 * \throw If \a this->getNumberOfComponents() != 1.
6280 DataArrayInt *DataArrayInt::findIdsEqualList(const int *valsBg, const int *valsEnd) const
6282 if(getNumberOfComponents()!=1)
6283 throw INTERP_KERNEL::Exception("DataArrayInt::findIdsEqualList : the array must have only one component, you can call 'rearrange' method before !");
6284 std::set<int> vals2(valsBg,valsEnd);
6285 const int *cptr(getConstPointer());
6286 std::vector<int> res;
6287 int nbOfTuples(getNumberOfTuples());
6288 MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
6289 for(int i=0;i<nbOfTuples;i++,cptr++)
6290 if(vals2.find(*cptr)!=vals2.end())
6291 ret->pushBackSilent(i);
6296 * Creates a new DataArrayInt containing IDs (indices) of tuples holding values \b not
6297 * equal to any of given values.
6298 * \param [in] valsBg - an array of values to ignore within \a this array.
6299 * \param [in] valsEnd - specifies the end of the array \a valsBg, so that
6300 * the last value of \a valsBg is \a valsEnd[ -1 ].
6301 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
6302 * array using decrRef() as it is no more needed.
6303 * \throw If \a this->getNumberOfComponents() != 1.
6305 DataArrayInt *DataArrayInt::findIdsNotEqualList(const int *valsBg, const int *valsEnd) const
6307 if(getNumberOfComponents()!=1)
6308 throw INTERP_KERNEL::Exception("DataArrayInt::findIdsNotEqualList : the array must have only one component, you can call 'rearrange' method before !");
6309 std::set<int> vals2(valsBg,valsEnd);
6310 const int *cptr=getConstPointer();
6311 std::vector<int> res;
6312 int nbOfTuples=getNumberOfTuples();
6313 MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
6314 for(int i=0;i<nbOfTuples;i++,cptr++)
6315 if(vals2.find(*cptr)==vals2.end())
6316 ret->pushBackSilent(i);
6321 * This method is an extension of DataArrayInt::findIdFirstEqual method because this method works for DataArrayInt with
6322 * any number of components excepted 0 (an INTERP_KERNEL::Exception is thrown in this case).
6323 * This method searches in \b this is there is a tuple that matched the input parameter \b tupl.
6324 * If any the tuple id is returned. If not -1 is returned.
6326 * This method throws an INTERP_KERNEL::Exception if the number of components in \b this mismatches with the size of
6327 * the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
6329 * \return tuple id where \b tupl is. -1 if no such tuple exists in \b this.
6330 * \sa DataArrayInt::findIdSequence, DataArrayInt::presenceOfTuple.
6332 int DataArrayInt::findIdFirstEqualTuple(const std::vector<int>& tupl) const
6335 int nbOfCompo=getNumberOfComponents();
6337 throw INTERP_KERNEL::Exception("DataArrayInt::findIdFirstEqualTuple : 0 components in 'this' !");
6338 if(nbOfCompo!=(int)tupl.size())
6340 std::ostringstream oss; oss << "DataArrayInt::findIdFirstEqualTuple : 'this' contains " << nbOfCompo << " components and searching for a tuple of length " << tupl.size() << " !";
6341 throw INTERP_KERNEL::Exception(oss.str().c_str());
6343 const int *cptr=getConstPointer();
6344 std::size_t nbOfVals=getNbOfElems();
6345 for(const int *work=cptr;work!=cptr+nbOfVals;)
6347 work=std::search(work,cptr+nbOfVals,tupl.begin(),tupl.end());
6348 if(work!=cptr+nbOfVals)
6350 if(std::distance(cptr,work)%nbOfCompo!=0)
6353 return std::distance(cptr,work)/nbOfCompo;
6360 * This method searches the sequence specified in input parameter \b vals in \b this.
6361 * This works only for DataArrayInt having number of components equal to one (if not an INTERP_KERNEL::Exception will be thrown).
6362 * This method differs from DataArrayInt::findIdFirstEqualTuple in that the position is internal raw data is not considered here contrary to DataArrayInt::findIdFirstEqualTuple.
6363 * \sa DataArrayInt::findIdFirstEqualTuple
6365 int DataArrayInt::findIdSequence(const std::vector<int>& vals) const
6368 int nbOfCompo=getNumberOfComponents();
6370 throw INTERP_KERNEL::Exception("DataArrayInt::findIdSequence : works only for DataArrayInt instance with one component !");
6371 const int *cptr=getConstPointer();
6372 std::size_t nbOfVals=getNbOfElems();
6373 const int *loc=std::search(cptr,cptr+nbOfVals,vals.begin(),vals.end());
6374 if(loc!=cptr+nbOfVals)
6375 return std::distance(cptr,loc);
6380 * This method expects to be called when number of components of this is equal to one.
6381 * This method returns the tuple id, if it exists, of the first tuple equal to \b value.
6382 * If not any tuple contains \b value -1 is returned.
6383 * \sa DataArrayInt::presenceOfValue
6385 int DataArrayInt::findIdFirstEqual(int value) const
6388 if(getNumberOfComponents()!=1)
6389 throw INTERP_KERNEL::Exception("DataArrayInt::presenceOfValue : the array must have only one component, you can call 'rearrange' method before !");
6390 const int *cptr=getConstPointer();
6391 int nbOfTuples=getNumberOfTuples();
6392 const int *ret=std::find(cptr,cptr+nbOfTuples,value);
6393 if(ret!=cptr+nbOfTuples)
6394 return std::distance(cptr,ret);
6399 * This method expects to be called when number of components of this is equal to one.
6400 * This method returns the tuple id, if it exists, of the first tuple so that the value is contained in \b vals.
6401 * If not any tuple contains one of the values contained in 'vals' -1 is returned.
6402 * \sa DataArrayInt::presenceOfValue
6404 int DataArrayInt::findIdFirstEqual(const std::vector<int>& vals) const
6407 if(getNumberOfComponents()!=1)
6408 throw INTERP_KERNEL::Exception("DataArrayInt::presenceOfValue : the array must have only one component, you can call 'rearrange' method before !");
6409 std::set<int> vals2(vals.begin(),vals.end());
6410 const int *cptr=getConstPointer();
6411 int nbOfTuples=getNumberOfTuples();
6412 for(const int *w=cptr;w!=cptr+nbOfTuples;w++)
6413 if(vals2.find(*w)!=vals2.end())
6414 return std::distance(cptr,w);
6419 * This method returns the number of values in \a this that are equals to input parameter \a value.
6420 * This method only works for single component array.
6422 * \return a value in [ 0, \c this->getNumberOfTuples() )
6424 * \throw If \a this is not allocated
6427 int DataArrayInt::count(int value) const
6431 if(getNumberOfComponents()!=1)
6432 throw INTERP_KERNEL::Exception("DataArrayInt::count : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
6433 const int *vals=begin();
6434 int nbOfTuples=getNumberOfTuples();
6435 for(int i=0;i<nbOfTuples;i++,vals++)
6442 * This method is an extension of DataArrayInt::presenceOfValue method because this method works for DataArrayInt with
6443 * any number of components excepted 0 (an INTERP_KERNEL::Exception is thrown in this case).
6444 * This method searches in \b this is there is a tuple that matched the input parameter \b tupl.
6445 * This method throws an INTERP_KERNEL::Exception if the number of components in \b this mismatches with the size of
6446 * the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
6447 * \sa DataArrayInt::findIdFirstEqualTuple
6449 bool DataArrayInt::presenceOfTuple(const std::vector<int>& tupl) const
6451 return findIdFirstEqualTuple(tupl)!=-1;
6456 * Returns \a true if a given value is present within \a this one-dimensional array.
6457 * \param [in] value - the value to find within \a this array.
6458 * \return bool - \a true in case if \a value is present within \a this array.
6459 * \throw If \a this is not allocated.
6460 * \throw If \a this->getNumberOfComponents() != 1.
6461 * \sa findIdFirstEqual()
6463 bool DataArrayInt::presenceOfValue(int value) const
6465 return findIdFirstEqual(value)!=-1;
6469 * This method expects to be called when number of components of this is equal to one.
6470 * This method returns true if it exists a tuple so that the value is contained in \b vals.
6471 * If not any tuple contains one of the values contained in 'vals' false is returned.
6472 * \sa DataArrayInt::findIdFirstEqual
6474 bool DataArrayInt::presenceOfValue(const std::vector<int>& vals) const
6476 return findIdFirstEqual(vals)!=-1;
6480 * Accumulates values of each component of \a this array.
6481 * \param [out] res - an array of length \a this->getNumberOfComponents(), allocated
6482 * by the caller, that is filled by this method with sum value for each
6484 * \throw If \a this is not allocated.
6486 void DataArrayInt::accumulate(int *res) const
6489 const int *ptr=getConstPointer();
6490 int nbTuple=getNumberOfTuples();
6491 int nbComps=getNumberOfComponents();
6492 std::fill(res,res+nbComps,0);
6493 for(int i=0;i<nbTuple;i++)
6494 std::transform(ptr+i*nbComps,ptr+(i+1)*nbComps,res,res,std::plus<int>());
6497 int DataArrayInt::accumulate(int compId) const
6500 const int *ptr=getConstPointer();
6501 int nbTuple=getNumberOfTuples();
6502 int nbComps=getNumberOfComponents();
6503 if(compId<0 || compId>=nbComps)
6504 throw INTERP_KERNEL::Exception("DataArrayInt::accumulate : Invalid compId specified : No such nb of components !");
6506 for(int i=0;i<nbTuple;i++)
6507 ret+=ptr[i*nbComps+compId];
6512 * This method accumulate using addition tuples in \a this using input index array [ \a bgOfIndex, \a endOfIndex ).
6513 * The returned array will have same number of components than \a this and number of tuples equal to
6514 * \c std::distance(bgOfIndex,endOfIndex) \b minus \b one.
6516 * The input index array is expected to be ascendingly sorted in which the all referenced ids should be in [0, \c this->getNumberOfTuples).
6518 * \param [in] bgOfIndex - begin (included) of the input index array.
6519 * \param [in] endOfIndex - end (excluded) of the input index array.
6520 * \return DataArrayInt * - the new instance having the same number of components than \a this.
6522 * \throw If bgOfIndex or end is NULL.
6523 * \throw If input index array is not ascendingly sorted.
6524 * \throw If there is an id in [ \a bgOfIndex, \a endOfIndex ) not in [0, \c this->getNumberOfTuples).
6525 * \throw If std::distance(bgOfIndex,endOfIndex)==0.
6527 DataArrayInt *DataArrayInt::accumulatePerChunck(const int *bgOfIndex, const int *endOfIndex) const
6529 if(!bgOfIndex || !endOfIndex)
6530 throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : input pointer NULL !");
6532 int nbCompo=getNumberOfComponents();
6533 int nbOfTuples=getNumberOfTuples();
6534 int sz=(int)std::distance(bgOfIndex,endOfIndex);
6536 throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : invalid size of input index array !");
6538 MCAuto<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(sz,nbCompo);
6539 const int *w=bgOfIndex;
6540 if(*w<0 || *w>=nbOfTuples)
6541 throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : The first element of the input index not in [0,nbOfTuples) !");
6542 const int *srcPt=begin()+(*w)*nbCompo;
6543 int *tmp=ret->getPointer();
6544 for(int i=0;i<sz;i++,tmp+=nbCompo,w++)
6546 std::fill(tmp,tmp+nbCompo,0);
6549 for(int j=w[0];j<w[1];j++,srcPt+=nbCompo)
6551 if(j>=0 && j<nbOfTuples)
6552 std::transform(srcPt,srcPt+nbCompo,tmp,tmp,std::plus<int>());
6555 std::ostringstream oss; oss << "DataArrayInt::accumulatePerChunck : At rank #" << i << " the input index array points to id " << j << " should be in [0," << nbOfTuples << ") !";
6556 throw INTERP_KERNEL::Exception(oss.str().c_str());
6562 std::ostringstream oss; oss << "DataArrayInt::accumulatePerChunck : At rank #" << i << " the input index array is not in ascendingly sorted.";
6563 throw INTERP_KERNEL::Exception(oss.str().c_str());
6566 ret->copyStringInfoFrom(*this);
6571 * Returns a new DataArrayInt by concatenating two given arrays, so that (1) the number
6572 * of tuples in the result array is <em> a1->getNumberOfTuples() + a2->getNumberOfTuples() -
6573 * offsetA2</em> and (2)
6574 * the number of component in the result array is same as that of each of given arrays.
6575 * First \a offsetA2 tuples of \a a2 are skipped and thus are missing from the result array.
6576 * Info on components is copied from the first of the given arrays. Number of components
6577 * in the given arrays must be the same.
6578 * \param [in] a1 - an array to include in the result array.
6579 * \param [in] a2 - another array to include in the result array.
6580 * \param [in] offsetA2 - number of tuples of \a a2 to skip.
6581 * \return DataArrayInt * - the new instance of DataArrayInt.
6582 * The caller is to delete this result array using decrRef() as it is no more
6584 * \throw If either \a a1 or \a a2 is NULL.
6585 * \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents().
6587 DataArrayInt *DataArrayInt::Aggregate(const DataArrayInt *a1, const DataArrayInt *a2, int offsetA2)
6590 throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : input DataArrayInt instance is NULL !");
6591 int nbOfComp=a1->getNumberOfComponents();
6592 if(nbOfComp!=a2->getNumberOfComponents())
6593 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Aggregation !");
6594 int nbOfTuple1=a1->getNumberOfTuples();
6595 int nbOfTuple2=a2->getNumberOfTuples();
6596 DataArrayInt *ret=DataArrayInt::New();
6597 ret->alloc(nbOfTuple1+nbOfTuple2-offsetA2,nbOfComp);
6598 int *pt=std::copy(a1->getConstPointer(),a1->getConstPointer()+nbOfTuple1*nbOfComp,ret->getPointer());
6599 std::copy(a2->getConstPointer()+offsetA2*nbOfComp,a2->getConstPointer()+nbOfTuple2*nbOfComp,pt);
6600 ret->copyStringInfoFrom(*a1);
6605 * Returns a new DataArrayInt by concatenating all given arrays, so that (1) the number
6606 * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
6607 * the number of component in the result array is same as that of each of given arrays.
6608 * Info on components is copied from the first of the given arrays. Number of components
6609 * in the given arrays must be the same.
6610 * If the number of non null of elements in \a arr is equal to one the returned object is a copy of it
6611 * not the object itself.
6612 * \param [in] arr - a sequence of arrays to include in the result array.
6613 * \return DataArrayInt * - the new instance of DataArrayInt.
6614 * The caller is to delete this result array using decrRef() as it is no more
6616 * \throw If all arrays within \a arr are NULL.
6617 * \throw If getNumberOfComponents() of arrays within \a arr.
6619 DataArrayInt *DataArrayInt::Aggregate(const std::vector<const DataArrayInt *>& arr)
6621 std::vector<const DataArrayInt *> a;
6622 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
6626 throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : input list must be NON EMPTY !");
6627 std::vector<const DataArrayInt *>::const_iterator it=a.begin();
6628 int nbOfComp=(*it)->getNumberOfComponents();
6629 int nbt=(*it++)->getNumberOfTuples();
6630 for(int i=1;it!=a.end();it++,i++)
6632 if((*it)->getNumberOfComponents()!=nbOfComp)
6633 throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : Nb of components mismatch for array aggregation !");
6634 nbt+=(*it)->getNumberOfTuples();
6636 MCAuto<DataArrayInt> ret=DataArrayInt::New();
6637 ret->alloc(nbt,nbOfComp);
6638 int *pt=ret->getPointer();
6639 for(it=a.begin();it!=a.end();it++)
6640 pt=std::copy((*it)->getConstPointer(),(*it)->getConstPointer()+(*it)->getNbOfElems(),pt);
6641 ret->copyStringInfoFrom(*(a[0]));
6646 * This method takes as input a list of DataArrayInt instances \a arrs that represent each a packed index arrays.
6647 * A packed index array is an allocated array with one component, and at least one tuple. The first element
6648 * of each array in \a arrs must be 0. Each array in \a arrs is expected to be increasingly monotonic.
6649 * 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.
6651 * \return DataArrayInt * - a new object to be managed by the caller.
6653 DataArrayInt *DataArrayInt::AggregateIndexes(const std::vector<const DataArrayInt *>& arrs)
6656 for(std::vector<const DataArrayInt *>::const_iterator it4=arrs.begin();it4!=arrs.end();it4++)
6660 (*it4)->checkAllocated();
6661 if((*it4)->getNumberOfComponents()!=1)
6663 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with nb of compo != 1 at pos " << std::distance(arrs.begin(),it4) << " !";
6664 throw INTERP_KERNEL::Exception(oss.str().c_str());
6666 int nbTupl=(*it4)->getNumberOfTuples();
6669 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with nb of tuples < 1 at pos " << std::distance(arrs.begin(),it4) << " !";
6670 throw INTERP_KERNEL::Exception(oss.str().c_str());
6672 if((*it4)->front()!=0)
6674 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with front value != 0 at pos " << std::distance(arrs.begin(),it4) << " !";
6675 throw INTERP_KERNEL::Exception(oss.str().c_str());
6681 std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a null instance at pos " << std::distance(arrs.begin(),it4) << " !";
6682 throw INTERP_KERNEL::Exception(oss.str().c_str());
6686 throw INTERP_KERNEL::Exception("DataArrayInt::AggregateIndexes : input list must be NON EMPTY !");
6687 MCAuto<DataArrayInt> ret=DataArrayInt::New();
6688 ret->alloc(retSz,1);
6689 int *pt=ret->getPointer(); *pt++=0;
6690 for(std::vector<const DataArrayInt *>::const_iterator it=arrs.begin();it!=arrs.end();it++)
6691 pt=std::transform((*it)->begin()+1,(*it)->end(),pt,std::bind2nd(std::plus<int>(),pt[-1]));
6692 ret->copyStringInfoFrom(*(arrs[0]));
6697 * Returns in a single walk in \a this the min value and the max value in \a this.
6698 * \a this is expected to be single component array.
6700 * \param [out] minValue - the min value in \a this.
6701 * \param [out] maxValue - the max value in \a this.
6703 * \sa getMinValueInArray, getMinValue, getMaxValueInArray, getMaxValue
6705 void DataArrayInt::getMinMaxValues(int& minValue, int& maxValue) const
6708 if(getNumberOfComponents()!=1)
6709 throw INTERP_KERNEL::Exception("DataArrayInt::getMinMaxValues : must be applied on DataArrayInt with only one component !");
6710 int nbTuples(getNumberOfTuples());
6711 const int *pt(begin());
6712 minValue=std::numeric_limits<int>::max(); maxValue=-std::numeric_limits<int>::max();
6713 for(int i=0;i<nbTuples;i++,pt++)
6723 * Converts every value of \a this array to its absolute value.
6724 * \b WARNING this method is non const. If a new DataArrayInt instance should be built containing the result of abs DataArrayInt::computeAbs
6725 * should be called instead.
6727 * \throw If \a this is not allocated.
6728 * \sa DataArrayInt::computeAbs
6730 void DataArrayInt::abs()
6733 int *ptr(getPointer());
6734 std::size_t nbOfElems(getNbOfElems());
6735 std::transform(ptr,ptr+nbOfElems,ptr,std::ptr_fun<int,int>(std::abs));
6740 * This method builds a new instance of \a this object containing the result of std::abs applied of all elements in \a this.
6741 * This method is a const method (that do not change any values in \a this) contrary to DataArrayInt::abs method.
6743 * \return DataArrayInt * - the new instance of DataArrayInt containing the
6744 * same number of tuples and component as \a this array.
6745 * The caller is to delete this result array using decrRef() as it is no more
6747 * \throw If \a this is not allocated.
6748 * \sa DataArrayInt::abs
6750 DataArrayInt *DataArrayInt::computeAbs() const
6753 DataArrayInt *newArr(DataArrayInt::New());
6754 int nbOfTuples(getNumberOfTuples());
6755 int nbOfComp(getNumberOfComponents());
6756 newArr->alloc(nbOfTuples,nbOfComp);
6757 std::transform(begin(),end(),newArr->getPointer(),std::ptr_fun<int,int>(std::abs));
6758 newArr->copyStringInfoFrom(*this);
6763 * Apply a liner function to a given component of \a this array, so that
6764 * an array element <em>(x)</em> becomes \f$ a * x + b \f$.
6765 * \param [in] a - the first coefficient of the function.
6766 * \param [in] b - the second coefficient of the function.
6767 * \param [in] compoId - the index of component to modify.
6768 * \throw If \a this is not allocated.
6770 void DataArrayInt::applyLin(int a, int b, int compoId)
6773 int *ptr=getPointer()+compoId;
6774 int nbOfComp=getNumberOfComponents();
6775 int nbOfTuple=getNumberOfTuples();
6776 for(int i=0;i<nbOfTuple;i++,ptr+=nbOfComp)
6782 * Apply a liner function to all elements of \a this array, so that
6783 * an element _x_ becomes \f$ a * x + b \f$.
6784 * \param [in] a - the first coefficient of the function.
6785 * \param [in] b - the second coefficient of the function.
6786 * \throw If \a this is not allocated.
6788 void DataArrayInt::applyLin(int a, int b)
6791 int *ptr=getPointer();
6792 std::size_t nbOfElems=getNbOfElems();
6793 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
6799 * Returns a full copy of \a this array except that sign of all elements is reversed.
6800 * \return DataArrayInt * - the new instance of DataArrayInt containing the
6801 * same number of tuples and component as \a this array.
6802 * The caller is to delete this result array using decrRef() as it is no more
6804 * \throw If \a this is not allocated.
6806 DataArrayInt *DataArrayInt::negate() const
6809 DataArrayInt *newArr=DataArrayInt::New();
6810 int nbOfTuples=getNumberOfTuples();
6811 int nbOfComp=getNumberOfComponents();
6812 newArr->alloc(nbOfTuples,nbOfComp);
6813 const int *cptr=getConstPointer();
6814 std::transform(cptr,cptr+nbOfTuples*nbOfComp,newArr->getPointer(),std::negate<int>());
6815 newArr->copyStringInfoFrom(*this);
6820 * Modify all elements of \a this array, so that
6821 * an element _x_ becomes \f$ numerator / x \f$.
6822 * \warning If an exception is thrown because of presence of 0 element in \a this
6823 * array, all elements processed before detection of the zero element remain
6825 * \param [in] numerator - the numerator used to modify array elements.
6826 * \throw If \a this is not allocated.
6827 * \throw If there is an element equal to 0 in \a this array.
6829 void DataArrayInt::applyInv(int numerator)
6832 int *ptr=getPointer();
6833 std::size_t nbOfElems=getNbOfElems();
6834 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
6838 *ptr=numerator/(*ptr);
6842 std::ostringstream oss; oss << "DataArrayInt::applyInv : presence of null value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
6844 throw INTERP_KERNEL::Exception(oss.str().c_str());
6851 * Modify all elements of \a this array, so that
6852 * an element _x_ becomes \f$ x / val \f$.
6853 * \param [in] val - the denominator used to modify array elements.
6854 * \throw If \a this is not allocated.
6855 * \throw If \a val == 0.
6857 void DataArrayInt::applyDivideBy(int val)
6860 throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to divide by 0 !");
6862 int *ptr=getPointer();
6863 std::size_t nbOfElems=getNbOfElems();
6864 std::transform(ptr,ptr+nbOfElems,ptr,std::bind2nd(std::divides<int>(),val));
6869 * Modify all elements of \a this array, so that
6870 * an element _x_ becomes <em> x % val </em>.
6871 * \param [in] val - the divisor used to modify array elements.
6872 * \throw If \a this is not allocated.
6873 * \throw If \a val <= 0.
6875 void DataArrayInt::applyModulus(int val)
6878 throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to operate modulus on value <= 0 !");
6880 int *ptr=getPointer();
6881 std::size_t nbOfElems=getNbOfElems();
6882 std::transform(ptr,ptr+nbOfElems,ptr,std::bind2nd(std::modulus<int>(),val));
6887 * This method works only on data array with one component.
6888 * This method returns a newly allocated array storing stored ascendantly tuple ids in \b this so that
6889 * this[*id] in [\b vmin,\b vmax)
6891 * \param [in] vmin begin of range. This value is included in range (included).
6892 * \param [in] vmax end of range. This value is \b not included in range (excluded).
6893 * \return a newly allocated data array that the caller should deal with.
6895 * \sa DataArrayInt::findIdsNotInRange , DataArrayInt::findIdsStricltyNegative
6897 DataArrayInt *DataArrayInt::findIdsInRange(int vmin, int vmax) const
6900 if(getNumberOfComponents()!=1)
6901 throw INTERP_KERNEL::Exception("DataArrayInt::findIdsInRange : this must have exactly one component !");
6902 const int *cptr(begin());
6903 MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
6904 int nbOfTuples(getNumberOfTuples());
6905 for(int i=0;i<nbOfTuples;i++,cptr++)
6906 if(*cptr>=vmin && *cptr<vmax)
6907 ret->pushBackSilent(i);
6912 * This method works only on data array with one component.
6913 * This method returns a newly allocated array storing stored ascendantly tuple ids in \b this so that
6914 * this[*id] \b not in [\b vmin,\b vmax)
6916 * \param [in] vmin begin of range. This value is \b not included in range (excluded).
6917 * \param [in] vmax end of range. This value is included in range (included).
6918 * \return a newly allocated data array that the caller should deal with.
6920 * \sa DataArrayInt::findIdsInRange , DataArrayInt::findIdsStricltyNegative
6922 DataArrayInt *DataArrayInt::findIdsNotInRange(int vmin, int vmax) const
6925 if(getNumberOfComponents()!=1)
6926 throw INTERP_KERNEL::Exception("DataArrayInt::findIdsNotInRange : this must have exactly one component !");
6927 const int *cptr(getConstPointer());
6928 MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
6929 int nbOfTuples(getNumberOfTuples());
6930 for(int i=0;i<nbOfTuples;i++,cptr++)
6931 if(*cptr<vmin || *cptr>=vmax)
6932 ret->pushBackSilent(i);
6937 * This method works only on data array with one component. This method returns a newly allocated array storing stored ascendantly of tuple ids in \a this so that this[id]<0.
6939 * \return a newly allocated data array that the caller should deal with.
6940 * \sa DataArrayInt::findIdsInRange
6942 DataArrayInt *DataArrayInt::findIdsStricltyNegative() const
6945 if(getNumberOfComponents()!=1)
6946 throw INTERP_KERNEL::Exception("DataArrayInt::findIdsStricltyNegative : this must have exactly one component !");
6947 const int *cptr(getConstPointer());
6948 MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
6949 int nbOfTuples(getNumberOfTuples());
6950 for(int i=0;i<nbOfTuples;i++,cptr++)
6952 ret->pushBackSilent(i);
6957 * This method works only on data array with one component.
6958 * 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.
6960 * \param [in] vmin begin of range. This value is included in range (included).
6961 * \param [in] vmax end of range. This value is \b not included in range (excluded).
6962 * \return if all ids in \a this are so that (*this)[i]==i for all i in [ 0, \c this->getNumberOfTuples() ). */
6963 bool DataArrayInt::checkAllIdsInRange(int vmin, int vmax) const
6966 if(getNumberOfComponents()!=1)
6967 throw INTERP_KERNEL::Exception("DataArrayInt::checkAllIdsInRange : this must have exactly one component !");
6968 int nbOfTuples=getNumberOfTuples();
6970 const int *cptr=getConstPointer();
6971 for(int i=0;i<nbOfTuples;i++,cptr++)
6973 if(*cptr>=vmin && *cptr<vmax)
6974 { ret=ret && *cptr==i; }
6977 std::ostringstream oss; oss << "DataArrayInt::checkAllIdsInRange : tuple #" << i << " has value " << *cptr << " should be in [" << vmin << "," << vmax << ") !";
6978 throw INTERP_KERNEL::Exception(oss.str().c_str());
6985 * Modify all elements of \a this array, so that
6986 * an element _x_ becomes <em> val % x </em>.
6987 * \warning If an exception is thrown because of presence of an element <= 0 in \a this
6988 * array, all elements processed before detection of the zero element remain
6990 * \param [in] val - the divident used to modify array elements.
6991 * \throw If \a this is not allocated.
6992 * \throw If there is an element equal to or less than 0 in \a this array.
6994 void DataArrayInt::applyRModulus(int val)
6997 int *ptr=getPointer();
6998 std::size_t nbOfElems=getNbOfElems();
6999 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
7007 std::ostringstream oss; oss << "DataArrayInt::applyRModulus : presence of value <=0 in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
7009 throw INTERP_KERNEL::Exception(oss.str().c_str());
7016 * Modify all elements of \a this array, so that
7017 * an element _x_ becomes <em> val ^ x </em>.
7018 * \param [in] val - the value used to apply pow on all array elements.
7019 * \throw If \a this is not allocated.
7020 * \throw If \a val < 0.
7022 void DataArrayInt::applyPow(int val)
7026 throw INTERP_KERNEL::Exception("DataArrayInt::applyPow : input pow in < 0 !");
7027 int *ptr=getPointer();
7028 std::size_t nbOfElems=getNbOfElems();
7031 std::fill(ptr,ptr+nbOfElems,1);
7034 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
7037 for(int j=0;j<val;j++)
7045 * Modify all elements of \a this array, so that
7046 * an element _x_ becomes \f$ val ^ x \f$.
7047 * \param [in] val - the value used to apply pow on all array elements.
7048 * \throw If \a this is not allocated.
7049 * \throw If there is an element < 0 in \a this array.
7050 * \warning If an exception is thrown because of presence of 0 element in \a this
7051 * array, all elements processed before detection of the zero element remain
7054 void DataArrayInt::applyRPow(int val)
7057 int *ptr=getPointer();
7058 std::size_t nbOfElems=getNbOfElems();
7059 for(std::size_t i=0;i<nbOfElems;i++,ptr++)
7064 for(int j=0;j<*ptr;j++)
7070 std::ostringstream oss; oss << "DataArrayInt::applyRPow : presence of negative value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
7072 throw INTERP_KERNEL::Exception(oss.str().c_str());
7079 * Returns a new DataArrayInt by aggregating two given arrays, so that (1) the number
7080 * of components in the result array is a sum of the number of components of given arrays
7081 * and (2) the number of tuples in the result array is same as that of each of given
7082 * arrays. In other words the i-th tuple of result array includes all components of
7083 * i-th tuples of all given arrays.
7084 * Number of tuples in the given arrays must be the same.
7085 * \param [in] a1 - an array to include in the result array.
7086 * \param [in] a2 - another array to include in the result array.
7087 * \return DataArrayInt * - the new instance of DataArrayInt.
7088 * The caller is to delete this result array using decrRef() as it is no more
7090 * \throw If both \a a1 and \a a2 are NULL.
7091 * \throw If any given array is not allocated.
7092 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
7094 DataArrayInt *DataArrayInt::Meld(const DataArrayInt *a1, const DataArrayInt *a2)
7096 std::vector<const DataArrayInt *> arr(2);
7097 arr[0]=a1; arr[1]=a2;
7102 * Returns a new DataArrayInt by aggregating all given arrays, so that (1) the number
7103 * of components in the result array is a sum of the number of components of given arrays
7104 * and (2) the number of tuples in the result array is same as that of each of given
7105 * arrays. In other words the i-th tuple of result array includes all components of
7106 * i-th tuples of all given arrays.
7107 * Number of tuples in the given arrays must be the same.
7108 * \param [in] arr - a sequence of arrays to include in the result array.
7109 * \return DataArrayInt * - the new instance of DataArrayInt.
7110 * The caller is to delete this result array using decrRef() as it is no more
7112 * \throw If all arrays within \a arr are NULL.
7113 * \throw If any given array is not allocated.
7114 * \throw If getNumberOfTuples() of arrays within \a arr is different.
7116 DataArrayInt *DataArrayInt::Meld(const std::vector<const DataArrayInt *>& arr)
7118 std::vector<const DataArrayInt *> a;
7119 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
7123 throw INTERP_KERNEL::Exception("DataArrayInt::Meld : array must be NON empty !");
7124 std::vector<const DataArrayInt *>::const_iterator it;
7125 for(it=a.begin();it!=a.end();it++)
7126 (*it)->checkAllocated();
7128 int nbOfTuples=(*it)->getNumberOfTuples();
7129 std::vector<int> nbc(a.size());
7130 std::vector<const int *> pts(a.size());
7131 nbc[0]=(*it)->getNumberOfComponents();
7132 pts[0]=(*it++)->getConstPointer();
7133 for(int i=1;it!=a.end();it++,i++)
7135 if(nbOfTuples!=(*it)->getNumberOfTuples())
7136 throw INTERP_KERNEL::Exception("DataArrayInt::meld : mismatch of number of tuples !");
7137 nbc[i]=(*it)->getNumberOfComponents();
7138 pts[i]=(*it)->getConstPointer();
7140 int totalNbOfComp=std::accumulate(nbc.begin(),nbc.end(),0);
7141 DataArrayInt *ret=DataArrayInt::New();
7142 ret->alloc(nbOfTuples,totalNbOfComp);
7143 int *retPtr=ret->getPointer();
7144 for(int i=0;i<nbOfTuples;i++)
7145 for(int j=0;j<(int)a.size();j++)
7147 retPtr=std::copy(pts[j],pts[j]+nbc[j],retPtr);
7151 for(int i=0;i<(int)a.size();i++)
7152 for(int j=0;j<nbc[i];j++,k++)
7153 ret->setInfoOnComponent(k,a[i]->getInfoOnComponent(j));
7158 * Returns a new DataArrayInt which is a minimal partition of elements of \a groups.
7159 * The i-th item of the result array is an ID of a set of elements belonging to a
7160 * unique set of groups, which the i-th element is a part of. This set of elements
7161 * belonging to a unique set of groups is called \a family, so the result array contains
7162 * IDs of families each element belongs to.
7164 * \b Example: if we have two groups of elements: \a group1 [0,4] and \a group2 [ 0,1,2 ],
7165 * then there are 3 families:
7166 * - \a family1 (with ID 1) contains element [0] belonging to ( \a group1 + \a group2 ),
7167 * - \a family2 (with ID 2) contains elements [4] belonging to ( \a group1 ),
7168 * - \a family3 (with ID 3) contains element [1,2] belonging to ( \a group2 ), <br>
7169 * and the result array contains IDs of families [ 1,3,3,0,2 ]. <br> Note a family ID 0 which
7170 * stands for the element #3 which is in none of groups.
7172 * \param [in] groups - sequence of groups of element IDs.
7173 * \param [in] newNb - total number of elements; it must be more than max ID of element
7175 * \param [out] fidsOfGroups - IDs of families the elements of each group belong to.
7176 * \return DataArrayInt * - a new instance of DataArrayInt containing IDs of families
7177 * each element with ID from range [0, \a newNb ) belongs to. The caller is to
7178 * delete this array using decrRef() as it is no more needed.
7179 * \throw If any element ID in \a groups violates condition ( 0 <= ID < \a newNb ).
7181 DataArrayInt *DataArrayInt::MakePartition(const std::vector<const DataArrayInt *>& groups, int newNb, std::vector< std::vector<int> >& fidsOfGroups)
7183 std::vector<const DataArrayInt *> groups2;
7184 for(std::vector<const DataArrayInt *>::const_iterator it4=groups.begin();it4!=groups.end();it4++)
7186 groups2.push_back(*it4);
7187 MCAuto<DataArrayInt> ret=DataArrayInt::New();
7188 ret->alloc(newNb,1);
7189 int *retPtr=ret->getPointer();
7190 std::fill(retPtr,retPtr+newNb,0);
7192 for(std::vector<const DataArrayInt *>::const_iterator iter=groups2.begin();iter!=groups2.end();iter++)
7194 const int *ptr=(*iter)->getConstPointer();
7195 std::size_t nbOfElem=(*iter)->getNbOfElems();
7197 for(int j=0;j<sfid;j++)
7200 for(std::size_t i=0;i<nbOfElem;i++)
7202 if(ptr[i]>=0 && ptr[i]<newNb)
7204 if(retPtr[ptr[i]]==j)
7212 std::ostringstream oss; oss << "DataArrayInt::MakePartition : In group \"" << (*iter)->getName() << "\" in tuple #" << i << " value = " << ptr[i] << " ! Should be in [0," << newNb;
7214 throw INTERP_KERNEL::Exception(oss.str().c_str());
7221 fidsOfGroups.clear();
7222 fidsOfGroups.resize(groups2.size());
7224 for(std::vector<const DataArrayInt *>::const_iterator iter=groups2.begin();iter!=groups2.end();iter++,grId++)
7227 const int *ptr=(*iter)->getConstPointer();
7228 std::size_t nbOfElem=(*iter)->getNbOfElems();
7229 for(const int *p=ptr;p!=ptr+nbOfElem;p++)
7230 tmp.insert(retPtr[*p]);
7231 fidsOfGroups[grId].insert(fidsOfGroups[grId].end(),tmp.begin(),tmp.end());
7237 * Returns a new DataArrayInt which contains all elements of given one-dimensional
7238 * arrays. The result array does not contain any duplicates and its values
7239 * are sorted in ascending order.
7240 * \param [in] arr - sequence of DataArrayInt's to unite.
7241 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7242 * array using decrRef() as it is no more needed.
7243 * \throw If any \a arr[i] is not allocated.
7244 * \throw If \a arr[i]->getNumberOfComponents() != 1.
7246 DataArrayInt *DataArrayInt::BuildUnion(const std::vector<const DataArrayInt *>& arr)
7248 std::vector<const DataArrayInt *> a;
7249 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
7252 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
7254 (*it)->checkAllocated();
7255 if((*it)->getNumberOfComponents()!=1)
7256 throw INTERP_KERNEL::Exception("DataArrayInt::BuildUnion : only single component allowed !");
7260 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
7262 const int *pt=(*it)->getConstPointer();
7263 int nbOfTuples=(*it)->getNumberOfTuples();
7264 r.insert(pt,pt+nbOfTuples);
7266 DataArrayInt *ret=DataArrayInt::New();
7267 ret->alloc((int)r.size(),1);
7268 std::copy(r.begin(),r.end(),ret->getPointer());
7273 * Returns a new DataArrayInt which contains elements present in each of given one-dimensional
7274 * arrays. The result array does not contain any duplicates and its values
7275 * are sorted in ascending order.
7276 * \param [in] arr - sequence of DataArrayInt's to intersect.
7277 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7278 * array using decrRef() as it is no more needed.
7279 * \throw If any \a arr[i] is not allocated.
7280 * \throw If \a arr[i]->getNumberOfComponents() != 1.
7282 DataArrayInt *DataArrayInt::BuildIntersection(const std::vector<const DataArrayInt *>& arr)
7284 std::vector<const DataArrayInt *> a;
7285 for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
7288 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
7290 (*it)->checkAllocated();
7291 if((*it)->getNumberOfComponents()!=1)
7292 throw INTERP_KERNEL::Exception("DataArrayInt::BuildIntersection : only single component allowed !");
7296 for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
7298 const int *pt=(*it)->getConstPointer();
7299 int nbOfTuples=(*it)->getNumberOfTuples();
7300 std::set<int> s1(pt,pt+nbOfTuples);
7304 std::set_intersection(r.begin(),r.end(),s1.begin(),s1.end(),inserter(r2,r2.end()));
7310 DataArrayInt *ret(DataArrayInt::New());
7311 ret->alloc((int)r.size(),1);
7312 std::copy(r.begin(),r.end(),ret->getPointer());
7317 namespace MEDCouplingImpl
7322 OpSwitchedOn(int *pt):_pt(pt),_cnt(0) { }
7323 void operator()(const bool& b) { if(b) *_pt++=_cnt; _cnt++; }
7332 OpSwitchedOff(int *pt):_pt(pt),_cnt(0) { }
7333 void operator()(const bool& b) { if(!b) *_pt++=_cnt; _cnt++; }
7342 * This method returns the list of ids in ascending mode so that v[id]==true.
7344 DataArrayInt *DataArrayInt::BuildListOfSwitchedOn(const std::vector<bool>& v)
7346 int sz((int)std::count(v.begin(),v.end(),true));
7347 MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
7348 std::for_each(v.begin(),v.end(),MEDCouplingImpl::OpSwitchedOn(ret->getPointer()));
7353 * This method returns the list of ids in ascending mode so that v[id]==false.
7355 DataArrayInt *DataArrayInt::BuildListOfSwitchedOff(const std::vector<bool>& v)
7357 int sz((int)std::count(v.begin(),v.end(),false));
7358 MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
7359 std::for_each(v.begin(),v.end(),MEDCouplingImpl::OpSwitchedOff(ret->getPointer()));
7364 * This method allows to put a vector of vector of integer into a more compact data stucture (skyline).
7365 * This method is not available into python because no available optimized data structure available to map std::vector< std::vector<int> >.
7367 * \param [in] v the input data structure to be translate into skyline format.
7368 * \param [out] data the first element of the skyline format. The user is expected to deal with newly allocated array.
7369 * \param [out] dataIndex the second element of the skyline format.
7371 void DataArrayInt::PutIntoToSkylineFrmt(const std::vector< std::vector<int> >& v, DataArrayInt *& data, DataArrayInt *& dataIndex)
7373 int sz((int)v.size());
7374 MCAuto<DataArrayInt> ret0(DataArrayInt::New()),ret1(DataArrayInt::New());
7375 ret1->alloc(sz+1,1);
7376 int *pt(ret1->getPointer()); *pt=0;
7377 for(int i=0;i<sz;i++,pt++)
7378 pt[1]=pt[0]+(int)v[i].size();
7379 ret0->alloc(ret1->back(),1);
7380 pt=ret0->getPointer();
7381 for(int i=0;i<sz;i++)
7382 pt=std::copy(v[i].begin(),v[i].end(),pt);
7383 data=ret0.retn(); dataIndex=ret1.retn();
7387 * Returns a new DataArrayInt which contains a complement of elements of \a this
7388 * one-dimensional array. I.e. the result array contains all elements from the range [0,
7389 * \a nbOfElement) not present in \a this array.
7390 * \param [in] nbOfElement - maximal size of the result array.
7391 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7392 * array using decrRef() as it is no more needed.
7393 * \throw If \a this is not allocated.
7394 * \throw If \a this->getNumberOfComponents() != 1.
7395 * \throw If any element \a x of \a this array violates condition ( 0 <= \a x < \a
7398 DataArrayInt *DataArrayInt::buildComplement(int nbOfElement) const
7401 if(getNumberOfComponents()!=1)
7402 throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : only single component allowed !");
7403 std::vector<bool> tmp(nbOfElement);
7404 const int *pt=getConstPointer();
7405 int nbOfTuples=getNumberOfTuples();
7406 for(const int *w=pt;w!=pt+nbOfTuples;w++)
7407 if(*w>=0 && *w<nbOfElement)
7410 throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : an element is not in valid range : [0,nbOfElement) !");
7411 int nbOfRetVal=(int)std::count(tmp.begin(),tmp.end(),false);
7412 DataArrayInt *ret=DataArrayInt::New();
7413 ret->alloc(nbOfRetVal,1);
7415 int *retPtr=ret->getPointer();
7416 for(int i=0;i<nbOfElement;i++)
7423 * Returns a new DataArrayInt containing elements of \a this one-dimensional missing
7424 * from an \a other one-dimensional array.
7425 * \param [in] other - a DataArrayInt containing elements not to include in the result array.
7426 * \return DataArrayInt * - a new instance of DataArrayInt with one component. The
7427 * caller is to delete this array using decrRef() as it is no more needed.
7428 * \throw If \a other is NULL.
7429 * \throw If \a other is not allocated.
7430 * \throw If \a other->getNumberOfComponents() != 1.
7431 * \throw If \a this is not allocated.
7432 * \throw If \a this->getNumberOfComponents() != 1.
7433 * \sa DataArrayInt::buildSubstractionOptimized()
7435 DataArrayInt *DataArrayInt::buildSubstraction(const DataArrayInt *other) const
7438 throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : DataArrayInt pointer in input is NULL !");
7440 other->checkAllocated();
7441 if(getNumberOfComponents()!=1)
7442 throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed !");
7443 if(other->getNumberOfComponents()!=1)
7444 throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed for other type !");
7445 const int *pt=getConstPointer();
7446 int nbOfTuples=getNumberOfTuples();
7447 std::set<int> s1(pt,pt+nbOfTuples);
7448 pt=other->getConstPointer();
7449 nbOfTuples=other->getNumberOfTuples();
7450 std::set<int> s2(pt,pt+nbOfTuples);
7452 std::set_difference(s1.begin(),s1.end(),s2.begin(),s2.end(),std::back_insert_iterator< std::vector<int> >(r));
7453 DataArrayInt *ret=DataArrayInt::New();
7454 ret->alloc((int)r.size(),1);
7455 std::copy(r.begin(),r.end(),ret->getPointer());
7460 * \a this is expected to have one component and to be sorted ascendingly (as for \a other).
7461 * \a other is expected to be a part of \a this. If not DataArrayInt::buildSubstraction should be called instead.
7463 * \param [in] other an array with one component and expected to be sorted ascendingly.
7464 * \ret list of ids in \a this but not in \a other.
7465 * \sa DataArrayInt::buildSubstraction
7467 DataArrayInt *DataArrayInt::buildSubstractionOptimized(const DataArrayInt *other) const
7469 static const char *MSG="DataArrayInt::buildSubstractionOptimized : only single component allowed !";
7470 if(!other) throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstractionOptimized : NULL input array !");
7471 checkAllocated(); other->checkAllocated();
7472 if(getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception(MSG);
7473 if(other->getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception(MSG);
7474 const int *pt1Bg(begin()),*pt1End(end()),*pt2Bg(other->begin()),*pt2End(other->end());
7475 const int *work1(pt1Bg),*work2(pt2Bg);
7476 MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
7477 for(;work1!=pt1End;work1++)
7479 if(work2!=pt2End && *work1==*work2)
7482 ret->pushBackSilent(*work1);
7489 * Returns a new DataArrayInt which contains all elements of \a this and a given
7490 * one-dimensional arrays. The result array does not contain any duplicates
7491 * and its values are sorted in ascending order.
7492 * \param [in] other - an array to unite with \a this one.
7493 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7494 * array using decrRef() as it is no more needed.
7495 * \throw If \a this or \a other is not allocated.
7496 * \throw If \a this->getNumberOfComponents() != 1.
7497 * \throw If \a other->getNumberOfComponents() != 1.
7499 DataArrayInt *DataArrayInt::buildUnion(const DataArrayInt *other) const
7501 std::vector<const DataArrayInt *>arrs(2);
7502 arrs[0]=this; arrs[1]=other;
7503 return BuildUnion(arrs);
7508 * Returns a new DataArrayInt which contains elements present in both \a this and a given
7509 * one-dimensional arrays. The result array does not contain any duplicates
7510 * and its values are sorted in ascending order.
7511 * \param [in] other - an array to intersect with \a this one.
7512 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7513 * array using decrRef() as it is no more needed.
7514 * \throw If \a this or \a other is not allocated.
7515 * \throw If \a this->getNumberOfComponents() != 1.
7516 * \throw If \a other->getNumberOfComponents() != 1.
7518 DataArrayInt *DataArrayInt::buildIntersection(const DataArrayInt *other) const
7520 std::vector<const DataArrayInt *>arrs(2);
7521 arrs[0]=this; arrs[1]=other;
7522 return BuildIntersection(arrs);
7526 * This method can be applied on allocated with one component DataArrayInt instance.
7527 * This method is typically relevant for sorted arrays. All consecutive duplicated items in \a this will appear only once in returned DataArrayInt instance.
7528 * 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]
7530 * \return a newly allocated array that contain the result of the unique operation applied on \a this.
7531 * \throw if \a this is not allocated or if \a this has not exactly one component.
7532 * \sa DataArrayInt::buildUniqueNotSorted
7534 DataArrayInt *DataArrayInt::buildUnique() const
7537 if(getNumberOfComponents()!=1)
7538 throw INTERP_KERNEL::Exception("DataArrayInt::buildUnique : only single component allowed !");
7539 int nbOfTuples=getNumberOfTuples();
7540 MCAuto<DataArrayInt> tmp=deepCopy();
7541 int *data=tmp->getPointer();
7542 int *last=std::unique(data,data+nbOfTuples);
7543 MCAuto<DataArrayInt> ret=DataArrayInt::New();
7544 ret->alloc(std::distance(data,last),1);
7545 std::copy(data,last,ret->getPointer());
7550 * This method can be applied on allocated with one component DataArrayInt instance.
7551 * This method keep elements only once by keeping the same order in \a this that is not expected to be sorted.
7553 * \return a newly allocated array that contain the result of the unique operation applied on \a this.
7555 * \throw if \a this is not allocated or if \a this has not exactly one component.
7557 * \sa DataArrayInt::buildUnique
7559 DataArrayInt *DataArrayInt::buildUniqueNotSorted() const
7562 if(getNumberOfComponents()!=1)
7563 throw INTERP_KERNEL::Exception("DataArrayInt::buildUniqueNotSorted : only single component allowed !");
7565 getMinMaxValues(minVal,maxVal);
7566 std::vector<bool> b(maxVal-minVal+1,false);
7567 const int *ptBg(begin()),*endBg(end());
7568 MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
7569 for(const int *pt=ptBg;pt!=endBg;pt++)
7573 ret->pushBackSilent(*pt);
7577 ret->copyStringInfoFrom(*this);
7582 * Returns a new DataArrayInt which contains size of every of groups described by \a this
7583 * "index" array. Such "index" array is returned for example by
7584 * \ref MEDCoupling::MEDCouplingUMesh::buildDescendingConnectivity
7585 * "MEDCouplingUMesh::buildDescendingConnectivity" and
7586 * \ref MEDCoupling::MEDCouplingUMesh::getNodalConnectivityIndex
7587 * "MEDCouplingUMesh::getNodalConnectivityIndex" etc.
7588 * This method preforms the reverse operation of DataArrayInt::computeOffsetsFull.
7589 * \return DataArrayInt * - a new instance of DataArrayInt, whose number of tuples
7590 * equals to \a this->getNumberOfComponents() - 1, and number of components is 1.
7591 * The caller is to delete this array using decrRef() as it is no more needed.
7592 * \throw If \a this is not allocated.
7593 * \throw If \a this->getNumberOfComponents() != 1.
7594 * \throw If \a this->getNumberOfTuples() < 2.
7597 * - this contains [1,3,6,7,7,9,15]
7598 * - result array contains [2,3,1,0,2,6],
7599 * where 2 = 3 - 1, 3 = 6 - 3, 1 = 7 - 6 etc.
7601 * \sa DataArrayInt::computeOffsetsFull
7603 DataArrayInt *DataArrayInt::deltaShiftIndex() const
7606 if(getNumberOfComponents()!=1)
7607 throw INTERP_KERNEL::Exception("DataArrayInt::deltaShiftIndex : only single component allowed !");
7608 int nbOfTuples=getNumberOfTuples();
7610 throw INTERP_KERNEL::Exception("DataArrayInt::deltaShiftIndex : 1 tuple at least must be present in 'this' !");
7611 const int *ptr=getConstPointer();
7612 DataArrayInt *ret=DataArrayInt::New();
7613 ret->alloc(nbOfTuples-1,1);
7614 int *out=ret->getPointer();
7615 std::transform(ptr+1,ptr+nbOfTuples,ptr,out,std::minus<int>());
7620 * Modifies \a this one-dimensional array so that value of each element \a x
7621 * of \a this array (\a a) is computed as \f$ x_i = \sum_{j=0}^{i-1} a[ j ] \f$.
7622 * Or: for each i>0 new[i]=new[i-1]+old[i-1] for i==0 new[i]=0. Number of tuples
7623 * and components remains the same.<br>
7624 * This method is useful for allToAllV in MPI with contiguous policy. This method
7625 * differs from computeOffsetsFull() in that the number of tuples is \b not changed by
7627 * \throw If \a this is not allocated.
7628 * \throw If \a this->getNumberOfComponents() != 1.
7631 * - Before \a this contains [3,5,1,2,0,8]
7632 * - After \a this contains [0,3,8,9,11,11]<br>
7633 * Note that the last element 19 = 11 + 8 is missing because size of \a this
7634 * array is retained and thus there is no space to store the last element.
7636 void DataArrayInt::computeOffsets()
7639 if(getNumberOfComponents()!=1)
7640 throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsets : only single component allowed !");
7641 int nbOfTuples=getNumberOfTuples();
7644 int *work=getPointer();
7647 for(int i=1;i<nbOfTuples;i++)
7650 work[i]=work[i-1]+tmp;
7658 * Modifies \a this one-dimensional array so that value of each element \a x
7659 * of \a this array (\a a) is computed as \f$ x_i = \sum_{j=0}^{i-1} a[ j ] \f$.
7660 * Or: for each i>0 new[i]=new[i-1]+old[i-1] for i==0 new[i]=0. Number
7661 * components remains the same and number of tuples is inceamented by one.<br>
7662 * This method is useful for allToAllV in MPI with contiguous policy. This method
7663 * differs from computeOffsets() in that the number of tuples is changed by this one.
7664 * This method preforms the reverse operation of DataArrayInt::deltaShiftIndex.
7665 * \throw If \a this is not allocated.
7666 * \throw If \a this->getNumberOfComponents() != 1.
7669 * - Before \a this contains [3,5,1,2,0,8]
7670 * - After \a this contains [0,3,8,9,11,11,19]<br>
7671 * \sa DataArrayInt::deltaShiftIndex
7673 void DataArrayInt::computeOffsetsFull()
7676 if(getNumberOfComponents()!=1)
7677 throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsetsFull : only single component allowed !");
7678 int nbOfTuples=getNumberOfTuples();
7679 int *ret=(int *)malloc((nbOfTuples+1)*sizeof(int));
7680 const int *work=getConstPointer();
7682 for(int i=0;i<nbOfTuples;i++)
7683 ret[i+1]=work[i]+ret[i];
7684 useArray(ret,true,C_DEALLOC,nbOfTuples+1,1);
7689 * Returns two new DataArrayInt instances whose contents is computed from that of \a this and \a listOfIds arrays as follows.
7690 * \a this is expected to be an offset format ( as returned by DataArrayInt::computeOffsetsFull ) that is to say with one component
7691 * and ** sorted strictly increasingly **. \a listOfIds is expected to be sorted ascendingly (not strictly needed for \a listOfIds).
7692 * This methods searches in \a this, considered as a set of contiguous \c this->getNumberOfComponents() ranges, all ids in \a listOfIds
7693 * filling completely one of the ranges in \a this.
7695 * \param [in] listOfIds a list of ids that has to be sorted ascendingly.
7696 * \param [out] rangeIdsFetched the range ids fetched
7697 * \param [out] idsInInputListThatFetch contains the list of ids in \a listOfIds that are \b fully included in a range in \a this. So
7698 * \a idsInInputListThatFetch is a part of input \a listOfIds.
7700 * \sa DataArrayInt::computeOffsetsFull
7703 * - \a this : [0,3,7,9,15,18]
7704 * - \a listOfIds contains [0,1,2,3,7,8,15,16,17]
7705 * - \a rangeIdsFetched result array: [0,2,4]
7706 * - \a idsInInputListThatFetch result array: [0,1,2,7,8,15,16,17]
7707 * In this example id 3 in input \a listOfIds is alone so it do not appear in output \a idsInInputListThatFetch.
7710 void DataArrayInt::findIdsRangesInListOfIds(const DataArrayInt *listOfIds, DataArrayInt *& rangeIdsFetched, DataArrayInt *& idsInInputListThatFetch) const
7713 throw INTERP_KERNEL::Exception("DataArrayInt::findIdsRangesInListOfIds : input list of ids is null !");
7714 listOfIds->checkAllocated(); checkAllocated();
7715 if(listOfIds->getNumberOfComponents()!=1)
7716 throw INTERP_KERNEL::Exception("DataArrayInt::findIdsRangesInListOfIds : input list of ids must have exactly one component !");
7717 if(getNumberOfComponents()!=1)
7718 throw INTERP_KERNEL::Exception("DataArrayInt::findIdsRangesInListOfIds : this must have exactly one component !");
7719 MCAuto<DataArrayInt> ret0=DataArrayInt::New(); ret0->alloc(0,1);
7720 MCAuto<DataArrayInt> ret1=DataArrayInt::New(); ret1->alloc(0,1);
7721 const int *tupEnd(listOfIds->end()),*offBg(begin()),*offEnd(end()-1);
7722 const int *tupPtr(listOfIds->begin()),*offPtr(offBg);
7723 while(tupPtr!=tupEnd && offPtr!=offEnd)
7725 if(*tupPtr==*offPtr)
7728 while(i<offPtr[1] && *tupPtr==i && tupPtr!=tupEnd) { i++; tupPtr++; }
7731 ret0->pushBackSilent((int)std::distance(offBg,offPtr));
7732 ret1->pushBackValsSilent(tupPtr-(offPtr[1]-offPtr[0]),tupPtr);
7737 { if(*tupPtr<*offPtr) tupPtr++; else offPtr++; }
7739 rangeIdsFetched=ret0.retn();
7740 idsInInputListThatFetch=ret1.retn();
7744 * Returns a new DataArrayInt whose contents is computed from that of \a this and \a
7745 * offsets arrays as follows. \a offsets is a one-dimensional array considered as an
7746 * "index" array of a "iota" array, thus, whose each element gives an index of a group
7747 * beginning within the "iota" array. And \a this is a one-dimensional array
7748 * considered as a selector of groups described by \a offsets to include into the result array.
7749 * \throw If \a offsets is NULL.
7750 * \throw If \a offsets is not allocated.
7751 * \throw If \a offsets->getNumberOfComponents() != 1.
7752 * \throw If \a offsets is not monotonically increasing.
7753 * \throw If \a this is not allocated.
7754 * \throw If \a this->getNumberOfComponents() != 1.
7755 * \throw If any element of \a this is not a valid index for \a offsets array.
7758 * - \a this: [0,2,3]
7759 * - \a offsets: [0,3,6,10,14,20]
7760 * - result array: [0,1,2,6,7,8,9,10,11,12,13] == <br>
7761 * \c range(0,3) + \c range(6,10) + \c range(10,14) ==<br>
7762 * \c range( \a offsets[ \a this[0] ], offsets[ \a this[0]+1 ]) +
7763 * \c range( \a offsets[ \a this[1] ], offsets[ \a this[1]+1 ]) +
7764 * \c range( \a offsets[ \a this[2] ], offsets[ \a this[2]+1 ])
7766 DataArrayInt *DataArrayInt::buildExplicitArrByRanges(const DataArrayInt *offsets) const
7769 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : DataArrayInt pointer in input is NULL !");
7771 if(getNumberOfComponents()!=1)
7772 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : only single component allowed !");
7773 offsets->checkAllocated();
7774 if(offsets->getNumberOfComponents()!=1)
7775 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : input array should have only single component !");
7776 int othNbTuples=offsets->getNumberOfTuples()-1;
7777 int nbOfTuples=getNumberOfTuples();
7778 int retNbOftuples=0;
7779 const int *work=getConstPointer();
7780 const int *offPtr=offsets->getConstPointer();
7781 for(int i=0;i<nbOfTuples;i++)
7784 if(val>=0 && val<othNbTuples)
7786 int delta=offPtr[val+1]-offPtr[val];
7788 retNbOftuples+=delta;
7791 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrByRanges : Tuple #" << val << " of offset array has a delta < 0 !";
7792 throw INTERP_KERNEL::Exception(oss.str().c_str());
7797 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrByRanges : Tuple #" << i << " in this contains " << val;
7798 oss << " whereas offsets array is of size " << othNbTuples+1 << " !";
7799 throw INTERP_KERNEL::Exception(oss.str().c_str());
7802 MCAuto<DataArrayInt> ret=DataArrayInt::New();
7803 ret->alloc(retNbOftuples,1);
7804 int *retPtr=ret->getPointer();
7805 for(int i=0;i<nbOfTuples;i++)
7808 int start=offPtr[val];
7809 int off=offPtr[val+1]-start;
7810 for(int j=0;j<off;j++,retPtr++)
7817 * Returns a new DataArrayInt whose contents is computed using \a this that must be a
7818 * scaled array (monotonically increasing).
7819 from that of \a this and \a
7820 * offsets arrays as follows. \a offsets is a one-dimensional array considered as an
7821 * "index" array of a "iota" array, thus, whose each element gives an index of a group
7822 * beginning within the "iota" array. And \a this is a one-dimensional array
7823 * considered as a selector of groups described by \a offsets to include into the result array.
7824 * \throw If \a is NULL.
7825 * \throw If \a this is not allocated.
7826 * \throw If \a this->getNumberOfComponents() != 1.
7827 * \throw If \a this->getNumberOfTuples() == 0.
7828 * \throw If \a this is not monotonically increasing.
7829 * \throw If any element of ids in ( \a bg \a stop \a step ) points outside the scale in \a this.
7832 * - \a bg , \a stop and \a step : (0,5,2)
7833 * - \a this: [0,3,6,10,14,20]
7834 * - result array: [0,0,0, 2,2,2,2, 4,4,4,4,4,4] == <br>
7836 DataArrayInt *DataArrayInt::buildExplicitArrOfSliceOnScaledArr(int bg, int stop, int step) const
7839 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : not allocated array !");
7840 if(getNumberOfComponents()!=1)
7841 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : number of components is expected to be equal to one !");
7842 int nbOfTuples(getNumberOfTuples());
7844 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : number of tuples must be != 0 !");
7845 const int *ids(begin());
7846 int nbOfEltsInSlc(GetNumberOfItemGivenBESRelative(bg,stop,step,"DataArrayInt::buildExplicitArrOfSliceOnScaledArr")),sz(0),pos(bg);
7847 for(int i=0;i<nbOfEltsInSlc;i++,pos+=step)
7849 if(pos>=0 && pos<nbOfTuples-1)
7851 int delta(ids[pos+1]-ids[pos]);
7855 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrOfSliceOnScaledArr : At pos #" << i << " of input slice, value is " << pos << " and at this pos this is not monotonically increasing !";
7856 throw INTERP_KERNEL::Exception(oss.str().c_str());
7861 std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrOfSliceOnScaledArr : At pos #" << i << " of input slice, value is " << pos << " should be in [0," << nbOfTuples-1 << ") !";
7862 throw INTERP_KERNEL::Exception(oss.str().c_str());
7865 MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
7866 int *retPtr(ret->getPointer());
7868 for(int i=0;i<nbOfEltsInSlc;i++,pos+=step)
7870 int delta(ids[pos+1]-ids[pos]);
7871 for(int j=0;j<delta;j++,retPtr++)
7878 * 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.
7879 * 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
7880 * in tuple **i** of returned DataArrayInt.
7881 * If ranges overlapped (in theory it should not) this method do not detect it and always returns the first range.
7883 * 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)]
7884 * The return DataArrayInt will contain : **[0,4,1,2,2,3]**
7886 * \param [in] ranges typically come from output of MEDCouplingUMesh::ComputeRangesFromTypeDistribution. Each range is specified like this : 1st component is
7887 * for lower value included and 2nd component is the upper value of corresponding range **excluded**.
7888 * \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
7889 * is thrown if no ranges in \a ranges contains value in \a this.
7891 * \sa DataArrayInt::findIdInRangeForEachTuple
7893 DataArrayInt *DataArrayInt::findRangeIdForEachTuple(const DataArrayInt *ranges) const
7896 throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : null input pointer !");
7897 if(ranges->getNumberOfComponents()!=2)
7898 throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : input DataArrayInt instance should have 2 components !");
7900 if(getNumberOfComponents()!=1)
7901 throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : this should have only one component !");
7902 int nbTuples=getNumberOfTuples();
7903 MCAuto<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTuples,1);
7904 int nbOfRanges=ranges->getNumberOfTuples();
7905 const int *rangesPtr=ranges->getConstPointer();
7906 int *retPtr=ret->getPointer();
7907 const int *inPtr=getConstPointer();
7908 for(int i=0;i<nbTuples;i++,retPtr++)
7912 for(int j=0;j<nbOfRanges && !found;j++)
7913 if(val>=rangesPtr[2*j] && val<rangesPtr[2*j+1])
7914 { *retPtr=j; found=true; }
7919 std::ostringstream oss; oss << "DataArrayInt::findRangeIdForEachTuple : tuple #" << i << " not found by any ranges !";
7920 throw INTERP_KERNEL::Exception(oss.str().c_str());
7927 * 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.
7928 * 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
7929 * in tuple **i** of returned DataArrayInt.
7930 * If ranges overlapped (in theory it should not) this method do not detect it and always returns the sub position of the first range.
7932 * 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)]
7933 * The return DataArrayInt will contain : **[1,2,4,0,2,2]**
7934 * This method is often called in pair with DataArrayInt::findRangeIdForEachTuple method.
7936 * \param [in] ranges typically come from output of MEDCouplingUMesh::ComputeRangesFromTypeDistribution. Each range is specified like this : 1st component is
7937 * for lower value included and 2nd component is the upper value of corresponding range **excluded**.
7938 * \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
7939 * is thrown if no ranges in \a ranges contains value in \a this.
7940 * \sa DataArrayInt::findRangeIdForEachTuple
7942 DataArrayInt *DataArrayInt::findIdInRangeForEachTuple(const DataArrayInt *ranges) const
7945 throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : null input pointer !");
7946 if(ranges->getNumberOfComponents()!=2)
7947 throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : input DataArrayInt instance should have 2 components !");
7949 if(getNumberOfComponents()!=1)
7950 throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : this should have only one component !");
7951 int nbTuples=getNumberOfTuples();
7952 MCAuto<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTuples,1);
7953 int nbOfRanges=ranges->getNumberOfTuples();
7954 const int *rangesPtr=ranges->getConstPointer();
7955 int *retPtr=ret->getPointer();
7956 const int *inPtr=getConstPointer();
7957 for(int i=0;i<nbTuples;i++,retPtr++)
7961 for(int j=0;j<nbOfRanges && !found;j++)
7962 if(val>=rangesPtr[2*j] && val<rangesPtr[2*j+1])
7963 { *retPtr=val-rangesPtr[2*j]; found=true; }
7968 std::ostringstream oss; oss << "DataArrayInt::findIdInRangeForEachTuple : tuple #" << i << " not found by any ranges !";
7969 throw INTERP_KERNEL::Exception(oss.str().c_str());
7976 * \b WARNING this method is a \b non \a const \b method. This method works tuple by tuple. Each tuple is expected to be pairs (number of components must be equal to 2).
7977 * This method rearrange each pair in \a this so that, tuple with id \b tid will be after the call \c this->getIJ(tid,0)==this->getIJ(tid-1,1) and \c this->getIJ(tid,1)==this->getIJ(tid+1,0).
7978 * If it is impossible to reach such condition an exception will be thrown ! \b WARNING In case of throw \a this can be partially modified !
7979 * If this method has correctly worked, \a this will be able to be considered as a linked list.
7980 * This method does nothing if number of tuples is lower of equal to 1.
7982 * This method is useful for users having an unstructured mesh having only SEG2 to rearrange internaly the connectibity without any coordinates consideration.
7984 * \sa MEDCouplingUMesh::orderConsecutiveCells1D
7986 void DataArrayInt::sortEachPairToMakeALinkedList()
7989 if(getNumberOfComponents()!=2)
7990 throw INTERP_KERNEL::Exception("DataArrayInt::sortEachPairToMakeALinkedList : Only works on DataArrayInt instance with nb of components equal to 2 !");
7991 int nbOfTuples(getNumberOfTuples());
7994 int *conn(getPointer());
7995 for(int i=1;i<nbOfTuples;i++,conn+=2)
7999 if(conn[2]==conn[3])
8001 std::ostringstream oss; oss << "DataArrayInt::sortEachPairToMakeALinkedList : In the tuple #" << i << " presence of a pair filled with same ids !";
8002 throw INTERP_KERNEL::Exception(oss.str().c_str());
8004 if(conn[2]!=conn[1] && conn[3]==conn[1] && conn[2]!=conn[0])
8005 std::swap(conn[2],conn[3]);
8006 //not(conn[2]==conn[1] && conn[3]!=conn[1] && conn[3]!=conn[0])
8007 if(conn[2]!=conn[1] || conn[3]==conn[1] || conn[3]==conn[0])
8009 std::ostringstream oss; oss << "DataArrayInt::sortEachPairToMakeALinkedList : In the tuple #" << i << " something is invalid !";
8010 throw INTERP_KERNEL::Exception(oss.str().c_str());
8015 if(conn[0]==conn[1] || conn[2]==conn[3])
8016 throw INTERP_KERNEL::Exception("DataArrayInt::sortEachPairToMakeALinkedList : In the 2 first tuples presence of a pair filled with same ids !");
8019 s.insert(conn,conn+4);
8021 throw INTERP_KERNEL::Exception("DataArrayInt::sortEachPairToMakeALinkedList : This can't be considered as a linked list regarding 2 first tuples !");
8022 if(std::count(conn,conn+4,conn[0])==2)
8027 if(conn[2]==conn[0])
8031 std::copy(tmp,tmp+4,conn);
8034 {//here we are sure to have (std::count(conn,conn+4,conn[1])==2)
8035 if(conn[1]==conn[3])
8036 std::swap(conn[2],conn[3]);
8044 * \param [in] nbTimes specifies the nb of times each tuples in \a this will be duplicated contiguouly in returned DataArrayInt instance.
8045 * \a nbTimes should be at least equal to 1.
8046 * \return a newly allocated DataArrayInt having one component and number of tuples equal to \a nbTimes * \c this->getNumberOfTuples.
8047 * \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.
8049 DataArrayInt *DataArrayInt::duplicateEachTupleNTimes(int nbTimes) const
8052 if(getNumberOfComponents()!=1)
8053 throw INTERP_KERNEL::Exception("DataArrayInt::duplicateEachTupleNTimes : this should have only one component !");
8055 throw INTERP_KERNEL::Exception("DataArrayInt::duplicateEachTupleNTimes : nb times should be >= 1 !");
8056 int nbTuples=getNumberOfTuples();
8057 const int *inPtr=getConstPointer();
8058 MCAuto<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTimes*nbTuples,1);
8059 int *retPtr=ret->getPointer();
8060 for(int i=0;i<nbTuples;i++,inPtr++)
8063 for(int j=0;j<nbTimes;j++,retPtr++)
8066 ret->copyStringInfoFrom(*this);
8071 * This method returns all different values found in \a this. This method throws if \a this has not been allocated.
8072 * But the number of components can be different from one.
8073 * \return a newly allocated array (that should be dealt by the caller) containing different values in \a this.
8075 DataArrayInt *DataArrayInt::getDifferentValues() const
8079 ret.insert(begin(),end());
8080 MCAuto<DataArrayInt> ret2=DataArrayInt::New(); ret2->alloc((int)ret.size(),1);
8081 std::copy(ret.begin(),ret.end(),ret2->getPointer());
8086 * This method is a refinement of DataArrayInt::getDifferentValues because it returns not only different values in \a this but also, for each of
8087 * them it tells which tuple id have this id.
8088 * This method works only on arrays with one component (if it is not the case call DataArrayInt::rearrange(1) ).
8089 * This method returns two arrays having same size.
8090 * 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.
8091 * 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]]
8093 std::vector<DataArrayInt *> DataArrayInt::partitionByDifferentValues(std::vector<int>& differentIds) const
8096 if(getNumberOfComponents()!=1)
8097 throw INTERP_KERNEL::Exception("DataArrayInt::partitionByDifferentValues : this should have only one component !");
8099 std::map<int,int> m,m2,m3;
8100 for(const int *w=begin();w!=end();w++)
8102 differentIds.resize(m.size());
8103 std::vector<DataArrayInt *> ret(m.size());
8104 std::vector<int *> retPtr(m.size());
8105 for(std::map<int,int>::const_iterator it=m.begin();it!=m.end();it++,id++)
8108 ret[id]=DataArrayInt::New();
8109 ret[id]->alloc((*it).second,1);
8110 retPtr[id]=ret[id]->getPointer();
8111 differentIds[id]=(*it).first;
8114 for(const int *w=begin();w!=end();w++,id++)
8116 retPtr[m2[*w]][m3[*w]++]=id;
8122 * This method split ids in [0, \c this->getNumberOfTuples() ) using \a this array as a field of weight (>=0 each).
8123 * The aim of this method is to return a set of \a nbOfSlices chunk of contiguous ids as balanced as possible.
8125 * \param [in] nbOfSlices - number of slices expected.
8126 * \return - a vector having a size equal to \a nbOfSlices giving the start (included) and the stop (excluded) of each chunks.
8128 * \sa DataArray::GetSlice
8129 * \throw If \a this is not allocated or not with exactly one component.
8130 * \throw If an element in \a this if < 0.
8132 std::vector< std::pair<int,int> > DataArrayInt::splitInBalancedSlices(int nbOfSlices) const
8134 if(!isAllocated() || getNumberOfComponents()!=1)
8135 throw INTERP_KERNEL::Exception("DataArrayInt::splitInBalancedSlices : this array should have number of components equal to one and must be allocated !");
8137 throw INTERP_KERNEL::Exception("DataArrayInt::splitInBalancedSlices : number of slices must be >= 1 !");
8138 int sum(accumulate(0)),nbOfTuples(getNumberOfTuples());
8139 int sumPerSlc(sum/nbOfSlices),pos(0);
8140 const int *w(begin());
8141 std::vector< std::pair<int,int> > ret(nbOfSlices);
8142 for(int i=0;i<nbOfSlices;i++)
8144 std::pair<int,int> p(pos,-1);
8146 while(locSum<sumPerSlc && pos<nbOfTuples) { pos++; locSum+=*w++; }
8150 p.second=nbOfTuples;
8157 * Returns a new DataArrayInt that is a sum of two given arrays. There are 3
8159 * 1. The arrays have same number of tuples and components. Then each value of
8160 * the result array (_a_) is a sum of the corresponding values of \a a1 and \a a2,
8161 * i.e.: _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, j ].
8162 * 2. The arrays have same number of tuples and one array, say _a2_, has one
8164 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, 0 ].
8165 * 3. The arrays have same number of components and one array, say _a2_, has one
8167 * _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ 0, j ].
8169 * Info on components is copied either from the first array (in the first case) or from
8170 * the array with maximal number of elements (getNbOfElems()).
8171 * \param [in] a1 - an array to sum up.
8172 * \param [in] a2 - another array to sum up.
8173 * \return DataArrayInt * - the new instance of DataArrayInt.
8174 * The caller is to delete this result array using decrRef() as it is no more
8176 * \throw If either \a a1 or \a a2 is NULL.
8177 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
8178 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
8179 * none of them has number of tuples or components equal to 1.
8181 DataArrayInt *DataArrayInt::Add(const DataArrayInt *a1, const DataArrayInt *a2)
8184 throw INTERP_KERNEL::Exception("DataArrayInt::Add : input DataArrayInt instance is NULL !");
8185 int nbOfTuple=a1->getNumberOfTuples();
8186 int nbOfTuple2=a2->getNumberOfTuples();
8187 int nbOfComp=a1->getNumberOfComponents();
8188 int nbOfComp2=a2->getNumberOfComponents();
8189 MCAuto<DataArrayInt> ret=0;
8190 if(nbOfTuple==nbOfTuple2)
8192 if(nbOfComp==nbOfComp2)
8194 ret=DataArrayInt::New();
8195 ret->alloc(nbOfTuple,nbOfComp);
8196 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::plus<int>());
8197 ret->copyStringInfoFrom(*a1);
8201 int nbOfCompMin,nbOfCompMax;
8202 const DataArrayInt *aMin, *aMax;
8203 if(nbOfComp>nbOfComp2)
8205 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
8210 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
8215 ret=DataArrayInt::New();
8216 ret->alloc(nbOfTuple,nbOfCompMax);
8217 const int *aMinPtr=aMin->getConstPointer();
8218 const int *aMaxPtr=aMax->getConstPointer();
8219 int *res=ret->getPointer();
8220 for(int i=0;i<nbOfTuple;i++)
8221 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::plus<int>(),aMinPtr[i]));
8222 ret->copyStringInfoFrom(*aMax);
8225 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
8228 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
8230 if(nbOfComp==nbOfComp2)
8232 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
8233 const DataArrayInt *aMin=nbOfTuple>nbOfTuple2?a2:a1;
8234 const DataArrayInt *aMax=nbOfTuple>nbOfTuple2?a1:a2;
8235 const int *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
8236 ret=DataArrayInt::New();
8237 ret->alloc(nbOfTupleMax,nbOfComp);
8238 int *res=ret->getPointer();
8239 for(int i=0;i<nbOfTupleMax;i++)
8240 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::plus<int>());
8241 ret->copyStringInfoFrom(*aMax);
8244 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
8247 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Add !");
8252 * Adds values of another DataArrayInt to values of \a this one. There are 3
8254 * 1. The arrays have same number of tuples and components. Then each value of
8255 * \a other array is added to the corresponding value of \a this array, i.e.:
8256 * _a_ [ i, j ] += _other_ [ i, j ].
8257 * 2. The arrays have same number of tuples and \a other array has one component. Then
8258 * _a_ [ i, j ] += _other_ [ i, 0 ].
8259 * 3. The arrays have same number of components and \a other array has one tuple. Then
8260 * _a_ [ i, j ] += _a2_ [ 0, j ].
8262 * \param [in] other - an array to add to \a this one.
8263 * \throw If \a other is NULL.
8264 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
8265 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
8266 * \a other has number of both tuples and components not equal to 1.
8268 void DataArrayInt::addEqual(const DataArrayInt *other)
8271 throw INTERP_KERNEL::Exception("DataArrayInt::addEqual : input DataArrayInt instance is NULL !");
8272 const char *msg="Nb of tuples mismatch for DataArrayInt::addEqual !";
8273 checkAllocated(); other->checkAllocated();
8274 int nbOfTuple=getNumberOfTuples();
8275 int nbOfTuple2=other->getNumberOfTuples();
8276 int nbOfComp=getNumberOfComponents();
8277 int nbOfComp2=other->getNumberOfComponents();
8278 if(nbOfTuple==nbOfTuple2)
8280 if(nbOfComp==nbOfComp2)
8282 std::transform(begin(),end(),other->begin(),getPointer(),std::plus<int>());
8284 else if(nbOfComp2==1)
8286 int *ptr=getPointer();
8287 const int *ptrc=other->getConstPointer();
8288 for(int i=0;i<nbOfTuple;i++)
8289 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::plus<int>(),*ptrc++));
8292 throw INTERP_KERNEL::Exception(msg);
8294 else if(nbOfTuple2==1)
8296 if(nbOfComp2==nbOfComp)
8298 int *ptr=getPointer();
8299 const int *ptrc=other->getConstPointer();
8300 for(int i=0;i<nbOfTuple;i++)
8301 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::plus<int>());
8304 throw INTERP_KERNEL::Exception(msg);
8307 throw INTERP_KERNEL::Exception(msg);
8312 * Returns a new DataArrayInt that is a subtraction of two given arrays. There are 3
8314 * 1. The arrays have same number of tuples and components. Then each value of
8315 * the result array (_a_) is a subtraction of the corresponding values of \a a1 and
8316 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, j ].
8317 * 2. The arrays have same number of tuples and one array, say _a2_, has one
8319 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, 0 ].
8320 * 3. The arrays have same number of components and one array, say _a2_, has one
8322 * _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ 0, j ].
8324 * Info on components is copied either from the first array (in the first case) or from
8325 * the array with maximal number of elements (getNbOfElems()).
8326 * \param [in] a1 - an array to subtract from.
8327 * \param [in] a2 - an array to subtract.
8328 * \return DataArrayInt * - the new instance of DataArrayInt.
8329 * The caller is to delete this result array using decrRef() as it is no more
8331 * \throw If either \a a1 or \a a2 is NULL.
8332 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
8333 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
8334 * none of them has number of tuples or components equal to 1.
8336 DataArrayInt *DataArrayInt::Substract(const DataArrayInt *a1, const DataArrayInt *a2)
8339 throw INTERP_KERNEL::Exception("DataArrayInt::Substract : input DataArrayInt instance is NULL !");
8340 int nbOfTuple1=a1->getNumberOfTuples();
8341 int nbOfTuple2=a2->getNumberOfTuples();
8342 int nbOfComp1=a1->getNumberOfComponents();
8343 int nbOfComp2=a2->getNumberOfComponents();
8344 if(nbOfTuple2==nbOfTuple1)
8346 if(nbOfComp1==nbOfComp2)
8348 MCAuto<DataArrayInt> ret=DataArrayInt::New();
8349 ret->alloc(nbOfTuple2,nbOfComp1);
8350 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::minus<int>());
8351 ret->copyStringInfoFrom(*a1);
8354 else if(nbOfComp2==1)
8356 MCAuto<DataArrayInt> ret=DataArrayInt::New();
8357 ret->alloc(nbOfTuple1,nbOfComp1);
8358 const int *a2Ptr=a2->getConstPointer();
8359 const int *a1Ptr=a1->getConstPointer();
8360 int *res=ret->getPointer();
8361 for(int i=0;i<nbOfTuple1;i++)
8362 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::minus<int>(),a2Ptr[i]));
8363 ret->copyStringInfoFrom(*a1);
8368 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
8372 else if(nbOfTuple2==1)
8374 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
8375 MCAuto<DataArrayInt> ret=DataArrayInt::New();
8376 ret->alloc(nbOfTuple1,nbOfComp1);
8377 const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
8378 int *pt=ret->getPointer();
8379 for(int i=0;i<nbOfTuple1;i++)
8380 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::minus<int>());
8381 ret->copyStringInfoFrom(*a1);
8386 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Substract !");//will always throw an exception
8392 * Subtract values of another DataArrayInt from values of \a this one. There are 3
8394 * 1. The arrays have same number of tuples and components. Then each value of
8395 * \a other array is subtracted from the corresponding value of \a this array, i.e.:
8396 * _a_ [ i, j ] -= _other_ [ i, j ].
8397 * 2. The arrays have same number of tuples and \a other array has one component. Then
8398 * _a_ [ i, j ] -= _other_ [ i, 0 ].
8399 * 3. The arrays have same number of components and \a other array has one tuple. Then
8400 * _a_ [ i, j ] -= _a2_ [ 0, j ].
8402 * \param [in] other - an array to subtract from \a this one.
8403 * \throw If \a other is NULL.
8404 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
8405 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
8406 * \a other has number of both tuples and components not equal to 1.
8408 void DataArrayInt::substractEqual(const DataArrayInt *other)
8411 throw INTERP_KERNEL::Exception("DataArrayInt::substractEqual : input DataArrayInt instance is NULL !");
8412 const char *msg="Nb of tuples mismatch for DataArrayInt::substractEqual !";
8413 checkAllocated(); other->checkAllocated();
8414 int nbOfTuple=getNumberOfTuples();
8415 int nbOfTuple2=other->getNumberOfTuples();
8416 int nbOfComp=getNumberOfComponents();
8417 int nbOfComp2=other->getNumberOfComponents();
8418 if(nbOfTuple==nbOfTuple2)
8420 if(nbOfComp==nbOfComp2)
8422 std::transform(begin(),end(),other->begin(),getPointer(),std::minus<int>());
8424 else if(nbOfComp2==1)
8426 int *ptr=getPointer();
8427 const int *ptrc=other->getConstPointer();
8428 for(int i=0;i<nbOfTuple;i++)
8429 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::minus<int>(),*ptrc++));
8432 throw INTERP_KERNEL::Exception(msg);
8434 else if(nbOfTuple2==1)
8436 int *ptr=getPointer();
8437 const int *ptrc=other->getConstPointer();
8438 for(int i=0;i<nbOfTuple;i++)
8439 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::minus<int>());
8442 throw INTERP_KERNEL::Exception(msg);
8447 * Returns a new DataArrayInt that is a product of two given arrays. There are 3
8449 * 1. The arrays have same number of tuples and components. Then each value of
8450 * the result array (_a_) is a product of the corresponding values of \a a1 and
8451 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, j ].
8452 * 2. The arrays have same number of tuples and one array, say _a2_, has one
8454 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, 0 ].
8455 * 3. The arrays have same number of components and one array, say _a2_, has one
8457 * _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ 0, j ].
8459 * Info on components is copied either from the first array (in the first case) or from
8460 * the array with maximal number of elements (getNbOfElems()).
8461 * \param [in] a1 - a factor array.
8462 * \param [in] a2 - another factor array.
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->getNumberOfTuples() != \a a2->getNumberOfTuples() and
8468 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
8469 * none of them has number of tuples or components equal to 1.
8471 DataArrayInt *DataArrayInt::Multiply(const DataArrayInt *a1, const DataArrayInt *a2)
8474 throw INTERP_KERNEL::Exception("DataArrayInt::Multiply : input DataArrayInt instance is NULL !");
8475 int nbOfTuple=a1->getNumberOfTuples();
8476 int nbOfTuple2=a2->getNumberOfTuples();
8477 int nbOfComp=a1->getNumberOfComponents();
8478 int nbOfComp2=a2->getNumberOfComponents();
8479 MCAuto<DataArrayInt> ret=0;
8480 if(nbOfTuple==nbOfTuple2)
8482 if(nbOfComp==nbOfComp2)
8484 ret=DataArrayInt::New();
8485 ret->alloc(nbOfTuple,nbOfComp);
8486 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::multiplies<int>());
8487 ret->copyStringInfoFrom(*a1);
8491 int nbOfCompMin,nbOfCompMax;
8492 const DataArrayInt *aMin, *aMax;
8493 if(nbOfComp>nbOfComp2)
8495 nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
8500 nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
8505 ret=DataArrayInt::New();
8506 ret->alloc(nbOfTuple,nbOfCompMax);
8507 const int *aMinPtr=aMin->getConstPointer();
8508 const int *aMaxPtr=aMax->getConstPointer();
8509 int *res=ret->getPointer();
8510 for(int i=0;i<nbOfTuple;i++)
8511 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::multiplies<int>(),aMinPtr[i]));
8512 ret->copyStringInfoFrom(*aMax);
8515 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
8518 else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
8520 if(nbOfComp==nbOfComp2)
8522 int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
8523 const DataArrayInt *aMin=nbOfTuple>nbOfTuple2?a2:a1;
8524 const DataArrayInt *aMax=nbOfTuple>nbOfTuple2?a1:a2;
8525 const int *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
8526 ret=DataArrayInt::New();
8527 ret->alloc(nbOfTupleMax,nbOfComp);
8528 int *res=ret->getPointer();
8529 for(int i=0;i<nbOfTupleMax;i++)
8530 res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::multiplies<int>());
8531 ret->copyStringInfoFrom(*aMax);
8534 throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
8537 throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Multiply !");
8543 * Multiply values of another DataArrayInt to values of \a this one. There are 3
8545 * 1. The arrays have same number of tuples and components. Then each value of
8546 * \a other array is multiplied to the corresponding value of \a this array, i.e.:
8547 * _a_ [ i, j ] *= _other_ [ i, j ].
8548 * 2. The arrays have same number of tuples and \a other array has one component. Then
8549 * _a_ [ i, j ] *= _other_ [ i, 0 ].
8550 * 3. The arrays have same number of components and \a other array has one tuple. Then
8551 * _a_ [ i, j ] *= _a2_ [ 0, j ].
8553 * \param [in] other - an array to multiply to \a this one.
8554 * \throw If \a other is NULL.
8555 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
8556 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
8557 * \a other has number of both tuples and components not equal to 1.
8559 void DataArrayInt::multiplyEqual(const DataArrayInt *other)
8562 throw INTERP_KERNEL::Exception("DataArrayInt::multiplyEqual : input DataArrayInt instance is NULL !");
8563 const char *msg="Nb of tuples mismatch for DataArrayInt::multiplyEqual !";
8564 checkAllocated(); other->checkAllocated();
8565 int nbOfTuple=getNumberOfTuples();
8566 int nbOfTuple2=other->getNumberOfTuples();
8567 int nbOfComp=getNumberOfComponents();
8568 int nbOfComp2=other->getNumberOfComponents();
8569 if(nbOfTuple==nbOfTuple2)
8571 if(nbOfComp==nbOfComp2)
8573 std::transform(begin(),end(),other->begin(),getPointer(),std::multiplies<int>());
8575 else if(nbOfComp2==1)
8577 int *ptr=getPointer();
8578 const int *ptrc=other->getConstPointer();
8579 for(int i=0;i<nbOfTuple;i++)
8580 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::multiplies<int>(),*ptrc++));
8583 throw INTERP_KERNEL::Exception(msg);
8585 else if(nbOfTuple2==1)
8587 if(nbOfComp2==nbOfComp)
8589 int *ptr=getPointer();
8590 const int *ptrc=other->getConstPointer();
8591 for(int i=0;i<nbOfTuple;i++)
8592 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::multiplies<int>());
8595 throw INTERP_KERNEL::Exception(msg);
8598 throw INTERP_KERNEL::Exception(msg);
8604 * Returns a new DataArrayInt that is a division of two given arrays. There are 3
8606 * 1. The arrays have same number of tuples and components. Then each value of
8607 * the result array (_a_) is a division of the corresponding values of \a a1 and
8608 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, j ].
8609 * 2. The arrays have same number of tuples and one array, say _a2_, has one
8611 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, 0 ].
8612 * 3. The arrays have same number of components and one array, say _a2_, has one
8614 * _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ 0, j ].
8616 * Info on components is copied either from the first array (in the first case) or from
8617 * the array with maximal number of elements (getNbOfElems()).
8618 * \warning No check of division by zero is performed!
8619 * \param [in] a1 - a numerator array.
8620 * \param [in] a2 - a denominator array.
8621 * \return DataArrayInt * - the new instance of DataArrayInt.
8622 * The caller is to delete this result array using decrRef() as it is no more
8624 * \throw If either \a a1 or \a a2 is NULL.
8625 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
8626 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
8627 * none of them has number of tuples or components equal to 1.
8629 DataArrayInt *DataArrayInt::Divide(const DataArrayInt *a1, const DataArrayInt *a2)
8632 throw INTERP_KERNEL::Exception("DataArrayInt::Divide : input DataArrayInt instance is NULL !");
8633 int nbOfTuple1=a1->getNumberOfTuples();
8634 int nbOfTuple2=a2->getNumberOfTuples();
8635 int nbOfComp1=a1->getNumberOfComponents();
8636 int nbOfComp2=a2->getNumberOfComponents();
8637 if(nbOfTuple2==nbOfTuple1)
8639 if(nbOfComp1==nbOfComp2)
8641 MCAuto<DataArrayInt> ret=DataArrayInt::New();
8642 ret->alloc(nbOfTuple2,nbOfComp1);
8643 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::divides<int>());
8644 ret->copyStringInfoFrom(*a1);
8647 else if(nbOfComp2==1)
8649 MCAuto<DataArrayInt> ret=DataArrayInt::New();
8650 ret->alloc(nbOfTuple1,nbOfComp1);
8651 const int *a2Ptr=a2->getConstPointer();
8652 const int *a1Ptr=a1->getConstPointer();
8653 int *res=ret->getPointer();
8654 for(int i=0;i<nbOfTuple1;i++)
8655 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::divides<int>(),a2Ptr[i]));
8656 ret->copyStringInfoFrom(*a1);
8661 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
8665 else if(nbOfTuple2==1)
8667 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
8668 MCAuto<DataArrayInt> ret=DataArrayInt::New();
8669 ret->alloc(nbOfTuple1,nbOfComp1);
8670 const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
8671 int *pt=ret->getPointer();
8672 for(int i=0;i<nbOfTuple1;i++)
8673 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::divides<int>());
8674 ret->copyStringInfoFrom(*a1);
8679 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Divide !");//will always throw an exception
8685 * Divide values of \a this array by values of another DataArrayInt. There are 3
8687 * 1. The arrays have same number of tuples and components. Then each value of
8688 * \a this array is divided by the corresponding value of \a other one, i.e.:
8689 * _a_ [ i, j ] /= _other_ [ i, j ].
8690 * 2. The arrays have same number of tuples and \a other array has one component. Then
8691 * _a_ [ i, j ] /= _other_ [ i, 0 ].
8692 * 3. The arrays have same number of components and \a other array has one tuple. Then
8693 * _a_ [ i, j ] /= _a2_ [ 0, j ].
8695 * \warning No check of division by zero is performed!
8696 * \param [in] other - an array to divide \a this one by.
8697 * \throw If \a other is NULL.
8698 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
8699 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
8700 * \a other has number of both tuples and components not equal to 1.
8702 void DataArrayInt::divideEqual(const DataArrayInt *other)
8705 throw INTERP_KERNEL::Exception("DataArrayInt::divideEqual : input DataArrayInt instance is NULL !");
8706 const char *msg="Nb of tuples mismatch for DataArrayInt::divideEqual !";
8707 checkAllocated(); other->checkAllocated();
8708 int nbOfTuple=getNumberOfTuples();
8709 int nbOfTuple2=other->getNumberOfTuples();
8710 int nbOfComp=getNumberOfComponents();
8711 int nbOfComp2=other->getNumberOfComponents();
8712 if(nbOfTuple==nbOfTuple2)
8714 if(nbOfComp==nbOfComp2)
8716 std::transform(begin(),end(),other->begin(),getPointer(),std::divides<int>());
8718 else if(nbOfComp2==1)
8720 int *ptr=getPointer();
8721 const int *ptrc=other->getConstPointer();
8722 for(int i=0;i<nbOfTuple;i++)
8723 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::divides<int>(),*ptrc++));
8726 throw INTERP_KERNEL::Exception(msg);
8728 else if(nbOfTuple2==1)
8730 if(nbOfComp2==nbOfComp)
8732 int *ptr=getPointer();
8733 const int *ptrc=other->getConstPointer();
8734 for(int i=0;i<nbOfTuple;i++)
8735 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::divides<int>());
8738 throw INTERP_KERNEL::Exception(msg);
8741 throw INTERP_KERNEL::Exception(msg);
8747 * Returns a new DataArrayInt that is a modulus of two given arrays. There are 3
8749 * 1. The arrays have same number of tuples and components. Then each value of
8750 * the result array (_a_) is a division of the corresponding values of \a a1 and
8751 * \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ i, j ].
8752 * 2. The arrays have same number of tuples and one array, say _a2_, has one
8754 * _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ i, 0 ].
8755 * 3. The arrays have same number of components and one array, say _a2_, has one
8757 * _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ 0, j ].
8759 * Info on components is copied either from the first array (in the first case) or from
8760 * the array with maximal number of elements (getNbOfElems()).
8761 * \warning No check of division by zero is performed!
8762 * \param [in] a1 - a dividend array.
8763 * \param [in] a2 - a divisor array.
8764 * \return DataArrayInt * - the new instance of DataArrayInt.
8765 * The caller is to delete this result array using decrRef() as it is no more
8767 * \throw If either \a a1 or \a a2 is NULL.
8768 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
8769 * \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
8770 * none of them has number of tuples or components equal to 1.
8772 DataArrayInt *DataArrayInt::Modulus(const DataArrayInt *a1, const DataArrayInt *a2)
8775 throw INTERP_KERNEL::Exception("DataArrayInt::Modulus : input DataArrayInt instance is NULL !");
8776 int nbOfTuple1=a1->getNumberOfTuples();
8777 int nbOfTuple2=a2->getNumberOfTuples();
8778 int nbOfComp1=a1->getNumberOfComponents();
8779 int nbOfComp2=a2->getNumberOfComponents();
8780 if(nbOfTuple2==nbOfTuple1)
8782 if(nbOfComp1==nbOfComp2)
8784 MCAuto<DataArrayInt> ret=DataArrayInt::New();
8785 ret->alloc(nbOfTuple2,nbOfComp1);
8786 std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::modulus<int>());
8787 ret->copyStringInfoFrom(*a1);
8790 else if(nbOfComp2==1)
8792 MCAuto<DataArrayInt> ret=DataArrayInt::New();
8793 ret->alloc(nbOfTuple1,nbOfComp1);
8794 const int *a2Ptr=a2->getConstPointer();
8795 const int *a1Ptr=a1->getConstPointer();
8796 int *res=ret->getPointer();
8797 for(int i=0;i<nbOfTuple1;i++)
8798 res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::modulus<int>(),a2Ptr[i]));
8799 ret->copyStringInfoFrom(*a1);
8804 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Modulus !");
8808 else if(nbOfTuple2==1)
8810 a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Modulus !");
8811 MCAuto<DataArrayInt> ret=DataArrayInt::New();
8812 ret->alloc(nbOfTuple1,nbOfComp1);
8813 const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
8814 int *pt=ret->getPointer();
8815 for(int i=0;i<nbOfTuple1;i++)
8816 pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::modulus<int>());
8817 ret->copyStringInfoFrom(*a1);
8822 a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Modulus !");//will always throw an exception
8828 * Modify \a this array so that each value becomes a modulus of division of this value by
8829 * a value of another DataArrayInt. There are 3 valid cases.
8830 * 1. The arrays have same number of tuples and components. Then each value of
8831 * \a this array is divided by the corresponding value of \a other one, i.e.:
8832 * _a_ [ i, j ] %= _other_ [ i, j ].
8833 * 2. The arrays have same number of tuples and \a other array has one component. Then
8834 * _a_ [ i, j ] %= _other_ [ i, 0 ].
8835 * 3. The arrays have same number of components and \a other array has one tuple. Then
8836 * _a_ [ i, j ] %= _a2_ [ 0, j ].
8838 * \warning No check of division by zero is performed!
8839 * \param [in] other - a divisor array.
8840 * \throw If \a other is NULL.
8841 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
8842 * \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
8843 * \a other has number of both tuples and components not equal to 1.
8845 void DataArrayInt::modulusEqual(const DataArrayInt *other)
8848 throw INTERP_KERNEL::Exception("DataArrayInt::modulusEqual : input DataArrayInt instance is NULL !");
8849 const char *msg="Nb of tuples mismatch for DataArrayInt::modulusEqual !";
8850 checkAllocated(); other->checkAllocated();
8851 int nbOfTuple=getNumberOfTuples();
8852 int nbOfTuple2=other->getNumberOfTuples();
8853 int nbOfComp=getNumberOfComponents();
8854 int nbOfComp2=other->getNumberOfComponents();
8855 if(nbOfTuple==nbOfTuple2)
8857 if(nbOfComp==nbOfComp2)
8859 std::transform(begin(),end(),other->begin(),getPointer(),std::modulus<int>());
8861 else if(nbOfComp2==1)
8863 if(nbOfComp2==nbOfComp)
8865 int *ptr=getPointer();
8866 const int *ptrc=other->getConstPointer();
8867 for(int i=0;i<nbOfTuple;i++)
8868 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::modulus<int>(),*ptrc++));
8871 throw INTERP_KERNEL::Exception(msg);
8874 throw INTERP_KERNEL::Exception(msg);
8876 else if(nbOfTuple2==1)
8878 int *ptr=getPointer();
8879 const int *ptrc=other->getConstPointer();
8880 for(int i=0;i<nbOfTuple;i++)
8881 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::modulus<int>());
8884 throw INTERP_KERNEL::Exception(msg);
8889 * Returns a new DataArrayInt that is the result of pow of two given arrays. There are 3
8892 * \param [in] a1 - an array to pow up.
8893 * \param [in] a2 - another array to sum up.
8894 * \return DataArrayInt * - the new instance of DataArrayInt.
8895 * The caller is to delete this result array using decrRef() as it is no more
8897 * \throw If either \a a1 or \a a2 is NULL.
8898 * \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
8899 * \throw If \a a1->getNumberOfComponents() != 1 or \a a2->getNumberOfComponents() != 1.
8900 * \throw If there is a negative value in \a a2.
8902 DataArrayInt *DataArrayInt::Pow(const DataArrayInt *a1, const DataArrayInt *a2)
8905 throw INTERP_KERNEL::Exception("DataArrayInt::Pow : at least one of input instances is null !");
8906 int nbOfTuple=a1->getNumberOfTuples();
8907 int nbOfTuple2=a2->getNumberOfTuples();
8908 int nbOfComp=a1->getNumberOfComponents();
8909 int nbOfComp2=a2->getNumberOfComponents();
8910 if(nbOfTuple!=nbOfTuple2)
8911 throw INTERP_KERNEL::Exception("DataArrayInt::Pow : number of tuples mismatches !");
8912 if(nbOfComp!=1 || nbOfComp2!=1)
8913 throw INTERP_KERNEL::Exception("DataArrayInt::Pow : number of components of both arrays must be equal to 1 !");
8914 MCAuto<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbOfTuple,1);
8915 const int *ptr1(a1->begin()),*ptr2(a2->begin());
8916 int *ptr=ret->getPointer();
8917 for(int i=0;i<nbOfTuple;i++,ptr1++,ptr2++,ptr++)
8922 for(int j=0;j<*ptr2;j++)
8928 std::ostringstream oss; oss << "DataArrayInt::Pow : on tuple #" << i << " of a2 value is < 0 (" << *ptr2 << ") !";
8929 throw INTERP_KERNEL::Exception(oss.str().c_str());
8936 * Apply pow on values of another DataArrayInt to values of \a this one.
8938 * \param [in] other - an array to pow to \a this one.
8939 * \throw If \a other is NULL.
8940 * \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples()
8941 * \throw If \a this->getNumberOfComponents() != 1 or \a other->getNumberOfComponents() != 1
8942 * \throw If there is a negative value in \a other.
8944 void DataArrayInt::powEqual(const DataArrayInt *other)
8947 throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : input instance is null !");
8948 int nbOfTuple=getNumberOfTuples();
8949 int nbOfTuple2=other->getNumberOfTuples();
8950 int nbOfComp=getNumberOfComponents();
8951 int nbOfComp2=other->getNumberOfComponents();
8952 if(nbOfTuple!=nbOfTuple2)
8953 throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : number of tuples mismatches !");
8954 if(nbOfComp!=1 || nbOfComp2!=1)
8955 throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : number of components of both arrays must be equal to 1 !");
8956 int *ptr=getPointer();
8957 const int *ptrc=other->begin();
8958 for(int i=0;i<nbOfTuple;i++,ptrc++,ptr++)
8963 for(int j=0;j<*ptrc;j++)
8969 std::ostringstream oss; oss << "DataArrayInt::powEqual : on tuple #" << i << " of other value is < 0 (" << *ptrc << ") !";
8970 throw INTERP_KERNEL::Exception(oss.str().c_str());
8977 * Returns a C array which is a renumbering map in "Old to New" mode for the input array.
8978 * This map, if applied to \a start array, would make it sorted. For example, if
8979 * \a start array contents are [9,10,0,6,4,11,3,7] then the contents of the result array is
8980 * [5,6,0,3,2,7,1,4].
8981 * \param [in] start - pointer to the first element of the array for which the
8982 * permutation map is computed.
8983 * \param [in] end - pointer specifying the end of the array \a start, so that
8984 * the last value of \a start is \a end[ -1 ].
8985 * \return int * - the result permutation array that the caller is to delete as it is no
8987 * \throw If there are equal values in the input array.
8989 int *DataArrayInt::CheckAndPreparePermutation(const int *start, const int *end)
8991 std::size_t sz=std::distance(start,end);
8992 int *ret=(int *)malloc(sz*sizeof(int));
8993 int *work=new int[sz];
8994 std::copy(start,end,work);
8995 std::sort(work,work+sz);
8996 if(std::unique(work,work+sz)!=work+sz)
9000 throw INTERP_KERNEL::Exception("Some elements are equals in the specified array !");
9002 std::map<int,int> m;
9003 for(int *workPt=work;workPt!=work+sz;workPt++)
9004 m[*workPt]=(int)std::distance(work,workPt);
9006 for(const int *iter=start;iter!=end;iter++,iter2++)
9013 * Returns a new DataArrayInt containing an arithmetic progression
9014 * that is equal to the sequence returned by Python \c range(\a begin,\a end,\a step )
9016 * \param [in] begin - the start value of the result sequence.
9017 * \param [in] end - limiting value, so that every value of the result array is less than
9019 * \param [in] step - specifies the increment or decrement.
9020 * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9021 * array using decrRef() as it is no more needed.
9022 * \throw If \a step == 0.
9023 * \throw If \a end < \a begin && \a step > 0.
9024 * \throw If \a end > \a begin && \a step < 0.
9026 DataArrayInt *DataArrayInt::Range(int begin, int end, int step)
9028 int nbOfTuples=GetNumberOfItemGivenBESRelative(begin,end,step,"DataArrayInt::Range");
9029 MCAuto<DataArrayInt> ret=DataArrayInt::New();
9030 ret->alloc(nbOfTuples,1);
9031 int *ptr=ret->getPointer();
9034 for(int i=begin;i<end;i+=step,ptr++)
9039 for(int i=begin;i>end;i+=step,ptr++)
9046 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
9049 void DataArrayInt::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
9054 tinyInfo[0]=getNumberOfTuples();
9055 tinyInfo[1]=getNumberOfComponents();
9065 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
9068 void DataArrayInt::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
9072 int nbOfCompo=getNumberOfComponents();
9073 tinyInfo.resize(nbOfCompo+1);
9074 tinyInfo[0]=getName();
9075 for(int i=0;i<nbOfCompo;i++)
9076 tinyInfo[i+1]=getInfoOnComponent(i);
9081 tinyInfo[0]=getName();
9086 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
9087 * This method returns if a feeding is needed.
9089 bool DataArrayInt::resizeForUnserialization(const std::vector<int>& tinyInfoI)
9091 int nbOfTuple=tinyInfoI[0];
9092 int nbOfComp=tinyInfoI[1];
9093 if(nbOfTuple!=-1 || nbOfComp!=-1)
9095 alloc(nbOfTuple,nbOfComp);
9102 * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
9103 * This method returns if a feeding is needed.
9105 void DataArrayInt::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<std::string>& tinyInfoS)
9107 setName(tinyInfoS[0]);
9110 int nbOfCompo=tinyInfoI[1];
9111 for(int i=0;i<nbOfCompo;i++)
9112 setInfoOnComponent(i,tinyInfoS[i+1]);
9116 DataArrayIntIterator::DataArrayIntIterator(DataArrayInt *da):_da(da),_pt(0),_tuple_id(0),_nb_comp(0),_nb_tuple(0)
9121 if(_da->isAllocated())
9123 _nb_comp=da->getNumberOfComponents();
9124 _nb_tuple=da->getNumberOfTuples();
9125 _pt=da->getPointer();
9130 DataArrayIntIterator::~DataArrayIntIterator()
9136 DataArrayIntTuple *DataArrayIntIterator::nextt()
9138 if(_tuple_id<_nb_tuple)
9141 DataArrayIntTuple *ret=new DataArrayIntTuple(_pt,_nb_comp);
9149 DataArrayIntTuple::DataArrayIntTuple(int *pt, int nbOfComp):_pt(pt),_nb_of_compo(nbOfComp)
9153 std::string DataArrayIntTuple::repr() const
9155 std::ostringstream oss; oss << "(";
9156 for(int i=0;i<_nb_of_compo-1;i++)
9157 oss << _pt[i] << ", ";
9158 oss << _pt[_nb_of_compo-1] << ")";
9162 int DataArrayIntTuple::intValue() const
9166 throw INTERP_KERNEL::Exception("DataArrayIntTuple::intValue : DataArrayIntTuple instance has not exactly 1 component -> Not possible to convert it into an integer !");
9170 * This method returns a newly allocated instance the caller should dealed with by a MEDCoupling::DataArrayInt::decrRef.
9171 * This method performs \b no copy of data. The content is only referenced using MEDCoupling::DataArrayInt::useArray with ownership set to \b false.
9172 * 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
9173 * \b nbOfCompo=1 and \bnbOfTuples==this->_nb_of_elem.
9175 DataArrayInt *DataArrayIntTuple::buildDAInt(int nbOfTuples, int nbOfCompo) const
9177 if((_nb_of_compo==nbOfCompo && nbOfTuples==1) || (_nb_of_compo==nbOfTuples && nbOfCompo==1))
9179 DataArrayInt *ret=DataArrayInt::New();
9180 ret->useExternalArrayWithRWAccess(_pt,nbOfTuples,nbOfCompo);
9185 std::ostringstream oss; oss << "DataArrayIntTuple::buildDAInt : unable to build a requested DataArrayInt instance with nbofTuple=" << nbOfTuples << " and nbOfCompo=" << nbOfCompo;
9186 oss << ".\nBecause the number of elements in this is " << _nb_of_compo << " !";
9187 throw INTERP_KERNEL::Exception(oss.str().c_str());