Viewing file:  test_old_ma.py (32.24 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
import numpy
import types
from numpy.ma import *
from numpy.core.numerictypes import float32
from numpy.ma.core import umath
from numpy.testing import *
pi = numpy.pi
def eq(v,w, msg=''):
result = allclose(v,w)
if not result:
print """Not eq:%s
%s
----
%s"""% (msg, str(v), str(w))
return result
class TestMa(TestCase):
def setUp (self):
x=numpy.array([1.,1.,1.,-2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
y=numpy.array([5.,0.,3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
a10 = 10.
m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0 ,0, 1]
xm = array(x, mask=m1)
ym = array(y, mask=m2)
z = numpy.array([-.5, 0., .5, .8])
zm = array(z, mask=[0,1,0,0])
xf = numpy.where(m1, 1.e+20, x)
s = x.shape
xm.set_fill_value(1.e+20)
self.d = (x, y, a10, m1, m2, xm, ym, z, zm, xf, s)
def test_testBasic1d(self):
"Test of basic array creation and properties in 1 dimension."
(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
self.failIf(isMaskedArray(x))
self.failUnless(isMaskedArray(xm))
self.assertEqual(shape(xm), s)
self.assertEqual(xm.shape, s)
self.assertEqual(xm.dtype, x.dtype)
self.assertEqual( xm.size , reduce(lambda x,y:x*y, s))
self.assertEqual(count(xm) , len(m1) - reduce(lambda x,y:x+y, m1))
self.failUnless(eq(xm, xf))
self.failUnless(eq(filled(xm, 1.e20), xf))
self.failUnless(eq(x, xm))
def test_testBasic2d(self):
"Test of basic array creation and properties in 2 dimensions."
for s in [(4,3), (6,2)]:
(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
x.shape = s
y.shape = s
xm.shape = s
ym.shape = s
xf.shape = s
self.failIf(isMaskedArray(x))
self.failUnless(isMaskedArray(xm))
self.assertEqual(shape(xm), s)
self.assertEqual(xm.shape, s)
self.assertEqual( xm.size , reduce(lambda x,y:x*y, s))
self.assertEqual( count(xm) , len(m1) - reduce(lambda x,y:x+y, m1))
self.failUnless(eq(xm, xf))
self.failUnless(eq(filled(xm, 1.e20), xf))
self.failUnless(eq(x, xm))
self.setUp()
def test_testArithmetic (self):
"Test of basic arithmetic."
(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
a2d = array([[1,2],[0,4]])
a2dm = masked_array(a2d, [[0,0],[1,0]])
self.failUnless(eq (a2d * a2d, a2d * a2dm))
self.failUnless(eq (a2d + a2d, a2d + a2dm))
self.failUnless(eq (a2d - a2d, a2d - a2dm))
for s in [(12,), (4,3), (2,6)]:
x = x.reshape(s)
y = y.reshape(s)
xm = xm.reshape(s)
ym = ym.reshape(s)
xf = xf.reshape(s)
self.failUnless(eq(-x, -xm))
self.failUnless(eq(x + y, xm + ym))
self.failUnless(eq(x - y, xm - ym))
self.failUnless(eq(x * y, xm * ym))
olderr = numpy.seterr(divide='ignore', invalid='ignore')
self.failUnless(eq(x / y, xm / ym))
numpy.seterr(**olderr)
self.failUnless(eq(a10 + y, a10 + ym))
self.failUnless(eq(a10 - y, a10 - ym))
self.failUnless(eq(a10 * y, a10 * ym))
olderr = numpy.seterr(divide='ignore', invalid='ignore')
self.failUnless(eq(a10 / y, a10 / ym))
numpy.seterr(**olderr)
self.failUnless(eq(x + a10, xm + a10))
self.failUnless(eq(x - a10, xm - a10))
self.failUnless(eq(x * a10, xm * a10))
self.failUnless(eq(x / a10, xm / a10))
self.failUnless(eq(x**2, xm**2))
self.failUnless(eq(abs(x)**2.5, abs(xm) **2.5))
self.failUnless(eq(x**y, xm**ym))
self.failUnless(eq(numpy.add(x,y), add(xm, ym)))
self.failUnless(eq(numpy.subtract(x,y), subtract(xm, ym)))
self.failUnless(eq(numpy.multiply(x,y), multiply(xm, ym)))
olderr = numpy.seterr(divide='ignore', invalid='ignore')
self.failUnless(eq(numpy.divide(x,y), divide(xm, ym)))
numpy.seterr(**olderr)
def test_testMixedArithmetic(self):
na = numpy.array([1])
ma = array([1])
self.failUnless(isinstance(na + ma, MaskedArray))
self.failUnless(isinstance(ma + na, MaskedArray))
def test_testUfuncs1 (self):
"Test various functions such as sin, cos."
(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
self.failUnless (eq(numpy.cos(x), cos(xm)))
self.failUnless (eq(numpy.cosh(x), cosh(xm)))
self.failUnless (eq(numpy.sin(x), sin(xm)))
self.failUnless (eq(numpy.sinh(x), sinh(xm)))
self.failUnless (eq(numpy.tan(x), tan(xm)))
self.failUnless (eq(numpy.tanh(x), tanh(xm)))
olderr = numpy.seterr(divide='ignore', invalid='ignore')
self.failUnless (eq(numpy.sqrt(abs(x)), sqrt(xm)))
self.failUnless (eq(numpy.log(abs(x)), log(xm)))
self.failUnless (eq(numpy.log10(abs(x)), log10(xm)))
numpy.seterr(**olderr)
self.failUnless (eq(numpy.exp(x), exp(xm)))
self.failUnless (eq(numpy.arcsin(z), arcsin(zm)))
self.failUnless (eq(numpy.arccos(z), arccos(zm)))
self.failUnless (eq(numpy.arctan(z), arctan(zm)))
self.failUnless (eq(numpy.arctan2(x, y), arctan2(xm, ym)))
self.failUnless (eq(numpy.absolute(x), absolute(xm)))
self.failUnless (eq(numpy.equal(x,y), equal(xm, ym)))
self.failUnless (eq(numpy.not_equal(x,y), not_equal(xm, ym)))
self.failUnless (eq(numpy.less(x,y), less(xm, ym)))
self.failUnless (eq(numpy.greater(x,y), greater(xm, ym)))
self.failUnless (eq(numpy.less_equal(x,y), less_equal(xm, ym)))
self.failUnless (eq(numpy.greater_equal(x,y), greater_equal(xm, ym)))
self.failUnless (eq(numpy.conjugate(x), conjugate(xm)))
self.failUnless (eq(numpy.concatenate((x,y)), concatenate((xm,ym))))
self.failUnless (eq(numpy.concatenate((x,y)), concatenate((x,y))))
self.failUnless (eq(numpy.concatenate((x,y)), concatenate((xm,y))))
self.failUnless (eq(numpy.concatenate((x,y,x)), concatenate((x,ym,x))))
def test_xtestCount (self):
"Test count"
ott = array([0.,1.,2.,3.], mask=[1,0,0,0])
self.failUnless( isinstance(count(ott), types.IntType))
self.assertEqual(3, count(ott))
self.assertEqual(1, count(1))
self.failUnless (eq(0, array(1,mask=[1])))
ott=ott.reshape((2,2))
assert isinstance(count(ott,0),numpy.ndarray)
assert isinstance(count(ott), types.IntType)
self.failUnless (eq(3, count(ott)))
assert getmask(count(ott,0)) is nomask
self.failUnless (eq([1,2],count(ott,0)))
def test_testMinMax (self):
"Test minimum and maximum."
(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
xr = numpy.ravel(x) #max doesn't work if shaped
xmr = ravel(xm)
#true because of careful selection of data
self.failUnless(eq(max(xr), maximum(xmr)))
#true because of careful selection of data
self.failUnless(eq(min(xr), minimum(xmr)))
def test_testAddSumProd (self):
"Test add, sum, product."
(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
self.failUnless (eq(numpy.add.reduce(x), add.reduce(x)))
self.failUnless (eq(numpy.add.accumulate(x), add.accumulate(x)))
self.failUnless (eq(4, sum(array(4),axis=0)))
self.failUnless (eq(4, sum(array(4), axis=0)))
self.failUnless (eq(numpy.sum(x,axis=0), sum(x,axis=0)))
self.failUnless (eq(numpy.sum(filled(xm,0),axis=0), sum(xm,axis=0)))
self.failUnless (eq(numpy.sum(x,0), sum(x,0)))
self.failUnless (eq(numpy.product(x,axis=0), product(x,axis=0)))
self.failUnless (eq(numpy.product(x,0), product(x,0)))
self.failUnless (eq(numpy.product(filled(xm,1),axis=0),
product(xm,axis=0)))
if len(s) > 1:
self.failUnless (eq(numpy.concatenate((x,y),1),
concatenate((xm,ym),1)))
self.failUnless (eq(numpy.add.reduce(x,1), add.reduce(x,1)))
self.failUnless (eq(numpy.sum(x,1), sum(x,1)))
self.failUnless (eq(numpy.product(x,1), product(x,1)))
def test_testCI(self):
"Test of conversions and indexing"
x1 = numpy.array([1,2,4,3])
x2 = array(x1, mask = [1,0,0,0])
x3 = array(x1, mask = [0,1,0,1])
x4 = array(x1)
# test conversion to strings
junk, garbage = str(x2), repr(x2)
assert eq(numpy.sort(x1),sort(x2, fill_value=0))
# tests of indexing
assert type(x2[1]) is type(x1[1])
assert x1[1] == x2[1]
assert x2[0] is masked
assert eq(x1[2],x2[2])
assert eq(x1[2:5],x2[2:5])
assert eq(x1[:],x2[:])
assert eq(x1[1:], x3[1:])
x1[2]=9
x2[2]=9
assert eq(x1,x2)
x1[1:3] = 99
x2[1:3] = 99
assert eq(x1,x2)
x2[1] = masked
assert eq(x1,x2)
x2[1:3]=masked
assert eq(x1,x2)
x2[:] = x1
x2[1] = masked
assert allequal(getmask(x2),array([0,1,0,0]))
x3[:] = masked_array([1,2,3,4],[0,1,1,0])
assert allequal(getmask(x3), array([0,1,1,0]))
x4[:] = masked_array([1,2,3,4],[0,1,1,0])
assert allequal(getmask(x4), array([0,1,1,0]))
assert allequal(x4, array([1,2,3,4]))
x1 = numpy.arange(5)*1.0
x2 = masked_values(x1, 3.0)
assert eq(x1,x2)
assert allequal(array([0,0,0,1,0],MaskType), x2.mask)
assert eq(3.0, x2.fill_value)
x1 = array([1,'hello',2,3],object)
x2 = numpy.array([1,'hello',2,3],object)
s1 = x1[1]
s2 = x2[1]
self.assertEqual(type(s2), str)
self.assertEqual(type(s1), str)
self.assertEqual(s1, s2)
assert x1[1:1].shape == (0,)
def test_testCopySize(self):
"Tests of some subtle points of copying and sizing."
n = [0,0,1,0,0]
m = make_mask(n)
m2 = make_mask(m)
self.failUnless(m is m2)
m3 = make_mask(m, copy=1)
self.failUnless(m is not m3)
x1 = numpy.arange(5)
y1 = array(x1, mask=m)
self.failUnless( y1._data is not x1)
self.failUnless( allequal(x1,y1._data))
self.failUnless( y1.mask is m)
y1a = array(y1, copy=0)
self.failUnless( y1a.mask is y1.mask)
y2 = array(x1, mask=m, copy=0)
self.failUnless( y2.mask is m)
self.failUnless( y2[2] is masked)
y2[2]=9
self.failUnless( y2[2] is not masked)
self.failUnless( y2.mask is not m)
self.failUnless( allequal(y2.mask, 0))
y3 = array(x1*1.0, mask=m)
self.failUnless(filled(y3).dtype is (x1*1.0).dtype)
x4 = arange(4)
x4[2] = masked
y4 = resize(x4, (8,))
self.failUnless( eq(concatenate([x4,x4]), y4))
self.failUnless( eq(getmask(y4),[0,0,1,0,0,0,1,0]))
y5 = repeat(x4, (2,2,2,2), axis=0)
self.failUnless( eq(y5, [0,0,1,1,2,2,3,3]))
y6 = repeat(x4, 2, axis=0)
self.failUnless( eq(y5, y6))
def test_testPut(self):
"Test of put"
d = arange(5)
n = [0,0,0,1,1]
m = make_mask(n)
x = array(d, mask = m)
self.failUnless( x[3] is masked)
self.failUnless( x[4] is masked)
x[[1,4]] = [10,40]
self.failUnless( x.mask is not m)
self.failUnless( x[3] is masked)
self.failUnless( x[4] is not masked)
self.failUnless( eq(x, [0,10,2,-1,40]))
x = array(d, mask = m)
x.put([0,1,2],[-1,100,200])
self.failUnless( eq(x, [-1,100,200,0,0]))
self.failUnless( x[3] is masked)
self.failUnless( x[4] is masked)
def test_testMaPut(self):
(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
m = [1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1]
i = numpy.nonzero(m)[0]
put(ym, i, zm)
assert all(take(ym, i, axis=0) == zm)
def test_testOddFeatures(self):
"Test of other odd features"
x = arange(20); x=x.reshape(4,5)
x.flat[5] = 12
assert x[1,0] == 12
z = x + 10j * x
assert eq(z.real, x)
assert eq(z.imag, 10*x)
assert eq((z*conjugate(z)).real, 101*x*x)
z.imag[...] = 0.0
x = arange(10)
x[3] = masked
assert str(x[3]) == str(masked)
c = x >= 8
assert count(where(c,masked,masked)) == 0
assert shape(where(c,masked,masked)) == c.shape
z = where(c , x, masked)
assert z.dtype is x.dtype
assert z[3] is masked
assert z[4] is masked
assert z[7] is masked
assert z[8] is not masked
assert z[9] is not masked
assert eq(x,z)
z = where(c , masked, x)
assert z.dtype is x.dtype
assert z[3] is masked
assert z[4] is not masked
assert z[7] is not masked
assert z[8] is masked
assert z[9] is masked
z = masked_where(c, x)
assert z.dtype is x.dtype
assert z[3] is masked
assert z[4] is not masked
assert z[7] is not masked
assert z[8] is masked
assert z[9] is masked
assert eq(x,z)
x = array([1.,2.,3.,4.,5.])
c = array([1,1,1,0,0])
x[2] = masked
z = where(c, x, -x)
assert eq(z, [1.,2.,0., -4., -5])
c[0] = masked
z = where(c, x, -x)
assert eq(z, [1.,2.,0., -4., -5])
assert z[0] is masked
assert z[1] is not masked
assert z[2] is masked
assert eq(masked_where(greater(x, 2), x), masked_greater(x,2))
assert eq(masked_where(greater_equal(x, 2), x),
masked_greater_equal(x,2))
assert eq(masked_where(less(x, 2), x), masked_less(x,2))
assert eq(masked_where(less_equal(x, 2), x), masked_less_equal(x,2))
assert eq(masked_where(not_equal(x, 2), x), masked_not_equal(x,2))
assert eq(masked_where(equal(x, 2), x), masked_equal(x,2))
assert eq(masked_where(not_equal(x,2), x), masked_not_equal(x,2))
assert eq(masked_inside(range(5), 1, 3), [0, 199, 199, 199, 4])
assert eq(masked_outside(range(5), 1, 3),[199,1,2,3,199])
assert eq(masked_inside(array(range(5), mask=[1,0,0,0,0]), 1, 3).mask,
[1,1,1,1,0])
assert eq(masked_outside(array(range(5), mask=[0,1,0,0,0]), 1, 3).mask,
[1,1,0,0,1])
assert eq(masked_equal(array(range(5), mask=[1,0,0,0,0]), 2).mask,
[1,0,1,0,0])
assert eq(masked_not_equal(array([2,2,1,2,1], mask=[1,0,0,0,0]), 2).mask,
[1,0,1,0,1])
assert eq(masked_where([1,1,0,0,0], [1,2,3,4,5]), [99,99,3,4,5])
atest = ones((10,10,10), dtype=float32)
btest = zeros(atest.shape, MaskType)
ctest = masked_where(btest,atest)
assert eq(atest,ctest)
z = choose(c, (-x, x))
assert eq(z, [1.,2.,0., -4., -5])
assert z[0] is masked
assert z[1] is not masked
assert z[2] is masked
x = arange(6)
x[5] = masked
y = arange(6)*10
y[2]= masked
c = array([1,1,1,0,0,0], mask=[1,0,0,0,0,0])
cm = c.filled(1)
z = where(c,x,y)
zm = where(cm,x,y)
assert eq(z, zm)
assert getmask(zm) is nomask
assert eq(zm, [0,1,2,30,40,50])
z = where(c, masked, 1)
assert eq(z, [99,99,99,1,1,1])
z = where(c, 1, masked)
assert eq(z, [99, 1, 1, 99, 99, 99])
def test_testMinMax(self):
"Test of minumum, maximum."
assert eq(minimum([1,2,3],[4,0,9]), [1,0,3])
assert eq(maximum([1,2,3],[4,0,9]), [4,2,9])
x = arange(5)
y = arange(5) - 2
x[3] = masked
y[0] = masked
assert eq(minimum(x,y), where(less(x,y), x, y))
assert eq(maximum(x,y), where(greater(x,y), x, y))
assert minimum(x) == 0
assert maximum(x) == 4
def test_testTakeTransposeInnerOuter(self):
"Test of take, transpose, inner, outer products"
x = arange(24)
y = numpy.arange(24)
x[5:6] = masked
x=x.reshape(2,3,4)
y=y.reshape(2,3,4)
assert eq(numpy.transpose(y,(2,0,1)), transpose(x,(2,0,1)))
assert eq(numpy.take(y, (2,0,1), 1), take(x, (2,0,1), 1))
assert eq(numpy.inner(filled(x,0),filled(y,0)),
inner(x, y))
assert eq(numpy.outer(filled(x,0),filled(y,0)),
outer(x, y))
y = array(['abc', 1, 'def', 2, 3], object)
y[2] = masked
t = take(y,[0,3,4])
assert t[0] == 'abc'
assert t[1] == 2
assert t[2] == 3
def test_testInplace(self):
"""Test of inplace operations and rich comparisons"""
y = arange(10)
x = arange(10)
xm = arange(10)
xm[2] = masked
x += 1
assert eq(x, y+1)
xm += 1
assert eq(x, y+1)
x = arange(10)
xm = arange(10)
xm[2] = masked
x -= 1
assert eq(x, y-1)
xm -= 1
assert eq(xm, y-1)
x = arange(10)*1.0
xm = arange(10)*1.0
xm[2] = masked
x *= 2.0
assert eq(x, y*2)
xm *= 2.0
assert eq(xm, y*2)
x = arange(10)*2
xm = arange(10)
xm[2] = masked
x /= 2
assert eq(x, y)
xm /= 2
assert eq(x, y)
x = arange(10)*1.0
xm = arange(10)*1.0
xm[2] = masked
x /= 2.0
assert eq(x, y/2.0)
xm /= arange(10)
assert eq(xm, ones((10,)))
x = arange(10).astype(float32)
xm = arange(10)
xm[2] = masked
x += 1.
assert eq(x, y+1.)
def test_testPickle(self):
"Test of pickling"
import pickle
x = arange(12)
x[4:10:2] = masked
x = x.reshape(4,3)
s = pickle.dumps(x)
y = pickle.loads(s)
assert eq(x,y)
def test_testMasked(self):
"Test of masked element"
xx=arange(6)
xx[1] = masked
self.failUnless(str(masked) == '--')
self.failUnless(xx[1] is masked)
self.failUnlessEqual(filled(xx[1], 0), 0)
# don't know why these should raise an exception...
#self.failUnlessRaises(Exception, lambda x,y: x+y, masked, masked)
#self.failUnlessRaises(Exception, lambda x,y: x+y, masked, 2)
#self.failUnlessRaises(Exception, lambda x,y: x+y, masked, xx)
#self.failUnlessRaises(Exception, lambda x,y: x+y, xx, masked)
def test_testAverage1(self):
"Test of average."
ott = array([0.,1.,2.,3.], mask=[1,0,0,0])
self.failUnless(eq(2.0, average(ott,axis=0)))
self.failUnless(eq(2.0, average(ott, weights=[1., 1., 2., 1.])))
result, wts = average(ott, weights=[1.,1.,2.,1.], returned=1)
self.failUnless(eq(2.0, result))
self.failUnless(wts == 4.0)
ott[:] = masked
self.failUnless(average(ott,axis=0) is masked)
ott = array([0.,1.,2.,3.], mask=[1,0,0,0])
ott=ott.reshape(2,2)
ott[:,1] = masked
self.failUnless(eq(average(ott,axis=0), [2.0, 0.0]))
self.failUnless(average(ott,axis=1)[0] is masked)
self.failUnless(eq([2.,0.], average(ott, axis=0)))
result, wts = average(ott, axis=0, returned=1)
self.failUnless(eq(wts, [1., 0.]))
def test_testAverage2(self):
"More tests of average."
w1 = [0,1,1,1,1,0]
w2 = [[0,1,1,1,1,0],[1,0,0,0,0,1]]
x=arange(6)
self.failUnless(allclose(average(x, axis=0), 2.5))
self.failUnless(allclose(average(x, axis=0, weights=w1), 2.5))
y=array([arange(6), 2.0*arange(6)])
self.failUnless(allclose(average(y, None),
numpy.add.reduce(numpy.arange(6))*3./12.))
self.failUnless(allclose(average(y, axis=0), numpy.arange(6) * 3./2.))
self.failUnless(allclose(average(y, axis=1),
[average(x,axis=0), average(x,axis=0) * 2.0]))
self.failUnless(allclose(average(y, None, weights=w2), 20./6.))
self.failUnless(allclose(average(y, axis=0, weights=w2),
[0.,1.,2.,3.,4.,10.]))
self.failUnless(allclose(average(y, axis=1),
[average(x,axis=0), average(x,axis=0) * 2.0]))
m1 = zeros(6)
m2 = [0,0,1,1,0,0]
m3 = [[0,0,1,1,0,0],[0,1,1,1,1,0]]
m4 = ones(6)
m5 = [0, 1, 1, 1, 1, 1]
self.failUnless(allclose(average(masked_array(x, m1),axis=0), 2.5))
self.failUnless(allclose(average(masked_array(x, m2),axis=0), 2.5))
self.failUnless(average(masked_array(x, m4),axis=0) is masked)
self.assertEqual(average(masked_array(x, m5),axis=0), 0.0)
self.assertEqual(count(average(masked_array(x, m4),axis=0)), 0)
z = masked_array(y, m3)
self.failUnless(allclose(average(z, None), 20./6.))
self.failUnless(allclose(average(z, axis=0), [0.,1.,99.,99.,4.0, 7.5]))
self.failUnless(allclose(average(z, axis=1), [2.5, 5.0]))
self.failUnless(allclose( average(z,axis=0, weights=w2),
[0.,1., 99., 99., 4.0, 10.0]))
a = arange(6)
b = arange(6) * 3
r1, w1 = average([[a,b],[b,a]], axis=1, returned=1)
self.assertEqual(shape(r1) , shape(w1))
self.assertEqual(r1.shape , w1.shape)
r2, w2 = average(ones((2,2,3)), axis=0, weights=[3,1], returned=1)
self.assertEqual(shape(w2) , shape(r2))
r2, w2 = average(ones((2,2,3)), returned=1)
self.assertEqual(shape(w2) , shape(r2))
r2, w2 = average(ones((2,2,3)), weights=ones((2,2,3)), returned=1)
self.failUnless(shape(w2) == shape(r2))
a2d = array([[1,2],[0,4]], float)
a2dm = masked_array(a2d, [[0,0],[1,0]])
a2da = average(a2d, axis=0)
self.failUnless(eq (a2da, [0.5, 3.0]))
a2dma = average(a2dm, axis=0)
self.failUnless(eq( a2dma, [1.0, 3.0]))
a2dma = average(a2dm, axis=None)
self.failUnless(eq(a2dma, 7./3.))
a2dma = average(a2dm, axis=1)
self.failUnless(eq(a2dma, [1.5, 4.0]))
def test_testToPython(self):
self.assertEqual(1, int(array(1)))
self.assertEqual(1.0, float(array(1)))
self.assertEqual(1, int(array([[[1]]])))
self.assertEqual(1.0, float(array([[1]])))
self.failUnlessRaises(TypeError, float, array([1,1]))
self.failUnlessRaises(ValueError, bool, array([0,1]))
self.failUnlessRaises(ValueError, bool, array([0,0],mask=[0,1]))
def test_testScalarArithmetic(self):
xm = array(0, mask=1)
self.failUnless((1/array(0)).mask)
self.failUnless((1 + xm).mask)
self.failUnless((-xm).mask)
self.failUnless((-xm).mask)
self.failUnless(maximum(xm, xm).mask)
self.failUnless(minimum(xm, xm).mask)
self.failUnless(xm.filled().dtype is xm._data.dtype)
x = array(0, mask=0)
self.failUnless(x.filled() == x._data)
self.failUnlessEqual(str(xm), str(masked_print_option))
def test_testArrayMethods(self):
a = array([1,3,2])
b = array([1,3,2], mask=[1,0,1])
self.failUnless(eq(a.any(), a._data.any()))
self.failUnless(eq(a.all(), a._data.all()))
self.failUnless(eq(a.argmax(), a._data.argmax()))
self.failUnless(eq(a.argmin(), a._data.argmin()))
self.failUnless(eq(a.choose(0,1,2,3,4), a._data.choose(0,1,2,3,4)))
self.failUnless(eq(a.compress([1,0,1]), a._data.compress([1,0,1])))
self.failUnless(eq(a.conj(), a._data.conj()))
self.failUnless(eq(a.conjugate(), a._data.conjugate()))
m = array([[1,2],[3,4]])
self.failUnless(eq(m.diagonal(), m._data.diagonal()))
self.failUnless(eq(a.sum(), a._data.sum()))
self.failUnless(eq(a.take([1,2]), a._data.take([1,2])))
self.failUnless(eq(m.transpose(), m._data.transpose()))
def test_testArrayAttributes(self):
a = array([1,3,2])
b = array([1,3,2], mask=[1,0,1])
self.failUnlessEqual(a.ndim, 1)
def test_testAPI(self):
self.failIf([m for m in dir(numpy.ndarray)
if m not in dir(MaskedArray) and not m.startswith('_')])
def test_testSingleElementSubscript(self):
a = array([1,3,2])
b = array([1,3,2], mask=[1,0,1])
self.failUnlessEqual(a[0].shape, ())
self.failUnlessEqual(b[0].shape, ())
self.failUnlessEqual(b[1].shape, ())
class TestUfuncs(TestCase):
def setUp(self):
self.d = (array([1.0, 0, -1, pi/2]*2, mask=[0,1]+[0]*6),
array([1.0, 0, -1, pi/2]*2, mask=[1,0]+[0]*6),)
def test_testUfuncRegression(self):
for f in ['sqrt', 'log', 'log10', 'exp', 'conjugate',
'sin', 'cos', 'tan',
'arcsin', 'arccos', 'arctan',
'sinh', 'cosh', 'tanh',
'arcsinh',
'arccosh',
'arctanh',
'absolute', 'fabs', 'negative',
# 'nonzero', 'around',
'floor', 'ceil',
# 'sometrue', 'alltrue',
'logical_not',
'add', 'subtract', 'multiply',
'divide', 'true_divide', 'floor_divide',
'remainder', 'fmod', 'hypot', 'arctan2',
'equal', 'not_equal', 'less_equal', 'greater_equal',
'less', 'greater',
'logical_and', 'logical_or', 'logical_xor',
]:
try:
uf = getattr(umath, f)
except AttributeError:
uf = getattr(fromnumeric, f)
mf = getattr(numpy.ma, f)
args = self.d[:uf.nin]
olderr = numpy.geterr()
f_invalid_ignore = ['sqrt', 'arctanh', 'arcsin', 'arccos',
'arccosh', 'arctanh', 'log', 'log10','divide',
'true_divide', 'floor_divide', 'remainder',
'fmod']
if f in f_invalid_ignore:
numpy.seterr(invalid='ignore')
if f in ['arctanh', 'log', 'log10']:
numpy.seterr(divide='ignore')
ur = uf(*args)
mr = mf(*args)
numpy.seterr(**olderr)
self.failUnless(eq(ur.filled(0), mr.filled(0), f))
self.failUnless(eqmask(ur.mask, mr.mask))
def test_reduce(self):
a = self.d[0]
self.failIf(alltrue(a,axis=0))
self.failUnless(sometrue(a,axis=0))
self.failUnlessEqual(sum(a[:3],axis=0), 0)
self.failUnlessEqual(product(a,axis=0), 0)
def test_minmax(self):
a = arange(1,13).reshape(3,4)
amask = masked_where(a < 5,a)
self.failUnlessEqual(amask.max(), a.max())
self.failUnlessEqual(amask.min(), 5)
self.failUnless((amask.max(0) == a.max(0)).all())
self.failUnless((amask.min(0) == [5,6,7,8]).all())
self.failUnless(amask.max(1)[0].mask)
self.failUnless(amask.min(1)[0].mask)
def test_nonzero(self):
for t in "?bhilqpBHILQPfdgFDGO":
x = array([1,0,2,0], mask=[0,0,1,1])
self.failUnless(eq(nonzero(x), [0]))
class TestArrayMethods(TestCase):
def setUp(self):
x = numpy.array([ 8.375, 7.545, 8.828, 8.5 , 1.757, 5.928,
8.43 , 7.78 , 9.865, 5.878, 8.979, 4.732,
3.012, 6.022, 5.095, 3.116, 5.238, 3.957,
6.04 , 9.63 , 7.712, 3.382, 4.489, 6.479,
7.189, 9.645, 5.395, 4.961, 9.894, 2.893,
7.357, 9.828, 6.272, 3.758, 6.693, 0.993])
X = x.reshape(6,6)
XX = x.reshape(3,2,2,3)
m = numpy.array([0, 1, 0, 1, 0, 0,
1, 0, 1, 1, 0, 1,
0, 0, 0, 1, 0, 1,
0, 0, 0, 1, 1, 1,
1, 0, 0, 1, 0, 0,
0, 0, 1, 0, 1, 0])
mx = array(data=x,mask=m)
mX = array(data=X,mask=m.reshape(X.shape))
mXX = array(data=XX,mask=m.reshape(XX.shape))
m2 = numpy.array([1, 1, 0, 1, 0, 0,
1, 1, 1, 1, 0, 1,
0, 0, 1, 1, 0, 1,
0, 0, 0, 1, 1, 1,
1, 0, 0, 1, 1, 0,
0, 0, 1, 0, 1, 1])
m2x = array(data=x,mask=m2)
m2X = array(data=X,mask=m2.reshape(X.shape))
m2XX = array(data=XX,mask=m2.reshape(XX.shape))
self.d = (x,X,XX,m,mx,mX,mXX)
#------------------------------------------------------
def test_trace(self):
(x,X,XX,m,mx,mX,mXX,) = self.d
mXdiag = mX.diagonal()
self.assertEqual(mX.trace(), mX.diagonal().compressed().sum())
self.failUnless(eq(mX.trace(),
X.trace() - sum(mXdiag.mask*X.diagonal(),axis=0)))
def test_clip(self):
(x,X,XX,m,mx,mX,mXX,) = self.d
clipped = mx.clip(2,8)
self.failUnless(eq(clipped.mask,mx.mask))
self.failUnless(eq(clipped._data,x.clip(2,8)))
self.failUnless(eq(clipped._data,mx._data.clip(2,8)))
def test_ptp(self):
(x,X,XX,m,mx,mX,mXX,) = self.d
(n,m) = X.shape
self.assertEqual(mx.ptp(),mx.compressed().ptp())
rows = numpy.zeros(n,numpy.float_)
cols = numpy.zeros(m,numpy.float_)
for k in range(m):
cols[k] = mX[:,k].compressed().ptp()
for k in range(n):
rows[k] = mX[k].compressed().ptp()
self.failUnless(eq(mX.ptp(0),cols))
self.failUnless(eq(mX.ptp(1),rows))
def test_swapaxes(self):
(x,X,XX,m,mx,mX,mXX,) = self.d
mXswapped = mX.swapaxes(0,1)
self.failUnless(eq(mXswapped[-1],mX[:,-1]))
mXXswapped = mXX.swapaxes(0,2)
self.assertEqual(mXXswapped.shape,(2,2,3,3))
def test_cumprod(self):
(x,X,XX,m,mx,mX,mXX,) = self.d
mXcp = mX.cumprod(0)
self.failUnless(eq(mXcp._data,mX.filled(1).cumprod(0)))
mXcp = mX.cumprod(1)
self.failUnless(eq(mXcp._data,mX.filled(1).cumprod(1)))
def test_cumsum(self):
(x,X,XX,m,mx,mX,mXX,) = self.d
mXcp = mX.cumsum(0)
self.failUnless(eq(mXcp._data,mX.filled(0).cumsum(0)))
mXcp = mX.cumsum(1)
self.failUnless(eq(mXcp._data,mX.filled(0).cumsum(1)))
def test_varstd(self):
(x,X,XX,m,mx,mX,mXX,) = self.d
self.failUnless(eq(mX.var(axis=None),mX.compressed().var()))
self.failUnless(eq(mX.std(axis=None),mX.compressed().std()))
self.failUnless(eq(mXX.var(axis=3).shape,XX.var(axis=3).shape))
self.failUnless(eq(mX.var().shape,X.var().shape))
(mXvar0,mXvar1) = (mX.var(axis=0), mX.var(axis=1))
for k in range(6):
self.failUnless(eq(mXvar1[k],mX[k].compressed().var()))
self.failUnless(eq(mXvar0[k],mX[:,k].compressed().var()))
self.failUnless(eq(numpy.sqrt(mXvar0[k]),
mX[:,k].compressed().std()))
def eqmask(m1, m2):
if m1 is nomask:
return m2 is nomask
if m2 is nomask:
return m1 is nomask
return (m1 == m2).all()
#def timingTest():
# for f in [testf, testinplace]:
# for n in [1000,10000,50000]:
# t = testta(n, f)
# t1 = testtb(n, f)
# t2 = testtc(n, f)
# print f.test_name
# print """\
#n = %7d
#numpy time (ms) %6.1f
#MA maskless ratio %6.1f
#MA masked ratio %6.1f
#""" % (n, t*1000.0, t1/t, t2/t)
#def testta(n, f):
# x=numpy.arange(n) + 1.0
# tn0 = time.time()
# z = f(x)
# return time.time() - tn0
#def testtb(n, f):
# x=arange(n) + 1.0
# tn0 = time.time()
# z = f(x)
# return time.time() - tn0
#def testtc(n, f):
# x=arange(n) + 1.0
# x[0] = masked
# tn0 = time.time()
# z = f(x)
# return time.time() - tn0
#def testf(x):
# for i in range(25):
# y = x **2 + 2.0 * x - 1.0
# w = x **2 + 1.0
# z = (y / w) ** 2
# return z
#testf.test_name = 'Simple arithmetic'
#def testinplace(x):
# for i in range(25):
# y = x**2
# y += 2.0*x
# y -= 1.0
# y /= x
# return y
#testinplace.test_name = 'Inplace operations'
if __name__ == "__main__":
run_module_suite()
|