def test_linked_variable_correct():
'''
Test correct uses of linked variables.
'''
tau = 10*ms
G1 = NeuronGroup(10, 'dv/dt = -v / tau : volt')
G1.v = np.linspace(0*mV, 20*mV, 10)
G2 = NeuronGroup(10, 'v : volt (linked)')
G2.v = linked_var(G1.v)
mon1 = StateMonitor(G1, 'v', record=True)
mon2 = StateMonitor(G2, 'v', record=True)
net = Network(G1, G2, mon1, mon2)
net.run(10*ms)
assert_equal(mon1.v[:, :], mon2.v[:, :])
def test_poisson_vectorized_values_fixed_and_random_seed():
if prefs.core.default_float_dtype is np.float32:
# TODO: Make test single-precision compatible, see #262
pytest.skip('Need double precision for this test')
G = NeuronGroup(
10, '''l: 1
dv/dt = -v/(10*ms) + 0.1*poisson(l)/ms : 1''')
G.l = arange(10)
mon = StateMonitor(G, 'v', record=True)
# first run
seed(13579)
G.v = 'poisson(l)'
seed()
run(2 * defaultclock.dt)
# second run
seed(13579)
G.v = 'poisson(l)'
seed()
run(2 * defaultclock.dt)
device.build(direct_call=False, **device.build_options)
first_run_values = np.array(mon.v[:, [0, 1]])
second_run_values = np.array(mon.v[:, [2, 3]])
# First time step should be identical (same seed)
assert_allclose(first_run_values[:, 0], second_run_values[:, 0])
# Second should be different (random seed)
with pytest.raises(AssertionError):
assert_allclose(first_run_values[:, 1], second_run_values[:, 1])
def test_random_values_fixed_and_random_seed():
G = NeuronGroup(10, 'dv/dt = -v/(10*ms) + 0.1*xi/sqrt(ms) : 1')
mon = StateMonitor(G, 'v', record=True)
# first run
seed(13579)
G.v = 'rand()'
seed()
run(2 * defaultclock.dt)
# second run
seed(13579)
G.v = 'rand()'
seed()
run(2 * defaultclock.dt)
device.build(direct_call=False, **device.build_options)
first_run_values = np.array(mon.v[:, [0, 1]])
second_run_values = np.array(mon.v[:, [2, 3]])
# First time step should be identical (same seed)
assert_allclose(first_run_values[:, 0], second_run_values[:, 0])
# Second should be different (random seed)
assert_raises(AssertionError, assert_allclose, first_run_values[:, 1],
second_run_values[:, 1])
def test_linked_subexpression_2():
'''
Test a linked variable referring to a subexpression without indices
'''
G = NeuronGroup(2, '''dv/dt = 100*Hz : 1
I = clip(v, 0, inf) : 1''',
threshold='v>1', reset='v=0')
G.v = [0, .5]
G2 = NeuronGroup(2, '''I_l : 1 (linked) ''')
G2.I_l = linked_var(G.I)
mon1 = StateMonitor(G, 'I', record=True)
mon = StateMonitor(G2, 'I_l', record=True)
run(5*ms)
assert all(mon[0].I_l == mon1[0].I)
assert all(mon[1].I_l == mon1[1].I)
def test_linked_variable_correct():
'''
Test correct uses of linked variables.
'''
tau = 10*ms
G1 = NeuronGroup(10, 'dv/dt = -v / tau : volt')
G1.v = linspace(0*mV, 20*mV, 10)
G2 = NeuronGroup(10, 'v : volt (linked)')
G2.v = linked_var(G1.v)
mon1 = StateMonitor(G1, 'v', record=True)
mon2 = StateMonitor(G2, 'v', record=True)
run(10*ms)
assert_equal(mon1.v[:, :], mon2.v[:, :])
# Make sure that printing the variable values works
assert len(str(G2.v)) > 0
assert len(repr(G2.v)) > 0
assert len(str(G2.v[:])) > 0
assert len(repr(G2.v[:])) > 0
def test_rand():
G = NeuronGroup(1000, 'dv/dt = rand() : second')
mon = StateMonitor(G, 'v', record=True)
run(3 * defaultclock.dt)
print(mon.v[:5, :])
assert_raises(AssertionError, assert_equal, mon.v[:, -1], 0)
assert_raises(AssertionError, assert_equal, mon.v[:, -2], mon.v[:, -1])
def test_linked_subexpression_3():
'''
Test a linked variable referring to a subexpression with indices
'''
G = NeuronGroup(2, '''dv/dt = 100*Hz : 1
I = clip(v, 0, inf) : 1''',
threshold='v>1', reset='v=0')
G.v = [0, .5]
G2 = NeuronGroup(10, '''I_l : 1 (linked) ''')
G2.I_l = linked_var(G.I, index=np.array([0, 1]).repeat(5))
mon1 = StateMonitor(G, 'I', record=True)
mon = StateMonitor(G2, 'I_l', record=True)
run(5*ms)
# Due to the linking, the first 5 and the second 5 recorded I vectors should
# refer to the
assert all((all(mon[i].I_l == mon1[0].I) for i in xrange(5)))
assert all((all(mon[i+5].I_l == mon1[1].I) for i in xrange(5)))
def test_random_number_generation_with_multiple_runs():
G = NeuronGroup(1000, 'dv/dt = rand() : second')
mon = StateMonitor(G, 'v', record=True)
run(1 * defaultclock.dt)
run(2 * defaultclock.dt)
device.build(direct_call=False, **device.build_options)
assert_raises(AssertionError, assert_equal, mon.v[:, -1], 0)
assert_raises(AssertionError, assert_equal, mon.v[:, -2], mon.v[:, -1])
def test_linked_variable_scalar():
'''
Test linked variable from a size 1 group.
'''
G1 = NeuronGroup(1, 'dx/dt = -x / (10*ms) : 1')
G2 = NeuronGroup(10, '''dy/dt = (-y + x) / (20*ms) : 1
x : 1 (linked)''')
G1.x = 1
G2.y = np.linspace(0, 1, 10)
G2.x = linked_var(G1.x)
mon = StateMonitor(G2, 'y', record=True)
net = Network(G1, G2, mon)
net.run(10*ms)
def test_binomial_values_synapse_dynamics_fixed_and_random_seed():
if prefs.core.default_float_dtype is np.float32:
# TODO: Make test single-precision compatible, see #262
pytest.skip('Need double precision for this test')
my_f = BinomialFunction(100, 0.1, approximate=False)
my_f_approximated = BinomialFunction(100, 0.1, approximate=True)
G = NeuronGroup(10, 'z : 1')
S = Synapses(
G, G,
'dv/dt = -v/(10*ms) + 0.1*(my_f() + my_f_approximated())*xi/sqrt(ms) : 1'
)
S.connect()
mon = StateMonitor(S, 'v', record=range(100))
# first run
S.v = 0
seed()
run(2 * defaultclock.dt)
# third run
S.v = 0
seed()
run(2 * defaultclock.dt)
# third run
S.v = 0
seed(13579)
run(2 * defaultclock.dt)
# fourth run
S.v = 0
seed(13579)
run(2 * defaultclock.dt)
device.build(direct_call=False, **device.build_options)
first_run_values = np.array(mon.v[:, [0, 1]])
second_run_values = np.array(mon.v[:, [2, 3]])
third_run_values = np.array(mon.v[:, [4, 5]])
fourth_run_values = np.array(mon.v[:, [6, 7]])
# First and second run should be different (random seed)
with pytest.raises(AssertionError):
assert_allclose(first_run_values, second_run_values)
# Third and fourth run should be identical (same seed)
assert_allclose(third_run_values, fourth_run_values)
def test_poisson_variable_lambda_values_fixed_and_random_seed():
if prefs.core.default_float_dtype is np.float32:
# TODO: Make test single-precision compatible, see #262
pytest.skip('Need double precision for this test')
G = NeuronGroup(
10, '''l : 1
dv/dt = -v/(10*ms) + 0.1*poisson(l)*xi/sqrt(ms) : 1''')
G.l = arange(10)
mon = StateMonitor(G, 'v', record=True)
# first run
G.v = 0
seed()
run(2 * defaultclock.dt)
# second run
G.v = 0
seed()
run(2 * defaultclock.dt)
# third run
G.v = 0
seed(13579)
run(2 * defaultclock.dt)
# fourth run
G.v = 0
seed(13579)
run(2 * defaultclock.dt)
device.build(direct_call=False, **device.build_options)
first_run_values = np.array(mon.v[:, [0, 1]])
second_run_values = np.array(mon.v[:, [2, 3]])
third_run_values = np.array(mon.v[:, [4, 5]])
fourth_run_values = np.array(mon.v[:, [6, 7]])
# First and second run should be different (random seed)
with pytest.raises(AssertionError):
assert_allclose(first_run_values, second_run_values)
# Third and fourth run should be identical (same seed)
assert_allclose(third_run_values, fourth_run_values)
def test_linked_subexpression():
'''
Test a subexpression referring to a linked variable.
'''
G = NeuronGroup(2, 'dv/dt = 100*Hz : 1',
threshold='v>1', reset='v=0')
G.v = [0, .5]
G2 = NeuronGroup(10, '''I = clip(x, 0, inf) : 1
x : 1 (linked) ''')
G2.x = linked_var(G.v, index=np.array([0, 1]).repeat(5))
mon = StateMonitor(G2, 'I', record=True)
run(5*ms)
# Due to the linking, the first 5 and the second 5 recorded I vectors should
# be identical
assert all((all(mon[i].I == mon[0].I) for i in xrange(5)))
assert all((all(mon[i+5].I == mon[5].I) for i in xrange(5)))
def test_binomial_values_synapse_dynamics_fixed_and_random_seed():
my_f = BinomialFunction(100, 0.1, approximate=False)
my_f_approximated = BinomialFunction(100, 0.1, approximate=True)
G = NeuronGroup(10, 'z : 1')
S = Synapses(
G, G,
'dv/dt = -v/(10*ms) + 0.1*(my_f() + my_f_approximated())*xi/sqrt(ms) : 1'
)
S.connect()
mon = StateMonitor(S, 'v', record=range(100))
# first run
S.v = 0
seed()
run(2 * defaultclock.dt)
# third run
S.v = 0
seed()
run(2 * defaultclock.dt)
# third run
S.v = 0
seed(13579)
run(2 * defaultclock.dt)
# fourth run
S.v = 0
seed(13579)
run(2 * defaultclock.dt)
device.build(direct_call=False, **device.build_options)
first_run_values = np.array(mon.v[:, [0, 1]])
second_run_values = np.array(mon.v[:, [2, 3]])
third_run_values = np.array(mon.v[:, [4, 5]])
fourth_run_values = np.array(mon.v[:, [6, 7]])
# First and second run should be different (random seed)
assert_raises(AssertionError, assert_allclose, first_run_values,
second_run_values)
# Third and fourth run should be identical (same seed)
assert_allclose(third_run_values, fourth_run_values)
def test_linked_variable_scalar():
'''
Test linked variable from a size 1 group.
'''
G1 = NeuronGroup(1, 'dx/dt = -x / (10*ms) : 1')
G2 = NeuronGroup(10, '''dy/dt = (-y + x) / (20*ms) : 1
x : 1 (linked)''')
G1.x = 1
G2.y = np.linspace(0, 1, 10)
G2.x = linked_var(G1.x)
mon = StateMonitor(G2, 'y', record=True)
# We don't test anything for now, except that it runs without raising an
# error
run(10*ms)
# Make sure that printing the variable values works
assert len(str(G2.x)) > 0
assert len(repr(G2.x)) > 0
assert len(str(G2.x[:])) > 0
assert len(repr(G2.x[:])) > 0
def test_random_values_codeobject_every_tick():
G = NeuronGroup(10, 'dv/dt = -v/(10*ms) + 0.1*xi/sqrt(ms) : 1')
mon = StateMonitor(G, 'v', record=True)
# first run
seed(10124)
G.v = 'rand()'
run(2 * defaultclock.dt)
# second run
seed(10124)
G.v = 'rand()'
run(2 * defaultclock.dt)
device.build(direct_call=False, **device.build_options)
first_run_values = np.array(mon.v[:, [0, 1]])
second_run_values = np.array(mon.v[:, [2, 3]])
# First time step should be identical (same seed)
assert_allclose(first_run_values[:, 0], second_run_values[:, 0])
# Second should also be identical (same seed)
assert_allclose(first_run_values[:, 1], second_run_values[:, 1])
def test_binomial_values():
if prefs.core.default_float_dtype is np.float32:
# TODO: Make test single-precision compatible, see #262
pytest.skip('Need double precision for this test')
# On Denis' local computer this test blows up all available RAM + SWAP when
# compiling with all threads in parallel. Use half the threads instead.
import socket
if socket.gethostname() == 'selene':
prefs.devices.cpp_standalone.extra_make_args_unix = ['-j4']
my_f_approximated = BinomialFunction(100, 0.1, approximate=True)
my_f = BinomialFunction(100, 0.1, approximate=False)
# Test neurongroup every tick objects
G = NeuronGroup(10,
'''dx/dt = my_f_approximated()/ms: 1
dy/dt = my_f()/ms: 1''',
threshold='True')
G.run_regularly('''x = my_f_approximated()
y = my_f()''')
# Test synapses every tick objects (where N is not known at compile time)
syn = Synapses(
G,
G,
model='''
dw/dt = my_f()/ms: 1
dv/dt = my_f_approximated()/ms: 1
''',
on_pre='''
x += w
y += v
'''
# TODO: fails when having binomial here, why?
#on_pre='''
# x += w * my_f()
# y += v * my_f_approximated()
# '''
)
# Test synapses generation, which needs host side binomial
syn.connect(condition='my_f_approximated() < 100')
mon = StateMonitor(G, ['x', 'y'], record=True)
w_mon = StateMonitor(syn, ['w', 'v'], record=np.arange(100))
def init_group_variables(my_f, my_f_approximated):
# Test codeobjects run only once outside the network,
# G.x uses group_variable_set_conditional, G.x[:5] uses group_variable_set
# Synapse objects (N not known at compile time)
syn.w = 'my_f()'
syn.w['i < j'] = 'my_f_approximated()'
syn.v = 'my_f_approximated()'
syn.v['i < j'] = 'my_f()'
# Neurongroup object
G.x = 'my_f_approximated()'
G.x[:5] = 'my_f()'
G.y = 'my_f()'
G.y[:5] = 'my_f_approximated()'
# first run
init_group_variables(my_f, my_f_approximated)
run(2 * defaultclock.dt)
# second run
seed(11400)
init_group_variables(my_f, my_f_approximated)
run(2 * defaultclock.dt)
# third run
seed()
init_group_variables(my_f, my_f_approximated)
run(2 * defaultclock.dt)
# forth run
seed(11400)
init_group_variables(my_f, my_f_approximated)
run(2 * defaultclock.dt)
device.build(direct_call=False, **device.build_options)
run_values_1 = np.vstack([
mon.x[:, [0, 1]], mon.y[:, [0, 1]], w_mon.w[:, [0, 1]], w_mon.v[:,
[0, 1]]
])
run_values_2 = np.vstack([
mon.x[:, [2, 3]], mon.y[:, [2, 3]], w_mon.w[:, [2, 3]], w_mon.v[:,
[2, 3]]
])
run_values_3 = np.vstack([
mon.x[:, [4, 5]], mon.y[:, [4, 5]], w_mon.w[:, [4, 5]], w_mon.v[:,
[4, 5]]
])
run_values_4 = np.vstack([
mon.x[:, [6, 7]], mon.y[:, [6, 7]], w_mon.w[:, [6, 7]], w_mon.v[:,
[6, 7]]
])
# Two calls to binomial functions should return different numbers in all runs
for n, values in enumerate(
[run_values_1, run_values_2, run_values_3, run_values_4]):
with pytest.raises(AssertionError):
assert_allclose(values[:, 0], values[:, 1])
# 2. and 4. run set the same seed
assert_allclose(run_values_2, run_values_4)
# all other combinations should be different
with pytest.raises(AssertionError):
assert_allclose(run_values_1, run_values_2)
with pytest.raises(AssertionError):
assert_allclose(run_values_1, run_values_3)
with pytest.raises(AssertionError):
assert_allclose(run_values_2, run_values_3)
def test_binomial_values():
my_f_approximated = BinomialFunction(100, 0.1, approximate=True)
my_f = BinomialFunction(100, 0.1, approximate=False)
# Test neurongroup every tick objects
G = NeuronGroup(10,
'''dx/dt = my_f_approximated()/ms: 1
dy/dt = my_f()/ms: 1''',
threshold='True')
G.run_regularly('''x = my_f_approximated()
y = my_f()''')
# Test synapses every tick objects (where N is not known at compile time)
syn = Synapses(
G,
G,
model='''
dw/dt = my_f()/ms: 1
dv/dt = my_f_approximated()/ms: 1
''',
on_pre='''
x += w
y += v
'''
# TODO: fails when having binomial here, why?
#on_pre='''
# x += w * my_f()
# y += v * my_f_approximated()
# '''
)
# Test synapses generation, which needs host side binomial
syn.connect(condition='my_f_approximated() < 100')
mon = StateMonitor(G, ['x', 'y'], record=True)
w_mon = StateMonitor(syn, ['w', 'v'], record=np.arange(100))
def init_group_variables(my_f, my_f_approximated):
# Test codeobjects run only once outside the network,
# G.x uses group_variable_set_conditional, G.x[:5] uses group_variable_set
# Synapse objects (N not known at compile time)
syn.w = 'my_f()'
syn.w['i < j'] = 'my_f_approximated()'
syn.v = 'my_f_approximated()'
syn.v['i < j'] = 'my_f()'
# Neurongroup object
G.x = 'my_f_approximated()'
G.x[:5] = 'my_f()'
G.y = 'my_f()'
G.y[:5] = 'my_f_approximated()'
# first run
init_group_variables(my_f, my_f_approximated)
run(2 * defaultclock.dt)
# second run
seed(11400)
init_group_variables(my_f, my_f_approximated)
run(2 * defaultclock.dt)
# third run
seed()
init_group_variables(my_f, my_f_approximated)
run(2 * defaultclock.dt)
# forth run
seed(11400)
init_group_variables(my_f, my_f_approximated)
run(2 * defaultclock.dt)
device.build(direct_call=False, **device.build_options)
run_values_1 = np.vstack([
mon.x[:, [0, 1]], mon.y[:, [0, 1]], w_mon.w[:, [0, 1]], w_mon.v[:,
[0, 1]]
])
run_values_2 = np.vstack([
mon.x[:, [2, 3]], mon.y[:, [2, 3]], w_mon.w[:, [2, 3]], w_mon.v[:,
[2, 3]]
])
run_values_3 = np.vstack([
mon.x[:, [4, 5]], mon.y[:, [4, 5]], w_mon.w[:, [4, 5]], w_mon.v[:,
[4, 5]]
])
run_values_4 = np.vstack([
mon.x[:, [6, 7]], mon.y[:, [6, 7]], w_mon.w[:, [6, 7]], w_mon.v[:,
[6, 7]]
])
# Two calls to binomial functions should return different numbers in all runs
for n, values in enumerate(
[run_values_1, run_values_2, run_values_3, run_values_4]):
assert_raises(AssertionError, assert_allclose, values[:, 0], values[:,
1])
# 2. and 4. run set the same seed
assert_allclose(run_values_2, run_values_4)
# all other combinations should be different
assert_raises(AssertionError, assert_allclose, run_values_1, run_values_2)
assert_raises(AssertionError, assert_allclose, run_values_1, run_values_3)
assert_raises(AssertionError, assert_allclose, run_values_2, run_values_3)