1 // Copyright (C) 2007-2013 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.
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 (CEA/DEN)
23 class DataArray : public RefCountObject, public TimeLabel
26 void setName(const char *name);
27 void copyStringInfoFrom(const DataArray& other) throw(INTERP_KERNEL::Exception);
28 void copyPartOfStringInfoFrom(const DataArray& other, const std::vector<int>& compoIds) throw(INTERP_KERNEL::Exception);
29 void copyPartOfStringInfoFrom2(const std::vector<int>& compoIds, const DataArray& other) throw(INTERP_KERNEL::Exception);
30 bool areInfoEqualsIfNotWhy(const DataArray& other, std::string& reason) const throw(INTERP_KERNEL::Exception);
31 bool areInfoEquals(const DataArray& other) const throw(INTERP_KERNEL::Exception);
32 std::string cppRepr(const char *varName) const throw(INTERP_KERNEL::Exception);
33 std::string getName() const;
34 void setInfoOnComponents(const std::vector<std::string>& info) throw(INTERP_KERNEL::Exception);
35 void setInfoAndChangeNbOfCompo(const std::vector<std::string>& info) throw(INTERP_KERNEL::Exception);
36 std::vector<std::string> getVarsOnComponent() const throw(INTERP_KERNEL::Exception);
37 std::vector<std::string> getUnitsOnComponent() const throw(INTERP_KERNEL::Exception);
38 std::string getInfoOnComponent(int i) const throw(INTERP_KERNEL::Exception);
39 std::string getVarOnComponent(int i) const throw(INTERP_KERNEL::Exception);
40 std::string getUnitOnComponent(int i) const throw(INTERP_KERNEL::Exception);
41 void setInfoOnComponent(int i, const char *info) throw(INTERP_KERNEL::Exception);
42 int getNumberOfComponents() const;
43 virtual void alloc(int nbOfTuple, int nbOfCompo=1) throw(INTERP_KERNEL::Exception);
44 virtual void reAlloc(int nbOfTuples) throw(INTERP_KERNEL::Exception);
45 virtual bool isAllocated() const throw(INTERP_KERNEL::Exception);
46 virtual void checkAllocated() const throw(INTERP_KERNEL::Exception);
47 virtual void desallocate() throw(INTERP_KERNEL::Exception);
48 virtual int getNumberOfTuples() const throw(INTERP_KERNEL::Exception);
49 virtual std::size_t getNbOfElems() const throw(INTERP_KERNEL::Exception);
50 virtual std::size_t getNbOfElemAllocated() const throw(INTERP_KERNEL::Exception);
51 virtual DataArray *deepCpy() const throw(INTERP_KERNEL::Exception);
52 virtual DataArray *selectByTupleId2(int bg, int end2, int step) const throw(INTERP_KERNEL::Exception);
53 virtual void rearrange(int newNbOfCompo) throw(INTERP_KERNEL::Exception);
54 void checkNbOfTuples(int nbOfTuples, const char *msg) const throw(INTERP_KERNEL::Exception);
55 void checkNbOfComps(int nbOfCompo, const char *msg) const throw(INTERP_KERNEL::Exception);
56 void checkNbOfTuplesAndComp(const DataArray& other, const char *msg) const throw(INTERP_KERNEL::Exception);
57 void checkNbOfTuplesAndComp(int nbOfTuples, int nbOfCompo, const char *msg) const throw(INTERP_KERNEL::Exception);
58 void checkNbOfElems(std::size_t nbOfElems, const char *msg) const throw(INTERP_KERNEL::Exception);
59 static int GetNumberOfItemGivenBES(int begin, int end, int step, const char *msg) throw(INTERP_KERNEL::Exception);
60 static int GetNumberOfItemGivenBESRelative(int begin, int end, int step, const char *msg) throw(INTERP_KERNEL::Exception);
61 static int GetPosOfItemGivenBESRelativeNoThrow(int value, int begin, int end, int step) throw(INTERP_KERNEL::Exception);
62 static std::string GetVarNameFromInfo(const std::string& info) throw(INTERP_KERNEL::Exception);
63 static std::string GetUnitFromInfo(const std::string& info) throw(INTERP_KERNEL::Exception);
64 void updateTime() const;
67 PyObject *getInfoOnComponents() const throw(INTERP_KERNEL::Exception)
69 const std::vector<std::string>& comps=self->getInfoOnComponents();
70 PyObject *ret=PyList_New((int)comps.size());
71 for(int i=0;i<(int)comps.size();i++)
72 PyList_SetItem(ret,i,PyString_FromString(comps[i].c_str()));
76 void copyPartOfStringInfoFrom(const DataArray& other, PyObject *li) throw(INTERP_KERNEL::Exception)
79 convertPyToNewIntArr3(li,tmp);
80 self->copyPartOfStringInfoFrom(other,tmp);
83 void copyPartOfStringInfoFrom2(PyObject *li, const DataArray& other) throw(INTERP_KERNEL::Exception)
86 convertPyToNewIntArr3(li,tmp);
87 self->copyPartOfStringInfoFrom2(tmp,other);
90 virtual void renumberInPlace(PyObject *li) throw(INTERP_KERNEL::Exception)
93 int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 );
97 INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
98 if(size!=self->getNumberOfTuples())
100 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
102 self->renumberInPlace(tmp);
106 DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
108 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
109 da2->checkAllocated();
110 int size=self->getNumberOfTuples();
111 if(size!=self->getNumberOfTuples())
113 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
115 self->renumberInPlace(da2->getConstPointer());
119 virtual void renumberInPlaceR(PyObject *li) throw(INTERP_KERNEL::Exception)
122 int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 );
123 if (!SWIG_IsOK(res1))
126 INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
127 if(size!=self->getNumberOfTuples())
129 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
131 self->renumberInPlaceR(tmp);
135 DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
137 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
138 da2->checkAllocated();
139 int size=self->getNumberOfTuples();
140 if(size!=self->getNumberOfTuples())
142 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
144 self->renumberInPlaceR(da2->getConstPointer());
148 //tuplesSelec in PyObject * because DataArrayInt is not already existing !
149 virtual void setContigPartOfSelectedValues(int tupleIdStart, PyObject *aBase, PyObject *tuplesSelec) throw(INTERP_KERNEL::Exception)
151 static const char msg[]="DataArray::setContigPartOfSelectedValues2 : 4th parameter \"tuplesSelec\" should be of type DataArrayInt";
152 DataArray *a=CheckAndRetrieveDataArrayInstance(aBase,"DataArray::setContigPartOfSelectedValues2 : 3rd parameter \"aBase\" should be of type DataArray");
153 DataArray *tuplesSelecPtr=CheckAndRetrieveDataArrayInstance(tuplesSelec,msg);
154 DataArrayInt *tuplesSelecPtr2=0;
157 tuplesSelecPtr2=dynamic_cast<DataArrayInt *>(tuplesSelecPtr);
159 throw INTERP_KERNEL::Exception(msg);
161 self->setContigPartOfSelectedValues(tupleIdStart,a,tuplesSelecPtr2);
164 virtual void setContigPartOfSelectedValues2(int tupleIdStart, PyObject *aBase, int bg, int end2, int step) throw(INTERP_KERNEL::Exception)
166 DataArray *a=CheckAndRetrieveDataArrayInstance(aBase,"DataArray::setContigPartOfSelectedValues2 : 2nd parameter \"aBase\" should be of type DataArray");
167 self->setContigPartOfSelectedValues2(tupleIdStart,a,bg,end2,step);
170 virtual DataArray *selectByTupleRanges(PyObject *li) const throw(INTERP_KERNEL::Exception)
172 std::vector<std::pair<int,int> > ranges;
173 convertPyToVectorPairInt(li,ranges);
174 return self->selectByTupleRanges(ranges);
177 virtual DataArray *selectByTupleId(PyObject *li) const throw(INTERP_KERNEL::Exception)
180 int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 );
181 if (!SWIG_IsOK(res1))
184 INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
185 return self->selectByTupleId(tmp,tmp+size);
189 DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
191 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
192 da2->checkAllocated();
193 return self->selectByTupleId(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
197 virtual DataArray *selectByTupleIdSafe(PyObject *li) const throw(INTERP_KERNEL::Exception)
200 int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 );
201 if (!SWIG_IsOK(res1))
204 INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
205 return self->selectByTupleIdSafe(tmp,tmp+size);
209 DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
211 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
212 da2->checkAllocated();
213 return self->selectByTupleIdSafe(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
217 virtual PyObject *keepSelectedComponents(PyObject *li) const throw(INTERP_KERNEL::Exception)
219 std::vector<int> tmp;
220 convertPyToNewIntArr3(li,tmp);
221 DataArray *ret=self->keepSelectedComponents(tmp);
222 return convertDataArray(ret,SWIG_POINTER_OWN | 0 );
225 static PyObject *GetSlice(PyObject *slic, int sliceId, int nbOfSlices) throw(INTERP_KERNEL::Exception)
227 if(!PySlice_Check(slic))
228 throw INTERP_KERNEL::Exception("DataArray::GetSlice (wrap) : expecting a pyslice as second (first) parameter !");
229 Py_ssize_t strt=2,stp=2,step=2;
230 PySliceObject *sly=reinterpret_cast<PySliceObject *>(slic);
231 if(PySlice_GetIndices(sly,std::numeric_limits<int>::max(),&strt,&stp,&step)!=0)
232 throw INTERP_KERNEL::Exception("DataArray::GetSlice (wrap) : the input slice is invalid !");
233 if(strt==std::numeric_limits<int>::max() || stp==std::numeric_limits<int>::max())
234 throw INTERP_KERNEL::Exception("DataArray::GetSlice (wrap) : the input slice contains some unknowns that can't be determined in static method ! Call DataArray::getSlice (non static) instead !");
236 DataArray::GetSlice(strt,stp,step,sliceId,nbOfSlices,a,b);
237 return PySlice_New(PyInt_FromLong(a),PyInt_FromLong(b),PyInt_FromLong(step));
240 PyObject *getSlice(PyObject *slic, int sliceId, int nbOfSlices) const throw(INTERP_KERNEL::Exception)
242 if(!PySlice_Check(slic))
243 throw INTERP_KERNEL::Exception("DataArray::getSlice (wrap) : expecting a pyslice as second (first) parameter !");
244 Py_ssize_t strt=2,stp=2,step=2;
245 PySliceObject *sly=reinterpret_cast<PySliceObject *>(slic);
246 if(PySlice_GetIndices(sly,self->getNumberOfTuples(),&strt,&stp,&step)!=0)
247 throw INTERP_KERNEL::Exception("DataArray::getSlice (wrap) : the input slice is invalid !");
249 DataArray::GetSlice(strt,stp,step,sliceId,nbOfSlices,a,b);
250 return PySlice_New(PyInt_FromLong(a),PyInt_FromLong(b),PyInt_FromLong(step));
253 static int GetNumberOfItemGivenBES(PyObject *slic) throw(INTERP_KERNEL::Exception)
255 if(!PySlice_Check(slic))
256 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBES (wrap) : expecting a pyslice as second (first) parameter !");
257 Py_ssize_t strt=2,stp=2,step=2;
258 PySliceObject *sly=reinterpret_cast<PySliceObject *>(slic);
259 if(PySlice_GetIndices(sly,std::numeric_limits<int>::max(),&strt,&stp,&step)!=0)
260 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBES (wrap) : the input slice is invalid !");
261 if(strt==std::numeric_limits<int>::max() || stp==std::numeric_limits<int>::max())
262 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBES (wrap) : the input slice contains some unknowns that can't be determined in static method !");
263 return DataArray::GetNumberOfItemGivenBES(strt,stp,step,"");
266 static int GetNumberOfItemGivenBESRelative(PyObject *slic) throw(INTERP_KERNEL::Exception)
268 if(!PySlice_Check(slic))
269 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBESRelative (wrap) : expecting a pyslice as second (first) parameter !");
270 Py_ssize_t strt=2,stp=2,step=2;
271 PySliceObject *sly=reinterpret_cast<PySliceObject *>(slic);
272 if(PySlice_GetIndices(sly,std::numeric_limits<int>::max(),&strt,&stp,&step)!=0)
273 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !");
274 if(strt==std::numeric_limits<int>::max() || stp==std::numeric_limits<int>::max())
275 throw INTERP_KERNEL::Exception("DataArray::GetNumberOfItemGivenBESRelative (wrap) : the input slice contains some unknowns that can't be determined in static method !");
276 return DataArray::GetNumberOfItemGivenBESRelative(strt,stp,step,"");
279 static DataArray *Aggregate(PyObject *arrs) throw(INTERP_KERNEL::Exception)
281 std::vector<const DataArray *> tmp;
282 convertFromPyObjVectorOfObj<const ParaMEDMEM::DataArray *>(arrs,SWIGTYPE_p_ParaMEDMEM__DataArray,"DataArray",tmp);
283 return DataArray::Aggregate(tmp);
286 int getNumberOfItemGivenBES(PyObject *slic) const throw(INTERP_KERNEL::Exception)
288 if(!PySlice_Check(slic))
289 throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBES (wrap) : expecting a pyslice as second (first) parameter !");
290 Py_ssize_t strt=2,stp=2,step=2;
291 PySliceObject *sly=reinterpret_cast<PySliceObject *>(slic);
292 if(PySlice_GetIndices(sly,self->getNumberOfTuples(),&strt,&stp,&step)!=0)
293 throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBES (wrap) : the input slice is invalid !");
294 return DataArray::GetNumberOfItemGivenBES(strt,stp,step,"");
297 int getNumberOfItemGivenBESRelative(PyObject *slic) throw(INTERP_KERNEL::Exception)
299 if(!PySlice_Check(slic))
300 throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBESRelative (wrap) : expecting a pyslice as second (first) parameter !");
301 Py_ssize_t strt=2,stp=2,step=2;
302 PySliceObject *sly=reinterpret_cast<PySliceObject *>(slic);
303 if(PySlice_GetIndices(sly,self->getNumberOfTuples(),&strt,&stp,&step)!=0)
304 throw INTERP_KERNEL::Exception("DataArray::getNumberOfItemGivenBESRelative (wrap) : the input slice is invalid !");
305 return DataArray::GetNumberOfItemGivenBESRelative(strt,stp,step,"");
311 class DataArrayDoubleIterator;
313 class DataArrayDouble : public DataArray
316 static DataArrayDouble *New();
317 double doubleValue() const throw(INTERP_KERNEL::Exception);
318 bool empty() const throw(INTERP_KERNEL::Exception);
319 DataArrayDouble *performCpy(bool deepCpy) const throw(INTERP_KERNEL::Exception);
320 void cpyFrom(const DataArrayDouble& other) throw(INTERP_KERNEL::Exception);
321 void reserve(std::size_t nbOfElems) throw(INTERP_KERNEL::Exception);
322 void pushBackSilent(double val) throw(INTERP_KERNEL::Exception);
323 double popBackSilent() throw(INTERP_KERNEL::Exception);
324 void pack() const throw(INTERP_KERNEL::Exception);
325 void allocIfNecessary(int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception);
326 void fillWithZero() throw(INTERP_KERNEL::Exception);
327 void fillWithValue(double val) throw(INTERP_KERNEL::Exception);
328 void iota(double init=0.) throw(INTERP_KERNEL::Exception);
329 bool isUniform(double val, double eps) const throw(INTERP_KERNEL::Exception);
330 void sort(bool asc=true) throw(INTERP_KERNEL::Exception);
331 void reverse() throw(INTERP_KERNEL::Exception);
332 void checkMonotonic(bool increasing, double eps) const throw(INTERP_KERNEL::Exception);
333 bool isMonotonic(bool increasing, double eps) const throw(INTERP_KERNEL::Exception);
334 std::string repr() const throw(INTERP_KERNEL::Exception);
335 std::string reprZip() const throw(INTERP_KERNEL::Exception);
336 bool isEqual(const DataArrayDouble& other, double prec) const throw(INTERP_KERNEL::Exception);
337 bool isEqualWithoutConsideringStr(const DataArrayDouble& other, double prec) const throw(INTERP_KERNEL::Exception);
338 DataArrayInt *convertToIntArr() const throw(INTERP_KERNEL::Exception);
339 DataArrayDouble *fromNoInterlace() const throw(INTERP_KERNEL::Exception);
340 DataArrayDouble *toNoInterlace() const throw(INTERP_KERNEL::Exception);
341 DataArrayDouble *substr(int tupleIdBg, int tupleIdEnd=-1) const throw(INTERP_KERNEL::Exception);
342 void transpose() throw(INTERP_KERNEL::Exception);
343 DataArrayDouble *changeNbOfComponents(int newNbOfComp, double dftValue) const throw(INTERP_KERNEL::Exception);
344 void meldWith(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception);
345 DataArrayDouble *duplicateEachTupleNTimes(int nbTimes) const throw(INTERP_KERNEL::Exception);
346 DataArrayDouble *getDifferentValues(double prec, int limitTupleId=-1) const throw(INTERP_KERNEL::Exception);
347 DataArrayInt *findClosestTupleId(const DataArrayDouble *other) const throw(INTERP_KERNEL::Exception);
348 DataArrayInt *computeNbOfInteractionsWith(const DataArrayDouble *otherBBoxFrmt, double eps) const throw(INTERP_KERNEL::Exception);
349 void setPartOfValues1(const DataArrayDouble *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare=true) throw(INTERP_KERNEL::Exception);
350 void setPartOfValuesSimple1(double a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp) throw(INTERP_KERNEL::Exception);
351 void setPartOfValuesAdv(const DataArrayDouble *a, const DataArrayInt *tuplesSelec) throw(INTERP_KERNEL::Exception);
352 double getIJ(int tupleId, int compoId) const throw(INTERP_KERNEL::Exception);
353 double front() const throw(INTERP_KERNEL::Exception);
354 double back() const throw(INTERP_KERNEL::Exception);
355 double getIJSafe(int tupleId, int compoId) const throw(INTERP_KERNEL::Exception);
356 void setIJ(int tupleId, int compoId, double newVal) throw(INTERP_KERNEL::Exception);
357 void setIJSilent(int tupleId, int compoId, double newVal) throw(INTERP_KERNEL::Exception);
358 double *getPointer() throw(INTERP_KERNEL::Exception);
359 void checkNoNullValues() const throw(INTERP_KERNEL::Exception);
360 DataArrayDouble *computeBBoxPerTuple(double epsilon=0.0) const throw(INTERP_KERNEL::Exception);
361 void recenterForMaxPrecision(double eps) throw(INTERP_KERNEL::Exception);
362 double getMaxValue(int& tupleId) const throw(INTERP_KERNEL::Exception);
363 double getMaxValueInArray() const throw(INTERP_KERNEL::Exception);
364 double getMinValue(int& tupleId) const throw(INTERP_KERNEL::Exception);
365 double getMinValueInArray() const throw(INTERP_KERNEL::Exception);
366 int count(double value, double eps) const throw(INTERP_KERNEL::Exception);
367 double getAverageValue() const throw(INTERP_KERNEL::Exception);
368 double norm2() const throw(INTERP_KERNEL::Exception);
369 double normMax() const throw(INTERP_KERNEL::Exception);
370 double accumulate(int compId) const throw(INTERP_KERNEL::Exception);
371 DataArrayDouble *fromPolarToCart() const throw(INTERP_KERNEL::Exception);
372 DataArrayDouble *fromCylToCart() const throw(INTERP_KERNEL::Exception);
373 DataArrayDouble *fromSpherToCart() const throw(INTERP_KERNEL::Exception);
374 DataArrayDouble *doublyContractedProduct() const throw(INTERP_KERNEL::Exception);
375 DataArrayDouble *determinant() const throw(INTERP_KERNEL::Exception);
376 DataArrayDouble *eigenValues() const throw(INTERP_KERNEL::Exception);
377 DataArrayDouble *eigenVectors() const throw(INTERP_KERNEL::Exception);
378 DataArrayDouble *inverse() const throw(INTERP_KERNEL::Exception);
379 DataArrayDouble *trace() const throw(INTERP_KERNEL::Exception);
380 DataArrayDouble *deviator() const throw(INTERP_KERNEL::Exception);
381 DataArrayDouble *magnitude() const throw(INTERP_KERNEL::Exception);
382 DataArrayDouble *maxPerTuple() const throw(INTERP_KERNEL::Exception);
383 DataArrayDouble *buildEuclidianDistanceDenseMatrix() const throw(INTERP_KERNEL::Exception);
384 DataArrayDouble *buildEuclidianDistanceDenseMatrixWith(const DataArrayDouble *other) const throw(INTERP_KERNEL::Exception);
385 void sortPerTuple(bool asc) throw(INTERP_KERNEL::Exception);
386 void abs() throw(INTERP_KERNEL::Exception);
387 void applyLin(double a, double b, int compoId) throw(INTERP_KERNEL::Exception);
388 void applyLin(double a, double b) throw(INTERP_KERNEL::Exception);
389 void applyInv(double numerator) throw(INTERP_KERNEL::Exception);
390 void applyPow(double val) throw(INTERP_KERNEL::Exception);
391 void applyRPow(double val) throw(INTERP_KERNEL::Exception);
392 DataArrayDouble *negate() const throw(INTERP_KERNEL::Exception);
393 DataArrayDouble *applyFunc(int nbOfComp, FunctionToEvaluate func) const throw(INTERP_KERNEL::Exception);
394 DataArrayDouble *applyFunc(int nbOfComp, const char *func) const throw(INTERP_KERNEL::Exception);
395 DataArrayDouble *applyFunc(const char *func) const throw(INTERP_KERNEL::Exception);
396 DataArrayDouble *applyFunc2(int nbOfComp, const char *func) const throw(INTERP_KERNEL::Exception);
397 DataArrayDouble *applyFunc3(int nbOfComp, const std::vector<std::string>& varsOrder, const char *func) const throw(INTERP_KERNEL::Exception);
398 void applyFuncFast32(const char *func) throw(INTERP_KERNEL::Exception);
399 void applyFuncFast64(const char *func) throw(INTERP_KERNEL::Exception);
400 DataArrayInt *getIdsInRange(double vmin, double vmax) const throw(INTERP_KERNEL::Exception);
401 static DataArrayDouble *Aggregate(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception);
402 static DataArrayDouble *Meld(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception);
403 static DataArrayDouble *Dot(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception);
404 static DataArrayDouble *CrossProduct(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception);
405 static DataArrayDouble *Max(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception);
406 static DataArrayDouble *Min(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception);
407 static DataArrayDouble *Add(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception);
408 void addEqual(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception);
409 static DataArrayDouble *Substract(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception);
410 void substractEqual(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception);
411 static DataArrayDouble *Multiply(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception);
412 void multiplyEqual(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception);
413 static DataArrayDouble *Divide(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception);
414 void divideEqual(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception);
415 static DataArrayDouble *Pow(const DataArrayDouble *a1, const DataArrayDouble *a2) throw(INTERP_KERNEL::Exception);
416 void powEqual(const DataArrayDouble *other) throw(INTERP_KERNEL::Exception);
419 DataArrayDouble() throw(INTERP_KERNEL::Exception)
421 return DataArrayDouble::New();
424 static DataArrayDouble *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0) throw(INTERP_KERNEL::Exception)
426 const char *msgBase="ParaMEDMEM::DataArrayDouble::New : Available API are : \n-DataArrayDouble.New()\n-DataArrayDouble.New([1.,3.,4.])\n-DataArrayDouble.New([1.,3.,4.],3)\n-DataArrayDouble.New([1.,3.,4.,5.],2,2)\n-DataArrayDouble.New([1.,3.,4.,5.,7,8.],3,2)\n-DataArrayDouble.New([(1.,3.),(4.,5.),(7,8.)])\n-DataArrayDouble.New(5)\n-DataArrayDouble.New(5,2)";
427 std::string msg(msgBase);
429 msg+="\n-DataArrayDouble.New(numpy array with dtype=float64)";
432 if(PyList_Check(elt0) || PyTuple_Check(elt0))
436 if(PyInt_Check(nbOfTuples))
438 int nbOfTuples1=PyInt_AS_LONG(nbOfTuples);
440 throw INTERP_KERNEL::Exception("DataArrayDouble::New : should be a positive set of allocated memory !");
443 if(PyInt_Check(elt2))
444 {//DataArrayDouble.New([1.,3.,4.,5.],2,2)
445 int nbOfCompo=PyInt_AS_LONG(elt2);
447 throw INTERP_KERNEL::Exception("DataArrayDouble::New : should be a positive number of components !");
448 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
449 std::vector<double> tmp=fillArrayWithPyListDbl2(elt0,nbOfTuples1,nbOfCompo);
450 ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
454 throw INTERP_KERNEL::Exception(msg.c_str());
457 {//DataArrayDouble.New([1.,3.,4.],3)
458 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
460 std::vector<double> tmp=fillArrayWithPyListDbl2(elt0,nbOfTuples1,tmpp1);
461 ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
466 throw INTERP_KERNEL::Exception(msg.c_str());
469 {// DataArrayDouble.New([1.,3.,4.])
470 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
471 int tmpp1=-1,tmpp2=-1;
472 std::vector<double> tmp=fillArrayWithPyListDbl2(elt0,tmpp1,tmpp2);
473 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
477 else if(PyInt_Check(elt0))
479 int nbOfTuples1=PyInt_AS_LONG(elt0);
481 throw INTERP_KERNEL::Exception("DataArrayDouble::New : should be a positive set of allocated memory !");
486 if(PyInt_Check(nbOfTuples))
487 {//DataArrayDouble.New(5,2)
488 int nbOfCompo=PyInt_AS_LONG(nbOfTuples);
490 throw INTERP_KERNEL::Exception("DataArrayDouble::New : should be a positive number of components !");
491 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
492 ret->alloc(nbOfTuples1,nbOfCompo);
496 throw INTERP_KERNEL::Exception(msg.c_str());
499 throw INTERP_KERNEL::Exception(msg.c_str());
502 {//DataArrayDouble.New(5)
503 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=DataArrayDouble::New();
504 ret->alloc(nbOfTuples1,1);
509 else if(PyArray_Check(elt0) && nbOfTuples==NULL && elt2==NULL)
510 {//DataArrayDouble.New(numpyArray)
511 return BuildNewInstance<DataArrayDouble,double>(elt0,NPY_DOUBLE,&PyCallBackDataArrayDouble_RefType,"FLOAT64");
515 throw INTERP_KERNEL::Exception(msg.c_str());
518 DataArrayDouble(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *elt2=0) throw(INTERP_KERNEL::Exception)
520 return ParaMEDMEM_DataArrayDouble_New__SWIG_1(elt0,nbOfTuples,elt2);
523 void pushBackValsSilent(PyObject *li) throw(INTERP_KERNEL::Exception)
526 std::vector<double> bb;
528 const char msg[]="Python wrap of DataArrayDouble::pushBackValsSilent : ";
529 const double *tmp=convertObjToPossibleCpp5_SingleCompo(li,sw,val,bb,msg,true,nbTuples);
530 self->pushBackValsSilent(tmp,tmp+nbTuples);
533 std::string __repr__() const throw(INTERP_KERNEL::Exception)
535 std::ostringstream oss;
536 self->reprQuickOverview(oss);
540 std::string __str__() const throw(INTERP_KERNEL::Exception)
545 double __float__() const throw(INTERP_KERNEL::Exception)
547 return self->doubleValue();
550 int __len__() const throw(INTERP_KERNEL::Exception)
552 if(self->isAllocated())
554 return self->getNumberOfTuples();
558 throw INTERP_KERNEL::Exception("DataArrayDouble::__len__ : Instance is NOT allocated !");
562 DataArrayDoubleIterator *__iter__() throw(INTERP_KERNEL::Exception)
564 return self->iterator();
567 void setValues(PyObject *li, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) throw(INTERP_KERNEL::Exception)
569 const char *msg="ParaMEDMEM::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 !";
570 if(PyList_Check(li) || PyTuple_Check(li))
574 if(PyInt_Check(nbOfTuples))
576 int nbOfTuples1=PyInt_AS_LONG(nbOfTuples);
578 throw INTERP_KERNEL::Exception("DataArrayDouble::setValues : should be a positive set of allocated memory !");
581 if(PyInt_Check(nbOfComp))
582 {//DataArrayDouble.setValues([1.,3.,4.,5.],2,2)
583 int nbOfCompo=PyInt_AS_LONG(nbOfComp);
585 throw INTERP_KERNEL::Exception("DataArrayDouble::setValues : should be a positive number of components !");
586 std::vector<double> tmp=fillArrayWithPyListDbl2(li,nbOfTuples1,nbOfCompo);
587 self->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),self->getPointer());
590 throw INTERP_KERNEL::Exception(msg);
593 {//DataArrayDouble.setValues([1.,3.,4.],3)
595 std::vector<double> tmp=fillArrayWithPyListDbl2(li,nbOfTuples1,tmpp1);
596 self->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),self->getPointer());
600 throw INTERP_KERNEL::Exception(msg);
603 {// DataArrayDouble.setValues([1.,3.,4.])
604 int tmpp1=-1,tmpp2=-1;
605 std::vector<double> tmp=fillArrayWithPyListDbl2(li,tmpp1,tmpp2);
606 self->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),self->getPointer());
610 throw INTERP_KERNEL::Exception(msg);
613 PyObject *getValues() const throw(INTERP_KERNEL::Exception)
615 const double *vals=self->getConstPointer();
616 return convertDblArrToPyList(vals,self->getNbOfElems());
620 PyObject *toNumPyArray() throw(INTERP_KERNEL::Exception) // not const. It is not a bug !
622 return ToNumPyArray<DataArrayDouble,double>(self,NPY_DOUBLE,"DataArrayDouble");
626 PyObject *isEqualIfNotWhy(const DataArrayDouble& other, double prec) const throw(INTERP_KERNEL::Exception)
629 bool ret0=self->isEqualIfNotWhy(other,prec,ret1);
630 PyObject *ret=PyTuple_New(2);
631 PyObject *ret0Py=ret0?Py_True:Py_False;
633 PyTuple_SetItem(ret,0,ret0Py);
634 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
638 PyObject *getValuesAsTuple() const throw(INTERP_KERNEL::Exception)
640 const double *vals=self->getConstPointer();
641 int nbOfComp=self->getNumberOfComponents();
642 int nbOfTuples=self->getNumberOfTuples();
643 return convertDblArrToPyListOfTuple(vals,nbOfComp,nbOfTuples);
646 DataArrayDouble *renumber(PyObject *li) throw(INTERP_KERNEL::Exception)
649 int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 );
650 if (!SWIG_IsOK(res1))
653 INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
654 if(size!=self->getNumberOfTuples())
656 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
658 return self->renumber(tmp);
662 DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
664 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
665 da2->checkAllocated();
666 int size=self->getNumberOfTuples();
667 if(size!=self->getNumberOfTuples())
669 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
671 return self->renumber(da2->getConstPointer());
675 DataArrayDouble *renumberR(PyObject *li) throw(INTERP_KERNEL::Exception)
678 int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 );
679 if (!SWIG_IsOK(res1))
682 INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
683 if(size!=self->getNumberOfTuples())
685 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
687 return self->renumberR(tmp);
691 DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
693 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
694 da2->checkAllocated();
695 int size=self->getNumberOfTuples();
696 if(size!=self->getNumberOfTuples())
698 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
700 return self->renumberR(da2->getConstPointer());
704 DataArrayDouble *renumberAndReduce(PyObject *li, int newNbOfTuple) throw(INTERP_KERNEL::Exception)
707 int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 );
708 if (!SWIG_IsOK(res1))
711 INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
712 if(size!=self->getNumberOfTuples())
714 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
716 return self->renumberAndReduce(tmp,newNbOfTuple);
720 DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
722 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
723 da2->checkAllocated();
724 int size=self->getNumberOfTuples();
725 if(size!=self->getNumberOfTuples())
727 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
729 return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
733 PyObject *minimalDistanceTo(const DataArrayDouble *other) const throw(INTERP_KERNEL::Exception)
735 int thisTupleId,otherTupleId;
736 double r0=self->minimalDistanceTo(other,thisTupleId,otherTupleId);
737 PyObject *ret=PyTuple_New(3);
738 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r0));
739 PyTuple_SetItem(ret,1,PyInt_FromLong(thisTupleId));
740 PyTuple_SetItem(ret,2,PyInt_FromLong(otherTupleId));
744 PyObject *getMaxValue() const throw(INTERP_KERNEL::Exception)
747 double r1=self->getMaxValue(tmp);
748 PyObject *ret=PyTuple_New(2);
749 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
750 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
754 PyObject *getMaxValue2() const throw(INTERP_KERNEL::Exception)
757 double r1=self->getMaxValue2(tmp);
758 PyObject *ret=PyTuple_New(2);
759 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
760 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ));
764 PyObject *getMinValue() const throw(INTERP_KERNEL::Exception)
767 double r1=self->getMinValue(tmp);
768 PyObject *ret=PyTuple_New(2);
769 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
770 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
774 PyObject *getMinValue2() const throw(INTERP_KERNEL::Exception)
777 double r1=self->getMinValue2(tmp);
778 PyObject *ret=PyTuple_New(2);
779 PyTuple_SetItem(ret,0,PyFloat_FromDouble(r1));
780 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(tmp),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ));
784 PyObject *getMinMaxPerComponent() const throw(INTERP_KERNEL::Exception)
786 int nbOfCompo=self->getNumberOfComponents();
787 INTERP_KERNEL::AutoPtr<double> tmp=new double[2*nbOfCompo];
788 self->getMinMaxPerComponent(tmp);
789 PyObject *ret=convertDblArrToPyListOfTuple(tmp,2,nbOfCompo);
793 PyObject *accumulate() const throw(INTERP_KERNEL::Exception)
795 int sz=self->getNumberOfComponents();
796 INTERP_KERNEL::AutoPtr<double> tmp=new double[sz];
797 self->accumulate(tmp);
798 return convertDblArrToPyList(tmp,sz);
801 DataArrayDouble *accumulatePerChunck(PyObject *indexArr) const throw(INTERP_KERNEL::Exception)
804 std::vector<int> val2;
805 const int *bg=convertObjToPossibleCpp1_Safe(indexArr,sw,sz,val,val2);
806 return self->accumulatePerChunck(bg,bg+sz);
809 PyObject *findCommonTuples(double prec, int limitNodeId=-1) const throw(INTERP_KERNEL::Exception)
811 DataArrayInt *comm, *commIndex;
812 self->findCommonTuples(prec,limitNodeId,comm,commIndex);
813 PyObject *res = PyList_New(2);
814 PyList_SetItem(res,0,SWIG_NewPointerObj(SWIG_as_voidptr(comm),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ));
815 PyList_SetItem(res,1,SWIG_NewPointerObj(SWIG_as_voidptr(commIndex),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ));
819 PyObject *distanceToTuple(PyObject *tuple) const throw(INTERP_KERNEL::Exception)
823 DataArrayDoubleTuple *aa;
824 std::vector<double> bb;
826 int tupleId=-1,nbOfCompo=self->getNumberOfComponents();
827 const double *pt=convertObjToPossibleCpp5_Safe(tuple,sw,val,a,aa,bb,"Python wrap of DataArrayDouble::distanceToTuple",1,nbOfCompo,true);
829 double ret0=self->distanceToTuple(pt,pt+nbOfCompo,tupleId);
830 PyObject *ret=PyTuple_New(2);
831 PyTuple_SetItem(ret,0,PyFloat_FromDouble(ret0));
832 PyTuple_SetItem(ret,1,PyInt_FromLong(tupleId));
836 void setSelectedComponents(const DataArrayDouble *a, PyObject *li) throw(INTERP_KERNEL::Exception)
838 std::vector<int> tmp;
839 convertPyToNewIntArr3(li,tmp);
840 self->setSelectedComponents(a,tmp);
843 PyObject *getTuple(int tupleId) throw(INTERP_KERNEL::Exception)
845 int sz=self->getNumberOfComponents();
846 INTERP_KERNEL::AutoPtr<double> tmp=new double[sz];
847 self->getTuple(tupleId,tmp);
848 return convertDblArrToPyList(tmp,sz);
851 static DataArrayDouble *Aggregate(PyObject *li) throw(INTERP_KERNEL::Exception)
853 std::vector<const DataArrayDouble *> tmp;
854 convertFromPyObjVectorOfObj<const DataArrayDouble *>(li,SWIGTYPE_p_ParaMEDMEM__DataArrayDouble,"DataArrayDouble",tmp);
855 return DataArrayDouble::Aggregate(tmp);
858 static DataArrayDouble *Meld(PyObject *li) throw(INTERP_KERNEL::Exception)
860 std::vector<const DataArrayDouble *> tmp;
861 convertFromPyObjVectorOfObj<const DataArrayDouble *>(li,SWIGTYPE_p_ParaMEDMEM__DataArrayDouble,"DataArrayDouble",tmp);
862 return DataArrayDouble::Meld(tmp);
865 PyObject *computeTupleIdsNearTuples(PyObject *pt, double eps) const throw(INTERP_KERNEL::Exception)
869 DataArrayDoubleTuple *aa;
870 std::vector<double> bb;
872 int nbComp=self->getNumberOfComponents(),nbTuples=-1;
873 const char msg[]="Python wrap of DataArrayDouble::computeTupleIdsNearTuples : ";
874 const double *pos=convertObjToPossibleCpp5_Safe2(pt,sw,val,a,aa,bb,msg,nbComp,true,nbTuples);
875 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> inpu=DataArrayDouble::New(); inpu->useArray(pos,false,CPP_DEALLOC,nbTuples,nbComp);
876 DataArrayInt *c=0,*cI=0;
877 self->computeTupleIdsNearTuples(inpu,eps,c,cI);
878 PyObject *ret=PyTuple_New(2);
879 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ));
880 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ));
884 PyObject *areIncludedInMe(const DataArrayDouble *other, double prec) const throw(INTERP_KERNEL::Exception)
886 DataArrayInt *ret1=0;
887 bool ret0=self->areIncludedInMe(other,prec,ret1);
888 PyObject *ret=PyTuple_New(2);
889 PyObject *ret0Py=ret0?Py_True:Py_False;
891 PyTuple_SetItem(ret,0,ret0Py);
892 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ));
896 PyObject *__getitem__(PyObject *obj) throw(INTERP_KERNEL::Exception)
898 const char msg[]="Unexpected situation in DataArrayDouble::__getitem__ !";
899 const char msg2[]="DataArrayDouble::__getitem__ : Mismatch of slice values in 2nd parameter (components) !";
900 self->checkAllocated();
901 int nbOfTuples=self->getNumberOfTuples();
902 int nbOfComponents=self->getNumberOfComponents();
904 std::vector<int> vt1,vc1;
905 std::pair<int, std::pair<int,int> > pt1,pc1;
906 DataArrayInt *dt1=0,*dc1=0;
908 convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1);
909 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret;
913 if(nbOfComponents==1)
914 return PyFloat_FromDouble(self->getIJSafe(it1,0));
915 return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(&it1,&it1+1)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
917 return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size())),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
919 return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleId2(pt1.first,pt1.second.first,pt1.second.second)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
921 return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems())),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
923 return PyFloat_FromDouble(self->getIJSafe(it1,ic1));
926 ret=self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size());
927 std::vector<int> v2(1,ic1);
928 return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
932 ret=self->selectByTupleId2(pt1.first,pt1.second.first,pt1.second.second);
933 std::vector<int> v2(1,ic1);
934 return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
938 ret=self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems());
939 std::vector<int> v2(1,ic1);
940 return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
944 ret=self->selectByTupleIdSafe(&it1,&it1+1);
945 return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
949 ret=self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size());
950 return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
954 ret=self->selectByTupleId2(pt1.first,pt1.second.first,pt1.second.second);
955 return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
959 ret=self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems());
960 return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
964 ret=self->selectByTupleIdSafe(&it1,&it1+1);
965 int nbOfComp=DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2);
966 std::vector<int> v2(nbOfComp);
967 for(int i=0;i<nbOfComp;i++)
968 v2[i]=pc1.first+i*pc1.second.second;
969 return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
973 ret=self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size());
974 int nbOfComp=DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2);
975 std::vector<int> v2(nbOfComp);
976 for(int i=0;i<nbOfComp;i++)
977 v2[i]=pc1.first+i*pc1.second.second;
978 return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
982 ret=self->selectByTupleId2(pt1.first,pt1.second.first,pt1.second.second);
983 int nbOfComp=DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2);
984 std::vector<int> v2(nbOfComp);
985 for(int i=0;i<nbOfComp;i++)
986 v2[i]=pc1.first+i*pc1.second.second;
987 return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
991 ret=self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems());
992 int nbOfComp=DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2);
993 std::vector<int> v2(nbOfComp);
994 for(int i=0;i<nbOfComp;i++)
995 v2[i]=pc1.first+i*pc1.second.second;
996 return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
999 throw INTERP_KERNEL::Exception(msg);
1003 DataArrayDouble *__setitem__(PyObject *obj, PyObject *value) throw(INTERP_KERNEL::Exception)
1005 self->checkAllocated();
1006 const char msg[]="Unexpected situation in DataArrayDouble::__setitem__ !";
1007 int nbOfTuples=self->getNumberOfTuples();
1008 int nbOfComponents=self->getNumberOfComponents();
1011 std::vector<double> v1;
1012 DataArrayDouble *d1=0;
1013 convertObjToPossibleCpp4(value,sw1,i1,v1,d1);
1015 std::vector<int> vt1,vc1;
1016 std::pair<int, std::pair<int,int> > pt1,pc1;
1017 DataArrayInt *dt1=0,*dc1=0;
1018 convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw2,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1);
1019 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> tmp;
1027 self->setPartOfValuesSimple1(i1,it1,it1+1,1,0,nbOfComponents,1);
1030 tmp=DataArrayDouble::New();
1031 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1032 self->setPartOfValues1(tmp,it1,it1+1,1,0,nbOfComponents,1,false);
1035 self->setPartOfValues1(d1,it1,it1+1,1,0,nbOfComponents,1);
1038 throw INTERP_KERNEL::Exception(msg);
1047 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1);
1050 tmp=DataArrayDouble::New();
1051 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1052 self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1,false);
1055 self->setPartOfValues3(d1,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1);
1058 throw INTERP_KERNEL::Exception(msg);
1067 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1);
1070 tmp=DataArrayDouble::New();
1071 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1072 self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1,false);
1075 self->setPartOfValues1(d1,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1);
1078 throw INTERP_KERNEL::Exception(msg);
1087 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1);
1090 tmp=DataArrayDouble::New();
1091 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1092 self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1,false);
1095 self->setPartOfValues3(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1);
1098 throw INTERP_KERNEL::Exception(msg);
1107 self->setPartOfValuesSimple1(i1,it1,it1+1,1,ic1,ic1+1,1);
1110 tmp=DataArrayDouble::New();
1111 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1112 self->setPartOfValues1(tmp,it1,it1+1,1,ic1,ic1+1,1,false);
1115 self->setPartOfValues1(d1,it1,it1+1,1,ic1,ic1+1,1);
1118 throw INTERP_KERNEL::Exception(msg);
1127 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1);
1130 tmp=DataArrayDouble::New();
1131 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1132 self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1,false);
1135 self->setPartOfValues3(d1,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1);
1138 throw INTERP_KERNEL::Exception(msg);
1147 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1);
1150 tmp=DataArrayDouble::New();
1151 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1152 self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1,false);
1155 self->setPartOfValues1(d1,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1);
1158 throw INTERP_KERNEL::Exception(msg);
1167 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1);
1170 tmp=DataArrayDouble::New();
1171 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1172 self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1,false);
1175 self->setPartOfValues3(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1);
1178 throw INTERP_KERNEL::Exception(msg);
1187 self->setPartOfValuesSimple2(i1,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size());
1190 tmp=DataArrayDouble::New();
1191 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1192 self->setPartOfValues2(tmp,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size(),false);
1195 self->setPartOfValues2(d1,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size());
1198 throw INTERP_KERNEL::Exception(msg);
1207 self->setPartOfValuesSimple2(i1,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size());
1210 tmp=DataArrayDouble::New();
1211 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1212 self->setPartOfValues2(tmp,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size(),false);
1215 self->setPartOfValues2(d1,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size());
1218 throw INTERP_KERNEL::Exception(msg);
1227 self->setPartOfValuesSimple4(i1,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size());
1230 tmp=DataArrayDouble::New();
1231 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1232 self->setPartOfValues4(tmp,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size(),false);
1235 self->setPartOfValues4(d1,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size());
1238 throw INTERP_KERNEL::Exception(msg);
1247 self->setPartOfValuesSimple2(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size());
1250 tmp=DataArrayDouble::New();
1251 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1252 self->setPartOfValues2(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size(),false);
1255 self->setPartOfValues2(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size());
1258 throw INTERP_KERNEL::Exception(msg);
1267 self->setPartOfValuesSimple1(i1,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second);
1270 tmp=DataArrayDouble::New();
1271 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1272 self->setPartOfValues1(tmp,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second,false);
1275 self->setPartOfValues1(d1,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second);
1278 throw INTERP_KERNEL::Exception(msg);
1287 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second);
1290 tmp=DataArrayDouble::New();
1291 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1292 self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second,false);
1295 self->setPartOfValues3(d1,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second);
1298 throw INTERP_KERNEL::Exception(msg);
1307 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second);
1310 tmp=DataArrayDouble::New();
1311 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1312 self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second,false);
1315 self->setPartOfValues1(d1,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second);
1318 throw INTERP_KERNEL::Exception(msg);
1327 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second);
1330 tmp=DataArrayDouble::New();
1331 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
1332 self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second,false);
1335 self->setPartOfValues3(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second);
1338 throw INTERP_KERNEL::Exception(msg);
1343 throw INTERP_KERNEL::Exception(msg);
1348 DataArrayDouble *__neg__() const throw(INTERP_KERNEL::Exception)
1350 return self->negate();
1353 PyObject *__add__(PyObject *obj) throw(INTERP_KERNEL::Exception)
1355 const char msg[]="Unexpected situation in DataArrayDouble.__add__ !";
1358 DataArrayDoubleTuple *aa;
1359 std::vector<double> bb;
1363 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_ParaMEDMEM__MEDCouplingFieldDouble,0|0)))
1365 MEDCouplingFieldDouble *other=reinterpret_cast< ParaMEDMEM::MEDCouplingFieldDouble * >(argp);
1368 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, 0 | 0 );
1369 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=ParaMEDMEM_MEDCouplingFieldDouble___radd__Impl(other,tmp);
1371 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_ParaMEDMEM__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1374 throw INTERP_KERNEL::Exception(msg);
1377 convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
1382 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=self->deepCpy();
1383 ret->applyLin(1.,val);
1384 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1388 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,a)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1392 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1393 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1397 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
1398 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Add(self,aaa)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1401 throw INTERP_KERNEL::Exception(msg);
1405 DataArrayDouble *__radd__(PyObject *obj) throw(INTERP_KERNEL::Exception)
1407 const char msg[]="Unexpected situation in __radd__ !";
1410 DataArrayDoubleTuple *aa;
1411 std::vector<double> bb;
1413 convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
1418 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=self->deepCpy();
1419 ret->applyLin(1.,val);
1424 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1425 return DataArrayDouble::Add(self,aaa);
1429 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
1430 return DataArrayDouble::Add(self,aaa);
1433 throw INTERP_KERNEL::Exception(msg);
1437 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
1439 const char msg[]="Unexpected situation in __iadd__ !";
1442 DataArrayDoubleTuple *aa;
1443 std::vector<double> bb;
1445 convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
1450 self->applyLin(1.,val);
1451 Py_XINCREF(trueSelf);
1457 Py_XINCREF(trueSelf);
1462 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1463 self->addEqual(aaa);
1464 Py_XINCREF(trueSelf);
1469 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
1470 self->addEqual(aaa);
1471 Py_XINCREF(trueSelf);
1475 throw INTERP_KERNEL::Exception(msg);
1479 PyObject *__sub__(PyObject *obj) throw(INTERP_KERNEL::Exception)
1481 const char msg[]="Unexpected situation in __sub__ !";
1484 DataArrayDoubleTuple *aa;
1485 std::vector<double> bb;
1489 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_ParaMEDMEM__MEDCouplingFieldDouble,0|0)))
1491 MEDCouplingFieldDouble *other=reinterpret_cast< ParaMEDMEM::MEDCouplingFieldDouble * >(argp);
1494 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, 0 | 0 );
1495 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=ParaMEDMEM_MEDCouplingFieldDouble___rsub__Impl(other,tmp);
1497 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_ParaMEDMEM__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1500 throw INTERP_KERNEL::Exception(msg);
1503 convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
1508 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=self->deepCpy();
1509 ret->applyLin(1.,-val);
1510 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1514 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,a)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1518 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1519 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1523 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
1524 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Substract(self,aaa)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1527 throw INTERP_KERNEL::Exception(msg);
1531 DataArrayDouble *__rsub__(PyObject *obj) throw(INTERP_KERNEL::Exception)
1533 const char msg[]="Unexpected situation in __rsub__ !";
1536 DataArrayDoubleTuple *aa;
1537 std::vector<double> bb;
1539 convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
1544 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=self->deepCpy();
1545 ret->applyLin(-1.,val);
1550 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1551 return DataArrayDouble::Substract(aaa,self);
1555 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
1556 return DataArrayDouble::Substract(aaa,self);
1559 throw INTERP_KERNEL::Exception(msg);
1563 PyObject *___isub___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
1565 const char msg[]="Unexpected situation in __isub__ !";
1568 DataArrayDoubleTuple *aa;
1569 std::vector<double> bb;
1571 convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
1576 self->applyLin(1,-val);
1577 Py_XINCREF(trueSelf);
1582 self->substractEqual(a);
1583 Py_XINCREF(trueSelf);
1588 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1589 self->substractEqual(aaa);
1590 Py_XINCREF(trueSelf);
1595 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
1596 self->substractEqual(aaa);
1597 Py_XINCREF(trueSelf);
1601 throw INTERP_KERNEL::Exception(msg);
1605 PyObject *__mul__(PyObject *obj) throw(INTERP_KERNEL::Exception)
1607 const char msg[]="Unexpected situation in __mul__ !";
1610 DataArrayDoubleTuple *aa;
1611 std::vector<double> bb;
1615 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_ParaMEDMEM__MEDCouplingFieldDouble,0|0)))
1617 MEDCouplingFieldDouble *other=reinterpret_cast< ParaMEDMEM::MEDCouplingFieldDouble * >(argp);
1620 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, 0 | 0 );
1621 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=ParaMEDMEM_MEDCouplingFieldDouble___rmul__Impl(other,tmp);
1623 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_ParaMEDMEM__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1626 throw INTERP_KERNEL::Exception(msg);
1629 convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
1634 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=self->deepCpy();
1635 ret->applyLin(val,0.);
1636 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1640 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,a)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1644 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1645 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1649 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
1650 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Multiply(self,aaa)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1653 throw INTERP_KERNEL::Exception(msg);
1657 DataArrayDouble *__rmul__(PyObject *obj) throw(INTERP_KERNEL::Exception)
1659 const char msg[]="Unexpected situation in __rmul__ !";
1662 DataArrayDoubleTuple *aa;
1663 std::vector<double> bb;
1665 convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
1670 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=self->deepCpy();
1671 ret->applyLin(val,0.);
1676 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1677 return DataArrayDouble::Multiply(self,aaa);
1681 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
1682 return DataArrayDouble::Multiply(self,aaa);
1685 throw INTERP_KERNEL::Exception(msg);
1689 PyObject *___imul___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
1691 const char msg[]="Unexpected situation in __imul__ !";
1694 DataArrayDoubleTuple *aa;
1695 std::vector<double> bb;
1697 convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
1702 self->applyLin(val,0.);
1703 Py_XINCREF(trueSelf);
1708 self->multiplyEqual(a);
1709 Py_XINCREF(trueSelf);
1714 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1715 self->multiplyEqual(aaa);
1716 Py_XINCREF(trueSelf);
1721 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
1722 self->multiplyEqual(aaa);
1723 Py_XINCREF(trueSelf);
1727 throw INTERP_KERNEL::Exception(msg);
1731 PyObject *__div__(PyObject *obj) throw(INTERP_KERNEL::Exception)
1733 const char msg[]="Unexpected situation in __div__ !";
1736 DataArrayDoubleTuple *aa;
1737 std::vector<double> bb;
1741 if(SWIG_IsOK(SWIG_ConvertPtr(obj,&argp,SWIGTYPE_p_ParaMEDMEM__MEDCouplingFieldDouble,0|0)))
1743 MEDCouplingFieldDouble *other=reinterpret_cast< ParaMEDMEM::MEDCouplingFieldDouble * >(argp);
1746 PyObject *tmp=SWIG_NewPointerObj(SWIG_as_voidptr(self),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, 0 | 0 );
1747 MEDCouplingAutoRefCountObjectPtr<MEDCouplingFieldDouble> ret=ParaMEDMEM_MEDCouplingFieldDouble___rdiv__Impl(other,tmp);
1749 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_ParaMEDMEM__MEDCouplingFieldDouble, SWIG_POINTER_OWN | 0 );
1752 throw INTERP_KERNEL::Exception(msg);
1755 convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
1761 throw INTERP_KERNEL::Exception("DataArrayDouble::__div__ : trying to divide by zero !");
1762 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=self->deepCpy();
1763 ret->applyLin(1/val,0.);
1764 return SWIG_NewPointerObj(SWIG_as_voidptr(ret.retn()),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1768 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,a)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1772 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1773 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1777 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
1778 return SWIG_NewPointerObj(SWIG_as_voidptr(DataArrayDouble::Divide(self,aaa)),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 );
1781 throw INTERP_KERNEL::Exception(msg);
1785 DataArrayDouble *__rdiv__(PyObject *obj) throw(INTERP_KERNEL::Exception)
1787 const char msg[]="Unexpected situation in __rdiv__ !";
1790 DataArrayDoubleTuple *aa;
1791 std::vector<double> bb;
1793 convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
1798 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=self->deepCpy();
1804 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1805 return DataArrayDouble::Divide(aaa,self);
1809 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
1810 return DataArrayDouble::Divide(aaa,self);
1813 throw INTERP_KERNEL::Exception(msg);
1817 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
1819 const char msg[]="Unexpected situation in __idiv__ !";
1822 DataArrayDoubleTuple *aa;
1823 std::vector<double> bb;
1825 convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
1831 throw INTERP_KERNEL::Exception("DataArrayDouble::__div__ : trying to divide by zero !");
1832 self->applyLin(1./val,0.);
1833 Py_XINCREF(trueSelf);
1838 self->divideEqual(a);
1839 Py_XINCREF(trueSelf);
1844 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1845 self->divideEqual(aaa);
1846 Py_XINCREF(trueSelf);
1851 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
1852 self->divideEqual(aaa);
1853 Py_XINCREF(trueSelf);
1857 throw INTERP_KERNEL::Exception(msg);
1861 DataArrayDouble *__pow__(PyObject *obj) throw(INTERP_KERNEL::Exception)
1863 const char msg[]="Unexpected situation in __pow__ !";
1866 DataArrayDoubleTuple *aa;
1867 std::vector<double> bb;
1869 convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
1874 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=self->deepCpy();
1880 return DataArrayDouble::Pow(self,a);
1884 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1885 return DataArrayDouble::Pow(self,aaa);
1889 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
1890 return DataArrayDouble::Pow(self,aaa);
1893 throw INTERP_KERNEL::Exception(msg);
1897 DataArrayDouble *__rpow__(PyObject *obj) throw(INTERP_KERNEL::Exception)
1899 const char msg[]="Unexpected situation in __rpow__ !";
1902 DataArrayDoubleTuple *aa;
1903 std::vector<double> bb;
1905 convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
1910 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=self->deepCpy();
1911 ret->applyRPow(val);
1916 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1917 return DataArrayDouble::Pow(aaa,self);
1921 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
1922 return DataArrayDouble::Pow(aaa,self);
1925 throw INTERP_KERNEL::Exception(msg);
1929 PyObject *___ipow___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
1931 const char msg[]="Unexpected situation in __ipow__ !";
1934 DataArrayDoubleTuple *aa;
1935 std::vector<double> bb;
1937 convertObjToPossibleCpp5(obj,sw,val,a,aa,bb);
1942 self->applyPow(val);
1943 Py_XINCREF(trueSelf);
1949 Py_XINCREF(trueSelf);
1954 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=aa->buildDADouble(1,self->getNumberOfComponents());
1955 self->powEqual(aaa);
1956 Py_XINCREF(trueSelf);
1961 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> aaa=DataArrayDouble::New(); aaa->useArray(&bb[0],false,CPP_DEALLOC,1,(int)bb.size());
1962 self->powEqual(aaa);
1963 Py_XINCREF(trueSelf);
1967 throw INTERP_KERNEL::Exception(msg);
1971 PyObject *computeTupleIdsNearTuples(const DataArrayDouble *other, double eps)
1973 DataArrayInt *c=0,*cI=0;
1975 self->computeTupleIdsNearTuples(other,eps,c,cI);
1976 PyObject *ret=PyTuple_New(2);
1977 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(c),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ));
1978 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(cI),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ));
1982 PyObject *maxPerTupleWithCompoId() const throw(INTERP_KERNEL::Exception)
1984 DataArrayInt *ret1=0;
1985 DataArrayDouble *ret0=self->maxPerTupleWithCompoId(ret1);
1986 PyObject *ret=PyTuple_New(2);
1987 PyTuple_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_ParaMEDMEM__DataArrayDouble, SWIG_POINTER_OWN | 0 ));
1988 PyTuple_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ));
1994 class DataArrayDoubleTuple;
1996 class DataArrayDoubleIterator
1999 DataArrayDoubleIterator(DataArrayDouble *da);
2000 ~DataArrayDoubleIterator();
2005 DataArrayDoubleTuple *ret=self->nextt();
2007 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_ParaMEDMEM__DataArrayDoubleTuple,SWIG_POINTER_OWN|0);
2010 PyErr_SetString(PyExc_StopIteration,"No more data.");
2017 class DataArrayDoubleTuple
2020 int getNumberOfCompo() const throw(INTERP_KERNEL::Exception);
2021 DataArrayDouble *buildDADouble(int nbOfTuples, int nbOfCompo) const throw(INTERP_KERNEL::Exception);
2024 std::string __str__() const throw(INTERP_KERNEL::Exception)
2026 return self->repr();
2029 double __float__() const throw(INTERP_KERNEL::Exception)
2031 return self->doubleValue();
2034 DataArrayDouble *buildDADouble() throw(INTERP_KERNEL::Exception)
2036 return self->buildDADouble(1,self->getNumberOfCompo());
2039 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
2041 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2042 ParaMEDMEM_DataArrayDouble____iadd___(ret,0,obj);
2043 Py_XINCREF(trueSelf);
2047 PyObject *___isub___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
2049 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2050 ParaMEDMEM_DataArrayDouble____isub___(ret,0,obj);
2051 Py_XINCREF(trueSelf);
2055 PyObject *___imul___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
2057 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2058 ParaMEDMEM_DataArrayDouble____imul___(ret,0,obj);
2059 Py_XINCREF(trueSelf);
2063 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
2065 MEDCouplingAutoRefCountObjectPtr<DataArrayDouble> ret=self->buildDADouble(1,self->getNumberOfCompo());
2066 ParaMEDMEM_DataArrayDouble____idiv___(ret,0,obj);
2067 Py_XINCREF(trueSelf);
2071 PyObject *__getitem__(PyObject *obj) throw(INTERP_KERNEL::Exception)
2073 const char msg2[]="DataArrayDoubleTuple::__getitem__ : Mismatch of slice values in 2nd parameter (components) !";
2076 std::vector<int> multiVal;
2077 std::pair<int, std::pair<int,int> > slic;
2078 ParaMEDMEM::DataArrayInt *daIntTyypp=0;
2079 const double *pt=self->getConstPointer();
2080 int nbc=self->getNumberOfCompo();
2081 convertObjToPossibleCpp2(obj,nbc,sw,singleVal,multiVal,slic,daIntTyypp);
2088 std::ostringstream oss;
2089 oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2090 throw INTERP_KERNEL::Exception(oss.str().c_str());
2093 return PyFloat_FromDouble(pt[singleVal]);
2097 return PyFloat_FromDouble(pt[nbc+singleVal]);
2100 std::ostringstream oss;
2101 oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
2102 throw INTERP_KERNEL::Exception(oss.str().c_str());
2108 PyObject *t=PyTuple_New(multiVal.size());
2109 for(int j=0;j<(int)multiVal.size();j++)
2111 int cid=multiVal[j];
2114 std::ostringstream oss;
2115 oss << "Requesting for id #" << cid << " having only " << nbc << " components !";
2116 throw INTERP_KERNEL::Exception(oss.str().c_str());
2118 PyTuple_SetItem(t,j,PyFloat_FromDouble(pt[cid]));
2124 int sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2125 PyObject *t=PyTuple_New(sz);
2126 for(int j=0;j<sz;j++)
2127 PyTuple_SetItem(t,j,PyFloat_FromDouble(pt[slic.first+j*slic.second.second]));
2131 throw INTERP_KERNEL::Exception("DataArrayDoubleTuple::__getitem__ : unrecognized type entered !");
2135 DataArrayDoubleTuple *__setitem__(PyObject *obj, PyObject *value) throw(INTERP_KERNEL::Exception)
2137 const char msg[]="DataArrayDoubleTuple::__setitem__ : unrecognized type entered, int, slice, list<int>, tuple<int> !";
2138 const char msg2[]="DataArrayDoubleTuple::__setitem__ : Mismatch of slice values in 2nd parameter (components) !";
2141 std::vector<double> multiValV;
2142 ParaMEDMEM::DataArrayDoubleTuple *daIntTyyppV=0;
2143 int nbc=self->getNumberOfCompo();
2144 convertObjToPossibleCpp44(value,sw1,singleValV,multiValV,daIntTyyppV);
2146 std::vector<int> multiVal;
2147 std::pair<int, std::pair<int,int> > slic;
2148 ParaMEDMEM::DataArrayInt *daIntTyypp=0;
2149 double *pt=self->getPointer();
2150 convertObjToPossibleCpp2(obj,nbc,sw2,singleVal,multiVal,slic,daIntTyypp);
2157 std::ostringstream oss;
2158 oss << "Requesting for setting id # " << singleVal << " having only " << nbc << " components !";
2159 throw INTERP_KERNEL::Exception(oss.str().c_str());
2165 pt[singleVal]=singleValV;
2170 if(multiValV.size()!=1)
2172 std::ostringstream oss;
2173 oss << "Requesting for setting id # " << singleVal << " with a list or tuple with size != 1 ! ";
2174 throw INTERP_KERNEL::Exception(oss.str().c_str());
2176 pt[singleVal]=multiValV[0];
2181 pt[singleVal]=daIntTyyppV->getConstPointer()[0];
2185 throw INTERP_KERNEL::Exception(msg);
2194 for(std::vector<int>::const_iterator it=multiVal.begin();it!=multiVal.end();it++)
2198 std::ostringstream oss;
2199 oss << "Requesting for setting id # " << *it << " having only " << nbc << " components !";
2200 throw INTERP_KERNEL::Exception(oss.str().c_str());
2208 if(multiVal.size()!=multiValV.size())
2210 std::ostringstream oss;
2211 oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << multiVal.size() << " !";
2212 throw INTERP_KERNEL::Exception(oss.str().c_str());
2214 for(int i=0;i<(int)multiVal.size();i++)
2216 int pos=multiVal[i];
2219 std::ostringstream oss;
2220 oss << "Requesting for setting id # " << pos << " having only " << nbc << " components !";
2221 throw INTERP_KERNEL::Exception(oss.str().c_str());
2223 pt[multiVal[i]]=multiValV[i];
2229 const double *ptV=daIntTyyppV->getConstPointer();
2230 if(nbc>daIntTyyppV->getNumberOfCompo())
2232 std::ostringstream oss;
2233 oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2234 throw INTERP_KERNEL::Exception(oss.str().c_str());
2236 std::copy(ptV,ptV+nbc,pt);
2240 throw INTERP_KERNEL::Exception(msg);
2245 int sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
2250 for(int j=0;j<sz;j++)
2251 pt[slic.first+j*slic.second.second]=singleValV;
2256 if(sz!=(int)multiValV.size())
2258 std::ostringstream oss;
2259 oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << sz << " !";
2260 throw INTERP_KERNEL::Exception(oss.str().c_str());
2262 for(int j=0;j<sz;j++)
2263 pt[slic.first+j*slic.second.second]=multiValV[j];
2268 const double *ptV=daIntTyyppV->getConstPointer();
2269 if(sz>daIntTyyppV->getNumberOfCompo())
2271 std::ostringstream oss;
2272 oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
2273 throw INTERP_KERNEL::Exception(oss.str().c_str());
2275 for(int j=0;j<sz;j++)
2276 pt[slic.first+j*slic.second.second]=ptV[j];
2280 throw INTERP_KERNEL::Exception(msg);
2284 throw INTERP_KERNEL::Exception(msg);
2290 class DataArrayIntIterator;
2292 class DataArrayInt : public DataArray
2295 static DataArrayInt *New();
2296 int intValue() const throw(INTERP_KERNEL::Exception);
2297 int getHashCode() const throw(INTERP_KERNEL::Exception);
2298 bool empty() const throw(INTERP_KERNEL::Exception);
2299 DataArrayInt *performCpy(bool deepCpy) const throw(INTERP_KERNEL::Exception);
2300 void cpyFrom(const DataArrayInt& other) throw(INTERP_KERNEL::Exception);
2301 void reserve(std::size_t nbOfElems) throw(INTERP_KERNEL::Exception);
2302 void pushBackSilent(int val) throw(INTERP_KERNEL::Exception);
2303 int popBackSilent() throw(INTERP_KERNEL::Exception);
2304 void pack() const throw(INTERP_KERNEL::Exception);
2305 void allocIfNecessary(int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception);
2306 bool isEqual(const DataArrayInt& other) const throw(INTERP_KERNEL::Exception);
2307 bool isEqualWithoutConsideringStr(const DataArrayInt& other) const throw(INTERP_KERNEL::Exception);
2308 bool isEqualWithoutConsideringStrAndOrder(const DataArrayInt& other) const throw(INTERP_KERNEL::Exception);
2309 DataArrayInt *buildPermutationArr(const DataArrayInt& other) const throw(INTERP_KERNEL::Exception);
2310 void sort(bool asc=true) throw(INTERP_KERNEL::Exception);
2311 void reverse() throw(INTERP_KERNEL::Exception);
2312 void checkMonotonic(bool increasing) const throw(INTERP_KERNEL::Exception);
2313 bool isMonotonic(bool increasing) const throw(INTERP_KERNEL::Exception);
2314 void checkStrictlyMonotonic(bool increasing) const throw(INTERP_KERNEL::Exception);
2315 bool isStrictlyMonotonic(bool increasing) const throw(INTERP_KERNEL::Exception);
2316 void fillWithZero() throw(INTERP_KERNEL::Exception);
2317 void fillWithValue(int val) throw(INTERP_KERNEL::Exception);
2318 void iota(int init=0) throw(INTERP_KERNEL::Exception);
2319 std::string repr() const throw(INTERP_KERNEL::Exception);
2320 std::string reprZip() const throw(INTERP_KERNEL::Exception);
2321 DataArrayInt *invertArrayO2N2N2O(int newNbOfElem) const throw(INTERP_KERNEL::Exception);
2322 DataArrayInt *invertArrayN2O2O2N(int oldNbOfElem) const throw(INTERP_KERNEL::Exception);
2323 DataArrayInt *invertArrayO2N2N2OBis(int newNbOfElem) const throw(INTERP_KERNEL::Exception);
2324 DataArrayDouble *convertToDblArr() const throw(INTERP_KERNEL::Exception);
2325 DataArrayInt *fromNoInterlace() const throw(INTERP_KERNEL::Exception);
2326 DataArrayInt *toNoInterlace() const throw(INTERP_KERNEL::Exception);
2327 DataArrayInt *selectByTupleId2(int bg, int end, int step) const throw(INTERP_KERNEL::Exception);
2328 DataArrayInt *checkAndPreparePermutation() const throw(INTERP_KERNEL::Exception);
2329 DataArrayInt *buildPermArrPerLevel() const throw(INTERP_KERNEL::Exception);
2330 bool isIdentity() const throw(INTERP_KERNEL::Exception);
2331 bool isUniform(int val) const throw(INTERP_KERNEL::Exception);
2332 DataArrayInt *substr(int tupleIdBg, int tupleIdEnd=-1) const throw(INTERP_KERNEL::Exception);
2333 void transpose() throw(INTERP_KERNEL::Exception);
2334 DataArrayInt *changeNbOfComponents(int newNbOfComp, int dftValue) const throw(INTERP_KERNEL::Exception);
2335 void meldWith(const DataArrayInt *other) throw(INTERP_KERNEL::Exception);
2336 void setPartOfValues1(const DataArrayInt *a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp, bool strictCompoCompare=true) throw(INTERP_KERNEL::Exception);
2337 void setPartOfValuesSimple1(int a, int bgTuples, int endTuples, int stepTuples, int bgComp, int endComp, int stepComp) throw(INTERP_KERNEL::Exception);
2338 void setPartOfValuesAdv(const DataArrayInt *a, const DataArrayInt *tuplesSelec) throw(INTERP_KERNEL::Exception);
2339 void getTuple(int tupleId, int *res) const throw(INTERP_KERNEL::Exception);
2340 int getIJ(int tupleId, int compoId) const throw(INTERP_KERNEL::Exception);
2341 int getIJSafe(int tupleId, int compoId) const throw(INTERP_KERNEL::Exception);
2342 int front() const throw(INTERP_KERNEL::Exception);
2343 int back() const throw(INTERP_KERNEL::Exception);
2344 void setIJ(int tupleId, int compoId, int newVal) throw(INTERP_KERNEL::Exception);
2345 void setIJSilent(int tupleId, int compoId, int newVal) throw(INTERP_KERNEL::Exception);
2346 int *getPointer() throw(INTERP_KERNEL::Exception);
2347 const int *getConstPointer() const throw(INTERP_KERNEL::Exception);
2348 DataArrayIntIterator *iterator() throw(INTERP_KERNEL::Exception);
2349 const int *begin() const throw(INTERP_KERNEL::Exception);
2350 const int *end() const throw(INTERP_KERNEL::Exception);
2351 DataArrayInt *getIdsEqual(int val) const throw(INTERP_KERNEL::Exception);
2352 DataArrayInt *getIdsNotEqual(int val) const throw(INTERP_KERNEL::Exception);
2353 int changeValue(int oldValue, int newValue) throw(INTERP_KERNEL::Exception);
2354 int locateTuple(const std::vector<int>& tupl) const throw(INTERP_KERNEL::Exception);
2355 int locateValue(int value) const throw(INTERP_KERNEL::Exception);
2356 int locateValue(const std::vector<int>& vals) const throw(INTERP_KERNEL::Exception);
2357 int search(const std::vector<int>& vals) const throw(INTERP_KERNEL::Exception);
2358 bool presenceOfTuple(const std::vector<int>& tupl) const throw(INTERP_KERNEL::Exception);
2359 bool presenceOfValue(int value) const throw(INTERP_KERNEL::Exception);
2360 bool presenceOfValue(const std::vector<int>& vals) const throw(INTERP_KERNEL::Exception);
2361 int count(int value) const throw(INTERP_KERNEL::Exception);
2362 int accumulate(int compId) const throw(INTERP_KERNEL::Exception);
2363 int getMaxValue(int& tupleId) const throw(INTERP_KERNEL::Exception);
2364 int getMaxValueInArray() const throw(INTERP_KERNEL::Exception);
2365 int getMinValue(int& tupleId) const throw(INTERP_KERNEL::Exception);
2366 int getMinValueInArray() const throw(INTERP_KERNEL::Exception);
2367 void abs() throw(INTERP_KERNEL::Exception);
2368 void applyLin(int a, int b, int compoId) throw(INTERP_KERNEL::Exception);
2369 void applyLin(int a, int b) throw(INTERP_KERNEL::Exception);
2370 void applyInv(int numerator) throw(INTERP_KERNEL::Exception);
2371 DataArrayInt *negate() const throw(INTERP_KERNEL::Exception);
2372 void applyDivideBy(int val) throw(INTERP_KERNEL::Exception);
2373 void applyModulus(int val) throw(INTERP_KERNEL::Exception);
2374 void applyRModulus(int val) throw(INTERP_KERNEL::Exception);
2375 void applyPow(int val) throw(INTERP_KERNEL::Exception);
2376 void applyRPow(int val) throw(INTERP_KERNEL::Exception);
2377 DataArrayInt *getIdsInRange(int vmin, int vmax) const throw(INTERP_KERNEL::Exception);
2378 bool checkAllIdsInRange(int vmin, int vmax) const throw(INTERP_KERNEL::Exception);
2379 static DataArrayInt *Aggregate(const DataArrayInt *a1, const DataArrayInt *a2, int offsetA2) throw(INTERP_KERNEL::Exception);
2380 static DataArrayInt *Meld(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception);
2381 static DataArrayInt *MakePartition(const std::vector<const DataArrayInt *>& groups, int newNb, std::vector< std::vector<int> >& fidsOfGroups) throw(INTERP_KERNEL::Exception);
2382 static DataArrayInt *BuildUnion(const std::vector<const DataArrayInt *>& arr) throw(INTERP_KERNEL::Exception);
2383 static DataArrayInt *BuildIntersection(const std::vector<const DataArrayInt *>& arr) throw(INTERP_KERNEL::Exception);
2384 static DataArrayInt *FindPermutationFromFirstToSecond(const DataArrayInt *ids1, const DataArrayInt *ids2) throw(INTERP_KERNEL::Exception);
2385 DataArrayInt *buildComplement(int nbOfElement) const throw(INTERP_KERNEL::Exception);
2386 DataArrayInt *buildSubstraction(const DataArrayInt *other) const throw(INTERP_KERNEL::Exception);
2387 DataArrayInt *buildSubstractionOptimized(const DataArrayInt *other) const throw(INTERP_KERNEL::Exception);
2388 DataArrayInt *buildUnion(const DataArrayInt *other) const throw(INTERP_KERNEL::Exception);
2389 DataArrayInt *buildIntersection(const DataArrayInt *other) const throw(INTERP_KERNEL::Exception);
2390 DataArrayInt *buildUnique() const throw(INTERP_KERNEL::Exception);
2391 DataArrayInt *deltaShiftIndex() const throw(INTERP_KERNEL::Exception);
2392 void computeOffsets() throw(INTERP_KERNEL::Exception);
2393 void computeOffsets2() throw(INTERP_KERNEL::Exception);
2394 DataArrayInt *buildExplicitArrByRanges(const DataArrayInt *offsets) const throw(INTERP_KERNEL::Exception);
2395 DataArrayInt *findRangeIdForEachTuple(const DataArrayInt *ranges) const throw(INTERP_KERNEL::Exception);
2396 DataArrayInt *findIdInRangeForEachTuple(const DataArrayInt *ranges) const throw(INTERP_KERNEL::Exception);
2397 DataArrayInt *duplicateEachTupleNTimes(int nbTimes) const throw(INTERP_KERNEL::Exception);
2398 DataArrayInt *getDifferentValues() const throw(INTERP_KERNEL::Exception);
2399 static DataArrayInt *Add(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception);
2400 void addEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception);
2401 static DataArrayInt *Substract(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception);
2402 void substractEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception);
2403 static DataArrayInt *Multiply(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception);
2404 void multiplyEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception);
2405 static DataArrayInt *Divide(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception);
2406 void divideEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception);
2407 static DataArrayInt *Modulus(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception);
2408 void modulusEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception);
2409 static DataArrayInt *Pow(const DataArrayInt *a1, const DataArrayInt *a2) throw(INTERP_KERNEL::Exception);
2410 void powEqual(const DataArrayInt *other) throw(INTERP_KERNEL::Exception);
2412 static DataArrayInt *Range(int begin, int end, int step) throw(INTERP_KERNEL::Exception);
2415 DataArrayInt() throw(INTERP_KERNEL::Exception)
2417 return DataArrayInt::New();
2420 static DataArrayInt *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) throw(INTERP_KERNEL::Exception)
2422 const char *msgBase="ParaMEDMEM::DataArrayInt::New : Available API are : \n-DataArrayInt.New()\n-DataArrayInt.New([1,3,4])\n-DataArrayInt.New([1,3,4],3)\n-DataArrayInt.New([1,3,4,5],2,2)\n-DataArrayInt.New([1,3,4,5,7,8],3,2)\n-DataArrayInt.New([(1,3),(4,5),(7,8)])\n-DataArrayInt.New(5)\n-DataArrayInt.New(5,2)";
2423 std::string msg(msgBase);
2425 msg+="\n-DataArrayInt.New(numpy array with dtype=int32)";
2428 if(PyList_Check(elt0) || PyTuple_Check(elt0))
2432 if(PyInt_Check(nbOfTuples))
2434 int nbOfTuples1=PyInt_AS_LONG(nbOfTuples);
2436 throw INTERP_KERNEL::Exception("DataArrayInt::New : should be a positive set of allocated memory !");
2439 if(PyInt_Check(nbOfComp))
2440 {//DataArrayInt.New([1,3,4,5],2,2)
2441 int nbOfCompo=PyInt_AS_LONG(nbOfComp);
2443 throw INTERP_KERNEL::Exception("DataArrayInt::New : should be a positive number of components !");
2444 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
2445 std::vector<int> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
2446 ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2450 throw INTERP_KERNEL::Exception(msg.c_str());
2453 {//DataArrayInt.New([1,3,4],3)
2454 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
2456 std::vector<int> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
2457 ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2462 throw INTERP_KERNEL::Exception(msg.c_str());
2465 {// DataArrayInt.New([1,3,4])
2466 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
2467 int tmpp1=-1,tmpp2=-1;
2468 std::vector<int> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
2469 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
2473 else if(PyInt_Check(elt0))
2475 int nbOfTuples1=PyInt_AS_LONG(elt0);
2477 throw INTERP_KERNEL::Exception("DataArrayInt::New : should be a positive set of allocated memory !");
2482 if(PyInt_Check(nbOfTuples))
2483 {//DataArrayInt.New(5,2)
2484 int nbOfCompo=PyInt_AS_LONG(nbOfTuples);
2486 throw INTERP_KERNEL::Exception("DataArrayInt::New : should be a positive number of components !");
2487 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
2488 ret->alloc(nbOfTuples1,nbOfCompo);
2492 throw INTERP_KERNEL::Exception(msg.c_str());
2495 throw INTERP_KERNEL::Exception(msg.c_str());
2498 {//DataArrayInt.New(5)
2499 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=DataArrayInt::New();
2500 ret->alloc(nbOfTuples1,1);
2505 else if(PyArray_Check(elt0) && nbOfTuples==NULL && nbOfComp==NULL)
2506 {//DataArrayInt.New(numpyArray)
2507 return BuildNewInstance<DataArrayInt,int>(elt0,NPY_INT32,&PyCallBackDataArrayInt_RefType,"INT32");
2511 throw INTERP_KERNEL::Exception(msg.c_str());
2514 DataArrayInt(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) throw(INTERP_KERNEL::Exception)
2516 return ParaMEDMEM_DataArrayInt_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
2519 std::string __str__() const throw(INTERP_KERNEL::Exception)
2521 return self->repr();
2524 int __len__() const throw(INTERP_KERNEL::Exception)
2526 if(self->isAllocated())
2528 return self->getNumberOfTuples();
2532 throw INTERP_KERNEL::Exception("DataArrayInt::__len__ : Instance is NOT allocated !");
2536 int __int__() const throw(INTERP_KERNEL::Exception)
2538 return self->intValue();
2541 DataArrayIntIterator *__iter__() throw(INTERP_KERNEL::Exception)
2543 return self->iterator();
2546 PyObject *accumulate() const throw(INTERP_KERNEL::Exception)
2548 int sz=self->getNumberOfComponents();
2549 INTERP_KERNEL::AutoPtr<int> tmp=new int[sz];
2550 self->accumulate(tmp);
2551 return convertIntArrToPyList(tmp,sz);
2554 DataArrayInt *accumulatePerChunck(PyObject *indexArr) const throw(INTERP_KERNEL::Exception)
2557 std::vector<int> val2;
2558 const int *bg=convertObjToPossibleCpp1_Safe(indexArr,sw,sz,val,val2);
2559 return self->accumulatePerChunck(bg,bg+sz);
2562 PyObject *splitInBalancedSlices(int nbOfSlices) const throw(INTERP_KERNEL::Exception)
2564 std::vector< std::pair<int,int> > slcs(self->splitInBalancedSlices(nbOfSlices));
2565 PyObject *ret=PyList_New(slcs.size());
2566 for(std::size_t i=0;i<slcs.size();i++)
2567 PyList_SetItem(ret,i,PySlice_New(PyInt_FromLong(slcs[i].first),PyInt_FromLong(slcs[i].second),PyInt_FromLong(1)));
2571 DataArrayInt *buildExplicitArrOfSliceOnScaledArr(PyObject *slic) const throw(INTERP_KERNEL::Exception)
2573 if(!PySlice_Check(slic))
2574 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr (wrap) : expecting a pyslice as second (first) parameter !");
2575 Py_ssize_t strt=2,stp=2,step=2;
2576 PySliceObject *sly=reinterpret_cast<PySliceObject *>(slic);
2577 if(PySlice_GetIndices(sly,std::numeric_limits<int>::max(),&strt,&stp,&step)!=0)
2578 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr (wrap) : the input slice is invalid !");
2579 if(strt==std::numeric_limits<int>::max() || stp==std::numeric_limits<int>::max())
2580 throw INTERP_KERNEL::Exception("DataArrayInt::buildExplicitArrOfSliceOnScaledArr (wrap) : the input slice contains some unknowns that can't be determined in static method ! Call DataArray::getSlice (non static) instead !");
2581 return self->buildExplicitArrOfSliceOnScaledArr(strt,stp,step);
2584 static PyObject *BuildOld2NewArrayFromSurjectiveFormat2(int nbOfOldTuples, PyObject *arr, PyObject *arrI) throw(INTERP_KERNEL::Exception)
2586 int newNbOfTuples=-1;
2587 int szArr,szArrI,sw,iTypppArr,iTypppArrI;
2588 std::vector<int> stdvecTyyppArr,stdvecTyyppArrI;
2589 const int *arrPtr=convertObjToPossibleCpp1_Safe(arr,sw,szArr,iTypppArr,stdvecTyyppArr);
2590 const int *arrIPtr=convertObjToPossibleCpp1_Safe(arrI,sw,szArrI,iTypppArrI,stdvecTyyppArrI);
2591 DataArrayInt *ret0=ParaMEDMEM::DataArrayInt::BuildOld2NewArrayFromSurjectiveFormat2(nbOfOldTuples,arrPtr,arrIPtr,arrIPtr+szArrI,newNbOfTuples);
2592 PyObject *ret=PyTuple_New(2);
2593 PyTuple_SetItem(ret,0,SWIG_NewPointerObj((void*)ret0,SWIGTYPE_p_ParaMEDMEM__DataArrayInt,SWIG_POINTER_OWN | 0));
2594 PyTuple_SetItem(ret,1,PyInt_FromLong(newNbOfTuples));
2598 void setValues(PyObject *li, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) throw(INTERP_KERNEL::Exception)
2600 const char *msg="ParaMEDMEM::DataArrayInt::setValues : Available API are : \n-DataArrayInt.setValues([1,3,4])\n-DataArrayInt.setValues([1,3,4],3)\n-DataArrayInt.setValues([1,3,4,5],2,2)\n-DataArrayInt.New(5)\n !";
2601 if(PyList_Check(li) || PyTuple_Check(li))
2605 if(PyInt_Check(nbOfTuples))
2607 int nbOfTuples1=PyInt_AS_LONG(nbOfTuples);
2609 throw INTERP_KERNEL::Exception("DataArrayInt::setValue : should be a positive set of allocated memory !");
2612 if(PyInt_Check(nbOfComp))
2613 {//DataArrayInt.setValues([1,3,4,5],2,2)
2614 int nbOfCompo=PyInt_AS_LONG(nbOfComp);
2616 throw INTERP_KERNEL::Exception("DataArrayInt::setValue : should be a positive number of components !");
2617 std::vector<int> tmp=fillArrayWithPyListInt2(li,nbOfTuples1,nbOfCompo);
2618 self->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),self->getPointer());
2621 throw INTERP_KERNEL::Exception(msg);
2624 {//DataArrayInt.setValues([1,3,4],3)
2626 std::vector<int> tmp=fillArrayWithPyListInt2(li,nbOfTuples1,tmpp1);
2627 self->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),self->getPointer());
2631 throw INTERP_KERNEL::Exception(msg);
2634 {// DataArrayInt.setValues([1,3,4])
2635 int tmpp1=-1,tmpp2=-1;
2636 std::vector<int> tmp=fillArrayWithPyListInt2(li,tmpp1,tmpp2);
2637 self->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),self->getPointer());
2641 throw INTERP_KERNEL::Exception(msg);
2644 PyObject *getValues() const throw(INTERP_KERNEL::Exception)
2646 const int *vals=self->getConstPointer();
2647 return convertIntArrToPyList(vals,self->getNbOfElems());
2651 PyObject *toNumPyArray() throw(INTERP_KERNEL::Exception) // not const. It is not a bug !
2653 return ToNumPyArray<DataArrayInt,int>(self,NPY_INT32,"DataArrayInt");
2657 PyObject *isEqualIfNotWhy(const DataArrayInt& other) const throw(INTERP_KERNEL::Exception)
2660 bool ret0=self->isEqualIfNotWhy(other,ret1);
2661 PyObject *ret=PyTuple_New(2);
2662 PyObject *ret0Py=ret0?Py_True:Py_False;
2664 PyTuple_SetItem(ret,0,ret0Py);
2665 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
2669 PyObject *getValuesAsTuple() const throw(INTERP_KERNEL::Exception)
2671 const int *vals=self->getConstPointer();
2672 int nbOfComp=self->getNumberOfComponents();
2673 int nbOfTuples=self->getNumberOfTuples();
2674 return convertIntArrToPyListOfTuple(vals,nbOfComp,nbOfTuples);
2677 static PyObject *MakePartition(PyObject *gps, int newNb) throw(INTERP_KERNEL::Exception)
2679 std::vector<const DataArrayInt *> groups;
2680 std::vector< std::vector<int> > fidsOfGroups;
2681 convertFromPyObjVectorOfObj<const ParaMEDMEM::DataArrayInt *>(gps,SWIGTYPE_p_ParaMEDMEM__DataArrayInt,"DataArrayInt",groups);
2682 ParaMEDMEM::DataArrayInt *ret0=ParaMEDMEM::DataArrayInt::MakePartition(groups,newNb,fidsOfGroups);
2683 PyObject *ret = PyList_New(2);
2684 PyList_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ));
2685 int sz=fidsOfGroups.size();
2686 PyObject *ret1 = PyList_New(sz);
2687 for(int i=0;i<sz;i++)
2688 PyList_SetItem(ret1,i,convertIntArrToPyList2(fidsOfGroups[i]));
2689 PyList_SetItem(ret,1,ret1);
2693 void transformWithIndArr(PyObject *li) throw(INTERP_KERNEL::Exception)
2696 int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 );
2697 if (!SWIG_IsOK(res1))
2700 INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
2701 self->transformWithIndArr(tmp,tmp+size);
2705 DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
2706 self->transformWithIndArr(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
2710 DataArrayInt *getIdsEqualList(PyObject *obj) throw(INTERP_KERNEL::Exception)
2714 std::vector<int> multiVal;
2715 std::pair<int, std::pair<int,int> > slic;
2716 ParaMEDMEM::DataArrayInt *daIntTyypp=0;
2717 convertObjToPossibleCpp2(obj,self->getNumberOfTuples(),sw,singleVal,multiVal,slic,daIntTyypp);
2721 return self->getIdsEqualList(&singleVal,&singleVal+1);
2723 return self->getIdsEqualList(&multiVal[0],&multiVal[0]+multiVal.size());
2725 return self->getIdsEqualList(daIntTyypp->begin(),daIntTyypp->end());
2727 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsEqualList : unrecognized type entered, expected list of int, tuple of int or DataArrayInt !");
2731 DataArrayInt *getIdsNotEqualList(PyObject *obj) throw(INTERP_KERNEL::Exception)
2735 std::vector<int> multiVal;
2736 std::pair<int, std::pair<int,int> > slic;
2737 ParaMEDMEM::DataArrayInt *daIntTyypp=0;
2738 convertObjToPossibleCpp2(obj,self->getNumberOfTuples(),sw,singleVal,multiVal,slic,daIntTyypp);
2742 return self->getIdsNotEqualList(&singleVal,&singleVal+1);
2744 return self->getIdsNotEqualList(&multiVal[0],&multiVal[0]+multiVal.size());
2746 return self->getIdsNotEqualList(daIntTyypp->begin(),daIntTyypp->end());
2748 throw INTERP_KERNEL::Exception("DataArrayInt::getIdsNotEqualList : unrecognized type entered, expected list of int, tuple of int or DataArrayInt !");
2752 PyObject *splitByValueRange(PyObject *li) const throw(INTERP_KERNEL::Exception)
2754 DataArrayInt *ret0=0,*ret1=0,*ret2=0;
2756 int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 );
2757 if (!SWIG_IsOK(res1))
2760 INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
2761 self->splitByValueRange(tmp,(int *)tmp+size,ret0,ret1,ret2);
2765 DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
2767 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
2768 da2->checkAllocated();
2769 int size=self->getNumberOfTuples();
2770 self->splitByValueRange(da2->getConstPointer(),da2->getConstPointer()+size,ret0,ret1,ret2);
2772 PyObject *ret = PyList_New(3);
2773 PyList_SetItem(ret,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ));
2774 PyList_SetItem(ret,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ));
2775 PyList_SetItem(ret,2,SWIG_NewPointerObj(SWIG_as_voidptr(ret2),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ));
2779 DataArrayInt *transformWithIndArrR(PyObject *li) const throw(INTERP_KERNEL::Exception)
2782 int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 );
2783 if (!SWIG_IsOK(res1))
2786 INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
2787 return self->transformWithIndArrR(tmp,tmp+size);
2791 DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
2792 return self->transformWithIndArrR(da2->getConstPointer(),da2->getConstPointer()+da2->getNbOfElems());
2796 DataArrayInt *renumberAndReduce(PyObject *li, int newNbOfTuple) throw(INTERP_KERNEL::Exception)
2799 int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 );
2800 if (!SWIG_IsOK(res1))
2803 INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
2804 if(size!=self->getNumberOfTuples())
2806 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2808 return self->renumberAndReduce(tmp,newNbOfTuple);
2812 DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
2814 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
2815 da2->checkAllocated();
2816 int size=self->getNumberOfTuples();
2817 if(size!=self->getNumberOfTuples())
2819 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2821 return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
2825 DataArrayInt *renumber(PyObject *li) throw(INTERP_KERNEL::Exception)
2828 int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 );
2829 if (!SWIG_IsOK(res1))
2832 INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
2833 if(size!=self->getNumberOfTuples())
2835 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2837 return self->renumber(tmp);
2841 DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
2843 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
2844 da2->checkAllocated();
2845 int size=self->getNumberOfTuples();
2846 if(size!=self->getNumberOfTuples())
2848 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2850 return self->renumber(da2->getConstPointer());
2854 DataArrayInt *renumberR(PyObject *li) throw(INTERP_KERNEL::Exception)
2857 int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 );
2858 if (!SWIG_IsOK(res1))
2861 INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
2862 if(size!=self->getNumberOfTuples())
2864 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2866 return self->renumberR(tmp);
2870 DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
2872 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
2873 da2->checkAllocated();
2874 int size=self->getNumberOfTuples();
2875 if(size!=self->getNumberOfTuples())
2877 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
2879 return self->renumberR(da2->getConstPointer());
2883 void setSelectedComponents(const DataArrayInt *a, PyObject *li) throw(INTERP_KERNEL::Exception)
2885 std::vector<int> tmp;
2886 convertPyToNewIntArr3(li,tmp);
2887 self->setSelectedComponents(a,tmp);
2890 PyObject *getTuple(int tupleId) throw(INTERP_KERNEL::Exception)
2892 int sz=self->getNumberOfComponents();
2893 INTERP_KERNEL::AutoPtr<int> tmp=new int[sz];
2894 self->getTuple(tupleId,tmp);
2895 return convertIntArrToPyList(tmp,sz);
2898 PyObject *changeSurjectiveFormat(int targetNb) const throw(INTERP_KERNEL::Exception)
2900 DataArrayInt *arr=0;
2901 DataArrayInt *arrI=0;
2902 self->changeSurjectiveFormat(targetNb,arr,arrI);
2903 PyObject *res = PyList_New(2);
2904 PyList_SetItem(res,0,SWIG_NewPointerObj((void*)arr,SWIGTYPE_p_ParaMEDMEM__DataArrayInt,SWIG_POINTER_OWN | 0));
2905 PyList_SetItem(res,1,SWIG_NewPointerObj((void*)arrI,SWIGTYPE_p_ParaMEDMEM__DataArrayInt,SWIG_POINTER_OWN | 0));
2909 static DataArrayInt *Meld(PyObject *li) throw(INTERP_KERNEL::Exception)
2911 std::vector<const DataArrayInt *> tmp;
2912 convertFromPyObjVectorOfObj<const ParaMEDMEM::DataArrayInt *>(li,SWIGTYPE_p_ParaMEDMEM__DataArrayInt,"DataArrayInt",tmp);
2913 return DataArrayInt::Meld(tmp);
2916 static DataArrayInt *Aggregate(PyObject *li) throw(INTERP_KERNEL::Exception)
2918 std::vector<const DataArrayInt *> tmp;
2919 convertFromPyObjVectorOfObj<const ParaMEDMEM::DataArrayInt *>(li,SWIGTYPE_p_ParaMEDMEM__DataArrayInt,"DataArrayInt",tmp);
2920 return DataArrayInt::Aggregate(tmp);
2923 static DataArrayInt *AggregateIndexes(PyObject *li) throw(INTERP_KERNEL::Exception)
2925 std::vector<const DataArrayInt *> tmp;
2926 convertFromPyObjVectorOfObj<const ParaMEDMEM::DataArrayInt *>(li,SWIGTYPE_p_ParaMEDMEM__DataArrayInt,"DataArrayInt",tmp);
2927 return DataArrayInt::AggregateIndexes(tmp);
2930 static DataArrayInt *BuildUnion(PyObject *li) throw(INTERP_KERNEL::Exception)
2932 std::vector<const DataArrayInt *> tmp;
2933 convertFromPyObjVectorOfObj<const ParaMEDMEM::DataArrayInt *>(li,SWIGTYPE_p_ParaMEDMEM__DataArrayInt,"DataArrayInt",tmp);
2934 return DataArrayInt::BuildUnion(tmp);
2937 static DataArrayInt *BuildIntersection(PyObject *li) throw(INTERP_KERNEL::Exception)
2939 std::vector<const DataArrayInt *> tmp;
2940 convertFromPyObjVectorOfObj<const ParaMEDMEM::DataArrayInt *>(li,SWIGTYPE_p_ParaMEDMEM__DataArrayInt,"DataArrayInt",tmp);
2941 return DataArrayInt::BuildIntersection(tmp);
2944 PyObject *getMaxValue() const throw(INTERP_KERNEL::Exception)
2947 int r1=self->getMaxValue(tmp);
2948 PyObject *ret=PyTuple_New(2);
2949 PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
2950 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
2954 PyObject *getMinValue() const throw(INTERP_KERNEL::Exception)
2957 int r1=self->getMinValue(tmp);
2958 PyObject *ret=PyTuple_New(2);
2959 PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
2960 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
2964 int index(PyObject *obj) const throw(INTERP_KERNEL::Exception)
2966 int nbOfCompo=self->getNumberOfComponents();
2971 if(PyInt_Check(obj))
2973 int val=(int)PyInt_AS_LONG(obj);
2974 return self->locateValue(val);
2977 throw INTERP_KERNEL::Exception("DataArrayInt::index : 'this' contains one component and trying to find an element which is not an integer !");
2981 std::vector<int> arr;
2982 convertPyToNewIntArr3(obj,arr);
2983 return self->locateTuple(arr);
2988 bool __contains__(PyObject *obj) const throw(INTERP_KERNEL::Exception)
2990 int nbOfCompo=self->getNumberOfComponents();
2997 if(PyInt_Check(obj))
2999 int val=(int)PyInt_AS_LONG(obj);
3000 return self->presenceOfValue(val);
3003 throw INTERP_KERNEL::Exception("DataArrayInt::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
3007 std::vector<int> arr;
3008 convertPyToNewIntArr3(obj,arr);
3009 return self->presenceOfTuple(arr);
3014 PyObject *__getitem__(PyObject *obj) throw(INTERP_KERNEL::Exception)
3016 const char msg[]="Unexpected situation in DataArrayInt::__getitem__ !";
3017 const char msg2[]="DataArrayInt::__getitem__ : Mismatch of slice values in 2nd parameter (components) !";
3018 self->checkAllocated();
3019 int nbOfTuples=self->getNumberOfTuples();
3020 int nbOfComponents=self->getNumberOfComponents();
3022 std::vector<int> vt1,vc1;
3023 std::pair<int, std::pair<int,int> > pt1,pc1;
3024 DataArrayInt *dt1=0,*dc1=0;
3026 convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1);
3027 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret;
3032 if(nbOfComponents==1)
3033 return PyInt_FromLong(self->getIJSafe(it1,0));
3034 return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(&it1,&it1+1)),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 );
3037 return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size())),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 );
3039 return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleId2(pt1.first,pt1.second.first,pt1.second.second)),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 );
3041 return SWIG_NewPointerObj(SWIG_as_voidptr(self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems())),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 );
3043 return PyInt_FromLong(self->getIJSafe(it1,ic1));
3046 ret=self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size());
3047 std::vector<int> v2(1,ic1);
3048 return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 );
3052 ret=self->selectByTupleId2(pt1.first,pt1.second.first,pt1.second.second);
3053 std::vector<int> v2(1,ic1);
3054 return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 );
3058 ret=self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems());
3059 std::vector<int> v2(1,ic1);
3060 return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 );
3064 ret=self->selectByTupleIdSafe(&it1,&it1+1);
3065 return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 );
3069 ret=self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size());
3070 return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 );
3074 ret=self->selectByTupleId2(pt1.first,pt1.second.first,pt1.second.second);
3075 return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 );
3079 ret=self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems());
3080 return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(vc1)),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 );
3084 ret=self->selectByTupleIdSafe(&it1,&it1+1);
3085 int nbOfComp=DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2);
3086 std::vector<int> v2(nbOfComp);
3087 for(int i=0;i<nbOfComp;i++)
3088 v2[i]=pc1.first+i*pc1.second.second;
3089 return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 );
3093 ret=self->selectByTupleIdSafe(&vt1[0],&vt1[0]+vt1.size());
3094 int nbOfComp=DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2);
3095 std::vector<int> v2(nbOfComp);
3096 for(int i=0;i<nbOfComp;i++)
3097 v2[i]=pc1.first+i*pc1.second.second;
3098 return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 );
3102 ret=self->selectByTupleId2(pt1.first,pt1.second.first,pt1.second.second);
3103 int nbOfComp=DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2);
3104 std::vector<int> v2(nbOfComp);
3105 for(int i=0;i<nbOfComp;i++)
3106 v2[i]=pc1.first+i*pc1.second.second;
3107 return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 );
3111 ret=self->selectByTupleIdSafe(dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems());
3112 int nbOfComp=DataArray::GetNumberOfItemGivenBESRelative(pc1.first,pc1.second.first,pc1.second.second,msg2);
3113 std::vector<int> v2(nbOfComp);
3114 for(int i=0;i<nbOfComp;i++)
3115 v2[i]=pc1.first+i*pc1.second.second;
3116 return SWIG_NewPointerObj(SWIG_as_voidptr(ret->keepSelectedComponents(v2)),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 );
3119 throw INTERP_KERNEL::Exception(msg);
3123 DataArrayInt *__setitem__(PyObject *obj, PyObject *value) throw(INTERP_KERNEL::Exception)
3125 self->checkAllocated();
3126 const char msg[]="Unexpected situation in __setitem__ !";
3127 int nbOfTuples=self->getNumberOfTuples();
3128 int nbOfComponents=self->getNumberOfComponents();
3131 std::vector<int> v1;
3133 DataArrayIntTuple *dd1=0;
3134 convertObjToPossibleCpp1(value,sw1,i1,v1,d1,dd1);
3136 std::vector<int> vt1,vc1;
3137 std::pair<int, std::pair<int,int> > pt1,pc1;
3138 DataArrayInt *dt1=0,*dc1=0;
3139 convertObjToPossibleCpp3(obj,nbOfTuples,nbOfComponents,sw2,it1,ic1,vt1,vc1,pt1,pc1,dt1,dc1);
3140 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> tmp;
3148 self->setPartOfValuesSimple1(i1,it1,it1+1,1,0,nbOfComponents,1);
3151 tmp=DataArrayInt::New();
3152 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3153 self->setPartOfValues1(tmp,it1,it1+1,1,0,nbOfComponents,1,false);
3156 self->setPartOfValues1(d1,it1,it1+1,1,0,nbOfComponents,1);
3159 tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3160 self->setPartOfValues1(tmp,it1,it1+1,1,0,nbOfComponents,1);
3163 throw INTERP_KERNEL::Exception(msg);
3172 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1);
3175 tmp=DataArrayInt::New();
3176 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3177 self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1,false);
3180 self->setPartOfValues3(d1,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1);
3183 tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3184 self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),0,nbOfComponents,1);
3187 throw INTERP_KERNEL::Exception(msg);
3196 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1);
3199 tmp=DataArrayInt::New();
3200 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3201 self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1,false);
3204 self->setPartOfValues1(d1,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1);
3207 tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3208 self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,0,nbOfComponents,1);
3211 throw INTERP_KERNEL::Exception(msg);
3220 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1);
3223 tmp=DataArrayInt::New();
3224 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3225 self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1,false);
3228 self->setPartOfValues3(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1);
3231 tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3232 self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),0,nbOfComponents,1);
3235 throw INTERP_KERNEL::Exception(msg);
3244 self->setPartOfValuesSimple1(i1,it1,it1+1,1,ic1,ic1+1,1);
3247 tmp=DataArrayInt::New();
3248 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3249 self->setPartOfValues1(tmp,it1,it1+1,1,ic1,ic1+1,1,false);
3252 self->setPartOfValues1(d1,it1,it1+1,1,ic1,ic1+1,1);
3255 tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3256 self->setPartOfValues1(tmp,it1,it1+1,1,ic1,ic1+1,1);
3259 throw INTERP_KERNEL::Exception(msg);
3268 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1);
3271 tmp=DataArrayInt::New();
3272 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3273 self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1,false);
3276 self->setPartOfValues3(d1,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1);
3279 tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3280 self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),ic1,ic1+1,1);
3283 throw INTERP_KERNEL::Exception(msg);
3292 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1);
3295 tmp=DataArrayInt::New();
3296 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3297 self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1,false);
3300 self->setPartOfValues1(d1,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1);
3303 tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3304 self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,ic1,ic1+1,1);
3307 throw INTERP_KERNEL::Exception(msg);
3316 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1);
3319 tmp=DataArrayInt::New();
3320 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3321 self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1,false);
3324 self->setPartOfValues3(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1);
3327 tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3328 self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),ic1,ic1+1,1);
3331 throw INTERP_KERNEL::Exception(msg);
3340 self->setPartOfValuesSimple2(i1,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size());
3343 tmp=DataArrayInt::New();
3344 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3345 self->setPartOfValues2(tmp,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size(),false);
3348 self->setPartOfValues2(d1,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size());
3351 tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3352 self->setPartOfValues2(tmp,&it1,&it1+1,&vc1[0],&vc1[0]+vc1.size());
3355 throw INTERP_KERNEL::Exception(msg);
3364 self->setPartOfValuesSimple2(i1,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size());
3367 tmp=DataArrayInt::New();
3368 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3369 self->setPartOfValues2(tmp,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size(),false);
3372 self->setPartOfValues2(d1,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size());
3375 tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3376 self->setPartOfValues2(tmp,&vt1[0],&vt1[0]+vt1.size(),&vc1[0],&vc1[0]+vc1.size());
3379 throw INTERP_KERNEL::Exception(msg);
3388 self->setPartOfValuesSimple4(i1,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size());
3391 tmp=DataArrayInt::New();
3392 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3393 self->setPartOfValues4(tmp,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size(),false);
3396 self->setPartOfValues4(d1,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size());
3399 tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3400 self->setPartOfValues4(tmp,pt1.first,pt1.second.first,pt1.second.second,&vc1[0],&vc1[0]+vc1.size());
3403 throw INTERP_KERNEL::Exception(msg);
3412 self->setPartOfValuesSimple2(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size());
3415 tmp=DataArrayInt::New();
3416 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3417 self->setPartOfValues2(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size(),false);
3420 self->setPartOfValues2(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size());
3423 tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3424 self->setPartOfValues2(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),&vc1[0],&vc1[0]+vc1.size());
3427 throw INTERP_KERNEL::Exception(msg);
3436 self->setPartOfValuesSimple1(i1,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second);
3439 tmp=DataArrayInt::New();
3440 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3441 self->setPartOfValues1(tmp,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second,false);
3444 self->setPartOfValues1(d1,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second);
3447 tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3448 self->setPartOfValues1(tmp,it1,it1+1,1,pc1.first,pc1.second.first,pc1.second.second);
3451 throw INTERP_KERNEL::Exception(msg);
3460 self->setPartOfValuesSimple3(i1,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second);
3463 tmp=DataArrayInt::New();
3464 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3465 self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second,false);
3468 self->setPartOfValues3(d1,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second);
3471 tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3472 self->setPartOfValues3(tmp,&vt1[0],&vt1[0]+vt1.size(),pc1.first,pc1.second.first,pc1.second.second);
3475 throw INTERP_KERNEL::Exception(msg);
3484 self->setPartOfValuesSimple1(i1,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second);
3487 tmp=DataArrayInt::New();
3488 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3489 self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second,false);
3492 self->setPartOfValues1(d1,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second);
3495 tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3496 self->setPartOfValues1(tmp,pt1.first,pt1.second.first,pt1.second.second,pc1.first,pc1.second.first,pc1.second.second);
3499 throw INTERP_KERNEL::Exception(msg);
3508 self->setPartOfValuesSimple3(i1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second);
3511 tmp=DataArrayInt::New();
3512 tmp->useArray(&v1[0],false,CPP_DEALLOC,1,v1.size());
3513 self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second,false);
3516 self->setPartOfValues3(d1,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second);
3519 tmp=dd1->buildDAInt(1,self->getNumberOfComponents());
3520 self->setPartOfValues3(tmp,dt1->getConstPointer(),dt1->getConstPointer()+dt1->getNbOfElems(),pc1.first,pc1.second.first,pc1.second.second);
3523 throw INTERP_KERNEL::Exception(msg);
3528 throw INTERP_KERNEL::Exception(msg);
3533 DataArrayInt *__neg__() const throw(INTERP_KERNEL::Exception)
3535 return self->negate();
3538 DataArrayInt *__add__(PyObject *obj) throw(INTERP_KERNEL::Exception)
3540 const char msg[]="Unexpected situation in __add__ !";
3543 std::vector<int> aa;
3544 DataArrayIntTuple *aaa;
3546 convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
3551 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=self->deepCpy();
3552 ret->applyLin(1,val);
3557 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
3558 return DataArrayInt::Add(self,aaaa);
3562 return DataArrayInt::Add(self,a);
3566 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
3567 return DataArrayInt::Add(self,aaaa);
3570 throw INTERP_KERNEL::Exception(msg);
3574 DataArrayInt *__radd__(PyObject *obj) throw(INTERP_KERNEL::Exception)
3576 const char msg[]="Unexpected situation in __radd__ !";
3579 std::vector<int> aa;
3580 DataArrayIntTuple *aaa;
3582 convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
3587 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=self->deepCpy();
3588 ret->applyLin(1,val);
3593 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
3594 return DataArrayInt::Add(self,aaaa);
3598 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
3599 return DataArrayInt::Add(self,aaaa);
3602 throw INTERP_KERNEL::Exception(msg);
3606 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
3608 const char msg[]="Unexpected situation in __iadd__ !";
3611 std::vector<int> aa;
3612 DataArrayIntTuple *aaa;
3614 convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
3619 self->applyLin(1,val);
3620 Py_XINCREF(trueSelf);
3625 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> bb=DataArrayInt::New(); bb->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
3627 Py_XINCREF(trueSelf);
3633 Py_XINCREF(trueSelf);
3638 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
3639 self->addEqual(aaaa);
3640 Py_XINCREF(trueSelf);
3644 throw INTERP_KERNEL::Exception(msg);
3648 DataArrayInt *__sub__(PyObject *obj) throw(INTERP_KERNEL::Exception)
3650 const char msg[]="Unexpected situation in __sub__ !";
3653 std::vector<int> aa;
3654 DataArrayIntTuple *aaa;
3656 convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
3661 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=self->deepCpy();
3662 ret->applyLin(1,-val);
3667 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
3668 return DataArrayInt::Substract(self,aaaa);
3672 return DataArrayInt::Substract(self,a);
3676 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
3677 return DataArrayInt::Substract(self,aaaa);
3680 throw INTERP_KERNEL::Exception(msg);
3684 DataArrayInt *__rsub__(PyObject *obj) throw(INTERP_KERNEL::Exception)
3686 const char msg[]="Unexpected situation in __rsub__ !";
3689 std::vector<int> aa;
3690 DataArrayIntTuple *aaa;
3692 convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
3697 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=self->deepCpy();
3698 ret->applyLin(-1,val);
3703 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
3704 return DataArrayInt::Substract(aaaa,self);
3708 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
3709 return DataArrayInt::Substract(aaaa,self);
3712 throw INTERP_KERNEL::Exception(msg);
3716 PyObject *___isub___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
3718 const char msg[]="Unexpected situation in __isub__ !";
3721 std::vector<int> aa;
3722 DataArrayIntTuple *aaa;
3724 convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
3729 self->applyLin(1,-val);
3730 Py_XINCREF(trueSelf);
3735 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> bb=DataArrayInt::New(); bb->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
3736 self->substractEqual(bb);
3737 Py_XINCREF(trueSelf);
3742 self->substractEqual(a);
3743 Py_XINCREF(trueSelf);
3748 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
3749 self->substractEqual(aaaa);
3750 Py_XINCREF(trueSelf);
3754 throw INTERP_KERNEL::Exception(msg);
3758 DataArrayInt *__mul__(PyObject *obj) throw(INTERP_KERNEL::Exception)
3760 const char msg[]="Unexpected situation in __mul__ !";
3763 std::vector<int> aa;
3764 DataArrayIntTuple *aaa;
3766 convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
3771 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=self->deepCpy();
3772 ret->applyLin(val,0);
3777 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
3778 return DataArrayInt::Multiply(self,aaaa);
3782 return DataArrayInt::Multiply(self,a);
3786 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
3787 return DataArrayInt::Multiply(self,aaaa);
3790 throw INTERP_KERNEL::Exception(msg);
3794 DataArrayInt *__rmul__(PyObject *obj) throw(INTERP_KERNEL::Exception)
3796 const char msg[]="Unexpected situation in __rmul__ !";
3799 std::vector<int> aa;
3800 DataArrayIntTuple *aaa;
3802 convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
3807 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=self->deepCpy();
3808 ret->applyLin(val,0);
3813 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
3814 return DataArrayInt::Multiply(self,aaaa);
3818 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
3819 return DataArrayInt::Multiply(self,aaaa);
3822 throw INTERP_KERNEL::Exception(msg);
3826 PyObject *___imul___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
3828 const char msg[]="Unexpected situation in __imul__ !";
3831 std::vector<int> aa;
3832 DataArrayIntTuple *aaa;
3834 convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
3839 self->applyLin(val,0);
3840 Py_XINCREF(trueSelf);
3845 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> bb=DataArrayInt::New(); bb->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
3846 self->multiplyEqual(bb);
3847 Py_XINCREF(trueSelf);
3852 self->multiplyEqual(a);
3853 Py_XINCREF(trueSelf);
3858 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
3859 self->multiplyEqual(aaaa);
3860 Py_XINCREF(trueSelf);
3864 throw INTERP_KERNEL::Exception(msg);
3868 DataArrayInt *__div__(PyObject *obj) throw(INTERP_KERNEL::Exception)
3870 const char msg[]="Unexpected situation in __div__ !";
3873 std::vector<int> aa;
3874 DataArrayIntTuple *aaa;
3876 convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
3881 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=self->deepCpy();
3882 ret->applyDivideBy(val);
3887 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
3888 return DataArrayInt::Divide(self,aaaa);
3892 return DataArrayInt::Divide(self,a);
3896 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
3897 return DataArrayInt::Divide(self,aaaa);
3900 throw INTERP_KERNEL::Exception(msg);
3904 DataArrayInt *__rdiv__(PyObject *obj) throw(INTERP_KERNEL::Exception)
3906 const char msg[]="Unexpected situation in __rdiv__ !";
3909 std::vector<int> aa;
3910 DataArrayIntTuple *aaa;
3912 convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
3917 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=self->deepCpy();
3923 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
3924 return DataArrayInt::Divide(aaaa,self);
3928 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
3929 return DataArrayInt::Divide(aaaa,self);
3932 throw INTERP_KERNEL::Exception(msg);
3936 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
3938 const char msg[]="Unexpected situation in __idiv__ !";
3941 std::vector<int> aa;
3942 DataArrayIntTuple *aaa;
3944 convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
3949 self->applyDivideBy(val);
3950 Py_XINCREF(trueSelf);
3955 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> bb=DataArrayInt::New(); bb->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
3956 self->divideEqual(bb);
3957 Py_XINCREF(trueSelf);
3962 self->divideEqual(a);
3963 Py_XINCREF(trueSelf);
3968 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
3969 self->divideEqual(aaaa);
3970 Py_XINCREF(trueSelf);
3974 throw INTERP_KERNEL::Exception(msg);
3978 DataArrayInt *__mod__(PyObject *obj) throw(INTERP_KERNEL::Exception)
3980 const char msg[]="Unexpected situation in __mod__ !";
3983 std::vector<int> aa;
3984 DataArrayIntTuple *aaa;
3986 convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
3991 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=self->deepCpy();
3992 ret->applyModulus(val);
3997 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
3998 return DataArrayInt::Modulus(self,aaaa);
4002 return DataArrayInt::Modulus(self,a);
4006 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
4007 return DataArrayInt::Modulus(self,aaaa);
4010 throw INTERP_KERNEL::Exception(msg);
4014 DataArrayInt *__rmod__(PyObject *obj) throw(INTERP_KERNEL::Exception)
4016 const char msg[]="Unexpected situation in __rmod__ !";
4019 std::vector<int> aa;
4020 DataArrayIntTuple *aaa;
4022 convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
4027 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=self->deepCpy();
4028 ret->applyRModulus(val);
4033 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
4034 return DataArrayInt::Modulus(aaaa,self);
4038 return DataArrayInt::Modulus(a,self);
4042 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
4043 return DataArrayInt::Modulus(aaaa,self);
4046 throw INTERP_KERNEL::Exception(msg);
4050 PyObject *___imod___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
4052 const char msg[]="Unexpected situation in __imod__ !";
4055 std::vector<int> aa;
4056 DataArrayIntTuple *aaa;
4058 convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
4063 self->applyModulus(val);
4064 Py_XINCREF(trueSelf);
4069 self->modulusEqual(a);
4070 Py_XINCREF(trueSelf);
4075 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
4076 self->modulusEqual(aaaa);
4077 Py_XINCREF(trueSelf);
4081 throw INTERP_KERNEL::Exception(msg);
4085 DataArrayInt *__pow__(PyObject *obj) throw(INTERP_KERNEL::Exception)
4087 const char msg[]="Unexpected situation in __pow__ !";
4090 std::vector<int> aa;
4091 DataArrayIntTuple *aaa;
4093 convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
4098 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=self->deepCpy();
4104 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
4105 return DataArrayInt::Pow(self,aaaa);
4109 return DataArrayInt::Pow(self,a);
4113 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
4114 return DataArrayInt::Pow(self,aaaa);
4117 throw INTERP_KERNEL::Exception(msg);
4121 DataArrayInt *__rpow__(PyObject *obj) throw(INTERP_KERNEL::Exception)
4123 const char msg[]="Unexpected situation in __rpow__ !";
4126 std::vector<int> aa;
4127 DataArrayIntTuple *aaa;
4129 convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
4134 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=self->deepCpy();
4135 ret->applyRPow(val);
4140 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=DataArrayInt::New(); aaaa->useArray(&aa[0],false,CPP_DEALLOC,1,(int)aa.size());
4141 return DataArrayInt::Pow(aaaa,self);
4145 return DataArrayInt::Pow(a,self);
4149 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
4150 return DataArrayInt::Pow(aaaa,self);
4153 throw INTERP_KERNEL::Exception(msg);
4157 PyObject *___ipow___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
4159 const char msg[]="Unexpected situation in __ipow__ !";
4162 std::vector<int> aa;
4163 DataArrayIntTuple *aaa;
4165 convertObjToPossibleCpp1(obj,sw,val,aa,a,aaa);
4170 self->applyPow(val);
4171 Py_XINCREF(trueSelf);
4177 Py_XINCREF(trueSelf);
4182 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> aaaa=aaa->buildDAInt(1,self->getNumberOfComponents());
4183 self->powEqual(aaaa);
4184 Py_XINCREF(trueSelf);
4188 throw INTERP_KERNEL::Exception(msg);
4192 std::string __repr__() const throw(INTERP_KERNEL::Exception)
4194 std::ostringstream oss;
4195 self->reprQuickOverview(oss);
4199 void pushBackValsSilent(PyObject *li) throw(INTERP_KERNEL::Exception)
4201 int szArr,sw,iTypppArr;
4202 std::vector<int> stdvecTyyppArr;
4203 const int *tmp=convertObjToPossibleCpp1_Safe(li,sw,szArr,iTypppArr,stdvecTyyppArr);
4204 self->pushBackValsSilent(tmp,tmp+szArr);
4207 PyObject *partitionByDifferentValues() const throw(INTERP_KERNEL::Exception)
4209 std::vector<int> ret1;
4210 std::vector<DataArrayInt *> ret0=self->partitionByDifferentValues(ret1);
4211 std::size_t sz=ret0.size();
4212 PyObject *pyRet=PyTuple_New(2);
4213 PyObject *pyRet0=PyList_New((int)sz);
4214 PyObject *pyRet1=PyList_New((int)sz);
4215 for(std::size_t i=0;i<sz;i++)
4217 PyList_SetItem(pyRet0,i,SWIG_NewPointerObj(SWIG_as_voidptr(ret0[i]),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ));
4218 PyList_SetItem(pyRet1,i,PyInt_FromLong(ret1[i]));
4220 PyTuple_SetItem(pyRet,0,pyRet0);
4221 PyTuple_SetItem(pyRet,1,pyRet1);
4225 PyObject *searchRangesInListOfIds(const DataArrayInt *listOfIds) const throw(INTERP_KERNEL::Exception)
4227 DataArrayInt *ret0=0,*ret1=0;
4228 self->searchRangesInListOfIds(listOfIds,ret0,ret1);
4229 PyObject *pyRet=PyTuple_New(2);
4230 PyTuple_SetItem(pyRet,0,SWIG_NewPointerObj(SWIG_as_voidptr(ret0),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ));
4231 PyTuple_SetItem(pyRet,1,SWIG_NewPointerObj(SWIG_as_voidptr(ret1),SWIGTYPE_p_ParaMEDMEM__DataArrayInt, SWIG_POINTER_OWN | 0 ));
4237 class DataArrayIntTuple;
4239 class DataArrayIntIterator
4242 DataArrayIntIterator(DataArrayInt *da);
4243 ~DataArrayIntIterator();
4248 DataArrayIntTuple *ret=self->nextt();
4250 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_ParaMEDMEM__DataArrayIntTuple,SWIG_POINTER_OWN | 0);
4253 PyErr_SetString(PyExc_StopIteration,"No more data.");
4260 class DataArrayIntTuple
4263 int getNumberOfCompo() const throw(INTERP_KERNEL::Exception);
4264 DataArrayInt *buildDAInt(int nbOfTuples, int nbOfCompo) const throw(INTERP_KERNEL::Exception);
4267 std::string __str__() const throw(INTERP_KERNEL::Exception)
4269 return self->repr();
4272 int __int__() const throw(INTERP_KERNEL::Exception)
4274 return self->intValue();
4277 DataArrayInt *buildDAInt() throw(INTERP_KERNEL::Exception)
4279 return self->buildDAInt(1,self->getNumberOfCompo());
4282 PyObject *___iadd___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
4284 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=self->buildDAInt(1,self->getNumberOfCompo());
4285 ParaMEDMEM_DataArrayInt____iadd___(ret,0,obj);
4286 Py_XINCREF(trueSelf);
4290 PyObject *___isub___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
4292 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=self->buildDAInt(1,self->getNumberOfCompo());
4293 ParaMEDMEM_DataArrayInt____isub___(ret,0,obj);
4294 Py_XINCREF(trueSelf);
4298 PyObject *___imul___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
4300 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=self->buildDAInt(1,self->getNumberOfCompo());
4301 ParaMEDMEM_DataArrayInt____imul___(ret,0,obj);
4302 Py_XINCREF(trueSelf);
4306 PyObject *___idiv___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
4308 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=self->buildDAInt(1,self->getNumberOfCompo());
4309 ParaMEDMEM_DataArrayInt____idiv___(ret,0,obj);
4310 Py_XINCREF(trueSelf);
4314 PyObject *___imod___(PyObject *trueSelf, PyObject *obj) throw(INTERP_KERNEL::Exception)
4316 MEDCouplingAutoRefCountObjectPtr<DataArrayInt> ret=self->buildDAInt(1,self->getNumberOfCompo());
4317 ParaMEDMEM_DataArrayInt____imod___(ret,0,obj);
4318 Py_XINCREF(trueSelf);
4322 PyObject *__getitem__(PyObject *obj) throw(INTERP_KERNEL::Exception)
4324 const char msg2[]="DataArrayIntTuple::__getitem__ : Mismatch of slice values in 2nd parameter (components) !";
4327 std::vector<int> multiVal;
4328 std::pair<int, std::pair<int,int> > slic;
4329 ParaMEDMEM::DataArrayInt *daIntTyypp=0;
4330 const int *pt=self->getConstPointer();
4331 int nbc=self->getNumberOfCompo();
4332 convertObjToPossibleCpp2(obj,nbc,sw,singleVal,multiVal,slic,daIntTyypp);
4339 std::ostringstream oss;
4340 oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
4341 throw INTERP_KERNEL::Exception(oss.str().c_str());
4344 return PyInt_FromLong(pt[singleVal]);
4348 return PyInt_FromLong(pt[nbc+singleVal]);
4351 std::ostringstream oss;
4352 oss << "Requesting for id " << singleVal << " having only " << nbc << " components !";
4353 throw INTERP_KERNEL::Exception(oss.str().c_str());
4359 PyObject *t=PyTuple_New(multiVal.size());
4360 for(int j=0;j<(int)multiVal.size();j++)
4362 int cid=multiVal[j];
4365 std::ostringstream oss;
4366 oss << "Requesting for id #" << cid << " having only " << nbc << " components !";
4367 throw INTERP_KERNEL::Exception(oss.str().c_str());
4369 PyTuple_SetItem(t,j,PyInt_FromLong(pt[cid]));
4375 int sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
4376 PyObject *t=PyTuple_New(sz);
4377 for(int j=0;j<sz;j++)
4378 PyTuple_SetItem(t,j,PyInt_FromLong(pt[slic.first+j*slic.second.second]));
4382 throw INTERP_KERNEL::Exception("DataArrayIntTuple::__getitem__ : unrecognized type entered !");
4386 DataArrayIntTuple *__setitem__(PyObject *obj, PyObject *value) throw(INTERP_KERNEL::Exception)
4388 const char msg[]="DataArrayIntTuple::__setitem__ : unrecognized type entered, int, slice, list<int>, tuple<int> !";
4389 const char msg2[]="DataArrayIntTuple::__setitem__ : Mismatch of slice values in 2nd parameter (components) !";
4392 std::vector<int> multiValV;
4393 std::pair<int, std::pair<int,int> > slicV;
4394 ParaMEDMEM::DataArrayIntTuple *daIntTyyppV=0;
4395 int nbc=self->getNumberOfCompo();
4396 convertObjToPossibleCpp22(value,nbc,sw1,singleValV,multiValV,slicV,daIntTyyppV);
4398 std::vector<int> multiVal;
4399 std::pair<int, std::pair<int,int> > slic;
4400 ParaMEDMEM::DataArrayInt *daIntTyypp=0;
4401 int *pt=self->getPointer();
4402 convertObjToPossibleCpp2(obj,nbc,sw2,singleVal,multiVal,slic,daIntTyypp);
4409 std::ostringstream oss;
4410 oss << "Requesting for setting id # " << singleVal << " having only " << nbc << " components !";
4411 throw INTERP_KERNEL::Exception(oss.str().c_str());
4417 pt[singleVal]=singleValV;
4422 if(multiValV.size()!=1)
4424 std::ostringstream oss;
4425 oss << "Requesting for setting id # " << singleVal << " with a list or tuple with size != 1 ! ";
4426 throw INTERP_KERNEL::Exception(oss.str().c_str());
4428 pt[singleVal]=multiValV[0];
4433 pt[singleVal]=daIntTyyppV->getConstPointer()[0];
4437 throw INTERP_KERNEL::Exception(msg);
4446 for(std::vector<int>::const_iterator it=multiVal.begin();it!=multiVal.end();it++)
4450 std::ostringstream oss;
4451 oss << "Requesting for setting id # " << *it << " having only " << nbc << " components !";
4452 throw INTERP_KERNEL::Exception(oss.str().c_str());
4460 if(multiVal.size()!=multiValV.size())
4462 std::ostringstream oss;
4463 oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << multiVal.size() << " !";
4464 throw INTERP_KERNEL::Exception(oss.str().c_str());
4466 for(int i=0;i<(int)multiVal.size();i++)
4468 int pos=multiVal[i];
4471 std::ostringstream oss;
4472 oss << "Requesting for setting id # " << pos << " having only " << nbc << " components !";
4473 throw INTERP_KERNEL::Exception(oss.str().c_str());
4475 pt[multiVal[i]]=multiValV[i];
4481 const int *ptV=daIntTyyppV->getConstPointer();
4482 if(nbc>daIntTyyppV->getNumberOfCompo())
4484 std::ostringstream oss;
4485 oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
4486 throw INTERP_KERNEL::Exception(oss.str().c_str());
4488 std::copy(ptV,ptV+nbc,pt);
4492 throw INTERP_KERNEL::Exception(msg);
4497 int sz=DataArray::GetNumberOfItemGivenBES(slic.first,slic.second.first,slic.second.second,msg2);
4502 for(int j=0;j<sz;j++)
4503 pt[slic.first+j*slic.second.second]=singleValV;
4508 if(sz!=(int)multiValV.size())
4510 std::ostringstream oss;
4511 oss << "Mismatch length of during assignment : " << multiValV.size() << " != " << sz << " !";
4512 throw INTERP_KERNEL::Exception(oss.str().c_str());
4514 for(int j=0;j<sz;j++)
4515 pt[slic.first+j*slic.second.second]=multiValV[j];
4520 const int *ptV=daIntTyyppV->getConstPointer();
4521 if(sz>daIntTyyppV->getNumberOfCompo())
4523 std::ostringstream oss;
4524 oss << "Mismatch length of during assignment : " << nbc << " != " << daIntTyyppV->getNumberOfCompo() << " !";
4525 throw INTERP_KERNEL::Exception(oss.str().c_str());
4527 for(int j=0;j<sz;j++)
4528 pt[slic.first+j*slic.second.second]=ptV[j];
4532 throw INTERP_KERNEL::Exception(msg);
4536 throw INTERP_KERNEL::Exception(msg);
4542 class DataArrayChar : public DataArray
4545 virtual DataArrayChar *buildEmptySpecializedDAChar() const throw(INTERP_KERNEL::Exception);
4546 int getHashCode() const throw(INTERP_KERNEL::Exception);
4547 bool empty() const throw(INTERP_KERNEL::Exception);
4548 void cpyFrom(const DataArrayChar& other) throw(INTERP_KERNEL::Exception);
4549 void reserve(std::size_t nbOfElems) throw(INTERP_KERNEL::Exception);
4550 void pushBackSilent(char val) throw(INTERP_KERNEL::Exception);
4551 char popBackSilent() throw(INTERP_KERNEL::Exception);
4552 void pack() const throw(INTERP_KERNEL::Exception);
4553 void allocIfNecessary(int nbOfTuple, int nbOfCompo) throw(INTERP_KERNEL::Exception);
4554 bool isEqual(const DataArrayChar& other) const throw(INTERP_KERNEL::Exception);
4555 bool isEqualWithoutConsideringStr(const DataArrayChar& other) const throw(INTERP_KERNEL::Exception);
4556 void reverse() throw(INTERP_KERNEL::Exception);
4557 void fillWithZero() throw(INTERP_KERNEL::Exception);
4558 void fillWithValue(char val) throw(INTERP_KERNEL::Exception);
4559 std::string repr() const throw(INTERP_KERNEL::Exception);
4560 std::string reprZip() const throw(INTERP_KERNEL::Exception);
4561 DataArrayInt *convertToIntArr() const throw(INTERP_KERNEL::Exception);
4562 DataArrayChar *renumber(const int *old2New) const throw(INTERP_KERNEL::Exception);
4563 DataArrayChar *renumberR(const int *new2Old) const throw(INTERP_KERNEL::Exception);
4564 DataArrayChar *renumberAndReduce(const int *old2NewBg, int newNbOfTuple) const throw(INTERP_KERNEL::Exception);
4565 bool isUniform(char val) const throw(INTERP_KERNEL::Exception);
4566 DataArrayChar *substr(int tupleIdBg, int tupleIdEnd=-1) const throw(INTERP_KERNEL::Exception);
4567 DataArrayChar *changeNbOfComponents(int newNbOfComp, char dftValue) const throw(INTERP_KERNEL::Exception);
4568 void meldWith(const DataArrayChar *other) throw(INTERP_KERNEL::Exception);
4569 void setPartOfValuesAdv(const DataArrayChar *a, const DataArrayChar *tuplesSelec) throw(INTERP_KERNEL::Exception);
4570 char front() const throw(INTERP_KERNEL::Exception);
4571 char back() const throw(INTERP_KERNEL::Exception);
4572 void setIJ(int tupleId, int compoId, char newVal) throw(INTERP_KERNEL::Exception);
4573 void setIJSilent(int tupleId, int compoId, char newVal) throw(INTERP_KERNEL::Exception);
4574 char *getPointer() throw(INTERP_KERNEL::Exception);
4575 DataArrayInt *getIdsEqual(char val) const throw(INTERP_KERNEL::Exception);
4576 DataArrayInt *getIdsNotEqual(char val) const throw(INTERP_KERNEL::Exception);
4577 int locateTuple(const std::vector<char>& tupl) const throw(INTERP_KERNEL::Exception);
4578 bool presenceOfTuple(const std::vector<char>& tupl) const throw(INTERP_KERNEL::Exception);
4579 char getMaxValue(int& tupleId) const throw(INTERP_KERNEL::Exception);
4580 char getMaxValueInArray() const throw(INTERP_KERNEL::Exception);
4581 char getMinValue(int& tupleId) const throw(INTERP_KERNEL::Exception);
4582 char getMinValueInArray() const throw(INTERP_KERNEL::Exception);
4583 DataArrayInt *getIdsInRange(char vmin, char vmax) const throw(INTERP_KERNEL::Exception);
4584 static DataArrayChar *Aggregate(const DataArrayChar *a1, const DataArrayChar *a2) throw(INTERP_KERNEL::Exception);
4585 static DataArrayChar *Meld(const DataArrayChar *a1, const DataArrayChar *a2) throw(INTERP_KERNEL::Exception);
4588 int __len__() const throw(INTERP_KERNEL::Exception)
4590 if(self->isAllocated())
4592 return self->getNumberOfTuples();
4596 throw INTERP_KERNEL::Exception("DataArrayChar::__len__ : Instance is NOT allocated !");
4600 PyObject *isEqualIfNotWhy(const DataArrayChar& other) const throw(INTERP_KERNEL::Exception)
4603 bool ret0=self->isEqualIfNotWhy(other,ret1);
4604 PyObject *ret=PyTuple_New(2);
4605 PyObject *ret0Py=ret0?Py_True:Py_False;
4607 PyTuple_SetItem(ret,0,ret0Py);
4608 PyTuple_SetItem(ret,1,PyString_FromString(ret1.c_str()));
4612 DataArrayChar *renumber(PyObject *li) throw(INTERP_KERNEL::Exception)
4615 int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 );
4616 if (!SWIG_IsOK(res1))
4619 INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
4620 if(size!=self->getNumberOfTuples())
4622 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
4624 return self->renumber(tmp);
4628 DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
4630 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
4631 da2->checkAllocated();
4632 int size=self->getNumberOfTuples();
4633 if(size!=self->getNumberOfTuples())
4635 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
4637 return self->renumber(da2->getConstPointer());
4641 DataArrayChar *renumberR(PyObject *li) throw(INTERP_KERNEL::Exception)
4644 int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 );
4645 if (!SWIG_IsOK(res1))
4648 INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
4649 if(size!=self->getNumberOfTuples())
4651 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
4653 return self->renumberR(tmp);
4657 DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
4659 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
4660 da2->checkAllocated();
4661 int size=self->getNumberOfTuples();
4662 if(size!=self->getNumberOfTuples())
4664 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
4666 return self->renumberR(da2->getConstPointer());
4670 DataArrayChar *renumberAndReduce(PyObject *li, int newNbOfTuple) throw(INTERP_KERNEL::Exception)
4673 int res1=SWIG_ConvertPtr(li,&da,SWIGTYPE_p_ParaMEDMEM__DataArrayInt, 0 | 0 );
4674 if (!SWIG_IsOK(res1))
4677 INTERP_KERNEL::AutoPtr<int> tmp=convertPyToNewIntArr2(li,&size);
4678 if(size!=self->getNumberOfTuples())
4680 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
4682 return self->renumberAndReduce(tmp,newNbOfTuple);
4686 DataArrayInt *da2=reinterpret_cast< DataArrayInt * >(da);
4688 throw INTERP_KERNEL::Exception("Not null DataArrayInt instance expected !");
4689 da2->checkAllocated();
4690 int size=self->getNumberOfTuples();
4691 if(size!=self->getNumberOfTuples())
4693 throw INTERP_KERNEL::Exception("Invalid list length ! Must be equal to number of tuples !");
4695 return self->renumberAndReduce(da2->getConstPointer(),newNbOfTuple);
4699 static DataArrayChar *Aggregate(PyObject *dachs) throw(INTERP_KERNEL::Exception)
4701 std::vector<const ParaMEDMEM::DataArrayChar *> tmp;
4702 convertFromPyObjVectorOfObj<const ParaMEDMEM::DataArrayChar *>(dachs,SWIGTYPE_p_ParaMEDMEM__DataArrayChar,"DataArrayChar",tmp);
4703 return DataArrayChar::Aggregate(tmp);
4706 static DataArrayChar *Meld(PyObject *dachs) throw(INTERP_KERNEL::Exception)
4708 std::vector<const ParaMEDMEM::DataArrayChar *> tmp;
4709 convertFromPyObjVectorOfObj<const ParaMEDMEM::DataArrayChar *>(dachs,SWIGTYPE_p_ParaMEDMEM__DataArrayChar,"DataArrayChar",tmp);
4710 return DataArrayChar::Meld(tmp);
4715 class DataArrayByteIterator;
4717 class DataArrayByte : public DataArrayChar
4720 static DataArrayByte *New();
4721 DataArrayByteIterator *iterator() throw(INTERP_KERNEL::Exception);
4722 DataArrayByte *performCpy(bool deepCpy) const throw(INTERP_KERNEL::Exception);
4723 char byteValue() const throw(INTERP_KERNEL::Exception);
4726 DataArrayByte() throw(INTERP_KERNEL::Exception)
4728 return DataArrayByte::New();
4731 static DataArrayByte *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) throw(INTERP_KERNEL::Exception)
4733 const char *msg="ParaMEDMEM::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) !";
4734 if(PyList_Check(elt0) || PyTuple_Check(elt0))
4738 if(PyInt_Check(nbOfTuples))
4740 int nbOfTuples1=PyInt_AS_LONG(nbOfTuples);
4742 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive set of allocated memory !");
4745 if(PyInt_Check(nbOfComp))
4746 {//DataArrayByte.New([1,3,4,5],2,2)
4747 int nbOfCompo=PyInt_AS_LONG(nbOfComp);
4749 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !");
4750 MEDCouplingAutoRefCountObjectPtr<DataArrayByte> ret=DataArrayByte::New();
4751 std::vector<int> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
4752 ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
4756 throw INTERP_KERNEL::Exception(msg);
4759 {//DataArrayByte.New([1,3,4],3)
4760 MEDCouplingAutoRefCountObjectPtr<DataArrayByte> ret=DataArrayByte::New();
4762 std::vector<int> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
4763 ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
4768 throw INTERP_KERNEL::Exception(msg);
4771 {// DataArrayByte.New([1,3,4])
4772 MEDCouplingAutoRefCountObjectPtr<DataArrayByte> ret=DataArrayByte::New();
4773 int tmpp1=-1,tmpp2=-1;
4774 std::vector<int> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
4775 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
4779 else if(PyInt_Check(elt0))
4781 int nbOfTuples1=PyInt_AS_LONG(elt0);
4783 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive set of allocated memory !");
4788 if(PyInt_Check(nbOfTuples))
4789 {//DataArrayByte.New(5,2)
4790 int nbOfCompo=PyInt_AS_LONG(nbOfTuples);
4792 throw INTERP_KERNEL::Exception("DataArrayByte::New : should be a positive number of components !");
4793 MEDCouplingAutoRefCountObjectPtr<DataArrayByte> ret=DataArrayByte::New();
4794 ret->alloc(nbOfTuples1,nbOfCompo);
4798 throw INTERP_KERNEL::Exception(msg);
4801 throw INTERP_KERNEL::Exception(msg);
4804 {//DataArrayByte.New(5)
4805 MEDCouplingAutoRefCountObjectPtr<DataArrayByte> ret=DataArrayByte::New();
4806 ret->alloc(nbOfTuples1,1);
4811 throw INTERP_KERNEL::Exception(msg);
4814 DataArrayByte(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) throw(INTERP_KERNEL::Exception)
4816 return ParaMEDMEM_DataArrayByte_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
4819 std::string __repr__() const throw(INTERP_KERNEL::Exception)
4821 std::ostringstream oss;
4822 self->reprQuickOverview(oss);
4826 int __int__() const throw(INTERP_KERNEL::Exception)
4828 return (int) self->byteValue();
4831 DataArrayByteIterator *__iter__() throw(INTERP_KERNEL::Exception)
4833 return self->iterator();
4836 int getIJ(int tupleId, int compoId) const throw(INTERP_KERNEL::Exception)
4838 return (int)self->getIJ(tupleId,compoId);
4841 int getIJSafe(int tupleId, int compoId) const throw(INTERP_KERNEL::Exception)
4843 return (int)self->getIJSafe(tupleId,compoId);
4846 std::string __str__() const throw(INTERP_KERNEL::Exception)
4848 return self->repr();
4851 PyObject *toStrList() const throw(INTERP_KERNEL::Exception)
4853 const char *vals=self->getConstPointer();
4854 int nbOfComp=self->getNumberOfComponents();
4855 int nbOfTuples=self->getNumberOfTuples();
4856 return convertCharArrToPyListOfTuple(vals,nbOfComp,nbOfTuples);
4859 bool presenceOfTuple(PyObject *tupl) const throw(INTERP_KERNEL::Exception)
4862 int ival=-1; std::vector<int> ivval;
4863 const int *pt=convertObjToPossibleCpp1_Safe(tupl,sw,sz,ival,ivval);
4864 std::vector<char> vals(sz);
4865 std::copy(pt,pt+sz,vals.begin());
4866 return self->presenceOfTuple(vals);
4869 bool presenceOfValue(PyObject *vals) const throw(INTERP_KERNEL::Exception)
4872 int ival=-1; std::vector<int> ivval;
4873 const int *pt=convertObjToPossibleCpp1_Safe(vals,sw,sz,ival,ivval);
4874 std::vector<char> vals2(sz);
4875 std::copy(pt,pt+sz,vals2.begin());
4876 return self->presenceOfValue(vals2);
4879 int locateValue(PyObject *vals) const throw(INTERP_KERNEL::Exception)
4882 int ival=-1; std::vector<int> ivval;
4883 const int *pt=convertObjToPossibleCpp1_Safe(vals,sw,sz,ival,ivval);
4884 std::vector<char> vals2(sz);
4885 std::copy(pt,pt+sz,vals2.begin());
4886 return self->locateValue(vals2);
4889 int locateTuple(PyObject *tupl) const throw(INTERP_KERNEL::Exception)
4892 int ival=-1; std::vector<int> ivval;
4893 const int *pt=convertObjToPossibleCpp1_Safe(tupl,sw,sz,ival,ivval);
4894 std::vector<char> vals(sz);
4895 std::copy(pt,pt+sz,vals.begin());
4896 return self->locateTuple(vals);
4899 int search(PyObject *strOrListOfInt) const throw(INTERP_KERNEL::Exception)
4902 int ival=-1; std::vector<int> ivval;
4903 const int *pt=convertObjToPossibleCpp1_Safe(strOrListOfInt,sw,sz,ival,ivval);
4904 std::vector<char> vals(sz);
4905 std::copy(pt,pt+sz,vals.begin());
4906 return self->search(vals);
4909 PyObject *getTuple(int tupleId) throw(INTERP_KERNEL::Exception)
4911 int sz=self->getNumberOfComponents();
4912 INTERP_KERNEL::AutoPtr<char> tmp=new char[sz];
4913 self->getTuple(tupleId,tmp);
4914 PyObject *ret=PyTuple_New(sz);
4915 for(int i=0;i<sz;i++) PyTuple_SetItem(ret,i,PyInt_FromLong((int)tmp[i]));
4919 PyObject *getMaxValue() const throw(INTERP_KERNEL::Exception)
4922 int r1=(int)self->getMaxValue(tmp);
4923 PyObject *ret=PyTuple_New(2);
4924 PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
4925 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
4929 PyObject *getMinValue() const throw(INTERP_KERNEL::Exception)
4932 int r1=(int)self->getMinValue(tmp);
4933 PyObject *ret=PyTuple_New(2);
4934 PyTuple_SetItem(ret,0,PyInt_FromLong(r1));
4935 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
4939 int index(PyObject *obj) const throw(INTERP_KERNEL::Exception)
4941 int nbOfCompo=self->getNumberOfComponents();
4946 if(PyInt_Check(obj))
4948 int val=(int)PyInt_AS_LONG(obj);
4949 return self->locateValue(val);
4952 throw INTERP_KERNEL::Exception("DataArrayByte::index : 'this' contains one component and trying to find an element which is not an integer !");
4955 return ParaMEDMEM_DataArrayByte_locateTuple(self,obj);
4959 bool __contains__(PyObject *obj) const throw(INTERP_KERNEL::Exception)
4961 int nbOfCompo=self->getNumberOfComponents();
4968 if(PyInt_Check(obj))
4970 int val=(int)PyInt_AS_LONG(obj);
4971 return self->presenceOfValue(val);
4974 throw INTERP_KERNEL::Exception("DataArrayByte::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
4977 return ParaMEDMEM_DataArrayByte_presenceOfTuple(self,obj);
4983 class DataArrayByteTuple;
4985 class DataArrayByteIterator
4988 DataArrayByteIterator(DataArrayByte *da);
4989 ~DataArrayByteIterator();
4992 class DataArrayByteTuple
4995 std::string repr() const throw(INTERP_KERNEL::Exception);
4996 DataArrayByte *buildDAByte(int nbOfTuples, int nbOfCompo) const throw(INTERP_KERNEL::Exception);
4999 std::string __str__() const throw(INTERP_KERNEL::Exception)
5001 return self->repr();
5004 char __int__() const throw(INTERP_KERNEL::Exception)
5006 return self->byteValue();
5009 DataArrayByte *buildDAByte() throw(INTERP_KERNEL::Exception)
5011 return self->buildDAByte(1,self->getNumberOfCompo());
5016 class DataArrayAsciiCharIterator;
5018 class DataArrayAsciiChar : public DataArrayChar
5021 static DataArrayAsciiChar *New();
5022 DataArrayAsciiCharIterator *iterator() throw(INTERP_KERNEL::Exception);
5023 DataArrayAsciiChar *performCpy(bool deepCpy) const throw(INTERP_KERNEL::Exception);
5024 char asciiCharValue() const throw(INTERP_KERNEL::Exception);
5027 DataArrayAsciiChar() throw(INTERP_KERNEL::Exception)
5029 return DataArrayAsciiChar::New();
5032 static DataArrayAsciiChar *New(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) throw(INTERP_KERNEL::Exception)
5034 const char *msg="ParaMEDMEM::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) !";
5035 if(PyList_Check(elt0) || PyTuple_Check(elt0))
5039 if(PyInt_Check(nbOfTuples))
5041 int nbOfTuples1=PyInt_AS_LONG(nbOfTuples);
5043 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive set of allocated memory !");
5046 if(PyInt_Check(nbOfComp))
5047 {//DataArrayAsciiChar.New([1,3,4,5],2,2)
5048 int nbOfCompo=PyInt_AS_LONG(nbOfComp);
5050 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !");
5051 MEDCouplingAutoRefCountObjectPtr<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
5052 std::vector<int> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,nbOfCompo);
5053 ret->alloc(nbOfTuples1,nbOfCompo); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
5057 throw INTERP_KERNEL::Exception(msg);
5060 {//DataArrayAsciiChar.New([1,3,4],3)
5061 MEDCouplingAutoRefCountObjectPtr<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
5063 std::vector<int> tmp=fillArrayWithPyListInt2(elt0,nbOfTuples1,tmpp1);
5064 ret->alloc(nbOfTuples1,tmpp1); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
5068 else if(PyString_Check(nbOfTuples))
5070 if(PyString_Size(nbOfTuples)!=1)
5071 throw INTERP_KERNEL::Exception(msg);
5072 //DataArrayAsciiChar.New(["abc","de","fghi"],"t")
5073 std::vector<std::string> tmp;
5074 if(fillStringVector(elt0,tmp))
5075 return DataArrayAsciiChar::New(tmp,PyString_AsString(nbOfTuples)[0]);
5077 throw INTERP_KERNEL::Exception(msg);
5080 throw INTERP_KERNEL::Exception(msg);
5084 std::vector<std::string> tmmp;
5085 if(fillStringVector(elt0,tmmp))
5086 //DataArrayAsciiChar.New(["abc","de","fghi"])
5087 return DataArrayAsciiChar::New(tmmp,' ');
5090 // DataArrayAsciiChar.New([1,3,4])
5091 MEDCouplingAutoRefCountObjectPtr<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
5092 int tmpp1=-1,tmpp2=-1;
5093 std::vector<int> tmp=fillArrayWithPyListInt2(elt0,tmpp1,tmpp2);
5094 ret->alloc(tmpp1,tmpp2); std::copy(tmp.begin(),tmp.end(),ret->getPointer());
5099 else if(PyInt_Check(elt0))
5101 int nbOfTuples1=PyInt_AS_LONG(elt0);
5103 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive set of allocated memory !");
5108 if(PyInt_Check(nbOfTuples))
5109 {//DataArrayAsciiChar.New(5,2)
5110 int nbOfCompo=PyInt_AS_LONG(nbOfTuples);
5112 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::New : should be a positive number of components !");
5113 MEDCouplingAutoRefCountObjectPtr<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
5114 ret->alloc(nbOfTuples1,nbOfCompo);
5118 throw INTERP_KERNEL::Exception(msg);
5121 throw INTERP_KERNEL::Exception(msg);
5124 {//DataArrayAsciiChar.New(5)
5125 MEDCouplingAutoRefCountObjectPtr<DataArrayAsciiChar> ret=DataArrayAsciiChar::New();
5126 ret->alloc(nbOfTuples1,1);
5131 throw INTERP_KERNEL::Exception(msg);
5134 DataArrayAsciiChar(PyObject *elt0, PyObject *nbOfTuples=0, PyObject *nbOfComp=0) throw(INTERP_KERNEL::Exception)
5136 return ParaMEDMEM_DataArrayAsciiChar_New__SWIG_1(elt0,nbOfTuples,nbOfComp);
5139 std::string __repr__() const throw(INTERP_KERNEL::Exception)
5141 std::ostringstream oss;
5142 self->reprQuickOverview(oss);
5146 DataArrayAsciiCharIterator *__iter__() throw(INTERP_KERNEL::Exception)
5148 return self->iterator();
5151 std::string getIJ(int tupleId, int compoId) const throw(INTERP_KERNEL::Exception)
5153 char tmp[2]; tmp[1]='\0';
5154 tmp[0]=self->getIJ(tupleId,compoId);
5155 return std::string(tmp);
5158 std::string getIJSafe(int tupleId, int compoId) const throw(INTERP_KERNEL::Exception)
5160 char tmp[2]; tmp[1]='\0';
5161 tmp[0]=self->getIJSafe(tupleId,compoId);
5162 return std::string(tmp);
5165 std::string __str__() const throw(INTERP_KERNEL::Exception)
5167 return self->repr();
5170 PyObject *toStrList() const throw(INTERP_KERNEL::Exception)
5172 const char *vals=self->getConstPointer();
5173 int nbOfComp=self->getNumberOfComponents();
5174 int nbOfTuples=self->getNumberOfTuples();
5175 return convertCharArrToPyListOfTuple(vals,nbOfComp,nbOfTuples);
5178 bool presenceOfTuple(PyObject *tupl) const throw(INTERP_KERNEL::Exception)
5180 if(PyString_Check(tupl))
5182 Py_ssize_t sz=PyString_Size(tupl);
5183 std::vector<char> vals(sz);
5184 std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin());
5185 return self->presenceOfTuple(vals);
5188 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfTuple : only strings in input supported !");
5191 bool presenceOfValue(PyObject *vals) const throw(INTERP_KERNEL::Exception)
5193 if(PyString_Check(vals))
5195 Py_ssize_t sz=PyString_Size(vals);
5196 std::vector<char> vals2(sz);
5197 std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin());
5198 return self->presenceOfValue(vals2);
5201 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::presenceOfValue : only strings in input supported !");
5204 int locateValue(PyObject *vals) const throw(INTERP_KERNEL::Exception)
5206 if(PyString_Check(vals))
5208 Py_ssize_t sz=PyString_Size(vals);
5209 std::vector<char> vals2(sz);
5210 std::copy(PyString_AsString(vals),PyString_AsString(vals)+sz,vals2.begin());
5211 return self->locateValue(vals2);
5214 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::locateValue : only strings in input supported !");
5217 int locateTuple(PyObject *tupl) const throw(INTERP_KERNEL::Exception)
5219 if(PyString_Check(tupl))
5221 Py_ssize_t sz=PyString_Size(tupl);
5222 std::vector<char> vals(sz);
5223 std::copy(PyString_AsString(tupl),PyString_AsString(tupl)+sz,vals.begin());
5224 return self->locateTuple(vals);
5227 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::locateTuple : only strings in input supported !");
5230 int search(PyObject *strOrListOfInt) const throw(INTERP_KERNEL::Exception)
5232 if(PyString_Check(strOrListOfInt))
5234 Py_ssize_t sz=PyString_Size(strOrListOfInt);
5235 std::vector<char> vals(sz);
5236 std::copy(PyString_AsString(strOrListOfInt),PyString_AsString(strOrListOfInt)+sz,vals.begin());
5237 return self->search(vals);
5240 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::search : only strings in input supported !");
5243 PyObject *getTuple(int tupleId) const throw(INTERP_KERNEL::Exception)
5245 int sz=self->getNumberOfComponents();
5246 INTERP_KERNEL::AutoPtr<char> tmp=new char[sz+1]; tmp[sz]='\0';
5247 self->getTuple(tupleId,tmp);
5248 return PyString_FromString(tmp);
5251 PyObject *getMaxValue() const throw(INTERP_KERNEL::Exception)
5254 char tmp2[2]; tmp2[1]='\0';
5255 tmp2[0]=self->getMaxValue(tmp);
5256 PyObject *ret=PyTuple_New(2);
5257 PyTuple_SetItem(ret,0,PyString_FromString(tmp2));
5258 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
5262 PyObject *getMinValue() const throw(INTERP_KERNEL::Exception)
5265 char tmp2[2]; tmp2[1]='\0';
5266 tmp2[0]=self->getMinValue(tmp);
5267 PyObject *ret=PyTuple_New(2);
5268 PyTuple_SetItem(ret,0,PyString_FromString(tmp2));
5269 PyTuple_SetItem(ret,1,PyInt_FromLong(tmp));
5273 int index(PyObject *obj) const throw(INTERP_KERNEL::Exception)
5275 int nbOfCompo=self->getNumberOfComponents();
5280 if(PyString_Check(obj))
5282 Py_ssize_t sz=PyString_Size(obj);
5283 char *pt=PyString_AsString(obj);
5285 return self->locateValue(pt[0]);
5287 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find a string with size different from 1 !");
5290 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::index : 'this' contains one component and trying to find an element which is not an integer !");
5293 return ParaMEDMEM_DataArrayAsciiChar_locateTuple(self,obj);
5297 bool __contains__(PyObject *obj) const throw(INTERP_KERNEL::Exception)
5299 int nbOfCompo=self->getNumberOfComponents();
5306 if(PyString_Check(obj))
5308 Py_ssize_t sz=PyString_Size(obj);
5309 char *pt=PyString_AsString(obj);
5311 return self->presenceOfValue(pt[0]);
5313 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find a string with size different from 1 !");
5316 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__contains__ : 'this' contains one component and trying to find an element which is not an integer !");
5319 return ParaMEDMEM_DataArrayAsciiChar_presenceOfTuple(self,obj);
5323 PyObject *__getitem__(PyObject *obj) const throw(INTERP_KERNEL::Exception)
5326 std::vector<int> stdvecTyyppArr;
5327 std::pair<int, std::pair<int,int> > sTyyppArr;
5328 ParaMEDMEM::DataArrayInt *daIntTyypp=0;
5329 convertObjToPossibleCpp2(obj,self->getNumberOfTuples(),sw,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp);
5333 return ParaMEDMEM_DataArrayAsciiChar_getTuple(self,iTypppArr);
5335 return convertDataArrayChar(self->selectByTupleIdSafe(&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size()), SWIG_POINTER_OWN | 0 );
5337 return convertDataArrayChar(self->selectByTupleId2(sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second), SWIG_POINTER_OWN | 0 );
5339 return convertDataArrayChar(self->selectByTupleIdSafe(daIntTyypp->begin(),daIntTyypp->end()), SWIG_POINTER_OWN | 0 );
5341 throw INTERP_KERNEL::Exception("DataArrayAsciiChar::__getitem__ : supporting int, list of int, tuple of int, DataArrayInt and slice in input !");
5345 DataArrayAsciiChar *__setitem__(PyObject *obj, PyObject *value) throw(INTERP_KERNEL::Exception)
5347 static const char msg[]="DataArrayAsciiChar::__setitem__ : supporting int, list of int, tuple of int, DataArrayInt and slice in input, and 4 types accepted in value : string, list or tuple of strings having same size, not null DataArrayChar instance.";
5349 std::vector<int> stdvecTyyppArr;
5350 std::pair<int, std::pair<int,int> > sTyyppArr;
5351 ParaMEDMEM::DataArrayInt *daIntTyypp=0;
5352 int nbOfCompo=self->getNumberOfComponents();
5353 int nbOfTuples=self->getNumberOfTuples();
5354 convertObjToPossibleCpp2(obj,nbOfTuples,sw1,iTypppArr,stdvecTyyppArr,sTyyppArr,daIntTyypp);
5356 char vc; std::string sc; std::vector<std::string> vsc; DataArrayChar *dacc=0;
5357 convertObjToPossibleCpp6(value,sw2,vc,sc,vsc,dacc);
5366 self->setPartOfValuesSimple3(vc,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1);
5372 MEDCouplingAutoRefCountObjectPtr<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
5373 self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
5376 //value vector<string>
5379 MEDCouplingAutoRefCountObjectPtr<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
5380 self->setPartOfValues3(tmp,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
5383 //value DataArrayChar
5386 self->setPartOfValues3(dacc,&iTypppArr,&iTypppArr+1,0,nbOfCompo,1,false);
5390 throw INTERP_KERNEL::Exception(msg);
5394 {//obj list-tuple[int]
5400 self->setPartOfValuesSimple3(vc,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1);
5406 MEDCouplingAutoRefCountObjectPtr<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
5407 self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
5410 //value vector<string>
5413 MEDCouplingAutoRefCountObjectPtr<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
5414 self->setPartOfValues3(tmp,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
5417 //value DataArrayChar
5420 self->setPartOfValues3(dacc,&stdvecTyyppArr[0],&stdvecTyyppArr[0]+stdvecTyyppArr.size(),0,nbOfCompo,1,false);
5424 throw INTERP_KERNEL::Exception(msg);
5435 self->setPartOfValuesSimple1(vc,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1);
5441 MEDCouplingAutoRefCountObjectPtr<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
5442 self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
5445 //value vector<string>
5448 MEDCouplingAutoRefCountObjectPtr<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
5449 self->setPartOfValues1(tmp,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
5452 //value DataArrayChar
5455 self->setPartOfValues1(dacc,sTyyppArr.first,sTyyppArr.second.first,sTyyppArr.second.second,0,nbOfCompo,1,false);
5459 throw INTERP_KERNEL::Exception(msg);
5470 self->setPartOfValuesSimple3(vc,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1);
5476 MEDCouplingAutoRefCountObjectPtr<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(sc);
5477 self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
5480 //value vector<string>
5483 MEDCouplingAutoRefCountObjectPtr<DataArrayAsciiChar> tmp=DataArrayAsciiChar::New(vsc,' ');
5484 self->setPartOfValues3(tmp,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
5487 //value DataArrayChar
5490 self->setPartOfValues3(dacc,daIntTyypp->begin(),daIntTyypp->end(),0,nbOfCompo,1,false);
5494 throw INTERP_KERNEL::Exception(msg);
5499 throw INTERP_KERNEL::Exception(msg);
5505 class DataArrayAsciiCharTuple;
5507 class DataArrayAsciiCharIterator
5510 DataArrayAsciiCharIterator(DataArrayAsciiChar *da);
5511 ~DataArrayAsciiCharIterator();
5516 DataArrayAsciiCharTuple *ret=self->nextt();
5518 return SWIG_NewPointerObj(SWIG_as_voidptr(ret),SWIGTYPE_p_ParaMEDMEM__DataArrayAsciiCharTuple,SWIG_POINTER_OWN | 0);
5521 PyErr_SetString(PyExc_StopIteration,"No more data.");
5528 class DataArrayAsciiCharTuple
5531 int getNumberOfCompo() const throw(INTERP_KERNEL::Exception);
5532 DataArrayAsciiChar *buildDAAsciiChar(int nbOfTuples, int nbOfCompo) const throw(INTERP_KERNEL::Exception);
5535 std::string __str__() const throw(INTERP_KERNEL::Exception)
5537 return self->repr();
5540 DataArrayAsciiChar *buildDAAsciiChar() throw(INTERP_KERNEL::Exception)
5542 return self->buildDAAsciiChar(1,self->getNumberOfCompo());