src/MEDCoupling_Swig/MEDCouplingNumPyTest.py

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