src/MEDCoupling_Swig/MEDCouplingNumPyTest.py

   1 #  -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2020  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=DataArrayInt32(a)
  50         d[:]=2
  51         #
  52         e=DataArrayInt32(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=DataArrayInt32(b)
  70         #
  71         e=DataArrayInt32(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=DataArrayInt32(b)
  85         self.assertTrue(d.isEqual(DataArrayInt32([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=DataArrayInt32(a)
  93         self.assertTrue(d.isEqual(DataArrayInt32([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=DataArrayInt32(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(DataArrayInt32(a).isUniform(4))
 120         pass
 121
 122     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 123     def test6(self):
 124         a=arange(20,dtype=int32)
 125         d=DataArrayInt32(a) # d owns data of a
 126         e=DataArrayInt32(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=DataArrayInt32(b) # d owns data of a
 146         e=DataArrayInt32(b) # a not owned -> e only an access to chunk of a
 147         f=DataArrayInt32(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=DataArrayInt32(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(DataArrayInt32([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=DataArrayInt32(a)
 398         self.assertEqual(10,d.getNumberOfTuples())
 399         self.assertEqual(2,d.getNumberOfComponents())
 400         self.assertEqual(sz,d.getNbOfElems())
 401         self.assertTrue(d.isEqual(DataArrayInt32([(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(DataArrayInt32([(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         DataArrayInt32(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=DataArrayInt32(a)
 568         c=DataArrayInt32(a)
 569         d=DataArrayInt32(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=DataArrayInt32(a)
 588         c=DataArrayInt32(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,(3*MEDCouplingSizeOfIDs()//8,MEDCouplingSizeOfIDs()//8))
 648         self.assertEqual(a.nbytes,15*MEDCouplingSizeOfIDs()//8)
 649         self.assertEqual(a.itemsize,MEDCouplingSizeOfIDs()//8)
 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     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
1066     def test41(self):
1067         """ This non regression test is focused on a numpy subarray of a bigger numpy array. Typically a 1D array coming from a 2D array. When medcoupling takes the ownership, medcoupling must store an offset to deallocate correctly the pointer. The pointer of medcoupling array is NOT the pointer to be transmited to free. The offset is typically the distance between the start of the main 2D array and the start of 1D array medcouplingized."""
1068         import numpy as np
1069         array = np.array([[1,2,3,10],[4,5,6,20],[7,8,9,30]],dtype=np.float64) # create a 2D array
1070         b = array[2] # b data pointer starts at array+2*4*sizeof(float64) so offset is expected to be equal to -2*4*sizeof(float64)=-64
1071         self.assertTrue(array.flags["OWNDATA"])
1072         self.assertTrue(not b.flags["OWNDATA"])
1073         d=DataArrayDouble(b)
1074         self.assertTrue(not array.flags["OWNDATA"])
1075         self.assertTrue(not b.flags["OWNDATA"])
1076         del b ; gc.collect()
1077         del array ; gc.collect()
1078         del d ; gc.collect() # important : destroy d after b and array to be sure to let the ownership to d.
1079         pass
1080
1081     def setUp(self):
1082         pass
1083     pass
1084
1085 #gc.set_debug(gc.DEBUG_LEAK)
1086 unittest.main()