def test_UniformTime_preserves_uniformity():
"Uniformity: allow ops which keep it, and deny those which break it"
utime = ts.UniformTime(t0=0, length=10, sampling_rate=1)
def assign_to_one_element_of(t): t[0]=42
nt.assert_raises(ValueError, assign_to_one_element_of,utime)
# same as utime, but starting 10s later
utime10 = ts.UniformTime(t0=10, length=10, sampling_rate=1)
utime += 10 # constants treated as having same units as utime
npt.assert_equal(utime,utime10)
# same as utime, but with a lower sampling rate
utime_2 = ts.UniformTime(t0=10, length=10, sampling_interval=2)
utime += np.arange(10) # make utime match utime_2
npt.assert_equal(utime,utime_2)
npt.assert_equal(utime.sampling_interval,utime_2.sampling_interval)
utime = ts.UniformTime(t0=5, length=10, sampling_rate=1)
utime *= 2 # alternative way to make utime match utime_2
npt.assert_equal(utime.sampling_interval,utime_2.sampling_interval)
npt.assert_equal(utime.sampling_rate,utime_2.sampling_rate)
nonuniform = np.concatenate((list(range(2)),list(range(3)), list(range(5))))
def iadd_nonuniform(t): t+=nonuniform
nt.assert_raises(ValueError, iadd_nonuniform, utime)
def test_UniformTime_index_at():
time1 = ts.UniformTime(t0=1000,
length=10,
sampling_rate=1000,
time_unit='ms')
mask = [False] * 10
for i in xrange(10):
idx = time1.index_at(ts.TimeArray(1000 + i, time_unit='ms'))
npt.assert_equal(idx, np.array(i))
mask[i] = True
mask_idx = time1.index_at(ts.TimeArray(1000 + i, time_unit='ms'),
boolean=True)
npt.assert_equal(mask_idx, mask)
if i > 0 and i < 9:
mask[i - 1] = True
mask[i + 1] = True
mask_idx = time1.index_at(ts.TimeArray(
[999 + i, 1000 + i, 1001 + i], time_unit='ms'),
boolean=True)
npt.assert_equal(mask_idx, mask)
mask[i - 1] = False
mask[i + 1] = False
mask[i] = False
def test_Epochs():
tms = ts.TimeArray(data=list(range(100)), time_unit='ms')
tmin = ts.TimeArray(data=list(range(100)), time_unit='m')
tsec = ts.TimeArray(data=list(range(100)), time_unit='s')
utms = ts.UniformTime(length=100, sampling_interval=1, time_unit='ms')
utmin = ts.UniformTime(length=100, sampling_interval=1, time_unit='m')
utsec = ts.UniformTime(length=100, sampling_interval=1, time_unit='s')
tsms = ts.TimeSeries(data=list(range(100)), sampling_interval=1, time_unit='ms')
tsmin = ts.TimeSeries(data=list(range(100)), sampling_interval=1, time_unit='m')
tssec = ts.TimeSeries(data=list(range(100)), sampling_interval=1, time_unit='s')
# one millisecond epoch
e1ms = ts.Epochs(0, 1, time_unit='ms')
e09ms = ts.Epochs(0.1, 1, time_unit='ms')
msg = "Seems like a problem with copy=False in TimeArray constructor."
npt.assert_equal(e1ms.duration, ts.TimeArray(1, time_unit='ms'), msg)
# one day
e1d = ts.Epochs(0, 1, time_unit='D')
npt.assert_equal(e1d.duration, ts.TimeArray(1, time_unit='D'), msg)
e1ms_ar = ts.Epochs([0, 0], [1, 1], time_unit='ms')
for t in [tms, tmin, tsec, utms, utmin, utsec]:
# the sample time arrays are all at least 1ms long, so this should
# return a timearray that has exactly one time point in it
npt.assert_equal(len(t.during(e1ms)), 1)
# this time epoch should not contain any point
npt.assert_equal(len(t.during(e09ms)), 0)
# make sure, slicing doesn't change the class
npt.assert_equal(type(t), type(t.during(e1ms)))
for t in [tsms, tsmin, tssec]:
# the sample time series are all at least 1ms long, so this should
# return a timeseries that has exactly one time point in it
npt.assert_equal(len(t.during(e1ms)), 1)
# make sure, slicing doesn't change the class
npt.assert_equal(type(t), type(t.during(e1ms)))
# same thing but now there's an array of epochs
e2 = ts.Epochs([0, 10], [10, 20], time_unit=t.time_unit)
# make sure, slicing doesn't change the class for array of epochs
npt.assert_equal(type(t), type(t.during(e2)))
# Indexing with an array of epochs (all of which are the same length)
npt.assert_equal(t[e2].data.shape, (2, 10))
npt.assert_equal(len(t.during(e2)), 10)
npt.assert_equal(t[e2].data.ndim, 2)
# check the data at some timepoints (a dimension was added)
npt.assert_equal(t[e2][0], (0, 10))
npt.assert_equal(t[e2][1], (1, 11))
# check the data for each epoch
npt.assert_equal(t[e2].data[0], list(range(10)))
npt.assert_equal(t[e2].data[1], list(range(10, 20)))
npt.assert_equal(t[e2].duration, e2[0].duration)
# slice with Epochs of different length (not supported for timeseries,
# raise error, though future jagged array implementation could go here)
ejag = ts.Epochs([0, 10], [10, 40], time_unit=t.time_unit)
# next line is the same as t[ejag]
npt.assert_raises(ValueError, t.__getitem__, ejag)
# if an epoch lies entirely between samples in the timeseries,
# return an empty array
eshort = ts.Epochs(2.5, 2.7, time_unit=t.time_unit)
npt.assert_equal(len(t[eshort].data), 0)
e1ms_outofrange = ts.Epochs(200, 300, time_unit=t.time_unit)
# assert that with the epoch moved outside of the time range of our
# data, slicing with the epoch now yields an empty array
npt.assert_raises(ValueError, t.during, dict(e=e1ms_outofrange))
# the sample timeseries are all shorter than a day, so this should
# raise an error (instead of padding, or returning a shorter than
# expected array.
npt.assert_raises(ValueError, t.during, dict(e=e1d))
def test_TimeSeries():
"""Testing the initialization of the uniform time series object """
#Test initialization with duration:
tseries1 = ts.TimeSeries([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], duration=10)
tseries2 = ts.TimeSeries([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], sampling_interval=1)
npt.assert_equal(tseries1.time, tseries2.time)
#downsampling:
t1 = ts.UniformTime(length=8, sampling_rate=2)
#duration is the same, but we're downsampling to 1Hz
tseries1 = ts.TimeSeries(data=[1, 2, 3, 4], time=t1, sampling_rate=1)
#If you didn't explicitely provide the rate you want to downsample to, that
#is an error:
npt.assert_raises(ValueError, ts.TimeSeries, dict(data=[1, 2, 3, 4],
time=t1))
tseries2 = ts.TimeSeries(data=[1, 2, 3, 4], sampling_rate=1)
tseries3 = ts.TimeSeries(data=[1, 2, 3, 4], sampling_rate=1000,
time_unit='ms')
#you can specify the sampling_rate or the sampling_interval, to the same
#effect, where specificying the sampling_interval is in the units of that
#time-series:
tseries4 = ts.TimeSeries(data=[1, 2, 3, 4], sampling_interval=1,
time_unit='ms')
npt.assert_equal(tseries4.time, tseries3.time)
#The units you use shouldn't matter - time is time:
tseries6 = ts.TimeSeries(data=[1, 2, 3, 4],
sampling_interval=0.001,
time_unit='s')
npt.assert_equal(tseries6.time, tseries3.time)
#And this too - perverse, but should be possible:
tseries5 = ts.TimeSeries(data=[1, 2, 3, 4],
sampling_interval=ts.TimeArray(0.001,
time_unit='s'),
time_unit='ms')
npt.assert_equal(tseries5.time, tseries3.time)
#initializing with a UniformTime object:
t = ts.UniformTime(length=3, sampling_rate=3)
data = [1, 2, 3]
tseries7 = ts.TimeSeries(data=data, time=t)
npt.assert_equal(tseries7.data, data)
data = [1, 2, 3, 4]
#If the data is not the right length, that should throw an error:
npt.assert_raises(ValueError,
ts.TimeSeries, dict(data=data, time=t))
# test basic arithmetics wiht TimeSeries
tseries1 = ts.TimeSeries([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], sampling_rate=1)
tseries2 = tseries1 + 1
npt.assert_equal(tseries1.data + 1, tseries2.data)
npt.assert_equal(tseries1.time, tseries2.time)
tseries2 -= 1
npt.assert_equal(tseries1.data, tseries2.data)
npt.assert_equal(tseries1.time, tseries2.time)
tseries2 = tseries1 * 2
npt.assert_equal(tseries1.data * 2, tseries2.data)
npt.assert_equal(tseries1.time, tseries2.time)
tseries2 = tseries2 / 2
npt.assert_equal(tseries1.data, tseries2.data)
npt.assert_equal(tseries1.time, tseries2.time)
def test_UniformTime():
tuc = ts.time_unit_conversion
for unit, duration in zip(['ns', 'ms', 's', None],
[2 * 10 ** 9, 2 * 10 ** 6, 100, 20]):
t1 = ts.UniformTime(duration=duration, sampling_rate=1,
time_unit=unit)
t2 = ts.UniformTime(duration=duration, sampling_rate=20,
time_unit=unit)
#The following two tests verify that first-last are equal to the
#duration, but it is unclear whether that is really the behavior we
#want, because the t_i held by a TimeSeries is the left
#(smaller) side of the time-duration defined by the bin
#The difference between the first and last item is the duration:
#npt.assert_equal(t1[-1]-t1[0],
# ts.TimeArray(duration,time_unit=unit))
#Duration doesn't depend on the sampling rate:
#npt.assert_equal(t1[-1]-t2[0],
# ts.TimeArray(duration,time_unit=unit))
a = ts.UniformTime(duration=10, sampling_rate=1)
b = ts.UniformTime(a, time_unit=unit)
npt.assert_equal(a.sampling_interval, b.sampling_interval)
npt.assert_equal(a.sampling_rate, b.sampling_rate)
b = ts.UniformTime(a, duration=2 * duration, time_unit=unit)
npt.assert_equal(a.sampling_interval, b.sampling_interval)
npt.assert_equal(a.sampling_rate, b.sampling_rate)
b = ts.UniformTime(a, length=100, time_unit=unit)
npt.assert_equal(a.sampling_interval, b.sampling_interval)
npt.assert_equal(a.sampling_rate, b.sampling_rate)
b = ts.UniformTime(a, length=100, time_unit=unit)
npt.assert_equal(a.sampling_interval, b.sampling_interval)
npt.assert_equal(a.sampling_rate, b.sampling_rate)
b = ts.UniformTime(a, length=100, duration=duration, time_unit=unit)
c = ts.UniformTime(length=100, duration=duration, time_unit=unit)
npt.assert_equal(c, b)
b = ts.UniformTime(sampling_interval=1, duration=10, time_unit=unit)
c = ts.UniformTime(sampling_rate=tuc['s'] / tuc[unit],
length=10, time_unit=unit)
npt.assert_equal(c, b)
#This should raise a value error, because the duration is shorter than
#the sampling_interval:
npt.assert_raises(ValueError,
ts.UniformTime,
dict(sampling_interval=10, duration=1))
#Time objects can be initialized with other time objects setting the
#duration, sampling_interval and sampling_rate:
a = ts.UniformTime(length=1, sampling_rate=1)
npt.assert_raises(ValueError, ts.UniformTime, dict(data=a,
sampling_rate=10, sampling_interval=.1))
b = ts.UniformTime(duration=2 * a.sampling_interval,
sampling_rate=2 * a.sampling_rate)
npt.assert_equal(ts.Frequency(b.sampling_rate),
ts.Frequency(2 * a.sampling_rate))
npt.assert_equal(b.sampling_interval,
ts.TimeArray(0.5 * a.sampling_rate))
b = ts.UniformTime(duration=10,
sampling_interval=a.sampling_interval)
npt.assert_equal(b.sampling_rate, a.sampling_rate)
b = ts.UniformTime(duration=10,
sampling_rate=a.sampling_rate)
npt.assert_equal(b.sampling_interval, a.sampling_interval)
# make sure the t0 ando other attribute is copied
a = ts.UniformTime(length=1, sampling_rate=1)
b = a.copy()
npt.assert_equal(b.duration, a.duration)
npt.assert_equal(b.sampling_rate, a.sampling_rate)
npt.assert_equal(b.sampling_interval, a.sampling_interval)
npt.assert_equal(b.t0, a.t0)
