src/MEDCoupling_Swig/MEDCouplingNumPyTest.py

   1 #  -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2024  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         DataArrayFloat.New( ravel(b) )
 827         pass
 828
 829     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 830     def test33(self):
 831         """Same as test13 with float32"""
 832         a=arange(20,dtype=float32)
 833         self.assertEqual(weakref.getweakrefcount(a),0)
 834         d=DataArrayFloat(a)
 835         self.assertEqual(weakref.getweakrefcount(a),1)
 836         self.assertTrue(not a.flags["OWNDATA"])
 837         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))
 838         self.assertEqual(len(d),20)
 839         a[:]=2 # modifying a and d because a and d share the same chunk of data
 840         self.assertTrue(d.isUniform(2,1e-7))
 841         del d # d is destroyed, a retrieves its ownership of its initial chunk of data
 842         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 843         import gc
 844         gc.collect()
 845         self.assertTrue(a.flags["OWNDATA"])
 846         a[:]=4 # a can be used has usual
 847         self.assertTrue(DataArrayFloat(a).isUniform(4,1e-7))
 848         pass
 849
 850     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 851     def test34(self):
 852         """Same as test14 with float32"""
 853         a=arange(20,dtype=float32)
 854         d=DataArrayFloat(a) # d owns data of a
 855         e=DataArrayFloat(a) # a not owned -> e only an access to chunk of a
 856         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))
 857         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))
 858         a[:]=6
 859         self.assertTrue(d.isUniform(6,1e-7))
 860         self.assertTrue(e.isUniform(6,1e-7))
 861         del a # a destroyed -> d no change because owned and e array is has no more data set
 862         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 863         import gc
 864         gc.collect()
 865         self.assertTrue(d.isUniform(6,1e-7))
 866         self.assertTrue(not e.isAllocated())
 867         pass
 868
 869     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 870     def test35(self):
 871         """Same as test15 with float32"""
 872         a=array(0,dtype=float32) ; a.resize(10,2)
 873         b=a.reshape(20)
 874         c=a.reshape(2,10)
 875         d=DataArrayFloat(b) # d owns data of a
 876         e=DataArrayFloat(b) # a not owned -> e only an access to chunk of a
 877         f=DataArrayFloat(b) # a not owned -> e only an access to chunk of a
 878         del d # d removed -> a ownes again data
 879         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 880         import gc
 881         gc.collect()
 882         self.assertTrue(e.isUniform(0,1e-7))
 883         e[:]=6
 884         self.assertTrue(e.isUniform(6,1e-7))
 885         self.assertTrue(f.isUniform(6,1e-7))
 886         self.assertEqual(b.tolist(),[6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6])
 887         self.assertEqual(a.tolist(),[[6,6],[6,6],[6,6],[6,6],[6,6],[6,6],[6,6],[6,6],[6,6],[6,6]])
 888         b[:]=arange(20)
 889         del b # no impact on e and f because a is the base of a.
 890         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 891         gc.collect()
 892         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))
 893         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))
 894         del a # a destroyed, but as c has its base set to a, a exists -> e and f not allocated
 895         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 896         gc.collect()
 897         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))
 898         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))
 899         del c # c killed -> a killed -> e and d are put into not allocated state
 900         ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
 901         gc.collect()
 902         self.assertTrue(not e.isAllocated())
 903         self.assertTrue(not f.isAllocated())
 904         pass
 905
 906     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 907     def test36(self):
 908         """Same as test16 with float32"""
 909         a=arange(20,dtype=float32)
 910         self.assertTrue(a.flags["OWNDATA"])
 911         d=DataArrayFloat(a) # d owns data of a
 912         self.assertTrue(not a.flags["OWNDATA"])
 913         d.pushBackSilent(20)# d pushBack so release of chunk of data -> a becomes owner of its data again
 914         self.assertTrue(a.flags["OWNDATA"])
 915         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))
 916         self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19])
 917         pass
 918
 919     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 920     def test37(self):
 921         """Same as test20 with float32"""
 922         sz=20
 923         a=array(0,dtype=float32)
 924         a.resize(sz//2,2)
 925         a[:]=4
 926         self.assertEqual(getrefcount(a),2)
 927         d=DataArrayFloat(a)
 928         self.assertEqual(10,d.getNumberOfTuples())
 929         self.assertEqual(2,d.getNumberOfComponents())
 930         self.assertEqual(sz,d.getNbOfElems())
 931         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))
 932         a[:]=7
 933         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))
 934         #
 935         b=a.reshape((2,5,2))
 936         self.assertRaises(InterpKernelException,DataArrayFloat.New,b) # b has not dimension in [0,1] !
 937         pass
 938
 939     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 940     def test38(self):
 941         """Same as test22 with float32"""
 942         d=DataArrayFloat(10)
 943         d.iota()
 944         a=d.toNumPyArray()
 945         self.assertTrue(not a.flags["OWNDATA"])
 946         del d
 947         gc.collect()
 948         self.assertTrue(a.flags["OWNDATA"])
 949         self.assertEqual(a.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 950         #
 951         d=DataArrayInt(10)
 952         d.iota()
 953         a=d.toNumPyArray()
 954         self.assertTrue(not a.flags["OWNDATA"])
 955         del d
 956         gc.collect()
 957         self.assertTrue(a.flags["OWNDATA"])
 958         self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9])
 959         pass
 960
 961     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
 962     def test39(self):
 963         """Same as test23 with float32"""
 964         d=DataArrayFloat(10)
 965         d.iota()
 966         a=d.toNumPyArray()
 967         b=d.toNumPyArray()
 968         c=d.toNumPyArray()
 969         self.assertTrue(not a.flags["OWNDATA"])
 970         self.assertTrue(not b.flags["OWNDATA"])
 971         self.assertTrue(not c.flags["OWNDATA"])
 972         self.assertEqual(a.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 973         self.assertEqual(b.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 974         self.assertEqual(c.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 975         del d
 976         gc.collect()
 977         self.assertTrue(a.flags["OWNDATA"])
 978         self.assertTrue(not b.flags["OWNDATA"])
 979         self.assertTrue(not c.flags["OWNDATA"])
 980         self.assertEqual(a.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 981         self.assertEqual(b.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 982         self.assertEqual(c.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
 983         #
 984         d=DataArrayInt(10)
 985         d.iota()
 986         a=d.toNumPyArray()
 987         b=d.toNumPyArray()
 988         c=d.toNumPyArray()
 989         self.assertTrue(not a.flags["OWNDATA"])
 990         self.assertTrue(not b.flags["OWNDATA"])
 991         self.assertTrue(not c.flags["OWNDATA"])
 992         self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9])
 993         self.assertEqual(b.tolist(),[0,1,2,3,4,5,6,7,8,9])
 994         self.assertEqual(c.tolist(),[0,1,2,3,4,5,6,7,8,9])
 995         del d
 996         gc.collect()
 997         self.assertTrue(a.flags["OWNDATA"])
 998         self.assertTrue(not b.flags["OWNDATA"])
 999         self.assertTrue(not c.flags["OWNDATA"])
1000         self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9])
1001         self.assertEqual(b.tolist(),[0,1,2,3,4,5,6,7,8,9])
1002         self.assertEqual(c.tolist(),[0,1,2,3,4,5,6,7,8,9])
1003         pass
1004
1005     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
1006     def test40(self):
1007         """Same as test24 with float32"""
1008         d=DataArrayFloat(10)
1009         d.iota()
1010         a=d.toNumPyArray()
1011         self.assertEqual(a.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
1012         self.assertTrue(not a.flags["OWNDATA"])
1013         self.assertTrue(a.base is None)
1014         del a
1015         gc.collect()
1016         a=d.toNumPyArray()
1017         self.assertEqual(a.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
1018         self.assertTrue(not a.flags["OWNDATA"])
1019         self.assertTrue(a.base is None)
1020         b=d.toNumPyArray()
1021         self.assertEqual(a.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
1022         self.assertEqual(b.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
1023         self.assertTrue(not a.flags["OWNDATA"])
1024         self.assertTrue(not b.flags["OWNDATA"])
1025         self.assertTrue(b.base is a)
1026         del a
1027         gc.collect()
1028         self.assertEqual(b.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
1029         self.assertTrue(not b.flags["OWNDATA"])
1030         del d
1031         gc.collect()
1032         self.assertEqual(b.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
1033         self.assertTrue(not b.flags["OWNDATA"])
1034         #
1035         d=DataArrayInt(10)
1036         d.iota()
1037         a=d.toNumPyArray()
1038         self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9])
1039         self.assertTrue(not a.flags["OWNDATA"])
1040         self.assertTrue(a.base is None)
1041         del a
1042         gc.collect()
1043         a=d.toNumPyArray()
1044         self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9])
1045         self.assertTrue(not a.flags["OWNDATA"])
1046         self.assertTrue(a.base is None)
1047         b=d.toNumPyArray()
1048         self.assertEqual(a.tolist(),[0,1,2,3,4,5,6,7,8,9])
1049         self.assertEqual(b.tolist(),[0,1,2,3,4,5,6,7,8,9])
1050         self.assertTrue(not a.flags["OWNDATA"])
1051         self.assertTrue(not b.flags["OWNDATA"])
1052         self.assertTrue(b.base is a)
1053         del a
1054         gc.collect()
1055         self.assertEqual(b.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
1056         self.assertTrue(not b.flags["OWNDATA"])
1057         del d
1058         gc.collect()
1059         self.assertEqual(b.tolist(),[0.,1.,2.,3.,4.,5.,6.,7.,8.,9.])
1060         self.assertTrue(not b.flags["OWNDATA"])
1061         pass
1062
1063     @unittest.skipUnless(MEDCouplingHasNumPyBindings(),"requires numpy")
1064     def test41(self):
1065         """ 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."""
1066         import numpy as np
1067         array = np.array([[1,2,3,10],[4,5,6,20],[7,8,9,30]],dtype=np.float64) # create a 2D array
1068         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
1069         self.assertTrue(array.flags["OWNDATA"])
1070         self.assertTrue(not b.flags["OWNDATA"])
1071         d=DataArrayDouble(b)
1072         self.assertTrue(not array.flags["OWNDATA"])
1073         self.assertTrue(not b.flags["OWNDATA"])
1074         del b ; gc.collect()
1075         del array ; gc.collect()
1076         del d ; gc.collect() # important : destroy d after b and array to be sure to let the ownership to d.
1077         pass
1078
1079     def setUp(self):
1080         pass
1081     pass
1082
1083 #gc.set_debug(gc.DEBUG_LEAK)
1084 unittest.main()