1 // Copyright (C) 2007-2021 CEA/DEN, EDF R&D
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 // Lesser General Public License for more details.
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
19 // Author : Anthony Geay (EDF R&D)
22 %typemap(out) MEDCoupling::DataArray*
24 $result=convertDataArray($1,$owner);
27 %typemap(out) DataArray*
29 $result=convertDataArray($1,$owner);
34 %typemap(out) MEDCoupling::DataArrayChar*
36 $result=convertDataArrayChar($1,$owner);
39 %typemap(out) DataArrayChar*
41 $result=convertDataArrayChar($1,$owner);
44 %typemap(out) MCAuto<MEDCoupling::DataArrayInt32>
46 $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt32,SWIG_POINTER_OWN|0);
49 %typemap(out) MCAuto<MEDCoupling::DataArrayInt64>
51 $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt64,SWIG_POINTER_OWN|0);
54 %typemap(out) MCAuto<MEDCoupling::DataArrayIdType>
56 $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTITraits<mcIdType>::TI,SWIG_POINTER_OWN|0);
59 %typemap(out) MCAuto<MEDCoupling::DataArrayDouble>
61 $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble,SWIG_POINTER_OWN|0);
64 %typemap(out) MCAuto<MEDCoupling::DataArrayFloat>
66 $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayFloat,SWIG_POINTER_OWN|0);
69 %typemap(out) MCAuto<MEDCoupling::MapII>
71 $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTYPE_p_MEDCoupling__MapII,SWIG_POINTER_OWN|0);
75 %newobject MEDCoupling::DataArray::deepCopy;
76 %newobject MEDCoupling::DataArray::copySorted;
77 %newobject MEDCoupling::DataArray::buildNewEmptyInstance;
78 %newobject MEDCoupling::DataArray::selectByTupleRanges;
79 %newobject MEDCoupling::DataArray::selectByTupleId;
80 %newobject MEDCoupling::DataArray::selectByTupleIdSafe;
81 %newobject MEDCoupling::DataArray::selectByTupleIdSafeSlice;
82 %newobject MEDCoupling::DataArray::Aggregate;
83 %newobject MEDCoupling::DataArrayFloat::New;
84 %newobject MEDCoupling::DataArrayFloat::iterator;
85 %newobject MEDCoupling::DataArrayFloat::__iter__;
86 %newobject MEDCoupling::DataArrayFloat::Meld;
87 %newobject MEDCoupling::DataArrayFloat::__rmul__;
88 %newobject MEDCoupling::DataArrayInt32::New;
89 %newobject MEDCoupling::DataArrayInt32::__iter__;
90 %newobject MEDCoupling::DataArrayInt32::performCopyOrIncrRef;
91 %newobject MEDCoupling::DataArrayInt32::subArray;
92 %newobject MEDCoupling::DataArrayInt32::changeNbOfComponents;
93 %newobject MEDCoupling::DataArrayInt32::accumulatePerChunck;
94 %newobject MEDCoupling::DataArrayInt32::checkAndPreparePermutation;
95 %newobject MEDCoupling::DataArrayInt32::transformWithIndArrR;
96 %newobject MEDCoupling::DataArrayInt32::renumber;
97 %newobject MEDCoupling::DataArrayInt32::renumberR;
98 %newobject MEDCoupling::DataArrayInt32::renumberAndReduce;
99 %newobject MEDCoupling::DataArrayInt32::invertArrayO2N2N2O;
100 %newobject MEDCoupling::DataArrayInt32::invertArrayN2O2O2N;
101 %newobject MEDCoupling::DataArrayInt32::invertArrayO2N2N2OBis;
102 %newobject MEDCoupling::DataArrayInt32::findIdsEqual;
103 %newobject MEDCoupling::DataArrayInt32::findIdsNotEqual;
104 %newobject MEDCoupling::DataArrayInt32::findIdsEqualList;
105 %newobject MEDCoupling::DataArrayInt32::findIdsNotEqualList;
106 %newobject MEDCoupling::DataArrayInt32::findIdsEqualTuple;
107 %newobject MEDCoupling::DataArrayInt32::findIdForEach;
108 %newobject MEDCoupling::DataArrayInt32::sumPerTuple;
109 %newobject MEDCoupling::DataArrayInt32::negate;
110 %newobject MEDCoupling::DataArrayInt32::computeAbs;
111 %newobject MEDCoupling::DataArrayInt32::findIdsInRange;
112 %newobject MEDCoupling::DataArrayInt32::findIdsNotInRange;
113 %newobject MEDCoupling::DataArrayInt32::findIdsStrictlyNegative;
114 %newobject MEDCoupling::DataArrayInt32::Aggregate;
115 %newobject MEDCoupling::DataArrayInt32::AggregateIndexes;
116 %newobject MEDCoupling::DataArrayInt32::Meld;
117 %newobject MEDCoupling::DataArrayInt32::Add;
118 %newobject MEDCoupling::DataArrayInt32::Substract;
119 %newobject MEDCoupling::DataArrayInt32::Multiply;
120 %newobject MEDCoupling::DataArrayInt32::Divide;
121 %newobject MEDCoupling::DataArrayInt32::Pow;
122 %newobject MEDCoupling::DataArrayInt32::BuildUnion;
123 %newobject MEDCoupling::DataArrayInt32::BuildIntersection;
124 %newobject MEDCoupling::DataArrayInt32::Range;
125 %newobject MEDCoupling::DataArrayInt32::indicesOfSubPart;
126 %newobject MEDCoupling::DataArrayInt32::fromNoInterlace;
127 %newobject MEDCoupling::DataArrayInt32::toNoInterlace;
128 %newobject MEDCoupling::DataArrayInt32::buildComplement;
129 %newobject MEDCoupling::DataArrayInt32::buildUnion;
130 %newobject MEDCoupling::DataArrayInt32::buildSubstraction;
131 %newobject MEDCoupling::DataArrayInt32::buildSubstractionOptimized;
132 %newobject MEDCoupling::DataArrayInt32::buildIntersection;
133 %newobject MEDCoupling::DataArrayInt32::indexOfSameConsecutiveValueGroups;
134 %newobject MEDCoupling::DataArrayInt32::buildUnique;
135 %newobject MEDCoupling::DataArrayInt32::buildUniqueNotSorted;
136 %newobject MEDCoupling::DataArrayInt32::deltaShiftIndex;
137 %newobject MEDCoupling::DataArrayInt32::buildExplicitArrByRanges;
138 %newobject MEDCoupling::DataArrayInt32::buildExplicitArrOfSliceOnScaledArr;
139 %newobject MEDCoupling::DataArrayInt32::findRangeIdForEachTuple;
140 %newobject MEDCoupling::DataArrayInt32::findIdInRangeForEachTuple;
141 %newobject MEDCoupling::DataArrayInt32::duplicateEachTupleNTimes;
142 %newobject MEDCoupling::DataArrayInt32::occurenceRankInThis;
143 %newobject MEDCoupling::DataArrayInt32::buildPermutationArr;
144 %newobject MEDCoupling::DataArrayInt32::buildPermArrPerLevel;
145 %newobject MEDCoupling::DataArrayInt32::getDifferentValues;
146 %newobject MEDCoupling::DataArrayInt32::FindPermutationFromFirstToSecond;
147 %newobject MEDCoupling::DataArrayInt32::FindPermutationFromFirstToSecondDuplicate;
148 %newobject MEDCoupling::DataArrayInt32::CheckAndPreparePermutation;
149 %newobject MEDCoupling::DataArrayInt32::__neg__;
150 %newobject MEDCoupling::DataArrayInt32::__add__;
151 %newobject MEDCoupling::DataArrayInt32::__radd__;
152 %newobject MEDCoupling::DataArrayInt32::__sub__;
153 %newobject MEDCoupling::DataArrayInt32::__rsub__;
154 %newobject MEDCoupling::DataArrayInt32::__mul__;
155 %newobject MEDCoupling::DataArrayInt32::__rmul__;
156 %newobject MEDCoupling::DataArrayInt32::__div__;
157 %newobject MEDCoupling::DataArrayInt32::__rdiv__;
158 %newobject MEDCoupling::DataArrayInt32::__mod__;
159 %newobject MEDCoupling::DataArrayInt32::__rmod__;
160 %newobject MEDCoupling::DataArrayInt32::__pow__;
161 %newobject MEDCoupling::DataArrayInt32::__rpow__;
162 %newobject MEDCoupling::DataArrayInt32::convertToInt64Arr;
163 %newobject MEDCoupling::DataArrayInt32Tuple::buildDAInt;
164 %newobject MEDCoupling::DataArrayInt64::New;
165 %newobject MEDCoupling::DataArrayInt64::__iter__;
166 %newobject MEDCoupling::DataArrayInt64::performCopyOrIncrRef;
167 %newobject MEDCoupling::DataArrayInt64::subArray;
168 %newobject MEDCoupling::DataArrayInt64::changeNbOfComponents;
169 %newobject MEDCoupling::DataArrayInt64::accumulatePerChunck;
170 %newobject MEDCoupling::DataArrayInt64::checkAndPreparePermutation;
171 %newobject MEDCoupling::DataArrayInt64::transformWithIndArrR;
172 %newobject MEDCoupling::DataArrayInt64::renumber;
173 %newobject MEDCoupling::DataArrayInt64::renumberR;
174 %newobject MEDCoupling::DataArrayInt64::renumberAndReduce;
175 %newobject MEDCoupling::DataArrayInt64::invertArrayO2N2N2O;
176 %newobject MEDCoupling::DataArrayInt64::invertArrayN2O2O2N;
177 %newobject MEDCoupling::DataArrayInt64::invertArrayO2N2N2OBis;
178 %newobject MEDCoupling::DataArrayInt64::findIdsEqual;
179 %newobject MEDCoupling::DataArrayInt64::findIdsNotEqual;
180 %newobject MEDCoupling::DataArrayInt64::findIdsEqualList;
181 %newobject MEDCoupling::DataArrayInt64::findIdsNotEqualList;
182 %newobject MEDCoupling::DataArrayInt64::findIdsEqualTuple;
183 %newobject MEDCoupling::DataArrayInt64::findIdForEach;
184 %newobject MEDCoupling::DataArrayInt64::sumPerTuple;
185 %newobject MEDCoupling::DataArrayInt64::negate;
186 %newobject MEDCoupling::DataArrayInt64::computeAbs;
187 %newobject MEDCoupling::DataArrayInt64::findIdsInRange;
188 %newobject MEDCoupling::DataArrayInt64::findIdsNotInRange;
189 %newobject MEDCoupling::DataArrayInt64::findIdsStrictlyNegative;
190 %newobject MEDCoupling::DataArrayInt64::Aggregate;
191 %newobject MEDCoupling::DataArrayInt64::AggregateIndexes;
192 %newobject MEDCoupling::DataArrayInt64::Meld;
193 %newobject MEDCoupling::DataArrayInt64::Add;
194 %newobject MEDCoupling::DataArrayInt64::Substract;
195 %newobject MEDCoupling::DataArrayInt64::Multiply;
196 %newobject MEDCoupling::DataArrayInt64::Divide;
197 %newobject MEDCoupling::DataArrayInt64::Pow;
198 %newobject MEDCoupling::DataArrayInt64::BuildUnion;
199 %newobject MEDCoupling::DataArrayInt64::BuildIntersection;
200 %newobject MEDCoupling::DataArrayInt64::Range;
201 %newobject MEDCoupling::DataArrayInt64::indicesOfSubPart;
202 %newobject MEDCoupling::DataArrayInt64::fromNoInterlace;
203 %newobject MEDCoupling::DataArrayInt64::toNoInterlace;
204 %newobject MEDCoupling::DataArrayInt64::buildComplement;
205 %newobject MEDCoupling::DataArrayInt64::buildUnion;
206 %newobject MEDCoupling::DataArrayInt64::buildSubstraction;
207 %newobject MEDCoupling::DataArrayInt64::buildSubstractionOptimized;
208 %newobject MEDCoupling::DataArrayInt64::buildIntersection;
209 %newobject MEDCoupling::DataArrayInt64::indexOfSameConsecutiveValueGroups;
210 %newobject MEDCoupling::DataArrayInt64::buildUnique;
211 %newobject MEDCoupling::DataArrayInt64::buildUniqueNotSorted;
212 %newobject MEDCoupling::DataArrayInt64::deltaShiftIndex;
213 %newobject MEDCoupling::DataArrayInt64::buildExplicitArrByRanges;
214 %newobject MEDCoupling::DataArrayInt64::buildExplicitArrOfSliceOnScaledArr;
215 %newobject MEDCoupling::DataArrayInt64::findRangeIdForEachTuple;
216 %newobject MEDCoupling::DataArrayInt64::findIdInRangeForEachTuple;
217 %newobject MEDCoupling::DataArrayInt64::duplicateEachTupleNTimes;
218 %newobject MEDCoupling::DataArrayInt64::occurenceRankInThis;
219 %newobject MEDCoupling::DataArrayInt64::buildPermutationArr;
220 %newobject MEDCoupling::DataArrayInt64::buildPermArrPerLevel;
221 %newobject MEDCoupling::DataArrayInt64::getDifferentValues;
222 %newobject MEDCoupling::DataArrayInt64::FindPermutationFromFirstToSecond;
223 %newobject MEDCoupling::DataArrayInt64::FindPermutationFromFirstToSecondDuplicate;
224 %newobject MEDCoupling::DataArrayInt64::CheckAndPreparePermutation;
225 %newobject MEDCoupling::DataArrayInt64::__neg__;
226 %newobject MEDCoupling::DataArrayInt64::__add__;
227 %newobject MEDCoupling::DataArrayInt64::__radd__;
228 %newobject MEDCoupling::DataArrayInt64::__sub__;
229 %newobject MEDCoupling::DataArrayInt64::__rsub__;
230 %newobject MEDCoupling::DataArrayInt64::__mul__;
231 %newobject MEDCoupling::DataArrayInt64::__rmul__;
232 %newobject MEDCoupling::DataArrayInt64::__div__;
233 %newobject MEDCoupling::DataArrayInt64::__rdiv__;
234 %newobject MEDCoupling::DataArrayInt64::__mod__;
235 %newobject MEDCoupling::DataArrayInt64::__rmod__;
236 %newobject MEDCoupling::DataArrayInt64::__pow__;
237 %newobject MEDCoupling::DataArrayInt64::__rpow__;
238 %newobject MEDCoupling::DataArrayInt64::convertToInt32Arr;
239 %newobject MEDCoupling::DataArrayInt64Tuple::buildDAInt;
240 %newobject MEDCoupling::DataArrayChar::convertToIntArr;
241 %newobject MEDCoupling::DataArrayChar::renumber;
242 %newobject MEDCoupling::DataArrayChar::renumberR;
243 %newobject MEDCoupling::DataArrayChar::renumberAndReduce;
244 %newobject MEDCoupling::DataArrayChar::changeNbOfComponents;
245 %newobject MEDCoupling::DataArrayChar::findIdsEqual;
246 %newobject MEDCoupling::DataArrayChar::findIdsNotEqual;
247 %newobject MEDCoupling::DataArrayChar::Aggregate;
248 %newobject MEDCoupling::DataArrayChar::Meld;
249 %newobject MEDCoupling::DataArrayByte::New;
250 %newobject MEDCoupling::DataArrayByte::__iter__;
251 %newobject MEDCoupling::DataArrayByte::performCopyOrIncrRef;
252 %newobject MEDCoupling::DataArrayByteTuple::buildDAByte;
253 %newobject MEDCoupling::DataArrayChar::subArray;
254 %newobject MEDCoupling::DataArrayAsciiChar::New;
255 %newobject MEDCoupling::DataArrayAsciiChar::__iter__;
256 %newobject MEDCoupling::DataArrayAsciiChar::performCopyOrIncrRef;
257 %newobject MEDCoupling::DataArrayAsciiCharTuple::buildDAAsciiChar;
258 %newobject MEDCoupling::DataArrayDouble::New;
259 %newobject MEDCoupling::DataArrayDouble::__iter__;
260 %newobject MEDCoupling::DataArrayDouble::performCopyOrIncrRef;
261 %newobject MEDCoupling::DataArrayDouble::Aggregate;
262 %newobject MEDCoupling::DataArrayDouble::Meld;
263 %newobject MEDCoupling::DataArrayDouble::Dot;
264 %newobject MEDCoupling::DataArrayDouble::CrossProduct;
265 %newobject MEDCoupling::DataArrayDouble::Add;
266 %newobject MEDCoupling::DataArrayDouble::Substract;
267 %newobject MEDCoupling::DataArrayDouble::Multiply;
268 %newobject MEDCoupling::DataArrayDouble::Divide;
269 %newobject MEDCoupling::DataArrayDouble::Pow;
270 %newobject MEDCoupling::DataArrayDouble::symmetry3DPlane;
271 %newobject MEDCoupling::DataArrayDouble::subArray;
272 %newobject MEDCoupling::DataArrayDouble::changeNbOfComponents;
273 %newobject MEDCoupling::DataArrayDouble::accumulatePerChunck;
274 %newobject MEDCoupling::DataArrayDouble::findIdsInRange;
275 %newobject MEDCoupling::DataArrayDouble::findIdsNotInRange;
276 %newobject MEDCoupling::DataArrayDouble::findIdsStrictlyNegative;
277 %newobject MEDCoupling::DataArrayDouble::negate;
278 %newobject MEDCoupling::DataArrayDouble::computeAbs;
279 %newobject MEDCoupling::DataArrayDouble::applyFunc;
280 %newobject MEDCoupling::DataArrayDouble::applyFuncCompo;
281 %newobject MEDCoupling::DataArrayDouble::applyFuncNamedCompo;
282 %newobject MEDCoupling::DataArrayDouble::doublyContractedProduct;
283 %newobject MEDCoupling::DataArrayDouble::determinant;
284 %newobject MEDCoupling::DataArrayDouble::eigenValues;
285 %newobject MEDCoupling::DataArrayDouble::eigenVectors;
286 %newobject MEDCoupling::DataArrayDouble::inverse;
287 %newobject MEDCoupling::DataArrayDouble::trace;
288 %newobject MEDCoupling::DataArrayDouble::deviator;
289 %newobject MEDCoupling::DataArrayDouble::magnitude;
290 %newobject MEDCoupling::DataArrayDouble::maxPerTuple;
291 %newobject MEDCoupling::DataArrayDouble::sumPerTuple;
292 %newobject MEDCoupling::DataArrayDouble::computeBBoxPerTuple;
293 %newobject MEDCoupling::DataArrayDouble::buildEuclidianDistanceDenseMatrix;
294 %newobject MEDCoupling::DataArrayDouble::buildEuclidianDistanceDenseMatrixWith;
295 %newobject MEDCoupling::DataArrayDouble::renumber;
296 %newobject MEDCoupling::DataArrayDouble::renumberR;
297 %newobject MEDCoupling::DataArrayDouble::renumberAndReduce;
298 %newobject MEDCoupling::DataArrayDouble::fromNoInterlace;
299 %newobject MEDCoupling::DataArrayDouble::toNoInterlace;
300 %newobject MEDCoupling::DataArrayDouble::fromPolarToCart;
301 %newobject MEDCoupling::DataArrayDouble::fromCylToCart;
302 %newobject MEDCoupling::DataArrayDouble::fromSpherToCart;
303 %newobject MEDCoupling::DataArrayDouble::fromCartToPolar;
304 %newobject MEDCoupling::DataArrayDouble::fromCartToCyl;
305 %newobject MEDCoupling::DataArrayDouble::fromCartToSpher;
306 %newobject MEDCoupling::DataArrayDouble::fromCartToCylGiven;
307 %newobject MEDCoupling::DataArrayDouble::cartesianize;
308 %newobject MEDCoupling::DataArrayDouble::getDifferentValues;
309 %newobject MEDCoupling::DataArrayDouble::findClosestTupleId;
310 %newobject MEDCoupling::DataArrayDouble::computeNbOfInteractionsWith;
311 %newobject MEDCoupling::DataArrayDouble::duplicateEachTupleNTimes;
312 %newobject MEDCoupling::DataArrayDouble::__neg__;
313 %newobject MEDCoupling::DataArrayDouble::__radd__;
314 %newobject MEDCoupling::DataArrayDouble::__rsub__;
315 %newobject MEDCoupling::DataArrayDouble::__rmul__;
316 %newobject MEDCoupling::DataArrayDouble::__rdiv__;
317 %newobject MEDCoupling::DataArrayDouble::__pow__;
318 %newobject MEDCoupling::DataArrayDouble::__rpow__;
319 %newobject MEDCoupling::DataArrayDoubleTuple::buildDADouble;
321 %newobject MEDCoupling::PartDefinition::New;
322 %newobject MEDCoupling::PartDefinition::toDAI;
323 %newobject MEDCoupling::PartDefinition::__add__;
324 %newobject MEDCoupling::PartDefinition::composeWith;
325 %newobject MEDCoupling::PartDefinition::tryToSimplify;
326 %newobject MEDCoupling::DataArrayPartDefinition::New;
327 %newobject MEDCoupling::SlicePartDefinition::New;
329 %newobject FromPyIntPtrToDataArrayByte;
332 %feature("unref") DataArray "$this->decrRef();"
333 %feature("unref") DataArrayDouble "$this->decrRef();"
334 %feature("unref") DataArrayInt32 "$this->decrRef();"
335 %feature("unref") DataArrayInt64 "$this->decrRef();"
336 %feature("unref") DataArrayChar "$this->decrRef();"
337 %feature("unref") DataArrayAsciiChar "$this->decrRef();"
338 %feature("unref") DataArrayByte "$this->decrRef();"
340 %feature("unref") MapII "$this->decrRef();"
341 %feature("unref") PartDefinition "$this->decrRef();"
342 %feature("unref") DataArrayPartDefinition "$this->decrRef();"
343 %feature("unref") SlicePartDefinition "$this->decrRef();"
345 namespace MEDCoupling
352 } MEDCouplingAxisType;
354 class DataArrayInt32;
355 class DataArrayInt64;
357 #ifndef MEDCOUPLING_USE_64BIT_IDS
358 typedef DataArrayInt32 DataArrayIdType;
359 #define DataArrayIdType DataArrayInt32
361 typedef DataArrayInt64 DataArrayIdType;
362 #define DataArrayIdType DataArrayInt64
365 class MapII : public RefCountObject, public TimeLabel
368 static MCAuto< MapII > New();
371 class PartDefinition : public RefCountObject, public TimeLabel
374 static PartDefinition *New(int start, int stop, int step);
375 static PartDefinition *New(DataArrayIdType *listOfIds);
376 virtual DataArrayIdType *toDAI() const;
377 virtual int getNumberOfElems() const;
378 virtual std::string getRepr() const;
379 virtual PartDefinition *composeWith(const PartDefinition *other) const;
380 virtual void checkConsistencyLight() const;
381 virtual PartDefinition *tryToSimplify() const;
384 virtual PartDefinition *__add__(const PartDefinition& other) const
386 return (*self)+other;
389 virtual PyObject *isEqual(const PartDefinition *other) const
392 bool ret0(self->isEqual(other,ret1));
393 PyObject *ret=PyTuple_New(2);
394 PyObject *ret0Py=ret0?Py_True:Py_False;
396 PyTuple_SetItem(ret,0,ret0Py);
397 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
401 virtual PyObject *deepCopy() const
403 return convertPartDefinition(self->deepCopy(),SWIG_POINTER_OWN | 0);
407 virtual ~PartDefinition();
410 class DataArrayPartDefinition : public PartDefinition
413 static DataArrayPartDefinition *New(DataArrayIdType *listOfIds);
416 DataArrayPartDefinition(DataArrayIdType *listOfIds)
418 return DataArrayPartDefinition::New(listOfIds);
421 std::string __str__() const
423 return self->getRepr();
426 std::string __repr__() const
428 std::ostringstream oss; oss << "DataArrayPartDefinition C++ instance at " << self << "." << std::endl;
429 oss << self->getRepr();
434 virtual ~DataArrayPartDefinition();
437 class SlicePartDefinition : public PartDefinition
440 static SlicePartDefinition *New(int start, int stop, int step);
441 int getEffectiveStop() const;
444 SlicePartDefinition(mcIdType start, mcIdType stop, mcIdType step)
446 return SlicePartDefinition::New(start,stop,step);
449 PyObject *getSlice() const
452 self->getSlice(a,b,c);
453 return PySlice_New(PyInt_FromLong(a),PyInt_FromLong(b),PyInt_FromLong(c));
456 std::string __str__() const
458 return self->getRepr();
461 std::string __repr__() const
463 std::ostringstream oss; oss << "SlicePartDefinition C++ instance at " << self << "." << std::endl;
464 oss << self->getRepr();
469 virtual ~SlicePartDefinition();
472 class DataArray : public RefCountObject, public TimeLabel
475 void setName(const std::string& name);
476 void copyStringInfoFrom(const DataArray& other);
477 void copyPartOfStringInfoFrom(const DataArray& other, const std::vector<std::size_t>& compoIds);
478 void copyPartOfStringInfoFrom2(const std::vector<std::size_t>& compoIds, const DataArray& other);
479 bool areInfoEqualsIfNotWhy(const DataArray& other, std::string& reason) const;
480 bool areInfoEquals(const DataArray& other) const;
481 std::string cppRepr(const std::string& varName) const;
482 std::string getName() const;
483 void setInfoOnComponents(const std::vector<std::string>& info);
484 void setInfoAndChangeNbOfCompo(const std::vector<std::string>& info);
485 std::vector<std::string> getVarsOnComponent() const;
486 std::vector<std::string> getUnitsOnComponent() const;
487 std::string getInfoOnComponent(int i) const;
488 std::string getVarOnComponent(int i) const;
489 std::string getUnitOnComponent(int i) const;
490 void setInfoOnComponent(int i, const std::string& info);
491 int getNumberOfComponents() const;
492 virtual void alloc(int nbOfTuple, int nbOfCompo=1);
493 virtual void reAlloc(int nbOfTuples);
494 virtual bool isAllocated() const;
495 virtual void checkAllocated() const;
496 virtual void desallocate();
497 virtual int getNumberOfTuples() const;
498 virtual std::size_t getNbOfElems() const;
499 virtual std::size_t getNbOfElemAllocated() const;
500 virtual DataArray *deepCopy() const;
501 virtual DataArray *copySorted() const;
502 virtual DataArray *buildNewEmptyInstance() const;
503 virtual DataArray *selectByTupleIdSafeSlice(int bg, int end2, int step) const;
504 virtual void rearrange(int newNbOfCompo);
505 virtual void circularPermutation(int nbOfShift=1);
506 virtual void circularPermutationPerTuple(int nbOfShift=1);
507 virtual void reversePerTuple();
508 void checkNbOfTuples(int nbOfTuples, const std::string& msg) const;
509 void checkNbOfComps(int nbOfCompo, const std::string& msg) const;
510 void checkNbOfTuplesAndComp(const DataArray& other, const std::string& msg) const;
511 void checkNbOfTuplesAndComp(int nbOfTuples, int nbOfCompo, const std::string& msg) const;
512 void checkNbOfElems(mcIdType nbOfElems, const std::string& msg) const;
513 static int GetNumberOfItemGivenBES(int begin, int end, int step, const std::string& msg);
514 static int GetNumberOfItemGivenBESRelative(int begin, int end, int step, const std::string& msg);
515 static int GetPosOfItemGivenBESRelativeNoThrow(int value, int begin, int end, int step);
516 static std::string GetVarNameFromInfo(const std::string& info);
517 static std::string GetUnitFromInfo(const std::string& info);
518 static std::string BuildInfoFromVarAndUnit(const std::string& var, const std::string& unit);
519 static std::string GetAxisTypeRepr(MEDCouplingAxisType at);
520 void updateTime() const;
523 PyObject *getInfoOnComponents() const
525 const std::vector<std::string>& comps=self->getInfoOnComponents();
526 PyObject *ret=PyList_New((mcIdType)comps.size());
527 for(std::size_t i=0;i<comps.size();i++)
528 PyList_SetItem(ret,i,PyString_FromString(comps[i].c_str()));
532 void copyPartOfStringInfoFrom(const DataArray& other, PyObject *li)
534 std::vector<std::size_t> tmp;
535 convertPyToNewIntArr3(li,tmp);
536 self->copyPartOfStringInfoFrom(other,tmp);
539 void copyPartOfStringInfoFrom2(PyObject *li, const DataArray& other)
541 std::vector<std::size_t> tmp;
542 convertPyToNewIntArr3(li,tmp);
543 self->copyPartOfStringInfoFrom2(tmp,other);
546 virtual void renumberInPlace(PyObject *li)
549 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
550 if (!SWIG_IsOK(res1))
553 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
554 if(size!=self->getNumberOfTuples())
556 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
558 self->renumberInPlace(tmp);
562 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
564 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
565 da2->checkAllocated();
566 mcIdType size=self->getNumberOfTuples();
567 if(size!=self->getNumberOfTuples())
569 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
571 self->renumberInPlace(da2->getConstPointer());
575 virtual void renumberInPlaceR(PyObject *li)
578 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
579 if (!SWIG_IsOK(res1))
582 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
583 if(size!=self->getNumberOfTuples())
585 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
587 self->renumberInPlaceR(tmp);
591 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
593 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
594 da2->checkAllocated();
595 mcIdType size=self->getNumberOfTuples();
596 if(size!=self->getNumberOfTuples())
598 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
600 self->renumberInPlaceR(da2->getConstPointer());
604 //tuplesSelec in PyObject * because DataArrayInt is not already existing !
605 virtual void setContigPartOfSelectedValues(mcIdType tupleIdStart, PyObject *aBase, PyObject *tuplesSelec)
607 static const char msg[]="DataArray::setContigPartOfSelectedValuesSlice : 4th parameter \"tuplesSelec\" should be of type DataArrayInt";
608 DataArray *a=CheckAndRetrieveDataArrayInstance(aBase,"DataArray::setContigPartOfSelectedValuesSlice : 3rd parameter \"aBase\" should be of type DataArray");
609 DataArray *tuplesSelecPtr=CheckAndRetrieveDataArrayInstance(tuplesSelec,msg);
610 DataArrayIdType *tuplesSelecPtr2=0;
613 tuplesSelecPtr2=dynamic_cast<DataArrayIdType *>(tuplesSelecPtr);
615 throw INTERP_KERNEL::Exception(msg);
617 self->setContigPartOfSelectedValues(tupleIdStart,a,tuplesSelecPtr2);
620 virtual void setContigPartOfSelectedValuesSlice(mcIdType tupleIdStart, PyObject *aBase, mcIdType bg, mcIdType end2, mcIdType step)
622 DataArray *a=CheckAndRetrieveDataArrayInstance(aBase,"DataArray::setContigPartOfSelectedValuesSlice : 2nd parameter \"aBase\" should be of type DataArray");
623 self->setContigPartOfSelectedValuesSlice(tupleIdStart,a,bg,end2,step);
626 virtual DataArray *selectByTupleRanges(PyObject *li) const
628 std::vector<std::pair<mcIdType,mcIdType> > ranges;
629 convertPyToVectorPairInt(li,ranges);
630 return self->selectByTupleRanges(ranges);
633 virtual DataArray *selectByTupleId(PyObject *li) const
636 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
637 if (!SWIG_IsOK(res1))
640 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
641 return self->selectByTupleId(tmp,tmp+size);
645 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
647 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
648 da2->checkAllocated();
649 return self->selectByTupleId(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
653 virtual DataArray *selectByTupleIdSafe(PyObject *li) const
656 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
657 if (!SWIG_IsOK(res1))
660 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
661 return self->selectByTupleIdSafe(tmp,tmp+size);
665 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
667 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
668 da2->checkAllocated();
669 return self->selectByTupleIdSafe(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
673 virtual PyObject *keepSelectedComponents(PyObject *li) const
675 std::vector<std::size_t> tmp;
676 convertPyToNewIntArr3(li,tmp);
677 DataArray *ret=self->keepSelectedComponents(tmp);
678 return convertDataArray(ret,SWIG_POINTER_OWN | 0 );
681 static PyObject *GetSlice(PyObject *slic, mcIdType sliceId, mcIdType nbOfSlices)
683 if(!PySlice_Check(slic))
684 throw INTERP_KERNEL::Exception("DataArray::GetSlice (wrap) : expecting a pyslice as second (first) parameter !");
685 Py_ssize_t strt=2,stp=2,step=2;
686 GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetSlice (wrap) : the input slice is invalid !");
688 DataArray::GetSlice(ToIdType(strt),ToIdType(stp),ToIdType(step),sliceId,nbOfSlices,a,b);
689 AutoPyPtr ap(PyInt_FromLong(a)),bp(PyInt_FromLong(b)),stepp(PyInt_FromLong(step));
690 return PySlice_New(ap,bp,stepp);
693 PyObject *getSlice(PyObject *slic, mcIdType sliceId, mcIdType nbOfSlices) const
695 if(!PySlice_Check(slic))
696 throw INTERP_KERNEL::Exception("DataArray::getSlice (wrap) : expecting a pyslice as second (first) parameter !");
697 Py_ssize_t strt=2,stp=2,step=2;
698 GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getSlice (wrap) : the input slice is invalid !");
700 DataArray::GetSlice(ToIdType(strt),ToIdType(stp),ToIdType(step),sliceId,nbOfSlices,a,b);
701 AutoPyPtr ap(PyInt_FromLong(a)),bp(PyInt_FromLong(b)),stepp(PyInt_FromLong(step));
702 return PySlice_New(ap,bp,stepp);
705 static mcIdType GetNumberOfItemGivenBES(PyObject *slic)
707 if(!PySlice_Check(slic))
708 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBES (wrap) : expecting a pyslice as second (first) parameter !");
709 Py_ssize_t strt=2,stp=2,step=2;
710 GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetNumberOfItemGivenBES (wrap) : the input slice is invalid !");
711 return DataArray::GetNumberOfItemGivenBES(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
714 static mcIdType GetNumberOfItemGivenBESRelative(PyObject *slic)
716 if(!PySlice_Check(slic))
717 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBESRelative (wrap) : expecting a pyslice as second (first) parameter !");
718 Py_ssize_t strt=2,stp=2,step=2;
719 GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !");
720 return DataArray::GetNumberOfItemGivenBESRelative(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
723 static DataArray *Aggregate(PyObject *arrs)
725 std::vector<const DataArray *> tmp;
726 convertFromPyObjVectorOfObj<const MEDCoupling::DataArray *>(arrs,SWIGTYPE_p_MEDCoupling__DataArray,"DataArray",tmp);
727 return DataArray::Aggregate(tmp);
730 mcIdType getNumberOfItemGivenBES(PyObject *slic) const
732 if(!PySlice_Check(slic))
733 throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBES (wrap) : expecting a pyslice as second (first) parameter !");
734 Py_ssize_t strt=2,stp=2,step=2;
735 GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getNumberOfItemGivenBES (wrap) : the input slice is invalid !");
736 return DataArray::GetNumberOfItemGivenBES(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
739 mcIdType getNumberOfItemGivenBESRelative(PyObject *slic)
741 if(!PySlice_Check(slic))
742 throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBESRelative (wrap) : expecting a pyslice as second (first) parameter !");
743 Py_ssize_t strt=2,stp=2,step=2;
744 GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !");
745 return DataArray::GetNumberOfItemGivenBESRelative(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
748 PyObject *__getstate__() const
750 PyObject *ret(PyTuple_New(2));
751 std::string a0(self->getName());
752 const std::vector<std::string> &a1(self->getInfoOnComponents());
753 PyTuple_SetItem(ret,0,PyString_FromString(a0.c_str()));
755 std::size_t sz(a1.size());
756 PyObject *ret1(PyList_New(sz));
757 for(std::size_t i=0;i<sz;i++)
758 PyList_SetItem(ret1,i,PyString_FromString(a1[i].c_str()));
759 PyTuple_SetItem(ret,1,ret1);
764 void __setstate__(PyObject *inp)
766 static const char MSG[]="DataArrayDouble.__setstate__ : expected input is a tuple of size 2 with string as 1st arg and list of string as 2nd arg !";
767 if(!PyTuple_Check(inp))
768 throw INTERP_KERNEL::Exception("DataArrayDouble.__setstate__ : invalid input ! Invalid overwrite of __getstate__ ?");
769 std::size_t sz(PyTuple_Size(inp));
771 throw INTERP_KERNEL::Exception("DataArrayDouble.__setstate__ : invalid tuple in input ! Should be of size 2 ! Invalid overwrite of __getstate__ ?");
772 PyObject *a0(PyTuple_GetItem(inp,0));
773 self->setName(convertPyObjectToStr(a0,MSG));
774 PyObject *a1(PyTuple_GetItem(inp,1));
775 std::vector<std::string> a1cpp;
776 if(!fillStringVector(a1,a1cpp))
777 throw INTERP_KERNEL::Exception(MSG);
778 self->setInfoOnComponents(a1cpp);
783 class DataArrayDouble;
785 class DataArrayFloat : public DataArray
788 static DataArrayFloat *New();
789 void fillWithValue(float val);
790 bool isEqual(const DataArrayFloat& other, float prec) const;
791 bool isEqualWithoutConsideringStr(const DataArrayFloat& other, float prec) const;
792 bool isUniform(float val, float eps) const;
793 void pushBackSilent(float val);
794 void iota(float init=0.);
795 DataArrayFloatIterator *iterator();
796 MCAuto<DataArrayDouble> convertToDblArr() const;
797 static DataArrayFloat *Meld(const DataArrayFloat *a1, const DataArrayFloat *a2);
802 return DataArrayFloat::New();
805 static DataArrayFloat *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
807 return DataArrayT_New<float>(elt0,nbOfTuples,elt2);
810 DataArrayFloat(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
812 return MEDCoupling_DataArrayFloat_New__SWIG_1(elt0,nbOfTuples,elt2);
815 DataArrayFloatIterator *__iter__()
817 return self->iterator();
820 std::string __repr__() const
822 std::ostringstream oss;
823 self->reprQuickOverview(oss);
827 std::string __str__() const
829 return self->reprNotTooLong();
832 mcIdType __len__() const
834 if(self->isAllocated())
836 return self->getNumberOfTuples();
840 throw INTERP_KERNEL::Exception("DataArrayFloat::__len__ : Instance is NOT allocated !");
844 PyObject *getValues() const
846 const float *vals(self->begin());
847 return convertDblArrToPyList<float>(vals,self->getNbOfElems());
850 PyObject *getValuesAsTuple() const
852 const float *vals(self->begin());
853 std::size_t nbOfComp(self->getNumberOfComponents());
854 mcIdType nbOfTuples(self->getNumberOfTuples());
855 return convertDblArrToPyListOfTuple<float>(vals,nbOfComp,nbOfTuples);
858 PyObject *isEqualIfNotWhy(const DataArrayFloat& other, float prec) const
861 bool ret0=self->isEqualIfNotWhy(other,prec,ret1);
862 PyObject *ret=PyTuple_New(2);
863 PyObject *ret0Py=ret0?Py_True:Py_False;
865 PyTuple_SetItem(ret,0,ret0Py);
866 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
870 PyObject *__getitem__(PyObject *obj)
872 return DataArrayT__getitem<float>(self,obj);
875 DataArrayFloat *__setitem__(PyObject *obj, PyObject *value)
877 return DataArrayT__setitem__<float>(self,obj,value);
880 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
882 return DataArrayT_iadd<float>(trueSelf,obj,self);
885 PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
887 return DataArrayT_isub<float>(trueSelf,obj,self);
890 PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
892 return DataArrayT_imul<float>(trueSelf,obj,self);
895 DataArrayFloat *__rmul__(PyObject *obj)
897 return DataArrayFPT_rmul<float>(self,obj);
900 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
902 return DataArrayT_idiv<float>(trueSelf,obj,self);
906 PyObject *toNumPyArray() // not const. It is not a bug !
908 return ToNumPyArray<DataArrayFloat,float>(self,NPY_FLOAT,"DataArrayFloat");
914 class DataArrayFloatTuple;
916 class DataArrayFloatIterator
919 DataArrayFloatIterator(DataArrayFloat *da);
920 ~DataArrayFloatIterator();
925 DataArrayFloatTuple *ret=self->nextt();
927 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayFloatTuple,SWIG_POINTER_OWN|0);
930 PyErr_SetString(PyExc_StopIteration,"No more data.");
937 class DataArrayFloatTuple
940 std::size_t getNumberOfCompo() const;
941 DataArrayFloat *buildDAFloat(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
944 std::string __str__() const
949 float __float__() const
951 return self->floatValue();
954 DataArrayFloat *buildDAFloat()
956 return self->buildDAFloat(1,self->getNumberOfCompo());
959 /*PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
961 MCAuto<DataArrayFloat> ret=self->buildDAFloat(1,self->getNumberOfCompo());
962 MEDCoupling_DataArrayFloat____imul___(ret,0,obj);
963 Py_XINCREF(trueSelf);
969 return PyInt_FromLong(self->getNumberOfCompo());
974 class DataArrayDoubleIterator;
976 class DataArrayDouble : public DataArray
979 static DataArrayDouble *New();
980 double doubleValue() const;
982 void aggregate(const DataArrayDouble *other);
983 DataArrayDouble *performCopyOrIncrRef(bool deepCopy) const;
984 void deepCopyFrom(const DataArrayDouble& other);
985 void reserve(std::size_t nbOfElems);
986 void pushBackSilent(double val);
987 double popBackSilent();
989 void allocIfNecessary(int nbOfTuple, int nbOfCompo);
991 void fillWithValue(double val);
992 void iota(double init=0.);
993 bool isUniform(double val, double eps) const;
994 void sort(bool asc=true);
996 void checkMonotonic(bool increasing, double eps) const;
997 bool isMonotonic(bool increasing, double eps) const;
998 std::string repr() const;
999 std::string reprZip() const;
1000 std::string reprNotTooLong() const;
1001 bool isEqual(const DataArrayDouble& other, double prec) const;
1002 bool isEqualWithoutConsideringStr(const DataArrayDouble& other, double prec) const;
1003 DataArrayDouble *fromNoInterlace() const;
1004 DataArrayDouble *toNoInterlace() const;
1005 DataArrayDouble *subArray(int tupleIdBg, int tupleIdEnd=-1) const;
1007 DataArrayDouble *changeNbOfComponents(std::size_t newNbOfComp, double dftValue) const;
1008 void meldWith(const DataArrayDouble *other);
1009 DataArrayDouble *duplicateEachTupleNTimes(int nbTimes) const;
1010 DataArrayDouble *getDifferentValues(double prec, int limitTupleId=-1) const;
1011 DataArrayIdType *findClosestTupleId(const DataArrayDouble *other) const;
1012 DataArrayIdType *computeNbOfInteractionsWith(const DataArrayDouble *otherBBoxFrmt, double eps) const;
1013 void setPartOfValues1(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare=true);
1014 void setPartOfValuesSimple1(double a, mcIdType bgTuples, mcIdType endTuples, mcIdType stepTuples, mcIdType bgComp, mcIdType endComp, mcIdType stepComp);
1015 void setPartOfValuesAdv(const DataArrayDouble *a, const DataArrayIdType *tuplesSelec);
1016 double getIJ(int tupleId, int compoId) const;
1017 double front() const;
1018 double back() const;
1019 double getIJSafe(int tupleId, int compoId) const;
1020 void setIJ(int tupleId, int compoId, double newVal);
1021 void setIJSilent(int tupleId, int compoId, double newVal);
1022 double *getPointer();
1023 void checkNoNullValues() const;
1024 DataArrayDouble *computeBBoxPerTuple(double epsilon=0.0) const;
1025 void recenterForMaxPrecision(double eps);
1026 double getMaxValueInArray() const;
1027 double getMaxAbsValueInArray() const;
1028 double getMinValueInArray() const;
1029 int count(double value, double eps) const;
1030 double getAverageValue() const;
1031 double norm2() const;
1032 double normMax() const;
1033 double normMin() const;
1034 double accumulate(int compId) const;
1035 DataArrayDouble *fromPolarToCart() const;
1036 DataArrayDouble *fromCylToCart() const;
1037 DataArrayDouble *fromSpherToCart() const;
1038 DataArrayDouble *fromCartToPolar() const;
1039 DataArrayDouble *fromCartToCyl() const;
1040 DataArrayDouble *fromCartToSpher() const;
1041 DataArrayDouble *cartesianize(MEDCouplingAxisType atOfThis) const;
1042 DataArrayDouble *doublyContractedProduct() const;
1043 DataArrayDouble *determinant() const;
1044 DataArrayDouble *eigenValues() const;
1045 DataArrayDouble *eigenVectors() const;
1046 DataArrayDouble *inverse() const;
1047 DataArrayDouble *trace() const;
1048 DataArrayDouble *deviator() const;
1049 DataArrayDouble *magnitude() const;
1050 DataArrayDouble *maxPerTuple() const;
1051 DataArrayDouble *sumPerTuple() const;
1052 DataArrayDouble *buildEuclidianDistanceDenseMatrix() const;
1053 DataArrayDouble *buildEuclidianDistanceDenseMatrixWith(const DataArrayDouble *other) const;
1054 void sortPerTuple(bool asc);
1056 DataArrayDouble *computeAbs() const;
1057 void applyLin(double a, double b, int compoId);
1058 void applyLin(double a, double b);
1059 void applyInv(double numerator);
1060 void applyPow(double val);
1061 void applyRPow(double val);
1062 DataArrayDouble *negate() const;
1063 DataArrayDouble *applyFunc(int nbOfComp, FunctionToEvaluate func) const;
1064 DataArrayDouble *applyFunc(int nbOfComp, const std::string& func, bool isSafe=true) const;
1065 DataArrayDouble *applyFunc(const std::string& func, bool isSafe=true) const;
1066 void applyFuncOnThis(const std::string& func, bool isSafe=true);
1067 DataArrayDouble *applyFuncCompo(int nbOfComp, const std::string& func, bool isSafe=true) const;
1068 DataArrayDouble *applyFuncNamedCompo(int nbOfComp, const std::vector<std::string>& varsOrder, const std::string& func, bool isSafe=true) const;
1069 void applyFuncFast32(const std::string& func);
1070 void applyFuncFast64(const std::string& func);
1071 DataArrayIdType *findIdsInRange(double vmin, double vmax) const;
1072 DataArrayIdType *findIdsNotInRange(double vmin, double vmax) const;
1073 DataArrayIdType *findIdsStrictlyNegative() const;
1074 static DataArrayDouble *Aggregate(const DataArrayDouble *a1, const DataArrayDouble *a2);
1075 static DataArrayDouble *Meld(const DataArrayDouble *a1, const DataArrayDouble *a2);
1076 static DataArrayDouble *Dot(const DataArrayDouble *a1, const DataArrayDouble *a2);
1077 static DataArrayDouble *CrossProduct(const DataArrayDouble *a1, const DataArrayDouble *a2);
1078 static DataArrayDouble *Max(const DataArrayDouble *a1, const DataArrayDouble *a2);
1079 static DataArrayDouble *Min(const DataArrayDouble *a1, const DataArrayDouble *a2);
1080 static DataArrayDouble *Add(const DataArrayDouble *a1, const DataArrayDouble *a2);
1081 void addEqual(const DataArrayDouble *other);
1082 static DataArrayDouble *Substract(const DataArrayDouble *a1, const DataArrayDouble *a2);
1083 void substractEqual(const DataArrayDouble *other);
1084 static DataArrayDouble *Multiply(const DataArrayDouble *a1, const DataArrayDouble *a2);
1085 void multiplyEqual(const DataArrayDouble *other);
1086 static DataArrayDouble *Divide(const DataArrayDouble *a1, const DataArrayDouble *a2);
1087 void divideEqual(const DataArrayDouble *other);
1088 static DataArrayDouble *Pow(const DataArrayDouble *a1, const DataArrayDouble *a2);
1089 void powEqual(const DataArrayDouble *other);
1090 MCAuto<DataArrayIdType> findIdsGreaterOrEqualTo(double val) const;
1091 MCAuto<DataArrayIdType> findIdsGreaterThan(double val) const;
1092 MCAuto<DataArrayIdType> findIdsLowerOrEqualTo(double val) const;
1093 MCAuto<DataArrayIdType> findIdsLowerThan(double val) const;
1094 MCAuto<DataArrayInt32> convertToIntArr() const;
1095 MCAuto<DataArrayDouble> selectPartDef(const PartDefinition* pd) const;
1096 MCAuto<DataArrayDouble> cumSum() const;
1097 MCAuto<DataArrayFloat> convertToFloatArr() const;
1102 return DataArrayDouble::New();
1105 static DataArrayDouble *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
1107 return DataArrayT_New<double>(elt0,nbOfTuples,elt2);
1110 DataArrayDouble(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
1112 return MEDCoupling_DataArrayDouble_New__SWIG_1(elt0,nbOfTuples,elt2);
1115 void pushBackValsSilent(PyObject *li)
1118 std::vector<double> bb;
1119 mcIdType sw; mcIdType nbTuples=-1;
1120 const char msg[]="Python wrap of DataArrayDouble::pushBackValsSilent : ";
1121 const double *tmp=convertObjToPossibleCpp5_SingleCompo(li,sw,val,bb,msg,true,nbTuples);
1122 self->pushBackValsSilent(tmp,tmp+nbTuples);
1125 std::string __repr__() const
1127 std::ostringstream oss;
1128 self->reprQuickOverview(oss);
1132 std::string __str__() const
1134 return self->reprNotTooLong();
1137 double __float__() const
1139 return self->doubleValue();
1142 mcIdType __len__() const
1144 if(self->isAllocated())
1146 return self->getNumberOfTuples();
1150 throw INTERP_KERNEL::Exception("DataArrayDouble::__len__ : Instance is NOT allocated !");
1154 PyObject *asArcOfCircle() const
1156 double center[2],radius,ang;
1157 self->asArcOfCircle(center,radius,ang);
1158 PyObject *ret(PyTuple_New(3));
1160 PyObject *ret0(PyList_New(2));
1161 PyList_SetItem(ret0,0,PyFloat_FromDouble(center[0]));
1162 PyList_SetItem(ret0,1,PyFloat_FromDouble(center[1]));
1163 PyTuple_SetItem(ret,0,ret0);
1165 PyTuple_SetItem(ret,1,PyFloat_FromDouble(radius));
1166 PyTuple_SetItem(ret,2,PyFloat_FromDouble(ang));
1170 DataArrayDoubleIterator *__iter__()
1172 return self->iterator();
1175 void setValues(PyObject *li, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
1177 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 !";
1178 if(PyList_Check(li) || PyTuple_Check(li))
1180 if(nbOfTuples && nbOfTuples != Py_None)
1182 if(PyInt_Check(nbOfTuples))
1184 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
1186 throw INTERP_KERNEL::Exception("DataArrayDouble::setValues : should be a positive set of allocated memory !");
1187 if(nbOfComp && nbOfComp != Py_None)
1189 if(PyInt_Check(nbOfComp))
1190 {//DataArrayDouble.setValues([1.,3.,4.,5.],2,2)
1191 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
1193 throw INTERP_KERNEL::Exception("DataArrayDouble::setValues : should be a positive number of components !");
1194 std::vector<double> tmp=fillArrayWithPyListDbl2(li,nbOfTuples1,nbOfCompo);
1195 self->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1198 throw INTERP_KERNEL::Exception(msg);
1201 {//DataArrayDouble.setValues([1.,3.,4.],3)
1203 std::vector<double> tmp=fillArrayWithPyListDbl2(li,nbOfTuples1,tmpp1);
1204 self->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1208 throw INTERP_KERNEL::Exception(msg);
1211 {// DataArrayDouble.setValues([1.,3.,4.])
1212 mcIdType tmpp1=-1,tmpp2=-1;
1213 std::vector<double> tmp=fillArrayWithPyListDbl2(li,tmpp1,tmpp2);
1214 self->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1218 throw INTERP_KERNEL::Exception(msg);
1221 PyObject *getValues() const
1223 const double *vals(self->begin());
1224 return convertDblArrToPyList<double>(vals,self->getNbOfElems());
1228 PyObject *toNumPyArray() // not const. It is not a bug !
1230 return ToNumPyArray<DataArrayDouble,double>(self,NPY_DOUBLE,"DataArrayDouble");
1234 PyObject *isEqualIfNotWhy(const DataArrayDouble& other, double prec) const
1237 bool ret0=self->isEqualIfNotWhy(other,prec,ret1);
1238 PyObject *ret=PyTuple_New(2);
1239 PyObject *ret0Py=ret0?Py_True:Py_False;
1241 PyTuple_SetItem(ret,0,ret0Py);
1242 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
1246 PyObject *getValuesAsTuple() const
1248 const double *vals(self->begin());
1249 std::size_t nbOfComp(self->getNumberOfComponents());
1250 mcIdType nbOfTuples(self->getNumberOfTuples());
1251 return convertDblArrToPyListOfTuple<double>(vals,nbOfComp,nbOfTuples);
1254 static PyObject *ComputeIntegralOfSeg2IntoTri3(PyObject *seg2, PyObject *tri3)
1256 const char msg[]="Python wrap of DataArrayDouble::ComputeIntegralOfSeg2IntoTri3 : ";
1258 DataArrayDouble *a,*a2;
1259 DataArrayDoubleTuple *aa,*aa2;
1260 std::vector<double> bb,bb2;
1262 const double *seg2Ptr(convertObjToPossibleCpp5_Safe(seg2,sw,val,a,aa,bb,msg,2,2,true));
1263 const double *tri3Ptr(convertObjToPossibleCpp5_Safe(tri3,sw,val2,a2,aa2,bb2,msg,3,2,true));
1265 double res0[3],res1;
1266 DataArrayDouble::ComputeIntegralOfSeg2IntoTri3(seg2Ptr,tri3Ptr,res0,res1);
1267 PyObject *ret(PyTuple_New(2)),*ret0(PyTuple_New(3));
1268 PyTuple_SetItem(ret0,0,PyFloat_FromDouble(res0[0]));
1269 PyTuple_SetItem(ret0,1,PyFloat_FromDouble(res0[1]));
1270 PyTuple_SetItem(ret0,2,PyFloat_FromDouble(res0[2]));
1271 PyTuple_SetItem(ret,0,ret0);
1272 PyTuple_SetItem(ret,1,PyFloat_FromDouble(res1));
1276 DataArrayDouble *symmetry3DPlane(PyObject *point, PyObject *normalVector)
1278 const char msg[]="Python wrap of DataArrayDouble::symmetry3DPlane : ";
1280 DataArrayDouble *a,*a2;
1281 DataArrayDoubleTuple *aa,*aa2;
1282 std::vector<double> bb,bb2;
1284 const double *centerPtr(convertObjToPossibleCpp5_Safe(point,sw,val,a,aa,bb,msg,1,3,true));
1285 const double *vectorPtr(convertObjToPossibleCpp5_Safe(normalVector,sw,val2,a2,aa2,bb2,msg,1,3,true));
1286 MCAuto<DataArrayDouble> ret(self->symmetry3DPlane(centerPtr,vectorPtr));
1290 static PyObject *GiveBaseForPlane(PyObject *normalVector)
1292 const char msg[]="Python wrap of DataArrayDouble::GiveBaseForPlane : ";
1295 DataArrayDoubleTuple *aa;
1296 std::vector<double> bb,bb2;
1298 const double *vectorPtr(convertObjToPossibleCpp5_Safe(normalVector,sw,val,a,aa,bb,msg,1,3,true));
1300 DataArrayDouble::GiveBaseForPlane(vectorPtr,res);
1301 return convertDblArrToPyListOfTuple<double>(res,3,3);
1304 DataArrayDouble *fromCartToCylGiven(const DataArrayDouble *coords, PyObject *center, PyObject *vector) const
1306 const char msg[]="Python wrap of DataArrayDouble::fromCartToCylGiven : ";
1308 DataArrayDouble *a,*a2;
1309 DataArrayDoubleTuple *aa,*aa2;
1310 std::vector<double> bb,bb2;
1312 const double *centerPtr=convertObjToPossibleCpp5_Safe(center,sw,val,a,aa,bb,msg,1,3,true);
1313 const double *vectorPtr=convertObjToPossibleCpp5_Safe(vector,sw,val2,a2,aa2,bb2,msg,1,3,true);
1314 return self->fromCartToCylGiven(coords,centerPtr,vectorPtr);
1317 DataArrayDouble *renumber(PyObject *li)
1320 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
1321 if (!SWIG_IsOK(res1))
1324 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1325 if(size!=self->getNumberOfTuples())
1327 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1329 return self->renumber(tmp);
1333 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1335 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1336 da2->checkAllocated();
1337 mcIdType size=self->getNumberOfTuples();
1338 if(size!=self->getNumberOfTuples())
1340 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1342 return self->renumber(da2->getConstPointer());
1346 DataArrayDouble *renumberR(PyObject *li)
1349 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
1350 if (!SWIG_IsOK(res1))
1353 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1354 if(size!=self->getNumberOfTuples())
1356 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1358 return self->renumberR(tmp);
1362 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1364 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1365 da2->checkAllocated();
1366 mcIdType size=self->getNumberOfTuples();
1367 if(size!=self->getNumberOfTuples())
1369 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1371 return self->renumberR(da2->getConstPointer());
1375 DataArrayDouble *renumberAndReduce(PyObject *li, mcIdType newNbOfTuple)
1378 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
1379 if (!SWIG_IsOK(res1))
1382 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1383 if(size!=self->getNumberOfTuples())
1385 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1387 return self->renumberAndReduce(tmp,newNbOfTuple);
1391 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1393 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1394 da2->checkAllocated();
1395 mcIdType size=self->getNumberOfTuples();
1396 if(size!=self->getNumberOfTuples())
1398 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1400 return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
1404 PyObject *minimalDistanceTo(const DataArrayDouble *other) const
1406 mcIdType thisTupleId,otherTupleId;
1407 double r0=self->minimalDistanceTo(other,thisTupleId,otherTupleId);
1408 PyObject *ret=PyTuple_New(3);
1409 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r0));
1410 PyTuple_SetItem(ret,1,PyInt_FromLong(thisTupleId));
1411 PyTuple_SetItem(ret,2,PyInt_FromLong(otherTupleId));
1415 PyObject *getMaxValue() const
1418 double r1=self->getMaxValue(tmp);
1419 PyObject *ret=PyTuple_New(2);
1420 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1421 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1425 PyObject *getMaxAbsValue() const
1428 double r1=self->getMaxAbsValue(tmp);
1429 PyObject *ret=PyTuple_New(2);
1430 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1431 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1435 PyObject *getMaxValue2() const
1437 DataArrayIdType *tmp;
1438 double r1=self->getMaxValue2(tmp);
1439 PyObject *ret=PyTuple_New(2);
1440 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1441 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1445 PyObject *getMinValue() const
1448 double r1=self->getMinValue(tmp);
1449 PyObject *ret=PyTuple_New(2);
1450 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1451 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1455 PyObject *getMinValue2() const
1457 DataArrayIdType *tmp;
1458 double r1=self->getMinValue2(tmp);
1459 PyObject *ret=PyTuple_New(2);
1460 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1461 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1465 PyObject *getMinMaxPerComponent() const
1467 std::size_t nbOfCompo(self->getNumberOfComponents());
1468 INTERP_KERNEL::AutoPtr<double> tmp(new double[2*nbOfCompo]);
1469 self->getMinMaxPerComponent(tmp);
1470 PyObject *ret=convertDblArrToPyListOfTuple<double>(tmp,2,ToIdType(nbOfCompo));
1474 PyObject *normMaxPerComponent() const
1476 std::size_t nbOfCompo(self->getNumberOfComponents());
1477 INTERP_KERNEL::AutoPtr<double> tmp(new double[nbOfCompo]);
1478 self->normMaxPerComponent(tmp);
1479 return convertDblArrToPyList<double>(tmp,ToIdType(nbOfCompo));
1482 PyObject *accumulate() const
1484 std::size_t sz=self->getNumberOfComponents();
1485 INTERP_KERNEL::AutoPtr<double> tmp=new double[sz];
1486 self->accumulate(tmp);
1487 return convertDblArrToPyList<double>(tmp,ToIdType(sz));
1490 DataArrayDouble *accumulatePerChunck(PyObject *indexArr) const
1492 mcIdType sw, sz,val;
1493 std::vector<mcIdType> val2;
1494 const mcIdType *bg=convertIntStarLikePyObjToCppIntStar(indexArr,sw,sz,val,val2);
1495 return self->accumulatePerChunck(bg,bg+sz);
1498 PyObject *findCommonTuples(double prec, mcIdType limitNodeId=-1) const
1500 DataArrayIdType *comm, *commIndex;
1501 self->findCommonTuples(prec,limitNodeId,comm,commIndex);
1502 PyObject *res = PyList_New(2);
1503 PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(comm),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1504 PyList_SetItem(res,1,SWIG_NewPointerObj(SWIG_as_voidptr(commIndex),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1508 PyObject *distanceToTuple(PyObject *tuple) const
1512 DataArrayDoubleTuple *aa;
1513 std::vector<double> bb;
1515 mcIdType tupleId=-1;
1516 std::size_t nbOfCompo=self->getNumberOfComponents();
1517 const double *pt=convertObjToPossibleCpp5_Safe(tuple,sw,val,a,aa,bb,"Python wrap of DataArrayDouble::distanceToTuple",1,(int)nbOfCompo,true);
1519 double ret0=self->distanceToTuple(pt,pt+nbOfCompo,tupleId);
1520 PyObject *ret=PyTuple_New(2);
1521 PyTuple_SetItem(ret,0,PyFloat_FromDouble(ret0));
1522 PyTuple_SetItem(ret,1,PyInt_FromLong(tupleId));
1526 void setSelectedComponents(const DataArrayDouble *a, PyObject *li)
1528 std::vector<std::size_t> tmp;
1529 convertPyToNewIntArr3(li,tmp);
1530 self->setSelectedComponents(a,tmp);
1533 PyObject *explodeComponents() const
1535 std::vector< MCAuto<DataArrayDouble> > retCpp(self->explodeComponents());
1536 std::size_t sz(retCpp.size());
1537 PyObject *res(PyList_New(sz));
1538 for(std::size_t i=0;i<sz;i++)
1539 PyList_SetItem(res,i,SWIG_NewPointerObj(SWIG_as_voidptr(retCpp[i].retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ));
1543 PyObject *getTuple(mcIdType tupleId)
1545 std::size_t sz=self->getNumberOfComponents();
1546 INTERP_KERNEL::AutoPtr<double> tmp=new double[sz];
1547 self->getTuple(tupleId,tmp);
1548 return convertDblArrToPyList<double>(tmp,ToIdType(sz));
1551 static DataArrayDouble *Aggregate(PyObject *li)
1553 std::vector<const DataArrayDouble *> tmp;
1554 convertFromPyObjVectorOfObj<const DataArrayDouble *>(li,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",tmp);
1555 return DataArrayDouble::Aggregate(tmp);
1558 static DataArrayDouble *Meld(PyObject *li)
1560 std::vector<const DataArrayDouble *> tmp;
1561 convertFromPyObjVectorOfObj<const DataArrayDouble *>(li,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",tmp);
1562 return DataArrayDouble::Meld(tmp);
1565 PyObject *computeTupleIdsNearTuples(PyObject *pt, double eps) const
1569 DataArrayDoubleTuple *aa;
1570 std::vector<double> bb;
1572 std::size_t nbComp=self->getNumberOfComponents();
1573 mcIdType nbTuples=-1;
1574 const char msg[]="Python wrap of DataArrayDouble::computeTupleIdsNearTuples : ";
1575 const double *pos=convertObjToPossibleCpp5_Safe2(pt,sw,val,a,aa,bb,msg,(int)nbComp,true,nbTuples);
1576 MCAuto<DataArrayDouble> inpu=DataArrayDouble::New(); inpu->useArray(pos,false,DeallocType::CPP_DEALLOC,nbTuples,nbComp);
1577 DataArrayIdType *c=0,*cI=0;
1578 self->computeTupleIdsNearTuples(inpu,eps,c,cI);
1579 PyObject *ret=PyTuple_New(2);
1580 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1581 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1585 PyObject *areIncludedInMe(const DataArrayDouble *other, double prec) const
1587 DataArrayIdType *ret1=0;
1588 bool ret0=self->areIncludedInMe(other,prec,ret1);
1589 PyObject *ret=PyTuple_New(2);
1590 PyObject *ret0Py=ret0?Py_True:Py_False;
1592 PyTuple_SetItem(ret,0,ret0Py);
1593 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1597 PyObject *__getitem__(PyObject *obj)
1599 return DataArrayT__getitem<double>(self,obj);
1602 DataArrayDouble *__setitem__(PyObject *obj, PyObject *value)
1604 return DataArrayT__setitem__<double>(self,obj,value);
1607 DataArrayDouble *__neg__() const
1609 return self->negate();
1612 PyObject *__add__(PyObject *obj)
1614 const char msg[]="Unexpected situation in DataArrayDouble.__add__ !";
1617 DataArrayDoubleTuple *aa;
1618 std::vector<double> bb;
1621 #ifndef WITHOUT_AUTOFIELD
1623 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1625 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1628 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1629 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___radd__Impl(other,tmp);
1631 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1634 throw INTERP_KERNEL::Exception(msg);
1638 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1643 MCAuto<DataArrayDouble> ret=self->deepCopy();
1644 ret->applyLin(1.,val);
1645 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1649 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1653 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1654 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1658 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1659 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1662 throw INTERP_KERNEL::Exception(msg);
1666 DataArrayDouble *__radd__(PyObject *obj)
1668 const char msg[]="Unexpected situation in __radd__ !";
1671 DataArrayDoubleTuple *aa;
1672 std::vector<double> bb;
1674 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1679 MCAuto<DataArrayDouble> ret=self->deepCopy();
1680 ret->applyLin(1.,val);
1685 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1686 return DataArrayDouble::Add(self,aaa);
1690 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1691 return DataArrayDouble::Add(self,aaa);
1694 throw INTERP_KERNEL::Exception(msg);
1698 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
1700 return DataArrayT_iadd<double>(trueSelf,obj,self);
1703 PyObject *__sub__(PyObject *obj)
1705 const char msg[]="Unexpected situation in __sub__ !";
1708 DataArrayDoubleTuple *aa;
1709 std::vector<double> bb;
1712 #ifndef WITHOUT_AUTOFIELD
1714 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1716 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1719 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1720 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rsub__Impl(other,tmp);
1722 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1725 throw INTERP_KERNEL::Exception(msg);
1729 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1734 MCAuto<DataArrayDouble> ret=self->deepCopy();
1735 ret->applyLin(1.,-val);
1736 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1740 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1744 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1745 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1749 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1750 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1753 throw INTERP_KERNEL::Exception(msg);
1757 DataArrayDouble *__rsub__(PyObject *obj)
1759 const char msg[]="Unexpected situation in __rsub__ !";
1762 DataArrayDoubleTuple *aa;
1763 std::vector<double> bb;
1765 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1770 MCAuto<DataArrayDouble> ret=self->deepCopy();
1771 ret->applyLin(-1.,val);
1776 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1777 return DataArrayDouble::Substract(aaa,self);
1781 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1782 return DataArrayDouble::Substract(aaa,self);
1785 throw INTERP_KERNEL::Exception(msg);
1789 PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
1791 return DataArrayT_isub<double>(trueSelf,obj,self);
1794 PyObject *__mul__(PyObject *obj)
1796 const char msg[]="Unexpected situation in __mul__ !";
1799 DataArrayDoubleTuple *aa;
1800 std::vector<double> bb;
1803 #ifndef WITHOUT_AUTOFIELD
1805 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1807 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1810 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1811 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rmul__Impl(other,tmp);
1813 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1816 throw INTERP_KERNEL::Exception(msg);
1820 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1825 MCAuto<DataArrayDouble> ret=self->deepCopy();
1826 ret->applyLin(val,0.);
1827 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1831 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1835 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1836 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1840 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1841 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1844 throw INTERP_KERNEL::Exception(msg);
1848 DataArrayDouble *__rmul__(PyObject *obj)
1850 return DataArrayFPT_rmul<double>(self,obj);
1853 PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
1855 return DataArrayT_imul<double>(trueSelf,obj,self);
1858 PyObject *__div__(PyObject *obj)
1860 const char msg[]="Unexpected situation in __div__ !";
1863 DataArrayDoubleTuple *aa;
1864 std::vector<double> bb;
1867 #ifndef WITHOUT_AUTOFIELD
1869 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1871 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1874 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1875 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rdiv__Impl(other,tmp);
1877 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1880 throw INTERP_KERNEL::Exception(msg);
1884 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1890 throw INTERP_KERNEL::Exception("DataArrayDouble::__div__ : trying to divide by zero !");
1891 MCAuto<DataArrayDouble> ret=self->deepCopy();
1892 ret->applyLin(1/val,0.);
1893 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1897 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1901 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1902 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1906 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1907 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1910 throw INTERP_KERNEL::Exception(msg);
1914 DataArrayDouble *__rdiv__(PyObject *obj)
1916 const char msg[]="Unexpected situation in __rdiv__ !";
1919 DataArrayDoubleTuple *aa;
1920 std::vector<double> bb;
1922 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1927 MCAuto<DataArrayDouble> ret=self->deepCopy();
1933 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1934 return DataArrayDouble::Divide(aaa,self);
1938 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1939 return DataArrayDouble::Divide(aaa,self);
1942 throw INTERP_KERNEL::Exception(msg);
1946 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
1948 return DataArrayT_idiv<double>(trueSelf,obj,self);
1951 DataArrayDouble *__pow__(PyObject *obj)
1953 const char msg[]="Unexpected situation in __pow__ !";
1956 DataArrayDoubleTuple *aa;
1957 std::vector<double> bb;
1959 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1964 MCAuto<DataArrayDouble> ret=self->deepCopy();
1970 return DataArrayDouble::Pow(self,a);
1974 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1975 return DataArrayDouble::Pow(self,aaa);
1979 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1980 return DataArrayDouble::Pow(self,aaa);
1983 throw INTERP_KERNEL::Exception(msg);
1987 DataArrayDouble *__rpow__(PyObject *obj)
1989 const char msg[]="Unexpected situation in __rpow__ !";
1992 DataArrayDoubleTuple *aa;
1993 std::vector<double> bb;
1995 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
2000 MCAuto<DataArrayDouble> ret=self->deepCopy();
2001 ret->applyRPow(val);
2006 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
2007 return DataArrayDouble::Pow(aaa,self);
2011 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
2012 return DataArrayDouble::Pow(aaa,self);
2015 throw INTERP_KERNEL::Exception(msg);
2019 PyObject *___ipow___(PyObject *trueSelf, PyObject *obj)
2021 const char msg[]="Unexpected situation in __ipow__ !";
2024 DataArrayDoubleTuple *aa;
2025 std::vector<double> bb;
2027 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
2032 self->applyPow(val);
2033 Py_XINCREF(trueSelf);
2039 Py_XINCREF(trueSelf);
2044 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
2045 self->powEqual(aaa);
2046 Py_XINCREF(trueSelf);
2051 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
2052 self->powEqual(aaa);
2053 Py_XINCREF(trueSelf);
2057 throw INTERP_KERNEL::Exception(msg);
2061 PyObject *computeTupleIdsNearTuples(const DataArrayDouble *other, double eps)
2063 DataArrayIdType *c=0,*cI=0;
2065 self->computeTupleIdsNearTuples(other,eps,c,cI);
2066 PyObject *ret=PyTuple_New(2);
2067 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2068 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2072 PyObject *maxPerTupleWithCompoId() const
2074 DataArrayIdType *ret1=0;
2075 DataArrayDouble *ret0=self->maxPerTupleWithCompoId(ret1);
2076 PyObject *ret=PyTuple_New(2);
2077 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ));
2078 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2084 class DataArrayDoubleTuple;
2086 class DataArrayDoubleIterator
2089 DataArrayDoubleIterator(DataArrayDouble *da);
2090 ~DataArrayDoubleIterator();
2095 DataArrayDoubleTuple *ret=self->nextt();
2097 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayDoubleTuple,SWIG_POINTER_OWN|0);
2100 PyErr_SetString(PyExc_StopIteration,"No more data.");
2107 class DataArrayDoubleTuple
2110 std::size_t getNumberOfCompo() const;
2111 DataArrayDouble *buildDADouble(int nbOfTuples, int nbOfCompo) const;
2114 std::string __str__() const
2116 return self->repr();
2119 double __float__() const
2121 return self->doubleValue();
2124 DataArrayDouble *buildDADouble()
2126 return self->buildDADouble(1,self->getNumberOfCompo());
2129 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
2131 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2132 MEDCoupling_DataArrayDouble____iadd___(ret,0,obj);
2133 Py_XINCREF(trueSelf);
2137 PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
2139 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2140 MEDCoupling_DataArrayDouble____isub___(ret,0,obj);
2141 Py_XINCREF(trueSelf);
2145 PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
2147 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2148 MEDCoupling_DataArrayDouble____imul___(ret,0,obj);
2149 Py_XINCREF(trueSelf);
2153 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
2155 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2156 MEDCoupling_DataArrayDouble____idiv___(ret,0,obj);
2157 Py_XINCREF(trueSelf);
2163 return PyInt_FromLong(self->getNumberOfCompo());
2166 PyObject *__getitem__(PyObject *obj)
2168 const char msg2[]="DataArrayDoubleTuple::__getitem__ : Mismatch of slice values in 2nd parameter (components) !";
2171 std::vector<mcIdType> multiVal;
2172 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2173 MEDCoupling::DataArrayIdType *daIntTyypp=0;
2174 const double *pt=self->getConstPointer();
2175 mcIdType nbc=ToIdType(self->getNumberOfCompo());
2176 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbc,sw,singleVal,multiVal,slic,daIntTyypp);
2183 std::ostringstream oss;
2184 oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2185 PyErr_SetString(PyExc_StopIteration,oss.str().c_str());
2189 return PyFloat_FromDouble(pt[singleVal]);
2193 return PyFloat_FromDouble(pt[nbc+singleVal]);
2196 std::ostringstream oss;
2197 oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2198 throw INTERP_KERNEL::Exception(oss.str().c_str());
2204 PyObject *t=PyTuple_New(multiVal.size());
2205 for(std::size_t j=0;j<multiVal.size();j++)
2207 mcIdType cid=multiVal[j];
2210 std::ostringstream oss;
2211 oss << "Requesting for id #" << cid << " having only " << nbc << " components !";
2212 throw INTERP_KERNEL::Exception(oss.str().c_str());
2214 PyTuple_SetItem(t,j,PyFloat_FromDouble(pt[cid]));
2220 mcIdType sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2221 PyObject *t=PyTuple_New(sz);
2222 for(mcIdType j=0;j<sz;j++)
2223 PyTuple_SetItem(t,j,PyFloat_FromDouble(pt[slic.first+j*slic.second.second]));
2227 throw INTERP_KERNEL::Exception("DataArrayDoubleTuple::__getitem__ : unrecognized type entered !");
2231 DataArrayDoubleTuple *__setitem__(PyObject *obj, PyObject *value)
2233 const char msg[]="DataArrayDoubleTuple::__setitem__ : unrecognized type entered, int, slice, list<int>, tuple<int> !";
2234 const char msg2[]="DataArrayDoubleTuple::__setitem__ : Mismatch of slice values in 2nd parameter (components) !";
2237 std::vector<double> multiValV;
2238 MEDCoupling::DataArrayDoubleTuple *daIntTyyppV=0;
2239 mcIdType nbc=ToIdType(self->getNumberOfCompo());
2240 convertDoubleStarLikePyObjToCpp(value,sw1,singleValV,multiValV,daIntTyyppV);
2242 std::vector<mcIdType> multiVal;
2243 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2244 MEDCoupling::DataArrayIdType *daIntTyypp=0;
2245 double *pt=self->getPointer();
2246 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbc,sw2,singleVal,multiVal,slic,daIntTyypp);
2253 std::ostringstream oss;
2254 oss << "Requesting for setting id # " << singleVal << " having only " << nbc << " components !";
2255 throw INTERP_KERNEL::Exception(oss.str().c_str());
2261 pt[singleVal]=singleValV;
2266 if(multiValV.size()!=1)
2268 std::ostringstream oss;
2269 oss << "Requesting for setting id # " << singleVal << " with a list or tuple with size != 1 ! ";
2270 throw INTERP_KERNEL::Exception(oss.str().c_str());
2272 pt[singleVal]=multiValV[0];
2277 pt[singleVal]=daIntTyyppV->getConstPointer()[0];
2281 throw INTERP_KERNEL::Exception(msg);
2290 for(std::vector<mcIdType>::const_iterator it=multiVal.begin();it!=multiVal.end();it++)
2294 std::ostringstream oss;
2295 oss << "Requesting for setting id # " << *it << " having only " << nbc << " components !";
2296 throw INTERP_KERNEL::Exception(oss.str().c_str());
2304 if(multiVal.size()!=multiValV.size())
2306 std::ostringstream oss;
2307 oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << multiVal.size() << " !";
2308 throw INTERP_KERNEL::Exception(oss.str().c_str());
2310 for(std::size_t i=0;i<multiVal.size();i++)
2312 mcIdType pos=multiVal[i];
2315 std::ostringstream oss;
2316 oss << "Requesting for setting id # " << pos << " having only " << nbc << " components !";
2317 throw INTERP_KERNEL::Exception(oss.str().c_str());
2319 pt[multiVal[i]]=multiValV[i];
2325 const double *ptV=daIntTyyppV->getConstPointer();
2326 if(nbc>(mcIdType)daIntTyyppV->getNumberOfCompo())
2328 std::ostringstream oss;
2329 oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2330 throw INTERP_KERNEL::Exception(oss.str().c_str());
2332 std::copy(ptV,ptV+nbc,pt);
2336 throw INTERP_KERNEL::Exception(msg);
2341 mcIdType sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2346 for(mcIdType j=0;j<sz;j++)
2347 pt[slic.first+j*slic.second.second]=singleValV;
2352 if(sz!=(mcIdType)multiValV.size())
2354 std::ostringstream oss;
2355 oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << sz << " !";
2356 throw INTERP_KERNEL::Exception(oss.str().c_str());
2358 for(mcIdType j=0;j<sz;j++)
2359 pt[slic.first+j*slic.second.second]=multiValV[j];
2364 const double *ptV=daIntTyyppV->getConstPointer();
2365 if(sz>(mcIdType)daIntTyyppV->getNumberOfCompo())
2367 std::ostringstream oss;
2368 oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2369 throw INTERP_KERNEL::Exception(oss.str().c_str());
2371 for(mcIdType j=0;j<sz;j++)
2372 pt[slic.first+j*slic.second.second]=ptV[j];
2376 throw INTERP_KERNEL::Exception(msg);
2380 throw INTERP_KERNEL::Exception(msg);
2386 class DataArrayChar : public DataArray
2389 virtual DataArrayChar *buildEmptySpecializedDAChar() const;
2390 int getHashCode() const;
2392 void deepCopyFrom(const DataArrayChar& other);
2393 void reserve(std::size_t nbOfElems);
2394 void pushBackSilent(char val);
2395 char popBackSilent();
2397 void allocIfNecessary(int nbOfTuple, int nbOfCompo);
2398 bool isEqual(const DataArrayChar& other) const;
2399 bool isEqualWithoutConsideringStr(const DataArrayChar& other) const;
2401 void fillWithZero();
2402 void fillWithValue(char val);
2403 std::string repr() const;
2404 std::string reprZip() const;
2405 DataArrayInt *convertToIntArr() const;
2406 DataArrayChar *renumber(const mcIdType *old2New) const;
2407 DataArrayChar *renumberR(const mcIdType *new2Old) const;
2408 DataArrayChar *renumberAndReduce(const mcIdType *old2NewBg, mcIdType newNbOfTuple) const;
2409 bool isUniform(char val) const;
2410 void sort(bool asc=true);
2411 DataArrayChar *subArray(mcIdType tupleIdBg, mcIdType tupleIdEnd=-1) const;
2412 DataArrayChar *changeNbOfComponents(std::size_t newNbOfComp, char dftValue) const;
2413 void meldWith(const DataArrayChar *other);
2414 void setPartOfValuesAdv(const DataArrayChar *a, const DataArrayIdType *tuplesSelec);
2417 void setIJ(mcIdType tupleId, int compoId, char newVal);
2418 void setIJSilent(mcIdType tupleId, int compoId, char newVal);
2420 DataArrayIdType *findIdsEqual(char val) const;
2421 DataArrayIdType *findIdsNotEqual(char val) const;
2422 int findIdFirstEqualTuple(const std::vector<char>& tupl) const;
2423 bool presenceOfTuple(const std::vector<char>& tupl) const;
2424 char getMaxValue(mcIdType& tupleId) const;
2425 char getMaxValueInArray() const;
2426 char getMinValue(mcIdType& tupleId) const;
2427 char getMinValueInArray() const;
2428 DataArrayIdType *findIdsInRange(char vmin, char vmax) const;
2429 static DataArrayChar *Aggregate(const DataArrayChar *a1, const DataArrayChar *a2);
2430 static DataArrayChar *Meld(const DataArrayChar *a1, const DataArrayChar *a2);
2433 mcIdType __len__() const
2435 if(self->isAllocated())
2437 return self->getNumberOfTuples();
2441 throw INTERP_KERNEL::Exception("DataArrayChar::__len__ : Instance is NOT allocated !");
2445 PyObject *isEqualIfNotWhy(const DataArrayChar& other) const
2448 bool ret0=self->isEqualIfNotWhy(other,ret1);
2449 PyObject *ret=PyTuple_New(2);
2450 PyObject *ret0Py=ret0?Py_True:Py_False;
2452 PyTuple_SetItem(ret,0,ret0Py);
2453 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
2457 DataArrayChar *renumber(PyObject *li)
2460 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
2461 if (!SWIG_IsOK(res1))
2464 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2465 if(size!=self->getNumberOfTuples())
2467 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2469 return self->renumber(tmp);
2473 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2475 throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2476 da2->checkAllocated();
2477 mcIdType size=self->getNumberOfTuples();
2478 if(size!=self->getNumberOfTuples())
2480 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2482 return self->renumber(da2->getConstPointer());
2486 DataArrayChar *renumberR(PyObject *li)
2489 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
2490 if (!SWIG_IsOK(res1))
2493 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2494 if(size!=self->getNumberOfTuples())
2496 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2498 return self->renumberR(tmp);
2502 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2504 throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2505 da2->checkAllocated();
2506 mcIdType size=self->getNumberOfTuples();
2507 if(size!=self->getNumberOfTuples())
2509 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2511 return self->renumberR(da2->getConstPointer());
2515 DataArrayChar *renumberAndReduce(PyObject *li, mcIdType newNbOfTuple)
2518 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
2519 if (!SWIG_IsOK(res1))
2522 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2523 if(size!=self->getNumberOfTuples())
2525 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2527 return self->renumberAndReduce(tmp,newNbOfTuple);
2531 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2533 throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2534 da2->checkAllocated();
2535 mcIdType size=self->getNumberOfTuples();
2536 if(size!=self->getNumberOfTuples())
2538 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2540 return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
2544 static DataArrayChar *Aggregate(PyObject *dachs)
2546 std::vector<const MEDCoupling::DataArrayChar *> tmp;
2547 convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayChar *>(dachs,SWIGTYPE_p_MEDCoupling__DataArrayChar,"DataArrayChar",tmp);
2548 return DataArrayChar::Aggregate(tmp);
2551 static DataArrayChar *Meld(PyObject *dachs)
2553 std::vector<const MEDCoupling::DataArrayChar *> tmp;
2554 convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayChar *>(dachs,SWIGTYPE_p_MEDCoupling__DataArrayChar,"DataArrayChar",tmp);
2555 return DataArrayChar::Meld(tmp);
2560 class DataArrayByteIterator;
2562 class DataArrayByte : public DataArrayChar
2565 static DataArrayByte *New();
2566 DataArrayByteIterator *iterator();
2567 DataArrayByte *performCopyOrIncrRef(bool deepCopy) const;
2568 char byteValue() const;
2573 return DataArrayByte::New();
2576 static DataArrayByte *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
2578 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) !";
2579 if(PyList_Check(elt0) || PyTuple_Check(elt0))
2583 if(PyInt_Check(nbOfTuples))
2585 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
2587 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive set of allocated memory !");
2590 if(PyInt_Check(nbOfComp))
2591 {//DataArrayByte.New([1,3,4,5],2,2)
2592 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
2594 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !");
2595 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2596 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
2597 ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2601 throw INTERP_KERNEL::Exception(msg);
2604 {//DataArrayByte.New([1,3,4],3)
2605 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2607 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
2608 ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2613 throw INTERP_KERNEL::Exception(msg);
2616 {// DataArrayByte.New([1,3,4])
2617 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2618 mcIdType tmpp1=-1,tmpp2=-1;
2619 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
2620 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2624 else if(PyInt_Check(elt0))
2626 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(elt0));
2628 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive set of allocated memory !");
2633 if(PyInt_Check(nbOfTuples))
2634 {//DataArrayByte.New(5,2)
2635 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfTuples));
2637 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !");
2638 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2639 ret->alloc(nbOfTuples1,nbOfCompo);
2643 throw INTERP_KERNEL::Exception(msg);
2646 throw INTERP_KERNEL::Exception(msg);
2649 {//DataArrayByte.New(5)
2650 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2651 ret->alloc(nbOfTuples1,1);
2656 else if(PyArray_Check(elt0) && nbOfTuples==NULL && nbOfComp==NULL)
2657 {//DataArrayDouble.New(numpyArray)
2658 return BuildNewInstance<DataArrayByte,char>(elt0,NPY_INT8,&PyCallBackDataArrayChar_RefType,"INT8");
2662 throw INTERP_KERNEL::Exception(msg);
2665 DataArrayByte(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
2667 return MEDCoupling_DataArrayByte_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
2670 std::string __repr__() const
2672 std::ostringstream oss;
2673 self->reprQuickOverview(oss);
2679 return (int) self->byteValue();
2682 DataArrayByteIterator *__iter__()
2684 return self->iterator();
2687 mcIdType getIJ(mcIdType tupleId, mcIdType compoId) const
2689 return (mcIdType)self->getIJ(tupleId,compoId);
2692 mcIdType getIJSafe(mcIdType tupleId, mcIdType compoId) const
2694 return (mcIdType)self->getIJSafe(tupleId,compoId);
2697 std::string __str__() const
2699 return self->repr();
2702 PyObject *toStrList() const
2704 const char *vals=self->getConstPointer();
2705 std::size_t nbOfComp=self->getNumberOfComponents();
2706 mcIdType nbOfTuples=self->getNumberOfTuples();
2707 return convertCharArrToPyListOfTuple(vals,(int)nbOfComp,nbOfTuples);
2710 bool presenceOfTuple(PyObject *tupl) const
2712 mcIdType sz=-1,sw=-1;
2713 mcIdType ival=-1; std::vector<mcIdType> ivval;
2714 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(tupl,sw,sz,ival,ivval);
2715 std::vector<char> vals(sz);
2716 std::copy(pt,pt+sz,vals.begin());
2717 return self->presenceOfTuple(vals);
2720 bool presenceOfValue(PyObject *vals) const
2722 mcIdType sz=-1,sw=-1;
2723 mcIdType ival=-1; std::vector<mcIdType> ivval;
2724 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(vals,sw,sz,ival,ivval);
2725 std::vector<char> vals2(sz);
2726 std::copy(pt,pt+sz,vals2.begin());
2727 return self->presenceOfValue(vals2);
2730 mcIdType findIdFirstEqual(PyObject *vals) const
2732 mcIdType sz=-1,sw=-1;
2733 mcIdType ival=-1; std::vector<mcIdType> ivval;
2734 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(vals,sw,sz,ival,ivval);
2735 std::vector<char> vals2(sz);
2736 std::copy(pt,pt+sz,vals2.begin());
2737 return self->findIdFirstEqual(vals2);
2740 mcIdType findIdFirstEqualTuple(PyObject *tupl) const
2742 mcIdType sz=-1,sw=-1;
2743 mcIdType ival=-1; std::vector<mcIdType> ivval;
2744 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(tupl,sw,sz,ival,ivval);
2745 std::vector<char> vals(sz);
2746 std::copy(pt,pt+sz,vals.begin());
2747 return self->findIdFirstEqualTuple(vals);
2750 mcIdType findIdSequence(PyObject *strOrListOfInt) const
2752 mcIdType sz=-1,sw=-1;
2753 mcIdType ival=-1; std::vector<mcIdType> ivval;
2754 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(strOrListOfInt,sw,sz,ival,ivval);
2755 std::vector<char> vals(sz);
2756 std::copy(pt,pt+sz,vals.begin());
2757 return self->findIdSequence(vals);
2760 PyObject *getTuple(mcIdType tupleId)
2762 std::size_t sz=self->getNumberOfComponents();
2763 INTERP_KERNEL::AutoPtr<char> tmp=new char[sz];
2764 self->getTuple(tupleId,tmp);
2765 PyObject *ret=PyTuple_New(sz);
2766 for(std::size_t i=0;i<sz;i++) PyTuple_SetItem(ret,i,PyInt_FromLong((mcIdType)tmp[i]));
2770 PyObject *getMaxValue() const
2773 mcIdType r1=(mcIdType)self->getMaxValue(tmp);
2774 PyObject *ret=PyTuple_New(2);
2775 PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
2776 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
2780 PyObject *getMinValue() const
2783 mcIdType r1=(mcIdType)self->getMinValue(tmp);
2784 PyObject *ret=PyTuple_New(2);
2785 PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
2786 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
2790 mcIdType index(PyObject *obj) const
2792 std::size_t nbOfCompo=self->getNumberOfComponents();
2797 if(PyInt_Check(obj))
2799 char val=(char)PyInt_AS_LONG(obj);
2800 return self->findIdFirstEqual(val);
2803 throw INTERP_KERNEL::Exception("DataArrayByte::index : 'this' contains one component and trying to find an element which is not an integer !");
2806 return MEDCoupling_DataArrayByte_findIdFirstEqualTuple(self,obj);
2810 bool __contains__(PyObject *obj) const
2812 std::size_t nbOfCompo=self->getNumberOfComponents();
2819 if(PyInt_Check(obj))
2821 char val=(char)PyInt_AS_LONG(obj);
2822 return self->presenceOfValue(val);
2825 throw INTERP_KERNEL::Exception("DataArrayByte::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
2828 return MEDCoupling_DataArrayByte_presenceOfTuple(self,obj);
2833 PyObject *toNumPyArray() // not const. It is not a bug !
2835 return ToNumPyArray<DataArrayByte,char>(self,NPY_INT8,"DataArrayByte");
2839 DataArrayByte *__setitem__(PyObject *obj, PyObject *value)
2841 self->checkAllocated();
2842 const char msg[]="Unexpected situation in __setitem__ !";
2843 mcIdType nbOfTuples(self->getNumberOfTuples());
2844 int nbOfComponents((int)self->getNumberOfComponents());
2847 std::vector<int> v1;
2848 DataArrayIdType *d1=0;
2849 DataArrayIntTuple *dd1=0;
2850 convertIntStarLikePyObjToCpp(value,sw1,int1,v1,d1,dd1);
2852 std::vector<mcIdType> vt1,vc1;
2853 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > pt1,pc1;
2854 DataArrayIdType *dt1=0,*dc1=0;
2855 convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw2,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1);
2856 MCAuto<DataArrayIdType> tmp;
2857 char i1 = (char)int1;
2865 self->setPartOfValuesSimple1(i1,it1,it1+1,1,0,nbOfComponents,1);
2868 throw INTERP_KERNEL::Exception(msg);
2877 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1);
2880 throw INTERP_KERNEL::Exception(msg);
2889 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1);
2892 throw INTERP_KERNEL::Exception(msg);
2901 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1);
2904 throw INTERP_KERNEL::Exception(msg);
2913 self->setPartOfValuesSimple1(i1,it1,it1+1,1,ic1,ic1+1,1);
2916 throw INTERP_KERNEL::Exception(msg);
2925 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1);
2928 throw INTERP_KERNEL::Exception(msg);
2937 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1);
2940 throw INTERP_KERNEL::Exception(msg);
2949 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1);
2952 throw INTERP_KERNEL::Exception(msg);
2961 self->setPartOfValuesSimple2(i1,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size());
2964 throw INTERP_KERNEL::Exception(msg);
2973 self->setPartOfValuesSimple2(i1,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size());
2976 throw INTERP_KERNEL::Exception(msg);
2985 self->setPartOfValuesSimple4(i1,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size());
2988 throw INTERP_KERNEL::Exception(msg);
2997 self->setPartOfValuesSimple2(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size());
3000 throw INTERP_KERNEL::Exception(msg);
3009 self->setPartOfValuesSimple1(i1,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second);
3012 throw INTERP_KERNEL::Exception(msg);
3021 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second);
3024 throw INTERP_KERNEL::Exception(msg);
3033 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second);
3036 throw INTERP_KERNEL::Exception(msg);
3045 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second);
3048 throw INTERP_KERNEL::Exception(msg);
3053 throw INTERP_KERNEL::Exception(msg);
3060 class DataArrayByteTuple;
3062 class DataArrayByteIterator
3065 DataArrayByteIterator(DataArrayByte *da);
3066 ~DataArrayByteIterator();
3069 class DataArrayByteTuple
3072 std::string repr() const;
3073 DataArrayByte *buildDAByte(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
3076 std::string __str__() const
3078 return self->repr();
3081 char __int__() const
3083 return self->byteValue();
3086 DataArrayByte *buildDAByte()
3088 return self->buildDAByte(1,self->getNumberOfCompo());
3093 class DataArrayAsciiCharIterator;
3095 class DataArrayAsciiChar : public DataArrayChar
3098 static DataArrayAsciiChar *New();
3099 DataArrayAsciiCharIterator *iterator();
3100 DataArrayAsciiChar *performCopyOrIncrRef(bool deepCopy) const;
3101 char asciiCharValue() const;
3104 DataArrayAsciiChar()
3106 return DataArrayAsciiChar::New();
3109 static DataArrayAsciiChar *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
3111 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) !";
3112 if(PyList_Check(elt0) || PyTuple_Check(elt0))
3116 if(PyInt_Check(nbOfTuples))
3118 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
3120 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive set of allocated memory !");
3123 if(PyInt_Check(nbOfComp))
3124 {//DataArrayAsciiChar.New([1,3,4,5],2,2)
3125 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
3127 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !");
3128 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3129 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
3130 ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3134 throw INTERP_KERNEL::Exception(msg);
3137 {//DataArrayAsciiChar.New([1,3,4],3)
3138 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3140 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
3141 ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3145 else if(PyString_Check(nbOfTuples))
3147 if(PyString_Size(nbOfTuples)!=1)
3148 throw INTERP_KERNEL::Exception(msg);
3149 //DataArrayAsciiChar.New(["abc","de","fghi"],"t")
3150 std::vector<std::string> tmp;
3151 if(fillStringVector(elt0,tmp))
3152 return DataArrayAsciiChar::New(tmp,PyString_AsString(nbOfTuples)[0]);
3154 throw INTERP_KERNEL::Exception(msg);
3156 %#if PY_VERSION_HEX >= 0x03000000
3157 else if(PyUnicode_Check(nbOfTuples))
3159 if(PyUnicode_GET_LENGTH(nbOfTuples)!=1)
3160 throw INTERP_KERNEL::Exception(msg);
3161 //DataArrayAsciiChar.New(["abc","de","fghi"],"t")
3162 std::vector<std::string> tmp;
3163 if(fillStringVector(elt0,tmp))
3164 return DataArrayAsciiChar::New(tmp,PyUnicode_AsUTF8(nbOfTuples)[0]);
3166 throw INTERP_KERNEL::Exception(msg);
3170 throw INTERP_KERNEL::Exception(msg);
3174 std::vector<std::string> tmmp;
3175 if(fillStringVector(elt0,tmmp))
3176 //DataArrayAsciiChar.New(["abc","de","fghi"])
3177 return DataArrayAsciiChar::New(tmmp,' ');
3180 // DataArrayAsciiChar.New([1,3,4])
3181 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3182 mcIdType tmpp1=-1,tmpp2=-1;
3183 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
3184 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3189 else if(PyInt_Check(elt0))
3191 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(elt0));
3193 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive set of allocated memory !");
3198 if(PyInt_Check(nbOfTuples))
3199 {//DataArrayAsciiChar.New(5,2)
3200 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfTuples));
3202 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !");
3203 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3204 ret->alloc(nbOfTuples1,nbOfCompo);
3208 throw INTERP_KERNEL::Exception(msg);
3211 throw INTERP_KERNEL::Exception(msg);
3214 {//DataArrayAsciiChar.New(5)
3215 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3216 ret->alloc(nbOfTuples1,1);
3221 throw INTERP_KERNEL::Exception(msg);
3224 DataArrayAsciiChar(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
3226 return MEDCoupling_DataArrayAsciiChar_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
3229 std::string __repr__() const
3231 std::ostringstream oss;
3232 self->reprQuickOverview(oss);
3236 DataArrayAsciiCharIterator *__iter__()
3238 return self->iterator();
3241 std::string getIJ(mcIdType tupleId, mcIdType compoId) const
3243 char tmp[2]; tmp[1]='\0';
3244 tmp[0]=self->getIJ(tupleId,compoId);
3245 return std::string(tmp);
3248 std::string getIJSafe(mcIdType tupleId, mcIdType compoId) const
3250 char tmp[2]; tmp[1]='\0';
3251 tmp[0]=self->getIJSafe(tupleId,compoId);
3252 return std::string(tmp);
3255 std::string __str__() const
3257 return self->repr();
3260 PyObject *toStrList() const
3262 const char *vals=self->getConstPointer();
3263 std::size_t nbOfComp=self->getNumberOfComponents();
3264 mcIdType nbOfTuples=self->getNumberOfTuples();
3265 return convertCharArrToPyListOfTuple(vals,(int)nbOfComp,nbOfTuples);
3268 bool presenceOfTuple(PyObject *tupl) const
3270 if(PyString_Check(tupl))
3272 Py_ssize_t sz=PyString_Size(tupl);
3273 std::vector<char> vals(sz);
3274 std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin());
3275 return self->presenceOfTuple(vals);
3277 %#if PY_VERSION_HEX >= 0x03000000
3278 else if(PyUnicode_Check(tupl))
3280 Py_ssize_t sz=PyUnicode_GET_LENGTH(tupl);
3281 std::vector<char> vals(sz);
3282 std::copy(PyUnicode_AsUTF8(tupl),PyUnicode_AsUTF8(tupl)+sz,vals.begin());
3283 return self->presenceOfTuple(vals);
3287 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfTuple : only strings in input supported !");
3290 bool presenceOfValue(PyObject *vals) const
3292 if(PyString_Check(vals))
3294 Py_ssize_t sz=PyString_Size(vals);
3295 std::vector<char> vals2(sz);
3296 std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin());
3297 return self->presenceOfValue(vals2);
3299 %#if PY_VERSION_HEX >= 0x03000000
3300 if(PyUnicode_Check(vals))
3302 Py_ssize_t sz=PyUnicode_GET_LENGTH(vals);
3303 std::vector<char> vals2(sz);
3304 std::copy(PyUnicode_AsUTF8(vals),PyUnicode_AsUTF8(vals)+sz,vals2.begin());
3305 return self->presenceOfValue(vals2);
3309 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfValue : only strings in input supported !");
3312 mcIdType findIdFirstEqual(PyObject *vals) const
3314 if(PyString_Check(vals))
3316 Py_ssize_t sz=PyString_Size(vals);
3317 std::vector<char> vals2(sz);
3318 std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin());
3319 return self->findIdFirstEqual(vals2);
3321 %#if PY_VERSION_HEX >= 0x03000000
3322 if(PyUnicode_Check(vals))
3324 Py_ssize_t sz=PyUnicode_GET_LENGTH(vals);
3325 std::vector<char> vals2(sz);
3326 std::copy(PyUnicode_AsUTF8(vals),PyUnicode_AsUTF8(vals)+sz,vals2.begin());
3327 return self->findIdFirstEqual(vals2);
3331 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::findIdFirstEqual : only strings in input supported !");
3334 mcIdType findIdFirstEqualTuple(PyObject *tupl) const
3336 if(PyString_Check(tupl))
3338 Py_ssize_t sz=PyString_Size(tupl);
3339 std::vector<char> vals(sz);
3340 std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin());
3341 return self->findIdFirstEqualTuple(vals);
3343 %#if PY_VERSION_HEX >= 0x03000000
3344 if(PyUnicode_Check(tupl))
3346 Py_ssize_t sz=PyUnicode_GET_LENGTH(tupl);
3347 std::vector<char> vals(sz);
3348 std::copy(PyUnicode_AsUTF8(tupl),PyUnicode_AsUTF8(tupl)+sz,vals.begin());
3349 return self->findIdFirstEqualTuple(vals);
3353 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::findIdFirstEqualTuple : only strings in input supported !");
3356 mcIdType findIdSequence(PyObject *strOrListOfInt) const
3358 if(PyString_Check(strOrListOfInt))
3360 Py_ssize_t sz=PyString_Size(strOrListOfInt);
3361 std::vector<char> vals(sz);
3362 std::copy(PyString_AsString(strOrListOfInt),PyString_AsString(strOrListOfInt)+sz,vals.begin());
3363 return self->findIdSequence(vals);
3365 %#if PY_VERSION_HEX >= 0x03000000
3366 else if(PyUnicode_Check(strOrListOfInt))
3368 Py_ssize_t sz=PyUnicode_GET_LENGTH(strOrListOfInt);
3369 std::vector<char> vals(sz);
3370 std::copy(PyUnicode_AsUTF8(strOrListOfInt),PyUnicode_AsUTF8(strOrListOfInt)+sz,vals.begin());
3371 return self->findIdSequence(vals);
3375 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::search : only strings in input supported !");
3378 PyObject *getTuple(mcIdType tupleId) const
3380 std::size_t sz=self->getNumberOfComponents();
3381 INTERP_KERNEL::AutoPtr<char> tmp=new char[sz+1]; tmp[sz]='\0';
3382 self->getTuple(tupleId,tmp);
3383 return PyString_FromString(tmp);
3386 PyObject *getMaxValue() const
3389 char tmp2[2]; tmp2[1]='\0';
3390 tmp2[0]=self->getMaxValue(tmp);
3391 PyObject *ret=PyTuple_New(2);
3392 PyTuple_SetItem(ret,0,PyString_FromString(tmp2));
3393 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
3397 PyObject *getMinValue() const
3400 char tmp2[2]; tmp2[1]='\0';
3401 tmp2[0]=self->getMinValue(tmp);
3402 PyObject *ret=PyTuple_New(2);
3403 PyTuple_SetItem(ret,0,PyString_FromString(tmp2));
3404 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
3408 mcIdType index(PyObject *obj) const
3410 std::size_t nbOfCompo=self->getNumberOfComponents();
3415 if(PyString_Check(obj))
3417 Py_ssize_t sz=PyString_Size(obj);
3418 char *pt=PyString_AsString(obj);
3420 return self->findIdFirstEqual(pt[0]);
3422 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find a string with size different from 1 !");
3424 %#if PY_VERSION_HEX >= 0x03000000
3425 if(PyUnicode_Check(obj))
3428 const char *pt=PyUnicode_AsUTF8AndSize(obj, &sz);
3430 return self->findIdFirstEqual(pt[0]);
3432 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find a string with size different from 1 !");
3436 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find an element which is not an integer !");
3439 return MEDCoupling_DataArrayAsciiChar_findIdFirstEqualTuple(self,obj);
3443 bool __contains__(PyObject *obj) const
3445 std::size_t nbOfCompo=self->getNumberOfComponents();
3452 if(PyString_Check(obj))
3454 Py_ssize_t sz=PyString_Size(obj);
3455 char *pt=PyString_AsString(obj);
3457 return self->presenceOfValue(pt[0]);
3459 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find a string with size different from 1 !");
3461 %#if PY_VERSION_HEX >= 0x03000000
3462 if(PyUnicode_Check(obj))
3465 const char *pt=PyUnicode_AsUTF8AndSize(obj, &sz);
3467 return self->presenceOfValue(pt[0]);
3469 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find a string with size different from 1 !");
3473 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
3476 return MEDCoupling_DataArrayAsciiChar_presenceOfTuple(self,obj);
3480 PyObject *__getitem__(PyObject *obj) const
3482 mcIdType sw,iTypppArr;
3483 std::vector<mcIdType> stdvecTyyppArr;
3484 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > sTyyppArr;
3485 MEDCoupling::DataArrayIdType *daIntTyypp=0;
3486 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,self->getNumberOfTuples(),sw,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp);
3490 return MEDCoupling_DataArrayAsciiChar_getTuple(self,iTypppArr);
3492 return convertDataArrayChar(self->selectByTupleIdSafe(&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size()), SWIG_POINTER_OWN | 0 );
3494 return convertDataArrayChar(self->selectByTupleIdSafeSlice(sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second), SWIG_POINTER_OWN | 0 );
3496 return convertDataArrayChar(self->selectByTupleIdSafe(daIntTyypp->begin(),daIntTyypp->end()), SWIG_POINTER_OWN | 0 );
3498 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__getitem__ : supporting int, list of int, tuple of int, DataArrayIdType and slice in input !");
3502 DataArrayAsciiChar *__setitem__(PyObject *obj, PyObject *value)
3504 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.";
3505 mcIdType sw1,iTypppArr;
3506 std::vector<mcIdType> stdvecTyyppArr;
3507 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > sTyyppArr;
3508 MEDCoupling::DataArrayIdType *daIntTyypp=0;
3509 mcIdType nbOfCompo=ToIdType(self->getNumberOfComponents());
3510 mcIdType nbOfTuples=self->getNumberOfTuples();
3511 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbOfTuples,sw1,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp);
3513 char vc; std::string sc; std::vector<std::string> vsc; DataArrayChar *dacc=0;
3514 convertObjToPossibleCpp6(value,sw2,vc,sc,vsc,dacc);
3523 self->setPartOfValuesSimple3(vc,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1);
3529 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3530 self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3533 //value vector<string>
3536 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3537 self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3540 //value DataArrayChar
3543 self->setPartOfValues3(dacc,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3547 throw INTERP_KERNEL::Exception(msg);
3551 {//obj list-tuple[int]
3557 self->setPartOfValuesSimple3(vc,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1);
3563 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3564 self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3567 //value vector<string>
3570 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3571 self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3574 //value DataArrayChar
3577 self->setPartOfValues3(dacc,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3581 throw INTERP_KERNEL::Exception(msg);
3592 self->setPartOfValuesSimple1(vc,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1);
3598 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3599 self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3602 //value vector<string>
3605 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3606 self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3609 //value DataArrayChar
3612 self->setPartOfValues1(dacc,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3616 throw INTERP_KERNEL::Exception(msg);
3627 self->setPartOfValuesSimple3(vc,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1);
3633 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3634 self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3637 //value vector<string>
3640 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3641 self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3644 //value DataArrayChar
3647 self->setPartOfValues3(dacc,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3651 throw INTERP_KERNEL::Exception(msg);
3656 throw INTERP_KERNEL::Exception(msg);
3662 class DataArrayAsciiCharTuple;
3664 class DataArrayAsciiCharIterator
3667 DataArrayAsciiCharIterator(DataArrayAsciiChar *da);
3668 ~DataArrayAsciiCharIterator();
3673 DataArrayAsciiCharTuple *ret=self->nextt();
3675 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayAsciiCharTuple,SWIG_POINTER_OWN | 0);
3678 PyErr_SetString(PyExc_StopIteration,"No more data.");
3685 class DataArrayAsciiCharTuple
3688 std::size_t getNumberOfCompo() const;
3689 DataArrayAsciiChar *buildDAAsciiChar(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
3692 std::string __str__() const
3694 return self->repr();
3697 DataArrayAsciiChar *buildDAAsciiChar()
3699 return self->buildDAAsciiChar(1,self->getNumberOfCompo());
3708 MEDCoupling::DataArrayByte *FromPyIntPtrToDataArrayByte(long intPtr)
3710 MEDCoupling::DataArrayByte *ret(reinterpret_cast<MEDCoupling::DataArrayByte *>(intPtr));
3715 %include "DataArrayInt.i"
3719 def MEDCouplingStdReduceFunct(cls,params):
3721 ret=object.__new__(cls)
3726 def MEDCouplingDataArrayDoubleReduce(self):
3727 if not MEDCouplingHasNumPyBindings():
3728 raise InterpKernelException("PyWrap of DataArrayDouble.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3729 return MEDCouplingStdReduceFunct,(DataArrayDouble,((self.toNumPyArray(),),(self.__getstate__()),))
3731 def MEDCouplingDataArrayInt32Reduce(self):
3732 if not MEDCouplingHasNumPyBindings():
3733 raise InterpKernelException("PyWrap of DataArrayIdType.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3734 return MEDCouplingStdReduceFunct,(DataArrayInt32,((self.toNumPyArray(),),(self.__getstate__()),))
3736 def MEDCouplingDataArrayInt64Reduce(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,(DataArrayInt64,((self.toNumPyArray(),),(self.__getstate__()),))
3741 def MEDCouplingDataArrayByteReduce(self):
3742 if not MEDCouplingHasNumPyBindings():
3743 raise InterpKernelException("PyWrap of DataArrayByte.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3744 return MEDCouplingStdReduceFunct,(DataArrayByte,((self.toNumPyArray(),),(self.__getstate__()),))
3746 def MEDCouplingDataArrayFloatReduce(self):
3747 if not MEDCouplingHasNumPyBindings():
3748 raise InterpKernelException("PyWrap of DataArrayFloat.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3749 return MEDCouplingStdReduceFunct,(DataArrayFloat,((self.toNumPyArray(),),(self.__getstate__()),))
3751 if MEDCouplingUse64BitIDs():
3752 DataArrayInt=DataArrayInt64
3754 DataArrayInt=DataArrayInt32