1 // Copyright (C) 2007-2021 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::DataArrayInt32::convertToInt64Arr;
163 %newobject MEDCoupling::DataArrayInt32Tuple::buildDAInt;
164 %newobject MEDCoupling::DataArrayInt64::New;
165 %newobject MEDCoupling::DataArrayInt64::__iter__;
166 %newobject MEDCoupling::DataArrayInt64::performCopyOrIncrRef;
167 %newobject MEDCoupling::DataArrayInt64::subArray;
168 %newobject MEDCoupling::DataArrayInt64::changeNbOfComponents;
169 %newobject MEDCoupling::DataArrayInt64::accumulatePerChunck;
170 %newobject MEDCoupling::DataArrayInt64::checkAndPreparePermutation;
171 %newobject MEDCoupling::DataArrayInt64::transformWithIndArrR;
172 %newobject MEDCoupling::DataArrayInt64::renumber;
173 %newobject MEDCoupling::DataArrayInt64::renumberR;
174 %newobject MEDCoupling::DataArrayInt64::renumberAndReduce;
175 %newobject MEDCoupling::DataArrayInt64::invertArrayO2N2N2O;
176 %newobject MEDCoupling::DataArrayInt64::invertArrayN2O2O2N;
177 %newobject MEDCoupling::DataArrayInt64::invertArrayO2N2N2OBis;
178 %newobject MEDCoupling::DataArrayInt64::findIdsEqual;
179 %newobject MEDCoupling::DataArrayInt64::findIdsNotEqual;
180 %newobject MEDCoupling::DataArrayInt64::findIdsEqualList;
181 %newobject MEDCoupling::DataArrayInt64::findIdsNotEqualList;
182 %newobject MEDCoupling::DataArrayInt64::findIdsEqualTuple;
183 %newobject MEDCoupling::DataArrayInt64::findIdForEach;
184 %newobject MEDCoupling::DataArrayInt64::sumPerTuple;
185 %newobject MEDCoupling::DataArrayInt64::negate;
186 %newobject MEDCoupling::DataArrayInt64::computeAbs;
187 %newobject MEDCoupling::DataArrayInt64::findIdsInRange;
188 %newobject MEDCoupling::DataArrayInt64::findIdsNotInRange;
189 %newobject MEDCoupling::DataArrayInt64::findIdsStrictlyNegative;
190 %newobject MEDCoupling::DataArrayInt64::Aggregate;
191 %newobject MEDCoupling::DataArrayInt64::AggregateIndexes;
192 %newobject MEDCoupling::DataArrayInt64::Meld;
193 %newobject MEDCoupling::DataArrayInt64::Add;
194 %newobject MEDCoupling::DataArrayInt64::Substract;
195 %newobject MEDCoupling::DataArrayInt64::Multiply;
196 %newobject MEDCoupling::DataArrayInt64::Divide;
197 %newobject MEDCoupling::DataArrayInt64::Pow;
198 %newobject MEDCoupling::DataArrayInt64::BuildUnion;
199 %newobject MEDCoupling::DataArrayInt64::BuildIntersection;
200 %newobject MEDCoupling::DataArrayInt64::Range;
201 %newobject MEDCoupling::DataArrayInt64::indicesOfSubPart;
202 %newobject MEDCoupling::DataArrayInt64::fromNoInterlace;
203 %newobject MEDCoupling::DataArrayInt64::toNoInterlace;
204 %newobject MEDCoupling::DataArrayInt64::buildComplement;
205 %newobject MEDCoupling::DataArrayInt64::buildUnion;
206 %newobject MEDCoupling::DataArrayInt64::buildSubstraction;
207 %newobject MEDCoupling::DataArrayInt64::buildSubstractionOptimized;
208 %newobject MEDCoupling::DataArrayInt64::buildIntersection;
209 %newobject MEDCoupling::DataArrayInt64::indexOfSameConsecutiveValueGroups;
210 %newobject MEDCoupling::DataArrayInt64::buildUnique;
211 %newobject MEDCoupling::DataArrayInt64::buildUniqueNotSorted;
212 %newobject MEDCoupling::DataArrayInt64::deltaShiftIndex;
213 %newobject MEDCoupling::DataArrayInt64::buildExplicitArrByRanges;
214 %newobject MEDCoupling::DataArrayInt64::buildExplicitArrOfSliceOnScaledArr;
215 %newobject MEDCoupling::DataArrayInt64::findRangeIdForEachTuple;
216 %newobject MEDCoupling::DataArrayInt64::findIdInRangeForEachTuple;
217 %newobject MEDCoupling::DataArrayInt64::duplicateEachTupleNTimes;
218 %newobject MEDCoupling::DataArrayInt64::occurenceRankInThis;
219 %newobject MEDCoupling::DataArrayInt64::buildPermutationArr;
220 %newobject MEDCoupling::DataArrayInt64::buildPermArrPerLevel;
221 %newobject MEDCoupling::DataArrayInt64::getDifferentValues;
222 %newobject MEDCoupling::DataArrayInt64::FindPermutationFromFirstToSecond;
223 %newobject MEDCoupling::DataArrayInt64::FindPermutationFromFirstToSecondDuplicate;
224 %newobject MEDCoupling::DataArrayInt64::CheckAndPreparePermutation;
225 %newobject MEDCoupling::DataArrayInt64::__neg__;
226 %newobject MEDCoupling::DataArrayInt64::__add__;
227 %newobject MEDCoupling::DataArrayInt64::__radd__;
228 %newobject MEDCoupling::DataArrayInt64::__sub__;
229 %newobject MEDCoupling::DataArrayInt64::__rsub__;
230 %newobject MEDCoupling::DataArrayInt64::__mul__;
231 %newobject MEDCoupling::DataArrayInt64::__rmul__;
232 %newobject MEDCoupling::DataArrayInt64::__div__;
233 %newobject MEDCoupling::DataArrayInt64::__rdiv__;
234 %newobject MEDCoupling::DataArrayInt64::__mod__;
235 %newobject MEDCoupling::DataArrayInt64::__rmod__;
236 %newobject MEDCoupling::DataArrayInt64::__pow__;
237 %newobject MEDCoupling::DataArrayInt64::__rpow__;
238 %newobject MEDCoupling::DataArrayInt64::convertToInt32Arr;
239 %newobject MEDCoupling::DataArrayInt64Tuple::buildDAInt;
240 %newobject MEDCoupling::DataArrayChar::convertToIntArr;
241 %newobject MEDCoupling::DataArrayChar::renumber;
242 %newobject MEDCoupling::DataArrayChar::renumberR;
243 %newobject MEDCoupling::DataArrayChar::renumberAndReduce;
244 %newobject MEDCoupling::DataArrayChar::changeNbOfComponents;
245 %newobject MEDCoupling::DataArrayChar::findIdsEqual;
246 %newobject MEDCoupling::DataArrayChar::findIdsNotEqual;
247 %newobject MEDCoupling::DataArrayChar::Aggregate;
248 %newobject MEDCoupling::DataArrayChar::Meld;
249 %newobject MEDCoupling::DataArrayByte::New;
250 %newobject MEDCoupling::DataArrayByte::__iter__;
251 %newobject MEDCoupling::DataArrayByte::performCopyOrIncrRef;
252 %newobject MEDCoupling::DataArrayByteTuple::buildDAByte;
253 %newobject MEDCoupling::DataArrayChar::subArray;
254 %newobject MEDCoupling::DataArrayAsciiChar::New;
255 %newobject MEDCoupling::DataArrayAsciiChar::__iter__;
256 %newobject MEDCoupling::DataArrayAsciiChar::performCopyOrIncrRef;
257 %newobject MEDCoupling::DataArrayAsciiCharTuple::buildDAAsciiChar;
258 %newobject MEDCoupling::DataArrayDouble::New;
259 %newobject MEDCoupling::DataArrayDouble::__iter__;
260 %newobject MEDCoupling::DataArrayDouble::performCopyOrIncrRef;
261 %newobject MEDCoupling::DataArrayDouble::Aggregate;
262 %newobject MEDCoupling::DataArrayDouble::Meld;
263 %newobject MEDCoupling::DataArrayDouble::Dot;
264 %newobject MEDCoupling::DataArrayDouble::CrossProduct;
265 %newobject MEDCoupling::DataArrayDouble::Add;
266 %newobject MEDCoupling::DataArrayDouble::Substract;
267 %newobject MEDCoupling::DataArrayDouble::Multiply;
268 %newobject MEDCoupling::DataArrayDouble::Divide;
269 %newobject MEDCoupling::DataArrayDouble::Pow;
270 %newobject MEDCoupling::DataArrayDouble::symmetry3DPlane;
271 %newobject MEDCoupling::DataArrayDouble::subArray;
272 %newobject MEDCoupling::DataArrayDouble::changeNbOfComponents;
273 %newobject MEDCoupling::DataArrayDouble::accumulatePerChunck;
274 %newobject MEDCoupling::DataArrayDouble::findIdsInRange;
275 %newobject MEDCoupling::DataArrayDouble::findIdsNotInRange;
276 %newobject MEDCoupling::DataArrayDouble::findIdsStrictlyNegative;
277 %newobject MEDCoupling::DataArrayDouble::negate;
278 %newobject MEDCoupling::DataArrayDouble::computeAbs;
279 %newobject MEDCoupling::DataArrayDouble::applyFunc;
280 %newobject MEDCoupling::DataArrayDouble::applyFuncCompo;
281 %newobject MEDCoupling::DataArrayDouble::applyFuncNamedCompo;
282 %newobject MEDCoupling::DataArrayDouble::doublyContractedProduct;
283 %newobject MEDCoupling::DataArrayDouble::determinant;
284 %newobject MEDCoupling::DataArrayDouble::eigenValues;
285 %newobject MEDCoupling::DataArrayDouble::eigenVectors;
286 %newobject MEDCoupling::DataArrayDouble::inverse;
287 %newobject MEDCoupling::DataArrayDouble::trace;
288 %newobject MEDCoupling::DataArrayDouble::deviator;
289 %newobject MEDCoupling::DataArrayDouble::magnitude;
290 %newobject MEDCoupling::DataArrayDouble::maxPerTuple;
291 %newobject MEDCoupling::DataArrayDouble::sumPerTuple;
292 %newobject MEDCoupling::DataArrayDouble::computeBBoxPerTuple;
293 %newobject MEDCoupling::DataArrayDouble::buildEuclidianDistanceDenseMatrix;
294 %newobject MEDCoupling::DataArrayDouble::buildEuclidianDistanceDenseMatrixWith;
295 %newobject MEDCoupling::DataArrayDouble::renumber;
296 %newobject MEDCoupling::DataArrayDouble::renumberR;
297 %newobject MEDCoupling::DataArrayDouble::renumberAndReduce;
298 %newobject MEDCoupling::DataArrayDouble::fromNoInterlace;
299 %newobject MEDCoupling::DataArrayDouble::toNoInterlace;
300 %newobject MEDCoupling::DataArrayDouble::fromPolarToCart;
301 %newobject MEDCoupling::DataArrayDouble::fromCylToCart;
302 %newobject MEDCoupling::DataArrayDouble::fromSpherToCart;
303 %newobject MEDCoupling::DataArrayDouble::fromCartToPolar;
304 %newobject MEDCoupling::DataArrayDouble::fromCartToCyl;
305 %newobject MEDCoupling::DataArrayDouble::fromCartToSpher;
306 %newobject MEDCoupling::DataArrayDouble::fromCartToCylGiven;
307 %newobject MEDCoupling::DataArrayDouble::cartesianize;
308 %newobject MEDCoupling::DataArrayDouble::getDifferentValues;
309 %newobject MEDCoupling::DataArrayDouble::findClosestTupleId;
310 %newobject MEDCoupling::DataArrayDouble::computeNbOfInteractionsWith;
311 %newobject MEDCoupling::DataArrayDouble::duplicateEachTupleNTimes;
312 %newobject MEDCoupling::DataArrayDouble::__neg__;
313 %newobject MEDCoupling::DataArrayDouble::__radd__;
314 %newobject MEDCoupling::DataArrayDouble::__rsub__;
315 %newobject MEDCoupling::DataArrayDouble::__rmul__;
316 %newobject MEDCoupling::DataArrayDouble::__rdiv__;
317 %newobject MEDCoupling::DataArrayDouble::__pow__;
318 %newobject MEDCoupling::DataArrayDouble::__rpow__;
319 %newobject MEDCoupling::DataArrayDoubleTuple::buildDADouble;
321 %newobject MEDCoupling::PartDefinition::New;
322 %newobject MEDCoupling::PartDefinition::toDAI;
323 %newobject MEDCoupling::PartDefinition::__add__;
324 %newobject MEDCoupling::PartDefinition::composeWith;
325 %newobject MEDCoupling::PartDefinition::tryToSimplify;
326 %newobject MEDCoupling::DataArrayPartDefinition::New;
327 %newobject MEDCoupling::SlicePartDefinition::New;
329 %newobject FromPyIntPtrToDataArrayByte;
332 %feature("unref") DataArray "$this->decrRef();"
333 %feature("unref") DataArrayDouble "$this->decrRef();"
334 %feature("unref") DataArrayInt32 "$this->decrRef();"
335 %feature("unref") DataArrayInt64 "$this->decrRef();"
336 %feature("unref") DataArrayChar "$this->decrRef();"
337 %feature("unref") DataArrayAsciiChar "$this->decrRef();"
338 %feature("unref") DataArrayByte "$this->decrRef();"
340 %feature("unref") MapII "$this->decrRef();"
341 %feature("unref") PartDefinition "$this->decrRef();"
342 %feature("unref") DataArrayPartDefinition "$this->decrRef();"
343 %feature("unref") SlicePartDefinition "$this->decrRef();"
345 namespace MEDCoupling
352 } MEDCouplingAxisType;
354 class DataArrayInt32;
355 class DataArrayInt64;
357 #ifndef MEDCOUPLING_USE_64BIT_IDS
358 typedef DataArrayInt32 DataArrayIdType;
359 #define DataArrayIdType DataArrayInt32
361 typedef DataArrayInt64 DataArrayIdType;
362 #define DataArrayIdType DataArrayInt64
365 class MapII : public RefCountObject, public TimeLabel
368 static MCAuto< MapII > New();
371 class PartDefinition : public RefCountObject, public TimeLabel
374 static PartDefinition *New(int start, int stop, int step);
375 static PartDefinition *New(DataArrayIdType *listOfIds);
376 virtual DataArrayIdType *toDAI() const;
377 virtual int getNumberOfElems() const;
378 virtual std::string getRepr() const;
379 virtual PartDefinition *composeWith(const PartDefinition *other) const;
380 virtual void checkConsistencyLight() const;
381 virtual PartDefinition *tryToSimplify() const;
384 virtual PartDefinition *__add__(const PartDefinition& other) const
386 return (*self)+other;
389 virtual PyObject *isEqual(const PartDefinition *other) const
392 bool ret0(self->isEqual(other,ret1));
393 PyObject *ret=PyTuple_New(2);
394 PyObject *ret0Py=ret0?Py_True:Py_False;
396 PyTuple_SetItem(ret,0,ret0Py);
397 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
401 virtual PyObject *deepCopy() const
403 return convertPartDefinition(self->deepCopy(),SWIG_POINTER_OWN | 0);
407 virtual ~PartDefinition();
410 class DataArrayPartDefinition : public PartDefinition
413 static DataArrayPartDefinition *New(DataArrayIdType *listOfIds);
416 DataArrayPartDefinition(DataArrayIdType *listOfIds)
418 return DataArrayPartDefinition::New(listOfIds);
421 std::string __str__() const
423 return self->getRepr();
426 std::string __repr__() const
428 std::ostringstream oss; oss << "DataArrayPartDefinition C++ instance at " << self << "." << std::endl;
429 oss << self->getRepr();
434 virtual ~DataArrayPartDefinition();
437 class SlicePartDefinition : public PartDefinition
440 static SlicePartDefinition *New(int start, int stop, int step);
441 int getEffectiveStop() const;
444 SlicePartDefinition(mcIdType start, mcIdType stop, mcIdType step)
446 return SlicePartDefinition::New(start,stop,step);
449 PyObject *getSlice() const
452 self->getSlice(a,b,c);
453 return PySlice_New(PyInt_FromLong(a),PyInt_FromLong(b),PyInt_FromLong(c));
456 std::string __str__() const
458 return self->getRepr();
461 std::string __repr__() const
463 std::ostringstream oss; oss << "SlicePartDefinition C++ instance at " << self << "." << std::endl;
464 oss << self->getRepr();
469 virtual ~SlicePartDefinition();
472 class DataArray : public RefCountObject, public TimeLabel
475 void setName(const std::string& name);
476 void copyStringInfoFrom(const DataArray& other);
477 void copyPartOfStringInfoFrom(const DataArray& other, const std::vector<std::size_t>& compoIds);
478 void copyPartOfStringInfoFrom2(const std::vector<std::size_t>& compoIds, const DataArray& other);
479 bool areInfoEqualsIfNotWhy(const DataArray& other, std::string& reason) const;
480 bool areInfoEquals(const DataArray& other) const;
481 std::string cppRepr(const std::string& varName) const;
482 std::string getName() const;
483 void setInfoOnComponents(const std::vector<std::string>& info);
484 void setInfoAndChangeNbOfCompo(const std::vector<std::string>& info);
485 std::vector<std::string> getVarsOnComponent() const;
486 std::vector<std::string> getUnitsOnComponent() const;
487 std::string getInfoOnComponent(int i) const;
488 std::string getVarOnComponent(int i) const;
489 std::string getUnitOnComponent(int i) const;
490 void setInfoOnComponent(int i, const std::string& info);
491 int getNumberOfComponents() const;
492 virtual void alloc(int nbOfTuple, int nbOfCompo=1);
493 virtual void reAlloc(int nbOfTuples);
494 virtual bool isAllocated() const;
495 virtual void checkAllocated() const;
496 virtual void desallocate();
497 virtual int getNumberOfTuples() const;
498 virtual std::size_t getNbOfElems() const;
499 virtual std::size_t getNbOfElemAllocated() const;
500 virtual DataArray *deepCopy() const;
501 virtual DataArray *copySorted() const;
502 virtual DataArray *buildNewEmptyInstance() const;
503 virtual DataArray *selectByTupleIdSafeSlice(int bg, int end2, int step) const;
504 virtual void rearrange(int newNbOfCompo);
505 virtual void circularPermutation(int nbOfShift=1);
506 virtual void circularPermutationPerTuple(int nbOfShift=1);
507 virtual void reversePerTuple();
508 void checkNbOfTuples(int nbOfTuples, const std::string& msg) const;
509 void checkNbOfComps(int nbOfCompo, const std::string& msg) const;
510 void checkNbOfTuplesAndComp(const DataArray& other, const std::string& msg) const;
511 void checkNbOfTuplesAndComp(int nbOfTuples, int nbOfCompo, const std::string& msg) const;
512 void checkNbOfElems(mcIdType nbOfElems, const std::string& msg) const;
513 static int GetNumberOfItemGivenBES(int begin, int end, int step, const std::string& msg);
514 static int GetNumberOfItemGivenBESRelative(int begin, int end, int step, const std::string& msg);
515 static int GetPosOfItemGivenBESRelativeNoThrow(int value, int begin, int end, int step);
516 static std::string GetVarNameFromInfo(const std::string& info);
517 static std::string GetUnitFromInfo(const std::string& info);
518 static std::string BuildInfoFromVarAndUnit(const std::string& var, const std::string& unit);
519 static std::string GetAxisTypeRepr(MEDCouplingAxisType at);
520 void updateTime() const;
523 PyObject *getInfoOnComponents() const
525 const std::vector<std::string>& comps=self->getInfoOnComponents();
526 PyObject *ret=PyList_New((mcIdType)comps.size());
527 for(std::size_t i=0;i<comps.size();i++)
528 PyList_SetItem(ret,i,PyString_FromString(comps[i].c_str()));
532 void copyPartOfStringInfoFrom(const DataArray& other, PyObject *li)
534 std::vector<std::size_t> tmp;
535 convertPyToNewIntArr3(li,tmp);
536 self->copyPartOfStringInfoFrom(other,tmp);
539 void copyPartOfStringInfoFrom2(PyObject *li, const DataArray& other)
541 std::vector<std::size_t> tmp;
542 convertPyToNewIntArr3(li,tmp);
543 self->copyPartOfStringInfoFrom2(tmp,other);
546 virtual void renumberInPlace(PyObject *li)
549 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
550 if (!SWIG_IsOK(res1))
553 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
554 if(size!=self->getNumberOfTuples())
556 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
558 self->renumberInPlace(tmp);
562 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
564 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
565 da2->checkAllocated();
566 mcIdType size=self->getNumberOfTuples();
567 if(size!=self->getNumberOfTuples())
569 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
571 self->renumberInPlace(da2->getConstPointer());
575 virtual void renumberInPlaceR(PyObject *li)
578 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
579 if (!SWIG_IsOK(res1))
582 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
583 if(size!=self->getNumberOfTuples())
585 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
587 self->renumberInPlaceR(tmp);
591 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
593 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
594 da2->checkAllocated();
595 mcIdType size=self->getNumberOfTuples();
596 if(size!=self->getNumberOfTuples())
598 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
600 self->renumberInPlaceR(da2->getConstPointer());
604 //tuplesSelec in PyObject * because DataArrayInt is not already existing !
605 virtual void setContigPartOfSelectedValues(mcIdType tupleIdStart, PyObject *aBase, PyObject *tuplesSelec)
607 static const char msg[]="DataArray::setContigPartOfSelectedValuesSlice : 4th parameter \"tuplesSelec\" should be of type DataArrayInt";
608 DataArray *a=CheckAndRetrieveDataArrayInstance(aBase,"DataArray::setContigPartOfSelectedValuesSlice : 3rd parameter \"aBase\" should be of type DataArray");
609 DataArray *tuplesSelecPtr=CheckAndRetrieveDataArrayInstance(tuplesSelec,msg);
610 DataArrayIdType *tuplesSelecPtr2=0;
613 tuplesSelecPtr2=dynamic_cast<DataArrayIdType *>(tuplesSelecPtr);
615 throw INTERP_KERNEL::Exception(msg);
617 self->setContigPartOfSelectedValues(tupleIdStart,a,tuplesSelecPtr2);
620 virtual void setContigPartOfSelectedValuesSlice(mcIdType tupleIdStart, PyObject *aBase, mcIdType bg, mcIdType end2, mcIdType step)
622 DataArray *a=CheckAndRetrieveDataArrayInstance(aBase,"DataArray::setContigPartOfSelectedValuesSlice : 2nd parameter \"aBase\" should be of type DataArray");
623 self->setContigPartOfSelectedValuesSlice(tupleIdStart,a,bg,end2,step);
626 virtual DataArray *selectByTupleRanges(PyObject *li) const
628 std::vector<std::pair<mcIdType,mcIdType> > ranges;
629 convertPyToVectorPairInt(li,ranges);
630 return self->selectByTupleRanges(ranges);
633 virtual DataArray *selectByTupleId(PyObject *li) const
636 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
637 if (!SWIG_IsOK(res1))
640 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
641 return self->selectByTupleId(tmp,tmp+size);
645 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
647 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
648 da2->checkAllocated();
649 return self->selectByTupleId(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
653 virtual DataArray *selectByTupleIdSafe(PyObject *li) const
656 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
657 if (!SWIG_IsOK(res1))
660 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
661 return self->selectByTupleIdSafe(tmp,tmp+size);
665 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
667 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
668 da2->checkAllocated();
669 return self->selectByTupleIdSafe(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
673 virtual PyObject *keepSelectedComponents(PyObject *li) const
675 std::vector<std::size_t> tmp;
676 convertPyToNewIntArr3(li,tmp);
677 DataArray *ret=self->keepSelectedComponents(tmp);
678 return convertDataArray(ret,SWIG_POINTER_OWN | 0 );
681 static PyObject *GetSlice(PyObject *slic, mcIdType sliceId, mcIdType nbOfSlices)
683 if(!PySlice_Check(slic))
684 throw INTERP_KERNEL::Exception("DataArray::GetSlice (wrap) : expecting a pyslice as second (first) parameter !");
685 Py_ssize_t strt=2,stp=2,step=2;
686 GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetSlice (wrap) : the input slice is invalid !");
688 DataArray::GetSlice(ToIdType(strt),ToIdType(stp),ToIdType(step),sliceId,nbOfSlices,a,b);
689 AutoPyPtr ap(PyInt_FromLong(a)),bp(PyInt_FromLong(b)),stepp(PyInt_FromLong(step));
690 return PySlice_New(ap,bp,stepp);
693 PyObject *getSlice(PyObject *slic, mcIdType sliceId, mcIdType nbOfSlices) const
695 if(!PySlice_Check(slic))
696 throw INTERP_KERNEL::Exception("DataArray::getSlice (wrap) : expecting a pyslice as second (first) parameter !");
697 Py_ssize_t strt=2,stp=2,step=2;
698 GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getSlice (wrap) : the input slice is invalid !");
700 DataArray::GetSlice(ToIdType(strt),ToIdType(stp),ToIdType(step),sliceId,nbOfSlices,a,b);
701 AutoPyPtr ap(PyInt_FromLong(a)),bp(PyInt_FromLong(b)),stepp(PyInt_FromLong(step));
702 return PySlice_New(ap,bp,stepp);
705 static mcIdType GetNumberOfItemGivenBES(PyObject *slic)
707 if(!PySlice_Check(slic))
708 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBES (wrap) : expecting a pyslice as second (first) parameter !");
709 Py_ssize_t strt=2,stp=2,step=2;
710 GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetNumberOfItemGivenBES (wrap) : the input slice is invalid !");
711 return DataArray::GetNumberOfItemGivenBES(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
714 static mcIdType GetNumberOfItemGivenBESRelative(PyObject *slic)
716 if(!PySlice_Check(slic))
717 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBESRelative (wrap) : expecting a pyslice as second (first) parameter !");
718 Py_ssize_t strt=2,stp=2,step=2;
719 GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !");
720 return DataArray::GetNumberOfItemGivenBESRelative(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
723 static DataArray *Aggregate(PyObject *arrs)
725 std::vector<const DataArray *> tmp;
726 convertFromPyObjVectorOfObj<const MEDCoupling::DataArray *>(arrs,SWIGTYPE_p_MEDCoupling__DataArray,"DataArray",tmp);
727 return DataArray::Aggregate(tmp);
730 mcIdType getNumberOfItemGivenBES(PyObject *slic) const
732 if(!PySlice_Check(slic))
733 throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBES (wrap) : expecting a pyslice as second (first) parameter !");
734 Py_ssize_t strt=2,stp=2,step=2;
735 GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getNumberOfItemGivenBES (wrap) : the input slice is invalid !");
736 return DataArray::GetNumberOfItemGivenBES(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
739 mcIdType getNumberOfItemGivenBESRelative(PyObject *slic)
741 if(!PySlice_Check(slic))
742 throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBESRelative (wrap) : expecting a pyslice as second (first) parameter !");
743 Py_ssize_t strt=2,stp=2,step=2;
744 GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !");
745 return DataArray::GetNumberOfItemGivenBESRelative(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
748 PyObject *__getstate__() const
750 PyObject *ret(PyTuple_New(2));
751 std::string a0(self->getName());
752 const std::vector<std::string> &a1(self->getInfoOnComponents());
753 PyTuple_SetItem(ret,0,PyString_FromString(a0.c_str()));
755 std::size_t sz(a1.size());
756 PyObject *ret1(PyList_New(sz));
757 for(std::size_t i=0;i<sz;i++)
758 PyList_SetItem(ret1,i,PyString_FromString(a1[i].c_str()));
759 PyTuple_SetItem(ret,1,ret1);
764 void __setstate__(PyObject *inp)
766 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 !";
767 if(!PyTuple_Check(inp))
768 throw INTERP_KERNEL::Exception("DataArrayDouble.__setstate__ : invalid input ! Invalid overwrite of __getstate__ ?");
769 std::size_t sz(PyTuple_Size(inp));
771 throw INTERP_KERNEL::Exception("DataArrayDouble.__setstate__ : invalid tuple in input ! Should be of size 2 ! Invalid overwrite of __getstate__ ?");
772 PyObject *a0(PyTuple_GetItem(inp,0));
773 self->setName(convertPyObjectToStr(a0,MSG));
774 PyObject *a1(PyTuple_GetItem(inp,1));
775 std::vector<std::string> a1cpp;
776 if(!fillStringVector(a1,a1cpp))
777 throw INTERP_KERNEL::Exception(MSG);
778 self->setInfoOnComponents(a1cpp);
783 class DataArrayDouble;
785 class DataArrayFloat : public DataArray
788 static DataArrayFloat *New();
789 void fillWithValue(float val);
790 bool isEqual(const DataArrayFloat& other, float prec) const;
791 bool isEqualWithoutConsideringStr(const DataArrayFloat& other, float prec) const;
792 bool isUniform(float val, float eps) const;
793 void pushBackSilent(float val);
794 void iota(float init=0.);
795 DataArrayFloatIterator *iterator();
796 MCAuto<DataArrayDouble> convertToDblArr() const;
797 static DataArrayFloat *Meld(const DataArrayFloat *a1, const DataArrayFloat *a2);
802 return DataArrayFloat::New();
805 static DataArrayFloat *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
807 return DataArrayT_New<float>(elt0,nbOfTuples,elt2);
810 DataArrayFloat(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
812 return MEDCoupling_DataArrayFloat_New__SWIG_1(elt0,nbOfTuples,elt2);
815 DataArrayFloatIterator *__iter__()
817 return self->iterator();
820 std::string __repr__() const
822 std::ostringstream oss;
823 self->reprQuickOverview(oss);
827 std::string __str__() const
829 return self->reprNotTooLong();
832 mcIdType __len__() const
834 if(self->isAllocated())
836 return self->getNumberOfTuples();
840 throw INTERP_KERNEL::Exception("DataArrayFloat::__len__ : Instance is NOT allocated !");
844 PyObject *getValues() const
846 const float *vals(self->begin());
847 return convertDblArrToPyList<float>(vals,self->getNbOfElems());
850 PyObject *getValuesAsTuple() const
852 const float *vals(self->begin());
853 std::size_t nbOfComp(self->getNumberOfComponents());
854 mcIdType nbOfTuples(self->getNumberOfTuples());
855 return convertDblArrToPyListOfTuple<float>(vals,nbOfComp,nbOfTuples);
858 PyObject *isEqualIfNotWhy(const DataArrayFloat& other, float prec) const
861 bool ret0=self->isEqualIfNotWhy(other,prec,ret1);
862 PyObject *ret=PyTuple_New(2);
863 PyObject *ret0Py=ret0?Py_True:Py_False;
865 PyTuple_SetItem(ret,0,ret0Py);
866 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
870 PyObject *__getitem__(PyObject *obj)
872 return DataArrayT__getitem<float>(self,obj);
875 DataArrayFloat *__setitem__(PyObject *obj, PyObject *value)
877 return DataArrayT__setitem__<float>(self,obj,value);
880 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
882 return DataArrayT_iadd<float>(trueSelf,obj,self);
885 PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
887 return DataArrayT_isub<float>(trueSelf,obj,self);
890 PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
892 return DataArrayT_imul<float>(trueSelf,obj,self);
895 DataArrayFloat *__rmul__(PyObject *obj)
897 return DataArrayFPT_rmul<float>(self,obj);
900 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
902 return DataArrayT_idiv<float>(trueSelf,obj,self);
906 PyObject *toNumPyArray() // not const. It is not a bug !
908 return ToNumPyArray<DataArrayFloat,float>(self,NPY_FLOAT,"DataArrayFloat");
914 class DataArrayFloatTuple;
916 class DataArrayFloatIterator
919 DataArrayFloatIterator(DataArrayFloat *da);
920 ~DataArrayFloatIterator();
925 DataArrayFloatTuple *ret=self->nextt();
927 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayFloatTuple,SWIG_POINTER_OWN|0);
930 PyErr_SetString(PyExc_StopIteration,"No more data.");
937 class DataArrayFloatTuple
940 std::size_t getNumberOfCompo() const;
941 DataArrayFloat *buildDAFloat(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
944 std::string __str__() const
949 float __float__() const
951 return self->floatValue();
954 DataArrayFloat *buildDAFloat()
956 return self->buildDAFloat(1,self->getNumberOfCompo());
959 /*PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
961 MCAuto<DataArrayFloat> ret=self->buildDAFloat(1,self->getNumberOfCompo());
962 MEDCoupling_DataArrayFloat____imul___(ret,0,obj);
963 Py_XINCREF(trueSelf);
969 return PyInt_FromLong(self->getNumberOfCompo());
974 class DataArrayDoubleIterator;
976 class DataArrayDouble : public DataArray
979 static DataArrayDouble *New();
980 double doubleValue() const;
982 void aggregate(const DataArrayDouble *other);
983 DataArrayDouble *performCopyOrIncrRef(bool deepCopy) const;
984 void deepCopyFrom(const DataArrayDouble& other);
985 void reserve(std::size_t nbOfElems);
986 void pushBackSilent(double val);
987 double popBackSilent();
989 void allocIfNecessary(int nbOfTuple, int nbOfCompo);
991 void fillWithValue(double val);
992 void iota(double init=0.);
993 bool isUniform(double val, double eps) const;
994 void sort(bool asc=true);
996 void checkMonotonic(bool increasing, double eps) const;
997 bool isMonotonic(bool increasing, double eps) const;
998 std::string repr() const;
999 std::string reprZip() const;
1000 std::string reprNotTooLong() const;
1001 bool isEqual(const DataArrayDouble& other, double prec) const;
1002 bool isEqualWithoutConsideringStr(const DataArrayDouble& other, double prec) const;
1003 DataArrayDouble *fromNoInterlace() const;
1004 DataArrayDouble *toNoInterlace() const;
1005 DataArrayDouble *subArray(int tupleIdBg, int tupleIdEnd=-1) const;
1007 DataArrayDouble *changeNbOfComponents(std::size_t newNbOfComp, double dftValue) const;
1008 void meldWith(const DataArrayDouble *other);
1009 DataArrayDouble *duplicateEachTupleNTimes(int nbTimes) const;
1010 DataArrayDouble *getDifferentValues(double prec, int limitTupleId=-1) const;
1011 DataArrayIdType *findClosestTupleId(const DataArrayDouble *other) const;
1012 DataArrayIdType *computeNbOfInteractionsWith(const DataArrayDouble *otherBBoxFrmt, double eps) const;
1013 void setPartOfValues1(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare=true);
1014 void setPartOfValuesSimple1(double a, mcIdType bgTuples, mcIdType endTuples, mcIdType stepTuples, mcIdType bgComp, mcIdType endComp, mcIdType stepComp);
1015 void setPartOfValuesAdv(const DataArrayDouble *a, const DataArrayIdType *tuplesSelec);
1016 double getIJ(int tupleId, int compoId) const;
1017 double front() const;
1018 double back() const;
1019 double getIJSafe(int tupleId, int compoId) const;
1020 void setIJ(int tupleId, int compoId, double newVal);
1021 void setIJSilent(int tupleId, int compoId, double newVal);
1022 double *getPointer();
1023 void checkNoNullValues() const;
1024 DataArrayDouble *computeBBoxPerTuple(double epsilon=0.0) const;
1025 void recenterForMaxPrecision(double eps);
1026 double getMaxValueInArray() const;
1027 double getMaxAbsValueInArray() const;
1028 double getMinValueInArray() const;
1029 int count(double value, double eps) const;
1030 double getAverageValue() const;
1031 double norm2() const;
1032 double normMax() const;
1033 double normMin() const;
1034 double accumulate(int compId) const;
1035 DataArrayDouble *fromPolarToCart() const;
1036 DataArrayDouble *fromCylToCart() const;
1037 DataArrayDouble *fromSpherToCart() const;
1038 DataArrayDouble *fromCartToPolar() const;
1039 DataArrayDouble *fromCartToCyl() const;
1040 DataArrayDouble *fromCartToSpher() const;
1041 DataArrayDouble *cartesianize(MEDCouplingAxisType atOfThis) const;
1042 DataArrayDouble *doublyContractedProduct() const;
1043 DataArrayDouble *determinant() const;
1044 DataArrayDouble *eigenValues() const;
1045 DataArrayDouble *eigenVectors() const;
1046 DataArrayDouble *inverse() const;
1047 DataArrayDouble *trace() const;
1048 DataArrayDouble *deviator() const;
1049 DataArrayDouble *magnitude() const;
1050 DataArrayDouble *maxPerTuple() const;
1051 DataArrayDouble *sumPerTuple() const;
1052 DataArrayDouble *buildEuclidianDistanceDenseMatrix() const;
1053 DataArrayDouble *buildEuclidianDistanceDenseMatrixWith(const DataArrayDouble *other) const;
1054 void sortPerTuple(bool asc);
1056 DataArrayDouble *computeAbs() const;
1057 void applyLin(double a, double b, int compoId);
1058 void applyLin(double a, double b);
1059 void applyInv(double numerator);
1060 void applyPow(double val);
1061 void applyRPow(double val);
1062 DataArrayDouble *negate() const;
1063 DataArrayDouble *applyFunc(int nbOfComp, FunctionToEvaluate func) const;
1064 DataArrayDouble *applyFunc(int nbOfComp, const std::string& func, bool isSafe=true) const;
1065 DataArrayDouble *applyFunc(const std::string& func, bool isSafe=true) const;
1066 void applyFuncOnThis(const std::string& func, bool isSafe=true);
1067 DataArrayDouble *applyFuncCompo(int nbOfComp, const std::string& func, bool isSafe=true) const;
1068 DataArrayDouble *applyFuncNamedCompo(int nbOfComp, const std::vector<std::string>& varsOrder, const std::string& func, bool isSafe=true) const;
1069 void applyFuncFast32(const std::string& func);
1070 void applyFuncFast64(const std::string& func);
1071 DataArrayIdType *findIdsInRange(double vmin, double vmax) const;
1072 DataArrayIdType *findIdsNotInRange(double vmin, double vmax) const;
1073 DataArrayIdType *findIdsStrictlyNegative() const;
1074 static DataArrayDouble *Aggregate(const DataArrayDouble *a1, const DataArrayDouble *a2);
1075 static DataArrayDouble *Meld(const DataArrayDouble *a1, const DataArrayDouble *a2);
1076 static DataArrayDouble *Dot(const DataArrayDouble *a1, const DataArrayDouble *a2);
1077 static DataArrayDouble *CrossProduct(const DataArrayDouble *a1, const DataArrayDouble *a2);
1078 static DataArrayDouble *Max(const DataArrayDouble *a1, const DataArrayDouble *a2);
1079 static DataArrayDouble *Min(const DataArrayDouble *a1, const DataArrayDouble *a2);
1080 static DataArrayDouble *Add(const DataArrayDouble *a1, const DataArrayDouble *a2);
1081 void addEqual(const DataArrayDouble *other);
1082 static DataArrayDouble *Substract(const DataArrayDouble *a1, const DataArrayDouble *a2);
1083 void substractEqual(const DataArrayDouble *other);
1084 static DataArrayDouble *Multiply(const DataArrayDouble *a1, const DataArrayDouble *a2);
1085 void multiplyEqual(const DataArrayDouble *other);
1086 static DataArrayDouble *Divide(const DataArrayDouble *a1, const DataArrayDouble *a2);
1087 void divideEqual(const DataArrayDouble *other);
1088 static DataArrayDouble *Pow(const DataArrayDouble *a1, const DataArrayDouble *a2);
1089 void powEqual(const DataArrayDouble *other);
1090 MCAuto<DataArrayIdType> findIdsGreaterOrEqualTo(double val) const;
1091 MCAuto<DataArrayIdType> findIdsGreaterThan(double val) const;
1092 MCAuto<DataArrayIdType> findIdsLowerOrEqualTo(double val) const;
1093 MCAuto<DataArrayIdType> findIdsLowerThan(double val) const;
1094 MCAuto<DataArrayInt32> convertToIntArr() const;
1095 MCAuto<DataArrayInt64> convertToInt64Arr() const;
1096 MCAuto<DataArrayDouble> selectPartDef(const PartDefinition* pd) const;
1097 MCAuto<DataArrayDouble> cumSum() const;
1098 MCAuto<DataArrayFloat> convertToFloatArr() const;
1103 return DataArrayDouble::New();
1106 static DataArrayDouble *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
1108 return DataArrayT_New<double>(elt0,nbOfTuples,elt2);
1111 DataArrayDouble(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
1113 return MEDCoupling_DataArrayDouble_New__SWIG_1(elt0,nbOfTuples,elt2);
1116 void pushBackValsSilent(PyObject *li)
1119 std::vector<double> bb;
1120 mcIdType sw; mcIdType nbTuples=-1;
1121 const char msg[]="Python wrap of DataArrayDouble::pushBackValsSilent : ";
1122 const double *tmp=convertObjToPossibleCpp5_SingleCompo(li,sw,val,bb,msg,true,nbTuples);
1123 self->pushBackValsSilent(tmp,tmp+nbTuples);
1126 std::string __repr__() const
1128 std::ostringstream oss;
1129 self->reprQuickOverview(oss);
1133 std::string __str__() const
1135 return self->reprNotTooLong();
1138 double __float__() const
1140 return self->doubleValue();
1143 mcIdType __len__() const
1145 if(self->isAllocated())
1147 return self->getNumberOfTuples();
1151 throw INTERP_KERNEL::Exception("DataArrayDouble::__len__ : Instance is NOT allocated !");
1155 PyObject *asArcOfCircle() const
1157 double center[2],radius,ang;
1158 self->asArcOfCircle(center,radius,ang);
1159 PyObject *ret(PyTuple_New(3));
1161 PyObject *ret0(PyList_New(2));
1162 PyList_SetItem(ret0,0,PyFloat_FromDouble(center[0]));
1163 PyList_SetItem(ret0,1,PyFloat_FromDouble(center[1]));
1164 PyTuple_SetItem(ret,0,ret0);
1166 PyTuple_SetItem(ret,1,PyFloat_FromDouble(radius));
1167 PyTuple_SetItem(ret,2,PyFloat_FromDouble(ang));
1171 DataArrayDoubleIterator *__iter__()
1173 return self->iterator();
1176 void setValues(PyObject *li, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
1178 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 !";
1179 if(PyList_Check(li) || PyTuple_Check(li))
1181 if(nbOfTuples && nbOfTuples != Py_None)
1183 if(PyInt_Check(nbOfTuples))
1185 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
1187 throw INTERP_KERNEL::Exception("DataArrayDouble::setValues : should be a positive set of allocated memory !");
1188 if(nbOfComp && nbOfComp != Py_None)
1190 if(PyInt_Check(nbOfComp))
1191 {//DataArrayDouble.setValues([1.,3.,4.,5.],2,2)
1192 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
1194 throw INTERP_KERNEL::Exception("DataArrayDouble::setValues : should be a positive number of components !");
1195 std::vector<double> tmp=fillArrayWithPyListDbl2(li,nbOfTuples1,nbOfCompo);
1196 self->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1199 throw INTERP_KERNEL::Exception(msg);
1202 {//DataArrayDouble.setValues([1.,3.,4.],3)
1204 std::vector<double> tmp=fillArrayWithPyListDbl2(li,nbOfTuples1,tmpp1);
1205 self->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1209 throw INTERP_KERNEL::Exception(msg);
1212 {// DataArrayDouble.setValues([1.,3.,4.])
1213 mcIdType tmpp1=-1,tmpp2=-1;
1214 std::vector<double> tmp=fillArrayWithPyListDbl2(li,tmpp1,tmpp2);
1215 self->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1219 throw INTERP_KERNEL::Exception(msg);
1222 PyObject *getValues() const
1224 const double *vals(self->begin());
1225 return convertDblArrToPyList<double>(vals,self->getNbOfElems());
1229 PyObject *toNumPyArray() // not const. It is not a bug !
1231 return ToNumPyArray<DataArrayDouble,double>(self,NPY_DOUBLE,"DataArrayDouble");
1235 PyObject *isEqualIfNotWhy(const DataArrayDouble& other, double prec) const
1238 bool ret0=self->isEqualIfNotWhy(other,prec,ret1);
1239 PyObject *ret=PyTuple_New(2);
1240 PyObject *ret0Py=ret0?Py_True:Py_False;
1242 PyTuple_SetItem(ret,0,ret0Py);
1243 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
1247 PyObject *getValuesAsTuple() const
1249 const double *vals(self->begin());
1250 std::size_t nbOfComp(self->getNumberOfComponents());
1251 mcIdType nbOfTuples(self->getNumberOfTuples());
1252 return convertDblArrToPyListOfTuple<double>(vals,nbOfComp,nbOfTuples);
1255 static PyObject *ComputeIntegralOfSeg2IntoTri3(PyObject *seg2, PyObject *tri3)
1257 const char msg[]="Python wrap of DataArrayDouble::ComputeIntegralOfSeg2IntoTri3 : ";
1259 DataArrayDouble *a,*a2;
1260 DataArrayDoubleTuple *aa,*aa2;
1261 std::vector<double> bb,bb2;
1263 const double *seg2Ptr(convertObjToPossibleCpp5_Safe(seg2,sw,val,a,aa,bb,msg,2,2,true));
1264 const double *tri3Ptr(convertObjToPossibleCpp5_Safe(tri3,sw,val2,a2,aa2,bb2,msg,3,2,true));
1266 double res0[3],res1;
1267 DataArrayDouble::ComputeIntegralOfSeg2IntoTri3(seg2Ptr,tri3Ptr,res0,res1);
1268 PyObject *ret(PyTuple_New(2)),*ret0(PyTuple_New(3));
1269 PyTuple_SetItem(ret0,0,PyFloat_FromDouble(res0[0]));
1270 PyTuple_SetItem(ret0,1,PyFloat_FromDouble(res0[1]));
1271 PyTuple_SetItem(ret0,2,PyFloat_FromDouble(res0[2]));
1272 PyTuple_SetItem(ret,0,ret0);
1273 PyTuple_SetItem(ret,1,PyFloat_FromDouble(res1));
1277 DataArrayDouble *symmetry3DPlane(PyObject *point, PyObject *normalVector)
1279 const char msg[]="Python wrap of DataArrayDouble::symmetry3DPlane : ";
1281 DataArrayDouble *a,*a2;
1282 DataArrayDoubleTuple *aa,*aa2;
1283 std::vector<double> bb,bb2;
1285 const double *centerPtr(convertObjToPossibleCpp5_Safe(point,sw,val,a,aa,bb,msg,1,3,true));
1286 const double *vectorPtr(convertObjToPossibleCpp5_Safe(normalVector,sw,val2,a2,aa2,bb2,msg,1,3,true));
1287 MCAuto<DataArrayDouble> ret(self->symmetry3DPlane(centerPtr,vectorPtr));
1291 static PyObject *GiveBaseForPlane(PyObject *normalVector)
1293 const char msg[]="Python wrap of DataArrayDouble::GiveBaseForPlane : ";
1296 DataArrayDoubleTuple *aa;
1297 std::vector<double> bb,bb2;
1299 const double *vectorPtr(convertObjToPossibleCpp5_Safe(normalVector,sw,val,a,aa,bb,msg,1,3,true));
1301 DataArrayDouble::GiveBaseForPlane(vectorPtr,res);
1302 return convertDblArrToPyListOfTuple<double>(res,3,3);
1305 DataArrayDouble *fromCartToCylGiven(const DataArrayDouble *coords, PyObject *center, PyObject *vector) const
1307 const char msg[]="Python wrap of DataArrayDouble::fromCartToCylGiven : ";
1309 DataArrayDouble *a,*a2;
1310 DataArrayDoubleTuple *aa,*aa2;
1311 std::vector<double> bb,bb2;
1313 const double *centerPtr=convertObjToPossibleCpp5_Safe(center,sw,val,a,aa,bb,msg,1,3,true);
1314 const double *vectorPtr=convertObjToPossibleCpp5_Safe(vector,sw,val2,a2,aa2,bb2,msg,1,3,true);
1315 return self->fromCartToCylGiven(coords,centerPtr,vectorPtr);
1318 DataArrayDouble *renumber(PyObject *li)
1321 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
1322 if (!SWIG_IsOK(res1))
1325 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1326 if(size!=self->getNumberOfTuples())
1328 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1330 return self->renumber(tmp);
1334 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1336 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1337 da2->checkAllocated();
1338 mcIdType size=self->getNumberOfTuples();
1339 if(size!=self->getNumberOfTuples())
1341 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1343 return self->renumber(da2->getConstPointer());
1347 DataArrayDouble *renumberR(PyObject *li)
1350 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
1351 if (!SWIG_IsOK(res1))
1354 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1355 if(size!=self->getNumberOfTuples())
1357 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1359 return self->renumberR(tmp);
1363 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1365 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1366 da2->checkAllocated();
1367 mcIdType size=self->getNumberOfTuples();
1368 if(size!=self->getNumberOfTuples())
1370 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1372 return self->renumberR(da2->getConstPointer());
1376 DataArrayDouble *renumberAndReduce(PyObject *li, mcIdType newNbOfTuple)
1379 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
1380 if (!SWIG_IsOK(res1))
1383 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1384 if(size!=self->getNumberOfTuples())
1386 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1388 return self->renumberAndReduce(tmp,newNbOfTuple);
1392 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1394 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1395 da2->checkAllocated();
1396 mcIdType size=self->getNumberOfTuples();
1397 if(size!=self->getNumberOfTuples())
1399 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1401 return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
1405 PyObject *minimalDistanceTo(const DataArrayDouble *other) const
1407 mcIdType thisTupleId,otherTupleId;
1408 double r0=self->minimalDistanceTo(other,thisTupleId,otherTupleId);
1409 PyObject *ret=PyTuple_New(3);
1410 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r0));
1411 PyTuple_SetItem(ret,1,PyInt_FromLong(thisTupleId));
1412 PyTuple_SetItem(ret,2,PyInt_FromLong(otherTupleId));
1416 PyObject *getMaxValue() const
1419 double r1=self->getMaxValue(tmp);
1420 PyObject *ret=PyTuple_New(2);
1421 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1422 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1426 PyObject *getMaxAbsValue() const
1429 double r1=self->getMaxAbsValue(tmp);
1430 PyObject *ret=PyTuple_New(2);
1431 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1432 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1436 PyObject *getMaxValue2() const
1438 DataArrayIdType *tmp;
1439 double r1=self->getMaxValue2(tmp);
1440 PyObject *ret=PyTuple_New(2);
1441 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1442 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1446 PyObject *getMinValue() const
1449 double r1=self->getMinValue(tmp);
1450 PyObject *ret=PyTuple_New(2);
1451 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1452 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1456 PyObject *getMinValue2() const
1458 DataArrayIdType *tmp;
1459 double r1=self->getMinValue2(tmp);
1460 PyObject *ret=PyTuple_New(2);
1461 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1462 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1466 PyObject *getMinMaxPerComponent() const
1468 std::size_t nbOfCompo(self->getNumberOfComponents());
1469 INTERP_KERNEL::AutoPtr<double> tmp(new double[2*nbOfCompo]);
1470 self->getMinMaxPerComponent(tmp);
1471 PyObject *ret=convertDblArrToPyListOfTuple<double>(tmp,2,ToIdType(nbOfCompo));
1475 PyObject *normMaxPerComponent() const
1477 std::size_t nbOfCompo(self->getNumberOfComponents());
1478 INTERP_KERNEL::AutoPtr<double> tmp(new double[nbOfCompo]);
1479 self->normMaxPerComponent(tmp);
1480 return convertDblArrToPyList<double>(tmp,ToIdType(nbOfCompo));
1483 PyObject *accumulate() const
1485 std::size_t sz=self->getNumberOfComponents();
1486 INTERP_KERNEL::AutoPtr<double> tmp=new double[sz];
1487 self->accumulate(tmp);
1488 return convertDblArrToPyList<double>(tmp,ToIdType(sz));
1491 DataArrayDouble *accumulatePerChunck(PyObject *indexArr) const
1493 mcIdType sw, sz,val;
1494 std::vector<mcIdType> val2;
1495 const mcIdType *bg=convertIntStarLikePyObjToCppIntStar(indexArr,sw,sz,val,val2);
1496 return self->accumulatePerChunck(bg,bg+sz);
1499 PyObject *findCommonTuples(double prec, mcIdType limitNodeId=-1) const
1501 DataArrayIdType *comm, *commIndex;
1502 self->findCommonTuples(prec,limitNodeId,comm,commIndex);
1503 PyObject *res = PyList_New(2);
1504 PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(comm),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1505 PyList_SetItem(res,1,SWIG_NewPointerObj(SWIG_as_voidptr(commIndex),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1509 PyObject *distanceToTuple(PyObject *tuple) const
1513 DataArrayDoubleTuple *aa;
1514 std::vector<double> bb;
1516 mcIdType tupleId=-1;
1517 std::size_t nbOfCompo=self->getNumberOfComponents();
1518 const double *pt=convertObjToPossibleCpp5_Safe(tuple,sw,val,a,aa,bb,"Python wrap of DataArrayDouble::distanceToTuple",1,(int)nbOfCompo,true);
1520 double ret0=self->distanceToTuple(pt,pt+nbOfCompo,tupleId);
1521 PyObject *ret=PyTuple_New(2);
1522 PyTuple_SetItem(ret,0,PyFloat_FromDouble(ret0));
1523 PyTuple_SetItem(ret,1,PyInt_FromLong(tupleId));
1527 void setSelectedComponents(const DataArrayDouble *a, PyObject *li)
1529 std::vector<std::size_t> tmp;
1530 convertPyToNewIntArr3(li,tmp);
1531 self->setSelectedComponents(a,tmp);
1534 PyObject *explodeComponents() const
1536 std::vector< MCAuto<DataArrayDouble> > retCpp(self->explodeComponents());
1537 std::size_t sz(retCpp.size());
1538 PyObject *res(PyList_New(sz));
1539 for(std::size_t i=0;i<sz;i++)
1540 PyList_SetItem(res,i,SWIG_NewPointerObj(SWIG_as_voidptr(retCpp[i].retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ));
1544 PyObject *getTuple(mcIdType tupleId)
1546 std::size_t sz=self->getNumberOfComponents();
1547 INTERP_KERNEL::AutoPtr<double> tmp=new double[sz];
1548 self->getTuple(tupleId,tmp);
1549 return convertDblArrToPyList<double>(tmp,ToIdType(sz));
1552 static DataArrayDouble *Aggregate(PyObject *li)
1554 std::vector<const DataArrayDouble *> tmp;
1555 convertFromPyObjVectorOfObj<const DataArrayDouble *>(li,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",tmp);
1556 return DataArrayDouble::Aggregate(tmp);
1559 static DataArrayDouble *Meld(PyObject *li)
1561 std::vector<const DataArrayDouble *> tmp;
1562 convertFromPyObjVectorOfObj<const DataArrayDouble *>(li,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",tmp);
1563 return DataArrayDouble::Meld(tmp);
1566 PyObject *computeTupleIdsNearTuples(PyObject *pt, double eps) const
1570 DataArrayDoubleTuple *aa;
1571 std::vector<double> bb;
1573 std::size_t nbComp=self->getNumberOfComponents();
1574 mcIdType nbTuples=-1;
1575 const char msg[]="Python wrap of DataArrayDouble::computeTupleIdsNearTuples : ";
1576 const double *pos=convertObjToPossibleCpp5_Safe2(pt,sw,val,a,aa,bb,msg,(int)nbComp,true,nbTuples);
1577 MCAuto<DataArrayDouble> inpu=DataArrayDouble::New(); inpu->useArray(pos,false,DeallocType::CPP_DEALLOC,nbTuples,nbComp);
1578 DataArrayIdType *c=0,*cI=0;
1579 self->computeTupleIdsNearTuples(inpu,eps,c,cI);
1580 PyObject *ret=PyTuple_New(2);
1581 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1582 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1586 PyObject *areIncludedInMe(const DataArrayDouble *other, double prec) const
1588 DataArrayIdType *ret1=0;
1589 bool ret0=self->areIncludedInMe(other,prec,ret1);
1590 PyObject *ret=PyTuple_New(2);
1591 PyObject *ret0Py=ret0?Py_True:Py_False;
1593 PyTuple_SetItem(ret,0,ret0Py);
1594 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1598 PyObject *__getitem__(PyObject *obj)
1600 return DataArrayT__getitem<double>(self,obj);
1603 DataArrayDouble *__setitem__(PyObject *obj, PyObject *value)
1605 return DataArrayT__setitem__<double>(self,obj,value);
1608 DataArrayDouble *__neg__() const
1610 return self->negate();
1613 PyObject *__add__(PyObject *obj)
1615 const char msg[]="Unexpected situation in DataArrayDouble.__add__ !";
1618 DataArrayDoubleTuple *aa;
1619 std::vector<double> bb;
1622 #ifndef WITHOUT_AUTOFIELD
1624 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1626 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1629 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1630 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___radd__Impl(other,tmp);
1632 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1635 throw INTERP_KERNEL::Exception(msg);
1639 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1644 MCAuto<DataArrayDouble> ret=self->deepCopy();
1645 ret->applyLin(1.,val);
1646 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1650 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1654 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1655 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1659 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1660 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1663 throw INTERP_KERNEL::Exception(msg);
1667 DataArrayDouble *__radd__(PyObject *obj)
1669 const char msg[]="Unexpected situation in __radd__ !";
1672 DataArrayDoubleTuple *aa;
1673 std::vector<double> bb;
1675 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1680 MCAuto<DataArrayDouble> ret=self->deepCopy();
1681 ret->applyLin(1.,val);
1686 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1687 return DataArrayDouble::Add(self,aaa);
1691 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1692 return DataArrayDouble::Add(self,aaa);
1695 throw INTERP_KERNEL::Exception(msg);
1699 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
1701 return DataArrayT_iadd<double>(trueSelf,obj,self);
1704 PyObject *__sub__(PyObject *obj)
1706 const char msg[]="Unexpected situation in __sub__ !";
1709 DataArrayDoubleTuple *aa;
1710 std::vector<double> bb;
1713 #ifndef WITHOUT_AUTOFIELD
1715 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1717 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1720 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1721 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rsub__Impl(other,tmp);
1723 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1726 throw INTERP_KERNEL::Exception(msg);
1730 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1735 MCAuto<DataArrayDouble> ret=self->deepCopy();
1736 ret->applyLin(1.,-val);
1737 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1741 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1745 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1746 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1750 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1751 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1754 throw INTERP_KERNEL::Exception(msg);
1758 DataArrayDouble *__rsub__(PyObject *obj)
1760 const char msg[]="Unexpected situation in __rsub__ !";
1763 DataArrayDoubleTuple *aa;
1764 std::vector<double> bb;
1766 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1771 MCAuto<DataArrayDouble> ret=self->deepCopy();
1772 ret->applyLin(-1.,val);
1777 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1778 return DataArrayDouble::Substract(aaa,self);
1782 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1783 return DataArrayDouble::Substract(aaa,self);
1786 throw INTERP_KERNEL::Exception(msg);
1790 PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
1792 return DataArrayT_isub<double>(trueSelf,obj,self);
1795 PyObject *__mul__(PyObject *obj)
1797 const char msg[]="Unexpected situation in __mul__ !";
1800 DataArrayDoubleTuple *aa;
1801 std::vector<double> bb;
1804 #ifndef WITHOUT_AUTOFIELD
1806 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1808 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1811 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1812 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rmul__Impl(other,tmp);
1814 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1817 throw INTERP_KERNEL::Exception(msg);
1821 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1826 MCAuto<DataArrayDouble> ret=self->deepCopy();
1827 ret->applyLin(val,0.);
1828 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1832 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1836 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1837 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1841 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1842 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1845 throw INTERP_KERNEL::Exception(msg);
1849 DataArrayDouble *__rmul__(PyObject *obj)
1851 return DataArrayFPT_rmul<double>(self,obj);
1854 PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
1856 return DataArrayT_imul<double>(trueSelf,obj,self);
1859 PyObject *__div__(PyObject *obj)
1861 const char msg[]="Unexpected situation in __div__ !";
1864 DataArrayDoubleTuple *aa;
1865 std::vector<double> bb;
1868 #ifndef WITHOUT_AUTOFIELD
1870 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1872 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1875 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1876 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rdiv__Impl(other,tmp);
1878 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1881 throw INTERP_KERNEL::Exception(msg);
1885 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1891 throw INTERP_KERNEL::Exception("DataArrayDouble::__div__ : trying to divide by zero !");
1892 MCAuto<DataArrayDouble> ret=self->deepCopy();
1893 ret->applyLin(1/val,0.);
1894 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1898 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1902 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1903 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1907 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1908 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1911 throw INTERP_KERNEL::Exception(msg);
1915 DataArrayDouble *__rdiv__(PyObject *obj)
1917 const char msg[]="Unexpected situation in __rdiv__ !";
1920 DataArrayDoubleTuple *aa;
1921 std::vector<double> bb;
1923 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1928 MCAuto<DataArrayDouble> ret=self->deepCopy();
1934 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1935 return DataArrayDouble::Divide(aaa,self);
1939 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1940 return DataArrayDouble::Divide(aaa,self);
1943 throw INTERP_KERNEL::Exception(msg);
1947 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
1949 return DataArrayT_idiv<double>(trueSelf,obj,self);
1952 DataArrayDouble *__pow__(PyObject *obj)
1954 const char msg[]="Unexpected situation in __pow__ !";
1957 DataArrayDoubleTuple *aa;
1958 std::vector<double> bb;
1960 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1965 MCAuto<DataArrayDouble> ret=self->deepCopy();
1971 return DataArrayDouble::Pow(self,a);
1975 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1976 return DataArrayDouble::Pow(self,aaa);
1980 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1981 return DataArrayDouble::Pow(self,aaa);
1984 throw INTERP_KERNEL::Exception(msg);
1988 DataArrayDouble *__rpow__(PyObject *obj)
1990 const char msg[]="Unexpected situation in __rpow__ !";
1993 DataArrayDoubleTuple *aa;
1994 std::vector<double> bb;
1996 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
2001 MCAuto<DataArrayDouble> ret=self->deepCopy();
2002 ret->applyRPow(val);
2007 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
2008 return DataArrayDouble::Pow(aaa,self);
2012 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
2013 return DataArrayDouble::Pow(aaa,self);
2016 throw INTERP_KERNEL::Exception(msg);
2020 PyObject *___ipow___(PyObject *trueSelf, PyObject *obj)
2022 const char msg[]="Unexpected situation in __ipow__ !";
2025 DataArrayDoubleTuple *aa;
2026 std::vector<double> bb;
2028 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
2033 self->applyPow(val);
2034 Py_XINCREF(trueSelf);
2040 Py_XINCREF(trueSelf);
2045 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
2046 self->powEqual(aaa);
2047 Py_XINCREF(trueSelf);
2052 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
2053 self->powEqual(aaa);
2054 Py_XINCREF(trueSelf);
2058 throw INTERP_KERNEL::Exception(msg);
2062 PyObject *computeTupleIdsNearTuples(const DataArrayDouble *other, double eps)
2064 DataArrayIdType *c=0,*cI=0;
2066 self->computeTupleIdsNearTuples(other,eps,c,cI);
2067 PyObject *ret=PyTuple_New(2);
2068 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2069 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2073 PyObject *maxPerTupleWithCompoId() const
2075 DataArrayIdType *ret1=0;
2076 DataArrayDouble *ret0=self->maxPerTupleWithCompoId(ret1);
2077 PyObject *ret=PyTuple_New(2);
2078 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ));
2079 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2085 class DataArrayDoubleTuple;
2087 class DataArrayDoubleIterator
2090 DataArrayDoubleIterator(DataArrayDouble *da);
2091 ~DataArrayDoubleIterator();
2096 DataArrayDoubleTuple *ret=self->nextt();
2098 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayDoubleTuple,SWIG_POINTER_OWN|0);
2101 PyErr_SetString(PyExc_StopIteration,"No more data.");
2108 class DataArrayDoubleTuple
2111 std::size_t getNumberOfCompo() const;
2112 DataArrayDouble *buildDADouble(int nbOfTuples, int nbOfCompo) const;
2115 std::string __str__() const
2117 return self->repr();
2120 double __float__() const
2122 return self->doubleValue();
2125 DataArrayDouble *buildDADouble()
2127 return self->buildDADouble(1,self->getNumberOfCompo());
2130 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
2132 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2133 MEDCoupling_DataArrayDouble____iadd___(ret,0,obj);
2134 Py_XINCREF(trueSelf);
2138 PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
2140 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2141 MEDCoupling_DataArrayDouble____isub___(ret,0,obj);
2142 Py_XINCREF(trueSelf);
2146 PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
2148 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2149 MEDCoupling_DataArrayDouble____imul___(ret,0,obj);
2150 Py_XINCREF(trueSelf);
2154 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
2156 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2157 MEDCoupling_DataArrayDouble____idiv___(ret,0,obj);
2158 Py_XINCREF(trueSelf);
2164 return PyInt_FromLong(self->getNumberOfCompo());
2167 PyObject *__getitem__(PyObject *obj)
2169 const char msg2[]="DataArrayDoubleTuple::__getitem__ : Mismatch of slice values in 2nd parameter (components) !";
2172 std::vector<mcIdType> multiVal;
2173 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2174 MEDCoupling::DataArrayIdType *daIntTyypp=0;
2175 const double *pt=self->getConstPointer();
2176 mcIdType nbc=ToIdType(self->getNumberOfCompo());
2177 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbc,sw,singleVal,multiVal,slic,daIntTyypp);
2184 std::ostringstream oss;
2185 oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2186 PyErr_SetString(PyExc_StopIteration,oss.str().c_str());
2190 return PyFloat_FromDouble(pt[singleVal]);
2194 return PyFloat_FromDouble(pt[nbc+singleVal]);
2197 std::ostringstream oss;
2198 oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2199 throw INTERP_KERNEL::Exception(oss.str().c_str());
2205 PyObject *t=PyTuple_New(multiVal.size());
2206 for(std::size_t j=0;j<multiVal.size();j++)
2208 mcIdType cid=multiVal[j];
2211 std::ostringstream oss;
2212 oss << "Requesting for id #" << cid << " having only " << nbc << " components !";
2213 throw INTERP_KERNEL::Exception(oss.str().c_str());
2215 PyTuple_SetItem(t,j,PyFloat_FromDouble(pt[cid]));
2221 mcIdType sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2222 PyObject *t=PyTuple_New(sz);
2223 for(mcIdType j=0;j<sz;j++)
2224 PyTuple_SetItem(t,j,PyFloat_FromDouble(pt[slic.first+j*slic.second.second]));
2228 throw INTERP_KERNEL::Exception("DataArrayDoubleTuple::__getitem__ : unrecognized type entered !");
2232 DataArrayDoubleTuple *__setitem__(PyObject *obj, PyObject *value)
2234 const char msg[]="DataArrayDoubleTuple::__setitem__ : unrecognized type entered, int, slice, list<int>, tuple<int> !";
2235 const char msg2[]="DataArrayDoubleTuple::__setitem__ : Mismatch of slice values in 2nd parameter (components) !";
2238 std::vector<double> multiValV;
2239 MEDCoupling::DataArrayDoubleTuple *daIntTyyppV=0;
2240 mcIdType nbc=ToIdType(self->getNumberOfCompo());
2241 convertDoubleStarLikePyObjToCpp(value,sw1,singleValV,multiValV,daIntTyyppV);
2243 std::vector<mcIdType> multiVal;
2244 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2245 MEDCoupling::DataArrayIdType *daIntTyypp=0;
2246 double *pt=self->getPointer();
2247 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbc,sw2,singleVal,multiVal,slic,daIntTyypp);
2254 std::ostringstream oss;
2255 oss << "Requesting for setting id # " << singleVal << " having only " << nbc << " components !";
2256 throw INTERP_KERNEL::Exception(oss.str().c_str());
2262 pt[singleVal]=singleValV;
2267 if(multiValV.size()!=1)
2269 std::ostringstream oss;
2270 oss << "Requesting for setting id # " << singleVal << " with a list or tuple with size != 1 ! ";
2271 throw INTERP_KERNEL::Exception(oss.str().c_str());
2273 pt[singleVal]=multiValV[0];
2278 pt[singleVal]=daIntTyyppV->getConstPointer()[0];
2282 throw INTERP_KERNEL::Exception(msg);
2291 for(std::vector<mcIdType>::const_iterator it=multiVal.begin();it!=multiVal.end();it++)
2295 std::ostringstream oss;
2296 oss << "Requesting for setting id # " << *it << " having only " << nbc << " components !";
2297 throw INTERP_KERNEL::Exception(oss.str().c_str());
2305 if(multiVal.size()!=multiValV.size())
2307 std::ostringstream oss;
2308 oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << multiVal.size() << " !";
2309 throw INTERP_KERNEL::Exception(oss.str().c_str());
2311 for(std::size_t i=0;i<multiVal.size();i++)
2313 mcIdType pos=multiVal[i];
2316 std::ostringstream oss;
2317 oss << "Requesting for setting id # " << pos << " having only " << nbc << " components !";
2318 throw INTERP_KERNEL::Exception(oss.str().c_str());
2320 pt[multiVal[i]]=multiValV[i];
2326 const double *ptV=daIntTyyppV->getConstPointer();
2327 if(nbc>(mcIdType)daIntTyyppV->getNumberOfCompo())
2329 std::ostringstream oss;
2330 oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2331 throw INTERP_KERNEL::Exception(oss.str().c_str());
2333 std::copy(ptV,ptV+nbc,pt);
2337 throw INTERP_KERNEL::Exception(msg);
2342 mcIdType sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2347 for(mcIdType j=0;j<sz;j++)
2348 pt[slic.first+j*slic.second.second]=singleValV;
2353 if(sz!=(mcIdType)multiValV.size())
2355 std::ostringstream oss;
2356 oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << sz << " !";
2357 throw INTERP_KERNEL::Exception(oss.str().c_str());
2359 for(mcIdType j=0;j<sz;j++)
2360 pt[slic.first+j*slic.second.second]=multiValV[j];
2365 const double *ptV=daIntTyyppV->getConstPointer();
2366 if(sz>(mcIdType)daIntTyyppV->getNumberOfCompo())
2368 std::ostringstream oss;
2369 oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2370 throw INTERP_KERNEL::Exception(oss.str().c_str());
2372 for(mcIdType j=0;j<sz;j++)
2373 pt[slic.first+j*slic.second.second]=ptV[j];
2377 throw INTERP_KERNEL::Exception(msg);
2381 throw INTERP_KERNEL::Exception(msg);
2387 class DataArrayChar : public DataArray
2390 virtual DataArrayChar *buildEmptySpecializedDAChar() const;
2391 int getHashCode() const;
2393 void deepCopyFrom(const DataArrayChar& other);
2394 void reserve(std::size_t nbOfElems);
2395 void pushBackSilent(char val);
2396 char popBackSilent();
2398 void allocIfNecessary(int nbOfTuple, int nbOfCompo);
2399 bool isEqual(const DataArrayChar& other) const;
2400 bool isEqualWithoutConsideringStr(const DataArrayChar& other) const;
2402 void fillWithZero();
2403 void fillWithValue(char val);
2404 std::string repr() const;
2405 std::string reprZip() const;
2406 DataArrayInt *convertToIntArr() const;
2407 DataArrayChar *renumber(const mcIdType *old2New) const;
2408 DataArrayChar *renumberR(const mcIdType *new2Old) const;
2409 DataArrayChar *renumberAndReduce(const mcIdType *old2NewBg, mcIdType newNbOfTuple) const;
2410 bool isUniform(char val) const;
2411 void sort(bool asc=true);
2412 DataArrayChar *subArray(mcIdType tupleIdBg, mcIdType tupleIdEnd=-1) const;
2413 DataArrayChar *changeNbOfComponents(std::size_t newNbOfComp, char dftValue) const;
2414 void meldWith(const DataArrayChar *other);
2415 void setPartOfValuesAdv(const DataArrayChar *a, const DataArrayIdType *tuplesSelec);
2418 void setIJ(mcIdType tupleId, int compoId, char newVal);
2419 void setIJSilent(mcIdType tupleId, int compoId, char newVal);
2421 DataArrayIdType *findIdsEqual(char val) const;
2422 DataArrayIdType *findIdsNotEqual(char val) const;
2423 int findIdFirstEqualTuple(const std::vector<char>& tupl) const;
2424 bool presenceOfTuple(const std::vector<char>& tupl) const;
2425 char getMaxValue(mcIdType& tupleId) const;
2426 char getMaxValueInArray() const;
2427 char getMinValue(mcIdType& tupleId) const;
2428 char getMinValueInArray() const;
2429 DataArrayIdType *findIdsInRange(char vmin, char vmax) const;
2430 static DataArrayChar *Aggregate(const DataArrayChar *a1, const DataArrayChar *a2);
2431 static DataArrayChar *Meld(const DataArrayChar *a1, const DataArrayChar *a2);
2434 mcIdType __len__() const
2436 if(self->isAllocated())
2438 return self->getNumberOfTuples();
2442 throw INTERP_KERNEL::Exception("DataArrayChar::__len__ : Instance is NOT allocated !");
2446 PyObject *isEqualIfNotWhy(const DataArrayChar& other) const
2449 bool ret0=self->isEqualIfNotWhy(other,ret1);
2450 PyObject *ret=PyTuple_New(2);
2451 PyObject *ret0Py=ret0?Py_True:Py_False;
2453 PyTuple_SetItem(ret,0,ret0Py);
2454 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
2458 DataArrayChar *renumber(PyObject *li)
2461 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
2462 if (!SWIG_IsOK(res1))
2465 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2466 if(size!=self->getNumberOfTuples())
2468 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2470 return self->renumber(tmp);
2474 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2476 throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2477 da2->checkAllocated();
2478 mcIdType size=self->getNumberOfTuples();
2479 if(size!=self->getNumberOfTuples())
2481 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2483 return self->renumber(da2->getConstPointer());
2487 DataArrayChar *renumberR(PyObject *li)
2490 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
2491 if (!SWIG_IsOK(res1))
2494 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2495 if(size!=self->getNumberOfTuples())
2497 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2499 return self->renumberR(tmp);
2503 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2505 throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2506 da2->checkAllocated();
2507 mcIdType size=self->getNumberOfTuples();
2508 if(size!=self->getNumberOfTuples())
2510 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2512 return self->renumberR(da2->getConstPointer());
2516 DataArrayChar *renumberAndReduce(PyObject *li, mcIdType newNbOfTuple)
2519 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
2520 if (!SWIG_IsOK(res1))
2523 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2524 if(size!=self->getNumberOfTuples())
2526 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2528 return self->renumberAndReduce(tmp,newNbOfTuple);
2532 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2534 throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2535 da2->checkAllocated();
2536 mcIdType size=self->getNumberOfTuples();
2537 if(size!=self->getNumberOfTuples())
2539 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2541 return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
2545 static DataArrayChar *Aggregate(PyObject *dachs)
2547 std::vector<const MEDCoupling::DataArrayChar *> tmp;
2548 convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayChar *>(dachs,SWIGTYPE_p_MEDCoupling__DataArrayChar,"DataArrayChar",tmp);
2549 return DataArrayChar::Aggregate(tmp);
2552 static DataArrayChar *Meld(PyObject *dachs)
2554 std::vector<const MEDCoupling::DataArrayChar *> tmp;
2555 convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayChar *>(dachs,SWIGTYPE_p_MEDCoupling__DataArrayChar,"DataArrayChar",tmp);
2556 return DataArrayChar::Meld(tmp);
2561 class DataArrayByteIterator;
2563 class DataArrayByte : public DataArrayChar
2566 static DataArrayByte *New();
2567 DataArrayByteIterator *iterator();
2568 DataArrayByte *performCopyOrIncrRef(bool deepCopy) const;
2569 char byteValue() const;
2574 return DataArrayByte::New();
2577 static DataArrayByte *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
2579 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) !";
2580 if(PyList_Check(elt0) || PyTuple_Check(elt0))
2584 if(PyInt_Check(nbOfTuples))
2586 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
2588 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive set of allocated memory !");
2591 if(PyInt_Check(nbOfComp))
2592 {//DataArrayByte.New([1,3,4,5],2,2)
2593 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
2595 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !");
2596 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2597 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
2598 ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2602 throw INTERP_KERNEL::Exception(msg);
2605 {//DataArrayByte.New([1,3,4],3)
2606 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2608 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
2609 ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2614 throw INTERP_KERNEL::Exception(msg);
2617 {// DataArrayByte.New([1,3,4])
2618 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2619 mcIdType tmpp1=-1,tmpp2=-1;
2620 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
2621 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2625 else if(PyInt_Check(elt0))
2627 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(elt0));
2629 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive set of allocated memory !");
2634 if(PyInt_Check(nbOfTuples))
2635 {//DataArrayByte.New(5,2)
2636 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfTuples));
2638 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !");
2639 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2640 ret->alloc(nbOfTuples1,nbOfCompo);
2644 throw INTERP_KERNEL::Exception(msg);
2647 throw INTERP_KERNEL::Exception(msg);
2650 {//DataArrayByte.New(5)
2651 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2652 ret->alloc(nbOfTuples1,1);
2657 else if(PyArray_Check(elt0) && nbOfTuples==NULL && nbOfComp==NULL)
2658 {//DataArrayDouble.New(numpyArray)
2659 return BuildNewInstance<DataArrayByte,char>(elt0,NPY_INT8,&PyCallBackDataArrayChar_RefType,"INT8");
2663 throw INTERP_KERNEL::Exception(msg);
2666 DataArrayByte(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
2668 return MEDCoupling_DataArrayByte_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
2671 std::string __repr__() const
2673 std::ostringstream oss;
2674 self->reprQuickOverview(oss);
2680 return (int) self->byteValue();
2683 DataArrayByteIterator *__iter__()
2685 return self->iterator();
2688 mcIdType getIJ(mcIdType tupleId, mcIdType compoId) const
2690 return (mcIdType)self->getIJ(tupleId,compoId);
2693 mcIdType getIJSafe(mcIdType tupleId, mcIdType compoId) const
2695 return (mcIdType)self->getIJSafe(tupleId,compoId);
2698 std::string __str__() const
2700 return self->repr();
2703 PyObject *toStrList() const
2705 const char *vals=self->getConstPointer();
2706 std::size_t nbOfComp=self->getNumberOfComponents();
2707 mcIdType nbOfTuples=self->getNumberOfTuples();
2708 return convertCharArrToPyListOfTuple(vals,(int)nbOfComp,nbOfTuples);
2711 bool presenceOfTuple(PyObject *tupl) const
2713 mcIdType sz=-1,sw=-1;
2714 mcIdType ival=-1; std::vector<mcIdType> ivval;
2715 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(tupl,sw,sz,ival,ivval);
2716 std::vector<char> vals(sz);
2717 std::copy(pt,pt+sz,vals.begin());
2718 return self->presenceOfTuple(vals);
2721 bool presenceOfValue(PyObject *vals) const
2723 mcIdType sz=-1,sw=-1;
2724 mcIdType ival=-1; std::vector<mcIdType> ivval;
2725 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(vals,sw,sz,ival,ivval);
2726 std::vector<char> vals2(sz);
2727 std::copy(pt,pt+sz,vals2.begin());
2728 return self->presenceOfValue(vals2);
2731 mcIdType findIdFirstEqual(PyObject *vals) const
2733 mcIdType sz=-1,sw=-1;
2734 mcIdType ival=-1; std::vector<mcIdType> ivval;
2735 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(vals,sw,sz,ival,ivval);
2736 std::vector<char> vals2(sz);
2737 std::copy(pt,pt+sz,vals2.begin());
2738 return self->findIdFirstEqual(vals2);
2741 mcIdType findIdFirstEqualTuple(PyObject *tupl) const
2743 mcIdType sz=-1,sw=-1;
2744 mcIdType ival=-1; std::vector<mcIdType> ivval;
2745 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(tupl,sw,sz,ival,ivval);
2746 std::vector<char> vals(sz);
2747 std::copy(pt,pt+sz,vals.begin());
2748 return self->findIdFirstEqualTuple(vals);
2751 mcIdType findIdSequence(PyObject *strOrListOfInt) const
2753 mcIdType sz=-1,sw=-1;
2754 mcIdType ival=-1; std::vector<mcIdType> ivval;
2755 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(strOrListOfInt,sw,sz,ival,ivval);
2756 std::vector<char> vals(sz);
2757 std::copy(pt,pt+sz,vals.begin());
2758 return self->findIdSequence(vals);
2761 PyObject *getTuple(mcIdType tupleId)
2763 std::size_t sz=self->getNumberOfComponents();
2764 INTERP_KERNEL::AutoPtr<char> tmp=new char[sz];
2765 self->getTuple(tupleId,tmp);
2766 PyObject *ret=PyTuple_New(sz);
2767 for(std::size_t i=0;i<sz;i++) PyTuple_SetItem(ret,i,PyInt_FromLong((mcIdType)tmp[i]));
2771 PyObject *getMaxValue() const
2774 mcIdType r1=(mcIdType)self->getMaxValue(tmp);
2775 PyObject *ret=PyTuple_New(2);
2776 PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
2777 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
2781 PyObject *getMinValue() const
2784 mcIdType r1=(mcIdType)self->getMinValue(tmp);
2785 PyObject *ret=PyTuple_New(2);
2786 PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
2787 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
2791 mcIdType index(PyObject *obj) const
2793 std::size_t nbOfCompo=self->getNumberOfComponents();
2798 if(PyInt_Check(obj))
2800 char val=(char)PyInt_AS_LONG(obj);
2801 return self->findIdFirstEqual(val);
2804 throw INTERP_KERNEL::Exception("DataArrayByte::index : 'this' contains one component and trying to find an element which is not an integer !");
2807 return MEDCoupling_DataArrayByte_findIdFirstEqualTuple(self,obj);
2811 bool __contains__(PyObject *obj) const
2813 std::size_t nbOfCompo=self->getNumberOfComponents();
2820 if(PyInt_Check(obj))
2822 char val=(char)PyInt_AS_LONG(obj);
2823 return self->presenceOfValue(val);
2826 throw INTERP_KERNEL::Exception("DataArrayByte::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
2829 return MEDCoupling_DataArrayByte_presenceOfTuple(self,obj);
2834 PyObject *toNumPyArray() // not const. It is not a bug !
2836 return ToNumPyArray<DataArrayByte,char>(self,NPY_INT8,"DataArrayByte");
2840 DataArrayByte *__setitem__(PyObject *obj, PyObject *value)
2842 self->checkAllocated();
2843 const char msg[]="Unexpected situation in __setitem__ !";
2844 mcIdType nbOfTuples(self->getNumberOfTuples());
2845 int nbOfComponents((int)self->getNumberOfComponents());
2848 std::vector<int> v1;
2849 DataArrayIdType *d1=0;
2850 DataArrayIntTuple *dd1=0;
2851 convertIntStarLikePyObjToCpp(value,sw1,int1,v1,d1,dd1);
2853 std::vector<mcIdType> vt1,vc1;
2854 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > pt1,pc1;
2855 DataArrayIdType *dt1=0,*dc1=0;
2856 convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw2,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1);
2857 MCAuto<DataArrayIdType> tmp;
2858 char i1 = (char)int1;
2866 self->setPartOfValuesSimple1(i1,it1,it1+1,1,0,nbOfComponents,1);
2869 throw INTERP_KERNEL::Exception(msg);
2878 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1);
2881 throw INTERP_KERNEL::Exception(msg);
2890 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1);
2893 throw INTERP_KERNEL::Exception(msg);
2902 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1);
2905 throw INTERP_KERNEL::Exception(msg);
2914 self->setPartOfValuesSimple1(i1,it1,it1+1,1,ic1,ic1+1,1);
2917 throw INTERP_KERNEL::Exception(msg);
2926 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1);
2929 throw INTERP_KERNEL::Exception(msg);
2938 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1);
2941 throw INTERP_KERNEL::Exception(msg);
2950 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1);
2953 throw INTERP_KERNEL::Exception(msg);
2962 self->setPartOfValuesSimple2(i1,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size());
2965 throw INTERP_KERNEL::Exception(msg);
2974 self->setPartOfValuesSimple2(i1,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size());
2977 throw INTERP_KERNEL::Exception(msg);
2986 self->setPartOfValuesSimple4(i1,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size());
2989 throw INTERP_KERNEL::Exception(msg);
2998 self->setPartOfValuesSimple2(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size());
3001 throw INTERP_KERNEL::Exception(msg);
3010 self->setPartOfValuesSimple1(i1,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second);
3013 throw INTERP_KERNEL::Exception(msg);
3022 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second);
3025 throw INTERP_KERNEL::Exception(msg);
3034 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second);
3037 throw INTERP_KERNEL::Exception(msg);
3046 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second);
3049 throw INTERP_KERNEL::Exception(msg);
3054 throw INTERP_KERNEL::Exception(msg);
3061 class DataArrayByteTuple;
3063 class DataArrayByteIterator
3066 DataArrayByteIterator(DataArrayByte *da);
3067 ~DataArrayByteIterator();
3070 class DataArrayByteTuple
3073 std::string repr() const;
3074 DataArrayByte *buildDAByte(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
3077 std::string __str__() const
3079 return self->repr();
3082 char __int__() const
3084 return self->byteValue();
3087 DataArrayByte *buildDAByte()
3089 return self->buildDAByte(1,self->getNumberOfCompo());
3094 class DataArrayAsciiCharIterator;
3096 class DataArrayAsciiChar : public DataArrayChar
3099 static DataArrayAsciiChar *New();
3100 DataArrayAsciiCharIterator *iterator();
3101 DataArrayAsciiChar *performCopyOrIncrRef(bool deepCopy) const;
3102 char asciiCharValue() const;
3105 DataArrayAsciiChar()
3107 return DataArrayAsciiChar::New();
3110 static DataArrayAsciiChar *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
3112 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) !";
3113 if(PyList_Check(elt0) || PyTuple_Check(elt0))
3117 if(PyInt_Check(nbOfTuples))
3119 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
3121 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive set of allocated memory !");
3124 if(PyInt_Check(nbOfComp))
3125 {//DataArrayAsciiChar.New([1,3,4,5],2,2)
3126 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
3128 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !");
3129 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3130 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
3131 ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3135 throw INTERP_KERNEL::Exception(msg);
3138 {//DataArrayAsciiChar.New([1,3,4],3)
3139 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3141 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
3142 ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3146 else if(PyString_Check(nbOfTuples))
3148 if(PyString_Size(nbOfTuples)!=1)
3149 throw INTERP_KERNEL::Exception(msg);
3150 //DataArrayAsciiChar.New(["abc","de","fghi"],"t")
3151 std::vector<std::string> tmp;
3152 if(fillStringVector(elt0,tmp))
3153 return DataArrayAsciiChar::New(tmp,PyString_AsString(nbOfTuples)[0]);
3155 throw INTERP_KERNEL::Exception(msg);
3157 %#if PY_VERSION_HEX >= 0x03000000
3158 else if(PyUnicode_Check(nbOfTuples))
3160 if(PyUnicode_GET_LENGTH(nbOfTuples)!=1)
3161 throw INTERP_KERNEL::Exception(msg);
3162 //DataArrayAsciiChar.New(["abc","de","fghi"],"t")
3163 std::vector<std::string> tmp;
3164 if(fillStringVector(elt0,tmp))
3165 return DataArrayAsciiChar::New(tmp,PyUnicode_AsUTF8(nbOfTuples)[0]);
3167 throw INTERP_KERNEL::Exception(msg);
3171 throw INTERP_KERNEL::Exception(msg);
3175 std::vector<std::string> tmmp;
3176 if(fillStringVector(elt0,tmmp))
3177 //DataArrayAsciiChar.New(["abc","de","fghi"])
3178 return DataArrayAsciiChar::New(tmmp,' ');
3181 // DataArrayAsciiChar.New([1,3,4])
3182 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3183 mcIdType tmpp1=-1,tmpp2=-1;
3184 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
3185 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3190 else if(PyInt_Check(elt0))
3192 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(elt0));
3194 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive set of allocated memory !");
3199 if(PyInt_Check(nbOfTuples))
3200 {//DataArrayAsciiChar.New(5,2)
3201 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfTuples));
3203 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !");
3204 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3205 ret->alloc(nbOfTuples1,nbOfCompo);
3209 throw INTERP_KERNEL::Exception(msg);
3212 throw INTERP_KERNEL::Exception(msg);
3215 {//DataArrayAsciiChar.New(5)
3216 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3217 ret->alloc(nbOfTuples1,1);
3222 throw INTERP_KERNEL::Exception(msg);
3225 DataArrayAsciiChar(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
3227 return MEDCoupling_DataArrayAsciiChar_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
3230 std::string __repr__() const
3232 std::ostringstream oss;
3233 self->reprQuickOverview(oss);
3237 DataArrayAsciiCharIterator *__iter__()
3239 return self->iterator();
3242 std::string getIJ(mcIdType tupleId, mcIdType compoId) const
3244 char tmp[2]; tmp[1]='\0';
3245 tmp[0]=self->getIJ(tupleId,compoId);
3246 return std::string(tmp);
3249 std::string getIJSafe(mcIdType tupleId, mcIdType compoId) const
3251 char tmp[2]; tmp[1]='\0';
3252 tmp[0]=self->getIJSafe(tupleId,compoId);
3253 return std::string(tmp);
3256 std::string __str__() const
3258 return self->repr();
3261 PyObject *toStrList() const
3263 const char *vals=self->getConstPointer();
3264 std::size_t nbOfComp=self->getNumberOfComponents();
3265 mcIdType nbOfTuples=self->getNumberOfTuples();
3266 return convertCharArrToPyListOfTuple(vals,(int)nbOfComp,nbOfTuples);
3269 bool presenceOfTuple(PyObject *tupl) const
3271 if(PyString_Check(tupl))
3273 Py_ssize_t sz=PyString_Size(tupl);
3274 std::vector<char> vals(sz);
3275 std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin());
3276 return self->presenceOfTuple(vals);
3278 %#if PY_VERSION_HEX >= 0x03000000
3279 else if(PyUnicode_Check(tupl))
3281 Py_ssize_t sz=PyUnicode_GET_LENGTH(tupl);
3282 std::vector<char> vals(sz);
3283 std::copy(PyUnicode_AsUTF8(tupl),PyUnicode_AsUTF8(tupl)+sz,vals.begin());
3284 return self->presenceOfTuple(vals);
3288 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfTuple : only strings in input supported !");
3291 bool presenceOfValue(PyObject *vals) const
3293 if(PyString_Check(vals))
3295 Py_ssize_t sz=PyString_Size(vals);
3296 std::vector<char> vals2(sz);
3297 std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin());
3298 return self->presenceOfValue(vals2);
3300 %#if PY_VERSION_HEX >= 0x03000000
3301 if(PyUnicode_Check(vals))
3303 Py_ssize_t sz=PyUnicode_GET_LENGTH(vals);
3304 std::vector<char> vals2(sz);
3305 std::copy(PyUnicode_AsUTF8(vals),PyUnicode_AsUTF8(vals)+sz,vals2.begin());
3306 return self->presenceOfValue(vals2);
3310 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfValue : only strings in input supported !");
3313 mcIdType findIdFirstEqual(PyObject *vals) const
3315 if(PyString_Check(vals))
3317 Py_ssize_t sz=PyString_Size(vals);
3318 std::vector<char> vals2(sz);
3319 std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin());
3320 return self->findIdFirstEqual(vals2);
3322 %#if PY_VERSION_HEX >= 0x03000000
3323 if(PyUnicode_Check(vals))
3325 Py_ssize_t sz=PyUnicode_GET_LENGTH(vals);
3326 std::vector<char> vals2(sz);
3327 std::copy(PyUnicode_AsUTF8(vals),PyUnicode_AsUTF8(vals)+sz,vals2.begin());
3328 return self->findIdFirstEqual(vals2);
3332 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::findIdFirstEqual : only strings in input supported !");
3335 mcIdType findIdFirstEqualTuple(PyObject *tupl) const
3337 if(PyString_Check(tupl))
3339 Py_ssize_t sz=PyString_Size(tupl);
3340 std::vector<char> vals(sz);
3341 std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin());
3342 return self->findIdFirstEqualTuple(vals);
3344 %#if PY_VERSION_HEX >= 0x03000000
3345 if(PyUnicode_Check(tupl))
3347 Py_ssize_t sz=PyUnicode_GET_LENGTH(tupl);
3348 std::vector<char> vals(sz);
3349 std::copy(PyUnicode_AsUTF8(tupl),PyUnicode_AsUTF8(tupl)+sz,vals.begin());
3350 return self->findIdFirstEqualTuple(vals);
3354 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::findIdFirstEqualTuple : only strings in input supported !");
3357 mcIdType findIdSequence(PyObject *strOrListOfInt) const
3359 if(PyString_Check(strOrListOfInt))
3361 Py_ssize_t sz=PyString_Size(strOrListOfInt);
3362 std::vector<char> vals(sz);
3363 std::copy(PyString_AsString(strOrListOfInt),PyString_AsString(strOrListOfInt)+sz,vals.begin());
3364 return self->findIdSequence(vals);
3366 %#if PY_VERSION_HEX >= 0x03000000
3367 else if(PyUnicode_Check(strOrListOfInt))
3369 Py_ssize_t sz=PyUnicode_GET_LENGTH(strOrListOfInt);
3370 std::vector<char> vals(sz);
3371 std::copy(PyUnicode_AsUTF8(strOrListOfInt),PyUnicode_AsUTF8(strOrListOfInt)+sz,vals.begin());
3372 return self->findIdSequence(vals);
3376 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::search : only strings in input supported !");
3379 PyObject *getTuple(mcIdType tupleId) const
3381 std::size_t sz=self->getNumberOfComponents();
3382 INTERP_KERNEL::AutoPtr<char> tmp=new char[sz+1]; tmp[sz]='\0';
3383 self->getTuple(tupleId,tmp);
3384 return PyString_FromString(tmp);
3387 PyObject *getMaxValue() const
3390 char tmp2[2]; tmp2[1]='\0';
3391 tmp2[0]=self->getMaxValue(tmp);
3392 PyObject *ret=PyTuple_New(2);
3393 PyTuple_SetItem(ret,0,PyString_FromString(tmp2));
3394 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
3398 PyObject *getMinValue() const
3401 char tmp2[2]; tmp2[1]='\0';
3402 tmp2[0]=self->getMinValue(tmp);
3403 PyObject *ret=PyTuple_New(2);
3404 PyTuple_SetItem(ret,0,PyString_FromString(tmp2));
3405 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
3409 mcIdType index(PyObject *obj) const
3411 std::size_t nbOfCompo=self->getNumberOfComponents();
3416 if(PyString_Check(obj))
3418 Py_ssize_t sz=PyString_Size(obj);
3419 char *pt=PyString_AsString(obj);
3421 return self->findIdFirstEqual(pt[0]);
3423 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find a string with size different from 1 !");
3425 %#if PY_VERSION_HEX >= 0x03000000
3426 if(PyUnicode_Check(obj))
3429 const char *pt=PyUnicode_AsUTF8AndSize(obj, &sz);
3431 return self->findIdFirstEqual(pt[0]);
3433 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find a string with size different from 1 !");
3437 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find an element which is not an integer !");
3440 return MEDCoupling_DataArrayAsciiChar_findIdFirstEqualTuple(self,obj);
3444 bool __contains__(PyObject *obj) const
3446 std::size_t nbOfCompo=self->getNumberOfComponents();
3453 if(PyString_Check(obj))
3455 Py_ssize_t sz=PyString_Size(obj);
3456 char *pt=PyString_AsString(obj);
3458 return self->presenceOfValue(pt[0]);
3460 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find a string with size different from 1 !");
3462 %#if PY_VERSION_HEX >= 0x03000000
3463 if(PyUnicode_Check(obj))
3466 const char *pt=PyUnicode_AsUTF8AndSize(obj, &sz);
3468 return self->presenceOfValue(pt[0]);
3470 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find a string with size different from 1 !");
3474 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
3477 return MEDCoupling_DataArrayAsciiChar_presenceOfTuple(self,obj);
3481 PyObject *__getitem__(PyObject *obj) const
3483 mcIdType sw,iTypppArr;
3484 std::vector<mcIdType> stdvecTyyppArr;
3485 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > sTyyppArr;
3486 MEDCoupling::DataArrayIdType *daIntTyypp=0;
3487 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,self->getNumberOfTuples(),sw,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp);
3491 return MEDCoupling_DataArrayAsciiChar_getTuple(self,iTypppArr);
3493 return convertDataArrayChar(self->selectByTupleIdSafe(&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size()), SWIG_POINTER_OWN | 0 );
3495 return convertDataArrayChar(self->selectByTupleIdSafeSlice(sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second), SWIG_POINTER_OWN | 0 );
3497 return convertDataArrayChar(self->selectByTupleIdSafe(daIntTyypp->begin(),daIntTyypp->end()), SWIG_POINTER_OWN | 0 );
3499 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__getitem__ : supporting int, list of int, tuple of int, DataArrayIdType and slice in input !");
3503 DataArrayAsciiChar *__setitem__(PyObject *obj, PyObject *value)
3505 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.";
3506 mcIdType sw1,iTypppArr;
3507 std::vector<mcIdType> stdvecTyyppArr;
3508 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > sTyyppArr;
3509 MEDCoupling::DataArrayIdType *daIntTyypp=0;
3510 mcIdType nbOfCompo=ToIdType(self->getNumberOfComponents());
3511 mcIdType nbOfTuples=self->getNumberOfTuples();
3512 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbOfTuples,sw1,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp);
3514 char vc; std::string sc; std::vector<std::string> vsc; DataArrayChar *dacc=0;
3515 convertObjToPossibleCpp6(value,sw2,vc,sc,vsc,dacc);
3524 self->setPartOfValuesSimple3(vc,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1);
3530 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3531 self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3534 //value vector<string>
3537 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3538 self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3541 //value DataArrayChar
3544 self->setPartOfValues3(dacc,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3548 throw INTERP_KERNEL::Exception(msg);
3552 {//obj list-tuple[int]
3558 self->setPartOfValuesSimple3(vc,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1);
3564 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3565 self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3568 //value vector<string>
3571 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3572 self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3575 //value DataArrayChar
3578 self->setPartOfValues3(dacc,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3582 throw INTERP_KERNEL::Exception(msg);
3593 self->setPartOfValuesSimple1(vc,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1);
3599 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3600 self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3603 //value vector<string>
3606 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3607 self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3610 //value DataArrayChar
3613 self->setPartOfValues1(dacc,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3617 throw INTERP_KERNEL::Exception(msg);
3628 self->setPartOfValuesSimple3(vc,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1);
3634 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3635 self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3638 //value vector<string>
3641 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3642 self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3645 //value DataArrayChar
3648 self->setPartOfValues3(dacc,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3652 throw INTERP_KERNEL::Exception(msg);
3657 throw INTERP_KERNEL::Exception(msg);
3663 class DataArrayAsciiCharTuple;
3665 class DataArrayAsciiCharIterator
3668 DataArrayAsciiCharIterator(DataArrayAsciiChar *da);
3669 ~DataArrayAsciiCharIterator();
3674 DataArrayAsciiCharTuple *ret=self->nextt();
3676 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayAsciiCharTuple,SWIG_POINTER_OWN | 0);
3679 PyErr_SetString(PyExc_StopIteration,"No more data.");
3686 class DataArrayAsciiCharTuple
3689 std::size_t getNumberOfCompo() const;
3690 DataArrayAsciiChar *buildDAAsciiChar(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
3693 std::string __str__() const
3695 return self->repr();
3698 DataArrayAsciiChar *buildDAAsciiChar()
3700 return self->buildDAAsciiChar(1,self->getNumberOfCompo());
3709 MEDCoupling::DataArrayByte *FromPyIntPtrToDataArrayByte(mcPyPtrType intPtr)
3711 MEDCoupling::DataArrayByte *ret(reinterpret_cast<MEDCoupling::DataArrayByte *>(intPtr));
3716 %include "DataArrayInt.i"
3720 def MEDCouplingStdReduceFunct(cls,params):
3722 ret=object.__new__(cls)
3727 def MEDCouplingDataArrayDoubleReduce(self):
3728 if not MEDCouplingHasNumPyBindings():
3729 raise InterpKernelException("PyWrap of DataArrayDouble.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3730 return MEDCouplingStdReduceFunct,(DataArrayDouble,((self.toNumPyArray(),),(self.__getstate__()),))
3732 def MEDCouplingDataArrayInt32Reduce(self):
3733 if not MEDCouplingHasNumPyBindings():
3734 raise InterpKernelException("PyWrap of DataArrayIdType.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3735 return MEDCouplingStdReduceFunct,(DataArrayInt32,((self.toNumPyArray(),),(self.__getstate__()),))
3737 def MEDCouplingDataArrayInt64Reduce(self):
3738 if not MEDCouplingHasNumPyBindings():
3739 raise InterpKernelException("PyWrap of DataArrayIdType.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3740 return MEDCouplingStdReduceFunct,(DataArrayInt64,((self.toNumPyArray(),),(self.__getstate__()),))
3742 def MEDCouplingDataArrayByteReduce(self):
3743 if not MEDCouplingHasNumPyBindings():
3744 raise InterpKernelException("PyWrap of DataArrayByte.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3745 return MEDCouplingStdReduceFunct,(DataArrayByte,((self.toNumPyArray(),),(self.__getstate__()),))
3747 def MEDCouplingDataArrayFloatReduce(self):
3748 if not MEDCouplingHasNumPyBindings():
3749 raise InterpKernelException("PyWrap of DataArrayFloat.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3750 return MEDCouplingStdReduceFunct,(DataArrayFloat,((self.toNumPyArray(),),(self.__getstate__()),))
3752 if MEDCouplingUse64BitIDs():
3753 DataArrayInt=DataArrayInt64
3755 DataArrayInt=DataArrayInt32