1 // Copyright (C) 2007-2019 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 return PySlice_New(PyInt_FromLong(a),PyInt_FromLong(b),PyInt_FromLong(step));
680 PyObject *getSlice(PyObject *slic, mcIdType sliceId, mcIdType nbOfSlices) const
682 if(!PySlice_Check(slic))
683 throw INTERP_KERNEL::Exception("DataArray::getSlice (wrap) : expecting a pyslice as second (first) parameter !");
684 Py_ssize_t strt=2,stp=2,step=2;
685 GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getSlice (wrap) : the input slice is invalid !");
687 DataArray::GetSlice(ToIdType(strt),ToIdType(stp),ToIdType(step),sliceId,nbOfSlices,a,b);
688 return PySlice_New(PyInt_FromLong(a),PyInt_FromLong(b),PyInt_FromLong(step));
691 static mcIdType GetNumberOfItemGivenBES(PyObject *slic)
693 if(!PySlice_Check(slic))
694 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBES (wrap) : expecting a pyslice as second (first) parameter !");
695 Py_ssize_t strt=2,stp=2,step=2;
696 GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetNumberOfItemGivenBES (wrap) : the input slice is invalid !");
697 return DataArray::GetNumberOfItemGivenBES(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
700 static mcIdType GetNumberOfItemGivenBESRelative(PyObject *slic)
702 if(!PySlice_Check(slic))
703 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBESRelative (wrap) : expecting a pyslice as second (first) parameter !");
704 Py_ssize_t strt=2,stp=2,step=2;
705 GetIndicesOfSliceExplicitely(slic,&strt,&stp,&step,"DataArray::GetNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !");
706 return DataArray::GetNumberOfItemGivenBESRelative(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
709 static DataArray *Aggregate(PyObject *arrs)
711 std::vector<const DataArray *> tmp;
712 convertFromPyObjVectorOfObj<const MEDCoupling::DataArray *>(arrs,SWIGTYPE_p_MEDCoupling__DataArray,"DataArray",tmp);
713 return DataArray::Aggregate(tmp);
716 mcIdType getNumberOfItemGivenBES(PyObject *slic) const
718 if(!PySlice_Check(slic))
719 throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBES (wrap) : expecting a pyslice as second (first) parameter !");
720 Py_ssize_t strt=2,stp=2,step=2;
721 GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getNumberOfItemGivenBES (wrap) : the input slice is invalid !");
722 return DataArray::GetNumberOfItemGivenBES(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
725 mcIdType getNumberOfItemGivenBESRelative(PyObject *slic)
727 if(!PySlice_Check(slic))
728 throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBESRelative (wrap) : expecting a pyslice as second (first) parameter !");
729 Py_ssize_t strt=2,stp=2,step=2;
730 GetIndicesOfSlice(slic,self->getNumberOfTuples(),&strt,&stp,&step,"DataArray::getNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !");
731 return DataArray::GetNumberOfItemGivenBESRelative(ToIdType(strt),ToIdType(stp),ToIdType(step),"");
734 PyObject *__getstate__() const
736 PyObject *ret(PyTuple_New(2));
737 std::string a0(self->getName());
738 const std::vector<std::string> &a1(self->getInfoOnComponents());
739 PyTuple_SetItem(ret,0,PyString_FromString(a0.c_str()));
741 std::size_t sz(a1.size());
742 PyObject *ret1(PyList_New(sz));
743 for(std::size_t i=0;i<sz;i++)
744 PyList_SetItem(ret1,i,PyString_FromString(a1[i].c_str()));
745 PyTuple_SetItem(ret,1,ret1);
750 void __setstate__(PyObject *inp)
752 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 !";
753 if(!PyTuple_Check(inp))
754 throw INTERP_KERNEL::Exception("DataArrayDouble.__setstate__ : invalid input ! Invalid overwrite of __getstate__ ?");
755 std::size_t sz(PyTuple_Size(inp));
757 throw INTERP_KERNEL::Exception("DataArrayDouble.__setstate__ : invalid tuple in input ! Should be of size 2 ! Invalid overwrite of __getstate__ ?");
758 PyObject *a0(PyTuple_GetItem(inp,0));
759 self->setName(convertPyObjectToStr(a0,MSG));
760 PyObject *a1(PyTuple_GetItem(inp,1));
761 std::vector<std::string> a1cpp;
762 if(!fillStringVector(a1,a1cpp))
763 throw INTERP_KERNEL::Exception(MSG);
764 self->setInfoOnComponents(a1cpp);
769 class DataArrayDouble;
771 class DataArrayFloat : public DataArray
774 static DataArrayFloat *New();
775 void fillWithValue(float val);
776 bool isEqual(const DataArrayFloat& other, float prec) const;
777 bool isEqualWithoutConsideringStr(const DataArrayFloat& other, float prec) const;
778 bool isUniform(float val, float eps) const;
779 void pushBackSilent(float val);
780 void iota(float init=0.);
781 DataArrayFloatIterator *iterator();
782 MCAuto<DataArrayDouble> convertToDblArr() const;
783 static DataArrayFloat *Meld(const DataArrayFloat *a1, const DataArrayFloat *a2);
788 return DataArrayFloat::New();
791 static DataArrayFloat *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
793 return DataArrayT_New<float>(elt0,nbOfTuples,elt2);
796 DataArrayFloat(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
798 return MEDCoupling_DataArrayFloat_New__SWIG_1(elt0,nbOfTuples,elt2);
801 DataArrayFloatIterator *__iter__()
803 return self->iterator();
806 std::string __repr__() const
808 std::ostringstream oss;
809 self->reprQuickOverview(oss);
813 std::string __str__() const
815 return self->reprNotTooLong();
818 mcIdType __len__() const
820 if(self->isAllocated())
822 return self->getNumberOfTuples();
826 throw INTERP_KERNEL::Exception("DataArrayFloat::__len__ : Instance is NOT allocated !");
830 PyObject *getValues() const
832 const float *vals(self->begin());
833 return convertDblArrToPyList<float>(vals,self->getNbOfElems());
836 PyObject *getValuesAsTuple() const
838 const float *vals(self->begin());
839 std::size_t nbOfComp(self->getNumberOfComponents());
840 mcIdType nbOfTuples(self->getNumberOfTuples());
841 return convertDblArrToPyListOfTuple<float>(vals,nbOfComp,nbOfTuples);
844 PyObject *isEqualIfNotWhy(const DataArrayFloat& other, float prec) const
847 bool ret0=self->isEqualIfNotWhy(other,prec,ret1);
848 PyObject *ret=PyTuple_New(2);
849 PyObject *ret0Py=ret0?Py_True:Py_False;
851 PyTuple_SetItem(ret,0,ret0Py);
852 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
856 PyObject *__getitem__(PyObject *obj)
858 return DataArrayT__getitem<float>(self,obj);
861 DataArrayFloat *__setitem__(PyObject *obj, PyObject *value)
863 return DataArrayT__setitem__<float>(self,obj,value);
866 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
868 return DataArrayT_iadd<float>(trueSelf,obj,self);
871 PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
873 return DataArrayT_isub<float>(trueSelf,obj,self);
876 PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
878 return DataArrayT_imul<float>(trueSelf,obj,self);
881 DataArrayFloat *__rmul__(PyObject *obj)
883 return DataArrayFPT_rmul<float>(self,obj);
886 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
888 return DataArrayT_idiv<float>(trueSelf,obj,self);
892 PyObject *toNumPyArray() // not const. It is not a bug !
894 return ToNumPyArray<DataArrayFloat,float>(self,NPY_FLOAT,"DataArrayFloat");
900 class DataArrayFloatTuple;
902 class DataArrayFloatIterator
905 DataArrayFloatIterator(DataArrayFloat *da);
906 ~DataArrayFloatIterator();
911 DataArrayFloatTuple *ret=self->nextt();
913 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayFloatTuple,SWIG_POINTER_OWN|0);
916 PyErr_SetString(PyExc_StopIteration,"No more data.");
923 class DataArrayFloatTuple
926 std::size_t getNumberOfCompo() const;
927 DataArrayFloat *buildDAFloat(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
930 std::string __str__() const
935 float __float__() const
937 return self->floatValue();
940 DataArrayFloat *buildDAFloat()
942 return self->buildDAFloat(1,self->getNumberOfCompo());
945 /*PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
947 MCAuto<DataArrayFloat> ret=self->buildDAFloat(1,self->getNumberOfCompo());
948 MEDCoupling_DataArrayFloat____imul___(ret,0,obj);
949 Py_XINCREF(trueSelf);
955 return PyInt_FromLong(self->getNumberOfCompo());
960 class DataArrayDoubleIterator;
962 class DataArrayDouble : public DataArray
965 static DataArrayDouble *New();
966 double doubleValue() const;
968 void aggregate(const DataArrayDouble *other);
969 DataArrayDouble *performCopyOrIncrRef(bool deepCopy) const;
970 void deepCopyFrom(const DataArrayDouble& other);
971 void reserve(std::size_t nbOfElems);
972 void pushBackSilent(double val);
973 double popBackSilent();
975 void allocIfNecessary(int nbOfTuple, int nbOfCompo);
977 void fillWithValue(double val);
978 void iota(double init=0.);
979 bool isUniform(double val, double eps) const;
980 void sort(bool asc=true);
982 void checkMonotonic(bool increasing, double eps) const;
983 bool isMonotonic(bool increasing, double eps) const;
984 std::string repr() const;
985 std::string reprZip() const;
986 std::string reprNotTooLong() const;
987 bool isEqual(const DataArrayDouble& other, double prec) const;
988 bool isEqualWithoutConsideringStr(const DataArrayDouble& other, double prec) const;
989 DataArrayDouble *fromNoInterlace() const;
990 DataArrayDouble *toNoInterlace() const;
991 DataArrayDouble *subArray(int tupleIdBg, int tupleIdEnd=-1) const;
993 DataArrayDouble *changeNbOfComponents(std::size_t newNbOfComp, double dftValue) const;
994 void meldWith(const DataArrayDouble *other);
995 DataArrayDouble *duplicateEachTupleNTimes(int nbTimes) const;
996 DataArrayDouble *getDifferentValues(double prec, int limitTupleId=-1) const;
997 DataArrayIdType *findClosestTupleId(const DataArrayDouble *other) const;
998 DataArrayIdType *computeNbOfInteractionsWith(const DataArrayDouble *otherBBoxFrmt, double eps) const;
999 void setPartOfValues1(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare=true);
1000 void setPartOfValuesSimple1(double a, mcIdType bgTuples, mcIdType endTuples, mcIdType stepTuples, mcIdType bgComp, mcIdType endComp, mcIdType stepComp);
1001 void setPartOfValuesAdv(const DataArrayDouble *a, const DataArrayIdType *tuplesSelec);
1002 double getIJ(int tupleId, int compoId) const;
1003 double front() const;
1004 double back() const;
1005 double getIJSafe(int tupleId, int compoId) const;
1006 void setIJ(int tupleId, int compoId, double newVal);
1007 void setIJSilent(int tupleId, int compoId, double newVal);
1008 double *getPointer();
1009 void checkNoNullValues() const;
1010 DataArrayDouble *computeBBoxPerTuple(double epsilon=0.0) const;
1011 void recenterForMaxPrecision(double eps);
1012 double getMaxValueInArray() const;
1013 double getMaxAbsValueInArray() const;
1014 double getMinValueInArray() const;
1015 int count(double value, double eps) const;
1016 double getAverageValue() const;
1017 double norm2() const;
1018 double normMax() const;
1019 double normMin() const;
1020 double accumulate(int compId) const;
1021 DataArrayDouble *fromPolarToCart() const;
1022 DataArrayDouble *fromCylToCart() const;
1023 DataArrayDouble *fromSpherToCart() const;
1024 DataArrayDouble *fromCartToPolar() const;
1025 DataArrayDouble *fromCartToCyl() const;
1026 DataArrayDouble *fromCartToSpher() const;
1027 DataArrayDouble *cartesianize(MEDCouplingAxisType atOfThis) const;
1028 DataArrayDouble *doublyContractedProduct() const;
1029 DataArrayDouble *determinant() const;
1030 DataArrayDouble *eigenValues() const;
1031 DataArrayDouble *eigenVectors() const;
1032 DataArrayDouble *inverse() const;
1033 DataArrayDouble *trace() const;
1034 DataArrayDouble *deviator() const;
1035 DataArrayDouble *magnitude() const;
1036 DataArrayDouble *maxPerTuple() const;
1037 DataArrayDouble *sumPerTuple() const;
1038 DataArrayDouble *buildEuclidianDistanceDenseMatrix() const;
1039 DataArrayDouble *buildEuclidianDistanceDenseMatrixWith(const DataArrayDouble *other) const;
1040 void sortPerTuple(bool asc);
1042 DataArrayDouble *computeAbs() const;
1043 void applyLin(double a, double b, int compoId);
1044 void applyLin(double a, double b);
1045 void applyInv(double numerator);
1046 void applyPow(double val);
1047 void applyRPow(double val);
1048 DataArrayDouble *negate() const;
1049 DataArrayDouble *applyFunc(int nbOfComp, FunctionToEvaluate func) const;
1050 DataArrayDouble *applyFunc(int nbOfComp, const std::string& func, bool isSafe=true) const;
1051 DataArrayDouble *applyFunc(const std::string& func, bool isSafe=true) const;
1052 void applyFuncOnThis(const std::string& func, bool isSafe=true);
1053 DataArrayDouble *applyFuncCompo(int nbOfComp, const std::string& func, bool isSafe=true) const;
1054 DataArrayDouble *applyFuncNamedCompo(int nbOfComp, const std::vector<std::string>& varsOrder, const std::string& func, bool isSafe=true) const;
1055 void applyFuncFast32(const std::string& func);
1056 void applyFuncFast64(const std::string& func);
1057 DataArrayIdType *findIdsInRange(double vmin, double vmax) const;
1058 DataArrayIdType *findIdsNotInRange(double vmin, double vmax) const;
1059 DataArrayIdType *findIdsStrictlyNegative() const;
1060 static DataArrayDouble *Aggregate(const DataArrayDouble *a1, const DataArrayDouble *a2);
1061 static DataArrayDouble *Meld(const DataArrayDouble *a1, const DataArrayDouble *a2);
1062 static DataArrayDouble *Dot(const DataArrayDouble *a1, const DataArrayDouble *a2);
1063 static DataArrayDouble *CrossProduct(const DataArrayDouble *a1, const DataArrayDouble *a2);
1064 static DataArrayDouble *Max(const DataArrayDouble *a1, const DataArrayDouble *a2);
1065 static DataArrayDouble *Min(const DataArrayDouble *a1, const DataArrayDouble *a2);
1066 static DataArrayDouble *Add(const DataArrayDouble *a1, const DataArrayDouble *a2);
1067 void addEqual(const DataArrayDouble *other);
1068 static DataArrayDouble *Substract(const DataArrayDouble *a1, const DataArrayDouble *a2);
1069 void substractEqual(const DataArrayDouble *other);
1070 static DataArrayDouble *Multiply(const DataArrayDouble *a1, const DataArrayDouble *a2);
1071 void multiplyEqual(const DataArrayDouble *other);
1072 static DataArrayDouble *Divide(const DataArrayDouble *a1, const DataArrayDouble *a2);
1073 void divideEqual(const DataArrayDouble *other);
1074 static DataArrayDouble *Pow(const DataArrayDouble *a1, const DataArrayDouble *a2);
1075 void powEqual(const DataArrayDouble *other);
1076 MCAuto<DataArrayIdType> findIdsGreaterOrEqualTo(double val) const;
1077 MCAuto<DataArrayIdType> findIdsGreaterThan(double val) const;
1078 MCAuto<DataArrayIdType> findIdsLowerOrEqualTo(double val) const;
1079 MCAuto<DataArrayIdType> findIdsLowerThan(double val) const;
1080 MCAuto<DataArrayInt32> convertToIntArr() const;
1081 MCAuto<DataArrayDouble> selectPartDef(const PartDefinition* pd) const;
1082 MCAuto<DataArrayDouble> cumSum() const;
1083 MCAuto<DataArrayFloat> convertToFloatArr() const;
1088 return DataArrayDouble::New();
1091 static DataArrayDouble *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
1093 return DataArrayT_New<double>(elt0,nbOfTuples,elt2);
1096 DataArrayDouble(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0)
1098 return MEDCoupling_DataArrayDouble_New__SWIG_1(elt0,nbOfTuples,elt2);
1101 void pushBackValsSilent(PyObject *li)
1104 std::vector<double> bb;
1105 mcIdType sw; mcIdType nbTuples=-1;
1106 const char msg[]="Python wrap of DataArrayDouble::pushBackValsSilent : ";
1107 const double *tmp=convertObjToPossibleCpp5_SingleCompo(li,sw,val,bb,msg,true,nbTuples);
1108 self->pushBackValsSilent(tmp,tmp+nbTuples);
1111 std::string __repr__() const
1113 std::ostringstream oss;
1114 self->reprQuickOverview(oss);
1118 std::string __str__() const
1120 return self->reprNotTooLong();
1123 double __float__() const
1125 return self->doubleValue();
1128 mcIdType __len__() const
1130 if(self->isAllocated())
1132 return self->getNumberOfTuples();
1136 throw INTERP_KERNEL::Exception("DataArrayDouble::__len__ : Instance is NOT allocated !");
1140 PyObject *asArcOfCircle() const
1142 double center[2],radius,ang;
1143 self->asArcOfCircle(center,radius,ang);
1144 PyObject *ret(PyTuple_New(3));
1146 PyObject *ret0(PyList_New(2));
1147 PyList_SetItem(ret0,0,PyFloat_FromDouble(center[0]));
1148 PyList_SetItem(ret0,1,PyFloat_FromDouble(center[1]));
1149 PyTuple_SetItem(ret,0,ret0);
1151 PyTuple_SetItem(ret,1,PyFloat_FromDouble(radius));
1152 PyTuple_SetItem(ret,2,PyFloat_FromDouble(ang));
1156 DataArrayDoubleIterator *__iter__()
1158 return self->iterator();
1161 void setValues(PyObject *li, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
1163 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 !";
1164 if(PyList_Check(li) || PyTuple_Check(li))
1166 if(nbOfTuples && nbOfTuples != Py_None)
1168 if(PyInt_Check(nbOfTuples))
1170 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
1172 throw INTERP_KERNEL::Exception("DataArrayDouble::setValues : should be a positive set of allocated memory !");
1173 if(nbOfComp && nbOfComp != Py_None)
1175 if(PyInt_Check(nbOfComp))
1176 {//DataArrayDouble.setValues([1.,3.,4.,5.],2,2)
1177 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
1179 throw INTERP_KERNEL::Exception("DataArrayDouble::setValues : should be a positive number of components !");
1180 std::vector<double> tmp=fillArrayWithPyListDbl2(li,nbOfTuples1,nbOfCompo);
1181 self->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1184 throw INTERP_KERNEL::Exception(msg);
1187 {//DataArrayDouble.setValues([1.,3.,4.],3)
1189 std::vector<double> tmp=fillArrayWithPyListDbl2(li,nbOfTuples1,tmpp1);
1190 self->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1194 throw INTERP_KERNEL::Exception(msg);
1197 {// DataArrayDouble.setValues([1.,3.,4.])
1198 mcIdType tmpp1=-1,tmpp2=-1;
1199 std::vector<double> tmp=fillArrayWithPyListDbl2(li,tmpp1,tmpp2);
1200 self->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),self->getPointer());
1204 throw INTERP_KERNEL::Exception(msg);
1207 PyObject *getValues() const
1209 const double *vals(self->begin());
1210 return convertDblArrToPyList<double>(vals,self->getNbOfElems());
1214 PyObject *toNumPyArray() // not const. It is not a bug !
1216 return ToNumPyArray<DataArrayDouble,double>(self,NPY_DOUBLE,"DataArrayDouble");
1220 PyObject *isEqualIfNotWhy(const DataArrayDouble& other, double prec) const
1223 bool ret0=self->isEqualIfNotWhy(other,prec,ret1);
1224 PyObject *ret=PyTuple_New(2);
1225 PyObject *ret0Py=ret0?Py_True:Py_False;
1227 PyTuple_SetItem(ret,0,ret0Py);
1228 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
1232 PyObject *getValuesAsTuple() const
1234 const double *vals(self->begin());
1235 std::size_t nbOfComp(self->getNumberOfComponents());
1236 mcIdType nbOfTuples(self->getNumberOfTuples());
1237 return convertDblArrToPyListOfTuple<double>(vals,nbOfComp,nbOfTuples);
1240 static PyObject *ComputeIntegralOfSeg2IntoTri3(PyObject *seg2, PyObject *tri3)
1242 const char msg[]="Python wrap of DataArrayDouble::ComputeIntegralOfSeg2IntoTri3 : ";
1244 DataArrayDouble *a,*a2;
1245 DataArrayDoubleTuple *aa,*aa2;
1246 std::vector<double> bb,bb2;
1248 const double *seg2Ptr(convertObjToPossibleCpp5_Safe(seg2,sw,val,a,aa,bb,msg,2,2,true));
1249 const double *tri3Ptr(convertObjToPossibleCpp5_Safe(tri3,sw,val2,a2,aa2,bb2,msg,3,2,true));
1251 double res0[3],res1;
1252 DataArrayDouble::ComputeIntegralOfSeg2IntoTri3(seg2Ptr,tri3Ptr,res0,res1);
1253 PyObject *ret(PyTuple_New(2)),*ret0(PyTuple_New(3));
1254 PyTuple_SetItem(ret0,0,PyFloat_FromDouble(res0[0]));
1255 PyTuple_SetItem(ret0,1,PyFloat_FromDouble(res0[1]));
1256 PyTuple_SetItem(ret0,2,PyFloat_FromDouble(res0[2]));
1257 PyTuple_SetItem(ret,0,ret0);
1258 PyTuple_SetItem(ret,1,PyFloat_FromDouble(res1));
1262 DataArrayDouble *symmetry3DPlane(PyObject *point, PyObject *normalVector)
1264 const char msg[]="Python wrap of DataArrayDouble::symmetry3DPlane : ";
1266 DataArrayDouble *a,*a2;
1267 DataArrayDoubleTuple *aa,*aa2;
1268 std::vector<double> bb,bb2;
1270 const double *centerPtr(convertObjToPossibleCpp5_Safe(point,sw,val,a,aa,bb,msg,1,3,true));
1271 const double *vectorPtr(convertObjToPossibleCpp5_Safe(normalVector,sw,val2,a2,aa2,bb2,msg,1,3,true));
1272 MCAuto<DataArrayDouble> ret(self->symmetry3DPlane(centerPtr,vectorPtr));
1276 static PyObject *GiveBaseForPlane(PyObject *normalVector)
1278 const char msg[]="Python wrap of DataArrayDouble::GiveBaseForPlane : ";
1281 DataArrayDoubleTuple *aa;
1282 std::vector<double> bb,bb2;
1284 const double *vectorPtr(convertObjToPossibleCpp5_Safe(normalVector,sw,val,a,aa,bb,msg,1,3,true));
1286 DataArrayDouble::GiveBaseForPlane(vectorPtr,res);
1287 return convertDblArrToPyListOfTuple<double>(res,3,3);
1290 DataArrayDouble *fromCartToCylGiven(const DataArrayDouble *coords, PyObject *center, PyObject *vector) const
1292 const char msg[]="Python wrap of DataArrayDouble::fromCartToCylGiven : ";
1294 DataArrayDouble *a,*a2;
1295 DataArrayDoubleTuple *aa,*aa2;
1296 std::vector<double> bb,bb2;
1298 const double *centerPtr=convertObjToPossibleCpp5_Safe(center,sw,val,a,aa,bb,msg,1,3,true);
1299 const double *vectorPtr=convertObjToPossibleCpp5_Safe(vector,sw,val2,a2,aa2,bb2,msg,1,3,true);
1300 return self->fromCartToCylGiven(coords,centerPtr,vectorPtr);
1303 DataArrayDouble *renumber(PyObject *li)
1306 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
1307 if (!SWIG_IsOK(res1))
1310 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1311 if(size!=self->getNumberOfTuples())
1313 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1315 return self->renumber(tmp);
1319 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1321 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1322 da2->checkAllocated();
1323 mcIdType size=self->getNumberOfTuples();
1324 if(size!=self->getNumberOfTuples())
1326 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1328 return self->renumber(da2->getConstPointer());
1332 DataArrayDouble *renumberR(PyObject *li)
1335 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
1336 if (!SWIG_IsOK(res1))
1339 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1340 if(size!=self->getNumberOfTuples())
1342 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1344 return self->renumberR(tmp);
1348 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1350 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1351 da2->checkAllocated();
1352 mcIdType size=self->getNumberOfTuples();
1353 if(size!=self->getNumberOfTuples())
1355 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1357 return self->renumberR(da2->getConstPointer());
1361 DataArrayDouble *renumberAndReduce(PyObject *li, mcIdType newNbOfTuple)
1364 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
1365 if (!SWIG_IsOK(res1))
1368 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
1369 if(size!=self->getNumberOfTuples())
1371 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1373 return self->renumberAndReduce(tmp,newNbOfTuple);
1377 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
1379 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
1380 da2->checkAllocated();
1381 mcIdType size=self->getNumberOfTuples();
1382 if(size!=self->getNumberOfTuples())
1384 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
1386 return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
1390 PyObject *minimalDistanceTo(const DataArrayDouble *other) const
1392 mcIdType thisTupleId,otherTupleId;
1393 double r0=self->minimalDistanceTo(other,thisTupleId,otherTupleId);
1394 PyObject *ret=PyTuple_New(3);
1395 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r0));
1396 PyTuple_SetItem(ret,1,PyInt_FromLong(thisTupleId));
1397 PyTuple_SetItem(ret,2,PyInt_FromLong(otherTupleId));
1401 PyObject *getMaxValue() const
1404 double r1=self->getMaxValue(tmp);
1405 PyObject *ret=PyTuple_New(2);
1406 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1407 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1411 PyObject *getMaxAbsValue() const
1414 double r1=self->getMaxAbsValue(tmp);
1415 PyObject *ret=PyTuple_New(2);
1416 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1417 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1421 PyObject *getMaxValue2() const
1423 DataArrayIdType *tmp;
1424 double r1=self->getMaxValue2(tmp);
1425 PyObject *ret=PyTuple_New(2);
1426 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1427 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1431 PyObject *getMinValue() const
1434 double r1=self->getMinValue(tmp);
1435 PyObject *ret=PyTuple_New(2);
1436 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1437 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
1441 PyObject *getMinValue2() const
1443 DataArrayIdType *tmp;
1444 double r1=self->getMinValue2(tmp);
1445 PyObject *ret=PyTuple_New(2);
1446 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
1447 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1451 PyObject *getMinMaxPerComponent() const
1453 std::size_t nbOfCompo(self->getNumberOfComponents());
1454 INTERP_KERNEL::AutoPtr<double> tmp(new double[2*nbOfCompo]);
1455 self->getMinMaxPerComponent(tmp);
1456 PyObject *ret=convertDblArrToPyListOfTuple<double>(tmp,2,ToIdType(nbOfCompo));
1460 PyObject *normMaxPerComponent() const
1462 std::size_t nbOfCompo(self->getNumberOfComponents());
1463 INTERP_KERNEL::AutoPtr<double> tmp(new double[nbOfCompo]);
1464 self->normMaxPerComponent(tmp);
1465 return convertDblArrToPyList<double>(tmp,ToIdType(nbOfCompo));
1468 PyObject *accumulate() const
1470 std::size_t sz=self->getNumberOfComponents();
1471 INTERP_KERNEL::AutoPtr<double> tmp=new double[sz];
1472 self->accumulate(tmp);
1473 return convertDblArrToPyList<double>(tmp,ToIdType(sz));
1476 DataArrayDouble *accumulatePerChunck(PyObject *indexArr) const
1478 mcIdType sw, sz,val;
1479 std::vector<mcIdType> val2;
1480 const mcIdType *bg=convertIntStarLikePyObjToCppIntStar(indexArr,sw,sz,val,val2);
1481 return self->accumulatePerChunck(bg,bg+sz);
1484 PyObject *findCommonTuples(double prec, mcIdType limitNodeId=-1) const
1486 DataArrayIdType *comm, *commIndex;
1487 self->findCommonTuples(prec,limitNodeId,comm,commIndex);
1488 PyObject *res = PyList_New(2);
1489 PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(comm),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1490 PyList_SetItem(res,1,SWIG_NewPointerObj(SWIG_as_voidptr(commIndex),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1494 PyObject *distanceToTuple(PyObject *tuple) const
1498 DataArrayDoubleTuple *aa;
1499 std::vector<double> bb;
1501 mcIdType tupleId=-1;
1502 std::size_t nbOfCompo=self->getNumberOfComponents();
1503 const double *pt=convertObjToPossibleCpp5_Safe(tuple,sw,val,a,aa,bb,"Python wrap of DataArrayDouble::distanceToTuple",1,(int)nbOfCompo,true);
1505 double ret0=self->distanceToTuple(pt,pt+nbOfCompo,tupleId);
1506 PyObject *ret=PyTuple_New(2);
1507 PyTuple_SetItem(ret,0,PyFloat_FromDouble(ret0));
1508 PyTuple_SetItem(ret,1,PyInt_FromLong(tupleId));
1512 void setSelectedComponents(const DataArrayDouble *a, PyObject *li)
1514 std::vector<std::size_t> tmp;
1515 convertPyToNewIntArr3(li,tmp);
1516 self->setSelectedComponents(a,tmp);
1519 PyObject *explodeComponents() const
1521 std::vector< MCAuto<DataArrayDouble> > retCpp(self->explodeComponents());
1522 std::size_t sz(retCpp.size());
1523 PyObject *res(PyList_New(sz));
1524 for(std::size_t i=0;i<sz;i++)
1525 PyList_SetItem(res,i,SWIG_NewPointerObj(SWIG_as_voidptr(retCpp[i].retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ));
1529 PyObject *getTuple(mcIdType tupleId)
1531 std::size_t sz=self->getNumberOfComponents();
1532 INTERP_KERNEL::AutoPtr<double> tmp=new double[sz];
1533 self->getTuple(tupleId,tmp);
1534 return convertDblArrToPyList<double>(tmp,ToIdType(sz));
1537 static DataArrayDouble *Aggregate(PyObject *li)
1539 std::vector<const DataArrayDouble *> tmp;
1540 convertFromPyObjVectorOfObj<const DataArrayDouble *>(li,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",tmp);
1541 return DataArrayDouble::Aggregate(tmp);
1544 static DataArrayDouble *Meld(PyObject *li)
1546 std::vector<const DataArrayDouble *> tmp;
1547 convertFromPyObjVectorOfObj<const DataArrayDouble *>(li,SWIGTYPE_p_MEDCoupling__DataArrayDouble,"DataArrayDouble",tmp);
1548 return DataArrayDouble::Meld(tmp);
1551 PyObject *computeTupleIdsNearTuples(PyObject *pt, double eps) const
1555 DataArrayDoubleTuple *aa;
1556 std::vector<double> bb;
1558 std::size_t nbComp=self->getNumberOfComponents();
1559 mcIdType nbTuples=-1;
1560 const char msg[]="Python wrap of DataArrayDouble::computeTupleIdsNearTuples : ";
1561 const double *pos=convertObjToPossibleCpp5_Safe2(pt,sw,val,a,aa,bb,msg,(int)nbComp,true,nbTuples);
1562 MCAuto<DataArrayDouble> inpu=DataArrayDouble::New(); inpu->useArray(pos,false,DeallocType::CPP_DEALLOC,nbTuples,nbComp);
1563 DataArrayIdType *c=0,*cI=0;
1564 self->computeTupleIdsNearTuples(inpu,eps,c,cI);
1565 PyObject *ret=PyTuple_New(2);
1566 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1567 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1571 PyObject *areIncludedInMe(const DataArrayDouble *other, double prec) const
1573 DataArrayIdType *ret1=0;
1574 bool ret0=self->areIncludedInMe(other,prec,ret1);
1575 PyObject *ret=PyTuple_New(2);
1576 PyObject *ret0Py=ret0?Py_True:Py_False;
1578 PyTuple_SetItem(ret,0,ret0Py);
1579 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
1583 PyObject *__getitem__(PyObject *obj)
1585 return DataArrayT__getitem<double>(self,obj);
1588 DataArrayDouble *__setitem__(PyObject *obj, PyObject *value)
1590 return DataArrayT__setitem__<double>(self,obj,value);
1593 DataArrayDouble *__neg__() const
1595 return self->negate();
1598 PyObject *__add__(PyObject *obj)
1600 const char msg[]="Unexpected situation in DataArrayDouble.__add__ !";
1603 DataArrayDoubleTuple *aa;
1604 std::vector<double> bb;
1607 #ifndef WITHOUT_AUTOFIELD
1609 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1611 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1614 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1615 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___radd__Impl(other,tmp);
1617 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1620 throw INTERP_KERNEL::Exception(msg);
1624 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1629 MCAuto<DataArrayDouble> ret=self->deepCopy();
1630 ret->applyLin(1.,val);
1631 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1635 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1639 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1640 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1644 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1645 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1648 throw INTERP_KERNEL::Exception(msg);
1652 DataArrayDouble *__radd__(PyObject *obj)
1654 const char msg[]="Unexpected situation in __radd__ !";
1657 DataArrayDoubleTuple *aa;
1658 std::vector<double> bb;
1660 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1665 MCAuto<DataArrayDouble> ret=self->deepCopy();
1666 ret->applyLin(1.,val);
1671 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1672 return DataArrayDouble::Add(self,aaa);
1676 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1677 return DataArrayDouble::Add(self,aaa);
1680 throw INTERP_KERNEL::Exception(msg);
1684 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
1686 return DataArrayT_iadd<double>(trueSelf,obj,self);
1689 PyObject *__sub__(PyObject *obj)
1691 const char msg[]="Unexpected situation in __sub__ !";
1694 DataArrayDoubleTuple *aa;
1695 std::vector<double> bb;
1698 #ifndef WITHOUT_AUTOFIELD
1700 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1702 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1705 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1706 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rsub__Impl(other,tmp);
1708 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1711 throw INTERP_KERNEL::Exception(msg);
1715 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1720 MCAuto<DataArrayDouble> ret=self->deepCopy();
1721 ret->applyLin(1.,-val);
1722 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1726 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1730 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1731 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1735 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1736 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1739 throw INTERP_KERNEL::Exception(msg);
1743 DataArrayDouble *__rsub__(PyObject *obj)
1745 const char msg[]="Unexpected situation in __rsub__ !";
1748 DataArrayDoubleTuple *aa;
1749 std::vector<double> bb;
1751 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1756 MCAuto<DataArrayDouble> ret=self->deepCopy();
1757 ret->applyLin(-1.,val);
1762 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1763 return DataArrayDouble::Substract(aaa,self);
1767 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1768 return DataArrayDouble::Substract(aaa,self);
1771 throw INTERP_KERNEL::Exception(msg);
1775 PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
1777 return DataArrayT_isub<double>(trueSelf,obj,self);
1780 PyObject *__mul__(PyObject *obj)
1782 const char msg[]="Unexpected situation in __mul__ !";
1785 DataArrayDoubleTuple *aa;
1786 std::vector<double> bb;
1789 #ifndef WITHOUT_AUTOFIELD
1791 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1793 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1796 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1797 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rmul__Impl(other,tmp);
1799 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1802 throw INTERP_KERNEL::Exception(msg);
1806 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1811 MCAuto<DataArrayDouble> ret=self->deepCopy();
1812 ret->applyLin(val,0.);
1813 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1817 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1821 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1822 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1826 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1827 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1830 throw INTERP_KERNEL::Exception(msg);
1834 DataArrayDouble *__rmul__(PyObject *obj)
1836 return DataArrayFPT_rmul<double>(self,obj);
1839 PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
1841 return DataArrayT_imul<double>(trueSelf,obj,self);
1844 PyObject *__div__(PyObject *obj)
1846 const char msg[]="Unexpected situation in __div__ !";
1849 DataArrayDoubleTuple *aa;
1850 std::vector<double> bb;
1853 #ifndef WITHOUT_AUTOFIELD
1855 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble,0|0)))
1857 MEDCouplingFieldDouble *other=reinterpret_cast< MEDCoupling::MEDCouplingFieldDouble * >(argp);
1860 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_MEDCoupling__DataArrayDouble, 0 | 0 );
1861 MCAuto<MEDCouplingFieldDouble> ret=MEDCoupling_MEDCouplingFieldDouble___rdiv__Impl(other,tmp);
1863 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1866 throw INTERP_KERNEL::Exception(msg);
1870 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1876 throw INTERP_KERNEL::Exception("DataArrayDouble::__div__ : trying to divide by zero !");
1877 MCAuto<DataArrayDouble> ret=self->deepCopy();
1878 ret->applyLin(1/val,0.);
1879 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1883 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,a)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1887 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1888 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1892 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1893 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1896 throw INTERP_KERNEL::Exception(msg);
1900 DataArrayDouble *__rdiv__(PyObject *obj)
1902 const char msg[]="Unexpected situation in __rdiv__ !";
1905 DataArrayDoubleTuple *aa;
1906 std::vector<double> bb;
1908 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1913 MCAuto<DataArrayDouble> ret=self->deepCopy();
1919 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1920 return DataArrayDouble::Divide(aaa,self);
1924 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1925 return DataArrayDouble::Divide(aaa,self);
1928 throw INTERP_KERNEL::Exception(msg);
1932 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
1934 return DataArrayT_idiv<double>(trueSelf,obj,self);
1937 DataArrayDouble *__pow__(PyObject *obj)
1939 const char msg[]="Unexpected situation in __pow__ !";
1942 DataArrayDoubleTuple *aa;
1943 std::vector<double> bb;
1945 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1950 MCAuto<DataArrayDouble> ret=self->deepCopy();
1956 return DataArrayDouble::Pow(self,a);
1960 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1961 return DataArrayDouble::Pow(self,aaa);
1965 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1966 return DataArrayDouble::Pow(self,aaa);
1969 throw INTERP_KERNEL::Exception(msg);
1973 DataArrayDouble *__rpow__(PyObject *obj)
1975 const char msg[]="Unexpected situation in __rpow__ !";
1978 DataArrayDoubleTuple *aa;
1979 std::vector<double> bb;
1981 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
1986 MCAuto<DataArrayDouble> ret=self->deepCopy();
1987 ret->applyRPow(val);
1992 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1993 return DataArrayDouble::Pow(aaa,self);
1997 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
1998 return DataArrayDouble::Pow(aaa,self);
2001 throw INTERP_KERNEL::Exception(msg);
2005 PyObject *___ipow___(PyObject *trueSelf, PyObject *obj)
2007 const char msg[]="Unexpected situation in __ipow__ !";
2010 DataArrayDoubleTuple *aa;
2011 std::vector<double> bb;
2013 convertDoubleStarLikePyObjToCpp_2(obj,sw,val,a,aa,bb);
2018 self->applyPow(val);
2019 Py_XINCREF(trueSelf);
2025 Py_XINCREF(trueSelf);
2030 MCAuto<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
2031 self->powEqual(aaa);
2032 Py_XINCREF(trueSelf);
2037 MCAuto<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,DeallocType::CPP_DEALLOC,1,bb.size());
2038 self->powEqual(aaa);
2039 Py_XINCREF(trueSelf);
2043 throw INTERP_KERNEL::Exception(msg);
2047 PyObject *computeTupleIdsNearTuples(const DataArrayDouble *other, double eps)
2049 DataArrayIdType *c=0,*cI=0;
2051 self->computeTupleIdsNearTuples(other,eps,c,cI);
2052 PyObject *ret=PyTuple_New(2);
2053 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2054 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2058 PyObject *maxPerTupleWithCompoId() const
2060 DataArrayIdType *ret1=0;
2061 DataArrayDouble *ret0=self->maxPerTupleWithCompoId(ret1);
2062 PyObject *ret=PyTuple_New(2);
2063 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_MEDCoupling__DataArrayDouble, SWIG_POINTER_OWN | 0 ));
2064 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTITraits<mcIdType>::TI, SWIG_POINTER_OWN | 0 ));
2070 class DataArrayDoubleTuple;
2072 class DataArrayDoubleIterator
2075 DataArrayDoubleIterator(DataArrayDouble *da);
2076 ~DataArrayDoubleIterator();
2081 DataArrayDoubleTuple *ret=self->nextt();
2083 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayDoubleTuple,SWIG_POINTER_OWN|0);
2086 PyErr_SetString(PyExc_StopIteration,"No more data.");
2093 class DataArrayDoubleTuple
2096 std::size_t getNumberOfCompo() const;
2097 DataArrayDouble *buildDADouble(int nbOfTuples, int nbOfCompo) const;
2100 std::string __str__() const
2102 return self->repr();
2105 double __float__() const
2107 return self->doubleValue();
2110 DataArrayDouble *buildDADouble()
2112 return self->buildDADouble(1,self->getNumberOfCompo());
2115 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj)
2117 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2118 MEDCoupling_DataArrayDouble____iadd___(ret,0,obj);
2119 Py_XINCREF(trueSelf);
2123 PyObject *___isub___(PyObject *trueSelf, PyObject *obj)
2125 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2126 MEDCoupling_DataArrayDouble____isub___(ret,0,obj);
2127 Py_XINCREF(trueSelf);
2131 PyObject *___imul___(PyObject *trueSelf, PyObject *obj)
2133 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2134 MEDCoupling_DataArrayDouble____imul___(ret,0,obj);
2135 Py_XINCREF(trueSelf);
2139 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj)
2141 MCAuto<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2142 MEDCoupling_DataArrayDouble____idiv___(ret,0,obj);
2143 Py_XINCREF(trueSelf);
2149 return PyInt_FromLong(self->getNumberOfCompo());
2152 PyObject *__getitem__(PyObject *obj)
2154 const char msg2[]="DataArrayDoubleTuple::__getitem__ : Mismatch of slice values in 2nd parameter (components) !";
2157 std::vector<mcIdType> multiVal;
2158 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2159 MEDCoupling::DataArrayIdType *daIntTyypp=0;
2160 const double *pt=self->getConstPointer();
2161 mcIdType nbc=ToIdType(self->getNumberOfCompo());
2162 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbc,sw,singleVal,multiVal,slic,daIntTyypp);
2169 std::ostringstream oss;
2170 oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2171 PyErr_SetString(PyExc_StopIteration,oss.str().c_str());
2175 return PyFloat_FromDouble(pt[singleVal]);
2179 return PyFloat_FromDouble(pt[nbc+singleVal]);
2182 std::ostringstream oss;
2183 oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2184 throw INTERP_KERNEL::Exception(oss.str().c_str());
2190 PyObject *t=PyTuple_New(multiVal.size());
2191 for(std::size_t j=0;j<multiVal.size();j++)
2193 mcIdType cid=multiVal[j];
2196 std::ostringstream oss;
2197 oss << "Requesting for id #" << cid << " having only " << nbc << " components !";
2198 throw INTERP_KERNEL::Exception(oss.str().c_str());
2200 PyTuple_SetItem(t,j,PyFloat_FromDouble(pt[cid]));
2206 mcIdType sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2207 PyObject *t=PyTuple_New(sz);
2208 for(mcIdType j=0;j<sz;j++)
2209 PyTuple_SetItem(t,j,PyFloat_FromDouble(pt[slic.first+j*slic.second.second]));
2213 throw INTERP_KERNEL::Exception("DataArrayDoubleTuple::__getitem__ : unrecognized type entered !");
2217 DataArrayDoubleTuple *__setitem__(PyObject *obj, PyObject *value)
2219 const char msg[]="DataArrayDoubleTuple::__setitem__ : unrecognized type entered, int, slice, list<int>, tuple<int> !";
2220 const char msg2[]="DataArrayDoubleTuple::__setitem__ : Mismatch of slice values in 2nd parameter (components) !";
2223 std::vector<double> multiValV;
2224 MEDCoupling::DataArrayDoubleTuple *daIntTyyppV=0;
2225 mcIdType nbc=ToIdType(self->getNumberOfCompo());
2226 convertDoubleStarLikePyObjToCpp(value,sw1,singleValV,multiValV,daIntTyyppV);
2228 std::vector<mcIdType> multiVal;
2229 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > slic;
2230 MEDCoupling::DataArrayIdType *daIntTyypp=0;
2231 double *pt=self->getPointer();
2232 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbc,sw2,singleVal,multiVal,slic,daIntTyypp);
2239 std::ostringstream oss;
2240 oss << "Requesting for setting id # " << singleVal << " having only " << nbc << " components !";
2241 throw INTERP_KERNEL::Exception(oss.str().c_str());
2247 pt[singleVal]=singleValV;
2252 if(multiValV.size()!=1)
2254 std::ostringstream oss;
2255 oss << "Requesting for setting id # " << singleVal << " with a list or tuple with size != 1 ! ";
2256 throw INTERP_KERNEL::Exception(oss.str().c_str());
2258 pt[singleVal]=multiValV[0];
2263 pt[singleVal]=daIntTyyppV->getConstPointer()[0];
2267 throw INTERP_KERNEL::Exception(msg);
2276 for(std::vector<mcIdType>::const_iterator it=multiVal.begin();it!=multiVal.end();it++)
2280 std::ostringstream oss;
2281 oss << "Requesting for setting id # " << *it << " having only " << nbc << " components !";
2282 throw INTERP_KERNEL::Exception(oss.str().c_str());
2290 if(multiVal.size()!=multiValV.size())
2292 std::ostringstream oss;
2293 oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << multiVal.size() << " !";
2294 throw INTERP_KERNEL::Exception(oss.str().c_str());
2296 for(std::size_t i=0;i<multiVal.size();i++)
2298 mcIdType pos=multiVal[i];
2301 std::ostringstream oss;
2302 oss << "Requesting for setting id # " << pos << " having only " << nbc << " components !";
2303 throw INTERP_KERNEL::Exception(oss.str().c_str());
2305 pt[multiVal[i]]=multiValV[i];
2311 const double *ptV=daIntTyyppV->getConstPointer();
2312 if(nbc>(mcIdType)daIntTyyppV->getNumberOfCompo())
2314 std::ostringstream oss;
2315 oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2316 throw INTERP_KERNEL::Exception(oss.str().c_str());
2318 std::copy(ptV,ptV+nbc,pt);
2322 throw INTERP_KERNEL::Exception(msg);
2327 mcIdType sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2332 for(mcIdType j=0;j<sz;j++)
2333 pt[slic.first+j*slic.second.second]=singleValV;
2338 if(sz!=(mcIdType)multiValV.size())
2340 std::ostringstream oss;
2341 oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << sz << " !";
2342 throw INTERP_KERNEL::Exception(oss.str().c_str());
2344 for(mcIdType j=0;j<sz;j++)
2345 pt[slic.first+j*slic.second.second]=multiValV[j];
2350 const double *ptV=daIntTyyppV->getConstPointer();
2351 if(sz>(mcIdType)daIntTyyppV->getNumberOfCompo())
2353 std::ostringstream oss;
2354 oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2355 throw INTERP_KERNEL::Exception(oss.str().c_str());
2357 for(mcIdType j=0;j<sz;j++)
2358 pt[slic.first+j*slic.second.second]=ptV[j];
2362 throw INTERP_KERNEL::Exception(msg);
2366 throw INTERP_KERNEL::Exception(msg);
2372 class DataArrayChar : public DataArray
2375 virtual DataArrayChar *buildEmptySpecializedDAChar() const;
2376 int getHashCode() const;
2378 void deepCopyFrom(const DataArrayChar& other);
2379 void reserve(std::size_t nbOfElems);
2380 void pushBackSilent(char val);
2381 char popBackSilent();
2383 void allocIfNecessary(int nbOfTuple, int nbOfCompo);
2384 bool isEqual(const DataArrayChar& other) const;
2385 bool isEqualWithoutConsideringStr(const DataArrayChar& other) const;
2387 void fillWithZero();
2388 void fillWithValue(char val);
2389 std::string repr() const;
2390 std::string reprZip() const;
2391 DataArrayInt *convertToIntArr() const;
2392 DataArrayChar *renumber(const mcIdType *old2New) const;
2393 DataArrayChar *renumberR(const mcIdType *new2Old) const;
2394 DataArrayChar *renumberAndReduce(const mcIdType *old2NewBg, mcIdType newNbOfTuple) const;
2395 bool isUniform(char val) const;
2396 void sort(bool asc=true);
2397 DataArrayChar *subArray(mcIdType tupleIdBg, mcIdType tupleIdEnd=-1) const;
2398 DataArrayChar *changeNbOfComponents(std::size_t newNbOfComp, char dftValue) const;
2399 void meldWith(const DataArrayChar *other);
2400 void setPartOfValuesAdv(const DataArrayChar *a, const DataArrayIdType *tuplesSelec);
2403 void setIJ(mcIdType tupleId, int compoId, char newVal);
2404 void setIJSilent(mcIdType tupleId, int compoId, char newVal);
2406 DataArrayIdType *findIdsEqual(char val) const;
2407 DataArrayIdType *findIdsNotEqual(char val) const;
2408 int findIdFirstEqualTuple(const std::vector<char>& tupl) const;
2409 bool presenceOfTuple(const std::vector<char>& tupl) const;
2410 char getMaxValue(mcIdType& tupleId) const;
2411 char getMaxValueInArray() const;
2412 char getMinValue(mcIdType& tupleId) const;
2413 char getMinValueInArray() const;
2414 DataArrayIdType *findIdsInRange(char vmin, char vmax) const;
2415 static DataArrayChar *Aggregate(const DataArrayChar *a1, const DataArrayChar *a2);
2416 static DataArrayChar *Meld(const DataArrayChar *a1, const DataArrayChar *a2);
2419 mcIdType __len__() const
2421 if(self->isAllocated())
2423 return self->getNumberOfTuples();
2427 throw INTERP_KERNEL::Exception("DataArrayChar::__len__ : Instance is NOT allocated !");
2431 PyObject *isEqualIfNotWhy(const DataArrayChar& other) const
2434 bool ret0=self->isEqualIfNotWhy(other,ret1);
2435 PyObject *ret=PyTuple_New(2);
2436 PyObject *ret0Py=ret0?Py_True:Py_False;
2438 PyTuple_SetItem(ret,0,ret0Py);
2439 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
2443 DataArrayChar *renumber(PyObject *li)
2446 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
2447 if (!SWIG_IsOK(res1))
2450 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2451 if(size!=self->getNumberOfTuples())
2453 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2455 return self->renumber(tmp);
2459 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2461 throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2462 da2->checkAllocated();
2463 mcIdType size=self->getNumberOfTuples();
2464 if(size!=self->getNumberOfTuples())
2466 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2468 return self->renumber(da2->getConstPointer());
2472 DataArrayChar *renumberR(PyObject *li)
2475 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
2476 if (!SWIG_IsOK(res1))
2479 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2480 if(size!=self->getNumberOfTuples())
2482 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2484 return self->renumberR(tmp);
2488 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2490 throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2491 da2->checkAllocated();
2492 mcIdType size=self->getNumberOfTuples();
2493 if(size!=self->getNumberOfTuples())
2495 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2497 return self->renumberR(da2->getConstPointer());
2501 DataArrayChar *renumberAndReduce(PyObject *li, mcIdType newNbOfTuple)
2504 int res1=SWIG_ConvertPtr(li,&da,SWIGTITraits<mcIdType>::TI, 0 | 0 );
2505 if (!SWIG_IsOK(res1))
2508 INTERP_KERNEL::AutoPtr<mcIdType> tmp=convertPyToNewIntArr2(li,&size);
2509 if(size!=self->getNumberOfTuples())
2511 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2513 return self->renumberAndReduce(tmp,newNbOfTuple);
2517 DataArrayIdType *da2=reinterpret_cast< DataArrayIdType * >(da);
2519 throw INTERP_KERNEL::Exception("Not null DataArrayIdType instance expected !");
2520 da2->checkAllocated();
2521 mcIdType size=self->getNumberOfTuples();
2522 if(size!=self->getNumberOfTuples())
2524 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2526 return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
2530 static DataArrayChar *Aggregate(PyObject *dachs)
2532 std::vector<const MEDCoupling::DataArrayChar *> tmp;
2533 convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayChar *>(dachs,SWIGTYPE_p_MEDCoupling__DataArrayChar,"DataArrayChar",tmp);
2534 return DataArrayChar::Aggregate(tmp);
2537 static DataArrayChar *Meld(PyObject *dachs)
2539 std::vector<const MEDCoupling::DataArrayChar *> tmp;
2540 convertFromPyObjVectorOfObj<const MEDCoupling::DataArrayChar *>(dachs,SWIGTYPE_p_MEDCoupling__DataArrayChar,"DataArrayChar",tmp);
2541 return DataArrayChar::Meld(tmp);
2546 class DataArrayByteIterator;
2548 class DataArrayByte : public DataArrayChar
2551 static DataArrayByte *New();
2552 DataArrayByteIterator *iterator();
2553 DataArrayByte *performCopyOrIncrRef(bool deepCopy) const;
2554 char byteValue() const;
2559 return DataArrayByte::New();
2562 static DataArrayByte *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
2564 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) !";
2565 if(PyList_Check(elt0) || PyTuple_Check(elt0))
2569 if(PyInt_Check(nbOfTuples))
2571 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
2573 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive set of allocated memory !");
2576 if(PyInt_Check(nbOfComp))
2577 {//DataArrayByte.New([1,3,4,5],2,2)
2578 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
2580 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !");
2581 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2582 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
2583 ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2587 throw INTERP_KERNEL::Exception(msg);
2590 {//DataArrayByte.New([1,3,4],3)
2591 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2593 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
2594 ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2599 throw INTERP_KERNEL::Exception(msg);
2602 {// DataArrayByte.New([1,3,4])
2603 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2604 mcIdType tmpp1=-1,tmpp2=-1;
2605 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
2606 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2610 else if(PyInt_Check(elt0))
2612 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(elt0));
2614 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive set of allocated memory !");
2619 if(PyInt_Check(nbOfTuples))
2620 {//DataArrayByte.New(5,2)
2621 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfTuples));
2623 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !");
2624 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2625 ret->alloc(nbOfTuples1,nbOfCompo);
2629 throw INTERP_KERNEL::Exception(msg);
2632 throw INTERP_KERNEL::Exception(msg);
2635 {//DataArrayByte.New(5)
2636 MCAuto<DataArrayByte> ret=DataArrayByte::New();
2637 ret->alloc(nbOfTuples1,1);
2642 else if(PyArray_Check(elt0) && nbOfTuples==NULL && nbOfComp==NULL)
2643 {//DataArrayDouble.New(numpyArray)
2644 return BuildNewInstance<DataArrayByte,char>(elt0,NPY_INT8,&PyCallBackDataArrayChar_RefType,"INT8");
2648 throw INTERP_KERNEL::Exception(msg);
2651 DataArrayByte(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
2653 return MEDCoupling_DataArrayByte_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
2656 std::string __repr__() const
2658 std::ostringstream oss;
2659 self->reprQuickOverview(oss);
2665 return (int) self->byteValue();
2668 DataArrayByteIterator *__iter__()
2670 return self->iterator();
2673 mcIdType getIJ(mcIdType tupleId, mcIdType compoId) const
2675 return (mcIdType)self->getIJ(tupleId,compoId);
2678 mcIdType getIJSafe(mcIdType tupleId, mcIdType compoId) const
2680 return (mcIdType)self->getIJSafe(tupleId,compoId);
2683 std::string __str__() const
2685 return self->repr();
2688 PyObject *toStrList() const
2690 const char *vals=self->getConstPointer();
2691 std::size_t nbOfComp=self->getNumberOfComponents();
2692 mcIdType nbOfTuples=self->getNumberOfTuples();
2693 return convertCharArrToPyListOfTuple(vals,(int)nbOfComp,nbOfTuples);
2696 bool presenceOfTuple(PyObject *tupl) const
2698 mcIdType sz=-1,sw=-1;
2699 mcIdType ival=-1; std::vector<mcIdType> ivval;
2700 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(tupl,sw,sz,ival,ivval);
2701 std::vector<char> vals(sz);
2702 std::copy(pt,pt+sz,vals.begin());
2703 return self->presenceOfTuple(vals);
2706 bool presenceOfValue(PyObject *vals) const
2708 mcIdType sz=-1,sw=-1;
2709 mcIdType ival=-1; std::vector<mcIdType> ivval;
2710 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(vals,sw,sz,ival,ivval);
2711 std::vector<char> vals2(sz);
2712 std::copy(pt,pt+sz,vals2.begin());
2713 return self->presenceOfValue(vals2);
2716 mcIdType findIdFirstEqual(PyObject *vals) const
2718 mcIdType sz=-1,sw=-1;
2719 mcIdType ival=-1; std::vector<mcIdType> ivval;
2720 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(vals,sw,sz,ival,ivval);
2721 std::vector<char> vals2(sz);
2722 std::copy(pt,pt+sz,vals2.begin());
2723 return self->findIdFirstEqual(vals2);
2726 mcIdType findIdFirstEqualTuple(PyObject *tupl) const
2728 mcIdType sz=-1,sw=-1;
2729 mcIdType ival=-1; std::vector<mcIdType> ivval;
2730 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(tupl,sw,sz,ival,ivval);
2731 std::vector<char> vals(sz);
2732 std::copy(pt,pt+sz,vals.begin());
2733 return self->findIdFirstEqualTuple(vals);
2736 mcIdType findIdSequence(PyObject *strOrListOfInt) const
2738 mcIdType sz=-1,sw=-1;
2739 mcIdType ival=-1; std::vector<mcIdType> ivval;
2740 const mcIdType *pt=convertIntStarLikePyObjToCppIntStar(strOrListOfInt,sw,sz,ival,ivval);
2741 std::vector<char> vals(sz);
2742 std::copy(pt,pt+sz,vals.begin());
2743 return self->findIdSequence(vals);
2746 PyObject *getTuple(mcIdType tupleId)
2748 std::size_t sz=self->getNumberOfComponents();
2749 INTERP_KERNEL::AutoPtr<char> tmp=new char[sz];
2750 self->getTuple(tupleId,tmp);
2751 PyObject *ret=PyTuple_New(sz);
2752 for(std::size_t i=0;i<sz;i++) PyTuple_SetItem(ret,i,PyInt_FromLong((mcIdType)tmp[i]));
2756 PyObject *getMaxValue() const
2759 mcIdType r1=(mcIdType)self->getMaxValue(tmp);
2760 PyObject *ret=PyTuple_New(2);
2761 PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
2762 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
2766 PyObject *getMinValue() const
2769 mcIdType r1=(mcIdType)self->getMinValue(tmp);
2770 PyObject *ret=PyTuple_New(2);
2771 PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
2772 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
2776 mcIdType index(PyObject *obj) const
2778 std::size_t nbOfCompo=self->getNumberOfComponents();
2783 if(PyInt_Check(obj))
2785 char val=(char)PyInt_AS_LONG(obj);
2786 return self->findIdFirstEqual(val);
2789 throw INTERP_KERNEL::Exception("DataArrayByte::index : 'this' contains one component and trying to find an element which is not an integer !");
2792 return MEDCoupling_DataArrayByte_findIdFirstEqualTuple(self,obj);
2796 bool __contains__(PyObject *obj) const
2798 std::size_t nbOfCompo=self->getNumberOfComponents();
2805 if(PyInt_Check(obj))
2807 char val=(char)PyInt_AS_LONG(obj);
2808 return self->presenceOfValue(val);
2811 throw INTERP_KERNEL::Exception("DataArrayByte::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
2814 return MEDCoupling_DataArrayByte_presenceOfTuple(self,obj);
2819 PyObject *toNumPyArray() // not const. It is not a bug !
2821 return ToNumPyArray<DataArrayByte,char>(self,NPY_INT8,"DataArrayByte");
2825 DataArrayByte *__setitem__(PyObject *obj, PyObject *value)
2827 self->checkAllocated();
2828 const char msg[]="Unexpected situation in __setitem__ !";
2829 mcIdType nbOfTuples(self->getNumberOfTuples());
2830 int nbOfComponents((int)self->getNumberOfComponents());
2833 std::vector<int> v1;
2834 DataArrayIdType *d1=0;
2835 DataArrayIntTuple *dd1=0;
2836 convertIntStarLikePyObjToCpp(value,sw1,int1,v1,d1,dd1);
2838 std::vector<mcIdType> vt1,vc1;
2839 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > pt1,pc1;
2840 DataArrayIdType *dt1=0,*dc1=0;
2841 convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw2,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1);
2842 MCAuto<DataArrayIdType> tmp;
2843 char i1 = (char)int1;
2851 self->setPartOfValuesSimple1(i1,it1,it1+1,1,0,nbOfComponents,1);
2854 throw INTERP_KERNEL::Exception(msg);
2863 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1);
2866 throw INTERP_KERNEL::Exception(msg);
2875 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1);
2878 throw INTERP_KERNEL::Exception(msg);
2887 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1);
2890 throw INTERP_KERNEL::Exception(msg);
2899 self->setPartOfValuesSimple1(i1,it1,it1+1,1,ic1,ic1+1,1);
2902 throw INTERP_KERNEL::Exception(msg);
2911 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1);
2914 throw INTERP_KERNEL::Exception(msg);
2923 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1);
2926 throw INTERP_KERNEL::Exception(msg);
2935 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1);
2938 throw INTERP_KERNEL::Exception(msg);
2947 self->setPartOfValuesSimple2(i1,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size());
2950 throw INTERP_KERNEL::Exception(msg);
2959 self->setPartOfValuesSimple2(i1,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size());
2962 throw INTERP_KERNEL::Exception(msg);
2971 self->setPartOfValuesSimple4(i1,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size());
2974 throw INTERP_KERNEL::Exception(msg);
2983 self->setPartOfValuesSimple2(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size());
2986 throw INTERP_KERNEL::Exception(msg);
2995 self->setPartOfValuesSimple1(i1,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second);
2998 throw INTERP_KERNEL::Exception(msg);
3007 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second);
3010 throw INTERP_KERNEL::Exception(msg);
3019 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second);
3022 throw INTERP_KERNEL::Exception(msg);
3031 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second);
3034 throw INTERP_KERNEL::Exception(msg);
3039 throw INTERP_KERNEL::Exception(msg);
3046 class DataArrayByteTuple;
3048 class DataArrayByteIterator
3051 DataArrayByteIterator(DataArrayByte *da);
3052 ~DataArrayByteIterator();
3055 class DataArrayByteTuple
3058 std::string repr() const;
3059 DataArrayByte *buildDAByte(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
3062 std::string __str__() const
3064 return self->repr();
3067 char __int__() const
3069 return self->byteValue();
3072 DataArrayByte *buildDAByte()
3074 return self->buildDAByte(1,self->getNumberOfCompo());
3079 class DataArrayAsciiCharIterator;
3081 class DataArrayAsciiChar : public DataArrayChar
3084 static DataArrayAsciiChar *New();
3085 DataArrayAsciiCharIterator *iterator();
3086 DataArrayAsciiChar *performCopyOrIncrRef(bool deepCopy) const;
3087 char asciiCharValue() const;
3090 DataArrayAsciiChar()
3092 return DataArrayAsciiChar::New();
3095 static DataArrayAsciiChar *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
3097 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) !";
3098 if(PyList_Check(elt0) || PyTuple_Check(elt0))
3102 if(PyInt_Check(nbOfTuples))
3104 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(nbOfTuples));
3106 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive set of allocated memory !");
3109 if(PyInt_Check(nbOfComp))
3110 {//DataArrayAsciiChar.New([1,3,4,5],2,2)
3111 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfComp));
3113 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !");
3114 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3115 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
3116 ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3120 throw INTERP_KERNEL::Exception(msg);
3123 {//DataArrayAsciiChar.New([1,3,4],3)
3124 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3126 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
3127 ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3131 else if(PyString_Check(nbOfTuples))
3133 if(PyString_Size(nbOfTuples)!=1)
3134 throw INTERP_KERNEL::Exception(msg);
3135 //DataArrayAsciiChar.New(["abc","de","fghi"],"t")
3136 std::vector<std::string> tmp;
3137 if(fillStringVector(elt0,tmp))
3138 return DataArrayAsciiChar::New(tmp,PyString_AsString(nbOfTuples)[0]);
3140 throw INTERP_KERNEL::Exception(msg);
3142 %#if PY_VERSION_HEX >= 0x03000000
3143 else if(PyUnicode_Check(nbOfTuples))
3145 if(PyUnicode_GET_LENGTH(nbOfTuples)!=1)
3146 throw INTERP_KERNEL::Exception(msg);
3147 //DataArrayAsciiChar.New(["abc","de","fghi"],"t")
3148 std::vector<std::string> tmp;
3149 if(fillStringVector(elt0,tmp))
3150 return DataArrayAsciiChar::New(tmp,PyUnicode_AsUTF8(nbOfTuples)[0]);
3152 throw INTERP_KERNEL::Exception(msg);
3156 throw INTERP_KERNEL::Exception(msg);
3160 std::vector<std::string> tmmp;
3161 if(fillStringVector(elt0,tmmp))
3162 //DataArrayAsciiChar.New(["abc","de","fghi"])
3163 return DataArrayAsciiChar::New(tmmp,' ');
3166 // DataArrayAsciiChar.New([1,3,4])
3167 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3168 mcIdType tmpp1=-1,tmpp2=-1;
3169 std::vector<mcIdType> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
3170 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
3175 else if(PyInt_Check(elt0))
3177 mcIdType nbOfTuples1=ToIdType(PyInt_AS_LONG(elt0));
3179 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive set of allocated memory !");
3184 if(PyInt_Check(nbOfTuples))
3185 {//DataArrayAsciiChar.New(5,2)
3186 mcIdType nbOfCompo=ToIdType(PyInt_AS_LONG(nbOfTuples));
3188 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !");
3189 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3190 ret->alloc(nbOfTuples1,nbOfCompo);
3194 throw INTERP_KERNEL::Exception(msg);
3197 throw INTERP_KERNEL::Exception(msg);
3200 {//DataArrayAsciiChar.New(5)
3201 MCAuto<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
3202 ret->alloc(nbOfTuples1,1);
3207 throw INTERP_KERNEL::Exception(msg);
3210 DataArrayAsciiChar(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0)
3212 return MEDCoupling_DataArrayAsciiChar_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
3215 std::string __repr__() const
3217 std::ostringstream oss;
3218 self->reprQuickOverview(oss);
3222 DataArrayAsciiCharIterator *__iter__()
3224 return self->iterator();
3227 std::string getIJ(mcIdType tupleId, mcIdType compoId) const
3229 char tmp[2]; tmp[1]='\0';
3230 tmp[0]=self->getIJ(tupleId,compoId);
3231 return std::string(tmp);
3234 std::string getIJSafe(mcIdType tupleId, mcIdType compoId) const
3236 char tmp[2]; tmp[1]='\0';
3237 tmp[0]=self->getIJSafe(tupleId,compoId);
3238 return std::string(tmp);
3241 std::string __str__() const
3243 return self->repr();
3246 PyObject *toStrList() const
3248 const char *vals=self->getConstPointer();
3249 std::size_t nbOfComp=self->getNumberOfComponents();
3250 mcIdType nbOfTuples=self->getNumberOfTuples();
3251 return convertCharArrToPyListOfTuple(vals,(int)nbOfComp,nbOfTuples);
3254 bool presenceOfTuple(PyObject *tupl) const
3256 if(PyString_Check(tupl))
3258 Py_ssize_t sz=PyString_Size(tupl);
3259 std::vector<char> vals(sz);
3260 std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin());
3261 return self->presenceOfTuple(vals);
3263 %#if PY_VERSION_HEX >= 0x03000000
3264 else if(PyUnicode_Check(tupl))
3266 Py_ssize_t sz=PyUnicode_GET_LENGTH(tupl);
3267 std::vector<char> vals(sz);
3268 std::copy(PyUnicode_AsUTF8(tupl),PyUnicode_AsUTF8(tupl)+sz,vals.begin());
3269 return self->presenceOfTuple(vals);
3273 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfTuple : only strings in input supported !");
3276 bool presenceOfValue(PyObject *vals) const
3278 if(PyString_Check(vals))
3280 Py_ssize_t sz=PyString_Size(vals);
3281 std::vector<char> vals2(sz);
3282 std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin());
3283 return self->presenceOfValue(vals2);
3285 %#if PY_VERSION_HEX >= 0x03000000
3286 if(PyUnicode_Check(vals))
3288 Py_ssize_t sz=PyUnicode_GET_LENGTH(vals);
3289 std::vector<char> vals2(sz);
3290 std::copy(PyUnicode_AsUTF8(vals),PyUnicode_AsUTF8(vals)+sz,vals2.begin());
3291 return self->presenceOfValue(vals2);
3295 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfValue : only strings in input supported !");
3298 mcIdType findIdFirstEqual(PyObject *vals) const
3300 if(PyString_Check(vals))
3302 Py_ssize_t sz=PyString_Size(vals);
3303 std::vector<char> vals2(sz);
3304 std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin());
3305 return self->findIdFirstEqual(vals2);
3307 %#if PY_VERSION_HEX >= 0x03000000
3308 if(PyUnicode_Check(vals))
3310 Py_ssize_t sz=PyUnicode_GET_LENGTH(vals);
3311 std::vector<char> vals2(sz);
3312 std::copy(PyUnicode_AsUTF8(vals),PyUnicode_AsUTF8(vals)+sz,vals2.begin());
3313 return self->findIdFirstEqual(vals2);
3317 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::findIdFirstEqual : only strings in input supported !");
3320 mcIdType findIdFirstEqualTuple(PyObject *tupl) const
3322 if(PyString_Check(tupl))
3324 Py_ssize_t sz=PyString_Size(tupl);
3325 std::vector<char> vals(sz);
3326 std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin());
3327 return self->findIdFirstEqualTuple(vals);
3329 %#if PY_VERSION_HEX >= 0x03000000
3330 if(PyUnicode_Check(tupl))
3332 Py_ssize_t sz=PyUnicode_GET_LENGTH(tupl);
3333 std::vector<char> vals(sz);
3334 std::copy(PyUnicode_AsUTF8(tupl),PyUnicode_AsUTF8(tupl)+sz,vals.begin());
3335 return self->findIdFirstEqualTuple(vals);
3339 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::findIdFirstEqualTuple : only strings in input supported !");
3342 mcIdType findIdSequence(PyObject *strOrListOfInt) const
3344 if(PyString_Check(strOrListOfInt))
3346 Py_ssize_t sz=PyString_Size(strOrListOfInt);
3347 std::vector<char> vals(sz);
3348 std::copy(PyString_AsString(strOrListOfInt),PyString_AsString(strOrListOfInt)+sz,vals.begin());
3349 return self->findIdSequence(vals);
3351 %#if PY_VERSION_HEX >= 0x03000000
3352 else if(PyUnicode_Check(strOrListOfInt))
3354 Py_ssize_t sz=PyUnicode_GET_LENGTH(strOrListOfInt);
3355 std::vector<char> vals(sz);
3356 std::copy(PyUnicode_AsUTF8(strOrListOfInt),PyUnicode_AsUTF8(strOrListOfInt)+sz,vals.begin());
3357 return self->findIdSequence(vals);
3361 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::search : only strings in input supported !");
3364 PyObject *getTuple(mcIdType tupleId) const
3366 std::size_t sz=self->getNumberOfComponents();
3367 INTERP_KERNEL::AutoPtr<char> tmp=new char[sz+1]; tmp[sz]='\0';
3368 self->getTuple(tupleId,tmp);
3369 return PyString_FromString(tmp);
3372 PyObject *getMaxValue() const
3375 char tmp2[2]; tmp2[1]='\0';
3376 tmp2[0]=self->getMaxValue(tmp);
3377 PyObject *ret=PyTuple_New(2);
3378 PyTuple_SetItem(ret,0,PyString_FromString(tmp2));
3379 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
3383 PyObject *getMinValue() const
3386 char tmp2[2]; tmp2[1]='\0';
3387 tmp2[0]=self->getMinValue(tmp);
3388 PyObject *ret=PyTuple_New(2);
3389 PyTuple_SetItem(ret,0,PyString_FromString(tmp2));
3390 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
3394 mcIdType index(PyObject *obj) const
3396 std::size_t nbOfCompo=self->getNumberOfComponents();
3401 if(PyString_Check(obj))
3403 Py_ssize_t sz=PyString_Size(obj);
3404 char *pt=PyString_AsString(obj);
3406 return self->findIdFirstEqual(pt[0]);
3408 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find a string with size different from 1 !");
3410 %#if PY_VERSION_HEX >= 0x03000000
3411 if(PyUnicode_Check(obj))
3414 const char *pt=PyUnicode_AsUTF8AndSize(obj, &sz);
3416 return self->findIdFirstEqual(pt[0]);
3418 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find a string with size different from 1 !");
3422 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find an element which is not an integer !");
3425 return MEDCoupling_DataArrayAsciiChar_findIdFirstEqualTuple(self,obj);
3429 bool __contains__(PyObject *obj) const
3431 std::size_t nbOfCompo=self->getNumberOfComponents();
3438 if(PyString_Check(obj))
3440 Py_ssize_t sz=PyString_Size(obj);
3441 char *pt=PyString_AsString(obj);
3443 return self->presenceOfValue(pt[0]);
3445 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find a string with size different from 1 !");
3447 %#if PY_VERSION_HEX >= 0x03000000
3448 if(PyUnicode_Check(obj))
3451 const char *pt=PyUnicode_AsUTF8AndSize(obj, &sz);
3453 return self->presenceOfValue(pt[0]);
3455 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find a string with size different from 1 !");
3459 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
3462 return MEDCoupling_DataArrayAsciiChar_presenceOfTuple(self,obj);
3466 PyObject *__getitem__(PyObject *obj) const
3468 mcIdType sw,iTypppArr;
3469 std::vector<mcIdType> stdvecTyyppArr;
3470 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > sTyyppArr;
3471 MEDCoupling::DataArrayIdType *daIntTyypp=0;
3472 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,self->getNumberOfTuples(),sw,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp);
3476 return MEDCoupling_DataArrayAsciiChar_getTuple(self,iTypppArr);
3478 return convertDataArrayChar(self->selectByTupleIdSafe(&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size()), SWIG_POINTER_OWN | 0 );
3480 return convertDataArrayChar(self->selectByTupleIdSafeSlice(sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second), SWIG_POINTER_OWN | 0 );
3482 return convertDataArrayChar(self->selectByTupleIdSafe(daIntTyypp->begin(),daIntTyypp->end()), SWIG_POINTER_OWN | 0 );
3484 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__getitem__ : supporting int, list of int, tuple of int, DataArrayIdType and slice in input !");
3488 DataArrayAsciiChar *__setitem__(PyObject *obj, PyObject *value)
3490 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.";
3491 mcIdType sw1,iTypppArr;
3492 std::vector<mcIdType> stdvecTyyppArr;
3493 std::pair<mcIdType, std::pair<mcIdType,mcIdType> > sTyyppArr;
3494 MEDCoupling::DataArrayIdType *daIntTyypp=0;
3495 mcIdType nbOfCompo=ToIdType(self->getNumberOfComponents());
3496 mcIdType nbOfTuples=self->getNumberOfTuples();
3497 convertIntStarOrSliceLikePyObjToCppWithNegIntInterp(obj,nbOfTuples,sw1,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp);
3499 char vc; std::string sc; std::vector<std::string> vsc; DataArrayChar *dacc=0;
3500 convertObjToPossibleCpp6(value,sw2,vc,sc,vsc,dacc);
3509 self->setPartOfValuesSimple3(vc,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1);
3515 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3516 self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3519 //value vector<string>
3522 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3523 self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3526 //value DataArrayChar
3529 self->setPartOfValues3(dacc,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
3533 throw INTERP_KERNEL::Exception(msg);
3537 {//obj list-tuple[int]
3543 self->setPartOfValuesSimple3(vc,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1);
3549 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3550 self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3553 //value vector<string>
3556 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3557 self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3560 //value DataArrayChar
3563 self->setPartOfValues3(dacc,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
3567 throw INTERP_KERNEL::Exception(msg);
3578 self->setPartOfValuesSimple1(vc,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1);
3584 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3585 self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3588 //value vector<string>
3591 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3592 self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3595 //value DataArrayChar
3598 self->setPartOfValues1(dacc,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
3602 throw INTERP_KERNEL::Exception(msg);
3613 self->setPartOfValuesSimple3(vc,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1);
3619 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
3620 self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3623 //value vector<string>
3626 MCAuto<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
3627 self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3630 //value DataArrayChar
3633 self->setPartOfValues3(dacc,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
3637 throw INTERP_KERNEL::Exception(msg);
3642 throw INTERP_KERNEL::Exception(msg);
3648 class DataArrayAsciiCharTuple;
3650 class DataArrayAsciiCharIterator
3653 DataArrayAsciiCharIterator(DataArrayAsciiChar *da);
3654 ~DataArrayAsciiCharIterator();
3659 DataArrayAsciiCharTuple *ret=self->nextt();
3661 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_MEDCoupling__DataArrayAsciiCharTuple,SWIG_POINTER_OWN | 0);
3664 PyErr_SetString(PyExc_StopIteration,"No more data.");
3671 class DataArrayAsciiCharTuple
3674 std::size_t getNumberOfCompo() const;
3675 DataArrayAsciiChar *buildDAAsciiChar(mcIdType nbOfTuples, mcIdType nbOfCompo) const;
3678 std::string __str__() const
3680 return self->repr();
3683 DataArrayAsciiChar *buildDAAsciiChar()
3685 return self->buildDAAsciiChar(1,self->getNumberOfCompo());
3691 %include "DataArrayInt.i"
3694 def MEDCouplingStdReduceFunct(cls,params):
3696 ret=object.__new__(cls)
3701 def MEDCouplingDataArrayDoubleReduce(self):
3702 if not MEDCouplingHasNumPyBindings():
3703 raise InterpKernelException("PyWrap of DataArrayDouble.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3704 return MEDCouplingStdReduceFunct,(DataArrayDouble,((self.toNumPyArray(),),(self.__getstate__()),))
3706 def MEDCouplingDataArrayInt32Reduce(self):
3707 if not MEDCouplingHasNumPyBindings():
3708 raise InterpKernelException("PyWrap of DataArrayIdType.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3709 return MEDCouplingStdReduceFunct,(DataArrayInt32,((self.toNumPyArray(),),(self.__getstate__()),))
3711 def MEDCouplingDataArrayInt64Reduce(self):
3712 if not MEDCouplingHasNumPyBindings():
3713 raise InterpKernelException("PyWrap of DataArrayIdType.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3714 return MEDCouplingStdReduceFunct,(DataArrayInt64,((self.toNumPyArray(),),(self.__getstate__()),))
3716 def MEDCouplingDataArrayByteReduce(self):
3717 if not MEDCouplingHasNumPyBindings():
3718 raise InterpKernelException("PyWrap of DataArrayByte.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3719 return MEDCouplingStdReduceFunct,(DataArrayByte,((self.toNumPyArray(),),(self.__getstate__()),))
3721 def MEDCouplingDataArrayFloatReduce(self):
3722 if not MEDCouplingHasNumPyBindings():
3723 raise InterpKernelException("PyWrap of DataArrayFloat.__reduce__ : not implemented because numpy is not active in your configuration ! No serialization/unserialization available without numpy !")
3724 return MEDCouplingStdReduceFunct,(DataArrayFloat,((self.toNumPyArray(),),(self.__getstate__()),))
3726 if MEDCouplingUse64BitIDs():
3727 DataArrayInt=DataArrayInt64
3729 DataArrayInt=DataArrayInt32