def test__merge(self):
self.signal1.description = None
self.signal1.file_origin = None
assert_neo_object_is_compliant(self.signal1)
data3 = np.arange(1000.0, 1066.0).reshape((11, 6)) * pq.uV
data3scale = data3.rescale(self.data1quant.units)
signal2 = AnalogSignal(self.data1quant,
sampling_rate=1*pq.kHz,
name='signal2',
description='test signal',
file_origin='testfile.txt')
signal3 = AnalogSignal(data3,
units="uV", sampling_rate=1*pq.kHz,
name='signal3',
description='test signal',
file_origin='testfile.txt')
signal4 = AnalogSignal(data3,
units="uV", sampling_rate=1*pq.kHz,
name='signal4',
description='test signal',
file_origin='testfile.txt')
merged13 = self.signal1.merge(signal3)
merged23 = signal2.merge(signal3)
merged24 = signal2.merge(signal4)
mergeddata13 = np.array(merged13)
mergeddata23 = np.array(merged23)
mergeddata24 = np.array(merged24)
targdata13 = np.hstack([self.data1quant, data3scale])
targdata23 = np.hstack([self.data1quant, data3scale])
targdata24 = np.hstack([self.data1quant, data3scale])
assert_neo_object_is_compliant(signal2)
assert_neo_object_is_compliant(signal3)
assert_neo_object_is_compliant(merged13)
assert_neo_object_is_compliant(merged23)
assert_neo_object_is_compliant(merged24)
self.assertEqual(merged13[0, 4], 4*pq.mV)
self.assertEqual(merged23[0, 4], 4*pq.mV)
self.assertEqual(merged13[0, 5], 1*pq.mV)
self.assertEqual(merged23[0, 5], 1*pq.mV)
self.assertEqual(merged13[10, 10], 1.065*pq.mV)
self.assertEqual(merged23[10, 10], 1.065*pq.mV)
self.assertEqual(merged13.t_stop, self.signal1.t_stop)
self.assertEqual(merged23.t_stop, self.signal1.t_stop)
self.assertEqual(merged13.name, 'merge(spam, signal3)')
self.assertEqual(merged23.name, 'merge(signal2, signal3)')
self.assertEqual(merged13.description, 'merge(None, test signal)')
self.assertEqual(merged23.description, 'test signal')
self.assertEqual(merged13.file_origin, 'merge(None, testfile.txt)')
self.assertEqual(merged23.file_origin, 'testfile.txt')
assert_arrays_equal(mergeddata13, targdata13)
assert_arrays_equal(mergeddata23, targdata23)
assert_arrays_equal(mergeddata24, targdata24)
def test__merge(self):
self.signal1.description = None
self.signal1.file_origin = None
assert_neo_object_is_compliant(self.signal1)
data3 = np.arange(1000.0, 1066.0).reshape((11, 6)) * pq.uV
data3scale = data3.rescale(self.data1quant.units)
signal2 = AnalogSignal(self.data1quant,
sampling_rate=1*pq.kHz,
name='signal2',
description='test signal',
file_origin='testfile.txt')
signal3 = AnalogSignal(data3,
units="uV", sampling_rate=1*pq.kHz,
name='signal3',
description='test signal',
file_origin='testfile.txt')
signal4 = AnalogSignal(data3,
units="uV", sampling_rate=1*pq.kHz,
name='signal4',
description='test signal',
file_origin='testfile.txt')
merged13 = self.signal1.merge(signal3)
merged23 = signal2.merge(signal3)
merged24 = signal2.merge(signal4)
mergeddata13 = np.array(merged13)
mergeddata23 = np.array(merged23)
mergeddata24 = np.array(merged24)
targdata13 = np.hstack([self.data1quant, data3scale])
targdata23 = np.hstack([self.data1quant, data3scale])
targdata24 = np.hstack([self.data1quant, data3scale])
assert_neo_object_is_compliant(signal2)
assert_neo_object_is_compliant(signal3)
assert_neo_object_is_compliant(merged13)
assert_neo_object_is_compliant(merged23)
assert_neo_object_is_compliant(merged24)
self.assertEqual(merged13[0, 4], 4*pq.mV)
self.assertEqual(merged23[0, 4], 4*pq.mV)
self.assertEqual(merged13[0, 5], 1*pq.mV)
self.assertEqual(merged23[0, 5], 1*pq.mV)
self.assertEqual(merged13[10, 10], 1.065*pq.mV)
self.assertEqual(merged23[10, 10], 1.065*pq.mV)
self.assertEqual(merged13.t_stop, self.signal1.t_stop)
self.assertEqual(merged23.t_stop, self.signal1.t_stop)
self.assertEqual(merged13.name, 'merge(spam, signal3)')
self.assertEqual(merged23.name, 'merge(signal2, signal3)')
self.assertEqual(merged13.description, 'merge(None, test signal)')
self.assertEqual(merged23.description, 'test signal')
self.assertEqual(merged13.file_origin, 'merge(None, testfile.txt)')
self.assertEqual(merged23.file_origin, 'testfile.txt')
assert_arrays_equal(mergeddata13, targdata13)
assert_arrays_equal(mergeddata23, targdata23)
assert_arrays_equal(mergeddata24, targdata24)
class TestAnalogSignalArrayCombination(unittest.TestCase):
def setUp(self):
self.data1 = np.arange(55.0).reshape((11, 5))
self.data1quant = self.data1 * pq.mV
self.signal1 = AnalogSignal(self.data1quant,
sampling_rate=1 * pq.kHz,
name='spam',
description='eggs',
file_origin='testfile.txt',
arg1='test')
self.data2 = np.arange(100.0, 155.0).reshape((11, 5))
self.data2quant = self.data2 * pq.mV
self.signal2 = AnalogSignal(self.data2quant,
sampling_rate=1 * pq.kHz,
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__add_const_quantity_should_preserve_data_complement(self):
result = self.signal1 + 0.065 * pq.V
self.assertIsInstance(result, AnalogSignal)
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'})
# time zero, signal index 4
assert_arrays_equal(result, self.data1 + 65)
self.assertEqual(self.signal1[0, 4], 4 * pq.mV)
self.assertEqual(result[0, 4], 69000 * pq.uV)
self.assertEqual(self.signal1.t_start, result.t_start)
self.assertEqual(self.signal1.sampling_rate, result.sampling_rate)
def test__add_two_consistent_signals_should_preserve_data_complement(self):
result = self.signal1 + self.signal2
self.assertIsInstance(result, AnalogSignal)
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'})
targdata = np.arange(100.0, 210.0, 2.0).reshape((11, 5))
targ = AnalogSignal(targdata,
units="mV",
sampling_rate=1 * pq.kHz,
name='spam',
description='eggs',
file_origin='testfile.txt',
arg1='test')
assert_neo_object_is_compliant(targ)
assert_arrays_equal(result, targdata)
assert_same_sub_schema(result, targ)
def test__add_signals_with_inconsistent_data_complement_ValueError(self):
self.signal2.sampling_rate = 0.5 * pq.kHz
assert_neo_object_is_compliant(self.signal2)
self.assertRaises(ValueError, self.signal1.__add__, self.signal2)
def test__subtract_const_should_preserve_data_complement(self):
result = self.signal1 - 65 * pq.mV
self.assertIsInstance(result, AnalogSignal)
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(np.array(self.signal1[1, 4]), 9)
self.assertEqual(np.array(result[1, 4]), -56)
assert_arrays_equal(result, self.data1 - 65)
self.assertEqual(self.signal1.sampling_rate, result.sampling_rate)
def test__subtract_from_const_should_return_signal(self):
result = 10 * pq.mV - self.signal1
self.assertIsInstance(result, AnalogSignal)
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(np.array(self.signal1[1, 4]), 9)
self.assertEqual(np.array(result[1, 4]), 1)
assert_arrays_equal(result, 10 - self.data1)
self.assertEqual(self.signal1.sampling_rate, result.sampling_rate)
def test__mult_by_const_float_should_preserve_data_complement(self):
result = self.signal1 * 2
self.assertIsInstance(result, AnalogSignal)
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(np.array(self.signal1[1, 4]), 9)
self.assertEqual(np.array(result[1, 4]), 18)
assert_arrays_equal(result, self.data1 * 2)
self.assertEqual(self.signal1.sampling_rate, result.sampling_rate)
def test__divide_by_const_should_preserve_data_complement(self):
result = self.signal1 / 0.5
self.assertIsInstance(result, AnalogSignal)
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(np.array(self.signal1[1, 4]), 9)
self.assertEqual(np.array(result[1, 4]), 18)
assert_arrays_equal(result, self.data1 / 0.5)
self.assertEqual(self.signal1.sampling_rate, result.sampling_rate)
def test__merge(self):
self.signal1.description = None
self.signal1.file_origin = None
assert_neo_object_is_compliant(self.signal1)
data3 = np.arange(1000.0, 1066.0).reshape((11, 6)) * pq.uV
data3scale = data3.rescale(self.data1quant.units)
signal2 = AnalogSignal(self.data1quant,
sampling_rate=1 * pq.kHz,
name='signal2',
description='test signal',
file_origin='testfile.txt')
signal3 = AnalogSignal(data3,
units="uV",
sampling_rate=1 * pq.kHz,
name='signal3',
description='test signal',
file_origin='testfile.txt')
signal4 = AnalogSignal(data3,
units="uV",
sampling_rate=1 * pq.kHz,
name='signal4',
description='test signal',
file_origin='testfile.txt')
merged13 = self.signal1.merge(signal3)
merged23 = signal2.merge(signal3)
merged24 = signal2.merge(signal4)
mergeddata13 = np.array(merged13)
mergeddata23 = np.array(merged23)
mergeddata24 = np.array(merged24)
targdata13 = np.hstack([self.data1quant, data3scale])
targdata23 = np.hstack([self.data1quant, data3scale])
targdata24 = np.hstack([self.data1quant, data3scale])
assert_neo_object_is_compliant(signal2)
assert_neo_object_is_compliant(signal3)
assert_neo_object_is_compliant(merged13)
assert_neo_object_is_compliant(merged23)
assert_neo_object_is_compliant(merged24)
self.assertEqual(merged13[0, 4], 4 * pq.mV)
self.assertEqual(merged23[0, 4], 4 * pq.mV)
self.assertEqual(merged13[0, 5], 1 * pq.mV)
self.assertEqual(merged23[0, 5], 1 * pq.mV)
self.assertEqual(merged13[10, 10], 1.065 * pq.mV)
self.assertEqual(merged23[10, 10], 1.065 * pq.mV)
self.assertEqual(merged13.t_stop, self.signal1.t_stop)
self.assertEqual(merged23.t_stop, self.signal1.t_stop)
self.assertEqual(merged13.name, 'merge(spam, signal3)')
self.assertEqual(merged23.name, 'merge(signal2, signal3)')
self.assertEqual(merged13.description, 'merge(None, test signal)')
self.assertEqual(merged23.description, 'test signal')
self.assertEqual(merged13.file_origin, 'merge(None, testfile.txt)')
self.assertEqual(merged23.file_origin, 'testfile.txt')
assert_arrays_equal(mergeddata13, targdata13)
assert_arrays_equal(mergeddata23, targdata23)
assert_arrays_equal(mergeddata24, targdata24)
def test__merge(self):
self.signal1.description = None
self.signal1.file_origin = None
assert_neo_object_is_compliant(self.signal1)
data3 = np.arange(1000.0, 1066.0).reshape((11, 6)) * pq.uV
data3scale = data3.rescale(self.data1quant.units)
arr_ann3 = {'anno1': np.arange(5, 11), 'anno3': ['h', 'i', 'j', 'k', 'l', 'm']}
arr_ann4 = {'anno1': np.arange(100, 106), 'anno3': ['o', 'p', 'q', 'r', 's', 't']}
signal2 = AnalogSignal(self.data1quant, sampling_rate=1 * pq.kHz, name='signal2',
description='test signal', file_origin='testfile.txt',
array_annotations=self.arr_ann1)
signal3 = AnalogSignal(data3, units="uV", sampling_rate=1 * pq.kHz, name='signal3',
description='test signal', file_origin='testfile.txt',
array_annotations=arr_ann3)
signal4 = AnalogSignal(data3, units="uV", sampling_rate=1 * pq.kHz, name='signal4',
description='test signal', file_origin='testfile.txt',
array_annotations=arr_ann4)
with warnings.catch_warnings(record=True) as w:
warnings.filterwarnings('always')
merged13 = self.signal1.merge(signal3)
merged23 = signal2.merge(signal3)
merged24 = signal2.merge(signal4)
self.assertTrue(len(w) == 3)
self.assertEqual(w[-1].category, UserWarning)
self.assertSequenceEqual(str(w[2].message), str(w[0].message))
self.assertSequenceEqual(str(w[2].message), str(w[1].message))
self.assertSequenceEqual(str(w[2].message), "The following array annotations were "
"omitted, because they were only present"
" in one of the merged objects: "
"['anno2'] from the one that was merged "
"into and ['anno3'] from the one that "
"was merged into the other")
mergeddata13 = np.array(merged13)
mergeddata23 = np.array(merged23)
mergeddata24 = np.array(merged24)
targdata13 = np.hstack([self.data1quant, data3scale])
targdata23 = np.hstack([self.data1quant, data3scale])
targdata24 = np.hstack([self.data1quant, data3scale])
assert_neo_object_is_compliant(signal2)
assert_neo_object_is_compliant(signal3)
assert_neo_object_is_compliant(merged13)
assert_neo_object_is_compliant(merged23)
assert_neo_object_is_compliant(merged24)
self.assertEqual(merged13[0, 4], 4 * pq.mV)
self.assertEqual(merged23[0, 4], 4 * pq.mV)
self.assertEqual(merged13[0, 5], 1 * pq.mV)
self.assertEqual(merged23[0, 5], 1 * pq.mV)
self.assertEqual(merged13[10, 10], 1.065 * pq.mV)
self.assertEqual(merged23[10, 10], 1.065 * pq.mV)
self.assertEqual(merged13.t_stop, self.signal1.t_stop)
self.assertEqual(merged23.t_stop, self.signal1.t_stop)
self.assertEqual(merged13.name, 'merge(spam, signal3)')
self.assertEqual(merged23.name, 'merge(signal2, signal3)')
self.assertEqual(merged13.description, 'merge(None, test signal)')
self.assertEqual(merged23.description, 'test signal')
self.assertEqual(merged13.file_origin, 'merge(None, testfile.txt)')
self.assertEqual(merged23.file_origin, 'testfile.txt')
assert_arrays_equal(merged13.array_annotations['anno1'], np.arange(11))
self.assertIsInstance(merged13.array_annotations, ArrayDict)
self.assertNotIn('anno2', merged13.array_annotations)
self.assertNotIn('anno3', merged13.array_annotations)
assert_arrays_equal(merged23.array_annotations['anno1'], np.arange(11))
self.assertIsInstance(merged23.array_annotations, ArrayDict)
self.assertNotIn('anno2', merged23.array_annotations)
self.assertNotIn('anno3', merged23.array_annotations)
assert_arrays_equal(merged24.array_annotations['anno1'],
np.array([0, 1, 2, 3, 4, 100, 101, 102, 103, 104, 105]))
self.assertIsInstance(merged24.array_annotations, ArrayDict)
self.assertNotIn('anno2', merged24.array_annotations)
self.assertNotIn('anno3', merged24.array_annotations)
assert_arrays_equal(mergeddata13, targdata13)
assert_arrays_equal(mergeddata23, targdata23)
assert_arrays_equal(mergeddata24, targdata24)
class TestAnalogSignalArrayCombination(unittest.TestCase):
def setUp(self):
self.data1 = np.arange(55.0).reshape((11, 5))
self.data1quant = self.data1 * pq.mV
self.arr_ann1 = {'anno1': np.arange(5), 'anno2': ['a', 'b', 'c', 'd', 'e']}
self.signal1 = AnalogSignal(self.data1quant, sampling_rate=1 * pq.kHz, name='spam',
description='eggs', file_origin='testfile.txt',
array_annotations=self.arr_ann1, arg1='test')
self.data2 = np.arange(100.0, 155.0).reshape((11, 5))
self.data2quant = self.data2 * pq.mV
self.arr_ann2 = {'anno1': np.arange(10, 15), 'anno2': ['k', 'l', 'm', 'n', 'o']}
self.signal2 = AnalogSignal(self.data2quant, sampling_rate=1 * pq.kHz, name='spam',
description='eggs', file_origin='testfile.txt',
array_annotations=self.arr_ann2, 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_arrays_equal(self.signal1.array_annotations['anno1'], np.arange(5))
assert_arrays_equal(self.signal1.array_annotations['anno2'],
np.array(['a', 'b', 'c', 'd', 'e']))
self.assertIsInstance(self.signal1.array_annotations, ArrayDict)
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'})
assert_arrays_equal(self.signal2.array_annotations['anno1'], np.arange(10, 15))
assert_arrays_equal(self.signal2.array_annotations['anno2'],
np.array(['k', 'l', 'm', 'n', 'o']))
self.assertIsInstance(self.signal2.array_annotations, ArrayDict)
def test__add_const_quantity_should_preserve_data_complement(self):
result = self.signal1 + 0.065 * pq.V
self.assertIsInstance(result, AnalogSignal)
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.arange(5))
assert_arrays_equal(result.array_annotations['anno2'], np.array(['a', 'b', 'c', 'd', 'e']))
self.assertIsInstance(result.array_annotations, ArrayDict)
# time zero, signal index 4
assert_arrays_equal(result, self.data1 + 65)
self.assertEqual(self.signal1[0, 4], 4 * pq.mV)
self.assertEqual(result[0, 4], 69000 * pq.uV)
self.assertEqual(self.signal1.t_start, result.t_start)
self.assertEqual(self.signal1.sampling_rate, result.sampling_rate)
def test__add_two_consistent_signals_should_preserve_data_complement(self):
result = self.signal1 + self.signal2
self.assertIsInstance(result, AnalogSignal)
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.arange(5))
assert_arrays_equal(result.array_annotations['anno2'], np.array(['a', 'b', 'c', 'd', 'e']))
self.assertIsInstance(result.array_annotations, ArrayDict)
targdata = np.arange(100.0, 210.0, 2.0).reshape((11, 5))
targ = AnalogSignal(targdata, units="mV", sampling_rate=1 * pq.kHz, name='spam',
description='eggs', file_origin='testfile.txt', arg1='test')
assert_neo_object_is_compliant(targ)
assert_arrays_equal(result, targdata)
assert_same_sub_schema(result, targ)
def test__add_signals_with_inconsistent_data_complement_ValueError(self):
self.signal2.sampling_rate = 0.5 * pq.kHz
assert_neo_object_is_compliant(self.signal2)
self.assertRaises(ValueError, self.signal1.__add__, self.signal2)
def test__subtract_const_should_preserve_data_complement(self):
result = self.signal1 - 65 * pq.mV
self.assertIsInstance(result, AnalogSignal)
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.arange(5))
assert_arrays_equal(result.array_annotations['anno2'], np.array(['a', 'b', 'c', 'd', 'e']))
self.assertIsInstance(result.array_annotations, ArrayDict)
self.assertEqual(np.array(self.signal1[1, 4]), 9)
self.assertEqual(np.array(result[1, 4]), -56)
assert_arrays_equal(result, self.data1 - 65)
self.assertEqual(self.signal1.sampling_rate, result.sampling_rate)
def test__subtract_from_const_should_return_signal(self):
result = 10 * pq.mV - self.signal1
self.assertIsInstance(result, AnalogSignal)
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.arange(5))
assert_arrays_equal(result.array_annotations['anno2'], np.array(['a', 'b', 'c', 'd', 'e']))
self.assertIsInstance(result.array_annotations, ArrayDict)
self.assertEqual(np.array(self.signal1[1, 4]), 9)
self.assertEqual(np.array(result[1, 4]), 1)
assert_arrays_equal(result, 10 - self.data1)
self.assertEqual(self.signal1.sampling_rate, result.sampling_rate)
def test__mult_by_const_float_should_preserve_data_complement(self):
result = self.signal1 * 2
self.assertIsInstance(result, AnalogSignal)
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.arange(5))
assert_arrays_equal(result.array_annotations['anno2'], np.array(['a', 'b', 'c', 'd', 'e']))
self.assertIsInstance(result.array_annotations, ArrayDict)
self.assertEqual(np.array(self.signal1[1, 4]), 9)
self.assertEqual(np.array(result[1, 4]), 18)
assert_arrays_equal(result, self.data1 * 2)
self.assertEqual(self.signal1.sampling_rate, result.sampling_rate)
def test__divide_by_const_should_preserve_data_complement(self):
result = self.signal1 / 0.5
self.assertIsInstance(result, AnalogSignal)
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.arange(5))
assert_arrays_equal(result.array_annotations['anno2'], np.array(['a', 'b', 'c', 'd', 'e']))
self.assertIsInstance(result.array_annotations, ArrayDict)
self.assertEqual(np.array(self.signal1[1, 4]), 9)
self.assertEqual(np.array(result[1, 4]), 18)
assert_arrays_equal(result, self.data1 / 0.5)
self.assertEqual(self.signal1.sampling_rate, result.sampling_rate)
def test__merge(self):
self.signal1.description = None
self.signal1.file_origin = None
assert_neo_object_is_compliant(self.signal1)
data3 = np.arange(1000.0, 1066.0).reshape((11, 6)) * pq.uV
data3scale = data3.rescale(self.data1quant.units)
arr_ann3 = {'anno1': np.arange(5, 11), 'anno3': ['h', 'i', 'j', 'k', 'l', 'm']}
arr_ann4 = {'anno1': np.arange(100, 106), 'anno3': ['o', 'p', 'q', 'r', 's', 't']}
signal2 = AnalogSignal(self.data1quant, sampling_rate=1 * pq.kHz, name='signal2',
description='test signal', file_origin='testfile.txt',
array_annotations=self.arr_ann1)
signal3 = AnalogSignal(data3, units="uV", sampling_rate=1 * pq.kHz, name='signal3',
description='test signal', file_origin='testfile.txt',
array_annotations=arr_ann3)
signal4 = AnalogSignal(data3, units="uV", sampling_rate=1 * pq.kHz, name='signal4',
description='test signal', file_origin='testfile.txt',
array_annotations=arr_ann4)
with warnings.catch_warnings(record=True) as w:
warnings.filterwarnings('always')
merged13 = self.signal1.merge(signal3)
merged23 = signal2.merge(signal3)
merged24 = signal2.merge(signal4)
self.assertTrue(len(w) == 3)
self.assertEqual(w[-1].category, UserWarning)
self.assertSequenceEqual(str(w[2].message), str(w[0].message))
self.assertSequenceEqual(str(w[2].message), str(w[1].message))
self.assertSequenceEqual(str(w[2].message), "The following array annotations were "
"omitted, because they were only present"
" in one of the merged objects: "
"['anno2'] from the one that was merged "
"into and ['anno3'] from the one that "
"was merged into the other")
mergeddata13 = np.array(merged13)
mergeddata23 = np.array(merged23)
mergeddata24 = np.array(merged24)
targdata13 = np.hstack([self.data1quant, data3scale])
targdata23 = np.hstack([self.data1quant, data3scale])
targdata24 = np.hstack([self.data1quant, data3scale])
assert_neo_object_is_compliant(signal2)
assert_neo_object_is_compliant(signal3)
assert_neo_object_is_compliant(merged13)
assert_neo_object_is_compliant(merged23)
assert_neo_object_is_compliant(merged24)
self.assertEqual(merged13[0, 4], 4 * pq.mV)
self.assertEqual(merged23[0, 4], 4 * pq.mV)
self.assertEqual(merged13[0, 5], 1 * pq.mV)
self.assertEqual(merged23[0, 5], 1 * pq.mV)
self.assertEqual(merged13[10, 10], 1.065 * pq.mV)
self.assertEqual(merged23[10, 10], 1.065 * pq.mV)
self.assertEqual(merged13.t_stop, self.signal1.t_stop)
self.assertEqual(merged23.t_stop, self.signal1.t_stop)
self.assertEqual(merged13.name, 'merge(spam, signal3)')
self.assertEqual(merged23.name, 'merge(signal2, signal3)')
self.assertEqual(merged13.description, 'merge(None, test signal)')
self.assertEqual(merged23.description, 'test signal')
self.assertEqual(merged13.file_origin, 'merge(None, testfile.txt)')
self.assertEqual(merged23.file_origin, 'testfile.txt')
assert_arrays_equal(merged13.array_annotations['anno1'], np.arange(11))
self.assertIsInstance(merged13.array_annotations, ArrayDict)
self.assertNotIn('anno2', merged13.array_annotations)
self.assertNotIn('anno3', merged13.array_annotations)
assert_arrays_equal(merged23.array_annotations['anno1'], np.arange(11))
self.assertIsInstance(merged23.array_annotations, ArrayDict)
self.assertNotIn('anno2', merged23.array_annotations)
self.assertNotIn('anno3', merged23.array_annotations)
assert_arrays_equal(merged24.array_annotations['anno1'],
np.array([0, 1, 2, 3, 4, 100, 101, 102, 103, 104, 105]))
self.assertIsInstance(merged24.array_annotations, ArrayDict)
self.assertNotIn('anno2', merged24.array_annotations)
self.assertNotIn('anno3', merged24.array_annotations)
assert_arrays_equal(mergeddata13, targdata13)
assert_arrays_equal(mergeddata23, targdata23)
assert_arrays_equal(mergeddata24, targdata24)
class TestAnalogSignalArrayCombination(unittest.TestCase):
def setUp(self):
self.data1 = np.arange(55.0).reshape((11, 5))
self.data1quant = self.data1 * pq.mV
self.signal1 = AnalogSignal(self.data1quant,
sampling_rate=1*pq.kHz,
name='spam', description='eggs',
file_origin='testfile.txt',
arg1='test')
self.data2 = np.arange(100.0, 155.0).reshape((11, 5))
self.data2quant = self.data2 * pq.mV
self.signal2 = AnalogSignal(self.data2quant,
sampling_rate=1*pq.kHz,
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__add_const_quantity_should_preserve_data_complement(self):
result = self.signal1 + 0.065*pq.V
self.assertIsInstance(result, AnalogSignal)
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'})
# time zero, signal index 4
assert_arrays_equal(result, self.data1 + 65)
self.assertEqual(self.signal1[0, 4], 4*pq.mV)
self.assertEqual(result[0, 4], 69000*pq.uV)
self.assertEqual(self.signal1.t_start, result.t_start)
self.assertEqual(self.signal1.sampling_rate, result.sampling_rate)
def test__add_two_consistent_signals_should_preserve_data_complement(self):
result = self.signal1 + self.signal2
self.assertIsInstance(result, AnalogSignal)
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'})
targdata = np.arange(100.0, 210.0, 2.0).reshape((11, 5))
targ = AnalogSignal(targdata, units="mV",
sampling_rate=1*pq.kHz,
name='spam', description='eggs',
file_origin='testfile.txt', arg1='test')
assert_neo_object_is_compliant(targ)
assert_arrays_equal(result, targdata)
assert_same_sub_schema(result, targ)
def test__add_signals_with_inconsistent_data_complement_ValueError(self):
self.signal2.sampling_rate = 0.5*pq.kHz
assert_neo_object_is_compliant(self.signal2)
self.assertRaises(ValueError, self.signal1.__add__, self.signal2)
def test__subtract_const_should_preserve_data_complement(self):
result = self.signal1 - 65*pq.mV
self.assertIsInstance(result, AnalogSignal)
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(np.array(self.signal1[1, 4]), 9)
self.assertEqual(np.array(result[1, 4]), -56)
assert_arrays_equal(result, self.data1 - 65)
self.assertEqual(self.signal1.sampling_rate, result.sampling_rate)
def test__subtract_from_const_should_return_signal(self):
result = 10*pq.mV - self.signal1
self.assertIsInstance(result, AnalogSignal)
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(np.array(self.signal1[1, 4]), 9)
self.assertEqual(np.array(result[1, 4]), 1)
assert_arrays_equal(result, 10 - self.data1)
self.assertEqual(self.signal1.sampling_rate, result.sampling_rate)
def test__mult_by_const_float_should_preserve_data_complement(self):
result = self.signal1*2
self.assertIsInstance(result, AnalogSignal)
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(np.array(self.signal1[1, 4]), 9)
self.assertEqual(np.array(result[1, 4]), 18)
assert_arrays_equal(result, self.data1*2)
self.assertEqual(self.signal1.sampling_rate, result.sampling_rate)
def test__divide_by_const_should_preserve_data_complement(self):
result = self.signal1/0.5
self.assertIsInstance(result, AnalogSignal)
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(np.array(self.signal1[1, 4]), 9)
self.assertEqual(np.array(result[1, 4]), 18)
assert_arrays_equal(result, self.data1/0.5)
self.assertEqual(self.signal1.sampling_rate, result.sampling_rate)
def test__merge(self):
self.signal1.description = None
self.signal1.file_origin = None
assert_neo_object_is_compliant(self.signal1)
data3 = np.arange(1000.0, 1066.0).reshape((11, 6)) * pq.uV
data3scale = data3.rescale(self.data1quant.units)
signal2 = AnalogSignal(self.data1quant,
sampling_rate=1*pq.kHz,
name='signal2',
description='test signal',
file_origin='testfile.txt')
signal3 = AnalogSignal(data3,
units="uV", sampling_rate=1*pq.kHz,
name='signal3',
description='test signal',
file_origin='testfile.txt')
signal4 = AnalogSignal(data3,
units="uV", sampling_rate=1*pq.kHz,
name='signal4',
description='test signal',
file_origin='testfile.txt')
merged13 = self.signal1.merge(signal3)
merged23 = signal2.merge(signal3)
merged24 = signal2.merge(signal4)
mergeddata13 = np.array(merged13)
mergeddata23 = np.array(merged23)
mergeddata24 = np.array(merged24)
targdata13 = np.hstack([self.data1quant, data3scale])
targdata23 = np.hstack([self.data1quant, data3scale])
targdata24 = np.hstack([self.data1quant, data3scale])
assert_neo_object_is_compliant(signal2)
assert_neo_object_is_compliant(signal3)
assert_neo_object_is_compliant(merged13)
assert_neo_object_is_compliant(merged23)
assert_neo_object_is_compliant(merged24)
self.assertEqual(merged13[0, 4], 4*pq.mV)
self.assertEqual(merged23[0, 4], 4*pq.mV)
self.assertEqual(merged13[0, 5], 1*pq.mV)
self.assertEqual(merged23[0, 5], 1*pq.mV)
self.assertEqual(merged13[10, 10], 1.065*pq.mV)
self.assertEqual(merged23[10, 10], 1.065*pq.mV)
self.assertEqual(merged13.t_stop, self.signal1.t_stop)
self.assertEqual(merged23.t_stop, self.signal1.t_stop)
self.assertEqual(merged13.name, 'merge(spam, signal3)')
self.assertEqual(merged23.name, 'merge(signal2, signal3)')
self.assertEqual(merged13.description, 'merge(None, test signal)')
self.assertEqual(merged23.description, 'test signal')
self.assertEqual(merged13.file_origin, 'merge(None, testfile.txt)')
self.assertEqual(merged23.file_origin, 'testfile.txt')
assert_arrays_equal(mergeddata13, targdata13)
assert_arrays_equal(mergeddata23, targdata23)
assert_arrays_equal(mergeddata24, targdata24)
def test__merge(self):
self.signal1.description = None
self.signal1.file_origin = None
assert_neo_object_is_compliant(self.signal1)
data3 = np.arange(1000.0, 1066.0).reshape((11, 6)) * pq.uV
data3scale = data3.rescale(self.data1quant.units)
arr_ann3 = {
'anno1': np.arange(5, 11),
'anno3': ['h', 'i', 'j', 'k', 'l', 'm']
}
arr_ann4 = {
'anno1': np.arange(100, 106),
'anno3': ['o', 'p', 'q', 'r', 's', 't']
}
signal2 = AnalogSignal(self.data1quant,
sampling_rate=1 * pq.kHz,
name='signal2',
description='test signal',
file_origin='testfile.txt',
array_annotations=self.arr_ann1)
signal3 = AnalogSignal(data3,
units="uV",
sampling_rate=1 * pq.kHz,
name='signal3',
description='test signal',
file_origin='testfile.txt',
array_annotations=arr_ann3)
signal4 = AnalogSignal(data3,
units="uV",
sampling_rate=1 * pq.kHz,
name='signal4',
description='test signal',
file_origin='testfile.txt',
array_annotations=arr_ann4)
with warnings.catch_warnings(record=True) as w:
warnings.filterwarnings('always')
merged13 = self.signal1.merge(signal3)
merged23 = signal2.merge(signal3)
merged24 = signal2.merge(signal4)
self.assertTrue(len(w) == 3)
self.assertEqual(w[-1].category, UserWarning)
self.assertSequenceEqual(str(w[2].message), str(w[0].message))
self.assertSequenceEqual(str(w[2].message), str(w[1].message))
self.assertSequenceEqual(
str(w[2].message), "The following array annotations were "
"omitted, because they were only present"
" in one of the merged objects: "
"['anno2'] from the one that was merged "
"into and ['anno3'] from the one that "
"was merged into the other")
mergeddata13 = np.array(merged13)
mergeddata23 = np.array(merged23)
mergeddata24 = np.array(merged24)
targdata13 = np.hstack([self.data1quant, data3scale])
targdata23 = np.hstack([self.data1quant, data3scale])
targdata24 = np.hstack([self.data1quant, data3scale])
assert_neo_object_is_compliant(signal2)
assert_neo_object_is_compliant(signal3)
assert_neo_object_is_compliant(merged13)
assert_neo_object_is_compliant(merged23)
assert_neo_object_is_compliant(merged24)
self.assertEqual(merged13[0, 4], 4 * pq.mV)
self.assertEqual(merged23[0, 4], 4 * pq.mV)
self.assertEqual(merged13[0, 5], 1 * pq.mV)
self.assertEqual(merged23[0, 5], 1 * pq.mV)
self.assertEqual(merged13[10, 10], 1.065 * pq.mV)
self.assertEqual(merged23[10, 10], 1.065 * pq.mV)
self.assertEqual(merged13.t_stop, self.signal1.t_stop)
self.assertEqual(merged23.t_stop, self.signal1.t_stop)
self.assertEqual(merged13.name, 'merge(spam, signal3)')
self.assertEqual(merged23.name, 'merge(signal2, signal3)')
self.assertEqual(merged13.description, 'merge(None, test signal)')
self.assertEqual(merged23.description, 'test signal')
self.assertEqual(merged13.file_origin, 'merge(None, testfile.txt)')
self.assertEqual(merged23.file_origin, 'testfile.txt')
assert_arrays_equal(merged13.array_annotations['anno1'], np.arange(11))
self.assertIsInstance(merged13.array_annotations, ArrayDict)
self.assertNotIn('anno2', merged13.array_annotations)
self.assertNotIn('anno3', merged13.array_annotations)
assert_arrays_equal(merged23.array_annotations['anno1'], np.arange(11))
self.assertIsInstance(merged23.array_annotations, ArrayDict)
self.assertNotIn('anno2', merged23.array_annotations)
self.assertNotIn('anno3', merged23.array_annotations)
assert_arrays_equal(
merged24.array_annotations['anno1'],
np.array([0, 1, 2, 3, 4, 100, 101, 102, 103, 104, 105]))
self.assertIsInstance(merged24.array_annotations, ArrayDict)
self.assertNotIn('anno2', merged24.array_annotations)
self.assertNotIn('anno3', merged24.array_annotations)
assert_arrays_equal(mergeddata13, targdata13)
assert_arrays_equal(mergeddata23, targdata23)
assert_arrays_equal(mergeddata24, targdata24)
class TestAnalogSignalArrayCombination(unittest.TestCase):
def setUp(self):
self.data1 = np.arange(55.0).reshape((11, 5))
self.data1quant = self.data1 * pq.mV
self.arr_ann1 = {
'anno1': np.arange(5),
'anno2': ['a', 'b', 'c', 'd', 'e']
}
self.signal1 = AnalogSignal(self.data1quant,
sampling_rate=1 * pq.kHz,
name='spam',
description='eggs',
file_origin='testfile.txt',
array_annotations=self.arr_ann1,
arg1='test')
self.data2 = np.arange(100.0, 155.0).reshape((11, 5))
self.data2quant = self.data2 * pq.mV
self.arr_ann2 = {
'anno1': np.arange(10, 15),
'anno2': ['k', 'l', 'm', 'n', 'o']
}
self.signal2 = AnalogSignal(self.data2quant,
sampling_rate=1 * pq.kHz,
name='spam',
description='eggs',
file_origin='testfile.txt',
array_annotations=self.arr_ann2,
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_arrays_equal(self.signal1.array_annotations['anno1'],
np.arange(5))
assert_arrays_equal(self.signal1.array_annotations['anno2'],
np.array(['a', 'b', 'c', 'd', 'e']))
self.assertIsInstance(self.signal1.array_annotations, ArrayDict)
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'})
assert_arrays_equal(self.signal2.array_annotations['anno1'],
np.arange(10, 15))
assert_arrays_equal(self.signal2.array_annotations['anno2'],
np.array(['k', 'l', 'm', 'n', 'o']))
self.assertIsInstance(self.signal2.array_annotations, ArrayDict)
def test__add_const_quantity_should_preserve_data_complement(self):
result = self.signal1 + 0.065 * pq.V
self.assertIsInstance(result, AnalogSignal)
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.arange(5))
assert_arrays_equal(result.array_annotations['anno2'],
np.array(['a', 'b', 'c', 'd', 'e']))
self.assertIsInstance(result.array_annotations, ArrayDict)
# time zero, signal index 4
assert_arrays_equal(result, self.data1 + 65)
self.assertEqual(self.signal1[0, 4], 4 * pq.mV)
self.assertEqual(result[0, 4], 69000 * pq.uV)
self.assertEqual(self.signal1.t_start, result.t_start)
self.assertEqual(self.signal1.sampling_rate, result.sampling_rate)
def test__add_two_consistent_signals_should_preserve_data_complement(self):
result = self.signal1 + self.signal2
self.assertIsInstance(result, AnalogSignal)
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.arange(5))
assert_arrays_equal(result.array_annotations['anno2'],
np.array(['a', 'b', 'c', 'd', 'e']))
self.assertIsInstance(result.array_annotations, ArrayDict)
targdata = np.arange(100.0, 210.0, 2.0).reshape((11, 5))
targ = AnalogSignal(targdata,
units="mV",
sampling_rate=1 * pq.kHz,
name='spam',
description='eggs',
file_origin='testfile.txt',
arg1='test')
assert_neo_object_is_compliant(targ)
assert_arrays_equal(result, targdata)
assert_same_sub_schema(result, targ)
def test__add_signals_with_inconsistent_data_complement_ValueError(self):
self.signal2.sampling_rate = 0.5 * pq.kHz
assert_neo_object_is_compliant(self.signal2)
self.assertRaises(ValueError, self.signal1.__add__, self.signal2)
def test__subtract_const_should_preserve_data_complement(self):
result = self.signal1 - 65 * pq.mV
self.assertIsInstance(result, AnalogSignal)
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.arange(5))
assert_arrays_equal(result.array_annotations['anno2'],
np.array(['a', 'b', 'c', 'd', 'e']))
self.assertIsInstance(result.array_annotations, ArrayDict)
self.assertEqual(np.array(self.signal1[1, 4]), 9)
self.assertEqual(np.array(result[1, 4]), -56)
assert_arrays_equal(result, self.data1 - 65)
self.assertEqual(self.signal1.sampling_rate, result.sampling_rate)
def test__subtract_from_const_should_return_signal(self):
result = 10 * pq.mV - self.signal1
self.assertIsInstance(result, AnalogSignal)
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.arange(5))
assert_arrays_equal(result.array_annotations['anno2'],
np.array(['a', 'b', 'c', 'd', 'e']))
self.assertIsInstance(result.array_annotations, ArrayDict)
self.assertEqual(np.array(self.signal1[1, 4]), 9)
self.assertEqual(np.array(result[1, 4]), 1)
assert_arrays_equal(result, 10 - self.data1)
self.assertEqual(self.signal1.sampling_rate, result.sampling_rate)
def test__mult_by_const_float_should_preserve_data_complement(self):
result = self.signal1 * 2
self.assertIsInstance(result, AnalogSignal)
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.arange(5))
assert_arrays_equal(result.array_annotations['anno2'],
np.array(['a', 'b', 'c', 'd', 'e']))
self.assertIsInstance(result.array_annotations, ArrayDict)
self.assertEqual(np.array(self.signal1[1, 4]), 9)
self.assertEqual(np.array(result[1, 4]), 18)
assert_arrays_equal(result, self.data1 * 2)
self.assertEqual(self.signal1.sampling_rate, result.sampling_rate)
def test__divide_by_const_should_preserve_data_complement(self):
result = self.signal1 / 0.5
self.assertIsInstance(result, AnalogSignal)
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.arange(5))
assert_arrays_equal(result.array_annotations['anno2'],
np.array(['a', 'b', 'c', 'd', 'e']))
self.assertIsInstance(result.array_annotations, ArrayDict)
self.assertEqual(np.array(self.signal1[1, 4]), 9)
self.assertEqual(np.array(result[1, 4]), 18)
assert_arrays_equal(result, self.data1 / 0.5)
self.assertEqual(self.signal1.sampling_rate, result.sampling_rate)
def test__merge(self):
self.signal1.description = None
self.signal1.file_origin = None
assert_neo_object_is_compliant(self.signal1)
data3 = np.arange(1000.0, 1066.0).reshape((11, 6)) * pq.uV
data3scale = data3.rescale(self.data1quant.units)
arr_ann3 = {
'anno1': np.arange(5, 11),
'anno3': ['h', 'i', 'j', 'k', 'l', 'm']
}
arr_ann4 = {
'anno1': np.arange(100, 106),
'anno3': ['o', 'p', 'q', 'r', 's', 't']
}
signal2 = AnalogSignal(self.data1quant,
sampling_rate=1 * pq.kHz,
name='signal2',
description='test signal',
file_origin='testfile.txt',
array_annotations=self.arr_ann1)
signal3 = AnalogSignal(data3,
units="uV",
sampling_rate=1 * pq.kHz,
name='signal3',
description='test signal',
file_origin='testfile.txt',
array_annotations=arr_ann3)
signal4 = AnalogSignal(data3,
units="uV",
sampling_rate=1 * pq.kHz,
name='signal4',
description='test signal',
file_origin='testfile.txt',
array_annotations=arr_ann4)
with warnings.catch_warnings(record=True) as w:
warnings.filterwarnings('always')
merged13 = self.signal1.merge(signal3)
merged23 = signal2.merge(signal3)
merged24 = signal2.merge(signal4)
self.assertTrue(len(w) == 3)
self.assertEqual(w[-1].category, UserWarning)
self.assertSequenceEqual(str(w[2].message), str(w[0].message))
self.assertSequenceEqual(str(w[2].message), str(w[1].message))
self.assertSequenceEqual(
str(w[2].message), "The following array annotations were "
"omitted, because they were only present"
" in one of the merged objects: "
"['anno2'] from the one that was merged "
"into and ['anno3'] from the one that "
"was merged into the other")
mergeddata13 = np.array(merged13)
mergeddata23 = np.array(merged23)
mergeddata24 = np.array(merged24)
targdata13 = np.hstack([self.data1quant, data3scale])
targdata23 = np.hstack([self.data1quant, data3scale])
targdata24 = np.hstack([self.data1quant, data3scale])
assert_neo_object_is_compliant(signal2)
assert_neo_object_is_compliant(signal3)
assert_neo_object_is_compliant(merged13)
assert_neo_object_is_compliant(merged23)
assert_neo_object_is_compliant(merged24)
self.assertEqual(merged13[0, 4], 4 * pq.mV)
self.assertEqual(merged23[0, 4], 4 * pq.mV)
self.assertEqual(merged13[0, 5], 1 * pq.mV)
self.assertEqual(merged23[0, 5], 1 * pq.mV)
self.assertEqual(merged13[10, 10], 1.065 * pq.mV)
self.assertEqual(merged23[10, 10], 1.065 * pq.mV)
self.assertEqual(merged13.t_stop, self.signal1.t_stop)
self.assertEqual(merged23.t_stop, self.signal1.t_stop)
self.assertEqual(merged13.name, 'merge(spam, signal3)')
self.assertEqual(merged23.name, 'merge(signal2, signal3)')
self.assertEqual(merged13.description, 'merge(None, test signal)')
self.assertEqual(merged23.description, 'test signal')
self.assertEqual(merged13.file_origin, 'merge(None, testfile.txt)')
self.assertEqual(merged23.file_origin, 'testfile.txt')
assert_arrays_equal(merged13.array_annotations['anno1'], np.arange(11))
self.assertIsInstance(merged13.array_annotations, ArrayDict)
self.assertNotIn('anno2', merged13.array_annotations)
self.assertNotIn('anno3', merged13.array_annotations)
assert_arrays_equal(merged23.array_annotations['anno1'], np.arange(11))
self.assertIsInstance(merged23.array_annotations, ArrayDict)
self.assertNotIn('anno2', merged23.array_annotations)
self.assertNotIn('anno3', merged23.array_annotations)
assert_arrays_equal(
merged24.array_annotations['anno1'],
np.array([0, 1, 2, 3, 4, 100, 101, 102, 103, 104, 105]))
self.assertIsInstance(merged24.array_annotations, ArrayDict)
self.assertNotIn('anno2', merged24.array_annotations)
self.assertNotIn('anno3', merged24.array_annotations)
assert_arrays_equal(mergeddata13, targdata13)
assert_arrays_equal(mergeddata23, targdata23)
assert_arrays_equal(mergeddata24, targdata24)
