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<DataArrayInt64> convertToInt64Arr() const;
1096     MCAuto<DataArrayDouble> selectPartDef(const PartDefinition* pd) const;
1097     MCAuto<DataArrayDouble> cumSum() const;
1098     MCAuto<DataArrayFloat> convertToFloatArr() const;
1099     %extend
1100     {
1101       DataArrayDouble()
1102       {
1103         return DataArrayDouble::New();
1104       }
1105
1106       static DataArrayDouble *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
1107       {
1108         return DataArrayT_New<double>(elt0,nbOfTuples,elt2);
1109       }
1110
1111       DataArrayDouble(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
1112       {
1113         return MEDCoupling_DataArrayDouble_New__SWIG_1(elt0,nbOfTuples,elt2);
1114       }
1115
1116       void pushBackValsSilent(PyObject *li)
1117       {
1118         double val;
1119         std::vector<double> bb;
1120         mcIdType sw; mcIdType nbTuples=-1;
1121         const char msg[]="Python wrap of DataArrayDouble::pushBackValsSilent : ";
1122         const double *tmp=convertObjToPossibleCpp5_SingleCompo(li,sw,val,bb,msg,true,nbTuples);
1123         self->pushBackValsSilent(tmp,tmp+nbTuples);
1124       }
1125
1126       std::string __repr__() const
1127       {
1128         std::ostringstream oss;
1129         self->reprQuickOverview(oss);
1130         return oss.str();
1131       }
1132
1133       std::string __str__() const
1134       {
1135         return self->reprNotTooLong();
1136       }
1137
1138       double __float__() const
1139       {
1140         return self->doubleValue();
1141       }
1142
1143       mcIdType __len__() const
1144       {
1145         if(self->isAllocated())
1146           {
1147             return self->getNumberOfTuples();
1148           }
1149         else
1150           {
1151             throw INTERP_KERNEL::Exception("DataArrayDouble::__len__ : Instance is NOT allocated !");
1152           }
1153       }
1154
1155       PyObject *asArcOfCircle() const
1156       {
1157         double center[2],radius,ang;
1158         self->asArcOfCircle(center,radius,ang);
1159         PyObject *ret(PyTuple_New(3));
1160         {
1161           PyObject *ret0(PyList_New(2));
1162           PyList_SetItem(ret0,0,PyFloat_FromDouble(center[0]));
1163           PyList_SetItem(ret0,1,PyFloat_FromDouble(center[1]));
1164           PyTuple_SetItem(ret,0,ret0);
1165         }
1166         PyTuple_SetItem(ret,1,PyFloat_FromDouble(radius));
1167         PyTuple_SetItem(ret,2,PyFloat_FromDouble(ang));
1168         return ret;
1169       }
1170
1171       DataArrayDoubleIterator *__iter__()
1172       {
1173         return self->iterator();
1174       }
1175
1176       void setValues(PyObject *li, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
1177       {
1178         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 !";
1179         if(PyList_Check(li) || PyTuple_Check(li))
1180           {
1181             if(nbOfTuples && nbOfTuples != Py_None)
1182               {
1183                 if(PyInt_Check(nbOfTuples))
1184                   {
1185                     mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
1186                     if(nbOfTuples1<0)
1187                       throw INTERP_KERNEL::Exception("DataArrayDouble::setValues : should be a positive set of allocated memory !");
1188                     if(nbOfComp && nbOfComp != Py_None)
1189                       {
1190                         if(PyInt_Check(nbOfComp))
1191                           {//DataArrayDouble.setValues([1.,3.,4.,5.],2,2)
1192                             mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
1193                             if(nbOfCompo<0)
1194                               throw INTERP_KERNEL::Exception("DataArrayDouble::setValues : should be a positive number of components !");
1195                             std::vector<double> tmp=fillArrayWithPyListDbl2(li,nbOfTuples1,nbOfCompo);
1196                             self->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1197                           }
1198                         else
1199                           throw INTERP_KERNEL::Exception(msg);
1200                       }
1201                     else
1202                       {//DataArrayDouble.setValues([1.,3.,4.],3)
1203                         mcIdType tmpp1=-1;
1204                         std::vector<double> tmp=fillArrayWithPyListDbl2(li,nbOfTuples1,tmpp1);
1205                         self->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1206                       }
1207                   }
1208                 else
1209                   throw INTERP_KERNEL::Exception(msg);
1210               }
1211             else
1212               {// DataArrayDouble.setValues([1.,3.,4.])
1213                 mcIdType tmpp1=-1,tmpp2=-1;
1214                 std::vector<double> tmp=fillArrayWithPyListDbl2(li,tmpp1,tmpp2);
1215                 self->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1216               }
1217           }
1218         else
1219           throw INTERP_KERNEL::Exception(msg);
1220       }
1221
1222       PyObject *getValues() const
1223       {
1224         const double *vals(self->begin());
1225         return convertDblArrToPyList<double>(vals,self->getNbOfElems());
1226       }
1227
1228 #ifdef WITH_NUMPY
1229       PyObject *toNumPyArray() // not const. It is not a bug !
1230       {
1231         return ToNumPyArray<DataArrayDouble,double>(self,NPY_DOUBLE,"DataArrayDouble");
1232       }
1233 #endif
1234
1235       PyObject *isEqualIfNotWhy(const DataArrayDouble& other, double prec) const
1236       {
1237         std::string ret1;
1238         bool ret0=self->isEqualIfNotWhy(other,prec,ret1);
1239         PyObject *ret=PyTuple_New(2);
1240         PyObject *ret0Py=ret0?Py_True:Py_False;
1241         Py_XINCREF(ret0Py);
1242         PyTuple_SetItem(ret,0,ret0Py);
1243         PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
1244         return ret;
1245       }
1246
1247       PyObject *getValuesAsTuple() const
1248       {
1249         const double *vals(self->begin());
1250         std::size_t nbOfComp(self->getNumberOfComponents());
1251         mcIdType nbOfTuples(self->getNumberOfTuples());
1252         return convertDblArrToPyListOfTuple<double>(vals,nbOfComp,nbOfTuples);
1253       }
1254
1255       static PyObject *ComputeIntegralOfSeg2IntoTri3(PyObject *seg2, PyObject *tri3)
1256       {
1257         const char msg[]="Python wrap of DataArrayDouble::ComputeIntegralOfSeg2IntoTri3 : ";
1258         double val,val2;
1259         DataArrayDouble *a,*a2;
1260         DataArrayDoubleTuple *aa,*aa2;
1261         std::vector<double> bb,bb2;
1262         mcIdType sw;
1263         const double *seg2Ptr(convertObjToPossibleCpp5_Safe(seg2,sw,val,a,aa,bb,msg,2,2,true));
1264         const double *tri3Ptr(convertObjToPossibleCpp5_Safe(tri3,sw,val2,a2,aa2,bb2,msg,3,2,true));
1265         //
1266         double res0[3],res1;
1267         DataArrayDouble::ComputeIntegralOfSeg2IntoTri3(seg2Ptr,tri3Ptr,res0,res1);
1268         PyObject *ret(PyTuple_New(2)),*ret0(PyTuple_New(3));
1269         PyTuple_SetItem(ret0,0,PyFloat_FromDouble(res0[0]));
1270         PyTuple_SetItem(ret0,1,PyFloat_FromDouble(res0[1]));
1271         PyTuple_SetItem(ret0,2,PyFloat_FromDouble(res0[2]));
1272         PyTuple_SetItem(ret,0,ret0);
1273         PyTuple_SetItem(ret,1,PyFloat_FromDouble(res1));
1274         return ret;
1275       }
1276
1277       DataArrayDouble *symmetry3DPlane(PyObject *point, PyObject *normalVector)
1278       {
1279         const char msg[]="Python wrap of DataArrayDouble::symmetry3DPlane : ";
1280         double val,val2;
1281         DataArrayDouble *a,*a2;
1282         DataArrayDoubleTuple *aa,*aa2;
1283         std::vector<double> bb,bb2;
1284         mcIdType sw;
1285         const double *centerPtr(convertObjToPossibleCpp5_Safe(point,sw,val,a,aa,bb,msg,1,3,true));
1286         const double *vectorPtr(convertObjToPossibleCpp5_Safe(normalVector,sw,val2,a2,aa2,bb2,msg,1,3,true));
1287         MCAuto<DataArrayDouble> ret(self->symmetry3DPlane(centerPtr,vectorPtr));
1288         return ret.retn();
1289       }
1290
1291       static PyObject *GiveBaseForPlane(PyObject *normalVector)
1292       {
1293         const char msg[]="Python wrap of DataArrayDouble::GiveBaseForPlane : ";
1294         double val;
1295         DataArrayDouble *a;
1296         DataArrayDoubleTuple *aa;
1297         std::vector<double> bb,bb2;
1298         mcIdType sw;
1299         const double *vectorPtr(convertObjToPossibleCpp5_Safe(normalVector,sw,val,a,aa,bb,msg,1,3,true));
1300         double res[9];
1301         DataArrayDouble::GiveBaseForPlane(vectorPtr,res);
1302         return convertDblArrToPyListOfTuple<double>(res,3,3);
1303       }
1304
1305       DataArrayDouble *fromCartToCylGiven(const DataArrayDouble *coords, PyObject *center, PyObject *vector) const
1306       {
1307         const char msg[]="Python wrap of DataArrayDouble::fromCartToCylGiven : ";
1308         double val,val2;
1309         DataArrayDouble *a,*a2;
1310         DataArrayDoubleTuple *aa,*aa2;
1311         std::vector<double> bb,bb2;
1312         mcIdType sw;
1313         const double *centerPtr=convertObjToPossibleCpp5_Safe(center,sw,val,a,aa,bb,msg,1,3,true);
1314         const double *vectorPtr=convertObjToPossibleCpp5_Safe(vector,sw,val2,a2,aa2,bb2,msg,1,3,true);
1315         return self->fromCartToCylGiven(coords,centerPtr,vectorPtr);
1316       }
1317
1318       DataArrayDouble *renumber(PyObject *li)
1319       {
1320         void *da=0;
1321         int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 |  0 );
1322         if (!SWIG_IsOK(res1))
1323           {
1324             mcIdType size;
1325             INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1326             if(size!=self->getNumberOfTuples())
1327               {
1328                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1329               }
1330             return self->renumber(tmp);
1331           }
1332         else
1333           {
1334             DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1335             if(!da2)
1336               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1337             da2->checkAllocated();
1338             mcIdType size=self->getNumberOfTuples();
1339             if(size!=self->getNumberOfTuples())
1340               {
1341                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1342               }
1343             return self->renumber(da2->getConstPointer());
1344           }
1345       }
1346
1347       DataArrayDouble *renumberR(PyObject *li)
1348       {
1349         void *da=0;
1350         int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 |  0 );
1351         if (!SWIG_IsOK(res1))
1352           {
1353             mcIdType size;
1354             INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1355             if(size!=self->getNumberOfTuples())
1356               {
1357                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1358               }
1359             return self->renumberR(tmp);
1360           }
1361         else
1362           {
1363             DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1364             if(!da2)
1365               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1366             da2->checkAllocated();
1367             mcIdType size=self->getNumberOfTuples();
1368             if(size!=self->getNumberOfTuples())
1369               {
1370                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1371               }
1372             return self->renumberR(da2->getConstPointer());
1373           }
1374       }
1375
1376       DataArrayDouble *renumberAndReduce(PyObject *li, mcIdType newNbOfTuple)
1377       {
1378         void *da=0;
1379         int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 |  0 );
1380         if (!SWIG_IsOK(res1))
1381           {
1382             mcIdType size;
1383             INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1384             if(size!=self->getNumberOfTuples())
1385               {
1386                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1387               }
1388             return self->renumberAndReduce(tmp,newNbOfTuple);
1389           }
1390         else
1391           {
1392             DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1393             if(!da2)
1394               throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1395             da2->checkAllocated();
1396             mcIdType size=self->getNumberOfTuples();
1397             if(size!=self->getNumberOfTuples())
1398               {
1399                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1400               }
1401             return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
1402           }
1403       }
1404
1405       PyObject *minimalDistanceTo(const DataArrayDouble *other) const
1406       {
1407         mcIdType thisTupleId,otherTupleId;
1408         double r0=self->minimalDistanceTo(other,thisTupleId,otherTupleId);
1409         PyObject *ret=PyTuple_New(3);
1410         PyTuple_SetItem(ret,0,PyFloat_FromDouble(r0));
1411         PyTuple_SetItem(ret,1,PyInt_FromLong(thisTupleId));
1412         PyTuple_SetItem(ret,2,PyInt_FromLong(otherTupleId));
1413         return ret;
1414       }
1415
1416       PyObject *getMaxValue() const
1417       {
1418         mcIdType tmp;
1419         double r1=self->getMaxValue(tmp);
1420         PyObject *ret=PyTuple_New(2);
1421         PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1422         PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1423         return ret;
1424       }
1425
1426           PyObject *getMaxAbsValue() const
1427       {
1428         std::size_t tmp;
1429         double r1=self->getMaxAbsValue(tmp);
1430         PyObject *ret=PyTuple_New(2);
1431         PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1432         PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1433         return ret;
1434       }
1435
1436       PyObject *getMaxValue2() const
1437       {
1438         DataArrayIdType *tmp;
1439         double r1=self->getMaxValue2(tmp);
1440         PyObject *ret=PyTuple_New(2);
1441         PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1442         PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1443         return ret;
1444       }
1445
1446       PyObject *getMinValue() const
1447       {
1448         mcIdType tmp;
1449         double r1=self->getMinValue(tmp);
1450         PyObject *ret=PyTuple_New(2);
1451         PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1452         PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1453         return ret;
1454       }
1455
1456       PyObject *getMinValue2() const
1457       {
1458         DataArrayIdType *tmp;
1459         double r1=self->getMinValue2(tmp);
1460         PyObject *ret=PyTuple_New(2);
1461         PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1462         PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1463         return ret;
1464       }
1465
1466       PyObject *getMinMaxPerComponent() const
1467       {
1468         std::size_t nbOfCompo(self->getNumberOfComponents());
1469         INTERP_KERNEL::AutoPtr<double> tmp(new double[2*nbOfCompo]);
1470         self->getMinMaxPerComponent(tmp);
1471         PyObject *ret=convertDblArrToPyListOfTuple<double>(tmp,2,ToIdType(nbOfCompo));
1472         return ret;
1473       }
1474
1475       PyObject *normMaxPerComponent() const
1476       {
1477         std::size_t nbOfCompo(self->getNumberOfComponents());
1478         INTERP_KERNEL::AutoPtr<double> tmp(new double[nbOfCompo]);
1479         self->normMaxPerComponent(tmp);
1480         return convertDblArrToPyList<double>(tmp,ToIdType(nbOfCompo));
1481       }
1482
1483       PyObject *accumulate() const
1484       {
1485         std::size_t sz=self->getNumberOfComponents();
1486         INTERP_KERNEL::AutoPtr<double> tmp=new double[sz];
1487         self->accumulate(tmp);
1488         return convertDblArrToPyList<double>(tmp,ToIdType(sz));
1489       }
1490
1491       DataArrayDouble *accumulatePerChunck(PyObject *indexArr) const
1492       {
1493         mcIdType sw, sz,val;
1494         std::vector<mcIdType> val2;
1495         const mcIdType *bg=convertIntStarLikePyObjToCppIntStar(indexArr,sw,sz,val,val2);
1496         return self->accumulatePerChunck(bg,bg+sz);
1497       }
1498
1499       PyObject *findCommonTuples(double prec, mcIdType limitNodeId=-1) const
1500       {
1501         DataArrayIdType *comm, *commIndex;
1502         self->findCommonTuples(prec,limitNodeId,comm,commIndex);
1503         PyObject *res = PyList_New(2);
1504         PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(comm),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1505         PyList_SetItem(res,1,SWIG_NewPointerObj(SWIG_as_voidptr(commIndex),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1506         return res;
1507       }
1508
1509       PyObject *distanceToTuple(PyObject *tuple) const
1510       {
1511         double val;
1512         DataArrayDouble *a;
1513         DataArrayDoubleTuple *aa;
1514         std::vector<double> bb;
1515         mcIdType sw;
1516         mcIdType tupleId=-1;
1517         std::size_t nbOfCompo=self->getNumberOfComponents();
1518         const double *pt=convertObjToPossibleCpp5_Safe(tuple,sw,val,a,aa,bb,"Python wrap of DataArrayDouble::distanceToTuple",1,(int)nbOfCompo,true);
1519         //
1520         double ret0=self->distanceToTuple(pt,pt+nbOfCompo,tupleId);
1521         PyObject *ret=PyTuple_New(2);
1522         PyTuple_SetItem(ret,0,PyFloat_FromDouble(ret0));
1523         PyTuple_SetItem(ret,1,PyInt_FromLong(tupleId));
1524         return ret;
1525       }
1526
1527       void setSelectedComponents(const DataArrayDouble *a, PyObject *li)
1528       {
1529         std::vector<std::size_t> tmp;
1530         convertPyToNewIntArr3(li,tmp);
1531         self->setSelectedComponents(a,tmp);
1532       }
1533
1534       PyObject *explodeComponents() const
1535       {
1536         std::vector< MCAuto<DataArrayDouble> > retCpp(self->explodeComponents());
1537         std::size_t sz(retCpp.size());
1538         PyObject *res(PyList_New(sz));
1539         for(std::size_t i=0;i<sz;i++)
1540           PyList_SetItem(res,i,SWIG_NewPointerObj(SWIG_as_voidptr(retCpp[i].retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ));
1541         return res;
1542       }
1543
1544       PyObject *getTuple(mcIdType tupleId)
1545       {
1546         std::size_t sz=self->getNumberOfComponents();
1547         INTERP_KERNEL::AutoPtr<double> tmp=new double[sz];
1548         self->getTuple(tupleId,tmp);
1549         return convertDblArrToPyList<double>(tmp,ToIdType(sz));
1550       }
1551
1552       static DataArrayDouble *Aggregate(PyObject *li)
1553       {
1554         std::vector<const DataArrayDouble *> tmp;
1555         convertFromPyObjVectorOfObj<const DataArrayDouble *>(li,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",tmp);
1556         return DataArrayDouble::Aggregate(tmp);
1557       }
1558
1559       static DataArrayDouble *Meld(PyObject *li)
1560       {
1561         std::vector<const DataArrayDouble *> tmp;
1562         convertFromPyObjVectorOfObj<const DataArrayDouble *>(li,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",tmp);
1563         return DataArrayDouble::Meld(tmp);
1564       }
1565
1566       PyObject *computeTupleIdsNearTuples(PyObject *pt, double eps) const
1567       {
1568         double val;
1569         DataArrayDouble *a;
1570         DataArrayDoubleTuple *aa;
1571         std::vector<double> bb;
1572         mcIdType sw;
1573         std::size_t nbComp=self->getNumberOfComponents();
1574         mcIdType nbTuples=-1;
1575         const char msg[]="Python wrap of DataArrayDouble::computeTupleIdsNearTuples : ";
1576         const double *pos=convertObjToPossibleCpp5_Safe2(pt,sw,val,a,aa,bb,msg,(int)nbComp,true,nbTuples);
1577         MCAuto<DataArrayDouble> inpu=DataArrayDouble::New(); inpu->useArray(pos,false,DeallocType::CPP_DEALLOC,nbTuples,nbComp);
1578         DataArrayIdType *c=0,*cI=0;
1579         self->computeTupleIdsNearTuples(inpu,eps,c,cI);
1580         PyObject *ret=PyTuple_New(2);
1581         PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1582         PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1583         return ret;
1584       }
1585
1586       PyObject *areIncludedInMe(const DataArrayDouble *other, double prec) const
1587       {
1588         DataArrayIdType *ret1=0;
1589         bool ret0=self->areIncludedInMe(other,prec,ret1);
1590         PyObject *ret=PyTuple_New(2);
1591         PyObject *ret0Py=ret0?Py_True:Py_False;
1592         Py_XINCREF(ret0Py);
1593         PyTuple_SetItem(ret,0,ret0Py);
1594         PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1595         return ret;
1596       }
1597
1598       PyObject *__getitem__(PyObject *obj)
1599       {
1600         return DataArrayT__getitem<double>(self,obj);
1601       }
1602
1603       DataArrayDouble *__setitem__(PyObject *obj, PyObject *value)
1604       {
1605         return DataArrayT__setitem__<double>(self,obj,value);
1606       }
1607
1608       DataArrayDouble *__neg__() const
1609       {
1610         return self->negate();
1611       }
1612
1613       PyObject *__add__(PyObject *obj)
1614       {
1615         const char msg[]="Unexpected situation in DataArrayDouble.__add__ !";
1616         double val;
1617         DataArrayDouble *a;
1618         DataArrayDoubleTuple *aa;
1619         std::vector<double> bb;
1620         mcIdType sw;
1621         //
1622 #ifndef WITHOUT_AUTOFIELD
1623         void *argp;
1624         if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1625           {
1626             MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1627             if(other)
1628               {
1629                 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1630                 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___radd__Impl(other,tmp);
1631                 Py_XDECREF(tmp);
1632                 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1633               }
1634             else
1635               throw INTERP_KERNEL::Exception(msg);
1636           }
1637 #endif
1638         //
1639         convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1640         switch(sw)
1641           {
1642           case 1:
1643             {
1644               MCAuto<DataArrayDouble> ret=self->deepCopy();
1645               ret->applyLin(1.,val);
1646               return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1647             }
1648           case 2:
1649             {
1650               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1651             }
1652           case 3:
1653             {
1654               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1655               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1656             }
1657           case 4:
1658             {
1659               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1660               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1661             }
1662           default:
1663             throw INTERP_KERNEL::Exception(msg);
1664           }
1665       }
1666
1667       DataArrayDouble *__radd__(PyObject *obj)
1668       {
1669         const char msg[]="Unexpected situation in __radd__ !";
1670         double val;
1671         DataArrayDouble *a;
1672         DataArrayDoubleTuple *aa;
1673         std::vector<double> bb;
1674         mcIdType sw;
1675         convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1676         switch(sw)
1677           {
1678           case 1:
1679             {
1680               MCAuto<DataArrayDouble> ret=self->deepCopy();
1681               ret->applyLin(1.,val);
1682               return ret.retn();
1683             }
1684           case 3:
1685             {
1686               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1687               return DataArrayDouble::Add(self,aaa);
1688             }
1689           case 4:
1690             {
1691               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1692               return DataArrayDouble::Add(self,aaa);
1693             }
1694           default:
1695             throw INTERP_KERNEL::Exception(msg);
1696           }
1697       }
1698
1699       PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
1700       {
1701         return DataArrayT_iadd<double>(trueSelf,obj,self);
1702       }
1703
1704       PyObject *__sub__(PyObject *obj)
1705       {
1706         const char msg[]="Unexpected situation in __sub__ !";
1707         double val;
1708         DataArrayDouble *a;
1709         DataArrayDoubleTuple *aa;
1710         std::vector<double> bb;
1711         mcIdType sw;
1712         //
1713 #ifndef WITHOUT_AUTOFIELD
1714         void *argp;
1715         if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1716           {
1717             MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1718             if(other)
1719               {
1720                 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1721                 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rsub__Impl(other,tmp);
1722                 Py_XDECREF(tmp);
1723                 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1724               }
1725             else
1726               throw INTERP_KERNEL::Exception(msg);
1727           }
1728 #endif
1729         //
1730         convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1731         switch(sw)
1732           {
1733           case 1:
1734             {
1735               MCAuto<DataArrayDouble> ret=self->deepCopy();
1736               ret->applyLin(1.,-val);
1737               return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1738             }
1739           case 2:
1740             {
1741               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1742             }
1743           case 3:
1744             {
1745               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1746               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1747             }
1748           case 4:
1749             {
1750               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1751               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1752             }
1753           default:
1754             throw INTERP_KERNEL::Exception(msg);
1755           }
1756       }
1757
1758       DataArrayDouble *__rsub__(PyObject *obj)
1759       {
1760         const char msg[]="Unexpected situation in __rsub__ !";
1761         double val;
1762         DataArrayDouble *a;
1763         DataArrayDoubleTuple *aa;
1764         std::vector<double> bb;
1765         mcIdType sw;
1766         convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1767         switch(sw)
1768           {
1769           case 1:
1770             {
1771               MCAuto<DataArrayDouble> ret=self->deepCopy();
1772               ret->applyLin(-1.,val);
1773               return ret.retn();
1774             }
1775           case 3:
1776             {
1777               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1778               return DataArrayDouble::Substract(aaa,self);
1779             }
1780           case 4:
1781             {
1782               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1783               return DataArrayDouble::Substract(aaa,self);
1784             }
1785           default:
1786             throw INTERP_KERNEL::Exception(msg);
1787           }
1788       }
1789
1790       PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
1791       {
1792         return DataArrayT_isub<double>(trueSelf,obj,self);
1793       }
1794
1795       PyObject *__mul__(PyObject *obj)
1796       {
1797         const char msg[]="Unexpected situation in __mul__ !";
1798         double val;
1799         DataArrayDouble *a;
1800         DataArrayDoubleTuple *aa;
1801         std::vector<double> bb;
1802         mcIdType sw;
1803         //
1804 #ifndef WITHOUT_AUTOFIELD
1805         void *argp;
1806         if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1807           {
1808             MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1809             if(other)
1810               {
1811                 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1812                 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rmul__Impl(other,tmp);
1813                 Py_XDECREF(tmp);
1814                 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1815               }
1816             else
1817               throw INTERP_KERNEL::Exception(msg);
1818           }
1819 #endif
1820         //
1821         convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1822         switch(sw)
1823           {
1824           case 1:
1825             {
1826               MCAuto<DataArrayDouble> ret=self->deepCopy();
1827               ret->applyLin(val,0.);
1828               return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1829             }
1830           case 2:
1831             {
1832               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1833             }
1834           case 3:
1835             {
1836               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1837               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1838             }
1839           case 4:
1840             {
1841               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1842               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1843             }
1844           default:
1845             throw INTERP_KERNEL::Exception(msg);
1846           }
1847       }
1848
1849       DataArrayDouble *__rmul__(PyObject *obj)
1850       {
1851         return DataArrayFPT_rmul<double>(self,obj);
1852       }
1853
1854       PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
1855       {
1856         return DataArrayT_imul<double>(trueSelf,obj,self);
1857       }
1858
1859       PyObject *__div__(PyObject *obj)
1860       {
1861         const char msg[]="Unexpected situation in __div__ !";
1862         double val;
1863         DataArrayDouble *a;
1864         DataArrayDoubleTuple *aa;
1865         std::vector<double> bb;
1866         mcIdType sw;
1867         //
1868 #ifndef WITHOUT_AUTOFIELD
1869         void *argp;
1870         if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1871           {
1872             MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1873             if(other)
1874               {
1875                 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1876                 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rdiv__Impl(other,tmp);
1877                 Py_XDECREF(tmp);
1878                 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1879               }
1880             else
1881               throw INTERP_KERNEL::Exception(msg);
1882           }
1883 #endif
1884         //
1885         convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1886         switch(sw)
1887           {
1888           case 1:
1889             {
1890               if(val==0.)
1891                 throw INTERP_KERNEL::Exception("DataArrayDouble::__div__ : trying to divide by zero !");
1892               MCAuto<DataArrayDouble> ret=self->deepCopy();
1893               ret->applyLin(1/val,0.);
1894               return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1895             }
1896           case 2:
1897             {
1898               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1899             }
1900           case 3:
1901             {
1902               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1903               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1904             }
1905           case 4:
1906             {
1907               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1908               return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1909             }
1910           default:
1911             throw INTERP_KERNEL::Exception(msg);
1912           }
1913       }
1914
1915       DataArrayDouble *__rdiv__(PyObject *obj)
1916       {
1917         const char msg[]="Unexpected situation in __rdiv__ !";
1918         double val;
1919         DataArrayDouble *a;
1920         DataArrayDoubleTuple *aa;
1921         std::vector<double> bb;
1922         mcIdType sw;
1923         convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1924         switch(sw)
1925           {
1926           case 1:
1927             {
1928               MCAuto<DataArrayDouble> ret=self->deepCopy();
1929               ret->applyInv(val);
1930               return ret.retn();
1931             }
1932           case 3:
1933             {
1934               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1935               return DataArrayDouble::Divide(aaa,self);
1936             }
1937           case 4:
1938             {
1939               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1940               return DataArrayDouble::Divide(aaa,self);
1941             }
1942           default:
1943             throw INTERP_KERNEL::Exception(msg);
1944           }
1945       }
1946
1947       PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
1948       {
1949         return DataArrayT_idiv<double>(trueSelf,obj,self);
1950       }
1951
1952       DataArrayDouble *__pow__(PyObject *obj)
1953       {
1954         const char msg[]="Unexpected situation in __pow__ !";
1955         double val;
1956         DataArrayDouble *a;
1957         DataArrayDoubleTuple *aa;
1958         std::vector<double> bb;
1959         mcIdType sw;
1960         convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1961         switch(sw)
1962           {
1963           case 1:
1964             {
1965               MCAuto<DataArrayDouble> ret=self->deepCopy();
1966               ret->applyPow(val);
1967               return ret.retn();
1968             }
1969           case 2:
1970             {
1971               return DataArrayDouble::Pow(self,a);
1972             }
1973           case 3:
1974             {
1975               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1976               return DataArrayDouble::Pow(self,aaa);
1977             }
1978           case 4:
1979             {
1980               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1981               return DataArrayDouble::Pow(self,aaa);
1982             }
1983           default:
1984             throw INTERP_KERNEL::Exception(msg);
1985           }
1986       }
1987
1988       DataArrayDouble *__rpow__(PyObject *obj)
1989       {
1990         const char msg[]="Unexpected situation in __rpow__ !";
1991         double val;
1992         DataArrayDouble *a;
1993         DataArrayDoubleTuple *aa;
1994         std::vector<double> bb;
1995         mcIdType sw;
1996         convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1997         switch(sw)
1998           {
1999           case 1:
2000             {
2001               MCAuto<DataArrayDouble> ret=self->deepCopy();
2002               ret->applyRPow(val);
2003               return ret.retn();
2004             }
2005           case 3:
2006             {
2007               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
2008               return DataArrayDouble::Pow(aaa,self);
2009             }
2010           case 4:
2011             {
2012               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
2013               return DataArrayDouble::Pow(aaa,self);
2014             }
2015           default:
2016             throw INTERP_KERNEL::Exception(msg);
2017           }
2018       }
2019
2020       PyObject *___ipow___(PyObject *trueSelf, PyObject *obj)
2021       {
2022         const char msg[]="Unexpected situation in __ipow__ !";
2023         double val;
2024         DataArrayDouble *a;
2025         DataArrayDoubleTuple *aa;
2026         std::vector<double> bb;
2027         mcIdType sw;
2028         convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
2029         switch(sw)
2030           {
2031           case 1:
2032             {
2033               self->applyPow(val);
2034               Py_XINCREF(trueSelf);
2035               return trueSelf;
2036             }
2037           case 2:
2038             {
2039               self->powEqual(a);
2040               Py_XINCREF(trueSelf);
2041               return trueSelf;
2042             }
2043           case 3:
2044             {
2045               MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
2046               self->powEqual(aaa);
2047               Py_XINCREF(trueSelf);
2048               return trueSelf;
2049             }
2050           case 4:
2051             {
2052               MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
2053               self->powEqual(aaa);
2054               Py_XINCREF(trueSelf);
2055               return trueSelf;
2056             }
2057           default:
2058             throw INTERP_KERNEL::Exception(msg);
2059           }
2060       }
2061
2062       PyObject *computeTupleIdsNearTuples(const DataArrayDouble *other, double eps)
2063       {
2064         DataArrayIdType *c=0,*cI=0;
2065         //
2066         self->computeTupleIdsNearTuples(other,eps,c,cI);
2067         PyObject *ret=PyTuple_New(2);
2068         PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2069         PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2070         return ret;
2071       }
2072
2073       PyObject *maxPerTupleWithCompoId() const
2074       {
2075         DataArrayIdType *ret1=0;
2076         DataArrayDouble *ret0=self->maxPerTupleWithCompoId(ret1);
2077         PyObject *ret=PyTuple_New(2);
2078         PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ));
2079         PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2080         return ret;
2081       }
2082     }
2083   };
2084
2085   class DataArrayDoubleTuple;
2086
2087   class DataArrayDoubleIterator
2088   {
2089   public:
2090     DataArrayDoubleIterator(DataArrayDouble *da);
2091     ~DataArrayDoubleIterator();
2092     %extend
2093     {
2094       PyObject *next()
2095       {
2096         DataArrayDoubleTuple *ret=self->nextt();
2097         if(ret)
2098           return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayDoubleTuple,SWIG_POINTER_OWN|0);
2099         else
2100           {
2101             PyErr_SetString(PyExc_StopIteration,"No more data.");
2102             return 0;
2103           }
2104       }
2105     }
2106   };
2107
2108   class DataArrayDoubleTuple
2109   {
2110   public:
2111     std::size_t getNumberOfCompo() const;
2112     DataArrayDouble *buildDADouble(int nbOfTuples, int nbOfCompo) const;
2113     %extend
2114     {
2115       std::string __str__() const
2116       {
2117         return self->repr();
2118       }
2119
2120       double __float__() const
2121       {
2122         return self->doubleValue();
2123       }
2124
2125       DataArrayDouble *buildDADouble()
2126       {
2127         return self->buildDADouble(1,self->getNumberOfCompo());
2128       }
2129
2130       PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
2131       {
2132         MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2133         MEDCoupling_DataArrayDouble____iadd___(ret,0,obj);
2134         Py_XINCREF(trueSelf);
2135         return trueSelf;
2136       }
2137
2138       PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
2139       {
2140         MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2141         MEDCoupling_DataArrayDouble____isub___(ret,0,obj);
2142         Py_XINCREF(trueSelf);
2143         return trueSelf;
2144       }
2145
2146       PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
2147       {
2148         MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2149         MEDCoupling_DataArrayDouble____imul___(ret,0,obj);
2150         Py_XINCREF(trueSelf);
2151         return trueSelf;
2152       }
2153
2154       PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
2155       {
2156         MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2157         MEDCoupling_DataArrayDouble____idiv___(ret,0,obj);
2158         Py_XINCREF(trueSelf);
2159         return trueSelf;
2160       }
2161
2162       PyObject *__len__()
2163       {
2164         return PyInt_FromLong(self->getNumberOfCompo());
2165       }
2166
2167       PyObject *__getitem__(PyObject *obj)
2168       {
2169         const char msg2[]="DataArrayDoubleTuple::__getitem__ : Mismatch of slice values in 2nd parameter (components) !";
2170         mcIdType sw;
2171         mcIdType singleVal;
2172         std::vector<mcIdType> multiVal;
2173         std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2174         MEDCoupling::DataArrayIdType *daIntTyypp=0;
2175         const double *pt=self->getConstPointer();
2176         mcIdType nbc=ToIdType(self->getNumberOfCompo());
2177         convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbc,sw,singleVal,multiVal,slic,daIntTyypp);
2178         switch(sw)
2179           {
2180           case 1:
2181             {
2182               if(singleVal>=nbc)
2183                 {
2184                   std::ostringstream oss;
2185                   oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2186                   PyErr_SetString(PyExc_StopIteration,oss.str().c_str());
2187                   return 0;
2188                 }
2189               if(singleVal>=0)
2190                 return PyFloat_FromDouble(pt[singleVal]);
2191               else
2192                 {
2193                   if(nbc+singleVal>0)
2194                     return PyFloat_FromDouble(pt[nbc+singleVal]);
2195                   else
2196                     {
2197                       std::ostringstream oss;
2198                       oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2199                       throw INTERP_KERNEL::Exception(oss.str().c_str());
2200                     }
2201                 }
2202             }
2203           case 2:
2204             {
2205               PyObject *t=PyTuple_New(multiVal.size());
2206               for(std::size_t j=0;j<multiVal.size();j++)
2207                 {
2208                   mcIdType cid=multiVal[j];
2209                   if(cid>=nbc)
2210                     {
2211                       std::ostringstream oss;
2212                       oss << "Requesting for id #" << cid << " having only " << nbc << " components !";
2213                       throw INTERP_KERNEL::Exception(oss.str().c_str());
2214                     }
2215                   PyTuple_SetItem(t,j,PyFloat_FromDouble(pt[cid]));
2216                 }
2217               return t;
2218             }
2219           case 3:
2220             {
2221               mcIdType sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2222               PyObject *t=PyTuple_New(sz);
2223               for(mcIdType j=0;j<sz;j++)
2224                 PyTuple_SetItem(t,j,PyFloat_FromDouble(pt[slic.first+j*slic.second.second]));
2225               return t;
2226             }
2227           default:
2228             throw INTERP_KERNEL::Exception("DataArrayDoubleTuple::__getitem__ : unrecognized type entered !");
2229           }
2230       }
2231
2232       DataArrayDoubleTuple *__setitem__(PyObject *obj, PyObject *value)
2233       {
2234         const char msg[]="DataArrayDoubleTuple::__setitem__ : unrecognized type entered, int, slice, list<int>, tuple<int> !";
2235         const char msg2[]="DataArrayDoubleTuple::__setitem__ : Mismatch of slice values in 2nd parameter (components) !";
2236         mcIdType sw1,sw2;
2237         double singleValV;
2238         std::vector<double> multiValV;
2239         MEDCoupling::DataArrayDoubleTuple *daIntTyyppV=0;
2240         mcIdType nbc=ToIdType(self->getNumberOfCompo());
2241         convertDoubleStarLikePyObjToCpp(value,sw1,singleValV,multiValV,daIntTyyppV);
2242         mcIdType singleVal;
2243         std::vector<mcIdType> multiVal;
2244         std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2245         MEDCoupling::DataArrayIdType *daIntTyypp=0;
2246         double *pt=self->getPointer();
2247         convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbc,sw2,singleVal,multiVal,slic,daIntTyypp);
2248         switch(sw2)
2249           {
2250           case 1:
2251             {
2252               if(singleVal>=nbc)
2253                 {
2254                   std::ostringstream oss;
2255                   oss << "Requesting for setting id # " << singleVal << " having only " << nbc << " components !";
2256                   throw INTERP_KERNEL::Exception(oss.str().c_str());
2257                 }
2258               switch(sw1)
2259                 {
2260                 case 1:
2261                   {
2262                     pt[singleVal]=singleValV;
2263                     return self;
2264                   }
2265                 case 2:
2266                   {
2267                     if(multiValV.size()!=1)
2268                       {
2269                         std::ostringstream oss;
2270                         oss << "Requesting for setting id # " << singleVal << " with a list or tuple with size != 1 ! ";
2271                         throw INTERP_KERNEL::Exception(oss.str().c_str());
2272                       }
2273                     pt[singleVal]=multiValV[0];
2274                     return self;
2275                   }
2276                 case 3:
2277                   {
2278                     pt[singleVal]=daIntTyyppV->getConstPointer()[0];
2279                     return self;
2280                   }
2281                 default:
2282                   throw INTERP_KERNEL::Exception(msg);
2283                 }
2284             }
2285           case 2:
2286             {
2287               switch(sw1)
2288                 {
2289                 case 1:
2290                   {
2291                     for(std::vector<mcIdType>::const_iterator it=multiVal.begin();it!=multiVal.end();it++)
2292                       {
2293                         if(*it>=nbc)
2294                           {
2295                             std::ostringstream oss;
2296                             oss << "Requesting for setting id # " << *it << " having only " << nbc << " components !";
2297                             throw INTERP_KERNEL::Exception(oss.str().c_str());
2298                           }
2299                         pt[*it]=singleValV;
2300                       }
2301                     return self;
2302                   }
2303                 case 2:
2304                   {
2305                     if(multiVal.size()!=multiValV.size())
2306                       {
2307                         std::ostringstream oss;
2308                         oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << multiVal.size() << " !";
2309                         throw INTERP_KERNEL::Exception(oss.str().c_str());
2310                       }
2311                     for(std::size_t i=0;i<multiVal.size();i++)
2312                       {
2313                         mcIdType pos=multiVal[i];
2314                         if(pos>=nbc)
2315                           {
2316                             std::ostringstream oss;
2317                             oss << "Requesting for setting id # " << pos << " having only " << nbc << " components !";
2318                             throw INTERP_KERNEL::Exception(oss.str().c_str());
2319                           }
2320                         pt[multiVal[i]]=multiValV[i];
2321                       }
2322                     return self;
2323                   }
2324                 case 3:
2325                   {
2326                     const double *ptV=daIntTyyppV->getConstPointer();
2327                     if(nbc>(mcIdType)daIntTyyppV->getNumberOfCompo())
2328                       {
2329                         std::ostringstream oss;
2330                         oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2331                         throw INTERP_KERNEL::Exception(oss.str().c_str());
2332                       }
2333                     std::copy(ptV,ptV+nbc,pt);
2334                     return self;
2335                   }
2336                 default:
2337                   throw INTERP_KERNEL::Exception(msg);
2338                 }
2339             }
2340           case 3:
2341             {
2342               mcIdType sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2343               switch(sw1)
2344                 {
2345                 case 1:
2346                   {
2347                     for(mcIdType j=0;j<sz;j++)
2348                       pt[slic.first+j*slic.second.second]=singleValV;
2349                     return self;
2350                   }
2351                 case 2:
2352                   {
2353                     if(sz!=(mcIdType)multiValV.size())
2354                       {
2355                         std::ostringstream oss;
2356                         oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << sz << " !";
2357                         throw INTERP_KERNEL::Exception(oss.str().c_str());
2358                       }
2359                     for(mcIdType j=0;j<sz;j++)
2360                       pt[slic.first+j*slic.second.second]=multiValV[j];
2361                     return self;
2362                   }
2363                 case 3:
2364                   {
2365                     const double *ptV=daIntTyyppV->getConstPointer();
2366                     if(sz>(mcIdType)daIntTyyppV->getNumberOfCompo())
2367                       {
2368                         std::ostringstream oss;
2369                         oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2370                         throw INTERP_KERNEL::Exception(oss.str().c_str());
2371                       }
2372                     for(mcIdType j=0;j<sz;j++)
2373                       pt[slic.first+j*slic.second.second]=ptV[j];
2374                     return self;
2375                   }
2376                 default:
2377                   throw INTERP_KERNEL::Exception(msg);
2378                 }
2379             }
2380           default:
2381             throw INTERP_KERNEL::Exception(msg);
2382           }
2383       }
2384     }
2385   };
2386
2387   class DataArrayChar : public DataArray
2388   {
2389   public:
2390     virtual DataArrayChar *buildEmptySpecializedDAChar() const;
2391     int getHashCode() const;
2392     bool empty() const;
2393     void deepCopyFrom(const DataArrayChar& other);
2394     void reserve(std::size_t nbOfElems);
2395     void pushBackSilent(char val);
2396     char popBackSilent();
2397     void pack() const;
2398     void allocIfNecessary(int nbOfTuple, int nbOfCompo);
2399     bool isEqual(const DataArrayChar& other) const;
2400     bool isEqualWithoutConsideringStr(const DataArrayChar& other) const;
2401     void reverse();
2402     void fillWithZero();
2403     void fillWithValue(char val);
2404     std::string repr() const;
2405     std::string reprZip() const;
2406     DataArrayInt *convertToIntArr() const;
2407     DataArrayChar *renumber(const mcIdType *old2New) const;
2408     DataArrayChar *renumberR(const mcIdType *new2Old) const;
2409     DataArrayChar *renumberAndReduce(const mcIdType *old2NewBg, mcIdType newNbOfTuple) const;
2410     bool isUniform(char val) const;
2411     void sort(bool asc=true);
2412     DataArrayChar *subArray(mcIdType tupleIdBg, mcIdType tupleIdEnd=-1) const;
2413     DataArrayChar *changeNbOfComponents(std::size_t newNbOfComp, char dftValue) const;
2414     void meldWith(const DataArrayChar *other);
2415     void setPartOfValuesAdv(const DataArrayChar *a, const DataArrayIdType *tuplesSelec);
2416     char front() const;
2417     char back() const;
2418     void setIJ(mcIdType tupleId, int compoId, char newVal);
2419     void setIJSilent(mcIdType tupleId, int compoId, char newVal);
2420     char *getPointer();
2421     DataArrayIdType *findIdsEqual(char val) const;
2422     DataArrayIdType *findIdsNotEqual(char val) const;
2423     int findIdFirstEqualTuple(const std::vector<char>& tupl) const;
2424     bool presenceOfTuple(const std::vector<char>& tupl) const;
2425     char getMaxValue(mcIdType& tupleId) const;
2426     char getMaxValueInArray() const;
2427     char getMinValue(mcIdType& tupleId) const;
2428     char getMinValueInArray() const;
2429     DataArrayIdType *findIdsInRange(char vmin, char vmax) const;
2430     static DataArrayChar *Aggregate(const DataArrayChar *a1, const DataArrayChar *a2);
2431     static DataArrayChar *Meld(const DataArrayChar *a1, const DataArrayChar *a2);
2432     %extend
2433     {
2434       mcIdType __len__() const
2435       {
2436         if(self->isAllocated())
2437           {
2438             return self->getNumberOfTuples();
2439           }
2440         else
2441           {
2442             throw INTERP_KERNEL::Exception("DataArrayChar::__len__ : Instance is NOT allocated !");
2443           }
2444       }
2445
2446       PyObject *isEqualIfNotWhy(const DataArrayChar& other) const
2447       {
2448         std::string ret1;
2449         bool ret0=self->isEqualIfNotWhy(other,ret1);
2450         PyObject *ret=PyTuple_New(2);
2451         PyObject *ret0Py=ret0?Py_True:Py_False;
2452         Py_XINCREF(ret0Py);
2453         PyTuple_SetItem(ret,0,ret0Py);
2454         PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
2455         return ret;
2456       }
2457
2458       DataArrayChar *renumber(PyObject *li)
2459       {
2460         void *da=0;
2461         int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 |  0 );
2462         if (!SWIG_IsOK(res1))
2463           {
2464             mcIdType size;
2465             INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2466             if(size!=self->getNumberOfTuples())
2467               {
2468                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2469               }
2470             return self->renumber(tmp);
2471           }
2472         else
2473           {
2474             DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2475             if(!da2)
2476               throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2477             da2->checkAllocated();
2478             mcIdType size=self->getNumberOfTuples();
2479             if(size!=self->getNumberOfTuples())
2480               {
2481                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2482               }
2483             return self->renumber(da2->getConstPointer());
2484           }
2485       }
2486
2487       DataArrayChar *renumberR(PyObject *li)
2488       {
2489         void *da=0;
2490         int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 |  0 );
2491         if (!SWIG_IsOK(res1))
2492           {
2493             mcIdType size;
2494             INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2495             if(size!=self->getNumberOfTuples())
2496               {
2497                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2498               }
2499             return self->renumberR(tmp);
2500           }
2501         else
2502           {
2503             DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2504             if(!da2)
2505               throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2506             da2->checkAllocated();
2507             mcIdType size=self->getNumberOfTuples();
2508             if(size!=self->getNumberOfTuples())
2509               {
2510                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2511               }
2512             return self->renumberR(da2->getConstPointer());
2513           }
2514       }
2515
2516       DataArrayChar *renumberAndReduce(PyObject *li, mcIdType newNbOfTuple)
2517       {
2518         void *da=0;
2519         int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 |  0 );
2520         if (!SWIG_IsOK(res1))
2521           {
2522             mcIdType size;
2523             INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2524             if(size!=self->getNumberOfTuples())
2525               {
2526                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2527               }
2528             return self->renumberAndReduce(tmp,newNbOfTuple);
2529           }
2530         else
2531           {
2532             DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2533             if(!da2)
2534               throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2535             da2->checkAllocated();
2536             mcIdType size=self->getNumberOfTuples();
2537             if(size!=self->getNumberOfTuples())
2538               {
2539                 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2540               }
2541             return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
2542           }
2543       }
2544
2545       static DataArrayChar *Aggregate(PyObject *dachs)
2546       {
2547         std::vector<const MEDCoupling::DataArrayChar *> tmp;
2548         convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayChar *>(dachs,SWIGTYPE_p_MEDCoupling__DataArrayChar,"DataArrayChar",tmp);
2549         return DataArrayChar::Aggregate(tmp);
2550       }
2551
2552       static DataArrayChar *Meld(PyObject *dachs)
2553       {
2554         std::vector<const MEDCoupling::DataArrayChar *> tmp;
2555         convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayChar *>(dachs,SWIGTYPE_p_MEDCoupling__DataArrayChar,"DataArrayChar",tmp);
2556         return DataArrayChar::Meld(tmp);
2557       }
2558     }
2559   };
2560
2561   class DataArrayByteIterator;
2562
2563   class DataArrayByte : public DataArrayChar
2564   {
2565   public:
2566     static DataArrayByte *New();
2567     DataArrayByteIterator *iterator();
2568     DataArrayByte *performCopyOrIncrRef(bool deepCopy) const;
2569     char byteValue() const;
2570     %extend
2571     {
2572       DataArrayByte()
2573         {
2574           return DataArrayByte::New();
2575         }
2576
2577       static DataArrayByte *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
2578       {
2579         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) !";
2580         if(PyList_Check(elt0) || PyTuple_Check(elt0))
2581           {
2582             if(nbOfTuples)
2583               {
2584                 if(PyInt_Check(nbOfTuples))
2585                   {
2586                     mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
2587                     if(nbOfTuples1<0)
2588                       throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive set of allocated memory !");
2589                     if(nbOfComp)
2590                       {
2591                         if(PyInt_Check(nbOfComp))
2592                           {//DataArrayByte.New([1,3,4,5],2,2)
2593                             mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
2594                             if(nbOfCompo<0)
2595                               throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !");
2596                             MCAuto<DataArrayByte> ret=DataArrayByte::New();
2597                             std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
2598                             ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2599                             return ret.retn();
2600                           }
2601                         else
2602                           throw INTERP_KERNEL::Exception(msg);
2603                       }
2604                     else
2605                       {//DataArrayByte.New([1,3,4],3)
2606                         MCAuto<DataArrayByte> ret=DataArrayByte::New();
2607                         mcIdType tmpp1=-1;
2608                         std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
2609                         ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2610                         return ret.retn();
2611                       }
2612                   }
2613                 else
2614                   throw INTERP_KERNEL::Exception(msg);
2615               }
2616             else
2617               {// DataArrayByte.New([1,3,4])
2618                 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2619                 mcIdType tmpp1=-1,tmpp2=-1;
2620                 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
2621                 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2622                 return ret.retn();
2623               }
2624           }
2625         else if(PyInt_Check(elt0))
2626           {
2627             mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(elt0));
2628             if(nbOfTuples1<0)
2629               throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive set of allocated memory !");
2630             if(nbOfTuples)
2631               {
2632                 if(!nbOfComp)
2633                   {
2634                     if(PyInt_Check(nbOfTuples))
2635                       {//DataArrayByte.New(5,2)
2636                         mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfTuples));
2637                         if(nbOfCompo<0)
2638                           throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !");
2639                         MCAuto<DataArrayByte> ret=DataArrayByte::New();
2640                         ret->alloc(nbOfTuples1,nbOfCompo);
2641                         return ret.retn();
2642                       }
2643                     else
2644                       throw INTERP_KERNEL::Exception(msg);
2645                   }
2646                 else
2647                   throw INTERP_KERNEL::Exception(msg);
2648               }
2649             else
2650               {//DataArrayByte.New(5)
2651                 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2652                 ret->alloc(nbOfTuples1,1);
2653                 return ret.retn();
2654               }
2655           }
2656 #ifdef WITH_NUMPY
2657         else if(PyArray_Check(elt0) && nbOfTuples==NULL && nbOfComp==NULL)
2658           {//DataArrayDouble.New(numpyArray)
2659             return BuildNewInstance<DataArrayByte,char>(elt0,NPY_INT8,&PyCallBackDataArrayChar_RefType,"INT8");
2660           }
2661 #endif
2662         else
2663           throw INTERP_KERNEL::Exception(msg);
2664       }
2665
2666       DataArrayByte(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
2667         {
2668           return MEDCoupling_DataArrayByte_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
2669         }
2670
2671       std::string __repr__() const
2672       {
2673         std::ostringstream oss;
2674         self->reprQuickOverview(oss);
2675         return oss.str();
2676       }
2677
2678       int __int__() const
2679       {
2680         return (int) self->byteValue();
2681       }
2682
2683       DataArrayByteIterator *__iter__()
2684       {
2685         return self->iterator();
2686       }
2687
2688       mcIdType getIJ(mcIdType tupleId, mcIdType compoId) const
2689       {
2690         return (mcIdType)self->getIJ(tupleId,compoId);
2691       }
2692
2693       mcIdType getIJSafe(mcIdType tupleId, mcIdType compoId) const
2694       {
2695         return (mcIdType)self->getIJSafe(tupleId,compoId);
2696       }
2697
2698       std::string __str__() const
2699       {
2700         return self->repr();
2701       }
2702
2703       PyObject *toStrList() const
2704       {
2705         const char *vals=self->getConstPointer();
2706         std::size_t nbOfComp=self->getNumberOfComponents();
2707         mcIdType nbOfTuples=self->getNumberOfTuples();
2708         return convertCharArrToPyListOfTuple(vals,(int)nbOfComp,nbOfTuples);
2709       }
2710
2711       bool presenceOfTuple(PyObject *tupl) const
2712       {
2713         mcIdType sz=-1,sw=-1;
2714         mcIdType ival=-1; std::vector<mcIdType> ivval;
2715         const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(tupl,sw,sz,ival,ivval);
2716         std::vector<char> vals(sz);
2717         std::copy(pt,pt+sz,vals.begin());
2718         return self->presenceOfTuple(vals);
2719       }
2720
2721       bool presenceOfValue(PyObject *vals) const
2722       {
2723         mcIdType sz=-1,sw=-1;
2724         mcIdType ival=-1; std::vector<mcIdType> ivval;
2725         const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(vals,sw,sz,ival,ivval);
2726         std::vector<char> vals2(sz);
2727         std::copy(pt,pt+sz,vals2.begin());
2728         return self->presenceOfValue(vals2);
2729       }
2730
2731       mcIdType findIdFirstEqual(PyObject *vals) const
2732       {
2733         mcIdType sz=-1,sw=-1;
2734         mcIdType ival=-1; std::vector<mcIdType> ivval;
2735         const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(vals,sw,sz,ival,ivval);
2736         std::vector<char> vals2(sz);
2737         std::copy(pt,pt+sz,vals2.begin());
2738         return self->findIdFirstEqual(vals2);
2739       }
2740
2741       mcIdType findIdFirstEqualTuple(PyObject *tupl) const
2742       {
2743         mcIdType sz=-1,sw=-1;
2744         mcIdType ival=-1; std::vector<mcIdType> ivval;
2745         const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(tupl,sw,sz,ival,ivval);
2746         std::vector<char> vals(sz);
2747         std::copy(pt,pt+sz,vals.begin());
2748         return self->findIdFirstEqualTuple(vals);
2749       }
2750
2751       mcIdType findIdSequence(PyObject *strOrListOfInt) const
2752       {
2753         mcIdType sz=-1,sw=-1;
2754         mcIdType ival=-1; std::vector<mcIdType> ivval;
2755         const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(strOrListOfInt,sw,sz,ival,ivval);
2756         std::vector<char> vals(sz);
2757         std::copy(pt,pt+sz,vals.begin());
2758         return self->findIdSequence(vals);
2759       }
2760
2761       PyObject *getTuple(mcIdType tupleId)
2762       {
2763         std::size_t sz=self->getNumberOfComponents();
2764         INTERP_KERNEL::AutoPtr<char> tmp=new char[sz];
2765         self->getTuple(tupleId,tmp);
2766         PyObject *ret=PyTuple_New(sz);
2767         for(std::size_t i=0;i<sz;i++) PyTuple_SetItem(ret,i,PyInt_FromLong((mcIdType)tmp[i]));
2768         return ret;
2769       }
2770
2771       PyObject *getMaxValue() const
2772       {
2773         mcIdType tmp;
2774         mcIdType r1=(mcIdType)self->getMaxValue(tmp);
2775         PyObject *ret=PyTuple_New(2);
2776         PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
2777         PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
2778         return ret;
2779       }
2780
2781       PyObject *getMinValue() const
2782       {
2783         mcIdType tmp;
2784         mcIdType r1=(mcIdType)self->getMinValue(tmp);
2785         PyObject *ret=PyTuple_New(2);
2786         PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
2787         PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
2788         return ret;
2789       }
2790
2791       mcIdType index(PyObject *obj) const
2792       {
2793         std::size_t nbOfCompo=self->getNumberOfComponents();
2794         switch(nbOfCompo)
2795           {
2796           case 1:
2797             {
2798               if(PyInt_Check(obj))
2799                 {
2800                   char val=(char)PyInt_AS_LONG(obj);
2801                   return self->findIdFirstEqual(val);
2802                 }
2803               else
2804                 throw INTERP_KERNEL::Exception("DataArrayByte::index : 'this' contains one component and trying to find an element which is not an integer !");
2805             }
2806           default:
2807             return MEDCoupling_DataArrayByte_findIdFirstEqualTuple(self,obj);
2808           }
2809       }
2810
2811       bool __contains__(PyObject *obj) const
2812       {
2813         std::size_t nbOfCompo=self->getNumberOfComponents();
2814         switch(nbOfCompo)
2815           {
2816           case 0:
2817             return false;
2818           case 1:
2819             {
2820               if(PyInt_Check(obj))
2821                 {
2822                   char val=(char)PyInt_AS_LONG(obj);
2823                   return self->presenceOfValue(val);
2824                 }
2825               else
2826                 throw INTERP_KERNEL::Exception("DataArrayByte::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
2827             }
2828           default:
2829             return MEDCoupling_DataArrayByte_presenceOfTuple(self,obj);
2830           }
2831       }
2832
2833 #ifdef WITH_NUMPY
2834       PyObject *toNumPyArray() // not const. It is not a bug !
2835       {
2836         return ToNumPyArray<DataArrayByte,char>(self,NPY_INT8,"DataArrayByte");
2837       }
2838 #endif
2839
2840       DataArrayByte *__setitem__(PyObject *obj, PyObject *value)
2841       {
2842         self->checkAllocated();
2843         const char msg[]="Unexpected situation in __setitem__ !";
2844         mcIdType nbOfTuples(self->getNumberOfTuples());
2845         int nbOfComponents((int)self->getNumberOfComponents());
2846         mcIdType sw1,sw2;
2847         int int1;
2848         std::vector<int> v1;
2849         DataArrayIdType *d1=0;
2850         DataArrayIntTuple *dd1=0;
2851         convertIntStarLikePyObjToCpp(value,sw1,int1,v1,d1,dd1);
2852         mcIdType it1,ic1;
2853         std::vector<mcIdType> vt1,vc1;
2854         std::pair<mcIdType, std::pair<mcIdType,mcIdType> > pt1,pc1;
2855         DataArrayIdType *dt1=0,*dc1=0;
2856         convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw2,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1);
2857         MCAuto<DataArrayIdType> tmp;
2858         char i1 = (char)int1;
2859         switch(sw2)
2860           {
2861           case 1:
2862             {
2863               switch(sw1)
2864                 {
2865                 case 1:
2866                   self->setPartOfValuesSimple1(i1,it1,it1+1,1,0,nbOfComponents,1);
2867                   return self;
2868                 default:
2869                   throw INTERP_KERNEL::Exception(msg);
2870                 }
2871               break;
2872             }
2873           case 2:
2874             {
2875               switch(sw1)
2876                 {
2877                 case 1:
2878                   self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1);
2879                   return self;
2880                 default:
2881                   throw INTERP_KERNEL::Exception(msg);
2882                 }
2883               break;
2884             }
2885           case 3:
2886             {
2887               switch(sw1)
2888                 {
2889                 case 1:
2890                   self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1);
2891                   return self;
2892                 default:
2893                   throw INTERP_KERNEL::Exception(msg);
2894                 }
2895               break;
2896             }
2897           case 4:
2898             {
2899               switch(sw1)
2900                 {
2901                 case 1:
2902                   self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1);
2903                   return self;
2904                 default:
2905                   throw INTERP_KERNEL::Exception(msg);
2906                 }
2907               break;
2908             }
2909           case 5:
2910             {
2911               switch(sw1)
2912                 {
2913                 case 1:
2914                   self->setPartOfValuesSimple1(i1,it1,it1+1,1,ic1,ic1+1,1);
2915                   return self;
2916                 default:
2917                   throw INTERP_KERNEL::Exception(msg);
2918                 }
2919               break;
2920             }
2921           case 6:
2922             {
2923               switch(sw1)
2924                 {
2925                 case 1:
2926                   self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1);
2927                   return self;
2928                 default:
2929                   throw INTERP_KERNEL::Exception(msg);
2930                 }
2931               break;
2932             }
2933           case 7:
2934             {
2935               switch(sw1)
2936                 {
2937                 case 1:
2938                   self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1);
2939                   return self;
2940                 default:
2941                   throw INTERP_KERNEL::Exception(msg);
2942                 }
2943               break;
2944             }
2945           case 8:
2946             {
2947               switch(sw1)
2948                 {
2949                 case 1:
2950                   self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1);
2951                   return self;
2952                 default:
2953                   throw INTERP_KERNEL::Exception(msg);
2954                 }
2955               break;
2956             }
2957           case 9:
2958             {
2959               switch(sw1)
2960                 {
2961                 case 1:
2962                   self->setPartOfValuesSimple2(i1,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size());
2963                   return self;
2964                 default:
2965                   throw INTERP_KERNEL::Exception(msg);
2966                 }
2967               break;
2968             }
2969           case 10:
2970             {
2971               switch(sw1)
2972                 {
2973                 case 1:
2974                   self->setPartOfValuesSimple2(i1,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size());
2975                   return self;
2976                 default:
2977                   throw INTERP_KERNEL::Exception(msg);
2978                 }
2979               break;
2980             }
2981           case 11:
2982             {
2983               switch(sw1)
2984                 {
2985                 case 1:
2986                   self->setPartOfValuesSimple4(i1,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size());
2987                   return self;
2988                 default:
2989                   throw INTERP_KERNEL::Exception(msg);
2990                 }
2991               break;
2992             }
2993           case 12:
2994             {
2995               switch(sw1)
2996                 {
2997                 case 1:
2998                   self->setPartOfValuesSimple2(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size());
2999                   return self;
3000                 default:
3001                   throw INTERP_KERNEL::Exception(msg);
3002                 }
3003               break;
3004             }
3005           case 13:
3006             {
3007               switch(sw1)
3008                 {
3009                 case 1:
3010                   self->setPartOfValuesSimple1(i1,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second);
3011                   return self;
3012                 default:
3013                   throw INTERP_KERNEL::Exception(msg);
3014                 }
3015               break;
3016             }
3017           case 14:
3018             {
3019               switch(sw1)
3020                 {
3021                 case 1:
3022                   self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second);
3023                   return self;
3024                 default:
3025                   throw INTERP_KERNEL::Exception(msg);
3026                 }
3027               break;
3028             }
3029           case 15:
3030             {
3031               switch(sw1)
3032                 {
3033                 case 1:
3034                   self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second);
3035                   return self;
3036                 default:
3037                   throw INTERP_KERNEL::Exception(msg);
3038                 }
3039               break;
3040             }
3041           case 16:
3042             {
3043               switch(sw1)
3044                 {
3045                 case 1:
3046                   self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second);
3047                   return self;
3048                 default:
3049                   throw INTERP_KERNEL::Exception(msg);
3050                 }
3051               break;
3052             }
3053           default:
3054             throw INTERP_KERNEL::Exception(msg);
3055           }
3056         return self;
3057       }
3058     }
3059   };
3060
3061   class DataArrayByteTuple;
3062
3063   class DataArrayByteIterator
3064   {
3065   public:
3066     DataArrayByteIterator(DataArrayByte *da);
3067     ~DataArrayByteIterator();
3068   };
3069
3070   class DataArrayByteTuple
3071   {
3072   public:
3073     std::string repr() const;
3074     DataArrayByte *buildDAByte(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
3075     %extend
3076     {
3077       std::string __str__() const
3078       {
3079         return self->repr();
3080       }
3081
3082       char __int__() const
3083       {
3084         return self->byteValue();
3085       }
3086
3087       DataArrayByte *buildDAByte()
3088       {
3089         return self->buildDAByte(1,self->getNumberOfCompo());
3090       }
3091     }
3092   };
3093
3094   class DataArrayAsciiCharIterator;
3095
3096   class DataArrayAsciiChar : public DataArrayChar
3097   {
3098   public:
3099     static DataArrayAsciiChar *New();
3100     DataArrayAsciiCharIterator *iterator();
3101     DataArrayAsciiChar *performCopyOrIncrRef(bool deepCopy) const;
3102     char asciiCharValue() const;
3103     %extend
3104     {
3105       DataArrayAsciiChar()
3106         {
3107           return DataArrayAsciiChar::New();
3108         }
3109
3110       static DataArrayAsciiChar *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
3111       {
3112         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) !";
3113         if(PyList_Check(elt0) || PyTuple_Check(elt0))
3114           {
3115             if(nbOfTuples)
3116               {
3117                 if(PyInt_Check(nbOfTuples))
3118                   {
3119                     mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
3120                     if(nbOfTuples1<0)
3121                       throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive set of allocated memory !");
3122                     if(nbOfComp)
3123                       {
3124                         if(PyInt_Check(nbOfComp))
3125                           {//DataArrayAsciiChar.New([1,3,4,5],2,2)
3126                             mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
3127                             if(nbOfCompo<0)
3128                               throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !");
3129                             MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3130                             std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
3131                             ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3132                             return ret.retn();
3133                           }
3134                         else
3135                           throw INTERP_KERNEL::Exception(msg);
3136                       }
3137                     else
3138                       {//DataArrayAsciiChar.New([1,3,4],3)
3139                         MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3140                         mcIdType tmpp1=-1;
3141                         std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
3142                         ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3143                         return ret.retn();
3144                       }
3145                   }
3146                 else if(PyString_Check(nbOfTuples))
3147                   {
3148                     if(PyString_Size(nbOfTuples)!=1)
3149                       throw INTERP_KERNEL::Exception(msg);
3150                     //DataArrayAsciiChar.New(["abc","de","fghi"],"t")
3151                     std::vector<std::string> tmp;
3152                     if(fillStringVector(elt0,tmp))
3153                       return DataArrayAsciiChar::New(tmp,PyString_AsString(nbOfTuples)[0]);
3154                     else
3155                       throw INTERP_KERNEL::Exception(msg);
3156                   }
3157 %#if PY_VERSION_HEX >= 0x03000000
3158                 else if(PyUnicode_Check(nbOfTuples))
3159                   {
3160                     if(PyUnicode_GET_LENGTH(nbOfTuples)!=1)
3161                       throw INTERP_KERNEL::Exception(msg);
3162                     //DataArrayAsciiChar.New(["abc","de","fghi"],"t")
3163                     std::vector<std::string> tmp;
3164                     if(fillStringVector(elt0,tmp))
3165                       return DataArrayAsciiChar::New(tmp,PyUnicode_AsUTF8(nbOfTuples)[0]);
3166                     else
3167                       throw INTERP_KERNEL::Exception(msg);
3168                   }
3169 %#endif
3170                 else
3171                   throw INTERP_KERNEL::Exception(msg);
3172               }
3173             else
3174               {
3175                 std::vector<std::string> tmmp;
3176                 if(fillStringVector(elt0,tmmp))
3177                   //DataArrayAsciiChar.New(["abc","de","fghi"])
3178                   return DataArrayAsciiChar::New(tmmp,' ');
3179                 else
3180                   {
3181                     // DataArrayAsciiChar.New([1,3,4])
3182                     MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3183                     mcIdType tmpp1=-1,tmpp2=-1;
3184                     std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
3185                     ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3186                     return ret.retn();
3187                   }
3188               }
3189           }
3190         else if(PyInt_Check(elt0))
3191           {
3192             mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(elt0));
3193             if(nbOfTuples1<0)
3194               throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive set of allocated memory !");
3195             if(nbOfTuples)
3196               {
3197                 if(!nbOfComp)
3198                   {
3199                     if(PyInt_Check(nbOfTuples))
3200                       {//DataArrayAsciiChar.New(5,2)
3201                         mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfTuples));
3202                         if(nbOfCompo<0)
3203                           throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !");
3204                         MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3205                         ret->alloc(nbOfTuples1,nbOfCompo);
3206                         return ret.retn();
3207                       }
3208                     else
3209                       throw INTERP_KERNEL::Exception(msg);
3210                   }
3211                 else
3212                   throw INTERP_KERNEL::Exception(msg);
3213               }
3214             else
3215               {//DataArrayAsciiChar.New(5)
3216                 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3217                 ret->alloc(nbOfTuples1,1);
3218                 return ret.retn();
3219               }
3220           }
3221         else
3222           throw INTERP_KERNEL::Exception(msg);
3223       }
3224
3225       DataArrayAsciiChar(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
3226         {
3227           return MEDCoupling_DataArrayAsciiChar_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
3228         }
3229
3230       std::string __repr__() const
3231       {
3232         std::ostringstream oss;
3233         self->reprQuickOverview(oss);
3234         return oss.str();
3235       }
3236
3237       DataArrayAsciiCharIterator *__iter__()
3238       {
3239         return self->iterator();
3240       }
3241
3242       std::string getIJ(mcIdType tupleId, mcIdType compoId) const
3243       {
3244         char tmp[2]; tmp[1]='\0';
3245         tmp[0]=self->getIJ(tupleId,compoId);
3246         return std::string(tmp);
3247       }
3248
3249       std::string getIJSafe(mcIdType tupleId, mcIdType compoId) const
3250       {
3251         char tmp[2]; tmp[1]='\0';
3252         tmp[0]=self->getIJSafe(tupleId,compoId);
3253         return std::string(tmp);
3254       }
3255
3256       std::string __str__() const
3257       {
3258         return self->repr();
3259       }
3260
3261       PyObject *toStrList() const
3262       {
3263         const char *vals=self->getConstPointer();
3264         std::size_t nbOfComp=self->getNumberOfComponents();
3265         mcIdType nbOfTuples=self->getNumberOfTuples();
3266         return convertCharArrToPyListOfTuple(vals,(int)nbOfComp,nbOfTuples);
3267       }
3268
3269       bool presenceOfTuple(PyObject *tupl) const
3270       {
3271         if(PyString_Check(tupl))
3272           {
3273             Py_ssize_t sz=PyString_Size(tupl);
3274             std::vector<char> vals(sz);
3275             std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin());
3276             return self->presenceOfTuple(vals);
3277           }
3278 %#if PY_VERSION_HEX >= 0x03000000
3279         else if(PyUnicode_Check(tupl))
3280           {
3281             Py_ssize_t sz=PyUnicode_GET_LENGTH(tupl);
3282             std::vector<char> vals(sz);
3283             std::copy(PyUnicode_AsUTF8(tupl),PyUnicode_AsUTF8(tupl)+sz,vals.begin());
3284             return self->presenceOfTuple(vals);
3285           }
3286 %#endif
3287         else
3288           throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfTuple : only strings in input supported !");
3289       }
3290
3291       bool presenceOfValue(PyObject *vals) const
3292       {
3293         if(PyString_Check(vals))
3294           {
3295             Py_ssize_t sz=PyString_Size(vals);
3296             std::vector<char> vals2(sz);
3297             std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin());
3298             return self->presenceOfValue(vals2);
3299           }
3300 %#if PY_VERSION_HEX >= 0x03000000
3301         if(PyUnicode_Check(vals))
3302           {
3303             Py_ssize_t sz=PyUnicode_GET_LENGTH(vals);
3304             std::vector<char> vals2(sz);
3305             std::copy(PyUnicode_AsUTF8(vals),PyUnicode_AsUTF8(vals)+sz,vals2.begin());
3306             return self->presenceOfValue(vals2);
3307           }
3308 %#endif
3309         else
3310           throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfValue : only strings in input supported !");
3311       }
3312
3313       mcIdType findIdFirstEqual(PyObject *vals) const
3314       {
3315         if(PyString_Check(vals))
3316           {
3317             Py_ssize_t sz=PyString_Size(vals);
3318             std::vector<char> vals2(sz);
3319             std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin());
3320             return self->findIdFirstEqual(vals2);
3321           }
3322 %#if PY_VERSION_HEX >= 0x03000000
3323         if(PyUnicode_Check(vals))
3324           {
3325             Py_ssize_t sz=PyUnicode_GET_LENGTH(vals);
3326             std::vector<char> vals2(sz);
3327             std::copy(PyUnicode_AsUTF8(vals),PyUnicode_AsUTF8(vals)+sz,vals2.begin());
3328             return self->findIdFirstEqual(vals2);
3329           }
3330 %#endif
3331         else
3332           throw INTERP_KERNEL::Exception("DataArrayAsciiChar::findIdFirstEqual : only strings in input supported !");
3333       }
3334
3335       mcIdType findIdFirstEqualTuple(PyObject *tupl) const
3336       {
3337         if(PyString_Check(tupl))
3338           {
3339             Py_ssize_t sz=PyString_Size(tupl);
3340             std::vector<char> vals(sz);
3341             std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin());
3342             return self->findIdFirstEqualTuple(vals);
3343           }
3344 %#if PY_VERSION_HEX >= 0x03000000
3345         if(PyUnicode_Check(tupl))
3346           {
3347             Py_ssize_t sz=PyUnicode_GET_LENGTH(tupl);
3348             std::vector<char> vals(sz);
3349             std::copy(PyUnicode_AsUTF8(tupl),PyUnicode_AsUTF8(tupl)+sz,vals.begin());
3350             return self->findIdFirstEqualTuple(vals);
3351           }
3352 %#endif
3353         else
3354           throw INTERP_KERNEL::Exception("DataArrayAsciiChar::findIdFirstEqualTuple : only strings in input supported !");
3355       }
3356
3357       mcIdType findIdSequence(PyObject *strOrListOfInt) const
3358       {
3359         if(PyString_Check(strOrListOfInt))
3360           {
3361             Py_ssize_t sz=PyString_Size(strOrListOfInt);
3362             std::vector<char> vals(sz);
3363             std::copy(PyString_AsString(strOrListOfInt),PyString_AsString(strOrListOfInt)+sz,vals.begin());
3364             return self->findIdSequence(vals);
3365           }
3366 %#if PY_VERSION_HEX >= 0x03000000
3367         else if(PyUnicode_Check(strOrListOfInt))
3368           {
3369             Py_ssize_t sz=PyUnicode_GET_LENGTH(strOrListOfInt);
3370             std::vector<char> vals(sz);
3371             std::copy(PyUnicode_AsUTF8(strOrListOfInt),PyUnicode_AsUTF8(strOrListOfInt)+sz,vals.begin());
3372             return self->findIdSequence(vals);
3373           }
3374 %#endif
3375         else
3376           throw INTERP_KERNEL::Exception("DataArrayAsciiChar::search : only strings in input supported !");
3377       }
3378
3379       PyObject *getTuple(mcIdType tupleId) const
3380       {
3381         std::size_t sz=self->getNumberOfComponents();
3382         INTERP_KERNEL::AutoPtr<char> tmp=new char[sz+1]; tmp[sz]='\0';
3383         self->getTuple(tupleId,tmp);
3384         return PyString_FromString(tmp);
3385       }
3386
3387       PyObject *getMaxValue() const
3388       {
3389         mcIdType tmp;
3390         char tmp2[2]; tmp2[1]='\0';
3391         tmp2[0]=self->getMaxValue(tmp);
3392         PyObject *ret=PyTuple_New(2);
3393         PyTuple_SetItem(ret,0,PyString_FromString(tmp2));
3394         PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
3395         return ret;
3396       }
3397
3398       PyObject *getMinValue() const
3399       {
3400         mcIdType tmp;
3401         char tmp2[2]; tmp2[1]='\0';
3402         tmp2[0]=self->getMinValue(tmp);
3403         PyObject *ret=PyTuple_New(2);
3404         PyTuple_SetItem(ret,0,PyString_FromString(tmp2));
3405         PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
3406         return ret;
3407       }
3408
3409       mcIdType index(PyObject *obj) const
3410       {
3411         std::size_t nbOfCompo=self->getNumberOfComponents();
3412         switch(nbOfCompo)
3413           {
3414           case 1:
3415             {
3416               if(PyString_Check(obj))
3417                 {
3418                   Py_ssize_t sz=PyString_Size(obj);
3419                   char *pt=PyString_AsString(obj);
3420                   if(sz==1)
3421                     return self->findIdFirstEqual(pt[0]);
3422                   else
3423                     throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find a string with size different from 1 !");
3424                 }
3425 %#if PY_VERSION_HEX >= 0x03000000
3426               if(PyUnicode_Check(obj))
3427                 {
3428                   Py_ssize_t sz;
3429                   const char *pt=PyUnicode_AsUTF8AndSize(obj, &sz);
3430                   if(sz==1)
3431                     return self->findIdFirstEqual(pt[0]);
3432                   else
3433                     throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find a string with size different from 1 !");
3434                 }
3435 %#endif
3436               else
3437                 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find an element which is not an integer !");
3438             }
3439           default:
3440             return MEDCoupling_DataArrayAsciiChar_findIdFirstEqualTuple(self,obj);
3441           }
3442       }
3443
3444       bool __contains__(PyObject *obj) const
3445       {
3446         std::size_t nbOfCompo=self->getNumberOfComponents();
3447         switch(nbOfCompo)
3448           {
3449           case 0:
3450             return false;
3451           case 1:
3452             {
3453               if(PyString_Check(obj))
3454                 {
3455                   Py_ssize_t sz=PyString_Size(obj);
3456                   char *pt=PyString_AsString(obj);
3457                   if(sz==1)
3458                     return self->presenceOfValue(pt[0]);
3459                   else
3460                     throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find a string with size different from 1 !");
3461                 }
3462 %#if PY_VERSION_HEX >= 0x03000000
3463               if(PyUnicode_Check(obj))
3464                 {
3465                   Py_ssize_t sz;
3466                   const char *pt=PyUnicode_AsUTF8AndSize(obj, &sz);
3467                   if(sz==1)
3468                     return self->presenceOfValue(pt[0]);
3469                   else
3470                     throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find a string with size different from 1 !");
3471                 }
3472 %#endif
3473               else
3474                 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
3475             }
3476           default:
3477             return MEDCoupling_DataArrayAsciiChar_presenceOfTuple(self,obj);
3478           }
3479       }
3480
3481       PyObject *__getitem__(PyObject *obj) const
3482       {
3483         mcIdType sw,iTypppArr;
3484         std::vector<mcIdType> stdvecTyyppArr;
3485         std::pair<mcIdType, std::pair<mcIdType,mcIdType> > sTyyppArr;
3486         MEDCoupling::DataArrayIdType *daIntTyypp=0;
3487         convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,self->getNumberOfTuples(),sw,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp);
3488         switch(sw)
3489           {
3490           case 1:
3491             return MEDCoupling_DataArrayAsciiChar_getTuple(self,iTypppArr);
3492           case 2:
3493             return convertDataArrayChar(self->selectByTupleIdSafe(&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size()), SWIG_POINTER_OWN | 0 );
3494           case 3:
3495             return convertDataArrayChar(self->selectByTupleIdSafeSlice(sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second), SWIG_POINTER_OWN | 0 );
3496           case 4:
3497             return convertDataArrayChar(self->selectByTupleIdSafe(daIntTyypp->begin(),daIntTyypp->end()), SWIG_POINTER_OWN | 0 );
3498           default:
3499             throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__getitem__ : supporting int, list of int, tuple of int, DataArrayIdType and slice in input !");
3500           }
3501       }
3502
3503       DataArrayAsciiChar *__setitem__(PyObject *obj, PyObject *value)
3504       {
3505         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.";
3506         mcIdType sw1,iTypppArr;
3507         std::vector<mcIdType> stdvecTyyppArr;
3508         std::pair<mcIdType, std::pair<mcIdType,mcIdType> > sTyyppArr;
3509         MEDCoupling::DataArrayIdType *daIntTyypp=0;
3510         mcIdType nbOfCompo=ToIdType(self->getNumberOfComponents());
3511         mcIdType nbOfTuples=self->getNumberOfTuples();
3512         convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbOfTuples,sw1,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp);
3513         mcIdType sw2;
3514         char vc; std::string sc; std::vector<std::string> vsc; DataArrayChar *dacc=0;
3515         convertObjToPossibleCpp6(value,sw2,vc,sc,vsc,dacc);
3516         switch(sw1)
3517           {
3518           case 1:
3519             {//obj int
3520               switch(sw2)
3521                 {//value char
3522                 case 1:
3523                   {
3524                     self->setPartOfValuesSimple3(vc,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1);
3525                     return self;
3526                   }
3527                   //value string
3528                 case 2:
3529                   {
3530                     MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3531                     self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3532                     return self;
3533                   }
3534                   //value vector<string>
3535                 case 3:
3536                   {
3537                     MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3538                     self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3539                     return self;
3540                   }
3541                   //value DataArrayChar
3542                 case 4:
3543                   {
3544                     self->setPartOfValues3(dacc,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3545                     return self;
3546                   }
3547                 default:
3548                   throw INTERP_KERNEL::Exception(msg);
3549                 }
3550             }
3551           case 2:
3552             {//obj list-tuple[int]
3553               switch(sw2)
3554                 {
3555                   {//value char
3556                   case 1:
3557                     {
3558                       self->setPartOfValuesSimple3(vc,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1);
3559                       return self;
3560                     }
3561                     //value string
3562                   case 2:
3563                     {
3564                       MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3565                       self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3566                       return self;
3567                     }
3568                     //value vector<string>
3569                   case 3:
3570                     {
3571                       MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3572                       self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3573                       return self;
3574                     }
3575                     //value DataArrayChar
3576                   case 4:
3577                     {
3578                       self->setPartOfValues3(dacc,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3579                       return self;
3580                     }
3581                   default:
3582                     throw INTERP_KERNEL::Exception(msg);
3583                   }
3584                 }
3585             }
3586           case 3:
3587             {//slice
3588               switch(sw2)
3589                 {
3590                   {//value char
3591                   case 1:
3592                     {
3593                       self->setPartOfValuesSimple1(vc,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1);
3594                       return self;
3595                     }
3596                     //value string
3597                   case 2:
3598                     {
3599                       MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3600                       self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3601                       return self;
3602                     }
3603                     //value vector<string>
3604                   case 3:
3605                     {
3606                       MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3607                       self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3608                       return self;
3609                     }
3610                     //value DataArrayChar
3611                   case 4:
3612                     {
3613                       self->setPartOfValues1(dacc,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3614                       return self;
3615                     }
3616                   default:
3617                     throw INTERP_KERNEL::Exception(msg);
3618                   }
3619                 }
3620             }
3621           case 4:
3622             {//DataArrayIdType
3623               switch(sw2)
3624                 {
3625                   {//value char
3626                   case 1:
3627                     {
3628                       self->setPartOfValuesSimple3(vc,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1);
3629                       return self;
3630                     }
3631                     //value string
3632                   case 2:
3633                     {
3634                       MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3635                       self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3636                       return self;
3637                     }
3638                     //value vector<string>
3639                   case 3:
3640                     {
3641                       MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3642                       self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3643                       return self;
3644                     }
3645                     //value DataArrayChar
3646                   case 4:
3647                     {
3648                       self->setPartOfValues3(dacc,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3649                       return self;
3650                     }
3651                   default:
3652                     throw INTERP_KERNEL::Exception(msg);
3653                   }
3654                 }
3655             }
3656           default:
3657             throw INTERP_KERNEL::Exception(msg);
3658           }
3659       }
3660     }
3661   };
3662
3663   class DataArrayAsciiCharTuple;
3664
3665   class DataArrayAsciiCharIterator
3666   {
3667   public:
3668     DataArrayAsciiCharIterator(DataArrayAsciiChar *da);
3669     ~DataArrayAsciiCharIterator();
3670     %extend
3671     {
3672       PyObject *next()
3673       {
3674         DataArrayAsciiCharTuple *ret=self->nextt();
3675         if(ret)
3676           return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayAsciiCharTuple,SWIG_POINTER_OWN | 0);
3677         else
3678           {
3679             PyErr_SetString(PyExc_StopIteration,"No more data.");
3680             return 0;
3681           }
3682       }
3683     }
3684   };
3685
3686   class DataArrayAsciiCharTuple
3687   {
3688   public:
3689     std::size_t getNumberOfCompo() const;
3690     DataArrayAsciiChar *buildDAAsciiChar(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
3691     %extend
3692     {
3693       std::string __str__() const
3694       {
3695         return self->repr();
3696       }
3697
3698       DataArrayAsciiChar *buildDAAsciiChar()
3699       {
3700         return self->buildDAAsciiChar(1,self->getNumberOfCompo());
3701       }
3702     }
3703   };
3704
3705 }
3706
3707 %inline
3708 {
3709   MEDCoupling::DataArrayByte *FromPyIntPtrToDataArrayByte(long intPtr)
3710   {
3711     MEDCoupling::DataArrayByte *ret(reinterpret_cast<MEDCoupling::DataArrayByte *>(intPtr));
3712     return ret;
3713   }
3714 }
3715
3716 %include "DataArrayInt.i"
3717
3718
3719 %pythoncode %{
3720 def MEDCouplingStdReduceFunct(cls,params):
3721     a,b=params
3722     ret=object.__new__(cls)
3723     ret.__init__(*a)
3724     ret.__setstate__(b)
3725     return ret
3726
3727 def MEDCouplingDataArrayDoubleReduce(self):
3728     if not MEDCouplingHasNumPyBindings():
3729       raise InterpKernelException("PyWrap of DataArrayDouble.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3730     return MEDCouplingStdReduceFunct,(DataArrayDouble,((self.toNumPyArray(),),(self.__getstate__()),))
3731
3732 def MEDCouplingDataArrayInt32Reduce(self):
3733     if not MEDCouplingHasNumPyBindings():
3734       raise InterpKernelException("PyWrap of DataArrayIdType.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3735     return MEDCouplingStdReduceFunct,(DataArrayInt32,((self.toNumPyArray(),),(self.__getstate__()),))
3736
3737 def MEDCouplingDataArrayInt64Reduce(self):
3738     if not MEDCouplingHasNumPyBindings():
3739       raise InterpKernelException("PyWrap of DataArrayIdType.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3740     return MEDCouplingStdReduceFunct,(DataArrayInt64,((self.toNumPyArray(),),(self.__getstate__()),))
3741
3742 def MEDCouplingDataArrayByteReduce(self):
3743     if not MEDCouplingHasNumPyBindings():
3744       raise InterpKernelException("PyWrap of DataArrayByte.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3745     return MEDCouplingStdReduceFunct,(DataArrayByte,((self.toNumPyArray(),),(self.__getstate__()),))
3746
3747 def MEDCouplingDataArrayFloatReduce(self):
3748     if not MEDCouplingHasNumPyBindings():
3749       raise InterpKernelException("PyWrap of DataArrayFloat.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3750     return MEDCouplingStdReduceFunct,(DataArrayFloat,((self.toNumPyArray(),),(self.__getstate__()),))
3751
3752 if MEDCouplingUse64BitIDs():
3753   DataArrayInt=DataArrayInt64
3754 else:
3755   DataArrayInt=DataArrayInt32
3756 pass
3757
3758 %}