1 // Copyright (C) 2007-2020 CEA/DEN, EDF R&D
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.
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.
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
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
19 // Author : Anthony Geay (EDF R&D)
22 %typemap(out) MEDCoupling::DataArray*
24 $result=convertDataArray($1,$owner);
27 %typemap(out) DataArray*
29 $result=convertDataArray($1,$owner);
34 %typemap(out) MEDCoupling::DataArrayChar*
36 $result=convertDataArrayChar($1,$owner);
39 %typemap(out) DataArrayChar*
41 $result=convertDataArrayChar($1,$owner);
44 %typemap(out) MCAuto<MEDCoupling::DataArrayInt32>
46 $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt32,SWIG_POINTER_OWN|0);
49 %typemap(out) MCAuto<MEDCoupling::DataArrayInt64>
51 $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt64,SWIG_POINTER_OWN|0);
54 %typemap(out) MCAuto<MEDCoupling::DataArrayIdType>
56 $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTITraits<mcIdType>::TI,SWIG_POINTER_OWN|0);
59 %typemap(out) MCAuto<MEDCoupling::DataArrayDouble>
61 $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble,SWIG_POINTER_OWN|0);
64 %typemap(out) MCAuto<MEDCoupling::DataArrayFloat>
66 $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayFloat,SWIG_POINTER_OWN|0);
69 %typemap(out) MCAuto<MEDCoupling::MapII>
71 $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTYPE_p_MEDCoupling__MapII,SWIG_POINTER_OWN|0);
75 %newobject MEDCoupling::DataArray::deepCopy;
76 %newobject MEDCoupling::DataArray::copySorted;
77 %newobject MEDCoupling::DataArray::buildNewEmptyInstance;
78 %newobject MEDCoupling::DataArray::selectByTupleRanges;
79 %newobject MEDCoupling::DataArray::selectByTupleId;
80 %newobject MEDCoupling::DataArray::selectByTupleIdSafe;
81 %newobject MEDCoupling::DataArray::selectByTupleIdSafeSlice;
82 %newobject MEDCoupling::DataArray::Aggregate;
83 %newobject MEDCoupling::DataArrayFloat::New;
84 %newobject MEDCoupling::DataArrayFloat::iterator;
85 %newobject MEDCoupling::DataArrayFloat::__iter__;
86 %newobject MEDCoupling::DataArrayFloat::Meld;
87 %newobject MEDCoupling::DataArrayFloat::__rmul__;
88 %newobject MEDCoupling::DataArrayInt32::New;
89 %newobject MEDCoupling::DataArrayInt32::__iter__;
90 %newobject MEDCoupling::DataArrayInt32::performCopyOrIncrRef;
91 %newobject MEDCoupling::DataArrayInt32::subArray;
92 %newobject MEDCoupling::DataArrayInt32::changeNbOfComponents;
93 %newobject MEDCoupling::DataArrayInt32::accumulatePerChunck;
94 %newobject MEDCoupling::DataArrayInt32::checkAndPreparePermutation;
95 %newobject MEDCoupling::DataArrayInt32::transformWithIndArrR;
96 %newobject MEDCoupling::DataArrayInt32::renumber;
97 %newobject MEDCoupling::DataArrayInt32::renumberR;
98 %newobject MEDCoupling::DataArrayInt32::renumberAndReduce;
99 %newobject MEDCoupling::DataArrayInt32::invertArrayO2N2N2O;
100 %newobject MEDCoupling::DataArrayInt32::invertArrayN2O2O2N;
101 %newobject MEDCoupling::DataArrayInt32::invertArrayO2N2N2OBis;
102 %newobject MEDCoupling::DataArrayInt32::findIdsEqual;
103 %newobject MEDCoupling::DataArrayInt32::findIdsNotEqual;
104 %newobject MEDCoupling::DataArrayInt32::findIdsEqualList;
105 %newobject MEDCoupling::DataArrayInt32::findIdsNotEqualList;
106 %newobject MEDCoupling::DataArrayInt32::findIdsEqualTuple;
107 %newobject MEDCoupling::DataArrayInt32::findIdForEach;
108 %newobject MEDCoupling::DataArrayInt32::sumPerTuple;
109 %newobject MEDCoupling::DataArrayInt32::negate;
110 %newobject MEDCoupling::DataArrayInt32::computeAbs;
111 %newobject MEDCoupling::DataArrayInt32::findIdsInRange;
112 %newobject MEDCoupling::DataArrayInt32::findIdsNotInRange;
113 %newobject MEDCoupling::DataArrayInt32::findIdsStrictlyNegative;
114 %newobject MEDCoupling::DataArrayInt32::Aggregate;
115 %newobject MEDCoupling::DataArrayInt32::AggregateIndexes;
116 %newobject MEDCoupling::DataArrayInt32::Meld;
117 %newobject MEDCoupling::DataArrayInt32::Add;
118 %newobject MEDCoupling::DataArrayInt32::Substract;
119 %newobject MEDCoupling::DataArrayInt32::Multiply;
120 %newobject MEDCoupling::DataArrayInt32::Divide;
121 %newobject MEDCoupling::DataArrayInt32::Pow;
122 %newobject MEDCoupling::DataArrayInt32::BuildUnion;
123 %newobject MEDCoupling::DataArrayInt32::BuildIntersection;
124 %newobject MEDCoupling::DataArrayInt32::Range;
125 %newobject MEDCoupling::DataArrayInt32::indicesOfSubPart;
126 %newobject MEDCoupling::DataArrayInt32::fromNoInterlace;
127 %newobject MEDCoupling::DataArrayInt32::toNoInterlace;
128 %newobject MEDCoupling::DataArrayInt32::buildComplement;
129 %newobject MEDCoupling::DataArrayInt32::buildUnion;
130 %newobject MEDCoupling::DataArrayInt32::buildSubstraction;
131 %newobject MEDCoupling::DataArrayInt32::buildSubstractionOptimized;
132 %newobject MEDCoupling::DataArrayInt32::buildIntersection;
133 %newobject MEDCoupling::DataArrayInt32::indexOfSameConsecutiveValueGroups;
134 %newobject MEDCoupling::DataArrayInt32::buildUnique;
135 %newobject MEDCoupling::DataArrayInt32::buildUniqueNotSorted;
136 %newobject MEDCoupling::DataArrayInt32::deltaShiftIndex;
137 %newobject MEDCoupling::DataArrayInt32::buildExplicitArrByRanges;
138 %newobject MEDCoupling::DataArrayInt32::buildExplicitArrOfSliceOnScaledArr;
139 %newobject MEDCoupling::DataArrayInt32::findRangeIdForEachTuple;
140 %newobject MEDCoupling::DataArrayInt32::findIdInRangeForEachTuple;
141 %newobject MEDCoupling::DataArrayInt32::duplicateEachTupleNTimes;
142 %newobject MEDCoupling::DataArrayInt32::occurenceRankInThis;
143 %newobject MEDCoupling::DataArrayInt32::buildPermutationArr;
144 %newobject MEDCoupling::DataArrayInt32::buildPermArrPerLevel;
145 %newobject MEDCoupling::DataArrayInt32::getDifferentValues;
146 %newobject MEDCoupling::DataArrayInt32::FindPermutationFromFirstToSecond;
147 %newobject MEDCoupling::DataArrayInt32::FindPermutationFromFirstToSecondDuplicate;
148 %newobject MEDCoupling::DataArrayInt32::CheckAndPreparePermutation;
149 %newobject MEDCoupling::DataArrayInt32::__neg__;
150 %newobject MEDCoupling::DataArrayInt32::__add__;
151 %newobject MEDCoupling::DataArrayInt32::__radd__;
152 %newobject MEDCoupling::DataArrayInt32::__sub__;
153 %newobject MEDCoupling::DataArrayInt32::__rsub__;
154 %newobject MEDCoupling::DataArrayInt32::__mul__;
155 %newobject MEDCoupling::DataArrayInt32::__rmul__;
156 %newobject MEDCoupling::DataArrayInt32::__div__;
157 %newobject MEDCoupling::DataArrayInt32::__rdiv__;
158 %newobject MEDCoupling::DataArrayInt32::__mod__;
159 %newobject MEDCoupling::DataArrayInt32::__rmod__;
160 %newobject MEDCoupling::DataArrayInt32::__pow__;
161 %newobject MEDCoupling::DataArrayInt32::__rpow__;
162 %newobject MEDCoupling::DataArrayInt32Tuple::buildDAInt;
163 %newobject MEDCoupling::DataArrayInt64::New;
164 %newobject MEDCoupling::DataArrayInt64::__iter__;
165 %newobject MEDCoupling::DataArrayInt64::performCopyOrIncrRef;
166 %newobject MEDCoupling::DataArrayInt64::subArray;
167 %newobject MEDCoupling::DataArrayInt64::changeNbOfComponents;
168 %newobject MEDCoupling::DataArrayInt64::accumulatePerChunck;
169 %newobject MEDCoupling::DataArrayInt64::checkAndPreparePermutation;
170 %newobject MEDCoupling::DataArrayInt64::transformWithIndArrR;
171 %newobject MEDCoupling::DataArrayInt64::renumber;
172 %newobject MEDCoupling::DataArrayInt64::renumberR;
173 %newobject MEDCoupling::DataArrayInt64::renumberAndReduce;
174 %newobject MEDCoupling::DataArrayInt64::invertArrayO2N2N2O;
175 %newobject MEDCoupling::DataArrayInt64::invertArrayN2O2O2N;
176 %newobject MEDCoupling::DataArrayInt64::invertArrayO2N2N2OBis;
177 %newobject MEDCoupling::DataArrayInt64::findIdsEqual;
178 %newobject MEDCoupling::DataArrayInt64::findIdsNotEqual;
179 %newobject MEDCoupling::DataArrayInt64::findIdsEqualList;
180 %newobject MEDCoupling::DataArrayInt64::findIdsNotEqualList;
181 %newobject MEDCoupling::DataArrayInt64::findIdsEqualTuple;
182 %newobject MEDCoupling::DataArrayInt64::findIdForEach;
183 %newobject MEDCoupling::DataArrayInt64::sumPerTuple;
184 %newobject MEDCoupling::DataArrayInt64::negate;
185 %newobject MEDCoupling::DataArrayInt64::computeAbs;
186 %newobject MEDCoupling::DataArrayInt64::findIdsInRange;
187 %newobject MEDCoupling::DataArrayInt64::findIdsNotInRange;
188 %newobject MEDCoupling::DataArrayInt64::findIdsStrictlyNegative;
189 %newobject MEDCoupling::DataArrayInt64::Aggregate;
190 %newobject MEDCoupling::DataArrayInt64::AggregateIndexes;
191 %newobject MEDCoupling::DataArrayInt64::Meld;
192 %newobject MEDCoupling::DataArrayInt64::Add;
193 %newobject MEDCoupling::DataArrayInt64::Substract;
194 %newobject MEDCoupling::DataArrayInt64::Multiply;
195 %newobject MEDCoupling::DataArrayInt64::Divide;
196 %newobject MEDCoupling::DataArrayInt64::Pow;
197 %newobject MEDCoupling::DataArrayInt64::BuildUnion;
198 %newobject MEDCoupling::DataArrayInt64::BuildIntersection;
199 %newobject MEDCoupling::DataArrayInt64::Range;
200 %newobject MEDCoupling::DataArrayInt64::indicesOfSubPart;
201 %newobject MEDCoupling::DataArrayInt64::fromNoInterlace;
202 %newobject MEDCoupling::DataArrayInt64::toNoInterlace;
203 %newobject MEDCoupling::DataArrayInt64::buildComplement;
204 %newobject MEDCoupling::DataArrayInt64::buildUnion;
205 %newobject MEDCoupling::DataArrayInt64::buildSubstraction;
206 %newobject MEDCoupling::DataArrayInt64::buildSubstractionOptimized;
207 %newobject MEDCoupling::DataArrayInt64::buildIntersection;
208 %newobject MEDCoupling::DataArrayInt64::indexOfSameConsecutiveValueGroups;
209 %newobject MEDCoupling::DataArrayInt64::buildUnique;
210 %newobject MEDCoupling::DataArrayInt64::buildUniqueNotSorted;
211 %newobject MEDCoupling::DataArrayInt64::deltaShiftIndex;
212 %newobject MEDCoupling::DataArrayInt64::buildExplicitArrByRanges;
213 %newobject MEDCoupling::DataArrayInt64::buildExplicitArrOfSliceOnScaledArr;
214 %newobject MEDCoupling::DataArrayInt64::findRangeIdForEachTuple;
215 %newobject MEDCoupling::DataArrayInt64::findIdInRangeForEachTuple;
216 %newobject MEDCoupling::DataArrayInt64::duplicateEachTupleNTimes;
217 %newobject MEDCoupling::DataArrayInt64::occurenceRankInThis;
218 %newobject MEDCoupling::DataArrayInt64::buildPermutationArr;
219 %newobject MEDCoupling::DataArrayInt64::buildPermArrPerLevel;
220 %newobject MEDCoupling::DataArrayInt64::getDifferentValues;
221 %newobject MEDCoupling::DataArrayInt64::FindPermutationFromFirstToSecond;
222 %newobject MEDCoupling::DataArrayInt64::FindPermutationFromFirstToSecondDuplicate;
223 %newobject MEDCoupling::DataArrayInt64::CheckAndPreparePermutation;
224 %newobject MEDCoupling::DataArrayInt64::__neg__;
225 %newobject MEDCoupling::DataArrayInt64::__add__;
226 %newobject MEDCoupling::DataArrayInt64::__radd__;
227 %newobject MEDCoupling::DataArrayInt64::__sub__;
228 %newobject MEDCoupling::DataArrayInt64::__rsub__;
229 %newobject MEDCoupling::DataArrayInt64::__mul__;
230 %newobject MEDCoupling::DataArrayInt64::__rmul__;
231 %newobject MEDCoupling::DataArrayInt64::__div__;
232 %newobject MEDCoupling::DataArrayInt64::__rdiv__;
233 %newobject MEDCoupling::DataArrayInt64::__mod__;
234 %newobject MEDCoupling::DataArrayInt64::__rmod__;
235 %newobject MEDCoupling::DataArrayInt64::__pow__;
236 %newobject MEDCoupling::DataArrayInt64::__rpow__;
237 %newobject MEDCoupling::DataArrayInt64Tuple::buildDAInt;
238 %newobject MEDCoupling::DataArrayChar::convertToIntArr;
239 %newobject MEDCoupling::DataArrayChar::renumber;
240 %newobject MEDCoupling::DataArrayChar::renumberR;
241 %newobject MEDCoupling::DataArrayChar::renumberAndReduce;
242 %newobject MEDCoupling::DataArrayChar::changeNbOfComponents;
243 %newobject MEDCoupling::DataArrayChar::findIdsEqual;
244 %newobject MEDCoupling::DataArrayChar::findIdsNotEqual;
245 %newobject MEDCoupling::DataArrayChar::Aggregate;
246 %newobject MEDCoupling::DataArrayChar::Meld;
247 %newobject MEDCoupling::DataArrayByte::New;
248 %newobject MEDCoupling::DataArrayByte::__iter__;
249 %newobject MEDCoupling::DataArrayByte::performCopyOrIncrRef;
250 %newobject MEDCoupling::DataArrayByteTuple::buildDAByte;
251 %newobject MEDCoupling::DataArrayChar::subArray;
252 %newobject MEDCoupling::DataArrayAsciiChar::New;
253 %newobject MEDCoupling::DataArrayAsciiChar::__iter__;
254 %newobject MEDCoupling::DataArrayAsciiChar::performCopyOrIncrRef;
255 %newobject MEDCoupling::DataArrayAsciiCharTuple::buildDAAsciiChar;
256 %newobject MEDCoupling::DataArrayDouble::New;
257 %newobject MEDCoupling::DataArrayDouble::__iter__;
258 %newobject MEDCoupling::DataArrayDouble::performCopyOrIncrRef;
259 %newobject MEDCoupling::DataArrayDouble::Aggregate;
260 %newobject MEDCoupling::DataArrayDouble::Meld;
261 %newobject MEDCoupling::DataArrayDouble::Dot;
262 %newobject MEDCoupling::DataArrayDouble::CrossProduct;
263 %newobject MEDCoupling::DataArrayDouble::Add;
264 %newobject MEDCoupling::DataArrayDouble::Substract;
265 %newobject MEDCoupling::DataArrayDouble::Multiply;
266 %newobject MEDCoupling::DataArrayDouble::Divide;
267 %newobject MEDCoupling::DataArrayDouble::Pow;
268 %newobject MEDCoupling::DataArrayDouble::symmetry3DPlane;
269 %newobject MEDCoupling::DataArrayDouble::subArray;
270 %newobject MEDCoupling::DataArrayDouble::changeNbOfComponents;
271 %newobject MEDCoupling::DataArrayDouble::accumulatePerChunck;
272 %newobject MEDCoupling::DataArrayDouble::findIdsInRange;
273 %newobject MEDCoupling::DataArrayDouble::findIdsNotInRange;
274 %newobject MEDCoupling::DataArrayDouble::findIdsStrictlyNegative;
275 %newobject MEDCoupling::DataArrayDouble::negate;
276 %newobject MEDCoupling::DataArrayDouble::computeAbs;
277 %newobject MEDCoupling::DataArrayDouble::applyFunc;
278 %newobject MEDCoupling::DataArrayDouble::applyFuncCompo;
279 %newobject MEDCoupling::DataArrayDouble::applyFuncNamedCompo;
280 %newobject MEDCoupling::DataArrayDouble::doublyContractedProduct;
281 %newobject MEDCoupling::DataArrayDouble::determinant;
282 %newobject MEDCoupling::DataArrayDouble::eigenValues;
283 %newobject MEDCoupling::DataArrayDouble::eigenVectors;
284 %newobject MEDCoupling::DataArrayDouble::inverse;
285 %newobject MEDCoupling::DataArrayDouble::trace;
286 %newobject MEDCoupling::DataArrayDouble::deviator;
287 %newobject MEDCoupling::DataArrayDouble::magnitude;
288 %newobject MEDCoupling::DataArrayDouble::maxPerTuple;
289 %newobject MEDCoupling::DataArrayDouble::sumPerTuple;
290 %newobject MEDCoupling::DataArrayDouble::computeBBoxPerTuple;
291 %newobject MEDCoupling::DataArrayDouble::buildEuclidianDistanceDenseMatrix;
292 %newobject MEDCoupling::DataArrayDouble::buildEuclidianDistanceDenseMatrixWith;
293 %newobject MEDCoupling::DataArrayDouble::renumber;
294 %newobject MEDCoupling::DataArrayDouble::renumberR;
295 %newobject MEDCoupling::DataArrayDouble::renumberAndReduce;
296 %newobject MEDCoupling::DataArrayDouble::fromNoInterlace;
297 %newobject MEDCoupling::DataArrayDouble::toNoInterlace;
298 %newobject MEDCoupling::DataArrayDouble::fromPolarToCart;
299 %newobject MEDCoupling::DataArrayDouble::fromCylToCart;
300 %newobject MEDCoupling::DataArrayDouble::fromSpherToCart;
301 %newobject MEDCoupling::DataArrayDouble::fromCartToPolar;
302 %newobject MEDCoupling::DataArrayDouble::fromCartToCyl;
303 %newobject MEDCoupling::DataArrayDouble::fromCartToSpher;
304 %newobject MEDCoupling::DataArrayDouble::fromCartToCylGiven;
305 %newobject MEDCoupling::DataArrayDouble::cartesianize;
306 %newobject MEDCoupling::DataArrayDouble::getDifferentValues;
307 %newobject MEDCoupling::DataArrayDouble::findClosestTupleId;
308 %newobject MEDCoupling::DataArrayDouble::computeNbOfInteractionsWith;
309 %newobject MEDCoupling::DataArrayDouble::duplicateEachTupleNTimes;
310 %newobject MEDCoupling::DataArrayDouble::__neg__;
311 %newobject MEDCoupling::DataArrayDouble::__radd__;
312 %newobject MEDCoupling::DataArrayDouble::__rsub__;
313 %newobject MEDCoupling::DataArrayDouble::__rmul__;
314 %newobject MEDCoupling::DataArrayDouble::__rdiv__;
315 %newobject MEDCoupling::DataArrayDouble::__pow__;
316 %newobject MEDCoupling::DataArrayDouble::__rpow__;
317 %newobject MEDCoupling::DataArrayDoubleTuple::buildDADouble;
319 %newobject MEDCoupling::PartDefinition::New;
320 %newobject MEDCoupling::PartDefinition::toDAI;
321 %newobject MEDCoupling::PartDefinition::__add__;
322 %newobject MEDCoupling::PartDefinition::composeWith;
323 %newobject MEDCoupling::PartDefinition::tryToSimplify;
324 %newobject MEDCoupling::DataArrayPartDefinition::New;
325 %newobject MEDCoupling::SlicePartDefinition::New;
328 %feature("unref") DataArray "$this->decrRef();"
329 %feature("unref") DataArrayDouble "$this->decrRef();"
330 %feature("unref") DataArrayInt32 "$this->decrRef();"
331 %feature("unref") DataArrayInt64 "$this->decrRef();"
332 %feature("unref") DataArrayChar "$this->decrRef();"
333 %feature("unref") DataArrayAsciiChar "$this->decrRef();"
334 %feature("unref") DataArrayByte "$this->decrRef();"
336 %feature("unref") MapII "$this->decrRef();"
337 %feature("unref") PartDefinition "$this->decrRef();"
338 %feature("unref") DataArrayPartDefinition "$this->decrRef();"
339 %feature("unref") SlicePartDefinition "$this->decrRef();"
341 namespace MEDCoupling
348 } MEDCouplingAxisType;
350 class DataArrayInt32;
351 class DataArrayInt64;
353 #ifndef MEDCOUPLING_USE_64BIT_IDS
354 typedef DataArrayInt32 DataArrayIdType;
355 #define DataArrayIdType DataArrayInt32
357 typedef DataArrayInt64 DataArrayIdType;
358 #define DataArrayIdType DataArrayInt64
361 class MapII : public RefCountObject, public TimeLabel
364 static MCAuto< MapII > New();
367 class PartDefinition : public RefCountObject, public TimeLabel
370 static PartDefinition *New(int start, int stop, int step);
371 static PartDefinition *New(DataArrayIdType *listOfIds);
372 virtual DataArrayIdType *toDAI() const;
373 virtual int getNumberOfElems() const;
374 virtual std::string getRepr() const;
375 virtual PartDefinition *composeWith(const PartDefinition *other) const;
376 virtual void checkConsistencyLight() const;
377 virtual PartDefinition *tryToSimplify() const;
380 virtual PartDefinition *__add__(const PartDefinition& other) const
382 return (*self)+other;
385 virtual PyObject *isEqual(const PartDefinition *other) const
388 bool ret0(self->isEqual(other,ret1));
389 PyObject *ret=PyTuple_New(2);
390 PyObject *ret0Py=ret0?Py_True:Py_False;
392 PyTuple_SetItem(ret,0,ret0Py);
393 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
397 virtual PyObject *deepCopy() const
399 return convertPartDefinition(self->deepCopy(),SWIG_POINTER_OWN | 0);
403 virtual ~PartDefinition();
406 class DataArrayPartDefinition : public PartDefinition
409 static DataArrayPartDefinition *New(DataArrayIdType *listOfIds);
412 DataArrayPartDefinition(DataArrayIdType *listOfIds)
414 return DataArrayPartDefinition::New(listOfIds);
417 std::string __str__() const
419 return self->getRepr();
422 std::string __repr__() const
424 std::ostringstream oss; oss << "DataArrayPartDefinition C++ instance at " << self << "." << std::endl;
425 oss << self->getRepr();
430 virtual ~DataArrayPartDefinition();
433 class SlicePartDefinition : public PartDefinition
436 static SlicePartDefinition *New(int start, int stop, int step);
437 int getEffectiveStop() const;
440 SlicePartDefinition(mcIdType start, mcIdType stop, mcIdType step)
442 return SlicePartDefinition::New(start,stop,step);
445 PyObject *getSlice() const
448 self->getSlice(a,b,c);
449 return PySlice_New(PyInt_FromLong(a),PyInt_FromLong(b),PyInt_FromLong(c));
452 std::string __str__() const
454 return self->getRepr();
457 std::string __repr__() const
459 std::ostringstream oss; oss << "SlicePartDefinition C++ instance at " << self << "." << std::endl;
460 oss << self->getRepr();
465 virtual ~SlicePartDefinition();
468 class DataArray : public RefCountObject, public TimeLabel
471 void setName(const std::string& name);
472 void copyStringInfoFrom(const DataArray& other);
473 void copyPartOfStringInfoFrom(const DataArray& other, const std::vector<std::size_t>& compoIds);
474 void copyPartOfStringInfoFrom2(const std::vector<std::size_t>& compoIds, const DataArray& other);
475 bool areInfoEqualsIfNotWhy(const DataArray& other, std::string& reason) const;
476 bool areInfoEquals(const DataArray& other) const;
477 std::string cppRepr(const std::string& varName) const;
478 std::string getName() const;
479 void setInfoOnComponents(const std::vector<std::string>& info);
480 void setInfoAndChangeNbOfCompo(const std::vector<std::string>& info);
481 std::vector<std::string> getVarsOnComponent() const;
482 std::vector<std::string> getUnitsOnComponent() const;
483 std::string getInfoOnComponent(int i) const;
484 std::string getVarOnComponent(int i) const;
485 std::string getUnitOnComponent(int i) const;
486 void setInfoOnComponent(int i, const std::string& info);
487 int getNumberOfComponents() const;
488 virtual void alloc(int nbOfTuple, int nbOfCompo=1);
489 virtual void reAlloc(int nbOfTuples);
490 virtual bool isAllocated() const;
491 virtual void checkAllocated() const;
492 virtual void desallocate();
493 virtual int getNumberOfTuples() const;
494 virtual std::size_t getNbOfElems() const;
495 virtual std::size_t getNbOfElemAllocated() const;
496 virtual DataArray *deepCopy() const;
497 virtual DataArray *copySorted() const;
498 virtual DataArray *buildNewEmptyInstance() const;
499 virtual DataArray *selectByTupleIdSafeSlice(int bg, int end2, int step) const;
500 virtual void rearrange(int newNbOfCompo);
501 virtual void circularPermutation(int nbOfShift=1);
502 virtual void circularPermutationPerTuple(int nbOfShift=1);
503 virtual void reversePerTuple();
504 void checkNbOfTuples(int nbOfTuples, const std::string& msg) const;
505 void checkNbOfComps(int nbOfCompo, const std::string& msg) const;
506 void checkNbOfTuplesAndComp(const DataArray& other, const std::string& msg) const;
507 void checkNbOfTuplesAndComp(int nbOfTuples, int nbOfCompo, const std::string& msg) const;
508 void checkNbOfElems(mcIdType nbOfElems, const std::string& msg) const;
509 static int GetNumberOfItemGivenBES(int begin, int end, int step, const std::string& msg);
510 static int GetNumberOfItemGivenBESRelative(int begin, int end, int step, const std::string& msg);
511 static int GetPosOfItemGivenBESRelativeNoThrow(int value, int begin, int end, int step);
512 static std::string GetVarNameFromInfo(const std::string& info);
513 static std::string GetUnitFromInfo(const std::string& info);
514 static std::string BuildInfoFromVarAndUnit(const std::string& var, const std::string& unit);
515 static std::string GetAxisTypeRepr(MEDCouplingAxisType at);
516 void updateTime() const;
519 PyObject *getInfoOnComponents() const
521 const std::vector<std::string>& comps=self->getInfoOnComponents();
522 PyObject *ret=PyList_New((mcIdType)comps.size());
523 for(std::size_t i=0;i<comps.size();i++)
524 PyList_SetItem(ret,i,PyString_FromString(comps[i].c_str()));
528 void copyPartOfStringInfoFrom(const DataArray& other, PyObject *li)
530 std::vector<std::size_t> tmp;
531 convertPyToNewIntArr3(li,tmp);
532 self->copyPartOfStringInfoFrom(other,tmp);
535 void copyPartOfStringInfoFrom2(PyObject *li, const DataArray& other)
537 std::vector<std::size_t> tmp;
538 convertPyToNewIntArr3(li,tmp);
539 self->copyPartOfStringInfoFrom2(tmp,other);
542 virtual void renumberInPlace(PyObject *li)
545 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
546 if (!SWIG_IsOK(res1))
549 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
550 if(size!=self->getNumberOfTuples())
552 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
554 self->renumberInPlace(tmp);
558 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
560 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
561 da2->checkAllocated();
562 mcIdType size=self->getNumberOfTuples();
563 if(size!=self->getNumberOfTuples())
565 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
567 self->renumberInPlace(da2->getConstPointer());
571 virtual void renumberInPlaceR(PyObject *li)
574 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
575 if (!SWIG_IsOK(res1))
578 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
579 if(size!=self->getNumberOfTuples())
581 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
583 self->renumberInPlaceR(tmp);
587 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
589 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
590 da2->checkAllocated();
591 mcIdType size=self->getNumberOfTuples();
592 if(size!=self->getNumberOfTuples())
594 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
596 self->renumberInPlaceR(da2->getConstPointer());
600 //tuplesSelec in PyObject * because DataArrayInt is not already existing !
601 virtual void setContigPartOfSelectedValues(mcIdType tupleIdStart, PyObject *aBase, PyObject *tuplesSelec)
603 static const char msg[]="DataArray::setContigPartOfSelectedValuesSlice : 4th parameter \"tuplesSelec\" should be of type DataArrayInt";
604 DataArray *a=CheckAndRetrieveDataArrayInstance(aBase,"DataArray::setContigPartOfSelectedValuesSlice : 3rd parameter \"aBase\" should be of type DataArray");
605 DataArray *tuplesSelecPtr=CheckAndRetrieveDataArrayInstance(tuplesSelec,msg);
606 DataArrayIdType *tuplesSelecPtr2=0;
609 tuplesSelecPtr2=dynamic_cast<DataArrayIdType *>(tuplesSelecPtr);
611 throw INTERP_KERNEL::Exception(msg);
613 self->setContigPartOfSelectedValues(tupleIdStart,a,tuplesSelecPtr2);
616 virtual void setContigPartOfSelectedValuesSlice(mcIdType tupleIdStart, PyObject *aBase, mcIdType bg, mcIdType end2, mcIdType step)
618 DataArray *a=CheckAndRetrieveDataArrayInstance(aBase,"DataArray::setContigPartOfSelectedValuesSlice : 2nd parameter \"aBase\" should be of type DataArray");
619 self->setContigPartOfSelectedValuesSlice(tupleIdStart,a,bg,end2,step);
622 virtual DataArray *selectByTupleRanges(PyObject *li) const
624 std::vector<std::pair<mcIdType,mcIdType> > ranges;
625 convertPyToVectorPairInt(li,ranges);
626 return self->selectByTupleRanges(ranges);
629 virtual DataArray *selectByTupleId(PyObject *li) const
632 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
633 if (!SWIG_IsOK(res1))
636 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
637 return self->selectByTupleId(tmp,tmp+size);
641 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
643 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
644 da2->checkAllocated();
645 return self->selectByTupleId(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
649 virtual DataArray *selectByTupleIdSafe(PyObject *li) const
652 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
653 if (!SWIG_IsOK(res1))
656 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
657 return self->selectByTupleIdSafe(tmp,tmp+size);
661 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
663 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
664 da2->checkAllocated();
665 return self->selectByTupleIdSafe(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
669 virtual PyObject *keepSelectedComponents(PyObject *li) const
671 std::vector<std::size_t> tmp;
672 convertPyToNewIntArr3(li,tmp);
673 DataArray *ret=self->keepSelectedComponents(tmp);
674 return convertDataArray(ret,SWIG_POINTER_OWN | 0 );
677 static PyObject *GetSlice(PyObject *slic, mcIdType sliceId, mcIdType nbOfSlices)
679 if(!PySlice_Check(slic))
680 throw INTERP_KERNEL::Exception("DataArray::GetSlice (wrap) : expecting a pyslice as second (first) parameter !");
681 Py_ssize_t strt=2,stp=2,step=2;
682 GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetSlice (wrap) : the input slice is invalid !");
684 DataArray::GetSlice(ToIdType(strt),ToIdType(stp),ToIdType(step),sliceId,nbOfSlices,a,b);
685 AutoPyPtr ap(PyInt_FromLong(a)),bp(PyInt_FromLong(b)),stepp(PyInt_FromLong(step));
686 return PySlice_New(ap,bp,stepp);
689 PyObject *getSlice(PyObject *slic, mcIdType sliceId, mcIdType nbOfSlices) const
691 if(!PySlice_Check(slic))
692 throw INTERP_KERNEL::Exception("DataArray::getSlice (wrap) : expecting a pyslice as second (first) parameter !");
693 Py_ssize_t strt=2,stp=2,step=2;
694 GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getSlice (wrap) : the input slice is invalid !");
696 DataArray::GetSlice(ToIdType(strt),ToIdType(stp),ToIdType(step),sliceId,nbOfSlices,a,b);
697 AutoPyPtr ap(PyInt_FromLong(a)),bp(PyInt_FromLong(b)),stepp(PyInt_FromLong(step));
698 return PySlice_New(ap,bp,stepp);
701 static mcIdType GetNumberOfItemGivenBES(PyObject *slic)
703 if(!PySlice_Check(slic))
704 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBES (wrap) : expecting a pyslice as second (first) parameter !");
705 Py_ssize_t strt=2,stp=2,step=2;
706 GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetNumberOfItemGivenBES (wrap) : the input slice is invalid !");
707 return DataArray::GetNumberOfItemGivenBES(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
710 static mcIdType GetNumberOfItemGivenBESRelative(PyObject *slic)
712 if(!PySlice_Check(slic))
713 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBESRelative (wrap) : expecting a pyslice as second (first) parameter !");
714 Py_ssize_t strt=2,stp=2,step=2;
715 GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !");
716 return DataArray::GetNumberOfItemGivenBESRelative(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
719 static DataArray *Aggregate(PyObject *arrs)
721 std::vector<const DataArray *> tmp;
722 convertFromPyObjVectorOfObj<const MEDCoupling::DataArray *>(arrs,SWIGTYPE_p_MEDCoupling__DataArray,"DataArray",tmp);
723 return DataArray::Aggregate(tmp);
726 mcIdType getNumberOfItemGivenBES(PyObject *slic) const
728 if(!PySlice_Check(slic))
729 throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBES (wrap) : expecting a pyslice as second (first) parameter !");
730 Py_ssize_t strt=2,stp=2,step=2;
731 GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getNumberOfItemGivenBES (wrap) : the input slice is invalid !");
732 return DataArray::GetNumberOfItemGivenBES(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
735 mcIdType getNumberOfItemGivenBESRelative(PyObject *slic)
737 if(!PySlice_Check(slic))
738 throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBESRelative (wrap) : expecting a pyslice as second (first) parameter !");
739 Py_ssize_t strt=2,stp=2,step=2;
740 GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !");
741 return DataArray::GetNumberOfItemGivenBESRelative(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
744 PyObject *__getstate__() const
746 PyObject *ret(PyTuple_New(2));
747 std::string a0(self->getName());
748 const std::vector<std::string> &a1(self->getInfoOnComponents());
749 PyTuple_SetItem(ret,0,PyString_FromString(a0.c_str()));
751 std::size_t sz(a1.size());
752 PyObject *ret1(PyList_New(sz));
753 for(std::size_t i=0;i<sz;i++)
754 PyList_SetItem(ret1,i,PyString_FromString(a1[i].c_str()));
755 PyTuple_SetItem(ret,1,ret1);
760 void __setstate__(PyObject *inp)
762 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 !";
763 if(!PyTuple_Check(inp))
764 throw INTERP_KERNEL::Exception("DataArrayDouble.__setstate__ : invalid input ! Invalid overwrite of __getstate__ ?");
765 std::size_t sz(PyTuple_Size(inp));
767 throw INTERP_KERNEL::Exception("DataArrayDouble.__setstate__ : invalid tuple in input ! Should be of size 2 ! Invalid overwrite of __getstate__ ?");
768 PyObject *a0(PyTuple_GetItem(inp,0));
769 self->setName(convertPyObjectToStr(a0,MSG));
770 PyObject *a1(PyTuple_GetItem(inp,1));
771 std::vector<std::string> a1cpp;
772 if(!fillStringVector(a1,a1cpp))
773 throw INTERP_KERNEL::Exception(MSG);
774 self->setInfoOnComponents(a1cpp);
779 class DataArrayDouble;
781 class DataArrayFloat : public DataArray
784 static DataArrayFloat *New();
785 void fillWithValue(float val);
786 bool isEqual(const DataArrayFloat& other, float prec) const;
787 bool isEqualWithoutConsideringStr(const DataArrayFloat& other, float prec) const;
788 bool isUniform(float val, float eps) const;
789 void pushBackSilent(float val);
790 void iota(float init=0.);
791 DataArrayFloatIterator *iterator();
792 MCAuto<DataArrayDouble> convertToDblArr() const;
793 static DataArrayFloat *Meld(const DataArrayFloat *a1, const DataArrayFloat *a2);
798 return DataArrayFloat::New();
801 static DataArrayFloat *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
803 return DataArrayT_New<float>(elt0,nbOfTuples,elt2);
806 DataArrayFloat(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
808 return MEDCoupling_DataArrayFloat_New__SWIG_1(elt0,nbOfTuples,elt2);
811 DataArrayFloatIterator *__iter__()
813 return self->iterator();
816 std::string __repr__() const
818 std::ostringstream oss;
819 self->reprQuickOverview(oss);
823 std::string __str__() const
825 return self->reprNotTooLong();
828 mcIdType __len__() const
830 if(self->isAllocated())
832 return self->getNumberOfTuples();
836 throw INTERP_KERNEL::Exception("DataArrayFloat::__len__ : Instance is NOT allocated !");
840 PyObject *getValues() const
842 const float *vals(self->begin());
843 return convertDblArrToPyList<float>(vals,self->getNbOfElems());
846 PyObject *getValuesAsTuple() const
848 const float *vals(self->begin());
849 std::size_t nbOfComp(self->getNumberOfComponents());
850 mcIdType nbOfTuples(self->getNumberOfTuples());
851 return convertDblArrToPyListOfTuple<float>(vals,nbOfComp,nbOfTuples);
854 PyObject *isEqualIfNotWhy(const DataArrayFloat& other, float prec) const
857 bool ret0=self->isEqualIfNotWhy(other,prec,ret1);
858 PyObject *ret=PyTuple_New(2);
859 PyObject *ret0Py=ret0?Py_True:Py_False;
861 PyTuple_SetItem(ret,0,ret0Py);
862 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
866 PyObject *__getitem__(PyObject *obj)
868 return DataArrayT__getitem<float>(self,obj);
871 DataArrayFloat *__setitem__(PyObject *obj, PyObject *value)
873 return DataArrayT__setitem__<float>(self,obj,value);
876 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
878 return DataArrayT_iadd<float>(trueSelf,obj,self);
881 PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
883 return DataArrayT_isub<float>(trueSelf,obj,self);
886 PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
888 return DataArrayT_imul<float>(trueSelf,obj,self);
891 DataArrayFloat *__rmul__(PyObject *obj)
893 return DataArrayFPT_rmul<float>(self,obj);
896 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
898 return DataArrayT_idiv<float>(trueSelf,obj,self);
902 PyObject *toNumPyArray() // not const. It is not a bug !
904 return ToNumPyArray<DataArrayFloat,float>(self,NPY_FLOAT,"DataArrayFloat");
910 class DataArrayFloatTuple;
912 class DataArrayFloatIterator
915 DataArrayFloatIterator(DataArrayFloat *da);
916 ~DataArrayFloatIterator();
921 DataArrayFloatTuple *ret=self->nextt();
923 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayFloatTuple,SWIG_POINTER_OWN|0);
926 PyErr_SetString(PyExc_StopIteration,"No more data.");
933 class DataArrayFloatTuple
936 std::size_t getNumberOfCompo() const;
937 DataArrayFloat *buildDAFloat(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
940 std::string __str__() const
945 float __float__() const
947 return self->floatValue();
950 DataArrayFloat *buildDAFloat()
952 return self->buildDAFloat(1,self->getNumberOfCompo());
955 /*PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
957 MCAuto<DataArrayFloat> ret=self->buildDAFloat(1,self->getNumberOfCompo());
958 MEDCoupling_DataArrayFloat____imul___(ret,0,obj);
959 Py_XINCREF(trueSelf);
965 return PyInt_FromLong(self->getNumberOfCompo());
970 class DataArrayDoubleIterator;
972 class DataArrayDouble : public DataArray
975 static DataArrayDouble *New();
976 double doubleValue() const;
978 void aggregate(const DataArrayDouble *other);
979 DataArrayDouble *performCopyOrIncrRef(bool deepCopy) const;
980 void deepCopyFrom(const DataArrayDouble& other);
981 void reserve(std::size_t nbOfElems);
982 void pushBackSilent(double val);
983 double popBackSilent();
985 void allocIfNecessary(int nbOfTuple, int nbOfCompo);
987 void fillWithValue(double val);
988 void iota(double init=0.);
989 bool isUniform(double val, double eps) const;
990 void sort(bool asc=true);
992 void checkMonotonic(bool increasing, double eps) const;
993 bool isMonotonic(bool increasing, double eps) const;
994 std::string repr() const;
995 std::string reprZip() const;
996 std::string reprNotTooLong() const;
997 bool isEqual(const DataArrayDouble& other, double prec) const;
998 bool isEqualWithoutConsideringStr(const DataArrayDouble& other, double prec) const;
999 DataArrayDouble *fromNoInterlace() const;
1000 DataArrayDouble *toNoInterlace() const;
1001 DataArrayDouble *subArray(int tupleIdBg, int tupleIdEnd=-1) const;
1003 DataArrayDouble *changeNbOfComponents(std::size_t newNbOfComp, double dftValue) const;
1004 void meldWith(const DataArrayDouble *other);
1005 DataArrayDouble *duplicateEachTupleNTimes(int nbTimes) const;
1006 DataArrayDouble *getDifferentValues(double prec, int limitTupleId=-1) const;
1007 DataArrayIdType *findClosestTupleId(const DataArrayDouble *other) const;
1008 DataArrayIdType *computeNbOfInteractionsWith(const DataArrayDouble *otherBBoxFrmt, double eps) const;
1009 void setPartOfValues1(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare=true);
1010 void setPartOfValuesSimple1(double a, mcIdType bgTuples, mcIdType endTuples, mcIdType stepTuples, mcIdType bgComp, mcIdType endComp, mcIdType stepComp);
1011 void setPartOfValuesAdv(const DataArrayDouble *a, const DataArrayIdType *tuplesSelec);
1012 double getIJ(int tupleId, int compoId) const;
1013 double front() const;
1014 double back() const;
1015 double getIJSafe(int tupleId, int compoId) const;
1016 void setIJ(int tupleId, int compoId, double newVal);
1017 void setIJSilent(int tupleId, int compoId, double newVal);
1018 double *getPointer();
1019 void checkNoNullValues() const;
1020 DataArrayDouble *computeBBoxPerTuple(double epsilon=0.0) const;
1021 void recenterForMaxPrecision(double eps);
1022 double getMaxValueInArray() const;
1023 double getMaxAbsValueInArray() const;
1024 double getMinValueInArray() const;
1025 int count(double value, double eps) const;
1026 double getAverageValue() const;
1027 double norm2() const;
1028 double normMax() const;
1029 double normMin() const;
1030 double accumulate(int compId) const;
1031 DataArrayDouble *fromPolarToCart() const;
1032 DataArrayDouble *fromCylToCart() const;
1033 DataArrayDouble *fromSpherToCart() const;
1034 DataArrayDouble *fromCartToPolar() const;
1035 DataArrayDouble *fromCartToCyl() const;
1036 DataArrayDouble *fromCartToSpher() const;
1037 DataArrayDouble *cartesianize(MEDCouplingAxisType atOfThis) const;
1038 DataArrayDouble *doublyContractedProduct() const;
1039 DataArrayDouble *determinant() const;
1040 DataArrayDouble *eigenValues() const;
1041 DataArrayDouble *eigenVectors() const;
1042 DataArrayDouble *inverse() const;
1043 DataArrayDouble *trace() const;
1044 DataArrayDouble *deviator() const;
1045 DataArrayDouble *magnitude() const;
1046 DataArrayDouble *maxPerTuple() const;
1047 DataArrayDouble *sumPerTuple() const;
1048 DataArrayDouble *buildEuclidianDistanceDenseMatrix() const;
1049 DataArrayDouble *buildEuclidianDistanceDenseMatrixWith(const DataArrayDouble *other) const;
1050 void sortPerTuple(bool asc);
1052 DataArrayDouble *computeAbs() const;
1053 void applyLin(double a, double b, int compoId);
1054 void applyLin(double a, double b);
1055 void applyInv(double numerator);
1056 void applyPow(double val);
1057 void applyRPow(double val);
1058 DataArrayDouble *negate() const;
1059 DataArrayDouble *applyFunc(int nbOfComp, FunctionToEvaluate func) const;
1060 DataArrayDouble *applyFunc(int nbOfComp, const std::string& func, bool isSafe=true) const;
1061 DataArrayDouble *applyFunc(const std::string& func, bool isSafe=true) const;
1062 void applyFuncOnThis(const std::string& func, bool isSafe=true);
1063 DataArrayDouble *applyFuncCompo(int nbOfComp, const std::string& func, bool isSafe=true) const;
1064 DataArrayDouble *applyFuncNamedCompo(int nbOfComp, const std::vector<std::string>& varsOrder, const std::string& func, bool isSafe=true) const;
1065 void applyFuncFast32(const std::string& func);
1066 void applyFuncFast64(const std::string& func);
1067 DataArrayIdType *findIdsInRange(double vmin, double vmax) const;
1068 DataArrayIdType *findIdsNotInRange(double vmin, double vmax) const;
1069 DataArrayIdType *findIdsStrictlyNegative() const;
1070 static DataArrayDouble *Aggregate(const DataArrayDouble *a1, const DataArrayDouble *a2);
1071 static DataArrayDouble *Meld(const DataArrayDouble *a1, const DataArrayDouble *a2);
1072 static DataArrayDouble *Dot(const DataArrayDouble *a1, const DataArrayDouble *a2);
1073 static DataArrayDouble *CrossProduct(const DataArrayDouble *a1, const DataArrayDouble *a2);
1074 static DataArrayDouble *Max(const DataArrayDouble *a1, const DataArrayDouble *a2);
1075 static DataArrayDouble *Min(const DataArrayDouble *a1, const DataArrayDouble *a2);
1076 static DataArrayDouble *Add(const DataArrayDouble *a1, const DataArrayDouble *a2);
1077 void addEqual(const DataArrayDouble *other);
1078 static DataArrayDouble *Substract(const DataArrayDouble *a1, const DataArrayDouble *a2);
1079 void substractEqual(const DataArrayDouble *other);
1080 static DataArrayDouble *Multiply(const DataArrayDouble *a1, const DataArrayDouble *a2);
1081 void multiplyEqual(const DataArrayDouble *other);
1082 static DataArrayDouble *Divide(const DataArrayDouble *a1, const DataArrayDouble *a2);
1083 void divideEqual(const DataArrayDouble *other);
1084 static DataArrayDouble *Pow(const DataArrayDouble *a1, const DataArrayDouble *a2);
1085 void powEqual(const DataArrayDouble *other);
1086 MCAuto<DataArrayIdType> findIdsGreaterOrEqualTo(double val) const;
1087 MCAuto<DataArrayIdType> findIdsGreaterThan(double val) const;
1088 MCAuto<DataArrayIdType> findIdsLowerOrEqualTo(double val) const;
1089 MCAuto<DataArrayIdType> findIdsLowerThan(double val) const;
1090 MCAuto<DataArrayInt32> convertToIntArr() const;
1091 MCAuto<DataArrayDouble> selectPartDef(const PartDefinition* pd) const;
1092 MCAuto<DataArrayDouble> cumSum() const;
1093 MCAuto<DataArrayFloat> convertToFloatArr() const;
1098 return DataArrayDouble::New();
1101 static DataArrayDouble *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
1103 return DataArrayT_New<double>(elt0,nbOfTuples,elt2);
1106 DataArrayDouble(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
1108 return MEDCoupling_DataArrayDouble_New__SWIG_1(elt0,nbOfTuples,elt2);
1111 void pushBackValsSilent(PyObject *li)
1114 std::vector<double> bb;
1115 mcIdType sw; mcIdType nbTuples=-1;
1116 const char msg[]="Python wrap of DataArrayDouble::pushBackValsSilent : ";
1117 const double *tmp=convertObjToPossibleCpp5_SingleCompo(li,sw,val,bb,msg,true,nbTuples);
1118 self->pushBackValsSilent(tmp,tmp+nbTuples);
1121 std::string __repr__() const
1123 std::ostringstream oss;
1124 self->reprQuickOverview(oss);
1128 std::string __str__() const
1130 return self->reprNotTooLong();
1133 double __float__() const
1135 return self->doubleValue();
1138 mcIdType __len__() const
1140 if(self->isAllocated())
1142 return self->getNumberOfTuples();
1146 throw INTERP_KERNEL::Exception("DataArrayDouble::__len__ : Instance is NOT allocated !");
1150 PyObject *asArcOfCircle() const
1152 double center[2],radius,ang;
1153 self->asArcOfCircle(center,radius,ang);
1154 PyObject *ret(PyTuple_New(3));
1156 PyObject *ret0(PyList_New(2));
1157 PyList_SetItem(ret0,0,PyFloat_FromDouble(center[0]));
1158 PyList_SetItem(ret0,1,PyFloat_FromDouble(center[1]));
1159 PyTuple_SetItem(ret,0,ret0);
1161 PyTuple_SetItem(ret,1,PyFloat_FromDouble(radius));
1162 PyTuple_SetItem(ret,2,PyFloat_FromDouble(ang));
1166 DataArrayDoubleIterator *__iter__()
1168 return self->iterator();
1171 void setValues(PyObject *li, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
1173 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 !";
1174 if(PyList_Check(li) || PyTuple_Check(li))
1176 if(nbOfTuples && nbOfTuples != Py_None)
1178 if(PyInt_Check(nbOfTuples))
1180 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
1182 throw INTERP_KERNEL::Exception("DataArrayDouble::setValues : should be a positive set of allocated memory !");
1183 if(nbOfComp && nbOfComp != Py_None)
1185 if(PyInt_Check(nbOfComp))
1186 {//DataArrayDouble.setValues([1.,3.,4.,5.],2,2)
1187 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
1189 throw INTERP_KERNEL::Exception("DataArrayDouble::setValues : should be a positive number of components !");
1190 std::vector<double> tmp=fillArrayWithPyListDbl2(li,nbOfTuples1,nbOfCompo);
1191 self->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1194 throw INTERP_KERNEL::Exception(msg);
1197 {//DataArrayDouble.setValues([1.,3.,4.],3)
1199 std::vector<double> tmp=fillArrayWithPyListDbl2(li,nbOfTuples1,tmpp1);
1200 self->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1204 throw INTERP_KERNEL::Exception(msg);
1207 {// DataArrayDouble.setValues([1.,3.,4.])
1208 mcIdType tmpp1=-1,tmpp2=-1;
1209 std::vector<double> tmp=fillArrayWithPyListDbl2(li,tmpp1,tmpp2);
1210 self->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1214 throw INTERP_KERNEL::Exception(msg);
1217 PyObject *getValues() const
1219 const double *vals(self->begin());
1220 return convertDblArrToPyList<double>(vals,self->getNbOfElems());
1224 PyObject *toNumPyArray() // not const. It is not a bug !
1226 return ToNumPyArray<DataArrayDouble,double>(self,NPY_DOUBLE,"DataArrayDouble");
1230 PyObject *isEqualIfNotWhy(const DataArrayDouble& other, double prec) const
1233 bool ret0=self->isEqualIfNotWhy(other,prec,ret1);
1234 PyObject *ret=PyTuple_New(2);
1235 PyObject *ret0Py=ret0?Py_True:Py_False;
1237 PyTuple_SetItem(ret,0,ret0Py);
1238 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
1242 PyObject *getValuesAsTuple() const
1244 const double *vals(self->begin());
1245 std::size_t nbOfComp(self->getNumberOfComponents());
1246 mcIdType nbOfTuples(self->getNumberOfTuples());
1247 return convertDblArrToPyListOfTuple<double>(vals,nbOfComp,nbOfTuples);
1250 static PyObject *ComputeIntegralOfSeg2IntoTri3(PyObject *seg2, PyObject *tri3)
1252 const char msg[]="Python wrap of DataArrayDouble::ComputeIntegralOfSeg2IntoTri3 : ";
1254 DataArrayDouble *a,*a2;
1255 DataArrayDoubleTuple *aa,*aa2;
1256 std::vector<double> bb,bb2;
1258 const double *seg2Ptr(convertObjToPossibleCpp5_Safe(seg2,sw,val,a,aa,bb,msg,2,2,true));
1259 const double *tri3Ptr(convertObjToPossibleCpp5_Safe(tri3,sw,val2,a2,aa2,bb2,msg,3,2,true));
1261 double res0[3],res1;
1262 DataArrayDouble::ComputeIntegralOfSeg2IntoTri3(seg2Ptr,tri3Ptr,res0,res1);
1263 PyObject *ret(PyTuple_New(2)),*ret0(PyTuple_New(3));
1264 PyTuple_SetItem(ret0,0,PyFloat_FromDouble(res0[0]));
1265 PyTuple_SetItem(ret0,1,PyFloat_FromDouble(res0[1]));
1266 PyTuple_SetItem(ret0,2,PyFloat_FromDouble(res0[2]));
1267 PyTuple_SetItem(ret,0,ret0);
1268 PyTuple_SetItem(ret,1,PyFloat_FromDouble(res1));
1272 DataArrayDouble *symmetry3DPlane(PyObject *point, PyObject *normalVector)
1274 const char msg[]="Python wrap of DataArrayDouble::symmetry3DPlane : ";
1276 DataArrayDouble *a,*a2;
1277 DataArrayDoubleTuple *aa,*aa2;
1278 std::vector<double> bb,bb2;
1280 const double *centerPtr(convertObjToPossibleCpp5_Safe(point,sw,val,a,aa,bb,msg,1,3,true));
1281 const double *vectorPtr(convertObjToPossibleCpp5_Safe(normalVector,sw,val2,a2,aa2,bb2,msg,1,3,true));
1282 MCAuto<DataArrayDouble> ret(self->symmetry3DPlane(centerPtr,vectorPtr));
1286 static PyObject *GiveBaseForPlane(PyObject *normalVector)
1288 const char msg[]="Python wrap of DataArrayDouble::GiveBaseForPlane : ";
1291 DataArrayDoubleTuple *aa;
1292 std::vector<double> bb,bb2;
1294 const double *vectorPtr(convertObjToPossibleCpp5_Safe(normalVector,sw,val,a,aa,bb,msg,1,3,true));
1296 DataArrayDouble::GiveBaseForPlane(vectorPtr,res);
1297 return convertDblArrToPyListOfTuple<double>(res,3,3);
1300 DataArrayDouble *fromCartToCylGiven(const DataArrayDouble *coords, PyObject *center, PyObject *vector) const
1302 const char msg[]="Python wrap of DataArrayDouble::fromCartToCylGiven : ";
1304 DataArrayDouble *a,*a2;
1305 DataArrayDoubleTuple *aa,*aa2;
1306 std::vector<double> bb,bb2;
1308 const double *centerPtr=convertObjToPossibleCpp5_Safe(center,sw,val,a,aa,bb,msg,1,3,true);
1309 const double *vectorPtr=convertObjToPossibleCpp5_Safe(vector,sw,val2,a2,aa2,bb2,msg,1,3,true);
1310 return self->fromCartToCylGiven(coords,centerPtr,vectorPtr);
1313 DataArrayDouble *renumber(PyObject *li)
1316 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
1317 if (!SWIG_IsOK(res1))
1320 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1321 if(size!=self->getNumberOfTuples())
1323 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1325 return self->renumber(tmp);
1329 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1331 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1332 da2->checkAllocated();
1333 mcIdType size=self->getNumberOfTuples();
1334 if(size!=self->getNumberOfTuples())
1336 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1338 return self->renumber(da2->getConstPointer());
1342 DataArrayDouble *renumberR(PyObject *li)
1345 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
1346 if (!SWIG_IsOK(res1))
1349 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1350 if(size!=self->getNumberOfTuples())
1352 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1354 return self->renumberR(tmp);
1358 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1360 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1361 da2->checkAllocated();
1362 mcIdType size=self->getNumberOfTuples();
1363 if(size!=self->getNumberOfTuples())
1365 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1367 return self->renumberR(da2->getConstPointer());
1371 DataArrayDouble *renumberAndReduce(PyObject *li, mcIdType newNbOfTuple)
1374 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
1375 if (!SWIG_IsOK(res1))
1378 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1379 if(size!=self->getNumberOfTuples())
1381 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1383 return self->renumberAndReduce(tmp,newNbOfTuple);
1387 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1389 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1390 da2->checkAllocated();
1391 mcIdType size=self->getNumberOfTuples();
1392 if(size!=self->getNumberOfTuples())
1394 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1396 return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
1400 PyObject *minimalDistanceTo(const DataArrayDouble *other) const
1402 mcIdType thisTupleId,otherTupleId;
1403 double r0=self->minimalDistanceTo(other,thisTupleId,otherTupleId);
1404 PyObject *ret=PyTuple_New(3);
1405 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r0));
1406 PyTuple_SetItem(ret,1,PyInt_FromLong(thisTupleId));
1407 PyTuple_SetItem(ret,2,PyInt_FromLong(otherTupleId));
1411 PyObject *getMaxValue() const
1414 double r1=self->getMaxValue(tmp);
1415 PyObject *ret=PyTuple_New(2);
1416 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1417 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1421 PyObject *getMaxAbsValue() const
1424 double r1=self->getMaxAbsValue(tmp);
1425 PyObject *ret=PyTuple_New(2);
1426 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1427 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1431 PyObject *getMaxValue2() const
1433 DataArrayIdType *tmp;
1434 double r1=self->getMaxValue2(tmp);
1435 PyObject *ret=PyTuple_New(2);
1436 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1437 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1441 PyObject *getMinValue() const
1444 double r1=self->getMinValue(tmp);
1445 PyObject *ret=PyTuple_New(2);
1446 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1447 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1451 PyObject *getMinValue2() const
1453 DataArrayIdType *tmp;
1454 double r1=self->getMinValue2(tmp);
1455 PyObject *ret=PyTuple_New(2);
1456 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1457 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1461 PyObject *getMinMaxPerComponent() const
1463 std::size_t nbOfCompo(self->getNumberOfComponents());
1464 INTERP_KERNEL::AutoPtr<double> tmp(new double[2*nbOfCompo]);
1465 self->getMinMaxPerComponent(tmp);
1466 PyObject *ret=convertDblArrToPyListOfTuple<double>(tmp,2,ToIdType(nbOfCompo));
1470 PyObject *normMaxPerComponent() const
1472 std::size_t nbOfCompo(self->getNumberOfComponents());
1473 INTERP_KERNEL::AutoPtr<double> tmp(new double[nbOfCompo]);
1474 self->normMaxPerComponent(tmp);
1475 return convertDblArrToPyList<double>(tmp,ToIdType(nbOfCompo));
1478 PyObject *accumulate() const
1480 std::size_t sz=self->getNumberOfComponents();
1481 INTERP_KERNEL::AutoPtr<double> tmp=new double[sz];
1482 self->accumulate(tmp);
1483 return convertDblArrToPyList<double>(tmp,ToIdType(sz));
1486 DataArrayDouble *accumulatePerChunck(PyObject *indexArr) const
1488 mcIdType sw, sz,val;
1489 std::vector<mcIdType> val2;
1490 const mcIdType *bg=convertIntStarLikePyObjToCppIntStar(indexArr,sw,sz,val,val2);
1491 return self->accumulatePerChunck(bg,bg+sz);
1494 PyObject *findCommonTuples(double prec, mcIdType limitNodeId=-1) const
1496 DataArrayIdType *comm, *commIndex;
1497 self->findCommonTuples(prec,limitNodeId,comm,commIndex);
1498 PyObject *res = PyList_New(2);
1499 PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(comm),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1500 PyList_SetItem(res,1,SWIG_NewPointerObj(SWIG_as_voidptr(commIndex),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1504 PyObject *distanceToTuple(PyObject *tuple) const
1508 DataArrayDoubleTuple *aa;
1509 std::vector<double> bb;
1511 mcIdType tupleId=-1;
1512 std::size_t nbOfCompo=self->getNumberOfComponents();
1513 const double *pt=convertObjToPossibleCpp5_Safe(tuple,sw,val,a,aa,bb,"Python wrap of DataArrayDouble::distanceToTuple",1,(int)nbOfCompo,true);
1515 double ret0=self->distanceToTuple(pt,pt+nbOfCompo,tupleId);
1516 PyObject *ret=PyTuple_New(2);
1517 PyTuple_SetItem(ret,0,PyFloat_FromDouble(ret0));
1518 PyTuple_SetItem(ret,1,PyInt_FromLong(tupleId));
1522 void setSelectedComponents(const DataArrayDouble *a, PyObject *li)
1524 std::vector<std::size_t> tmp;
1525 convertPyToNewIntArr3(li,tmp);
1526 self->setSelectedComponents(a,tmp);
1529 PyObject *explodeComponents() const
1531 std::vector< MCAuto<DataArrayDouble> > retCpp(self->explodeComponents());
1532 std::size_t sz(retCpp.size());
1533 PyObject *res(PyList_New(sz));
1534 for(std::size_t i=0;i<sz;i++)
1535 PyList_SetItem(res,i,SWIG_NewPointerObj(SWIG_as_voidptr(retCpp[i].retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ));
1539 PyObject *getTuple(mcIdType tupleId)
1541 std::size_t sz=self->getNumberOfComponents();
1542 INTERP_KERNEL::AutoPtr<double> tmp=new double[sz];
1543 self->getTuple(tupleId,tmp);
1544 return convertDblArrToPyList<double>(tmp,ToIdType(sz));
1547 static DataArrayDouble *Aggregate(PyObject *li)
1549 std::vector<const DataArrayDouble *> tmp;
1550 convertFromPyObjVectorOfObj<const DataArrayDouble *>(li,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",tmp);
1551 return DataArrayDouble::Aggregate(tmp);
1554 static DataArrayDouble *Meld(PyObject *li)
1556 std::vector<const DataArrayDouble *> tmp;
1557 convertFromPyObjVectorOfObj<const DataArrayDouble *>(li,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",tmp);
1558 return DataArrayDouble::Meld(tmp);
1561 PyObject *computeTupleIdsNearTuples(PyObject *pt, double eps) const
1565 DataArrayDoubleTuple *aa;
1566 std::vector<double> bb;
1568 std::size_t nbComp=self->getNumberOfComponents();
1569 mcIdType nbTuples=-1;
1570 const char msg[]="Python wrap of DataArrayDouble::computeTupleIdsNearTuples : ";
1571 const double *pos=convertObjToPossibleCpp5_Safe2(pt,sw,val,a,aa,bb,msg,(int)nbComp,true,nbTuples);
1572 MCAuto<DataArrayDouble> inpu=DataArrayDouble::New(); inpu->useArray(pos,false,DeallocType::CPP_DEALLOC,nbTuples,nbComp);
1573 DataArrayIdType *c=0,*cI=0;
1574 self->computeTupleIdsNearTuples(inpu,eps,c,cI);
1575 PyObject *ret=PyTuple_New(2);
1576 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1577 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1581 PyObject *areIncludedInMe(const DataArrayDouble *other, double prec) const
1583 DataArrayIdType *ret1=0;
1584 bool ret0=self->areIncludedInMe(other,prec,ret1);
1585 PyObject *ret=PyTuple_New(2);
1586 PyObject *ret0Py=ret0?Py_True:Py_False;
1588 PyTuple_SetItem(ret,0,ret0Py);
1589 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1593 PyObject *__getitem__(PyObject *obj)
1595 return DataArrayT__getitem<double>(self,obj);
1598 DataArrayDouble *__setitem__(PyObject *obj, PyObject *value)
1600 return DataArrayT__setitem__<double>(self,obj,value);
1603 DataArrayDouble *__neg__() const
1605 return self->negate();
1608 PyObject *__add__(PyObject *obj)
1610 const char msg[]="Unexpected situation in DataArrayDouble.__add__ !";
1613 DataArrayDoubleTuple *aa;
1614 std::vector<double> bb;
1617 #ifndef WITHOUT_AUTOFIELD
1619 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1621 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1624 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1625 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___radd__Impl(other,tmp);
1627 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1630 throw INTERP_KERNEL::Exception(msg);
1634 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1639 MCAuto<DataArrayDouble> ret=self->deepCopy();
1640 ret->applyLin(1.,val);
1641 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1645 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1649 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1650 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1654 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1655 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1658 throw INTERP_KERNEL::Exception(msg);
1662 DataArrayDouble *__radd__(PyObject *obj)
1664 const char msg[]="Unexpected situation in __radd__ !";
1667 DataArrayDoubleTuple *aa;
1668 std::vector<double> bb;
1670 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1675 MCAuto<DataArrayDouble> ret=self->deepCopy();
1676 ret->applyLin(1.,val);
1681 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1682 return DataArrayDouble::Add(self,aaa);
1686 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1687 return DataArrayDouble::Add(self,aaa);
1690 throw INTERP_KERNEL::Exception(msg);
1694 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
1696 return DataArrayT_iadd<double>(trueSelf,obj,self);
1699 PyObject *__sub__(PyObject *obj)
1701 const char msg[]="Unexpected situation in __sub__ !";
1704 DataArrayDoubleTuple *aa;
1705 std::vector<double> bb;
1708 #ifndef WITHOUT_AUTOFIELD
1710 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1712 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1715 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1716 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rsub__Impl(other,tmp);
1718 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1721 throw INTERP_KERNEL::Exception(msg);
1725 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1730 MCAuto<DataArrayDouble> ret=self->deepCopy();
1731 ret->applyLin(1.,-val);
1732 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1736 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1740 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1741 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1745 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1746 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1749 throw INTERP_KERNEL::Exception(msg);
1753 DataArrayDouble *__rsub__(PyObject *obj)
1755 const char msg[]="Unexpected situation in __rsub__ !";
1758 DataArrayDoubleTuple *aa;
1759 std::vector<double> bb;
1761 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1766 MCAuto<DataArrayDouble> ret=self->deepCopy();
1767 ret->applyLin(-1.,val);
1772 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1773 return DataArrayDouble::Substract(aaa,self);
1777 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1778 return DataArrayDouble::Substract(aaa,self);
1781 throw INTERP_KERNEL::Exception(msg);
1785 PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
1787 return DataArrayT_isub<double>(trueSelf,obj,self);
1790 PyObject *__mul__(PyObject *obj)
1792 const char msg[]="Unexpected situation in __mul__ !";
1795 DataArrayDoubleTuple *aa;
1796 std::vector<double> bb;
1799 #ifndef WITHOUT_AUTOFIELD
1801 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1803 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1806 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1807 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rmul__Impl(other,tmp);
1809 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1812 throw INTERP_KERNEL::Exception(msg);
1816 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1821 MCAuto<DataArrayDouble> ret=self->deepCopy();
1822 ret->applyLin(val,0.);
1823 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1827 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1831 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1832 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1836 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1837 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1840 throw INTERP_KERNEL::Exception(msg);
1844 DataArrayDouble *__rmul__(PyObject *obj)
1846 return DataArrayFPT_rmul<double>(self,obj);
1849 PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
1851 return DataArrayT_imul<double>(trueSelf,obj,self);
1854 PyObject *__div__(PyObject *obj)
1856 const char msg[]="Unexpected situation in __div__ !";
1859 DataArrayDoubleTuple *aa;
1860 std::vector<double> bb;
1863 #ifndef WITHOUT_AUTOFIELD
1865 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1867 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1870 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1871 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rdiv__Impl(other,tmp);
1873 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1876 throw INTERP_KERNEL::Exception(msg);
1880 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1886 throw INTERP_KERNEL::Exception("DataArrayDouble::__div__ : trying to divide by zero !");
1887 MCAuto<DataArrayDouble> ret=self->deepCopy();
1888 ret->applyLin(1/val,0.);
1889 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1893 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1897 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1898 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1902 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1903 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1906 throw INTERP_KERNEL::Exception(msg);
1910 DataArrayDouble *__rdiv__(PyObject *obj)
1912 const char msg[]="Unexpected situation in __rdiv__ !";
1915 DataArrayDoubleTuple *aa;
1916 std::vector<double> bb;
1918 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1923 MCAuto<DataArrayDouble> ret=self->deepCopy();
1929 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1930 return DataArrayDouble::Divide(aaa,self);
1934 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1935 return DataArrayDouble::Divide(aaa,self);
1938 throw INTERP_KERNEL::Exception(msg);
1942 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
1944 return DataArrayT_idiv<double>(trueSelf,obj,self);
1947 DataArrayDouble *__pow__(PyObject *obj)
1949 const char msg[]="Unexpected situation in __pow__ !";
1952 DataArrayDoubleTuple *aa;
1953 std::vector<double> bb;
1955 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1960 MCAuto<DataArrayDouble> ret=self->deepCopy();
1966 return DataArrayDouble::Pow(self,a);
1970 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1971 return DataArrayDouble::Pow(self,aaa);
1975 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1976 return DataArrayDouble::Pow(self,aaa);
1979 throw INTERP_KERNEL::Exception(msg);
1983 DataArrayDouble *__rpow__(PyObject *obj)
1985 const char msg[]="Unexpected situation in __rpow__ !";
1988 DataArrayDoubleTuple *aa;
1989 std::vector<double> bb;
1991 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1996 MCAuto<DataArrayDouble> ret=self->deepCopy();
1997 ret->applyRPow(val);
2002 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
2003 return DataArrayDouble::Pow(aaa,self);
2007 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
2008 return DataArrayDouble::Pow(aaa,self);
2011 throw INTERP_KERNEL::Exception(msg);
2015 PyObject *___ipow___(PyObject *trueSelf, PyObject *obj)
2017 const char msg[]="Unexpected situation in __ipow__ !";
2020 DataArrayDoubleTuple *aa;
2021 std::vector<double> bb;
2023 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
2028 self->applyPow(val);
2029 Py_XINCREF(trueSelf);
2035 Py_XINCREF(trueSelf);
2040 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
2041 self->powEqual(aaa);
2042 Py_XINCREF(trueSelf);
2047 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
2048 self->powEqual(aaa);
2049 Py_XINCREF(trueSelf);
2053 throw INTERP_KERNEL::Exception(msg);
2057 PyObject *computeTupleIdsNearTuples(const DataArrayDouble *other, double eps)
2059 DataArrayIdType *c=0,*cI=0;
2061 self->computeTupleIdsNearTuples(other,eps,c,cI);
2062 PyObject *ret=PyTuple_New(2);
2063 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2064 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2068 PyObject *maxPerTupleWithCompoId() const
2070 DataArrayIdType *ret1=0;
2071 DataArrayDouble *ret0=self->maxPerTupleWithCompoId(ret1);
2072 PyObject *ret=PyTuple_New(2);
2073 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ));
2074 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2080 class DataArrayDoubleTuple;
2082 class DataArrayDoubleIterator
2085 DataArrayDoubleIterator(DataArrayDouble *da);
2086 ~DataArrayDoubleIterator();
2091 DataArrayDoubleTuple *ret=self->nextt();
2093 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayDoubleTuple,SWIG_POINTER_OWN|0);
2096 PyErr_SetString(PyExc_StopIteration,"No more data.");
2103 class DataArrayDoubleTuple
2106 std::size_t getNumberOfCompo() const;
2107 DataArrayDouble *buildDADouble(int nbOfTuples, int nbOfCompo) const;
2110 std::string __str__() const
2112 return self->repr();
2115 double __float__() const
2117 return self->doubleValue();
2120 DataArrayDouble *buildDADouble()
2122 return self->buildDADouble(1,self->getNumberOfCompo());
2125 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
2127 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2128 MEDCoupling_DataArrayDouble____iadd___(ret,0,obj);
2129 Py_XINCREF(trueSelf);
2133 PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
2135 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2136 MEDCoupling_DataArrayDouble____isub___(ret,0,obj);
2137 Py_XINCREF(trueSelf);
2141 PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
2143 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2144 MEDCoupling_DataArrayDouble____imul___(ret,0,obj);
2145 Py_XINCREF(trueSelf);
2149 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
2151 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2152 MEDCoupling_DataArrayDouble____idiv___(ret,0,obj);
2153 Py_XINCREF(trueSelf);
2159 return PyInt_FromLong(self->getNumberOfCompo());
2162 PyObject *__getitem__(PyObject *obj)
2164 const char msg2[]="DataArrayDoubleTuple::__getitem__ : Mismatch of slice values in 2nd parameter (components) !";
2167 std::vector<mcIdType> multiVal;
2168 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2169 MEDCoupling::DataArrayIdType *daIntTyypp=0;
2170 const double *pt=self->getConstPointer();
2171 mcIdType nbc=ToIdType(self->getNumberOfCompo());
2172 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbc,sw,singleVal,multiVal,slic,daIntTyypp);
2179 std::ostringstream oss;
2180 oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2181 PyErr_SetString(PyExc_StopIteration,oss.str().c_str());
2185 return PyFloat_FromDouble(pt[singleVal]);
2189 return PyFloat_FromDouble(pt[nbc+singleVal]);
2192 std::ostringstream oss;
2193 oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2194 throw INTERP_KERNEL::Exception(oss.str().c_str());
2200 PyObject *t=PyTuple_New(multiVal.size());
2201 for(std::size_t j=0;j<multiVal.size();j++)
2203 mcIdType cid=multiVal[j];
2206 std::ostringstream oss;
2207 oss << "Requesting for id #" << cid << " having only " << nbc << " components !";
2208 throw INTERP_KERNEL::Exception(oss.str().c_str());
2210 PyTuple_SetItem(t,j,PyFloat_FromDouble(pt[cid]));
2216 mcIdType sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2217 PyObject *t=PyTuple_New(sz);
2218 for(mcIdType j=0;j<sz;j++)
2219 PyTuple_SetItem(t,j,PyFloat_FromDouble(pt[slic.first+j*slic.second.second]));
2223 throw INTERP_KERNEL::Exception("DataArrayDoubleTuple::__getitem__ : unrecognized type entered !");
2227 DataArrayDoubleTuple *__setitem__(PyObject *obj, PyObject *value)
2229 const char msg[]="DataArrayDoubleTuple::__setitem__ : unrecognized type entered, int, slice, list<int>, tuple<int> !";
2230 const char msg2[]="DataArrayDoubleTuple::__setitem__ : Mismatch of slice values in 2nd parameter (components) !";
2233 std::vector<double> multiValV;
2234 MEDCoupling::DataArrayDoubleTuple *daIntTyyppV=0;
2235 mcIdType nbc=ToIdType(self->getNumberOfCompo());
2236 convertDoubleStarLikePyObjToCpp(value,sw1,singleValV,multiValV,daIntTyyppV);
2238 std::vector<mcIdType> multiVal;
2239 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2240 MEDCoupling::DataArrayIdType *daIntTyypp=0;
2241 double *pt=self->getPointer();
2242 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbc,sw2,singleVal,multiVal,slic,daIntTyypp);
2249 std::ostringstream oss;
2250 oss << "Requesting for setting id # " << singleVal << " having only " << nbc << " components !";
2251 throw INTERP_KERNEL::Exception(oss.str().c_str());
2257 pt[singleVal]=singleValV;
2262 if(multiValV.size()!=1)
2264 std::ostringstream oss;
2265 oss << "Requesting for setting id # " << singleVal << " with a list or tuple with size != 1 ! ";
2266 throw INTERP_KERNEL::Exception(oss.str().c_str());
2268 pt[singleVal]=multiValV[0];
2273 pt[singleVal]=daIntTyyppV->getConstPointer()[0];
2277 throw INTERP_KERNEL::Exception(msg);
2286 for(std::vector<mcIdType>::const_iterator it=multiVal.begin();it!=multiVal.end();it++)
2290 std::ostringstream oss;
2291 oss << "Requesting for setting id # " << *it << " having only " << nbc << " components !";
2292 throw INTERP_KERNEL::Exception(oss.str().c_str());
2300 if(multiVal.size()!=multiValV.size())
2302 std::ostringstream oss;
2303 oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << multiVal.size() << " !";
2304 throw INTERP_KERNEL::Exception(oss.str().c_str());
2306 for(std::size_t i=0;i<multiVal.size();i++)
2308 mcIdType pos=multiVal[i];
2311 std::ostringstream oss;
2312 oss << "Requesting for setting id # " << pos << " having only " << nbc << " components !";
2313 throw INTERP_KERNEL::Exception(oss.str().c_str());
2315 pt[multiVal[i]]=multiValV[i];
2321 const double *ptV=daIntTyyppV->getConstPointer();
2322 if(nbc>(mcIdType)daIntTyyppV->getNumberOfCompo())
2324 std::ostringstream oss;
2325 oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2326 throw INTERP_KERNEL::Exception(oss.str().c_str());
2328 std::copy(ptV,ptV+nbc,pt);
2332 throw INTERP_KERNEL::Exception(msg);
2337 mcIdType sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2342 for(mcIdType j=0;j<sz;j++)
2343 pt[slic.first+j*slic.second.second]=singleValV;
2348 if(sz!=(mcIdType)multiValV.size())
2350 std::ostringstream oss;
2351 oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << sz << " !";
2352 throw INTERP_KERNEL::Exception(oss.str().c_str());
2354 for(mcIdType j=0;j<sz;j++)
2355 pt[slic.first+j*slic.second.second]=multiValV[j];
2360 const double *ptV=daIntTyyppV->getConstPointer();
2361 if(sz>(mcIdType)daIntTyyppV->getNumberOfCompo())
2363 std::ostringstream oss;
2364 oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2365 throw INTERP_KERNEL::Exception(oss.str().c_str());
2367 for(mcIdType j=0;j<sz;j++)
2368 pt[slic.first+j*slic.second.second]=ptV[j];
2372 throw INTERP_KERNEL::Exception(msg);
2376 throw INTERP_KERNEL::Exception(msg);
2382 class DataArrayChar : public DataArray
2385 virtual DataArrayChar *buildEmptySpecializedDAChar() const;
2386 int getHashCode() const;
2388 void deepCopyFrom(const DataArrayChar& other);
2389 void reserve(std::size_t nbOfElems);
2390 void pushBackSilent(char val);
2391 char popBackSilent();
2393 void allocIfNecessary(int nbOfTuple, int nbOfCompo);
2394 bool isEqual(const DataArrayChar& other) const;
2395 bool isEqualWithoutConsideringStr(const DataArrayChar& other) const;
2397 void fillWithZero();
2398 void fillWithValue(char val);
2399 std::string repr() const;
2400 std::string reprZip() const;
2401 DataArrayInt *convertToIntArr() const;
2402 DataArrayChar *renumber(const mcIdType *old2New) const;
2403 DataArrayChar *renumberR(const mcIdType *new2Old) const;
2404 DataArrayChar *renumberAndReduce(const mcIdType *old2NewBg, mcIdType newNbOfTuple) const;
2405 bool isUniform(char val) const;
2406 void sort(bool asc=true);
2407 DataArrayChar *subArray(mcIdType tupleIdBg, mcIdType tupleIdEnd=-1) const;
2408 DataArrayChar *changeNbOfComponents(std::size_t newNbOfComp, char dftValue) const;
2409 void meldWith(const DataArrayChar *other);
2410 void setPartOfValuesAdv(const DataArrayChar *a, const DataArrayIdType *tuplesSelec);
2413 void setIJ(mcIdType tupleId, int compoId, char newVal);
2414 void setIJSilent(mcIdType tupleId, int compoId, char newVal);
2416 DataArrayIdType *findIdsEqual(char val) const;
2417 DataArrayIdType *findIdsNotEqual(char val) const;
2418 int findIdFirstEqualTuple(const std::vector<char>& tupl) const;
2419 bool presenceOfTuple(const std::vector<char>& tupl) const;
2420 char getMaxValue(mcIdType& tupleId) const;
2421 char getMaxValueInArray() const;
2422 char getMinValue(mcIdType& tupleId) const;
2423 char getMinValueInArray() const;
2424 DataArrayIdType *findIdsInRange(char vmin, char vmax) const;
2425 static DataArrayChar *Aggregate(const DataArrayChar *a1, const DataArrayChar *a2);
2426 static DataArrayChar *Meld(const DataArrayChar *a1, const DataArrayChar *a2);
2429 mcIdType __len__() const
2431 if(self->isAllocated())
2433 return self->getNumberOfTuples();
2437 throw INTERP_KERNEL::Exception("DataArrayChar::__len__ : Instance is NOT allocated !");
2441 PyObject *isEqualIfNotWhy(const DataArrayChar& other) const
2444 bool ret0=self->isEqualIfNotWhy(other,ret1);
2445 PyObject *ret=PyTuple_New(2);
2446 PyObject *ret0Py=ret0?Py_True:Py_False;
2448 PyTuple_SetItem(ret,0,ret0Py);
2449 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
2453 DataArrayChar *renumber(PyObject *li)
2456 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
2457 if (!SWIG_IsOK(res1))
2460 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2461 if(size!=self->getNumberOfTuples())
2463 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2465 return self->renumber(tmp);
2469 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2471 throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2472 da2->checkAllocated();
2473 mcIdType size=self->getNumberOfTuples();
2474 if(size!=self->getNumberOfTuples())
2476 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2478 return self->renumber(da2->getConstPointer());
2482 DataArrayChar *renumberR(PyObject *li)
2485 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
2486 if (!SWIG_IsOK(res1))
2489 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2490 if(size!=self->getNumberOfTuples())
2492 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2494 return self->renumberR(tmp);
2498 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2500 throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2501 da2->checkAllocated();
2502 mcIdType size=self->getNumberOfTuples();
2503 if(size!=self->getNumberOfTuples())
2505 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2507 return self->renumberR(da2->getConstPointer());
2511 DataArrayChar *renumberAndReduce(PyObject *li, mcIdType newNbOfTuple)
2514 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
2515 if (!SWIG_IsOK(res1))
2518 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2519 if(size!=self->getNumberOfTuples())
2521 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2523 return self->renumberAndReduce(tmp,newNbOfTuple);
2527 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2529 throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2530 da2->checkAllocated();
2531 mcIdType size=self->getNumberOfTuples();
2532 if(size!=self->getNumberOfTuples())
2534 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2536 return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
2540 static DataArrayChar *Aggregate(PyObject *dachs)
2542 std::vector<const MEDCoupling::DataArrayChar *> tmp;
2543 convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayChar *>(dachs,SWIGTYPE_p_MEDCoupling__DataArrayChar,"DataArrayChar",tmp);
2544 return DataArrayChar::Aggregate(tmp);
2547 static DataArrayChar *Meld(PyObject *dachs)
2549 std::vector<const MEDCoupling::DataArrayChar *> tmp;
2550 convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayChar *>(dachs,SWIGTYPE_p_MEDCoupling__DataArrayChar,"DataArrayChar",tmp);
2551 return DataArrayChar::Meld(tmp);
2556 class DataArrayByteIterator;
2558 class DataArrayByte : public DataArrayChar
2561 static DataArrayByte *New();
2562 DataArrayByteIterator *iterator();
2563 DataArrayByte *performCopyOrIncrRef(bool deepCopy) const;
2564 char byteValue() const;
2569 return DataArrayByte::New();
2572 static DataArrayByte *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
2574 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) !";
2575 if(PyList_Check(elt0) || PyTuple_Check(elt0))
2579 if(PyInt_Check(nbOfTuples))
2581 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
2583 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive set of allocated memory !");
2586 if(PyInt_Check(nbOfComp))
2587 {//DataArrayByte.New([1,3,4,5],2,2)
2588 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
2590 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !");
2591 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2592 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
2593 ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2597 throw INTERP_KERNEL::Exception(msg);
2600 {//DataArrayByte.New([1,3,4],3)
2601 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2603 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
2604 ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2609 throw INTERP_KERNEL::Exception(msg);
2612 {// DataArrayByte.New([1,3,4])
2613 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2614 mcIdType tmpp1=-1,tmpp2=-1;
2615 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
2616 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2620 else if(PyInt_Check(elt0))
2622 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(elt0));
2624 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive set of allocated memory !");
2629 if(PyInt_Check(nbOfTuples))
2630 {//DataArrayByte.New(5,2)
2631 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfTuples));
2633 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !");
2634 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2635 ret->alloc(nbOfTuples1,nbOfCompo);
2639 throw INTERP_KERNEL::Exception(msg);
2642 throw INTERP_KERNEL::Exception(msg);
2645 {//DataArrayByte.New(5)
2646 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2647 ret->alloc(nbOfTuples1,1);
2652 else if(PyArray_Check(elt0) && nbOfTuples==NULL && nbOfComp==NULL)
2653 {//DataArrayDouble.New(numpyArray)
2654 return BuildNewInstance<DataArrayByte,char>(elt0,NPY_INT8,&PyCallBackDataArrayChar_RefType,"INT8");
2658 throw INTERP_KERNEL::Exception(msg);
2661 DataArrayByte(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
2663 return MEDCoupling_DataArrayByte_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
2666 std::string __repr__() const
2668 std::ostringstream oss;
2669 self->reprQuickOverview(oss);
2675 return (int) self->byteValue();
2678 DataArrayByteIterator *__iter__()
2680 return self->iterator();
2683 mcIdType getIJ(mcIdType tupleId, mcIdType compoId) const
2685 return (mcIdType)self->getIJ(tupleId,compoId);
2688 mcIdType getIJSafe(mcIdType tupleId, mcIdType compoId) const
2690 return (mcIdType)self->getIJSafe(tupleId,compoId);
2693 std::string __str__() const
2695 return self->repr();
2698 PyObject *toStrList() const
2700 const char *vals=self->getConstPointer();
2701 std::size_t nbOfComp=self->getNumberOfComponents();
2702 mcIdType nbOfTuples=self->getNumberOfTuples();
2703 return convertCharArrToPyListOfTuple(vals,(int)nbOfComp,nbOfTuples);
2706 bool presenceOfTuple(PyObject *tupl) const
2708 mcIdType sz=-1,sw=-1;
2709 mcIdType ival=-1; std::vector<mcIdType> ivval;
2710 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(tupl,sw,sz,ival,ivval);
2711 std::vector<char> vals(sz);
2712 std::copy(pt,pt+sz,vals.begin());
2713 return self->presenceOfTuple(vals);
2716 bool presenceOfValue(PyObject *vals) const
2718 mcIdType sz=-1,sw=-1;
2719 mcIdType ival=-1; std::vector<mcIdType> ivval;
2720 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(vals,sw,sz,ival,ivval);
2721 std::vector<char> vals2(sz);
2722 std::copy(pt,pt+sz,vals2.begin());
2723 return self->presenceOfValue(vals2);
2726 mcIdType findIdFirstEqual(PyObject *vals) const
2728 mcIdType sz=-1,sw=-1;
2729 mcIdType ival=-1; std::vector<mcIdType> ivval;
2730 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(vals,sw,sz,ival,ivval);
2731 std::vector<char> vals2(sz);
2732 std::copy(pt,pt+sz,vals2.begin());
2733 return self->findIdFirstEqual(vals2);
2736 mcIdType findIdFirstEqualTuple(PyObject *tupl) const
2738 mcIdType sz=-1,sw=-1;
2739 mcIdType ival=-1; std::vector<mcIdType> ivval;
2740 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(tupl,sw,sz,ival,ivval);
2741 std::vector<char> vals(sz);
2742 std::copy(pt,pt+sz,vals.begin());
2743 return self->findIdFirstEqualTuple(vals);
2746 mcIdType findIdSequence(PyObject *strOrListOfInt) const
2748 mcIdType sz=-1,sw=-1;
2749 mcIdType ival=-1; std::vector<mcIdType> ivval;
2750 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(strOrListOfInt,sw,sz,ival,ivval);
2751 std::vector<char> vals(sz);
2752 std::copy(pt,pt+sz,vals.begin());
2753 return self->findIdSequence(vals);
2756 PyObject *getTuple(mcIdType tupleId)
2758 std::size_t sz=self->getNumberOfComponents();
2759 INTERP_KERNEL::AutoPtr<char> tmp=new char[sz];
2760 self->getTuple(tupleId,tmp);
2761 PyObject *ret=PyTuple_New(sz);
2762 for(std::size_t i=0;i<sz;i++) PyTuple_SetItem(ret,i,PyInt_FromLong((mcIdType)tmp[i]));
2766 PyObject *getMaxValue() const
2769 mcIdType r1=(mcIdType)self->getMaxValue(tmp);
2770 PyObject *ret=PyTuple_New(2);
2771 PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
2772 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
2776 PyObject *getMinValue() const
2779 mcIdType r1=(mcIdType)self->getMinValue(tmp);
2780 PyObject *ret=PyTuple_New(2);
2781 PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
2782 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
2786 mcIdType index(PyObject *obj) const
2788 std::size_t nbOfCompo=self->getNumberOfComponents();
2793 if(PyInt_Check(obj))
2795 char val=(char)PyInt_AS_LONG(obj);
2796 return self->findIdFirstEqual(val);
2799 throw INTERP_KERNEL::Exception("DataArrayByte::index : 'this' contains one component and trying to find an element which is not an integer !");
2802 return MEDCoupling_DataArrayByte_findIdFirstEqualTuple(self,obj);
2806 bool __contains__(PyObject *obj) const
2808 std::size_t nbOfCompo=self->getNumberOfComponents();
2815 if(PyInt_Check(obj))
2817 char val=(char)PyInt_AS_LONG(obj);
2818 return self->presenceOfValue(val);
2821 throw INTERP_KERNEL::Exception("DataArrayByte::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
2824 return MEDCoupling_DataArrayByte_presenceOfTuple(self,obj);
2829 PyObject *toNumPyArray() // not const. It is not a bug !
2831 return ToNumPyArray<DataArrayByte,char>(self,NPY_INT8,"DataArrayByte");
2835 DataArrayByte *__setitem__(PyObject *obj, PyObject *value)
2837 self->checkAllocated();
2838 const char msg[]="Unexpected situation in __setitem__ !";
2839 mcIdType nbOfTuples(self->getNumberOfTuples());
2840 int nbOfComponents((int)self->getNumberOfComponents());
2843 std::vector<int> v1;
2844 DataArrayIdType *d1=0;
2845 DataArrayIntTuple *dd1=0;
2846 convertIntStarLikePyObjToCpp(value,sw1,int1,v1,d1,dd1);
2848 std::vector<mcIdType> vt1,vc1;
2849 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > pt1,pc1;
2850 DataArrayIdType *dt1=0,*dc1=0;
2851 convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw2,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1);
2852 MCAuto<DataArrayIdType> tmp;
2853 char i1 = (char)int1;
2861 self->setPartOfValuesSimple1(i1,it1,it1+1,1,0,nbOfComponents,1);
2864 throw INTERP_KERNEL::Exception(msg);
2873 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1);
2876 throw INTERP_KERNEL::Exception(msg);
2885 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1);
2888 throw INTERP_KERNEL::Exception(msg);
2897 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1);
2900 throw INTERP_KERNEL::Exception(msg);
2909 self->setPartOfValuesSimple1(i1,it1,it1+1,1,ic1,ic1+1,1);
2912 throw INTERP_KERNEL::Exception(msg);
2921 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1);
2924 throw INTERP_KERNEL::Exception(msg);
2933 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1);
2936 throw INTERP_KERNEL::Exception(msg);
2945 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1);
2948 throw INTERP_KERNEL::Exception(msg);
2957 self->setPartOfValuesSimple2(i1,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size());
2960 throw INTERP_KERNEL::Exception(msg);
2969 self->setPartOfValuesSimple2(i1,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size());
2972 throw INTERP_KERNEL::Exception(msg);
2981 self->setPartOfValuesSimple4(i1,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size());
2984 throw INTERP_KERNEL::Exception(msg);
2993 self->setPartOfValuesSimple2(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size());
2996 throw INTERP_KERNEL::Exception(msg);
3005 self->setPartOfValuesSimple1(i1,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second);
3008 throw INTERP_KERNEL::Exception(msg);
3017 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second);
3020 throw INTERP_KERNEL::Exception(msg);
3029 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second);
3032 throw INTERP_KERNEL::Exception(msg);
3041 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second);
3044 throw INTERP_KERNEL::Exception(msg);
3049 throw INTERP_KERNEL::Exception(msg);
3056 class DataArrayByteTuple;
3058 class DataArrayByteIterator
3061 DataArrayByteIterator(DataArrayByte *da);
3062 ~DataArrayByteIterator();
3065 class DataArrayByteTuple
3068 std::string repr() const;
3069 DataArrayByte *buildDAByte(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
3072 std::string __str__() const
3074 return self->repr();
3077 char __int__() const
3079 return self->byteValue();
3082 DataArrayByte *buildDAByte()
3084 return self->buildDAByte(1,self->getNumberOfCompo());
3089 class DataArrayAsciiCharIterator;
3091 class DataArrayAsciiChar : public DataArrayChar
3094 static DataArrayAsciiChar *New();
3095 DataArrayAsciiCharIterator *iterator();
3096 DataArrayAsciiChar *performCopyOrIncrRef(bool deepCopy) const;
3097 char asciiCharValue() const;
3100 DataArrayAsciiChar()
3102 return DataArrayAsciiChar::New();
3105 static DataArrayAsciiChar *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
3107 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) !";
3108 if(PyList_Check(elt0) || PyTuple_Check(elt0))
3112 if(PyInt_Check(nbOfTuples))
3114 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
3116 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive set of allocated memory !");
3119 if(PyInt_Check(nbOfComp))
3120 {//DataArrayAsciiChar.New([1,3,4,5],2,2)
3121 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
3123 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !");
3124 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3125 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
3126 ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3130 throw INTERP_KERNEL::Exception(msg);
3133 {//DataArrayAsciiChar.New([1,3,4],3)
3134 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3136 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
3137 ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3141 else if(PyString_Check(nbOfTuples))
3143 if(PyString_Size(nbOfTuples)!=1)
3144 throw INTERP_KERNEL::Exception(msg);
3145 //DataArrayAsciiChar.New(["abc","de","fghi"],"t")
3146 std::vector<std::string> tmp;
3147 if(fillStringVector(elt0,tmp))
3148 return DataArrayAsciiChar::New(tmp,PyString_AsString(nbOfTuples)[0]);
3150 throw INTERP_KERNEL::Exception(msg);
3152 %#if PY_VERSION_HEX >= 0x03000000
3153 else if(PyUnicode_Check(nbOfTuples))
3155 if(PyUnicode_GET_LENGTH(nbOfTuples)!=1)
3156 throw INTERP_KERNEL::Exception(msg);
3157 //DataArrayAsciiChar.New(["abc","de","fghi"],"t")
3158 std::vector<std::string> tmp;
3159 if(fillStringVector(elt0,tmp))
3160 return DataArrayAsciiChar::New(tmp,PyUnicode_AsUTF8(nbOfTuples)[0]);
3162 throw INTERP_KERNEL::Exception(msg);
3166 throw INTERP_KERNEL::Exception(msg);
3170 std::vector<std::string> tmmp;
3171 if(fillStringVector(elt0,tmmp))
3172 //DataArrayAsciiChar.New(["abc","de","fghi"])
3173 return DataArrayAsciiChar::New(tmmp,' ');
3176 // DataArrayAsciiChar.New([1,3,4])
3177 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3178 mcIdType tmpp1=-1,tmpp2=-1;
3179 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
3180 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3185 else if(PyInt_Check(elt0))
3187 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(elt0));
3189 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive set of allocated memory !");
3194 if(PyInt_Check(nbOfTuples))
3195 {//DataArrayAsciiChar.New(5,2)
3196 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfTuples));
3198 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !");
3199 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3200 ret->alloc(nbOfTuples1,nbOfCompo);
3204 throw INTERP_KERNEL::Exception(msg);
3207 throw INTERP_KERNEL::Exception(msg);
3210 {//DataArrayAsciiChar.New(5)
3211 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3212 ret->alloc(nbOfTuples1,1);
3217 throw INTERP_KERNEL::Exception(msg);
3220 DataArrayAsciiChar(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
3222 return MEDCoupling_DataArrayAsciiChar_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
3225 std::string __repr__() const
3227 std::ostringstream oss;
3228 self->reprQuickOverview(oss);
3232 DataArrayAsciiCharIterator *__iter__()
3234 return self->iterator();
3237 std::string getIJ(mcIdType tupleId, mcIdType compoId) const
3239 char tmp[2]; tmp[1]='\0';
3240 tmp[0]=self->getIJ(tupleId,compoId);
3241 return std::string(tmp);
3244 std::string getIJSafe(mcIdType tupleId, mcIdType compoId) const
3246 char tmp[2]; tmp[1]='\0';
3247 tmp[0]=self->getIJSafe(tupleId,compoId);
3248 return std::string(tmp);
3251 std::string __str__() const
3253 return self->repr();
3256 PyObject *toStrList() const
3258 const char *vals=self->getConstPointer();
3259 std::size_t nbOfComp=self->getNumberOfComponents();
3260 mcIdType nbOfTuples=self->getNumberOfTuples();
3261 return convertCharArrToPyListOfTuple(vals,(int)nbOfComp,nbOfTuples);
3264 bool presenceOfTuple(PyObject *tupl) const
3266 if(PyString_Check(tupl))
3268 Py_ssize_t sz=PyString_Size(tupl);
3269 std::vector<char> vals(sz);
3270 std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin());
3271 return self->presenceOfTuple(vals);
3273 %#if PY_VERSION_HEX >= 0x03000000
3274 else if(PyUnicode_Check(tupl))
3276 Py_ssize_t sz=PyUnicode_GET_LENGTH(tupl);
3277 std::vector<char> vals(sz);
3278 std::copy(PyUnicode_AsUTF8(tupl),PyUnicode_AsUTF8(tupl)+sz,vals.begin());
3279 return self->presenceOfTuple(vals);
3283 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfTuple : only strings in input supported !");
3286 bool presenceOfValue(PyObject *vals) const
3288 if(PyString_Check(vals))
3290 Py_ssize_t sz=PyString_Size(vals);
3291 std::vector<char> vals2(sz);
3292 std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin());
3293 return self->presenceOfValue(vals2);
3295 %#if PY_VERSION_HEX >= 0x03000000
3296 if(PyUnicode_Check(vals))
3298 Py_ssize_t sz=PyUnicode_GET_LENGTH(vals);
3299 std::vector<char> vals2(sz);
3300 std::copy(PyUnicode_AsUTF8(vals),PyUnicode_AsUTF8(vals)+sz,vals2.begin());
3301 return self->presenceOfValue(vals2);
3305 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfValue : only strings in input supported !");
3308 mcIdType findIdFirstEqual(PyObject *vals) const
3310 if(PyString_Check(vals))
3312 Py_ssize_t sz=PyString_Size(vals);
3313 std::vector<char> vals2(sz);
3314 std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin());
3315 return self->findIdFirstEqual(vals2);
3317 %#if PY_VERSION_HEX >= 0x03000000
3318 if(PyUnicode_Check(vals))
3320 Py_ssize_t sz=PyUnicode_GET_LENGTH(vals);
3321 std::vector<char> vals2(sz);
3322 std::copy(PyUnicode_AsUTF8(vals),PyUnicode_AsUTF8(vals)+sz,vals2.begin());
3323 return self->findIdFirstEqual(vals2);
3327 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::findIdFirstEqual : only strings in input supported !");
3330 mcIdType findIdFirstEqualTuple(PyObject *tupl) const
3332 if(PyString_Check(tupl))
3334 Py_ssize_t sz=PyString_Size(tupl);
3335 std::vector<char> vals(sz);
3336 std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin());
3337 return self->findIdFirstEqualTuple(vals);
3339 %#if PY_VERSION_HEX >= 0x03000000
3340 if(PyUnicode_Check(tupl))
3342 Py_ssize_t sz=PyUnicode_GET_LENGTH(tupl);
3343 std::vector<char> vals(sz);
3344 std::copy(PyUnicode_AsUTF8(tupl),PyUnicode_AsUTF8(tupl)+sz,vals.begin());
3345 return self->findIdFirstEqualTuple(vals);
3349 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::findIdFirstEqualTuple : only strings in input supported !");
3352 mcIdType findIdSequence(PyObject *strOrListOfInt) const
3354 if(PyString_Check(strOrListOfInt))
3356 Py_ssize_t sz=PyString_Size(strOrListOfInt);
3357 std::vector<char> vals(sz);
3358 std::copy(PyString_AsString(strOrListOfInt),PyString_AsString(strOrListOfInt)+sz,vals.begin());
3359 return self->findIdSequence(vals);
3361 %#if PY_VERSION_HEX >= 0x03000000
3362 else if(PyUnicode_Check(strOrListOfInt))
3364 Py_ssize_t sz=PyUnicode_GET_LENGTH(strOrListOfInt);
3365 std::vector<char> vals(sz);
3366 std::copy(PyUnicode_AsUTF8(strOrListOfInt),PyUnicode_AsUTF8(strOrListOfInt)+sz,vals.begin());
3367 return self->findIdSequence(vals);
3371 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::search : only strings in input supported !");
3374 PyObject *getTuple(mcIdType tupleId) const
3376 std::size_t sz=self->getNumberOfComponents();
3377 INTERP_KERNEL::AutoPtr<char> tmp=new char[sz+1]; tmp[sz]='\0';
3378 self->getTuple(tupleId,tmp);
3379 return PyString_FromString(tmp);
3382 PyObject *getMaxValue() const
3385 char tmp2[2]; tmp2[1]='\0';
3386 tmp2[0]=self->getMaxValue(tmp);
3387 PyObject *ret=PyTuple_New(2);
3388 PyTuple_SetItem(ret,0,PyString_FromString(tmp2));
3389 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
3393 PyObject *getMinValue() const
3396 char tmp2[2]; tmp2[1]='\0';
3397 tmp2[0]=self->getMinValue(tmp);
3398 PyObject *ret=PyTuple_New(2);
3399 PyTuple_SetItem(ret,0,PyString_FromString(tmp2));
3400 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
3404 mcIdType index(PyObject *obj) const
3406 std::size_t nbOfCompo=self->getNumberOfComponents();
3411 if(PyString_Check(obj))
3413 Py_ssize_t sz=PyString_Size(obj);
3414 char *pt=PyString_AsString(obj);
3416 return self->findIdFirstEqual(pt[0]);
3418 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find a string with size different from 1 !");
3420 %#if PY_VERSION_HEX >= 0x03000000
3421 if(PyUnicode_Check(obj))
3424 const char *pt=PyUnicode_AsUTF8AndSize(obj, &sz);
3426 return self->findIdFirstEqual(pt[0]);
3428 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find a string with size different from 1 !");
3432 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find an element which is not an integer !");
3435 return MEDCoupling_DataArrayAsciiChar_findIdFirstEqualTuple(self,obj);
3439 bool __contains__(PyObject *obj) const
3441 std::size_t nbOfCompo=self->getNumberOfComponents();
3448 if(PyString_Check(obj))
3450 Py_ssize_t sz=PyString_Size(obj);
3451 char *pt=PyString_AsString(obj);
3453 return self->presenceOfValue(pt[0]);
3455 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find a string with size different from 1 !");
3457 %#if PY_VERSION_HEX >= 0x03000000
3458 if(PyUnicode_Check(obj))
3461 const char *pt=PyUnicode_AsUTF8AndSize(obj, &sz);
3463 return self->presenceOfValue(pt[0]);
3465 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find a string with size different from 1 !");
3469 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
3472 return MEDCoupling_DataArrayAsciiChar_presenceOfTuple(self,obj);
3476 PyObject *__getitem__(PyObject *obj) const
3478 mcIdType sw,iTypppArr;
3479 std::vector<mcIdType> stdvecTyyppArr;
3480 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > sTyyppArr;
3481 MEDCoupling::DataArrayIdType *daIntTyypp=0;
3482 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,self->getNumberOfTuples(),sw,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp);
3486 return MEDCoupling_DataArrayAsciiChar_getTuple(self,iTypppArr);
3488 return convertDataArrayChar(self->selectByTupleIdSafe(&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size()), SWIG_POINTER_OWN | 0 );
3490 return convertDataArrayChar(self->selectByTupleIdSafeSlice(sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second), SWIG_POINTER_OWN | 0 );
3492 return convertDataArrayChar(self->selectByTupleIdSafe(daIntTyypp->begin(),daIntTyypp->end()), SWIG_POINTER_OWN | 0 );
3494 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__getitem__ : supporting int, list of int, tuple of int, DataArrayIdType and slice in input !");
3498 DataArrayAsciiChar *__setitem__(PyObject *obj, PyObject *value)
3500 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.";
3501 mcIdType sw1,iTypppArr;
3502 std::vector<mcIdType> stdvecTyyppArr;
3503 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > sTyyppArr;
3504 MEDCoupling::DataArrayIdType *daIntTyypp=0;
3505 mcIdType nbOfCompo=ToIdType(self->getNumberOfComponents());
3506 mcIdType nbOfTuples=self->getNumberOfTuples();
3507 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbOfTuples,sw1,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp);
3509 char vc; std::string sc; std::vector<std::string> vsc; DataArrayChar *dacc=0;
3510 convertObjToPossibleCpp6(value,sw2,vc,sc,vsc,dacc);
3519 self->setPartOfValuesSimple3(vc,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1);
3525 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3526 self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3529 //value vector<string>
3532 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3533 self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3536 //value DataArrayChar
3539 self->setPartOfValues3(dacc,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3543 throw INTERP_KERNEL::Exception(msg);
3547 {//obj list-tuple[int]
3553 self->setPartOfValuesSimple3(vc,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1);
3559 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3560 self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3563 //value vector<string>
3566 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3567 self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3570 //value DataArrayChar
3573 self->setPartOfValues3(dacc,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3577 throw INTERP_KERNEL::Exception(msg);
3588 self->setPartOfValuesSimple1(vc,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1);
3594 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3595 self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3598 //value vector<string>
3601 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3602 self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3605 //value DataArrayChar
3608 self->setPartOfValues1(dacc,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3612 throw INTERP_KERNEL::Exception(msg);
3623 self->setPartOfValuesSimple3(vc,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1);
3629 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3630 self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3633 //value vector<string>
3636 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3637 self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3640 //value DataArrayChar
3643 self->setPartOfValues3(dacc,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3647 throw INTERP_KERNEL::Exception(msg);
3652 throw INTERP_KERNEL::Exception(msg);
3658 class DataArrayAsciiCharTuple;
3660 class DataArrayAsciiCharIterator
3663 DataArrayAsciiCharIterator(DataArrayAsciiChar *da);
3664 ~DataArrayAsciiCharIterator();
3669 DataArrayAsciiCharTuple *ret=self->nextt();
3671 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayAsciiCharTuple,SWIG_POINTER_OWN | 0);
3674 PyErr_SetString(PyExc_StopIteration,"No more data.");
3681 class DataArrayAsciiCharTuple
3684 std::size_t getNumberOfCompo() const;
3685 DataArrayAsciiChar *buildDAAsciiChar(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
3688 std::string __str__() const
3690 return self->repr();
3693 DataArrayAsciiChar *buildDAAsciiChar()
3695 return self->buildDAAsciiChar(1,self->getNumberOfCompo());
3701 %include "DataArrayInt.i"
3704 def MEDCouplingStdReduceFunct(cls,params):
3706 ret=object.__new__(cls)
3711 def MEDCouplingDataArrayDoubleReduce(self):
3712 if not MEDCouplingHasNumPyBindings():
3713 raise InterpKernelException("PyWrap of DataArrayDouble.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3714 return MEDCouplingStdReduceFunct,(DataArrayDouble,((self.toNumPyArray(),),(self.__getstate__()),))
3716 def MEDCouplingDataArrayInt32Reduce(self):
3717 if not MEDCouplingHasNumPyBindings():
3718 raise InterpKernelException("PyWrap of DataArrayIdType.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3719 return MEDCouplingStdReduceFunct,(DataArrayInt32,((self.toNumPyArray(),),(self.__getstate__()),))
3721 def MEDCouplingDataArrayInt64Reduce(self):
3722 if not MEDCouplingHasNumPyBindings():
3723 raise InterpKernelException("PyWrap of DataArrayIdType.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3724 return MEDCouplingStdReduceFunct,(DataArrayInt64,((self.toNumPyArray(),),(self.__getstate__()),))
3726 def MEDCouplingDataArrayByteReduce(self):
3727 if not MEDCouplingHasNumPyBindings():
3728 raise InterpKernelException("PyWrap of DataArrayByte.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3729 return MEDCouplingStdReduceFunct,(DataArrayByte,((self.toNumPyArray(),),(self.__getstate__()),))
3731 def MEDCouplingDataArrayFloatReduce(self):
3732 if not MEDCouplingHasNumPyBindings():
3733 raise InterpKernelException("PyWrap of DataArrayFloat.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3734 return MEDCouplingStdReduceFunct,(DataArrayFloat,((self.toNumPyArray(),),(self.__getstate__()),))
3736 if MEDCouplingUse64BitIDs():
3737 DataArrayInt=DataArrayInt64
3739 DataArrayInt=DataArrayInt32