[Numpy-svn] r4661 - trunk/numpy/core/tests
numpy-svn at scipy.org
numpy-svn at scipy.org
Sat Dec 29 18:28:34 EST 2007
Author: stefan
Date: 2007-12-29 17:28:11 -0600 (Sat, 29 Dec 2007)
New Revision: 4661
Modified:
trunk/numpy/core/tests/test_multiarray.py
trunk/numpy/core/tests/test_regression.py
Log:
Change remaining N's to np.
Modified: trunk/numpy/core/tests/test_multiarray.py
===================================================================
--- trunk/numpy/core/tests/test_multiarray.py 2007-12-29 20:09:51 UTC (rev 4660)
+++ trunk/numpy/core/tests/test_multiarray.py 2007-12-29 23:28:11 UTC (rev 4661)
@@ -515,12 +515,12 @@
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 @@
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):
Modified: trunk/numpy/core/tests/test_regression.py
===================================================================
--- trunk/numpy/core/tests/test_regression.py 2007-12-29 20:09:51 UTC (rev 4660)
+++ trunk/numpy/core/tests/test_regression.py 2007-12-29 23:28:11 UTC (rev 4661)
@@ -10,8 +10,8 @@
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 @@
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 @@
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 @@
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 @@
"""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 @@
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 @@
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 @@
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 @@
"""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 @@
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 @@
# 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
"""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 @@
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 @@
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()
More information about the Numpy-svn
mailing list