diff options
| -rw-r--r-- | numpy/core/tests/test_multiarray.py | 6 | ||||
| -rw-r--r-- | numpy/core/tests/test_regression.py | 385 |
2 files changed, 195 insertions, 196 deletions
diff --git a/numpy/core/tests/test_multiarray.py b/numpy/core/tests/test_multiarray.py index c59fa48be..777cf2893 100644 --- a/numpy/core/tests/test_multiarray.py +++ b/numpy/core/tests/test_multiarray.py @@ -515,12 +515,12 @@ class TestFromToFile(NumpyTestCase): class TestFromBuffer(ParametricTestCase): def tst_basic(self,buffer,expected,kwargs): - assert_array_equal(N.frombuffer(buffer,**kwargs),expected) + assert_array_equal(np.frombuffer(buffer,**kwargs),expected) def testip_basic(self): tests = [] for byteorder in ['<','>']: - for dtype in [float,int,N.complex]: + for dtype in [float,int,np.complex]: dt = np.dtype(dtype).newbyteorder(byteorder) x = (np.random.random((4,7))*5).astype(dt) buf = x.tostring() @@ -531,7 +531,7 @@ class TestResize(NumpyTestCase): def test_basic(self): x = np.eye(3) x.resize((5,5)) - assert_array_equal(x.flat[:9],N.eye(3).flat) + assert_array_equal(x.flat[:9],np.eye(3).flat) assert_array_equal(x[9:].flat,0) def test_check_reference(self): diff --git a/numpy/core/tests/test_regression.py b/numpy/core/tests/test_regression.py index 0f3acd7f2..b9575bdf4 100644 --- a/numpy/core/tests/test_regression.py +++ b/numpy/core/tests/test_regression.py @@ -10,8 +10,8 @@ restore_path() rlevel = 1 def assert_valid_refcount(op): - a = N.arange(100 * 100) - b = N.arange(100*100).reshape(100, 100) + a = np.arange(100 * 100) + b = np.arange(100*100).reshape(100, 100) c = b i = 1 @@ -26,15 +26,15 @@ class TestRegression(NumpyTestCase): def check_invalid_round(self,level=rlevel): """Ticket #3""" v = 4.7599999999999998 - assert_array_equal(N.array([v]),N.array(v)) + assert_array_equal(np.array([v]),np.array(v)) def check_mem_empty(self,level=rlevel): """Ticket #7""" - np.empty((1,),dtype=[('x',N.int64)]) + np.empty((1,),dtype=[('x',np.int64)]) def check_pickle_transposed(self,level=rlevel): """Ticket #16""" - a = np.transpose(N.array([[2,9],[7,0],[3,8]])) + a = np.transpose(np.array([[2,9],[7,0],[3,8]])) f = StringIO() pickle.dump(a,f) f.seek(0) @@ -45,8 +45,7 @@ class TestRegression(NumpyTestCase): def check_masked_array_create(self,level=rlevel): """Ticket #17""" x = np.ma.masked_array([0,1,2,3,0,4,5,6],mask=[0,0,0,1,1,1,0,0]) -from data_store import load, save, create_module, create_shelf - assert_array_equal(N.ma.nonzero(x),[[1,2,6,7]]) + assert_array_equal(np.ma.nonzero(x),[[1,2,6,7]]) def check_poly1d(self,level=rlevel): """Ticket #28""" @@ -75,7 +74,7 @@ from data_store import load, save, create_module, create_shelf def check_sort_bigendian(self,level=rlevel): """Ticket #47""" a = np.linspace(0, 10, 11) - c = a.astype(N.dtype('<f8')) + c = a.astype(np.dtype('<f8')) c.sort() assert_array_almost_equal(c, a) @@ -91,7 +90,7 @@ from data_store import load, save, create_module, create_shelf """Ticket #50""" import tempfile f = StringIO() - ca = np.char.array(N.arange(1000,1010),itemsize=4) + ca = np.char.array(np.arange(1000,1010),itemsize=4) ca.dump(f) f.seek(0) ca = np.load(f) @@ -143,7 +142,7 @@ from data_store import load, save, create_module, create_shelf def check_kron_matrix(self,level=rlevel): """Ticket #71""" x = np.matrix('[1 0; 1 0]') - assert_equal(type(N.kron(x,x)),type(x)) + assert_equal(type(np.kron(x,x)),type(x)) def check_scalar_compare(self,level=rlevel): """Ticket #72""" @@ -164,7 +163,7 @@ from data_store import load, save, create_module, create_shelf def check_matrix_std_argmax(self,level=rlevel): """Ticket #83""" - x = np.asmatrix(N.random.uniform(0,1,(3,3))) + x = np.asmatrix(np.random.uniform(0,1,(3,3))) self.assertEqual(x.std().shape, ()) self.assertEqual(x.argmax().shape, ()) @@ -183,7 +182,7 @@ from data_store import load, save, create_module, create_shelf def check_mem_dtype_align(self,level=rlevel): """Ticket #93""" - self.failUnlessRaises(TypeError,N.dtype, + self.failUnlessRaises(TypeError,np.dtype, {'names':['a'],'formats':['foo']},align=1) def check_mem_digitize(self,level=rlevel): @@ -196,10 +195,10 @@ from data_store import load, save, create_module, create_shelf """Ticket #99""" i_width = np.int_(0).nbytes*2 - 1 np.intp('0x' + 'f'*i_width,16) - self.failUnlessRaises(OverflowError,N.intp,'0x' + 'f'*(i_width+1),16) - self.failUnlessRaises(ValueError,N.intp,'0x1',32) - assert_equal(255,N.intp('0xFF',16)) - assert_equal(1024,N.intp(1024)) + self.failUnlessRaises(OverflowError,np.intp,'0x' + 'f'*(i_width+1),16) + self.failUnlessRaises(ValueError,np.intp,'0x1',32) + assert_equal(255,np.intp('0xFF',16)) + assert_equal(1024,np.intp(1024)) def check_endian_bool_indexing(self,level=rlevel): """Ticket #105""" @@ -211,8 +210,8 @@ from data_store import load, save, create_module, create_shelf yb = ((b>2) & (b<6)) assert_array_almost_equal(xa,ya.nonzero()) assert_array_almost_equal(xb,yb.nonzero()) - assert(N.all(a[ya] > 0.5)) - assert(N.all(b[yb] > 0.5)) + assert(np.all(a[ya] > 0.5)) + assert(np.all(b[yb] > 0.5)) def check_mem_dot(self,level=rlevel): """Ticket #106""" @@ -233,7 +232,7 @@ from data_store import load, save, create_module, create_shelf # def check_longfloat_repr(self,level=rlevel): # """Ticket #112""" # if np.longfloat(0).itemsize > 8: -# a = np.exp(N.array([1000],dtype=N.longfloat)) +# a = np.exp(np.array([1000],dtype=np.longfloat)) # assert(str(a)[1:9] == str(a[0])[:8]) def check_argmax(self,level=rlevel): @@ -245,78 +244,78 @@ from data_store import load, save, create_module, create_shelf def check_matrix_properties(self,level=rlevel): """Ticket #125""" a = np.matrix([1.0],dtype=float) - assert(type(a.real) is N.matrix) - assert(type(a.imag) is N.matrix) - c,d = N.matrix([0.0]).nonzero() - assert(type(c) is N.matrix) - assert(type(d) is N.matrix) + assert(type(a.real) is np.matrix) + assert(type(a.imag) is np.matrix) + c,d = np.matrix([0.0]).nonzero() + assert(type(c) is np.matrix) + assert(type(d) is np.matrix) def check_mem_divmod(self,level=rlevel): """Ticket #126""" for i in range(10): - divmod(N.array([i])[0],10) + divmod(np.array([i])[0],10) def check_hstack_invalid_dims(self,level=rlevel): """Ticket #128""" - x = N.arange(9).reshape((3,3)) - y = N.array([0,0,0]) - self.failUnlessRaises(ValueError,N.hstack,(x,y)) + x = np.arange(9).reshape((3,3)) + y = np.array([0,0,0]) + self.failUnlessRaises(ValueError,np.hstack,(x,y)) def check_squeeze_type(self,level=rlevel): """Ticket #133""" - a = N.array([3]) - b = N.array(3) - assert(type(a.squeeze()) is N.ndarray) - assert(type(b.squeeze()) is N.ndarray) + a = np.array([3]) + b = np.array(3) + assert(type(a.squeeze()) is np.ndarray) + assert(type(b.squeeze()) is np.ndarray) def check_add_identity(self,level=rlevel): """Ticket #143""" - assert_equal(0,N.add.identity) + assert_equal(0,np.add.identity) def check_binary_repr_0(self,level=rlevel): """Ticket #151""" - assert_equal('0',N.binary_repr(0)) + assert_equal('0',np.binary_repr(0)) def check_rec_iterate(self,level=rlevel): """Ticket #160""" - descr = N.dtype([('i',int),('f',float),('s','|S3')]) - x = N.rec.array([(1,1.1,'1.0'), + descr = np.dtype([('i',int),('f',float),('s','|S3')]) + x = np.rec.array([(1,1.1,'1.0'), (2,2.2,'2.0')],dtype=descr) x[0].tolist() [i for i in x[0]] def check_unicode_string_comparison(self,level=rlevel): """Ticket #190""" - a = N.array('hello',N.unicode_) - b = N.array('world') + a = np.array('hello',np.unicode_) + b = np.array('world') a == b def check_tostring_FORTRANORDER_discontiguous(self,level=rlevel): """Fix in r2836""" # Create discontiguous Fortran-ordered array - x = N.array(N.random.rand(3,3),order='F')[:,:2] - assert_array_almost_equal(x.ravel(),N.fromstring(x.tostring())) + x = np.array(np.random.rand(3,3),order='F')[:,:2] + assert_array_almost_equal(x.ravel(),np.fromstring(x.tostring())) def check_flat_assignment(self,level=rlevel): """Correct behaviour of ticket #194""" - x = N.empty((3,1)) - x.flat = N.arange(3) + x = np.empty((3,1)) + x.flat = np.arange(3) assert_array_almost_equal(x,[[0],[1],[2]]) - x.flat = N.arange(3,dtype=float) + x.flat = np.arange(3,dtype=float) assert_array_almost_equal(x,[[0],[1],[2]]) def check_broadcast_flat_assignment(self,level=rlevel): """Ticket #194""" - x = N.empty((3,1)) - def bfa(): x[:] = N.arange(3) - def bfb(): x[:] = N.arange(3,dtype=float) + x = np.empty((3,1)) + def bfa(): x[:] = np.arange(3) + def bfb(): x[:] = np.arange(3,dtype=float) self.failUnlessRaises(ValueError, bfa) self.failUnlessRaises(ValueError, bfb) def check_unpickle_dtype_with_object(self,level=rlevel): """Implemented in r2840""" - dt = N.dtype([('x',int),('y',N.object_),('z','O')]) + dt = np.dtype([('x',int),('y',np.object_),('z','O')]) f = StringIO() pickle.dump(dt,f) f.seek(0) @@ -326,107 +325,107 @@ from data_store import load, save, create_module, create_shelf def check_mem_array_creation_invalid_specification(self,level=rlevel): """Ticket #196""" - dt = N.dtype([('x',int),('y',N.object_)]) + dt = np.dtype([('x',int),('y',np.object_)]) # Wrong way - self.failUnlessRaises(ValueError, N.array, [1,'object'], dt) + self.failUnlessRaises(ValueError, np.array, [1,'object'], dt) # Correct way - N.array([(1,'object')],dt) + np.array([(1,'object')],dt) def check_recarray_single_element(self,level=rlevel): """Ticket #202""" - a = N.array([1,2,3],dtype=N.int32) + a = np.array([1,2,3],dtype=np.int32) b = a.copy() - r = N.rec.array(a,shape=1,formats=['3i4'],names=['d']) + r = np.rec.array(a,shape=1,formats=['3i4'],names=['d']) assert_array_equal(a,b) assert_equal(a,r[0][0]) def check_zero_sized_array_indexing(self,level=rlevel): """Ticket #205""" - tmp = N.array([]) - def index_tmp(): tmp[N.array(10)] + tmp = np.array([]) + def index_tmp(): tmp[np.array(10)] self.failUnlessRaises(IndexError, index_tmp) def check_unique_zero_sized(self,level=rlevel): """Ticket #205""" - assert_array_equal([], N.unique(N.array([]))) + assert_array_equal([], np.unique(np.array([]))) def check_chararray_rstrip(self,level=rlevel): """Ticket #222""" - x = N.chararray((1,),5) + x = np.chararray((1,),5) x[0] = 'a ' x = x.rstrip() assert_equal(x[0], 'a') def check_object_array_shape(self,level=rlevel): """Ticket #239""" - assert_equal(N.array([[1,2],3,4],dtype=object).shape, (3,)) - assert_equal(N.array([[1,2],[3,4]],dtype=object).shape, (2,2)) - assert_equal(N.array([(1,2),(3,4)],dtype=object).shape, (2,2)) - assert_equal(N.array([],dtype=object).shape, (0,)) - assert_equal(N.array([[],[],[]],dtype=object).shape, (3,0)) - assert_equal(N.array([[3,4],[5,6],None],dtype=object).shape, (3,)) + assert_equal(np.array([[1,2],3,4],dtype=object).shape, (3,)) + assert_equal(np.array([[1,2],[3,4]],dtype=object).shape, (2,2)) + assert_equal(np.array([(1,2),(3,4)],dtype=object).shape, (2,2)) + assert_equal(np.array([],dtype=object).shape, (0,)) + assert_equal(np.array([[],[],[]],dtype=object).shape, (3,0)) + assert_equal(np.array([[3,4],[5,6],None],dtype=object).shape, (3,)) def check_mem_around(self,level=rlevel): """Ticket #243""" - x = N.zeros((1,)) + x = np.zeros((1,)) y = [0] decimal = 6 - N.around(abs(x-y),decimal) <= 10.0**(-decimal) + np.around(abs(x-y),decimal) <= 10.0**(-decimal) def check_character_array_strip(self,level=rlevel): """Ticket #246""" - x = N.char.array(("x","x ","x ")) + x = np.char.array(("x","x ","x ")) for c in x: assert_equal(c,"x") def check_lexsort(self,level=rlevel): """Lexsort memory error""" - v = N.array([1,2,3,4,5,6,7,8,9,10]) - assert_equal(N.lexsort(v),0) + v = np.array([1,2,3,4,5,6,7,8,9,10]) + assert_equal(np.lexsort(v),0) def check_pickle_dtype(self,level=rlevel): """Ticket #251""" import pickle - pickle.dumps(N.float) + pickle.dumps(np.float) def check_masked_array_multiply(self,level=rlevel): """Ticket #254""" - a = N.ma.zeros((4,1)) - a[2,0] = N.ma.masked - b = N.zeros((4,2)) + a = np.ma.zeros((4,1)) + a[2,0] = np.ma.masked + b = np.zeros((4,2)) a*b b*a def check_swap_real(self, level=rlevel): """Ticket #265""" - assert_equal(N.arange(4,dtype='>c8').imag.max(),0.0) - assert_equal(N.arange(4,dtype='<c8').imag.max(),0.0) - assert_equal(N.arange(4,dtype='>c8').real.max(),3.0) - assert_equal(N.arange(4,dtype='<c8').real.max(),3.0) + assert_equal(np.arange(4,dtype='>c8').imag.max(),0.0) + assert_equal(np.arange(4,dtype='<c8').imag.max(),0.0) + assert_equal(np.arange(4,dtype='>c8').real.max(),3.0) + assert_equal(np.arange(4,dtype='<c8').real.max(),3.0) def check_object_array_from_list(self, level=rlevel): """Ticket #270""" - a = N.array([1,'A',None]) + a = np.array([1,'A',None]) def check_masked_array_repeat(self, level=rlevel): """Ticket #271""" - N.ma.array([1],mask=False).repeat(10) + np.ma.array([1],mask=False).repeat(10) def check_multiple_assign(self, level=rlevel): """Ticket #273""" - a = N.zeros((3,1),int) + a = np.zeros((3,1),int) a[[1,2]] = 1 def check_empty_array_type(self, level=rlevel): - assert_equal(N.array([]).dtype, N.zeros(0).dtype) + assert_equal(np.array([]).dtype, np.zeros(0).dtype) def check_void_coercion(self, level=rlevel): - dt = N.dtype([('a','f4'),('b','i4')]) - x = N.zeros((1,),dt) - assert(N.r_[x,x].dtype == dt) + dt = np.dtype([('a','f4'),('b','i4')]) + x = np.zeros((1,),dt) + assert(np.r_[x,x].dtype == dt) def check_void_copyswap(self, level=rlevel): - dt = N.dtype([('one', '<i4'),('two', '<i4')]) - x = N.array((1,2), dtype=dt) + dt = np.dtype([('one', '<i4'),('two', '<i4')]) + x = np.array((1,2), dtype=dt) x = x.byteswap() assert(x['one'] > 1 and x['two'] > 2) @@ -441,7 +440,7 @@ from data_store import load, save, create_module, create_shelf funcs2 = ['compress', 'take', 'repeat'] for func in funcs1: - arr = N.random.rand(8,7) + arr = np.random.rand(8,7) arr2 = arr.copy() if isinstance(func, tuple): func_meth = func[1] @@ -449,15 +448,15 @@ from data_store import load, save, create_module, create_shelf else: func_meth = func res1 = getattr(arr, func_meth)() - res2 = getattr(N, func)(arr2) + res2 = getattr(np, func)(arr2) if res1 is None: assert abs(arr-res2).max() < 1e-8, func else: assert abs(res1-res2).max() < 1e-8, func for func in funcs2: - arr1 = N.random.rand(8,7) - arr2 = N.random.rand(8,7) + arr1 = np.random.rand(8,7) + arr2 = np.random.rand(8,7) res1 = None if func == 'compress': arr1 = arr1.ravel() @@ -466,219 +465,219 @@ from data_store import load, save, create_module, create_shelf arr2 = (15*arr2).astype(int).ravel() if res1 is None: res1 = getattr(arr1, func)(arr2) - res2 = getattr(N, func)(arr1, arr2) + res2 = getattr(np, func)(arr1, arr2) assert abs(res1-res2).max() < 1e-8, func def check_mem_lexsort_strings(self, level=rlevel): """Ticket #298""" lst = ['abc','cde','fgh'] - N.lexsort((lst,)) + np.lexsort((lst,)) def check_fancy_index(self, level=rlevel): """Ticket #302""" - x = N.array([1,2])[N.array([0])] + x = np.array([1,2])[np.array([0])] assert_equal(x.shape,(1,)) def check_recarray_copy(self, level=rlevel): """Ticket #312""" - dt = [('x',N.int16),('y',N.float64)] - ra = N.array([(1,2.3)], dtype=dt) - rb = N.rec.array(ra, dtype=dt) + dt = [('x',np.int16),('y',np.float64)] + ra = np.array([(1,2.3)], dtype=dt) + rb = np.rec.array(ra, dtype=dt) rb['x'] = 2. assert ra['x'] != rb['x'] def check_rec_fromarray(self, level=rlevel): """Ticket #322""" - x1 = N.array([[1,2],[3,4],[5,6]]) - x2 = N.array(['a','dd','xyz']) - x3 = N.array([1.1,2,3]) - N.rec.fromarrays([x1,x2,x3], formats="(2,)i4,a3,f8") + x1 = np.array([[1,2],[3,4],[5,6]]) + x2 = np.array(['a','dd','xyz']) + x3 = np.array([1.1,2,3]) + np.rec.fromarrays([x1,x2,x3], formats="(2,)i4,a3,f8") def check_object_array_assign(self, level=rlevel): - x = N.empty((2,2),object) + x = np.empty((2,2),object) x.flat[2] = (1,2,3) assert_equal(x.flat[2],(1,2,3)) def check_ndmin_float64(self, level=rlevel): """Ticket #324""" - x = N.array([1,2,3],dtype=N.float64) - assert_equal(N.array(x,dtype=N.float32,ndmin=2).ndim,2) - assert_equal(N.array(x,dtype=N.float64,ndmin=2).ndim,2) + x = np.array([1,2,3],dtype=np.float64) + assert_equal(np.array(x,dtype=np.float32,ndmin=2).ndim,2) + assert_equal(np.array(x,dtype=np.float64,ndmin=2).ndim,2) def check_mem_vectorise(self, level=rlevel): """Ticket #325""" - vt = N.vectorize(lambda *args: args) - vt(N.zeros((1,2,1)), N.zeros((2,1,1)), N.zeros((1,1,2))) - vt(N.zeros((1,2,1)), N.zeros((2,1,1)), N.zeros((1,1,2)), N.zeros((2,2))) + vt = np.vectorize(lambda *args: args) + vt(np.zeros((1,2,1)), np.zeros((2,1,1)), np.zeros((1,1,2))) + vt(np.zeros((1,2,1)), np.zeros((2,1,1)), np.zeros((1,1,2)), np.zeros((2,2))) def check_mem_axis_minimization(self, level=rlevel): """Ticket #327""" - data = N.arange(5) - data = N.add.outer(data,data) + data = np.arange(5) + data = np.add.outer(data,data) def check_mem_float_imag(self, level=rlevel): """Ticket #330""" - N.float64(1.0).imag + np.float64(1.0).imag def check_dtype_tuple(self, level=rlevel): """Ticket #334""" - assert N.dtype('i4') == N.dtype(('i4',())) + assert np.dtype('i4') == np.dtype(('i4',())) def check_dtype_posttuple(self, level=rlevel): """Ticket #335""" - N.dtype([('col1', '()i4')]) + np.dtype([('col1', '()i4')]) def check_mgrid_single_element(self, level=rlevel): """Ticket #339""" - assert_array_equal(N.mgrid[0:0:1j],[0]) - assert_array_equal(N.mgrid[0:0],[]) + assert_array_equal(np.mgrid[0:0:1j],[0]) + assert_array_equal(np.mgrid[0:0],[]) def check_numeric_carray_compare(self, level=rlevel): """Ticket #341""" - assert_equal(N.array([ 'X' ], 'c'),'X') + assert_equal(np.array([ 'X' ], 'c'),'X') def check_string_array_size(self, level=rlevel): """Ticket #342""" self.failUnlessRaises(ValueError, - N.array,[['X'],['X','X','X']],'|S1') + np.array,[['X'],['X','X','X']],'|S1') def check_dtype_repr(self, level=rlevel): """Ticket #344""" - dt1=N.dtype(('uint32', 2)) - dt2=N.dtype(('uint32', (2,))) + dt1=np.dtype(('uint32', 2)) + dt2=np.dtype(('uint32', (2,))) assert_equal(dt1.__repr__(), dt2.__repr__()) def check_reshape_order(self, level=rlevel): """Make sure reshape order works.""" - a = N.arange(6).reshape(2,3,order='F') + a = np.arange(6).reshape(2,3,order='F') assert_equal(a,[[0,2,4],[1,3,5]]) - a = N.array([[1,2],[3,4],[5,6],[7,8]]) + a = np.array([[1,2],[3,4],[5,6],[7,8]]) b = a[:,1] assert_equal(b.reshape(2,2,order='F'), [[2,6],[4,8]]) def check_repeat_discont(self, level=rlevel): """Ticket #352""" - a = N.arange(12).reshape(4,3)[:,2] + a = np.arange(12).reshape(4,3)[:,2] assert_equal(a.repeat(3), [2,2,2,5,5,5,8,8,8,11,11,11]) def check_array_index(self, level=rlevel): """Make sure optimization is not called in this case.""" - a = N.array([1,2,3]) - a2 = N.array([[1,2,3]]) - assert_equal(a[N.where(a==3)], a2[N.where(a2==3)]) + a = np.array([1,2,3]) + a2 = np.array([[1,2,3]]) + assert_equal(a[np.where(a==3)], a2[np.where(a2==3)]) def check_object_argmax(self, level=rlevel): - a = N.array([1,2,3],dtype=object) + a = np.array([1,2,3],dtype=object) assert a.argmax() == 2 def check_recarray_fields(self, level=rlevel): """Ticket #372""" - dt0 = N.dtype([('f0','i4'),('f1','i4')]) - dt1 = N.dtype([('f0','i8'),('f1','i8')]) - for a in [N.array([(1,2),(3,4)],"i4,i4"), - N.rec.array([(1,2),(3,4)],"i4,i4"), - N.rec.array([(1,2),(3,4)]), - N.rec.fromarrays([(1,2),(3,4)],"i4,i4"), - N.rec.fromarrays([(1,2),(3,4)])]: + dt0 = np.dtype([('f0','i4'),('f1','i4')]) + dt1 = np.dtype([('f0','i8'),('f1','i8')]) + for a in [np.array([(1,2),(3,4)],"i4,i4"), + np.rec.array([(1,2),(3,4)],"i4,i4"), + np.rec.array([(1,2),(3,4)]), + np.rec.fromarrays([(1,2),(3,4)],"i4,i4"), + np.rec.fromarrays([(1,2),(3,4)])]: assert(a.dtype in [dt0,dt1]) def check_random_shuffle(self, level=rlevel): """Ticket #374""" - a = N.arange(5).reshape((5,1)) + a = np.arange(5).reshape((5,1)) b = a.copy() - N.random.shuffle(b) - assert_equal(N.sort(b, axis=0),a) + np.random.shuffle(b) + assert_equal(np.sort(b, axis=0),a) def check_refcount_vectorize(self, level=rlevel): """Ticket #378""" def p(x,y): return 123 - v = N.vectorize(p) + v = np.vectorize(p) assert_valid_refcount(v) def check_poly1d_nan_roots(self, level=rlevel): """Ticket #396""" - p = N.poly1d([N.nan,N.nan,1], r=0) - self.failUnlessRaises(N.linalg.LinAlgError,getattr,p,"r") + p = np.poly1d([np.nan,np.nan,1], r=0) + self.failUnlessRaises(np.linalg.LinAlgError,getattr,p,"r") def check_refcount_vdot(self, level=rlevel): """Changeset #3443""" - assert_valid_refcount(N.vdot) + assert_valid_refcount(np.vdot) def check_startswith(self, level=rlevel): - ca = N.char.array(['Hi','There']) + ca = np.char.array(['Hi','There']) assert_equal(ca.startswith('H'),[True,False]) def check_noncommutative_reduce_accumulate(self, level=rlevel): """Ticket #413""" - tosubtract = N.arange(5) - todivide = N.array([2.0, 0.5, 0.25]) - assert_equal(N.subtract.reduce(tosubtract), -10) - assert_equal(N.divide.reduce(todivide), 16.0) - assert_array_equal(N.subtract.accumulate(tosubtract), - N.array([0, -1, -3, -6, -10])) - assert_array_equal(N.divide.accumulate(todivide), - N.array([2., 4., 16.])) + tosubtract = np.arange(5) + todivide = np.array([2.0, 0.5, 0.25]) + assert_equal(np.subtract.reduce(tosubtract), -10) + assert_equal(np.divide.reduce(todivide), 16.0) + assert_array_equal(np.subtract.accumulate(tosubtract), + np.array([0, -1, -3, -6, -10])) + assert_array_equal(np.divide.accumulate(todivide), + np.array([2., 4., 16.])) def check_mem_polymul(self, level=rlevel): """Ticket #448""" - N.polymul([],[1.]) + np.polymul([],[1.]) def check_convolve_empty(self, level=rlevel): """Convolve should raise an error for empty input array.""" - self.failUnlessRaises(AssertionError,N.convolve,[],[1]) - self.failUnlessRaises(AssertionError,N.convolve,[1],[]) + self.failUnlessRaises(AssertionError,np.convolve,[],[1]) + self.failUnlessRaises(AssertionError,np.convolve,[1],[]) def check_multidim_byteswap(self, level=rlevel): """Ticket #449""" - r=N.array([(1,(0,1,2))], dtype="i2,3i2") + r=np.array([(1,(0,1,2))], dtype="i2,3i2") assert_array_equal(r.byteswap(), - N.array([(256,(0,256,512))],r.dtype)) + np.array([(256,(0,256,512))],r.dtype)) def check_string_NULL(self, level=rlevel): """Changeset 3557""" - assert_equal(N.array("a\x00\x0b\x0c\x00").item(), + assert_equal(np.array("a\x00\x0b\x0c\x00").item(), 'a\x00\x0b\x0c') def check_mem_string_concat(self, level=rlevel): """Ticket #469""" - x = N.array([]) - N.append(x,'asdasd\tasdasd') + x = np.array([]) + np.append(x,'asdasd\tasdasd') def check_matrix_multiply_by_1d_vector(self, level=rlevel) : """Ticket #473""" def mul() : - N.mat(N.eye(2))*N.ones(2) + np.mat(np.eye(2))*np.ones(2) self.failUnlessRaises(ValueError,mul) def check_junk_in_string_fields_of_recarray(self, level=rlevel): """Ticket #483""" - r = N.array([['abc']], dtype=[('var1', '|S20')]) + r = np.array([['abc']], dtype=[('var1', '|S20')]) assert str(r['var1'][0][0]) == 'abc' def check_take_output(self, level=rlevel): """Ensure that 'take' honours output parameter.""" - x = N.arange(12).reshape((3,4)) - a = N.take(x,[0,2],axis=1) - b = N.zeros_like(a) - N.take(x,[0,2],axis=1,out=b) + x = np.arange(12).reshape((3,4)) + a = np.take(x,[0,2],axis=1) + b = np.zeros_like(a) + np.take(x,[0,2],axis=1,out=b) assert_array_equal(a,b) def check_array_str_64bit(self, level=rlevel): """Ticket #501""" - s = N.array([1, N.nan],dtype=N.float64) - errstate = N.seterr(all='raise') + s = np.array([1, np.nan],dtype=np.float64) + errstate = np.seterr(all='raise') try: - sstr = N.array_str(s) + sstr = np.array_str(s) finally: - N.seterr(**errstate) + np.seterr(**errstate) def check_frompyfunc_endian(self, level=rlevel): """Ticket #503""" from math import radians - uradians = N.frompyfunc(radians, 1, 1) - big_endian = N.array([83.4, 83.5], dtype='>f8') - little_endian = N.array([83.4, 83.5], dtype='<f8') + uradians = np.frompyfunc(radians, 1, 1) + big_endian = np.array([83.4, 83.5], dtype='>f8') + little_endian = np.array([83.4, 83.5], dtype='<f8') assert_almost_equal(uradians(big_endian).astype(float), uradians(little_endian).astype(float)) @@ -686,21 +685,21 @@ from data_store import load, save, create_module, create_shelf """Ticket #514""" s = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" t = [] - N.hstack((t, s )) + np.hstack((t, s )) def check_arr_transpose(self, level=rlevel): """Ticket #516""" - x = N.random.rand(*(2,)*16) + x = np.random.rand(*(2,)*16) y = x.transpose(range(16)) def check_string_mergesort(self, level=rlevel): """Ticket #540""" - x = N.array(['a']*32) - assert_array_equal(x.argsort(kind='m'), N.arange(32)) + x = np.array(['a']*32) + assert_array_equal(x.argsort(kind='m'), np.arange(32)) def check_argmax_byteorder(self, level=rlevel): """Ticket #546""" - a = N.arange(3, dtype='>f') + a = np.arange(3, dtype='>f') assert a[a.argmax()] == a.max() def check_numeric_random(self, level=rlevel): @@ -710,41 +709,41 @@ from data_store import load, save, create_module, create_shelf def check_poly_div(self, level=rlevel): """Ticket #553""" - u = N.poly1d([1,2,3]) - v = N.poly1d([1,2,3,4,5]) - q,r = N.polydiv(u,v) + u = np.poly1d([1,2,3]) + v = np.poly1d([1,2,3,4,5]) + q,r = np.polydiv(u,v) assert_equal(q*v + r, u) def check_poly_eq(self, level=rlevel): """Ticket #554""" - x = N.poly1d([1,2,3]) - y = N.poly1d([3,4]) + x = np.poly1d([1,2,3]) + y = np.poly1d([3,4]) assert x != y assert x == x def check_mem_insert(self, level=rlevel): """Ticket #572""" - N.lib.place(1,1,1) + np.lib.place(1,1,1) def check_dot_negative_stride(self, level=rlevel): """Ticket #588""" - x = N.array([[1,5,25,125.,625]]) - y = N.array([[20.],[160.],[640.],[1280.],[1024.]]) + x = np.array([[1,5,25,125.,625]]) + y = np.array([[20.],[160.],[640.],[1280.],[1024.]]) z = y[::-1].copy() y2 = y[::-1] - assert_equal(N.dot(x,z),N.dot(x,y2)) + assert_equal(np.dot(x,z),np.dot(x,y2)) def check_object_casting(self, level=rlevel): def rs(): - x = N.ones([484,286]) - y = N.zeros([484,286]) + x = np.ones([484,286]) + y = np.zeros([484,286]) x |= y self.failUnlessRaises(TypeError,rs) def check_unicode_scalar(self, level=rlevel): """Ticket #600""" import cPickle - x = N.array(["DROND", "DROND1"], dtype="U6") + x = np.array(["DROND", "DROND1"], dtype="U6") el = x[1] new = cPickle.loads(cPickle.dumps(el)) assert_equal(new, el) @@ -752,25 +751,25 @@ from data_store import load, save, create_module, create_shelf def check_arange_non_native_dtype(self, level=rlevel): """Ticket #616""" for T in ('>f4','<f4'): - dt = N.dtype(T) - assert_equal(N.arange(0,dtype=dt).dtype,dt) - assert_equal(N.arange(0.5,dtype=dt).dtype,dt) - assert_equal(N.arange(5,dtype=dt).dtype,dt) + dt = np.dtype(T) + assert_equal(np.arange(0,dtype=dt).dtype,dt) + assert_equal(np.arange(0.5,dtype=dt).dtype,dt) + assert_equal(np.arange(5,dtype=dt).dtype,dt) def check_bool_indexing_invalid_nr_elements(self, level=rlevel): - s = N.ones(10,dtype=float) - x = N.array((15,),dtype=float) + s = np.ones(10,dtype=float) + x = np.array((15,),dtype=float) def ia(x,s): x[(s>0)]=1.0 self.failUnlessRaises(ValueError,ia,x,s) def check_mem_scalar_indexing(self, level=rlevel): """Ticket #603""" - x = N.array([0],dtype=float) - index = N.array(0,dtype=N.int32) + x = np.array([0],dtype=float) + index = np.array(0,dtype=np.int32) x[index] def check_binary_repr_0_width(self, level=rlevel): - assert_equal(N.binary_repr(0,width=3),'000') + assert_equal(np.binary_repr(0,width=3),'000') if __name__ == "__main__": NumpyTest().run() |