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_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_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_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_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_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_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_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)