1 // Copyright (C) 2007-2022 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::minPerTuple;
292 %newobject MEDCoupling::DataArrayDouble::sumPerTuple;
293 %newobject MEDCoupling::DataArrayDouble::computeBBoxPerTuple;
294 %newobject MEDCoupling::DataArrayDouble::buildEuclidianDistanceDenseMatrix;
295 %newobject MEDCoupling::DataArrayDouble::buildEuclidianDistanceDenseMatrixWith;
296 %newobject MEDCoupling::DataArrayDouble::renumber;
297 %newobject MEDCoupling::DataArrayDouble::renumberR;
298 %newobject MEDCoupling::DataArrayDouble::renumberAndReduce;
299 %newobject MEDCoupling::DataArrayDouble::fromNoInterlace;
300 %newobject MEDCoupling::DataArrayDouble::toNoInterlace;
301 %newobject MEDCoupling::DataArrayDouble::fromPolarToCart;
302 %newobject MEDCoupling::DataArrayDouble::fromCylToCart;
303 %newobject MEDCoupling::DataArrayDouble::fromSpherToCart;
304 %newobject MEDCoupling::DataArrayDouble::fromCartToPolar;
305 %newobject MEDCoupling::DataArrayDouble::fromCartToCyl;
306 %newobject MEDCoupling::DataArrayDouble::fromCartToSpher;
307 %newobject MEDCoupling::DataArrayDouble::fromCartToCylGiven;
308 %newobject MEDCoupling::DataArrayDouble::cartesianize;
309 %newobject MEDCoupling::DataArrayDouble::getDifferentValues;
310 %newobject MEDCoupling::DataArrayDouble::findClosestTupleId;
311 %newobject MEDCoupling::DataArrayDouble::computeNbOfInteractionsWith;
312 %newobject MEDCoupling::DataArrayDouble::duplicateEachTupleNTimes;
313 %newobject MEDCoupling::DataArrayDouble::__neg__;
314 %newobject MEDCoupling::DataArrayDouble::__radd__;
315 %newobject MEDCoupling::DataArrayDouble::__rsub__;
316 %newobject MEDCoupling::DataArrayDouble::__rmul__;
317 %newobject MEDCoupling::DataArrayDouble::__rdiv__;
318 %newobject MEDCoupling::DataArrayDouble::__pow__;
319 %newobject MEDCoupling::DataArrayDouble::__rpow__;
320 %newobject MEDCoupling::DataArrayDoubleTuple::buildDADouble;
322 %newobject MEDCoupling::PartDefinition::New;
323 %newobject MEDCoupling::PartDefinition::toDAI;
324 %newobject MEDCoupling::PartDefinition::__add__;
325 %newobject MEDCoupling::PartDefinition::composeWith;
326 %newobject MEDCoupling::PartDefinition::tryToSimplify;
327 %newobject MEDCoupling::DataArrayPartDefinition::New;
328 %newobject MEDCoupling::SlicePartDefinition::New;
330 %newobject FromPyIntPtrToDataArrayByte;
333 %feature("unref") DataArray "$this->decrRef();"
334 %feature("unref") DataArrayDouble "$this->decrRef();"
335 %feature("unref") DataArrayInt32 "$this->decrRef();"
336 %feature("unref") DataArrayInt64 "$this->decrRef();"
337 %feature("unref") DataArrayChar "$this->decrRef();"
338 %feature("unref") DataArrayAsciiChar "$this->decrRef();"
339 %feature("unref") DataArrayByte "$this->decrRef();"
341 %feature("unref") MapII "$this->decrRef();"
342 %feature("unref") PartDefinition "$this->decrRef();"
343 %feature("unref") DataArrayPartDefinition "$this->decrRef();"
344 %feature("unref") SlicePartDefinition "$this->decrRef();"
346 namespace MEDCoupling
353 } MEDCouplingAxisType;
355 class DataArrayInt32;
356 class DataArrayInt64;
358 #ifndef MEDCOUPLING_USE_64BIT_IDS
359 typedef DataArrayInt32 DataArrayIdType;
360 #define DataArrayIdType DataArrayInt32
362 typedef DataArrayInt64 DataArrayIdType;
363 #define DataArrayIdType DataArrayInt64
366 class MapII : public RefCountObject, public TimeLabel
369 static MCAuto< MapII > New();
372 class PartDefinition : public RefCountObject, public TimeLabel
375 static PartDefinition *New(int start, int stop, int step);
376 static PartDefinition *New(DataArrayIdType *listOfIds);
377 virtual DataArrayIdType *toDAI() const;
378 virtual int getNumberOfElems() const;
379 virtual std::string getRepr() const;
380 virtual PartDefinition *composeWith(const PartDefinition *other) const;
381 virtual void checkConsistencyLight() const;
382 virtual PartDefinition *tryToSimplify() const;
385 virtual PartDefinition *__add__(const PartDefinition& other) const
387 return (*self)+other;
390 virtual PyObject *isEqual(const PartDefinition *other) const
393 bool ret0(self->isEqual(other,ret1));
394 PyObject *ret=PyTuple_New(2);
395 PyObject *ret0Py=ret0?Py_True:Py_False;
397 PyTuple_SetItem(ret,0,ret0Py);
398 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
402 virtual PyObject *deepCopy() const
404 return convertPartDefinition(self->deepCopy(),SWIG_POINTER_OWN | 0);
408 virtual ~PartDefinition();
411 class DataArrayPartDefinition : public PartDefinition
414 static DataArrayPartDefinition *New(DataArrayIdType *listOfIds);
417 DataArrayPartDefinition(DataArrayIdType *listOfIds)
419 return DataArrayPartDefinition::New(listOfIds);
422 std::string __str__() const
424 return self->getRepr();
427 std::string __repr__() const
429 std::ostringstream oss; oss << "DataArrayPartDefinition C++ instance at " << self << "." << std::endl;
430 oss << self->getRepr();
435 virtual ~DataArrayPartDefinition();
438 class SlicePartDefinition : public PartDefinition
441 static SlicePartDefinition *New(int start, int stop, int step);
442 int getEffectiveStop() const;
445 SlicePartDefinition(mcIdType start, mcIdType stop, mcIdType step)
447 return SlicePartDefinition::New(start,stop,step);
450 PyObject *getSlice() const
453 self->getSlice(a,b,c);
454 return PySlice_New(PyInt_FromLong(a),PyInt_FromLong(b),PyInt_FromLong(c));
457 std::string __str__() const
459 return self->getRepr();
462 std::string __repr__() const
464 std::ostringstream oss; oss << "SlicePartDefinition C++ instance at " << self << "." << std::endl;
465 oss << self->getRepr();
470 virtual ~SlicePartDefinition();
473 class DataArray : public RefCountObject, public TimeLabel
476 void setName(const std::string& name);
477 void copyStringInfoFrom(const DataArray& other);
478 void copyPartOfStringInfoFrom(const DataArray& other, const std::vector<std::size_t>& compoIds);
479 void copyPartOfStringInfoFrom2(const std::vector<std::size_t>& compoIds, const DataArray& other);
480 bool areInfoEqualsIfNotWhy(const DataArray& other, std::string& reason) const;
481 bool areInfoEquals(const DataArray& other) const;
482 std::string cppRepr(const std::string& varName) const;
483 std::string getName() const;
484 void setInfoOnComponents(const std::vector<std::string>& info);
485 void setInfoAndChangeNbOfCompo(const std::vector<std::string>& info);
486 std::vector<std::string> getVarsOnComponent() const;
487 std::vector<std::string> getUnitsOnComponent() const;
488 std::string getInfoOnComponent(int i) const;
489 std::string getVarOnComponent(int i) const;
490 std::string getUnitOnComponent(int i) const;
491 void setInfoOnComponent(int i, const std::string& info);
492 int getNumberOfComponents() const;
493 virtual void alloc(int nbOfTuple, int nbOfCompo=1);
494 virtual void reAlloc(int nbOfTuples);
495 virtual bool isAllocated() const;
496 virtual void checkAllocated() const;
497 virtual void desallocate();
498 virtual int getNumberOfTuples() const;
499 virtual std::size_t getNbOfElems() const;
500 virtual std::size_t getNbOfElemAllocated() const;
501 virtual DataArray *deepCopy() const;
502 virtual DataArray *copySorted() const;
503 virtual DataArray *buildNewEmptyInstance() const;
504 virtual DataArray *selectByTupleIdSafeSlice(int bg, int end2, int step) const;
505 virtual void rearrange(int newNbOfCompo);
506 virtual void circularPermutation(int nbOfShift=1);
507 virtual void circularPermutationPerTuple(int nbOfShift=1);
508 virtual void reversePerTuple();
509 void checkNbOfTuples(int nbOfTuples, const std::string& msg) const;
510 void checkNbOfComps(int nbOfCompo, const std::string& msg) const;
511 void checkNbOfTuplesAndComp(const DataArray& other, const std::string& msg) const;
512 void checkNbOfTuplesAndComp(int nbOfTuples, int nbOfCompo, const std::string& msg) const;
513 void checkNbOfElems(mcIdType nbOfElems, const std::string& msg) const;
514 static int GetNumberOfItemGivenBES(int begin, int end, int step, const std::string& msg);
515 static int GetNumberOfItemGivenBESRelative(int begin, int end, int step, const std::string& msg);
516 static int GetPosOfItemGivenBESRelativeNoThrow(int value, int begin, int end, int step);
517 static std::string GetVarNameFromInfo(const std::string& info);
518 static std::string GetUnitFromInfo(const std::string& info);
519 static std::string BuildInfoFromVarAndUnit(const std::string& var, const std::string& unit);
520 static std::string GetAxisTypeRepr(MEDCouplingAxisType at);
521 void updateTime() const;
524 PyObject *getInfoOnComponents() const
526 const std::vector<std::string>& comps=self->getInfoOnComponents();
527 PyObject *ret=PyList_New((mcIdType)comps.size());
528 for(std::size_t i=0;i<comps.size();i++)
529 PyList_SetItem(ret,i,PyString_FromString(comps[i].c_str()));
533 void copyPartOfStringInfoFrom(const DataArray& other, PyObject *li)
535 std::vector<std::size_t> tmp;
536 convertPyToNewIntArr3(li,tmp);
537 self->copyPartOfStringInfoFrom(other,tmp);
540 void copyPartOfStringInfoFrom2(PyObject *li, const DataArray& other)
542 std::vector<std::size_t> tmp;
543 convertPyToNewIntArr3(li,tmp);
544 self->copyPartOfStringInfoFrom2(tmp,other);
547 virtual void renumberInPlace(PyObject *li)
550 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
551 if (!SWIG_IsOK(res1))
554 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
555 if(size!=self->getNumberOfTuples())
557 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
559 self->renumberInPlace(tmp);
563 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
565 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
566 da2->checkAllocated();
567 mcIdType size=self->getNumberOfTuples();
568 if(size!=self->getNumberOfTuples())
570 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
572 self->renumberInPlace(da2->getConstPointer());
576 virtual void renumberInPlaceR(PyObject *li)
579 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
580 if (!SWIG_IsOK(res1))
583 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
584 if(size!=self->getNumberOfTuples())
586 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
588 self->renumberInPlaceR(tmp);
592 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
594 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
595 da2->checkAllocated();
596 mcIdType size=self->getNumberOfTuples();
597 if(size!=self->getNumberOfTuples())
599 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
601 self->renumberInPlaceR(da2->getConstPointer());
605 //tuplesSelec in PyObject * because DataArrayInt is not already existing !
606 virtual void setContigPartOfSelectedValues(mcIdType tupleIdStart, PyObject *aBase, PyObject *tuplesSelec)
608 static const char msg[]="DataArray::setContigPartOfSelectedValuesSlice : 4th parameter \"tuplesSelec\" should be of type DataArrayInt";
609 DataArray *a=CheckAndRetrieveDataArrayInstance(aBase,"DataArray::setContigPartOfSelectedValuesSlice : 3rd parameter \"aBase\" should be of type DataArray");
610 DataArray *tuplesSelecPtr=CheckAndRetrieveDataArrayInstance(tuplesSelec,msg);
611 DataArrayIdType *tuplesSelecPtr2=0;
614 tuplesSelecPtr2=dynamic_cast<DataArrayIdType *>(tuplesSelecPtr);
616 throw INTERP_KERNEL::Exception(msg);
618 self->setContigPartOfSelectedValues(tupleIdStart,a,tuplesSelecPtr2);
621 virtual void setContigPartOfSelectedValuesSlice(mcIdType tupleIdStart, PyObject *aBase, mcIdType bg, mcIdType end2, mcIdType step)
623 DataArray *a=CheckAndRetrieveDataArrayInstance(aBase,"DataArray::setContigPartOfSelectedValuesSlice : 2nd parameter \"aBase\" should be of type DataArray");
624 self->setContigPartOfSelectedValuesSlice(tupleIdStart,a,bg,end2,step);
627 virtual DataArray *selectByTupleRanges(PyObject *li) const
629 std::vector<std::pair<mcIdType,mcIdType> > ranges;
630 convertPyToVectorPairInt(li,ranges);
631 return self->selectByTupleRanges(ranges);
634 virtual DataArray *selectByTupleId(PyObject *li) const
637 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
638 if (!SWIG_IsOK(res1))
641 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
642 return self->selectByTupleId(tmp,tmp+size);
646 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
648 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
649 da2->checkAllocated();
650 return self->selectByTupleId(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
654 virtual DataArray *selectByTupleIdSafe(PyObject *li) const
657 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
658 if (!SWIG_IsOK(res1))
661 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
662 return self->selectByTupleIdSafe(tmp,tmp+size);
666 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
668 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
669 da2->checkAllocated();
670 return self->selectByTupleIdSafe(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
674 virtual PyObject *keepSelectedComponents(PyObject *li) const
676 std::vector<std::size_t> tmp;
677 convertPyToNewIntArr3(li,tmp);
678 DataArray *ret=self->keepSelectedComponents(tmp);
679 return convertDataArray(ret,SWIG_POINTER_OWN | 0 );
682 static PyObject *GetSlice(PyObject *slic, mcIdType sliceId, mcIdType nbOfSlices)
684 if(!PySlice_Check(slic))
685 throw INTERP_KERNEL::Exception("DataArray::GetSlice (wrap) : expecting a pyslice as second (first) parameter !");
686 Py_ssize_t strt=2,stp=2,step=2;
687 GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetSlice (wrap) : the input slice is invalid !");
689 DataArray::GetSlice(ToIdType(strt),ToIdType(stp),ToIdType(step),sliceId,nbOfSlices,a,b);
690 AutoPyPtr ap(PyInt_FromLong(a)),bp(PyInt_FromLong(b)),stepp(PyInt_FromLong(step));
691 return PySlice_New(ap,bp,stepp);
694 PyObject *getSlice(PyObject *slic, mcIdType sliceId, mcIdType nbOfSlices) const
696 if(!PySlice_Check(slic))
697 throw INTERP_KERNEL::Exception("DataArray::getSlice (wrap) : expecting a pyslice as second (first) parameter !");
698 Py_ssize_t strt=2,stp=2,step=2;
699 GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getSlice (wrap) : the input slice is invalid !");
701 DataArray::GetSlice(ToIdType(strt),ToIdType(stp),ToIdType(step),sliceId,nbOfSlices,a,b);
702 AutoPyPtr ap(PyInt_FromLong(a)),bp(PyInt_FromLong(b)),stepp(PyInt_FromLong(step));
703 return PySlice_New(ap,bp,stepp);
706 static mcIdType GetNumberOfItemGivenBES(PyObject *slic)
708 if(!PySlice_Check(slic))
709 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBES (wrap) : expecting a pyslice as second (first) parameter !");
710 Py_ssize_t strt=2,stp=2,step=2;
711 GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetNumberOfItemGivenBES (wrap) : the input slice is invalid !");
712 return DataArray::GetNumberOfItemGivenBES(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
715 static mcIdType GetNumberOfItemGivenBESRelative(PyObject *slic)
717 if(!PySlice_Check(slic))
718 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBESRelative (wrap) : expecting a pyslice as second (first) parameter !");
719 Py_ssize_t strt=2,stp=2,step=2;
720 GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !");
721 return DataArray::GetNumberOfItemGivenBESRelative(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
724 static DataArray *Aggregate(PyObject *arrs)
726 std::vector<const DataArray *> tmp;
727 convertFromPyObjVectorOfObj<const MEDCoupling::DataArray *>(arrs,SWIGTYPE_p_MEDCoupling__DataArray,"DataArray",tmp);
728 return DataArray::Aggregate(tmp);
731 mcIdType getNumberOfItemGivenBES(PyObject *slic) const
733 if(!PySlice_Check(slic))
734 throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBES (wrap) : expecting a pyslice as second (first) parameter !");
735 Py_ssize_t strt=2,stp=2,step=2;
736 GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getNumberOfItemGivenBES (wrap) : the input slice is invalid !");
737 return DataArray::GetNumberOfItemGivenBES(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
740 mcIdType getNumberOfItemGivenBESRelative(PyObject *slic)
742 if(!PySlice_Check(slic))
743 throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBESRelative (wrap) : expecting a pyslice as second (first) parameter !");
744 Py_ssize_t strt=2,stp=2,step=2;
745 GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !");
746 return DataArray::GetNumberOfItemGivenBESRelative(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
749 PyObject *__getstate__() const
751 PyObject *ret(PyTuple_New(2));
752 std::string a0(self->getName());
753 const std::vector<std::string> &a1(self->getInfoOnComponents());
754 PyTuple_SetItem(ret,0,PyString_FromString(a0.c_str()));
756 std::size_t sz(a1.size());
757 PyObject *ret1(PyList_New(sz));
758 for(std::size_t i=0;i<sz;i++)
759 PyList_SetItem(ret1,i,PyString_FromString(a1[i].c_str()));
760 PyTuple_SetItem(ret,1,ret1);
765 void __setstate__(PyObject *inp)
767 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 !";
768 if(!PyTuple_Check(inp))
769 throw INTERP_KERNEL::Exception("DataArrayDouble.__setstate__ : invalid input ! Invalid overwrite of __getstate__ ?");
770 std::size_t sz(PyTuple_Size(inp));
772 throw INTERP_KERNEL::Exception("DataArrayDouble.__setstate__ : invalid tuple in input ! Should be of size 2 ! Invalid overwrite of __getstate__ ?");
773 PyObject *a0(PyTuple_GetItem(inp,0));
774 self->setName(convertPyObjectToStr(a0,MSG));
775 PyObject *a1(PyTuple_GetItem(inp,1));
776 std::vector<std::string> a1cpp;
777 if(!fillStringVector(a1,a1cpp))
778 throw INTERP_KERNEL::Exception(MSG);
779 self->setInfoOnComponents(a1cpp);
784 class DataArrayDouble;
786 class DataArrayFloat : public DataArray
789 static DataArrayFloat *New();
790 void fillWithValue(float val);
791 bool isEqual(const DataArrayFloat& other, float prec) const;
792 bool isEqualWithoutConsideringStr(const DataArrayFloat& other, float prec) const;
793 bool isUniform(float val, float eps) const;
794 void pushBackSilent(float val);
795 void iota(float init=0.);
796 DataArrayFloatIterator *iterator();
797 MCAuto<DataArrayDouble> convertToDblArr() const;
798 static DataArrayFloat *Meld(const DataArrayFloat *a1, const DataArrayFloat *a2);
803 return DataArrayFloat::New();
806 static DataArrayFloat *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
808 return DataArrayT_New<float>(elt0,nbOfTuples,elt2);
811 DataArrayFloat(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
813 return MEDCoupling_DataArrayFloat_New__SWIG_1(elt0,nbOfTuples,elt2);
816 DataArrayFloatIterator *__iter__()
818 return self->iterator();
821 std::string __repr__() const
823 std::ostringstream oss;
824 self->reprQuickOverview(oss);
828 std::string __str__() const
830 return self->reprNotTooLong();
833 mcIdType __len__() const
835 if(self->isAllocated())
837 return self->getNumberOfTuples();
841 throw INTERP_KERNEL::Exception("DataArrayFloat::__len__ : Instance is NOT allocated !");
845 PyObject *getValues() const
847 const float *vals(self->begin());
848 return convertDblArrToPyList<float>(vals,self->getNbOfElems());
851 PyObject *getValuesAsTuple() const
853 const float *vals(self->begin());
854 std::size_t nbOfComp(self->getNumberOfComponents());
855 mcIdType nbOfTuples(self->getNumberOfTuples());
856 return convertDblArrToPyListOfTuple<float>(vals,nbOfComp,nbOfTuples);
859 PyObject *isEqualIfNotWhy(const DataArrayFloat& other, float prec) const
862 bool ret0=self->isEqualIfNotWhy(other,prec,ret1);
863 PyObject *ret=PyTuple_New(2);
864 PyObject *ret0Py=ret0?Py_True:Py_False;
866 PyTuple_SetItem(ret,0,ret0Py);
867 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
871 PyObject *__getitem__(PyObject *obj)
873 return DataArrayT__getitem<float>(self,obj);
876 DataArrayFloat *__setitem__(PyObject *obj, PyObject *value)
878 return DataArrayT__setitem__<float>(self,obj,value);
881 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
883 return DataArrayT_iadd<float>(trueSelf,obj,self);
886 PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
888 return DataArrayT_isub<float>(trueSelf,obj,self);
891 PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
893 return DataArrayT_imul<float>(trueSelf,obj,self);
896 DataArrayFloat *__rmul__(PyObject *obj)
898 return DataArrayFPT_rmul<float>(self,obj);
901 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
903 return DataArrayT_idiv<float>(trueSelf,obj,self);
907 PyObject *toNumPyArray() // not const. It is not a bug !
909 return ToNumPyArray<DataArrayFloat,float>(self,NPY_FLOAT,"DataArrayFloat");
915 class DataArrayFloatTuple;
917 class DataArrayFloatIterator
920 DataArrayFloatIterator(DataArrayFloat *da);
921 ~DataArrayFloatIterator();
926 DataArrayFloatTuple *ret=self->nextt();
928 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayFloatTuple,SWIG_POINTER_OWN|0);
931 PyErr_SetString(PyExc_StopIteration,"No more data.");
938 class DataArrayFloatTuple
941 std::size_t getNumberOfCompo() const;
942 DataArrayFloat *buildDAFloat(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
945 std::string __str__() const
950 float __float__() const
952 return self->floatValue();
955 DataArrayFloat *buildDAFloat()
957 return self->buildDAFloat(1,self->getNumberOfCompo());
960 /*PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
962 MCAuto<DataArrayFloat> ret=self->buildDAFloat(1,self->getNumberOfCompo());
963 MEDCoupling_DataArrayFloat____imul___(ret,0,obj);
964 Py_XINCREF(trueSelf);
970 return PyInt_FromLong(self->getNumberOfCompo());
975 class DataArrayDoubleIterator;
977 class DataArrayDouble : public DataArray
980 static DataArrayDouble *New();
981 double doubleValue() const;
983 void aggregate(const DataArrayDouble *other);
984 DataArrayDouble *performCopyOrIncrRef(bool deepCopy) const;
985 void deepCopyFrom(const DataArrayDouble& other);
986 void reserve(std::size_t nbOfElems);
987 void pushBackSilent(double val);
988 double popBackSilent();
990 void allocIfNecessary(int nbOfTuple, int nbOfCompo);
992 void fillWithValue(double val);
993 void iota(double init=0.);
994 bool isUniform(double val, double eps) const;
995 void sort(bool asc=true);
997 void checkMonotonic(bool increasing, double eps) const;
998 bool isMonotonic(bool increasing, double eps) const;
999 std::string repr() const;
1000 std::string reprZip() const;
1001 std::string reprNotTooLong() const;
1002 bool isEqual(const DataArrayDouble& other, double prec) const;
1003 bool isEqualWithoutConsideringStr(const DataArrayDouble& other, double prec) const;
1004 DataArrayDouble *fromNoInterlace() const;
1005 DataArrayDouble *toNoInterlace() const;
1006 DataArrayDouble *subArray(int tupleIdBg, int tupleIdEnd=-1) const;
1008 DataArrayDouble *changeNbOfComponents(std::size_t newNbOfComp, double dftValue) const;
1009 void meldWith(const DataArrayDouble *other);
1010 DataArrayDouble *duplicateEachTupleNTimes(int nbTimes) const;
1011 DataArrayDouble *getDifferentValues(double prec, int limitTupleId=-1) const;
1012 DataArrayIdType *findClosestTupleId(const DataArrayDouble *other) const;
1013 DataArrayIdType *computeNbOfInteractionsWith(const DataArrayDouble *otherBBoxFrmt, double eps) const;
1014 void setPartOfValues1(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare=true);
1015 void setPartOfValuesSimple1(double a, mcIdType bgTuples, mcIdType endTuples, mcIdType stepTuples, mcIdType bgComp, mcIdType endComp, mcIdType stepComp);
1016 void setPartOfValuesAdv(const DataArrayDouble *a, const DataArrayIdType *tuplesSelec);
1017 double getIJ(int tupleId, int compoId) const;
1018 double front() const;
1019 double back() const;
1020 double getIJSafe(int tupleId, int compoId) const;
1021 void setIJ(int tupleId, int compoId, double newVal);
1022 void setIJSilent(int tupleId, int compoId, double newVal);
1023 double *getPointer();
1024 void checkNoNullValues() const;
1025 DataArrayDouble *computeBBoxPerTuple(double epsilon=0.0) const;
1026 void recenterForMaxPrecision(double eps);
1027 double getMaxValueInArray() const;
1028 double getMaxAbsValueInArray() const;
1029 double getMinValueInArray() const;
1030 int count(double value, double eps) const;
1031 double getAverageValue() const;
1032 double norm2() const;
1033 double normMax() const;
1034 double normMin() const;
1035 double accumulate(int compId) const;
1036 DataArrayDouble *fromPolarToCart() const;
1037 DataArrayDouble *fromCylToCart() const;
1038 DataArrayDouble *fromSpherToCart() const;
1039 DataArrayDouble *fromCartToPolar() const;
1040 DataArrayDouble *fromCartToCyl() const;
1041 DataArrayDouble *fromCartToSpher() const;
1042 DataArrayDouble *cartesianize(MEDCouplingAxisType atOfThis) const;
1043 DataArrayDouble *doublyContractedProduct() const;
1044 DataArrayDouble *determinant() const;
1045 DataArrayDouble *eigenValues() const;
1046 DataArrayDouble *eigenVectors() const;
1047 DataArrayDouble *inverse() const;
1048 DataArrayDouble *trace() const;
1049 DataArrayDouble *deviator() const;
1050 DataArrayDouble *magnitude() const;
1051 DataArrayDouble *maxPerTuple() const;
1052 DataArrayDouble *minPerTuple() const;
1053 DataArrayDouble *sumPerTuple() const;
1054 DataArrayDouble *buildEuclidianDistanceDenseMatrix() const;
1055 DataArrayDouble *buildEuclidianDistanceDenseMatrixWith(const DataArrayDouble *other) const;
1056 void sortPerTuple(bool asc);
1058 DataArrayDouble *computeAbs() const;
1059 void applyLin(double a, double b, int compoId);
1060 void applyLin(double a, double b);
1061 void applyInv(double numerator);
1062 void applyPow(double val);
1063 void applyRPow(double val);
1064 DataArrayDouble *negate() const;
1065 DataArrayDouble *applyFunc(int nbOfComp, FunctionToEvaluate func) const;
1066 DataArrayDouble *applyFunc(int nbOfComp, const std::string& func, bool isSafe=true) const;
1067 DataArrayDouble *applyFunc(const std::string& func, bool isSafe=true) const;
1068 void applyFuncOnThis(const std::string& func, bool isSafe=true);
1069 DataArrayDouble *applyFuncCompo(int nbOfComp, const std::string& func, bool isSafe=true) const;
1070 DataArrayDouble *applyFuncNamedCompo(int nbOfComp, const std::vector<std::string>& varsOrder, const std::string& func, bool isSafe=true) const;
1071 void applyFuncFast32(const std::string& func);
1072 void applyFuncFast64(const std::string& func);
1073 DataArrayIdType *findIdsInRange(double vmin, double vmax) const;
1074 DataArrayIdType *findIdsNotInRange(double vmin, double vmax) const;
1075 DataArrayIdType *findIdsStrictlyNegative() const;
1076 static DataArrayDouble *Aggregate(const DataArrayDouble *a1, const DataArrayDouble *a2);
1077 static DataArrayDouble *Meld(const DataArrayDouble *a1, const DataArrayDouble *a2);
1078 static DataArrayDouble *Dot(const DataArrayDouble *a1, const DataArrayDouble *a2);
1079 static DataArrayDouble *CrossProduct(const DataArrayDouble *a1, const DataArrayDouble *a2);
1080 static DataArrayDouble *Max(const DataArrayDouble *a1, const DataArrayDouble *a2);
1081 static DataArrayDouble *Min(const DataArrayDouble *a1, const DataArrayDouble *a2);
1082 static DataArrayDouble *Add(const DataArrayDouble *a1, const DataArrayDouble *a2);
1083 void addEqual(const DataArrayDouble *other);
1084 static DataArrayDouble *Substract(const DataArrayDouble *a1, const DataArrayDouble *a2);
1085 void substractEqual(const DataArrayDouble *other);
1086 static DataArrayDouble *Multiply(const DataArrayDouble *a1, const DataArrayDouble *a2);
1087 void multiplyEqual(const DataArrayDouble *other);
1088 static DataArrayDouble *Divide(const DataArrayDouble *a1, const DataArrayDouble *a2);
1089 void divideEqual(const DataArrayDouble *other);
1090 static DataArrayDouble *Pow(const DataArrayDouble *a1, const DataArrayDouble *a2);
1091 void powEqual(const DataArrayDouble *other);
1092 MCAuto<DataArrayIdType> findIdsGreaterOrEqualTo(double val) const;
1093 MCAuto<DataArrayIdType> findIdsGreaterThan(double val) const;
1094 MCAuto<DataArrayIdType> findIdsLowerOrEqualTo(double val) const;
1095 MCAuto<DataArrayIdType> findIdsLowerThan(double val) const;
1096 MCAuto<DataArrayInt32> convertToIntArr() const;
1097 MCAuto<DataArrayInt64> convertToInt64Arr() const;
1098 MCAuto<DataArrayDouble> selectPartDef(const PartDefinition* pd) const;
1099 MCAuto<DataArrayDouble> cumSum() const;
1100 MCAuto<DataArrayFloat> convertToFloatArr() const;
1105 return DataArrayDouble::New();
1108 static DataArrayDouble *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
1110 return DataArrayT_New<double>(elt0,nbOfTuples,elt2);
1113 DataArrayDouble(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
1115 return MEDCoupling_DataArrayDouble_New__SWIG_1(elt0,nbOfTuples,elt2);
1118 void pushBackValsSilent(PyObject *li)
1121 std::vector<double> bb;
1122 mcIdType sw; mcIdType nbTuples=-1;
1123 const char msg[]="Python wrap of DataArrayDouble::pushBackValsSilent : ";
1124 const double *tmp=convertObjToPossibleCpp5_SingleCompo(li,sw,val,bb,msg,true,nbTuples);
1125 self->pushBackValsSilent(tmp,tmp+nbTuples);
1128 std::string __repr__() const
1130 std::ostringstream oss;
1131 self->reprQuickOverview(oss);
1135 std::string __str__() const
1137 return self->reprNotTooLong();
1140 double __float__() const
1142 return self->doubleValue();
1145 mcIdType __len__() const
1147 if(self->isAllocated())
1149 return self->getNumberOfTuples();
1153 throw INTERP_KERNEL::Exception("DataArrayDouble::__len__ : Instance is NOT allocated !");
1157 PyObject *asArcOfCircle() const
1159 double center[2],radius,ang;
1160 self->asArcOfCircle(center,radius,ang);
1161 PyObject *ret(PyTuple_New(3));
1163 PyObject *ret0(PyList_New(2));
1164 PyList_SetItem(ret0,0,PyFloat_FromDouble(center[0]));
1165 PyList_SetItem(ret0,1,PyFloat_FromDouble(center[1]));
1166 PyTuple_SetItem(ret,0,ret0);
1168 PyTuple_SetItem(ret,1,PyFloat_FromDouble(radius));
1169 PyTuple_SetItem(ret,2,PyFloat_FromDouble(ang));
1173 DataArrayDoubleIterator *__iter__()
1175 return self->iterator();
1178 void setValues(PyObject *li, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
1180 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 !";
1181 if(PyList_Check(li) || PyTuple_Check(li))
1183 if(nbOfTuples && nbOfTuples != Py_None)
1185 if(PyInt_Check(nbOfTuples))
1187 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
1189 throw INTERP_KERNEL::Exception("DataArrayDouble::setValues : should be a positive set of allocated memory !");
1190 if(nbOfComp && nbOfComp != Py_None)
1192 if(PyInt_Check(nbOfComp))
1193 {//DataArrayDouble.setValues([1.,3.,4.,5.],2,2)
1194 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
1196 throw INTERP_KERNEL::Exception("DataArrayDouble::setValues : should be a positive number of components !");
1197 std::vector<double> tmp=fillArrayWithPyListDbl2(li,nbOfTuples1,nbOfCompo);
1198 self->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1201 throw INTERP_KERNEL::Exception(msg);
1204 {//DataArrayDouble.setValues([1.,3.,4.],3)
1206 std::vector<double> tmp=fillArrayWithPyListDbl2(li,nbOfTuples1,tmpp1);
1207 self->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1211 throw INTERP_KERNEL::Exception(msg);
1214 {// DataArrayDouble.setValues([1.,3.,4.])
1215 mcIdType tmpp1=-1,tmpp2=-1;
1216 std::vector<double> tmp=fillArrayWithPyListDbl2(li,tmpp1,tmpp2);
1217 self->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1221 throw INTERP_KERNEL::Exception(msg);
1224 PyObject *getValues() const
1226 const double *vals(self->begin());
1227 return convertDblArrToPyList<double>(vals,self->getNbOfElems());
1231 PyObject *toNumPyArray() // not const. It is not a bug !
1233 return ToNumPyArray<DataArrayDouble,double>(self,NPY_DOUBLE,"DataArrayDouble");
1237 PyObject *isEqualIfNotWhy(const DataArrayDouble& other, double prec) const
1240 bool ret0=self->isEqualIfNotWhy(other,prec,ret1);
1241 PyObject *ret=PyTuple_New(2);
1242 PyObject *ret0Py=ret0?Py_True:Py_False;
1244 PyTuple_SetItem(ret,0,ret0Py);
1245 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
1249 PyObject *getValuesAsTuple() const
1251 const double *vals(self->begin());
1252 std::size_t nbOfComp(self->getNumberOfComponents());
1253 mcIdType nbOfTuples(self->getNumberOfTuples());
1254 return convertDblArrToPyListOfTuple<double>(vals,nbOfComp,nbOfTuples);
1257 static PyObject *ComputeIntegralOfSeg2IntoTri3(PyObject *seg2, PyObject *tri3)
1259 const char msg[]="Python wrap of DataArrayDouble::ComputeIntegralOfSeg2IntoTri3 : ";
1261 DataArrayDouble *a,*a2;
1262 DataArrayDoubleTuple *aa,*aa2;
1263 std::vector<double> bb,bb2;
1265 const double *seg2Ptr(convertObjToPossibleCpp5_Safe(seg2,sw,val,a,aa,bb,msg,2,2,true));
1266 const double *tri3Ptr(convertObjToPossibleCpp5_Safe(tri3,sw,val2,a2,aa2,bb2,msg,3,2,true));
1268 double res0[3],res1;
1269 DataArrayDouble::ComputeIntegralOfSeg2IntoTri3(seg2Ptr,tri3Ptr,res0,res1);
1270 PyObject *ret(PyTuple_New(2)),*ret0(PyTuple_New(3));
1271 PyTuple_SetItem(ret0,0,PyFloat_FromDouble(res0[0]));
1272 PyTuple_SetItem(ret0,1,PyFloat_FromDouble(res0[1]));
1273 PyTuple_SetItem(ret0,2,PyFloat_FromDouble(res0[2]));
1274 PyTuple_SetItem(ret,0,ret0);
1275 PyTuple_SetItem(ret,1,PyFloat_FromDouble(res1));
1279 DataArrayDouble *symmetry3DPlane(PyObject *point, PyObject *normalVector)
1281 const char msg[]="Python wrap of DataArrayDouble::symmetry3DPlane : ";
1283 DataArrayDouble *a,*a2;
1284 DataArrayDoubleTuple *aa,*aa2;
1285 std::vector<double> bb,bb2;
1287 const double *centerPtr(convertObjToPossibleCpp5_Safe(point,sw,val,a,aa,bb,msg,1,3,true));
1288 const double *vectorPtr(convertObjToPossibleCpp5_Safe(normalVector,sw,val2,a2,aa2,bb2,msg,1,3,true));
1289 MCAuto<DataArrayDouble> ret(self->symmetry3DPlane(centerPtr,vectorPtr));
1293 static PyObject *GiveBaseForPlane(PyObject *normalVector)
1295 const char msg[]="Python wrap of DataArrayDouble::GiveBaseForPlane : ";
1298 DataArrayDoubleTuple *aa;
1299 std::vector<double> bb,bb2;
1301 const double *vectorPtr(convertObjToPossibleCpp5_Safe(normalVector,sw,val,a,aa,bb,msg,1,3,true));
1303 DataArrayDouble::GiveBaseForPlane(vectorPtr,res);
1304 return convertDblArrToPyListOfTuple<double>(res,3,3);
1307 DataArrayDouble *fromCartToCylGiven(const DataArrayDouble *coords, PyObject *center, PyObject *vector) const
1309 const char msg[]="Python wrap of DataArrayDouble::fromCartToCylGiven : ";
1311 DataArrayDouble *a,*a2;
1312 DataArrayDoubleTuple *aa,*aa2;
1313 std::vector<double> bb,bb2;
1315 const double *centerPtr=convertObjToPossibleCpp5_Safe(center,sw,val,a,aa,bb,msg,1,3,true);
1316 const double *vectorPtr=convertObjToPossibleCpp5_Safe(vector,sw,val2,a2,aa2,bb2,msg,1,3,true);
1317 return self->fromCartToCylGiven(coords,centerPtr,vectorPtr);
1320 DataArrayDouble *renumber(PyObject *li)
1323 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
1324 if (!SWIG_IsOK(res1))
1327 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1328 if(size!=self->getNumberOfTuples())
1330 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1332 return self->renumber(tmp);
1336 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1338 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1339 da2->checkAllocated();
1340 mcIdType size=self->getNumberOfTuples();
1341 if(size!=self->getNumberOfTuples())
1343 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1345 return self->renumber(da2->getConstPointer());
1349 DataArrayDouble *renumberR(PyObject *li)
1352 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
1353 if (!SWIG_IsOK(res1))
1356 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1357 if(size!=self->getNumberOfTuples())
1359 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1361 return self->renumberR(tmp);
1365 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1367 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1368 da2->checkAllocated();
1369 mcIdType size=self->getNumberOfTuples();
1370 if(size!=self->getNumberOfTuples())
1372 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1374 return self->renumberR(da2->getConstPointer());
1378 DataArrayDouble *renumberAndReduce(PyObject *li, mcIdType newNbOfTuple)
1381 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
1382 if (!SWIG_IsOK(res1))
1385 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1386 if(size!=self->getNumberOfTuples())
1388 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1390 return self->renumberAndReduce(tmp,newNbOfTuple);
1394 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1396 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1397 da2->checkAllocated();
1398 mcIdType size=self->getNumberOfTuples();
1399 if(size!=self->getNumberOfTuples())
1401 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1403 return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
1407 PyObject *minimalDistanceTo(const DataArrayDouble *other) const
1409 mcIdType thisTupleId,otherTupleId;
1410 double r0=self->minimalDistanceTo(other,thisTupleId,otherTupleId);
1411 PyObject *ret=PyTuple_New(3);
1412 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r0));
1413 PyTuple_SetItem(ret,1,PyInt_FromLong(thisTupleId));
1414 PyTuple_SetItem(ret,2,PyInt_FromLong(otherTupleId));
1418 PyObject *getMaxValue() const
1421 double r1=self->getMaxValue(tmp);
1422 PyObject *ret=PyTuple_New(2);
1423 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1424 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1428 PyObject *getMaxAbsValue() const
1431 double r1=self->getMaxAbsValue(tmp);
1432 PyObject *ret=PyTuple_New(2);
1433 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1434 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1438 PyObject *getMaxValue2() const
1440 DataArrayIdType *tmp;
1441 double r1=self->getMaxValue2(tmp);
1442 PyObject *ret=PyTuple_New(2);
1443 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1444 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1448 PyObject *getMinValue() const
1451 double r1=self->getMinValue(tmp);
1452 PyObject *ret=PyTuple_New(2);
1453 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1454 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1458 PyObject *getMinValue2() const
1460 DataArrayIdType *tmp;
1461 double r1=self->getMinValue2(tmp);
1462 PyObject *ret=PyTuple_New(2);
1463 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1464 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1468 PyObject *getMinMaxPerComponent() const
1470 std::size_t nbOfCompo(self->getNumberOfComponents());
1471 INTERP_KERNEL::AutoPtr<double> tmp(new double[2*nbOfCompo]);
1472 self->getMinMaxPerComponent(tmp);
1473 PyObject *ret=convertDblArrToPyListOfTuple<double>(tmp,2,ToIdType(nbOfCompo));
1477 PyObject *normMaxPerComponent() const
1479 std::size_t nbOfCompo(self->getNumberOfComponents());
1480 INTERP_KERNEL::AutoPtr<double> tmp(new double[nbOfCompo]);
1481 self->normMaxPerComponent(tmp);
1482 return convertDblArrToPyList<double>(tmp,ToIdType(nbOfCompo));
1485 PyObject *accumulate() const
1487 std::size_t sz=self->getNumberOfComponents();
1488 INTERP_KERNEL::AutoPtr<double> tmp=new double[sz];
1489 self->accumulate(tmp);
1490 return convertDblArrToPyList<double>(tmp,ToIdType(sz));
1493 DataArrayDouble *accumulatePerChunck(PyObject *indexArr) const
1495 mcIdType sw, sz,val;
1496 std::vector<mcIdType> val2;
1497 const mcIdType *bg=convertIntStarLikePyObjToCppIntStar(indexArr,sw,sz,val,val2);
1498 return self->accumulatePerChunck(bg,bg+sz);
1501 PyObject *findCommonTuples(double prec, mcIdType limitNodeId=-1) const
1503 DataArrayIdType *comm, *commIndex;
1504 self->findCommonTuples(prec,limitNodeId,comm,commIndex);
1505 PyObject *res = PyList_New(2);
1506 PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(comm),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1507 PyList_SetItem(res,1,SWIG_NewPointerObj(SWIG_as_voidptr(commIndex),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1511 PyObject *distanceToTuple(PyObject *tuple) const
1515 DataArrayDoubleTuple *aa;
1516 std::vector<double> bb;
1518 mcIdType tupleId=-1;
1519 std::size_t nbOfCompo=self->getNumberOfComponents();
1520 const double *pt=convertObjToPossibleCpp5_Safe(tuple,sw,val,a,aa,bb,"Python wrap of DataArrayDouble::distanceToTuple",1,(int)nbOfCompo,true);
1522 double ret0=self->distanceToTuple(pt,pt+nbOfCompo,tupleId);
1523 PyObject *ret=PyTuple_New(2);
1524 PyTuple_SetItem(ret,0,PyFloat_FromDouble(ret0));
1525 PyTuple_SetItem(ret,1,PyInt_FromLong(tupleId));
1529 void setSelectedComponents(const DataArrayDouble *a, PyObject *li)
1531 std::vector<std::size_t> tmp;
1532 convertPyToNewIntArr3(li,tmp);
1533 self->setSelectedComponents(a,tmp);
1536 PyObject *explodeComponents() const
1538 std::vector< MCAuto<DataArrayDouble> > retCpp(self->explodeComponents());
1539 std::size_t sz(retCpp.size());
1540 PyObject *res(PyList_New(sz));
1541 for(std::size_t i=0;i<sz;i++)
1542 PyList_SetItem(res,i,SWIG_NewPointerObj(SWIG_as_voidptr(retCpp[i].retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ));
1546 PyObject *getTuple(mcIdType tupleId)
1548 std::size_t sz=self->getNumberOfComponents();
1549 INTERP_KERNEL::AutoPtr<double> tmp=new double[sz];
1550 self->getTuple(tupleId,tmp);
1551 return convertDblArrToPyList<double>(tmp,ToIdType(sz));
1554 static DataArrayDouble *Aggregate(PyObject *li)
1556 std::vector<const DataArrayDouble *> tmp;
1557 convertFromPyObjVectorOfObj<const DataArrayDouble *>(li,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",tmp);
1558 return DataArrayDouble::Aggregate(tmp);
1561 static DataArrayDouble *Meld(PyObject *li)
1563 std::vector<const DataArrayDouble *> tmp;
1564 convertFromPyObjVectorOfObj<const DataArrayDouble *>(li,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",tmp);
1565 return DataArrayDouble::Meld(tmp);
1568 PyObject *computeTupleIdsNearTuples(PyObject *pt, double eps) const
1572 DataArrayDoubleTuple *aa;
1573 std::vector<double> bb;
1575 std::size_t nbComp=self->getNumberOfComponents();
1576 mcIdType nbTuples=-1;
1577 const char msg[]="Python wrap of DataArrayDouble::computeTupleIdsNearTuples : ";
1578 const double *pos=convertObjToPossibleCpp5_Safe2(pt,sw,val,a,aa,bb,msg,(int)nbComp,true,nbTuples);
1579 MCAuto<DataArrayDouble> inpu=DataArrayDouble::New(); inpu->useArray(pos,false,DeallocType::CPP_DEALLOC,nbTuples,nbComp);
1580 DataArrayIdType *c=0,*cI=0;
1581 self->computeTupleIdsNearTuples(inpu,eps,c,cI);
1582 PyObject *ret=PyTuple_New(2);
1583 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1584 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1588 PyObject *areIncludedInMe(const DataArrayDouble *other, double prec) const
1590 DataArrayIdType *ret1=0;
1591 bool ret0=self->areIncludedInMe(other,prec,ret1);
1592 PyObject *ret=PyTuple_New(2);
1593 PyObject *ret0Py=ret0?Py_True:Py_False;
1595 PyTuple_SetItem(ret,0,ret0Py);
1596 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1600 PyObject *__getitem__(PyObject *obj)
1602 return DataArrayT__getitem<double>(self,obj);
1605 DataArrayDouble *__setitem__(PyObject *obj, PyObject *value)
1607 return DataArrayT__setitem__<double>(self,obj,value);
1610 DataArrayDouble *__neg__() const
1612 return self->negate();
1615 PyObject *__add__(PyObject *obj)
1617 const char msg[]="Unexpected situation in DataArrayDouble.__add__ !";
1620 DataArrayDoubleTuple *aa;
1621 std::vector<double> bb;
1624 #ifndef WITHOUT_AUTOFIELD
1626 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1628 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1631 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1632 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___radd__Impl(other,tmp);
1634 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1637 throw INTERP_KERNEL::Exception(msg);
1641 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1646 MCAuto<DataArrayDouble> ret=self->deepCopy();
1647 ret->applyLin(1.,val);
1648 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1652 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1656 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1657 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1661 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1662 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1665 throw INTERP_KERNEL::Exception(msg);
1669 DataArrayDouble *__radd__(PyObject *obj)
1671 const char msg[]="Unexpected situation in __radd__ !";
1674 DataArrayDoubleTuple *aa;
1675 std::vector<double> bb;
1677 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1682 MCAuto<DataArrayDouble> ret=self->deepCopy();
1683 ret->applyLin(1.,val);
1688 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1689 return DataArrayDouble::Add(self,aaa);
1693 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1694 return DataArrayDouble::Add(self,aaa);
1697 throw INTERP_KERNEL::Exception(msg);
1701 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
1703 return DataArrayT_iadd<double>(trueSelf,obj,self);
1706 PyObject *__sub__(PyObject *obj)
1708 const char msg[]="Unexpected situation in __sub__ !";
1711 DataArrayDoubleTuple *aa;
1712 std::vector<double> bb;
1715 #ifndef WITHOUT_AUTOFIELD
1717 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1719 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1722 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1723 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rsub__Impl(other,tmp);
1725 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1728 throw INTERP_KERNEL::Exception(msg);
1732 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1737 MCAuto<DataArrayDouble> ret=self->deepCopy();
1738 ret->applyLin(1.,-val);
1739 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1743 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1747 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1748 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1752 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1753 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1756 throw INTERP_KERNEL::Exception(msg);
1760 DataArrayDouble *__rsub__(PyObject *obj)
1762 const char msg[]="Unexpected situation in __rsub__ !";
1765 DataArrayDoubleTuple *aa;
1766 std::vector<double> bb;
1768 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1773 MCAuto<DataArrayDouble> ret=self->deepCopy();
1774 ret->applyLin(-1.,val);
1779 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1780 return DataArrayDouble::Substract(aaa,self);
1784 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1785 return DataArrayDouble::Substract(aaa,self);
1788 throw INTERP_KERNEL::Exception(msg);
1792 PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
1794 return DataArrayT_isub<double>(trueSelf,obj,self);
1797 PyObject *__mul__(PyObject *obj)
1799 const char msg[]="Unexpected situation in __mul__ !";
1802 DataArrayDoubleTuple *aa;
1803 std::vector<double> bb;
1806 #ifndef WITHOUT_AUTOFIELD
1808 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1810 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1813 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1814 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rmul__Impl(other,tmp);
1816 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1819 throw INTERP_KERNEL::Exception(msg);
1823 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1828 MCAuto<DataArrayDouble> ret=self->deepCopy();
1829 ret->applyLin(val,0.);
1830 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1834 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1838 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1839 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1843 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1844 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1847 throw INTERP_KERNEL::Exception(msg);
1851 DataArrayDouble *__rmul__(PyObject *obj)
1853 return DataArrayFPT_rmul<double>(self,obj);
1856 PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
1858 return DataArrayT_imul<double>(trueSelf,obj,self);
1861 PyObject *__div__(PyObject *obj)
1863 const char msg[]="Unexpected situation in __div__ !";
1866 DataArrayDoubleTuple *aa;
1867 std::vector<double> bb;
1870 #ifndef WITHOUT_AUTOFIELD
1872 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1874 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1877 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1878 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rdiv__Impl(other,tmp);
1880 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1883 throw INTERP_KERNEL::Exception(msg);
1887 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1893 throw INTERP_KERNEL::Exception("DataArrayDouble::__div__ : trying to divide by zero !");
1894 MCAuto<DataArrayDouble> ret=self->deepCopy();
1895 ret->applyLin(1/val,0.);
1896 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1900 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1904 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1905 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1909 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1910 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1913 throw INTERP_KERNEL::Exception(msg);
1917 DataArrayDouble *__rdiv__(PyObject *obj)
1919 const char msg[]="Unexpected situation in __rdiv__ !";
1922 DataArrayDoubleTuple *aa;
1923 std::vector<double> bb;
1925 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1930 MCAuto<DataArrayDouble> ret=self->deepCopy();
1936 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1937 return DataArrayDouble::Divide(aaa,self);
1941 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1942 return DataArrayDouble::Divide(aaa,self);
1945 throw INTERP_KERNEL::Exception(msg);
1949 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
1951 return DataArrayT_idiv<double>(trueSelf,obj,self);
1954 DataArrayDouble *__pow__(PyObject *obj)
1956 const char msg[]="Unexpected situation in __pow__ !";
1959 DataArrayDoubleTuple *aa;
1960 std::vector<double> bb;
1962 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1967 MCAuto<DataArrayDouble> ret=self->deepCopy();
1973 return DataArrayDouble::Pow(self,a);
1977 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1978 return DataArrayDouble::Pow(self,aaa);
1982 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1983 return DataArrayDouble::Pow(self,aaa);
1986 throw INTERP_KERNEL::Exception(msg);
1990 DataArrayDouble *__rpow__(PyObject *obj)
1992 const char msg[]="Unexpected situation in __rpow__ !";
1995 DataArrayDoubleTuple *aa;
1996 std::vector<double> bb;
1998 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
2003 MCAuto<DataArrayDouble> ret=self->deepCopy();
2004 ret->applyRPow(val);
2009 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
2010 return DataArrayDouble::Pow(aaa,self);
2014 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
2015 return DataArrayDouble::Pow(aaa,self);
2018 throw INTERP_KERNEL::Exception(msg);
2022 PyObject *___ipow___(PyObject *trueSelf, PyObject *obj)
2024 const char msg[]="Unexpected situation in __ipow__ !";
2027 DataArrayDoubleTuple *aa;
2028 std::vector<double> bb;
2030 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
2035 self->applyPow(val);
2036 Py_XINCREF(trueSelf);
2042 Py_XINCREF(trueSelf);
2047 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
2048 self->powEqual(aaa);
2049 Py_XINCREF(trueSelf);
2054 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
2055 self->powEqual(aaa);
2056 Py_XINCREF(trueSelf);
2060 throw INTERP_KERNEL::Exception(msg);
2064 PyObject *computeTupleIdsNearTuples(const DataArrayDouble *other, double eps)
2066 DataArrayIdType *c=0,*cI=0;
2068 self->computeTupleIdsNearTuples(other,eps,c,cI);
2069 PyObject *ret=PyTuple_New(2);
2070 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2071 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2075 PyObject *maxPerTupleWithCompoId() const
2077 DataArrayIdType *ret1=0;
2078 DataArrayDouble *ret0=self->maxPerTupleWithCompoId(ret1);
2079 PyObject *ret=PyTuple_New(2);
2080 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ));
2081 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2087 class DataArrayDoubleTuple;
2089 class DataArrayDoubleIterator
2092 DataArrayDoubleIterator(DataArrayDouble *da);
2093 ~DataArrayDoubleIterator();
2098 DataArrayDoubleTuple *ret=self->nextt();
2100 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayDoubleTuple,SWIG_POINTER_OWN|0);
2103 PyErr_SetString(PyExc_StopIteration,"No more data.");
2110 class DataArrayDoubleTuple
2113 std::size_t getNumberOfCompo() const;
2114 DataArrayDouble *buildDADouble(int nbOfTuples, int nbOfCompo) const;
2117 std::string __str__() const
2119 return self->repr();
2122 double __float__() const
2124 return self->doubleValue();
2127 DataArrayDouble *buildDADouble()
2129 return self->buildDADouble(1,self->getNumberOfCompo());
2132 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
2134 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2135 MEDCoupling_DataArrayDouble____iadd___(ret,0,obj);
2136 Py_XINCREF(trueSelf);
2140 PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
2142 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2143 MEDCoupling_DataArrayDouble____isub___(ret,0,obj);
2144 Py_XINCREF(trueSelf);
2148 PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
2150 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2151 MEDCoupling_DataArrayDouble____imul___(ret,0,obj);
2152 Py_XINCREF(trueSelf);
2156 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
2158 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2159 MEDCoupling_DataArrayDouble____idiv___(ret,0,obj);
2160 Py_XINCREF(trueSelf);
2166 return PyInt_FromLong(self->getNumberOfCompo());
2169 PyObject *__getitem__(PyObject *obj)
2171 const char msg2[]="DataArrayDoubleTuple::__getitem__ : Mismatch of slice values in 2nd parameter (components) !";
2174 std::vector<mcIdType> multiVal;
2175 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2176 MEDCoupling::DataArrayIdType *daIntTyypp=0;
2177 const double *pt=self->getConstPointer();
2178 mcIdType nbc=ToIdType(self->getNumberOfCompo());
2179 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbc,sw,singleVal,multiVal,slic,daIntTyypp);
2186 std::ostringstream oss;
2187 oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2188 PyErr_SetString(PyExc_StopIteration,oss.str().c_str());
2192 return PyFloat_FromDouble(pt[singleVal]);
2196 return PyFloat_FromDouble(pt[nbc+singleVal]);
2199 std::ostringstream oss;
2200 oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2201 throw INTERP_KERNEL::Exception(oss.str().c_str());
2207 PyObject *t=PyTuple_New(multiVal.size());
2208 for(std::size_t j=0;j<multiVal.size();j++)
2210 mcIdType cid=multiVal[j];
2213 std::ostringstream oss;
2214 oss << "Requesting for id #" << cid << " having only " << nbc << " components !";
2215 throw INTERP_KERNEL::Exception(oss.str().c_str());
2217 PyTuple_SetItem(t,j,PyFloat_FromDouble(pt[cid]));
2223 mcIdType sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2224 PyObject *t=PyTuple_New(sz);
2225 for(mcIdType j=0;j<sz;j++)
2226 PyTuple_SetItem(t,j,PyFloat_FromDouble(pt[slic.first+j*slic.second.second]));
2230 throw INTERP_KERNEL::Exception("DataArrayDoubleTuple::__getitem__ : unrecognized type entered !");
2234 DataArrayDoubleTuple *__setitem__(PyObject *obj, PyObject *value)
2236 const char msg[]="DataArrayDoubleTuple::__setitem__ : unrecognized type entered, int, slice, list<int>, tuple<int> !";
2237 const char msg2[]="DataArrayDoubleTuple::__setitem__ : Mismatch of slice values in 2nd parameter (components) !";
2240 std::vector<double> multiValV;
2241 MEDCoupling::DataArrayDoubleTuple *daIntTyyppV=0;
2242 mcIdType nbc=ToIdType(self->getNumberOfCompo());
2243 convertDoubleStarLikePyObjToCpp(value,sw1,singleValV,multiValV,daIntTyyppV);
2245 std::vector<mcIdType> multiVal;
2246 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2247 MEDCoupling::DataArrayIdType *daIntTyypp=0;
2248 double *pt=self->getPointer();
2249 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbc,sw2,singleVal,multiVal,slic,daIntTyypp);
2256 std::ostringstream oss;
2257 oss << "Requesting for setting id # " << singleVal << " having only " << nbc << " components !";
2258 throw INTERP_KERNEL::Exception(oss.str().c_str());
2264 pt[singleVal]=singleValV;
2269 if(multiValV.size()!=1)
2271 std::ostringstream oss;
2272 oss << "Requesting for setting id # " << singleVal << " with a list or tuple with size != 1 ! ";
2273 throw INTERP_KERNEL::Exception(oss.str().c_str());
2275 pt[singleVal]=multiValV[0];
2280 pt[singleVal]=daIntTyyppV->getConstPointer()[0];
2284 throw INTERP_KERNEL::Exception(msg);
2293 for(std::vector<mcIdType>::const_iterator it=multiVal.begin();it!=multiVal.end();it++)
2297 std::ostringstream oss;
2298 oss << "Requesting for setting id # " << *it << " having only " << nbc << " components !";
2299 throw INTERP_KERNEL::Exception(oss.str().c_str());
2307 if(multiVal.size()!=multiValV.size())
2309 std::ostringstream oss;
2310 oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << multiVal.size() << " !";
2311 throw INTERP_KERNEL::Exception(oss.str().c_str());
2313 for(std::size_t i=0;i<multiVal.size();i++)
2315 mcIdType pos=multiVal[i];
2318 std::ostringstream oss;
2319 oss << "Requesting for setting id # " << pos << " having only " << nbc << " components !";
2320 throw INTERP_KERNEL::Exception(oss.str().c_str());
2322 pt[multiVal[i]]=multiValV[i];
2328 const double *ptV=daIntTyyppV->getConstPointer();
2329 if(nbc>(mcIdType)daIntTyyppV->getNumberOfCompo())
2331 std::ostringstream oss;
2332 oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2333 throw INTERP_KERNEL::Exception(oss.str().c_str());
2335 std::copy(ptV,ptV+nbc,pt);
2339 throw INTERP_KERNEL::Exception(msg);
2344 mcIdType sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2349 for(mcIdType j=0;j<sz;j++)
2350 pt[slic.first+j*slic.second.second]=singleValV;
2355 if(sz!=(mcIdType)multiValV.size())
2357 std::ostringstream oss;
2358 oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << sz << " !";
2359 throw INTERP_KERNEL::Exception(oss.str().c_str());
2361 for(mcIdType j=0;j<sz;j++)
2362 pt[slic.first+j*slic.second.second]=multiValV[j];
2367 const double *ptV=daIntTyyppV->getConstPointer();
2368 if(sz>(mcIdType)daIntTyyppV->getNumberOfCompo())
2370 std::ostringstream oss;
2371 oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2372 throw INTERP_KERNEL::Exception(oss.str().c_str());
2374 for(mcIdType j=0;j<sz;j++)
2375 pt[slic.first+j*slic.second.second]=ptV[j];
2379 throw INTERP_KERNEL::Exception(msg);
2383 throw INTERP_KERNEL::Exception(msg);
2389 class DataArrayChar : public DataArray
2392 virtual DataArrayChar *buildEmptySpecializedDAChar() const;
2393 int getHashCode() const;
2395 void deepCopyFrom(const DataArrayChar& other);
2396 void reserve(std::size_t nbOfElems);
2397 void pushBackSilent(char val);
2398 char popBackSilent();
2400 void allocIfNecessary(int nbOfTuple, int nbOfCompo);
2401 bool isEqual(const DataArrayChar& other) const;
2402 bool isEqualWithoutConsideringStr(const DataArrayChar& other) const;
2404 void fillWithZero();
2405 void fillWithValue(char val);
2406 std::string repr() const;
2407 std::string reprZip() const;
2408 DataArrayInt *convertToIntArr() const;
2409 DataArrayChar *renumber(const mcIdType *old2New) const;
2410 DataArrayChar *renumberR(const mcIdType *new2Old) const;
2411 DataArrayChar *renumberAndReduce(const mcIdType *old2NewBg, mcIdType newNbOfTuple) const;
2412 bool isUniform(char val) const;
2413 void sort(bool asc=true);
2414 DataArrayChar *subArray(mcIdType tupleIdBg, mcIdType tupleIdEnd=-1) const;
2415 DataArrayChar *changeNbOfComponents(std::size_t newNbOfComp, char dftValue) const;
2416 void meldWith(const DataArrayChar *other);
2417 void setPartOfValuesAdv(const DataArrayChar *a, const DataArrayIdType *tuplesSelec);
2420 void setIJ(mcIdType tupleId, int compoId, char newVal);
2421 void setIJSilent(mcIdType tupleId, int compoId, char newVal);
2423 DataArrayIdType *findIdsEqual(char val) const;
2424 DataArrayIdType *findIdsNotEqual(char val) const;
2425 int findIdFirstEqualTuple(const std::vector<char>& tupl) const;
2426 bool presenceOfTuple(const std::vector<char>& tupl) const;
2427 char getMaxValue(mcIdType& tupleId) const;
2428 char getMaxValueInArray() const;
2429 char getMinValue(mcIdType& tupleId) const;
2430 char getMinValueInArray() const;
2431 DataArrayIdType *findIdsInRange(char vmin, char vmax) const;
2432 static DataArrayChar *Aggregate(const DataArrayChar *a1, const DataArrayChar *a2);
2433 static DataArrayChar *Meld(const DataArrayChar *a1, const DataArrayChar *a2);
2436 mcIdType __len__() const
2438 if(self->isAllocated())
2440 return self->getNumberOfTuples();
2444 throw INTERP_KERNEL::Exception("DataArrayChar::__len__ : Instance is NOT allocated !");
2448 PyObject *isEqualIfNotWhy(const DataArrayChar& other) const
2451 bool ret0=self->isEqualIfNotWhy(other,ret1);
2452 PyObject *ret=PyTuple_New(2);
2453 PyObject *ret0Py=ret0?Py_True:Py_False;
2455 PyTuple_SetItem(ret,0,ret0Py);
2456 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
2460 DataArrayChar *renumber(PyObject *li)
2463 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
2464 if (!SWIG_IsOK(res1))
2467 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2468 if(size!=self->getNumberOfTuples())
2470 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2472 return self->renumber(tmp);
2476 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2478 throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2479 da2->checkAllocated();
2480 mcIdType size=self->getNumberOfTuples();
2481 if(size!=self->getNumberOfTuples())
2483 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2485 return self->renumber(da2->getConstPointer());
2489 DataArrayChar *renumberR(PyObject *li)
2492 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
2493 if (!SWIG_IsOK(res1))
2496 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2497 if(size!=self->getNumberOfTuples())
2499 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2501 return self->renumberR(tmp);
2505 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2507 throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2508 da2->checkAllocated();
2509 mcIdType size=self->getNumberOfTuples();
2510 if(size!=self->getNumberOfTuples())
2512 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2514 return self->renumberR(da2->getConstPointer());
2518 DataArrayChar *renumberAndReduce(PyObject *li, mcIdType newNbOfTuple)
2521 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
2522 if (!SWIG_IsOK(res1))
2525 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2526 if(size!=self->getNumberOfTuples())
2528 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2530 return self->renumberAndReduce(tmp,newNbOfTuple);
2534 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2536 throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2537 da2->checkAllocated();
2538 mcIdType size=self->getNumberOfTuples();
2539 if(size!=self->getNumberOfTuples())
2541 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2543 return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
2547 static DataArrayChar *Aggregate(PyObject *dachs)
2549 std::vector<const MEDCoupling::DataArrayChar *> tmp;
2550 convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayChar *>(dachs,SWIGTYPE_p_MEDCoupling__DataArrayChar,"DataArrayChar",tmp);
2551 return DataArrayChar::Aggregate(tmp);
2554 static DataArrayChar *Meld(PyObject *dachs)
2556 std::vector<const MEDCoupling::DataArrayChar *> tmp;
2557 convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayChar *>(dachs,SWIGTYPE_p_MEDCoupling__DataArrayChar,"DataArrayChar",tmp);
2558 return DataArrayChar::Meld(tmp);
2563 class DataArrayByteIterator;
2565 class DataArrayByte : public DataArrayChar
2568 static DataArrayByte *New();
2569 DataArrayByteIterator *iterator();
2570 DataArrayByte *performCopyOrIncrRef(bool deepCopy) const;
2571 char byteValue() const;
2576 return DataArrayByte::New();
2579 static DataArrayByte *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
2581 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) !";
2582 if(PyList_Check(elt0) || PyTuple_Check(elt0))
2586 if(PyInt_Check(nbOfTuples))
2588 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
2590 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive set of allocated memory !");
2593 if(PyInt_Check(nbOfComp))
2594 {//DataArrayByte.New([1,3,4,5],2,2)
2595 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
2597 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !");
2598 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2599 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
2600 ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2604 throw INTERP_KERNEL::Exception(msg);
2607 {//DataArrayByte.New([1,3,4],3)
2608 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2610 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
2611 ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2616 throw INTERP_KERNEL::Exception(msg);
2619 {// DataArrayByte.New([1,3,4])
2620 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2621 mcIdType tmpp1=-1,tmpp2=-1;
2622 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
2623 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2627 else if(PyInt_Check(elt0))
2629 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(elt0));
2631 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive set of allocated memory !");
2636 if(PyInt_Check(nbOfTuples))
2637 {//DataArrayByte.New(5,2)
2638 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfTuples));
2640 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !");
2641 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2642 ret->alloc(nbOfTuples1,nbOfCompo);
2646 throw INTERP_KERNEL::Exception(msg);
2649 throw INTERP_KERNEL::Exception(msg);
2652 {//DataArrayByte.New(5)
2653 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2654 ret->alloc(nbOfTuples1,1);
2659 else if(PyArray_Check(elt0) && nbOfTuples==NULL && nbOfComp==NULL)
2660 {//DataArrayDouble.New(numpyArray)
2661 return BuildNewInstance<DataArrayByte,char>(elt0,NPY_INT8,&PyCallBackDataArrayChar_RefType,"INT8");
2665 throw INTERP_KERNEL::Exception(msg);
2668 DataArrayByte(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
2670 return MEDCoupling_DataArrayByte_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
2673 std::string __repr__() const
2675 std::ostringstream oss;
2676 self->reprQuickOverview(oss);
2682 return (int) self->byteValue();
2685 DataArrayByteIterator *__iter__()
2687 return self->iterator();
2690 mcIdType getIJ(mcIdType tupleId, mcIdType compoId) const
2692 return (mcIdType)self->getIJ(tupleId,compoId);
2695 mcIdType getIJSafe(mcIdType tupleId, mcIdType compoId) const
2697 return (mcIdType)self->getIJSafe(tupleId,compoId);
2700 std::string __str__() const
2702 return self->repr();
2705 PyObject *toStrList() const
2707 const char *vals=self->getConstPointer();
2708 std::size_t nbOfComp=self->getNumberOfComponents();
2709 mcIdType nbOfTuples=self->getNumberOfTuples();
2710 return convertCharArrToPyListOfTuple(vals,(int)nbOfComp,nbOfTuples);
2713 bool presenceOfTuple(PyObject *tupl) const
2715 mcIdType sz=-1,sw=-1;
2716 mcIdType ival=-1; std::vector<mcIdType> ivval;
2717 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(tupl,sw,sz,ival,ivval);
2718 std::vector<char> vals(sz);
2719 std::copy(pt,pt+sz,vals.begin());
2720 return self->presenceOfTuple(vals);
2723 bool presenceOfValue(PyObject *vals) const
2725 mcIdType sz=-1,sw=-1;
2726 mcIdType ival=-1; std::vector<mcIdType> ivval;
2727 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(vals,sw,sz,ival,ivval);
2728 std::vector<char> vals2(sz);
2729 std::copy(pt,pt+sz,vals2.begin());
2730 return self->presenceOfValue(vals2);
2733 mcIdType findIdFirstEqual(PyObject *vals) const
2735 mcIdType sz=-1,sw=-1;
2736 mcIdType ival=-1; std::vector<mcIdType> ivval;
2737 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(vals,sw,sz,ival,ivval);
2738 std::vector<char> vals2(sz);
2739 std::copy(pt,pt+sz,vals2.begin());
2740 return self->findIdFirstEqual(vals2);
2743 mcIdType findIdFirstEqualTuple(PyObject *tupl) const
2745 mcIdType sz=-1,sw=-1;
2746 mcIdType ival=-1; std::vector<mcIdType> ivval;
2747 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(tupl,sw,sz,ival,ivval);
2748 std::vector<char> vals(sz);
2749 std::copy(pt,pt+sz,vals.begin());
2750 return self->findIdFirstEqualTuple(vals);
2753 mcIdType findIdSequence(PyObject *strOrListOfInt) const
2755 mcIdType sz=-1,sw=-1;
2756 mcIdType ival=-1; std::vector<mcIdType> ivval;
2757 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(strOrListOfInt,sw,sz,ival,ivval);
2758 std::vector<char> vals(sz);
2759 std::copy(pt,pt+sz,vals.begin());
2760 return self->findIdSequence(vals);
2763 PyObject *getTuple(mcIdType tupleId)
2765 std::size_t sz=self->getNumberOfComponents();
2766 INTERP_KERNEL::AutoPtr<char> tmp=new char[sz];
2767 self->getTuple(tupleId,tmp);
2768 PyObject *ret=PyTuple_New(sz);
2769 for(std::size_t i=0;i<sz;i++) PyTuple_SetItem(ret,i,PyInt_FromLong((mcIdType)tmp[i]));
2773 PyObject *getMaxValue() const
2776 mcIdType r1=(mcIdType)self->getMaxValue(tmp);
2777 PyObject *ret=PyTuple_New(2);
2778 PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
2779 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
2783 PyObject *getMinValue() const
2786 mcIdType r1=(mcIdType)self->getMinValue(tmp);
2787 PyObject *ret=PyTuple_New(2);
2788 PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
2789 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
2793 mcIdType index(PyObject *obj) const
2795 std::size_t nbOfCompo=self->getNumberOfComponents();
2800 if(PyInt_Check(obj))
2802 char val=(char)PyInt_AS_LONG(obj);
2803 return self->findIdFirstEqual(val);
2806 throw INTERP_KERNEL::Exception("DataArrayByte::index : 'this' contains one component and trying to find an element which is not an integer !");
2809 return MEDCoupling_DataArrayByte_findIdFirstEqualTuple(self,obj);
2813 bool __contains__(PyObject *obj) const
2815 std::size_t nbOfCompo=self->getNumberOfComponents();
2822 if(PyInt_Check(obj))
2824 char val=(char)PyInt_AS_LONG(obj);
2825 return self->presenceOfValue(val);
2828 throw INTERP_KERNEL::Exception("DataArrayByte::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
2831 return MEDCoupling_DataArrayByte_presenceOfTuple(self,obj);
2836 PyObject *toNumPyArray() // not const. It is not a bug !
2838 return ToNumPyArray<DataArrayByte,char>(self,NPY_INT8,"DataArrayByte");
2842 DataArrayByte *__setitem__(PyObject *obj, PyObject *value)
2844 self->checkAllocated();
2845 const char msg[]="Unexpected situation in __setitem__ !";
2846 mcIdType nbOfTuples(self->getNumberOfTuples());
2847 int nbOfComponents((int)self->getNumberOfComponents());
2850 std::vector<int> v1;
2851 DataArrayIdType *d1=0;
2852 DataArrayIntTuple *dd1=0;
2853 convertIntStarLikePyObjToCpp(value,sw1,int1,v1,d1,dd1);
2855 std::vector<mcIdType> vt1,vc1;
2856 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > pt1,pc1;
2857 DataArrayIdType *dt1=0,*dc1=0;
2858 convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw2,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1);
2859 MCAuto<DataArrayIdType> tmp;
2860 char i1 = (char)int1;
2868 self->setPartOfValuesSimple1(i1,it1,it1+1,1,0,nbOfComponents,1);
2871 throw INTERP_KERNEL::Exception(msg);
2880 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1);
2883 throw INTERP_KERNEL::Exception(msg);
2892 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1);
2895 throw INTERP_KERNEL::Exception(msg);
2904 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1);
2907 throw INTERP_KERNEL::Exception(msg);
2916 self->setPartOfValuesSimple1(i1,it1,it1+1,1,ic1,ic1+1,1);
2919 throw INTERP_KERNEL::Exception(msg);
2928 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1);
2931 throw INTERP_KERNEL::Exception(msg);
2940 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1);
2943 throw INTERP_KERNEL::Exception(msg);
2952 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1);
2955 throw INTERP_KERNEL::Exception(msg);
2964 self->setPartOfValuesSimple2(i1,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size());
2967 throw INTERP_KERNEL::Exception(msg);
2976 self->setPartOfValuesSimple2(i1,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size());
2979 throw INTERP_KERNEL::Exception(msg);
2988 self->setPartOfValuesSimple4(i1,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size());
2991 throw INTERP_KERNEL::Exception(msg);
3000 self->setPartOfValuesSimple2(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size());
3003 throw INTERP_KERNEL::Exception(msg);
3012 self->setPartOfValuesSimple1(i1,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second);
3015 throw INTERP_KERNEL::Exception(msg);
3024 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second);
3027 throw INTERP_KERNEL::Exception(msg);
3036 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second);
3039 throw INTERP_KERNEL::Exception(msg);
3048 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second);
3051 throw INTERP_KERNEL::Exception(msg);
3056 throw INTERP_KERNEL::Exception(msg);
3063 class DataArrayByteTuple;
3065 class DataArrayByteIterator
3068 DataArrayByteIterator(DataArrayByte *da);
3069 ~DataArrayByteIterator();
3072 class DataArrayByteTuple
3075 std::string repr() const;
3076 DataArrayByte *buildDAByte(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
3079 std::string __str__() const
3081 return self->repr();
3084 char __int__() const
3086 return self->byteValue();
3089 DataArrayByte *buildDAByte()
3091 return self->buildDAByte(1,self->getNumberOfCompo());
3096 class DataArrayAsciiCharIterator;
3098 class DataArrayAsciiChar : public DataArrayChar
3101 static DataArrayAsciiChar *New();
3102 DataArrayAsciiCharIterator *iterator();
3103 DataArrayAsciiChar *performCopyOrIncrRef(bool deepCopy) const;
3104 char asciiCharValue() const;
3107 DataArrayAsciiChar()
3109 return DataArrayAsciiChar::New();
3112 static DataArrayAsciiChar *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
3114 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) !";
3115 if(PyList_Check(elt0) || PyTuple_Check(elt0))
3119 if(PyInt_Check(nbOfTuples))
3121 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
3123 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive set of allocated memory !");
3126 if(PyInt_Check(nbOfComp))
3127 {//DataArrayAsciiChar.New([1,3,4,5],2,2)
3128 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
3130 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !");
3131 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3132 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
3133 ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3137 throw INTERP_KERNEL::Exception(msg);
3140 {//DataArrayAsciiChar.New([1,3,4],3)
3141 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3143 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
3144 ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3148 else if(PyString_Check(nbOfTuples))
3150 if(PyString_Size(nbOfTuples)!=1)
3151 throw INTERP_KERNEL::Exception(msg);
3152 //DataArrayAsciiChar.New(["abc","de","fghi"],"t")
3153 std::vector<std::string> tmp;
3154 if(fillStringVector(elt0,tmp))
3155 return DataArrayAsciiChar::New(tmp,PyString_AsString(nbOfTuples)[0]);
3157 throw INTERP_KERNEL::Exception(msg);
3159 %#if PY_VERSION_HEX >= 0x03000000
3160 else if(PyUnicode_Check(nbOfTuples))
3162 if(PyUnicode_GET_LENGTH(nbOfTuples)!=1)
3163 throw INTERP_KERNEL::Exception(msg);
3164 //DataArrayAsciiChar.New(["abc","de","fghi"],"t")
3165 std::vector<std::string> tmp;
3166 if(fillStringVector(elt0,tmp))
3167 return DataArrayAsciiChar::New(tmp,PyUnicode_AsUTF8(nbOfTuples)[0]);
3169 throw INTERP_KERNEL::Exception(msg);
3173 throw INTERP_KERNEL::Exception(msg);
3177 std::vector<std::string> tmmp;
3178 if(fillStringVector(elt0,tmmp))
3179 //DataArrayAsciiChar.New(["abc","de","fghi"])
3180 return DataArrayAsciiChar::New(tmmp,' ');
3183 // DataArrayAsciiChar.New([1,3,4])
3184 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3185 mcIdType tmpp1=-1,tmpp2=-1;
3186 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
3187 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3192 else if(PyInt_Check(elt0))
3194 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(elt0));
3196 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive set of allocated memory !");
3201 if(PyInt_Check(nbOfTuples))
3202 {//DataArrayAsciiChar.New(5,2)
3203 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfTuples));
3205 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !");
3206 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3207 ret->alloc(nbOfTuples1,nbOfCompo);
3211 throw INTERP_KERNEL::Exception(msg);
3214 throw INTERP_KERNEL::Exception(msg);
3217 {//DataArrayAsciiChar.New(5)
3218 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3219 ret->alloc(nbOfTuples1,1);
3224 throw INTERP_KERNEL::Exception(msg);
3227 DataArrayAsciiChar(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
3229 return MEDCoupling_DataArrayAsciiChar_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
3232 std::string __repr__() const
3234 std::ostringstream oss;
3235 self->reprQuickOverview(oss);
3239 DataArrayAsciiCharIterator *__iter__()
3241 return self->iterator();
3244 std::string getIJ(mcIdType tupleId, mcIdType compoId) const
3246 char tmp[2]; tmp[1]='\0';
3247 tmp[0]=self->getIJ(tupleId,compoId);
3248 return std::string(tmp);
3251 std::string getIJSafe(mcIdType tupleId, mcIdType compoId) const
3253 char tmp[2]; tmp[1]='\0';
3254 tmp[0]=self->getIJSafe(tupleId,compoId);
3255 return std::string(tmp);
3258 std::string __str__() const
3260 return self->repr();
3263 PyObject *toStrList() const
3265 const char *vals=self->getConstPointer();
3266 std::size_t nbOfComp=self->getNumberOfComponents();
3267 mcIdType nbOfTuples=self->getNumberOfTuples();
3268 return convertCharArrToPyListOfTuple(vals,(int)nbOfComp,nbOfTuples);
3271 bool presenceOfTuple(PyObject *tupl) const
3273 if(PyString_Check(tupl))
3275 Py_ssize_t sz=PyString_Size(tupl);
3276 std::vector<char> vals(sz);
3277 std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin());
3278 return self->presenceOfTuple(vals);
3280 %#if PY_VERSION_HEX >= 0x03000000
3281 else if(PyUnicode_Check(tupl))
3283 Py_ssize_t sz=PyUnicode_GET_LENGTH(tupl);
3284 std::vector<char> vals(sz);
3285 std::copy(PyUnicode_AsUTF8(tupl),PyUnicode_AsUTF8(tupl)+sz,vals.begin());
3286 return self->presenceOfTuple(vals);
3290 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfTuple : only strings in input supported !");
3293 bool presenceOfValue(PyObject *vals) const
3295 if(PyString_Check(vals))
3297 Py_ssize_t sz=PyString_Size(vals);
3298 std::vector<char> vals2(sz);
3299 std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin());
3300 return self->presenceOfValue(vals2);
3302 %#if PY_VERSION_HEX >= 0x03000000
3303 if(PyUnicode_Check(vals))
3305 Py_ssize_t sz=PyUnicode_GET_LENGTH(vals);
3306 std::vector<char> vals2(sz);
3307 std::copy(PyUnicode_AsUTF8(vals),PyUnicode_AsUTF8(vals)+sz,vals2.begin());
3308 return self->presenceOfValue(vals2);
3312 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfValue : only strings in input supported !");
3315 mcIdType findIdFirstEqual(PyObject *vals) const
3317 if(PyString_Check(vals))
3319 Py_ssize_t sz=PyString_Size(vals);
3320 std::vector<char> vals2(sz);
3321 std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin());
3322 return self->findIdFirstEqual(vals2);
3324 %#if PY_VERSION_HEX >= 0x03000000
3325 if(PyUnicode_Check(vals))
3327 Py_ssize_t sz=PyUnicode_GET_LENGTH(vals);
3328 std::vector<char> vals2(sz);
3329 std::copy(PyUnicode_AsUTF8(vals),PyUnicode_AsUTF8(vals)+sz,vals2.begin());
3330 return self->findIdFirstEqual(vals2);
3334 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::findIdFirstEqual : only strings in input supported !");
3337 mcIdType findIdFirstEqualTuple(PyObject *tupl) const
3339 if(PyString_Check(tupl))
3341 Py_ssize_t sz=PyString_Size(tupl);
3342 std::vector<char> vals(sz);
3343 std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin());
3344 return self->findIdFirstEqualTuple(vals);
3346 %#if PY_VERSION_HEX >= 0x03000000
3347 if(PyUnicode_Check(tupl))
3349 Py_ssize_t sz=PyUnicode_GET_LENGTH(tupl);
3350 std::vector<char> vals(sz);
3351 std::copy(PyUnicode_AsUTF8(tupl),PyUnicode_AsUTF8(tupl)+sz,vals.begin());
3352 return self->findIdFirstEqualTuple(vals);
3356 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::findIdFirstEqualTuple : only strings in input supported !");
3359 mcIdType findIdSequence(PyObject *strOrListOfInt) const
3361 if(PyString_Check(strOrListOfInt))
3363 Py_ssize_t sz=PyString_Size(strOrListOfInt);
3364 std::vector<char> vals(sz);
3365 std::copy(PyString_AsString(strOrListOfInt),PyString_AsString(strOrListOfInt)+sz,vals.begin());
3366 return self->findIdSequence(vals);
3368 %#if PY_VERSION_HEX >= 0x03000000
3369 else if(PyUnicode_Check(strOrListOfInt))
3371 Py_ssize_t sz=PyUnicode_GET_LENGTH(strOrListOfInt);
3372 std::vector<char> vals(sz);
3373 std::copy(PyUnicode_AsUTF8(strOrListOfInt),PyUnicode_AsUTF8(strOrListOfInt)+sz,vals.begin());
3374 return self->findIdSequence(vals);
3378 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::search : only strings in input supported !");
3381 PyObject *getTuple(mcIdType tupleId) const
3383 std::size_t sz=self->getNumberOfComponents();
3384 INTERP_KERNEL::AutoPtr<char> tmp=new char[sz+1]; tmp[sz]='\0';
3385 self->getTuple(tupleId,tmp);
3386 return PyString_FromString(tmp);
3389 PyObject *getMaxValue() const
3392 char tmp2[2]; tmp2[1]='\0';
3393 tmp2[0]=self->getMaxValue(tmp);
3394 PyObject *ret=PyTuple_New(2);
3395 PyTuple_SetItem(ret,0,PyString_FromString(tmp2));
3396 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
3400 PyObject *getMinValue() const
3403 char tmp2[2]; tmp2[1]='\0';
3404 tmp2[0]=self->getMinValue(tmp);
3405 PyObject *ret=PyTuple_New(2);
3406 PyTuple_SetItem(ret,0,PyString_FromString(tmp2));
3407 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
3411 mcIdType index(PyObject *obj) const
3413 std::size_t nbOfCompo=self->getNumberOfComponents();
3418 if(PyString_Check(obj))
3420 Py_ssize_t sz=PyString_Size(obj);
3421 char *pt=PyString_AsString(obj);
3423 return self->findIdFirstEqual(pt[0]);
3425 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find a string with size different from 1 !");
3427 %#if PY_VERSION_HEX >= 0x03000000
3428 if(PyUnicode_Check(obj))
3431 const char *pt=PyUnicode_AsUTF8AndSize(obj, &sz);
3433 return self->findIdFirstEqual(pt[0]);
3435 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find a string with size different from 1 !");
3439 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find an element which is not an integer !");
3442 return MEDCoupling_DataArrayAsciiChar_findIdFirstEqualTuple(self,obj);
3446 bool __contains__(PyObject *obj) const
3448 std::size_t nbOfCompo=self->getNumberOfComponents();
3455 if(PyString_Check(obj))
3457 Py_ssize_t sz=PyString_Size(obj);
3458 char *pt=PyString_AsString(obj);
3460 return self->presenceOfValue(pt[0]);
3462 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find a string with size different from 1 !");
3464 %#if PY_VERSION_HEX >= 0x03000000
3465 if(PyUnicode_Check(obj))
3468 const char *pt=PyUnicode_AsUTF8AndSize(obj, &sz);
3470 return self->presenceOfValue(pt[0]);
3472 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find a string with size different from 1 !");
3476 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
3479 return MEDCoupling_DataArrayAsciiChar_presenceOfTuple(self,obj);
3483 PyObject *__getitem__(PyObject *obj) const
3485 mcIdType sw,iTypppArr;
3486 std::vector<mcIdType> stdvecTyyppArr;
3487 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > sTyyppArr;
3488 MEDCoupling::DataArrayIdType *daIntTyypp=0;
3489 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,self->getNumberOfTuples(),sw,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp);
3493 return MEDCoupling_DataArrayAsciiChar_getTuple(self,iTypppArr);
3495 return convertDataArrayChar(self->selectByTupleIdSafe(&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size()), SWIG_POINTER_OWN | 0 );
3497 return convertDataArrayChar(self->selectByTupleIdSafeSlice(sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second), SWIG_POINTER_OWN | 0 );
3499 return convertDataArrayChar(self->selectByTupleIdSafe(daIntTyypp->begin(),daIntTyypp->end()), SWIG_POINTER_OWN | 0 );
3501 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__getitem__ : supporting int, list of int, tuple of int, DataArrayIdType and slice in input !");
3505 DataArrayAsciiChar *__setitem__(PyObject *obj, PyObject *value)
3507 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.";
3508 mcIdType sw1,iTypppArr;
3509 std::vector<mcIdType> stdvecTyyppArr;
3510 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > sTyyppArr;
3511 MEDCoupling::DataArrayIdType *daIntTyypp=0;
3512 mcIdType nbOfCompo=ToIdType(self->getNumberOfComponents());
3513 mcIdType nbOfTuples=self->getNumberOfTuples();
3514 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbOfTuples,sw1,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp);
3516 char vc; std::string sc; std::vector<std::string> vsc; DataArrayChar *dacc=0;
3517 convertObjToPossibleCpp6(value,sw2,vc,sc,vsc,dacc);
3526 self->setPartOfValuesSimple3(vc,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1);
3532 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3533 self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3536 //value vector<string>
3539 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3540 self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3543 //value DataArrayChar
3546 self->setPartOfValues3(dacc,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3550 throw INTERP_KERNEL::Exception(msg);
3554 {//obj list-tuple[int]
3560 self->setPartOfValuesSimple3(vc,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1);
3566 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3567 self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3570 //value vector<string>
3573 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3574 self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3577 //value DataArrayChar
3580 self->setPartOfValues3(dacc,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3584 throw INTERP_KERNEL::Exception(msg);
3595 self->setPartOfValuesSimple1(vc,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1);
3601 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3602 self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3605 //value vector<string>
3608 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3609 self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3612 //value DataArrayChar
3615 self->setPartOfValues1(dacc,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3619 throw INTERP_KERNEL::Exception(msg);
3630 self->setPartOfValuesSimple3(vc,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1);
3636 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3637 self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3640 //value vector<string>
3643 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3644 self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3647 //value DataArrayChar
3650 self->setPartOfValues3(dacc,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3654 throw INTERP_KERNEL::Exception(msg);
3659 throw INTERP_KERNEL::Exception(msg);
3665 class DataArrayAsciiCharTuple;
3667 class DataArrayAsciiCharIterator
3670 DataArrayAsciiCharIterator(DataArrayAsciiChar *da);
3671 ~DataArrayAsciiCharIterator();
3676 DataArrayAsciiCharTuple *ret=self->nextt();
3678 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayAsciiCharTuple,SWIG_POINTER_OWN | 0);
3681 PyErr_SetString(PyExc_StopIteration,"No more data.");
3688 class DataArrayAsciiCharTuple
3691 std::size_t getNumberOfCompo() const;
3692 DataArrayAsciiChar *buildDAAsciiChar(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
3695 std::string __str__() const
3697 return self->repr();
3700 DataArrayAsciiChar *buildDAAsciiChar()
3702 return self->buildDAAsciiChar(1,self->getNumberOfCompo());
3711 MEDCoupling::DataArrayByte *FromPyIntPtrToDataArrayByte(mcPyPtrType intPtr)
3713 MEDCoupling::DataArrayByte *ret(reinterpret_cast<MEDCoupling::DataArrayByte *>(intPtr));
3718 %include "DataArrayInt.i"
3722 def MEDCouplingStdReduceFunct(cls,params):
3724 ret=object.__new__(cls)
3729 def MEDCouplingDataArrayDoubleReduce(self):
3730 if not MEDCouplingHasNumPyBindings():
3731 raise InterpKernelException("PyWrap of DataArrayDouble.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3732 return MEDCouplingStdReduceFunct,(DataArrayDouble,((self.toNumPyArray(),),(self.__getstate__()),))
3734 def MEDCouplingDataArrayInt32Reduce(self):
3735 if not MEDCouplingHasNumPyBindings():
3736 raise InterpKernelException("PyWrap of DataArrayIdType.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3737 return MEDCouplingStdReduceFunct,(DataArrayInt32,((self.toNumPyArray(),),(self.__getstate__()),))
3739 def MEDCouplingDataArrayInt64Reduce(self):
3740 if not MEDCouplingHasNumPyBindings():
3741 raise InterpKernelException("PyWrap of DataArrayIdType.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3742 return MEDCouplingStdReduceFunct,(DataArrayInt64,((self.toNumPyArray(),),(self.__getstate__()),))
3744 def MEDCouplingDataArrayByteReduce(self):
3745 if not MEDCouplingHasNumPyBindings():
3746 raise InterpKernelException("PyWrap of DataArrayByte.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3747 return MEDCouplingStdReduceFunct,(DataArrayByte,((self.toNumPyArray(),),(self.__getstate__()),))
3749 def MEDCouplingDataArrayFloatReduce(self):
3750 if not MEDCouplingHasNumPyBindings():
3751 raise InterpKernelException("PyWrap of DataArrayFloat.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3752 return MEDCouplingStdReduceFunct,(DataArrayFloat,((self.toNumPyArray(),),(self.__getstate__()),))
3754 if MEDCouplingUse64BitIDs():
3755 DataArrayInt=DataArrayInt64
3757 DataArrayInt=DataArrayInt32