Viewing file:  test_extras.py (30.7 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
# pylint: disable-msg=W0611, W0612, W0511
"""Tests suite for MaskedArray.
Adapted from the original test_ma by Pierre Gerard-Marchant
:author: Pierre Gerard-Marchant
:contact: pierregm_at_uga_dot_edu
:version: $Id: test_extras.py 3473 2007-10-29 15:18:13Z jarrod.millman $
"""
__author__ = "Pierre GF Gerard-Marchant ($Author: jarrod.millman $)"
__version__ = '1.0'
__revision__ = "$Revision: 3473 $"
__date__ = '$Date: 2007-10-29 17:18:13 +0200 (Mon, 29 Oct 2007) $'
import numpy as np
from numpy.testing import TestCase, run_module_suite
from numpy.ma.testutils import *
from numpy.ma.core import *
from numpy.ma.extras import *
class TestGeneric(TestCase):
#
def test_masked_all(self):
"Tests masked_all"
# Standard dtype
test = masked_all((2,), dtype=float)
control = array([1, 1], mask=[1, 1], dtype=float)
assert_equal(test, control)
# Flexible dtype
dt = np.dtype({'names': ['a', 'b'], 'formats': ['f', 'f']})
test = masked_all((2,), dtype=dt)
control = array([(0, 0), (0, 0)], mask=[(1, 1), (1, 1)], dtype=dt)
assert_equal(test, control)
test = masked_all((2,2), dtype=dt)
control = array([[(0, 0), (0, 0)], [(0, 0), (0, 0)]],
mask=[[(1, 1), (1, 1)], [(1, 1), (1, 1)]],
dtype=dt)
assert_equal(test, control)
# Nested dtype
dt = np.dtype([('a','f'), ('b', [('ba', 'f'), ('bb', 'f')])])
test = masked_all((2,), dtype=dt)
control = array([(1, (1, 1)), (1, (1, 1))],
mask=[(1, (1, 1)), (1, (1, 1))], dtype=dt)
assert_equal(test, control)
test = masked_all((2,), dtype=dt)
control = array([(1, (1, 1)), (1, (1, 1))],
mask=[(1, (1, 1)), (1, (1, 1))], dtype=dt)
assert_equal(test, control)
test = masked_all((1,1), dtype=dt)
control = array([[(1, (1, 1))]], mask=[[(1, (1, 1))]], dtype=dt)
assert_equal(test, control)
def test_masked_all_like(self):
"Tests masked_all"
# Standard dtype
base = array([1, 2], dtype=float)
test = masked_all_like(base)
control = array([1, 1], mask=[1, 1], dtype=float)
assert_equal(test, control)
# Flexible dtype
dt = np.dtype({'names': ['a', 'b'], 'formats': ['f', 'f']})
base = array([(0, 0), (0, 0)], mask=[(1, 1), (1, 1)], dtype=dt)
test = masked_all_like(base)
control = array([(10, 10), (10, 10)], mask=[(1, 1), (1, 1)], dtype=dt)
assert_equal(test, control)
# Nested dtype
dt = np.dtype([('a','f'), ('b', [('ba', 'f'), ('bb', 'f')])])
control = array([(1, (1, 1)), (1, (1, 1))],
mask=[(1, (1, 1)), (1, (1, 1))], dtype=dt)
test = masked_all_like(control)
assert_equal(test, control)
def test_clump_masked(self):
"Test clump_masked"
a = masked_array(np.arange(10))
a[[0, 1, 2, 6, 8, 9]] = masked
#
test = clump_masked(a)
control = [slice(0, 3), slice(6, 7), slice(8, 10)]
assert_equal(test, control)
def test_clump_unmasked(self):
"Test clump_unmasked"
a = masked_array(np.arange(10))
a[[0, 1, 2, 6, 8, 9]] = masked
test = clump_unmasked(a)
control = [slice(3, 6), slice(7, 8),]
assert_equal(test, control)
class TestAverage(TestCase):
"Several tests of average. Why so many ? Good point..."
def test_testAverage1(self):
"Test of average."
ott = array([0.,1.,2.,3.], mask=[True, False, False, False])
assert_equal(2.0, average(ott, axis=0))
assert_equal(2.0, average(ott, weights=[1., 1., 2., 1.]))
result, wts = average(ott, weights=[1., 1., 2., 1.], returned=1)
assert_equal(2.0, result)
self.failUnless(wts == 4.0)
ott[:] = masked
assert_equal(average(ott, axis=0).mask, [True])
ott = array([0., 1., 2., 3.], mask=[True, False, False, False])
ott = ott.reshape(2, 2)
ott[:,1] = masked
assert_equal(average(ott, axis=0), [2.0, 0.0])
assert_equal(average(ott, axis=1).mask[0], [True])
assert_equal([2.,0.], average(ott, axis=0))
result, wts = average(ott, axis=0, returned=1)
assert_equal(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, dtype=float_)
assert_equal(average(x, axis=0), 2.5)
assert_equal(average(x, axis=0, weights=w1), 2.5)
y = array([arange(6, dtype=float_), 2.0*arange(6)])
assert_equal(average(y, None), np.add.reduce(np.arange(6))*3./12.)
assert_equal(average(y, axis=0), np.arange(6) * 3./2.)
assert_equal(average(y, axis=1),
[average(x, axis=0), average(x, axis=0) * 2.0])
assert_equal(average(y, None, weights=w2), 20./6.)
assert_equal(average(y, axis=0, weights=w2),
[0.,1.,2.,3.,4.,10.])
assert_equal(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]
assert_equal(average(masked_array(x, m1), axis=0), 2.5)
assert_equal(average(masked_array(x, m2), axis=0), 2.5)
assert_equal(average(masked_array(x, m4), axis=0).mask, [True])
assert_equal(average(masked_array(x, m5), axis=0), 0.0)
assert_equal(count(average(masked_array(x, m4), axis=0)), 0)
z = masked_array(y, m3)
assert_equal(average(z, None), 20./6.)
assert_equal(average(z, axis=0), [0.,1.,99.,99.,4.0, 7.5])
assert_equal(average(z, axis=1), [2.5, 5.0])
assert_equal(average(z,axis=0, weights=w2),
[0.,1., 99., 99., 4.0, 10.0])
def test_testAverage3(self):
"Yet more tests of average!"
a = arange(6)
b = arange(6) * 3
r1, w1 = average([[a, b], [b, a]], axis=1, returned=1)
assert_equal(shape(r1) , shape(w1))
assert_equal(r1.shape , w1.shape)
r2, w2 = average(ones((2, 2, 3)), axis=0, weights=[3, 1], returned=1)
assert_equal(shape(w2) , shape(r2))
r2, w2 = average(ones((2, 2, 3)), returned=1)
assert_equal(shape(w2) , shape(r2))
r2, w2 = average(ones((2, 2, 3)), weights=ones((2, 2, 3)), returned=1)
assert_equal(shape(w2), shape(r2))
a2d = array([[1, 2], [0, 4]], float)
a2dm = masked_array(a2d, [[False, False],[True, False]])
a2da = average(a2d, axis=0)
assert_equal(a2da, [0.5, 3.0])
a2dma = average(a2dm, axis=0)
assert_equal(a2dma, [1.0, 3.0])
a2dma = average(a2dm, axis=None)
assert_equal(a2dma, 7./3.)
a2dma = average(a2dm, axis=1)
assert_equal(a2dma, [1.5, 4.0])
def test_onintegers_with_mask(self):
"Test average on integers with mask"
a = average(array([1, 2]))
assert_equal(a, 1.5)
a = average(array([1, 2, 3, 4], mask=[False, False, True, True]))
assert_equal(a, 1.5)
class TestConcatenator(TestCase):
"""
Tests for mr_, the equivalent of r_ for masked arrays.
"""
def test_1d(self):
"Tests mr_ on 1D arrays."
assert_array_equal(mr_[1,2,3,4,5,6],array([1,2,3,4,5,6]))
b = ones(5)
m = [1,0,0,0,0]
d = masked_array(b,mask=m)
c = mr_[d,0,0,d]
self.failUnless(isinstance(c,MaskedArray) or isinstance(c,core.MaskedArray))
assert_array_equal(c,[1,1,1,1,1,0,0,1,1,1,1,1])
assert_array_equal(c.mask, mr_[m,0,0,m])
def test_2d(self):
"Tests mr_ on 2D arrays."
a_1 = rand(5,5)
a_2 = rand(5,5)
m_1 = np.round_(rand(5,5),0)
m_2 = np.round_(rand(5,5),0)
b_1 = masked_array(a_1,mask=m_1)
b_2 = masked_array(a_2,mask=m_2)
d = mr_['1',b_1,b_2] # append columns
self.failUnless(d.shape == (5,10))
assert_array_equal(d[:,:5],b_1)
assert_array_equal(d[:,5:],b_2)
assert_array_equal(d.mask, np.r_['1',m_1,m_2])
d = mr_[b_1,b_2]
self.failUnless(d.shape == (10,5))
assert_array_equal(d[:5,:],b_1)
assert_array_equal(d[5:,:],b_2)
assert_array_equal(d.mask, np.r_[m_1,m_2])
class TestNotMasked(TestCase):
"""
Tests notmasked_edges and notmasked_contiguous.
"""
def test_edges(self):
"Tests unmasked_edges"
data = masked_array(np.arange(25).reshape(5, 5),
mask=[[0, 0, 1, 0, 0],
[0, 0, 0, 1, 1],
[1, 1, 0, 0, 0],
[0, 0, 0, 0, 0],
[1, 1, 1, 0, 0]],)
test = notmasked_edges(data, None)
assert_equal(test, [0, 24])
test = notmasked_edges(data, 0)
assert_equal(test[0], [(0, 0, 1, 0, 0), (0, 1, 2, 3, 4)])
assert_equal(test[1], [(3, 3, 3, 4, 4), (0, 1, 2, 3, 4)])
test = notmasked_edges(data, 1)
assert_equal(test[0], [(0, 1, 2, 3, 4), (0, 0, 2, 0, 3)])
assert_equal(test[1], [(0, 1, 2, 3, 4), (4, 2, 4, 4, 4)])
#
test = notmasked_edges(data.data, None)
assert_equal(test, [0, -1])
test = notmasked_edges(data.data, 0)
assert_equal(test[0], [(0, 0, 0, 0, 0), (0, 1, 2, 3, 4)])
assert_equal(test[1], [(4, 4, 4, 4, 4), (0, 1, 2, 3, 4)])
test = notmasked_edges(data.data, -1)
assert_equal(test[0], [(0, 1, 2, 3, 4), (0, 0, 0, 0, 0)])
assert_equal(test[1], [(0, 1, 2, 3, 4), (4, 4, 4, 4, 4)])
#
data[-2] = masked
test = notmasked_edges(data, 0)
assert_equal(test[0], [(0, 0, 1, 0, 0), (0, 1, 2, 3, 4)])
assert_equal(test[1], [(1, 1, 2, 4, 4), (0, 1, 2, 3, 4)])
test = notmasked_edges(data, -1)
assert_equal(test[0], [(0, 1, 2, 4), (0, 0, 2, 3)])
assert_equal(test[1], [(0, 1, 2, 4), (4, 2, 4, 4)])
def test_contiguous(self):
"Tests notmasked_contiguous"
a = masked_array(np.arange(24).reshape(3,8),
mask=[[0,0,0,0,1,1,1,1],
[1,1,1,1,1,1,1,1],
[0,0,0,0,0,0,1,0],])
tmp = notmasked_contiguous(a, None)
assert_equal(tmp[-1], slice(23,23,None))
assert_equal(tmp[-2], slice(16,21,None))
assert_equal(tmp[-3], slice(0,3,None))
#
tmp = notmasked_contiguous(a, 0)
self.failUnless(len(tmp[-1]) == 1)
self.failUnless(tmp[-2] is None)
assert_equal(tmp[-3],tmp[-1])
self.failUnless(len(tmp[0]) == 2)
#
tmp = notmasked_contiguous(a, 1)
assert_equal(tmp[0][-1], slice(0,3,None))
self.failUnless(tmp[1] is None)
assert_equal(tmp[2][-1], slice(7,7,None))
assert_equal(tmp[2][-2], slice(0,5,None))
class Test2DFunctions(TestCase):
"Tests 2D functions"
def test_compress2d(self):
"Tests compress2d"
x = array(np.arange(9).reshape(3,3), mask=[[1,0,0],[0,0,0],[0,0,0]])
assert_equal(compress_rowcols(x), [[4,5],[7,8]] )
assert_equal(compress_rowcols(x,0), [[3,4,5],[6,7,8]] )
assert_equal(compress_rowcols(x,1), [[1,2],[4,5],[7,8]] )
x = array(x._data, mask=[[0,0,0],[0,1,0],[0,0,0]])
assert_equal(compress_rowcols(x), [[0,2],[6,8]] )
assert_equal(compress_rowcols(x,0), [[0,1,2],[6,7,8]] )
assert_equal(compress_rowcols(x,1), [[0,2],[3,5],[6,8]] )
x = array(x._data, mask=[[1,0,0],[0,1,0],[0,0,0]])
assert_equal(compress_rowcols(x), [[8]] )
assert_equal(compress_rowcols(x,0), [[6,7,8]] )
assert_equal(compress_rowcols(x,1,), [[2],[5],[8]] )
x = array(x._data, mask=[[1,0,0],[0,1,0],[0,0,1]])
assert_equal(compress_rowcols(x).size, 0 )
assert_equal(compress_rowcols(x,0).size, 0 )
assert_equal(compress_rowcols(x,1).size, 0 )
#
def test_mask_rowcols(self):
"Tests mask_rowcols."
x = array(np.arange(9).reshape(3,3), mask=[[1,0,0],[0,0,0],[0,0,0]])
assert_equal(mask_rowcols(x).mask, [[1,1,1],[1,0,0],[1,0,0]] )
assert_equal(mask_rowcols(x,0).mask, [[1,1,1],[0,0,0],[0,0,0]] )
assert_equal(mask_rowcols(x,1).mask, [[1,0,0],[1,0,0],[1,0,0]] )
x = array(x._data, mask=[[0,0,0],[0,1,0],[0,0,0]])
assert_equal(mask_rowcols(x).mask, [[0,1,0],[1,1,1],[0,1,0]] )
assert_equal(mask_rowcols(x,0).mask, [[0,0,0],[1,1,1],[0,0,0]] )
assert_equal(mask_rowcols(x,1).mask, [[0,1,0],[0,1,0],[0,1,0]] )
x = array(x._data, mask=[[1,0,0],[0,1,0],[0,0,0]])
assert_equal(mask_rowcols(x).mask, [[1,1,1],[1,1,1],[1,1,0]] )
assert_equal(mask_rowcols(x,0).mask, [[1,1,1],[1,1,1],[0,0,0]] )
assert_equal(mask_rowcols(x,1,).mask, [[1,1,0],[1,1,0],[1,1,0]] )
x = array(x._data, mask=[[1,0,0],[0,1,0],[0,0,1]])
self.failUnless(mask_rowcols(x).all() is masked)
self.failUnless(mask_rowcols(x,0).all() is masked)
self.failUnless(mask_rowcols(x,1).all() is masked)
self.failUnless(mask_rowcols(x).mask.all())
self.failUnless(mask_rowcols(x,0).mask.all())
self.failUnless(mask_rowcols(x,1).mask.all())
#
def test_dot(self):
"Tests dot product"
n = np.arange(1,7)
#
m = [1,0,0,0,0,0]
a = masked_array(n, mask=m).reshape(2,3)
b = masked_array(n, mask=m).reshape(3,2)
c = dot(a,b,True)
assert_equal(c.mask, [[1,1],[1,0]])
c = dot(b,a,True)
assert_equal(c.mask, [[1,1,1],[1,0,0],[1,0,0]])
c = dot(a,b,False)
assert_equal(c, np.dot(a.filled(0), b.filled(0)))
c = dot(b,a,False)
assert_equal(c, np.dot(b.filled(0), a.filled(0)))
#
m = [0,0,0,0,0,1]
a = masked_array(n, mask=m).reshape(2,3)
b = masked_array(n, mask=m).reshape(3,2)
c = dot(a,b,True)
assert_equal(c.mask,[[0,1],[1,1]])
c = dot(b,a,True)
assert_equal(c.mask, [[0,0,1],[0,0,1],[1,1,1]])
c = dot(a,b,False)
assert_equal(c, np.dot(a.filled(0), b.filled(0)))
assert_equal(c, dot(a,b))
c = dot(b,a,False)
assert_equal(c, np.dot(b.filled(0), a.filled(0)))
#
m = [0,0,0,0,0,0]
a = masked_array(n, mask=m).reshape(2,3)
b = masked_array(n, mask=m).reshape(3,2)
c = dot(a,b)
assert_equal(c.mask,nomask)
c = dot(b,a)
assert_equal(c.mask,nomask)
#
a = masked_array(n, mask=[1,0,0,0,0,0]).reshape(2,3)
b = masked_array(n, mask=[0,0,0,0,0,0]).reshape(3,2)
c = dot(a,b,True)
assert_equal(c.mask,[[1,1],[0,0]])
c = dot(a,b,False)
assert_equal(c, np.dot(a.filled(0),b.filled(0)))
c = dot(b,a,True)
assert_equal(c.mask,[[1,0,0],[1,0,0],[1,0,0]])
c = dot(b,a,False)
assert_equal(c, np.dot(b.filled(0),a.filled(0)))
#
a = masked_array(n, mask=[0,0,0,0,0,1]).reshape(2,3)
b = masked_array(n, mask=[0,0,0,0,0,0]).reshape(3,2)
c = dot(a,b,True)
assert_equal(c.mask,[[0,0],[1,1]])
c = dot(a,b)
assert_equal(c, np.dot(a.filled(0),b.filled(0)))
c = dot(b,a,True)
assert_equal(c.mask,[[0,0,1],[0,0,1],[0,0,1]])
c = dot(b,a,False)
assert_equal(c, np.dot(b.filled(0), a.filled(0)))
#
a = masked_array(n, mask=[0,0,0,0,0,1]).reshape(2,3)
b = masked_array(n, mask=[0,0,1,0,0,0]).reshape(3,2)
c = dot(a,b,True)
assert_equal(c.mask,[[1,0],[1,1]])
c = dot(a,b,False)
assert_equal(c, np.dot(a.filled(0),b.filled(0)))
c = dot(b,a,True)
assert_equal(c.mask,[[0,0,1],[1,1,1],[0,0,1]])
c = dot(b,a,False)
assert_equal(c, np.dot(b.filled(0),a.filled(0)))
class TestApplyAlongAxis(TestCase):
#
"Tests 2D functions"
def test_3d(self):
a = arange(12.).reshape(2,2,3)
def myfunc(b):
return b[1]
xa = apply_along_axis(myfunc,2,a)
assert_equal(xa,[[1,4],[7,10]])
class TestMedian(TestCase):
#
def test_2d(self):
"Tests median w/ 2D"
(n,p) = (101,30)
x = masked_array(np.linspace(-1.,1.,n),)
x[:10] = x[-10:] = masked
z = masked_array(np.empty((n,p), dtype=float))
z[:,0] = x[:]
idx = np.arange(len(x))
for i in range(1,p):
np.random.shuffle(idx)
z[:,i] = x[idx]
assert_equal(median(z[:,0]), 0)
assert_equal(median(z), 0)
assert_equal(median(z, axis=0), np.zeros(p))
assert_equal(median(z.T, axis=1), np.zeros(p))
#
def test_2d_waxis(self):
"Tests median w/ 2D arrays and different axis."
x = masked_array(np.arange(30).reshape(10,3))
x[:3] = x[-3:] = masked
assert_equal(median(x), 14.5)
assert_equal(median(x, axis=0), [13.5,14.5,15.5])
assert_equal(median(x,axis=1), [0,0,0,10,13,16,19,0,0,0])
assert_equal(median(x,axis=1).mask, [1,1,1,0,0,0,0,1,1,1])
#
def test_3d(self):
"Tests median w/ 3D"
x = np.ma.arange(24).reshape(3,4,2)
x[x%3==0] = masked
assert_equal(median(x,0), [[12,9],[6,15],[12,9],[18,15]])
x.shape = (4,3,2)
assert_equal(median(x,0),[[99,10],[11,99],[13,14]])
x = np.ma.arange(24).reshape(4,3,2)
x[x%5==0] = masked
assert_equal(median(x,0), [[12,10],[8,9],[16,17]])
class TestCov(TestCase):
def setUp(self):
self.data = array(np.random.rand(12))
def test_1d_wo_missing(self):
"Test cov on 1D variable w/o missing values"
x = self.data
assert_almost_equal(np.cov(x), cov(x))
assert_almost_equal(np.cov(x, rowvar=False), cov(x, rowvar=False))
assert_almost_equal(np.cov(x, rowvar=False, bias=True),
cov(x, rowvar=False, bias=True))
def test_2d_wo_missing(self):
"Test cov on 1 2D variable w/o missing values"
x = self.data.reshape(3,4)
assert_almost_equal(np.cov(x), cov(x))
assert_almost_equal(np.cov(x, rowvar=False), cov(x, rowvar=False))
assert_almost_equal(np.cov(x, rowvar=False, bias=True),
cov(x, rowvar=False, bias=True))
def test_1d_w_missing(self):
"Test cov 1 1D variable w/missing values"
x = self.data
x[-1] = masked
x -= x.mean()
nx = x.compressed()
assert_almost_equal(np.cov(nx), cov(x))
assert_almost_equal(np.cov(nx, rowvar=False), cov(x, rowvar=False))
assert_almost_equal(np.cov(nx, rowvar=False, bias=True),
cov(x, rowvar=False, bias=True))
#
try:
cov(x, allow_masked=False)
except ValueError:
pass
#
# 2 1D variables w/ missing values
nx = x[1:-1]
assert_almost_equal(np.cov(nx, nx[::-1]), cov(x, x[::-1]))
assert_almost_equal(np.cov(nx, nx[::-1], rowvar=False),
cov(x, x[::-1], rowvar=False))
assert_almost_equal(np.cov(nx, nx[::-1], rowvar=False, bias=True),
cov(x, x[::-1], rowvar=False, bias=True))
def test_2d_w_missing(self):
"Test cov on 2D variable w/ missing value"
x = self.data
x[-1] = masked
x = x.reshape(3,4)
valid = np.logical_not(getmaskarray(x)).astype(int)
frac = np.dot(valid, valid.T)
xf = (x - x.mean(1)[:,None]).filled(0)
assert_almost_equal(cov(x), np.cov(xf) * (x.shape[1]-1) / (frac - 1.))
assert_almost_equal(cov(x, bias=True),
np.cov(xf, bias=True) * x.shape[1] / frac)
frac = np.dot(valid.T, valid)
xf = (x - x.mean(0)).filled(0)
assert_almost_equal(cov(x, rowvar=False),
np.cov(xf, rowvar=False) * (x.shape[0]-1)/(frac - 1.))
assert_almost_equal(cov(x, rowvar=False, bias=True),
np.cov(xf, rowvar=False, bias=True) * x.shape[0]/frac)
class TestCorrcoef(TestCase):
def setUp(self):
self.data = array(np.random.rand(12))
def test_1d_wo_missing(self):
"Test cov on 1D variable w/o missing values"
x = self.data
assert_almost_equal(np.corrcoef(x), corrcoef(x))
assert_almost_equal(np.corrcoef(x, rowvar=False),
corrcoef(x, rowvar=False))
assert_almost_equal(np.corrcoef(x, rowvar=False, bias=True),
corrcoef(x, rowvar=False, bias=True))
def test_2d_wo_missing(self):
"Test corrcoef on 1 2D variable w/o missing values"
x = self.data.reshape(3,4)
assert_almost_equal(np.corrcoef(x), corrcoef(x))
assert_almost_equal(np.corrcoef(x, rowvar=False),
corrcoef(x, rowvar=False))
assert_almost_equal(np.corrcoef(x, rowvar=False, bias=True),
corrcoef(x, rowvar=False, bias=True))
def test_1d_w_missing(self):
"Test corrcoef 1 1D variable w/missing values"
x = self.data
x[-1] = masked
x -= x.mean()
nx = x.compressed()
assert_almost_equal(np.corrcoef(nx), corrcoef(x))
assert_almost_equal(np.corrcoef(nx, rowvar=False), corrcoef(x, rowvar=False))
assert_almost_equal(np.corrcoef(nx, rowvar=False, bias=True),
corrcoef(x, rowvar=False, bias=True))
#
try:
corrcoef(x, allow_masked=False)
except ValueError:
pass
#
# 2 1D variables w/ missing values
nx = x[1:-1]
assert_almost_equal(np.corrcoef(nx, nx[::-1]), corrcoef(x, x[::-1]))
assert_almost_equal(np.corrcoef(nx, nx[::-1], rowvar=False),
corrcoef(x, x[::-1], rowvar=False))
assert_almost_equal(np.corrcoef(nx, nx[::-1], rowvar=False, bias=True),
corrcoef(x, x[::-1], rowvar=False, bias=True))
def test_2d_w_missing(self):
"Test corrcoef on 2D variable w/ missing value"
x = self.data
x[-1] = masked
x = x.reshape(3,4)
test = corrcoef(x)
control = np.corrcoef(x)
assert_almost_equal(test[:-1,:-1], control[:-1,:-1])
class TestPolynomial(TestCase):
#
def test_polyfit(self):
"Tests polyfit"
# On ndarrays
x = np.random.rand(10)
y = np.random.rand(20).reshape(-1,2)
assert_almost_equal(polyfit(x,y,3),np.polyfit(x,y,3))
# ON 1D maskedarrays
x = x.view(MaskedArray)
x[0] = masked
y = y.view(MaskedArray)
y[0,0] = y[-1,-1] = masked
#
(C,R,K,S,D) = polyfit(x,y[:,0],3,full=True)
(c,r,k,s,d) = np.polyfit(x[1:], y[1:,0].compressed(), 3, full=True)
for (a,a_) in zip((C,R,K,S,D),(c,r,k,s,d)):
assert_almost_equal(a, a_)
#
(C,R,K,S,D) = polyfit(x,y[:,-1],3,full=True)
(c,r,k,s,d) = np.polyfit(x[1:-1], y[1:-1,-1], 3, full=True)
for (a,a_) in zip((C,R,K,S,D),(c,r,k,s,d)):
assert_almost_equal(a, a_)
#
(C,R,K,S,D) = polyfit(x,y,3,full=True)
(c,r,k,s,d) = np.polyfit(x[1:-1], y[1:-1,:], 3, full=True)
for (a,a_) in zip((C,R,K,S,D),(c,r,k,s,d)):
assert_almost_equal(a, a_)
class TestArraySetOps(TestCase):
#
def test_unique_onlist(self):
"Test unique on list"
data = [1, 1, 1, 2, 2, 3]
test = unique(data, return_index=True, return_inverse=True)
self.failUnless(isinstance(test[0], MaskedArray))
assert_equal(test[0], masked_array([1, 2, 3], mask=[0, 0, 0]))
assert_equal(test[1], [0, 3, 5])
assert_equal(test[2], [0, 0, 0, 1, 1, 2])
def test_unique_onmaskedarray(self):
"Test unique on masked data w/use_mask=True"
data = masked_array([1, 1, 1, 2, 2, 3], mask=[0, 0, 1, 0, 1, 0])
test = unique(data, return_index=True, return_inverse=True)
assert_equal(test[0], masked_array([1, 2, 3, -1], mask=[0, 0, 0, 1]))
assert_equal(test[1], [0, 3, 5, 2])
assert_equal(test[2], [0, 0, 3, 1, 3, 2])
#
data.fill_value = 3
data = masked_array([1, 1, 1, 2, 2, 3],
mask=[0, 0, 1, 0, 1, 0], fill_value=3)
test = unique(data, return_index=True, return_inverse=True)
assert_equal(test[0], masked_array([1, 2, 3, -1], mask=[0, 0, 0, 1]))
assert_equal(test[1], [0, 3, 5, 2])
assert_equal(test[2], [0, 0, 3, 1, 3, 2])
def test_unique_allmasked(self):
"Test all masked"
data = masked_array([1, 1, 1], mask=True)
test = unique(data, return_index=True, return_inverse=True)
assert_equal(test[0], masked_array([1,], mask=[True]))
assert_equal(test[1], [0])
assert_equal(test[2], [0, 0, 0])
#
"Test masked"
data = masked
test = unique(data, return_index=True, return_inverse=True)
assert_equal(test[0], masked_array(masked))
assert_equal(test[1], [0])
assert_equal(test[2], [0])
def test_ediff1d(self):
"Tests mediff1d"
x = masked_array(np.arange(5), mask=[1,0,0,0,1])
control = array([1, 1, 1, 4], mask=[1, 0, 0, 1])
test = ediff1d(x)
assert_equal(test, control)
assert_equal(test.data, control.data)
assert_equal(test.mask, control.mask)
#
def test_ediff1d_tobegin(self):
"Test ediff1d w/ to_begin"
x = masked_array(np.arange(5), mask=[1,0,0,0,1])
test = ediff1d(x, to_begin=masked)
control = array([0, 1, 1, 1, 4], mask=[1, 1, 0, 0, 1])
assert_equal(test, control)
assert_equal(test.data, control.data)
assert_equal(test.mask, control.mask)
#
test = ediff1d(x, to_begin=[1,2,3])
control = array([1, 2, 3, 1, 1, 1, 4], mask=[0, 0, 0, 1, 0, 0, 1])
assert_equal(test, control)
assert_equal(test.data, control.data)
assert_equal(test.mask, control.mask)
#
def test_ediff1d_toend(self):
"Test ediff1d w/ to_end"
x = masked_array(np.arange(5), mask=[1,0,0,0,1])
test = ediff1d(x, to_end=masked)
control = array([1, 1, 1, 4, 0], mask=[1, 0, 0, 1, 1])
assert_equal(test, control)
assert_equal(test.data, control.data)
assert_equal(test.mask, control.mask)
#
test = ediff1d(x, to_end=[1,2,3])
control = array([1, 1, 1, 4, 1, 2, 3], mask=[1, 0, 0, 1, 0, 0, 0])
assert_equal(test, control)
assert_equal(test.data, control.data)
assert_equal(test.mask, control.mask)
#
def test_ediff1d_tobegin_toend(self):
"Test ediff1d w/ to_begin and to_end"
x = masked_array(np.arange(5), mask=[1,0,0,0,1])
test = ediff1d(x, to_end=masked, to_begin=masked)
control = array([0, 1, 1, 1, 4, 0], mask=[1, 1, 0, 0, 1, 1])
assert_equal(test, control)
assert_equal(test.data, control.data)
assert_equal(test.mask, control.mask)
#
test = ediff1d(x, to_end=[1,2,3], to_begin=masked)
control = array([0, 1, 1, 1, 4, 1, 2, 3], mask=[1, 1, 0, 0, 1, 0, 0, 0])
assert_equal(test, control)
assert_equal(test.data, control.data)
assert_equal(test.mask, control.mask)
#
def test_ediff1d_ndarray(self):
"Test ediff1d w/ a ndarray"
x = np.arange(5)
test = ediff1d(x)
control = array([1, 1, 1, 1], mask=[0, 0, 0, 0])
assert_equal(test, control)
self.failUnless(isinstance(test, MaskedArray))
assert_equal(test.data, control.data)
assert_equal(test.mask, control.mask)
#
test = ediff1d(x, to_end=masked, to_begin=masked)
control = array([0, 1, 1, 1, 1, 0], mask=[1, 0, 0, 0, 0, 1])
self.failUnless(isinstance(test, MaskedArray))
assert_equal(test.data, control.data)
assert_equal(test.mask, control.mask)
def test_intersect1d(self):
"Test intersect1d"
x = array([1, 3, 3, 3], mask=[0, 0, 0, 1])
y = array([3, 1, 1, 1], mask=[0, 0, 0, 1])
test = intersect1d(x, y)
control = array([1, 3, -1], mask=[0, 0, 1])
assert_equal(test, control)
def test_setxor1d(self):
"Test setxor1d"
a = array([1, 2, 5, 7, -1], mask=[0, 0, 0, 0, 1])
b = array([1, 2, 3, 4, 5, -1], mask=[0, 0, 0, 0, 0, 1])
test = setxor1d(a, b)
assert_equal(test, array([3, 4, 7]))
#
a = array([1, 2, 5, 7, -1], mask=[0, 0, 0, 0, 1])
b = [1, 2, 3, 4, 5]
test = setxor1d(a, b)
assert_equal(test, array([3, 4, 7, -1], mask=[0, 0, 0, 1]))
#
a = array( [1, 2, 3] )
b = array( [6, 5, 4] )
test = setxor1d(a, b)
assert(isinstance(test, MaskedArray))
assert_equal(test, [1, 2, 3, 4, 5, 6])
#
a = array([1, 8, 2, 3], mask=[0, 1, 0, 0])
b = array([6, 5, 4, 8], mask=[0, 0, 0, 1])
test = setxor1d(a, b)
assert(isinstance(test, MaskedArray))
assert_equal(test, [1, 2, 3, 4, 5, 6])
#
assert_array_equal([], setxor1d([],[]))
def test_in1d( self ):
"Test in1d"
a = array([1, 2, 5, 7, -1], mask=[0, 0, 0, 0, 1])
b = array([1, 2, 3, 4, 5, -1], mask=[0, 0, 0, 0, 0, 1])
test = in1d(a, b)
assert_equal(test, [True, True, True, False, True])
#
a = array([5, 5, 2, 1, -1], mask=[0, 0, 0, 0, 1])
b = array([1, 5, -1], mask=[0, 0, 1])
test = in1d(a, b)
assert_equal(test, [True, True, False, True, True])
#
assert_array_equal([], in1d([],[]))
def test_union1d( self ):
"Test union1d"
a = array([1, 2, 5, 7, 5, -1], mask=[0, 0, 0, 0, 0, 1])
b = array([1, 2, 3, 4, 5, -1], mask=[0, 0, 0, 0, 0, 1])
test = union1d(a, b)
control = array([1, 2, 3, 4, 5, 7, -1], mask=[0, 0, 0, 0, 0, 0, 1])
assert_equal(test, control)
#
assert_array_equal([], union1d([],[]))
def test_setdiff1d( self ):
"Test setdiff1d"
a = array([6, 5, 4, 7, 7, 1, 2, 1], mask=[0, 0, 0, 0, 0, 0, 0, 1])
b = array([2, 4, 3, 3, 2, 1, 5])
test = setdiff1d(a, b)
assert_equal(test, array([6, 7, -1], mask=[0, 0, 1]))
#
a = arange(10)
b = arange(8)
assert_equal(setdiff1d(a, b), array([8, 9]))
def test_setdiff1d_char_array(self):
"Test setdiff1d_charray"
a = np.array(['a','b','c'])
b = np.array(['a','b','s'])
assert_array_equal(setdiff1d(a,b), np.array(['c']))
class TestShapeBase(TestCase):
#
def test_atleast1d(self):
pass
###############################################################################
#------------------------------------------------------------------------------
if __name__ == "__main__":
run_module_suite()
|