src/MEDCoupling_Swig/MEDCouplingMemArray.i

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