src/MEDCoupling_Swig/MEDCouplingMemArray.i

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