src/MEDCoupling/MEDCouplingMemArray.cxx

   1 // Copyright (C) 2007-2015  CEA/DEN, EDF R&D
   2 //
   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.
   7 //
   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.
  12 //
  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
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19 // Author : Anthony Geay (CEA/DEN)
  20
  21 #include "MEDCouplingMemArray.txx"
  22 #include "MEDCouplingAutoRefCountObjectPtr.hxx"
  23
  24 #include "BBTree.txx"
  25 #include "GenMathFormulae.hxx"
  26 #include "InterpKernelAutoPtr.hxx"
  27 #include "InterpKernelExprParser.hxx"
  28
  29 #include <set>
  30 #include <cmath>
  31 #include <limits>
  32 #include <numeric>
  33 #include <algorithm>
  34 #include <functional>
  35
  36 typedef double (*MYFUNCPTR)(double);
  37
  38 using namespace ParaMEDMEM;
  39
  40 template<int SPACEDIM>
  41 void DataArrayDouble::findCommonTuplesAlg(const double *bbox, int nbNodes, int limitNodeId, double prec, DataArrayInt *c, DataArrayInt *cI) const
  42 {
  43   const double *coordsPtr=getConstPointer();
  44   BBTreePts<SPACEDIM,int> myTree(bbox,0,0,nbNodes,prec);
  45   std::vector<bool> isDone(nbNodes);
  46   for(int i=0;i<nbNodes;i++)
  47     {
  48       if(!isDone[i])
  49         {
  50           std::vector<int> intersectingElems;
  51           myTree.getElementsAroundPoint(coordsPtr+i*SPACEDIM,intersectingElems);
  52           if(intersectingElems.size()>1)
  53             {
  54               std::vector<int> commonNodes;
  55               for(std::vector<int>::const_iterator it=intersectingElems.begin();it!=intersectingElems.end();it++)
  56                 if(*it!=i)
  57                   if(*it>=limitNodeId)
  58                     {
  59                       commonNodes.push_back(*it);
  60                       isDone[*it]=true;
  61                     }
  62               if(!commonNodes.empty())
  63                 {
  64                   cI->pushBackSilent(cI->back()+(int)commonNodes.size()+1);
  65                   c->pushBackSilent(i);
  66                   c->insertAtTheEnd(commonNodes.begin(),commonNodes.end());
  67                 }
  68             }
  69         }
  70     }
  71 }
  72
  73 template<int SPACEDIM>
  74 void DataArrayDouble::FindTupleIdsNearTuplesAlg(const BBTreePts<SPACEDIM,int>& myTree, const double *pos, int nbOfTuples, double eps,
  75                                                 DataArrayInt *c, DataArrayInt *cI)
  76 {
  77   for(int i=0;i<nbOfTuples;i++)
  78     {
  79       std::vector<int> intersectingElems;
  80       myTree.getElementsAroundPoint(pos+i*SPACEDIM,intersectingElems);
  81       std::vector<int> commonNodes;
  82       for(std::vector<int>::const_iterator it=intersectingElems.begin();it!=intersectingElems.end();it++)
  83         commonNodes.push_back(*it);
  84       cI->pushBackSilent(cI->back()+(int)commonNodes.size());
  85       c->insertAtTheEnd(commonNodes.begin(),commonNodes.end());
  86     }
  87 }
  88
  89 template<int SPACEDIM>
  90 void DataArrayDouble::FindClosestTupleIdAlg(const BBTreePts<SPACEDIM,int>& myTree, double dist, const double *pos, int nbOfTuples, const double *thisPt, int thisNbOfTuples, int *res)
  91 {
  92   double distOpt(dist);
  93   const double *p(pos);
  94   int *r(res);
  95   for(int i=0;i<nbOfTuples;i++,p+=SPACEDIM,r++)
  96     {
  97       while(true)
  98         {
  99           int elem=-1;
 100           double ret=myTree.getElementsAroundPoint2(p,distOpt,elem);
 101           if(ret!=std::numeric_limits<double>::max())
 102             {
 103               distOpt=std::max(ret,1e-4);
 104               *r=elem;
 105               break;
 106             }
 107           else
 108             { distOpt=2*distOpt; continue; }
 109         }
 110     }
 111 }
 112
 113 std::size_t DataArray::getHeapMemorySizeWithoutChildren() const
 114 {
 115   std::size_t sz1=_name.capacity();
 116   std::size_t sz2=_info_on_compo.capacity();
 117   std::size_t sz3=0;
 118   for(std::vector<std::string>::const_iterator it=_info_on_compo.begin();it!=_info_on_compo.end();it++)
 119     sz3+=(*it).capacity();
 120   return sz1+sz2+sz3;
 121 }
 122
 123 std::vector<const BigMemoryObject *> DataArray::getDirectChildrenWithNull() const
 124 {
 125   return std::vector<const BigMemoryObject *>();
 126 }
 127
 128 /*!
 129  * Sets the attribute \a _name of \a this array.
 130  * See \ref MEDCouplingArrayBasicsName "DataArrays infos" for more information.
 131  *  \param [in] name - new array name
 132  */
 133 void DataArray::setName(const std::string& name)
 134 {
 135   _name=name;
 136 }
 137
 138 /*!
 139  * Copies textual data from an \a other DataArray. The copied data are
 140  * - the name attribute,
 141  * - the information of components.
 142  *
 143  * For more information on these data see \ref MEDCouplingArrayBasicsName "DataArrays infos".
 144  *
 145  *  \param [in] other - another instance of DataArray to copy the textual data from.
 146  *  \throw If number of components of \a this array differs from that of the \a other.
 147  */
 148 void DataArray::copyStringInfoFrom(const DataArray& other)
 149 {
 150   if(_info_on_compo.size()!=other._info_on_compo.size())
 151     throw INTERP_KERNEL::Exception("Size of arrays mismatches on copyStringInfoFrom !");
 152   _name=other._name;
 153   _info_on_compo=other._info_on_compo;
 154 }
 155
 156 void DataArray::copyPartOfStringInfoFrom(const DataArray& other, const std::vector<int>& compoIds)
 157 {
 158   int nbOfCompoOth=other.getNumberOfComponents();
 159   std::size_t newNbOfCompo=compoIds.size();
 160   for(std::size_t i=0;i<newNbOfCompo;i++)
 161     if(compoIds[i]>=nbOfCompoOth || compoIds[i]<0)
 162       {
 163         std::ostringstream oss; oss << "Specified component id is out of range (" << compoIds[i] << ") compared with nb of actual components (" << nbOfCompoOth << ")";
 164         throw INTERP_KERNEL::Exception(oss.str().c_str());
 165       }
 166   for(std::size_t i=0;i<newNbOfCompo;i++)
 167     setInfoOnComponent((int)i,other.getInfoOnComponent(compoIds[i]));
 168 }
 169
 170 void DataArray::copyPartOfStringInfoFrom2(const std::vector<int>& compoIds, const DataArray& other)
 171 {
 172   int nbOfCompo=getNumberOfComponents();
 173   std::size_t partOfCompoToSet=compoIds.size();
 174   if((int)partOfCompoToSet!=other.getNumberOfComponents())
 175     throw INTERP_KERNEL::Exception("Given compoIds has not the same size as number of components of given array !");
 176   for(std::size_t i=0;i<partOfCompoToSet;i++)
 177     if(compoIds[i]>=nbOfCompo || compoIds[i]<0)
 178       {
 179         std::ostringstream oss; oss << "Specified component id is out of range (" << compoIds[i] << ") compared with nb of actual components (" << nbOfCompo << ")";
 180         throw INTERP_KERNEL::Exception(oss.str().c_str());
 181       }
 182   for(std::size_t i=0;i<partOfCompoToSet;i++)
 183     setInfoOnComponent(compoIds[i],other.getInfoOnComponent((int)i));
 184 }
 185
 186 bool DataArray::areInfoEqualsIfNotWhy(const DataArray& other, std::string& reason) const
 187 {
 188   std::ostringstream oss;
 189   if(_name!=other._name)
 190     {
 191       oss << "Names DataArray mismatch : this name=\"" << _name << " other name=\"" << other._name << "\" !";
 192       reason=oss.str();
 193       return false;
 194     }
 195   if(_info_on_compo!=other._info_on_compo)
 196     {
 197       oss << "Components DataArray mismatch : \nThis components=";
 198       for(std::vector<std::string>::const_iterator it=_info_on_compo.begin();it!=_info_on_compo.end();it++)
 199         oss << "\"" << *it << "\",";
 200       oss << "\nOther components=";
 201       for(std::vector<std::string>::const_iterator it=other._info_on_compo.begin();it!=other._info_on_compo.end();it++)
 202         oss << "\"" << *it << "\",";
 203       reason=oss.str();
 204       return false;
 205     }
 206   return true;
 207 }
 208
 209 /*!
 210  * Compares textual information of \a this DataArray with that of an \a other one.
 211  * The compared data are
 212  * - the name attribute,
 213  * - the information of components.
 214  *
 215  * For more information on these data see \ref MEDCouplingArrayBasicsName "DataArrays infos".
 216  *  \param [in] other - another instance of DataArray to compare the textual data of.
 217  *  \return bool - \a true if the textual information is same, \a false else.
 218  */
 219 bool DataArray::areInfoEquals(const DataArray& other) const
 220 {
 221   std::string tmp;
 222   return areInfoEqualsIfNotWhy(other,tmp);
 223 }
 224
 225 void DataArray::reprWithoutNameStream(std::ostream& stream) const
 226 {
 227   stream << "Number of components : "<< getNumberOfComponents() << "\n";
 228   stream << "Info of these components : ";
 229   for(std::vector<std::string>::const_iterator iter=_info_on_compo.begin();iter!=_info_on_compo.end();iter++)
 230     stream << "\"" << *iter << "\"   ";
 231   stream << "\n";
 232 }
 233
 234 std::string DataArray::cppRepr(const std::string& varName) const
 235 {
 236   std::ostringstream ret;
 237   reprCppStream(varName,ret);
 238   return ret.str();
 239 }
 240
 241 /*!
 242  * Sets information on all components. To know more on format of this information
 243  * see \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
 244  *  \param [in] info - a vector of strings.
 245  *  \throw If size of \a info differs from the number of components of \a this.
 246  */
 247 void DataArray::setInfoOnComponents(const std::vector<std::string>& info)
 248 {
 249   if(getNumberOfComponents()!=(int)info.size())
 250     {
 251       std::ostringstream oss; oss << "DataArray::setInfoOnComponents : input is of size " << info.size() << " whereas number of components is equal to " << getNumberOfComponents() << " !";
 252       throw INTERP_KERNEL::Exception(oss.str().c_str());
 253     }
 254   _info_on_compo=info;
 255 }
 256
 257 /*!
 258  * This method is only a dispatcher towards DataArrayDouble::setPartOfValues3, DataArrayInt::setPartOfValues3, DataArrayChar::setPartOfValues3 depending on the true
 259  * type of \a this and \a aBase.
 260  *
 261  * \throw If \a aBase and \a this do not have the same type.
 262  *
 263  * \sa DataArrayDouble::setPartOfValues3, DataArrayInt::setPartOfValues3, DataArrayChar::setPartOfValues3.
 264  */
 265 void DataArray::setPartOfValuesBase3(const DataArray *aBase, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
 266 {
 267   if(!aBase)
 268     throw INTERP_KERNEL::Exception("DataArray::setPartOfValuesBase3 : input aBase object is NULL !");
 269   DataArrayDouble *this1(dynamic_cast<DataArrayDouble *>(this));
 270   DataArrayInt *this2(dynamic_cast<DataArrayInt *>(this));
 271   DataArrayChar *this3(dynamic_cast<DataArrayChar *>(this));
 272   const DataArrayDouble *a1(dynamic_cast<const DataArrayDouble *>(aBase));
 273   const DataArrayInt *a2(dynamic_cast<const DataArrayInt *>(aBase));
 274   const DataArrayChar *a3(dynamic_cast<const DataArrayChar *>(aBase));
 275   if(this1 && a1)
 276     {
 277       this1->setPartOfValues3(a1,bgTuples,endTuples,bgComp,endComp,stepComp,strictCompoCompare);
 278       return ;
 279     }
 280   if(this2 && a2)
 281     {
 282       this2->setPartOfValues3(a2,bgTuples,endTuples,bgComp,endComp,stepComp,strictCompoCompare);
 283       return ;
 284     }
 285   if(this3 && a3)
 286     {
 287       this3->setPartOfValues3(a3,bgTuples,endTuples,bgComp,endComp,stepComp,strictCompoCompare);
 288       return ;
 289     }
 290   throw INTERP_KERNEL::Exception("DataArray::setPartOfValuesBase3 : input aBase object and this do not have the same type !");
 291 }
 292
 293 std::vector<std::string> DataArray::getVarsOnComponent() const
 294 {
 295   int nbOfCompo=(int)_info_on_compo.size();
 296   std::vector<std::string> ret(nbOfCompo);
 297   for(int i=0;i<nbOfCompo;i++)
 298     ret[i]=getVarOnComponent(i);
 299   return ret;
 300 }
 301
 302 std::vector<std::string> DataArray::getUnitsOnComponent() const
 303 {
 304   int nbOfCompo=(int)_info_on_compo.size();
 305   std::vector<std::string> ret(nbOfCompo);
 306   for(int i=0;i<nbOfCompo;i++)
 307     ret[i]=getUnitOnComponent(i);
 308   return ret;
 309 }
 310
 311 /*!
 312  * Returns information on a component specified by an index.
 313  * To know more on format of this information
 314  * see \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
 315  *  \param [in] i - the index (zero based) of the component of interest.
 316  *  \return std::string - a string containing the information on \a i-th component.
 317  *  \throw If \a i is not a valid component index.
 318  */
 319 std::string DataArray::getInfoOnComponent(int i) const
 320 {
 321   if(i<(int)_info_on_compo.size() && i>=0)
 322     return _info_on_compo[i];
 323   else
 324     {
 325       std::ostringstream oss; oss << "DataArray::getInfoOnComponent : Specified component id is out of range (" << i << ") compared with nb of actual components (" << (int) _info_on_compo.size();
 326       throw INTERP_KERNEL::Exception(oss.str().c_str());
 327     }
 328 }
 329
 330 /*!
 331  * Returns the var part of the full information of the \a i-th component.
 332  * For example, if \c getInfoOnComponent(0) returns "SIGXY [N/m^2]", then
 333  * \c getVarOnComponent(0) returns "SIGXY".
 334  * If a unit part of information is not detected by presence of
 335  * two square brackets, then the full information is returned.
 336  * To read more about the component information format, see
 337  * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
 338  *  \param [in] i - the index (zero based) of the component of interest.
 339  *  \return std::string - a string containing the var information, or the full info.
 340  *  \throw If \a i is not a valid component index.
 341  */
 342 std::string DataArray::getVarOnComponent(int i) const
 343 {
 344   if(i<(int)_info_on_compo.size() && i>=0)
 345     {
 346       return GetVarNameFromInfo(_info_on_compo[i]);
 347     }
 348   else
 349     {
 350       std::ostringstream oss; oss << "DataArray::getVarOnComponent : Specified component id is out of range  (" << i << ") compared with nb of actual components (" << (int) _info_on_compo.size();
 351       throw INTERP_KERNEL::Exception(oss.str().c_str());
 352     }
 353 }
 354
 355 /*!
 356  * Returns the unit part of the full information of the \a i-th component.
 357  * For example, if \c getInfoOnComponent(0) returns "SIGXY [ N/m^2]", then
 358  * \c getUnitOnComponent(0) returns " N/m^2".
 359  * If a unit part of information is not detected by presence of
 360  * two square brackets, then an empty string is returned.
 361  * To read more about the component information format, see
 362  * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
 363  *  \param [in] i - the index (zero based) of the component of interest.
 364  *  \return std::string - a string containing the unit information, if any, or "".
 365  *  \throw If \a i is not a valid component index.
 366  */
 367 std::string DataArray::getUnitOnComponent(int i) const
 368 {
 369   if(i<(int)_info_on_compo.size() && i>=0)
 370     {
 371       return GetUnitFromInfo(_info_on_compo[i]);
 372     }
 373   else
 374     {
 375       std::ostringstream oss; oss << "DataArray::getUnitOnComponent : Specified component id is out of range  (" << i << ") compared with nb of actual components (" << (int) _info_on_compo.size();
 376       throw INTERP_KERNEL::Exception(oss.str().c_str());
 377     }
 378 }
 379
 380 /*!
 381  * Returns the var part of the full component information.
 382  * For example, if \a info == "SIGXY [N/m^2]", then this method returns "SIGXY".
 383  * If a unit part of information is not detected by presence of
 384  * two square brackets, then the whole \a info is returned.
 385  * To read more about the component information format, see
 386  * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
 387  *  \param [in] info - the full component information.
 388  *  \return std::string - a string containing only var information, or the \a info.
 389  */
 390 std::string DataArray::GetVarNameFromInfo(const std::string& info)
 391 {
 392   std::size_t p1=info.find_last_of('[');
 393   std::size_t p2=info.find_last_of(']');
 394   if(p1==std::string::npos || p2==std::string::npos)
 395     return info;
 396   if(p1>p2)
 397     return info;
 398   if(p1==0)
 399     return std::string();
 400   std::size_t p3=info.find_last_not_of(' ',p1-1);
 401   return info.substr(0,p3+1);
 402 }
 403
 404 /*!
 405  * Returns the unit part of the full component information.
 406  * For example, if \a info == "SIGXY [ N/m^2]", then this method returns " N/m^2".
 407  * If a unit part of information is not detected by presence of
 408  * two square brackets, then an empty string is returned.
 409  * To read more about the component information format, see
 410  * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
 411  *  \param [in] info - the full component information.
 412  *  \return std::string - a string containing only unit information, if any, or "".
 413  */
 414 std::string DataArray::GetUnitFromInfo(const std::string& info)
 415 {
 416   std::size_t p1=info.find_last_of('[');
 417   std::size_t p2=info.find_last_of(']');
 418   if(p1==std::string::npos || p2==std::string::npos)
 419     return std::string();
 420   if(p1>p2)
 421     return std::string();
 422   return info.substr(p1+1,p2-p1-1);
 423 }
 424
 425 /*!
 426  * This method put in info format the result of the merge of \a var and \a unit.
 427  * The standard format for that is "var [unit]".
 428  * Inversely you can retrieve the var part or the unit part of info string using resp. GetVarNameFromInfo and GetUnitFromInfo.
 429  */
 430 std::string DataArray::BuildInfoFromVarAndUnit(const std::string& var, const std::string& unit)
 431 {
 432   std::ostringstream oss;
 433   oss << var << " [" << unit << "]";
 434   return oss.str();
 435 }
 436
 437 /*!
 438  * Returns a new DataArray by concatenating all given arrays, so that (1) the number
 439  * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
 440  * the number of component in the result array is same as that of each of given arrays.
 441  * Info on components is copied from the first of the given arrays. Number of components
 442  * in the given arrays must be  the same.
 443  *  \param [in] arrs - a sequence of arrays to include in the result array. All arrays must have the same type.
 444  *  \return DataArray * - the new instance of DataArray (that can be either DataArrayInt, DataArrayDouble, DataArrayChar).
 445  *          The caller is to delete this result array using decrRef() as it is no more
 446  *          needed.
 447  *  \throw If all arrays within \a arrs are NULL.
 448  *  \throw If all not null arrays in \a arrs have not the same type.
 449  *  \throw If getNumberOfComponents() of arrays within \a arrs.
 450  */
 451 DataArray *DataArray::Aggregate(const std::vector<const DataArray *>& arrs)
 452 {
 453   std::vector<const DataArray *> arr2;
 454   for(std::vector<const DataArray *>::const_iterator it=arrs.begin();it!=arrs.end();it++)
 455     if(*it)
 456       arr2.push_back(*it);
 457   if(arr2.empty())
 458     throw INTERP_KERNEL::Exception("DataArray::Aggregate : only null instance in input vector !");
 459   std::vector<const DataArrayDouble *> arrd;
 460   std::vector<const DataArrayInt *> arri;
 461   std::vector<const DataArrayChar *> arrc;
 462   for(std::vector<const DataArray *>::const_iterator it=arr2.begin();it!=arr2.end();it++)
 463     {
 464       const DataArrayDouble *a=dynamic_cast<const DataArrayDouble *>(*it);
 465       if(a)
 466         { arrd.push_back(a); continue; }
 467       const DataArrayInt *b=dynamic_cast<const DataArrayInt *>(*it);
 468       if(b)
 469         { arri.push_back(b); continue; }
 470       const DataArrayChar *c=dynamic_cast<const DataArrayChar *>(*it);
 471       if(c)
 472         { arrc.push_back(c); continue; }
 473       throw INTERP_KERNEL::Exception("DataArray::Aggregate : presence of not null instance in inuput that is not in [DataArrayDouble, DataArrayInt, DataArrayChar] !");
 474     }
 475   if(arr2.size()==arrd.size())
 476     return DataArrayDouble::Aggregate(arrd);
 477   if(arr2.size()==arri.size())
 478     return DataArrayInt::Aggregate(arri);
 479   if(arr2.size()==arrc.size())
 480     return DataArrayChar::Aggregate(arrc);
 481   throw INTERP_KERNEL::Exception("DataArray::Aggregate : all input arrays must have the same type !");
 482 }
 483
 484 /*!
 485  * Sets information on a component specified by an index.
 486  * To know more on format of this information
 487  * see \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
 488  *  \warning Don't pass NULL as \a info!
 489  *  \param [in] i - the index (zero based) of the component of interest.
 490  *  \param [in] info - the string containing the information.
 491  *  \throw If \a i is not a valid component index.
 492  */
 493 void DataArray::setInfoOnComponent(int i, const std::string& info)
 494 {
 495   if(i<(int)_info_on_compo.size() && i>=0)
 496     _info_on_compo[i]=info;
 497   else
 498     {
 499       std::ostringstream oss; oss << "DataArray::setInfoOnComponent : Specified component id is out of range  (" << i << ") compared with nb of actual components (" << (int) _info_on_compo.size();
 500       throw INTERP_KERNEL::Exception(oss.str().c_str());
 501     }
 502 }
 503
 504 /*!
 505  * Sets information on all components. This method can change number of components
 506  * at certain conditions; if the conditions are not respected, an exception is thrown.
 507  * The number of components can be changed in \a this only if \a this is not allocated.
 508  * The condition of number of components must not be changed.
 509  *
 510  * To know more on format of the component information see
 511  * \ref MEDCouplingArrayBasicsCompoName "DataArrays infos".
 512  *  \param [in] info - a vector of component infos.
 513  *  \throw If \a this->getNumberOfComponents() != \a info.size() && \a this->isAllocated()
 514  */
 515 void DataArray::setInfoAndChangeNbOfCompo(const std::vector<std::string>& info)
 516 {
 517   if(getNumberOfComponents()!=(int)info.size())
 518     {
 519       if(!isAllocated())
 520         _info_on_compo=info;
 521       else
 522         {
 523           std::ostringstream oss; oss << "DataArray::setInfoAndChangeNbOfCompo : input is of size " << info.size() << " whereas number of components is equal to " << getNumberOfComponents() << "  and this is already allocated !";
 524           throw INTERP_KERNEL::Exception(oss.str().c_str());
 525         }
 526     }
 527   else
 528     _info_on_compo=info;
 529 }
 530
 531 void DataArray::checkNbOfTuples(int nbOfTuples, const std::string& msg) const
 532 {
 533   if(getNumberOfTuples()!=nbOfTuples)
 534     {
 535       std::ostringstream oss; oss << msg << " : mismatch number of tuples : expected " <<  nbOfTuples << " having " << getNumberOfTuples() << " !";
 536       throw INTERP_KERNEL::Exception(oss.str().c_str());
 537     }
 538 }
 539
 540 void DataArray::checkNbOfComps(int nbOfCompo, const std::string& msg) const
 541 {
 542   if(getNumberOfComponents()!=nbOfCompo)
 543     {
 544       std::ostringstream oss; oss << msg << " : mismatch number of components : expected " << nbOfCompo << " having " << getNumberOfComponents() << " !";
 545       throw INTERP_KERNEL::Exception(oss.str().c_str());
 546     }
 547 }
 548
 549 void DataArray::checkNbOfElems(std::size_t nbOfElems, const std::string& msg) const
 550 {
 551   if(getNbOfElems()!=nbOfElems)
 552     {
 553       std::ostringstream oss; oss << msg << " : mismatch number of elems : Expected " << nbOfElems << " having " << getNbOfElems() << " !";
 554       throw INTERP_KERNEL::Exception(oss.str().c_str());
 555     }
 556 }
 557
 558 void DataArray::checkNbOfTuplesAndComp(const DataArray& other, const std::string& msg) const
 559 {
 560   if(getNumberOfTuples()!=other.getNumberOfTuples())
 561     {
 562       std::ostringstream oss; oss << msg << " : mismatch number of tuples : expected " <<  other.getNumberOfTuples() << " having " << getNumberOfTuples() << " !";
 563       throw INTERP_KERNEL::Exception(oss.str().c_str());
 564     }
 565   if(getNumberOfComponents()!=other.getNumberOfComponents())
 566     {
 567       std::ostringstream oss; oss << msg << " : mismatch number of components : expected " << other.getNumberOfComponents() << " having " << getNumberOfComponents() << " !";
 568       throw INTERP_KERNEL::Exception(oss.str().c_str());
 569     }
 570 }
 571
 572 void DataArray::checkNbOfTuplesAndComp(int nbOfTuples, int nbOfCompo, const std::string& msg) const
 573 {
 574   checkNbOfTuples(nbOfTuples,msg);
 575   checkNbOfComps(nbOfCompo,msg);
 576 }
 577
 578 /*!
 579  * Simply this method checks that \b value is in [0,\b ref).
 580  */
 581 void DataArray::CheckValueInRange(int ref, int value, const std::string& msg)
 582 {
 583   if(value<0 || value>=ref)
 584     {
 585       std::ostringstream oss; oss << "DataArray::CheckValueInRange : " << msg  << " ! Expected in range [0," << ref << "[ having " << value << " !";
 586       throw INTERP_KERNEL::Exception(oss.str().c_str());
 587     }
 588 }
 589
 590 /*!
 591  * This method checks that [\b start, \b end) is compliant with ref length \b value.
 592  * typicaly start in [0,\b value) and end in [0,\b value). If value==start and start==end, it is supported.
 593  */
 594 void DataArray::CheckValueInRangeEx(int value, int start, int end, const std::string& msg)
 595 {
 596   if(start<0 || start>=value)
 597     {
 598       if(value!=start || end!=start)
 599         {
 600           std::ostringstream oss; oss << "DataArray::CheckValueInRangeEx : " << msg  << " ! Expected start " << start << " of input range, in [0," << value << "[ !";
 601           throw INTERP_KERNEL::Exception(oss.str().c_str());
 602         }
 603     }
 604   if(end<0 || end>value)
 605     {
 606       std::ostringstream oss; oss << "DataArray::CheckValueInRangeEx : " << msg  << " ! Expected end " << end << " of input range, in [0," << value << "] !";
 607       throw INTERP_KERNEL::Exception(oss.str().c_str());
 608     }
 609 }
 610
 611 void DataArray::CheckClosingParInRange(int ref, int value, const std::string& msg)
 612 {
 613   if(value<0 || value>ref)
 614     {
 615       std::ostringstream oss; oss << "DataArray::CheckClosingParInRange : " << msg  << " ! Expected input range in [0," << ref << "] having closing open parenthesis " << value << " !";
 616       throw INTERP_KERNEL::Exception(oss.str().c_str());
 617     }
 618 }
 619
 620 /*!
 621  * This method is useful to slice work among a pool of threads or processes. \a begin, \a end \a step is the input whole slice of work to perform,
 622  * typically it is a whole slice of tuples of DataArray or cells, nodes of a mesh...
 623  *
 624  * The input \a sliceId should be an id in [0, \a nbOfSlices) that specifies the slice of work.
 625  *
 626  * \param [in] start - the start of the input slice of the whole work to perform splitted into slices.
 627  * \param [in] stop - the stop of the input slice of the whole work to perform splitted into slices.
 628  * \param [in] step - the step (that can be <0) of the input slice of the whole work to perform splitted into slices.
 629  * \param [in] sliceId - the slice id considered
 630  * \param [in] nbOfSlices - the number of slices (typically the number of cores on which the work is expected to be sliced)
 631  * \param [out] startSlice - the start of the slice considered
 632  * \param [out] stopSlice - the stop of the slice consided
 633  *
 634  * \throw If \a step == 0
 635  * \throw If \a nbOfSlices not > 0
 636  * \throw If \a sliceId not in [0,nbOfSlices)
 637  */
 638 void DataArray::GetSlice(int start, int stop, int step, int sliceId, int nbOfSlices, int& startSlice, int& stopSlice)
 639 {
 640   if(nbOfSlices<=0)
 641     {
 642       std::ostringstream oss; oss << "DataArray::GetSlice : nbOfSlices (" << nbOfSlices << ") must be > 0 !";
 643       throw INTERP_KERNEL::Exception(oss.str().c_str());
 644     }
 645   if(sliceId<0 || sliceId>=nbOfSlices)
 646     {
 647       std::ostringstream oss; oss << "DataArray::GetSlice : sliceId (" << nbOfSlices << ") must be in [0 , nbOfSlices (" << nbOfSlices << ") ) !";
 648       throw INTERP_KERNEL::Exception(oss.str().c_str());
 649     }
 650   int nbElems=GetNumberOfItemGivenBESRelative(start,stop,step,"DataArray::GetSlice");
 651   int minNbOfElemsPerSlice=nbElems/nbOfSlices;
 652   startSlice=start+minNbOfElemsPerSlice*step*sliceId;
 653   if(sliceId<nbOfSlices-1)
 654     stopSlice=start+minNbOfElemsPerSlice*step*(sliceId+1);
 655   else
 656     stopSlice=stop;
 657 }
 658
 659 int DataArray::GetNumberOfItemGivenBES(int begin, int end, int step, const std::string& msg)
 660 {
 661   if(end<begin)
 662     {
 663       std::ostringstream oss; oss << msg << " : end before begin !";
 664       throw INTERP_KERNEL::Exception(oss.str().c_str());
 665     }
 666   if(end==begin)
 667     return 0;
 668   if(step<=0)
 669     {
 670       std::ostringstream oss; oss << msg << " : invalid step should be > 0 !";
 671       throw INTERP_KERNEL::Exception(oss.str().c_str());
 672     }
 673   return (end-1-begin)/step+1;
 674 }
 675
 676 int DataArray::GetNumberOfItemGivenBESRelative(int begin, int end, int step, const std::string& msg)
 677 {
 678   if(step==0)
 679     throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBES : step=0 is not allowed !");
 680   if(end<begin && step>0)
 681     {
 682       std::ostringstream oss; oss << msg << " : end before begin whereas step is positive !";
 683       throw INTERP_KERNEL::Exception(oss.str().c_str());
 684     }
 685   if(begin<end && step<0)
 686     {
 687       std::ostringstream oss; oss << msg << " : invalid step should be > 0 !";
 688       throw INTERP_KERNEL::Exception(oss.str().c_str());
 689     }
 690   if(begin!=end)
 691     return (std::max(begin,end)-1-std::min(begin,end))/std::abs(step)+1;
 692   else
 693     return 0;
 694 }
 695
 696 int DataArray::GetPosOfItemGivenBESRelativeNoThrow(int value, int begin, int end, int step)
 697 {
 698   if(step!=0)
 699     {
 700       if(step>0)
 701         {
 702           if(begin<=value && value<end)
 703             {
 704               if((value-begin)%step==0)
 705                 return (value-begin)/step;
 706               else
 707                 return -1;
 708             }
 709           else
 710             return -1;
 711         }
 712       else
 713         {
 714           if(begin>=value && value>end)
 715             {
 716               if((begin-value)%(-step)==0)
 717                 return (begin-value)/(-step);
 718               else
 719                 return -1;
 720             }
 721           else
 722             return -1;
 723         }
 724     }
 725   else
 726     return -1;
 727 }
 728
 729 /*!
 730  * Returns a new instance of DataArrayDouble. The caller is to delete this array
 731  * using decrRef() as it is no more needed.
 732  */
 733 DataArrayDouble *DataArrayDouble::New()
 734 {
 735   return new DataArrayDouble;
 736 }
 737
 738 /*!
 739  * Checks if raw data is allocated. Read more on the raw data
 740  * in \ref MEDCouplingArrayBasicsTuplesAndCompo "DataArrays infos" for more information.
 741  *  \return bool - \a true if the raw data is allocated, \a false else.
 742  */
 743 bool DataArrayDouble::isAllocated() const
 744 {
 745   return getConstPointer()!=0;
 746 }
 747
 748 /*!
 749  * Checks if raw data is allocated and throws an exception if it is not the case.
 750  *  \throw If the raw data is not allocated.
 751  */
 752 void DataArrayDouble::checkAllocated() const
 753 {
 754   if(!isAllocated())
 755     throw INTERP_KERNEL::Exception("DataArrayDouble::checkAllocated : Array is defined but not allocated ! Call alloc or setValues method first !");
 756 }
 757
 758 /*!
 759  * This method desallocated \a this without modification of informations relative to the components.
 760  * After call of this method, DataArrayDouble::isAllocated will return false.
 761  * If \a this is already not allocated, \a this is let unchanged.
 762  */
 763 void DataArrayDouble::desallocate()
 764 {
 765   _mem.destroy();
 766 }
 767
 768 std::size_t DataArrayDouble::getHeapMemorySizeWithoutChildren() const
 769 {
 770   std::size_t sz(_mem.getNbOfElemAllocated());
 771   sz*=sizeof(double);
 772   return DataArray::getHeapMemorySizeWithoutChildren()+sz;
 773 }
 774
 775 /*!
 776  * Returns the only one value in \a this, if and only if number of elements
 777  * (nb of tuples * nb of components) is equal to 1, and that \a this is allocated.
 778  *  \return double - the sole value stored in \a this array.
 779  *  \throw If at least one of conditions stated above is not fulfilled.
 780  */
 781 double DataArrayDouble::doubleValue() const
 782 {
 783   if(isAllocated())
 784     {
 785       if(getNbOfElems()==1)
 786         {
 787           return *getConstPointer();
 788         }
 789       else
 790         throw INTERP_KERNEL::Exception("DataArrayDouble::doubleValue : DataArrayDouble instance is allocated but number of elements is not equal to 1 !");
 791     }
 792   else
 793     throw INTERP_KERNEL::Exception("DataArrayDouble::doubleValue : DataArrayDouble instance is not allocated !");
 794 }
 795
 796 /*!
 797  * Checks the number of tuples.
 798  *  \return bool - \a true if getNumberOfTuples() == 0, \a false else.
 799  *  \throw If \a this is not allocated.
 800  */
 801 bool DataArrayDouble::empty() const
 802 {
 803   checkAllocated();
 804   return getNumberOfTuples()==0;
 805 }
 806
 807 /*!
 808  * Returns a full copy of \a this. For more info on copying data arrays see
 809  * \ref MEDCouplingArrayBasicsCopyDeep.
 810  *  \return DataArrayDouble * - a new instance of DataArrayDouble. The caller is to
 811  *          delete this array using decrRef() as it is no more needed.
 812  */
 813 DataArrayDouble *DataArrayDouble::deepCpy() const
 814 {
 815   return new DataArrayDouble(*this);
 816 }
 817
 818 /*!
 819  * Returns either a \a deep or \a shallow copy of this array. For more info see
 820  * \ref MEDCouplingArrayBasicsCopyDeep and \ref MEDCouplingArrayBasicsCopyShallow.
 821  *  \param [in] dCpy - if \a true, a deep copy is returned, else, a shallow one.
 822  *  \return DataArrayDouble * - either a new instance of DataArrayDouble (if \a dCpy
 823  *          == \a true) or \a this instance (if \a dCpy == \a false).
 824  */
 825 DataArrayDouble *DataArrayDouble::performCpy(bool dCpy) const
 826 {
 827   if(dCpy)
 828     return deepCpy();
 829   else
 830     {
 831       incrRef();
 832       return const_cast<DataArrayDouble *>(this);
 833     }
 834 }
 835
 836 /*!
 837  * Copies all the data from another DataArrayDouble. For more info see
 838  * \ref MEDCouplingArrayBasicsCopyDeepAssign.
 839  *  \param [in] other - another instance of DataArrayDouble to copy data from.
 840  *  \throw If the \a other is not allocated.
 841  */
 842 void DataArrayDouble::cpyFrom(const DataArrayDouble& other)
 843 {
 844   other.checkAllocated();
 845   int nbOfTuples=other.getNumberOfTuples();
 846   int nbOfComp=other.getNumberOfComponents();
 847   allocIfNecessary(nbOfTuples,nbOfComp);
 848   std::size_t nbOfElems=(std::size_t)nbOfTuples*nbOfComp;
 849   double *pt=getPointer();
 850   const double *ptI=other.getConstPointer();
 851   for(std::size_t i=0;i<nbOfElems;i++)
 852     pt[i]=ptI[i];
 853   copyStringInfoFrom(other);
 854 }
 855
 856 /*!
 857  * This method reserve nbOfElems elements in memory ( nbOfElems*8 bytes ) \b without impacting the number of tuples in \a this.
 858  * If \a this has already been allocated, this method checks that \a this has only one component. If not an INTERP_KERNEL::Exception will be thrown.
 859  * If \a this has not already been allocated, number of components is set to one.
 860  * This method allows to reduce number of reallocations on invokation of DataArrayDouble::pushBackSilent and DataArrayDouble::pushBackValsSilent on \a this.
 861  *
 862  * \sa DataArrayDouble::pack, DataArrayDouble::pushBackSilent, DataArrayDouble::pushBackValsSilent
 863  */
 864 void DataArrayDouble::reserve(std::size_t nbOfElems)
 865 {
 866   int nbCompo=getNumberOfComponents();
 867   if(nbCompo==1)
 868     {
 869       _mem.reserve(nbOfElems);
 870     }
 871   else if(nbCompo==0)
 872     {
 873       _mem.reserve(nbOfElems);
 874       _info_on_compo.resize(1);
 875     }
 876   else
 877     throw INTERP_KERNEL::Exception("DataArrayDouble::reserve : not available for DataArrayDouble with number of components different than 1 !");
 878 }
 879
 880 /*!
 881  * This method adds at the end of \a this the single value \a val. This method do \b not update its time label to avoid useless incrementation
 882  * of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
 883  *
 884  * \param [in] val the value to be added in \a this
 885  * \throw If \a this has already been allocated with number of components different from one.
 886  * \sa DataArrayDouble::pushBackValsSilent
 887  */
 888 void DataArrayDouble::pushBackSilent(double val)
 889 {
 890   int nbCompo=getNumberOfComponents();
 891   if(nbCompo==1)
 892     _mem.pushBack(val);
 893   else if(nbCompo==0)
 894     {
 895       _info_on_compo.resize(1);
 896       _mem.pushBack(val);
 897     }
 898   else
 899     throw INTERP_KERNEL::Exception("DataArrayDouble::pushBackSilent : not available for DataArrayDouble with number of components different than 1 !");
 900 }
 901
 902 /*!
 903  * This method adds at the end of \a this a serie of values [\c valsBg,\c valsEnd). This method do \b not update its time label to avoid useless incrementation
 904  * of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
 905  *
 906  *  \param [in] valsBg - an array of values to push at the end of \this.
 907  *  \param [in] valsEnd - specifies the end of the array \a valsBg, so that
 908  *              the last value of \a valsBg is \a valsEnd[ -1 ].
 909  * \throw If \a this has already been allocated with number of components different from one.
 910  * \sa DataArrayDouble::pushBackSilent
 911  */
 912 void DataArrayDouble::pushBackValsSilent(const double *valsBg, const double *valsEnd)
 913 {
 914   int nbCompo=getNumberOfComponents();
 915   if(nbCompo==1)
 916     _mem.insertAtTheEnd(valsBg,valsEnd);
 917   else if(nbCompo==0)
 918     {
 919       _info_on_compo.resize(1);
 920       _mem.insertAtTheEnd(valsBg,valsEnd);
 921     }
 922   else
 923     throw INTERP_KERNEL::Exception("DataArrayDouble::pushBackValsSilent : not available for DataArrayDouble with number of components different than 1 !");
 924 }
 925
 926 /*!
 927  * This method returns silently ( without updating time label in \a this ) the last value, if any and suppress it.
 928  * \throw If \a this is already empty.
 929  * \throw If \a this has number of components different from one.
 930  */
 931 double DataArrayDouble::popBackSilent()
 932 {
 933   if(getNumberOfComponents()==1)
 934     return _mem.popBack();
 935   else
 936     throw INTERP_KERNEL::Exception("DataArrayDouble::popBackSilent : not available for DataArrayDouble with number of components different than 1 !");
 937 }
 938
 939 /*!
 940  * This method \b do \b not modify content of \a this. It only modify its memory footprint if the allocated memory is to high regarding real data to store.
 941  *
 942  * \sa DataArrayDouble::getHeapMemorySizeWithoutChildren, DataArrayDouble::reserve
 943  */
 944 void DataArrayDouble::pack() const
 945 {
 946   _mem.pack();
 947 }
 948
 949 /*!
 950  * Allocates the raw data in memory. If exactly same memory as needed already
 951  * allocated, it is not re-allocated.
 952  *  \param [in] nbOfTuple - number of tuples of data to allocate.
 953  *  \param [in] nbOfCompo - number of components of data to allocate.
 954  *  \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
 955  */
 956 void DataArrayDouble::allocIfNecessary(int nbOfTuple, int nbOfCompo)
 957 {
 958   if(isAllocated())
 959     {
 960       if(nbOfTuple!=getNumberOfTuples() || nbOfCompo!=getNumberOfComponents())
 961         alloc(nbOfTuple,nbOfCompo);
 962     }
 963   else
 964     alloc(nbOfTuple,nbOfCompo);
 965 }
 966
 967 /*!
 968  * Allocates the raw data in memory. If the memory was already allocated, then it is
 969  * freed and re-allocated. See an example of this method use
 970  * \ref MEDCouplingArraySteps1WC "here".
 971  *  \param [in] nbOfTuple - number of tuples of data to allocate.
 972  *  \param [in] nbOfCompo - number of components of data to allocate.
 973  *  \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
 974  */
 975 void DataArrayDouble::alloc(int nbOfTuple, int nbOfCompo)
 976 {
 977   if(nbOfTuple<0 || nbOfCompo<0)
 978     throw INTERP_KERNEL::Exception("DataArrayDouble::alloc : request for negative length of data !");
 979   _info_on_compo.resize(nbOfCompo);
 980   _mem.alloc(nbOfCompo*(std::size_t)nbOfTuple);
 981   declareAsNew();
 982 }
 983
 984 /*!
 985  * Assign zero to all values in \a this array. To know more on filling arrays see
 986  * \ref MEDCouplingArrayFill.
 987  * \throw If \a this is not allocated.
 988  */
 989 void DataArrayDouble::fillWithZero()
 990 {
 991   checkAllocated();
 992   _mem.fillWithValue(0.);
 993   declareAsNew();
 994 }
 995
 996 /*!
 997  * Assign \a val to all values in \a this array. To know more on filling arrays see
 998  * \ref MEDCouplingArrayFill.
 999  *  \param [in] val - the value to fill with.
1000  *  \throw If \a this is not allocated.
1001  */
1002 void DataArrayDouble::fillWithValue(double val)
1003 {
1004   checkAllocated();
1005   _mem.fillWithValue(val);
1006   declareAsNew();
1007 }
1008
1009 /*!
1010  * Set all values in \a this array so that the i-th element equals to \a init + i
1011  * (i starts from zero). To know more on filling arrays see \ref MEDCouplingArrayFill.
1012  *  \param [in] init - value to assign to the first element of array.
1013  *  \throw If \a this->getNumberOfComponents() != 1
1014  *  \throw If \a this is not allocated.
1015  */
1016 void DataArrayDouble::iota(double init)
1017 {
1018   checkAllocated();
1019   if(getNumberOfComponents()!=1)
1020     throw INTERP_KERNEL::Exception("DataArrayDouble::iota : works only for arrays with only one component, you can call 'rearrange' method before !");
1021   double *ptr=getPointer();
1022   int ntuples=getNumberOfTuples();
1023   for(int i=0;i<ntuples;i++)
1024     ptr[i]=init+double(i);
1025   declareAsNew();
1026 }
1027
1028 /*!
1029  * Checks if all values in \a this array are equal to \a val at precision \a eps.
1030  *  \param [in] val - value to check equality of array values to.
1031  *  \param [in] eps - precision to check the equality.
1032  *  \return bool - \a true if all values are in range (_val_ - _eps_; _val_ + _eps_),
1033  *                 \a false else.
1034  *  \throw If \a this->getNumberOfComponents() != 1
1035  *  \throw If \a this is not allocated.
1036  */
1037 bool DataArrayDouble::isUniform(double val, double eps) const
1038 {
1039   checkAllocated();
1040   if(getNumberOfComponents()!=1)
1041     throw INTERP_KERNEL::Exception("DataArrayDouble::isUniform : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
1042   int nbOfTuples=getNumberOfTuples();
1043   const double *w=getConstPointer();
1044   const double *end2=w+nbOfTuples;
1045   const double vmin=val-eps;
1046   const double vmax=val+eps;
1047   for(;w!=end2;w++)
1048     if(*w<vmin || *w>vmax)
1049       return false;
1050   return true;
1051 }
1052
1053 /*!
1054  * Sorts values of the array.
1055  *  \param [in] asc - \a true means ascending order, \a false, descending.
1056  *  \throw If \a this is not allocated.
1057  *  \throw If \a this->getNumberOfComponents() != 1.
1058  */
1059 void DataArrayDouble::sort(bool asc)
1060 {
1061   checkAllocated();
1062   if(getNumberOfComponents()!=1)
1063     throw INTERP_KERNEL::Exception("DataArrayDouble::sort : only supported with 'this' array with ONE component !");
1064   _mem.sort(asc);
1065   declareAsNew();
1066 }
1067
1068 /*!
1069  * Reverse the array values.
1070  *  \throw If \a this->getNumberOfComponents() < 1.
1071  *  \throw If \a this is not allocated.
1072  */
1073 void DataArrayDouble::reverse()
1074 {
1075   checkAllocated();
1076   _mem.reverse(getNumberOfComponents());
1077   declareAsNew();
1078 }
1079
1080 /*!
1081  * Checks that \a this array is consistently **increasing** or **decreasing** in value,
1082  * with at least absolute difference value of |\a eps| at each step.
1083  * If not an exception is thrown.
1084  *  \param [in] increasing - if \a true, the array values should be increasing.
1085  *  \param [in] eps - minimal absolute difference between the neighbor values at which
1086  *                    the values are considered different.
1087  *  \throw If sequence of values is not strictly monotonic in agreement with \a
1088  *         increasing arg.
1089  *  \throw If \a this->getNumberOfComponents() != 1.
1090  *  \throw If \a this is not allocated.
1091  */
1092 void DataArrayDouble::checkMonotonic(bool increasing, double eps) const
1093 {
1094   if(!isMonotonic(increasing,eps))
1095     {
1096       if (increasing)
1097         throw INTERP_KERNEL::Exception("DataArrayDouble::checkMonotonic : 'this' is not INCREASING monotonic !");
1098       else
1099         throw INTERP_KERNEL::Exception("DataArrayDouble::checkMonotonic : 'this' is not DECREASING monotonic !");
1100     }
1101 }
1102
1103 /*!
1104  * Checks that \a this array is consistently **increasing** or **decreasing** in value,
1105  * with at least absolute difference value of |\a eps| at each step.
1106  *  \param [in] increasing - if \a true, array values should be increasing.
1107  *  \param [in] eps - minimal absolute difference between the neighbor values at which
1108  *                    the values are considered different.
1109  *  \return bool - \a true if values change in accordance with \a increasing arg.
1110  *  \throw If \a this->getNumberOfComponents() != 1.
1111  *  \throw If \a this is not allocated.
1112  */
1113 bool DataArrayDouble::isMonotonic(bool increasing, double eps) const
1114 {
1115   checkAllocated();
1116   if(getNumberOfComponents()!=1)
1117     throw INTERP_KERNEL::Exception("DataArrayDouble::isMonotonic : only supported with 'this' array with ONE component !");
1118   int nbOfElements=getNumberOfTuples();
1119   const double *ptr=getConstPointer();
1120   if(nbOfElements==0)
1121     return true;
1122   double ref=ptr[0];
1123   double absEps=fabs(eps);
1124   if(increasing)
1125     {
1126       for(int i=1;i<nbOfElements;i++)
1127         {
1128           if(ptr[i]<(ref+absEps))
1129             return false;
1130           ref=ptr[i];
1131         }
1132       return true;
1133     }
1134   else
1135     {
1136       for(int i=1;i<nbOfElements;i++)
1137         {
1138           if(ptr[i]>(ref-absEps))
1139             return false;
1140           ref=ptr[i];
1141         }
1142       return true;
1143     }
1144 }
1145
1146 /*!
1147  * Returns a textual and human readable representation of \a this instance of
1148  * DataArrayDouble. This text is shown when a DataArrayDouble is printed in Python.
1149  * \return std::string - text describing \a this DataArrayDouble.
1150  *
1151  * \sa reprNotTooLong, reprZip
1152  */
1153 std::string DataArrayDouble::repr() const
1154 {
1155   std::ostringstream ret;
1156   reprStream(ret);
1157   return ret.str();
1158 }
1159
1160 std::string DataArrayDouble::reprZip() const
1161 {
1162   std::ostringstream ret;
1163   reprZipStream(ret);
1164   return ret.str();
1165 }
1166
1167 /*!
1168  * This method is close to repr method except that when \a this has more than 1000 tuples, all tuples are not
1169  * printed out to avoid to consume too much space in interpretor.
1170  * \sa repr
1171  */
1172 std::string DataArrayDouble::reprNotTooLong() const
1173 {
1174   std::ostringstream ret;
1175   reprNotTooLongStream(ret);
1176   return ret.str();
1177 }
1178
1179 void DataArrayDouble::writeVTK(std::ostream& ofs, int indent, const std::string& nameInFile, DataArrayByte *byteArr) const
1180 {
1181   static const char SPACE[4]={' ',' ',' ',' '};
1182   checkAllocated();
1183   std::string idt(indent,' ');
1184   ofs.precision(17);
1185   ofs << idt << "<DataArray type=\"Float32\" Name=\"" << nameInFile << "\" NumberOfComponents=\"" << getNumberOfComponents() << "\"";
1186   //
1187   bool areAllEmpty(true);
1188   for(std::vector<std::string>::const_iterator it=_info_on_compo.begin();it!=_info_on_compo.end();it++)
1189     if(!(*it).empty())
1190       areAllEmpty=false;
1191   if(!areAllEmpty)
1192     for(std::size_t i=0;i<_info_on_compo.size();i++)
1193       ofs << " ComponentName" << i << "=\"" << _info_on_compo[i] << "\"";
1194   //
1195   if(byteArr)
1196     {
1197       ofs << " format=\"appended\" offset=\"" << byteArr->getNumberOfTuples() << "\">";
1198       INTERP_KERNEL::AutoPtr<float> tmp(new float[getNbOfElems()]);
1199       float *pt(tmp);
1200       // to make Visual C++ happy : instead of std::copy(begin(),end(),(float *)tmp);
1201       for(const double *src=begin();src!=end();src++,pt++)
1202         *pt=float(*src);
1203       const char *data(reinterpret_cast<const char *>((float *)tmp));
1204       std::size_t sz(getNbOfElems()*sizeof(float));
1205       byteArr->insertAtTheEnd(data,data+sz);
1206       byteArr->insertAtTheEnd(SPACE,SPACE+4);
1207     }
1208   else
1209     {
1210       ofs << " RangeMin=\"" << getMinValueInArray() << "\" RangeMax=\"" << getMaxValueInArray() << "\" format=\"ascii\">\n" << idt;
1211       std::copy(begin(),end(),std::ostream_iterator<double>(ofs," "));
1212     }
1213   ofs << std::endl << idt << "</DataArray>\n";
1214 }
1215
1216 void DataArrayDouble::reprStream(std::ostream& stream) const
1217 {
1218   stream << "Name of double array : \"" << _name << "\"\n";
1219   reprWithoutNameStream(stream);
1220 }
1221
1222 void DataArrayDouble::reprZipStream(std::ostream& stream) const
1223 {
1224   stream << "Name of double array : \"" << _name << "\"\n";
1225   reprZipWithoutNameStream(stream);
1226 }
1227
1228 void DataArrayDouble::reprNotTooLongStream(std::ostream& stream) const
1229 {
1230   stream << "Name of double array : \"" << _name << "\"\n";
1231   reprNotTooLongWithoutNameStream(stream);
1232 }
1233
1234 void DataArrayDouble::reprWithoutNameStream(std::ostream& stream) const
1235 {
1236   DataArray::reprWithoutNameStream(stream);
1237   stream.precision(17);
1238   _mem.repr(getNumberOfComponents(),stream);
1239 }
1240
1241 void DataArrayDouble::reprZipWithoutNameStream(std::ostream& stream) const
1242 {
1243   DataArray::reprWithoutNameStream(stream);
1244   stream.precision(17);
1245   _mem.reprZip(getNumberOfComponents(),stream);
1246 }
1247
1248 void DataArrayDouble::reprNotTooLongWithoutNameStream(std::ostream& stream) const
1249 {
1250   DataArray::reprWithoutNameStream(stream);
1251   stream.precision(17);
1252   _mem.reprNotTooLong(getNumberOfComponents(),stream);
1253 }
1254
1255 void DataArrayDouble::reprCppStream(const std::string& varName, std::ostream& stream) const
1256 {
1257   int nbTuples=getNumberOfTuples(),nbComp=getNumberOfComponents();
1258   const double *data=getConstPointer();
1259   stream.precision(17);
1260   stream << "DataArrayDouble *" << varName << "=DataArrayDouble::New();" << std::endl;
1261   if(nbTuples*nbComp>=1)
1262     {
1263       stream << "const double " << varName << "Data[" << nbTuples*nbComp << "]={";
1264       std::copy(data,data+nbTuples*nbComp-1,std::ostream_iterator<double>(stream,","));
1265       stream << data[nbTuples*nbComp-1] << "};" << std::endl;
1266       stream << varName << "->useArray(" << varName << "Data,false,CPP_DEALLOC," << nbTuples << "," << nbComp << ");" << std::endl;
1267     }
1268   else
1269     stream << varName << "->alloc(" << nbTuples << "," << nbComp << ");" << std::endl;
1270   stream << varName << "->setName(\"" << getName() << "\");" << std::endl;
1271 }
1272
1273 /*!
1274  * Method that gives a quick overvien of \a this for python.
1275  */
1276 void DataArrayDouble::reprQuickOverview(std::ostream& stream) const
1277 {
1278   static const std::size_t MAX_NB_OF_BYTE_IN_REPR=300;
1279   stream << "DataArrayDouble C++ instance at " << this << ". ";
1280   if(isAllocated())
1281     {
1282       int nbOfCompo=(int)_info_on_compo.size();
1283       if(nbOfCompo>=1)
1284         {
1285           int nbOfTuples=getNumberOfTuples();
1286           stream << "Number of tuples : " << nbOfTuples << ". Number of components : " << nbOfCompo << "." << std::endl;
1287           reprQuickOverviewData(stream,MAX_NB_OF_BYTE_IN_REPR);
1288         }
1289       else
1290         stream << "Number of components : 0.";
1291     }
1292   else
1293     stream << "*** No data allocated ****";
1294 }
1295
1296 void DataArrayDouble::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const
1297 {
1298   const double *data=begin();
1299   int nbOfTuples=getNumberOfTuples();
1300   int nbOfCompo=(int)_info_on_compo.size();
1301   std::ostringstream oss2; oss2 << "[";
1302   oss2.precision(17);
1303   std::string oss2Str(oss2.str());
1304   bool isFinished=true;
1305   for(int i=0;i<nbOfTuples && isFinished;i++)
1306     {
1307       if(nbOfCompo>1)
1308         {
1309           oss2 << "(";
1310           for(int j=0;j<nbOfCompo;j++,data++)
1311             {
1312               oss2 << *data;
1313               if(j!=nbOfCompo-1) oss2 << ", ";
1314             }
1315           oss2 << ")";
1316         }
1317       else
1318         oss2 << *data++;
1319       if(i!=nbOfTuples-1) oss2 << ", ";
1320       std::string oss3Str(oss2.str());
1321       if(oss3Str.length()<maxNbOfByteInRepr)
1322         oss2Str=oss3Str;
1323       else
1324         isFinished=false;
1325     }
1326   stream << oss2Str;
1327   if(!isFinished)
1328     stream << "... ";
1329   stream << "]";
1330 }
1331
1332 /*!
1333  * Equivalent to DataArrayDouble::isEqual except that if false the reason of
1334  * mismatch is given.
1335  *
1336  * \param [in] other the instance to be compared with \a this
1337  * \param [in] prec the precision to compare numeric data of the arrays.
1338  * \param [out] reason In case of inequality returns the reason.
1339  * \sa DataArrayDouble::isEqual
1340  */
1341 bool DataArrayDouble::isEqualIfNotWhy(const DataArrayDouble& other, double prec, std::string& reason) const
1342 {
1343   if(!areInfoEqualsIfNotWhy(other,reason))
1344     return false;
1345   return _mem.isEqual(other._mem,prec,reason);
1346 }
1347
1348 /*!
1349  * Checks if \a this and another DataArrayDouble are fully equal. For more info see
1350  * \ref MEDCouplingArrayBasicsCompare.
1351  *  \param [in] other - an instance of DataArrayDouble to compare with \a this one.
1352  *  \param [in] prec - precision value to compare numeric data of the arrays.
1353  *  \return bool - \a true if the two arrays are equal, \a false else.
1354  */
1355 bool DataArrayDouble::isEqual(const DataArrayDouble& other, double prec) const
1356 {
1357   std::string tmp;
1358   return isEqualIfNotWhy(other,prec,tmp);
1359 }
1360
1361 /*!
1362  * Checks if values of \a this and another DataArrayDouble are equal. For more info see
1363  * \ref MEDCouplingArrayBasicsCompare.
1364  *  \param [in] other - an instance of DataArrayDouble to compare with \a this one.
1365  *  \param [in] prec - precision value to compare numeric data of the arrays.
1366  *  \return bool - \a true if the values of two arrays are equal, \a false else.
1367  */
1368 bool DataArrayDouble::isEqualWithoutConsideringStr(const DataArrayDouble& other, double prec) const
1369 {
1370   std::string tmp;
1371   return _mem.isEqual(other._mem,prec,tmp);
1372 }
1373
1374 /*!
1375  * Changes number of tuples in the array. If the new number of tuples is smaller
1376  * than the current number the array is truncated, otherwise the array is extended.
1377  *  \param [in] nbOfTuples - new number of tuples.
1378  *  \throw If \a this is not allocated.
1379  *  \throw If \a nbOfTuples is negative.
1380  */
1381 void DataArrayDouble::reAlloc(int nbOfTuples)
1382 {
1383   if(nbOfTuples<0)
1384     throw INTERP_KERNEL::Exception("DataArrayDouble::reAlloc : input new number of tuples should be >=0 !");
1385   checkAllocated();
1386   _mem.reAlloc(getNumberOfComponents()*(std::size_t)nbOfTuples);
1387   declareAsNew();
1388 }
1389
1390 /*!
1391  * Creates a new DataArrayInt and assigns all (textual and numerical) data of \a this
1392  * array to the new one.
1393  *  \return DataArrayInt * - the new instance of DataArrayInt.
1394  */
1395 DataArrayInt *DataArrayDouble::convertToIntArr() const
1396 {
1397   DataArrayInt *ret=DataArrayInt::New();
1398   ret->alloc(getNumberOfTuples(),getNumberOfComponents());
1399   int *dest=ret->getPointer();
1400   // to make Visual C++ happy : instead of std::size_t nbOfVals=getNbOfElems(); std::copy(src,src+nbOfVals,dest);
1401   for(const double *src=begin();src!=end();src++,dest++)
1402     *dest=(int)*src;
1403   ret->copyStringInfoFrom(*this);
1404   return ret;
1405 }
1406
1407 /*!
1408  * Returns a new DataArrayDouble holding the same values as \a this array but differently
1409  * arranged in memory. If \a this array holds 2 components of 3 values:
1410  * \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$, then the result array holds these values arranged
1411  * as follows: \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$.
1412  *  \warning Do not confuse this method with transpose()!
1413  *  \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1414  *          is to delete using decrRef() as it is no more needed.
1415  *  \throw If \a this is not allocated.
1416  */
1417 DataArrayDouble *DataArrayDouble::fromNoInterlace() const
1418 {
1419   if(_mem.isNull())
1420     throw INTERP_KERNEL::Exception("DataArrayDouble::fromNoInterlace : Not defined array !");
1421   double *tab=_mem.fromNoInterlace(getNumberOfComponents());
1422   DataArrayDouble *ret=DataArrayDouble::New();
1423   ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
1424   return ret;
1425 }
1426
1427 /*!
1428  * Returns a new DataArrayDouble holding the same values as \a this array but differently
1429  * arranged in memory. If \a this array holds 2 components of 3 values:
1430  * \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$, then the result array holds these values arranged
1431  * as follows: \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$.
1432  *  \warning Do not confuse this method with transpose()!
1433  *  \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1434  *          is to delete using decrRef() as it is no more needed.
1435  *  \throw If \a this is not allocated.
1436  */
1437 DataArrayDouble *DataArrayDouble::toNoInterlace() const
1438 {
1439   if(_mem.isNull())
1440     throw INTERP_KERNEL::Exception("DataArrayDouble::toNoInterlace : Not defined array !");
1441   double *tab=_mem.toNoInterlace(getNumberOfComponents());
1442   DataArrayDouble *ret=DataArrayDouble::New();
1443   ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
1444   return ret;
1445 }
1446
1447 /*!
1448  * Permutes values of \a this array as required by \a old2New array. The values are
1449  * permuted so that \c new[ \a old2New[ i ]] = \c old[ i ]. Number of tuples remains
1450  * the same as in \this one.
1451  * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
1452  * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1453  *  \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
1454  *     giving a new position for i-th old value.
1455  */
1456 void DataArrayDouble::renumberInPlace(const int *old2New)
1457 {
1458   checkAllocated();
1459   int nbTuples=getNumberOfTuples();
1460   int nbOfCompo=getNumberOfComponents();
1461   double *tmp=new double[nbTuples*nbOfCompo];
1462   const double *iptr=getConstPointer();
1463   for(int i=0;i<nbTuples;i++)
1464     {
1465       int v=old2New[i];
1466       if(v>=0 && v<nbTuples)
1467         std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),tmp+nbOfCompo*v);
1468       else
1469         {
1470           std::ostringstream oss; oss << "DataArrayDouble::renumberInPlace : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
1471           throw INTERP_KERNEL::Exception(oss.str().c_str());
1472         }
1473     }
1474   std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
1475   delete [] tmp;
1476   declareAsNew();
1477 }
1478
1479 /*!
1480  * Permutes values of \a this array as required by \a new2Old array. The values are
1481  * permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of tuples remains
1482  * the same as in \this one.
1483  * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1484  *  \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
1485  *     giving a previous position of i-th new value.
1486  *  \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1487  *          is to delete using decrRef() as it is no more needed.
1488  */
1489 void DataArrayDouble::renumberInPlaceR(const int *new2Old)
1490 {
1491   checkAllocated();
1492   int nbTuples=getNumberOfTuples();
1493   int nbOfCompo=getNumberOfComponents();
1494   double *tmp=new double[nbTuples*nbOfCompo];
1495   const double *iptr=getConstPointer();
1496   for(int i=0;i<nbTuples;i++)
1497     {
1498       int v=new2Old[i];
1499       if(v>=0 && v<nbTuples)
1500         std::copy(iptr+nbOfCompo*v,iptr+nbOfCompo*(v+1),tmp+nbOfCompo*i);
1501       else
1502         {
1503           std::ostringstream oss; oss << "DataArrayDouble::renumberInPlaceR : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
1504           throw INTERP_KERNEL::Exception(oss.str().c_str());
1505         }
1506     }
1507   std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
1508   delete [] tmp;
1509   declareAsNew();
1510 }
1511
1512 /*!
1513  * Returns a copy of \a this array with values permuted as required by \a old2New array.
1514  * The values are permuted so that  \c new[ \a old2New[ i ]] = \c old[ i ].
1515  * Number of tuples in the result array remains the same as in \this one.
1516  * If a permutation reduction is needed, renumberAndReduce() should be used.
1517  * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1518  *  \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
1519  *          giving a new position for i-th old value.
1520  *  \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1521  *          is to delete using decrRef() as it is no more needed.
1522  *  \throw If \a this is not allocated.
1523  */
1524 DataArrayDouble *DataArrayDouble::renumber(const int *old2New) const
1525 {
1526   checkAllocated();
1527   int nbTuples=getNumberOfTuples();
1528   int nbOfCompo=getNumberOfComponents();
1529   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1530   ret->alloc(nbTuples,nbOfCompo);
1531   ret->copyStringInfoFrom(*this);
1532   const double *iptr=getConstPointer();
1533   double *optr=ret->getPointer();
1534   for(int i=0;i<nbTuples;i++)
1535     std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),optr+nbOfCompo*old2New[i]);
1536   ret->copyStringInfoFrom(*this);
1537   return ret.retn();
1538 }
1539
1540 /*!
1541  * Returns a copy of \a this array with values permuted as required by \a new2Old array.
1542  * The values are permuted so that  \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of
1543  * tuples in the result array remains the same as in \this one.
1544  * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
1545  * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1546  *  \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
1547  *     giving a previous position of i-th new value.
1548  *  \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1549  *          is to delete using decrRef() as it is no more needed.
1550  */
1551 DataArrayDouble *DataArrayDouble::renumberR(const int *new2Old) const
1552 {
1553   checkAllocated();
1554   int nbTuples=getNumberOfTuples();
1555   int nbOfCompo=getNumberOfComponents();
1556   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1557   ret->alloc(nbTuples,nbOfCompo);
1558   ret->copyStringInfoFrom(*this);
1559   const double *iptr=getConstPointer();
1560   double *optr=ret->getPointer();
1561   for(int i=0;i<nbTuples;i++)
1562     std::copy(iptr+nbOfCompo*new2Old[i],iptr+nbOfCompo*(new2Old[i]+1),optr+i*nbOfCompo);
1563   ret->copyStringInfoFrom(*this);
1564   return ret.retn();
1565 }
1566
1567 /*!
1568  * Returns a shorten and permuted copy of \a this array. The new DataArrayDouble is
1569  * of size \a newNbOfTuple and it's values are permuted as required by \a old2New array.
1570  * The values are permuted so that  \c new[ \a old2New[ i ]] = \c old[ i ] for all
1571  * \a old2New[ i ] >= 0. In other words every i-th tuple in \a this array, for which
1572  * \a old2New[ i ] is negative, is missing from the result array.
1573  * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1574  *  \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
1575  *     giving a new position for i-th old tuple and giving negative position for
1576  *     for i-th old tuple that should be omitted.
1577  *  \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1578  *          is to delete using decrRef() as it is no more needed.
1579  */
1580 DataArrayDouble *DataArrayDouble::renumberAndReduce(const int *old2New, int newNbOfTuple) const
1581 {
1582   checkAllocated();
1583   int nbTuples=getNumberOfTuples();
1584   int nbOfCompo=getNumberOfComponents();
1585   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1586   ret->alloc(newNbOfTuple,nbOfCompo);
1587   const double *iptr=getConstPointer();
1588   double *optr=ret->getPointer();
1589   for(int i=0;i<nbTuples;i++)
1590     {
1591       int w=old2New[i];
1592       if(w>=0)
1593         std::copy(iptr+i*nbOfCompo,iptr+(i+1)*nbOfCompo,optr+w*nbOfCompo);
1594     }
1595   ret->copyStringInfoFrom(*this);
1596   return ret.retn();
1597 }
1598
1599 /*!
1600  * Returns a shorten and permuted copy of \a this array. The new DataArrayDouble is
1601  * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
1602  * \a new2OldBg array.
1603  * The values are permuted so that  \c new[ i ] = \c old[ \a new2OldBg[ i ]].
1604  * This method is equivalent to renumberAndReduce() except that convention in input is
1605  * \c new2old and \b not \c old2new.
1606  * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1607  *  \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
1608  *              tuple index in \a this array to fill the i-th tuple in the new array.
1609  *  \param [in] new2OldEnd - specifies the end of the permutation array that starts at
1610  *              \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
1611  *              \a new2OldBg <= \a pi < \a new2OldEnd.
1612  *  \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1613  *          is to delete using decrRef() as it is no more needed.
1614  */
1615 DataArrayDouble *DataArrayDouble::selectByTupleId(const int *new2OldBg, const int *new2OldEnd) const
1616 {
1617   checkAllocated();
1618   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1619   int nbComp=getNumberOfComponents();
1620   ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
1621   ret->copyStringInfoFrom(*this);
1622   double *pt=ret->getPointer();
1623   const double *srcPt=getConstPointer();
1624   int i=0;
1625   for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
1626     std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
1627   ret->copyStringInfoFrom(*this);
1628   return ret.retn();
1629 }
1630
1631 /*!
1632  * Returns a shorten and permuted copy of \a this array. The new DataArrayDouble is
1633  * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
1634  * \a new2OldBg array.
1635  * The values are permuted so that  \c new[ i ] = \c old[ \a new2OldBg[ i ]].
1636  * This method is equivalent to renumberAndReduce() except that convention in input is
1637  * \c new2old and \b not \c old2new.
1638  * This method is equivalent to selectByTupleId() except that it prevents coping data
1639  * from behind the end of \a this array.
1640  * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1641  *  \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
1642  *              tuple index in \a this array to fill the i-th tuple in the new array.
1643  *  \param [in] new2OldEnd - specifies the end of the permutation array that starts at
1644  *              \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
1645  *              \a new2OldBg <= \a pi < \a new2OldEnd.
1646  *  \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1647  *          is to delete using decrRef() as it is no more needed.
1648  *  \throw If \a new2OldEnd - \a new2OldBg > \a this->getNumberOfTuples().
1649  */
1650 DataArrayDouble *DataArrayDouble::selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const
1651 {
1652   checkAllocated();
1653   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1654   int nbComp=getNumberOfComponents();
1655   int oldNbOfTuples=getNumberOfTuples();
1656   ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
1657   ret->copyStringInfoFrom(*this);
1658   double *pt=ret->getPointer();
1659   const double *srcPt=getConstPointer();
1660   int i=0;
1661   for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
1662     if(*w>=0 && *w<oldNbOfTuples)
1663       std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
1664     else
1665       throw INTERP_KERNEL::Exception("DataArrayDouble::selectByTupleIdSafe : some ids has been detected to be out of [0,this->getNumberOfTuples) !");
1666   ret->copyStringInfoFrom(*this);
1667   return ret.retn();
1668 }
1669
1670 /*!
1671  * Returns a shorten copy of \a this array. The new DataArrayDouble contains every
1672  * (\a bg + \c i * \a step)-th tuple of \a this array located before the \a end2-th
1673  * tuple. Indices of the selected tuples are the same as ones returned by the Python
1674  * command \c range( \a bg, \a end2, \a step ).
1675  * This method is equivalent to selectByTupleIdSafe() except that the input array is
1676  * not constructed explicitly.
1677  * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1678  *  \param [in] bg - index of the first tuple to copy from \a this array.
1679  *  \param [in] end2 - index of the tuple before which the tuples to copy are located.
1680  *  \param [in] step - index increment to get index of the next tuple to copy.
1681  *  \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1682  *          is to delete using decrRef() as it is no more needed.
1683  *  \sa DataArrayDouble::substr.
1684  */
1685 DataArrayDouble *DataArrayDouble::selectByTupleId2(int bg, int end2, int step) const
1686 {
1687   checkAllocated();
1688   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1689   int nbComp=getNumberOfComponents();
1690   int newNbOfTuples=GetNumberOfItemGivenBESRelative(bg,end2,step,"DataArrayDouble::selectByTupleId2 : ");
1691   ret->alloc(newNbOfTuples,nbComp);
1692   double *pt=ret->getPointer();
1693   const double *srcPt=getConstPointer()+bg*nbComp;
1694   for(int i=0;i<newNbOfTuples;i++,srcPt+=step*nbComp)
1695     std::copy(srcPt,srcPt+nbComp,pt+i*nbComp);
1696   ret->copyStringInfoFrom(*this);
1697   return ret.retn();
1698 }
1699
1700 /*!
1701  * Returns a shorten copy of \a this array. The new DataArrayDouble contains ranges
1702  * of tuples specified by \a ranges parameter.
1703  * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
1704  *  \param [in] ranges - std::vector of std::pair's each of which defines a range
1705  *              of tuples in [\c begin,\c end) format.
1706  *  \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1707  *          is to delete using decrRef() as it is no more needed.
1708  *  \throw If \a end < \a begin.
1709  *  \throw If \a end > \a this->getNumberOfTuples().
1710  *  \throw If \a this is not allocated.
1711  */
1712 DataArray *DataArrayDouble::selectByTupleRanges(const std::vector<std::pair<int,int> >& ranges) const
1713 {
1714   checkAllocated();
1715   int nbOfComp=getNumberOfComponents();
1716   int nbOfTuplesThis=getNumberOfTuples();
1717   if(ranges.empty())
1718     {
1719       DataArrayDouble *ret=DataArrayDouble::New();
1720       ret->alloc(0,nbOfComp);
1721       ret->copyStringInfoFrom(*this);
1722       return ret;
1723     }
1724   int ref=ranges.front().first;
1725   int nbOfTuples=0;
1726   bool isIncreasing=true;
1727   for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
1728     {
1729       if((*it).first<=(*it).second)
1730         {
1731           if((*it).first>=0 && (*it).second<=nbOfTuplesThis)
1732             {
1733               nbOfTuples+=(*it).second-(*it).first;
1734               if(isIncreasing)
1735                 isIncreasing=ref<=(*it).first;
1736               ref=(*it).second;
1737             }
1738           else
1739             {
1740               std::ostringstream oss; oss << "DataArrayDouble::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
1741               oss << " (" << (*it).first << "," << (*it).second << ") is greater than number of tuples of this :" << nbOfTuples << " !";
1742               throw INTERP_KERNEL::Exception(oss.str().c_str());
1743             }
1744         }
1745       else
1746         {
1747           std::ostringstream oss; oss << "DataArrayDouble::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
1748           oss << " (" << (*it).first << "," << (*it).second << ") end is before begin !";
1749           throw INTERP_KERNEL::Exception(oss.str().c_str());
1750         }
1751     }
1752   if(isIncreasing && nbOfTuplesThis==nbOfTuples)
1753     return deepCpy();
1754   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1755   ret->alloc(nbOfTuples,nbOfComp);
1756   ret->copyStringInfoFrom(*this);
1757   const double *src=getConstPointer();
1758   double *work=ret->getPointer();
1759   for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
1760     work=std::copy(src+(*it).first*nbOfComp,src+(*it).second*nbOfComp,work);
1761   return ret.retn();
1762 }
1763
1764 /*!
1765  * Returns a shorten copy of \a this array. The new DataArrayDouble contains all
1766  * tuples starting from the \a tupleIdBg-th tuple and including all tuples located before
1767  * the \a tupleIdEnd-th one. This methods has a similar behavior as std::string::substr().
1768  * This method is a specialization of selectByTupleId2().
1769  *  \param [in] tupleIdBg - index of the first tuple to copy from \a this array.
1770  *  \param [in] tupleIdEnd - index of the tuple before which the tuples to copy are located.
1771  *          If \a tupleIdEnd == -1, all the tuples till the end of \a this array are copied.
1772  *  \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1773  *          is to delete using decrRef() as it is no more needed.
1774  *  \throw If \a tupleIdBg < 0.
1775  *  \throw If \a tupleIdBg > \a this->getNumberOfTuples().
1776     \throw If \a tupleIdEnd != -1 && \a tupleIdEnd < \a this->getNumberOfTuples().
1777  *  \sa DataArrayDouble::selectByTupleId2
1778  */
1779 DataArrayDouble *DataArrayDouble::substr(int tupleIdBg, int tupleIdEnd) const
1780 {
1781   checkAllocated();
1782   int nbt=getNumberOfTuples();
1783   if(tupleIdBg<0)
1784     throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter must be greater than 0 !");
1785   if(tupleIdBg>nbt)
1786     throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter is greater than number of tuples !");
1787   int trueEnd=tupleIdEnd;
1788   if(tupleIdEnd!=-1)
1789     {
1790       if(tupleIdEnd>nbt)
1791         throw INTERP_KERNEL::Exception("DataArrayDouble::substr : The tupleIdBg parameter is greater or equal than number of tuples !");
1792     }
1793   else
1794     trueEnd=nbt;
1795   int nbComp=getNumberOfComponents();
1796   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1797   ret->alloc(trueEnd-tupleIdBg,nbComp);
1798   ret->copyStringInfoFrom(*this);
1799   std::copy(getConstPointer()+tupleIdBg*nbComp,getConstPointer()+trueEnd*nbComp,ret->getPointer());
1800   return ret.retn();
1801 }
1802
1803 /*!
1804  * Returns a shorten or extended copy of \a this array. If \a newNbOfComp is less
1805  * than \a this->getNumberOfComponents() then the result array is shorten as each tuple
1806  * is truncated to have \a newNbOfComp components, keeping first components. If \a
1807  * newNbOfComp is more than \a this->getNumberOfComponents() then the result array is
1808  * expanded as each tuple is populated with \a dftValue to have \a newNbOfComp
1809  * components.
1810  *  \param [in] newNbOfComp - number of components for the new array to have.
1811  *  \param [in] dftValue - value assigned to new values added to the new array.
1812  *  \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1813  *          is to delete using decrRef() as it is no more needed.
1814  *  \throw If \a this is not allocated.
1815  */
1816 DataArrayDouble *DataArrayDouble::changeNbOfComponents(int newNbOfComp, double dftValue) const
1817 {
1818   checkAllocated();
1819   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
1820   ret->alloc(getNumberOfTuples(),newNbOfComp);
1821   const double *oldc=getConstPointer();
1822   double *nc=ret->getPointer();
1823   int nbOfTuples=getNumberOfTuples();
1824   int oldNbOfComp=getNumberOfComponents();
1825   int dim=std::min(oldNbOfComp,newNbOfComp);
1826   for(int i=0;i<nbOfTuples;i++)
1827     {
1828       int j=0;
1829       for(;j<dim;j++)
1830         nc[newNbOfComp*i+j]=oldc[i*oldNbOfComp+j];
1831       for(;j<newNbOfComp;j++)
1832         nc[newNbOfComp*i+j]=dftValue;
1833     }
1834   ret->setName(getName());
1835   for(int i=0;i<dim;i++)
1836     ret->setInfoOnComponent(i,getInfoOnComponent(i));
1837   ret->setName(getName());
1838   return ret.retn();
1839 }
1840
1841 /*!
1842  * Changes the number of components within \a this array so that its raw data **does
1843  * not** change, instead splitting this data into tuples changes.
1844  *  \warning This method erases all (name and unit) component info set before!
1845  *  \param [in] newNbOfComp - number of components for \a this array to have.
1846  *  \throw If \a this is not allocated
1847  *  \throw If getNbOfElems() % \a newNbOfCompo != 0.
1848  *  \throw If \a newNbOfCompo is lower than 1.
1849  *  \throw If the rearrange method would lead to a number of tuples higher than 2147483647 (maximal capacity of int32 !).
1850  *  \warning This method erases all (name and unit) component info set before!
1851  */
1852 void DataArrayDouble::rearrange(int newNbOfCompo)
1853 {
1854   checkAllocated();
1855   if(newNbOfCompo<1)
1856     throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : input newNbOfCompo must be > 0 !");
1857   std::size_t nbOfElems=getNbOfElems();
1858   if(nbOfElems%newNbOfCompo!=0)
1859     throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : nbOfElems%newNbOfCompo!=0 !");
1860   if(nbOfElems/newNbOfCompo>(std::size_t)std::numeric_limits<int>::max())
1861     throw INTERP_KERNEL::Exception("DataArrayDouble::rearrange : the rearrangement leads to too high number of tuples (> 2147483647) !");
1862   _info_on_compo.clear();
1863   _info_on_compo.resize(newNbOfCompo);
1864   declareAsNew();
1865 }
1866
1867 /*!
1868  * Changes the number of components within \a this array to be equal to its number
1869  * of tuples, and inversely its number of tuples to become equal to its number of
1870  * components. So that its raw data **does not** change, instead splitting this
1871  * data into tuples changes.
1872  *  \warning This method erases all (name and unit) component info set before!
1873  *  \warning Do not confuse this method with fromNoInterlace() and toNoInterlace()!
1874  *  \throw If \a this is not allocated.
1875  *  \sa rearrange()
1876  */
1877 void DataArrayDouble::transpose()
1878 {
1879   checkAllocated();
1880   int nbOfTuples=getNumberOfTuples();
1881   rearrange(nbOfTuples);
1882 }
1883
1884 /*!
1885  * Returns a copy of \a this array composed of selected components.
1886  * The new DataArrayDouble has the same number of tuples but includes components
1887  * specified by \a compoIds parameter. So that getNbOfElems() of the result array
1888  * can be either less, same or more than \a this->getNbOfElems().
1889  *  \param [in] compoIds - sequence of zero based indices of components to include
1890  *              into the new array.
1891  *  \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
1892  *          is to delete using decrRef() as it is no more needed.
1893  *  \throw If \a this is not allocated.
1894  *  \throw If a component index (\a i) is not valid:
1895  *         \a i < 0 || \a i >= \a this->getNumberOfComponents().
1896  *
1897  *  \if ENABLE_EXAMPLES
1898  *  \ref py_mcdataarraydouble_KeepSelectedComponents "Here is a Python example".
1899  *  \endif
1900  */
1901 DataArrayDouble *DataArrayDouble::keepSelectedComponents(const std::vector<int>& compoIds) const
1902 {
1903   checkAllocated();
1904   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret(DataArrayDouble::New());
1905   std::size_t newNbOfCompo=compoIds.size();
1906   int oldNbOfCompo=getNumberOfComponents();
1907   for(std::vector<int>::const_iterator it=compoIds.begin();it!=compoIds.end();it++)
1908     if((*it)<0 || (*it)>=oldNbOfCompo)
1909       {
1910         std::ostringstream oss; oss << "DataArrayDouble::keepSelectedComponents : invalid requested component : " << *it << " whereas it should be in [0," << oldNbOfCompo << ") !";
1911         throw INTERP_KERNEL::Exception(oss.str().c_str());
1912       }
1913   int nbOfTuples=getNumberOfTuples();
1914   ret->alloc(nbOfTuples,(int)newNbOfCompo);
1915   ret->copyPartOfStringInfoFrom(*this,compoIds);
1916   const double *oldc=getConstPointer();
1917   double *nc=ret->getPointer();
1918   for(int i=0;i<nbOfTuples;i++)
1919     for(std::size_t j=0;j<newNbOfCompo;j++,nc++)
1920       *nc=oldc[i*oldNbOfCompo+compoIds[j]];
1921   return ret.retn();
1922 }
1923
1924 /*!
1925  * Appends components of another array to components of \a this one, tuple by tuple.
1926  * So that the number of tuples of \a this array remains the same and the number of
1927  * components increases.
1928  *  \param [in] other - the DataArrayDouble to append to \a this one.
1929  *  \throw If \a this is not allocated.
1930  *  \throw If \a this and \a other arrays have different number of tuples.
1931  *
1932  *  \if ENABLE_EXAMPLES
1933  *  \ref cpp_mcdataarraydouble_meldwith "Here is a C++ example".
1934  *
1935  *  \ref py_mcdataarraydouble_meldwith "Here is a Python example".
1936  *  \endif
1937  */
1938 void DataArrayDouble::meldWith(const DataArrayDouble *other)
1939 {
1940   checkAllocated();
1941   other->checkAllocated();
1942   int nbOfTuples=getNumberOfTuples();
1943   if(nbOfTuples!=other->getNumberOfTuples())
1944     throw INTERP_KERNEL::Exception("DataArrayDouble::meldWith : mismatch of number of tuples !");
1945   int nbOfComp1=getNumberOfComponents();
1946   int nbOfComp2=other->getNumberOfComponents();
1947   double *newArr=(double *)malloc((nbOfTuples*(nbOfComp1+nbOfComp2))*sizeof(double));
1948   double *w=newArr;
1949   const double *inp1=getConstPointer();
1950   const double *inp2=other->getConstPointer();
1951   for(int i=0;i<nbOfTuples;i++,inp1+=nbOfComp1,inp2+=nbOfComp2)
1952     {
1953       w=std::copy(inp1,inp1+nbOfComp1,w);
1954       w=std::copy(inp2,inp2+nbOfComp2,w);
1955     }
1956   useArray(newArr,true,C_DEALLOC,nbOfTuples,nbOfComp1+nbOfComp2);
1957   std::vector<int> compIds(nbOfComp2);
1958   for(int i=0;i<nbOfComp2;i++)
1959     compIds[i]=nbOfComp1+i;
1960   copyPartOfStringInfoFrom2(compIds,*other);
1961 }
1962
1963 /*!
1964  * This method checks that all tuples in \a other are in \a this.
1965  * If true, the output param \a tupleIds contains the tuples ids of \a this that correspond to tupes in \a this.
1966  * For each i in [ 0 , other->getNumberOfTuples() ) tuple #i in \a other is equal ( regarding input precision \a prec ) to tuple tupleIds[i] in \a this.
1967  *
1968  * \param [in] other - the array having the same number of components than \a this.
1969  * \param [out] tupleIds - the tuple ids containing the same number of tuples than \a other has.
1970  * \sa DataArrayDouble::findCommonTuples
1971  */
1972 bool DataArrayDouble::areIncludedInMe(const DataArrayDouble *other, double prec, DataArrayInt *&tupleIds) const
1973 {
1974   if(!other)
1975     throw INTERP_KERNEL::Exception("DataArrayDouble::areIncludedInMe : input array is NULL !");
1976   checkAllocated(); other->checkAllocated();
1977   if(getNumberOfComponents()!=other->getNumberOfComponents())
1978     throw INTERP_KERNEL::Exception("DataArrayDouble::areIncludedInMe : the number of components does not match !");
1979   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> a=DataArrayDouble::Aggregate(this,other);
1980   DataArrayInt *c=0,*ci=0;
1981   a->findCommonTuples(prec,getNumberOfTuples(),c,ci);
1982   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cSafe(c),ciSafe(ci);
1983   int newNbOfTuples=-1;
1984   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ids=DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(a->getNumberOfTuples(),c->begin(),ci->begin(),ci->end(),newNbOfTuples);
1985   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=ids->selectByTupleId2(getNumberOfTuples(),a->getNumberOfTuples(),1);
1986   tupleIds=ret1.retn();
1987   return newNbOfTuples==getNumberOfTuples();
1988 }
1989
1990 /*!
1991  * Searches for tuples coincident within \a prec tolerance. Each tuple is considered
1992  * as coordinates of a point in getNumberOfComponents()-dimensional space. The
1993  * distance separating two points is computed with the infinite norm.
1994  *
1995  * Indices of coincident tuples are stored in output arrays.
1996  * A pair of arrays (\a comm, \a commIndex) is called "Surjective Format 2".
1997  *
1998  * This method is typically used by MEDCouplingPointSet::findCommonNodes() and
1999  * MEDCouplingUMesh::mergeNodes().
2000  *  \param [in] prec - minimal absolute distance between two tuples (infinite norm) at which they are
2001  *              considered not coincident.
2002  *  \param [in] limitTupleId - limit tuple id. If all tuples within a group of coincident
2003  *              tuples have id strictly lower than \a limitTupleId then they are not returned.
2004  *  \param [out] comm - the array holding ids (== indices) of coincident tuples.
2005  *               \a comm->getNumberOfComponents() == 1.
2006  *               \a comm->getNumberOfTuples() == \a commIndex->back().
2007  *  \param [out] commIndex - the array dividing all indices stored in \a comm into
2008  *               groups of (indices of) coincident tuples. Its every value is a tuple
2009  *               index where a next group of tuples begins. For example the second
2010  *               group of tuples in \a comm is described by following range of indices:
2011  *               [ \a commIndex[1], \a commIndex[2] ). \a commIndex->getNumberOfTuples()-1
2012  *               gives the number of groups of coincident tuples.
2013  *  \throw If \a this is not allocated.
2014  *  \throw If the number of components is not in [1,2,3,4].
2015  *
2016  *  \if ENABLE_EXAMPLES
2017  *  \ref cpp_mcdataarraydouble_findcommontuples "Here is a C++ example".
2018  *
2019  *  \ref py_mcdataarraydouble_findcommontuples  "Here is a Python example".
2020  *  \endif
2021  *  \sa DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(), DataArrayDouble::areIncludedInMe
2022  */
2023 void DataArrayDouble::findCommonTuples(double prec, int limitTupleId, DataArrayInt *&comm, DataArrayInt *&commIndex) const
2024 {
2025   checkAllocated();
2026   int nbOfCompo=getNumberOfComponents();
2027   if ((nbOfCompo<1) || (nbOfCompo>4)) //test before work
2028     throw INTERP_KERNEL::Exception("DataArrayDouble::findCommonTuples : Unexpected spacedim of coords. Must be 1, 2, 3 or 4.");
2029
2030   int nbOfTuples=getNumberOfTuples();
2031   //
2032   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> c(DataArrayInt::New()),cI(DataArrayInt::New()); c->alloc(0,1); cI->pushBackSilent(0);
2033   switch(nbOfCompo)
2034   {
2035     case 4:
2036       findCommonTuplesAlg<4>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
2037       break;
2038     case 3:
2039       findCommonTuplesAlg<3>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
2040       break;
2041     case 2:
2042       findCommonTuplesAlg<2>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
2043       break;
2044     case 1:
2045       findCommonTuplesAlg<1>(begin(),nbOfTuples,limitTupleId,prec,c,cI);
2046       break;
2047     default:
2048       throw INTERP_KERNEL::Exception("DataArrayDouble::findCommonTuples : nb of components managed are 1,2,3 and 4 ! not implemented for other number of components !");
2049   }
2050   comm=c.retn();
2051   commIndex=cI.retn();
2052 }
2053
2054 /*!
2055  *
2056  * \param [in] nbTimes specifies the nb of times each tuples in \a this will be duplicated contiguouly in returned DataArrayDouble instance.
2057  *             \a nbTimes  should be at least equal to 1.
2058  * \return a newly allocated DataArrayDouble having one component and number of tuples equal to \a nbTimes * \c this->getNumberOfTuples.
2059  * \throw if \a this is not allocated or if \a this has not number of components set to one or if \a nbTimes is lower than 1.
2060  */
2061 DataArrayDouble *DataArrayDouble::duplicateEachTupleNTimes(int nbTimes) const
2062 {
2063   checkAllocated();
2064   if(getNumberOfComponents()!=1)
2065     throw INTERP_KERNEL::Exception("DataArrayDouble::duplicateEachTupleNTimes : this should have only one component !");
2066   if(nbTimes<1)
2067     throw INTERP_KERNEL::Exception("DataArrayDouble::duplicateEachTupleNTimes : nb times should be >= 1 !");
2068   int nbTuples=getNumberOfTuples();
2069   const double *inPtr=getConstPointer();
2070   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(nbTimes*nbTuples,1);
2071   double *retPtr=ret->getPointer();
2072   for(int i=0;i<nbTuples;i++,inPtr++)
2073     {
2074       double val=*inPtr;
2075       for(int j=0;j<nbTimes;j++,retPtr++)
2076         *retPtr=val;
2077     }
2078   ret->copyStringInfoFrom(*this);
2079   return ret.retn();
2080 }
2081
2082 /*!
2083  * This methods returns the minimal distance between the two set of points \a this and \a other.
2084  * So \a this and \a other have to have the same number of components. If not an INTERP_KERNEL::Exception will be thrown.
2085  * This method works only if number of components of \a this (equal to those of \a other) is in 1, 2 or 3.
2086  *
2087  * \param [out] thisTupleId the tuple id in \a this corresponding to the returned minimal distance
2088  * \param [out] otherTupleId the tuple id in \a other corresponding to the returned minimal distance
2089  * \return the minimal distance between the two set of points \a this and \a other.
2090  * \sa DataArrayDouble::findClosestTupleId
2091  */
2092 double DataArrayDouble::minimalDistanceTo(const DataArrayDouble *other, int& thisTupleId, int& otherTupleId) const
2093 {
2094   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> part1=findClosestTupleId(other);
2095   int nbOfCompo(getNumberOfComponents());
2096   int otherNbTuples(other->getNumberOfTuples());
2097   const double *thisPt(begin()),*otherPt(other->begin());
2098   const int *part1Pt(part1->begin());
2099   double ret=std::numeric_limits<double>::max();
2100   for(int i=0;i<otherNbTuples;i++,part1Pt++,otherPt+=nbOfCompo)
2101     {
2102       double tmp(0.);
2103       for(int j=0;j<nbOfCompo;j++)
2104         tmp+=(otherPt[j]-thisPt[nbOfCompo*(*part1Pt)+j])*(otherPt[j]-thisPt[nbOfCompo*(*part1Pt)+j]);
2105       if(tmp<ret)
2106         { ret=tmp; thisTupleId=*part1Pt; otherTupleId=i; }
2107     }
2108   return sqrt(ret);
2109 }
2110
2111 /*!
2112  * This methods returns for each tuple in \a other which tuple in \a this is the closest.
2113  * So \a this and \a other have to have the same number of components. If not an INTERP_KERNEL::Exception will be thrown.
2114  * This method works only if number of components of \a this (equal to those of \a other) is in 1, 2 or 3.
2115  *
2116  * \return a newly allocated (new object to be dealt by the caller) DataArrayInt having \c other->getNumberOfTuples() tuples and one components.
2117  * \sa DataArrayDouble::minimalDistanceTo
2118  */
2119 DataArrayInt *DataArrayDouble::findClosestTupleId(const DataArrayDouble *other) const
2120 {
2121   if(!other)
2122     throw INTERP_KERNEL::Exception("DataArrayDouble::findClosestTupleId : other instance is NULL !");
2123   checkAllocated(); other->checkAllocated();
2124   int nbOfCompo=getNumberOfComponents();
2125   if(nbOfCompo!=other->getNumberOfComponents())
2126     {
2127       std::ostringstream oss; oss << "DataArrayDouble::findClosestTupleId : number of components in this is " << nbOfCompo;
2128       oss << ", whereas number of components in other is " << other->getNumberOfComponents() << "! Should be equal !";
2129       throw INTERP_KERNEL::Exception(oss.str().c_str());
2130     }
2131   int nbOfTuples=other->getNumberOfTuples();
2132   int thisNbOfTuples=getNumberOfTuples();
2133   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbOfTuples,1);
2134   double bounds[6];
2135   getMinMaxPerComponent(bounds);
2136   switch(nbOfCompo)
2137   {
2138     case 3:
2139       {
2140         double xDelta(fabs(bounds[1]-bounds[0])),yDelta(fabs(bounds[3]-bounds[2])),zDelta(fabs(bounds[5]-bounds[4]));
2141         double delta=std::max(xDelta,yDelta); delta=std::max(delta,zDelta);
2142         double characSize=pow((delta*delta*delta)/((double)thisNbOfTuples),1./3.);
2143         BBTreePts<3,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
2144         FindClosestTupleIdAlg<3>(myTree,3.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
2145         break;
2146       }
2147     case 2:
2148       {
2149         double xDelta(fabs(bounds[1]-bounds[0])),yDelta(fabs(bounds[3]-bounds[2]));
2150         double delta=std::max(xDelta,yDelta);
2151         double characSize=sqrt(delta/(double)thisNbOfTuples);
2152         BBTreePts<2,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
2153         FindClosestTupleIdAlg<2>(myTree,2.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
2154         break;
2155       }
2156     case 1:
2157       {
2158         double characSize=fabs(bounds[1]-bounds[0])/thisNbOfTuples;
2159         BBTreePts<1,int> myTree(begin(),0,0,getNumberOfTuples(),characSize*1e-12);
2160         FindClosestTupleIdAlg<1>(myTree,1.*characSize*characSize,other->begin(),nbOfTuples,begin(),thisNbOfTuples,ret->getPointer());
2161         break;
2162       }
2163     default:
2164       throw INTERP_KERNEL::Exception("Unexpected spacedim of coords for findClosestTupleId. Must be 1, 2 or 3.");
2165   }
2166   return ret.retn();
2167 }
2168
2169 /*!
2170  * This method expects that \a this and \a otherBBoxFrmt arrays are bounding box arrays ( as the output of MEDCouplingPointSet::getBoundingBoxForBBTree method ).
2171  * This method will return a DataArrayInt array having the same number of tuples than \a this. This returned array tells for each cell in \a this
2172  * how many bounding boxes in \a otherBBoxFrmt.
2173  * So, this method expects that \a this and \a otherBBoxFrmt have the same number of components.
2174  *
2175  * \param [in] otherBBoxFrmt - It is an array .
2176  * \param [in] eps - the absolute precision of the detection. when eps < 0 the bboxes are enlarged so more interactions are detected. Inversely when > 0 the bboxes are stretched.
2177  * \sa MEDCouplingPointSet::getBoundingBoxForBBTree
2178  * \throw If \a this and \a otherBBoxFrmt have not the same number of components.
2179  * \throw If \a this and \a otherBBoxFrmt number of components is not even (BBox format).
2180  */
2181 DataArrayInt *DataArrayDouble::computeNbOfInteractionsWith(const DataArrayDouble *otherBBoxFrmt, double eps) const
2182 {
2183   if(!otherBBoxFrmt)
2184     throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : input array is NULL !");
2185   if(!isAllocated() || !otherBBoxFrmt->isAllocated())
2186     throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : this and input array must be allocated !");
2187   int nbOfComp(getNumberOfComponents()),nbOfTuples(getNumberOfTuples());
2188   if(nbOfComp!=otherBBoxFrmt->getNumberOfComponents())
2189     {
2190       std::ostringstream oss; oss << "DataArrayDouble::computeNbOfInteractionsWith : this number of components (" << nbOfComp << ") must be equal to the number of components of input array (" << otherBBoxFrmt->getNumberOfComponents() << ") !";
2191       throw INTERP_KERNEL::Exception(oss.str().c_str());
2192     }
2193   if(nbOfComp%2!=0)
2194     {
2195       std::ostringstream oss; oss << "DataArrayDouble::computeNbOfInteractionsWith : Number of components (" << nbOfComp << ") is not even ! It should be to be compatible with bbox format !";
2196       throw INTERP_KERNEL::Exception(oss.str().c_str());
2197     }
2198   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(nbOfTuples,1);
2199   const double *thisBBPtr(begin());
2200   int *retPtr(ret->getPointer());
2201   switch(nbOfComp/2)
2202   {
2203     case 3:
2204       {
2205         BBTree<3,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
2206         for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
2207           *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
2208         break;
2209       }
2210     case 2:
2211       {
2212         BBTree<2,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
2213         for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
2214           *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
2215         break;
2216       }
2217     case 1:
2218       {
2219         BBTree<1,int> bbt(otherBBoxFrmt->begin(),0,0,otherBBoxFrmt->getNumberOfTuples(),eps);
2220         for(int i=0;i<nbOfTuples;i++,retPtr++,thisBBPtr+=nbOfComp)
2221           *retPtr=bbt.getNbOfIntersectingElems(thisBBPtr);
2222         break;
2223       }
2224     default:
2225       throw INTERP_KERNEL::Exception("DataArrayDouble::computeNbOfInteractionsWith : space dimension supported are [1,2,3] !");
2226   }
2227
2228   return ret.retn();
2229 }
2230
2231 /*!
2232  * Returns a copy of \a this array by excluding coincident tuples. Each tuple is
2233  * considered as coordinates of a point in getNumberOfComponents()-dimensional
2234  * space. The distance between tuples is computed using norm2. If several tuples are
2235  * not far each from other than \a prec, only one of them remains in the result
2236  * array. The order of tuples in the result array is same as in \a this one except
2237  * that coincident tuples are excluded.
2238  *  \param [in] prec - minimal absolute distance between two tuples at which they are
2239  *              considered not coincident.
2240  *  \param [in] limitTupleId - limit tuple id. If all tuples within a group of coincident
2241  *              tuples have id strictly lower than \a limitTupleId then they are not excluded.
2242  *  \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
2243  *          is to delete using decrRef() as it is no more needed.
2244  *  \throw If \a this is not allocated.
2245  *  \throw If the number of components is not in [1,2,3,4].
2246  *
2247  *  \if ENABLE_EXAMPLES
2248  *  \ref py_mcdataarraydouble_getdifferentvalues "Here is a Python example".
2249  *  \endif
2250  */
2251 DataArrayDouble *DataArrayDouble::getDifferentValues(double prec, int limitTupleId) const
2252 {
2253   checkAllocated();
2254   DataArrayInt *c0=0,*cI0=0;
2255   findCommonTuples(prec,limitTupleId,c0,cI0);
2256   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> c(c0),cI(cI0);
2257   int newNbOfTuples=-1;
2258   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> o2n=DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(getNumberOfTuples(),c0->begin(),cI0->begin(),cI0->end(),newNbOfTuples);
2259   return renumberAndReduce(o2n->getConstPointer(),newNbOfTuples);
2260 }
2261
2262 /*!
2263  * Copy all components in a specified order from another DataArrayDouble.
2264  * Both numerical and textual data is copied. The number of tuples in \a this and
2265  * the other array can be different.
2266  *  \param [in] a - the array to copy data from.
2267  *  \param [in] compoIds - sequence of zero based indices of components, data of which is
2268  *              to be copied.
2269  *  \throw If \a a is NULL.
2270  *  \throw If \a compoIds.size() != \a a->getNumberOfComponents().
2271  *  \throw If \a compoIds[i] < 0 or \a compoIds[i] > \a this->getNumberOfComponents().
2272  *
2273  *  \if ENABLE_EXAMPLES
2274  *  \ref py_mcdataarraydouble_setselectedcomponents "Here is a Python example".
2275  *  \endif
2276  */
2277 void DataArrayDouble::setSelectedComponents(const DataArrayDouble *a, const std::vector<int>& compoIds)
2278 {
2279   if(!a)
2280     throw INTERP_KERNEL::Exception("DataArrayDouble::setSelectedComponents : input DataArrayDouble is NULL !");
2281   checkAllocated();
2282   copyPartOfStringInfoFrom2(compoIds,*a);
2283   std::size_t partOfCompoSz=compoIds.size();
2284   int nbOfCompo=getNumberOfComponents();
2285   int nbOfTuples=std::min(getNumberOfTuples(),a->getNumberOfTuples());
2286   const double *ac=a->getConstPointer();
2287   double *nc=getPointer();
2288   for(int i=0;i<nbOfTuples;i++)
2289     for(std::size_t j=0;j<partOfCompoSz;j++,ac++)
2290       nc[nbOfCompo*i+compoIds[j]]=*ac;
2291 }
2292
2293 /*!
2294  * Copy all values from another DataArrayDouble into specified tuples and components
2295  * of \a this array. Textual data is not copied.
2296  * The tree parameters defining set of indices of tuples and components are similar to
2297  * the tree parameters of the Python function \c range(\c start,\c stop,\c step).
2298  *  \param [in] a - the array to copy values from.
2299  *  \param [in] bgTuples - index of the first tuple of \a this array to assign values to.
2300  *  \param [in] endTuples - index of the tuple before which the tuples to assign to
2301  *              are located.
2302  *  \param [in] stepTuples - index increment to get index of the next tuple to assign to.
2303  *  \param [in] bgComp - index of the first component of \a this array to assign values to.
2304  *  \param [in] endComp - index of the component before which the components to assign
2305  *              to are located.
2306  *  \param [in] stepComp - index increment to get index of the next component to assign to.
2307  *  \param [in] strictCompoCompare - if \a true (by default), then \a a->getNumberOfComponents()
2308  *              must be equal to the number of columns to assign to, else an
2309  *              exception is thrown; if \a false, then it is only required that \a
2310  *              a->getNbOfElems() equals to number of values to assign to (this condition
2311  *              must be respected even if \a strictCompoCompare is \a true). The number of
2312  *              values to assign to is given by following Python expression:
2313  *              \a nbTargetValues =
2314  *              \c len(\c range(\a bgTuples,\a endTuples,\a stepTuples)) *
2315  *              \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2316  *  \throw If \a a is NULL.
2317  *  \throw If \a a is not allocated.
2318  *  \throw If \a this is not allocated.
2319  *  \throw If parameters specifying tuples and components to assign to do not give a
2320  *            non-empty range of increasing indices.
2321  *  \throw If \a a->getNbOfElems() != \a nbTargetValues.
2322  *  \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
2323  *            \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2324  *
2325  *  \if ENABLE_EXAMPLES
2326  *  \ref py_mcdataarraydouble_setpartofvalues1 "Here is a Python example".
2327  *  \endif
2328  */
2329 void DataArrayDouble::setPartOfValues1(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
2330 {
2331   if(!a)
2332     throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues1 : input DataArrayDouble is NULL !");
2333   const char msg[]="DataArrayDouble::setPartOfValues1";
2334   checkAllocated();
2335   a->checkAllocated();
2336   int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2337   int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2338   int nbComp=getNumberOfComponents();
2339   int nbOfTuples=getNumberOfTuples();
2340   DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2341   DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2342   bool assignTech=true;
2343   if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2344     {
2345       if(strictCompoCompare)
2346         a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2347     }
2348   else
2349     {
2350       a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2351       assignTech=false;
2352     }
2353   const double *srcPt=a->getConstPointer();
2354   double *pt=getPointer()+bgTuples*nbComp+bgComp;
2355   if(assignTech)
2356     {
2357       for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2358         for(int j=0;j<newNbOfComp;j++,srcPt++)
2359           pt[j*stepComp]=*srcPt;
2360     }
2361   else
2362     {
2363       for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2364         {
2365           const double *srcPt2=srcPt;
2366           for(int j=0;j<newNbOfComp;j++,srcPt2++)
2367             pt[j*stepComp]=*srcPt2;
2368         }
2369     }
2370 }
2371
2372 /*!
2373  * Assign a given value to values at specified tuples and components of \a this array.
2374  * The tree parameters defining set of indices of tuples and components are similar to
2375  * the tree parameters of the Python function \c range(\c start,\c stop,\c step)..
2376  *  \param [in] a - the value to assign.
2377  *  \param [in] bgTuples - index of the first tuple of \a this array to assign to.
2378  *  \param [in] endTuples - index of the tuple before which the tuples to assign to
2379  *              are located.
2380  *  \param [in] stepTuples - index increment to get index of the next tuple to assign to.
2381  *  \param [in] bgComp - index of the first component of \a this array to assign to.
2382  *  \param [in] endComp - index of the component before which the components to assign
2383  *              to are located.
2384  *  \param [in] stepComp - index increment to get index of the next component to assign to.
2385  *  \throw If \a this is not allocated.
2386  *  \throw If parameters specifying tuples and components to assign to, do not give a
2387  *            non-empty range of increasing indices or indices are out of a valid range
2388  *            for \this array.
2389  *
2390  *  \if ENABLE_EXAMPLES
2391  *  \ref py_mcdataarraydouble_setpartofvaluessimple1 "Here is a Python example".
2392  *  \endif
2393  */
2394 void DataArrayDouble::setPartOfValuesSimple1(double a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp)
2395 {
2396   const char msg[]="DataArrayDouble::setPartOfValuesSimple1";
2397   checkAllocated();
2398   int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2399   int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2400   int nbComp=getNumberOfComponents();
2401   int nbOfTuples=getNumberOfTuples();
2402   DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2403   DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2404   double *pt=getPointer()+bgTuples*nbComp+bgComp;
2405   for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2406     for(int j=0;j<newNbOfComp;j++)
2407       pt[j*stepComp]=a;
2408 }
2409
2410 /*!
2411  * Copy all values from another DataArrayDouble (\a a) into specified tuples and
2412  * components of \a this array. Textual data is not copied.
2413  * The tuples and components to assign to are defined by C arrays of indices.
2414  * There are two *modes of usage*:
2415  * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
2416  *   of \a a is assigned to its own location within \a this array.
2417  * - If \a a includes one tuple, then all values of \a a are assigned to the specified
2418  *   components of every specified tuple of \a this array. In this mode it is required
2419  *   that \a a->getNumberOfComponents() equals to the number of specified components.
2420  *
2421  *  \param [in] a - the array to copy values from.
2422  *  \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2423  *              assign values of \a a to.
2424  *  \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2425  *              pointer to a tuple index <em>(pi)</em> varies as this:
2426  *              \a bgTuples <= \a pi < \a endTuples.
2427  *  \param [in] bgComp - pointer to an array of component indices of \a this array to
2428  *              assign values of \a a to.
2429  *  \param [in] endComp - specifies the end of the array \a bgTuples, so that
2430  *              pointer to a component index <em>(pi)</em> varies as this:
2431  *              \a bgComp <= \a pi < \a endComp.
2432  *  \param [in] strictCompoCompare - this parameter is checked only if the
2433  *               *mode of usage* is the first; if it is \a true (default),
2434  *               then \a a->getNumberOfComponents() must be equal
2435  *               to the number of specified columns, else this is not required.
2436  *  \throw If \a a is NULL.
2437  *  \throw If \a a is not allocated.
2438  *  \throw If \a this is not allocated.
2439  *  \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
2440  *         out of a valid range for \a this array.
2441  *  \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
2442  *         if <em> a->getNumberOfComponents() != (endComp - bgComp) </em>.
2443  *  \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
2444  *         <em> a->getNumberOfComponents() != (endComp - bgComp)</em>.
2445  *
2446  *  \if ENABLE_EXAMPLES
2447  *  \ref py_mcdataarraydouble_setpartofvalues2 "Here is a Python example".
2448  *  \endif
2449  */
2450 void DataArrayDouble::setPartOfValues2(const DataArrayDouble *a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
2451 {
2452   if(!a)
2453     throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues2 : input DataArrayDouble is NULL !");
2454   const char msg[]="DataArrayDouble::setPartOfValues2";
2455   checkAllocated();
2456   a->checkAllocated();
2457   int nbComp=getNumberOfComponents();
2458   int nbOfTuples=getNumberOfTuples();
2459   for(const int *z=bgComp;z!=endComp;z++)
2460     DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2461   int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
2462   int newNbOfComp=(int)std::distance(bgComp,endComp);
2463   bool assignTech=true;
2464   if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2465     {
2466       if(strictCompoCompare)
2467         a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2468     }
2469   else
2470     {
2471       a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2472       assignTech=false;
2473     }
2474   double *pt=getPointer();
2475   const double *srcPt=a->getConstPointer();
2476   if(assignTech)
2477     {
2478       for(const int *w=bgTuples;w!=endTuples;w++)
2479         {
2480           DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2481           for(const int *z=bgComp;z!=endComp;z++,srcPt++)
2482             {
2483               pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt;
2484             }
2485         }
2486     }
2487   else
2488     {
2489       for(const int *w=bgTuples;w!=endTuples;w++)
2490         {
2491           const double *srcPt2=srcPt;
2492           DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2493           for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
2494             {
2495               pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt2;
2496             }
2497         }
2498     }
2499 }
2500
2501 /*!
2502  * Assign a given value to values at specified tuples and components of \a this array.
2503  * The tuples and components to assign to are defined by C arrays of indices.
2504  *  \param [in] a - the value to assign.
2505  *  \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2506  *              assign \a a to.
2507  *  \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2508  *              pointer to a tuple index (\a pi) varies as this:
2509  *              \a bgTuples <= \a pi < \a endTuples.
2510  *  \param [in] bgComp - pointer to an array of component indices of \a this array to
2511  *              assign \a a to.
2512  *  \param [in] endComp - specifies the end of the array \a bgTuples, so that
2513  *              pointer to a component index (\a pi) varies as this:
2514  *              \a bgComp <= \a pi < \a endComp.
2515  *  \throw If \a this is not allocated.
2516  *  \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
2517  *         out of a valid range for \a this array.
2518  *
2519  *  \if ENABLE_EXAMPLES
2520  *  \ref py_mcdataarraydouble_setpartofvaluessimple2 "Here is a Python example".
2521  *  \endif
2522  */
2523 void DataArrayDouble::setPartOfValuesSimple2(double a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp)
2524 {
2525   checkAllocated();
2526   int nbComp=getNumberOfComponents();
2527   int nbOfTuples=getNumberOfTuples();
2528   for(const int *z=bgComp;z!=endComp;z++)
2529     DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2530   double *pt=getPointer();
2531   for(const int *w=bgTuples;w!=endTuples;w++)
2532     for(const int *z=bgComp;z!=endComp;z++)
2533       {
2534         DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2535         pt[(std::size_t)(*w)*nbComp+(*z)]=a;
2536       }
2537 }
2538
2539 /*!
2540  * Copy all values from another DataArrayDouble (\a a) into specified tuples and
2541  * components of \a this array. Textual data is not copied.
2542  * The tuples to assign to are defined by a C array of indices.
2543  * The components to assign to are defined by three values similar to parameters of
2544  * the Python function \c range(\c start,\c stop,\c step).
2545  * There are two *modes of usage*:
2546  * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
2547  *   of \a a is assigned to its own location within \a this array.
2548  * - If \a a includes one tuple, then all values of \a a are assigned to the specified
2549  *   components of every specified tuple of \a this array. In this mode it is required
2550  *   that \a a->getNumberOfComponents() equals to the number of specified components.
2551  *
2552  *  \param [in] a - the array to copy values from.
2553  *  \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2554  *              assign values of \a a to.
2555  *  \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2556  *              pointer to a tuple index <em>(pi)</em> varies as this:
2557  *              \a bgTuples <= \a pi < \a endTuples.
2558  *  \param [in] bgComp - index of the first component of \a this array to assign to.
2559  *  \param [in] endComp - index of the component before which the components to assign
2560  *              to are located.
2561  *  \param [in] stepComp - index increment to get index of the next component to assign to.
2562  *  \param [in] strictCompoCompare - this parameter is checked only in the first
2563  *               *mode of usage*; if \a strictCompoCompare is \a true (default),
2564  *               then \a a->getNumberOfComponents() must be equal
2565  *               to the number of specified columns, else this is not required.
2566  *  \throw If \a a is NULL.
2567  *  \throw If \a a is not allocated.
2568  *  \throw If \a this is not allocated.
2569  *  \throw If any index of tuple given by \a bgTuples is out of a valid range for
2570  *         \a this array.
2571  *  \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
2572  *         if <em> a->getNumberOfComponents()</em> is unequal to the number of components
2573  *         defined by <em>(bgComp,endComp,stepComp)</em>.
2574  *  \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
2575  *         <em> a->getNumberOfComponents()</em> is unequal to the number of components
2576  *         defined by <em>(bgComp,endComp,stepComp)</em>.
2577  *  \throw If parameters specifying components to assign to, do not give a
2578  *            non-empty range of increasing indices or indices are out of a valid range
2579  *            for \this array.
2580  *
2581  *  \if ENABLE_EXAMPLES
2582  *  \ref py_mcdataarraydouble_setpartofvalues3 "Here is a Python example".
2583  *  \endif
2584  */
2585 void DataArrayDouble::setPartOfValues3(const DataArrayDouble *a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
2586 {
2587   if(!a)
2588     throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues3 : input DataArrayDouble is NULL !");
2589   const char msg[]="DataArrayDouble::setPartOfValues3";
2590   checkAllocated();
2591   a->checkAllocated();
2592   int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2593   int nbComp=getNumberOfComponents();
2594   int nbOfTuples=getNumberOfTuples();
2595   DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2596   int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
2597   bool assignTech=true;
2598   if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2599     {
2600       if(strictCompoCompare)
2601         a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2602     }
2603   else
2604     {
2605       a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2606       assignTech=false;
2607     }
2608   double *pt=getPointer()+bgComp;
2609   const double *srcPt=a->getConstPointer();
2610   if(assignTech)
2611     {
2612       for(const int *w=bgTuples;w!=endTuples;w++)
2613         for(int j=0;j<newNbOfComp;j++,srcPt++)
2614           {
2615             DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2616             pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt;
2617           }
2618     }
2619   else
2620     {
2621       for(const int *w=bgTuples;w!=endTuples;w++)
2622         {
2623           const double *srcPt2=srcPt;
2624           for(int j=0;j<newNbOfComp;j++,srcPt2++)
2625             {
2626               DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2627               pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt2;
2628             }
2629         }
2630     }
2631 }
2632
2633 /*!
2634  * Assign a given value to values at specified tuples and components of \a this array.
2635  * The tuples to assign to are defined by a C array of indices.
2636  * The components to assign to are defined by three values similar to parameters of
2637  * the Python function \c range(\c start,\c stop,\c step).
2638  *  \param [in] a - the value to assign.
2639  *  \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
2640  *              assign \a a to.
2641  *  \param [in] endTuples - specifies the end of the array \a bgTuples, so that
2642  *              pointer to a tuple index <em>(pi)</em> varies as this:
2643  *              \a bgTuples <= \a pi < \a endTuples.
2644  *  \param [in] bgComp - index of the first component of \a this array to assign to.
2645  *  \param [in] endComp - index of the component before which the components to assign
2646  *              to are located.
2647  *  \param [in] stepComp - index increment to get index of the next component to assign to.
2648  *  \throw If \a this is not allocated.
2649  *  \throw If any index of tuple given by \a bgTuples is out of a valid range for
2650  *         \a this array.
2651  *  \throw If parameters specifying components to assign to, do not give a
2652  *            non-empty range of increasing indices or indices are out of a valid range
2653  *            for \this array.
2654  *
2655  *  \if ENABLE_EXAMPLES
2656  *  \ref py_mcdataarraydouble_setpartofvaluessimple3 "Here is a Python example".
2657  *  \endif
2658  */
2659 void DataArrayDouble::setPartOfValuesSimple3(double a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp)
2660 {
2661   const char msg[]="DataArrayDouble::setPartOfValuesSimple3";
2662   checkAllocated();
2663   int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
2664   int nbComp=getNumberOfComponents();
2665   int nbOfTuples=getNumberOfTuples();
2666   DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
2667   double *pt=getPointer()+bgComp;
2668   for(const int *w=bgTuples;w!=endTuples;w++)
2669     for(int j=0;j<newNbOfComp;j++)
2670       {
2671         DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
2672         pt[(std::size_t)(*w)*nbComp+j*stepComp]=a;
2673       }
2674 }
2675
2676 /*!
2677  * Copy all values from another DataArrayDouble into specified tuples and components
2678  * of \a this array. Textual data is not copied.
2679  * The tree parameters defining set of indices of tuples and components are similar to
2680  * the tree parameters of the Python function \c range(\c start,\c stop,\c step).
2681  *  \param [in] a - the array to copy values from.
2682  *  \param [in] bgTuples - index of the first tuple of \a this array to assign values to.
2683  *  \param [in] endTuples - index of the tuple before which the tuples to assign to
2684  *              are located.
2685  *  \param [in] stepTuples - index increment to get index of the next tuple to assign to.
2686  *  \param [in] bgComp - pointer to an array of component indices of \a this array to
2687  *              assign \a a to.
2688  *  \param [in] endComp - specifies the end of the array \a bgTuples, so that
2689  *              pointer to a component index (\a pi) varies as this:
2690  *              \a bgComp <= \a pi < \a endComp.
2691  *  \param [in] strictCompoCompare - if \a true (by default), then \a a->getNumberOfComponents()
2692  *              must be equal to the number of columns to assign to, else an
2693  *              exception is thrown; if \a false, then it is only required that \a
2694  *              a->getNbOfElems() equals to number of values to assign to (this condition
2695  *              must be respected even if \a strictCompoCompare is \a true). The number of
2696  *              values to assign to is given by following Python expression:
2697  *              \a nbTargetValues =
2698  *              \c len(\c range(\a bgTuples,\a endTuples,\a stepTuples)) *
2699  *              \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2700  *  \throw If \a a is NULL.
2701  *  \throw If \a a is not allocated.
2702  *  \throw If \a this is not allocated.
2703  *  \throw If parameters specifying tuples and components to assign to do not give a
2704  *            non-empty range of increasing indices.
2705  *  \throw If \a a->getNbOfElems() != \a nbTargetValues.
2706  *  \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
2707  *            \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
2708  *
2709  */
2710 void DataArrayDouble::setPartOfValues4(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
2711 {
2712   if(!a)
2713     throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValues4 : input DataArrayDouble is NULL !");
2714   const char msg[]="DataArrayDouble::setPartOfValues4";
2715   checkAllocated();
2716   a->checkAllocated();
2717   int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2718   int newNbOfComp=(int)std::distance(bgComp,endComp);
2719   int nbComp=getNumberOfComponents();
2720   for(const int *z=bgComp;z!=endComp;z++)
2721     DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2722   int nbOfTuples=getNumberOfTuples();
2723   DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2724   bool assignTech=true;
2725   if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
2726     {
2727       if(strictCompoCompare)
2728         a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
2729     }
2730   else
2731     {
2732       a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
2733       assignTech=false;
2734     }
2735   const double *srcPt=a->getConstPointer();
2736   double *pt=getPointer()+bgTuples*nbComp;
2737   if(assignTech)
2738     {
2739       for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2740         for(const int *z=bgComp;z!=endComp;z++,srcPt++)
2741           pt[*z]=*srcPt;
2742     }
2743   else
2744     {
2745       for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2746         {
2747           const double *srcPt2=srcPt;
2748           for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
2749             pt[*z]=*srcPt2;
2750         }
2751     }
2752 }
2753
2754 void DataArrayDouble::setPartOfValuesSimple4(double a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp)
2755 {
2756   const char msg[]="DataArrayDouble::setPartOfValuesSimple4";
2757   checkAllocated();
2758   int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
2759   int nbComp=getNumberOfComponents();
2760   for(const int *z=bgComp;z!=endComp;z++)
2761     DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
2762   int nbOfTuples=getNumberOfTuples();
2763   DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
2764   double *pt=getPointer()+bgTuples*nbComp;
2765   for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
2766     for(const int *z=bgComp;z!=endComp;z++)
2767       pt[*z]=a;
2768 }
2769
2770 /*!
2771  * Copy some tuples from another DataArrayDouble into specified tuples
2772  * of \a this array. Textual data is not copied. Both arrays must have equal number of
2773  * components.
2774  * Both the tuples to assign and the tuples to assign to are defined by a DataArrayInt.
2775  * All components of selected tuples are copied.
2776  *  \param [in] a - the array to copy values from.
2777  *  \param [in] tuplesSelec - the array specifying both source tuples of \a a and
2778  *              target tuples of \a this. \a tuplesSelec has two components, and the
2779  *              first component specifies index of the source tuple and the second
2780  *              one specifies index of the target tuple.
2781  *  \throw If \a this is not allocated.
2782  *  \throw If \a a is NULL.
2783  *  \throw If \a a is not allocated.
2784  *  \throw If \a tuplesSelec is NULL.
2785  *  \throw If \a tuplesSelec is not allocated.
2786  *  \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
2787  *  \throw If \a tuplesSelec->getNumberOfComponents() != 2.
2788  *  \throw If any tuple index given by \a tuplesSelec is out of a valid range for
2789  *         the corresponding (\a this or \a a) array.
2790  */
2791 void DataArrayDouble::setPartOfValuesAdv(const DataArrayDouble *a, const DataArrayInt *tuplesSelec)
2792 {
2793   if(!a || !tuplesSelec)
2794     throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValuesAdv : input DataArrayDouble is NULL !");
2795   checkAllocated();
2796   a->checkAllocated();
2797   tuplesSelec->checkAllocated();
2798   int nbOfComp=getNumberOfComponents();
2799   if(nbOfComp!=a->getNumberOfComponents())
2800     throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValuesAdv : This and a do not have the same number of components !");
2801   if(tuplesSelec->getNumberOfComponents()!=2)
2802     throw INTERP_KERNEL::Exception("DataArrayDouble::setPartOfValuesAdv : Expecting to have a tuple selector DataArrayInt instance with exactly 2 components !");
2803   int thisNt=getNumberOfTuples();
2804   int aNt=a->getNumberOfTuples();
2805   double *valsToSet=getPointer();
2806   const double *valsSrc=a->getConstPointer();
2807   for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple+=2)
2808     {
2809       if(tuple[1]>=0 && tuple[1]<aNt)
2810         {
2811           if(tuple[0]>=0 && tuple[0]<thisNt)
2812             std::copy(valsSrc+nbOfComp*tuple[1],valsSrc+nbOfComp*(tuple[1]+1),valsToSet+nbOfComp*tuple[0]);
2813           else
2814             {
2815               std::ostringstream oss; oss << "DataArrayDouble::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
2816               oss << " of 'tuplesSelec' request of tuple id #" << tuple[0] << " in 'this' ! It should be in [0," << thisNt << ") !";
2817               throw INTERP_KERNEL::Exception(oss.str().c_str());
2818             }
2819         }
2820       else
2821         {
2822           std::ostringstream oss; oss << "DataArrayDouble::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
2823           oss << " of 'tuplesSelec' request of tuple id #" << tuple[1] << " in 'a' ! It should be in [0," << aNt << ") !";
2824           throw INTERP_KERNEL::Exception(oss.str().c_str());
2825         }
2826     }
2827 }
2828
2829 /*!
2830  * Copy some tuples from another DataArrayDouble (\a aBase) into contiguous tuples
2831  * of \a this array. Textual data is not copied. Both arrays must have equal number of
2832  * components.
2833  * The tuples to assign to are defined by index of the first tuple, and
2834  * their number is defined by \a tuplesSelec->getNumberOfTuples().
2835  * The tuples to copy are defined by values of a DataArrayInt.
2836  * All components of selected tuples are copied.
2837  *  \param [in] tupleIdStart - index of the first tuple of \a this array to assign
2838  *              values to.
2839  *  \param [in] aBase - the array to copy values from.
2840  *  \param [in] tuplesSelec - the array specifying tuples of \a a to copy.
2841  *  \throw If \a this is not allocated.
2842  *  \throw If \a aBase is NULL.
2843  *  \throw If \a aBase is not allocated.
2844  *  \throw If \a tuplesSelec is NULL.
2845  *  \throw If \a tuplesSelec is not allocated.
2846  *  \throw If <em>this->getNumberOfComponents() != aBase->getNumberOfComponents()</em>.
2847  *  \throw If \a tuplesSelec->getNumberOfComponents() != 1.
2848  *  \throw If <em>tupleIdStart + tuplesSelec->getNumberOfTuples() > this->getNumberOfTuples().</em>
2849  *  \throw If any tuple index given by \a tuplesSelec is out of a valid range for
2850  *         \a aBase array.
2851  */
2852 void DataArrayDouble::setContigPartOfSelectedValues(int tupleIdStart, const DataArray *aBase, const DataArrayInt *tuplesSelec)
2853 {
2854   if(!aBase || !tuplesSelec)
2855     throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : input DataArray is NULL !");
2856   const DataArrayDouble *a=dynamic_cast<const DataArrayDouble *>(aBase);
2857   if(!a)
2858     throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : input DataArray aBase is not a DataArrayDouble !");
2859   checkAllocated();
2860   a->checkAllocated();
2861   tuplesSelec->checkAllocated();
2862   int nbOfComp=getNumberOfComponents();
2863   if(nbOfComp!=a->getNumberOfComponents())
2864     throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : This and a do not have the same number of components !");
2865   if(tuplesSelec->getNumberOfComponents()!=1)
2866     throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : Expecting to have a tuple selector DataArrayInt instance with exactly 1 component !");
2867   int thisNt=getNumberOfTuples();
2868   int aNt=a->getNumberOfTuples();
2869   int nbOfTupleToWrite=tuplesSelec->getNumberOfTuples();
2870   double *valsToSet=getPointer()+tupleIdStart*nbOfComp;
2871   if(tupleIdStart+nbOfTupleToWrite>thisNt)
2872     throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues : invalid number range of values to write !");
2873   const double *valsSrc=a->getConstPointer();
2874   for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple++,valsToSet+=nbOfComp)
2875     {
2876       if(*tuple>=0 && *tuple<aNt)
2877         {
2878           std::copy(valsSrc+nbOfComp*(*tuple),valsSrc+nbOfComp*(*tuple+1),valsToSet);
2879         }
2880       else
2881         {
2882           std::ostringstream oss; oss << "DataArrayDouble::setContigPartOfSelectedValues : Tuple #" << std::distance(tuplesSelec->begin(),tuple);
2883           oss << " of 'tuplesSelec' request of tuple id #" << *tuple << " in 'a' ! It should be in [0," << aNt << ") !";
2884           throw INTERP_KERNEL::Exception(oss.str().c_str());
2885         }
2886     }
2887 }
2888
2889 /*!
2890  * Copy some tuples from another DataArrayDouble (\a aBase) into contiguous tuples
2891  * of \a this array. Textual data is not copied. Both arrays must have equal number of
2892  * components.
2893  * The tuples to copy are defined by three values similar to parameters of
2894  * the Python function \c range(\c start,\c stop,\c step).
2895  * The tuples to assign to are defined by index of the first tuple, and
2896  * their number is defined by number of tuples to copy.
2897  * All components of selected tuples are copied.
2898  *  \param [in] tupleIdStart - index of the first tuple of \a this array to assign
2899  *              values to.
2900  *  \param [in] aBase - the array to copy values from.
2901  *  \param [in] bg - index of the first tuple to copy of the array \a aBase.
2902  *  \param [in] end2 - index of the tuple of \a aBase before which the tuples to copy
2903  *              are located.
2904  *  \param [in] step - index increment to get index of the next tuple to copy.
2905  *  \throw If \a this is not allocated.
2906  *  \throw If \a aBase is NULL.
2907  *  \throw If \a aBase is not allocated.
2908  *  \throw If <em>this->getNumberOfComponents() != aBase->getNumberOfComponents()</em>.
2909  *  \throw If <em>tupleIdStart + len(range(bg,end2,step)) > this->getNumberOfTuples().</em>
2910  *  \throw If parameters specifying tuples to copy, do not give a
2911  *            non-empty range of increasing indices or indices are out of a valid range
2912  *            for the array \a aBase.
2913  */
2914 void DataArrayDouble::setContigPartOfSelectedValues2(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step)
2915 {
2916   if(!aBase)
2917     throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : input DataArray is NULL !");
2918   const DataArrayDouble *a=dynamic_cast<const DataArrayDouble *>(aBase);
2919   if(!a)
2920     throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : input DataArray aBase is not a DataArrayDouble !");
2921   checkAllocated();
2922   a->checkAllocated();
2923   int nbOfComp=getNumberOfComponents();
2924   const char msg[]="DataArrayDouble::setContigPartOfSelectedValues2";
2925   int nbOfTupleToWrite=DataArray::GetNumberOfItemGivenBES(bg,end2,step,msg);
2926   if(nbOfComp!=a->getNumberOfComponents())
2927     throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : This and a do not have the same number of components !");
2928   int thisNt=getNumberOfTuples();
2929   int aNt=a->getNumberOfTuples();
2930   double *valsToSet=getPointer()+tupleIdStart*nbOfComp;
2931   if(tupleIdStart+nbOfTupleToWrite>thisNt)
2932     throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : invalid number range of values to write !");
2933   if(end2>aNt)
2934     throw INTERP_KERNEL::Exception("DataArrayDouble::setContigPartOfSelectedValues2 : invalid range of values to read !");
2935   const double *valsSrc=a->getConstPointer()+bg*nbOfComp;
2936   for(int i=0;i<nbOfTupleToWrite;i++,valsToSet+=nbOfComp,valsSrc+=step*nbOfComp)
2937     {
2938       std::copy(valsSrc,valsSrc+nbOfComp,valsToSet);
2939     }
2940 }
2941
2942 /*!
2943  * Returns a value located at specified tuple and component.
2944  * This method is equivalent to DataArrayDouble::getIJ() except that validity of
2945  * parameters is checked. So this method is safe but expensive if used to go through
2946  * all values of \a this.
2947  *  \param [in] tupleId - index of tuple of interest.
2948  *  \param [in] compoId - index of component of interest.
2949  *  \return double - value located by \a tupleId and \a compoId.
2950  *  \throw If \a this is not allocated.
2951  *  \throw If condition <em>( 0 <= tupleId < this->getNumberOfTuples() )</em> is violated.
2952  *  \throw If condition <em>( 0 <= compoId < this->getNumberOfComponents() )</em> is violated.
2953  */
2954 double DataArrayDouble::getIJSafe(int tupleId, int compoId) const
2955 {
2956   checkAllocated();
2957   if(tupleId<0 || tupleId>=getNumberOfTuples())
2958     {
2959       std::ostringstream oss; oss << "DataArrayDouble::getIJSafe : request for tupleId " << tupleId << " should be in [0," << getNumberOfTuples() << ") !";
2960       throw INTERP_KERNEL::Exception(oss.str().c_str());
2961     }
2962   if(compoId<0 || compoId>=getNumberOfComponents())
2963     {
2964       std::ostringstream oss; oss << "DataArrayDouble::getIJSafe : request for compoId " << compoId << " should be in [0," << getNumberOfComponents() << ") !";
2965       throw INTERP_KERNEL::Exception(oss.str().c_str());
2966     }
2967   return _mem[tupleId*_info_on_compo.size()+compoId];
2968 }
2969
2970 /*!
2971  * Returns the first value of \a this.
2972  *  \return double - the last value of \a this array.
2973  *  \throw If \a this is not allocated.
2974  *  \throw If \a this->getNumberOfComponents() != 1.
2975  *  \throw If \a this->getNumberOfTuples() < 1.
2976  */
2977 double DataArrayDouble::front() const
2978 {
2979   checkAllocated();
2980   if(getNumberOfComponents()!=1)
2981     throw INTERP_KERNEL::Exception("DataArrayDouble::front : number of components not equal to one !");
2982   int nbOfTuples=getNumberOfTuples();
2983   if(nbOfTuples<1)
2984     throw INTERP_KERNEL::Exception("DataArrayDouble::front : number of tuples must be >= 1 !");
2985   return *(getConstPointer());
2986 }
2987
2988 /*!
2989  * Returns the last value of \a this.
2990  *  \return double - the last value of \a this array.
2991  *  \throw If \a this is not allocated.
2992  *  \throw If \a this->getNumberOfComponents() != 1.
2993  *  \throw If \a this->getNumberOfTuples() < 1.
2994  */
2995 double DataArrayDouble::back() const
2996 {
2997   checkAllocated();
2998   if(getNumberOfComponents()!=1)
2999     throw INTERP_KERNEL::Exception("DataArrayDouble::back : number of components not equal to one !");
3000   int nbOfTuples=getNumberOfTuples();
3001   if(nbOfTuples<1)
3002     throw INTERP_KERNEL::Exception("DataArrayDouble::back : number of tuples must be >= 1 !");
3003   return *(getConstPointer()+nbOfTuples-1);
3004 }
3005
3006 void DataArrayDouble::SetArrayIn(DataArrayDouble *newArray, DataArrayDouble* &arrayToSet)
3007 {
3008   if(newArray!=arrayToSet)
3009     {
3010       if(arrayToSet)
3011         arrayToSet->decrRef();
3012       arrayToSet=newArray;
3013       if(arrayToSet)
3014         arrayToSet->incrRef();
3015     }
3016 }
3017
3018 /*!
3019  * Sets a C array to be used as raw data of \a this. The previously set info
3020  *  of components is retained and re-sized.
3021  * For more info see \ref MEDCouplingArraySteps1.
3022  *  \param [in] array - the C array to be used as raw data of \a this.
3023  *  \param [in] ownership - if \a true, \a array will be deallocated at destruction of \a this.
3024  *  \param [in] type - specifies how to deallocate \a array. If \a type == ParaMEDMEM::CPP_DEALLOC,
3025  *                     \c delete [] \c array; will be called. If \a type == ParaMEDMEM::C_DEALLOC,
3026  *                     \c free(\c array ) will be called.
3027  *  \param [in] nbOfTuple - new number of tuples in \a this.
3028  *  \param [in] nbOfCompo - new number of components in \a this.
3029  */
3030 void DataArrayDouble::useArray(const double *array, bool ownership, DeallocType type, int nbOfTuple, int nbOfCompo)
3031 {
3032   _info_on_compo.resize(nbOfCompo);
3033   _mem.useArray(array,ownership,type,(std::size_t)nbOfTuple*nbOfCompo);
3034   declareAsNew();
3035 }
3036
3037 void DataArrayDouble::useExternalArrayWithRWAccess(const double *array, int nbOfTuple, int nbOfCompo)
3038 {
3039   _info_on_compo.resize(nbOfCompo);
3040   _mem.useExternalArrayWithRWAccess(array,(std::size_t)nbOfTuple*nbOfCompo);
3041   declareAsNew();
3042 }
3043
3044 /*!
3045  * Checks if 0.0 value is present in \a this array. If it is the case, an exception
3046  * is thrown.
3047  * \throw If zero is found in \a this array.
3048  */
3049 void DataArrayDouble::checkNoNullValues() const
3050 {
3051   const double *tmp=getConstPointer();
3052   std::size_t nbOfElems=getNbOfElems();
3053   const double *where=std::find(tmp,tmp+nbOfElems,0.);
3054   if(where!=tmp+nbOfElems)
3055     throw INTERP_KERNEL::Exception("A value 0.0 have been detected !");
3056 }
3057
3058 /*!
3059  * Computes minimal and maximal value in each component. An output array is filled
3060  * with \c 2 * \a this->getNumberOfComponents() values, so the caller is to allocate
3061  * enough memory before calling this method.
3062  *  \param [out] bounds - array of size at least 2 *\a this->getNumberOfComponents().
3063  *               It is filled as follows:<br>
3064  *               \a bounds[0] = \c min_of_component_0 <br>
3065  *               \a bounds[1] = \c max_of_component_0 <br>
3066  *               \a bounds[2] = \c min_of_component_1 <br>
3067  *               \a bounds[3] = \c max_of_component_1 <br>
3068  *               ...
3069  */
3070 void DataArrayDouble::getMinMaxPerComponent(double *bounds) const
3071 {
3072   checkAllocated();
3073   int dim=getNumberOfComponents();
3074   for (int idim=0; idim<dim; idim++)
3075     {
3076       bounds[idim*2]=std::numeric_limits<double>::max();
3077       bounds[idim*2+1]=-std::numeric_limits<double>::max();
3078     }
3079   const double *ptr=getConstPointer();
3080   int nbOfTuples=getNumberOfTuples();
3081   for(int i=0;i<nbOfTuples;i++)
3082     {
3083       for(int idim=0;idim<dim;idim++)
3084         {
3085           if(bounds[idim*2]>ptr[i*dim+idim])
3086             {
3087               bounds[idim*2]=ptr[i*dim+idim];
3088             }
3089           if(bounds[idim*2+1]<ptr[i*dim+idim])
3090             {
3091               bounds[idim*2+1]=ptr[i*dim+idim];
3092             }
3093         }
3094     }
3095 }
3096
3097 /*!
3098  * This method retrieves a newly allocated DataArrayDouble instance having same number of tuples than \a this and twice number of components than \a this
3099  * to store both the min and max per component of each tuples.
3100  * \param [in] epsilon the width of the bbox (identical in each direction) - 0.0 by default
3101  *
3102  * \return a newly created DataArrayDouble instance having \c this->getNumberOfTuples() tuples and 2 * \c this->getNumberOfComponent() components
3103  *
3104  * \throw If \a this is not allocated yet.
3105  */
3106 DataArrayDouble *DataArrayDouble::computeBBoxPerTuple(double epsilon) const
3107 {
3108   checkAllocated();
3109   const double *dataPtr=getConstPointer();
3110   int nbOfCompo=getNumberOfComponents();
3111   int nbTuples=getNumberOfTuples();
3112   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> bbox=DataArrayDouble::New();
3113   bbox->alloc(nbTuples,2*nbOfCompo);
3114   double *bboxPtr=bbox->getPointer();
3115   for(int i=0;i<nbTuples;i++)
3116     {
3117       for(int j=0;j<nbOfCompo;j++)
3118         {
3119           bboxPtr[2*nbOfCompo*i+2*j]=dataPtr[nbOfCompo*i+j]-epsilon;
3120           bboxPtr[2*nbOfCompo*i+2*j+1]=dataPtr[nbOfCompo*i+j]+epsilon;
3121         }
3122     }
3123   return bbox.retn();
3124 }
3125
3126 /*!
3127  * For each tuples **t** in \a other, this method retrieves tuples in \a this that are equal to **t**.
3128  * Two tuples are considered equal if the euclidian distance between the two tuples is lower than \a eps.
3129  *
3130  * \param [in] other a DataArrayDouble having same number of components than \a this.
3131  * \param [in] eps absolute precision representing distance (using infinite norm) between 2 tuples behind which 2 tuples are considered equal.
3132  * \param [out] c will contain the set of tuple ids in \a this that are equal to to the tuple ids in \a other contiguously.
3133  *             \a cI allows to extract information in \a c.
3134  * \param [out] cI is an indirection array that allows to extract the data contained in \a c.
3135  *
3136  * \throw In case of:
3137  *  - \a this is not allocated
3138  *  - \a other is not allocated or null
3139  *  - \a this and \a other do not have the same number of components
3140  *  - if number of components of \a this is not in [1,2,3]
3141  *
3142  * \sa MEDCouplingPointSet::getNodeIdsNearPoints, DataArrayDouble::getDifferentValues
3143  */
3144 void DataArrayDouble::computeTupleIdsNearTuples(const DataArrayDouble *other, double eps, DataArrayInt *& c, DataArrayInt *& cI) const
3145 {
3146   if(!other)
3147     throw INTERP_KERNEL::Exception("DataArrayDouble::computeTupleIdsNearTuples : input pointer other is null !");
3148   checkAllocated();
3149   other->checkAllocated();
3150   int nbOfCompo=getNumberOfComponents();
3151   int otherNbOfCompo=other->getNumberOfComponents();
3152   if(nbOfCompo!=otherNbOfCompo)
3153     throw INTERP_KERNEL::Exception("DataArrayDouble::computeTupleIdsNearTuples : number of components should be equal between this and other !");
3154   int nbOfTuplesOther=other->getNumberOfTuples();
3155   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> cArr(DataArrayInt::New()),cIArr(DataArrayInt::New()); cArr->alloc(0,1); cIArr->pushBackSilent(0);
3156   switch(nbOfCompo)
3157   {
3158     case 3:
3159       {
3160         BBTreePts<3,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
3161         FindTupleIdsNearTuplesAlg<3>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
3162         break;
3163       }
3164     case 2:
3165       {
3166         BBTreePts<2,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
3167         FindTupleIdsNearTuplesAlg<2>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
3168         break;
3169       }
3170     case 1:
3171       {
3172         BBTreePts<1,int> myTree(begin(),0,0,getNumberOfTuples(),eps);
3173         FindTupleIdsNearTuplesAlg<1>(myTree,other->getConstPointer(),nbOfTuplesOther,eps,cArr,cIArr);
3174         break;
3175       }
3176     default:
3177       throw INTERP_KERNEL::Exception("Unexpected spacedim of coords for computeTupleIdsNearTuples. Must be 1, 2 or 3.");
3178   }
3179   c=cArr.retn(); cI=cIArr.retn();
3180 }
3181
3182 /*!
3183  * This method recenter tuples in \b this in order to be centered at the origin to benefit about the advantages of maximal precision to be around the box
3184  * around origin of 'radius' 1.
3185  *
3186  * \param [in] eps absolute epsilon. under that value of delta between max and min no scale is performed.
3187  */
3188 void DataArrayDouble::recenterForMaxPrecision(double eps)
3189 {
3190   checkAllocated();
3191   int dim=getNumberOfComponents();
3192   std::vector<double> bounds(2*dim);
3193   getMinMaxPerComponent(&bounds[0]);
3194   for(int i=0;i<dim;i++)
3195     {
3196       double delta=bounds[2*i+1]-bounds[2*i];
3197       double offset=(bounds[2*i]+bounds[2*i+1])/2.;
3198       if(delta>eps)
3199         applyLin(1./delta,-offset/delta,i);
3200       else
3201         applyLin(1.,-offset,i);
3202     }
3203 }
3204
3205 /*!
3206  * Returns the maximal value and its location within \a this one-dimensional array.
3207  *  \param [out] tupleId - index of the tuple holding the maximal value.
3208  *  \return double - the maximal value among all values of \a this array.
3209  *  \throw If \a this->getNumberOfComponents() != 1
3210  *  \throw If \a this->getNumberOfTuples() < 1
3211  */
3212 double DataArrayDouble::getMaxValue(int& tupleId) const
3213 {
3214   checkAllocated();
3215   if(getNumberOfComponents()!=1)
3216     throw INTERP_KERNEL::Exception("DataArrayDouble::getMaxValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before or call 'getMaxValueInArray' method !");
3217   int nbOfTuples=getNumberOfTuples();
3218   if(nbOfTuples<=0)
3219     throw INTERP_KERNEL::Exception("DataArrayDouble::getMaxValue : array exists but number of tuples must be > 0 !");
3220   const double *vals=getConstPointer();
3221   const double *loc=std::max_element(vals,vals+nbOfTuples);
3222   tupleId=(int)std::distance(vals,loc);
3223   return *loc;
3224 }
3225
3226 /*!
3227  * Returns the maximal value within \a this array that is allowed to have more than
3228  *  one component.
3229  *  \return double - the maximal value among all values of \a this array.
3230  *  \throw If \a this is not allocated.
3231  */
3232 double DataArrayDouble::getMaxValueInArray() const
3233 {
3234   checkAllocated();
3235   const double *loc=std::max_element(begin(),end());
3236   return *loc;
3237 }
3238
3239 /*!
3240  * Returns the maximal value and all its locations within \a this one-dimensional array.
3241  *  \param [out] tupleIds - a new instance of DataArrayInt containg indices of
3242  *               tuples holding the maximal value. The caller is to delete it using
3243  *               decrRef() as it is no more needed.
3244  *  \return double - the maximal value among all values of \a this array.
3245  *  \throw If \a this->getNumberOfComponents() != 1
3246  *  \throw If \a this->getNumberOfTuples() < 1
3247  */
3248 double DataArrayDouble::getMaxValue2(DataArrayInt*& tupleIds) const
3249 {
3250   int tmp;
3251   tupleIds=0;
3252   double ret=getMaxValue(tmp);
3253   tupleIds=getIdsInRange(ret,ret);
3254   return ret;
3255 }
3256
3257 /*!
3258  * Returns the minimal value and its location within \a this one-dimensional array.
3259  *  \param [out] tupleId - index of the tuple holding the minimal value.
3260  *  \return double - the minimal value among all values of \a this array.
3261  *  \throw If \a this->getNumberOfComponents() != 1
3262  *  \throw If \a this->getNumberOfTuples() < 1
3263  */
3264 double DataArrayDouble::getMinValue(int& tupleId) const
3265 {
3266   checkAllocated();
3267   if(getNumberOfComponents()!=1)
3268     throw INTERP_KERNEL::Exception("DataArrayDouble::getMinValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before call 'getMinValueInArray' method !");
3269   int nbOfTuples=getNumberOfTuples();
3270   if(nbOfTuples<=0)
3271     throw INTERP_KERNEL::Exception("DataArrayDouble::getMinValue : array exists but number of tuples must be > 0 !");
3272   const double *vals=getConstPointer();
3273   const double *loc=std::min_element(vals,vals+nbOfTuples);
3274   tupleId=(int)std::distance(vals,loc);
3275   return *loc;
3276 }
3277
3278 /*!
3279  * Returns the minimal value within \a this array that is allowed to have more than
3280  *  one component.
3281  *  \return double - the minimal value among all values of \a this array.
3282  *  \throw If \a this is not allocated.
3283  */
3284 double DataArrayDouble::getMinValueInArray() const
3285 {
3286   checkAllocated();
3287   const double *loc=std::min_element(begin(),end());
3288   return *loc;
3289 }
3290
3291 /*!
3292  * Returns the minimal value and all its locations within \a this one-dimensional array.
3293  *  \param [out] tupleIds - a new instance of DataArrayInt containg indices of
3294  *               tuples holding the minimal value. The caller is to delete it using
3295  *               decrRef() as it is no more needed.
3296  *  \return double - the minimal value among all values of \a this array.
3297  *  \throw If \a this->getNumberOfComponents() != 1
3298  *  \throw If \a this->getNumberOfTuples() < 1
3299  */
3300 double DataArrayDouble::getMinValue2(DataArrayInt*& tupleIds) const
3301 {
3302   int tmp;
3303   tupleIds=0;
3304   double ret=getMinValue(tmp);
3305   tupleIds=getIdsInRange(ret,ret);
3306   return ret;
3307 }
3308
3309 /*!
3310  * This method returns the number of values in \a this that are equals ( within an absolute precision of \a eps ) to input parameter \a value.
3311  * This method only works for single component array.
3312  *
3313  * \return a value in [ 0, \c this->getNumberOfTuples() )
3314  *
3315  * \throw If \a this is not allocated
3316  *
3317  */
3318 int DataArrayDouble::count(double value, double eps) const
3319 {
3320   int ret=0;
3321   checkAllocated();
3322   if(getNumberOfComponents()!=1)
3323     throw INTERP_KERNEL::Exception("DataArrayDouble::count : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
3324   const double *vals=begin();
3325   int nbOfTuples=getNumberOfTuples();
3326   for(int i=0;i<nbOfTuples;i++,vals++)
3327     if(fabs(*vals-value)<=eps)
3328       ret++;
3329   return ret;
3330 }
3331
3332 /*!
3333  * Returns the average value of \a this one-dimensional array.
3334  *  \return double - the average value over all values of \a this array.
3335  *  \throw If \a this->getNumberOfComponents() != 1
3336  *  \throw If \a this->getNumberOfTuples() < 1
3337  */
3338 double DataArrayDouble::getAverageValue() const
3339 {
3340   if(getNumberOfComponents()!=1)
3341     throw INTERP_KERNEL::Exception("DataArrayDouble::getAverageValue : must be applied on DataArrayDouble with only one component, you can call 'rearrange' method before !");
3342   int nbOfTuples=getNumberOfTuples();
3343   if(nbOfTuples<=0)
3344     throw INTERP_KERNEL::Exception("DataArrayDouble::getAverageValue : array exists but number of tuples must be > 0 !");
3345   const double *vals=getConstPointer();
3346   double ret=std::accumulate(vals,vals+nbOfTuples,0.);
3347   return ret/nbOfTuples;
3348 }
3349
3350 /*!
3351  * Returns the Euclidean norm of the vector defined by \a this array.
3352  *  \return double - the value of the Euclidean norm, i.e.
3353  *          the square root of the inner product of vector.
3354  *  \throw If \a this is not allocated.
3355  */
3356 double DataArrayDouble::norm2() const
3357 {
3358   checkAllocated();
3359   double ret=0.;
3360   std::size_t nbOfElems=getNbOfElems();
3361   const double *pt=getConstPointer();
3362   for(std::size_t i=0;i<nbOfElems;i++,pt++)
3363     ret+=(*pt)*(*pt);
3364   return sqrt(ret);
3365 }
3366
3367 /*!
3368  * Returns the maximum norm of the vector defined by \a this array.
3369  * This method works even if the number of components is diferent from one.
3370  * If the number of elements in \a this is 0, -1. is returned.
3371  *  \return double - the value of the maximum norm, i.e.
3372  *          the maximal absolute value among values of \a this array (whatever its number of components).
3373  *  \throw If \a this is not allocated.
3374  */
3375 double DataArrayDouble::normMax() const
3376 {
3377   checkAllocated();
3378   double ret(-1.);
3379   std::size_t nbOfElems(getNbOfElems());
3380   const double *pt(getConstPointer());
3381   for(std::size_t i=0;i<nbOfElems;i++,pt++)
3382     {
3383       double val(std::abs(*pt));
3384       if(val>ret)
3385         ret=val;
3386     }
3387   return ret;
3388 }
3389
3390 /*!
3391  * Returns the minimum norm (absolute value) of the vector defined by \a this array.
3392  * This method works even if the number of components is diferent from one.
3393  * If the number of elements in \a this is 0, std::numeric_limits<double>::max() is returned.
3394  *  \return double - the value of the minimum norm, i.e.
3395  *          the minimal absolute value among values of \a this array (whatever its number of components).
3396  *  \throw If \a this is not allocated.
3397  */
3398 double DataArrayDouble::normMin() const
3399 {
3400   checkAllocated();
3401   double ret(std::numeric_limits<double>::max());
3402   std::size_t nbOfElems(getNbOfElems());
3403   const double *pt(getConstPointer());
3404   for(std::size_t i=0;i<nbOfElems;i++,pt++)
3405     {
3406       double val(std::abs(*pt));
3407       if(val<ret)
3408         ret=val;
3409     }
3410   return ret;
3411 }
3412
3413 /*!
3414  * Accumulates values of each component of \a this array.
3415  *  \param [out] res - an array of length \a this->getNumberOfComponents(), allocated
3416  *         by the caller, that is filled by this method with sum value for each
3417  *         component.
3418  *  \throw If \a this is not allocated.
3419  */
3420 void DataArrayDouble::accumulate(double *res) const
3421 {
3422   checkAllocated();
3423   const double *ptr=getConstPointer();
3424   int nbTuple=getNumberOfTuples();
3425   int nbComps=getNumberOfComponents();
3426   std::fill(res,res+nbComps,0.);
3427   for(int i=0;i<nbTuple;i++)
3428     std::transform(ptr+i*nbComps,ptr+(i+1)*nbComps,res,res,std::plus<double>());
3429 }
3430
3431 /*!
3432  * This method returns the min distance from an external tuple defined by [ \a tupleBg , \a tupleEnd ) to \a this and
3433  * the first tuple in \a this that matches the returned distance. If there is no tuples in \a this an exception will be thrown.
3434  *
3435  *
3436  * \a this is expected to be allocated and expected to have a number of components equal to the distance from \a tupleBg to
3437  * \a tupleEnd. If not an exception will be thrown.
3438  *
3439  * \param [in] tupleBg start pointer (included) of input external tuple
3440  * \param [in] tupleEnd end pointer (not included) of input external tuple
3441  * \param [out] tupleId the tuple id in \a this that matches the min of distance between \a this and input external tuple
3442  * \return the min distance.
3443  * \sa MEDCouplingUMesh::distanceToPoint
3444  */
3445 double DataArrayDouble::distanceToTuple(const double *tupleBg, const double *tupleEnd, int& tupleId) const
3446 {
3447   checkAllocated();
3448   int nbTuple=getNumberOfTuples();
3449   int nbComps=getNumberOfComponents();
3450   if(nbComps!=(int)std::distance(tupleBg,tupleEnd))
3451     { std::ostringstream oss; oss << "DataArrayDouble::distanceToTuple : size of input tuple is " << std::distance(tupleBg,tupleEnd) << " should be equal to the number of components in this : " << nbComps << " !"; throw INTERP_KERNEL::Exception(oss.str().c_str()); }
3452   if(nbTuple==0)
3453     throw INTERP_KERNEL::Exception("DataArrayDouble::distanceToTuple : no tuple in this ! No distance to compute !");
3454   double ret0=std::numeric_limits<double>::max();
3455   tupleId=-1;
3456   const double *work=getConstPointer();
3457   for(int i=0;i<nbTuple;i++)
3458     {
3459       double val=0.;
3460       for(int j=0;j<nbComps;j++,work++)
3461         val+=(*work-tupleBg[j])*((*work-tupleBg[j]));
3462       if(val>=ret0)
3463         continue;
3464       else
3465         { ret0=val; tupleId=i; }
3466     }
3467   return sqrt(ret0);
3468 }
3469
3470 /*!
3471  * Accumulate values of the given component of \a this array.
3472  *  \param [in] compId - the index of the component of interest.
3473  *  \return double - a sum value of \a compId-th component.
3474  *  \throw If \a this is not allocated.
3475  *  \throw If \a the condition ( 0 <= \a compId < \a this->getNumberOfComponents() ) is
3476  *         not respected.
3477  */
3478 double DataArrayDouble::accumulate(int compId) const
3479 {
3480   checkAllocated();
3481   const double *ptr=getConstPointer();
3482   int nbTuple=getNumberOfTuples();
3483   int nbComps=getNumberOfComponents();
3484   if(compId<0 || compId>=nbComps)
3485     throw INTERP_KERNEL::Exception("DataArrayDouble::accumulate : Invalid compId specified : No such nb of components !");
3486   double ret=0.;
3487   for(int i=0;i<nbTuple;i++)
3488     ret+=ptr[i*nbComps+compId];
3489   return ret;
3490 }
3491
3492 /*!
3493  * This method accumulate using addition tuples in \a this using input index array [ \a bgOfIndex, \a endOfIndex ).
3494  * The returned array will have same number of components than \a this and number of tuples equal to
3495  * \c std::distance(bgOfIndex,endOfIndex) \b minus \b one.
3496  *
3497  * The input index array is expected to be ascendingly sorted in which the all referenced ids should be in [0, \c this->getNumberOfTuples).
3498  * This method is quite useful for users that need to put a field on cells to field on nodes on the same mesh without a need of conservation.
3499  *
3500  * \param [in] bgOfIndex - begin (included) of the input index array.
3501  * \param [in] endOfIndex - end (excluded) of the input index array.
3502  * \return DataArrayDouble * - the new instance having the same number of components than \a this.
3503  *
3504  * \throw If bgOfIndex or end is NULL.
3505  * \throw If input index array is not ascendingly sorted.
3506  * \throw If there is an id in [ \a bgOfIndex, \a endOfIndex ) not in [0, \c this->getNumberOfTuples).
3507  * \throw If std::distance(bgOfIndex,endOfIndex)==0.
3508  */
3509 DataArrayDouble *DataArrayDouble::accumulatePerChunck(const int *bgOfIndex, const int *endOfIndex) const
3510 {
3511   if(!bgOfIndex || !endOfIndex)
3512     throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : input pointer NULL !");
3513   checkAllocated();
3514   int nbCompo=getNumberOfComponents();
3515   int nbOfTuples=getNumberOfTuples();
3516   int sz=(int)std::distance(bgOfIndex,endOfIndex);
3517   if(sz<1)
3518     throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : invalid size of input index array !");
3519   sz--;
3520   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(sz,nbCompo);
3521   const int *w=bgOfIndex;
3522   if(*w<0 || *w>=nbOfTuples)
3523     throw INTERP_KERNEL::Exception("DataArrayDouble::accumulatePerChunck : The first element of the input index not in [0,nbOfTuples) !");
3524   const double *srcPt=begin()+(*w)*nbCompo;
3525   double *tmp=ret->getPointer();
3526   for(int i=0;i<sz;i++,tmp+=nbCompo,w++)
3527     {
3528       std::fill(tmp,tmp+nbCompo,0.);
3529       if(w[1]>=w[0])
3530         {
3531           for(int j=w[0];j<w[1];j++,srcPt+=nbCompo)
3532             {
3533               if(j>=0 && j<nbOfTuples)
3534                 std::transform(srcPt,srcPt+nbCompo,tmp,tmp,std::plus<double>());
3535               else
3536                 {
3537                   std::ostringstream oss; oss << "DataArrayDouble::accumulatePerChunck : At rank #" << i << " the input index array points to id " << j << " should be in [0," << nbOfTuples << ") !";
3538                   throw INTERP_KERNEL::Exception(oss.str().c_str());
3539                 }
3540             }
3541         }
3542       else
3543         {
3544           std::ostringstream oss; oss << "DataArrayDouble::accumulatePerChunck : At rank #" << i << " the input index array is not in ascendingly sorted.";
3545           throw INTERP_KERNEL::Exception(oss.str().c_str());
3546         }
3547     }
3548   ret->copyStringInfoFrom(*this);
3549   return ret.retn();
3550 }
3551
3552 /*!
3553  * Converts each 2D point defined by the tuple of \a this array from the Polar to the
3554  * Cartesian coordinate system. The two components of the tuple of \a this array are
3555  * considered to contain (1) radius and (2) angle of the point in the Polar CS.
3556  *  \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3557  *          contains X and Y coordinates of the point in the Cartesian CS. The caller
3558  *          is to delete this array using decrRef() as it is no more needed. The array
3559  *          does not contain any textual info on components.
3560  *  \throw If \a this->getNumberOfComponents() != 2.
3561  */
3562 DataArrayDouble *DataArrayDouble::fromPolarToCart() const
3563 {
3564   checkAllocated();
3565   int nbOfComp=getNumberOfComponents();
3566   if(nbOfComp!=2)
3567     throw INTERP_KERNEL::Exception("DataArrayDouble::fromPolarToCart : must be an array with exactly 2 components !");
3568   int nbOfTuple=getNumberOfTuples();
3569   DataArrayDouble *ret=DataArrayDouble::New();
3570   ret->alloc(nbOfTuple,2);
3571   double *w=ret->getPointer();
3572   const double *wIn=getConstPointer();
3573   for(int i=0;i<nbOfTuple;i++,w+=2,wIn+=2)
3574     {
3575       w[0]=wIn[0]*cos(wIn[1]);
3576       w[1]=wIn[0]*sin(wIn[1]);
3577     }
3578   return ret;
3579 }
3580
3581 /*!
3582  * Converts each 3D point defined by the tuple of \a this array from the Cylindrical to
3583  * the Cartesian coordinate system. The three components of the tuple of \a this array
3584  * are considered to contain (1) radius, (2) azimuth and (3) altitude of the point in
3585  * the Cylindrical CS.
3586  *  \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3587  *          contains X, Y and Z coordinates of the point in the Cartesian CS. The info
3588  *          on the third component is copied from \a this array. The caller
3589  *          is to delete this array using decrRef() as it is no more needed.
3590  *  \throw If \a this->getNumberOfComponents() != 3.
3591  */
3592 DataArrayDouble *DataArrayDouble::fromCylToCart() const
3593 {
3594   checkAllocated();
3595   int nbOfComp=getNumberOfComponents();
3596   if(nbOfComp!=3)
3597     throw INTERP_KERNEL::Exception("DataArrayDouble::fromCylToCart : must be an array with exactly 3 components !");
3598   int nbOfTuple=getNumberOfTuples();
3599   DataArrayDouble *ret=DataArrayDouble::New();
3600   ret->alloc(getNumberOfTuples(),3);
3601   double *w=ret->getPointer();
3602   const double *wIn=getConstPointer();
3603   for(int i=0;i<nbOfTuple;i++,w+=3,wIn+=3)
3604     {
3605       w[0]=wIn[0]*cos(wIn[1]);
3606       w[1]=wIn[0]*sin(wIn[1]);
3607       w[2]=wIn[2];
3608     }
3609   ret->setInfoOnComponent(2,getInfoOnComponent(2));
3610   return ret;
3611 }
3612
3613 /*!
3614  * Converts each 3D point defined by the tuple of \a this array from the Spherical to
3615  * the Cartesian coordinate system. The three components of the tuple of \a this array
3616  * are considered to contain (1) radius, (2) polar angle and (3) azimuthal angle of the
3617  * point in the Cylindrical CS.
3618  *  \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3619  *          contains X, Y and Z coordinates of the point in the Cartesian CS. The info
3620  *          on the third component is copied from \a this array. The caller
3621  *          is to delete this array using decrRef() as it is no more needed.
3622  *  \throw If \a this->getNumberOfComponents() != 3.
3623  */
3624 DataArrayDouble *DataArrayDouble::fromSpherToCart() const
3625 {
3626   checkAllocated();
3627   int nbOfComp=getNumberOfComponents();
3628   if(nbOfComp!=3)
3629     throw INTERP_KERNEL::Exception("DataArrayDouble::fromSpherToCart : must be an array with exactly 3 components !");
3630   int nbOfTuple=getNumberOfTuples();
3631   DataArrayDouble *ret=DataArrayDouble::New();
3632   ret->alloc(getNumberOfTuples(),3);
3633   double *w=ret->getPointer();
3634   const double *wIn=getConstPointer();
3635   for(int i=0;i<nbOfTuple;i++,w+=3,wIn+=3)
3636     {
3637       w[0]=wIn[0]*cos(wIn[2])*sin(wIn[1]);
3638       w[1]=wIn[0]*sin(wIn[2])*sin(wIn[1]);
3639       w[2]=wIn[0]*cos(wIn[1]);
3640     }
3641   return ret;
3642 }
3643
3644 /*!
3645  * Computes the doubly contracted product of every tensor defined by the tuple of \a this
3646  * array contating 6 components.
3647  *  \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3648  *          is calculated from the tuple <em>(t)</em> of \a this array as follows:
3649  *          \f$ t[0]^2+t[1]^2+t[2]^2+2*t[3]^2+2*t[4]^2+2*t[5]^2\f$.
3650  *         The caller is to delete this result array using decrRef() as it is no more needed.
3651  *  \throw If \a this->getNumberOfComponents() != 6.
3652  */
3653 DataArrayDouble *DataArrayDouble::doublyContractedProduct() const
3654 {
3655   checkAllocated();
3656   int nbOfComp=getNumberOfComponents();
3657   if(nbOfComp!=6)
3658     throw INTERP_KERNEL::Exception("DataArrayDouble::doublyContractedProduct : must be an array with exactly 6 components !");
3659   DataArrayDouble *ret=DataArrayDouble::New();
3660   int nbOfTuple=getNumberOfTuples();
3661   ret->alloc(nbOfTuple,1);
3662   const double *src=getConstPointer();
3663   double *dest=ret->getPointer();
3664   for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
3665     *dest=src[0]*src[0]+src[1]*src[1]+src[2]*src[2]+2.*src[3]*src[3]+2.*src[4]*src[4]+2.*src[5]*src[5];
3666   return ret;
3667 }
3668
3669 /*!
3670  * Computes the determinant of every square matrix defined by the tuple of \a this
3671  * array, which contains either 4, 6 or 9 components. The case of 6 components
3672  * corresponds to that of the upper triangular matrix.
3673  *  \return DataArrayDouble * - the new instance of DataArrayDouble, whose each tuple
3674  *          is the determinant of matrix of the corresponding tuple of \a this array.
3675  *          The caller is to delete this result array using decrRef() as it is no more
3676  *          needed.
3677  *  \throw If \a this->getNumberOfComponents() is not in [4,6,9].
3678  */
3679 DataArrayDouble *DataArrayDouble::determinant() const
3680 {
3681   checkAllocated();
3682   DataArrayDouble *ret=DataArrayDouble::New();
3683   int nbOfTuple=getNumberOfTuples();
3684   ret->alloc(nbOfTuple,1);
3685   const double *src=getConstPointer();
3686   double *dest=ret->getPointer();
3687   switch(getNumberOfComponents())
3688   {
3689     case 6:
3690       for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
3691         *dest=src[0]*src[1]*src[2]+2.*src[4]*src[5]*src[3]-src[0]*src[4]*src[4]-src[2]*src[3]*src[3]-src[1]*src[5]*src[5];
3692       return ret;
3693     case 4:
3694       for(int i=0;i<nbOfTuple;i++,dest++,src+=4)
3695         *dest=src[0]*src[3]-src[1]*src[2];
3696       return ret;
3697     case 9:
3698       for(int i=0;i<nbOfTuple;i++,dest++,src+=9)
3699         *dest=src[0]*src[4]*src[8]+src[1]*src[5]*src[6]+src[2]*src[3]*src[7]-src[0]*src[5]*src[7]-src[1]*src[3]*src[8]-src[2]*src[4]*src[6];
3700       return ret;
3701     default:
3702       ret->decrRef();
3703       throw INTERP_KERNEL::Exception("DataArrayDouble::determinant : Invalid number of components ! must be in 4,6,9 !");
3704   }
3705 }
3706
3707 /*!
3708  * Computes 3 eigenvalues of every upper triangular matrix defined by the tuple of
3709  * \a this array, which contains 6 components.
3710  *  \return DataArrayDouble * - the new instance of DataArrayDouble containing 3
3711  *          components, whose each tuple contains the eigenvalues of the matrix of
3712  *          corresponding tuple of \a this array.
3713  *          The caller is to delete this result array using decrRef() as it is no more
3714  *          needed.
3715  *  \throw If \a this->getNumberOfComponents() != 6.
3716  */
3717 DataArrayDouble *DataArrayDouble::eigenValues() const
3718 {
3719   checkAllocated();
3720   int nbOfComp=getNumberOfComponents();
3721   if(nbOfComp!=6)
3722     throw INTERP_KERNEL::Exception("DataArrayDouble::eigenValues : must be an array with exactly 6 components !");
3723   DataArrayDouble *ret=DataArrayDouble::New();
3724   int nbOfTuple=getNumberOfTuples();
3725   ret->alloc(nbOfTuple,3);
3726   const double *src=getConstPointer();
3727   double *dest=ret->getPointer();
3728   for(int i=0;i<nbOfTuple;i++,dest+=3,src+=6)
3729     INTERP_KERNEL::computeEigenValues6(src,dest);
3730   return ret;
3731 }
3732
3733 /*!
3734  * Computes 3 eigenvectors of every upper triangular matrix defined by the tuple of
3735  * \a this array, which contains 6 components.
3736  *  \return DataArrayDouble * - the new instance of DataArrayDouble containing 9
3737  *          components, whose each tuple contains 3 eigenvectors of the matrix of
3738  *          corresponding tuple of \a this array.
3739  *          The caller is to delete this result array using decrRef() as it is no more
3740  *          needed.
3741  *  \throw If \a this->getNumberOfComponents() != 6.
3742  */
3743 DataArrayDouble *DataArrayDouble::eigenVectors() const
3744 {
3745   checkAllocated();
3746   int nbOfComp=getNumberOfComponents();
3747   if(nbOfComp!=6)
3748     throw INTERP_KERNEL::Exception("DataArrayDouble::eigenVectors : must be an array with exactly 6 components !");
3749   DataArrayDouble *ret=DataArrayDouble::New();
3750   int nbOfTuple=getNumberOfTuples();
3751   ret->alloc(nbOfTuple,9);
3752   const double *src=getConstPointer();
3753   double *dest=ret->getPointer();
3754   for(int i=0;i<nbOfTuple;i++,src+=6)
3755     {
3756       double tmp[3];
3757       INTERP_KERNEL::computeEigenValues6(src,tmp);
3758       for(int j=0;j<3;j++,dest+=3)
3759         INTERP_KERNEL::computeEigenVectorForEigenValue6(src,tmp[j],1e-12,dest);
3760     }
3761   return ret;
3762 }
3763
3764 /*!
3765  * Computes the inverse matrix of every matrix defined by the tuple of \a this
3766  * array, which contains either 4, 6 or 9 components. The case of 6 components
3767  * corresponds to that of the upper triangular matrix.
3768  *  \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3769  *          same number of components as \a this one, whose each tuple is the inverse
3770  *          matrix of the matrix of corresponding tuple of \a this array.
3771  *          The caller is to delete this result array using decrRef() as it is no more
3772  *          needed.
3773  *  \throw If \a this->getNumberOfComponents() is not in [4,6,9].
3774  */
3775 DataArrayDouble *DataArrayDouble::inverse() const
3776 {
3777   checkAllocated();
3778   int nbOfComp=getNumberOfComponents();
3779   if(nbOfComp!=6 && nbOfComp!=9 && nbOfComp!=4)
3780     throw INTERP_KERNEL::Exception("DataArrayDouble::inversion : must be an array with 4,6 or 9 components !");
3781   DataArrayDouble *ret=DataArrayDouble::New();
3782   int nbOfTuple=getNumberOfTuples();
3783   ret->alloc(nbOfTuple,nbOfComp);
3784   const double *src=getConstPointer();
3785   double *dest=ret->getPointer();
3786   if(nbOfComp==6)
3787     for(int i=0;i<nbOfTuple;i++,dest+=6,src+=6)
3788       {
3789         double det=src[0]*src[1]*src[2]+2.*src[4]*src[5]*src[3]-src[0]*src[4]*src[4]-src[2]*src[3]*src[3]-src[1]*src[5]*src[5];
3790         dest[0]=(src[1]*src[2]-src[4]*src[4])/det;
3791         dest[1]=(src[0]*src[2]-src[5]*src[5])/det;
3792         dest[2]=(src[0]*src[1]-src[3]*src[3])/det;
3793         dest[3]=(src[5]*src[4]-src[3]*src[2])/det;
3794         dest[4]=(src[5]*src[3]-src[0]*src[4])/det;
3795         dest[5]=(src[3]*src[4]-src[1]*src[5])/det;
3796       }
3797   else if(nbOfComp==4)
3798     for(int i=0;i<nbOfTuple;i++,dest+=4,src+=4)
3799       {
3800         double det=src[0]*src[3]-src[1]*src[2];
3801         dest[0]=src[3]/det;
3802         dest[1]=-src[1]/det;
3803         dest[2]=-src[2]/det;
3804         dest[3]=src[0]/det;
3805       }
3806   else
3807     for(int i=0;i<nbOfTuple;i++,dest+=9,src+=9)
3808       {
3809         double det=src[0]*src[4]*src[8]+src[1]*src[5]*src[6]+src[2]*src[3]*src[7]-src[0]*src[5]*src[7]-src[1]*src[3]*src[8]-src[2]*src[4]*src[6];
3810         dest[0]=(src[4]*src[8]-src[7]*src[5])/det;
3811         dest[1]=(src[7]*src[2]-src[1]*src[8])/det;
3812         dest[2]=(src[1]*src[5]-src[4]*src[2])/det;
3813         dest[3]=(src[6]*src[5]-src[3]*src[8])/det;
3814         dest[4]=(src[0]*src[8]-src[6]*src[2])/det;
3815         dest[5]=(src[2]*src[3]-src[0]*src[5])/det;
3816         dest[6]=(src[3]*src[7]-src[6]*src[4])/det;
3817         dest[7]=(src[6]*src[1]-src[0]*src[7])/det;
3818         dest[8]=(src[0]*src[4]-src[1]*src[3])/det;
3819       }
3820   return ret;
3821 }
3822
3823 /*!
3824  * Computes the trace of every matrix defined by the tuple of \a this
3825  * array, which contains either 4, 6 or 9 components. The case of 6 components
3826  * corresponds to that of the upper triangular matrix.
3827  *  \return DataArrayDouble * - the new instance of DataArrayDouble containing
3828  *          1 component, whose each tuple is the trace of
3829  *          the matrix of corresponding tuple of \a this array.
3830  *          The caller is to delete this result array using decrRef() as it is no more
3831  *          needed.
3832  *  \throw If \a this->getNumberOfComponents() is not in [4,6,9].
3833  */
3834 DataArrayDouble *DataArrayDouble::trace() const
3835 {
3836   checkAllocated();
3837   int nbOfComp=getNumberOfComponents();
3838   if(nbOfComp!=6 && nbOfComp!=9 && nbOfComp!=4)
3839     throw INTERP_KERNEL::Exception("DataArrayDouble::trace : must be an array with 4,6 or 9 components !");
3840   DataArrayDouble *ret=DataArrayDouble::New();
3841   int nbOfTuple=getNumberOfTuples();
3842   ret->alloc(nbOfTuple,1);
3843   const double *src=getConstPointer();
3844   double *dest=ret->getPointer();
3845   if(nbOfComp==6)
3846     for(int i=0;i<nbOfTuple;i++,dest++,src+=6)
3847       *dest=src[0]+src[1]+src[2];
3848   else if(nbOfComp==4)
3849     for(int i=0;i<nbOfTuple;i++,dest++,src+=4)
3850       *dest=src[0]+src[3];
3851   else
3852     for(int i=0;i<nbOfTuple;i++,dest++,src+=9)
3853       *dest=src[0]+src[4]+src[8];
3854   return ret;
3855 }
3856
3857 /*!
3858  * Computes the stress deviator tensor of every stress tensor defined by the tuple of
3859  * \a this array, which contains 6 components.
3860  *  \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3861  *          same number of components and tuples as \a this array.
3862  *          The caller is to delete this result array using decrRef() as it is no more
3863  *          needed.
3864  *  \throw If \a this->getNumberOfComponents() != 6.
3865  */
3866 DataArrayDouble *DataArrayDouble::deviator() const
3867 {
3868   checkAllocated();
3869   int nbOfComp=getNumberOfComponents();
3870   if(nbOfComp!=6)
3871     throw INTERP_KERNEL::Exception("DataArrayDouble::deviator : must be an array with exactly 6 components !");
3872   DataArrayDouble *ret=DataArrayDouble::New();
3873   int nbOfTuple=getNumberOfTuples();
3874   ret->alloc(nbOfTuple,6);
3875   const double *src=getConstPointer();
3876   double *dest=ret->getPointer();
3877   for(int i=0;i<nbOfTuple;i++,dest+=6,src+=6)
3878     {
3879       double tr=(src[0]+src[1]+src[2])/3.;
3880       dest[0]=src[0]-tr;
3881       dest[1]=src[1]-tr;
3882       dest[2]=src[2]-tr;
3883       dest[3]=src[3];
3884       dest[4]=src[4];
3885       dest[5]=src[5];
3886     }
3887   return ret;
3888 }
3889
3890 /*!
3891  * Computes the magnitude of every vector defined by the tuple of
3892  * \a this array.
3893  *  \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3894  *          same number of tuples as \a this array and one component.
3895  *          The caller is to delete this result array using decrRef() as it is no more
3896  *          needed.
3897  *  \throw If \a this is not allocated.
3898  */
3899 DataArrayDouble *DataArrayDouble::magnitude() const
3900 {
3901   checkAllocated();
3902   int nbOfComp=getNumberOfComponents();
3903   DataArrayDouble *ret=DataArrayDouble::New();
3904   int nbOfTuple=getNumberOfTuples();
3905   ret->alloc(nbOfTuple,1);
3906   const double *src=getConstPointer();
3907   double *dest=ret->getPointer();
3908   for(int i=0;i<nbOfTuple;i++,dest++)
3909     {
3910       double sum=0.;
3911       for(int j=0;j<nbOfComp;j++,src++)
3912         sum+=(*src)*(*src);
3913       *dest=sqrt(sum);
3914     }
3915   return ret;
3916 }
3917
3918 /*!
3919  * Computes for each tuple the sum of number of components values in the tuple and return it.
3920  *
3921  * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3922  *          same number of tuples as \a this array and one component.
3923  *          The caller is to delete this result array using decrRef() as it is no more
3924  *          needed.
3925  *  \throw If \a this is not allocated.
3926  */
3927 DataArrayDouble *DataArrayDouble::sumPerTuple() const
3928 {
3929   checkAllocated();
3930   int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
3931   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret(DataArrayDouble::New());
3932   ret->alloc(nbOfTuple,1);
3933   const double *src(getConstPointer());
3934   double *dest(ret->getPointer());
3935   for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
3936     *dest=std::accumulate(src,src+nbOfComp,0.);
3937   return ret.retn();
3938 }
3939
3940 /*!
3941  * Computes the maximal value within every tuple of \a this array.
3942  *  \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3943  *          same number of tuples as \a this array and one component.
3944  *          The caller is to delete this result array using decrRef() as it is no more
3945  *          needed.
3946  *  \throw If \a this is not allocated.
3947  *  \sa DataArrayDouble::maxPerTupleWithCompoId
3948  */
3949 DataArrayDouble *DataArrayDouble::maxPerTuple() const
3950 {
3951   checkAllocated();
3952   int nbOfComp=getNumberOfComponents();
3953   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
3954   int nbOfTuple=getNumberOfTuples();
3955   ret->alloc(nbOfTuple,1);
3956   const double *src=getConstPointer();
3957   double *dest=ret->getPointer();
3958   for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
3959     *dest=*std::max_element(src,src+nbOfComp);
3960   return ret.retn();
3961 }
3962
3963 /*!
3964  * Computes the maximal value within every tuple of \a this array and it returns the first component
3965  * id for each tuple that corresponds to the maximal value within the tuple.
3966  *
3967  *  \param [out] compoIdOfMaxPerTuple - the new new instance of DataArrayInt containing the
3968  *          same number of tuples and only one component.
3969  *  \return DataArrayDouble * - the new instance of DataArrayDouble containing the
3970  *          same number of tuples as \a this array and one component.
3971  *          The caller is to delete this result array using decrRef() as it is no more
3972  *          needed.
3973  *  \throw If \a this is not allocated.
3974  *  \sa DataArrayDouble::maxPerTuple
3975  */
3976 DataArrayDouble *DataArrayDouble::maxPerTupleWithCompoId(DataArrayInt* &compoIdOfMaxPerTuple) const
3977 {
3978   checkAllocated();
3979   int nbOfComp=getNumberOfComponents();
3980   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret0=DataArrayDouble::New();
3981   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New();
3982   int nbOfTuple=getNumberOfTuples();
3983   ret0->alloc(nbOfTuple,1); ret1->alloc(nbOfTuple,1);
3984   const double *src=getConstPointer();
3985   double *dest=ret0->getPointer(); int *dest1=ret1->getPointer();
3986   for(int i=0;i<nbOfTuple;i++,dest++,dest1++,src+=nbOfComp)
3987     {
3988       const double *loc=std::max_element(src,src+nbOfComp);
3989       *dest=*loc;
3990       *dest1=(int)std::distance(src,loc);
3991     }
3992   compoIdOfMaxPerTuple=ret1.retn();
3993   return ret0.retn();
3994 }
3995
3996 /*!
3997  * This method returns a newly allocated DataArrayDouble instance having one component and \c this->getNumberOfTuples() * \c this->getNumberOfTuples() tuples.
3998  * \n This returned array contains the euclidian distance for each tuple in \a this.
3999  * \n So the returned array can be seen as a dense symmetrical matrix whose diagonal elements are equal to 0.
4000  * \n The returned array has only one component (and **not** \c this->getNumberOfTuples() components to avoid the useless memory consumption due to components info in returned DataArrayDouble)
4001  *
4002  * \warning use this method with care because it can leads to big amount of consumed memory !
4003  *
4004  * \return A newly allocated (huge) ParaMEDMEM::DataArrayDouble instance that the caller should deal with.
4005  *
4006  * \throw If \a this is not allocated.
4007  *
4008  * \sa DataArrayDouble::buildEuclidianDistanceDenseMatrixWith
4009  */
4010 DataArrayDouble *DataArrayDouble::buildEuclidianDistanceDenseMatrix() const
4011 {
4012   checkAllocated();
4013   int nbOfComp=getNumberOfComponents();
4014   int nbOfTuples=getNumberOfTuples();
4015   const double *inData=getConstPointer();
4016   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
4017   ret->alloc(nbOfTuples*nbOfTuples,1);
4018   double *outData=ret->getPointer();
4019   for(int i=0;i<nbOfTuples;i++)
4020     {
4021       outData[i*nbOfTuples+i]=0.;
4022       for(int j=i+1;j<nbOfTuples;j++)
4023         {
4024           double dist=0.;
4025           for(int k=0;k<nbOfComp;k++)
4026             { double delta=inData[i*nbOfComp+k]-inData[j*nbOfComp+k]; dist+=delta*delta; }
4027           dist=sqrt(dist);
4028           outData[i*nbOfTuples+j]=dist;
4029           outData[j*nbOfTuples+i]=dist;
4030         }
4031     }
4032   return ret.retn();
4033 }
4034
4035 /*!
4036  * This method returns a newly allocated DataArrayDouble instance having one component and \c this->getNumberOfTuples() * \c other->getNumberOfTuples() tuples.
4037  * \n This returned array contains the euclidian distance for each tuple in \a other with each tuple in \a this.
4038  * \n So the returned array can be seen as a dense rectangular matrix with \c other->getNumberOfTuples() rows and \c this->getNumberOfTuples() columns.
4039  * \n Output rectangular matrix is sorted along rows.
4040  * \n The returned array has only one component (and **not** \c this->getNumberOfTuples() components to avoid the useless memory consumption due to components info in returned DataArrayDouble)
4041  *
4042  * \warning use this method with care because it can leads to big amount of consumed memory !
4043  *
4044  * \param [in] other DataArrayDouble instance having same number of components than \a this.
4045  * \return A newly allocated (huge) ParaMEDMEM::DataArrayDouble instance that the caller should deal with.
4046  *
4047  * \throw If \a this is not allocated, or if \a other is null or if \a other is not allocated, or if number of components of \a other and \a this differs.
4048  *
4049  * \sa DataArrayDouble::buildEuclidianDistanceDenseMatrix
4050  */
4051 DataArrayDouble *DataArrayDouble::buildEuclidianDistanceDenseMatrixWith(const DataArrayDouble *other) const
4052 {
4053   if(!other)
4054     throw INTERP_KERNEL::Exception("DataArrayDouble::buildEuclidianDistanceDenseMatrixWith : input parameter is null !");
4055   checkAllocated();
4056   other->checkAllocated();
4057   int nbOfComp=getNumberOfComponents();
4058   int otherNbOfComp=other->getNumberOfComponents();
4059   if(nbOfComp!=otherNbOfComp)
4060     {
4061       std::ostringstream oss; oss << "DataArrayDouble::buildEuclidianDistanceDenseMatrixWith : this nb of compo=" << nbOfComp << " and other nb of compo=" << otherNbOfComp << ". It should match !";
4062       throw INTERP_KERNEL::Exception(oss.str().c_str());
4063     }
4064   int nbOfTuples=getNumberOfTuples();
4065   int otherNbOfTuples=other->getNumberOfTuples();
4066   const double *inData=getConstPointer();
4067   const double *inDataOther=other->getConstPointer();
4068   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
4069   ret->alloc(otherNbOfTuples*nbOfTuples,1);
4070   double *outData=ret->getPointer();
4071   for(int i=0;i<otherNbOfTuples;i++,inDataOther+=nbOfComp)
4072     {
4073       for(int j=0;j<nbOfTuples;j++)
4074         {
4075           double dist=0.;
4076           for(int k=0;k<nbOfComp;k++)
4077             { double delta=inDataOther[k]-inData[j*nbOfComp+k]; dist+=delta*delta; }
4078           dist=sqrt(dist);
4079           outData[i*nbOfTuples+j]=dist;
4080         }
4081     }
4082   return ret.retn();
4083 }
4084
4085 /*!
4086  * Sorts value within every tuple of \a this array.
4087  *  \param [in] asc - if \a true, the values are sorted in ascending order, else,
4088  *              in descending order.
4089  *  \throw If \a this is not allocated.
4090  */
4091 void DataArrayDouble::sortPerTuple(bool asc)
4092 {
4093   checkAllocated();
4094   double *pt=getPointer();
4095   int nbOfTuple=getNumberOfTuples();
4096   int nbOfComp=getNumberOfComponents();
4097   if(asc)
4098     for(int i=0;i<nbOfTuple;i++,pt+=nbOfComp)
4099       std::sort(pt,pt+nbOfComp);
4100   else
4101     for(int i=0;i<nbOfTuple;i++,pt+=nbOfComp)
4102       std::sort(pt,pt+nbOfComp,std::greater<double>());
4103   declareAsNew();
4104 }
4105
4106 /*!
4107  * Converts every value of \a this array to its absolute value.
4108  * \b WARNING this method is non const. If a new DataArrayDouble instance should be built containing the result of abs DataArrayDouble::computeAbs
4109  * should be called instead.
4110  *
4111  * \throw If \a this is not allocated.
4112  * \sa DataArrayDouble::computeAbs
4113  */
4114 void DataArrayDouble::abs()
4115 {
4116   checkAllocated();
4117   double *ptr(getPointer());
4118   std::size_t nbOfElems(getNbOfElems());
4119   std::transform(ptr,ptr+nbOfElems,ptr,std::ptr_fun<double,double>(fabs));
4120   declareAsNew();
4121 }
4122
4123 /*!
4124  * This method builds a new instance of \a this object containing the result of std::abs applied of all elements in \a this.
4125  * This method is a const method (that do not change any values in \a this) contrary to  DataArrayDouble::abs method.
4126  *
4127  * \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4128  *         same number of tuples and component as \a this array.
4129  *         The caller is to delete this result array using decrRef() as it is no more
4130  *         needed.
4131  * \throw If \a this is not allocated.
4132  * \sa DataArrayDouble::abs
4133  */
4134 DataArrayDouble *DataArrayDouble::computeAbs() const
4135 {
4136   checkAllocated();
4137   DataArrayDouble *newArr(DataArrayDouble::New());
4138   int nbOfTuples(getNumberOfTuples());
4139   int nbOfComp(getNumberOfComponents());
4140   newArr->alloc(nbOfTuples,nbOfComp);
4141   std::transform(begin(),end(),newArr->getPointer(),std::ptr_fun<double,double>(fabs));
4142   newArr->copyStringInfoFrom(*this);
4143   return newArr;
4144 }
4145
4146 /*!
4147  * Apply a linear function to a given component of \a this array, so that
4148  * an array element <em>(x)</em> becomes \f$ a * x + b \f$.
4149  *  \param [in] a - the first coefficient of the function.
4150  *  \param [in] b - the second coefficient of the function.
4151  *  \param [in] compoId - the index of component to modify.
4152  *  \throw If \a this is not allocated, or \a compoId is not in [0,\c this->getNumberOfComponents() ).
4153  */
4154 void DataArrayDouble::applyLin(double a, double b, int compoId)
4155 {
4156   checkAllocated();
4157   double *ptr(getPointer()+compoId);
4158   int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
4159   if(compoId<0 || compoId>=nbOfComp)
4160     {
4161       std::ostringstream oss; oss << "DataArrayDouble::applyLin : The compoId requested (" << compoId << ") is not valid ! Must be in [0," << nbOfComp << ") !";
4162       throw INTERP_KERNEL::Exception(oss.str().c_str());
4163     }
4164   for(int i=0;i<nbOfTuple;i++,ptr+=nbOfComp)
4165     *ptr=a*(*ptr)+b;
4166   declareAsNew();
4167 }
4168
4169 /*!
4170  * Apply a linear function to all elements of \a this array, so that
4171  * an element _x_ becomes \f$ a * x + b \f$.
4172  *  \param [in] a - the first coefficient of the function.
4173  *  \param [in] b - the second coefficient of the function.
4174  *  \throw If \a this is not allocated.
4175  */
4176 void DataArrayDouble::applyLin(double a, double b)
4177 {
4178   checkAllocated();
4179   double *ptr=getPointer();
4180   std::size_t nbOfElems=getNbOfElems();
4181   for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4182     *ptr=a*(*ptr)+b;
4183   declareAsNew();
4184 }
4185
4186 /*!
4187  * Modify all elements of \a this array, so that
4188  * an element _x_ becomes \f$ numerator / x \f$.
4189  *  \warning If an exception is thrown because of presence of 0.0 element in \a this
4190  *           array, all elements processed before detection of the zero element remain
4191  *           modified.
4192  *  \param [in] numerator - the numerator used to modify array elements.
4193  *  \throw If \a this is not allocated.
4194  *  \throw If there is an element equal to 0.0 in \a this array.
4195  */
4196 void DataArrayDouble::applyInv(double numerator)
4197 {
4198   checkAllocated();
4199   double *ptr=getPointer();
4200   std::size_t nbOfElems=getNbOfElems();
4201   for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4202     {
4203       if(std::abs(*ptr)>std::numeric_limits<double>::min())
4204         {
4205           *ptr=numerator/(*ptr);
4206         }
4207       else
4208         {
4209           std::ostringstream oss; oss << "DataArrayDouble::applyInv : presence of null value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
4210           oss << " !";
4211           throw INTERP_KERNEL::Exception(oss.str().c_str());
4212         }
4213     }
4214   declareAsNew();
4215 }
4216
4217 /*!
4218  * Returns a full copy of \a this array except that sign of all elements is reversed.
4219  *  \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4220  *          same number of tuples and component as \a this array.
4221  *          The caller is to delete this result array using decrRef() as it is no more
4222  *          needed.
4223  *  \throw If \a this is not allocated.
4224  */
4225 DataArrayDouble *DataArrayDouble::negate() const
4226 {
4227   checkAllocated();
4228   DataArrayDouble *newArr=DataArrayDouble::New();
4229   int nbOfTuples=getNumberOfTuples();
4230   int nbOfComp=getNumberOfComponents();
4231   newArr->alloc(nbOfTuples,nbOfComp);
4232   const double *cptr=getConstPointer();
4233   std::transform(cptr,cptr+nbOfTuples*nbOfComp,newArr->getPointer(),std::negate<double>());
4234   newArr->copyStringInfoFrom(*this);
4235   return newArr;
4236 }
4237
4238 /*!
4239  * Modify all elements of \a this array, so that
4240  * an element _x_ becomes <em> val ^ x </em>. Contrary to DataArrayInt::applyPow
4241  * all values in \a this have to be >= 0 if val is \b not integer.
4242  *  \param [in] val - the value used to apply pow on all array elements.
4243  *  \throw If \a this is not allocated.
4244  *  \warning If an exception is thrown because of presence of 0 element in \a this
4245  *           array and \a val is \b not integer, all elements processed before detection of the zero element remain
4246  *           modified.
4247  */
4248 void DataArrayDouble::applyPow(double val)
4249 {
4250   checkAllocated();
4251   double *ptr=getPointer();
4252   std::size_t nbOfElems=getNbOfElems();
4253   int val2=(int)val;
4254   bool isInt=((double)val2)==val;
4255   if(!isInt)
4256     {
4257       for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4258         {
4259           if(*ptr>=0)
4260             *ptr=pow(*ptr,val);
4261           else
4262             {
4263               std::ostringstream oss; oss << "DataArrayDouble::applyPow (double) : At elem # " << i << " value is " << *ptr << " ! must be >=0. !";
4264               throw INTERP_KERNEL::Exception(oss.str().c_str());
4265             }
4266         }
4267     }
4268   else
4269     {
4270       for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4271         *ptr=pow(*ptr,val2);
4272     }
4273   declareAsNew();
4274 }
4275
4276 /*!
4277  * Modify all elements of \a this array, so that
4278  * an element _x_ becomes \f$ val ^ x \f$.
4279  *  \param [in] val - the value used to apply pow on all array elements.
4280  *  \throw If \a this is not allocated.
4281  *  \throw If \a val < 0.
4282  *  \warning If an exception is thrown because of presence of 0 element in \a this
4283  *           array, all elements processed before detection of the zero element remain
4284  *           modified.
4285  */
4286 void DataArrayDouble::applyRPow(double val)
4287 {
4288   checkAllocated();
4289   if(val<0.)
4290     throw INTERP_KERNEL::Exception("DataArrayDouble::applyRPow : the input value has to be >= 0 !");
4291   double *ptr=getPointer();
4292   std::size_t nbOfElems=getNbOfElems();
4293   for(std::size_t i=0;i<nbOfElems;i++,ptr++)
4294     *ptr=pow(val,*ptr);
4295   declareAsNew();
4296 }
4297
4298 /*!
4299  * Returns a new DataArrayDouble created from \a this one by applying \a
4300  * FunctionToEvaluate to every tuple of \a this array. Textual data is not copied.
4301  * For more info see \ref MEDCouplingArrayApplyFunc
4302  *  \param [in] nbOfComp - number of components in the result array.
4303  *  \param [in] func - the \a FunctionToEvaluate declared as
4304  *              \c bool (*\a func)(\c const \c double *\a pos, \c double *\a res),
4305  *              where \a pos points to the first component of a tuple of \a this array
4306  *              and \a res points to the first component of a tuple of the result array.
4307  *              Note that length (number of components) of \a pos can differ from
4308  *              that of \a res.
4309  *  \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4310  *          same number of tuples as \a this array.
4311  *          The caller is to delete this result array using decrRef() as it is no more
4312  *          needed.
4313  *  \throw If \a this is not allocated.
4314  *  \throw If \a func returns \a false.
4315  */
4316 DataArrayDouble *DataArrayDouble::applyFunc(int nbOfComp, FunctionToEvaluate func) const
4317 {
4318   checkAllocated();
4319   DataArrayDouble *newArr=DataArrayDouble::New();
4320   int nbOfTuples=getNumberOfTuples();
4321   int oldNbOfComp=getNumberOfComponents();
4322   newArr->alloc(nbOfTuples,nbOfComp);
4323   const double *ptr=getConstPointer();
4324   double *ptrToFill=newArr->getPointer();
4325   for(int i=0;i<nbOfTuples;i++)
4326     {
4327       if(!func(ptr+i*oldNbOfComp,ptrToFill+i*nbOfComp))
4328         {
4329           std::ostringstream oss; oss << "For tuple # " << i << " with value (";
4330           std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
4331           oss << ") : Evaluation of function failed !";
4332           newArr->decrRef();
4333           throw INTERP_KERNEL::Exception(oss.str().c_str());
4334         }
4335     }
4336   return newArr;
4337 }
4338
4339 /*!
4340  * Returns a new DataArrayDouble created from \a this one by applying a function to every
4341  * tuple of \a this array. Textual data is not copied.
4342  * For more info see \ref MEDCouplingArrayApplyFunc1.
4343  *  \param [in] nbOfComp - number of components in the result array.
4344  *  \param [in] func - the expression defining how to transform a tuple of \a this array.
4345  *              Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4346  *  \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
4347  *              If false the computation is carried on without any notification. When false the evaluation is a little faster.
4348  *  \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4349  *          same number of tuples as \a this array and \a nbOfComp components.
4350  *          The caller is to delete this result array using decrRef() as it is no more
4351  *          needed.
4352  *  \throw If \a this is not allocated.
4353  *  \throw If computing \a func fails.
4354  */
4355 DataArrayDouble *DataArrayDouble::applyFunc(int nbOfComp, const std::string& func, bool isSafe) const
4356 {
4357   INTERP_KERNEL::ExprParser expr(func);
4358   expr.parse();
4359   std::set<std::string> vars;
4360   expr.getTrueSetOfVars(vars);
4361   std::vector<std::string> varsV(vars.begin(),vars.end());
4362   return applyFunc3(nbOfComp,varsV,func,isSafe);
4363 }
4364
4365 /*!
4366  * Returns a new DataArrayDouble created from \a this one by applying a function to every
4367  * tuple of \a this array. Textual data is not copied. This method works by tuples (whatever its size).
4368  * If \a this is a one component array, call applyFuncOnThis instead that performs the same work faster.
4369  *
4370  * For more info see \ref MEDCouplingArrayApplyFunc0.
4371  *  \param [in] func - the expression defining how to transform a tuple of \a this array.
4372  *              Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4373  *  \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
4374  *                       If false the computation is carried on without any notification. When false the evaluation is a little faster.
4375  *  \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4376  *          same number of tuples and components as \a this array.
4377  *          The caller is to delete this result array using decrRef() as it is no more
4378  *          needed.
4379  *  \sa applyFuncOnThis
4380  *  \throw If \a this is not allocated.
4381  *  \throw If computing \a func fails.
4382  */
4383 DataArrayDouble *DataArrayDouble::applyFunc(const std::string& func, bool isSafe) const
4384 {
4385   int nbOfComp(getNumberOfComponents());
4386   if(nbOfComp<=0)
4387     throw INTERP_KERNEL::Exception("DataArrayDouble::applyFunc : output number of component must be > 0 !");
4388   checkAllocated();
4389   int nbOfTuples(getNumberOfTuples());
4390   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> newArr(DataArrayDouble::New());
4391   newArr->alloc(nbOfTuples,nbOfComp);
4392   INTERP_KERNEL::ExprParser expr(func);
4393   expr.parse();
4394   std::set<std::string> vars;
4395   expr.getTrueSetOfVars(vars);
4396   if((int)vars.size()>1)
4397     {
4398       std::ostringstream oss; oss << "DataArrayDouble::applyFunc : this method works only with at most one var func expression ! If you need to map comps on variables please use applyFunc2 or applyFunc3 instead ! Vars in expr are : ";
4399       std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
4400       throw INTERP_KERNEL::Exception(oss.str().c_str());
4401     }
4402   if(vars.empty())
4403     {
4404       expr.prepareFastEvaluator();
4405       newArr->rearrange(1);
4406       newArr->fillWithValue(expr.evaluateDouble());
4407       newArr->rearrange(nbOfComp);
4408       return newArr.retn();
4409     }
4410   std::vector<std::string> vars2(vars.begin(),vars.end());
4411   double buff,*ptrToFill(newArr->getPointer());
4412   const double *ptr(begin());
4413   std::vector<double> stck;
4414   expr.prepareExprEvaluationDouble(vars2,1,1,0,&buff,&buff+1);
4415   expr.prepareFastEvaluator();
4416   if(!isSafe)
4417     {
4418       for(int i=0;i<nbOfTuples;i++)
4419         {
4420           for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
4421             {
4422               buff=*ptr;
4423               expr.evaluateDoubleInternal(stck);
4424               *ptrToFill=stck.back();
4425               stck.pop_back();
4426             }
4427         }
4428     }
4429   else
4430     {
4431       for(int i=0;i<nbOfTuples;i++)
4432         {
4433           for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
4434             {
4435               buff=*ptr;
4436               try
4437               {
4438                   expr.evaluateDoubleInternalSafe(stck);
4439               }
4440               catch(INTERP_KERNEL::Exception& e)
4441               {
4442                   std::ostringstream oss; oss << "For tuple # " << i << " component # " << iComp << " with value (";
4443                   oss << buff;
4444                   oss << ") : Evaluation of function failed !" << e.what();
4445                   throw INTERP_KERNEL::Exception(oss.str().c_str());
4446               }
4447               *ptrToFill=stck.back();
4448               stck.pop_back();
4449             }
4450         }
4451     }
4452   return newArr.retn();
4453 }
4454
4455 /*!
4456  * This method is a non const method that modify the array in \a this.
4457  * This method only works on one component array. It means that function \a func must
4458  * contain at most one variable.
4459  * This method is a specialization of applyFunc method with one parameter on one component array.
4460  *
4461  *  \param [in] func - the expression defining how to transform a tuple of \a this array.
4462  *              Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4463  *  \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
4464  *              If false the computation is carried on without any notification. When false the evaluation is a little faster.
4465  *
4466  * \sa applyFunc
4467  */
4468 void DataArrayDouble::applyFuncOnThis(const std::string& func, bool isSafe)
4469 {
4470   int nbOfComp(getNumberOfComponents());
4471   if(nbOfComp<=0)
4472     throw INTERP_KERNEL::Exception("DataArrayDouble::applyFuncOnThis : output number of component must be > 0 !");
4473   checkAllocated();
4474   int nbOfTuples(getNumberOfTuples());
4475   INTERP_KERNEL::ExprParser expr(func);
4476   expr.parse();
4477   std::set<std::string> vars;
4478   expr.getTrueSetOfVars(vars);
4479   if((int)vars.size()>1)
4480     {
4481       std::ostringstream oss; oss << "DataArrayDouble::applyFuncOnThis : this method works only with at most one var func expression ! If you need to map comps on variables please use applyFunc2 or applyFunc3 instead ! Vars in expr are : ";
4482       std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
4483       throw INTERP_KERNEL::Exception(oss.str().c_str());
4484     }
4485   if(vars.empty())
4486     {
4487       expr.prepareFastEvaluator();
4488       std::vector<std::string> compInfo(getInfoOnComponents());
4489       rearrange(1);
4490       fillWithValue(expr.evaluateDouble());
4491       rearrange(nbOfComp);
4492       setInfoOnComponents(compInfo);
4493       return ;
4494     }
4495   std::vector<std::string> vars2(vars.begin(),vars.end());
4496   double buff,*ptrToFill(getPointer());
4497   const double *ptr(begin());
4498   std::vector<double> stck;
4499   expr.prepareExprEvaluationDouble(vars2,1,1,0,&buff,&buff+1);
4500   expr.prepareFastEvaluator();
4501   if(!isSafe)
4502     {
4503       for(int i=0;i<nbOfTuples;i++)
4504         {
4505           for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
4506             {
4507               buff=*ptr;
4508               expr.evaluateDoubleInternal(stck);
4509               *ptrToFill=stck.back();
4510               stck.pop_back();
4511             }
4512         }
4513     }
4514   else
4515     {
4516       for(int i=0;i<nbOfTuples;i++)
4517         {
4518           for(int iComp=0;iComp<nbOfComp;iComp++,ptr++,ptrToFill++)
4519             {
4520               buff=*ptr;
4521               try
4522               {
4523                   expr.evaluateDoubleInternalSafe(stck);
4524               }
4525               catch(INTERP_KERNEL::Exception& e)
4526               {
4527                   std::ostringstream oss; oss << "For tuple # " << i << " component # " << iComp << " with value (";
4528                   oss << buff;
4529                   oss << ") : Evaluation of function failed !" << e.what();
4530                   throw INTERP_KERNEL::Exception(oss.str().c_str());
4531               }
4532               *ptrToFill=stck.back();
4533               stck.pop_back();
4534             }
4535         }
4536     }
4537 }
4538
4539 /*!
4540  * Returns a new DataArrayDouble created from \a this one by applying a function to every
4541  * tuple of \a this array. Textual data is not copied.
4542  * For more info see \ref MEDCouplingArrayApplyFunc2.
4543  *  \param [in] nbOfComp - number of components in the result array.
4544  *  \param [in] func - the expression defining how to transform a tuple of \a this array.
4545  *              Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4546  *  \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
4547  *              If false the computation is carried on without any notification. When false the evaluation is a little faster.
4548  *  \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4549  *          same number of tuples as \a this array.
4550  *          The caller is to delete this result array using decrRef() as it is no more
4551  *          needed.
4552  *  \throw If \a this is not allocated.
4553  *  \throw If \a func contains vars that are not in \a this->getInfoOnComponent().
4554  *  \throw If computing \a func fails.
4555  */
4556 DataArrayDouble *DataArrayDouble::applyFunc2(int nbOfComp, const std::string& func, bool isSafe) const
4557 {
4558   return applyFunc3(nbOfComp,getVarsOnComponent(),func,isSafe);
4559 }
4560
4561 /*!
4562  * Returns a new DataArrayDouble created from \a this one by applying a function to every
4563  * tuple of \a this array. Textual data is not copied.
4564  * For more info see \ref MEDCouplingArrayApplyFunc3.
4565  *  \param [in] nbOfComp - number of components in the result array.
4566  *  \param [in] varsOrder - sequence of vars defining their order.
4567  *  \param [in] func - the expression defining how to transform a tuple of \a this array.
4568  *              Supported expressions are described \ref MEDCouplingArrayApplyFuncExpr "here".
4569  *  \param [in] isSafe - By default true. If true invalid operation (division by 0. acos of value > 1. ...) leads to a throw of an exception.
4570  *              If false the computation is carried on without any notification. When false the evaluation is a little faster.
4571  *  \return DataArrayDouble * - the new instance of DataArrayDouble containing the
4572  *          same number of tuples as \a this array.
4573  *          The caller is to delete this result array using decrRef() as it is no more
4574  *          needed.
4575  *  \throw If \a this is not allocated.
4576  *  \throw If \a func contains vars not in \a varsOrder.
4577  *  \throw If computing \a func fails.
4578  */
4579 DataArrayDouble *DataArrayDouble::applyFunc3(int nbOfComp, const std::vector<std::string>& varsOrder, const std::string& func, bool isSafe) const
4580 {
4581   if(nbOfComp<=0)
4582     throw INTERP_KERNEL::Exception("DataArrayDouble::applyFunc3 : output number of component must be > 0 !");
4583   std::vector<std::string> varsOrder2(varsOrder);
4584   int oldNbOfComp(getNumberOfComponents());
4585   for(int i=(int)varsOrder.size();i<oldNbOfComp;i++)
4586     varsOrder2.push_back(std::string());
4587   checkAllocated();
4588   int nbOfTuples(getNumberOfTuples());
4589   INTERP_KERNEL::ExprParser expr(func);
4590   expr.parse();
4591   std::set<std::string> vars;
4592   expr.getTrueSetOfVars(vars);
4593   if((int)vars.size()>oldNbOfComp)
4594     {
4595       std::ostringstream oss; oss << "The field has " << oldNbOfComp << " components and there are ";
4596       oss << vars.size() << " variables : ";
4597       std::copy(vars.begin(),vars.end(),std::ostream_iterator<std::string>(oss," "));
4598       throw INTERP_KERNEL::Exception(oss.str().c_str());
4599     }
4600   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> newArr(DataArrayDouble::New());
4601   newArr->alloc(nbOfTuples,nbOfComp);
4602   INTERP_KERNEL::AutoPtr<double> buff(new double[oldNbOfComp]);
4603   double *buffPtr(buff),*ptrToFill;
4604   std::vector<double> stck;
4605   for(int iComp=0;iComp<nbOfComp;iComp++)
4606     {
4607       expr.prepareExprEvaluationDouble(varsOrder2,oldNbOfComp,nbOfComp,iComp,buffPtr,buffPtr+oldNbOfComp);
4608       expr.prepareFastEvaluator();
4609       const double *ptr(getConstPointer());
4610       ptrToFill=newArr->getPointer()+iComp;
4611       if(!isSafe)
4612         {
4613           for(int i=0;i<nbOfTuples;i++,ptrToFill+=nbOfComp,ptr+=oldNbOfComp)
4614             {
4615               std::copy(ptr,ptr+oldNbOfComp,buffPtr);
4616               expr.evaluateDoubleInternal(stck);
4617               *ptrToFill=stck.back();
4618               stck.pop_back();
4619             }
4620         }
4621       else
4622         {
4623           for(int i=0;i<nbOfTuples;i++,ptrToFill+=nbOfComp,ptr+=oldNbOfComp)
4624             {
4625               std::copy(ptr,ptr+oldNbOfComp,buffPtr);
4626               try
4627               {
4628                   expr.evaluateDoubleInternalSafe(stck);
4629                   *ptrToFill=stck.back();
4630                   stck.pop_back();
4631               }
4632               catch(INTERP_KERNEL::Exception& e)
4633               {
4634                   std::ostringstream oss; oss << "For tuple # " << i << " with value (";
4635                   std::copy(ptr+oldNbOfComp*i,ptr+oldNbOfComp*(i+1),std::ostream_iterator<double>(oss,", "));
4636                   oss << ") : Evaluation of function failed !" << e.what();
4637                   throw INTERP_KERNEL::Exception(oss.str().c_str());
4638               }
4639             }
4640         }
4641     }
4642   return newArr.retn();
4643 }
4644
4645 void DataArrayDouble::applyFuncFast32(const std::string& func)
4646 {
4647   checkAllocated();
4648   INTERP_KERNEL::ExprParser expr(func);
4649   expr.parse();
4650   char *funcStr=expr.compileX86();
4651   MYFUNCPTR funcPtr;
4652   *((void **)&funcPtr)=funcStr;//he he...
4653   //
4654   double *ptr=getPointer();
4655   int nbOfComp=getNumberOfComponents();
4656   int nbOfTuples=getNumberOfTuples();
4657   int nbOfElems=nbOfTuples*nbOfComp;
4658   for(int i=0;i<nbOfElems;i++,ptr++)
4659     *ptr=funcPtr(*ptr);
4660   declareAsNew();
4661 }
4662
4663 void DataArrayDouble::applyFuncFast64(const std::string& func)
4664 {
4665   checkAllocated();
4666   INTERP_KERNEL::ExprParser expr(func);
4667   expr.parse();
4668   char *funcStr=expr.compileX86_64();
4669   MYFUNCPTR funcPtr;
4670   *((void **)&funcPtr)=funcStr;//he he...
4671   //
4672   double *ptr=getPointer();
4673   int nbOfComp=getNumberOfComponents();
4674   int nbOfTuples=getNumberOfTuples();
4675   int nbOfElems=nbOfTuples*nbOfComp;
4676   for(int i=0;i<nbOfElems;i++,ptr++)
4677     *ptr=funcPtr(*ptr);
4678   declareAsNew();
4679 }
4680
4681 DataArrayDoubleIterator *DataArrayDouble::iterator()
4682 {
4683   return new DataArrayDoubleIterator(this);
4684 }
4685
4686 /*!
4687  * Returns a new DataArrayInt contating indices of tuples of \a this one-dimensional
4688  * array whose values are within a given range. Textual data is not copied.
4689  *  \param [in] vmin - a lowest acceptable value (included).
4690  *  \param [in] vmax - a greatest acceptable value (included).
4691  *  \return DataArrayInt * - the new instance of DataArrayInt.
4692  *          The caller is to delete this result array using decrRef() as it is no more
4693  *          needed.
4694  *  \throw If \a this->getNumberOfComponents() != 1.
4695  *
4696  *  \sa DataArrayDouble::getIdsNotInRange
4697  *
4698  *  \if ENABLE_EXAMPLES
4699  *  \ref cpp_mcdataarraydouble_getidsinrange "Here is a C++ example".<br>
4700  *  \ref py_mcdataarraydouble_getidsinrange "Here is a Python example".
4701  *  \endif
4702  */
4703 DataArrayInt *DataArrayDouble::getIdsInRange(double vmin, double vmax) const
4704 {
4705   checkAllocated();
4706   if(getNumberOfComponents()!=1)
4707     throw INTERP_KERNEL::Exception("DataArrayDouble::getIdsInRange : this must have exactly one component !");
4708   const double *cptr(begin());
4709   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
4710   int nbOfTuples(getNumberOfTuples());
4711   for(int i=0;i<nbOfTuples;i++,cptr++)
4712     if(*cptr>=vmin && *cptr<=vmax)
4713       ret->pushBackSilent(i);
4714   return ret.retn();
4715 }
4716
4717 /*!
4718  * Returns a new DataArrayInt contating indices of tuples of \a this one-dimensional
4719  * array whose values are not within a given range. Textual data is not copied.
4720  *  \param [in] vmin - a lowest not acceptable value (excluded).
4721  *  \param [in] vmax - a greatest not acceptable value (excluded).
4722  *  \return DataArrayInt * - the new instance of DataArrayInt.
4723  *          The caller is to delete this result array using decrRef() as it is no more
4724  *          needed.
4725  *  \throw If \a this->getNumberOfComponents() != 1.
4726  *
4727  *  \sa DataArrayDouble::getIdsInRange
4728  */
4729 DataArrayInt *DataArrayDouble::getIdsNotInRange(double vmin, double vmax) const
4730 {
4731   checkAllocated();
4732   if(getNumberOfComponents()!=1)
4733     throw INTERP_KERNEL::Exception("DataArrayDouble::getIdsNotInRange : this must have exactly one component !");
4734   const double *cptr(begin());
4735   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
4736   int nbOfTuples(getNumberOfTuples());
4737   for(int i=0;i<nbOfTuples;i++,cptr++)
4738     if(*cptr<vmin || *cptr>vmax)
4739       ret->pushBackSilent(i);
4740   return ret.retn();
4741 }
4742
4743 /*!
4744  * Returns a new DataArrayDouble by concatenating two given arrays, so that (1) the number
4745  * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
4746  * the number of component in the result array is same as that of each of given arrays.
4747  * Info on components is copied from the first of the given arrays. Number of components
4748  * in the given arrays must be  the same.
4749  *  \param [in] a1 - an array to include in the result array.
4750  *  \param [in] a2 - another array to include in the result array.
4751  *  \return DataArrayDouble * - the new instance of DataArrayDouble.
4752  *          The caller is to delete this result array using decrRef() as it is no more
4753  *          needed.
4754  *  \throw If both \a a1 and \a a2 are NULL.
4755  *  \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents().
4756  */
4757 DataArrayDouble *DataArrayDouble::Aggregate(const DataArrayDouble *a1, const DataArrayDouble *a2)
4758 {
4759   std::vector<const DataArrayDouble *> tmp(2);
4760   tmp[0]=a1; tmp[1]=a2;
4761   return Aggregate(tmp);
4762 }
4763
4764 /*!
4765  * Returns a new DataArrayDouble by concatenating all given arrays, so that (1) the number
4766  * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
4767  * the number of component in the result array is same as that of each of given arrays.
4768  * Info on components is copied from the first of the given arrays. Number of components
4769  * in the given arrays must be  the same.
4770  * If the number of non null of elements in \a arr is equal to one the returned object is a copy of it
4771  * not the object itself.
4772  *  \param [in] arr - a sequence of arrays to include in the result array.
4773  *  \return DataArrayDouble * - the new instance of DataArrayDouble.
4774  *          The caller is to delete this result array using decrRef() as it is no more
4775  *          needed.
4776  *  \throw If all arrays within \a arr are NULL.
4777  *  \throw If getNumberOfComponents() of arrays within \a arr.
4778  */
4779 DataArrayDouble *DataArrayDouble::Aggregate(const std::vector<const DataArrayDouble *>& arr)
4780 {
4781   std::vector<const DataArrayDouble *> a;
4782   for(std::vector<const DataArrayDouble *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
4783     if(*it4)
4784       a.push_back(*it4);
4785   if(a.empty())
4786     throw INTERP_KERNEL::Exception("DataArrayDouble::Aggregate : input list must contain at least one NON EMPTY DataArrayDouble !");
4787   std::vector<const DataArrayDouble *>::const_iterator it=a.begin();
4788   int nbOfComp=(*it)->getNumberOfComponents();
4789   int nbt=(*it++)->getNumberOfTuples();
4790   for(int i=1;it!=a.end();it++,i++)
4791     {
4792       if((*it)->getNumberOfComponents()!=nbOfComp)
4793         throw INTERP_KERNEL::Exception("DataArrayDouble::Aggregate : Nb of components mismatch for array aggregation !");
4794       nbt+=(*it)->getNumberOfTuples();
4795     }
4796   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
4797   ret->alloc(nbt,nbOfComp);
4798   double *pt=ret->getPointer();
4799   for(it=a.begin();it!=a.end();it++)
4800     pt=std::copy((*it)->getConstPointer(),(*it)->getConstPointer()+(*it)->getNbOfElems(),pt);
4801   ret->copyStringInfoFrom(*(a[0]));
4802   return ret.retn();
4803 }
4804
4805 /*!
4806  * Returns a new DataArrayDouble by aggregating two given arrays, so that (1) the number
4807  * of components in the result array is a sum of the number of components of given arrays
4808  * and (2) the number of tuples in the result array is same as that of each of given
4809  * arrays. In other words the i-th tuple of result array includes all components of
4810  * i-th tuples of all given arrays.
4811  * Number of tuples in the given arrays must be  the same.
4812  *  \param [in] a1 - an array to include in the result array.
4813  *  \param [in] a2 - another array to include in the result array.
4814  *  \return DataArrayDouble * - the new instance of DataArrayDouble.
4815  *          The caller is to delete this result array using decrRef() as it is no more
4816  *          needed.
4817  *  \throw If both \a a1 and \a a2 are NULL.
4818  *  \throw If any given array is not allocated.
4819  *  \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4820  */
4821 DataArrayDouble *DataArrayDouble::Meld(const DataArrayDouble *a1, const DataArrayDouble *a2)
4822 {
4823   std::vector<const DataArrayDouble *> arr(2);
4824   arr[0]=a1; arr[1]=a2;
4825   return Meld(arr);
4826 }
4827
4828 /*!
4829  * Returns a new DataArrayDouble by aggregating all given arrays, so that (1) the number
4830  * of components in the result array is a sum of the number of components of given arrays
4831  * and (2) the number of tuples in the result array is same as that of each of given
4832  * arrays. In other words the i-th tuple of result array includes all components of
4833  * i-th tuples of all given arrays.
4834  * Number of tuples in the given arrays must be  the same.
4835  *  \param [in] arr - a sequence of arrays to include in the result array.
4836  *  \return DataArrayDouble * - the new instance of DataArrayDouble.
4837  *          The caller is to delete this result array using decrRef() as it is no more
4838  *          needed.
4839  *  \throw If all arrays within \a arr are NULL.
4840  *  \throw If any given array is not allocated.
4841  *  \throw If getNumberOfTuples() of arrays within \a arr is different.
4842  */
4843 DataArrayDouble *DataArrayDouble::Meld(const std::vector<const DataArrayDouble *>& arr)
4844 {
4845   std::vector<const DataArrayDouble *> a;
4846   for(std::vector<const DataArrayDouble *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
4847     if(*it4)
4848       a.push_back(*it4);
4849   if(a.empty())
4850     throw INTERP_KERNEL::Exception("DataArrayDouble::Meld : input list must contain at least one NON EMPTY DataArrayDouble !");
4851   std::vector<const DataArrayDouble *>::const_iterator it;
4852   for(it=a.begin();it!=a.end();it++)
4853     (*it)->checkAllocated();
4854   it=a.begin();
4855   int nbOfTuples=(*it)->getNumberOfTuples();
4856   std::vector<int> nbc(a.size());
4857   std::vector<const double *> pts(a.size());
4858   nbc[0]=(*it)->getNumberOfComponents();
4859   pts[0]=(*it++)->getConstPointer();
4860   for(int i=1;it!=a.end();it++,i++)
4861     {
4862       if(nbOfTuples!=(*it)->getNumberOfTuples())
4863         throw INTERP_KERNEL::Exception("DataArrayDouble::Meld : mismatch of number of tuples !");
4864       nbc[i]=(*it)->getNumberOfComponents();
4865       pts[i]=(*it)->getConstPointer();
4866     }
4867   int totalNbOfComp=std::accumulate(nbc.begin(),nbc.end(),0);
4868   DataArrayDouble *ret=DataArrayDouble::New();
4869   ret->alloc(nbOfTuples,totalNbOfComp);
4870   double *retPtr=ret->getPointer();
4871   for(int i=0;i<nbOfTuples;i++)
4872     for(int j=0;j<(int)a.size();j++)
4873       {
4874         retPtr=std::copy(pts[j],pts[j]+nbc[j],retPtr);
4875         pts[j]+=nbc[j];
4876       }
4877   int k=0;
4878   for(int i=0;i<(int)a.size();i++)
4879     for(int j=0;j<nbc[i];j++,k++)
4880       ret->setInfoOnComponent(k,a[i]->getInfoOnComponent(j));
4881   return ret;
4882 }
4883
4884 /*!
4885  * Returns a new DataArrayDouble containing a dot product of two given arrays, so that
4886  * the i-th tuple of the result array is a sum of products of j-th components of i-th
4887  * tuples of given arrays (\f$ a_i = \sum_{j=1}^n a1_j * a2_j \f$).
4888  * Info on components and name is copied from the first of the given arrays.
4889  * Number of tuples and components in the given arrays must be the same.
4890  *  \param [in] a1 - a given array.
4891  *  \param [in] a2 - another given array.
4892  *  \return DataArrayDouble * - the new instance of DataArrayDouble.
4893  *          The caller is to delete this result array using decrRef() as it is no more
4894  *          needed.
4895  *  \throw If either \a a1 or \a a2 is NULL.
4896  *  \throw If any given array is not allocated.
4897  *  \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4898  *  \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
4899  */
4900 DataArrayDouble *DataArrayDouble::Dot(const DataArrayDouble *a1, const DataArrayDouble *a2)
4901 {
4902   if(!a1 || !a2)
4903     throw INTERP_KERNEL::Exception("DataArrayDouble::Dot : input DataArrayDouble instance is NULL !");
4904   a1->checkAllocated();
4905   a2->checkAllocated();
4906   int nbOfComp=a1->getNumberOfComponents();
4907   if(nbOfComp!=a2->getNumberOfComponents())
4908     throw INTERP_KERNEL::Exception("Nb of components mismatch for array Dot !");
4909   int nbOfTuple=a1->getNumberOfTuples();
4910   if(nbOfTuple!=a2->getNumberOfTuples())
4911     throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Dot !");
4912   DataArrayDouble *ret=DataArrayDouble::New();
4913   ret->alloc(nbOfTuple,1);
4914   double *retPtr=ret->getPointer();
4915   const double *a1Ptr=a1->getConstPointer();
4916   const double *a2Ptr=a2->getConstPointer();
4917   for(int i=0;i<nbOfTuple;i++)
4918     {
4919       double sum=0.;
4920       for(int j=0;j<nbOfComp;j++)
4921         sum+=a1Ptr[i*nbOfComp+j]*a2Ptr[i*nbOfComp+j];
4922       retPtr[i]=sum;
4923     }
4924   ret->setInfoOnComponent(0,a1->getInfoOnComponent(0));
4925   ret->setName(a1->getName());
4926   return ret;
4927 }
4928
4929 /*!
4930  * Returns a new DataArrayDouble containing a cross product of two given arrays, so that
4931  * the i-th tuple of the result array contains 3 components of a vector which is a cross
4932  * product of two vectors defined by the i-th tuples of given arrays.
4933  * Info on components is copied from the first of the given arrays.
4934  * Number of tuples in the given arrays must be the same.
4935  * Number of components in the given arrays must be 3.
4936  *  \param [in] a1 - a given array.
4937  *  \param [in] a2 - another given array.
4938  *  \return DataArrayDouble * - the new instance of DataArrayDouble.
4939  *          The caller is to delete this result array using decrRef() as it is no more
4940  *          needed.
4941  *  \throw If either \a a1 or \a a2 is NULL.
4942  *  \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4943  *  \throw If \a a1->getNumberOfComponents() != 3
4944  *  \throw If \a a2->getNumberOfComponents() != 3
4945  */
4946 DataArrayDouble *DataArrayDouble::CrossProduct(const DataArrayDouble *a1, const DataArrayDouble *a2)
4947 {
4948   if(!a1 || !a2)
4949     throw INTERP_KERNEL::Exception("DataArrayDouble::CrossProduct : input DataArrayDouble instance is NULL !");
4950   int nbOfComp=a1->getNumberOfComponents();
4951   if(nbOfComp!=a2->getNumberOfComponents())
4952     throw INTERP_KERNEL::Exception("Nb of components mismatch for array crossProduct !");
4953   if(nbOfComp!=3)
4954     throw INTERP_KERNEL::Exception("Nb of components must be equal to 3 for array crossProduct !");
4955   int nbOfTuple=a1->getNumberOfTuples();
4956   if(nbOfTuple!=a2->getNumberOfTuples())
4957     throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array crossProduct !");
4958   DataArrayDouble *ret=DataArrayDouble::New();
4959   ret->alloc(nbOfTuple,3);
4960   double *retPtr=ret->getPointer();
4961   const double *a1Ptr=a1->getConstPointer();
4962   const double *a2Ptr=a2->getConstPointer();
4963   for(int i=0;i<nbOfTuple;i++)
4964     {
4965       retPtr[3*i]=a1Ptr[3*i+1]*a2Ptr[3*i+2]-a1Ptr[3*i+2]*a2Ptr[3*i+1];
4966       retPtr[3*i+1]=a1Ptr[3*i+2]*a2Ptr[3*i]-a1Ptr[3*i]*a2Ptr[3*i+2];
4967       retPtr[3*i+2]=a1Ptr[3*i]*a2Ptr[3*i+1]-a1Ptr[3*i+1]*a2Ptr[3*i];
4968     }
4969   ret->copyStringInfoFrom(*a1);
4970   return ret;
4971 }
4972
4973 /*!
4974  * Returns a new DataArrayDouble containing maximal values of two given arrays.
4975  * Info on components is copied from the first of the given arrays.
4976  * Number of tuples and components in the given arrays must be the same.
4977  *  \param [in] a1 - an array to compare values with another one.
4978  *  \param [in] a2 - another array to compare values with the first one.
4979  *  \return DataArrayDouble * - the new instance of DataArrayDouble.
4980  *          The caller is to delete this result array using decrRef() as it is no more
4981  *          needed.
4982  *  \throw If either \a a1 or \a a2 is NULL.
4983  *  \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
4984  *  \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
4985  */
4986 DataArrayDouble *DataArrayDouble::Max(const DataArrayDouble *a1, const DataArrayDouble *a2)
4987 {
4988   if(!a1 || !a2)
4989     throw INTERP_KERNEL::Exception("DataArrayDouble::Max : input DataArrayDouble instance is NULL !");
4990   int nbOfComp=a1->getNumberOfComponents();
4991   if(nbOfComp!=a2->getNumberOfComponents())
4992     throw INTERP_KERNEL::Exception("Nb of components mismatch for array Max !");
4993   int nbOfTuple=a1->getNumberOfTuples();
4994   if(nbOfTuple!=a2->getNumberOfTuples())
4995     throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Max !");
4996   DataArrayDouble *ret=DataArrayDouble::New();
4997   ret->alloc(nbOfTuple,nbOfComp);
4998   double *retPtr=ret->getPointer();
4999   const double *a1Ptr=a1->getConstPointer();
5000   const double *a2Ptr=a2->getConstPointer();
5001   int nbElem=nbOfTuple*nbOfComp;
5002   for(int i=0;i<nbElem;i++)
5003     retPtr[i]=std::max(a1Ptr[i],a2Ptr[i]);
5004   ret->copyStringInfoFrom(*a1);
5005   return ret;
5006 }
5007
5008 /*!
5009  * Returns a new DataArrayDouble containing minimal values of two given arrays.
5010  * Info on components is copied from the first of the given arrays.
5011  * Number of tuples and components in the given arrays must be the same.
5012  *  \param [in] a1 - an array to compare values with another one.
5013  *  \param [in] a2 - another array to compare values with the first one.
5014  *  \return DataArrayDouble * - the new instance of DataArrayDouble.
5015  *          The caller is to delete this result array using decrRef() as it is no more
5016  *          needed.
5017  *  \throw If either \a a1 or \a a2 is NULL.
5018  *  \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
5019  *  \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents()
5020  */
5021 DataArrayDouble *DataArrayDouble::Min(const DataArrayDouble *a1, const DataArrayDouble *a2)
5022 {
5023   if(!a1 || !a2)
5024     throw INTERP_KERNEL::Exception("DataArrayDouble::Min : input DataArrayDouble instance is NULL !");
5025   int nbOfComp=a1->getNumberOfComponents();
5026   if(nbOfComp!=a2->getNumberOfComponents())
5027     throw INTERP_KERNEL::Exception("Nb of components mismatch for array min !");
5028   int nbOfTuple=a1->getNumberOfTuples();
5029   if(nbOfTuple!=a2->getNumberOfTuples())
5030     throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array min !");
5031   DataArrayDouble *ret=DataArrayDouble::New();
5032   ret->alloc(nbOfTuple,nbOfComp);
5033   double *retPtr=ret->getPointer();
5034   const double *a1Ptr=a1->getConstPointer();
5035   const double *a2Ptr=a2->getConstPointer();
5036   int nbElem=nbOfTuple*nbOfComp;
5037   for(int i=0;i<nbElem;i++)
5038     retPtr[i]=std::min(a1Ptr[i],a2Ptr[i]);
5039   ret->copyStringInfoFrom(*a1);
5040   return ret;
5041 }
5042
5043 /*!
5044  * Returns a new DataArrayDouble that is a sum of two given arrays. There are 3
5045  * valid cases.
5046  * 1.  The arrays have same number of tuples and components. Then each value of
5047  *   the result array (_a_) is a sum of the corresponding values of \a a1 and \a a2,
5048  *   i.e.: _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, j ].
5049  * 2.  The arrays have same number of tuples and one array, say _a2_, has one
5050  *   component. Then
5051  *   _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, 0 ].
5052  * 3.  The arrays have same number of components and one array, say _a2_, has one
5053  *   tuple. Then
5054  *   _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ 0, j ].
5055  *
5056  * Info on components is copied either from the first array (in the first case) or from
5057  * the array with maximal number of elements (getNbOfElems()).
5058  *  \param [in] a1 - an array to sum up.
5059  *  \param [in] a2 - another array to sum up.
5060  *  \return DataArrayDouble * - the new instance of DataArrayDouble.
5061  *          The caller is to delete this result array using decrRef() as it is no more
5062  *          needed.
5063  *  \throw If either \a a1 or \a a2 is NULL.
5064  *  \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
5065  *         \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
5066  *         none of them has number of tuples or components equal to 1.
5067  */
5068 DataArrayDouble *DataArrayDouble::Add(const DataArrayDouble *a1, const DataArrayDouble *a2)
5069 {
5070   if(!a1 || !a2)
5071     throw INTERP_KERNEL::Exception("DataArrayDouble::Add : input DataArrayDouble instance is NULL !");
5072   int nbOfTuple=a1->getNumberOfTuples();
5073   int nbOfTuple2=a2->getNumberOfTuples();
5074   int nbOfComp=a1->getNumberOfComponents();
5075   int nbOfComp2=a2->getNumberOfComponents();
5076   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=0;
5077   if(nbOfTuple==nbOfTuple2)
5078     {
5079       if(nbOfComp==nbOfComp2)
5080         {
5081           ret=DataArrayDouble::New();
5082           ret->alloc(nbOfTuple,nbOfComp);
5083           std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::plus<double>());
5084           ret->copyStringInfoFrom(*a1);
5085         }
5086       else
5087         {
5088           int nbOfCompMin,nbOfCompMax;
5089           const DataArrayDouble *aMin, *aMax;
5090           if(nbOfComp>nbOfComp2)
5091             {
5092               nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
5093               aMin=a2; aMax=a1;
5094             }
5095           else
5096             {
5097               nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
5098               aMin=a1; aMax=a2;
5099             }
5100           if(nbOfCompMin==1)
5101             {
5102               ret=DataArrayDouble::New();
5103               ret->alloc(nbOfTuple,nbOfCompMax);
5104               const double *aMinPtr=aMin->getConstPointer();
5105               const double *aMaxPtr=aMax->getConstPointer();
5106               double *res=ret->getPointer();
5107               for(int i=0;i<nbOfTuple;i++)
5108                 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::plus<double>(),aMinPtr[i]));
5109               ret->copyStringInfoFrom(*aMax);
5110             }
5111           else
5112             throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
5113         }
5114     }
5115   else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
5116     {
5117       if(nbOfComp==nbOfComp2)
5118         {
5119           int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
5120           const DataArrayDouble *aMin=nbOfTuple>nbOfTuple2?a2:a1;
5121           const DataArrayDouble *aMax=nbOfTuple>nbOfTuple2?a1:a2;
5122           const double *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
5123           ret=DataArrayDouble::New();
5124           ret->alloc(nbOfTupleMax,nbOfComp);
5125           double *res=ret->getPointer();
5126           for(int i=0;i<nbOfTupleMax;i++)
5127             res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::plus<double>());
5128           ret->copyStringInfoFrom(*aMax);
5129         }
5130       else
5131         throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
5132     }
5133   else
5134     throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Add !");
5135   return ret.retn();
5136 }
5137
5138 /*!
5139  * Adds values of another DataArrayDouble to values of \a this one. There are 3
5140  * valid cases.
5141  * 1.  The arrays have same number of tuples and components. Then each value of
5142  *   \a other array is added to the corresponding value of \a this array, i.e.:
5143  *   _a_ [ i, j ] += _other_ [ i, j ].
5144  * 2.  The arrays have same number of tuples and \a other array has one component. Then
5145  *   _a_ [ i, j ] += _other_ [ i, 0 ].
5146  * 3.  The arrays have same number of components and \a other array has one tuple. Then
5147  *   _a_ [ i, j ] += _a2_ [ 0, j ].
5148  *
5149  *  \param [in] other - an array to add to \a this one.
5150  *  \throw If \a other is NULL.
5151  *  \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
5152  *         \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
5153  *         \a other has number of both tuples and components not equal to 1.
5154  */
5155 void DataArrayDouble::addEqual(const DataArrayDouble *other)
5156 {
5157   if(!other)
5158     throw INTERP_KERNEL::Exception("DataArrayDouble::addEqual : input DataArrayDouble instance is NULL !");
5159   const char *msg="Nb of tuples mismatch for DataArrayDouble::addEqual  !";
5160   checkAllocated();
5161   other->checkAllocated();
5162   int nbOfTuple=getNumberOfTuples();
5163   int nbOfTuple2=other->getNumberOfTuples();
5164   int nbOfComp=getNumberOfComponents();
5165   int nbOfComp2=other->getNumberOfComponents();
5166   if(nbOfTuple==nbOfTuple2)
5167     {
5168       if(nbOfComp==nbOfComp2)
5169         {
5170           std::transform(begin(),end(),other->begin(),getPointer(),std::plus<double>());
5171         }
5172       else if(nbOfComp2==1)
5173         {
5174           double *ptr=getPointer();
5175           const double *ptrc=other->getConstPointer();
5176           for(int i=0;i<nbOfTuple;i++)
5177             std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::plus<double>(),*ptrc++));
5178         }
5179       else
5180         throw INTERP_KERNEL::Exception(msg);
5181     }
5182   else if(nbOfTuple2==1)
5183     {
5184       if(nbOfComp2==nbOfComp)
5185         {
5186           double *ptr=getPointer();
5187           const double *ptrc=other->getConstPointer();
5188           for(int i=0;i<nbOfTuple;i++)
5189             std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::plus<double>());
5190         }
5191       else
5192         throw INTERP_KERNEL::Exception(msg);
5193     }
5194   else
5195     throw INTERP_KERNEL::Exception(msg);
5196   declareAsNew();
5197 }
5198
5199 /*!
5200  * Returns a new DataArrayDouble that is a subtraction of two given arrays. There are 3
5201  * valid cases.
5202  * 1.  The arrays have same number of tuples and components. Then each value of
5203  *   the result array (_a_) is a subtraction of the corresponding values of \a a1 and
5204  *   \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, j ].
5205  * 2.  The arrays have same number of tuples and one array, say _a2_, has one
5206  *   component. Then
5207  *   _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, 0 ].
5208  * 3.  The arrays have same number of components and one array, say _a2_, has one
5209  *   tuple. Then
5210  *   _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ 0, j ].
5211  *
5212  * Info on components is copied either from the first array (in the first case) or from
5213  * the array with maximal number of elements (getNbOfElems()).
5214  *  \param [in] a1 - an array to subtract from.
5215  *  \param [in] a2 - an array to subtract.
5216  *  \return DataArrayDouble * - the new instance of DataArrayDouble.
5217  *          The caller is to delete this result array using decrRef() as it is no more
5218  *          needed.
5219  *  \throw If either \a a1 or \a a2 is NULL.
5220  *  \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
5221  *         \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
5222  *         none of them has number of tuples or components equal to 1.
5223  */
5224 DataArrayDouble *DataArrayDouble::Substract(const DataArrayDouble *a1, const DataArrayDouble *a2)
5225 {
5226   if(!a1 || !a2)
5227     throw INTERP_KERNEL::Exception("DataArrayDouble::Substract : input DataArrayDouble instance is NULL !");
5228   int nbOfTuple1=a1->getNumberOfTuples();
5229   int nbOfTuple2=a2->getNumberOfTuples();
5230   int nbOfComp1=a1->getNumberOfComponents();
5231   int nbOfComp2=a2->getNumberOfComponents();
5232   if(nbOfTuple2==nbOfTuple1)
5233     {
5234       if(nbOfComp1==nbOfComp2)
5235         {
5236           MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5237           ret->alloc(nbOfTuple2,nbOfComp1);
5238           std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::minus<double>());
5239           ret->copyStringInfoFrom(*a1);
5240           return ret.retn();
5241         }
5242       else if(nbOfComp2==1)
5243         {
5244           MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5245           ret->alloc(nbOfTuple1,nbOfComp1);
5246           const double *a2Ptr=a2->getConstPointer();
5247           const double *a1Ptr=a1->getConstPointer();
5248           double *res=ret->getPointer();
5249           for(int i=0;i<nbOfTuple1;i++)
5250             res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::minus<double>(),a2Ptr[i]));
5251           ret->copyStringInfoFrom(*a1);
5252           return ret.retn();
5253         }
5254       else
5255         {
5256           a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
5257           return 0;
5258         }
5259     }
5260   else if(nbOfTuple2==1)
5261     {
5262       a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
5263       MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5264       ret->alloc(nbOfTuple1,nbOfComp1);
5265       const double *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
5266       double *pt=ret->getPointer();
5267       for(int i=0;i<nbOfTuple1;i++)
5268         pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::minus<double>());
5269       ret->copyStringInfoFrom(*a1);
5270       return ret.retn();
5271     }
5272   else
5273     {
5274       a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Substract !");//will always throw an exception
5275       return 0;
5276     }
5277 }
5278
5279 /*!
5280  * Subtract values of another DataArrayDouble from values of \a this one. There are 3
5281  * valid cases.
5282  * 1.  The arrays have same number of tuples and components. Then each value of
5283  *   \a other array is subtracted from the corresponding value of \a this array, i.e.:
5284  *   _a_ [ i, j ] -= _other_ [ i, j ].
5285  * 2.  The arrays have same number of tuples and \a other array has one component. Then
5286  *   _a_ [ i, j ] -= _other_ [ i, 0 ].
5287  * 3.  The arrays have same number of components and \a other array has one tuple. Then
5288  *   _a_ [ i, j ] -= _a2_ [ 0, j ].
5289  *
5290  *  \param [in] other - an array to subtract from \a this one.
5291  *  \throw If \a other is NULL.
5292  *  \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
5293  *         \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
5294  *         \a other has number of both tuples and components not equal to 1.
5295  */
5296 void DataArrayDouble::substractEqual(const DataArrayDouble *other)
5297 {
5298   if(!other)
5299     throw INTERP_KERNEL::Exception("DataArrayDouble::substractEqual : input DataArrayDouble instance is NULL !");
5300   const char *msg="Nb of tuples mismatch for DataArrayDouble::substractEqual  !";
5301   checkAllocated();
5302   other->checkAllocated();
5303   int nbOfTuple=getNumberOfTuples();
5304   int nbOfTuple2=other->getNumberOfTuples();
5305   int nbOfComp=getNumberOfComponents();
5306   int nbOfComp2=other->getNumberOfComponents();
5307   if(nbOfTuple==nbOfTuple2)
5308     {
5309       if(nbOfComp==nbOfComp2)
5310         {
5311           std::transform(begin(),end(),other->begin(),getPointer(),std::minus<double>());
5312         }
5313       else if(nbOfComp2==1)
5314         {
5315           double *ptr=getPointer();
5316           const double *ptrc=other->getConstPointer();
5317           for(int i=0;i<nbOfTuple;i++)
5318             std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::minus<double>(),*ptrc++));
5319         }
5320       else
5321         throw INTERP_KERNEL::Exception(msg);
5322     }
5323   else if(nbOfTuple2==1)
5324     {
5325       if(nbOfComp2==nbOfComp)
5326         {
5327           double *ptr=getPointer();
5328           const double *ptrc=other->getConstPointer();
5329           for(int i=0;i<nbOfTuple;i++)
5330             std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::minus<double>());
5331         }
5332       else
5333         throw INTERP_KERNEL::Exception(msg);
5334     }
5335   else
5336     throw INTERP_KERNEL::Exception(msg);
5337   declareAsNew();
5338 }
5339
5340 /*!
5341  * Returns a new DataArrayDouble that is a product of two given arrays. There are 3
5342  * valid cases.
5343  * 1.  The arrays have same number of tuples and components. Then each value of
5344  *   the result array (_a_) is a product of the corresponding values of \a a1 and
5345  *   \a a2, i.e. _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, j ].
5346  * 2.  The arrays have same number of tuples and one array, say _a2_, has one
5347  *   component. Then
5348  *   _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, 0 ].
5349  * 3.  The arrays have same number of components and one array, say _a2_, has one
5350  *   tuple. Then
5351  *   _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ 0, j ].
5352  *
5353  * Info on components is copied either from the first array (in the first case) or from
5354  * the array with maximal number of elements (getNbOfElems()).
5355  *  \param [in] a1 - a factor array.
5356  *  \param [in] a2 - another factor array.
5357  *  \return DataArrayDouble * - the new instance of DataArrayDouble.
5358  *          The caller is to delete this result array using decrRef() as it is no more
5359  *          needed.
5360  *  \throw If either \a a1 or \a a2 is NULL.
5361  *  \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
5362  *         \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
5363  *         none of them has number of tuples or components equal to 1.
5364  */
5365 DataArrayDouble *DataArrayDouble::Multiply(const DataArrayDouble *a1, const DataArrayDouble *a2)
5366 {
5367   if(!a1 || !a2)
5368     throw INTERP_KERNEL::Exception("DataArrayDouble::Multiply : input DataArrayDouble instance is NULL !");
5369   int nbOfTuple=a1->getNumberOfTuples();
5370   int nbOfTuple2=a2->getNumberOfTuples();
5371   int nbOfComp=a1->getNumberOfComponents();
5372   int nbOfComp2=a2->getNumberOfComponents();
5373   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=0;
5374   if(nbOfTuple==nbOfTuple2)
5375     {
5376       if(nbOfComp==nbOfComp2)
5377         {
5378           ret=DataArrayDouble::New();
5379           ret->alloc(nbOfTuple,nbOfComp);
5380           std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::multiplies<double>());
5381           ret->copyStringInfoFrom(*a1);
5382         }
5383       else
5384         {
5385           int nbOfCompMin,nbOfCompMax;
5386           const DataArrayDouble *aMin, *aMax;
5387           if(nbOfComp>nbOfComp2)
5388             {
5389               nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
5390               aMin=a2; aMax=a1;
5391             }
5392           else
5393             {
5394               nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
5395               aMin=a1; aMax=a2;
5396             }
5397           if(nbOfCompMin==1)
5398             {
5399               ret=DataArrayDouble::New();
5400               ret->alloc(nbOfTuple,nbOfCompMax);
5401               const double *aMinPtr=aMin->getConstPointer();
5402               const double *aMaxPtr=aMax->getConstPointer();
5403               double *res=ret->getPointer();
5404               for(int i=0;i<nbOfTuple;i++)
5405                 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::multiplies<double>(),aMinPtr[i]));
5406               ret->copyStringInfoFrom(*aMax);
5407             }
5408           else
5409             throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
5410         }
5411     }
5412   else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
5413     {
5414       if(nbOfComp==nbOfComp2)
5415         {
5416           int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
5417           const DataArrayDouble *aMin=nbOfTuple>nbOfTuple2?a2:a1;
5418           const DataArrayDouble *aMax=nbOfTuple>nbOfTuple2?a1:a2;
5419           const double *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
5420           ret=DataArrayDouble::New();
5421           ret->alloc(nbOfTupleMax,nbOfComp);
5422           double *res=ret->getPointer();
5423           for(int i=0;i<nbOfTupleMax;i++)
5424             res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::multiplies<double>());
5425           ret->copyStringInfoFrom(*aMax);
5426         }
5427       else
5428         throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
5429     }
5430   else
5431     throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Multiply !");
5432   return ret.retn();
5433 }
5434
5435 /*!
5436  * Multiply values of another DataArrayDouble to values of \a this one. There are 3
5437  * valid cases.
5438  * 1.  The arrays have same number of tuples and components. Then each value of
5439  *   \a other array is multiplied to the corresponding value of \a this array, i.e.
5440  *   _this_ [ i, j ] *= _other_ [ i, j ].
5441  * 2.  The arrays have same number of tuples and \a other array has one component. Then
5442  *   _this_ [ i, j ] *= _other_ [ i, 0 ].
5443  * 3.  The arrays have same number of components and \a other array has one tuple. Then
5444  *   _this_ [ i, j ] *= _a2_ [ 0, j ].
5445  *
5446  *  \param [in] other - an array to multiply to \a this one.
5447  *  \throw If \a other is NULL.
5448  *  \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
5449  *         \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
5450  *         \a other has number of both tuples and components not equal to 1.
5451  */
5452 void DataArrayDouble::multiplyEqual(const DataArrayDouble *other)
5453 {
5454   if(!other)
5455     throw INTERP_KERNEL::Exception("DataArrayDouble::multiplyEqual : input DataArrayDouble instance is NULL !");
5456   const char *msg="Nb of tuples mismatch for DataArrayDouble::multiplyEqual !";
5457   checkAllocated();
5458   other->checkAllocated();
5459   int nbOfTuple=getNumberOfTuples();
5460   int nbOfTuple2=other->getNumberOfTuples();
5461   int nbOfComp=getNumberOfComponents();
5462   int nbOfComp2=other->getNumberOfComponents();
5463   if(nbOfTuple==nbOfTuple2)
5464     {
5465       if(nbOfComp==nbOfComp2)
5466         {
5467           std::transform(begin(),end(),other->begin(),getPointer(),std::multiplies<double>());
5468         }
5469       else if(nbOfComp2==1)
5470         {
5471           double *ptr=getPointer();
5472           const double *ptrc=other->getConstPointer();
5473           for(int i=0;i<nbOfTuple;i++)
5474             std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::multiplies<double>(),*ptrc++));
5475         }
5476       else
5477         throw INTERP_KERNEL::Exception(msg);
5478     }
5479   else if(nbOfTuple2==1)
5480     {
5481       if(nbOfComp2==nbOfComp)
5482         {
5483           double *ptr=getPointer();
5484           const double *ptrc=other->getConstPointer();
5485           for(int i=0;i<nbOfTuple;i++)
5486             std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::multiplies<double>());
5487         }
5488       else
5489         throw INTERP_KERNEL::Exception(msg);
5490     }
5491   else
5492     throw INTERP_KERNEL::Exception(msg);
5493   declareAsNew();
5494 }
5495
5496 /*!
5497  * Returns a new DataArrayDouble that is a division of two given arrays. There are 3
5498  * valid cases.
5499  * 1.  The arrays have same number of tuples and components. Then each value of
5500  *   the result array (_a_) is a division of the corresponding values of \a a1 and
5501  *   \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, j ].
5502  * 2.  The arrays have same number of tuples and one array, say _a2_, has one
5503  *   component. Then
5504  *   _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, 0 ].
5505  * 3.  The arrays have same number of components and one array, say _a2_, has one
5506  *   tuple. Then
5507  *   _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ 0, j ].
5508  *
5509  * Info on components is copied either from the first array (in the first case) or from
5510  * the array with maximal number of elements (getNbOfElems()).
5511  *  \warning No check of division by zero is performed!
5512  *  \param [in] a1 - a numerator array.
5513  *  \param [in] a2 - a denominator array.
5514  *  \return DataArrayDouble * - the new instance of DataArrayDouble.
5515  *          The caller is to delete this result array using decrRef() as it is no more
5516  *          needed.
5517  *  \throw If either \a a1 or \a a2 is NULL.
5518  *  \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
5519  *         \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
5520  *         none of them has number of tuples or components equal to 1.
5521  */
5522 DataArrayDouble *DataArrayDouble::Divide(const DataArrayDouble *a1, const DataArrayDouble *a2)
5523 {
5524   if(!a1 || !a2)
5525     throw INTERP_KERNEL::Exception("DataArrayDouble::Divide : input DataArrayDouble instance is NULL !");
5526   int nbOfTuple1=a1->getNumberOfTuples();
5527   int nbOfTuple2=a2->getNumberOfTuples();
5528   int nbOfComp1=a1->getNumberOfComponents();
5529   int nbOfComp2=a2->getNumberOfComponents();
5530   if(nbOfTuple2==nbOfTuple1)
5531     {
5532       if(nbOfComp1==nbOfComp2)
5533         {
5534           MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5535           ret->alloc(nbOfTuple2,nbOfComp1);
5536           std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::divides<double>());
5537           ret->copyStringInfoFrom(*a1);
5538           return ret.retn();
5539         }
5540       else if(nbOfComp2==1)
5541         {
5542           MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5543           ret->alloc(nbOfTuple1,nbOfComp1);
5544           const double *a2Ptr=a2->getConstPointer();
5545           const double *a1Ptr=a1->getConstPointer();
5546           double *res=ret->getPointer();
5547           for(int i=0;i<nbOfTuple1;i++)
5548             res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::divides<double>(),a2Ptr[i]));
5549           ret->copyStringInfoFrom(*a1);
5550           return ret.retn();
5551         }
5552       else
5553         {
5554           a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
5555           return 0;
5556         }
5557     }
5558   else if(nbOfTuple2==1)
5559     {
5560       a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
5561       MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
5562       ret->alloc(nbOfTuple1,nbOfComp1);
5563       const double *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
5564       double *pt=ret->getPointer();
5565       for(int i=0;i<nbOfTuple1;i++)
5566         pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::divides<double>());
5567       ret->copyStringInfoFrom(*a1);
5568       return ret.retn();
5569     }
5570   else
5571     {
5572       a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Divide !");//will always throw an exception
5573       return 0;
5574     }
5575 }
5576
5577 /*!
5578  * Divide values of \a this array by values of another DataArrayDouble. There are 3
5579  * valid cases.
5580  * 1.  The arrays have same number of tuples and components. Then each value of
5581  *    \a this array is divided by the corresponding value of \a other one, i.e.:
5582  *   _a_ [ i, j ] /= _other_ [ i, j ].
5583  * 2.  The arrays have same number of tuples and \a other array has one component. Then
5584  *   _a_ [ i, j ] /= _other_ [ i, 0 ].
5585  * 3.  The arrays have same number of components and \a other array has one tuple. Then
5586  *   _a_ [ i, j ] /= _a2_ [ 0, j ].
5587  *
5588  *  \warning No check of division by zero is performed!
5589  *  \param [in] other - an array to divide \a this one by.
5590  *  \throw If \a other is NULL.
5591  *  \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
5592  *         \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
5593  *         \a other has number of both tuples and components not equal to 1.
5594  */
5595 void DataArrayDouble::divideEqual(const DataArrayDouble *other)
5596 {
5597   if(!other)
5598     throw INTERP_KERNEL::Exception("DataArrayDouble::divideEqual : input DataArrayDouble instance is NULL !");
5599   const char *msg="Nb of tuples mismatch for DataArrayDouble::divideEqual !";
5600   checkAllocated();
5601   other->checkAllocated();
5602   int nbOfTuple=getNumberOfTuples();
5603   int nbOfTuple2=other->getNumberOfTuples();
5604   int nbOfComp=getNumberOfComponents();
5605   int nbOfComp2=other->getNumberOfComponents();
5606   if(nbOfTuple==nbOfTuple2)
5607     {
5608       if(nbOfComp==nbOfComp2)
5609         {
5610           std::transform(begin(),end(),other->begin(),getPointer(),std::divides<double>());
5611         }
5612       else if(nbOfComp2==1)
5613         {
5614           double *ptr=getPointer();
5615           const double *ptrc=other->getConstPointer();
5616           for(int i=0;i<nbOfTuple;i++)
5617             std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::divides<double>(),*ptrc++));
5618         }
5619       else
5620         throw INTERP_KERNEL::Exception(msg);
5621     }
5622   else if(nbOfTuple2==1)
5623     {
5624       if(nbOfComp2==nbOfComp)
5625         {
5626           double *ptr=getPointer();
5627           const double *ptrc=other->getConstPointer();
5628           for(int i=0;i<nbOfTuple;i++)
5629             std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::divides<double>());
5630         }
5631       else
5632         throw INTERP_KERNEL::Exception(msg);
5633     }
5634   else
5635     throw INTERP_KERNEL::Exception(msg);
5636   declareAsNew();
5637 }
5638
5639 /*!
5640  * Returns a new DataArrayDouble that is the result of pow of two given arrays. There are 3
5641  * valid cases.
5642  *
5643  *  \param [in] a1 - an array to pow up.
5644  *  \param [in] a2 - another array to sum up.
5645  *  \return DataArrayDouble * - the new instance of DataArrayDouble.
5646  *          The caller is to delete this result array using decrRef() as it is no more
5647  *          needed.
5648  *  \throw If either \a a1 or \a a2 is NULL.
5649  *  \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
5650  *  \throw If \a a1->getNumberOfComponents() != 1 or \a a2->getNumberOfComponents() != 1.
5651  *  \throw If there is a negative value in \a a1.
5652  */
5653 DataArrayDouble *DataArrayDouble::Pow(const DataArrayDouble *a1, const DataArrayDouble *a2)
5654 {
5655   if(!a1 || !a2)
5656     throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : at least one of input instances is null !");
5657   int nbOfTuple=a1->getNumberOfTuples();
5658   int nbOfTuple2=a2->getNumberOfTuples();
5659   int nbOfComp=a1->getNumberOfComponents();
5660   int nbOfComp2=a2->getNumberOfComponents();
5661   if(nbOfTuple!=nbOfTuple2)
5662     throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : number of tuples mismatches !");
5663   if(nbOfComp!=1 || nbOfComp2!=1)
5664     throw INTERP_KERNEL::Exception("DataArrayDouble::Pow : number of components of both arrays must be equal to 1 !");
5665   MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New(); ret->alloc(nbOfTuple,1);
5666   const double *ptr1(a1->begin()),*ptr2(a2->begin());
5667   double *ptr=ret->getPointer();
5668   for(int i=0;i<nbOfTuple;i++,ptr1++,ptr2++,ptr++)
5669     {
5670       if(*ptr1>=0)
5671         {
5672           *ptr=pow(*ptr1,*ptr2);
5673         }
5674       else
5675         {
5676           std::ostringstream oss; oss << "DataArrayDouble::Pow : on tuple #" << i << " of a1 value is < 0 (" << *ptr1 << ") !";
5677           throw INTERP_KERNEL::Exception(oss.str().c_str());
5678         }
5679     }
5680   return ret.retn();
5681 }
5682
5683 /*!
5684  * Apply pow on values of another DataArrayDouble to values of \a this one.
5685  *
5686  *  \param [in] other - an array to pow to \a this one.
5687  *  \throw If \a other is NULL.
5688  *  \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples()
5689  *  \throw If \a this->getNumberOfComponents() != 1 or \a other->getNumberOfComponents() != 1
5690  *  \throw If there is a negative value in \a this.
5691  */
5692 void DataArrayDouble::powEqual(const DataArrayDouble *other)
5693 {
5694   if(!other)
5695     throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : input instance is null !");
5696   int nbOfTuple=getNumberOfTuples();
5697   int nbOfTuple2=other->getNumberOfTuples();
5698   int nbOfComp=getNumberOfComponents();
5699   int nbOfComp2=other->getNumberOfComponents();
5700   if(nbOfTuple!=nbOfTuple2)
5701     throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : number of tuples mismatches !");
5702   if(nbOfComp!=1 || nbOfComp2!=1)
5703     throw INTERP_KERNEL::Exception("DataArrayDouble::powEqual : number of components of both arrays must be equal to 1 !");
5704   double *ptr=getPointer();
5705   const double *ptrc=other->begin();
5706   for(int i=0;i<nbOfTuple;i++,ptrc++,ptr++)
5707     {
5708       if(*ptr>=0)
5709         *ptr=pow(*ptr,*ptrc);
5710       else
5711         {
5712           std::ostringstream oss; oss << "DataArrayDouble::powEqual : on tuple #" << i << " of this value is < 0 (" << *ptr << ") !";
5713           throw INTERP_KERNEL::Exception(oss.str().c_str());
5714         }
5715     }
5716   declareAsNew();
5717 }
5718
5719 /*!
5720  * This method is \b NOT wrapped into python because it can be useful only for performance reasons in C++ context.
5721  * All values in \a this must be 0. or 1. within eps error. 0 means false, 1 means true.
5722  * If an another value than 0 or 1 appear (within eps precision) an INTERP_KERNEL::Exception will be thrown.
5723  *
5724  * \throw if \a this is not allocated.
5725  * \throw if \a this has not exactly one component.
5726  */
5727 std::vector<bool> DataArrayDouble::toVectorOfBool(double eps) const
5728 {
5729   checkAllocated();
5730   if(getNumberOfComponents()!=1)
5731     throw INTERP_KERNEL::Exception("DataArrayDouble::toVectorOfBool : must be applied on single component array !");
5732   int nbt(getNumberOfTuples());
5733   std::vector<bool> ret(nbt);
5734   const double *pt(begin());
5735   for(int i=0;i<nbt;i++)
5736     {
5737       if(fabs(pt[i])<eps)
5738         ret[i]=false;
5739       else if(fabs(pt[i]-1.)<eps)
5740         ret[i]=true;
5741       else
5742         {
5743           std::ostringstream oss; oss << "DataArrayDouble::toVectorOfBool : the tuple #" << i << " has value " << pt[i] << " is invalid ! must be 0. or 1. !";
5744           throw INTERP_KERNEL::Exception(oss.str().c_str());
5745         }
5746     }
5747   return ret;
5748 }
5749
5750 /*!
5751  * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5752  * Server side.
5753  */
5754 void DataArrayDouble::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
5755 {
5756   tinyInfo.resize(2);
5757   if(isAllocated())
5758     {
5759       tinyInfo[0]=getNumberOfTuples();
5760       tinyInfo[1]=getNumberOfComponents();
5761     }
5762   else
5763     {
5764       tinyInfo[0]=-1;
5765       tinyInfo[1]=-1;
5766     }
5767 }
5768
5769 /*!
5770  * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5771  * Server side.
5772  */
5773 void DataArrayDouble::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
5774 {
5775   if(isAllocated())
5776     {
5777       int nbOfCompo=getNumberOfComponents();
5778       tinyInfo.resize(nbOfCompo+1);
5779       tinyInfo[0]=getName();
5780       for(int i=0;i<nbOfCompo;i++)
5781         tinyInfo[i+1]=getInfoOnComponent(i);
5782     }
5783   else
5784     {
5785       tinyInfo.resize(1);
5786       tinyInfo[0]=getName();
5787     }
5788 }
5789
5790 /*!
5791  * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5792  * This method returns if a feeding is needed.
5793  */
5794 bool DataArrayDouble::resizeForUnserialization(const std::vector<int>& tinyInfoI)
5795 {
5796   int nbOfTuple=tinyInfoI[0];
5797   int nbOfComp=tinyInfoI[1];
5798   if(nbOfTuple!=-1 || nbOfComp!=-1)
5799     {
5800       alloc(nbOfTuple,nbOfComp);
5801       return true;
5802     }
5803   return false;
5804 }
5805
5806 /*!
5807  * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
5808  */
5809 void DataArrayDouble::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<std::string>& tinyInfoS)
5810 {
5811   setName(tinyInfoS[0]);
5812   if(isAllocated())
5813     {
5814       int nbOfCompo=getNumberOfComponents();
5815       for(int i=0;i<nbOfCompo;i++)
5816         setInfoOnComponent(i,tinyInfoS[i+1]);
5817     }
5818 }
5819
5820 DataArrayDoubleIterator::DataArrayDoubleIterator(DataArrayDouble *da):_da(da),_tuple_id(0),_nb_comp(0),_nb_tuple(0)
5821 {
5822   if(_da)
5823     {
5824       _da->incrRef();
5825       if(_da->isAllocated())
5826         {
5827           _nb_comp=da->getNumberOfComponents();
5828           _nb_tuple=da->getNumberOfTuples();
5829           _pt=da->getPointer();
5830         }
5831     }
5832 }
5833
5834 DataArrayDoubleIterator::~DataArrayDoubleIterator()
5835 {
5836   if(_da)
5837     _da->decrRef();
5838 }
5839
5840 DataArrayDoubleTuple *DataArrayDoubleIterator::nextt()
5841 {
5842   if(_tuple_id<_nb_tuple)
5843     {
5844       _tuple_id++;
5845       DataArrayDoubleTuple *ret=new DataArrayDoubleTuple(_pt,_nb_comp);
5846       _pt+=_nb_comp;
5847       return ret;
5848     }
5849   else
5850     return 0;
5851 }
5852
5853 DataArrayDoubleTuple::DataArrayDoubleTuple(double *pt, int nbOfComp):_pt(pt),_nb_of_compo(nbOfComp)
5854 {
5855 }
5856
5857
5858 std::string DataArrayDoubleTuple::repr() const
5859 {
5860   std::ostringstream oss; oss.precision(17); oss << "(";
5861   for(int i=0;i<_nb_of_compo-1;i++)
5862     oss << _pt[i] << ", ";
5863   oss << _pt[_nb_of_compo-1] << ")";
5864   return oss.str();
5865 }
5866
5867 double DataArrayDoubleTuple::doubleValue() const
5868 {
5869   if(_nb_of_compo==1)
5870     return *_pt;
5871   throw INTERP_KERNEL::Exception("DataArrayDoubleTuple::doubleValue : DataArrayDoubleTuple instance has not exactly 1 component -> Not possible to convert it into a double precision float !");
5872 }
5873
5874 /*!
5875  * This method returns a newly allocated instance the caller should dealed with by a ParaMEDMEM::DataArrayDouble::decrRef.
5876  * This method performs \b no copy of data. The content is only referenced using ParaMEDMEM::DataArrayDouble::useArray with ownership set to \b false.
5877  * This method throws an INTERP_KERNEL::Exception is it is impossible to match sizes of \b this that is too say \b nbOfCompo=this->_nb_of_elem and \bnbOfTuples==1 or
5878  * \b nbOfCompo=1 and \bnbOfTuples==this->_nb_of_elem.
5879  */
5880 DataArrayDouble *DataArrayDoubleTuple::buildDADouble(int nbOfTuples, int nbOfCompo) const
5881 {
5882   if((_nb_of_compo==nbOfCompo && nbOfTuples==1) || (_nb_of_compo==nbOfTuples && nbOfCompo==1))
5883     {
5884       DataArrayDouble *ret=DataArrayDouble::New();
5885       ret->useExternalArrayWithRWAccess(_pt,nbOfTuples,nbOfCompo);
5886       return ret;
5887     }
5888   else
5889     {
5890       std::ostringstream oss; oss << "DataArrayDoubleTuple::buildDADouble : unable to build a requested DataArrayDouble instance with nbofTuple=" << nbOfTuples << " and nbOfCompo=" << nbOfCompo;
5891       oss << ".\nBecause the number of elements in this is " << _nb_of_compo << " !";
5892       throw INTERP_KERNEL::Exception(oss.str().c_str());
5893     }
5894 }
5895
5896 /*!
5897  * Returns a new instance of DataArrayInt. The caller is to delete this array
5898  * using decrRef() as it is no more needed.
5899  */
5900 DataArrayInt *DataArrayInt::New()
5901 {
5902   return new DataArrayInt;
5903 }
5904
5905 /*!
5906  * Checks if raw data is allocated. Read more on the raw data
5907  * in \ref MEDCouplingArrayBasicsTuplesAndCompo "DataArrays infos" for more information.
5908  *  \return bool - \a true if the raw data is allocated, \a false else.
5909  */
5910 bool DataArrayInt::isAllocated() const
5911 {
5912   return getConstPointer()!=0;
5913 }
5914
5915 /*!
5916  * Checks if raw data is allocated and throws an exception if it is not the case.
5917  *  \throw If the raw data is not allocated.
5918  */
5919 void DataArrayInt::checkAllocated() const
5920 {
5921   if(!isAllocated())
5922     throw INTERP_KERNEL::Exception("DataArrayInt::checkAllocated : Array is defined but not allocated ! Call alloc or setValues method first !");
5923 }
5924
5925 /*!
5926  * This method desallocated \a this without modification of informations relative to the components.
5927  * After call of this method, DataArrayInt::isAllocated will return false.
5928  * If \a this is already not allocated, \a this is let unchanged.
5929  */
5930 void DataArrayInt::desallocate()
5931 {
5932   _mem.destroy();
5933 }
5934
5935 std::size_t DataArrayInt::getHeapMemorySizeWithoutChildren() const
5936 {
5937   std::size_t sz(_mem.getNbOfElemAllocated());
5938   sz*=sizeof(int);
5939   return DataArray::getHeapMemorySizeWithoutChildren()+sz;
5940 }
5941
5942 /*!
5943  * Returns the only one value in \a this, if and only if number of elements
5944  * (nb of tuples * nb of components) is equal to 1, and that \a this is allocated.
5945  *  \return double - the sole value stored in \a this array.
5946  *  \throw If at least one of conditions stated above is not fulfilled.
5947  */
5948 int DataArrayInt::intValue() const
5949 {
5950   if(isAllocated())
5951     {
5952       if(getNbOfElems()==1)
5953         {
5954           return *getConstPointer();
5955         }
5956       else
5957         throw INTERP_KERNEL::Exception("DataArrayInt::intValue : DataArrayInt instance is allocated but number of elements is not equal to 1 !");
5958     }
5959   else
5960     throw INTERP_KERNEL::Exception("DataArrayInt::intValue : DataArrayInt instance is not allocated !");
5961 }
5962
5963 /*!
5964  * Returns an integer value characterizing \a this array, which is useful for a quick
5965  * comparison of many instances of DataArrayInt.
5966  *  \return int - the hash value.
5967  *  \throw If \a this is not allocated.
5968  */
5969 int DataArrayInt::getHashCode() const
5970 {
5971   checkAllocated();
5972   std::size_t nbOfElems=getNbOfElems();
5973   int ret=nbOfElems*65536;
5974   int delta=3;
5975   if(nbOfElems>48)
5976     delta=nbOfElems/8;
5977   int ret0=0;
5978   const int *pt=begin();
5979   for(std::size_t i=0;i<nbOfElems;i+=delta)
5980     ret0+=pt[i] & 0x1FFF;
5981   return ret+ret0;
5982 }
5983
5984 /*!
5985  * Checks the number of tuples.
5986  *  \return bool - \a true if getNumberOfTuples() == 0, \a false else.
5987  *  \throw If \a this is not allocated.
5988  */
5989 bool DataArrayInt::empty() const
5990 {
5991   checkAllocated();
5992   return getNumberOfTuples()==0;
5993 }
5994
5995 /*!
5996  * Returns a full copy of \a this. For more info on copying data arrays see
5997  * \ref MEDCouplingArrayBasicsCopyDeep.
5998  *  \return DataArrayInt * - a new instance of DataArrayInt.
5999  */
6000 DataArrayInt *DataArrayInt::deepCpy() const
6001 {
6002   return new DataArrayInt(*this);
6003 }
6004
6005 /*!
6006  * Returns either a \a deep or \a shallow copy of this array. For more info see
6007  * \ref MEDCouplingArrayBasicsCopyDeep and \ref MEDCouplingArrayBasicsCopyShallow.
6008  *  \param [in] dCpy - if \a true, a deep copy is returned, else, a shallow one.
6009  *  \return DataArrayInt * - either a new instance of DataArrayInt (if \a dCpy
6010  *          == \a true) or \a this instance (if \a dCpy == \a false).
6011  */
6012 DataArrayInt *DataArrayInt::performCpy(bool dCpy) const
6013 {
6014   if(dCpy)
6015     return deepCpy();
6016   else
6017     {
6018       incrRef();
6019       return const_cast<DataArrayInt *>(this);
6020     }
6021 }
6022
6023 /*!
6024  * Copies all the data from another DataArrayInt. For more info see
6025  * \ref MEDCouplingArrayBasicsCopyDeepAssign.
6026  *  \param [in] other - another instance of DataArrayInt to copy data from.
6027  *  \throw If the \a other is not allocated.
6028  */
6029 void DataArrayInt::cpyFrom(const DataArrayInt& other)
6030 {
6031   other.checkAllocated();
6032   int nbOfTuples=other.getNumberOfTuples();
6033   int nbOfComp=other.getNumberOfComponents();
6034   allocIfNecessary(nbOfTuples,nbOfComp);
6035   std::size_t nbOfElems=(std::size_t)nbOfTuples*nbOfComp;
6036   int *pt=getPointer();
6037   const int *ptI=other.getConstPointer();
6038   for(std::size_t i=0;i<nbOfElems;i++)
6039     pt[i]=ptI[i];
6040   copyStringInfoFrom(other);
6041 }
6042
6043 /*!
6044  * This method reserve nbOfElems elements in memory ( nbOfElems*4 bytes ) \b without impacting the number of tuples in \a this.
6045  * If \a this has already been allocated, this method checks that \a this has only one component. If not an INTERP_KERNEL::Exception will be thrown.
6046  * If \a this has not already been allocated, number of components is set to one.
6047  * This method allows to reduce number of reallocations on invokation of DataArrayInt::pushBackSilent and DataArrayInt::pushBackValsSilent on \a this.
6048  *
6049  * \sa DataArrayInt::pack, DataArrayInt::pushBackSilent, DataArrayInt::pushBackValsSilent
6050  */
6051 void DataArrayInt::reserve(std::size_t nbOfElems)
6052 {
6053   int nbCompo=getNumberOfComponents();
6054   if(nbCompo==1)
6055     {
6056       _mem.reserve(nbOfElems);
6057     }
6058   else if(nbCompo==0)
6059     {
6060       _mem.reserve(nbOfElems);
6061       _info_on_compo.resize(1);
6062     }
6063   else
6064     throw INTERP_KERNEL::Exception("DataArrayInt::reserve : not available for DataArrayInt with number of components different than 1 !");
6065 }
6066
6067 /*!
6068  * This method adds at the end of \a this the single value \a val. This method do \b not update its time label to avoid useless incrementation
6069  * of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
6070  *
6071  * \param [in] val the value to be added in \a this
6072  * \throw If \a this has already been allocated with number of components different from one.
6073  * \sa DataArrayInt::pushBackValsSilent
6074  */
6075 void DataArrayInt::pushBackSilent(int val)
6076 {
6077   int nbCompo=getNumberOfComponents();
6078   if(nbCompo==1)
6079     _mem.pushBack(val);
6080   else if(nbCompo==0)
6081     {
6082       _info_on_compo.resize(1);
6083       _mem.pushBack(val);
6084     }
6085   else
6086     throw INTERP_KERNEL::Exception("DataArrayInt::pushBackSilent : not available for DataArrayInt with number of components different than 1 !");
6087 }
6088
6089 /*!
6090  * This method adds at the end of \a this a serie of values [\c valsBg,\c valsEnd). This method do \b not update its time label to avoid useless incrementation
6091  * of counter. So the caller is expected to call TimeLabel::declareAsNew on \a this at the end of the push session.
6092  *
6093  *  \param [in] valsBg - an array of values to push at the end of \this.
6094  *  \param [in] valsEnd - specifies the end of the array \a valsBg, so that
6095  *              the last value of \a valsBg is \a valsEnd[ -1 ].
6096  * \throw If \a this has already been allocated with number of components different from one.
6097  * \sa DataArrayInt::pushBackSilent
6098  */
6099 void DataArrayInt::pushBackValsSilent(const int *valsBg, const int *valsEnd)
6100 {
6101   int nbCompo=getNumberOfComponents();
6102   if(nbCompo==1)
6103     _mem.insertAtTheEnd(valsBg,valsEnd);
6104   else if(nbCompo==0)
6105     {
6106       _info_on_compo.resize(1);
6107       _mem.insertAtTheEnd(valsBg,valsEnd);
6108     }
6109   else
6110     throw INTERP_KERNEL::Exception("DataArrayInt::pushBackValsSilent : not available for DataArrayInt with number of components different than 1 !");
6111 }
6112
6113 /*!
6114  * This method returns silently ( without updating time label in \a this ) the last value, if any and suppress it.
6115  * \throw If \a this is already empty.
6116  * \throw If \a this has number of components different from one.
6117  */
6118 int DataArrayInt::popBackSilent()
6119 {
6120   if(getNumberOfComponents()==1)
6121     return _mem.popBack();
6122   else
6123     throw INTERP_KERNEL::Exception("DataArrayInt::popBackSilent : not available for DataArrayInt with number of components different than 1 !");
6124 }
6125
6126 /*!
6127  * This method \b do \b not modify content of \a this. It only modify its memory footprint if the allocated memory is to high regarding real data to store.
6128  *
6129  * \sa DataArrayInt::getHeapMemorySizeWithoutChildren, DataArrayInt::reserve
6130  */
6131 void DataArrayInt::pack() const
6132 {
6133   _mem.pack();
6134 }
6135
6136 /*!
6137  * Allocates the raw data in memory. If exactly as same memory as needed already
6138  * allocated, it is not re-allocated.
6139  *  \param [in] nbOfTuple - number of tuples of data to allocate.
6140  *  \param [in] nbOfCompo - number of components of data to allocate.
6141  *  \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
6142  */
6143 void DataArrayInt::allocIfNecessary(int nbOfTuple, int nbOfCompo)
6144 {
6145   if(isAllocated())
6146     {
6147       if(nbOfTuple!=getNumberOfTuples() || nbOfCompo!=getNumberOfComponents())
6148         alloc(nbOfTuple,nbOfCompo);
6149     }
6150   else
6151     alloc(nbOfTuple,nbOfCompo);
6152 }
6153
6154 /*!
6155  * Allocates the raw data in memory. If the memory was already allocated, then it is
6156  * freed and re-allocated. See an example of this method use
6157  * \ref MEDCouplingArraySteps1WC "here".
6158  *  \param [in] nbOfTuple - number of tuples of data to allocate.
6159  *  \param [in] nbOfCompo - number of components of data to allocate.
6160  *  \throw If \a nbOfTuple < 0 or \a nbOfCompo < 0.
6161  */
6162 void DataArrayInt::alloc(int nbOfTuple, int nbOfCompo)
6163 {
6164   if(nbOfTuple<0 || nbOfCompo<0)
6165     throw INTERP_KERNEL::Exception("DataArrayInt::alloc : request for negative length of data !");
6166   _info_on_compo.resize(nbOfCompo);
6167   _mem.alloc(nbOfCompo*(std::size_t)nbOfTuple);
6168   declareAsNew();
6169 }
6170
6171 /*!
6172  * Assign zero to all values in \a this array. To know more on filling arrays see
6173  * \ref MEDCouplingArrayFill.
6174  * \throw If \a this is not allocated.
6175  */
6176 void DataArrayInt::fillWithZero()
6177 {
6178   checkAllocated();
6179   _mem.fillWithValue(0);
6180   declareAsNew();
6181 }
6182
6183 /*!
6184  * Assign \a val to all values in \a this array. To know more on filling arrays see
6185  * \ref MEDCouplingArrayFill.
6186  *  \param [in] val - the value to fill with.
6187  *  \throw If \a this is not allocated.
6188  */
6189 void DataArrayInt::fillWithValue(int val)
6190 {
6191   checkAllocated();
6192   _mem.fillWithValue(val);
6193   declareAsNew();
6194 }
6195
6196 /*!
6197  * Set all values in \a this array so that the i-th element equals to \a init + i
6198  * (i starts from zero). To know more on filling arrays see \ref MEDCouplingArrayFill.
6199  *  \param [in] init - value to assign to the first element of array.
6200  *  \throw If \a this->getNumberOfComponents() != 1
6201  *  \throw If \a this is not allocated.
6202  */
6203 void DataArrayInt::iota(int init)
6204 {
6205   checkAllocated();
6206   if(getNumberOfComponents()!=1)
6207     throw INTERP_KERNEL::Exception("DataArrayInt::iota : works only for arrays with only one component, you can call 'rearrange' method before !");
6208   int *ptr=getPointer();
6209   int ntuples=getNumberOfTuples();
6210   for(int i=0;i<ntuples;i++)
6211     ptr[i]=init+i;
6212   declareAsNew();
6213 }
6214
6215 /*!
6216  * Returns a textual and human readable representation of \a this instance of
6217  * DataArrayInt. This text is shown when a DataArrayInt is printed in Python.
6218  * \return std::string - text describing \a this DataArrayInt.
6219  *
6220  * \sa reprNotTooLong, reprZip
6221  */
6222 std::string DataArrayInt::repr() const
6223 {
6224   std::ostringstream ret;
6225   reprStream(ret);
6226   return ret.str();
6227 }
6228
6229 std::string DataArrayInt::reprZip() const
6230 {
6231   std::ostringstream ret;
6232   reprZipStream(ret);
6233   return ret.str();
6234 }
6235
6236 /*!
6237  * This method is close to repr method except that when \a this has more than 1000 tuples, all tuples are not
6238  * printed out to avoid to consume too much space in interpretor.
6239  * \sa repr
6240  */
6241 std::string DataArrayInt::reprNotTooLong() const
6242 {
6243   std::ostringstream ret;
6244   reprNotTooLongStream(ret);
6245   return ret.str();
6246 }
6247
6248 void DataArrayInt::writeVTK(std::ostream& ofs, int indent, const std::string& type, const std::string& nameInFile, DataArrayByte *byteArr) const
6249 {
6250   static const char SPACE[4]={' ',' ',' ',' '};
6251   checkAllocated();
6252   std::string idt(indent,' ');
6253   ofs << idt << "<DataArray type=\"" << type << "\" Name=\"" << nameInFile << "\" NumberOfComponents=\"" << getNumberOfComponents() << "\"";
6254   if(byteArr)
6255     {
6256       ofs << " format=\"appended\" offset=\"" << byteArr->getNumberOfTuples() << "\">";
6257       if(std::string(type)=="Int32")
6258         {
6259           const char *data(reinterpret_cast<const char *>(begin()));
6260           std::size_t sz(getNbOfElems()*sizeof(int));
6261           byteArr->insertAtTheEnd(data,data+sz);
6262           byteArr->insertAtTheEnd(SPACE,SPACE+4);
6263         }
6264       else if(std::string(type)=="Int8")
6265         {
6266           INTERP_KERNEL::AutoPtr<char> tmp(new char[getNbOfElems()]);
6267           std::copy(begin(),end(),(char *)tmp);
6268           byteArr->insertAtTheEnd((char *)tmp,(char *)tmp+getNbOfElems());
6269           byteArr->insertAtTheEnd(SPACE,SPACE+4);
6270         }
6271       else if(std::string(type)=="UInt8")
6272         {
6273           INTERP_KERNEL::AutoPtr<unsigned char> tmp(new unsigned char[getNbOfElems()]);
6274           std::copy(begin(),end(),(unsigned char *)tmp);
6275           byteArr->insertAtTheEnd((unsigned char *)tmp,(unsigned char *)tmp+getNbOfElems());
6276           byteArr->insertAtTheEnd(SPACE,SPACE+4);
6277         }
6278       else
6279         throw INTERP_KERNEL::Exception("DataArrayInt::writeVTK : Only Int32, Int8 and UInt8 supported !");
6280     }
6281   else
6282     {
6283       ofs << " RangeMin=\"" << getMinValueInArray() << "\" RangeMax=\"" << getMaxValueInArray() << "\" format=\"ascii\">\n" << idt;
6284       std::copy(begin(),end(),std::ostream_iterator<int>(ofs," "));
6285     }
6286   ofs << std::endl << idt << "</DataArray>\n";
6287 }
6288
6289 void DataArrayInt::reprStream(std::ostream& stream) const
6290 {
6291   stream << "Name of int array : \"" << _name << "\"\n";
6292   reprWithoutNameStream(stream);
6293 }
6294
6295 void DataArrayInt::reprZipStream(std::ostream& stream) const
6296 {
6297   stream << "Name of int array : \"" << _name << "\"\n";
6298   reprZipWithoutNameStream(stream);
6299 }
6300
6301 void DataArrayInt::reprNotTooLongStream(std::ostream& stream) const
6302 {
6303   stream << "Name of int array : \"" << _name << "\"\n";
6304   reprNotTooLongWithoutNameStream(stream);
6305 }
6306
6307 void DataArrayInt::reprWithoutNameStream(std::ostream& stream) const
6308 {
6309   DataArray::reprWithoutNameStream(stream);
6310   _mem.repr(getNumberOfComponents(),stream);
6311 }
6312
6313 void DataArrayInt::reprZipWithoutNameStream(std::ostream& stream) const
6314 {
6315   DataArray::reprWithoutNameStream(stream);
6316   _mem.reprZip(getNumberOfComponents(),stream);
6317 }
6318
6319 void DataArrayInt::reprNotTooLongWithoutNameStream(std::ostream& stream) const
6320 {
6321   DataArray::reprWithoutNameStream(stream);
6322   stream.precision(17);
6323   _mem.reprNotTooLong(getNumberOfComponents(),stream);
6324 }
6325
6326 void DataArrayInt::reprCppStream(const std::string& varName, std::ostream& stream) const
6327 {
6328   int nbTuples=getNumberOfTuples(),nbComp=getNumberOfComponents();
6329   const int *data=getConstPointer();
6330   stream << "DataArrayInt *" << varName << "=DataArrayInt::New();" << std::endl;
6331   if(nbTuples*nbComp>=1)
6332     {
6333       stream << "const int " << varName << "Data[" << nbTuples*nbComp << "]={";
6334       std::copy(data,data+nbTuples*nbComp-1,std::ostream_iterator<int>(stream,","));
6335       stream << data[nbTuples*nbComp-1] << "};" << std::endl;
6336       stream << varName << "->useArray(" << varName << "Data,false,CPP_DEALLOC," << nbTuples << "," << nbComp << ");" << std::endl;
6337     }
6338   else
6339     stream << varName << "->alloc(" << nbTuples << "," << nbComp << ");" << std::endl;
6340   stream << varName << "->setName(\"" << getName() << "\");" << std::endl;
6341 }
6342
6343 /*!
6344  * Method that gives a quick overvien of \a this for python.
6345  */
6346 void DataArrayInt::reprQuickOverview(std::ostream& stream) const
6347 {
6348   static const std::size_t MAX_NB_OF_BYTE_IN_REPR=300;
6349   stream << "DataArrayInt C++ instance at " << this << ". ";
6350   if(isAllocated())
6351     {
6352       int nbOfCompo=(int)_info_on_compo.size();
6353       if(nbOfCompo>=1)
6354         {
6355           int nbOfTuples=getNumberOfTuples();
6356           stream << "Number of tuples : " << nbOfTuples << ". Number of components : " << nbOfCompo << "." << std::endl;
6357           reprQuickOverviewData(stream,MAX_NB_OF_BYTE_IN_REPR);
6358         }
6359       else
6360         stream << "Number of components : 0.";
6361     }
6362   else
6363     stream << "*** No data allocated ****";
6364 }
6365
6366 void DataArrayInt::reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const
6367 {
6368   const int *data=begin();
6369   int nbOfTuples=getNumberOfTuples();
6370   int nbOfCompo=(int)_info_on_compo.size();
6371   std::ostringstream oss2; oss2 << "[";
6372   std::string oss2Str(oss2.str());
6373   bool isFinished=true;
6374   for(int i=0;i<nbOfTuples && isFinished;i++)
6375     {
6376       if(nbOfCompo>1)
6377         {
6378           oss2 << "(";
6379           for(int j=0;j<nbOfCompo;j++,data++)
6380             {
6381               oss2 << *data;
6382               if(j!=nbOfCompo-1) oss2 << ", ";
6383             }
6384           oss2 << ")";
6385         }
6386       else
6387         oss2 << *data++;
6388       if(i!=nbOfTuples-1) oss2 << ", ";
6389       std::string oss3Str(oss2.str());
6390       if(oss3Str.length()<maxNbOfByteInRepr)
6391         oss2Str=oss3Str;
6392       else
6393         isFinished=false;
6394     }
6395   stream << oss2Str;
6396   if(!isFinished)
6397     stream << "... ";
6398   stream << "]";
6399 }
6400
6401 /*!
6402  * Modifies in place \a this one-dimensional array so that each value \a v = \a indArrBg[ \a v ],
6403  * i.e. a current value is used as in index to get a new value from \a indArrBg.
6404  *  \param [in] indArrBg - pointer to the first element of array of new values to assign
6405  *         to \a this array.
6406  *  \param [in] indArrEnd - specifies the end of the array \a indArrBg, so that
6407  *              the last value of \a indArrBg is \a indArrEnd[ -1 ].
6408  *  \throw If \a this->getNumberOfComponents() != 1
6409  *  \throw If any value of \a this can't be used as a valid index for
6410  *         [\a indArrBg, \a indArrEnd).
6411  *
6412  *  \sa replaceOneValByInThis
6413  */
6414 void DataArrayInt::transformWithIndArr(const int *indArrBg, const int *indArrEnd)
6415 {
6416   checkAllocated();
6417   if(getNumberOfComponents()!=1)
6418     throw INTERP_KERNEL::Exception("Call transformWithIndArr method on DataArrayInt with only one component, you can call 'rearrange' method before !");
6419   int nbElemsIn((int)std::distance(indArrBg,indArrEnd)),nbOfTuples(getNumberOfTuples()),*pt(getPointer());
6420   for(int i=0;i<nbOfTuples;i++,pt++)
6421     {
6422       if(*pt>=0 && *pt<nbElemsIn)
6423         *pt=indArrBg[*pt];
6424       else
6425         {
6426           std::ostringstream oss; oss << "DataArrayInt::transformWithIndArr : error on tuple #" << i << " of this value is " << *pt << ", should be in [0," << nbElemsIn << ") !";
6427           throw INTERP_KERNEL::Exception(oss.str().c_str());
6428         }
6429     }
6430   declareAsNew();
6431 }
6432
6433 /*!
6434  * Modifies in place \a this one-dimensional array like this : each id in \a this so that this[id] equal to \a valToBeReplaced will be replaced at the same place by \a replacedBy.
6435  *
6436  * \param [in] valToBeReplaced - the value in \a this to be replaced.
6437  * \param [in] replacedBy - the value taken by each tuple previously equal to \a valToBeReplaced.
6438  *
6439  * \sa DataArrayInt::transformWithIndArr
6440  */
6441 void DataArrayInt::replaceOneValByInThis(int valToBeReplaced, int replacedBy)
6442 {
6443   checkAllocated();
6444   if(getNumberOfComponents()!=1)
6445     throw INTERP_KERNEL::Exception("Call replaceOneValByInThis method on DataArrayInt with only one component, you can call 'rearrange' method before !");
6446   if(valToBeReplaced==replacedBy)
6447     return ;
6448   int nbOfTuples(getNumberOfTuples()),*pt(getPointer());
6449   for(int i=0;i<nbOfTuples;i++,pt++)
6450     {
6451       if(*pt==valToBeReplaced)
6452         *pt=replacedBy;
6453     }
6454 }
6455
6456 /*!
6457  * Computes distribution of values of \a this one-dimensional array between given value
6458  * ranges (casts). This method is typically useful for entity number spliting by types,
6459  * for example.
6460  *  \warning The values contained in \a arrBg should be sorted ascendently. No
6461  *           check of this is be done. If not, the result is not warranted.
6462  *  \param [in] arrBg - the array of ascending values defining the value ranges. The i-th
6463  *         value of \a arrBg (\a arrBg[ i ]) gives the lowest value of the i-th range,
6464  *         and the greatest value of the i-th range equals to \a arrBg[ i+1 ] - 1. \a
6465  *         arrBg containing \a n values defines \a n-1 ranges. The last value of \a arrBg
6466  *         should be more than every value in \a this array.
6467  *  \param [in] arrEnd - specifies the end of the array \a arrBg, so that
6468  *              the last value of \a arrBg is \a arrEnd[ -1 ].
6469  *  \param [out] castArr - a new instance of DataArrayInt, of same size as \a this array
6470  *         (same number of tuples and components), the caller is to delete
6471  *         using decrRef() as it is no more needed.
6472  *         This array contains indices of ranges for every value of \a this array. I.e.
6473  *         the i-th value of \a castArr gives the index of range the i-th value of \a this
6474  *         belongs to. Or, in other words, this parameter contains for each tuple in \a
6475  *         this in which cast it holds.
6476  *  \param [out] rankInsideCast - a new instance of DataArrayInt, of same size as \a this
6477  *         array, the caller is to delete using decrRef() as it is no more needed.
6478  *         This array contains ranks of values of \a this array within ranges
6479  *         they belongs to. I.e. the i-th value of \a rankInsideCast gives the rank of
6480  *         the i-th value of \a this array within the \a castArr[ i ]-th range, to which
6481  *         the i-th value of \a this belongs to. Or, in other words, this param contains
6482  *         for each tuple its rank inside its cast. The rank is computed as difference
6483  *         between the value and the lowest value of range.
6484  *  \param [out] castsPresent - a new instance of DataArrayInt, containing indices of
6485  *         ranges (casts) to which at least one value of \a this array belongs.
6486  *         Or, in other words, this param contains the casts that \a this contains.
6487  *         The caller is to delete this array using decrRef() as it is no more needed.
6488  *
6489  * \b Example: If \a this contains [6,5,0,3,2,7,8,1,4] and \a arrBg contains [0,4,9] then
6490  *            the output of this method will be :
6491  * - \a castArr       : [1,1,0,0,0,1,1,0,1]
6492  * - \a rankInsideCast: [2,1,0,3,2,3,4,1,0]
6493  * - \a castsPresent  : [0,1]
6494  *
6495  * I.e. values of \a this array belong to 2 ranges: #0 and #1. Value 6 belongs to the
6496  * range #1 and its rank within this range is 2; etc.
6497  *
6498  *  \throw If \a this->getNumberOfComponents() != 1.
6499  *  \throw If \a arrEnd - arrBg < 2.
6500  *  \throw If any value of \a this is not less than \a arrEnd[-1].
6501  */
6502 void DataArrayInt::splitByValueRange(const int *arrBg, const int *arrEnd,
6503                                      DataArrayInt *& castArr, DataArrayInt *& rankInsideCast, DataArrayInt *& castsPresent) const
6504 {
6505   checkAllocated();
6506   if(getNumberOfComponents()!=1)
6507     throw INTERP_KERNEL::Exception("Call splitByValueRange  method on DataArrayInt with only one component, you can call 'rearrange' method before !");
6508   int nbOfTuples=getNumberOfTuples();
6509   std::size_t nbOfCast=std::distance(arrBg,arrEnd);
6510   if(nbOfCast<2)
6511     throw INTERP_KERNEL::Exception("DataArrayInt::splitByValueRange : The input array giving the cast range values should be of size >=2 !");
6512   nbOfCast--;
6513   const int *work=getConstPointer();
6514   typedef std::reverse_iterator<const int *> rintstart;
6515   rintstart bg(arrEnd);//OK no problem because size of 'arr' is greater or equal 2
6516   rintstart end2(arrBg);
6517   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New();
6518   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret2=DataArrayInt::New();
6519   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret3=DataArrayInt::New();
6520   ret1->alloc(nbOfTuples,1);
6521   ret2->alloc(nbOfTuples,1);
6522   int *ret1Ptr=ret1->getPointer();
6523   int *ret2Ptr=ret2->getPointer();
6524   std::set<std::size_t> castsDetected;
6525   for(int i=0;i<nbOfTuples;i++)
6526     {
6527       rintstart res=std::find_if(bg,end2,std::bind2nd(std::less_equal<int>(), work[i]));
6528       std::size_t pos=std::distance(bg,res);
6529       std::size_t pos2=nbOfCast-pos;
6530       if(pos2<nbOfCast)
6531         {
6532           ret1Ptr[i]=(int)pos2;
6533           ret2Ptr[i]=work[i]-arrBg[pos2];
6534           castsDetected.insert(pos2);
6535         }
6536       else
6537         {
6538           std::ostringstream oss; oss << "DataArrayInt::splitByValueRange : At rank #" << i << " the value is " << work[i] << " should be in [0," << *bg << ") !";
6539           throw INTERP_KERNEL::Exception(oss.str().c_str());
6540         }
6541     }
6542   ret3->alloc((int)castsDetected.size(),1);
6543   std::copy(castsDetected.begin(),castsDetected.end(),ret3->getPointer());
6544   castArr=ret1.retn();
6545   rankInsideCast=ret2.retn();
6546   castsPresent=ret3.retn();
6547 }
6548
6549 /*!
6550  * This method look at \a this if it can be considered as a range defined by the 3-tuple ( \a strt , \a sttoopp , \a stteepp ).
6551  * If false is returned the tuple must be ignored. If true is returned \a this can be considered by a range( \a strt , \a sttoopp , \a stteepp ).
6552  * This method works only if \a this is allocated and single component. If not an exception will be thrown.
6553  *
6554  * \param [out] strt - the start of the range (included) if true is returned.
6555  * \param [out] sttoopp - the end of the range (not included) if true is returned.
6556  * \param [out] stteepp - the step of the range if true is returned.
6557  * \return the verdict of the check.
6558  *
6559  * \sa DataArray::GetNumberOfItemGivenBES
6560  */
6561 bool DataArrayInt::isRange(int& strt, int& sttoopp, int& stteepp) const
6562 {
6563   checkAllocated();
6564   if(getNumberOfComponents()!=1)
6565     throw INTERP_KERNEL::Exception("DataArrayInt::isRange : this must be single component array !");
6566   int nbTuples(getNumberOfTuples());
6567   if(nbTuples==0)
6568     { strt=0; sttoopp=0; stteepp=1; return true; }
6569   const int *pt(begin());
6570   strt=*pt;
6571   if(nbTuples==1)
6572     { sttoopp=strt+1; stteepp=1; return true; }
6573   strt=*pt; sttoopp=pt[nbTuples-1];
6574   if(strt==sttoopp)
6575     return false;
6576   if(sttoopp>strt)
6577     {
6578       sttoopp++;
6579       int a(sttoopp-1-strt),tmp(strt);
6580       if(a%(nbTuples-1)!=0)
6581         return false;
6582       stteepp=a/(nbTuples-1);
6583       for(int i=0;i<nbTuples;i++,tmp+=stteepp)
6584         if(pt[i]!=tmp)
6585           return false;
6586       return true;
6587     }
6588   else
6589     {
6590       sttoopp--;
6591       int a(strt-sttoopp-1),tmp(strt);
6592       if(a%(nbTuples-1)!=0)
6593         return false;
6594       stteepp=-(a/(nbTuples-1));
6595       for(int i=0;i<nbTuples;i++,tmp+=stteepp)
6596         if(pt[i]!=tmp)
6597           return false;
6598       return true;
6599     }
6600 }
6601
6602 /*!
6603  * Creates a one-dimensional DataArrayInt (\a res) whose contents are computed from
6604  * values of \a this (\a a) and the given (\a indArr) arrays as follows:
6605  * \a res[ \a indArr[ \a a[ i ]]] = i. I.e. for each value in place i \a v = \a a[ i ],
6606  * new value in place \a indArr[ \a v ] is i.
6607  *  \param [in] indArrBg - the array holding indices within the result array to assign
6608  *         indices of values of \a this array pointing to values of \a indArrBg.
6609  *  \param [in] indArrEnd - specifies the end of the array \a indArrBg, so that
6610  *              the last value of \a indArrBg is \a indArrEnd[ -1 ].
6611  *  \return DataArrayInt * - the new instance of DataArrayInt.
6612  *          The caller is to delete this result array using decrRef() as it is no more
6613  *          needed.
6614  *  \throw If \a this->getNumberOfComponents() != 1.
6615  *  \throw If any value of \a this array is not a valid index for \a indArrBg array.
6616  *  \throw If any value of \a indArrBg is not a valid index for \a this array.
6617  */
6618 DataArrayInt *DataArrayInt::transformWithIndArrR(const int *indArrBg, const int *indArrEnd) const
6619 {
6620   checkAllocated();
6621   if(getNumberOfComponents()!=1)
6622     throw INTERP_KERNEL::Exception("Call transformWithIndArrR method on DataArrayInt with only one component, you can call 'rearrange' method before !");
6623   int nbElemsIn=(int)std::distance(indArrBg,indArrEnd);
6624   int nbOfTuples=getNumberOfTuples();
6625   const int *pt=getConstPointer();
6626   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6627   ret->alloc(nbOfTuples,1);
6628   ret->fillWithValue(-1);
6629   int *tmp=ret->getPointer();
6630   for(int i=0;i<nbOfTuples;i++,pt++)
6631     {
6632       if(*pt>=0 && *pt<nbElemsIn)
6633         {
6634           int pos=indArrBg[*pt];
6635           if(pos>=0 && pos<nbOfTuples)
6636             tmp[pos]=i;
6637           else
6638             {
6639               std::ostringstream oss; oss << "DataArrayInt::transformWithIndArrR : error on tuple #" << i << " value of new pos is " << pos << " ( indArrBg[" << *pt << "]) ! Should be in [0," << nbOfTuples << ") !";
6640               throw INTERP_KERNEL::Exception(oss.str().c_str());
6641             }
6642         }
6643       else
6644         {
6645           std::ostringstream oss; oss << "DataArrayInt::transformWithIndArrR : error on tuple #" << i << " value is " << *pt << " and indirectionnal array as a size equal to " << nbElemsIn << " !";
6646           throw INTERP_KERNEL::Exception(oss.str().c_str());
6647         }
6648     }
6649   return ret.retn();
6650 }
6651
6652 /*!
6653  * Creates a one-dimensional DataArrayInt of given length, whose contents are computed
6654  * from values of \a this array, which is supposed to contain a renumbering map in
6655  * "Old to New" mode. The result array contains a renumbering map in "New to Old" mode.
6656  * To know how to use the renumbering maps see \ref MEDCouplingArrayRenumbering.
6657  *  \param [in] newNbOfElem - the number of tuples in the result array.
6658  *  \return DataArrayInt * - the new instance of DataArrayInt.
6659  *          The caller is to delete this result array using decrRef() as it is no more
6660  *          needed.
6661  *
6662  *  \if ENABLE_EXAMPLES
6663  *  \ref cpp_mcdataarrayint_invertarrayo2n2n2o "Here is a C++ example".<br>
6664  *  \ref py_mcdataarrayint_invertarrayo2n2n2o  "Here is a Python example".
6665  *  \endif
6666  */
6667 DataArrayInt *DataArrayInt::invertArrayO2N2N2O(int newNbOfElem) const
6668 {
6669   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6670   ret->alloc(newNbOfElem,1);
6671   int nbOfOldNodes=getNumberOfTuples();
6672   const int *old2New=getConstPointer();
6673   int *pt=ret->getPointer();
6674   for(int i=0;i!=nbOfOldNodes;i++)
6675     {
6676       int newp(old2New[i]);
6677       if(newp!=-1)
6678         {
6679           if(newp>=0 && newp<newNbOfElem)
6680             pt[newp]=i;
6681           else
6682             {
6683               std::ostringstream oss; oss << "DataArrayInt::invertArrayO2N2N2O : At place #" << i << " the newplace is " << newp << " must be in [0," << newNbOfElem << ") !";
6684               throw INTERP_KERNEL::Exception(oss.str().c_str());
6685             }
6686         }
6687     }
6688   return ret.retn();
6689 }
6690
6691 /*!
6692  * This method is similar to DataArrayInt::invertArrayO2N2N2O except that
6693  * Example : If \a this contains [0,1,2,0,3,4,5,4,6,4] this method will return [0,1,2,4,5,6,8] whereas DataArrayInt::invertArrayO2N2N2O returns [3,1,2,4,9,6,8]
6694  */
6695 DataArrayInt *DataArrayInt::invertArrayO2N2N2OBis(int newNbOfElem) const
6696 {
6697   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6698   ret->alloc(newNbOfElem,1);
6699   int nbOfOldNodes=getNumberOfTuples();
6700   const int *old2New=getConstPointer();
6701   int *pt=ret->getPointer();
6702   for(int i=nbOfOldNodes-1;i>=0;i--)
6703     {
6704       int newp(old2New[i]);
6705       if(newp!=-1)
6706         {
6707           if(newp>=0 && newp<newNbOfElem)
6708             pt[newp]=i;
6709           else
6710             {
6711               std::ostringstream oss; oss << "DataArrayInt::invertArrayO2N2N2OBis : At place #" << i << " the newplace is " << newp << " must be in [0," << newNbOfElem << ") !";
6712               throw INTERP_KERNEL::Exception(oss.str().c_str());
6713             }
6714         }
6715     }
6716   return ret.retn();
6717 }
6718
6719 /*!
6720  * Creates a one-dimensional DataArrayInt of given length, whose contents are computed
6721  * from values of \a this array, which is supposed to contain a renumbering map in
6722  * "New to Old" mode. The result array contains a renumbering map in "Old to New" mode.
6723  * To know how to use the renumbering maps see \ref MEDCouplingArrayRenumbering.
6724  *  \param [in] newNbOfElem - the number of tuples in the result array.
6725  *  \return DataArrayInt * - the new instance of DataArrayInt.
6726  *          The caller is to delete this result array using decrRef() as it is no more
6727  *          needed.
6728  *
6729  *  \if ENABLE_EXAMPLES
6730  *  \ref cpp_mcdataarrayint_invertarrayn2o2o2n "Here is a C++ example".
6731  *
6732  *  \ref py_mcdataarrayint_invertarrayn2o2o2n "Here is a Python example".
6733  *  \endif
6734  */
6735 DataArrayInt *DataArrayInt::invertArrayN2O2O2N(int oldNbOfElem) const
6736 {
6737   checkAllocated();
6738   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
6739   ret->alloc(oldNbOfElem,1);
6740   const int *new2Old=getConstPointer();
6741   int *pt=ret->getPointer();
6742   std::fill(pt,pt+oldNbOfElem,-1);
6743   int nbOfNewElems=getNumberOfTuples();
6744   for(int i=0;i<nbOfNewElems;i++)
6745     {
6746       int v(new2Old[i]);
6747       if(v>=0 && v<oldNbOfElem)
6748         pt[v]=i;
6749       else
6750         {
6751           std::ostringstream oss; oss << "DataArrayInt::invertArrayN2O2O2N : in new id #" << i << " old value is " << v << " expected to be in [0," << oldNbOfElem << ") !";
6752           throw INTERP_KERNEL::Exception(oss.str().c_str());
6753         }
6754     }
6755   return ret.retn();
6756 }
6757
6758 /*!
6759  * Equivalent to DataArrayInt::isEqual except that if false the reason of
6760  * mismatch is given.
6761  *
6762  * \param [in] other the instance to be compared with \a this
6763  * \param [out] reason In case of inequality returns the reason.
6764  * \sa DataArrayInt::isEqual
6765  */
6766 bool DataArrayInt::isEqualIfNotWhy(const DataArrayInt& other, std::string& reason) const
6767 {
6768   if(!areInfoEqualsIfNotWhy(other,reason))
6769     return false;
6770   return _mem.isEqual(other._mem,0,reason);
6771 }
6772
6773 /*!
6774  * Checks if \a this and another DataArrayInt are fully equal. For more info see
6775  * \ref MEDCouplingArrayBasicsCompare.
6776  *  \param [in] other - an instance of DataArrayInt to compare with \a this one.
6777  *  \return bool - \a true if the two arrays are equal, \a false else.
6778  */
6779 bool DataArrayInt::isEqual(const DataArrayInt& other) const
6780 {
6781   std::string tmp;
6782   return isEqualIfNotWhy(other,tmp);
6783 }
6784
6785 /*!
6786  * Checks if values of \a this and another DataArrayInt are equal. For more info see
6787  * \ref MEDCouplingArrayBasicsCompare.
6788  *  \param [in] other - an instance of DataArrayInt to compare with \a this one.
6789  *  \return bool - \a true if the values of two arrays are equal, \a false else.
6790  */
6791 bool DataArrayInt::isEqualWithoutConsideringStr(const DataArrayInt& other) const
6792 {
6793   std::string tmp;
6794   return _mem.isEqual(other._mem,0,tmp);
6795 }
6796
6797 /*!
6798  * Checks if values of \a this and another DataArrayInt are equal. Comparison is
6799  * performed on sorted value sequences.
6800  * For more info see\ref MEDCouplingArrayBasicsCompare.
6801  *  \param [in] other - an instance of DataArrayInt to compare with \a this one.
6802  *  \return bool - \a true if the sorted values of two arrays are equal, \a false else.
6803  */
6804 bool DataArrayInt::isEqualWithoutConsideringStrAndOrder(const DataArrayInt& other) const
6805 {
6806   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> a=deepCpy();
6807   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> b=other.deepCpy();
6808   a->sort();
6809   b->sort();
6810   return a->isEqualWithoutConsideringStr(*b);
6811 }
6812
6813 /*!
6814  * This method compares content of input vector \a v and \a this.
6815  * If for each id in \a this v[id]==True and for all other ids id2 not in \a this v[id2]==False, true is returned.
6816  * For performance reasons \a this is expected to be sorted ascendingly. If not an exception will be thrown.
6817  *
6818  * \param [in] v - the vector of 'flags' to be compared with \a this.
6819  *
6820  * \throw If \a this is not sorted ascendingly.
6821  * \throw If \a this has not exactly one component.
6822  * \throw If \a this is not allocated.
6823  */
6824 bool DataArrayInt::isFittingWith(const std::vector<bool>& v) const
6825 {
6826   checkAllocated();
6827   if(getNumberOfComponents()!=1)
6828     throw INTERP_KERNEL::Exception("DataArrayInt::isFittingWith : number of components of this should be equal to one !");
6829   const int *w(begin()),*end2(end());
6830   int refVal=-std::numeric_limits<int>::max();
6831   int i=0;
6832   std::vector<bool>::const_iterator it(v.begin());
6833   for(;it!=v.end();it++,i++)
6834     {
6835       if(*it)
6836         {
6837           if(w!=end2)
6838             {
6839               if(*w++==i)
6840                 {
6841                   if(i>refVal)
6842                     refVal=i;
6843                   else
6844                     {
6845                       std::ostringstream oss; oss << "DataArrayInt::isFittingWith : At pos #" << std::distance(begin(),w-1) << " this is not sorted ascendingly !";
6846                       throw INTERP_KERNEL::Exception(oss.str().c_str());
6847                     }
6848                 }
6849               else
6850                 return false;
6851             }
6852           else
6853             return false;
6854         }
6855     }
6856   return w==end2;
6857 }
6858
6859 /*!
6860  * This method assumes that \a this has one component and is allocated. This method scans all tuples in \a this and for all tuple equal to \a val
6861  * put True to the corresponding entry in \a vec.
6862  * \a vec is expected to be with the same size than the number of tuples of \a this.
6863  */
6864 void DataArrayInt::switchOnTupleEqualTo(int val, std::vector<bool>& vec) const
6865 {
6866   checkAllocated();
6867   if(getNumberOfComponents()!=1)
6868     throw INTERP_KERNEL::Exception("DataArrayInt::switchOnTupleEqualTo : number of components of this should be equal to one !");
6869   int nbOfTuples(getNumberOfTuples());
6870   if(nbOfTuples!=(int)vec.size())
6871     throw INTERP_KERNEL::Exception("DataArrayInt::switchOnTupleEqualTo : number of tuples of this should be equal to size of input vector of bool !");
6872   const int *pt(begin());
6873   for(int i=0;i<nbOfTuples;i++)
6874     if(pt[i]==val)
6875       vec[i]=true;
6876 }
6877
6878 /*!
6879  * Sorts values of the array.
6880  *  \param [in] asc - \a true means ascending order, \a false, descending.
6881  *  \throw If \a this is not allocated.
6882  *  \throw If \a this->getNumberOfComponents() != 1.
6883  */
6884 void DataArrayInt::sort(bool asc)
6885 {
6886   checkAllocated();
6887   if(getNumberOfComponents()!=1)
6888     throw INTERP_KERNEL::Exception("DataArrayInt::sort : only supported with 'this' array with ONE component !");
6889   _mem.sort(asc);
6890   declareAsNew();
6891 }
6892
6893 /*!
6894  * Computes for each tuple the sum of number of components values in the tuple and return it.
6895  *
6896  * \return DataArrayInt * - the new instance of DataArrayInt containing the
6897  *          same number of tuples as \a this array and one component.
6898  *          The caller is to delete this result array using decrRef() as it is no more
6899  *          needed.
6900  *  \throw If \a this is not allocated.
6901  */
6902 DataArrayInt *DataArrayInt::sumPerTuple() const
6903 {
6904   checkAllocated();
6905   int nbOfComp(getNumberOfComponents()),nbOfTuple(getNumberOfTuples());
6906   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
6907   ret->alloc(nbOfTuple,1);
6908   const int *src(getConstPointer());
6909   int *dest(ret->getPointer());
6910   for(int i=0;i<nbOfTuple;i++,dest++,src+=nbOfComp)
6911     *dest=std::accumulate(src,src+nbOfComp,0);
6912   return ret.retn();
6913 }
6914
6915 /*!
6916  * Reverse the array values.
6917  *  \throw If \a this->getNumberOfComponents() < 1.
6918  *  \throw If \a this is not allocated.
6919  */
6920 void DataArrayInt::reverse()
6921 {
6922   checkAllocated();
6923   _mem.reverse(getNumberOfComponents());
6924   declareAsNew();
6925 }
6926
6927 /*!
6928  * Checks that \a this array is consistently **increasing** or **decreasing** in value.
6929  * If not an exception is thrown.
6930  *  \param [in] increasing - if \a true, the array values should be increasing.
6931  *  \throw If sequence of values is not strictly monotonic in agreement with \a
6932  *         increasing arg.
6933  *  \throw If \a this->getNumberOfComponents() != 1.
6934  *  \throw If \a this is not allocated.
6935  */
6936 void DataArrayInt::checkMonotonic(bool increasing) const
6937 {
6938   if(!isMonotonic(increasing))
6939     {
6940       if (increasing)
6941         throw INTERP_KERNEL::Exception("DataArrayInt::checkMonotonic : 'this' is not INCREASING monotonic !");
6942       else
6943         throw INTERP_KERNEL::Exception("DataArrayInt::checkMonotonic : 'this' is not DECREASING monotonic !");
6944     }
6945 }
6946
6947 /*!
6948  * Checks that \a this array is consistently **increasing** or **decreasing** in value.
6949  *  \param [in] increasing - if \a true, array values should be increasing.
6950  *  \return bool - \a true if values change in accordance with \a increasing arg.
6951  *  \throw If \a this->getNumberOfComponents() != 1.
6952  *  \throw If \a this is not allocated.
6953  */
6954 bool DataArrayInt::isMonotonic(bool increasing) const
6955 {
6956   checkAllocated();
6957   if(getNumberOfComponents()!=1)
6958     throw INTERP_KERNEL::Exception("DataArrayInt::isMonotonic : only supported with 'this' array with ONE component !");
6959   int nbOfElements=getNumberOfTuples();
6960   const int *ptr=getConstPointer();
6961   if(nbOfElements==0)
6962     return true;
6963   int ref=ptr[0];
6964   if(increasing)
6965     {
6966       for(int i=1;i<nbOfElements;i++)
6967         {
6968           if(ptr[i]>=ref)
6969             ref=ptr[i];
6970           else
6971             return false;
6972         }
6973     }
6974   else
6975     {
6976       for(int i=1;i<nbOfElements;i++)
6977         {
6978           if(ptr[i]<=ref)
6979             ref=ptr[i];
6980           else
6981             return false;
6982         }
6983     }
6984   return true;
6985 }
6986
6987 /*!
6988  * This method check that array consistently INCREASING or DECREASING in value.
6989  */
6990 bool DataArrayInt::isStrictlyMonotonic(bool increasing) const
6991 {
6992   checkAllocated();
6993   if(getNumberOfComponents()!=1)
6994     throw INTERP_KERNEL::Exception("DataArrayInt::isStrictlyMonotonic : only supported with 'this' array with ONE component !");
6995   int nbOfElements=getNumberOfTuples();
6996   const int *ptr=getConstPointer();
6997   if(nbOfElements==0)
6998     return true;
6999   int ref=ptr[0];
7000   if(increasing)
7001     {
7002       for(int i=1;i<nbOfElements;i++)
7003         {
7004           if(ptr[i]>ref)
7005             ref=ptr[i];
7006           else
7007             return false;
7008         }
7009     }
7010   else
7011     {
7012       for(int i=1;i<nbOfElements;i++)
7013         {
7014           if(ptr[i]<ref)
7015             ref=ptr[i];
7016           else
7017             return false;
7018         }
7019     }
7020   return true;
7021 }
7022
7023 /*!
7024  * This method check that array consistently INCREASING or DECREASING in value.
7025  */
7026 void DataArrayInt::checkStrictlyMonotonic(bool increasing) const
7027 {
7028   if(!isStrictlyMonotonic(increasing))
7029     {
7030       if (increasing)
7031         throw INTERP_KERNEL::Exception("DataArrayInt::checkStrictlyMonotonic : 'this' is not strictly INCREASING monotonic !");
7032       else
7033         throw INTERP_KERNEL::Exception("DataArrayInt::checkStrictlyMonotonic : 'this' is not strictly DECREASING monotonic !");
7034     }
7035 }
7036
7037 /*!
7038  * Creates a new one-dimensional DataArrayInt of the same size as \a this and a given
7039  * one-dimensional arrays that must be of the same length. The result array describes
7040  * correspondence between \a this and \a other arrays, so that
7041  * <em> other.getIJ(i,0) == this->getIJ(ret->getIJ(i),0)</em>. If such a permutation is
7042  * not possible because some element in \a other is not in \a this, an exception is thrown.
7043  *  \param [in] other - an array to compute permutation to.
7044  *  \return DataArrayInt * - a new instance of DataArrayInt, which is a permutation array
7045  * from \a this to \a other. The caller is to delete this array using decrRef() as it is
7046  * no more needed.
7047  *  \throw If \a this->getNumberOfComponents() != 1.
7048  *  \throw If \a other->getNumberOfComponents() != 1.
7049  *  \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples().
7050  *  \throw If \a other includes a value which is not in \a this array.
7051  *
7052  *  \if ENABLE_EXAMPLES
7053  *  \ref cpp_mcdataarrayint_buildpermutationarr "Here is a C++ example".
7054  *
7055  *  \ref py_mcdataarrayint_buildpermutationarr "Here is a Python example".
7056  *  \endif
7057  */
7058 DataArrayInt *DataArrayInt::buildPermutationArr(const DataArrayInt& other) const
7059 {
7060   checkAllocated();
7061   if(getNumberOfComponents()!=1 || other.getNumberOfComponents()!=1)
7062     throw INTERP_KERNEL::Exception("DataArrayInt::buildPermutationArr : 'this' and 'other' have to have exactly ONE component !");
7063   int nbTuple=getNumberOfTuples();
7064   other.checkAllocated();
7065   if(nbTuple!=other.getNumberOfTuples())
7066     throw INTERP_KERNEL::Exception("DataArrayInt::buildPermutationArr : 'this' and 'other' must have the same number of tuple !");
7067   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7068   ret->alloc(nbTuple,1);
7069   ret->fillWithValue(-1);
7070   const int *pt=getConstPointer();
7071   std::map<int,int> mm;
7072   for(int i=0;i<nbTuple;i++)
7073     mm[pt[i]]=i;
7074   pt=other.getConstPointer();
7075   int *retToFill=ret->getPointer();
7076   for(int i=0;i<nbTuple;i++)
7077     {
7078       std::map<int,int>::const_iterator it=mm.find(pt[i]);
7079       if(it==mm.end())
7080         {
7081           std::ostringstream oss; oss << "DataArrayInt::buildPermutationArr : Arrays mismatch : element (" << pt[i] << ") in 'other' not findable in 'this' !";
7082           throw INTERP_KERNEL::Exception(oss.str().c_str());
7083         }
7084       retToFill[i]=(*it).second;
7085     }
7086   return ret.retn();
7087 }
7088
7089 /*!
7090  * Sets a C array to be used as raw data of \a this. The previously set info
7091  *  of components is retained and re-sized.
7092  * For more info see \ref MEDCouplingArraySteps1.
7093  *  \param [in] array - the C array to be used as raw data of \a this.
7094  *  \param [in] ownership - if \a true, \a array will be deallocated at destruction of \a this.
7095  *  \param [in] type - specifies how to deallocate \a array. If \a type == ParaMEDMEM::CPP_DEALLOC,
7096  *                     \c delete [] \c array; will be called. If \a type == ParaMEDMEM::C_DEALLOC,
7097  *                     \c free(\c array ) will be called.
7098  *  \param [in] nbOfTuple - new number of tuples in \a this.
7099  *  \param [in] nbOfCompo - new number of components in \a this.
7100  */
7101 void DataArrayInt::useArray(const int *array, bool ownership,  DeallocType type, int nbOfTuple, int nbOfCompo)
7102 {
7103   _info_on_compo.resize(nbOfCompo);
7104   _mem.useArray(array,ownership,type,nbOfTuple*nbOfCompo);
7105   declareAsNew();
7106 }
7107
7108 void DataArrayInt::useExternalArrayWithRWAccess(const int *array, int nbOfTuple, int nbOfCompo)
7109 {
7110   _info_on_compo.resize(nbOfCompo);
7111   _mem.useExternalArrayWithRWAccess(array,nbOfTuple*nbOfCompo);
7112   declareAsNew();
7113 }
7114
7115 /*!
7116  * Returns a new DataArrayInt holding the same values as \a this array but differently
7117  * arranged in memory. If \a this array holds 2 components of 3 values:
7118  * \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$, then the result array holds these values arranged
7119  * as follows: \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$.
7120  *  \warning Do not confuse this method with transpose()!
7121  *  \return DataArrayInt * - the new instance of DataArrayInt that the caller
7122  *          is to delete using decrRef() as it is no more needed.
7123  *  \throw If \a this is not allocated.
7124  */
7125 DataArrayInt *DataArrayInt::fromNoInterlace() const
7126 {
7127   checkAllocated();
7128   if(_mem.isNull())
7129     throw INTERP_KERNEL::Exception("DataArrayInt::fromNoInterlace : Not defined array !");
7130   int *tab=_mem.fromNoInterlace(getNumberOfComponents());
7131   DataArrayInt *ret=DataArrayInt::New();
7132   ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
7133   return ret;
7134 }
7135
7136 /*!
7137  * Returns a new DataArrayInt holding the same values as \a this array but differently
7138  * arranged in memory. If \a this array holds 2 components of 3 values:
7139  * \f$ x_0,y_0,x_1,y_1,x_2,y_2 \f$, then the result array holds these values arranged
7140  * as follows: \f$ x_0,x_1,x_2,y_0,y_1,y_2 \f$.
7141  *  \warning Do not confuse this method with transpose()!
7142  *  \return DataArrayInt * - the new instance of DataArrayInt that the caller
7143  *          is to delete using decrRef() as it is no more needed.
7144  *  \throw If \a this is not allocated.
7145  */
7146 DataArrayInt *DataArrayInt::toNoInterlace() const
7147 {
7148   checkAllocated();
7149   if(_mem.isNull())
7150     throw INTERP_KERNEL::Exception("DataArrayInt::toNoInterlace : Not defined array !");
7151   int *tab=_mem.toNoInterlace(getNumberOfComponents());
7152   DataArrayInt *ret=DataArrayInt::New();
7153   ret->useArray(tab,true,C_DEALLOC,getNumberOfTuples(),getNumberOfComponents());
7154   return ret;
7155 }
7156
7157 /*!
7158  * Permutes values of \a this array as required by \a old2New array. The values are
7159  * permuted so that \c new[ \a old2New[ i ]] = \c old[ i ]. Number of tuples remains
7160  * the same as in \this one.
7161  * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
7162  * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7163  *  \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
7164  *     giving a new position for i-th old value.
7165  */
7166 void DataArrayInt::renumberInPlace(const int *old2New)
7167 {
7168   checkAllocated();
7169   int nbTuples=getNumberOfTuples();
7170   int nbOfCompo=getNumberOfComponents();
7171   int *tmp=new int[nbTuples*nbOfCompo];
7172   const int *iptr=getConstPointer();
7173   for(int i=0;i<nbTuples;i++)
7174     {
7175       int v=old2New[i];
7176       if(v>=0 && v<nbTuples)
7177         std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),tmp+nbOfCompo*v);
7178       else
7179         {
7180           std::ostringstream oss; oss << "DataArrayInt::renumberInPlace : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
7181           throw INTERP_KERNEL::Exception(oss.str().c_str());
7182         }
7183     }
7184   std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
7185   delete [] tmp;
7186   declareAsNew();
7187 }
7188
7189 /*!
7190  * Permutes values of \a this array as required by \a new2Old array. The values are
7191  * permuted so that \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of tuples remains
7192  * the same as in \this one.
7193  * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7194  *  \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
7195  *     giving a previous position of i-th new value.
7196  *  \return DataArrayInt * - the new instance of DataArrayInt that the caller
7197  *          is to delete using decrRef() as it is no more needed.
7198  */
7199 void DataArrayInt::renumberInPlaceR(const int *new2Old)
7200 {
7201   checkAllocated();
7202   int nbTuples=getNumberOfTuples();
7203   int nbOfCompo=getNumberOfComponents();
7204   int *tmp=new int[nbTuples*nbOfCompo];
7205   const int *iptr=getConstPointer();
7206   for(int i=0;i<nbTuples;i++)
7207     {
7208       int v=new2Old[i];
7209       if(v>=0 && v<nbTuples)
7210         std::copy(iptr+nbOfCompo*v,iptr+nbOfCompo*(v+1),tmp+nbOfCompo*i);
7211       else
7212         {
7213           std::ostringstream oss; oss << "DataArrayInt::renumberInPlaceR : At place #" << i << " value is " << v << " ! Should be in [0," << nbTuples << ") !";
7214           throw INTERP_KERNEL::Exception(oss.str().c_str());
7215         }
7216     }
7217   std::copy(tmp,tmp+nbTuples*nbOfCompo,getPointer());
7218   delete [] tmp;
7219   declareAsNew();
7220 }
7221
7222 /*!
7223  * Returns a copy of \a this array with values permuted as required by \a old2New array.
7224  * The values are permuted so that  \c new[ \a old2New[ i ]] = \c old[ i ].
7225  * Number of tuples in the result array remains the same as in \this one.
7226  * If a permutation reduction is needed, renumberAndReduce() should be used.
7227  * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7228  *  \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
7229  *          giving a new position for i-th old value.
7230  *  \return DataArrayInt * - the new instance of DataArrayInt that the caller
7231  *          is to delete using decrRef() as it is no more needed.
7232  *  \throw If \a this is not allocated.
7233  */
7234 DataArrayInt *DataArrayInt::renumber(const int *old2New) const
7235 {
7236   checkAllocated();
7237   int nbTuples=getNumberOfTuples();
7238   int nbOfCompo=getNumberOfComponents();
7239   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7240   ret->alloc(nbTuples,nbOfCompo);
7241   ret->copyStringInfoFrom(*this);
7242   const int *iptr=getConstPointer();
7243   int *optr=ret->getPointer();
7244   for(int i=0;i<nbTuples;i++)
7245     std::copy(iptr+nbOfCompo*i,iptr+nbOfCompo*(i+1),optr+nbOfCompo*old2New[i]);
7246   ret->copyStringInfoFrom(*this);
7247   return ret.retn();
7248 }
7249
7250 /*!
7251  * Returns a copy of \a this array with values permuted as required by \a new2Old array.
7252  * The values are permuted so that  \c new[ i ] = \c old[ \a new2Old[ i ]]. Number of
7253  * tuples in the result array remains the same as in \this one.
7254  * If a permutation reduction is needed, substr() or selectByTupleId() should be used.
7255  * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7256  *  \param [in] new2Old - C array of length equal to \a this->getNumberOfTuples()
7257  *     giving a previous position of i-th new value.
7258  *  \return DataArrayInt * - the new instance of DataArrayInt that the caller
7259  *          is to delete using decrRef() as it is no more needed.
7260  */
7261 DataArrayInt *DataArrayInt::renumberR(const int *new2Old) const
7262 {
7263   checkAllocated();
7264   int nbTuples=getNumberOfTuples();
7265   int nbOfCompo=getNumberOfComponents();
7266   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7267   ret->alloc(nbTuples,nbOfCompo);
7268   ret->copyStringInfoFrom(*this);
7269   const int *iptr=getConstPointer();
7270   int *optr=ret->getPointer();
7271   for(int i=0;i<nbTuples;i++)
7272     std::copy(iptr+nbOfCompo*new2Old[i],iptr+nbOfCompo*(new2Old[i]+1),optr+nbOfCompo*i);
7273   ret->copyStringInfoFrom(*this);
7274   return ret.retn();
7275 }
7276
7277 /*!
7278  * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
7279  * of size \a newNbOfTuple and it's values are permuted as required by \a old2New array.
7280  * The values are permuted so that  \c new[ \a old2New[ i ]] = \c old[ i ] for all
7281  * \a old2New[ i ] >= 0. In other words every i-th tuple in \a this array, for which
7282  * \a old2New[ i ] is negative, is missing from the result array.
7283  * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7284  *  \param [in] old2New - C array of length equal to \a this->getNumberOfTuples()
7285  *     giving a new position for i-th old tuple and giving negative position for
7286  *     for i-th old tuple that should be omitted.
7287  *  \return DataArrayInt * - the new instance of DataArrayInt that the caller
7288  *          is to delete using decrRef() as it is no more needed.
7289  */
7290 DataArrayInt *DataArrayInt::renumberAndReduce(const int *old2New, int newNbOfTuple) const
7291 {
7292   checkAllocated();
7293   int nbTuples=getNumberOfTuples();
7294   int nbOfCompo=getNumberOfComponents();
7295   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7296   ret->alloc(newNbOfTuple,nbOfCompo);
7297   const int *iptr=getConstPointer();
7298   int *optr=ret->getPointer();
7299   for(int i=0;i<nbTuples;i++)
7300     {
7301       int w=old2New[i];
7302       if(w>=0)
7303         std::copy(iptr+i*nbOfCompo,iptr+(i+1)*nbOfCompo,optr+w*nbOfCompo);
7304     }
7305   ret->copyStringInfoFrom(*this);
7306   return ret.retn();
7307 }
7308
7309 /*!
7310  * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
7311  * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
7312  * \a new2OldBg array.
7313  * The values are permuted so that  \c new[ i ] = \c old[ \a new2OldBg[ i ]].
7314  * This method is equivalent to renumberAndReduce() except that convention in input is
7315  * \c new2old and \b not \c old2new.
7316  * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7317  *  \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
7318  *              tuple index in \a this array to fill the i-th tuple in the new array.
7319  *  \param [in] new2OldEnd - specifies the end of the permutation array that starts at
7320  *              \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
7321  *              \a new2OldBg <= \a pi < \a new2OldEnd.
7322  *  \return DataArrayInt * - the new instance of DataArrayInt that the caller
7323  *          is to delete using decrRef() as it is no more needed.
7324  */
7325 DataArrayInt *DataArrayInt::selectByTupleId(const int *new2OldBg, const int *new2OldEnd) const
7326 {
7327   checkAllocated();
7328   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7329   int nbComp=getNumberOfComponents();
7330   ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
7331   ret->copyStringInfoFrom(*this);
7332   int *pt=ret->getPointer();
7333   const int *srcPt=getConstPointer();
7334   int i=0;
7335   for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
7336     std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
7337   ret->copyStringInfoFrom(*this);
7338   return ret.retn();
7339 }
7340
7341 /*!
7342  * Returns a shorten and permuted copy of \a this array. The new DataArrayInt is
7343  * of size \a new2OldEnd - \a new2OldBg and it's values are permuted as required by
7344  * \a new2OldBg array.
7345  * The values are permuted so that  \c new[ i ] = \c old[ \a new2OldBg[ i ]].
7346  * This method is equivalent to renumberAndReduce() except that convention in input is
7347  * \c new2old and \b not \c old2new.
7348  * This method is equivalent to selectByTupleId() except that it prevents coping data
7349  * from behind the end of \a this array.
7350  * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7351  *  \param [in] new2OldBg - pointer to the beginning of a permutation array that gives a
7352  *              tuple index in \a this array to fill the i-th tuple in the new array.
7353  *  \param [in] new2OldEnd - specifies the end of the permutation array that starts at
7354  *              \a new2OldBg, so that pointer to a tuple index (\a pi) varies as this:
7355  *              \a new2OldBg <= \a pi < \a new2OldEnd.
7356  *  \return DataArrayInt * - the new instance of DataArrayInt that the caller
7357  *          is to delete using decrRef() as it is no more needed.
7358  *  \throw If \a new2OldEnd - \a new2OldBg > \a this->getNumberOfTuples().
7359  */
7360 DataArrayInt *DataArrayInt::selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const
7361 {
7362   checkAllocated();
7363   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7364   int nbComp=getNumberOfComponents();
7365   int oldNbOfTuples=getNumberOfTuples();
7366   ret->alloc((int)std::distance(new2OldBg,new2OldEnd),nbComp);
7367   ret->copyStringInfoFrom(*this);
7368   int *pt=ret->getPointer();
7369   const int *srcPt=getConstPointer();
7370   int i=0;
7371   for(const int *w=new2OldBg;w!=new2OldEnd;w++,i++)
7372     if(*w>=0 && *w<oldNbOfTuples)
7373       std::copy(srcPt+(*w)*nbComp,srcPt+((*w)+1)*nbComp,pt+i*nbComp);
7374     else
7375       throw INTERP_KERNEL::Exception("DataArrayInt::selectByTupleIdSafe : some ids has been detected to be out of [0,this->getNumberOfTuples) !");
7376   ret->copyStringInfoFrom(*this);
7377   return ret.retn();
7378 }
7379
7380 /*!
7381  * Returns a shorten copy of \a this array. The new DataArrayInt contains every
7382  * (\a bg + \c i * \a step)-th tuple of \a this array located before the \a end2-th
7383  * tuple. Indices of the selected tuples are the same as ones returned by the Python
7384  * command \c range( \a bg, \a end2, \a step ).
7385  * This method is equivalent to selectByTupleIdSafe() except that the input array is
7386  * not constructed explicitly.
7387  * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7388  *  \param [in] bg - index of the first tuple to copy from \a this array.
7389  *  \param [in] end2 - index of the tuple before which the tuples to copy are located.
7390  *  \param [in] step - index increment to get index of the next tuple to copy.
7391  *  \return DataArrayInt * - the new instance of DataArrayInt that the caller
7392  *          is to delete using decrRef() as it is no more needed.
7393  *  \sa DataArrayInt::substr.
7394  */
7395 DataArrayInt *DataArrayInt::selectByTupleId2(int bg, int end2, int step) const
7396 {
7397   checkAllocated();
7398   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7399   int nbComp=getNumberOfComponents();
7400   int newNbOfTuples=GetNumberOfItemGivenBESRelative(bg,end2,step,"DataArrayInt::selectByTupleId2 : ");
7401   ret->alloc(newNbOfTuples,nbComp);
7402   int *pt=ret->getPointer();
7403   const int *srcPt=getConstPointer()+bg*nbComp;
7404   for(int i=0;i<newNbOfTuples;i++,srcPt+=step*nbComp)
7405     std::copy(srcPt,srcPt+nbComp,pt+i*nbComp);
7406   ret->copyStringInfoFrom(*this);
7407   return ret.retn();
7408 }
7409
7410 /*!
7411  * Returns a shorten copy of \a this array. The new DataArrayInt contains ranges
7412  * of tuples specified by \a ranges parameter.
7413  * For more info on renumbering see \ref MEDCouplingArrayRenumbering.
7414  *  \param [in] ranges - std::vector of std::pair's each of which defines a range
7415  *              of tuples in [\c begin,\c end) format.
7416  *  \return DataArrayInt * - the new instance of DataArrayInt that the caller
7417  *          is to delete using decrRef() as it is no more needed.
7418  *  \throw If \a end < \a begin.
7419  *  \throw If \a end > \a this->getNumberOfTuples().
7420  *  \throw If \a this is not allocated.
7421  */
7422 DataArray *DataArrayInt::selectByTupleRanges(const std::vector<std::pair<int,int> >& ranges) const
7423 {
7424   checkAllocated();
7425   int nbOfComp=getNumberOfComponents();
7426   int nbOfTuplesThis=getNumberOfTuples();
7427   if(ranges.empty())
7428     {
7429       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7430       ret->alloc(0,nbOfComp);
7431       ret->copyStringInfoFrom(*this);
7432       return ret.retn();
7433     }
7434   int ref=ranges.front().first;
7435   int nbOfTuples=0;
7436   bool isIncreasing=true;
7437   for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
7438     {
7439       if((*it).first<=(*it).second)
7440         {
7441           if((*it).first>=0 && (*it).second<=nbOfTuplesThis)
7442             {
7443               nbOfTuples+=(*it).second-(*it).first;
7444               if(isIncreasing)
7445                 isIncreasing=ref<=(*it).first;
7446               ref=(*it).second;
7447             }
7448           else
7449             {
7450               std::ostringstream oss; oss << "DataArrayInt::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
7451               oss << " (" << (*it).first << "," << (*it).second << ") is greater than number of tuples of this :" << nbOfTuples << " !";
7452               throw INTERP_KERNEL::Exception(oss.str().c_str());
7453             }
7454         }
7455       else
7456         {
7457           std::ostringstream oss; oss << "DataArrayInt::selectByTupleRanges : on range #" << std::distance(ranges.begin(),it);
7458           oss << " (" << (*it).first << "," << (*it).second << ") end is before begin !";
7459           throw INTERP_KERNEL::Exception(oss.str().c_str());
7460         }
7461     }
7462   if(isIncreasing && nbOfTuplesThis==nbOfTuples)
7463     return deepCpy();
7464   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7465   ret->alloc(nbOfTuples,nbOfComp);
7466   ret->copyStringInfoFrom(*this);
7467   const int *src=getConstPointer();
7468   int *work=ret->getPointer();
7469   for(std::vector<std::pair<int,int> >::const_iterator it=ranges.begin();it!=ranges.end();it++)
7470     work=std::copy(src+(*it).first*nbOfComp,src+(*it).second*nbOfComp,work);
7471   return ret.retn();
7472 }
7473
7474 /*!
7475  * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode.
7476  * This map, if applied to \a this array, would make it sorted. For example, if
7477  * \a this array contents are [9,10,0,6,4,11,3,7] then the contents of the result array
7478  * are [5,6,0,3,2,7,1,4]; if this result array (\a res) is used as an argument in call
7479  * \a this->renumber(\a res) then the returned array contains [0,3,4,6,7,9,10,11].
7480  * This method is useful for renumbering (in MED file for example). For more info
7481  * on renumbering see \ref MEDCouplingArrayRenumbering.
7482  *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7483  *          array using decrRef() as it is no more needed.
7484  *  \throw If \a this is not allocated.
7485  *  \throw If \a this->getNumberOfComponents() != 1.
7486  *  \throw If there are equal values in \a this array.
7487  */
7488 DataArrayInt *DataArrayInt::checkAndPreparePermutation() const
7489 {
7490   checkAllocated();
7491   if(getNumberOfComponents()!=1)
7492     throw INTERP_KERNEL::Exception("DataArrayInt::checkAndPreparePermutation : number of components must == 1 !");
7493   int nbTuples=getNumberOfTuples();
7494   const int *pt=getConstPointer();
7495   int *pt2=CheckAndPreparePermutation(pt,pt+nbTuples);
7496   DataArrayInt *ret=DataArrayInt::New();
7497   ret->useArray(pt2,true,C_DEALLOC,nbTuples,1);
7498   return ret;
7499 }
7500
7501 /*!
7502  * This method tries to find the permutation to apply to the first input \a ids1 to obtain the same array (without considering strings informations) the second
7503  * input array \a ids2.
7504  * \a ids1 and \a ids2 are expected to be both a list of ids (both with number of components equal to one) not sorted and with values that can be negative.
7505  * This method will throw an exception is no such permutation array can be obtained. It is typically the case if there is some ids in \a ids1 not in \a ids2 or
7506  * inversely.
7507  * In case of success (no throw) : \c ids1->renumber(ret)->isEqual(ids2) where \a ret is the return of this method.
7508  *
7509  * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7510  *          array using decrRef() as it is no more needed.
7511  * \throw If either ids1 or ids2 is null not allocated or not with one components.
7512  *
7513  */
7514 DataArrayInt *DataArrayInt::FindPermutationFromFirstToSecond(const DataArrayInt *ids1, const DataArrayInt *ids2)
7515 {
7516   if(!ids1 || !ids2)
7517     throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays must be not null !");
7518   if(!ids1->isAllocated() || !ids2->isAllocated())
7519     throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays must be allocated !");
7520   if(ids1->getNumberOfComponents()!=1 || ids2->getNumberOfComponents()!=1)
7521     throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays have exactly one component !");
7522   if(ids1->getNumberOfTuples()!=ids2->getNumberOfTuples())
7523     {
7524       std::ostringstream oss; oss << "DataArrayInt::FindPermutationFromFirstToSecond : first array has " << ids1->getNumberOfTuples() << " tuples and the second one " << ids2->getNumberOfTuples() << " tuples ! No chance to find a permutation between the 2 arrays !";
7525       throw INTERP_KERNEL::Exception(oss.str().c_str());
7526     }
7527   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p1(ids1->deepCpy());
7528   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> p2(ids2->deepCpy());
7529   p1->sort(true); p2->sort(true);
7530   if(!p1->isEqualWithoutConsideringStr(*p2))
7531     throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two arrays are not lying on same ids ! Impossible to find a permutation between the 2 arrays !");
7532   p1=ids1->checkAndPreparePermutation();
7533   p2=ids2->checkAndPreparePermutation();
7534   p2=p2->invertArrayO2N2N2O(p2->getNumberOfTuples());
7535   p2=p2->selectByTupleIdSafe(p1->begin(),p1->end());
7536   return p2.retn();
7537 }
7538
7539 /*!
7540  * Returns two arrays describing a surjective mapping from \a this set of values (\a A)
7541  * onto a set of values of size \a targetNb (\a B). The surjective function is
7542  * \a B[ \a A[ i ]] = i. That is to say that for each \a id in [0,\a targetNb), where \a
7543  * targetNb < \a this->getNumberOfTuples(), there exists at least one tupleId (\a tid) so
7544  * that <em> this->getIJ( tid, 0 ) == id</em>. <br>
7545  * The first of out arrays returns indices of elements of \a this array, grouped by their
7546  * place in the set \a B. The second out array is the index of the first one; it shows how
7547  * many elements of \a A are mapped into each element of \a B. <br>
7548  * For more info on
7549  * mapping and its usage in renumbering see \ref MEDCouplingArrayRenumbering. <br>
7550  * \b Example:
7551  * - \a this: [0,3,2,3,2,2,1,2]
7552  * - \a targetNb: 4
7553  * - \a arr:  [0,  6,  2,4,5,7,  1,3]
7554  * - \a arrI: [0,1,2,6,8]
7555  *
7556  * This result means: <br>
7557  * the element of \a B 0 encounters within \a A once (\a arrI[ 0+1 ] - \a arrI[ 0 ]) and
7558  * its index within \a A is 0 ( \a arr[ 0:1 ] == \a arr[ \a arrI[ 0 ] : \a arrI[ 0+1 ]]);<br>
7559  * the element of \a B 2 encounters within \a A 4 times (\a arrI[ 2+1 ] - \a arrI[ 2 ]) and
7560  * its indices within \a A are [2,4,5,7] ( \a arr[ 2:6 ] == \a arr[ \a arrI[ 2 ] :
7561  * \a arrI[ 2+1 ]]); <br> etc.
7562  *  \param [in] targetNb - the size of the set \a B. \a targetNb must be equal or more
7563  *         than the maximal value of \a A.
7564  *  \param [out] arr - a new instance of DataArrayInt returning indices of
7565  *         elements of \a this, grouped by their place in the set \a B. The caller is to delete
7566  *         this array using decrRef() as it is no more needed.
7567  *  \param [out] arrI - a new instance of DataArrayInt returning size of groups of equal
7568  *         elements of \a this. The caller is to delete this array using decrRef() as it
7569  *         is no more needed.
7570  *  \throw If \a this is not allocated.
7571  *  \throw If \a this->getNumberOfComponents() != 1.
7572  *  \throw If any value in \a this is more or equal to \a targetNb.
7573  */
7574 void DataArrayInt::changeSurjectiveFormat(int targetNb, DataArrayInt *&arr, DataArrayInt *&arrI) const
7575 {
7576   checkAllocated();
7577   if(getNumberOfComponents()!=1)
7578     throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : number of components must == 1 !");
7579   int nbOfTuples=getNumberOfTuples();
7580   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
7581   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> retI(DataArrayInt::New());
7582   retI->alloc(targetNb+1,1);
7583   const int *input=getConstPointer();
7584   std::vector< std::vector<int> > tmp(targetNb);
7585   for(int i=0;i<nbOfTuples;i++)
7586     {
7587       int tmp2=input[i];
7588       if(tmp2>=0 && tmp2<targetNb)
7589         tmp[tmp2].push_back(i);
7590       else
7591         {
7592           std::ostringstream oss; oss << "DataArrayInt::changeSurjectiveFormat : At pos " << i << " presence of element " << tmp2 << " ! should be in [0," << targetNb << ") !";
7593           throw INTERP_KERNEL::Exception(oss.str().c_str());
7594         }
7595     }
7596   int *retIPtr=retI->getPointer();
7597   *retIPtr=0;
7598   for(std::vector< std::vector<int> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++,retIPtr++)
7599     retIPtr[1]=retIPtr[0]+(int)((*it1).size());
7600   if(nbOfTuples!=retI->getIJ(targetNb,0))
7601     throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : big problem should never happen !");
7602   ret->alloc(nbOfTuples,1);
7603   int *retPtr=ret->getPointer();
7604   for(std::vector< std::vector<int> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++)
7605     retPtr=std::copy((*it1).begin(),(*it1).end(),retPtr);
7606   arr=ret.retn();
7607   arrI=retI.retn();
7608 }
7609
7610
7611 /*!
7612  * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode computed
7613  * from a zip representation of a surjective format (returned e.g. by
7614  * \ref ParaMEDMEM::DataArrayDouble::findCommonTuples() "DataArrayDouble::findCommonTuples()"
7615  * for example). The result array minimizes the permutation. <br>
7616  * For more info on renumbering see \ref MEDCouplingArrayRenumbering. <br>
7617  * \b Example: <br>
7618  * - \a nbOfOldTuples: 10
7619  * - \a arr          : [0,3, 5,7,9]
7620  * - \a arrIBg       : [0,2,5]
7621  * - \a newNbOfTuples: 7
7622  * - result array    : [0,1,2,0,3,4,5,4,6,4]
7623  *
7624  *  \param [in] nbOfOldTuples - number of tuples in the initial array \a arr.
7625  *  \param [in] arr - the array of tuple indices grouped by \a arrIBg array.
7626  *  \param [in] arrIBg - the array dividing all indices stored in \a arr into groups of
7627  *         (indices of) equal values. Its every element (except the last one) points to
7628  *         the first element of a group of equal values.
7629  *  \param [in] arrIEnd - specifies the end of \a arrIBg, so that the last element of \a
7630  *          arrIBg is \a arrIEnd[ -1 ].
7631  *  \param [out] newNbOfTuples - number of tuples after surjection application.
7632  *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7633  *          array using decrRef() as it is no more needed.
7634  *  \throw If any value of \a arr breaks condition ( 0 <= \a arr[ i ] < \a nbOfOldTuples ).
7635  */
7636 DataArrayInt *DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(int nbOfOldTuples, const int *arr, const int *arrIBg, const int *arrIEnd, int &newNbOfTuples)
7637 {
7638   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7639   ret->alloc(nbOfOldTuples,1);
7640   int *pt=ret->getPointer();
7641   std::fill(pt,pt+nbOfOldTuples,-1);
7642   int nbOfGrps=((int)std::distance(arrIBg,arrIEnd))-1;
7643   const int *cIPtr=arrIBg;
7644   for(int i=0;i<nbOfGrps;i++)
7645     pt[arr[cIPtr[i]]]=-(i+2);
7646   int newNb=0;
7647   for(int iNode=0;iNode<nbOfOldTuples;iNode++)
7648     {
7649       if(pt[iNode]<0)
7650         {
7651           if(pt[iNode]==-1)
7652             pt[iNode]=newNb++;
7653           else
7654             {
7655               int grpId=-(pt[iNode]+2);
7656               for(int j=cIPtr[grpId];j<cIPtr[grpId+1];j++)
7657                 {
7658                   if(arr[j]>=0 && arr[j]<nbOfOldTuples)
7659                     pt[arr[j]]=newNb;
7660                   else
7661                     {
7662                       std::ostringstream oss; oss << "DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2 : With element #" << j << " value is " << arr[j] << " should be in [0," << nbOfOldTuples << ") !";
7663                       throw INTERP_KERNEL::Exception(oss.str().c_str());
7664                     }
7665                 }
7666               newNb++;
7667             }
7668         }
7669     }
7670   newNbOfTuples=newNb;
7671   return ret.retn();
7672 }
7673
7674 /*!
7675  * Returns a new DataArrayInt containing a renumbering map in "New to Old" mode,
7676  * which if applied to \a this array would make it sorted ascendingly.
7677  * For more info on renumbering see \ref MEDCouplingArrayRenumbering. <br>
7678  * \b Example: <br>
7679  * - \a this: [2,0,1,1,0,1,2,0,1,1,0,0]
7680  * - result: [10,0,5,6,1,7,11,2,8,9,3,4]
7681  * - after applying result to \a this: [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2]
7682  *
7683  *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
7684  *          array using decrRef() as it is no more needed.
7685  *  \throw If \a this is not allocated.
7686  *  \throw If \a this->getNumberOfComponents() != 1.
7687  */
7688 DataArrayInt *DataArrayInt::buildPermArrPerLevel() const
7689 {
7690   checkAllocated();
7691   if(getNumberOfComponents()!=1)
7692     throw INTERP_KERNEL::Exception("DataArrayInt::buildPermArrPerLevel : number of components must == 1 !");
7693   int nbOfTuples=getNumberOfTuples();
7694   const int *pt=getConstPointer();
7695   std::map<int,int> m;
7696   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7697   ret->alloc(nbOfTuples,1);
7698   int *opt=ret->getPointer();
7699   for(int i=0;i<nbOfTuples;i++,pt++,opt++)
7700     {
7701       int val=*pt;
7702       std::map<int,int>::iterator it=m.find(val);
7703       if(it!=m.end())
7704         {
7705           *opt=(*it).second;
7706           (*it).second++;
7707         }
7708       else
7709         {
7710           *opt=0;
7711           m.insert(std::pair<int,int>(val,1));
7712         }
7713     }
7714   int sum=0;
7715   for(std::map<int,int>::iterator it=m.begin();it!=m.end();it++)
7716     {
7717       int vt=(*it).second;
7718       (*it).second=sum;
7719       sum+=vt;
7720     }
7721   pt=getConstPointer();
7722   opt=ret->getPointer();
7723   for(int i=0;i<nbOfTuples;i++,pt++,opt++)
7724     *opt+=m[*pt];
7725   //
7726   return ret.retn();
7727 }
7728
7729 /*!
7730  * Checks if contents of \a this array are equal to that of an array filled with
7731  * iota(). This method is particularly useful for DataArrayInt instances that represent
7732  * a renumbering array to check the real need in renumbering.
7733  *  \return bool - \a true if \a this array contents == \a range( \a this->getNumberOfTuples())
7734  *  \throw If \a this is not allocated.
7735  *  \throw If \a this->getNumberOfComponents() != 1.
7736  */
7737 bool DataArrayInt::isIdentity() const
7738 {
7739   checkAllocated();
7740   if(getNumberOfComponents()!=1)
7741     return false;
7742   int nbOfTuples=getNumberOfTuples();
7743   const int *pt=getConstPointer();
7744   for(int i=0;i<nbOfTuples;i++,pt++)
7745     if(*pt!=i)
7746       return false;
7747   return true;
7748 }
7749
7750 /*!
7751  * Checks if all values in \a this array are equal to \a val.
7752  *  \param [in] val - value to check equality of array values to.
7753  *  \return bool - \a true if all values are \a val.
7754  *  \throw If \a this is not allocated.
7755  *  \throw If \a this->getNumberOfComponents() != 1
7756  */
7757 bool DataArrayInt::isUniform(int val) const
7758 {
7759   checkAllocated();
7760   if(getNumberOfComponents()!=1)
7761     throw INTERP_KERNEL::Exception("DataArrayInt::isUniform : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
7762   int nbOfTuples=getNumberOfTuples();
7763   const int *w=getConstPointer();
7764   const int *end2=w+nbOfTuples;
7765   for(;w!=end2;w++)
7766     if(*w!=val)
7767       return false;
7768   return true;
7769 }
7770
7771 /*!
7772  * Creates a new DataArrayDouble and assigns all (textual and numerical) data of \a this
7773  * array to the new one.
7774  *  \return DataArrayDouble * - the new instance of DataArrayInt.
7775  */
7776 DataArrayDouble *DataArrayInt::convertToDblArr() const
7777 {
7778   checkAllocated();
7779   DataArrayDouble *ret=DataArrayDouble::New();
7780   ret->alloc(getNumberOfTuples(),getNumberOfComponents());
7781   std::size_t nbOfVals=getNbOfElems();
7782   const int *src=getConstPointer();
7783   double *dest=ret->getPointer();
7784   std::copy(src,src+nbOfVals,dest);
7785   ret->copyStringInfoFrom(*this);
7786   return ret;
7787 }
7788
7789 /*!
7790  * Returns a shorten copy of \a this array. The new DataArrayInt contains all
7791  * tuples starting from the \a tupleIdBg-th tuple and including all tuples located before
7792  * the \a tupleIdEnd-th one. This methods has a similar behavior as std::string::substr().
7793  * This method is a specialization of selectByTupleId2().
7794  *  \param [in] tupleIdBg - index of the first tuple to copy from \a this array.
7795  *  \param [in] tupleIdEnd - index of the tuple before which the tuples to copy are located.
7796  *          If \a tupleIdEnd == -1, all the tuples till the end of \a this array are copied.
7797  *  \return DataArrayInt * - the new instance of DataArrayInt that the caller
7798  *          is to delete using decrRef() as it is no more needed.
7799  *  \throw If \a tupleIdBg < 0.
7800  *  \throw If \a tupleIdBg > \a this->getNumberOfTuples().
7801     \throw If \a tupleIdEnd != -1 && \a tupleIdEnd < \a this->getNumberOfTuples().
7802  *  \sa DataArrayInt::selectByTupleId2
7803  */
7804 DataArrayInt *DataArrayInt::substr(int tupleIdBg, int tupleIdEnd) const
7805 {
7806   checkAllocated();
7807   int nbt=getNumberOfTuples();
7808   if(tupleIdBg<0)
7809     throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter must be greater than 0 !");
7810   if(tupleIdBg>nbt)
7811     throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter is greater than number of tuples !");
7812   int trueEnd=tupleIdEnd;
7813   if(tupleIdEnd!=-1)
7814     {
7815       if(tupleIdEnd>nbt)
7816         throw INTERP_KERNEL::Exception("DataArrayInt::substr : The tupleIdBg parameter is greater or equal than number of tuples !");
7817     }
7818   else
7819     trueEnd=nbt;
7820   int nbComp=getNumberOfComponents();
7821   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7822   ret->alloc(trueEnd-tupleIdBg,nbComp);
7823   ret->copyStringInfoFrom(*this);
7824   std::copy(getConstPointer()+tupleIdBg*nbComp,getConstPointer()+trueEnd*nbComp,ret->getPointer());
7825   return ret.retn();
7826 }
7827
7828 /*!
7829  * Changes the number of components within \a this array so that its raw data **does
7830  * not** change, instead splitting this data into tuples changes.
7831  *  \warning This method erases all (name and unit) component info set before!
7832  *  \param [in] newNbOfComp - number of components for \a this array to have.
7833  *  \throw If \a this is not allocated
7834  *  \throw If getNbOfElems() % \a newNbOfCompo != 0.
7835  *  \throw If \a newNbOfCompo is lower than 1.
7836  *  \throw If the rearrange method would lead to a number of tuples higher than 2147483647 (maximal capacity of int32 !).
7837  *  \warning This method erases all (name and unit) component info set before!
7838  */
7839 void DataArrayInt::rearrange(int newNbOfCompo)
7840 {
7841   checkAllocated();
7842   if(newNbOfCompo<1)
7843     throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : input newNbOfCompo must be > 0 !");
7844   std::size_t nbOfElems=getNbOfElems();
7845   if(nbOfElems%newNbOfCompo!=0)
7846     throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : nbOfElems%newNbOfCompo!=0 !");
7847   if(nbOfElems/newNbOfCompo>(std::size_t)std::numeric_limits<int>::max())
7848     throw INTERP_KERNEL::Exception("DataArrayInt::rearrange : the rearrangement leads to too high number of tuples (> 2147483647) !");
7849   _info_on_compo.clear();
7850   _info_on_compo.resize(newNbOfCompo);
7851   declareAsNew();
7852 }
7853
7854 /*!
7855  * Changes the number of components within \a this array to be equal to its number
7856  * of tuples, and inversely its number of tuples to become equal to its number of
7857  * components. So that its raw data **does not** change, instead splitting this
7858  * data into tuples changes.
7859  *  \warning This method erases all (name and unit) component info set before!
7860  *  \warning Do not confuse this method with fromNoInterlace() and toNoInterlace()!
7861  *  \throw If \a this is not allocated.
7862  *  \sa rearrange()
7863  */
7864 void DataArrayInt::transpose()
7865 {
7866   checkAllocated();
7867   int nbOfTuples=getNumberOfTuples();
7868   rearrange(nbOfTuples);
7869 }
7870
7871 /*!
7872  * Returns a shorten or extended copy of \a this array. If \a newNbOfComp is less
7873  * than \a this->getNumberOfComponents() then the result array is shorten as each tuple
7874  * is truncated to have \a newNbOfComp components, keeping first components. If \a
7875  * newNbOfComp is more than \a this->getNumberOfComponents() then the result array is
7876  * expanded as each tuple is populated with \a dftValue to have \a newNbOfComp
7877  * components.
7878  *  \param [in] newNbOfComp - number of components for the new array to have.
7879  *  \param [in] dftValue - value assigned to new values added to the new array.
7880  *  \return DataArrayDouble * - the new instance of DataArrayDouble that the caller
7881  *          is to delete using decrRef() as it is no more needed.
7882  *  \throw If \a this is not allocated.
7883  */
7884 DataArrayInt *DataArrayInt::changeNbOfComponents(int newNbOfComp, int dftValue) const
7885 {
7886   checkAllocated();
7887   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
7888   ret->alloc(getNumberOfTuples(),newNbOfComp);
7889   const int *oldc=getConstPointer();
7890   int *nc=ret->getPointer();
7891   int nbOfTuples=getNumberOfTuples();
7892   int oldNbOfComp=getNumberOfComponents();
7893   int dim=std::min(oldNbOfComp,newNbOfComp);
7894   for(int i=0;i<nbOfTuples;i++)
7895     {
7896       int j=0;
7897       for(;j<dim;j++)
7898         nc[newNbOfComp*i+j]=oldc[i*oldNbOfComp+j];
7899       for(;j<newNbOfComp;j++)
7900         nc[newNbOfComp*i+j]=dftValue;
7901     }
7902   ret->setName(getName());
7903   for(int i=0;i<dim;i++)
7904     ret->setInfoOnComponent(i,getInfoOnComponent(i));
7905   ret->setName(getName());
7906   return ret.retn();
7907 }
7908
7909 /*!
7910  * Changes number of tuples in the array. If the new number of tuples is smaller
7911  * than the current number the array is truncated, otherwise the array is extended.
7912  *  \param [in] nbOfTuples - new number of tuples.
7913  *  \throw If \a this is not allocated.
7914  *  \throw If \a nbOfTuples is negative.
7915  */
7916 void DataArrayInt::reAlloc(int nbOfTuples)
7917 {
7918   if(nbOfTuples<0)
7919     throw INTERP_KERNEL::Exception("DataArrayInt::reAlloc : input new number of tuples should be >=0 !");
7920   checkAllocated();
7921   _mem.reAlloc(getNumberOfComponents()*(std::size_t)nbOfTuples);
7922   declareAsNew();
7923 }
7924
7925
7926 /*!
7927  * Returns a copy of \a this array composed of selected components.
7928  * The new DataArrayInt has the same number of tuples but includes components
7929  * specified by \a compoIds parameter. So that getNbOfElems() of the result array
7930  * can be either less, same or more than \a this->getNbOfElems().
7931  *  \param [in] compoIds - sequence of zero based indices of components to include
7932  *              into the new array.
7933  *  \return DataArrayInt * - the new instance of DataArrayInt that the caller
7934  *          is to delete using decrRef() as it is no more needed.
7935  *  \throw If \a this is not allocated.
7936  *  \throw If a component index (\a i) is not valid:
7937  *         \a i < 0 || \a i >= \a this->getNumberOfComponents().
7938  *
7939  *  \if ENABLE_EXAMPLES
7940  *  \ref py_mcdataarrayint_keepselectedcomponents "Here is a Python example".
7941  *  \endif
7942  */
7943 DataArrayInt *DataArrayInt::keepSelectedComponents(const std::vector<int>& compoIds) const
7944 {
7945   checkAllocated();
7946   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New());
7947   int newNbOfCompo=(int)compoIds.size();
7948   int oldNbOfCompo=getNumberOfComponents();
7949   for(std::vector<int>::const_iterator it=compoIds.begin();it!=compoIds.end();it++)
7950     DataArray::CheckValueInRange(oldNbOfCompo,(*it),"keepSelectedComponents invalid requested component");
7951   int nbOfTuples=getNumberOfTuples();
7952   ret->alloc(nbOfTuples,newNbOfCompo);
7953   ret->copyPartOfStringInfoFrom(*this,compoIds);
7954   const int *oldc=getConstPointer();
7955   int *nc=ret->getPointer();
7956   for(int i=0;i<nbOfTuples;i++)
7957     for(int j=0;j<newNbOfCompo;j++,nc++)
7958       *nc=oldc[i*oldNbOfCompo+compoIds[j]];
7959   return ret.retn();
7960 }
7961
7962 /*!
7963  * Appends components of another array to components of \a this one, tuple by tuple.
7964  * So that the number of tuples of \a this array remains the same and the number of
7965  * components increases.
7966  *  \param [in] other - the DataArrayInt to append to \a this one.
7967  *  \throw If \a this is not allocated.
7968  *  \throw If \a this and \a other arrays have different number of tuples.
7969  *
7970  *  \if ENABLE_EXAMPLES
7971  *  \ref cpp_mcdataarrayint_meldwith "Here is a C++ example".
7972  *
7973  *  \ref py_mcdataarrayint_meldwith "Here is a Python example".
7974  *  \endif
7975  */
7976 void DataArrayInt::meldWith(const DataArrayInt *other)
7977 {
7978   if(!other)
7979     throw INTERP_KERNEL::Exception("DataArrayInt::meldWith : DataArrayInt pointer in input is NULL !");
7980   checkAllocated();
7981   other->checkAllocated();
7982   int nbOfTuples=getNumberOfTuples();
7983   if(nbOfTuples!=other->getNumberOfTuples())
7984     throw INTERP_KERNEL::Exception("DataArrayInt::meldWith : mismatch of number of tuples !");
7985   int nbOfComp1=getNumberOfComponents();
7986   int nbOfComp2=other->getNumberOfComponents();
7987   int *newArr=(int *)malloc(nbOfTuples*(nbOfComp1+nbOfComp2)*sizeof(int));
7988   int *w=newArr;
7989   const int *inp1=getConstPointer();
7990   const int *inp2=other->getConstPointer();
7991   for(int i=0;i<nbOfTuples;i++,inp1+=nbOfComp1,inp2+=nbOfComp2)
7992     {
7993       w=std::copy(inp1,inp1+nbOfComp1,w);
7994       w=std::copy(inp2,inp2+nbOfComp2,w);
7995     }
7996   useArray(newArr,true,C_DEALLOC,nbOfTuples,nbOfComp1+nbOfComp2);
7997   std::vector<int> compIds(nbOfComp2);
7998   for(int i=0;i<nbOfComp2;i++)
7999     compIds[i]=nbOfComp1+i;
8000   copyPartOfStringInfoFrom2(compIds,*other);
8001 }
8002
8003 /*!
8004  * Copy all components in a specified order from another DataArrayInt.
8005  * The specified components become the first ones in \a this array.
8006  * Both numerical and textual data is copied. The number of tuples in \a this and
8007  * the other array can be different.
8008  *  \param [in] a - the array to copy data from.
8009  *  \param [in] compoIds - sequence of zero based indices of components, data of which is
8010  *              to be copied.
8011  *  \throw If \a a is NULL.
8012  *  \throw If \a compoIds.size() != \a a->getNumberOfComponents().
8013  *  \throw If \a compoIds[i] < 0 or \a compoIds[i] > \a this->getNumberOfComponents().
8014  *
8015  *  \if ENABLE_EXAMPLES
8016  *  \ref py_mcdataarrayint_setselectedcomponents "Here is a Python example".
8017  *  \endif
8018  */
8019 void DataArrayInt::setSelectedComponents(const DataArrayInt *a, const std::vector<int>& compoIds)
8020 {
8021   if(!a)
8022     throw INTERP_KERNEL::Exception("DataArrayInt::setSelectedComponents : input DataArrayInt is NULL !");
8023   checkAllocated();
8024   a->checkAllocated();
8025   copyPartOfStringInfoFrom2(compoIds,*a);
8026   std::size_t partOfCompoSz=compoIds.size();
8027   int nbOfCompo=getNumberOfComponents();
8028   int nbOfTuples=std::min(getNumberOfTuples(),a->getNumberOfTuples());
8029   const int *ac=a->getConstPointer();
8030   int *nc=getPointer();
8031   for(int i=0;i<nbOfTuples;i++)
8032     for(std::size_t j=0;j<partOfCompoSz;j++,ac++)
8033       nc[nbOfCompo*i+compoIds[j]]=*ac;
8034 }
8035
8036 /*!
8037  * Copy all values from another DataArrayInt into specified tuples and components
8038  * of \a this array. Textual data is not copied.
8039  * The tree parameters defining set of indices of tuples and components are similar to
8040  * the tree parameters of the Python function \c range(\c start,\c stop,\c step).
8041  *  \param [in] a - the array to copy values from.
8042  *  \param [in] bgTuples - index of the first tuple of \a this array to assign values to.
8043  *  \param [in] endTuples - index of the tuple before which the tuples to assign to
8044  *              are located.
8045  *  \param [in] stepTuples - index increment to get index of the next tuple to assign to.
8046  *  \param [in] bgComp - index of the first component of \a this array to assign values to.
8047  *  \param [in] endComp - index of the component before which the components to assign
8048  *              to are located.
8049  *  \param [in] stepComp - index increment to get index of the next component to assign to.
8050  *  \param [in] strictCompoCompare - if \a true (by default), then \a a->getNumberOfComponents()
8051  *              must be equal to the number of columns to assign to, else an
8052  *              exception is thrown; if \a false, then it is only required that \a
8053  *              a->getNbOfElems() equals to number of values to assign to (this condition
8054  *              must be respected even if \a strictCompoCompare is \a true). The number of
8055  *              values to assign to is given by following Python expression:
8056  *              \a nbTargetValues =
8057  *              \c len(\c range(\a bgTuples,\a endTuples,\a stepTuples)) *
8058  *              \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
8059  *  \throw If \a a is NULL.
8060  *  \throw If \a a is not allocated.
8061  *  \throw If \a this is not allocated.
8062  *  \throw If parameters specifying tuples and components to assign to do not give a
8063  *            non-empty range of increasing indices.
8064  *  \throw If \a a->getNbOfElems() != \a nbTargetValues.
8065  *  \throw If \a strictCompoCompare == \a true && \a a->getNumberOfComponents() !=
8066  *            \c len(\c range(\a bgComp,\a endComp,\a stepComp)).
8067  *
8068  *  \if ENABLE_EXAMPLES
8069  *  \ref py_mcdataarrayint_setpartofvalues1 "Here is a Python example".
8070  *  \endif
8071  */
8072 void DataArrayInt::setPartOfValues1(const DataArrayInt *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
8073 {
8074   if(!a)
8075     throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues1 : DataArrayInt pointer in input is NULL !");
8076   const char msg[]="DataArrayInt::setPartOfValues1";
8077   checkAllocated();
8078   a->checkAllocated();
8079   int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
8080   int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
8081   int nbComp=getNumberOfComponents();
8082   int nbOfTuples=getNumberOfTuples();
8083   DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
8084   DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
8085   bool assignTech=true;
8086   if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
8087     {
8088       if(strictCompoCompare)
8089         a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
8090     }
8091   else
8092     {
8093       a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
8094       assignTech=false;
8095     }
8096   int *pt=getPointer()+bgTuples*nbComp+bgComp;
8097   const int *srcPt=a->getConstPointer();
8098   if(assignTech)
8099     {
8100       for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8101         for(int j=0;j<newNbOfComp;j++,srcPt++)
8102           pt[j*stepComp]=*srcPt;
8103     }
8104   else
8105     {
8106       for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8107         {
8108           const int *srcPt2=srcPt;
8109           for(int j=0;j<newNbOfComp;j++,srcPt2++)
8110             pt[j*stepComp]=*srcPt2;
8111         }
8112     }
8113 }
8114
8115 /*!
8116  * Assign a given value to values at specified tuples and components of \a this array.
8117  * The tree parameters defining set of indices of tuples and components are similar to
8118  * the tree parameters of the Python function \c range(\c start,\c stop,\c step)..
8119  *  \param [in] a - the value to assign.
8120  *  \param [in] bgTuples - index of the first tuple of \a this array to assign to.
8121  *  \param [in] endTuples - index of the tuple before which the tuples to assign to
8122  *              are located.
8123  *  \param [in] stepTuples - index increment to get index of the next tuple to assign to.
8124  *  \param [in] bgComp - index of the first component of \a this array to assign to.
8125  *  \param [in] endComp - index of the component before which the components to assign
8126  *              to are located.
8127  *  \param [in] stepComp - index increment to get index of the next component to assign to.
8128  *  \throw If \a this is not allocated.
8129  *  \throw If parameters specifying tuples and components to assign to, do not give a
8130  *            non-empty range of increasing indices or indices are out of a valid range
8131  *            for \this array.
8132  *
8133  *  \if ENABLE_EXAMPLES
8134  *  \ref py_mcdataarrayint_setpartofvaluessimple1 "Here is a Python example".
8135  *  \endif
8136  */
8137 void DataArrayInt::setPartOfValuesSimple1(int a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp)
8138 {
8139   const char msg[]="DataArrayInt::setPartOfValuesSimple1";
8140   checkAllocated();
8141   int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
8142   int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
8143   int nbComp=getNumberOfComponents();
8144   int nbOfTuples=getNumberOfTuples();
8145   DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
8146   DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
8147   int *pt=getPointer()+bgTuples*nbComp+bgComp;
8148   for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8149     for(int j=0;j<newNbOfComp;j++)
8150       pt[j*stepComp]=a;
8151 }
8152
8153
8154 /*!
8155  * Copy all values from another DataArrayInt (\a a) into specified tuples and
8156  * components of \a this array. Textual data is not copied.
8157  * The tuples and components to assign to are defined by C arrays of indices.
8158  * There are two *modes of usage*:
8159  * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
8160  *   of \a a is assigned to its own location within \a this array.
8161  * - If \a a includes one tuple, then all values of \a a are assigned to the specified
8162  *   components of every specified tuple of \a this array. In this mode it is required
8163  *   that \a a->getNumberOfComponents() equals to the number of specified components.
8164  *
8165  *  \param [in] a - the array to copy values from.
8166  *  \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
8167  *              assign values of \a a to.
8168  *  \param [in] endTuples - specifies the end of the array \a bgTuples, so that
8169  *              pointer to a tuple index <em>(pi)</em> varies as this:
8170  *              \a bgTuples <= \a pi < \a endTuples.
8171  *  \param [in] bgComp - pointer to an array of component indices of \a this array to
8172  *              assign values of \a a to.
8173  *  \param [in] endComp - specifies the end of the array \a bgTuples, so that
8174  *              pointer to a component index <em>(pi)</em> varies as this:
8175  *              \a bgComp <= \a pi < \a endComp.
8176  *  \param [in] strictCompoCompare - this parameter is checked only if the
8177  *               *mode of usage* is the first; if it is \a true (default),
8178  *               then \a a->getNumberOfComponents() must be equal
8179  *               to the number of specified columns, else this is not required.
8180  *  \throw If \a a is NULL.
8181  *  \throw If \a a is not allocated.
8182  *  \throw If \a this is not allocated.
8183  *  \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
8184  *         out of a valid range for \a this array.
8185  *  \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
8186  *         if <em> a->getNumberOfComponents() != (endComp - bgComp) </em>.
8187  *  \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
8188  *         <em> a->getNumberOfComponents() != (endComp - bgComp)</em>.
8189  *
8190  *  \if ENABLE_EXAMPLES
8191  *  \ref py_mcdataarrayint_setpartofvalues2 "Here is a Python example".
8192  *  \endif
8193  */
8194 void DataArrayInt::setPartOfValues2(const DataArrayInt *a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
8195 {
8196   if(!a)
8197     throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues2 : DataArrayInt pointer in input is NULL !");
8198   const char msg[]="DataArrayInt::setPartOfValues2";
8199   checkAllocated();
8200   a->checkAllocated();
8201   int nbComp=getNumberOfComponents();
8202   int nbOfTuples=getNumberOfTuples();
8203   for(const int *z=bgComp;z!=endComp;z++)
8204     DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
8205   int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
8206   int newNbOfComp=(int)std::distance(bgComp,endComp);
8207   bool assignTech=true;
8208   if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
8209     {
8210       if(strictCompoCompare)
8211         a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
8212     }
8213   else
8214     {
8215       a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
8216       assignTech=false;
8217     }
8218   int *pt=getPointer();
8219   const int *srcPt=a->getConstPointer();
8220   if(assignTech)
8221     {
8222       for(const int *w=bgTuples;w!=endTuples;w++)
8223         {
8224           DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8225           for(const int *z=bgComp;z!=endComp;z++,srcPt++)
8226             {
8227               pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt;
8228             }
8229         }
8230     }
8231   else
8232     {
8233       for(const int *w=bgTuples;w!=endTuples;w++)
8234         {
8235           const int *srcPt2=srcPt;
8236           DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8237           for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
8238             {
8239               pt[(std::size_t)(*w)*nbComp+(*z)]=*srcPt2;
8240             }
8241         }
8242     }
8243 }
8244
8245 /*!
8246  * Assign a given value to values at specified tuples and components of \a this array.
8247  * The tuples and components to assign to are defined by C arrays of indices.
8248  *  \param [in] a - the value to assign.
8249  *  \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
8250  *              assign \a a to.
8251  *  \param [in] endTuples - specifies the end of the array \a bgTuples, so that
8252  *              pointer to a tuple index (\a pi) varies as this:
8253  *              \a bgTuples <= \a pi < \a endTuples.
8254  *  \param [in] bgComp - pointer to an array of component indices of \a this array to
8255  *              assign \a a to.
8256  *  \param [in] endComp - specifies the end of the array \a bgTuples, so that
8257  *              pointer to a component index (\a pi) varies as this:
8258  *              \a bgComp <= \a pi < \a endComp.
8259  *  \throw If \a this is not allocated.
8260  *  \throw If any index of tuple/component given by <em>bgTuples / bgComp</em> is
8261  *         out of a valid range for \a this array.
8262  *
8263  *  \if ENABLE_EXAMPLES
8264  *  \ref py_mcdataarrayint_setpartofvaluessimple2 "Here is a Python example".
8265  *  \endif
8266  */
8267 void DataArrayInt::setPartOfValuesSimple2(int a, const int *bgTuples, const int *endTuples, const int *bgComp, const int *endComp)
8268 {
8269   checkAllocated();
8270   int nbComp=getNumberOfComponents();
8271   int nbOfTuples=getNumberOfTuples();
8272   for(const int *z=bgComp;z!=endComp;z++)
8273     DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
8274   int *pt=getPointer();
8275   for(const int *w=bgTuples;w!=endTuples;w++)
8276     for(const int *z=bgComp;z!=endComp;z++)
8277       {
8278         DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8279         pt[(std::size_t)(*w)*nbComp+(*z)]=a;
8280       }
8281 }
8282
8283 /*!
8284  * Copy all values from another DataArrayInt (\a a) into specified tuples and
8285  * components of \a this array. Textual data is not copied.
8286  * The tuples to assign to are defined by a C array of indices.
8287  * The components to assign to are defined by three values similar to parameters of
8288  * the Python function \c range(\c start,\c stop,\c step).
8289  * There are two *modes of usage*:
8290  * - If \a a->getNbOfElems() equals to number of values to assign to, then every value
8291  *   of \a a is assigned to its own location within \a this array.
8292  * - If \a a includes one tuple, then all values of \a a are assigned to the specified
8293  *   components of every specified tuple of \a this array. In this mode it is required
8294  *   that \a a->getNumberOfComponents() equals to the number of specified components.
8295  *
8296  *  \param [in] a - the array to copy values from.
8297  *  \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
8298  *              assign values of \a a to.
8299  *  \param [in] endTuples - specifies the end of the array \a bgTuples, so that
8300  *              pointer to a tuple index <em>(pi)</em> varies as this:
8301  *              \a bgTuples <= \a pi < \a endTuples.
8302  *  \param [in] bgComp - index of the first component of \a this array to assign to.
8303  *  \param [in] endComp - index of the component before which the components to assign
8304  *              to are located.
8305  *  \param [in] stepComp - index increment to get index of the next component to assign to.
8306  *  \param [in] strictCompoCompare - this parameter is checked only in the first
8307  *               *mode of usage*; if \a strictCompoCompare is \a true (default),
8308  *               then \a a->getNumberOfComponents() must be equal
8309  *               to the number of specified columns, else this is not required.
8310  *  \throw If \a a is NULL.
8311  *  \throw If \a a is not allocated.
8312  *  \throw If \a this is not allocated.
8313  *  \throw If any index of tuple given by \a bgTuples is out of a valid range for
8314  *         \a this array.
8315  *  \throw In the first *mode of usage*, if <em>strictCompoCompare == true </em> and
8316  *         if <em> a->getNumberOfComponents()</em> is unequal to the number of components
8317  *         defined by <em>(bgComp,endComp,stepComp)</em>.
8318  *  \throw In the second *mode of usage*, if \a a->getNumberOfTuples() != 1 or
8319  *         <em> a->getNumberOfComponents()</em> is unequal to the number of components
8320  *         defined by <em>(bgComp,endComp,stepComp)</em>.
8321  *  \throw If parameters specifying components to assign to, do not give a
8322  *            non-empty range of increasing indices or indices are out of a valid range
8323  *            for \this array.
8324  *
8325  *  \if ENABLE_EXAMPLES
8326  *  \ref py_mcdataarrayint_setpartofvalues3 "Here is a Python example".
8327  *  \endif
8328  */
8329 void DataArrayInt::setPartOfValues3(const DataArrayInt *a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare)
8330 {
8331   if(!a)
8332     throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues3 : DataArrayInt pointer in input is NULL !");
8333   const char msg[]="DataArrayInt::setPartOfValues3";
8334   checkAllocated();
8335   a->checkAllocated();
8336   int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
8337   int nbComp=getNumberOfComponents();
8338   int nbOfTuples=getNumberOfTuples();
8339   DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
8340   int newNbOfTuples=(int)std::distance(bgTuples,endTuples);
8341   bool assignTech=true;
8342   if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
8343     {
8344       if(strictCompoCompare)
8345         a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
8346     }
8347   else
8348     {
8349       a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
8350       assignTech=false;
8351     }
8352   int *pt=getPointer()+bgComp;
8353   const int *srcPt=a->getConstPointer();
8354   if(assignTech)
8355     {
8356       for(const int *w=bgTuples;w!=endTuples;w++)
8357         for(int j=0;j<newNbOfComp;j++,srcPt++)
8358           {
8359             DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8360             pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt;
8361           }
8362     }
8363   else
8364     {
8365       for(const int *w=bgTuples;w!=endTuples;w++)
8366         {
8367           const int *srcPt2=srcPt;
8368           for(int j=0;j<newNbOfComp;j++,srcPt2++)
8369             {
8370               DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8371               pt[(std::size_t)(*w)*nbComp+j*stepComp]=*srcPt2;
8372             }
8373         }
8374     }
8375 }
8376
8377 /*!
8378  * Assign a given value to values at specified tuples and components of \a this array.
8379  * The tuples to assign to are defined by a C array of indices.
8380  * The components to assign to are defined by three values similar to parameters of
8381  * the Python function \c range(\c start,\c stop,\c step).
8382  *  \param [in] a - the value to assign.
8383  *  \param [in] bgTuples - pointer to an array of tuple indices of \a this array to
8384  *              assign \a a to.
8385  *  \param [in] endTuples - specifies the end of the array \a bgTuples, so that
8386  *              pointer to a tuple index <em>(pi)</em> varies as this:
8387  *              \a bgTuples <= \a pi < \a endTuples.
8388  *  \param [in] bgComp - index of the first component of \a this array to assign to.
8389  *  \param [in] endComp - index of the component before which the components to assign
8390  *              to are located.
8391  *  \param [in] stepComp - index increment to get index of the next component to assign to.
8392  *  \throw If \a this is not allocated.
8393  *  \throw If any index of tuple given by \a bgTuples is out of a valid range for
8394  *         \a this array.
8395  *  \throw If parameters specifying components to assign to, do not give a
8396  *            non-empty range of increasing indices or indices are out of a valid range
8397  *            for \this array.
8398  *
8399  *  \if ENABLE_EXAMPLES
8400  *  \ref py_mcdataarrayint_setpartofvaluessimple3 "Here is a Python example".
8401  *  \endif
8402  */
8403 void DataArrayInt::setPartOfValuesSimple3(int a, const int *bgTuples, const int *endTuples, int bgComp, int endComp, int stepComp)
8404 {
8405   const char msg[]="DataArrayInt::setPartOfValuesSimple3";
8406   checkAllocated();
8407   int newNbOfComp=DataArray::GetNumberOfItemGivenBES(bgComp,endComp,stepComp,msg);
8408   int nbComp=getNumberOfComponents();
8409   int nbOfTuples=getNumberOfTuples();
8410   DataArray::CheckValueInRangeEx(nbComp,bgComp,endComp,"invalid component value");
8411   int *pt=getPointer()+bgComp;
8412   for(const int *w=bgTuples;w!=endTuples;w++)
8413     for(int j=0;j<newNbOfComp;j++)
8414       {
8415         DataArray::CheckValueInRange(nbOfTuples,*w,"invalid tuple id");
8416         pt[(std::size_t)(*w)*nbComp+j*stepComp]=a;
8417       }
8418 }
8419
8420 void DataArrayInt::setPartOfValues4(const DataArrayInt *a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp, bool strictCompoCompare)
8421 {
8422   if(!a)
8423     throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValues4 : input DataArrayInt is NULL !");
8424   const char msg[]="DataArrayInt::setPartOfValues4";
8425   checkAllocated();
8426   a->checkAllocated();
8427   int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
8428   int newNbOfComp=(int)std::distance(bgComp,endComp);
8429   int nbComp=getNumberOfComponents();
8430   for(const int *z=bgComp;z!=endComp;z++)
8431     DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
8432   int nbOfTuples=getNumberOfTuples();
8433   DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
8434   bool assignTech=true;
8435   if(a->getNbOfElems()==(std::size_t)newNbOfTuples*newNbOfComp)
8436     {
8437       if(strictCompoCompare)
8438         a->checkNbOfTuplesAndComp(newNbOfTuples,newNbOfComp,msg);
8439     }
8440   else
8441     {
8442       a->checkNbOfTuplesAndComp(1,newNbOfComp,msg);
8443       assignTech=false;
8444     }
8445   const int *srcPt=a->getConstPointer();
8446   int *pt=getPointer()+bgTuples*nbComp;
8447   if(assignTech)
8448     {
8449       for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8450         for(const int *z=bgComp;z!=endComp;z++,srcPt++)
8451           pt[*z]=*srcPt;
8452     }
8453   else
8454     {
8455       for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8456         {
8457           const int *srcPt2=srcPt;
8458           for(const int *z=bgComp;z!=endComp;z++,srcPt2++)
8459             pt[*z]=*srcPt2;
8460         }
8461     }
8462 }
8463
8464 void DataArrayInt::setPartOfValuesSimple4(int a, int bgTuples, int endTuples, int stepTuples, const int *bgComp, const int *endComp)
8465 {
8466   const char msg[]="DataArrayInt::setPartOfValuesSimple4";
8467   checkAllocated();
8468   int newNbOfTuples=DataArray::GetNumberOfItemGivenBES(bgTuples,endTuples,stepTuples,msg);
8469   int nbComp=getNumberOfComponents();
8470   for(const int *z=bgComp;z!=endComp;z++)
8471     DataArray::CheckValueInRange(nbComp,*z,"invalid component id");
8472   int nbOfTuples=getNumberOfTuples();
8473   DataArray::CheckValueInRangeEx(nbOfTuples,bgTuples,endTuples,"invalid tuple value");
8474   int *pt=getPointer()+bgTuples*nbComp;
8475   for(int i=0;i<newNbOfTuples;i++,pt+=stepTuples*nbComp)
8476     for(const int *z=bgComp;z!=endComp;z++)
8477       pt[*z]=a;
8478 }
8479
8480 /*!
8481  * Copy some tuples from another DataArrayInt into specified tuples
8482  * of \a this array. Textual data is not copied. Both arrays must have equal number of
8483  * components.
8484  * Both the tuples to assign and the tuples to assign to are defined by a DataArrayInt.
8485  * All components of selected tuples are copied.
8486  *  \param [in] a - the array to copy values from.
8487  *  \param [in] tuplesSelec - the array specifying both source tuples of \a a and
8488  *              target tuples of \a this. \a tuplesSelec has two components, and the
8489  *              first component specifies index of the source tuple and the second
8490  *              one specifies index of the target tuple.
8491  *  \throw If \a this is not allocated.
8492  *  \throw If \a a is NULL.
8493  *  \throw If \a a is not allocated.
8494  *  \throw If \a tuplesSelec is NULL.
8495  *  \throw If \a tuplesSelec is not allocated.
8496  *  \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
8497  *  \throw If \a tuplesSelec->getNumberOfComponents() != 2.
8498  *  \throw If any tuple index given by \a tuplesSelec is out of a valid range for
8499  *         the corresponding (\a this or \a a) array.
8500  */
8501 void DataArrayInt::setPartOfValuesAdv(const DataArrayInt *a, const DataArrayInt *tuplesSelec)
8502 {
8503   if(!a || !tuplesSelec)
8504     throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : DataArrayInt pointer in input is NULL !");
8505   checkAllocated();
8506   a->checkAllocated();
8507   tuplesSelec->checkAllocated();
8508   int nbOfComp=getNumberOfComponents();
8509   if(nbOfComp!=a->getNumberOfComponents())
8510     throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : This and a do not have the same number of components !");
8511   if(tuplesSelec->getNumberOfComponents()!=2)
8512     throw INTERP_KERNEL::Exception("DataArrayInt::setPartOfValuesAdv : Expecting to have a tuple selector DataArrayInt instance with exactly 2 components !");
8513   int thisNt=getNumberOfTuples();
8514   int aNt=a->getNumberOfTuples();
8515   int *valsToSet=getPointer();
8516   const int *valsSrc=a->getConstPointer();
8517   for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple+=2)
8518     {
8519       if(tuple[1]>=0 && tuple[1]<aNt)
8520         {
8521           if(tuple[0]>=0 && tuple[0]<thisNt)
8522             std::copy(valsSrc+nbOfComp*tuple[1],valsSrc+nbOfComp*(tuple[1]+1),valsToSet+nbOfComp*tuple[0]);
8523           else
8524             {
8525               std::ostringstream oss; oss << "DataArrayInt::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
8526               oss << " of 'tuplesSelec' request of tuple id #" << tuple[0] << " in 'this' ! It should be in [0," << thisNt << ") !";
8527               throw INTERP_KERNEL::Exception(oss.str().c_str());
8528             }
8529         }
8530       else
8531         {
8532           std::ostringstream oss; oss << "DataArrayInt::setPartOfValuesAdv : Tuple #" << std::distance(tuplesSelec->begin(),tuple)/2;
8533           oss << " of 'tuplesSelec' request of tuple id #" << tuple[1] << " in 'a' ! It should be in [0," << aNt << ") !";
8534           throw INTERP_KERNEL::Exception(oss.str().c_str());
8535         }
8536     }
8537 }
8538
8539 /*!
8540  * Copy some tuples from another DataArrayInt (\a aBase) into contiguous tuples
8541  * of \a this array. Textual data is not copied. Both arrays must have equal number of
8542  * components.
8543  * The tuples to assign to are defined by index of the first tuple, and
8544  * their number is defined by \a tuplesSelec->getNumberOfTuples().
8545  * The tuples to copy are defined by values of a DataArrayInt.
8546  * All components of selected tuples are copied.
8547  *  \param [in] tupleIdStart - index of the first tuple of \a this array to assign
8548  *              values to.
8549  *  \param [in] aBase - the array to copy values from.
8550  *  \param [in] tuplesSelec - the array specifying tuples of \a aBase to copy.
8551  *  \throw If \a this is not allocated.
8552  *  \throw If \a aBase is NULL.
8553  *  \throw If \a aBase is not allocated.
8554  *  \throw If \a tuplesSelec is NULL.
8555  *  \throw If \a tuplesSelec is not allocated.
8556  *  \throw If <em>this->getNumberOfComponents() != a->getNumberOfComponents()</em>.
8557  *  \throw If \a tuplesSelec->getNumberOfComponents() != 1.
8558  *  \throw If <em>tupleIdStart + tuplesSelec->getNumberOfTuples() > this->getNumberOfTuples().</em>
8559  *  \throw If any tuple index given by \a tuplesSelec is out of a valid range for
8560  *         \a aBase array.
8561  */
8562 void DataArrayInt::setContigPartOfSelectedValues(int tupleIdStart, const DataArray *aBase, const DataArrayInt *tuplesSelec)
8563 {
8564   if(!aBase || !tuplesSelec)
8565     throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : input DataArray is NULL !");
8566   const DataArrayInt *a=dynamic_cast<const DataArrayInt *>(aBase);
8567   if(!a)
8568     throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : input DataArray aBase is not a DataArrayInt !");
8569   checkAllocated();
8570   a->checkAllocated();
8571   tuplesSelec->checkAllocated();
8572   int nbOfComp=getNumberOfComponents();
8573   if(nbOfComp!=a->getNumberOfComponents())
8574     throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : This and a do not have the same number of components !");
8575   if(tuplesSelec->getNumberOfComponents()!=1)
8576     throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : Expecting to have a tuple selector DataArrayInt instance with exactly 1 component !");
8577   int thisNt=getNumberOfTuples();
8578   int aNt=a->getNumberOfTuples();
8579   int nbOfTupleToWrite=tuplesSelec->getNumberOfTuples();
8580   int *valsToSet=getPointer()+tupleIdStart*nbOfComp;
8581   if(tupleIdStart+nbOfTupleToWrite>thisNt)
8582     throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues : invalid number range of values to write !");
8583   const int *valsSrc=a->getConstPointer();
8584   for(const int *tuple=tuplesSelec->begin();tuple!=tuplesSelec->end();tuple++,valsToSet+=nbOfComp)
8585     {
8586       if(*tuple>=0 && *tuple<aNt)
8587         {
8588           std::copy(valsSrc+nbOfComp*(*tuple),valsSrc+nbOfComp*(*tuple+1),valsToSet);
8589         }
8590       else
8591         {
8592           std::ostringstream oss; oss << "DataArrayInt::setContigPartOfSelectedValues : Tuple #" << std::distance(tuplesSelec->begin(),tuple);
8593           oss << " of 'tuplesSelec' request of tuple id #" << *tuple << " in 'a' ! It should be in [0," << aNt << ") !";
8594           throw INTERP_KERNEL::Exception(oss.str().c_str());
8595         }
8596     }
8597 }
8598
8599 /*!
8600  * Copy some tuples from another DataArrayInt (\a aBase) into contiguous tuples
8601  * of \a this array. Textual data is not copied. Both arrays must have equal number of
8602  * components.
8603  * The tuples to copy are defined by three values similar to parameters of
8604  * the Python function \c range(\c start,\c stop,\c step).
8605  * The tuples to assign to are defined by index of the first tuple, and
8606  * their number is defined by number of tuples to copy.
8607  * All components of selected tuples are copied.
8608  *  \param [in] tupleIdStart - index of the first tuple of \a this array to assign
8609  *              values to.
8610  *  \param [in] aBase - the array to copy values from.
8611  *  \param [in] bg - index of the first tuple to copy of the array \a aBase.
8612  *  \param [in] end2 - index of the tuple of \a aBase before which the tuples to copy
8613  *              are located.
8614  *  \param [in] step - index increment to get index of the next tuple to copy.
8615  *  \throw If \a this is not allocated.
8616  *  \throw If \a aBase is NULL.
8617  *  \throw If \a aBase is not allocated.
8618  *  \throw If <em>this->getNumberOfComponents() != aBase->getNumberOfComponents()</em>.
8619  *  \throw If <em>tupleIdStart + len(range(bg,end2,step)) > this->getNumberOfTuples().</em>
8620  *  \throw If parameters specifying tuples to copy, do not give a
8621  *            non-empty range of increasing indices or indices are out of a valid range
8622  *            for the array \a aBase.
8623  */
8624 void DataArrayInt::setContigPartOfSelectedValues2(int tupleIdStart, const DataArray *aBase, int bg, int end2, int step)
8625 {
8626   if(!aBase)
8627     throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : input DataArray is NULL !");
8628   const DataArrayInt *a=dynamic_cast<const DataArrayInt *>(aBase);
8629   if(!a)
8630     throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : input DataArray aBase is not a DataArrayInt !");
8631   checkAllocated();
8632   a->checkAllocated();
8633   int nbOfComp=getNumberOfComponents();
8634   const char msg[]="DataArrayInt::setContigPartOfSelectedValues2";
8635   int nbOfTupleToWrite=DataArray::GetNumberOfItemGivenBES(bg,end2,step,msg);
8636   if(nbOfComp!=a->getNumberOfComponents())
8637     throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : This and a do not have the same number of components !");
8638   int thisNt=getNumberOfTuples();
8639   int aNt=a->getNumberOfTuples();
8640   int *valsToSet=getPointer()+tupleIdStart*nbOfComp;
8641   if(tupleIdStart+nbOfTupleToWrite>thisNt)
8642     throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : invalid number range of values to write !");
8643   if(end2>aNt)
8644     throw INTERP_KERNEL::Exception("DataArrayInt::setContigPartOfSelectedValues2 : invalid range of values to read !");
8645   const int *valsSrc=a->getConstPointer()+bg*nbOfComp;
8646   for(int i=0;i<nbOfTupleToWrite;i++,valsToSet+=nbOfComp,valsSrc+=step*nbOfComp)
8647     {
8648       std::copy(valsSrc,valsSrc+nbOfComp,valsToSet);
8649     }
8650 }
8651
8652 /*!
8653  * Returns a value located at specified tuple and component.
8654  * This method is equivalent to DataArrayInt::getIJ() except that validity of
8655  * parameters is checked. So this method is safe but expensive if used to go through
8656  * all values of \a this.
8657  *  \param [in] tupleId - index of tuple of interest.
8658  *  \param [in] compoId - index of component of interest.
8659  *  \return double - value located by \a tupleId and \a compoId.
8660  *  \throw If \a this is not allocated.
8661  *  \throw If condition <em>( 0 <= tupleId < this->getNumberOfTuples() )</em> is violated.
8662  *  \throw If condition <em>( 0 <= compoId < this->getNumberOfComponents() )</em> is violated.
8663  */
8664 int DataArrayInt::getIJSafe(int tupleId, int compoId) const
8665 {
8666   checkAllocated();
8667   if(tupleId<0 || tupleId>=getNumberOfTuples())
8668     {
8669       std::ostringstream oss; oss << "DataArrayInt::getIJSafe : request for tupleId " << tupleId << " should be in [0," << getNumberOfTuples() << ") !";
8670       throw INTERP_KERNEL::Exception(oss.str().c_str());
8671     }
8672   if(compoId<0 || compoId>=getNumberOfComponents())
8673     {
8674       std::ostringstream oss; oss << "DataArrayInt::getIJSafe : request for compoId " << compoId << " should be in [0," << getNumberOfComponents() << ") !";
8675       throw INTERP_KERNEL::Exception(oss.str().c_str());
8676     }
8677   return _mem[tupleId*_info_on_compo.size()+compoId];
8678 }
8679
8680 /*!
8681  * Returns the first value of \a this.
8682  *  \return int - the last value of \a this array.
8683  *  \throw If \a this is not allocated.
8684  *  \throw If \a this->getNumberOfComponents() != 1.
8685  *  \throw If \a this->getNumberOfTuples() < 1.
8686  */
8687 int DataArrayInt::front() const
8688 {
8689   checkAllocated();
8690   if(getNumberOfComponents()!=1)
8691     throw INTERP_KERNEL::Exception("DataArrayInt::front : number of components not equal to one !");
8692   int nbOfTuples=getNumberOfTuples();
8693   if(nbOfTuples<1)
8694     throw INTERP_KERNEL::Exception("DataArrayInt::front : number of tuples must be >= 1 !");
8695   return *(getConstPointer());
8696 }
8697
8698 /*!
8699  * Returns the last value of \a this.
8700  *  \return int - the last value of \a this array.
8701  *  \throw If \a this is not allocated.
8702  *  \throw If \a this->getNumberOfComponents() != 1.
8703  *  \throw If \a this->getNumberOfTuples() < 1.
8704  */
8705 int DataArrayInt::back() const
8706 {
8707   checkAllocated();
8708   if(getNumberOfComponents()!=1)
8709     throw INTERP_KERNEL::Exception("DataArrayInt::back : number of components not equal to one !");
8710   int nbOfTuples=getNumberOfTuples();
8711   if(nbOfTuples<1)
8712     throw INTERP_KERNEL::Exception("DataArrayInt::back : number of tuples must be >= 1 !");
8713   return *(getConstPointer()+nbOfTuples-1);
8714 }
8715
8716 /*!
8717  * Assign pointer to one array to a pointer to another appay. Reference counter of
8718  * \a arrayToSet is incremented / decremented.
8719  *  \param [in] newArray - the pointer to array to assign to \a arrayToSet.
8720  *  \param [in,out] arrayToSet - the pointer to array to assign to.
8721  */
8722 void DataArrayInt::SetArrayIn(DataArrayInt *newArray, DataArrayInt* &arrayToSet)
8723 {
8724   if(newArray!=arrayToSet)
8725     {
8726       if(arrayToSet)
8727         arrayToSet->decrRef();
8728       arrayToSet=newArray;
8729       if(arrayToSet)
8730         arrayToSet->incrRef();
8731     }
8732 }
8733
8734 DataArrayIntIterator *DataArrayInt::iterator()
8735 {
8736   return new DataArrayIntIterator(this);
8737 }
8738
8739 /*!
8740  * Creates a new DataArrayInt containing IDs (indices) of tuples holding value equal to a
8741  * given one. The ids are sorted in the ascending order.
8742  *  \param [in] val - the value to find within \a this.
8743  *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8744  *          array using decrRef() as it is no more needed.
8745  *  \throw If \a this is not allocated.
8746  *  \throw If \a this->getNumberOfComponents() != 1.
8747  *  \sa DataArrayInt::getIdsEqualTuple
8748  */
8749 DataArrayInt *DataArrayInt::getIdsEqual(int val) const
8750 {
8751   checkAllocated();
8752   if(getNumberOfComponents()!=1)
8753     throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqual : the array must have only one component, you can call 'rearrange' method before !");
8754   const int *cptr(getConstPointer());
8755   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8756   int nbOfTuples=getNumberOfTuples();
8757   for(int i=0;i<nbOfTuples;i++,cptr++)
8758     if(*cptr==val)
8759       ret->pushBackSilent(i);
8760   return ret.retn();
8761 }
8762
8763 /*!
8764  * Creates a new DataArrayInt containing IDs (indices) of tuples holding value \b not
8765  * equal to a given one.
8766  *  \param [in] val - the value to ignore within \a this.
8767  *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8768  *          array using decrRef() as it is no more needed.
8769  *  \throw If \a this is not allocated.
8770  *  \throw If \a this->getNumberOfComponents() != 1.
8771  */
8772 DataArrayInt *DataArrayInt::getIdsNotEqual(int val) const
8773 {
8774   checkAllocated();
8775   if(getNumberOfComponents()!=1)
8776     throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotEqual : the array must have only one component, you can call 'rearrange' method before !");
8777   const int *cptr(getConstPointer());
8778   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8779   int nbOfTuples=getNumberOfTuples();
8780   for(int i=0;i<nbOfTuples;i++,cptr++)
8781     if(*cptr!=val)
8782       ret->pushBackSilent(i);
8783   return ret.retn();
8784 }
8785
8786 /*!
8787  * Creates a new DataArrayInt containing IDs (indices) of tuples holding tuple equal to those defined by [ \a tupleBg , \a tupleEnd )
8788  * This method is an extension of  DataArrayInt::getIdsEqual method.
8789  *
8790  *  \param [in] tupleBg - the begin (included) of the input tuple to find within \a this.
8791  *  \param [in] tupleEnd - the end (excluded) of the input tuple to find within \a this.
8792  *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8793  *          array using decrRef() as it is no more needed.
8794  *  \throw If \a this is not allocated.
8795  *  \throw If \a this->getNumberOfComponents() != std::distance(tupleBg,tupleEnd).
8796  * \throw If \a this->getNumberOfComponents() is equal to 0.
8797  * \sa DataArrayInt::getIdsEqual
8798  */
8799 DataArrayInt *DataArrayInt::getIdsEqualTuple(const int *tupleBg, const int *tupleEnd) const
8800 {
8801   std::size_t nbOfCompoExp(std::distance(tupleBg,tupleEnd));
8802   checkAllocated();
8803   if(getNumberOfComponents()!=(int)nbOfCompoExp)
8804     {
8805       std::ostringstream oss; oss << "DataArrayInt::getIdsEqualTuple : mismatch of number of components. Input tuple has " << nbOfCompoExp << " whereas this array has " << getNumberOfComponents() << " components !";
8806       throw INTERP_KERNEL::Exception(oss.str().c_str());
8807     }
8808   if(nbOfCompoExp==0)
8809     throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqualTuple : number of components should be > 0 !");
8810   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8811   const int *bg(begin()),*end2(end()),*work(begin());
8812   while(work!=end2)
8813     {
8814       work=std::search(work,end2,tupleBg,tupleEnd);
8815       if(work!=end2)
8816         {
8817           std::size_t pos(std::distance(bg,work));
8818           if(pos%nbOfCompoExp==0)
8819             ret->pushBackSilent(pos/nbOfCompoExp);
8820           work++;
8821         }
8822     }
8823   return ret.retn();
8824 }
8825
8826 /*!
8827  * Assigns \a newValue to all elements holding \a oldValue within \a this
8828  * one-dimensional array.
8829  *  \param [in] oldValue - the value to replace.
8830  *  \param [in] newValue - the value to assign.
8831  *  \return int - number of replacements performed.
8832  *  \throw If \a this is not allocated.
8833  *  \throw If \a this->getNumberOfComponents() != 1.
8834  */
8835 int DataArrayInt::changeValue(int oldValue, int newValue)
8836 {
8837   checkAllocated();
8838   if(getNumberOfComponents()!=1)
8839     throw INTERP_KERNEL::Exception("DataArrayInt::changeValue : the array must have only one component, you can call 'rearrange' method before !");
8840   int *start=getPointer();
8841   int *end2=start+getNbOfElems();
8842   int ret=0;
8843   for(int *val=start;val!=end2;val++)
8844     {
8845       if(*val==oldValue)
8846         {
8847           *val=newValue;
8848           ret++;
8849         }
8850     }
8851   return ret;
8852 }
8853
8854 /*!
8855  * Creates a new DataArrayInt containing IDs (indices) of tuples holding value equal to
8856  * one of given values.
8857  *  \param [in] valsBg - an array of values to find within \a this array.
8858  *  \param [in] valsEnd - specifies the end of the array \a valsBg, so that
8859  *              the last value of \a valsBg is \a valsEnd[ -1 ].
8860  *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8861  *          array using decrRef() as it is no more needed.
8862  *  \throw If \a this->getNumberOfComponents() != 1.
8863  */
8864 DataArrayInt *DataArrayInt::getIdsEqualList(const int *valsBg, const int *valsEnd) const
8865 {
8866   if(getNumberOfComponents()!=1)
8867     throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqualList : the array must have only one component, you can call 'rearrange' method before !");
8868   std::set<int> vals2(valsBg,valsEnd);
8869   const int *cptr=getConstPointer();
8870   std::vector<int> res;
8871   int nbOfTuples=getNumberOfTuples();
8872   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8873   for(int i=0;i<nbOfTuples;i++,cptr++)
8874     if(vals2.find(*cptr)!=vals2.end())
8875       ret->pushBackSilent(i);
8876   return ret.retn();
8877 }
8878
8879 /*!
8880  * Creates a new DataArrayInt containing IDs (indices) of tuples holding values \b not
8881  * equal to any of given values.
8882  *  \param [in] valsBg - an array of values to ignore within \a this array.
8883  *  \param [in] valsEnd - specifies the end of the array \a valsBg, so that
8884  *              the last value of \a valsBg is \a valsEnd[ -1 ].
8885  *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
8886  *          array using decrRef() as it is no more needed.
8887  *  \throw If \a this->getNumberOfComponents() != 1.
8888  */
8889 DataArrayInt *DataArrayInt::getIdsNotEqualList(const int *valsBg, const int *valsEnd) const
8890 {
8891   if(getNumberOfComponents()!=1)
8892     throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotEqualList : the array must have only one component, you can call 'rearrange' method before !");
8893   std::set<int> vals2(valsBg,valsEnd);
8894   const int *cptr=getConstPointer();
8895   std::vector<int> res;
8896   int nbOfTuples=getNumberOfTuples();
8897   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
8898   for(int i=0;i<nbOfTuples;i++,cptr++)
8899     if(vals2.find(*cptr)==vals2.end())
8900       ret->pushBackSilent(i);
8901   return ret.retn();
8902 }
8903
8904 /*!
8905  * This method is an extension of DataArrayInt::locateValue method because this method works for DataArrayInt with
8906  * any number of components excepted 0 (an INTERP_KERNEL::Exception is thrown in this case).
8907  * This method searches in \b this is there is a tuple that matched the input parameter \b tupl.
8908  * If any the tuple id is returned. If not -1 is returned.
8909  *
8910  * This method throws an INTERP_KERNEL::Exception if the number of components in \b this mismatches with the size of
8911  * the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
8912  *
8913  * \return tuple id where \b tupl is. -1 if no such tuple exists in \b this.
8914  * \sa DataArrayInt::search, DataArrayInt::presenceOfTuple.
8915  */
8916 int DataArrayInt::locateTuple(const std::vector<int>& tupl) const
8917 {
8918   checkAllocated();
8919   int nbOfCompo=getNumberOfComponents();
8920   if(nbOfCompo==0)
8921     throw INTERP_KERNEL::Exception("DataArrayInt::locateTuple : 0 components in 'this' !");
8922   if(nbOfCompo!=(int)tupl.size())
8923     {
8924       std::ostringstream oss; oss << "DataArrayInt::locateTuple : 'this' contains " << nbOfCompo << " components and searching for a tuple of length " << tupl.size() << " !";
8925       throw INTERP_KERNEL::Exception(oss.str().c_str());
8926     }
8927   const int *cptr=getConstPointer();
8928   std::size_t nbOfVals=getNbOfElems();
8929   for(const int *work=cptr;work!=cptr+nbOfVals;)
8930     {
8931       work=std::search(work,cptr+nbOfVals,tupl.begin(),tupl.end());
8932       if(work!=cptr+nbOfVals)
8933         {
8934           if(std::distance(cptr,work)%nbOfCompo!=0)
8935             work++;
8936           else
8937             return std::distance(cptr,work)/nbOfCompo;
8938         }
8939     }
8940   return -1;
8941 }
8942
8943 /*!
8944  * This method searches the sequence specified in input parameter \b vals in \b this.
8945  * This works only for DataArrayInt having number of components equal to one (if not an INTERP_KERNEL::Exception will be thrown).
8946  * This method differs from DataArrayInt::locateTuple in that the position is internal raw data is not considered here contrary to DataArrayInt::locateTuple.
8947  * \sa DataArrayInt::locateTuple
8948  */
8949 int DataArrayInt::search(const std::vector<int>& vals) const
8950 {
8951   checkAllocated();
8952   int nbOfCompo=getNumberOfComponents();
8953   if(nbOfCompo!=1)
8954     throw INTERP_KERNEL::Exception("DataArrayInt::search : works only for DataArrayInt instance with one component !");
8955   const int *cptr=getConstPointer();
8956   std::size_t nbOfVals=getNbOfElems();
8957   const int *loc=std::search(cptr,cptr+nbOfVals,vals.begin(),vals.end());
8958   if(loc!=cptr+nbOfVals)
8959     return std::distance(cptr,loc);
8960   return -1;
8961 }
8962
8963 /*!
8964  * This method expects to be called when number of components of this is equal to one.
8965  * This method returns the tuple id, if it exists, of the first tuple equal to \b value.
8966  * If not any tuple contains \b value -1 is returned.
8967  * \sa DataArrayInt::presenceOfValue
8968  */
8969 int DataArrayInt::locateValue(int value) const
8970 {
8971   checkAllocated();
8972   if(getNumberOfComponents()!=1)
8973     throw INTERP_KERNEL::Exception("DataArrayInt::presenceOfValue : the array must have only one component, you can call 'rearrange' method before !");
8974   const int *cptr=getConstPointer();
8975   int nbOfTuples=getNumberOfTuples();
8976   const int *ret=std::find(cptr,cptr+nbOfTuples,value);
8977   if(ret!=cptr+nbOfTuples)
8978     return std::distance(cptr,ret);
8979   return -1;
8980 }
8981
8982 /*!
8983  * This method expects to be called when number of components of this is equal to one.
8984  * This method returns the tuple id, if it exists, of the first tuple so that the value is contained in \b vals.
8985  * If not any tuple contains one of the values contained in 'vals' false is returned.
8986  * \sa DataArrayInt::presenceOfValue
8987  */
8988 int DataArrayInt::locateValue(const std::vector<int>& vals) const
8989 {
8990   checkAllocated();
8991   if(getNumberOfComponents()!=1)
8992     throw INTERP_KERNEL::Exception("DataArrayInt::presenceOfValue : the array must have only one component, you can call 'rearrange' method before !");
8993   std::set<int> vals2(vals.begin(),vals.end());
8994   const int *cptr=getConstPointer();
8995   int nbOfTuples=getNumberOfTuples();
8996   for(const int *w=cptr;w!=cptr+nbOfTuples;w++)
8997     if(vals2.find(*w)!=vals2.end())
8998       return std::distance(cptr,w);
8999   return -1;
9000 }
9001
9002 /*!
9003  * This method returns the number of values in \a this that are equals to input parameter \a value.
9004  * This method only works for single component array.
9005  *
9006  * \return a value in [ 0, \c this->getNumberOfTuples() )
9007  *
9008  * \throw If \a this is not allocated
9009  *
9010  */
9011 int DataArrayInt::count(int value) const
9012 {
9013   int ret=0;
9014   checkAllocated();
9015   if(getNumberOfComponents()!=1)
9016     throw INTERP_KERNEL::Exception("DataArrayInt::count : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
9017   const int *vals=begin();
9018   int nbOfTuples=getNumberOfTuples();
9019   for(int i=0;i<nbOfTuples;i++,vals++)
9020     if(*vals==value)
9021       ret++;
9022   return ret;
9023 }
9024
9025 /*!
9026  * This method is an extension of DataArrayInt::presenceOfValue method because this method works for DataArrayInt with
9027  * any number of components excepted 0 (an INTERP_KERNEL::Exception is thrown in this case).
9028  * This method searches in \b this is there is a tuple that matched the input parameter \b tupl.
9029  * This method throws an INTERP_KERNEL::Exception if the number of components in \b this mismatches with the size of
9030  * the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
9031  * \sa DataArrayInt::locateTuple
9032  */
9033 bool DataArrayInt::presenceOfTuple(const std::vector<int>& tupl) const
9034 {
9035   return locateTuple(tupl)!=-1;
9036 }
9037
9038
9039 /*!
9040  * Returns \a true if a given value is present within \a this one-dimensional array.
9041  *  \param [in] value - the value to find within \a this array.
9042  *  \return bool - \a true in case if \a value is present within \a this array.
9043  *  \throw If \a this is not allocated.
9044  *  \throw If \a this->getNumberOfComponents() != 1.
9045  *  \sa locateValue()
9046  */
9047 bool DataArrayInt::presenceOfValue(int value) const
9048 {
9049   return locateValue(value)!=-1;
9050 }
9051
9052 /*!
9053  * This method expects to be called when number of components of this is equal to one.
9054  * This method returns true if it exists a tuple so that the value is contained in \b vals.
9055  * If not any tuple contains one of the values contained in 'vals' false is returned.
9056  * \sa DataArrayInt::locateValue
9057  */
9058 bool DataArrayInt::presenceOfValue(const std::vector<int>& vals) const
9059 {
9060   return locateValue(vals)!=-1;
9061 }
9062
9063 /*!
9064  * Accumulates values of each component of \a this array.
9065  *  \param [out] res - an array of length \a this->getNumberOfComponents(), allocated
9066  *         by the caller, that is filled by this method with sum value for each
9067  *         component.
9068  *  \throw If \a this is not allocated.
9069  */
9070 void DataArrayInt::accumulate(int *res) const
9071 {
9072   checkAllocated();
9073   const int *ptr=getConstPointer();
9074   int nbTuple=getNumberOfTuples();
9075   int nbComps=getNumberOfComponents();
9076   std::fill(res,res+nbComps,0);
9077   for(int i=0;i<nbTuple;i++)
9078     std::transform(ptr+i*nbComps,ptr+(i+1)*nbComps,res,res,std::plus<int>());
9079 }
9080
9081 int DataArrayInt::accumulate(int compId) const
9082 {
9083   checkAllocated();
9084   const int *ptr=getConstPointer();
9085   int nbTuple=getNumberOfTuples();
9086   int nbComps=getNumberOfComponents();
9087   if(compId<0 || compId>=nbComps)
9088     throw INTERP_KERNEL::Exception("DataArrayInt::accumulate : Invalid compId specified : No such nb of components !");
9089   int ret=0;
9090   for(int i=0;i<nbTuple;i++)
9091     ret+=ptr[i*nbComps+compId];
9092   return ret;
9093 }
9094
9095 /*!
9096  * This method accumulate using addition tuples in \a this using input index array [ \a bgOfIndex, \a endOfIndex ).
9097  * The returned array will have same number of components than \a this and number of tuples equal to
9098  * \c std::distance(bgOfIndex,endOfIndex) \b minus \b one.
9099  *
9100  * The input index array is expected to be ascendingly sorted in which the all referenced ids should be in [0, \c this->getNumberOfTuples).
9101  *
9102  * \param [in] bgOfIndex - begin (included) of the input index array.
9103  * \param [in] endOfIndex - end (excluded) of the input index array.
9104  * \return DataArrayInt * - the new instance having the same number of components than \a this.
9105  *
9106  * \throw If bgOfIndex or end is NULL.
9107  * \throw If input index array is not ascendingly sorted.
9108  * \throw If there is an id in [ \a bgOfIndex, \a endOfIndex ) not in [0, \c this->getNumberOfTuples).
9109  * \throw If std::distance(bgOfIndex,endOfIndex)==0.
9110  */
9111 DataArrayInt *DataArrayInt::accumulatePerChunck(const int *bgOfIndex, const int *endOfIndex) const
9112 {
9113   if(!bgOfIndex || !endOfIndex)
9114     throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : input pointer NULL !");
9115   checkAllocated();
9116   int nbCompo=getNumberOfComponents();
9117   int nbOfTuples=getNumberOfTuples();
9118   int sz=(int)std::distance(bgOfIndex,endOfIndex);
9119   if(sz<1)
9120     throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : invalid size of input index array !");
9121   sz--;
9122   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(sz,nbCompo);
9123   const int *w=bgOfIndex;
9124   if(*w<0 || *w>=nbOfTuples)
9125     throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : The first element of the input index not in [0,nbOfTuples) !");
9126   const int *srcPt=begin()+(*w)*nbCompo;
9127   int *tmp=ret->getPointer();
9128   for(int i=0;i<sz;i++,tmp+=nbCompo,w++)
9129     {
9130       std::fill(tmp,tmp+nbCompo,0);
9131       if(w[1]>=w[0])
9132         {
9133           for(int j=w[0];j<w[1];j++,srcPt+=nbCompo)
9134             {
9135               if(j>=0 && j<nbOfTuples)
9136                 std::transform(srcPt,srcPt+nbCompo,tmp,tmp,std::plus<int>());
9137               else
9138                 {
9139                   std::ostringstream oss; oss << "DataArrayInt::accumulatePerChunck : At rank #" << i << " the input index array points to id " << j << " should be in [0," << nbOfTuples << ") !";
9140                   throw INTERP_KERNEL::Exception(oss.str().c_str());
9141                 }
9142             }
9143         }
9144       else
9145         {
9146           std::ostringstream oss; oss << "DataArrayInt::accumulatePerChunck : At rank #" << i << " the input index array is not in ascendingly sorted.";
9147           throw INTERP_KERNEL::Exception(oss.str().c_str());
9148         }
9149     }
9150   ret->copyStringInfoFrom(*this);
9151   return ret.retn();
9152 }
9153
9154 /*!
9155  * Returns a new DataArrayInt by concatenating two given arrays, so that (1) the number
9156  * of tuples in the result array is <em> a1->getNumberOfTuples() + a2->getNumberOfTuples() -
9157  * offsetA2</em> and (2)
9158  * the number of component in the result array is same as that of each of given arrays.
9159  * First \a offsetA2 tuples of \a a2 are skipped and thus are missing from the result array.
9160  * Info on components is copied from the first of the given arrays. Number of components
9161  * in the given arrays must be the same.
9162  *  \param [in] a1 - an array to include in the result array.
9163  *  \param [in] a2 - another array to include in the result array.
9164  *  \param [in] offsetA2 - number of tuples of \a a2 to skip.
9165  *  \return DataArrayInt * - the new instance of DataArrayInt.
9166  *          The caller is to delete this result array using decrRef() as it is no more
9167  *          needed.
9168  *  \throw If either \a a1 or \a a2 is NULL.
9169  *  \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents().
9170  */
9171 DataArrayInt *DataArrayInt::Aggregate(const DataArrayInt *a1, const DataArrayInt *a2, int offsetA2)
9172 {
9173   if(!a1 || !a2)
9174     throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : input DataArrayInt instance is NULL !");
9175   int nbOfComp=a1->getNumberOfComponents();
9176   if(nbOfComp!=a2->getNumberOfComponents())
9177     throw INTERP_KERNEL::Exception("Nb of components mismatch for array Aggregation !");
9178   int nbOfTuple1=a1->getNumberOfTuples();
9179   int nbOfTuple2=a2->getNumberOfTuples();
9180   DataArrayInt *ret=DataArrayInt::New();
9181   ret->alloc(nbOfTuple1+nbOfTuple2-offsetA2,nbOfComp);
9182   int *pt=std::copy(a1->getConstPointer(),a1->getConstPointer()+nbOfTuple1*nbOfComp,ret->getPointer());
9183   std::copy(a2->getConstPointer()+offsetA2*nbOfComp,a2->getConstPointer()+nbOfTuple2*nbOfComp,pt);
9184   ret->copyStringInfoFrom(*a1);
9185   return ret;
9186 }
9187
9188 /*!
9189  * Returns a new DataArrayInt by concatenating all given arrays, so that (1) the number
9190  * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
9191  * the number of component in the result array is same as that of each of given arrays.
9192  * Info on components is copied from the first of the given arrays. Number of components
9193  * in the given arrays must be  the same.
9194  * If the number of non null of elements in \a arr is equal to one the returned object is a copy of it
9195  * not the object itself.
9196  *  \param [in] arr - a sequence of arrays to include in the result array.
9197  *  \return DataArrayInt * - the new instance of DataArrayInt.
9198  *          The caller is to delete this result array using decrRef() as it is no more
9199  *          needed.
9200  *  \throw If all arrays within \a arr are NULL.
9201  *  \throw If getNumberOfComponents() of arrays within \a arr.
9202  */
9203 DataArrayInt *DataArrayInt::Aggregate(const std::vector<const DataArrayInt *>& arr)
9204 {
9205   std::vector<const DataArrayInt *> a;
9206   for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9207     if(*it4)
9208       a.push_back(*it4);
9209   if(a.empty())
9210     throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : input list must be NON EMPTY !");
9211   std::vector<const DataArrayInt *>::const_iterator it=a.begin();
9212   int nbOfComp=(*it)->getNumberOfComponents();
9213   int nbt=(*it++)->getNumberOfTuples();
9214   for(int i=1;it!=a.end();it++,i++)
9215     {
9216       if((*it)->getNumberOfComponents()!=nbOfComp)
9217         throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : Nb of components mismatch for array aggregation !");
9218       nbt+=(*it)->getNumberOfTuples();
9219     }
9220   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9221   ret->alloc(nbt,nbOfComp);
9222   int *pt=ret->getPointer();
9223   for(it=a.begin();it!=a.end();it++)
9224     pt=std::copy((*it)->getConstPointer(),(*it)->getConstPointer()+(*it)->getNbOfElems(),pt);
9225   ret->copyStringInfoFrom(*(a[0]));
9226   return ret.retn();
9227 }
9228
9229 /*!
9230  * This method takes as input a list of DataArrayInt instances \a arrs that represent each a packed index arrays.
9231  * A packed index array is an allocated array with one component, and at least one tuple. The first element
9232  * of each array in \a arrs must be 0. Each array in \a arrs is expected to be increasingly monotonic.
9233  * This method is useful for users that want to aggregate a pair of DataArrayInt representing an indexed data (typically nodal connectivity index in unstructured meshes.
9234  *
9235  * \return DataArrayInt * - a new object to be managed by the caller.
9236  */
9237 DataArrayInt *DataArrayInt::AggregateIndexes(const std::vector<const DataArrayInt *>& arrs)
9238 {
9239   int retSz=1;
9240   for(std::vector<const DataArrayInt *>::const_iterator it4=arrs.begin();it4!=arrs.end();it4++)
9241     {
9242       if(*it4)
9243         {
9244           (*it4)->checkAllocated();
9245           if((*it4)->getNumberOfComponents()!=1)
9246             {
9247               std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with nb of compo != 1 at pos " << std::distance(arrs.begin(),it4) << " !";
9248               throw INTERP_KERNEL::Exception(oss.str().c_str());
9249             }
9250           int nbTupl=(*it4)->getNumberOfTuples();
9251           if(nbTupl<1)
9252             {
9253               std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with nb of tuples < 1 at pos " << std::distance(arrs.begin(),it4) << " !";
9254               throw INTERP_KERNEL::Exception(oss.str().c_str());
9255             }
9256           if((*it4)->front()!=0)
9257             {
9258               std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with front value != 0 at pos " << std::distance(arrs.begin(),it4) << " !";
9259               throw INTERP_KERNEL::Exception(oss.str().c_str());
9260             }
9261           retSz+=nbTupl-1;
9262         }
9263       else
9264         {
9265           std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a null instance at pos " << std::distance(arrs.begin(),it4) << " !";
9266           throw INTERP_KERNEL::Exception(oss.str().c_str());
9267         }
9268     }
9269   if(arrs.empty())
9270     throw INTERP_KERNEL::Exception("DataArrayInt::AggregateIndexes : input list must be NON EMPTY !");
9271   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9272   ret->alloc(retSz,1);
9273   int *pt=ret->getPointer(); *pt++=0;
9274   for(std::vector<const DataArrayInt *>::const_iterator it=arrs.begin();it!=arrs.end();it++)
9275     pt=std::transform((*it)->begin()+1,(*it)->end(),pt,std::bind2nd(std::plus<int>(),pt[-1]));
9276   ret->copyStringInfoFrom(*(arrs[0]));
9277   return ret.retn();
9278 }
9279
9280 /*!
9281  * Returns the maximal value and its location within \a this one-dimensional array.
9282  *  \param [out] tupleId - index of the tuple holding the maximal value.
9283  *  \return int - the maximal value among all values of \a this array.
9284  *  \throw If \a this->getNumberOfComponents() != 1
9285  *  \throw If \a this->getNumberOfTuples() < 1
9286  */
9287 int DataArrayInt::getMaxValue(int& tupleId) const
9288 {
9289   checkAllocated();
9290   if(getNumberOfComponents()!=1)
9291     throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : must be applied on DataArrayInt with only one component !");
9292   int nbOfTuples=getNumberOfTuples();
9293   if(nbOfTuples<=0)
9294     throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : array exists but number of tuples must be > 0 !");
9295   const int *vals=getConstPointer();
9296   const int *loc=std::max_element(vals,vals+nbOfTuples);
9297   tupleId=(int)std::distance(vals,loc);
9298   return *loc;
9299 }
9300
9301 /*!
9302  * Returns the maximal value within \a this array that is allowed to have more than
9303  *  one component.
9304  *  \return int - the maximal value among all values of \a this array.
9305  *  \throw If \a this is not allocated.
9306  */
9307 int DataArrayInt::getMaxValueInArray() const
9308 {
9309   checkAllocated();
9310   const int *loc=std::max_element(begin(),end());
9311   return *loc;
9312 }
9313
9314 /*!
9315  * Returns the minimal value and its location within \a this one-dimensional array.
9316  *  \param [out] tupleId - index of the tuple holding the minimal value.
9317  *  \return int - the minimal value among all values of \a this array.
9318  *  \throw If \a this->getNumberOfComponents() != 1
9319  *  \throw If \a this->getNumberOfTuples() < 1
9320  */
9321 int DataArrayInt::getMinValue(int& tupleId) const
9322 {
9323   checkAllocated();
9324   if(getNumberOfComponents()!=1)
9325     throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : must be applied on DataArrayInt with only one component !");
9326   int nbOfTuples=getNumberOfTuples();
9327   if(nbOfTuples<=0)
9328     throw INTERP_KERNEL::Exception("DataArrayInt::getMaxValue : array exists but number of tuples must be > 0 !");
9329   const int *vals=getConstPointer();
9330   const int *loc=std::min_element(vals,vals+nbOfTuples);
9331   tupleId=(int)std::distance(vals,loc);
9332   return *loc;
9333 }
9334
9335 /*!
9336  * Returns the minimal value within \a this array that is allowed to have more than
9337  *  one component.
9338  *  \return int - the minimal value among all values of \a this array.
9339  *  \throw If \a this is not allocated.
9340  */
9341 int DataArrayInt::getMinValueInArray() const
9342 {
9343   checkAllocated();
9344   const int *loc=std::min_element(begin(),end());
9345   return *loc;
9346 }
9347
9348 /*!
9349  * Returns in a single walk in \a this the min value and the max value in \a this.
9350  * \a this is expected to be single component array.
9351  *
9352  * \param [out] minValue - the min value in \a this.
9353  * \param [out] maxValue - the max value in \a this.
9354  *
9355  * \sa getMinValueInArray, getMinValue, getMaxValueInArray, getMaxValue
9356  */
9357 void DataArrayInt::getMinMaxValues(int& minValue, int& maxValue) const
9358 {
9359   checkAllocated();
9360   if(getNumberOfComponents()!=1)
9361     throw INTERP_KERNEL::Exception("DataArrayInt::getMinMaxValues : must be applied on DataArrayInt with only one component !");
9362   int nbTuples(getNumberOfTuples());
9363   const int *pt(begin());
9364   minValue=std::numeric_limits<int>::max(); maxValue=-std::numeric_limits<int>::max();
9365   for(int i=0;i<nbTuples;i++,pt++)
9366     {
9367       if(*pt<minValue)
9368         minValue=*pt;
9369       if(*pt>maxValue)
9370         maxValue=*pt;
9371     }
9372 }
9373
9374 /*!
9375  * Converts every value of \a this array to its absolute value.
9376  * \b WARNING this method is non const. If a new DataArrayInt instance should be built containing the result of abs DataArrayInt::computeAbs
9377  * should be called instead.
9378  *
9379  * \throw If \a this is not allocated.
9380  * \sa DataArrayInt::computeAbs
9381  */
9382 void DataArrayInt::abs()
9383 {
9384   checkAllocated();
9385   int *ptr(getPointer());
9386   std::size_t nbOfElems(getNbOfElems());
9387   std::transform(ptr,ptr+nbOfElems,ptr,std::ptr_fun<int,int>(std::abs));
9388   declareAsNew();
9389 }
9390
9391 /*!
9392  * This method builds a new instance of \a this object containing the result of std::abs applied of all elements in \a this.
9393  * This method is a const method (that do not change any values in \a this) contrary to  DataArrayInt::abs method.
9394  *
9395  * \return DataArrayInt * - the new instance of DataArrayInt containing the
9396  *         same number of tuples and component as \a this array.
9397  *         The caller is to delete this result array using decrRef() as it is no more
9398  *         needed.
9399  * \throw If \a this is not allocated.
9400  * \sa DataArrayInt::abs
9401  */
9402 DataArrayInt *DataArrayInt::computeAbs() const
9403 {
9404   checkAllocated();
9405   DataArrayInt *newArr(DataArrayInt::New());
9406   int nbOfTuples(getNumberOfTuples());
9407   int nbOfComp(getNumberOfComponents());
9408   newArr->alloc(nbOfTuples,nbOfComp);
9409   std::transform(begin(),end(),newArr->getPointer(),std::ptr_fun<int,int>(std::abs));
9410   newArr->copyStringInfoFrom(*this);
9411   return newArr;
9412 }
9413
9414 /*!
9415  * Apply a liner function to a given component of \a this array, so that
9416  * an array element <em>(x)</em> becomes \f$ a * x + b \f$.
9417  *  \param [in] a - the first coefficient of the function.
9418  *  \param [in] b - the second coefficient of the function.
9419  *  \param [in] compoId - the index of component to modify.
9420  *  \throw If \a this is not allocated.
9421  */
9422 void DataArrayInt::applyLin(int a, int b, int compoId)
9423 {
9424   checkAllocated();
9425   int *ptr=getPointer()+compoId;
9426   int nbOfComp=getNumberOfComponents();
9427   int nbOfTuple=getNumberOfTuples();
9428   for(int i=0;i<nbOfTuple;i++,ptr+=nbOfComp)
9429     *ptr=a*(*ptr)+b;
9430   declareAsNew();
9431 }
9432
9433 /*!
9434  * Apply a liner function to all elements of \a this array, so that
9435  * an element _x_ becomes \f$ a * x + b \f$.
9436  *  \param [in] a - the first coefficient of the function.
9437  *  \param [in] b - the second coefficient of the function.
9438  *  \throw If \a this is not allocated.
9439  */
9440 void DataArrayInt::applyLin(int a, int b)
9441 {
9442   checkAllocated();
9443   int *ptr=getPointer();
9444   std::size_t nbOfElems=getNbOfElems();
9445   for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9446     *ptr=a*(*ptr)+b;
9447   declareAsNew();
9448 }
9449
9450 /*!
9451  * Returns a full copy of \a this array except that sign of all elements is reversed.
9452  *  \return DataArrayInt * - the new instance of DataArrayInt containing the
9453  *          same number of tuples and component as \a this array.
9454  *          The caller is to delete this result array using decrRef() as it is no more
9455  *          needed.
9456  *  \throw If \a this is not allocated.
9457  */
9458 DataArrayInt *DataArrayInt::negate() const
9459 {
9460   checkAllocated();
9461   DataArrayInt *newArr=DataArrayInt::New();
9462   int nbOfTuples=getNumberOfTuples();
9463   int nbOfComp=getNumberOfComponents();
9464   newArr->alloc(nbOfTuples,nbOfComp);
9465   const int *cptr=getConstPointer();
9466   std::transform(cptr,cptr+nbOfTuples*nbOfComp,newArr->getPointer(),std::negate<int>());
9467   newArr->copyStringInfoFrom(*this);
9468   return newArr;
9469 }
9470
9471 /*!
9472  * Modify all elements of \a this array, so that
9473  * an element _x_ becomes \f$ numerator / x \f$.
9474  *  \warning If an exception is thrown because of presence of 0 element in \a this
9475  *           array, all elements processed before detection of the zero element remain
9476  *           modified.
9477  *  \param [in] numerator - the numerator used to modify array elements.
9478  *  \throw If \a this is not allocated.
9479  *  \throw If there is an element equal to 0 in \a this array.
9480  */
9481 void DataArrayInt::applyInv(int numerator)
9482 {
9483   checkAllocated();
9484   int *ptr=getPointer();
9485   std::size_t nbOfElems=getNbOfElems();
9486   for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9487     {
9488       if(*ptr!=0)
9489         {
9490           *ptr=numerator/(*ptr);
9491         }
9492       else
9493         {
9494           std::ostringstream oss; oss << "DataArrayInt::applyInv : presence of null value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
9495           oss << " !";
9496           throw INTERP_KERNEL::Exception(oss.str().c_str());
9497         }
9498     }
9499   declareAsNew();
9500 }
9501
9502 /*!
9503  * Modify all elements of \a this array, so that
9504  * an element _x_ becomes \f$ x / val \f$.
9505  *  \param [in] val - the denominator used to modify array elements.
9506  *  \throw If \a this is not allocated.
9507  *  \throw If \a val == 0.
9508  */
9509 void DataArrayInt::applyDivideBy(int val)
9510 {
9511   if(val==0)
9512     throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to divide by 0 !");
9513   checkAllocated();
9514   int *ptr=getPointer();
9515   std::size_t nbOfElems=getNbOfElems();
9516   std::transform(ptr,ptr+nbOfElems,ptr,std::bind2nd(std::divides<int>(),val));
9517   declareAsNew();
9518 }
9519
9520 /*!
9521  * Modify all elements of \a this array, so that
9522  * an element _x_ becomes  <em> x % val </em>.
9523  *  \param [in] val - the divisor used to modify array elements.
9524  *  \throw If \a this is not allocated.
9525  *  \throw If \a val <= 0.
9526  */
9527 void DataArrayInt::applyModulus(int val)
9528 {
9529   if(val<=0)
9530     throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to operate modulus on value <= 0 !");
9531   checkAllocated();
9532   int *ptr=getPointer();
9533   std::size_t nbOfElems=getNbOfElems();
9534   std::transform(ptr,ptr+nbOfElems,ptr,std::bind2nd(std::modulus<int>(),val));
9535   declareAsNew();
9536 }
9537
9538 /*!
9539  * This method works only on data array with one component.
9540  * This method returns a newly allocated array storing stored ascendantly tuple ids in \b this so that
9541  * this[*id] in [\b vmin,\b vmax)
9542  *
9543  * \param [in] vmin begin of range. This value is included in range (included).
9544  * \param [in] vmax end of range. This value is \b not included in range (excluded).
9545  * \return a newly allocated data array that the caller should deal with.
9546  *
9547  * \sa DataArrayInt::getIdsNotInRange , DataArrayInt::getIdsStrictlyNegative
9548  */
9549 DataArrayInt *DataArrayInt::getIdsInRange(int vmin, int vmax) const
9550 {
9551   checkAllocated();
9552   if(getNumberOfComponents()!=1)
9553     throw INTERP_KERNEL::Exception("DataArrayInt::getIdsInRange : this must have exactly one component !");
9554   const int *cptr(begin());
9555   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
9556   int nbOfTuples(getNumberOfTuples());
9557   for(int i=0;i<nbOfTuples;i++,cptr++)
9558     if(*cptr>=vmin && *cptr<vmax)
9559       ret->pushBackSilent(i);
9560   return ret.retn();
9561 }
9562
9563 /*!
9564  * This method works only on data array with one component.
9565  * This method returns a newly allocated array storing stored ascendantly tuple ids in \b this so that
9566  * this[*id] \b not in [\b vmin,\b vmax)
9567  *
9568  * \param [in] vmin begin of range. This value is \b not included in range (excluded).
9569  * \param [in] vmax end of range. This value is included in range (included).
9570  * \return a newly allocated data array that the caller should deal with.
9571  *
9572  * \sa DataArrayInt::getIdsInRange , DataArrayInt::getIdsStrictlyNegative
9573  */
9574 DataArrayInt *DataArrayInt::getIdsNotInRange(int vmin, int vmax) const
9575 {
9576   checkAllocated();
9577   if(getNumberOfComponents()!=1)
9578     throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotInRange : this must have exactly one component !");
9579   const int *cptr(getConstPointer());
9580   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
9581   int nbOfTuples(getNumberOfTuples());
9582   for(int i=0;i<nbOfTuples;i++,cptr++)
9583     if(*cptr<vmin || *cptr>=vmax)
9584       ret->pushBackSilent(i);
9585   return ret.retn();
9586 }
9587
9588 /*!
9589  * This method works only on data array with one component. This method returns a newly allocated array storing stored ascendantly of tuple ids in \a this so that this[id]<0.
9590  *
9591  * \return a newly allocated data array that the caller should deal with.
9592  * \sa DataArrayInt::getIdsInRange
9593  */
9594 DataArrayInt *DataArrayInt::getIdsStrictlyNegative() const
9595 {
9596   checkAllocated();
9597   if(getNumberOfComponents()!=1)
9598     throw INTERP_KERNEL::Exception("DataArrayInt::getIdsStrictlyNegative : this must have exactly one component !");
9599   const int *cptr(getConstPointer());
9600   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
9601   int nbOfTuples(getNumberOfTuples());
9602   for(int i=0;i<nbOfTuples;i++,cptr++)
9603     if(*cptr<0)
9604       ret->pushBackSilent(i);
9605   return ret.retn();
9606 }
9607
9608 /*!
9609  * This method works only on data array with one component.
9610  * This method checks that all ids in \b this are in [ \b vmin, \b vmax ). If there is at least one element in \a this not in [ \b vmin, \b vmax ) an exception will be thrown.
9611  *
9612  * \param [in] vmin begin of range. This value is included in range (included).
9613  * \param [in] vmax end of range. This value is \b not included in range (excluded).
9614  * \return if all ids in \a this are so that (*this)[i]==i for all i in [ 0, \c this->getNumberOfTuples() ). */
9615 bool DataArrayInt::checkAllIdsInRange(int vmin, int vmax) const
9616 {
9617   checkAllocated();
9618   if(getNumberOfComponents()!=1)
9619     throw INTERP_KERNEL::Exception("DataArrayInt::checkAllIdsInRange : this must have exactly one component !");
9620   int nbOfTuples=getNumberOfTuples();
9621   bool ret=true;
9622   const int *cptr=getConstPointer();
9623   for(int i=0;i<nbOfTuples;i++,cptr++)
9624     {
9625       if(*cptr>=vmin && *cptr<vmax)
9626         { ret=ret && *cptr==i; }
9627       else
9628         {
9629           std::ostringstream oss; oss << "DataArrayInt::checkAllIdsInRange : tuple #" << i << " has value " << *cptr << " should be in [" << vmin << "," << vmax << ") !";
9630           throw INTERP_KERNEL::Exception(oss.str().c_str());
9631         }
9632     }
9633   return ret;
9634 }
9635
9636 /*!
9637  * Modify all elements of \a this array, so that
9638  * an element _x_ becomes <em> val % x </em>.
9639  *  \warning If an exception is thrown because of presence of an element <= 0 in \a this
9640  *           array, all elements processed before detection of the zero element remain
9641  *           modified.
9642  *  \param [in] val - the divident used to modify array elements.
9643  *  \throw If \a this is not allocated.
9644  *  \throw If there is an element equal to or less than 0 in \a this array.
9645  */
9646 void DataArrayInt::applyRModulus(int val)
9647 {
9648   checkAllocated();
9649   int *ptr=getPointer();
9650   std::size_t nbOfElems=getNbOfElems();
9651   for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9652     {
9653       if(*ptr>0)
9654         {
9655           *ptr=val%(*ptr);
9656         }
9657       else
9658         {
9659           std::ostringstream oss; oss << "DataArrayInt::applyRModulus : presence of value <=0 in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
9660           oss << " !";
9661           throw INTERP_KERNEL::Exception(oss.str().c_str());
9662         }
9663     }
9664   declareAsNew();
9665 }
9666
9667 /*!
9668  * Modify all elements of \a this array, so that
9669  * an element _x_ becomes <em> val ^ x </em>.
9670  *  \param [in] val - the value used to apply pow on all array elements.
9671  *  \throw If \a this is not allocated.
9672  *  \throw If \a val < 0.
9673  */
9674 void DataArrayInt::applyPow(int val)
9675 {
9676   checkAllocated();
9677   if(val<0)
9678     throw INTERP_KERNEL::Exception("DataArrayInt::applyPow : input pow in < 0 !");
9679   int *ptr=getPointer();
9680   std::size_t nbOfElems=getNbOfElems();
9681   if(val==0)
9682     {
9683       std::fill(ptr,ptr+nbOfElems,1);
9684       return ;
9685     }
9686   for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9687     {
9688       int tmp=1;
9689       for(int j=0;j<val;j++)
9690         tmp*=*ptr;
9691       *ptr=tmp;
9692     }
9693   declareAsNew();
9694 }
9695
9696 /*!
9697  * Modify all elements of \a this array, so that
9698  * an element _x_ becomes \f$ val ^ x \f$.
9699  *  \param [in] val - the value used to apply pow on all array elements.
9700  *  \throw If \a this is not allocated.
9701  *  \throw If there is an element < 0 in \a this array.
9702  *  \warning If an exception is thrown because of presence of 0 element in \a this
9703  *           array, all elements processed before detection of the zero element remain
9704  *           modified.
9705  */
9706 void DataArrayInt::applyRPow(int val)
9707 {
9708   checkAllocated();
9709   int *ptr=getPointer();
9710   std::size_t nbOfElems=getNbOfElems();
9711   for(std::size_t i=0;i<nbOfElems;i++,ptr++)
9712     {
9713       if(*ptr>=0)
9714         {
9715           int tmp=1;
9716           for(int j=0;j<*ptr;j++)
9717             tmp*=val;
9718           *ptr=tmp;
9719         }
9720       else
9721         {
9722           std::ostringstream oss; oss << "DataArrayInt::applyRPow : presence of negative value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
9723           oss << " !";
9724           throw INTERP_KERNEL::Exception(oss.str().c_str());
9725         }
9726     }
9727   declareAsNew();
9728 }
9729
9730 /*!
9731  * Returns a new DataArrayInt by aggregating two given arrays, so that (1) the number
9732  * of components in the result array is a sum of the number of components of given arrays
9733  * and (2) the number of tuples in the result array is same as that of each of given
9734  * arrays. In other words the i-th tuple of result array includes all components of
9735  * i-th tuples of all given arrays.
9736  * Number of tuples in the given arrays must be the same.
9737  *  \param [in] a1 - an array to include in the result array.
9738  *  \param [in] a2 - another array to include in the result array.
9739  *  \return DataArrayInt * - the new instance of DataArrayInt.
9740  *          The caller is to delete this result array using decrRef() as it is no more
9741  *          needed.
9742  *  \throw If both \a a1 and \a a2 are NULL.
9743  *  \throw If any given array is not allocated.
9744  *  \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
9745  */
9746 DataArrayInt *DataArrayInt::Meld(const DataArrayInt *a1, const DataArrayInt *a2)
9747 {
9748   std::vector<const DataArrayInt *> arr(2);
9749   arr[0]=a1; arr[1]=a2;
9750   return Meld(arr);
9751 }
9752
9753 /*!
9754  * Returns a new DataArrayInt by aggregating all given arrays, so that (1) the number
9755  * of components in the result array is a sum of the number of components of given arrays
9756  * and (2) the number of tuples in the result array is same as that of each of given
9757  * arrays. In other words the i-th tuple of result array includes all components of
9758  * i-th tuples of all given arrays.
9759  * Number of tuples in the given arrays must be  the same.
9760  *  \param [in] arr - a sequence of arrays to include in the result array.
9761  *  \return DataArrayInt * - the new instance of DataArrayInt.
9762  *          The caller is to delete this result array using decrRef() as it is no more
9763  *          needed.
9764  *  \throw If all arrays within \a arr are NULL.
9765  *  \throw If any given array is not allocated.
9766  *  \throw If getNumberOfTuples() of arrays within \a arr is different.
9767  */
9768 DataArrayInt *DataArrayInt::Meld(const std::vector<const DataArrayInt *>& arr)
9769 {
9770   std::vector<const DataArrayInt *> a;
9771   for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9772     if(*it4)
9773       a.push_back(*it4);
9774   if(a.empty())
9775     throw INTERP_KERNEL::Exception("DataArrayInt::Meld : array must be NON empty !");
9776   std::vector<const DataArrayInt *>::const_iterator it;
9777   for(it=a.begin();it!=a.end();it++)
9778     (*it)->checkAllocated();
9779   it=a.begin();
9780   int nbOfTuples=(*it)->getNumberOfTuples();
9781   std::vector<int> nbc(a.size());
9782   std::vector<const int *> pts(a.size());
9783   nbc[0]=(*it)->getNumberOfComponents();
9784   pts[0]=(*it++)->getConstPointer();
9785   for(int i=1;it!=a.end();it++,i++)
9786     {
9787       if(nbOfTuples!=(*it)->getNumberOfTuples())
9788         throw INTERP_KERNEL::Exception("DataArrayInt::meld : mismatch of number of tuples !");
9789       nbc[i]=(*it)->getNumberOfComponents();
9790       pts[i]=(*it)->getConstPointer();
9791     }
9792   int totalNbOfComp=std::accumulate(nbc.begin(),nbc.end(),0);
9793   DataArrayInt *ret=DataArrayInt::New();
9794   ret->alloc(nbOfTuples,totalNbOfComp);
9795   int *retPtr=ret->getPointer();
9796   for(int i=0;i<nbOfTuples;i++)
9797     for(int j=0;j<(int)a.size();j++)
9798       {
9799         retPtr=std::copy(pts[j],pts[j]+nbc[j],retPtr);
9800         pts[j]+=nbc[j];
9801       }
9802   int k=0;
9803   for(int i=0;i<(int)a.size();i++)
9804     for(int j=0;j<nbc[i];j++,k++)
9805       ret->setInfoOnComponent(k,a[i]->getInfoOnComponent(j));
9806   return ret;
9807 }
9808
9809 /*!
9810  * Returns a new DataArrayInt which is a minimal partition of elements of \a groups.
9811  * The i-th item of the result array is an ID of a set of elements belonging to a
9812  * unique set of groups, which the i-th element is a part of. This set of elements
9813  * belonging to a unique set of groups is called \a family, so the result array contains
9814  * IDs of families each element belongs to.
9815  *
9816  * \b Example: if we have two groups of elements: \a group1 [0,4] and \a group2 [ 0,1,2 ],
9817  * then there are 3 families:
9818  * - \a family1 (with ID 1) contains element [0] belonging to ( \a group1 + \a group2 ),
9819  * - \a family2 (with ID 2) contains elements [4] belonging to ( \a group1 ),
9820  * - \a family3 (with ID 3) contains element [1,2] belonging to ( \a group2 ), <br>
9821  * and the result array contains IDs of families [ 1,3,3,0,2 ]. <br> Note a family ID 0 which
9822  * stands for the element #3 which is in none of groups.
9823  *
9824  *  \param [in] groups - sequence of groups of element IDs.
9825  *  \param [in] newNb - total number of elements; it must be more than max ID of element
9826  *         in \a groups.
9827  *  \param [out] fidsOfGroups - IDs of families the elements of each group belong to.
9828  *  \return DataArrayInt * - a new instance of DataArrayInt containing IDs of families
9829  *         each element with ID from range [0, \a newNb ) belongs to. The caller is to
9830  *         delete this array using decrRef() as it is no more needed.
9831  *  \throw If any element ID in \a groups violates condition ( 0 <= ID < \a newNb ).
9832  */
9833 DataArrayInt *DataArrayInt::MakePartition(const std::vector<const DataArrayInt *>& groups, int newNb, std::vector< std::vector<int> >& fidsOfGroups)
9834 {
9835   std::vector<const DataArrayInt *> groups2;
9836   for(std::vector<const DataArrayInt *>::const_iterator it4=groups.begin();it4!=groups.end();it4++)
9837     if(*it4)
9838       groups2.push_back(*it4);
9839   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
9840   ret->alloc(newNb,1);
9841   int *retPtr=ret->getPointer();
9842   std::fill(retPtr,retPtr+newNb,0);
9843   int fid=1;
9844   for(std::vector<const DataArrayInt *>::const_iterator iter=groups2.begin();iter!=groups2.end();iter++)
9845     {
9846       const int *ptr=(*iter)->getConstPointer();
9847       std::size_t nbOfElem=(*iter)->getNbOfElems();
9848       int sfid=fid;
9849       for(int j=0;j<sfid;j++)
9850         {
9851           bool found=false;
9852           for(std::size_t i=0;i<nbOfElem;i++)
9853             {
9854               if(ptr[i]>=0 && ptr[i]<newNb)
9855                 {
9856                   if(retPtr[ptr[i]]==j)
9857                     {
9858                       retPtr[ptr[i]]=fid;
9859                       found=true;
9860                     }
9861                 }
9862               else
9863                 {
9864                   std::ostringstream oss; oss << "DataArrayInt::MakePartition : In group \"" << (*iter)->getName() << "\" in tuple #" << i << " value = " << ptr[i] << " ! Should be in [0," << newNb;
9865                   oss << ") !";
9866                   throw INTERP_KERNEL::Exception(oss.str().c_str());
9867                 }
9868             }
9869           if(found)
9870             fid++;
9871         }
9872     }
9873   fidsOfGroups.clear();
9874   fidsOfGroups.resize(groups2.size());
9875   int grId=0;
9876   for(std::vector<const DataArrayInt *>::const_iterator iter=groups2.begin();iter!=groups2.end();iter++,grId++)
9877     {
9878       std::set<int> tmp;
9879       const int *ptr=(*iter)->getConstPointer();
9880       std::size_t nbOfElem=(*iter)->getNbOfElems();
9881       for(const int *p=ptr;p!=ptr+nbOfElem;p++)
9882         tmp.insert(retPtr[*p]);
9883       fidsOfGroups[grId].insert(fidsOfGroups[grId].end(),tmp.begin(),tmp.end());
9884     }
9885   return ret.retn();
9886 }
9887
9888 /*!
9889  * Returns a new DataArrayInt which contains all elements of given one-dimensional
9890  * arrays. The result array does not contain any duplicates and its values
9891  * are sorted in ascending order.
9892  *  \param [in] arr - sequence of DataArrayInt's to unite.
9893  *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9894  *         array using decrRef() as it is no more needed.
9895  *  \throw If any \a arr[i] is not allocated.
9896  *  \throw If \a arr[i]->getNumberOfComponents() != 1.
9897  */
9898 DataArrayInt *DataArrayInt::BuildUnion(const std::vector<const DataArrayInt *>& arr)
9899 {
9900   std::vector<const DataArrayInt *> a;
9901   for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9902     if(*it4)
9903       a.push_back(*it4);
9904   for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9905     {
9906       (*it)->checkAllocated();
9907       if((*it)->getNumberOfComponents()!=1)
9908         throw INTERP_KERNEL::Exception("DataArrayInt::BuildUnion : only single component allowed !");
9909     }
9910   //
9911   std::set<int> r;
9912   for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9913     {
9914       const int *pt=(*it)->getConstPointer();
9915       int nbOfTuples=(*it)->getNumberOfTuples();
9916       r.insert(pt,pt+nbOfTuples);
9917     }
9918   DataArrayInt *ret=DataArrayInt::New();
9919   ret->alloc((int)r.size(),1);
9920   std::copy(r.begin(),r.end(),ret->getPointer());
9921   return ret;
9922 }
9923
9924 /*!
9925  * Returns a new DataArrayInt which contains elements present in each of given one-dimensional
9926  * arrays. The result array does not contain any duplicates and its values
9927  * are sorted in ascending order.
9928  *  \param [in] arr - sequence of DataArrayInt's to intersect.
9929  *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
9930  *         array using decrRef() as it is no more needed.
9931  *  \throw If any \a arr[i] is not allocated.
9932  *  \throw If \a arr[i]->getNumberOfComponents() != 1.
9933  */
9934 DataArrayInt *DataArrayInt::BuildIntersection(const std::vector<const DataArrayInt *>& arr)
9935 {
9936   std::vector<const DataArrayInt *> a;
9937   for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
9938     if(*it4)
9939       a.push_back(*it4);
9940   for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9941     {
9942       (*it)->checkAllocated();
9943       if((*it)->getNumberOfComponents()!=1)
9944         throw INTERP_KERNEL::Exception("DataArrayInt::BuildIntersection : only single component allowed !");
9945     }
9946   //
9947   std::set<int> r;
9948   for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
9949     {
9950       const int *pt=(*it)->getConstPointer();
9951       int nbOfTuples=(*it)->getNumberOfTuples();
9952       std::set<int> s1(pt,pt+nbOfTuples);
9953       if(it!=a.begin())
9954         {
9955           std::set<int> r2;
9956           std::set_intersection(r.begin(),r.end(),s1.begin(),s1.end(),inserter(r2,r2.end()));
9957           r=r2;
9958         }
9959       else
9960         r=s1;
9961     }
9962   DataArrayInt *ret(DataArrayInt::New());
9963   ret->alloc((int)r.size(),1);
9964   std::copy(r.begin(),r.end(),ret->getPointer());
9965   return ret;
9966 }
9967
9968 /// @cond INTERNAL
9969 namespace ParaMEDMEMImpl
9970 {
9971   class OpSwitchedOn
9972   {
9973   public:
9974     OpSwitchedOn(int *pt):_pt(pt),_cnt(0) { }
9975     void operator()(const bool& b) { if(b) *_pt++=_cnt; _cnt++; }
9976   private:
9977     int *_pt;
9978     int _cnt;
9979   };
9980
9981   class OpSwitchedOff
9982   {
9983   public:
9984     OpSwitchedOff(int *pt):_pt(pt),_cnt(0) { }
9985     void operator()(const bool& b) { if(!b) *_pt++=_cnt; _cnt++; }
9986   private:
9987     int *_pt;
9988     int _cnt;
9989   };
9990 }
9991 /// @endcond
9992
9993 /*!
9994  * This method returns the list of ids in ascending mode so that v[id]==true.
9995  */
9996 DataArrayInt *DataArrayInt::BuildListOfSwitchedOn(const std::vector<bool>& v)
9997 {
9998   int sz((int)std::count(v.begin(),v.end(),true));
9999   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
10000   std::for_each(v.begin(),v.end(),ParaMEDMEMImpl::OpSwitchedOn(ret->getPointer()));
10001   return ret.retn();
10002 }
10003
10004 /*!
10005  * This method returns the list of ids in ascending mode so that v[id]==false.
10006  */
10007 DataArrayInt *DataArrayInt::BuildListOfSwitchedOff(const std::vector<bool>& v)
10008 {
10009   int sz((int)std::count(v.begin(),v.end(),false));
10010   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
10011   std::for_each(v.begin(),v.end(),ParaMEDMEMImpl::OpSwitchedOff(ret->getPointer()));
10012   return ret.retn();
10013 }
10014
10015 /*!
10016  * This method allows to put a vector of vector of integer into a more compact data stucture (skyline).
10017  * This method is not available into python because no available optimized data structure available to map std::vector< std::vector<int> >.
10018  *
10019  * \param [in] v the input data structure to be translate into skyline format.
10020  * \param [out] data the first element of the skyline format. The user is expected to deal with newly allocated array.
10021  * \param [out] dataIndex the second element of the skyline format.
10022  */
10023 void DataArrayInt::PutIntoToSkylineFrmt(const std::vector< std::vector<int> >& v, DataArrayInt *& data, DataArrayInt *& dataIndex)
10024 {
10025   int sz((int)v.size());
10026   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret0(DataArrayInt::New()),ret1(DataArrayInt::New());
10027   ret1->alloc(sz+1,1);
10028   int *pt(ret1->getPointer()); *pt=0;
10029   for(int i=0;i<sz;i++,pt++)
10030     pt[1]=pt[0]+(int)v[i].size();
10031   ret0->alloc(ret1->back(),1);
10032   pt=ret0->getPointer();
10033   for(int i=0;i<sz;i++)
10034     pt=std::copy(v[i].begin(),v[i].end(),pt);
10035   data=ret0.retn(); dataIndex=ret1.retn();
10036 }
10037
10038 /*!
10039  * Returns a new DataArrayInt which contains a complement of elements of \a this
10040  * one-dimensional array. I.e. the result array contains all elements from the range [0,
10041  * \a nbOfElement) not present in \a this array.
10042  *  \param [in] nbOfElement - maximal size of the result array.
10043  *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
10044  *         array using decrRef() as it is no more needed.
10045  *  \throw If \a this is not allocated.
10046  *  \throw If \a this->getNumberOfComponents() != 1.
10047  *  \throw If any element \a x of \a this array violates condition ( 0 <= \a x < \a
10048  *         nbOfElement ).
10049  */
10050 DataArrayInt *DataArrayInt::buildComplement(int nbOfElement) const
10051 {
10052   checkAllocated();
10053   if(getNumberOfComponents()!=1)
10054     throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : only single component allowed !");
10055   std::vector<bool> tmp(nbOfElement);
10056   const int *pt=getConstPointer();
10057   int nbOfTuples=getNumberOfTuples();
10058   for(const int *w=pt;w!=pt+nbOfTuples;w++)
10059     if(*w>=0 && *w<nbOfElement)
10060       tmp[*w]=true;
10061     else
10062       throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : an element is not in valid range : [0,nbOfElement) !");
10063   int nbOfRetVal=(int)std::count(tmp.begin(),tmp.end(),false);
10064   DataArrayInt *ret=DataArrayInt::New();
10065   ret->alloc(nbOfRetVal,1);
10066   int j=0;
10067   int *retPtr=ret->getPointer();
10068   for(int i=0;i<nbOfElement;i++)
10069     if(!tmp[i])
10070       retPtr[j++]=i;
10071   return ret;
10072 }
10073
10074 /*!
10075  * Returns a new DataArrayInt containing elements of \a this one-dimensional missing
10076  * from an \a other one-dimensional array.
10077  *  \param [in] other - a DataArrayInt containing elements not to include in the result array.
10078  *  \return DataArrayInt * - a new instance of DataArrayInt with one component. The
10079  *         caller is to delete this array using decrRef() as it is no more needed.
10080  *  \throw If \a other is NULL.
10081  *  \throw If \a other is not allocated.
10082  *  \throw If \a other->getNumberOfComponents() != 1.
10083  *  \throw If \a this is not allocated.
10084  *  \throw If \a this->getNumberOfComponents() != 1.
10085  *  \sa DataArrayInt::buildSubstractionOptimized()
10086  */
10087 DataArrayInt *DataArrayInt::buildSubstraction(const DataArrayInt *other) const
10088 {
10089   if(!other)
10090     throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : DataArrayInt pointer in input is NULL !");
10091   checkAllocated();
10092   other->checkAllocated();
10093   if(getNumberOfComponents()!=1)
10094     throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed !");
10095   if(other->getNumberOfComponents()!=1)
10096     throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed for other type !");
10097   const int *pt=getConstPointer();
10098   int nbOfTuples=getNumberOfTuples();
10099   std::set<int> s1(pt,pt+nbOfTuples);
10100   pt=other->getConstPointer();
10101   nbOfTuples=other->getNumberOfTuples();
10102   std::set<int> s2(pt,pt+nbOfTuples);
10103   std::vector<int> r;
10104   std::set_difference(s1.begin(),s1.end(),s2.begin(),s2.end(),std::back_insert_iterator< std::vector<int> >(r));
10105   DataArrayInt *ret=DataArrayInt::New();
10106   ret->alloc((int)r.size(),1);
10107   std::copy(r.begin(),r.end(),ret->getPointer());
10108   return ret;
10109 }
10110
10111 /*!
10112  * \a this is expected to have one component and to be sorted ascendingly (as for \a other).
10113  * \a other is expected to be a part of \a this. If not DataArrayInt::buildSubstraction should be called instead.
10114  *
10115  * \param [in] other an array with one component and expected to be sorted ascendingly.
10116  * \ret list of ids in \a this but not in \a other.
10117  * \sa DataArrayInt::buildSubstraction
10118  */
10119 DataArrayInt *DataArrayInt::buildSubstractionOptimized(const DataArrayInt *other) const
10120 {
10121   static const char *MSG="DataArrayInt::buildSubstractionOptimized : only single component allowed !";
10122   if(!other) throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstractionOptimized : NULL input array !");
10123   checkAllocated(); other->checkAllocated();
10124   if(getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception(MSG);
10125   if(other->getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception(MSG);
10126   const int *pt1Bg(begin()),*pt1End(end()),*pt2Bg(other->begin()),*pt2End(other->end());
10127   const int *work1(pt1Bg),*work2(pt2Bg);
10128   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
10129   for(;work1!=pt1End;work1++)
10130     {
10131       if(work2!=pt2End && *work1==*work2)
10132         work2++;
10133       else
10134         ret->pushBackSilent(*work1);
10135     }
10136   return ret.retn();
10137 }
10138
10139
10140 /*!
10141  * Returns a new DataArrayInt which contains all elements of \a this and a given
10142  * one-dimensional arrays. The result array does not contain any duplicates
10143  * and its values are sorted in ascending order.
10144  *  \param [in] other - an array to unite with \a this one.
10145  *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
10146  *         array using decrRef() as it is no more needed.
10147  *  \throw If \a this or \a other is not allocated.
10148  *  \throw If \a this->getNumberOfComponents() != 1.
10149  *  \throw If \a other->getNumberOfComponents() != 1.
10150  */
10151 DataArrayInt *DataArrayInt::buildUnion(const DataArrayInt *other) const
10152 {
10153   std::vector<const DataArrayInt *>arrs(2);
10154   arrs[0]=this; arrs[1]=other;
10155   return BuildUnion(arrs);
10156 }
10157
10158
10159 /*!
10160  * Returns a new DataArrayInt which contains elements present in both \a this and a given
10161  * one-dimensional arrays. The result array does not contain any duplicates
10162  * and its values are sorted in ascending order.
10163  *  \param [in] other - an array to intersect with \a this one.
10164  *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
10165  *         array using decrRef() as it is no more needed.
10166  *  \throw If \a this or \a other is not allocated.
10167  *  \throw If \a this->getNumberOfComponents() != 1.
10168  *  \throw If \a other->getNumberOfComponents() != 1.
10169  */
10170 DataArrayInt *DataArrayInt::buildIntersection(const DataArrayInt *other) const
10171 {
10172   std::vector<const DataArrayInt *>arrs(2);
10173   arrs[0]=this; arrs[1]=other;
10174   return BuildIntersection(arrs);
10175 }
10176
10177 /*!
10178  * This method can be applied on allocated with one component DataArrayInt instance.
10179  * This method is typically relevant for sorted arrays. All consecutive duplicated items in \a this will appear only once in returned DataArrayInt instance.
10180  * Example : if \a this contains [1,2,2,3,3,3,3,4,5,5,7,7,7,19] the returned array will contain [1,2,3,4,5,7,19]
10181  *
10182  * \return a newly allocated array that contain the result of the unique operation applied on \a this.
10183  * \throw if \a this is not allocated or if \a this has not exactly one component.
10184  * \sa DataArrayInt::buildUniqueNotSorted
10185  */
10186 DataArrayInt *DataArrayInt::buildUnique() const
10187 {
10188   checkAllocated();
10189   if(getNumberOfComponents()!=1)
10190     throw INTERP_KERNEL::Exception("DataArrayInt::buildUnique : only single component allowed !");
10191   int nbOfTuples=getNumberOfTuples();
10192   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp=deepCpy();
10193   int *data=tmp->getPointer();
10194   int *last=std::unique(data,data+nbOfTuples);
10195   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10196   ret->alloc(std::distance(data,last),1);
10197   std::copy(data,last,ret->getPointer());
10198   return ret.retn();
10199 }
10200
10201 /*!
10202  * This method can be applied on allocated with one component DataArrayInt instance.
10203  * This method keep elements only once by keeping the same order in \a this that is not expected to be sorted.
10204  *
10205  * \return a newly allocated array that contain the result of the unique operation applied on \a this.
10206  *
10207  * \throw if \a this is not allocated or if \a this has not exactly one component.
10208  *
10209  * \sa DataArrayInt::buildUnique
10210  */
10211 DataArrayInt *DataArrayInt::buildUniqueNotSorted() const
10212 {
10213   checkAllocated();
10214     if(getNumberOfComponents()!=1)
10215       throw INTERP_KERNEL::Exception("DataArrayInt::buildUniqueNotSorted : only single component allowed !");
10216   int minVal,maxVal;
10217   getMinMaxValues(minVal,maxVal);
10218   std::vector<bool> b(maxVal-minVal+1,false);
10219   const int *ptBg(begin()),*endBg(end());
10220   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
10221   for(const int *pt=ptBg;pt!=endBg;pt++)
10222     {
10223       if(!b[*pt-minVal])
10224         {
10225           ret->pushBackSilent(*pt);
10226           b[*pt-minVal]=true;
10227         }
10228     }
10229   ret->copyStringInfoFrom(*this);
10230   return ret.retn();
10231 }
10232
10233 /*!
10234  * Returns a new DataArrayInt which contains size of every of groups described by \a this
10235  * "index" array. Such "index" array is returned for example by
10236  * \ref ParaMEDMEM::MEDCouplingUMesh::buildDescendingConnectivity
10237  * "MEDCouplingUMesh::buildDescendingConnectivity" and
10238  * \ref ParaMEDMEM::MEDCouplingUMesh::getNodalConnectivityIndex
10239  * "MEDCouplingUMesh::getNodalConnectivityIndex" etc.
10240  * This method preforms the reverse operation of DataArrayInt::computeOffsets2.
10241  *  \return DataArrayInt * - a new instance of DataArrayInt, whose number of tuples
10242  *          equals to \a this->getNumberOfComponents() - 1, and number of components is 1.
10243  *          The caller is to delete this array using decrRef() as it is no more needed.
10244  *  \throw If \a this is not allocated.
10245  *  \throw If \a this->getNumberOfComponents() != 1.
10246  *  \throw If \a this->getNumberOfTuples() < 2.
10247  *
10248  *  \b Example: <br>
10249  *         - this contains [1,3,6,7,7,9,15]
10250  *         - result array contains [2,3,1,0,2,6],
10251  *          where 2 = 3 - 1, 3 = 6 - 3, 1 = 7 - 6 etc.
10252  *
10253  * \sa DataArrayInt::computeOffsets2
10254  */
10255 DataArrayInt *DataArrayInt::deltaShiftIndex() const
10256 {
10257   checkAllocated();
10258   if(getNumberOfComponents()!=1)
10259     throw INTERP_KERNEL::Exception("DataArrayInt::deltaShiftIndex : only single component allowed !");
10260   int nbOfTuples=getNumberOfTuples();
10261   if(nbOfTuples<2)
10262     throw INTERP_KERNEL::Exception("DataArrayInt::deltaShiftIndex : 1 tuple at least must be present in 'this' !");
10263   const int *ptr=getConstPointer();
10264   DataArrayInt *ret=DataArrayInt::New();
10265   ret->alloc(nbOfTuples-1,1);
10266   int *out=ret->getPointer();
10267   std::transform(ptr+1,ptr+nbOfTuples,ptr,out,std::minus<int>());
10268   return ret;
10269 }
10270
10271 /*!
10272  * Modifies \a this one-dimensional array so that value of each element \a x
10273  * of \a this array (\a a) is computed as \f$ x_i = \sum_{j=0}^{i-1} a[ j ] \f$.
10274  * Or: for each i>0 new[i]=new[i-1]+old[i-1] for i==0 new[i]=0. Number of tuples
10275  * and components remains the same.<br>
10276  * This method is useful for allToAllV in MPI with contiguous policy. This method
10277  * differs from computeOffsets2() in that the number of tuples is \b not changed by
10278  * this one.
10279  *  \throw If \a this is not allocated.
10280  *  \throw If \a this->getNumberOfComponents() != 1.
10281  *
10282  *  \b Example: <br>
10283  *          - Before \a this contains [3,5,1,2,0,8]
10284  *          - After \a this contains  [0,3,8,9,11,11]<br>
10285  *          Note that the last element 19 = 11 + 8 is missing because size of \a this
10286  *          array is retained and thus there is no space to store the last element.
10287  */
10288 void DataArrayInt::computeOffsets()
10289 {
10290   checkAllocated();
10291   if(getNumberOfComponents()!=1)
10292     throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsets : only single component allowed !");
10293   int nbOfTuples=getNumberOfTuples();
10294   if(nbOfTuples==0)
10295     return ;
10296   int *work=getPointer();
10297   int tmp=work[0];
10298   work[0]=0;
10299   for(int i=1;i<nbOfTuples;i++)
10300     {
10301       int tmp2=work[i];
10302       work[i]=work[i-1]+tmp;
10303       tmp=tmp2;
10304     }
10305   declareAsNew();
10306 }
10307
10308
10309 /*!
10310  * Modifies \a this one-dimensional array so that value of each element \a x
10311  * of \a this array (\a a) is computed as \f$ x_i = \sum_{j=0}^{i-1} a[ j ] \f$.
10312  * Or: for each i>0 new[i]=new[i-1]+old[i-1] for i==0 new[i]=0. Number
10313  * components remains the same and number of tuples is inceamented by one.<br>
10314  * This method is useful for allToAllV in MPI with contiguous policy. This method
10315  * differs from computeOffsets() in that the number of tuples is changed by this one.
10316  * This method preforms the reverse operation of DataArrayInt::deltaShiftIndex.
10317  *  \throw If \a this is not allocated.
10318  *  \throw If \a this->getNumberOfComponents() != 1.
10319  *
10320  *  \b Example: <br>
10321  *          - Before \a this contains [3,5,1,2,0,8]
10322  *          - After \a this contains  [0,3,8,9,11,11,19]<br>
10323  * \sa DataArrayInt::deltaShiftIndex
10324  */
10325 void DataArrayInt::computeOffsets2()
10326 {
10327   checkAllocated();
10328   if(getNumberOfComponents()!=1)
10329     throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsets2 : only single component allowed !");
10330   int nbOfTuples=getNumberOfTuples();
10331   int *ret=(int *)malloc((nbOfTuples+1)*sizeof(int));
10332   if(nbOfTuples==0)
10333     return ;
10334   const int *work=getConstPointer();
10335   ret[0]=0;
10336   for(int i=0;i<nbOfTuples;i++)
10337     ret[i+1]=work[i]+ret[i];
10338   useArray(ret,true,C_DEALLOC,nbOfTuples+1,1);
10339   declareAsNew();
10340 }
10341
10342 /*!
10343  * Returns two new DataArrayInt instances whose contents is computed from that of \a this and \a listOfIds arrays as follows.
10344  * \a this is expected to be an offset format ( as returned by DataArrayInt::computeOffsets2 ) that is to say with one component
10345  * and ** sorted strictly increasingly **. \a listOfIds is expected to be sorted ascendingly (not strictly needed for \a listOfIds).
10346  * This methods searches in \a this, considered as a set of contiguous \c this->getNumberOfComponents() ranges, all ids in \a listOfIds
10347  * filling completely one of the ranges in \a this.
10348  *
10349  * \param [in] listOfIds a list of ids that has to be sorted ascendingly.
10350  * \param [out] rangeIdsFetched the range ids fetched
10351  * \param [out] idsInInputListThatFetch contains the list of ids in \a listOfIds that are \b fully included in a range in \a this. So
10352  *              \a idsInInputListThatFetch is a part of input \a listOfIds.
10353  *
10354  * \sa DataArrayInt::computeOffsets2
10355  *
10356  *  \b Example: <br>
10357  *          - \a this : [0,3,7,9,15,18]
10358  *          - \a listOfIds contains  [0,1,2,3,7,8,15,16,17]
10359  *          - \a rangeIdsFetched result array: [0,2,4]
10360  *          - \a idsInInputListThatFetch result array: [0,1,2,7,8,15,16,17]
10361  * In this example id 3 in input \a listOfIds is alone so it do not appear in output \a idsInInputListThatFetch.
10362  * <br>
10363  */
10364 void DataArrayInt::searchRangesInListOfIds(const DataArrayInt *listOfIds, DataArrayInt *& rangeIdsFetched, DataArrayInt *& idsInInputListThatFetch) const
10365 {
10366   if(!listOfIds)
10367     throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : input list of ids is null !");
10368   listOfIds->checkAllocated(); checkAllocated();
10369   if(listOfIds->getNumberOfComponents()!=1)
10370     throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : input list of ids must have exactly one component !");
10371   if(getNumberOfComponents()!=1)
10372     throw INTERP_KERNEL::Exception("DataArrayInt::searchRangesInListOfIds : this must have exactly one component !");
10373   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret0=DataArrayInt::New(); ret0->alloc(0,1);
10374   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret1=DataArrayInt::New(); ret1->alloc(0,1);
10375   const int *tupEnd(listOfIds->end()),*offBg(begin()),*offEnd(end()-1);
10376   const int *tupPtr(listOfIds->begin()),*offPtr(offBg);
10377   while(tupPtr!=tupEnd && offPtr!=offEnd)
10378     {
10379       if(*tupPtr==*offPtr)
10380         {
10381           int i=offPtr[0];
10382           while(i<offPtr[1] && *tupPtr==i && tupPtr!=tupEnd) { i++; tupPtr++; }
10383           if(i==offPtr[1])
10384             {
10385               ret0->pushBackSilent((int)std::distance(offBg,offPtr));
10386               ret1->pushBackValsSilent(tupPtr-(offPtr[1]-offPtr[0]),tupPtr);
10387               offPtr++;
10388             }
10389         }
10390       else
10391         { if(*tupPtr<*offPtr) tupPtr++; else offPtr++; }
10392     }
10393   rangeIdsFetched=ret0.retn();
10394   idsInInputListThatFetch=ret1.retn();
10395 }
10396
10397 /*!
10398  * Returns a new DataArrayInt whose contents is computed from that of \a this and \a
10399  * offsets arrays as follows. \a offsets is a one-dimensional array considered as an
10400  * "index" array of a "iota" array, thus, whose each element gives an index of a group
10401  * beginning within the "iota" array. And \a this is a one-dimensional array
10402  * considered as a selector of groups described by \a offsets to include into the result array.
10403  *  \throw If \a offsets is NULL.
10404  *  \throw If \a offsets is not allocated.
10405  *  \throw If \a offsets->getNumberOfComponents() != 1.
10406  *  \throw If \a offsets is not monotonically increasing.
10407  *  \throw If \a this is not allocated.
10408  *  \throw If \a this->getNumberOfComponents() != 1.
10409  *  \throw If any element of \a this is not a valid index for \a offsets array.
10410  *
10411  *  \b Example: <br>
10412  *          - \a this: [0,2,3]
10413  *          - \a offsets: [0,3,6,10,14,20]
10414  *          - result array: [0,1,2,6,7,8,9,10,11,12,13] == <br>
10415  *            \c range(0,3) + \c range(6,10) + \c range(10,14) ==<br>
10416  *            \c range( \a offsets[ \a this[0] ], offsets[ \a this[0]+1 ]) +
10417  *            \c range( \a offsets[ \a this[1] ], offsets[ \a this[1]+1 ]) +
10418  *            \c range( \a offsets[ \a this[2] ], offsets[ \a this[2]+1 ])
10419  */
10420 DataArrayInt *DataArrayInt::buildExplicitArrByRanges(const DataArrayInt *offsets) const
10421 {
10422   if(!offsets)
10423     throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : DataArrayInt pointer in input is NULL !");
10424   checkAllocated();
10425   if(getNumberOfComponents()!=1)
10426     throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : only single component allowed !");
10427   offsets->checkAllocated();
10428   if(offsets->getNumberOfComponents()!=1)
10429     throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : input array should have only single component !");
10430   int othNbTuples=offsets->getNumberOfTuples()-1;
10431   int nbOfTuples=getNumberOfTuples();
10432   int retNbOftuples=0;
10433   const int *work=getConstPointer();
10434   const int *offPtr=offsets->getConstPointer();
10435   for(int i=0;i<nbOfTuples;i++)
10436     {
10437       int val=work[i];
10438       if(val>=0 && val<othNbTuples)
10439         {
10440           int delta=offPtr[val+1]-offPtr[val];
10441           if(delta>=0)
10442             retNbOftuples+=delta;
10443           else
10444             {
10445               std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrByRanges : Tuple #" << val << " of offset array has a delta < 0 !";
10446               throw INTERP_KERNEL::Exception(oss.str().c_str());
10447             }
10448         }
10449       else
10450         {
10451           std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrByRanges : Tuple #" << i << " in this contains " << val;
10452           oss << " whereas offsets array is of size " << othNbTuples+1 << " !";
10453           throw INTERP_KERNEL::Exception(oss.str().c_str());
10454         }
10455     }
10456   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10457   ret->alloc(retNbOftuples,1);
10458   int *retPtr=ret->getPointer();
10459   for(int i=0;i<nbOfTuples;i++)
10460     {
10461       int val=work[i];
10462       int start=offPtr[val];
10463       int off=offPtr[val+1]-start;
10464       for(int j=0;j<off;j++,retPtr++)
10465         *retPtr=start+j;
10466     }
10467   return ret.retn();
10468 }
10469
10470 /*!
10471  * Returns a new DataArrayInt whose contents is computed using \a this that must be a
10472  * scaled array (monotonically increasing).
10473 from that of \a this and \a
10474  * offsets arrays as follows. \a offsets is a one-dimensional array considered as an
10475  * "index" array of a "iota" array, thus, whose each element gives an index of a group
10476  * beginning within the "iota" array. And \a this is a one-dimensional array
10477  * considered as a selector of groups described by \a offsets to include into the result array.
10478  *  \throw If \a  is NULL.
10479  *  \throw If \a this is not allocated.
10480  *  \throw If \a this->getNumberOfComponents() != 1.
10481  *  \throw If \a this->getNumberOfTuples() == 0.
10482  *  \throw If \a this is not monotonically increasing.
10483  *  \throw If any element of ids in ( \a bg \a stop \a step ) points outside the scale in \a this.
10484  *
10485  *  \b Example: <br>
10486  *          - \a bg , \a stop and \a step : (0,5,2)
10487  *          - \a this: [0,3,6,10,14,20]
10488  *          - result array: [0,0,0, 2,2,2,2, 4,4,4,4,4,4] == <br>
10489  */
10490 DataArrayInt *DataArrayInt::buildExplicitArrOfSliceOnScaledArr(int bg, int stop, int step) const
10491 {
10492   if(!isAllocated())
10493     throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : not allocated array !");
10494   if(getNumberOfComponents()!=1)
10495     throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : number of components is expected to be equal to one !");
10496   int nbOfTuples(getNumberOfTuples());
10497   if(nbOfTuples==0)
10498     throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : number of tuples must be != 0 !");
10499   const int *ids(begin());
10500   int nbOfEltsInSlc(GetNumberOfItemGivenBESRelative(bg,stop,step,"DataArrayInt::buildExplicitArrOfSliceOnScaledArr")),sz(0),pos(bg);
10501   for(int i=0;i<nbOfEltsInSlc;i++,pos+=step)
10502     {
10503       if(pos>=0 && pos<nbOfTuples-1)
10504         {
10505           int delta(ids[pos+1]-ids[pos]);
10506           sz+=delta;
10507           if(delta<0)
10508             {
10509               std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrOfSliceOnScaledArr : At pos #" << i << " of input slice, value is " << pos << " and at this pos this is not monotonically increasing !";
10510               throw INTERP_KERNEL::Exception(oss.str().c_str());
10511             }
10512         }
10513       else
10514         {
10515           std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrOfSliceOnScaledArr : At pos #" << i << " of input slice, value is " << pos << " should be in [0," << nbOfTuples-1 << ") !";
10516           throw INTERP_KERNEL::Exception(oss.str().c_str());
10517         }
10518     }
10519   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
10520   int *retPtr(ret->getPointer());
10521   pos=bg;
10522   for(int i=0;i<nbOfEltsInSlc;i++,pos+=step)
10523     {
10524       int delta(ids[pos+1]-ids[pos]);
10525       for(int j=0;j<delta;j++,retPtr++)
10526         *retPtr=pos;
10527     }
10528   return ret.retn();
10529 }
10530
10531 /*!
10532  * Given in input ranges \a ranges, it returns a newly allocated DataArrayInt instance having one component and the same number of tuples than \a this.
10533  * For each tuple at place **i** in \a this it tells which is the first range in \a ranges that contains value \c this->getIJ(i,0) and put the result
10534  * in tuple **i** of returned DataArrayInt.
10535  * If ranges overlapped (in theory it should not) this method do not detect it and always returns the first range.
10536  *
10537  * For example if \a this contains : [1,24,7,8,10,17] and \a ranges contains [(0,3),(3,8),(8,15),(15,22),(22,30)]
10538  * The return DataArrayInt will contain : **[0,4,1,2,2,3]**
10539  *
10540  * \param [in] ranges typically come from output of MEDCouplingUMesh::ComputeRangesFromTypeDistribution. Each range is specified like this : 1st component is
10541  *             for lower value included and 2nd component is the upper value of corresponding range **excluded**.
10542  * \throw If offsets is a null pointer or does not have 2 components or if \a this is not allocated or \a this do not have exactly one component. To finish an exception
10543  *        is thrown if no ranges in \a ranges contains value in \a this.
10544  *
10545  * \sa DataArrayInt::findIdInRangeForEachTuple
10546  */
10547 DataArrayInt *DataArrayInt::findRangeIdForEachTuple(const DataArrayInt *ranges) const
10548 {
10549   if(!ranges)
10550     throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : null input pointer !");
10551   if(ranges->getNumberOfComponents()!=2)
10552     throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : input DataArrayInt instance should have 2 components !");
10553   checkAllocated();
10554   if(getNumberOfComponents()!=1)
10555     throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : this should have only one component !");
10556   int nbTuples=getNumberOfTuples();
10557   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTuples,1);
10558   int nbOfRanges=ranges->getNumberOfTuples();
10559   const int *rangesPtr=ranges->getConstPointer();
10560   int *retPtr=ret->getPointer();
10561   const int *inPtr=getConstPointer();
10562   for(int i=0;i<nbTuples;i++,retPtr++)
10563     {
10564       int val=inPtr[i];
10565       bool found=false;
10566       for(int j=0;j<nbOfRanges && !found;j++)
10567         if(val>=rangesPtr[2*j] && val<rangesPtr[2*j+1])
10568           { *retPtr=j; found=true; }
10569       if(found)
10570         continue;
10571       else
10572         {
10573           std::ostringstream oss; oss << "DataArrayInt::findRangeIdForEachTuple : tuple #" << i << " not found by any ranges !";
10574           throw INTERP_KERNEL::Exception(oss.str().c_str());
10575         }
10576     }
10577   return ret.retn();
10578 }
10579
10580 /*!
10581  * Given in input ranges \a ranges, it returns a newly allocated DataArrayInt instance having one component and the same number of tuples than \a this.
10582  * For each tuple at place **i** in \a this it tells which is the sub position of the first range in \a ranges that contains value \c this->getIJ(i,0) and put the result
10583  * in tuple **i** of returned DataArrayInt.
10584  * If ranges overlapped (in theory it should not) this method do not detect it and always returns the sub position of the first range.
10585  *
10586  * For example if \a this contains : [1,24,7,8,10,17] and \a ranges contains [(0,3),(3,8),(8,15),(15,22),(22,30)]
10587  * The return DataArrayInt will contain : **[1,2,4,0,2,2]**
10588  * This method is often called in pair with DataArrayInt::findRangeIdForEachTuple method.
10589  *
10590  * \param [in] ranges typically come from output of MEDCouplingUMesh::ComputeRangesFromTypeDistribution. Each range is specified like this : 1st component is
10591  *             for lower value included and 2nd component is the upper value of corresponding range **excluded**.
10592  * \throw If offsets is a null pointer or does not have 2 components or if \a this is not allocated or \a this do not have exactly one component. To finish an exception
10593  *        is thrown if no ranges in \a ranges contains value in \a this.
10594  * \sa DataArrayInt::findRangeIdForEachTuple
10595  */
10596 DataArrayInt *DataArrayInt::findIdInRangeForEachTuple(const DataArrayInt *ranges) const
10597 {
10598   if(!ranges)
10599     throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : null input pointer !");
10600   if(ranges->getNumberOfComponents()!=2)
10601     throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : input DataArrayInt instance should have 2 components !");
10602   checkAllocated();
10603   if(getNumberOfComponents()!=1)
10604     throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : this should have only one component !");
10605   int nbTuples=getNumberOfTuples();
10606   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTuples,1);
10607   int nbOfRanges=ranges->getNumberOfTuples();
10608   const int *rangesPtr=ranges->getConstPointer();
10609   int *retPtr=ret->getPointer();
10610   const int *inPtr=getConstPointer();
10611   for(int i=0;i<nbTuples;i++,retPtr++)
10612     {
10613       int val=inPtr[i];
10614       bool found=false;
10615       for(int j=0;j<nbOfRanges && !found;j++)
10616         if(val>=rangesPtr[2*j] && val<rangesPtr[2*j+1])
10617           { *retPtr=val-rangesPtr[2*j]; found=true; }
10618       if(found)
10619         continue;
10620       else
10621         {
10622           std::ostringstream oss; oss << "DataArrayInt::findIdInRangeForEachTuple : tuple #" << i << " not found by any ranges !";
10623           throw INTERP_KERNEL::Exception(oss.str().c_str());
10624         }
10625     }
10626   return ret.retn();
10627 }
10628
10629 /*!
10630  * \b WARNING this method is a \b non \a const \b method. This method works tuple by tuple. Each tuple is expected to be pairs (number of components must be equal to 2).
10631  * This method rearrange each pair in \a this so that, tuple with id \b tid will be after the call \c this->getIJ(tid,0)==this->getIJ(tid-1,1) and \c this->getIJ(tid,1)==this->getIJ(tid+1,0).
10632  * If it is impossible to reach such condition an exception will be thrown ! \b WARNING In case of throw \a this can be partially modified !
10633  * If this method has correctly worked, \a this will be able to be considered as a linked list.
10634  * This method does nothing if number of tuples is lower of equal to 1.
10635  *
10636  * This method is useful for users having an unstructured mesh having only SEG2 to rearrange internaly the connectibity without any coordinates consideration.
10637  *
10638  * \sa MEDCouplingUMesh::orderConsecutiveCells1D
10639  */
10640 void DataArrayInt::sortEachPairToMakeALinkedList()
10641 {
10642   checkAllocated();
10643   if(getNumberOfComponents()!=2)
10644     throw INTERP_KERNEL::Exception("DataArrayInt::sortEachPairToMakeALinkedList : Only works on DataArrayInt instance with nb of components equal to 2 !");
10645   int nbOfTuples(getNumberOfTuples());
10646   if(nbOfTuples<=1)
10647     return ;
10648   int *conn(getPointer());
10649   for(int i=1;i<nbOfTuples;i++,conn+=2)
10650     {
10651       if(i>1)
10652         {
10653           if(conn[2]==conn[3])
10654             {
10655               std::ostringstream oss; oss << "DataArrayInt::sortEachPairToMakeALinkedList : In the tuple #" << i << " presence of a pair filled with same ids !";
10656               throw INTERP_KERNEL::Exception(oss.str().c_str());
10657             }
10658           if(conn[2]!=conn[1] && conn[3]==conn[1] && conn[2]!=conn[0])
10659             std::swap(conn[2],conn[3]);
10660           //not(conn[2]==conn[1] && conn[3]!=conn[1] && conn[3]!=conn[0])
10661           if(conn[2]!=conn[1] || conn[3]==conn[1] || conn[3]==conn[0])
10662             {
10663               std::ostringstream oss; oss << "DataArrayInt::sortEachPairToMakeALinkedList : In the tuple #" << i << " something is invalid !";
10664               throw INTERP_KERNEL::Exception(oss.str().c_str());
10665             }
10666         }
10667       else
10668         {
10669           if(conn[0]==conn[1] || conn[2]==conn[3])
10670             throw INTERP_KERNEL::Exception("DataArrayInt::sortEachPairToMakeALinkedList : In the 2 first tuples presence of a pair filled with same ids !");
10671           int tmp[4];
10672           std::set<int> s;
10673           s.insert(conn,conn+4);
10674           if(s.size()!=3)
10675             throw INTERP_KERNEL::Exception("DataArrayInt::sortEachPairToMakeALinkedList : This can't be considered as a linked list regarding 2 first tuples !");
10676           if(std::count(conn,conn+4,conn[0])==2)
10677             {
10678               tmp[0]=conn[1];
10679               tmp[1]=conn[0];
10680               tmp[2]=conn[0];
10681               if(conn[2]==conn[0])
10682                 { tmp[3]=conn[3]; }
10683               else
10684                 { tmp[3]=conn[2];}
10685               std::copy(tmp,tmp+4,conn);
10686             }
10687         }
10688     }
10689 }
10690
10691 /*!
10692  *
10693  * \param [in] nbTimes specifies the nb of times each tuples in \a this will be duplicated contiguouly in returned DataArrayInt instance.
10694  *             \a nbTimes  should be at least equal to 1.
10695  * \return a newly allocated DataArrayInt having one component and number of tuples equal to \a nbTimes * \c this->getNumberOfTuples.
10696  * \throw if \a this is not allocated or if \a this has not number of components set to one or if \a nbTimes is lower than 1.
10697  */
10698 DataArrayInt *DataArrayInt::duplicateEachTupleNTimes(int nbTimes) const
10699 {
10700   checkAllocated();
10701   if(getNumberOfComponents()!=1)
10702     throw INTERP_KERNEL::Exception("DataArrayInt::duplicateEachTupleNTimes : this should have only one component !");
10703   if(nbTimes<1)
10704     throw INTERP_KERNEL::Exception("DataArrayInt::duplicateEachTupleNTimes : nb times should be >= 1 !");
10705   int nbTuples=getNumberOfTuples();
10706   const int *inPtr=getConstPointer();
10707   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTimes*nbTuples,1);
10708   int *retPtr=ret->getPointer();
10709   for(int i=0;i<nbTuples;i++,inPtr++)
10710     {
10711       int val=*inPtr;
10712       for(int j=0;j<nbTimes;j++,retPtr++)
10713         *retPtr=val;
10714     }
10715   ret->copyStringInfoFrom(*this);
10716   return ret.retn();
10717 }
10718
10719 /*!
10720  * This method returns all different values found in \a this. This method throws if \a this has not been allocated.
10721  * But the number of components can be different from one.
10722  * \return a newly allocated array (that should be dealt by the caller) containing different values in \a this.
10723  */
10724 DataArrayInt *DataArrayInt::getDifferentValues() const
10725 {
10726   checkAllocated();
10727   std::set<int> ret;
10728   ret.insert(begin(),end());
10729   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret2=DataArrayInt::New(); ret2->alloc((int)ret.size(),1);
10730   std::copy(ret.begin(),ret.end(),ret2->getPointer());
10731   return ret2.retn();
10732 }
10733
10734 /*!
10735  * This method is a refinement of DataArrayInt::getDifferentValues because it returns not only different values in \a this but also, for each of
10736  * them it tells which tuple id have this id.
10737  * This method works only on arrays with one component (if it is not the case call DataArrayInt::rearrange(1) ).
10738  * This method returns two arrays having same size.
10739  * The instances of DataArrayInt in the returned vector have be specially allocated and computed by this method. Each of them should be dealt by the caller of this method.
10740  * Example : if this is equal to [1,0,1,2,0,2,2,-3,2] -> differentIds=[-3,0,1,2] and returned array will be equal to [[7],[1,4],[0,2],[3,5,6,8]]
10741  */
10742 std::vector<DataArrayInt *> DataArrayInt::partitionByDifferentValues(std::vector<int>& differentIds) const
10743 {
10744   checkAllocated();
10745   if(getNumberOfComponents()!=1)
10746     throw INTERP_KERNEL::Exception("DataArrayInt::partitionByDifferentValues : this should have only one component !");
10747   int id=0;
10748   std::map<int,int> m,m2,m3;
10749   for(const int *w=begin();w!=end();w++)
10750     m[*w]++;
10751   differentIds.resize(m.size());
10752   std::vector<DataArrayInt *> ret(m.size());
10753   std::vector<int *> retPtr(m.size());
10754   for(std::map<int,int>::const_iterator it=m.begin();it!=m.end();it++,id++)
10755     {
10756       m2[(*it).first]=id;
10757       ret[id]=DataArrayInt::New();
10758       ret[id]->alloc((*it).second,1);
10759       retPtr[id]=ret[id]->getPointer();
10760       differentIds[id]=(*it).first;
10761     }
10762   id=0;
10763   for(const int *w=begin();w!=end();w++,id++)
10764     {
10765       retPtr[m2[*w]][m3[*w]++]=id;
10766     }
10767   return ret;
10768 }
10769
10770 /*!
10771  * This method split ids in [0, \c this->getNumberOfTuples() ) using \a this array as a field of weight (>=0 each).
10772  * The aim of this method is to return a set of \a nbOfSlices chunk of contiguous ids as balanced as possible.
10773  *
10774  * \param [in] nbOfSlices - number of slices expected.
10775  * \return - a vector having a size equal to \a nbOfSlices giving the start (included) and the stop (excluded) of each chunks.
10776  *
10777  * \sa DataArray::GetSlice
10778  * \throw If \a this is not allocated or not with exactly one component.
10779  * \throw If an element in \a this if < 0.
10780  */
10781 std::vector< std::pair<int,int> > DataArrayInt::splitInBalancedSlices(int nbOfSlices) const
10782 {
10783   if(!isAllocated() || getNumberOfComponents()!=1)
10784     throw INTERP_KERNEL::Exception("DataArrayInt::splitInBalancedSlices : this array should have number of components equal to one and must be allocated !");
10785   if(nbOfSlices<=0)
10786     throw INTERP_KERNEL::Exception("DataArrayInt::splitInBalancedSlices : number of slices must be >= 1 !");
10787   int sum(accumulate(0)),nbOfTuples(getNumberOfTuples());
10788   int sumPerSlc(sum/nbOfSlices),pos(0);
10789   const int *w(begin());
10790   std::vector< std::pair<int,int> > ret(nbOfSlices);
10791   for(int i=0;i<nbOfSlices;i++)
10792     {
10793       std::pair<int,int> p(pos,-1);
10794       int locSum(0);
10795       while(locSum<sumPerSlc && pos<nbOfTuples) { pos++; locSum+=*w++; }
10796       if(i!=nbOfSlices-1)
10797         p.second=pos;
10798       else
10799         p.second=nbOfTuples;
10800       ret[i]=p;
10801     }
10802   return ret;
10803 }
10804
10805 /*!
10806  * Returns a new DataArrayInt that is a sum of two given arrays. There are 3
10807  * valid cases.
10808  * 1.  The arrays have same number of tuples and components. Then each value of
10809  *   the result array (_a_) is a sum of the corresponding values of \a a1 and \a a2,
10810  *   i.e.: _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, j ].
10811  * 2.  The arrays have same number of tuples and one array, say _a2_, has one
10812  *   component. Then
10813  *   _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ i, 0 ].
10814  * 3.  The arrays have same number of components and one array, say _a2_, has one
10815  *   tuple. Then
10816  *   _a_ [ i, j ] = _a1_ [ i, j ] + _a2_ [ 0, j ].
10817  *
10818  * Info on components is copied either from the first array (in the first case) or from
10819  * the array with maximal number of elements (getNbOfElems()).
10820  *  \param [in] a1 - an array to sum up.
10821  *  \param [in] a2 - another array to sum up.
10822  *  \return DataArrayInt * - the new instance of DataArrayInt.
10823  *          The caller is to delete this result array using decrRef() as it is no more
10824  *          needed.
10825  *  \throw If either \a a1 or \a a2 is NULL.
10826  *  \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
10827  *         \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
10828  *         none of them has number of tuples or components equal to 1.
10829  */
10830 DataArrayInt *DataArrayInt::Add(const DataArrayInt *a1, const DataArrayInt *a2)
10831 {
10832   if(!a1 || !a2)
10833     throw INTERP_KERNEL::Exception("DataArrayInt::Add : input DataArrayInt instance is NULL !");
10834   int nbOfTuple=a1->getNumberOfTuples();
10835   int nbOfTuple2=a2->getNumberOfTuples();
10836   int nbOfComp=a1->getNumberOfComponents();
10837   int nbOfComp2=a2->getNumberOfComponents();
10838   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=0;
10839   if(nbOfTuple==nbOfTuple2)
10840     {
10841       if(nbOfComp==nbOfComp2)
10842         {
10843           ret=DataArrayInt::New();
10844           ret->alloc(nbOfTuple,nbOfComp);
10845           std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::plus<int>());
10846           ret->copyStringInfoFrom(*a1);
10847         }
10848       else
10849         {
10850           int nbOfCompMin,nbOfCompMax;
10851           const DataArrayInt *aMin, *aMax;
10852           if(nbOfComp>nbOfComp2)
10853             {
10854               nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
10855               aMin=a2; aMax=a1;
10856             }
10857           else
10858             {
10859               nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
10860               aMin=a1; aMax=a2;
10861             }
10862           if(nbOfCompMin==1)
10863             {
10864               ret=DataArrayInt::New();
10865               ret->alloc(nbOfTuple,nbOfCompMax);
10866               const int *aMinPtr=aMin->getConstPointer();
10867               const int *aMaxPtr=aMax->getConstPointer();
10868               int *res=ret->getPointer();
10869               for(int i=0;i<nbOfTuple;i++)
10870                 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::plus<int>(),aMinPtr[i]));
10871               ret->copyStringInfoFrom(*aMax);
10872             }
10873           else
10874             throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
10875         }
10876     }
10877   else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
10878     {
10879       if(nbOfComp==nbOfComp2)
10880         {
10881           int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
10882           const DataArrayInt *aMin=nbOfTuple>nbOfTuple2?a2:a1;
10883           const DataArrayInt *aMax=nbOfTuple>nbOfTuple2?a1:a2;
10884           const int *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
10885           ret=DataArrayInt::New();
10886           ret->alloc(nbOfTupleMax,nbOfComp);
10887           int *res=ret->getPointer();
10888           for(int i=0;i<nbOfTupleMax;i++)
10889             res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::plus<int>());
10890           ret->copyStringInfoFrom(*aMax);
10891         }
10892       else
10893         throw INTERP_KERNEL::Exception("Nb of components mismatch for array Add !");
10894     }
10895   else
10896     throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Add !");
10897   return ret.retn();
10898 }
10899
10900 /*!
10901  * Adds values of another DataArrayInt to values of \a this one. There are 3
10902  * valid cases.
10903  * 1.  The arrays have same number of tuples and components. Then each value of
10904  *   \a other array is added to the corresponding value of \a this array, i.e.:
10905  *   _a_ [ i, j ] += _other_ [ i, j ].
10906  * 2.  The arrays have same number of tuples and \a other array has one component. Then
10907  *   _a_ [ i, j ] += _other_ [ i, 0 ].
10908  * 3.  The arrays have same number of components and \a other array has one tuple. Then
10909  *   _a_ [ i, j ] += _a2_ [ 0, j ].
10910  *
10911  *  \param [in] other - an array to add to \a this one.
10912  *  \throw If \a other is NULL.
10913  *  \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
10914  *         \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
10915  *         \a other has number of both tuples and components not equal to 1.
10916  */
10917 void DataArrayInt::addEqual(const DataArrayInt *other)
10918 {
10919   if(!other)
10920     throw INTERP_KERNEL::Exception("DataArrayInt::addEqual : input DataArrayInt instance is NULL !");
10921   const char *msg="Nb of tuples mismatch for DataArrayInt::addEqual  !";
10922   checkAllocated(); other->checkAllocated();
10923   int nbOfTuple=getNumberOfTuples();
10924   int nbOfTuple2=other->getNumberOfTuples();
10925   int nbOfComp=getNumberOfComponents();
10926   int nbOfComp2=other->getNumberOfComponents();
10927   if(nbOfTuple==nbOfTuple2)
10928     {
10929       if(nbOfComp==nbOfComp2)
10930         {
10931           std::transform(begin(),end(),other->begin(),getPointer(),std::plus<int>());
10932         }
10933       else if(nbOfComp2==1)
10934         {
10935           int *ptr=getPointer();
10936           const int *ptrc=other->getConstPointer();
10937           for(int i=0;i<nbOfTuple;i++)
10938             std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::plus<int>(),*ptrc++));
10939         }
10940       else
10941         throw INTERP_KERNEL::Exception(msg);
10942     }
10943   else if(nbOfTuple2==1)
10944     {
10945       if(nbOfComp2==nbOfComp)
10946         {
10947           int *ptr=getPointer();
10948           const int *ptrc=other->getConstPointer();
10949           for(int i=0;i<nbOfTuple;i++)
10950             std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::plus<int>());
10951         }
10952       else
10953         throw INTERP_KERNEL::Exception(msg);
10954     }
10955   else
10956     throw INTERP_KERNEL::Exception(msg);
10957   declareAsNew();
10958 }
10959
10960 /*!
10961  * Returns a new DataArrayInt that is a subtraction of two given arrays. There are 3
10962  * valid cases.
10963  * 1.  The arrays have same number of tuples and components. Then each value of
10964  *   the result array (_a_) is a subtraction of the corresponding values of \a a1 and
10965  *   \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, j ].
10966  * 2.  The arrays have same number of tuples and one array, say _a2_, has one
10967  *   component. Then
10968  *   _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ i, 0 ].
10969  * 3.  The arrays have same number of components and one array, say _a2_, has one
10970  *   tuple. Then
10971  *   _a_ [ i, j ] = _a1_ [ i, j ] - _a2_ [ 0, j ].
10972  *
10973  * Info on components is copied either from the first array (in the first case) or from
10974  * the array with maximal number of elements (getNbOfElems()).
10975  *  \param [in] a1 - an array to subtract from.
10976  *  \param [in] a2 - an array to subtract.
10977  *  \return DataArrayInt * - the new instance of DataArrayInt.
10978  *          The caller is to delete this result array using decrRef() as it is no more
10979  *          needed.
10980  *  \throw If either \a a1 or \a a2 is NULL.
10981  *  \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
10982  *         \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
10983  *         none of them has number of tuples or components equal to 1.
10984  */
10985 DataArrayInt *DataArrayInt::Substract(const DataArrayInt *a1, const DataArrayInt *a2)
10986 {
10987   if(!a1 || !a2)
10988     throw INTERP_KERNEL::Exception("DataArrayInt::Substract : input DataArrayInt instance is NULL !");
10989   int nbOfTuple1=a1->getNumberOfTuples();
10990   int nbOfTuple2=a2->getNumberOfTuples();
10991   int nbOfComp1=a1->getNumberOfComponents();
10992   int nbOfComp2=a2->getNumberOfComponents();
10993   if(nbOfTuple2==nbOfTuple1)
10994     {
10995       if(nbOfComp1==nbOfComp2)
10996         {
10997           MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
10998           ret->alloc(nbOfTuple2,nbOfComp1);
10999           std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::minus<int>());
11000           ret->copyStringInfoFrom(*a1);
11001           return ret.retn();
11002         }
11003       else if(nbOfComp2==1)
11004         {
11005           MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11006           ret->alloc(nbOfTuple1,nbOfComp1);
11007           const int *a2Ptr=a2->getConstPointer();
11008           const int *a1Ptr=a1->getConstPointer();
11009           int *res=ret->getPointer();
11010           for(int i=0;i<nbOfTuple1;i++)
11011             res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::minus<int>(),a2Ptr[i]));
11012           ret->copyStringInfoFrom(*a1);
11013           return ret.retn();
11014         }
11015       else
11016         {
11017           a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
11018           return 0;
11019         }
11020     }
11021   else if(nbOfTuple2==1)
11022     {
11023       a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Substract !");
11024       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11025       ret->alloc(nbOfTuple1,nbOfComp1);
11026       const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
11027       int *pt=ret->getPointer();
11028       for(int i=0;i<nbOfTuple1;i++)
11029         pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::minus<int>());
11030       ret->copyStringInfoFrom(*a1);
11031       return ret.retn();
11032     }
11033   else
11034     {
11035       a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Substract !");//will always throw an exception
11036       return 0;
11037     }
11038 }
11039
11040 /*!
11041  * Subtract values of another DataArrayInt from values of \a this one. There are 3
11042  * valid cases.
11043  * 1.  The arrays have same number of tuples and components. Then each value of
11044  *   \a other array is subtracted from the corresponding value of \a this array, i.e.:
11045  *   _a_ [ i, j ] -= _other_ [ i, j ].
11046  * 2.  The arrays have same number of tuples and \a other array has one component. Then
11047  *   _a_ [ i, j ] -= _other_ [ i, 0 ].
11048  * 3.  The arrays have same number of components and \a other array has one tuple. Then
11049  *   _a_ [ i, j ] -= _a2_ [ 0, j ].
11050  *
11051  *  \param [in] other - an array to subtract from \a this one.
11052  *  \throw If \a other is NULL.
11053  *  \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
11054  *         \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
11055  *         \a other has number of both tuples and components not equal to 1.
11056  */
11057 void DataArrayInt::substractEqual(const DataArrayInt *other)
11058 {
11059   if(!other)
11060     throw INTERP_KERNEL::Exception("DataArrayInt::substractEqual : input DataArrayInt instance is NULL !");
11061   const char *msg="Nb of tuples mismatch for DataArrayInt::substractEqual  !";
11062   checkAllocated(); other->checkAllocated();
11063   int nbOfTuple=getNumberOfTuples();
11064   int nbOfTuple2=other->getNumberOfTuples();
11065   int nbOfComp=getNumberOfComponents();
11066   int nbOfComp2=other->getNumberOfComponents();
11067   if(nbOfTuple==nbOfTuple2)
11068     {
11069       if(nbOfComp==nbOfComp2)
11070         {
11071           std::transform(begin(),end(),other->begin(),getPointer(),std::minus<int>());
11072         }
11073       else if(nbOfComp2==1)
11074         {
11075           int *ptr=getPointer();
11076           const int *ptrc=other->getConstPointer();
11077           for(int i=0;i<nbOfTuple;i++)
11078             std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::minus<int>(),*ptrc++));
11079         }
11080       else
11081         throw INTERP_KERNEL::Exception(msg);
11082     }
11083   else if(nbOfTuple2==1)
11084     {
11085       int *ptr=getPointer();
11086       const int *ptrc=other->getConstPointer();
11087       for(int i=0;i<nbOfTuple;i++)
11088         std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::minus<int>());
11089     }
11090   else
11091     throw INTERP_KERNEL::Exception(msg);
11092   declareAsNew();
11093 }
11094
11095 /*!
11096  * Returns a new DataArrayInt that is a product of two given arrays. There are 3
11097  * valid cases.
11098  * 1.  The arrays have same number of tuples and components. Then each value of
11099  *   the result array (_a_) is a product of the corresponding values of \a a1 and
11100  *   \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, j ].
11101  * 2.  The arrays have same number of tuples and one array, say _a2_, has one
11102  *   component. Then
11103  *   _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ i, 0 ].
11104  * 3.  The arrays have same number of components and one array, say _a2_, has one
11105  *   tuple. Then
11106  *   _a_ [ i, j ] = _a1_ [ i, j ] * _a2_ [ 0, j ].
11107  *
11108  * Info on components is copied either from the first array (in the first case) or from
11109  * the array with maximal number of elements (getNbOfElems()).
11110  *  \param [in] a1 - a factor array.
11111  *  \param [in] a2 - another factor array.
11112  *  \return DataArrayInt * - the new instance of DataArrayInt.
11113  *          The caller is to delete this result array using decrRef() as it is no more
11114  *          needed.
11115  *  \throw If either \a a1 or \a a2 is NULL.
11116  *  \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
11117  *         \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
11118  *         none of them has number of tuples or components equal to 1.
11119  */
11120 DataArrayInt *DataArrayInt::Multiply(const DataArrayInt *a1, const DataArrayInt *a2)
11121 {
11122   if(!a1 || !a2)
11123     throw INTERP_KERNEL::Exception("DataArrayInt::Multiply : input DataArrayInt instance is NULL !");
11124   int nbOfTuple=a1->getNumberOfTuples();
11125   int nbOfTuple2=a2->getNumberOfTuples();
11126   int nbOfComp=a1->getNumberOfComponents();
11127   int nbOfComp2=a2->getNumberOfComponents();
11128   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=0;
11129   if(nbOfTuple==nbOfTuple2)
11130     {
11131       if(nbOfComp==nbOfComp2)
11132         {
11133           ret=DataArrayInt::New();
11134           ret->alloc(nbOfTuple,nbOfComp);
11135           std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::multiplies<int>());
11136           ret->copyStringInfoFrom(*a1);
11137         }
11138       else
11139         {
11140           int nbOfCompMin,nbOfCompMax;
11141           const DataArrayInt *aMin, *aMax;
11142           if(nbOfComp>nbOfComp2)
11143             {
11144               nbOfCompMin=nbOfComp2; nbOfCompMax=nbOfComp;
11145               aMin=a2; aMax=a1;
11146             }
11147           else
11148             {
11149               nbOfCompMin=nbOfComp; nbOfCompMax=nbOfComp2;
11150               aMin=a1; aMax=a2;
11151             }
11152           if(nbOfCompMin==1)
11153             {
11154               ret=DataArrayInt::New();
11155               ret->alloc(nbOfTuple,nbOfCompMax);
11156               const int *aMinPtr=aMin->getConstPointer();
11157               const int *aMaxPtr=aMax->getConstPointer();
11158               int *res=ret->getPointer();
11159               for(int i=0;i<nbOfTuple;i++)
11160                 res=std::transform(aMaxPtr+i*nbOfCompMax,aMaxPtr+(i+1)*nbOfCompMax,res,std::bind2nd(std::multiplies<int>(),aMinPtr[i]));
11161               ret->copyStringInfoFrom(*aMax);
11162             }
11163           else
11164             throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
11165         }
11166     }
11167   else if((nbOfTuple==1 && nbOfTuple2>1) || (nbOfTuple>1 && nbOfTuple2==1))
11168     {
11169       if(nbOfComp==nbOfComp2)
11170         {
11171           int nbOfTupleMax=std::max(nbOfTuple,nbOfTuple2);
11172           const DataArrayInt *aMin=nbOfTuple>nbOfTuple2?a2:a1;
11173           const DataArrayInt *aMax=nbOfTuple>nbOfTuple2?a1:a2;
11174           const int *aMinPtr=aMin->getConstPointer(),*aMaxPtr=aMax->getConstPointer();
11175           ret=DataArrayInt::New();
11176           ret->alloc(nbOfTupleMax,nbOfComp);
11177           int *res=ret->getPointer();
11178           for(int i=0;i<nbOfTupleMax;i++)
11179             res=std::transform(aMaxPtr+i*nbOfComp,aMaxPtr+(i+1)*nbOfComp,aMinPtr,res,std::multiplies<int>());
11180           ret->copyStringInfoFrom(*aMax);
11181         }
11182       else
11183         throw INTERP_KERNEL::Exception("Nb of components mismatch for array Multiply !");
11184     }
11185   else
11186     throw INTERP_KERNEL::Exception("Nb of tuples mismatch for array Multiply !");
11187   return ret.retn();
11188 }
11189
11190
11191 /*!
11192  * Multiply values of another DataArrayInt to values of \a this one. There are 3
11193  * valid cases.
11194  * 1.  The arrays have same number of tuples and components. Then each value of
11195  *   \a other array is multiplied to the corresponding value of \a this array, i.e.:
11196  *   _a_ [ i, j ] *= _other_ [ i, j ].
11197  * 2.  The arrays have same number of tuples and \a other array has one component. Then
11198  *   _a_ [ i, j ] *= _other_ [ i, 0 ].
11199  * 3.  The arrays have same number of components and \a other array has one tuple. Then
11200  *   _a_ [ i, j ] *= _a2_ [ 0, j ].
11201  *
11202  *  \param [in] other - an array to multiply to \a this one.
11203  *  \throw If \a other is NULL.
11204  *  \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
11205  *         \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
11206  *         \a other has number of both tuples and components not equal to 1.
11207  */
11208 void DataArrayInt::multiplyEqual(const DataArrayInt *other)
11209 {
11210   if(!other)
11211     throw INTERP_KERNEL::Exception("DataArrayInt::multiplyEqual : input DataArrayInt instance is NULL !");
11212   const char *msg="Nb of tuples mismatch for DataArrayInt::multiplyEqual !";
11213   checkAllocated(); other->checkAllocated();
11214   int nbOfTuple=getNumberOfTuples();
11215   int nbOfTuple2=other->getNumberOfTuples();
11216   int nbOfComp=getNumberOfComponents();
11217   int nbOfComp2=other->getNumberOfComponents();
11218   if(nbOfTuple==nbOfTuple2)
11219     {
11220       if(nbOfComp==nbOfComp2)
11221         {
11222           std::transform(begin(),end(),other->begin(),getPointer(),std::multiplies<int>());
11223         }
11224       else if(nbOfComp2==1)
11225         {
11226           int *ptr=getPointer();
11227           const int *ptrc=other->getConstPointer();
11228           for(int i=0;i<nbOfTuple;i++)
11229             std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::multiplies<int>(),*ptrc++));
11230         }
11231       else
11232         throw INTERP_KERNEL::Exception(msg);
11233     }
11234   else if(nbOfTuple2==1)
11235     {
11236       if(nbOfComp2==nbOfComp)
11237         {
11238           int *ptr=getPointer();
11239           const int *ptrc=other->getConstPointer();
11240           for(int i=0;i<nbOfTuple;i++)
11241             std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::multiplies<int>());
11242         }
11243       else
11244         throw INTERP_KERNEL::Exception(msg);
11245     }
11246   else
11247     throw INTERP_KERNEL::Exception(msg);
11248   declareAsNew();
11249 }
11250
11251
11252 /*!
11253  * Returns a new DataArrayInt that is a division of two given arrays. There are 3
11254  * valid cases.
11255  * 1.  The arrays have same number of tuples and components. Then each value of
11256  *   the result array (_a_) is a division of the corresponding values of \a a1 and
11257  *   \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, j ].
11258  * 2.  The arrays have same number of tuples and one array, say _a2_, has one
11259  *   component. Then
11260  *   _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ i, 0 ].
11261  * 3.  The arrays have same number of components and one array, say _a2_, has one
11262  *   tuple. Then
11263  *   _a_ [ i, j ] = _a1_ [ i, j ] / _a2_ [ 0, j ].
11264  *
11265  * Info on components is copied either from the first array (in the first case) or from
11266  * the array with maximal number of elements (getNbOfElems()).
11267  *  \warning No check of division by zero is performed!
11268  *  \param [in] a1 - a numerator array.
11269  *  \param [in] a2 - a denominator array.
11270  *  \return DataArrayInt * - the new instance of DataArrayInt.
11271  *          The caller is to delete this result array using decrRef() as it is no more
11272  *          needed.
11273  *  \throw If either \a a1 or \a a2 is NULL.
11274  *  \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
11275  *         \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
11276  *         none of them has number of tuples or components equal to 1.
11277  */
11278 DataArrayInt *DataArrayInt::Divide(const DataArrayInt *a1, const DataArrayInt *a2)
11279 {
11280   if(!a1 || !a2)
11281     throw INTERP_KERNEL::Exception("DataArrayInt::Divide : input DataArrayInt instance is NULL !");
11282   int nbOfTuple1=a1->getNumberOfTuples();
11283   int nbOfTuple2=a2->getNumberOfTuples();
11284   int nbOfComp1=a1->getNumberOfComponents();
11285   int nbOfComp2=a2->getNumberOfComponents();
11286   if(nbOfTuple2==nbOfTuple1)
11287     {
11288       if(nbOfComp1==nbOfComp2)
11289         {
11290           MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11291           ret->alloc(nbOfTuple2,nbOfComp1);
11292           std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::divides<int>());
11293           ret->copyStringInfoFrom(*a1);
11294           return ret.retn();
11295         }
11296       else if(nbOfComp2==1)
11297         {
11298           MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11299           ret->alloc(nbOfTuple1,nbOfComp1);
11300           const int *a2Ptr=a2->getConstPointer();
11301           const int *a1Ptr=a1->getConstPointer();
11302           int *res=ret->getPointer();
11303           for(int i=0;i<nbOfTuple1;i++)
11304             res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::divides<int>(),a2Ptr[i]));
11305           ret->copyStringInfoFrom(*a1);
11306           return ret.retn();
11307         }
11308       else
11309         {
11310           a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
11311           return 0;
11312         }
11313     }
11314   else if(nbOfTuple2==1)
11315     {
11316       a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Divide !");
11317       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11318       ret->alloc(nbOfTuple1,nbOfComp1);
11319       const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
11320       int *pt=ret->getPointer();
11321       for(int i=0;i<nbOfTuple1;i++)
11322         pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::divides<int>());
11323       ret->copyStringInfoFrom(*a1);
11324       return ret.retn();
11325     }
11326   else
11327     {
11328       a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Divide !");//will always throw an exception
11329       return 0;
11330     }
11331 }
11332
11333 /*!
11334  * Divide values of \a this array by values of another DataArrayInt. There are 3
11335  * valid cases.
11336  * 1.  The arrays have same number of tuples and components. Then each value of
11337  *    \a this array is divided by the corresponding value of \a other one, i.e.:
11338  *   _a_ [ i, j ] /= _other_ [ i, j ].
11339  * 2.  The arrays have same number of tuples and \a other array has one component. Then
11340  *   _a_ [ i, j ] /= _other_ [ i, 0 ].
11341  * 3.  The arrays have same number of components and \a other array has one tuple. Then
11342  *   _a_ [ i, j ] /= _a2_ [ 0, j ].
11343  *
11344  *  \warning No check of division by zero is performed!
11345  *  \param [in] other - an array to divide \a this one by.
11346  *  \throw If \a other is NULL.
11347  *  \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
11348  *         \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
11349  *         \a other has number of both tuples and components not equal to 1.
11350  */
11351 void DataArrayInt::divideEqual(const DataArrayInt *other)
11352 {
11353   if(!other)
11354     throw INTERP_KERNEL::Exception("DataArrayInt::divideEqual : input DataArrayInt instance is NULL !");
11355   const char *msg="Nb of tuples mismatch for DataArrayInt::divideEqual !";
11356   checkAllocated(); other->checkAllocated();
11357   int nbOfTuple=getNumberOfTuples();
11358   int nbOfTuple2=other->getNumberOfTuples();
11359   int nbOfComp=getNumberOfComponents();
11360   int nbOfComp2=other->getNumberOfComponents();
11361   if(nbOfTuple==nbOfTuple2)
11362     {
11363       if(nbOfComp==nbOfComp2)
11364         {
11365           std::transform(begin(),end(),other->begin(),getPointer(),std::divides<int>());
11366         }
11367       else if(nbOfComp2==1)
11368         {
11369           int *ptr=getPointer();
11370           const int *ptrc=other->getConstPointer();
11371           for(int i=0;i<nbOfTuple;i++)
11372             std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::divides<int>(),*ptrc++));
11373         }
11374       else
11375         throw INTERP_KERNEL::Exception(msg);
11376     }
11377   else if(nbOfTuple2==1)
11378     {
11379       if(nbOfComp2==nbOfComp)
11380         {
11381           int *ptr=getPointer();
11382           const int *ptrc=other->getConstPointer();
11383           for(int i=0;i<nbOfTuple;i++)
11384             std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::divides<int>());
11385         }
11386       else
11387         throw INTERP_KERNEL::Exception(msg);
11388     }
11389   else
11390     throw INTERP_KERNEL::Exception(msg);
11391   declareAsNew();
11392 }
11393
11394
11395 /*!
11396  * Returns a new DataArrayInt that is a modulus of two given arrays. There are 3
11397  * valid cases.
11398  * 1.  The arrays have same number of tuples and components. Then each value of
11399  *   the result array (_a_) is a division of the corresponding values of \a a1 and
11400  *   \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ i, j ].
11401  * 2.  The arrays have same number of tuples and one array, say _a2_, has one
11402  *   component. Then
11403  *   _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ i, 0 ].
11404  * 3.  The arrays have same number of components and one array, say _a2_, has one
11405  *   tuple. Then
11406  *   _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ 0, j ].
11407  *
11408  * Info on components is copied either from the first array (in the first case) or from
11409  * the array with maximal number of elements (getNbOfElems()).
11410  *  \warning No check of division by zero is performed!
11411  *  \param [in] a1 - a dividend array.
11412  *  \param [in] a2 - a divisor array.
11413  *  \return DataArrayInt * - the new instance of DataArrayInt.
11414  *          The caller is to delete this result array using decrRef() as it is no more
11415  *          needed.
11416  *  \throw If either \a a1 or \a a2 is NULL.
11417  *  \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
11418  *         \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
11419  *         none of them has number of tuples or components equal to 1.
11420  */
11421 DataArrayInt *DataArrayInt::Modulus(const DataArrayInt *a1, const DataArrayInt *a2)
11422 {
11423   if(!a1 || !a2)
11424     throw INTERP_KERNEL::Exception("DataArrayInt::Modulus : input DataArrayInt instance is NULL !");
11425   int nbOfTuple1=a1->getNumberOfTuples();
11426   int nbOfTuple2=a2->getNumberOfTuples();
11427   int nbOfComp1=a1->getNumberOfComponents();
11428   int nbOfComp2=a2->getNumberOfComponents();
11429   if(nbOfTuple2==nbOfTuple1)
11430     {
11431       if(nbOfComp1==nbOfComp2)
11432         {
11433           MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11434           ret->alloc(nbOfTuple2,nbOfComp1);
11435           std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::modulus<int>());
11436           ret->copyStringInfoFrom(*a1);
11437           return ret.retn();
11438         }
11439       else if(nbOfComp2==1)
11440         {
11441           MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11442           ret->alloc(nbOfTuple1,nbOfComp1);
11443           const int *a2Ptr=a2->getConstPointer();
11444           const int *a1Ptr=a1->getConstPointer();
11445           int *res=ret->getPointer();
11446           for(int i=0;i<nbOfTuple1;i++)
11447             res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::modulus<int>(),a2Ptr[i]));
11448           ret->copyStringInfoFrom(*a1);
11449           return ret.retn();
11450         }
11451       else
11452         {
11453           a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Modulus !");
11454           return 0;
11455         }
11456     }
11457   else if(nbOfTuple2==1)
11458     {
11459       a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Modulus !");
11460       MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11461       ret->alloc(nbOfTuple1,nbOfComp1);
11462       const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
11463       int *pt=ret->getPointer();
11464       for(int i=0;i<nbOfTuple1;i++)
11465         pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::modulus<int>());
11466       ret->copyStringInfoFrom(*a1);
11467       return ret.retn();
11468     }
11469   else
11470     {
11471       a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Modulus !");//will always throw an exception
11472       return 0;
11473     }
11474 }
11475
11476 /*!
11477  * Modify \a this array so that each value becomes a modulus of division of this value by
11478  * a value of another DataArrayInt. There are 3 valid cases.
11479  * 1.  The arrays have same number of tuples and components. Then each value of
11480  *    \a this array is divided by the corresponding value of \a other one, i.e.:
11481  *   _a_ [ i, j ] %= _other_ [ i, j ].
11482  * 2.  The arrays have same number of tuples and \a other array has one component. Then
11483  *   _a_ [ i, j ] %= _other_ [ i, 0 ].
11484  * 3.  The arrays have same number of components and \a other array has one tuple. Then
11485  *   _a_ [ i, j ] %= _a2_ [ 0, j ].
11486  *
11487  *  \warning No check of division by zero is performed!
11488  *  \param [in] other - a divisor array.
11489  *  \throw If \a other is NULL.
11490  *  \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
11491  *         \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
11492  *         \a other has number of both tuples and components not equal to 1.
11493  */
11494 void DataArrayInt::modulusEqual(const DataArrayInt *other)
11495 {
11496   if(!other)
11497     throw INTERP_KERNEL::Exception("DataArrayInt::modulusEqual : input DataArrayInt instance is NULL !");
11498   const char *msg="Nb of tuples mismatch for DataArrayInt::modulusEqual !";
11499   checkAllocated(); other->checkAllocated();
11500   int nbOfTuple=getNumberOfTuples();
11501   int nbOfTuple2=other->getNumberOfTuples();
11502   int nbOfComp=getNumberOfComponents();
11503   int nbOfComp2=other->getNumberOfComponents();
11504   if(nbOfTuple==nbOfTuple2)
11505     {
11506       if(nbOfComp==nbOfComp2)
11507         {
11508           std::transform(begin(),end(),other->begin(),getPointer(),std::modulus<int>());
11509         }
11510       else if(nbOfComp2==1)
11511         {
11512           if(nbOfComp2==nbOfComp)
11513             {
11514               int *ptr=getPointer();
11515               const int *ptrc=other->getConstPointer();
11516               for(int i=0;i<nbOfTuple;i++)
11517                 std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::modulus<int>(),*ptrc++));
11518             }
11519           else
11520             throw INTERP_KERNEL::Exception(msg);
11521         }
11522       else
11523         throw INTERP_KERNEL::Exception(msg);
11524     }
11525   else if(nbOfTuple2==1)
11526     {
11527       int *ptr=getPointer();
11528       const int *ptrc=other->getConstPointer();
11529       for(int i=0;i<nbOfTuple;i++)
11530         std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::modulus<int>());
11531     }
11532   else
11533     throw INTERP_KERNEL::Exception(msg);
11534   declareAsNew();
11535 }
11536
11537 /*!
11538  * Returns a new DataArrayInt that is the result of pow of two given arrays. There are 3
11539  * valid cases.
11540  *
11541  *  \param [in] a1 - an array to pow up.
11542  *  \param [in] a2 - another array to sum up.
11543  *  \return DataArrayInt * - the new instance of DataArrayInt.
11544  *          The caller is to delete this result array using decrRef() as it is no more
11545  *          needed.
11546  *  \throw If either \a a1 or \a a2 is NULL.
11547  *  \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
11548  *  \throw If \a a1->getNumberOfComponents() != 1 or \a a2->getNumberOfComponents() != 1.
11549  *  \throw If there is a negative value in \a a2.
11550  */
11551 DataArrayInt *DataArrayInt::Pow(const DataArrayInt *a1, const DataArrayInt *a2)
11552 {
11553   if(!a1 || !a2)
11554     throw INTERP_KERNEL::Exception("DataArrayInt::Pow : at least one of input instances is null !");
11555   int nbOfTuple=a1->getNumberOfTuples();
11556   int nbOfTuple2=a2->getNumberOfTuples();
11557   int nbOfComp=a1->getNumberOfComponents();
11558   int nbOfComp2=a2->getNumberOfComponents();
11559   if(nbOfTuple!=nbOfTuple2)
11560     throw INTERP_KERNEL::Exception("DataArrayInt::Pow : number of tuples mismatches !");
11561   if(nbOfComp!=1 || nbOfComp2!=1)
11562     throw INTERP_KERNEL::Exception("DataArrayInt::Pow : number of components of both arrays must be equal to 1 !");
11563   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbOfTuple,1);
11564   const int *ptr1(a1->begin()),*ptr2(a2->begin());
11565   int *ptr=ret->getPointer();
11566   for(int i=0;i<nbOfTuple;i++,ptr1++,ptr2++,ptr++)
11567     {
11568       if(*ptr2>=0)
11569         {
11570           int tmp=1;
11571           for(int j=0;j<*ptr2;j++)
11572             tmp*=*ptr1;
11573           *ptr=tmp;
11574         }
11575       else
11576         {
11577           std::ostringstream oss; oss << "DataArrayInt::Pow : on tuple #" << i << " of a2 value is < 0 (" << *ptr2 << ") !";
11578           throw INTERP_KERNEL::Exception(oss.str().c_str());
11579         }
11580     }
11581   return ret.retn();
11582 }
11583
11584 /*!
11585  * Apply pow on values of another DataArrayInt to values of \a this one.
11586  *
11587  *  \param [in] other - an array to pow to \a this one.
11588  *  \throw If \a other is NULL.
11589  *  \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples()
11590  *  \throw If \a this->getNumberOfComponents() != 1 or \a other->getNumberOfComponents() != 1
11591  *  \throw If there is a negative value in \a other.
11592  */
11593 void DataArrayInt::powEqual(const DataArrayInt *other)
11594 {
11595   if(!other)
11596     throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : input instance is null !");
11597   int nbOfTuple=getNumberOfTuples();
11598   int nbOfTuple2=other->getNumberOfTuples();
11599   int nbOfComp=getNumberOfComponents();
11600   int nbOfComp2=other->getNumberOfComponents();
11601   if(nbOfTuple!=nbOfTuple2)
11602     throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : number of tuples mismatches !");
11603   if(nbOfComp!=1 || nbOfComp2!=1)
11604     throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : number of components of both arrays must be equal to 1 !");
11605   int *ptr=getPointer();
11606   const int *ptrc=other->begin();
11607   for(int i=0;i<nbOfTuple;i++,ptrc++,ptr++)
11608     {
11609       if(*ptrc>=0)
11610         {
11611           int tmp=1;
11612           for(int j=0;j<*ptrc;j++)
11613             tmp*=*ptr;
11614           *ptr=tmp;
11615         }
11616       else
11617         {
11618           std::ostringstream oss; oss << "DataArrayInt::powEqual : on tuple #" << i << " of other value is < 0 (" << *ptrc << ") !";
11619           throw INTERP_KERNEL::Exception(oss.str().c_str());
11620         }
11621     }
11622   declareAsNew();
11623 }
11624
11625 /*!
11626  * Returns a C array which is a renumbering map in "Old to New" mode for the input array.
11627  * This map, if applied to \a start array, would make it sorted. For example, if
11628  * \a start array contents are [9,10,0,6,4,11,3,7] then the contents of the result array is
11629  * [5,6,0,3,2,7,1,4].
11630  *  \param [in] start - pointer to the first element of the array for which the
11631  *         permutation map is computed.
11632  *  \param [in] end - pointer specifying the end of the array \a start, so that
11633  *         the last value of \a start is \a end[ -1 ].
11634  *  \return int * - the result permutation array that the caller is to delete as it is no
11635  *         more needed.
11636  *  \throw If there are equal values in the input array.
11637  */
11638 int *DataArrayInt::CheckAndPreparePermutation(const int *start, const int *end)
11639 {
11640   std::size_t sz=std::distance(start,end);
11641   int *ret=(int *)malloc(sz*sizeof(int));
11642   int *work=new int[sz];
11643   std::copy(start,end,work);
11644   std::sort(work,work+sz);
11645   if(std::unique(work,work+sz)!=work+sz)
11646     {
11647       delete [] work;
11648       free(ret);
11649       throw INTERP_KERNEL::Exception("Some elements are equals in the specified array !");
11650     }
11651   std::map<int,int> m;
11652   for(int *workPt=work;workPt!=work+sz;workPt++)
11653     m[*workPt]=(int)std::distance(work,workPt);
11654   int *iter2=ret;
11655   for(const int *iter=start;iter!=end;iter++,iter2++)
11656     *iter2=m[*iter];
11657   delete [] work;
11658   return ret;
11659 }
11660
11661 /*!
11662  * Returns a new DataArrayInt containing an arithmetic progression
11663  * that is equal to the sequence returned by Python \c range(\a begin,\a  end,\a  step )
11664  * function.
11665  *  \param [in] begin - the start value of the result sequence.
11666  *  \param [in] end - limiting value, so that every value of the result array is less than
11667  *              \a end.
11668  *  \param [in] step - specifies the increment or decrement.
11669  *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
11670  *          array using decrRef() as it is no more needed.
11671  *  \throw If \a step == 0.
11672  *  \throw If \a end < \a begin && \a step > 0.
11673  *  \throw If \a end > \a begin && \a step < 0.
11674  */
11675 DataArrayInt *DataArrayInt::Range(int begin, int end, int step)
11676 {
11677   int nbOfTuples=GetNumberOfItemGivenBESRelative(begin,end,step,"DataArrayInt::Range");
11678   MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
11679   ret->alloc(nbOfTuples,1);
11680   int *ptr=ret->getPointer();
11681   if(step>0)
11682     {
11683       for(int i=begin;i<end;i+=step,ptr++)
11684         *ptr=i;
11685     }
11686   else
11687     {
11688       for(int i=begin;i>end;i+=step,ptr++)
11689         *ptr=i;
11690     }
11691   return ret.retn();
11692 }
11693
11694 /*!
11695  * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
11696  * Server side.
11697  */
11698 void DataArrayInt::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
11699 {
11700   tinyInfo.resize(2);
11701   if(isAllocated())
11702     {
11703       tinyInfo[0]=getNumberOfTuples();
11704       tinyInfo[1]=getNumberOfComponents();
11705     }
11706   else
11707     {
11708       tinyInfo[0]=-1;
11709       tinyInfo[1]=-1;
11710     }
11711 }
11712
11713 /*!
11714  * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
11715  * Server side.
11716  */
11717 void DataArrayInt::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
11718 {
11719   if(isAllocated())
11720     {
11721       int nbOfCompo=getNumberOfComponents();
11722       tinyInfo.resize(nbOfCompo+1);
11723       tinyInfo[0]=getName();
11724       for(int i=0;i<nbOfCompo;i++)
11725         tinyInfo[i+1]=getInfoOnComponent(i);
11726     }
11727   else
11728     {
11729       tinyInfo.resize(1);
11730       tinyInfo[0]=getName();
11731     }
11732 }
11733
11734 /*!
11735  * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
11736  * This method returns if a feeding is needed.
11737  */
11738 bool DataArrayInt::resizeForUnserialization(const std::vector<int>& tinyInfoI)
11739 {
11740   int nbOfTuple=tinyInfoI[0];
11741   int nbOfComp=tinyInfoI[1];
11742   if(nbOfTuple!=-1 || nbOfComp!=-1)
11743     {
11744       alloc(nbOfTuple,nbOfComp);
11745       return true;
11746     }
11747   return false;
11748 }
11749
11750 /*!
11751  * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
11752  * This method returns if a feeding is needed.
11753  */
11754 void DataArrayInt::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<std::string>& tinyInfoS)
11755 {
11756   setName(tinyInfoS[0]);
11757   if(isAllocated())
11758     {
11759       int nbOfCompo=tinyInfoI[1];
11760       for(int i=0;i<nbOfCompo;i++)
11761         setInfoOnComponent(i,tinyInfoS[i+1]);
11762     }
11763 }
11764
11765 DataArrayIntIterator::DataArrayIntIterator(DataArrayInt *da):_da(da),_pt(0),_tuple_id(0),_nb_comp(0),_nb_tuple(0)
11766 {
11767   if(_da)
11768     {
11769       _da->incrRef();
11770       if(_da->isAllocated())
11771         {
11772           _nb_comp=da->getNumberOfComponents();
11773           _nb_tuple=da->getNumberOfTuples();
11774           _pt=da->getPointer();
11775         }
11776     }
11777 }
11778
11779 DataArrayIntIterator::~DataArrayIntIterator()
11780 {
11781   if(_da)
11782     _da->decrRef();
11783 }
11784
11785 DataArrayIntTuple *DataArrayIntIterator::nextt()
11786 {
11787   if(_tuple_id<_nb_tuple)
11788     {
11789       _tuple_id++;
11790       DataArrayIntTuple *ret=new DataArrayIntTuple(_pt,_nb_comp);
11791       _pt+=_nb_comp;
11792       return ret;
11793     }
11794   else
11795     return 0;
11796 }
11797
11798 DataArrayIntTuple::DataArrayIntTuple(int *pt, int nbOfComp):_pt(pt),_nb_of_compo(nbOfComp)
11799 {
11800 }
11801
11802 std::string DataArrayIntTuple::repr() const
11803 {
11804   std::ostringstream oss; oss << "(";
11805   for(int i=0;i<_nb_of_compo-1;i++)
11806     oss << _pt[i] << ", ";
11807   oss << _pt[_nb_of_compo-1] << ")";
11808   return oss.str();
11809 }
11810
11811 int DataArrayIntTuple::intValue() const
11812 {
11813   if(_nb_of_compo==1)
11814     return *_pt;
11815   throw INTERP_KERNEL::Exception("DataArrayIntTuple::intValue : DataArrayIntTuple instance has not exactly 1 component -> Not possible to convert it into an integer !");
11816 }
11817
11818 /*!
11819  * This method returns a newly allocated instance the caller should dealed with by a ParaMEDMEM::DataArrayInt::decrRef.
11820  * This method performs \b no copy of data. The content is only referenced using ParaMEDMEM::DataArrayInt::useArray with ownership set to \b false.
11821  * This method throws an INTERP_KERNEL::Exception is it is impossible to match sizes of \b this that is too say \b nbOfCompo=this->_nb_of_elem and \bnbOfTuples==1 or
11822  * \b nbOfCompo=1 and \bnbOfTuples==this->_nb_of_elem.
11823  */
11824 DataArrayInt *DataArrayIntTuple::buildDAInt(int nbOfTuples, int nbOfCompo) const
11825 {
11826   if((_nb_of_compo==nbOfCompo && nbOfTuples==1) || (_nb_of_compo==nbOfTuples && nbOfCompo==1))
11827     {
11828       DataArrayInt *ret=DataArrayInt::New();
11829       ret->useExternalArrayWithRWAccess(_pt,nbOfTuples,nbOfCompo);
11830       return ret;
11831     }
11832   else
11833     {
11834       std::ostringstream oss; oss << "DataArrayIntTuple::buildDAInt : unable to build a requested DataArrayInt instance with nbofTuple=" << nbOfTuples << " and nbOfCompo=" << nbOfCompo;
11835       oss << ".\nBecause the number of elements in this is " << _nb_of_compo << " !";
11836       throw INTERP_KERNEL::Exception(oss.str().c_str());
11837     }
11838 }