src/MEDCoupling_Swig/MEDCouplingNumPyTest.py

   1 #  -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2016  CEA/DEN, EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License, or (at your option) any later version.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20
  21
  22 import sys
  23 if sys.platform == "win32":
  24     from MEDCouplingCompat import *
  25 else:
  26     from MEDCoupling import *
  27
  28 if MEDCouplingHasNumPyBindings():
  29     from numpy import *
  30     pass
  31
  32 from platform import architecture
  33 from sys import getrefcount
  34
  35 import os,gc,weakref,unittest
  36
  37 class MEDCouplingNumPyTest(unittest.TestCase):
  38
  39     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
  40     def test1(self):
  41         sz=20
  42         a=array(0,dtype=int32)
  43         a.resize(sz)
  44         a[:]=4
  45         self.assertEqual(getrefcount(a),2)
  46         a=a.cumsum(dtype=int32)
  47         a=array(a,dtype=int64) ; a=array(a,dtype=int32)
  48         self.assertEqual(getrefcount(a),2)
  49         d=DataArrayInt(a)
  50         d[:]=2
  51         #
  52         e=DataArrayInt(sz) ; e.fillWithValue(2)
  53         self.assertTrue(d.isEqual(e))
  54         #
  55         a[:]=4 ; e.fillWithValue(4)
  56         self.assertTrue(d.isEqual(e))
  57         pass
  58
  59     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
  60     def test2(self):
  61         sz=20
  62         a=array(0,dtype=int32)
  63         a.resize(sz,2)
  64         self.assertEqual(getrefcount(a),2)
  65         b=a.reshape(2*sz)
  66         self.assertEqual(getrefcount(a),3)
  67         self.assertEqual(getrefcount(b),2)
  68         b[:]=5
  69         d=DataArrayInt(b)
  70         #
  71         e=DataArrayInt(sz*2) ; e.fillWithValue(5)
  72         self.assertTrue(d.isEqual(e))
  73         pass
  74
  75     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
  76     def test3(self):
  77         sz=10
  78         a=array(0,dtype=int32)
  79         a.resize(sz,2)
  80         b=a.reshape(2*sz)
  81         c=a.reshape(2,sz)
  82         b[:]=6
  83         b[7:17]=7
  84         d=DataArrayInt(b)
  85         self.assertTrue(d.isEqual(DataArrayInt([6,6,6,6,6,6,6,7,7,7,7,7,7,7,7,7,7,6,6,6])))
  86         #
  87         a=zeros((10,2),dtype=int32)
  88         b=a.T
  89         c=b.view()
  90         a.shape=20
  91         a[3:]=10.
  92         d=DataArrayInt(a)
  93         self.assertTrue(d.isEqual(DataArrayInt([0,0,0,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10])))
  94         pass
  95
  96     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
  97     def test4(self):
  98         a=zeros(20,dtype=int32)
  99         b = a[::-1]
 100         self.assertRaises(InterpKernelException,DataArrayInt.New,b) # b is not contiguous in memory
 101         pass
 102
 103     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 104     def test5(self):
 105         a=arange(20,dtype=int32)
 106         self.assertEqual(weakref.getweakrefcount(a),0)
 107         d=DataArrayInt(a)
 108         self.assertEqual(weakref.getweakrefcount(a),1)
 109         self.assertTrue(not a.flags["OWNDATA"])
 110         self.assertTrue(d.isIota(20))
 111         a[:]=2 # modifying a and d because a and d share the same chunk of data
 112         self.assertTrue(d.isUniform(2))
 113         del d # d is destroyed, a retrieves its ownership of its initial chunk of data
 114         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 115         import gc
 116         gc.collect()
 117         self.assertTrue(a.flags["OWNDATA"])
 118         a[:]=4 # a can be used has usual
 119         self.assertTrue(DataArrayInt(a).isUniform(4))
 120         pass
 121
 122     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 123     def test6(self):
 124         a=arange(20,dtype=int32)
 125         d=DataArrayInt(a) # d owns data of a
 126         e=DataArrayInt(a) # a not owned -> e only an access to chunk of a
 127         self.assertTrue(d.isIota(d.getNumberOfTuples()))
 128         self.assertTrue(e.isIota(e.getNumberOfTuples()))
 129         a[:]=6
 130         self.assertTrue(d.isUniform(6))
 131         self.assertTrue(e.isUniform(6))
 132         del a # a destroyed -> d no change because owned and e array is has no more data set
 133         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 134         import gc
 135         gc.collect()
 136         self.assertTrue(d.isUniform(6))
 137         self.assertTrue(not e.isAllocated())
 138         pass
 139
 140     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 141     def test7(self):
 142         a=array(0,dtype=int32) ; a.resize(10,2)
 143         b=a.reshape(20)
 144         c=a.reshape(2,10)
 145         d=DataArrayInt(b) # d owns data of a
 146         e=DataArrayInt(b) # a not owned -> e only an access to chunk of a
 147         f=DataArrayInt(b) # a not owned -> e only an access to chunk of a
 148         del d # d removed -> a ownes again data
 149         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 150         import gc
 151         gc.collect()
 152         self.assertTrue(e.isUniform(0))
 153         e[:]=6
 154         self.assertTrue(e.isUniform(6))
 155         self.assertTrue(f.isUniform(6))
 156         self.assertEqual(b.tolist(),[6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6])
 157         self.assertEqual(a.tolist(),[[6,6],[6,6],[6,6],[6,6],[6,6],[6,6],[6,6],[6,6],[6,6],[6,6]])
 158         b[:]=arange(20)
 159         del b # no impact on e and f because a is the base of a.
 160         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 161         gc.collect()
 162         self.assertTrue(f.isIota(f.getNumberOfTuples()))
 163         self.assertTrue(e.isIota(e.getNumberOfTuples()))
 164         del a # a destroyed, but as c has its base set to a, a exists -> e and f not allocated
 165         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 166         gc.collect()
 167         self.assertTrue(f.isIota(f.getNumberOfTuples()))
 168         self.assertTrue(e.isIota(e.getNumberOfTuples()))
 169         del c # c killed -> a killed -> e and d are put into not allocated state
 170         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 171         gc.collect()
 172         self.assertTrue(not e.isAllocated())
 173         self.assertTrue(not f.isAllocated())
 174         pass
 175
 176     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 177     def test8(self):
 178         a=arange(20,dtype=int32)
 179         self.assertTrue(a.flags["OWNDATA"])
 180         d=DataArrayInt(a) # d owns data of a
 181         self.assertTrue(not a.flags["OWNDATA"])
 182         d.pushBackSilent(20)# d pushBack so release of chunk of data -> a becomes owner of its data again
 183         self.assertTrue(a.flags["OWNDATA"])
 184         self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20])))
 185         self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19])
 186         pass
 187
 188     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 189     def test9(self):
 190         sz=20
 191         a=array(0,dtype=float64)
 192         a.resize(sz)
 193         a[:]=4
 194         self.assertEqual(getrefcount(a),2)
 195         a=a.cumsum(dtype=float64)
 196         self.assertEqual(getrefcount(a),2)
 197         d=DataArrayDouble(a)
 198         d[:]=2
 199         #
 200         e=DataArrayDouble(sz) ; e.fillWithValue(2)
 201         self.assertTrue(d.isEqual(e,1e-14))
 202         #
 203         a[:]=4 ; e.fillWithValue(4)
 204         self.assertTrue(d.isEqual(e,1e-14))
 205         pass
 206
 207     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 208     def test10(self):
 209         sz=20
 210         a=array(0,dtype=float64)
 211         a.resize(sz,2)
 212         self.assertEqual(getrefcount(a),2)
 213         b=a.reshape(2*sz)
 214         self.assertEqual(getrefcount(a),3)
 215         self.assertEqual(getrefcount(b),2)
 216         b[:]=5
 217         d=DataArrayDouble(b)
 218         #
 219         e=DataArrayDouble(sz*2) ; e.fillWithValue(5)
 220         self.assertTrue(d.isEqual(e,1e-14))
 221         pass
 222
 223     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 224     def test11(self):
 225         sz=10
 226         a=array(0,dtype=float64)
 227         a.resize(sz,2)
 228         b=a.reshape(2*sz)
 229         c=a.reshape(2,sz)
 230         b[:]=6
 231         b[7:17]=7
 232         d=DataArrayDouble(b)
 233         self.assertTrue(d.isEqual(DataArrayDouble([6,6,6,6,6,6,6,7,7,7,7,7,7,7,7,7,7,6,6,6]),1e-14))
 234         #
 235         a=zeros((10,2),dtype=float64)
 236         b=a.T
 237         c=b.view()
 238         a.shape=20
 239         a[3:]=10.
 240         d=DataArrayDouble(a)
 241         self.assertTrue(d.isEqual(DataArrayDouble([0,0,0,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10]),1e-14))
 242         pass
 243
 244     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 245     def test12(self):
 246         a=zeros(20,dtype=float64)
 247         b = a[::-1]
 248         self.assertRaises(InterpKernelException,DataArrayDouble.New,b) # b is not contiguous in memory
 249         pass
 250
 251     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 252     def test13(self):
 253         a=arange(20,dtype=float64)
 254         self.assertEqual(weakref.getweakrefcount(a),0)
 255         d=DataArrayDouble(a)
 256         self.assertEqual(weakref.getweakrefcount(a),1)
 257         self.assertTrue(not a.flags["OWNDATA"])
 258         self.assertTrue(d.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]),1e-14))
 259         self.assertEqual(len(d),20)
 260         a[:]=2 # modifying a and d because a and d share the same chunk of data
 261         self.assertTrue(d.isUniform(2,1e-14))
 262         del d # d is destroyed, a retrieves its ownership of its initial chunk of data
 263         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 264         import gc
 265         gc.collect()
 266         self.assertTrue(a.flags["OWNDATA"])
 267         a[:]=4 # a can be used has usual
 268         self.assertTrue(DataArrayDouble(a).isUniform(4,1e-14))
 269         pass
 270
 271     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 272     def test14(self):
 273         a=arange(20,dtype=float64)
 274         d=DataArrayDouble(a) # d owns data of a
 275         e=DataArrayDouble(a) # a not owned -> e only an access to chunk of a
 276         self.assertTrue(d.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]),1e-14))
 277         self.assertTrue(e.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]),1e-14))
 278         a[:]=6
 279         self.assertTrue(d.isUniform(6,1e-14))
 280         self.assertTrue(e.isUniform(6,1e-14))
 281         del a # a destroyed -> d no change because owned and e array is has no more data set
 282         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 283         import gc
 284         gc.collect()
 285         self.assertTrue(d.isUniform(6,1e-14))
 286         self.assertTrue(not e.isAllocated())
 287         pass
 288
 289     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 290     def test15(self):
 291         a=array(0,dtype=float64) ; a.resize(10,2)
 292         b=a.reshape(20)
 293         c=a.reshape(2,10)
 294         d=DataArrayDouble(b) # d owns data of a
 295         e=DataArrayDouble(b) # a not owned -> e only an access to chunk of a
 296         f=DataArrayDouble(b) # a not owned -> e only an access to chunk of a
 297         del d # d removed -> a ownes again data
 298         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 299         import gc
 300         gc.collect()
 301         self.assertTrue(e.isUniform(0,1e-14))
 302         e[:]=6
 303         self.assertTrue(e.isUniform(6,1e-14))
 304         self.assertTrue(f.isUniform(6,1e-14))
 305         self.assertEqual(b.tolist(),[6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6])
 306         self.assertEqual(a.tolist(),[[6,6],[6,6],[6,6],[6,6],[6,6],[6,6],[6,6],[6,6],[6,6],[6,6]])
 307         b[:]=arange(20)
 308         del b # no impact on e and f because a is the base of a.
 309         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 310         gc.collect()
 311         self.assertTrue(f.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]),1e-14))
 312         self.assertTrue(e.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]),1e-14))
 313         del a # a destroyed, but as c has its base set to a, a exists -> e and f not allocated
 314         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 315         gc.collect()
 316         self.assertTrue(f.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]),1e-14))
 317         self.assertTrue(e.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]),1e-14))
 318         del c # c killed -> a killed -> e and d are put into not allocated state
 319         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 320         gc.collect()
 321         self.assertTrue(not e.isAllocated())
 322         self.assertTrue(not f.isAllocated())
 323         pass
 324
 325     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 326     def test16(self):
 327         a=arange(20,dtype=float64)
 328         self.assertTrue(a.flags["OWNDATA"])
 329         d=DataArrayDouble(a) # d owns data of a
 330         self.assertTrue(not a.flags["OWNDATA"])
 331         d.pushBackSilent(20)# d pushBack so release of chunk of data -> a becomes owner of its data again
 332         self.assertTrue(a.flags["OWNDATA"])
 333         self.assertTrue(d.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]),1e-14))
 334         self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19])
 335         pass
 336
 337     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 338     def test17(self):
 339         d=DataArrayInt.Range(0,20,1)
 340         a=d.toNumPyArray()
 341         self.assertTrue(not a.flags["OWNDATA"])
 342         a[-2:]=100
 343         self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,100,100])))
 344         self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,100,100])
 345         del a
 346         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 347         import gc
 348         gc.collect()
 349         self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,100,100])))
 350         #
 351         d.rearrange(2)
 352         a=d.toNumPyArray()
 353         self.assertTrue(not a.flags["OWNDATA"])
 354         a[-2:]=200
 355         self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,200,200,200,200],10,2)))
 356         self.assertEqual(a.tolist(),[[0,1],[2,3],[4,5],[6,7],[8,9],[10,11],[12,13],[14,15],[200,200],[200,200]])
 357         del a
 358         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 359         gc.collect()
 360         self.assertTrue(d.isEqual(DataArrayInt([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,200,200,200,200],10,2)))
 361         pass
 362
 363     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 364     def test18(self):
 365         d=DataArrayInt.Range(0,20,1)
 366         d=d.convertToDblArr()
 367         a=d.toNumPyArray()
 368         self.assertTrue(not a.flags["OWNDATA"])
 369         a[-2:]=100
 370         self.assertTrue(d.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,100,100]),1e-14))
 371         self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,100,100])
 372         del a
 373         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 374         import gc
 375         gc.collect()
 376         self.assertTrue(d.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,100,100]),1e-14))
 377         #
 378         d.rearrange(2)
 379         a=d.toNumPyArray()
 380         self.assertTrue(not a.flags["OWNDATA"])
 381         a[-2:]=200
 382         self.assertTrue(d.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,200,200,200,200],10,2),1e-14))
 383         self.assertEqual(a.tolist(),[[0,1],[2,3],[4,5],[6,7],[8,9],[10,11],[12,13],[14,15],[200,200],[200,200]])
 384         del a
 385         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 386         gc.collect()
 387         self.assertTrue(d.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,200,200,200,200],10,2),1e-14))
 388         pass
 389
 390     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 391     def test19(self):
 392         sz=20
 393         a=array(0,dtype=int32)
 394         a.resize(sz//2,2)
 395         a[:]=4
 396         self.assertEqual(getrefcount(a),2)
 397         d=DataArrayInt(a)
 398         self.assertEqual(10,d.getNumberOfTuples())
 399         self.assertEqual(2,d.getNumberOfComponents())
 400         self.assertEqual(sz,d.getNbOfElems())
 401         self.assertTrue(d.isEqual(DataArrayInt([(4,4),(4,4),(4,4),(4,4),(4,4),(4,4),(4,4),(4,4),(4,4),(4,4)])))
 402         a[:]=7
 403         self.assertTrue(d.isEqual(DataArrayInt([(7,7),(7,7),(7,7),(7,7),(7,7),(7,7),(7,7),(7,7),(7,7),(7,7)])))
 404         #
 405         b=a.reshape((2,5,2))
 406         self.assertRaises(InterpKernelException,DataArrayInt.New,b) # b has not dimension in [0,1] !
 407         pass
 408
 409     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 410     def test20(self):
 411         sz=20
 412         a=array(0,dtype=float64)
 413         a.resize(sz//2,2)
 414         a[:]=4
 415         self.assertEqual(getrefcount(a),2)
 416         d=DataArrayDouble(a)
 417         self.assertEqual(10,d.getNumberOfTuples())
 418         self.assertEqual(2,d.getNumberOfComponents())
 419         self.assertEqual(sz,d.getNbOfElems())
 420         self.assertTrue(d.isEqual(DataArrayDouble([(4.,4.),(4.,4.),(4.,4.),(4.,4.),(4.,4.),(4.,4.),(4.,4.),(4.,4.),(4.,4.),(4.,4.)]),1e-14))
 421         a[:]=7
 422         self.assertTrue(d.isEqual(DataArrayDouble([(7.,7.),(7.,7.),(7.,7.),(7.,7.),(7.,7.),(7.,7.),(7.,7.),(7.,7.),(7.,7.),(7.,7.)]),1e-14))
 423         #
 424         b=a.reshape((2,5,2))
 425         self.assertRaises(InterpKernelException,DataArrayDouble.New,b) # b has not dimension in [0,1] !
 426         pass
 427
 428     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 429     def test21(self):
 430         #tests that only DataArray*(npArray) constructor is available
 431         a=array(0,dtype=int32)
 432         a.resize(20)
 433         DataArrayInt(a)
 434         self.assertRaises(InterpKernelException,DataArrayInt.New,a,20)
 435         self.assertRaises(InterpKernelException,DataArrayInt.New,a,20,1)
 436         a=array(0,dtype=float64)
 437         a.resize(20)
 438         DataArrayDouble(a)
 439         self.assertRaises(InterpKernelException,DataArrayDouble.New,a,20)
 440         self.assertRaises(InterpKernelException,DataArrayDouble.New,a,20,1)
 441         pass
 442
 443     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 444     def test22(self):
 445         d=DataArrayDouble(10)
 446         d.iota()
 447         a=d.toNumPyArray()
 448         self.assertTrue(not a.flags["OWNDATA"])
 449         del d
 450         gc.collect()
 451         self.assertTrue(a.flags["OWNDATA"])
 452         self.assertEqual(a.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 453         #
 454         d=DataArrayInt(10)
 455         d.iota()
 456         a=d.toNumPyArray()
 457         self.assertTrue(not a.flags["OWNDATA"])
 458         del d
 459         gc.collect()
 460         self.assertTrue(a.flags["OWNDATA"])
 461         self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9])
 462         pass
 463
 464     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 465     def test23(self):
 466         d=DataArrayDouble(10)
 467         d.iota()
 468         a=d.toNumPyArray()
 469         b=d.toNumPyArray()
 470         c=d.toNumPyArray()
 471         self.assertTrue(not a.flags["OWNDATA"])
 472         self.assertTrue(not b.flags["OWNDATA"])
 473         self.assertTrue(not c.flags["OWNDATA"])
 474         self.assertEqual(a.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 475         self.assertEqual(b.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 476         self.assertEqual(c.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 477         del d
 478         gc.collect()
 479         self.assertTrue(a.flags["OWNDATA"])
 480         self.assertTrue(not b.flags["OWNDATA"])
 481         self.assertTrue(not c.flags["OWNDATA"])
 482         self.assertEqual(a.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 483         self.assertEqual(b.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 484         self.assertEqual(c.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 485         #
 486         d=DataArrayInt(10)
 487         d.iota()
 488         a=d.toNumPyArray()
 489         b=d.toNumPyArray()
 490         c=d.toNumPyArray()
 491         self.assertTrue(not a.flags["OWNDATA"])
 492         self.assertTrue(not b.flags["OWNDATA"])
 493         self.assertTrue(not c.flags["OWNDATA"])
 494         self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9])
 495         self.assertEqual(b.tolist(),[0,1,2,3,4,5,6,7,8,9])
 496         self.assertEqual(c.tolist(),[0,1,2,3,4,5,6,7,8,9])
 497         del d
 498         gc.collect()
 499         self.assertTrue(a.flags["OWNDATA"])
 500         self.assertTrue(not b.flags["OWNDATA"])
 501         self.assertTrue(not c.flags["OWNDATA"])
 502         self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9])
 503         self.assertEqual(b.tolist(),[0,1,2,3,4,5,6,7,8,9])
 504         self.assertEqual(c.tolist(),[0,1,2,3,4,5,6,7,8,9])
 505         pass
 506
 507     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 508     def test24(self):
 509         d=DataArrayDouble(10)
 510         d.iota()
 511         a=d.toNumPyArray()
 512         self.assertEqual(a.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 513         self.assertTrue(not a.flags["OWNDATA"])
 514         self.assertTrue(a.base is None)
 515         del a
 516         gc.collect()
 517         a=d.toNumPyArray()
 518         self.assertEqual(a.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 519         self.assertTrue(not a.flags["OWNDATA"])
 520         self.assertTrue(a.base is None)
 521         b=d.toNumPyArray()
 522         self.assertEqual(a.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 523         self.assertEqual(b.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 524         self.assertTrue(not a.flags["OWNDATA"])
 525         self.assertTrue(not b.flags["OWNDATA"])
 526         self.assertTrue(b.base is a)
 527         del a
 528         gc.collect()
 529         self.assertEqual(b.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 530         self.assertTrue(not b.flags["OWNDATA"])
 531         del d
 532         gc.collect()
 533         self.assertEqual(b.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 534         self.assertTrue(not b.flags["OWNDATA"])
 535         #
 536         d=DataArrayInt(10)
 537         d.iota()
 538         a=d.toNumPyArray()
 539         self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9])
 540         self.assertTrue(not a.flags["OWNDATA"])
 541         self.assertTrue(a.base is None)
 542         del a
 543         gc.collect()
 544         a=d.toNumPyArray()
 545         self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9])
 546         self.assertTrue(not a.flags["OWNDATA"])
 547         self.assertTrue(a.base is None)
 548         b=d.toNumPyArray()
 549         self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9])
 550         self.assertEqual(b.tolist(),[0,1,2,3,4,5,6,7,8,9])
 551         self.assertTrue(not a.flags["OWNDATA"])
 552         self.assertTrue(not b.flags["OWNDATA"])
 553         self.assertTrue(b.base is a)
 554         del a
 555         gc.collect()
 556         self.assertEqual(b.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 557         self.assertTrue(not b.flags["OWNDATA"])
 558         del d
 559         gc.collect()
 560         self.assertEqual(b.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 561         self.assertTrue(not b.flags["OWNDATA"])
 562         pass
 563
 564     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 565     def test25(self):
 566         a=arange(10,dtype=int32)
 567         b=DataArrayInt(a)
 568         c=DataArrayInt(a)
 569         d=DataArrayInt(a)
 570         self.assertTrue(b.isIota(10))
 571         self.assertTrue(c.isIota(10))
 572         self.assertTrue(d.isIota(10))
 573         c.pushBackSilent(10) # c and a,b are dissociated
 574         self.assertTrue(b.isIota(10))
 575         self.assertTrue(c.isIota(11))
 576         self.assertTrue(d.isIota(10))
 577         del a
 578         gc.collect()
 579         self.assertTrue(b.isIota(10))
 580         self.assertTrue(c.isIota(11))
 581         self.assertTrue(not d.isAllocated())
 582         del b
 583         gc.collect()
 584         self.assertTrue(c.isIota(11))
 585         #
 586         a=arange(10,dtype=int32)
 587         b=DataArrayInt(a)
 588         c=DataArrayInt(a)
 589         self.assertTrue(b.isIota(10))
 590         self.assertTrue(c.isIota(10))
 591         b.pushBackSilent(10) # c and a,b are dissociated
 592         self.assertTrue(b.isIota(11))
 593         self.assertTrue(c.isIota(10))
 594         del a
 595         gc.collect()
 596         self.assertTrue(b.isIota(11))
 597         self.assertTrue(not c.isAllocated())
 598         del b
 599         gc.collect()
 600         self.assertTrue(not c.isAllocated())
 601         #
 602         a=float64(arange(5,dtype=int32))
 603         b=DataArrayDouble(a)
 604         c=DataArrayDouble(a)
 605         d=DataArrayDouble(a)
 606         self.assertTrue(b.isEqual(DataArrayDouble([0.,1.,2.,3.,4.]),1e-12))
 607         self.assertTrue(c.isEqual(DataArrayDouble([0.,1.,2.,3.,4.]),1e-12))
 608         self.assertTrue(d.isEqual(DataArrayDouble([0.,1.,2.,3.,4.]),1e-12))
 609         c.pushBackSilent(10.) # c and a,b are dissociated
 610         self.assertTrue(b.isEqual(DataArrayDouble([0.,1.,2.,3.,4.]),1e-12))
 611         self.assertTrue(c.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,10.]),1e-12))
 612         self.assertTrue(d.isEqual(DataArrayDouble([0.,1.,2.,3.,4.]),1e-12))
 613         del a
 614         gc.collect()
 615         self.assertTrue(b.isEqual(DataArrayDouble([0.,1.,2.,3.,4.]),1e-12))
 616         self.assertTrue(c.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,10.]),1e-12))
 617         self.assertTrue(not d.isAllocated())
 618         del b
 619         gc.collect()
 620         self.assertTrue(c.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,10.]),1e-12))
 621         #
 622         a=float64(arange(5,dtype=int32))
 623         b=DataArrayDouble(a)
 624         c=DataArrayDouble(a)
 625         self.assertTrue(b.isEqual(DataArrayDouble([0.,1.,2.,3.,4.]),1e-12))
 626         self.assertTrue(c.isEqual(DataArrayDouble([0.,1.,2.,3.,4.]),1e-12))
 627         b.pushBackSilent(10.) # c and a,b are dissociated
 628         self.assertTrue(b.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,10.]),1e-12))
 629         self.assertTrue(c.isEqual(DataArrayDouble([0.,1.,2.,3.,4.]),1e-12))
 630         del a
 631         gc.collect()
 632         self.assertTrue(b.isEqual(DataArrayDouble([0.,1.,2.,3.,4.,10.]),1e-12))
 633         self.assertTrue(not c.isAllocated())
 634         del b
 635         gc.collect()
 636         self.assertTrue(not c.isAllocated())
 637         pass
 638
 639     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 640     def test26(self):
 641         d=DataArrayInt(15) ; d.iota()
 642         d.rearrange(3)
 643         a=d.toNumPyArray()
 644         self.assertEqual(a.ndim,2)
 645         self.assertEqual(a.size,15)
 646         self.assertEqual(a.shape,(5,3))
 647         self.assertEqual(a.strides,(12,4))
 648         self.assertEqual(a.nbytes,60)
 649         self.assertEqual(a.itemsize,4)
 650         self.assertEqual(a.tolist(),[[0,1,2],[3,4,5],[6,7,8],[9,10,11],[12,13,14]])
 651         #
 652         d2=d.convertToDblArr()
 653         a2=d2.toNumPyArray()
 654         self.assertEqual(a2.ndim,2)
 655         self.assertEqual(a2.size,15)
 656         self.assertEqual(a2.shape,(5,3))
 657         self.assertEqual(a2.strides,(24,8))
 658         self.assertEqual(a2.nbytes,120)
 659         self.assertEqual(a2.itemsize,8)
 660         self.assertEqual(a2.tolist(),[[0.,1.,2.],[3.,4.,5.],[6.,7.,8.],[9.,10.,11.],[12.,13.,14.]])
 661         pass
 662
 663     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 664     def test27(self):
 665         m0=DenseMatrix(DataArrayDouble([2,3,4,5,1,6]),2,3)
 666         m0np=m0.toNumPyMatrix()
 667         self.assertEqual(m0np.shape,(2,3))
 668         self.assertEqual(m0np.tolist(),[[2.0,3.0,4.0],[5.0,1.0,6.0]])
 669         pass
 670
 671     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 672     def test28(self):
 673         """Test on DataArrayBytes"""
 674         # use case 1
 675         d=DataArrayByte(256)
 676         for i in range(len(d)):
 677             d[i]=-128+i
 678             pass
 679         arr=d.toNumPyArray()
 680         for i in range(len(d)):
 681             self.assertEqual(int(arr[i]),-128+i)
 682             pass
 683         d[0]=7
 684         self.assertEqual(int(arr[0]),7)
 685         arr[0]=8
 686         self.assertEqual(int(d.getIJ(0,0)),8)
 687         del arr
 688         gc.collect()
 689         del d
 690         gc.collect()
 691         # use case 2
 692         d=DataArrayByte(256)
 693         for i in range(len(d)):
 694             d[i]=-128+i
 695             pass
 696         arr=d.toNumPyArray()
 697         for i in range(len(d)):
 698             self.assertEqual(int(arr[i]),-128+i)
 699             pass
 700         del d
 701         gc.collect()
 702         del arr
 703         gc.collect()
 704         # use case 3
 705         d=DataArrayByte(256)
 706         for i in range(len(d)):
 707             d[i]=-128+i
 708             pass
 709         arr1=d.toNumPyArray()
 710         arr2=d.toNumPyArray()
 711         arr3=d.toNumPyArray()
 712         d[0]=10
 713         self.assertEqual(int(arr1[0]),10) ; self.assertEqual(int(arr2[0]),10) ; self.assertEqual(int(arr3[0]),10)
 714         arr2[0]=15 ; self.assertEqual(int(d.getIJ(0,0)),15) ; self.assertEqual(int(arr1[0]),15) ; self.assertEqual(int(arr3[0]),15)
 715         arr1[0]=-128
 716         for i in range(len(d)):
 717             self.assertEqual(int(arr1[i]),-128+i)
 718             self.assertEqual(int(arr2[i]),-128+i)
 719             self.assertEqual(int(arr3[i]),-128+i)
 720             pass
 721         del arr2
 722         gc.collect()
 723         for i in range(len(d)):
 724             self.assertEqual(int(arr1[i]),-128+i)
 725             self.assertEqual(int(arr3[i]),-128+i)
 726             pass
 727         del arr1
 728         gc.collect()
 729         for i in range(len(d)):
 730             self.assertEqual(int(arr3[i]),-128+i)
 731             pass
 732         del arr3
 733         gc.collect()
 734         # use case 4
 735         arr=array(0,dtype=int8)
 736         arr.resize(256)
 737         for i in range(256):
 738             arr[i]=-128+i
 739             pass
 740         d=DataArrayByte(arr)
 741         for i in range(256):
 742             self.assertEqual(int(d.getIJ(i,0)),-128+i)
 743             pass
 744         del arr
 745         gc.collect()
 746         del d
 747         gc.collect()
 748         # use case 5
 749         arr=array(0,dtype=int8)
 750         arr.resize(256)
 751         for i in range(256):
 752             arr[i]=-128+i
 753             pass
 754         d=DataArrayByte(arr)
 755         for i in range(256):
 756             self.assertEqual(int(d.getIJ(i,0)),-128+i)
 757             pass
 758         del d
 759         gc.collect()
 760         del arr
 761         gc.collect()
 762         pass
 763
 764     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 765     def test29(self):
 766         """Same as test9 with float32"""
 767         sz=20
 768         a=array(0,dtype=float32)
 769         a.resize(sz)
 770         a[:]=4
 771         self.assertEqual(getrefcount(a),2)
 772         a=a.cumsum(dtype=float32)
 773         self.assertEqual(getrefcount(a),2)
 774         d=DataArrayFloat(a)
 775         d[:]=2
 776         #
 777         e=DataArrayFloat(sz) ; e.fillWithValue(2)
 778         self.assertTrue(d.isEqual(e,1e-7))
 779         #
 780         a[:]=4 ; e.fillWithValue(4)
 781         self.assertTrue(d.isEqual(e,1e-7))
 782         pass
 783
 784     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 785     def test30(self):
 786         """Same as test10 with float32"""
 787         sz=20
 788         a=array(0,dtype=float32)
 789         a.resize(sz,2)
 790         self.assertEqual(getrefcount(a),2)
 791         b=a.reshape(2*sz)
 792         self.assertEqual(getrefcount(a),3)
 793         self.assertEqual(getrefcount(b),2)
 794         b[:]=5
 795         d=DataArrayFloat(b)
 796         #
 797         e=DataArrayFloat(sz*2) ; e.fillWithValue(5)
 798         self.assertTrue(d.isEqual(e,1e-7))
 799         pass
 800
 801     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 802     def test31(self):
 803         """Same as test11 with float32"""
 804         sz=10
 805         a=array(0,dtype=float32)
 806         a.resize(sz,2)
 807         b=a.reshape(2*sz)
 808         c=a.reshape(2,sz)
 809         b[:]=6
 810         b[7:17]=7
 811         d=DataArrayFloat(b)
 812         self.assertTrue(d.isEqual(DataArrayFloat([6,6,6,6,6,6,6,7,7,7,7,7,7,7,7,7,7,6,6,6]),1e-7))
 813         #
 814         a=zeros((10,2),dtype=float32)
 815         b=a.T
 816         c=b.view()
 817         a.shape=20
 818         a[3:]=10.
 819         d=DataArrayFloat(a)
 820         self.assertTrue(d.isEqual(DataArrayFloat([0,0,0,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10]),1e-7))
 821         pass
 822
 823     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 824     def test32(self):
 825         """Same as test12 with float32"""
 826         a=zeros(20,dtype=float32)
 827         b = a[::-1]
 828         self.assertRaises(InterpKernelException,DataArrayFloat.New,b) # b is not contiguous in memory
 829         pass
 830
 831     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 832     def test33(self):
 833         """Same as test13 with float32"""
 834         a=arange(20,dtype=float32)
 835         self.assertEqual(weakref.getweakrefcount(a),0)
 836         d=DataArrayFloat(a)
 837         self.assertEqual(weakref.getweakrefcount(a),1)
 838         self.assertTrue(not a.flags["OWNDATA"])
 839         self.assertTrue(d.isEqual(DataArrayFloat([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]),1e-7))
 840         self.assertEqual(len(d),20)
 841         a[:]=2 # modifying a and d because a and d share the same chunk of data
 842         self.assertTrue(d.isUniform(2,1e-7))
 843         del d # d is destroyed, a retrieves its ownership of its initial chunk of data
 844         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 845         import gc
 846         gc.collect()
 847         self.assertTrue(a.flags["OWNDATA"])
 848         a[:]=4 # a can be used has usual
 849         self.assertTrue(DataArrayFloat(a).isUniform(4,1e-7))
 850         pass
 851
 852     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 853     def test34(self):
 854         """Same as test14 with float32"""
 855         a=arange(20,dtype=float32)
 856         d=DataArrayFloat(a) # d owns data of a
 857         e=DataArrayFloat(a) # a not owned -> e only an access to chunk of a
 858         self.assertTrue(d.isEqual(DataArrayFloat([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]),1e-7))
 859         self.assertTrue(e.isEqual(DataArrayFloat([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]),1e-7))
 860         a[:]=6
 861         self.assertTrue(d.isUniform(6,1e-7))
 862         self.assertTrue(e.isUniform(6,1e-7))
 863         del a # a destroyed -> d no change because owned and e array is has no more data set
 864         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 865         import gc
 866         gc.collect()
 867         self.assertTrue(d.isUniform(6,1e-7))
 868         self.assertTrue(not e.isAllocated())
 869         pass
 870
 871     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 872     def test35(self):
 873         """Same as test15 with float32"""
 874         a=array(0,dtype=float32) ; a.resize(10,2)
 875         b=a.reshape(20)
 876         c=a.reshape(2,10)
 877         d=DataArrayFloat(b) # d owns data of a
 878         e=DataArrayFloat(b) # a not owned -> e only an access to chunk of a
 879         f=DataArrayFloat(b) # a not owned -> e only an access to chunk of a
 880         del d # d removed -> a ownes again data
 881         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 882         import gc
 883         gc.collect()
 884         self.assertTrue(e.isUniform(0,1e-7))
 885         e[:]=6
 886         self.assertTrue(e.isUniform(6,1e-7))
 887         self.assertTrue(f.isUniform(6,1e-7))
 888         self.assertEqual(b.tolist(),[6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6])
 889         self.assertEqual(a.tolist(),[[6,6],[6,6],[6,6],[6,6],[6,6],[6,6],[6,6],[6,6],[6,6],[6,6]])
 890         b[:]=arange(20)
 891         del b # no impact on e and f because a is the base of a.
 892         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 893         gc.collect()
 894         self.assertTrue(f.isEqual(DataArrayFloat([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]),1e-7))
 895         self.assertTrue(e.isEqual(DataArrayFloat([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]),1e-7))
 896         del a # a destroyed, but as c has its base set to a, a exists -> e and f not allocated
 897         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 898         gc.collect()
 899         self.assertTrue(f.isEqual(DataArrayFloat([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]),1e-7))
 900         self.assertTrue(e.isEqual(DataArrayFloat([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]),1e-7))
 901         del c # c killed -> a killed -> e and d are put into not allocated state
 902         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 903         gc.collect()
 904         self.assertTrue(not e.isAllocated())
 905         self.assertTrue(not f.isAllocated())
 906         pass
 907
 908     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 909     def test36(self):
 910         """Same as test16 with float32"""
 911         a=arange(20,dtype=float32)
 912         self.assertTrue(a.flags["OWNDATA"])
 913         d=DataArrayFloat(a) # d owns data of a
 914         self.assertTrue(not a.flags["OWNDATA"])
 915         d.pushBackSilent(20)# d pushBack so release of chunk of data -> a becomes owner of its data again
 916         self.assertTrue(a.flags["OWNDATA"])
 917         self.assertTrue(d.isEqual(DataArrayFloat([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]),1e-7))
 918         self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19])
 919         pass
 920
 921     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 922     def test37(self):
 923         """Same as test20 with float32"""
 924         sz=20
 925         a=array(0,dtype=float32)
 926         a.resize(sz//2,2)
 927         a[:]=4
 928         self.assertEqual(getrefcount(a),2)
 929         d=DataArrayFloat(a)
 930         self.assertEqual(10,d.getNumberOfTuples())
 931         self.assertEqual(2,d.getNumberOfComponents())
 932         self.assertEqual(sz,d.getNbOfElems())
 933         self.assertTrue(d.isEqual(DataArrayFloat([(4.,4.),(4.,4.),(4.,4.),(4.,4.),(4.,4.),(4.,4.),(4.,4.),(4.,4.),(4.,4.),(4.,4.)]),1e-7))
 934         a[:]=7
 935         self.assertTrue(d.isEqual(DataArrayFloat([(7.,7.),(7.,7.),(7.,7.),(7.,7.),(7.,7.),(7.,7.),(7.,7.),(7.,7.),(7.,7.),(7.,7.)]),1e-7))
 936         #
 937         b=a.reshape((2,5,2))
 938         self.assertRaises(InterpKernelException,DataArrayFloat.New,b) # b has not dimension in [0,1] !
 939         pass
 940
 941     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 942     def test38(self):
 943         """Same as test22 with float32"""
 944         d=DataArrayFloat(10)
 945         d.iota()
 946         a=d.toNumPyArray()
 947         self.assertTrue(not a.flags["OWNDATA"])
 948         del d
 949         gc.collect()
 950         self.assertTrue(a.flags["OWNDATA"])
 951         self.assertEqual(a.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 952         #
 953         d=DataArrayInt(10)
 954         d.iota()
 955         a=d.toNumPyArray()
 956         self.assertTrue(not a.flags["OWNDATA"])
 957         del d
 958         gc.collect()
 959         self.assertTrue(a.flags["OWNDATA"])
 960         self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9])
 961         pass
 962
 963     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 964     def test39(self):
 965         """Same as test23 with float32"""
 966         d=DataArrayFloat(10)
 967         d.iota()
 968         a=d.toNumPyArray()
 969         b=d.toNumPyArray()
 970         c=d.toNumPyArray()
 971         self.assertTrue(not a.flags["OWNDATA"])
 972         self.assertTrue(not b.flags["OWNDATA"])
 973         self.assertTrue(not c.flags["OWNDATA"])
 974         self.assertEqual(a.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 975         self.assertEqual(b.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 976         self.assertEqual(c.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 977         del d
 978         gc.collect()
 979         self.assertTrue(a.flags["OWNDATA"])
 980         self.assertTrue(not b.flags["OWNDATA"])
 981         self.assertTrue(not c.flags["OWNDATA"])
 982         self.assertEqual(a.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 983         self.assertEqual(b.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 984         self.assertEqual(c.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 985         #
 986         d=DataArrayInt(10)
 987         d.iota()
 988         a=d.toNumPyArray()
 989         b=d.toNumPyArray()
 990         c=d.toNumPyArray()
 991         self.assertTrue(not a.flags["OWNDATA"])
 992         self.assertTrue(not b.flags["OWNDATA"])
 993         self.assertTrue(not c.flags["OWNDATA"])
 994         self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9])
 995         self.assertEqual(b.tolist(),[0,1,2,3,4,5,6,7,8,9])
 996         self.assertEqual(c.tolist(),[0,1,2,3,4,5,6,7,8,9])
 997         del d
 998         gc.collect()
 999         self.assertTrue(a.flags["OWNDATA"])
1000         self.assertTrue(not b.flags["OWNDATA"])
1001         self.assertTrue(not c.flags["OWNDATA"])
1002         self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9])
1003         self.assertEqual(b.tolist(),[0,1,2,3,4,5,6,7,8,9])
1004         self.assertEqual(c.tolist(),[0,1,2,3,4,5,6,7,8,9])
1005         pass
1006
1007     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
1008     def test40(self):
1009         """Same as test24 with float32"""
1010         d=DataArrayFloat(10)
1011         d.iota()
1012         a=d.toNumPyArray()
1013         self.assertEqual(a.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
1014         self.assertTrue(not a.flags["OWNDATA"])
1015         self.assertTrue(a.base is None)
1016         del a
1017         gc.collect()
1018         a=d.toNumPyArray()
1019         self.assertEqual(a.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
1020         self.assertTrue(not a.flags["OWNDATA"])
1021         self.assertTrue(a.base is None)
1022         b=d.toNumPyArray()
1023         self.assertEqual(a.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
1024         self.assertEqual(b.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
1025         self.assertTrue(not a.flags["OWNDATA"])
1026         self.assertTrue(not b.flags["OWNDATA"])
1027         self.assertTrue(b.base is a)
1028         del a
1029         gc.collect()
1030         self.assertEqual(b.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
1031         self.assertTrue(not b.flags["OWNDATA"])
1032         del d
1033         gc.collect()
1034         self.assertEqual(b.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
1035         self.assertTrue(not b.flags["OWNDATA"])
1036         #
1037         d=DataArrayInt(10)
1038         d.iota()
1039         a=d.toNumPyArray()
1040         self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9])
1041         self.assertTrue(not a.flags["OWNDATA"])
1042         self.assertTrue(a.base is None)
1043         del a
1044         gc.collect()
1045         a=d.toNumPyArray()
1046         self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9])
1047         self.assertTrue(not a.flags["OWNDATA"])
1048         self.assertTrue(a.base is None)
1049         b=d.toNumPyArray()
1050         self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9])
1051         self.assertEqual(b.tolist(),[0,1,2,3,4,5,6,7,8,9])
1052         self.assertTrue(not a.flags["OWNDATA"])
1053         self.assertTrue(not b.flags["OWNDATA"])
1054         self.assertTrue(b.base is a)
1055         del a
1056         gc.collect()
1057         self.assertEqual(b.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
1058         self.assertTrue(not b.flags["OWNDATA"])
1059         del d
1060         gc.collect()
1061         self.assertEqual(b.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
1062         self.assertTrue(not b.flags["OWNDATA"])
1063         pass
1064
1065     def setUp(self):
1066         pass
1067     pass
1068
1069 #gc.set_debug(gc.DEBUG_LEAK)
1070 unittest.main()