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)