def test_annotations(self):
spiketrain = neo.SpikeTrain([1, 2], t_stop=2 * pq.s, units=pq.s)
kernel = kernels.AlphaKernel(sigma=100 * pq.ms)
rate = statistics.instantaneous_rate(spiketrain,
sampling_period=10 * pq.ms,
kernel=kernel)
kernel_annotation = dict(type=type(kernel).__name__,
sigma=str(kernel.sigma),
invert=kernel.invert)
self.assertIn('kernel', rate.annotations)
self.assertEqual(rate.annotations['kernel'], kernel_annotation)
def test_regression_288(self):
np.random.seed(9)
sampling_period = 200 * pq.ms
spiketrain = homogeneous_poisson_process(10 * pq.Hz,
t_start=0 * pq.s,
t_stop=10 * pq.s)
kernel = kernels.AlphaKernel(sigma=5 * pq.ms, invert=True)
# check that instantaneous_rate "works" for kernels with small sigma
# without triggering an incomprehensible error
rate = statistics.instantaneous_rate(spiketrain,
sampling_period=sampling_period,
kernel=kernel)
self.assertEqual(len(rate), (spiketrain.t_stop /
sampling_period).simplified.item())
def test_regression_288(self):
np.random.seed(9)
sampling_period = 200 * pq.ms
spiketrain = homogeneous_poisson_process(10 * pq.Hz,
t_start=0 * pq.s,
t_stop=10 * pq.s)
kernel = kernels.AlphaKernel(sigma=5 * pq.ms, invert=True)
rate = statistics.instantaneous_rate(spiketrain,
sampling_period=sampling_period,
kernel=kernel)
self.assertEqual(len(rate), (spiketrain.t_stop /
sampling_period).simplified.item())
# 3 Hz is not a target - it's meant to test the non-negativity of the
# result rate; ideally, for smaller sampling rates, the integral
# should match the num. of spikes in the spiketrain
self.assertGreater(rate.mean(), 3 * pq.Hz)
def test_not_center_kernel(self):
# issue 107
t_spike = 1 * pq.s
st = neo.SpikeTrain([t_spike],
t_start=0 * pq.s,
t_stop=2 * pq.s,
units=pq.s)
kernel = kernels.AlphaKernel(200 * pq.ms)
fs = 0.1 * pq.ms
rate = statistics.instantaneous_rate(st,
sampling_period=fs,
kernel=kernel,
center_kernel=False)
rate_nonzero_index = np.nonzero(rate > 1e-6)[0]
# where the mass is concentrated
rate_mass = rate.times.rescale(t_spike.units)[rate_nonzero_index]
all_after_response_onset = (rate_mass >= t_spike).all()
self.assertTrue(all_after_response_onset)
def test_wrong_input(self):
self.assertRaises(TypeError, stds.victor_purpura_distance,
[self.array1, self.array2], self.q3)
self.assertRaises(TypeError, stds.victor_purpura_distance,
[self.qarray1, self.qarray2], self.q3)
self.assertRaises(TypeError, stds.victor_purpura_distance,
[self.qarray1, self.qarray2], 5.0 * ms)
self.assertRaises(TypeError,
stds.victor_purpura_distance,
[self.array1, self.array2],
self.q3,
algorithm='intuitive')
self.assertRaises(TypeError,
stds.victor_purpura_distance,
[self.qarray1, self.qarray2],
self.q3,
algorithm='intuitive')
self.assertRaises(TypeError,
stds.victor_purpura_distance,
[self.qarray1, self.qarray2],
5.0 * ms,
algorithm='intuitive')
self.assertRaises(TypeError, stds.van_rossum_distance,
[self.array1, self.array2], self.tau3)
self.assertRaises(TypeError, stds.van_rossum_distance,
[self.qarray1, self.qarray2], self.tau3)
self.assertRaises(TypeError, stds.van_rossum_distance,
[self.qarray1, self.qarray2], 5.0 * Hz)
self.assertRaises(TypeError, stds.victor_purpura_distance,
[self.st11, self.st13], self.tau2)
self.assertRaises(TypeError, stds.victor_purpura_distance,
[self.st11, self.st13], 5.0)
self.assertRaises(TypeError,
stds.victor_purpura_distance, [self.st11, self.st13],
self.tau2,
algorithm='intuitive')
self.assertRaises(TypeError,
stds.victor_purpura_distance, [self.st11, self.st13],
5.0,
algorithm='intuitive')
self.assertRaises(TypeError, stds.van_rossum_distance,
[self.st11, self.st13], self.q4)
self.assertRaises(TypeError, stds.van_rossum_distance,
[self.st11, self.st13], 5.0)
self.assertRaises(NotImplementedError,
stds.victor_purpura_distance, [self.st01, self.st02],
self.q3,
kernel=kernels.Kernel(2.0 / self.q3))
self.assertRaises(NotImplementedError,
stds.victor_purpura_distance, [self.st01, self.st02],
self.q3,
kernel=kernels.SymmetricKernel(2.0 / self.q3))
self.assertEqual(
stds.victor_purpura_distance(
[self.st01, self.st02],
self.q1,
kernel=kernels.TriangularKernel(
2.0 / (np.sqrt(6.0) * self.q2)))[0, 1],
stds.victor_purpura_distance(
[self.st01, self.st02],
self.q3,
kernel=kernels.TriangularKernel(
2.0 / (np.sqrt(6.0) * self.q2)))[0, 1])
self.assertEqual(
stds.victor_purpura_distance(
[self.st01, self.st02],
kernel=kernels.TriangularKernel(
2.0 / (np.sqrt(6.0) * self.q2)))[0, 1], 1.0)
self.assertNotEqual(
stds.victor_purpura_distance(
[self.st01, self.st02],
kernel=kernels.AlphaKernel(2.0 / (np.sqrt(6.0) * self.q2)))[0,
1],
1.0)
self.assertRaises(NameError,
stds.victor_purpura_distance, [self.st11, self.st13],
self.q2,
algorithm='slow')
def test_alpha_kernel_extreme(self):
alp_kernel = kernels.AlphaKernel(sigma=0.3 * pq.ms)
quantile = alp_kernel.boundary_enclosing_area_fraction(0.9999999)
self.assertAlmostEqual(quantile.magnitude, 4.055922083048838)
def test_error_alpha_kernel(self):
alp_kernel = kernels.AlphaKernel(sigma=0.3*pq.ms)
self.assertRaises(ValueError,
alp_kernel.boundary_enclosing_area_fraction, 0.9999999)
