Viewing file: test_numeric.py (30.05 KB) -rw-r--r-- Select action/file-type: (+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) |
import sys from decimal import Decimal
import numpy as np from numpy.core import * from numpy.random import rand, randint, randn from numpy.testing import * from numpy.core.multiarray import dot as dot_
class Vec: def __init__(self,sequence=None): if sequence is None: sequence=[] self.array=array(sequence) def __add__(self,other): out=Vec() out.array=self.array+other.array return out def __sub__(self,other): out=Vec() out.array=self.array-other.array return out def __mul__(self,other): # with scalar out=Vec(self.array.copy()) out.array*=other return out def __rmul__(self,other): return self*other
class TestDot(TestCase): def setUp(self): self.A = rand(10,8) self.b1 = rand(8,1) self.b2 = rand(8) self.b3 = rand(1,8) self.b4 = rand(10) self.N = 14
def test_matmat(self): A = self.A c1 = dot(A.transpose(), A) c2 = dot_(A.transpose(), A) assert_almost_equal(c1, c2, decimal=self.N)
def test_matvec(self): A, b1 = self.A, self.b1 c1 = dot(A, b1) c2 = dot_(A, b1) assert_almost_equal(c1, c2, decimal=self.N)
def test_matvec2(self): A, b2 = self.A, self.b2 c1 = dot(A, b2) c2 = dot_(A, b2) assert_almost_equal(c1, c2, decimal=self.N)
def test_vecmat(self): A, b4 = self.A, self.b4 c1 = dot(b4, A) c2 = dot_(b4, A) assert_almost_equal(c1, c2, decimal=self.N)
def test_vecmat2(self): b3, A = self.b3, self.A c1 = dot(b3, A.transpose()) c2 = dot_(b3, A.transpose()) assert_almost_equal(c1, c2, decimal=self.N)
def test_vecmat3(self): A, b4 = self.A, self.b4 c1 = dot(A.transpose(),b4) c2 = dot_(A.transpose(),b4) assert_almost_equal(c1, c2, decimal=self.N)
def test_vecvecouter(self): b1, b3 = self.b1, self.b3 c1 = dot(b1, b3) c2 = dot_(b1, b3) assert_almost_equal(c1, c2, decimal=self.N)
def test_vecvecinner(self): b1, b3 = self.b1, self.b3 c1 = dot(b3, b1) c2 = dot_(b3, b1) assert_almost_equal(c1, c2, decimal=self.N)
def test_columnvect1(self): b1 = ones((3,1)) b2 = [5.3] c1 = dot(b1,b2) c2 = dot_(b1,b2) assert_almost_equal(c1, c2, decimal=self.N)
def test_columnvect2(self): b1 = ones((3,1)).transpose() b2 = [6.2] c1 = dot(b2,b1) c2 = dot_(b2,b1) assert_almost_equal(c1, c2, decimal=self.N)
def test_vecscalar(self): b1 = rand(1,1) b2 = rand(1,8) c1 = dot(b1,b2) c2 = dot_(b1,b2) assert_almost_equal(c1, c2, decimal=self.N)
def test_vecscalar2(self): b1 = rand(8,1) b2 = rand(1,1) c1 = dot(b1,b2) c2 = dot_(b1,b2) assert_almost_equal(c1, c2, decimal=self.N)
def test_all(self): dims = [(),(1,),(1,1)] for dim1 in dims: for dim2 in dims: arg1 = rand(*dim1) arg2 = rand(*dim2) c1 = dot(arg1, arg2) c2 = dot_(arg1, arg2) assert (c1.shape == c2.shape) assert_almost_equal(c1, c2, decimal=self.N)
def test_vecobject(self): U_non_cont = transpose([[1.,1.],[1.,2.]]) U_cont = ascontiguousarray(U_non_cont) x = array([Vec([1.,0.]),Vec([0.,1.])]) zeros = array([Vec([0.,0.]),Vec([0.,0.])]) zeros_test = dot(U_cont,x) - dot(U_non_cont,x) assert_equal(zeros[0].array, zeros_test[0].array) assert_equal(zeros[1].array, zeros_test[1].array)
class TestResize(TestCase): def test_copies(self): A = array([[1,2],[3,4]]) Ar1 = array([[1,2,3,4],[1,2,3,4]]) assert_equal(resize(A, (2,4)), Ar1)
Ar2 = array([[1,2],[3,4],[1,2],[3,4]]) assert_equal(resize(A, (4,2)), Ar2)
Ar3 = array([[1,2,3],[4,1,2],[3,4,1],[2,3,4]]) assert_equal(resize(A, (4,3)), Ar3)
def test_zeroresize(self): A = array([[1,2],[3,4]]) Ar = resize(A, (0,)) assert_equal(Ar, array([]))
class TestNonarrayArgs(TestCase): # check that non-array arguments to functions wrap them in arrays def test_squeeze(self): A = [[[1,1,1],[2,2,2],[3,3,3]]] assert squeeze(A).shape == (3,3)
def test_cumproduct(self): A = [[1,2,3],[4,5,6]] assert all(cumproduct(A) == array([1,2,6,24,120,720]))
def test_size(self): A = [[1,2,3],[4,5,6]] assert size(A) == 6 assert size(A,0) == 2 assert size(A,1) == 3
def test_mean(self): A = [[1,2,3],[4,5,6]] assert mean(A) == 3.5 assert all(mean(A,0) == array([2.5,3.5,4.5])) assert all(mean(A,1) == array([2.,5.]))
def test_std(self): A = [[1,2,3],[4,5,6]] assert_almost_equal(std(A), 1.707825127659933) assert_almost_equal(std(A,0), array([1.5, 1.5, 1.5])) assert_almost_equal(std(A,1), array([0.81649658, 0.81649658]))
def test_var(self): A = [[1,2,3],[4,5,6]] assert_almost_equal(var(A), 2.9166666666666665) assert_almost_equal(var(A,0), array([2.25, 2.25, 2.25])) assert_almost_equal(var(A,1), array([0.66666667, 0.66666667]))
class TestBoolScalar(TestCase): def test_logical(self): f = False_ t = True_ s = "xyz" self.failUnless((t and s) is s) self.failUnless((f and s) is f)
def test_bitwise_or(self): f = False_ t = True_ self.failUnless((t | t) is t) self.failUnless((f | t) is t) self.failUnless((t | f) is t) self.failUnless((f | f) is f)
def test_bitwise_and(self): f = False_ t = True_ self.failUnless((t & t) is t) self.failUnless((f & t) is f) self.failUnless((t & f) is f) self.failUnless((f & f) is f)
def test_bitwise_xor(self): f = False_ t = True_ self.failUnless((t ^ t) is f) self.failUnless((f ^ t) is t) self.failUnless((t ^ f) is t) self.failUnless((f ^ f) is f)
class TestSeterr(TestCase): def test_set(self): err = seterr() old = seterr(divide='warn') self.failUnless(err == old) new = seterr() self.failUnless(new['divide'] == 'warn') seterr(over='raise') self.failUnless(geterr()['over'] == 'raise') self.failUnless(new['divide'] == 'warn') seterr(**old) self.failUnless(geterr() == old)
def test_divide_err(self): seterr(divide='raise') try: array([1.]) / array([0.]) except FloatingPointError: pass else: self.fail() seterr(divide='ignore') array([1.]) / array([0.])
class TestFromiter(TestCase): def makegen(self): for x in xrange(24): yield x**2
def test_types(self): ai32 = fromiter(self.makegen(), int32) ai64 = fromiter(self.makegen(), int64) af = fromiter(self.makegen(), float) self.failUnless(ai32.dtype == dtype(int32)) self.failUnless(ai64.dtype == dtype(int64)) self.failUnless(af.dtype == dtype(float))
def test_lengths(self): expected = array(list(self.makegen())) a = fromiter(self.makegen(), int) a20 = fromiter(self.makegen(), int, 20) self.failUnless(len(a) == len(expected)) self.failUnless(len(a20) == 20) try: fromiter(self.makegen(), int, len(expected) + 10) except ValueError: pass else: self.fail()
def test_values(self): expected = array(list(self.makegen())) a = fromiter(self.makegen(), int) a20 = fromiter(self.makegen(), int, 20) self.failUnless(alltrue(a == expected,axis=0)) self.failUnless(alltrue(a20 == expected[:20],axis=0))
class TestIndex(TestCase): def test_boolean(self): a = rand(3,5,8) V = rand(5,8) g1 = randint(0,5,size=15) g2 = randint(0,8,size=15) V[g1,g2] = -V[g1,g2] assert (array([a[0][V>0],a[1][V>0],a[2][V>0]]) == a[:,V>0]).all()
class TestBinaryRepr(TestCase): def test_zero(self): assert_equal(binary_repr(0),'0')
def test_large(self): assert_equal(binary_repr(10736848),'101000111101010011010000')
def test_negative(self): assert_equal(binary_repr(-1), '-1') assert_equal(binary_repr(-1, width=8), '11111111')
class TestArrayComparisons(TestCase): def test_array_equal(self): res = array_equal(array([1,2]), array([1,2])) assert res assert type(res) is bool res = array_equal(array([1,2]), array([1,2,3])) assert not res assert type(res) is bool res = array_equal(array([1,2]), array([3,4])) assert not res assert type(res) is bool res = array_equal(array([1,2]), array([1,3])) assert not res assert type(res) is bool
def test_array_equiv(self): res = array_equiv(array([1,2]), array([1,2])) assert res assert type(res) is bool res = array_equiv(array([1,2]), array([1,2,3])) assert not res assert type(res) is bool res = array_equiv(array([1,2]), array([3,4])) assert not res assert type(res) is bool res = array_equiv(array([1,2]), array([1,3])) assert not res assert type(res) is bool
res = array_equiv(array([1,1]), array([1])) assert res assert type(res) is bool res = array_equiv(array([1,1]), array([[1],[1]])) assert res assert type(res) is bool res = array_equiv(array([1,2]), array([2])) assert not res assert type(res) is bool res = array_equiv(array([1,2]), array([[1],[2]])) assert not res assert type(res) is bool res = array_equiv(array([1,2]), array([[1,2,3],[4,5,6],[7,8,9]])) assert not res assert type(res) is bool
def assert_array_strict_equal(x, y): assert_array_equal(x, y) # Check flags assert x.flags == y.flags # check endianness assert x.dtype.isnative == y.dtype.isnative
class TestClip(TestCase): def setUp(self): self.nr = 5 self.nc = 3
def fastclip(self, a, m, M, out=None): if out is None: return a.clip(m,M) else: return a.clip(m,M,out)
def clip(self, a, m, M, out=None): # use slow-clip selector = less(a, m)+2*greater(a, M) return selector.choose((a, m, M), out=out)
# Handy functions def _generate_data(self, n, m): return randn(n, m)
def _generate_data_complex(self, n, m): return randn(n, m) + 1.j *rand(n, m)
def _generate_flt_data(self, n, m): return (randn(n, m)).astype(float32)
def _neg_byteorder(self, a): a = asarray(a) if sys.byteorder == 'little': a = a.astype(a.dtype.newbyteorder('>')) else: a = a.astype(a.dtype.newbyteorder('<')) return a
def _generate_non_native_data(self, n, m): data = randn(n, m) data = self._neg_byteorder(data) assert not data.dtype.isnative return data
def _generate_int_data(self, n, m): return (10 * rand(n, m)).astype(int64)
def _generate_int32_data(self, n, m): return (10 * rand(n, m)).astype(int32)
# Now the real test cases def test_simple_double(self): """Test native double input with scalar min/max.""" a = self._generate_data(self.nr, self.nc) m = 0.1 M = 0.6 ac = self.fastclip(a, m, M) act = self.clip(a, m, M) assert_array_strict_equal(ac, act)
def test_simple_int(self): """Test native int input with scalar min/max.""" a = self._generate_int_data(self.nr, self.nc) a = a.astype(int) m = -2 M = 4 ac = self.fastclip(a, m, M) act = self.clip(a, m, M) assert_array_strict_equal(ac, act)
def test_array_double(self): """Test native double input with array min/max.""" a = self._generate_data(self.nr, self.nc) m = zeros(a.shape) M = m + 0.5 ac = self.fastclip(a, m, M) act = self.clip(a, m, M) assert_array_strict_equal(ac, act)
def test_simple_nonnative(self): """Test non native double input with scalar min/max. Test native double input with non native double scalar min/max.""" a = self._generate_non_native_data(self.nr, self.nc) m = -0.5 M = 0.6 ac = self.fastclip(a, m, M) act = self.clip(a, m, M) assert_array_equal(ac, act)
"Test native double input with non native double scalar min/max." a = self._generate_data(self.nr, self.nc) m = -0.5 M = self._neg_byteorder(0.6) assert not M.dtype.isnative ac = self.fastclip(a, m, M) act = self.clip(a, m, M) assert_array_equal(ac, act)
def test_simple_complex(self): """Test native complex input with native double scalar min/max. Test native input with complex double scalar min/max. """ a = 3 * self._generate_data_complex(self.nr, self.nc) m = -0.5 M = 1. ac = self.fastclip(a, m, M) act = self.clip(a, m, M) assert_array_strict_equal(ac, act)
"Test native input with complex double scalar min/max." a = 3 * self._generate_data(self.nr, self.nc) m = -0.5 + 1.j M = 1. + 2.j ac = self.fastclip(a, m, M) act = self.clip(a, m, M) assert_array_strict_equal(ac, act)
def test_clip_non_contig(self): """Test clip for non contiguous native input and native scalar min/max.""" a = self._generate_data(self.nr * 2, self.nc * 3) a = a[::2, ::3] assert not a.flags['F_CONTIGUOUS'] assert not a.flags['C_CONTIGUOUS'] ac = self.fastclip(a, -1.6, 1.7) act = self.clip(a, -1.6, 1.7) assert_array_strict_equal(ac, act)
def test_simple_out(self): """Test native double input with scalar min/max.""" a = self._generate_data(self.nr, self.nc) m = -0.5 M = 0.6 ac = zeros(a.shape) act = zeros(a.shape) self.fastclip(a, m, M, ac) self.clip(a, m, M, act) assert_array_strict_equal(ac, act)
def test_simple_int32_inout(self): """Test native int32 input with double min/max and int32 out.""" a = self._generate_int32_data(self.nr, self.nc) m = float64(0) M = float64(2) ac = zeros(a.shape, dtype = int32) act = ac.copy() self.fastclip(a, m, M, ac) self.clip(a, m, M, act) assert_array_strict_equal(ac, act)
def test_simple_int64_out(self): """Test native int32 input with int32 scalar min/max and int64 out.""" a = self._generate_int32_data(self.nr, self.nc) m = int32(-1) M = int32(1) ac = zeros(a.shape, dtype = int64) act = ac.copy() self.fastclip(a, m, M, ac) self.clip(a, m, M, act) assert_array_strict_equal(ac, act)
def test_simple_int64_inout(self): """Test native in32 input with double array min/max and int32 out.""" a = self._generate_int32_data(self.nr, self.nc) m = zeros(a.shape, float64) M = float64(1) ac = zeros(a.shape, dtype = int32) act = ac.copy() self.fastclip(a, m, M, ac) self.clip(a, m, M, act) assert_array_strict_equal(ac, act)
def test_simple_int32_out(self): """Test native double input with scalar min/max and int out.""" a = self._generate_data(self.nr, self.nc) m = -1.0 M = 2.0 ac = zeros(a.shape, dtype = int32) act = ac.copy() self.fastclip(a, m, M, ac) self.clip(a, m, M, act) assert_array_strict_equal(ac, act)
def test_simple_inplace_01(self): """Test native double input with array min/max in-place.""" a = self._generate_data(self.nr, self.nc) ac = a.copy() m = zeros(a.shape) M = 1.0 self.fastclip(a, m, M, a) self.clip(a, m, M, ac) assert_array_strict_equal(a, ac)
def test_simple_inplace_02(self): """Test native double input with scalar min/max in-place.""" a = self._generate_data(self.nr, self.nc) ac = a.copy() m = -0.5 M = 0.6 self.fastclip(a, m, M, a) self.clip(a, m, M, ac) assert_array_strict_equal(a, ac)
def test_noncontig_inplace(self): """Test non contiguous double input with double scalar min/max in-place.""" a = self._generate_data(self.nr * 2, self.nc * 3) a = a[::2, ::3] assert not a.flags['F_CONTIGUOUS'] assert not a.flags['C_CONTIGUOUS'] ac = a.copy() m = -0.5 M = 0.6 self.fastclip(a, m, M, a) self.clip(a, m, M, ac) assert_array_equal(a, ac)
def test_type_cast_01(self): "Test native double input with scalar min/max." a = self._generate_data(self.nr, self.nc) m = -0.5 M = 0.6 ac = self.fastclip(a, m, M) act = self.clip(a, m, M) assert_array_strict_equal(ac, act)
def test_type_cast_02(self): "Test native int32 input with int32 scalar min/max." a = self._generate_int_data(self.nr, self.nc) a = a.astype(int32) m = -2 M = 4 ac = self.fastclip(a, m, M) act = self.clip(a, m, M) assert_array_strict_equal(ac, act)
def test_type_cast_03(self): "Test native int32 input with float64 scalar min/max." a = self._generate_int32_data(self.nr, self.nc) m = -2 M = 4 ac = self.fastclip(a, float64(m), float64(M)) act = self.clip(a, float64(m), float64(M)) assert_array_strict_equal(ac, act)
def test_type_cast_04(self): "Test native int32 input with float32 scalar min/max." a = self._generate_int32_data(self.nr, self.nc) m = float32(-2) M = float32(4) act = self.fastclip(a,m,M) ac = self.clip(a,m,M) assert_array_strict_equal(ac, act)
def test_type_cast_05(self): "Test native int32 with double arrays min/max." a = self._generate_int_data(self.nr, self.nc) m = -0.5 M = 1. ac = self.fastclip(a, m * zeros(a.shape), M) act = self.clip(a, m * zeros(a.shape), M) assert_array_strict_equal(ac, act)
def test_type_cast_06(self): "Test native with NON native scalar min/max." a = self._generate_data(self.nr, self.nc) m = 0.5 m_s = self._neg_byteorder(m) M = 1. act = self.clip(a, m_s, M) ac = self.fastclip(a, m_s, M) assert_array_strict_equal(ac, act)
def test_type_cast_07(self): "Test NON native with native array min/max." a = self._generate_data(self.nr, self.nc) m = -0.5 * ones(a.shape) M = 1. a_s = self._neg_byteorder(a) assert not a_s.dtype.isnative act = a_s.clip(m, M) ac = self.fastclip(a_s, m, M) assert_array_strict_equal(ac, act)
def test_type_cast_08(self): "Test NON native with native scalar min/max." a = self._generate_data(self.nr, self.nc) m = -0.5 M = 1. a_s = self._neg_byteorder(a) assert not a_s.dtype.isnative ac = self.fastclip(a_s, m , M) act = a_s.clip(m, M) assert_array_strict_equal(ac, act)
def test_type_cast_09(self): "Test native with NON native array min/max." a = self._generate_data(self.nr, self.nc) m = -0.5 * ones(a.shape) M = 1. m_s = self._neg_byteorder(m) assert not m_s.dtype.isnative ac = self.fastclip(a, m_s , M) act = self.clip(a, m_s, M) assert_array_strict_equal(ac, act)
def test_type_cast_10(self): """Test native int32 with float min/max and float out for output argument.""" a = self._generate_int_data(self.nr, self.nc) b = zeros(a.shape, dtype = float32) m = float32(-0.5) M = float32(1) act = self.clip(a, m, M, out = b) ac = self.fastclip(a, m , M, out = b) assert_array_strict_equal(ac, act)
def test_type_cast_11(self): "Test non native with native scalar, min/max, out non native" a = self._generate_non_native_data(self.nr, self.nc) b = a.copy() b = b.astype(b.dtype.newbyteorder('>')) bt = b.copy() m = -0.5 M = 1. self.fastclip(a, m , M, out = b) self.clip(a, m, M, out = bt) assert_array_strict_equal(b, bt)
def test_type_cast_12(self): "Test native int32 input and min/max and float out" a = self._generate_int_data(self.nr, self.nc) b = zeros(a.shape, dtype = float32) m = int32(0) M = int32(1) act = self.clip(a, m, M, out = b) ac = self.fastclip(a, m , M, out = b) assert_array_strict_equal(ac, act)
def test_clip_with_out_simple(self): "Test native double input with scalar min/max" a = self._generate_data(self.nr, self.nc) m = -0.5 M = 0.6 ac = zeros(a.shape) act = zeros(a.shape) self.fastclip(a, m, M, ac) self.clip(a, m, M, act) assert_array_strict_equal(ac, act)
def test_clip_with_out_simple2(self): "Test native int32 input with double min/max and int32 out" a = self._generate_int32_data(self.nr, self.nc) m = float64(0) M = float64(2) ac = zeros(a.shape, dtype = int32) act = ac.copy() self.fastclip(a, m, M, ac) self.clip(a, m, M, act) assert_array_strict_equal(ac, act)
def test_clip_with_out_simple_int32(self): "Test native int32 input with int32 scalar min/max and int64 out" a = self._generate_int32_data(self.nr, self.nc) m = int32(-1) M = int32(1) ac = zeros(a.shape, dtype = int64) act = ac.copy() self.fastclip(a, m, M, ac) self.clip(a, m, M, act) assert_array_strict_equal(ac, act)
def test_clip_with_out_array_int32(self): "Test native int32 input with double array min/max and int32 out" a = self._generate_int32_data(self.nr, self.nc) m = zeros(a.shape, float64) M = float64(1) ac = zeros(a.shape, dtype = int32) act = ac.copy() self.fastclip(a, m, M, ac) self.clip(a, m, M, act) assert_array_strict_equal(ac, act)
def test_clip_with_out_array_outint32(self): "Test native double input with scalar min/max and int out" a = self._generate_data(self.nr, self.nc) m = -1.0 M = 2.0 ac = zeros(a.shape, dtype = int32) act = ac.copy() self.fastclip(a, m, M, ac) self.clip(a, m, M, act) assert_array_strict_equal(ac, act)
def test_clip_inplace_array(self): "Test native double input with array min/max" a = self._generate_data(self.nr, self.nc) ac = a.copy() m = zeros(a.shape) M = 1.0 self.fastclip(a, m, M, a) self.clip(a, m, M, ac) assert_array_strict_equal(a, ac)
def test_clip_inplace_simple(self): "Test native double input with scalar min/max" a = self._generate_data(self.nr, self.nc) ac = a.copy() m = -0.5 M = 0.6 self.fastclip(a, m, M, a) self.clip(a, m, M, ac) assert_array_strict_equal(a, ac)
def test_clip_func_takes_out(self): """ Ensure that the clip() function takes an out= argument. """ a = self._generate_data(self.nr, self.nc) ac = a.copy() m = -0.5 M = 0.6 a2 = clip(a, m, M, out=a) self.clip(a, m, M, ac) assert_array_strict_equal(a2, ac) self.assert_(a2 is a)
class test_allclose_inf(TestCase): rtol = 1e-5 atol = 1e-8
def tst_allclose(self,x,y): assert allclose(x,y), "%s and %s not close" % (x,y)
def tst_not_allclose(self,x,y): assert not allclose(x,y), "%s and %s shouldn't be close" % (x,y)
def test_ip_allclose(self): """Parametric test factory.""" arr = array([100,1000]) aran = arange(125).reshape((5,5,5))
atol = self.atol rtol = self.rtol
data = [([1,0], [1,0]), ([atol], [0]), ([1], [1+rtol+atol]), (arr, arr + arr*rtol), (arr, arr + arr*rtol + atol*2), (aran, aran + aran*rtol),]
for (x,y) in data: yield (self.tst_allclose,x,y)
def test_ip_not_allclose(self): """Parametric test factory.""" aran = arange(125).reshape((5,5,5))
atol = self.atol rtol = self.rtol
data = [([inf,0], [1,inf]), ([inf,0], [1,0]), ([inf,inf], [1,inf]), ([inf,inf], [1,0]), ([-inf, 0], [inf, 0]), ([nan,0], [nan,0]), ([atol*2], [0]), ([1], [1+rtol+atol*2]), (aran, aran + aran*atol + atol*2), (array([inf,1]), array([0,inf]))]
for (x,y) in data: yield (self.tst_not_allclose,x,y)
def test_no_parameter_modification(self): x = array([inf,1]) y = array([0,inf]) allclose(x,y) assert_array_equal(x,array([inf,1])) assert_array_equal(y,array([0,inf]))
class TestStdVar(TestCase): def setUp(self): self.A = array([1,-1,1,-1]) self.real_var = 1
def test_basic(self): assert_almost_equal(var(self.A),self.real_var) assert_almost_equal(std(self.A)**2,self.real_var)
def test_ddof1(self): assert_almost_equal(var(self.A,ddof=1), self.real_var*len(self.A)/float(len(self.A)-1)) assert_almost_equal(std(self.A,ddof=1)**2, self.real_var*len(self.A)/float(len(self.A)-1))
def test_ddof2(self): assert_almost_equal(var(self.A,ddof=2), self.real_var*len(self.A)/float(len(self.A)-2)) assert_almost_equal(std(self.A,ddof=2)**2, self.real_var*len(self.A)/float(len(self.A)-2))
class TestStdVarComplex(TestCase): def test_basic(self): A = array([1,1.j,-1,-1.j]) real_var = 1 assert_almost_equal(var(A),real_var) assert_almost_equal(std(A)**2,real_var)
class TestLikeFuncs(TestCase): '''Test zeros_like and empty_like'''
def setUp(self): self.data = [(array([[1,2,3],[4,5,6]],dtype=int32), (2,3), int32), (array([[1,2,3],[4,5,6]],dtype=float32), (2,3), float32), ]
def test_zeros_like(self): for d, dshape, dtype in self.data: dz = zeros_like(d) assert dz.shape == dshape assert dz.dtype.type == dtype assert all(abs(dz) == 0)
def test_empty_like(self): for d, dshape, dtype in self.data: dz = zeros_like(d) assert dz.shape == dshape assert dz.dtype.type == dtype
class _TestCorrelate(TestCase): def _setup(self, dt): self.x = np.array([1, 2, 3, 4, 5], dtype=dt) self.y = np.array([-1, -2, -3], dtype=dt) self.z1 = np.array([ -3., -8., -14., -20., -26., -14., -5.], dtype=dt) self.z2 = np.array([ -5., -14., -26., -20., -14., -8., -3.], dtype=dt)
def test_float(self): self._setup(np.float) z = np.correlate(self.x, self.y, 'full', old_behavior=self.old_behavior) assert_array_almost_equal(z, self.z1) z = np.correlate(self.y, self.x, 'full', old_behavior=self.old_behavior) assert_array_almost_equal(z, self.z2)
def test_object(self): self._setup(Decimal) z = np.correlate(self.x, self.y, 'full', old_behavior=self.old_behavior) assert_array_almost_equal(z, self.z1) z = np.correlate(self.y, self.x, 'full', old_behavior=self.old_behavior) assert_array_almost_equal(z, self.z2)
class TestCorrelate(_TestCorrelate): old_behavior = True def _setup(self, dt): # correlate uses an unconventional definition so that correlate(a, b) # == correlate(b, a), so force the corresponding outputs to be the same # as well _TestCorrelate._setup(self, dt) self.z2 = self.z1
@dec.deprecated() def test_complex(self): x = np.array([1, 2, 3, 4+1j], dtype=np.complex) y = np.array([-1, -2j, 3+1j], dtype=np.complex) r_z = np.array([3+1j, 6, 8-1j, 9+1j, -1-8j, -4-1j], dtype=np.complex) z = np.correlate(x, y, 'full') assert_array_almost_equal(z, r_z)
@dec.deprecated() def test_float(self): _TestCorrelate.test_float(self)
@dec.deprecated() def test_object(self): _TestCorrelate.test_object(self)
class TestCorrelateNew(_TestCorrelate): old_behavior = False def test_complex(self): x = np.array([1, 2, 3, 4+1j], dtype=np.complex) y = np.array([-1, -2j, 3+1j], dtype=np.complex) r_z = np.array([3-1j, 6, 8+1j, 11+5j, -5+8j, -4-1j], dtype=np.complex) #z = np.acorrelate(x, y, 'full') #assert_array_almost_equal(z, r_z)
r_z = r_z[::-1].conjugate() z = np.correlate(y, x, 'full', old_behavior=self.old_behavior) assert_array_almost_equal(z, r_z)
class TestArgwhere: def test_2D(self): x = np.arange(6).reshape((2, 3)) assert_array_equal(np.argwhere(x > 1), [[0, 2], [1, 0], [1, 1], [1, 2]])
def test_list(self): assert_equal(np.argwhere([4, 0, 2, 1, 3]), [[0], [2], [3], [4]])
if __name__ == "__main__": run_module_suite()
|