src/MEDCoupling_Swig/MEDCouplingMemArray.i

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