1 // Copyright (C) 2007-2024 CEA, EDF
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::locateComponentId;
146 %newobject MEDCoupling::DataArrayInt32::getDifferentValues;
147 %newobject MEDCoupling::DataArrayInt32::FindPermutationFromFirstToSecond;
148 %newobject MEDCoupling::DataArrayInt32::FindPermutationFromFirstToSecondDuplicate;
149 %newobject MEDCoupling::DataArrayInt32::CheckAndPreparePermutation;
150 %newobject MEDCoupling::DataArrayInt32::__neg__;
151 %newobject MEDCoupling::DataArrayInt32::__add__;
152 %newobject MEDCoupling::DataArrayInt32::__radd__;
153 %newobject MEDCoupling::DataArrayInt32::__sub__;
154 %newobject MEDCoupling::DataArrayInt32::__rsub__;
155 %newobject MEDCoupling::DataArrayInt32::__mul__;
156 %newobject MEDCoupling::DataArrayInt32::__rmul__;
157 %newobject MEDCoupling::DataArrayInt32::__div__;
158 %newobject MEDCoupling::DataArrayInt32::__rdiv__;
159 %newobject MEDCoupling::DataArrayInt32::__mod__;
160 %newobject MEDCoupling::DataArrayInt32::__rmod__;
161 %newobject MEDCoupling::DataArrayInt32::__pow__;
162 %newobject MEDCoupling::DataArrayInt32::__rpow__;
163 %newobject MEDCoupling::DataArrayInt32::convertToInt64Arr;
164 %newobject MEDCoupling::DataArrayInt32Tuple::buildDAInt;
165 %newobject MEDCoupling::DataArrayInt64::New;
166 %newobject MEDCoupling::DataArrayInt64::__iter__;
167 %newobject MEDCoupling::DataArrayInt64::performCopyOrIncrRef;
168 %newobject MEDCoupling::DataArrayInt64::subArray;
169 %newobject MEDCoupling::DataArrayInt64::changeNbOfComponents;
170 %newobject MEDCoupling::DataArrayInt64::accumulatePerChunck;
171 %newobject MEDCoupling::DataArrayInt64::checkAndPreparePermutation;
172 %newobject MEDCoupling::DataArrayInt64::transformWithIndArrR;
173 %newobject MEDCoupling::DataArrayInt64::renumber;
174 %newobject MEDCoupling::DataArrayInt64::renumberR;
175 %newobject MEDCoupling::DataArrayInt64::renumberAndReduce;
176 %newobject MEDCoupling::DataArrayInt64::invertArrayO2N2N2O;
177 %newobject MEDCoupling::DataArrayInt64::invertArrayN2O2O2N;
178 %newobject MEDCoupling::DataArrayInt64::invertArrayO2N2N2OBis;
179 %newobject MEDCoupling::DataArrayInt64::findIdsEqual;
180 %newobject MEDCoupling::DataArrayInt64::findIdsNotEqual;
181 %newobject MEDCoupling::DataArrayInt64::findIdsEqualList;
182 %newobject MEDCoupling::DataArrayInt64::findIdsNotEqualList;
183 %newobject MEDCoupling::DataArrayInt64::findIdsEqualTuple;
184 %newobject MEDCoupling::DataArrayInt64::findIdForEach;
185 %newobject MEDCoupling::DataArrayInt64::sumPerTuple;
186 %newobject MEDCoupling::DataArrayInt64::negate;
187 %newobject MEDCoupling::DataArrayInt64::computeAbs;
188 %newobject MEDCoupling::DataArrayInt64::findIdsInRange;
189 %newobject MEDCoupling::DataArrayInt64::findIdsNotInRange;
190 %newobject MEDCoupling::DataArrayInt64::findIdsStrictlyNegative;
191 %newobject MEDCoupling::DataArrayInt64::Aggregate;
192 %newobject MEDCoupling::DataArrayInt64::AggregateIndexes;
193 %newobject MEDCoupling::DataArrayInt64::Meld;
194 %newobject MEDCoupling::DataArrayInt64::Add;
195 %newobject MEDCoupling::DataArrayInt64::Substract;
196 %newobject MEDCoupling::DataArrayInt64::Multiply;
197 %newobject MEDCoupling::DataArrayInt64::Divide;
198 %newobject MEDCoupling::DataArrayInt64::Pow;
199 %newobject MEDCoupling::DataArrayInt64::BuildUnion;
200 %newobject MEDCoupling::DataArrayInt64::BuildIntersection;
201 %newobject MEDCoupling::DataArrayInt64::Range;
202 %newobject MEDCoupling::DataArrayInt64::indicesOfSubPart;
203 %newobject MEDCoupling::DataArrayInt64::fromNoInterlace;
204 %newobject MEDCoupling::DataArrayInt64::toNoInterlace;
205 %newobject MEDCoupling::DataArrayInt64::buildComplement;
206 %newobject MEDCoupling::DataArrayInt64::buildUnion;
207 %newobject MEDCoupling::DataArrayInt64::buildSubstraction;
208 %newobject MEDCoupling::DataArrayInt64::buildSubstractionOptimized;
209 %newobject MEDCoupling::DataArrayInt64::buildIntersection;
210 %newobject MEDCoupling::DataArrayInt64::indexOfSameConsecutiveValueGroups;
211 %newobject MEDCoupling::DataArrayInt64::buildUnique;
212 %newobject MEDCoupling::DataArrayInt64::buildUniqueNotSorted;
213 %newobject MEDCoupling::DataArrayInt64::deltaShiftIndex;
214 %newobject MEDCoupling::DataArrayInt64::buildExplicitArrByRanges;
215 %newobject MEDCoupling::DataArrayInt64::buildExplicitArrOfSliceOnScaledArr;
216 %newobject MEDCoupling::DataArrayInt64::findRangeIdForEachTuple;
217 %newobject MEDCoupling::DataArrayInt64::findIdInRangeForEachTuple;
218 %newobject MEDCoupling::DataArrayInt64::duplicateEachTupleNTimes;
219 %newobject MEDCoupling::DataArrayInt64::occurenceRankInThis;
220 %newobject MEDCoupling::DataArrayInt64::buildPermutationArr;
221 %newobject MEDCoupling::DataArrayInt64::buildPermArrPerLevel;
222 %newobject MEDCoupling::DataArrayInt64::locateComponentId;
223 %newobject MEDCoupling::DataArrayInt64::getDifferentValues;
224 %newobject MEDCoupling::DataArrayInt64::FindPermutationFromFirstToSecond;
225 %newobject MEDCoupling::DataArrayInt64::FindPermutationFromFirstToSecondDuplicate;
226 %newobject MEDCoupling::DataArrayInt64::CheckAndPreparePermutation;
227 %newobject MEDCoupling::DataArrayInt64::__neg__;
228 %newobject MEDCoupling::DataArrayInt64::__add__;
229 %newobject MEDCoupling::DataArrayInt64::__radd__;
230 %newobject MEDCoupling::DataArrayInt64::__sub__;
231 %newobject MEDCoupling::DataArrayInt64::__rsub__;
232 %newobject MEDCoupling::DataArrayInt64::__mul__;
233 %newobject MEDCoupling::DataArrayInt64::__rmul__;
234 %newobject MEDCoupling::DataArrayInt64::__div__;
235 %newobject MEDCoupling::DataArrayInt64::__rdiv__;
236 %newobject MEDCoupling::DataArrayInt64::__mod__;
237 %newobject MEDCoupling::DataArrayInt64::__rmod__;
238 %newobject MEDCoupling::DataArrayInt64::__pow__;
239 %newobject MEDCoupling::DataArrayInt64::__rpow__;
240 %newobject MEDCoupling::DataArrayInt64::convertToInt32Arr;
241 %newobject MEDCoupling::DataArrayInt64Tuple::buildDAInt;
242 %newobject MEDCoupling::DataArrayChar::convertToIntArr;
243 %newobject MEDCoupling::DataArrayChar::renumber;
244 %newobject MEDCoupling::DataArrayChar::renumberR;
245 %newobject MEDCoupling::DataArrayChar::renumberAndReduce;
246 %newobject MEDCoupling::DataArrayChar::changeNbOfComponents;
247 %newobject MEDCoupling::DataArrayChar::findIdsEqual;
248 %newobject MEDCoupling::DataArrayChar::findIdsNotEqual;
249 %newobject MEDCoupling::DataArrayChar::Aggregate;
250 %newobject MEDCoupling::DataArrayChar::Meld;
251 %newobject MEDCoupling::DataArrayByte::New;
252 %newobject MEDCoupling::DataArrayByte::__iter__;
253 %newobject MEDCoupling::DataArrayByte::performCopyOrIncrRef;
254 %newobject MEDCoupling::DataArrayByteTuple::buildDAByte;
255 %newobject MEDCoupling::DataArrayChar::subArray;
256 %newobject MEDCoupling::DataArrayAsciiChar::New;
257 %newobject MEDCoupling::DataArrayAsciiChar::__iter__;
258 %newobject MEDCoupling::DataArrayAsciiChar::performCopyOrIncrRef;
259 %newobject MEDCoupling::DataArrayAsciiCharTuple::buildDAAsciiChar;
260 %newobject MEDCoupling::DataArrayDouble::New;
261 %newobject MEDCoupling::DataArrayDouble::__iter__;
262 %newobject MEDCoupling::DataArrayDouble::performCopyOrIncrRef;
263 %newobject MEDCoupling::DataArrayDouble::Aggregate;
264 %newobject MEDCoupling::DataArrayDouble::Meld;
265 %newobject MEDCoupling::DataArrayDouble::Dot;
266 %newobject MEDCoupling::DataArrayDouble::CrossProduct;
267 %newobject MEDCoupling::DataArrayDouble::Add;
268 %newobject MEDCoupling::DataArrayDouble::Substract;
269 %newobject MEDCoupling::DataArrayDouble::Multiply;
270 %newobject MEDCoupling::DataArrayDouble::Divide;
271 %newobject MEDCoupling::DataArrayDouble::Pow;
272 %newobject MEDCoupling::DataArrayDouble::symmetry3DPlane;
273 %newobject MEDCoupling::DataArrayDouble::subArray;
274 %newobject MEDCoupling::DataArrayDouble::changeNbOfComponents;
275 %newobject MEDCoupling::DataArrayDouble::accumulatePerChunck;
276 %newobject MEDCoupling::DataArrayDouble::findIdsInRange;
277 %newobject MEDCoupling::DataArrayDouble::findIdsNotInRange;
278 %newobject MEDCoupling::DataArrayDouble::findIdsStrictlyNegative;
279 %newobject MEDCoupling::DataArrayDouble::negate;
280 %newobject MEDCoupling::DataArrayDouble::computeAbs;
281 %newobject MEDCoupling::DataArrayDouble::applyFunc;
282 %newobject MEDCoupling::DataArrayDouble::applyFuncCompo;
283 %newobject MEDCoupling::DataArrayDouble::applyFuncNamedCompo;
284 %newobject MEDCoupling::DataArrayDouble::doublyContractedProduct;
285 %newobject MEDCoupling::DataArrayDouble::determinant;
286 %newobject MEDCoupling::DataArrayDouble::eigenValues;
287 %newobject MEDCoupling::DataArrayDouble::eigenVectors;
288 %newobject MEDCoupling::DataArrayDouble::inverse;
289 %newobject MEDCoupling::DataArrayDouble::trace;
290 %newobject MEDCoupling::DataArrayDouble::deviator;
291 %newobject MEDCoupling::DataArrayDouble::magnitude;
292 %newobject MEDCoupling::DataArrayDouble::maxPerTuple;
293 %newobject MEDCoupling::DataArrayDouble::minPerTuple;
294 %newobject MEDCoupling::DataArrayDouble::sumPerTuple;
295 %newobject MEDCoupling::DataArrayDouble::computeBBoxPerTuple;
296 %newobject MEDCoupling::DataArrayDouble::buildEuclidianDistanceDenseMatrix;
297 %newobject MEDCoupling::DataArrayDouble::buildEuclidianDistanceDenseMatrixWith;
298 %newobject MEDCoupling::DataArrayDouble::renumber;
299 %newobject MEDCoupling::DataArrayDouble::renumberR;
300 %newobject MEDCoupling::DataArrayDouble::renumberAndReduce;
301 %newobject MEDCoupling::DataArrayDouble::fromNoInterlace;
302 %newobject MEDCoupling::DataArrayDouble::toNoInterlace;
303 %newobject MEDCoupling::DataArrayDouble::fromPolarToCart;
304 %newobject MEDCoupling::DataArrayDouble::fromCylToCart;
305 %newobject MEDCoupling::DataArrayDouble::fromSpherToCart;
306 %newobject MEDCoupling::DataArrayDouble::fromCartToPolar;
307 %newobject MEDCoupling::DataArrayDouble::fromCartToCyl;
308 %newobject MEDCoupling::DataArrayDouble::fromCartToSpher;
309 %newobject MEDCoupling::DataArrayDouble::fromCartToCylGiven;
310 %newobject MEDCoupling::DataArrayDouble::cartesianize;
311 %newobject MEDCoupling::DataArrayDouble::getDifferentValues;
312 %newobject MEDCoupling::DataArrayDouble::findClosestTupleId;
313 %newobject MEDCoupling::DataArrayDouble::computeNbOfInteractionsWith;
314 %newobject MEDCoupling::DataArrayDouble::duplicateEachTupleNTimes;
315 %newobject MEDCoupling::DataArrayDouble::__neg__;
316 %newobject MEDCoupling::DataArrayDouble::__radd__;
317 %newobject MEDCoupling::DataArrayDouble::__rsub__;
318 %newobject MEDCoupling::DataArrayDouble::__rmul__;
319 %newobject MEDCoupling::DataArrayDouble::__rdiv__;
320 %newobject MEDCoupling::DataArrayDouble::__pow__;
321 %newobject MEDCoupling::DataArrayDouble::__rpow__;
322 %newobject MEDCoupling::DataArrayDoubleTuple::buildDADouble;
324 %newobject MEDCoupling::PartDefinition::New;
325 %newobject MEDCoupling::PartDefinition::toDAI;
326 %newobject MEDCoupling::PartDefinition::__add__;
327 %newobject MEDCoupling::PartDefinition::composeWith;
328 %newobject MEDCoupling::PartDefinition::tryToSimplify;
329 %newobject MEDCoupling::DataArrayPartDefinition::New;
330 %newobject MEDCoupling::SlicePartDefinition::New;
332 %newobject FromPyIntPtrToDataArrayByte;
335 %feature("unref") DataArray "$this->decrRef();"
336 %feature("unref") DataArrayDouble "$this->decrRef();"
337 %feature("unref") DataArrayInt32 "$this->decrRef();"
338 %feature("unref") DataArrayInt64 "$this->decrRef();"
339 %feature("unref") DataArrayChar "$this->decrRef();"
340 %feature("unref") DataArrayAsciiChar "$this->decrRef();"
341 %feature("unref") DataArrayByte "$this->decrRef();"
343 %feature("unref") MapII "$this->decrRef();"
344 %feature("unref") PartDefinition "$this->decrRef();"
345 %feature("unref") DataArrayPartDefinition "$this->decrRef();"
346 %feature("unref") SlicePartDefinition "$this->decrRef();"
348 namespace MEDCoupling
355 } MEDCouplingAxisType;
357 class DataArrayInt32;
358 class DataArrayInt64;
360 #ifndef MEDCOUPLING_USE_64BIT_IDS
361 typedef DataArrayInt32 DataArrayIdType;
362 #define DataArrayIdType DataArrayInt32
364 typedef DataArrayInt64 DataArrayIdType;
365 #define DataArrayIdType DataArrayInt64
368 class MapII : public RefCountObject, public TimeLabel
371 static MCAuto< MapII > New();
374 class PartDefinition : public RefCountObject, public TimeLabel
377 static PartDefinition *New(int start, int stop, int step);
378 static PartDefinition *New(DataArrayIdType *listOfIds);
379 virtual DataArrayIdType *toDAI() const;
380 virtual int getNumberOfElems() const;
381 virtual std::string getRepr() const;
382 virtual PartDefinition *composeWith(const PartDefinition *other) const;
383 virtual void checkConsistencyLight() const;
384 virtual PartDefinition *tryToSimplify() const;
387 virtual PartDefinition *__add__(const PartDefinition& other) const
389 return (*self)+other;
392 virtual PyObject *isEqual(const PartDefinition *other) const
395 bool ret0(self->isEqual(other,ret1));
396 PyObject *ret=PyTuple_New(2);
397 PyObject *ret0Py=ret0?Py_True:Py_False;
399 PyTuple_SetItem(ret,0,ret0Py);
400 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
404 virtual PyObject *deepCopy() const
406 return convertPartDefinition(self->deepCopy(),SWIG_POINTER_OWN | 0);
410 virtual ~PartDefinition();
413 class DataArrayPartDefinition : public PartDefinition
416 static DataArrayPartDefinition *New(DataArrayIdType *listOfIds);
419 DataArrayPartDefinition(DataArrayIdType *listOfIds)
421 return DataArrayPartDefinition::New(listOfIds);
424 std::string __str__() const
426 return self->getRepr();
429 std::string __repr__() const
431 std::ostringstream oss; oss << "DataArrayPartDefinition C++ instance at " << self << "." << std::endl;
432 oss << self->getRepr();
437 virtual ~DataArrayPartDefinition();
440 class SlicePartDefinition : public PartDefinition
443 static SlicePartDefinition *New(int start, int stop, int step);
444 int getEffectiveStop() const;
447 SlicePartDefinition(mcIdType start, mcIdType stop, mcIdType step)
449 return SlicePartDefinition::New(start,stop,step);
452 PyObject *getSlice() const
455 self->getSlice(a,b,c);
456 return PySlice_New(PyInt_FromLong(a),PyInt_FromLong(b),PyInt_FromLong(c));
459 std::string __str__() const
461 return self->getRepr();
464 std::string __repr__() const
466 std::ostringstream oss; oss << "SlicePartDefinition C++ instance at " << self << "." << std::endl;
467 oss << self->getRepr();
472 virtual ~SlicePartDefinition();
475 class DataArray : public RefCountObject, public TimeLabel
478 void setName(const std::string& name);
479 void copyStringInfoFrom(const DataArray& other);
480 void copyPartOfStringInfoFrom(const DataArray& other, const std::vector<std::size_t>& compoIds);
481 void copyPartOfStringInfoFrom2(const std::vector<std::size_t>& compoIds, const DataArray& other);
482 bool areInfoEqualsIfNotWhy(const DataArray& other, std::string& reason) const;
483 bool areInfoEquals(const DataArray& other) const;
484 std::string cppRepr(const std::string& varName) const;
485 std::string getName() const;
486 void setInfoOnComponents(const std::vector<std::string>& info);
487 void setInfoAndChangeNbOfCompo(const std::vector<std::string>& info);
488 std::vector<std::string> getVarsOnComponent() const;
489 std::vector<std::string> getUnitsOnComponent() const;
490 std::string getInfoOnComponent(int i) const;
491 std::string getVarOnComponent(int i) const;
492 std::string getUnitOnComponent(int i) const;
493 void setInfoOnComponent(int i, const std::string& info);
494 int getNumberOfComponents() const;
495 virtual void alloc(int nbOfTuple, int nbOfCompo=1);
496 virtual void reAlloc(int nbOfTuples);
497 virtual bool isAllocated() const;
498 virtual void checkAllocated() const;
499 virtual void desallocate();
500 virtual int getNumberOfTuples() const;
501 virtual std::size_t getNbOfElems() const;
502 virtual std::size_t getNbOfElemAllocated() const;
503 virtual DataArray *deepCopy() const;
504 virtual DataArray *copySorted() const;
505 virtual DataArray *buildNewEmptyInstance() const;
506 virtual DataArray *selectByTupleIdSafeSlice(int bg, int end2, int step) const;
507 virtual void rearrange(int newNbOfCompo);
508 virtual void circularPermutation(int nbOfShift=1);
509 virtual void circularPermutationPerTuple(int nbOfShift=1);
510 virtual void reversePerTuple();
511 void checkNbOfTuples(int nbOfTuples, const std::string& msg) const;
512 void checkNbOfComps(int nbOfCompo, const std::string& msg) const;
513 void checkNbOfTuplesAndComp(const DataArray& other, const std::string& msg) const;
514 void checkNbOfTuplesAndComp(int nbOfTuples, int nbOfCompo, const std::string& msg) const;
515 void checkNbOfElems(mcIdType nbOfElems, const std::string& msg) const;
516 static int GetNumberOfItemGivenBES(int begin, int end, int step, const std::string& msg);
517 static int GetNumberOfItemGivenBESRelative(int begin, int end, int step, const std::string& msg);
518 static int GetPosOfItemGivenBESRelativeNoThrow(int value, int begin, int end, int step);
519 static std::string GetVarNameFromInfo(const std::string& info);
520 static std::string GetUnitFromInfo(const std::string& info);
521 static std::string BuildInfoFromVarAndUnit(const std::string& var, const std::string& unit);
522 static std::string GetAxisTypeRepr(MEDCouplingAxisType at);
523 void updateTime() const;
526 PyObject *getInfoOnComponents() const
528 const std::vector<std::string>& comps=self->getInfoOnComponents();
529 PyObject *ret=PyList_New((mcIdType)comps.size());
530 for(std::size_t i=0;i<comps.size();i++)
531 PyList_SetItem(ret,i,PyString_FromString(comps[i].c_str()));
535 void copyPartOfStringInfoFrom(const DataArray& other, PyObject *li)
537 std::vector<std::size_t> tmp;
538 convertPyToNewIntArr3(li,tmp);
539 self->copyPartOfStringInfoFrom(other,tmp);
542 void copyPartOfStringInfoFrom2(PyObject *li, const DataArray& other)
544 std::vector<std::size_t> tmp;
545 convertPyToNewIntArr3(li,tmp);
546 self->copyPartOfStringInfoFrom2(tmp,other);
549 virtual void renumberInPlace(PyObject *li)
552 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
553 if (!SWIG_IsOK(res1))
556 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
557 if(size!=self->getNumberOfTuples())
559 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
561 self->renumberInPlace(tmp);
565 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
567 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
568 da2->checkAllocated();
569 mcIdType size=self->getNumberOfTuples();
570 if(size!=self->getNumberOfTuples())
572 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
574 self->renumberInPlace(da2->getConstPointer());
578 virtual void renumberInPlaceR(PyObject *li)
581 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
582 if (!SWIG_IsOK(res1))
585 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
586 if(size!=self->getNumberOfTuples())
588 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
590 self->renumberInPlaceR(tmp);
594 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
596 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
597 da2->checkAllocated();
598 mcIdType size=self->getNumberOfTuples();
599 if(size!=self->getNumberOfTuples())
601 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
603 self->renumberInPlaceR(da2->getConstPointer());
607 //tuplesSelec in PyObject * because DataArrayInt is not already existing !
608 virtual void setContigPartOfSelectedValues(mcIdType tupleIdStart, PyObject *aBase, PyObject *tuplesSelec)
610 static const char msg[]="DataArray::setContigPartOfSelectedValuesSlice : 4th parameter \"tuplesSelec\" should be of type DataArrayInt";
611 DataArray *a=CheckAndRetrieveDataArrayInstance(aBase,"DataArray::setContigPartOfSelectedValuesSlice : 3rd parameter \"aBase\" should be of type DataArray");
612 DataArray *tuplesSelecPtr=CheckAndRetrieveDataArrayInstance(tuplesSelec,msg);
613 DataArrayIdType *tuplesSelecPtr2=0;
616 tuplesSelecPtr2=dynamic_cast<DataArrayIdType *>(tuplesSelecPtr);
618 throw INTERP_KERNEL::Exception(msg);
620 self->setContigPartOfSelectedValues(tupleIdStart,a,tuplesSelecPtr2);
623 virtual void setContigPartOfSelectedValuesSlice(mcIdType tupleIdStart, PyObject *aBase, mcIdType bg, mcIdType end2, mcIdType step)
625 DataArray *a=CheckAndRetrieveDataArrayInstance(aBase,"DataArray::setContigPartOfSelectedValuesSlice : 2nd parameter \"aBase\" should be of type DataArray");
626 self->setContigPartOfSelectedValuesSlice(tupleIdStart,a,bg,end2,step);
629 virtual DataArray *selectByTupleRanges(PyObject *li) const
631 std::vector<std::pair<mcIdType,mcIdType> > ranges;
632 convertPyToVectorPairInt(li,ranges);
633 return self->selectByTupleRanges(ranges);
636 virtual DataArray *selectByTupleId(PyObject *li) const
639 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
640 if (!SWIG_IsOK(res1))
643 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
644 return self->selectByTupleId(tmp,tmp+size);
648 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
650 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
651 da2->checkAllocated();
652 return self->selectByTupleId(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
656 virtual DataArray *selectByTupleIdSafe(PyObject *li) const
659 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
660 if (!SWIG_IsOK(res1))
663 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
664 return self->selectByTupleIdSafe(tmp,tmp+size);
668 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
670 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
671 da2->checkAllocated();
672 return self->selectByTupleIdSafe(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
676 virtual PyObject *keepSelectedComponents(PyObject *li) const
678 std::vector<std::size_t> tmp;
679 convertPyToNewIntArr3(li,tmp);
680 DataArray *ret=self->keepSelectedComponents(tmp);
681 return convertDataArray(ret,SWIG_POINTER_OWN | 0 );
684 static PyObject *GetSlice(PyObject *slic, mcIdType sliceId, mcIdType nbOfSlices)
686 if(!PySlice_Check(slic))
687 throw INTERP_KERNEL::Exception("DataArray::GetSlice (wrap) : expecting a pyslice as second (first) parameter !");
688 Py_ssize_t strt=2,stp=2,step=2;
689 GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetSlice (wrap) : the input slice is invalid !");
691 DataArray::GetSlice(ToIdType(strt),ToIdType(stp),ToIdType(step),sliceId,nbOfSlices,a,b);
692 AutoPyPtr ap(PyInt_FromLong(a)),bp(PyInt_FromLong(b)),stepp(PyInt_FromLong(step));
693 return PySlice_New(ap,bp,stepp);
696 PyObject *getSlice(PyObject *slic, mcIdType sliceId, mcIdType nbOfSlices) const
698 if(!PySlice_Check(slic))
699 throw INTERP_KERNEL::Exception("DataArray::getSlice (wrap) : expecting a pyslice as second (first) parameter !");
700 Py_ssize_t strt=2,stp=2,step=2;
701 GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getSlice (wrap) : the input slice is invalid !");
703 DataArray::GetSlice(ToIdType(strt),ToIdType(stp),ToIdType(step),sliceId,nbOfSlices,a,b);
704 AutoPyPtr ap(PyInt_FromLong(a)),bp(PyInt_FromLong(b)),stepp(PyInt_FromLong(step));
705 return PySlice_New(ap,bp,stepp);
708 static mcIdType GetNumberOfItemGivenBES(PyObject *slic)
710 if(!PySlice_Check(slic))
711 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBES (wrap) : expecting a pyslice as second (first) parameter !");
712 Py_ssize_t strt=2,stp=2,step=2;
713 GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetNumberOfItemGivenBES (wrap) : the input slice is invalid !");
714 return DataArray::GetNumberOfItemGivenBES(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
717 static mcIdType GetNumberOfItemGivenBESRelative(PyObject *slic)
719 if(!PySlice_Check(slic))
720 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBESRelative (wrap) : expecting a pyslice as second (first) parameter !");
721 Py_ssize_t strt=2,stp=2,step=2;
722 GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !");
723 return DataArray::GetNumberOfItemGivenBESRelative(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
726 static DataArray *Aggregate(PyObject *arrs)
728 std::vector<const DataArray *> tmp;
729 convertFromPyObjVectorOfObj<const MEDCoupling::DataArray *>(arrs,SWIGTYPE_p_MEDCoupling__DataArray,"DataArray",tmp);
730 return DataArray::Aggregate(tmp);
733 mcIdType getNumberOfItemGivenBES(PyObject *slic) const
735 if(!PySlice_Check(slic))
736 throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBES (wrap) : expecting a pyslice as second (first) parameter !");
737 Py_ssize_t strt=2,stp=2,step=2;
738 GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getNumberOfItemGivenBES (wrap) : the input slice is invalid !");
739 return DataArray::GetNumberOfItemGivenBES(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
742 mcIdType getNumberOfItemGivenBESRelative(PyObject *slic)
744 if(!PySlice_Check(slic))
745 throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBESRelative (wrap) : expecting a pyslice as second (first) parameter !");
746 Py_ssize_t strt=2,stp=2,step=2;
747 GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !");
748 return DataArray::GetNumberOfItemGivenBESRelative(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
751 PyObject *__getstate__() const
753 PyObject *ret(PyTuple_New(2));
754 std::string a0(self->getName());
755 const std::vector<std::string> &a1(self->getInfoOnComponents());
756 PyTuple_SetItem(ret,0,PyString_FromString(a0.c_str()));
758 std::size_t sz(a1.size());
759 PyObject *ret1(PyList_New(sz));
760 for(std::size_t i=0;i<sz;i++)
761 PyList_SetItem(ret1,i,PyString_FromString(a1[i].c_str()));
762 PyTuple_SetItem(ret,1,ret1);
767 void __setstate__(PyObject *inp)
769 static const char MSG[]="DataArrayDouble.__setstate__ : expected input is a tuple of size 2 with string as 1st arg and list of string as 2nd arg !";
770 if(!PyTuple_Check(inp))
771 throw INTERP_KERNEL::Exception("DataArrayDouble.__setstate__ : invalid input ! Invalid overwrite of __getstate__ ?");
772 std::size_t sz(PyTuple_Size(inp));
774 throw INTERP_KERNEL::Exception("DataArrayDouble.__setstate__ : invalid tuple in input ! Should be of size 2 ! Invalid overwrite of __getstate__ ?");
775 PyObject *a0(PyTuple_GetItem(inp,0));
776 self->setName(convertPyObjectToStr(a0,MSG));
777 PyObject *a1(PyTuple_GetItem(inp,1));
778 std::vector<std::string> a1cpp;
779 if(!fillStringVector(a1,a1cpp))
780 throw INTERP_KERNEL::Exception(MSG);
781 self->setInfoOnComponents(a1cpp);
786 class DataArrayDouble;
788 class DataArrayFloat : public DataArray
791 static DataArrayFloat *New();
792 void fillWithValue(float val);
793 bool isEqual(const DataArrayFloat& other, float prec) const;
794 bool isEqualWithoutConsideringStr(const DataArrayFloat& other, float prec) const;
795 bool isUniform(float val, float eps) const;
796 void pushBackSilent(float val);
797 void iota(float init=0.);
798 DataArrayFloatIterator *iterator();
799 MCAuto<DataArrayDouble> convertToDblArr() const;
800 static DataArrayFloat *Meld(const DataArrayFloat *a1, const DataArrayFloat *a2);
805 return DataArrayFloat::New();
808 static DataArrayFloat *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
810 return DataArrayT_New<float>(elt0,nbOfTuples,elt2);
813 DataArrayFloat(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
815 return MEDCoupling_DataArrayFloat_New__SWIG_1(elt0,nbOfTuples,elt2);
818 DataArrayFloatIterator *__iter__()
820 return self->iterator();
823 std::string __repr__() const
825 std::ostringstream oss;
826 self->reprQuickOverview(oss);
830 std::string __str__() const
832 return self->reprNotTooLong();
835 mcIdType __len__() const
837 if(self->isAllocated())
839 return self->getNumberOfTuples();
843 throw INTERP_KERNEL::Exception("DataArrayFloat::__len__ : Instance is NOT allocated !");
847 PyObject *getValues() const
849 const float *vals(self->begin());
850 return convertDblArrToPyList<float>(vals,self->getNbOfElems());
853 PyObject *getValuesAsTuple() const
855 const float *vals(self->begin());
856 std::size_t nbOfComp(self->getNumberOfComponents());
857 mcIdType nbOfTuples(self->getNumberOfTuples());
858 return convertDblArrToPyListOfTuple<float>(vals,nbOfComp,nbOfTuples);
861 PyObject *isEqualIfNotWhy(const DataArrayFloat& other, float prec) const
864 bool ret0=self->isEqualIfNotWhy(other,prec,ret1);
865 PyObject *ret=PyTuple_New(2);
866 PyObject *ret0Py=ret0?Py_True:Py_False;
868 PyTuple_SetItem(ret,0,ret0Py);
869 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
873 PyObject *__getitem__(PyObject *obj)
875 return DataArrayT__getitem<float>(self,obj);
878 DataArrayFloat *__setitem__(PyObject *obj, PyObject *value)
880 return DataArrayT__setitem__<float>(self,obj,value);
883 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
885 return DataArrayT_iadd<float>(trueSelf,obj,self);
888 PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
890 return DataArrayT_isub<float>(trueSelf,obj,self);
893 PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
895 return DataArrayT_imul<float>(trueSelf,obj,self);
898 DataArrayFloat *__rmul__(PyObject *obj)
900 return DataArrayFPT_rmul<float>(self,obj);
903 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
905 return DataArrayT_idiv<float>(trueSelf,obj,self);
909 PyObject *toNumPyArray() // not const. It is not a bug !
911 return ToNumPyArray<DataArrayFloat,float>(self,NPY_FLOAT,"DataArrayFloat");
917 class DataArrayFloatTuple;
919 class DataArrayFloatIterator
922 DataArrayFloatIterator(DataArrayFloat *da);
923 ~DataArrayFloatIterator();
928 DataArrayFloatTuple *ret=self->nextt();
930 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayFloatTuple,SWIG_POINTER_OWN|0);
933 PyErr_SetString(PyExc_StopIteration,"No more data.");
940 class DataArrayFloatTuple
943 std::size_t getNumberOfCompo() const;
944 DataArrayFloat *buildDAFloat(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
947 std::string __str__() const
952 float __float__() const
954 return self->floatValue();
957 DataArrayFloat *buildDAFloat()
959 return self->buildDAFloat(1,self->getNumberOfCompo());
962 /*PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
964 MCAuto<DataArrayFloat> ret=self->buildDAFloat(1,self->getNumberOfCompo());
965 MEDCoupling_DataArrayFloat____imul___(ret,0,obj);
966 Py_XINCREF(trueSelf);
972 return PyInt_FromLong(self->getNumberOfCompo());
977 class DataArrayDoubleIterator;
979 class DataArrayDouble : public DataArray
982 static DataArrayDouble *New();
983 double doubleValue() const;
985 void aggregate(const DataArrayDouble *other);
986 DataArrayDouble *performCopyOrIncrRef(bool deepCopy) const;
987 void deepCopyFrom(const DataArrayDouble& other);
988 void reserve(std::size_t nbOfElems);
989 void pushBackSilent(double val);
990 double popBackSilent();
992 void allocIfNecessary(int nbOfTuple, int nbOfCompo);
994 void fillWithValue(double val);
995 void iota(double init=0.);
996 bool isUniform(double val, double eps) const;
997 void sort(bool asc=true);
999 void checkMonotonic(bool increasing, double eps) const;
1000 bool isMonotonic(bool increasing, double eps) const;
1001 std::string repr() const;
1002 std::string reprZip() const;
1003 std::string reprNotTooLong() const;
1004 bool isEqual(const DataArrayDouble& other, double prec) const;
1005 bool isEqualWithoutConsideringStr(const DataArrayDouble& other, double prec) const;
1006 DataArrayDouble *fromNoInterlace() const;
1007 DataArrayDouble *toNoInterlace() const;
1008 DataArrayDouble *subArray(int tupleIdBg, int tupleIdEnd=-1) const;
1010 DataArrayDouble *changeNbOfComponents(std::size_t newNbOfComp, double dftValue) const;
1011 void meldWith(const DataArrayDouble *other);
1012 DataArrayDouble *duplicateEachTupleNTimes(int nbTimes) const;
1013 DataArrayDouble *getDifferentValues(double prec, int limitTupleId=-1) const;
1014 DataArrayIdType *findClosestTupleId(const DataArrayDouble *other) const;
1015 DataArrayIdType *computeNbOfInteractionsWith(const DataArrayDouble *otherBBoxFrmt, double eps) const;
1016 void setPartOfValues1(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare=true);
1017 void setPartOfValuesSimple1(double a, mcIdType bgTuples, mcIdType endTuples, mcIdType stepTuples, mcIdType bgComp, mcIdType endComp, mcIdType stepComp);
1018 void setPartOfValuesAdv(const DataArrayDouble *a, const DataArrayIdType *tuplesSelec);
1019 double getIJ(int tupleId, int compoId) const;
1020 double front() const;
1021 double back() const;
1022 double getIJSafe(int tupleId, int compoId) const;
1023 void setIJ(int tupleId, int compoId, double newVal);
1024 void setIJSilent(int tupleId, int compoId, double newVal);
1025 double *getPointer();
1026 void checkNoNullValues() const;
1027 DataArrayDouble *computeBBoxPerTuple(double epsilon=0.0) const;
1028 void recenterForMaxPrecision(double eps);
1029 double getMaxValueInArray() const;
1030 double getMaxAbsValueInArray() const;
1031 double getMinValueInArray() const;
1032 int count(double value, double eps) const;
1033 double getAverageValue() const;
1034 double norm2() const;
1035 double normMax() const;
1036 double normMin() const;
1037 double accumulate(int compId) const;
1038 DataArrayDouble *fromPolarToCart() const;
1039 DataArrayDouble *fromCylToCart() const;
1040 DataArrayDouble *fromSpherToCart() const;
1041 DataArrayDouble *fromCartToPolar() const;
1042 DataArrayDouble *fromCartToCyl() const;
1043 DataArrayDouble *fromCartToSpher() const;
1044 DataArrayDouble *cartesianize(MEDCouplingAxisType atOfThis) const;
1045 DataArrayDouble *doublyContractedProduct() const;
1046 DataArrayDouble *determinant() const;
1047 DataArrayDouble *eigenValues() const;
1048 DataArrayDouble *eigenVectors() const;
1049 DataArrayDouble *inverse() const;
1050 DataArrayDouble *trace() const;
1051 DataArrayDouble *deviator() const;
1052 DataArrayDouble *magnitude() const;
1053 DataArrayDouble *maxPerTuple() const;
1054 DataArrayDouble *minPerTuple() const;
1055 DataArrayDouble *sumPerTuple() const;
1056 DataArrayDouble *buildEuclidianDistanceDenseMatrix() const;
1057 DataArrayDouble *buildEuclidianDistanceDenseMatrixWith(const DataArrayDouble *other) const;
1058 void sortPerTuple(bool asc);
1060 DataArrayDouble *computeAbs() const;
1061 void applyLin(double a, double b, int compoId);
1062 void applyLin(double a, double b);
1063 void applyInv(double numerator);
1064 void applyPow(double val);
1065 void applyRPow(double val);
1066 DataArrayDouble *negate() const;
1067 DataArrayDouble *applyFunc(int nbOfComp, FunctionToEvaluate func) const;
1068 DataArrayDouble *applyFunc(int nbOfComp, const std::string& func, bool isSafe=true) const;
1069 DataArrayDouble *applyFunc(const std::string& func, bool isSafe=true) const;
1070 void applyFuncOnThis(const std::string& func, bool isSafe=true);
1071 DataArrayDouble *applyFuncCompo(int nbOfComp, const std::string& func, bool isSafe=true) const;
1072 DataArrayDouble *applyFuncNamedCompo(int nbOfComp, const std::vector<std::string>& varsOrder, const std::string& func, bool isSafe=true) const;
1073 void applyFuncFast32(const std::string& func);
1074 void applyFuncFast64(const std::string& func);
1075 DataArrayIdType *findIdsInRange(double vmin, double vmax) const;
1076 DataArrayIdType *findIdsNotInRange(double vmin, double vmax) const;
1077 DataArrayIdType *findIdsStrictlyNegative() const;
1078 static DataArrayDouble *Aggregate(const DataArrayDouble *a1, const DataArrayDouble *a2);
1079 static DataArrayDouble *Meld(const DataArrayDouble *a1, const DataArrayDouble *a2);
1080 static DataArrayDouble *Dot(const DataArrayDouble *a1, const DataArrayDouble *a2);
1081 static DataArrayDouble *CrossProduct(const DataArrayDouble *a1, const DataArrayDouble *a2);
1082 static DataArrayDouble *Max(const DataArrayDouble *a1, const DataArrayDouble *a2);
1083 static DataArrayDouble *Min(const DataArrayDouble *a1, const DataArrayDouble *a2);
1084 static DataArrayDouble *Add(const DataArrayDouble *a1, const DataArrayDouble *a2);
1085 void addEqual(const DataArrayDouble *other);
1086 static DataArrayDouble *Substract(const DataArrayDouble *a1, const DataArrayDouble *a2);
1087 void substractEqual(const DataArrayDouble *other);
1088 static DataArrayDouble *Multiply(const DataArrayDouble *a1, const DataArrayDouble *a2);
1089 void multiplyEqual(const DataArrayDouble *other);
1090 static DataArrayDouble *Divide(const DataArrayDouble *a1, const DataArrayDouble *a2);
1091 void divideEqual(const DataArrayDouble *other);
1092 static DataArrayDouble *Pow(const DataArrayDouble *a1, const DataArrayDouble *a2);
1093 void powEqual(const DataArrayDouble *other);
1094 MCAuto<DataArrayIdType> findIdsGreaterOrEqualTo(double val) const;
1095 MCAuto<DataArrayIdType> findIdsGreaterThan(double val) const;
1096 MCAuto<DataArrayIdType> findIdsLowerOrEqualTo(double val) const;
1097 MCAuto<DataArrayIdType> findIdsLowerThan(double val) const;
1098 MCAuto<DataArrayInt32> convertToIntArr() const;
1099 MCAuto<DataArrayInt64> convertToInt64Arr() const;
1100 MCAuto<DataArrayDouble> selectPartDef(const PartDefinition* pd) const;
1101 MCAuto<DataArrayDouble> cumSum() const;
1102 MCAuto<DataArrayFloat> convertToFloatArr() const;
1107 return DataArrayDouble::New();
1110 static DataArrayDouble *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
1112 return DataArrayT_New<double>(elt0,nbOfTuples,elt2);
1115 DataArrayDouble(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
1117 return MEDCoupling_DataArrayDouble_New__SWIG_1(elt0,nbOfTuples,elt2);
1120 void pushBackValsSilent(PyObject *li)
1123 std::vector<double> bb;
1124 mcIdType sw; mcIdType nbTuples=-1;
1125 const char msg[]="Python wrap of DataArrayDouble::pushBackValsSilent : ";
1126 const double *tmp=convertObjToPossibleCpp5_SingleCompo(li,sw,val,bb,msg,true,nbTuples);
1127 self->pushBackValsSilent(tmp,tmp+nbTuples);
1130 std::string __repr__() const
1132 std::ostringstream oss;
1133 self->reprQuickOverview(oss);
1137 std::string __str__() const
1139 return self->reprNotTooLong();
1142 double __float__() const
1144 return self->doubleValue();
1147 mcIdType __len__() const
1149 if(self->isAllocated())
1151 return self->getNumberOfTuples();
1155 throw INTERP_KERNEL::Exception("DataArrayDouble::__len__ : Instance is NOT allocated !");
1159 PyObject *asArcOfCircle() const
1161 double center[2],radius,ang;
1162 self->asArcOfCircle(center,radius,ang);
1163 PyObject *ret(PyTuple_New(3));
1165 PyObject *ret0(PyList_New(2));
1166 PyList_SetItem(ret0,0,PyFloat_FromDouble(center[0]));
1167 PyList_SetItem(ret0,1,PyFloat_FromDouble(center[1]));
1168 PyTuple_SetItem(ret,0,ret0);
1170 PyTuple_SetItem(ret,1,PyFloat_FromDouble(radius));
1171 PyTuple_SetItem(ret,2,PyFloat_FromDouble(ang));
1175 DataArrayDoubleIterator *__iter__()
1177 return self->iterator();
1180 void setValues(PyObject *li, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
1182 const char *msg="MEDCoupling::DataArrayDouble::setValues : Available API are : \n-DataArrayDouble.setValues([1.,3.,4.])\n-DataArrayDouble.setValues([1.,3.,4.],3)\n-DataArrayDouble.setValues([1.,3.,4.,5.],2,2)\n-DataArrayDouble.setValues([(1.,1.7),(3.,3.7),(4.,4.7)])\n !";
1183 if(PyList_Check(li) || PyTuple_Check(li))
1185 if(nbOfTuples && nbOfTuples != Py_None)
1187 if(PyInt_Check(nbOfTuples))
1189 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
1191 throw INTERP_KERNEL::Exception("DataArrayDouble::setValues : should be a positive set of allocated memory !");
1192 if(nbOfComp && nbOfComp != Py_None)
1194 if(PyInt_Check(nbOfComp))
1195 {//DataArrayDouble.setValues([1.,3.,4.,5.],2,2)
1196 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
1198 throw INTERP_KERNEL::Exception("DataArrayDouble::setValues : should be a positive number of components !");
1199 std::vector<double> tmp=fillArrayWithPyListDbl2(li,nbOfTuples1,nbOfCompo);
1200 self->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1203 throw INTERP_KERNEL::Exception(msg);
1206 {//DataArrayDouble.setValues([1.,3.,4.],3)
1208 std::vector<double> tmp=fillArrayWithPyListDbl2(li,nbOfTuples1,tmpp1);
1209 self->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1213 throw INTERP_KERNEL::Exception(msg);
1216 {// DataArrayDouble.setValues([1.,3.,4.])
1217 mcIdType tmpp1=-1,tmpp2=-1;
1218 std::vector<double> tmp=fillArrayWithPyListDbl2(li,tmpp1,tmpp2);
1219 self->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1223 throw INTERP_KERNEL::Exception(msg);
1226 PyObject *getValues() const
1228 const double *vals(self->begin());
1229 return convertDblArrToPyList<double>(vals,self->getNbOfElems());
1233 PyObject *toNumPyArray() // not const. It is not a bug !
1235 return ToNumPyArray<DataArrayDouble,double>(self,NPY_DOUBLE,"DataArrayDouble");
1239 PyObject *isEqualIfNotWhy(const DataArrayDouble& other, double prec) const
1242 bool ret0=self->isEqualIfNotWhy(other,prec,ret1);
1243 PyObject *ret=PyTuple_New(2);
1244 PyObject *ret0Py=ret0?Py_True:Py_False;
1246 PyTuple_SetItem(ret,0,ret0Py);
1247 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
1251 PyObject *getValuesAsTuple() const
1253 const double *vals(self->begin());
1254 std::size_t nbOfComp(self->getNumberOfComponents());
1255 mcIdType nbOfTuples(self->getNumberOfTuples());
1256 return convertDblArrToPyListOfTuple<double>(vals,nbOfComp,nbOfTuples);
1259 static PyObject *ComputeIntegralOfSeg2IntoTri3(PyObject *seg2, PyObject *tri3)
1261 const char msg[]="Python wrap of DataArrayDouble::ComputeIntegralOfSeg2IntoTri3 : ";
1263 DataArrayDouble *a,*a2;
1264 DataArrayDoubleTuple *aa,*aa2;
1265 std::vector<double> bb,bb2;
1267 const double *seg2Ptr(convertObjToPossibleCpp5_Safe(seg2,sw,val,a,aa,bb,msg,2,2,true));
1268 const double *tri3Ptr(convertObjToPossibleCpp5_Safe(tri3,sw,val2,a2,aa2,bb2,msg,3,2,true));
1270 double res0[3],res1;
1271 DataArrayDouble::ComputeIntegralOfSeg2IntoTri3(seg2Ptr,tri3Ptr,res0,res1);
1272 PyObject *ret(PyTuple_New(2)),*ret0(PyTuple_New(3));
1273 PyTuple_SetItem(ret0,0,PyFloat_FromDouble(res0[0]));
1274 PyTuple_SetItem(ret0,1,PyFloat_FromDouble(res0[1]));
1275 PyTuple_SetItem(ret0,2,PyFloat_FromDouble(res0[2]));
1276 PyTuple_SetItem(ret,0,ret0);
1277 PyTuple_SetItem(ret,1,PyFloat_FromDouble(res1));
1281 DataArrayDouble *symmetry3DPlane(PyObject *point, PyObject *normalVector)
1283 const char msg[]="Python wrap of DataArrayDouble::symmetry3DPlane : ";
1285 DataArrayDouble *a,*a2;
1286 DataArrayDoubleTuple *aa,*aa2;
1287 std::vector<double> bb,bb2;
1289 const double *centerPtr(convertObjToPossibleCpp5_Safe(point,sw,val,a,aa,bb,msg,1,3,true));
1290 const double *vectorPtr(convertObjToPossibleCpp5_Safe(normalVector,sw,val2,a2,aa2,bb2,msg,1,3,true));
1291 MCAuto<DataArrayDouble> ret(self->symmetry3DPlane(centerPtr,vectorPtr));
1295 static PyObject *GiveBaseForPlane(PyObject *normalVector)
1297 const char msg[]="Python wrap of DataArrayDouble::GiveBaseForPlane : ";
1300 DataArrayDoubleTuple *aa;
1301 std::vector<double> bb,bb2;
1303 const double *vectorPtr(convertObjToPossibleCpp5_Safe(normalVector,sw,val,a,aa,bb,msg,1,3,true));
1305 DataArrayDouble::GiveBaseForPlane(vectorPtr,res);
1306 return convertDblArrToPyListOfTuple<double>(res,3,3);
1309 DataArrayDouble *fromCartToCylGiven(const DataArrayDouble *coords, PyObject *center, PyObject *vector) const
1311 const char msg[]="Python wrap of DataArrayDouble::fromCartToCylGiven : ";
1313 DataArrayDouble *a,*a2;
1314 DataArrayDoubleTuple *aa,*aa2;
1315 std::vector<double> bb,bb2;
1317 const double *centerPtr=convertObjToPossibleCpp5_Safe(center,sw,val,a,aa,bb,msg,1,3,true);
1318 const double *vectorPtr=convertObjToPossibleCpp5_Safe(vector,sw,val2,a2,aa2,bb2,msg,1,3,true);
1319 return self->fromCartToCylGiven(coords,centerPtr,vectorPtr);
1322 DataArrayDouble *renumber(PyObject *li)
1325 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
1326 if (!SWIG_IsOK(res1))
1329 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1330 if(size!=self->getNumberOfTuples())
1332 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1334 return self->renumber(tmp);
1338 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1340 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1341 da2->checkAllocated();
1342 mcIdType size=self->getNumberOfTuples();
1343 if(size!=self->getNumberOfTuples())
1345 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1347 return self->renumber(da2->getConstPointer());
1351 DataArrayDouble *renumberR(PyObject *li)
1354 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
1355 if (!SWIG_IsOK(res1))
1358 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1359 if(size!=self->getNumberOfTuples())
1361 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1363 return self->renumberR(tmp);
1367 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1369 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1370 da2->checkAllocated();
1371 mcIdType size=self->getNumberOfTuples();
1372 if(size!=self->getNumberOfTuples())
1374 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1376 return self->renumberR(da2->getConstPointer());
1380 DataArrayDouble *renumberAndReduce(PyObject *li, mcIdType newNbOfTuple)
1383 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
1384 if (!SWIG_IsOK(res1))
1387 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1388 if(size!=self->getNumberOfTuples())
1390 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1392 return self->renumberAndReduce(tmp,newNbOfTuple);
1396 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1398 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1399 da2->checkAllocated();
1400 mcIdType size=self->getNumberOfTuples();
1401 if(size!=self->getNumberOfTuples())
1403 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1405 return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
1409 PyObject *minimalDistanceTo(const DataArrayDouble *other) const
1411 mcIdType thisTupleId,otherTupleId;
1412 double r0=self->minimalDistanceTo(other,thisTupleId,otherTupleId);
1413 PyObject *ret=PyTuple_New(3);
1414 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r0));
1415 PyTuple_SetItem(ret,1,PyInt_FromLong(thisTupleId));
1416 PyTuple_SetItem(ret,2,PyInt_FromLong(otherTupleId));
1420 PyObject *getMaxValue() const
1423 double r1=self->getMaxValue(tmp);
1424 PyObject *ret=PyTuple_New(2);
1425 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1426 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1430 PyObject *getMaxAbsValue() const
1433 double r1=self->getMaxAbsValue(tmp);
1434 PyObject *ret=PyTuple_New(2);
1435 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1436 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1440 PyObject *getMaxValue2() const
1442 DataArrayIdType *tmp;
1443 double r1=self->getMaxValue2(tmp);
1444 PyObject *ret=PyTuple_New(2);
1445 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1446 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1450 PyObject *getMinValue() const
1453 double r1=self->getMinValue(tmp);
1454 PyObject *ret=PyTuple_New(2);
1455 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1456 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1460 PyObject *getMinValue2() const
1462 DataArrayIdType *tmp;
1463 double r1=self->getMinValue2(tmp);
1464 PyObject *ret=PyTuple_New(2);
1465 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1466 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1470 PyObject *getMinMaxPerComponent() const
1472 std::size_t nbOfCompo(self->getNumberOfComponents());
1473 INTERP_KERNEL::AutoPtr<double> tmp(new double[2*nbOfCompo]);
1474 self->getMinMaxPerComponent(tmp);
1475 PyObject *ret=convertDblArrToPyListOfTuple<double>(tmp,2,ToIdType(nbOfCompo));
1479 PyObject *normMaxPerComponent() const
1481 std::size_t nbOfCompo(self->getNumberOfComponents());
1482 INTERP_KERNEL::AutoPtr<double> tmp(new double[nbOfCompo]);
1483 self->normMaxPerComponent(tmp);
1484 return convertDblArrToPyList<double>(tmp,ToIdType(nbOfCompo));
1487 PyObject *accumulate() const
1489 std::size_t sz=self->getNumberOfComponents();
1490 INTERP_KERNEL::AutoPtr<double> tmp=new double[sz];
1491 self->accumulate(tmp);
1492 return convertDblArrToPyList<double>(tmp,ToIdType(sz));
1495 DataArrayDouble *accumulatePerChunck(PyObject *indexArr) const
1497 mcIdType sw, sz,val;
1498 std::vector<mcIdType> val2;
1499 const mcIdType *bg=convertIntStarLikePyObjToCppIntStar(indexArr,sw,sz,val,val2);
1500 return self->accumulatePerChunck(bg,bg+sz);
1503 PyObject *findCommonTuples(double prec, mcIdType limitNodeId=-1) const
1505 DataArrayIdType *comm, *commIndex;
1506 self->findCommonTuples(prec,limitNodeId,comm,commIndex);
1507 PyObject *res = PyList_New(2);
1508 PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(comm),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1509 PyList_SetItem(res,1,SWIG_NewPointerObj(SWIG_as_voidptr(commIndex),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1513 PyObject *distanceToTuple(PyObject *tuple) const
1517 DataArrayDoubleTuple *aa;
1518 std::vector<double> bb;
1520 mcIdType tupleId=-1;
1521 std::size_t nbOfCompo=self->getNumberOfComponents();
1522 const double *pt=convertObjToPossibleCpp5_Safe(tuple,sw,val,a,aa,bb,"Python wrap of DataArrayDouble::distanceToTuple",1,(int)nbOfCompo,true);
1524 double ret0=self->distanceToTuple(pt,pt+nbOfCompo,tupleId);
1525 PyObject *ret=PyTuple_New(2);
1526 PyTuple_SetItem(ret,0,PyFloat_FromDouble(ret0));
1527 PyTuple_SetItem(ret,1,PyInt_FromLong(tupleId));
1531 void setSelectedComponents(const DataArrayDouble *a, PyObject *li)
1533 std::vector<std::size_t> tmp;
1534 convertPyToNewIntArr3(li,tmp);
1535 self->setSelectedComponents(a,tmp);
1538 PyObject *explodeComponents() const
1540 std::vector< MCAuto<DataArrayDouble> > retCpp(self->explodeComponents());
1541 std::size_t sz(retCpp.size());
1542 PyObject *res(PyList_New(sz));
1543 for(std::size_t i=0;i<sz;i++)
1544 PyList_SetItem(res,i,SWIG_NewPointerObj(SWIG_as_voidptr(retCpp[i].retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ));
1548 PyObject *getTuple(mcIdType tupleId)
1550 std::size_t sz=self->getNumberOfComponents();
1551 INTERP_KERNEL::AutoPtr<double> tmp=new double[sz];
1552 self->getTuple(tupleId,tmp);
1553 return convertDblArrToPyList<double>(tmp,ToIdType(sz));
1556 static DataArrayDouble *Aggregate(PyObject *li)
1558 std::vector<const DataArrayDouble *> tmp;
1559 convertFromPyObjVectorOfObj<const DataArrayDouble *>(li,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",tmp);
1560 return DataArrayDouble::Aggregate(tmp);
1563 static DataArrayDouble *Meld(PyObject *li)
1565 std::vector<const DataArrayDouble *> tmp;
1566 convertFromPyObjVectorOfObj<const DataArrayDouble *>(li,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",tmp);
1567 return DataArrayDouble::Meld(tmp);
1570 PyObject *computeTupleIdsNearTuples(PyObject *pt, double eps) const
1574 DataArrayDoubleTuple *aa;
1575 std::vector<double> bb;
1577 std::size_t nbComp=self->getNumberOfComponents();
1578 mcIdType nbTuples=-1;
1579 const char msg[]="Python wrap of DataArrayDouble::computeTupleIdsNearTuples : ";
1580 const double *pos=convertObjToPossibleCpp5_Safe2(pt,sw,val,a,aa,bb,msg,(int)nbComp,true,nbTuples);
1581 MCAuto<DataArrayDouble> inpu=DataArrayDouble::New(); inpu->useArray(pos,false,DeallocType::CPP_DEALLOC,nbTuples,nbComp);
1582 DataArrayIdType *c=0,*cI=0;
1583 self->computeTupleIdsNearTuples(inpu,eps,c,cI);
1584 PyObject *ret=PyTuple_New(2);
1585 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1586 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1590 PyObject *areIncludedInMe(const DataArrayDouble *other, double prec) const
1592 DataArrayIdType *ret1=0;
1593 bool ret0=self->areIncludedInMe(other,prec,ret1);
1594 PyObject *ret=PyTuple_New(2);
1595 PyObject *ret0Py=ret0?Py_True:Py_False;
1597 PyTuple_SetItem(ret,0,ret0Py);
1598 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1602 PyObject *__getitem__(PyObject *obj)
1604 return DataArrayT__getitem<double>(self,obj);
1607 DataArrayDouble *__setitem__(PyObject *obj, PyObject *value)
1609 return DataArrayT__setitem__<double>(self,obj,value);
1612 DataArrayDouble *__neg__() const
1614 return self->negate();
1617 PyObject *__add__(PyObject *obj)
1619 const char msg[]="Unexpected situation in DataArrayDouble.__add__ !";
1622 DataArrayDoubleTuple *aa;
1623 std::vector<double> bb;
1626 #ifndef WITHOUT_AUTOFIELD
1628 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1630 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1633 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1634 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___radd__Impl(other,tmp);
1636 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1639 throw INTERP_KERNEL::Exception(msg);
1643 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1648 MCAuto<DataArrayDouble> ret=self->deepCopy();
1649 ret->applyLin(1.,val);
1650 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1654 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1658 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1659 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1663 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1664 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1667 throw INTERP_KERNEL::Exception(msg);
1671 DataArrayDouble *__radd__(PyObject *obj)
1673 const char msg[]="Unexpected situation in __radd__ !";
1676 DataArrayDoubleTuple *aa;
1677 std::vector<double> bb;
1679 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1684 MCAuto<DataArrayDouble> ret=self->deepCopy();
1685 ret->applyLin(1.,val);
1690 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1691 return DataArrayDouble::Add(self,aaa);
1695 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1696 return DataArrayDouble::Add(self,aaa);
1699 throw INTERP_KERNEL::Exception(msg);
1703 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
1705 return DataArrayT_iadd<double>(trueSelf,obj,self);
1708 PyObject *__sub__(PyObject *obj)
1710 const char msg[]="Unexpected situation in __sub__ !";
1713 DataArrayDoubleTuple *aa;
1714 std::vector<double> bb;
1717 #ifndef WITHOUT_AUTOFIELD
1719 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1721 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1724 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1725 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rsub__Impl(other,tmp);
1727 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1730 throw INTERP_KERNEL::Exception(msg);
1734 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1739 MCAuto<DataArrayDouble> ret=self->deepCopy();
1740 ret->applyLin(1.,-val);
1741 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1745 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1749 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1750 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1754 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1755 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1758 throw INTERP_KERNEL::Exception(msg);
1762 DataArrayDouble *__rsub__(PyObject *obj)
1764 const char msg[]="Unexpected situation in __rsub__ !";
1767 DataArrayDoubleTuple *aa;
1768 std::vector<double> bb;
1770 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1775 MCAuto<DataArrayDouble> ret=self->deepCopy();
1776 ret->applyLin(-1.,val);
1781 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1782 return DataArrayDouble::Substract(aaa,self);
1786 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1787 return DataArrayDouble::Substract(aaa,self);
1790 throw INTERP_KERNEL::Exception(msg);
1794 PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
1796 return DataArrayT_isub<double>(trueSelf,obj,self);
1799 PyObject *__mul__(PyObject *obj)
1801 const char msg[]="Unexpected situation in __mul__ !";
1804 DataArrayDoubleTuple *aa;
1805 std::vector<double> bb;
1808 #ifndef WITHOUT_AUTOFIELD
1810 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1812 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1815 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1816 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rmul__Impl(other,tmp);
1818 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1821 throw INTERP_KERNEL::Exception(msg);
1825 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1830 MCAuto<DataArrayDouble> ret=self->deepCopy();
1831 ret->applyLin(val,0.);
1832 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1836 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1840 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1841 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1845 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1846 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1849 throw INTERP_KERNEL::Exception(msg);
1853 DataArrayDouble *__rmul__(PyObject *obj)
1855 return DataArrayFPT_rmul<double>(self,obj);
1858 PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
1860 return DataArrayT_imul<double>(trueSelf,obj,self);
1863 PyObject *__div__(PyObject *obj)
1865 const char msg[]="Unexpected situation in __div__ !";
1868 DataArrayDoubleTuple *aa;
1869 std::vector<double> bb;
1872 #ifndef WITHOUT_AUTOFIELD
1874 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1876 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1879 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1880 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rdiv__Impl(other,tmp);
1882 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1885 throw INTERP_KERNEL::Exception(msg);
1889 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1895 throw INTERP_KERNEL::Exception("DataArrayDouble::__div__ : trying to divide by zero !");
1896 MCAuto<DataArrayDouble> ret=self->deepCopy();
1897 ret->applyLin(1/val,0.);
1898 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1902 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1906 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1907 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1911 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1912 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1915 throw INTERP_KERNEL::Exception(msg);
1919 DataArrayDouble *__rdiv__(PyObject *obj)
1921 const char msg[]="Unexpected situation in __rdiv__ !";
1924 DataArrayDoubleTuple *aa;
1925 std::vector<double> bb;
1927 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1932 MCAuto<DataArrayDouble> ret=self->deepCopy();
1938 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1939 return DataArrayDouble::Divide(aaa,self);
1943 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1944 return DataArrayDouble::Divide(aaa,self);
1947 throw INTERP_KERNEL::Exception(msg);
1951 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
1953 return DataArrayT_idiv<double>(trueSelf,obj,self);
1956 DataArrayDouble *__pow__(PyObject *obj)
1958 const char msg[]="Unexpected situation in __pow__ !";
1961 DataArrayDoubleTuple *aa;
1962 std::vector<double> bb;
1964 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1969 MCAuto<DataArrayDouble> ret=self->deepCopy();
1975 return DataArrayDouble::Pow(self,a);
1979 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1980 return DataArrayDouble::Pow(self,aaa);
1984 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1985 return DataArrayDouble::Pow(self,aaa);
1988 throw INTERP_KERNEL::Exception(msg);
1992 DataArrayDouble *__rpow__(PyObject *obj)
1994 const char msg[]="Unexpected situation in __rpow__ !";
1997 DataArrayDoubleTuple *aa;
1998 std::vector<double> bb;
2000 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
2005 MCAuto<DataArrayDouble> ret=self->deepCopy();
2006 ret->applyRPow(val);
2011 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
2012 return DataArrayDouble::Pow(aaa,self);
2016 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
2017 return DataArrayDouble::Pow(aaa,self);
2020 throw INTERP_KERNEL::Exception(msg);
2024 PyObject *___ipow___(PyObject *trueSelf, PyObject *obj)
2026 const char msg[]="Unexpected situation in __ipow__ !";
2029 DataArrayDoubleTuple *aa;
2030 std::vector<double> bb;
2032 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
2037 self->applyPow(val);
2038 Py_XINCREF(trueSelf);
2044 Py_XINCREF(trueSelf);
2049 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
2050 self->powEqual(aaa);
2051 Py_XINCREF(trueSelf);
2056 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
2057 self->powEqual(aaa);
2058 Py_XINCREF(trueSelf);
2062 throw INTERP_KERNEL::Exception(msg);
2066 PyObject *computeTupleIdsNearTuples(const DataArrayDouble *other, double eps)
2068 DataArrayIdType *c=0,*cI=0;
2070 self->computeTupleIdsNearTuples(other,eps,c,cI);
2071 PyObject *ret=PyTuple_New(2);
2072 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2073 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2077 PyObject *maxPerTupleWithCompoId() const
2079 DataArrayIdType *ret1=0;
2080 DataArrayDouble *ret0=self->maxPerTupleWithCompoId(ret1);
2081 PyObject *ret=PyTuple_New(2);
2082 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ));
2083 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2089 class DataArrayDoubleTuple;
2091 class DataArrayDoubleIterator
2094 DataArrayDoubleIterator(DataArrayDouble *da);
2095 ~DataArrayDoubleIterator();
2100 DataArrayDoubleTuple *ret=self->nextt();
2102 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayDoubleTuple,SWIG_POINTER_OWN|0);
2105 PyErr_SetString(PyExc_StopIteration,"No more data.");
2112 class DataArrayDoubleTuple
2115 std::size_t getNumberOfCompo() const;
2116 DataArrayDouble *buildDADouble(int nbOfTuples, int nbOfCompo) const;
2119 std::string __str__() const
2121 return self->repr();
2124 double __float__() const
2126 return self->doubleValue();
2129 DataArrayDouble *buildDADouble()
2131 return self->buildDADouble(1,self->getNumberOfCompo());
2134 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
2136 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2137 MEDCoupling_DataArrayDouble____iadd___(ret,0,obj);
2138 Py_XINCREF(trueSelf);
2142 PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
2144 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2145 MEDCoupling_DataArrayDouble____isub___(ret,0,obj);
2146 Py_XINCREF(trueSelf);
2150 PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
2152 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2153 MEDCoupling_DataArrayDouble____imul___(ret,0,obj);
2154 Py_XINCREF(trueSelf);
2158 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
2160 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2161 MEDCoupling_DataArrayDouble____idiv___(ret,0,obj);
2162 Py_XINCREF(trueSelf);
2168 return PyInt_FromLong(self->getNumberOfCompo());
2171 PyObject *__getitem__(PyObject *obj)
2173 const char msg2[]="DataArrayDoubleTuple::__getitem__ : Mismatch of slice values in 2nd parameter (components) !";
2176 std::vector<mcIdType> multiVal;
2177 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2178 MEDCoupling::DataArrayIdType *daIntTyypp=0;
2179 const double *pt=self->getConstPointer();
2180 mcIdType nbc=ToIdType(self->getNumberOfCompo());
2181 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbc,sw,singleVal,multiVal,slic,daIntTyypp);
2188 std::ostringstream oss;
2189 oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2190 PyErr_SetString(PyExc_StopIteration,oss.str().c_str());
2194 return PyFloat_FromDouble(pt[singleVal]);
2198 return PyFloat_FromDouble(pt[nbc+singleVal]);
2201 std::ostringstream oss;
2202 oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2203 throw INTERP_KERNEL::Exception(oss.str().c_str());
2209 PyObject *t=PyTuple_New(multiVal.size());
2210 for(std::size_t j=0;j<multiVal.size();j++)
2212 mcIdType cid=multiVal[j];
2215 std::ostringstream oss;
2216 oss << "Requesting for id #" << cid << " having only " << nbc << " components !";
2217 throw INTERP_KERNEL::Exception(oss.str().c_str());
2219 PyTuple_SetItem(t,j,PyFloat_FromDouble(pt[cid]));
2225 mcIdType sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2226 PyObject *t=PyTuple_New(sz);
2227 for(mcIdType j=0;j<sz;j++)
2228 PyTuple_SetItem(t,j,PyFloat_FromDouble(pt[slic.first+j*slic.second.second]));
2232 throw INTERP_KERNEL::Exception("DataArrayDoubleTuple::__getitem__ : unrecognized type entered !");
2236 DataArrayDoubleTuple *__setitem__(PyObject *obj, PyObject *value)
2238 const char msg[]="DataArrayDoubleTuple::__setitem__ : unrecognized type entered, int, slice, list<int>, tuple<int> !";
2239 const char msg2[]="DataArrayDoubleTuple::__setitem__ : Mismatch of slice values in 2nd parameter (components) !";
2242 std::vector<double> multiValV;
2243 MEDCoupling::DataArrayDoubleTuple *daIntTyyppV=0;
2244 mcIdType nbc=ToIdType(self->getNumberOfCompo());
2245 convertDoubleStarLikePyObjToCpp(value,sw1,singleValV,multiValV,daIntTyyppV);
2247 std::vector<mcIdType> multiVal;
2248 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2249 MEDCoupling::DataArrayIdType *daIntTyypp=0;
2250 double *pt=self->getPointer();
2251 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbc,sw2,singleVal,multiVal,slic,daIntTyypp);
2258 std::ostringstream oss;
2259 oss << "Requesting for setting id # " << singleVal << " having only " << nbc << " components !";
2260 throw INTERP_KERNEL::Exception(oss.str().c_str());
2266 pt[singleVal]=singleValV;
2271 if(multiValV.size()!=1)
2273 std::ostringstream oss;
2274 oss << "Requesting for setting id # " << singleVal << " with a list or tuple with size != 1 ! ";
2275 throw INTERP_KERNEL::Exception(oss.str().c_str());
2277 pt[singleVal]=multiValV[0];
2282 pt[singleVal]=daIntTyyppV->getConstPointer()[0];
2286 throw INTERP_KERNEL::Exception(msg);
2295 for(std::vector<mcIdType>::const_iterator it=multiVal.begin();it!=multiVal.end();it++)
2299 std::ostringstream oss;
2300 oss << "Requesting for setting id # " << *it << " having only " << nbc << " components !";
2301 throw INTERP_KERNEL::Exception(oss.str().c_str());
2309 if(multiVal.size()!=multiValV.size())
2311 std::ostringstream oss;
2312 oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << multiVal.size() << " !";
2313 throw INTERP_KERNEL::Exception(oss.str().c_str());
2315 for(std::size_t i=0;i<multiVal.size();i++)
2317 mcIdType pos=multiVal[i];
2320 std::ostringstream oss;
2321 oss << "Requesting for setting id # " << pos << " having only " << nbc << " components !";
2322 throw INTERP_KERNEL::Exception(oss.str().c_str());
2324 pt[multiVal[i]]=multiValV[i];
2330 const double *ptV=daIntTyyppV->getConstPointer();
2331 if(nbc>(mcIdType)daIntTyyppV->getNumberOfCompo())
2333 std::ostringstream oss;
2334 oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2335 throw INTERP_KERNEL::Exception(oss.str().c_str());
2337 std::copy(ptV,ptV+nbc,pt);
2341 throw INTERP_KERNEL::Exception(msg);
2346 mcIdType sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2351 for(mcIdType j=0;j<sz;j++)
2352 pt[slic.first+j*slic.second.second]=singleValV;
2357 if(sz!=(mcIdType)multiValV.size())
2359 std::ostringstream oss;
2360 oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << sz << " !";
2361 throw INTERP_KERNEL::Exception(oss.str().c_str());
2363 for(mcIdType j=0;j<sz;j++)
2364 pt[slic.first+j*slic.second.second]=multiValV[j];
2369 const double *ptV=daIntTyyppV->getConstPointer();
2370 if(sz>(mcIdType)daIntTyyppV->getNumberOfCompo())
2372 std::ostringstream oss;
2373 oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2374 throw INTERP_KERNEL::Exception(oss.str().c_str());
2376 for(mcIdType j=0;j<sz;j++)
2377 pt[slic.first+j*slic.second.second]=ptV[j];
2381 throw INTERP_KERNEL::Exception(msg);
2385 throw INTERP_KERNEL::Exception(msg);
2391 class DataArrayChar : public DataArray
2394 virtual DataArrayChar *buildEmptySpecializedDAChar() const;
2395 int getHashCode() const;
2397 void deepCopyFrom(const DataArrayChar& other);
2398 void reserve(std::size_t nbOfElems);
2399 void pushBackSilent(char val);
2400 char popBackSilent();
2402 void allocIfNecessary(int nbOfTuple, int nbOfCompo);
2403 bool isEqual(const DataArrayChar& other) const;
2404 bool isEqualWithoutConsideringStr(const DataArrayChar& other) const;
2406 void fillWithZero();
2407 void fillWithValue(char val);
2408 std::string repr() const;
2409 std::string reprZip() const;
2410 DataArrayInt *convertToIntArr() const;
2411 DataArrayChar *renumber(const mcIdType *old2New) const;
2412 DataArrayChar *renumberR(const mcIdType *new2Old) const;
2413 DataArrayChar *renumberAndReduce(const mcIdType *old2NewBg, mcIdType newNbOfTuple) const;
2414 bool isUniform(char val) const;
2415 void sort(bool asc=true);
2416 DataArrayChar *subArray(mcIdType tupleIdBg, mcIdType tupleIdEnd=-1) const;
2417 DataArrayChar *changeNbOfComponents(std::size_t newNbOfComp, char dftValue) const;
2418 void meldWith(const DataArrayChar *other);
2419 void setPartOfValuesAdv(const DataArrayChar *a, const DataArrayIdType *tuplesSelec);
2422 void setIJ(mcIdType tupleId, int compoId, char newVal);
2423 void setIJSilent(mcIdType tupleId, int compoId, char newVal);
2425 DataArrayIdType *findIdsEqual(char val) const;
2426 DataArrayIdType *findIdsNotEqual(char val) const;
2427 int findIdFirstEqualTuple(const std::vector<char>& tupl) const;
2428 bool presenceOfTuple(const std::vector<char>& tupl) const;
2429 char getMaxValue(mcIdType& tupleId) const;
2430 char getMaxValueInArray() const;
2431 char getMinValue(mcIdType& tupleId) const;
2432 char getMinValueInArray() const;
2433 DataArrayIdType *findIdsInRange(char vmin, char vmax) const;
2434 static DataArrayChar *Aggregate(const DataArrayChar *a1, const DataArrayChar *a2);
2435 static DataArrayChar *Meld(const DataArrayChar *a1, const DataArrayChar *a2);
2438 mcIdType __len__() const
2440 if(self->isAllocated())
2442 return self->getNumberOfTuples();
2446 throw INTERP_KERNEL::Exception("DataArrayChar::__len__ : Instance is NOT allocated !");
2450 PyObject *isEqualIfNotWhy(const DataArrayChar& other) const
2453 bool ret0=self->isEqualIfNotWhy(other,ret1);
2454 PyObject *ret=PyTuple_New(2);
2455 PyObject *ret0Py=ret0?Py_True:Py_False;
2457 PyTuple_SetItem(ret,0,ret0Py);
2458 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
2462 DataArrayChar *renumber(PyObject *li)
2465 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
2466 if (!SWIG_IsOK(res1))
2469 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2470 if(size!=self->getNumberOfTuples())
2472 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2474 return self->renumber(tmp);
2478 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2480 throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2481 da2->checkAllocated();
2482 mcIdType size=self->getNumberOfTuples();
2483 if(size!=self->getNumberOfTuples())
2485 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2487 return self->renumber(da2->getConstPointer());
2491 DataArrayChar *renumberR(PyObject *li)
2494 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
2495 if (!SWIG_IsOK(res1))
2498 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2499 if(size!=self->getNumberOfTuples())
2501 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2503 return self->renumberR(tmp);
2507 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2509 throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2510 da2->checkAllocated();
2511 mcIdType size=self->getNumberOfTuples();
2512 if(size!=self->getNumberOfTuples())
2514 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2516 return self->renumberR(da2->getConstPointer());
2520 DataArrayChar *renumberAndReduce(PyObject *li, mcIdType newNbOfTuple)
2523 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
2524 if (!SWIG_IsOK(res1))
2527 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2528 if(size!=self->getNumberOfTuples())
2530 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2532 return self->renumberAndReduce(tmp,newNbOfTuple);
2536 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2538 throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2539 da2->checkAllocated();
2540 mcIdType size=self->getNumberOfTuples();
2541 if(size!=self->getNumberOfTuples())
2543 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2545 return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
2549 static DataArrayChar *Aggregate(PyObject *dachs)
2551 std::vector<const MEDCoupling::DataArrayChar *> tmp;
2552 convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayChar *>(dachs,SWIGTYPE_p_MEDCoupling__DataArrayChar,"DataArrayChar",tmp);
2553 return DataArrayChar::Aggregate(tmp);
2556 static DataArrayChar *Meld(PyObject *dachs)
2558 std::vector<const MEDCoupling::DataArrayChar *> tmp;
2559 convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayChar *>(dachs,SWIGTYPE_p_MEDCoupling__DataArrayChar,"DataArrayChar",tmp);
2560 return DataArrayChar::Meld(tmp);
2565 class DataArrayByteIterator;
2567 class DataArrayByte : public DataArrayChar
2570 static DataArrayByte *New();
2571 DataArrayByteIterator *iterator();
2572 DataArrayByte *performCopyOrIncrRef(bool deepCopy) const;
2573 char byteValue() const;
2578 return DataArrayByte::New();
2581 static DataArrayByte *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
2583 const char *msg="MEDCoupling::DataArrayByte::New : Available API are : \n-DataArrayByte.New()\n--DataArrayByte.New([1,3,4])\n-DataArrayByte.New([1,3,4],3)\n-DataArrayByte.New([1,3,4,5],2,2)\n-DataArrayByte.New(5)\n-DataArrayByte.New(5,2) !";
2584 if(PyList_Check(elt0) || PyTuple_Check(elt0))
2588 if(PyInt_Check(nbOfTuples))
2590 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
2592 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive set of allocated memory !");
2595 if(PyInt_Check(nbOfComp))
2596 {//DataArrayByte.New([1,3,4,5],2,2)
2597 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
2599 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !");
2600 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2601 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
2602 ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2606 throw INTERP_KERNEL::Exception(msg);
2609 {//DataArrayByte.New([1,3,4],3)
2610 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2612 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
2613 ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2618 throw INTERP_KERNEL::Exception(msg);
2621 {// DataArrayByte.New([1,3,4])
2622 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2623 mcIdType tmpp1=-1,tmpp2=-1;
2624 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
2625 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2629 else if(PyInt_Check(elt0))
2631 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(elt0));
2633 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive set of allocated memory !");
2638 if(PyInt_Check(nbOfTuples))
2639 {//DataArrayByte.New(5,2)
2640 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfTuples));
2642 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !");
2643 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2644 ret->alloc(nbOfTuples1,nbOfCompo);
2648 throw INTERP_KERNEL::Exception(msg);
2651 throw INTERP_KERNEL::Exception(msg);
2654 {//DataArrayByte.New(5)
2655 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2656 ret->alloc(nbOfTuples1,1);
2661 else if(PyArray_Check(elt0) && nbOfTuples==NULL && nbOfComp==NULL)
2662 {//DataArrayDouble.New(numpyArray)
2663 return BuildNewInstance<DataArrayByte,char>(elt0,NPY_INT8,&PyCallBackDataArrayChar_RefType,"INT8");
2667 throw INTERP_KERNEL::Exception(msg);
2670 DataArrayByte(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
2672 return MEDCoupling_DataArrayByte_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
2675 std::string __repr__() const
2677 std::ostringstream oss;
2678 self->reprQuickOverview(oss);
2684 return (int) self->byteValue();
2687 DataArrayByteIterator *__iter__()
2689 return self->iterator();
2692 mcIdType getIJ(mcIdType tupleId, mcIdType compoId) const
2694 return (mcIdType)self->getIJ(tupleId,compoId);
2697 mcIdType getIJSafe(mcIdType tupleId, mcIdType compoId) const
2699 return (mcIdType)self->getIJSafe(tupleId,compoId);
2702 std::string __str__() const
2704 return self->repr();
2707 PyObject *toStrList() const
2709 const char *vals=self->getConstPointer();
2710 std::size_t nbOfComp=self->getNumberOfComponents();
2711 mcIdType nbOfTuples=self->getNumberOfTuples();
2712 return convertCharArrToPyListOfTuple(vals,(int)nbOfComp,nbOfTuples);
2715 bool presenceOfTuple(PyObject *tupl) const
2717 mcIdType sz=-1,sw=-1;
2718 mcIdType ival=-1; std::vector<mcIdType> ivval;
2719 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(tupl,sw,sz,ival,ivval);
2720 std::vector<char> vals(sz);
2721 std::copy(pt,pt+sz,vals.begin());
2722 return self->presenceOfTuple(vals);
2725 bool presenceOfValue(PyObject *vals) const
2727 mcIdType sz=-1,sw=-1;
2728 mcIdType ival=-1; std::vector<mcIdType> ivval;
2729 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(vals,sw,sz,ival,ivval);
2730 std::vector<char> vals2(sz);
2731 std::copy(pt,pt+sz,vals2.begin());
2732 return self->presenceOfValue(vals2);
2735 mcIdType findIdFirstEqual(PyObject *vals) const
2737 mcIdType sz=-1,sw=-1;
2738 mcIdType ival=-1; std::vector<mcIdType> ivval;
2739 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(vals,sw,sz,ival,ivval);
2740 std::vector<char> vals2(sz);
2741 std::copy(pt,pt+sz,vals2.begin());
2742 return self->findIdFirstEqual(vals2);
2745 mcIdType findIdFirstEqualTuple(PyObject *tupl) const
2747 mcIdType sz=-1,sw=-1;
2748 mcIdType ival=-1; std::vector<mcIdType> ivval;
2749 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(tupl,sw,sz,ival,ivval);
2750 std::vector<char> vals(sz);
2751 std::copy(pt,pt+sz,vals.begin());
2752 return self->findIdFirstEqualTuple(vals);
2755 mcIdType findIdSequence(PyObject *strOrListOfInt) const
2757 mcIdType sz=-1,sw=-1;
2758 mcIdType ival=-1; std::vector<mcIdType> ivval;
2759 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(strOrListOfInt,sw,sz,ival,ivval);
2760 std::vector<char> vals(sz);
2761 std::copy(pt,pt+sz,vals.begin());
2762 return self->findIdSequence(vals);
2765 PyObject *getTuple(mcIdType tupleId)
2767 std::size_t sz=self->getNumberOfComponents();
2768 INTERP_KERNEL::AutoPtr<char> tmp=new char[sz];
2769 self->getTuple(tupleId,tmp);
2770 PyObject *ret=PyTuple_New(sz);
2771 for(std::size_t i=0;i<sz;i++) PyTuple_SetItem(ret,i,PyInt_FromLong((mcIdType)tmp[i]));
2775 PyObject *getMaxValue() const
2778 mcIdType r1=(mcIdType)self->getMaxValue(tmp);
2779 PyObject *ret=PyTuple_New(2);
2780 PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
2781 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
2785 PyObject *getMinValue() const
2788 mcIdType r1=(mcIdType)self->getMinValue(tmp);
2789 PyObject *ret=PyTuple_New(2);
2790 PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
2791 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
2795 mcIdType index(PyObject *obj) const
2797 std::size_t nbOfCompo=self->getNumberOfComponents();
2802 if(PyInt_Check(obj))
2804 char val=(char)PyInt_AS_LONG(obj);
2805 return self->findIdFirstEqual(val);
2808 throw INTERP_KERNEL::Exception("DataArrayByte::index : 'this' contains one component and trying to find an element which is not an integer !");
2811 return MEDCoupling_DataArrayByte_findIdFirstEqualTuple(self,obj);
2815 bool __contains__(PyObject *obj) const
2817 std::size_t nbOfCompo=self->getNumberOfComponents();
2824 if(PyInt_Check(obj))
2826 char val=(char)PyInt_AS_LONG(obj);
2827 return self->presenceOfValue(val);
2830 throw INTERP_KERNEL::Exception("DataArrayByte::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
2833 return MEDCoupling_DataArrayByte_presenceOfTuple(self,obj);
2838 PyObject *toNumPyArray() // not const. It is not a bug !
2840 return ToNumPyArray<DataArrayByte,char>(self,NPY_INT8,"DataArrayByte");
2844 DataArrayByte *__setitem__(PyObject *obj, PyObject *value)
2846 self->checkAllocated();
2847 const char msg[]="Unexpected situation in __setitem__ !";
2848 mcIdType nbOfTuples(self->getNumberOfTuples());
2849 int nbOfComponents((int)self->getNumberOfComponents());
2852 std::vector<int> v1;
2853 DataArrayIdType *d1=0;
2854 DataArrayIntTuple *dd1=0;
2855 convertIntStarLikePyObjToCpp(value,sw1,int1,v1,d1,dd1);
2857 std::vector<mcIdType> vt1,vc1;
2858 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > pt1,pc1;
2859 DataArrayIdType *dt1=0,*dc1=0;
2860 convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw2,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1);
2861 MCAuto<DataArrayIdType> tmp;
2862 char i1 = (char)int1;
2870 self->setPartOfValuesSimple1(i1,it1,it1+1,1,0,nbOfComponents,1);
2873 throw INTERP_KERNEL::Exception(msg);
2882 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1);
2885 throw INTERP_KERNEL::Exception(msg);
2894 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1);
2897 throw INTERP_KERNEL::Exception(msg);
2906 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1);
2909 throw INTERP_KERNEL::Exception(msg);
2918 self->setPartOfValuesSimple1(i1,it1,it1+1,1,ic1,ic1+1,1);
2921 throw INTERP_KERNEL::Exception(msg);
2930 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1);
2933 throw INTERP_KERNEL::Exception(msg);
2942 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1);
2945 throw INTERP_KERNEL::Exception(msg);
2954 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1);
2957 throw INTERP_KERNEL::Exception(msg);
2966 self->setPartOfValuesSimple2(i1,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size());
2969 throw INTERP_KERNEL::Exception(msg);
2978 self->setPartOfValuesSimple2(i1,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size());
2981 throw INTERP_KERNEL::Exception(msg);
2990 self->setPartOfValuesSimple4(i1,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size());
2993 throw INTERP_KERNEL::Exception(msg);
3002 self->setPartOfValuesSimple2(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size());
3005 throw INTERP_KERNEL::Exception(msg);
3014 self->setPartOfValuesSimple1(i1,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second);
3017 throw INTERP_KERNEL::Exception(msg);
3026 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second);
3029 throw INTERP_KERNEL::Exception(msg);
3038 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second);
3041 throw INTERP_KERNEL::Exception(msg);
3050 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second);
3053 throw INTERP_KERNEL::Exception(msg);
3058 throw INTERP_KERNEL::Exception(msg);
3065 class DataArrayByteTuple;
3067 class DataArrayByteIterator
3070 DataArrayByteIterator(DataArrayByte *da);
3071 ~DataArrayByteIterator();
3074 class DataArrayByteTuple
3077 std::string repr() const;
3078 DataArrayByte *buildDAByte(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
3081 std::string __str__() const
3083 return self->repr();
3086 char __int__() const
3088 return self->byteValue();
3091 DataArrayByte *buildDAByte()
3093 return self->buildDAByte(1,self->getNumberOfCompo());
3098 class DataArrayAsciiCharIterator;
3100 class DataArrayAsciiChar : public DataArrayChar
3103 static DataArrayAsciiChar *New();
3104 DataArrayAsciiCharIterator *iterator();
3105 DataArrayAsciiChar *performCopyOrIncrRef(bool deepCopy) const;
3106 char asciiCharValue() const;
3109 DataArrayAsciiChar()
3111 return DataArrayAsciiChar::New();
3114 static DataArrayAsciiChar *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
3116 const char *msg="MEDCoupling::DataArrayAsciiChar::New : Available API are : \n-DataArrayAsciiChar.New()\n-DataArrayAsciiChar.New([1,3,4])\n-DataArrayAsciiChar.New([\"abc\",\"de\",\"fghi\"])\n-DataArrayAsciiChar.New([\"abc\",\"de\",\"fghi\"],\"t\")\n-DataArrayAsciiChar.New([1,3,4],3)\n-DataArrayAsciiChar.New([1,3,4,5],2,2)\n-DataArrayAsciiChar.New(5)\n-DataArrayAsciiChar.New(5,2) !";
3117 if(PyList_Check(elt0) || PyTuple_Check(elt0))
3121 if(PyInt_Check(nbOfTuples))
3123 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
3125 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive set of allocated memory !");
3128 if(PyInt_Check(nbOfComp))
3129 {//DataArrayAsciiChar.New([1,3,4,5],2,2)
3130 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
3132 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !");
3133 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3134 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
3135 ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3139 throw INTERP_KERNEL::Exception(msg);
3142 {//DataArrayAsciiChar.New([1,3,4],3)
3143 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3145 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
3146 ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3150 else if(PyString_Check(nbOfTuples))
3152 if(PyString_Size(nbOfTuples)!=1)
3153 throw INTERP_KERNEL::Exception(msg);
3154 //DataArrayAsciiChar.New(["abc","de","fghi"],"t")
3155 std::vector<std::string> tmp;
3156 if(fillStringVector(elt0,tmp))
3157 return DataArrayAsciiChar::New(tmp,PyString_AsString(nbOfTuples)[0]);
3159 throw INTERP_KERNEL::Exception(msg);
3161 %#if PY_VERSION_HEX >= 0x03000000
3162 else if(PyUnicode_Check(nbOfTuples))
3164 if(PyUnicode_GET_LENGTH(nbOfTuples)!=1)
3165 throw INTERP_KERNEL::Exception(msg);
3166 //DataArrayAsciiChar.New(["abc","de","fghi"],"t")
3167 std::vector<std::string> tmp;
3168 if(fillStringVector(elt0,tmp))
3169 return DataArrayAsciiChar::New(tmp,PyUnicode_AsUTF8(nbOfTuples)[0]);
3171 throw INTERP_KERNEL::Exception(msg);
3175 throw INTERP_KERNEL::Exception(msg);
3179 std::vector<std::string> tmmp;
3180 if(fillStringVector(elt0,tmmp))
3181 //DataArrayAsciiChar.New(["abc","de","fghi"])
3182 return DataArrayAsciiChar::New(tmmp,' ');
3185 // DataArrayAsciiChar.New([1,3,4])
3186 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3187 mcIdType tmpp1=-1,tmpp2=-1;
3188 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
3189 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3194 else if(PyInt_Check(elt0))
3196 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(elt0));
3198 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive set of allocated memory !");
3203 if(PyInt_Check(nbOfTuples))
3204 {//DataArrayAsciiChar.New(5,2)
3205 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfTuples));
3207 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !");
3208 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3209 ret->alloc(nbOfTuples1,nbOfCompo);
3213 throw INTERP_KERNEL::Exception(msg);
3216 throw INTERP_KERNEL::Exception(msg);
3219 {//DataArrayAsciiChar.New(5)
3220 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3221 ret->alloc(nbOfTuples1,1);
3226 throw INTERP_KERNEL::Exception(msg);
3229 DataArrayAsciiChar(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
3231 return MEDCoupling_DataArrayAsciiChar_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
3234 std::string __repr__() const
3236 std::ostringstream oss;
3237 self->reprQuickOverview(oss);
3241 DataArrayAsciiCharIterator *__iter__()
3243 return self->iterator();
3246 std::string getIJ(mcIdType tupleId, mcIdType compoId) const
3248 char tmp[2]; tmp[1]='\0';
3249 tmp[0]=self->getIJ(tupleId,compoId);
3250 return std::string(tmp);
3253 std::string getIJSafe(mcIdType tupleId, mcIdType compoId) const
3255 char tmp[2]; tmp[1]='\0';
3256 tmp[0]=self->getIJSafe(tupleId,compoId);
3257 return std::string(tmp);
3260 std::string __str__() const
3262 return self->repr();
3265 PyObject *toStrList() const
3267 const char *vals=self->getConstPointer();
3268 std::size_t nbOfComp=self->getNumberOfComponents();
3269 mcIdType nbOfTuples=self->getNumberOfTuples();
3270 return convertCharArrToPyListOfTuple(vals,(int)nbOfComp,nbOfTuples);
3273 bool presenceOfTuple(PyObject *tupl) const
3275 if(PyString_Check(tupl))
3277 Py_ssize_t sz=PyString_Size(tupl);
3278 std::vector<char> vals(sz);
3279 std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin());
3280 return self->presenceOfTuple(vals);
3282 %#if PY_VERSION_HEX >= 0x03000000
3283 else if(PyUnicode_Check(tupl))
3285 Py_ssize_t sz=PyUnicode_GET_LENGTH(tupl);
3286 std::vector<char> vals(sz);
3287 std::copy(PyUnicode_AsUTF8(tupl),PyUnicode_AsUTF8(tupl)+sz,vals.begin());
3288 return self->presenceOfTuple(vals);
3292 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfTuple : only strings in input supported !");
3295 bool presenceOfValue(PyObject *vals) const
3297 if(PyString_Check(vals))
3299 Py_ssize_t sz=PyString_Size(vals);
3300 std::vector<char> vals2(sz);
3301 std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin());
3302 return self->presenceOfValue(vals2);
3304 %#if PY_VERSION_HEX >= 0x03000000
3305 if(PyUnicode_Check(vals))
3307 Py_ssize_t sz=PyUnicode_GET_LENGTH(vals);
3308 std::vector<char> vals2(sz);
3309 std::copy(PyUnicode_AsUTF8(vals),PyUnicode_AsUTF8(vals)+sz,vals2.begin());
3310 return self->presenceOfValue(vals2);
3314 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfValue : only strings in input supported !");
3317 mcIdType findIdFirstEqual(PyObject *vals) const
3319 if(PyString_Check(vals))
3321 Py_ssize_t sz=PyString_Size(vals);
3322 std::vector<char> vals2(sz);
3323 std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin());
3324 return self->findIdFirstEqual(vals2);
3326 %#if PY_VERSION_HEX >= 0x03000000
3327 if(PyUnicode_Check(vals))
3329 Py_ssize_t sz=PyUnicode_GET_LENGTH(vals);
3330 std::vector<char> vals2(sz);
3331 std::copy(PyUnicode_AsUTF8(vals),PyUnicode_AsUTF8(vals)+sz,vals2.begin());
3332 return self->findIdFirstEqual(vals2);
3336 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::findIdFirstEqual : only strings in input supported !");
3339 mcIdType findIdFirstEqualTuple(PyObject *tupl) const
3341 if(PyString_Check(tupl))
3343 Py_ssize_t sz=PyString_Size(tupl);
3344 std::vector<char> vals(sz);
3345 std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin());
3346 return self->findIdFirstEqualTuple(vals);
3348 %#if PY_VERSION_HEX >= 0x03000000
3349 if(PyUnicode_Check(tupl))
3351 Py_ssize_t sz=PyUnicode_GET_LENGTH(tupl);
3352 std::vector<char> vals(sz);
3353 std::copy(PyUnicode_AsUTF8(tupl),PyUnicode_AsUTF8(tupl)+sz,vals.begin());
3354 return self->findIdFirstEqualTuple(vals);
3358 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::findIdFirstEqualTuple : only strings in input supported !");
3361 mcIdType findIdSequence(PyObject *strOrListOfInt) const
3363 if(PyString_Check(strOrListOfInt))
3365 Py_ssize_t sz=PyString_Size(strOrListOfInt);
3366 std::vector<char> vals(sz);
3367 std::copy(PyString_AsString(strOrListOfInt),PyString_AsString(strOrListOfInt)+sz,vals.begin());
3368 return self->findIdSequence(vals);
3370 %#if PY_VERSION_HEX >= 0x03000000
3371 else if(PyUnicode_Check(strOrListOfInt))
3373 Py_ssize_t sz=PyUnicode_GET_LENGTH(strOrListOfInt);
3374 std::vector<char> vals(sz);
3375 std::copy(PyUnicode_AsUTF8(strOrListOfInt),PyUnicode_AsUTF8(strOrListOfInt)+sz,vals.begin());
3376 return self->findIdSequence(vals);
3380 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::search : only strings in input supported !");
3383 PyObject *getTuple(mcIdType tupleId) const
3385 std::size_t sz=self->getNumberOfComponents();
3386 INTERP_KERNEL::AutoPtr<char> tmp=new char[sz+1]; tmp[sz]='\0';
3387 self->getTuple(tupleId,tmp);
3388 return PyString_FromString(tmp);
3391 PyObject *getMaxValue() const
3394 char tmp2[2]; tmp2[1]='\0';
3395 tmp2[0]=self->getMaxValue(tmp);
3396 PyObject *ret=PyTuple_New(2);
3397 PyTuple_SetItem(ret,0,PyString_FromString(tmp2));
3398 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
3402 PyObject *getMinValue() const
3405 char tmp2[2]; tmp2[1]='\0';
3406 tmp2[0]=self->getMinValue(tmp);
3407 PyObject *ret=PyTuple_New(2);
3408 PyTuple_SetItem(ret,0,PyString_FromString(tmp2));
3409 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
3413 mcIdType index(PyObject *obj) const
3415 std::size_t nbOfCompo=self->getNumberOfComponents();
3420 if(PyString_Check(obj))
3422 Py_ssize_t sz=PyString_Size(obj);
3423 char *pt=PyString_AsString(obj);
3425 return self->findIdFirstEqual(pt[0]);
3427 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find a string with size different from 1 !");
3429 %#if PY_VERSION_HEX >= 0x03000000
3430 if(PyUnicode_Check(obj))
3433 const char *pt=PyUnicode_AsUTF8AndSize(obj, &sz);
3435 return self->findIdFirstEqual(pt[0]);
3437 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find a string with size different from 1 !");
3441 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find an element which is not an integer !");
3444 return MEDCoupling_DataArrayAsciiChar_findIdFirstEqualTuple(self,obj);
3448 bool __contains__(PyObject *obj) const
3450 std::size_t nbOfCompo=self->getNumberOfComponents();
3457 if(PyString_Check(obj))
3459 Py_ssize_t sz=PyString_Size(obj);
3460 char *pt=PyString_AsString(obj);
3462 return self->presenceOfValue(pt[0]);
3464 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find a string with size different from 1 !");
3466 %#if PY_VERSION_HEX >= 0x03000000
3467 if(PyUnicode_Check(obj))
3470 const char *pt=PyUnicode_AsUTF8AndSize(obj, &sz);
3472 return self->presenceOfValue(pt[0]);
3474 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find a string with size different from 1 !");
3478 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
3481 return MEDCoupling_DataArrayAsciiChar_presenceOfTuple(self,obj);
3485 PyObject *__getitem__(PyObject *obj) const
3487 mcIdType sw,iTypppArr;
3488 std::vector<mcIdType> stdvecTyyppArr;
3489 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > sTyyppArr;
3490 MEDCoupling::DataArrayIdType *daIntTyypp=0;
3491 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,self->getNumberOfTuples(),sw,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp);
3495 return MEDCoupling_DataArrayAsciiChar_getTuple(self,iTypppArr);
3497 return convertDataArrayChar(self->selectByTupleIdSafe(&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size()), SWIG_POINTER_OWN | 0 );
3499 return convertDataArrayChar(self->selectByTupleIdSafeSlice(sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second), SWIG_POINTER_OWN | 0 );
3501 return convertDataArrayChar(self->selectByTupleIdSafe(daIntTyypp->begin(),daIntTyypp->end()), SWIG_POINTER_OWN | 0 );
3503 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__getitem__ : supporting int, list of int, tuple of int, DataArrayIdType and slice in input !");
3507 DataArrayAsciiChar *__setitem__(PyObject *obj, PyObject *value)
3509 static const char msg[]="DataArrayAsciiChar::__setitem__ : supporting int, list of int, tuple of int, DataArrayIdType and slice in input, and 4 types accepted in value : string, list or tuple of strings having same size, not null DataArrayChar instance.";
3510 mcIdType sw1,iTypppArr;
3511 std::vector<mcIdType> stdvecTyyppArr;
3512 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > sTyyppArr;
3513 MEDCoupling::DataArrayIdType *daIntTyypp=0;
3514 mcIdType nbOfCompo=ToIdType(self->getNumberOfComponents());
3515 mcIdType nbOfTuples=self->getNumberOfTuples();
3516 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbOfTuples,sw1,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp);
3518 char vc; std::string sc; std::vector<std::string> vsc; DataArrayChar *dacc=0;
3519 convertObjToPossibleCpp6(value,sw2,vc,sc,vsc,dacc);
3528 self->setPartOfValuesSimple3(vc,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1);
3534 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3535 self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3538 //value vector<string>
3541 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3542 self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3545 //value DataArrayChar
3548 self->setPartOfValues3(dacc,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3552 throw INTERP_KERNEL::Exception(msg);
3556 {//obj list-tuple[int]
3562 self->setPartOfValuesSimple3(vc,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1);
3568 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3569 self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3572 //value vector<string>
3575 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3576 self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3579 //value DataArrayChar
3582 self->setPartOfValues3(dacc,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3586 throw INTERP_KERNEL::Exception(msg);
3597 self->setPartOfValuesSimple1(vc,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1);
3603 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3604 self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3607 //value vector<string>
3610 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3611 self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3614 //value DataArrayChar
3617 self->setPartOfValues1(dacc,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3621 throw INTERP_KERNEL::Exception(msg);
3632 self->setPartOfValuesSimple3(vc,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1);
3638 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3639 self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3642 //value vector<string>
3645 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3646 self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3649 //value DataArrayChar
3652 self->setPartOfValues3(dacc,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3656 throw INTERP_KERNEL::Exception(msg);
3661 throw INTERP_KERNEL::Exception(msg);
3667 class DataArrayAsciiCharTuple;
3669 class DataArrayAsciiCharIterator
3672 DataArrayAsciiCharIterator(DataArrayAsciiChar *da);
3673 ~DataArrayAsciiCharIterator();
3678 DataArrayAsciiCharTuple *ret=self->nextt();
3680 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayAsciiCharTuple,SWIG_POINTER_OWN | 0);
3683 PyErr_SetString(PyExc_StopIteration,"No more data.");
3690 class DataArrayAsciiCharTuple
3693 std::size_t getNumberOfCompo() const;
3694 DataArrayAsciiChar *buildDAAsciiChar(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
3697 std::string __str__() const
3699 return self->repr();
3702 DataArrayAsciiChar *buildDAAsciiChar()
3704 return self->buildDAAsciiChar(1,self->getNumberOfCompo());
3713 MEDCoupling::DataArrayByte *FromPyIntPtrToDataArrayByte(mcPyPtrType intPtr)
3715 MEDCoupling::DataArrayByte *ret(reinterpret_cast<MEDCoupling::DataArrayByte *>(intPtr));
3720 %include "DataArrayInt.i"
3724 def MEDCouplingStdReduceFunct(cls,params):
3726 ret=object.__new__(cls)
3731 def MEDCouplingDataArrayDoubleReduce(self):
3732 if not MEDCouplingHasNumPyBindings():
3733 raise InterpKernelException("PyWrap of DataArrayDouble.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3734 return MEDCouplingStdReduceFunct,(DataArrayDouble,((self.toNumPyArray(),),(self.__getstate__()),))
3736 def MEDCouplingDataArrayInt32Reduce(self):
3737 if not MEDCouplingHasNumPyBindings():
3738 raise InterpKernelException("PyWrap of DataArrayIdType.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3739 return MEDCouplingStdReduceFunct,(DataArrayInt32,((self.toNumPyArray(),),(self.__getstate__()),))
3741 def MEDCouplingDataArrayInt64Reduce(self):
3742 if not MEDCouplingHasNumPyBindings():
3743 raise InterpKernelException("PyWrap of DataArrayIdType.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3744 return MEDCouplingStdReduceFunct,(DataArrayInt64,((self.toNumPyArray(),),(self.__getstate__()),))
3746 def MEDCouplingDataArrayByteReduce(self):
3747 if not MEDCouplingHasNumPyBindings():
3748 raise InterpKernelException("PyWrap of DataArrayByte.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3749 return MEDCouplingStdReduceFunct,(DataArrayByte,((self.toNumPyArray(),),(self.__getstate__()),))
3751 def MEDCouplingDataArrayFloatReduce(self):
3752 if not MEDCouplingHasNumPyBindings():
3753 raise InterpKernelException("PyWrap of DataArrayFloat.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3754 return MEDCouplingStdReduceFunct,(DataArrayFloat,((self.toNumPyArray(),),(self.__getstate__()),))
3756 if MEDCouplingUse64BitIDs():
3757 DataArrayInt=DataArrayInt64
3759 DataArrayInt=DataArrayInt32