class TestAnalogSignalArrayArrayMethods(unittest.TestCase):
def setUp(self):
self.data1 = np.arange(55.0).reshape((11, 5))
self.data1quant = self.data1 * pq.nA
self.signal1 = AnalogSignalArray(self.data1quant,
sampling_rate=1*pq.kHz,
name='spam', description='eggs',
file_origin='testfile.txt',
arg1='test')
self.data2 = np.array([[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]]).T
self.data2quant = self.data2 * pq.mV
self.signal2 = AnalogSignalArray(self.data2quant,
sampling_rate=1.0*pq.Hz,
name='spam', description='eggs',
file_origin='testfile.txt',
arg1='test')
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_neo_object_is_compliant(self.signal2)
self.assertEqual(self.signal2.name, 'spam')
self.assertEqual(self.signal2.description, 'eggs')
self.assertEqual(self.signal2.file_origin, 'testfile.txt')
self.assertEqual(self.signal2.annotations, {'arg1': 'test'})
def test__index_dim1_should_return_analogsignal(self):
result = self.signal1[:, 0]
self.assertIsInstance(result, AnalogSignal)
assert_neo_object_is_compliant(result)
self.assertEqual(result.name, None)
self.assertEqual(result.description, None)
self.assertEqual(result.file_origin, None)
self.assertEqual(result.annotations, {})
self.assertEqual(result.t_stop, self.signal1.t_stop)
self.assertEqual(result.t_start, self.signal1.t_start)
self.assertEqual(result.sampling_rate,
self.signal1.sampling_rate)
assert_arrays_equal(result, self.data1[:, 0])
def test__index_dim1_and_slice_dim0_should_return_analogsignal(self):
result = self.signal1[2:7, 0]
self.assertIsInstance(result, AnalogSignal)
assert_neo_object_is_compliant(result)
self.assertEqual(result.name, None)
self.assertEqual(result.description, None)
self.assertEqual(result.file_origin, None)
self.assertEqual(result.annotations, {})
self.assertEqual(result.t_start,
self.signal1.t_start+2*self.signal1.sampling_period)
self.assertEqual(result.t_stop,
self.signal1.t_start+7*self.signal1.sampling_period)
self.assertEqual(result.sampling_rate,
self.signal1.sampling_rate)
assert_arrays_equal(result, self.data1[2:7, 0])
def test__index_dim0_should_return_quantity_array(self):
# i.e. values from all signals for a single point in time
result = self.signal1[3, :]
self.assertIsInstance(result, pq.Quantity)
self.assertFalse(hasattr(result, 'name'))
self.assertFalse(hasattr(result, 'description'))
self.assertFalse(hasattr(result, 'file_origin'))
self.assertFalse(hasattr(result, 'annotations'))
self.assertEqual(result.shape, (5,))
self.assertFalse(hasattr(result, "t_start"))
self.assertEqual(result.units, pq.nA)
assert_arrays_equal(result, self.data1[3, :])
def test__index_dim0_and_slice_dim1_should_return_quantity_array(self):
# i.e. values from a subset of signals for a single point in time
result = self.signal1[3, 2:5]
self.assertIsInstance(result, pq.Quantity)
self.assertFalse(hasattr(result, 'name'))
self.assertFalse(hasattr(result, 'description'))
self.assertFalse(hasattr(result, 'file_origin'))
self.assertFalse(hasattr(result, 'annotations'))
self.assertEqual(result.shape, (3,))
self.assertFalse(hasattr(result, "t_start"))
self.assertEqual(result.units, pq.nA)
assert_arrays_equal(result, self.data1[3, 2:5])
def test__index_as_string_IndexError(self):
self.assertRaises(IndexError, self.signal1.__getitem__, 5.)
def test__slice_both_dimensions_should_return_analogsignalarray(self):
result = self.signal1[0:3, 0:3]
self.assertIsInstance(result, AnalogSignalArray)
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'})
targ = AnalogSignalArray([[0, 1, 2], [5, 6, 7], [10, 11, 12]],
dtype=float, units="nA",
sampling_rate=1*pq.kHz,
name='spam', description='eggs',
file_origin='testfile.txt', arg1='test')
assert_neo_object_is_compliant(targ)
self.assertEqual(result.t_stop, targ.t_stop)
self.assertEqual(result.t_start, targ.t_start)
self.assertEqual(result.sampling_rate, targ.sampling_rate)
self.assertEqual(result.shape, targ.shape)
assert_same_sub_schema(result, targ)
assert_arrays_equal(result, self.data1[0:3, 0:3])
def test__slice_only_first_dimension_should_return_analogsignalarray(self):
result = self.signal1[2:7]
self.assertIsInstance(result, AnalogSignalArray)
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.shape, (5, 5))
self.assertEqual(result.t_start,
self.signal1.t_start+2*self.signal1.sampling_period)
self.assertEqual(result.t_stop,
self.signal1.t_start+7*self.signal1.sampling_period)
self.assertEqual(result.sampling_rate, self.signal1.sampling_rate)
assert_arrays_equal(result, self.data1[2:7])
def test__getitem_should_return_single_quantity(self):
# quantities drops the units in this case
self.assertEqual(self.signal1[9, 3], 48000*pq.pA)
self.assertEqual(self.signal1[9][3], self.signal1[9, 3])
self.assertTrue(hasattr(self.signal1[9, 3], 'units'))
self.assertRaises(IndexError, self.signal1.__getitem__, (99, 73))
def test_comparison_operators(self):
assert_arrays_equal(self.signal1[0:3, 0:3] >= 5*pq.nA,
np.array([[False, False, False],
[True, True, True],
[True, True, True]]))
assert_arrays_equal(self.signal1[0:3, 0:3] >= 5*pq.pA,
np.array([[False, True, True],
[True, True, True],
[True, True, True]]))
def test__comparison_with_inconsistent_units_should_raise_Exception(self):
self.assertRaises(ValueError, self.signal1.__gt__, 5*pq.mV)
def test__simple_statistics(self):
self.assertEqual(self.signal1.max(), 54000*pq.pA)
self.assertEqual(self.signal1.min(), 0*pq.nA)
self.assertEqual(self.signal1.mean(), 27*pq.nA)
def test__rescale_same(self):
result = self.signal1.copy()
result = result.rescale(pq.nA)
self.assertIsInstance(result, AnalogSignalArray)
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.nA)
assert_arrays_equal(result, self.data1)
assert_same_sub_schema(result, self.signal1)
def test__rescale_new(self):
result = self.signal1.copy()
result = result.rescale(pq.pA)
self.assertIsInstance(result, AnalogSignalArray)
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.pA)
assert_arrays_almost_equal(np.array(result), self.data1*1000., 1e-10)
def test__time_slice(self):
t_start = 2 * pq.s
t_stop = 4 * pq.s
result = self.signal2.time_slice(t_start, t_stop)
self.assertIsInstance(result, AnalogSignalArray)
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'})
targ = AnalogSignalArray(np.array([[2, 3], [2, 3]]).T,
sampling_rate=1.0*pq.Hz, units='mV',
t_start=t_start,
name='spam', description='eggs',
file_origin='testfile.txt', arg1='test')
assert_neo_object_is_compliant(result)
self.assertEqual(result.t_stop, t_stop)
self.assertEqual(result.t_start, t_start)
self.assertEqual(result.sampling_rate, targ.sampling_rate)
assert_arrays_equal(result, targ)
assert_same_sub_schema(result, targ)
def test__time_slice__out_of_bounds_ValueError(self):
t_start_good = 2 * pq.s
t_stop_good = 4 * pq.s
t_start_bad = -2 * pq.s
t_stop_bad = 40 * pq.s
self.assertRaises(ValueError, self.signal2.time_slice,
t_start_good, t_stop_bad)
self.assertRaises(ValueError, self.signal2.time_slice,
t_start_bad, t_stop_good)
self.assertRaises(ValueError, self.signal2.time_slice,
t_start_bad, t_stop_bad)
def test__time_equal(self):
t_start = 0 * pq.s
t_stop = 6 * pq.s
result = self.signal2.time_slice(t_start, t_stop)
self.assertIsInstance(result, AnalogSignalArray)
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.t_stop, t_stop)
self.assertEqual(result.t_start, t_start)
assert_arrays_equal(result, self.signal2)
assert_same_sub_schema(result, self.signal2)
def test__time_slice__offset(self):
self.signal2.t_start = 10.0 * pq.s
assert_neo_object_is_compliant(self.signal2)
t_start = 12 * pq.s
t_stop = 14 * pq.s
result = self.signal2.time_slice(t_start, t_stop)
self.assertIsInstance(result, AnalogSignalArray)
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'})
targ = AnalogSignalArray(np.array([[2, 3], [2, 3]]).T,
t_start=12.0*pq.ms,
sampling_rate=1.0*pq.Hz, units='mV',
name='spam', description='eggs',
file_origin='testfile.txt', arg1='test')
assert_neo_object_is_compliant(result)
self.assertEqual(self.signal2.t_start, 10.0 * pq.s)
self.assertEqual(result.t_stop, t_stop)
self.assertEqual(result.t_start, t_start)
self.assertEqual(result.sampling_rate, targ.sampling_rate)
assert_arrays_equal(result, targ)
assert_same_sub_schema(result, targ)
def test__time_slice__different_units(self):
self.signal2.t_start = 10.0 * pq.ms
assert_neo_object_is_compliant(self.signal2)
t_start = 2 * pq.s + 10.0 * pq.ms
t_stop = 4 * pq.s + 10.0 * pq.ms
result = self.signal2.time_slice(t_start, t_stop)
self.assertIsInstance(result, AnalogSignalArray)
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'})
targ = AnalogSignalArray(np.array([[2, 3], [2, 3]]).T,
t_start=t_start.rescale(pq.ms),
sampling_rate=1.0*pq.Hz, units='mV',
name='spam', description='eggs',
file_origin='testfile.txt', arg1='test')
assert_neo_object_is_compliant(result)
assert_neo_object_is_compliant(self.signal2)
self.assertEqual(self.signal2.t_start, 10.0 * pq.ms)
self.assertAlmostEqual(result.t_stop, t_stop, delta=1e-12*pq.ms)
self.assertAlmostEqual(result.t_start, t_start, delta=1e-12*pq.ms)
assert_arrays_almost_equal(result.times, targ.times, 1e-12*pq.ms)
self.assertEqual(result.sampling_rate, targ.sampling_rate)
assert_arrays_equal(result, targ)
assert_same_sub_schema(result, targ)
class TestArrayMethods(unittest.TestCase):
def setUp(self):
self.signal = AnalogSignalArray(numpy.arange(55.0).reshape((11,5)), units="nA", sampling_rate=1*kHz)
def test__index_dim1_should_return_analogsignal(self):
single_signal = self.signal[:, 0]
self.assertIsInstance(single_signal, AnalogSignal)
self.assertEqual(single_signal.t_stop, self.signal.t_stop)
self.assertEqual(single_signal.t_start, self.signal.t_start)
self.assertEqual(single_signal.sampling_rate, self.signal.sampling_rate)
def test__index_dim1_and_slice_dim0_should_return_analogsignal(self):
single_signal = self.signal[2:7,0]
self.assertIsInstance(single_signal, AnalogSignal)
self.assertEqual(single_signal.t_start, self.signal.t_start+2*self.signal.sampling_period)
self.assertEqual(single_signal.t_stop, self.signal.t_start+7*self.signal.sampling_period)
self.assertEqual(single_signal.sampling_rate, self.signal.sampling_rate)
def test__index_dim0_should_return_quantity_array(self):
# i.e. values from all signals for a single point in time
values = self.signal[3, :]
self.assertNotIsInstance(values, AnalogSignalArray)
self.assertEqual(values.shape, (5,))
assert not hasattr(values, "t_start")
self.assertEqual(values.units, pq.nA)
def test__index_dim0_and_slice_dim1_should_return_quantity_array(self):
# i.e. values from a subset of signals for a single point in time
values = self.signal[3, 2:5]
self.assertNotIsInstance(values, AnalogSignalArray)
self.assertEqual(values.shape, (3,))
assert not hasattr(values, "t_start")
self.assertEqual(values.units, pq.nA)
def test__slice_both_dimensions_should_return_analogsignalarray(self):
values = self.signal[0:3, 0:3]
assert_arrays_equal(values, AnalogSignalArray([[0, 1, 2], [5, 6, 7], [10, 11, 12]], dtype=float, units="nA", sampling_rate=1*kHz))
def test__slice_only_first_dimension_should_return_analogsignalarray(self):
signal2 = self.signal[2:7]
self.assertIsInstance(signal2, AnalogSignalArray)
self.assertEqual(signal2.shape, (5,5))
self.assertEqual(signal2.t_start, self.signal.t_start+2*self.signal.sampling_period)
self.assertEqual(signal2.t_stop, self.signal.t_start+7*self.signal.sampling_period)
self.assertEqual(signal2.sampling_rate, self.signal.sampling_rate)
def test__getitem_should_return_single_quantity(self):
self.assertEqual(self.signal[9, 3], 48000*pA) # quantities drops the units in this case
self.assertEqual(self.signal[9][3], self.signal[9, 3])
assert hasattr(self.signal[9, 3], 'units')
self.assertRaises(IndexError, self.signal.__getitem__, (99,73))
def test_comparison_operators(self):
assert_arrays_equal(self.signal[0:3, 0:3] >= 5*nA,
numpy.array([[False, False, False], [True, True, True], [True, True, True]]))
assert_arrays_equal(self.signal[0:3, 0:3] >= 5*pA,
numpy.array([[False, True, True], [True, True, True], [True, True, True]]))
def test__comparison_with_inconsistent_units_should_raise_Exception(self):
self.assertRaises(ValueError, self.signal.__gt__, 5*mV)
def test_simple_statistics(self):
self.assertEqual(self.signal.max(), 54000*pA)
self.assertEqual(self.signal.min(), 0*nA)
self.assertEqual(self.signal.mean(), 27*nA)
def test_time_slice(self):
#import numpy
av = AnalogSignalArray(numpy.array([[0,1,2,3,4,5],[0,1,2,3,4,5]]).T,sampling_rate=1.0*pq.Hz, units='mV')
t_start = 2 * pq.s
t_stop = 4 * pq.s
av2 = av.time_slice(t_start,t_stop)
correct = AnalogSignalArray(numpy.array([[2,3],[2,3]]).T, sampling_rate=1.0*pq.Hz, units='mV')
ar = numpy.array([a == b for (a,b) in zip(av2.flatten(),correct.flatten())])
self.assertEqual(ar.all(),True)
self.assertIsInstance(av2, AnalogSignalArray)
self.assertEqual(av2.t_stop,t_stop)
self.assertEqual(av2.t_start,t_start)
self.assertEqual(av2.sampling_rate, correct.sampling_rate)
def test_time_equal(self):
#import numpy
av = AnalogSignalArray(numpy.array([[0,1,2,3,4,5],[0,1,2,3,4,5]]).T,sampling_rate=1.0*pq.Hz, units='mV')
t_start = 0 * pq.s
t_stop = 6 * pq.s
av2 = av.time_slice(t_start,t_stop)
ar = numpy.array([a == b for (a,b) in zip(av2.flatten(),av.flatten())])
self.assertEqual(ar.all(),True)
self.assertIsInstance(av2, AnalogSignalArray)
self.assertEqual(av2.t_stop,t_stop)
self.assertEqual(av2.t_start,t_start)
def test_time_slice_offset(self):
#import numpy
av = AnalogSignalArray(numpy.array([[0,1,2,3,4,5],[0,1,2,3,4,5]]).T, t_start = 10.0 * pq.s,sampling_rate=1.0*pq.Hz, units='mV')
t_start = 12 * pq.s
t_stop = 14 * pq.s
av2 = av.time_slice(t_start,t_stop)
correct = AnalogSignalArray(numpy.array([[2,3],[2,3]]).T, t_start = 12.0*pq.ms,sampling_rate=1.0*pq.Hz, units='mV')
ar = numpy.array([a == b for (a,b) in zip(av2.flatten(),correct.flatten())])
self.assertEqual(ar.all(),True)
self.assertIsInstance(av2, AnalogSignalArray)
self.assertEqual(av2.t_stop,t_stop)
self.assertEqual(av2.t_start,t_start)
self.assertEqual(av2.sampling_rate, correct.sampling_rate)
def test_time_slice_different_units(self):
#import numpy
av = AnalogSignalArray(numpy.array([[0,1,2,3,4,5],[0,1,2,3,4,5]]).T, t_start = 10.0 * pq.ms,sampling_rate=1.0*pq.Hz, units='mV')
t_start = 2 * pq.s + 10.0 * pq.ms
t_stop = 4 * pq.s + 10.0 * pq.ms
av2 = av.time_slice(t_start,t_stop)
correct = AnalogSignalArray(numpy.array([[2,3],[2,3]]).T, t_start = t_start,sampling_rate=1.0*pq.Hz, units='mV')
self.assertIsInstance(av2, AnalogSignalArray)
self.assertAlmostEqual(av2.t_stop,t_stop,delta=1e-12*ms)
self.assertAlmostEqual(av2.t_start,t_start,delta=1e-12*ms)
assert_arrays_almost_equal(av2.times,correct.times,1e-12*ms)
self.assertEqual(av2.sampling_rate, correct.sampling_rate)
class TestArrayMethods(unittest.TestCase):
def setUp(self):
self.signal = AnalogSignalArray(numpy.arange(55.0).reshape((11, 5)),
units="nA",
sampling_rate=1 * kHz)
def test__index_dim1_should_return_analogsignal(self):
single_signal = self.signal[:, 0]
self.assertIsInstance(single_signal, AnalogSignal)
self.assertEqual(single_signal.t_stop, self.signal.t_stop)
self.assertEqual(single_signal.t_start, self.signal.t_start)
self.assertEqual(single_signal.sampling_rate,
self.signal.sampling_rate)
def test__index_dim1_and_slice_dim0_should_return_analogsignal(self):
single_signal = self.signal[2:7, 0]
self.assertIsInstance(single_signal, AnalogSignal)
self.assertEqual(single_signal.t_start,
self.signal.t_start + 2 * self.signal.sampling_period)
self.assertEqual(single_signal.t_stop,
self.signal.t_start + 7 * self.signal.sampling_period)
self.assertEqual(single_signal.sampling_rate,
self.signal.sampling_rate)
def test__index_dim0_should_return_quantity_array(self):
# i.e. values from all signals for a single point in time
values = self.signal[3, :]
self.assertNotIsInstance(values, AnalogSignalArray)
self.assertEqual(values.shape, (5, ))
assert not hasattr(values, "t_start")
self.assertEqual(values.units, pq.nA)
def test__index_dim0_and_slice_dim1_should_return_quantity_array(self):
# i.e. values from a subset of signals for a single point in time
values = self.signal[3, 2:5]
self.assertNotIsInstance(values, AnalogSignalArray)
self.assertEqual(values.shape, (3, ))
assert not hasattr(values, "t_start")
self.assertEqual(values.units, pq.nA)
def test__slice_both_dimensions_should_return_analogsignalarray(self):
values = self.signal[0:3, 0:3]
assert_arrays_equal(
values,
AnalogSignalArray([[0, 1, 2], [5, 6, 7], [10, 11, 12]],
dtype=float,
units="nA",
sampling_rate=1 * kHz))
def test__slice_only_first_dimension_should_return_analogsignalarray(self):
signal2 = self.signal[2:7]
self.assertIsInstance(signal2, AnalogSignalArray)
self.assertEqual(signal2.shape, (5, 5))
self.assertEqual(signal2.t_start,
self.signal.t_start + 2 * self.signal.sampling_period)
self.assertEqual(signal2.t_stop,
self.signal.t_start + 7 * self.signal.sampling_period)
self.assertEqual(signal2.sampling_rate, self.signal.sampling_rate)
def test__getitem_should_return_single_quantity(self):
self.assertEqual(self.signal[9, 3],
48000 * pA) # quantities drops the units in this case
self.assertEqual(self.signal[9][3], self.signal[9, 3])
assert hasattr(self.signal[9, 3], 'units')
self.assertRaises(IndexError, self.signal.__getitem__, (99, 73))
def test_comparison_operators(self):
assert_arrays_equal(
self.signal[0:3, 0:3] >= 5 * nA,
numpy.array([[False, False, False], [True, True, True],
[True, True, True]]))
assert_arrays_equal(
self.signal[0:3, 0:3] >= 5 * pA,
numpy.array([[False, True, True], [True, True, True],
[True, True, True]]))
def test__comparison_with_inconsistent_units_should_raise_Exception(self):
self.assertRaises(ValueError, self.signal.__gt__, 5 * mV)
def test_simple_statistics(self):
self.assertEqual(self.signal.max(), 54000 * pA)
self.assertEqual(self.signal.min(), 0 * nA)
self.assertEqual(self.signal.mean(), 27 * nA)
def test_time_slice(self):
#import numpy
av = AnalogSignalArray(numpy.array([[0, 1, 2, 3, 4, 5],
[0, 1, 2, 3, 4, 5]]).T,
sampling_rate=1.0 * pq.Hz,
units='mV')
t_start = 2 * pq.s
t_stop = 4 * pq.s
av2 = av.time_slice(t_start, t_stop)
correct = AnalogSignalArray(numpy.array([[2, 3], [2, 3]]).T,
sampling_rate=1.0 * pq.Hz,
units='mV')
ar = numpy.array(
[a == b for (a, b) in zip(av2.flatten(), correct.flatten())])
self.assertEqual(ar.all(), True)
self.assertIsInstance(av2, AnalogSignalArray)
self.assertEqual(av2.t_stop, t_stop)
self.assertEqual(av2.t_start, t_start)
self.assertEqual(av2.sampling_rate, correct.sampling_rate)
def test_time_equal(self):
#import numpy
av = AnalogSignalArray(numpy.array([[0, 1, 2, 3, 4, 5],
[0, 1, 2, 3, 4, 5]]).T,
sampling_rate=1.0 * pq.Hz,
units='mV')
t_start = 0 * pq.s
t_stop = 6 * pq.s
av2 = av.time_slice(t_start, t_stop)
ar = numpy.array(
[a == b for (a, b) in zip(av2.flatten(), av.flatten())])
self.assertEqual(ar.all(), True)
self.assertIsInstance(av2, AnalogSignalArray)
self.assertEqual(av2.t_stop, t_stop)
self.assertEqual(av2.t_start, t_start)
def test_time_slice_offset(self):
#import numpy
av = AnalogSignalArray(numpy.array([[0, 1, 2, 3, 4, 5],
[0, 1, 2, 3, 4, 5]]).T,
t_start=10.0 * pq.s,
sampling_rate=1.0 * pq.Hz,
units='mV')
t_start = 12 * pq.s
t_stop = 14 * pq.s
av2 = av.time_slice(t_start, t_stop)
correct = AnalogSignalArray(numpy.array([[2, 3], [2, 3]]).T,
t_start=12.0 * pq.ms,
sampling_rate=1.0 * pq.Hz,
units='mV')
ar = numpy.array(
[a == b for (a, b) in zip(av2.flatten(), correct.flatten())])
self.assertEqual(ar.all(), True)
self.assertIsInstance(av2, AnalogSignalArray)
self.assertEqual(av2.t_stop, t_stop)
self.assertEqual(av2.t_start, t_start)
self.assertEqual(av2.sampling_rate, correct.sampling_rate)
def test_time_slice_different_units(self):
#import numpy
av = AnalogSignalArray(numpy.array([[0, 1, 2, 3, 4, 5],
[0, 1, 2, 3, 4, 5]]).T,
t_start=10.0 * pq.ms,
sampling_rate=1.0 * pq.Hz,
units='mV')
t_start = 2 * pq.s + 10.0 * pq.ms
t_stop = 4 * pq.s + 10.0 * pq.ms
av2 = av.time_slice(t_start, t_stop)
correct = AnalogSignalArray(numpy.array([[2, 3], [2, 3]]).T,
t_start=t_start,
sampling_rate=1.0 * pq.Hz,
units='mV')
self.assertIsInstance(av2, AnalogSignalArray)
self.assertAlmostEqual(av2.t_stop, t_stop, delta=1e-12 * ms)
self.assertAlmostEqual(av2.t_start, t_start, delta=1e-12 * ms)
assert_arrays_almost_equal(av2.times, correct.times, 1e-12 * ms)
self.assertEqual(av2.sampling_rate, correct.sampling_rate)
