class TestIrregularlySampledSignalArrayMethods(unittest.TestCase): def setUp(self): self.data1 = np.arange(10.0) self.data1quant = self.data1 * pq.mV self.time1 = np.logspace(1, 5, 10) self.time1quant = self.time1 * pq.ms self.arr_ann = {'anno1': [23], 'anno2': ['A']} self.signal1 = IrregularlySampledSignal(self.time1quant, signal=self.data1quant, name='spam', description='eggs', file_origin='testfile.txt', arg1='test', array_annotations=self.arr_ann) self.signal1.segment = Segment() self.signal1.channel_index = ChannelIndex([0]) def test__compliant(self): assert_neo_object_is_compliant(self.signal1) self.assertEqual(self.signal1.name, 'spam') self.assertEqual(self.signal1.description, 'eggs') self.assertEqual(self.signal1.file_origin, 'testfile.txt') self.assertEqual(self.signal1.annotations, {'arg1': 'test'}) assert_arrays_equal(self.signal1.array_annotations['anno1'], np.array([23])) assert_arrays_equal(self.signal1.array_annotations['anno2'], np.array(['A'])) self.assertIsInstance(self.signal1.array_annotations, ArrayDict) def test__slice_should_return_IrregularlySampledSignal(self): result = self.signal1[3:8] self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) self.assertEqual(result.size, 5) self.assertEqual(result.t_start, self.time1quant[3]) self.assertEqual(result.t_stop, self.time1quant[7]) assert_array_equal(self.time1quant[3:8], result.times) assert_array_equal(self.data1[3:8].reshape(-1, 1), result.magnitude) # Test other attributes were copied over (in this case, defaults) self.assertEqual(result.file_origin, self.signal1.file_origin) self.assertEqual(result.name, self.signal1.name) self.assertEqual(result.description, self.signal1.description) self.assertEqual(result.annotations, self.signal1.annotations) assert_arrays_equal(result.array_annotations['anno1'], np.array([23])) assert_arrays_equal(result.array_annotations['anno2'], np.array(['A'])) self.assertIsInstance(result.array_annotations, ArrayDict) def test__getitem_should_return_single_quantity(self): self.assertEqual(self.signal1[0], 0 * pq.mV) self.assertEqual(self.signal1[9], 9 * pq.mV) self.assertRaises(IndexError, self.signal1.__getitem__, 10) def test__getitem_out_of_bounds_IndexError(self): self.assertRaises(IndexError, self.signal1.__getitem__, 10) def test_comparison_operators(self): assert_array_equal(self.signal1 >= 5 * pq.mV, np.array( [[False, False, False, False, False, True, True, True, True, True]]).T) assert_array_equal(self.signal1 == 5 * pq.mV, np.array( [[False, False, False, False, False, True, False, False, False, False]]).T) assert_array_equal(self.signal1 == self.signal1, np.array( [[True, True, True, True, True, True, True, True, True, True]]).T) def test__comparison_as_indexing_single_trace(self): self.assertEqual(self.signal1[self.signal1 == 5], [5 * pq.mV]) def test__comparison_as_indexing_multi_trace(self): signal = IrregularlySampledSignal(self.time1quant, np.arange(20).reshape((-1, 2)) * pq.V) assert_array_equal(signal[signal < 10], np.array([[0, 2, 4, 6, 8], [1, 3, 5, 7, 9]]).T * pq.V) def test__indexing_keeps_order_across_channels(self): # AnalogSignals with 10 traces each having 5 samples (eg. data[0] = [0,10,20,30,40]) data = np.array([range(10), range(10, 20), range(20, 30), range(30, 40), range(40, 50)]) mask = np.full((5, 10), fill_value=False, dtype=bool) # selecting one entry per trace mask[[0, 1, 0, 3, 0, 2, 4, 3, 1, 4], range(10)] = True signal = IrregularlySampledSignal(np.arange(5) * pq.s, np.array(data) * pq.V) assert_array_equal(signal[mask], np.array([[0, 11, 2, 33, 4, 25, 46, 37, 18, 49]]) * pq.V) def test__indexing_keeps_order_across_time(self): # AnalogSignals with 10 traces each having 5 samples (eg. data[0] = [0,10,20,30,40]) data = np.array([range(10), range(10, 20), range(20, 30), range(30, 40), range(40, 50)]) mask = np.full((5, 10), fill_value=False, dtype=bool) # selecting two entries per trace temporal_ids = [0, 1, 0, 3, 1, 2, 4, 2, 1, 4] + [4, 3, 2, 1, 0, 1, 2, 3, 2, 1] mask[temporal_ids, list(range(10)) + list(range(10))] = True signal = IrregularlySampledSignal(np.arange(5) * pq.s, np.array(data) * pq.V) assert_array_equal(signal[mask], np.array([[0, 11, 2, 13, 4, 15, 26, 27, 18, 19], [40, 31, 22, 33, 14, 25, 46, 37, 28, 49]]) * pq.V) def test__comparison_with_inconsistent_units_should_raise_Exception(self): self.assertRaises(ValueError, self.signal1.__gt__, 5 * pq.nA) def test_simple_statistics(self): targmean = self.signal1[:-1] * np.diff(self.time1quant).reshape(-1, 1) targmean = targmean.sum() / (self.time1quant[-1] - self.time1quant[0]) self.assertEqual(self.signal1.max(), 9 * pq.mV) self.assertEqual(self.signal1.min(), 0 * pq.mV) self.assertEqual(self.signal1.mean(), targmean) def test_mean_interpolation_NotImplementedError(self): self.assertRaises(NotImplementedError, self.signal1.mean, True) def test_resample_NotImplementedError(self): self.assertRaises(NotImplementedError, self.signal1.resample, True) def test__rescale_same(self): result = self.signal1.copy() result = result.rescale(pq.mV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) assert_arrays_equal(result.array_annotations['anno1'], np.array([23])) assert_arrays_equal(result.array_annotations['anno2'], np.array(['A'])) self.assertIsInstance(result.array_annotations, ArrayDict) self.assertEqual(result.units, 1 * pq.mV) assert_array_equal(result.magnitude, self.data1.reshape(-1, 1)) assert_array_equal(result.times, self.time1quant) assert_same_sub_schema(result, self.signal1) self.assertIsInstance(result.channel_index, ChannelIndex) self.assertIsInstance(result.segment, Segment) self.assertIs(result.channel_index, self.signal1.channel_index) self.assertIs(result.segment, self.signal1.segment) def test__rescale_new(self): result = self.signal1.copy() result = result.rescale(pq.uV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) assert_arrays_equal(result.array_annotations['anno1'], np.array([23])) assert_arrays_equal(result.array_annotations['anno2'], np.array(['A'])) self.assertIsInstance(result.array_annotations, ArrayDict) self.assertEqual(result.units, 1 * pq.uV) assert_arrays_almost_equal(np.array(result), self.data1.reshape(-1, 1) * 1000., 1e-10) assert_array_equal(result.times, self.time1quant) self.assertIsInstance(result.channel_index, ChannelIndex) self.assertIsInstance(result.segment, Segment) self.assertIs(result.channel_index, self.signal1.channel_index) self.assertIs(result.segment, self.signal1.segment) def test__rescale_new_incompatible_ValueError(self): self.assertRaises(ValueError, self.signal1.rescale, pq.nA) def test_time_slice(self): targdataquant = [[1.0], [2.0], [3.0]] * pq.mV targtime = np.logspace(1, 5, 10) targtimequant = targtime[1:4] * pq.ms targ_signal = IrregularlySampledSignal(targtimequant, signal=targdataquant, name='spam', description='eggs', file_origin='testfile.txt', arg1='test') t_start = 15 t_stop = 250 result = self.signal1.time_slice(t_start, t_stop) assert_array_equal(result, targ_signal) assert_array_equal(result.times, targtimequant) self.assertEqual(result.units, 1 * pq.mV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) assert_arrays_equal(result.array_annotations['anno1'], np.array([23])) assert_arrays_equal(result.array_annotations['anno2'], np.array(['A'])) self.assertIsInstance(result.array_annotations, ArrayDict) def test_time_slice_out_of_boundries(self): targdataquant = self.data1quant targtimequant = self.time1quant targ_signal = IrregularlySampledSignal(targtimequant, signal=targdataquant, name='spam', description='eggs', file_origin='testfile.txt', arg1='test') t_start = 0 t_stop = 2500000 result = self.signal1.time_slice(t_start, t_stop) assert_array_equal(result, targ_signal) assert_array_equal(result.times, targtimequant) self.assertEqual(result.units, 1 * pq.mV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) assert_arrays_equal(result.array_annotations['anno1'], np.array([23])) assert_arrays_equal(result.array_annotations['anno2'], np.array(['A'])) self.assertIsInstance(result.array_annotations, ArrayDict) def test_time_slice_empty(self): targdataquant = [] * pq.mV targtimequant = [] * pq.ms targ_signal = IrregularlySampledSignal(targtimequant, signal=targdataquant, name='spam', description='eggs', file_origin='testfile.txt', arg1='test') t_start = 15 t_stop = 250 result = targ_signal.time_slice(t_start, t_stop) assert_array_equal(result, targ_signal) assert_array_equal(result.times, targtimequant) self.assertEqual(result.units, 1 * pq.mV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) self.assertEqual(result.array_annotations, {}) self.assertIsInstance(result.array_annotations, ArrayDict) def test_time_slice_none_stop(self): targdataquant = [[1.0], [2.0], [3.0], [4.0], [5.0], [6.0], [7.0], [8.0], [9.0]] * pq.mV targtime = np.logspace(1, 5, 10) targtimequant = targtime[1:10] * pq.ms targ_signal = IrregularlySampledSignal(targtimequant, signal=targdataquant, name='spam', description='eggs', file_origin='testfile.txt', arg1='test') t_start = 15 t_stop = None result = self.signal1.time_slice(t_start, t_stop) assert_array_equal(result, targ_signal) assert_array_equal(result.times, targtimequant) self.assertEqual(result.units, 1 * pq.mV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) assert_arrays_equal(result.array_annotations['anno1'], np.array([23])) assert_arrays_equal(result.array_annotations['anno2'], np.array(['A'])) self.assertIsInstance(result.array_annotations, ArrayDict) def test_time_slice_none_start(self): targdataquant = [[0.0], [1.0], [2.0], [3.0]] * pq.mV targtime = np.logspace(1, 5, 10) targtimequant = targtime[0:4] * pq.ms targ_signal = IrregularlySampledSignal(targtimequant, signal=targdataquant, name='spam', description='eggs', file_origin='testfile.txt', arg1='test') t_start = None t_stop = 250 result = self.signal1.time_slice(t_start, t_stop) assert_array_equal(result, targ_signal) assert_array_equal(result.times, targtimequant) self.assertEqual(result.units, 1 * pq.mV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) assert_arrays_equal(result.array_annotations['anno1'], np.array([23])) assert_arrays_equal(result.array_annotations['anno2'], np.array(['A'])) self.assertIsInstance(result.array_annotations, ArrayDict) def test_time_slice_none_both(self): targdataquant = [[0.0], [1.0], [2.0], [3.0], [4.0], [5.0], [6.0], [7.0], [8.0], [9.0]] * pq.mV targtime = np.logspace(1, 5, 10) targtimequant = targtime[0:10] * pq.ms targ_signal = IrregularlySampledSignal(targtimequant, signal=targdataquant, name='spam', description='eggs', file_origin='testfile.txt', arg1='test') t_start = None t_stop = None result = self.signal1.time_slice(t_start, t_stop) assert_array_equal(result, targ_signal) assert_array_equal(result.times, targtimequant) self.assertEqual(result.units, 1 * pq.mV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) assert_arrays_equal(result.array_annotations['anno1'], np.array([23])) assert_arrays_equal(result.array_annotations['anno2'], np.array(['A'])) self.assertIsInstance(result.array_annotations, ArrayDict) def test_time_slice_differnt_units(self): targdataquant = [[1.0], [2.0], [3.0]] * pq.mV targtime = np.logspace(1, 5, 10) targtimequant = targtime[1:4] * pq.ms targ_signal = IrregularlySampledSignal(targtimequant, signal=targdataquant, name='spam', description='eggs', file_origin='testfile.txt', arg1='test') t_start = 15 t_stop = 250 t_start = 0.015 * pq.s t_stop = .250 * pq.s result = self.signal1.time_slice(t_start, t_stop) assert_array_equal(result, targ_signal) assert_array_equal(result.times, targtimequant) self.assertEqual(result.units, 1 * pq.mV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) assert_arrays_equal(result.array_annotations['anno1'], np.array([23])) assert_arrays_equal(result.array_annotations['anno2'], np.array(['A'])) self.assertIsInstance(result.array_annotations, ArrayDict) def test_as_array(self): sig_as_arr = self.signal1.as_array() self.assertIsInstance(sig_as_arr, np.ndarray) assert_array_equal(self.data1, sig_as_arr.flat) def test_as_quantity(self): sig_as_q = self.signal1.as_quantity() self.assertIsInstance(sig_as_q, pq.Quantity) assert_array_equal(self.data1, sig_as_q.magnitude.flat) def test__copy_should_preserve_parent_objects(self): result = self.signal1.copy() self.assertIs(result.segment, self.signal1.segment) self.assertIs(result.channel_index, self.signal1.channel_index)
class TestIrregularlySampledSignalArrayMethods(unittest.TestCase): def setUp(self): self.data1 = np.arange(10.0) self.data1quant = self.data1 * pq.mV self.time1 = np.logspace(1, 5, 10) self.time1quant = self.time1*pq.ms self.signal1 = IrregularlySampledSignal(self.time1quant, signal=self.data1quant, name='spam', description='eggs', file_origin='testfile.txt', arg1='test') self.signal1.segment = Segment() self.signal1.channel_index = ChannelIndex([0]) def test__compliant(self): assert_neo_object_is_compliant(self.signal1) self.assertEqual(self.signal1.name, 'spam') self.assertEqual(self.signal1.description, 'eggs') self.assertEqual(self.signal1.file_origin, 'testfile.txt') self.assertEqual(self.signal1.annotations, {'arg1': 'test'}) def test__slice_should_return_IrregularlySampledSignal(self): result = self.signal1[3:8] self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) self.assertEqual(result.size, 5) self.assertEqual(result.t_start, self.time1quant[3]) self.assertEqual(result.t_stop, self.time1quant[7]) assert_array_equal(self.time1quant[3:8], result.times) assert_array_equal(self.data1[3:8].reshape(-1, 1), result.magnitude) # Test other attributes were copied over (in this case, defaults) self.assertEqual(result.file_origin, self.signal1.file_origin) self.assertEqual(result.name, self.signal1.name) self.assertEqual(result.description, self.signal1.description) self.assertEqual(result.annotations, self.signal1.annotations) def test__getitem_should_return_single_quantity(self): self.assertEqual(self.signal1[0], 0*pq.mV) self.assertEqual(self.signal1[9], 9*pq.mV) self.assertRaises(IndexError, self.signal1.__getitem__, 10) def test__getitem_out_of_bounds_IndexError(self): self.assertRaises(IndexError, self.signal1.__getitem__, 10) def test_comparison_operators(self): assert_array_equal(self.signal1 >= 5*pq.mV, np.array([[False, False, False, False, False, True, True, True, True, True]]).T) def test__comparison_with_inconsistent_units_should_raise_Exception(self): self.assertRaises(ValueError, self.signal1.__gt__, 5*pq.nA) def test_simple_statistics(self): targmean = self.signal1[:-1]*np.diff(self.time1quant).reshape(-1, 1) targmean = targmean.sum()/(self.time1quant[-1] - self.time1quant[0]) self.assertEqual(self.signal1.max(), 9*pq.mV) self.assertEqual(self.signal1.min(), 0*pq.mV) self.assertEqual(self.signal1.mean(), targmean) def test_mean_interpolation_NotImplementedError(self): self.assertRaises(NotImplementedError, self.signal1.mean, True) def test_resample_NotImplementedError(self): self.assertRaises(NotImplementedError, self.signal1.resample, True) def test__rescale_same(self): result = self.signal1.copy() result = result.rescale(pq.mV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) self.assertEqual(result.units, 1*pq.mV) assert_array_equal(result.magnitude, self.data1.reshape(-1, 1)) assert_array_equal(result.times, self.time1quant) assert_same_sub_schema(result, self.signal1) self.assertIsInstance(result.channel_index, ChannelIndex) self.assertIsInstance(result.segment, Segment) self.assertIs(result.channel_index, self.signal1.channel_index) self.assertIs(result.segment, self.signal1.segment) def test__rescale_new(self): result = self.signal1.copy() result = result.rescale(pq.uV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) self.assertEqual(result.units, 1*pq.uV) assert_arrays_almost_equal(np.array(result), self.data1.reshape(-1, 1)*1000., 1e-10) assert_array_equal(result.times, self.time1quant) self.assertIsInstance(result.channel_index, ChannelIndex) self.assertIsInstance(result.segment, Segment) self.assertIs(result.channel_index, self.signal1.channel_index) self.assertIs(result.segment, self.signal1.segment) def test__rescale_new_incompatible_ValueError(self): self.assertRaises(ValueError, self.signal1.rescale, pq.nA) def test_time_slice(self): targdataquant = [[1.0], [2.0], [3.0]] * pq.mV targtime = np.logspace(1, 5, 10) targtimequant = targtime [1:4] *pq.ms targ_signal = IrregularlySampledSignal(targtimequant, signal=targdataquant, name='spam', description='eggs', file_origin='testfile.txt', arg1='test') t_start = 15 t_stop = 250 result = self.signal1.time_slice(t_start, t_stop) assert_array_equal(result, targ_signal) assert_array_equal(result.times, targtimequant) self.assertEqual(result.units, 1*pq.mV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) def test_time_slice_out_of_boundries(self): targdataquant = self.data1quant targtimequant = self.time1quant targ_signal = IrregularlySampledSignal(targtimequant, signal=targdataquant, name='spam', description='eggs', file_origin='testfile.txt', arg1='test') t_start = 0 t_stop = 2500000 result = self.signal1.time_slice(t_start, t_stop) assert_array_equal(result, targ_signal) assert_array_equal(result.times, targtimequant) self.assertEqual(result.units, 1*pq.mV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) def test_time_slice_empty(self): targdataquant = [] * pq.mV targtimequant = [] *pq.ms targ_signal = IrregularlySampledSignal(targtimequant, signal=targdataquant, name='spam', description='eggs', file_origin='testfile.txt', arg1='test') t_start = 15 t_stop = 250 result = targ_signal.time_slice(t_start, t_stop) assert_array_equal(result, targ_signal) assert_array_equal(result.times, targtimequant) self.assertEqual(result.units, 1*pq.mV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) def test_time_slice_none_stop(self): targdataquant = [[1.0], [2.0], [3.0], [4.0], [5.0], [6.0], [7.0], [8.0], [9.0]] * pq.mV targtime = np.logspace(1, 5, 10) targtimequant = targtime [1:10] *pq.ms targ_signal = IrregularlySampledSignal(targtimequant, signal=targdataquant, name='spam', description='eggs', file_origin='testfile.txt', arg1='test') t_start = 15 t_stop = None result = self.signal1.time_slice(t_start, t_stop) assert_array_equal(result, targ_signal) assert_array_equal(result.times, targtimequant) self.assertEqual(result.units, 1*pq.mV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) def test_time_slice_none_start(self): targdataquant = [[0.0], [1.0], [2.0], [3.0]] * pq.mV targtime = np.logspace(1, 5, 10) targtimequant = targtime [0:4] *pq.ms targ_signal = IrregularlySampledSignal(targtimequant, signal=targdataquant, name='spam', description='eggs', file_origin='testfile.txt', arg1='test') t_start = None t_stop = 250 result = self.signal1.time_slice(t_start, t_stop) assert_array_equal(result, targ_signal) assert_array_equal(result.times, targtimequant) self.assertEqual(result.units, 1*pq.mV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) def test_time_slice_none_both(self): targdataquant = [[0.0], [1.0], [2.0], [3.0], [4.0], [5.0], [6.0], [7.0], [8.0], [9.0]] * pq.mV targtime = np.logspace(1, 5, 10) targtimequant = targtime [0:10] *pq.ms targ_signal = IrregularlySampledSignal(targtimequant, signal=targdataquant, name='spam', description='eggs', file_origin='testfile.txt', arg1='test') t_start = None t_stop = None result = self.signal1.time_slice(t_start, t_stop) assert_array_equal(result, targ_signal) assert_array_equal(result.times, targtimequant) self.assertEqual(result.units, 1*pq.mV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) def test_time_slice_differnt_units(self): targdataquant = [[1.0], [2.0], [3.0]] * pq.mV targtime = np.logspace(1, 5, 10) targtimequant = targtime [1:4] *pq.ms targ_signal = IrregularlySampledSignal(targtimequant, signal=targdataquant, name='spam', description='eggs', file_origin='testfile.txt', arg1='test') t_start = 15 t_stop = 250 t_start = 0.015 * pq.s t_stop = .250 * pq.s result = self.signal1.time_slice(t_start, t_stop) assert_array_equal(result, targ_signal) assert_array_equal(result.times, targtimequant) self.assertEqual(result.units, 1*pq.mV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) def test_as_array(self): sig_as_arr = self.signal1.as_array() self.assertIsInstance(sig_as_arr, np.ndarray) assert_array_equal(self.data1, sig_as_arr.flat) def test_as_quantity(self): sig_as_q = self.signal1.as_quantity() self.assertIsInstance(sig_as_q, pq.Quantity) assert_array_equal(self.data1, sig_as_q.magnitude.flat) def test__copy_should_preserve_parent_objects(self): result = self.signal1.copy() self.assertIs(result.segment, self.signal1.segment) self.assertIs(result.channel_index, self.signal1.channel_index)
class TestIrregularlySampledSignalArrayMethods(unittest.TestCase): def setUp(self): self.data1 = np.arange(10.0) self.data1quant = self.data1 * pq.mV self.time1 = np.logspace(1, 5, 10) self.time1quant = self.time1 * pq.ms self.arr_ann = {'anno1': [23], 'anno2': ['A']} self.signal1 = IrregularlySampledSignal(self.time1quant, signal=self.data1quant, name='spam', description='eggs', file_origin='testfile.txt', arg1='test', array_annotations=self.arr_ann) self.signal1.segment = Segment() self.signal1.channel_index = ChannelIndex([0]) def test__compliant(self): assert_neo_object_is_compliant(self.signal1) self.assertEqual(self.signal1.name, 'spam') self.assertEqual(self.signal1.description, 'eggs') self.assertEqual(self.signal1.file_origin, 'testfile.txt') self.assertEqual(self.signal1.annotations, {'arg1': 'test'}) assert_arrays_equal(self.signal1.array_annotations['anno1'], np.array([23])) assert_arrays_equal(self.signal1.array_annotations['anno2'], np.array(['A'])) self.assertIsInstance(self.signal1.array_annotations, ArrayDict) def test__slice_should_return_IrregularlySampledSignal(self): result = self.signal1[3:8] self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) self.assertEqual(result.size, 5) self.assertEqual(result.t_start, self.time1quant[3]) self.assertEqual(result.t_stop, self.time1quant[7]) assert_array_equal(self.time1quant[3:8], result.times) assert_array_equal(self.data1[3:8].reshape(-1, 1), result.magnitude) # Test other attributes were copied over (in this case, defaults) self.assertEqual(result.file_origin, self.signal1.file_origin) self.assertEqual(result.name, self.signal1.name) self.assertEqual(result.description, self.signal1.description) self.assertEqual(result.annotations, self.signal1.annotations) assert_arrays_equal(result.array_annotations['anno1'], np.array([23])) assert_arrays_equal(result.array_annotations['anno2'], np.array(['A'])) self.assertIsInstance(result.array_annotations, ArrayDict) def test__getitem_should_return_single_quantity(self): self.assertEqual(self.signal1[0], 0 * pq.mV) self.assertEqual(self.signal1[9], 9 * pq.mV) self.assertRaises(IndexError, self.signal1.__getitem__, 10) def test__getitem_out_of_bounds_IndexError(self): self.assertRaises(IndexError, self.signal1.__getitem__, 10) def test_comparison_operators(self): assert_array_equal( self.signal1 >= 5 * pq.mV, np.array([[ False, False, False, False, False, True, True, True, True, True ]]).T) assert_array_equal( self.signal1 == 5 * pq.mV, np.array([[ False, False, False, False, False, True, False, False, False, False ]]).T) assert_array_equal( self.signal1 == self.signal1, np.array( [[True, True, True, True, True, True, True, True, True, True]]).T) def test__comparison_as_indexing_single_trace(self): self.assertEqual(self.signal1[self.signal1 == 5], [5 * pq.mV]) def test__comparison_as_indexing_multi_trace(self): signal = IrregularlySampledSignal( self.time1quant, np.arange(20).reshape((-1, 2)) * pq.V) assert_array_equal( signal[signal < 10], np.array([[0, 2, 4, 6, 8], [1, 3, 5, 7, 9]]).T * pq.V) def test__indexing_keeps_order_across_channels(self): # AnalogSignals with 10 traces each having 5 samples (eg. data[0] = [0,10,20,30,40]) data = np.array([ range(10), range(10, 20), range(20, 30), range(30, 40), range(40, 50) ]) mask = np.full((5, 10), fill_value=False, dtype=bool) # selecting one entry per trace mask[[0, 1, 0, 3, 0, 2, 4, 3, 1, 4], range(10)] = True signal = IrregularlySampledSignal( np.arange(5) * pq.s, np.array(data) * pq.V) assert_array_equal( signal[mask], np.array([[0, 11, 2, 33, 4, 25, 46, 37, 18, 49]]) * pq.V) def test__indexing_keeps_order_across_time(self): # AnalogSignals with 10 traces each having 5 samples (eg. data[0] = [0,10,20,30,40]) data = np.array([ range(10), range(10, 20), range(20, 30), range(30, 40), range(40, 50) ]) mask = np.full((5, 10), fill_value=False, dtype=bool) # selecting two entries per trace temporal_ids = [0, 1, 0, 3, 1, 2, 4, 2, 1, 4 ] + [4, 3, 2, 1, 0, 1, 2, 3, 2, 1] mask[temporal_ids, list(range(10)) + list(range(10))] = True signal = IrregularlySampledSignal( np.arange(5) * pq.s, np.array(data) * pq.V) assert_array_equal( signal[mask], np.array([[0, 11, 2, 13, 4, 15, 26, 27, 18, 19], [40, 31, 22, 33, 14, 25, 46, 37, 28, 49]]) * pq.V) def test__comparison_with_inconsistent_units_should_raise_Exception(self): self.assertRaises(ValueError, self.signal1.__gt__, 5 * pq.nA) def test_simple_statistics(self): targmean = self.signal1[:-1] * np.diff(self.time1quant).reshape(-1, 1) targmean = targmean.sum() / (self.time1quant[-1] - self.time1quant[0]) self.assertEqual(self.signal1.max(), 9 * pq.mV) self.assertEqual(self.signal1.min(), 0 * pq.mV) self.assertEqual(self.signal1.mean(), targmean) def test_mean_interpolation_NotImplementedError(self): self.assertRaises(NotImplementedError, self.signal1.mean, True) def test_resample_NotImplementedError(self): self.assertRaises(NotImplementedError, self.signal1.resample, True) def test__rescale_same(self): result = self.signal1.copy() result = result.rescale(pq.mV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) assert_arrays_equal(result.array_annotations['anno1'], np.array([23])) assert_arrays_equal(result.array_annotations['anno2'], np.array(['A'])) self.assertIsInstance(result.array_annotations, ArrayDict) self.assertEqual(result.units, 1 * pq.mV) assert_array_equal(result.magnitude, self.data1.reshape(-1, 1)) assert_array_equal(result.times, self.time1quant) assert_same_sub_schema(result, self.signal1) self.assertIsInstance(result.channel_index, ChannelIndex) self.assertIsInstance(result.segment, Segment) self.assertIs(result.channel_index, self.signal1.channel_index) self.assertIs(result.segment, self.signal1.segment) def test__rescale_new(self): result = self.signal1.copy() result = result.rescale(pq.uV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) assert_arrays_equal(result.array_annotations['anno1'], np.array([23])) assert_arrays_equal(result.array_annotations['anno2'], np.array(['A'])) self.assertIsInstance(result.array_annotations, ArrayDict) self.assertEqual(result.units, 1 * pq.uV) assert_arrays_almost_equal(np.array(result), self.data1.reshape(-1, 1) * 1000., 1e-10) assert_array_equal(result.times, self.time1quant) self.assertIsInstance(result.channel_index, ChannelIndex) self.assertIsInstance(result.segment, Segment) self.assertIs(result.channel_index, self.signal1.channel_index) self.assertIs(result.segment, self.signal1.segment) def test__rescale_new_incompatible_ValueError(self): self.assertRaises(ValueError, self.signal1.rescale, pq.nA) def test_time_slice(self): targdataquant = [[1.0], [2.0], [3.0]] * pq.mV targtime = np.logspace(1, 5, 10) targtimequant = targtime[1:4] * pq.ms targ_signal = IrregularlySampledSignal(targtimequant, signal=targdataquant, name='spam', description='eggs', file_origin='testfile.txt', arg1='test') t_start = 15 t_stop = 250 result = self.signal1.time_slice(t_start, t_stop) assert_array_equal(result, targ_signal) assert_array_equal(result.times, targtimequant) self.assertEqual(result.units, 1 * pq.mV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) assert_arrays_equal(result.array_annotations['anno1'], np.array([23])) assert_arrays_equal(result.array_annotations['anno2'], np.array(['A'])) self.assertIsInstance(result.array_annotations, ArrayDict) def test__time_slice_deepcopy_annotations(self): params1 = {'test0': 'y1', 'test1': ['deeptest'], 'test2': True} self.signal1.annotate(**params1) result = self.signal1.time_slice(None, None) # Change annotations of original params2 = {'test0': 'y2', 'test2': False} self.signal1.annotate(**params2) self.signal1.annotations['test1'][0] = 'shallowtest' self.assertNotEqual(self.signal1.annotations['test0'], result.annotations['test0']) self.assertNotEqual(self.signal1.annotations['test1'], result.annotations['test1']) self.assertNotEqual(self.signal1.annotations['test2'], result.annotations['test2']) # Change annotations of result params3 = {'test0': 'y3'} result.annotate(**params3) result.annotations['test1'][0] = 'shallowtest2' self.assertNotEqual(self.signal1.annotations['test0'], result.annotations['test0']) self.assertNotEqual(self.signal1.annotations['test1'], result.annotations['test1']) self.assertNotEqual(self.signal1.annotations['test2'], result.annotations['test2']) def test__time_slice_deepcopy_array_annotations(self): length = self.signal1.shape[-1] params1 = { 'test0': ['y{}'.format(i) for i in range(length)], 'test1': ['deeptest' for i in range(length)], 'test2': [(-1)**i > 0 for i in range(length)] } self.signal1.array_annotate(**params1) result = self.signal1.time_slice(None, None) # Change annotations of original params2 = { 'test0': ['x{}'.format(i) for i in range(length)], 'test2': [(-1)**(i + 1) > 0 for i in range(length)] } self.signal1.array_annotate(**params2) self.signal1.array_annotations['test1'][0] = 'shallowtest' self.assertFalse( all(self.signal1.array_annotations['test0'] == result.array_annotations['test0'])) self.assertFalse( all(self.signal1.array_annotations['test1'] == result.array_annotations['test1'])) self.assertFalse( all(self.signal1.array_annotations['test2'] == result.array_annotations['test2'])) # Change annotations of result params3 = { 'test0': ['z{}'.format(i) for i in range(1, result.shape[-1] + 1)] } result.array_annotate(**params3) result.array_annotations['test1'][0] = 'shallow2' self.assertFalse( all(self.signal1.array_annotations['test0'] == result.array_annotations['test0'])) self.assertFalse( all(self.signal1.array_annotations['test1'] == result.array_annotations['test1'])) self.assertFalse( all(self.signal1.array_annotations['test2'] == result.array_annotations['test2'])) def test__time_slice_deepcopy_data(self): result = self.signal1.time_slice(None, None) # Change values of original array self.signal1[2] = 7.3 * self.signal1.units self.assertFalse(all(self.signal1 == result)) # Change values of sliced array result[3] = 9.5 * result.units self.assertFalse(all(self.signal1 == result)) def test_time_slice_out_of_boundries(self): targdataquant = self.data1quant targtimequant = self.time1quant targ_signal = IrregularlySampledSignal(targtimequant, signal=targdataquant, name='spam', description='eggs', file_origin='testfile.txt', arg1='test') t_start = 0 t_stop = 2500000 result = self.signal1.time_slice(t_start, t_stop) assert_array_equal(result, targ_signal) assert_array_equal(result.times, targtimequant) self.assertEqual(result.units, 1 * pq.mV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) assert_arrays_equal(result.array_annotations['anno1'], np.array([23])) assert_arrays_equal(result.array_annotations['anno2'], np.array(['A'])) self.assertIsInstance(result.array_annotations, ArrayDict) def test_time_slice_empty(self): targdataquant = [] * pq.mV targtimequant = [] * pq.ms targ_signal = IrregularlySampledSignal(targtimequant, signal=targdataquant, name='spam', description='eggs', file_origin='testfile.txt', arg1='test') t_start = 15 t_stop = 250 result = targ_signal.time_slice(t_start, t_stop) assert_array_equal(result, targ_signal) assert_array_equal(result.times, targtimequant) self.assertEqual(result.units, 1 * pq.mV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) self.assertEqual(result.array_annotations, {}) self.assertIsInstance(result.array_annotations, ArrayDict) def test_time_slice_none_stop(self): targdataquant = [[1.0], [2.0], [3.0], [4.0], [5.0], [6.0], [7.0], [8.0], [9.0]] * pq.mV targtime = np.logspace(1, 5, 10) targtimequant = targtime[1:10] * pq.ms targ_signal = IrregularlySampledSignal(targtimequant, signal=targdataquant, name='spam', description='eggs', file_origin='testfile.txt', arg1='test') t_start = 15 t_stop = None result = self.signal1.time_slice(t_start, t_stop) assert_array_equal(result, targ_signal) assert_array_equal(result.times, targtimequant) self.assertEqual(result.units, 1 * pq.mV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) assert_arrays_equal(result.array_annotations['anno1'], np.array([23])) assert_arrays_equal(result.array_annotations['anno2'], np.array(['A'])) self.assertIsInstance(result.array_annotations, ArrayDict) def test_time_slice_none_start(self): targdataquant = [[0.0], [1.0], [2.0], [3.0]] * pq.mV targtime = np.logspace(1, 5, 10) targtimequant = targtime[0:4] * pq.ms targ_signal = IrregularlySampledSignal(targtimequant, signal=targdataquant, name='spam', description='eggs', file_origin='testfile.txt', arg1='test') t_start = None t_stop = 250 result = self.signal1.time_slice(t_start, t_stop) assert_array_equal(result, targ_signal) assert_array_equal(result.times, targtimequant) self.assertEqual(result.units, 1 * pq.mV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) assert_arrays_equal(result.array_annotations['anno1'], np.array([23])) assert_arrays_equal(result.array_annotations['anno2'], np.array(['A'])) self.assertIsInstance(result.array_annotations, ArrayDict) def test_time_slice_none_both(self): targdataquant = [[0.0], [1.0], [2.0], [3.0], [4.0], [5.0], [6.0], [7.0], [8.0], [9.0]] * pq.mV targtime = np.logspace(1, 5, 10) targtimequant = targtime[0:10] * pq.ms targ_signal = IrregularlySampledSignal(targtimequant, signal=targdataquant, name='spam', description='eggs', file_origin='testfile.txt', arg1='test') t_start = None t_stop = None result = self.signal1.time_slice(t_start, t_stop) assert_array_equal(result, targ_signal) assert_array_equal(result.times, targtimequant) self.assertEqual(result.units, 1 * pq.mV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) assert_arrays_equal(result.array_annotations['anno1'], np.array([23])) assert_arrays_equal(result.array_annotations['anno2'], np.array(['A'])) self.assertIsInstance(result.array_annotations, ArrayDict) def test_time_slice_differnt_units(self): targdataquant = [[1.0], [2.0], [3.0]] * pq.mV targtime = np.logspace(1, 5, 10) targtimequant = targtime[1:4] * pq.ms targ_signal = IrregularlySampledSignal(targtimequant, signal=targdataquant, name='spam', description='eggs', file_origin='testfile.txt', arg1='test') t_start = 15 t_stop = 250 t_start = 0.015 * pq.s t_stop = .250 * pq.s result = self.signal1.time_slice(t_start, t_stop) assert_array_equal(result, targ_signal) assert_array_equal(result.times, targtimequant) self.assertEqual(result.units, 1 * pq.mV) self.assertIsInstance(result, IrregularlySampledSignal) assert_neo_object_is_compliant(result) self.assertEqual(result.name, 'spam') self.assertEqual(result.description, 'eggs') self.assertEqual(result.file_origin, 'testfile.txt') self.assertEqual(result.annotations, {'arg1': 'test'}) assert_arrays_equal(result.array_annotations['anno1'], np.array([23])) assert_arrays_equal(result.array_annotations['anno2'], np.array(['A'])) self.assertIsInstance(result.array_annotations, ArrayDict) def test__time_slice_should_set_parents_to_None(self): # When timeslicing, a deep copy is made, # thus the reference to parent objects should be destroyed result = self.signal1.time_slice(1 * pq.ms, 3 * pq.ms) self.assertEqual(result.segment, None) self.assertEqual(result.channel_index, None) def test__deepcopy_should_set_parents_objects_to_None(self): # Deepcopy should destroy references to parents result = deepcopy(self.signal1) self.assertEqual(result.segment, None) self.assertEqual(result.channel_index, None) def test_as_array(self): sig_as_arr = self.signal1.as_array() self.assertIsInstance(sig_as_arr, np.ndarray) assert_array_equal(self.data1, sig_as_arr.flat) def test_as_quantity(self): sig_as_q = self.signal1.as_quantity() self.assertIsInstance(sig_as_q, pq.Quantity) assert_array_equal(self.data1, sig_as_q.magnitude.flat) def test__copy_should_preserve_parent_objects(self): result = self.signal1.copy() self.assertIs(result.segment, self.signal1.segment) self.assertIs(result.channel_index, self.signal1.channel_index)