def test_view_flexible_type(self):
(mrec, a, b, arr) = self.data
alttype = [('A', np.float), ('B', np.float)]
test = mrec.view(alttype)
self.assertTrue(isinstance(test, MaskedRecords))
assert_equal_records(test, arr.view(alttype))
self.assertTrue(test['B'][3] is masked)
assert_equal(test.dtype, np.dtype(alttype))
self.assertTrue(test._fill_value is None)
def test_view_flexible_type(self):
(mrec, a, b, arr) = self.data
alttype = [('A', np.float), ('B', np.float)]
test = mrec.view(alttype)
assert_(isinstance(test, MaskedRecords))
assert_equal_records(test, arr.view(alttype))
assert_(test['B'][3] is masked)
assert_equal(test.dtype, np.dtype(alttype))
assert_(test._fill_value is None)
def test_fromarrays(self):
_a = ma.array([1, 2, 3], mask=[0, 0, 1], dtype=int)
_b = ma.array([1.1, 2.2, 3.3], mask=[0, 0, 1], dtype=float)
_c = ma.array(['one', 'two', 'three'], mask=[0, 0, 1], dtype='|S8')
(mrec, nrec, _) = self.data
for (f, l) in zip(('a', 'b', 'c'), (_a, _b, _c)):
assert_equal(getattr(mrec, f)._mask, l._mask)
# One record only
_x = ma.array([1, 1.1, 'one'], mask=[1, 0, 0],)
assert_equal_records(fromarrays(_x, dtype=mrec.dtype), mrec[0])
def test_fromarrays(self):
_a = ma.array([1, 2, 3], mask=[0, 0, 1], dtype=int)
_b = ma.array([1.1, 2.2, 3.3], mask=[0, 0, 1], dtype=float)
_c = ma.array(['one', 'two', 'three'], mask=[0, 0, 1], dtype='|S8')
(mrec, nrec, _) = self.data
for (f, l) in zip(('a', 'b', 'c'), (_a, _b, _c)):
assert_equal(getattr(mrec, f)._mask, l._mask)
# One record only
_x = ma.array([1, 1.1, 'one'], mask=[1, 0, 0], )
assert_equal_records(fromarrays(_x, dtype=mrec.dtype), mrec[0])
def test_fromarrays(self):
_a = ma.array([1, 2, 3], mask=[0, 0, 1], dtype=int)
_b = ma.array([1.1, 2.2, 3.3], mask=[0, 0, 1], dtype=float)
_c = ma.array(["one", "two", "three"], mask=[0, 0, 1], dtype="|S8")
(mrec, nrec, _) = self.data
for (f, l) in zip(("a", "b", "c"), (_a, _b, _c)):
assert_equal(getattr(mrec, f)._mask, l._mask)
# One record only
_x = ma.array([1, 1.1, "one"], mask=[1, 0, 0],)
assert_equal_records(fromarrays(_x, dtype=mrec.dtype), mrec[0])
def test_pickling(self):
# Test pickling
base = self.base.copy()
mrec = base.view(mrecarray)
_ = pickle.dumps(mrec)
mrec_ = pickle.loads(_)
assert_equal(mrec_.dtype, mrec.dtype)
assert_equal_records(mrec_._data, mrec._data)
assert_equal(mrec_._mask, mrec._mask)
assert_equal_records(mrec_._mask, mrec._mask)
def test_pickling(self):
# Test pickling
base = self.base.copy()
mrec = base.view(mrecarray)
_ = pickle.dumps(mrec)
mrec_ = pickle.loads(_)
assert_equal(mrec_.dtype, mrec.dtype)
assert_equal_records(mrec_._data, mrec._data)
assert_equal(mrec_._mask, mrec._mask)
assert_equal_records(mrec_._mask, mrec._mask)
def test_view_flexible_type(self):
(tarr, a, b) = self.data
arr = tarr._series
alttype = [('A', np.float), ('B', np.float)]
test = tarr.view(alttype)
self.failUnless(isinstance(test, TimeSeries))
assert_equal_records(test, arr.view(alttype))
self.failUnless(test['B'][3] is ma.masked)
assert_equal(test.dtype, np.dtype(alttype))
self.failUnless(test._fill_value is None)
def test_view_flexible_type(self):
(tarr, a, b) = self.data
arr = tarr._series
alttype = [('A', np.float), ('B', np.float)]
test = tarr.view(alttype)
self.failUnless(isinstance(test, TimeSeries))
assert_equal_records(test, arr.view(alttype))
self.failUnless(test['B'][3] is ma.masked)
assert_equal(test.dtype, np.dtype(alttype))
self.failUnless(test._fill_value is None)
def test_pickling(self):
# Test pickling
base = self.base.copy()
mrec = base.view(mrecarray)
for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
_ = pickle.dumps(mrec, protocol=proto)
mrec_ = pickle.loads(_)
assert_equal(mrec_.dtype, mrec.dtype)
assert_equal_records(mrec_._data, mrec._data)
assert_equal(mrec_._mask, mrec._mask)
assert_equal_records(mrec_._mask, mrec._mask)
def test_append_maskedarray(self):
"Test appending to a MaskedTable"
table = self.h5file.root.marray
data = self.marray
newdata = ma.array(zip(np.random.rand(3), np.arange(3)+10),
mask=[(0,0),(1,0),(0,1)],
dtype=data.dtype)
table.append(newdata)
test = table.read()
self.failUnless(isinstance(test, MaskedArray))
assert_equal_records(test, ma.mr_[data,newdata])
def test_pickling(self):
# Test pickling
base = self.base.copy()
mrec = base.view(mrecarray)
for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
_ = pickle.dumps(mrec, protocol=proto)
mrec_ = pickle.loads(_)
assert_equal(mrec_.dtype, mrec.dtype)
assert_equal_records(mrec_._data, mrec._data)
assert_equal(mrec_._mask, mrec._mask)
assert_equal_records(mrec_._mask, mrec._mask)
def test_append_timeseries(self):
"Test appending to a MaskedTable"
table = self.h5file.root.tseries
tseries = self.tseries
newdata = ts.time_series(zip(np.random.rand(3), np.arange(3)+10),
mask=[(0,0),(1,0),(0,1)],
dtype=tseries.dtype,
start_date=tseries.dates[-1]+1)
table.append(newdata)
test = table.read()
self.failUnless(isinstance(test, TimeSeries))
assert_equal_records(test, ts.concatenate((tseries,newdata)))
def test_append_maskedarray(self):
"Test appending to a MaskedTable"
table = self.h5file.root.marray
data = self.marray
newdata = ma.array(zip(np.random.rand(3),
np.arange(3) + 10),
mask=[(0, 0), (1, 0), (0, 1)],
dtype=data.dtype)
table.append(newdata)
test = table.read()
self.failUnless(isinstance(test, MaskedArray))
assert_equal_records(test, ma.mr_[data, newdata])
def test_get_dates(self):
"Tests date retrieval"
[d, m, mrec, dlist, dates, mts, rts] = self.data
# Get item by dates w/ masked values
test = rts['2007-01']
self.failUnless(isinstance(test, ma.MaskedArray))
self.failUnless(not isinstance(test, TimeSeries))
assert_equal_records(test, mrec[0])
# Get item by dates w/o masked values
test = rts['2007-03']
self.failUnless(isinstance(test, np.void))
assert_equal_records(test, mrec[2])
def test_get_dates(self):
"Tests date retrieval"
[d, m, mrec, dlist, dates, mts, rts] = self.data
# Get item by dates w/ masked values
test = rts['2007-01']
self.failUnless(isinstance(test, ma.MaskedArray))
self.failUnless(not isinstance(test, TimeSeries))
assert_equal_records(test, mrec[0])
# Get item by dates w/o masked values
test = rts['2007-03']
self.failUnless(isinstance(test, np.void))
assert_equal_records(test, mrec[2])
def test_append_timeseries(self):
"Test appending to a MaskedTable"
table = self.h5file.root.tseries
tseries = self.tseries
newdata = ts.time_series(zip(np.random.rand(3),
np.arange(3) + 10),
mask=[(0, 0), (1, 0), (0, 1)],
dtype=tseries.dtype,
start_date=tseries.dates[-1] + 1)
table.append(newdata)
test = table.read()
self.failUnless(isinstance(test, TimeSeries))
assert_equal_records(test, ts.concatenate((tseries, newdata)))
def test_fromrecords_wmask(self):
# Tests construction from records w/ mask.
(mrec, nrec, ddtype) = self.data
_mrec = fromrecords(nrec.tolist(), dtype=ddtype, mask=[
0,
1,
0,
])
assert_equal_records(_mrec._data, mrec._data)
assert_equal(_mrec._mask.tolist(), [(0, 0, 0), (1, 1, 1), (0, 0, 0)])
_mrec = fromrecords(nrec.tolist(), dtype=ddtype, mask=True)
assert_equal_records(_mrec._data, mrec._data)
assert_equal(_mrec._mask.tolist(), [(1, 1, 1), (1, 1, 1), (1, 1, 1)])
_mrec = fromrecords(nrec.tolist(), dtype=ddtype, mask=mrec._mask)
assert_equal_records(_mrec._data, mrec._data)
assert_equal(_mrec._mask.tolist(), mrec._mask.tolist())
_mrec = fromrecords(nrec.tolist(),
dtype=ddtype,
mask=mrec._mask.tolist())
assert_equal_records(_mrec._data, mrec._data)
assert_equal(_mrec._mask.tolist(), mrec._mask.tolist())
def test_hardmask(self):
# Test hardmask
base = self.base.copy()
mbase = base.view(mrecarray)
mbase.harden_mask()
assert_(mbase._hardmask)
mbase.mask = nomask
assert_equal_records(mbase._mask, base._mask)
mbase.soften_mask()
assert_(not mbase._hardmask)
mbase.mask = nomask
# So, the mask of a field is no longer set to nomask...
assert_equal_records(mbase._mask, ma.make_mask_none(base.shape, base.dtype))
assert_(ma.make_mask(mbase["b"]._mask) is nomask)
assert_equal(mbase["a"]._mask, mbase["b"]._mask)
def test_hardmask(self):
# Test hardmask
base = self.base.copy()
mbase = base.view(mrecarray)
mbase.harden_mask()
self.assertTrue(mbase._hardmask)
mbase.mask = nomask
assert_equal_records(mbase._mask, base._mask)
mbase.soften_mask()
self.assertTrue(not mbase._hardmask)
mbase.mask = nomask
# So, the mask of a field is no longer set to nomask...
assert_equal_records(mbase._mask,
ma.make_mask_none(base.shape, base.dtype))
self.assertTrue(ma.make_mask(mbase['b']._mask) is nomask)
assert_equal(mbase['a']._mask, mbase['b']._mask)
def test_exotic_formats(self):
# Test that 'exotic' formats are processed properly
easy = mrecarray(1, dtype=[("i", int), ("s", "|S8"), ("f", float)])
easy[0] = masked
assert_equal(easy.filled(1).item(), (1, b"1", 1.0))
solo = mrecarray(1, dtype=[("f0", "<f8", (2, 2))])
solo[0] = masked
assert_equal(solo.filled(1).item(), np.array((1,), dtype=solo.dtype).item())
mult = mrecarray(2, dtype="i4, (2,3)float, float")
mult[0] = masked
mult[1] = (1, 1, 1)
mult.filled(0)
assert_equal_records(
mult.filled(0), np.array([(0, 0, 0), (1, 1, 1)], dtype=mult.dtype)
)
def test_exotic_formats(self):
# Test that 'exotic' formats are processed properly
easy = mrecarray(1, dtype=[('i', int), ('s', '|S8'), ('f', float)])
easy[0] = masked
assert_equal(easy.filled(1).item(), (1, asbytes('1'), 1.))
solo = mrecarray(1, dtype=[('f0', '<f8', (2, 2))])
solo[0] = masked
assert_equal(solo.filled(1).item(),
np.array((1,), dtype=solo.dtype).item())
mult = mrecarray(2, dtype="i4, (2,3)float, float")
mult[0] = masked
mult[1] = (1, 1, 1)
mult.filled(0)
assert_equal_records(mult.filled(0),
np.array([(0, 0, 0), (1, 1, 1)],
dtype=mult.dtype))
def test_exotic_formats(self):
# Test that 'exotic' formats are processed properly
easy = mrecarray(1, dtype=[('i', int), ('s', '|S8'), ('f', float)])
easy[0] = masked
assert_equal(easy.filled(1).item(), (1, b'1', 1.))
solo = mrecarray(1, dtype=[('f0', '<f8', (2, 2))])
solo[0] = masked
assert_equal(
solo.filled(1).item(),
np.array((1, ), dtype=solo.dtype).item())
mult = mrecarray(2, dtype="i4, (2,3)float, float")
mult[0] = masked
mult[1] = (1, 1, 1)
mult.filled(0)
assert_equal_records(
mult.filled(0), np.array([(0, 0, 0), (1, 1, 1)], dtype=mult.dtype))
def test_tabulateNV(self):
"Tests the transformation of named variables to..."
data5N = self.data['data5N']
_data5N = tabulate(data5N)
zipped5N = [((ma.filled(s['a']), ma.getmaskarray(s['a'])),
(ma.filled(s['b']), ma.getmaskarray(s['b'])),
(ma.filled(s['c']), ma.getmaskarray(s['c'])))
for s in data5N]
ndtype5N = [(fname,[('_data',ftype), ('_mask',bool)])
for (fname,ftype) in data5N.dtype.descr]
data5N = np.array(zipped5N, dtype=ndtype5N)
for key in ('a','b','c'):
assert_equal_records(data5N[key].view(np.recarray),
_data5N[key].view(np.recarray))
#
_data5R = tabulate(self.data['data5N'])
data5R = np.array(zipped5N, dtype=ndtype5N)
for key in ('a','b','c'):
assert_equal_records(data5R[key].view(np.recarray),
_data5R[key].view(np.recarray))
def test_tabulateNV(self):
"Tests the transformation of named variables to..."
data5N = self.data['data5N']
_data5N = tabulate(data5N)
zipped5N = [((ma.filled(s['a']), ma.getmaskarray(s['a'])),
(ma.filled(s['b']), ma.getmaskarray(s['b'])),
(ma.filled(s['c']), ma.getmaskarray(s['c'])))
for s in data5N]
ndtype5N = [(fname, [('_data', ftype), ('_mask', bool)])
for (fname, ftype) in data5N.dtype.descr]
data5N = np.array(zipped5N, dtype=ndtype5N)
for key in ('a', 'b', 'c'):
assert_equal_records(data5N[key].view(np.recarray),
_data5N[key].view(np.recarray))
#
_data5R = tabulate(self.data['data5N'])
data5R = np.array(zipped5N, dtype=ndtype5N)
for key in ('a', 'b', 'c'):
assert_equal_records(data5R[key].view(np.recarray),
_data5R[key].view(np.recarray))
def test_get(self):
# Tests fields retrieval
base = self.base.copy()
mbase = base.view(mrecarray)
# As fields..........
for field in ("a", "b", "c"):
assert_equal(getattr(mbase, field), mbase[field])
assert_equal(base[field], mbase[field])
# as elements .......
mbase_first = mbase[0]
assert_(isinstance(mbase_first, mrecarray))
assert_equal(mbase_first.dtype, mbase.dtype)
assert_equal(mbase_first.tolist(), (1, 1.1, b"one"))
# Used to be mask, now it's recordmask
assert_equal(mbase_first.recordmask, nomask)
assert_equal(mbase_first._mask.item(), (False, False, False))
assert_equal(mbase_first["a"], mbase["a"][0])
mbase_last = mbase[-1]
assert_(isinstance(mbase_last, mrecarray))
assert_equal(mbase_last.dtype, mbase.dtype)
assert_equal(mbase_last.tolist(), (None, None, None))
# Used to be mask, now it's recordmask
assert_equal(mbase_last.recordmask, True)
assert_equal(mbase_last._mask.item(), (True, True, True))
assert_equal(mbase_last["a"], mbase["a"][-1])
assert_((mbase_last["a"] is masked))
# as slice ..........
mbase_sl = mbase[:2]
assert_(isinstance(mbase_sl, mrecarray))
assert_equal(mbase_sl.dtype, mbase.dtype)
# Used to be mask, now it's recordmask
assert_equal(mbase_sl.recordmask, [0, 1])
assert_equal_records(
mbase_sl.mask,
np.array(
[(False, False, False), (True, True, True)], dtype=mbase._mask.dtype
),
)
assert_equal_records(mbase_sl, base[:2].view(mrecarray))
for field in ("a", "b", "c"):
assert_equal(getattr(mbase_sl, field), base[:2][field])
def test_fromrecords(self):
# Test construction from records.
(mrec, nrec, ddtype) = self.data
#......
palist = [(1, 'abc', 3.7000002861022949, 0),
(2, 'xy', 6.6999998092651367, 1),
(0, ' ', 0.40000000596046448, 0)]
pa = recfromrecords(palist, names='c1, c2, c3, c4')
mpa = fromrecords(palist, names='c1, c2, c3, c4')
assert_equal_records(pa, mpa)
#.....
_mrec = fromrecords(nrec)
assert_equal(_mrec.dtype, mrec.dtype)
for field in _mrec.dtype.names:
assert_equal(getattr(_mrec, field), getattr(mrec._data, field))
_mrec = fromrecords(nrec.tolist(), names='c1,c2,c3')
assert_equal(_mrec.dtype, [('c1', int), ('c2', float), ('c3', '|S5')])
for (f, n) in zip(('c1', 'c2', 'c3'), ('a', 'b', 'c')):
assert_equal(getattr(_mrec, f), getattr(mrec._data, n))
_mrec = fromrecords(mrec)
assert_equal(_mrec.dtype, mrec.dtype)
assert_equal_records(_mrec._data, mrec.filled())
assert_equal_records(_mrec._mask, mrec._mask)
def test_fromrecords(self):
# Test construction from records.
(mrec, nrec, ddtype) = self.data
#......
palist = [(1, 'abc', 3.7000002861022949, 0),
(2, 'xy', 6.6999998092651367, 1),
(0, ' ', 0.40000000596046448, 0)]
pa = recfromrecords(palist, names='c1, c2, c3, c4')
mpa = fromrecords(palist, names='c1, c2, c3, c4')
assert_equal_records(pa, mpa)
#.....
_mrec = fromrecords(nrec)
assert_equal(_mrec.dtype, mrec.dtype)
for field in _mrec.dtype.names:
assert_equal(getattr(_mrec, field), getattr(mrec._data, field))
_mrec = fromrecords(nrec.tolist(), names='c1,c2,c3')
assert_equal(_mrec.dtype, [('c1', int), ('c2', float), ('c3', '|S5')])
for (f, n) in zip(('c1', 'c2', 'c3'), ('a', 'b', 'c')):
assert_equal(getattr(_mrec, f), getattr(mrec._data, n))
_mrec = fromrecords(mrec)
assert_equal(_mrec.dtype, mrec.dtype)
assert_equal_records(_mrec._data, mrec.filled())
assert_equal_records(_mrec._mask, mrec._mask)
def test_fromrecords(self):
# Test construction from records.
(mrec, nrec, ddtype) = self.data
# ......
palist = [
(1, "abc", 3.7000002861022949, 0),
(2, "xy", 6.6999998092651367, 1),
(0, " ", 0.40000000596046448, 0),
]
pa = recfromrecords(palist, names="c1, c2, c3, c4")
mpa = fromrecords(palist, names="c1, c2, c3, c4")
assert_equal_records(pa, mpa)
# .....
_mrec = fromrecords(nrec)
assert_equal(_mrec.dtype, mrec.dtype)
for field in _mrec.dtype.names:
assert_equal(getattr(_mrec, field), getattr(mrec._data, field))
_mrec = fromrecords(nrec.tolist(), names="c1,c2,c3")
assert_equal(_mrec.dtype, [("c1", int), ("c2", float), ("c3", "|S5")])
for (f, n) in zip(("c1", "c2", "c3"), ("a", "b", "c")):
assert_equal(getattr(_mrec, f), getattr(mrec._data, n))
_mrec = fromrecords(mrec)
assert_equal(_mrec.dtype, mrec.dtype)
assert_equal_records(_mrec._data, mrec.filled())
assert_equal_records(_mrec._mask, mrec._mask)
def test_get(self):
# Tests fields retrieval
base = self.base.copy()
mbase = base.view(mrecarray)
# As fields..........
for field in ('a', 'b', 'c'):
assert_equal(getattr(mbase, field), mbase[field])
assert_equal(base[field], mbase[field])
# as elements .......
mbase_first = mbase[0]
assert_(isinstance(mbase_first, mrecarray))
assert_equal(mbase_first.dtype, mbase.dtype)
assert_equal(mbase_first.tolist(), (1, 1.1, asbytes('one')))
# Used to be mask, now it's recordmask
assert_equal(mbase_first.recordmask, nomask)
assert_equal(mbase_first._mask.item(), (False, False, False))
assert_equal(mbase_first['a'], mbase['a'][0])
mbase_last = mbase[-1]
assert_(isinstance(mbase_last, mrecarray))
assert_equal(mbase_last.dtype, mbase.dtype)
assert_equal(mbase_last.tolist(), (None, None, None))
# Used to be mask, now it's recordmask
assert_equal(mbase_last.recordmask, True)
assert_equal(mbase_last._mask.item(), (True, True, True))
assert_equal(mbase_last['a'], mbase['a'][-1])
assert_((mbase_last['a'] is masked))
# as slice ..........
mbase_sl = mbase[:2]
assert_(isinstance(mbase_sl, mrecarray))
assert_equal(mbase_sl.dtype, mbase.dtype)
# Used to be mask, now it's recordmask
assert_equal(mbase_sl.recordmask, [0, 1])
assert_equal_records(mbase_sl.mask,
np.array([(False, False, False),
(True, True, True)],
dtype=mbase._mask.dtype))
assert_equal_records(mbase_sl, base[:2].view(mrecarray))
for field in ('a', 'b', 'c'):
assert_equal(getattr(mbase_sl, field), base[:2][field])
def test_tseries_read(self):
"Test reading specific elements of a TimeSeriesTable"
table = self.h5file.root.tseries
series = self.tseries
#
test = table.read()
self.failUnless(isinstance(test, TimeSeries))
assert_equal_records(test, series)
#
test = table.read(field='a')
self.failUnless(isinstance(test, TimeSeries))
assert_equal(test, series['a'])
#
test = table.read(step=2)
self.failUnless(isinstance(test, TimeSeries))
assert_equal(test, series[::2])
#
test = table.readCoordinates([1, 2, 3])
self.failUnless(isinstance(test, TimeSeries))
assert_equal(test, series[[1, 2, 3]])
#
test = table.readCoordinates([1, 2, 3], field='a')
self.failUnless(isinstance(test, TimeSeries))
assert_equal(test, series['a'][[1, 2, 3]])
def test_marray_read(self):
"Test reading specific elements of a MaskedTable"
table = self.h5file.root.marray
data = self.marray
#
test = table.read()
self.failUnless(isinstance(test, MaskedArray))
assert_equal_records(test, data)
#
test = table.read(field='a')
self.failUnless(isinstance(test, MaskedArray))
assert_equal(test, data['a'])
#
test = table.read(step=2)
self.failUnless(isinstance(test, MaskedArray))
assert_equal(test, data[::2])
#
test = table.readCoordinates([1, 2, 3])
self.failUnless(isinstance(test, MaskedArray))
assert_equal(test, data[[1, 2, 3]])
#
test = table.readCoordinates([1, 2, 3], field='a')
self.failUnless(isinstance(test, MaskedArray))
assert_equal(test, data['a'][[1, 2, 3]])
def test_tseries_read(self):
"Test reading specific elements of a TimeSeriesTable"
table = self.h5file.root.tseries
series = self.tseries
#
test = table.read()
self.failUnless(isinstance(test, TimeSeries))
assert_equal_records(test, series)
#
test = table.read(field='a')
self.failUnless(isinstance(test, TimeSeries))
assert_equal(test, series['a'])
#
test = table.read(step=2)
self.failUnless(isinstance(test, TimeSeries))
assert_equal(test, series[::2])
#
test = table.readCoordinates([1,2,3])
self.failUnless(isinstance(test, TimeSeries))
assert_equal(test, series[[1,2,3]])
#
test = table.readCoordinates([1,2,3], field='a')
self.failUnless(isinstance(test, TimeSeries))
assert_equal(test, series['a'][[1,2,3]])
def test_marray_read(self):
"Test reading specific elements of a MaskedTable"
table = self.h5file.root.marray
data = self.marray
#
test = table.read()
self.failUnless(isinstance(test, MaskedArray))
assert_equal_records(test, data)
#
test = table.read(field='a')
self.failUnless(isinstance(test, MaskedArray))
assert_equal(test, data['a'])
#
test = table.read(step=2)
self.failUnless(isinstance(test, MaskedArray))
assert_equal(test, data[::2])
#
test = table.readCoordinates([1,2,3])
self.failUnless(isinstance(test, MaskedArray))
assert_equal(test, data[[1,2,3]])
#
test = table.readCoordinates([1,2,3], field='a')
self.failUnless(isinstance(test, MaskedArray))
assert_equal(test, data['a'][[1,2,3]])
def test_byview(self):
# Test creation by view
base = self.base
mbase = base.view(mrecarray)
assert_equal(mbase.recordmask, base.recordmask)
assert_equal_records(mbase._mask, base._mask)
assert_(isinstance(mbase._data, recarray))
assert_equal_records(mbase._data, base._data.view(recarray))
for field in ('a', 'b', 'c'):
assert_equal(base[field], mbase[field])
assert_equal_records(mbase.view(mrecarray), mbase)
def test_byview(self):
# Test creation by view
base = self.base
mbase = base.view(mrecarray)
assert_equal(mbase.recordmask, base.recordmask)
assert_equal_records(mbase._mask, base._mask)
assert_(isinstance(mbase._data, recarray))
assert_equal_records(mbase._data, base._data.view(recarray))
for field in ('a', 'b', 'c'):
assert_equal(base[field], mbase[field])
assert_equal_records(mbase.view(mrecarray), mbase)
def test_get_index(self):
"Tests index retrieval"
[d, m, mrec, dlist, dates, mts, rts] = self.data
test = rts[0]
self.failUnless(not (isinstance(test, TimeSeriesRecords)))
assert_equal_records(test, rts._data[0])
assert_equal_records(test, mrec._data[0])
# We can't use assert_equal here, as it tries to convert the tuple into a singleton
# self.failUnless(rts[0]._data.view(numpyndarray) == mrec[0])
assert_equal_records(rts._data[0], mrec[0])
assert_equal(rts.mask[0], mrec.mask[0])
assert_equal(test.mask, rts.mask[0])
def test_get_index(self):
"Tests index retrieval"
[d, m, mrec, dlist, dates, mts, rts] = self.data
test = rts[0]
self.failUnless(not (isinstance(test, TimeSeriesRecords)))
assert_equal_records(test, rts._data[0])
assert_equal_records(test, mrec._data[0])
# We can't use assert_equal here, as it tries to convert the tuple into a singleton
# self.failUnless(rts[0]._data.view(numpyndarray) == mrec[0])
assert_equal_records(rts._data[0], mrec[0])
assert_equal(rts.mask[0], mrec.mask[0])
assert_equal(test.mask, rts.mask[0])
def test_fromrecords_wmask(self):
# Tests construction from records w/ mask.
(mrec, nrec, ddtype) = self.data
_mrec = fromrecords(nrec.tolist(), dtype=ddtype, mask=[0, 1, 0,])
assert_equal_records(_mrec._data, mrec._data)
assert_equal(_mrec._mask.tolist(), [(0, 0, 0), (1, 1, 1), (0, 0, 0)])
_mrec = fromrecords(nrec.tolist(), dtype=ddtype, mask=True)
assert_equal_records(_mrec._data, mrec._data)
assert_equal(_mrec._mask.tolist(), [(1, 1, 1), (1, 1, 1), (1, 1, 1)])
_mrec = fromrecords(nrec.tolist(), dtype=ddtype, mask=mrec._mask)
assert_equal_records(_mrec._data, mrec._data)
assert_equal(_mrec._mask.tolist(), mrec._mask.tolist())
_mrec = fromrecords(nrec.tolist(), dtype=ddtype,
mask=mrec._mask.tolist())
assert_equal_records(_mrec._data, mrec._data)
assert_equal(_mrec._mask.tolist(), mrec._mask.tolist())
def test_view_by_itself(self):
(tarr, a, b) = self.data
test = tarr.view()
self.failUnless(isinstance(test, TimeSeries))
assert_equal_records(test, tarr)
assert_equal_records(test._mask, tarr._mask)
def test_view_by_itself(self):
(tarr, a, b) = self.data
test = tarr.view()
self.failUnless(isinstance(test, TimeSeries))
assert_equal_records(test, tarr)
assert_equal_records(test._mask, tarr._mask)
def test_view_by_itself(self):
(mrec, a, b, arr) = self.data
test = mrec.view()
self.assertTrue(isinstance(test, MaskedRecords))
assert_equal_records(test, mrec)
assert_equal_records(test._mask, mrec._mask)
def test_view_by_itself(self):
(mrec, a, b, arr) = self.data
test = mrec.view()
assert_(isinstance(test, MaskedRecords))
assert_equal_records(test, mrec)
assert_equal_records(test._mask, mrec._mask)
