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::buildNewEmptyInstance;
77 %newobject MEDCoupling::DataArray::selectByTupleRanges;
78 %newobject MEDCoupling::DataArray::selectByTupleId;
79 %newobject MEDCoupling::DataArray::selectByTupleIdSafe;
80 %newobject MEDCoupling::DataArray::selectByTupleIdSafeSlice;
81 %newobject MEDCoupling::DataArray::Aggregate;
82 %newobject MEDCoupling::DataArrayFloat::New;
83 %newobject MEDCoupling::DataArrayFloat::iterator;
84 %newobject MEDCoupling::DataArrayFloat::__iter__;
85 %newobject MEDCoupling::DataArrayFloat::Meld;
86 %newobject MEDCoupling::DataArrayFloat::__rmul__;
87 %newobject MEDCoupling::DataArrayInt32::New;
88 %newobject MEDCoupling::DataArrayInt32::__iter__;
89 %newobject MEDCoupling::DataArrayInt32::performCopyOrIncrRef;
90 %newobject MEDCoupling::DataArrayInt32::subArray;
91 %newobject MEDCoupling::DataArrayInt32::changeNbOfComponents;
92 %newobject MEDCoupling::DataArrayInt32::accumulatePerChunck;
93 %newobject MEDCoupling::DataArrayInt32::checkAndPreparePermutation;
94 %newobject MEDCoupling::DataArrayInt32::transformWithIndArrR;
95 %newobject MEDCoupling::DataArrayInt32::renumber;
96 %newobject MEDCoupling::DataArrayInt32::renumberR;
97 %newobject MEDCoupling::DataArrayInt32::renumberAndReduce;
98 %newobject MEDCoupling::DataArrayInt32::invertArrayO2N2N2O;
99 %newobject MEDCoupling::DataArrayInt32::invertArrayN2O2O2N;
100 %newobject MEDCoupling::DataArrayInt32::invertArrayO2N2N2OBis;
101 %newobject MEDCoupling::DataArrayInt32::findIdsEqual;
102 %newobject MEDCoupling::DataArrayInt32::findIdsNotEqual;
103 %newobject MEDCoupling::DataArrayInt32::findIdsEqualList;
104 %newobject MEDCoupling::DataArrayInt32::findIdsNotEqualList;
105 %newobject MEDCoupling::DataArrayInt32::findIdsEqualTuple;
106 %newobject MEDCoupling::DataArrayInt32::findIdForEach;
107 %newobject MEDCoupling::DataArrayInt32::sumPerTuple;
108 %newobject MEDCoupling::DataArrayInt32::negate;
109 %newobject MEDCoupling::DataArrayInt32::computeAbs;
110 %newobject MEDCoupling::DataArrayInt32::findIdsInRange;
111 %newobject MEDCoupling::DataArrayInt32::findIdsNotInRange;
112 %newobject MEDCoupling::DataArrayInt32::findIdsStrictlyNegative;
113 %newobject MEDCoupling::DataArrayInt32::Aggregate;
114 %newobject MEDCoupling::DataArrayInt32::AggregateIndexes;
115 %newobject MEDCoupling::DataArrayInt32::Meld;
116 %newobject MEDCoupling::DataArrayInt32::Add;
117 %newobject MEDCoupling::DataArrayInt32::Substract;
118 %newobject MEDCoupling::DataArrayInt32::Multiply;
119 %newobject MEDCoupling::DataArrayInt32::Divide;
120 %newobject MEDCoupling::DataArrayInt32::Pow;
121 %newobject MEDCoupling::DataArrayInt32::BuildUnion;
122 %newobject MEDCoupling::DataArrayInt32::BuildIntersection;
123 %newobject MEDCoupling::DataArrayInt32::Range;
124 %newobject MEDCoupling::DataArrayInt32::indicesOfSubPart;
125 %newobject MEDCoupling::DataArrayInt32::fromNoInterlace;
126 %newobject MEDCoupling::DataArrayInt32::toNoInterlace;
127 %newobject MEDCoupling::DataArrayInt32::buildComplement;
128 %newobject MEDCoupling::DataArrayInt32::buildUnion;
129 %newobject MEDCoupling::DataArrayInt32::buildSubstraction;
130 %newobject MEDCoupling::DataArrayInt32::buildSubstractionOptimized;
131 %newobject MEDCoupling::DataArrayInt32::buildIntersection;
132 %newobject MEDCoupling::DataArrayInt32::buildUnique;
133 %newobject MEDCoupling::DataArrayInt32::buildUniqueNotSorted;
134 %newobject MEDCoupling::DataArrayInt32::deltaShiftIndex;
135 %newobject MEDCoupling::DataArrayInt32::buildExplicitArrByRanges;
136 %newobject MEDCoupling::DataArrayInt32::buildExplicitArrOfSliceOnScaledArr;
137 %newobject MEDCoupling::DataArrayInt32::findRangeIdForEachTuple;
138 %newobject MEDCoupling::DataArrayInt32::findIdInRangeForEachTuple;
139 %newobject MEDCoupling::DataArrayInt32::duplicateEachTupleNTimes;
140 %newobject MEDCoupling::DataArrayInt32::buildPermutationArr;
141 %newobject MEDCoupling::DataArrayInt32::buildPermArrPerLevel;
142 %newobject MEDCoupling::DataArrayInt32::getDifferentValues;
143 %newobject MEDCoupling::DataArrayInt32::FindPermutationFromFirstToSecond;
144 %newobject MEDCoupling::DataArrayInt32::CheckAndPreparePermutation;
145 %newobject MEDCoupling::DataArrayInt32::__neg__;
146 %newobject MEDCoupling::DataArrayInt32::__add__;
147 %newobject MEDCoupling::DataArrayInt32::__radd__;
148 %newobject MEDCoupling::DataArrayInt32::__sub__;
149 %newobject MEDCoupling::DataArrayInt32::__rsub__;
150 %newobject MEDCoupling::DataArrayInt32::__mul__;
151 %newobject MEDCoupling::DataArrayInt32::__rmul__;
152 %newobject MEDCoupling::DataArrayInt32::__div__;
153 %newobject MEDCoupling::DataArrayInt32::__rdiv__;
154 %newobject MEDCoupling::DataArrayInt32::__mod__;
155 %newobject MEDCoupling::DataArrayInt32::__rmod__;
156 %newobject MEDCoupling::DataArrayInt32::__pow__;
157 %newobject MEDCoupling::DataArrayInt32::__rpow__;
158 %newobject MEDCoupling::DataArrayInt32Tuple::buildDAInt;
159 %newobject MEDCoupling::DataArrayInt64::New;
160 %newobject MEDCoupling::DataArrayInt64::__iter__;
161 %newobject MEDCoupling::DataArrayInt64::performCopyOrIncrRef;
162 %newobject MEDCoupling::DataArrayInt64::subArray;
163 %newobject MEDCoupling::DataArrayInt64::changeNbOfComponents;
164 %newobject MEDCoupling::DataArrayInt64::accumulatePerChunck;
165 %newobject MEDCoupling::DataArrayInt64::checkAndPreparePermutation;
166 %newobject MEDCoupling::DataArrayInt64::transformWithIndArrR;
167 %newobject MEDCoupling::DataArrayInt64::renumber;
168 %newobject MEDCoupling::DataArrayInt64::renumberR;
169 %newobject MEDCoupling::DataArrayInt64::renumberAndReduce;
170 %newobject MEDCoupling::DataArrayInt64::invertArrayO2N2N2O;
171 %newobject MEDCoupling::DataArrayInt64::invertArrayN2O2O2N;
172 %newobject MEDCoupling::DataArrayInt64::invertArrayO2N2N2OBis;
173 %newobject MEDCoupling::DataArrayInt64::findIdsEqual;
174 %newobject MEDCoupling::DataArrayInt64::findIdsNotEqual;
175 %newobject MEDCoupling::DataArrayInt64::findIdsEqualList;
176 %newobject MEDCoupling::DataArrayInt64::findIdsNotEqualList;
177 %newobject MEDCoupling::DataArrayInt64::findIdsEqualTuple;
178 %newobject MEDCoupling::DataArrayInt64::findIdForEach;
179 %newobject MEDCoupling::DataArrayInt64::sumPerTuple;
180 %newobject MEDCoupling::DataArrayInt64::negate;
181 %newobject MEDCoupling::DataArrayInt64::computeAbs;
182 %newobject MEDCoupling::DataArrayInt64::findIdsInRange;
183 %newobject MEDCoupling::DataArrayInt64::findIdsNotInRange;
184 %newobject MEDCoupling::DataArrayInt64::findIdsStrictlyNegative;
185 %newobject MEDCoupling::DataArrayInt64::Aggregate;
186 %newobject MEDCoupling::DataArrayInt64::AggregateIndexes;
187 %newobject MEDCoupling::DataArrayInt64::Meld;
188 %newobject MEDCoupling::DataArrayInt64::Add;
189 %newobject MEDCoupling::DataArrayInt64::Substract;
190 %newobject MEDCoupling::DataArrayInt64::Multiply;
191 %newobject MEDCoupling::DataArrayInt64::Divide;
192 %newobject MEDCoupling::DataArrayInt64::Pow;
193 %newobject MEDCoupling::DataArrayInt64::BuildUnion;
194 %newobject MEDCoupling::DataArrayInt64::BuildIntersection;
195 %newobject MEDCoupling::DataArrayInt64::Range;
196 %newobject MEDCoupling::DataArrayInt64::indicesOfSubPart;
197 %newobject MEDCoupling::DataArrayInt64::fromNoInterlace;
198 %newobject MEDCoupling::DataArrayInt64::toNoInterlace;
199 %newobject MEDCoupling::DataArrayInt64::buildComplement;
200 %newobject MEDCoupling::DataArrayInt64::buildUnion;
201 %newobject MEDCoupling::DataArrayInt64::buildSubstraction;
202 %newobject MEDCoupling::DataArrayInt64::buildSubstractionOptimized;
203 %newobject MEDCoupling::DataArrayInt64::buildIntersection;
204 %newobject MEDCoupling::DataArrayInt64::buildUnique;
205 %newobject MEDCoupling::DataArrayInt64::buildUniqueNotSorted;
206 %newobject MEDCoupling::DataArrayInt64::deltaShiftIndex;
207 %newobject MEDCoupling::DataArrayInt64::buildExplicitArrByRanges;
208 %newobject MEDCoupling::DataArrayInt64::buildExplicitArrOfSliceOnScaledArr;
209 %newobject MEDCoupling::DataArrayInt64::findRangeIdForEachTuple;
210 %newobject MEDCoupling::DataArrayInt64::findIdInRangeForEachTuple;
211 %newobject MEDCoupling::DataArrayInt64::duplicateEachTupleNTimes;
212 %newobject MEDCoupling::DataArrayInt64::buildPermutationArr;
213 %newobject MEDCoupling::DataArrayInt64::buildPermArrPerLevel;
214 %newobject MEDCoupling::DataArrayInt64::getDifferentValues;
215 %newobject MEDCoupling::DataArrayInt64::FindPermutationFromFirstToSecond;
216 %newobject MEDCoupling::DataArrayInt64::CheckAndPreparePermutation;
217 %newobject MEDCoupling::DataArrayInt64::__neg__;
218 %newobject MEDCoupling::DataArrayInt64::__add__;
219 %newobject MEDCoupling::DataArrayInt64::__radd__;
220 %newobject MEDCoupling::DataArrayInt64::__sub__;
221 %newobject MEDCoupling::DataArrayInt64::__rsub__;
222 %newobject MEDCoupling::DataArrayInt64::__mul__;
223 %newobject MEDCoupling::DataArrayInt64::__rmul__;
224 %newobject MEDCoupling::DataArrayInt64::__div__;
225 %newobject MEDCoupling::DataArrayInt64::__rdiv__;
226 %newobject MEDCoupling::DataArrayInt64::__mod__;
227 %newobject MEDCoupling::DataArrayInt64::__rmod__;
228 %newobject MEDCoupling::DataArrayInt64::__pow__;
229 %newobject MEDCoupling::DataArrayInt64::__rpow__;
230 %newobject MEDCoupling::DataArrayInt64Tuple::buildDAInt;
231 %newobject MEDCoupling::DataArrayChar::convertToIntArr;
232 %newobject MEDCoupling::DataArrayChar::renumber;
233 %newobject MEDCoupling::DataArrayChar::renumberR;
234 %newobject MEDCoupling::DataArrayChar::renumberAndReduce;
235 %newobject MEDCoupling::DataArrayChar::changeNbOfComponents;
236 %newobject MEDCoupling::DataArrayChar::findIdsEqual;
237 %newobject MEDCoupling::DataArrayChar::findIdsNotEqual;
238 %newobject MEDCoupling::DataArrayChar::Aggregate;
239 %newobject MEDCoupling::DataArrayChar::Meld;
240 %newobject MEDCoupling::DataArrayByte::New;
241 %newobject MEDCoupling::DataArrayByte::__iter__;
242 %newobject MEDCoupling::DataArrayByte::performCopyOrIncrRef;
243 %newobject MEDCoupling::DataArrayByteTuple::buildDAByte;
244 %newobject MEDCoupling::DataArrayChar::subArray;
245 %newobject MEDCoupling::DataArrayAsciiChar::New;
246 %newobject MEDCoupling::DataArrayAsciiChar::__iter__;
247 %newobject MEDCoupling::DataArrayAsciiChar::performCopyOrIncrRef;
248 %newobject MEDCoupling::DataArrayAsciiCharTuple::buildDAAsciiChar;
249 %newobject MEDCoupling::DataArrayDouble::New;
250 %newobject MEDCoupling::DataArrayDouble::__iter__;
251 %newobject MEDCoupling::DataArrayDouble::performCopyOrIncrRef;
252 %newobject MEDCoupling::DataArrayDouble::Aggregate;
253 %newobject MEDCoupling::DataArrayDouble::Meld;
254 %newobject MEDCoupling::DataArrayDouble::Dot;
255 %newobject MEDCoupling::DataArrayDouble::CrossProduct;
256 %newobject MEDCoupling::DataArrayDouble::Add;
257 %newobject MEDCoupling::DataArrayDouble::Substract;
258 %newobject MEDCoupling::DataArrayDouble::Multiply;
259 %newobject MEDCoupling::DataArrayDouble::Divide;
260 %newobject MEDCoupling::DataArrayDouble::Pow;
261 %newobject MEDCoupling::DataArrayDouble::symmetry3DPlane;
262 %newobject MEDCoupling::DataArrayDouble::subArray;
263 %newobject MEDCoupling::DataArrayDouble::changeNbOfComponents;
264 %newobject MEDCoupling::DataArrayDouble::accumulatePerChunck;
265 %newobject MEDCoupling::DataArrayDouble::findIdsInRange;
266 %newobject MEDCoupling::DataArrayDouble::findIdsNotInRange;
267 %newobject MEDCoupling::DataArrayDouble::findIdsStrictlyNegative;
268 %newobject MEDCoupling::DataArrayDouble::negate;
269 %newobject MEDCoupling::DataArrayDouble::computeAbs;
270 %newobject MEDCoupling::DataArrayDouble::applyFunc;
271 %newobject MEDCoupling::DataArrayDouble::applyFuncCompo;
272 %newobject MEDCoupling::DataArrayDouble::applyFuncNamedCompo;
273 %newobject MEDCoupling::DataArrayDouble::doublyContractedProduct;
274 %newobject MEDCoupling::DataArrayDouble::determinant;
275 %newobject MEDCoupling::DataArrayDouble::eigenValues;
276 %newobject MEDCoupling::DataArrayDouble::eigenVectors;
277 %newobject MEDCoupling::DataArrayDouble::inverse;
278 %newobject MEDCoupling::DataArrayDouble::trace;
279 %newobject MEDCoupling::DataArrayDouble::deviator;
280 %newobject MEDCoupling::DataArrayDouble::magnitude;
281 %newobject MEDCoupling::DataArrayDouble::maxPerTuple;
282 %newobject MEDCoupling::DataArrayDouble::sumPerTuple;
283 %newobject MEDCoupling::DataArrayDouble::computeBBoxPerTuple;
284 %newobject MEDCoupling::DataArrayDouble::buildEuclidianDistanceDenseMatrix;
285 %newobject MEDCoupling::DataArrayDouble::buildEuclidianDistanceDenseMatrixWith;
286 %newobject MEDCoupling::DataArrayDouble::renumber;
287 %newobject MEDCoupling::DataArrayDouble::renumberR;
288 %newobject MEDCoupling::DataArrayDouble::renumberAndReduce;
289 %newobject MEDCoupling::DataArrayDouble::fromNoInterlace;
290 %newobject MEDCoupling::DataArrayDouble::toNoInterlace;
291 %newobject MEDCoupling::DataArrayDouble::fromPolarToCart;
292 %newobject MEDCoupling::DataArrayDouble::fromCylToCart;
293 %newobject MEDCoupling::DataArrayDouble::fromSpherToCart;
294 %newobject MEDCoupling::DataArrayDouble::fromCartToPolar;
295 %newobject MEDCoupling::DataArrayDouble::fromCartToCyl;
296 %newobject MEDCoupling::DataArrayDouble::fromCartToSpher;
297 %newobject MEDCoupling::DataArrayDouble::fromCartToCylGiven;
298 %newobject MEDCoupling::DataArrayDouble::cartesianize;
299 %newobject MEDCoupling::DataArrayDouble::getDifferentValues;
300 %newobject MEDCoupling::DataArrayDouble::findClosestTupleId;
301 %newobject MEDCoupling::DataArrayDouble::computeNbOfInteractionsWith;
302 %newobject MEDCoupling::DataArrayDouble::duplicateEachTupleNTimes;
303 %newobject MEDCoupling::DataArrayDouble::__neg__;
304 %newobject MEDCoupling::DataArrayDouble::__radd__;
305 %newobject MEDCoupling::DataArrayDouble::__rsub__;
306 %newobject MEDCoupling::DataArrayDouble::__rmul__;
307 %newobject MEDCoupling::DataArrayDouble::__rdiv__;
308 %newobject MEDCoupling::DataArrayDouble::__pow__;
309 %newobject MEDCoupling::DataArrayDouble::__rpow__;
310 %newobject MEDCoupling::DataArrayDoubleTuple::buildDADouble;
312 %newobject MEDCoupling::PartDefinition::New;
313 %newobject MEDCoupling::PartDefinition::toDAI;
314 %newobject MEDCoupling::PartDefinition::__add__;
315 %newobject MEDCoupling::PartDefinition::composeWith;
316 %newobject MEDCoupling::PartDefinition::tryToSimplify;
317 %newobject MEDCoupling::DataArrayPartDefinition::New;
318 %newobject MEDCoupling::SlicePartDefinition::New;
321 %feature("unref") DataArray "$this->decrRef();"
322 %feature("unref") DataArrayDouble "$this->decrRef();"
323 %feature("unref") DataArrayInt32 "$this->decrRef();"
324 %feature("unref") DataArrayInt64 "$this->decrRef();"
325 %feature("unref") DataArrayChar "$this->decrRef();"
326 %feature("unref") DataArrayAsciiChar "$this->decrRef();"
327 %feature("unref") DataArrayByte "$this->decrRef();"
329 %feature("unref") MapII "$this->decrRef();"
330 %feature("unref") PartDefinition "$this->decrRef();"
331 %feature("unref") DataArrayPartDefinition "$this->decrRef();"
332 %feature("unref") SlicePartDefinition "$this->decrRef();"
334 namespace MEDCoupling
341 } MEDCouplingAxisType;
343 class DataArrayInt32;
344 class DataArrayInt64;
346 #ifndef MEDCOUPLING_USE_64BIT_IDS
347 typedef DataArrayInt32 DataArrayIdType;
348 #define DataArrayIdType DataArrayInt32
350 typedef DataArrayInt64 DataArrayIdType;
351 #define DataArrayIdType DataArrayInt64
354 class MapII : public RefCountObject, public TimeLabel
357 static MCAuto< MapII > New();
360 class PartDefinition : public RefCountObject, public TimeLabel
363 static PartDefinition *New(int start, int stop, int step);
364 static PartDefinition *New(DataArrayIdType *listOfIds);
365 virtual DataArrayIdType *toDAI() const;
366 virtual int getNumberOfElems() const;
367 virtual std::string getRepr() const;
368 virtual PartDefinition *composeWith(const PartDefinition *other) const;
369 virtual void checkConsistencyLight() const;
370 virtual PartDefinition *tryToSimplify() const;
373 virtual PartDefinition *__add__(const PartDefinition& other) const
375 return (*self)+other;
378 virtual PyObject *isEqual(const PartDefinition *other) const
381 bool ret0(self->isEqual(other,ret1));
382 PyObject *ret=PyTuple_New(2);
383 PyObject *ret0Py=ret0?Py_True:Py_False;
385 PyTuple_SetItem(ret,0,ret0Py);
386 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
390 virtual PyObject *deepCopy() const
392 return convertPartDefinition(self->deepCopy(),SWIG_POINTER_OWN | 0);
396 virtual ~PartDefinition();
399 class DataArrayPartDefinition : public PartDefinition
402 static DataArrayPartDefinition *New(DataArrayIdType *listOfIds);
405 DataArrayPartDefinition(DataArrayIdType *listOfIds)
407 return DataArrayPartDefinition::New(listOfIds);
410 std::string __str__() const
412 return self->getRepr();
415 std::string __repr__() const
417 std::ostringstream oss; oss << "DataArrayPartDefinition C++ instance at " << self << "." << std::endl;
418 oss << self->getRepr();
423 virtual ~DataArrayPartDefinition();
426 class SlicePartDefinition : public PartDefinition
429 static SlicePartDefinition *New(int start, int stop, int step);
430 int getEffectiveStop() const;
433 SlicePartDefinition(mcIdType start, mcIdType stop, mcIdType step)
435 return SlicePartDefinition::New(start,stop,step);
438 PyObject *getSlice() const
441 self->getSlice(a,b,c);
442 return PySlice_New(PyInt_FromLong(a),PyInt_FromLong(b),PyInt_FromLong(c));
445 std::string __str__() const
447 return self->getRepr();
450 std::string __repr__() const
452 std::ostringstream oss; oss << "SlicePartDefinition C++ instance at " << self << "." << std::endl;
453 oss << self->getRepr();
458 virtual ~SlicePartDefinition();
461 class DataArray : public RefCountObject, public TimeLabel
464 void setName(const std::string& name);
465 void copyStringInfoFrom(const DataArray& other);
466 void copyPartOfStringInfoFrom(const DataArray& other, const std::vector<std::size_t>& compoIds);
467 void copyPartOfStringInfoFrom2(const std::vector<std::size_t>& compoIds, const DataArray& other);
468 bool areInfoEqualsIfNotWhy(const DataArray& other, std::string& reason) const;
469 bool areInfoEquals(const DataArray& other) const;
470 std::string cppRepr(const std::string& varName) const;
471 std::string getName() const;
472 void setInfoOnComponents(const std::vector<std::string>& info);
473 void setInfoAndChangeNbOfCompo(const std::vector<std::string>& info);
474 std::vector<std::string> getVarsOnComponent() const;
475 std::vector<std::string> getUnitsOnComponent() const;
476 std::string getInfoOnComponent(int i) const;
477 std::string getVarOnComponent(int i) const;
478 std::string getUnitOnComponent(int i) const;
479 void setInfoOnComponent(int i, const std::string& info);
480 int getNumberOfComponents() const;
481 virtual void alloc(int nbOfTuple, int nbOfCompo=1);
482 virtual void reAlloc(int nbOfTuples);
483 virtual bool isAllocated() const;
484 virtual void checkAllocated() const;
485 virtual void desallocate();
486 virtual int getNumberOfTuples() const;
487 virtual std::size_t getNbOfElems() const;
488 virtual std::size_t getNbOfElemAllocated() const;
489 virtual DataArray *deepCopy() const;
490 virtual DataArray *buildNewEmptyInstance() const;
491 virtual DataArray *selectByTupleIdSafeSlice(int bg, int end2, int step) const;
492 virtual void rearrange(int newNbOfCompo);
493 virtual void circularPermutation(int nbOfShift=1);
494 virtual void circularPermutationPerTuple(int nbOfShift=1);
495 virtual void reversePerTuple();
496 void checkNbOfTuples(int nbOfTuples, const std::string& msg) const;
497 void checkNbOfComps(int nbOfCompo, const std::string& msg) const;
498 void checkNbOfTuplesAndComp(const DataArray& other, const std::string& msg) const;
499 void checkNbOfTuplesAndComp(int nbOfTuples, int nbOfCompo, const std::string& msg) const;
500 void checkNbOfElems(mcIdType nbOfElems, const std::string& msg) const;
501 static int GetNumberOfItemGivenBES(int begin, int end, int step, const std::string& msg);
502 static int GetNumberOfItemGivenBESRelative(int begin, int end, int step, const std::string& msg);
503 static int GetPosOfItemGivenBESRelativeNoThrow(int value, int begin, int end, int step);
504 static std::string GetVarNameFromInfo(const std::string& info);
505 static std::string GetUnitFromInfo(const std::string& info);
506 static std::string BuildInfoFromVarAndUnit(const std::string& var, const std::string& unit);
507 static std::string GetAxisTypeRepr(MEDCouplingAxisType at);
508 void updateTime() const;
511 PyObject *getInfoOnComponents() const
513 const std::vector<std::string>& comps=self->getInfoOnComponents();
514 PyObject *ret=PyList_New((mcIdType)comps.size());
515 for(std::size_t i=0;i<comps.size();i++)
516 PyList_SetItem(ret,i,PyString_FromString(comps[i].c_str()));
520 void copyPartOfStringInfoFrom(const DataArray& other, PyObject *li)
522 std::vector<std::size_t> tmp;
523 convertPyToNewIntArr3(li,tmp);
524 self->copyPartOfStringInfoFrom(other,tmp);
527 void copyPartOfStringInfoFrom2(PyObject *li, const DataArray& other)
529 std::vector<std::size_t> tmp;
530 convertPyToNewIntArr3(li,tmp);
531 self->copyPartOfStringInfoFrom2(tmp,other);
534 virtual void renumberInPlace(PyObject *li)
537 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
538 if (!SWIG_IsOK(res1))
541 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
542 if(size!=self->getNumberOfTuples())
544 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
546 self->renumberInPlace(tmp);
550 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
552 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
553 da2->checkAllocated();
554 mcIdType size=self->getNumberOfTuples();
555 if(size!=self->getNumberOfTuples())
557 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
559 self->renumberInPlace(da2->getConstPointer());
563 virtual void renumberInPlaceR(PyObject *li)
566 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
567 if (!SWIG_IsOK(res1))
570 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
571 if(size!=self->getNumberOfTuples())
573 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
575 self->renumberInPlaceR(tmp);
579 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
581 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
582 da2->checkAllocated();
583 mcIdType size=self->getNumberOfTuples();
584 if(size!=self->getNumberOfTuples())
586 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
588 self->renumberInPlaceR(da2->getConstPointer());
592 //tuplesSelec in PyObject * because DataArrayInt is not already existing !
593 virtual void setContigPartOfSelectedValues(mcIdType tupleIdStart, PyObject *aBase, PyObject *tuplesSelec)
595 static const char msg[]="DataArray::setContigPartOfSelectedValuesSlice : 4th parameter \"tuplesSelec\" should be of type DataArrayInt";
596 DataArray *a=CheckAndRetrieveDataArrayInstance(aBase,"DataArray::setContigPartOfSelectedValuesSlice : 3rd parameter \"aBase\" should be of type DataArray");
597 DataArray *tuplesSelecPtr=CheckAndRetrieveDataArrayInstance(tuplesSelec,msg);
598 DataArrayIdType *tuplesSelecPtr2=0;
601 tuplesSelecPtr2=dynamic_cast<DataArrayIdType *>(tuplesSelecPtr);
603 throw INTERP_KERNEL::Exception(msg);
605 self->setContigPartOfSelectedValues(tupleIdStart,a,tuplesSelecPtr2);
608 virtual void setContigPartOfSelectedValuesSlice(mcIdType tupleIdStart, PyObject *aBase, mcIdType bg, mcIdType end2, mcIdType step)
610 DataArray *a=CheckAndRetrieveDataArrayInstance(aBase,"DataArray::setContigPartOfSelectedValuesSlice : 2nd parameter \"aBase\" should be of type DataArray");
611 self->setContigPartOfSelectedValuesSlice(tupleIdStart,a,bg,end2,step);
614 virtual DataArray *selectByTupleRanges(PyObject *li) const
616 std::vector<std::pair<mcIdType,mcIdType> > ranges;
617 convertPyToVectorPairInt(li,ranges);
618 return self->selectByTupleRanges(ranges);
621 virtual DataArray *selectByTupleId(PyObject *li) const
624 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
625 if (!SWIG_IsOK(res1))
628 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
629 return self->selectByTupleId(tmp,tmp+size);
633 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
635 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
636 da2->checkAllocated();
637 return self->selectByTupleId(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
641 virtual DataArray *selectByTupleIdSafe(PyObject *li) const
644 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
645 if (!SWIG_IsOK(res1))
648 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
649 return self->selectByTupleIdSafe(tmp,tmp+size);
653 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
655 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
656 da2->checkAllocated();
657 return self->selectByTupleIdSafe(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
661 virtual PyObject *keepSelectedComponents(PyObject *li) const
663 std::vector<std::size_t> tmp;
664 convertPyToNewIntArr3(li,tmp);
665 DataArray *ret=self->keepSelectedComponents(tmp);
666 return convertDataArray(ret,SWIG_POINTER_OWN | 0 );
669 static PyObject *GetSlice(PyObject *slic, mcIdType sliceId, mcIdType nbOfSlices)
671 if(!PySlice_Check(slic))
672 throw INTERP_KERNEL::Exception("DataArray::GetSlice (wrap) : expecting a pyslice as second (first) parameter !");
673 Py_ssize_t strt=2,stp=2,step=2;
674 GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetSlice (wrap) : the input slice is invalid !");
676 DataArray::GetSlice(ToIdType(strt),ToIdType(stp),ToIdType(step),sliceId,nbOfSlices,a,b);
677 AutoPyPtr ap(PyInt_FromLong(a)),bp(PyInt_FromLong(b)),stepp(PyInt_FromLong(step));
678 return PySlice_New(ap,bp,stepp);
681 PyObject *getSlice(PyObject *slic, mcIdType sliceId, mcIdType nbOfSlices) const
683 if(!PySlice_Check(slic))
684 throw INTERP_KERNEL::Exception("DataArray::getSlice (wrap) : expecting a pyslice as second (first) parameter !");
685 Py_ssize_t strt=2,stp=2,step=2;
686 GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getSlice (wrap) : the input slice is invalid !");
688 DataArray::GetSlice(ToIdType(strt),ToIdType(stp),ToIdType(step),sliceId,nbOfSlices,a,b);
689 AutoPyPtr ap(PyInt_FromLong(a)),bp(PyInt_FromLong(b)),stepp(PyInt_FromLong(step));
690 return PySlice_New(ap,bp,stepp);
693 static mcIdType GetNumberOfItemGivenBES(PyObject *slic)
695 if(!PySlice_Check(slic))
696 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBES (wrap) : expecting a pyslice as second (first) parameter !");
697 Py_ssize_t strt=2,stp=2,step=2;
698 GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetNumberOfItemGivenBES (wrap) : the input slice is invalid !");
699 return DataArray::GetNumberOfItemGivenBES(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
702 static mcIdType GetNumberOfItemGivenBESRelative(PyObject *slic)
704 if(!PySlice_Check(slic))
705 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBESRelative (wrap) : expecting a pyslice as second (first) parameter !");
706 Py_ssize_t strt=2,stp=2,step=2;
707 GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !");
708 return DataArray::GetNumberOfItemGivenBESRelative(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
711 static DataArray *Aggregate(PyObject *arrs)
713 std::vector<const DataArray *> tmp;
714 convertFromPyObjVectorOfObj<const MEDCoupling::DataArray *>(arrs,SWIGTYPE_p_MEDCoupling__DataArray,"DataArray",tmp);
715 return DataArray::Aggregate(tmp);
718 mcIdType getNumberOfItemGivenBES(PyObject *slic) const
720 if(!PySlice_Check(slic))
721 throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBES (wrap) : expecting a pyslice as second (first) parameter !");
722 Py_ssize_t strt=2,stp=2,step=2;
723 GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getNumberOfItemGivenBES (wrap) : the input slice is invalid !");
724 return DataArray::GetNumberOfItemGivenBES(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
727 mcIdType getNumberOfItemGivenBESRelative(PyObject *slic)
729 if(!PySlice_Check(slic))
730 throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBESRelative (wrap) : expecting a pyslice as second (first) parameter !");
731 Py_ssize_t strt=2,stp=2,step=2;
732 GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !");
733 return DataArray::GetNumberOfItemGivenBESRelative(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
736 PyObject *__getstate__() const
738 PyObject *ret(PyTuple_New(2));
739 std::string a0(self->getName());
740 const std::vector<std::string> &a1(self->getInfoOnComponents());
741 PyTuple_SetItem(ret,0,PyString_FromString(a0.c_str()));
743 std::size_t sz(a1.size());
744 PyObject *ret1(PyList_New(sz));
745 for(std::size_t i=0;i<sz;i++)
746 PyList_SetItem(ret1,i,PyString_FromString(a1[i].c_str()));
747 PyTuple_SetItem(ret,1,ret1);
752 void __setstate__(PyObject *inp)
754 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 !";
755 if(!PyTuple_Check(inp))
756 throw INTERP_KERNEL::Exception("DataArrayDouble.__setstate__ : invalid input ! Invalid overwrite of __getstate__ ?");
757 std::size_t sz(PyTuple_Size(inp));
759 throw INTERP_KERNEL::Exception("DataArrayDouble.__setstate__ : invalid tuple in input ! Should be of size 2 ! Invalid overwrite of __getstate__ ?");
760 PyObject *a0(PyTuple_GetItem(inp,0));
761 self->setName(convertPyObjectToStr(a0,MSG));
762 PyObject *a1(PyTuple_GetItem(inp,1));
763 std::vector<std::string> a1cpp;
764 if(!fillStringVector(a1,a1cpp))
765 throw INTERP_KERNEL::Exception(MSG);
766 self->setInfoOnComponents(a1cpp);
771 class DataArrayDouble;
773 class DataArrayFloat : public DataArray
776 static DataArrayFloat *New();
777 void fillWithValue(float val);
778 bool isEqual(const DataArrayFloat& other, float prec) const;
779 bool isEqualWithoutConsideringStr(const DataArrayFloat& other, float prec) const;
780 bool isUniform(float val, float eps) const;
781 void pushBackSilent(float val);
782 void iota(float init=0.);
783 DataArrayFloatIterator *iterator();
784 MCAuto<DataArrayDouble> convertToDblArr() const;
785 static DataArrayFloat *Meld(const DataArrayFloat *a1, const DataArrayFloat *a2);
790 return DataArrayFloat::New();
793 static DataArrayFloat *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
795 return DataArrayT_New<float>(elt0,nbOfTuples,elt2);
798 DataArrayFloat(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
800 return MEDCoupling_DataArrayFloat_New__SWIG_1(elt0,nbOfTuples,elt2);
803 DataArrayFloatIterator *__iter__()
805 return self->iterator();
808 std::string __repr__() const
810 std::ostringstream oss;
811 self->reprQuickOverview(oss);
815 std::string __str__() const
817 return self->reprNotTooLong();
820 mcIdType __len__() const
822 if(self->isAllocated())
824 return self->getNumberOfTuples();
828 throw INTERP_KERNEL::Exception("DataArrayFloat::__len__ : Instance is NOT allocated !");
832 PyObject *getValues() const
834 const float *vals(self->begin());
835 return convertDblArrToPyList<float>(vals,self->getNbOfElems());
838 PyObject *getValuesAsTuple() const
840 const float *vals(self->begin());
841 std::size_t nbOfComp(self->getNumberOfComponents());
842 mcIdType nbOfTuples(self->getNumberOfTuples());
843 return convertDblArrToPyListOfTuple<float>(vals,nbOfComp,nbOfTuples);
846 PyObject *isEqualIfNotWhy(const DataArrayFloat& other, float prec) const
849 bool ret0=self->isEqualIfNotWhy(other,prec,ret1);
850 PyObject *ret=PyTuple_New(2);
851 PyObject *ret0Py=ret0?Py_True:Py_False;
853 PyTuple_SetItem(ret,0,ret0Py);
854 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
858 PyObject *__getitem__(PyObject *obj)
860 return DataArrayT__getitem<float>(self,obj);
863 DataArrayFloat *__setitem__(PyObject *obj, PyObject *value)
865 return DataArrayT__setitem__<float>(self,obj,value);
868 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
870 return DataArrayT_iadd<float>(trueSelf,obj,self);
873 PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
875 return DataArrayT_isub<float>(trueSelf,obj,self);
878 PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
880 return DataArrayT_imul<float>(trueSelf,obj,self);
883 DataArrayFloat *__rmul__(PyObject *obj)
885 return DataArrayFPT_rmul<float>(self,obj);
888 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
890 return DataArrayT_idiv<float>(trueSelf,obj,self);
894 PyObject *toNumPyArray() // not const. It is not a bug !
896 return ToNumPyArray<DataArrayFloat,float>(self,NPY_FLOAT,"DataArrayFloat");
902 class DataArrayFloatTuple;
904 class DataArrayFloatIterator
907 DataArrayFloatIterator(DataArrayFloat *da);
908 ~DataArrayFloatIterator();
913 DataArrayFloatTuple *ret=self->nextt();
915 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayFloatTuple,SWIG_POINTER_OWN|0);
918 PyErr_SetString(PyExc_StopIteration,"No more data.");
925 class DataArrayFloatTuple
928 std::size_t getNumberOfCompo() const;
929 DataArrayFloat *buildDAFloat(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
932 std::string __str__() const
937 float __float__() const
939 return self->floatValue();
942 DataArrayFloat *buildDAFloat()
944 return self->buildDAFloat(1,self->getNumberOfCompo());
947 /*PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
949 MCAuto<DataArrayFloat> ret=self->buildDAFloat(1,self->getNumberOfCompo());
950 MEDCoupling_DataArrayFloat____imul___(ret,0,obj);
951 Py_XINCREF(trueSelf);
957 return PyInt_FromLong(self->getNumberOfCompo());
962 class DataArrayDoubleIterator;
964 class DataArrayDouble : public DataArray
967 static DataArrayDouble *New();
968 double doubleValue() const;
970 void aggregate(const DataArrayDouble *other);
971 DataArrayDouble *performCopyOrIncrRef(bool deepCopy) const;
972 void deepCopyFrom(const DataArrayDouble& other);
973 void reserve(std::size_t nbOfElems);
974 void pushBackSilent(double val);
975 double popBackSilent();
977 void allocIfNecessary(int nbOfTuple, int nbOfCompo);
979 void fillWithValue(double val);
980 void iota(double init=0.);
981 bool isUniform(double val, double eps) const;
982 void sort(bool asc=true);
984 void checkMonotonic(bool increasing, double eps) const;
985 bool isMonotonic(bool increasing, double eps) const;
986 std::string repr() const;
987 std::string reprZip() const;
988 std::string reprNotTooLong() const;
989 bool isEqual(const DataArrayDouble& other, double prec) const;
990 bool isEqualWithoutConsideringStr(const DataArrayDouble& other, double prec) const;
991 DataArrayDouble *fromNoInterlace() const;
992 DataArrayDouble *toNoInterlace() const;
993 DataArrayDouble *subArray(int tupleIdBg, int tupleIdEnd=-1) const;
995 DataArrayDouble *changeNbOfComponents(std::size_t newNbOfComp, double dftValue) const;
996 void meldWith(const DataArrayDouble *other);
997 DataArrayDouble *duplicateEachTupleNTimes(int nbTimes) const;
998 DataArrayDouble *getDifferentValues(double prec, int limitTupleId=-1) const;
999 DataArrayIdType *findClosestTupleId(const DataArrayDouble *other) const;
1000 DataArrayIdType *computeNbOfInteractionsWith(const DataArrayDouble *otherBBoxFrmt, double eps) const;
1001 void setPartOfValues1(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare=true);
1002 void setPartOfValuesSimple1(double a, mcIdType bgTuples, mcIdType endTuples, mcIdType stepTuples, mcIdType bgComp, mcIdType endComp, mcIdType stepComp);
1003 void setPartOfValuesAdv(const DataArrayDouble *a, const DataArrayIdType *tuplesSelec);
1004 double getIJ(int tupleId, int compoId) const;
1005 double front() const;
1006 double back() const;
1007 double getIJSafe(int tupleId, int compoId) const;
1008 void setIJ(int tupleId, int compoId, double newVal);
1009 void setIJSilent(int tupleId, int compoId, double newVal);
1010 double *getPointer();
1011 void checkNoNullValues() const;
1012 DataArrayDouble *computeBBoxPerTuple(double epsilon=0.0) const;
1013 void recenterForMaxPrecision(double eps);
1014 double getMaxValueInArray() const;
1015 double getMaxAbsValueInArray() const;
1016 double getMinValueInArray() const;
1017 int count(double value, double eps) const;
1018 double getAverageValue() const;
1019 double norm2() const;
1020 double normMax() const;
1021 double normMin() const;
1022 double accumulate(int compId) const;
1023 DataArrayDouble *fromPolarToCart() const;
1024 DataArrayDouble *fromCylToCart() const;
1025 DataArrayDouble *fromSpherToCart() const;
1026 DataArrayDouble *fromCartToPolar() const;
1027 DataArrayDouble *fromCartToCyl() const;
1028 DataArrayDouble *fromCartToSpher() const;
1029 DataArrayDouble *cartesianize(MEDCouplingAxisType atOfThis) const;
1030 DataArrayDouble *doublyContractedProduct() const;
1031 DataArrayDouble *determinant() const;
1032 DataArrayDouble *eigenValues() const;
1033 DataArrayDouble *eigenVectors() const;
1034 DataArrayDouble *inverse() const;
1035 DataArrayDouble *trace() const;
1036 DataArrayDouble *deviator() const;
1037 DataArrayDouble *magnitude() const;
1038 DataArrayDouble *maxPerTuple() const;
1039 DataArrayDouble *sumPerTuple() const;
1040 DataArrayDouble *buildEuclidianDistanceDenseMatrix() const;
1041 DataArrayDouble *buildEuclidianDistanceDenseMatrixWith(const DataArrayDouble *other) const;
1042 void sortPerTuple(bool asc);
1044 DataArrayDouble *computeAbs() const;
1045 void applyLin(double a, double b, int compoId);
1046 void applyLin(double a, double b);
1047 void applyInv(double numerator);
1048 void applyPow(double val);
1049 void applyRPow(double val);
1050 DataArrayDouble *negate() const;
1051 DataArrayDouble *applyFunc(int nbOfComp, FunctionToEvaluate func) const;
1052 DataArrayDouble *applyFunc(int nbOfComp, const std::string& func, bool isSafe=true) const;
1053 DataArrayDouble *applyFunc(const std::string& func, bool isSafe=true) const;
1054 void applyFuncOnThis(const std::string& func, bool isSafe=true);
1055 DataArrayDouble *applyFuncCompo(int nbOfComp, const std::string& func, bool isSafe=true) const;
1056 DataArrayDouble *applyFuncNamedCompo(int nbOfComp, const std::vector<std::string>& varsOrder, const std::string& func, bool isSafe=true) const;
1057 void applyFuncFast32(const std::string& func);
1058 void applyFuncFast64(const std::string& func);
1059 DataArrayIdType *findIdsInRange(double vmin, double vmax) const;
1060 DataArrayIdType *findIdsNotInRange(double vmin, double vmax) const;
1061 DataArrayIdType *findIdsStrictlyNegative() const;
1062 static DataArrayDouble *Aggregate(const DataArrayDouble *a1, const DataArrayDouble *a2);
1063 static DataArrayDouble *Meld(const DataArrayDouble *a1, const DataArrayDouble *a2);
1064 static DataArrayDouble *Dot(const DataArrayDouble *a1, const DataArrayDouble *a2);
1065 static DataArrayDouble *CrossProduct(const DataArrayDouble *a1, const DataArrayDouble *a2);
1066 static DataArrayDouble *Max(const DataArrayDouble *a1, const DataArrayDouble *a2);
1067 static DataArrayDouble *Min(const DataArrayDouble *a1, const DataArrayDouble *a2);
1068 static DataArrayDouble *Add(const DataArrayDouble *a1, const DataArrayDouble *a2);
1069 void addEqual(const DataArrayDouble *other);
1070 static DataArrayDouble *Substract(const DataArrayDouble *a1, const DataArrayDouble *a2);
1071 void substractEqual(const DataArrayDouble *other);
1072 static DataArrayDouble *Multiply(const DataArrayDouble *a1, const DataArrayDouble *a2);
1073 void multiplyEqual(const DataArrayDouble *other);
1074 static DataArrayDouble *Divide(const DataArrayDouble *a1, const DataArrayDouble *a2);
1075 void divideEqual(const DataArrayDouble *other);
1076 static DataArrayDouble *Pow(const DataArrayDouble *a1, const DataArrayDouble *a2);
1077 void powEqual(const DataArrayDouble *other);
1078 MCAuto<DataArrayIdType> findIdsGreaterOrEqualTo(double val) const;
1079 MCAuto<DataArrayIdType> findIdsGreaterThan(double val) const;
1080 MCAuto<DataArrayIdType> findIdsLowerOrEqualTo(double val) const;
1081 MCAuto<DataArrayIdType> findIdsLowerThan(double val) const;
1082 MCAuto<DataArrayInt32> convertToIntArr() const;
1083 MCAuto<DataArrayDouble> selectPartDef(const PartDefinition* pd) const;
1084 MCAuto<DataArrayDouble> cumSum() const;
1085 MCAuto<DataArrayFloat> convertToFloatArr() const;
1090 return DataArrayDouble::New();
1093 static DataArrayDouble *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
1095 return DataArrayT_New<double>(elt0,nbOfTuples,elt2);
1098 DataArrayDouble(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
1100 return MEDCoupling_DataArrayDouble_New__SWIG_1(elt0,nbOfTuples,elt2);
1103 void pushBackValsSilent(PyObject *li)
1106 std::vector<double> bb;
1107 mcIdType sw; mcIdType nbTuples=-1;
1108 const char msg[]="Python wrap of DataArrayDouble::pushBackValsSilent : ";
1109 const double *tmp=convertObjToPossibleCpp5_SingleCompo(li,sw,val,bb,msg,true,nbTuples);
1110 self->pushBackValsSilent(tmp,tmp+nbTuples);
1113 std::string __repr__() const
1115 std::ostringstream oss;
1116 self->reprQuickOverview(oss);
1120 std::string __str__() const
1122 return self->reprNotTooLong();
1125 double __float__() const
1127 return self->doubleValue();
1130 mcIdType __len__() const
1132 if(self->isAllocated())
1134 return self->getNumberOfTuples();
1138 throw INTERP_KERNEL::Exception("DataArrayDouble::__len__ : Instance is NOT allocated !");
1142 PyObject *asArcOfCircle() const
1144 double center[2],radius,ang;
1145 self->asArcOfCircle(center,radius,ang);
1146 PyObject *ret(PyTuple_New(3));
1148 PyObject *ret0(PyList_New(2));
1149 PyList_SetItem(ret0,0,PyFloat_FromDouble(center[0]));
1150 PyList_SetItem(ret0,1,PyFloat_FromDouble(center[1]));
1151 PyTuple_SetItem(ret,0,ret0);
1153 PyTuple_SetItem(ret,1,PyFloat_FromDouble(radius));
1154 PyTuple_SetItem(ret,2,PyFloat_FromDouble(ang));
1158 DataArrayDoubleIterator *__iter__()
1160 return self->iterator();
1163 void setValues(PyObject *li, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
1165 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 !";
1166 if(PyList_Check(li) || PyTuple_Check(li))
1168 if(nbOfTuples && nbOfTuples != Py_None)
1170 if(PyInt_Check(nbOfTuples))
1172 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
1174 throw INTERP_KERNEL::Exception("DataArrayDouble::setValues : should be a positive set of allocated memory !");
1175 if(nbOfComp && nbOfComp != Py_None)
1177 if(PyInt_Check(nbOfComp))
1178 {//DataArrayDouble.setValues([1.,3.,4.,5.],2,2)
1179 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
1181 throw INTERP_KERNEL::Exception("DataArrayDouble::setValues : should be a positive number of components !");
1182 std::vector<double> tmp=fillArrayWithPyListDbl2(li,nbOfTuples1,nbOfCompo);
1183 self->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1186 throw INTERP_KERNEL::Exception(msg);
1189 {//DataArrayDouble.setValues([1.,3.,4.],3)
1191 std::vector<double> tmp=fillArrayWithPyListDbl2(li,nbOfTuples1,tmpp1);
1192 self->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1196 throw INTERP_KERNEL::Exception(msg);
1199 {// DataArrayDouble.setValues([1.,3.,4.])
1200 mcIdType tmpp1=-1,tmpp2=-1;
1201 std::vector<double> tmp=fillArrayWithPyListDbl2(li,tmpp1,tmpp2);
1202 self->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1206 throw INTERP_KERNEL::Exception(msg);
1209 PyObject *getValues() const
1211 const double *vals(self->begin());
1212 return convertDblArrToPyList<double>(vals,self->getNbOfElems());
1216 PyObject *toNumPyArray() // not const. It is not a bug !
1218 return ToNumPyArray<DataArrayDouble,double>(self,NPY_DOUBLE,"DataArrayDouble");
1222 PyObject *isEqualIfNotWhy(const DataArrayDouble& other, double prec) const
1225 bool ret0=self->isEqualIfNotWhy(other,prec,ret1);
1226 PyObject *ret=PyTuple_New(2);
1227 PyObject *ret0Py=ret0?Py_True:Py_False;
1229 PyTuple_SetItem(ret,0,ret0Py);
1230 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
1234 PyObject *getValuesAsTuple() const
1236 const double *vals(self->begin());
1237 std::size_t nbOfComp(self->getNumberOfComponents());
1238 mcIdType nbOfTuples(self->getNumberOfTuples());
1239 return convertDblArrToPyListOfTuple<double>(vals,nbOfComp,nbOfTuples);
1242 static PyObject *ComputeIntegralOfSeg2IntoTri3(PyObject *seg2, PyObject *tri3)
1244 const char msg[]="Python wrap of DataArrayDouble::ComputeIntegralOfSeg2IntoTri3 : ";
1246 DataArrayDouble *a,*a2;
1247 DataArrayDoubleTuple *aa,*aa2;
1248 std::vector<double> bb,bb2;
1250 const double *seg2Ptr(convertObjToPossibleCpp5_Safe(seg2,sw,val,a,aa,bb,msg,2,2,true));
1251 const double *tri3Ptr(convertObjToPossibleCpp5_Safe(tri3,sw,val2,a2,aa2,bb2,msg,3,2,true));
1253 double res0[3],res1;
1254 DataArrayDouble::ComputeIntegralOfSeg2IntoTri3(seg2Ptr,tri3Ptr,res0,res1);
1255 PyObject *ret(PyTuple_New(2)),*ret0(PyTuple_New(3));
1256 PyTuple_SetItem(ret0,0,PyFloat_FromDouble(res0[0]));
1257 PyTuple_SetItem(ret0,1,PyFloat_FromDouble(res0[1]));
1258 PyTuple_SetItem(ret0,2,PyFloat_FromDouble(res0[2]));
1259 PyTuple_SetItem(ret,0,ret0);
1260 PyTuple_SetItem(ret,1,PyFloat_FromDouble(res1));
1264 DataArrayDouble *symmetry3DPlane(PyObject *point, PyObject *normalVector)
1266 const char msg[]="Python wrap of DataArrayDouble::symmetry3DPlane : ";
1268 DataArrayDouble *a,*a2;
1269 DataArrayDoubleTuple *aa,*aa2;
1270 std::vector<double> bb,bb2;
1272 const double *centerPtr(convertObjToPossibleCpp5_Safe(point,sw,val,a,aa,bb,msg,1,3,true));
1273 const double *vectorPtr(convertObjToPossibleCpp5_Safe(normalVector,sw,val2,a2,aa2,bb2,msg,1,3,true));
1274 MCAuto<DataArrayDouble> ret(self->symmetry3DPlane(centerPtr,vectorPtr));
1278 static PyObject *GiveBaseForPlane(PyObject *normalVector)
1280 const char msg[]="Python wrap of DataArrayDouble::GiveBaseForPlane : ";
1283 DataArrayDoubleTuple *aa;
1284 std::vector<double> bb,bb2;
1286 const double *vectorPtr(convertObjToPossibleCpp5_Safe(normalVector,sw,val,a,aa,bb,msg,1,3,true));
1288 DataArrayDouble::GiveBaseForPlane(vectorPtr,res);
1289 return convertDblArrToPyListOfTuple<double>(res,3,3);
1292 DataArrayDouble *fromCartToCylGiven(const DataArrayDouble *coords, PyObject *center, PyObject *vector) const
1294 const char msg[]="Python wrap of DataArrayDouble::fromCartToCylGiven : ";
1296 DataArrayDouble *a,*a2;
1297 DataArrayDoubleTuple *aa,*aa2;
1298 std::vector<double> bb,bb2;
1300 const double *centerPtr=convertObjToPossibleCpp5_Safe(center,sw,val,a,aa,bb,msg,1,3,true);
1301 const double *vectorPtr=convertObjToPossibleCpp5_Safe(vector,sw,val2,a2,aa2,bb2,msg,1,3,true);
1302 return self->fromCartToCylGiven(coords,centerPtr,vectorPtr);
1305 DataArrayDouble *renumber(PyObject *li)
1308 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
1309 if (!SWIG_IsOK(res1))
1312 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1313 if(size!=self->getNumberOfTuples())
1315 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1317 return self->renumber(tmp);
1321 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1323 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1324 da2->checkAllocated();
1325 mcIdType size=self->getNumberOfTuples();
1326 if(size!=self->getNumberOfTuples())
1328 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1330 return self->renumber(da2->getConstPointer());
1334 DataArrayDouble *renumberR(PyObject *li)
1337 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
1338 if (!SWIG_IsOK(res1))
1341 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1342 if(size!=self->getNumberOfTuples())
1344 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1346 return self->renumberR(tmp);
1350 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1352 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1353 da2->checkAllocated();
1354 mcIdType size=self->getNumberOfTuples();
1355 if(size!=self->getNumberOfTuples())
1357 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1359 return self->renumberR(da2->getConstPointer());
1363 DataArrayDouble *renumberAndReduce(PyObject *li, mcIdType newNbOfTuple)
1366 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
1367 if (!SWIG_IsOK(res1))
1370 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1371 if(size!=self->getNumberOfTuples())
1373 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1375 return self->renumberAndReduce(tmp,newNbOfTuple);
1379 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1381 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1382 da2->checkAllocated();
1383 mcIdType size=self->getNumberOfTuples();
1384 if(size!=self->getNumberOfTuples())
1386 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1388 return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
1392 PyObject *minimalDistanceTo(const DataArrayDouble *other) const
1394 mcIdType thisTupleId,otherTupleId;
1395 double r0=self->minimalDistanceTo(other,thisTupleId,otherTupleId);
1396 PyObject *ret=PyTuple_New(3);
1397 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r0));
1398 PyTuple_SetItem(ret,1,PyInt_FromLong(thisTupleId));
1399 PyTuple_SetItem(ret,2,PyInt_FromLong(otherTupleId));
1403 PyObject *getMaxValue() const
1406 double r1=self->getMaxValue(tmp);
1407 PyObject *ret=PyTuple_New(2);
1408 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1409 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1413 PyObject *getMaxAbsValue() const
1416 double r1=self->getMaxAbsValue(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 *getMaxValue2() const
1425 DataArrayIdType *tmp;
1426 double r1=self->getMaxValue2(tmp);
1427 PyObject *ret=PyTuple_New(2);
1428 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1429 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1433 PyObject *getMinValue() const
1436 double r1=self->getMinValue(tmp);
1437 PyObject *ret=PyTuple_New(2);
1438 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1439 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1443 PyObject *getMinValue2() const
1445 DataArrayIdType *tmp;
1446 double r1=self->getMinValue2(tmp);
1447 PyObject *ret=PyTuple_New(2);
1448 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1449 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1453 PyObject *getMinMaxPerComponent() const
1455 std::size_t nbOfCompo(self->getNumberOfComponents());
1456 INTERP_KERNEL::AutoPtr<double> tmp(new double[2*nbOfCompo]);
1457 self->getMinMaxPerComponent(tmp);
1458 PyObject *ret=convertDblArrToPyListOfTuple<double>(tmp,2,ToIdType(nbOfCompo));
1462 PyObject *normMaxPerComponent() const
1464 std::size_t nbOfCompo(self->getNumberOfComponents());
1465 INTERP_KERNEL::AutoPtr<double> tmp(new double[nbOfCompo]);
1466 self->normMaxPerComponent(tmp);
1467 return convertDblArrToPyList<double>(tmp,ToIdType(nbOfCompo));
1470 PyObject *accumulate() const
1472 std::size_t sz=self->getNumberOfComponents();
1473 INTERP_KERNEL::AutoPtr<double> tmp=new double[sz];
1474 self->accumulate(tmp);
1475 return convertDblArrToPyList<double>(tmp,ToIdType(sz));
1478 DataArrayDouble *accumulatePerChunck(PyObject *indexArr) const
1480 mcIdType sw, sz,val;
1481 std::vector<mcIdType> val2;
1482 const mcIdType *bg=convertIntStarLikePyObjToCppIntStar(indexArr,sw,sz,val,val2);
1483 return self->accumulatePerChunck(bg,bg+sz);
1486 PyObject *findCommonTuples(double prec, mcIdType limitNodeId=-1) const
1488 DataArrayIdType *comm, *commIndex;
1489 self->findCommonTuples(prec,limitNodeId,comm,commIndex);
1490 PyObject *res = PyList_New(2);
1491 PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(comm),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1492 PyList_SetItem(res,1,SWIG_NewPointerObj(SWIG_as_voidptr(commIndex),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1496 PyObject *distanceToTuple(PyObject *tuple) const
1500 DataArrayDoubleTuple *aa;
1501 std::vector<double> bb;
1503 mcIdType tupleId=-1;
1504 std::size_t nbOfCompo=self->getNumberOfComponents();
1505 const double *pt=convertObjToPossibleCpp5_Safe(tuple,sw,val,a,aa,bb,"Python wrap of DataArrayDouble::distanceToTuple",1,(int)nbOfCompo,true);
1507 double ret0=self->distanceToTuple(pt,pt+nbOfCompo,tupleId);
1508 PyObject *ret=PyTuple_New(2);
1509 PyTuple_SetItem(ret,0,PyFloat_FromDouble(ret0));
1510 PyTuple_SetItem(ret,1,PyInt_FromLong(tupleId));
1514 void setSelectedComponents(const DataArrayDouble *a, PyObject *li)
1516 std::vector<std::size_t> tmp;
1517 convertPyToNewIntArr3(li,tmp);
1518 self->setSelectedComponents(a,tmp);
1521 PyObject *explodeComponents() const
1523 std::vector< MCAuto<DataArrayDouble> > retCpp(self->explodeComponents());
1524 std::size_t sz(retCpp.size());
1525 PyObject *res(PyList_New(sz));
1526 for(std::size_t i=0;i<sz;i++)
1527 PyList_SetItem(res,i,SWIG_NewPointerObj(SWIG_as_voidptr(retCpp[i].retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ));
1531 PyObject *getTuple(mcIdType tupleId)
1533 std::size_t sz=self->getNumberOfComponents();
1534 INTERP_KERNEL::AutoPtr<double> tmp=new double[sz];
1535 self->getTuple(tupleId,tmp);
1536 return convertDblArrToPyList<double>(tmp,ToIdType(sz));
1539 static DataArrayDouble *Aggregate(PyObject *li)
1541 std::vector<const DataArrayDouble *> tmp;
1542 convertFromPyObjVectorOfObj<const DataArrayDouble *>(li,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",tmp);
1543 return DataArrayDouble::Aggregate(tmp);
1546 static DataArrayDouble *Meld(PyObject *li)
1548 std::vector<const DataArrayDouble *> tmp;
1549 convertFromPyObjVectorOfObj<const DataArrayDouble *>(li,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",tmp);
1550 return DataArrayDouble::Meld(tmp);
1553 PyObject *computeTupleIdsNearTuples(PyObject *pt, double eps) const
1557 DataArrayDoubleTuple *aa;
1558 std::vector<double> bb;
1560 std::size_t nbComp=self->getNumberOfComponents();
1561 mcIdType nbTuples=-1;
1562 const char msg[]="Python wrap of DataArrayDouble::computeTupleIdsNearTuples : ";
1563 const double *pos=convertObjToPossibleCpp5_Safe2(pt,sw,val,a,aa,bb,msg,(int)nbComp,true,nbTuples);
1564 MCAuto<DataArrayDouble> inpu=DataArrayDouble::New(); inpu->useArray(pos,false,DeallocType::CPP_DEALLOC,nbTuples,nbComp);
1565 DataArrayIdType *c=0,*cI=0;
1566 self->computeTupleIdsNearTuples(inpu,eps,c,cI);
1567 PyObject *ret=PyTuple_New(2);
1568 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1569 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1573 PyObject *areIncludedInMe(const DataArrayDouble *other, double prec) const
1575 DataArrayIdType *ret1=0;
1576 bool ret0=self->areIncludedInMe(other,prec,ret1);
1577 PyObject *ret=PyTuple_New(2);
1578 PyObject *ret0Py=ret0?Py_True:Py_False;
1580 PyTuple_SetItem(ret,0,ret0Py);
1581 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1585 PyObject *__getitem__(PyObject *obj)
1587 return DataArrayT__getitem<double>(self,obj);
1590 DataArrayDouble *__setitem__(PyObject *obj, PyObject *value)
1592 return DataArrayT__setitem__<double>(self,obj,value);
1595 DataArrayDouble *__neg__() const
1597 return self->negate();
1600 PyObject *__add__(PyObject *obj)
1602 const char msg[]="Unexpected situation in DataArrayDouble.__add__ !";
1605 DataArrayDoubleTuple *aa;
1606 std::vector<double> bb;
1609 #ifndef WITHOUT_AUTOFIELD
1611 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1613 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1616 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1617 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___radd__Impl(other,tmp);
1619 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1622 throw INTERP_KERNEL::Exception(msg);
1626 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1631 MCAuto<DataArrayDouble> ret=self->deepCopy();
1632 ret->applyLin(1.,val);
1633 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1637 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1641 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1642 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1646 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1647 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1650 throw INTERP_KERNEL::Exception(msg);
1654 DataArrayDouble *__radd__(PyObject *obj)
1656 const char msg[]="Unexpected situation in __radd__ !";
1659 DataArrayDoubleTuple *aa;
1660 std::vector<double> bb;
1662 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1667 MCAuto<DataArrayDouble> ret=self->deepCopy();
1668 ret->applyLin(1.,val);
1673 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1674 return DataArrayDouble::Add(self,aaa);
1678 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1679 return DataArrayDouble::Add(self,aaa);
1682 throw INTERP_KERNEL::Exception(msg);
1686 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
1688 return DataArrayT_iadd<double>(trueSelf,obj,self);
1691 PyObject *__sub__(PyObject *obj)
1693 const char msg[]="Unexpected situation in __sub__ !";
1696 DataArrayDoubleTuple *aa;
1697 std::vector<double> bb;
1700 #ifndef WITHOUT_AUTOFIELD
1702 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1704 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1707 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1708 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rsub__Impl(other,tmp);
1710 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1713 throw INTERP_KERNEL::Exception(msg);
1717 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1722 MCAuto<DataArrayDouble> ret=self->deepCopy();
1723 ret->applyLin(1.,-val);
1724 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1728 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1732 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1733 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1737 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1738 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1741 throw INTERP_KERNEL::Exception(msg);
1745 DataArrayDouble *__rsub__(PyObject *obj)
1747 const char msg[]="Unexpected situation in __rsub__ !";
1750 DataArrayDoubleTuple *aa;
1751 std::vector<double> bb;
1753 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1758 MCAuto<DataArrayDouble> ret=self->deepCopy();
1759 ret->applyLin(-1.,val);
1764 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1765 return DataArrayDouble::Substract(aaa,self);
1769 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1770 return DataArrayDouble::Substract(aaa,self);
1773 throw INTERP_KERNEL::Exception(msg);
1777 PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
1779 return DataArrayT_isub<double>(trueSelf,obj,self);
1782 PyObject *__mul__(PyObject *obj)
1784 const char msg[]="Unexpected situation in __mul__ !";
1787 DataArrayDoubleTuple *aa;
1788 std::vector<double> bb;
1791 #ifndef WITHOUT_AUTOFIELD
1793 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1795 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1798 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1799 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rmul__Impl(other,tmp);
1801 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1804 throw INTERP_KERNEL::Exception(msg);
1808 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1813 MCAuto<DataArrayDouble> ret=self->deepCopy();
1814 ret->applyLin(val,0.);
1815 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1819 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1823 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1824 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1828 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1829 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1832 throw INTERP_KERNEL::Exception(msg);
1836 DataArrayDouble *__rmul__(PyObject *obj)
1838 return DataArrayFPT_rmul<double>(self,obj);
1841 PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
1843 return DataArrayT_imul<double>(trueSelf,obj,self);
1846 PyObject *__div__(PyObject *obj)
1848 const char msg[]="Unexpected situation in __div__ !";
1851 DataArrayDoubleTuple *aa;
1852 std::vector<double> bb;
1855 #ifndef WITHOUT_AUTOFIELD
1857 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1859 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1862 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1863 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rdiv__Impl(other,tmp);
1865 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1868 throw INTERP_KERNEL::Exception(msg);
1872 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1878 throw INTERP_KERNEL::Exception("DataArrayDouble::__div__ : trying to divide by zero !");
1879 MCAuto<DataArrayDouble> ret=self->deepCopy();
1880 ret->applyLin(1/val,0.);
1881 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1885 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1889 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1890 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1894 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1895 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1898 throw INTERP_KERNEL::Exception(msg);
1902 DataArrayDouble *__rdiv__(PyObject *obj)
1904 const char msg[]="Unexpected situation in __rdiv__ !";
1907 DataArrayDoubleTuple *aa;
1908 std::vector<double> bb;
1910 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1915 MCAuto<DataArrayDouble> ret=self->deepCopy();
1921 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1922 return DataArrayDouble::Divide(aaa,self);
1926 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1927 return DataArrayDouble::Divide(aaa,self);
1930 throw INTERP_KERNEL::Exception(msg);
1934 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
1936 return DataArrayT_idiv<double>(trueSelf,obj,self);
1939 DataArrayDouble *__pow__(PyObject *obj)
1941 const char msg[]="Unexpected situation in __pow__ !";
1944 DataArrayDoubleTuple *aa;
1945 std::vector<double> bb;
1947 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1952 MCAuto<DataArrayDouble> ret=self->deepCopy();
1958 return DataArrayDouble::Pow(self,a);
1962 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1963 return DataArrayDouble::Pow(self,aaa);
1967 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1968 return DataArrayDouble::Pow(self,aaa);
1971 throw INTERP_KERNEL::Exception(msg);
1975 DataArrayDouble *__rpow__(PyObject *obj)
1977 const char msg[]="Unexpected situation in __rpow__ !";
1980 DataArrayDoubleTuple *aa;
1981 std::vector<double> bb;
1983 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1988 MCAuto<DataArrayDouble> ret=self->deepCopy();
1989 ret->applyRPow(val);
1994 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1995 return DataArrayDouble::Pow(aaa,self);
1999 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
2000 return DataArrayDouble::Pow(aaa,self);
2003 throw INTERP_KERNEL::Exception(msg);
2007 PyObject *___ipow___(PyObject *trueSelf, PyObject *obj)
2009 const char msg[]="Unexpected situation in __ipow__ !";
2012 DataArrayDoubleTuple *aa;
2013 std::vector<double> bb;
2015 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
2020 self->applyPow(val);
2021 Py_XINCREF(trueSelf);
2027 Py_XINCREF(trueSelf);
2032 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
2033 self->powEqual(aaa);
2034 Py_XINCREF(trueSelf);
2039 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
2040 self->powEqual(aaa);
2041 Py_XINCREF(trueSelf);
2045 throw INTERP_KERNEL::Exception(msg);
2049 PyObject *computeTupleIdsNearTuples(const DataArrayDouble *other, double eps)
2051 DataArrayIdType *c=0,*cI=0;
2053 self->computeTupleIdsNearTuples(other,eps,c,cI);
2054 PyObject *ret=PyTuple_New(2);
2055 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2056 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2060 PyObject *maxPerTupleWithCompoId() const
2062 DataArrayIdType *ret1=0;
2063 DataArrayDouble *ret0=self->maxPerTupleWithCompoId(ret1);
2064 PyObject *ret=PyTuple_New(2);
2065 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ));
2066 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2072 class DataArrayDoubleTuple;
2074 class DataArrayDoubleIterator
2077 DataArrayDoubleIterator(DataArrayDouble *da);
2078 ~DataArrayDoubleIterator();
2083 DataArrayDoubleTuple *ret=self->nextt();
2085 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayDoubleTuple,SWIG_POINTER_OWN|0);
2088 PyErr_SetString(PyExc_StopIteration,"No more data.");
2095 class DataArrayDoubleTuple
2098 std::size_t getNumberOfCompo() const;
2099 DataArrayDouble *buildDADouble(int nbOfTuples, int nbOfCompo) const;
2102 std::string __str__() const
2104 return self->repr();
2107 double __float__() const
2109 return self->doubleValue();
2112 DataArrayDouble *buildDADouble()
2114 return self->buildDADouble(1,self->getNumberOfCompo());
2117 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
2119 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2120 MEDCoupling_DataArrayDouble____iadd___(ret,0,obj);
2121 Py_XINCREF(trueSelf);
2125 PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
2127 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2128 MEDCoupling_DataArrayDouble____isub___(ret,0,obj);
2129 Py_XINCREF(trueSelf);
2133 PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
2135 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2136 MEDCoupling_DataArrayDouble____imul___(ret,0,obj);
2137 Py_XINCREF(trueSelf);
2141 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
2143 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2144 MEDCoupling_DataArrayDouble____idiv___(ret,0,obj);
2145 Py_XINCREF(trueSelf);
2151 return PyInt_FromLong(self->getNumberOfCompo());
2154 PyObject *__getitem__(PyObject *obj)
2156 const char msg2[]="DataArrayDoubleTuple::__getitem__ : Mismatch of slice values in 2nd parameter (components) !";
2159 std::vector<mcIdType> multiVal;
2160 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2161 MEDCoupling::DataArrayIdType *daIntTyypp=0;
2162 const double *pt=self->getConstPointer();
2163 mcIdType nbc=ToIdType(self->getNumberOfCompo());
2164 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbc,sw,singleVal,multiVal,slic,daIntTyypp);
2171 std::ostringstream oss;
2172 oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2173 PyErr_SetString(PyExc_StopIteration,oss.str().c_str());
2177 return PyFloat_FromDouble(pt[singleVal]);
2181 return PyFloat_FromDouble(pt[nbc+singleVal]);
2184 std::ostringstream oss;
2185 oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2186 throw INTERP_KERNEL::Exception(oss.str().c_str());
2192 PyObject *t=PyTuple_New(multiVal.size());
2193 for(std::size_t j=0;j<multiVal.size();j++)
2195 mcIdType cid=multiVal[j];
2198 std::ostringstream oss;
2199 oss << "Requesting for id #" << cid << " having only " << nbc << " components !";
2200 throw INTERP_KERNEL::Exception(oss.str().c_str());
2202 PyTuple_SetItem(t,j,PyFloat_FromDouble(pt[cid]));
2208 mcIdType sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2209 PyObject *t=PyTuple_New(sz);
2210 for(mcIdType j=0;j<sz;j++)
2211 PyTuple_SetItem(t,j,PyFloat_FromDouble(pt[slic.first+j*slic.second.second]));
2215 throw INTERP_KERNEL::Exception("DataArrayDoubleTuple::__getitem__ : unrecognized type entered !");
2219 DataArrayDoubleTuple *__setitem__(PyObject *obj, PyObject *value)
2221 const char msg[]="DataArrayDoubleTuple::__setitem__ : unrecognized type entered, int, slice, list<int>, tuple<int> !";
2222 const char msg2[]="DataArrayDoubleTuple::__setitem__ : Mismatch of slice values in 2nd parameter (components) !";
2225 std::vector<double> multiValV;
2226 MEDCoupling::DataArrayDoubleTuple *daIntTyyppV=0;
2227 mcIdType nbc=ToIdType(self->getNumberOfCompo());
2228 convertDoubleStarLikePyObjToCpp(value,sw1,singleValV,multiValV,daIntTyyppV);
2230 std::vector<mcIdType> multiVal;
2231 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2232 MEDCoupling::DataArrayIdType *daIntTyypp=0;
2233 double *pt=self->getPointer();
2234 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbc,sw2,singleVal,multiVal,slic,daIntTyypp);
2241 std::ostringstream oss;
2242 oss << "Requesting for setting id # " << singleVal << " having only " << nbc << " components !";
2243 throw INTERP_KERNEL::Exception(oss.str().c_str());
2249 pt[singleVal]=singleValV;
2254 if(multiValV.size()!=1)
2256 std::ostringstream oss;
2257 oss << "Requesting for setting id # " << singleVal << " with a list or tuple with size != 1 ! ";
2258 throw INTERP_KERNEL::Exception(oss.str().c_str());
2260 pt[singleVal]=multiValV[0];
2265 pt[singleVal]=daIntTyyppV->getConstPointer()[0];
2269 throw INTERP_KERNEL::Exception(msg);
2278 for(std::vector<mcIdType>::const_iterator it=multiVal.begin();it!=multiVal.end();it++)
2282 std::ostringstream oss;
2283 oss << "Requesting for setting id # " << *it << " having only " << nbc << " components !";
2284 throw INTERP_KERNEL::Exception(oss.str().c_str());
2292 if(multiVal.size()!=multiValV.size())
2294 std::ostringstream oss;
2295 oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << multiVal.size() << " !";
2296 throw INTERP_KERNEL::Exception(oss.str().c_str());
2298 for(std::size_t i=0;i<multiVal.size();i++)
2300 mcIdType pos=multiVal[i];
2303 std::ostringstream oss;
2304 oss << "Requesting for setting id # " << pos << " having only " << nbc << " components !";
2305 throw INTERP_KERNEL::Exception(oss.str().c_str());
2307 pt[multiVal[i]]=multiValV[i];
2313 const double *ptV=daIntTyyppV->getConstPointer();
2314 if(nbc>(mcIdType)daIntTyyppV->getNumberOfCompo())
2316 std::ostringstream oss;
2317 oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2318 throw INTERP_KERNEL::Exception(oss.str().c_str());
2320 std::copy(ptV,ptV+nbc,pt);
2324 throw INTERP_KERNEL::Exception(msg);
2329 mcIdType sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2334 for(mcIdType j=0;j<sz;j++)
2335 pt[slic.first+j*slic.second.second]=singleValV;
2340 if(sz!=(mcIdType)multiValV.size())
2342 std::ostringstream oss;
2343 oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << sz << " !";
2344 throw INTERP_KERNEL::Exception(oss.str().c_str());
2346 for(mcIdType j=0;j<sz;j++)
2347 pt[slic.first+j*slic.second.second]=multiValV[j];
2352 const double *ptV=daIntTyyppV->getConstPointer();
2353 if(sz>(mcIdType)daIntTyyppV->getNumberOfCompo())
2355 std::ostringstream oss;
2356 oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2357 throw INTERP_KERNEL::Exception(oss.str().c_str());
2359 for(mcIdType j=0;j<sz;j++)
2360 pt[slic.first+j*slic.second.second]=ptV[j];
2364 throw INTERP_KERNEL::Exception(msg);
2368 throw INTERP_KERNEL::Exception(msg);
2374 class DataArrayChar : public DataArray
2377 virtual DataArrayChar *buildEmptySpecializedDAChar() const;
2378 int getHashCode() const;
2380 void deepCopyFrom(const DataArrayChar& other);
2381 void reserve(std::size_t nbOfElems);
2382 void pushBackSilent(char val);
2383 char popBackSilent();
2385 void allocIfNecessary(int nbOfTuple, int nbOfCompo);
2386 bool isEqual(const DataArrayChar& other) const;
2387 bool isEqualWithoutConsideringStr(const DataArrayChar& other) const;
2389 void fillWithZero();
2390 void fillWithValue(char val);
2391 std::string repr() const;
2392 std::string reprZip() const;
2393 DataArrayInt *convertToIntArr() const;
2394 DataArrayChar *renumber(const mcIdType *old2New) const;
2395 DataArrayChar *renumberR(const mcIdType *new2Old) const;
2396 DataArrayChar *renumberAndReduce(const mcIdType *old2NewBg, mcIdType newNbOfTuple) const;
2397 bool isUniform(char val) const;
2398 void sort(bool asc=true);
2399 DataArrayChar *subArray(mcIdType tupleIdBg, mcIdType tupleIdEnd=-1) const;
2400 DataArrayChar *changeNbOfComponents(std::size_t newNbOfComp, char dftValue) const;
2401 void meldWith(const DataArrayChar *other);
2402 void setPartOfValuesAdv(const DataArrayChar *a, const DataArrayIdType *tuplesSelec);
2405 void setIJ(mcIdType tupleId, int compoId, char newVal);
2406 void setIJSilent(mcIdType tupleId, int compoId, char newVal);
2408 DataArrayIdType *findIdsEqual(char val) const;
2409 DataArrayIdType *findIdsNotEqual(char val) const;
2410 int findIdFirstEqualTuple(const std::vector<char>& tupl) const;
2411 bool presenceOfTuple(const std::vector<char>& tupl) const;
2412 char getMaxValue(mcIdType& tupleId) const;
2413 char getMaxValueInArray() const;
2414 char getMinValue(mcIdType& tupleId) const;
2415 char getMinValueInArray() const;
2416 DataArrayIdType *findIdsInRange(char vmin, char vmax) const;
2417 static DataArrayChar *Aggregate(const DataArrayChar *a1, const DataArrayChar *a2);
2418 static DataArrayChar *Meld(const DataArrayChar *a1, const DataArrayChar *a2);
2421 mcIdType __len__() const
2423 if(self->isAllocated())
2425 return self->getNumberOfTuples();
2429 throw INTERP_KERNEL::Exception("DataArrayChar::__len__ : Instance is NOT allocated !");
2433 PyObject *isEqualIfNotWhy(const DataArrayChar& other) const
2436 bool ret0=self->isEqualIfNotWhy(other,ret1);
2437 PyObject *ret=PyTuple_New(2);
2438 PyObject *ret0Py=ret0?Py_True:Py_False;
2440 PyTuple_SetItem(ret,0,ret0Py);
2441 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
2445 DataArrayChar *renumber(PyObject *li)
2448 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
2449 if (!SWIG_IsOK(res1))
2452 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2453 if(size!=self->getNumberOfTuples())
2455 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2457 return self->renumber(tmp);
2461 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2463 throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2464 da2->checkAllocated();
2465 mcIdType size=self->getNumberOfTuples();
2466 if(size!=self->getNumberOfTuples())
2468 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2470 return self->renumber(da2->getConstPointer());
2474 DataArrayChar *renumberR(PyObject *li)
2477 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
2478 if (!SWIG_IsOK(res1))
2481 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2482 if(size!=self->getNumberOfTuples())
2484 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2486 return self->renumberR(tmp);
2490 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2492 throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2493 da2->checkAllocated();
2494 mcIdType size=self->getNumberOfTuples();
2495 if(size!=self->getNumberOfTuples())
2497 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2499 return self->renumberR(da2->getConstPointer());
2503 DataArrayChar *renumberAndReduce(PyObject *li, mcIdType newNbOfTuple)
2506 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
2507 if (!SWIG_IsOK(res1))
2510 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2511 if(size!=self->getNumberOfTuples())
2513 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2515 return self->renumberAndReduce(tmp,newNbOfTuple);
2519 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2521 throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2522 da2->checkAllocated();
2523 mcIdType size=self->getNumberOfTuples();
2524 if(size!=self->getNumberOfTuples())
2526 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2528 return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
2532 static DataArrayChar *Aggregate(PyObject *dachs)
2534 std::vector<const MEDCoupling::DataArrayChar *> tmp;
2535 convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayChar *>(dachs,SWIGTYPE_p_MEDCoupling__DataArrayChar,"DataArrayChar",tmp);
2536 return DataArrayChar::Aggregate(tmp);
2539 static DataArrayChar *Meld(PyObject *dachs)
2541 std::vector<const MEDCoupling::DataArrayChar *> tmp;
2542 convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayChar *>(dachs,SWIGTYPE_p_MEDCoupling__DataArrayChar,"DataArrayChar",tmp);
2543 return DataArrayChar::Meld(tmp);
2548 class DataArrayByteIterator;
2550 class DataArrayByte : public DataArrayChar
2553 static DataArrayByte *New();
2554 DataArrayByteIterator *iterator();
2555 DataArrayByte *performCopyOrIncrRef(bool deepCopy) const;
2556 char byteValue() const;
2561 return DataArrayByte::New();
2564 static DataArrayByte *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
2566 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) !";
2567 if(PyList_Check(elt0) || PyTuple_Check(elt0))
2571 if(PyInt_Check(nbOfTuples))
2573 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
2575 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive set of allocated memory !");
2578 if(PyInt_Check(nbOfComp))
2579 {//DataArrayByte.New([1,3,4,5],2,2)
2580 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
2582 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !");
2583 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2584 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
2585 ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2589 throw INTERP_KERNEL::Exception(msg);
2592 {//DataArrayByte.New([1,3,4],3)
2593 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2595 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
2596 ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2601 throw INTERP_KERNEL::Exception(msg);
2604 {// DataArrayByte.New([1,3,4])
2605 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2606 mcIdType tmpp1=-1,tmpp2=-1;
2607 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
2608 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2612 else if(PyInt_Check(elt0))
2614 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(elt0));
2616 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive set of allocated memory !");
2621 if(PyInt_Check(nbOfTuples))
2622 {//DataArrayByte.New(5,2)
2623 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfTuples));
2625 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !");
2626 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2627 ret->alloc(nbOfTuples1,nbOfCompo);
2631 throw INTERP_KERNEL::Exception(msg);
2634 throw INTERP_KERNEL::Exception(msg);
2637 {//DataArrayByte.New(5)
2638 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2639 ret->alloc(nbOfTuples1,1);
2644 else if(PyArray_Check(elt0) && nbOfTuples==NULL && nbOfComp==NULL)
2645 {//DataArrayDouble.New(numpyArray)
2646 return BuildNewInstance<DataArrayByte,char>(elt0,NPY_INT8,&PyCallBackDataArrayChar_RefType,"INT8");
2650 throw INTERP_KERNEL::Exception(msg);
2653 DataArrayByte(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
2655 return MEDCoupling_DataArrayByte_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
2658 std::string __repr__() const
2660 std::ostringstream oss;
2661 self->reprQuickOverview(oss);
2667 return (int) self->byteValue();
2670 DataArrayByteIterator *__iter__()
2672 return self->iterator();
2675 mcIdType getIJ(mcIdType tupleId, mcIdType compoId) const
2677 return (mcIdType)self->getIJ(tupleId,compoId);
2680 mcIdType getIJSafe(mcIdType tupleId, mcIdType compoId) const
2682 return (mcIdType)self->getIJSafe(tupleId,compoId);
2685 std::string __str__() const
2687 return self->repr();
2690 PyObject *toStrList() const
2692 const char *vals=self->getConstPointer();
2693 std::size_t nbOfComp=self->getNumberOfComponents();
2694 mcIdType nbOfTuples=self->getNumberOfTuples();
2695 return convertCharArrToPyListOfTuple(vals,(int)nbOfComp,nbOfTuples);
2698 bool presenceOfTuple(PyObject *tupl) const
2700 mcIdType sz=-1,sw=-1;
2701 mcIdType ival=-1; std::vector<mcIdType> ivval;
2702 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(tupl,sw,sz,ival,ivval);
2703 std::vector<char> vals(sz);
2704 std::copy(pt,pt+sz,vals.begin());
2705 return self->presenceOfTuple(vals);
2708 bool presenceOfValue(PyObject *vals) const
2710 mcIdType sz=-1,sw=-1;
2711 mcIdType ival=-1; std::vector<mcIdType> ivval;
2712 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(vals,sw,sz,ival,ivval);
2713 std::vector<char> vals2(sz);
2714 std::copy(pt,pt+sz,vals2.begin());
2715 return self->presenceOfValue(vals2);
2718 mcIdType findIdFirstEqual(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->findIdFirstEqual(vals2);
2728 mcIdType findIdFirstEqualTuple(PyObject *tupl) const
2730 mcIdType sz=-1,sw=-1;
2731 mcIdType ival=-1; std::vector<mcIdType> ivval;
2732 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(tupl,sw,sz,ival,ivval);
2733 std::vector<char> vals(sz);
2734 std::copy(pt,pt+sz,vals.begin());
2735 return self->findIdFirstEqualTuple(vals);
2738 mcIdType findIdSequence(PyObject *strOrListOfInt) const
2740 mcIdType sz=-1,sw=-1;
2741 mcIdType ival=-1; std::vector<mcIdType> ivval;
2742 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(strOrListOfInt,sw,sz,ival,ivval);
2743 std::vector<char> vals(sz);
2744 std::copy(pt,pt+sz,vals.begin());
2745 return self->findIdSequence(vals);
2748 PyObject *getTuple(mcIdType tupleId)
2750 std::size_t sz=self->getNumberOfComponents();
2751 INTERP_KERNEL::AutoPtr<char> tmp=new char[sz];
2752 self->getTuple(tupleId,tmp);
2753 PyObject *ret=PyTuple_New(sz);
2754 for(std::size_t i=0;i<sz;i++) PyTuple_SetItem(ret,i,PyInt_FromLong((mcIdType)tmp[i]));
2758 PyObject *getMaxValue() const
2761 mcIdType r1=(mcIdType)self->getMaxValue(tmp);
2762 PyObject *ret=PyTuple_New(2);
2763 PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
2764 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
2768 PyObject *getMinValue() const
2771 mcIdType r1=(mcIdType)self->getMinValue(tmp);
2772 PyObject *ret=PyTuple_New(2);
2773 PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
2774 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
2778 mcIdType index(PyObject *obj) const
2780 std::size_t nbOfCompo=self->getNumberOfComponents();
2785 if(PyInt_Check(obj))
2787 char val=(char)PyInt_AS_LONG(obj);
2788 return self->findIdFirstEqual(val);
2791 throw INTERP_KERNEL::Exception("DataArrayByte::index : 'this' contains one component and trying to find an element which is not an integer !");
2794 return MEDCoupling_DataArrayByte_findIdFirstEqualTuple(self,obj);
2798 bool __contains__(PyObject *obj) const
2800 std::size_t nbOfCompo=self->getNumberOfComponents();
2807 if(PyInt_Check(obj))
2809 char val=(char)PyInt_AS_LONG(obj);
2810 return self->presenceOfValue(val);
2813 throw INTERP_KERNEL::Exception("DataArrayByte::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
2816 return MEDCoupling_DataArrayByte_presenceOfTuple(self,obj);
2821 PyObject *toNumPyArray() // not const. It is not a bug !
2823 return ToNumPyArray<DataArrayByte,char>(self,NPY_INT8,"DataArrayByte");
2827 DataArrayByte *__setitem__(PyObject *obj, PyObject *value)
2829 self->checkAllocated();
2830 const char msg[]="Unexpected situation in __setitem__ !";
2831 mcIdType nbOfTuples(self->getNumberOfTuples());
2832 int nbOfComponents((int)self->getNumberOfComponents());
2835 std::vector<int> v1;
2836 DataArrayIdType *d1=0;
2837 DataArrayIntTuple *dd1=0;
2838 convertIntStarLikePyObjToCpp(value,sw1,int1,v1,d1,dd1);
2840 std::vector<mcIdType> vt1,vc1;
2841 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > pt1,pc1;
2842 DataArrayIdType *dt1=0,*dc1=0;
2843 convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw2,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1);
2844 MCAuto<DataArrayIdType> tmp;
2845 char i1 = (char)int1;
2853 self->setPartOfValuesSimple1(i1,it1,it1+1,1,0,nbOfComponents,1);
2856 throw INTERP_KERNEL::Exception(msg);
2865 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1);
2868 throw INTERP_KERNEL::Exception(msg);
2877 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1);
2880 throw INTERP_KERNEL::Exception(msg);
2889 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1);
2892 throw INTERP_KERNEL::Exception(msg);
2901 self->setPartOfValuesSimple1(i1,it1,it1+1,1,ic1,ic1+1,1);
2904 throw INTERP_KERNEL::Exception(msg);
2913 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1);
2916 throw INTERP_KERNEL::Exception(msg);
2925 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1);
2928 throw INTERP_KERNEL::Exception(msg);
2937 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1);
2940 throw INTERP_KERNEL::Exception(msg);
2949 self->setPartOfValuesSimple2(i1,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size());
2952 throw INTERP_KERNEL::Exception(msg);
2961 self->setPartOfValuesSimple2(i1,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size());
2964 throw INTERP_KERNEL::Exception(msg);
2973 self->setPartOfValuesSimple4(i1,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size());
2976 throw INTERP_KERNEL::Exception(msg);
2985 self->setPartOfValuesSimple2(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size());
2988 throw INTERP_KERNEL::Exception(msg);
2997 self->setPartOfValuesSimple1(i1,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second);
3000 throw INTERP_KERNEL::Exception(msg);
3009 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second);
3012 throw INTERP_KERNEL::Exception(msg);
3021 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second);
3024 throw INTERP_KERNEL::Exception(msg);
3033 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second);
3036 throw INTERP_KERNEL::Exception(msg);
3041 throw INTERP_KERNEL::Exception(msg);
3048 class DataArrayByteTuple;
3050 class DataArrayByteIterator
3053 DataArrayByteIterator(DataArrayByte *da);
3054 ~DataArrayByteIterator();
3057 class DataArrayByteTuple
3060 std::string repr() const;
3061 DataArrayByte *buildDAByte(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
3064 std::string __str__() const
3066 return self->repr();
3069 char __int__() const
3071 return self->byteValue();
3074 DataArrayByte *buildDAByte()
3076 return self->buildDAByte(1,self->getNumberOfCompo());
3081 class DataArrayAsciiCharIterator;
3083 class DataArrayAsciiChar : public DataArrayChar
3086 static DataArrayAsciiChar *New();
3087 DataArrayAsciiCharIterator *iterator();
3088 DataArrayAsciiChar *performCopyOrIncrRef(bool deepCopy) const;
3089 char asciiCharValue() const;
3092 DataArrayAsciiChar()
3094 return DataArrayAsciiChar::New();
3097 static DataArrayAsciiChar *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
3099 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) !";
3100 if(PyList_Check(elt0) || PyTuple_Check(elt0))
3104 if(PyInt_Check(nbOfTuples))
3106 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
3108 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive set of allocated memory !");
3111 if(PyInt_Check(nbOfComp))
3112 {//DataArrayAsciiChar.New([1,3,4,5],2,2)
3113 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
3115 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !");
3116 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3117 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
3118 ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3122 throw INTERP_KERNEL::Exception(msg);
3125 {//DataArrayAsciiChar.New([1,3,4],3)
3126 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3128 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
3129 ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3133 else if(PyString_Check(nbOfTuples))
3135 if(PyString_Size(nbOfTuples)!=1)
3136 throw INTERP_KERNEL::Exception(msg);
3137 //DataArrayAsciiChar.New(["abc","de","fghi"],"t")
3138 std::vector<std::string> tmp;
3139 if(fillStringVector(elt0,tmp))
3140 return DataArrayAsciiChar::New(tmp,PyString_AsString(nbOfTuples)[0]);
3142 throw INTERP_KERNEL::Exception(msg);
3144 %#if PY_VERSION_HEX >= 0x03000000
3145 else if(PyUnicode_Check(nbOfTuples))
3147 if(PyUnicode_GET_LENGTH(nbOfTuples)!=1)
3148 throw INTERP_KERNEL::Exception(msg);
3149 //DataArrayAsciiChar.New(["abc","de","fghi"],"t")
3150 std::vector<std::string> tmp;
3151 if(fillStringVector(elt0,tmp))
3152 return DataArrayAsciiChar::New(tmp,PyUnicode_AsUTF8(nbOfTuples)[0]);
3154 throw INTERP_KERNEL::Exception(msg);
3158 throw INTERP_KERNEL::Exception(msg);
3162 std::vector<std::string> tmmp;
3163 if(fillStringVector(elt0,tmmp))
3164 //DataArrayAsciiChar.New(["abc","de","fghi"])
3165 return DataArrayAsciiChar::New(tmmp,' ');
3168 // DataArrayAsciiChar.New([1,3,4])
3169 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3170 mcIdType tmpp1=-1,tmpp2=-1;
3171 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
3172 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3177 else if(PyInt_Check(elt0))
3179 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(elt0));
3181 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive set of allocated memory !");
3186 if(PyInt_Check(nbOfTuples))
3187 {//DataArrayAsciiChar.New(5,2)
3188 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfTuples));
3190 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !");
3191 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3192 ret->alloc(nbOfTuples1,nbOfCompo);
3196 throw INTERP_KERNEL::Exception(msg);
3199 throw INTERP_KERNEL::Exception(msg);
3202 {//DataArrayAsciiChar.New(5)
3203 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3204 ret->alloc(nbOfTuples1,1);
3209 throw INTERP_KERNEL::Exception(msg);
3212 DataArrayAsciiChar(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
3214 return MEDCoupling_DataArrayAsciiChar_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
3217 std::string __repr__() const
3219 std::ostringstream oss;
3220 self->reprQuickOverview(oss);
3224 DataArrayAsciiCharIterator *__iter__()
3226 return self->iterator();
3229 std::string getIJ(mcIdType tupleId, mcIdType compoId) const
3231 char tmp[2]; tmp[1]='\0';
3232 tmp[0]=self->getIJ(tupleId,compoId);
3233 return std::string(tmp);
3236 std::string getIJSafe(mcIdType tupleId, mcIdType compoId) const
3238 char tmp[2]; tmp[1]='\0';
3239 tmp[0]=self->getIJSafe(tupleId,compoId);
3240 return std::string(tmp);
3243 std::string __str__() const
3245 return self->repr();
3248 PyObject *toStrList() const
3250 const char *vals=self->getConstPointer();
3251 std::size_t nbOfComp=self->getNumberOfComponents();
3252 mcIdType nbOfTuples=self->getNumberOfTuples();
3253 return convertCharArrToPyListOfTuple(vals,(int)nbOfComp,nbOfTuples);
3256 bool presenceOfTuple(PyObject *tupl) const
3258 if(PyString_Check(tupl))
3260 Py_ssize_t sz=PyString_Size(tupl);
3261 std::vector<char> vals(sz);
3262 std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin());
3263 return self->presenceOfTuple(vals);
3265 %#if PY_VERSION_HEX >= 0x03000000
3266 else if(PyUnicode_Check(tupl))
3268 Py_ssize_t sz=PyUnicode_GET_LENGTH(tupl);
3269 std::vector<char> vals(sz);
3270 std::copy(PyUnicode_AsUTF8(tupl),PyUnicode_AsUTF8(tupl)+sz,vals.begin());
3271 return self->presenceOfTuple(vals);
3275 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfTuple : only strings in input supported !");
3278 bool presenceOfValue(PyObject *vals) const
3280 if(PyString_Check(vals))
3282 Py_ssize_t sz=PyString_Size(vals);
3283 std::vector<char> vals2(sz);
3284 std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin());
3285 return self->presenceOfValue(vals2);
3287 %#if PY_VERSION_HEX >= 0x03000000
3288 if(PyUnicode_Check(vals))
3290 Py_ssize_t sz=PyUnicode_GET_LENGTH(vals);
3291 std::vector<char> vals2(sz);
3292 std::copy(PyUnicode_AsUTF8(vals),PyUnicode_AsUTF8(vals)+sz,vals2.begin());
3293 return self->presenceOfValue(vals2);
3297 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfValue : only strings in input supported !");
3300 mcIdType findIdFirstEqual(PyObject *vals) const
3302 if(PyString_Check(vals))
3304 Py_ssize_t sz=PyString_Size(vals);
3305 std::vector<char> vals2(sz);
3306 std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin());
3307 return self->findIdFirstEqual(vals2);
3309 %#if PY_VERSION_HEX >= 0x03000000
3310 if(PyUnicode_Check(vals))
3312 Py_ssize_t sz=PyUnicode_GET_LENGTH(vals);
3313 std::vector<char> vals2(sz);
3314 std::copy(PyUnicode_AsUTF8(vals),PyUnicode_AsUTF8(vals)+sz,vals2.begin());
3315 return self->findIdFirstEqual(vals2);
3319 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::findIdFirstEqual : only strings in input supported !");
3322 mcIdType findIdFirstEqualTuple(PyObject *tupl) const
3324 if(PyString_Check(tupl))
3326 Py_ssize_t sz=PyString_Size(tupl);
3327 std::vector<char> vals(sz);
3328 std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin());
3329 return self->findIdFirstEqualTuple(vals);
3331 %#if PY_VERSION_HEX >= 0x03000000
3332 if(PyUnicode_Check(tupl))
3334 Py_ssize_t sz=PyUnicode_GET_LENGTH(tupl);
3335 std::vector<char> vals(sz);
3336 std::copy(PyUnicode_AsUTF8(tupl),PyUnicode_AsUTF8(tupl)+sz,vals.begin());
3337 return self->findIdFirstEqualTuple(vals);
3341 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::findIdFirstEqualTuple : only strings in input supported !");
3344 mcIdType findIdSequence(PyObject *strOrListOfInt) const
3346 if(PyString_Check(strOrListOfInt))
3348 Py_ssize_t sz=PyString_Size(strOrListOfInt);
3349 std::vector<char> vals(sz);
3350 std::copy(PyString_AsString(strOrListOfInt),PyString_AsString(strOrListOfInt)+sz,vals.begin());
3351 return self->findIdSequence(vals);
3353 %#if PY_VERSION_HEX >= 0x03000000
3354 else if(PyUnicode_Check(strOrListOfInt))
3356 Py_ssize_t sz=PyUnicode_GET_LENGTH(strOrListOfInt);
3357 std::vector<char> vals(sz);
3358 std::copy(PyUnicode_AsUTF8(strOrListOfInt),PyUnicode_AsUTF8(strOrListOfInt)+sz,vals.begin());
3359 return self->findIdSequence(vals);
3363 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::search : only strings in input supported !");
3366 PyObject *getTuple(mcIdType tupleId) const
3368 std::size_t sz=self->getNumberOfComponents();
3369 INTERP_KERNEL::AutoPtr<char> tmp=new char[sz+1]; tmp[sz]='\0';
3370 self->getTuple(tupleId,tmp);
3371 return PyString_FromString(tmp);
3374 PyObject *getMaxValue() const
3377 char tmp2[2]; tmp2[1]='\0';
3378 tmp2[0]=self->getMaxValue(tmp);
3379 PyObject *ret=PyTuple_New(2);
3380 PyTuple_SetItem(ret,0,PyString_FromString(tmp2));
3381 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
3385 PyObject *getMinValue() const
3388 char tmp2[2]; tmp2[1]='\0';
3389 tmp2[0]=self->getMinValue(tmp);
3390 PyObject *ret=PyTuple_New(2);
3391 PyTuple_SetItem(ret,0,PyString_FromString(tmp2));
3392 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
3396 mcIdType index(PyObject *obj) const
3398 std::size_t nbOfCompo=self->getNumberOfComponents();
3403 if(PyString_Check(obj))
3405 Py_ssize_t sz=PyString_Size(obj);
3406 char *pt=PyString_AsString(obj);
3408 return self->findIdFirstEqual(pt[0]);
3410 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find a string with size different from 1 !");
3412 %#if PY_VERSION_HEX >= 0x03000000
3413 if(PyUnicode_Check(obj))
3416 const char *pt=PyUnicode_AsUTF8AndSize(obj, &sz);
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 !");
3424 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find an element which is not an integer !");
3427 return MEDCoupling_DataArrayAsciiChar_findIdFirstEqualTuple(self,obj);
3431 bool __contains__(PyObject *obj) const
3433 std::size_t nbOfCompo=self->getNumberOfComponents();
3440 if(PyString_Check(obj))
3442 Py_ssize_t sz=PyString_Size(obj);
3443 char *pt=PyString_AsString(obj);
3445 return self->presenceOfValue(pt[0]);
3447 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find a string with size different from 1 !");
3449 %#if PY_VERSION_HEX >= 0x03000000
3450 if(PyUnicode_Check(obj))
3453 const char *pt=PyUnicode_AsUTF8AndSize(obj, &sz);
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 !");
3461 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
3464 return MEDCoupling_DataArrayAsciiChar_presenceOfTuple(self,obj);
3468 PyObject *__getitem__(PyObject *obj) const
3470 mcIdType sw,iTypppArr;
3471 std::vector<mcIdType> stdvecTyyppArr;
3472 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > sTyyppArr;
3473 MEDCoupling::DataArrayIdType *daIntTyypp=0;
3474 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,self->getNumberOfTuples(),sw,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp);
3478 return MEDCoupling_DataArrayAsciiChar_getTuple(self,iTypppArr);
3480 return convertDataArrayChar(self->selectByTupleIdSafe(&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size()), SWIG_POINTER_OWN | 0 );
3482 return convertDataArrayChar(self->selectByTupleIdSafeSlice(sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second), SWIG_POINTER_OWN | 0 );
3484 return convertDataArrayChar(self->selectByTupleIdSafe(daIntTyypp->begin(),daIntTyypp->end()), SWIG_POINTER_OWN | 0 );
3486 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__getitem__ : supporting int, list of int, tuple of int, DataArrayIdType and slice in input !");
3490 DataArrayAsciiChar *__setitem__(PyObject *obj, PyObject *value)
3492 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.";
3493 mcIdType sw1,iTypppArr;
3494 std::vector<mcIdType> stdvecTyyppArr;
3495 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > sTyyppArr;
3496 MEDCoupling::DataArrayIdType *daIntTyypp=0;
3497 mcIdType nbOfCompo=ToIdType(self->getNumberOfComponents());
3498 mcIdType nbOfTuples=self->getNumberOfTuples();
3499 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbOfTuples,sw1,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp);
3501 char vc; std::string sc; std::vector<std::string> vsc; DataArrayChar *dacc=0;
3502 convertObjToPossibleCpp6(value,sw2,vc,sc,vsc,dacc);
3511 self->setPartOfValuesSimple3(vc,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1);
3517 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3518 self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3521 //value vector<string>
3524 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3525 self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3528 //value DataArrayChar
3531 self->setPartOfValues3(dacc,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3535 throw INTERP_KERNEL::Exception(msg);
3539 {//obj list-tuple[int]
3545 self->setPartOfValuesSimple3(vc,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1);
3551 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3552 self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3555 //value vector<string>
3558 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3559 self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3562 //value DataArrayChar
3565 self->setPartOfValues3(dacc,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3569 throw INTERP_KERNEL::Exception(msg);
3580 self->setPartOfValuesSimple1(vc,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1);
3586 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3587 self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3590 //value vector<string>
3593 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3594 self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3597 //value DataArrayChar
3600 self->setPartOfValues1(dacc,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3604 throw INTERP_KERNEL::Exception(msg);
3615 self->setPartOfValuesSimple3(vc,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1);
3621 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3622 self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3625 //value vector<string>
3628 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3629 self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3632 //value DataArrayChar
3635 self->setPartOfValues3(dacc,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3639 throw INTERP_KERNEL::Exception(msg);
3644 throw INTERP_KERNEL::Exception(msg);
3650 class DataArrayAsciiCharTuple;
3652 class DataArrayAsciiCharIterator
3655 DataArrayAsciiCharIterator(DataArrayAsciiChar *da);
3656 ~DataArrayAsciiCharIterator();
3661 DataArrayAsciiCharTuple *ret=self->nextt();
3663 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayAsciiCharTuple,SWIG_POINTER_OWN | 0);
3666 PyErr_SetString(PyExc_StopIteration,"No more data.");
3673 class DataArrayAsciiCharTuple
3676 std::size_t getNumberOfCompo() const;
3677 DataArrayAsciiChar *buildDAAsciiChar(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
3680 std::string __str__() const
3682 return self->repr();
3685 DataArrayAsciiChar *buildDAAsciiChar()
3687 return self->buildDAAsciiChar(1,self->getNumberOfCompo());
3693 %include "DataArrayInt.i"
3696 def MEDCouplingStdReduceFunct(cls,params):
3698 ret=object.__new__(cls)
3703 def MEDCouplingDataArrayDoubleReduce(self):
3704 if not MEDCouplingHasNumPyBindings():
3705 raise InterpKernelException("PyWrap of DataArrayDouble.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3706 return MEDCouplingStdReduceFunct,(DataArrayDouble,((self.toNumPyArray(),),(self.__getstate__()),))
3708 def MEDCouplingDataArrayInt32Reduce(self):
3709 if not MEDCouplingHasNumPyBindings():
3710 raise InterpKernelException("PyWrap of DataArrayIdType.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3711 return MEDCouplingStdReduceFunct,(DataArrayInt32,((self.toNumPyArray(),),(self.__getstate__()),))
3713 def MEDCouplingDataArrayInt64Reduce(self):
3714 if not MEDCouplingHasNumPyBindings():
3715 raise InterpKernelException("PyWrap of DataArrayIdType.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3716 return MEDCouplingStdReduceFunct,(DataArrayInt64,((self.toNumPyArray(),),(self.__getstate__()),))
3718 def MEDCouplingDataArrayByteReduce(self):
3719 if not MEDCouplingHasNumPyBindings():
3720 raise InterpKernelException("PyWrap of DataArrayByte.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3721 return MEDCouplingStdReduceFunct,(DataArrayByte,((self.toNumPyArray(),),(self.__getstate__()),))
3723 def MEDCouplingDataArrayFloatReduce(self):
3724 if not MEDCouplingHasNumPyBindings():
3725 raise InterpKernelException("PyWrap of DataArrayFloat.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3726 return MEDCouplingStdReduceFunct,(DataArrayFloat,((self.toNumPyArray(),),(self.__getstate__()),))
3728 if MEDCouplingUse64BitIDs():
3729 DataArrayInt=DataArrayInt64
3731 DataArrayInt=DataArrayInt32