src/MEDCoupling_Swig/DataArrayInt.i

   1 // Copyright (C) 2007-2024  CEA, EDF
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19 // Author : Anthony Geay (EDF R&D)
  20
  21 %include "MEDCouplingMemArray.i"
  22
  23 %define ARRAYDEF( ARRAY, INT )
  24
  25 // namespace MEDCoupling
  26 // {
  27 //   class ARRAY ## Iterator;
  28
  29 //   class ARRAY : public DataArray -- #ifdef doesn't work inside
  30 //   {
  31   public:
  32     static ARRAY *New();
  33     INT intValue() const;
  34     INT getHashCode() const;
  35     bool empty() const;
  36     void aggregate(const ARRAY *other);
  37     ARRAY *performCopyOrIncrRef(bool deepCopy) const;
  38     void deepCopyFrom(const ARRAY& other);
  39     void reserve(std::size_t nbOfElems);
  40     void pushBackSilent(INT val);
  41     INT popBackSilent();
  42     void pack() const;
  43     void allocIfNecessary(INT nbOfTuple, INT nbOfCompo);
  44     bool isEqual(const ARRAY& other) const;
  45     bool isEqualWithoutConsideringStr(const ARRAY& other) const;
  46     bool isEqualWithoutConsideringStrAndOrder(const ARRAY& other) const;
  47     DataArrayIdType *occurenceRankInThis() const;
  48     DataArrayIdType *buildPermutationArr(const ARRAY& other) const;
  49     ARRAY *sumPerTuple() const;
  50     void sort(bool asc=true);
  51     void reverse();
  52     void checkMonotonic(bool increasing) const;
  53     bool isMonotonic(bool increasing) const;
  54     void checkStrictlyMonotonic(bool increasing) const;
  55     bool isStrictlyMonotonic(bool increasing) const;
  56     void fillWithZero();
  57     void fillWithValue(INT val);
  58     void iota(INT init=0);
  59     std::string repr() const;
  60     std::string reprZip() const;
  61     std::string reprNotTooLong() const;
  62     ARRAY *invertArrayO2N2N2O(mcIdType newNbOfElem) const;
  63     ARRAY *invertArrayN2O2O2N(mcIdType oldNbOfElem) const;
  64     ARRAY *invertArrayO2N2N2OBis(mcIdType newNbOfElem) const;
  65     DataArrayIdType *indicesOfSubPart(const ARRAY& partOfThis) const;
  66     ARRAY *fromNoInterlace() const;
  67     ARRAY *toNoInterlace() const;
  68     ARRAY *selectByTupleIdSafeSlice(mcIdType bg, mcIdType end, mcIdType step) const;
  69     DataArrayIdType *checkAndPreparePermutation() const;
  70     DataArrayIdType *buildPermArrPerLevel() const;
  71     bool isIota(mcIdType sizeExpected) const;
  72     bool isUniform(INT val) const;
  73     INT checkUniformAndGuess() const;
  74     bool hasUniqueValues() const;
  75     ARRAY *subArray(mcIdType tupleIdBg, mcIdType tupleIdEnd=-1) const;
  76     void transpose();
  77     ARRAY *changeNbOfComponents(std::size_t newNbOfComp, INT dftValue) const;
  78     void meldWith(const ARRAY *other);
  79     void setPartOfValues1(const ARRAY *a, mcIdType bgTuples, mcIdType endTuples, mcIdType stepTuples, mcIdType bgComp, mcIdType endComp, mcIdType stepComp, bool strictCompoCompare=true);
  80     void setPartOfValuesSimple1(INT a, mcIdType bgTuples, mcIdType endTuples, mcIdType stepTuples, mcIdType bgComp, mcIdType endComp, mcIdType stepComp);
  81     void setPartOfValuesAdv(const ARRAY *a, const DataArrayIdType *tuplesSelec);
  82     void getTuple(mcIdType tupleId, INT *res) const;
  83     INT getIJ(std::size_t tupleId, std::size_t compoId) const;
  84     INT getIJSafe(std::size_t tupleId, std::size_t compoId) const;
  85     INT front() const;
  86     INT back() const;
  87     void setIJ(mcIdType tupleId, mcIdType compoId, INT newVal);
  88     void setIJSilent(mcIdType tupleId, mcIdType compoId, INT newVal);
  89     INT *getPointer();
  90     const INT *getConstPointer() const;
  91     ARRAY ## Iterator *iterator();
  92     const INT *begin() const;
  93     const INT *end() const;
  94     DataArrayIdType *findIdsEqual(INT val) const;
  95     DataArrayIdType *findIdsNotEqual(INT val) const;
  96     mcIdType changeValue(INT oldValue, INT newValue);
  97     mcIdType findIdFirstEqualTuple(const std::vector<INT>& tupl) const;
  98     mcIdType findIdFirstEqual(INT value) const;
  99     mcIdType findIdFirstEqual(const std::vector<INT>& vals) const;
 100     mcIdType findIdSequence(const std::vector<INT>& vals) const;
 101     bool presenceOfTuple(const std::vector<INT>& tupl) const;
 102     bool presenceOfValue(INT value) const;
 103     bool presenceOfValue(const std::vector<INT>& vals) const;
 104     INT count(INT value) const;
 105     INT accumulate(INT compId) const;
 106     INT getMaxValueInArray() const;
 107     INT getMaxAbsValueInArray() const;
 108     INT getMinValueInArray() const;
 109     void abs();
 110     void sortPerTuple(bool asc);
 111     ARRAY *computeAbs() const;
 112     void applyLin(INT a, INT b, INT compoId);
 113     void applyLin(INT a, INT b);
 114     void applyInv(INT numerator);
 115     ARRAY *negate() const;
 116     void applyDivideBy(INT val);
 117     void applyModulus(INT val);
 118     void applyRModulus(INT val);
 119     void applyPow(INT val);
 120     void applyRPow(INT val);
 121     ARRAY *findIdsInRange(INT vmin, INT vmax) const;
 122     ARRAY *findIdsNotInRange(INT vmin, INT vmax) const;
 123     ARRAY *findIdsStrictlyNegative() const;
 124     bool checkAllIdsInRange(INT vmin, INT vmax) const;
 125     static ARRAY *Aggregate(const ARRAY *a1, const ARRAY *a2, INT offsetA2);
 126     static ARRAY *Meld(const ARRAY *a1, const ARRAY *a2);
 127     static DataArrayIdType *MakePartition(const std::vector<const ARRAY *>& groups, mcIdType newNb, std::vector< std::vector<mcIdType> >& fidsOfGroups);
 128     static ARRAY *BuildUnion(const std::vector<const ARRAY *>& arr);
 129     static ARRAY *BuildIntersection(const std::vector<const ARRAY *>& arr);
 130     static DataArrayIdType *FindPermutationFromFirstToSecond(const ARRAY *ids1, const ARRAY *ids2);
 131     static DataArrayIdType *FindPermutationFromFirstToSecondDuplicate(const ARRAY *ids1, const ARRAY *ids2);
 132     DataArrayIdType *buildComplement(mcIdType nbOfElement) const;
 133     ARRAY *buildSubstraction(const ARRAY *other) const;
 134     ARRAY *buildSubstractionOptimized(const ARRAY *other) const;
 135     ARRAY *buildUnion(const ARRAY *other) const;
 136     ARRAY *buildIntersection(const ARRAY *other) const;
 137     DataArrayIdType *indexOfSameConsecutiveValueGroups() const;
 138     ARRAY *buildUnique() const;
 139     ARRAY *buildUniqueNotSorted() const;
 140     ARRAY *deltaShiftIndex() const;
 141     void computeOffsets();
 142     void computeOffsetsFull();
 143     ARRAY *buildExplicitArrByRanges(const ARRAY *offsets) const;
 144     DataArrayIdType *findRangeIdForEachTuple(const ARRAY *ranges) const;
 145     ARRAY *findIdInRangeForEachTuple(const ARRAY *ranges) const;
 146     void sortEachPairToMakeALinkedList();
 147     void sortToHaveConsecutivePairs();
 148     ARRAY *duplicateEachTupleNTimes(mcIdType nbTimes) const;
 149     ARRAY *getDifferentValues() const;
 150     static ARRAY *Add(const ARRAY *a1, const ARRAY *a2);
 151     void addEqual(const ARRAY *other);
 152     static ARRAY *Substract(const ARRAY *a1, const ARRAY *a2);
 153     void substractEqual(const ARRAY *other);
 154     static ARRAY *Multiply(const ARRAY *a1, const ARRAY *a2);
 155     void multiplyEqual(const ARRAY *other);
 156     static ARRAY *Divide(const ARRAY *a1, const ARRAY *a2);
 157     void divideEqual(const ARRAY *other);
 158     static ARRAY *Modulus(const ARRAY *a1, const ARRAY *a2);
 159     void modulusEqual(const ARRAY *other);
 160     static ARRAY *Pow(const ARRAY *a1, const ARRAY *a2);
 161     void powEqual(const ARRAY *other);
 162     MCAuto<ARRAY> fromLinkedListOfPairToList() const;
 163     MCAuto<DataArrayIdType> findIdsGreaterOrEqualTo(INT val) const;
 164     MCAuto<DataArrayIdType> findIdsGreaterThan(INT val) const;
 165     MCAuto<DataArrayIdType> findIdsLowerOrEqualTo(INT val) const;
 166     MCAuto<DataArrayIdType> findIdsLowerThan(INT val) const;
 167     MCAuto<ARRAY> selectPartDef(const PartDefinition* pd) const;
 168     MCAuto<DataArrayDouble> convertToDblArr() const;
 169     MCAuto<DataArrayFloat> convertToFloatArr() const;
 170   public:
 171     static ARRAY *Range(INT begin, INT end, INT step);
 172     %extend
 173     {
 174       ARRAY()
 175         {
 176           return ARRAY::New();
 177         }
 178
 179       static ARRAY *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
 180       {
 181         const char *msgBase="MEDCoupling::ARRAY::New : Available API are : \n-ARRAY.New()\n-ARRAY.New([1,3,4])\n-ARRAY.New([1,3,4],3)\n-ARRAY.New([1,3,4,5],2,2)\n-ARRAY.New([1,3,4,5,7,8],3,2)\n-ARRAY.New([(1,3),(4,5),(7,8)])\n-ARRAY.New(5)\n-ARRAY.New(5,2)";
 182         std::string msg(msgBase);
 183         if ( MEDCouplingHasNumPyBindings() )
 184           msg+="\n-ARRAY.New(numpy array with dtype=int32)";
 185
 186         msg+=" !";
 187         if(PyList_Check(elt0) || PyTuple_Check(elt0))
 188           {
 189             if(nbOfTuples)
 190               {
 191                 if(PyInt_Check(nbOfTuples))
 192                   {
 193                     mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
 194                     if(nbOfTuples1<0)
 195                       throw INTERP_KERNEL::Exception("ARRAY::New : should be a positive set of allocated memory !");
 196                     if(nbOfComp)
 197                       {
 198                         if(PyInt_Check(nbOfComp))
 199                           {//ARRAY.New([1,3,4,5],2,2)
 200                             mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
 201                             if(nbOfCompo<0)
 202                               throw INTERP_KERNEL::Exception("ARRAY::New : should be a positive number of components !");
 203                             MCAuto<ARRAY> ret=ARRAY::New();
 204                             std::vector<INT> tmp=fillArrayWithPyListInt2<INT>(elt0,nbOfTuples1,nbOfCompo);
 205                             ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
 206                             return ret.retn();
 207                           }
 208                         else
 209                           throw INTERP_KERNEL::Exception(msg.c_str());
 210                       }
 211                     else
 212                       {//ARRAY.New([1,3,4],3)
 213                         MCAuto<ARRAY> ret=ARRAY::New();
 214                         mcIdType tmpp1=-1;
 215                         std::vector<INT> tmp=fillArrayWithPyListInt2<INT>(elt0,nbOfTuples1,tmpp1);
 216                         ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
 217                         return ret.retn();
 218                       }
 219                   }
 220                 else
 221                   throw INTERP_KERNEL::Exception(msg.c_str());
 222               }
 223             else
 224               {// ARRAY.New([1,3,4])
 225                 MCAuto<ARRAY> ret=ARRAY::New();
 226                 mcIdType tmpp1=-1,tmpp2=-1;
 227                 std::vector<INT> tmp=fillArrayWithPyListInt2<INT>(elt0,tmpp1,tmpp2);
 228                 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
 229                 return ret.retn();
 230               }
 231           }
 232         else if(PyInt_Check(elt0))
 233           {
 234             INT nbOfTuples1=(INT)PyInt_AS_LONG(elt0);
 235             if(nbOfTuples1<0)
 236               throw INTERP_KERNEL::Exception("ARRAY::New : should be a positive set of allocated memory !");
 237             if(nbOfTuples)
 238               {
 239                 if(!nbOfComp)
 240                   {
 241                     if(PyInt_Check(nbOfTuples))
 242                       {//ARRAY.New(5,2)
 243                         INT nbOfCompo=(INT)PyInt_AS_LONG(nbOfTuples);
 244                         if(nbOfCompo<0)
 245                           throw INTERP_KERNEL::Exception("ARRAY::New : should be a positive number of components !");
 246                         MCAuto<ARRAY> ret=ARRAY::New();
 247                         ret->alloc(nbOfTuples1,nbOfCompo);
 248                         return ret.retn();
 249                       }
 250                     else
 251                       throw INTERP_KERNEL::Exception(msg.c_str());
 252                   }
 253                 else
 254                   throw INTERP_KERNEL::Exception(msg.c_str());
 255               }
 256             else
 257               {//ARRAY.New(5)
 258                 MCAuto<ARRAY> ret=ARRAY::New();
 259                 ret->alloc(nbOfTuples1,1);
 260                 return ret.retn();
 261               }
 262           }
 263 #if defined(WITH_NUMPY)
 264         else if(MEDCouplingHasNumPyBindings() && PyArray_Check(elt0) && nbOfTuples==NULL && nbOfComp==NULL)
 265           {//ARRAY.New(numpyArray)
 266             return BuildNewInstance<ARRAY,INT>(elt0,NPYTraits<INT>::NPYObjectType,NPYTraits<INT>::NPYFunc,MEDCoupling::Traits<INT>::NPYStr);
 267           }
 268 #endif
 269         else
 270           throw INTERP_KERNEL::Exception(msg.c_str());
 271         throw INTERP_KERNEL::Exception(msg.c_str());//to make g++ happy
 272       }
 273
 274       ARRAY(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
 275         {
 276           return MEDCoupling_ ## ARRAY ## _New__SWIG_1(elt0,nbOfTuples,nbOfComp);
 277         }
 278
 279       std::string __str__() const
 280       {
 281         return self->reprNotTooLong();
 282       }
 283
 284       mcIdType __len__() const
 285       {
 286         if(self->isAllocated())
 287           {
 288             return self->getNumberOfTuples();
 289           }
 290         else
 291           {
 292             throw INTERP_KERNEL::Exception("ARRAY::__len__ : Instance is NOT allocated !");
 293           }
 294       }
 295
 296       INT __int__() const
 297       {
 298         return self->intValue();
 299       }
 300
 301       ARRAY ## Iterator *__iter__()
 302       {
 303         return self->iterator();
 304       }
 305
 306       PyObject *accumulate() const
 307       {
 308         mcIdType sz=ToIdType(self->getNumberOfComponents());
 309         INTERP_KERNEL::AutoPtr<INT> tmp=new INT[sz];
 310         self->accumulate((INT *)tmp);
 311         return convertIntArrToPyList((const INT *)tmp,sz);
 312       }
 313
 314       ARRAY *accumulatePerChunck(PyObject *indexArr) const
 315       {
 316         mcIdType sw,sz,val;
 317         std::vector<mcIdType> val2;
 318         const mcIdType *bg=convertIntStarLikePyObjToCppIntStar(indexArr,sw,sz,val,val2);
 319         return self->accumulatePerChunck(bg,bg+sz);
 320       }
 321
 322       DataArrayIdType *findIdsEqualTuple(PyObject *inputTuple) const
 323       {
 324         mcIdType sw,sz;
 325         INT val;
 326         std::vector<INT> val2;
 327         const INT *bg(convertIntStarLikePyObjToCppIntStar(inputTuple,sw,sz,val,val2));
 328         return self->findIdsEqualTuple(bg,bg+sz);
 329       }
 330
 331       DataArrayIdType *findIdForEach(PyObject *vals) const
 332       {
 333         mcIdType sw,sz;
 334         INT val;
 335         std::vector<INT> val2;
 336         const INT *bg(convertIntStarLikePyObjToCppIntStar(vals,sw,sz,val,val2));
 337         MCAuto<DataArrayIdType> ret(self->findIdForEach(bg,bg+sz));
 338         return ret.retn();
 339       }
 340
 341       PyObject *splitInBalancedSlices(mcIdType nbOfSlices) const
 342       {
 343         std::vector< std::pair<mcIdType,mcIdType> > slcs(self->splitInBalancedSlices(nbOfSlices));
 344         PyObject *ret=PyList_New(slcs.size());
 345         for(std::size_t i=0;i<slcs.size();i++)
 346           PyList_SetItem(ret,i,PySlice_New(PyInt_FromLong(slcs[i].first),PyInt_FromLong(slcs[i].second),PyInt_FromLong(1)));
 347         return ret;
 348       }
 349
 350       ARRAY *buildExplicitArrOfSliceOnScaledArr(PyObject *slic) const
 351       {
 352         if(!PySlice_Check(slic))
 353           throw INTERP_KERNEL::Exception("ARRAY::buildExplicitArrOfSliceOnScaledArr (wrap) : expecting a pyslice as second (first) parameter !");
 354         Py_ssize_t strt=2,stp=2,step=2;
 355         GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"ARRAY::buildExplicitArrOfSliceOnScaledArr (wrap) : the input slice is invalid !");
 356         if(strt==std::numeric_limits<INT>::max() || stp==std::numeric_limits<INT>::max())
 357           throw INTERP_KERNEL::Exception("ARRAY::buildExplicitArrOfSliceOnScaledArr (wrap) : the input slice contains some unknowns that can't be determined in static method ! Call DataArray::getSlice (non static) instead !");
 358         return self->buildExplicitArrOfSliceOnScaledArr((INT)strt,(INT)stp,(INT)step);
 359       }
 360
 361       PyObject *getMinMaxValues() const
 362       {
 363         INT a,b;
 364         self->getMinMaxValues(a,b);
 365         PyObject *ret=PyTuple_New(2);
 366         PyTuple_SetItem(ret,0,PyInt_FromLong(a));
 367         PyTuple_SetItem(ret,1,PyInt_FromLong(b));
 368         return ret;
 369       }
 370
 371       static PyObject *ConvertIndexArrayToO2N(mcIdType nbOfOldTuples, PyObject *arr, PyObject *arrI)
 372       {
 373         mcIdType newNbOfTuples=-1;
 374         mcIdType szArr,szArrI,sw,iTypppArr,iTypppArrI;
 375         std::vector<mcIdType> stdvecTyyppArr;
 376         std::vector<mcIdType> stdvecTyyppArrI;
 377         const mcIdType *arrPtr=convertIntStarLikePyObjToCppIntStar(arr,sw,szArr,iTypppArr,stdvecTyyppArr);
 378         const mcIdType *arrIPtr=convertIntStarLikePyObjToCppIntStar(arrI,sw,szArrI,iTypppArrI,stdvecTyyppArrI);
 379         DataArrayIdType *ret0=MEDCoupling::ARRAY::ConvertIndexArrayToO2N(nbOfOldTuples,arrPtr,arrIPtr,arrIPtr+szArrI,newNbOfTuples);
 380         PyObject *ret=PyTuple_New(2);
 381         PyTuple_SetItem(ret,0,SWIG_NewPointerObj((void*)ret0,SWIGTITraits<mcIdType>::TI,SWIG_POINTER_OWN | 0));
 382         PyTuple_SetItem(ret,1,PyInt_FromLong(newNbOfTuples));
 383         return ret;
 384       }
 385
 386       static DataArrayIdType *CheckAndPreparePermutation(PyObject *arr)
 387       {
 388         MCAuto<DataArrayIdType> ret(DataArrayIdType::New());
 389         mcIdType szArr,sw;
 390         INT iTypppArr;
 391         std::vector<INT> stdvecTyyppArr;
 392         const INT *arrPtr(convertIntStarLikePyObjToCppIntStar(arr,sw,szArr,iTypppArr,stdvecTyyppArr));
 393         mcIdType *pt(MEDCoupling::ARRAY::CheckAndPreparePermutation(arrPtr,arrPtr+szArr));
 394         ret->useArray(pt,true,MEDCoupling::DeallocType::C_DEALLOC,szArr,1);
 395         return ret.retn();
 396       }
 397
 398       void setValues(PyObject *li, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
 399       {
 400         const char *msg="MEDCoupling::ARRAY::setValues : Available API are : \n-ARRAY.setValues([1,3,4])\n-ARRAY.setValues([1,3,4],3)\n-ARRAY.setValues([1,3,4,5],2,2)\n-ARRAY.New(5)\n !";
 401         if(PyList_Check(li) || PyTuple_Check(li))
 402           {
 403             if(nbOfTuples && nbOfTuples != Py_None)
 404               {
 405                 if(PyInt_Check(nbOfTuples))
 406                   {
 407                     mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
 408                     if(nbOfTuples1<0)
 409                       throw INTERP_KERNEL::Exception("ARRAY::setValue : should be a positive set of allocated memory !");
 410                     if(nbOfComp && nbOfComp != Py_None)
 411                       {
 412                         if(PyInt_Check(nbOfComp))
 413                           {//ARRAY.setValues([1,3,4,5],2,2)
 414                             mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
 415                             if(nbOfCompo<0)
 416                               throw INTERP_KERNEL::Exception("ARRAY::setValue : should be a positive number of components !");
 417                             std::vector<INT> tmp=fillArrayWithPyListInt2<INT>(li,nbOfTuples1,nbOfCompo);
 418                             self->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),self->getPointer());
 419                           }
 420                         else
 421                           throw INTERP_KERNEL::Exception(msg);
 422                       }
 423                     else
 424                       {//ARRAY.setValues([1,3,4],3)
 425                         mcIdType tmpp1=-1;
 426                         std::vector<INT> tmp=fillArrayWithPyListInt2<INT>(li,nbOfTuples1,tmpp1);
 427                         self->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),self->getPointer());
 428                       }
 429                   }
 430                 else
 431                   throw INTERP_KERNEL::Exception(msg);
 432               }
 433             else
 434               {// ARRAY.setValues([1,3,4])
 435                 mcIdType tmpp1=-1,tmpp2=-1;
 436                 std::vector<INT> tmp=fillArrayWithPyListInt2<INT>(li,tmpp1,tmpp2);
 437                 self->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),self->getPointer());
 438               }
 439           }
 440         else
 441           throw INTERP_KERNEL::Exception(msg);
 442       }
 443
 444       PyObject *getValues() const
 445       {
 446         const INT *vals=self->getConstPointer();
 447         return convertIntArrToPyList(vals,self->getNbOfElems());
 448       }
 449
 450       PyObject *isEqualIfNotWhy(const ARRAY& other) const
 451       {
 452         std::string ret1;
 453         bool ret0=self->isEqualIfNotWhy(other,ret1);
 454         PyObject *ret=PyTuple_New(2);
 455         PyObject *ret0Py=ret0?Py_True:Py_False;
 456         Py_XINCREF(ret0Py);
 457         PyTuple_SetItem(ret,0,ret0Py);
 458         PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
 459         return ret;
 460       }
 461
 462       PyObject *getValuesAsTuple() const
 463       {
 464         const INT *vals=self->getConstPointer();
 465         mcIdType nbOfComp=ToIdType(self->getNumberOfComponents());
 466         mcIdType nbOfTuples=self->getNumberOfTuples();
 467         return convertIntArrToPyListOfTuple(vals,nbOfComp,nbOfTuples);
 468       }
 469
 470       static PyObject *MakePartition(PyObject *gps, mcIdType newNb)
 471       {
 472         std::vector<const ARRAY *> groups;
 473         std::vector< std::vector<mcIdType> > fidsOfGroups;
 474         convertFromPyObjVectorOfObj(gps,SWIGTITraits<INT>::TI,"ARRAY",groups);
 475         DataArrayIdType *ret0=MEDCoupling::ARRAY::MakePartition(groups,newNb,fidsOfGroups);
 476         PyObject *ret = PyList_New(2);
 477         PyList_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
 478         std::size_t sz=fidsOfGroups.size();
 479         PyObject *ret1 = PyList_New(sz);
 480         for(std::size_t i=0;i<sz;i++)
 481           PyList_SetItem(ret1,i,convertIntArrToPyList2(fidsOfGroups[i]));
 482         PyList_SetItem(ret,1,ret1);
 483         return ret;
 484       }
 485
 486       DataArrayIdType *findIdsEqualList(PyObject *obj)
 487       {
 488         mcIdType sw;
 489         INT singleVal;
 490         std::vector<INT> multiVal;
 491         std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
 492         ARRAY *daIntTyypp=0;
 493         convertIntStarOrSliceLikePyObjToCpp(obj,self->getNumberOfTuples(),sw,singleVal,multiVal,slic,daIntTyypp);
 494         switch(sw)
 495           {
 496           case 1:
 497             return self->findIdsEqualList(&singleVal,&singleVal+1);
 498           case 2:
 499             return self->findIdsEqualList(&multiVal[0],&multiVal[0]+multiVal.size());
 500           case 4:
 501             return self->findIdsEqualList(daIntTyypp->begin(),daIntTyypp->end());
 502           default:
 503             throw INTERP_KERNEL::Exception("ARRAY::findIdsEqualList : unrecognized type entered, expected list of int, tuple of int or ARRAY !");
 504           }
 505       }
 506
 507       DataArrayIdType *findIdsNotEqualList(PyObject *obj)
 508       {
 509         mcIdType sw;
 510         INT singleVal;
 511         std::vector<INT> multiVal;
 512         std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
 513         ARRAY *daIntTyypp=0;
 514         convertIntStarOrSliceLikePyObjToCpp(obj,self->getNumberOfTuples(),sw,singleVal,multiVal,slic,daIntTyypp);
 515         switch(sw)
 516           {
 517           case 1:
 518             return self->findIdsNotEqualList(&singleVal,&singleVal+1);
 519           case 2:
 520             return self->findIdsNotEqualList(&multiVal[0],&multiVal[0]+multiVal.size());
 521           case 4:
 522             return self->findIdsNotEqualList(daIntTyypp->begin(),daIntTyypp->end());
 523           default:
 524             throw INTERP_KERNEL::Exception("ARRAY::findIdsNotEqualList : unrecognized type entered, expected list of int, tuple of int or ARRAY !");
 525           }
 526       }
 527
 528       PyObject *splitByValueRange(PyObject *li) const
 529       {
 530         ARRAY *ret0=0,*ret1=0,*ret2=0;
 531         void *da=0;
 532         int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<INT>::TI, 0 |  0 );
 533         if (!SWIG_IsOK(res1))
 534           {
 535             mcIdType size;
 536             INTERP_KERNEL::AutoPtr<INT> tmp=convertPyToNewIntArr2<INT>(li,&size);
 537             self->splitByValueRange(tmp,(INT *)tmp+size,ret0,ret1,ret2);
 538           }
 539         else
 540           {
 541             ARRAY *da2=reinterpret_cast< ARRAY * >(da);
 542             if(!da2)
 543               throw INTERP_KERNEL::Exception("Not null ARRAY instance expected !");
 544             da2->checkAllocated();
 545             self->splitByValueRange(da2->begin(),da2->end(),ret0,ret1,ret2);
 546           }
 547         PyObject *ret = PyList_New(3);
 548         PyList_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTITraits<INT>::TI, SWIG_POINTER_OWN | 0 ));
 549         PyList_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits<INT>::TI, SWIG_POINTER_OWN | 0 ));
 550         PyList_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(ret2),SWIGTITraits<INT>::TI, SWIG_POINTER_OWN | 0 ));
 551         return ret;
 552       }
 553
 554       DataArrayIdType *transformWithIndArrR(PyObject *li) const
 555       {
 556         void *da=0;
 557         int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<INT>::TI, 0 |  0 );
 558         if (!SWIG_IsOK(res1))
 559           {
 560             mcIdType size;
 561             INTERP_KERNEL::AutoPtr<INT> tmp=convertPyToNewIntArr2<INT>(li,&size);
 562             return self->transformWithIndArrR(tmp,tmp+size);
 563           }
 564         else
 565           {
 566             ARRAY *da2=reinterpret_cast< ARRAY * >(da);
 567             return self->transformWithIndArrR(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
 568           }
 569       }
 570
 571       ARRAY *renumberAndReduce(PyObject *li, mcIdType newNbOfTuple)
 572       {
 573         void *da=0;
 574         int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 |  0 );
 575         if (!SWIG_IsOK(res1))
 576           {
 577             mcIdType size;
 578             INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
 579             if(size!=self->getNumberOfTuples())
 580               {
 581                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
 582               }
 583             return self->renumberAndReduce(tmp,newNbOfTuple);
 584           }
 585         else
 586           {
 587             DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
 588             if(!da2)
 589               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
 590             da2->checkAllocated();
 591             mcIdType size=self->getNumberOfTuples();
 592             if(size!=self->getNumberOfTuples())
 593               {
 594                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
 595               }
 596             return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
 597           }
 598       }
 599
 600       ARRAY *renumber(PyObject *li)
 601       {
 602         void *da=0;
 603         int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 |  0 );
 604         if (!SWIG_IsOK(res1))
 605           {
 606             mcIdType size;
 607             INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
 608             if(size!=self->getNumberOfTuples())
 609               {
 610                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
 611               }
 612             return self->renumber(tmp);
 613           }
 614         else
 615           {
 616             DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
 617             if(!da2)
 618               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
 619             da2->checkAllocated();
 620             mcIdType size=self->getNumberOfTuples();
 621             if(size!=self->getNumberOfTuples())
 622               {
 623                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
 624               }
 625             return self->renumber(da2->getConstPointer());
 626           }
 627       }
 628
 629       ARRAY *renumberR(PyObject *li)
 630       {
 631         void *da=0;
 632         int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 |  0 );
 633         if (!SWIG_IsOK(res1))
 634           {
 635             mcIdType size;
 636             INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
 637             if(size!=self->getNumberOfTuples())
 638               {
 639                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
 640               }
 641             return self->renumberR(tmp);
 642           }
 643         else
 644           {
 645             DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
 646             if(!da2)
 647               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
 648             da2->checkAllocated();
 649             mcIdType size=self->getNumberOfTuples();
 650             if(size!=self->getNumberOfTuples())
 651               {
 652                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
 653               }
 654             return self->renumberR(da2->getConstPointer());
 655           }
 656       }
 657
 658       void setSelectedComponents(const ARRAY *a, PyObject *li)
 659       {
 660         std::vector<std::size_t> tmp;
 661         convertPyToNewIntArr3(li,tmp);
 662         self->setSelectedComponents(a,tmp);
 663       }
 664
 665       PyObject *explodeComponents() const
 666       {
 667         std::vector< MCAuto<ARRAY> > retCpp(self->explodeComponents());
 668         std::size_t sz(retCpp.size());
 669         PyObject *res(PyList_New(sz));
 670         for(std::size_t i=0;i<sz;i++)
 671           PyList_SetItem(res,i,SWIG_NewPointerObj(SWIG_as_voidptr(retCpp[i].retn()),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
 672         return res;
 673       }
 674
 675       PyObject *getTuple(mcIdType tupleId)
 676       {
 677         mcIdType sz=ToIdType(self->getNumberOfComponents());
 678         INTERP_KERNEL::AutoPtr<INT> tmp=new INT[sz];
 679         self->getTuple(tupleId,tmp);
 680         return convertIntArrToPyList((const INT*)tmp,sz);
 681       }
 682
 683       PyObject *changeSurjectiveFormat(INT targetNb) const
 684       {
 685         DataArrayIdType *arr=0;
 686         DataArrayIdType *arrI=0;
 687         self->changeSurjectiveFormat(targetNb,arr,arrI);
 688         PyObject *res = PyList_New(2);
 689         PyList_SetItem(res,0,SWIG_NewPointerObj((void*)arr,SWIGTITraits<mcIdType>::TI,SWIG_POINTER_OWN | 0));
 690         PyList_SetItem(res,1,SWIG_NewPointerObj((void*)arrI,SWIGTITraits<mcIdType>::TI,SWIG_POINTER_OWN | 0));
 691         return res;
 692       }
 693
 694       static ARRAY *Meld(PyObject *li)
 695       {
 696         std::vector<const ARRAY *> tmp;
 697         convertFromPyObjVectorOfObj(li,SWIGTITraits<INT>::TI,"ARRAY",tmp);
 698         return ARRAY::Meld(tmp);
 699       }
 700
 701       static ARRAY *Aggregate(PyObject *li)
 702       {
 703         std::vector<const ARRAY *> tmp;
 704         convertFromPyObjVectorOfObj(li,SWIGTITraits<INT>::TI,"ARRAY",tmp);
 705         return ARRAY::Aggregate(tmp);
 706       }
 707
 708       static ARRAY *AggregateIndexes(PyObject *li)
 709       {
 710         std::vector<const ARRAY *> tmp;
 711         convertFromPyObjVectorOfObj(li,SWIGTITraits<INT>::TI,"ARRAY",tmp);
 712         return ARRAY::AggregateIndexes(tmp);
 713       }
 714
 715       static ARRAY *BuildUnion(PyObject *li)
 716       {
 717         std::vector<const ARRAY *> tmp;
 718         convertFromPyObjVectorOfObj(li,SWIGTITraits<INT>::TI,"ARRAY",tmp);
 719         return ARRAY::BuildUnion(tmp);
 720       }
 721
 722       static ARRAY *BuildIntersection(PyObject *li)
 723       {
 724         std::vector<const ARRAY *> tmp;
 725         convertFromPyObjVectorOfObj(li,SWIGTITraits<INT>::TI,"ARRAY",tmp);
 726         return ARRAY::BuildIntersection(tmp);
 727       }
 728
 729       PyObject *getMaxValue() const
 730       {
 731         mcIdType tmp;
 732         INT r1=self->getMaxValue(tmp);
 733         PyObject *ret=PyTuple_New(2);
 734         PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
 735         PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
 736         return ret;
 737       }
 738
 739       PyObject *getMaxAbsValue(std::size_t& tupleId) const
 740       {
 741         std::size_t tmp;
 742         INT r1=self->getMaxAbsValue(tmp);
 743         PyObject *ret=PyTuple_New(2);
 744         PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
 745         PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
 746         return ret;
 747       }
 748
 749       PyObject *getMinValue() const
 750       {
 751         mcIdType tmp;
 752         INT r1=self->getMinValue(tmp);
 753         PyObject *ret=PyTuple_New(2);
 754         PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
 755         PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
 756         return ret;
 757       }
 758
 759       mcIdType index(PyObject *obj) const
 760       {
 761         std::size_t nbOfCompo=self->getNumberOfComponents();
 762         switch(nbOfCompo)
 763           {
 764           case 1:
 765             {
 766               if(PyInt_Check(obj))
 767                 {
 768                   INT val=(INT)PyInt_AS_LONG(obj);
 769                   return self->findIdFirstEqual(val);
 770                 }
 771               else
 772                 throw INTERP_KERNEL::Exception("ARRAY::index : 'this' contains one component and trying to find an element which is not an integer !");
 773             }
 774           default:
 775             {
 776               std::vector<INT> arr;
 777               convertPyToNewIntArr3(obj,arr);
 778               return self->findIdFirstEqualTuple(arr);
 779             }
 780           }
 781       }
 782
 783       bool __contains__(PyObject *obj) const
 784       {
 785         std::size_t nbOfCompo=self->getNumberOfComponents();
 786         switch(nbOfCompo)
 787           {
 788           case 0:
 789             return false;
 790           case 1:
 791             {
 792               if(PyInt_Check(obj))
 793                 {
 794                   INT val=(INT)PyInt_AS_LONG(obj);
 795                   return self->presenceOfValue(val);
 796                 }
 797               else
 798                 throw INTERP_KERNEL::Exception("ARRAY::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
 799             }
 800           default:
 801             {
 802               std::vector<INT> arr;
 803               convertPyToNewIntArr3(obj,arr);
 804               return self->presenceOfTuple(arr);
 805             }
 806           }
 807       }
 808
 809       PyObject *__getitem__(PyObject *obj)
 810       {
 811         const char msg[]="Unexpected situation in ARRAY::__getitem__ !";
 812         const char msg2[]="ARRAY::__getitem__ : Mismatch of slice values in 2nd parameter (components) !";
 813         self->checkAllocated();
 814         mcIdType nbOfTuples=self->getNumberOfTuples();
 815         std::size_t nbOfComponents=self->getNumberOfComponents();
 816         mcIdType it1;
 817         std::size_t ic1;
 818         std::vector<mcIdType> vt1;
 819         std::vector<std::size_t> vc1;
 820         std::pair<mcIdType, std::pair<mcIdType,mcIdType> > pt1,pc1;
 821         DataArrayIdType *dt1=0,*dc1=0;
 822         mcIdType sw;
 823         convertObjToPossibleCpp3(obj,nbOfTuples,(int)nbOfComponents,sw,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1);
 824         MCAuto<ARRAY> ret;
 825         switch(sw)
 826           {
 827           case 1:
 828             {
 829               if(nbOfComponents==1)
 830                 return PyInt_FromLong(self->getIJSafe(it1,0));
 831               return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(&it1,&it1+1)),SWIGTITraits<INT>::TI, SWIG_POINTER_OWN | 0 );
 832             }
 833           case 2:
 834             return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size())),SWIGTITraits<INT>::TI, SWIG_POINTER_OWN | 0 );
 835           case 3:
 836             return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafeSlice(pt1.first,pt1.second.first,pt1.second.second)),SWIGTITraits<INT>::TI, SWIG_POINTER_OWN | 0 );
 837           case 4:
 838             return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems())),SWIGTITraits<INT>::TI, SWIG_POINTER_OWN | 0 );
 839           case 5:
 840             return PyInt_FromLong(self->getIJSafe(it1,ic1));
 841           case 6:
 842             {
 843               ret=self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size());
 844               std::vector<std::size_t> v2(1,ic1);
 845               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTITraits<INT>::TI, SWIG_POINTER_OWN | 0 );
 846             }
 847           case 7:
 848             {
 849               ret=self->selectByTupleIdSafeSlice(pt1.first,pt1.second.first,pt1.second.second);
 850               std::vector<std::size_t> v2(1,ic1);
 851               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTITraits<INT>::TI, SWIG_POINTER_OWN | 0 );
 852             }
 853           case 8:
 854             {
 855               ret=self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems());
 856               std::vector<std::size_t> v2(1,ic1);
 857               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTITraits<INT>::TI, SWIG_POINTER_OWN | 0 );
 858             }
 859           case 9:
 860             {
 861               ret=self->selectByTupleIdSafe(&it1,&it1+1);
 862               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTITraits<INT>::TI, SWIG_POINTER_OWN | 0 );
 863             }
 864           case 10:
 865             {
 866               ret=self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size());
 867               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTITraits<INT>::TI, SWIG_POINTER_OWN | 0 );
 868             }
 869           case 11:
 870             {
 871               ret=self->selectByTupleIdSafeSlice(pt1.first,pt1.second.first,pt1.second.second);
 872               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTITraits<INT>::TI, SWIG_POINTER_OWN | 0 );
 873             }
 874           case 12:
 875             {
 876               ret=self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems());
 877               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTITraits<INT>::TI, SWIG_POINTER_OWN | 0 );
 878             }
 879           case 13:
 880             {
 881               ret=self->selectByTupleIdSafe(&it1,&it1+1);
 882               mcIdType nbOfComp=DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2);
 883               std::vector<std::size_t> v2(nbOfComp);
 884               for(INT i=0;i<nbOfComp;i++)
 885                 v2[i]=pc1.first+i*pc1.second.second;
 886               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTITraits<INT>::TI, SWIG_POINTER_OWN | 0 );
 887             }
 888           case 14:
 889             {
 890               ret=self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size());
 891               mcIdType nbOfComp=DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2);
 892               std::vector<std::size_t> v2(nbOfComp);
 893               for(INT i=0;i<nbOfComp;i++)
 894                 v2[i]=pc1.first+i*pc1.second.second;
 895               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTITraits<INT>::TI, SWIG_POINTER_OWN | 0 );
 896             }
 897           case 15:
 898             {
 899               ret=self->selectByTupleIdSafeSlice(pt1.first,pt1.second.first,pt1.second.second);
 900               mcIdType nbOfComp=DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2);
 901               std::vector<std::size_t> v2(nbOfComp);
 902               for(mcIdType i=0;i<nbOfComp;i++)
 903                 v2[i]=pc1.first+i*pc1.second.second;
 904               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTITraits<INT>::TI, SWIG_POINTER_OWN | 0 );
 905             }
 906           case 16:
 907             {
 908               ret=self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems());
 909               mcIdType nbOfComp=DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2);
 910               std::vector<std::size_t> v2(nbOfComp);
 911               for(INT i=0;i<nbOfComp;i++)
 912                 v2[i]=pc1.first+i*pc1.second.second;
 913               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTITraits<INT>::TI, SWIG_POINTER_OWN | 0 );
 914             }
 915           default:
 916             throw INTERP_KERNEL::Exception(msg);
 917           }
 918       }
 919
 920       ARRAY *__setitem__(PyObject *obj, PyObject *value)
 921       {
 922         self->checkAllocated();
 923         const char msg[]="Unexpected situation in __setitem__ !";
 924         mcIdType nbOfTuples=self->getNumberOfTuples();
 925         int nbOfComponents=(int)self->getNumberOfComponents();
 926         mcIdType sw1,sw2;
 927         INT i1;
 928         std::vector<INT> v1;
 929         ARRAY *d1=0;
 930         ARRAY ## Tuple *dd1=0;
 931         convertIntStarLikePyObjToCpp(value,sw1,i1,v1,d1,dd1);
 932         mcIdType it1,ic1;
 933         std::vector<mcIdType> vt1,vc1;
 934         std::pair<mcIdType, std::pair<mcIdType,mcIdType> > pt1,pc1;
 935         DataArrayIdType *dt1=0,*dc1=0;
 936         convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw2,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1);
 937         MCAuto<ARRAY> tmp;
 938         switch(sw2)
 939           {
 940           case 1:
 941             {
 942               switch(sw1)
 943                 {
 944                 case 1:
 945                   self->setPartOfValuesSimple1(i1,it1,it1+1,1,0,nbOfComponents,1);
 946                   return self;
 947                 case 2:
 948                   tmp=ARRAY::New();
 949                   tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size());
 950                   self->setPartOfValues1(tmp,it1,it1+1,1,0,nbOfComponents,1,false);
 951                   return self;
 952                 case 3:
 953                   self->setPartOfValues1(d1,it1,it1+1,1,0,nbOfComponents,1);
 954                   return self;
 955                 case 4:
 956                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
 957                   self->setPartOfValues1(tmp,it1,it1+1,1,0,nbOfComponents,1);
 958                   return self;
 959                 default:
 960                   throw INTERP_KERNEL::Exception(msg);
 961                 }
 962               break;
 963             }
 964           case 2:
 965             {
 966               switch(sw1)
 967                 {
 968                 case 1:
 969                   self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1);
 970                   return self;
 971                 case 2:
 972                   tmp=ARRAY::New();
 973                   tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size());
 974                   self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1,false);
 975                   return self;
 976                 case 3:
 977                   self->setPartOfValues3(d1,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1);
 978                   return self;
 979                 case 4:
 980                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
 981                   self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1);
 982                   return self;
 983                 default:
 984                   throw INTERP_KERNEL::Exception(msg);
 985                 }
 986               break;
 987             }
 988           case 3:
 989             {
 990               switch(sw1)
 991                 {
 992                 case 1:
 993                   self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1);
 994                   return self;
 995                 case 2:
 996                   tmp=ARRAY::New();
 997                   tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size());
 998                   self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1,false);
 999                   return self;
1000                 case 3:
1001                   self->setPartOfValues1(d1,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1);
1002                   return self;
1003                 case 4:
1004                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
1005                   self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1);
1006                   return self;
1007                 default:
1008                   throw INTERP_KERNEL::Exception(msg);
1009                 }
1010               break;
1011             }
1012           case 4:
1013             {
1014               switch(sw1)
1015                 {
1016                 case 1:
1017                   self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1);
1018                   return self;
1019                 case 2:
1020                   tmp=ARRAY::New();
1021                   tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size());
1022                   self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1,false);
1023                   return self;
1024                 case 3:
1025                   self->setPartOfValues3(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1);
1026                   return self;
1027                 case 4:
1028                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
1029                   self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1);
1030                   return self;
1031                 default:
1032                   throw INTERP_KERNEL::Exception(msg);
1033                 }
1034               break;
1035             }
1036           case 5:
1037             {
1038               switch(sw1)
1039                 {
1040                 case 1:
1041                   self->setPartOfValuesSimple1(i1,it1,it1+1,1,ic1,ic1+1,1);
1042                   return self;
1043                 case 2:
1044                   tmp=ARRAY::New();
1045                   tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size());
1046                   self->setPartOfValues1(tmp,it1,it1+1,1,ic1,ic1+1,1,false);
1047                   return self;
1048                 case 3:
1049                   self->setPartOfValues1(d1,it1,it1+1,1,ic1,ic1+1,1);
1050                   return self;
1051                 case 4:
1052                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
1053                   self->setPartOfValues1(tmp,it1,it1+1,1,ic1,ic1+1,1);
1054                   return self;
1055                 default:
1056                   throw INTERP_KERNEL::Exception(msg);
1057                 }
1058               break;
1059             }
1060           case 6:
1061             {
1062               switch(sw1)
1063                 {
1064                 case 1:
1065                   self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1);
1066                   return self;
1067                 case 2:
1068                   tmp=ARRAY::New();
1069                   tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size());
1070                   self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1,false);
1071                   return self;
1072                 case 3:
1073                   self->setPartOfValues3(d1,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1);
1074                   return self;
1075                 case 4:
1076                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
1077                   self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1);
1078                   return self;
1079                 default:
1080                   throw INTERP_KERNEL::Exception(msg);
1081                 }
1082               break;
1083             }
1084           case 7:
1085             {
1086               switch(sw1)
1087                 {
1088                 case 1:
1089                   self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1);
1090                   return self;
1091                 case 2:
1092                   tmp=ARRAY::New();
1093                   tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size());
1094                   self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1,false);
1095                   return self;
1096                 case 3:
1097                   self->setPartOfValues1(d1,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1);
1098                   return self;
1099                 case 4:
1100                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
1101                   self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1);
1102                   return self;
1103                 default:
1104                   throw INTERP_KERNEL::Exception(msg);
1105                 }
1106               break;
1107             }
1108           case 8:
1109             {
1110               switch(sw1)
1111                 {
1112                 case 1:
1113                   self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1);
1114                   return self;
1115                 case 2:
1116                   tmp=ARRAY::New();
1117                   tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size());
1118                   self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1,false);
1119                   return self;
1120                 case 3:
1121                   self->setPartOfValues3(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1);
1122                   return self;
1123                 case 4:
1124                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
1125                   self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1);
1126                   return self;
1127                 default:
1128                   throw INTERP_KERNEL::Exception(msg);
1129                 }
1130               break;
1131             }
1132           case 9:
1133             {
1134               switch(sw1)
1135                 {
1136                 case 1:
1137                   self->setPartOfValuesSimple2(i1,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size());
1138                   return self;
1139                 case 2:
1140                   tmp=ARRAY::New();
1141                   tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size());
1142                   self->setPartOfValues2(tmp,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size(),false);
1143                   return self;
1144                 case 3:
1145                   self->setPartOfValues2(d1,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size());
1146                   return self;
1147                 case 4:
1148                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
1149                   self->setPartOfValues2(tmp,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size());
1150                   return self;
1151                 default:
1152                   throw INTERP_KERNEL::Exception(msg);
1153                 }
1154               break;
1155             }
1156           case 10:
1157             {
1158               switch(sw1)
1159                 {
1160                 case 1:
1161                   self->setPartOfValuesSimple2(i1,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size());
1162                   return self;
1163                 case 2:
1164                   tmp=ARRAY::New();
1165                   tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size());
1166                   self->setPartOfValues2(tmp,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size(),false);
1167                   return self;
1168                 case 3:
1169                   self->setPartOfValues2(d1,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size());
1170                   return self;
1171                 case 4:
1172                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
1173                   self->setPartOfValues2(tmp,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size());
1174                   return self;
1175                 default:
1176                   throw INTERP_KERNEL::Exception(msg);
1177                 }
1178               break;
1179             }
1180           case 11:
1181             {
1182               switch(sw1)
1183                 {
1184                 case 1:
1185                   self->setPartOfValuesSimple4(i1,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size());
1186                   return self;
1187                 case 2:
1188                   tmp=ARRAY::New();
1189                   tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size());
1190                   self->setPartOfValues4(tmp,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size(),false);
1191                   return self;
1192                 case 3:
1193                   self->setPartOfValues4(d1,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size());
1194                   return self;
1195                 case 4:
1196                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
1197                   self->setPartOfValues4(tmp,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size());
1198                   return self;
1199                 default:
1200                   throw INTERP_KERNEL::Exception(msg);
1201                 }
1202               break;
1203             }
1204           case 12:
1205             {
1206               switch(sw1)
1207                 {
1208                 case 1:
1209                   self->setPartOfValuesSimple2(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size());
1210                   return self;
1211                 case 2:
1212                   tmp=ARRAY::New();
1213                   tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size());
1214                   self->setPartOfValues2(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size(),false);
1215                   return self;
1216                 case 3:
1217                   self->setPartOfValues2(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size());
1218                   return self;
1219                 case 4:
1220                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
1221                   self->setPartOfValues2(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size());
1222                   return self;
1223                 default:
1224                   throw INTERP_KERNEL::Exception(msg);
1225                 }
1226               break;
1227             }
1228           case 13:
1229             {
1230               switch(sw1)
1231                 {
1232                 case 1:
1233                   self->setPartOfValuesSimple1(i1,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second);
1234                   return self;
1235                 case 2:
1236                   tmp=ARRAY::New();
1237                   tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size());
1238                   self->setPartOfValues1(tmp,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second,false);
1239                   return self;
1240                 case 3:
1241                   self->setPartOfValues1(d1,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second);
1242                   return self;
1243                 case 4:
1244                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
1245                   self->setPartOfValues1(tmp,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second);
1246                   return self;
1247                 default:
1248                   throw INTERP_KERNEL::Exception(msg);
1249                 }
1250               break;
1251             }
1252           case 14:
1253             {
1254               switch(sw1)
1255                 {
1256                 case 1:
1257                   self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second);
1258                   return self;
1259                 case 2:
1260                   tmp=ARRAY::New();
1261                   tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size());
1262                   self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second,false);
1263                   return self;
1264                 case 3:
1265                   self->setPartOfValues3(d1,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second);
1266                   return self;
1267                 case 4:
1268                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
1269                   self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second);
1270                   return self;
1271                 default:
1272                   throw INTERP_KERNEL::Exception(msg);
1273                 }
1274               break;
1275             }
1276           case 15:
1277             {
1278               switch(sw1)
1279                 {
1280                 case 1:
1281                   self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second);
1282                   return self;
1283                 case 2:
1284                   tmp=ARRAY::New();
1285                   tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size());
1286                   self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second,false);
1287                   return self;
1288                 case 3:
1289                   self->setPartOfValues1(d1,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second);
1290                   return self;
1291                 case 4:
1292                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
1293                   self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second);
1294                   return self;
1295                 default:
1296                   throw INTERP_KERNEL::Exception(msg);
1297                 }
1298               break;
1299             }
1300           case 16:
1301             {
1302               switch(sw1)
1303                 {
1304                 case 1:
1305                   self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second);
1306                   return self;
1307                 case 2:
1308                   tmp=ARRAY::New();
1309                   tmp->useArray(&v1[0],false,DeallocType::CPP_DEALLOC,1,v1.size());
1310                   self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second,false);
1311                   return self;
1312                 case 3:
1313                   self->setPartOfValues3(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second);
1314                   return self;
1315                 case 4:
1316                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
1317                   self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second);
1318                   return self;
1319                 default:
1320                   throw INTERP_KERNEL::Exception(msg);
1321                 }
1322               break;
1323             }
1324           default:
1325             throw INTERP_KERNEL::Exception(msg);
1326           }
1327         return self;
1328       }
1329
1330       ARRAY *__neg__() const
1331       {
1332         return self->negate();
1333       }
1334
1335       ARRAY *__add__(PyObject *obj)
1336       {
1337         const char msg[]="Unexpected situation in __add__ !";
1338         INT val;
1339         ARRAY *a;
1340         std::vector<INT> aa;
1341         ARRAY ## Tuple *aaa;
1342         mcIdType sw;
1343         convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa);
1344         switch(sw)
1345           {
1346           case 1:
1347             {
1348               MCAuto<ARRAY> ret=self->deepCopy();
1349               ret->applyLin(1,val);
1350               return ret.retn();
1351             }
1352           case 2:
1353             {
1354               MCAuto<ARRAY> aaaa=ARRAY::New(); aaaa->useArray(&aa[0],false,DeallocType::CPP_DEALLOC,1,aa.size());
1355               return ARRAY::Add(self,aaaa);
1356             }
1357           case 3:
1358             {
1359               return ARRAY::Add(self,a);
1360             }
1361           case 4:
1362             {
1363               MCAuto<ARRAY> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
1364               return ARRAY::Add(self,aaaa);
1365             }
1366           default:
1367             throw INTERP_KERNEL::Exception(msg);
1368           }
1369       }
1370
1371       ARRAY *__radd__(PyObject *obj)
1372       {
1373         const char msg[]="Unexpected situation in __radd__ !";
1374         INT val;
1375         ARRAY *a;
1376         std::vector<INT> aa;
1377         ARRAY ## Tuple *aaa;
1378         mcIdType sw;
1379         convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa);
1380         switch(sw)
1381           {
1382           case 1:
1383             {
1384               MCAuto<ARRAY> ret=self->deepCopy();
1385               ret->applyLin(1,val);
1386               return ret.retn();
1387             }
1388           case 2:
1389             {
1390               MCAuto<ARRAY> aaaa=ARRAY::New(); aaaa->useArray(&aa[0],false,DeallocType::CPP_DEALLOC,1,aa.size());
1391               return ARRAY::Add(self,aaaa);
1392             }
1393           case 4:
1394             {
1395               MCAuto<ARRAY> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
1396               return ARRAY::Add(self,aaaa);
1397             }
1398           default:
1399             throw INTERP_KERNEL::Exception(msg);
1400           }
1401       }
1402
1403       PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
1404       {
1405         const char msg[]="Unexpected situation in __iadd__ !";
1406         INT val;
1407         ARRAY *a;
1408         std::vector<INT> aa;
1409         ARRAY ## Tuple *aaa;
1410         mcIdType sw;
1411         convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa);
1412         switch(sw)
1413           {
1414           case 1:
1415             {
1416               self->applyLin(1,val);
1417               Py_XINCREF(trueSelf);
1418               return trueSelf;
1419             }
1420           case 2:
1421             {
1422               MCAuto<ARRAY> bb=ARRAY::New(); bb->useArray(&aa[0],false,DeallocType::CPP_DEALLOC,1,aa.size());
1423               self->addEqual(bb);
1424               Py_XINCREF(trueSelf);
1425               return trueSelf;
1426             }
1427           case 3:
1428             {
1429               self->addEqual(a);
1430               Py_XINCREF(trueSelf);
1431               return trueSelf;
1432             }
1433           case 4:
1434             {
1435               MCAuto<ARRAY> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
1436               self->addEqual(aaaa);
1437               Py_XINCREF(trueSelf);
1438               return trueSelf;
1439             }
1440           default:
1441             throw INTERP_KERNEL::Exception(msg);
1442           }
1443       }
1444
1445       ARRAY *__sub__(PyObject *obj)
1446       {
1447         const char msg[]="Unexpected situation in __sub__ !";
1448         INT val;
1449         ARRAY *a;
1450         std::vector<INT> aa;
1451         ARRAY ## Tuple *aaa;
1452         mcIdType sw;
1453         convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa);
1454         switch(sw)
1455           {
1456           case 1:
1457             {
1458               MCAuto<ARRAY> ret=self->deepCopy();
1459               ret->applyLin(1,-val);
1460               return ret.retn();
1461             }
1462           case 2:
1463             {
1464               MCAuto<ARRAY> aaaa=ARRAY::New(); aaaa->useArray(&aa[0],false,DeallocType::CPP_DEALLOC,1,aa.size());
1465               return ARRAY::Substract(self,aaaa);
1466             }
1467           case 3:
1468             {
1469               return ARRAY::Substract(self,a);
1470             }
1471           case 4:
1472             {
1473               MCAuto<ARRAY> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
1474               return ARRAY::Substract(self,aaaa);
1475             }
1476           default:
1477             throw INTERP_KERNEL::Exception(msg);
1478           }
1479       }
1480
1481       ARRAY *__rsub__(PyObject *obj)
1482       {
1483         const char msg[]="Unexpected situation in __rsub__ !";
1484         INT val;
1485         ARRAY *a;
1486         std::vector<INT> aa;
1487         ARRAY ## Tuple *aaa;
1488         mcIdType sw;
1489         convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa);
1490         switch(sw)
1491           {
1492           case 1:
1493             {
1494               MCAuto<ARRAY> ret=self->deepCopy();
1495               ret->applyLin(-1,val);
1496               return ret.retn();
1497             }
1498           case 2:
1499             {
1500               MCAuto<ARRAY> aaaa=ARRAY::New(); aaaa->useArray(&aa[0],false,DeallocType::CPP_DEALLOC,1,aa.size());
1501               return ARRAY::Substract(aaaa,self);
1502             }
1503           case 4:
1504             {
1505               MCAuto<ARRAY> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
1506               return ARRAY::Substract(aaaa,self);
1507             }
1508           default:
1509             throw INTERP_KERNEL::Exception(msg);
1510           }
1511       }
1512
1513       PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
1514       {
1515         const char msg[]="Unexpected situation in __isub__ !";
1516         INT val;
1517         ARRAY *a;
1518         std::vector<INT> aa;
1519         ARRAY ## Tuple *aaa;
1520         mcIdType sw;
1521         convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa);
1522         switch(sw)
1523           {
1524           case 1:
1525             {
1526               self->applyLin(1,-val);
1527               Py_XINCREF(trueSelf);
1528               return trueSelf;
1529             }
1530           case 2:
1531             {
1532               MCAuto<ARRAY> bb=ARRAY::New(); bb->useArray(&aa[0],false,DeallocType::CPP_DEALLOC,1,aa.size());
1533               self->substractEqual(bb);
1534               Py_XINCREF(trueSelf);
1535               return trueSelf;
1536             }
1537           case 3:
1538             {
1539               self->substractEqual(a);
1540               Py_XINCREF(trueSelf);
1541               return trueSelf;
1542             }
1543           case 4:
1544             {
1545               MCAuto<ARRAY> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
1546               self->substractEqual(aaaa);
1547               Py_XINCREF(trueSelf);
1548               return trueSelf;
1549             }
1550           default:
1551             throw INTERP_KERNEL::Exception(msg);
1552           }
1553       }
1554
1555       ARRAY *__mul__(PyObject *obj)
1556       {
1557         const char msg[]="Unexpected situation in __mul__ !";
1558         INT val;
1559         ARRAY *a;
1560         std::vector<INT> aa;
1561         ARRAY ## Tuple *aaa;
1562         mcIdType sw;
1563         convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa);
1564         switch(sw)
1565           {
1566           case 1:
1567             {
1568               MCAuto<ARRAY> ret=self->deepCopy();
1569               ret->applyLin(val,0);
1570               return ret.retn();
1571             }
1572           case 2:
1573             {
1574               MCAuto<ARRAY> aaaa=ARRAY::New(); aaaa->useArray(&aa[0],false,DeallocType::CPP_DEALLOC,1,aa.size());
1575               return ARRAY::Multiply(self,aaaa);
1576             }
1577           case 3:
1578             {
1579               return ARRAY::Multiply(self,a);
1580             }
1581           case 4:
1582             {
1583               MCAuto<ARRAY> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
1584               return ARRAY::Multiply(self,aaaa);
1585             }
1586           default:
1587             throw INTERP_KERNEL::Exception(msg);
1588           }
1589       }
1590
1591       ARRAY *__rmul__(PyObject *obj)
1592       {
1593         const char msg[]="Unexpected situation in __rmul__ !";
1594         INT val;
1595         ARRAY *a;
1596         std::vector<INT> aa;
1597         ARRAY ## Tuple *aaa;
1598         mcIdType sw;
1599         convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa);
1600         switch(sw)
1601           {
1602           case 1:
1603             {
1604               MCAuto<ARRAY> ret=self->deepCopy();
1605               ret->applyLin(val,0);
1606               return ret.retn();
1607             }
1608           case 2:
1609             {
1610               MCAuto<ARRAY> aaaa=ARRAY::New(); aaaa->useArray(&aa[0],false,DeallocType::CPP_DEALLOC,1,aa.size());
1611               return ARRAY::Multiply(self,aaaa);
1612             }
1613           case 4:
1614             {
1615               MCAuto<ARRAY> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
1616               return ARRAY::Multiply(self,aaaa);
1617             }
1618           default:
1619             throw INTERP_KERNEL::Exception(msg);
1620           }
1621       }
1622
1623       PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
1624       {
1625         const char msg[]="Unexpected situation in __imul__ !";
1626         INT val;
1627         ARRAY *a;
1628         std::vector<INT> aa;
1629         ARRAY ## Tuple *aaa;
1630         mcIdType sw;
1631         convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa);
1632         switch(sw)
1633           {
1634           case 1:
1635             {
1636               self->applyLin(val,0);
1637               Py_XINCREF(trueSelf);
1638               return trueSelf;
1639             }
1640           case 2:
1641             {
1642               MCAuto<ARRAY> bb=ARRAY::New(); bb->useArray(&aa[0],false,DeallocType::CPP_DEALLOC,1,aa.size());
1643               self->multiplyEqual(bb);
1644               Py_XINCREF(trueSelf);
1645               return trueSelf;
1646             }
1647           case 3:
1648             {
1649               self->multiplyEqual(a);
1650               Py_XINCREF(trueSelf);
1651               return trueSelf;
1652             }
1653           case 4:
1654             {
1655               MCAuto<ARRAY> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
1656               self->multiplyEqual(aaaa);
1657               Py_XINCREF(trueSelf);
1658               return trueSelf;
1659             }
1660           default:
1661             throw INTERP_KERNEL::Exception(msg);
1662           }
1663       }
1664
1665       ARRAY *__div__(PyObject *obj)
1666       {
1667         const char msg[]="Unexpected situation in __div__ !";
1668         INT val;
1669         ARRAY *a;
1670         std::vector<INT> aa;
1671         ARRAY ## Tuple *aaa;
1672         mcIdType sw;
1673         convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa);
1674         switch(sw)
1675           {
1676           case 1:
1677             {
1678               MCAuto<ARRAY> ret=self->deepCopy();
1679               ret->applyDivideBy(val);
1680               return ret.retn();
1681             }
1682           case 2:
1683             {
1684               MCAuto<ARRAY> aaaa=ARRAY::New(); aaaa->useArray(&aa[0],false,DeallocType::CPP_DEALLOC,1,aa.size());
1685               return ARRAY::Divide(self,aaaa);
1686             }
1687           case 3:
1688             {
1689               return ARRAY::Divide(self,a);
1690             }
1691           case 4:
1692             {
1693               MCAuto<ARRAY> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
1694               return ARRAY::Divide(self,aaaa);
1695             }
1696           default:
1697             throw INTERP_KERNEL::Exception(msg);
1698           }
1699       }
1700
1701       ARRAY *__rdiv__(PyObject *obj)
1702       {
1703         const char msg[]="Unexpected situation in __rdiv__ !";
1704         INT val;
1705         ARRAY *a;
1706         std::vector<INT> aa;
1707         ARRAY ## Tuple *aaa;
1708         mcIdType sw;
1709         convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa);
1710         switch(sw)
1711           {
1712           case 1:
1713             {
1714               MCAuto<ARRAY> ret=self->deepCopy();
1715               ret->applyInv(val);
1716               return ret.retn();
1717             }
1718           case 2:
1719             {
1720               MCAuto<ARRAY> aaaa=ARRAY::New(); aaaa->useArray(&aa[0],false,DeallocType::CPP_DEALLOC,1,aa.size());
1721               return ARRAY::Divide(aaaa,self);
1722             }
1723           case 4:
1724             {
1725               MCAuto<ARRAY> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
1726               return ARRAY::Divide(aaaa,self);
1727             }
1728           default:
1729             throw INTERP_KERNEL::Exception(msg);
1730           }
1731       }
1732
1733       PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
1734       {
1735         const char msg[]="Unexpected situation in __idiv__ !";
1736         INT val;
1737         ARRAY *a;
1738         std::vector<INT> aa;
1739         ARRAY ## Tuple *aaa;
1740         mcIdType sw;
1741         convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa);
1742         switch(sw)
1743           {
1744           case 1:
1745             {
1746               self->applyDivideBy(val);
1747               Py_XINCREF(trueSelf);
1748               return trueSelf;
1749             }
1750           case 2:
1751             {
1752               MCAuto<ARRAY> bb=ARRAY::New(); bb->useArray(&aa[0],false,DeallocType::CPP_DEALLOC,1,aa.size());
1753               self->divideEqual(bb);
1754               Py_XINCREF(trueSelf);
1755               return trueSelf;
1756             }
1757           case 3:
1758             {
1759               self->divideEqual(a);
1760               Py_XINCREF(trueSelf);
1761               return trueSelf;
1762             }
1763           case 4:
1764             {
1765               MCAuto<ARRAY> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
1766               self->divideEqual(aaaa);
1767               Py_XINCREF(trueSelf);
1768               return trueSelf;
1769             }
1770           default:
1771             throw INTERP_KERNEL::Exception(msg);
1772           }
1773       }
1774
1775       ARRAY *__mod__(PyObject *obj)
1776       {
1777         const char msg[]="Unexpected situation in __mod__ !";
1778         INT val;
1779         ARRAY *a;
1780         std::vector<INT> aa;
1781         ARRAY ## Tuple *aaa;
1782         mcIdType sw;
1783         convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa);
1784         switch(sw)
1785           {
1786           case 1:
1787             {
1788               MCAuto<ARRAY> ret=self->deepCopy();
1789               ret->applyModulus(val);
1790               return ret.retn();
1791             }
1792           case 2:
1793             {
1794               MCAuto<ARRAY> aaaa=ARRAY::New(); aaaa->useArray(&aa[0],false,DeallocType::CPP_DEALLOC,1,aa.size());
1795               return ARRAY::Modulus(self,aaaa);
1796             }
1797           case 3:
1798             {
1799               return ARRAY::Modulus(self,a);
1800             }
1801           case 4:
1802             {
1803               MCAuto<ARRAY> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
1804               return ARRAY::Modulus(self,aaaa);
1805             }
1806           default:
1807             throw INTERP_KERNEL::Exception(msg);
1808           }
1809       }
1810
1811       ARRAY *__rmod__(PyObject *obj)
1812       {
1813         const char msg[]="Unexpected situation in __rmod__ !";
1814         INT val;
1815         ARRAY *a;
1816         std::vector<INT> aa;
1817         ARRAY ## Tuple *aaa;
1818         mcIdType sw;
1819         convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa);
1820         switch(sw)
1821           {
1822           case 1:
1823             {
1824               MCAuto<ARRAY> ret=self->deepCopy();
1825               ret->applyRModulus(val);
1826               return ret.retn();
1827             }
1828           case 2:
1829             {
1830               MCAuto<ARRAY> aaaa=ARRAY::New(); aaaa->useArray(&aa[0],false,DeallocType::CPP_DEALLOC,1,aa.size());
1831               return ARRAY::Modulus(aaaa,self);
1832             }
1833           case 3:
1834             {
1835               return ARRAY::Modulus(a,self);
1836             }
1837           case 4:
1838             {
1839               MCAuto<ARRAY> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
1840               return ARRAY::Modulus(aaaa,self);
1841             }
1842           default:
1843             throw INTERP_KERNEL::Exception(msg);
1844           }
1845       }
1846
1847       PyObject *___imod___(PyObject *trueSelf, PyObject *obj)
1848       {
1849         const char msg[]="Unexpected situation in __imod__ !";
1850         INT val;
1851         ARRAY *a;
1852         std::vector<INT> aa;
1853         ARRAY ## Tuple *aaa;
1854         mcIdType sw;
1855         convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa);
1856         switch(sw)
1857           {
1858           case 1:
1859             {
1860               self->applyModulus(val);
1861               Py_XINCREF(trueSelf);
1862               return trueSelf;
1863             }
1864           case 3:
1865             {
1866               self->modulusEqual(a);
1867               Py_XINCREF(trueSelf);
1868               return trueSelf;
1869             }
1870           case 4:
1871             {
1872               MCAuto<ARRAY> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
1873               self->modulusEqual(aaaa);
1874               Py_XINCREF(trueSelf);
1875               return trueSelf;
1876             }
1877           default:
1878             throw INTERP_KERNEL::Exception(msg);
1879           }
1880       }
1881
1882       ARRAY *__pow__(PyObject *obj)
1883       {
1884         const char msg[]="Unexpected situation in __pow__ !";
1885         INT val;
1886         ARRAY *a;
1887         std::vector<INT> aa;
1888         ARRAY ## Tuple *aaa;
1889         mcIdType sw;
1890         convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa);
1891         switch(sw)
1892           {
1893           case 1:
1894             {
1895               MCAuto<ARRAY> ret=self->deepCopy();
1896               ret->applyPow(val);
1897               return ret.retn();
1898             }
1899           case 2:
1900             {
1901               MCAuto<ARRAY> aaaa=ARRAY::New(); aaaa->useArray(&aa[0],false,DeallocType::CPP_DEALLOC,1,aa.size());
1902               return ARRAY::Pow(self,aaaa);
1903             }
1904           case 3:
1905             {
1906               return ARRAY::Pow(self,a);
1907             }
1908           case 4:
1909             {
1910               MCAuto<ARRAY> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
1911               return ARRAY::Pow(self,aaaa);
1912             }
1913           default:
1914             throw INTERP_KERNEL::Exception(msg);
1915           }
1916       }
1917
1918       ARRAY *__rpow__(PyObject *obj)
1919       {
1920         const char msg[]="Unexpected situation in __rpow__ !";
1921         INT val;
1922         ARRAY *a;
1923         std::vector<INT> aa;
1924         ARRAY ## Tuple *aaa;
1925         mcIdType sw;
1926         convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa);
1927         switch(sw)
1928           {
1929           case 1:
1930             {
1931               MCAuto<ARRAY> ret=self->deepCopy();
1932               ret->applyRPow(val);
1933               return ret.retn();
1934             }
1935           case 2:
1936             {
1937               MCAuto<ARRAY> aaaa=ARRAY::New(); aaaa->useArray(&aa[0],false,DeallocType::CPP_DEALLOC,1,aa.size());
1938               return ARRAY::Pow(aaaa,self);
1939             }
1940           case 3:
1941             {
1942               return ARRAY::Pow(a,self);
1943             }
1944           case 4:
1945             {
1946               MCAuto<ARRAY> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
1947               return ARRAY::Pow(aaaa,self);
1948             }
1949           default:
1950             throw INTERP_KERNEL::Exception(msg);
1951           }
1952       }
1953
1954       PyObject *___ipow___(PyObject *trueSelf, PyObject *obj)
1955       {
1956         const char msg[]="Unexpected situation in __ipow__ !";
1957         INT val;
1958         ARRAY *a;
1959         std::vector<INT> aa;
1960         ARRAY ## Tuple *aaa;
1961         mcIdType sw;
1962         convertIntStarLikePyObjToCpp(obj,sw,val,aa,a,aaa);
1963         switch(sw)
1964           {
1965           case 1:
1966             {
1967               self->applyPow(val);
1968               Py_XINCREF(trueSelf);
1969               return trueSelf;
1970             }
1971           case 3:
1972             {
1973               self->powEqual(a);
1974               Py_XINCREF(trueSelf);
1975               return trueSelf;
1976             }
1977           case 4:
1978             {
1979               MCAuto<ARRAY> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
1980               self->powEqual(aaaa);
1981               Py_XINCREF(trueSelf);
1982               return trueSelf;
1983             }
1984           default:
1985             throw INTERP_KERNEL::Exception(msg);
1986           }
1987       }
1988
1989       std::string __repr__() const
1990       {
1991         std::ostringstream oss;
1992         self->reprQuickOverview(oss);
1993         return oss.str();
1994       }
1995
1996       void pushBackValsSilent(PyObject *li)
1997       {
1998         mcIdType szArr,sw;
1999         INT iTypppArr;
2000         std::vector<INT> stdvecTyyppArr;
2001         const INT *tmp=convertIntStarLikePyObjToCppIntStar(li,sw,szArr,iTypppArr,stdvecTyyppArr);
2002         self->pushBackValsSilent(tmp,tmp+szArr);
2003       }
2004
2005       PyObject *partitionByDifferentValues() const
2006       {
2007         std::vector<INT> ret1;
2008         std::vector<DataArrayIdType *> ret0=self->partitionByDifferentValues(ret1);
2009         std::size_t sz=ret0.size();
2010         PyObject *pyRet=PyTuple_New(2);
2011         PyObject *pyRet0=PyList_New((INT)sz);
2012         PyObject *pyRet1=PyList_New((INT)sz);
2013         for(std::size_t i=0;i<sz;i++)
2014           {
2015             PyList_SetItem(pyRet0,i,SWIG_NewPointerObj(SWIG_as_voidptr(ret0[i]),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2016             PyList_SetItem(pyRet1,i,PyInt_FromLong(ret1[i]));
2017           }
2018         PyTuple_SetItem(pyRet,0,pyRet0);
2019         PyTuple_SetItem(pyRet,1,pyRet1);
2020         return pyRet;
2021       }
2022
2023       DataArrayIdType *locateComponentId(const ARRAY *valToSearchIntoTuples, const DataArrayIdType *tupleIdHint) const
2024       {
2025         return self->locateComponentId(valToSearchIntoTuples,tupleIdHint);
2026       }
2027
2028       PyObject *findIdsRangesInListOfIds(const ARRAY *listOfIds) const
2029       {
2030         DataArrayIdType *ret0=0;
2031         ARRAY *ret1=0;
2032         self->findIdsRangesInListOfIds(listOfIds,ret0,ret1);
2033         PyObject *pyRet=PyTuple_New(2);
2034         PyTuple_SetItem(pyRet,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2035         PyTuple_SetItem(pyRet,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits<INT>::TI, SWIG_POINTER_OWN | 0 ));
2036         return pyRet;
2037       }
2038
2039       PyObject *forThisAsPartitionBuildReduction(DataArrayIdType *commonEntities, DataArrayIdType *commonEntitiesIndex) const
2040       {
2041         MCAuto<DataArrayIdType> ceCpp( MCAuto<DataArrayIdType>::TakeRef(commonEntities) );
2042         MCAuto<DataArrayIdType> ceiCpp( MCAuto<DataArrayIdType>::TakeRef(commonEntitiesIndex) );
2043         MCAuto<ARRAY> ret1;
2044         MCAuto<DataArrayIdType> ret2;
2045         MCAuto<ARRAY> ret0 = self->forThisAsPartitionBuildReduction(ceCpp,ceiCpp,ret1,ret2);
2046         PyObject *pyRet( PyTuple_New(3) );
2047         PyTuple_SetItem(pyRet,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0.retn()),SWIGTITraits<INT>::TI, SWIG_POINTER_OWN | 0 ));
2048         PyTuple_SetItem(pyRet,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1.retn()),SWIGTITraits<INT>::TI, SWIG_POINTER_OWN | 0 ));
2049         PyTuple_SetItem(pyRet,2,SWIG_NewPointerObj(SWIG_as_voidptr(ret2.retn()),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2050         return pyRet;
2051       }
2052
2053       PyObject *isRange() const
2054       {
2055         INT a(0),b(0),c(0);
2056         bool ret(self->isRange(a,b,c));
2057         PyObject *pyRet=PyTuple_New(2);
2058         PyObject *ret0Py=ret?Py_True:Py_False,*ret1Py(0);
2059         Py_XINCREF(ret0Py);
2060         PyTuple_SetItem(pyRet,0,ret0Py);
2061         if(ret)
2062           ret1Py=PySlice_New(PyInt_FromLong(a),PyInt_FromLong(b),PyInt_FromLong(c));
2063         else
2064           {
2065             ret1Py=Py_None;
2066             Py_XINCREF(ret1Py);
2067           }
2068         PyTuple_SetItem(pyRet,1,ret1Py);
2069         return pyRet;
2070       }
2071
2072       static bool RemoveIdsFromIndexedArrays(PyObject *li, ARRAY *arr, DataArrayIdType *arrIndx, mcIdType offsetForRemoval=0) throw(INTERP_KERNEL::Exception)
2073       {
2074         mcIdType sw;
2075         INT singleVal;
2076         std::vector<INT> multiVal;
2077         std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2078         MEDCoupling::ARRAY *daIntTyypp=0;
2079         if(!arrIndx)
2080           throw INTERP_KERNEL::Exception("ARRAY::RemoveIdsFromIndexedArrays : null pointer as arrIndex !");
2081         convertIntStarOrSliceLikePyObjToCpp(li,arrIndx->getNumberOfTuples()-1,sw,singleVal,multiVal,slic,daIntTyypp);
2082         switch(sw)
2083           {
2084           case 1:
2085             return ARRAY::RemoveIdsFromIndexedArrays(&singleVal,&singleVal+1,arr,arrIndx,offsetForRemoval);
2086           case 2:
2087             return ARRAY::RemoveIdsFromIndexedArrays(&multiVal[0],&multiVal[0]+multiVal.size(),arr,arrIndx,offsetForRemoval);
2088           case 4:
2089             return ARRAY::RemoveIdsFromIndexedArrays(daIntTyypp->begin(),daIntTyypp->end(),arr,arrIndx,offsetForRemoval);
2090           default:
2091             throw INTERP_KERNEL::Exception("MEDCouplingUMesh::RemoveIdsFromIndexedArrays : unrecognized type entered, expected list of int, tuple of int or ARRAY !");
2092           }
2093       }
2094
2095       PyObject *findCommonTuples(mcIdType limitNodeId=-1) const
2096       {
2097         MCAuto<DataArrayIdType> comm,commIndex;
2098         self->findCommonTuples(limitNodeId,comm,commIndex);
2099         PyObject *res = PyList_New(2);
2100         PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(comm.retn()),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2101         PyList_SetItem(res,1,SWIG_NewPointerObj(SWIG_as_voidptr(commIndex.retn()),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2102         return res;
2103       }
2104
2105       static PyObject *ExtractFromIndexedArrays(PyObject *li, const ARRAY *arrIn, const DataArrayIdType *arrIndxIn) throw(INTERP_KERNEL::Exception)
2106       {
2107         ARRAY *arrOut=0;
2108         DataArrayIdType *arrIndexOut=0;
2109         mcIdType sw;
2110         mcIdType singleVal;
2111         std::vector<mcIdType> multiVal;
2112         std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2113         MEDCoupling::DataArrayIdType *daIntTyypp=0;
2114         if(!arrIndxIn)
2115           throw INTERP_KERNEL::Exception("ARRAY::ExtractFromIndexedArrays : null pointer as arrIndxIn !");
2116         convertIntStarOrSliceLikePyObjToCpp(li,arrIndxIn->getNumberOfTuples()-1,sw,singleVal,multiVal,slic,daIntTyypp);
2117         switch(sw)
2118           {
2119           case 1:
2120             {
2121               ARRAY::ExtractFromIndexedArrays(&singleVal,&singleVal+1,arrIn,arrIndxIn,arrOut,arrIndexOut);
2122               break;
2123             }
2124           case 2:
2125             {
2126               ARRAY::ExtractFromIndexedArrays(&multiVal[0],&multiVal[0]+multiVal.size(),arrIn,arrIndxIn,arrOut,arrIndexOut);
2127               break;
2128             }
2129           case 4:
2130             {
2131               ARRAY::ExtractFromIndexedArrays(daIntTyypp->begin(),daIntTyypp->end(),arrIn,arrIndxIn,arrOut,arrIndexOut);
2132               break;
2133             }
2134           default:
2135             throw INTERP_KERNEL::Exception("ARRAY::ExtractFromIndexedArrays : unrecognized type entered, expected list of int, tuple of int or ARRAY !");
2136           }
2137         PyObject *ret=PyTuple_New(2);
2138         PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(arrOut),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2139         PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(arrIndexOut),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2140         return ret;
2141       }
2142
2143       static PyObject *ExtractFromIndexedArraysSlice(mcIdType strt, mcIdType stp, mcIdType step, const ARRAY *arrIn, const DataArrayIdType *arrIndxIn) throw(INTERP_KERNEL::Exception)
2144       {
2145         ARRAY *arrOut=0;
2146         DataArrayIdType *arrIndexOut=0;
2147         ARRAY::ExtractFromIndexedArraysSlice(strt,stp,step,arrIn,arrIndxIn,arrOut,arrIndexOut);
2148         PyObject *ret=PyTuple_New(2);
2149         PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(arrOut),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2150         PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(arrIndexOut),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2151         return ret;
2152       }
2153
2154       static PyObject *ExtractFromIndexedArraysSlice(PyObject *slic, const ARRAY *arrIn, const DataArrayIdType *arrIndxIn) throw(INTERP_KERNEL::Exception)
2155       {
2156         if(!PySlice_Check(slic))
2157           throw INTERP_KERNEL::Exception("ExtractFromIndexedArraysSlice (wrap) : the first param is not a pyslice !");
2158         Py_ssize_t strt=2,stp=2,step=2;
2159         if(!arrIndxIn)
2160           throw INTERP_KERNEL::Exception("ExtractFromIndexedArraysSlice (wrap) : last array is null !");
2161         arrIndxIn->checkAllocated();
2162         if(arrIndxIn->getNumberOfComponents()!=1)
2163           throw INTERP_KERNEL::Exception("ExtractFromIndexedArraysSlice (wrap) : number of components of last argument must be equal to one !");
2164         GetIndicesOfSlice(slic,arrIndxIn->getNumberOfTuples(),&strt,&stp,&step,"ExtractFromIndexedArraysSlice (wrap) : Invalid slice regarding nb of elements !");
2165         ARRAY *arrOut=0;
2166         DataArrayIdType *arrIndexOut=0;
2167         ARRAY::ExtractFromIndexedArraysSlice(ToIdType(strt),ToIdType(stp),ToIdType(step),arrIn,arrIndxIn,arrOut,arrIndexOut);
2168         PyObject *ret=PyTuple_New(2);
2169         PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(arrOut),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2170         PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(arrIndexOut),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2171         return ret;
2172       }
2173
2174       static PyObject *SetPartOfIndexedArrays(PyObject *li,
2175                                               const ARRAY *arrIn, const DataArrayIdType *arrIndxIn,
2176                                               const ARRAY *srcArr, const DataArrayIdType *srcArrIndex) throw(INTERP_KERNEL::Exception)
2177       {
2178         ARRAY *arrOut=0;
2179         DataArrayIdType *arrIndexOut=0;
2180         mcIdType sw;
2181         mcIdType singleVal;
2182         std::vector<mcIdType> multiVal;
2183         std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2184         MEDCoupling::DataArrayIdType *daIntTyypp=0;
2185         if(!arrIndxIn)
2186           throw INTERP_KERNEL::Exception("ARRAY::SetPartOfIndexedArrays : null pointer as arrIndex !");
2187         convertIntStarOrSliceLikePyObjToCpp(li,arrIndxIn->getNumberOfTuples()-1,sw,singleVal,multiVal,slic,daIntTyypp);
2188         switch(sw)
2189           {
2190           case 1:
2191             {
2192               ARRAY::SetPartOfIndexedArrays(&singleVal,&singleVal+1,arrIn,arrIndxIn,srcArr,srcArrIndex,arrOut,arrIndexOut);
2193               break;
2194             }
2195           case 2:
2196             {
2197               ARRAY::SetPartOfIndexedArrays(&multiVal[0],&multiVal[0]+multiVal.size(),arrIn,arrIndxIn,srcArr,srcArrIndex,arrOut,arrIndexOut);
2198               break;
2199             }
2200           case 4:
2201             {
2202               ARRAY::SetPartOfIndexedArrays(daIntTyypp->begin(),daIntTyypp->end(),arrIn,arrIndxIn,srcArr,srcArrIndex,arrOut,arrIndexOut);
2203               break;
2204             }
2205           default:
2206             throw INTERP_KERNEL::Exception("ARRAY::SetPartOfIndexedArrays : unrecognized type entered, expected list of int, tuple of int or ARRAY !");
2207           }
2208         PyObject *ret=PyTuple_New(2);
2209         PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(arrOut),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2210         PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(arrIndexOut),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2211         return ret;
2212       }
2213
2214       static void SetPartOfIndexedArraysSameIdx(PyObject *li, ARRAY *arrIn, const DataArrayIdType *arrIndxIn,
2215                                                 const ARRAY *srcArr, const DataArrayIdType *srcArrIndex) throw(INTERP_KERNEL::Exception)
2216       {
2217         mcIdType sw;
2218         mcIdType singleVal;
2219         std::vector<mcIdType> multiVal;
2220         std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2221         MEDCoupling::DataArrayIdType *daIntTyypp=0;
2222         if(!arrIndxIn)
2223           throw INTERP_KERNEL::Exception("ARRAY::SetPartOfIndexedArraysSameIdx : null pointer as arrIndex !");
2224         convertIntStarOrSliceLikePyObjToCpp(li,arrIndxIn->getNumberOfTuples()-1,sw,singleVal,multiVal,slic,daIntTyypp);
2225         switch(sw)
2226           {
2227           case 1:
2228             {
2229               ARRAY::SetPartOfIndexedArraysSameIdx(&singleVal,&singleVal+1,arrIn,arrIndxIn,srcArr,srcArrIndex);
2230               break;
2231             }
2232           case 2:
2233             {
2234               ARRAY::SetPartOfIndexedArraysSameIdx(&multiVal[0],&multiVal[0]+multiVal.size(),arrIn,arrIndxIn,srcArr,srcArrIndex);
2235               break;
2236             }
2237           case 4:
2238             {
2239               ARRAY::SetPartOfIndexedArraysSameIdx(daIntTyypp->begin(),daIntTyypp->end(),arrIn,arrIndxIn,srcArr,srcArrIndex);
2240               break;
2241             }
2242           default:
2243             throw INTERP_KERNEL::Exception("ARRAY::SetPartOfIndexedArraysSameIdx : unrecognized type entered, expected list of int, tuple of int or ARRAY !");
2244           }
2245       }
2246
2247     } // end extent
2248   };
2249
2250   class ARRAY ## Tuple;
2251
2252   class ARRAY ## Iterator
2253   {
2254   public:
2255     ARRAY ## Iterator(ARRAY *da);
2256     ~ARRAY ## Iterator();
2257     %extend
2258     {
2259       PyObject *next()
2260       {
2261         ARRAY ## Tuple *ret=self->nextt();
2262         if(ret)
2263           return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__ ## ARRAY ## Tuple,SWIG_POINTER_OWN | 0);
2264         else
2265           {
2266             PyErr_SetString(PyExc_StopIteration,"No more data.");
2267             return 0;
2268           }
2269       }
2270     }
2271   };
2272
2273   class ARRAY ## Tuple
2274   {
2275   public:
2276     std::size_t getNumberOfCompo() const;
2277     ARRAY *buildDAInt(INT nbOfTuples, INT nbOfCompo) const;
2278     %extend
2279     {
2280       std::string __str__() const
2281       {
2282         return self->repr();
2283       }
2284
2285       INT __int__() const
2286       {
2287         return self->intValue();
2288       }
2289
2290       ARRAY *buildDAInt()
2291       {
2292         return self->buildDAInt(1,self->getNumberOfCompo());
2293       }
2294
2295       PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
2296       {
2297         MCAuto<ARRAY> ret=self->buildDAInt(1,self->getNumberOfCompo());
2298         MEDCoupling_ ## ARRAY ## ____iadd___(ret,0,obj);
2299         Py_XINCREF(trueSelf);
2300         return trueSelf;
2301       }
2302
2303       PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
2304       {
2305         MCAuto<ARRAY> ret=self->buildDAInt(1,self->getNumberOfCompo());
2306         MEDCoupling_ ## ARRAY ## ____isub___(ret,0,obj);
2307         Py_XINCREF(trueSelf);
2308         return trueSelf;
2309       }
2310
2311       PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
2312       {
2313         MCAuto<ARRAY> ret=self->buildDAInt(1,self->getNumberOfCompo());
2314         MEDCoupling_ ## ARRAY ## ____imul___(ret,0,obj);
2315         Py_XINCREF(trueSelf);
2316         return trueSelf;
2317       }
2318       PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
2319       {
2320         MCAuto<ARRAY> ret=self->buildDAInt(1,self->getNumberOfCompo());
2321         MEDCoupling_ ## ARRAY ## ____idiv___(ret,0,obj);
2322         Py_XINCREF(trueSelf);
2323         return trueSelf;
2324       }
2325
2326       PyObject *___imod___(PyObject *trueSelf, PyObject *obj)
2327       {
2328         MCAuto<ARRAY> ret=self->buildDAInt(1,self->getNumberOfCompo());
2329         MEDCoupling_ ## ARRAY ## ____imod___(ret,0,obj);
2330         Py_XINCREF(trueSelf);
2331         return trueSelf;
2332       }
2333
2334       PyObject *__len__()
2335       {
2336         return PyInt_FromLong(self->getNumberOfCompo());
2337       }
2338
2339       PyObject *__getitem__(PyObject *obj)
2340       {
2341         const char msg2[]="ARRAY ## Tuple::__getitem__ : Mismatch of slice values in 2nd parameter (components) !";
2342         mcIdType sw;
2343         INT singleVal;
2344         std::vector<INT> multiVal;
2345         std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2346         MEDCoupling::DataArrayIdType *daIntTyypp=0;
2347         const INT *pt=self->getConstPointer();
2348         INT nbc=(INT)self->getNumberOfCompo();
2349         convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,ToIdType(nbc),sw,singleVal,multiVal,slic,daIntTyypp);
2350         switch(sw)
2351           {
2352           case 1:
2353             {
2354               if(singleVal>=(INT)nbc)
2355                 {
2356                   std::ostringstream oss;
2357                   oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2358                   PyErr_SetString(PyExc_StopIteration,oss.str().c_str());
2359                   return 0;
2360                 }
2361               if(singleVal>=0)
2362                 return PyInt_FromLong(pt[singleVal]);
2363               else
2364                 {
2365                   if(nbc+singleVal>0)
2366                     return PyInt_FromLong(pt[nbc+singleVal]);
2367                   else
2368                     {
2369                       std::ostringstream oss;
2370                       oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2371                       throw INTERP_KERNEL::Exception(oss.str().c_str());
2372                     }
2373                 }
2374             }
2375           case 2:
2376             {
2377               PyObject *t=PyTuple_New(multiVal.size());
2378               for(std::size_t j=0;j<multiVal.size();j++)
2379                 {
2380                   INT cid=multiVal[j];
2381                   if(cid>=(INT)nbc)
2382                     {
2383                       std::ostringstream oss;
2384                       oss << "Requesting for id #" << cid << " having only " << nbc << " components !";
2385                       throw INTERP_KERNEL::Exception(oss.str().c_str());
2386                     }
2387                   PyTuple_SetItem(t,j,PyInt_FromLong(pt[cid]));
2388                 }
2389               return t;
2390             }
2391           case 3:
2392             {
2393               mcIdType sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2394               PyObject *t=PyTuple_New(sz);
2395               for(INT j=0;j<sz;j++)
2396                 PyTuple_SetItem(t,j,PyInt_FromLong(pt[slic.first+j*slic.second.second]));
2397               return t;
2398             }
2399           default:
2400             throw INTERP_KERNEL::Exception("ARRAY ## Tuple::__getitem__ : unrecognized type entered !");
2401           }
2402       }
2403
2404       ARRAY ## Tuple *__setitem__(PyObject *obj, PyObject *value)
2405       {
2406         const char msg[]="DataArrayIntTuple::__setitem__ : unrecognized type entered, int, slice, list<int>, tuple<int> !";
2407         const char msg2[]="DataArrayIntTuple::__setitem__ : Mismatch of slice values in 2nd parameter (components) !";
2408         mcIdType sw1,sw2;
2409         mcIdType singleValV;
2410         std::vector<mcIdType> multiValV;
2411         std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slicV;
2412         MEDCoupling::ARRAY ## Tuple *daIntTyyppV=0;
2413         mcIdType nbc=ToIdType(self->getNumberOfCompo());
2414         convertObjToPossibleCpp22<INT>(value,nbc,sw1,singleValV,multiValV,slicV,daIntTyyppV);
2415         INT singleVal;
2416         std::vector<INT> multiVal;
2417         std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2418         MEDCoupling::ARRAY *daIntTyypp=0;
2419         INT *pt=self->getPointer();
2420         convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbc,sw2,singleVal,multiVal,slic,daIntTyypp);
2421         switch(sw2)
2422           {
2423           case 1:
2424             {
2425               if(singleVal>=nbc)
2426                 {
2427                   std::ostringstream oss;
2428                   oss << "Requesting for setting id # " << singleVal << " having only " << nbc << " components !";
2429                   throw INTERP_KERNEL::Exception(oss.str().c_str());
2430                 }
2431               switch(sw1)
2432                 {
2433                 case 1:
2434                   {
2435                     pt[singleVal]=(INT)singleValV;
2436                     return self;
2437                   }
2438                 case 2:
2439                   {
2440                     if(multiValV.size()!=1)
2441                       {
2442                         std::ostringstream oss;
2443                         oss << "Requesting for setting id # " << singleVal << " with a list or tuple with size != 1 ! ";
2444                         throw INTERP_KERNEL::Exception(oss.str().c_str());
2445                       }
2446                     pt[singleVal]=(INT)multiValV[0];
2447                     return self;
2448                   }
2449                 case 4:
2450                   {
2451                     pt[singleVal]=daIntTyyppV->getConstPointer()[0];
2452                     return self;
2453                   }
2454                 default:
2455                   throw INTERP_KERNEL::Exception(msg);
2456                 }
2457             }
2458           case 2:
2459             {
2460               switch(sw1)
2461                 {
2462                 case 1:
2463                   {
2464                     for(std::vector<INT>::const_iterator it=multiVal.begin();it!=multiVal.end();it++)
2465                       {
2466                         if(*it>=nbc)
2467                           {
2468                             std::ostringstream oss;
2469                             oss << "Requesting for setting id # " << *it << " having only " << nbc << " components !";
2470                             throw INTERP_KERNEL::Exception(oss.str().c_str());
2471                           }
2472                         pt[*it]=(INT)singleValV;
2473                       }
2474                     return self;
2475                   }
2476                 case 2:
2477                   {
2478                     if(multiVal.size()!=multiValV.size())
2479                       {
2480                         std::ostringstream oss;
2481                         oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << multiVal.size() << " !";
2482                         throw INTERP_KERNEL::Exception(oss.str().c_str());
2483                       }
2484                     for(INT i=0;i<(INT)multiVal.size();i++)
2485                       {
2486                         INT pos=multiVal[i];
2487                         if(pos>=nbc)
2488                           {
2489                             std::ostringstream oss;
2490                             oss << "Requesting for setting id # " << pos << " having only " << nbc << " components !";
2491                             throw INTERP_KERNEL::Exception(oss.str().c_str());
2492                           }
2493                         pt[multiVal[i]]=(INT)multiValV[i];
2494                       }
2495                     return self;
2496                   }
2497                 case 4:
2498                   {
2499                     const INT *ptV=daIntTyyppV->getConstPointer();
2500                     if(nbc>(INT)daIntTyyppV->getNumberOfCompo())
2501                       {
2502                         std::ostringstream oss;
2503                         oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2504                         throw INTERP_KERNEL::Exception(oss.str().c_str());
2505                       }
2506                     std::copy(ptV,ptV+nbc,pt);
2507                     return self;
2508                   }
2509                 default:
2510                   throw INTERP_KERNEL::Exception(msg);
2511                 }
2512             }
2513           case 3:
2514             {
2515               std::size_t sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2516               switch(sw1)
2517                 {
2518                 case 1:
2519                   {
2520                     for(std::size_t j=0;j<sz;j++)
2521                       pt[slic.first+j*slic.second.second]=(INT)singleValV;
2522                     return self;
2523                   }
2524                 case 2:
2525                   {
2526                     if(sz!=multiValV.size())
2527                       {
2528                         std::ostringstream oss;
2529                         oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << sz << " !";
2530                         throw INTERP_KERNEL::Exception(oss.str().c_str());
2531                       }
2532                     for(std::size_t j=0;j<sz;j++)
2533                       pt[slic.first+j*slic.second.second]=(INT)multiValV[j];
2534                     return self;
2535                   }
2536                 case 4:
2537                   {
2538                     const INT *ptV=daIntTyyppV->getConstPointer();
2539                     if(sz>daIntTyyppV->getNumberOfCompo())
2540                       {
2541                         std::ostringstream oss;
2542                         oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2543                         throw INTERP_KERNEL::Exception(oss.str().c_str());
2544                       }
2545                     for(std::size_t j=0;j<sz;j++)
2546                       pt[slic.first+j*slic.second.second]=ptV[j];
2547                     return self;
2548                   }
2549                 default:
2550                   throw INTERP_KERNEL::Exception(msg);
2551                 }
2552             }
2553           default:
2554             throw INTERP_KERNEL::Exception(msg);
2555           }
2556       }
2557     }
2558 //   };
2559 // }
2560 %enddef
2561
2562
2563 %define TRANSFORMWITHINDARR( ARRAY, INT )
2564 void transformWithIndArr(PyObject *li)
2565 {
2566   void *da=0;
2567   int res1(SWIG_ConvertPtr(li,&da,SWIGTITraits<INT>::TI, 0 |  0 ));
2568   if (!SWIG_IsOK(res1))
2569     {
2570       int res2(SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__MapII, 0 |  0 ));
2571       if(SWIG_IsOK(res2))
2572         {
2573           MapII *m=reinterpret_cast<MapII *>(da);
2574           self->transformWithIndArr(*m);
2575         }
2576       else
2577         {
2578           mcIdType size;
2579           INTERP_KERNEL::AutoPtr<INT> tmp=convertPyToNewIntArr2<INT>(li,&size);
2580           self->transformWithIndArr(tmp,tmp+size);
2581         }
2582     }
2583   else
2584     {
2585       ARRAY *da2=reinterpret_cast< ARRAY * >(da);
2586       self->transformWithIndArr(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
2587     }
2588 }
2589 %enddef
2590
2591 namespace MEDCoupling
2592 {
2593   typedef int      Int32;
2594 #ifdef WIN32
2595   typedef long long Int64;
2596 #else
2597   typedef long int  Int64;
2598 #endif
2599
2600   class DataArrayInt32Iterator;
2601
2602   class DataArrayInt32 : public DataArray
2603   {
2604     ARRAYDEF( DataArrayInt32, Int32 )
2605   };
2606   %extend DataArrayInt32 {
2607     DataArrayInt64 *convertToInt64Arr() const
2608     {
2609       MCAuto<DataArrayInt64> ret(self->convertToInt64Arr());
2610       return ret.retn();
2611     }
2612 #ifdef WITH_NUMPY
2613     PyObject *toNumPyArray() // not const. It is not a bug !
2614     {
2615       return ToNumPyArray<DataArrayInt32,MEDCoupling::Int32>(self,NPY_INT32,"DataArrayInt32");
2616     }
2617 #endif
2618 #ifndef MEDCOUPLING_USE_64BIT_IDS
2619     MCAuto< MapII > invertArrayN2O2O2NOptimized()
2620     {
2621       return self->invertArrayN2O2O2NOptimized();
2622     }
2623     MCAuto< MapII > giveN2OOptimized()
2624     {
2625       return self->giveN2OOptimized();
2626     }
2627     TRANSFORMWITHINDARR( DataArrayInt32, Int32 )
2628 #endif
2629   };
2630
2631   class DataArrayInt64Iterator;
2632
2633   class DataArrayInt64 : public DataArray
2634   {
2635     ARRAYDEF( DataArrayInt64, Int64 )
2636   };
2637   %extend DataArrayInt64 {
2638     DataArrayInt32 *convertToInt32Arr() const
2639     {
2640       MCAuto<DataArrayInt32> ret(self->convertToInt32Arr());
2641       return ret.retn();
2642     }
2643 #ifdef WITH_NUMPY
2644     PyObject *toNumPyArray() // not const. It is not a bug !
2645     {
2646       return ToNumPyArray<DataArrayInt64,MEDCoupling::Int64>(self,NPY_INT64,"DataArrayInt64");
2647     }
2648 #endif
2649 #ifdef MEDCOUPLING_USE_64BIT_IDS
2650     MCAuto< MapII > invertArrayN2O2O2NOptimized()
2651     {
2652       return self->invertArrayN2O2O2NOptimized();
2653     }
2654     MCAuto< MapII > giveN2OOptimized()
2655     {
2656       return self->giveN2OOptimized();
2657     }
2658     TRANSFORMWITHINDARR( DataArrayInt64, Int64 )
2659 #endif
2660   };
2661
2662 }