def test_apply_function_to_structured_array(): f = lambda m: 2 * m + 3 input = numpy.arange(12).reshape((4, 3)) m0 = LazyArray(input, shape=(4, 3)) m1 = f(m0) assert isinstance(m1, larray) assert_arrays_equal(m1.evaluate(simplify=True), input * 2 + 3)
def test_infinite_space_with_3D_distances(self): s = space.Space() self.assertEqual(s.distances(self.A, self.B), sqrt(3)) self.assertEqual(s.distances(self.C, self.B), sqrt(12)) self.assertArraysEqual(s.distances(self.A, self.ABCD), numpy.array([0.0, sqrt(3), sqrt(3), sqrt(29)])) self.assertArraysEqual(s.distances(self.A, self.ABCD), s.distances(self.ABCD, self.A).T) assert_arrays_equal( s.distances(self.ABCD, self.ABCD), numpy.array([ 0.0, sqrt(3), sqrt(3), sqrt(29), sqrt(3), 0.0, sqrt(12), sqrt(14), sqrt(3), sqrt(12), 0.0, sqrt(50.0), sqrt(29), sqrt(14), sqrt(50.0), 0.0 ])) self.assertArraysEqual(s.distances(self.ABCD, self.A), numpy.array([0.0, sqrt(3), sqrt(3), sqrt(29)]))
def test_tsodyks_markram_synapse(): if not have_nest: raise SkipTest import nest sim = pyNN.nest sim.setup() spike_source = sim.Population( 1, sim.SpikeSourceArray(spike_times=numpy.arange(10, 100, 10))) neurons = sim.Population( 5, sim.IF_cond_exp(e_rev_I=-75, tau_syn_I=numpy.arange(0.2, 0.7, 0.1))) synapse_type = sim.TsodyksMarkramSynapse(U=0.04, tau_rec=100.0, tau_facil=1000.0, weight=0.01, delay=0.5) connector = sim.AllToAllConnector() prj = sim.Projection(spike_source, neurons, connector, receptor_type='inhibitory', synapse_type=synapse_type) neurons.record('gsyn_inh') sim.run(100.0) connections = nest.GetConnections(numpy.unique(prj._sources).tolist(), synapse_model=prj.nest_synapse_model) tau_psc = numpy.array(nest.GetStatus(connections, 'tau_psc')) assert_arrays_equal(tau_psc, numpy.arange(0.2, 0.7, 0.1))
def test_tset_with_numeric_values(): p = MockPopulation() p._set_array = Mock() tau_m = numpy.linspace(10.0, 20.0, num=p.size) p.tset("tau_m", tau_m) assert_arrays_equal(p._set_array.call_args[1]['tau_m'], tau_m[p._mask_local])
def test_really_simple1(self): A = numpy.ones((3, )) B = numpy.zeros((3, 5)) D = connectors.DistanceMatrix(B, space.Space()) D.set_source(A) assert_arrays_equal(D.as_array(), numpy.sqrt(3 * numpy.ones((5, ), float)))
def test_setitem_nonexpanded_different_value(): A = LazyArray(3, shape=(5, )) assert A.evaluate(simplify=True) == 3 A[0] = 4 A[4] = 5 assert_arrays_equal(A.evaluate(simplify=True), numpy.array([4, 3, 3, 3, 5]))
def test__make_compatible_v(): r = recording.Recorder('v') input_data = numpy.array([[0, 0.0, -65.0], [3, 0.0, -65.0], [0, 0.1, -64.3], [3, 0.1, -65.1], [0, 0.2, -63.7], [3, 0.2, -65.5]]) output_data = r._make_compatible(input_data) # voltage id assert_arrays_equal(input_data[:,(2,0)], output_data)
def test_reset_recording(sim): """ Check that record(None) resets the list of things to record. This test injects different levels of current into two neurons. In the first run, we record one of the neurons, in the second we record the other. The main point is to check that the first neuron is not recorded in the second run. """ sim.setup() p = sim.Population(7, sim.IF_cond_exp()) p[3].i_offset = 0.1 p[4].i_offset = 0.2 p[3:4].record('v') sim.run(10.0) sim.reset() p.record(None) p[4:5].record('v') sim.run(10.0) data = p.get_data() ti = lambda i: data.segments[i].analogsignalarrays[0].times assert_arrays_equal(ti(0), ti(1)) idx = lambda i: data.segments[i].analogsignalarrays[0].channel_index assert idx(0) == [3] assert idx(1) == [4] vi = lambda i: data.segments[i].analogsignalarrays[0] assert vi(0).shape == vi(1).shape == (101, 1) assert vi(0)[0, 0] == vi(1)[0, 0] == p.initial_values['v'].evaluate(simplify=True)*pq.mV # the first value should be the same assert not (vi(0)[1:, 0] == vi(1)[1:, 0]).any() # none of the others should be, because of different i_offset
def test_reset_recording(sim): """ Check that record(None) resets the list of things to record. This test injects different levels of current into two neurons. In the first run, we record one of the neurons, in the second we record the other. The main point is to check that the first neuron is not recorded in the second run. """ sim.setup() p = sim.Population(7, sim.IF_cond_exp()) p[3].i_offset = 0.1 p[4].i_offset = 0.2 p[3:4].record('v') sim.run(10.0) sim.reset() p.record(None) p[4:5].record('v') sim.run(10.0) data = p.get_data() sim.end() ti = lambda i: data.segments[i].analogsignalarrays[0].times assert_arrays_equal(ti(0), ti(1)) idx = lambda i: data.segments[i].analogsignalarrays[0].channel_index assert idx(0) == [3] assert idx(1) == [4] vi = lambda i: data.segments[i].analogsignalarrays[0] assert vi(0).shape == vi(1).shape == (101, 1) assert vi(0)[0, 0] == vi(1)[0, 0] == p.initial_values['v'].evaluate(simplify=True)*pq.mV # the first value should be the same assert not (vi(0)[1:, 0] == vi(1)[1:, 0]).any() # none of the others should be, because of different i_offset
def issue241(sim): spike_train1 = sim.Population(1, sim.SpikeSourcePoisson, { 'rate': [5], 'start': [1000], 'duration': [1234] }) spike_train2 = sim.Population(2, sim.SpikeSourcePoisson, { 'rate': [5, 6], 'start': [1000, 1001], 'duration': [1234, 2345] }) spike_train3 = sim.Population(1, sim.SpikeSourcePoisson, { 'rate': [5], 'start': [1000], 'duration': 1234 }) spike_train4 = sim.Population(1, sim.SpikeSourcePoisson, { 'rate': [5], 'start': [1000] }) spike_train5 = sim.Population(2, sim.SpikeSourcePoisson, { 'rate': [5, 6], 'start': [1000, 1001] }) assert_arrays_equal(spike_train2.get('duration'), numpy.array([1234, 2345])) assert_equal(spike_train3.get(['rate', 'start', 'duration']), [5, 1000, 1234])
def test_get_positions(): p = MockPopulation(11, MockStandardCell) ppos = numpy.random.uniform(size=(3, 11)) p._positions = ppos pv = common.PopulationView(parent=p, selector=slice(3, 9, 2)) assert_arrays_equal(pv.positions, numpy.array([ppos[:, 3], ppos[:, 5], ppos[:, 7]]).T)
def test_columnwise_iteration_with_structured_array_and_mask(): input = numpy.arange(12).reshape((4, 3)) m = LazyArray(input, shape=(4, 3)) # 4 rows, 3 columns mask = numpy.array([False, True, True]) cols = [col for col in m.by_column(mask=mask)] assert_arrays_equal(cols[0], input[:, 1]) assert_arrays_equal(cols[1], input[:, 2])
def test_infinite_space_with_3D_distances(self): s = space.Space() self.assertEqual(s.distances(self.A, self.B), sqrt(3)) self.assertEqual(s.distances(self.C, self.B), sqrt(12)) self.assertArraysEqual(s.distances(self.A, self.ABCD), numpy.array([0.0, sqrt(3), sqrt(3), sqrt(29)])) self.assertArraysEqual(s.distances(self.A, self.ABCD), s.distances(self.ABCD, self.A).T) assert_arrays_equal( s.distances(self.ABCD, self.ABCD), numpy.array( [ 0.0, sqrt(3), sqrt(3), sqrt(29), sqrt(3), 0.0, sqrt(12), sqrt(14), sqrt(3), sqrt(12), 0.0, sqrt(50.0), sqrt(29), sqrt(14), sqrt(50.0), 0.0, ] ), ) self.assertArraysEqual(s.distances(self.ABCD, self.A), numpy.array([0.0, sqrt(3), sqrt(3), sqrt(29)]))
def test_really_simple1(self): A = numpy.ones((3,)) B = numpy.zeros((3,5)) D = connectors.DistanceMatrix(B, space.Space()) D.set_source(A) assert_arrays_equal(D.as_array(), numpy.sqrt(3*numpy.ones((5,), float)))
def test_create_with_boolean_array_selector(): p = MockPopulation(11, MockStandardCell) mask = numpy.array([0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0], dtype=bool) pv = common.PopulationView(parent=p, selector=mask) assert_arrays_equal( pv.all_cells, numpy.array([p.all_cells[3], p.all_cells[5], p.all_cells[7]]))
def test_get_positions(): p = MockPopulation(11, MockStandardCell) ppos = numpy.random.uniform(size=(3,11)) p._positions = ppos pv = common.PopulationView(parent=p, selector=slice(3,9,2)) assert_arrays_equal(pv.positions, numpy.array([ppos[:,3], ppos[:,5], ppos[:,7]]).T)
def issue241(sim): # "Nest SpikeSourcePoisson populations require all parameters to be passed to constructor" sim.setup() spike_train1 = sim.Population(1, sim.SpikeSourcePoisson, { 'rate': [5], 'start': [1000], 'duration': [1234] }) spike_train2 = sim.Population(2, sim.SpikeSourcePoisson, { 'rate': [5, 6], 'start': [1000, 1001], 'duration': [1234, 2345] }) spike_train3 = sim.Population(1, sim.SpikeSourcePoisson, { 'rate': [5], 'start': [1000], 'duration': 1234 }) spike_train4 = sim.Population(1, sim.SpikeSourcePoisson, { 'rate': [5], 'start': [1000] }) spike_train5 = sim.Population(2, sim.SpikeSourcePoisson, { 'rate': [5, 6], 'start': [1000, 1001] }) assert_arrays_equal(spike_train2.get('duration'), numpy.array([1234, 2345])) assert_equal(spike_train3.get(['rate', 'start', 'duration']), [5, 1000, 1234]) sim.end()
def test_set_synaptic_parameters(sim): sim.setup() mpi_rank = sim.rank() p1 = sim.Population(4, sim.IF_cond_exp()) p2 = sim.Population(2, sim.IF_cond_exp()) syn = sim.TsodyksMarkramSynapse(U=0.5, weight=0.123, delay=0.1) prj = sim.Projection(p1, p2, sim.AllToAllConnector(), syn) expected = numpy.array([ (0.0, 0.0, 0.123, 0.1, 0.5), (0.0, 1.0, 0.123, 0.1, 0.5), (1.0, 0.0, 0.123, 0.1, 0.5), (1.0, 1.0, 0.123, 0.1, 0.5), (2.0, 0.0, 0.123, 0.1, 0.5), (2.0, 1.0, 0.123, 0.1, 0.5), (3.0, 0.0, 0.123, 0.1, 0.5), (3.0, 1.0, 0.123, 0.1, 0.5), ]) actual = numpy.array(prj.get(['weight', 'delay', 'U'], format='list')) if mpi_rank == 0: ind = numpy.lexsort((actual[:, 1], actual[:, 0])) assert_arrays_equal(actual[ind], expected) positional_weights = numpy.array([[0, 1], [2, 3], [4, 5], [6, 7]], dtype=float) prj.set(weight=positional_weights) expected = positional_weights actual = prj.get('weight', format='array') if mpi_rank == 0: assert_arrays_equal(actual, expected) u_list = [0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2] prj.set(U=u_list) expected = numpy.array([[0.9, 0.8], [0.7, 0.6], [0.5, 0.4], [0.3, 0.2]]) actual = prj.get('U', format='array') if mpi_rank == 0: assert_arrays_equal(actual, expected) f_delay = lambda d: 0.5 + d prj.set(delay=f_delay) expected = numpy.array([[0.5, 1.5], [1.5, 0.5], [2.5, 1.5], [3.5, 2.5]]) actual = prj.get('delay', format='array') if mpi_rank == 0: assert_arrays_equal(actual, expected) # final sanity check expected = numpy.array([ (0.0, 0.0, 0.0, 0.5, 0.9), (0.0, 1.0, 1.0, 1.5, 0.8), (1.0, 0.0, 2.0, 1.5, 0.7), (1.0, 1.0, 3.0, 0.5, 0.6), (2.0, 0.0, 4.0, 2.5, 0.5), (2.0, 1.0, 5.0, 1.5, 0.4), (3.0, 0.0, 6.0, 3.5, 0.3), (3.0, 1.0, 7.0, 2.5, 0.2), ]) actual = numpy.array(prj.get(['weight', 'delay', 'U'], format='list')) if mpi_rank == 0: ind = numpy.lexsort((actual[:, 1], actual[:, 0])) assert_arrays_equal(actual[ind], expected)
def test_columnwise_iteration_with_structured_array_and_mask(): input = numpy.arange(12).reshape((4,3)) m = LazyArray(input, shape=(4,3)) # 4 rows, 3 columns mask = numpy.array([False, True, True]) cols = [col for col in m.by_column(mask=mask)] assert_arrays_equal(cols[0], input[:,1]) assert_arrays_equal(cols[1], input[:,2])
def test_apply_function_to_structured_array(): f = lambda m: 2*m + 3 input = numpy.arange(12).reshape((4,3)) m0 = LazyArray(input, shape=(4,3)) m1 = f(m0) assert isinstance(m1, larray) assert_arrays_equal(m1.evaluate(simplify=True), input*2 + 3)
def test_set_synaptic_parameters(sim): sim.setup() mpi_rank = sim.rank() p1 = sim.Population(4, sim.IF_cond_exp()) p2 = sim.Population(2, sim.IF_cond_exp()) syn = sim.TsodyksMarkramSynapse(U=0.5, weight=0.123, delay=0.1) prj = sim.Projection(p1, p2, sim.AllToAllConnector(), syn) expected = numpy.array([ (0.0, 0.0, 0.123, 0.1, 0.5), (0.0, 1.0, 0.123, 0.1, 0.5), (1.0, 0.0, 0.123, 0.1, 0.5), (1.0, 1.0, 0.123, 0.1, 0.5), (2.0, 0.0, 0.123, 0.1, 0.5), (2.0, 1.0, 0.123, 0.1, 0.5), (3.0, 0.0, 0.123, 0.1, 0.5), (3.0, 1.0, 0.123, 0.1, 0.5), ]) actual = numpy.array(prj.get(['weight', 'delay', 'U'], format='list')) if mpi_rank == 0: ind = numpy.lexsort((actual[:, 1], actual[:, 0])) assert_arrays_equal(actual[ind], expected) positional_weights = numpy.array([[0, 1], [2, 3], [4, 5], [6, 7]], dtype=float) prj.set(weight=positional_weights) expected = positional_weights actual = prj.get('weight', format='array') if mpi_rank == 0: assert_arrays_equal(actual, expected) u_list = [0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2] prj.set(U=u_list) expected = numpy.array([[0.9, 0.8], [0.7, 0.6], [0.5, 0.4], [0.3, 0.2]]) actual = prj.get('U', format='array') if mpi_rank == 0: assert_arrays_equal(actual, expected) f_delay = lambda d: 0.5+d prj.set(delay=f_delay) expected = numpy.array([[0.5, 1.5], [1.5, 0.5], [2.5, 1.5], [3.5, 2.5]]) actual = prj.get('delay', format='array') if mpi_rank == 0: assert_arrays_equal(actual, expected) # final sanity check expected = numpy.array([ (0.0, 0.0, 0.0, 0.5, 0.9), (0.0, 1.0, 1.0, 1.5, 0.8), (1.0, 0.0, 2.0, 1.5, 0.7), (1.0, 1.0, 3.0, 0.5, 0.6), (2.0, 0.0, 4.0, 2.5, 0.5), (2.0, 1.0, 5.0, 1.5, 0.4), (3.0, 0.0, 6.0, 3.5, 0.3), (3.0, 1.0, 7.0, 2.5, 0.2), ]) actual = numpy.array(prj.get(['weight', 'delay', 'U'], format='list')) if mpi_rank == 0: ind = numpy.lexsort((actual[:, 1], actual[:, 0])) assert_arrays_equal(actual[ind], expected)
def test__record(): p = MockPopulation() p.recorders = {'v': Mock()} p._record('v') meth, args, kwargs = p.recorders['v'].method_calls[0] id_arr, = args assert_equal(meth, 'record') assert_arrays_equal(id_arr, p.all_cells)
def issue241(sim): spike_train1 = sim.Population(1, sim.SpikeSourcePoisson, {'rate' : [5], 'start' : [1000], 'duration': [1234]}) spike_train2 = sim.Population(2, sim.SpikeSourcePoisson, {'rate' : [5, 6], 'start' : [1000, 1001], 'duration': [1234, 2345]}) spike_train3 = sim.Population(1, sim.SpikeSourcePoisson, {'rate' : [5], 'start' : [1000], 'duration': 1234}) spike_train4 = sim.Population(1, sim.SpikeSourcePoisson, {'rate' : [5], 'start' : [1000]}) spike_train5 = sim.Population(2, sim.SpikeSourcePoisson, {'rate' : [5, 6], 'start' : [1000, 1001]}) assert_arrays_equal(spike_train2.get('duration'), numpy.array([1234, 2345])) assert_equal(spike_train3.get(['rate', 'start', 'duration']), [5, 1000, 1234])
def test_create_with_index_array_selector(): p = MockPopulation(11, MockStandardCell) mask = numpy.array([3, 5, 7]) pv = common.PopulationView(parent=p, selector=mask) assert_arrays_equal( pv.all_cells, numpy.array([p.all_cells[3], p.all_cells[5], p.all_cells[7]])) assert_arrays_equal(pv.mask, mask)
def test_apply_function_to_functional_array(): input = lambda i, j: 2 * i + j m0 = LazyArray(input, shape=(4, 3)) f = lambda m: 2 * m + 3 m1 = f(m0) assert_arrays_equal( m1.evaluate(), numpy.array([[3, 5, 7], [7, 9, 11], [11, 13, 15], [15, 17, 19]]))
def test_evaluate_with_functional_array(): input = lambda i,j: 2*i + j m = LazyArray(input, shape=(4,3)) assert_arrays_equal(m.evaluate(), numpy.array([[0, 1, 2], [2, 3, 4], [4, 5, 6], [6, 7, 8]]))
def test__make_compatible_v(): r = recording.Recorder('v') input_data = numpy.array([[0, 0.0, -65.0], [3, 0.0, -65.0], [0, 0.1, -64.3], [3, 0.1, -65.1], [0, 0.2, -63.7], [3, 0.2, -65.5]]) output_data = r._make_compatible(input_data) # voltage id assert_arrays_equal(input_data[:, (2, 0)], output_data)
def test_check_weight_with_NaN(): w = numpy.arange(10.0) w[0] = numpy.nan assert_arrays_equal( w[1:], common.check_weight( w, 'excitatory', is_conductance=True)[1:]) # NaN != NaN by definition
def test_set_positions(): p = MockPopulation(11, MockStandardCell) assert p._structure != None new_positions = numpy.random.uniform(size=(3,11)) p.positions = new_positions assert_equal(p.structure, None) assert_arrays_equal(p.positions, new_positions) new_positions[0,0] = 99.9 assert p.positions[0,0] != 99.9
def test_sample(): orig_pv = populations.PopulationView populations.PopulationView = Mock() p = MockPopulation() rng = Mock() rng.permutation = Mock(return_value=numpy.array([7,4,8,12,0,3,9,1,2,11,5,10,6])) pv = p.sample(5, rng=rng) assert_arrays_equal(populations.PopulationView.call_args[0][1], numpy.array([7,4,8,12,0])) populations.PopulationView = orig_pv
def test_initialize_random_distribution(): p = MockPopulation() p.initial_values = {} p._set_initial_value_array = Mock() class MockRandomDistribution(random.RandomDistribution): def next(self, n, mask_local): return 42*numpy.ones(n)[mask_local] p.initialize('v', MockRandomDistribution()) assert_arrays_equal(p.initial_values['v'].evaluate(simplify=True), 42*numpy.ones(p.local_size))
def test_get__zero_offset(): r = recording.Recorder('spikes') fake_data = numpy.array([ (3, 12.3), (4, 14.5), (7, 19.8) ]) r._get = Mock(return_value=fake_data) assert_arrays_equal(r.get(), fake_data)
def test_set_positions(): p = MockPopulation(11, MockStandardCell) assert p._structure != None new_positions = numpy.random.uniform(size=(3, 11)) p.positions = new_positions assert_equal(p.structure, None) assert_arrays_equal(p.positions, new_positions) new_positions[0, 0] = 99.9 assert p.positions[0, 0] != 99.9
def test_tset_with_array_values(): p = MockPopulation() p._set_array = Mock() spike_times = numpy.linspace(0.0, 1000.0, num=10*p.size).reshape((p.size,10)) p.tset("spike_times", spike_times) call_args = p._set_array.call_args[1]['spike_times'] assert_equal(call_args.shape, spike_times[p._mask_local].shape) assert_arrays_equal(call_args.flatten(), spike_times[p._mask_local].flatten())
def test_local_cells(): p1 = MockPopulation() p2 = MockPopulation() p3 = MockPopulation() a = Assembly(p1, p2, p3) assert_equal(a.local_cells.size, p1.local_cells.size + p2.local_cells.size + p3.local_cells.size) assert_equal(a.local_cells[0], p1.local_cells[0]) assert_equal(a.local_cells[-1], p3.local_cells[-1]) assert_arrays_equal(a.local_cells, numpy.append(p1.local_cells, (p2.local_cells, p3.local_cells)))
def test_tset_with_array_values(): p = MockPopulation() p._set_array = Mock() spike_times = numpy.linspace(0.0, 1000.0, num=10 * p.size).reshape( (p.size, 10)) p.tset("spike_times", spike_times) call_args = p._set_array.call_args[1]['spike_times'] assert_equal(call_args.shape, spike_times[p._mask_local].shape) assert_arrays_equal(call_args.flatten(), spike_times[p._mask_local].flatten())
def test_apply_function_to_functional_array(): input = lambda i,j: 2*i + j m0 = LazyArray(input, shape=(4,3)) f = lambda m: 2*m + 3 m1 = f(m0) assert_arrays_equal(m1.evaluate(), numpy.array([[3, 5, 7], [7, 9, 11], [11, 13, 15], [15, 17, 19]]))
def test_weight_histogram_no_args(): p1 = MockPopulation() p2 = MockPopulation() prj = common.Projection(p1, p2, method=Mock()) prj.getWeights = Mock(return_value=numpy.array(range(10)*42)) n, bins = prj.weightHistogram(nbins=10) assert_equal(n.size, 10) assert_equal(bins.size, n.size+1) assert_arrays_equal(n, 42*numpy.ones(10)) assert_equal(n.sum(), 420) assert_arrays_equal(bins, numpy.arange(0.0, 9.1, 0.9))
def test_all_cells(): p1 = MockPopulation() p2 = MockPopulation() p3 = MockPopulation() a = Assembly(p1, p2, p3) assert_equal(a.all_cells.size, p1.all_cells.size + p2.all_cells.size + p3.all_cells.size) assert_equal(a.all_cells[0], p1.all_cells[0]) assert_equal(a.all_cells[-1], p3.all_cells[-1]) assert_arrays_equal( a.all_cells, numpy.append(p1.all_cells, (p2.all_cells, p3.all_cells)))
def test_weight_histogram_no_args(): p1 = MockPopulation() p2 = MockPopulation() prj = common.Projection(p1, p2, method=Mock()) prj.getWeights = Mock(return_value=numpy.array(range(10) * 42)) n, bins = prj.weightHistogram(nbins=10) assert_equal(n.size, 10) assert_equal(bins.size, n.size + 1) assert_arrays_equal(n, 42 * numpy.ones(10)) assert_equal(n.sum(), 420) assert_arrays_equal(bins, numpy.arange(0.0, 9.1, 0.9))
def test_mask_local(): p1 = MockPopulation() p2 = MockPopulation() p3 = MockPopulation() a = Assembly(p1, p2, p3) assert_equal(a._mask_local.size, p1._mask_local.size + p2._mask_local.size + p3._mask_local.size) assert_equal(a._mask_local[0], p1._mask_local[0]) assert_equal(a._mask_local[-1], p3._mask_local[-1]) assert_arrays_equal(a._mask_local, numpy.append(p1._mask_local, (p2._mask_local, p3._mask_local))) assert_arrays_equal(a.local_cells, a.all_cells[a._mask_local])
def test_generator_for_infinite_space_with_3D_distances(self): s = space.Space() f = lambda i: self.ABCD[i] g = lambda j: self.ABCD[j] self.assertArraysEqual(s.distance_generator(f, g)(0, numpy.arange(4)), numpy.array([0.0, sqrt(3), sqrt(3), sqrt(29)])) assert_arrays_equal(numpy.fromfunction(s.distance_generator(f, g), shape=(4, 4), dtype=int), numpy.array([(0.0, sqrt(3), sqrt(3), sqrt(29)), (sqrt(3), 0.0, sqrt(12), sqrt(14)), (sqrt(3), sqrt(12), 0.0, sqrt(50.0)), (sqrt(29), sqrt(14), sqrt(50.0), 0.0)]))
def issue241(sim): # "Nest SpikeSourcePoisson populations require all parameters to be passed to constructor" sim.setup() spike_train1 = sim.Population(1, sim.SpikeSourcePoisson, {'rate' : [5], 'start' : [1000], 'duration': [1234]}) spike_train2 = sim.Population(2, sim.SpikeSourcePoisson, {'rate' : [5, 6], 'start' : [1000, 1001], 'duration': [1234, 2345]}) spike_train3 = sim.Population(1, sim.SpikeSourcePoisson, {'rate' : [5], 'start' : [1000], 'duration': 1234}) spike_train4 = sim.Population(1, sim.SpikeSourcePoisson, {'rate' : [5], 'start' : [1000]}) spike_train5 = sim.Population(2, sim.SpikeSourcePoisson, {'rate' : [5, 6], 'start' : [1000, 1001]}) assert_arrays_equal(spike_train2.get('duration'), numpy.array([1234, 2345])) assert_equal(spike_train3.get(['rate', 'start', 'duration']), [5, 1000, 1234]) sim.end()
def test_generator_for_infinite_space_with_3D_distances(self): s = space.Space() def f(i): return self.ABCD[i] def g(j): return self.ABCD[j] self.assertArraysEqual(s.distance_generator(f, g)(0, np.arange(4)), np.array([0.0, sqrt(3), sqrt(3), sqrt(29)])) assert_arrays_equal(np.fromfunction(s.distance_generator(f, g), shape=(4, 4), dtype=int), np.array([(0.0, sqrt(3), sqrt(3), sqrt(29)), (sqrt(3), 0.0, sqrt(12), sqrt(14)), (sqrt(3), sqrt(12), 0.0, sqrt(50.0)), (sqrt(29), sqrt(14), sqrt(50.0), 0.0)]))
def test_sample(): orig_pv = populations.PopulationView populations.PopulationView = Mock() p = MockPopulation() rng = Mock() rng.permutation = Mock( return_value=numpy.array([7, 4, 8, 12, 0, 3, 9, 1, 2, 11, 5, 10, 6])) pv = p.sample(5, rng=rng) assert_arrays_equal(populations.PopulationView.call_args[0][1], numpy.array([7, 4, 8, 12, 0])) populations.PopulationView = orig_pv
def test_rset(): """Population.rset()""" p = MockPopulation() rd = Mock() rnums = numpy.arange(p.size) rd.next = Mock(return_value=rnums) p.tset = Mock() p.rset("cm", rd) rd.next.assert_called_with(**{'mask_local': False, 'n': p.size}) call_args = p.tset.call_args assert_equal(call_args[0][0], 'cm') assert_arrays_equal(call_args[0][1], rnums)
def test_initialize_random_distribution(): p = MockPopulation() p.initial_values = {} p._set_initial_value_array = Mock() class MockRandomDistribution(random.RandomDistribution): def next(self, n, mask_local): return 42 * numpy.ones(n)[mask_local] p.initialize('v', MockRandomDistribution()) assert_arrays_equal(p.initial_values['v'].evaluate(simplify=True), 42 * numpy.ones(p.local_size))
def test_NumpyBinaryFile(): nbf = files.NumpyBinaryFile("tmp.npz", "w") data=[(0, 2.3),(1, 3.4),(2, 4.3)] metadata = {'a': 1, 'b': 9.99} nbf.write(data, metadata) nbf.close() nbf = files.NumpyBinaryFile("tmp.npz", "r") assert_equal(nbf.get_metadata(), metadata) assert_arrays_equal(nbf.read().flatten(), numpy.array(data).flatten()) nbf.close() os.remove("tmp.npz")
def test_NumpyBinaryFile(): nbf = files.NumpyBinaryFile("tmp.npz", "w") data = [(0, 2.3), (1, 3.4), (2, 4.3)] metadata = {'a': 1, 'b': 9.99} nbf.write(data, metadata) nbf.close() nbf = files.NumpyBinaryFile("tmp.npz", "r") assert_equal(nbf.get_metadata(), metadata) assert_arrays_equal(nbf.read().flatten(), numpy.array(data).flatten()) nbf.close() os.remove("tmp.npz")
def test_save_positions(): import os orig_rank = MockPopulation._simulator.state.mpi_rank MockPopulation._simulator.state.mpi_rank = 0 p = MockPopulation() p.all_cells = numpy.array([34, 45, 56, 67]) p.positions = numpy.arange(12).reshape((4,3)).T output_file = Mock() p.save_positions(output_file) assert_arrays_equal(output_file.write.call_args[0][0], numpy.array([[34, 0, 1, 2], [45, 3, 4, 5], [56, 6, 7, 8], [67, 9, 10, 11]])) assert_equal(output_file.write.call_args[0][1], {'population': p.label}) # arguably, the first column should contain indices, not ids. MockPopulation._simulator.state.mpi_rank = orig_rank
def test_generator_for_infinite_space_with_3D_distances(self): s = space.Space() f = lambda i: self.ABCD[:, i] g = lambda j: self.ABCD[:, j] self.assertArraysEqual( s.distance_generator(f, g)(0, numpy.arange(4)), numpy.array([0.0, sqrt(3), sqrt(3), sqrt(29)])) assert_arrays_equal( s.distance_generator(f, g)(numpy.arange(4), numpy.arange(4)), numpy.array([(0.0, sqrt(3), sqrt(3), sqrt(29)), (sqrt(3), 0.0, sqrt(12), sqrt(14)), (sqrt(3), sqrt(12), 0.0, sqrt(50.0)), (sqrt(29), sqrt(14), sqrt(50.0), 0.0)]))
def test_mask_local(): p1 = MockPopulation() p2 = MockPopulation() p3 = MockPopulation() a = Assembly(p1, p2, p3) assert_equal( a._mask_local.size, p1._mask_local.size + p2._mask_local.size + p3._mask_local.size) assert_equal(a._mask_local[0], p1._mask_local[0]) assert_equal(a._mask_local[-1], p3._mask_local[-1]) assert_arrays_equal( a._mask_local, numpy.append(p1._mask_local, (p2._mask_local, p3._mask_local))) assert_arrays_equal(a.local_cells, a.all_cells[a._mask_local])
def test_position_generator(): p = MockPopulation(11, MockStandardCell) assert_arrays_equal(p.position_generator(0), p.positions[:, 0]) assert_arrays_equal(p.position_generator(10), p.positions[:, 10]) assert_arrays_equal(p.position_generator(-1), p.positions[:, 10]) assert_arrays_equal(p.position_generator(-11), p.positions[:, 0]) assert_raises(IndexError, p.position_generator, 11) assert_raises(IndexError, p.position_generator, -12)
def test_position_generator(): p = MockPopulation(11, MockStandardCell) assert_arrays_equal(p.position_generator(0), p.positions[:,0]) assert_arrays_equal(p.position_generator(10), p.positions[:,10]) assert_arrays_equal(p.position_generator(-1), p.positions[:,10]) assert_arrays_equal(p.position_generator(-11), p.positions[:,0]) assert_raises(IndexError, p.position_generator, 11) assert_raises(IndexError, p.position_generator, -12)
def test_HDF5ArrayFile(): if files.have_hdf5: h5f = files.HDF5ArrayFile("tmp.h5", "w") data = [(0, 2.3), (1, 3.4), (2, 4.3)] metadata = {'a': 1, 'b': 9.99} h5f.write(data, metadata) h5f.close() h5f = files.HDF5ArrayFile("tmp.h5", "r") assert_equal(h5f.get_metadata(), metadata) assert_arrays_equal(numpy.array(h5f.read()).flatten(), numpy.array(data).flatten()) h5f.close() os.remove("tmp.h5")
def test_save_positions(): import os Assembly._simulator = MockSimulator Assembly._simulator.state.mpi_rank = 0 p1 = MockPopulation() p2 = MockPopulation() p1.all_cells = numpy.array([34, 45]) p2.all_cells = numpy.array([56, 67]) p1.positions = numpy.arange(0,6).reshape((2,3)).T p2.positions = numpy.arange(6,12).reshape((2,3)).T a = Assembly(p1, p2, label="test") output_file = Mock() a.save_positions(output_file) assert_arrays_equal(output_file.write.call_args[0][0], numpy.array([[34, 0, 1, 2], [45, 3, 4, 5], [56, 6, 7, 8], [67, 9, 10, 11]])) assert_equal(output_file.write.call_args[0][1], {'assembly': a.label}) # arguably, the first column should contain indices, not ids. del Assembly._simulator
def test_mix_procedural_and_oo(sim): # cf Issues #217, #234 fn_proc = "test_write_procedural.pkl" fn_oo = "test_write_oo.pkl" sim.setup(timestep=0.1, min_delay=0.1) cells = sim.Population(5, sim.IF_cond_exp(i_offset=0.2)) sim.record('v', cells, fn_proc) sim.run(10.0) cells.write_data(fn_oo) # explicitly write data sim.end() # implicitly write data using filename provided previously data_proc = get_io(fn_proc).read()[0] data_oo = get_io(fn_oo).read()[0] assert_arrays_equal(data_proc.segments[0].analogsignalarrays[0], data_oo.segments[0].analogsignalarrays[0]) os.remove(fn_proc) os.remove(fn_oo)
def test_tsodyks_markram_synapse(): import nest sim = pyNN.nest sim.setup() spike_source = sim.Population(1, sim.SpikeSourceArray(spike_times=numpy.arange(10, 100, 10))) neurons = sim.Population(5, sim.IF_cond_exp(e_rev_I=-75, tau_syn_I=numpy.arange(0.2, 0.7, 0.1))) synapse_type = sim.TsodyksMarkramSynapse(U=0.04, tau_rec=100.0, tau_facil=1000.0, weight=0.01, delay=0.5) connector = sim.AllToAllConnector() prj = sim.Projection(spike_source, neurons, connector, receptor_type='inhibitory', synapse_type=synapse_type) neurons.record('gsyn_inh') sim.run(100.0) connections = nest.GetConnections(prj._sources.tolist(), synapse_model=prj.nest_synapse_model) tau_psc = numpy.array(nest.GetStatus(connections, 'tau_psc')) assert_arrays_equal(tau_psc, numpy.arange(0.2, 0.7, 0.1))