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