src/MEDCoupling_Swig/MEDCouplingMemArray.i

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