From: emv <emv@opencascade.com>
Date: Wed, 23 Oct 2019 09:51:12 +0000 (+0300)
Subject: LOT 3: Moving DataArrayInt32 methods into DataArrayDiscrete<T> to make them available... 
X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=refs%2Fheads%2Femv%2FLOT3;p=tools%2Fmedcoupling.git

LOT 3: Moving DataArrayInt32 methods into DataArrayDiscrete<T> to make them available in DataArrayInt64
---

diff --git a/src/MEDCoupling/MCType.hxx b/src/MEDCoupling/MCType.hxx
index 87ed588fa..f7cbce4d2 100644
--- a/src/MEDCoupling/MCType.hxx
+++ b/src/MEDCoupling/MCType.hxx
@@ -31,18 +31,23 @@ namespace MEDCoupling
   using Int32 = std::int32_t;
 #ifndef MEDCOUPLING_USE_64BIT_IDS
   using mcIdType = std::int32_t;
+
+#define DataArrayIdType DataArrayInt32
+
 #else
   using mcIdType = std::int64_t;
+
+#define DataArrayIdType DataArrayInt64
+
 #endif
+
   template <class T> inline mcIdType ToIdType(T val)
   {
     return static_cast<mcIdType>(val);
   }
-}
 
 #define DataArrayInt DataArrayInt32
-#define DataArrayIdType DataArrayInt32
-
 #define DataArrayIntIterator DataArrayInt32Iterator
+}
 
 #endif
diff --git a/src/MEDCoupling/MEDCouplingMap.cxx b/src/MEDCoupling/MEDCouplingMap.cxx
index afeabb2eb..d4534d3d0 100644
--- a/src/MEDCoupling/MEDCouplingMap.cxx
+++ b/src/MEDCoupling/MEDCouplingMap.cxx
@@ -22,4 +22,4 @@
 
 using namespace MEDCoupling;
 
-template class MEDCoupling::MapKeyVal<int>;
+template class MEDCoupling::MapKeyVal<mcIdType, mcIdType>;
diff --git a/src/MEDCoupling/MEDCouplingMap.hxx b/src/MEDCoupling/MEDCouplingMap.hxx
index 68b084a77..395d56e49 100644
--- a/src/MEDCoupling/MEDCouplingMap.hxx
+++ b/src/MEDCoupling/MEDCouplingMap.hxx
@@ -23,6 +23,7 @@
 
 #include "MEDCoupling.hxx"
 #include "MCAuto.hxx"
+#include "MCType.hxx"
 #include "MEDCouplingTimeLabel.hxx"
 #include "MEDCouplingRefCountObject.hxx"
 #include "InterpKernelException.hxx"
@@ -31,13 +32,13 @@
 
 namespace MEDCoupling
 {  
-  template<class T>
+  template<class ID, class T>
   class MapKeyVal : public RefCountObject, public TimeLabel
   {
   public:
-    static MCAuto< MapKeyVal<T> > New();
-    std::map<T,T>& data() { return _m; }
-    const std::map<T,T>& data() const { return _m; }
+    static MCAuto< MapKeyVal<ID, T> > New();
+    std::map<ID,T>& data() { return _m; }
+    const std::map<ID,T>& data() const { return _m; }
     std::size_t getHeapMemorySizeWithoutChildren() const;
     std::vector<const BigMemoryObject*> getDirectChildrenWithNull() const;
     void updateTime() const { }
@@ -45,10 +46,10 @@ namespace MEDCoupling
     MapKeyVal() { }
     ~MapKeyVal() { }
   private:
-    std::map<T,T> _m;
+    std::map<ID,T> _m;
   };
 
-  using MapII = MapKeyVal<int>;
+  using MapII = MapKeyVal<mcIdType, mcIdType>;
 }
 
 #endif
diff --git a/src/MEDCoupling/MEDCouplingMap.txx b/src/MEDCoupling/MEDCouplingMap.txx
index 6248b4ee6..fb8f0cc88 100644
--- a/src/MEDCoupling/MEDCouplingMap.txx
+++ b/src/MEDCoupling/MEDCouplingMap.txx
@@ -25,21 +25,21 @@
 
 namespace MEDCoupling
 {
-  template<class T>
-  MCAuto< MapKeyVal<T> > MapKeyVal<T>::New()
+  template<class ID, class T>
+  MCAuto< MapKeyVal<ID, T> > MapKeyVal<ID, T>::New()
   {
-    MCAuto< MapKeyVal<T> > ret(new MapKeyVal<T>);
+    MCAuto< MapKeyVal<ID, T> > ret(new MapKeyVal<ID, T>);
     return ret;
   }
   
-  template<class T>
-  std::size_t MapKeyVal<T>::getHeapMemorySizeWithoutChildren() const
+  template<class ID, class T>
+  std::size_t MapKeyVal<ID, T>::getHeapMemorySizeWithoutChildren() const
   {
-    return _m.size()*sizeof(std::pair<T,T>);
+    return _m.size()*sizeof(std::pair<ID, T>);
   }
   
-  template<class T>
-  std::vector<const BigMemoryObject*> MapKeyVal<T>::getDirectChildrenWithNull() const
+  template<class ID, class T>
+  std::vector<const BigMemoryObject*> MapKeyVal<ID, T>::getDirectChildrenWithNull() const
   {
     return std::vector<const BigMemoryObject*>();//not a bug no child. Leaf object !
   }
diff --git a/src/MEDCoupling/MEDCouplingMemArray.cxx b/src/MEDCoupling/MEDCouplingMemArray.cxx
index 77d6320fc..d48a98c29 100755
--- a/src/MEDCoupling/MEDCouplingMemArray.cxx
+++ b/src/MEDCoupling/MEDCouplingMemArray.cxx
@@ -3661,27 +3661,6 @@ DataArrayDouble *DataArrayDoubleTuple::buildDADouble(int nbOfTuples, int nbOfCom
   return this->buildDA(nbOfTuples,nbOfCompo);
 }
 
-/*!
- * Returns the only one value in \a this, if and only if number of elements
- * (nb of tuples * nb of components) is equal to 1, and that \a this is allocated.
- *  \return double - the sole value stored in \a this array.
- *  \throw If at least one of conditions stated above is not fulfilled.
- */
-int DataArrayInt::intValue() const
-{
-  if(isAllocated())
-    {
-      if(getNbOfElems()==1)
-        {
-          return *getConstPointer();
-        }
-      else
-        throw INTERP_KERNEL::Exception("DataArrayInt::intValue : DataArrayInt instance is allocated but number of elements is not equal to 1 !");
-    }
-  else
-    throw INTERP_KERNEL::Exception("DataArrayInt::intValue : DataArrayInt instance is not allocated !");
-}
-
 /*!
  * Returns a full copy of \a this. For more info on copying data arrays see
  * \ref MEDCouplingArrayBasicsCopyDeep.
@@ -3692,3387 +3671,78 @@ DataArrayInt32 *DataArrayInt32::deepCopy() const
   return new DataArrayInt32(*this);
 }
 
-/*!
- * Computes distribution of values of \a this one-dimensional array between given value
- * ranges (casts). This method is typically useful for entity number splitting by types,
- * for example. 
- *  \warning The values contained in \a arrBg should be sorted ascendently. No
- *           check of this is be done. If not, the result is not warranted. 
- *  \param [in] arrBg - the array of ascending values defining the value ranges. The i-th
- *         value of \a arrBg (\a arrBg[ i ]) gives the lowest value of the i-th range,
- *         and the greatest value of the i-th range equals to \a arrBg[ i+1 ] - 1. \a
- *         arrBg containing \a n values defines \a n-1 ranges. The last value of \a arrBg
- *         should be more than every value in \a this array.
- *  \param [in] arrEnd - specifies the end of the array \a arrBg, so that
- *              the last value of \a arrBg is \a arrEnd[ -1 ].
- *  \param [out] castArr - a new instance of DataArrayInt, of same size as \a this array
- *         (same number of tuples and components), the caller is to delete
- *         using decrRef() as it is no more needed.
- *         This array contains indices of ranges for every value of \a this array. I.e.
- *         the i-th value of \a castArr gives the index of range the i-th value of \a this
- *         belongs to. Or, in other words, this parameter contains for each tuple in \a
- *         this in which cast it holds.
- *  \param [out] rankInsideCast - a new instance of DataArrayInt, of same size as \a this
- *         array, the caller is to delete using decrRef() as it is no more needed.
- *         This array contains ranks of values of \a this array within ranges
- *         they belongs to. I.e. the i-th value of \a rankInsideCast gives the rank of
- *         the i-th value of \a this array within the \a castArr[ i ]-th range, to which
- *         the i-th value of \a this belongs to. Or, in other words, this param contains
- *         for each tuple its rank inside its cast. The rank is computed as difference
- *         between the value and the lowest value of range.
- *  \param [out] castsPresent - a new instance of DataArrayInt, containing indices of
- *         ranges (casts) to which at least one value of \a this array belongs.
- *         Or, in other words, this param contains the casts that \a this contains.
- *         The caller is to delete this array using decrRef() as it is no more needed.
- *
- * \b Example: If \a this contains [6,5,0,3,2,7,8,1,4] and \a arrBg contains [0,4,9] then
- *            the output of this method will be :
- * - \a castArr       : [1,1,0,0,0,1,1,0,1]
- * - \a rankInsideCast: [2,1,0,3,2,3,4,1,0]
- * - \a castsPresent  : [0,1]
- *
- * I.e. values of \a this array belong to 2 ranges: #0 and #1. Value 6 belongs to the
- * range #1 and its rank within this range is 2; etc.
- *
- *  \throw If \a this->getNumberOfComponents() != 1.
- *  \throw If \a arrEnd - arrBg < 2.
- *  \throw If any value of \a this is not less than \a arrEnd[-1].
- */
-void DataArrayInt::splitByValueRange(const int *arrBg, const int *arrEnd,
-                                     DataArrayInt *& castArr, DataArrayInt *& rankInsideCast, DataArrayInt *& castsPresent) const
+DataArrayIntIterator *DataArrayInt::iterator()
 {
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("Call splitByValueRange  method on DataArrayInt with only one component, you can call 'rearrange' method before !");
-  std::size_t nbOfTuples=getNumberOfTuples();
-  std::size_t nbOfCast=std::distance(arrBg,arrEnd);
-  if(nbOfCast<2)
-    throw INTERP_KERNEL::Exception("DataArrayInt::splitByValueRange : The input array giving the cast range values should be of size >=2 !");
-  nbOfCast--;
-  const int *work=getConstPointer();
-  typedef std::reverse_iterator<const int *> rintstart;
-  rintstart bg(arrEnd);//OK no problem because size of 'arr' is greater or equal 2
-  rintstart end2(arrBg);
-  MCAuto<DataArrayInt> ret1=DataArrayInt::New();
-  MCAuto<DataArrayInt> ret2=DataArrayInt::New();
-  MCAuto<DataArrayInt> ret3=DataArrayInt::New();
-  ret1->alloc(nbOfTuples,1);
-  ret2->alloc(nbOfTuples,1);
-  int *ret1Ptr=ret1->getPointer();
-  int *ret2Ptr=ret2->getPointer();
-  std::set<mcIdType> castsDetected;
-  for(std::size_t i=0;i<nbOfTuples;i++)
-    {
-      rintstart res=std::find_if(bg,end2,std::bind2nd(std::less_equal<int>(), work[i]));
-      std::size_t pos=std::distance(bg,res);
-      std::size_t pos2=nbOfCast-pos;
-      if(pos2<nbOfCast)
-        {
-          ret1Ptr[i]=(int)pos2;
-          ret2Ptr[i]=work[i]-arrBg[pos2];
-          castsDetected.insert(ToIdType(pos2));
-        }
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::splitByValueRange : At rank #" << i << " the value is " << work[i] << " should be in [0," << *bg << ") !";
-          throw INTERP_KERNEL::Exception(oss.str().c_str());
-        }
-    }
-  ret3->alloc(castsDetected.size(),1);
-  std::copy(castsDetected.begin(),castsDetected.end(),ret3->getPointer());
-  castArr=ret1.retn();
-  rankInsideCast=ret2.retn();
-  castsPresent=ret3.retn();
+  return new DataArrayIntIterator(this);
 }
 
-/*!
- * 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 ).
- * 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 ).
- * This method works only if \a this is allocated and single component. If not an exception will be thrown.
- *
- * \param [out] strt - the start of the range (included) if true is returned.
- * \param [out] sttoopp - the end of the range (not included) if true is returned.
- * \param [out] stteepp - the step of the range if true is returned.
- * \return the verdict of the check.
- *
- * \sa DataArray::GetNumberOfItemGivenBES
- */
-bool DataArrayInt::isRange(int& strt, int& sttoopp, int& stteepp) const
-{
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::isRange : this must be single component array !");
-  mcIdType nbTuples=ToIdType(getNumberOfTuples());
-  if(nbTuples==0)
-    { strt=0; sttoopp=0; stteepp=1; return true; }
-  const int *pt(begin());
-  strt=*pt;
-  if(nbTuples==1)
-    { sttoopp=strt+1; stteepp=1; return true; }
-  strt=*pt; sttoopp=pt[nbTuples-1];
-  if(strt==sttoopp)
-    return false;
-  if(sttoopp>strt)
-    {
-      sttoopp++;
-      int a(sttoopp-1-strt),tmp(strt);
-      if(a%(nbTuples-1)!=0)
-        return false;
-      stteepp=a/(nbTuples-1);
-      for(mcIdType i=0;i<nbTuples;i++,tmp+=stteepp)
-        if(pt[i]!=tmp)
-          return false;
-      return true;
-    }
-  else
-    {
-      sttoopp--;
-      int a(strt-sttoopp-1),tmp(strt);
-      if(a%(nbTuples-1)!=0)
-        return false;
-      stteepp=-(a/(nbTuples-1));
-      for(mcIdType i=0;i<nbTuples;i++,tmp+=stteepp)
-        if(pt[i]!=tmp)
-          return false;
-      return true;
-    }
-}
 
-/*!
- * Creates a one-dimensional DataArrayInt (\a res) whose contents are computed from
- * values of \a this (\a a) and the given (\a indArr) arrays as follows:
- * \a res[ \a indArr[ \a a[ i ]]] = i. I.e. for each value in place i \a v = \a a[ i ],
- * new value in place \a indArr[ \a v ] is i.
- *  \param [in] indArrBg - the array holding indices within the result array to assign
- *         indices of values of \a this array pointing to values of \a indArrBg.
- *  \param [in] indArrEnd - specifies the end of the array \a indArrBg, so that
- *              the last value of \a indArrBg is \a indArrEnd[ -1 ].
- *  \return DataArrayInt * - the new instance of DataArrayInt.
- *          The caller is to delete this result array using decrRef() as it is no more
- *          needed.
- *  \throw If \a this->getNumberOfComponents() != 1.
- *  \throw If any value of \a this array is not a valid index for \a indArrBg array.
- *  \throw If any value of \a indArrBg is not a valid index for \a this array.
- */
-DataArrayInt *DataArrayInt::transformWithIndArrR(const int *indArrBg, const int *indArrEnd) const
+DataArrayInt32Iterator::DataArrayInt32Iterator(DataArrayInt32 *da):DataArrayIterator<Int32>(da)
 {
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("Call transformWithIndArrR method on DataArrayInt with only one component, you can call 'rearrange' method before !");
-  int nbElemsIn=(int)std::distance(indArrBg,indArrEnd);
-  mcIdType nbOfTuples=ToIdType(getNumberOfTuples());
-  const int *pt=getConstPointer();
-  MCAuto<DataArrayInt> ret=DataArrayInt::New();
-  ret->alloc(nbOfTuples,1);
-  ret->fillWithValue(-1);
-  int *tmp=ret->getPointer();
-  for(mcIdType i=0;i<nbOfTuples;i++,pt++)
-    {
-      if(*pt>=0 && *pt<nbElemsIn)
-        {
-          int pos=indArrBg[*pt];
-          if(pos>=0 && pos<nbOfTuples)
-            tmp[pos]=i;
-          else
-            {
-              std::ostringstream oss; oss << "DataArrayInt::transformWithIndArrR : error on tuple #" << i << " value of new pos is " << pos << " ( indArrBg[" << *pt << "]) ! Should be in [0," << nbOfTuples << ") !";
-              throw INTERP_KERNEL::Exception(oss.str().c_str());
-            }
-        }
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::transformWithIndArrR : error on tuple #" << i << " value is " << *pt << " and indirectionnal array as a size equal to " << nbElemsIn << " !";
-          throw INTERP_KERNEL::Exception(oss.str().c_str());
-        }
-    }
-  return ret.retn();
-}
-
-/*!
- * Creates a one-dimensional DataArrayInt of given length, whose contents are computed
- * from values of \a this array, which is supposed to contain a renumbering map in
- * "Old to New" mode. The result array contains a renumbering map in "New to Old" mode.
- * To know how to use the renumbering maps see \ref numbering.
- *  \param [in] newNbOfElem - the number of tuples in the result array.
- *  \return DataArrayInt * - the new instance of DataArrayInt.
- *          The caller is to delete this result array using decrRef() as it is no more
- *          needed.
- *
- *  \if ENABLE_EXAMPLES
- *  \ref cpp_mcdataarrayint_invertarrayo2n2n2o "Here is a C++ example".<br>
- *  \ref py_mcdataarrayint_invertarrayo2n2n2o  "Here is a Python example".
- *  \endif
- */
-DataArrayInt *DataArrayInt::invertArrayO2N2N2O(int newNbOfElem) const
-{
-  MCAuto<DataArrayInt> ret(DataArrayInt::New());
-  ret->alloc(newNbOfElem,1);
-  mcIdType nbOfOldNodes=ToIdType(this->getNumberOfTuples());
-  const int *old2New(begin());
-  int *pt(ret->getPointer());
-  for(mcIdType i=0;i!=nbOfOldNodes;i++)
-    {
-      int newp(old2New[i]);
-      if(newp!=-1)
-        {
-          if(newp>=0 && newp<newNbOfElem)
-            pt[newp]=i;
-          else
-            {
-              std::ostringstream oss; oss << "DataArrayInt::invertArrayO2N2N2O : At place #" << i << " the newplace is " << newp << " must be in [0," << newNbOfElem << ") !";
-              throw INTERP_KERNEL::Exception(oss.str().c_str());
-            }
-        }
-    }
-  return ret.retn();
-}
-
-/*!
- * This method is similar to DataArrayInt::invertArrayO2N2N2O except that
- * 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]
- */
-DataArrayInt *DataArrayInt::invertArrayO2N2N2OBis(int newNbOfElem) const
-{
-  MCAuto<DataArrayInt> ret=DataArrayInt::New();
-  ret->alloc(newNbOfElem,1);
-  mcIdType nbOfOldNodes=ToIdType(getNumberOfTuples());
-  const int *old2New=getConstPointer();
-  int *pt=ret->getPointer();
-  for(mcIdType i=nbOfOldNodes-1;i>=0;i--)
-    {
-      int newp(old2New[i]);
-      if(newp!=-1)
-        {
-          if(newp>=0 && newp<newNbOfElem)
-            pt[newp]=i;
-          else
-            {
-              std::ostringstream oss; oss << "DataArrayInt::invertArrayO2N2N2OBis : At place #" << i << " the newplace is " << newp << " must be in [0," << newNbOfElem << ") !";
-              throw INTERP_KERNEL::Exception(oss.str().c_str());
-            }
-        }
-    }
-  return ret.retn();
 }
 
-/*!
- * Creates a one-dimensional DataArrayInt of given length, whose contents are computed
- * from values of \a this array, which is supposed to contain a renumbering map in
- * "New to Old" mode. The result array contains a renumbering map in "Old to New" mode.
- * To know how to use the renumbering maps see \ref numbering.
- *  \param [in] newNbOfElem - the number of tuples in the result array.
- *  \return DataArrayInt * - the new instance of DataArrayInt.
- *          The caller is to delete this result array using decrRef() as it is no more
- *          needed.
- *
- *  \if ENABLE_EXAMPLES
- *  \ref cpp_mcdataarrayint_invertarrayn2o2o2n "Here is a C++ example".
- *
- *  \ref py_mcdataarrayint_invertarrayn2o2o2n "Here is a Python example".
- *  \sa invertArrayN2O2O2NOptimized
- *  \endif
- */
-DataArrayInt *DataArrayInt::invertArrayN2O2O2N(int oldNbOfElem) const
+DataArrayInt32Tuple::DataArrayInt32Tuple(Int32 *pt, mcIdType nbOfComp):DataArrayTuple<Int32>(pt,nbOfComp)
 {
-  checkAllocated();
-  MCAuto<DataArrayInt> ret=DataArrayInt::New();
-  ret->alloc(oldNbOfElem,1);
-  const int *new2Old=getConstPointer();
-  int *pt=ret->getPointer();
-  std::fill(pt,pt+oldNbOfElem,-1);
-  mcIdType nbOfNewElems=ToIdType(getNumberOfTuples());
-  for(mcIdType i=0;i<nbOfNewElems;i++)
-    {
-      int v(new2Old[i]);
-      if(v>=0 && v<oldNbOfElem)
-        pt[v]=i;
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::invertArrayN2O2O2N : in new id #" << i << " old value is " << v << " expected to be in [0," << oldNbOfElem << ") !";
-          throw INTERP_KERNEL::Exception(oss.str().c_str());
-        }
-    }
-  return ret.retn();
 }
 
-/*!
- * Creates a map, whose contents are computed
- * from values of \a this array, which is supposed to contain a renumbering map in
- * "New to Old" mode. The result array contains a renumbering map in "Old to New" mode.
- * To know how to use the renumbering maps see \ref numbering.
- *  \param [in] newNbOfElem - the number of tuples in the result array.
- *  \return MapII  - the new instance of Map.
- *
- *  \if ENABLE_EXAMPLES
- *  \ref cpp_mcdataarrayint_invertarrayn2o2o2n "Here is a C++ example".
- *
- *  \ref py_mcdataarrayint_invertarrayn2o2o2n "Here is a Python example".
- *  \sa invertArrayN2O2O2N, giveN2OOptimized, MEDCouplingPointSet::renumberNodesInConn
- *  \endif
- */
-MCAuto< MapKeyVal<int> > DataArrayInt32::invertArrayN2O2O2NOptimized() const
+std::string DataArrayInt32Tuple::repr() const
 {
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt32::invertArrayN2O2O2NOptimized : single component expected !");
-  MCAuto< MapKeyVal<int> > ret(MapKeyVal<int>::New());
-  std::map<int,int>& m(ret->data());
-  const int *new2Old(begin());
-  mcIdType nbOfNewElems=ToIdType(this->getNumberOfTuples());
-  for(mcIdType i=0;i<nbOfNewElems;i++)
-    {
-      int v(new2Old[i]);
-      m[v]=i;
-    }
-  return ret;
+  std::ostringstream oss; oss << "(";
+  for(mcIdType i=0;i<_nb_of_compo-1;i++)
+    oss << _pt[i] << ", ";
+  oss << _pt[_nb_of_compo-1] << ")";
+  return oss.str();
 }
 
-/*!
- * Creates a map, whose contents are computed
- * from values of \a this array, which is supposed to contain a renumbering map in 
- * "New to Old" mode. The result array contains a renumbering map in "New to Old" mode as C++ map for performance reasons.
- *
- * \sa invertArrayN2O2O2NOptimized, MEDCouplingPointSet::renumberNodesInConn
- */
-MCAuto< MapKeyVal<int> > DataArrayInt32::giveN2OOptimized() const
+Int32 DataArrayInt32Tuple::intValue() const
 {
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt32::giveN2OOptimized : single component expected !");
-  MCAuto< MapKeyVal<int> > ret(MapKeyVal<int>::New());
-  std::map<int,int>& m(ret->data());
-  const int *new2Old(begin());
-  mcIdType nbOfNewElems=ToIdType(this->getNumberOfTuples());
-  for(mcIdType i=0;i<nbOfNewElems;i++)
-    {
-      int v(new2Old[i]);
-      m[i]=v;
-    }
-  return ret;
+  return this->zeValue();
 }
 
 /*!
- * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode.
- * This map, if applied to \a this array, would make it sorted. For example, if
- * \a this array contents are [9,10,0,6,4,11,3,7] then the contents of the result array
- * are [5,6,0,3,2,7,1,4]; if this result array (\a res) is used as an argument in call
- * \a this->renumber(\a res) then the returned array contains [0,3,4,6,7,9,10,11].
- * This method is useful for renumbering (in MED file for example). For more info
- * on renumbering see \ref numbering.
- *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
- *          array using decrRef() as it is no more needed.
- *  \throw If \a this is not allocated.
- *  \throw If \a this->getNumberOfComponents() != 1.
- *  \throw If there are equal values in \a this array.
+ * This method returns a newly allocated instance the caller should dealed with by a MEDCoupling::DataArrayInt::decrRef.
+ * This method performs \b no copy of data. The content is only referenced using MEDCoupling::DataArrayInt::useArray with ownership set to \b false.
+ * 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
+ * \b nbOfCompo=1 and \bnbOfTuples==this->_nb_of_elem.
  */
-DataArrayInt *DataArrayInt::checkAndPreparePermutation() const
+DataArrayInt32 *DataArrayInt32Tuple::buildDAInt(mcIdType nbOfTuples, mcIdType nbOfCompo) const
 {
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::checkAndPreparePermutation : number of components must == 1 !");
-  mcIdType nbTuples=ToIdType(getNumberOfTuples());
-  const int *pt=getConstPointer();
-  int *pt2=CheckAndPreparePermutation(pt,pt+nbTuples);
-  DataArrayInt *ret=DataArrayInt::New();
-  ret->useArray(pt2,true,DeallocType::C_DEALLOC,nbTuples,1);
-  return ret;
-}
-
-/*!
- * This method tries to find the permutation to apply to the first input \a ids1 to obtain the same array (without considering strings information) the second
- * input array \a ids2.
- * \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.
- * 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
- * inversely.
- * In case of success both assertion will be true (no throw) :
- * \c ids1->renumber(ret)->isEqual(ids2) where \a ret is the return of this method.
- * \c ret->transformWithIndArr(ids2)->isEqual(ids1)
- *
- * \b Example:
- * - \a ids1 : [3,1,103,4,6,10,-7,205]
- * - \a ids2 : [-7,1,205,10,6,3,103,4]
- * - \a return is : [5,1,6,7,4,3,0,2] because ids2[5]==ids1[0], ids2[1]==ids1[1], ids2[6]==ids1[2]...
- *
- * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
- *          array using decrRef() as it is no more needed.
- * \throw If either ids1 or ids2 is null not allocated or not with one components.
- *
- * \sa DataArrayInt32::findIdForEach
- */
-DataArrayInt *DataArrayInt::FindPermutationFromFirstToSecond(const DataArrayInt *ids1, const DataArrayInt *ids2)
-{
-  if(!ids1 || !ids2)
-    throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays must be not null !");
-  if(!ids1->isAllocated() || !ids2->isAllocated())
-    throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays must be allocated !");
-  if(ids1->getNumberOfComponents()!=1 || ids2->getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays have exactly one component !");
-  if(ids1->getNumberOfTuples()!=ids2->getNumberOfTuples())
-    {
-      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 !";
-      throw INTERP_KERNEL::Exception(oss.str().c_str());
-    }
-  MCAuto<DataArrayInt> p1(ids1->deepCopy());
-  MCAuto<DataArrayInt> p2(ids2->deepCopy());
-  p1->sort(true); p2->sort(true);
-  if(!p1->isEqualWithoutConsideringStr(*p2))
-    throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two arrays are not lying on same ids ! Impossible to find a permutation between the 2 arrays !");
-  p1=ids1->checkAndPreparePermutation();
-  p2=ids2->checkAndPreparePermutation();
-  p2=p2->invertArrayO2N2N2O(ToIdType(p2->getNumberOfTuples()));
-  p2=p2->selectByTupleIdSafe(p1->begin(),p1->end());
-  return p2.retn();
+  return this->buildDA(nbOfTuples,nbOfCompo);
 }
 
-/*!
- * Returns two arrays describing a surjective mapping from \a this set of values (\a A)
- * onto a set of values of size \a targetNb (\a B). The surjective function is
- * \a B[ \a A[ i ]] = i. That is to say that for each \a id in [0,\a targetNb), where \a
- * targetNb < \a this->getNumberOfTuples(), there exists at least one tupleId (\a tid) so
- * that <em> this->getIJ( tid, 0 ) == id</em>. <br>
- * The first of out arrays returns indices of elements of \a this array, grouped by their
- * place in the set \a B. The second out array is the index of the first one; it shows how
- * many elements of \a A are mapped into each element of \a B. <br>
- * For more info on
- * mapping and its usage in renumbering see \ref numbering. <br>
- * \b Example:
- * - \a this: [0,3,2,3,2,2,1,2]
- * - \a targetNb: 4
- * - \a arr:  [0,  6,  2,4,5,7,  1,3]
- * - \a arrI: [0,1,2,6,8]
- *
- * This result means: <br>
- * the element of \a B 0 encounters within \a A once (\a arrI[ 0+1 ] - \a arrI[ 0 ]) and
- * its index within \a A is 0 ( \a arr[ 0:1 ] == \a arr[ \a arrI[ 0 ] : \a arrI[ 0+1 ]]);<br>
- * the element of \a B 2 encounters within \a A 4 times (\a arrI[ 2+1 ] - \a arrI[ 2 ]) and
- * its indices within \a A are [2,4,5,7] ( \a arr[ 2:6 ] == \a arr[ \a arrI[ 2 ] :
- * \a arrI[ 2+1 ]]); <br> etc.
- *  \param [in] targetNb - the size of the set \a B. \a targetNb must be equal or more
- *         than the maximal value of \a A.
- *  \param [out] arr - a new instance of DataArrayInt returning indices of
- *         elements of \a this, grouped by their place in the set \a B. The caller is to delete
- *         this array using decrRef() as it is no more needed.
- *  \param [out] arrI - a new instance of DataArrayInt returning size of groups of equal
- *         elements of \a this. The caller is to delete this array using decrRef() as it
- *         is no more needed.
- *  \throw If \a this is not allocated.
- *  \throw If \a this->getNumberOfComponents() != 1.
- *  \throw If any value in \a this is more or equal to \a targetNb.
- */
-void DataArrayInt::changeSurjectiveFormat(int targetNb, DataArrayInt *&arr, DataArrayInt *&arrI) const
+DataArrayInt64Iterator *DataArrayInt64::iterator()
 {
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : number of components must == 1 !");
-  mcIdType nbOfTuples=ToIdType(getNumberOfTuples());
-  MCAuto<DataArrayInt> ret(DataArrayInt::New());
-  MCAuto<DataArrayInt> retI(DataArrayInt::New());
-  retI->alloc(targetNb+1,1);
-  const int *input=getConstPointer();
-  std::vector< std::vector<int> > tmp(targetNb);
-  for(mcIdType i=0;i<nbOfTuples;i++)
-    {
-      int tmp2=input[i];
-      if(tmp2>=0 && tmp2<targetNb)
-        tmp[tmp2].push_back(i);
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::changeSurjectiveFormat : At pos " << i << " presence of element " << tmp2 << " ! should be in [0," << targetNb << ") !";
-          throw INTERP_KERNEL::Exception(oss.str().c_str());
-        }
-    }
-  int *retIPtr=retI->getPointer();
-  *retIPtr=0;
-  for(std::vector< std::vector<int> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++,retIPtr++)
-    retIPtr[1]=retIPtr[0]+(int)((*it1).size());
-  if(nbOfTuples!=retI->getIJ(targetNb,0))
-    throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : big problem should never happen !");
-  ret->alloc(nbOfTuples,1);
-  int *retPtr=ret->getPointer();
-  for(std::vector< std::vector<int> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++)
-    retPtr=std::copy((*it1).begin(),(*it1).end(),retPtr);
-  arr=ret.retn();
-  arrI=retI.retn();
+  return new DataArrayInt64Iterator(this);
 }
 
 
-/*!
- * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode computed
- * from a zip representation of a surjective format (returned e.g. by
- * \ref MEDCoupling::DataArrayDouble::findCommonTuples() "DataArrayDouble::findCommonTuples()"
- * for example). The result array minimizes the permutation. <br>
- * For more info on renumbering see \ref numbering. <br>
- * \b Example: <br>
- * - \a nbOfOldTuples: 10
- * - \a arr          : [0,3, 5,7,9]
- * - \a arrIBg       : [0,2,5]
- * - \a newNbOfTuples: 7
- * - result array    : [0,1,2,0,3,4,5,4,6,4]
- *
- *  \param [in] nbOfOldTuples - number of tuples in the initial array \a arr.
- *  \param [in] arr - the array of tuple indices grouped by \a arrIBg array.
- *  \param [in] arrIBg - the array dividing all indices stored in \a arr into groups of
- *         (indices of) equal values. Its every element (except the last one) points to
- *         the first element of a group of equal values.
- *  \param [in] arrIEnd - specifies the end of \a arrIBg, so that the last element of \a
- *          arrIBg is \a arrIEnd[ -1 ].
- *  \param [out] newNbOfTuples - number of tuples after surjection application.
- *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
- *          array using decrRef() as it is no more needed.
- *  \throw If any value of \a arr breaks condition ( 0 <= \a arr[ i ] < \a nbOfOldTuples ).
- */
-DataArrayInt *DataArrayInt::ConvertIndexArrayToO2N(int nbOfOldTuples, const int *arr, const int *arrIBg, const int *arrIEnd, int &newNbOfTuples)
-{
-  MCAuto<DataArrayInt> ret=DataArrayInt::New();
-  ret->alloc(nbOfOldTuples,1);
-  int *pt=ret->getPointer();
-  std::fill(pt,pt+nbOfOldTuples,-1);
-  int nbOfGrps=((int)std::distance(arrIBg,arrIEnd))-1;
-  const int *cIPtr=arrIBg;
-  for(int i=0;i<nbOfGrps;i++)
-    pt[arr[cIPtr[i]]]=-(i+2);
-  int newNb=0;
-  for(int iNode=0;iNode<nbOfOldTuples;iNode++)
-    {
-      if(pt[iNode]<0)
-        {
-          if(pt[iNode]==-1)
-            pt[iNode]=newNb++;
-          else
-            {
-              int grpId=-(pt[iNode]+2);
-              for(int j=cIPtr[grpId];j<cIPtr[grpId+1];j++)
-                {
-                  if(arr[j]>=0 && arr[j]<nbOfOldTuples)
-                    pt[arr[j]]=newNb;
-                  else
-                    {
-                      std::ostringstream oss; oss << "DataArrayInt::ConvertIndexArrayToO2N : With element #" << j << " value is " << arr[j] << " should be in [0," << nbOfOldTuples << ") !";
-                      throw INTERP_KERNEL::Exception(oss.str().c_str());
-                    }
-                }
-              newNb++;
-            }
-        }
-    }
-  newNbOfTuples=newNb;
-  return ret.retn();
+DataArrayInt64Iterator::DataArrayInt64Iterator(DataArrayInt64 *da):DataArrayIterator<Int64>(da)
+{
 }
 
-/*!
- * Returns a new DataArrayInt containing a renumbering map in "New to Old" mode,
- * which if applied to \a this array would make it sorted ascendingly.
- * For more info on renumbering see \ref numbering. <br>
- * \b Example: <br>
- * - \a this: [2,0,1,1,0,1,2,0,1,1,0,0]
- * - result: [10,0,5,6,1,7,11,2,8,9,3,4]
- * - after applying result to \a this: [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2]
- *
- *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
- *          array using decrRef() as it is no more needed.
- *  \throw If \a this is not allocated.
- *  \throw If \a this->getNumberOfComponents() != 1.
- */
-DataArrayInt *DataArrayInt::buildPermArrPerLevel() const
+DataArrayInt64Tuple::DataArrayInt64Tuple(Int64 *pt, mcIdType nbOfComp):DataArrayTuple<Int64>(pt,nbOfComp)
 {
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::buildPermArrPerLevel : number of components must == 1 !");
-  std::size_t nbOfTuples=getNumberOfTuples();
-  const int *pt=getConstPointer();
-  std::map<int,int> m;
-  MCAuto<DataArrayInt> ret=DataArrayInt::New();
-  ret->alloc(nbOfTuples,1);
-  int *opt=ret->getPointer();
-  for(std::size_t i=0;i<nbOfTuples;i++,pt++,opt++)
-    {
-      int val=*pt;
-      std::map<int,int>::iterator it=m.find(val);
-      if(it!=m.end())
-        {
-          *opt=(*it).second;
-          (*it).second++;
-        }
-      else
-        {
-          *opt=0;
-          m.insert(std::pair<int,int>(val,1));
-        }
-    }
-  int sum=0;
-  for(std::map<int,int>::iterator it=m.begin();it!=m.end();it++)
-    {
-      int vt=(*it).second;
-      (*it).second=sum;
-      sum+=vt;
-    }
-  pt=getConstPointer();
-  opt=ret->getPointer();
-  for(std::size_t i=0;i<nbOfTuples;i++,pt++,opt++)
-    *opt+=m[*pt];
-  //
-  return ret.retn();
 }
 
-/*!
- * Checks if \a this array has the given size, and if its contents is equal to an array filled with
- * iota(). This method is particularly useful for DataArrayInt instances that represent
- * a renumbering array, to check if there is a real need in renumbering.
- * This method checks than \a this can be considered as an identity mapping
- * of a set having \a sizeExpected elements into itself.
- *
- *  \param [in] sizeExpected - The number of elements expected.
- *  \return bool - \a true if \a this array contents == \a range( \a this->getNumberOfTuples())
- *  \throw If \a this is not allocated.
- *  \throw If \a this->getNumberOfComponents() != 1.
- */
-bool DataArrayInt::isIota(int sizeExpected) const
+std::string DataArrayInt64Tuple::repr() const
 {
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    return false;
-  mcIdType nbOfTuples=ToIdType(getNumberOfTuples());
-  if(nbOfTuples!=sizeExpected)
-    return false;
-  const int *pt=getConstPointer();
-  for(mcIdType i=0;i<nbOfTuples;i++,pt++)
-    if(*pt!=i)
-      return false;
-  return true;
+  std::ostringstream oss; oss << "(";
+  for(mcIdType i=0;i<_nb_of_compo-1;i++)
+    oss << _pt[i] << ", ";
+  oss << _pt[_nb_of_compo-1] << ")";
+  return oss.str();
 }
 
-/*!
- * Checks if all values in \a this array are equal to \a val.
- *  \param [in] val - value to check equality of array values to.
- *  \return bool - \a true if all values are \a val.
- *  \throw If \a this is not allocated.
- *  \throw If \a this->getNumberOfComponents() != 1
- *  \sa DataArrayInt::checkUniformAndGuess
- */
-bool DataArrayInt::isUniform(int val) const
+Int64 DataArrayInt64Tuple::intValue() const
 {
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::isUniform : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
-  const int *w(begin()),*end2(end());
-  for(;w!=end2;w++)
-    if(*w!=val)
-      return false;
-  return true;
+  return this->zeValue();
 }
 
-/*!
- * This method checks that \a this is uniform. If not and exception will be thrown.
- * In case of uniformity the corresponding value is returned.
- *
- * \return int - the unique value contained in this
- * \throw If \a this is not allocated.
- * \throw If \a this->getNumberOfComponents() != 1
- * \throw If \a this is not uniform.
- * \sa DataArrayInt::isUniform
- */
-int DataArrayInt::checkUniformAndGuess() const
+DataArrayInt64 *DataArrayInt64Tuple::buildDAInt(mcIdType nbOfTuples, mcIdType nbOfCompo) const
 {
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::checkUniformAndGuess : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
-  if(empty())
-    throw INTERP_KERNEL::Exception("DataArrayInt::checkUniformAndGuess : this is empty !");
-  const int *w(begin()),*end2(end());
-  int ret(*w);
-  for(;w!=end2;w++)
-    if(*w!=ret)
-      throw INTERP_KERNEL::Exception("DataArrayInt::checkUniformAndGuess : this is not uniform !");
-  return ret;
+  return this->buildDA(nbOfTuples,nbOfCompo);
 }
 
-/*!
- * Checks if all values in \a this array are unique.
- *  \return bool - \a true if condition above is true
- *  \throw If \a this is not allocated.
- *  \throw If \a this->getNumberOfComponents() != 1
- */
-bool DataArrayInt::hasUniqueValues() const
-{
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::hasOnlyUniqueValues: must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
-  std::size_t nbOfTuples(getNumberOfTuples());
-  std::set<int> s(begin(),end());  // in C++11, should use unordered_set (O(1) complexity)
-  if (s.size() != nbOfTuples)
-    return false;
-  return true;
-}
-
-/*!
- * Copy all components in a specified order from another DataArrayInt.
- * The specified components become the first ones in \a this array.
- * Both numerical and textual data is copied. The number of tuples in \a this and
- * the other array can be different.
- *  \param [in] a - the array to copy data from.
- *  \param [in] compoIds - sequence of zero based indices of components, data of which is
- *              to be copied.
- *  \throw If \a a is NULL.
- *  \throw If \a compoIds.size() != \a a->getNumberOfComponents().
- *  \throw If \a compoIds[i] < 0 or \a compoIds[i] > \a this->getNumberOfComponents().
- *
- *  \if ENABLE_EXAMPLES
- *  \ref py_mcdataarrayint_setselectedcomponents "Here is a Python example".
- *  \endif
- */
-void DataArrayInt::setSelectedComponents(const DataArrayInt *a, const std::vector<int>& compoIds)
-{
-  if(!a)
-    throw INTERP_KERNEL::Exception("DataArrayInt::setSelectedComponents : input DataArrayInt is NULL !");
-  checkAllocated();
-  a->checkAllocated();
-  copyPartOfStringInfoFrom2(compoIds,*a);
-  std::size_t partOfCompoSz=compoIds.size();
-  mcIdType nbOfCompo=ToIdType(getNumberOfComponents());
-  mcIdType nbOfTuples=ToIdType(std::min(getNumberOfTuples(),a->getNumberOfTuples()));
-  const int *ac=a->getConstPointer();
-  int *nc=getPointer();
-  for(mcIdType i=0;i<nbOfTuples;i++)
-    for(std::size_t j=0;j<partOfCompoSz;j++,ac++)
-      nc[nbOfCompo*i+compoIds[j]]=*ac;
-}
-
-DataArrayIntIterator *DataArrayInt::iterator()
-{
-  return new DataArrayIntIterator(this);
-}
-
-/*!
- * Creates a new DataArrayInt containing IDs (indices) of tuples holding value \b not
- * equal to a given one.
- *  \param [in] val - the value to ignore within \a this.
- *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
- *          array using decrRef() as it is no more needed.
- *  \throw If \a this is not allocated.
- *  \throw If \a this->getNumberOfComponents() != 1.
- */
-DataArrayInt *DataArrayInt::findIdsNotEqual(int val) const
-{
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::findIdsNotEqual : the array must have only one component, you can call 'rearrange' method before !");
-  const int *cptr(getConstPointer());
-  MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
-  mcIdType nbOfTuples=ToIdType(getNumberOfTuples());
-  for(mcIdType i=0;i<nbOfTuples;i++,cptr++)
-    if(*cptr!=val)
-      ret->pushBackSilent(i);
-  return ret.retn();
-}
-
-/*!
- * Creates a new DataArrayInt containing IDs (indices) of tuples holding tuple equal to those defined by [ \a tupleBg , \a tupleEnd )
- * This method is an extension of  DataArrayInt::findIdsEqual method.
- *
- *  \param [in] tupleBg - the begin (included) of the input tuple to find within \a this.
- *  \param [in] tupleEnd - the end (excluded) of the input tuple to find within \a this.
- *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
- *          array using decrRef() as it is no more needed.
- *  \throw If \a this is not allocated.
- *  \throw If \a this->getNumberOfComponents() != std::distance(tupleBg,tupleEnd).
- * \throw If \a this->getNumberOfComponents() is equal to 0.
- * \sa DataArrayInt::findIdsEqual
- */
-DataArrayInt *DataArrayInt::findIdsEqualTuple(const int *tupleBg, const int *tupleEnd) const
-{
-  mcIdType nbOfCompoExp=ToIdType(std::distance(tupleBg,tupleEnd));
-  checkAllocated();
-  if(ToIdType(getNumberOfComponents())!=nbOfCompoExp)
-    {
-      std::ostringstream oss; oss << "DataArrayInt::findIdsEqualTuple : mismatch of number of components. Input tuple has " << nbOfCompoExp << " whereas this array has " << getNumberOfComponents() << " components !";
-      throw INTERP_KERNEL::Exception(oss.str().c_str());
-    }
-  if(nbOfCompoExp==0)
-    throw INTERP_KERNEL::Exception("DataArrayInt::findIdsEqualTuple : number of components should be > 0 !");
-  MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
-  const int *bg(begin()),*end2(end()),*work(begin());
-  while(work!=end2)
-    {
-      work=std::search(work,end2,tupleBg,tupleEnd);
-      if(work!=end2)
-        {
-          mcIdType pos=ToIdType(std::distance(bg,work));
-          if(pos%nbOfCompoExp==0)
-            ret->pushBackSilent(pos/nbOfCompoExp);
-          work++;
-        }
-    }
-  return ret.retn();
-}
-
-/*!
- * This method finds for each element \a ELT in [valsBg,valsEnd) elements in \a this equal to it. Associated to ELT
- * this method will return the tuple id of last element found. If there is no element in \a this equal to ELT
- * an exception will be thrown.
- *
- * In case of success this[ret]==vals. Samely ret->transformWithIndArr(this->begin(),this->end())==vals.
- * Where \a vals is the [valsBg,valsEnd) array and \a ret the array returned by this method.
- * This method can be seen as an extension of FindPermutationFromFirstToSecond.
- * <br>
- * \b Example: <br>
- * - \a this: [17,27,2,10,-4,3,12,27,16]
- * - \a val : [3,16,-4,27,17]
- * - result: [5,8,4,7,0]
- *
- * \return - An array of size std::distance(valsBg,valsEnd)
- *
- * \sa DataArrayInt32::FindPermutationFromFirstToSecond
- */
-MCAuto<DataArrayInt32> DataArrayInt32::findIdForEach(const int *valsBg, const int *valsEnd) const
-{
-  MCAuto<DataArrayInt32> ret(DataArrayInt32::New());
-  std::size_t nbOfTuplesOut(std::distance(valsBg,valsEnd));
-  ret->alloc(nbOfTuplesOut,1);
-  MCAuto< MapKeyVal<int> > zeMap(invertArrayN2O2O2NOptimized());
-  const std::map<int,int>& dat(zeMap->data());
-  int *ptToFeed(ret->getPointer());
-  for(const int *pt=valsBg;pt!=valsEnd;pt++)
-    {
-      std::map<int,int>::const_iterator it(dat.find(*pt));
-      if(it!=dat.end())
-        *ptToFeed++=(*it).second;
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt32::findIdForEach : error for element at place " << std::distance(valsBg,pt);
-          oss << " of input array value is " << *pt << " which is not in this !";
-          throw INTERP_KERNEL::Exception(oss.str());
-        }
-    }
-  return ret;
-}
-
-/*!
- * Assigns \a newValue to all elements holding \a oldValue within \a this
- * one-dimensional array.
- *  \param [in] oldValue - the value to replace.
- *  \param [in] newValue - the value to assign.
- *  \return int - number of replacements performed.
- *  \throw If \a this is not allocated.
- *  \throw If \a this->getNumberOfComponents() != 1.
- */
-int DataArrayInt::changeValue(int oldValue, int newValue)
-{
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::changeValue : the array must have only one component, you can call 'rearrange' method before !");
-  if(oldValue==newValue)
-    return 0;
-  int *start(getPointer()),*end2(start+getNbOfElems());
-  int ret(0);
-  for(int *val=start;val!=end2;val++)
-    {
-      if(*val==oldValue)
-        {
-          *val=newValue;
-          ret++;
-        }
-    }
-  if(ret>0)
-    declareAsNew();
-  return ret;
-}
-
-/*!
- * Creates a new DataArrayInt containing IDs (indices) of tuples holding value equal to
- * one of given values.
- *  \param [in] valsBg - an array of values to find within \a this array.
- *  \param [in] valsEnd - specifies the end of the array \a valsBg, so that
- *              the last value of \a valsBg is \a valsEnd[ -1 ].
- *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
- *          array using decrRef() as it is no more needed.
- *  \throw If \a this->getNumberOfComponents() != 1.
- */
-DataArrayInt *DataArrayInt::findIdsEqualList(const int *valsBg, const int *valsEnd) const
-{
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::findIdsEqualList : the array must have only one component, you can call 'rearrange' method before !");
-  std::set<int> vals2(valsBg,valsEnd);
-  const int *cptr(getConstPointer());
-  std::vector<int> res;
-  mcIdType nbOfTuples=ToIdType(getNumberOfTuples());
-  MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
-  for(mcIdType i=0;i<nbOfTuples;i++,cptr++)
-    if(vals2.find(*cptr)!=vals2.end())
-      ret->pushBackSilent(i);
-  return ret.retn();
-}
-
-/*!
- * Creates a new DataArrayInt containing IDs (indices) of tuples holding values \b not
- * equal to any of given values.
- *  \param [in] valsBg - an array of values to ignore within \a this array.
- *  \param [in] valsEnd - specifies the end of the array \a valsBg, so that
- *              the last value of \a valsBg is \a valsEnd[ -1 ].
- *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
- *          array using decrRef() as it is no more needed.
- *  \throw If \a this->getNumberOfComponents() != 1.
- */
-DataArrayInt *DataArrayInt::findIdsNotEqualList(const int *valsBg, const int *valsEnd) const
-{
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::findIdsNotEqualList : the array must have only one component, you can call 'rearrange' method before !");
-  std::set<int> vals2(valsBg,valsEnd);
-  const int *cptr=getConstPointer();
-  std::vector<int> res;
-  mcIdType nbOfTuples=ToIdType(getNumberOfTuples());
-  MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
-  for(mcIdType i=0;i<nbOfTuples;i++,cptr++)
-    if(vals2.find(*cptr)==vals2.end())
-      ret->pushBackSilent(i);
-  return ret.retn();
-}
-
-/*!
- * This method is an extension of DataArrayInt::findIdFirstEqual method because this method works for DataArrayInt with
- * any number of components excepted 0 (an INTERP_KERNEL::Exception is thrown in this case).
- * This method searches in \b this is there is a tuple that matched the input parameter \b tupl.
- * If any the tuple id is returned. If not -1 is returned.
- *
- * This method throws an INTERP_KERNEL::Exception if the number of components in \b this mismatches with the size of
- * the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
- *
- * \return tuple id where \b tupl is. -1 if no such tuple exists in \b this.
- * \sa DataArrayInt::findIdSequence, DataArrayInt::presenceOfTuple.
- */
-int DataArrayInt::findIdFirstEqualTuple(const std::vector<int>& tupl) const
-{
-  checkAllocated();
-  mcIdType nbOfCompo=ToIdType(getNumberOfComponents());
-  if(nbOfCompo==0)
-    throw INTERP_KERNEL::Exception("DataArrayInt::findIdFirstEqualTuple : 0 components in 'this' !");
-  if(nbOfCompo!=ToIdType(tupl.size()))
-    {
-      std::ostringstream oss; oss << "DataArrayInt::findIdFirstEqualTuple : 'this' contains " << nbOfCompo << " components and searching for a tuple of length " << tupl.size() << " !";
-      throw INTERP_KERNEL::Exception(oss.str().c_str());
-    }
-  const int *cptr=getConstPointer();
-  std::size_t nbOfVals=getNbOfElems();
-  for(const int *work=cptr;work!=cptr+nbOfVals;)
-    {
-      work=std::search(work,cptr+nbOfVals,tupl.begin(),tupl.end());
-      if(work!=cptr+nbOfVals)
-        {
-          if(std::distance(cptr,work)%nbOfCompo!=0)
-            work++;
-          else
-            return ToIdType (std::distance(cptr,work)/nbOfCompo);
-        }
-    }
-  return -1;
-}
-
-/*!
- * This method searches the sequence specified in input parameter \b vals in \b this.
- * This works only for DataArrayInt having number of components equal to one (if not an INTERP_KERNEL::Exception will be thrown).
- * This method differs from DataArrayInt::findIdFirstEqualTuple in that the position is internal raw data is not considered here contrary to DataArrayInt::findIdFirstEqualTuple.
- * \sa DataArrayInt::findIdFirstEqualTuple
- */
-int DataArrayInt::findIdSequence(const std::vector<int>& vals) const
-{
-  checkAllocated();
-  std::size_t nbOfCompo=getNumberOfComponents();
-  if(nbOfCompo!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::findIdSequence : works only for DataArrayInt instance with one component !");
-  const int *cptr=getConstPointer();
-  std::size_t nbOfVals=getNbOfElems();
-  const int *loc=std::search(cptr,cptr+nbOfVals,vals.begin(),vals.end());
-  if(loc!=cptr+nbOfVals)
-    return ToIdType(std::distance(cptr,loc));
-  return -1;
-}
-
-/*!
- * This method expects to be called when number of components of this is equal to one.
- * This method returns the tuple id, if it exists, of the first tuple equal to \b value.
- * If not any tuple contains \b value -1 is returned.
- * \sa DataArrayInt::presenceOfValue
- */
-int DataArrayInt::findIdFirstEqual(int value) const
-{
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::presenceOfValue : the array must have only one component, you can call 'rearrange' method before !");
-  const int *cptr=getConstPointer();
-  mcIdType nbOfTuples=ToIdType(getNumberOfTuples());
-  const int *ret=std::find(cptr,cptr+nbOfTuples,value);
-  if(ret!=cptr+nbOfTuples)
-    return ToIdType(std::distance(cptr,ret));
-  return -1;
-}
-
-/*!
- * This method expects to be called when number of components of this is equal to one.
- * This method returns the tuple id, if it exists, of the first tuple so that the value is contained in \b vals.
- * If not any tuple contains one of the values contained in 'vals' -1 is returned.
- * \sa DataArrayInt::presenceOfValue
- */
-int DataArrayInt::findIdFirstEqual(const std::vector<int>& vals) const
-{
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::presenceOfValue : the array must have only one component, you can call 'rearrange' method before !");
-  std::set<int> vals2(vals.begin(),vals.end());
-  const int *cptr=getConstPointer();
-  mcIdType nbOfTuples=ToIdType(getNumberOfTuples());
-  for(const int *w=cptr;w!=cptr+nbOfTuples;w++)
-    if(vals2.find(*w)!=vals2.end())
-      return ToIdType(std::distance(cptr,w));
-  return -1;
-}
-
-/*!
- * This method returns the number of values in \a this that are equals to input parameter \a value.
- * This method only works for single component array.
- *
- * \return a value in [ 0, \c this->getNumberOfTuples() )
- *
- * \throw If \a this is not allocated
- *
- */
-int DataArrayInt::count(int value) const
-{
-  int ret=0;
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::count : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
-  const int *vals=begin();
-  std::size_t nbOfTuples=getNumberOfTuples();
-  for(std::size_t i=0;i<nbOfTuples;i++,vals++)
-    if(*vals==value)
-      ret++;
-  return ret;
-}
-
-/*!
- * This method is an extension of DataArrayInt::presenceOfValue method because this method works for DataArrayInt with
- * any number of components excepted 0 (an INTERP_KERNEL::Exception is thrown in this case).
- * This method searches in \b this is there is a tuple that matched the input parameter \b tupl.
- * This method throws an INTERP_KERNEL::Exception if the number of components in \b this mismatches with the size of
- * the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
- * \sa DataArrayInt::findIdFirstEqualTuple
- */
-bool DataArrayInt::presenceOfTuple(const std::vector<int>& tupl) const
-{
-  return findIdFirstEqualTuple(tupl)!=-1;
-}
-
-
-/*!
- * Returns \a true if a given value is present within \a this one-dimensional array.
- *  \param [in] value - the value to find within \a this array.
- *  \return bool - \a true in case if \a value is present within \a this array.
- *  \throw If \a this is not allocated.
- *  \throw If \a this->getNumberOfComponents() != 1.
- *  \sa findIdFirstEqual()
- */
-bool DataArrayInt::presenceOfValue(int value) const
-{
-  return findIdFirstEqual(value)!=-1;
-}
-
-/*!
- * This method expects to be called when number of components of this is equal to one.
- * This method returns true if it exists a tuple so that the value is contained in \b vals.
- * If not any tuple contains one of the values contained in 'vals' false is returned.
- * \sa DataArrayInt::findIdFirstEqual
- */
-bool DataArrayInt::presenceOfValue(const std::vector<int>& vals) const
-{
-  return findIdFirstEqual(vals)!=-1;
-}
-
-/*!
- * Accumulates values of each component of \a this array.
- *  \param [out] res - an array of length \a this->getNumberOfComponents(), allocated
- *         by the caller, that is filled by this method with sum value for each
- *         component.
- *  \throw If \a this is not allocated.
- */
-void DataArrayInt::accumulate(int *res) const
-{
-  checkAllocated();
-  const int *ptr=getConstPointer();
-  mcIdType nbTuple=ToIdType(getNumberOfTuples());
-  mcIdType nbComps=ToIdType(getNumberOfComponents());
-  std::fill(res,res+nbComps,0);
-  for(mcIdType i=0;i<nbTuple;i++)
-    std::transform(ptr+i*nbComps,ptr+(i+1)*nbComps,res,res,std::plus<int>());
-}
-
-int DataArrayInt::accumulate(int compId) const
-{
-  checkAllocated();
-  const int *ptr=getConstPointer();
-  mcIdType nbTuple=ToIdType(getNumberOfTuples());
-  mcIdType nbComps=ToIdType(getNumberOfComponents());
-  if(compId<0 || compId>=nbComps)
-    throw INTERP_KERNEL::Exception("DataArrayInt::accumulate : Invalid compId specified : No such nb of components !");
-  int ret=0;
-  for(mcIdType i=0;i<nbTuple;i++)
-    ret+=ptr[i*nbComps+compId];
-  return ret;
-}
-
-/*!
- * This method accumulate using addition tuples in \a this using input index array [ \a bgOfIndex, \a endOfIndex ).
- * The returned array will have same number of components than \a this and number of tuples equal to
- * \c std::distance(bgOfIndex,endOfIndex) \b minus \b one.
- *
- * The input index array is expected to be ascendingly sorted in which the all referenced ids should be in [0, \c this->getNumberOfTuples).
- *
- * \param [in] bgOfIndex - begin (included) of the input index array.
- * \param [in] endOfIndex - end (excluded) of the input index array.
- * \return DataArrayInt * - the new instance having the same number of components than \a this.
- *
- * \throw If bgOfIndex or end is NULL.
- * \throw If input index array is not ascendingly sorted.
- * \throw If there is an id in [ \a bgOfIndex, \a endOfIndex ) not in [0, \c this->getNumberOfTuples).
- * \throw If std::distance(bgOfIndex,endOfIndex)==0.
- */
-DataArrayInt *DataArrayInt::accumulatePerChunck(const int *bgOfIndex, const int *endOfIndex) const
-{
-  if(!bgOfIndex || !endOfIndex)
-    throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : input pointer NULL !");
-  checkAllocated();
-  mcIdType nbCompo=ToIdType(getNumberOfComponents());
-  mcIdType nbOfTuples=ToIdType(getNumberOfTuples());
-  int sz=(int)std::distance(bgOfIndex,endOfIndex);
-  if(sz<1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : invalid size of input index array !");
-  sz--;
-  MCAuto<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(sz,nbCompo);
-  const int *w=bgOfIndex;
-  if(*w<0 || *w>=nbOfTuples)
-    throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : The first element of the input index not in [0,nbOfTuples) !");
-  const int *srcPt=begin()+(*w)*nbCompo;
-  int *tmp=ret->getPointer();
-  for(mcIdType i=0;i<sz;i++,tmp+=nbCompo,w++)
-    {
-      std::fill(tmp,tmp+nbCompo,0);
-      if(w[1]>=w[0])
-        {
-          for(mcIdType j=w[0];j<w[1];j++,srcPt+=nbCompo)
-            {
-              if(j>=0 && j<nbOfTuples)
-                std::transform(srcPt,srcPt+nbCompo,tmp,tmp,std::plus<int>());
-              else
-                {
-                  std::ostringstream oss; oss << "DataArrayInt::accumulatePerChunck : At rank #" << i << " the input index array points to id " << j << " should be in [0," << nbOfTuples << ") !";
-                  throw INTERP_KERNEL::Exception(oss.str().c_str());
-                }
-            }
-        }
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::accumulatePerChunck : At rank #" << i << " the input index array is not in ascendingly sorted.";
-          throw INTERP_KERNEL::Exception(oss.str().c_str());
-        }
-    }
-  ret->copyStringInfoFrom(*this);
-  return ret.retn();
-}
-
-/*!
- * Returns a new DataArrayInt by concatenating two given arrays, so that (1) the number
- * of tuples in the result array is <em> a1->getNumberOfTuples() + a2->getNumberOfTuples() -
- * offsetA2</em> and (2)
- * the number of component in the result array is same as that of each of given arrays.
- * First \a offsetA2 tuples of \a a2 are skipped and thus are missing from the result array.
- * Info on components is copied from the first of the given arrays. Number of components
- * in the given arrays must be the same.
- *  \param [in] a1 - an array to include in the result array.
- *  \param [in] a2 - another array to include in the result array.
- *  \param [in] offsetA2 - number of tuples of \a a2 to skip.
- *  \return DataArrayInt * - the new instance of DataArrayInt.
- *          The caller is to delete this result array using decrRef() as it is no more
- *          needed.
- *  \throw If either \a a1 or \a a2 is NULL.
- *  \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents().
- */
-DataArrayInt *DataArrayInt::Aggregate(const DataArrayInt *a1, const DataArrayInt *a2, int offsetA2)
-{
-  if(!a1 || !a2)
-    throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : input DataArrayInt instance is NULL !");
-  std::size_t nbOfComp(a1->getNumberOfComponents());
-  if(nbOfComp!=a2->getNumberOfComponents())
-    throw INTERP_KERNEL::Exception("Nb of components mismatch for array Aggregation !");
-  std::size_t nbOfTuple1(a1->getNumberOfTuples()),nbOfTuple2(a2->getNumberOfTuples());
-  MCAuto<DataArrayInt> ret(DataArrayInt::New());
-  ret->alloc(nbOfTuple1+nbOfTuple2-offsetA2,nbOfComp);
-  int *pt=std::copy(a1->begin(),a1->end(),ret->getPointer());
-  std::copy(a2->getConstPointer()+offsetA2*nbOfComp,a2->getConstPointer()+nbOfTuple2*nbOfComp,pt);
-  ret->copyStringInfoFrom(*a1);
-  return ret.retn();
-}
-
-/*!
- * Returns a new DataArrayInt by concatenating all given arrays, so that (1) the number
- * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
- * the number of component in the result array is same as that of each of given arrays.
- * Info on components is copied from the first of the given arrays. Number of components
- * in the given arrays must be  the same.
- * If the number of non null of elements in \a arr is equal to one the returned object is a copy of it
- * not the object itself.
- *  \param [in] arr - a sequence of arrays to include in the result array.
- *  \return DataArrayInt * - the new instance of DataArrayInt.
- *          The caller is to delete this result array using decrRef() as it is no more
- *          needed.
- *  \throw If all arrays within \a arr are NULL.
- *  \throw If getNumberOfComponents() of arrays within \a arr.
- */
-DataArrayInt *DataArrayInt::Aggregate(const std::vector<const DataArrayInt *>& arr)
-{
-  std::vector<const DataArrayInt *> a;
-  for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
-    if(*it4)
-      a.push_back(*it4);
-  if(a.empty())
-    throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : input list must be NON EMPTY !");
-  std::vector<const DataArrayInt *>::const_iterator it=a.begin();
-  std::size_t nbOfComp((*it)->getNumberOfComponents()),nbt((*it++)->getNumberOfTuples());
-  for(int i=1;it!=a.end();it++,i++)
-    {
-      if((*it)->getNumberOfComponents()!=nbOfComp)
-        throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : Nb of components mismatch for array aggregation !");
-      nbt+=(*it)->getNumberOfTuples();
-    }
-  MCAuto<DataArrayInt> ret=DataArrayInt::New();
-  ret->alloc(nbt,nbOfComp);
-  int *pt=ret->getPointer();
-  for(it=a.begin();it!=a.end();it++)
-    pt=std::copy((*it)->getConstPointer(),(*it)->getConstPointer()+(*it)->getNbOfElems(),pt);
-  ret->copyStringInfoFrom(*(a[0]));
-  return ret.retn();
-}
-
-/*!
- * This method takes as input a list of DataArrayInt instances \a arrs that represent each a packed index arrays.
- * A packed index array is an allocated array with one component, and at least one tuple. The first element
- * of each array in \a arrs must be 0. Each array in \a arrs is expected to be increasingly monotonic.
- * 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.
- *
- * \return DataArrayInt * - a new object to be managed by the caller.
- */
-DataArrayInt *DataArrayInt::AggregateIndexes(const std::vector<const DataArrayInt *>& arrs)
-{
-  int retSz=1;
-  for(std::vector<const DataArrayInt *>::const_iterator it4=arrs.begin();it4!=arrs.end();it4++)
-    {
-      if(*it4)
-        {
-          (*it4)->checkAllocated();
-          if((*it4)->getNumberOfComponents()!=1)
-            {
-              std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with nb of compo != 1 at pos " << std::distance(arrs.begin(),it4) << " !";
-              throw INTERP_KERNEL::Exception(oss.str().c_str());
-            }
-          mcIdType nbTupl=ToIdType((*it4)->getNumberOfTuples());
-          if(nbTupl<1)
-            {
-              std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with nb of tuples < 1 at pos " << std::distance(arrs.begin(),it4) << " !";
-              throw INTERP_KERNEL::Exception(oss.str().c_str());
-            }
-          if((*it4)->front()!=0)
-            {
-              std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with front value != 0 at pos " << std::distance(arrs.begin(),it4) << " !";
-              throw INTERP_KERNEL::Exception(oss.str().c_str());
-            }
-          retSz+=nbTupl-1;
-        }
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a null instance at pos " << std::distance(arrs.begin(),it4) << " !";
-          throw INTERP_KERNEL::Exception(oss.str().c_str());
-        }
-    }
-  if(arrs.empty())
-    throw INTERP_KERNEL::Exception("DataArrayInt::AggregateIndexes : input list must be NON EMPTY !");
-  MCAuto<DataArrayInt> ret=DataArrayInt::New();
-  ret->alloc(retSz,1);
-  int *pt=ret->getPointer(); *pt++=0;
-  for(std::vector<const DataArrayInt *>::const_iterator it=arrs.begin();it!=arrs.end();it++)
-    pt=std::transform((*it)->begin()+1,(*it)->end(),pt,std::bind2nd(std::plus<int>(),pt[-1]));
-  ret->copyStringInfoFrom(*(arrs[0]));
-  return ret.retn();
-}
-
-/*!
- * Returns in a single walk in \a this the min value and the max value in \a this.
- * \a this is expected to be single component array.
- *
- * \param [out] minValue - the min value in \a this.
- * \param [out] maxValue - the max value in \a this.
- *
- * \sa getMinValueInArray, getMinValue, getMaxValueInArray, getMaxValue
- */
-void DataArrayInt::getMinMaxValues(int& minValue, int& maxValue) const
-{
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::getMinMaxValues : must be applied on DataArrayInt with only one component !");
-  std::size_t nbTuples(getNumberOfTuples());
-  const int *pt(begin());
-  minValue=std::numeric_limits<int>::max(); maxValue=-std::numeric_limits<int>::max();
-  for(std::size_t i=0;i<nbTuples;i++,pt++)
-    {
-      if(*pt<minValue)
-        minValue=*pt;
-      if(*pt>maxValue)
-        maxValue=*pt;
-    }
-}
-
-/*!
- * Modify all elements of \a this array, so that
- * an element _x_ becomes \f$ numerator / x \f$.
- *  \warning If an exception is thrown because of presence of 0 element in \a this
- *           array, all elements processed before detection of the zero element remain
- *           modified.
- *  \param [in] numerator - the numerator used to modify array elements.
- *  \throw If \a this is not allocated.
- *  \throw If there is an element equal to 0 in \a this array.
- */
-void DataArrayInt::applyInv(int numerator)
-{
-  checkAllocated();
-  int *ptr=getPointer();
-  std::size_t nbOfElems=getNbOfElems();
-  for(std::size_t i=0;i<nbOfElems;i++,ptr++)
-    {
-      if(*ptr!=0)
-        {
-          *ptr=numerator/(*ptr);
-        }
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::applyInv : presence of null value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
-          oss << " !";
-          throw INTERP_KERNEL::Exception(oss.str().c_str());
-        }
-    }
-  declareAsNew();
-}
-
-/*!
- * Modify all elements of \a this array, so that
- * an element _x_ becomes \f$ x / val \f$.
- *  \param [in] val - the denominator used to modify array elements.
- *  \throw If \a this is not allocated.
- *  \throw If \a val == 0.
- */
-void DataArrayInt::applyDivideBy(int val)
-{
-  if(val==0)
-    throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to divide by 0 !");
-  checkAllocated();
-  int *ptr=getPointer();
-  std::size_t nbOfElems=getNbOfElems();
-  std::transform(ptr,ptr+nbOfElems,ptr,std::bind2nd(std::divides<int>(),val));
-  declareAsNew();
-}
-
-/*!
- * Modify all elements of \a this array, so that
- * an element _x_ becomes  <em> x % val </em>.
- *  \param [in] val - the divisor used to modify array elements.
- *  \throw If \a this is not allocated.
- *  \throw If \a val <= 0.
- */
-void DataArrayInt::applyModulus(int val)
-{
-  if(val<=0)
-    throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to operate modulus on value <= 0 !");
-  checkAllocated();
-  int *ptr=getPointer();
-  std::size_t nbOfElems=getNbOfElems();
-  std::transform(ptr,ptr+nbOfElems,ptr,std::bind2nd(std::modulus<int>(),val));
-  declareAsNew();
-}
-
-/*!
- * This method works only on data array with one component.
- * This method returns a newly allocated array storing stored ascendantly tuple ids in \b this so that
- * this[*id] in [\b vmin,\b vmax)
- *
- * \param [in] vmin begin of range. This value is included in range (included).
- * \param [in] vmax end of range. This value is \b not included in range (excluded).
- * \return a newly allocated data array that the caller should deal with.
- *
- * \sa DataArrayInt::findIdsNotInRange , DataArrayInt::findIdsStricltyNegative
- */
-DataArrayInt *DataArrayInt::findIdsInRange(int vmin, int vmax) const
-{
-  InRange<int> ir(vmin,vmax);
-  MCAuto<DataArrayInt> ret(findIdsAdv(ir));
-  return ret.retn();
-}
-
-/*!
- * This method works only on data array with one component.
- * This method returns a newly allocated array storing stored ascendantly tuple ids in \b this so that
- * this[*id] \b not in [\b vmin,\b vmax)
- *
- * \param [in] vmin begin of range. This value is \b not included in range (excluded).
- * \param [in] vmax end of range. This value is included in range (included).
- * \return a newly allocated data array that the caller should deal with.
- *
- * \sa DataArrayInt::findIdsInRange , DataArrayInt::findIdsStricltyNegative
- */
-DataArrayInt *DataArrayInt::findIdsNotInRange(int vmin, int vmax) const
-{
-  NotInRange<int> nir(vmin,vmax);
-  MCAuto<DataArrayInt> ret(findIdsAdv(nir));
-  return ret.retn();
-}
-
-/*!
- * This method works only on data array with one component.
- * 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.
- *
- * \param [in] vmin begin of range. This value is included in range (included).
- * \param [in] vmax end of range. This value is \b not included in range (excluded).
- * \return if all ids in \a this are so that (*this)[i]==i for all i in [ 0, \c this->getNumberOfTuples() ). */
-bool DataArrayInt::checkAllIdsInRange(int vmin, int vmax) const
-{
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::checkAllIdsInRange : this must have exactly one component !");
-  mcIdType nbOfTuples=ToIdType(getNumberOfTuples());
-  bool ret=true;
-  const int *cptr=getConstPointer();
-  for(mcIdType i=0;i<nbOfTuples;i++,cptr++)
-    {
-      if(*cptr>=vmin && *cptr<vmax)
-        { ret=ret && *cptr==i; }
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::checkAllIdsInRange : tuple #" << i << " has value " << *cptr << " should be in [" << vmin << "," << vmax << ") !";
-          throw INTERP_KERNEL::Exception(oss.str().c_str());
-        }
-    }
-  return ret;
-}
-
-/*!
- * Modify all elements of \a this array, so that
- * an element _x_ becomes <em> val % x </em>.
- *  \warning If an exception is thrown because of presence of an element <= 0 in \a this
- *           array, all elements processed before detection of the zero element remain
- *           modified.
- *  \param [in] val - the divident used to modify array elements.
- *  \throw If \a this is not allocated.
- *  \throw If there is an element equal to or less than 0 in \a this array.
- */
-void DataArrayInt::applyRModulus(int val)
-{
-  checkAllocated();
-  int *ptr=getPointer();
-  std::size_t nbOfElems=getNbOfElems();
-  for(std::size_t i=0;i<nbOfElems;i++,ptr++)
-    {
-      if(*ptr>0)
-        {
-          *ptr=val%(*ptr);
-        }
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::applyRModulus : presence of value <=0 in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
-          oss << " !";
-          throw INTERP_KERNEL::Exception(oss.str().c_str());
-        }
-    }
-  declareAsNew();
-}
-
-/*!
- * Modify all elements of \a this array, so that
- * an element _x_ becomes <em> val ^ x </em>.
- *  \param [in] val - the value used to apply pow on all array elements.
- *  \throw If \a this is not allocated.
- *  \throw If \a val < 0.
- */
-void DataArrayInt::applyPow(int val)
-{
-  checkAllocated();
-  if(val<0)
-    throw INTERP_KERNEL::Exception("DataArrayInt::applyPow : input pow in < 0 !");
-  int *ptr=getPointer();
-  std::size_t nbOfElems=getNbOfElems();
-  if(val==0)
-    {
-      std::fill(ptr,ptr+nbOfElems,1);
-      return ;
-    }
-  for(std::size_t i=0;i<nbOfElems;i++,ptr++)
-    {
-      int tmp=1;
-      for(int j=0;j<val;j++)
-        tmp*=*ptr;
-      *ptr=tmp;
-    }
-  declareAsNew();
-}
-
-/*!
- * Modify all elements of \a this array, so that
- * an element _x_ becomes \f$ val ^ x \f$.
- *  \param [in] val - the value used to apply pow on all array elements.
- *  \throw If \a this is not allocated.
- *  \throw If there is an element < 0 in \a this array.
- *  \warning If an exception is thrown because of presence of 0 element in \a this
- *           array, all elements processed before detection of the zero element remain
- *           modified.
- */
-void DataArrayInt::applyRPow(int val)
-{
-  checkAllocated();
-  int *ptr=getPointer();
-  std::size_t nbOfElems=getNbOfElems();
-  for(std::size_t i=0;i<nbOfElems;i++,ptr++)
-    {
-      if(*ptr>=0)
-        {
-          int tmp=1;
-          for(int j=0;j<*ptr;j++)
-            tmp*=val;
-          *ptr=tmp;
-        }
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::applyRPow : presence of negative value in tuple #" << i/getNumberOfComponents() << " component #" << i%getNumberOfComponents();
-          oss << " !";
-          throw INTERP_KERNEL::Exception(oss.str().c_str());
-        }
-    }
-  declareAsNew();
-}
-
-/*!
- * Returns a new DataArrayInt which is a minimal partition of elements of \a groups.
- * The i-th item of the result array is an ID of a set of elements belonging to a
- * unique set of groups, which the i-th element is a part of. This set of elements
- * belonging to a unique set of groups is called \a family, so the result array contains
- * IDs of families each element belongs to.
- *
- * \b Example: if we have two groups of elements: \a group1 [0,4] and \a group2 [ 0,1,2 ],
- * then there are 3 families:
- * - \a family1 (with ID 1) contains element [0] belonging to ( \a group1 + \a group2 ),
- * - \a family2 (with ID 2) contains elements [4] belonging to ( \a group1 ),
- * - \a family3 (with ID 3) contains element [1,2] belonging to ( \a group2 ), <br>
- * and the result array contains IDs of families [ 1,3,3,0,2 ]. <br> Note a family ID 0 which
- * stands for the element #3 which is in none of groups.
- *
- *  \param [in] groups - sequence of groups of element IDs.
- *  \param [in] newNb - total number of elements; it must be more than max ID of element
- *         in \a groups.
- *  \param [out] fidsOfGroups - IDs of families the elements of each group belong to.
- *  \return DataArrayInt * - a new instance of DataArrayInt containing IDs of families
- *         each element with ID from range [0, \a newNb ) belongs to. The caller is to
- *         delete this array using decrRef() as it is no more needed.
- *  \throw If any element ID in \a groups violates condition ( 0 <= ID < \a newNb ).
- */
-DataArrayInt *DataArrayInt::MakePartition(const std::vector<const DataArrayInt *>& groups, int newNb, std::vector< std::vector<int> >& fidsOfGroups)
-{
-  std::vector<const DataArrayInt *> groups2;
-  for(std::vector<const DataArrayInt *>::const_iterator it4=groups.begin();it4!=groups.end();it4++)
-    if(*it4)
-      groups2.push_back(*it4);
-  MCAuto<DataArrayInt> ret=DataArrayInt::New();
-  ret->alloc(newNb,1);
-  int *retPtr=ret->getPointer();
-  std::fill(retPtr,retPtr+newNb,0);
-  int fid=1;
-  for(std::vector<const DataArrayInt *>::const_iterator iter=groups2.begin();iter!=groups2.end();iter++)
-    {
-      const int *ptr=(*iter)->getConstPointer();
-      std::size_t nbOfElem=(*iter)->getNbOfElems();
-      int sfid=fid;
-      for(int j=0;j<sfid;j++)
-        {
-          bool found=false;
-          for(std::size_t i=0;i<nbOfElem;i++)
-            {
-              if(ptr[i]>=0 && ptr[i]<newNb)
-                {
-                  if(retPtr[ptr[i]]==j)
-                    {
-                      retPtr[ptr[i]]=fid;
-                      found=true;
-                    }
-                }
-              else
-                {
-                  std::ostringstream oss; oss << "DataArrayInt::MakePartition : In group \"" << (*iter)->getName() << "\" in tuple #" << i << " value = " << ptr[i] << " ! Should be in [0," << newNb;
-                  oss << ") !";
-                  throw INTERP_KERNEL::Exception(oss.str().c_str());
-                }
-            }
-          if(found)
-            fid++;
-        }
-    }
-  fidsOfGroups.clear();
-  fidsOfGroups.resize(groups2.size());
-  int grId=0;
-  for(std::vector<const DataArrayInt *>::const_iterator iter=groups2.begin();iter!=groups2.end();iter++,grId++)
-    {
-      std::set<int> tmp;
-      const int *ptr=(*iter)->getConstPointer();
-      std::size_t nbOfElem=(*iter)->getNbOfElems();
-      for(const int *p=ptr;p!=ptr+nbOfElem;p++)
-        tmp.insert(retPtr[*p]);
-      fidsOfGroups[grId].insert(fidsOfGroups[grId].end(),tmp.begin(),tmp.end());
-    }
-  return ret.retn();
-}
-
-/*!
- * Returns a new DataArrayInt which contains all elements of given one-dimensional
- * arrays. The result array does not contain any duplicates and its values
- * are sorted in ascending order.
- *  \param [in] arr - sequence of DataArrayInt's to unite.
- *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
- *         array using decrRef() as it is no more needed.
- *  \throw If any \a arr[i] is not allocated.
- *  \throw If \a arr[i]->getNumberOfComponents() != 1.
- */
-DataArrayInt *DataArrayInt::BuildUnion(const std::vector<const DataArrayInt *>& arr)
-{
-  std::vector<const DataArrayInt *> a;
-  for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
-    if(*it4)
-      a.push_back(*it4);
-  for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
-    {
-      (*it)->checkAllocated();
-      if((*it)->getNumberOfComponents()!=1)
-        throw INTERP_KERNEL::Exception("DataArrayInt::BuildUnion : only single component allowed !");
-    }
-  //
-  std::set<int> r;
-  for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
-    {
-      const int *pt=(*it)->getConstPointer();
-      mcIdType nbOfTuples=ToIdType((*it)->getNumberOfTuples());
-      r.insert(pt,pt+nbOfTuples);
-    }
-  DataArrayInt *ret=DataArrayInt::New();
-  ret->alloc((int)r.size(),1);
-  std::copy(r.begin(),r.end(),ret->getPointer());
-  return ret;
-}
-
-/*!
- * Returns a new DataArrayInt which contains elements present in each of given one-dimensional
- * arrays. The result array does not contain any duplicates and its values
- * are sorted in ascending order.
- *  \param [in] arr - sequence of DataArrayInt's to intersect.
- *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
- *         array using decrRef() as it is no more needed.
- *  \throw If any \a arr[i] is not allocated.
- *  \throw If \a arr[i]->getNumberOfComponents() != 1.
- */
-DataArrayInt *DataArrayInt::BuildIntersection(const std::vector<const DataArrayInt *>& arr)
-{
-  std::vector<const DataArrayInt *> a;
-  for(std::vector<const DataArrayInt *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
-    if(*it4)
-      a.push_back(*it4);
-  for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
-    {
-      (*it)->checkAllocated();
-      if((*it)->getNumberOfComponents()!=1)
-        throw INTERP_KERNEL::Exception("DataArrayInt::BuildIntersection : only single component allowed !");
-    }
-  //
-  std::set<int> r;
-  for(std::vector<const DataArrayInt *>::const_iterator it=a.begin();it!=a.end();it++)
-    {
-      const int *pt=(*it)->getConstPointer();
-      mcIdType nbOfTuples=ToIdType((*it)->getNumberOfTuples());
-      std::set<int> s1(pt,pt+nbOfTuples);
-      if(it!=a.begin())
-        {
-          std::set<int> r2;
-          std::set_intersection(r.begin(),r.end(),s1.begin(),s1.end(),inserter(r2,r2.end()));
-          r=r2;
-        }
-      else
-        r=s1;
-    }
-  DataArrayInt *ret(DataArrayInt::New());
-  ret->alloc((int)r.size(),1);
-  std::copy(r.begin(),r.end(),ret->getPointer());
-  return ret;
-}
-
-/// @cond INTERNAL
-namespace MEDCouplingImpl
-{
-  class OpSwitchedOn
-  {
-  public:
-    OpSwitchedOn(int *pt):_pt(pt),_cnt(0) { }
-    void operator()(const bool& b) { if(b) *_pt++=_cnt; _cnt++; }
-  private:
-    int *_pt;
-    int _cnt;
-  };
-
-  class OpSwitchedOff
-  {
-  public:
-    OpSwitchedOff(int *pt):_pt(pt),_cnt(0) { }
-    void operator()(const bool& b) { if(!b) *_pt++=_cnt; _cnt++; }
-  private:
-    int *_pt;
-    int _cnt;
-  };
-}
-/// @endcond
-
-/*!
- * This method returns the list of ids in ascending mode so that v[id]==true.
- */
-DataArrayInt *DataArrayInt::BuildListOfSwitchedOn(const std::vector<bool>& v)
-{
-  int sz((int)std::count(v.begin(),v.end(),true));
-  MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
-  std::for_each(v.begin(),v.end(),MEDCouplingImpl::OpSwitchedOn(ret->getPointer()));
-  return ret.retn();
-}
-
-/*!
- * This method returns the list of ids in ascending mode so that v[id]==false.
- */
-DataArrayInt *DataArrayInt::BuildListOfSwitchedOff(const std::vector<bool>& v)
-{
-  int sz((int)std::count(v.begin(),v.end(),false));
-  MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
-  std::for_each(v.begin(),v.end(),MEDCouplingImpl::OpSwitchedOff(ret->getPointer()));
-  return ret.retn();
-}
-
-/*!
- * This method allows to put a vector of vector of integer into a more compact data structure (skyline).
- * This method is not available into python because no available optimized data structure available to map std::vector< std::vector<int> >.
- *
- * \param [in] v the input data structure to be translate into skyline format.
- * \param [out] data the first element of the skyline format. The user is expected to deal with newly allocated array.
- * \param [out] dataIndex the second element of the skyline format.
- */
-void DataArrayInt::PutIntoToSkylineFrmt(const std::vector< std::vector<int> >& v, DataArrayInt *& data, DataArrayInt *& dataIndex)
-{
-  int sz((int)v.size());
-  MCAuto<DataArrayInt> ret0(DataArrayInt::New()),ret1(DataArrayInt::New());
-  ret1->alloc(sz+1,1);
-  int *pt(ret1->getPointer()); *pt=0;
-  for(int i=0;i<sz;i++,pt++)
-    pt[1]=pt[0]+(int)v[i].size();
-  ret0->alloc(ret1->back(),1);
-  pt=ret0->getPointer();
-  for(int i=0;i<sz;i++)
-    pt=std::copy(v[i].begin(),v[i].end(),pt);
-  data=ret0.retn(); dataIndex=ret1.retn();
-}
-
-/*!
- * Returns a new DataArrayInt which contains a complement of elements of \a this
- * one-dimensional array. I.e. the result array contains all elements from the range [0,
- * \a nbOfElement) not present in \a this array.
- *  \param [in] nbOfElement - maximal size of the result array.
- *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
- *         array using decrRef() as it is no more needed.
- *  \throw If \a this is not allocated.
- *  \throw If \a this->getNumberOfComponents() != 1.
- *  \throw If any element \a x of \a this array violates condition ( 0 <= \a x < \a
- *         nbOfElement ).
- */
-DataArrayInt *DataArrayInt::buildComplement(int nbOfElement) const
-{
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : only single component allowed !");
-  std::vector<bool> tmp(nbOfElement);
-  const int *pt=getConstPointer();
-  mcIdType nbOfTuples=ToIdType(getNumberOfTuples());
-  for(const int *w=pt;w!=pt+nbOfTuples;w++)
-    if(*w>=0 && *w<nbOfElement)
-      tmp[*w]=true;
-    else
-      throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : an element is not in valid range : [0,nbOfElement) !");
-  int nbOfRetVal=(int)std::count(tmp.begin(),tmp.end(),false);
-  DataArrayInt *ret=DataArrayInt::New();
-  ret->alloc(nbOfRetVal,1);
-  int j=0;
-  int *retPtr=ret->getPointer();
-  for(int i=0;i<nbOfElement;i++)
-    if(!tmp[i])
-      retPtr[j++]=i;
-  return ret;
-}
-
-/*!
- * Returns a new DataArrayInt containing elements of \a this one-dimensional missing
- * from an \a other one-dimensional array.
- *  \param [in] other - a DataArrayInt containing elements not to include in the result array.
- *  \return DataArrayInt * - a new instance of DataArrayInt with one component. The
- *         caller is to delete this array using decrRef() as it is no more needed.
- *  \throw If \a other is NULL.
- *  \throw If \a other is not allocated.
- *  \throw If \a other->getNumberOfComponents() != 1.
- *  \throw If \a this is not allocated.
- *  \throw If \a this->getNumberOfComponents() != 1.
- *  \sa DataArrayInt::buildSubstractionOptimized()
- */
-DataArrayInt *DataArrayInt::buildSubstraction(const DataArrayInt *other) const
-{
-  if(!other)
-    throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : DataArrayInt pointer in input is NULL !");
-  checkAllocated();
-  other->checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed !");
-  if(other->getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed for other type !");
-  const int *pt=getConstPointer();
-  mcIdType nbOfTuples=ToIdType(getNumberOfTuples());
-  std::set<int> s1(pt,pt+nbOfTuples);
-  pt=other->getConstPointer();
-  nbOfTuples=ToIdType(other->getNumberOfTuples());
-  std::set<int> s2(pt,pt+nbOfTuples);
-  std::vector<int> r;
-  std::set_difference(s1.begin(),s1.end(),s2.begin(),s2.end(),std::back_insert_iterator< std::vector<int> >(r));
-  DataArrayInt *ret=DataArrayInt::New();
-  ret->alloc((int)r.size(),1);
-  std::copy(r.begin(),r.end(),ret->getPointer());
-  return ret;
-}
-
-/*!
- * \a this is expected to have one component and to be sorted ascendingly (as for \a other).
- * \a other is expected to be a part of \a this. If not DataArrayInt::buildSubstraction should be called instead.
- *
- * \param [in] other an array with one component and expected to be sorted ascendingly.
- * \ret list of ids in \a this but not in \a other.
- * \sa DataArrayInt::buildSubstraction
- */
-DataArrayInt *DataArrayInt::buildSubstractionOptimized(const DataArrayInt *other) const
-{
-  static const char *MSG="DataArrayInt::buildSubstractionOptimized : only single component allowed !";
-  if(!other) throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstractionOptimized : NULL input array !");
-  checkAllocated(); other->checkAllocated();
-  if(getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception(MSG);
-  if(other->getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception(MSG);
-  const int *pt1Bg(begin()),*pt1End(end()),*pt2Bg(other->begin()),*pt2End(other->end());
-  const int *work1(pt1Bg),*work2(pt2Bg);
-  MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
-  for(;work1!=pt1End;work1++)
-    {
-      if(work2!=pt2End && *work1==*work2)
-        work2++;
-      else
-        ret->pushBackSilent(*work1);
-    }
-  return ret.retn();
-}
-
-
-/*!
- * Returns a new DataArrayInt which contains all elements of \a this and a given
- * one-dimensional arrays. The result array does not contain any duplicates
- * and its values are sorted in ascending order.
- *  \param [in] other - an array to unite with \a this one.
- *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
- *         array using decrRef() as it is no more needed.
- *  \throw If \a this or \a other is not allocated.
- *  \throw If \a this->getNumberOfComponents() != 1.
- *  \throw If \a other->getNumberOfComponents() != 1.
- */
-DataArrayInt *DataArrayInt::buildUnion(const DataArrayInt *other) const
-{
-  std::vector<const DataArrayInt *>arrs(2);
-  arrs[0]=this; arrs[1]=other;
-  return BuildUnion(arrs);
-}
-
-
-/*!
- * Returns a new DataArrayInt which contains elements present in both \a this and a given
- * one-dimensional arrays. The result array does not contain any duplicates
- * and its values are sorted in ascending order.
- *  \param [in] other - an array to intersect with \a this one.
- *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
- *         array using decrRef() as it is no more needed.
- *  \throw If \a this or \a other is not allocated.
- *  \throw If \a this->getNumberOfComponents() != 1.
- *  \throw If \a other->getNumberOfComponents() != 1.
- */
-DataArrayInt *DataArrayInt::buildIntersection(const DataArrayInt *other) const
-{
-  std::vector<const DataArrayInt *>arrs(2);
-  arrs[0]=this; arrs[1]=other;
-  return BuildIntersection(arrs);
-}
-
-/*!
- * This method can be applied on allocated with one component DataArrayInt instance.
- * This method is typically relevant for sorted arrays. All consecutive duplicated items in \a this will appear only once in returned DataArrayInt instance.
- * 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]
- *
- * \return a newly allocated array that contain the result of the unique operation applied on \a this.
- * \throw if \a this is not allocated or if \a this has not exactly one component.
- * \sa DataArrayInt::buildUniqueNotSorted
- */
-DataArrayInt *DataArrayInt::buildUnique() const
-{
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::buildUnique : only single component allowed !");
-  mcIdType nbOfTuples=ToIdType(getNumberOfTuples());
-  MCAuto<DataArrayInt> tmp=deepCopy();
-  int *data=tmp->getPointer();
-  int *last=std::unique(data,data+nbOfTuples);
-  MCAuto<DataArrayInt> ret=DataArrayInt::New();
-  ret->alloc(std::distance(data,last),1);
-  std::copy(data,last,ret->getPointer());
-  return ret.retn();
-}
-
-/*!
- * This method can be applied on allocated with one component DataArrayInt instance.
- * This method keep elements only once by keeping the same order in \a this that is not expected to be sorted.
- *
- * \return a newly allocated array that contain the result of the unique operation applied on \a this.
- *
- * \throw if \a this is not allocated or if \a this has not exactly one component.
- *
- * \sa DataArrayInt::buildUnique
- */
-DataArrayInt *DataArrayInt::buildUniqueNotSorted() const
-{
-  checkAllocated();
-    if(getNumberOfComponents()!=1)
-      throw INTERP_KERNEL::Exception("DataArrayInt::buildUniqueNotSorted : only single component allowed !");
-  int minVal,maxVal;
-  getMinMaxValues(minVal,maxVal);
-  std::vector<bool> b(maxVal-minVal+1,false);
-  const int *ptBg(begin()),*endBg(end());
-  MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(0,1);
-  for(const int *pt=ptBg;pt!=endBg;pt++)
-    {
-      if(!b[*pt-minVal])
-        {
-          ret->pushBackSilent(*pt);
-          b[*pt-minVal]=true;
-        }
-    }
-  ret->copyStringInfoFrom(*this);
-  return ret.retn();
-}
-
-/*!
- * Returns a new DataArrayInt which contains size of every of groups described by \a this
- * "index" array. Such "index" array is returned for example by
- * \ref MEDCoupling::MEDCouplingUMesh::buildDescendingConnectivity
- * "MEDCouplingUMesh::buildDescendingConnectivity" and
- * \ref MEDCoupling::MEDCouplingUMesh::getNodalConnectivityIndex
- * "MEDCouplingUMesh::getNodalConnectivityIndex" etc.
- * This method performs the reverse operation of DataArrayInt::computeOffsetsFull.
- *  \return DataArrayInt * - a new instance of DataArrayInt, whose number of tuples
- *          equals to \a this->getNumberOfComponents() - 1, and number of components is 1.
- *          The caller is to delete this array using decrRef() as it is no more needed.
- *  \throw If \a this is not allocated.
- *  \throw If \a this->getNumberOfComponents() != 1.
- *  \throw If \a this->getNumberOfTuples() < 2.
- *
- *  \b Example: <br>
- *         - this contains [1,3,6,7,7,9,15]
- *         - result array contains [2,3,1,0,2,6],
- *          where 2 = 3 - 1, 3 = 6 - 3, 1 = 7 - 6 etc.
- *
- * \sa DataArrayInt::computeOffsetsFull
- */
-DataArrayInt *DataArrayInt::deltaShiftIndex() const
-{
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::deltaShiftIndex : only single component allowed !");
-  mcIdType nbOfTuples=ToIdType(getNumberOfTuples());
-  if(nbOfTuples<2)
-    throw INTERP_KERNEL::Exception("DataArrayInt::deltaShiftIndex : 1 tuple at least must be present in 'this' !");
-  const int *ptr=getConstPointer();
-  DataArrayInt *ret=DataArrayInt::New();
-  ret->alloc(nbOfTuples-1,1);
-  int *out=ret->getPointer();
-  std::transform(ptr+1,ptr+nbOfTuples,ptr,out,std::minus<int>());
-  return ret;
-}
-
-/*!
- * Modifies \a this one-dimensional array so that value of each element \a x
- * of \a this array (\a a) is computed as \f$ x_i = \sum_{j=0}^{i-1} a[ j ] \f$.
- * Or: for each i>0 new[i]=new[i-1]+old[i-1] for i==0 new[i]=0. Number of tuples
- * and components remains the same.<br>
- * This method is useful for allToAllV in MPI with contiguous policy. This method
- * differs from computeOffsetsFull() in that the number of tuples is \b not changed by
- * this one.
- *  \throw If \a this is not allocated.
- *  \throw If \a this->getNumberOfComponents() != 1.
- *
- *  \b Example: <br>
- *          - Before \a this contains [3,5,1,2,0,8]
- *          - After \a this contains  [0,3,8,9,11,11]<br>
- *          Note that the last element 19 = 11 + 8 is missing because size of \a this
- *          array is retained and thus there is no space to store the last element.
- */
-void DataArrayInt::computeOffsets()
-{
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsets : only single component allowed !");
-  std::size_t nbOfTuples=getNumberOfTuples();
-  if(nbOfTuples==0)
-    return ;
-  int *work=getPointer();
-  int tmp=work[0];
-  work[0]=0;
-  for(std::size_t i=1;i<nbOfTuples;i++)
-    {
-      int tmp2=work[i];
-      work[i]=work[i-1]+tmp;
-      tmp=tmp2;
-    }
-  declareAsNew();
-}
-
-
-/*!
- * Modifies \a this one-dimensional array so that value of each element \a x
- * of \a this array (\a a) is computed as \f$ x_i = \sum_{j=0}^{i-1} a[ j ] \f$.
- * Or: for each i>0 new[i]=new[i-1]+old[i-1] for i==0 new[i]=0. Number
- * components remains the same and number of tuples is inceamented by one.<br>
- * This method is useful for allToAllV in MPI with contiguous policy. This method
- * differs from computeOffsets() in that the number of tuples is changed by this one.
- * This method performs the reverse operation of DataArrayInt::deltaShiftIndex.
- *  \throw If \a this is not allocated.
- *  \throw If \a this->getNumberOfComponents() != 1.
- *
- *  \b Example: <br>
- *          - Before \a this contains [3,5,1,2,0,8]
- *          - After \a this contains  [0,3,8,9,11,11,19]<br>
- * \sa DataArrayInt::deltaShiftIndex
- */
-void DataArrayInt::computeOffsetsFull()
-{
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsetsFull : only single component allowed !");
-  mcIdType nbOfTuples=ToIdType(getNumberOfTuples());
-  int *ret=(int *)malloc((nbOfTuples+1)*sizeof(int));
-  const int *work=getConstPointer();
-  ret[0]=0;
-  for(mcIdType i=0;i<nbOfTuples;i++)
-    ret[i+1]=work[i]+ret[i];
-  useArray(ret,true,DeallocType::C_DEALLOC,nbOfTuples+1,1);
-  declareAsNew();
-}
-
-/*!
- * Returns two new DataArrayInt instances whose contents is computed from that of \a this and \a listOfIds arrays as follows.
- * \a this is expected to be an offset format ( as returned by DataArrayInt::computeOffsetsFull ) that is to say with one component
- * and ** sorted strictly increasingly **. \a listOfIds is expected to be sorted ascendingly (not strictly needed for \a listOfIds).
- * This methods searches in \a this, considered as a set of contiguous \c this->getNumberOfComponents() ranges, all ids in \a listOfIds
- * filling completely one of the ranges in \a this.
- *
- * \param [in] listOfIds a list of ids that has to be sorted ascendingly.
- * \param [out] rangeIdsFetched the range ids fetched
- * \param [out] idsInInputListThatFetch contains the list of ids in \a listOfIds that are \b fully included in a range in \a this. So
- *              \a idsInInputListThatFetch is a part of input \a listOfIds.
- *
- * \sa DataArrayInt::computeOffsetsFull
- *
- *  \b Example: <br>
- *          - \a this : [0,3,7,9,15,18]
- *          - \a listOfIds contains  [0,1,2,3,7,8,15,16,17]
- *          - \a rangeIdsFetched result array: [0,2,4]
- *          - \a idsInInputListThatFetch result array: [0,1,2,7,8,15,16,17]
- * In this example id 3 in input \a listOfIds is alone so it do not appear in output \a idsInInputListThatFetch.
- * <br>
- */
-void DataArrayInt::findIdsRangesInListOfIds(const DataArrayInt *listOfIds, DataArrayInt *& rangeIdsFetched, DataArrayInt *& idsInInputListThatFetch) const
-{
-  if(!listOfIds)
-    throw INTERP_KERNEL::Exception("DataArrayInt::findIdsRangesInListOfIds : input list of ids is null !");
-  listOfIds->checkAllocated(); checkAllocated();
-  if(listOfIds->getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::findIdsRangesInListOfIds : input list of ids must have exactly one component !");
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::findIdsRangesInListOfIds : this must have exactly one component !");
-  MCAuto<DataArrayInt> ret0=DataArrayInt::New(); ret0->alloc(0,1);
-  MCAuto<DataArrayInt> ret1=DataArrayInt::New(); ret1->alloc(0,1);
-  const int *tupEnd(listOfIds->end()),*offBg(begin()),*offEnd(end()-1);
-  const int *tupPtr(listOfIds->begin()),*offPtr(offBg);
-  while(tupPtr!=tupEnd && offPtr!=offEnd)
-    {
-      if(*tupPtr==*offPtr)
-        {
-          int i=offPtr[0];
-          while(i<offPtr[1] && *tupPtr==i && tupPtr!=tupEnd) { i++; tupPtr++; }
-          if(i==offPtr[1])
-            {
-              ret0->pushBackSilent((int)std::distance(offBg,offPtr));
-              ret1->pushBackValsSilent(tupPtr-(offPtr[1]-offPtr[0]),tupPtr);
-              offPtr++;
-            }
-        }
-      else
-        { if(*tupPtr<*offPtr) tupPtr++; else offPtr++; }
-    }
-  rangeIdsFetched=ret0.retn();
-  idsInInputListThatFetch=ret1.retn();
-}
-
-/*!
- * Returns a new DataArrayInt whose contents is computed from that of \a this and \a
- * offsets arrays as follows. \a offsets is a one-dimensional array considered as an
- * "index" array of a "iota" array, thus, whose each element gives an index of a group
- * beginning within the "iota" array. And \a this is a one-dimensional array
- * considered as a selector of groups described by \a offsets to include into the result array.
- *  \throw If \a offsets is NULL.
- *  \throw If \a offsets is not allocated.
- *  \throw If \a offsets->getNumberOfComponents() != 1.
- *  \throw If \a offsets is not monotonically increasing.
- *  \throw If \a this is not allocated.
- *  \throw If \a this->getNumberOfComponents() != 1.
- *  \throw If any element of \a this is not a valid index for \a offsets array.
- *
- *  \b Example: <br>
- *          - \a this: [0,2,3]
- *          - \a offsets: [0,3,6,10,14,20]
- *          - result array: [0,1,2,6,7,8,9,10,11,12,13] == <br>
- *            \c range(0,3) + \c range(6,10) + \c range(10,14) ==<br>
- *            \c range( \a offsets[ \a this[0] ], offsets[ \a this[0]+1 ]) +
- *            \c range( \a offsets[ \a this[1] ], offsets[ \a this[1]+1 ]) +
- *            \c range( \a offsets[ \a this[2] ], offsets[ \a this[2]+1 ])
- */
-DataArrayInt *DataArrayInt::buildExplicitArrByRanges(const DataArrayInt *offsets) const
-{
-  if(!offsets)
-    throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : DataArrayInt pointer in input is NULL !");
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : only single component allowed !");
-  offsets->checkAllocated();
-  if(offsets->getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : input array should have only single component !");
-  mcIdType othNbTuples=ToIdType(offsets->getNumberOfTuples())-1;
-  mcIdType nbOfTuples=ToIdType(getNumberOfTuples());
-  int retNbOftuples=0;
-  const int *work=getConstPointer();
-  const int *offPtr=offsets->getConstPointer();
-  for(mcIdType i=0;i<nbOfTuples;i++)
-    {
-      int val=work[i];
-      if(val>=0 && val<othNbTuples)
-        {
-          int delta=offPtr[val+1]-offPtr[val];
-          if(delta>=0)
-            retNbOftuples+=delta;
-          else
-            {
-              std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrByRanges : Tuple #" << val << " of offset array has a delta < 0 !";
-              throw INTERP_KERNEL::Exception(oss.str().c_str());
-            }
-        }
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrByRanges : Tuple #" << i << " in this contains " << val;
-          oss << " whereas offsets array is of size " << othNbTuples+1 << " !";
-          throw INTERP_KERNEL::Exception(oss.str().c_str());
-        }
-    }
-  MCAuto<DataArrayInt> ret=DataArrayInt::New();
-  ret->alloc(retNbOftuples,1);
-  int *retPtr=ret->getPointer();
-  for(mcIdType i=0;i<nbOfTuples;i++)
-    {
-      int val=work[i];
-      int start=offPtr[val];
-      int off=offPtr[val+1]-start;
-      for(int j=0;j<off;j++,retPtr++)
-        *retPtr=start+j;
-    }
-  return ret.retn();
-}
-
-/*!
- * Returns a new DataArrayInt whose contents is computed using \a this that must be a
- * scaled array (monotonically increasing).
-from that of \a this and \a
- * offsets arrays as follows. \a offsets is a one-dimensional array considered as an
- * "index" array of a "iota" array, thus, whose each element gives an index of a group
- * beginning within the "iota" array. And \a this is a one-dimensional array
- * considered as a selector of groups described by \a offsets to include into the result array.
- *  \throw If \a  is NULL.
- *  \throw If \a this is not allocated.
- *  \throw If \a this->getNumberOfComponents() != 1.
- *  \throw If \a this->getNumberOfTuples() == 0.
- *  \throw If \a this is not monotonically increasing.
- *  \throw If any element of ids in ( \a bg \a stop \a step ) points outside the scale in \a this.
- *
- *  \b Example: <br>
- *          - \a bg , \a stop and \a step : (0,5,2)
- *          - \a this: [0,3,6,10,14,20]
- *          - result array: [0,0,0, 2,2,2,2, 4,4,4,4,4,4] == <br>
- */
-DataArrayInt *DataArrayInt::buildExplicitArrOfSliceOnScaledArr(int bg, int stop, int step) const
-{
-  if(!isAllocated())
-    throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : not allocated array !");
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : number of components is expected to be equal to one !");
-  mcIdType nbOfTuples = ToIdType(getNumberOfTuples());
-  if(nbOfTuples==0)
-    throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : number of tuples must be != 0 !");
-  const int *ids(begin());
-  int nbOfEltsInSlc(GetNumberOfItemGivenBESRelative(bg,stop,step,"DataArrayInt::buildExplicitArrOfSliceOnScaledArr")),sz(0),pos(bg);
-  for(int i=0;i<nbOfEltsInSlc;i++,pos+=step)
-    {
-      if(pos>=0 && pos<nbOfTuples-1)
-        {
-          int delta(ids[pos+1]-ids[pos]);
-          sz+=delta;
-          if(delta<0)
-            {
-              std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrOfSliceOnScaledArr : At pos #" << i << " of input slice, value is " << pos << " and at this pos this is not monotonically increasing !";
-              throw INTERP_KERNEL::Exception(oss.str().c_str());
-            }
-        }
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrOfSliceOnScaledArr : At pos #" << i << " of input slice, value is " << pos << " should be in [0," << nbOfTuples-1 << ") !";
-          throw INTERP_KERNEL::Exception(oss.str().c_str());
-        }
-    }
-  MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(sz,1);
-  int *retPtr(ret->getPointer());
-  pos=bg;
-  for(int i=0;i<nbOfEltsInSlc;i++,pos+=step)
-    {
-      int delta(ids[pos+1]-ids[pos]);
-      for(int j=0;j<delta;j++,retPtr++)
-        *retPtr=pos;
-    }
-  return ret.retn();
-}
-
-/*!
- * 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.
- * 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
- * in tuple **i** of returned DataArrayInt.
- * If ranges overlapped (in theory it should not) this method do not detect it and always returns the first range.
- *
- * 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)]
- * The return DataArrayInt will contain : **[0,4,1,2,2,3]**
- *
- * \param [in] ranges typically come from output of MEDCouplingUMesh::ComputeRangesFromTypeDistribution. Each range is specified like this : 1st component is
- *             for lower value included and 2nd component is the upper value of corresponding range **excluded**.
- * \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
- *        is thrown if no ranges in \a ranges contains value in \a this.
- *
- * \sa DataArrayInt::findIdInRangeForEachTuple
- */
-DataArrayInt *DataArrayInt::findRangeIdForEachTuple(const DataArrayInt *ranges) const
-{
-  if(!ranges)
-    throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : null input pointer !");
-  if(ranges->getNumberOfComponents()!=2)
-    throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : input DataArrayInt instance should have 2 components !");
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : this should have only one component !");
-  mcIdType nbTuples=ToIdType(getNumberOfTuples());
-  MCAuto<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTuples,1);
-  mcIdType nbOfRanges=ToIdType(ranges->getNumberOfTuples());
-  const int *rangesPtr=ranges->getConstPointer();
-  int *retPtr=ret->getPointer();
-  const int *inPtr=getConstPointer();
-  for(mcIdType i=0;i<nbTuples;i++,retPtr++)
-    {
-      int val=inPtr[i];
-      bool found=false;
-      for(int j=0;j<nbOfRanges && !found;j++)
-        if(val>=rangesPtr[2*j] && val<rangesPtr[2*j+1])
-          { *retPtr=j; found=true; }
-      if(found)
-        continue;
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::findRangeIdForEachTuple : tuple #" << i << " not found by any ranges !";
-          throw INTERP_KERNEL::Exception(oss.str().c_str());
-        }
-    }
-  return ret.retn();
-}
-
-/*!
- * 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.
- * 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
- * in tuple **i** of returned DataArrayInt.
- * If ranges overlapped (in theory it should not) this method do not detect it and always returns the sub position of the first range.
- *
- * 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)]
- * The return DataArrayInt will contain : **[1,2,4,0,2,2]**
- * This method is often called in pair with DataArrayInt::findRangeIdForEachTuple method.
- *
- * \param [in] ranges typically come from output of MEDCouplingUMesh::ComputeRangesFromTypeDistribution. Each range is specified like this : 1st component is
- *             for lower value included and 2nd component is the upper value of corresponding range **excluded**.
- * \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
- *        is thrown if no ranges in \a ranges contains value in \a this.
- * \sa DataArrayInt::findRangeIdForEachTuple
- */
-DataArrayInt *DataArrayInt::findIdInRangeForEachTuple(const DataArrayInt *ranges) const
-{
-  if(!ranges)
-    throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : null input pointer !");
-  if(ranges->getNumberOfComponents()!=2)
-    throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : input DataArrayInt instance should have 2 components !");
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : this should have only one component !");
-  std::size_t nbTuples=getNumberOfTuples();
-  MCAuto<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbTuples,1);
-  std::size_t nbOfRanges=ranges->getNumberOfTuples();
-  const int *rangesPtr=ranges->getConstPointer();
-  int *retPtr=ret->getPointer();
-  const int *inPtr=getConstPointer();
-  for(std::size_t i=0;i<nbTuples;i++,retPtr++)
-    {
-      int val=inPtr[i];
-      bool found=false;
-      for(std::size_t j=0;j<nbOfRanges && !found;j++)
-        if(val>=rangesPtr[2*j] && val<rangesPtr[2*j+1])
-          { *retPtr=val-rangesPtr[2*j]; found=true; }
-      if(found)
-        continue;
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::findIdInRangeForEachTuple : tuple #" << i << " not found by any ranges !";
-          throw INTERP_KERNEL::Exception(oss.str().c_str());
-        }
-    }
-  return ret.retn();
-}
-
-/*!
- * \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).
- * 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).
- * 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 !
- * If this method has correctly worked, \a this will be able to be considered as a linked list.
- * This method does nothing if number of tuples is lower of equal to 1.
- *
- * This method is useful for users having an unstructured mesh having only SEG2 to rearrange internally the connectivity without any coordinates consideration.
- *
- * \sa MEDCouplingUMesh::orderConsecutiveCells1D, DataArrayInt::fromLinkedListOfPairToList
- */
-void DataArrayInt::sortEachPairToMakeALinkedList()
-{
-  checkAllocated();
-  if(getNumberOfComponents()!=2)
-    throw INTERP_KERNEL::Exception("DataArrayInt::sortEachPairToMakeALinkedList : Only works on DataArrayInt instance with nb of components equal to 2 !");
-  std::size_t nbOfTuples(getNumberOfTuples());
-  if(nbOfTuples<=1)
-    return ;
-  int *conn(getPointer());
-  for(std::size_t i=1;i<nbOfTuples;i++,conn+=2)
-    {
-      if(i>1)
-        {
-          if(conn[2]==conn[3])
-            {
-              std::ostringstream oss; oss << "DataArrayInt::sortEachPairToMakeALinkedList : In the tuple #" << i << " presence of a pair filled with same ids !";
-              throw INTERP_KERNEL::Exception(oss.str().c_str());
-            }
-          if(conn[2]!=conn[1] && conn[3]==conn[1] && conn[2]!=conn[0])
-            std::swap(conn[2],conn[3]);
-          //not(conn[2]==conn[1] && conn[3]!=conn[1] && conn[3]!=conn[0])
-          if(conn[2]!=conn[1] || conn[3]==conn[1] || conn[3]==conn[0])
-            {
-              std::ostringstream oss; oss << "DataArrayInt::sortEachPairToMakeALinkedList : In the tuple #" << i << " something is invalid !";
-              throw INTERP_KERNEL::Exception(oss.str().c_str());
-            }
-        }
-      else
-        {
-          if(conn[0]==conn[1] || conn[2]==conn[3])
-            throw INTERP_KERNEL::Exception("DataArrayInt::sortEachPairToMakeALinkedList : In the 2 first tuples presence of a pair filled with same ids !");
-          int tmp[4];
-          std::set<int> s;
-          s.insert(conn,conn+4);
-          if(s.size()!=3)
-            throw INTERP_KERNEL::Exception("DataArrayInt::sortEachPairToMakeALinkedList : This can't be considered as a linked list regarding 2 first tuples !");
-          if(std::count(conn,conn+4,conn[0])==2)
-            {
-              tmp[0]=conn[1];
-              tmp[1]=conn[0];
-              tmp[2]=conn[0];
-              if(conn[2]==conn[0])
-                { tmp[3]=conn[3]; }
-              else
-                { tmp[3]=conn[2];}
-              std::copy(tmp,tmp+4,conn);
-            }
-          else
-            {//here we are sure to have (std::count(conn,conn+4,conn[1])==2)
-              if(conn[1]==conn[3])
-                std::swap(conn[2],conn[3]);
-            }
-        }
-    }
-}
-
-/*!
- * \a this is expected to be a correctly linked list of pairs.
- *
- * \sa DataArrayInt::sortEachPairToMakeALinkedList
- */
-MCAuto<DataArrayInt> DataArrayInt::fromLinkedListOfPairToList() const
-{
-  checkAllocated();
-  checkNbOfComps(2,"DataArrayInt::fromLinkedListOfPairToList : this is expected to have 2 components");
-  mcIdType nbTuples=ToIdType(getNumberOfTuples());
-  if(nbTuples<1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::fromLinkedListOfPairToList : no tuples in this ! Not a linked list !");
-  MCAuto<DataArrayInt> ret(DataArrayInt::New()); ret->alloc(nbTuples+1,1);
-  const int *thisPtr(begin());
-  int *retPtr(ret->getPointer());
-  retPtr[0]=thisPtr[0];
-  for(mcIdType i=0;i<nbTuples;i++)
-    {
-      retPtr[i+1]=thisPtr[2*i+1];
-      if(i<nbTuples-1)
-        if(thisPtr[2*i+1]!=thisPtr[2*(i+1)+0])
-          {
-            std::ostringstream oss; oss << "DataArrayInt::fromLinkedListOfPairToList : this is not a proper linked list of pair. The link is broken between tuple #" << i << " and tuple #" << i+1 << " ! Call sortEachPairToMakeALinkedList ?";
-            throw INTERP_KERNEL::Exception(oss.str());
-          }
-    }
-  return ret;
-}
-
-/*!
- * This method returns all different values found in \a this. This method throws if \a this has not been allocated.
- * But the number of components can be different from one.
- * \return a newly allocated array (that should be dealt by the caller) containing different values in \a this.
- */
-DataArrayInt *DataArrayInt::getDifferentValues() const
-{
-  checkAllocated();
-  std::set<int> ret;
-  ret.insert(begin(),end());
-  MCAuto<DataArrayInt> ret2=DataArrayInt::New(); ret2->alloc((int)ret.size(),1);
-  std::copy(ret.begin(),ret.end(),ret2->getPointer());
-  return ret2.retn();
-}
-
-/*!
- * This method is a refinement of DataArrayInt::getDifferentValues because it returns not only different values in \a this but also, for each of
- * them it tells which tuple id have this id.
- * This method works only on arrays with one component (if it is not the case call DataArrayInt::rearrange(1) ).
- * This method returns two arrays having same size.
- * 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.
- * 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]]
- */
-std::vector<DataArrayInt *> DataArrayInt::partitionByDifferentValues(std::vector<int>& differentIds) const
-{
-  checkAllocated();
-  if(getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::partitionByDifferentValues : this should have only one component !");
-  int id=0;
-  std::map<int,int> m,m2,m3;
-  for(const int *w=begin();w!=end();w++)
-    m[*w]++;
-  differentIds.resize(m.size());
-  std::vector<DataArrayInt *> ret(m.size());
-  std::vector<int *> retPtr(m.size());
-  for(std::map<int,int>::const_iterator it=m.begin();it!=m.end();it++,id++)
-    {
-      m2[(*it).first]=id;
-      ret[id]=DataArrayInt::New();
-      ret[id]->alloc((*it).second,1);
-      retPtr[id]=ret[id]->getPointer();
-      differentIds[id]=(*it).first;
-    }
-  id=0;
-  for(const int *w=begin();w!=end();w++,id++)
-    {
-      retPtr[m2[*w]][m3[*w]++]=id;
-    }
-  return ret;
-}
-
-/*!
- * This method split ids in [0, \c this->getNumberOfTuples() ) using \a this array as a field of weight (>=0 each).
- * The aim of this method is to return a set of \a nbOfSlices chunk of contiguous ids as balanced as possible.
- *
- * \param [in] nbOfSlices - number of slices expected.
- * \return - a vector having a size equal to \a nbOfSlices giving the start (included) and the stop (excluded) of each chunks.
- *
- * \sa DataArray::GetSlice
- * \throw If \a this is not allocated or not with exactly one component.
- * \throw If an element in \a this if < 0.
- */
-std::vector< std::pair<int,int> > DataArrayInt::splitInBalancedSlices(int nbOfSlices) const
-{
-  if(!isAllocated() || getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::splitInBalancedSlices : this array should have number of components equal to one and must be allocated !");
-  if(nbOfSlices<=0)
-    throw INTERP_KERNEL::Exception("DataArrayInt::splitInBalancedSlices : number of slices must be >= 1 !");
-  int sum(accumulate(0));
-  mcIdType nbOfTuples=ToIdType(getNumberOfTuples());
-  int sumPerSlc(sum/nbOfSlices),pos(0);
-  const int *w(begin());
-  std::vector< std::pair<int,int> > ret(nbOfSlices);
-  for(int i=0;i<nbOfSlices;i++)
-    {
-      std::pair<int,int> p(pos,-1);
-      int locSum(0);
-      while(locSum<sumPerSlc && pos<nbOfTuples) { pos++; locSum+=*w++; }
-      if(i!=nbOfSlices-1)
-        p.second=pos;
-      else
-        p.second=nbOfTuples;
-      ret[i]=p;
-    }
-  return ret;
-}
-
-/*!
- * Returns a new DataArrayInt that is a modulus of two given arrays. There are 3
- * valid cases.
- * 1.  The arrays have same number of tuples and components. Then each value of
- *   the result array (_a_) is a division of the corresponding values of \a a1 and
- *   \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ i, j ].
- * 2.  The arrays have same number of tuples and one array, say _a2_, has one
- *   component. Then
- *   _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ i, 0 ].
- * 3.  The arrays have same number of components and one array, say _a2_, has one
- *   tuple. Then
- *   _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ 0, j ].
- *
- * Info on components is copied either from the first array (in the first case) or from
- * the array with maximal number of elements (getNbOfElems()).
- *  \warning No check of division by zero is performed!
- *  \param [in] a1 - a dividend array.
- *  \param [in] a2 - a divisor array.
- *  \return DataArrayInt * - the new instance of DataArrayInt.
- *          The caller is to delete this result array using decrRef() as it is no more
- *          needed.
- *  \throw If either \a a1 or \a a2 is NULL.
- *  \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
- *         \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
- *         none of them has number of tuples or components equal to 1.
- */
-DataArrayInt *DataArrayInt::Modulus(const DataArrayInt *a1, const DataArrayInt *a2)
-{
-  if(!a1 || !a2)
-    throw INTERP_KERNEL::Exception("DataArrayInt::Modulus : input DataArrayInt instance is NULL !");
-  mcIdType nbOfTuple1=ToIdType(a1->getNumberOfTuples());
-  mcIdType nbOfTuple2=ToIdType(a2->getNumberOfTuples());
-  mcIdType nbOfComp1=ToIdType(a1->getNumberOfComponents());
-  mcIdType nbOfComp2=ToIdType(a2->getNumberOfComponents());
-  if(nbOfTuple2==nbOfTuple1)
-    {
-      if(nbOfComp1==nbOfComp2)
-        {
-          MCAuto<DataArrayInt> ret=DataArrayInt::New();
-          ret->alloc(nbOfTuple2,nbOfComp1);
-          std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::modulus<int>());
-          ret->copyStringInfoFrom(*a1);
-          return ret.retn();
-        }
-      else if(nbOfComp2==1)
-        {
-          MCAuto<DataArrayInt> ret=DataArrayInt::New();
-          ret->alloc(nbOfTuple1,nbOfComp1);
-          const int *a2Ptr=a2->getConstPointer();
-          const int *a1Ptr=a1->getConstPointer();
-          int *res=ret->getPointer();
-          for(mcIdType i=0;i<nbOfTuple1;i++)
-            res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::modulus<int>(),a2Ptr[i]));
-          ret->copyStringInfoFrom(*a1);
-          return ret.retn();
-        }
-      else
-        {
-          a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Modulus !");
-          return 0;
-        }
-    }
-  else if(nbOfTuple2==1)
-    {
-      a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Modulus !");
-      MCAuto<DataArrayInt> ret=DataArrayInt::New();
-      ret->alloc(nbOfTuple1,nbOfComp1);
-      const int *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
-      int *pt=ret->getPointer();
-      for(mcIdType i=0;i<nbOfTuple1;i++)
-        pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::modulus<int>());
-      ret->copyStringInfoFrom(*a1);
-      return ret.retn();
-    }
-  else
-    {
-      a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Modulus !");//will always throw an exception
-      return 0;
-    }
-}
-
-/*!
- * Modify \a this array so that each value becomes a modulus of division of this value by
- * a value of another DataArrayInt. There are 3 valid cases.
- * 1.  The arrays have same number of tuples and components. Then each value of
- *    \a this array is divided by the corresponding value of \a other one, i.e.:
- *   _a_ [ i, j ] %= _other_ [ i, j ].
- * 2.  The arrays have same number of tuples and \a other array has one component. Then
- *   _a_ [ i, j ] %= _other_ [ i, 0 ].
- * 3.  The arrays have same number of components and \a other array has one tuple. Then
- *   _a_ [ i, j ] %= _a2_ [ 0, j ].
- *
- *  \warning No check of division by zero is performed!
- *  \param [in] other - a divisor array.
- *  \throw If \a other is NULL.
- *  \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
- *         \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
- *         \a other has number of both tuples and components not equal to 1.
- */
-void DataArrayInt::modulusEqual(const DataArrayInt *other)
-{
-  if(!other)
-    throw INTERP_KERNEL::Exception("DataArrayInt::modulusEqual : input DataArrayInt instance is NULL !");
-  const char *msg="Nb of tuples mismatch for DataArrayInt::modulusEqual !";
-  checkAllocated(); other->checkAllocated();
-  mcIdType nbOfTuple=ToIdType(getNumberOfTuples());
-  mcIdType nbOfTuple2=ToIdType(other->getNumberOfTuples());
-  mcIdType nbOfComp=ToIdType(getNumberOfComponents());
-  mcIdType nbOfComp2=ToIdType(other->getNumberOfComponents());
-  if(nbOfTuple==nbOfTuple2)
-    {
-      if(nbOfComp==nbOfComp2)
-        {
-          std::transform(begin(),end(),other->begin(),getPointer(),std::modulus<int>());
-        }
-      else if(nbOfComp2==1)
-        {
-          if(nbOfComp2==nbOfComp)
-            {
-              int *ptr=getPointer();
-              const int *ptrc=other->getConstPointer();
-              for(mcIdType i=0;i<nbOfTuple;i++)
-                std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::modulus<int>(),*ptrc++));
-            }
-          else
-            throw INTERP_KERNEL::Exception(msg);
-        }
-      else
-        throw INTERP_KERNEL::Exception(msg);
-    }
-  else if(nbOfTuple2==1)
-    {
-      int *ptr=getPointer();
-      const int *ptrc=other->getConstPointer();
-      for(mcIdType i=0;i<nbOfTuple;i++)
-        std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::modulus<int>());
-    }
-  else
-    throw INTERP_KERNEL::Exception(msg);
-  declareAsNew();
-}
-
-/*!
- * Returns a new DataArrayInt that is the result of pow of two given arrays. There are 3
- * valid cases.
- *
- *  \param [in] a1 - an array to pow up.
- *  \param [in] a2 - another array to sum up.
- *  \return DataArrayInt * - the new instance of DataArrayInt.
- *          The caller is to delete this result array using decrRef() as it is no more
- *          needed.
- *  \throw If either \a a1 or \a a2 is NULL.
- *  \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
- *  \throw If \a a1->getNumberOfComponents() != 1 or \a a2->getNumberOfComponents() != 1.
- *  \throw If there is a negative value in \a a2.
- */
-DataArrayInt *DataArrayInt::Pow(const DataArrayInt *a1, const DataArrayInt *a2)
-{
-  if(!a1 || !a2)
-    throw INTERP_KERNEL::Exception("DataArrayInt::Pow : at least one of input instances is null !");
-  std::size_t nbOfTuple=a1->getNumberOfTuples();
-  std::size_t nbOfTuple2=a2->getNumberOfTuples();
-  std::size_t nbOfComp=a1->getNumberOfComponents();
-  std::size_t nbOfComp2=a2->getNumberOfComponents();
-  if(nbOfTuple!=nbOfTuple2)
-    throw INTERP_KERNEL::Exception("DataArrayInt::Pow : number of tuples mismatches !");
-  if(nbOfComp!=1 || nbOfComp2!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::Pow : number of components of both arrays must be equal to 1 !");
-  MCAuto<DataArrayInt> ret=DataArrayInt::New(); ret->alloc(nbOfTuple,1);
-  const int *ptr1(a1->begin()),*ptr2(a2->begin());
-  int *ptr=ret->getPointer();
-  for(std::size_t i=0;i<nbOfTuple;i++,ptr1++,ptr2++,ptr++)
-    {
-      if(*ptr2>=0)
-        {
-          int tmp=1;
-          for(int j=0;j<*ptr2;j++)
-            tmp*=*ptr1;
-          *ptr=tmp;
-        }
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::Pow : on tuple #" << i << " of a2 value is < 0 (" << *ptr2 << ") !";
-          throw INTERP_KERNEL::Exception(oss.str().c_str());
-        }
-    }
-  return ret.retn();
-}
-
-/*!
- * Apply pow on values of another DataArrayInt to values of \a this one.
- *
- *  \param [in] other - an array to pow to \a this one.
- *  \throw If \a other is NULL.
- *  \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples()
- *  \throw If \a this->getNumberOfComponents() != 1 or \a other->getNumberOfComponents() != 1
- *  \throw If there is a negative value in \a other.
- */
-void DataArrayInt::powEqual(const DataArrayInt *other)
-{
-  if(!other)
-    throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : input instance is null !");
-  std::size_t nbOfTuple=getNumberOfTuples();
-  std::size_t nbOfTuple2=other->getNumberOfTuples();
-  std::size_t nbOfComp=getNumberOfComponents();
-  std::size_t nbOfComp2=other->getNumberOfComponents();
-  if(nbOfTuple!=nbOfTuple2)
-    throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : number of tuples mismatches !");
-  if(nbOfComp!=1 || nbOfComp2!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : number of components of both arrays must be equal to 1 !");
-  int *ptr=getPointer();
-  const int *ptrc=other->begin();
-  for(std::size_t i=0;i<nbOfTuple;i++,ptrc++,ptr++)
-    {
-      if(*ptrc>=0)
-        {
-          int tmp=1;
-          for(int j=0;j<*ptrc;j++)
-            tmp*=*ptr;
-          *ptr=tmp;
-        }
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::powEqual : on tuple #" << i << " of other value is < 0 (" << *ptrc << ") !";
-          throw INTERP_KERNEL::Exception(oss.str().c_str());
-        }
-    }
-  declareAsNew();
-}
-
-/*!
- * This method works on a pair input (\b arrIn, \b arrIndxIn) where \b arrIn indexes is in \b arrIndxIn
- * (\ref numbering-indirect).
- * This method returns the result of the extraction ( specified by a set of ids in [\b idsOfSelectBg , \b idsOfSelectEnd ) ).
- * The selection of extraction is done standardly in new2old format.
- * This method returns indexed arrays (\ref numbering-indirect) using 2 arrays (arrOut,arrIndexOut).
- *
- * \param [in] idsOfSelectBg begin of set of ids of the input extraction (included)
- * \param [in] idsOfSelectEnd end of set of ids of the input extraction (excluded)
- * \param [in] arrIn arr origin array from which the extraction will be done.
- * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
- * \param [out] arrOut the resulting array
- * \param [out] arrIndexOut the index array of the resulting array \b arrOut
- * \sa DataArrayInt::ExtractFromIndexedArraysSlice
- */
-void DataArrayInt::ExtractFromIndexedArrays(const int *idsOfSelectBg, const int *idsOfSelectEnd, const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn,
-                                                DataArrayInt* &arrOut, DataArrayInt* &arrIndexOut)
-{
-  if(!arrIn || !arrIndxIn)
-    throw INTERP_KERNEL::Exception("DataArrayInt::ExtractFromIndexedArrays : input pointer is NULL !");
-  arrIn->checkAllocated(); arrIndxIn->checkAllocated();
-  if(arrIn->getNumberOfComponents()!=1 || arrIndxIn->getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::ExtractFromIndexedArrays : input arrays must have exactly one component !");
-  std::size_t sz=std::distance(idsOfSelectBg,idsOfSelectEnd);
-  const int *arrInPtr=arrIn->begin();
-  const int *arrIndxPtr=arrIndxIn->begin();
-  mcIdType nbOfGrps=ToIdType(arrIndxIn->getNumberOfTuples())-1;
-  if(nbOfGrps<0)
-    throw INTERP_KERNEL::Exception("DataArrayInt::ExtractFromIndexedArrays : The format of \"arrIndxIn\" is invalid ! Its nb of tuples should be >=1 !");
-  mcIdType maxSizeOfArr=ToIdType(arrIn->getNumberOfTuples());
-  MCAuto<DataArrayInt> arro=DataArrayInt::New();
-  MCAuto<DataArrayInt> arrIo=DataArrayInt::New();
-  arrIo->alloc((int)(sz+1),1);
-  const int *idsIt=idsOfSelectBg;
-  int *work=arrIo->getPointer();
-  *work++=0;
-  int lgth=0;
-  for(std::size_t i=0;i<sz;i++,work++,idsIt++)
-    {
-      if(*idsIt>=0 && *idsIt<nbOfGrps)
-        lgth+=arrIndxPtr[*idsIt+1]-arrIndxPtr[*idsIt];
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::ExtractFromIndexedArrays : id located on pos #" << i << " value is " << *idsIt << " ! Must be in [0," << nbOfGrps << ") !";
-          throw INTERP_KERNEL::Exception(oss.str());
-        }
-      if(lgth>=work[-1])
-        *work=lgth;
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::ExtractFromIndexedArrays : id located on pos #" << i << " value is " << *idsIt << " and at this pos arrIndxIn[" << *idsIt;
-          oss << "+1]-arrIndxIn[" << *idsIt << "] < 0 ! The input index array is bugged !";
-          throw INTERP_KERNEL::Exception(oss.str());
-        }
-    }
-  arro->alloc(lgth,1);
-  work=arro->getPointer();
-  idsIt=idsOfSelectBg;
-  for(std::size_t i=0;i<sz;i++,idsIt++)
-    {
-      if(arrIndxPtr[*idsIt]>=0 && arrIndxPtr[*idsIt+1]<=maxSizeOfArr)
-        work=std::copy(arrInPtr+arrIndxPtr[*idsIt],arrInPtr+arrIndxPtr[*idsIt+1],work);
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::ExtractFromIndexedArrays : id located on pos #" << i << " value is " << *idsIt << " arrIndx[" << *idsIt << "] must be >= 0 and arrIndx[";
-          oss << *idsIt << "+1] <= " << maxSizeOfArr << " (the size of arrIn)!";
-          throw INTERP_KERNEL::Exception(oss.str());
-        }
-    }
-  arrOut=arro.retn();
-  arrIndexOut=arrIo.retn();
-}
-
-/*!
- * This method works on a pair input (\b arrIn, \b arrIndxIn) where \b arrIn indexes is in \b arrIndxIn
- * (\ref numbering-indirect).
- * This method returns the result of the extraction ( specified by a set of ids with a slice given by \a idsOfSelectStart, \a idsOfSelectStop and \a idsOfSelectStep ).
- * The selection of extraction is done standardly in new2old format.
- * This method returns indexed arrays (\ref numbering-indirect) using 2 arrays (arrOut,arrIndexOut).
- *
- * \param [in] idsOfSelectStart begin of set of ids of the input extraction (included)
- * \param [in] idsOfSelectStop end of set of ids of the input extraction (excluded)
- * \param [in] idsOfSelectStep
- * \param [in] arrIn arr origin array from which the extraction will be done.
- * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
- * \param [out] arrOut the resulting array
- * \param [out] arrIndexOut the index array of the resulting array \b arrOut
- * \sa DataArrayInt::ExtractFromIndexedArrays
- */
-void DataArrayInt::ExtractFromIndexedArraysSlice(int idsOfSelectStart, int idsOfSelectStop, int idsOfSelectStep, const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn,
-                                                 DataArrayInt* &arrOut, DataArrayInt* &arrIndexOut)
-{
-  if(!arrIn || !arrIndxIn)
-    throw INTERP_KERNEL::Exception("DataArrayInt::ExtractFromIndexedArraysSlice : input pointer is NULL !");
-  arrIn->checkAllocated(); arrIndxIn->checkAllocated();
-  if(arrIn->getNumberOfComponents()!=1 || arrIndxIn->getNumberOfComponents()!=1)
-    throw INTERP_KERNEL::Exception("DataArrayInt::ExtractFromIndexedArraysSlice : input arrays must have exactly one component !");
-  int sz=DataArrayInt::GetNumberOfItemGivenBESRelative(idsOfSelectStart,idsOfSelectStop,idsOfSelectStep,"MEDCouplingUMesh::ExtractFromIndexedArraysSlice : Input slice ");
-  const int *arrInPtr=arrIn->begin();
-  const int *arrIndxPtr=arrIndxIn->begin();
-  mcIdType nbOfGrps=ToIdType(arrIndxIn->getNumberOfTuples())-1;
-  if(nbOfGrps<0)
-    throw INTERP_KERNEL::Exception("DataArrayInt::ExtractFromIndexedArraysSlice : The format of \"arrIndxIn\" is invalid ! Its nb of tuples should be >=1 !");
-  mcIdType maxSizeOfArr=ToIdType(arrIn->getNumberOfTuples());
-  MCAuto<DataArrayInt> arro=DataArrayInt::New();
-  MCAuto<DataArrayInt> arrIo=DataArrayInt::New();
-  arrIo->alloc((int)(sz+1),1);
-  int idsIt=idsOfSelectStart;
-  int *work=arrIo->getPointer();
-  *work++=0;
-  int lgth=0;
-  for(int i=0;i<sz;i++,work++,idsIt+=idsOfSelectStep)
-    {
-      if(idsIt>=0 && idsIt<nbOfGrps)
-        lgth+=arrIndxPtr[idsIt+1]-arrIndxPtr[idsIt];
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::ExtractFromIndexedArraysSlice : id located on pos #" << i << " value is " << idsIt << " ! Must be in [0," << nbOfGrps << ") !";
-          throw INTERP_KERNEL::Exception(oss.str());
-        }
-      if(lgth>=work[-1])
-        *work=lgth;
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::ExtractFromIndexedArraysSlice : id located on pos #" << i << " value is " << idsIt << " and at this pos arrIndxIn[" << idsIt;
-          oss << "+1]-arrIndxIn[" << idsIt << "] < 0 ! The input index array is bugged !";
-          throw INTERP_KERNEL::Exception(oss.str());
-        }
-    }
-  arro->alloc(lgth,1);
-  work=arro->getPointer();
-  idsIt=idsOfSelectStart;
-  for(int i=0;i<sz;i++,idsIt+=idsOfSelectStep)
-    {
-      if(arrIndxPtr[idsIt]>=0 && arrIndxPtr[idsIt+1]<=maxSizeOfArr)
-        work=std::copy(arrInPtr+arrIndxPtr[idsIt],arrInPtr+arrIndxPtr[idsIt+1],work);
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::ExtractFromIndexedArraysSlice : id located on pos #" << i << " value is " << idsIt << " arrIndx[" << idsIt << "] must be >= 0 and arrIndx[";
-          oss << idsIt << "+1] <= " << maxSizeOfArr << " (the size of arrIn)!";
-          throw INTERP_KERNEL::Exception(oss.str());
-        }
-    }
-  arrOut=arro.retn();
-  arrIndexOut=arrIo.retn();
-}
-
-/*!
- * This method works on an input pair (\b arrIn, \b arrIndxIn) where \b arrIn indexes is in \b arrIndxIn.
- * This method builds an output pair (\b arrOut,\b arrIndexOut) that is a copy from \b arrIn for all cell ids \b not \b in [ \b idsOfSelectBg , \b idsOfSelectEnd ) and for
- * cellIds \b in [ \b idsOfSelectBg , \b idsOfSelectEnd ) a copy coming from the corresponding values in input pair (\b srcArr, \b srcArrIndex).
- * This method is an generalization of MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx that performs the same thing but by without building explicitly a result output arrays.
- *
- * \param [in] idsOfSelectBg begin of set of ids of the input extraction (included)
- * \param [in] idsOfSelectEnd end of set of ids of the input extraction (excluded)
- * \param [in] arrIn arr origin array from which the extraction will be done.
- * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
- * \param [in] srcArr input array that will be used as source of copy for ids in [ \b idsOfSelectBg, \b idsOfSelectEnd )
- * \param [in] srcArrIndex index array of \b srcArr
- * \param [out] arrOut the resulting array
- * \param [out] arrIndexOut the index array of the resulting array \b arrOut
- *
- * \sa DataArrayInt::SetPartOfIndexedArraysSameIdx
- */
-void DataArrayInt::SetPartOfIndexedArrays(const int *idsOfSelectBg, const int *idsOfSelectEnd, const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn,
-                                              const DataArrayInt *srcArr, const DataArrayInt *srcArrIndex,
-                                              DataArrayInt* &arrOut, DataArrayInt* &arrIndexOut)
-{
-  if(arrIn==0 || arrIndxIn==0 || srcArr==0 || srcArrIndex==0)
-    throw INTERP_KERNEL::Exception("DataArrayInt::SetPartOfIndexedArrays : presence of null pointer in input parameter !");
-  MCAuto<DataArrayInt> arro=DataArrayInt::New();
-  MCAuto<DataArrayInt> arrIo=DataArrayInt::New();
-  mcIdType nbOfTuples=ToIdType(arrIndxIn->getNumberOfTuples())-1;
-  std::vector<bool> v(nbOfTuples,true);
-  int offset=0;
-  const int *arrIndxInPtr=arrIndxIn->begin();
-  const int *srcArrIndexPtr=srcArrIndex->begin();
-  for(const int *it=idsOfSelectBg;it!=idsOfSelectEnd;it++,srcArrIndexPtr++)
-    {
-      if(*it>=0 && *it<nbOfTuples)
-        {
-          v[*it]=false;
-          offset+=(srcArrIndexPtr[1]-srcArrIndexPtr[0])-(arrIndxInPtr[*it+1]-arrIndxInPtr[*it]);
-        }
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::SetPartOfIndexedArrays : On pos #" << std::distance(idsOfSelectBg,it) << " value is " << *it << " not in [0," << nbOfTuples << ") !";
-          throw INTERP_KERNEL::Exception(oss.str());
-        }
-    }
-  srcArrIndexPtr=srcArrIndex->begin();
-  arrIo->alloc(nbOfTuples+1,1);
-  arro->alloc(arrIn->getNumberOfTuples()+offset,1);
-  const int *arrInPtr=arrIn->begin();
-  const int *srcArrPtr=srcArr->begin();
-  int *arrIoPtr=arrIo->getPointer(); *arrIoPtr++=0;
-  int *arroPtr=arro->getPointer();
-  for(mcIdType ii=0;ii<nbOfTuples;ii++,arrIoPtr++)
-    {
-      if(v[ii])
-        {
-          arroPtr=std::copy(arrInPtr+arrIndxInPtr[ii],arrInPtr+arrIndxInPtr[ii+1],arroPtr);
-          *arrIoPtr=arrIoPtr[-1]+(arrIndxInPtr[ii+1]-arrIndxInPtr[ii]);
-        }
-      else
-        {
-          std::size_t pos=std::distance(idsOfSelectBg,std::find(idsOfSelectBg,idsOfSelectEnd,ii));
-          arroPtr=std::copy(srcArrPtr+srcArrIndexPtr[pos],srcArrPtr+srcArrIndexPtr[pos+1],arroPtr);
-          *arrIoPtr=arrIoPtr[-1]+(srcArrIndexPtr[pos+1]-srcArrIndexPtr[pos]);
-        }
-    }
-  arrOut=arro.retn();
-  arrIndexOut=arrIo.retn();
-}
-
-
-/*!
- * This method works on an input pair (\b arrIn, \b arrIndxIn) where \b arrIn indexes is in \b arrIndxIn.
- * This method builds an output pair (\b arrOut,\b arrIndexOut) that is a copy from \b arrIn for all cell ids \b not \b in [ \b idsOfSelectBg , \b idsOfSelectEnd ) and for
- * cellIds \b in [\b idsOfSelectBg, \b idsOfSelectEnd) a copy coming from the corresponding values in input pair (\b srcArr, \b srcArrIndex).
- * This method is an generalization of DataArrayInt::SetPartOfIndexedArraysSameIdx that performs the same thing but by without building explicitly a result output arrays.
- *
- * \param [in] start begin of set of ids of the input extraction (included)
- * \param [in] end end of set of ids of the input extraction (excluded)
- * \param [in] step step of the set of ids in range mode.
- * \param [in] arrIn arr origin array from which the extraction will be done.
- * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
- * \param [in] srcArr input array that will be used as source of copy for ids in [\b idsOfSelectBg, \b idsOfSelectEnd)
- * \param [in] srcArrIndex index array of \b srcArr
- * \param [out] arrOut the resulting array
- * \param [out] arrIndexOut the index array of the resulting array \b arrOut
- *
- * \sa DataArrayInt::SetPartOfIndexedArraysSameIdx DataArrayInt::SetPartOfIndexedArrays
- */
-void DataArrayInt::SetPartOfIndexedArraysSlice(int start, int end, int step, const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn,
-                                               const DataArrayInt *srcArr, const DataArrayInt *srcArrIndex,
-                                               DataArrayInt* &arrOut, DataArrayInt* &arrIndexOut)
-{
-  if(arrIn==0 || arrIndxIn==0 || srcArr==0 || srcArrIndex==0)
-    throw INTERP_KERNEL::Exception("DataArrayInt::SetPartOfIndexedArraysSlice : presence of null pointer in input parameter !");
-  MCAuto<DataArrayInt> arro=DataArrayInt::New();
-  MCAuto<DataArrayInt> arrIo=DataArrayInt::New();
-  mcIdType nbOfTuples=ToIdType(arrIndxIn->getNumberOfTuples())-1;
-  int offset=0;
-  const int *arrIndxInPtr=arrIndxIn->begin();
-  const int *srcArrIndexPtr=srcArrIndex->begin();
-  int nbOfElemsToSet=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"DataArrayInt::SetPartOfIndexedArraysSlice : ");
-  int it=start;
-  for(int i=0;i<nbOfElemsToSet;i++,srcArrIndexPtr++,it+=step)
-    {
-      if(it>=0 && it<nbOfTuples)
-        offset+=(srcArrIndexPtr[1]-srcArrIndexPtr[0])-(arrIndxInPtr[it+1]-arrIndxInPtr[it]);
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::SetPartOfIndexedArraysSlice : On pos #" << i << " value is " << it << " not in [0," << nbOfTuples << ") !";
-          throw INTERP_KERNEL::Exception(oss.str());
-        }
-    }
-  srcArrIndexPtr=srcArrIndex->begin();
-  arrIo->alloc(nbOfTuples+1,1);
-  arro->alloc(arrIn->getNumberOfTuples()+offset,1);
-  const int *arrInPtr=arrIn->begin();
-  const int *srcArrPtr=srcArr->begin();
-  int *arrIoPtr=arrIo->getPointer(); *arrIoPtr++=0;
-  int *arroPtr=arro->getPointer();
-  for(mcIdType ii=0;ii<nbOfTuples;ii++,arrIoPtr++)
-    {
-      int pos=DataArray::GetPosOfItemGivenBESRelativeNoThrow(ii,start,end,step);
-      if(pos<0)
-        {
-          arroPtr=std::copy(arrInPtr+arrIndxInPtr[ii],arrInPtr+arrIndxInPtr[ii+1],arroPtr);
-          *arrIoPtr=arrIoPtr[-1]+(arrIndxInPtr[ii+1]-arrIndxInPtr[ii]);
-        }
-      else
-        {
-          arroPtr=std::copy(srcArrPtr+srcArrIndexPtr[pos],srcArrPtr+srcArrIndexPtr[pos+1],arroPtr);
-          *arrIoPtr=arrIoPtr[-1]+(srcArrIndexPtr[pos+1]-srcArrIndexPtr[pos]);
-        }
-    }
-  arrOut=arro.retn();
-  arrIndexOut=arrIo.retn();
-}
-
-
-/*!
- * This method works on an input pair (\b arrIn, \b arrIndxIn) where \b arrIn indexes is in \b arrIndxIn.
- * This method is an specialization of MEDCouplingUMesh::SetPartOfIndexedArrays in the case of assignment do not modify the index in \b arrIndxIn.
- *
- * \param [in] idsOfSelectBg begin of set of ids of the input extraction (included)
- * \param [in] idsOfSelectEnd end of set of ids of the input extraction (excluded)
- * \param [in,out] arrInOut arr origin array from which the extraction will be done.
- * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
- * \param [in] srcArr input array that will be used as source of copy for ids in [ \b idsOfSelectBg , \b idsOfSelectEnd )
- * \param [in] srcArrIndex index array of \b srcArr
- *
- * \sa DataArrayInt::SetPartOfIndexedArrays
- */
-void DataArrayInt::SetPartOfIndexedArraysSameIdx(const int *idsOfSelectBg, const int *idsOfSelectEnd, DataArrayInt *arrInOut, const DataArrayInt *arrIndxIn,
-                                                     const DataArrayInt *srcArr, const DataArrayInt *srcArrIndex)
-{
-  if(arrInOut==0 || arrIndxIn==0 || srcArr==0 || srcArrIndex==0)
-    throw INTERP_KERNEL::Exception("DataArrayInt::SetPartOfIndexedArraysSameIdx : presence of null pointer in input parameter !");
-  mcIdType nbOfTuples=ToIdType(arrIndxIn->getNumberOfTuples())-1;
-  const int *arrIndxInPtr=arrIndxIn->begin();
-  const int *srcArrIndexPtr=srcArrIndex->begin();
-  int *arrInOutPtr=arrInOut->getPointer();
-  const int *srcArrPtr=srcArr->begin();
-  for(const int *it=idsOfSelectBg;it!=idsOfSelectEnd;it++,srcArrIndexPtr++)
-    {
-      if(*it>=0 && *it<nbOfTuples)
-        {
-          if(srcArrIndexPtr[1]-srcArrIndexPtr[0]==arrIndxInPtr[*it+1]-arrIndxInPtr[*it])
-            std::copy(srcArrPtr+srcArrIndexPtr[0],srcArrPtr+srcArrIndexPtr[1],arrInOutPtr+arrIndxInPtr[*it]);
-          else
-            {
-              std::ostringstream oss; oss << "DataArrayInt::SetPartOfIndexedArraysSameIdx : On pos #" << std::distance(idsOfSelectBg,it) << " id (idsOfSelectBg[" << std::distance(idsOfSelectBg,it)<< "]) is " << *it << " arrIndxIn[id+1]-arrIndxIn[id]!=srcArrIndex[pos+1]-srcArrIndex[pos] !";
-              throw INTERP_KERNEL::Exception(oss.str());
-            }
-        }
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::SetPartOfIndexedArraysSameIdx : On pos #" << std::distance(idsOfSelectBg,it) << " value is " << *it << " not in [0," << nbOfTuples << ") !";
-          throw INTERP_KERNEL::Exception(oss.str());
-        }
-    }
-}
-
-/*!
- * This method works on an input pair (\b arr, \b arrIndx) where \b arr indexes is in \b arrIndx.
- * This method will not impact the size of inout parameter \b arrIndx but the size of \b arr will be modified in case of suppression.
- *
- * \param [in] idsToRemoveBg begin of set of ids to remove in \b arr (included)
- * \param [in] idsToRemoveEnd end of set of ids to remove in \b arr (excluded)
- * \param [in,out] arr array in which the remove operation will be done.
- * \param [in,out] arrIndx array in the remove operation will modify
- * \param [in] offsetForRemoval (by default 0) offset so that for each i in [0,arrIndx->getNumberOfTuples()-1) removal process will be performed in the following range [arr+arrIndx[i]+offsetForRemoval,arr+arr[i+1])
- * \return true if \b arr and \b arrIndx have been modified, false if not.
- */
-bool DataArrayInt::RemoveIdsFromIndexedArrays(const int *idsToRemoveBg, const int *idsToRemoveEnd, DataArrayInt *arr, DataArrayInt *arrIndx, int offsetForRemoval)
-{
-  if(!arrIndx || !arr)
-    throw INTERP_KERNEL::Exception("DataArrayInt::RemoveIdsFromIndexedArrays : some input arrays are empty !");
-  if(offsetForRemoval<0)
-    throw INTERP_KERNEL::Exception("DataArrayInt::RemoveIdsFromIndexedArrays : offsetForRemoval should be >=0 !");
-  std::set<int> s(idsToRemoveBg,idsToRemoveEnd);
-  mcIdType nbOfGrps=ToIdType(arrIndx->getNumberOfTuples())-1;
-  int *arrIPtr=arrIndx->getPointer();
-  *arrIPtr++=0;
-  int previousArrI=0;
-  const int *arrPtr=arr->begin();
-  std::vector<int> arrOut;//no utility to switch to DataArrayInt because copy always needed
-  for(mcIdType i=0;i<nbOfGrps;i++,arrIPtr++)
-    {
-      if(*arrIPtr-previousArrI>offsetForRemoval)
-        {
-          for(const int *work=arrPtr+previousArrI+offsetForRemoval;work!=arrPtr+*arrIPtr;work++)
-            {
-              if(s.find(*work)==s.end())
-                arrOut.push_back(*work);
-            }
-        }
-      previousArrI=*arrIPtr;
-      *arrIPtr=(int)arrOut.size();
-    }
-  if(arr->getNumberOfTuples()==arrOut.size())
-    return false;
-  arr->alloc((int)arrOut.size(),1);
-  std::copy(arrOut.begin(),arrOut.end(),arr->getPointer());
-  return true;
-}
-
-/*!
- * This method works on an input pair (\b arrIn, \b arrIndxIn) where \b arrIn indexes is in \b arrIndxIn.
- * This method is an specialization of MEDCouplingUMesh::SetPartOfIndexedArrays in the case of assignment do not modify the index in \b arrIndxIn.
- *
- * \param [in] start begin of set of ids of the input extraction (included)
- * \param [in] end end of set of ids of the input extraction (excluded)
- * \param [in] step step of the set of ids in range mode.
- * \param [in,out] arrInOut arr origin array from which the extraction will be done.
- * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
- * \param [in] srcArr input array that will be used as source of copy for ids in [\b idsOfSelectBg, \b idsOfSelectEnd)
- * \param [in] srcArrIndex index array of \b srcArr
- *
- * \sa DataArrayInt::SetPartOfIndexedArraysSlice DataArrayInt::SetPartOfIndexedArraysSameIdx
- */
-void DataArrayInt::SetPartOfIndexedArraysSameIdxSlice(int start, int end, int step, DataArrayInt *arrInOut, const DataArrayInt *arrIndxIn,
-                                                      const DataArrayInt *srcArr, const DataArrayInt *srcArrIndex)
-{
-  if(arrInOut==0 || arrIndxIn==0 || srcArr==0 || srcArrIndex==0)
-    throw INTERP_KERNEL::Exception("DataArrayInt::SetPartOfIndexedArraysSameIdxSlice : presence of null pointer in input parameter !");
-  mcIdType nbOfTuples=ToIdType(arrIndxIn->getNumberOfTuples())-1;
-  const int *arrIndxInPtr=arrIndxIn->begin();
-  const int *srcArrIndexPtr=srcArrIndex->begin();
-  int *arrInOutPtr=arrInOut->getPointer();
-  const int *srcArrPtr=srcArr->begin();
-  int nbOfElemsToSet=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"DataArrayInt::SetPartOfIndexedArraysSameIdxSlice : ");
-  int it=start;
-  for(int i=0;i<nbOfElemsToSet;i++,srcArrIndexPtr++,it+=step)
-    {
-      if(it>=0 && it<nbOfTuples)
-        {
-          if(srcArrIndexPtr[1]-srcArrIndexPtr[0]==arrIndxInPtr[it+1]-arrIndxInPtr[it])
-            std::copy(srcArrPtr+srcArrIndexPtr[0],srcArrPtr+srcArrIndexPtr[1],arrInOutPtr+arrIndxInPtr[it]);
-          else
-            {
-              std::ostringstream oss; oss << "DataArrayInt::SetPartOfIndexedArraysSameIdxSlice : On pos #" << i << " id (idsOfSelectBg[" << i << "]) is " << it << " arrIndxIn[id+1]-arrIndxIn[id]!=srcArrIndex[pos+1]-srcArrIndex[pos] !";
-              throw INTERP_KERNEL::Exception(oss.str());
-            }
-        }
-      else
-        {
-          std::ostringstream oss; oss << "DataArrayInt::SetPartOfIndexedArraysSameIdxSlice : On pos #" << i << " value is " << it << " not in [0," << nbOfTuples << ") !";
-          throw INTERP_KERNEL::Exception(oss.str());
-        }
-    }
-}
-
-
-/*!
- * Returns a C array which is a renumbering map in "Old to New" mode for the input array.
- * This map, if applied to \a start array, would make it sorted. For example, if
- * \a start array contents are [9,10,0,6,4,11,3,7] then the contents of the result array is
- * [5,6,0,3,2,7,1,4].
- *  \param [in] start - pointer to the first element of the array for which the
- *         permutation map is computed.
- *  \param [in] end - pointer specifying the end of the array \a start, so that
- *         the last value of \a start is \a end[ -1 ].
- *  \return int * - the result permutation array that the caller is to delete as it is no
- *         more needed.
- *  \throw If there are equal values in the input array.
- */
-int *DataArrayInt::CheckAndPreparePermutation(const int *start, const int *end)
-{
-  std::size_t sz=std::distance(start,end);
-  int *ret=(int *)malloc(sz*sizeof(int));
-  int *work=new int[sz];
-  std::copy(start,end,work);
-  std::sort(work,work+sz);
-  if(std::unique(work,work+sz)!=work+sz)
-    {
-      delete [] work;
-      free(ret);
-      throw INTERP_KERNEL::Exception("Some elements are equals in the specified array !");
-    }
-  std::map<int,int> m;
-  for(int *workPt=work;workPt!=work+sz;workPt++)
-    m[*workPt]=(int)std::distance(work,workPt);
-  int *iter2=ret;
-  for(const int *iter=start;iter!=end;iter++,iter2++)
-    *iter2=m[*iter];
-  delete [] work;
-  return ret;
-}
-
-/*!
- * Returns a new DataArrayInt containing an arithmetic progression
- * that is equal to the sequence returned by Python \c range(\a begin,\a  end,\a  step )
- * function.
- *  \param [in] begin - the start value of the result sequence.
- *  \param [in] end - limiting value, so that every value of the result array is less than
- *              \a end.
- *  \param [in] step - specifies the increment or decrement.
- *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
- *          array using decrRef() as it is no more needed.
- *  \throw If \a step == 0.
- *  \throw If \a end < \a begin && \a step > 0.
- *  \throw If \a end > \a begin && \a step < 0.
- */
-DataArrayInt *DataArrayInt::Range(int begin, int end, int step)
-{
-  int nbOfTuples=GetNumberOfItemGivenBESRelative(begin,end,step,"DataArrayInt::Range");
-  MCAuto<DataArrayInt> ret=DataArrayInt::New();
-  ret->alloc(nbOfTuples,1);
-  int *ptr=ret->getPointer();
-  if(step>0)
-    {
-      for(int i=begin;i<end;i+=step,ptr++)
-        *ptr=i;
-    }
-  else
-    {
-      for(int i=begin;i>end;i+=step,ptr++)
-        *ptr=i;
-    }
-  return ret.retn();
-}
-
-/*!
- * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
- * Server side.
- */
-void DataArrayInt::getTinySerializationIntInformation(std::vector<int>& tinyInfo) const
-{
-  tinyInfo.resize(2);
-  if(isAllocated())
-    {
-      tinyInfo[0]=ToIdType(getNumberOfTuples());
-      tinyInfo[1]=ToIdType(getNumberOfComponents());
-    }
-  else
-    {
-      tinyInfo[0]=-1;
-      tinyInfo[1]=-1;
-    }
-}
-
-/*!
- * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
- * Server side.
- */
-void DataArrayInt::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
-{
-  if(isAllocated())
-    {
-      mcIdType nbOfCompo=ToIdType(getNumberOfComponents());
-      tinyInfo.resize(nbOfCompo+1);
-      tinyInfo[0]=getName();
-      for(int i=0;i<nbOfCompo;i++)
-        tinyInfo[i+1]=getInfoOnComponent(i);
-    }
-  else
-    {
-      tinyInfo.resize(1);
-      tinyInfo[0]=getName();
-    }
-}
-
-/*!
- * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
- * This method returns if a feeding is needed.
- */
-bool DataArrayInt::resizeForUnserialization(const std::vector<int>& tinyInfoI)
-{
-  int nbOfTuple=tinyInfoI[0];
-  int nbOfComp=tinyInfoI[1];
-  if(nbOfTuple!=-1 || nbOfComp!=-1)
-    {
-      alloc(nbOfTuple,nbOfComp);
-      return true;
-    }
-  return false;
-}
-
-/*!
- * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
- * This method returns if a feeding is needed.
- */
-void DataArrayInt::finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<std::string>& tinyInfoS)
-{
-  setName(tinyInfoS[0]);
-  if(isAllocated())
-    {
-      int nbOfCompo=tinyInfoI[1];
-      for(int i=0;i<nbOfCompo;i++)
-        setInfoOnComponent(i,tinyInfoS[i+1]);
-    }
-}
-
-DataArrayIntIterator::DataArrayIntIterator(DataArrayInt *da):DataArrayIterator<int>(da)
-{
-}
-
-DataArrayInt32Tuple::DataArrayInt32Tuple(int *pt, int nbOfComp):DataArrayTuple<int>(pt,nbOfComp)
-{
-}
-
-std::string DataArrayIntTuple::repr() const
-{
-  std::ostringstream oss; oss << "(";
-  for(int i=0;i<_nb_of_compo-1;i++)
-    oss << _pt[i] << ", ";
-  oss << _pt[_nb_of_compo-1] << ")";
-  return oss.str();
-}
-
-int DataArrayIntTuple::intValue() const
-{
-  return this->zeValue();
-}
-
-/*!
- * This method returns a newly allocated instance the caller should dealed with by a MEDCoupling::DataArrayInt::decrRef.
- * This method performs \b no copy of data. The content is only referenced using MEDCoupling::DataArrayInt::useArray with ownership set to \b false.
- * 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
- * \b nbOfCompo=1 and \bnbOfTuples==this->_nb_of_elem.
- */
-DataArrayInt *DataArrayIntTuple::buildDAInt(int nbOfTuples, int nbOfCompo) const
-{
-  return this->buildDA(nbOfTuples,nbOfCompo);
-}
 
 DataArrayInt64 *DataArrayInt64::deepCopy() const
 {
diff --git a/src/MEDCoupling/MEDCouplingMemArray.hxx b/src/MEDCoupling/MEDCouplingMemArray.hxx
old mode 100644
new mode 100755
index ba2855c40..145ca3fa9
--- a/src/MEDCoupling/MEDCouplingMemArray.hxx
+++ b/src/MEDCoupling/MEDCouplingMemArray.hxx
@@ -523,12 +523,18 @@ namespace MEDCoupling
     ~DataArrayDouble() { }
     DataArrayDouble() { }
   };
+}
 
+namespace MEDCoupling
+{
   template<class T>
   class DataArrayDiscrete : public DataArrayTemplateClassic<T>
   {
   public:
-    MEDCOUPLING_EXPORT static typename Traits<T>::ArrayType *New();
+    typedef typename Traits<T>::ArrayType DataArrayType;
+  public:
+    MEDCOUPLING_EXPORT static DataArrayType *New();
+    MEDCOUPLING_EXPORT T intValue() const;
     MEDCOUPLING_EXPORT bool isEqual(const DataArrayDiscrete<T>& other) const;
     MEDCOUPLING_EXPORT bool isEqualIfNotWhy(const DataArrayDiscrete<T>& other, std::string& reason) const;
     MEDCOUPLING_EXPORT bool isEqualWithoutConsideringStr(const DataArrayDiscrete<T>& other) const;
@@ -541,14 +547,126 @@ namespace MEDCoupling
     MEDCOUPLING_EXPORT bool isMonotonic(bool increasing) const;
     MEDCOUPLING_EXPORT void checkStrictlyMonotonic(bool increasing) const;
     MEDCOUPLING_EXPORT bool isStrictlyMonotonic(bool increasing) const;
-    MEDCOUPLING_EXPORT int getHashCode() const;
+    MEDCOUPLING_EXPORT mcIdType getHashCode() const;
     MEDCOUPLING_EXPORT void reprCppStream(const std::string& varName, std::ostream& stream) const;
     MEDCOUPLING_EXPORT void reprQuickOverview(std::ostream& stream) const;
     MEDCOUPLING_EXPORT void reprQuickOverviewData(std::ostream& stream, std::size_t maxNbOfByteInRepr) const;
     MEDCOUPLING_EXPORT void writeVTK(std::ostream& ofs, int indent, const std::string& type, const std::string& nameInFile, DataArrayByte *byteArr) const;
     MEDCOUPLING_EXPORT void transformWithIndArr(const T *indArrBg, const T *indArrEnd);
-    MEDCOUPLING_EXPORT void transformWithIndArr(const MapKeyVal<T>& m);
+    MEDCOUPLING_EXPORT void transformWithIndArr(const MapKeyVal<T, T>& m);
     MEDCOUPLING_EXPORT DataArrayIdType *findIdsEqual(T val) const;
+    MEDCOUPLING_EXPORT DataArrayIdType *transformWithIndArrR(const T *indArr2Bg, const T *indArrEnd) const;
+    MEDCOUPLING_EXPORT void splitByValueRange(const T *arrBg, const T *arrEnd,
+                                              DataArrayType *& castArr, DataArrayType *& rankInsideCast, DataArrayType *& castsPresent) const;
+    MEDCOUPLING_EXPORT bool isRange(T& strt, T& sttoopp, T& stteepp) const;
+    MEDCOUPLING_EXPORT DataArrayIdType *invertArrayO2N2N2O(mcIdType newNbOfElem) const;
+    MEDCOUPLING_EXPORT DataArrayIdType *invertArrayN2O2O2N(mcIdType oldNbOfElem) const;
+    MEDCOUPLING_EXPORT DataArrayIdType *invertArrayO2N2N2OBis(mcIdType newNbOfElem) const;
+    MEDCOUPLING_EXPORT MCAuto< MapKeyVal<T, mcIdType> > invertArrayN2O2O2NOptimized() const;
+    MEDCOUPLING_EXPORT MCAuto< MapKeyVal<mcIdType, T> > giveN2OOptimized() const;
+    MEDCOUPLING_EXPORT MCAuto<DataArrayIdType> findIdForEach(const T *valsBg, const T *valsEnd) const;
+    MEDCOUPLING_EXPORT DataArrayIdType *checkAndPreparePermutation() const;
+    MEDCOUPLING_EXPORT void changeSurjectiveFormat(T targetNb, DataArrayIdType *&arr, DataArrayIdType *&arrI) const;
+    MEDCOUPLING_EXPORT DataArrayIdType *buildPermArrPerLevel() const;
+    MEDCOUPLING_EXPORT bool isIota(mcIdType sizeExpected) const;
+    MEDCOUPLING_EXPORT bool isUniform(T val) const;
+    MEDCOUPLING_EXPORT T checkUniformAndGuess() const;
+    MEDCOUPLING_EXPORT bool hasUniqueValues() const;
+    MEDCOUPLING_EXPORT void setSelectedComponents(const DataArrayType *a, const std::vector<mcIdType>& compoIds);
+    MEDCOUPLING_EXPORT DataArrayIdType *findIdsNotEqual(T val) const;
+    MEDCOUPLING_EXPORT DataArrayIdType *findIdsEqualTuple(const T *tupleBg, const T *tupleEnd) const;
+    MEDCOUPLING_EXPORT DataArrayIdType *findIdsEqualList(const T *valsBg, const T *valsEnd) const;
+    MEDCOUPLING_EXPORT DataArrayIdType *findIdsNotEqualList(const T *valsBg, const T *valsEnd) const;
+    MEDCOUPLING_EXPORT mcIdType findIdFirstEqual(T value) const;
+    MEDCOUPLING_EXPORT mcIdType findIdFirstEqual(const std::vector<T>& vals) const;
+    MEDCOUPLING_EXPORT mcIdType findIdFirstEqualTuple(const std::vector<T>& tupl) const;
+    MEDCOUPLING_EXPORT mcIdType findIdSequence(const std::vector<T>& vals) const;
+    MEDCOUPLING_EXPORT mcIdType changeValue(T oldValue, T newValue);
+    MEDCOUPLING_EXPORT mcIdType count(T value) const;
+    MEDCOUPLING_EXPORT bool presenceOfTuple(const std::vector<T>& tupl) const;
+    MEDCOUPLING_EXPORT bool presenceOfValue(T value) const;
+    MEDCOUPLING_EXPORT bool presenceOfValue(const std::vector<T>& vals) const;
+    MEDCOUPLING_EXPORT void accumulate(T *res) const;
+    MEDCOUPLING_EXPORT T accumulate(mcIdType compId) const;
+    MEDCOUPLING_EXPORT DataArrayType *accumulatePerChunck(const mcIdType *bgOfIndex, const mcIdType *endOfIndex) const;
+    MEDCOUPLING_EXPORT void getMinMaxValues(T& minValue, T& maxValue) const;
+    MEDCOUPLING_EXPORT void applyInv(T numerator);
+    MEDCOUPLING_EXPORT void applyDivideBy(T val);
+    MEDCOUPLING_EXPORT void applyModulus(T val);
+    MEDCOUPLING_EXPORT void applyRModulus(T val);
+    MEDCOUPLING_EXPORT void applyPow(T val);
+    MEDCOUPLING_EXPORT void applyRPow(T val);
+    MEDCOUPLING_EXPORT DataArrayIdType *findIdsInRange(T vmin, T vmax) const;
+    MEDCOUPLING_EXPORT DataArrayIdType *findIdsNotInRange(T vmin, T vmax) const;
+    MEDCOUPLING_EXPORT bool checkAllIdsInRange(T vmin, T vmax) const;
+    MEDCOUPLING_EXPORT static DataArrayType *Aggregate(const DataArrayType *a1, const DataArrayType *a2, T offsetA2);
+    MEDCOUPLING_EXPORT static DataArrayType *Aggregate(const std::vector<const DataArrayType *>& arr);
+    MEDCOUPLING_EXPORT static DataArrayType *AggregateIndexes(const std::vector<const DataArrayType *>& arrs);
+    MEDCOUPLING_EXPORT static DataArrayType *BuildUnion(const std::vector<const DataArrayType *>& arr);
+    MEDCOUPLING_EXPORT static DataArrayType *BuildIntersection(const std::vector<const DataArrayType *>& arr);
+    MEDCOUPLING_EXPORT static void PutIntoToSkylineFrmt(const std::vector< std::vector<T> >& v, DataArrayType *& data, DataArrayIdType *& dataIndex);
+    MEDCOUPLING_EXPORT DataArrayIdType *buildComplement(mcIdType nbOfElement) const;
+    MEDCOUPLING_EXPORT DataArrayType *buildSubstraction(const DataArrayType *other) const;
+    MEDCOUPLING_EXPORT DataArrayType *buildSubstractionOptimized(const DataArrayType *other) const;
+    MEDCOUPLING_EXPORT DataArrayType *buildUnion(const DataArrayType *other) const;
+    MEDCOUPLING_EXPORT DataArrayType *buildIntersection(const DataArrayType *other) const;
+    MEDCOUPLING_EXPORT DataArrayType *buildUnique() const;
+    MEDCOUPLING_EXPORT DataArrayType *buildUniqueNotSorted() const;
+    MEDCOUPLING_EXPORT DataArrayType *deltaShiftIndex() const;
+    MEDCOUPLING_EXPORT void computeOffsets();
+    MEDCOUPLING_EXPORT void computeOffsetsFull();
+    MEDCOUPLING_EXPORT void findIdsRangesInListOfIds(const DataArrayType *listOfIds, DataArrayIdType *& rangeIdsFetched, DataArrayType *& idsInInputListThatFetch) const;
+    MEDCOUPLING_EXPORT DataArrayType *buildExplicitArrByRanges(const DataArrayType *offsets) const;
+    MEDCOUPLING_EXPORT DataArrayType *buildExplicitArrOfSliceOnScaledArr(T begin, T stop, T step) const;
+    MEDCOUPLING_EXPORT DataArrayIdType *findRangeIdForEachTuple(const DataArrayType *ranges) const;
+    MEDCOUPLING_EXPORT DataArrayType *findIdInRangeForEachTuple(const DataArrayType *ranges) const;
+    MEDCOUPLING_EXPORT void sortEachPairToMakeALinkedList();
+    MEDCOUPLING_EXPORT MCAuto<DataArrayType> fromLinkedListOfPairToList() const;
+    MEDCOUPLING_EXPORT DataArrayType *getDifferentValues() const;
+    MEDCOUPLING_EXPORT std::vector<DataArrayIdType *> partitionByDifferentValues(std::vector<T>& differentIds) const;
+    MEDCOUPLING_EXPORT std::vector< std::pair<mcIdType,mcIdType> > splitInBalancedSlices(mcIdType nbOfSlices) const;
+    MEDCOUPLING_EXPORT static DataArrayType *Modulus(const DataArrayType *a1, const DataArrayType *a2);
+    MEDCOUPLING_EXPORT void modulusEqual(const DataArrayType *other);
+    MEDCOUPLING_EXPORT static DataArrayType *Pow(const DataArrayType *a1, const DataArrayType *a2);
+    MEDCOUPLING_EXPORT void powEqual(const DataArrayType *other);
+    //MEDCOUPLING_EXPORT MemArray<T>& accessToMemArray() { return _mem; }
+    //MEDCOUPLING_EXPORT const MemArray<T>& accessToMemArray() const { return _mem; }
+  public:
+    MEDCOUPLING_EXPORT static DataArrayIdType *FindPermutationFromFirstToSecond(const DataArrayType *ids1, const DataArrayType *ids2);
+    MEDCOUPLING_EXPORT static mcIdType *CheckAndPreparePermutation(const T *start, const T *end);
+    MEDCOUPLING_EXPORT static DataArrayType *BuildListOfSwitchedOn(const std::vector<bool>& v);
+    MEDCOUPLING_EXPORT static DataArrayType *BuildListOfSwitchedOff(const std::vector<bool>& v);
+    MEDCOUPLING_EXPORT static DataArrayIdType *ConvertIndexArrayToO2N(mcIdType nbOfOldTuples, const T *arr, const mcIdType *arrIBg, const mcIdType *arrIEnd, mcIdType &newNbOfTuples);
+    MEDCOUPLING_EXPORT static DataArrayIdType *MakePartition(const std::vector<const DataArrayType *>& groups, mcIdType newNb, std::vector< std::vector<mcIdType> >& fidsOfGroups);
+  public:
+    MEDCOUPLING_EXPORT static void ExtractFromIndexedArrays(const mcIdType *idsOfSelectBg, const mcIdType *idsOfSelectEnd,
+                                                            const DataArrayType *arrIn, const DataArrayIdType *arrIndxIn,
+                                                            DataArrayType* &arrOut, DataArrayIdType* &arrIndexOut);
+    MEDCOUPLING_EXPORT static void ExtractFromIndexedArraysSlice(mcIdType idsOfSelectStart, mcIdType idsOfSelectStop, mcIdType idsOfSelectStep,
+                                                                 const DataArrayType *arrIn, const DataArrayIdType *arrIndxIn,
+                                                                 DataArrayType* &arrOut, DataArrayIdType* &arrIndexOut);
+    MEDCOUPLING_EXPORT static void SetPartOfIndexedArrays(const mcIdType *idsOfSelectBg, const mcIdType *idsOfSelectEnd,
+                                                          const DataArrayType *arrIn, const DataArrayIdType *arrIndxIn,
+                                                          const DataArrayType *srcArr, const DataArrayIdType *srcArrIndex,
+                                                          DataArrayType* &arrOut, DataArrayIdType* &arrIndexOut);
+    MEDCOUPLING_EXPORT static void SetPartOfIndexedArraysSlice(mcIdType start, mcIdType end, mcIdType step,
+                                                               const DataArrayType *arrIn, const DataArrayIdType *arrIndxIn,
+                                                               const DataArrayType *srcArr, const DataArrayIdType *srcArrIndex,
+                                                               DataArrayType* &arrOut, DataArrayIdType* &arrIndexOut);
+    MEDCOUPLING_EXPORT static void SetPartOfIndexedArraysSameIdx(const mcIdType *idsOfSelectBg, const mcIdType *idsOfSelectEnd,
+                                                                 DataArrayType *arrInOut, const DataArrayIdType *arrIndxIn,
+                                                                 const DataArrayType *srcArr, const DataArrayIdType *srcArrIndex);
+    MEDCOUPLING_EXPORT static void SetPartOfIndexedArraysSameIdxSlice(mcIdType start, mcIdType end, mcIdType step,
+                                                                      DataArrayType *arrInOut, const DataArrayIdType *arrIndxIn,
+                                                                      const DataArrayType *srcArr, const DataArrayIdType *srcArrIndex);
+    MEDCOUPLING_EXPORT static bool RemoveIdsFromIndexedArrays(const T *idsToRemoveBg, const T *idsToRemoveEnd,
+                                                              DataArrayType *arr, DataArrayIdType *arrIndx, mcIdType offsetForRemoval=0);
+    MEDCOUPLING_EXPORT static DataArrayType *Range(T begin, T end, T step);
+  public:
+    MEDCOUPLING_EXPORT void getTinySerializationIntInformation(std::vector<int>& tinyInfo) const;
+    MEDCOUPLING_EXPORT void getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const;
+    MEDCOUPLING_EXPORT bool resizeForUnserialization(const std::vector<int>& tinyInfoI);
+    MEDCOUPLING_EXPORT void finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<std::string>& tinyInfoS);
   protected:
     template<class ALG>
     void switchOnTupleAlg(T val, std::vector<bool>& vec, ALG algo) const;
@@ -571,120 +689,17 @@ namespace MEDCoupling
   {
     friend class DataArrayDiscrete<Int32>;
   public:
-    MEDCOUPLING_EXPORT int intValue() const;
     MEDCOUPLING_EXPORT DataArrayInt32 *deepCopy() const;//ok
     MEDCOUPLING_EXPORT DataArrayInt32 *buildNewEmptyInstance() const { return DataArrayInt32::New(); }//ok
-    MEDCOUPLING_EXPORT DataArrayInt32 *transformWithIndArrR(const int *indArr2Bg, const int *indArrEnd) const;
-    MEDCOUPLING_EXPORT void splitByValueRange(const int *arrBg, const int *arrEnd,
-                                              DataArrayInt32 *& castArr, DataArrayInt32 *& rankInsideCast, DataArrayInt32 *& castsPresent) const;
-    MEDCOUPLING_EXPORT bool isRange(int& strt, int& sttoopp, int& stteepp) const;
-    MEDCOUPLING_EXPORT DataArrayInt32 *invertArrayO2N2N2O(int newNbOfElem) const;
-    MEDCOUPLING_EXPORT DataArrayInt32 *invertArrayN2O2O2N(int oldNbOfElem) const;
-    MEDCOUPLING_EXPORT MCAuto< MapKeyVal<int> > invertArrayN2O2O2NOptimized() const;
-    MEDCOUPLING_EXPORT MCAuto< MapKeyVal<int> > giveN2OOptimized() const;
-    MEDCOUPLING_EXPORT DataArrayInt32 *invertArrayO2N2N2OBis(int newNbOfElem) const;
+  public:
     MEDCOUPLING_EXPORT DataArrayInt32 *selectByTupleId(const mcIdType *new2OldBg, const mcIdType *new2OldEnd) const { return this->mySelectByTupleId(new2OldBg,new2OldEnd); }
     MEDCOUPLING_EXPORT DataArrayInt32 *selectByTupleId(const DataArrayIdType& di) const { return this->mySelectByTupleId(di); }
     MEDCOUPLING_EXPORT DataArrayInt32 *selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const { return DataArrayTemplate<int>::mySelectByTupleIdSafe(new2OldBg,new2OldEnd); }
     MEDCOUPLING_EXPORT DataArrayInt32 *keepSelectedComponents(const std::vector<int>& compoIds) const { return DataArrayTemplate<int>::myKeepSelectedComponents(compoIds); }
     MEDCOUPLING_EXPORT DataArrayInt32 *selectByTupleIdSafeSlice(int bg, int end2, int step) const { return DataArrayTemplate<int>::mySelectByTupleIdSafeSlice(bg,end2,step); }
     MEDCOUPLING_EXPORT DataArrayInt32 *selectByTupleRanges(const std::vector<std::pair<int,int> >& ranges) const { return DataArrayTemplate<int>::mySelectByTupleRanges(ranges); }
-    MEDCOUPLING_EXPORT DataArrayInt32 *checkAndPreparePermutation() const;
-    MEDCOUPLING_EXPORT static DataArrayInt32 *FindPermutationFromFirstToSecond(const DataArrayInt32 *ids1, const DataArrayInt32 *ids2);
-    MEDCOUPLING_EXPORT void changeSurjectiveFormat(int targetNb, DataArrayInt32 *&arr, DataArrayInt32 *&arrI) const;
-    MEDCOUPLING_EXPORT static DataArrayInt32 *ConvertIndexArrayToO2N(int nbOfOldTuples, const int *arr, const int *arrIBg, const int *arrIEnd, int &newNbOfTuples);
-    MEDCOUPLING_EXPORT DataArrayInt32 *buildPermArrPerLevel() const;
-    MEDCOUPLING_EXPORT bool isIota(int sizeExpected) const;
-    MEDCOUPLING_EXPORT bool isUniform(int val) const;
-    MEDCOUPLING_EXPORT int checkUniformAndGuess() const;
-    MEDCOUPLING_EXPORT bool hasUniqueValues() const;
-    MEDCOUPLING_EXPORT void setSelectedComponents(const DataArrayInt32 *a, const std::vector<int>& compoIds);
-    MEDCOUPLING_EXPORT DataArrayInt32Iterator *iterator();
-    MEDCOUPLING_EXPORT DataArrayInt32 *findIdsNotEqual(int val) const;
-    MEDCOUPLING_EXPORT DataArrayInt32 *findIdsEqualList(const int *valsBg, const int *valsEnd) const;
-    MEDCOUPLING_EXPORT DataArrayInt32 *findIdsNotEqualList(const int *valsBg, const int *valsEnd) const;
-    MEDCOUPLING_EXPORT DataArrayInt32 *findIdsEqualTuple(const int *tupleBg, const int *tupleEnd) const;
-    MEDCOUPLING_EXPORT MCAuto<DataArrayInt32> findIdForEach(const int *valsBg, const int *valsEnd) const;
-    MEDCOUPLING_EXPORT int changeValue(int oldValue, int newValue);
-    MEDCOUPLING_EXPORT int findIdFirstEqualTuple(const std::vector<int>& tupl) const;
-    MEDCOUPLING_EXPORT int findIdFirstEqual(int value) const;
-    MEDCOUPLING_EXPORT int findIdFirstEqual(const std::vector<int>& vals) const;
-    MEDCOUPLING_EXPORT int findIdSequence(const std::vector<int>& vals) const;
-    MEDCOUPLING_EXPORT bool presenceOfTuple(const std::vector<int>& tupl) const;
-    MEDCOUPLING_EXPORT bool presenceOfValue(int value) const;
-    MEDCOUPLING_EXPORT bool presenceOfValue(const std::vector<int>& vals) const;
-    MEDCOUPLING_EXPORT int count(int value) const;
-    MEDCOUPLING_EXPORT void accumulate(int *res) const;
-    MEDCOUPLING_EXPORT int accumulate(int compId) const;
-    MEDCOUPLING_EXPORT DataArrayInt32 *accumulatePerChunck(const int *bgOfIndex, const int *endOfIndex) const;
-    MEDCOUPLING_EXPORT void getMinMaxValues(int& minValue, int& maxValue) const;
-    MEDCOUPLING_EXPORT void applyInv(int numerator);
-    MEDCOUPLING_EXPORT void applyDivideBy(int val);
-    MEDCOUPLING_EXPORT void applyModulus(int val);
-    MEDCOUPLING_EXPORT void applyRModulus(int val);
-    MEDCOUPLING_EXPORT void applyPow(int val);
-    MEDCOUPLING_EXPORT void applyRPow(int val);
-    MEDCOUPLING_EXPORT DataArrayInt32 *findIdsInRange(int vmin, int vmax) const;
-    MEDCOUPLING_EXPORT DataArrayInt32 *findIdsNotInRange(int vmin, int vmax) const;
-    MEDCOUPLING_EXPORT bool checkAllIdsInRange(int vmin, int vmax) const;
-    MEDCOUPLING_EXPORT static DataArrayInt32 *Aggregate(const DataArrayInt32 *a1, const DataArrayInt32 *a2, int offsetA2);
-    MEDCOUPLING_EXPORT static DataArrayInt32 *Aggregate(const std::vector<const DataArrayInt32 *>& arr);
-    MEDCOUPLING_EXPORT static DataArrayInt32 *AggregateIndexes(const std::vector<const DataArrayInt32 *>& arrs);
-    MEDCOUPLING_EXPORT static DataArrayInt32 *MakePartition(const std::vector<const DataArrayInt32 *>& groups, int newNb, std::vector< std::vector<int> >& fidsOfGroups);
-    MEDCOUPLING_EXPORT static DataArrayInt32 *BuildUnion(const std::vector<const DataArrayInt32 *>& arr);
-    MEDCOUPLING_EXPORT static DataArrayInt32 *BuildIntersection(const std::vector<const DataArrayInt32 *>& arr);
-    MEDCOUPLING_EXPORT static DataArrayInt32 *BuildListOfSwitchedOn(const std::vector<bool>& v);
-    MEDCOUPLING_EXPORT static DataArrayInt32 *BuildListOfSwitchedOff(const std::vector<bool>& v);
-    MEDCOUPLING_EXPORT static void PutIntoToSkylineFrmt(const std::vector< std::vector<int> >& v, DataArrayInt32 *& data, DataArrayInt32 *& dataIndex);
-    MEDCOUPLING_EXPORT DataArrayInt32 *buildComplement(int nbOfElement) const;
-    MEDCOUPLING_EXPORT DataArrayInt32 *buildSubstraction(const DataArrayInt32 *other) const;
-    MEDCOUPLING_EXPORT DataArrayInt32 *buildSubstractionOptimized(const DataArrayInt32 *other) const;
-    MEDCOUPLING_EXPORT DataArrayInt32 *buildUnion(const DataArrayInt32 *other) const;
-    MEDCOUPLING_EXPORT DataArrayInt32 *buildIntersection(const DataArrayInt32 *other) const;
-    MEDCOUPLING_EXPORT DataArrayInt32 *buildUnique() const;
-    MEDCOUPLING_EXPORT DataArrayInt32 *buildUniqueNotSorted() const;
-    MEDCOUPLING_EXPORT DataArrayInt32 *deltaShiftIndex() const;
-    MEDCOUPLING_EXPORT void computeOffsets();
-    MEDCOUPLING_EXPORT void computeOffsetsFull();
-    MEDCOUPLING_EXPORT void findIdsRangesInListOfIds(const DataArrayInt32 *listOfIds, DataArrayInt32 *& rangeIdsFetched, DataArrayInt32 *& idsInInputListThatFetch) const;
-    MEDCOUPLING_EXPORT DataArrayInt32 *buildExplicitArrByRanges(const DataArrayInt32 *offsets) const;
-    MEDCOUPLING_EXPORT DataArrayInt32 *buildExplicitArrOfSliceOnScaledArr(int begin, int stop, int step) const;
-    MEDCOUPLING_EXPORT DataArrayInt32 *findRangeIdForEachTuple(const DataArrayInt32 *ranges) const;
-    MEDCOUPLING_EXPORT DataArrayInt32 *findIdInRangeForEachTuple(const DataArrayInt32 *ranges) const;
-    MEDCOUPLING_EXPORT void sortEachPairToMakeALinkedList();
-    MEDCOUPLING_EXPORT MCAuto<DataArrayInt32> fromLinkedListOfPairToList() const;
-    MEDCOUPLING_EXPORT DataArrayInt32 *getDifferentValues() const;
-    MEDCOUPLING_EXPORT std::vector<DataArrayInt32 *> partitionByDifferentValues(std::vector<int>& differentIds) const;
-    MEDCOUPLING_EXPORT std::vector< std::pair<int,int> > splitInBalancedSlices(int nbOfSlices) const;
-    MEDCOUPLING_EXPORT static DataArrayInt32 *Modulus(const DataArrayInt32 *a1, const DataArrayInt32 *a2);
-    MEDCOUPLING_EXPORT void modulusEqual(const DataArrayInt32 *other);
-    MEDCOUPLING_EXPORT static DataArrayInt32 *Pow(const DataArrayInt32 *a1, const DataArrayInt32 *a2);
-    MEDCOUPLING_EXPORT void powEqual(const DataArrayInt32 *other);
-    MEDCOUPLING_EXPORT MemArray<int>& accessToMemArray() { return _mem; }
-    MEDCOUPLING_EXPORT const MemArray<int>& accessToMemArray() const { return _mem; }
-  public:
-    MEDCOUPLING_EXPORT static void ExtractFromIndexedArrays(const int *idsOfSelectBg, const int *idsOfSelectEnd, const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn,
-                                                    DataArrayInt* &arrOut, DataArrayInt* &arrIndexOut);
-    MEDCOUPLING_EXPORT static void ExtractFromIndexedArraysSlice(int idsOfSelectStart, int idsOfSelectStop, int idsOfSelectStep, const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn,
-                                                     DataArrayInt* &arrOut, DataArrayInt* &arrIndexOut);
-    MEDCOUPLING_EXPORT static void SetPartOfIndexedArrays(const int *idsOfSelectBg, const int *idsOfSelectEnd, const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn,
-                                                  const DataArrayInt *srcArr, const DataArrayInt *srcArrIndex,
-                                                  DataArrayInt* &arrOut, DataArrayInt* &arrIndexOut);
-    MEDCOUPLING_EXPORT static void SetPartOfIndexedArraysSlice(int start, int end, int step, const DataArrayInt *arrIn, const DataArrayInt *arrIndxIn,
-                                                   const DataArrayInt *srcArr, const DataArrayInt *srcArrIndex,
-                                                   DataArrayInt* &arrOut, DataArrayInt* &arrIndexOut);
-    MEDCOUPLING_EXPORT static void SetPartOfIndexedArraysSameIdx(const int *idsOfSelectBg, const int *idsOfSelectEnd, DataArrayInt *arrInOut, const DataArrayInt *arrIndxIn,
-                                                         const DataArrayInt *srcArr, const DataArrayInt *srcArrIndex);
-    MEDCOUPLING_EXPORT static void SetPartOfIndexedArraysSameIdxSlice(int start, int end, int step, DataArrayInt *arrInOut, const DataArrayInt *arrIndxIn,
-                                                          const DataArrayInt *srcArr, const DataArrayInt *srcArrIndex);
-    MEDCOUPLING_EXPORT static bool RemoveIdsFromIndexedArrays(const int *idsToRemoveBg, const int *idsToRemoveEnd, DataArrayInt *arr, DataArrayInt *arrIndx, int offsetForRemoval=0);
-    MEDCOUPLING_EXPORT static int *CheckAndPreparePermutation(const int *start, const int *end);
-    MEDCOUPLING_EXPORT static DataArrayInt32 *Range(int begin, int end, int step);
   public:
-    MEDCOUPLING_EXPORT void getTinySerializationIntInformation(std::vector<int>& tinyInfo) const;
-    MEDCOUPLING_EXPORT void getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const;
-    MEDCOUPLING_EXPORT bool resizeForUnserialization(const std::vector<int>& tinyInfoI);
-    MEDCOUPLING_EXPORT void finishUnserialization(const std::vector<int>& tinyInfoI, const std::vector<std::string>& tinyInfoS);
+    MEDCOUPLING_EXPORT DataArrayInt32Iterator *iterator();
   private:
     ~DataArrayInt32() { }
     DataArrayInt32() { }
@@ -696,17 +711,24 @@ namespace MEDCoupling
   public:
     MEDCOUPLING_EXPORT DataArrayInt64 *deepCopy() const;
     MEDCOUPLING_EXPORT DataArrayInt64 *buildNewEmptyInstance() const { return DataArrayInt64::New(); }//ok
+  public:
     MEDCOUPLING_EXPORT DataArrayInt64 *selectByTupleId(const mcIdType *new2OldBg, const mcIdType *new2OldEnd) const { return this->mySelectByTupleId(new2OldBg,new2OldEnd); }
     MEDCOUPLING_EXPORT DataArrayInt64 *selectByTupleId(const DataArrayIdType& di) const { return this->mySelectByTupleId(di); }
     MEDCOUPLING_EXPORT DataArrayInt64 *selectByTupleIdSafe(const int *new2OldBg, const int *new2OldEnd) const { return DataArrayTemplate<Int64>::mySelectByTupleIdSafe(new2OldBg,new2OldEnd); }
     MEDCOUPLING_EXPORT DataArrayInt64 *keepSelectedComponents(const std::vector<int>& compoIds) const { return DataArrayTemplate<Int64>::myKeepSelectedComponents(compoIds); }
     MEDCOUPLING_EXPORT DataArrayInt64 *selectByTupleIdSafeSlice(int bg, int end2, int step) const { return DataArrayTemplate<Int64>::mySelectByTupleIdSafeSlice(bg,end2,step); }
     MEDCOUPLING_EXPORT DataArrayInt64 *selectByTupleRanges(const std::vector<std::pair<int,int> >& ranges) const { return DataArrayTemplate<Int64>::mySelectByTupleRanges(ranges); }
+  public:
+    MEDCOUPLING_EXPORT DataArrayInt64Iterator *iterator();
   private:
     ~DataArrayInt64() { }
     DataArrayInt64() { }
   };
-  
+}
+
+namespace MEDCoupling
+{
+
   template<class T>
   template<class OP>
   MCAuto<DataArrayInt> DataArrayTemplateClassic<T>::findIdsAdv(const OP& op) const
@@ -832,26 +854,26 @@ namespace MEDCoupling
   private:
     typename Traits<T>::ArrayType *_da;
     T *_pt;
-    int _tuple_id;
-    int _nb_comp;
-    int _nb_tuple;
+    mcIdType _tuple_id;
+    mcIdType _nb_comp;
+    mcIdType _nb_tuple;
   };
 
   template<class T>
   class DataArrayTuple
   {
   public:
-    MEDCOUPLING_EXPORT DataArrayTuple(T *pt, int nbOfComp);
+    MEDCOUPLING_EXPORT DataArrayTuple(T *pt, mcIdType nbOfComp);
     //MEDCOUPLING_EXPORT std::string repr() const;
-    MEDCOUPLING_EXPORT int getNumberOfCompo() const { return _nb_of_compo; }
+    MEDCOUPLING_EXPORT mcIdType getNumberOfCompo() const { return _nb_of_compo; }
     MEDCOUPLING_EXPORT const T *getConstPointer() const { return  _pt; }
     MEDCOUPLING_EXPORT T *getPointer() { return _pt; }
-    MEDCOUPLING_EXPORT typename Traits<T>::ArrayType *buildDA(int nbOfTuples, int nbOfCompo) const;
+    MEDCOUPLING_EXPORT typename Traits<T>::ArrayType *buildDA(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
   protected:
     T zeValue() const;
   protected:
     T *_pt;
-    int _nb_of_compo;
+    mcIdType _nb_of_compo;
   };
 
   class DataArrayDoubleTuple;
@@ -866,10 +888,10 @@ namespace MEDCoupling
   class DataArrayDoubleTuple : public DataArrayTuple<double>
   {
   public:
-    MEDCOUPLING_EXPORT DataArrayDoubleTuple(double *pt, int nbOfComp);
+    MEDCOUPLING_EXPORT DataArrayDoubleTuple(double *pt, mcIdType nbOfComp);
     MEDCOUPLING_EXPORT std::string repr() const;
     MEDCOUPLING_EXPORT double doubleValue() const;
-    MEDCOUPLING_EXPORT DataArrayDouble *buildDADouble(int nbOfTuples, int nbOfCompo) const;
+    MEDCOUPLING_EXPORT DataArrayDouble *buildDADouble(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
   };
 
   class DataArrayFloatTuple;
@@ -884,26 +906,42 @@ namespace MEDCoupling
   class DataArrayFloatTuple : public DataArrayTuple<float>
   {
   public:
-    MEDCOUPLING_EXPORT DataArrayFloatTuple(float *pt, int nbOfComp);
+    MEDCOUPLING_EXPORT DataArrayFloatTuple(float *pt, mcIdType nbOfComp);
     MEDCOUPLING_EXPORT std::string repr() const;
     MEDCOUPLING_EXPORT float floatValue() const;
-    MEDCOUPLING_EXPORT DataArrayFloat *buildDAFloat(int nbOfTuples, int nbOfCompo) const;
+    MEDCOUPLING_EXPORT DataArrayFloat *buildDAFloat(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
   };
   
-  class DataArrayIntIterator : public DataArrayIterator<int>
+  class DataArrayInt32Iterator : public DataArrayIterator<Int32>
+  {
+  public:
+    MEDCOUPLING_EXPORT DataArrayInt32Iterator(DataArrayInt32 *da);
+    MEDCOUPLING_EXPORT ~DataArrayInt32Iterator() { }
+  };
+
+  class DataArrayInt64Iterator : public DataArrayIterator<Int64>
   {
   public:
-    MEDCOUPLING_EXPORT DataArrayIntIterator(DataArrayInt *da);
-    MEDCOUPLING_EXPORT ~DataArrayIntIterator() { }
+    MEDCOUPLING_EXPORT DataArrayInt64Iterator(DataArrayInt64 *da);
+    MEDCOUPLING_EXPORT ~DataArrayInt64Iterator() { }
   };
 
   class DataArrayInt32Tuple : public DataArrayTuple<Int32>
   {
   public:
-    MEDCOUPLING_EXPORT DataArrayInt32Tuple(int *pt, int nbOfComp);
+    MEDCOUPLING_EXPORT DataArrayInt32Tuple(Int32 *pt, mcIdType nbOfComp);
+    MEDCOUPLING_EXPORT std::string repr() const;
+    MEDCOUPLING_EXPORT Int32 intValue() const;
+    MEDCOUPLING_EXPORT DataArrayInt32 *buildDAInt(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
+  };
+
+  class DataArrayInt64Tuple : public DataArrayTuple<Int64>
+  {
+  public:
+    MEDCOUPLING_EXPORT DataArrayInt64Tuple(Int64 *pt, mcIdType nbOfComp);
     MEDCOUPLING_EXPORT std::string repr() const;
-    MEDCOUPLING_EXPORT int intValue() const;
-    MEDCOUPLING_EXPORT DataArrayInt32 *buildDAInt(int nbOfTuples, int nbOfCompo) const;
+    MEDCOUPLING_EXPORT Int64 intValue() const;
+    MEDCOUPLING_EXPORT DataArrayInt64 *buildDAInt(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
   };
 
   typedef DataArrayInt32Tuple DataArrayIntTuple;
diff --git a/src/MEDCoupling/MEDCouplingMemArray.txx b/src/MEDCoupling/MEDCouplingMemArray.txx
index 9fde4127d..5456c4cf2 100755
--- a/src/MEDCoupling/MEDCouplingMemArray.txx
+++ b/src/MEDCoupling/MEDCouplingMemArray.txx
@@ -28,6 +28,7 @@
 #include "MEDCouplingPartDefinition.hxx"
 #include "InterpKernelAutoPtr.hxx"
 #include "MCAuto.hxx"
+#include "MEDCouplingMap.txx"
 
 #include <sstream>
 #include <cstdlib>
@@ -3468,6 +3469,30 @@ struct NotInRange
     return true;
   }
 
+  /////////////////////////////////
+
+  /*!
+   * Returns the only one value in \a this, if and only if number of elements
+   * (nb of tuples * nb of components) is equal to 1, and that \a this is allocated.
+   *  \return double - the sole value stored in \a this array.
+   *  \throw If at least one of conditions stated above is not fulfilled.
+   */
+  template <class T>
+  T DataArrayDiscrete<T>::intValue() const
+  {
+    if(this->isAllocated())
+      {
+        if(this->getNbOfElems()==1)
+          {
+            return *this->getConstPointer();
+          }
+        else
+          throw INTERP_KERNEL::Exception("DataArrayInt::intValue : DataArrayInt instance is allocated but number of elements is not equal to 1 !");
+      }
+    else
+      throw INTERP_KERNEL::Exception("DataArrayInt::intValue : DataArrayInt instance is not allocated !");
+  }
+
   /*!
    * Equivalent to DataArrayInt::isEqual except that if false the reason of
    * mismatch is given.
@@ -3796,7 +3821,7 @@ struct NotInRange
    *  \throw If \a this is not allocated.
    */
   template<class T>
-  int DataArrayDiscrete<T>::getHashCode() const
+  mcIdType DataArrayDiscrete<T>::getHashCode() const
   {
     this->checkAllocated();
     mcIdType nbOfElems=ToIdType(this->getNbOfElems());
@@ -3808,7 +3833,7 @@ struct NotInRange
     const T *pt(this->begin());
     for(mcIdType i=0;i<nbOfElems;i+=delta)
       ret0+=pt[i] & 0x1FFF;
-    return int(ret+ret0);
+    return ToIdType(ret+ret0);
   }
 
   template<class T>
@@ -3971,7 +3996,7 @@ struct NotInRange
   }
 
   template<class T>
-  void DataArrayDiscrete<T>::transformWithIndArr(const MapKeyVal<T>& m)
+  void DataArrayDiscrete<T>::transformWithIndArr(const MapKeyVal<T, T>& m)
   {
     this->checkAllocated();
     if(this->getNumberOfComponents()!=1)
@@ -4018,8 +4043,3461 @@ struct NotInRange
     return ret.retn();
   }
 
-  ////////////////////////////////////
+  /*!
+   * Creates a one-dimensional DataArrayInt (\a res) whose contents are computed from
+   * values of \a this (\a a) and the given (\a indArr) arrays as follows:
+   * \a res[ \a indArr[ \a a[ i ]]] = i. I.e. for each value in place i \a v = \a a[ i ],
+   * new value in place \a indArr[ \a v ] is i.
+   *  \param [in] indArrBg - the array holding indices within the result array to assign
+   *         indices of values of \a this array pointing to values of \a indArrBg.
+   *  \param [in] indArrEnd - specifies the end of the array \a indArrBg, so that
+   *              the last value of \a indArrBg is \a indArrEnd[ -1 ].
+   *  \return DataArrayInt * - the new instance of DataArrayInt.
+   *          The caller is to delete this result array using decrRef() as it is no more
+   *          needed.
+   *  \throw If \a this->getNumberOfComponents() != 1.
+   *  \throw If any value of \a this array is not a valid index for \a indArrBg array.
+   *  \throw If any value of \a indArrBg is not a valid index for \a this array.
+   */
+  template<class T>
+  DataArrayIdType *DataArrayDiscrete<T>::transformWithIndArrR(const T *indArrBg, const T *indArrEnd) const
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("Call transformWithIndArrR method on DataArrayInt with only one component, you can call 'rearrange' method before !");
+    mcIdType nbElemsIn=ToIdType(std::distance(indArrBg,indArrEnd));
+    mcIdType nbOfTuples=ToIdType(this->getNumberOfTuples());
+    const T *pt=this->getConstPointer();
+    MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
+    ret->alloc(nbOfTuples,1);
+    ret->fillWithValue(-1);
+    mcIdType *tmp=ret->getPointer();
+    for(mcIdType i=0;i<nbOfTuples;i++,pt++)
+      {
+        if(*pt>=0 && *pt<nbElemsIn)
+          {
+            T pos=indArrBg[*pt];
+            if(pos>=0 && pos<nbOfTuples)
+              tmp[ToIdType(pos)]=i;
+            else
+              {
+                std::ostringstream oss; oss << "DataArrayInt::transformWithIndArrR : error on tuple #" << i << " value of new pos is " << pos << " ( indArrBg[" << *pt << "]) ! Should be in [0," << nbOfTuples << ") !";
+                throw INTERP_KERNEL::Exception(oss.str().c_str());
+              }
+          }
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::transformWithIndArrR : error on tuple #" << i << " value is " << *pt << " and indirectionnal array as a size equal to " << nbElemsIn << " !";
+            throw INTERP_KERNEL::Exception(oss.str().c_str());
+          }
+      }
+    return ret.retn();
+  }
+
+  /*!
+   * Computes distribution of values of \a this one-dimensional array between given value
+   * ranges (casts). This method is typically useful for entity number splitting by types,
+   * for example. 
+   *  \warning The values contained in \a arrBg should be sorted ascendently. No
+   *           check of this is be done. If not, the result is not warranted. 
+   *  \param [in] arrBg - the array of ascending values defining the value ranges. The i-th
+   *         value of \a arrBg (\a arrBg[ i ]) gives the lowest value of the i-th range,
+   *         and the greatest value of the i-th range equals to \a arrBg[ i+1 ] - 1. \a
+   *         arrBg containing \a n values defines \a n-1 ranges. The last value of \a arrBg
+   *         should be more than every value in \a this array.
+   *  \param [in] arrEnd - specifies the end of the array \a arrBg, so that
+   *              the last value of \a arrBg is \a arrEnd[ -1 ].
+   *  \param [out] castArr - a new instance of DataArrayInt, of same size as \a this array
+   *         (same number of tuples and components), the caller is to delete
+   *         using decrRef() as it is no more needed.
+   *         This array contains indices of ranges for every value of \a this array. I.e.
+   *         the i-th value of \a castArr gives the index of range the i-th value of \a this
+   *         belongs to. Or, in other words, this parameter contains for each tuple in \a
+   *         this in which cast it holds.
+   *  \param [out] rankInsideCast - a new instance of DataArrayInt, of same size as \a this
+   *         array, the caller is to delete using decrRef() as it is no more needed.
+   *         This array contains ranks of values of \a this array within ranges
+   *         they belongs to. I.e. the i-th value of \a rankInsideCast gives the rank of
+   *         the i-th value of \a this array within the \a castArr[ i ]-th range, to which
+   *         the i-th value of \a this belongs to. Or, in other words, this param contains
+   *         for each tuple its rank inside its cast. The rank is computed as difference
+   *         between the value and the lowest value of range.
+   *  \param [out] castsPresent - a new instance of DataArrayInt, containing indices of
+   *         ranges (casts) to which at least one value of \a this array belongs.
+   *         Or, in other words, this param contains the casts that \a this contains.
+   *         The caller is to delete this array using decrRef() as it is no more needed.
+   *
+   * \b Example: If \a this contains [6,5,0,3,2,7,8,1,4] and \a arrBg contains [0,4,9] then
+   *            the output of this method will be :
+   * - \a castArr       : [1,1,0,0,0,1,1,0,1]
+   * - \a rankInsideCast: [2,1,0,3,2,3,4,1,0]
+   * - \a castsPresent  : [0,1]
+   *
+   * I.e. values of \a this array belong to 2 ranges: #0 and #1. Value 6 belongs to the
+   * range #1 and its rank within this range is 2; etc.
+   *
+   *  \throw If \a this->getNumberOfComponents() != 1.
+   *  \throw If \a arrEnd - arrBg < 2.
+   *  \throw If any value of \a this is not less than \a arrEnd[-1].
+   */
+  template<class T>
+  void DataArrayDiscrete<T>::splitByValueRange(const T *arrBg, const T *arrEnd,
+                                               DataArrayType *& castArr, DataArrayType *& rankInsideCast, DataArrayType *& castsPresent) const
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("Call splitByValueRange  method on DataArrayInt with only one component, you can call 'rearrange' method before !");
+    std::size_t nbOfTuples=this->getNumberOfTuples();
+    std::size_t nbOfCast=std::distance(arrBg,arrEnd);
+    if(nbOfCast<2)
+      throw INTERP_KERNEL::Exception("DataArrayInt::splitByValueRange : The input array giving the cast range values should be of size >=2 !");
+    nbOfCast--;
+    const T *work=this->getConstPointer();
+    typedef std::reverse_iterator<const T *> rintstart;
+    rintstart bg(arrEnd);//OK no problem because size of 'arr' is greater or equal 2
+    rintstart end2(arrBg);
+    MCAuto<DataArrayType> ret1=DataArrayType::New();
+    MCAuto<DataArrayType> ret2=DataArrayType::New();
+    MCAuto<DataArrayType> ret3=DataArrayType::New();
+    ret1->alloc(nbOfTuples,1);
+    ret2->alloc(nbOfTuples,1);
+    T *ret1Ptr=ret1->getPointer();
+    T *ret2Ptr=ret2->getPointer();
+    std::set<T> castsDetected;
+    for(std::size_t i=0;i<nbOfTuples;i++)
+      {
+        rintstart res=std::find_if(bg,end2,std::bind2nd(std::less_equal<T>(), work[i]));
+        std::size_t pos=std::distance(bg,res);
+        std::size_t pos2=nbOfCast-pos;
+        if(pos2<nbOfCast)
+          {
+            ret1Ptr[i]=static_cast<T>(pos2);
+            ret2Ptr[i]=work[i]-arrBg[pos2];
+            castsDetected.insert(ret1Ptr[i]);
+          }
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::splitByValueRange : At rank #" << i << " the value is " << work[i] << " should be in [0," << *bg << ") !";
+            throw INTERP_KERNEL::Exception(oss.str().c_str());
+          }
+      }
+    ret3->alloc(castsDetected.size(),1);
+    std::copy(castsDetected.begin(),castsDetected.end(),ret3->getPointer());
+    castArr=ret1.retn();
+    rankInsideCast=ret2.retn();
+    castsPresent=ret3.retn();
+  }
+
+  /*!
+   * 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 ).
+   * 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 ).
+   * This method works only if \a this is allocated and single component. If not an exception will be thrown.
+   *
+   * \param [out] strt - the start of the range (included) if true is returned.
+   * \param [out] sttoopp - the end of the range (not included) if true is returned.
+   * \param [out] stteepp - the step of the range if true is returned.
+   * \return the verdict of the check.
+   *
+   * \sa DataArray::GetNumberOfItemGivenBES
+   */
+  template<class T>
+  bool DataArrayDiscrete<T>::isRange(T& strt, T& sttoopp, T& stteepp) const
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::isRange : this must be single component array !");
+    mcIdType nbTuples=ToIdType(this->getNumberOfTuples());
+    if(nbTuples==0)
+      { strt=0; sttoopp=0; stteepp=1; return true; }
+    const T *pt(this->begin());
+    strt=*pt;
+    if(nbTuples==1)
+      { sttoopp=strt+1; stteepp=1; return true; }
+    strt=*pt; sttoopp=pt[nbTuples-1];
+    if(strt==sttoopp)
+      return false;
+    if(sttoopp>strt)
+      {
+        sttoopp++;
+        T a(sttoopp-1-strt),tmp(strt);
+        if(a%(nbTuples-1)!=0)
+          return false;
+        stteepp=a/(nbTuples-1);
+        for(mcIdType i=0;i<nbTuples;i++,tmp+=stteepp)
+          if(pt[i]!=tmp)
+            return false;
+        return true;
+      }
+    else
+      {
+        sttoopp--;
+        T a(strt-sttoopp-1),tmp(strt);
+        if(a%(nbTuples-1)!=0)
+          return false;
+        stteepp=-(a/(nbTuples-1));
+        for(mcIdType i=0;i<nbTuples;i++,tmp+=stteepp)
+          if(pt[i]!=tmp)
+            return false;
+        return true;
+      }
+  }
+
+  /*!
+   * Creates a one-dimensional DataArrayInt of given length, whose contents are computed
+   * from values of \a this array, which is supposed to contain a renumbering map in
+   * "Old to New" mode. The result array contains a renumbering map in "New to Old" mode.
+   * To know how to use the renumbering maps see \ref numbering.
+   *  \param [in] newNbOfElem - the number of tuples in the result array.
+   *  \return DataArrayInt * - the new instance of DataArrayInt.
+   *          The caller is to delete this result array using decrRef() as it is no more
+   *          needed.
+   *
+   *  \if ENABLE_EXAMPLES
+   *  \ref cpp_mcdataarrayint_invertarrayo2n2n2o "Here is a C++ example".<br>
+   *  \ref py_mcdataarrayint_invertarrayo2n2n2o  "Here is a Python example".
+   *  \endif
+   */
+  template<class T>
+  DataArrayIdType * DataArrayDiscrete<T>::invertArrayO2N2N2O(mcIdType newNbOfElem) const
+  {
+    MCAuto<DataArrayIdType> ret(DataArrayIdType::New());
+    ret->alloc(newNbOfElem,1);
+    mcIdType nbOfOldNodes=ToIdType(this->getNumberOfTuples());
+    const T *old2New(this->begin());
+    mcIdType *pt(ret->getPointer());
+    for(mcIdType i=0;i!=nbOfOldNodes;i++)
+      {
+        T newp(old2New[i]);
+        if(newp!=-1)
+          {
+            if(newp>=0 && newp<newNbOfElem)
+              pt[newp]=i;
+            else
+              {
+                std::ostringstream oss; oss << "DataArrayInt::invertArrayO2N2N2O : At place #" << i << " the newplace is " << newp << " must be in [0," << newNbOfElem << ") !";
+                throw INTERP_KERNEL::Exception(oss.str().c_str());
+              }
+          }
+      }
+    return ret.retn();
+  }
+
+  /*!
+   * Creates a one-dimensional DataArrayInt of given length, whose contents are computed
+   * from values of \a this array, which is supposed to contain a renumbering map in
+   * "New to Old" mode. The result array contains a renumbering map in "Old to New" mode.
+   * To know how to use the renumbering maps see \ref numbering.
+   *  \param [in] newNbOfElem - the number of tuples in the result array.
+   *  \return DataArrayInt * - the new instance of DataArrayInt.
+   *          The caller is to delete this result array using decrRef() as it is no more
+   *          needed.
+   *
+   *  \if ENABLE_EXAMPLES
+   *  \ref cpp_mcdataarrayint_invertarrayn2o2o2n "Here is a C++ example".
+   *
+   *  \ref py_mcdataarrayint_invertarrayn2o2o2n "Here is a Python example".
+   *  \sa invertArrayN2O2O2NOptimized
+   *  \endif
+   */
+  template <class T>
+  DataArrayIdType *DataArrayDiscrete<T>::invertArrayN2O2O2N(mcIdType oldNbOfElem) const
+  {
+    this->checkAllocated();
+    MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
+    ret->alloc(oldNbOfElem,1);
+    const T *new2Old=this->getConstPointer();
+    mcIdType *pt=ret->getPointer();
+    std::fill(pt,pt+oldNbOfElem,-1);
+    mcIdType nbOfNewElems=ToIdType(this->getNumberOfTuples());
+    for(mcIdType i=0;i<nbOfNewElems;i++)
+      {
+        T v(new2Old[i]);
+        if(v>=0 && v<oldNbOfElem)
+          pt[v]=i;
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::invertArrayN2O2O2N : in new id #" << i << " old value is " << v << " expected to be in [0," << oldNbOfElem << ") !";
+            throw INTERP_KERNEL::Exception(oss.str().c_str());
+          }
+      }
+    return ret.retn();
+  }
+
+  /*!
+   * This method is similar to DataArrayInt::invertArrayO2N2N2O except that
+   * 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]
+   */
+  template <class T>
+  DataArrayIdType *DataArrayDiscrete<T>::invertArrayO2N2N2OBis(mcIdType newNbOfElem) const
+  {
+    MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
+    ret->alloc(newNbOfElem,1);
+    mcIdType nbOfOldNodes=ToIdType(this->getNumberOfTuples());
+    const T *old2New=this->getConstPointer();
+    mcIdType *pt=ret->getPointer();
+    for(mcIdType i=nbOfOldNodes-1;i>=0;i--)
+      {
+        T newp(old2New[i]);
+        if(newp!=-1)
+          {
+            if(newp>=0 && newp<newNbOfElem)
+              pt[newp]=i;
+            else
+              {
+                std::ostringstream oss; oss << "DataArrayInt::invertArrayO2N2N2OBis : At place #" << i << " the newplace is " << newp << " must be in [0," << newNbOfElem << ") !";
+                throw INTERP_KERNEL::Exception(oss.str().c_str());
+              }
+          }
+      }
+    return ret.retn();
+  }
+
+  /*!
+   * Creates a map, whose contents are computed
+   * from values of \a this array, which is supposed to contain a renumbering map in
+   * "New to Old" mode. The result array contains a renumbering map in "Old to New" mode.
+   * To know how to use the renumbering maps see \ref numbering.
+   *  \param [in] newNbOfElem - the number of tuples in the result array.
+   *  \return MapII  - the new instance of Map.
+   *
+   *  \if ENABLE_EXAMPLES
+   *  \ref cpp_mcdataarrayint_invertarrayn2o2o2n "Here is a C++ example".
+   *
+   *  \ref py_mcdataarrayint_invertarrayn2o2o2n "Here is a Python example".
+   *  \sa invertArrayN2O2O2N, giveN2OOptimized, MEDCouplingPointSet::renumberNodesInConn
+   *  \endif
+   */
+  template <class T>
+  MCAuto< MapKeyVal<T, mcIdType> > DataArrayDiscrete<T>::invertArrayN2O2O2NOptimized() const
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::invertArrayN2O2O2NOptimized : single component expected !");
+    MCAuto< MapKeyVal<T, mcIdType> > ret(MapKeyVal<T, mcIdType>::New());
+    std::map<T, mcIdType>& m(ret->data());
+    const T *new2Old(this->begin());
+    mcIdType nbOfNewElems=ToIdType(this->getNumberOfTuples());
+    for(mcIdType i=0;i<nbOfNewElems;i++)
+      {
+        T v(new2Old[i]);
+        m[v]=i;
+      }
+    return ret;
+  }
+
+  /*!
+   * Creates a map, whose contents are computed
+   * from values of \a this array, which is supposed to contain a renumbering map in 
+   * "New to Old" mode. The result array contains a renumbering map in "New to Old" mode as C++ map for performance reasons.
+   *
+   * \sa invertArrayN2O2O2NOptimized, MEDCouplingPointSet::renumberNodesInConn
+   */
+  template <class T>
+  MCAuto< MapKeyVal<mcIdType, T> > DataArrayDiscrete<T>::giveN2OOptimized() const
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::giveN2OOptimized : single component expected !");
+    MCAuto< MapKeyVal<mcIdType, T> > ret(MapKeyVal<mcIdType, T>::New());
+    std::map<mcIdType,T>& m(ret->data());
+    const T *new2Old(this->begin());
+    mcIdType nbOfNewElems=ToIdType(this->getNumberOfTuples());
+    for(mcIdType i=0;i<nbOfNewElems;i++)
+      {
+        T v(new2Old[i]);
+        m[i]=v;
+      }
+    return ret;
+  }
+
+  /*!
+   * This method finds for each element \a ELT in [valsBg,valsEnd) elements in \a this equal to it. Associated to ELT
+   * this method will return the tuple id of last element found. If there is no element in \a this equal to ELT
+   * an exception will be thrown.
+   *
+   * In case of success this[ret]==vals. Samely ret->transformWithIndArr(this->begin(),this->end())==vals.
+   * Where \a vals is the [valsBg,valsEnd) array and \a ret the array returned by this method.
+   * This method can be seen as an extension of FindPermutationFromFirstToSecond.
+   * <br>
+   * \b Example: <br>
+   * - \a this: [17,27,2,10,-4,3,12,27,16]
+   * - \a val : [3,16,-4,27,17]
+   * - result: [5,8,4,7,0]
+   *
+   * \return - An array of size std::distance(valsBg,valsEnd)
+   *
+   * \sa DataArrayInt::FindPermutationFromFirstToSecond
+   */
+  template <class T>
+  MCAuto<DataArrayIdType> DataArrayDiscrete<T>::findIdForEach(const T *valsBg, const T *valsEnd) const
+  {
+    MCAuto<DataArrayIdType> ret(DataArrayIdType::New());
+    std::size_t nbOfTuplesOut(std::distance(valsBg,valsEnd));
+    ret->alloc(nbOfTuplesOut,1);
+    MCAuto< MapKeyVal<T, mcIdType> > zeMap(this->invertArrayN2O2O2NOptimized());
+    const std::map<T, mcIdType>& dat(zeMap->data());
+    mcIdType *ptToFeed(ret->getPointer());
+    for(const T *pt=valsBg;pt!=valsEnd;pt++)
+      {
+        typename std::map<T,mcIdType>::const_iterator it(dat.find(*pt));
+        if(it!=dat.end())
+          *ptToFeed++=(*it).second;
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::findIdForEach : error for element at place " << std::distance(valsBg,pt);
+            oss << " of input array value is " << *pt << " which is not in this !";
+            throw INTERP_KERNEL::Exception(oss.str());
+          }
+      }
+    return ret;
+  }
+
+  /*!
+   * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode.
+   * This map, if applied to \a this array, would make it sorted. For example, if
+   * \a this array contents are [9,10,0,6,4,11,3,7] then the contents of the result array
+   * are [5,6,0,3,2,7,1,4]; if this result array (\a res) is used as an argument in call
+   * \a this->renumber(\a res) then the returned array contains [0,3,4,6,7,9,10,11].
+   * This method is useful for renumbering (in MED file for example). For more info
+   * on renumbering see \ref numbering.
+   *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
+   *          array using decrRef() as it is no more needed.
+   *  \throw If \a this is not allocated.
+   *  \throw If \a this->getNumberOfComponents() != 1.
+   *  \throw If there are equal values in \a this array.
+   */
+  template <class T>
+  DataArrayIdType *DataArrayDiscrete<T>::checkAndPreparePermutation() const
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::checkAndPreparePermutation : number of components must == 1 !");
+    mcIdType nbTuples=ToIdType(this->getNumberOfTuples());
+    const T *pt=this->getConstPointer();
+    mcIdType *pt2=this->CheckAndPreparePermutation(pt,pt+nbTuples);
+    DataArrayIdType *ret=DataArrayIdType::New();
+    ret->useArray(pt2,true,DeallocType::C_DEALLOC,nbTuples,1);
+    return ret;
+  }
+
+  /*!
+   * Returns two arrays describing a surjective mapping from \a this set of values (\a A)
+   * onto a set of values of size \a targetNb (\a B). The surjective function is
+   * \a B[ \a A[ i ]] = i. That is to say that for each \a id in [0,\a targetNb), where \a
+   * targetNb < \a this->getNumberOfTuples(), there exists at least one tupleId (\a tid) so
+   * that <em> this->getIJ( tid, 0 ) == id</em>. <br>
+   * The first of out arrays returns indices of elements of \a this array, grouped by their
+   * place in the set \a B. The second out array is the index of the first one; it shows how
+   * many elements of \a A are mapped into each element of \a B. <br>
+   * For more info on
+   * mapping and its usage in renumbering see \ref numbering. <br>
+   * \b Example:
+   * - \a this: [0,3,2,3,2,2,1,2]
+   * - \a targetNb: 4
+   * - \a arr:  [0,  6,  2,4,5,7,  1,3]
+   * - \a arrI: [0,1,2,6,8]
+   *
+   * This result means: <br>
+   * the element of \a B 0 encounters within \a A once (\a arrI[ 0+1 ] - \a arrI[ 0 ]) and
+   * its index within \a A is 0 ( \a arr[ 0:1 ] == \a arr[ \a arrI[ 0 ] : \a arrI[ 0+1 ]]);<br>
+   * the element of \a B 2 encounters within \a A 4 times (\a arrI[ 2+1 ] - \a arrI[ 2 ]) and
+   * its indices within \a A are [2,4,5,7] ( \a arr[ 2:6 ] == \a arr[ \a arrI[ 2 ] :
+   * \a arrI[ 2+1 ]]); <br> etc.
+   *  \param [in] targetNb - the size of the set \a B. \a targetNb must be equal or more
+   *         than the maximal value of \a A.
+   *  \param [out] arr - a new instance of DataArrayInt returning indices of
+   *         elements of \a this, grouped by their place in the set \a B. The caller is to delete
+   *         this array using decrRef() as it is no more needed.
+   *  \param [out] arrI - a new instance of DataArrayInt returning size of groups of equal
+   *         elements of \a this. The caller is to delete this array using decrRef() as it
+   *         is no more needed.
+   *  \throw If \a this is not allocated.
+   *  \throw If \a this->getNumberOfComponents() != 1.
+   *  \throw If any value in \a this is more or equal to \a targetNb.
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::changeSurjectiveFormat(T targetNb, DataArrayIdType *&arr, DataArrayIdType *&arrI) const
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : number of components must == 1 !");
+    mcIdType nbOfTuples=ToIdType(this->getNumberOfTuples());
+    const T *input=this->getConstPointer();
+    std::vector< std::vector<mcIdType> > tmp(targetNb);
+    for(mcIdType i=0;i<nbOfTuples;i++)
+      {
+        T tmp2=input[i];
+        if(tmp2>=0 && tmp2<targetNb)
+          tmp[tmp2].push_back(i);
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::changeSurjectiveFormat : At pos " << i << " presence of element " << tmp2 << " ! should be in [0," << targetNb << ") !";
+            throw INTERP_KERNEL::Exception(oss.str().c_str());
+          }
+      }
+
+    MCAuto<DataArrayIdType> retI(DataArrayIdType::New());
+    retI->alloc(targetNb+1,1);
+    mcIdType *retIPtr=retI->getPointer();
+    *retIPtr=0;
+    for(std::vector< std::vector<mcIdType> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++,retIPtr++)
+      retIPtr[1]=retIPtr[0]+ToIdType((*it1).size());
+    if(nbOfTuples!=retI->getIJ(ToIdType(targetNb),0))
+      throw INTERP_KERNEL::Exception("DataArrayInt::changeSurjectiveFormat : big problem should never happen !");
+    MCAuto<DataArrayIdType> ret(DataArrayIdType::New());
+    ret->alloc(nbOfTuples,1);
+    mcIdType *retPtr=ret->getPointer();
+    for(std::vector< std::vector<mcIdType> >::const_iterator it1=tmp.begin();it1!=tmp.end();it1++)
+      retPtr=std::copy((*it1).begin(),(*it1).end(),retPtr);
+    arr=ret.retn();
+    arrI=retI.retn();
+  }
+
+  /*!
+   * Returns a new DataArrayInt containing a renumbering map in "New to Old" mode,
+   * which if applied to \a this array would make it sorted ascendingly.
+   * For more info on renumbering see \ref numbering. <br>
+   * \b Example: <br>
+   * - \a this: [2,0,1,1,0,1,2,0,1,1,0,0]
+   * - result: [10,0,5,6,1,7,11,2,8,9,3,4]
+   * - after applying result to \a this: [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2]
+   *
+   *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
+   *          array using decrRef() as it is no more needed.
+   *  \throw If \a this is not allocated.
+   *  \throw If \a this->getNumberOfComponents() != 1.
+   */
+  template <class T>
+  DataArrayIdType *DataArrayDiscrete<T>::buildPermArrPerLevel() const
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::buildPermArrPerLevel : number of components must == 1 !");
+    std::size_t nbOfTuples=this->getNumberOfTuples();
+    const T *pt=this->getConstPointer();
+    std::map<T,mcIdType> m;
+    MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
+    ret->alloc(nbOfTuples,1);
+    mcIdType *opt=ret->getPointer();
+    for(std::size_t i=0;i<nbOfTuples;i++,pt++,opt++)
+      {
+        T val=*pt;
+        typename std::map<T,mcIdType>::iterator it=m.find(val);
+        if(it!=m.end())
+          {
+            *opt=(*it).second;
+            (*it).second++;
+          }
+        else
+          {
+            *opt=0;
+            m.insert(std::pair<T,mcIdType>(val,1));
+          }
+      }
+    mcIdType sum=0;
+    for(typename std::map<T,mcIdType>::iterator it=m.begin();it!=m.end();it++)
+      {
+        mcIdType vt=(*it).second;
+        (*it).second=sum;
+        sum+=vt;
+      }
+    pt=this->getConstPointer();
+    opt=ret->getPointer();
+    for(std::size_t i=0;i<nbOfTuples;i++,pt++,opt++)
+      *opt+=m[*pt];
+    //
+    return ret.retn();
+  }
 
+  /*!
+   * Checks if \a this array has the given size, and if its contents is equal to an array filled with
+   * iota(). This method is particularly useful for DataArrayInt instances that represent
+   * a renumbering array, to check if there is a real need in renumbering.
+   * This method checks than \a this can be considered as an identity mapping
+   * of a set having \a sizeExpected elements into itself.
+   *
+   *  \param [in] sizeExpected - The number of elements expected.
+   *  \return bool - \a true if \a this array contents == \a range( \a this->getNumberOfTuples())
+   *  \throw If \a this is not allocated.
+   *  \throw If \a this->getNumberOfComponents() != 1.
+   */
+  template <class T>
+  bool DataArrayDiscrete<T>::isIota(mcIdType sizeExpected) const
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      return false;
+    mcIdType nbOfTuples=ToIdType(this->getNumberOfTuples());
+    if(nbOfTuples!=sizeExpected)
+      return false;
+    const T *pt=this->getConstPointer();
+    for(mcIdType i=0;i<nbOfTuples;i++,pt++)
+      if(*pt!=i)
+        return false;
+    return true;
+  }
+
+  /*!
+   * Checks if all values in \a this array are equal to \a val.
+   *  \param [in] val - value to check equality of array values to.
+   *  \return bool - \a true if all values are \a val.
+   *  \throw If \a this is not allocated.
+   *  \throw If \a this->getNumberOfComponents() != 1
+   *  \sa DataArrayInt::checkUniformAndGuess
+   */
+  template <class T>
+  bool DataArrayDiscrete<T>::isUniform(T val) const
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::isUniform : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
+    const T *w(this->begin()),*end2(this->end());
+    for(;w!=end2;w++)
+      if(*w!=val)
+        return false;
+    return true;
+  }
+
+  /*!
+   * This method checks that \a this is uniform. If not and exception will be thrown.
+   * In case of uniformity the corresponding value is returned.
+   *
+   * \return int - the unique value contained in this
+   * \throw If \a this is not allocated.
+   * \throw If \a this->getNumberOfComponents() != 1
+   * \throw If \a this is not uniform.
+   * \sa DataArrayInt::isUniform
+   */
+  template <class T>
+  T DataArrayDiscrete<T>::checkUniformAndGuess() const
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::checkUniformAndGuess : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
+    if(this->empty())
+      throw INTERP_KERNEL::Exception("DataArrayInt::checkUniformAndGuess : this is empty !");
+    const T *w(this->begin()),*end2(this->end());
+    T ret(*w);
+    for(;w!=end2;w++)
+      if(*w!=ret)
+        throw INTERP_KERNEL::Exception("DataArrayInt::checkUniformAndGuess : this is not uniform !");
+    return ret;
+  }
+
+  /*!
+   * Checks if all values in \a this array are unique.
+   *  \return bool - \a true if condition above is true
+   *  \throw If \a this is not allocated.
+   *  \throw If \a this->getNumberOfComponents() != 1
+   */
+  template <class T>
+  bool DataArrayDiscrete<T>::hasUniqueValues() const
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::hasOnlyUniqueValues: must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
+    std::size_t nbOfTuples(this->getNumberOfTuples());
+    std::set<T> s(this->begin(),this->end());  // in C++11, should use unordered_set (O(1) complexity)
+    if (s.size() != nbOfTuples)
+      return false;
+    return true;
+  }
+
+  /*!
+   * Copy all components in a specified order from another DataArrayInt.
+   * The specified components become the first ones in \a this array.
+   * Both numerical and textual data is copied. The number of tuples in \a this and
+   * the other array can be different.
+   *  \param [in] a - the array to copy data from.
+   *  \param [in] compoIds - sequence of zero based indices of components, data of which is
+   *              to be copied.
+   *  \throw If \a a is NULL.
+   *  \throw If \a compoIds.size() != \a a->getNumberOfComponents().
+   *  \throw If \a compoIds[i] < 0 or \a compoIds[i] > \a this->getNumberOfComponents().
+   *
+   *  \if ENABLE_EXAMPLES
+   *  \ref py_mcdataarrayint_setselectedcomponents "Here is a Python example".
+   *  \endif
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::setSelectedComponents(const DataArrayType *a, const std::vector<mcIdType>& compoIds)
+  {
+    if(!a)
+      throw INTERP_KERNEL::Exception("DataArrayInt::setSelectedComponents : input DataArrayInt is NULL !");
+    this->checkAllocated();
+    a->checkAllocated();
+    this->copyPartOfStringInfoFrom2(compoIds,*a);
+    std::size_t partOfCompoSz=compoIds.size();
+    mcIdType nbOfCompo=ToIdType(this->getNumberOfComponents());
+    mcIdType nbOfTuples=ToIdType(std::min(this->getNumberOfTuples(),a->getNumberOfTuples()));
+    const T *ac=a->getConstPointer();
+    T *nc=this->getPointer();
+    for(mcIdType i=0;i<nbOfTuples;i++)
+      for(std::size_t j=0;j<partOfCompoSz;j++,ac++)
+        nc[nbOfCompo*i+compoIds[j]]=*ac;
+  }
+
+  /*!
+   * Creates a new DataArrayInt containing IDs (indices) of tuples holding value \b not
+   * equal to a given one.
+   *  \param [in] val - the value to ignore within \a this.
+   *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
+   *          array using decrRef() as it is no more needed.
+   *  \throw If \a this is not allocated.
+   *  \throw If \a this->getNumberOfComponents() != 1.
+   */
+  template <class T>
+  DataArrayIdType *DataArrayDiscrete<T>::findIdsNotEqual(T val) const
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::findIdsNotEqual : the array must have only one component, you can call 'rearrange' method before !");
+    const T *cptr(this->getConstPointer());
+    MCAuto<DataArrayIdType> ret(DataArrayIdType::New());
+    ret->alloc(0,1);
+    mcIdType nbOfTuples=ToIdType(this->getNumberOfTuples());
+    for(mcIdType i=0;i<nbOfTuples;i++,cptr++)
+      if(*cptr!=val)
+        ret->pushBackSilent(i);
+    return ret.retn();
+  }
+  
+  /*!
+   * Creates a new DataArrayInt containing IDs (indices) of tuples holding tuple equal to those defined by [ \a tupleBg , \a tupleEnd )
+   * This method is an extension of  DataArrayInt::findIdsEqual method.
+   *
+   *  \param [in] tupleBg - the begin (included) of the input tuple to find within \a this.
+   *  \param [in] tupleEnd - the end (excluded) of the input tuple to find within \a this.
+   *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
+   *          array using decrRef() as it is no more needed.
+   *  \throw If \a this is not allocated.
+   *  \throw If \a this->getNumberOfComponents() != std::distance(tupleBg,tupleEnd).
+   * \throw If \a this->getNumberOfComponents() is equal to 0.
+   * \sa DataArrayInt::findIdsEqual
+   */
+  template <class T>
+  DataArrayIdType *DataArrayDiscrete<T>::findIdsEqualTuple(const T *tupleBg, const T *tupleEnd) const
+  {
+    mcIdType nbOfCompoExp=ToIdType(std::distance(tupleBg,tupleEnd));
+    this->checkAllocated();
+    if(ToIdType(this->getNumberOfComponents())!=nbOfCompoExp)
+      {
+        std::ostringstream oss; oss << "DataArrayInt::findIdsEqualTuple : mismatch of number of components. Input tuple has " << nbOfCompoExp << " whereas this array has " << this->getNumberOfComponents() << " components !";
+        throw INTERP_KERNEL::Exception(oss.str().c_str());
+      }
+    if(nbOfCompoExp==0)
+      throw INTERP_KERNEL::Exception("DataArrayInt::findIdsEqualTuple : number of components should be > 0 !");
+    MCAuto<DataArrayIdType> ret(DataArrayIdType::New());
+    ret->alloc(0,1);
+    const T *bg(this->begin()),*end2(this->end()),*work(this->begin());
+    while(work!=end2)
+      {
+        work=std::search(work,end2,tupleBg,tupleEnd);
+        if(work!=end2)
+          {
+            mcIdType pos=ToIdType(std::distance(bg,work));
+            if(pos%nbOfCompoExp==0)
+              ret->pushBackSilent(pos/nbOfCompoExp);
+            work++;
+          }
+      }
+    return ret.retn();
+  }
+
+  /*!
+   * Creates a new DataArrayInt containing IDs (indices) of tuples holding value equal to
+   * one of given values.
+   *  \param [in] valsBg - an array of values to find within \a this array.
+   *  \param [in] valsEnd - specifies the end of the array \a valsBg, so that
+   *              the last value of \a valsBg is \a valsEnd[ -1 ].
+   *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
+   *          array using decrRef() as it is no more needed.
+   *  \throw If \a this->getNumberOfComponents() != 1.
+   */
+  template <class T>
+  DataArrayIdType *DataArrayDiscrete<T>::findIdsEqualList(const T *valsBg, const T *valsEnd) const
+  {
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::findIdsEqualList : the array must have only one component, you can call 'rearrange' method before !");
+    std::set<T> vals2(valsBg,valsEnd);
+    const T *cptr(this->getConstPointer());
+    mcIdType nbOfTuples=ToIdType(this->getNumberOfTuples());
+    MCAuto<DataArrayIdType> ret(DataArrayIdType::New()); ret->alloc(0,1);
+    for(mcIdType i=0;i<nbOfTuples;i++,cptr++)
+      if(vals2.find(*cptr)!=vals2.end())
+        ret->pushBackSilent(i);
+    return ret.retn();
+  }
+  
+  /*!
+   * Creates a new DataArrayInt containing IDs (indices) of tuples holding values \b not
+   * equal to any of given values.
+   *  \param [in] valsBg - an array of values to ignore within \a this array.
+   *  \param [in] valsEnd - specifies the end of the array \a valsBg, so that
+   *              the last value of \a valsBg is \a valsEnd[ -1 ].
+   *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
+   *          array using decrRef() as it is no more needed.
+   *  \throw If \a this->getNumberOfComponents() != 1.
+   */
+  template <class T>
+  DataArrayIdType *DataArrayDiscrete<T>::findIdsNotEqualList(const T *valsBg, const T *valsEnd) const
+  {
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::findIdsNotEqualList : the array must have only one component, you can call 'rearrange' method before !");
+    std::set<T> vals2(valsBg,valsEnd);
+    const T *cptr=this->getConstPointer();
+    mcIdType nbOfTuples=ToIdType(this->getNumberOfTuples());
+    MCAuto<DataArrayIdType> ret(DataArrayIdType::New()); ret->alloc(0,1);
+    for(mcIdType i=0;i<nbOfTuples;i++,cptr++)
+      if(vals2.find(*cptr)==vals2.end())
+        ret->pushBackSilent(i);
+    return ret.retn();
+  }
+
+  /*!
+   * This method expects to be called when number of components of this is equal to one.
+   * This method returns the tuple id, if it exists, of the first tuple equal to \b value.
+   * If not any tuple contains \b value -1 is returned.
+   * \sa DataArrayInt::presenceOfValue
+   */
+  template <class T>
+  mcIdType DataArrayDiscrete<T>::findIdFirstEqual(T value) const
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::presenceOfValue : the array must have only one component, you can call 'rearrange' method before !");
+    const T *cptr=this->getConstPointer();
+    mcIdType nbOfTuples=ToIdType(this->getNumberOfTuples());
+    const T *ret=std::find(cptr,cptr+nbOfTuples,value);
+    if(ret!=cptr+nbOfTuples)
+      return ToIdType(std::distance(cptr,ret));
+    return -1;
+  }
+  
+  /*!
+   * This method expects to be called when number of components of this is equal to one.
+   * This method returns the tuple id, if it exists, of the first tuple so that the value is contained in \b vals.
+   * If not any tuple contains one of the values contained in 'vals' -1 is returned.
+   * \sa DataArrayInt::presenceOfValue
+   */
+  template <class T>
+  mcIdType DataArrayDiscrete<T>::findIdFirstEqual(const std::vector<T>& vals) const
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::presenceOfValue : the array must have only one component, you can call 'rearrange' method before !");
+    std::set<T> vals2(vals.begin(),vals.end());
+    const T *cptr=this->getConstPointer();
+    mcIdType nbOfTuples=ToIdType(this->getNumberOfTuples());
+    for(const T *w=cptr;w!=cptr+nbOfTuples;w++)
+      if(vals2.find(*w)!=vals2.end())
+        return ToIdType(std::distance(cptr,w));
+    return -1;
+  }
+
+  /*!
+   * This method is an extension of DataArrayInt::findIdFirstEqual method because this method works for DataArrayInt with
+   * any number of components excepted 0 (an INTERP_KERNEL::Exception is thrown in this case).
+   * This method searches in \b this is there is a tuple that matched the input parameter \b tupl.
+   * If any the tuple id is returned. If not -1 is returned.
+   *
+   * This method throws an INTERP_KERNEL::Exception if the number of components in \b this mismatches with the size of
+   * the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
+   *
+   * \return tuple id where \b tupl is. -1 if no such tuple exists in \b this.
+   * \sa DataArrayInt::findIdSequence, DataArrayInt::presenceOfTuple.
+   */
+  template <class T>
+  mcIdType DataArrayDiscrete<T>::findIdFirstEqualTuple(const std::vector<T>& tupl) const
+  {
+    this->checkAllocated();
+    mcIdType nbOfCompo=ToIdType(this->getNumberOfComponents());
+    if(nbOfCompo==0)
+      throw INTERP_KERNEL::Exception("DataArrayInt::findIdFirstEqualTuple : 0 components in 'this' !");
+    if(nbOfCompo!=ToIdType(tupl.size()))
+      {
+        std::ostringstream oss; oss << "DataArrayInt::findIdFirstEqualTuple : 'this' contains " << nbOfCompo << " components and searching for a tuple of length " << tupl.size() << " !";
+        throw INTERP_KERNEL::Exception(oss.str().c_str());
+      }
+    const T *cptr=this->getConstPointer();
+    std::size_t nbOfVals=this->getNbOfElems();
+    for(const T *work=cptr;work!=cptr+nbOfVals;)
+      {
+        work=std::search(work,cptr+nbOfVals,tupl.begin(),tupl.end());
+        if(work!=cptr+nbOfVals)
+          {
+            if(std::distance(cptr,work)%nbOfCompo!=0)
+              work++;
+            else
+              return ToIdType (std::distance(cptr,work)/nbOfCompo);
+          }
+      }
+    return -1;
+  }
+
+  /*!
+   * This method searches the sequence specified in input parameter \b vals in \b this.
+   * This works only for DataArrayInt having number of components equal to one (if not an INTERP_KERNEL::Exception will be thrown).
+   * This method differs from DataArrayInt::findIdFirstEqualTuple in that the position is internal raw data is not considered here contrary to DataArrayInt::findIdFirstEqualTuple.
+   * \sa DataArrayInt::findIdFirstEqualTuple
+   */
+  template <class T>
+  mcIdType DataArrayDiscrete<T>::findIdSequence(const std::vector<T>& vals) const
+  {
+    this->checkAllocated();
+    std::size_t nbOfCompo=this->getNumberOfComponents();
+    if(nbOfCompo!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::findIdSequence : works only for DataArrayInt instance with one component !");
+    const T *cptr=this->getConstPointer();
+    std::size_t nbOfVals=this->getNbOfElems();
+    const T *loc=std::search(cptr,cptr+nbOfVals,vals.begin(),vals.end());
+    if(loc!=cptr+nbOfVals)
+      return ToIdType(std::distance(cptr,loc));
+    return -1;
+  }
+
+  /*!
+   * Assigns \a newValue to all elements holding \a oldValue within \a this
+   * one-dimensional array.
+   *  \param [in] oldValue - the value to replace.
+   *  \param [in] newValue - the value to assign.
+   *  \return int - number of replacements performed.
+   *  \throw If \a this is not allocated.
+   *  \throw If \a this->getNumberOfComponents() != 1.
+   */
+  template <class T>
+  mcIdType DataArrayDiscrete<T>::changeValue(T oldValue, T newValue)
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::changeValue : the array must have only one component, you can call 'rearrange' method before !");
+    if(oldValue==newValue)
+      return 0;
+    T *start(this->getPointer()),*end2(start+this->getNbOfElems());
+    mcIdType ret(0);
+    for(T *val=start;val!=end2;val++)
+      {
+        if(*val==oldValue)
+          {
+            *val=newValue;
+            ret++;
+          }
+      }
+    if(ret>0)
+      this->declareAsNew();
+    return ret;
+  }
+
+  /*!
+   * This method returns the number of values in \a this that are equals to input parameter \a value.
+   * This method only works for single component array.
+   *
+   * \return a value in [ 0, \c this->getNumberOfTuples() )
+   *
+   * \throw If \a this is not allocated
+   *
+   */
+  template <class T>
+  mcIdType DataArrayDiscrete<T>::count(T value) const
+  {
+    mcIdType ret=0;
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::count : must be applied on DataArrayInt with only one component, you can call 'rearrange' method before !");
+    const T *vals=this->begin();
+    std::size_t nbOfTuples=this->getNumberOfTuples();
+    for(std::size_t i=0;i<nbOfTuples;i++,vals++)
+      if(*vals==value)
+        ret++;
+    return ret;
+  }
+
+  /*!
+   * This method is an extension of DataArrayInt::presenceOfValue method because this method works for DataArrayInt with
+   * any number of components excepted 0 (an INTERP_KERNEL::Exception is thrown in this case).
+   * This method searches in \b this is there is a tuple that matched the input parameter \b tupl.
+   * This method throws an INTERP_KERNEL::Exception if the number of components in \b this mismatches with the size of
+   * the input vector. An INTERP_KERNEL::Exception is thrown too if \b this is not allocated.
+   * \sa DataArrayInt::findIdFirstEqualTuple
+   */
+  template <class T>
+  bool DataArrayDiscrete<T>::presenceOfTuple(const std::vector<T>& tupl) const
+  {
+    return this->findIdFirstEqualTuple(tupl)!=-1;
+  }
+  
+  
+  /*!
+   * Returns \a true if a given value is present within \a this one-dimensional array.
+   *  \param [in] value - the value to find within \a this array.
+   *  \return bool - \a true in case if \a value is present within \a this array.
+   *  \throw If \a this is not allocated.
+   *  \throw If \a this->getNumberOfComponents() != 1.
+   *  \sa findIdFirstEqual()
+   */
+  template <class T>
+  bool DataArrayDiscrete<T>::presenceOfValue(T value) const
+  {
+    return this->findIdFirstEqual(value)!=-1;
+  }
+  
+  /*!
+   * This method expects to be called when number of components of this is equal to one.
+   * This method returns true if it exists a tuple so that the value is contained in \b vals.
+   * If not any tuple contains one of the values contained in 'vals' false is returned.
+   * \sa DataArrayInt::findIdFirstEqual
+   */
+  template <class T>
+  bool DataArrayDiscrete<T>::presenceOfValue(const std::vector<T>& vals) const
+  {
+    return this->findIdFirstEqual(vals)!=-1;
+  }
+
+  /*!
+   * Accumulates values of each component of \a this array.
+   *  \param [out] res - an array of length \a this->getNumberOfComponents(), allocated
+   *         by the caller, that is filled by this method with sum value for each
+   *         component.
+   *  \throw If \a this is not allocated.
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::accumulate(T *res) const
+  {
+    this->checkAllocated();
+    const T *ptr=this->getConstPointer();
+    mcIdType nbTuple=ToIdType(this->getNumberOfTuples());
+    mcIdType nbComps=ToIdType(this->getNumberOfComponents());
+    std::fill(res,res+nbComps,0);
+    for(mcIdType i=0;i<nbTuple;i++)
+      std::transform(ptr+i*nbComps,ptr+(i+1)*nbComps,res,res,std::plus<T>());
+  }
+  
+  template <class T>
+  T DataArrayDiscrete<T>::accumulate(mcIdType compId) const
+  {
+    this->checkAllocated();
+    const T *ptr=this->getConstPointer();
+    mcIdType nbTuple=ToIdType(this->getNumberOfTuples());
+    mcIdType nbComps=ToIdType(this->getNumberOfComponents());
+    if(compId<0 || compId>=nbComps)
+      throw INTERP_KERNEL::Exception("DataArrayInt::accumulate : Invalid compId specified : No such nb of components !");
+    T ret=0;
+    for(mcIdType i=0;i<nbTuple;i++)
+      ret+=ptr[i*nbComps+compId];
+    return ret;
+  }
+
+  /*!
+   * This method accumulate using addition tuples in \a this using input index array [ \a bgOfIndex, \a endOfIndex ).
+   * The returned array will have same number of components than \a this and number of tuples equal to
+   * \c std::distance(bgOfIndex,endOfIndex) \b minus \b one.
+   *
+   * The input index array is expected to be ascendingly sorted in which the all referenced ids should be in [0, \c this->getNumberOfTuples).
+   *
+   * \param [in] bgOfIndex - begin (included) of the input index array.
+   * \param [in] endOfIndex - end (excluded) of the input index array.
+   * \return DataArrayInt * - the new instance having the same number of components than \a this.
+   *
+   * \throw If bgOfIndex or end is NULL.
+   * \throw If input index array is not ascendingly sorted.
+   * \throw If there is an id in [ \a bgOfIndex, \a endOfIndex ) not in [0, \c this->getNumberOfTuples).
+   * \throw If std::distance(bgOfIndex,endOfIndex)==0.
+   */
+  template <class T>
+  typename Traits<T>::ArrayType *DataArrayDiscrete<T>::accumulatePerChunck(const mcIdType *bgOfIndex, const mcIdType *endOfIndex) const
+  {
+    if(!bgOfIndex || !endOfIndex)
+      throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : input pointer NULL !");
+    this->checkAllocated();
+    mcIdType nbCompo=ToIdType(this->getNumberOfComponents());
+    mcIdType nbOfTuples=ToIdType(this->getNumberOfTuples());
+    mcIdType sz=ToIdType(std::distance(bgOfIndex,endOfIndex));
+    if(sz<1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : invalid size of input index array !");
+    sz--;
+    MCAuto<DataArrayType> ret=DataArrayType::New(); ret->alloc(sz,nbCompo);
+    const mcIdType *w=bgOfIndex;
+    if(*w<0 || *w>=nbOfTuples)
+      throw INTERP_KERNEL::Exception("DataArrayInt::accumulatePerChunck : The first element of the input index not in [0,nbOfTuples) !");
+    const T *srcPt=this->begin()+(*w)*nbCompo;
+    T *tmp=ret->getPointer();
+    for(mcIdType i=0;i<sz;i++,tmp+=nbCompo,w++)
+      {
+        std::fill(tmp,tmp+nbCompo,0);
+        if(w[1]>=w[0])
+          {
+            for(mcIdType j=w[0];j<w[1];j++,srcPt+=nbCompo)
+              {
+                if(j>=0 && j<nbOfTuples)
+                  std::transform(srcPt,srcPt+nbCompo,tmp,tmp,std::plus<T>());
+                else
+                  {
+                    std::ostringstream oss; oss << "DataArrayInt::accumulatePerChunck : At rank #" << i << " the input index array points to id " << j << " should be in [0," << nbOfTuples << ") !";
+                    throw INTERP_KERNEL::Exception(oss.str().c_str());
+                  }
+              }
+          }
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::accumulatePerChunck : At rank #" << i << " the input index array is not in ascendingly sorted.";
+            throw INTERP_KERNEL::Exception(oss.str().c_str());
+          }
+      }
+    ret->copyStringInfoFrom(*this);
+    return ret.retn();
+  }
+
+  /*!
+   * Returns in a single walk in \a this the min value and the max value in \a this.
+   * \a this is expected to be single component array.
+   *
+   * \param [out] minValue - the min value in \a this.
+   * \param [out] maxValue - the max value in \a this.
+   *
+   * \sa getMinValueInArray, getMinValue, getMaxValueInArray, getMaxValue
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::getMinMaxValues(T& minValue, T& maxValue) const
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::getMinMaxValues : must be applied on DataArrayInt with only one component !");
+    std::size_t nbTuples(this->getNumberOfTuples());
+    const T *pt(this->begin());
+    minValue=std::numeric_limits<T>::max(); maxValue=-std::numeric_limits<T>::max();
+    for(std::size_t i=0;i<nbTuples;i++,pt++)
+      {
+        if(*pt<minValue)
+          minValue=*pt;
+        if(*pt>maxValue)
+          maxValue=*pt;
+      }
+  }
+
+  /*!
+   * Modify all elements of \a this array, so that
+   * an element _x_ becomes \f$ numerator / x \f$.
+   *  \warning If an exception is thrown because of presence of 0 element in \a this
+   *           array, all elements processed before detection of the zero element remain
+   *           modified.
+   *  \param [in] numerator - the numerator used to modify array elements.
+   *  \throw If \a this is not allocated.
+   *  \throw If there is an element equal to 0 in \a this array.
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::applyInv(T numerator)
+  {
+    this->checkAllocated();
+    T *ptr=this->getPointer();
+    std::size_t nbOfElems=this->getNbOfElems();
+    for(std::size_t i=0;i<nbOfElems;i++,ptr++)
+      {
+        if(*ptr!=0)
+          {
+            *ptr=numerator/(*ptr);
+          }
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::applyInv : presence of null value in tuple #" << i/(this->getNumberOfComponents()) << " component #" << i%(this->getNumberOfComponents());
+            oss << " !";
+            throw INTERP_KERNEL::Exception(oss.str().c_str());
+          }
+      }
+    this->declareAsNew();
+  }
+
+  /*!
+   * Modify all elements of \a this array, so that
+   * an element _x_ becomes \f$ x / val \f$.
+   *  \param [in] val - the denominator used to modify array elements.
+   *  \throw If \a this is not allocated.
+   *  \throw If \a val == 0.
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::applyDivideBy(T val)
+  {
+    if(val==0)
+      throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to divide by 0 !");
+    this->checkAllocated();
+    T *ptr=this->getPointer();
+    std::size_t nbOfElems=this->getNbOfElems();
+    std::transform(ptr,ptr+nbOfElems,ptr,std::bind2nd(std::divides<T>(),val));
+    this->declareAsNew();
+  }
+
+  /*!
+   * Modify all elements of \a this array, so that
+   * an element _x_ becomes  <em> x % val </em>.
+   *  \param [in] val - the divisor used to modify array elements.
+   *  \throw If \a this is not allocated.
+   *  \throw If \a val <= 0.
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::applyModulus(T val)
+  {
+    if(val<=0)
+      throw INTERP_KERNEL::Exception("DataArrayInt::applyDivideBy : Trying to operate modulus on value <= 0 !");
+    this->checkAllocated();
+    T *ptr=this->getPointer();
+    std::size_t nbOfElems=this->getNbOfElems();
+    std::transform(ptr,ptr+nbOfElems,ptr,std::bind2nd(std::modulus<T>(),val));
+    this->declareAsNew();
+  }
+
+  /*!
+   * Modify all elements of \a this array, so that
+   * an element _x_ becomes <em> val % x </em>.
+   *  \warning If an exception is thrown because of presence of an element <= 0 in \a this
+   *           array, all elements processed before detection of the zero element remain
+   *           modified.
+   *  \param [in] val - the divident used to modify array elements.
+   *  \throw If \a this is not allocated.
+   *  \throw If there is an element equal to or less than 0 in \a this array.
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::applyRModulus(T val)
+  {
+    this->checkAllocated();
+    T *ptr=this->getPointer();
+    std::size_t nbOfElems=this->getNbOfElems();
+    for(std::size_t i=0;i<nbOfElems;i++,ptr++)
+      {
+        if(*ptr>0)
+          {
+            *ptr=val%(*ptr);
+          }
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::applyRModulus : presence of value <=0 in tuple #" << i/(this->getNumberOfComponents()) << " component #" << i%(this->getNumberOfComponents());
+            oss << " !";
+            throw INTERP_KERNEL::Exception(oss.str().c_str());
+          }
+      }
+    this->declareAsNew();
+  }
+
+  /*!
+   * Modify all elements of \a this array, so that
+   * an element _x_ becomes <em> val ^ x </em>.
+   *  \param [in] val - the value used to apply pow on all array elements.
+   *  \throw If \a this is not allocated.
+   *  \throw If \a val < 0.
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::applyPow(T val)
+  {
+    this->checkAllocated();
+    if(val<0)
+      throw INTERP_KERNEL::Exception("DataArrayInt::applyPow : input pow in < 0 !");
+    T *ptr=this->getPointer();
+    std::size_t nbOfElems=this->getNbOfElems();
+    if(val==0)
+      {
+        std::fill(ptr,ptr+nbOfElems,1);
+        return ;
+      }
+    for(std::size_t i=0;i<nbOfElems;i++,ptr++)
+      {
+        T tmp=1;
+        for(T j=0;j<val;j++)
+          tmp*=*ptr;
+        *ptr=tmp;
+      }
+    this->declareAsNew();
+  }
+  
+  /*!
+   * Modify all elements of \a this array, so that
+   * an element _x_ becomes \f$ val ^ x \f$.
+   *  \param [in] val - the value used to apply pow on all array elements.
+   *  \throw If \a this is not allocated.
+   *  \throw If there is an element < 0 in \a this array.
+   *  \warning If an exception is thrown because of presence of 0 element in \a this
+   *           array, all elements processed before detection of the zero element remain
+   *           modified.
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::applyRPow(T val)
+  {
+    this->checkAllocated();
+    T *ptr=this->getPointer();
+    std::size_t nbOfElems=this->getNbOfElems();
+    for(std::size_t i=0;i<nbOfElems;i++,ptr++)
+      {
+        if(*ptr>=0)
+          {
+            T tmp=1;
+            for(T j=0;j<*ptr;j++)
+              tmp*=val;
+            *ptr=tmp;
+          }
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::applyRPow : presence of negative value in tuple #" << i/(this->getNumberOfComponents()) << " component #" << i%(this->getNumberOfComponents());
+            oss << " !";
+            throw INTERP_KERNEL::Exception(oss.str().c_str());
+          }
+      }
+    this->declareAsNew();
+  }
+
+  /*!
+   * This method works only on data array with one component.
+   * This method returns a newly allocated array storing stored ascendantly tuple ids in \b this so that
+   * this[*id] in [\b vmin,\b vmax)
+   *
+   * \param [in] vmin begin of range. This value is included in range (included).
+   * \param [in] vmax end of range. This value is \b not included in range (excluded).
+   * \return a newly allocated data array that the caller should deal with.
+   *
+   * \sa DataArrayInt::findIdsNotInRange , DataArrayInt::findIdsStricltyNegative
+   */
+  template <class T>
+  DataArrayIdType *DataArrayDiscrete<T>::findIdsInRange(T vmin, T vmax) const
+  {
+    InRange<T> ir(vmin,vmax);
+    MCAuto<DataArrayIdType> ret(this->findIdsAdv(ir));
+    return ret.retn();
+  }
+  
+  /*!
+   * This method works only on data array with one component.
+   * This method returns a newly allocated array storing stored ascendantly tuple ids in \b this so that
+   * this[*id] \b not in [\b vmin,\b vmax)
+   *
+   * \param [in] vmin begin of range. This value is \b not included in range (excluded).
+   * \param [in] vmax end of range. This value is included in range (included).
+   * \return a newly allocated data array that the caller should deal with.
+   *
+   * \sa DataArrayInt::findIdsInRange , DataArrayInt::findIdsStricltyNegative
+   */
+  template <class T>
+  DataArrayIdType *DataArrayDiscrete<T>::findIdsNotInRange(T vmin, T vmax) const
+  {
+    NotInRange<T> nir(vmin,vmax);
+    MCAuto<DataArrayIdType> ret(this->findIdsAdv(nir));
+    return ret.retn();
+  }
+
+  /*!
+   * This method works only on data array with one component.
+   * 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.
+   *
+   * \param [in] vmin begin of range. This value is included in range (included).
+   * \param [in] vmax end of range. This value is \b not included in range (excluded).
+   * \return if all ids in \a this are so that (*this)[i]==i for all i in [ 0, \c this->getNumberOfTuples() ). */
+  template <class T>
+  bool DataArrayDiscrete<T>::checkAllIdsInRange(T vmin, T vmax) const
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::checkAllIdsInRange : this must have exactly one component !");
+    mcIdType nbOfTuples=ToIdType(this->getNumberOfTuples());
+    bool ret=true;
+    const T *cptr=this->getConstPointer();
+    for(mcIdType i=0;i<nbOfTuples;i++,cptr++)
+      {
+        if(*cptr>=vmin && *cptr<vmax)
+          { ret=ret && *cptr==i; }
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::checkAllIdsInRange : tuple #" << i << " has value " << *cptr << " should be in [" << vmin << "," << vmax << ") !";
+            throw INTERP_KERNEL::Exception(oss.str().c_str());
+          }
+      }
+    return ret;
+  }
+
+  /*!
+   * Returns a new DataArrayInt which contains a complement of elements of \a this
+   * one-dimensional array. I.e. the result array contains all elements from the range [0,
+   * \a nbOfElement) not present in \a this array.
+   *  \param [in] nbOfElement - maximal size of the result array.
+   *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
+   *         array using decrRef() as it is no more needed.
+   *  \throw If \a this is not allocated.
+   *  \throw If \a this->getNumberOfComponents() != 1.
+   *  \throw If any element \a x of \a this array violates condition ( 0 <= \a x < \a
+   *         nbOfElement ).
+   */
+  template <class T>
+  DataArrayIdType *DataArrayDiscrete<T>::buildComplement(mcIdType nbOfElement) const
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : only single component allowed !");
+    std::vector<bool> tmp(nbOfElement);
+    const T *pt=this->getConstPointer();
+    std::size_t nbOfTuples=this->getNumberOfTuples();
+    for(const T *w=pt;w!=pt+nbOfTuples;w++)
+      if(*w>=0 && *w<nbOfElement)
+        tmp[*w]=true;
+      else
+        throw INTERP_KERNEL::Exception("DataArrayInt::buildComplement : an element is not in valid range : [0,nbOfElement) !");
+    std::size_t nbOfRetVal=std::count(tmp.begin(),tmp.end(),false);
+    DataArrayIdType *ret=DataArrayIdType::New();
+    ret->alloc(nbOfRetVal,1);
+    mcIdType j=0;
+    mcIdType *retPtr=ret->getPointer();
+    for(mcIdType i=0;i<nbOfElement;i++)
+      if(!tmp[i])
+        retPtr[j++]=i;
+    return ret;
+  }
+
+  /*!
+   * Returns a new DataArrayInt containing elements of \a this one-dimensional missing
+   * from an \a other one-dimensional array.
+   *  \param [in] other - a DataArrayInt containing elements not to include in the result array.
+   *  \return DataArrayInt * - a new instance of DataArrayInt with one component. The
+   *         caller is to delete this array using decrRef() as it is no more needed.
+   *  \throw If \a other is NULL.
+   *  \throw If \a other is not allocated.
+   *  \throw If \a other->getNumberOfComponents() != 1.
+   *  \throw If \a this is not allocated.
+   *  \throw If \a this->getNumberOfComponents() != 1.
+   *  \sa DataArrayInt::buildSubstractionOptimized()
+   */
+  template <class T>
+  typename Traits<T>::ArrayType *DataArrayDiscrete<T>::buildSubstraction(const DataArrayType *other) const
+  {
+    if(!other)
+      throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : DataArrayInt pointer in input is NULL !");
+    this->checkAllocated();
+    other->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed !");
+    if(other->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstraction : only single component allowed for other type !");
+    const T *pt=this->getConstPointer();
+    std::size_t nbOfTuples=this->getNumberOfTuples();
+    std::set<T> s1(pt,pt+nbOfTuples);
+    pt=other->getConstPointer();
+    nbOfTuples=other->getNumberOfTuples();
+    std::set<T> s2(pt,pt+nbOfTuples);
+    std::vector<T> r;
+    std::set_difference(s1.begin(),s1.end(),s2.begin(),s2.end(),std::back_insert_iterator< std::vector<T> >(r));
+    DataArrayType *ret=DataArrayType::New();
+    ret->alloc(r.size(),1);
+    std::copy(r.begin(),r.end(),ret->getPointer());
+    return ret;
+  }
+
+  /*!
+   * \a this is expected to have one component and to be sorted ascendingly (as for \a other).
+   * \a other is expected to be a part of \a this. If not DataArrayInt::buildSubstraction should be called instead.
+   *
+   * \param [in] other an array with one component and expected to be sorted ascendingly.
+   * \ret list of ids in \a this but not in \a other.
+   * \sa DataArrayInt::buildSubstraction
+   */
+  template <class T>
+  typename Traits<T>::ArrayType *DataArrayDiscrete<T>::buildSubstractionOptimized(const DataArrayType *other) const
+  {
+    static const char *MSG="DataArrayInt::buildSubstractionOptimized : only single component allowed !";
+    if(!other) throw INTERP_KERNEL::Exception("DataArrayInt::buildSubstractionOptimized : NULL input array !");
+    this->checkAllocated(); other->checkAllocated();
+    if(this->getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception(MSG);
+    if(other->getNumberOfComponents()!=1) throw INTERP_KERNEL::Exception(MSG);
+    const T *pt1Bg(this->begin()),*pt1End(this->end()),*pt2Bg(other->begin()),*pt2End(other->end());
+    const T *work1(pt1Bg),*work2(pt2Bg);
+    MCAuto<DataArrayType> ret(DataArrayType::New()); ret->alloc(0,1);
+    for(;work1!=pt1End;work1++)
+      {
+        if(work2!=pt2End && *work1==*work2)
+          work2++;
+        else
+          ret->pushBackSilent(*work1);
+      }
+    return ret.retn();
+  }
+
+  /*!
+   * Returns a new DataArrayInt which contains all elements of \a this and a given
+   * one-dimensional arrays. The result array does not contain any duplicates
+   * and its values are sorted in ascending order.
+   *  \param [in] other - an array to unite with \a this one.
+   *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
+   *         array using decrRef() as it is no more needed.
+   *  \throw If \a this or \a other is not allocated.
+   *  \throw If \a this->getNumberOfComponents() != 1.
+   *  \throw If \a other->getNumberOfComponents() != 1.
+   */
+  template <class T>
+  typename Traits<T>::ArrayType *DataArrayDiscrete<T>::buildUnion(const DataArrayType *other) const
+  {
+    std::vector<const DataArrayType *>arrs(2);
+    arrs[0]=dynamic_cast<const DataArrayType *>(this); arrs[1]=other;
+    return DataArrayDiscrete<T>::BuildUnion(arrs);
+  }
+
+  /*!
+   * Returns a new DataArrayInt which contains elements present in both \a this and a given
+   * one-dimensional arrays. The result array does not contain any duplicates
+   * and its values are sorted in ascending order.
+   *  \param [in] other - an array to intersect with \a this one.
+   *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
+   *         array using decrRef() as it is no more needed.
+   *  \throw If \a this or \a other is not allocated.
+   *  \throw If \a this->getNumberOfComponents() != 1.
+   *  \throw If \a other->getNumberOfComponents() != 1.
+   */
+  template <class T>
+  typename Traits<T>::ArrayType *DataArrayDiscrete<T>::buildIntersection(const DataArrayType *other) const
+  {
+    std::vector<const DataArrayType *>arrs(2);
+    arrs[0]=dynamic_cast<const DataArrayType *>(this); arrs[1]=other;
+    return DataArrayDiscrete<T>::BuildIntersection(arrs);
+  }
+
+  /*!
+   * This method can be applied on allocated with one component DataArrayInt instance.
+   * This method is typically relevant for sorted arrays. All consecutive duplicated items in \a this will appear only once in returned DataArrayInt instance.
+   * 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]
+   *
+   * \return a newly allocated array that contain the result of the unique operation applied on \a this.
+   * \throw if \a this is not allocated or if \a this has not exactly one component.
+   * \sa DataArrayInt::buildUniqueNotSorted
+   */
+  template <class T>
+  typename Traits<T>::ArrayType *DataArrayDiscrete<T>::buildUnique() const
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::buildUnique : only single component allowed !");
+    std::size_t nbOfTuples=this->getNumberOfTuples();
+    MCAuto<DataArrayType> tmp=DataArrayType::New();
+    tmp->deepCopyFrom (*this);
+    T *data=tmp->getPointer();
+    T *last=std::unique(data,data+nbOfTuples);
+    MCAuto<DataArrayType> ret=DataArrayType::New();
+    ret->alloc(std::distance(data,last),1);
+    std::copy(data,last,ret->getPointer());
+    return ret.retn();
+  }
+
+  /*!
+   * This method can be applied on allocated with one component DataArrayInt instance.
+   * This method keep elements only once by keeping the same order in \a this that is not expected to be sorted.
+   *
+   * \return a newly allocated array that contain the result of the unique operation applied on \a this.
+   *
+   * \throw if \a this is not allocated or if \a this has not exactly one component.
+   *
+   * \sa DataArrayInt::buildUnique
+   */
+  template <class T>
+  typename Traits<T>::ArrayType *DataArrayDiscrete<T>::buildUniqueNotSorted() const
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::buildUniqueNotSorted : only single component allowed !");
+    T minVal,maxVal;
+    this->getMinMaxValues(minVal,maxVal);
+    std::vector<bool> b(maxVal-minVal+1,false);
+    const T *ptBg(this->begin()),*endBg(this->end());
+    MCAuto<DataArrayType> ret(DataArrayType::New()); ret->alloc(0,1);
+    for(const T *pt=ptBg;pt!=endBg;pt++)
+      {
+        if(!b[*pt-minVal])
+          {
+            ret->pushBackSilent(*pt);
+            b[*pt-minVal]=true;
+          }
+      }
+    ret->copyStringInfoFrom(*this);
+    return ret.retn();
+  }
+
+  /*!
+   * Returns a new DataArrayInt which contains size of every of groups described by \a this
+   * "index" array. Such "index" array is returned for example by
+   * \ref MEDCoupling::MEDCouplingUMesh::buildDescendingConnectivity
+   * "MEDCouplingUMesh::buildDescendingConnectivity" and
+   * \ref MEDCoupling::MEDCouplingUMesh::getNodalConnectivityIndex
+   * "MEDCouplingUMesh::getNodalConnectivityIndex" etc.
+   * This method performs the reverse operation of DataArrayInt::computeOffsetsFull.
+   *  \return DataArrayInt * - a new instance of DataArrayInt, whose number of tuples
+   *          equals to \a this->getNumberOfComponents() - 1, and number of components is 1.
+   *          The caller is to delete this array using decrRef() as it is no more needed.
+   *  \throw If \a this is not allocated.
+   *  \throw If \a this->getNumberOfComponents() != 1.
+   *  \throw If \a this->getNumberOfTuples() < 2.
+   *
+   *  \b Example: <br>
+   *         - this contains [1,3,6,7,7,9,15]
+   *         - result array contains [2,3,1,0,2,6],
+   *          where 2 = 3 - 1, 3 = 6 - 3, 1 = 7 - 6 etc.
+   *
+   * \sa DataArrayInt::computeOffsetsFull
+   */
+  template <class T>
+  typename Traits<T>::ArrayType *DataArrayDiscrete<T>::deltaShiftIndex() const
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::deltaShiftIndex : only single component allowed !");
+    std::size_t nbOfTuples=this->getNumberOfTuples();
+    if(nbOfTuples<2)
+      throw INTERP_KERNEL::Exception("DataArrayInt::deltaShiftIndex : 1 tuple at least must be present in 'this' !");
+    const T *ptr=this->getConstPointer();
+    DataArrayType *ret=DataArrayType::New();
+    ret->alloc(nbOfTuples-1,1);
+    T *out=ret->getPointer();
+    std::transform(ptr+1,ptr+nbOfTuples,ptr,out,std::minus<T>());
+    return ret;
+  }
+
+  /*!
+   * Modifies \a this one-dimensional array so that value of each element \a x
+   * of \a this array (\a a) is computed as \f$ x_i = \sum_{j=0}^{i-1} a[ j ] \f$.
+   * Or: for each i>0 new[i]=new[i-1]+old[i-1] for i==0 new[i]=0. Number of tuples
+   * and components remains the same.<br>
+   * This method is useful for allToAllV in MPI with contiguous policy. This method
+   * differs from computeOffsetsFull() in that the number of tuples is \b not changed by
+   * this one.
+   *  \throw If \a this is not allocated.
+   *  \throw If \a this->getNumberOfComponents() != 1.
+   *
+   *  \b Example: <br>
+   *          - Before \a this contains [3,5,1,2,0,8]
+   *          - After \a this contains  [0,3,8,9,11,11]<br>
+   *          Note that the last element 19 = 11 + 8 is missing because size of \a this
+   *          array is retained and thus there is no space to store the last element.
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::computeOffsets()
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsets : only single component allowed !");
+    std::size_t nbOfTuples=this->getNumberOfTuples();
+    if(nbOfTuples==0)
+      return ;
+    T *work=this->getPointer();
+    T tmp=work[0];
+    work[0]=0;
+    for(std::size_t i=1;i<nbOfTuples;i++)
+      {
+        T tmp2=work[i];
+        work[i]=work[i-1]+tmp;
+        tmp=tmp2;
+      }
+    this->declareAsNew();
+  }
+
+  /*!
+   * Modifies \a this one-dimensional array so that value of each element \a x
+   * of \a this array (\a a) is computed as \f$ x_i = \sum_{j=0}^{i-1} a[ j ] \f$.
+   * Or: for each i>0 new[i]=new[i-1]+old[i-1] for i==0 new[i]=0. Number
+   * components remains the same and number of tuples is inceamented by one.<br>
+   * This method is useful for allToAllV in MPI with contiguous policy. This method
+   * differs from computeOffsets() in that the number of tuples is changed by this one.
+   * This method performs the reverse operation of DataArrayInt::deltaShiftIndex.
+   *  \throw If \a this is not allocated.
+   *  \throw If \a this->getNumberOfComponents() != 1.
+   *
+   *  \b Example: <br>
+   *          - Before \a this contains [3,5,1,2,0,8]
+   *          - After \a this contains  [0,3,8,9,11,11,19]<br>
+   * \sa DataArrayInt::deltaShiftIndex
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::computeOffsetsFull()
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::computeOffsetsFull : only single component allowed !");
+    std::size_t nbOfTuples=this->getNumberOfTuples();
+    T *ret=(T *)malloc((nbOfTuples+1)*sizeof(T));
+    const T *work=this->getConstPointer();
+    ret[0]=0;
+    for(std::size_t i=0;i<nbOfTuples;i++)
+      ret[i+1]=work[i]+ret[i];
+    this->useArray(ret,true,DeallocType::C_DEALLOC,ToIdType(nbOfTuples)+1,1);
+    this->declareAsNew();
+  }
+
+  /*!
+   * Returns two new DataArrayInt instances whose contents is computed from that of \a this and \a listOfIds arrays as follows.
+   * \a this is expected to be an offset format ( as returned by DataArrayInt::computeOffsetsFull ) that is to say with one component
+   * and ** sorted strictly increasingly **. \a listOfIds is expected to be sorted ascendingly (not strictly needed for \a listOfIds).
+   * This methods searches in \a this, considered as a set of contiguous \c this->getNumberOfComponents() ranges, all ids in \a listOfIds
+   * filling completely one of the ranges in \a this.
+   *
+   * \param [in] listOfIds a list of ids that has to be sorted ascendingly.
+   * \param [out] rangeIdsFetched the range ids fetched
+   * \param [out] idsInInputListThatFetch contains the list of ids in \a listOfIds that are \b fully included in a range in \a this. So
+   *              \a idsInInputListThatFetch is a part of input \a listOfIds.
+   *
+   * \sa DataArrayInt::computeOffsetsFull
+   *
+   *  \b Example: <br>
+   *          - \a this : [0,3,7,9,15,18]
+   *          - \a listOfIds contains  [0,1,2,3,7,8,15,16,17]
+   *          - \a rangeIdsFetched result array: [0,2,4]
+   *          - \a idsInInputListThatFetch result array: [0,1,2,7,8,15,16,17]
+   * In this example id 3 in input \a listOfIds is alone so it do not appear in output \a idsInInputListThatFetch.
+   * <br>
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::findIdsRangesInListOfIds(const DataArrayType *listOfIds, DataArrayIdType *& rangeIdsFetched, DataArrayType *& idsInInputListThatFetch) const
+  {
+    if(!listOfIds)
+      throw INTERP_KERNEL::Exception("DataArrayInt::findIdsRangesInListOfIds : input list of ids is null !");
+    listOfIds->checkAllocated(); this->checkAllocated();
+    if(listOfIds->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::findIdsRangesInListOfIds : input list of ids must have exactly one component !");
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::findIdsRangesInListOfIds : this must have exactly one component !");
+    MCAuto<DataArrayIdType> ret0=DataArrayIdType::New(); ret0->alloc(0,1);
+    MCAuto<DataArrayType> ret1=DataArrayType::New(); ret1->alloc(0,1);
+    const T *tupPtr(listOfIds->begin()), *tupEnd(listOfIds->end());
+    const T *offBg(this->begin()),*offEnd(this->end()-1);
+    const T *offPtr(offBg);
+    while(tupPtr!=tupEnd && offPtr!=offEnd)
+      {
+        if(*tupPtr==*offPtr)
+          {
+            T i=offPtr[0];
+            while(i<offPtr[1] && *tupPtr==i && tupPtr!=tupEnd) { i++; tupPtr++; }
+            if(i==offPtr[1])
+              {
+                ret0->pushBackSilent(ToIdType(std::distance(offBg,offPtr)));
+                ret1->pushBackValsSilent(tupPtr-(offPtr[1]-offPtr[0]),tupPtr);
+                offPtr++;
+              }
+          }
+        else
+          { if(*tupPtr<*offPtr) tupPtr++; else offPtr++; }
+      }
+    rangeIdsFetched=ret0.retn();
+    idsInInputListThatFetch=ret1.retn();
+  }
+
+  /*!
+   * Returns a new DataArrayInt whose contents is computed from that of \a this and \a
+   * offsets arrays as follows. \a offsets is a one-dimensional array considered as an
+   * "index" array of a "iota" array, thus, whose each element gives an index of a group
+   * beginning within the "iota" array. And \a this is a one-dimensional array
+   * considered as a selector of groups described by \a offsets to include into the result array.
+   *  \throw If \a offsets is NULL.
+   *  \throw If \a offsets is not allocated.
+   *  \throw If \a offsets->getNumberOfComponents() != 1.
+   *  \throw If \a offsets is not monotonically increasing.
+   *  \throw If \a this is not allocated.
+   *  \throw If \a this->getNumberOfComponents() != 1.
+   *  \throw If any element of \a this is not a valid index for \a offsets array.
+   *
+   *  \b Example: <br>
+   *          - \a this: [0,2,3]
+   *          - \a offsets: [0,3,6,10,14,20]
+   *          - result array: [0,1,2,6,7,8,9,10,11,12,13] == <br>
+   *            \c range(0,3) + \c range(6,10) + \c range(10,14) ==<br>
+   *            \c range( \a offsets[ \a this[0] ], offsets[ \a this[0]+1 ]) +
+   *            \c range( \a offsets[ \a this[1] ], offsets[ \a this[1]+1 ]) +
+   *            \c range( \a offsets[ \a this[2] ], offsets[ \a this[2]+1 ])
+   */
+  template <class T>
+  typename Traits<T>::ArrayType *DataArrayDiscrete<T>::buildExplicitArrByRanges(const DataArrayType *offsets) const
+  {
+    if(!offsets)
+      throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : DataArrayInt pointer in input is NULL !");
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : only single component allowed !");
+    offsets->checkAllocated();
+    if(offsets->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrByRanges : input array should have only single component !");
+    mcIdType othNbTuples=ToIdType(offsets->getNumberOfTuples())-1;
+    mcIdType nbOfTuples=ToIdType(this->getNumberOfTuples());
+    T retNbOftuples=0;
+    const T *work=this->getConstPointer();
+    const T *offPtr=offsets->getConstPointer();
+    for(mcIdType i=0;i<nbOfTuples;i++)
+      {
+        T val=work[i];
+        if(val>=0 && val<othNbTuples)
+          {
+            T delta=offPtr[val+1]-offPtr[val];
+            if(delta>=0)
+              retNbOftuples+=delta;
+            else
+              {
+                std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrByRanges : Tuple #" << val << " of offset array has a delta < 0 !";
+                throw INTERP_KERNEL::Exception(oss.str().c_str());
+              }
+          }
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrByRanges : Tuple #" << i << " in this contains " << val;
+            oss << " whereas offsets array is of size " << othNbTuples+1 << " !";
+            throw INTERP_KERNEL::Exception(oss.str().c_str());
+          }
+      }
+    MCAuto<DataArrayType> ret=DataArrayType::New();
+    ret->alloc(retNbOftuples,1);
+    T *retPtr=ret->getPointer();
+    for(mcIdType i=0;i<nbOfTuples;i++)
+      {
+        T val=work[i];
+        T start=offPtr[val];
+        T off=offPtr[val+1]-start;
+        for(T j=0;j<off;j++,retPtr++)
+          *retPtr=start+j;
+      }
+    return ret.retn();
+  }
+
+  /*!
+   * Returns a new DataArrayInt whose contents is computed using \a this that must be a
+   * scaled array (monotonically increasing).
+  from that of \a this and \a
+   * offsets arrays as follows. \a offsets is a one-dimensional array considered as an
+   * "index" array of a "iota" array, thus, whose each element gives an index of a group
+   * beginning within the "iota" array. And \a this is a one-dimensional array
+   * considered as a selector of groups described by \a offsets to include into the result array.
+   *  \throw If \a  is NULL.
+   *  \throw If \a this is not allocated.
+   *  \throw If \a this->getNumberOfComponents() != 1.
+   *  \throw If \a this->getNumberOfTuples() == 0.
+   *  \throw If \a this is not monotonically increasing.
+   *  \throw If any element of ids in ( \a bg \a stop \a step ) points outside the scale in \a this.
+   *
+   *  \b Example: <br>
+   *          - \a bg , \a stop and \a step : (0,5,2)
+   *          - \a this: [0,3,6,10,14,20]
+   *          - result array: [0,0,0, 2,2,2,2, 4,4,4,4,4,4] == <br>
+   */
+  template <class T>
+  typename Traits<T>::ArrayType *DataArrayDiscrete<T>::buildExplicitArrOfSliceOnScaledArr(T bg, T stop, T step) const
+  {
+    if(!this->isAllocated())
+      throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : not allocated array !");
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : number of components is expected to be equal to one !");
+    mcIdType nbOfTuples = ToIdType(this->getNumberOfTuples());
+    if(nbOfTuples==0)
+      throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr : number of tuples must be != 0 !");
+    const T *ids(this->begin());
+    // TODO: the method GetNumberOfItemGivenBESRelative should be moved to DataArrayTemplate and conversion must be removed
+    mcIdType nbOfEltsInSlc=DataArray::GetNumberOfItemGivenBESRelative(ToIdType(bg),ToIdType(stop),ToIdType(step),"DataArrayInt::buildExplicitArrOfSliceOnScaledArr");
+    T sz(0),pos(bg);
+    for(mcIdType i=0;i<nbOfEltsInSlc;i++,pos+=step)
+      {
+        if(pos>=0 && pos<nbOfTuples-1)
+          {
+            T delta(ids[pos+1]-ids[pos]);
+            sz+=delta;
+            if(delta<0)
+              {
+                std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrOfSliceOnScaledArr : At pos #" << i << " of input slice, value is " << pos << " and at this pos this is not monotonically increasing !";
+                throw INTERP_KERNEL::Exception(oss.str().c_str());
+              }
+          }
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::buildExplicitArrOfSliceOnScaledArr : At pos #" << i << " of input slice, value is " << pos << " should be in [0," << nbOfTuples-1 << ") !";
+            throw INTERP_KERNEL::Exception(oss.str().c_str());
+          }
+      }
+    MCAuto<DataArrayType> ret(DataArrayType::New()); ret->alloc(sz,1);
+    T *retPtr(ret->getPointer());
+    pos=bg;
+    for(mcIdType i=0;i<nbOfEltsInSlc;i++,pos+=step)
+      {
+        T delta(ids[pos+1]-ids[pos]);
+        for(T j=0;j<delta;j++,retPtr++)
+          *retPtr=pos;
+      }
+    return ret.retn();
+  }
+
+  /*!
+   * 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.
+   * 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
+   * in tuple **i** of returned DataArrayInt.
+   * If ranges overlapped (in theory it should not) this method do not detect it and always returns the first range.
+   *
+   * 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)]
+   * The return DataArrayInt will contain : **[0,4,1,2,2,3]**
+   *
+   * \param [in] ranges typically come from output of MEDCouplingUMesh::ComputeRangesFromTypeDistribution. Each range is specified like this : 1st component is
+   *             for lower value included and 2nd component is the upper value of corresponding range **excluded**.
+   * \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
+   *        is thrown if no ranges in \a ranges contains value in \a this.
+   *
+   * \sa DataArrayInt::findIdInRangeForEachTuple
+   */
+  template <class T>
+  DataArrayIdType *DataArrayDiscrete<T>::findRangeIdForEachTuple(const DataArrayType *ranges) const
+  {
+    if(!ranges)
+      throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : null input pointer !");
+    if(ranges->getNumberOfComponents()!=2)
+      throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : input DataArrayInt instance should have 2 components !");
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::findRangeIdForEachTuple : this should have only one component !");
+    mcIdType nbTuples=ToIdType(this->getNumberOfTuples());
+    MCAuto<DataArrayIdType> ret=DataArrayIdType::New(); ret->alloc(nbTuples,1);
+    mcIdType nbOfRanges=ToIdType(ranges->getNumberOfTuples());
+    const T *rangesPtr=ranges->getConstPointer();
+    mcIdType *retPtr=ret->getPointer();
+    const T *inPtr=this->getConstPointer();
+    for(mcIdType i=0;i<nbTuples;i++,retPtr++)
+      {
+        T val=inPtr[i];
+        bool found=false;
+        for(mcIdType j=0;j<nbOfRanges && !found;j++)
+          if(val>=rangesPtr[2*j] && val<rangesPtr[2*j+1])
+            { *retPtr=j; found=true; }
+        if(found)
+          continue;
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::findRangeIdForEachTuple : tuple #" << i << " not found by any ranges !";
+            throw INTERP_KERNEL::Exception(oss.str().c_str());
+          }
+      }
+    return ret.retn();
+  }
+
+  /*!
+   * 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.
+   * 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
+   * in tuple **i** of returned DataArrayInt.
+   * If ranges overlapped (in theory it should not) this method do not detect it and always returns the sub position of the first range.
+   *
+   * 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)]
+   * The return DataArrayInt will contain : **[1,2,4,0,2,2]**
+   * This method is often called in pair with DataArrayInt::findRangeIdForEachTuple method.
+   *
+   * \param [in] ranges typically come from output of MEDCouplingUMesh::ComputeRangesFromTypeDistribution. Each range is specified like this : 1st component is
+   *             for lower value included and 2nd component is the upper value of corresponding range **excluded**.
+   * \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
+   *        is thrown if no ranges in \a ranges contains value in \a this.
+   * \sa DataArrayInt::findRangeIdForEachTuple
+   */
+  template <class T>
+  typename Traits<T>::ArrayType *DataArrayDiscrete<T>::findIdInRangeForEachTuple(const DataArrayType *ranges) const
+  {
+    if(!ranges)
+      throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : null input pointer !");
+    if(ranges->getNumberOfComponents()!=2)
+      throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : input DataArrayInt instance should have 2 components !");
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::findIdInRangeForEachTuple : this should have only one component !");
+    std::size_t nbTuples=this->getNumberOfTuples();
+    MCAuto<DataArrayType> ret=DataArrayType::New(); ret->alloc(nbTuples,1);
+    std::size_t nbOfRanges=ranges->getNumberOfTuples();
+    const T *rangesPtr=ranges->getConstPointer();
+    T *retPtr=ret->getPointer();
+    const T *inPtr=this->getConstPointer();
+    for(std::size_t i=0;i<nbTuples;i++,retPtr++)
+      {
+        T val=inPtr[i];
+        bool found=false;
+        for(std::size_t j=0;j<nbOfRanges && !found;j++)
+          if(val>=rangesPtr[2*j] && val<rangesPtr[2*j+1])
+            { *retPtr=val-rangesPtr[2*j]; found=true; }
+        if(found)
+          continue;
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::findIdInRangeForEachTuple : tuple #" << i << " not found by any ranges !";
+            throw INTERP_KERNEL::Exception(oss.str().c_str());
+          }
+      }
+    return ret.retn();
+  }
+
+  /*!
+   * \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).
+   * 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).
+   * 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 !
+   * If this method has correctly worked, \a this will be able to be considered as a linked list.
+   * This method does nothing if number of tuples is lower of equal to 1.
+   *
+   * This method is useful for users having an unstructured mesh having only SEG2 to rearrange internally the connectivity without any coordinates consideration.
+   *
+   * \sa MEDCouplingUMesh::orderConsecutiveCells1D, DataArrayInt::fromLinkedListOfPairToList
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::sortEachPairToMakeALinkedList()
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=2)
+      throw INTERP_KERNEL::Exception("DataArrayInt::sortEachPairToMakeALinkedList : Only works on DataArrayInt instance with nb of components equal to 2 !");
+    std::size_t nbOfTuples(this->getNumberOfTuples());
+    if(nbOfTuples<=1)
+      return ;
+    T *conn(this->getPointer());
+    for(std::size_t i=1;i<nbOfTuples;i++,conn+=2)
+      {
+        if(i>1)
+          {
+            if(conn[2]==conn[3])
+              {
+                std::ostringstream oss; oss << "DataArrayInt::sortEachPairToMakeALinkedList : In the tuple #" << i << " presence of a pair filled with same ids !";
+                throw INTERP_KERNEL::Exception(oss.str().c_str());
+              }
+            if(conn[2]!=conn[1] && conn[3]==conn[1] && conn[2]!=conn[0])
+              std::swap(conn[2],conn[3]);
+            //not(conn[2]==conn[1] && conn[3]!=conn[1] && conn[3]!=conn[0])
+            if(conn[2]!=conn[1] || conn[3]==conn[1] || conn[3]==conn[0])
+              {
+                std::ostringstream oss; oss << "DataArrayInt::sortEachPairToMakeALinkedList : In the tuple #" << i << " something is invalid !";
+                throw INTERP_KERNEL::Exception(oss.str().c_str());
+              }
+          }
+        else
+          {
+            if(conn[0]==conn[1] || conn[2]==conn[3])
+              throw INTERP_KERNEL::Exception("DataArrayInt::sortEachPairToMakeALinkedList : In the 2 first tuples presence of a pair filled with same ids !");
+            T tmp[4];
+            std::set<T> s;
+            s.insert(conn,conn+4);
+            if(s.size()!=3)
+              throw INTERP_KERNEL::Exception("DataArrayInt::sortEachPairToMakeALinkedList : This can't be considered as a linked list regarding 2 first tuples !");
+            if(std::count(conn,conn+4,conn[0])==2)
+              {
+                tmp[0]=conn[1];
+                tmp[1]=conn[0];
+                tmp[2]=conn[0];
+                if(conn[2]==conn[0])
+                  { tmp[3]=conn[3]; }
+                else
+                  { tmp[3]=conn[2];}
+                std::copy(tmp,tmp+4,conn);
+              }
+            else
+              {//here we are sure to have (std::count(conn,conn+4,conn[1])==2)
+                if(conn[1]==conn[3])
+                  std::swap(conn[2],conn[3]);
+              }
+          }
+      }
+  }
+
+  /*!
+   * \a this is expected to be a correctly linked list of pairs.
+   *
+   * \sa DataArrayInt::sortEachPairToMakeALinkedList
+   */
+  template <class T>
+  MCAuto<typename Traits<T>::ArrayType> DataArrayDiscrete<T>::fromLinkedListOfPairToList() const
+  {
+    this->checkAllocated();
+    this->checkNbOfComps(2,"DataArrayInt::fromLinkedListOfPairToList : this is expected to have 2 components");
+    mcIdType nbTuples=ToIdType(this->getNumberOfTuples());
+    if(nbTuples<1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::fromLinkedListOfPairToList : no tuples in this ! Not a linked list !");
+    MCAuto<DataArrayType> ret(DataArrayType::New()); ret->alloc(nbTuples+1,1);
+    const T *thisPtr(this->begin());
+    T *retPtr(ret->getPointer());
+    retPtr[0]=thisPtr[0];
+    for(mcIdType i=0;i<nbTuples;i++)
+      {
+        retPtr[i+1]=thisPtr[2*i+1];
+        if(i<nbTuples-1)
+          if(thisPtr[2*i+1]!=thisPtr[2*(i+1)+0])
+            {
+              std::ostringstream oss; oss << "DataArrayInt::fromLinkedListOfPairToList : this is not a proper linked list of pair. The link is broken between tuple #" << i << " and tuple #" << i+1 << " ! Call sortEachPairToMakeALinkedList ?";
+              throw INTERP_KERNEL::Exception(oss.str());
+            }
+      }
+    return ret;
+  }
+
+  /*!
+   * This method returns all different values found in \a this. This method throws if \a this has not been allocated.
+   * But the number of components can be different from one.
+   * \return a newly allocated array (that should be dealt by the caller) containing different values in \a this.
+   */
+  template <class T>
+  typename Traits<T>::ArrayType *DataArrayDiscrete<T>::getDifferentValues() const
+  {
+    this->checkAllocated();
+    std::set<T> ret;
+    ret.insert(this->begin(),this->end());
+    MCAuto<DataArrayType> ret2=DataArrayType::New();
+    ret2->alloc(ret.size(),1);
+    std::copy(ret.begin(),ret.end(),ret2->getPointer());
+    return ret2.retn();
+  }
+
+  /*!
+   * This method is a refinement of DataArrayInt::getDifferentValues because it returns not only different values in \a this but also, for each of
+   * them it tells which tuple id have this id.
+   * This method works only on arrays with one component (if it is not the case call DataArrayInt::rearrange(1) ).
+   * This method returns two arrays having same size.
+   * 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.
+   * 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]]
+   */
+  template <class T>
+  std::vector<DataArrayIdType *> DataArrayDiscrete<T>::partitionByDifferentValues(std::vector<T>& differentIds) const
+  {
+    this->checkAllocated();
+    if(this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::partitionByDifferentValues : this should have only one component !");
+    mcIdType id=0;
+    std::map<T,mcIdType> m,m2,m3;
+    for(const T *w=this->begin();w!=this->end();w++)
+      m[*w]++;
+    differentIds.resize(m.size());
+    std::vector<DataArrayIdType *> ret(m.size());
+    std::vector<mcIdType *> retPtr(m.size());
+    for(typename std::map<T,mcIdType>::const_iterator it=m.begin();it!=m.end();it++,id++)
+      {
+        m2[(*it).first]=id;
+        ret[id]=DataArrayIdType::New();
+        ret[id]->alloc((*it).second,1);
+        retPtr[id]=ret[id]->getPointer();
+        differentIds[id]=(*it).first;
+      }
+    id=0;
+    for(const T *w=this->begin();w!=this->end();w++,id++)
+      {
+        retPtr[m2[*w]][m3[*w]++]=id;
+      }
+    return ret;
+  }
+
+  /*!
+   * This method split ids in [0, \c this->getNumberOfTuples() ) using \a this array as a field of weight (>=0 each).
+   * The aim of this method is to return a set of \a nbOfSlices chunk of contiguous ids as balanced as possible.
+   *
+   * \param [in] nbOfSlices - number of slices expected.
+   * \return - a vector having a size equal to \a nbOfSlices giving the start (included) and the stop (excluded) of each chunks.
+   *
+   * \sa DataArray::GetSlice
+   * \throw If \a this is not allocated or not with exactly one component.
+   * \throw If an element in \a this if < 0.
+   */
+  template <class T>
+  std::vector< std::pair<mcIdType,mcIdType> > DataArrayDiscrete<T>::splitInBalancedSlices(mcIdType nbOfSlices) const
+  {
+    if(!this->isAllocated() || this->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::splitInBalancedSlices : this array should have number of components equal to one and must be allocated !");
+    if(nbOfSlices<=0)
+      throw INTERP_KERNEL::Exception("DataArrayInt::splitInBalancedSlices : number of slices must be >= 1 !");
+    T sum(this->accumulate(0));
+    mcIdType nbOfTuples=ToIdType(this->getNumberOfTuples());
+    T sumPerSlc(sum/nbOfSlices);
+    mcIdType pos(0);
+    const T *w(this->begin());
+    std::vector< std::pair<mcIdType,mcIdType> > ret(nbOfSlices);
+    for(mcIdType i=0;i<nbOfSlices;i++)
+      {
+        std::pair<mcIdType, mcIdType> p(pos,-1);
+        T locSum(0);
+        while(locSum<sumPerSlc && pos<nbOfTuples) { pos++; locSum+=*w++; }
+        if(i!=nbOfSlices-1)
+          p.second=pos;
+        else
+          p.second=nbOfTuples;
+        ret[i]=p;
+      }
+    return ret;
+  }
+
+  /*!
+   * Modify \a this array so that each value becomes a modulus of division of this value by
+   * a value of another DataArrayInt. There are 3 valid cases.
+   * 1.  The arrays have same number of tuples and components. Then each value of
+   *    \a this array is divided by the corresponding value of \a other one, i.e.:
+   *   _a_ [ i, j ] %= _other_ [ i, j ].
+   * 2.  The arrays have same number of tuples and \a other array has one component. Then
+   *   _a_ [ i, j ] %= _other_ [ i, 0 ].
+   * 3.  The arrays have same number of components and \a other array has one tuple. Then
+   *   _a_ [ i, j ] %= _a2_ [ 0, j ].
+   *
+   *  \warning No check of division by zero is performed!
+   *  \param [in] other - a divisor array.
+   *  \throw If \a other is NULL.
+   *  \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples() and
+   *         \a this->getNumberOfComponents() != \a other->getNumberOfComponents() and
+   *         \a other has number of both tuples and components not equal to 1.
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::modulusEqual(const DataArrayType *other)
+  {
+    if(!other)
+      throw INTERP_KERNEL::Exception("DataArrayInt::modulusEqual : input DataArrayInt instance is NULL !");
+    const char *msg="Nb of tuples mismatch for DataArrayInt::modulusEqual !";
+    this->checkAllocated(); other->checkAllocated();
+    mcIdType nbOfTuple=ToIdType(this->getNumberOfTuples());
+    mcIdType nbOfTuple2=ToIdType(other->getNumberOfTuples());
+    mcIdType nbOfComp=ToIdType(this->getNumberOfComponents());
+    mcIdType nbOfComp2=ToIdType(other->getNumberOfComponents());
+    if(nbOfTuple==nbOfTuple2)
+      {
+        if(nbOfComp==nbOfComp2)
+          {
+            std::transform(this->begin(),this->end(),other->begin(),this->getPointer(),std::modulus<T>());
+          }
+        else if(nbOfComp2==1)
+          {
+            if(nbOfComp2==nbOfComp)
+              {
+                T *ptr=this->getPointer();
+                const T *ptrc=other->getConstPointer();
+                for(mcIdType i=0;i<nbOfTuple;i++)
+                  std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptr+i*nbOfComp,std::bind2nd(std::modulus<T>(),*ptrc++));
+              }
+            else
+              throw INTERP_KERNEL::Exception(msg);
+          }
+        else
+          throw INTERP_KERNEL::Exception(msg);
+      }
+    else if(nbOfTuple2==1)
+      {
+        T *ptr=this->getPointer();
+        const T *ptrc=other->getConstPointer();
+        for(mcIdType i=0;i<nbOfTuple;i++)
+          std::transform(ptr+i*nbOfComp,ptr+(i+1)*nbOfComp,ptrc,ptr+i*nbOfComp,std::modulus<T>());
+      }
+    else
+      throw INTERP_KERNEL::Exception(msg);
+    this->declareAsNew();
+  }
+
+  /*!
+   * Apply pow on values of another DataArrayInt to values of \a this one.
+   *
+   *  \param [in] other - an array to pow to \a this one.
+   *  \throw If \a other is NULL.
+   *  \throw If \a this->getNumberOfTuples() != \a other->getNumberOfTuples()
+   *  \throw If \a this->getNumberOfComponents() != 1 or \a other->getNumberOfComponents() != 1
+   *  \throw If there is a negative value in \a other.
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::powEqual(const DataArrayType *other)
+  {
+    if(!other)
+      throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : input instance is null !");
+    std::size_t nbOfTuple=this->getNumberOfTuples();
+    std::size_t nbOfTuple2=other->getNumberOfTuples();
+    std::size_t nbOfComp=this->getNumberOfComponents();
+    std::size_t nbOfComp2=other->getNumberOfComponents();
+    if(nbOfTuple!=nbOfTuple2)
+      throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : number of tuples mismatches !");
+    if(nbOfComp!=1 || nbOfComp2!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::powEqual : number of components of both arrays must be equal to 1 !");
+    T *ptr=this->getPointer();
+    const T *ptrc=other->begin();
+    for(std::size_t i=0;i<nbOfTuple;i++,ptrc++,ptr++)
+      {
+        if(*ptrc>=0)
+          {
+            T tmp=1;
+            for(T j=0;j<*ptrc;j++)
+              tmp*=*ptr;
+            *ptr=tmp;
+          }
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::powEqual : on tuple #" << i << " of other value is < 0 (" << *ptrc << ") !";
+            throw INTERP_KERNEL::Exception(oss.str().c_str());
+          }
+      }
+    this->declareAsNew();
+  }
+
+  ////////////////////////////////////
+  /*!
+   * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
+   * Server side.
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::getTinySerializationIntInformation(std::vector<mcIdType>& tinyInfo) const
+  {
+    tinyInfo.resize(2);
+    if(this->isAllocated())
+      {
+        tinyInfo[0]=ToIdType(this->getNumberOfTuples());
+        tinyInfo[1]=ToIdType(this->getNumberOfComponents());
+      }
+    else
+      {
+        tinyInfo[0]=-1;
+        tinyInfo[1]=-1;
+      }
+  }
+
+  /*!
+   * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
+   * Server side.
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::getTinySerializationStrInformation(std::vector<std::string>& tinyInfo) const
+  {
+    if(this->isAllocated())
+      {
+        mcIdType nbOfCompo=ToIdType(this->getNumberOfComponents());
+        tinyInfo.resize(nbOfCompo+1);
+        tinyInfo[0]=this->getName();
+        for(mcIdType i=0;i<nbOfCompo;i++)
+          tinyInfo[i+1]=this->getInfoOnComponent(i);
+      }
+    else
+      {
+        tinyInfo.resize(1);
+        tinyInfo[0]=this->getName();
+      }
+  }
+
+  /*!
+   * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
+   * This method returns if a feeding is needed.
+   */
+  template <class T>
+  bool DataArrayDiscrete<T>::resizeForUnserialization(const std::vector<mcIdType>& tinyInfoI)
+  {
+    mcIdType nbOfTuple=tinyInfoI[0];
+    mcIdType nbOfComp=tinyInfoI[1];
+    if(nbOfTuple!=-1 || nbOfComp!=-1)
+      {
+        this->alloc(nbOfTuple,nbOfComp);
+        return true;
+      }
+    return false;
+  }
+
+  /*!
+   * Useless method for end user. Only for MPI/Corba/File serialsation for multi arrays class.
+   * This method returns if a feeding is needed.
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::finishUnserialization(const std::vector<mcIdType>& tinyInfoI, const std::vector<std::string>& tinyInfoS)
+  {
+    this->setName(tinyInfoS[0]);
+    if(this->isAllocated())
+      {
+        mcIdType nbOfCompo=tinyInfoI[1];
+        for(mcIdType i=0;i<nbOfCompo;i++)
+          this->setInfoOnComponent(i,tinyInfoS[i+1]);
+      }
+  }
+
+  ////////////////////////////////////
+
+  /*!
+   * Returns a new DataArrayInt that is the result of pow of two given arrays. There are 3
+   * valid cases.
+   *
+   *  \param [in] a1 - an array to pow up.
+   *  \param [in] a2 - another array to sum up.
+   *  \return DataArrayInt * - the new instance of DataArrayInt.
+   *          The caller is to delete this result array using decrRef() as it is no more
+   *          needed.
+   *  \throw If either \a a1 or \a a2 is NULL.
+   *  \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples()
+   *  \throw If \a a1->getNumberOfComponents() != 1 or \a a2->getNumberOfComponents() != 1.
+   *  \throw If there is a negative value in \a a2.
+   */
+  template <class T>
+  typename Traits<T>::ArrayType *DataArrayDiscrete<T>::Pow(const DataArrayType *a1, const DataArrayType *a2)
+  {
+    if(!a1 || !a2)
+      throw INTERP_KERNEL::Exception("DataArrayInt::Pow : at least one of input instances is null !");
+    std::size_t nbOfTuple=a1->getNumberOfTuples();
+    std::size_t nbOfTuple2=a2->getNumberOfTuples();
+    std::size_t nbOfComp=a1->getNumberOfComponents();
+    std::size_t nbOfComp2=a2->getNumberOfComponents();
+    if(nbOfTuple!=nbOfTuple2)
+      throw INTERP_KERNEL::Exception("DataArrayInt::Pow : number of tuples mismatches !");
+    if(nbOfComp!=1 || nbOfComp2!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::Pow : number of components of both arrays must be equal to 1 !");
+    MCAuto<DataArrayType> ret=DataArrayType::New(); ret->alloc(nbOfTuple,1);
+    const T *ptr1(a1->begin()),*ptr2(a2->begin());
+    T *ptr=ret->getPointer();
+    for(std::size_t i=0;i<nbOfTuple;i++,ptr1++,ptr2++,ptr++)
+      {
+        if(*ptr2>=0)
+          {
+            T tmp=1;
+            for(T j=0;j<*ptr2;j++)
+              tmp*=*ptr1;
+            *ptr=tmp;
+          }
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::Pow : on tuple #" << i << " of a2 value is < 0 (" << *ptr2 << ") !";
+            throw INTERP_KERNEL::Exception(oss.str().c_str());
+          }
+      }
+    return ret.retn();
+  }
+
+  /*!
+   * Returns a new DataArrayInt that is a modulus of two given arrays. There are 3
+   * valid cases.
+   * 1.  The arrays have same number of tuples and components. Then each value of
+   *   the result array (_a_) is a division of the corresponding values of \a a1 and
+   *   \a a2, i.e.: _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ i, j ].
+   * 2.  The arrays have same number of tuples and one array, say _a2_, has one
+   *   component. Then
+   *   _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ i, 0 ].
+   * 3.  The arrays have same number of components and one array, say _a2_, has one
+   *   tuple. Then
+   *   _a_ [ i, j ] = _a1_ [ i, j ] % _a2_ [ 0, j ].
+   *
+   * Info on components is copied either from the first array (in the first case) or from
+   * the array with maximal number of elements (getNbOfElems()).
+   *  \warning No check of division by zero is performed!
+   *  \param [in] a1 - a dividend array.
+   *  \param [in] a2 - a divisor array.
+   *  \return DataArrayInt * - the new instance of DataArrayInt.
+   *          The caller is to delete this result array using decrRef() as it is no more
+   *          needed.
+   *  \throw If either \a a1 or \a a2 is NULL.
+   *  \throw If \a a1->getNumberOfTuples() != \a a2->getNumberOfTuples() and
+   *         \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents() and
+   *         none of them has number of tuples or components equal to 1.
+   */
+  template <class T>
+  typename Traits<T>::ArrayType *DataArrayDiscrete<T>::Modulus(const DataArrayType *a1, const DataArrayType *a2)
+  {
+    if(!a1 || !a2)
+      throw INTERP_KERNEL::Exception("DataArrayInt::Modulus : input DataArrayInt instance is NULL !");
+    mcIdType nbOfTuple1=ToIdType(a1->getNumberOfTuples());
+    mcIdType nbOfTuple2=ToIdType(a2->getNumberOfTuples());
+    mcIdType nbOfComp1=ToIdType(a1->getNumberOfComponents());
+    mcIdType nbOfComp2=ToIdType(a2->getNumberOfComponents());
+    if(nbOfTuple2==nbOfTuple1)
+      {
+        if(nbOfComp1==nbOfComp2)
+          {
+            MCAuto<DataArrayType> ret=DataArrayType::New();
+            ret->alloc(nbOfTuple2,nbOfComp1);
+            std::transform(a1->begin(),a1->end(),a2->begin(),ret->getPointer(),std::modulus<T>());
+            ret->copyStringInfoFrom(*a1);
+            return ret.retn();
+          }
+        else if(nbOfComp2==1)
+          {
+            MCAuto<DataArrayType> ret=DataArrayType::New();
+            ret->alloc(nbOfTuple1,nbOfComp1);
+            const T *a2Ptr=a2->getConstPointer();
+            const T *a1Ptr=a1->getConstPointer();
+            T *res=ret->getPointer();
+            for(mcIdType i=0;i<nbOfTuple1;i++)
+              res=std::transform(a1Ptr+i*nbOfComp1,a1Ptr+(i+1)*nbOfComp1,res,std::bind2nd(std::modulus<T>(),a2Ptr[i]));
+            ret->copyStringInfoFrom(*a1);
+            return ret.retn();
+          }
+        else
+          {
+            a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Modulus !");
+            return 0;
+          }
+      }
+    else if(nbOfTuple2==1)
+      {
+        a1->checkNbOfComps(nbOfComp2,"Nb of components mismatch for array Modulus !");
+        MCAuto<DataArrayType> ret=DataArrayType::New();
+        ret->alloc(nbOfTuple1,nbOfComp1);
+        const T *a1ptr=a1->getConstPointer(),*a2ptr=a2->getConstPointer();
+        T *pt=ret->getPointer();
+        for(mcIdType i=0;i<nbOfTuple1;i++)
+          pt=std::transform(a1ptr+i*nbOfComp1,a1ptr+(i+1)*nbOfComp1,a2ptr,pt,std::modulus<T>());
+        ret->copyStringInfoFrom(*a1);
+        return ret.retn();
+      }
+    else
+      {
+        a1->checkNbOfTuples(nbOfTuple2,"Nb of tuples mismatch for array Modulus !");//will always throw an exception
+        return 0;
+      }
+  }
+
+  /*!
+   * This method tries to find the permutation to apply to the first input \a ids1 to obtain the same array (without considering strings information) the second
+   * input array \a ids2.
+   * \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.
+   * 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
+   * inversely.
+   * In case of success both assertion will be true (no throw) :
+   * \c ids1->renumber(ret)->isEqual(ids2) where \a ret is the return of this method.
+   * \c ret->transformWithIndArr(ids2)->isEqual(ids1)
+   *
+   * \b Example:
+   * - \a ids1 : [3,1,103,4,6,10,-7,205]
+   * - \a ids2 : [-7,1,205,10,6,3,103,4]
+   * - \a return is : [5,1,6,7,4,3,0,2] because ids2[5]==ids1[0], ids2[1]==ids1[1], ids2[6]==ids1[2]...
+   *
+   * \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
+   *          array using decrRef() as it is no more needed.
+   * \throw If either ids1 or ids2 is null not allocated or not with one components.
+   *
+   * \sa DataArrayInt::findIdForEach
+   */
+  template<class T>
+  DataArrayIdType *DataArrayDiscrete<T>::FindPermutationFromFirstToSecond(const DataArrayType *ids1, const DataArrayType *ids2)
+  {
+    if(!ids1 || !ids2)
+      throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays must be not null !");
+    if(!ids1->isAllocated() || !ids2->isAllocated())
+      throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays must be allocated !");
+    if(ids1->getNumberOfComponents()!=1 || ids2->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two input arrays have exactly one component !");
+    if(ids1->getNumberOfTuples()!=ids2->getNumberOfTuples())
+      {
+        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 !";
+        throw INTERP_KERNEL::Exception(oss.str().c_str());
+      }
+    MCAuto<DataArrayType> c1(ids1->deepCopy());
+    MCAuto<DataArrayType> c2(ids2->deepCopy());
+    c1->sort(true); c2->sort(true);
+    if(!c1->isEqualWithoutConsideringStr(*c2))
+      throw INTERP_KERNEL::Exception("DataArrayInt::FindPermutationFromFirstToSecond : the two arrays are not lying on same ids ! Impossible to find a permutation between the 2 arrays !");
+    MCAuto<DataArrayIdType> p1=ids1->checkAndPreparePermutation();
+    MCAuto<DataArrayIdType> p2=ids2->checkAndPreparePermutation();
+    p2=p2->invertArrayO2N2N2O(ToIdType(p2->getNumberOfTuples()));
+    p2=p2->selectByTupleIdSafe(p1->begin(),p1->end());
+    return p2.retn();
+  }
+
+  /*!
+   * Returns a C array which is a renumbering map in "Old to New" mode for the input array.
+   * This map, if applied to \a start array, would make it sorted. For example, if
+   * \a start array contents are [9,10,0,6,4,11,3,7] then the contents of the result array is
+   * [5,6,0,3,2,7,1,4].
+   *  \param [in] start - pointer to the first element of the array for which the
+   *         permutation map is computed.
+   *  \param [in] end - pointer specifying the end of the array \a start, so that
+   *         the last value of \a start is \a end[ -1 ].
+   *  \return int * - the result permutation array that the caller is to delete as it is no
+   *         more needed.
+   *  \throw If there are equal values in the input array.
+   */
+  template<class T>
+  mcIdType *DataArrayDiscrete<T>::CheckAndPreparePermutation(const T *start, const T *end)
+  {
+    std::size_t sz=std::distance(start,end);
+    mcIdType *ret=(mcIdType *)malloc(sz*sizeof(mcIdType));
+    T *work=new T[sz];
+    std::copy(start,end,work);
+    std::sort(work,work+sz);
+    if(std::unique(work,work+sz)!=work+sz)
+      {
+        delete [] work;
+        free(ret);
+        throw INTERP_KERNEL::Exception("Some elements are equals in the specified array !");
+      }
+    std::map<T,mcIdType> m;
+    for(T *workPt=work;workPt!=work+sz;workPt++)
+      m[*workPt]=ToIdType(std::distance(work,workPt));
+    mcIdType *iter2=ret;
+    for(const T *iter=start;iter!=end;iter++,iter2++)
+      *iter2=m[*iter];
+    delete [] work;
+    return ret;
+  }
+
+  /*!
+   * Returns a new DataArrayInt by concatenating two given arrays, so that (1) the number
+   * of tuples in the result array is <em> a1->getNumberOfTuples() + a2->getNumberOfTuples() -
+   * offsetA2</em> and (2)
+   * the number of component in the result array is same as that of each of given arrays.
+   * First \a offsetA2 tuples of \a a2 are skipped and thus are missing from the result array.
+   * Info on components is copied from the first of the given arrays. Number of components
+   * in the given arrays must be the same.
+   *  \param [in] a1 - an array to include in the result array.
+   *  \param [in] a2 - another array to include in the result array.
+   *  \param [in] offsetA2 - number of tuples of \a a2 to skip.
+   *  \return DataArrayInt * - the new instance of DataArrayInt.
+   *          The caller is to delete this result array using decrRef() as it is no more
+   *          needed.
+   *  \throw If either \a a1 or \a a2 is NULL.
+   *  \throw If \a a1->getNumberOfComponents() != \a a2->getNumberOfComponents().
+   */
+  template <class T>
+  typename Traits<T>::ArrayType *DataArrayDiscrete<T>::Aggregate(const DataArrayType *a1, const DataArrayType *a2, T offsetA2)
+  {
+    if(!a1 || !a2)
+      throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : input DataArrayInt instance is NULL !");
+    std::size_t nbOfComp(a1->getNumberOfComponents());
+    if(nbOfComp!=a2->getNumberOfComponents())
+      throw INTERP_KERNEL::Exception("Nb of components mismatch for array Aggregation !");
+    std::size_t nbOfTuple1(a1->getNumberOfTuples()),nbOfTuple2(a2->getNumberOfTuples());
+    MCAuto<DataArrayType> ret(DataArrayType::New());
+    ret->alloc(nbOfTuple1+nbOfTuple2-offsetA2,nbOfComp);
+    T *pt=std::copy(a1->begin(),a1->end(),ret->getPointer());
+    std::copy(a2->getConstPointer()+offsetA2*nbOfComp,a2->getConstPointer()+nbOfTuple2*nbOfComp,pt);
+    ret->copyStringInfoFrom(*a1);
+    return ret.retn();
+  }
+
+  /*!
+   * Returns a new DataArrayInt by concatenating all given arrays, so that (1) the number
+   * of tuples in the result array is a sum of the number of tuples of given arrays and (2)
+   * the number of component in the result array is same as that of each of given arrays.
+   * Info on components is copied from the first of the given arrays. Number of components
+   * in the given arrays must be  the same.
+   * If the number of non null of elements in \a arr is equal to one the returned object is a copy of it
+   * not the object itself.
+   *  \param [in] arr - a sequence of arrays to include in the result array.
+   *  \return DataArrayInt * - the new instance of DataArrayInt.
+   *          The caller is to delete this result array using decrRef() as it is no more
+   *          needed.
+   *  \throw If all arrays within \a arr are NULL.
+   *  \throw If getNumberOfComponents() of arrays within \a arr.
+   */
+  template <class T>
+  typename Traits<T>::ArrayType *DataArrayDiscrete<T>::Aggregate(const std::vector<const DataArrayType *>& arr)
+  {
+    std::vector<const DataArrayType *> a;
+    for(typename std::vector<const DataArrayType *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
+      if(*it4)
+        a.push_back(*it4);
+    if(a.empty())
+      throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : input list must be NON EMPTY !");
+    typename std::vector<const DataArrayType *>::const_iterator it=a.begin();
+    std::size_t nbOfComp((*it)->getNumberOfComponents()),nbt((*it++)->getNumberOfTuples());
+    for(;it!=a.end();it++)
+      {
+        if((*it)->getNumberOfComponents()!=nbOfComp)
+          throw INTERP_KERNEL::Exception("DataArrayInt::Aggregate : Nb of components mismatch for array aggregation !");
+        nbt+=(*it)->getNumberOfTuples();
+      }
+    MCAuto<DataArrayType> ret=DataArrayType::New();
+    ret->alloc(nbt,nbOfComp);
+    T *pt=ret->getPointer();
+    for(it=a.begin();it!=a.end();it++)
+      pt=std::copy((*it)->getConstPointer(),(*it)->getConstPointer()+(*it)->getNbOfElems(),pt);
+    ret->copyStringInfoFrom(*(a[0]));
+    return ret.retn();
+  }
+
+  /*!
+   * This method takes as input a list of DataArrayInt instances \a arrs that represent each a packed index arrays.
+   * A packed index array is an allocated array with one component, and at least one tuple. The first element
+   * of each array in \a arrs must be 0. Each array in \a arrs is expected to be increasingly monotonic.
+   * 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.
+   *
+   * \return DataArrayInt * - a new object to be managed by the caller.
+   */
+  template <class T>
+  typename Traits<T>::ArrayType *DataArrayDiscrete<T>::AggregateIndexes(const std::vector<const DataArrayType *>& arrs)
+  {
+    mcIdType retSz=1;
+    for(typename std::vector<const DataArrayType *>::const_iterator it4=arrs.begin();it4!=arrs.end();it4++)
+      {
+        if(*it4)
+          {
+            (*it4)->checkAllocated();
+            if((*it4)->getNumberOfComponents()!=1)
+              {
+                std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with nb of compo != 1 at pos " << std::distance(arrs.begin(),it4) << " !";
+                throw INTERP_KERNEL::Exception(oss.str().c_str());
+              }
+            mcIdType nbTupl=ToIdType((*it4)->getNumberOfTuples());
+            if(nbTupl<1)
+              {
+                std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with nb of tuples < 1 at pos " << std::distance(arrs.begin(),it4) << " !";
+                throw INTERP_KERNEL::Exception(oss.str().c_str());
+              }
+            if((*it4)->front()!=0)
+              {
+                std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a DataArrayInt instance with front value != 0 at pos " << std::distance(arrs.begin(),it4) << " !";
+                throw INTERP_KERNEL::Exception(oss.str().c_str());
+              }
+            retSz+=nbTupl-1;
+          }
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::AggregateIndexes : presence of a null instance at pos " << std::distance(arrs.begin(),it4) << " !";
+            throw INTERP_KERNEL::Exception(oss.str().c_str());
+          }
+      }
+    if(arrs.empty())
+      throw INTERP_KERNEL::Exception("DataArrayInt::AggregateIndexes : input list must be NON EMPTY !");
+    MCAuto<DataArrayType> ret=DataArrayType::New();
+    ret->alloc(retSz,1);
+    T *pt=ret->getPointer(); *pt++=0;
+    for(typename std::vector<const DataArrayType *>::const_iterator it=arrs.begin();it!=arrs.end();it++)
+      pt=std::transform((*it)->begin()+1,(*it)->end(),pt,std::bind2nd(std::plus<T>(),pt[-1]));
+    ret->copyStringInfoFrom(*(arrs[0]));
+    return ret.retn();
+  }
+
+  /*!
+   * Returns a new DataArrayInt which contains all elements of given one-dimensional
+   * arrays. The result array does not contain any duplicates and its values
+   * are sorted in ascending order.
+   *  \param [in] arr - sequence of DataArrayInt's to unite.
+   *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
+   *         array using decrRef() as it is no more needed.
+   *  \throw If any \a arr[i] is not allocated.
+   *  \throw If \a arr[i]->getNumberOfComponents() != 1.
+   */
+  template <class T>
+  typename Traits<T>::ArrayType *DataArrayDiscrete<T>::BuildUnion(const std::vector<const DataArrayType *>& arr)
+  {
+    std::vector<const DataArrayType *> a;
+    for(typename std::vector<const DataArrayType *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
+      if(*it4)
+        a.push_back(*it4);
+    for(typename std::vector<const DataArrayType *>::const_iterator it=a.begin();it!=a.end();it++)
+      {
+        (*it)->checkAllocated();
+        if((*it)->getNumberOfComponents()!=1)
+          throw INTERP_KERNEL::Exception("DataArrayInt::BuildUnion : only single component allowed !");
+      }
+    //
+    std::set<T> r;
+    for(typename std::vector<const DataArrayType *>::const_iterator it=a.begin();it!=a.end();it++)
+      {
+        const T *pt=(*it)->getConstPointer();
+        mcIdType nbOfTuples=ToIdType((*it)->getNumberOfTuples());
+        r.insert(pt,pt+nbOfTuples);
+      }
+    DataArrayType *ret=DataArrayType::New();
+    ret->alloc(r.size(),1);
+    std::copy(r.begin(),r.end(),ret->getPointer());
+    return ret;
+  }
+
+  /*!
+   * Returns a new DataArrayInt which contains elements present in each of given one-dimensional
+   * arrays. The result array does not contain any duplicates and its values
+   * are sorted in ascending order.
+   *  \param [in] arr - sequence of DataArrayInt's to intersect.
+   *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
+   *         array using decrRef() as it is no more needed.
+   *  \throw If any \a arr[i] is not allocated.
+   *  \throw If \a arr[i]->getNumberOfComponents() != 1.
+   */
+  template <class T>
+  typename Traits<T>::ArrayType *DataArrayDiscrete<T>::BuildIntersection(const std::vector<const DataArrayType *>& arr)
+  {
+    std::vector<const DataArrayType *> a;
+    for(typename std::vector<const DataArrayType *>::const_iterator it4=arr.begin();it4!=arr.end();it4++)
+      if(*it4)
+        a.push_back(*it4);
+    for(typename std::vector<const DataArrayType *>::const_iterator it=a.begin();it!=a.end();it++)
+      {
+        (*it)->checkAllocated();
+        if((*it)->getNumberOfComponents()!=1)
+          throw INTERP_KERNEL::Exception("DataArrayInt::BuildIntersection : only single component allowed !");
+      }
+    //
+    std::set<T> r;
+    for(typename std::vector<const DataArrayType *>::const_iterator it=a.begin();it!=a.end();it++)
+      {
+        const T *pt=(*it)->getConstPointer();
+        mcIdType nbOfTuples=ToIdType((*it)->getNumberOfTuples());
+        std::set<T> s1(pt,pt+nbOfTuples);
+        if(it!=a.begin())
+          {
+            std::set<T> r2;
+            std::set_intersection(r.begin(),r.end(),s1.begin(),s1.end(),inserter(r2,r2.end()));
+            r=r2;
+          }
+        else
+          r=s1;
+      }
+    DataArrayType *ret(DataArrayType::New());
+    ret->alloc(r.size(),1);
+    std::copy(r.begin(),r.end(),ret->getPointer());
+    return ret;
+  }
+
+  /*!
+   * This method allows to put a vector of vector of integer into a more compact data structure (skyline).
+   * This method is not available into python because no available optimized data structure available to map std::vector< std::vector<int> >.
+   *
+   * \param [in] v the input data structure to be translate into skyline format.
+   * \param [out] data the first element of the skyline format. The user is expected to deal with newly allocated array.
+   * \param [out] dataIndex the second element of the skyline format.
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::PutIntoToSkylineFrmt(const std::vector< std::vector<T> >& v, DataArrayType *& data, DataArrayIdType *& dataIndex)
+  {
+    std::size_t sz(v.size());
+    MCAuto<DataArrayType> retDat(DataArrayType::New());
+    MCAuto<DataArrayIdType> retIdx(DataArrayIdType::New());
+    retIdx->alloc(sz+1,1);
+    mcIdType *ptid(retIdx->getPointer()); *ptid=0;
+    for(std::size_t i=0;i<sz;i++,ptid++)
+      ptid[1]=ptid[0]+ToIdType(v[i].size());
+    retDat->alloc(retIdx->back(),1);
+    T *pt=retDat->getPointer();
+    for(std::size_t i=0;i<sz;i++)
+      pt=std::copy(v[i].begin(),v[i].end(),pt);
+    data=retDat.retn(); dataIndex=retIdx.retn();
+  }
+
+  /*!
+   * This method works on a pair input (\b arrIn, \b arrIndxIn) where \b arrIn indexes is in \b arrIndxIn
+   * (\ref numbering-indirect).
+   * This method returns the result of the extraction ( specified by a set of ids in [\b idsOfSelectBg , \b idsOfSelectEnd ) ).
+   * The selection of extraction is done standardly in new2old format.
+   * This method returns indexed arrays (\ref numbering-indirect) using 2 arrays (arrOut,arrIndexOut).
+   *
+   * \param [in] idsOfSelectBg begin of set of ids of the input extraction (included)
+   * \param [in] idsOfSelectEnd end of set of ids of the input extraction (excluded)
+   * \param [in] arrIn arr origin array from which the extraction will be done.
+   * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
+   * \param [out] arrOut the resulting array
+   * \param [out] arrIndexOut the index array of the resulting array \b arrOut
+   * \sa DataArrayInt::ExtractFromIndexedArraysSlice
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::ExtractFromIndexedArrays(const mcIdType *idsOfSelectBg, const mcIdType *idsOfSelectEnd,
+                                                      const DataArrayType *arrIn, const DataArrayIdType *arrIndxIn,
+                                                      DataArrayType* &arrOut, DataArrayIdType* &arrIndexOut)
+  {
+    if(!arrIn || !arrIndxIn)
+      throw INTERP_KERNEL::Exception("DataArrayInt::ExtractFromIndexedArrays : input pointer is NULL !");
+    arrIn->checkAllocated(); arrIndxIn->checkAllocated();
+    if(arrIn->getNumberOfComponents()!=1 || arrIndxIn->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::ExtractFromIndexedArrays : input arrays must have exactly one component !");
+    std::size_t sz=std::distance(idsOfSelectBg,idsOfSelectEnd);
+    const T *arrInPtr=arrIn->begin();
+    const mcIdType *arrIndxPtr=arrIndxIn->begin();
+    mcIdType nbOfGrps=ToIdType(arrIndxIn->getNumberOfTuples())-1;
+    if(nbOfGrps<0)
+      throw INTERP_KERNEL::Exception("DataArrayInt::ExtractFromIndexedArrays : The format of \"arrIndxIn\" is invalid ! Its nb of tuples should be >=1 !");
+    mcIdType maxSizeOfArr=ToIdType(arrIn->getNumberOfTuples());
+    MCAuto<DataArrayType> arro=DataArrayType::New();
+    MCAuto<DataArrayIdType> arrIo=DataArrayIdType::New();
+    arrIo->alloc(sz+1,1);
+    const mcIdType *idsIt=idsOfSelectBg;
+    mcIdType *work=arrIo->getPointer();
+    *work++=0;
+    mcIdType lgth=0;
+    for(std::size_t i=0;i<sz;i++,work++,idsIt++)
+      {
+        if(*idsIt>=0 && *idsIt<nbOfGrps)
+          lgth+=arrIndxPtr[*idsIt+1]-arrIndxPtr[*idsIt];
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::ExtractFromIndexedArrays : id located on pos #" << i << " value is " << *idsIt << " ! Must be in [0," << nbOfGrps << ") !";
+            throw INTERP_KERNEL::Exception(oss.str());
+          }
+        if(lgth>=work[-1])
+          *work=lgth;
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::ExtractFromIndexedArrays : id located on pos #" << i << " value is " << *idsIt << " and at this pos arrIndxIn[" << *idsIt;
+            oss << "+1]-arrIndxIn[" << *idsIt << "] < 0 ! The input index array is bugged !";
+            throw INTERP_KERNEL::Exception(oss.str());
+          }
+      }
+    arro->alloc(lgth,1);
+    T *data=arro->getPointer();
+    idsIt=idsOfSelectBg;
+    for(std::size_t i=0;i<sz;i++,idsIt++)
+      {
+        if(arrIndxPtr[*idsIt]>=0 && arrIndxPtr[*idsIt+1]<=maxSizeOfArr)
+          data=std::copy(arrInPtr+arrIndxPtr[*idsIt],arrInPtr+arrIndxPtr[*idsIt+1],data);
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::ExtractFromIndexedArrays : id located on pos #" << i << " value is " << *idsIt << " arrIndx[" << *idsIt << "] must be >= 0 and arrIndx[";
+            oss << *idsIt << "+1] <= " << maxSizeOfArr << " (the size of arrIn)!";
+            throw INTERP_KERNEL::Exception(oss.str());
+          }
+      }
+    arrOut=arro.retn();
+    arrIndexOut=arrIo.retn();
+  }
+
+  /*!
+   * This method works on a pair input (\b arrIn, \b arrIndxIn) where \b arrIn indexes is in \b arrIndxIn
+   * (\ref numbering-indirect).
+   * This method returns the result of the extraction ( specified by a set of ids with a slice given by \a idsOfSelectStart, \a idsOfSelectStop and \a idsOfSelectStep ).
+   * The selection of extraction is done standardly in new2old format.
+   * This method returns indexed arrays (\ref numbering-indirect) using 2 arrays (arrOut,arrIndexOut).
+   *
+   * \param [in] idsOfSelectStart begin of set of ids of the input extraction (included)
+   * \param [in] idsOfSelectStop end of set of ids of the input extraction (excluded)
+   * \param [in] idsOfSelectStep
+   * \param [in] arrIn arr origin array from which the extraction will be done.
+   * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
+   * \param [out] arrOut the resulting array
+   * \param [out] arrIndexOut the index array of the resulting array \b arrOut
+   * \sa DataArrayInt::ExtractFromIndexedArrays
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::ExtractFromIndexedArraysSlice(mcIdType idsOfSelectStart, mcIdType idsOfSelectStop, mcIdType idsOfSelectStep,
+                                                           const DataArrayType *arrIn, const DataArrayIdType *arrIndxIn,
+                                                           DataArrayType* &arrOut, DataArrayIdType* &arrIndexOut)
+  {
+    if(!arrIn || !arrIndxIn)
+      throw INTERP_KERNEL::Exception("DataArrayInt::ExtractFromIndexedArraysSlice : input pointer is NULL !");
+    arrIn->checkAllocated(); arrIndxIn->checkAllocated();
+    if(arrIn->getNumberOfComponents()!=1 || arrIndxIn->getNumberOfComponents()!=1)
+      throw INTERP_KERNEL::Exception("DataArrayInt::ExtractFromIndexedArraysSlice : input arrays must have exactly one component !");
+    mcIdType sz=DataArray::GetNumberOfItemGivenBESRelative(idsOfSelectStart,idsOfSelectStop,idsOfSelectStep,"MEDCouplingUMesh::ExtractFromIndexedArraysSlice : Input slice ");
+    const T *arrInPtr=arrIn->begin();
+    const mcIdType *arrIndxPtr=arrIndxIn->begin();
+    mcIdType nbOfGrps=ToIdType(arrIndxIn->getNumberOfTuples())-1;
+    if(nbOfGrps<0)
+      throw INTERP_KERNEL::Exception("DataArrayInt::ExtractFromIndexedArraysSlice : The format of \"arrIndxIn\" is invalid ! Its nb of tuples should be >=1 !");
+    mcIdType maxSizeOfArr=ToIdType(arrIn->getNumberOfTuples());
+    MCAuto<DataArrayType> arro=DataArrayType::New();
+    MCAuto<DataArrayIdType> arrIo=DataArrayIdType::New();
+    arrIo->alloc(sz+1,1);
+    mcIdType idsIt=idsOfSelectStart;
+    mcIdType *work=arrIo->getPointer();
+    *work++=0;
+    mcIdType lgth=0;
+    for(mcIdType i=0;i<sz;i++,work++,idsIt+=idsOfSelectStep)
+      {
+        if(idsIt>=0 && idsIt<nbOfGrps)
+          lgth+=arrIndxPtr[idsIt+1]-arrIndxPtr[idsIt];
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::ExtractFromIndexedArraysSlice : id located on pos #" << i << " value is " << idsIt << " ! Must be in [0," << nbOfGrps << ") !";
+            throw INTERP_KERNEL::Exception(oss.str());
+          }
+        if(lgth>=work[-1])
+          *work=lgth;
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::ExtractFromIndexedArraysSlice : id located on pos #" << i << " value is " << idsIt << " and at this pos arrIndxIn[" << idsIt;
+            oss << "+1]-arrIndxIn[" << idsIt << "] < 0 ! The input index array is bugged !";
+            throw INTERP_KERNEL::Exception(oss.str());
+          }
+      }
+    arro->alloc(lgth,1);
+    T *data=arro->getPointer();
+    idsIt=idsOfSelectStart;
+    for(mcIdType i=0;i<sz;i++,idsIt+=idsOfSelectStep)
+      {
+        if(arrIndxPtr[idsIt]>=0 && arrIndxPtr[idsIt+1]<=maxSizeOfArr)
+          data=std::copy(arrInPtr+arrIndxPtr[idsIt],arrInPtr+arrIndxPtr[idsIt+1],data);
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::ExtractFromIndexedArraysSlice : id located on pos #" << i << " value is " << idsIt << " arrIndx[" << idsIt << "] must be >= 0 and arrIndx[";
+            oss << idsIt << "+1] <= " << maxSizeOfArr << " (the size of arrIn)!";
+            throw INTERP_KERNEL::Exception(oss.str());
+          }
+      }
+    arrOut=arro.retn();
+    arrIndexOut=arrIo.retn();
+  }
+
+  /*!
+   * This method works on an input pair (\b arrIn, \b arrIndxIn) where \b arrIn indexes is in \b arrIndxIn.
+   * This method builds an output pair (\b arrOut,\b arrIndexOut) that is a copy from \b arrIn for all cell ids \b not \b in [ \b idsOfSelectBg , \b idsOfSelectEnd ) and for
+   * cellIds \b in [ \b idsOfSelectBg , \b idsOfSelectEnd ) a copy coming from the corresponding values in input pair (\b srcArr, \b srcArrIndex).
+   * This method is an generalization of MEDCouplingUMesh::SetPartOfIndexedArraysSameIdx that performs the same thing but by without building explicitly a result output arrays.
+   *
+   * \param [in] idsOfSelectBg begin of set of ids of the input extraction (included)
+   * \param [in] idsOfSelectEnd end of set of ids of the input extraction (excluded)
+   * \param [in] arrIn arr origin array from which the extraction will be done.
+   * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
+   * \param [in] srcArr input array that will be used as source of copy for ids in [ \b idsOfSelectBg, \b idsOfSelectEnd )
+   * \param [in] srcArrIndex index array of \b srcArr
+   * \param [out] arrOut the resulting array
+   * \param [out] arrIndexOut the index array of the resulting array \b arrOut
+   *
+   * \sa DataArrayInt::SetPartOfIndexedArraysSameIdx
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::SetPartOfIndexedArrays(const mcIdType *idsOfSelectBg, const mcIdType *idsOfSelectEnd,
+                                                    const DataArrayType *arrIn, const DataArrayIdType *arrIndxIn,
+                                                    const DataArrayType *srcArr, const DataArrayIdType *srcArrIndex,
+                                                    DataArrayType* &arrOut, DataArrayIdType* &arrIndexOut)
+  {
+    if(arrIn==0 || arrIndxIn==0 || srcArr==0 || srcArrIndex==0)
+      throw INTERP_KERNEL::Exception("DataArrayInt::SetPartOfIndexedArrays : presence of null pointer in input parameter !");
+    MCAuto<DataArrayType> arro=DataArrayType::New();
+    MCAuto<DataArrayIdType> arrIo=DataArrayIdType::New();
+    mcIdType nbOfTuples=ToIdType(arrIndxIn->getNumberOfTuples())-1;
+    std::vector<bool> v(nbOfTuples,true);
+    mcIdType offset=0;
+    const mcIdType *arrIndxInPtr=arrIndxIn->begin();
+    const mcIdType *srcArrIndexPtr=srcArrIndex->begin();
+    for(const mcIdType *it=idsOfSelectBg;it!=idsOfSelectEnd;it++,srcArrIndexPtr++)
+      {
+        if(*it>=0 && *it<nbOfTuples)
+          {
+            v[*it]=false;
+            offset+=(srcArrIndexPtr[1]-srcArrIndexPtr[0])-(arrIndxInPtr[*it+1]-arrIndxInPtr[*it]);
+          }
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::SetPartOfIndexedArrays : On pos #" << std::distance(idsOfSelectBg,it) << " value is " << *it << " not in [0," << nbOfTuples << ") !";
+            throw INTERP_KERNEL::Exception(oss.str());
+          }
+      }
+    srcArrIndexPtr=srcArrIndex->begin();
+    arrIo->alloc(nbOfTuples+1,1);
+    arro->alloc(arrIn->getNumberOfTuples()+offset,1);
+    const T *arrInPtr=arrIn->begin();
+    const T *srcArrPtr=srcArr->begin();
+    mcIdType *arrIoPtr=arrIo->getPointer(); *arrIoPtr++=0;
+    T *arroPtr=arro->getPointer();
+    for(mcIdType ii=0;ii<nbOfTuples;ii++,arrIoPtr++)
+      {
+        if(v[ii])
+          {
+            arroPtr=std::copy(arrInPtr+arrIndxInPtr[ii],arrInPtr+arrIndxInPtr[ii+1],arroPtr);
+            *arrIoPtr=arrIoPtr[-1]+(arrIndxInPtr[ii+1]-arrIndxInPtr[ii]);
+          }
+        else
+          {
+            std::size_t pos=std::distance(idsOfSelectBg,std::find(idsOfSelectBg,idsOfSelectEnd,ii));
+            arroPtr=std::copy(srcArrPtr+srcArrIndexPtr[pos],srcArrPtr+srcArrIndexPtr[pos+1],arroPtr);
+            *arrIoPtr=arrIoPtr[-1]+(srcArrIndexPtr[pos+1]-srcArrIndexPtr[pos]);
+          }
+      }
+    arrOut=arro.retn();
+    arrIndexOut=arrIo.retn();
+  }
+
+  /*!
+   * This method works on an input pair (\b arrIn, \b arrIndxIn) where \b arrIn indexes is in \b arrIndxIn.
+   * This method builds an output pair (\b arrOut,\b arrIndexOut) that is a copy from \b arrIn for all cell ids \b not \b in [ \b idsOfSelectBg , \b idsOfSelectEnd ) and for
+   * cellIds \b in [\b idsOfSelectBg, \b idsOfSelectEnd) a copy coming from the corresponding values in input pair (\b srcArr, \b srcArrIndex).
+   * This method is an generalization of DataArrayInt::SetPartOfIndexedArraysSameIdx that performs the same thing but by without building explicitly a result output arrays.
+   *
+   * \param [in] start begin of set of ids of the input extraction (included)
+   * \param [in] end end of set of ids of the input extraction (excluded)
+   * \param [in] step step of the set of ids in range mode.
+   * \param [in] arrIn arr origin array from which the extraction will be done.
+   * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
+   * \param [in] srcArr input array that will be used as source of copy for ids in [\b idsOfSelectBg, \b idsOfSelectEnd)
+   * \param [in] srcArrIndex index array of \b srcArr
+   * \param [out] arrOut the resulting array
+   * \param [out] arrIndexOut the index array of the resulting array \b arrOut
+   *
+   * \sa DataArrayInt::SetPartOfIndexedArraysSameIdx DataArrayInt::SetPartOfIndexedArrays
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::SetPartOfIndexedArraysSlice(mcIdType start, mcIdType end, mcIdType step,
+                                                         const DataArrayType *arrIn, const DataArrayIdType *arrIndxIn,
+                                                         const DataArrayType *srcArr, const DataArrayIdType *srcArrIndex,
+                                                         DataArrayType* &arrOut, DataArrayIdType* &arrIndexOut)
+  {
+    if(arrIn==0 || arrIndxIn==0 || srcArr==0 || srcArrIndex==0)
+      throw INTERP_KERNEL::Exception("DataArrayInt::SetPartOfIndexedArraysSlice : presence of null pointer in input parameter !");
+    MCAuto<DataArrayType> arro=DataArrayType::New();
+    MCAuto<DataArrayIdType> arrIo=DataArrayIdType::New();
+    mcIdType nbOfTuples=ToIdType(arrIndxIn->getNumberOfTuples())-1;
+    mcIdType offset=0;
+    const mcIdType *arrIndxInPtr=arrIndxIn->begin();
+    const mcIdType *srcArrIndexPtr=srcArrIndex->begin();
+    mcIdType nbOfElemsToSet=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"DataArrayInt::SetPartOfIndexedArraysSlice : ");
+    mcIdType it=start;
+    for(mcIdType i=0;i<nbOfElemsToSet;i++,srcArrIndexPtr++,it+=step)
+      {
+        if(it>=0 && it<nbOfTuples)
+          offset+=(srcArrIndexPtr[1]-srcArrIndexPtr[0])-(arrIndxInPtr[it+1]-arrIndxInPtr[it]);
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::SetPartOfIndexedArraysSlice : On pos #" << i << " value is " << it << " not in [0," << nbOfTuples << ") !";
+            throw INTERP_KERNEL::Exception(oss.str());
+          }
+      }
+    srcArrIndexPtr=srcArrIndex->begin();
+    arrIo->alloc(nbOfTuples+1,1);
+    arro->alloc(arrIn->getNumberOfTuples()+offset,1);
+    const T *arrInPtr=arrIn->begin();
+    const T *srcArrPtr=srcArr->begin();
+    mcIdType *arrIoPtr=arrIo->getPointer(); *arrIoPtr++=0;
+    T *arroPtr=arro->getPointer();
+    for(mcIdType ii=0;ii<nbOfTuples;ii++,arrIoPtr++)
+      {
+        mcIdType pos=DataArray::GetPosOfItemGivenBESRelativeNoThrow(ii,start,end,step);
+        if(pos<0)
+          {
+            arroPtr=std::copy(arrInPtr+arrIndxInPtr[ii],arrInPtr+arrIndxInPtr[ii+1],arroPtr);
+            *arrIoPtr=arrIoPtr[-1]+(arrIndxInPtr[ii+1]-arrIndxInPtr[ii]);
+          }
+        else
+          {
+            arroPtr=std::copy(srcArrPtr+srcArrIndexPtr[pos],srcArrPtr+srcArrIndexPtr[pos+1],arroPtr);
+            *arrIoPtr=arrIoPtr[-1]+(srcArrIndexPtr[pos+1]-srcArrIndexPtr[pos]);
+          }
+      }
+    arrOut=arro.retn();
+    arrIndexOut=arrIo.retn();
+  }
+
+  /*!
+   * This method works on an input pair (\b arrIn, \b arrIndxIn) where \b arrIn indexes is in \b arrIndxIn.
+   * This method is an specialization of MEDCouplingUMesh::SetPartOfIndexedArrays in the case of assignment do not modify the index in \b arrIndxIn.
+   *
+   * \param [in] idsOfSelectBg begin of set of ids of the input extraction (included)
+   * \param [in] idsOfSelectEnd end of set of ids of the input extraction (excluded)
+   * \param [in,out] arrInOut arr origin array from which the extraction will be done.
+   * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
+   * \param [in] srcArr input array that will be used as source of copy for ids in [ \b idsOfSelectBg , \b idsOfSelectEnd )
+   * \param [in] srcArrIndex index array of \b srcArr
+   *
+   * \sa DataArrayInt::SetPartOfIndexedArrays
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::SetPartOfIndexedArraysSameIdx(const mcIdType *idsOfSelectBg, const mcIdType *idsOfSelectEnd,
+                                                           DataArrayType *arrInOut, const DataArrayIdType *arrIndxIn,
+                                                           const DataArrayType *srcArr, const DataArrayIdType *srcArrIndex)
+  {
+    if(arrInOut==0 || arrIndxIn==0 || srcArr==0 || srcArrIndex==0)
+      throw INTERP_KERNEL::Exception("DataArrayInt::SetPartOfIndexedArraysSameIdx : presence of null pointer in input parameter !");
+    mcIdType nbOfTuples=ToIdType(arrIndxIn->getNumberOfTuples())-1;
+    const mcIdType *arrIndxInPtr=arrIndxIn->begin();
+    const mcIdType *srcArrIndexPtr=srcArrIndex->begin();
+    T *arrInOutPtr=arrInOut->getPointer();
+    const T *srcArrPtr=srcArr->begin();
+    for(const mcIdType *it=idsOfSelectBg;it!=idsOfSelectEnd;it++,srcArrIndexPtr++)
+      {
+        if(*it>=0 && *it<nbOfTuples)
+          {
+            if(srcArrIndexPtr[1]-srcArrIndexPtr[0]==arrIndxInPtr[*it+1]-arrIndxInPtr[*it])
+              std::copy(srcArrPtr+srcArrIndexPtr[0],srcArrPtr+srcArrIndexPtr[1],arrInOutPtr+arrIndxInPtr[*it]);
+            else
+              {
+                std::ostringstream oss; oss << "DataArrayInt::SetPartOfIndexedArraysSameIdx : On pos #" << std::distance(idsOfSelectBg,it) << " id (idsOfSelectBg[" << std::distance(idsOfSelectBg,it)<< "]) is " << *it << " arrIndxIn[id+1]-arrIndxIn[id]!=srcArrIndex[pos+1]-srcArrIndex[pos] !";
+                throw INTERP_KERNEL::Exception(oss.str());
+              }
+          }
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::SetPartOfIndexedArraysSameIdx : On pos #" << std::distance(idsOfSelectBg,it) << " value is " << *it << " not in [0," << nbOfTuples << ") !";
+            throw INTERP_KERNEL::Exception(oss.str());
+          }
+      }
+  }
+
+  /*!
+   * This method works on an input pair (\b arrIn, \b arrIndxIn) where \b arrIn indexes is in \b arrIndxIn.
+   * This method is an specialization of MEDCouplingUMesh::SetPartOfIndexedArrays in the case of assignment do not modify the index in \b arrIndxIn.
+   *
+   * \param [in] start begin of set of ids of the input extraction (included)
+   * \param [in] end end of set of ids of the input extraction (excluded)
+   * \param [in] step step of the set of ids in range mode.
+   * \param [in,out] arrInOut arr origin array from which the extraction will be done.
+   * \param [in] arrIndxIn is the input index array allowing to walk into \b arrIn
+   * \param [in] srcArr input array that will be used as source of copy for ids in [\b idsOfSelectBg, \b idsOfSelectEnd)
+   * \param [in] srcArrIndex index array of \b srcArr
+   *
+   * \sa DataArrayInt::SetPartOfIndexedArraysSlice DataArrayInt::SetPartOfIndexedArraysSameIdx
+   */
+  template <class T>
+  void DataArrayDiscrete<T>::SetPartOfIndexedArraysSameIdxSlice(mcIdType start, mcIdType end, mcIdType step,
+                                                                DataArrayType *arrInOut, const DataArrayIdType *arrIndxIn,
+                                                                const DataArrayType *srcArr, const DataArrayIdType *srcArrIndex)
+  {
+    if(arrInOut==0 || arrIndxIn==0 || srcArr==0 || srcArrIndex==0)
+      throw INTERP_KERNEL::Exception("DataArrayInt::SetPartOfIndexedArraysSameIdxSlice : presence of null pointer in input parameter !");
+    mcIdType nbOfTuples=ToIdType(arrIndxIn->getNumberOfTuples())-1;
+    const mcIdType *arrIndxInPtr=arrIndxIn->begin();
+    const mcIdType *srcArrIndexPtr=srcArrIndex->begin();
+    T *arrInOutPtr=arrInOut->getPointer();
+    const T *srcArrPtr=srcArr->begin();
+    mcIdType nbOfElemsToSet=DataArray::GetNumberOfItemGivenBESRelative(start,end,step,"DataArrayInt::SetPartOfIndexedArraysSameIdxSlice : ");
+    mcIdType it=start;
+    for(mcIdType i=0;i<nbOfElemsToSet;i++,srcArrIndexPtr++,it+=step)
+      {
+        if(it>=0 && it<nbOfTuples)
+          {
+            if(srcArrIndexPtr[1]-srcArrIndexPtr[0]==arrIndxInPtr[it+1]-arrIndxInPtr[it])
+              std::copy(srcArrPtr+srcArrIndexPtr[0],srcArrPtr+srcArrIndexPtr[1],arrInOutPtr+arrIndxInPtr[it]);
+            else
+              {
+                std::ostringstream oss; oss << "DataArrayInt::SetPartOfIndexedArraysSameIdxSlice : On pos #" << i << " id (idsOfSelectBg[" << i << "]) is " << it << " arrIndxIn[id+1]-arrIndxIn[id]!=srcArrIndex[pos+1]-srcArrIndex[pos] !";
+                throw INTERP_KERNEL::Exception(oss.str());
+              }
+          }
+        else
+          {
+            std::ostringstream oss; oss << "DataArrayInt::SetPartOfIndexedArraysSameIdxSlice : On pos #" << i << " value is " << it << " not in [0," << nbOfTuples << ") !";
+            throw INTERP_KERNEL::Exception(oss.str());
+          }
+      }
+  }
+
+  /*!
+   * This method works on an input pair (\b arr, \b arrIndx) where \b arr indexes is in \b arrIndx.
+   * This method will not impact the size of inout parameter \b arrIndx but the size of \b arr will be modified in case of suppression.
+   *
+   * \param [in] idsToRemoveBg begin of set of ids to remove in \b arr (included)
+   * \param [in] idsToRemoveEnd end of set of ids to remove in \b arr (excluded)
+   * \param [in,out] arr array in which the remove operation will be done.
+   * \param [in,out] arrIndx array in the remove operation will modify
+   * \param [in] offsetForRemoval (by default 0) offset so that for each i in [0,arrIndx->getNumberOfTuples()-1) removal process will be performed in the following range [arr+arrIndx[i]+offsetForRemoval,arr+arr[i+1])
+   * \return true if \b arr and \b arrIndx have been modified, false if not.
+   */
+  template <class T>
+  bool DataArrayDiscrete<T>::RemoveIdsFromIndexedArrays(const T *idsToRemoveBg, const T *idsToRemoveEnd,
+                                                        DataArrayType *arr, DataArrayIdType *arrIndx, mcIdType offsetForRemoval)
+  {
+    if(!arrIndx || !arr)
+      throw INTERP_KERNEL::Exception("DataArrayInt::RemoveIdsFromIndexedArrays : some input arrays are empty !");
+    if(offsetForRemoval<0)
+      throw INTERP_KERNEL::Exception("DataArrayInt::RemoveIdsFromIndexedArrays : offsetForRemoval should be >=0 !");
+    std::set<T> s(idsToRemoveBg,idsToRemoveEnd);
+    mcIdType nbOfGrps=ToIdType(arrIndx->getNumberOfTuples())-1;
+    mcIdType *arrIPtr=arrIndx->getPointer();
+    *arrIPtr++=0;
+    mcIdType previousArrI=0;
+    const T *arrPtr=arr->begin();
+    std::vector<T> arrOut;//no utility to switch to DataArrayInt because copy always needed
+    for(mcIdType i=0;i<nbOfGrps;i++,arrIPtr++)
+      {
+        if(*arrIPtr-previousArrI>offsetForRemoval)
+          {
+            for(const T *work=arrPtr+previousArrI+offsetForRemoval;work!=arrPtr+*arrIPtr;work++)
+              {
+                if(s.find(*work)==s.end())
+                  arrOut.push_back(*work);
+              }
+          }
+        previousArrI=*arrIPtr;
+        *arrIPtr=ToIdType(arrOut.size());
+      }
+    if(arr->getNumberOfTuples()==arrOut.size())
+      return false;
+    arr->alloc(arrOut.size(),1);
+    std::copy(arrOut.begin(),arrOut.end(),arr->getPointer());
+    return true;
+  }
+
+  /*!
+   * Returns a new DataArrayInt containing an arithmetic progression
+   * that is equal to the sequence returned by Python \c range(\a begin,\a  end,\a  step )
+   * function.
+   *  \param [in] begin - the start value of the result sequence.
+   *  \param [in] end - limiting value, so that every value of the result array is less than
+   *              \a end.
+   *  \param [in] step - specifies the increment or decrement.
+   *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
+   *          array using decrRef() as it is no more needed.
+   *  \throw If \a step == 0.
+   *  \throw If \a end < \a begin && \a step > 0.
+   *  \throw If \a end > \a begin && \a step < 0.
+   */
+  template <class T>
+  typename Traits<T>::ArrayType *DataArrayDiscrete<T>::Range(T begin, T end, T step)
+  {
+    mcIdType nbOfTuples=DataArray::GetNumberOfItemGivenBESRelative(ToIdType(begin),ToIdType(end),ToIdType(step),"DataArrayInt::Range");
+    MCAuto<DataArrayType> ret=DataArrayType::New();
+    ret->alloc(nbOfTuples,1);
+    T *ptr=ret->getPointer();
+    if(step>0)
+      {
+        for(T i=begin;i<end;i+=step,ptr++)
+          *ptr=i;
+      }
+    else
+      {
+        for(T i=begin;i>end;i+=step,ptr++)
+          *ptr=i;
+      }
+    return ret.retn();
+  }
+
+  /*!
+   * Returns a new DataArrayInt containing a renumbering map in "Old to New" mode computed
+   * from a zip representation of a surjective format (returned e.g. by
+   * \ref MEDCoupling::DataArrayDouble::findCommonTuples() "DataArrayDouble::findCommonTuples()"
+   * for example). The result array minimizes the permutation. <br>
+   * For more info on renumbering see \ref numbering. <br>
+   * \b Example: <br>
+   * - \a nbOfOldTuples: 10
+   * - \a arr          : [0,3, 5,7,9]
+   * - \a arrIBg       : [0,2,5]
+   * - \a newNbOfTuples: 7
+   * - result array    : [0,1,2,0,3,4,5,4,6,4]
+   *
+   *  \param [in] nbOfOldTuples - number of tuples in the initial array \a arr.
+   *  \param [in] arr - the array of tuple indices grouped by \a arrIBg array.
+   *  \param [in] arrIBg - the array dividing all indices stored in \a arr into groups of
+   *         (indices of) equal values. Its every element (except the last one) points to
+   *         the first element of a group of equal values.
+   *  \param [in] arrIEnd - specifies the end of \a arrIBg, so that the last element of \a
+   *          arrIBg is \a arrIEnd[ -1 ].
+   *  \param [out] newNbOfTuples - number of tuples after surjection application.
+   *  \return DataArrayInt * - a new instance of DataArrayInt. The caller is to delete this
+   *          array using decrRef() as it is no more needed.
+   *  \throw If any value of \a arr breaks condition ( 0 <= \a arr[ i ] < \a nbOfOldTuples ).
+   */
+  template <class T>
+  DataArrayIdType *DataArrayDiscrete<T>::ConvertIndexArrayToO2N(mcIdType nbOfOldTuples, const T *arr, const mcIdType *arrIBg, const mcIdType *arrIEnd, mcIdType &newNbOfTuples)
+  {
+    MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
+    ret->alloc(nbOfOldTuples,1);
+    mcIdType *pt=ret->getPointer();
+    std::fill(pt,pt+nbOfOldTuples,-1);
+    mcIdType nbOfGrps=ToIdType(std::distance(arrIBg,arrIEnd))-1;
+    const mcIdType *cIPtr=arrIBg;
+    for(mcIdType i=0;i<nbOfGrps;i++)
+      pt[arr[cIPtr[i]]]=-(i+2);
+    mcIdType newNb=0;
+    for(mcIdType iNode=0;iNode<nbOfOldTuples;iNode++)
+      {
+        if(pt[iNode]<0)
+          {
+            if(pt[iNode]==-1)
+              pt[iNode]=newNb++;
+            else
+              {
+                mcIdType grpId=-(pt[iNode]+2);
+                for(mcIdType j=cIPtr[grpId];j<cIPtr[grpId+1];j++)
+                  {
+                    if(arr[j]>=0 && arr[j]<nbOfOldTuples)
+                      pt[arr[j]]=newNb;
+                    else
+                      {
+                        std::ostringstream oss; oss << "DataArrayInt::ConvertIndexArrayToO2N : With element #" << j << " value is " << arr[j] << " should be in [0," << nbOfOldTuples << ") !";
+                        throw INTERP_KERNEL::Exception(oss.str().c_str());
+                      }
+                  }
+                newNb++;
+              }
+          }
+      }
+    newNbOfTuples=newNb;
+    return ret.retn();
+  }
+
+  /*!
+   * Returns a new DataArrayInt which is a minimal partition of elements of \a groups.
+   * The i-th item of the result array is an ID of a set of elements belonging to a
+   * unique set of groups, which the i-th element is a part of. This set of elements
+   * belonging to a unique set of groups is called \a family, so the result array contains
+   * IDs of families each element belongs to.
+   *
+   * \b Example: if we have two groups of elements: \a group1 [0,4] and \a group2 [ 0,1,2 ],
+   * then there are 3 families:
+   * - \a family1 (with ID 1) contains element [0] belonging to ( \a group1 + \a group2 ),
+   * - \a family2 (with ID 2) contains elements [4] belonging to ( \a group1 ),
+   * - \a family3 (with ID 3) contains element [1,2] belonging to ( \a group2 ), <br>
+   * and the result array contains IDs of families [ 1,3,3,0,2 ]. <br> Note a family ID 0 which
+   * stands for the element #3 which is in none of groups.
+   *
+   *  \param [in] groups - sequence of groups of element IDs.
+   *  \param [in] newNb - total number of elements; it must be more than max ID of element
+   *         in \a groups.
+   *  \param [out] fidsOfGroups - IDs of families the elements of each group belong to.
+   *  \return DataArrayInt * - a new instance of DataArrayInt containing IDs of families
+   *         each element with ID from range [0, \a newNb ) belongs to. The caller is to
+   *         delete this array using decrRef() as it is no more needed.
+   *  \throw If any element ID in \a groups violates condition ( 0 <= ID < \a newNb ).
+   */
+  template <class T>
+  DataArrayIdType *DataArrayDiscrete<T>::MakePartition(const std::vector<const DataArrayType *>& groups, mcIdType newNb, std::vector< std::vector<mcIdType> >& fidsOfGroups)
+  {
+    std::vector<const DataArrayType *> groups2;
+    for(typename std::vector<const DataArrayType *>::const_iterator it4=groups.begin();it4!=groups.end();it4++)
+      if(*it4)
+        groups2.push_back(*it4);
+    MCAuto<DataArrayIdType> ret=DataArrayIdType::New();
+    ret->alloc(newNb,1);
+    mcIdType *retPtr=ret->getPointer();
+    std::fill(retPtr,retPtr+newNb,0);
+    mcIdType fid=1;
+    for(typename std::vector<const DataArrayType *>::const_iterator iter=groups2.begin();iter!=groups2.end();iter++)
+      {
+        const T *ptr=(*iter)->getConstPointer();
+        std::size_t nbOfElem=(*iter)->getNbOfElems();
+        mcIdType sfid=fid;
+        for(mcIdType j=0;j<sfid;j++)
+          {
+            bool found=false;
+            for(std::size_t i=0;i<nbOfElem;i++)
+              {
+                if(ptr[i]>=0 && ptr[i]<newNb)
+                  {
+                    if(retPtr[ptr[i]]==j)
+                      {
+                        retPtr[ptr[i]]=fid;
+                        found=true;
+                      }
+                  }
+                else
+                  {
+                    std::ostringstream oss; oss << "DataArrayInt::MakePartition : In group \"" << (*iter)->getName() << "\" in tuple #" << i << " value = " << ptr[i] << " ! Should be in [0," << newNb;
+                    oss << ") !";
+                    throw INTERP_KERNEL::Exception(oss.str().c_str());
+                  }
+              }
+            if(found)
+              fid++;
+          }
+      }
+    fidsOfGroups.clear();
+    fidsOfGroups.resize(groups2.size());
+    mcIdType grId=0;
+    for(typename std::vector<const DataArrayType *>::const_iterator iter=groups2.begin();iter!=groups2.end();iter++,grId++)
+      {
+        std::set<mcIdType> tmp;
+        const T *ptr=(*iter)->getConstPointer();
+        std::size_t nbOfElem=(*iter)->getNbOfElems();
+        for(const T *p=ptr;p!=ptr+nbOfElem;p++)
+          tmp.insert(retPtr[*p]);
+        fidsOfGroups[grId].insert(fidsOfGroups[grId].end(),tmp.begin(),tmp.end());
+      }
+    return ret.retn();
+  }
+
+}
+
+/// @cond INTERNAL
+namespace MEDCouplingImpl
+{
+  template <class T>
+  class OpSwitchedOn
+  {
+  public:
+    OpSwitchedOn(T *pt):_pt(pt),_cnt(0) { }
+    void operator()(const bool& b) { if(b) *_pt++=_cnt; _cnt++; }
+  private:
+    T *_pt;
+    MEDCoupling::mcIdType _cnt;
+  };
+
+  template <class T>
+  class OpSwitchedOff
+  {
+  public:
+    OpSwitchedOff(T *pt):_pt(pt),_cnt(0) { }
+    void operator()(const bool& b) { if(!b) *_pt++=_cnt; _cnt++; }
+  private:
+    T *_pt;
+    MEDCoupling::mcIdType _cnt;
+  };
+}
+/// @endcond
+
+namespace MEDCoupling
+{
+  /*!
+   * This method returns the list of ids in ascending mode so that v[id]==true.
+   */
+  template <class T>
+  typename Traits<T>::ArrayType *DataArrayDiscrete<T>::BuildListOfSwitchedOn(const std::vector<bool>& v)
+  {
+    std::size_t sz(std::count(v.begin(),v.end(),true));
+    MCAuto<DataArrayType> ret(DataArrayType::New()); ret->alloc(sz,1);
+    std::for_each(v.begin(),v.end(),MEDCouplingImpl::OpSwitchedOn<T>(ret->getPointer()));
+    return ret.retn();
+  }
+
+  /*!
+   * This method returns the list of ids in ascending mode so that v[id]==false.
+   */
+  template <class T>
+  typename Traits<T>::ArrayType *DataArrayDiscrete<T>::BuildListOfSwitchedOff(const std::vector<bool>& v)
+  {
+    std::size_t sz(std::count(v.begin(),v.end(),false));
+    MCAuto<DataArrayType> ret(DataArrayType::New()); ret->alloc(sz,1);
+    std::for_each(v.begin(),v.end(),MEDCouplingImpl::OpSwitchedOff<T>(ret->getPointer()));
+    return ret.retn();
+  }
+}
+
+namespace MEDCoupling
+{
   /*!
    * This method compares content of input vector \a v and \a this.
    * 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.
@@ -4039,7 +7517,7 @@ struct NotInRange
       throw INTERP_KERNEL::Exception("DataArrayInt::isFittingWith : number of components of this should be equal to one !");
     const T *w(this->begin()),*end2(this->end());
     T refVal=-std::numeric_limits<T>::max();
-    int i=0;
+    T i=0;
     std::vector<bool>::const_iterator it(v.begin());
     for(;it!=v.end();it++,i++)
       {
diff --git a/src/MEDCoupling/MEDCouplingTraits.hxx b/src/MEDCoupling/MEDCouplingTraits.hxx
index e5961fe9a..5d550b55e 100644
--- a/src/MEDCoupling/MEDCouplingTraits.hxx
+++ b/src/MEDCoupling/MEDCouplingTraits.hxx
@@ -42,8 +42,11 @@ namespace MEDCoupling
   class MEDCouplingFieldFloat;
   class MEDCouplingFieldInt;
   class DataArrayInt32Tuple;
+  class DataArrayInt64Tuple;
   class DataArrayFloatTuple;
   class DataArrayDoubleTuple;
+  class DataArrayInt32Iterator;
+  class DataArrayInt64Iterator;
   
   template<>
   struct MEDCOUPLING_EXPORT Traits<double>
@@ -83,6 +86,7 @@ namespace MEDCoupling
     typedef DataArrayInt32 ArrayTypeCh;
     typedef MEDCouplingFieldInt FieldType;
     typedef DataArrayInt32Tuple ArrayTuple;
+    typedef DataArrayInt32Iterator IteratorType;
   };
 
   template<>
@@ -96,7 +100,8 @@ namespace MEDCoupling
     typedef DataArrayInt64 ArrayType;
     typedef DataArrayInt64 ArrayTypeCh;
     //typedef MEDCouplingFieldInt64 FieldType;
-    //typedef DataArrayInt64Tuple ArrayTuple;
+    typedef DataArrayInt64Tuple ArrayTuple;
+    typedef DataArrayInt64Iterator IteratorType;
   };
 
   template<>