def test_semantics_floor_division():
# See Brian2 github issues #815 and #661
G = NeuronGroup(11,
'''a : integer
b : integer
x : 1
y : 1
fvalue : 1
ivalue : integer''',
dtype={
'a': np.int32,
'b': np.int64,
'x': np.float,
'y': np.double
})
int_values = np.arange(-5, 6)
float_values = np.arange(-5.0, 6.0, dtype=np.double)
G.ivalue = int_values
G.fvalue = float_values
with catch_logs() as l:
G.run_regularly('''
a = ivalue//3
b = ivalue//3
x = fvalue//3
y = fvalue//3
''')
run(defaultclock.dt)
# XXX: brian2 test adapted here for 1 warning
assert len(l) == 1
assert_equal(G.a[:], int_values // 3)
assert_equal(G.b[:], int_values // 3)
assert_allclose(G.x[:], float_values // 3)
assert_allclose(G.y[:], float_values // 3)
def test_stochastic_variable():
'''
Test that a NeuronGroup with a stochastic variable can be simulated. Only
makes sure no error occurs.
'''
tau = 10 * ms
G = NeuronGroup(1, 'dv/dt = -v/tau + xi*tau**-0.5: 1')
run(defaultclock.dt)
def test_stochastic_variable():
'''
Test that a NeuronGroup with a stochastic variable can be simulated. Only
makes sure no error occurs.
'''
tau = 10 * ms
G = NeuronGroup(1, 'dv/dt = -v/tau + xi*tau**-0.5: 1')
run(defaultclock.dt)
def test_stochastic_variable_multiplicative():
'''
Test that a NeuronGroup with multiplicative noise can be simulated. Only
makes sure no error occurs.
'''
mu = 0.5/second # drift
sigma = 0.1/second #diffusion
G = NeuronGroup(1, 'dX/dt = (mu - 0.5*second*sigma**2)*X + X*sigma*xi*second**.5: 1')
run(defaultclock.dt)
def test_stochastic_variable_multiplicative():
'''
Test that a NeuronGroup with multiplicative noise can be simulated. Only
makes sure no error occurs.
'''
mu = 0.5/second # drift
sigma = 0.1/second #diffusion
G = NeuronGroup(1, 'dX/dt = (mu - 0.5*second*sigma**2)*X + X*sigma*xi*second**.5: 1')
run(defaultclock.dt)
def test_threshold_reset():
'''
Test that threshold and reset work in the expected way.
'''
# Membrane potential does not change by itself
G = NeuronGroup(3, 'dv/dt = 0 / second : 1',
threshold='v > 1', reset='v=0.5')
G.v = np.array([0, 1, 2])
run(defaultclock.dt)
assert_equal(G.v[:], np.array([0, 1, 0.5]))
def test_threshold_reset():
'''
Test that threshold and reset work in the expected way.
'''
# Membrane potential does not change by itself
G = NeuronGroup(3, 'dv/dt = 0 / second : 1',
threshold='v > 1', reset='v=0.5')
G.v = np.array([0, 1, 2])
run(defaultclock.dt)
assert_equal(G.v[:], np.array([0, 1, 0.5]))
def test_linked_var_in_reset_size_1():
G1 = NeuronGroup(1, 'x:1')
G2 = NeuronGroup(1, '''x_linked : 1 (linked)
y:1''',
threshold='y>1', reset='y=0; x_linked += 1')
G2.x_linked = linked_var(G1, 'x')
G2.y = 1.1
# In this context, x_linked should not be considered as a scalar variable
# and therefore the reset statement should be allowed
run(3*defaultclock.dt)
assert_equal(G1.x[:], 1)
def test_group_variable_set_conditional_copy_to_host():
G = NeuronGroup(1, 'v : 1')
# uses group_variable_set_conditional template
G.v['i < 1'] = '50'
# connect template runs on host, requiring G.v on host after the group_variable_set
# template call above (this tests that data is copied from device to host)
S = Synapses(G, G)
S.connect(condition='v_pre == 50')
run(0 * second)
assert len(S) == 1, len(S)
def test_linked_var_in_reset_size_1():
G1 = NeuronGroup(1, 'x:1')
G2 = NeuronGroup(1, '''x_linked : 1 (linked)
y:1''',
threshold='y>1', reset='y=0; x_linked += 1')
G2.x_linked = linked_var(G1, 'x')
G2.y = 1.1
# In this context, x_linked should not be considered as a scalar variable
# and therefore the reset statement should be allowed
run(3*defaultclock.dt)
assert_equal(G1.x[:], 1)
def test_no_code():
# Make sure that we are not unncessarily creating code objects for a state
# updater that has nothing to do
group_1 = NeuronGroup(10, 'v: 1', threshold='False')
# The refractory argument will automatically add a statement for each time
# step, so we'll need a state updater here
group_2 = NeuronGroup(10, 'v: 1', threshold='False', refractory=2*ms)
run(0*ms)
assert len(group_1.state_updater.code_objects) == 0
assert group_1.state_updater.codeobj is None
assert len(group_2.state_updater.code_objects) == 1
assert group_2.state_updater.codeobj is not None
def test_referred_scalar_variable():
'''
Test the correct handling of referred scalar variables in subexpressions
'''
G = NeuronGroup(10, '''out = sin(2*pi*t*freq) + x: 1
x : 1
freq : Hz (shared)''')
G.freq = 1*Hz
G.x = np.arange(10)
G2 = NeuronGroup(10, '')
G2.variables.add_reference('out', G)
run(.25*second)
assert_allclose(G2.out[:], np.arange(10)+1)
def test_referred_scalar_variable():
'''
Test the correct handling of referred scalar variables in subexpressions
'''
G = NeuronGroup(10, '''out = sin(2*pi*t*freq) + x: 1
x : 1
freq : Hz (shared)''')
G.freq = 1*Hz
G.x = np.arange(10)
G2 = NeuronGroup(10, '')
G2.variables.add_reference('out', G)
run(.25*second)
assert_allclose(G2.out[:], np.arange(10)+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_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_integer_variables_and_mod():
'''
Test that integer operations and variable definitions work.
'''
n = 10
eqs = '''
dv/dt = (a+b+j+k)/second : 1
j = i%n : integer
k = i/n : integer
a = v%(i+1) : 1
b = v%(2*v) : 1
'''
G = NeuronGroup(100, eqs)
G.v = np.random.rand(len(G))
run(1*ms)
assert_equal(G.j[:], G.i[:]%n)
assert_equal(G.k[:], G.i[:]/n)
assert_equal(G.a[:], G.v[:]%(G.i[:]+1))
def test_integer_variables_and_mod():
'''
Test that integer operations and variable definitions work.
'''
n = 10
eqs = '''
dv/dt = (a+b+j+k)/second : 1
j = i%n : integer
k = i/n : integer
a = v%(i+1) : 1
b = v%(2*v) : 1
'''
G = NeuronGroup(100, eqs)
G.v = np.random.rand(len(G))
run(1*ms)
assert_equal(G.j[:], G.i[:]%n)
assert_equal(G.k[:], G.i[:]/n)
assert_equal(G.a[:], G.v[:]%(G.i[:]+1))
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_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)
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_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_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_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_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_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_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_unit_errors_threshold_reset():
'''
Test that unit errors in thresholds and resets are detected.
'''
# Unit error in threshold
group = NeuronGroup(1, 'dv/dt = -v/(10*ms) : 1', threshold='v > -20*mV')
assert_raises(DimensionMismatchError,
lambda: Network(group).run(0*ms))
# Unit error in reset
group = NeuronGroup(1, 'dv/dt = -v/(10*ms) : 1',
threshold='True',
reset='v = -65*mV')
assert_raises(DimensionMismatchError,
lambda: Network(group).run(0*ms))
# More complicated unit reset with an intermediate variable
# This should pass
group = NeuronGroup(1, 'dv/dt = -v/(10*ms) : 1',
threshold='False',
reset='''temp_var = -65
v = temp_var''')
run(0*ms)
# throw in an empty line (should still pass)
group = NeuronGroup(1, 'dv/dt = -v/(10*ms) : 1',
threshold='False',
reset='''temp_var = -65
v = temp_var''')
run(0*ms)
# This should fail
group = NeuronGroup(1, 'dv/dt = -v/(10*ms) : 1',
threshold='False',
reset='''temp_var = -65*mV
v = temp_var''')
assert_raises(DimensionMismatchError,
lambda: Network(group).run(0*ms))
# Resets with an in-place modification
# This should work
group = NeuronGroup(1, 'dv/dt = -v/(10*ms) : 1',
threshold='False',
reset='''v /= 2''')
run(0*ms)
# This should fail
group = NeuronGroup(1, 'dv/dt = -v/(10*ms) : 1',
threshold='False',
reset='''v -= 60*mV''')
assert_raises(DimensionMismatchError,
lambda: Network(group).run(0*ms))
def test_get_set_random_generator_state():
group = NeuronGroup(10,
'dv/dt = -v/(10*ms) + (10*ms)**-0.5*xi : 1',
method='euler')
group.v = 'rand()'
run(10 * ms)
assert np.var(group.v) > 0 # very basic test for randomness ;)
old_v = np.array(group.v)
random_state = get_device().get_random_state()
group.v = 'rand()'
run(10 * ms)
assert np.var(group.v - old_v) > 0 # just checking for *some* difference
old_v = np.array(group.v)
get_device().set_random_state(random_state)
group.v = 'rand()'
run(10 * ms)
assert_equal(group.v, old_v)
