1 // Copyright (C) 2007-2020 CEA/DEN, EDF R&D
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 // Lesser General Public License for more details.
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
19 // Author : Anthony Geay (EDF R&D)
22 %typemap(out) MEDCoupling::DataArray*
24 $result=convertDataArray($1,$owner);
27 %typemap(out) DataArray*
29 $result=convertDataArray($1,$owner);
34 %typemap(out) MEDCoupling::DataArrayChar*
36 $result=convertDataArrayChar($1,$owner);
39 %typemap(out) DataArrayChar*
41 $result=convertDataArrayChar($1,$owner);
44 %typemap(out) MCAuto<MEDCoupling::DataArrayInt32>
46 $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt32,SWIG_POINTER_OWN|0);
49 %typemap(out) MCAuto<MEDCoupling::DataArrayInt64>
51 $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayInt64,SWIG_POINTER_OWN|0);
54 %typemap(out) MCAuto<MEDCoupling::DataArrayIdType>
56 $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTITraits<mcIdType>::TI,SWIG_POINTER_OWN|0);
59 %typemap(out) MCAuto<MEDCoupling::DataArrayDouble>
61 $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble,SWIG_POINTER_OWN|0);
64 %typemap(out) MCAuto<MEDCoupling::DataArrayFloat>
66 $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTYPE_p_MEDCoupling__DataArrayFloat,SWIG_POINTER_OWN|0);
69 %typemap(out) MCAuto<MEDCoupling::MapII>
71 $result=SWIG_NewPointerObj(SWIG_as_voidptr($1.retn()),SWIGTYPE_p_MEDCoupling__MapII,SWIG_POINTER_OWN|0);
75 %newobject MEDCoupling::DataArray::deepCopy;
76 %newobject MEDCoupling::DataArray::copySorted;
77 %newobject MEDCoupling::DataArray::buildNewEmptyInstance;
78 %newobject MEDCoupling::DataArray::selectByTupleRanges;
79 %newobject MEDCoupling::DataArray::selectByTupleId;
80 %newobject MEDCoupling::DataArray::selectByTupleIdSafe;
81 %newobject MEDCoupling::DataArray::selectByTupleIdSafeSlice;
82 %newobject MEDCoupling::DataArray::Aggregate;
83 %newobject MEDCoupling::DataArrayFloat::New;
84 %newobject MEDCoupling::DataArrayFloat::iterator;
85 %newobject MEDCoupling::DataArrayFloat::__iter__;
86 %newobject MEDCoupling::DataArrayFloat::Meld;
87 %newobject MEDCoupling::DataArrayFloat::__rmul__;
88 %newobject MEDCoupling::DataArrayInt32::New;
89 %newobject MEDCoupling::DataArrayInt32::__iter__;
90 %newobject MEDCoupling::DataArrayInt32::performCopyOrIncrRef;
91 %newobject MEDCoupling::DataArrayInt32::subArray;
92 %newobject MEDCoupling::DataArrayInt32::changeNbOfComponents;
93 %newobject MEDCoupling::DataArrayInt32::accumulatePerChunck;
94 %newobject MEDCoupling::DataArrayInt32::checkAndPreparePermutation;
95 %newobject MEDCoupling::DataArrayInt32::transformWithIndArrR;
96 %newobject MEDCoupling::DataArrayInt32::renumber;
97 %newobject MEDCoupling::DataArrayInt32::renumberR;
98 %newobject MEDCoupling::DataArrayInt32::renumberAndReduce;
99 %newobject MEDCoupling::DataArrayInt32::invertArrayO2N2N2O;
100 %newobject MEDCoupling::DataArrayInt32::invertArrayN2O2O2N;
101 %newobject MEDCoupling::DataArrayInt32::invertArrayO2N2N2OBis;
102 %newobject MEDCoupling::DataArrayInt32::findIdsEqual;
103 %newobject MEDCoupling::DataArrayInt32::findIdsNotEqual;
104 %newobject MEDCoupling::DataArrayInt32::findIdsEqualList;
105 %newobject MEDCoupling::DataArrayInt32::findIdsNotEqualList;
106 %newobject MEDCoupling::DataArrayInt32::findIdsEqualTuple;
107 %newobject MEDCoupling::DataArrayInt32::findIdForEach;
108 %newobject MEDCoupling::DataArrayInt32::sumPerTuple;
109 %newobject MEDCoupling::DataArrayInt32::negate;
110 %newobject MEDCoupling::DataArrayInt32::computeAbs;
111 %newobject MEDCoupling::DataArrayInt32::findIdsInRange;
112 %newobject MEDCoupling::DataArrayInt32::findIdsNotInRange;
113 %newobject MEDCoupling::DataArrayInt32::findIdsStrictlyNegative;
114 %newobject MEDCoupling::DataArrayInt32::Aggregate;
115 %newobject MEDCoupling::DataArrayInt32::AggregateIndexes;
116 %newobject MEDCoupling::DataArrayInt32::Meld;
117 %newobject MEDCoupling::DataArrayInt32::Add;
118 %newobject MEDCoupling::DataArrayInt32::Substract;
119 %newobject MEDCoupling::DataArrayInt32::Multiply;
120 %newobject MEDCoupling::DataArrayInt32::Divide;
121 %newobject MEDCoupling::DataArrayInt32::Pow;
122 %newobject MEDCoupling::DataArrayInt32::BuildUnion;
123 %newobject MEDCoupling::DataArrayInt32::BuildIntersection;
124 %newobject MEDCoupling::DataArrayInt32::Range;
125 %newobject MEDCoupling::DataArrayInt32::indicesOfSubPart;
126 %newobject MEDCoupling::DataArrayInt32::fromNoInterlace;
127 %newobject MEDCoupling::DataArrayInt32::toNoInterlace;
128 %newobject MEDCoupling::DataArrayInt32::buildComplement;
129 %newobject MEDCoupling::DataArrayInt32::buildUnion;
130 %newobject MEDCoupling::DataArrayInt32::buildSubstraction;
131 %newobject MEDCoupling::DataArrayInt32::buildSubstractionOptimized;
132 %newobject MEDCoupling::DataArrayInt32::buildIntersection;
133 %newobject MEDCoupling::DataArrayInt32::indexOfSameConsecutiveValueGroups;
134 %newobject MEDCoupling::DataArrayInt32::buildUnique;
135 %newobject MEDCoupling::DataArrayInt32::buildUniqueNotSorted;
136 %newobject MEDCoupling::DataArrayInt32::deltaShiftIndex;
137 %newobject MEDCoupling::DataArrayInt32::buildExplicitArrByRanges;
138 %newobject MEDCoupling::DataArrayInt32::buildExplicitArrOfSliceOnScaledArr;
139 %newobject MEDCoupling::DataArrayInt32::findRangeIdForEachTuple;
140 %newobject MEDCoupling::DataArrayInt32::findIdInRangeForEachTuple;
141 %newobject MEDCoupling::DataArrayInt32::duplicateEachTupleNTimes;
142 %newobject MEDCoupling::DataArrayInt32::occurenceRankInThis;
143 %newobject MEDCoupling::DataArrayInt32::buildPermutationArr;
144 %newobject MEDCoupling::DataArrayInt32::buildPermArrPerLevel;
145 %newobject MEDCoupling::DataArrayInt32::getDifferentValues;
146 %newobject MEDCoupling::DataArrayInt32::FindPermutationFromFirstToSecond;
147 %newobject MEDCoupling::DataArrayInt32::FindPermutationFromFirstToSecondDuplicate;
148 %newobject MEDCoupling::DataArrayInt32::CheckAndPreparePermutation;
149 %newobject MEDCoupling::DataArrayInt32::__neg__;
150 %newobject MEDCoupling::DataArrayInt32::__add__;
151 %newobject MEDCoupling::DataArrayInt32::__radd__;
152 %newobject MEDCoupling::DataArrayInt32::__sub__;
153 %newobject MEDCoupling::DataArrayInt32::__rsub__;
154 %newobject MEDCoupling::DataArrayInt32::__mul__;
155 %newobject MEDCoupling::DataArrayInt32::__rmul__;
156 %newobject MEDCoupling::DataArrayInt32::__div__;
157 %newobject MEDCoupling::DataArrayInt32::__rdiv__;
158 %newobject MEDCoupling::DataArrayInt32::__mod__;
159 %newobject MEDCoupling::DataArrayInt32::__rmod__;
160 %newobject MEDCoupling::DataArrayInt32::__pow__;
161 %newobject MEDCoupling::DataArrayInt32::__rpow__;
162 %newobject MEDCoupling::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;
330 %feature("unref") DataArray "$this->decrRef();"
331 %feature("unref") DataArrayDouble "$this->decrRef();"
332 %feature("unref") DataArrayInt32 "$this->decrRef();"
333 %feature("unref") DataArrayInt64 "$this->decrRef();"
334 %feature("unref") DataArrayChar "$this->decrRef();"
335 %feature("unref") DataArrayAsciiChar "$this->decrRef();"
336 %feature("unref") DataArrayByte "$this->decrRef();"
338 %feature("unref") MapII "$this->decrRef();"
339 %feature("unref") PartDefinition "$this->decrRef();"
340 %feature("unref") DataArrayPartDefinition "$this->decrRef();"
341 %feature("unref") SlicePartDefinition "$this->decrRef();"
343 namespace MEDCoupling
350 } MEDCouplingAxisType;
352 class DataArrayInt32;
353 class DataArrayInt64;
355 #ifndef MEDCOUPLING_USE_64BIT_IDS
356 typedef DataArrayInt32 DataArrayIdType;
357 #define DataArrayIdType DataArrayInt32
359 typedef DataArrayInt64 DataArrayIdType;
360 #define DataArrayIdType DataArrayInt64
363 class MapII : public RefCountObject, public TimeLabel
366 static MCAuto< MapII > New();
369 class PartDefinition : public RefCountObject, public TimeLabel
372 static PartDefinition *New(int start, int stop, int step);
373 static PartDefinition *New(DataArrayIdType *listOfIds);
374 virtual DataArrayIdType *toDAI() const;
375 virtual int getNumberOfElems() const;
376 virtual std::string getRepr() const;
377 virtual PartDefinition *composeWith(const PartDefinition *other) const;
378 virtual void checkConsistencyLight() const;
379 virtual PartDefinition *tryToSimplify() const;
382 virtual PartDefinition *__add__(const PartDefinition& other) const
384 return (*self)+other;
387 virtual PyObject *isEqual(const PartDefinition *other) const
390 bool ret0(self->isEqual(other,ret1));
391 PyObject *ret=PyTuple_New(2);
392 PyObject *ret0Py=ret0?Py_True:Py_False;
394 PyTuple_SetItem(ret,0,ret0Py);
395 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
399 virtual PyObject *deepCopy() const
401 return convertPartDefinition(self->deepCopy(),SWIG_POINTER_OWN | 0);
405 virtual ~PartDefinition();
408 class DataArrayPartDefinition : public PartDefinition
411 static DataArrayPartDefinition *New(DataArrayIdType *listOfIds);
414 DataArrayPartDefinition(DataArrayIdType *listOfIds)
416 return DataArrayPartDefinition::New(listOfIds);
419 std::string __str__() const
421 return self->getRepr();
424 std::string __repr__() const
426 std::ostringstream oss; oss << "DataArrayPartDefinition C++ instance at " << self << "." << std::endl;
427 oss << self->getRepr();
432 virtual ~DataArrayPartDefinition();
435 class SlicePartDefinition : public PartDefinition
438 static SlicePartDefinition *New(int start, int stop, int step);
439 int getEffectiveStop() const;
442 SlicePartDefinition(mcIdType start, mcIdType stop, mcIdType step)
444 return SlicePartDefinition::New(start,stop,step);
447 PyObject *getSlice() const
450 self->getSlice(a,b,c);
451 return PySlice_New(PyInt_FromLong(a),PyInt_FromLong(b),PyInt_FromLong(c));
454 std::string __str__() const
456 return self->getRepr();
459 std::string __repr__() const
461 std::ostringstream oss; oss << "SlicePartDefinition C++ instance at " << self << "." << std::endl;
462 oss << self->getRepr();
467 virtual ~SlicePartDefinition();
470 class DataArray : public RefCountObject, public TimeLabel
473 void setName(const std::string& name);
474 void copyStringInfoFrom(const DataArray& other);
475 void copyPartOfStringInfoFrom(const DataArray& other, const std::vector<std::size_t>& compoIds);
476 void copyPartOfStringInfoFrom2(const std::vector<std::size_t>& compoIds, const DataArray& other);
477 bool areInfoEqualsIfNotWhy(const DataArray& other, std::string& reason) const;
478 bool areInfoEquals(const DataArray& other) const;
479 std::string cppRepr(const std::string& varName) const;
480 std::string getName() const;
481 void setInfoOnComponents(const std::vector<std::string>& info);
482 void setInfoAndChangeNbOfCompo(const std::vector<std::string>& info);
483 std::vector<std::string> getVarsOnComponent() const;
484 std::vector<std::string> getUnitsOnComponent() const;
485 std::string getInfoOnComponent(int i) const;
486 std::string getVarOnComponent(int i) const;
487 std::string getUnitOnComponent(int i) const;
488 void setInfoOnComponent(int i, const std::string& info);
489 int getNumberOfComponents() const;
490 virtual void alloc(int nbOfTuple, int nbOfCompo=1);
491 virtual void reAlloc(int nbOfTuples);
492 virtual bool isAllocated() const;
493 virtual void checkAllocated() const;
494 virtual void desallocate();
495 virtual int getNumberOfTuples() const;
496 virtual std::size_t getNbOfElems() const;
497 virtual std::size_t getNbOfElemAllocated() const;
498 virtual DataArray *deepCopy() const;
499 virtual DataArray *copySorted() const;
500 virtual DataArray *buildNewEmptyInstance() const;
501 virtual DataArray *selectByTupleIdSafeSlice(int bg, int end2, int step) const;
502 virtual void rearrange(int newNbOfCompo);
503 virtual void circularPermutation(int nbOfShift=1);
504 virtual void circularPermutationPerTuple(int nbOfShift=1);
505 virtual void reversePerTuple();
506 void checkNbOfTuples(int nbOfTuples, const std::string& msg) const;
507 void checkNbOfComps(int nbOfCompo, const std::string& msg) const;
508 void checkNbOfTuplesAndComp(const DataArray& other, const std::string& msg) const;
509 void checkNbOfTuplesAndComp(int nbOfTuples, int nbOfCompo, const std::string& msg) const;
510 void checkNbOfElems(mcIdType nbOfElems, const std::string& msg) const;
511 static int GetNumberOfItemGivenBES(int begin, int end, int step, const std::string& msg);
512 static int GetNumberOfItemGivenBESRelative(int begin, int end, int step, const std::string& msg);
513 static int GetPosOfItemGivenBESRelativeNoThrow(int value, int begin, int end, int step);
514 static std::string GetVarNameFromInfo(const std::string& info);
515 static std::string GetUnitFromInfo(const std::string& info);
516 static std::string BuildInfoFromVarAndUnit(const std::string& var, const std::string& unit);
517 static std::string GetAxisTypeRepr(MEDCouplingAxisType at);
518 void updateTime() const;
521 PyObject *getInfoOnComponents() const
523 const std::vector<std::string>& comps=self->getInfoOnComponents();
524 PyObject *ret=PyList_New((mcIdType)comps.size());
525 for(std::size_t i=0;i<comps.size();i++)
526 PyList_SetItem(ret,i,PyString_FromString(comps[i].c_str()));
530 void copyPartOfStringInfoFrom(const DataArray& other, PyObject *li)
532 std::vector<std::size_t> tmp;
533 convertPyToNewIntArr3(li,tmp);
534 self->copyPartOfStringInfoFrom(other,tmp);
537 void copyPartOfStringInfoFrom2(PyObject *li, const DataArray& other)
539 std::vector<std::size_t> tmp;
540 convertPyToNewIntArr3(li,tmp);
541 self->copyPartOfStringInfoFrom2(tmp,other);
544 virtual void renumberInPlace(PyObject *li)
547 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
548 if (!SWIG_IsOK(res1))
551 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
552 if(size!=self->getNumberOfTuples())
554 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
556 self->renumberInPlace(tmp);
560 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
562 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
563 da2->checkAllocated();
564 mcIdType size=self->getNumberOfTuples();
565 if(size!=self->getNumberOfTuples())
567 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
569 self->renumberInPlace(da2->getConstPointer());
573 virtual void renumberInPlaceR(PyObject *li)
576 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
577 if (!SWIG_IsOK(res1))
580 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
581 if(size!=self->getNumberOfTuples())
583 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
585 self->renumberInPlaceR(tmp);
589 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
591 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
592 da2->checkAllocated();
593 mcIdType size=self->getNumberOfTuples();
594 if(size!=self->getNumberOfTuples())
596 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
598 self->renumberInPlaceR(da2->getConstPointer());
602 //tuplesSelec in PyObject * because DataArrayInt is not already existing !
603 virtual void setContigPartOfSelectedValues(mcIdType tupleIdStart, PyObject *aBase, PyObject *tuplesSelec)
605 static const char msg[]="DataArray::setContigPartOfSelectedValuesSlice : 4th parameter \"tuplesSelec\" should be of type DataArrayInt";
606 DataArray *a=CheckAndRetrieveDataArrayInstance(aBase,"DataArray::setContigPartOfSelectedValuesSlice : 3rd parameter \"aBase\" should be of type DataArray");
607 DataArray *tuplesSelecPtr=CheckAndRetrieveDataArrayInstance(tuplesSelec,msg);
608 DataArrayIdType *tuplesSelecPtr2=0;
611 tuplesSelecPtr2=dynamic_cast<DataArrayIdType *>(tuplesSelecPtr);
613 throw INTERP_KERNEL::Exception(msg);
615 self->setContigPartOfSelectedValues(tupleIdStart,a,tuplesSelecPtr2);
618 virtual void setContigPartOfSelectedValuesSlice(mcIdType tupleIdStart, PyObject *aBase, mcIdType bg, mcIdType end2, mcIdType step)
620 DataArray *a=CheckAndRetrieveDataArrayInstance(aBase,"DataArray::setContigPartOfSelectedValuesSlice : 2nd parameter \"aBase\" should be of type DataArray");
621 self->setContigPartOfSelectedValuesSlice(tupleIdStart,a,bg,end2,step);
624 virtual DataArray *selectByTupleRanges(PyObject *li) const
626 std::vector<std::pair<mcIdType,mcIdType> > ranges;
627 convertPyToVectorPairInt(li,ranges);
628 return self->selectByTupleRanges(ranges);
631 virtual DataArray *selectByTupleId(PyObject *li) const
634 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
635 if (!SWIG_IsOK(res1))
638 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
639 return self->selectByTupleId(tmp,tmp+size);
643 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
645 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
646 da2->checkAllocated();
647 return self->selectByTupleId(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
651 virtual DataArray *selectByTupleIdSafe(PyObject *li) const
654 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
655 if (!SWIG_IsOK(res1))
658 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
659 return self->selectByTupleIdSafe(tmp,tmp+size);
663 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
665 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
666 da2->checkAllocated();
667 return self->selectByTupleIdSafe(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
671 virtual PyObject *keepSelectedComponents(PyObject *li) const
673 std::vector<std::size_t> tmp;
674 convertPyToNewIntArr3(li,tmp);
675 DataArray *ret=self->keepSelectedComponents(tmp);
676 return convertDataArray(ret,SWIG_POINTER_OWN | 0 );
679 static PyObject *GetSlice(PyObject *slic, mcIdType sliceId, mcIdType nbOfSlices)
681 if(!PySlice_Check(slic))
682 throw INTERP_KERNEL::Exception("DataArray::GetSlice (wrap) : expecting a pyslice as second (first) parameter !");
683 Py_ssize_t strt=2,stp=2,step=2;
684 GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetSlice (wrap) : the input slice is invalid !");
686 DataArray::GetSlice(ToIdType(strt),ToIdType(stp),ToIdType(step),sliceId,nbOfSlices,a,b);
687 AutoPyPtr ap(PyInt_FromLong(a)),bp(PyInt_FromLong(b)),stepp(PyInt_FromLong(step));
688 return PySlice_New(ap,bp,stepp);
691 PyObject *getSlice(PyObject *slic, mcIdType sliceId, mcIdType nbOfSlices) const
693 if(!PySlice_Check(slic))
694 throw INTERP_KERNEL::Exception("DataArray::getSlice (wrap) : expecting a pyslice as second (first) parameter !");
695 Py_ssize_t strt=2,stp=2,step=2;
696 GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getSlice (wrap) : the input slice is invalid !");
698 DataArray::GetSlice(ToIdType(strt),ToIdType(stp),ToIdType(step),sliceId,nbOfSlices,a,b);
699 AutoPyPtr ap(PyInt_FromLong(a)),bp(PyInt_FromLong(b)),stepp(PyInt_FromLong(step));
700 return PySlice_New(ap,bp,stepp);
703 static mcIdType GetNumberOfItemGivenBES(PyObject *slic)
705 if(!PySlice_Check(slic))
706 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBES (wrap) : expecting a pyslice as second (first) parameter !");
707 Py_ssize_t strt=2,stp=2,step=2;
708 GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetNumberOfItemGivenBES (wrap) : the input slice is invalid !");
709 return DataArray::GetNumberOfItemGivenBES(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
712 static mcIdType GetNumberOfItemGivenBESRelative(PyObject *slic)
714 if(!PySlice_Check(slic))
715 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBESRelative (wrap) : expecting a pyslice as second (first) parameter !");
716 Py_ssize_t strt=2,stp=2,step=2;
717 GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !");
718 return DataArray::GetNumberOfItemGivenBESRelative(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
721 static DataArray *Aggregate(PyObject *arrs)
723 std::vector<const DataArray *> tmp;
724 convertFromPyObjVectorOfObj<const MEDCoupling::DataArray *>(arrs,SWIGTYPE_p_MEDCoupling__DataArray,"DataArray",tmp);
725 return DataArray::Aggregate(tmp);
728 mcIdType getNumberOfItemGivenBES(PyObject *slic) const
730 if(!PySlice_Check(slic))
731 throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBES (wrap) : expecting a pyslice as second (first) parameter !");
732 Py_ssize_t strt=2,stp=2,step=2;
733 GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getNumberOfItemGivenBES (wrap) : the input slice is invalid !");
734 return DataArray::GetNumberOfItemGivenBES(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
737 mcIdType getNumberOfItemGivenBESRelative(PyObject *slic)
739 if(!PySlice_Check(slic))
740 throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBESRelative (wrap) : expecting a pyslice as second (first) parameter !");
741 Py_ssize_t strt=2,stp=2,step=2;
742 GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !");
743 return DataArray::GetNumberOfItemGivenBESRelative(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
746 PyObject *__getstate__() const
748 PyObject *ret(PyTuple_New(2));
749 std::string a0(self->getName());
750 const std::vector<std::string> &a1(self->getInfoOnComponents());
751 PyTuple_SetItem(ret,0,PyString_FromString(a0.c_str()));
753 std::size_t sz(a1.size());
754 PyObject *ret1(PyList_New(sz));
755 for(std::size_t i=0;i<sz;i++)
756 PyList_SetItem(ret1,i,PyString_FromString(a1[i].c_str()));
757 PyTuple_SetItem(ret,1,ret1);
762 void __setstate__(PyObject *inp)
764 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 !";
765 if(!PyTuple_Check(inp))
766 throw INTERP_KERNEL::Exception("DataArrayDouble.__setstate__ : invalid input ! Invalid overwrite of __getstate__ ?");
767 std::size_t sz(PyTuple_Size(inp));
769 throw INTERP_KERNEL::Exception("DataArrayDouble.__setstate__ : invalid tuple in input ! Should be of size 2 ! Invalid overwrite of __getstate__ ?");
770 PyObject *a0(PyTuple_GetItem(inp,0));
771 self->setName(convertPyObjectToStr(a0,MSG));
772 PyObject *a1(PyTuple_GetItem(inp,1));
773 std::vector<std::string> a1cpp;
774 if(!fillStringVector(a1,a1cpp))
775 throw INTERP_KERNEL::Exception(MSG);
776 self->setInfoOnComponents(a1cpp);
781 class DataArrayDouble;
783 class DataArrayFloat : public DataArray
786 static DataArrayFloat *New();
787 void fillWithValue(float val);
788 bool isEqual(const DataArrayFloat& other, float prec) const;
789 bool isEqualWithoutConsideringStr(const DataArrayFloat& other, float prec) const;
790 bool isUniform(float val, float eps) const;
791 void pushBackSilent(float val);
792 void iota(float init=0.);
793 DataArrayFloatIterator *iterator();
794 MCAuto<DataArrayDouble> convertToDblArr() const;
795 static DataArrayFloat *Meld(const DataArrayFloat *a1, const DataArrayFloat *a2);
800 return DataArrayFloat::New();
803 static DataArrayFloat *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
805 return DataArrayT_New<float>(elt0,nbOfTuples,elt2);
808 DataArrayFloat(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
810 return MEDCoupling_DataArrayFloat_New__SWIG_1(elt0,nbOfTuples,elt2);
813 DataArrayFloatIterator *__iter__()
815 return self->iterator();
818 std::string __repr__() const
820 std::ostringstream oss;
821 self->reprQuickOverview(oss);
825 std::string __str__() const
827 return self->reprNotTooLong();
830 mcIdType __len__() const
832 if(self->isAllocated())
834 return self->getNumberOfTuples();
838 throw INTERP_KERNEL::Exception("DataArrayFloat::__len__ : Instance is NOT allocated !");
842 PyObject *getValues() const
844 const float *vals(self->begin());
845 return convertDblArrToPyList<float>(vals,self->getNbOfElems());
848 PyObject *getValuesAsTuple() const
850 const float *vals(self->begin());
851 std::size_t nbOfComp(self->getNumberOfComponents());
852 mcIdType nbOfTuples(self->getNumberOfTuples());
853 return convertDblArrToPyListOfTuple<float>(vals,nbOfComp,nbOfTuples);
856 PyObject *isEqualIfNotWhy(const DataArrayFloat& other, float prec) const
859 bool ret0=self->isEqualIfNotWhy(other,prec,ret1);
860 PyObject *ret=PyTuple_New(2);
861 PyObject *ret0Py=ret0?Py_True:Py_False;
863 PyTuple_SetItem(ret,0,ret0Py);
864 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
868 PyObject *__getitem__(PyObject *obj)
870 return DataArrayT__getitem<float>(self,obj);
873 DataArrayFloat *__setitem__(PyObject *obj, PyObject *value)
875 return DataArrayT__setitem__<float>(self,obj,value);
878 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
880 return DataArrayT_iadd<float>(trueSelf,obj,self);
883 PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
885 return DataArrayT_isub<float>(trueSelf,obj,self);
888 PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
890 return DataArrayT_imul<float>(trueSelf,obj,self);
893 DataArrayFloat *__rmul__(PyObject *obj)
895 return DataArrayFPT_rmul<float>(self,obj);
898 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
900 return DataArrayT_idiv<float>(trueSelf,obj,self);
904 PyObject *toNumPyArray() // not const. It is not a bug !
906 return ToNumPyArray<DataArrayFloat,float>(self,NPY_FLOAT,"DataArrayFloat");
912 class DataArrayFloatTuple;
914 class DataArrayFloatIterator
917 DataArrayFloatIterator(DataArrayFloat *da);
918 ~DataArrayFloatIterator();
923 DataArrayFloatTuple *ret=self->nextt();
925 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayFloatTuple,SWIG_POINTER_OWN|0);
928 PyErr_SetString(PyExc_StopIteration,"No more data.");
935 class DataArrayFloatTuple
938 std::size_t getNumberOfCompo() const;
939 DataArrayFloat *buildDAFloat(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
942 std::string __str__() const
947 float __float__() const
949 return self->floatValue();
952 DataArrayFloat *buildDAFloat()
954 return self->buildDAFloat(1,self->getNumberOfCompo());
957 /*PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
959 MCAuto<DataArrayFloat> ret=self->buildDAFloat(1,self->getNumberOfCompo());
960 MEDCoupling_DataArrayFloat____imul___(ret,0,obj);
961 Py_XINCREF(trueSelf);
967 return PyInt_FromLong(self->getNumberOfCompo());
972 class DataArrayDoubleIterator;
974 class DataArrayDouble : public DataArray
977 static DataArrayDouble *New();
978 double doubleValue() const;
980 void aggregate(const DataArrayDouble *other);
981 DataArrayDouble *performCopyOrIncrRef(bool deepCopy) const;
982 void deepCopyFrom(const DataArrayDouble& other);
983 void reserve(std::size_t nbOfElems);
984 void pushBackSilent(double val);
985 double popBackSilent();
987 void allocIfNecessary(int nbOfTuple, int nbOfCompo);
989 void fillWithValue(double val);
990 void iota(double init=0.);
991 bool isUniform(double val, double eps) const;
992 void sort(bool asc=true);
994 void checkMonotonic(bool increasing, double eps) const;
995 bool isMonotonic(bool increasing, double eps) const;
996 std::string repr() const;
997 std::string reprZip() const;
998 std::string reprNotTooLong() const;
999 bool isEqual(const DataArrayDouble& other, double prec) const;
1000 bool isEqualWithoutConsideringStr(const DataArrayDouble& other, double prec) const;
1001 DataArrayDouble *fromNoInterlace() const;
1002 DataArrayDouble *toNoInterlace() const;
1003 DataArrayDouble *subArray(int tupleIdBg, int tupleIdEnd=-1) const;
1005 DataArrayDouble *changeNbOfComponents(std::size_t newNbOfComp, double dftValue) const;
1006 void meldWith(const DataArrayDouble *other);
1007 DataArrayDouble *duplicateEachTupleNTimes(int nbTimes) const;
1008 DataArrayDouble *getDifferentValues(double prec, int limitTupleId=-1) const;
1009 DataArrayIdType *findClosestTupleId(const DataArrayDouble *other) const;
1010 DataArrayIdType *computeNbOfInteractionsWith(const DataArrayDouble *otherBBoxFrmt, double eps) const;
1011 void setPartOfValues1(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare=true);
1012 void setPartOfValuesSimple1(double a, mcIdType bgTuples, mcIdType endTuples, mcIdType stepTuples, mcIdType bgComp, mcIdType endComp, mcIdType stepComp);
1013 void setPartOfValuesAdv(const DataArrayDouble *a, const DataArrayIdType *tuplesSelec);
1014 double getIJ(int tupleId, int compoId) const;
1015 double front() const;
1016 double back() const;
1017 double getIJSafe(int tupleId, int compoId) const;
1018 void setIJ(int tupleId, int compoId, double newVal);
1019 void setIJSilent(int tupleId, int compoId, double newVal);
1020 double *getPointer();
1021 void checkNoNullValues() const;
1022 DataArrayDouble *computeBBoxPerTuple(double epsilon=0.0) const;
1023 void recenterForMaxPrecision(double eps);
1024 double getMaxValueInArray() const;
1025 double getMaxAbsValueInArray() const;
1026 double getMinValueInArray() const;
1027 int count(double value, double eps) const;
1028 double getAverageValue() const;
1029 double norm2() const;
1030 double normMax() const;
1031 double normMin() const;
1032 double accumulate(int compId) const;
1033 DataArrayDouble *fromPolarToCart() const;
1034 DataArrayDouble *fromCylToCart() const;
1035 DataArrayDouble *fromSpherToCart() const;
1036 DataArrayDouble *fromCartToPolar() const;
1037 DataArrayDouble *fromCartToCyl() const;
1038 DataArrayDouble *fromCartToSpher() const;
1039 DataArrayDouble *cartesianize(MEDCouplingAxisType atOfThis) const;
1040 DataArrayDouble *doublyContractedProduct() const;
1041 DataArrayDouble *determinant() const;
1042 DataArrayDouble *eigenValues() const;
1043 DataArrayDouble *eigenVectors() const;
1044 DataArrayDouble *inverse() const;
1045 DataArrayDouble *trace() const;
1046 DataArrayDouble *deviator() const;
1047 DataArrayDouble *magnitude() const;
1048 DataArrayDouble *maxPerTuple() const;
1049 DataArrayDouble *sumPerTuple() const;
1050 DataArrayDouble *buildEuclidianDistanceDenseMatrix() const;
1051 DataArrayDouble *buildEuclidianDistanceDenseMatrixWith(const DataArrayDouble *other) const;
1052 void sortPerTuple(bool asc);
1054 DataArrayDouble *computeAbs() const;
1055 void applyLin(double a, double b, int compoId);
1056 void applyLin(double a, double b);
1057 void applyInv(double numerator);
1058 void applyPow(double val);
1059 void applyRPow(double val);
1060 DataArrayDouble *negate() const;
1061 DataArrayDouble *applyFunc(int nbOfComp, FunctionToEvaluate func) const;
1062 DataArrayDouble *applyFunc(int nbOfComp, const std::string& func, bool isSafe=true) const;
1063 DataArrayDouble *applyFunc(const std::string& func, bool isSafe=true) const;
1064 void applyFuncOnThis(const std::string& func, bool isSafe=true);
1065 DataArrayDouble *applyFuncCompo(int nbOfComp, const std::string& func, bool isSafe=true) const;
1066 DataArrayDouble *applyFuncNamedCompo(int nbOfComp, const std::vector<std::string>& varsOrder, const std::string& func, bool isSafe=true) const;
1067 void applyFuncFast32(const std::string& func);
1068 void applyFuncFast64(const std::string& func);
1069 DataArrayIdType *findIdsInRange(double vmin, double vmax) const;
1070 DataArrayIdType *findIdsNotInRange(double vmin, double vmax) const;
1071 DataArrayIdType *findIdsStrictlyNegative() const;
1072 static DataArrayDouble *Aggregate(const DataArrayDouble *a1, const DataArrayDouble *a2);
1073 static DataArrayDouble *Meld(const DataArrayDouble *a1, const DataArrayDouble *a2);
1074 static DataArrayDouble *Dot(const DataArrayDouble *a1, const DataArrayDouble *a2);
1075 static DataArrayDouble *CrossProduct(const DataArrayDouble *a1, const DataArrayDouble *a2);
1076 static DataArrayDouble *Max(const DataArrayDouble *a1, const DataArrayDouble *a2);
1077 static DataArrayDouble *Min(const DataArrayDouble *a1, const DataArrayDouble *a2);
1078 static DataArrayDouble *Add(const DataArrayDouble *a1, const DataArrayDouble *a2);
1079 void addEqual(const DataArrayDouble *other);
1080 static DataArrayDouble *Substract(const DataArrayDouble *a1, const DataArrayDouble *a2);
1081 void substractEqual(const DataArrayDouble *other);
1082 static DataArrayDouble *Multiply(const DataArrayDouble *a1, const DataArrayDouble *a2);
1083 void multiplyEqual(const DataArrayDouble *other);
1084 static DataArrayDouble *Divide(const DataArrayDouble *a1, const DataArrayDouble *a2);
1085 void divideEqual(const DataArrayDouble *other);
1086 static DataArrayDouble *Pow(const DataArrayDouble *a1, const DataArrayDouble *a2);
1087 void powEqual(const DataArrayDouble *other);
1088 MCAuto<DataArrayIdType> findIdsGreaterOrEqualTo(double val) const;
1089 MCAuto<DataArrayIdType> findIdsGreaterThan(double val) const;
1090 MCAuto<DataArrayIdType> findIdsLowerOrEqualTo(double val) const;
1091 MCAuto<DataArrayIdType> findIdsLowerThan(double val) const;
1092 MCAuto<DataArrayInt32> convertToIntArr() const;
1093 MCAuto<DataArrayDouble> selectPartDef(const PartDefinition* pd) const;
1094 MCAuto<DataArrayDouble> cumSum() const;
1095 MCAuto<DataArrayFloat> convertToFloatArr() const;
1100 return DataArrayDouble::New();
1103 static DataArrayDouble *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
1105 return DataArrayT_New<double>(elt0,nbOfTuples,elt2);
1108 DataArrayDouble(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
1110 return MEDCoupling_DataArrayDouble_New__SWIG_1(elt0,nbOfTuples,elt2);
1113 void pushBackValsSilent(PyObject *li)
1116 std::vector<double> bb;
1117 mcIdType sw; mcIdType nbTuples=-1;
1118 const char msg[]="Python wrap of DataArrayDouble::pushBackValsSilent : ";
1119 const double *tmp=convertObjToPossibleCpp5_SingleCompo(li,sw,val,bb,msg,true,nbTuples);
1120 self->pushBackValsSilent(tmp,tmp+nbTuples);
1123 std::string __repr__() const
1125 std::ostringstream oss;
1126 self->reprQuickOverview(oss);
1130 std::string __str__() const
1132 return self->reprNotTooLong();
1135 double __float__() const
1137 return self->doubleValue();
1140 mcIdType __len__() const
1142 if(self->isAllocated())
1144 return self->getNumberOfTuples();
1148 throw INTERP_KERNEL::Exception("DataArrayDouble::__len__ : Instance is NOT allocated !");
1152 PyObject *asArcOfCircle() const
1154 double center[2],radius,ang;
1155 self->asArcOfCircle(center,radius,ang);
1156 PyObject *ret(PyTuple_New(3));
1158 PyObject *ret0(PyList_New(2));
1159 PyList_SetItem(ret0,0,PyFloat_FromDouble(center[0]));
1160 PyList_SetItem(ret0,1,PyFloat_FromDouble(center[1]));
1161 PyTuple_SetItem(ret,0,ret0);
1163 PyTuple_SetItem(ret,1,PyFloat_FromDouble(radius));
1164 PyTuple_SetItem(ret,2,PyFloat_FromDouble(ang));
1168 DataArrayDoubleIterator *__iter__()
1170 return self->iterator();
1173 void setValues(PyObject *li, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
1175 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 !";
1176 if(PyList_Check(li) || PyTuple_Check(li))
1178 if(nbOfTuples && nbOfTuples != Py_None)
1180 if(PyInt_Check(nbOfTuples))
1182 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
1184 throw INTERP_KERNEL::Exception("DataArrayDouble::setValues : should be a positive set of allocated memory !");
1185 if(nbOfComp && nbOfComp != Py_None)
1187 if(PyInt_Check(nbOfComp))
1188 {//DataArrayDouble.setValues([1.,3.,4.,5.],2,2)
1189 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
1191 throw INTERP_KERNEL::Exception("DataArrayDouble::setValues : should be a positive number of components !");
1192 std::vector<double> tmp=fillArrayWithPyListDbl2(li,nbOfTuples1,nbOfCompo);
1193 self->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1196 throw INTERP_KERNEL::Exception(msg);
1199 {//DataArrayDouble.setValues([1.,3.,4.],3)
1201 std::vector<double> tmp=fillArrayWithPyListDbl2(li,nbOfTuples1,tmpp1);
1202 self->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1206 throw INTERP_KERNEL::Exception(msg);
1209 {// DataArrayDouble.setValues([1.,3.,4.])
1210 mcIdType tmpp1=-1,tmpp2=-1;
1211 std::vector<double> tmp=fillArrayWithPyListDbl2(li,tmpp1,tmpp2);
1212 self->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1216 throw INTERP_KERNEL::Exception(msg);
1219 PyObject *getValues() const
1221 const double *vals(self->begin());
1222 return convertDblArrToPyList<double>(vals,self->getNbOfElems());
1226 PyObject *toNumPyArray() // not const. It is not a bug !
1228 return ToNumPyArray<DataArrayDouble,double>(self,NPY_DOUBLE,"DataArrayDouble");
1232 PyObject *isEqualIfNotWhy(const DataArrayDouble& other, double prec) const
1235 bool ret0=self->isEqualIfNotWhy(other,prec,ret1);
1236 PyObject *ret=PyTuple_New(2);
1237 PyObject *ret0Py=ret0?Py_True:Py_False;
1239 PyTuple_SetItem(ret,0,ret0Py);
1240 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
1244 PyObject *getValuesAsTuple() const
1246 const double *vals(self->begin());
1247 std::size_t nbOfComp(self->getNumberOfComponents());
1248 mcIdType nbOfTuples(self->getNumberOfTuples());
1249 return convertDblArrToPyListOfTuple<double>(vals,nbOfComp,nbOfTuples);
1252 static PyObject *ComputeIntegralOfSeg2IntoTri3(PyObject *seg2, PyObject *tri3)
1254 const char msg[]="Python wrap of DataArrayDouble::ComputeIntegralOfSeg2IntoTri3 : ";
1256 DataArrayDouble *a,*a2;
1257 DataArrayDoubleTuple *aa,*aa2;
1258 std::vector<double> bb,bb2;
1260 const double *seg2Ptr(convertObjToPossibleCpp5_Safe(seg2,sw,val,a,aa,bb,msg,2,2,true));
1261 const double *tri3Ptr(convertObjToPossibleCpp5_Safe(tri3,sw,val2,a2,aa2,bb2,msg,3,2,true));
1263 double res0[3],res1;
1264 DataArrayDouble::ComputeIntegralOfSeg2IntoTri3(seg2Ptr,tri3Ptr,res0,res1);
1265 PyObject *ret(PyTuple_New(2)),*ret0(PyTuple_New(3));
1266 PyTuple_SetItem(ret0,0,PyFloat_FromDouble(res0[0]));
1267 PyTuple_SetItem(ret0,1,PyFloat_FromDouble(res0[1]));
1268 PyTuple_SetItem(ret0,2,PyFloat_FromDouble(res0[2]));
1269 PyTuple_SetItem(ret,0,ret0);
1270 PyTuple_SetItem(ret,1,PyFloat_FromDouble(res1));
1274 DataArrayDouble *symmetry3DPlane(PyObject *point, PyObject *normalVector)
1276 const char msg[]="Python wrap of DataArrayDouble::symmetry3DPlane : ";
1278 DataArrayDouble *a,*a2;
1279 DataArrayDoubleTuple *aa,*aa2;
1280 std::vector<double> bb,bb2;
1282 const double *centerPtr(convertObjToPossibleCpp5_Safe(point,sw,val,a,aa,bb,msg,1,3,true));
1283 const double *vectorPtr(convertObjToPossibleCpp5_Safe(normalVector,sw,val2,a2,aa2,bb2,msg,1,3,true));
1284 MCAuto<DataArrayDouble> ret(self->symmetry3DPlane(centerPtr,vectorPtr));
1288 static PyObject *GiveBaseForPlane(PyObject *normalVector)
1290 const char msg[]="Python wrap of DataArrayDouble::GiveBaseForPlane : ";
1293 DataArrayDoubleTuple *aa;
1294 std::vector<double> bb,bb2;
1296 const double *vectorPtr(convertObjToPossibleCpp5_Safe(normalVector,sw,val,a,aa,bb,msg,1,3,true));
1298 DataArrayDouble::GiveBaseForPlane(vectorPtr,res);
1299 return convertDblArrToPyListOfTuple<double>(res,3,3);
1302 DataArrayDouble *fromCartToCylGiven(const DataArrayDouble *coords, PyObject *center, PyObject *vector) const
1304 const char msg[]="Python wrap of DataArrayDouble::fromCartToCylGiven : ";
1306 DataArrayDouble *a,*a2;
1307 DataArrayDoubleTuple *aa,*aa2;
1308 std::vector<double> bb,bb2;
1310 const double *centerPtr=convertObjToPossibleCpp5_Safe(center,sw,val,a,aa,bb,msg,1,3,true);
1311 const double *vectorPtr=convertObjToPossibleCpp5_Safe(vector,sw,val2,a2,aa2,bb2,msg,1,3,true);
1312 return self->fromCartToCylGiven(coords,centerPtr,vectorPtr);
1315 DataArrayDouble *renumber(PyObject *li)
1318 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
1319 if (!SWIG_IsOK(res1))
1322 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1323 if(size!=self->getNumberOfTuples())
1325 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1327 return self->renumber(tmp);
1331 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1333 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1334 da2->checkAllocated();
1335 mcIdType size=self->getNumberOfTuples();
1336 if(size!=self->getNumberOfTuples())
1338 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1340 return self->renumber(da2->getConstPointer());
1344 DataArrayDouble *renumberR(PyObject *li)
1347 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
1348 if (!SWIG_IsOK(res1))
1351 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1352 if(size!=self->getNumberOfTuples())
1354 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1356 return self->renumberR(tmp);
1360 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1362 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1363 da2->checkAllocated();
1364 mcIdType size=self->getNumberOfTuples();
1365 if(size!=self->getNumberOfTuples())
1367 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1369 return self->renumberR(da2->getConstPointer());
1373 DataArrayDouble *renumberAndReduce(PyObject *li, mcIdType newNbOfTuple)
1376 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
1377 if (!SWIG_IsOK(res1))
1380 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1381 if(size!=self->getNumberOfTuples())
1383 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1385 return self->renumberAndReduce(tmp,newNbOfTuple);
1389 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1391 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1392 da2->checkAllocated();
1393 mcIdType size=self->getNumberOfTuples();
1394 if(size!=self->getNumberOfTuples())
1396 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1398 return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
1402 PyObject *minimalDistanceTo(const DataArrayDouble *other) const
1404 mcIdType thisTupleId,otherTupleId;
1405 double r0=self->minimalDistanceTo(other,thisTupleId,otherTupleId);
1406 PyObject *ret=PyTuple_New(3);
1407 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r0));
1408 PyTuple_SetItem(ret,1,PyInt_FromLong(thisTupleId));
1409 PyTuple_SetItem(ret,2,PyInt_FromLong(otherTupleId));
1413 PyObject *getMaxValue() const
1416 double r1=self->getMaxValue(tmp);
1417 PyObject *ret=PyTuple_New(2);
1418 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1419 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1423 PyObject *getMaxAbsValue() const
1426 double r1=self->getMaxAbsValue(tmp);
1427 PyObject *ret=PyTuple_New(2);
1428 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1429 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1433 PyObject *getMaxValue2() const
1435 DataArrayIdType *tmp;
1436 double r1=self->getMaxValue2(tmp);
1437 PyObject *ret=PyTuple_New(2);
1438 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1439 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1443 PyObject *getMinValue() const
1446 double r1=self->getMinValue(tmp);
1447 PyObject *ret=PyTuple_New(2);
1448 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1449 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1453 PyObject *getMinValue2() const
1455 DataArrayIdType *tmp;
1456 double r1=self->getMinValue2(tmp);
1457 PyObject *ret=PyTuple_New(2);
1458 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1459 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1463 PyObject *getMinMaxPerComponent() const
1465 std::size_t nbOfCompo(self->getNumberOfComponents());
1466 INTERP_KERNEL::AutoPtr<double> tmp(new double[2*nbOfCompo]);
1467 self->getMinMaxPerComponent(tmp);
1468 PyObject *ret=convertDblArrToPyListOfTuple<double>(tmp,2,ToIdType(nbOfCompo));
1472 PyObject *normMaxPerComponent() const
1474 std::size_t nbOfCompo(self->getNumberOfComponents());
1475 INTERP_KERNEL::AutoPtr<double> tmp(new double[nbOfCompo]);
1476 self->normMaxPerComponent(tmp);
1477 return convertDblArrToPyList<double>(tmp,ToIdType(nbOfCompo));
1480 PyObject *accumulate() const
1482 std::size_t sz=self->getNumberOfComponents();
1483 INTERP_KERNEL::AutoPtr<double> tmp=new double[sz];
1484 self->accumulate(tmp);
1485 return convertDblArrToPyList<double>(tmp,ToIdType(sz));
1488 DataArrayDouble *accumulatePerChunck(PyObject *indexArr) const
1490 mcIdType sw, sz,val;
1491 std::vector<mcIdType> val2;
1492 const mcIdType *bg=convertIntStarLikePyObjToCppIntStar(indexArr,sw,sz,val,val2);
1493 return self->accumulatePerChunck(bg,bg+sz);
1496 PyObject *findCommonTuples(double prec, mcIdType limitNodeId=-1) const
1498 DataArrayIdType *comm, *commIndex;
1499 self->findCommonTuples(prec,limitNodeId,comm,commIndex);
1500 PyObject *res = PyList_New(2);
1501 PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(comm),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1502 PyList_SetItem(res,1,SWIG_NewPointerObj(SWIG_as_voidptr(commIndex),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1506 PyObject *distanceToTuple(PyObject *tuple) const
1510 DataArrayDoubleTuple *aa;
1511 std::vector<double> bb;
1513 mcIdType tupleId=-1;
1514 std::size_t nbOfCompo=self->getNumberOfComponents();
1515 const double *pt=convertObjToPossibleCpp5_Safe(tuple,sw,val,a,aa,bb,"Python wrap of DataArrayDouble::distanceToTuple",1,(int)nbOfCompo,true);
1517 double ret0=self->distanceToTuple(pt,pt+nbOfCompo,tupleId);
1518 PyObject *ret=PyTuple_New(2);
1519 PyTuple_SetItem(ret,0,PyFloat_FromDouble(ret0));
1520 PyTuple_SetItem(ret,1,PyInt_FromLong(tupleId));
1524 void setSelectedComponents(const DataArrayDouble *a, PyObject *li)
1526 std::vector<std::size_t> tmp;
1527 convertPyToNewIntArr3(li,tmp);
1528 self->setSelectedComponents(a,tmp);
1531 PyObject *explodeComponents() const
1533 std::vector< MCAuto<DataArrayDouble> > retCpp(self->explodeComponents());
1534 std::size_t sz(retCpp.size());
1535 PyObject *res(PyList_New(sz));
1536 for(std::size_t i=0;i<sz;i++)
1537 PyList_SetItem(res,i,SWIG_NewPointerObj(SWIG_as_voidptr(retCpp[i].retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ));
1541 PyObject *getTuple(mcIdType tupleId)
1543 std::size_t sz=self->getNumberOfComponents();
1544 INTERP_KERNEL::AutoPtr<double> tmp=new double[sz];
1545 self->getTuple(tupleId,tmp);
1546 return convertDblArrToPyList<double>(tmp,ToIdType(sz));
1549 static DataArrayDouble *Aggregate(PyObject *li)
1551 std::vector<const DataArrayDouble *> tmp;
1552 convertFromPyObjVectorOfObj<const DataArrayDouble *>(li,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",tmp);
1553 return DataArrayDouble::Aggregate(tmp);
1556 static DataArrayDouble *Meld(PyObject *li)
1558 std::vector<const DataArrayDouble *> tmp;
1559 convertFromPyObjVectorOfObj<const DataArrayDouble *>(li,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",tmp);
1560 return DataArrayDouble::Meld(tmp);
1563 PyObject *computeTupleIdsNearTuples(PyObject *pt, double eps) const
1567 DataArrayDoubleTuple *aa;
1568 std::vector<double> bb;
1570 std::size_t nbComp=self->getNumberOfComponents();
1571 mcIdType nbTuples=-1;
1572 const char msg[]="Python wrap of DataArrayDouble::computeTupleIdsNearTuples : ";
1573 const double *pos=convertObjToPossibleCpp5_Safe2(pt,sw,val,a,aa,bb,msg,(int)nbComp,true,nbTuples);
1574 MCAuto<DataArrayDouble> inpu=DataArrayDouble::New(); inpu->useArray(pos,false,DeallocType::CPP_DEALLOC,nbTuples,nbComp);
1575 DataArrayIdType *c=0,*cI=0;
1576 self->computeTupleIdsNearTuples(inpu,eps,c,cI);
1577 PyObject *ret=PyTuple_New(2);
1578 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1579 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1583 PyObject *areIncludedInMe(const DataArrayDouble *other, double prec) const
1585 DataArrayIdType *ret1=0;
1586 bool ret0=self->areIncludedInMe(other,prec,ret1);
1587 PyObject *ret=PyTuple_New(2);
1588 PyObject *ret0Py=ret0?Py_True:Py_False;
1590 PyTuple_SetItem(ret,0,ret0Py);
1591 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1595 PyObject *__getitem__(PyObject *obj)
1597 return DataArrayT__getitem<double>(self,obj);
1600 DataArrayDouble *__setitem__(PyObject *obj, PyObject *value)
1602 return DataArrayT__setitem__<double>(self,obj,value);
1605 DataArrayDouble *__neg__() const
1607 return self->negate();
1610 PyObject *__add__(PyObject *obj)
1612 const char msg[]="Unexpected situation in DataArrayDouble.__add__ !";
1615 DataArrayDoubleTuple *aa;
1616 std::vector<double> bb;
1619 #ifndef WITHOUT_AUTOFIELD
1621 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1623 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1626 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1627 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___radd__Impl(other,tmp);
1629 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1632 throw INTERP_KERNEL::Exception(msg);
1636 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1641 MCAuto<DataArrayDouble> ret=self->deepCopy();
1642 ret->applyLin(1.,val);
1643 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1647 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1651 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1652 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1656 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1657 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1660 throw INTERP_KERNEL::Exception(msg);
1664 DataArrayDouble *__radd__(PyObject *obj)
1666 const char msg[]="Unexpected situation in __radd__ !";
1669 DataArrayDoubleTuple *aa;
1670 std::vector<double> bb;
1672 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1677 MCAuto<DataArrayDouble> ret=self->deepCopy();
1678 ret->applyLin(1.,val);
1683 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1684 return DataArrayDouble::Add(self,aaa);
1688 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1689 return DataArrayDouble::Add(self,aaa);
1692 throw INTERP_KERNEL::Exception(msg);
1696 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
1698 return DataArrayT_iadd<double>(trueSelf,obj,self);
1701 PyObject *__sub__(PyObject *obj)
1703 const char msg[]="Unexpected situation in __sub__ !";
1706 DataArrayDoubleTuple *aa;
1707 std::vector<double> bb;
1710 #ifndef WITHOUT_AUTOFIELD
1712 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1714 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1717 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1718 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rsub__Impl(other,tmp);
1720 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1723 throw INTERP_KERNEL::Exception(msg);
1727 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1732 MCAuto<DataArrayDouble> ret=self->deepCopy();
1733 ret->applyLin(1.,-val);
1734 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1738 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1742 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1743 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1747 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1748 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1751 throw INTERP_KERNEL::Exception(msg);
1755 DataArrayDouble *__rsub__(PyObject *obj)
1757 const char msg[]="Unexpected situation in __rsub__ !";
1760 DataArrayDoubleTuple *aa;
1761 std::vector<double> bb;
1763 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1768 MCAuto<DataArrayDouble> ret=self->deepCopy();
1769 ret->applyLin(-1.,val);
1774 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1775 return DataArrayDouble::Substract(aaa,self);
1779 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1780 return DataArrayDouble::Substract(aaa,self);
1783 throw INTERP_KERNEL::Exception(msg);
1787 PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
1789 return DataArrayT_isub<double>(trueSelf,obj,self);
1792 PyObject *__mul__(PyObject *obj)
1794 const char msg[]="Unexpected situation in __mul__ !";
1797 DataArrayDoubleTuple *aa;
1798 std::vector<double> bb;
1801 #ifndef WITHOUT_AUTOFIELD
1803 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1805 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1808 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1809 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rmul__Impl(other,tmp);
1811 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1814 throw INTERP_KERNEL::Exception(msg);
1818 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1823 MCAuto<DataArrayDouble> ret=self->deepCopy();
1824 ret->applyLin(val,0.);
1825 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1829 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1833 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1834 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1838 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1839 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1842 throw INTERP_KERNEL::Exception(msg);
1846 DataArrayDouble *__rmul__(PyObject *obj)
1848 return DataArrayFPT_rmul<double>(self,obj);
1851 PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
1853 return DataArrayT_imul<double>(trueSelf,obj,self);
1856 PyObject *__div__(PyObject *obj)
1858 const char msg[]="Unexpected situation in __div__ !";
1861 DataArrayDoubleTuple *aa;
1862 std::vector<double> bb;
1865 #ifndef WITHOUT_AUTOFIELD
1867 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1869 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1872 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1873 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rdiv__Impl(other,tmp);
1875 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1878 throw INTERP_KERNEL::Exception(msg);
1882 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1888 throw INTERP_KERNEL::Exception("DataArrayDouble::__div__ : trying to divide by zero !");
1889 MCAuto<DataArrayDouble> ret=self->deepCopy();
1890 ret->applyLin(1/val,0.);
1891 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1895 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1899 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1900 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1904 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1905 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1908 throw INTERP_KERNEL::Exception(msg);
1912 DataArrayDouble *__rdiv__(PyObject *obj)
1914 const char msg[]="Unexpected situation in __rdiv__ !";
1917 DataArrayDoubleTuple *aa;
1918 std::vector<double> bb;
1920 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1925 MCAuto<DataArrayDouble> ret=self->deepCopy();
1931 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1932 return DataArrayDouble::Divide(aaa,self);
1936 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1937 return DataArrayDouble::Divide(aaa,self);
1940 throw INTERP_KERNEL::Exception(msg);
1944 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
1946 return DataArrayT_idiv<double>(trueSelf,obj,self);
1949 DataArrayDouble *__pow__(PyObject *obj)
1951 const char msg[]="Unexpected situation in __pow__ !";
1954 DataArrayDoubleTuple *aa;
1955 std::vector<double> bb;
1957 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1962 MCAuto<DataArrayDouble> ret=self->deepCopy();
1968 return DataArrayDouble::Pow(self,a);
1972 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1973 return DataArrayDouble::Pow(self,aaa);
1977 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1978 return DataArrayDouble::Pow(self,aaa);
1981 throw INTERP_KERNEL::Exception(msg);
1985 DataArrayDouble *__rpow__(PyObject *obj)
1987 const char msg[]="Unexpected situation in __rpow__ !";
1990 DataArrayDoubleTuple *aa;
1991 std::vector<double> bb;
1993 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1998 MCAuto<DataArrayDouble> ret=self->deepCopy();
1999 ret->applyRPow(val);
2004 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
2005 return DataArrayDouble::Pow(aaa,self);
2009 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
2010 return DataArrayDouble::Pow(aaa,self);
2013 throw INTERP_KERNEL::Exception(msg);
2017 PyObject *___ipow___(PyObject *trueSelf, PyObject *obj)
2019 const char msg[]="Unexpected situation in __ipow__ !";
2022 DataArrayDoubleTuple *aa;
2023 std::vector<double> bb;
2025 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
2030 self->applyPow(val);
2031 Py_XINCREF(trueSelf);
2037 Py_XINCREF(trueSelf);
2042 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
2043 self->powEqual(aaa);
2044 Py_XINCREF(trueSelf);
2049 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
2050 self->powEqual(aaa);
2051 Py_XINCREF(trueSelf);
2055 throw INTERP_KERNEL::Exception(msg);
2059 PyObject *computeTupleIdsNearTuples(const DataArrayDouble *other, double eps)
2061 DataArrayIdType *c=0,*cI=0;
2063 self->computeTupleIdsNearTuples(other,eps,c,cI);
2064 PyObject *ret=PyTuple_New(2);
2065 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2066 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2070 PyObject *maxPerTupleWithCompoId() const
2072 DataArrayIdType *ret1=0;
2073 DataArrayDouble *ret0=self->maxPerTupleWithCompoId(ret1);
2074 PyObject *ret=PyTuple_New(2);
2075 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ));
2076 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2082 class DataArrayDoubleTuple;
2084 class DataArrayDoubleIterator
2087 DataArrayDoubleIterator(DataArrayDouble *da);
2088 ~DataArrayDoubleIterator();
2093 DataArrayDoubleTuple *ret=self->nextt();
2095 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayDoubleTuple,SWIG_POINTER_OWN|0);
2098 PyErr_SetString(PyExc_StopIteration,"No more data.");
2105 class DataArrayDoubleTuple
2108 std::size_t getNumberOfCompo() const;
2109 DataArrayDouble *buildDADouble(int nbOfTuples, int nbOfCompo) const;
2112 std::string __str__() const
2114 return self->repr();
2117 double __float__() const
2119 return self->doubleValue();
2122 DataArrayDouble *buildDADouble()
2124 return self->buildDADouble(1,self->getNumberOfCompo());
2127 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
2129 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2130 MEDCoupling_DataArrayDouble____iadd___(ret,0,obj);
2131 Py_XINCREF(trueSelf);
2135 PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
2137 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2138 MEDCoupling_DataArrayDouble____isub___(ret,0,obj);
2139 Py_XINCREF(trueSelf);
2143 PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
2145 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2146 MEDCoupling_DataArrayDouble____imul___(ret,0,obj);
2147 Py_XINCREF(trueSelf);
2151 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
2153 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2154 MEDCoupling_DataArrayDouble____idiv___(ret,0,obj);
2155 Py_XINCREF(trueSelf);
2161 return PyInt_FromLong(self->getNumberOfCompo());
2164 PyObject *__getitem__(PyObject *obj)
2166 const char msg2[]="DataArrayDoubleTuple::__getitem__ : Mismatch of slice values in 2nd parameter (components) !";
2169 std::vector<mcIdType> multiVal;
2170 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2171 MEDCoupling::DataArrayIdType *daIntTyypp=0;
2172 const double *pt=self->getConstPointer();
2173 mcIdType nbc=ToIdType(self->getNumberOfCompo());
2174 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbc,sw,singleVal,multiVal,slic,daIntTyypp);
2181 std::ostringstream oss;
2182 oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2183 PyErr_SetString(PyExc_StopIteration,oss.str().c_str());
2187 return PyFloat_FromDouble(pt[singleVal]);
2191 return PyFloat_FromDouble(pt[nbc+singleVal]);
2194 std::ostringstream oss;
2195 oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2196 throw INTERP_KERNEL::Exception(oss.str().c_str());
2202 PyObject *t=PyTuple_New(multiVal.size());
2203 for(std::size_t j=0;j<multiVal.size();j++)
2205 mcIdType cid=multiVal[j];
2208 std::ostringstream oss;
2209 oss << "Requesting for id #" << cid << " having only " << nbc << " components !";
2210 throw INTERP_KERNEL::Exception(oss.str().c_str());
2212 PyTuple_SetItem(t,j,PyFloat_FromDouble(pt[cid]));
2218 mcIdType sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2219 PyObject *t=PyTuple_New(sz);
2220 for(mcIdType j=0;j<sz;j++)
2221 PyTuple_SetItem(t,j,PyFloat_FromDouble(pt[slic.first+j*slic.second.second]));
2225 throw INTERP_KERNEL::Exception("DataArrayDoubleTuple::__getitem__ : unrecognized type entered !");
2229 DataArrayDoubleTuple *__setitem__(PyObject *obj, PyObject *value)
2231 const char msg[]="DataArrayDoubleTuple::__setitem__ : unrecognized type entered, int, slice, list<int>, tuple<int> !";
2232 const char msg2[]="DataArrayDoubleTuple::__setitem__ : Mismatch of slice values in 2nd parameter (components) !";
2235 std::vector<double> multiValV;
2236 MEDCoupling::DataArrayDoubleTuple *daIntTyyppV=0;
2237 mcIdType nbc=ToIdType(self->getNumberOfCompo());
2238 convertDoubleStarLikePyObjToCpp(value,sw1,singleValV,multiValV,daIntTyyppV);
2240 std::vector<mcIdType> multiVal;
2241 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2242 MEDCoupling::DataArrayIdType *daIntTyypp=0;
2243 double *pt=self->getPointer();
2244 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbc,sw2,singleVal,multiVal,slic,daIntTyypp);
2251 std::ostringstream oss;
2252 oss << "Requesting for setting id # " << singleVal << " having only " << nbc << " components !";
2253 throw INTERP_KERNEL::Exception(oss.str().c_str());
2259 pt[singleVal]=singleValV;
2264 if(multiValV.size()!=1)
2266 std::ostringstream oss;
2267 oss << "Requesting for setting id # " << singleVal << " with a list or tuple with size != 1 ! ";
2268 throw INTERP_KERNEL::Exception(oss.str().c_str());
2270 pt[singleVal]=multiValV[0];
2275 pt[singleVal]=daIntTyyppV->getConstPointer()[0];
2279 throw INTERP_KERNEL::Exception(msg);
2288 for(std::vector<mcIdType>::const_iterator it=multiVal.begin();it!=multiVal.end();it++)
2292 std::ostringstream oss;
2293 oss << "Requesting for setting id # " << *it << " having only " << nbc << " components !";
2294 throw INTERP_KERNEL::Exception(oss.str().c_str());
2302 if(multiVal.size()!=multiValV.size())
2304 std::ostringstream oss;
2305 oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << multiVal.size() << " !";
2306 throw INTERP_KERNEL::Exception(oss.str().c_str());
2308 for(std::size_t i=0;i<multiVal.size();i++)
2310 mcIdType pos=multiVal[i];
2313 std::ostringstream oss;
2314 oss << "Requesting for setting id # " << pos << " having only " << nbc << " components !";
2315 throw INTERP_KERNEL::Exception(oss.str().c_str());
2317 pt[multiVal[i]]=multiValV[i];
2323 const double *ptV=daIntTyyppV->getConstPointer();
2324 if(nbc>(mcIdType)daIntTyyppV->getNumberOfCompo())
2326 std::ostringstream oss;
2327 oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2328 throw INTERP_KERNEL::Exception(oss.str().c_str());
2330 std::copy(ptV,ptV+nbc,pt);
2334 throw INTERP_KERNEL::Exception(msg);
2339 mcIdType sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2344 for(mcIdType j=0;j<sz;j++)
2345 pt[slic.first+j*slic.second.second]=singleValV;
2350 if(sz!=(mcIdType)multiValV.size())
2352 std::ostringstream oss;
2353 oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << sz << " !";
2354 throw INTERP_KERNEL::Exception(oss.str().c_str());
2356 for(mcIdType j=0;j<sz;j++)
2357 pt[slic.first+j*slic.second.second]=multiValV[j];
2362 const double *ptV=daIntTyyppV->getConstPointer();
2363 if(sz>(mcIdType)daIntTyyppV->getNumberOfCompo())
2365 std::ostringstream oss;
2366 oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2367 throw INTERP_KERNEL::Exception(oss.str().c_str());
2369 for(mcIdType j=0;j<sz;j++)
2370 pt[slic.first+j*slic.second.second]=ptV[j];
2374 throw INTERP_KERNEL::Exception(msg);
2378 throw INTERP_KERNEL::Exception(msg);
2384 class DataArrayChar : public DataArray
2387 virtual DataArrayChar *buildEmptySpecializedDAChar() const;
2388 int getHashCode() const;
2390 void deepCopyFrom(const DataArrayChar& other);
2391 void reserve(std::size_t nbOfElems);
2392 void pushBackSilent(char val);
2393 char popBackSilent();
2395 void allocIfNecessary(int nbOfTuple, int nbOfCompo);
2396 bool isEqual(const DataArrayChar& other) const;
2397 bool isEqualWithoutConsideringStr(const DataArrayChar& other) const;
2399 void fillWithZero();
2400 void fillWithValue(char val);
2401 std::string repr() const;
2402 std::string reprZip() const;
2403 DataArrayInt *convertToIntArr() const;
2404 DataArrayChar *renumber(const mcIdType *old2New) const;
2405 DataArrayChar *renumberR(const mcIdType *new2Old) const;
2406 DataArrayChar *renumberAndReduce(const mcIdType *old2NewBg, mcIdType newNbOfTuple) const;
2407 bool isUniform(char val) const;
2408 void sort(bool asc=true);
2409 DataArrayChar *subArray(mcIdType tupleIdBg, mcIdType tupleIdEnd=-1) const;
2410 DataArrayChar *changeNbOfComponents(std::size_t newNbOfComp, char dftValue) const;
2411 void meldWith(const DataArrayChar *other);
2412 void setPartOfValuesAdv(const DataArrayChar *a, const DataArrayIdType *tuplesSelec);
2415 void setIJ(mcIdType tupleId, int compoId, char newVal);
2416 void setIJSilent(mcIdType tupleId, int compoId, char newVal);
2418 DataArrayIdType *findIdsEqual(char val) const;
2419 DataArrayIdType *findIdsNotEqual(char val) const;
2420 int findIdFirstEqualTuple(const std::vector<char>& tupl) const;
2421 bool presenceOfTuple(const std::vector<char>& tupl) const;
2422 char getMaxValue(mcIdType& tupleId) const;
2423 char getMaxValueInArray() const;
2424 char getMinValue(mcIdType& tupleId) const;
2425 char getMinValueInArray() const;
2426 DataArrayIdType *findIdsInRange(char vmin, char vmax) const;
2427 static DataArrayChar *Aggregate(const DataArrayChar *a1, const DataArrayChar *a2);
2428 static DataArrayChar *Meld(const DataArrayChar *a1, const DataArrayChar *a2);
2431 mcIdType __len__() const
2433 if(self->isAllocated())
2435 return self->getNumberOfTuples();
2439 throw INTERP_KERNEL::Exception("DataArrayChar::__len__ : Instance is NOT allocated !");
2443 PyObject *isEqualIfNotWhy(const DataArrayChar& other) const
2446 bool ret0=self->isEqualIfNotWhy(other,ret1);
2447 PyObject *ret=PyTuple_New(2);
2448 PyObject *ret0Py=ret0?Py_True:Py_False;
2450 PyTuple_SetItem(ret,0,ret0Py);
2451 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
2455 DataArrayChar *renumber(PyObject *li)
2458 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
2459 if (!SWIG_IsOK(res1))
2462 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2463 if(size!=self->getNumberOfTuples())
2465 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2467 return self->renumber(tmp);
2471 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2473 throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2474 da2->checkAllocated();
2475 mcIdType size=self->getNumberOfTuples();
2476 if(size!=self->getNumberOfTuples())
2478 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2480 return self->renumber(da2->getConstPointer());
2484 DataArrayChar *renumberR(PyObject *li)
2487 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
2488 if (!SWIG_IsOK(res1))
2491 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2492 if(size!=self->getNumberOfTuples())
2494 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2496 return self->renumberR(tmp);
2500 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2502 throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2503 da2->checkAllocated();
2504 mcIdType size=self->getNumberOfTuples();
2505 if(size!=self->getNumberOfTuples())
2507 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2509 return self->renumberR(da2->getConstPointer());
2513 DataArrayChar *renumberAndReduce(PyObject *li, mcIdType newNbOfTuple)
2516 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
2517 if (!SWIG_IsOK(res1))
2520 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2521 if(size!=self->getNumberOfTuples())
2523 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2525 return self->renumberAndReduce(tmp,newNbOfTuple);
2529 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2531 throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2532 da2->checkAllocated();
2533 mcIdType size=self->getNumberOfTuples();
2534 if(size!=self->getNumberOfTuples())
2536 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2538 return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
2542 static DataArrayChar *Aggregate(PyObject *dachs)
2544 std::vector<const MEDCoupling::DataArrayChar *> tmp;
2545 convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayChar *>(dachs,SWIGTYPE_p_MEDCoupling__DataArrayChar,"DataArrayChar",tmp);
2546 return DataArrayChar::Aggregate(tmp);
2549 static DataArrayChar *Meld(PyObject *dachs)
2551 std::vector<const MEDCoupling::DataArrayChar *> tmp;
2552 convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayChar *>(dachs,SWIGTYPE_p_MEDCoupling__DataArrayChar,"DataArrayChar",tmp);
2553 return DataArrayChar::Meld(tmp);
2558 class DataArrayByteIterator;
2560 class DataArrayByte : public DataArrayChar
2563 static DataArrayByte *New();
2564 DataArrayByteIterator *iterator();
2565 DataArrayByte *performCopyOrIncrRef(bool deepCopy) const;
2566 char byteValue() const;
2571 return DataArrayByte::New();
2574 static DataArrayByte *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
2576 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) !";
2577 if(PyList_Check(elt0) || PyTuple_Check(elt0))
2581 if(PyInt_Check(nbOfTuples))
2583 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
2585 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive set of allocated memory !");
2588 if(PyInt_Check(nbOfComp))
2589 {//DataArrayByte.New([1,3,4,5],2,2)
2590 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
2592 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !");
2593 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2594 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
2595 ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2599 throw INTERP_KERNEL::Exception(msg);
2602 {//DataArrayByte.New([1,3,4],3)
2603 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2605 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
2606 ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2611 throw INTERP_KERNEL::Exception(msg);
2614 {// DataArrayByte.New([1,3,4])
2615 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2616 mcIdType tmpp1=-1,tmpp2=-1;
2617 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
2618 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2622 else if(PyInt_Check(elt0))
2624 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(elt0));
2626 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive set of allocated memory !");
2631 if(PyInt_Check(nbOfTuples))
2632 {//DataArrayByte.New(5,2)
2633 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfTuples));
2635 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !");
2636 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2637 ret->alloc(nbOfTuples1,nbOfCompo);
2641 throw INTERP_KERNEL::Exception(msg);
2644 throw INTERP_KERNEL::Exception(msg);
2647 {//DataArrayByte.New(5)
2648 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2649 ret->alloc(nbOfTuples1,1);
2654 else if(PyArray_Check(elt0) && nbOfTuples==NULL && nbOfComp==NULL)
2655 {//DataArrayDouble.New(numpyArray)
2656 return BuildNewInstance<DataArrayByte,char>(elt0,NPY_INT8,&PyCallBackDataArrayChar_RefType,"INT8");
2660 throw INTERP_KERNEL::Exception(msg);
2663 DataArrayByte(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
2665 return MEDCoupling_DataArrayByte_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
2668 std::string __repr__() const
2670 std::ostringstream oss;
2671 self->reprQuickOverview(oss);
2677 return (int) self->byteValue();
2680 DataArrayByteIterator *__iter__()
2682 return self->iterator();
2685 mcIdType getIJ(mcIdType tupleId, mcIdType compoId) const
2687 return (mcIdType)self->getIJ(tupleId,compoId);
2690 mcIdType getIJSafe(mcIdType tupleId, mcIdType compoId) const
2692 return (mcIdType)self->getIJSafe(tupleId,compoId);
2695 std::string __str__() const
2697 return self->repr();
2700 PyObject *toStrList() const
2702 const char *vals=self->getConstPointer();
2703 std::size_t nbOfComp=self->getNumberOfComponents();
2704 mcIdType nbOfTuples=self->getNumberOfTuples();
2705 return convertCharArrToPyListOfTuple(vals,(int)nbOfComp,nbOfTuples);
2708 bool presenceOfTuple(PyObject *tupl) const
2710 mcIdType sz=-1,sw=-1;
2711 mcIdType ival=-1; std::vector<mcIdType> ivval;
2712 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(tupl,sw,sz,ival,ivval);
2713 std::vector<char> vals(sz);
2714 std::copy(pt,pt+sz,vals.begin());
2715 return self->presenceOfTuple(vals);
2718 bool presenceOfValue(PyObject *vals) const
2720 mcIdType sz=-1,sw=-1;
2721 mcIdType ival=-1; std::vector<mcIdType> ivval;
2722 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(vals,sw,sz,ival,ivval);
2723 std::vector<char> vals2(sz);
2724 std::copy(pt,pt+sz,vals2.begin());
2725 return self->presenceOfValue(vals2);
2728 mcIdType findIdFirstEqual(PyObject *vals) const
2730 mcIdType sz=-1,sw=-1;
2731 mcIdType ival=-1; std::vector<mcIdType> ivval;
2732 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(vals,sw,sz,ival,ivval);
2733 std::vector<char> vals2(sz);
2734 std::copy(pt,pt+sz,vals2.begin());
2735 return self->findIdFirstEqual(vals2);
2738 mcIdType findIdFirstEqualTuple(PyObject *tupl) const
2740 mcIdType sz=-1,sw=-1;
2741 mcIdType ival=-1; std::vector<mcIdType> ivval;
2742 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(tupl,sw,sz,ival,ivval);
2743 std::vector<char> vals(sz);
2744 std::copy(pt,pt+sz,vals.begin());
2745 return self->findIdFirstEqualTuple(vals);
2748 mcIdType findIdSequence(PyObject *strOrListOfInt) const
2750 mcIdType sz=-1,sw=-1;
2751 mcIdType ival=-1; std::vector<mcIdType> ivval;
2752 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(strOrListOfInt,sw,sz,ival,ivval);
2753 std::vector<char> vals(sz);
2754 std::copy(pt,pt+sz,vals.begin());
2755 return self->findIdSequence(vals);
2758 PyObject *getTuple(mcIdType tupleId)
2760 std::size_t sz=self->getNumberOfComponents();
2761 INTERP_KERNEL::AutoPtr<char> tmp=new char[sz];
2762 self->getTuple(tupleId,tmp);
2763 PyObject *ret=PyTuple_New(sz);
2764 for(std::size_t i=0;i<sz;i++) PyTuple_SetItem(ret,i,PyInt_FromLong((mcIdType)tmp[i]));
2768 PyObject *getMaxValue() const
2771 mcIdType r1=(mcIdType)self->getMaxValue(tmp);
2772 PyObject *ret=PyTuple_New(2);
2773 PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
2774 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
2778 PyObject *getMinValue() const
2781 mcIdType r1=(mcIdType)self->getMinValue(tmp);
2782 PyObject *ret=PyTuple_New(2);
2783 PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
2784 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
2788 mcIdType index(PyObject *obj) const
2790 std::size_t nbOfCompo=self->getNumberOfComponents();
2795 if(PyInt_Check(obj))
2797 char val=(char)PyInt_AS_LONG(obj);
2798 return self->findIdFirstEqual(val);
2801 throw INTERP_KERNEL::Exception("DataArrayByte::index : 'this' contains one component and trying to find an element which is not an integer !");
2804 return MEDCoupling_DataArrayByte_findIdFirstEqualTuple(self,obj);
2808 bool __contains__(PyObject *obj) const
2810 std::size_t nbOfCompo=self->getNumberOfComponents();
2817 if(PyInt_Check(obj))
2819 char val=(char)PyInt_AS_LONG(obj);
2820 return self->presenceOfValue(val);
2823 throw INTERP_KERNEL::Exception("DataArrayByte::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
2826 return MEDCoupling_DataArrayByte_presenceOfTuple(self,obj);
2831 PyObject *toNumPyArray() // not const. It is not a bug !
2833 return ToNumPyArray<DataArrayByte,char>(self,NPY_INT8,"DataArrayByte");
2837 DataArrayByte *__setitem__(PyObject *obj, PyObject *value)
2839 self->checkAllocated();
2840 const char msg[]="Unexpected situation in __setitem__ !";
2841 mcIdType nbOfTuples(self->getNumberOfTuples());
2842 int nbOfComponents((int)self->getNumberOfComponents());
2845 std::vector<int> v1;
2846 DataArrayIdType *d1=0;
2847 DataArrayIntTuple *dd1=0;
2848 convertIntStarLikePyObjToCpp(value,sw1,int1,v1,d1,dd1);
2850 std::vector<mcIdType> vt1,vc1;
2851 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > pt1,pc1;
2852 DataArrayIdType *dt1=0,*dc1=0;
2853 convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw2,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1);
2854 MCAuto<DataArrayIdType> tmp;
2855 char i1 = (char)int1;
2863 self->setPartOfValuesSimple1(i1,it1,it1+1,1,0,nbOfComponents,1);
2866 throw INTERP_KERNEL::Exception(msg);
2875 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1);
2878 throw INTERP_KERNEL::Exception(msg);
2887 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1);
2890 throw INTERP_KERNEL::Exception(msg);
2899 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1);
2902 throw INTERP_KERNEL::Exception(msg);
2911 self->setPartOfValuesSimple1(i1,it1,it1+1,1,ic1,ic1+1,1);
2914 throw INTERP_KERNEL::Exception(msg);
2923 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1);
2926 throw INTERP_KERNEL::Exception(msg);
2935 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1);
2938 throw INTERP_KERNEL::Exception(msg);
2947 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1);
2950 throw INTERP_KERNEL::Exception(msg);
2959 self->setPartOfValuesSimple2(i1,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size());
2962 throw INTERP_KERNEL::Exception(msg);
2971 self->setPartOfValuesSimple2(i1,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size());
2974 throw INTERP_KERNEL::Exception(msg);
2983 self->setPartOfValuesSimple4(i1,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size());
2986 throw INTERP_KERNEL::Exception(msg);
2995 self->setPartOfValuesSimple2(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size());
2998 throw INTERP_KERNEL::Exception(msg);
3007 self->setPartOfValuesSimple1(i1,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second);
3010 throw INTERP_KERNEL::Exception(msg);
3019 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second);
3022 throw INTERP_KERNEL::Exception(msg);
3031 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second);
3034 throw INTERP_KERNEL::Exception(msg);
3043 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second);
3046 throw INTERP_KERNEL::Exception(msg);
3051 throw INTERP_KERNEL::Exception(msg);
3058 class DataArrayByteTuple;
3060 class DataArrayByteIterator
3063 DataArrayByteIterator(DataArrayByte *da);
3064 ~DataArrayByteIterator();
3067 class DataArrayByteTuple
3070 std::string repr() const;
3071 DataArrayByte *buildDAByte(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
3074 std::string __str__() const
3076 return self->repr();
3079 char __int__() const
3081 return self->byteValue();
3084 DataArrayByte *buildDAByte()
3086 return self->buildDAByte(1,self->getNumberOfCompo());
3091 class DataArrayAsciiCharIterator;
3093 class DataArrayAsciiChar : public DataArrayChar
3096 static DataArrayAsciiChar *New();
3097 DataArrayAsciiCharIterator *iterator();
3098 DataArrayAsciiChar *performCopyOrIncrRef(bool deepCopy) const;
3099 char asciiCharValue() const;
3102 DataArrayAsciiChar()
3104 return DataArrayAsciiChar::New();
3107 static DataArrayAsciiChar *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
3109 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) !";
3110 if(PyList_Check(elt0) || PyTuple_Check(elt0))
3114 if(PyInt_Check(nbOfTuples))
3116 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
3118 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive set of allocated memory !");
3121 if(PyInt_Check(nbOfComp))
3122 {//DataArrayAsciiChar.New([1,3,4,5],2,2)
3123 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
3125 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !");
3126 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3127 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
3128 ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3132 throw INTERP_KERNEL::Exception(msg);
3135 {//DataArrayAsciiChar.New([1,3,4],3)
3136 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3138 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
3139 ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3143 else if(PyString_Check(nbOfTuples))
3145 if(PyString_Size(nbOfTuples)!=1)
3146 throw INTERP_KERNEL::Exception(msg);
3147 //DataArrayAsciiChar.New(["abc","de","fghi"],"t")
3148 std::vector<std::string> tmp;
3149 if(fillStringVector(elt0,tmp))
3150 return DataArrayAsciiChar::New(tmp,PyString_AsString(nbOfTuples)[0]);
3152 throw INTERP_KERNEL::Exception(msg);
3154 %#if PY_VERSION_HEX >= 0x03000000
3155 else if(PyUnicode_Check(nbOfTuples))
3157 if(PyUnicode_GET_LENGTH(nbOfTuples)!=1)
3158 throw INTERP_KERNEL::Exception(msg);
3159 //DataArrayAsciiChar.New(["abc","de","fghi"],"t")
3160 std::vector<std::string> tmp;
3161 if(fillStringVector(elt0,tmp))
3162 return DataArrayAsciiChar::New(tmp,PyUnicode_AsUTF8(nbOfTuples)[0]);
3164 throw INTERP_KERNEL::Exception(msg);
3168 throw INTERP_KERNEL::Exception(msg);
3172 std::vector<std::string> tmmp;
3173 if(fillStringVector(elt0,tmmp))
3174 //DataArrayAsciiChar.New(["abc","de","fghi"])
3175 return DataArrayAsciiChar::New(tmmp,' ');
3178 // DataArrayAsciiChar.New([1,3,4])
3179 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3180 mcIdType tmpp1=-1,tmpp2=-1;
3181 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
3182 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3187 else if(PyInt_Check(elt0))
3189 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(elt0));
3191 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive set of allocated memory !");
3196 if(PyInt_Check(nbOfTuples))
3197 {//DataArrayAsciiChar.New(5,2)
3198 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfTuples));
3200 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !");
3201 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3202 ret->alloc(nbOfTuples1,nbOfCompo);
3206 throw INTERP_KERNEL::Exception(msg);
3209 throw INTERP_KERNEL::Exception(msg);
3212 {//DataArrayAsciiChar.New(5)
3213 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3214 ret->alloc(nbOfTuples1,1);
3219 throw INTERP_KERNEL::Exception(msg);
3222 DataArrayAsciiChar(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
3224 return MEDCoupling_DataArrayAsciiChar_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
3227 std::string __repr__() const
3229 std::ostringstream oss;
3230 self->reprQuickOverview(oss);
3234 DataArrayAsciiCharIterator *__iter__()
3236 return self->iterator();
3239 std::string getIJ(mcIdType tupleId, mcIdType compoId) const
3241 char tmp[2]; tmp[1]='\0';
3242 tmp[0]=self->getIJ(tupleId,compoId);
3243 return std::string(tmp);
3246 std::string getIJSafe(mcIdType tupleId, mcIdType compoId) const
3248 char tmp[2]; tmp[1]='\0';
3249 tmp[0]=self->getIJSafe(tupleId,compoId);
3250 return std::string(tmp);
3253 std::string __str__() const
3255 return self->repr();
3258 PyObject *toStrList() const
3260 const char *vals=self->getConstPointer();
3261 std::size_t nbOfComp=self->getNumberOfComponents();
3262 mcIdType nbOfTuples=self->getNumberOfTuples();
3263 return convertCharArrToPyListOfTuple(vals,(int)nbOfComp,nbOfTuples);
3266 bool presenceOfTuple(PyObject *tupl) const
3268 if(PyString_Check(tupl))
3270 Py_ssize_t sz=PyString_Size(tupl);
3271 std::vector<char> vals(sz);
3272 std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin());
3273 return self->presenceOfTuple(vals);
3275 %#if PY_VERSION_HEX >= 0x03000000
3276 else if(PyUnicode_Check(tupl))
3278 Py_ssize_t sz=PyUnicode_GET_LENGTH(tupl);
3279 std::vector<char> vals(sz);
3280 std::copy(PyUnicode_AsUTF8(tupl),PyUnicode_AsUTF8(tupl)+sz,vals.begin());
3281 return self->presenceOfTuple(vals);
3285 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfTuple : only strings in input supported !");
3288 bool presenceOfValue(PyObject *vals) const
3290 if(PyString_Check(vals))
3292 Py_ssize_t sz=PyString_Size(vals);
3293 std::vector<char> vals2(sz);
3294 std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin());
3295 return self->presenceOfValue(vals2);
3297 %#if PY_VERSION_HEX >= 0x03000000
3298 if(PyUnicode_Check(vals))
3300 Py_ssize_t sz=PyUnicode_GET_LENGTH(vals);
3301 std::vector<char> vals2(sz);
3302 std::copy(PyUnicode_AsUTF8(vals),PyUnicode_AsUTF8(vals)+sz,vals2.begin());
3303 return self->presenceOfValue(vals2);
3307 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfValue : only strings in input supported !");
3310 mcIdType findIdFirstEqual(PyObject *vals) const
3312 if(PyString_Check(vals))
3314 Py_ssize_t sz=PyString_Size(vals);
3315 std::vector<char> vals2(sz);
3316 std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin());
3317 return self->findIdFirstEqual(vals2);
3319 %#if PY_VERSION_HEX >= 0x03000000
3320 if(PyUnicode_Check(vals))
3322 Py_ssize_t sz=PyUnicode_GET_LENGTH(vals);
3323 std::vector<char> vals2(sz);
3324 std::copy(PyUnicode_AsUTF8(vals),PyUnicode_AsUTF8(vals)+sz,vals2.begin());
3325 return self->findIdFirstEqual(vals2);
3329 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::findIdFirstEqual : only strings in input supported !");
3332 mcIdType findIdFirstEqualTuple(PyObject *tupl) const
3334 if(PyString_Check(tupl))
3336 Py_ssize_t sz=PyString_Size(tupl);
3337 std::vector<char> vals(sz);
3338 std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin());
3339 return self->findIdFirstEqualTuple(vals);
3341 %#if PY_VERSION_HEX >= 0x03000000
3342 if(PyUnicode_Check(tupl))
3344 Py_ssize_t sz=PyUnicode_GET_LENGTH(tupl);
3345 std::vector<char> vals(sz);
3346 std::copy(PyUnicode_AsUTF8(tupl),PyUnicode_AsUTF8(tupl)+sz,vals.begin());
3347 return self->findIdFirstEqualTuple(vals);
3351 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::findIdFirstEqualTuple : only strings in input supported !");
3354 mcIdType findIdSequence(PyObject *strOrListOfInt) const
3356 if(PyString_Check(strOrListOfInt))
3358 Py_ssize_t sz=PyString_Size(strOrListOfInt);
3359 std::vector<char> vals(sz);
3360 std::copy(PyString_AsString(strOrListOfInt),PyString_AsString(strOrListOfInt)+sz,vals.begin());
3361 return self->findIdSequence(vals);
3363 %#if PY_VERSION_HEX >= 0x03000000
3364 else if(PyUnicode_Check(strOrListOfInt))
3366 Py_ssize_t sz=PyUnicode_GET_LENGTH(strOrListOfInt);
3367 std::vector<char> vals(sz);
3368 std::copy(PyUnicode_AsUTF8(strOrListOfInt),PyUnicode_AsUTF8(strOrListOfInt)+sz,vals.begin());
3369 return self->findIdSequence(vals);
3373 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::search : only strings in input supported !");
3376 PyObject *getTuple(mcIdType tupleId) const
3378 std::size_t sz=self->getNumberOfComponents();
3379 INTERP_KERNEL::AutoPtr<char> tmp=new char[sz+1]; tmp[sz]='\0';
3380 self->getTuple(tupleId,tmp);
3381 return PyString_FromString(tmp);
3384 PyObject *getMaxValue() const
3387 char tmp2[2]; tmp2[1]='\0';
3388 tmp2[0]=self->getMaxValue(tmp);
3389 PyObject *ret=PyTuple_New(2);
3390 PyTuple_SetItem(ret,0,PyString_FromString(tmp2));
3391 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
3395 PyObject *getMinValue() const
3398 char tmp2[2]; tmp2[1]='\0';
3399 tmp2[0]=self->getMinValue(tmp);
3400 PyObject *ret=PyTuple_New(2);
3401 PyTuple_SetItem(ret,0,PyString_FromString(tmp2));
3402 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
3406 mcIdType index(PyObject *obj) const
3408 std::size_t nbOfCompo=self->getNumberOfComponents();
3413 if(PyString_Check(obj))
3415 Py_ssize_t sz=PyString_Size(obj);
3416 char *pt=PyString_AsString(obj);
3418 return self->findIdFirstEqual(pt[0]);
3420 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find a string with size different from 1 !");
3422 %#if PY_VERSION_HEX >= 0x03000000
3423 if(PyUnicode_Check(obj))
3426 const char *pt=PyUnicode_AsUTF8AndSize(obj, &sz);
3428 return self->findIdFirstEqual(pt[0]);
3430 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find a string with size different from 1 !");
3434 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find an element which is not an integer !");
3437 return MEDCoupling_DataArrayAsciiChar_findIdFirstEqualTuple(self,obj);
3441 bool __contains__(PyObject *obj) const
3443 std::size_t nbOfCompo=self->getNumberOfComponents();
3450 if(PyString_Check(obj))
3452 Py_ssize_t sz=PyString_Size(obj);
3453 char *pt=PyString_AsString(obj);
3455 return self->presenceOfValue(pt[0]);
3457 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find a string with size different from 1 !");
3459 %#if PY_VERSION_HEX >= 0x03000000
3460 if(PyUnicode_Check(obj))
3463 const char *pt=PyUnicode_AsUTF8AndSize(obj, &sz);
3465 return self->presenceOfValue(pt[0]);
3467 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find a string with size different from 1 !");
3471 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
3474 return MEDCoupling_DataArrayAsciiChar_presenceOfTuple(self,obj);
3478 PyObject *__getitem__(PyObject *obj) const
3480 mcIdType sw,iTypppArr;
3481 std::vector<mcIdType> stdvecTyyppArr;
3482 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > sTyyppArr;
3483 MEDCoupling::DataArrayIdType *daIntTyypp=0;
3484 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,self->getNumberOfTuples(),sw,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp);
3488 return MEDCoupling_DataArrayAsciiChar_getTuple(self,iTypppArr);
3490 return convertDataArrayChar(self->selectByTupleIdSafe(&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size()), SWIG_POINTER_OWN | 0 );
3492 return convertDataArrayChar(self->selectByTupleIdSafeSlice(sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second), SWIG_POINTER_OWN | 0 );
3494 return convertDataArrayChar(self->selectByTupleIdSafe(daIntTyypp->begin(),daIntTyypp->end()), SWIG_POINTER_OWN | 0 );
3496 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__getitem__ : supporting int, list of int, tuple of int, DataArrayIdType and slice in input !");
3500 DataArrayAsciiChar *__setitem__(PyObject *obj, PyObject *value)
3502 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.";
3503 mcIdType sw1,iTypppArr;
3504 std::vector<mcIdType> stdvecTyyppArr;
3505 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > sTyyppArr;
3506 MEDCoupling::DataArrayIdType *daIntTyypp=0;
3507 mcIdType nbOfCompo=ToIdType(self->getNumberOfComponents());
3508 mcIdType nbOfTuples=self->getNumberOfTuples();
3509 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbOfTuples,sw1,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp);
3511 char vc; std::string sc; std::vector<std::string> vsc; DataArrayChar *dacc=0;
3512 convertObjToPossibleCpp6(value,sw2,vc,sc,vsc,dacc);
3521 self->setPartOfValuesSimple3(vc,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1);
3527 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3528 self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3531 //value vector<string>
3534 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3535 self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3538 //value DataArrayChar
3541 self->setPartOfValues3(dacc,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3545 throw INTERP_KERNEL::Exception(msg);
3549 {//obj list-tuple[int]
3555 self->setPartOfValuesSimple3(vc,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1);
3561 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3562 self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3565 //value vector<string>
3568 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3569 self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3572 //value DataArrayChar
3575 self->setPartOfValues3(dacc,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3579 throw INTERP_KERNEL::Exception(msg);
3590 self->setPartOfValuesSimple1(vc,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1);
3596 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3597 self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3600 //value vector<string>
3603 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3604 self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3607 //value DataArrayChar
3610 self->setPartOfValues1(dacc,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3614 throw INTERP_KERNEL::Exception(msg);
3625 self->setPartOfValuesSimple3(vc,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1);
3631 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3632 self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3635 //value vector<string>
3638 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3639 self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3642 //value DataArrayChar
3645 self->setPartOfValues3(dacc,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3649 throw INTERP_KERNEL::Exception(msg);
3654 throw INTERP_KERNEL::Exception(msg);
3660 class DataArrayAsciiCharTuple;
3662 class DataArrayAsciiCharIterator
3665 DataArrayAsciiCharIterator(DataArrayAsciiChar *da);
3666 ~DataArrayAsciiCharIterator();
3671 DataArrayAsciiCharTuple *ret=self->nextt();
3673 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayAsciiCharTuple,SWIG_POINTER_OWN | 0);
3676 PyErr_SetString(PyExc_StopIteration,"No more data.");
3683 class DataArrayAsciiCharTuple
3686 std::size_t getNumberOfCompo() const;
3687 DataArrayAsciiChar *buildDAAsciiChar(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
3690 std::string __str__() const
3692 return self->repr();
3695 DataArrayAsciiChar *buildDAAsciiChar()
3697 return self->buildDAAsciiChar(1,self->getNumberOfCompo());
3703 %include "DataArrayInt.i"
3706 def MEDCouplingStdReduceFunct(cls,params):
3708 ret=object.__new__(cls)
3713 def MEDCouplingDataArrayDoubleReduce(self):
3714 if not MEDCouplingHasNumPyBindings():
3715 raise InterpKernelException("PyWrap of DataArrayDouble.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3716 return MEDCouplingStdReduceFunct,(DataArrayDouble,((self.toNumPyArray(),),(self.__getstate__()),))
3718 def MEDCouplingDataArrayInt32Reduce(self):
3719 if not MEDCouplingHasNumPyBindings():
3720 raise InterpKernelException("PyWrap of DataArrayIdType.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3721 return MEDCouplingStdReduceFunct,(DataArrayInt32,((self.toNumPyArray(),),(self.__getstate__()),))
3723 def MEDCouplingDataArrayInt64Reduce(self):
3724 if not MEDCouplingHasNumPyBindings():
3725 raise InterpKernelException("PyWrap of DataArrayIdType.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3726 return MEDCouplingStdReduceFunct,(DataArrayInt64,((self.toNumPyArray(),),(self.__getstate__()),))
3728 def MEDCouplingDataArrayByteReduce(self):
3729 if not MEDCouplingHasNumPyBindings():
3730 raise InterpKernelException("PyWrap of DataArrayByte.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3731 return MEDCouplingStdReduceFunct,(DataArrayByte,((self.toNumPyArray(),),(self.__getstate__()),))
3733 def MEDCouplingDataArrayFloatReduce(self):
3734 if not MEDCouplingHasNumPyBindings():
3735 raise InterpKernelException("PyWrap of DataArrayFloat.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3736 return MEDCouplingStdReduceFunct,(DataArrayFloat,((self.toNumPyArray(),),(self.__getstate__()),))
3738 if MEDCouplingUse64BitIDs():
3739 DataArrayInt=DataArrayInt64
3741 DataArrayInt=DataArrayInt32