src/MEDCoupling_Swig/MEDCouplingMemArray.i

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