src/MEDCoupling_Swig/MEDCouplingMemArray.i

   1 // Copyright (C) 2007-2015  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19 // Author : Anthony Geay (CEA/DEN)
  20
  21 ////////////////////
  22 %typemap(out) MEDCoupling::DataArray*
  23 {
  24   $result=convertDataArray($1,$owner);
  25 }
  26
  27 %typemap(out) DataArray*
  28 {
  29   $result=convertDataArray($1,$owner);
  30 }
  31 //$$$$$$$$$$$$$$$$$$
  32
  33 ////////////////////
  34 %typemap(out) MEDCoupling::DataArrayChar*
  35 {
  36   $result=convertDataArrayChar($1,$owner);
  37 }
  38
  39 %typemap(out) DataArrayChar*
  40 {
  41   $result=convertDataArrayChar($1,$owner);
  42 }
  43 //$$$$$$$$$$$$$$$$$$
  44
  45 %newobject MEDCoupling::DataArray::deepCopy;
  46 %newobject MEDCoupling::DataArray::selectByTupleRanges;
  47 %newobject MEDCoupling::DataArray::selectByTupleId;
  48 %newobject MEDCoupling::DataArray::selectByTupleIdSafe;
  49 %newobject MEDCoupling::DataArray::selectByTupleIdSafeSlice;
  50 %newobject MEDCoupling::DataArray::Aggregate;
  51 %newobject MEDCoupling::DataArrayInt::New;
  52 %newobject MEDCoupling::DataArrayInt::__iter__;
  53 %newobject MEDCoupling::DataArrayInt::convertToDblArr;
  54 %newobject MEDCoupling::DataArrayInt::performCopyOrIncrRef;
  55 %newobject MEDCoupling::DataArrayInt::subArray;
  56 %newobject MEDCoupling::DataArrayInt::changeNbOfComponents;
  57 %newobject MEDCoupling::DataArrayInt::accumulatePerChunck;
  58 %newobject MEDCoupling::DataArrayInt::checkAndPreparePermutation;
  59 %newobject MEDCoupling::DataArrayInt::transformWithIndArrR;
  60 %newobject MEDCoupling::DataArrayInt::renumber;
  61 %newobject MEDCoupling::DataArrayInt::renumberR;
  62 %newobject MEDCoupling::DataArrayInt::renumberAndReduce;
  63 %newobject MEDCoupling::DataArrayInt::invertArrayO2N2N2O;
  64 %newobject MEDCoupling::DataArrayInt::invertArrayN2O2O2N;
  65 %newobject MEDCoupling::DataArrayInt::invertArrayO2N2N2OBis;
  66 %newobject MEDCoupling::DataArrayInt::findIdsEqual;
  67 %newobject MEDCoupling::DataArrayInt::findIdsNotEqual;
  68 %newobject MEDCoupling::DataArrayInt::findIdsEqualList;
  69 %newobject MEDCoupling::DataArrayInt::findIdsNotEqualList;
  70 %newobject MEDCoupling::DataArrayInt::findIdsEqualTuple;
  71 %newobject MEDCoupling::DataArrayInt::sumPerTuple;
  72 %newobject MEDCoupling::DataArrayInt::negate;
  73 %newobject MEDCoupling::DataArrayInt::computeAbs;
  74 %newobject MEDCoupling::DataArrayInt::findIdsInRange;
  75 %newobject MEDCoupling::DataArrayInt::findIdsNotInRange;
  76 %newobject MEDCoupling::DataArrayInt::findIdsStricltyNegative;
  77 %newobject MEDCoupling::DataArrayInt::Aggregate;
  78 %newobject MEDCoupling::DataArrayInt::AggregateIndexes;
  79 %newobject MEDCoupling::DataArrayInt::Meld;
  80 %newobject MEDCoupling::DataArrayInt::Add;
  81 %newobject MEDCoupling::DataArrayInt::Substract;
  82 %newobject MEDCoupling::DataArrayInt::Multiply;
  83 %newobject MEDCoupling::DataArrayInt::Divide;
  84 %newobject MEDCoupling::DataArrayInt::Pow;
  85 %newobject MEDCoupling::DataArrayInt::BuildUnion;
  86 %newobject MEDCoupling::DataArrayInt::BuildIntersection;
  87 %newobject MEDCoupling::DataArrayInt::Range;
  88 %newobject MEDCoupling::DataArrayInt::fromNoInterlace;
  89 %newobject MEDCoupling::DataArrayInt::toNoInterlace;
  90 %newobject MEDCoupling::DataArrayInt::buildComplement;
  91 %newobject MEDCoupling::DataArrayInt::buildUnion;
  92 %newobject MEDCoupling::DataArrayInt::buildSubstraction;
  93 %newobject MEDCoupling::DataArrayInt::buildSubstractionOptimized;
  94 %newobject MEDCoupling::DataArrayInt::buildIntersection;
  95 %newobject MEDCoupling::DataArrayInt::buildUnique;
  96 %newobject MEDCoupling::DataArrayInt::buildUniqueNotSorted;
  97 %newobject MEDCoupling::DataArrayInt::deltaShiftIndex;
  98 %newobject MEDCoupling::DataArrayInt::buildExplicitArrByRanges;
  99 %newobject MEDCoupling::DataArrayInt::buildExplicitArrOfSliceOnScaledArr;
 100 %newobject MEDCoupling::DataArrayInt::findRangeIdForEachTuple;
 101 %newobject MEDCoupling::DataArrayInt::findIdInRangeForEachTuple;
 102 %newobject MEDCoupling::DataArrayInt::duplicateEachTupleNTimes;
 103 %newobject MEDCoupling::DataArrayInt::buildPermutationArr;
 104 %newobject MEDCoupling::DataArrayInt::buildPermArrPerLevel;
 105 %newobject MEDCoupling::DataArrayInt::getDifferentValues;
 106 %newobject MEDCoupling::DataArrayInt::FindPermutationFromFirstToSecond;
 107 %newobject MEDCoupling::DataArrayInt::CheckAndPreparePermutation;
 108 %newobject MEDCoupling::DataArrayInt::__neg__;
 109 %newobject MEDCoupling::DataArrayInt::__add__;
 110 %newobject MEDCoupling::DataArrayInt::__radd__;
 111 %newobject MEDCoupling::DataArrayInt::__sub__;
 112 %newobject MEDCoupling::DataArrayInt::__rsub__;
 113 %newobject MEDCoupling::DataArrayInt::__mul__;
 114 %newobject MEDCoupling::DataArrayInt::__rmul__;
 115 %newobject MEDCoupling::DataArrayInt::__div__;
 116 %newobject MEDCoupling::DataArrayInt::__rdiv__;
 117 %newobject MEDCoupling::DataArrayInt::__mod__;
 118 %newobject MEDCoupling::DataArrayInt::__rmod__;
 119 %newobject MEDCoupling::DataArrayInt::__pow__;
 120 %newobject MEDCoupling::DataArrayInt::__rpow__;
 121 %newobject MEDCoupling::DataArrayIntTuple::buildDAInt;
 122 %newobject MEDCoupling::DataArrayChar::convertToIntArr;
 123 %newobject MEDCoupling::DataArrayChar::renumber;
 124 %newobject MEDCoupling::DataArrayChar::renumberR;
 125 %newobject MEDCoupling::DataArrayChar::renumberAndReduce;
 126 %newobject MEDCoupling::DataArrayChar::changeNbOfComponents;
 127 %newobject MEDCoupling::DataArrayChar::findIdsEqual;
 128 %newobject MEDCoupling::DataArrayChar::findIdsNotEqual;
 129 %newobject MEDCoupling::DataArrayChar::Aggregate;
 130 %newobject MEDCoupling::DataArrayChar::Meld;
 131 %newobject MEDCoupling::DataArrayByte::New;
 132 %newobject MEDCoupling::DataArrayByte::__iter__;
 133 %newobject MEDCoupling::DataArrayByte::performCopyOrIncrRef;
 134 %newobject MEDCoupling::DataArrayByteTuple::buildDAByte;
 135 %newobject MEDCoupling::DataArrayChar::subArray;
 136 %newobject MEDCoupling::DataArrayAsciiChar::New;
 137 %newobject MEDCoupling::DataArrayAsciiChar::__iter__;
 138 %newobject MEDCoupling::DataArrayAsciiChar::performCopyOrIncrRef;
 139 %newobject MEDCoupling::DataArrayAsciiCharTuple::buildDAAsciiChar;
 140 %newobject MEDCoupling::DataArrayDouble::New;
 141 %newobject MEDCoupling::DataArrayDouble::__iter__;
 142 %newobject MEDCoupling::DataArrayDouble::convertToIntArr;
 143 %newobject MEDCoupling::DataArrayDouble::performCopyOrIncrRef;
 144 %newobject MEDCoupling::DataArrayDouble::Aggregate;
 145 %newobject MEDCoupling::DataArrayDouble::Meld;
 146 %newobject MEDCoupling::DataArrayDouble::Dot;
 147 %newobject MEDCoupling::DataArrayDouble::CrossProduct;
 148 %newobject MEDCoupling::DataArrayDouble::Add;
 149 %newobject MEDCoupling::DataArrayDouble::Substract;
 150 %newobject MEDCoupling::DataArrayDouble::Multiply;
 151 %newobject MEDCoupling::DataArrayDouble::Divide;
 152 %newobject MEDCoupling::DataArrayDouble::Pow;
 153 %newobject MEDCoupling::DataArrayDouble::subArray;
 154 %newobject MEDCoupling::DataArrayDouble::changeNbOfComponents;
 155 %newobject MEDCoupling::DataArrayDouble::accumulatePerChunck;
 156 %newobject MEDCoupling::DataArrayDouble::findIdsInRange;
 157 %newobject MEDCoupling::DataArrayDouble::findIdsNotInRange;
 158 %newobject MEDCoupling::DataArrayDouble::negate;
 159 %newobject MEDCoupling::DataArrayDouble::computeAbs;
 160 %newobject MEDCoupling::DataArrayDouble::applyFunc;
 161 %newobject MEDCoupling::DataArrayDouble::applyFuncCompo;
 162 %newobject MEDCoupling::DataArrayDouble::applyFuncNamedCompo;
 163 %newobject MEDCoupling::DataArrayDouble::doublyContractedProduct;
 164 %newobject MEDCoupling::DataArrayDouble::determinant;
 165 %newobject MEDCoupling::DataArrayDouble::eigenValues;
 166 %newobject MEDCoupling::DataArrayDouble::eigenVectors;
 167 %newobject MEDCoupling::DataArrayDouble::inverse;
 168 %newobject MEDCoupling::DataArrayDouble::trace;
 169 %newobject MEDCoupling::DataArrayDouble::deviator;
 170 %newobject MEDCoupling::DataArrayDouble::magnitude;
 171 %newobject MEDCoupling::DataArrayDouble::maxPerTuple;
 172 %newobject MEDCoupling::DataArrayDouble::sumPerTuple;
 173 %newobject MEDCoupling::DataArrayDouble::computeBBoxPerTuple;
 174 %newobject MEDCoupling::DataArrayDouble::buildEuclidianDistanceDenseMatrix;
 175 %newobject MEDCoupling::DataArrayDouble::buildEuclidianDistanceDenseMatrixWith;
 176 %newobject MEDCoupling::DataArrayDouble::renumber;
 177 %newobject MEDCoupling::DataArrayDouble::renumberR;
 178 %newobject MEDCoupling::DataArrayDouble::renumberAndReduce;
 179 %newobject MEDCoupling::DataArrayDouble::fromNoInterlace;
 180 %newobject MEDCoupling::DataArrayDouble::toNoInterlace;
 181 %newobject MEDCoupling::DataArrayDouble::fromPolarToCart;
 182 %newobject MEDCoupling::DataArrayDouble::fromCylToCart;
 183 %newobject MEDCoupling::DataArrayDouble::fromSpherToCart;
 184 %newobject MEDCoupling::DataArrayDouble::cartesianize;
 185 %newobject MEDCoupling::DataArrayDouble::getDifferentValues;
 186 %newobject MEDCoupling::DataArrayDouble::findClosestTupleId;
 187 %newobject MEDCoupling::DataArrayDouble::computeNbOfInteractionsWith;
 188 %newobject MEDCoupling::DataArrayDouble::duplicateEachTupleNTimes;
 189 %newobject MEDCoupling::DataArrayDouble::__neg__;
 190 %newobject MEDCoupling::DataArrayDouble::__radd__;
 191 %newobject MEDCoupling::DataArrayDouble::__rsub__;
 192 %newobject MEDCoupling::DataArrayDouble::__rmul__;
 193 %newobject MEDCoupling::DataArrayDouble::__rdiv__;
 194 %newobject MEDCoupling::DataArrayDouble::__pow__;
 195 %newobject MEDCoupling::DataArrayDouble::__rpow__;
 196 %newobject MEDCoupling::DataArrayDoubleTuple::buildDADouble;
 197
 198 %feature("unref") DataArray "$this->decrRef();"
 199 %feature("unref") DataArrayDouble "$this->decrRef();"
 200 %feature("unref") DataArrayInt "$this->decrRef();"
 201 %feature("unref") DataArrayChar "$this->decrRef();"
 202 %feature("unref") DataArrayAsciiChar "$this->decrRef();"
 203 %feature("unref") DataArrayByte "$this->decrRef();"
 204
 205 namespace MEDCoupling
 206 {
 207   typedef enum
 208     {
 209       AX_CART = 3,
 210       AX_CYL = 4,
 211       AX_SPHER = 5
 212     } MEDCouplingAxisType;
 213
 214   class DataArray : public RefCountObject, public TimeLabel
 215   {
 216   public:
 217     void setName(const std::string& name);
 218     void copyStringInfoFrom(const DataArray& other) throw(INTERP_KERNEL::Exception);
 219     void copyPartOfStringInfoFrom(const DataArray& other, const std::vector<int>& compoIds) throw(INTERP_KERNEL::Exception);
 220     void copyPartOfStringInfoFrom2(const std::vector<int>& compoIds, const DataArray& other) throw(INTERP_KERNEL::Exception);
 221     bool areInfoEqualsIfNotWhy(const DataArray& other, std::string& reason) const throw(INTERP_KERNEL::Exception);
 222     bool areInfoEquals(const DataArray& other) const throw(INTERP_KERNEL::Exception);
 223     std::string cppRepr(const std::string& varName) const throw(INTERP_KERNEL::Exception);
 224     std::string getName() const;
 225     void setInfoOnComponents(const std::vector<std::string>& info) throw(INTERP_KERNEL::Exception);
 226     void setInfoAndChangeNbOfCompo(const std::vector<std::string>& info) throw(INTERP_KERNEL::Exception);
 227     std::vector<std::string> getVarsOnComponent() const throw(INTERP_KERNEL::Exception);
 228     std::vector<std::string> getUnitsOnComponent() const throw(INTERP_KERNEL::Exception);
 229     std::string getInfoOnComponent(int i) const throw(INTERP_KERNEL::Exception);
 230     std::string getVarOnComponent(int i) const throw(INTERP_KERNEL::Exception);
 231     std::string getUnitOnComponent(int i) const throw(INTERP_KERNEL::Exception);
 232     void setInfoOnComponent(int i, const std::string& info) throw(INTERP_KERNEL::Exception);
 233     int getNumberOfComponents() const;
 234     virtual void alloc(int nbOfTuple, int nbOfCompo=1) throw(INTERP_KERNEL::Exception);
 235     virtual void reAlloc(int nbOfTuples) throw(INTERP_KERNEL::Exception);
 236     virtual bool isAllocated() const throw(INTERP_KERNEL::Exception);
 237     virtual void checkAllocated() const throw(INTERP_KERNEL::Exception);
 238     virtual void desallocate() throw(INTERP_KERNEL::Exception);
 239     virtual int getNumberOfTuples() const throw(INTERP_KERNEL::Exception);
 240     virtual std::size_t getNbOfElems() const throw(INTERP_KERNEL::Exception);
 241     virtual std::size_t getNbOfElemAllocated() const throw(INTERP_KERNEL::Exception);
 242     virtual DataArray *deepCopy() const throw(INTERP_KERNEL::Exception);
 243     virtual DataArray *selectByTupleIdSafeSlice(int bg, int end2, int step) const throw(INTERP_KERNEL::Exception);
 244     virtual void rearrange(int newNbOfCompo) throw(INTERP_KERNEL::Exception);
 245     void checkNbOfTuples(int nbOfTuples, const std::string& msg) const throw(INTERP_KERNEL::Exception);
 246     void checkNbOfComps(int nbOfCompo, const std::string& msg) const throw(INTERP_KERNEL::Exception);
 247     void checkNbOfTuplesAndComp(const DataArray& other, const std::string& msg) const throw(INTERP_KERNEL::Exception);
 248     void checkNbOfTuplesAndComp(int nbOfTuples, int nbOfCompo, const std::string& msg) const throw(INTERP_KERNEL::Exception);
 249     void checkNbOfElems(std::size_t nbOfElems, const std::string& msg) const throw(INTERP_KERNEL::Exception);
 250     static int GetNumberOfItemGivenBES(int begin, int end, int step, const std::string& msg) throw(INTERP_KERNEL::Exception);
 251     static int GetNumberOfItemGivenBESRelative(int begin, int end, int step, const std::string& msg) throw(INTERP_KERNEL::Exception);
 252     static int GetPosOfItemGivenBESRelativeNoThrow(int value, int begin, int end, int step) throw(INTERP_KERNEL::Exception);
 253     static std::string GetVarNameFromInfo(const std::string& info) throw(INTERP_KERNEL::Exception);
 254     static std::string GetUnitFromInfo(const std::string& info) throw(INTERP_KERNEL::Exception);
 255     static std::string BuildInfoFromVarAndUnit(const std::string& var, const std::string& unit) throw(INTERP_KERNEL::Exception);
 256     static std::string GetAxisTypeRepr(MEDCouplingAxisType at) throw(INTERP_KERNEL::Exception);
 257     void updateTime() const;
 258     %extend
 259     {
 260       PyObject *getInfoOnComponents() const throw(INTERP_KERNEL::Exception)
 261       {
 262         const std::vector<std::string>& comps=self->getInfoOnComponents();
 263         PyObject *ret=PyList_New((int)comps.size());
 264         for(int i=0;i<(int)comps.size();i++)
 265           PyList_SetItem(ret,i,PyString_FromString(comps[i].c_str()));
 266         return ret;
 267       }
 268
 269       void copyPartOfStringInfoFrom(const DataArray& other, PyObject *li) throw(INTERP_KERNEL::Exception)
 270       {
 271         std::vector<int> tmp;
 272         convertPyToNewIntArr3(li,tmp);
 273         self->copyPartOfStringInfoFrom(other,tmp);
 274       }
 275
 276       void copyPartOfStringInfoFrom2(PyObject *li, const DataArray& other) throw(INTERP_KERNEL::Exception)
 277       {
 278         std::vector<int> tmp;
 279         convertPyToNewIntArr3(li,tmp);
 280         self->copyPartOfStringInfoFrom2(tmp,other);
 281       }
 282
 283       virtual void renumberInPlace(PyObject *li) throw(INTERP_KERNEL::Exception)
 284       {
 285         void *da=0;
 286         int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 |  0 );
 287         if (!SWIG_IsOK(res1))
 288           {
 289             int size;
 290             INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
 291             if(size!=self->getNumberOfTuples())
 292               {
 293                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
 294               }
 295             self->renumberInPlace(tmp);
 296           }
 297         else
 298           {
 299             DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
 300             if(!da2)
 301               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
 302             da2->checkAllocated();
 303             int size=self->getNumberOfTuples();
 304             if(size!=self->getNumberOfTuples())
 305               {
 306                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
 307               }
 308             self->renumberInPlace(da2->getConstPointer());
 309           }
 310       }
 311
 312       virtual void renumberInPlaceR(PyObject *li) throw(INTERP_KERNEL::Exception)
 313       {
 314         void *da=0;
 315         int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 |  0 );
 316         if (!SWIG_IsOK(res1))
 317           {
 318             int size;
 319             INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
 320             if(size!=self->getNumberOfTuples())
 321               {
 322                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
 323               }
 324             self->renumberInPlaceR(tmp);
 325           }
 326         else
 327           {
 328             DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
 329             if(!da2)
 330               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
 331             da2->checkAllocated();
 332             int size=self->getNumberOfTuples();
 333             if(size!=self->getNumberOfTuples())
 334               {
 335                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
 336               }
 337             self->renumberInPlaceR(da2->getConstPointer());
 338           }
 339       }
 340
 341       //tuplesSelec in PyObject * because DataArrayInt is not already existing !
 342       virtual void setContigPartOfSelectedValues(int tupleIdStart, PyObject *aBase, PyObject *tuplesSelec) throw(INTERP_KERNEL::Exception)
 343       {
 344         static const char msg[]="DataArray::setContigPartOfSelectedValuesSlice : 4th parameter \"tuplesSelec\" should be of type DataArrayInt";
 345           DataArray *a=CheckAndRetrieveDataArrayInstance(aBase,"DataArray::setContigPartOfSelectedValuesSlice : 3rd parameter \"aBase\" should be of type DataArray");
 346         DataArray *tuplesSelecPtr=CheckAndRetrieveDataArrayInstance(tuplesSelec,msg);
 347         DataArrayInt *tuplesSelecPtr2=0;
 348         if(tuplesSelecPtr)
 349           {
 350             tuplesSelecPtr2=dynamic_cast<DataArrayInt *>(tuplesSelecPtr);
 351             if(!tuplesSelecPtr2)
 352               throw INTERP_KERNEL::Exception(msg);
 353           }
 354         self->setContigPartOfSelectedValues(tupleIdStart,a,tuplesSelecPtr2);
 355       }
 356
 357       virtual void setContigPartOfSelectedValuesSlice(int tupleIdStart, PyObject *aBase, int bg, int end2, int step) throw(INTERP_KERNEL::Exception)
 358       {
 359         DataArray *a=CheckAndRetrieveDataArrayInstance(aBase,"DataArray::setContigPartOfSelectedValuesSlice : 2nd parameter \"aBase\" should be of type DataArray");
 360         self->setContigPartOfSelectedValuesSlice(tupleIdStart,a,bg,end2,step);
 361       }
 362
 363       virtual DataArray *selectByTupleRanges(PyObject *li) const throw(INTERP_KERNEL::Exception)
 364       {
 365         std::vector<std::pair<int,int> > ranges;
 366         convertPyToVectorPairInt(li,ranges);
 367         return self->selectByTupleRanges(ranges);
 368       }
 369
 370       virtual DataArray *selectByTupleId(PyObject *li) const throw(INTERP_KERNEL::Exception)
 371       {
 372         void *da=0;
 373         int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 |  0 );
 374         if (!SWIG_IsOK(res1))
 375           {
 376             int size;
 377             INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
 378             return self->selectByTupleId(tmp,tmp+size);
 379           }
 380         else
 381           {
 382             DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
 383             if(!da2)
 384               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
 385             da2->checkAllocated();
 386             return self->selectByTupleId(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
 387           }
 388       }
 389
 390       virtual DataArray *selectByTupleIdSafe(PyObject *li) const throw(INTERP_KERNEL::Exception)
 391       {
 392         void *da=0;
 393         int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 |  0 );
 394         if (!SWIG_IsOK(res1))
 395           {
 396             int size;
 397             INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
 398             return self->selectByTupleIdSafe(tmp,tmp+size);
 399           }
 400         else
 401           {
 402             DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
 403             if(!da2)
 404               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
 405             da2->checkAllocated();
 406             return self->selectByTupleIdSafe(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
 407           }
 408       }
 409
 410       virtual PyObject *keepSelectedComponents(PyObject *li) const throw(INTERP_KERNEL::Exception)
 411       {
 412         std::vector<int> tmp;
 413         convertPyToNewIntArr3(li,tmp);
 414         DataArray *ret=self->keepSelectedComponents(tmp);
 415         return convertDataArray(ret,SWIG_POINTER_OWN | 0 );
 416       }
 417
 418       static PyObject *GetSlice(PyObject *slic, int sliceId, int nbOfSlices) throw(INTERP_KERNEL::Exception)
 419       {
 420         if(!PySlice_Check(slic))
 421           throw INTERP_KERNEL::Exception("DataArray::GetSlice (wrap) : expecting a pyslice as second (first) parameter !");
 422         Py_ssize_t strt=2,stp=2,step=2;
 423         PySliceObject *sly=reinterpret_cast<PySliceObject *>(slic);
 424         GetIndicesOfSliceExplicitely(sly,&strt,&stp,&step,"DataArray::GetSlice (wrap) : the input slice is invalid !");
 425         int a,b;
 426         DataArray::GetSlice(strt,stp,step,sliceId,nbOfSlices,a,b);
 427         return PySlice_New(PyInt_FromLong(a),PyInt_FromLong(b),PyInt_FromLong(step));
 428       }
 429
 430       PyObject *getSlice(PyObject *slic, int sliceId, int nbOfSlices) const throw(INTERP_KERNEL::Exception)
 431       {
 432         if(!PySlice_Check(slic))
 433           throw INTERP_KERNEL::Exception("DataArray::getSlice (wrap) : expecting a pyslice as second (first) parameter !");
 434         Py_ssize_t strt=2,stp=2,step=2;
 435         PySliceObject *sly=reinterpret_cast<PySliceObject *>(slic);
 436         GetIndicesOfSlice(sly,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getSlice (wrap) : the input slice is invalid !");
 437         int a,b;
 438         DataArray::GetSlice(strt,stp,step,sliceId,nbOfSlices,a,b);
 439         return PySlice_New(PyInt_FromLong(a),PyInt_FromLong(b),PyInt_FromLong(step));
 440       }
 441
 442       static int GetNumberOfItemGivenBES(PyObject *slic) throw(INTERP_KERNEL::Exception)
 443       {
 444         if(!PySlice_Check(slic))
 445           throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBES (wrap) : expecting a pyslice as second (first) parameter !");
 446         Py_ssize_t strt=2,stp=2,step=2;
 447         PySliceObject *sly=reinterpret_cast<PySliceObject *>(slic);
 448         GetIndicesOfSliceExplicitely(sly,&strt,&stp,&step,"DataArray::GetNumberOfItemGivenBES (wrap) : the input slice is invalid !");
 449         return DataArray::GetNumberOfItemGivenBES(strt,stp,step,"");
 450       }
 451
 452       static int GetNumberOfItemGivenBESRelative(PyObject *slic) throw(INTERP_KERNEL::Exception)
 453       {
 454         if(!PySlice_Check(slic))
 455           throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBESRelative (wrap) : expecting a pyslice as second (first) parameter !");
 456         Py_ssize_t strt=2,stp=2,step=2;
 457         PySliceObject *sly=reinterpret_cast<PySliceObject *>(slic);
 458         GetIndicesOfSliceExplicitely(sly,&strt,&stp,&step,"DataArray::GetNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !");
 459         return DataArray::GetNumberOfItemGivenBESRelative(strt,stp,step,"");
 460       }
 461
 462       static DataArray *Aggregate(PyObject *arrs) throw(INTERP_KERNEL::Exception)
 463       {
 464         std::vector<const DataArray *> tmp;
 465         convertFromPyObjVectorOfObj<const MEDCoupling::DataArray *>(arrs,SWIGTYPE_p_MEDCoupling__DataArray,"DataArray",tmp);
 466         return DataArray::Aggregate(tmp);
 467       }
 468
 469       int getNumberOfItemGivenBES(PyObject *slic) const throw(INTERP_KERNEL::Exception)
 470       {
 471         if(!PySlice_Check(slic))
 472           throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBES (wrap) : expecting a pyslice as second (first) parameter !");
 473         Py_ssize_t strt=2,stp=2,step=2;
 474         PySliceObject *sly=reinterpret_cast<PySliceObject *>(slic);
 475         GetIndicesOfSlice(sly,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getNumberOfItemGivenBES (wrap) : the input slice is invalid !");
 476         return DataArray::GetNumberOfItemGivenBES(strt,stp,step,"");
 477       }
 478
 479       int getNumberOfItemGivenBESRelative(PyObject *slic) throw(INTERP_KERNEL::Exception)
 480       {
 481         if(!PySlice_Check(slic))
 482           throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBESRelative (wrap) : expecting a pyslice as second (first) parameter !");
 483         Py_ssize_t strt=2,stp=2,step=2;
 484         PySliceObject *sly=reinterpret_cast<PySliceObject *>(slic);
 485         GetIndicesOfSlice(sly,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !");
 486         return DataArray::GetNumberOfItemGivenBESRelative(strt,stp,step,"");
 487       }
 488
 489       PyObject *__getstate__() const throw(INTERP_KERNEL::Exception)
 490       {
 491         PyObject *ret(PyTuple_New(2));
 492         std::string a0(self->getName());
 493         const std::vector<std::string> &a1(self->getInfoOnComponents());
 494         PyTuple_SetItem(ret,0,PyString_FromString(a0.c_str()));
 495         //
 496         int sz(a1.size());
 497         PyObject *ret1(PyList_New(sz));
 498         for(int i=0;i<sz;i++)
 499           PyList_SetItem(ret1,i,PyString_FromString(a1[i].c_str()));
 500         PyTuple_SetItem(ret,1,ret1);
 501         //
 502         return ret;
 503       }
 504
 505       void __setstate__(PyObject *inp) throw(INTERP_KERNEL::Exception)
 506       {
 507         static const char MSG[]="DataArrayDouble.__setstate__ : expected input is a tuple of size 2 with string as 1st arg and list of string as 2nd arg !";
 508         if(!PyTuple_Check(inp))
 509           throw INTERP_KERNEL::Exception("DataArrayDouble.__setstate__ : invalid input ! Invalid overwrite of __getstate__ ?");
 510         int sz(PyTuple_Size(inp));
 511         if(sz!=2)
 512           throw INTERP_KERNEL::Exception("DataArrayDouble.__setstate__ : invalid tuple in input ! Should be of size 2 ! Invalid overwrite of __getstate__ ?");
 513         PyObject *a0(PyTuple_GetItem(inp,0));
 514         if(!PyString_Check(a0))
 515           throw INTERP_KERNEL::Exception(MSG);
 516         PyObject *a1(PyTuple_GetItem(inp,1));
 517         std::vector<std::string> a1cpp;
 518         if(!fillStringVector(a1,a1cpp))
 519           throw INTERP_KERNEL::Exception(MSG);
 520         self->setName(PyString_AsString(a0));
 521         self->setInfoOnComponents(a1cpp);
 522       }
 523     }
 524   };
 525
 526   class DataArrayInt;
 527   class DataArrayDoubleIterator;
 528
 529   class DataArrayDouble : public DataArray
 530   {
 531   public:
 532     static DataArrayDouble *New();
 533     double doubleValue() const throw(INTERP_KERNEL::Exception);
 534     bool empty() const throw(INTERP_KERNEL::Exception);
 535     DataArrayDouble *performCopyOrIncrRef(bool deepCopy) const throw(INTERP_KERNEL::Exception);
 536     void deepCopyFrom(const DataArrayDouble& other) throw(INTERP_KERNEL::Exception);
 537     void reserve(std::size_t nbOfElems) throw(INTERP_KERNEL::Exception);
 538     void pushBackSilent(double val) throw(INTERP_KERNEL::Exception);
 539     double popBackSilent() throw(INTERP_KERNEL::Exception);
 540     void pack() const throw(INTERP_KERNEL::Exception);
 541     void allocIfNecessary(int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception);
 542     void fillWithZero() throw(INTERP_KERNEL::Exception);
 543     void fillWithValue(double val) throw(INTERP_KERNEL::Exception);
 544     void iota(double init=0.) throw(INTERP_KERNEL::Exception);
 545     bool isUniform(double val, double eps) const throw(INTERP_KERNEL::Exception);
 546     void sort(bool asc=true) throw(INTERP_KERNEL::Exception);
 547     void reverse() throw(INTERP_KERNEL::Exception);
 548     void checkMonotonic(bool increasing, double eps) const throw(INTERP_KERNEL::Exception);
 549     bool isMonotonic(bool increasing, double eps) const throw(INTERP_KERNEL::Exception);
 550     std::string repr() const throw(INTERP_KERNEL::Exception);
 551     std::string reprZip() const throw(INTERP_KERNEL::Exception);
 552     std::string reprNotTooLong() const throw(INTERP_KERNEL::Exception);
 553     bool isEqual(const DataArrayDouble& other, double prec) const throw(INTERP_KERNEL::Exception);
 554     bool isEqualWithoutConsideringStr(const DataArrayDouble& other, double prec) const throw(INTERP_KERNEL::Exception);
 555     DataArrayInt *convertToIntArr() const throw(INTERP_KERNEL::Exception);
 556     DataArrayDouble *fromNoInterlace() const throw(INTERP_KERNEL::Exception);
 557     DataArrayDouble *toNoInterlace() const throw(INTERP_KERNEL::Exception);
 558     DataArrayDouble *subArray(int tupleIdBg, int tupleIdEnd=-1) const throw(INTERP_KERNEL::Exception);
 559     void transpose() throw(INTERP_KERNEL::Exception);
 560     DataArrayDouble *changeNbOfComponents(int newNbOfComp, double dftValue) const throw(INTERP_KERNEL::Exception);
 561     void meldWith(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception);
 562     DataArrayDouble *duplicateEachTupleNTimes(int nbTimes) const throw(INTERP_KERNEL::Exception);
 563     DataArrayDouble *getDifferentValues(double prec, int limitTupleId=-1) const throw(INTERP_KERNEL::Exception);
 564     DataArrayInt *findClosestTupleId(const DataArrayDouble *other) const throw(INTERP_KERNEL::Exception);
 565     DataArrayInt *computeNbOfInteractionsWith(const DataArrayDouble *otherBBoxFrmt, double eps) const throw(INTERP_KERNEL::Exception);
 566     void setPartOfValues1(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare=true) throw(INTERP_KERNEL::Exception);
 567     void setPartOfValuesSimple1(double a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp) throw(INTERP_KERNEL::Exception);
 568     void setPartOfValuesAdv(const DataArrayDouble *a, const DataArrayInt *tuplesSelec) throw(INTERP_KERNEL::Exception);
 569     double getIJ(int tupleId, int compoId) const throw(INTERP_KERNEL::Exception);
 570     double front() const throw(INTERP_KERNEL::Exception);
 571     double back() const throw(INTERP_KERNEL::Exception);
 572     double getIJSafe(int tupleId, int compoId) const throw(INTERP_KERNEL::Exception);
 573     void setIJ(int tupleId, int compoId, double newVal) throw(INTERP_KERNEL::Exception);
 574     void setIJSilent(int tupleId, int compoId, double newVal) throw(INTERP_KERNEL::Exception);
 575     double *getPointer() throw(INTERP_KERNEL::Exception);
 576     void checkNoNullValues() const throw(INTERP_KERNEL::Exception);
 577     DataArrayDouble *computeBBoxPerTuple(double epsilon=0.0) const throw(INTERP_KERNEL::Exception);
 578     void recenterForMaxPrecision(double eps) throw(INTERP_KERNEL::Exception);
 579     double getMaxValue(int& tupleId) const throw(INTERP_KERNEL::Exception);
 580     double getMaxValueInArray() const throw(INTERP_KERNEL::Exception);
 581     double getMinValue(int& tupleId) const throw(INTERP_KERNEL::Exception);
 582     double getMinValueInArray() const throw(INTERP_KERNEL::Exception);
 583     int count(double value, double eps) const throw(INTERP_KERNEL::Exception);
 584     double getAverageValue() const throw(INTERP_KERNEL::Exception);
 585     double norm2() const throw(INTERP_KERNEL::Exception);
 586     double normMax() const throw(INTERP_KERNEL::Exception);
 587     double normMin() const throw(INTERP_KERNEL::Exception);
 588     double accumulate(int compId) const throw(INTERP_KERNEL::Exception);
 589     DataArrayDouble *fromPolarToCart() const throw(INTERP_KERNEL::Exception);
 590     DataArrayDouble *fromCylToCart() const throw(INTERP_KERNEL::Exception);
 591     DataArrayDouble *fromSpherToCart() const throw(INTERP_KERNEL::Exception);
 592     DataArrayDouble *cartesianize(MEDCouplingAxisType atOfThis) const throw(INTERP_KERNEL::Exception);
 593     DataArrayDouble *doublyContractedProduct() const throw(INTERP_KERNEL::Exception);
 594     DataArrayDouble *determinant() const throw(INTERP_KERNEL::Exception);
 595     DataArrayDouble *eigenValues() const throw(INTERP_KERNEL::Exception);
 596     DataArrayDouble *eigenVectors() const throw(INTERP_KERNEL::Exception);
 597     DataArrayDouble *inverse() const throw(INTERP_KERNEL::Exception);
 598     DataArrayDouble *trace() const throw(INTERP_KERNEL::Exception);
 599     DataArrayDouble *deviator() const throw(INTERP_KERNEL::Exception);
 600     DataArrayDouble *magnitude() const throw(INTERP_KERNEL::Exception);
 601     DataArrayDouble *maxPerTuple() const throw(INTERP_KERNEL::Exception);
 602     DataArrayDouble *sumPerTuple() const throw(INTERP_KERNEL::Exception);
 603     DataArrayDouble *buildEuclidianDistanceDenseMatrix() const throw(INTERP_KERNEL::Exception);
 604     DataArrayDouble *buildEuclidianDistanceDenseMatrixWith(const DataArrayDouble *other) const throw(INTERP_KERNEL::Exception);
 605     void sortPerTuple(bool asc) throw(INTERP_KERNEL::Exception);
 606     void abs() throw(INTERP_KERNEL::Exception);
 607     DataArrayDouble *computeAbs() const throw(INTERP_KERNEL::Exception);
 608     void applyLin(double a, double b, int compoId) throw(INTERP_KERNEL::Exception);
 609     void applyLin(double a, double b) throw(INTERP_KERNEL::Exception);
 610     void applyInv(double numerator) throw(INTERP_KERNEL::Exception);
 611     void applyPow(double val) throw(INTERP_KERNEL::Exception);
 612     void applyRPow(double val) throw(INTERP_KERNEL::Exception);
 613     DataArrayDouble *negate() const throw(INTERP_KERNEL::Exception);
 614     DataArrayDouble *applyFunc(int nbOfComp, FunctionToEvaluate func) const throw(INTERP_KERNEL::Exception);
 615     DataArrayDouble *applyFunc(int nbOfComp, const std::string& func, bool isSafe=true) const throw(INTERP_KERNEL::Exception);
 616     DataArrayDouble *applyFunc(const std::string& func, bool isSafe=true) const throw(INTERP_KERNEL::Exception);
 617     void applyFuncOnThis(const std::string& func, bool isSafe=true) throw(INTERP_KERNEL::Exception);
 618     DataArrayDouble *applyFuncCompo(int nbOfComp, const std::string& func, bool isSafe=true) const throw(INTERP_KERNEL::Exception);
 619     DataArrayDouble *applyFuncNamedCompo(int nbOfComp, const std::vector<std::string>& varsOrder, const std::string& func, bool isSafe=true) const throw(INTERP_KERNEL::Exception);
 620     void applyFuncFast32(const std::string& func) throw(INTERP_KERNEL::Exception);
 621     void applyFuncFast64(const std::string& func) throw(INTERP_KERNEL::Exception);
 622     DataArrayInt *findIdsInRange(double vmin, double vmax) const throw(INTERP_KERNEL::Exception);
 623     DataArrayInt *findIdsNotInRange(double vmin, double vmax) const throw(INTERP_KERNEL::Exception);
 624     static DataArrayDouble *Aggregate(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception);
 625     static DataArrayDouble *Meld(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception);
 626     static DataArrayDouble *Dot(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception);
 627     static DataArrayDouble *CrossProduct(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception);
 628     static DataArrayDouble *Max(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception);
 629     static DataArrayDouble *Min(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception);
 630     static DataArrayDouble *Add(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception);
 631     void addEqual(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception);
 632     static DataArrayDouble *Substract(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception);
 633     void substractEqual(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception);
 634     static DataArrayDouble *Multiply(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception);
 635     void multiplyEqual(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception);
 636     static DataArrayDouble *Divide(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception);
 637     void divideEqual(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception);
 638     static DataArrayDouble *Pow(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception);
 639     void powEqual(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception);
 640     %extend
 641     {
 642       DataArrayDouble() throw(INTERP_KERNEL::Exception)
 643         {
 644           return DataArrayDouble::New();
 645         }
 646
 647       static DataArrayDouble *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0) throw(INTERP_KERNEL::Exception)
 648       {
 649         const char *msgBase="MEDCoupling::DataArrayDouble::New : Available API are : \n-DataArrayDouble.New()\n-DataArrayDouble.New([1.,3.,4.])\n-DataArrayDouble.New([1.,3.,4.],3)\n-DataArrayDouble.New([1.,3.,4.,5.],2,2)\n-DataArrayDouble.New([1.,3.,4.,5.,7,8.],3,2)\n-DataArrayDouble.New([(1.,3.),(4.,5.),(7,8.)])\n-DataArrayDouble.New(5)\n-DataArrayDouble.New(5,2)";
 650         std::string msg(msgBase);
 651 #ifdef WITH_NUMPY
 652         msg+="\n-DataArrayDouble.New(numpy array with dtype=float64)";
 653 #endif
 654         msg+=" !";
 655         if(PyList_Check(elt0) || PyTuple_Check(elt0))
 656           {
 657             if(nbOfTuples)
 658               {
 659                 if(PyInt_Check(nbOfTuples))
 660                   {
 661                     int nbOfTuples1=PyInt_AS_LONG(nbOfTuples);
 662                     if(nbOfTuples1<0)
 663                       throw INTERP_KERNEL::Exception("DataArrayDouble::New : should be a positive set of allocated memory !");
 664                     if(elt2)
 665                       {
 666                         if(PyInt_Check(elt2))
 667                           {//DataArrayDouble.New([1.,3.,4.,5.],2,2)
 668                             int nbOfCompo=PyInt_AS_LONG(elt2);
 669                             if(nbOfCompo<0)
 670                               throw INTERP_KERNEL::Exception("DataArrayDouble::New : should be a positive number of components !");
 671                             MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
 672                             std::vector<double> tmp=fillArrayWithPyListDbl2(elt0,nbOfTuples1,nbOfCompo);
 673                             ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
 674                             return ret.retn();
 675                           }
 676                         else
 677                           throw INTERP_KERNEL::Exception(msg.c_str());
 678                       }
 679                     else
 680                       {//DataArrayDouble.New([1.,3.,4.],3)
 681                         MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
 682                         int tmpp1=-1;
 683                         std::vector<double> tmp=fillArrayWithPyListDbl2(elt0,nbOfTuples1,tmpp1);
 684                         ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
 685                         return ret.retn();
 686                       }
 687                   }
 688                 else
 689                   throw INTERP_KERNEL::Exception(msg.c_str());
 690               }
 691             else
 692               {// DataArrayDouble.New([1.,3.,4.])
 693                 MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
 694                 int tmpp1=-1,tmpp2=-1;
 695                 std::vector<double> tmp=fillArrayWithPyListDbl2(elt0,tmpp1,tmpp2);
 696                 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
 697                 return ret.retn();
 698               }
 699           }
 700         else if(PyInt_Check(elt0))
 701           {
 702             int nbOfTuples1=PyInt_AS_LONG(elt0);
 703             if(nbOfTuples1<0)
 704               throw INTERP_KERNEL::Exception("DataArrayDouble::New : should be a positive set of allocated memory !");
 705             if(nbOfTuples)
 706               {
 707                 if(!elt2)
 708                   {
 709                     if(PyInt_Check(nbOfTuples))
 710                       {//DataArrayDouble.New(5,2)
 711                         int nbOfCompo=PyInt_AS_LONG(nbOfTuples);
 712                         if(nbOfCompo<0)
 713                           throw INTERP_KERNEL::Exception("DataArrayDouble::New : should be a positive number of components !");
 714                         MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
 715                         ret->alloc(nbOfTuples1,nbOfCompo);
 716                         return ret.retn();
 717                       }
 718                     else
 719                       throw INTERP_KERNEL::Exception(msg.c_str());
 720                   }
 721                 else
 722                   throw INTERP_KERNEL::Exception(msg.c_str());
 723               }
 724             else
 725               {//DataArrayDouble.New(5)
 726                 MCAuto<DataArrayDouble> ret=DataArrayDouble::New();
 727                 ret->alloc(nbOfTuples1,1);
 728                 return ret.retn();
 729               }
 730           }
 731 #ifdef WITH_NUMPY
 732         else if(PyArray_Check(elt0) && nbOfTuples==NULL && elt2==NULL)
 733           {//DataArrayDouble.New(numpyArray)
 734             return BuildNewInstance<DataArrayDouble,double>(elt0,NPY_DOUBLE,&PyCallBackDataArrayDouble_RefType,"FLOAT64");
 735           }
 736 #endif
 737         else
 738           throw INTERP_KERNEL::Exception(msg.c_str());
 739         throw INTERP_KERNEL::Exception(msg.c_str());//to make g++ happy
 740       }
 741
 742       DataArrayDouble(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0) throw(INTERP_KERNEL::Exception)
 743         {
 744           return MEDCoupling_DataArrayDouble_New__SWIG_1(elt0,nbOfTuples,elt2);
 745         }
 746
 747       void pushBackValsSilent(PyObject *li) throw(INTERP_KERNEL::Exception)
 748       {
 749         double val;
 750         std::vector<double> bb;
 751         int sw,nbTuples=-1;
 752         const char msg[]="Python wrap of DataArrayDouble::pushBackValsSilent : ";
 753         const double *tmp=convertObjToPossibleCpp5_SingleCompo(li,sw,val,bb,msg,true,nbTuples);
 754         self->pushBackValsSilent(tmp,tmp+nbTuples);
 755       }
 756
 757       std::string __repr__() const throw(INTERP_KERNEL::Exception)
 758       {
 759         std::ostringstream oss;
 760         self->reprQuickOverview(oss);
 761         return oss.str();
 762       }
 763
 764       std::string __str__() const throw(INTERP_KERNEL::Exception)
 765       {
 766         return self->reprNotTooLong();
 767       }
 768
 769       double __float__() const throw(INTERP_KERNEL::Exception)
 770       {
 771         return self->doubleValue();
 772       }
 773
 774       int __len__() const throw(INTERP_KERNEL::Exception)
 775       {
 776         if(self->isAllocated())
 777           {
 778             return self->getNumberOfTuples();
 779           }
 780         else
 781           {
 782             throw INTERP_KERNEL::Exception("DataArrayDouble::__len__ : Instance is NOT allocated !");
 783           }
 784       }
 785
 786       DataArrayDoubleIterator *__iter__() throw(INTERP_KERNEL::Exception)
 787       {
 788         return self->iterator();
 789       }
 790
 791       void setValues(PyObject *li, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) throw(INTERP_KERNEL::Exception)
 792       {
 793         const char *msg="MEDCoupling::DataArrayDouble::setValues : Available API are : \n-DataArrayDouble.setValues([1.,3.,4.])\n-DataArrayDouble.setValues([1.,3.,4.],3)\n-DataArrayDouble.setValues([1.,3.,4.,5.],2,2)\n-DataArrayDouble.setValues([(1.,1.7),(3.,3.7),(4.,4.7)])\n !";
 794         if(PyList_Check(li) || PyTuple_Check(li))
 795           {
 796             if(nbOfTuples)
 797               {
 798                 if(PyInt_Check(nbOfTuples))
 799                   {
 800                     int nbOfTuples1=PyInt_AS_LONG(nbOfTuples);
 801                     if(nbOfTuples1<0)
 802                       throw INTERP_KERNEL::Exception("DataArrayDouble::setValues : should be a positive set of allocated memory !");
 803                     if(nbOfComp)
 804                       {
 805                         if(PyInt_Check(nbOfComp))
 806                           {//DataArrayDouble.setValues([1.,3.,4.,5.],2,2)
 807                             int nbOfCompo=PyInt_AS_LONG(nbOfComp);
 808                             if(nbOfCompo<0)
 809                               throw INTERP_KERNEL::Exception("DataArrayDouble::setValues : should be a positive number of components !");
 810                             std::vector<double> tmp=fillArrayWithPyListDbl2(li,nbOfTuples1,nbOfCompo);
 811                             self->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),self->getPointer());
 812                           }
 813                         else
 814                           throw INTERP_KERNEL::Exception(msg);
 815                       }
 816                     else
 817                       {//DataArrayDouble.setValues([1.,3.,4.],3)
 818                         int tmpp1=-1;
 819                         std::vector<double> tmp=fillArrayWithPyListDbl2(li,nbOfTuples1,tmpp1);
 820                         self->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),self->getPointer());
 821                       }
 822                   }
 823                 else
 824                   throw INTERP_KERNEL::Exception(msg);
 825               }
 826             else
 827               {// DataArrayDouble.setValues([1.,3.,4.])
 828                 int tmpp1=-1,tmpp2=-1;
 829                 std::vector<double> tmp=fillArrayWithPyListDbl2(li,tmpp1,tmpp2);
 830                 self->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),self->getPointer());
 831               }
 832           }
 833         else
 834           throw INTERP_KERNEL::Exception(msg);
 835       }
 836
 837       PyObject *getValues() const throw(INTERP_KERNEL::Exception)
 838       {
 839         const double *vals=self->getConstPointer();
 840         return convertDblArrToPyList(vals,self->getNbOfElems());
 841       }
 842
 843 #ifdef WITH_NUMPY
 844       PyObject *toNumPyArray() throw(INTERP_KERNEL::Exception) // not const. It is not a bug !
 845       {
 846         return ToNumPyArray<DataArrayDouble,double>(self,NPY_DOUBLE,"DataArrayDouble");
 847       }
 848 #endif
 849
 850       PyObject *isEqualIfNotWhy(const DataArrayDouble& other, double prec) const throw(INTERP_KERNEL::Exception)
 851       {
 852         std::string ret1;
 853         bool ret0=self->isEqualIfNotWhy(other,prec,ret1);
 854         PyObject *ret=PyTuple_New(2);
 855         PyObject *ret0Py=ret0?Py_True:Py_False;
 856         Py_XINCREF(ret0Py);
 857         PyTuple_SetItem(ret,0,ret0Py);
 858         PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
 859         return ret;
 860       }
 861
 862       PyObject *getValuesAsTuple() const throw(INTERP_KERNEL::Exception)
 863       {
 864         const double *vals=self->getConstPointer();
 865         int nbOfComp=self->getNumberOfComponents();
 866         int nbOfTuples=self->getNumberOfTuples();
 867         return convertDblArrToPyListOfTuple(vals,nbOfComp,nbOfTuples);
 868       }
 869
 870       DataArrayDouble *renumber(PyObject *li) throw(INTERP_KERNEL::Exception)
 871       {
 872         void *da=0;
 873         int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 |  0 );
 874         if (!SWIG_IsOK(res1))
 875           {
 876             int size;
 877             INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
 878             if(size!=self->getNumberOfTuples())
 879               {
 880                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
 881               }
 882             return self->renumber(tmp);
 883           }
 884         else
 885           {
 886             DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
 887             if(!da2)
 888               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
 889             da2->checkAllocated();
 890             int size=self->getNumberOfTuples();
 891             if(size!=self->getNumberOfTuples())
 892               {
 893                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
 894               }
 895             return self->renumber(da2->getConstPointer());
 896           }
 897       }
 898
 899       DataArrayDouble *renumberR(PyObject *li) throw(INTERP_KERNEL::Exception)
 900       {
 901         void *da=0;
 902         int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 |  0 );
 903         if (!SWIG_IsOK(res1))
 904           {
 905             int size;
 906             INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
 907             if(size!=self->getNumberOfTuples())
 908               {
 909                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
 910               }
 911             return self->renumberR(tmp);
 912           }
 913         else
 914           {
 915             DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
 916             if(!da2)
 917               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
 918             da2->checkAllocated();
 919             int size=self->getNumberOfTuples();
 920             if(size!=self->getNumberOfTuples())
 921               {
 922                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
 923               }
 924             return self->renumberR(da2->getConstPointer());
 925           }
 926       }
 927
 928       DataArrayDouble *renumberAndReduce(PyObject *li, int newNbOfTuple) throw(INTERP_KERNEL::Exception)
 929       {
 930         void *da=0;
 931         int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 |  0 );
 932         if (!SWIG_IsOK(res1))
 933           {
 934             int size;
 935             INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
 936             if(size!=self->getNumberOfTuples())
 937               {
 938                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
 939               }
 940             return self->renumberAndReduce(tmp,newNbOfTuple);
 941           }
 942         else
 943           {
 944             DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
 945             if(!da2)
 946               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
 947             da2->checkAllocated();
 948             int size=self->getNumberOfTuples();
 949             if(size!=self->getNumberOfTuples())
 950               {
 951                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
 952               }
 953             return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
 954           }
 955       }
 956
 957       PyObject *minimalDistanceTo(const DataArrayDouble *other) const throw(INTERP_KERNEL::Exception)
 958       {
 959         int thisTupleId,otherTupleId;
 960         double r0=self->minimalDistanceTo(other,thisTupleId,otherTupleId);
 961         PyObject *ret=PyTuple_New(3);
 962         PyTuple_SetItem(ret,0,PyFloat_FromDouble(r0));
 963         PyTuple_SetItem(ret,1,PyInt_FromLong(thisTupleId));
 964         PyTuple_SetItem(ret,2,PyInt_FromLong(otherTupleId));
 965         return ret;
 966       }
 967
 968       PyObject *getMaxValue() const throw(INTERP_KERNEL::Exception)
 969       {
 970         int tmp;
 971         double r1=self->getMaxValue(tmp);
 972         PyObject *ret=PyTuple_New(2);
 973         PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
 974         PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
 975         return ret;
 976       }
 977
 978       PyObject *getMaxValue2() const throw(INTERP_KERNEL::Exception)
 979       {
 980         DataArrayInt *tmp;
 981         double r1=self->getMaxValue2(tmp);
 982         PyObject *ret=PyTuple_New(2);
 983         PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
 984         PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ));
 985         return ret;
 986       }
 987
 988       PyObject *getMinValue() const throw(INTERP_KERNEL::Exception)
 989       {
 990         int tmp;
 991         double r1=self->getMinValue(tmp);
 992         PyObject *ret=PyTuple_New(2);
 993         PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
 994         PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
 995         return ret;
 996       }
 997
 998       PyObject *getMinValue2() const throw(INTERP_KERNEL::Exception)
 999       {
1000         DataArrayInt *tmp;
1001         double r1=self->getMinValue2(tmp);
1002         PyObject *ret=PyTuple_New(2);
1003         PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1004         PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ));
1005         return ret;
1006       }
1007
1008       PyObject *getMinMaxPerComponent() const throw(INTERP_KERNEL::Exception)
1009       {
1010         int nbOfCompo=self->getNumberOfComponents();
1011         INTERP_KERNEL::AutoPtr<double> tmp=new double[2*nbOfCompo];
1012         self->getMinMaxPerComponent(tmp);
1013         PyObject *ret=convertDblArrToPyListOfTuple(tmp,2,nbOfCompo);
1014         return ret;
1015       }
1016
1017       PyObject *accumulate() const throw(INTERP_KERNEL::Exception)
1018       {
1019         int sz=self->getNumberOfComponents();
1020         INTERP_KERNEL::AutoPtr<double> tmp=new double[sz];
1021         self->accumulate(tmp);
1022         return convertDblArrToPyList(tmp,sz);
1023       }
1024
1025       DataArrayDouble *accumulatePerChunck(PyObject *indexArr) const throw(INTERP_KERNEL::Exception)
1026       {
1027         int sw,sz,val;
1028         std::vector<int> val2;
1029         const int *bg=convertObjToPossibleCpp1_Safe(indexArr,sw,sz,val,val2);
1030         return self->accumulatePerChunck(bg,bg+sz);
1031       }
1032
1033       PyObject *findCommonTuples(double prec, int limitNodeId=-1) const throw(INTERP_KERNEL::Exception)
1034       {
1035         DataArrayInt *comm, *commIndex;
1036         self->findCommonTuples(prec,limitNodeId,comm,commIndex);
1037         PyObject *res = PyList_New(2);
1038         PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(comm),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ));
1039         PyList_SetItem(res,1,SWIG_NewPointerObj(SWIG_as_voidptr(commIndex),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ));
1040         return res;
1041       }
1042
1043       PyObject *distanceToTuple(PyObject *tuple) const throw(INTERP_KERNEL::Exception)
1044       {
1045         double val;
1046         DataArrayDouble *a;
1047         DataArrayDoubleTuple *aa;
1048         std::vector<double> bb;
1049         int sw;
1050         int tupleId=-1,nbOfCompo=self->getNumberOfComponents();
1051         const double *pt=convertObjToPossibleCpp5_Safe(tuple,sw,val,a,aa,bb,"Python wrap of DataArrayDouble::distanceToTuple",1,nbOfCompo,true);
1052         //
1053         double ret0=self->distanceToTuple(pt,pt+nbOfCompo,tupleId);
1054         PyObject *ret=PyTuple_New(2);
1055         PyTuple_SetItem(ret,0,PyFloat_FromDouble(ret0));
1056         PyTuple_SetItem(ret,1,PyInt_FromLong(tupleId));
1057         return ret;
1058       }
1059
1060       void setSelectedComponents(const DataArrayDouble *a, PyObject *li) throw(INTERP_KERNEL::Exception)
1061       {
1062         std::vector<int> tmp;
1063         convertPyToNewIntArr3(li,tmp);
1064         self->setSelectedComponents(a,tmp);
1065       }
1066
1067       PyObject *getTuple(int tupleId) throw(INTERP_KERNEL::Exception)
1068       {
1069         int sz=self->getNumberOfComponents();
1070         INTERP_KERNEL::AutoPtr<double> tmp=new double[sz];
1071         self->getTuple(tupleId,tmp);
1072         return convertDblArrToPyList(tmp,sz);
1073       }
1074
1075       static DataArrayDouble *Aggregate(PyObject *li) throw(INTERP_KERNEL::Exception)
1076       {
1077         std::vector<const DataArrayDouble *> tmp;
1078         convertFromPyObjVectorOfObj<const DataArrayDouble *>(li,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",tmp);
1079         return DataArrayDouble::Aggregate(tmp);
1080       }
1081
1082       static DataArrayDouble *Meld(PyObject *li) throw(INTERP_KERNEL::Exception)
1083       {
1084         std::vector<const DataArrayDouble *> tmp;
1085         convertFromPyObjVectorOfObj<const DataArrayDouble *>(li,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",tmp);
1086         return DataArrayDouble::Meld(tmp);
1087       }
1088
1089       PyObject *computeTupleIdsNearTuples(PyObject *pt, double eps) const throw(INTERP_KERNEL::Exception)
1090       {
1091         double val;
1092         DataArrayDouble *a;
1093         DataArrayDoubleTuple *aa;
1094         std::vector<double> bb;
1095         int sw;
1096         int nbComp=self->getNumberOfComponents(),nbTuples=-1;
1097         const char msg[]="Python wrap of DataArrayDouble::computeTupleIdsNearTuples : ";
1098         const double *pos=convertObjToPossibleCpp5_Safe2(pt,sw,val,a,aa,bb,msg,nbComp,true,nbTuples);
1099         MCAuto<DataArrayDouble> inpu=DataArrayDouble::New(); inpu->useArray(pos,false,CPP_DEALLOC,nbTuples,nbComp);
1100         DataArrayInt *c=0,*cI=0;
1101         self->computeTupleIdsNearTuples(inpu,eps,c,cI);
1102         PyObject *ret=PyTuple_New(2);
1103         PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ));
1104         PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ));
1105         return ret;
1106       }
1107
1108       PyObject *areIncludedInMe(const DataArrayDouble *other, double prec) const throw(INTERP_KERNEL::Exception)
1109       {
1110         DataArrayInt *ret1=0;
1111         bool ret0=self->areIncludedInMe(other,prec,ret1);
1112         PyObject *ret=PyTuple_New(2);
1113         PyObject *ret0Py=ret0?Py_True:Py_False;
1114         Py_XINCREF(ret0Py);
1115         PyTuple_SetItem(ret,0,ret0Py);
1116         PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ));
1117         return ret;
1118       }
1119
1120       PyObject *__getitem__(PyObject *obj) throw(INTERP_KERNEL::Exception)
1121       {
1122         const char msg[]="Unexpected situation in DataArrayDouble::__getitem__ !";
1123         const char msg2[]="DataArrayDouble::__getitem__ : Mismatch of slice values in 2nd parameter (components) !";
1124         self->checkAllocated();
1125         int nbOfTuples=self->getNumberOfTuples();
1126         int nbOfComponents=self->getNumberOfComponents();
1127         int it1,ic1;
1128         std::vector<int> vt1,vc1;
1129         std::pair<int, std::pair<int,int> > pt1,pc1;
1130         DataArrayInt *dt1=0,*dc1=0;
1131         int sw;
1132         convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1);
1133         MCAuto<DataArrayDouble> ret;
1134         switch(sw)
1135           {
1136           case 1:
1137             if(nbOfComponents==1)
1138               return PyFloat_FromDouble(self->getIJSafe(it1,0));
1139             return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(&it1,&it1+1)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1140           case 2:
1141             return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size())),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1142           case 3:
1143             return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafeSlice(pt1.first,pt1.second.first,pt1.second.second)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1144           case 4:
1145             return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems())),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1146           case 5:
1147             return PyFloat_FromDouble(self->getIJSafe(it1,ic1));
1148           case 6:
1149             {
1150               ret=self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size());
1151               std::vector<int> v2(1,ic1);
1152               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1153             }
1154           case 7:
1155             {
1156               ret=self->selectByTupleIdSafeSlice(pt1.first,pt1.second.first,pt1.second.second);
1157               std::vector<int> v2(1,ic1);
1158               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1159             }
1160           case 8:
1161             {
1162               ret=self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems());
1163               std::vector<int> v2(1,ic1);
1164               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1165             }
1166           case 9:
1167             {
1168               ret=self->selectByTupleIdSafe(&it1,&it1+1);
1169               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1170             }
1171           case 10:
1172             {
1173               ret=self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size());
1174               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1175             }
1176           case 11:
1177             {
1178               ret=self->selectByTupleIdSafeSlice(pt1.first,pt1.second.first,pt1.second.second);
1179               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1180             }
1181           case 12:
1182             {
1183               ret=self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems());
1184               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1185             }
1186           case 13:
1187             {
1188               ret=self->selectByTupleIdSafe(&it1,&it1+1);
1189               int nbOfComp=DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2);
1190               std::vector<int> v2(nbOfComp);
1191               for(int i=0;i<nbOfComp;i++)
1192                 v2[i]=pc1.first+i*pc1.second.second;
1193               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1194             }
1195           case 14:
1196             {
1197               ret=self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size());
1198               int nbOfComp=DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2);
1199               std::vector<int> v2(nbOfComp);
1200               for(int i=0;i<nbOfComp;i++)
1201                 v2[i]=pc1.first+i*pc1.second.second;
1202               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1203             }
1204           case 15:
1205             {
1206               ret=self->selectByTupleIdSafeSlice(pt1.first,pt1.second.first,pt1.second.second);
1207               int nbOfComp=DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2);
1208               std::vector<int> v2(nbOfComp);
1209               for(int i=0;i<nbOfComp;i++)
1210                 v2[i]=pc1.first+i*pc1.second.second;
1211               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1212             }
1213           case 16:
1214             {
1215               ret=self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems());
1216               int nbOfComp=DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2);
1217               std::vector<int> v2(nbOfComp);
1218               for(int i=0;i<nbOfComp;i++)
1219                 v2[i]=pc1.first+i*pc1.second.second;
1220               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1221             }
1222           default:
1223             throw INTERP_KERNEL::Exception(msg);
1224           }
1225       }
1226
1227       DataArrayDouble *__setitem__(PyObject *obj, PyObject *value) throw(INTERP_KERNEL::Exception)
1228       {
1229         self->checkAllocated();
1230         const char msg[]="Unexpected situation in DataArrayDouble::__setitem__ !";
1231         int nbOfTuples=self->getNumberOfTuples();
1232         int nbOfComponents=self->getNumberOfComponents();
1233         int sw1,sw2;
1234         double i1;
1235         std::vector<double> v1;
1236         DataArrayDouble *d1=0;
1237         convertObjToPossibleCpp4(value,sw1,i1,v1,d1);
1238         int it1,ic1;
1239         std::vector<int> vt1,vc1;
1240         std::pair<int, std::pair<int,int> > pt1,pc1;
1241         DataArrayInt *dt1=0,*dc1=0;
1242         convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw2,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1);
1243         MCAuto<DataArrayDouble> tmp;
1244         switch(sw2)
1245           {
1246           case 1:
1247             {
1248               switch(sw1)
1249                 {
1250                 case 1:
1251                   self->setPartOfValuesSimple1(i1,it1,it1+1,1,0,nbOfComponents,1);
1252                   return self;
1253                 case 2:
1254                   tmp=DataArrayDouble::New();
1255                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1256                   self->setPartOfValues1(tmp,it1,it1+1,1,0,nbOfComponents,1,false);
1257                   return self;
1258                 case 3:
1259                   self->setPartOfValues1(d1,it1,it1+1,1,0,nbOfComponents,1);
1260                   return self;
1261                 default:
1262                   throw INTERP_KERNEL::Exception(msg);
1263                 }
1264               break;
1265             }
1266           case 2:
1267             {
1268               switch(sw1)
1269                 {
1270                 case 1:
1271                   self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1);
1272                   return self;
1273                 case 2:
1274                   tmp=DataArrayDouble::New();
1275                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1276                   self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1,false);
1277                   return self;
1278                 case 3:
1279                   self->setPartOfValues3(d1,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1);
1280                   return self;
1281                 default:
1282                   throw INTERP_KERNEL::Exception(msg);
1283                 }
1284               break;
1285             }
1286           case 3:
1287             {
1288               switch(sw1)
1289                 {
1290                 case 1:
1291                   self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1);
1292                   return self;
1293                 case 2:
1294                   tmp=DataArrayDouble::New();
1295                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1296                   self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1,false);
1297                   return self;
1298                 case 3:
1299                   self->setPartOfValues1(d1,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1);
1300                   return self;
1301                 default:
1302                   throw INTERP_KERNEL::Exception(msg);
1303                 }
1304               break;
1305             }
1306           case 4:
1307             {
1308               switch(sw1)
1309                 {
1310                 case 1:
1311                   self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1);
1312                   return self;
1313                 case 2:
1314                   tmp=DataArrayDouble::New();
1315                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1316                   self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1,false);
1317                   return self;
1318                 case 3:
1319                   self->setPartOfValues3(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1);
1320                   return self;
1321                 default:
1322                   throw INTERP_KERNEL::Exception(msg);
1323                 }
1324               break;
1325             }
1326           case 5:
1327             {
1328               switch(sw1)
1329                 {
1330                 case 1:
1331                   self->setPartOfValuesSimple1(i1,it1,it1+1,1,ic1,ic1+1,1);
1332                   return self;
1333                 case 2:
1334                   tmp=DataArrayDouble::New();
1335                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1336                   self->setPartOfValues1(tmp,it1,it1+1,1,ic1,ic1+1,1,false);
1337                   return self;
1338                 case 3:
1339                   self->setPartOfValues1(d1,it1,it1+1,1,ic1,ic1+1,1);
1340                   return self;
1341                 default:
1342                   throw INTERP_KERNEL::Exception(msg);
1343                 }
1344               break;
1345             }
1346           case 6:
1347             {
1348               switch(sw1)
1349                 {
1350                 case 1:
1351                   self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1);
1352                   return self;
1353                 case 2:
1354                   tmp=DataArrayDouble::New();
1355                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1356                   self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1,false);
1357                   return self;
1358                 case 3:
1359                   self->setPartOfValues3(d1,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1);
1360                   return self;
1361                 default:
1362                   throw INTERP_KERNEL::Exception(msg);
1363                 }
1364               break;
1365             }
1366           case 7:
1367             {
1368               switch(sw1)
1369                 {
1370                 case 1:
1371                   self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1);
1372                   return self;
1373                 case 2:
1374                   tmp=DataArrayDouble::New();
1375                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1376                   self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1,false);
1377                   return self;
1378                 case 3:
1379                   self->setPartOfValues1(d1,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1);
1380                   return self;
1381                 default:
1382                   throw INTERP_KERNEL::Exception(msg);
1383                 }
1384               break;
1385             }
1386           case 8:
1387             {
1388               switch(sw1)
1389                 {
1390                 case 1:
1391                   self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1);
1392                   return self;
1393                 case 2:
1394                   tmp=DataArrayDouble::New();
1395                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1396                   self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1,false);
1397                   return self;
1398                 case 3:
1399                   self->setPartOfValues3(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1);
1400                   return self;
1401                 default:
1402                   throw INTERP_KERNEL::Exception(msg);
1403                 }
1404               break;
1405             }
1406           case 9:
1407             {
1408               switch(sw1)
1409                 {
1410                 case 1:
1411                   self->setPartOfValuesSimple2(i1,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size());
1412                   return self;
1413                 case 2:
1414                   tmp=DataArrayDouble::New();
1415                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1416                   self->setPartOfValues2(tmp,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size(),false);
1417                   return self;
1418                 case 3:
1419                   self->setPartOfValues2(d1,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size());
1420                   return self;
1421                 default:
1422                   throw INTERP_KERNEL::Exception(msg);
1423                 }
1424               break;
1425             }
1426           case 10:
1427             {
1428               switch(sw1)
1429                 {
1430                 case 1:
1431                   self->setPartOfValuesSimple2(i1,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size());
1432                   return self;
1433                 case 2:
1434                   tmp=DataArrayDouble::New();
1435                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1436                   self->setPartOfValues2(tmp,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size(),false);
1437                   return self;
1438                 case 3:
1439                   self->setPartOfValues2(d1,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size());
1440                   return self;
1441                 default:
1442                   throw INTERP_KERNEL::Exception(msg);
1443                 }
1444               break;
1445             }
1446           case 11:
1447             {
1448               switch(sw1)
1449                 {
1450                 case 1:
1451                   self->setPartOfValuesSimple4(i1,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size());
1452                   return self;
1453                 case 2:
1454                   tmp=DataArrayDouble::New();
1455                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1456                   self->setPartOfValues4(tmp,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size(),false);
1457                   return self;
1458                 case 3:
1459                   self->setPartOfValues4(d1,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size());
1460                   return self;
1461                 default:
1462                   throw INTERP_KERNEL::Exception(msg);
1463                 }
1464               break;
1465             }
1466           case 12:
1467             {
1468               switch(sw1)
1469                 {
1470                 case 1:
1471                   self->setPartOfValuesSimple2(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size());
1472                   return self;
1473                 case 2:
1474                   tmp=DataArrayDouble::New();
1475                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1476                   self->setPartOfValues2(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size(),false);
1477                   return self;
1478                 case 3:
1479                   self->setPartOfValues2(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size());
1480                   return self;
1481                 default:
1482                   throw INTERP_KERNEL::Exception(msg);
1483                 }
1484               break;
1485             }
1486           case 13:
1487             {
1488               switch(sw1)
1489                 {
1490                 case 1:
1491                   self->setPartOfValuesSimple1(i1,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second);
1492                   return self;
1493                 case 2:
1494                   tmp=DataArrayDouble::New();
1495                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1496                   self->setPartOfValues1(tmp,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second,false);
1497                   return self;
1498                 case 3:
1499                   self->setPartOfValues1(d1,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second);
1500                   return self;
1501                 default:
1502                   throw INTERP_KERNEL::Exception(msg);
1503                 }
1504               break;
1505             }
1506           case 14:
1507             {
1508               switch(sw1)
1509                 {
1510                 case 1:
1511                   self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second);
1512                   return self;
1513                 case 2:
1514                   tmp=DataArrayDouble::New();
1515                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1516                   self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second,false);
1517                   return self;
1518                 case 3:
1519                   self->setPartOfValues3(d1,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second);
1520                   return self;
1521                 default:
1522                   throw INTERP_KERNEL::Exception(msg);
1523                 }
1524               break;
1525             }
1526           case 15:
1527             {
1528               switch(sw1)
1529                 {
1530                 case 1:
1531                   self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second);
1532                   return self;
1533                 case 2:
1534                   tmp=DataArrayDouble::New();
1535                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1536                   self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second,false);
1537                   return self;
1538                 case 3:
1539                   self->setPartOfValues1(d1,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second);
1540                   return self;
1541                 default:
1542                   throw INTERP_KERNEL::Exception(msg);
1543                 }
1544               break;
1545             }
1546           case 16:
1547             {
1548               switch(sw1)
1549                 {
1550                 case 1:
1551                   self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second);
1552                   return self;
1553                 case 2:
1554                   tmp=DataArrayDouble::New();
1555                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1556                   self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second,false);
1557                   return self;
1558                 case 3:
1559                   self->setPartOfValues3(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second);
1560                   return self;
1561                 default:
1562                   throw INTERP_KERNEL::Exception(msg);
1563                 }
1564               break;
1565             }
1566           default:
1567             throw INTERP_KERNEL::Exception(msg);
1568           }
1569         return self;
1570       }
1571
1572       DataArrayDouble *__neg__() const throw(INTERP_KERNEL::Exception)
1573       {
1574         return self->negate();
1575       }
1576
1577       PyObject *__add__(PyObject *obj) throw(INTERP_KERNEL::Exception)
1578       {
1579         const char msg[]="Unexpected situation in DataArrayDouble.__add__ !";
1580         double val;
1581         DataArrayDouble *a;
1582         DataArrayDoubleTuple *aa;
1583         std::vector<double> bb;
1584         int sw;
1585         //
1586 #ifndef WITHOUT_AUTOFIELD
1587         void *argp;
1588         if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1589           {
1590             MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1591             if(other)
1592               {
1593                 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1594                 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___radd__Impl(other,tmp);
1595                 Py_XDECREF(tmp);
1596                 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1597               }
1598             else
1599               throw INTERP_KERNEL::Exception(msg);
1600           }
1601 #endif
1602         //
1603         convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
1604         switch(sw)
1605           {
1606           case 1:
1607             {
1608               MCAuto<DataArrayDouble> ret=self->deepCopy();
1609               ret->applyLin(1.,val);
1610               return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1611             }
1612           case 2:
1613             {
1614               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1615             }
1616           case 3:
1617             {
1618               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1619               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1620             }
1621           case 4:
1622             {
1623               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
1624               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1625             }
1626           default:
1627             throw INTERP_KERNEL::Exception(msg);
1628           }
1629       }
1630
1631       DataArrayDouble *__radd__(PyObject *obj) throw(INTERP_KERNEL::Exception)
1632       {
1633         const char msg[]="Unexpected situation in __radd__ !";
1634         double val;
1635         DataArrayDouble *a;
1636         DataArrayDoubleTuple *aa;
1637         std::vector<double> bb;
1638         int sw;
1639         convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
1640         switch(sw)
1641           {
1642           case 1:
1643             {
1644               MCAuto<DataArrayDouble> ret=self->deepCopy();
1645               ret->applyLin(1.,val);
1646               return ret.retn();
1647             }
1648           case 3:
1649             {
1650               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1651               return DataArrayDouble::Add(self,aaa);
1652             }
1653           case 4:
1654             {
1655               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
1656               return DataArrayDouble::Add(self,aaa);
1657             }
1658           default:
1659             throw INTERP_KERNEL::Exception(msg);
1660           }
1661       }
1662
1663       PyObject *___iadd___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
1664       {
1665         const char msg[]="Unexpected situation in __iadd__ !";
1666         double val;
1667         DataArrayDouble *a;
1668         DataArrayDoubleTuple *aa;
1669         std::vector<double> bb;
1670         int sw;
1671         convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
1672         switch(sw)
1673           {
1674           case 1:
1675             {
1676               self->applyLin(1.,val);
1677               Py_XINCREF(trueSelf);
1678               return trueSelf;
1679             }
1680           case 2:
1681             {
1682               self->addEqual(a);
1683               Py_XINCREF(trueSelf);
1684               return trueSelf;
1685             }
1686           case 3:
1687             {
1688               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1689               self->addEqual(aaa);
1690               Py_XINCREF(trueSelf);
1691               return trueSelf;
1692             }
1693           case 4:
1694             {
1695               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
1696               self->addEqual(aaa);
1697               Py_XINCREF(trueSelf);
1698               return trueSelf;
1699             }
1700           default:
1701             throw INTERP_KERNEL::Exception(msg);
1702           }
1703       }
1704
1705       PyObject *__sub__(PyObject *obj) throw(INTERP_KERNEL::Exception)
1706       {
1707         const char msg[]="Unexpected situation in __sub__ !";
1708         double val;
1709         DataArrayDouble *a;
1710         DataArrayDoubleTuple *aa;
1711         std::vector<double> bb;
1712         int sw;
1713         //
1714 #ifndef WITHOUT_AUTOFIELD
1715         void *argp;
1716         if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1717           {
1718             MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1719             if(other)
1720               {
1721                 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1722                 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rsub__Impl(other,tmp);
1723                 Py_XDECREF(tmp);
1724                 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1725               }
1726             else
1727               throw INTERP_KERNEL::Exception(msg);
1728           }
1729 #endif
1730         //
1731         convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
1732         switch(sw)
1733           {
1734           case 1:
1735             {
1736               MCAuto<DataArrayDouble> ret=self->deepCopy();
1737               ret->applyLin(1.,-val);
1738               return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1739             }
1740           case 2:
1741             {
1742               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1743             }
1744           case 3:
1745             {
1746               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1747               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1748             }
1749           case 4:
1750             {
1751               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
1752               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1753             }
1754           default:
1755             throw INTERP_KERNEL::Exception(msg);
1756           }
1757       }
1758
1759       DataArrayDouble *__rsub__(PyObject *obj) throw(INTERP_KERNEL::Exception)
1760       {
1761         const char msg[]="Unexpected situation in __rsub__ !";
1762         double val;
1763         DataArrayDouble *a;
1764         DataArrayDoubleTuple *aa;
1765         std::vector<double> bb;
1766         int sw;
1767         convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
1768         switch(sw)
1769           {
1770           case 1:
1771             {
1772               MCAuto<DataArrayDouble> ret=self->deepCopy();
1773               ret->applyLin(-1.,val);
1774               return ret.retn();
1775             }
1776           case 3:
1777             {
1778               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1779               return DataArrayDouble::Substract(aaa,self);
1780             }
1781           case 4:
1782             {
1783               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
1784               return DataArrayDouble::Substract(aaa,self);
1785             }
1786           default:
1787             throw INTERP_KERNEL::Exception(msg);
1788           }
1789       }
1790
1791       PyObject *___isub___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
1792       {
1793         const char msg[]="Unexpected situation in __isub__ !";
1794         double val;
1795         DataArrayDouble *a;
1796         DataArrayDoubleTuple *aa;
1797         std::vector<double> bb;
1798         int sw;
1799         convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
1800         switch(sw)
1801           {
1802           case 1:
1803             {
1804               self->applyLin(1,-val);
1805               Py_XINCREF(trueSelf);
1806               return trueSelf;
1807             }
1808           case 2:
1809             {
1810               self->substractEqual(a);
1811               Py_XINCREF(trueSelf);
1812               return trueSelf;
1813             }
1814           case 3:
1815             {
1816               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1817               self->substractEqual(aaa);
1818               Py_XINCREF(trueSelf);
1819               return trueSelf;
1820             }
1821           case 4:
1822             {
1823               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
1824               self->substractEqual(aaa);
1825               Py_XINCREF(trueSelf);
1826               return trueSelf;
1827             }
1828           default:
1829             throw INTERP_KERNEL::Exception(msg);
1830           }
1831       }
1832
1833       PyObject *__mul__(PyObject *obj) throw(INTERP_KERNEL::Exception)
1834       {
1835         const char msg[]="Unexpected situation in __mul__ !";
1836         double val;
1837         DataArrayDouble *a;
1838         DataArrayDoubleTuple *aa;
1839         std::vector<double> bb;
1840         int sw;
1841         //
1842 #ifndef WITHOUT_AUTOFIELD
1843         void *argp;
1844         if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1845           {
1846             MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1847             if(other)
1848               {
1849                 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1850                 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rmul__Impl(other,tmp);
1851                 Py_XDECREF(tmp);
1852                 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1853               }
1854             else
1855               throw INTERP_KERNEL::Exception(msg);
1856           }
1857 #endif
1858         //
1859         convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
1860         switch(sw)
1861           {
1862           case 1:
1863             {
1864               MCAuto<DataArrayDouble> ret=self->deepCopy();
1865               ret->applyLin(val,0.);
1866               return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1867             }
1868           case 2:
1869             {
1870               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1871             }
1872           case 3:
1873             {
1874               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1875               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1876             }
1877           case 4:
1878             {
1879               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
1880               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1881             }
1882           default:
1883             throw INTERP_KERNEL::Exception(msg);
1884           }
1885       }
1886
1887       DataArrayDouble *__rmul__(PyObject *obj) throw(INTERP_KERNEL::Exception)
1888       {
1889         const char msg[]="Unexpected situation in __rmul__ !";
1890         double val;
1891         DataArrayDouble *a;
1892         DataArrayDoubleTuple *aa;
1893         std::vector<double> bb;
1894         int sw;
1895         convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
1896         switch(sw)
1897           {
1898           case 1:
1899             {
1900               MCAuto<DataArrayDouble> ret=self->deepCopy();
1901               ret->applyLin(val,0.);
1902               return ret.retn();
1903             }
1904           case 3:
1905             {
1906               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1907               return DataArrayDouble::Multiply(self,aaa);
1908             }
1909           case 4:
1910             {
1911               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
1912               return DataArrayDouble::Multiply(self,aaa);
1913             }
1914           default:
1915             throw INTERP_KERNEL::Exception(msg);
1916           }
1917       }
1918
1919       PyObject *___imul___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
1920       {
1921         const char msg[]="Unexpected situation in __imul__ !";
1922         double val;
1923         DataArrayDouble *a;
1924         DataArrayDoubleTuple *aa;
1925         std::vector<double> bb;
1926         int sw;
1927         convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
1928         switch(sw)
1929           {
1930           case 1:
1931             {
1932               self->applyLin(val,0.);
1933               Py_XINCREF(trueSelf);
1934               return trueSelf;
1935             }
1936           case 2:
1937             {
1938               self->multiplyEqual(a);
1939               Py_XINCREF(trueSelf);
1940               return trueSelf;
1941             }
1942           case 3:
1943             {
1944               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1945               self->multiplyEqual(aaa);
1946               Py_XINCREF(trueSelf);
1947               return trueSelf;
1948             }
1949           case 4:
1950             {
1951               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
1952               self->multiplyEqual(aaa);
1953               Py_XINCREF(trueSelf);
1954               return trueSelf;
1955             }
1956           default:
1957             throw INTERP_KERNEL::Exception(msg);
1958           }
1959       }
1960
1961       PyObject *__div__(PyObject *obj) throw(INTERP_KERNEL::Exception)
1962       {
1963         const char msg[]="Unexpected situation in __div__ !";
1964         double val;
1965         DataArrayDouble *a;
1966         DataArrayDoubleTuple *aa;
1967         std::vector<double> bb;
1968         int sw;
1969         //
1970 #ifndef WITHOUT_AUTOFIELD
1971         void *argp;
1972         if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1973           {
1974             MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1975             if(other)
1976               {
1977                 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1978                 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rdiv__Impl(other,tmp);
1979                 Py_XDECREF(tmp);
1980                 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1981               }
1982             else
1983               throw INTERP_KERNEL::Exception(msg);
1984           }
1985 #endif
1986         //
1987         convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
1988         switch(sw)
1989           {
1990           case 1:
1991             {
1992               if(val==0.)
1993                 throw INTERP_KERNEL::Exception("DataArrayDouble::__div__ : trying to divide by zero !");
1994               MCAuto<DataArrayDouble> ret=self->deepCopy();
1995               ret->applyLin(1/val,0.);
1996               return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1997             }
1998           case 2:
1999             {
2000               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
2001             }
2002           case 3:
2003             {
2004               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
2005               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
2006             }
2007           case 4:
2008             {
2009               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
2010               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
2011             }
2012           default:
2013             throw INTERP_KERNEL::Exception(msg);
2014           }
2015       }
2016
2017       DataArrayDouble *__rdiv__(PyObject *obj) throw(INTERP_KERNEL::Exception)
2018       {
2019         const char msg[]="Unexpected situation in __rdiv__ !";
2020         double val;
2021         DataArrayDouble *a;
2022         DataArrayDoubleTuple *aa;
2023         std::vector<double> bb;
2024         int sw;
2025         convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
2026         switch(sw)
2027           {
2028           case 1:
2029             {
2030               MCAuto<DataArrayDouble> ret=self->deepCopy();
2031               ret->applyInv(val);
2032               return ret.retn();
2033             }
2034           case 3:
2035             {
2036               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
2037               return DataArrayDouble::Divide(aaa,self);
2038             }
2039           case 4:
2040             {
2041               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
2042               return DataArrayDouble::Divide(aaa,self);
2043             }
2044           default:
2045             throw INTERP_KERNEL::Exception(msg);
2046           }
2047       }
2048
2049       PyObject *___idiv___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
2050       {
2051         const char msg[]="Unexpected situation in __idiv__ !";
2052         double val;
2053         DataArrayDouble *a;
2054         DataArrayDoubleTuple *aa;
2055         std::vector<double> bb;
2056         int sw;
2057         convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
2058         switch(sw)
2059           {
2060           case 1:
2061             {
2062               if(val==0.)
2063                 throw INTERP_KERNEL::Exception("DataArrayDouble::__div__ : trying to divide by zero !");
2064               self->applyLin(1./val,0.);
2065               Py_XINCREF(trueSelf);
2066               return trueSelf;
2067             }
2068           case 2:
2069             {
2070               self->divideEqual(a);
2071               Py_XINCREF(trueSelf);
2072               return trueSelf;
2073             }
2074           case 3:
2075             {
2076               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
2077               self->divideEqual(aaa);
2078               Py_XINCREF(trueSelf);
2079               return trueSelf;
2080             }
2081           case 4:
2082             {
2083               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
2084               self->divideEqual(aaa);
2085               Py_XINCREF(trueSelf);
2086               return trueSelf;
2087             }
2088           default:
2089             throw INTERP_KERNEL::Exception(msg);
2090           }
2091       }
2092
2093       DataArrayDouble *__pow__(PyObject *obj) throw(INTERP_KERNEL::Exception)
2094       {
2095         const char msg[]="Unexpected situation in __pow__ !";
2096         double val;
2097         DataArrayDouble *a;
2098         DataArrayDoubleTuple *aa;
2099         std::vector<double> bb;
2100         int sw;
2101         convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
2102         switch(sw)
2103           {
2104           case 1:
2105             {
2106               MCAuto<DataArrayDouble> ret=self->deepCopy();
2107               ret->applyPow(val);
2108               return ret.retn();
2109             }
2110           case 2:
2111             {
2112               return DataArrayDouble::Pow(self,a);
2113             }
2114           case 3:
2115             {
2116               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
2117               return DataArrayDouble::Pow(self,aaa);
2118             }
2119           case 4:
2120             {
2121               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
2122               return DataArrayDouble::Pow(self,aaa);
2123             }
2124           default:
2125             throw INTERP_KERNEL::Exception(msg);
2126           }
2127       }
2128
2129       DataArrayDouble *__rpow__(PyObject *obj) throw(INTERP_KERNEL::Exception)
2130       {
2131         const char msg[]="Unexpected situation in __rpow__ !";
2132         double val;
2133         DataArrayDouble *a;
2134         DataArrayDoubleTuple *aa;
2135         std::vector<double> bb;
2136         int sw;
2137         convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
2138         switch(sw)
2139           {
2140           case 1:
2141             {
2142               MCAuto<DataArrayDouble> ret=self->deepCopy();
2143               ret->applyRPow(val);
2144               return ret.retn();
2145             }
2146           case 3:
2147             {
2148               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
2149               return DataArrayDouble::Pow(aaa,self);
2150             }
2151           case 4:
2152             {
2153               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
2154               return DataArrayDouble::Pow(aaa,self);
2155             }
2156           default:
2157             throw INTERP_KERNEL::Exception(msg);
2158           }
2159       }
2160
2161       PyObject *___ipow___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
2162       {
2163         const char msg[]="Unexpected situation in __ipow__ !";
2164         double val;
2165         DataArrayDouble *a;
2166         DataArrayDoubleTuple *aa;
2167         std::vector<double> bb;
2168         int sw;
2169         convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
2170         switch(sw)
2171           {
2172           case 1:
2173             {
2174               self->applyPow(val);
2175               Py_XINCREF(trueSelf);
2176               return trueSelf;
2177             }
2178           case 2:
2179             {
2180               self->powEqual(a);
2181               Py_XINCREF(trueSelf);
2182               return trueSelf;
2183             }
2184           case 3:
2185             {
2186               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
2187               self->powEqual(aaa);
2188               Py_XINCREF(trueSelf);
2189               return trueSelf;
2190             }
2191           case 4:
2192             {
2193               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
2194               self->powEqual(aaa);
2195               Py_XINCREF(trueSelf);
2196               return trueSelf;
2197             }
2198           default:
2199             throw INTERP_KERNEL::Exception(msg);
2200           }
2201       }
2202
2203       PyObject *computeTupleIdsNearTuples(const DataArrayDouble *other, double eps)
2204       {
2205         DataArrayInt *c=0,*cI=0;
2206         //
2207         self->computeTupleIdsNearTuples(other,eps,c,cI);
2208         PyObject *ret=PyTuple_New(2);
2209         PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ));
2210         PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ));
2211         return ret;
2212       }
2213
2214       PyObject *maxPerTupleWithCompoId() const throw(INTERP_KERNEL::Exception)
2215       {
2216         DataArrayInt *ret1=0;
2217         DataArrayDouble *ret0=self->maxPerTupleWithCompoId(ret1);
2218         PyObject *ret=PyTuple_New(2);
2219         PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ));
2220         PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ));
2221         return ret;
2222       }
2223
2224       // serialization
2225       static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception)
2226       {
2227         static const char MSG[]="DataArrayDouble.__new__ : the args in input is expected to be a tuple !";
2228         if(!PyTuple_Check(args))
2229           throw INTERP_KERNEL::Exception(MSG);
2230         PyObject *builtinsd(PyEval_GetBuiltins());//borrowed
2231         PyObject *obj(PyDict_GetItemString(builtinsd,"object"));//borrowed
2232         PyObject *selfMeth(PyObject_GetAttrString(obj,"__new__"));
2233         //
2234         PyObject *tmp0(PyTuple_New(1));
2235         PyTuple_SetItem(tmp0,0,cls); Py_XINCREF(cls);
2236         PyObject *instance(PyObject_CallObject(selfMeth,tmp0));
2237         Py_DECREF(tmp0);
2238         Py_DECREF(selfMeth);
2239         PyObject *initMeth(PyObject_GetAttrString(instance,"__init__"));
2240         int sz(PyTuple_Size(args));
2241
2242         if(PyTuple_Size(args)==2 && PyDict_Check(PyTuple_GetItem(args,1)) && PyDict_Size(PyTuple_GetItem(args,1))==1 )
2243           {// NOT general case. only true if in unpickeling context ! call __init__. Because for all other cases, __init__ is called right after __new__ !
2244             PyObject *zeNumpyRepr(0);
2245             PyObject *tmp1(PyInt_FromLong(0));
2246             zeNumpyRepr=PyDict_GetItem(PyTuple_GetItem(args,1),tmp1);//borrowed
2247             Py_DECREF(tmp1);
2248             PyObject *tmp3(PyTuple_New(1));
2249             PyTuple_SetItem(tmp3,0,zeNumpyRepr); Py_XINCREF(zeNumpyRepr);
2250             PyObject *tmp2(PyObject_CallObject(initMeth,tmp3));
2251             Py_XDECREF(tmp2);
2252             Py_DECREF(tmp3);
2253           }
2254         Py_DECREF(initMeth);
2255         return instance;
2256       }
2257
2258       PyObject *__getnewargs__() throw(INTERP_KERNEL::Exception)
2259       {
2260 #ifdef WITH_NUMPY
2261         if(!self->isAllocated())
2262           throw INTERP_KERNEL::Exception("PyWrap of DataArrayDouble.__getnewargs__ : self is not allocated !");
2263         PyObject *ret(PyTuple_New(1));
2264         PyObject *ret0(PyDict_New());
2265         PyObject *numpyArryObj(MEDCoupling_DataArrayDouble_toNumPyArray(self));
2266         {// create a dict to discriminite in __new__ if __init__ should be called. Not beautiful but not idea ...
2267           PyObject *tmp1(PyInt_FromLong(0));
2268           PyDict_SetItem(ret0,tmp1,numpyArryObj); Py_DECREF(tmp1); Py_DECREF(numpyArryObj);
2269           PyTuple_SetItem(ret,0,ret0);
2270         }
2271         return ret;
2272 #else
2273         throw INTERP_KERNEL::Exception("PyWrap of DataArrayDouble.__getnewargs__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !");
2274 #endif
2275       }
2276     }
2277   };
2278
2279   class DataArrayDoubleTuple;
2280
2281   class DataArrayDoubleIterator
2282   {
2283   public:
2284     DataArrayDoubleIterator(DataArrayDouble *da);
2285     ~DataArrayDoubleIterator();
2286     %extend
2287     {
2288       PyObject *next()
2289       {
2290         DataArrayDoubleTuple *ret=self->nextt();
2291         if(ret)
2292           return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayDoubleTuple,SWIG_POINTER_OWN|0);
2293         else
2294           {
2295             PyErr_SetString(PyExc_StopIteration,"No more data.");
2296             return 0;
2297           }
2298       }
2299     }
2300   };
2301
2302   class DataArrayDoubleTuple
2303   {
2304   public:
2305     int getNumberOfCompo() const throw(INTERP_KERNEL::Exception);
2306     DataArrayDouble *buildDADouble(int nbOfTuples, int nbOfCompo) const throw(INTERP_KERNEL::Exception);
2307     %extend
2308     {
2309       std::string __str__() const throw(INTERP_KERNEL::Exception)
2310       {
2311         return self->repr();
2312       }
2313
2314       double __float__() const throw(INTERP_KERNEL::Exception)
2315       {
2316         return self->doubleValue();
2317       }
2318
2319       DataArrayDouble *buildDADouble() throw(INTERP_KERNEL::Exception)
2320       {
2321         return self->buildDADouble(1,self->getNumberOfCompo());
2322       }
2323
2324       PyObject *___iadd___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
2325       {
2326         MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2327         MEDCoupling_DataArrayDouble____iadd___(ret,0,obj);
2328         Py_XINCREF(trueSelf);
2329         return trueSelf;
2330       }
2331
2332       PyObject *___isub___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
2333       {
2334         MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2335         MEDCoupling_DataArrayDouble____isub___(ret,0,obj);
2336         Py_XINCREF(trueSelf);
2337         return trueSelf;
2338       }
2339
2340       PyObject *___imul___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
2341       {
2342         MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2343         MEDCoupling_DataArrayDouble____imul___(ret,0,obj);
2344         Py_XINCREF(trueSelf);
2345         return trueSelf;
2346       }
2347
2348       PyObject *___idiv___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
2349       {
2350         MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2351         MEDCoupling_DataArrayDouble____idiv___(ret,0,obj);
2352         Py_XINCREF(trueSelf);
2353         return trueSelf;
2354       }
2355
2356       PyObject *__len__() throw(INTERP_KERNEL::Exception)
2357       {
2358         return PyInt_FromLong(self->getNumberOfCompo());
2359       }
2360
2361       PyObject *__getitem__(PyObject *obj) throw(INTERP_KERNEL::Exception)
2362       {
2363         const char msg2[]="DataArrayDoubleTuple::__getitem__ : Mismatch of slice values in 2nd parameter (components) !";
2364         int sw;
2365         int singleVal;
2366         std::vector<int> multiVal;
2367         std::pair<int, std::pair<int,int> > slic;
2368         MEDCoupling::DataArrayInt *daIntTyypp=0;
2369         const double *pt=self->getConstPointer();
2370         int nbc=self->getNumberOfCompo();
2371         convertObjToPossibleCpp2WithNegIntInterp(obj,nbc,sw,singleVal,multiVal,slic,daIntTyypp);
2372         switch(sw)
2373           {
2374           case 1:
2375             {
2376               if(singleVal>=nbc)
2377                 {
2378                   std::ostringstream oss;
2379                   oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2380                   PyErr_SetString(PyExc_StopIteration,oss.str().c_str());
2381                   return 0;
2382                 }
2383               if(singleVal>=0)
2384                 return PyFloat_FromDouble(pt[singleVal]);
2385               else
2386                 {
2387                   if(nbc+singleVal>0)
2388                     return PyFloat_FromDouble(pt[nbc+singleVal]);
2389                   else
2390                     {
2391                       std::ostringstream oss;
2392                       oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2393                       throw INTERP_KERNEL::Exception(oss.str().c_str());
2394                     }
2395                 }
2396             }
2397           case 2:
2398             {
2399               PyObject *t=PyTuple_New(multiVal.size());
2400               for(int j=0;j<(int)multiVal.size();j++)
2401                 {
2402                   int cid=multiVal[j];
2403                   if(cid>=nbc)
2404                     {
2405                       std::ostringstream oss;
2406                       oss << "Requesting for id #" << cid << " having only " << nbc << " components !";
2407                       throw INTERP_KERNEL::Exception(oss.str().c_str());
2408                     }
2409                   PyTuple_SetItem(t,j,PyFloat_FromDouble(pt[cid]));
2410                 }
2411               return t;
2412             }
2413           case 3:
2414             {
2415               int sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2416               PyObject *t=PyTuple_New(sz);
2417               for(int j=0;j<sz;j++)
2418                 PyTuple_SetItem(t,j,PyFloat_FromDouble(pt[slic.first+j*slic.second.second]));
2419               return t;
2420             }
2421           default:
2422             throw INTERP_KERNEL::Exception("DataArrayDoubleTuple::__getitem__ : unrecognized type entered !");
2423           }
2424       }
2425
2426       DataArrayDoubleTuple *__setitem__(PyObject *obj, PyObject *value) throw(INTERP_KERNEL::Exception)
2427       {
2428         const char msg[]="DataArrayDoubleTuple::__setitem__ : unrecognized type entered, int, slice, list<int>, tuple<int> !";
2429         const char msg2[]="DataArrayDoubleTuple::__setitem__ : Mismatch of slice values in 2nd parameter (components) !";
2430         int sw1,sw2;
2431         double singleValV;
2432         std::vector<double> multiValV;
2433         MEDCoupling::DataArrayDoubleTuple *daIntTyyppV=0;
2434         int nbc=self->getNumberOfCompo();
2435         convertObjToPossibleCpp44(value,sw1,singleValV,multiValV,daIntTyyppV);
2436         int singleVal;
2437         std::vector<int> multiVal;
2438         std::pair<int, std::pair<int,int> > slic;
2439         MEDCoupling::DataArrayInt *daIntTyypp=0;
2440         double *pt=self->getPointer();
2441         convertObjToPossibleCpp2WithNegIntInterp(obj,nbc,sw2,singleVal,multiVal,slic,daIntTyypp);
2442         switch(sw2)
2443           {
2444           case 1:
2445             {
2446               if(singleVal>=nbc)
2447                 {
2448                   std::ostringstream oss;
2449                   oss << "Requesting for setting id # " << singleVal << " having only " << nbc << " components !";
2450                   throw INTERP_KERNEL::Exception(oss.str().c_str());
2451                 }
2452               switch(sw1)
2453                 {
2454                 case 1:
2455                   {
2456                     pt[singleVal]=singleValV;
2457                     return self;
2458                   }
2459                 case 2:
2460                   {
2461                     if(multiValV.size()!=1)
2462                       {
2463                         std::ostringstream oss;
2464                         oss << "Requesting for setting id # " << singleVal << " with a list or tuple with size != 1 ! ";
2465                         throw INTERP_KERNEL::Exception(oss.str().c_str());
2466                       }
2467                     pt[singleVal]=multiValV[0];
2468                     return self;
2469                   }
2470                 case 3:
2471                   {
2472                     pt[singleVal]=daIntTyyppV->getConstPointer()[0];
2473                     return self;
2474                   }
2475                 default:
2476                   throw INTERP_KERNEL::Exception(msg);
2477                 }
2478             }
2479           case 2:
2480             {
2481               switch(sw1)
2482                 {
2483                 case 1:
2484                   {
2485                     for(std::vector<int>::const_iterator it=multiVal.begin();it!=multiVal.end();it++)
2486                       {
2487                         if(*it>=nbc)
2488                           {
2489                             std::ostringstream oss;
2490                             oss << "Requesting for setting id # " << *it << " having only " << nbc << " components !";
2491                             throw INTERP_KERNEL::Exception(oss.str().c_str());
2492                           }
2493                         pt[*it]=singleValV;
2494                       }
2495                     return self;
2496                   }
2497                 case 2:
2498                   {
2499                     if(multiVal.size()!=multiValV.size())
2500                       {
2501                         std::ostringstream oss;
2502                         oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << multiVal.size() << " !";
2503                         throw INTERP_KERNEL::Exception(oss.str().c_str());
2504                       }
2505                     for(int i=0;i<(int)multiVal.size();i++)
2506                       {
2507                         int pos=multiVal[i];
2508                         if(pos>=nbc)
2509                           {
2510                             std::ostringstream oss;
2511                             oss << "Requesting for setting id # " << pos << " having only " << nbc << " components !";
2512                             throw INTERP_KERNEL::Exception(oss.str().c_str());
2513                           }
2514                         pt[multiVal[i]]=multiValV[i];
2515                       }
2516                     return self;
2517                   }
2518                 case 3:
2519                   {
2520                     const double *ptV=daIntTyyppV->getConstPointer();
2521                     if(nbc>daIntTyyppV->getNumberOfCompo())
2522                       {
2523                         std::ostringstream oss;
2524                         oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2525                         throw INTERP_KERNEL::Exception(oss.str().c_str());
2526                       }
2527                     std::copy(ptV,ptV+nbc,pt);
2528                     return self;
2529                   }
2530                 default:
2531                   throw INTERP_KERNEL::Exception(msg);
2532                 }
2533             }
2534           case 3:
2535             {
2536               int sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2537               switch(sw1)
2538                 {
2539                 case 1:
2540                   {
2541                     for(int j=0;j<sz;j++)
2542                       pt[slic.first+j*slic.second.second]=singleValV;
2543                     return self;
2544                   }
2545                 case 2:
2546                   {
2547                     if(sz!=(int)multiValV.size())
2548                       {
2549                         std::ostringstream oss;
2550                         oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << sz << " !";
2551                         throw INTERP_KERNEL::Exception(oss.str().c_str());
2552                       }
2553                     for(int j=0;j<sz;j++)
2554                       pt[slic.first+j*slic.second.second]=multiValV[j];
2555                     return self;
2556                   }
2557                 case 3:
2558                   {
2559                     const double *ptV=daIntTyyppV->getConstPointer();
2560                     if(sz>daIntTyyppV->getNumberOfCompo())
2561                       {
2562                         std::ostringstream oss;
2563                         oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2564                         throw INTERP_KERNEL::Exception(oss.str().c_str());
2565                       }
2566                     for(int j=0;j<sz;j++)
2567                       pt[slic.first+j*slic.second.second]=ptV[j];
2568                     return self;
2569                   }
2570                 default:
2571                   throw INTERP_KERNEL::Exception(msg);
2572                 }
2573             }
2574           default:
2575             throw INTERP_KERNEL::Exception(msg);
2576           }
2577       }
2578     }
2579   };
2580
2581   class DataArrayIntIterator;
2582
2583   class DataArrayInt : public DataArray
2584   {
2585   public:
2586     static DataArrayInt *New();
2587     int intValue() const throw(INTERP_KERNEL::Exception);
2588     int getHashCode() const throw(INTERP_KERNEL::Exception);
2589     bool empty() const throw(INTERP_KERNEL::Exception);
2590     DataArrayInt *performCopyOrIncrRef(bool deepCopy) const throw(INTERP_KERNEL::Exception);
2591     void deepCopyFrom(const DataArrayInt& other) throw(INTERP_KERNEL::Exception);
2592     void reserve(std::size_t nbOfElems) throw(INTERP_KERNEL::Exception);
2593     void pushBackSilent(int val) throw(INTERP_KERNEL::Exception);
2594     int popBackSilent() throw(INTERP_KERNEL::Exception);
2595     void pack() const throw(INTERP_KERNEL::Exception);
2596     void allocIfNecessary(int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception);
2597     bool isEqual(const DataArrayInt& other) const throw(INTERP_KERNEL::Exception);
2598     bool isEqualWithoutConsideringStr(const DataArrayInt& other) const throw(INTERP_KERNEL::Exception);
2599     bool isEqualWithoutConsideringStrAndOrder(const DataArrayInt& other) const throw(INTERP_KERNEL::Exception);
2600     DataArrayInt *buildPermutationArr(const DataArrayInt& other) const throw(INTERP_KERNEL::Exception);
2601     DataArrayInt *sumPerTuple() const throw(INTERP_KERNEL::Exception);
2602     void sort(bool asc=true) throw(INTERP_KERNEL::Exception);
2603     void reverse() throw(INTERP_KERNEL::Exception);
2604     void checkMonotonic(bool increasing) const throw(INTERP_KERNEL::Exception);
2605     bool isMonotonic(bool increasing) const throw(INTERP_KERNEL::Exception);
2606     void checkStrictlyMonotonic(bool increasing) const throw(INTERP_KERNEL::Exception);
2607     bool isStrictlyMonotonic(bool increasing) const throw(INTERP_KERNEL::Exception);
2608     void fillWithZero() throw(INTERP_KERNEL::Exception);
2609     void fillWithValue(int val) throw(INTERP_KERNEL::Exception);
2610     void iota(int init=0) throw(INTERP_KERNEL::Exception);
2611     std::string repr() const throw(INTERP_KERNEL::Exception);
2612     std::string reprZip() const throw(INTERP_KERNEL::Exception);
2613     std::string reprNotTooLong() const throw(INTERP_KERNEL::Exception);
2614     DataArrayInt *invertArrayO2N2N2O(int newNbOfElem) const throw(INTERP_KERNEL::Exception);
2615     DataArrayInt *invertArrayN2O2O2N(int oldNbOfElem) const throw(INTERP_KERNEL::Exception);
2616     DataArrayInt *invertArrayO2N2N2OBis(int newNbOfElem) const throw(INTERP_KERNEL::Exception);
2617     DataArrayDouble *convertToDblArr() const throw(INTERP_KERNEL::Exception);
2618     DataArrayInt *fromNoInterlace() const throw(INTERP_KERNEL::Exception);
2619     DataArrayInt *toNoInterlace() const throw(INTERP_KERNEL::Exception);
2620     DataArrayInt *selectByTupleIdSafeSlice(int bg, int end, int step) const throw(INTERP_KERNEL::Exception);
2621     DataArrayInt *checkAndPreparePermutation() const throw(INTERP_KERNEL::Exception);
2622     DataArrayInt *buildPermArrPerLevel() const throw(INTERP_KERNEL::Exception);
2623     bool isIota(int sizeExpected) const throw(INTERP_KERNEL::Exception);
2624     bool isUniform(int val) const throw(INTERP_KERNEL::Exception);
2625     bool hasUniqueValues() const throw(INTERP_KERNEL::Exception);
2626     DataArrayInt *subArray(int tupleIdBg, int tupleIdEnd=-1) const throw(INTERP_KERNEL::Exception);
2627     void transpose() throw(INTERP_KERNEL::Exception);
2628     DataArrayInt *changeNbOfComponents(int newNbOfComp, int dftValue) const throw(INTERP_KERNEL::Exception);
2629     void meldWith(const DataArrayInt *other) throw(INTERP_KERNEL::Exception);
2630     void setPartOfValues1(const DataArrayInt *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare=true) throw(INTERP_KERNEL::Exception);
2631     void setPartOfValuesSimple1(int a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp) throw(INTERP_KERNEL::Exception);
2632     void setPartOfValuesAdv(const DataArrayInt *a, const DataArrayInt *tuplesSelec) throw(INTERP_KERNEL::Exception);
2633     void getTuple(int tupleId, int *res) const throw(INTERP_KERNEL::Exception);
2634     int getIJ(int tupleId, int compoId) const throw(INTERP_KERNEL::Exception);
2635     int getIJSafe(int tupleId, int compoId) const throw(INTERP_KERNEL::Exception);
2636     int front() const throw(INTERP_KERNEL::Exception);
2637     int back() const throw(INTERP_KERNEL::Exception);
2638     void setIJ(int tupleId, int compoId, int newVal) throw(INTERP_KERNEL::Exception);
2639     void setIJSilent(int tupleId, int compoId, int newVal) throw(INTERP_KERNEL::Exception);
2640     int *getPointer() throw(INTERP_KERNEL::Exception);
2641     const int *getConstPointer() const throw(INTERP_KERNEL::Exception);
2642     DataArrayIntIterator *iterator() throw(INTERP_KERNEL::Exception);
2643     const int *begin() const throw(INTERP_KERNEL::Exception);
2644     const int *end() const throw(INTERP_KERNEL::Exception);
2645     DataArrayInt *findIdsEqual(int val) const throw(INTERP_KERNEL::Exception);
2646     DataArrayInt *findIdsNotEqual(int val) const throw(INTERP_KERNEL::Exception);
2647     int changeValue(int oldValue, int newValue) throw(INTERP_KERNEL::Exception);
2648     int findIdFirstEqualTuple(const std::vector<int>& tupl) const throw(INTERP_KERNEL::Exception);
2649     int findIdFirstEqual(int value) const throw(INTERP_KERNEL::Exception);
2650     int findIdFirstEqual(const std::vector<int>& vals) const throw(INTERP_KERNEL::Exception);
2651     int findIdSequence(const std::vector<int>& vals) const throw(INTERP_KERNEL::Exception);
2652     bool presenceOfTuple(const std::vector<int>& tupl) const throw(INTERP_KERNEL::Exception);
2653     bool presenceOfValue(int value) const throw(INTERP_KERNEL::Exception);
2654     bool presenceOfValue(const std::vector<int>& vals) const throw(INTERP_KERNEL::Exception);
2655     int count(int value) const throw(INTERP_KERNEL::Exception);
2656     int accumulate(int compId) const throw(INTERP_KERNEL::Exception);
2657     int getMaxValue(int& tupleId) const throw(INTERP_KERNEL::Exception);
2658     int getMaxValueInArray() const throw(INTERP_KERNEL::Exception);
2659     int getMinValue(int& tupleId) const throw(INTERP_KERNEL::Exception);
2660     int getMinValueInArray() const throw(INTERP_KERNEL::Exception);
2661     void abs() throw(INTERP_KERNEL::Exception);
2662     DataArrayInt *computeAbs() const throw(INTERP_KERNEL::Exception);
2663     void applyLin(int a, int b, int compoId) throw(INTERP_KERNEL::Exception);
2664     void applyLin(int a, int b) throw(INTERP_KERNEL::Exception);
2665     void applyInv(int numerator) throw(INTERP_KERNEL::Exception);
2666     DataArrayInt *negate() const throw(INTERP_KERNEL::Exception);
2667     void applyDivideBy(int val) throw(INTERP_KERNEL::Exception);
2668     void applyModulus(int val) throw(INTERP_KERNEL::Exception);
2669     void applyRModulus(int val) throw(INTERP_KERNEL::Exception);
2670     void applyPow(int val) throw(INTERP_KERNEL::Exception);
2671     void applyRPow(int val) throw(INTERP_KERNEL::Exception);
2672     DataArrayInt *findIdsInRange(int vmin, int vmax) const throw(INTERP_KERNEL::Exception);
2673     DataArrayInt *findIdsNotInRange(int vmin, int vmax) const throw(INTERP_KERNEL::Exception);
2674     DataArrayInt *findIdsStricltyNegative() const throw(INTERP_KERNEL::Exception);
2675     bool checkAllIdsInRange(int vmin, int vmax) const throw(INTERP_KERNEL::Exception);
2676     static DataArrayInt *Aggregate(const DataArrayInt *a1, const DataArrayInt *a2, int offsetA2) throw(INTERP_KERNEL::Exception);
2677     static DataArrayInt *Meld(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception);
2678     static DataArrayInt *MakePartition(const std::vector<const DataArrayInt *>& groups, int newNb, std::vector< std::vector<int> >& fidsOfGroups) throw(INTERP_KERNEL::Exception);
2679     static DataArrayInt *BuildUnion(const std::vector<const DataArrayInt *>& arr) throw(INTERP_KERNEL::Exception);
2680     static DataArrayInt *BuildIntersection(const std::vector<const DataArrayInt *>& arr) throw(INTERP_KERNEL::Exception);
2681     static DataArrayInt *FindPermutationFromFirstToSecond(const DataArrayInt *ids1, const DataArrayInt *ids2) throw(INTERP_KERNEL::Exception);
2682     DataArrayInt *buildComplement(int nbOfElement) const throw(INTERP_KERNEL::Exception);
2683     DataArrayInt *buildSubstraction(const DataArrayInt *other) const throw(INTERP_KERNEL::Exception);
2684     DataArrayInt *buildSubstractionOptimized(const DataArrayInt *other) const throw(INTERP_KERNEL::Exception);
2685     DataArrayInt *buildUnion(const DataArrayInt *other) const throw(INTERP_KERNEL::Exception);
2686     DataArrayInt *buildIntersection(const DataArrayInt *other) const throw(INTERP_KERNEL::Exception);
2687     DataArrayInt *buildUnique() const throw(INTERP_KERNEL::Exception);
2688     DataArrayInt *buildUniqueNotSorted() const throw(INTERP_KERNEL::Exception);
2689     DataArrayInt *deltaShiftIndex() const throw(INTERP_KERNEL::Exception);
2690     void computeOffsets() throw(INTERP_KERNEL::Exception);
2691     void computeOffsetsFull() throw(INTERP_KERNEL::Exception);
2692     DataArrayInt *buildExplicitArrByRanges(const DataArrayInt *offsets) const throw(INTERP_KERNEL::Exception);
2693     DataArrayInt *findRangeIdForEachTuple(const DataArrayInt *ranges) const throw(INTERP_KERNEL::Exception);
2694     DataArrayInt *findIdInRangeForEachTuple(const DataArrayInt *ranges) const throw(INTERP_KERNEL::Exception);
2695     void sortEachPairToMakeALinkedList() throw(INTERP_KERNEL::Exception);
2696     DataArrayInt *duplicateEachTupleNTimes(int nbTimes) const throw(INTERP_KERNEL::Exception);
2697     DataArrayInt *getDifferentValues() const throw(INTERP_KERNEL::Exception);
2698     static DataArrayInt *Add(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception);
2699     void addEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception);
2700     static DataArrayInt *Substract(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception);
2701     void substractEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception);
2702     static DataArrayInt *Multiply(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception);
2703     void multiplyEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception);
2704     static DataArrayInt *Divide(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception);
2705     void divideEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception);
2706     static DataArrayInt *Modulus(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception);
2707     void modulusEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception);
2708     static DataArrayInt *Pow(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception);
2709     void powEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception);
2710   public:
2711     static DataArrayInt *Range(int begin, int end, int step) throw(INTERP_KERNEL::Exception);
2712     %extend
2713     {
2714       DataArrayInt() throw(INTERP_KERNEL::Exception)
2715         {
2716           return DataArrayInt::New();
2717         }
2718
2719       static DataArrayInt *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) throw(INTERP_KERNEL::Exception)
2720       {
2721         const char *msgBase="MEDCoupling::DataArrayInt::New : Available API are : \n-DataArrayInt.New()\n-DataArrayInt.New([1,3,4])\n-DataArrayInt.New([1,3,4],3)\n-DataArrayInt.New([1,3,4,5],2,2)\n-DataArrayInt.New([1,3,4,5,7,8],3,2)\n-DataArrayInt.New([(1,3),(4,5),(7,8)])\n-DataArrayInt.New(5)\n-DataArrayInt.New(5,2)";
2722         std::string msg(msgBase);
2723 #ifdef WITH_NUMPY
2724         msg+="\n-DataArrayInt.New(numpy array with dtype=int32)";
2725 #endif
2726         msg+=" !";
2727         if(PyList_Check(elt0) || PyTuple_Check(elt0))
2728           {
2729             if(nbOfTuples)
2730               {
2731                 if(PyInt_Check(nbOfTuples))
2732                   {
2733                     int nbOfTuples1=PyInt_AS_LONG(nbOfTuples);
2734                     if(nbOfTuples1<0)
2735                       throw INTERP_KERNEL::Exception("DataArrayInt::New : should be a positive set of allocated memory !");
2736                     if(nbOfComp)
2737                       {
2738                         if(PyInt_Check(nbOfComp))
2739                           {//DataArrayInt.New([1,3,4,5],2,2)
2740                             int nbOfCompo=PyInt_AS_LONG(nbOfComp);
2741                             if(nbOfCompo<0)
2742                               throw INTERP_KERNEL::Exception("DataArrayInt::New : should be a positive number of components !");
2743                             MCAuto<DataArrayInt> ret=DataArrayInt::New();
2744                             std::vector<int> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
2745                             ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2746                             return ret.retn();
2747                           }
2748                         else
2749                           throw INTERP_KERNEL::Exception(msg.c_str());
2750                       }
2751                     else
2752                       {//DataArrayInt.New([1,3,4],3)
2753                         MCAuto<DataArrayInt> ret=DataArrayInt::New();
2754                         int tmpp1=-1;
2755                         std::vector<int> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
2756                         ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2757                         return ret.retn();
2758                       }
2759                   }
2760                 else
2761                   throw INTERP_KERNEL::Exception(msg.c_str());
2762               }
2763             else
2764               {// DataArrayInt.New([1,3,4])
2765                 MCAuto<DataArrayInt> ret=DataArrayInt::New();
2766                 int tmpp1=-1,tmpp2=-1;
2767                 std::vector<int> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
2768                 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2769                 return ret.retn();
2770               }
2771           }
2772         else if(PyInt_Check(elt0))
2773           {
2774             int nbOfTuples1=PyInt_AS_LONG(elt0);
2775             if(nbOfTuples1<0)
2776               throw INTERP_KERNEL::Exception("DataArrayInt::New : should be a positive set of allocated memory !");
2777             if(nbOfTuples)
2778               {
2779                 if(!nbOfComp)
2780                   {
2781                     if(PyInt_Check(nbOfTuples))
2782                       {//DataArrayInt.New(5,2)
2783                         int nbOfCompo=PyInt_AS_LONG(nbOfTuples);
2784                         if(nbOfCompo<0)
2785                           throw INTERP_KERNEL::Exception("DataArrayInt::New : should be a positive number of components !");
2786                         MCAuto<DataArrayInt> ret=DataArrayInt::New();
2787                         ret->alloc(nbOfTuples1,nbOfCompo);
2788                         return ret.retn();
2789                       }
2790                     else
2791                       throw INTERP_KERNEL::Exception(msg.c_str());
2792                   }
2793                 else
2794                   throw INTERP_KERNEL::Exception(msg.c_str());
2795               }
2796             else
2797               {//DataArrayInt.New(5)
2798                 MCAuto<DataArrayInt> ret=DataArrayInt::New();
2799                 ret->alloc(nbOfTuples1,1);
2800                 return ret.retn();
2801               }
2802           }
2803 #ifdef WITH_NUMPY
2804         else if(PyArray_Check(elt0) && nbOfTuples==NULL && nbOfComp==NULL)
2805           {//DataArrayInt.New(numpyArray)
2806             return BuildNewInstance<DataArrayInt,int>(elt0,NPY_INT32,&PyCallBackDataArrayInt_RefType,"INT32");
2807           }
2808 #endif
2809         else
2810           throw INTERP_KERNEL::Exception(msg.c_str());
2811         throw INTERP_KERNEL::Exception(msg.c_str());//to make g++ happy
2812       }
2813
2814       DataArrayInt(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) throw(INTERP_KERNEL::Exception)
2815         {
2816           return MEDCoupling_DataArrayInt_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
2817         }
2818
2819       std::string __str__() const throw(INTERP_KERNEL::Exception)
2820       {
2821         return self->reprNotTooLong();
2822       }
2823
2824       int __len__() const throw(INTERP_KERNEL::Exception)
2825       {
2826         if(self->isAllocated())
2827           {
2828             return self->getNumberOfTuples();
2829           }
2830         else
2831           {
2832             throw INTERP_KERNEL::Exception("DataArrayInt::__len__ : Instance is NOT allocated !");
2833           }
2834       }
2835
2836       int __int__() const throw(INTERP_KERNEL::Exception)
2837       {
2838         return self->intValue();
2839       }
2840
2841       DataArrayIntIterator *__iter__() throw(INTERP_KERNEL::Exception)
2842       {
2843         return self->iterator();
2844       }
2845
2846       PyObject *accumulate() const throw(INTERP_KERNEL::Exception)
2847       {
2848         int sz=self->getNumberOfComponents();
2849         INTERP_KERNEL::AutoPtr<int> tmp=new int[sz];
2850         self->accumulate(tmp);
2851         return convertIntArrToPyList(tmp,sz);
2852       }
2853
2854       DataArrayInt *accumulatePerChunck(PyObject *indexArr) const throw(INTERP_KERNEL::Exception)
2855       {
2856         int sw,sz,val;
2857         std::vector<int> val2;
2858         const int *bg=convertObjToPossibleCpp1_Safe(indexArr,sw,sz,val,val2);
2859         return self->accumulatePerChunck(bg,bg+sz);
2860       }
2861
2862       DataArrayInt *findIdsEqualTuple(PyObject *inputTuple) const throw(INTERP_KERNEL::Exception)
2863       {
2864         int sw,sz,val;
2865         std::vector<int> val2;
2866         const int *bg(convertObjToPossibleCpp1_Safe(inputTuple,sw,sz,val,val2));
2867         return self->findIdsEqualTuple(bg,bg+sz);
2868       }
2869
2870       PyObject *splitInBalancedSlices(int nbOfSlices) const throw(INTERP_KERNEL::Exception)
2871       {
2872         std::vector< std::pair<int,int> > slcs(self->splitInBalancedSlices(nbOfSlices));
2873         PyObject *ret=PyList_New(slcs.size());
2874         for(std::size_t i=0;i<slcs.size();i++)
2875           PyList_SetItem(ret,i,PySlice_New(PyInt_FromLong(slcs[i].first),PyInt_FromLong(slcs[i].second),PyInt_FromLong(1)));
2876         return ret;
2877       }
2878
2879       DataArrayInt *buildExplicitArrOfSliceOnScaledArr(PyObject *slic) const throw(INTERP_KERNEL::Exception)
2880       {
2881         if(!PySlice_Check(slic))
2882           throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr (wrap) : expecting a pyslice as second (first) parameter !");
2883         Py_ssize_t strt=2,stp=2,step=2;
2884         PySliceObject *sly=reinterpret_cast<PySliceObject *>(slic);
2885         GetIndicesOfSliceExplicitely(sly,&strt,&stp,&step,"DataArrayInt::buildExplicitArrOfSliceOnScaledArr (wrap) : the input slice is invalid !");
2886         if(strt==std::numeric_limits<int>::max() || stp==std::numeric_limits<int>::max())
2887           throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr (wrap) : the input slice contains some unknowns that can't be determined in static method ! Call DataArray::getSlice (non static) instead !");
2888         return self->buildExplicitArrOfSliceOnScaledArr(strt,stp,step);
2889       }
2890
2891       PyObject *getMinMaxValues() const throw(INTERP_KERNEL::Exception)
2892       {
2893         int a,b;
2894         self->getMinMaxValues(a,b);
2895         PyObject *ret=PyTuple_New(2);
2896         PyTuple_SetItem(ret,0,PyInt_FromLong(a));
2897         PyTuple_SetItem(ret,1,PyInt_FromLong(b));
2898         return ret;
2899       }
2900
2901       static PyObject *ConvertIndexArrayToO2N(int nbOfOldTuples, PyObject *arr, PyObject *arrI) throw(INTERP_KERNEL::Exception)
2902       {
2903         int newNbOfTuples=-1;
2904         int szArr,szArrI,sw,iTypppArr,iTypppArrI;
2905         std::vector<int> stdvecTyyppArr,stdvecTyyppArrI;
2906         const int *arrPtr=convertObjToPossibleCpp1_Safe(arr,sw,szArr,iTypppArr,stdvecTyyppArr);
2907         const int *arrIPtr=convertObjToPossibleCpp1_Safe(arrI,sw,szArrI,iTypppArrI,stdvecTyyppArrI);
2908         DataArrayInt *ret0=MEDCoupling::DataArrayInt::ConvertIndexArrayToO2N(nbOfOldTuples,arrPtr,arrIPtr,arrIPtr+szArrI,newNbOfTuples);
2909         PyObject *ret=PyTuple_New(2);
2910         PyTuple_SetItem(ret,0,SWIG_NewPointerObj((void*)ret0,SWIGTYPE_p_MEDCoupling__DataArrayInt,SWIG_POINTER_OWN | 0));
2911         PyTuple_SetItem(ret,1,PyInt_FromLong(newNbOfTuples));
2912         return ret;
2913       }
2914
2915       static DataArrayInt *CheckAndPreparePermutation(PyObject *arr) throw(INTERP_KERNEL::Exception)
2916       {
2917         MCAuto<DataArrayInt> ret(DataArrayInt::New());
2918         int szArr,sw,iTypppArr;
2919         std::vector<int> stdvecTyyppArr;
2920         const int *arrPtr(convertObjToPossibleCpp1_Safe(arr,sw,szArr,iTypppArr,stdvecTyyppArr));
2921         int *pt(MEDCoupling::DataArrayInt::CheckAndPreparePermutation(arrPtr,arrPtr+szArr));
2922         ret->useArray(pt,true,MEDCoupling::C_DEALLOC,szArr,1);
2923         return ret.retn();
2924       }
2925
2926       void setValues(PyObject *li, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) throw(INTERP_KERNEL::Exception)
2927       {
2928         const char *msg="MEDCoupling::DataArrayInt::setValues : Available API are : \n-DataArrayInt.setValues([1,3,4])\n-DataArrayInt.setValues([1,3,4],3)\n-DataArrayInt.setValues([1,3,4,5],2,2)\n-DataArrayInt.New(5)\n !";
2929         if(PyList_Check(li) || PyTuple_Check(li))
2930           {
2931             if(nbOfTuples)
2932               {
2933                 if(PyInt_Check(nbOfTuples))
2934                   {
2935                     int nbOfTuples1=PyInt_AS_LONG(nbOfTuples);
2936                     if(nbOfTuples<0)
2937                       throw INTERP_KERNEL::Exception("DataArrayInt::setValue : should be a positive set of allocated memory !");
2938                     if(nbOfComp)
2939                       {
2940                         if(PyInt_Check(nbOfComp))
2941                           {//DataArrayInt.setValues([1,3,4,5],2,2)
2942                             int nbOfCompo=PyInt_AS_LONG(nbOfComp);
2943                             if(nbOfCompo<0)
2944                               throw INTERP_KERNEL::Exception("DataArrayInt::setValue : should be a positive number of components !");
2945                             std::vector<int> tmp=fillArrayWithPyListInt2(li,nbOfTuples1,nbOfCompo);
2946                             self->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),self->getPointer());
2947                           }
2948                         else
2949                           throw INTERP_KERNEL::Exception(msg);
2950                       }
2951                     else
2952                       {//DataArrayInt.setValues([1,3,4],3)
2953                         int tmpp1=-1;
2954                         std::vector<int> tmp=fillArrayWithPyListInt2(li,nbOfTuples1,tmpp1);
2955                         self->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),self->getPointer());
2956                       }
2957                   }
2958                 else
2959                   throw INTERP_KERNEL::Exception(msg);
2960               }
2961             else
2962               {// DataArrayInt.setValues([1,3,4])
2963                 int tmpp1=-1,tmpp2=-1;
2964                 std::vector<int> tmp=fillArrayWithPyListInt2(li,tmpp1,tmpp2);
2965                 self->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),self->getPointer());
2966               }
2967           }
2968         else
2969           throw INTERP_KERNEL::Exception(msg);
2970       }
2971
2972       PyObject *getValues() const throw(INTERP_KERNEL::Exception)
2973       {
2974         const int *vals=self->getConstPointer();
2975         return convertIntArrToPyList(vals,self->getNbOfElems());
2976       }
2977
2978 #ifdef WITH_NUMPY
2979       PyObject *toNumPyArray() throw(INTERP_KERNEL::Exception) // not const. It is not a bug !
2980       {
2981         return ToNumPyArray<DataArrayInt,int>(self,NPY_INT32,"DataArrayInt");
2982       }
2983 #endif
2984
2985       PyObject *isEqualIfNotWhy(const DataArrayInt& other) const throw(INTERP_KERNEL::Exception)
2986       {
2987         std::string ret1;
2988         bool ret0=self->isEqualIfNotWhy(other,ret1);
2989         PyObject *ret=PyTuple_New(2);
2990         PyObject *ret0Py=ret0?Py_True:Py_False;
2991         Py_XINCREF(ret0Py);
2992         PyTuple_SetItem(ret,0,ret0Py);
2993         PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
2994         return ret;
2995       }
2996
2997       PyObject *getValuesAsTuple() const throw(INTERP_KERNEL::Exception)
2998       {
2999         const int *vals=self->getConstPointer();
3000         int nbOfComp=self->getNumberOfComponents();
3001         int nbOfTuples=self->getNumberOfTuples();
3002         return convertIntArrToPyListOfTuple(vals,nbOfComp,nbOfTuples);
3003       }
3004
3005       static PyObject *MakePartition(PyObject *gps, int newNb) throw(INTERP_KERNEL::Exception)
3006       {
3007         std::vector<const DataArrayInt *> groups;
3008         std::vector< std::vector<int> > fidsOfGroups;
3009         convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayInt *>(gps,SWIGTYPE_p_MEDCoupling__DataArrayInt,"DataArrayInt",groups);
3010         MEDCoupling::DataArrayInt *ret0=MEDCoupling::DataArrayInt::MakePartition(groups,newNb,fidsOfGroups);
3011         PyObject *ret = PyList_New(2);
3012         PyList_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ));
3013         int sz=fidsOfGroups.size();
3014         PyObject *ret1 = PyList_New(sz);
3015         for(int i=0;i<sz;i++)
3016           PyList_SetItem(ret1,i,convertIntArrToPyList2(fidsOfGroups[i]));
3017         PyList_SetItem(ret,1,ret1);
3018         return ret;
3019       }
3020
3021       void transformWithIndArr(PyObject *li) throw(INTERP_KERNEL::Exception)
3022       {
3023         void *da=0;
3024         int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 |  0 );
3025         if (!SWIG_IsOK(res1))
3026           {
3027             int size;
3028             INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
3029             self->transformWithIndArr(tmp,tmp+size);
3030           }
3031         else
3032           {
3033             DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
3034             self->transformWithIndArr(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
3035           }
3036       }
3037
3038       DataArrayInt *findIdsEqualList(PyObject *obj) throw(INTERP_KERNEL::Exception)
3039       {
3040         int sw;
3041         int singleVal;
3042         std::vector<int> multiVal;
3043         std::pair<int, std::pair<int,int> > slic;
3044         MEDCoupling::DataArrayInt *daIntTyypp=0;
3045         convertObjToPossibleCpp2(obj,self->getNumberOfTuples(),sw,singleVal,multiVal,slic,daIntTyypp);
3046         switch(sw)
3047           {
3048           case 1:
3049             return self->findIdsEqualList(&singleVal,&singleVal+1);
3050           case 2:
3051             return self->findIdsEqualList(&multiVal[0],&multiVal[0]+multiVal.size());
3052           case 4:
3053             return self->findIdsEqualList(daIntTyypp->begin(),daIntTyypp->end());
3054           default:
3055             throw INTERP_KERNEL::Exception("DataArrayInt::findIdsEqualList : unrecognized type entered, expected list of int, tuple of int or DataArrayInt !");
3056           }
3057       }
3058
3059       DataArrayInt *findIdsNotEqualList(PyObject *obj) throw(INTERP_KERNEL::Exception)
3060       {
3061         int sw;
3062         int singleVal;
3063         std::vector<int> multiVal;
3064         std::pair<int, std::pair<int,int> > slic;
3065         MEDCoupling::DataArrayInt *daIntTyypp=0;
3066         convertObjToPossibleCpp2(obj,self->getNumberOfTuples(),sw,singleVal,multiVal,slic,daIntTyypp);
3067         switch(sw)
3068           {
3069           case 1:
3070             return self->findIdsNotEqualList(&singleVal,&singleVal+1);
3071           case 2:
3072             return self->findIdsNotEqualList(&multiVal[0],&multiVal[0]+multiVal.size());
3073           case 4:
3074             return self->findIdsNotEqualList(daIntTyypp->begin(),daIntTyypp->end());
3075           default:
3076             throw INTERP_KERNEL::Exception("DataArrayInt::findIdsNotEqualList : unrecognized type entered, expected list of int, tuple of int or DataArrayInt !");
3077           }
3078       }
3079
3080       PyObject *splitByValueRange(PyObject *li) const throw(INTERP_KERNEL::Exception)
3081       {
3082         DataArrayInt *ret0=0,*ret1=0,*ret2=0;
3083         void *da=0;
3084         int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 |  0 );
3085         if (!SWIG_IsOK(res1))
3086           {
3087             int size;
3088             INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
3089             self->splitByValueRange(tmp,(int *)tmp+size,ret0,ret1,ret2);
3090           }
3091         else
3092           {
3093             DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
3094             if(!da2)
3095               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
3096             da2->checkAllocated();
3097             int size=self->getNumberOfTuples();
3098             self->splitByValueRange(da2->getConstPointer(),da2->getConstPointer()+size,ret0,ret1,ret2);
3099           }
3100         PyObject *ret = PyList_New(3);
3101         PyList_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ));
3102         PyList_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ));
3103         PyList_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(ret2),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ));
3104         return ret;
3105       }
3106
3107       DataArrayInt *transformWithIndArrR(PyObject *li) const throw(INTERP_KERNEL::Exception)
3108       {
3109         void *da=0;
3110         int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 |  0 );
3111         if (!SWIG_IsOK(res1))
3112           {
3113             int size;
3114             INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
3115             return self->transformWithIndArrR(tmp,tmp+size);
3116           }
3117         else
3118           {
3119             DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
3120             return self->transformWithIndArrR(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
3121           }
3122       }
3123
3124       DataArrayInt *renumberAndReduce(PyObject *li, int newNbOfTuple) throw(INTERP_KERNEL::Exception)
3125       {
3126         void *da=0;
3127         int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 |  0 );
3128         if (!SWIG_IsOK(res1))
3129           {
3130             int size;
3131             INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
3132             if(size!=self->getNumberOfTuples())
3133               {
3134                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
3135               }
3136             return self->renumberAndReduce(tmp,newNbOfTuple);
3137           }
3138         else
3139           {
3140             DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
3141             if(!da2)
3142               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
3143             da2->checkAllocated();
3144             int size=self->getNumberOfTuples();
3145             if(size!=self->getNumberOfTuples())
3146               {
3147                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
3148               }
3149             return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
3150           }
3151       }
3152
3153       DataArrayInt *renumber(PyObject *li) throw(INTERP_KERNEL::Exception)
3154       {
3155         void *da=0;
3156         int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 |  0 );
3157         if (!SWIG_IsOK(res1))
3158           {
3159             int size;
3160             INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
3161             if(size!=self->getNumberOfTuples())
3162               {
3163                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
3164               }
3165             return self->renumber(tmp);
3166           }
3167         else
3168           {
3169             DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
3170             if(!da2)
3171               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
3172             da2->checkAllocated();
3173             int size=self->getNumberOfTuples();
3174             if(size!=self->getNumberOfTuples())
3175               {
3176                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
3177               }
3178             return self->renumber(da2->getConstPointer());
3179           }
3180       }
3181
3182       DataArrayInt *renumberR(PyObject *li) throw(INTERP_KERNEL::Exception)
3183       {
3184         void *da=0;
3185         int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 |  0 );
3186         if (!SWIG_IsOK(res1))
3187           {
3188             int size;
3189             INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
3190             if(size!=self->getNumberOfTuples())
3191               {
3192                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
3193               }
3194             return self->renumberR(tmp);
3195           }
3196         else
3197           {
3198             DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
3199             if(!da2)
3200               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
3201             da2->checkAllocated();
3202             int size=self->getNumberOfTuples();
3203             if(size!=self->getNumberOfTuples())
3204               {
3205                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
3206               }
3207             return self->renumberR(da2->getConstPointer());
3208           }
3209       }
3210
3211       void setSelectedComponents(const DataArrayInt *a, PyObject *li) throw(INTERP_KERNEL::Exception)
3212       {
3213         std::vector<int> tmp;
3214         convertPyToNewIntArr3(li,tmp);
3215         self->setSelectedComponents(a,tmp);
3216       }
3217
3218       PyObject *getTuple(int tupleId) throw(INTERP_KERNEL::Exception)
3219       {
3220         int sz=self->getNumberOfComponents();
3221         INTERP_KERNEL::AutoPtr<int> tmp=new int[sz];
3222         self->getTuple(tupleId,tmp);
3223         return convertIntArrToPyList(tmp,sz);
3224       }
3225
3226       PyObject *changeSurjectiveFormat(int targetNb) const throw(INTERP_KERNEL::Exception)
3227       {
3228         DataArrayInt *arr=0;
3229         DataArrayInt *arrI=0;
3230         self->changeSurjectiveFormat(targetNb,arr,arrI);
3231         PyObject *res = PyList_New(2);
3232         PyList_SetItem(res,0,SWIG_NewPointerObj((void*)arr,SWIGTYPE_p_MEDCoupling__DataArrayInt,SWIG_POINTER_OWN | 0));
3233         PyList_SetItem(res,1,SWIG_NewPointerObj((void*)arrI,SWIGTYPE_p_MEDCoupling__DataArrayInt,SWIG_POINTER_OWN | 0));
3234         return res;
3235       }
3236
3237       static DataArrayInt *Meld(PyObject *li) throw(INTERP_KERNEL::Exception)
3238       {
3239         std::vector<const DataArrayInt *> tmp;
3240         convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayInt *>(li,SWIGTYPE_p_MEDCoupling__DataArrayInt,"DataArrayInt",tmp);
3241         return DataArrayInt::Meld(tmp);
3242       }
3243
3244       static DataArrayInt *Aggregate(PyObject *li) throw(INTERP_KERNEL::Exception)
3245       {
3246         std::vector<const DataArrayInt *> tmp;
3247         convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayInt *>(li,SWIGTYPE_p_MEDCoupling__DataArrayInt,"DataArrayInt",tmp);
3248         return DataArrayInt::Aggregate(tmp);
3249       }
3250
3251       static DataArrayInt *AggregateIndexes(PyObject *li) throw(INTERP_KERNEL::Exception)
3252       {
3253         std::vector<const DataArrayInt *> tmp;
3254         convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayInt *>(li,SWIGTYPE_p_MEDCoupling__DataArrayInt,"DataArrayInt",tmp);
3255         return DataArrayInt::AggregateIndexes(tmp);
3256       }
3257
3258       static DataArrayInt *BuildUnion(PyObject *li) throw(INTERP_KERNEL::Exception)
3259       {
3260         std::vector<const DataArrayInt *> tmp;
3261         convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayInt *>(li,SWIGTYPE_p_MEDCoupling__DataArrayInt,"DataArrayInt",tmp);
3262         return DataArrayInt::BuildUnion(tmp);
3263       }
3264
3265       static DataArrayInt *BuildIntersection(PyObject *li) throw(INTERP_KERNEL::Exception)
3266       {
3267         std::vector<const DataArrayInt *> tmp;
3268         convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayInt *>(li,SWIGTYPE_p_MEDCoupling__DataArrayInt,"DataArrayInt",tmp);
3269         return DataArrayInt::BuildIntersection(tmp);
3270       }
3271
3272       PyObject *getMaxValue() const throw(INTERP_KERNEL::Exception)
3273       {
3274         int tmp;
3275         int r1=self->getMaxValue(tmp);
3276         PyObject *ret=PyTuple_New(2);
3277         PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
3278         PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
3279         return ret;
3280       }
3281
3282       PyObject *getMinValue() const throw(INTERP_KERNEL::Exception)
3283       {
3284         int tmp;
3285         int r1=self->getMinValue(tmp);
3286         PyObject *ret=PyTuple_New(2);
3287         PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
3288         PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
3289         return ret;
3290       }
3291
3292       int index(PyObject *obj) const throw(INTERP_KERNEL::Exception)
3293       {
3294         int nbOfCompo=self->getNumberOfComponents();
3295         switch(nbOfCompo)
3296           {
3297           case 1:
3298             {
3299               if(PyInt_Check(obj))
3300                 {
3301                   int val=(int)PyInt_AS_LONG(obj);
3302                   return self->findIdFirstEqual(val);
3303                 }
3304               else
3305                 throw INTERP_KERNEL::Exception("DataArrayInt::index : 'this' contains one component and trying to find an element which is not an integer !");
3306             }
3307           default:
3308             {
3309               std::vector<int> arr;
3310               convertPyToNewIntArr3(obj,arr);
3311               return self->findIdFirstEqualTuple(arr);
3312             }
3313           }
3314       }
3315
3316       bool __contains__(PyObject *obj) const throw(INTERP_KERNEL::Exception)
3317       {
3318         int nbOfCompo=self->getNumberOfComponents();
3319         switch(nbOfCompo)
3320           {
3321           case 0:
3322             return false;
3323           case 1:
3324             {
3325               if(PyInt_Check(obj))
3326                 {
3327                   int val=(int)PyInt_AS_LONG(obj);
3328                   return self->presenceOfValue(val);
3329                 }
3330               else
3331                 throw INTERP_KERNEL::Exception("DataArrayInt::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
3332             }
3333           default:
3334             {
3335               std::vector<int> arr;
3336               convertPyToNewIntArr3(obj,arr);
3337               return self->presenceOfTuple(arr);
3338             }
3339           }
3340       }
3341
3342       PyObject *__getitem__(PyObject *obj) throw(INTERP_KERNEL::Exception)
3343       {
3344         const char msg[]="Unexpected situation in DataArrayInt::__getitem__ !";
3345         const char msg2[]="DataArrayInt::__getitem__ : Mismatch of slice values in 2nd parameter (components) !";
3346         self->checkAllocated();
3347         int nbOfTuples=self->getNumberOfTuples();
3348         int nbOfComponents=self->getNumberOfComponents();
3349         int it1,ic1;
3350         std::vector<int> vt1,vc1;
3351         std::pair<int, std::pair<int,int> > pt1,pc1;
3352         DataArrayInt *dt1=0,*dc1=0;
3353         int sw;
3354         convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1);
3355         MCAuto<DataArrayInt> ret;
3356         switch(sw)
3357           {
3358           case 1:
3359             {
3360               if(nbOfComponents==1)
3361                 return PyInt_FromLong(self->getIJSafe(it1,0));
3362               return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(&it1,&it1+1)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 );
3363             }
3364           case 2:
3365             return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size())),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 );
3366           case 3:
3367             return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafeSlice(pt1.first,pt1.second.first,pt1.second.second)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 );
3368           case 4:
3369             return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems())),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 );
3370           case 5:
3371             return PyInt_FromLong(self->getIJSafe(it1,ic1));
3372           case 6:
3373             {
3374               ret=self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size());
3375               std::vector<int> v2(1,ic1);
3376               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 );
3377             }
3378           case 7:
3379             {
3380               ret=self->selectByTupleIdSafeSlice(pt1.first,pt1.second.first,pt1.second.second);
3381               std::vector<int> v2(1,ic1);
3382               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 );
3383             }
3384           case 8:
3385             {
3386               ret=self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems());
3387               std::vector<int> v2(1,ic1);
3388               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 );
3389             }
3390           case 9:
3391             {
3392               ret=self->selectByTupleIdSafe(&it1,&it1+1);
3393               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 );
3394             }
3395           case 10:
3396             {
3397               ret=self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size());
3398               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 );
3399             }
3400           case 11:
3401             {
3402               ret=self->selectByTupleIdSafeSlice(pt1.first,pt1.second.first,pt1.second.second);
3403               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 );
3404             }
3405           case 12:
3406             {
3407               ret=self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems());
3408               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 );
3409             }
3410           case 13:
3411             {
3412               ret=self->selectByTupleIdSafe(&it1,&it1+1);
3413               int nbOfComp=DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2);
3414               std::vector<int> v2(nbOfComp);
3415               for(int i=0;i<nbOfComp;i++)
3416                 v2[i]=pc1.first+i*pc1.second.second;
3417               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 );
3418             }
3419           case 14:
3420             {
3421               ret=self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size());
3422               int nbOfComp=DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2);
3423               std::vector<int> v2(nbOfComp);
3424               for(int i=0;i<nbOfComp;i++)
3425                 v2[i]=pc1.first+i*pc1.second.second;
3426               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 );
3427             }
3428           case 15:
3429             {
3430               ret=self->selectByTupleIdSafeSlice(pt1.first,pt1.second.first,pt1.second.second);
3431               int nbOfComp=DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2);
3432               std::vector<int> v2(nbOfComp);
3433               for(int i=0;i<nbOfComp;i++)
3434                 v2[i]=pc1.first+i*pc1.second.second;
3435               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 );
3436             }
3437           case 16:
3438             {
3439               ret=self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems());
3440               int nbOfComp=DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2);
3441               std::vector<int> v2(nbOfComp);
3442               for(int i=0;i<nbOfComp;i++)
3443                 v2[i]=pc1.first+i*pc1.second.second;
3444               return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 );
3445             }
3446           default:
3447             throw INTERP_KERNEL::Exception(msg);
3448           }
3449       }
3450
3451       DataArrayInt *__setitem__(PyObject *obj, PyObject *value) throw(INTERP_KERNEL::Exception)
3452       {
3453         self->checkAllocated();
3454         const char msg[]="Unexpected situation in __setitem__ !";
3455         int nbOfTuples=self->getNumberOfTuples();
3456         int nbOfComponents=self->getNumberOfComponents();
3457         int sw1,sw2;
3458         int i1;
3459         std::vector<int> v1;
3460         DataArrayInt *d1=0;
3461         DataArrayIntTuple *dd1=0;
3462         convertObjToPossibleCpp1(value,sw1,i1,v1,d1,dd1);
3463         int it1,ic1;
3464         std::vector<int> vt1,vc1;
3465         std::pair<int, std::pair<int,int> > pt1,pc1;
3466         DataArrayInt *dt1=0,*dc1=0;
3467         convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw2,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1);
3468         MCAuto<DataArrayInt> tmp;
3469         switch(sw2)
3470           {
3471           case 1:
3472             {
3473               switch(sw1)
3474                 {
3475                 case 1:
3476                   self->setPartOfValuesSimple1(i1,it1,it1+1,1,0,nbOfComponents,1);
3477                   return self;
3478                 case 2:
3479                   tmp=DataArrayInt::New();
3480                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3481                   self->setPartOfValues1(tmp,it1,it1+1,1,0,nbOfComponents,1,false);
3482                   return self;
3483                 case 3:
3484                   self->setPartOfValues1(d1,it1,it1+1,1,0,nbOfComponents,1);
3485                   return self;
3486                 case 4:
3487                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3488                   self->setPartOfValues1(tmp,it1,it1+1,1,0,nbOfComponents,1);
3489                   return self;
3490                 default:
3491                   throw INTERP_KERNEL::Exception(msg);
3492                 }
3493               break;
3494             }
3495           case 2:
3496             {
3497               switch(sw1)
3498                 {
3499                 case 1:
3500                   self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1);
3501                   return self;
3502                 case 2:
3503                   tmp=DataArrayInt::New();
3504                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3505                   self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1,false);
3506                   return self;
3507                 case 3:
3508                   self->setPartOfValues3(d1,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1);
3509                   return self;
3510                 case 4:
3511                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3512                   self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1);
3513                   return self;
3514                 default:
3515                   throw INTERP_KERNEL::Exception(msg);
3516                 }
3517               break;
3518             }
3519           case 3:
3520             {
3521               switch(sw1)
3522                 {
3523                 case 1:
3524                   self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1);
3525                   return self;
3526                 case 2:
3527                   tmp=DataArrayInt::New();
3528                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3529                   self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1,false);
3530                   return self;
3531                 case 3:
3532                   self->setPartOfValues1(d1,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1);
3533                   return self;
3534                 case 4:
3535                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3536                   self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1);
3537                   return self;
3538                 default:
3539                   throw INTERP_KERNEL::Exception(msg);
3540                 }
3541               break;
3542             }
3543           case 4:
3544             {
3545               switch(sw1)
3546                 {
3547                 case 1:
3548                   self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1);
3549                   return self;
3550                 case 2:
3551                   tmp=DataArrayInt::New();
3552                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3553                   self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1,false);
3554                   return self;
3555                 case 3:
3556                   self->setPartOfValues3(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1);
3557                   return self;
3558                 case 4:
3559                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3560                   self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1);
3561                   return self;
3562                 default:
3563                   throw INTERP_KERNEL::Exception(msg);
3564                 }
3565               break;
3566             }
3567           case 5:
3568             {
3569               switch(sw1)
3570                 {
3571                 case 1:
3572                   self->setPartOfValuesSimple1(i1,it1,it1+1,1,ic1,ic1+1,1);
3573                   return self;
3574                 case 2:
3575                   tmp=DataArrayInt::New();
3576                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3577                   self->setPartOfValues1(tmp,it1,it1+1,1,ic1,ic1+1,1,false);
3578                   return self;
3579                 case 3:
3580                   self->setPartOfValues1(d1,it1,it1+1,1,ic1,ic1+1,1);
3581                   return self;
3582                 case 4:
3583                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3584                   self->setPartOfValues1(tmp,it1,it1+1,1,ic1,ic1+1,1);
3585                   return self;
3586                 default:
3587                   throw INTERP_KERNEL::Exception(msg);
3588                 }
3589               break;
3590             }
3591           case 6:
3592             {
3593               switch(sw1)
3594                 {
3595                 case 1:
3596                   self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1);
3597                   return self;
3598                 case 2:
3599                   tmp=DataArrayInt::New();
3600                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3601                   self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1,false);
3602                   return self;
3603                 case 3:
3604                   self->setPartOfValues3(d1,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1);
3605                   return self;
3606                 case 4:
3607                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3608                   self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1);
3609                   return self;
3610                 default:
3611                   throw INTERP_KERNEL::Exception(msg);
3612                 }
3613               break;
3614             }
3615           case 7:
3616             {
3617               switch(sw1)
3618                 {
3619                 case 1:
3620                   self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1);
3621                   return self;
3622                 case 2:
3623                   tmp=DataArrayInt::New();
3624                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3625                   self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1,false);
3626                   return self;
3627                 case 3:
3628                   self->setPartOfValues1(d1,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1);
3629                   return self;
3630                 case 4:
3631                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3632                   self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1);
3633                   return self;
3634                 default:
3635                   throw INTERP_KERNEL::Exception(msg);
3636                 }
3637               break;
3638             }
3639           case 8:
3640             {
3641               switch(sw1)
3642                 {
3643                 case 1:
3644                   self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1);
3645                   return self;
3646                 case 2:
3647                   tmp=DataArrayInt::New();
3648                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3649                   self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1,false);
3650                   return self;
3651                 case 3:
3652                   self->setPartOfValues3(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1);
3653                   return self;
3654                 case 4:
3655                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3656                   self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1);
3657                   return self;
3658                 default:
3659                   throw INTERP_KERNEL::Exception(msg);
3660                 }
3661               break;
3662             }
3663           case 9:
3664             {
3665               switch(sw1)
3666                 {
3667                 case 1:
3668                   self->setPartOfValuesSimple2(i1,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size());
3669                   return self;
3670                 case 2:
3671                   tmp=DataArrayInt::New();
3672                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3673                   self->setPartOfValues2(tmp,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size(),false);
3674                   return self;
3675                 case 3:
3676                   self->setPartOfValues2(d1,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size());
3677                   return self;
3678                 case 4:
3679                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3680                   self->setPartOfValues2(tmp,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size());
3681                   return self;
3682                 default:
3683                   throw INTERP_KERNEL::Exception(msg);
3684                 }
3685               break;
3686             }
3687           case 10:
3688             {
3689               switch(sw1)
3690                 {
3691                 case 1:
3692                   self->setPartOfValuesSimple2(i1,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size());
3693                   return self;
3694                 case 2:
3695                   tmp=DataArrayInt::New();
3696                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3697                   self->setPartOfValues2(tmp,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size(),false);
3698                   return self;
3699                 case 3:
3700                   self->setPartOfValues2(d1,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size());
3701                   return self;
3702                 case 4:
3703                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3704                   self->setPartOfValues2(tmp,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size());
3705                   return self;
3706                 default:
3707                   throw INTERP_KERNEL::Exception(msg);
3708                 }
3709               break;
3710             }
3711           case 11:
3712             {
3713               switch(sw1)
3714                 {
3715                 case 1:
3716                   self->setPartOfValuesSimple4(i1,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size());
3717                   return self;
3718                 case 2:
3719                   tmp=DataArrayInt::New();
3720                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3721                   self->setPartOfValues4(tmp,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size(),false);
3722                   return self;
3723                 case 3:
3724                   self->setPartOfValues4(d1,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size());
3725                   return self;
3726                 case 4:
3727                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3728                   self->setPartOfValues4(tmp,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size());
3729                   return self;
3730                 default:
3731                   throw INTERP_KERNEL::Exception(msg);
3732                 }
3733               break;
3734             }
3735           case 12:
3736             {
3737               switch(sw1)
3738                 {
3739                 case 1:
3740                   self->setPartOfValuesSimple2(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size());
3741                   return self;
3742                 case 2:
3743                   tmp=DataArrayInt::New();
3744                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3745                   self->setPartOfValues2(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size(),false);
3746                   return self;
3747                 case 3:
3748                   self->setPartOfValues2(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size());
3749                   return self;
3750                 case 4:
3751                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3752                   self->setPartOfValues2(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size());
3753                   return self;
3754                 default:
3755                   throw INTERP_KERNEL::Exception(msg);
3756                 }
3757               break;
3758             }
3759           case 13:
3760             {
3761               switch(sw1)
3762                 {
3763                 case 1:
3764                   self->setPartOfValuesSimple1(i1,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second);
3765                   return self;
3766                 case 2:
3767                   tmp=DataArrayInt::New();
3768                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3769                   self->setPartOfValues1(tmp,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second,false);
3770                   return self;
3771                 case 3:
3772                   self->setPartOfValues1(d1,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second);
3773                   return self;
3774                 case 4:
3775                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3776                   self->setPartOfValues1(tmp,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second);
3777                   return self;
3778                 default:
3779                   throw INTERP_KERNEL::Exception(msg);
3780                 }
3781               break;
3782             }
3783           case 14:
3784             {
3785               switch(sw1)
3786                 {
3787                 case 1:
3788                   self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second);
3789                   return self;
3790                 case 2:
3791                   tmp=DataArrayInt::New();
3792                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3793                   self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second,false);
3794                   return self;
3795                 case 3:
3796                   self->setPartOfValues3(d1,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second);
3797                   return self;
3798                 case 4:
3799                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3800                   self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second);
3801                   return self;
3802                 default:
3803                   throw INTERP_KERNEL::Exception(msg);
3804                 }
3805               break;
3806             }
3807           case 15:
3808             {
3809               switch(sw1)
3810                 {
3811                 case 1:
3812                   self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second);
3813                   return self;
3814                 case 2:
3815                   tmp=DataArrayInt::New();
3816                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3817                   self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second,false);
3818                   return self;
3819                 case 3:
3820                   self->setPartOfValues1(d1,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second);
3821                   return self;
3822                 case 4:
3823                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3824                   self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second);
3825                   return self;
3826                 default:
3827                   throw INTERP_KERNEL::Exception(msg);
3828                 }
3829               break;
3830             }
3831           case 16:
3832             {
3833               switch(sw1)
3834                 {
3835                 case 1:
3836                   self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second);
3837                   return self;
3838                 case 2:
3839                   tmp=DataArrayInt::New();
3840                   tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3841                   self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second,false);
3842                   return self;
3843                 case 3:
3844                   self->setPartOfValues3(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second);
3845                   return self;
3846                 case 4:
3847                   tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3848                   self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second);
3849                   return self;
3850                 default:
3851                   throw INTERP_KERNEL::Exception(msg);
3852                 }
3853               break;
3854             }
3855           default:
3856             throw INTERP_KERNEL::Exception(msg);
3857           }
3858         return self;
3859       }
3860
3861       DataArrayInt *__neg__() const throw(INTERP_KERNEL::Exception)
3862       {
3863         return self->negate();
3864       }
3865
3866       DataArrayInt *__add__(PyObject *obj) throw(INTERP_KERNEL::Exception)
3867       {
3868         const char msg[]="Unexpected situation in __add__ !";
3869         int val;
3870         DataArrayInt *a;
3871         std::vector<int> aa;
3872         DataArrayIntTuple *aaa;
3873         int sw;
3874         convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
3875         switch(sw)
3876           {
3877           case 1:
3878             {
3879               MCAuto<DataArrayInt> ret=self->deepCopy();
3880               ret->applyLin(1,val);
3881               return ret.retn();
3882             }
3883           case 2:
3884             {
3885               MCAuto<DataArrayInt> aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
3886               return DataArrayInt::Add(self,aaaa);
3887             }
3888           case 3:
3889             {
3890               return DataArrayInt::Add(self,a);
3891             }
3892           case 4:
3893             {
3894               MCAuto<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
3895               return DataArrayInt::Add(self,aaaa);
3896             }
3897           default:
3898             throw INTERP_KERNEL::Exception(msg);
3899           }
3900       }
3901
3902       DataArrayInt *__radd__(PyObject *obj) throw(INTERP_KERNEL::Exception)
3903       {
3904         const char msg[]="Unexpected situation in __radd__ !";
3905         int val;
3906         DataArrayInt *a;
3907         std::vector<int> aa;
3908         DataArrayIntTuple *aaa;
3909         int sw;
3910         convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
3911         switch(sw)
3912           {
3913           case 1:
3914             {
3915               MCAuto<DataArrayInt> ret=self->deepCopy();
3916               ret->applyLin(1,val);
3917               return ret.retn();
3918             }
3919           case 2:
3920             {
3921               MCAuto<DataArrayInt> aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
3922               return DataArrayInt::Add(self,aaaa);
3923             }
3924           case 4:
3925             {
3926               MCAuto<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
3927               return DataArrayInt::Add(self,aaaa);
3928             }
3929           default:
3930             throw INTERP_KERNEL::Exception(msg);
3931           }
3932       }
3933
3934       PyObject *___iadd___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
3935       {
3936         const char msg[]="Unexpected situation in __iadd__ !";
3937         int val;
3938         DataArrayInt *a;
3939         std::vector<int> aa;
3940         DataArrayIntTuple *aaa;
3941         int sw;
3942         convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
3943         switch(sw)
3944           {
3945           case 1:
3946             {
3947               self->applyLin(1,val);
3948               Py_XINCREF(trueSelf);
3949               return trueSelf;
3950             }
3951           case 2:
3952             {
3953               MCAuto<DataArrayInt> bb=DataArrayInt::New(); bb->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
3954               self->addEqual(bb);
3955               Py_XINCREF(trueSelf);
3956               return trueSelf;
3957             }
3958           case 3:
3959             {
3960               self->addEqual(a);
3961               Py_XINCREF(trueSelf);
3962               return trueSelf;
3963             }
3964           case 4:
3965             {
3966               MCAuto<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
3967               self->addEqual(aaaa);
3968               Py_XINCREF(trueSelf);
3969               return trueSelf;
3970             }
3971           default:
3972             throw INTERP_KERNEL::Exception(msg);
3973           }
3974       }
3975
3976       DataArrayInt *__sub__(PyObject *obj) throw(INTERP_KERNEL::Exception)
3977       {
3978         const char msg[]="Unexpected situation in __sub__ !";
3979         int val;
3980         DataArrayInt *a;
3981         std::vector<int> aa;
3982         DataArrayIntTuple *aaa;
3983         int sw;
3984         convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
3985         switch(sw)
3986           {
3987           case 1:
3988             {
3989               MCAuto<DataArrayInt> ret=self->deepCopy();
3990               ret->applyLin(1,-val);
3991               return ret.retn();
3992             }
3993           case 2:
3994             {
3995               MCAuto<DataArrayInt> aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
3996               return DataArrayInt::Substract(self,aaaa);
3997             }
3998           case 3:
3999             {
4000               return DataArrayInt::Substract(self,a);
4001             }
4002           case 4:
4003             {
4004               MCAuto<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
4005               return DataArrayInt::Substract(self,aaaa);
4006             }
4007           default:
4008             throw INTERP_KERNEL::Exception(msg);
4009           }
4010       }
4011
4012       DataArrayInt *__rsub__(PyObject *obj) throw(INTERP_KERNEL::Exception)
4013       {
4014         const char msg[]="Unexpected situation in __rsub__ !";
4015         int val;
4016         DataArrayInt *a;
4017         std::vector<int> aa;
4018         DataArrayIntTuple *aaa;
4019         int sw;
4020         convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
4021         switch(sw)
4022           {
4023           case 1:
4024             {
4025               MCAuto<DataArrayInt> ret=self->deepCopy();
4026               ret->applyLin(-1,val);
4027               return ret.retn();
4028             }
4029           case 2:
4030             {
4031               MCAuto<DataArrayInt> aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
4032               return DataArrayInt::Substract(aaaa,self);
4033             }
4034           case 4:
4035             {
4036               MCAuto<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
4037               return DataArrayInt::Substract(aaaa,self);
4038             }
4039           default:
4040             throw INTERP_KERNEL::Exception(msg);
4041           }
4042       }
4043
4044       PyObject *___isub___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
4045       {
4046         const char msg[]="Unexpected situation in __isub__ !";
4047         int val;
4048         DataArrayInt *a;
4049         std::vector<int> aa;
4050         DataArrayIntTuple *aaa;
4051         int sw;
4052         convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
4053         switch(sw)
4054           {
4055           case 1:
4056             {
4057               self->applyLin(1,-val);
4058               Py_XINCREF(trueSelf);
4059               return trueSelf;
4060             }
4061           case 2:
4062             {
4063               MCAuto<DataArrayInt> bb=DataArrayInt::New(); bb->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
4064               self->substractEqual(bb);
4065               Py_XINCREF(trueSelf);
4066               return trueSelf;
4067             }
4068           case 3:
4069             {
4070               self->substractEqual(a);
4071               Py_XINCREF(trueSelf);
4072               return trueSelf;
4073             }
4074           case 4:
4075             {
4076               MCAuto<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
4077               self->substractEqual(aaaa);
4078               Py_XINCREF(trueSelf);
4079               return trueSelf;
4080             }
4081           default:
4082             throw INTERP_KERNEL::Exception(msg);
4083           }
4084       }
4085
4086       DataArrayInt *__mul__(PyObject *obj) throw(INTERP_KERNEL::Exception)
4087       {
4088         const char msg[]="Unexpected situation in __mul__ !";
4089         int val;
4090         DataArrayInt *a;
4091         std::vector<int> aa;
4092         DataArrayIntTuple *aaa;
4093         int sw;
4094         convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
4095         switch(sw)
4096           {
4097           case 1:
4098             {
4099               MCAuto<DataArrayInt> ret=self->deepCopy();
4100               ret->applyLin(val,0);
4101               return ret.retn();
4102             }
4103           case 2:
4104             {
4105               MCAuto<DataArrayInt> aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
4106               return DataArrayInt::Multiply(self,aaaa);
4107             }
4108           case 3:
4109             {
4110               return DataArrayInt::Multiply(self,a);
4111             }
4112           case 4:
4113             {
4114               MCAuto<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
4115               return DataArrayInt::Multiply(self,aaaa);
4116             }
4117           default:
4118             throw INTERP_KERNEL::Exception(msg);
4119           }
4120       }
4121
4122       DataArrayInt *__rmul__(PyObject *obj) throw(INTERP_KERNEL::Exception)
4123       {
4124         const char msg[]="Unexpected situation in __rmul__ !";
4125         int val;
4126         DataArrayInt *a;
4127         std::vector<int> aa;
4128         DataArrayIntTuple *aaa;
4129         int sw;
4130         convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
4131         switch(sw)
4132           {
4133           case 1:
4134             {
4135               MCAuto<DataArrayInt> ret=self->deepCopy();
4136               ret->applyLin(val,0);
4137               return ret.retn();
4138             }
4139           case 2:
4140             {
4141               MCAuto<DataArrayInt> aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
4142               return DataArrayInt::Multiply(self,aaaa);
4143             }
4144           case 4:
4145             {
4146               MCAuto<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
4147               return DataArrayInt::Multiply(self,aaaa);
4148             }
4149           default:
4150             throw INTERP_KERNEL::Exception(msg);
4151           }
4152       }
4153
4154       PyObject *___imul___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
4155       {
4156         const char msg[]="Unexpected situation in __imul__ !";
4157         int val;
4158         DataArrayInt *a;
4159         std::vector<int> aa;
4160         DataArrayIntTuple *aaa;
4161         int sw;
4162         convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
4163         switch(sw)
4164           {
4165           case 1:
4166             {
4167               self->applyLin(val,0);
4168               Py_XINCREF(trueSelf);
4169               return trueSelf;
4170             }
4171           case 2:
4172             {
4173               MCAuto<DataArrayInt> bb=DataArrayInt::New(); bb->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
4174               self->multiplyEqual(bb);
4175               Py_XINCREF(trueSelf);
4176               return trueSelf;
4177             }
4178           case 3:
4179             {
4180               self->multiplyEqual(a);
4181               Py_XINCREF(trueSelf);
4182               return trueSelf;
4183             }
4184           case 4:
4185             {
4186               MCAuto<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
4187               self->multiplyEqual(aaaa);
4188               Py_XINCREF(trueSelf);
4189               return trueSelf;
4190             }
4191           default:
4192             throw INTERP_KERNEL::Exception(msg);
4193           }
4194       }
4195
4196       DataArrayInt *__div__(PyObject *obj) throw(INTERP_KERNEL::Exception)
4197       {
4198         const char msg[]="Unexpected situation in __div__ !";
4199         int val;
4200         DataArrayInt *a;
4201         std::vector<int> aa;
4202         DataArrayIntTuple *aaa;
4203         int sw;
4204         convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
4205         switch(sw)
4206           {
4207           case 1:
4208             {
4209               MCAuto<DataArrayInt> ret=self->deepCopy();
4210               ret->applyDivideBy(val);
4211               return ret.retn();
4212             }
4213           case 2:
4214             {
4215               MCAuto<DataArrayInt> aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
4216               return DataArrayInt::Divide(self,aaaa);
4217             }
4218           case 3:
4219             {
4220               return DataArrayInt::Divide(self,a);
4221             }
4222           case 4:
4223             {
4224               MCAuto<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
4225               return DataArrayInt::Divide(self,aaaa);
4226             }
4227           default:
4228             throw INTERP_KERNEL::Exception(msg);
4229           }
4230       }
4231
4232       DataArrayInt *__rdiv__(PyObject *obj) throw(INTERP_KERNEL::Exception)
4233       {
4234         const char msg[]="Unexpected situation in __rdiv__ !";
4235         int val;
4236         DataArrayInt *a;
4237         std::vector<int> aa;
4238         DataArrayIntTuple *aaa;
4239         int sw;
4240         convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
4241         switch(sw)
4242           {
4243           case 1:
4244             {
4245               MCAuto<DataArrayInt> ret=self->deepCopy();
4246               ret->applyInv(val);
4247               return ret.retn();
4248             }
4249           case 2:
4250             {
4251               MCAuto<DataArrayInt> aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
4252               return DataArrayInt::Divide(aaaa,self);
4253             }
4254           case 4:
4255             {
4256               MCAuto<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
4257               return DataArrayInt::Divide(aaaa,self);
4258             }
4259           default:
4260             throw INTERP_KERNEL::Exception(msg);
4261           }
4262       }
4263
4264       PyObject *___idiv___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
4265       {
4266         const char msg[]="Unexpected situation in __idiv__ !";
4267         int val;
4268         DataArrayInt *a;
4269         std::vector<int> aa;
4270         DataArrayIntTuple *aaa;
4271         int sw;
4272         convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
4273         switch(sw)
4274           {
4275           case 1:
4276             {
4277               self->applyDivideBy(val);
4278               Py_XINCREF(trueSelf);
4279               return trueSelf;
4280             }
4281           case 2:
4282             {
4283               MCAuto<DataArrayInt> bb=DataArrayInt::New(); bb->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
4284               self->divideEqual(bb);
4285               Py_XINCREF(trueSelf);
4286               return trueSelf;
4287             }
4288           case 3:
4289             {
4290               self->divideEqual(a);
4291               Py_XINCREF(trueSelf);
4292               return trueSelf;
4293             }
4294           case 4:
4295             {
4296               MCAuto<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
4297               self->divideEqual(aaaa);
4298               Py_XINCREF(trueSelf);
4299               return trueSelf;
4300             }
4301           default:
4302             throw INTERP_KERNEL::Exception(msg);
4303           }
4304       }
4305
4306       DataArrayInt *__mod__(PyObject *obj) throw(INTERP_KERNEL::Exception)
4307       {
4308         const char msg[]="Unexpected situation in __mod__ !";
4309         int val;
4310         DataArrayInt *a;
4311         std::vector<int> aa;
4312         DataArrayIntTuple *aaa;
4313         int sw;
4314         convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
4315         switch(sw)
4316           {
4317           case 1:
4318             {
4319               MCAuto<DataArrayInt> ret=self->deepCopy();
4320               ret->applyModulus(val);
4321               return ret.retn();
4322             }
4323           case 2:
4324             {
4325               MCAuto<DataArrayInt> aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
4326               return DataArrayInt::Modulus(self,aaaa);
4327             }
4328           case 3:
4329             {
4330               return DataArrayInt::Modulus(self,a);
4331             }
4332           case 4:
4333             {
4334               MCAuto<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
4335               return DataArrayInt::Modulus(self,aaaa);
4336             }
4337           default:
4338             throw INTERP_KERNEL::Exception(msg);
4339           }
4340       }
4341
4342       DataArrayInt *__rmod__(PyObject *obj) throw(INTERP_KERNEL::Exception)
4343       {
4344         const char msg[]="Unexpected situation in __rmod__ !";
4345         int val;
4346         DataArrayInt *a;
4347         std::vector<int> aa;
4348         DataArrayIntTuple *aaa;
4349         int sw;
4350         convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
4351         switch(sw)
4352           {
4353           case 1:
4354             {
4355               MCAuto<DataArrayInt> ret=self->deepCopy();
4356               ret->applyRModulus(val);
4357               return ret.retn();
4358             }
4359           case 2:
4360             {
4361               MCAuto<DataArrayInt> aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
4362               return DataArrayInt::Modulus(aaaa,self);
4363             }
4364           case 3:
4365             {
4366               return DataArrayInt::Modulus(a,self);
4367             }
4368           case 4:
4369             {
4370               MCAuto<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
4371               return DataArrayInt::Modulus(aaaa,self);
4372             }
4373           default:
4374             throw INTERP_KERNEL::Exception(msg);
4375           }
4376       }
4377
4378       PyObject *___imod___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
4379       {
4380         const char msg[]="Unexpected situation in __imod__ !";
4381         int val;
4382         DataArrayInt *a;
4383         std::vector<int> aa;
4384         DataArrayIntTuple *aaa;
4385         int sw;
4386         convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
4387         switch(sw)
4388           {
4389           case 1:
4390             {
4391               self->applyModulus(val);
4392               Py_XINCREF(trueSelf);
4393               return trueSelf;
4394             }
4395           case 3:
4396             {
4397               self->modulusEqual(a);
4398               Py_XINCREF(trueSelf);
4399               return trueSelf;
4400             }
4401           case 4:
4402             {
4403               MCAuto<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
4404               self->modulusEqual(aaaa);
4405               Py_XINCREF(trueSelf);
4406               return trueSelf;
4407             }
4408           default:
4409             throw INTERP_KERNEL::Exception(msg);
4410           }
4411       }
4412
4413       DataArrayInt *__pow__(PyObject *obj) throw(INTERP_KERNEL::Exception)
4414       {
4415         const char msg[]="Unexpected situation in __pow__ !";
4416         int val;
4417         DataArrayInt *a;
4418         std::vector<int> aa;
4419         DataArrayIntTuple *aaa;
4420         int sw;
4421         convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
4422         switch(sw)
4423           {
4424           case 1:
4425             {
4426               MCAuto<DataArrayInt> ret=self->deepCopy();
4427               ret->applyPow(val);
4428               return ret.retn();
4429             }
4430           case 2:
4431             {
4432               MCAuto<DataArrayInt> aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
4433               return DataArrayInt::Pow(self,aaaa);
4434             }
4435           case 3:
4436             {
4437               return DataArrayInt::Pow(self,a);
4438             }
4439           case 4:
4440             {
4441               MCAuto<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
4442               return DataArrayInt::Pow(self,aaaa);
4443             }
4444           default:
4445             throw INTERP_KERNEL::Exception(msg);
4446           }
4447       }
4448
4449       DataArrayInt *__rpow__(PyObject *obj) throw(INTERP_KERNEL::Exception)
4450       {
4451         const char msg[]="Unexpected situation in __rpow__ !";
4452         int val;
4453         DataArrayInt *a;
4454         std::vector<int> aa;
4455         DataArrayIntTuple *aaa;
4456         int sw;
4457         convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
4458         switch(sw)
4459           {
4460           case 1:
4461             {
4462               MCAuto<DataArrayInt> ret=self->deepCopy();
4463               ret->applyRPow(val);
4464               return ret.retn();
4465             }
4466           case 2:
4467             {
4468               MCAuto<DataArrayInt> aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
4469               return DataArrayInt::Pow(aaaa,self);
4470             }
4471           case 3:
4472             {
4473               return DataArrayInt::Pow(a,self);
4474             }
4475           case 4:
4476             {
4477               MCAuto<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
4478               return DataArrayInt::Pow(aaaa,self);
4479             }
4480           default:
4481             throw INTERP_KERNEL::Exception(msg);
4482           }
4483       }
4484
4485       PyObject *___ipow___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
4486       {
4487         const char msg[]="Unexpected situation in __ipow__ !";
4488         int val;
4489         DataArrayInt *a;
4490         std::vector<int> aa;
4491         DataArrayIntTuple *aaa;
4492         int sw;
4493         convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
4494         switch(sw)
4495           {
4496           case 1:
4497             {
4498               self->applyPow(val);
4499               Py_XINCREF(trueSelf);
4500               return trueSelf;
4501             }
4502           case 3:
4503             {
4504               self->powEqual(a);
4505               Py_XINCREF(trueSelf);
4506               return trueSelf;
4507             }
4508           case 4:
4509             {
4510               MCAuto<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
4511               self->powEqual(aaaa);
4512               Py_XINCREF(trueSelf);
4513               return trueSelf;
4514             }
4515           default:
4516             throw INTERP_KERNEL::Exception(msg);
4517           }
4518       }
4519
4520       std::string __repr__() const throw(INTERP_KERNEL::Exception)
4521       {
4522         std::ostringstream oss;
4523         self->reprQuickOverview(oss);
4524         return oss.str();
4525       }
4526
4527       void pushBackValsSilent(PyObject *li) throw(INTERP_KERNEL::Exception)
4528       {
4529         int szArr,sw,iTypppArr;
4530         std::vector<int> stdvecTyyppArr;
4531         const int *tmp=convertObjToPossibleCpp1_Safe(li,sw,szArr,iTypppArr,stdvecTyyppArr);
4532         self->pushBackValsSilent(tmp,tmp+szArr);
4533       }
4534
4535       PyObject *partitionByDifferentValues() const throw(INTERP_KERNEL::Exception)
4536       {
4537         std::vector<int> ret1;
4538         std::vector<DataArrayInt *> ret0=self->partitionByDifferentValues(ret1);
4539         std::size_t sz=ret0.size();
4540         PyObject *pyRet=PyTuple_New(2);
4541         PyObject *pyRet0=PyList_New((int)sz);
4542         PyObject *pyRet1=PyList_New((int)sz);
4543         for(std::size_t i=0;i<sz;i++)
4544           {
4545             PyList_SetItem(pyRet0,i,SWIG_NewPointerObj(SWIG_as_voidptr(ret0[i]),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ));
4546             PyList_SetItem(pyRet1,i,PyInt_FromLong(ret1[i]));
4547           }
4548         PyTuple_SetItem(pyRet,0,pyRet0);
4549         PyTuple_SetItem(pyRet,1,pyRet1);
4550         return pyRet;
4551       }
4552
4553       PyObject *findIdsRangesInListOfIds(const DataArrayInt *listOfIds) const throw(INTERP_KERNEL::Exception)
4554       {
4555         DataArrayInt *ret0=0,*ret1=0;
4556         self->findIdsRangesInListOfIds(listOfIds,ret0,ret1);
4557         PyObject *pyRet=PyTuple_New(2);
4558         PyTuple_SetItem(pyRet,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ));
4559         PyTuple_SetItem(pyRet,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTYPE_p_MEDCoupling__DataArrayInt, SWIG_POINTER_OWN | 0 ));
4560         return pyRet;
4561       }
4562
4563       PyObject *isRange() const throw(INTERP_KERNEL::Exception)
4564       {
4565         int a(0),b(0),c(0);
4566         bool ret(self->isRange(a,b,c));
4567         PyObject *pyRet=PyTuple_New(2);
4568         PyObject *ret0Py=ret?Py_True:Py_False,*ret1Py(0);
4569         Py_XINCREF(ret0Py);
4570         PyTuple_SetItem(pyRet,0,ret0Py);
4571         if(ret)
4572           ret1Py=PySlice_New(PyInt_FromLong(a),PyInt_FromLong(b),PyInt_FromLong(c));
4573         else
4574           {
4575             ret1Py=Py_None;
4576             Py_XINCREF(ret1Py);
4577           }
4578         PyTuple_SetItem(pyRet,1,ret1Py);
4579         return pyRet;
4580       }
4581
4582       // serialization
4583       static PyObject *___new___(PyObject *cls, PyObject *args) throw(INTERP_KERNEL::Exception)
4584       {
4585         static const char MSG[]="DataArrayInt.__new__ : the args in input is expected to be a tuple !";
4586         if(!PyTuple_Check(args))
4587           throw INTERP_KERNEL::Exception(MSG);
4588         PyObject *builtinsd(PyEval_GetBuiltins());//borrowed
4589         PyObject *obj(PyDict_GetItemString(builtinsd,"object"));//borrowed
4590         PyObject *selfMeth(PyObject_GetAttrString(obj,"__new__"));
4591         //
4592         PyObject *tmp0(PyTuple_New(1));
4593         PyTuple_SetItem(tmp0,0,cls); Py_XINCREF(cls);
4594         PyObject *instance(PyObject_CallObject(selfMeth,tmp0));
4595         Py_DECREF(tmp0);
4596         Py_DECREF(selfMeth);
4597         PyObject *initMeth(PyObject_GetAttrString(instance,"__init__"));
4598         int sz(PyTuple_Size(args));
4599
4600         if(PyTuple_Size(args)==2 && PyDict_Check(PyTuple_GetItem(args,1)) && PyDict_Size(PyTuple_GetItem(args,1))==1 )
4601           {// NOT general case. only true if in unpickeling context ! call __init__. Because for all other cases, __init__ is called right after __new__ !
4602             PyObject *zeNumpyRepr(0);
4603             PyObject *tmp1(PyInt_FromLong(0));
4604             zeNumpyRepr=PyDict_GetItem(PyTuple_GetItem(args,1),tmp1);//borrowed
4605             Py_DECREF(tmp1);
4606             PyObject *tmp3(PyTuple_New(1));
4607             PyTuple_SetItem(tmp3,0,zeNumpyRepr); Py_XINCREF(zeNumpyRepr);
4608             PyObject *tmp2(PyObject_CallObject(initMeth,tmp3));
4609             Py_XDECREF(tmp2);
4610             Py_DECREF(tmp3);
4611           }
4612         Py_DECREF(initMeth);
4613         return instance;
4614       }
4615
4616       PyObject *__getnewargs__() throw(INTERP_KERNEL::Exception)
4617       {
4618 #ifdef WITH_NUMPY
4619         if(!self->isAllocated())
4620           throw INTERP_KERNEL::Exception("PyWrap of DataArrayInt.__getnewargs__ : self is not allocated !");
4621         PyObject *ret(PyTuple_New(1));
4622         PyObject *ret0(PyDict_New());
4623         PyObject *numpyArryObj(MEDCoupling_DataArrayInt_toNumPyArray(self));
4624         {// create a dict to discriminite in __new__ if __init__ should be called. Not beautiful but not idea ...
4625           PyObject *tmp1(PyInt_FromLong(0));
4626           PyDict_SetItem(ret0,tmp1,numpyArryObj); Py_DECREF(tmp1); Py_DECREF(numpyArryObj);
4627           PyTuple_SetItem(ret,0,ret0);
4628         }
4629         return ret;
4630 #else
4631         throw INTERP_KERNEL::Exception("PyWrap of DataArrayInt.__getnewargs__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !");
4632 #endif
4633       }
4634     }
4635   };
4636
4637   class DataArrayIntTuple;
4638
4639   class DataArrayIntIterator
4640   {
4641   public:
4642     DataArrayIntIterator(DataArrayInt *da);
4643     ~DataArrayIntIterator();
4644     %extend
4645     {
4646       PyObject *next()
4647       {
4648         DataArrayIntTuple *ret=self->nextt();
4649         if(ret)
4650           return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayIntTuple,SWIG_POINTER_OWN | 0);
4651         else
4652           {
4653             PyErr_SetString(PyExc_StopIteration,"No more data.");
4654             return 0;
4655           }
4656       }
4657     }
4658   };
4659
4660   class DataArrayIntTuple
4661   {
4662   public:
4663     int getNumberOfCompo() const throw(INTERP_KERNEL::Exception);
4664     DataArrayInt *buildDAInt(int nbOfTuples, int nbOfCompo) const throw(INTERP_KERNEL::Exception);
4665     %extend
4666     {
4667       std::string __str__() const throw(INTERP_KERNEL::Exception)
4668       {
4669         return self->repr();
4670       }
4671
4672       int __int__() const throw(INTERP_KERNEL::Exception)
4673       {
4674         return self->intValue();
4675       }
4676
4677       DataArrayInt *buildDAInt() throw(INTERP_KERNEL::Exception)
4678       {
4679         return self->buildDAInt(1,self->getNumberOfCompo());
4680       }
4681
4682       PyObject *___iadd___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
4683       {
4684         MCAuto<DataArrayInt> ret=self->buildDAInt(1,self->getNumberOfCompo());
4685         MEDCoupling_DataArrayInt____iadd___(ret,0,obj);
4686         Py_XINCREF(trueSelf);
4687         return trueSelf;
4688       }
4689
4690       PyObject *___isub___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
4691       {
4692         MCAuto<DataArrayInt> ret=self->buildDAInt(1,self->getNumberOfCompo());
4693         MEDCoupling_DataArrayInt____isub___(ret,0,obj);
4694         Py_XINCREF(trueSelf);
4695         return trueSelf;
4696       }
4697
4698       PyObject *___imul___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
4699       {
4700         MCAuto<DataArrayInt> ret=self->buildDAInt(1,self->getNumberOfCompo());
4701         MEDCoupling_DataArrayInt____imul___(ret,0,obj);
4702         Py_XINCREF(trueSelf);
4703         return trueSelf;
4704       }
4705
4706       PyObject *___idiv___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
4707       {
4708         MCAuto<DataArrayInt> ret=self->buildDAInt(1,self->getNumberOfCompo());
4709         MEDCoupling_DataArrayInt____idiv___(ret,0,obj);
4710         Py_XINCREF(trueSelf);
4711         return trueSelf;
4712       }
4713
4714       PyObject *___imod___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
4715       {
4716         MCAuto<DataArrayInt> ret=self->buildDAInt(1,self->getNumberOfCompo());
4717         MEDCoupling_DataArrayInt____imod___(ret,0,obj);
4718         Py_XINCREF(trueSelf);
4719         return trueSelf;
4720       }
4721
4722       PyObject *__len__() throw(INTERP_KERNEL::Exception)
4723       {
4724         return PyInt_FromLong(self->getNumberOfCompo());
4725       }
4726
4727       PyObject *__getitem__(PyObject *obj) throw(INTERP_KERNEL::Exception)
4728       {
4729         const char msg2[]="DataArrayIntTuple::__getitem__ : Mismatch of slice values in 2nd parameter (components) !";
4730         int sw;
4731         int singleVal;
4732         std::vector<int> multiVal;
4733         std::pair<int, std::pair<int,int> > slic;
4734         MEDCoupling::DataArrayInt *daIntTyypp=0;
4735         const int *pt=self->getConstPointer();
4736         int nbc=self->getNumberOfCompo();
4737         convertObjToPossibleCpp2WithNegIntInterp(obj,nbc,sw,singleVal,multiVal,slic,daIntTyypp);
4738         switch(sw)
4739           {
4740           case 1:
4741             {
4742               if(singleVal>=nbc)
4743                 {
4744                   std::ostringstream oss;
4745                   oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
4746                   PyErr_SetString(PyExc_StopIteration,oss.str().c_str());
4747                   return 0;
4748                 }
4749               if(singleVal>=0)
4750                 return PyInt_FromLong(pt[singleVal]);
4751               else
4752                 {
4753                   if(nbc+singleVal>0)
4754                     return PyInt_FromLong(pt[nbc+singleVal]);
4755                   else
4756                     {
4757                       std::ostringstream oss;
4758                       oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
4759                       throw INTERP_KERNEL::Exception(oss.str().c_str());
4760                     }
4761                 }
4762             }
4763           case 2:
4764             {
4765               PyObject *t=PyTuple_New(multiVal.size());
4766               for(int j=0;j<(int)multiVal.size();j++)
4767                 {
4768                   int cid=multiVal[j];
4769                   if(cid>=nbc)
4770                     {
4771                       std::ostringstream oss;
4772                       oss << "Requesting for id #" << cid << " having only " << nbc << " components !";
4773                       throw INTERP_KERNEL::Exception(oss.str().c_str());
4774                     }
4775                   PyTuple_SetItem(t,j,PyInt_FromLong(pt[cid]));
4776                 }
4777               return t;
4778             }
4779           case 3:
4780             {
4781               int sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
4782               PyObject *t=PyTuple_New(sz);
4783               for(int j=0;j<sz;j++)
4784                 PyTuple_SetItem(t,j,PyInt_FromLong(pt[slic.first+j*slic.second.second]));
4785               return t;
4786             }
4787           default:
4788             throw INTERP_KERNEL::Exception("DataArrayIntTuple::__getitem__ : unrecognized type entered !");
4789           }
4790       }
4791
4792       DataArrayIntTuple *__setitem__(PyObject *obj, PyObject *value) throw(INTERP_KERNEL::Exception)
4793       {
4794         const char msg[]="DataArrayIntTuple::__setitem__ : unrecognized type entered, int, slice, list<int>, tuple<int> !";
4795         const char msg2[]="DataArrayIntTuple::__setitem__ : Mismatch of slice values in 2nd parameter (components) !";
4796         int sw1,sw2;
4797         int singleValV;
4798         std::vector<int> multiValV;
4799         std::pair<int, std::pair<int,int> > slicV;
4800         MEDCoupling::DataArrayIntTuple *daIntTyyppV=0;
4801         int nbc=self->getNumberOfCompo();
4802         convertObjToPossibleCpp22(value,nbc,sw1,singleValV,multiValV,slicV,daIntTyyppV);
4803         int singleVal;
4804         std::vector<int> multiVal;
4805         std::pair<int, std::pair<int,int> > slic;
4806         MEDCoupling::DataArrayInt *daIntTyypp=0;
4807         int *pt=self->getPointer();
4808         convertObjToPossibleCpp2WithNegIntInterp(obj,nbc,sw2,singleVal,multiVal,slic,daIntTyypp);
4809         switch(sw2)
4810           {
4811           case 1:
4812             {
4813               if(singleVal>=nbc)
4814                 {
4815                   std::ostringstream oss;
4816                   oss << "Requesting for setting id # " << singleVal << " having only " << nbc << " components !";
4817                   throw INTERP_KERNEL::Exception(oss.str().c_str());
4818                 }
4819               switch(sw1)
4820                 {
4821                 case 1:
4822                   {
4823                     pt[singleVal]=singleValV;
4824                     return self;
4825                   }
4826                 case 2:
4827                   {
4828                     if(multiValV.size()!=1)
4829                       {
4830                         std::ostringstream oss;
4831                         oss << "Requesting for setting id # " << singleVal << " with a list or tuple with size != 1 ! ";
4832                         throw INTERP_KERNEL::Exception(oss.str().c_str());
4833                       }
4834                     pt[singleVal]=multiValV[0];
4835                     return self;
4836                   }
4837                 case 4:
4838                   {
4839                     pt[singleVal]=daIntTyyppV->getConstPointer()[0];
4840                     return self;
4841                   }
4842                 default:
4843                   throw INTERP_KERNEL::Exception(msg);
4844                 }
4845             }
4846           case 2:
4847             {
4848               switch(sw1)
4849                 {
4850                 case 1:
4851                   {
4852                     for(std::vector<int>::const_iterator it=multiVal.begin();it!=multiVal.end();it++)
4853                       {
4854                         if(*it>=nbc)
4855                           {
4856                             std::ostringstream oss;
4857                             oss << "Requesting for setting id # " << *it << " having only " << nbc << " components !";
4858                             throw INTERP_KERNEL::Exception(oss.str().c_str());
4859                           }
4860                         pt[*it]=singleValV;
4861                       }
4862                     return self;
4863                   }
4864                 case 2:
4865                   {
4866                     if(multiVal.size()!=multiValV.size())
4867                       {
4868                         std::ostringstream oss;
4869                         oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << multiVal.size() << " !";
4870                         throw INTERP_KERNEL::Exception(oss.str().c_str());
4871                       }
4872                     for(int i=0;i<(int)multiVal.size();i++)
4873                       {
4874                         int pos=multiVal[i];
4875                         if(pos>=nbc)
4876                           {
4877                             std::ostringstream oss;
4878                             oss << "Requesting for setting id # " << pos << " having only " << nbc << " components !";
4879                             throw INTERP_KERNEL::Exception(oss.str().c_str());
4880                           }
4881                         pt[multiVal[i]]=multiValV[i];
4882                       }
4883                     return self;
4884                   }
4885                 case 4:
4886                   {
4887                     const int *ptV=daIntTyyppV->getConstPointer();
4888                     if(nbc>daIntTyyppV->getNumberOfCompo())
4889                       {
4890                         std::ostringstream oss;
4891                         oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
4892                         throw INTERP_KERNEL::Exception(oss.str().c_str());
4893                       }
4894                     std::copy(ptV,ptV+nbc,pt);
4895                     return self;
4896                   }
4897                 default:
4898                   throw INTERP_KERNEL::Exception(msg);
4899                 }
4900             }
4901           case 3:
4902             {
4903               int sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
4904               switch(sw1)
4905                 {
4906                 case 1:
4907                   {
4908                     for(int j=0;j<sz;j++)
4909                       pt[slic.first+j*slic.second.second]=singleValV;
4910                     return self;
4911                   }
4912                 case 2:
4913                   {
4914                     if(sz!=(int)multiValV.size())
4915                       {
4916                         std::ostringstream oss;
4917                         oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << sz << " !";
4918                         throw INTERP_KERNEL::Exception(oss.str().c_str());
4919                       }
4920                     for(int j=0;j<sz;j++)
4921                       pt[slic.first+j*slic.second.second]=multiValV[j];
4922                     return self;
4923                   }
4924                 case 4:
4925                   {
4926                     const int *ptV=daIntTyyppV->getConstPointer();
4927                     if(sz>daIntTyyppV->getNumberOfCompo())
4928                       {
4929                         std::ostringstream oss;
4930                         oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
4931                         throw INTERP_KERNEL::Exception(oss.str().c_str());
4932                       }
4933                     for(int j=0;j<sz;j++)
4934                       pt[slic.first+j*slic.second.second]=ptV[j];
4935                     return self;
4936                   }
4937                 default:
4938                   throw INTERP_KERNEL::Exception(msg);
4939                 }
4940             }
4941           default:
4942             throw INTERP_KERNEL::Exception(msg);
4943           }
4944       }
4945     }
4946   };
4947
4948   class DataArrayChar : public DataArray
4949   {
4950   public:
4951     virtual DataArrayChar *buildEmptySpecializedDAChar() const throw(INTERP_KERNEL::Exception);
4952     int getHashCode() const throw(INTERP_KERNEL::Exception);
4953     bool empty() const throw(INTERP_KERNEL::Exception);
4954     void deepCopyFrom(const DataArrayChar& other) throw(INTERP_KERNEL::Exception);
4955     void reserve(std::size_t nbOfElems) throw(INTERP_KERNEL::Exception);
4956     void pushBackSilent(char val) throw(INTERP_KERNEL::Exception);
4957     char popBackSilent() throw(INTERP_KERNEL::Exception);
4958     void pack() const throw(INTERP_KERNEL::Exception);
4959     void allocIfNecessary(int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception);
4960     bool isEqual(const DataArrayChar& other) const throw(INTERP_KERNEL::Exception);
4961     bool isEqualWithoutConsideringStr(const DataArrayChar& other) const throw(INTERP_KERNEL::Exception);
4962     void reverse() throw(INTERP_KERNEL::Exception);
4963     void fillWithZero() throw(INTERP_KERNEL::Exception);
4964     void fillWithValue(char val) throw(INTERP_KERNEL::Exception);
4965     std::string repr() const throw(INTERP_KERNEL::Exception);
4966     std::string reprZip() const throw(INTERP_KERNEL::Exception);
4967     DataArrayInt *convertToIntArr() const throw(INTERP_KERNEL::Exception);
4968     DataArrayChar *renumber(const int *old2New) const throw(INTERP_KERNEL::Exception);
4969     DataArrayChar *renumberR(const int *new2Old) const throw(INTERP_KERNEL::Exception);
4970     DataArrayChar *renumberAndReduce(const int *old2NewBg, int newNbOfTuple) const throw(INTERP_KERNEL::Exception);
4971     bool isUniform(char val) const throw(INTERP_KERNEL::Exception);
4972     DataArrayChar *subArray(int tupleIdBg, int tupleIdEnd=-1) const throw(INTERP_KERNEL::Exception);
4973     DataArrayChar *changeNbOfComponents(int newNbOfComp, char dftValue) const throw(INTERP_KERNEL::Exception);
4974     void meldWith(const DataArrayChar *other) throw(INTERP_KERNEL::Exception);
4975     void setPartOfValuesAdv(const DataArrayChar *a, const DataArrayChar *tuplesSelec) throw(INTERP_KERNEL::Exception);
4976     char front() const throw(INTERP_KERNEL::Exception);
4977     char back() const throw(INTERP_KERNEL::Exception);
4978     void setIJ(int tupleId, int compoId, char newVal) throw(INTERP_KERNEL::Exception);
4979     void setIJSilent(int tupleId, int compoId, char newVal) throw(INTERP_KERNEL::Exception);
4980     char *getPointer() throw(INTERP_KERNEL::Exception);
4981     DataArrayInt *findIdsEqual(char val) const throw(INTERP_KERNEL::Exception);
4982     DataArrayInt *findIdsNotEqual(char val) const throw(INTERP_KERNEL::Exception);
4983     int findIdFirstEqualTuple(const std::vector<char>& tupl) const throw(INTERP_KERNEL::Exception);
4984     bool presenceOfTuple(const std::vector<char>& tupl) const throw(INTERP_KERNEL::Exception);
4985     char getMaxValue(int& tupleId) const throw(INTERP_KERNEL::Exception);
4986     char getMaxValueInArray() const throw(INTERP_KERNEL::Exception);
4987     char getMinValue(int& tupleId) const throw(INTERP_KERNEL::Exception);
4988     char getMinValueInArray() const throw(INTERP_KERNEL::Exception);
4989     DataArrayInt *findIdsInRange(char vmin, char vmax) const throw(INTERP_KERNEL::Exception);
4990     static DataArrayChar *Aggregate(const DataArrayChar *a1, const DataArrayChar *a2) throw(INTERP_KERNEL::Exception);
4991     static DataArrayChar *Meld(const DataArrayChar *a1, const DataArrayChar *a2) throw(INTERP_KERNEL::Exception);
4992     %extend
4993     {
4994       int __len__() const throw(INTERP_KERNEL::Exception)
4995       {
4996         if(self->isAllocated())
4997           {
4998             return self->getNumberOfTuples();
4999           }
5000         else
5001           {
5002             throw INTERP_KERNEL::Exception("DataArrayChar::__len__ : Instance is NOT allocated !");
5003           }
5004       }
5005
5006       PyObject *isEqualIfNotWhy(const DataArrayChar& other) const throw(INTERP_KERNEL::Exception)
5007       {
5008         std::string ret1;
5009         bool ret0=self->isEqualIfNotWhy(other,ret1);
5010         PyObject *ret=PyTuple_New(2);
5011         PyObject *ret0Py=ret0?Py_True:Py_False;
5012         Py_XINCREF(ret0Py);
5013         PyTuple_SetItem(ret,0,ret0Py);
5014         PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
5015         return ret;
5016       }
5017
5018       DataArrayChar *renumber(PyObject *li) throw(INTERP_KERNEL::Exception)
5019       {
5020         void *da=0;
5021         int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 |  0 );
5022         if (!SWIG_IsOK(res1))
5023           {
5024             int size;
5025             INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
5026             if(size!=self->getNumberOfTuples())
5027               {
5028                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
5029               }
5030             return self->renumber(tmp);
5031           }
5032         else
5033           {
5034             DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
5035             if(!da2)
5036               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
5037             da2->checkAllocated();
5038             int size=self->getNumberOfTuples();
5039             if(size!=self->getNumberOfTuples())
5040               {
5041                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
5042               }
5043             return self->renumber(da2->getConstPointer());
5044           }
5045       }
5046
5047       DataArrayChar *renumberR(PyObject *li) throw(INTERP_KERNEL::Exception)
5048       {
5049         void *da=0;
5050         int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 |  0 );
5051         if (!SWIG_IsOK(res1))
5052           {
5053             int size;
5054             INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
5055             if(size!=self->getNumberOfTuples())
5056               {
5057                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
5058               }
5059             return self->renumberR(tmp);
5060           }
5061         else
5062           {
5063             DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
5064             if(!da2)
5065               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
5066             da2->checkAllocated();
5067             int size=self->getNumberOfTuples();
5068             if(size!=self->getNumberOfTuples())
5069               {
5070                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
5071               }
5072             return self->renumberR(da2->getConstPointer());
5073           }
5074       }
5075
5076       DataArrayChar *renumberAndReduce(PyObject *li, int newNbOfTuple) throw(INTERP_KERNEL::Exception)
5077       {
5078         void *da=0;
5079         int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_MEDCoupling__DataArrayInt, 0 |  0 );
5080         if (!SWIG_IsOK(res1))
5081           {
5082             int size;
5083             INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
5084             if(size!=self->getNumberOfTuples())
5085               {
5086                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
5087               }
5088             return self->renumberAndReduce(tmp,newNbOfTuple);
5089           }
5090         else
5091           {
5092             DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
5093             if(!da2)
5094               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
5095             da2->checkAllocated();
5096             int size=self->getNumberOfTuples();
5097             if(size!=self->getNumberOfTuples())
5098               {
5099                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
5100               }
5101             return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
5102           }
5103       }
5104
5105       static DataArrayChar *Aggregate(PyObject *dachs) throw(INTERP_KERNEL::Exception)
5106       {
5107         std::vector<const MEDCoupling::DataArrayChar *> tmp;
5108         convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayChar *>(dachs,SWIGTYPE_p_MEDCoupling__DataArrayChar,"DataArrayChar",tmp);
5109         return DataArrayChar::Aggregate(tmp);
5110       }
5111
5112       static DataArrayChar *Meld(PyObject *dachs) throw(INTERP_KERNEL::Exception)
5113       {
5114         std::vector<const MEDCoupling::DataArrayChar *> tmp;
5115         convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayChar *>(dachs,SWIGTYPE_p_MEDCoupling__DataArrayChar,"DataArrayChar",tmp);
5116         return DataArrayChar::Meld(tmp);
5117       }
5118     }
5119   };
5120
5121   class DataArrayByteIterator;
5122
5123   class DataArrayByte : public DataArrayChar
5124   {
5125   public:
5126     static DataArrayByte *New();
5127     DataArrayByteIterator *iterator() throw(INTERP_KERNEL::Exception);
5128     DataArrayByte *performCopyOrIncrRef(bool deepCopy) const throw(INTERP_KERNEL::Exception);
5129     char byteValue() const throw(INTERP_KERNEL::Exception);
5130     %extend
5131     {
5132       DataArrayByte() throw(INTERP_KERNEL::Exception)
5133         {
5134           return DataArrayByte::New();
5135         }
5136
5137       static DataArrayByte *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) throw(INTERP_KERNEL::Exception)
5138       {
5139         const char *msg="MEDCoupling::DataArrayByte::New : Available API are : \n-DataArrayByte.New()\n--DataArrayByte.New([1,3,4])\n-DataArrayByte.New([1,3,4],3)\n-DataArrayByte.New([1,3,4,5],2,2)\n-DataArrayByte.New(5)\n-DataArrayByte.New(5,2) !";
5140         if(PyList_Check(elt0) || PyTuple_Check(elt0))
5141           {
5142             if(nbOfTuples)
5143               {
5144                 if(PyInt_Check(nbOfTuples))
5145                   {
5146                     int nbOfTuples1=PyInt_AS_LONG(nbOfTuples);
5147                     if(nbOfTuples1<0)
5148                       throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive set of allocated memory !");
5149                     if(nbOfComp)
5150                       {
5151                         if(PyInt_Check(nbOfComp))
5152                           {//DataArrayByte.New([1,3,4,5],2,2)
5153                             int nbOfCompo=PyInt_AS_LONG(nbOfComp);
5154                             if(nbOfCompo<0)
5155                               throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !");
5156                             MCAuto<DataArrayByte> ret=DataArrayByte::New();
5157                             std::vector<int> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
5158                             ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
5159                             return ret.retn();
5160                           }
5161                         else
5162                           throw INTERP_KERNEL::Exception(msg);
5163                       }
5164                     else
5165                       {//DataArrayByte.New([1,3,4],3)
5166                         MCAuto<DataArrayByte> ret=DataArrayByte::New();
5167                         int tmpp1=-1;
5168                         std::vector<int> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
5169                         ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
5170                         return ret.retn();
5171                       }
5172                   }
5173                 else
5174                   throw INTERP_KERNEL::Exception(msg);
5175               }
5176             else
5177               {// DataArrayByte.New([1,3,4])
5178                 MCAuto<DataArrayByte> ret=DataArrayByte::New();
5179                 int tmpp1=-1,tmpp2=-1;
5180                 std::vector<int> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
5181                 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
5182                 return ret.retn();
5183               }
5184           }
5185         else if(PyInt_Check(elt0))
5186           {
5187             int nbOfTuples1=PyInt_AS_LONG(elt0);
5188             if(nbOfTuples1<0)
5189               throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive set of allocated memory !");
5190             if(nbOfTuples)
5191               {
5192                 if(!nbOfComp)
5193                   {
5194                     if(PyInt_Check(nbOfTuples))
5195                       {//DataArrayByte.New(5,2)
5196                         int nbOfCompo=PyInt_AS_LONG(nbOfTuples);
5197                         if(nbOfCompo<0)
5198                           throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !");
5199                         MCAuto<DataArrayByte> ret=DataArrayByte::New();
5200                         ret->alloc(nbOfTuples1,nbOfCompo);
5201                         return ret.retn();
5202                       }
5203                     else
5204                       throw INTERP_KERNEL::Exception(msg);
5205                   }
5206                 else
5207                   throw INTERP_KERNEL::Exception(msg);
5208               }
5209             else
5210               {//DataArrayByte.New(5)
5211                 MCAuto<DataArrayByte> ret=DataArrayByte::New();
5212                 ret->alloc(nbOfTuples1,1);
5213                 return ret.retn();
5214               }
5215           }
5216         else
5217           throw INTERP_KERNEL::Exception(msg);
5218       }
5219
5220       DataArrayByte(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) throw(INTERP_KERNEL::Exception)
5221         {
5222           return MEDCoupling_DataArrayByte_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
5223         }
5224
5225       std::string __repr__() const throw(INTERP_KERNEL::Exception)
5226       {
5227         std::ostringstream oss;
5228         self->reprQuickOverview(oss);
5229         return oss.str();
5230       }
5231
5232       int __int__() const throw(INTERP_KERNEL::Exception)
5233       {
5234         return (int) self->byteValue();
5235       }
5236
5237       DataArrayByteIterator *__iter__() throw(INTERP_KERNEL::Exception)
5238       {
5239         return self->iterator();
5240       }
5241
5242       int getIJ(int tupleId, int compoId) const throw(INTERP_KERNEL::Exception)
5243       {
5244         return (int)self->getIJ(tupleId,compoId);
5245       }
5246
5247       int getIJSafe(int tupleId, int compoId) const throw(INTERP_KERNEL::Exception)
5248       {
5249         return (int)self->getIJSafe(tupleId,compoId);
5250       }
5251
5252       std::string __str__() const throw(INTERP_KERNEL::Exception)
5253       {
5254         return self->repr();
5255       }
5256
5257       PyObject *toStrList() const throw(INTERP_KERNEL::Exception)
5258       {
5259         const char *vals=self->getConstPointer();
5260         int nbOfComp=self->getNumberOfComponents();
5261         int nbOfTuples=self->getNumberOfTuples();
5262         return convertCharArrToPyListOfTuple(vals,nbOfComp,nbOfTuples);
5263       }
5264
5265       bool presenceOfTuple(PyObject *tupl) const throw(INTERP_KERNEL::Exception)
5266       {
5267         int sz=-1,sw=-1;
5268         int ival=-1; std::vector<int> ivval;
5269         const int *pt=convertObjToPossibleCpp1_Safe(tupl,sw,sz,ival,ivval);
5270         std::vector<char> vals(sz);
5271         std::copy(pt,pt+sz,vals.begin());
5272         return self->presenceOfTuple(vals);
5273       }
5274
5275       bool presenceOfValue(PyObject *vals) const throw(INTERP_KERNEL::Exception)
5276       {
5277         int sz=-1,sw=-1;
5278         int ival=-1; std::vector<int> ivval;
5279         const int *pt=convertObjToPossibleCpp1_Safe(vals,sw,sz,ival,ivval);
5280         std::vector<char> vals2(sz);
5281         std::copy(pt,pt+sz,vals2.begin());
5282         return self->presenceOfValue(vals2);
5283       }
5284
5285       int findIdFirstEqual(PyObject *vals) const throw(INTERP_KERNEL::Exception)
5286       {
5287         int sz=-1,sw=-1;
5288         int ival=-1; std::vector<int> ivval;
5289         const int *pt=convertObjToPossibleCpp1_Safe(vals,sw,sz,ival,ivval);
5290         std::vector<char> vals2(sz);
5291         std::copy(pt,pt+sz,vals2.begin());
5292         return self->findIdFirstEqual(vals2);
5293       }
5294
5295       int findIdFirstEqualTuple(PyObject *tupl) const throw(INTERP_KERNEL::Exception)
5296       {
5297         int sz=-1,sw=-1;
5298         int ival=-1; std::vector<int> ivval;
5299         const int *pt=convertObjToPossibleCpp1_Safe(tupl,sw,sz,ival,ivval);
5300         std::vector<char> vals(sz);
5301         std::copy(pt,pt+sz,vals.begin());
5302         return self->findIdFirstEqualTuple(vals);
5303       }
5304
5305       int findIdSequence(PyObject *strOrListOfInt) const throw(INTERP_KERNEL::Exception)
5306       {
5307         int sz=-1,sw=-1;
5308         int ival=-1; std::vector<int> ivval;
5309         const int *pt=convertObjToPossibleCpp1_Safe(strOrListOfInt,sw,sz,ival,ivval);
5310         std::vector<char> vals(sz);
5311         std::copy(pt,pt+sz,vals.begin());
5312         return self->findIdSequence(vals);
5313       }
5314
5315       PyObject *getTuple(int tupleId) throw(INTERP_KERNEL::Exception)
5316       {
5317         int sz=self->getNumberOfComponents();
5318         INTERP_KERNEL::AutoPtr<char> tmp=new char[sz];
5319         self->getTuple(tupleId,tmp);
5320         PyObject *ret=PyTuple_New(sz);
5321         for(int i=0;i<sz;i++) PyTuple_SetItem(ret,i,PyInt_FromLong((int)tmp[i]));
5322         return ret;
5323       }
5324
5325       PyObject *getMaxValue() const throw(INTERP_KERNEL::Exception)
5326       {
5327         int tmp;
5328         int r1=(int)self->getMaxValue(tmp);
5329         PyObject *ret=PyTuple_New(2);
5330         PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
5331         PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
5332         return ret;
5333       }
5334
5335       PyObject *getMinValue() const throw(INTERP_KERNEL::Exception)
5336       {
5337         int tmp;
5338         int r1=(int)self->getMinValue(tmp);
5339         PyObject *ret=PyTuple_New(2);
5340         PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
5341         PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
5342         return ret;
5343       }
5344
5345       int index(PyObject *obj) const throw(INTERP_KERNEL::Exception)
5346       {
5347         int nbOfCompo=self->getNumberOfComponents();
5348         switch(nbOfCompo)
5349           {
5350           case 1:
5351             {
5352               if(PyInt_Check(obj))
5353                 {
5354                   int val=(int)PyInt_AS_LONG(obj);
5355                   return self->findIdFirstEqual(val);
5356                 }
5357               else
5358                 throw INTERP_KERNEL::Exception("DataArrayByte::index : 'this' contains one component and trying to find an element which is not an integer !");
5359             }
5360           default:
5361             return MEDCoupling_DataArrayByte_findIdFirstEqualTuple(self,obj);
5362           }
5363       }
5364
5365       bool __contains__(PyObject *obj) const throw(INTERP_KERNEL::Exception)
5366       {
5367         int nbOfCompo=self->getNumberOfComponents();
5368         switch(nbOfCompo)
5369           {
5370           case 0:
5371             return false;
5372           case 1:
5373             {
5374               if(PyInt_Check(obj))
5375                 {
5376                   int val=(int)PyInt_AS_LONG(obj);
5377                   return self->presenceOfValue(val);
5378                 }
5379               else
5380                 throw INTERP_KERNEL::Exception("DataArrayByte::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
5381             }
5382           default:
5383             return MEDCoupling_DataArrayByte_presenceOfTuple(self,obj);
5384           }
5385       }
5386
5387       DataArrayByte *__setitem__(PyObject *obj, PyObject *value) throw(INTERP_KERNEL::Exception)
5388       {
5389         self->checkAllocated();
5390         const char msg[]="Unexpected situation in __setitem__ !";
5391         int nbOfTuples(self->getNumberOfTuples()),nbOfComponents(self->getNumberOfComponents());
5392         int sw1,sw2;
5393         int i1;
5394         std::vector<int> v1;
5395         DataArrayInt *d1=0;
5396         DataArrayIntTuple *dd1=0;
5397         convertObjToPossibleCpp1(value,sw1,i1,v1,d1,dd1);
5398         int it1,ic1;
5399         std::vector<int> vt1,vc1;
5400         std::pair<int, std::pair<int,int> > pt1,pc1;
5401         DataArrayInt *dt1=0,*dc1=0;
5402         convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw2,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1);
5403         MCAuto<DataArrayInt> tmp;
5404         switch(sw2)
5405           {
5406           case 1:
5407             {
5408               switch(sw1)
5409                 {
5410                 case 1:
5411                   self->setPartOfValuesSimple1(i1,it1,it1+1,1,0,nbOfComponents,1);
5412                   return self;
5413                 default:
5414                   throw INTERP_KERNEL::Exception(msg);
5415                 }
5416               break;
5417             }
5418           case 2:
5419             {
5420               switch(sw1)
5421                 {
5422                 case 1:
5423                   self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1);
5424                   return self;
5425                 default:
5426                   throw INTERP_KERNEL::Exception(msg);
5427                 }
5428               break;
5429             }
5430           case 3:
5431             {
5432               switch(sw1)
5433                 {
5434                 case 1:
5435                   self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1);
5436                   return self;
5437                 default:
5438                   throw INTERP_KERNEL::Exception(msg);
5439                 }
5440               break;
5441             }
5442           case 4:
5443             {
5444               switch(sw1)
5445                 {
5446                 case 1:
5447                   self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1);
5448                   return self;
5449                 default:
5450                   throw INTERP_KERNEL::Exception(msg);
5451                 }
5452               break;
5453             }
5454           case 5:
5455             {
5456               switch(sw1)
5457                 {
5458                 case 1:
5459                   self->setPartOfValuesSimple1(i1,it1,it1+1,1,ic1,ic1+1,1);
5460                   return self;
5461                 default:
5462                   throw INTERP_KERNEL::Exception(msg);
5463                 }
5464               break;
5465             }
5466           case 6:
5467             {
5468               switch(sw1)
5469                 {
5470                 case 1:
5471                   self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1);
5472                   return self;
5473                 default:
5474                   throw INTERP_KERNEL::Exception(msg);
5475                 }
5476               break;
5477             }
5478           case 7:
5479             {
5480               switch(sw1)
5481                 {
5482                 case 1:
5483                   self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1);
5484                   return self;
5485                 default:
5486                   throw INTERP_KERNEL::Exception(msg);
5487                 }
5488               break;
5489             }
5490           case 8:
5491             {
5492               switch(sw1)
5493                 {
5494                 case 1:
5495                   self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1);
5496                   return self;
5497                 default:
5498                   throw INTERP_KERNEL::Exception(msg);
5499                 }
5500               break;
5501             }
5502           case 9:
5503             {
5504               switch(sw1)
5505                 {
5506                 case 1:
5507                   self->setPartOfValuesSimple2(i1,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size());
5508                   return self;
5509                 default:
5510                   throw INTERP_KERNEL::Exception(msg);
5511                 }
5512               break;
5513             }
5514           case 10:
5515             {
5516               switch(sw1)
5517                 {
5518                 case 1:
5519                   self->setPartOfValuesSimple2(i1,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size());
5520                   return self;
5521                 default:
5522                   throw INTERP_KERNEL::Exception(msg);
5523                 }
5524               break;
5525             }
5526           case 11:
5527             {
5528               switch(sw1)
5529                 {
5530                 case 1:
5531                   self->setPartOfValuesSimple4(i1,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size());
5532                   return self;
5533                 default:
5534                   throw INTERP_KERNEL::Exception(msg);
5535                 }
5536               break;
5537             }
5538           case 12:
5539             {
5540               switch(sw1)
5541                 {
5542                 case 1:
5543                   self->setPartOfValuesSimple2(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size());
5544                   return self;
5545                 default:
5546                   throw INTERP_KERNEL::Exception(msg);
5547                 }
5548               break;
5549             }
5550           case 13:
5551             {
5552               switch(sw1)
5553                 {
5554                 case 1:
5555                   self->setPartOfValuesSimple1(i1,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second);
5556                   return self;
5557                 default:
5558                   throw INTERP_KERNEL::Exception(msg);
5559                 }
5560               break;
5561             }
5562           case 14:
5563             {
5564               switch(sw1)
5565                 {
5566                 case 1:
5567                   self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second);
5568                   return self;
5569                 default:
5570                   throw INTERP_KERNEL::Exception(msg);
5571                 }
5572               break;
5573             }
5574           case 15:
5575             {
5576               switch(sw1)
5577                 {
5578                 case 1:
5579                   self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second);
5580                   return self;
5581                 default:
5582                   throw INTERP_KERNEL::Exception(msg);
5583                 }
5584               break;
5585             }
5586           case 16:
5587             {
5588               switch(sw1)
5589                 {
5590                 case 1:
5591                   self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second);
5592                   return self;
5593                 default:
5594                   throw INTERP_KERNEL::Exception(msg);
5595                 }
5596               break;
5597             }
5598           default:
5599             throw INTERP_KERNEL::Exception(msg);
5600           }
5601         return self;
5602       }
5603     }
5604   };
5605
5606   class DataArrayByteTuple;
5607
5608   class DataArrayByteIterator
5609   {
5610   public:
5611     DataArrayByteIterator(DataArrayByte *da);
5612     ~DataArrayByteIterator();
5613   };
5614
5615   class DataArrayByteTuple
5616   {
5617   public:
5618     std::string repr() const throw(INTERP_KERNEL::Exception);
5619     DataArrayByte *buildDAByte(int nbOfTuples, int nbOfCompo) const throw(INTERP_KERNEL::Exception);
5620     %extend
5621     {
5622       std::string __str__() const throw(INTERP_KERNEL::Exception)
5623       {
5624         return self->repr();
5625       }
5626
5627       char __int__() const throw(INTERP_KERNEL::Exception)
5628       {
5629         return self->byteValue();
5630       }
5631
5632       DataArrayByte *buildDAByte() throw(INTERP_KERNEL::Exception)
5633       {
5634         return self->buildDAByte(1,self->getNumberOfCompo());
5635       }
5636     }
5637   };
5638
5639   class DataArrayAsciiCharIterator;
5640
5641   class DataArrayAsciiChar : public DataArrayChar
5642   {
5643   public:
5644     static DataArrayAsciiChar *New();
5645     DataArrayAsciiCharIterator *iterator() throw(INTERP_KERNEL::Exception);
5646     DataArrayAsciiChar *performCopyOrIncrRef(bool deepCopy) const throw(INTERP_KERNEL::Exception);
5647     char asciiCharValue() const throw(INTERP_KERNEL::Exception);
5648     %extend
5649     {
5650       DataArrayAsciiChar() throw(INTERP_KERNEL::Exception)
5651         {
5652           return DataArrayAsciiChar::New();
5653         }
5654
5655       static DataArrayAsciiChar *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) throw(INTERP_KERNEL::Exception)
5656       {
5657         const char *msg="MEDCoupling::DataArrayAsciiChar::New : Available API are : \n-DataArrayAsciiChar.New()\n-DataArrayAsciiChar.New([1,3,4])\n-DataArrayAsciiChar.New([\"abc\",\"de\",\"fghi\"])\n-DataArrayAsciiChar.New([\"abc\",\"de\",\"fghi\"],\"t\")\n-DataArrayAsciiChar.New([1,3,4],3)\n-DataArrayAsciiChar.New([1,3,4,5],2,2)\n-DataArrayAsciiChar.New(5)\n-DataArrayAsciiChar.New(5,2) !";
5658         if(PyList_Check(elt0) || PyTuple_Check(elt0))
5659           {
5660             if(nbOfTuples)
5661               {
5662                 if(PyInt_Check(nbOfTuples))
5663                   {
5664                     int nbOfTuples1=PyInt_AS_LONG(nbOfTuples);
5665                     if(nbOfTuples1<0)
5666                       throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive set of allocated memory !");
5667                     if(nbOfComp)
5668                       {
5669                         if(PyInt_Check(nbOfComp))
5670                           {//DataArrayAsciiChar.New([1,3,4,5],2,2)
5671                             int nbOfCompo=PyInt_AS_LONG(nbOfComp);
5672                             if(nbOfCompo<0)
5673                               throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !");
5674                             MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
5675                             std::vector<int> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
5676                             ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
5677                             return ret.retn();
5678                           }
5679                         else
5680                           throw INTERP_KERNEL::Exception(msg);
5681                       }
5682                     else
5683                       {//DataArrayAsciiChar.New([1,3,4],3)
5684                         MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
5685                         int tmpp1=-1;
5686                         std::vector<int> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
5687                         ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
5688                         return ret.retn();
5689                       }
5690                   }
5691                 else if(PyString_Check(nbOfTuples))
5692                   {
5693                     if(PyString_Size(nbOfTuples)!=1)
5694                       throw INTERP_KERNEL::Exception(msg);
5695                     //DataArrayAsciiChar.New(["abc","de","fghi"],"t")
5696                     std::vector<std::string> tmp;
5697                     if(fillStringVector(elt0,tmp))
5698                       return DataArrayAsciiChar::New(tmp,PyString_AsString(nbOfTuples)[0]);
5699                     else
5700                       throw INTERP_KERNEL::Exception(msg);
5701                   }
5702                 else
5703                   throw INTERP_KERNEL::Exception(msg);
5704               }
5705             else
5706               {
5707                 std::vector<std::string> tmmp;
5708                 if(fillStringVector(elt0,tmmp))
5709                   //DataArrayAsciiChar.New(["abc","de","fghi"])
5710                   return DataArrayAsciiChar::New(tmmp,' ');
5711                 else
5712                   {
5713                     // DataArrayAsciiChar.New([1,3,4])
5714                     MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
5715                     int tmpp1=-1,tmpp2=-1;
5716                     std::vector<int> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
5717                     ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
5718                     return ret.retn();
5719                   }
5720               }
5721           }
5722         else if(PyInt_Check(elt0))
5723           {
5724             int nbOfTuples1=PyInt_AS_LONG(elt0);
5725             if(nbOfTuples1<0)
5726               throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive set of allocated memory !");
5727             if(nbOfTuples)
5728               {
5729                 if(!nbOfComp)
5730                   {
5731                     if(PyInt_Check(nbOfTuples))
5732                       {//DataArrayAsciiChar.New(5,2)
5733                         int nbOfCompo=PyInt_AS_LONG(nbOfTuples);
5734                         if(nbOfCompo<0)
5735                           throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !");
5736                         MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
5737                         ret->alloc(nbOfTuples1,nbOfCompo);
5738                         return ret.retn();
5739                       }
5740                     else
5741                       throw INTERP_KERNEL::Exception(msg);
5742                   }
5743                 else
5744                   throw INTERP_KERNEL::Exception(msg);
5745               }
5746             else
5747               {//DataArrayAsciiChar.New(5)
5748                 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
5749                 ret->alloc(nbOfTuples1,1);
5750                 return ret.retn();
5751               }
5752           }
5753         else
5754           throw INTERP_KERNEL::Exception(msg);
5755       }
5756
5757       DataArrayAsciiChar(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) throw(INTERP_KERNEL::Exception)
5758         {
5759           return MEDCoupling_DataArrayAsciiChar_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
5760         }
5761
5762       std::string __repr__() const throw(INTERP_KERNEL::Exception)
5763       {
5764         std::ostringstream oss;
5765         self->reprQuickOverview(oss);
5766         return oss.str();
5767       }
5768
5769       DataArrayAsciiCharIterator *__iter__() throw(INTERP_KERNEL::Exception)
5770       {
5771         return self->iterator();
5772       }
5773
5774       std::string getIJ(int tupleId, int compoId) const throw(INTERP_KERNEL::Exception)
5775       {
5776         char tmp[2]; tmp[1]='\0';
5777         tmp[0]=self->getIJ(tupleId,compoId);
5778         return std::string(tmp);
5779       }
5780
5781       std::string getIJSafe(int tupleId, int compoId) const throw(INTERP_KERNEL::Exception)
5782       {
5783         char tmp[2]; tmp[1]='\0';
5784         tmp[0]=self->getIJSafe(tupleId,compoId);
5785         return std::string(tmp);
5786       }
5787
5788       std::string __str__() const throw(INTERP_KERNEL::Exception)
5789       {
5790         return self->repr();
5791       }
5792
5793       PyObject *toStrList() const throw(INTERP_KERNEL::Exception)
5794       {
5795         const char *vals=self->getConstPointer();
5796         int nbOfComp=self->getNumberOfComponents();
5797         int nbOfTuples=self->getNumberOfTuples();
5798         return convertCharArrToPyListOfTuple(vals,nbOfComp,nbOfTuples);
5799       }
5800
5801       bool presenceOfTuple(PyObject *tupl) const throw(INTERP_KERNEL::Exception)
5802       {
5803         if(PyString_Check(tupl))
5804           {
5805             Py_ssize_t sz=PyString_Size(tupl);
5806             std::vector<char> vals(sz);
5807             std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin());
5808             return self->presenceOfTuple(vals);
5809           }
5810         else
5811           throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfTuple : only strings in input supported !");
5812       }
5813
5814       bool presenceOfValue(PyObject *vals) const throw(INTERP_KERNEL::Exception)
5815       {
5816         if(PyString_Check(vals))
5817           {
5818             Py_ssize_t sz=PyString_Size(vals);
5819             std::vector<char> vals2(sz);
5820             std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin());
5821             return self->presenceOfValue(vals2);
5822           }
5823         else
5824           throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfValue : only strings in input supported !");
5825       }
5826
5827       int findIdFirstEqual(PyObject *vals) const throw(INTERP_KERNEL::Exception)
5828       {
5829         if(PyString_Check(vals))
5830           {
5831             Py_ssize_t sz=PyString_Size(vals);
5832             std::vector<char> vals2(sz);
5833             std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin());
5834             return self->findIdFirstEqual(vals2);
5835           }
5836         else
5837           throw INTERP_KERNEL::Exception("DataArrayAsciiChar::findIdFirstEqual : only strings in input supported !");
5838       }
5839
5840       int findIdFirstEqualTuple(PyObject *tupl) const throw(INTERP_KERNEL::Exception)
5841       {
5842         if(PyString_Check(tupl))
5843           {
5844             Py_ssize_t sz=PyString_Size(tupl);
5845             std::vector<char> vals(sz);
5846             std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin());
5847             return self->findIdFirstEqualTuple(vals);
5848           }
5849         else
5850           throw INTERP_KERNEL::Exception("DataArrayAsciiChar::findIdFirstEqualTuple : only strings in input supported !");
5851       }
5852
5853       int findIdSequence(PyObject *strOrListOfInt) const throw(INTERP_KERNEL::Exception)
5854       {
5855         if(PyString_Check(strOrListOfInt))
5856           {
5857             Py_ssize_t sz=PyString_Size(strOrListOfInt);
5858             std::vector<char> vals(sz);
5859             std::copy(PyString_AsString(strOrListOfInt),PyString_AsString(strOrListOfInt)+sz,vals.begin());
5860             return self->findIdSequence(vals);
5861           }
5862         else
5863           throw INTERP_KERNEL::Exception("DataArrayAsciiChar::search : only strings in input supported !");
5864       }
5865
5866       PyObject *getTuple(int tupleId) const throw(INTERP_KERNEL::Exception)
5867       {
5868         int sz=self->getNumberOfComponents();
5869         INTERP_KERNEL::AutoPtr<char> tmp=new char[sz+1]; tmp[sz]='\0';
5870         self->getTuple(tupleId,tmp);
5871         return PyString_FromString(tmp);
5872       }
5873
5874       PyObject *getMaxValue() const throw(INTERP_KERNEL::Exception)
5875       {
5876         int tmp;
5877         char tmp2[2]; tmp2[1]='\0';
5878         tmp2[0]=self->getMaxValue(tmp);
5879         PyObject *ret=PyTuple_New(2);
5880         PyTuple_SetItem(ret,0,PyString_FromString(tmp2));
5881         PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
5882         return ret;
5883       }
5884
5885       PyObject *getMinValue() const throw(INTERP_KERNEL::Exception)
5886       {
5887         int tmp;
5888         char tmp2[2]; tmp2[1]='\0';
5889         tmp2[0]=self->getMinValue(tmp);
5890         PyObject *ret=PyTuple_New(2);
5891         PyTuple_SetItem(ret,0,PyString_FromString(tmp2));
5892         PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
5893         return ret;
5894       }
5895
5896       int index(PyObject *obj) const throw(INTERP_KERNEL::Exception)
5897       {
5898         int nbOfCompo=self->getNumberOfComponents();
5899         switch(nbOfCompo)
5900           {
5901           case 1:
5902             {
5903               if(PyString_Check(obj))
5904                 {
5905                   Py_ssize_t sz=PyString_Size(obj);
5906                   char *pt=PyString_AsString(obj);
5907                   if(sz==1)
5908                     return self->findIdFirstEqual(pt[0]);
5909                   else
5910                     throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find a string with size different from 1 !");
5911                 }
5912               else
5913                 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find an element which is not an integer !");
5914             }
5915           default:
5916             return MEDCoupling_DataArrayAsciiChar_findIdFirstEqualTuple(self,obj);
5917           }
5918       }
5919
5920       bool __contains__(PyObject *obj) const throw(INTERP_KERNEL::Exception)
5921       {
5922         int nbOfCompo=self->getNumberOfComponents();
5923         switch(nbOfCompo)
5924           {
5925           case 0:
5926             return false;
5927           case 1:
5928             {
5929               if(PyString_Check(obj))
5930                 {
5931                   Py_ssize_t sz=PyString_Size(obj);
5932                   char *pt=PyString_AsString(obj);
5933                   if(sz==1)
5934                     return self->presenceOfValue(pt[0]);
5935                   else
5936                     throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find a string with size different from 1 !");
5937                 }
5938               else
5939                 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
5940             }
5941           default:
5942             return MEDCoupling_DataArrayAsciiChar_presenceOfTuple(self,obj);
5943           }
5944       }
5945
5946       PyObject *__getitem__(PyObject *obj) const throw(INTERP_KERNEL::Exception)
5947       {
5948         int sw,iTypppArr;
5949         std::vector<int> stdvecTyyppArr;
5950         std::pair<int, std::pair<int,int> > sTyyppArr;
5951         MEDCoupling::DataArrayInt *daIntTyypp=0;
5952         convertObjToPossibleCpp2WithNegIntInterp(obj,self->getNumberOfTuples(),sw,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp);
5953         switch(sw)
5954           {
5955           case 1:
5956             return MEDCoupling_DataArrayAsciiChar_getTuple(self,iTypppArr);
5957           case 2:
5958             return convertDataArrayChar(self->selectByTupleIdSafe(&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size()), SWIG_POINTER_OWN | 0 );
5959           case 3:
5960             return convertDataArrayChar(self->selectByTupleIdSafeSlice(sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second), SWIG_POINTER_OWN | 0 );
5961           case 4:
5962             return convertDataArrayChar(self->selectByTupleIdSafe(daIntTyypp->begin(),daIntTyypp->end()), SWIG_POINTER_OWN | 0 );
5963           default:
5964             throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__getitem__ : supporting int, list of int, tuple of int, DataArrayInt and slice in input !");
5965           }
5966       }
5967
5968       DataArrayAsciiChar *__setitem__(PyObject *obj, PyObject *value) throw(INTERP_KERNEL::Exception)
5969       {
5970         static const char msg[]="DataArrayAsciiChar::__setitem__ : supporting int, list of int, tuple of int, DataArrayInt and slice in input, and 4 types accepted in value : string, list or tuple of strings having same size, not null DataArrayChar instance.";
5971         int sw1,iTypppArr;
5972         std::vector<int> stdvecTyyppArr;
5973         std::pair<int, std::pair<int,int> > sTyyppArr;
5974         MEDCoupling::DataArrayInt *daIntTyypp=0;
5975         int nbOfCompo=self->getNumberOfComponents();
5976         int nbOfTuples=self->getNumberOfTuples();
5977         convertObjToPossibleCpp2WithNegIntInterp(obj,nbOfTuples,sw1,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp);
5978         int sw2;
5979         char vc; std::string sc; std::vector<std::string> vsc; DataArrayChar *dacc=0;
5980         convertObjToPossibleCpp6(value,sw2,vc,sc,vsc,dacc);
5981         switch(sw1)
5982           {
5983           case 1:
5984             {//obj int
5985               switch(sw2)
5986                 {//value char
5987                 case 1:
5988                   {
5989                     self->setPartOfValuesSimple3(vc,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1);
5990                     return self;
5991                   }
5992                   //value string
5993                 case 2:
5994                   {
5995                     MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
5996                     self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
5997                     return self;
5998                   }
5999                   //value vector<string>
6000                 case 3:
6001                   {
6002                     MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
6003                     self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
6004                     return self;
6005                   }
6006                   //value DataArrayChar
6007                 case 4:
6008                   {
6009                     self->setPartOfValues3(dacc,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
6010                     return self;
6011                   }
6012                 default:
6013                   throw INTERP_KERNEL::Exception(msg);
6014                 }
6015             }
6016           case 2:
6017             {//obj list-tuple[int]
6018               switch(sw2)
6019                 {
6020                   {//value char
6021                   case 1:
6022                     {
6023                       self->setPartOfValuesSimple3(vc,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1);
6024                       return self;
6025                     }
6026                     //value string
6027                   case 2:
6028                     {
6029                       MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
6030                       self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
6031                       return self;
6032                     }
6033                     //value vector<string>
6034                   case 3:
6035                     {
6036                       MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
6037                       self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
6038                       return self;
6039                     }
6040                     //value DataArrayChar
6041                   case 4:
6042                     {
6043                       self->setPartOfValues3(dacc,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
6044                       return self;
6045                     }
6046                   default:
6047                     throw INTERP_KERNEL::Exception(msg);
6048                   }
6049                 }
6050             }
6051           case 3:
6052             {//slice
6053               switch(sw2)
6054                 {
6055                   {//value char
6056                   case 1:
6057                     {
6058                       self->setPartOfValuesSimple1(vc,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1);
6059                       return self;
6060                     }
6061                     //value string
6062                   case 2:
6063                     {
6064                       MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
6065                       self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
6066                       return self;
6067                     }
6068                     //value vector<string>
6069                   case 3:
6070                     {
6071                       MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
6072                       self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
6073                       return self;
6074                     }
6075                     //value DataArrayChar
6076                   case 4:
6077                     {
6078                       self->setPartOfValues1(dacc,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
6079                       return self;
6080                     }
6081                   default:
6082                     throw INTERP_KERNEL::Exception(msg);
6083                   }
6084                 }
6085             }
6086           case 4:
6087             {//DataArrayInt
6088               switch(sw2)
6089                 {
6090                   {//value char
6091                   case 1:
6092                     {
6093                       self->setPartOfValuesSimple3(vc,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1);
6094                       return self;
6095                     }
6096                     //value string
6097                   case 2:
6098                     {
6099                       MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
6100                       self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
6101                       return self;
6102                     }
6103                     //value vector<string>
6104                   case 3:
6105                     {
6106                       MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
6107                       self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
6108                       return self;
6109                     }
6110                     //value DataArrayChar
6111                   case 4:
6112                     {
6113                       self->setPartOfValues3(dacc,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
6114                       return self;
6115                     }
6116                   default:
6117                     throw INTERP_KERNEL::Exception(msg);
6118                   }
6119                 }
6120             }
6121           default:
6122             throw INTERP_KERNEL::Exception(msg);
6123           }
6124       }
6125     }
6126   };
6127
6128   class DataArrayAsciiCharTuple;
6129
6130   class DataArrayAsciiCharIterator
6131   {
6132   public:
6133     DataArrayAsciiCharIterator(DataArrayAsciiChar *da);
6134     ~DataArrayAsciiCharIterator();
6135     %extend
6136     {
6137       PyObject *next()
6138       {
6139         DataArrayAsciiCharTuple *ret=self->nextt();
6140         if(ret)
6141           return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayAsciiCharTuple,SWIG_POINTER_OWN | 0);
6142         else
6143           {
6144             PyErr_SetString(PyExc_StopIteration,"No more data.");
6145             return 0;
6146           }
6147       }
6148     }
6149   };
6150
6151   class DataArrayAsciiCharTuple
6152   {
6153   public:
6154     int getNumberOfCompo() const throw(INTERP_KERNEL::Exception);
6155     DataArrayAsciiChar *buildDAAsciiChar(int nbOfTuples, int nbOfCompo) const throw(INTERP_KERNEL::Exception);
6156     %extend
6157     {
6158       std::string __str__() const throw(INTERP_KERNEL::Exception)
6159       {
6160         return self->repr();
6161       }
6162
6163       DataArrayAsciiChar *buildDAAsciiChar() throw(INTERP_KERNEL::Exception)
6164       {
6165         return self->buildDAAsciiChar(1,self->getNumberOfCompo());
6166       }
6167     }
6168   };
6169 }