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_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_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_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_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_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): (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)