src/MEDCoupling_Swig/MEDCouplingMemArray.i

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