src/MEDCoupling_Swig/MEDCouplingMemArray.i

   1 // Copyright (C) 2007-2021  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 (EDF R&D)
  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 %typemap(out) MCAuto<MEDCoupling::DataArrayInt32>
  45 {
  46   $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt32,SWIG_POINTER_OWN|0);
  47 }
  48
  49 %typemap(out) MCAuto<MEDCoupling::DataArrayInt64>
  50 {
  51   $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt64,SWIG_POINTER_OWN|0);
  52 }
  53
  54 %typemap(out) MCAuto<MEDCoupling::DataArrayIdType>
  55 {
  56   $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTITraits<mcIdType>::TI,SWIG_POINTER_OWN|0);
  57 }
  58
  59 %typemap(out) MCAuto<MEDCoupling::DataArrayDouble>
  60 {
  61   $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble,SWIG_POINTER_OWN|0);
  62 }
  63
  64 %typemap(out) MCAuto<MEDCoupling::DataArrayFloat>
  65 {
  66   $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayFloat,SWIG_POINTER_OWN|0);
  67 }
  68
  69 %typemap(out) MCAuto<MEDCoupling::MapII>
  70 {
  71   $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTYPE_p_MEDCoupling__MapII,SWIG_POINTER_OWN|0);
  72 }
  73 //$$$$$$$$$$$$$$$$$$
  74
  75 %newobject MEDCoupling::DataArray::deepCopy;
  76 %newobject MEDCoupling::DataArray::copySorted;
  77 %newobject MEDCoupling::DataArray::buildNewEmptyInstance;
  78 %newobject MEDCoupling::DataArray::selectByTupleRanges;
  79 %newobject MEDCoupling::DataArray::selectByTupleId;
  80 %newobject MEDCoupling::DataArray::selectByTupleIdSafe;
  81 %newobject MEDCoupling::DataArray::selectByTupleIdSafeSlice;
  82 %newobject MEDCoupling::DataArray::Aggregate;
  83 %newobject MEDCoupling::DataArrayFloat::New;
  84 %newobject MEDCoupling::DataArrayFloat::iterator;
  85 %newobject MEDCoupling::DataArrayFloat::__iter__;
  86 %newobject MEDCoupling::DataArrayFloat::Meld;
  87 %newobject MEDCoupling::DataArrayFloat::__rmul__;
  88 %newobject MEDCoupling::DataArrayInt32::New;
  89 %newobject MEDCoupling::DataArrayInt32::__iter__;
  90 %newobject MEDCoupling::DataArrayInt32::performCopyOrIncrRef;
  91 %newobject MEDCoupling::DataArrayInt32::subArray;
  92 %newobject MEDCoupling::DataArrayInt32::changeNbOfComponents;
  93 %newobject MEDCoupling::DataArrayInt32::accumulatePerChunck;
  94 %newobject MEDCoupling::DataArrayInt32::checkAndPreparePermutation;
  95 %newobject MEDCoupling::DataArrayInt32::transformWithIndArrR;
  96 %newobject MEDCoupling::DataArrayInt32::renumber;
  97 %newobject MEDCoupling::DataArrayInt32::renumberR;
  98 %newobject MEDCoupling::DataArrayInt32::renumberAndReduce;
  99 %newobject MEDCoupling::DataArrayInt32::invertArrayO2N2N2O;
 100 %newobject MEDCoupling::DataArrayInt32::invertArrayN2O2O2N;
 101 %newobject MEDCoupling::DataArrayInt32::invertArrayO2N2N2OBis;
 102 %newobject MEDCoupling::DataArrayInt32::findIdsEqual;
 103 %newobject MEDCoupling::DataArrayInt32::findIdsNotEqual;
 104 %newobject MEDCoupling::DataArrayInt32::findIdsEqualList;
 105 %newobject MEDCoupling::DataArrayInt32::findIdsNotEqualList;
 106 %newobject MEDCoupling::DataArrayInt32::findIdsEqualTuple;
 107 %newobject MEDCoupling::DataArrayInt32::findIdForEach;
 108 %newobject MEDCoupling::DataArrayInt32::sumPerTuple;
 109 %newobject MEDCoupling::DataArrayInt32::negate;
 110 %newobject MEDCoupling::DataArrayInt32::computeAbs;
 111 %newobject MEDCoupling::DataArrayInt32::findIdsInRange;
 112 %newobject MEDCoupling::DataArrayInt32::findIdsNotInRange;
 113 %newobject MEDCoupling::DataArrayInt32::findIdsStrictlyNegative;
 114 %newobject MEDCoupling::DataArrayInt32::Aggregate;
 115 %newobject MEDCoupling::DataArrayInt32::AggregateIndexes;
 116 %newobject MEDCoupling::DataArrayInt32::Meld;
 117 %newobject MEDCoupling::DataArrayInt32::Add;
 118 %newobject MEDCoupling::DataArrayInt32::Substract;
 119 %newobject MEDCoupling::DataArrayInt32::Multiply;
 120 %newobject MEDCoupling::DataArrayInt32::Divide;
 121 %newobject MEDCoupling::DataArrayInt32::Pow;
 122 %newobject MEDCoupling::DataArrayInt32::BuildUnion;
 123 %newobject MEDCoupling::DataArrayInt32::BuildIntersection;
 124 %newobject MEDCoupling::DataArrayInt32::Range;
 125 %newobject MEDCoupling::DataArrayInt32::indicesOfSubPart;
 126 %newobject MEDCoupling::DataArrayInt32::fromNoInterlace;
 127 %newobject MEDCoupling::DataArrayInt32::toNoInterlace;
 128 %newobject MEDCoupling::DataArrayInt32::buildComplement;
 129 %newobject MEDCoupling::DataArrayInt32::buildUnion;
 130 %newobject MEDCoupling::DataArrayInt32::buildSubstraction;
 131 %newobject MEDCoupling::DataArrayInt32::buildSubstractionOptimized;
 132 %newobject MEDCoupling::DataArrayInt32::buildIntersection;
 133 %newobject MEDCoupling::DataArrayInt32::indexOfSameConsecutiveValueGroups;
 134 %newobject MEDCoupling::DataArrayInt32::buildUnique;
 135 %newobject MEDCoupling::DataArrayInt32::buildUniqueNotSorted;
 136 %newobject MEDCoupling::DataArrayInt32::deltaShiftIndex;
 137 %newobject MEDCoupling::DataArrayInt32::buildExplicitArrByRanges;
 138 %newobject MEDCoupling::DataArrayInt32::buildExplicitArrOfSliceOnScaledArr;
 139 %newobject MEDCoupling::DataArrayInt32::findRangeIdForEachTuple;
 140 %newobject MEDCoupling::DataArrayInt32::findIdInRangeForEachTuple;
 141 %newobject MEDCoupling::DataArrayInt32::duplicateEachTupleNTimes;
 142 %newobject MEDCoupling::DataArrayInt32::occurenceRankInThis;
 143 %newobject MEDCoupling::DataArrayInt32::buildPermutationArr;
 144 %newobject MEDCoupling::DataArrayInt32::buildPermArrPerLevel;
 145 %newobject MEDCoupling::DataArrayInt32::getDifferentValues;
 146 %newobject MEDCoupling::DataArrayInt32::FindPermutationFromFirstToSecond;
 147 %newobject MEDCoupling::DataArrayInt32::FindPermutationFromFirstToSecondDuplicate;
 148 %newobject MEDCoupling::DataArrayInt32::CheckAndPreparePermutation;
 149 %newobject MEDCoupling::DataArrayInt32::__neg__;
 150 %newobject MEDCoupling::DataArrayInt32::__add__;
 151 %newobject MEDCoupling::DataArrayInt32::__radd__;
 152 %newobject MEDCoupling::DataArrayInt32::__sub__;
 153 %newobject MEDCoupling::DataArrayInt32::__rsub__;
 154 %newobject MEDCoupling::DataArrayInt32::__mul__;
 155 %newobject MEDCoupling::DataArrayInt32::__rmul__;
 156 %newobject MEDCoupling::DataArrayInt32::__div__;
 157 %newobject MEDCoupling::DataArrayInt32::__rdiv__;
 158 %newobject MEDCoupling::DataArrayInt32::__mod__;
 159 %newobject MEDCoupling::DataArrayInt32::__rmod__;
 160 %newobject MEDCoupling::DataArrayInt32::__pow__;
 161 %newobject MEDCoupling::DataArrayInt32::__rpow__;
 162 %newobject MEDCoupling::DataArrayInt32::convertToInt64Arr;
 163 %newobject MEDCoupling::DataArrayInt32Tuple::buildDAInt;
 164 %newobject MEDCoupling::DataArrayInt64::New;
 165 %newobject MEDCoupling::DataArrayInt64::__iter__;
 166 %newobject MEDCoupling::DataArrayInt64::performCopyOrIncrRef;
 167 %newobject MEDCoupling::DataArrayInt64::subArray;
 168 %newobject MEDCoupling::DataArrayInt64::changeNbOfComponents;
 169 %newobject MEDCoupling::DataArrayInt64::accumulatePerChunck;
 170 %newobject MEDCoupling::DataArrayInt64::checkAndPreparePermutation;
 171 %newobject MEDCoupling::DataArrayInt64::transformWithIndArrR;
 172 %newobject MEDCoupling::DataArrayInt64::renumber;
 173 %newobject MEDCoupling::DataArrayInt64::renumberR;
 174 %newobject MEDCoupling::DataArrayInt64::renumberAndReduce;
 175 %newobject MEDCoupling::DataArrayInt64::invertArrayO2N2N2O;
 176 %newobject MEDCoupling::DataArrayInt64::invertArrayN2O2O2N;
 177 %newobject MEDCoupling::DataArrayInt64::invertArrayO2N2N2OBis;
 178 %newobject MEDCoupling::DataArrayInt64::findIdsEqual;
 179 %newobject MEDCoupling::DataArrayInt64::findIdsNotEqual;
 180 %newobject MEDCoupling::DataArrayInt64::findIdsEqualList;
 181 %newobject MEDCoupling::DataArrayInt64::findIdsNotEqualList;
 182 %newobject MEDCoupling::DataArrayInt64::findIdsEqualTuple;
 183 %newobject MEDCoupling::DataArrayInt64::findIdForEach;
 184 %newobject MEDCoupling::DataArrayInt64::sumPerTuple;
 185 %newobject MEDCoupling::DataArrayInt64::negate;
 186 %newobject MEDCoupling::DataArrayInt64::computeAbs;
 187 %newobject MEDCoupling::DataArrayInt64::findIdsInRange;
 188 %newobject MEDCoupling::DataArrayInt64::findIdsNotInRange;
 189 %newobject MEDCoupling::DataArrayInt64::findIdsStrictlyNegative;
 190 %newobject MEDCoupling::DataArrayInt64::Aggregate;
 191 %newobject MEDCoupling::DataArrayInt64::AggregateIndexes;
 192 %newobject MEDCoupling::DataArrayInt64::Meld;
 193 %newobject MEDCoupling::DataArrayInt64::Add;
 194 %newobject MEDCoupling::DataArrayInt64::Substract;
 195 %newobject MEDCoupling::DataArrayInt64::Multiply;
 196 %newobject MEDCoupling::DataArrayInt64::Divide;
 197 %newobject MEDCoupling::DataArrayInt64::Pow;
 198 %newobject MEDCoupling::DataArrayInt64::BuildUnion;
 199 %newobject MEDCoupling::DataArrayInt64::BuildIntersection;
 200 %newobject MEDCoupling::DataArrayInt64::Range;
 201 %newobject MEDCoupling::DataArrayInt64::indicesOfSubPart;
 202 %newobject MEDCoupling::DataArrayInt64::fromNoInterlace;
 203 %newobject MEDCoupling::DataArrayInt64::toNoInterlace;
 204 %newobject MEDCoupling::DataArrayInt64::buildComplement;
 205 %newobject MEDCoupling::DataArrayInt64::buildUnion;
 206 %newobject MEDCoupling::DataArrayInt64::buildSubstraction;
 207 %newobject MEDCoupling::DataArrayInt64::buildSubstractionOptimized;
 208 %newobject MEDCoupling::DataArrayInt64::buildIntersection;
 209 %newobject MEDCoupling::DataArrayInt64::indexOfSameConsecutiveValueGroups;
 210 %newobject MEDCoupling::DataArrayInt64::buildUnique;
 211 %newobject MEDCoupling::DataArrayInt64::buildUniqueNotSorted;
 212 %newobject MEDCoupling::DataArrayInt64::deltaShiftIndex;
 213 %newobject MEDCoupling::DataArrayInt64::buildExplicitArrByRanges;
 214 %newobject MEDCoupling::DataArrayInt64::buildExplicitArrOfSliceOnScaledArr;
 215 %newobject MEDCoupling::DataArrayInt64::findRangeIdForEachTuple;
 216 %newobject MEDCoupling::DataArrayInt64::findIdInRangeForEachTuple;
 217 %newobject MEDCoupling::DataArrayInt64::duplicateEachTupleNTimes;
 218 %newobject MEDCoupling::DataArrayInt64::occurenceRankInThis;
 219 %newobject MEDCoupling::DataArrayInt64::buildPermutationArr;
 220 %newobject MEDCoupling::DataArrayInt64::buildPermArrPerLevel;
 221 %newobject MEDCoupling::DataArrayInt64::getDifferentValues;
 222 %newobject MEDCoupling::DataArrayInt64::FindPermutationFromFirstToSecond;
 223 %newobject MEDCoupling::DataArrayInt64::FindPermutationFromFirstToSecondDuplicate;
 224 %newobject MEDCoupling::DataArrayInt64::CheckAndPreparePermutation;
 225 %newobject MEDCoupling::DataArrayInt64::__neg__;
 226 %newobject MEDCoupling::DataArrayInt64::__add__;
 227 %newobject MEDCoupling::DataArrayInt64::__radd__;
 228 %newobject MEDCoupling::DataArrayInt64::__sub__;
 229 %newobject MEDCoupling::DataArrayInt64::__rsub__;
 230 %newobject MEDCoupling::DataArrayInt64::__mul__;
 231 %newobject MEDCoupling::DataArrayInt64::__rmul__;
 232 %newobject MEDCoupling::DataArrayInt64::__div__;
 233 %newobject MEDCoupling::DataArrayInt64::__rdiv__;
 234 %newobject MEDCoupling::DataArrayInt64::__mod__;
 235 %newobject MEDCoupling::DataArrayInt64::__rmod__;
 236 %newobject MEDCoupling::DataArrayInt64::__pow__;
 237 %newobject MEDCoupling::DataArrayInt64::__rpow__;
 238 %newobject MEDCoupling::DataArrayInt64::convertToInt32Arr;
 239 %newobject MEDCoupling::DataArrayInt64Tuple::buildDAInt;
 240 %newobject MEDCoupling::DataArrayChar::convertToIntArr;
 241 %newobject MEDCoupling::DataArrayChar::renumber;
 242 %newobject MEDCoupling::DataArrayChar::renumberR;
 243 %newobject MEDCoupling::DataArrayChar::renumberAndReduce;
 244 %newobject MEDCoupling::DataArrayChar::changeNbOfComponents;
 245 %newobject MEDCoupling::DataArrayChar::findIdsEqual;
 246 %newobject MEDCoupling::DataArrayChar::findIdsNotEqual;
 247 %newobject MEDCoupling::DataArrayChar::Aggregate;
 248 %newobject MEDCoupling::DataArrayChar::Meld;
 249 %newobject MEDCoupling::DataArrayByte::New;
 250 %newobject MEDCoupling::DataArrayByte::__iter__;
 251 %newobject MEDCoupling::DataArrayByte::performCopyOrIncrRef;
 252 %newobject MEDCoupling::DataArrayByteTuple::buildDAByte;
 253 %newobject MEDCoupling::DataArrayChar::subArray;
 254 %newobject MEDCoupling::DataArrayAsciiChar::New;
 255 %newobject MEDCoupling::DataArrayAsciiChar::__iter__;
 256 %newobject MEDCoupling::DataArrayAsciiChar::performCopyOrIncrRef;
 257 %newobject MEDCoupling::DataArrayAsciiCharTuple::buildDAAsciiChar;
 258 %newobject MEDCoupling::DataArrayDouble::New;
 259 %newobject MEDCoupling::DataArrayDouble::__iter__;
 260 %newobject MEDCoupling::DataArrayDouble::performCopyOrIncrRef;
 261 %newobject MEDCoupling::DataArrayDouble::Aggregate;
 262 %newobject MEDCoupling::DataArrayDouble::Meld;
 263 %newobject MEDCoupling::DataArrayDouble::Dot;
 264 %newobject MEDCoupling::DataArrayDouble::CrossProduct;
 265 %newobject MEDCoupling::DataArrayDouble::Add;
 266 %newobject MEDCoupling::DataArrayDouble::Substract;
 267 %newobject MEDCoupling::DataArrayDouble::Multiply;
 268 %newobject MEDCoupling::DataArrayDouble::Divide;
 269 %newobject MEDCoupling::DataArrayDouble::Pow;
 270 %newobject MEDCoupling::DataArrayDouble::symmetry3DPlane;
 271 %newobject MEDCoupling::DataArrayDouble::subArray;
 272 %newobject MEDCoupling::DataArrayDouble::changeNbOfComponents;
 273 %newobject MEDCoupling::DataArrayDouble::accumulatePerChunck;
 274 %newobject MEDCoupling::DataArrayDouble::findIdsInRange;
 275 %newobject MEDCoupling::DataArrayDouble::findIdsNotInRange;
 276 %newobject MEDCoupling::DataArrayDouble::findIdsStrictlyNegative;
 277 %newobject MEDCoupling::DataArrayDouble::negate;
 278 %newobject MEDCoupling::DataArrayDouble::computeAbs;
 279 %newobject MEDCoupling::DataArrayDouble::applyFunc;
 280 %newobject MEDCoupling::DataArrayDouble::applyFuncCompo;
 281 %newobject MEDCoupling::DataArrayDouble::applyFuncNamedCompo;
 282 %newobject MEDCoupling::DataArrayDouble::doublyContractedProduct;
 283 %newobject MEDCoupling::DataArrayDouble::determinant;
 284 %newobject MEDCoupling::DataArrayDouble::eigenValues;
 285 %newobject MEDCoupling::DataArrayDouble::eigenVectors;
 286 %newobject MEDCoupling::DataArrayDouble::inverse;
 287 %newobject MEDCoupling::DataArrayDouble::trace;
 288 %newobject MEDCoupling::DataArrayDouble::deviator;
 289 %newobject MEDCoupling::DataArrayDouble::magnitude;
 290 %newobject MEDCoupling::DataArrayDouble::maxPerTuple;
 291 %newobject MEDCoupling::DataArrayDouble::sumPerTuple;
 292 %newobject MEDCoupling::DataArrayDouble::computeBBoxPerTuple;
 293 %newobject MEDCoupling::DataArrayDouble::buildEuclidianDistanceDenseMatrix;
 294 %newobject MEDCoupling::DataArrayDouble::buildEuclidianDistanceDenseMatrixWith;
 295 %newobject MEDCoupling::DataArrayDouble::renumber;
 296 %newobject MEDCoupling::DataArrayDouble::renumberR;
 297 %newobject MEDCoupling::DataArrayDouble::renumberAndReduce;
 298 %newobject MEDCoupling::DataArrayDouble::fromNoInterlace;
 299 %newobject MEDCoupling::DataArrayDouble::toNoInterlace;
 300 %newobject MEDCoupling::DataArrayDouble::fromPolarToCart;
 301 %newobject MEDCoupling::DataArrayDouble::fromCylToCart;
 302 %newobject MEDCoupling::DataArrayDouble::fromSpherToCart;
 303 %newobject MEDCoupling::DataArrayDouble::fromCartToPolar;
 304 %newobject MEDCoupling::DataArrayDouble::fromCartToCyl;
 305 %newobject MEDCoupling::DataArrayDouble::fromCartToSpher;
 306 %newobject MEDCoupling::DataArrayDouble::fromCartToCylGiven;
 307 %newobject MEDCoupling::DataArrayDouble::cartesianize;
 308 %newobject MEDCoupling::DataArrayDouble::getDifferentValues;
 309 %newobject MEDCoupling::DataArrayDouble::findClosestTupleId;
 310 %newobject MEDCoupling::DataArrayDouble::computeNbOfInteractionsWith;
 311 %newobject MEDCoupling::DataArrayDouble::duplicateEachTupleNTimes;
 312 %newobject MEDCoupling::DataArrayDouble::__neg__;
 313 %newobject MEDCoupling::DataArrayDouble::__radd__;
 314 %newobject MEDCoupling::DataArrayDouble::__rsub__;
 315 %newobject MEDCoupling::DataArrayDouble::__rmul__;
 316 %newobject MEDCoupling::DataArrayDouble::__rdiv__;
 317 %newobject MEDCoupling::DataArrayDouble::__pow__;
 318 %newobject MEDCoupling::DataArrayDouble::__rpow__;
 319 %newobject MEDCoupling::DataArrayDoubleTuple::buildDADouble;
 320
 321 %newobject MEDCoupling::PartDefinition::New;
 322 %newobject MEDCoupling::PartDefinition::toDAI;
 323 %newobject MEDCoupling::PartDefinition::__add__;
 324 %newobject MEDCoupling::PartDefinition::composeWith;
 325 %newobject MEDCoupling::PartDefinition::tryToSimplify;
 326 %newobject MEDCoupling::DataArrayPartDefinition::New;
 327 %newobject MEDCoupling::SlicePartDefinition::New;
 328
 329 %newobject FromPyIntPtrToDataArrayByte;
 330
 331
 332 %feature("unref") DataArray "$this->decrRef();"
 333 %feature("unref") DataArrayDouble "$this->decrRef();"
 334 %feature("unref") DataArrayInt32 "$this->decrRef();"
 335 %feature("unref") DataArrayInt64 "$this->decrRef();"
 336 %feature("unref") DataArrayChar "$this->decrRef();"
 337 %feature("unref") DataArrayAsciiChar "$this->decrRef();"
 338 %feature("unref") DataArrayByte "$this->decrRef();"
 339
 340 %feature("unref") MapII "$this->decrRef();"
 341 %feature("unref") PartDefinition "$this->decrRef();"
 342 %feature("unref") DataArrayPartDefinition "$this->decrRef();"
 343 %feature("unref") SlicePartDefinition "$this->decrRef();"
 344
 345 namespace MEDCoupling
 346 {
 347   typedef enum
 348     {
 349       AX_CART = 3,
 350       AX_CYL = 4,
 351       AX_SPHER = 5
 352     } MEDCouplingAxisType;
 353
 354   class DataArrayInt32;
 355   class DataArrayInt64;
 356
 357 #ifndef MEDCOUPLING_USE_64BIT_IDS
 358 typedef DataArrayInt32 DataArrayIdType;
 359 #define DataArrayIdType DataArrayInt32
 360 #else
 361 typedef DataArrayInt64 DataArrayIdType;
 362 #define DataArrayIdType DataArrayInt64
 363 #endif
 364
 365   class MapII : public RefCountObject, public TimeLabel
 366   {
 367   public:
 368     static MCAuto< MapII > New();
 369   };
 370
 371   class PartDefinition : public RefCountObject, public TimeLabel
 372   {
 373   public:
 374     static PartDefinition *New(int start, int stop, int step);
 375     static PartDefinition *New(DataArrayIdType *listOfIds);
 376     virtual DataArrayIdType *toDAI() const;
 377     virtual int getNumberOfElems() const;
 378     virtual std::string getRepr() const;
 379     virtual PartDefinition *composeWith(const PartDefinition *other) const;
 380     virtual void checkConsistencyLight() const;
 381     virtual PartDefinition *tryToSimplify() const;
 382     %extend
 383     {
 384       virtual PartDefinition *__add__(const PartDefinition& other) const
 385       {
 386         return (*self)+other;
 387       }
 388
 389       virtual PyObject *isEqual(const PartDefinition *other) const
 390       {
 391         std::string ret1;
 392         bool ret0(self->isEqual(other,ret1));
 393         PyObject *ret=PyTuple_New(2);
 394         PyObject *ret0Py=ret0?Py_True:Py_False;
 395         Py_XINCREF(ret0Py);
 396         PyTuple_SetItem(ret,0,ret0Py);
 397         PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
 398         return ret;
 399       }
 400
 401       virtual PyObject *deepCopy() const
 402       {
 403         return convertPartDefinition(self->deepCopy(),SWIG_POINTER_OWN | 0);
 404       }
 405     }
 406   protected:
 407     virtual ~PartDefinition();
 408   };
 409
 410   class DataArrayPartDefinition : public PartDefinition
 411   {
 412   public:
 413     static DataArrayPartDefinition *New(DataArrayIdType *listOfIds);
 414     %extend
 415     {
 416       DataArrayPartDefinition(DataArrayIdType *listOfIds)
 417       {
 418         return DataArrayPartDefinition::New(listOfIds);
 419       }
 420
 421       std::string __str__() const
 422       {
 423         return self->getRepr();
 424       }
 425
 426       std::string __repr__() const
 427       {
 428         std::ostringstream oss; oss << "DataArrayPartDefinition C++ instance at " << self << "." << std::endl;
 429         oss << self->getRepr();
 430         return oss.str();
 431       }
 432     }
 433   protected:
 434     virtual ~DataArrayPartDefinition();
 435   };
 436
 437   class SlicePartDefinition : public PartDefinition
 438   {
 439   public:
 440     static SlicePartDefinition *New(int start, int stop, int step);
 441     int getEffectiveStop() const;
 442     %extend
 443     {
 444       SlicePartDefinition(mcIdType start, mcIdType stop, mcIdType step)
 445       {
 446         return SlicePartDefinition::New(start,stop,step);
 447       }
 448
 449       PyObject *getSlice() const
 450       {
 451         mcIdType a,b,c;
 452         self->getSlice(a,b,c);
 453         return PySlice_New(PyInt_FromLong(a),PyInt_FromLong(b),PyInt_FromLong(c));
 454       }
 455
 456       std::string __str__() const
 457       {
 458         return self->getRepr();
 459       }
 460
 461       std::string __repr__() const
 462       {
 463         std::ostringstream oss; oss << "SlicePartDefinition C++ instance at " << self << "." << std::endl;
 464         oss << self->getRepr();
 465         return oss.str();
 466       }
 467     }
 468   protected:
 469     virtual ~SlicePartDefinition();
 470   };
 471
 472   class DataArray : public RefCountObject, public TimeLabel
 473   {
 474   public:
 475     void setName(const std::string& name);
 476     void copyStringInfoFrom(const DataArray& other);
 477     void copyPartOfStringInfoFrom(const DataArray& other, const std::vector<std::size_t>& compoIds);
 478     void copyPartOfStringInfoFrom2(const std::vector<std::size_t>& compoIds, const DataArray& other);
 479     bool areInfoEqualsIfNotWhy(const DataArray& other, std::string& reason) const;
 480     bool areInfoEquals(const DataArray& other) const;
 481     std::string cppRepr(const std::string& varName) const;
 482     std::string getName() const;
 483     void setInfoOnComponents(const std::vector<std::string>& info);
 484     void setInfoAndChangeNbOfCompo(const std::vector<std::string>& info);
 485     std::vector<std::string> getVarsOnComponent() const;
 486     std::vector<std::string> getUnitsOnComponent() const;
 487     std::string getInfoOnComponent(int i) const;
 488     std::string getVarOnComponent(int i) const;
 489     std::string getUnitOnComponent(int i) const;
 490     void setInfoOnComponent(int i, const std::string& info);
 491     int getNumberOfComponents() const;
 492     virtual void alloc(int nbOfTuple, int nbOfCompo=1);
 493     virtual void reAlloc(int nbOfTuples);
 494     virtual bool isAllocated() const;
 495     virtual void checkAllocated() const;
 496     virtual void desallocate();
 497     virtual int getNumberOfTuples() const;
 498     virtual std::size_t getNbOfElems() const;
 499     virtual std::size_t getNbOfElemAllocated() const;
 500     virtual DataArray *deepCopy() const;
 501     virtual DataArray *copySorted() const;
 502     virtual DataArray *buildNewEmptyInstance() const;
 503     virtual DataArray *selectByTupleIdSafeSlice(int bg, int end2, int step) const;
 504     virtual void rearrange(int newNbOfCompo);
 505     virtual void circularPermutation(int nbOfShift=1);
 506     virtual void circularPermutationPerTuple(int nbOfShift=1);
 507     virtual void reversePerTuple();
 508     void checkNbOfTuples(int nbOfTuples, const std::string& msg) const;
 509     void checkNbOfComps(int nbOfCompo, const std::string& msg) const;
 510     void checkNbOfTuplesAndComp(const DataArray& other, const std::string& msg) const;
 511     void checkNbOfTuplesAndComp(int nbOfTuples, int nbOfCompo, const std::string& msg) const;
 512     void checkNbOfElems(mcIdType nbOfElems, const std::string& msg) const;
 513     static int GetNumberOfItemGivenBES(int begin, int end, int step, const std::string& msg);
 514     static int GetNumberOfItemGivenBESRelative(int begin, int end, int step, const std::string& msg);
 515     static int GetPosOfItemGivenBESRelativeNoThrow(int value, int begin, int end, int step);
 516     static std::string GetVarNameFromInfo(const std::string& info);
 517     static std::string GetUnitFromInfo(const std::string& info);
 518     static std::string BuildInfoFromVarAndUnit(const std::string& var, const std::string& unit);
 519     static std::string GetAxisTypeRepr(MEDCouplingAxisType at);
 520     void updateTime() const;
 521     %extend
 522     {
 523       PyObject *getInfoOnComponents() const
 524       {
 525         const std::vector<std::string>& comps=self->getInfoOnComponents();
 526         PyObject *ret=PyList_New((mcIdType)comps.size());
 527         for(std::size_t i=0;i<comps.size();i++)
 528           PyList_SetItem(ret,i,PyString_FromString(comps[i].c_str()));
 529         return ret;
 530       }
 531
 532       void copyPartOfStringInfoFrom(const DataArray& other, PyObject *li)
 533       {
 534         std::vector<std::size_t> tmp;
 535         convertPyToNewIntArr3(li,tmp);
 536         self->copyPartOfStringInfoFrom(other,tmp);
 537       }
 538
 539       void copyPartOfStringInfoFrom2(PyObject *li, const DataArray& other)
 540       {
 541         std::vector<std::size_t> tmp;
 542         convertPyToNewIntArr3(li,tmp);
 543         self->copyPartOfStringInfoFrom2(tmp,other);
 544       }
 545
 546       virtual void renumberInPlace(PyObject *li)
 547       {
 548         void *da=0;
 549         int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 |  0 );
 550         if (!SWIG_IsOK(res1))
 551           {
 552             mcIdType size;
 553             INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
 554             if(size!=self->getNumberOfTuples())
 555               {
 556                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
 557               }
 558             self->renumberInPlace(tmp);
 559           }
 560         else
 561           {
 562             DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
 563             if(!da2)
 564               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
 565             da2->checkAllocated();
 566             mcIdType size=self->getNumberOfTuples();
 567             if(size!=self->getNumberOfTuples())
 568               {
 569                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
 570               }
 571             self->renumberInPlace(da2->getConstPointer());
 572           }
 573       }
 574
 575       virtual void renumberInPlaceR(PyObject *li)
 576       {
 577         void *da=0;
 578         int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 |  0 );
 579         if (!SWIG_IsOK(res1))
 580           {
 581             mcIdType size;
 582             INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
 583             if(size!=self->getNumberOfTuples())
 584               {
 585                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
 586               }
 587             self->renumberInPlaceR(tmp);
 588           }
 589         else
 590           {
 591             DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
 592             if(!da2)
 593               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
 594             da2->checkAllocated();
 595             mcIdType size=self->getNumberOfTuples();
 596             if(size!=self->getNumberOfTuples())
 597               {
 598                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
 599               }
 600             self->renumberInPlaceR(da2->getConstPointer());
 601           }
 602       }
 603
 604       //tuplesSelec in PyObject * because DataArrayInt is not already existing !
 605       virtual void setContigPartOfSelectedValues(mcIdType tupleIdStart, PyObject *aBase, PyObject *tuplesSelec)
 606       {
 607         static const char msg[]="DataArray::setContigPartOfSelectedValuesSlice : 4th parameter \"tuplesSelec\" should be of type DataArrayInt";
 608           DataArray *a=CheckAndRetrieveDataArrayInstance(aBase,"DataArray::setContigPartOfSelectedValuesSlice : 3rd parameter \"aBase\" should be of type DataArray");
 609         DataArray *tuplesSelecPtr=CheckAndRetrieveDataArrayInstance(tuplesSelec,msg);
 610         DataArrayIdType *tuplesSelecPtr2=0;
 611         if(tuplesSelecPtr)
 612           {
 613             tuplesSelecPtr2=dynamic_cast<DataArrayIdType *>(tuplesSelecPtr);
 614             if(!tuplesSelecPtr2)
 615               throw INTERP_KERNEL::Exception(msg);
 616           }
 617         self->setContigPartOfSelectedValues(tupleIdStart,a,tuplesSelecPtr2);
 618       }
 619
 620       virtual void setContigPartOfSelectedValuesSlice(mcIdType tupleIdStart, PyObject *aBase, mcIdType bg, mcIdType end2, mcIdType step)
 621       {
 622         DataArray *a=CheckAndRetrieveDataArrayInstance(aBase,"DataArray::setContigPartOfSelectedValuesSlice : 2nd parameter \"aBase\" should be of type DataArray");
 623         self->setContigPartOfSelectedValuesSlice(tupleIdStart,a,bg,end2,step);
 624       }
 625
 626       virtual DataArray *selectByTupleRanges(PyObject *li) const
 627       {
 628         std::vector<std::pair<mcIdType,mcIdType> > ranges;
 629         convertPyToVectorPairInt(li,ranges);
 630         return self->selectByTupleRanges(ranges);
 631       }
 632
 633       virtual DataArray *selectByTupleId(PyObject *li) const
 634       {
 635         void *da=0;
 636         int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 |  0 );
 637         if (!SWIG_IsOK(res1))
 638           {
 639             mcIdType size;
 640             INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
 641             return self->selectByTupleId(tmp,tmp+size);
 642           }
 643         else
 644           {
 645             DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
 646             if(!da2)
 647               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
 648             da2->checkAllocated();
 649             return self->selectByTupleId(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
 650           }
 651       }
 652
 653       virtual DataArray *selectByTupleIdSafe(PyObject *li) const
 654       {
 655         void *da=0;
 656         int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 |  0 );
 657         if (!SWIG_IsOK(res1))
 658           {
 659             mcIdType size;
 660             INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
 661             return self->selectByTupleIdSafe(tmp,tmp+size);
 662           }
 663         else
 664           {
 665             DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
 666             if(!da2)
 667               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
 668             da2->checkAllocated();
 669             return self->selectByTupleIdSafe(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
 670           }
 671       }
 672
 673       virtual PyObject *keepSelectedComponents(PyObject *li) const
 674       {
 675         std::vector<std::size_t> tmp;
 676         convertPyToNewIntArr3(li,tmp);
 677         DataArray *ret=self->keepSelectedComponents(tmp);
 678         return convertDataArray(ret,SWIG_POINTER_OWN | 0 );
 679       }
 680
 681       static PyObject *GetSlice(PyObject *slic, mcIdType sliceId, mcIdType nbOfSlices)
 682       {
 683         if(!PySlice_Check(slic))
 684           throw INTERP_KERNEL::Exception("DataArray::GetSlice (wrap) : expecting a pyslice as second (first) parameter !");
 685         Py_ssize_t strt=2,stp=2,step=2;
 686         GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetSlice (wrap) : the input slice is invalid !");
 687         mcIdType a,b;
 688         DataArray::GetSlice(ToIdType(strt),ToIdType(stp),ToIdType(step),sliceId,nbOfSlices,a,b);
 689         AutoPyPtr ap(PyInt_FromLong(a)),bp(PyInt_FromLong(b)),stepp(PyInt_FromLong(step));
 690         return PySlice_New(ap,bp,stepp);
 691       }
 692
 693       PyObject *getSlice(PyObject *slic, mcIdType sliceId, mcIdType nbOfSlices) const
 694       {
 695         if(!PySlice_Check(slic))
 696           throw INTERP_KERNEL::Exception("DataArray::getSlice (wrap) : expecting a pyslice as second (first) parameter !");
 697         Py_ssize_t strt=2,stp=2,step=2;
 698         GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getSlice (wrap) : the input slice is invalid !");
 699         mcIdType a,b;
 700         DataArray::GetSlice(ToIdType(strt),ToIdType(stp),ToIdType(step),sliceId,nbOfSlices,a,b);
 701         AutoPyPtr ap(PyInt_FromLong(a)),bp(PyInt_FromLong(b)),stepp(PyInt_FromLong(step));
 702         return PySlice_New(ap,bp,stepp);
 703       }
 704
 705       static mcIdType GetNumberOfItemGivenBES(PyObject *slic)
 706       {
 707         if(!PySlice_Check(slic))
 708           throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBES (wrap) : expecting a pyslice as second (first) parameter !");
 709         Py_ssize_t strt=2,stp=2,step=2;
 710         GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetNumberOfItemGivenBES (wrap) : the input slice is invalid !");
 711         return DataArray::GetNumberOfItemGivenBES(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
 712       }
 713
 714       static mcIdType GetNumberOfItemGivenBESRelative(PyObject *slic)
 715       {
 716         if(!PySlice_Check(slic))
 717           throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBESRelative (wrap) : expecting a pyslice as second (first) parameter !");
 718         Py_ssize_t strt=2,stp=2,step=2;
 719         GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !");
 720         return DataArray::GetNumberOfItemGivenBESRelative(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
 721       }
 722
 723       static DataArray *Aggregate(PyObject *arrs)
 724       {
 725         std::vector<const DataArray *> tmp;
 726         convertFromPyObjVectorOfObj<const MEDCoupling::DataArray *>(arrs,SWIGTYPE_p_MEDCoupling__DataArray,"DataArray",tmp);
 727         return DataArray::Aggregate(tmp);
 728       }
 729
 730       mcIdType getNumberOfItemGivenBES(PyObject *slic) const
 731       {
 732         if(!PySlice_Check(slic))
 733           throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBES (wrap) : expecting a pyslice as second (first) parameter !");
 734         Py_ssize_t strt=2,stp=2,step=2;
 735         GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getNumberOfItemGivenBES (wrap) : the input slice is invalid !");
 736         return DataArray::GetNumberOfItemGivenBES(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
 737       }
 738
 739       mcIdType getNumberOfItemGivenBESRelative(PyObject *slic)
 740       {
 741         if(!PySlice_Check(slic))
 742           throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBESRelative (wrap) : expecting a pyslice as second (first) parameter !");
 743         Py_ssize_t strt=2,stp=2,step=2;
 744         GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !");
 745         return DataArray::GetNumberOfItemGivenBESRelative(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
 746       }
 747
 748       PyObject *__getstate__() const
 749       {
 750         PyObject *ret(PyTuple_New(2));
 751         std::string a0(self->getName());
 752         const std::vector<std::string> &a1(self->getInfoOnComponents());
 753         PyTuple_SetItem(ret,0,PyString_FromString(a0.c_str()));
 754         //
 755         std::size_t sz(a1.size());
 756         PyObject *ret1(PyList_New(sz));
 757         for(std::size_t i=0;i<sz;i++)
 758           PyList_SetItem(ret1,i,PyString_FromString(a1[i].c_str()));
 759         PyTuple_SetItem(ret,1,ret1);
 760         //
 761         return ret;
 762       }
 763
 764       void __setstate__(PyObject *inp)
 765       {
 766         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 !";
 767         if(!PyTuple_Check(inp))
 768           throw INTERP_KERNEL::Exception("DataArrayDouble.__setstate__ : invalid input ! Invalid overwrite of __getstate__ ?");
 769         std::size_t sz(PyTuple_Size(inp));
 770         if(sz!=2)
 771           throw INTERP_KERNEL::Exception("DataArrayDouble.__setstate__ : invalid tuple in input ! Should be of size 2 ! Invalid overwrite of __getstate__ ?");
 772         PyObject *a0(PyTuple_GetItem(inp,0));
 773         self->setName(convertPyObjectToStr(a0,MSG));
 774         PyObject *a1(PyTuple_GetItem(inp,1));
 775         std::vector<std::string> a1cpp;
 776         if(!fillStringVector(a1,a1cpp))
 777           throw INTERP_KERNEL::Exception(MSG);
 778         self->setInfoOnComponents(a1cpp);
 779       }
 780     }
 781   };
 782
 783   class DataArrayDouble;
 784
 785   class DataArrayFloat : public DataArray
 786   {
 787   public:
 788     static DataArrayFloat *New();
 789     void fillWithValue(float val);
 790     bool isEqual(const DataArrayFloat& other, float prec) const;
 791     bool isEqualWithoutConsideringStr(const DataArrayFloat& other, float prec) const;
 792     bool isUniform(float val, float eps) const;
 793     void pushBackSilent(float val);
 794     void iota(float init=0.);
 795     DataArrayFloatIterator *iterator();
 796     MCAuto<DataArrayDouble> convertToDblArr() const;
 797     static DataArrayFloat *Meld(const DataArrayFloat *a1, const DataArrayFloat *a2);
 798     %extend
 799     {
 800       DataArrayFloat()
 801       {
 802         return DataArrayFloat::New();
 803       }
 804
 805       static DataArrayFloat *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
 806       {
 807         return DataArrayT_New<float>(elt0,nbOfTuples,elt2);
 808       }
 809
 810       DataArrayFloat(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
 811       {
 812         return MEDCoupling_DataArrayFloat_New__SWIG_1(elt0,nbOfTuples,elt2);
 813       }
 814
 815       DataArrayFloatIterator *__iter__()
 816       {
 817         return self->iterator();
 818       }
 819
 820       std::string __repr__() const
 821       {
 822         std::ostringstream oss;
 823         self->reprQuickOverview(oss);
 824         return oss.str();
 825       }
 826
 827       std::string __str__() const
 828       {
 829         return self->reprNotTooLong();
 830       }
 831
 832       mcIdType __len__() const
 833       {
 834         if(self->isAllocated())
 835           {
 836             return self->getNumberOfTuples();
 837           }
 838         else
 839           {
 840             throw INTERP_KERNEL::Exception("DataArrayFloat::__len__ : Instance is NOT allocated !");
 841           }
 842       }
 843
 844       PyObject *getValues() const
 845       {
 846         const float *vals(self->begin());
 847         return convertDblArrToPyList<float>(vals,self->getNbOfElems());
 848       }
 849
 850       PyObject *getValuesAsTuple() const
 851       {
 852         const float *vals(self->begin());
 853         std::size_t nbOfComp(self->getNumberOfComponents());
 854         mcIdType nbOfTuples(self->getNumberOfTuples());
 855         return convertDblArrToPyListOfTuple<float>(vals,nbOfComp,nbOfTuples);
 856       }
 857
 858       PyObject *isEqualIfNotWhy(const DataArrayFloat& other, float prec) const
 859       {
 860         std::string ret1;
 861         bool ret0=self->isEqualIfNotWhy(other,prec,ret1);
 862         PyObject *ret=PyTuple_New(2);
 863         PyObject *ret0Py=ret0?Py_True:Py_False;
 864         Py_XINCREF(ret0Py);
 865         PyTuple_SetItem(ret,0,ret0Py);
 866         PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
 867         return ret;
 868       }
 869
 870       PyObject *__getitem__(PyObject *obj)
 871       {
 872         return DataArrayT__getitem<float>(self,obj);
 873       }
 874
 875       DataArrayFloat *__setitem__(PyObject *obj, PyObject *value)
 876       {
 877         return DataArrayT__setitem__<float>(self,obj,value);
 878       }
 879
 880       PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
 881       {
 882         return DataArrayT_iadd<float>(trueSelf,obj,self);
 883       }
 884
 885       PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
 886       {
 887         return DataArrayT_isub<float>(trueSelf,obj,self);
 888       }
 889
 890       PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
 891       {
 892         return DataArrayT_imul<float>(trueSelf,obj,self);
 893       }
 894
 895       DataArrayFloat *__rmul__(PyObject *obj)
 896       {
 897         return DataArrayFPT_rmul<float>(self,obj);
 898       }
 899
 900       PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
 901       {
 902         return DataArrayT_idiv<float>(trueSelf,obj,self);
 903       }
 904
 905 #ifdef WITH_NUMPY
 906       PyObject *toNumPyArray() // not const. It is not a bug !
 907       {
 908         return ToNumPyArray<DataArrayFloat,float>(self,NPY_FLOAT,"DataArrayFloat");
 909       }
 910 #endif
 911     }
 912   };
 913
 914   class DataArrayFloatTuple;
 915
 916   class DataArrayFloatIterator
 917   {
 918   public:
 919     DataArrayFloatIterator(DataArrayFloat *da);
 920     ~DataArrayFloatIterator();
 921     %extend
 922     {
 923       PyObject *next()
 924       {
 925         DataArrayFloatTuple *ret=self->nextt();
 926         if(ret)
 927           return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayFloatTuple,SWIG_POINTER_OWN|0);
 928         else
 929           {
 930             PyErr_SetString(PyExc_StopIteration,"No more data.");
 931             return 0;
 932           }
 933       }
 934     }
 935   };
 936
 937   class DataArrayFloatTuple
 938   {
 939   public:
 940     std::size_t getNumberOfCompo() const;
 941     DataArrayFloat *buildDAFloat(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
 942     %extend
 943     {
 944       std::string __str__() const
 945       {
 946         return self->repr();
 947       }
 948
 949       float __float__() const
 950       {
 951         return self->floatValue();
 952       }
 953
 954       DataArrayFloat *buildDAFloat()
 955       {
 956         return self->buildDAFloat(1,self->getNumberOfCompo());
 957       }
 958
 959       /*PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
 960       {
 961         MCAuto<DataArrayFloat> ret=self->buildDAFloat(1,self->getNumberOfCompo());
 962         MEDCoupling_DataArrayFloat____imul___(ret,0,obj);
 963         Py_XINCREF(trueSelf);
 964         return trueSelf;
 965         }*/
 966
 967       PyObject *__len__()
 968       {
 969         return PyInt_FromLong(self->getNumberOfCompo());
 970       }
 971     }
 972   };
 973
 974   class DataArrayDoubleIterator;
 975
 976   class DataArrayDouble : public DataArray
 977   {
 978   public:
 979     static DataArrayDouble *New();
 980     double doubleValue() const;
 981     bool empty() const;
 982     void aggregate(const DataArrayDouble *other);
 983     DataArrayDouble *performCopyOrIncrRef(bool deepCopy) const;
 984     void deepCopyFrom(const DataArrayDouble& other);
 985     void reserve(std::size_t nbOfElems);
 986     void pushBackSilent(double val);
 987     double popBackSilent();
 988     void pack() const;
 989     void allocIfNecessary(int nbOfTuple, int nbOfCompo);
 990     void fillWithZero();
 991     void fillWithValue(double val);
 992     void iota(double init=0.);
 993     bool isUniform(double val, double eps) const;
 994     void sort(bool asc=true);
 995     void reverse();
 996     void checkMonotonic(bool increasing, double eps) const;
 997     bool isMonotonic(bool increasing, double eps) const;
 998     std::string repr() const;
 999     std::string reprZip() const;
1000     std::string reprNotTooLong() const;
1001     bool isEqual(const DataArrayDouble& other, double prec) const;
1002     bool isEqualWithoutConsideringStr(const DataArrayDouble& other, double prec) const;
1003     DataArrayDouble *fromNoInterlace() const;
1004     DataArrayDouble *toNoInterlace() const;
1005     DataArrayDouble *subArray(int tupleIdBg, int tupleIdEnd=-1) const;
1006     void transpose();
1007     DataArrayDouble *changeNbOfComponents(std::size_t newNbOfComp, double dftValue) const;
1008     void meldWith(const DataArrayDouble *other);
1009     DataArrayDouble *duplicateEachTupleNTimes(int nbTimes) const;
1010     DataArrayDouble *getDifferentValues(double prec, int limitTupleId=-1) const;
1011     DataArrayIdType *findClosestTupleId(const DataArrayDouble *other) const;
1012     DataArrayIdType *computeNbOfInteractionsWith(const DataArrayDouble *otherBBoxFrmt, double eps) const;
1013     void setPartOfValues1(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare=true);
1014     void setPartOfValuesSimple1(double a, mcIdType bgTuples, mcIdType endTuples, mcIdType stepTuples, mcIdType bgComp, mcIdType endComp, mcIdType stepComp);
1015     void setPartOfValuesAdv(const DataArrayDouble *a, const DataArrayIdType *tuplesSelec);
1016     double getIJ(int tupleId, int compoId) const;
1017     double front() const;
1018     double back() const;
1019     double getIJSafe(int tupleId, int compoId) const;
1020     void setIJ(int tupleId, int compoId, double newVal);
1021     void setIJSilent(int tupleId, int compoId, double newVal);
1022     double *getPointer();
1023     void checkNoNullValues() const;
1024     DataArrayDouble *computeBBoxPerTuple(double epsilon=0.0) const;
1025     void recenterForMaxPrecision(double eps);
1026     double getMaxValueInArray() const;
1027     double getMaxAbsValueInArray() const;
1028     double getMinValueInArray() const;
1029     int count(double value, double eps) const;
1030     double getAverageValue() const;
1031     double norm2() const;
1032     double normMax() const;
1033     double normMin() const;
1034     double accumulate(int compId) const;
1035     DataArrayDouble *fromPolarToCart() const;
1036     DataArrayDouble *fromCylToCart() const;
1037     DataArrayDouble *fromSpherToCart() const;
1038     DataArrayDouble *fromCartToPolar() const;
1039     DataArrayDouble *fromCartToCyl() const;
1040     DataArrayDouble *fromCartToSpher() const;
1041     DataArrayDouble *cartesianize(MEDCouplingAxisType atOfThis) const;
1042     DataArrayDouble *doublyContractedProduct() const;
1043     DataArrayDouble *determinant() const;
1044     DataArrayDouble *eigenValues() const;
1045     DataArrayDouble *eigenVectors() const;
1046     DataArrayDouble *inverse() const;
1047     DataArrayDouble *trace() const;
1048     DataArrayDouble *deviator() const;
1049     DataArrayDouble *magnitude() const;
1050     DataArrayDouble *maxPerTuple() const;
1051     DataArrayDouble *sumPerTuple() const;
1052     DataArrayDouble *buildEuclidianDistanceDenseMatrix() const;
1053     DataArrayDouble *buildEuclidianDistanceDenseMatrixWith(const DataArrayDouble *other) const;
1054     void sortPerTuple(bool asc);
1055     void abs();
1056     DataArrayDouble *computeAbs() const;
1057     void applyLin(double a, double b, int compoId);
1058     void applyLin(double a, double b);
1059     void applyInv(double numerator);
1060     void applyPow(double val);
1061     void applyRPow(double val);
1062     DataArrayDouble *negate() const;
1063     DataArrayDouble *applyFunc(int nbOfComp, FunctionToEvaluate func) const;
1064     DataArrayDouble *applyFunc(int nbOfComp, const std::string& func, bool isSafe=true) const;
1065     DataArrayDouble *applyFunc(const std::string& func, bool isSafe=true) const;
1066     void applyFuncOnThis(const std::string& func, bool isSafe=true);
1067     DataArrayDouble *applyFuncCompo(int nbOfComp, const std::string& func, bool isSafe=true) const;
1068     DataArrayDouble *applyFuncNamedCompo(int nbOfComp, const std::vector<std::string>& varsOrder, const std::string& func, bool isSafe=true) const;
1069     void applyFuncFast32(const std::string& func);
1070     void applyFuncFast64(const std::string& func);
1071     DataArrayIdType *findIdsInRange(double vmin, double vmax) const;
1072     DataArrayIdType *findIdsNotInRange(double vmin, double vmax) const;
1073     DataArrayIdType *findIdsStrictlyNegative() const;
1074     static DataArrayDouble *Aggregate(const DataArrayDouble *a1, const DataArrayDouble *a2);
1075     static DataArrayDouble *Meld(const DataArrayDouble *a1, const DataArrayDouble *a2);
1076     static DataArrayDouble *Dot(const DataArrayDouble *a1, const DataArrayDouble *a2);
1077     static DataArrayDouble *CrossProduct(const DataArrayDouble *a1, const DataArrayDouble *a2);
1078     static DataArrayDouble *Max(const DataArrayDouble *a1, const DataArrayDouble *a2);
1079     static DataArrayDouble *Min(const DataArrayDouble *a1, const DataArrayDouble *a2);
1080     static DataArrayDouble *Add(const DataArrayDouble *a1, const DataArrayDouble *a2);
1081     void addEqual(const DataArrayDouble *other);
1082     static DataArrayDouble *Substract(const DataArrayDouble *a1, const DataArrayDouble *a2);
1083     void substractEqual(const DataArrayDouble *other);
1084     static DataArrayDouble *Multiply(const DataArrayDouble *a1, const DataArrayDouble *a2);
1085     void multiplyEqual(const DataArrayDouble *other);
1086     static DataArrayDouble *Divide(const DataArrayDouble *a1, const DataArrayDouble *a2);
1087     void divideEqual(const DataArrayDouble *other);
1088     static DataArrayDouble *Pow(const DataArrayDouble *a1, const DataArrayDouble *a2);
1089     void powEqual(const DataArrayDouble *other);
1090     MCAuto<DataArrayIdType> findIdsGreaterOrEqualTo(double val) const;
1091     MCAuto<DataArrayIdType> findIdsGreaterThan(double val) const;
1092     MCAuto<DataArrayIdType> findIdsLowerOrEqualTo(double val) const;
1093     MCAuto<DataArrayIdType> findIdsLowerThan(double val) const;
1094     MCAuto<DataArrayInt32> convertToIntArr() const;
1095     MCAuto<DataArrayDouble> selectPartDef(const PartDefinition* pd) const;
1096     MCAuto<DataArrayDouble> cumSum() const;
1097     MCAuto<DataArrayFloat> convertToFloatArr() const;
1098     %extend
1099     {
1100       DataArrayDouble()
1101       {
1102         return DataArrayDouble::New();
1103       }
1104
1105       static DataArrayDouble *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
1106       {
1107         return DataArrayT_New<double>(elt0,nbOfTuples,elt2);
1108       }
1109
1110       DataArrayDouble(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
1111       {
1112         return MEDCoupling_DataArrayDouble_New__SWIG_1(elt0,nbOfTuples,elt2);
1113       }
1114
1115       void pushBackValsSilent(PyObject *li)
1116       {
1117         double val;
1118         std::vector<double> bb;
1119         mcIdType sw; mcIdType nbTuples=-1;
1120         const char msg[]="Python wrap of DataArrayDouble::pushBackValsSilent : ";
1121         const double *tmp=convertObjToPossibleCpp5_SingleCompo(li,sw,val,bb,msg,true,nbTuples);
1122         self->pushBackValsSilent(tmp,tmp+nbTuples);
1123       }
1124
1125       std::string __repr__() const
1126       {
1127         std::ostringstream oss;
1128         self->reprQuickOverview(oss);
1129         return oss.str();
1130       }
1131
1132       std::string __str__() const
1133       {
1134         return self->reprNotTooLong();
1135       }
1136
1137       double __float__() const
1138       {
1139         return self->doubleValue();
1140       }
1141
1142       mcIdType __len__() const
1143       {
1144         if(self->isAllocated())
1145           {
1146             return self->getNumberOfTuples();
1147           }
1148         else
1149           {
1150             throw INTERP_KERNEL::Exception("DataArrayDouble::__len__ : Instance is NOT allocated !");
1151           }
1152       }
1153
1154       PyObject *asArcOfCircle() const
1155       {
1156         double center[2],radius,ang;
1157         self->asArcOfCircle(center,radius,ang);
1158         PyObject *ret(PyTuple_New(3));
1159         {
1160           PyObject *ret0(PyList_New(2));
1161           PyList_SetItem(ret0,0,PyFloat_FromDouble(center[0]));
1162           PyList_SetItem(ret0,1,PyFloat_FromDouble(center[1]));
1163           PyTuple_SetItem(ret,0,ret0);
1164         }
1165         PyTuple_SetItem(ret,1,PyFloat_FromDouble(radius));
1166         PyTuple_SetItem(ret,2,PyFloat_FromDouble(ang));
1167         return ret;
1168       }
1169
1170       DataArrayDoubleIterator *__iter__()
1171       {
1172         return self->iterator();
1173       }
1174
1175       void setValues(PyObject *li, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
1176       {
1177         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 !";
1178         if(PyList_Check(li) || PyTuple_Check(li))
1179           {
1180             if(nbOfTuples && nbOfTuples != Py_None)
1181               {
1182                 if(PyInt_Check(nbOfTuples))
1183                   {
1184                     mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
1185                     if(nbOfTuples1<0)
1186                       throw INTERP_KERNEL::Exception("DataArrayDouble::setValues : should be a positive set of allocated memory !");
1187                     if(nbOfComp && nbOfComp != Py_None)
1188                       {
1189                         if(PyInt_Check(nbOfComp))
1190                           {//DataArrayDouble.setValues([1.,3.,4.,5.],2,2)
1191                             mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
1192                             if(nbOfCompo<0)
1193                               throw INTERP_KERNEL::Exception("DataArrayDouble::setValues : should be a positive number of components !");
1194                             std::vector<double> tmp=fillArrayWithPyListDbl2(li,nbOfTuples1,nbOfCompo);
1195                             self->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1196                           }
1197                         else
1198                           throw INTERP_KERNEL::Exception(msg);
1199                       }
1200                     else
1201                       {//DataArrayDouble.setValues([1.,3.,4.],3)
1202                         mcIdType tmpp1=-1;
1203                         std::vector<double> tmp=fillArrayWithPyListDbl2(li,nbOfTuples1,tmpp1);
1204                         self->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1205                       }
1206                   }
1207                 else
1208                   throw INTERP_KERNEL::Exception(msg);
1209               }
1210             else
1211               {// DataArrayDouble.setValues([1.,3.,4.])
1212                 mcIdType tmpp1=-1,tmpp2=-1;
1213                 std::vector<double> tmp=fillArrayWithPyListDbl2(li,tmpp1,tmpp2);
1214                 self->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1215               }
1216           }
1217         else
1218           throw INTERP_KERNEL::Exception(msg);
1219       }
1220
1221       PyObject *getValues() const
1222       {
1223         const double *vals(self->begin());
1224         return convertDblArrToPyList<double>(vals,self->getNbOfElems());
1225       }
1226
1227 #ifdef WITH_NUMPY
1228       PyObject *toNumPyArray() // not const. It is not a bug !
1229       {
1230         return ToNumPyArray<DataArrayDouble,double>(self,NPY_DOUBLE,"DataArrayDouble");
1231       }
1232 #endif
1233
1234       PyObject *isEqualIfNotWhy(const DataArrayDouble& other, double prec) const
1235       {
1236         std::string ret1;
1237         bool ret0=self->isEqualIfNotWhy(other,prec,ret1);
1238         PyObject *ret=PyTuple_New(2);
1239         PyObject *ret0Py=ret0?Py_True:Py_False;
1240         Py_XINCREF(ret0Py);
1241         PyTuple_SetItem(ret,0,ret0Py);
1242         PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
1243         return ret;
1244       }
1245
1246       PyObject *getValuesAsTuple() const
1247       {
1248         const double *vals(self->begin());
1249         std::size_t nbOfComp(self->getNumberOfComponents());
1250         mcIdType nbOfTuples(self->getNumberOfTuples());
1251         return convertDblArrToPyListOfTuple<double>(vals,nbOfComp,nbOfTuples);
1252       }
1253
1254       static PyObject *ComputeIntegralOfSeg2IntoTri3(PyObject *seg2, PyObject *tri3)
1255       {
1256         const char msg[]="Python wrap of DataArrayDouble::ComputeIntegralOfSeg2IntoTri3 : ";
1257         double val,val2;
1258         DataArrayDouble *a,*a2;
1259         DataArrayDoubleTuple *aa,*aa2;
1260         std::vector<double> bb,bb2;
1261         mcIdType sw;
1262         const double *seg2Ptr(convertObjToPossibleCpp5_Safe(seg2,sw,val,a,aa,bb,msg,2,2,true));
1263         const double *tri3Ptr(convertObjToPossibleCpp5_Safe(tri3,sw,val2,a2,aa2,bb2,msg,3,2,true));
1264         //
1265         double res0[3],res1;
1266         DataArrayDouble::ComputeIntegralOfSeg2IntoTri3(seg2Ptr,tri3Ptr,res0,res1);
1267         PyObject *ret(PyTuple_New(2)),*ret0(PyTuple_New(3));
1268         PyTuple_SetItem(ret0,0,PyFloat_FromDouble(res0[0]));
1269         PyTuple_SetItem(ret0,1,PyFloat_FromDouble(res0[1]));
1270         PyTuple_SetItem(ret0,2,PyFloat_FromDouble(res0[2]));
1271         PyTuple_SetItem(ret,0,ret0);
1272         PyTuple_SetItem(ret,1,PyFloat_FromDouble(res1));
1273         return ret;
1274       }
1275
1276       DataArrayDouble *symmetry3DPlane(PyObject *point, PyObject *normalVector)
1277       {
1278         const char msg[]="Python wrap of DataArrayDouble::symmetry3DPlane : ";
1279         double val,val2;
1280         DataArrayDouble *a,*a2;
1281         DataArrayDoubleTuple *aa,*aa2;
1282         std::vector<double> bb,bb2;
1283         mcIdType sw;
1284         const double *centerPtr(convertObjToPossibleCpp5_Safe(point,sw,val,a,aa,bb,msg,1,3,true));
1285         const double *vectorPtr(convertObjToPossibleCpp5_Safe(normalVector,sw,val2,a2,aa2,bb2,msg,1,3,true));
1286         MCAuto<DataArrayDouble> ret(self->symmetry3DPlane(centerPtr,vectorPtr));
1287         return ret.retn();
1288       }
1289
1290       static PyObject *GiveBaseForPlane(PyObject *normalVector)
1291       {
1292         const char msg[]="Python wrap of DataArrayDouble::GiveBaseForPlane : ";
1293         double val;
1294         DataArrayDouble *a;
1295         DataArrayDoubleTuple *aa;
1296         std::vector<double> bb,bb2;
1297         mcIdType sw;
1298         const double *vectorPtr(convertObjToPossibleCpp5_Safe(normalVector,sw,val,a,aa,bb,msg,1,3,true));
1299         double res[9];
1300         DataArrayDouble::GiveBaseForPlane(vectorPtr,res);
1301         return convertDblArrToPyListOfTuple<double>(res,3,3);
1302       }
1303
1304       DataArrayDouble *fromCartToCylGiven(const DataArrayDouble *coords, PyObject *center, PyObject *vector) const
1305       {
1306         const char msg[]="Python wrap of DataArrayDouble::fromCartToCylGiven : ";
1307         double val,val2;
1308         DataArrayDouble *a,*a2;
1309         DataArrayDoubleTuple *aa,*aa2;
1310         std::vector<double> bb,bb2;
1311         mcIdType sw;
1312         const double *centerPtr=convertObjToPossibleCpp5_Safe(center,sw,val,a,aa,bb,msg,1,3,true);
1313         const double *vectorPtr=convertObjToPossibleCpp5_Safe(vector,sw,val2,a2,aa2,bb2,msg,1,3,true);
1314         return self->fromCartToCylGiven(coords,centerPtr,vectorPtr);
1315       }
1316
1317       DataArrayDouble *renumber(PyObject *li)
1318       {
1319         void *da=0;
1320         int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 |  0 );
1321         if (!SWIG_IsOK(res1))
1322           {
1323             mcIdType size;
1324             INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1325             if(size!=self->getNumberOfTuples())
1326               {
1327                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1328               }
1329             return self->renumber(tmp);
1330           }
1331         else
1332           {
1333             DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1334             if(!da2)
1335               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1336             da2->checkAllocated();
1337             mcIdType size=self->getNumberOfTuples();
1338             if(size!=self->getNumberOfTuples())
1339               {
1340                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1341               }
1342             return self->renumber(da2->getConstPointer());
1343           }
1344       }
1345
1346       DataArrayDouble *renumberR(PyObject *li)
1347       {
1348         void *da=0;
1349         int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 |  0 );
1350         if (!SWIG_IsOK(res1))
1351           {
1352             mcIdType size;
1353             INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1354             if(size!=self->getNumberOfTuples())
1355               {
1356                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1357               }
1358             return self->renumberR(tmp);
1359           }
1360         else
1361           {
1362             DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1363             if(!da2)
1364               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1365             da2->checkAllocated();
1366             mcIdType size=self->getNumberOfTuples();
1367             if(size!=self->getNumberOfTuples())
1368               {
1369                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1370               }
1371             return self->renumberR(da2->getConstPointer());
1372           }
1373       }
1374
1375       DataArrayDouble *renumberAndReduce(PyObject *li, mcIdType newNbOfTuple)
1376       {
1377         void *da=0;
1378         int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 |  0 );
1379         if (!SWIG_IsOK(res1))
1380           {
1381             mcIdType size;
1382             INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1383             if(size!=self->getNumberOfTuples())
1384               {
1385                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1386               }
1387             return self->renumberAndReduce(tmp,newNbOfTuple);
1388           }
1389         else
1390           {
1391             DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1392             if(!da2)
1393               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1394             da2->checkAllocated();
1395             mcIdType size=self->getNumberOfTuples();
1396             if(size!=self->getNumberOfTuples())
1397               {
1398                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1399               }
1400             return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
1401           }
1402       }
1403
1404       PyObject *minimalDistanceTo(const DataArrayDouble *other) const
1405       {
1406         mcIdType thisTupleId,otherTupleId;
1407         double r0=self->minimalDistanceTo(other,thisTupleId,otherTupleId);
1408         PyObject *ret=PyTuple_New(3);
1409         PyTuple_SetItem(ret,0,PyFloat_FromDouble(r0));
1410         PyTuple_SetItem(ret,1,PyInt_FromLong(thisTupleId));
1411         PyTuple_SetItem(ret,2,PyInt_FromLong(otherTupleId));
1412         return ret;
1413       }
1414
1415       PyObject *getMaxValue() const
1416       {
1417         mcIdType tmp;
1418         double r1=self->getMaxValue(tmp);
1419         PyObject *ret=PyTuple_New(2);
1420         PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1421         PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1422         return ret;
1423       }
1424
1425           PyObject *getMaxAbsValue() const
1426       {
1427         std::size_t tmp;
1428         double r1=self->getMaxAbsValue(tmp);
1429         PyObject *ret=PyTuple_New(2);
1430         PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1431         PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1432         return ret;
1433       }
1434
1435       PyObject *getMaxValue2() const
1436       {
1437         DataArrayIdType *tmp;
1438         double r1=self->getMaxValue2(tmp);
1439         PyObject *ret=PyTuple_New(2);
1440         PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1441         PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1442         return ret;
1443       }
1444
1445       PyObject *getMinValue() const
1446       {
1447         mcIdType tmp;
1448         double r1=self->getMinValue(tmp);
1449         PyObject *ret=PyTuple_New(2);
1450         PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1451         PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1452         return ret;
1453       }
1454
1455       PyObject *getMinValue2() const
1456       {
1457         DataArrayIdType *tmp;
1458         double r1=self->getMinValue2(tmp);
1459         PyObject *ret=PyTuple_New(2);
1460         PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1461         PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1462         return ret;
1463       }
1464
1465       PyObject *getMinMaxPerComponent() const
1466       {
1467         std::size_t nbOfCompo(self->getNumberOfComponents());
1468         INTERP_KERNEL::AutoPtr<double> tmp(new double[2*nbOfCompo]);
1469         self->getMinMaxPerComponent(tmp);
1470         PyObject *ret=convertDblArrToPyListOfTuple<double>(tmp,2,ToIdType(nbOfCompo));
1471         return ret;
1472       }
1473
1474       PyObject *normMaxPerComponent() const
1475       {
1476         std::size_t nbOfCompo(self->getNumberOfComponents());
1477         INTERP_KERNEL::AutoPtr<double> tmp(new double[nbOfCompo]);
1478         self->normMaxPerComponent(tmp);
1479         return convertDblArrToPyList<double>(tmp,ToIdType(nbOfCompo));
1480       }
1481
1482       PyObject *accumulate() const
1483       {
1484         std::size_t sz=self->getNumberOfComponents();
1485         INTERP_KERNEL::AutoPtr<double> tmp=new double[sz];
1486         self->accumulate(tmp);
1487         return convertDblArrToPyList<double>(tmp,ToIdType(sz));
1488       }
1489
1490       DataArrayDouble *accumulatePerChunck(PyObject *indexArr) const
1491       {
1492         mcIdType sw, sz,val;
1493         std::vector<mcIdType> val2;
1494         const mcIdType *bg=convertIntStarLikePyObjToCppIntStar(indexArr,sw,sz,val,val2);
1495         return self->accumulatePerChunck(bg,bg+sz);
1496       }
1497
1498       PyObject *findCommonTuples(double prec, mcIdType limitNodeId=-1) const
1499       {
1500         DataArrayIdType *comm, *commIndex;
1501         self->findCommonTuples(prec,limitNodeId,comm,commIndex);
1502         PyObject *res = PyList_New(2);
1503         PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(comm),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1504         PyList_SetItem(res,1,SWIG_NewPointerObj(SWIG_as_voidptr(commIndex),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1505         return res;
1506       }
1507
1508       PyObject *distanceToTuple(PyObject *tuple) const
1509       {
1510         double val;
1511         DataArrayDouble *a;
1512         DataArrayDoubleTuple *aa;
1513         std::vector<double> bb;
1514         mcIdType sw;
1515         mcIdType tupleId=-1;
1516         std::size_t nbOfCompo=self->getNumberOfComponents();
1517         const double *pt=convertObjToPossibleCpp5_Safe(tuple,sw,val,a,aa,bb,"Python wrap of DataArrayDouble::distanceToTuple",1,(int)nbOfCompo,true);
1518         //
1519         double ret0=self->distanceToTuple(pt,pt+nbOfCompo,tupleId);
1520         PyObject *ret=PyTuple_New(2);
1521         PyTuple_SetItem(ret,0,PyFloat_FromDouble(ret0));
1522         PyTuple_SetItem(ret,1,PyInt_FromLong(tupleId));
1523         return ret;
1524       }
1525
1526       void setSelectedComponents(const DataArrayDouble *a, PyObject *li)
1527       {
1528         std::vector<std::size_t> tmp;
1529         convertPyToNewIntArr3(li,tmp);
1530         self->setSelectedComponents(a,tmp);
1531       }
1532
1533       PyObject *explodeComponents() const
1534       {
1535         std::vector< MCAuto<DataArrayDouble> > retCpp(self->explodeComponents());
1536         std::size_t sz(retCpp.size());
1537         PyObject *res(PyList_New(sz));
1538         for(std::size_t i=0;i<sz;i++)
1539           PyList_SetItem(res,i,SWIG_NewPointerObj(SWIG_as_voidptr(retCpp[i].retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ));
1540         return res;
1541       }
1542
1543       PyObject *getTuple(mcIdType tupleId)
1544       {
1545         std::size_t sz=self->getNumberOfComponents();
1546         INTERP_KERNEL::AutoPtr<double> tmp=new double[sz];
1547         self->getTuple(tupleId,tmp);
1548         return convertDblArrToPyList<double>(tmp,ToIdType(sz));
1549       }
1550
1551       static DataArrayDouble *Aggregate(PyObject *li)
1552       {
1553         std::vector<const DataArrayDouble *> tmp;
1554         convertFromPyObjVectorOfObj<const DataArrayDouble *>(li,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",tmp);
1555         return DataArrayDouble::Aggregate(tmp);
1556       }
1557
1558       static DataArrayDouble *Meld(PyObject *li)
1559       {
1560         std::vector<const DataArrayDouble *> tmp;
1561         convertFromPyObjVectorOfObj<const DataArrayDouble *>(li,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",tmp);
1562         return DataArrayDouble::Meld(tmp);
1563       }
1564
1565       PyObject *computeTupleIdsNearTuples(PyObject *pt, double eps) const
1566       {
1567         double val;
1568         DataArrayDouble *a;
1569         DataArrayDoubleTuple *aa;
1570         std::vector<double> bb;
1571         mcIdType sw;
1572         std::size_t nbComp=self->getNumberOfComponents();
1573         mcIdType nbTuples=-1;
1574         const char msg[]="Python wrap of DataArrayDouble::computeTupleIdsNearTuples : ";
1575         const double *pos=convertObjToPossibleCpp5_Safe2(pt,sw,val,a,aa,bb,msg,(int)nbComp,true,nbTuples);
1576         MCAuto<DataArrayDouble> inpu=DataArrayDouble::New(); inpu->useArray(pos,false,DeallocType::CPP_DEALLOC,nbTuples,nbComp);
1577         DataArrayIdType *c=0,*cI=0;
1578         self->computeTupleIdsNearTuples(inpu,eps,c,cI);
1579         PyObject *ret=PyTuple_New(2);
1580         PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1581         PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1582         return ret;
1583       }
1584
1585       PyObject *areIncludedInMe(const DataArrayDouble *other, double prec) const
1586       {
1587         DataArrayIdType *ret1=0;
1588         bool ret0=self->areIncludedInMe(other,prec,ret1);
1589         PyObject *ret=PyTuple_New(2);
1590         PyObject *ret0Py=ret0?Py_True:Py_False;
1591         Py_XINCREF(ret0Py);
1592         PyTuple_SetItem(ret,0,ret0Py);
1593         PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1594         return ret;
1595       }
1596
1597       PyObject *__getitem__(PyObject *obj)
1598       {
1599         return DataArrayT__getitem<double>(self,obj);
1600       }
1601
1602       DataArrayDouble *__setitem__(PyObject *obj, PyObject *value)
1603       {
1604         return DataArrayT__setitem__<double>(self,obj,value);
1605       }
1606
1607       DataArrayDouble *__neg__() const
1608       {
1609         return self->negate();
1610       }
1611
1612       PyObject *__add__(PyObject *obj)
1613       {
1614         const char msg[]="Unexpected situation in DataArrayDouble.__add__ !";
1615         double val;
1616         DataArrayDouble *a;
1617         DataArrayDoubleTuple *aa;
1618         std::vector<double> bb;
1619         mcIdType sw;
1620         //
1621 #ifndef WITHOUT_AUTOFIELD
1622         void *argp;
1623         if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1624           {
1625             MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1626             if(other)
1627               {
1628                 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1629                 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___radd__Impl(other,tmp);
1630                 Py_XDECREF(tmp);
1631                 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1632               }
1633             else
1634               throw INTERP_KERNEL::Exception(msg);
1635           }
1636 #endif
1637         //
1638         convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1639         switch(sw)
1640           {
1641           case 1:
1642             {
1643               MCAuto<DataArrayDouble> ret=self->deepCopy();
1644               ret->applyLin(1.,val);
1645               return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1646             }
1647           case 2:
1648             {
1649               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1650             }
1651           case 3:
1652             {
1653               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1654               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1655             }
1656           case 4:
1657             {
1658               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1659               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1660             }
1661           default:
1662             throw INTERP_KERNEL::Exception(msg);
1663           }
1664       }
1665
1666       DataArrayDouble *__radd__(PyObject *obj)
1667       {
1668         const char msg[]="Unexpected situation in __radd__ !";
1669         double val;
1670         DataArrayDouble *a;
1671         DataArrayDoubleTuple *aa;
1672         std::vector<double> bb;
1673         mcIdType sw;
1674         convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1675         switch(sw)
1676           {
1677           case 1:
1678             {
1679               MCAuto<DataArrayDouble> ret=self->deepCopy();
1680               ret->applyLin(1.,val);
1681               return ret.retn();
1682             }
1683           case 3:
1684             {
1685               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1686               return DataArrayDouble::Add(self,aaa);
1687             }
1688           case 4:
1689             {
1690               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1691               return DataArrayDouble::Add(self,aaa);
1692             }
1693           default:
1694             throw INTERP_KERNEL::Exception(msg);
1695           }
1696       }
1697
1698       PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
1699       {
1700         return DataArrayT_iadd<double>(trueSelf,obj,self);
1701       }
1702
1703       PyObject *__sub__(PyObject *obj)
1704       {
1705         const char msg[]="Unexpected situation in __sub__ !";
1706         double val;
1707         DataArrayDouble *a;
1708         DataArrayDoubleTuple *aa;
1709         std::vector<double> bb;
1710         mcIdType sw;
1711         //
1712 #ifndef WITHOUT_AUTOFIELD
1713         void *argp;
1714         if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1715           {
1716             MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1717             if(other)
1718               {
1719                 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1720                 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rsub__Impl(other,tmp);
1721                 Py_XDECREF(tmp);
1722                 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1723               }
1724             else
1725               throw INTERP_KERNEL::Exception(msg);
1726           }
1727 #endif
1728         //
1729         convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1730         switch(sw)
1731           {
1732           case 1:
1733             {
1734               MCAuto<DataArrayDouble> ret=self->deepCopy();
1735               ret->applyLin(1.,-val);
1736               return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1737             }
1738           case 2:
1739             {
1740               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1741             }
1742           case 3:
1743             {
1744               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1745               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1746             }
1747           case 4:
1748             {
1749               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1750               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1751             }
1752           default:
1753             throw INTERP_KERNEL::Exception(msg);
1754           }
1755       }
1756
1757       DataArrayDouble *__rsub__(PyObject *obj)
1758       {
1759         const char msg[]="Unexpected situation in __rsub__ !";
1760         double val;
1761         DataArrayDouble *a;
1762         DataArrayDoubleTuple *aa;
1763         std::vector<double> bb;
1764         mcIdType sw;
1765         convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1766         switch(sw)
1767           {
1768           case 1:
1769             {
1770               MCAuto<DataArrayDouble> ret=self->deepCopy();
1771               ret->applyLin(-1.,val);
1772               return ret.retn();
1773             }
1774           case 3:
1775             {
1776               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1777               return DataArrayDouble::Substract(aaa,self);
1778             }
1779           case 4:
1780             {
1781               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1782               return DataArrayDouble::Substract(aaa,self);
1783             }
1784           default:
1785             throw INTERP_KERNEL::Exception(msg);
1786           }
1787       }
1788
1789       PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
1790       {
1791         return DataArrayT_isub<double>(trueSelf,obj,self);
1792       }
1793
1794       PyObject *__mul__(PyObject *obj)
1795       {
1796         const char msg[]="Unexpected situation in __mul__ !";
1797         double val;
1798         DataArrayDouble *a;
1799         DataArrayDoubleTuple *aa;
1800         std::vector<double> bb;
1801         mcIdType sw;
1802         //
1803 #ifndef WITHOUT_AUTOFIELD
1804         void *argp;
1805         if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1806           {
1807             MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1808             if(other)
1809               {
1810                 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1811                 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rmul__Impl(other,tmp);
1812                 Py_XDECREF(tmp);
1813                 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1814               }
1815             else
1816               throw INTERP_KERNEL::Exception(msg);
1817           }
1818 #endif
1819         //
1820         convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1821         switch(sw)
1822           {
1823           case 1:
1824             {
1825               MCAuto<DataArrayDouble> ret=self->deepCopy();
1826               ret->applyLin(val,0.);
1827               return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1828             }
1829           case 2:
1830             {
1831               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1832             }
1833           case 3:
1834             {
1835               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1836               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1837             }
1838           case 4:
1839             {
1840               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1841               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1842             }
1843           default:
1844             throw INTERP_KERNEL::Exception(msg);
1845           }
1846       }
1847
1848       DataArrayDouble *__rmul__(PyObject *obj)
1849       {
1850         return DataArrayFPT_rmul<double>(self,obj);
1851       }
1852
1853       PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
1854       {
1855         return DataArrayT_imul<double>(trueSelf,obj,self);
1856       }
1857
1858       PyObject *__div__(PyObject *obj)
1859       {
1860         const char msg[]="Unexpected situation in __div__ !";
1861         double val;
1862         DataArrayDouble *a;
1863         DataArrayDoubleTuple *aa;
1864         std::vector<double> bb;
1865         mcIdType sw;
1866         //
1867 #ifndef WITHOUT_AUTOFIELD
1868         void *argp;
1869         if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1870           {
1871             MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1872             if(other)
1873               {
1874                 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1875                 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rdiv__Impl(other,tmp);
1876                 Py_XDECREF(tmp);
1877                 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1878               }
1879             else
1880               throw INTERP_KERNEL::Exception(msg);
1881           }
1882 #endif
1883         //
1884         convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1885         switch(sw)
1886           {
1887           case 1:
1888             {
1889               if(val==0.)
1890                 throw INTERP_KERNEL::Exception("DataArrayDouble::__div__ : trying to divide by zero !");
1891               MCAuto<DataArrayDouble> ret=self->deepCopy();
1892               ret->applyLin(1/val,0.);
1893               return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1894             }
1895           case 2:
1896             {
1897               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1898             }
1899           case 3:
1900             {
1901               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1902               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1903             }
1904           case 4:
1905             {
1906               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1907               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1908             }
1909           default:
1910             throw INTERP_KERNEL::Exception(msg);
1911           }
1912       }
1913
1914       DataArrayDouble *__rdiv__(PyObject *obj)
1915       {
1916         const char msg[]="Unexpected situation in __rdiv__ !";
1917         double val;
1918         DataArrayDouble *a;
1919         DataArrayDoubleTuple *aa;
1920         std::vector<double> bb;
1921         mcIdType sw;
1922         convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1923         switch(sw)
1924           {
1925           case 1:
1926             {
1927               MCAuto<DataArrayDouble> ret=self->deepCopy();
1928               ret->applyInv(val);
1929               return ret.retn();
1930             }
1931           case 3:
1932             {
1933               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1934               return DataArrayDouble::Divide(aaa,self);
1935             }
1936           case 4:
1937             {
1938               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1939               return DataArrayDouble::Divide(aaa,self);
1940             }
1941           default:
1942             throw INTERP_KERNEL::Exception(msg);
1943           }
1944       }
1945
1946       PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
1947       {
1948         return DataArrayT_idiv<double>(trueSelf,obj,self);
1949       }
1950
1951       DataArrayDouble *__pow__(PyObject *obj)
1952       {
1953         const char msg[]="Unexpected situation in __pow__ !";
1954         double val;
1955         DataArrayDouble *a;
1956         DataArrayDoubleTuple *aa;
1957         std::vector<double> bb;
1958         mcIdType sw;
1959         convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1960         switch(sw)
1961           {
1962           case 1:
1963             {
1964               MCAuto<DataArrayDouble> ret=self->deepCopy();
1965               ret->applyPow(val);
1966               return ret.retn();
1967             }
1968           case 2:
1969             {
1970               return DataArrayDouble::Pow(self,a);
1971             }
1972           case 3:
1973             {
1974               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1975               return DataArrayDouble::Pow(self,aaa);
1976             }
1977           case 4:
1978             {
1979               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1980               return DataArrayDouble::Pow(self,aaa);
1981             }
1982           default:
1983             throw INTERP_KERNEL::Exception(msg);
1984           }
1985       }
1986
1987       DataArrayDouble *__rpow__(PyObject *obj)
1988       {
1989         const char msg[]="Unexpected situation in __rpow__ !";
1990         double val;
1991         DataArrayDouble *a;
1992         DataArrayDoubleTuple *aa;
1993         std::vector<double> bb;
1994         mcIdType sw;
1995         convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1996         switch(sw)
1997           {
1998           case 1:
1999             {
2000               MCAuto<DataArrayDouble> ret=self->deepCopy();
2001               ret->applyRPow(val);
2002               return ret.retn();
2003             }
2004           case 3:
2005             {
2006               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
2007               return DataArrayDouble::Pow(aaa,self);
2008             }
2009           case 4:
2010             {
2011               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
2012               return DataArrayDouble::Pow(aaa,self);
2013             }
2014           default:
2015             throw INTERP_KERNEL::Exception(msg);
2016           }
2017       }
2018
2019       PyObject *___ipow___(PyObject *trueSelf, PyObject *obj)
2020       {
2021         const char msg[]="Unexpected situation in __ipow__ !";
2022         double val;
2023         DataArrayDouble *a;
2024         DataArrayDoubleTuple *aa;
2025         std::vector<double> bb;
2026         mcIdType sw;
2027         convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
2028         switch(sw)
2029           {
2030           case 1:
2031             {
2032               self->applyPow(val);
2033               Py_XINCREF(trueSelf);
2034               return trueSelf;
2035             }
2036           case 2:
2037             {
2038               self->powEqual(a);
2039               Py_XINCREF(trueSelf);
2040               return trueSelf;
2041             }
2042           case 3:
2043             {
2044               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
2045               self->powEqual(aaa);
2046               Py_XINCREF(trueSelf);
2047               return trueSelf;
2048             }
2049           case 4:
2050             {
2051               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
2052               self->powEqual(aaa);
2053               Py_XINCREF(trueSelf);
2054               return trueSelf;
2055             }
2056           default:
2057             throw INTERP_KERNEL::Exception(msg);
2058           }
2059       }
2060
2061       PyObject *computeTupleIdsNearTuples(const DataArrayDouble *other, double eps)
2062       {
2063         DataArrayIdType *c=0,*cI=0;
2064         //
2065         self->computeTupleIdsNearTuples(other,eps,c,cI);
2066         PyObject *ret=PyTuple_New(2);
2067         PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2068         PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2069         return ret;
2070       }
2071
2072       PyObject *maxPerTupleWithCompoId() const
2073       {
2074         DataArrayIdType *ret1=0;
2075         DataArrayDouble *ret0=self->maxPerTupleWithCompoId(ret1);
2076         PyObject *ret=PyTuple_New(2);
2077         PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ));
2078         PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2079         return ret;
2080       }
2081     }
2082   };
2083
2084   class DataArrayDoubleTuple;
2085
2086   class DataArrayDoubleIterator
2087   {
2088   public:
2089     DataArrayDoubleIterator(DataArrayDouble *da);
2090     ~DataArrayDoubleIterator();
2091     %extend
2092     {
2093       PyObject *next()
2094       {
2095         DataArrayDoubleTuple *ret=self->nextt();
2096         if(ret)
2097           return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayDoubleTuple,SWIG_POINTER_OWN|0);
2098         else
2099           {
2100             PyErr_SetString(PyExc_StopIteration,"No more data.");
2101             return 0;
2102           }
2103       }
2104     }
2105   };
2106
2107   class DataArrayDoubleTuple
2108   {
2109   public:
2110     std::size_t getNumberOfCompo() const;
2111     DataArrayDouble *buildDADouble(int nbOfTuples, int nbOfCompo) const;
2112     %extend
2113     {
2114       std::string __str__() const
2115       {
2116         return self->repr();
2117       }
2118
2119       double __float__() const
2120       {
2121         return self->doubleValue();
2122       }
2123
2124       DataArrayDouble *buildDADouble()
2125       {
2126         return self->buildDADouble(1,self->getNumberOfCompo());
2127       }
2128
2129       PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
2130       {
2131         MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2132         MEDCoupling_DataArrayDouble____iadd___(ret,0,obj);
2133         Py_XINCREF(trueSelf);
2134         return trueSelf;
2135       }
2136
2137       PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
2138       {
2139         MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2140         MEDCoupling_DataArrayDouble____isub___(ret,0,obj);
2141         Py_XINCREF(trueSelf);
2142         return trueSelf;
2143       }
2144
2145       PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
2146       {
2147         MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2148         MEDCoupling_DataArrayDouble____imul___(ret,0,obj);
2149         Py_XINCREF(trueSelf);
2150         return trueSelf;
2151       }
2152
2153       PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
2154       {
2155         MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2156         MEDCoupling_DataArrayDouble____idiv___(ret,0,obj);
2157         Py_XINCREF(trueSelf);
2158         return trueSelf;
2159       }
2160
2161       PyObject *__len__()
2162       {
2163         return PyInt_FromLong(self->getNumberOfCompo());
2164       }
2165
2166       PyObject *__getitem__(PyObject *obj)
2167       {
2168         const char msg2[]="DataArrayDoubleTuple::__getitem__ : Mismatch of slice values in 2nd parameter (components) !";
2169         mcIdType sw;
2170         mcIdType singleVal;
2171         std::vector<mcIdType> multiVal;
2172         std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2173         MEDCoupling::DataArrayIdType *daIntTyypp=0;
2174         const double *pt=self->getConstPointer();
2175         mcIdType nbc=ToIdType(self->getNumberOfCompo());
2176         convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbc,sw,singleVal,multiVal,slic,daIntTyypp);
2177         switch(sw)
2178           {
2179           case 1:
2180             {
2181               if(singleVal>=nbc)
2182                 {
2183                   std::ostringstream oss;
2184                   oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2185                   PyErr_SetString(PyExc_StopIteration,oss.str().c_str());
2186                   return 0;
2187                 }
2188               if(singleVal>=0)
2189                 return PyFloat_FromDouble(pt[singleVal]);
2190               else
2191                 {
2192                   if(nbc+singleVal>0)
2193                     return PyFloat_FromDouble(pt[nbc+singleVal]);
2194                   else
2195                     {
2196                       std::ostringstream oss;
2197                       oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2198                       throw INTERP_KERNEL::Exception(oss.str().c_str());
2199                     }
2200                 }
2201             }
2202           case 2:
2203             {
2204               PyObject *t=PyTuple_New(multiVal.size());
2205               for(std::size_t j=0;j<multiVal.size();j++)
2206                 {
2207                   mcIdType cid=multiVal[j];
2208                   if(cid>=nbc)
2209                     {
2210                       std::ostringstream oss;
2211                       oss << "Requesting for id #" << cid << " having only " << nbc << " components !";
2212                       throw INTERP_KERNEL::Exception(oss.str().c_str());
2213                     }
2214                   PyTuple_SetItem(t,j,PyFloat_FromDouble(pt[cid]));
2215                 }
2216               return t;
2217             }
2218           case 3:
2219             {
2220               mcIdType sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2221               PyObject *t=PyTuple_New(sz);
2222               for(mcIdType j=0;j<sz;j++)
2223                 PyTuple_SetItem(t,j,PyFloat_FromDouble(pt[slic.first+j*slic.second.second]));
2224               return t;
2225             }
2226           default:
2227             throw INTERP_KERNEL::Exception("DataArrayDoubleTuple::__getitem__ : unrecognized type entered !");
2228           }
2229       }
2230
2231       DataArrayDoubleTuple *__setitem__(PyObject *obj, PyObject *value)
2232       {
2233         const char msg[]="DataArrayDoubleTuple::__setitem__ : unrecognized type entered, int, slice, list<int>, tuple<int> !";
2234         const char msg2[]="DataArrayDoubleTuple::__setitem__ : Mismatch of slice values in 2nd parameter (components) !";
2235         mcIdType sw1,sw2;
2236         double singleValV;
2237         std::vector<double> multiValV;
2238         MEDCoupling::DataArrayDoubleTuple *daIntTyyppV=0;
2239         mcIdType nbc=ToIdType(self->getNumberOfCompo());
2240         convertDoubleStarLikePyObjToCpp(value,sw1,singleValV,multiValV,daIntTyyppV);
2241         mcIdType singleVal;
2242         std::vector<mcIdType> multiVal;
2243         std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2244         MEDCoupling::DataArrayIdType *daIntTyypp=0;
2245         double *pt=self->getPointer();
2246         convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbc,sw2,singleVal,multiVal,slic,daIntTyypp);
2247         switch(sw2)
2248           {
2249           case 1:
2250             {
2251               if(singleVal>=nbc)
2252                 {
2253                   std::ostringstream oss;
2254                   oss << "Requesting for setting id # " << singleVal << " having only " << nbc << " components !";
2255                   throw INTERP_KERNEL::Exception(oss.str().c_str());
2256                 }
2257               switch(sw1)
2258                 {
2259                 case 1:
2260                   {
2261                     pt[singleVal]=singleValV;
2262                     return self;
2263                   }
2264                 case 2:
2265                   {
2266                     if(multiValV.size()!=1)
2267                       {
2268                         std::ostringstream oss;
2269                         oss << "Requesting for setting id # " << singleVal << " with a list or tuple with size != 1 ! ";
2270                         throw INTERP_KERNEL::Exception(oss.str().c_str());
2271                       }
2272                     pt[singleVal]=multiValV[0];
2273                     return self;
2274                   }
2275                 case 3:
2276                   {
2277                     pt[singleVal]=daIntTyyppV->getConstPointer()[0];
2278                     return self;
2279                   }
2280                 default:
2281                   throw INTERP_KERNEL::Exception(msg);
2282                 }
2283             }
2284           case 2:
2285             {
2286               switch(sw1)
2287                 {
2288                 case 1:
2289                   {
2290                     for(std::vector<mcIdType>::const_iterator it=multiVal.begin();it!=multiVal.end();it++)
2291                       {
2292                         if(*it>=nbc)
2293                           {
2294                             std::ostringstream oss;
2295                             oss << "Requesting for setting id # " << *it << " having only " << nbc << " components !";
2296                             throw INTERP_KERNEL::Exception(oss.str().c_str());
2297                           }
2298                         pt[*it]=singleValV;
2299                       }
2300                     return self;
2301                   }
2302                 case 2:
2303                   {
2304                     if(multiVal.size()!=multiValV.size())
2305                       {
2306                         std::ostringstream oss;
2307                         oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << multiVal.size() << " !";
2308                         throw INTERP_KERNEL::Exception(oss.str().c_str());
2309                       }
2310                     for(std::size_t i=0;i<multiVal.size();i++)
2311                       {
2312                         mcIdType pos=multiVal[i];
2313                         if(pos>=nbc)
2314                           {
2315                             std::ostringstream oss;
2316                             oss << "Requesting for setting id # " << pos << " having only " << nbc << " components !";
2317                             throw INTERP_KERNEL::Exception(oss.str().c_str());
2318                           }
2319                         pt[multiVal[i]]=multiValV[i];
2320                       }
2321                     return self;
2322                   }
2323                 case 3:
2324                   {
2325                     const double *ptV=daIntTyyppV->getConstPointer();
2326                     if(nbc>(mcIdType)daIntTyyppV->getNumberOfCompo())
2327                       {
2328                         std::ostringstream oss;
2329                         oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2330                         throw INTERP_KERNEL::Exception(oss.str().c_str());
2331                       }
2332                     std::copy(ptV,ptV+nbc,pt);
2333                     return self;
2334                   }
2335                 default:
2336                   throw INTERP_KERNEL::Exception(msg);
2337                 }
2338             }
2339           case 3:
2340             {
2341               mcIdType sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2342               switch(sw1)
2343                 {
2344                 case 1:
2345                   {
2346                     for(mcIdType j=0;j<sz;j++)
2347                       pt[slic.first+j*slic.second.second]=singleValV;
2348                     return self;
2349                   }
2350                 case 2:
2351                   {
2352                     if(sz!=(mcIdType)multiValV.size())
2353                       {
2354                         std::ostringstream oss;
2355                         oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << sz << " !";
2356                         throw INTERP_KERNEL::Exception(oss.str().c_str());
2357                       }
2358                     for(mcIdType j=0;j<sz;j++)
2359                       pt[slic.first+j*slic.second.second]=multiValV[j];
2360                     return self;
2361                   }
2362                 case 3:
2363                   {
2364                     const double *ptV=daIntTyyppV->getConstPointer();
2365                     if(sz>(mcIdType)daIntTyyppV->getNumberOfCompo())
2366                       {
2367                         std::ostringstream oss;
2368                         oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2369                         throw INTERP_KERNEL::Exception(oss.str().c_str());
2370                       }
2371                     for(mcIdType j=0;j<sz;j++)
2372                       pt[slic.first+j*slic.second.second]=ptV[j];
2373                     return self;
2374                   }
2375                 default:
2376                   throw INTERP_KERNEL::Exception(msg);
2377                 }
2378             }
2379           default:
2380             throw INTERP_KERNEL::Exception(msg);
2381           }
2382       }
2383     }
2384   };
2385
2386   class DataArrayChar : public DataArray
2387   {
2388   public:
2389     virtual DataArrayChar *buildEmptySpecializedDAChar() const;
2390     int getHashCode() const;
2391     bool empty() const;
2392     void deepCopyFrom(const DataArrayChar& other);
2393     void reserve(std::size_t nbOfElems);
2394     void pushBackSilent(char val);
2395     char popBackSilent();
2396     void pack() const;
2397     void allocIfNecessary(int nbOfTuple, int nbOfCompo);
2398     bool isEqual(const DataArrayChar& other) const;
2399     bool isEqualWithoutConsideringStr(const DataArrayChar& other) const;
2400     void reverse();
2401     void fillWithZero();
2402     void fillWithValue(char val);
2403     std::string repr() const;
2404     std::string reprZip() const;
2405     DataArrayInt *convertToIntArr() const;
2406     DataArrayChar *renumber(const mcIdType *old2New) const;
2407     DataArrayChar *renumberR(const mcIdType *new2Old) const;
2408     DataArrayChar *renumberAndReduce(const mcIdType *old2NewBg, mcIdType newNbOfTuple) const;
2409     bool isUniform(char val) const;
2410     void sort(bool asc=true);
2411     DataArrayChar *subArray(mcIdType tupleIdBg, mcIdType tupleIdEnd=-1) const;
2412     DataArrayChar *changeNbOfComponents(std::size_t newNbOfComp, char dftValue) const;
2413     void meldWith(const DataArrayChar *other);
2414     void setPartOfValuesAdv(const DataArrayChar *a, const DataArrayIdType *tuplesSelec);
2415     char front() const;
2416     char back() const;
2417     void setIJ(mcIdType tupleId, int compoId, char newVal);
2418     void setIJSilent(mcIdType tupleId, int compoId, char newVal);
2419     char *getPointer();
2420     DataArrayIdType *findIdsEqual(char val) const;
2421     DataArrayIdType *findIdsNotEqual(char val) const;
2422     int findIdFirstEqualTuple(const std::vector<char>& tupl) const;
2423     bool presenceOfTuple(const std::vector<char>& tupl) const;
2424     char getMaxValue(mcIdType& tupleId) const;
2425     char getMaxValueInArray() const;
2426     char getMinValue(mcIdType& tupleId) const;
2427     char getMinValueInArray() const;
2428     DataArrayIdType *findIdsInRange(char vmin, char vmax) const;
2429     static DataArrayChar *Aggregate(const DataArrayChar *a1, const DataArrayChar *a2);
2430     static DataArrayChar *Meld(const DataArrayChar *a1, const DataArrayChar *a2);
2431     %extend
2432     {
2433       mcIdType __len__() const
2434       {
2435         if(self->isAllocated())
2436           {
2437             return self->getNumberOfTuples();
2438           }
2439         else
2440           {
2441             throw INTERP_KERNEL::Exception("DataArrayChar::__len__ : Instance is NOT allocated !");
2442           }
2443       }
2444
2445       PyObject *isEqualIfNotWhy(const DataArrayChar& other) const
2446       {
2447         std::string ret1;
2448         bool ret0=self->isEqualIfNotWhy(other,ret1);
2449         PyObject *ret=PyTuple_New(2);
2450         PyObject *ret0Py=ret0?Py_True:Py_False;
2451         Py_XINCREF(ret0Py);
2452         PyTuple_SetItem(ret,0,ret0Py);
2453         PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
2454         return ret;
2455       }
2456
2457       DataArrayChar *renumber(PyObject *li)
2458       {
2459         void *da=0;
2460         int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 |  0 );
2461         if (!SWIG_IsOK(res1))
2462           {
2463             mcIdType size;
2464             INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2465             if(size!=self->getNumberOfTuples())
2466               {
2467                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2468               }
2469             return self->renumber(tmp);
2470           }
2471         else
2472           {
2473             DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2474             if(!da2)
2475               throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2476             da2->checkAllocated();
2477             mcIdType size=self->getNumberOfTuples();
2478             if(size!=self->getNumberOfTuples())
2479               {
2480                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2481               }
2482             return self->renumber(da2->getConstPointer());
2483           }
2484       }
2485
2486       DataArrayChar *renumberR(PyObject *li)
2487       {
2488         void *da=0;
2489         int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 |  0 );
2490         if (!SWIG_IsOK(res1))
2491           {
2492             mcIdType size;
2493             INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2494             if(size!=self->getNumberOfTuples())
2495               {
2496                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2497               }
2498             return self->renumberR(tmp);
2499           }
2500         else
2501           {
2502             DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2503             if(!da2)
2504               throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2505             da2->checkAllocated();
2506             mcIdType size=self->getNumberOfTuples();
2507             if(size!=self->getNumberOfTuples())
2508               {
2509                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2510               }
2511             return self->renumberR(da2->getConstPointer());
2512           }
2513       }
2514
2515       DataArrayChar *renumberAndReduce(PyObject *li, mcIdType newNbOfTuple)
2516       {
2517         void *da=0;
2518         int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 |  0 );
2519         if (!SWIG_IsOK(res1))
2520           {
2521             mcIdType size;
2522             INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2523             if(size!=self->getNumberOfTuples())
2524               {
2525                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2526               }
2527             return self->renumberAndReduce(tmp,newNbOfTuple);
2528           }
2529         else
2530           {
2531             DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2532             if(!da2)
2533               throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2534             da2->checkAllocated();
2535             mcIdType size=self->getNumberOfTuples();
2536             if(size!=self->getNumberOfTuples())
2537               {
2538                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2539               }
2540             return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
2541           }
2542       }
2543
2544       static DataArrayChar *Aggregate(PyObject *dachs)
2545       {
2546         std::vector<const MEDCoupling::DataArrayChar *> tmp;
2547         convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayChar *>(dachs,SWIGTYPE_p_MEDCoupling__DataArrayChar,"DataArrayChar",tmp);
2548         return DataArrayChar::Aggregate(tmp);
2549       }
2550
2551       static DataArrayChar *Meld(PyObject *dachs)
2552       {
2553         std::vector<const MEDCoupling::DataArrayChar *> tmp;
2554         convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayChar *>(dachs,SWIGTYPE_p_MEDCoupling__DataArrayChar,"DataArrayChar",tmp);
2555         return DataArrayChar::Meld(tmp);
2556       }
2557     }
2558   };
2559
2560   class DataArrayByteIterator;
2561
2562   class DataArrayByte : public DataArrayChar
2563   {
2564   public:
2565     static DataArrayByte *New();
2566     DataArrayByteIterator *iterator();
2567     DataArrayByte *performCopyOrIncrRef(bool deepCopy) const;
2568     char byteValue() const;
2569     %extend
2570     {
2571       DataArrayByte()
2572         {
2573           return DataArrayByte::New();
2574         }
2575
2576       static DataArrayByte *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
2577       {
2578         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) !";
2579         if(PyList_Check(elt0) || PyTuple_Check(elt0))
2580           {
2581             if(nbOfTuples)
2582               {
2583                 if(PyInt_Check(nbOfTuples))
2584                   {
2585                     mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
2586                     if(nbOfTuples1<0)
2587                       throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive set of allocated memory !");
2588                     if(nbOfComp)
2589                       {
2590                         if(PyInt_Check(nbOfComp))
2591                           {//DataArrayByte.New([1,3,4,5],2,2)
2592                             mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
2593                             if(nbOfCompo<0)
2594                               throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !");
2595                             MCAuto<DataArrayByte> ret=DataArrayByte::New();
2596                             std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
2597                             ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2598                             return ret.retn();
2599                           }
2600                         else
2601                           throw INTERP_KERNEL::Exception(msg);
2602                       }
2603                     else
2604                       {//DataArrayByte.New([1,3,4],3)
2605                         MCAuto<DataArrayByte> ret=DataArrayByte::New();
2606                         mcIdType tmpp1=-1;
2607                         std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
2608                         ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2609                         return ret.retn();
2610                       }
2611                   }
2612                 else
2613                   throw INTERP_KERNEL::Exception(msg);
2614               }
2615             else
2616               {// DataArrayByte.New([1,3,4])
2617                 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2618                 mcIdType tmpp1=-1,tmpp2=-1;
2619                 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
2620                 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2621                 return ret.retn();
2622               }
2623           }
2624         else if(PyInt_Check(elt0))
2625           {
2626             mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(elt0));
2627             if(nbOfTuples1<0)
2628               throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive set of allocated memory !");
2629             if(nbOfTuples)
2630               {
2631                 if(!nbOfComp)
2632                   {
2633                     if(PyInt_Check(nbOfTuples))
2634                       {//DataArrayByte.New(5,2)
2635                         mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfTuples));
2636                         if(nbOfCompo<0)
2637                           throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !");
2638                         MCAuto<DataArrayByte> ret=DataArrayByte::New();
2639                         ret->alloc(nbOfTuples1,nbOfCompo);
2640                         return ret.retn();
2641                       }
2642                     else
2643                       throw INTERP_KERNEL::Exception(msg);
2644                   }
2645                 else
2646                   throw INTERP_KERNEL::Exception(msg);
2647               }
2648             else
2649               {//DataArrayByte.New(5)
2650                 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2651                 ret->alloc(nbOfTuples1,1);
2652                 return ret.retn();
2653               }
2654           }
2655 #ifdef WITH_NUMPY
2656         else if(PyArray_Check(elt0) && nbOfTuples==NULL && nbOfComp==NULL)
2657           {//DataArrayDouble.New(numpyArray)
2658             return BuildNewInstance<DataArrayByte,char>(elt0,NPY_INT8,&PyCallBackDataArrayChar_RefType,"INT8");
2659           }
2660 #endif
2661         else
2662           throw INTERP_KERNEL::Exception(msg);
2663       }
2664
2665       DataArrayByte(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
2666         {
2667           return MEDCoupling_DataArrayByte_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
2668         }
2669
2670       std::string __repr__() const
2671       {
2672         std::ostringstream oss;
2673         self->reprQuickOverview(oss);
2674         return oss.str();
2675       }
2676
2677       int __int__() const
2678       {
2679         return (int) self->byteValue();
2680       }
2681
2682       DataArrayByteIterator *__iter__()
2683       {
2684         return self->iterator();
2685       }
2686
2687       mcIdType getIJ(mcIdType tupleId, mcIdType compoId) const
2688       {
2689         return (mcIdType)self->getIJ(tupleId,compoId);
2690       }
2691
2692       mcIdType getIJSafe(mcIdType tupleId, mcIdType compoId) const
2693       {
2694         return (mcIdType)self->getIJSafe(tupleId,compoId);
2695       }
2696
2697       std::string __str__() const
2698       {
2699         return self->repr();
2700       }
2701
2702       PyObject *toStrList() const
2703       {
2704         const char *vals=self->getConstPointer();
2705         std::size_t nbOfComp=self->getNumberOfComponents();
2706         mcIdType nbOfTuples=self->getNumberOfTuples();
2707         return convertCharArrToPyListOfTuple(vals,(int)nbOfComp,nbOfTuples);
2708       }
2709
2710       bool presenceOfTuple(PyObject *tupl) const
2711       {
2712         mcIdType sz=-1,sw=-1;
2713         mcIdType ival=-1; std::vector<mcIdType> ivval;
2714         const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(tupl,sw,sz,ival,ivval);
2715         std::vector<char> vals(sz);
2716         std::copy(pt,pt+sz,vals.begin());
2717         return self->presenceOfTuple(vals);
2718       }
2719
2720       bool presenceOfValue(PyObject *vals) const
2721       {
2722         mcIdType sz=-1,sw=-1;
2723         mcIdType ival=-1; std::vector<mcIdType> ivval;
2724         const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(vals,sw,sz,ival,ivval);
2725         std::vector<char> vals2(sz);
2726         std::copy(pt,pt+sz,vals2.begin());
2727         return self->presenceOfValue(vals2);
2728       }
2729
2730       mcIdType findIdFirstEqual(PyObject *vals) const
2731       {
2732         mcIdType sz=-1,sw=-1;
2733         mcIdType ival=-1; std::vector<mcIdType> ivval;
2734         const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(vals,sw,sz,ival,ivval);
2735         std::vector<char> vals2(sz);
2736         std::copy(pt,pt+sz,vals2.begin());
2737         return self->findIdFirstEqual(vals2);
2738       }
2739
2740       mcIdType findIdFirstEqualTuple(PyObject *tupl) const
2741       {
2742         mcIdType sz=-1,sw=-1;
2743         mcIdType ival=-1; std::vector<mcIdType> ivval;
2744         const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(tupl,sw,sz,ival,ivval);
2745         std::vector<char> vals(sz);
2746         std::copy(pt,pt+sz,vals.begin());
2747         return self->findIdFirstEqualTuple(vals);
2748       }
2749
2750       mcIdType findIdSequence(PyObject *strOrListOfInt) const
2751       {
2752         mcIdType sz=-1,sw=-1;
2753         mcIdType ival=-1; std::vector<mcIdType> ivval;
2754         const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(strOrListOfInt,sw,sz,ival,ivval);
2755         std::vector<char> vals(sz);
2756         std::copy(pt,pt+sz,vals.begin());
2757         return self->findIdSequence(vals);
2758       }
2759
2760       PyObject *getTuple(mcIdType tupleId)
2761       {
2762         std::size_t sz=self->getNumberOfComponents();
2763         INTERP_KERNEL::AutoPtr<char> tmp=new char[sz];
2764         self->getTuple(tupleId,tmp);
2765         PyObject *ret=PyTuple_New(sz);
2766         for(std::size_t i=0;i<sz;i++) PyTuple_SetItem(ret,i,PyInt_FromLong((mcIdType)tmp[i]));
2767         return ret;
2768       }
2769
2770       PyObject *getMaxValue() const
2771       {
2772         mcIdType tmp;
2773         mcIdType r1=(mcIdType)self->getMaxValue(tmp);
2774         PyObject *ret=PyTuple_New(2);
2775         PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
2776         PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
2777         return ret;
2778       }
2779
2780       PyObject *getMinValue() const
2781       {
2782         mcIdType tmp;
2783         mcIdType r1=(mcIdType)self->getMinValue(tmp);
2784         PyObject *ret=PyTuple_New(2);
2785         PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
2786         PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
2787         return ret;
2788       }
2789
2790       mcIdType index(PyObject *obj) const
2791       {
2792         std::size_t nbOfCompo=self->getNumberOfComponents();
2793         switch(nbOfCompo)
2794           {
2795           case 1:
2796             {
2797               if(PyInt_Check(obj))
2798                 {
2799                   char val=(char)PyInt_AS_LONG(obj);
2800                   return self->findIdFirstEqual(val);
2801                 }
2802               else
2803                 throw INTERP_KERNEL::Exception("DataArrayByte::index : 'this' contains one component and trying to find an element which is not an integer !");
2804             }
2805           default:
2806             return MEDCoupling_DataArrayByte_findIdFirstEqualTuple(self,obj);
2807           }
2808       }
2809
2810       bool __contains__(PyObject *obj) const
2811       {
2812         std::size_t nbOfCompo=self->getNumberOfComponents();
2813         switch(nbOfCompo)
2814           {
2815           case 0:
2816             return false;
2817           case 1:
2818             {
2819               if(PyInt_Check(obj))
2820                 {
2821                   char val=(char)PyInt_AS_LONG(obj);
2822                   return self->presenceOfValue(val);
2823                 }
2824               else
2825                 throw INTERP_KERNEL::Exception("DataArrayByte::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
2826             }
2827           default:
2828             return MEDCoupling_DataArrayByte_presenceOfTuple(self,obj);
2829           }
2830       }
2831
2832 #ifdef WITH_NUMPY
2833       PyObject *toNumPyArray() // not const. It is not a bug !
2834       {
2835         return ToNumPyArray<DataArrayByte,char>(self,NPY_INT8,"DataArrayByte");
2836       }
2837 #endif
2838
2839       DataArrayByte *__setitem__(PyObject *obj, PyObject *value)
2840       {
2841         self->checkAllocated();
2842         const char msg[]="Unexpected situation in __setitem__ !";
2843         mcIdType nbOfTuples(self->getNumberOfTuples());
2844         int nbOfComponents((int)self->getNumberOfComponents());
2845         mcIdType sw1,sw2;
2846         int int1;
2847         std::vector<int> v1;
2848         DataArrayIdType *d1=0;
2849         DataArrayIntTuple *dd1=0;
2850         convertIntStarLikePyObjToCpp(value,sw1,int1,v1,d1,dd1);
2851         mcIdType it1,ic1;
2852         std::vector<mcIdType> vt1,vc1;
2853         std::pair<mcIdType, std::pair<mcIdType,mcIdType> > pt1,pc1;
2854         DataArrayIdType *dt1=0,*dc1=0;
2855         convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw2,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1);
2856         MCAuto<DataArrayIdType> tmp;
2857         char i1 = (char)int1;
2858         switch(sw2)
2859           {
2860           case 1:
2861             {
2862               switch(sw1)
2863                 {
2864                 case 1:
2865                   self->setPartOfValuesSimple1(i1,it1,it1+1,1,0,nbOfComponents,1);
2866                   return self;
2867                 default:
2868                   throw INTERP_KERNEL::Exception(msg);
2869                 }
2870               break;
2871             }
2872           case 2:
2873             {
2874               switch(sw1)
2875                 {
2876                 case 1:
2877                   self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1);
2878                   return self;
2879                 default:
2880                   throw INTERP_KERNEL::Exception(msg);
2881                 }
2882               break;
2883             }
2884           case 3:
2885             {
2886               switch(sw1)
2887                 {
2888                 case 1:
2889                   self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1);
2890                   return self;
2891                 default:
2892                   throw INTERP_KERNEL::Exception(msg);
2893                 }
2894               break;
2895             }
2896           case 4:
2897             {
2898               switch(sw1)
2899                 {
2900                 case 1:
2901                   self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1);
2902                   return self;
2903                 default:
2904                   throw INTERP_KERNEL::Exception(msg);
2905                 }
2906               break;
2907             }
2908           case 5:
2909             {
2910               switch(sw1)
2911                 {
2912                 case 1:
2913                   self->setPartOfValuesSimple1(i1,it1,it1+1,1,ic1,ic1+1,1);
2914                   return self;
2915                 default:
2916                   throw INTERP_KERNEL::Exception(msg);
2917                 }
2918               break;
2919             }
2920           case 6:
2921             {
2922               switch(sw1)
2923                 {
2924                 case 1:
2925                   self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1);
2926                   return self;
2927                 default:
2928                   throw INTERP_KERNEL::Exception(msg);
2929                 }
2930               break;
2931             }
2932           case 7:
2933             {
2934               switch(sw1)
2935                 {
2936                 case 1:
2937                   self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1);
2938                   return self;
2939                 default:
2940                   throw INTERP_KERNEL::Exception(msg);
2941                 }
2942               break;
2943             }
2944           case 8:
2945             {
2946               switch(sw1)
2947                 {
2948                 case 1:
2949                   self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1);
2950                   return self;
2951                 default:
2952                   throw INTERP_KERNEL::Exception(msg);
2953                 }
2954               break;
2955             }
2956           case 9:
2957             {
2958               switch(sw1)
2959                 {
2960                 case 1:
2961                   self->setPartOfValuesSimple2(i1,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size());
2962                   return self;
2963                 default:
2964                   throw INTERP_KERNEL::Exception(msg);
2965                 }
2966               break;
2967             }
2968           case 10:
2969             {
2970               switch(sw1)
2971                 {
2972                 case 1:
2973                   self->setPartOfValuesSimple2(i1,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size());
2974                   return self;
2975                 default:
2976                   throw INTERP_KERNEL::Exception(msg);
2977                 }
2978               break;
2979             }
2980           case 11:
2981             {
2982               switch(sw1)
2983                 {
2984                 case 1:
2985                   self->setPartOfValuesSimple4(i1,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size());
2986                   return self;
2987                 default:
2988                   throw INTERP_KERNEL::Exception(msg);
2989                 }
2990               break;
2991             }
2992           case 12:
2993             {
2994               switch(sw1)
2995                 {
2996                 case 1:
2997                   self->setPartOfValuesSimple2(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size());
2998                   return self;
2999                 default:
3000                   throw INTERP_KERNEL::Exception(msg);
3001                 }
3002               break;
3003             }
3004           case 13:
3005             {
3006               switch(sw1)
3007                 {
3008                 case 1:
3009                   self->setPartOfValuesSimple1(i1,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second);
3010                   return self;
3011                 default:
3012                   throw INTERP_KERNEL::Exception(msg);
3013                 }
3014               break;
3015             }
3016           case 14:
3017             {
3018               switch(sw1)
3019                 {
3020                 case 1:
3021                   self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second);
3022                   return self;
3023                 default:
3024                   throw INTERP_KERNEL::Exception(msg);
3025                 }
3026               break;
3027             }
3028           case 15:
3029             {
3030               switch(sw1)
3031                 {
3032                 case 1:
3033                   self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second);
3034                   return self;
3035                 default:
3036                   throw INTERP_KERNEL::Exception(msg);
3037                 }
3038               break;
3039             }
3040           case 16:
3041             {
3042               switch(sw1)
3043                 {
3044                 case 1:
3045                   self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second);
3046                   return self;
3047                 default:
3048                   throw INTERP_KERNEL::Exception(msg);
3049                 }
3050               break;
3051             }
3052           default:
3053             throw INTERP_KERNEL::Exception(msg);
3054           }
3055         return self;
3056       }
3057     }
3058   };
3059
3060   class DataArrayByteTuple;
3061
3062   class DataArrayByteIterator
3063   {
3064   public:
3065     DataArrayByteIterator(DataArrayByte *da);
3066     ~DataArrayByteIterator();
3067   };
3068
3069   class DataArrayByteTuple
3070   {
3071   public:
3072     std::string repr() const;
3073     DataArrayByte *buildDAByte(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
3074     %extend
3075     {
3076       std::string __str__() const
3077       {
3078         return self->repr();
3079       }
3080
3081       char __int__() const
3082       {
3083         return self->byteValue();
3084       }
3085
3086       DataArrayByte *buildDAByte()
3087       {
3088         return self->buildDAByte(1,self->getNumberOfCompo());
3089       }
3090     }
3091   };
3092
3093   class DataArrayAsciiCharIterator;
3094
3095   class DataArrayAsciiChar : public DataArrayChar
3096   {
3097   public:
3098     static DataArrayAsciiChar *New();
3099     DataArrayAsciiCharIterator *iterator();
3100     DataArrayAsciiChar *performCopyOrIncrRef(bool deepCopy) const;
3101     char asciiCharValue() const;
3102     %extend
3103     {
3104       DataArrayAsciiChar()
3105         {
3106           return DataArrayAsciiChar::New();
3107         }
3108
3109       static DataArrayAsciiChar *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
3110       {
3111         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) !";
3112         if(PyList_Check(elt0) || PyTuple_Check(elt0))
3113           {
3114             if(nbOfTuples)
3115               {
3116                 if(PyInt_Check(nbOfTuples))
3117                   {
3118                     mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
3119                     if(nbOfTuples1<0)
3120                       throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive set of allocated memory !");
3121                     if(nbOfComp)
3122                       {
3123                         if(PyInt_Check(nbOfComp))
3124                           {//DataArrayAsciiChar.New([1,3,4,5],2,2)
3125                             mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
3126                             if(nbOfCompo<0)
3127                               throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !");
3128                             MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3129                             std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
3130                             ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3131                             return ret.retn();
3132                           }
3133                         else
3134                           throw INTERP_KERNEL::Exception(msg);
3135                       }
3136                     else
3137                       {//DataArrayAsciiChar.New([1,3,4],3)
3138                         MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3139                         mcIdType tmpp1=-1;
3140                         std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
3141                         ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3142                         return ret.retn();
3143                       }
3144                   }
3145                 else if(PyString_Check(nbOfTuples))
3146                   {
3147                     if(PyString_Size(nbOfTuples)!=1)
3148                       throw INTERP_KERNEL::Exception(msg);
3149                     //DataArrayAsciiChar.New(["abc","de","fghi"],"t")
3150                     std::vector<std::string> tmp;
3151                     if(fillStringVector(elt0,tmp))
3152                       return DataArrayAsciiChar::New(tmp,PyString_AsString(nbOfTuples)[0]);
3153                     else
3154                       throw INTERP_KERNEL::Exception(msg);
3155                   }
3156 %#if PY_VERSION_HEX >= 0x03000000
3157                 else if(PyUnicode_Check(nbOfTuples))
3158                   {
3159                     if(PyUnicode_GET_LENGTH(nbOfTuples)!=1)
3160                       throw INTERP_KERNEL::Exception(msg);
3161                     //DataArrayAsciiChar.New(["abc","de","fghi"],"t")
3162                     std::vector<std::string> tmp;
3163                     if(fillStringVector(elt0,tmp))
3164                       return DataArrayAsciiChar::New(tmp,PyUnicode_AsUTF8(nbOfTuples)[0]);
3165                     else
3166                       throw INTERP_KERNEL::Exception(msg);
3167                   }
3168 %#endif
3169                 else
3170                   throw INTERP_KERNEL::Exception(msg);
3171               }
3172             else
3173               {
3174                 std::vector<std::string> tmmp;
3175                 if(fillStringVector(elt0,tmmp))
3176                   //DataArrayAsciiChar.New(["abc","de","fghi"])
3177                   return DataArrayAsciiChar::New(tmmp,' ');
3178                 else
3179                   {
3180                     // DataArrayAsciiChar.New([1,3,4])
3181                     MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3182                     mcIdType tmpp1=-1,tmpp2=-1;
3183                     std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
3184                     ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3185                     return ret.retn();
3186                   }
3187               }
3188           }
3189         else if(PyInt_Check(elt0))
3190           {
3191             mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(elt0));
3192             if(nbOfTuples1<0)
3193               throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive set of allocated memory !");
3194             if(nbOfTuples)
3195               {
3196                 if(!nbOfComp)
3197                   {
3198                     if(PyInt_Check(nbOfTuples))
3199                       {//DataArrayAsciiChar.New(5,2)
3200                         mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfTuples));
3201                         if(nbOfCompo<0)
3202                           throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !");
3203                         MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3204                         ret->alloc(nbOfTuples1,nbOfCompo);
3205                         return ret.retn();
3206                       }
3207                     else
3208                       throw INTERP_KERNEL::Exception(msg);
3209                   }
3210                 else
3211                   throw INTERP_KERNEL::Exception(msg);
3212               }
3213             else
3214               {//DataArrayAsciiChar.New(5)
3215                 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3216                 ret->alloc(nbOfTuples1,1);
3217                 return ret.retn();
3218               }
3219           }
3220         else
3221           throw INTERP_KERNEL::Exception(msg);
3222       }
3223
3224       DataArrayAsciiChar(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
3225         {
3226           return MEDCoupling_DataArrayAsciiChar_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
3227         }
3228
3229       std::string __repr__() const
3230       {
3231         std::ostringstream oss;
3232         self->reprQuickOverview(oss);
3233         return oss.str();
3234       }
3235
3236       DataArrayAsciiCharIterator *__iter__()
3237       {
3238         return self->iterator();
3239       }
3240
3241       std::string getIJ(mcIdType tupleId, mcIdType compoId) const
3242       {
3243         char tmp[2]; tmp[1]='\0';
3244         tmp[0]=self->getIJ(tupleId,compoId);
3245         return std::string(tmp);
3246       }
3247
3248       std::string getIJSafe(mcIdType tupleId, mcIdType compoId) const
3249       {
3250         char tmp[2]; tmp[1]='\0';
3251         tmp[0]=self->getIJSafe(tupleId,compoId);
3252         return std::string(tmp);
3253       }
3254
3255       std::string __str__() const
3256       {
3257         return self->repr();
3258       }
3259
3260       PyObject *toStrList() const
3261       {
3262         const char *vals=self->getConstPointer();
3263         std::size_t nbOfComp=self->getNumberOfComponents();
3264         mcIdType nbOfTuples=self->getNumberOfTuples();
3265         return convertCharArrToPyListOfTuple(vals,(int)nbOfComp,nbOfTuples);
3266       }
3267
3268       bool presenceOfTuple(PyObject *tupl) const
3269       {
3270         if(PyString_Check(tupl))
3271           {
3272             Py_ssize_t sz=PyString_Size(tupl);
3273             std::vector<char> vals(sz);
3274             std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin());
3275             return self->presenceOfTuple(vals);
3276           }
3277 %#if PY_VERSION_HEX >= 0x03000000
3278         else if(PyUnicode_Check(tupl))
3279           {
3280             Py_ssize_t sz=PyUnicode_GET_LENGTH(tupl);
3281             std::vector<char> vals(sz);
3282             std::copy(PyUnicode_AsUTF8(tupl),PyUnicode_AsUTF8(tupl)+sz,vals.begin());
3283             return self->presenceOfTuple(vals);
3284           }
3285 %#endif
3286         else
3287           throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfTuple : only strings in input supported !");
3288       }
3289
3290       bool presenceOfValue(PyObject *vals) const
3291       {
3292         if(PyString_Check(vals))
3293           {
3294             Py_ssize_t sz=PyString_Size(vals);
3295             std::vector<char> vals2(sz);
3296             std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin());
3297             return self->presenceOfValue(vals2);
3298           }
3299 %#if PY_VERSION_HEX >= 0x03000000
3300         if(PyUnicode_Check(vals))
3301           {
3302             Py_ssize_t sz=PyUnicode_GET_LENGTH(vals);
3303             std::vector<char> vals2(sz);
3304             std::copy(PyUnicode_AsUTF8(vals),PyUnicode_AsUTF8(vals)+sz,vals2.begin());
3305             return self->presenceOfValue(vals2);
3306           }
3307 %#endif
3308         else
3309           throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfValue : only strings in input supported !");
3310       }
3311
3312       mcIdType findIdFirstEqual(PyObject *vals) const
3313       {
3314         if(PyString_Check(vals))
3315           {
3316             Py_ssize_t sz=PyString_Size(vals);
3317             std::vector<char> vals2(sz);
3318             std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin());
3319             return self->findIdFirstEqual(vals2);
3320           }
3321 %#if PY_VERSION_HEX >= 0x03000000
3322         if(PyUnicode_Check(vals))
3323           {
3324             Py_ssize_t sz=PyUnicode_GET_LENGTH(vals);
3325             std::vector<char> vals2(sz);
3326             std::copy(PyUnicode_AsUTF8(vals),PyUnicode_AsUTF8(vals)+sz,vals2.begin());
3327             return self->findIdFirstEqual(vals2);
3328           }
3329 %#endif
3330         else
3331           throw INTERP_KERNEL::Exception("DataArrayAsciiChar::findIdFirstEqual : only strings in input supported !");
3332       }
3333
3334       mcIdType findIdFirstEqualTuple(PyObject *tupl) const
3335       {
3336         if(PyString_Check(tupl))
3337           {
3338             Py_ssize_t sz=PyString_Size(tupl);
3339             std::vector<char> vals(sz);
3340             std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin());
3341             return self->findIdFirstEqualTuple(vals);
3342           }
3343 %#if PY_VERSION_HEX >= 0x03000000
3344         if(PyUnicode_Check(tupl))
3345           {
3346             Py_ssize_t sz=PyUnicode_GET_LENGTH(tupl);
3347             std::vector<char> vals(sz);
3348             std::copy(PyUnicode_AsUTF8(tupl),PyUnicode_AsUTF8(tupl)+sz,vals.begin());
3349             return self->findIdFirstEqualTuple(vals);
3350           }
3351 %#endif
3352         else
3353           throw INTERP_KERNEL::Exception("DataArrayAsciiChar::findIdFirstEqualTuple : only strings in input supported !");
3354       }
3355
3356       mcIdType findIdSequence(PyObject *strOrListOfInt) const
3357       {
3358         if(PyString_Check(strOrListOfInt))
3359           {
3360             Py_ssize_t sz=PyString_Size(strOrListOfInt);
3361             std::vector<char> vals(sz);
3362             std::copy(PyString_AsString(strOrListOfInt),PyString_AsString(strOrListOfInt)+sz,vals.begin());
3363             return self->findIdSequence(vals);
3364           }
3365 %#if PY_VERSION_HEX >= 0x03000000
3366         else if(PyUnicode_Check(strOrListOfInt))
3367           {
3368             Py_ssize_t sz=PyUnicode_GET_LENGTH(strOrListOfInt);
3369             std::vector<char> vals(sz);
3370             std::copy(PyUnicode_AsUTF8(strOrListOfInt),PyUnicode_AsUTF8(strOrListOfInt)+sz,vals.begin());
3371             return self->findIdSequence(vals);
3372           }
3373 %#endif
3374         else
3375           throw INTERP_KERNEL::Exception("DataArrayAsciiChar::search : only strings in input supported !");
3376       }
3377
3378       PyObject *getTuple(mcIdType tupleId) const
3379       {
3380         std::size_t sz=self->getNumberOfComponents();
3381         INTERP_KERNEL::AutoPtr<char> tmp=new char[sz+1]; tmp[sz]='\0';
3382         self->getTuple(tupleId,tmp);
3383         return PyString_FromString(tmp);
3384       }
3385
3386       PyObject *getMaxValue() const
3387       {
3388         mcIdType tmp;
3389         char tmp2[2]; tmp2[1]='\0';
3390         tmp2[0]=self->getMaxValue(tmp);
3391         PyObject *ret=PyTuple_New(2);
3392         PyTuple_SetItem(ret,0,PyString_FromString(tmp2));
3393         PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
3394         return ret;
3395       }
3396
3397       PyObject *getMinValue() const
3398       {
3399         mcIdType tmp;
3400         char tmp2[2]; tmp2[1]='\0';
3401         tmp2[0]=self->getMinValue(tmp);
3402         PyObject *ret=PyTuple_New(2);
3403         PyTuple_SetItem(ret,0,PyString_FromString(tmp2));
3404         PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
3405         return ret;
3406       }
3407
3408       mcIdType index(PyObject *obj) const
3409       {
3410         std::size_t nbOfCompo=self->getNumberOfComponents();
3411         switch(nbOfCompo)
3412           {
3413           case 1:
3414             {
3415               if(PyString_Check(obj))
3416                 {
3417                   Py_ssize_t sz=PyString_Size(obj);
3418                   char *pt=PyString_AsString(obj);
3419                   if(sz==1)
3420                     return self->findIdFirstEqual(pt[0]);
3421                   else
3422                     throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find a string with size different from 1 !");
3423                 }
3424 %#if PY_VERSION_HEX >= 0x03000000
3425               if(PyUnicode_Check(obj))
3426                 {
3427                   Py_ssize_t sz;
3428                   const char *pt=PyUnicode_AsUTF8AndSize(obj, &sz);
3429                   if(sz==1)
3430                     return self->findIdFirstEqual(pt[0]);
3431                   else
3432                     throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find a string with size different from 1 !");
3433                 }
3434 %#endif
3435               else
3436                 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find an element which is not an integer !");
3437             }
3438           default:
3439             return MEDCoupling_DataArrayAsciiChar_findIdFirstEqualTuple(self,obj);
3440           }
3441       }
3442
3443       bool __contains__(PyObject *obj) const
3444       {
3445         std::size_t nbOfCompo=self->getNumberOfComponents();
3446         switch(nbOfCompo)
3447           {
3448           case 0:
3449             return false;
3450           case 1:
3451             {
3452               if(PyString_Check(obj))
3453                 {
3454                   Py_ssize_t sz=PyString_Size(obj);
3455                   char *pt=PyString_AsString(obj);
3456                   if(sz==1)
3457                     return self->presenceOfValue(pt[0]);
3458                   else
3459                     throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find a string with size different from 1 !");
3460                 }
3461 %#if PY_VERSION_HEX >= 0x03000000
3462               if(PyUnicode_Check(obj))
3463                 {
3464                   Py_ssize_t sz;
3465                   const char *pt=PyUnicode_AsUTF8AndSize(obj, &sz);
3466                   if(sz==1)
3467                     return self->presenceOfValue(pt[0]);
3468                   else
3469                     throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find a string with size different from 1 !");
3470                 }
3471 %#endif
3472               else
3473                 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
3474             }
3475           default:
3476             return MEDCoupling_DataArrayAsciiChar_presenceOfTuple(self,obj);
3477           }
3478       }
3479
3480       PyObject *__getitem__(PyObject *obj) const
3481       {
3482         mcIdType sw,iTypppArr;
3483         std::vector<mcIdType> stdvecTyyppArr;
3484         std::pair<mcIdType, std::pair<mcIdType,mcIdType> > sTyyppArr;
3485         MEDCoupling::DataArrayIdType *daIntTyypp=0;
3486         convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,self->getNumberOfTuples(),sw,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp);
3487         switch(sw)
3488           {
3489           case 1:
3490             return MEDCoupling_DataArrayAsciiChar_getTuple(self,iTypppArr);
3491           case 2:
3492             return convertDataArrayChar(self->selectByTupleIdSafe(&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size()), SWIG_POINTER_OWN | 0 );
3493           case 3:
3494             return convertDataArrayChar(self->selectByTupleIdSafeSlice(sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second), SWIG_POINTER_OWN | 0 );
3495           case 4:
3496             return convertDataArrayChar(self->selectByTupleIdSafe(daIntTyypp->begin(),daIntTyypp->end()), SWIG_POINTER_OWN | 0 );
3497           default:
3498             throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__getitem__ : supporting int, list of int, tuple of int, DataArrayIdType and slice in input !");
3499           }
3500       }
3501
3502       DataArrayAsciiChar *__setitem__(PyObject *obj, PyObject *value)
3503       {
3504         static const char msg[]="DataArrayAsciiChar::__setitem__ : supporting int, list of int, tuple of int, DataArrayIdType and slice in input, and 4 types accepted in value : string, list or tuple of strings having same size, not null DataArrayChar instance.";
3505         mcIdType sw1,iTypppArr;
3506         std::vector<mcIdType> stdvecTyyppArr;
3507         std::pair<mcIdType, std::pair<mcIdType,mcIdType> > sTyyppArr;
3508         MEDCoupling::DataArrayIdType *daIntTyypp=0;
3509         mcIdType nbOfCompo=ToIdType(self->getNumberOfComponents());
3510         mcIdType nbOfTuples=self->getNumberOfTuples();
3511         convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbOfTuples,sw1,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp);
3512         mcIdType sw2;
3513         char vc; std::string sc; std::vector<std::string> vsc; DataArrayChar *dacc=0;
3514         convertObjToPossibleCpp6(value,sw2,vc,sc,vsc,dacc);
3515         switch(sw1)
3516           {
3517           case 1:
3518             {//obj int
3519               switch(sw2)
3520                 {//value char
3521                 case 1:
3522                   {
3523                     self->setPartOfValuesSimple3(vc,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1);
3524                     return self;
3525                   }
3526                   //value string
3527                 case 2:
3528                   {
3529                     MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3530                     self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3531                     return self;
3532                   }
3533                   //value vector<string>
3534                 case 3:
3535                   {
3536                     MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3537                     self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3538                     return self;
3539                   }
3540                   //value DataArrayChar
3541                 case 4:
3542                   {
3543                     self->setPartOfValues3(dacc,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3544                     return self;
3545                   }
3546                 default:
3547                   throw INTERP_KERNEL::Exception(msg);
3548                 }
3549             }
3550           case 2:
3551             {//obj list-tuple[int]
3552               switch(sw2)
3553                 {
3554                   {//value char
3555                   case 1:
3556                     {
3557                       self->setPartOfValuesSimple3(vc,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1);
3558                       return self;
3559                     }
3560                     //value string
3561                   case 2:
3562                     {
3563                       MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3564                       self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3565                       return self;
3566                     }
3567                     //value vector<string>
3568                   case 3:
3569                     {
3570                       MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3571                       self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3572                       return self;
3573                     }
3574                     //value DataArrayChar
3575                   case 4:
3576                     {
3577                       self->setPartOfValues3(dacc,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3578                       return self;
3579                     }
3580                   default:
3581                     throw INTERP_KERNEL::Exception(msg);
3582                   }
3583                 }
3584             }
3585           case 3:
3586             {//slice
3587               switch(sw2)
3588                 {
3589                   {//value char
3590                   case 1:
3591                     {
3592                       self->setPartOfValuesSimple1(vc,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1);
3593                       return self;
3594                     }
3595                     //value string
3596                   case 2:
3597                     {
3598                       MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3599                       self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3600                       return self;
3601                     }
3602                     //value vector<string>
3603                   case 3:
3604                     {
3605                       MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3606                       self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3607                       return self;
3608                     }
3609                     //value DataArrayChar
3610                   case 4:
3611                     {
3612                       self->setPartOfValues1(dacc,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3613                       return self;
3614                     }
3615                   default:
3616                     throw INTERP_KERNEL::Exception(msg);
3617                   }
3618                 }
3619             }
3620           case 4:
3621             {//DataArrayIdType
3622               switch(sw2)
3623                 {
3624                   {//value char
3625                   case 1:
3626                     {
3627                       self->setPartOfValuesSimple3(vc,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1);
3628                       return self;
3629                     }
3630                     //value string
3631                   case 2:
3632                     {
3633                       MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3634                       self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3635                       return self;
3636                     }
3637                     //value vector<string>
3638                   case 3:
3639                     {
3640                       MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3641                       self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3642                       return self;
3643                     }
3644                     //value DataArrayChar
3645                   case 4:
3646                     {
3647                       self->setPartOfValues3(dacc,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3648                       return self;
3649                     }
3650                   default:
3651                     throw INTERP_KERNEL::Exception(msg);
3652                   }
3653                 }
3654             }
3655           default:
3656             throw INTERP_KERNEL::Exception(msg);
3657           }
3658       }
3659     }
3660   };
3661
3662   class DataArrayAsciiCharTuple;
3663
3664   class DataArrayAsciiCharIterator
3665   {
3666   public:
3667     DataArrayAsciiCharIterator(DataArrayAsciiChar *da);
3668     ~DataArrayAsciiCharIterator();
3669     %extend
3670     {
3671       PyObject *next()
3672       {
3673         DataArrayAsciiCharTuple *ret=self->nextt();
3674         if(ret)
3675           return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayAsciiCharTuple,SWIG_POINTER_OWN | 0);
3676         else
3677           {
3678             PyErr_SetString(PyExc_StopIteration,"No more data.");
3679             return 0;
3680           }
3681       }
3682     }
3683   };
3684
3685   class DataArrayAsciiCharTuple
3686   {
3687   public:
3688     std::size_t getNumberOfCompo() const;
3689     DataArrayAsciiChar *buildDAAsciiChar(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
3690     %extend
3691     {
3692       std::string __str__() const
3693       {
3694         return self->repr();
3695       }
3696
3697       DataArrayAsciiChar *buildDAAsciiChar()
3698       {
3699         return self->buildDAAsciiChar(1,self->getNumberOfCompo());
3700       }
3701     }
3702   };
3703
3704 }
3705
3706 %inline
3707 {
3708   MEDCoupling::DataArrayByte *FromPyIntPtrToDataArrayByte(long intPtr)
3709   {
3710     MEDCoupling::DataArrayByte *ret(reinterpret_cast<MEDCoupling::DataArrayByte *>(intPtr));
3711     return ret;
3712   }
3713 }
3714
3715 %include "DataArrayInt.i"
3716
3717
3718 %pythoncode %{
3719 def MEDCouplingStdReduceFunct(cls,params):
3720     a,b=params
3721     ret=object.__new__(cls)
3722     ret.__init__(*a)
3723     ret.__setstate__(b)
3724     return ret
3725
3726 def MEDCouplingDataArrayDoubleReduce(self):
3727     if not MEDCouplingHasNumPyBindings():
3728       raise InterpKernelException("PyWrap of DataArrayDouble.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3729     return MEDCouplingStdReduceFunct,(DataArrayDouble,((self.toNumPyArray(),),(self.__getstate__()),))
3730
3731 def MEDCouplingDataArrayInt32Reduce(self):
3732     if not MEDCouplingHasNumPyBindings():
3733       raise InterpKernelException("PyWrap of DataArrayIdType.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3734     return MEDCouplingStdReduceFunct,(DataArrayInt32,((self.toNumPyArray(),),(self.__getstate__()),))
3735
3736 def MEDCouplingDataArrayInt64Reduce(self):
3737     if not MEDCouplingHasNumPyBindings():
3738       raise InterpKernelException("PyWrap of DataArrayIdType.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3739     return MEDCouplingStdReduceFunct,(DataArrayInt64,((self.toNumPyArray(),),(self.__getstate__()),))
3740
3741 def MEDCouplingDataArrayByteReduce(self):
3742     if not MEDCouplingHasNumPyBindings():
3743       raise InterpKernelException("PyWrap of DataArrayByte.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3744     return MEDCouplingStdReduceFunct,(DataArrayByte,((self.toNumPyArray(),),(self.__getstate__()),))
3745
3746 def MEDCouplingDataArrayFloatReduce(self):
3747     if not MEDCouplingHasNumPyBindings():
3748       raise InterpKernelException("PyWrap of DataArrayFloat.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3749     return MEDCouplingStdReduceFunct,(DataArrayFloat,((self.toNumPyArray(),),(self.__getstate__()),))
3750
3751 if MEDCouplingUse64BitIDs():
3752   DataArrayInt=DataArrayInt64
3753 else:
3754   DataArrayInt=DataArrayInt32
3755 pass
3756
3757 %}