def test_create_with_list_of_lists(self):
     schema = {'a': Sequence}
     ps = ParameterSpace({'a': [[1, 2, 3], [4, 5, 6]]},
                         schema,
                         shape=(2,))
     ps.evaluate()
     assert_array_equal(ps['a'], np.array([Sequence([1, 2, 3]), Sequence([4, 5, 6])], dtype=Sequence))  

 def test_create_with_array_of_sequences(self):
     schema = {"a": Sequence}
     ps = ParameterSpace(
         {"a": np.array([Sequence([1, 2, 3]), Sequence([4, 5, 6])], dtype=Sequence)}, schema, shape=(2,)
     )
     ps.evaluate()
     assert_array_equal(ps["a"], np.array([Sequence([1, 2, 3]), Sequence([4, 5, 6])], dtype=Sequence))

 def test_iteration(self):
     ps = ParameterSpace({'a': [2, 3, 5, 8, 13], 'b': 7, 'c': lambda i: 3*i+2}, shape=(5,))
     ps.evaluate(mask=[1, 3, 4])
     self.assertEqual(list(ps),
                      [{'a': 3, 'c': 5, 'b': 7},
                       {'a': 8, 'c': 11, 'b': 7},
                       {'a': 13, 'c': 14, 'b': 7}])

 def test_create_with_tuple(self):
     schema = {'a': Sequence}
     ps = ParameterSpace({'a': (1, 2, 3)},
                         schema,
                         shape=(2,))
     ps.evaluate()
     assert_array_equal(ps['a'], np.array([Sequence([1, 2, 3]), Sequence([1, 2, 3])], dtype=Sequence))

 def test_evaluate_with_mask_2D(self):
     ps2d = ParameterSpace(
         {"a": [[2, 3, 5, 8, 13], [21, 34, 55, 89, 144]], "b": 7, "c": lambda i, j: 3 * i - 2 * j}, shape=(2, 5)
     )
     ps2d.evaluate(mask=(slice(None), [1, 3, 4]))
     assert_array_equal(ps2d["a"], np.array([[3, 8, 13], [34, 89, 144]]))
     assert_array_equal(ps2d["c"], np.array([[-2, -6, -8], [1, -3, -5]]))

 def test_iteration_items(self):
     ps = ParameterSpace({'a': [2, 3, 5, 8, 13], 'b': 7, 'c': lambda i: 3*i+2}, shape=(5,))
     ps.evaluate(mask=[1, 3, 4])
     expected = {'a': np.array([3,  8, 13]),
                 'c': np.array([5, 11, 14]),
                 'b': np.array([7, 7, 7])}
     for key, value in ps.items():
         assert_array_equal(expected[key], value)

 def test_evaluate_with_mask(self):
     ps = ParameterSpace({'a': [2, 3, 5, 8, 13], 'b': 7, 'c': lambda i: 3*i+2}, shape=(5,))
     ps.evaluate(mask=[1, 3, 4])
     expected = {'a': np.array([ 3,  8, 13]),
                 'c': np.array([ 5, 11, 14]),
                 'b': np.array([7, 7, 7])}
     for key in expected:
         assert_array_equal(expected[key], ps[key])

 def __init__(self, **parameters):
     self._device   = nest.Create(self.nest_name)
     self.cell_list = []
     parameter_space = ParameterSpace(self.default_parameters,
                                      self.get_schema(),
                                      shape=(1,))
     parameter_space.update(**parameters)
     parameter_space = self.translate(parameter_space)
     self.set_native_parameters(parameter_space)

 def test_columnwise_iteration_single_column(self):
     ps2d = ParameterSpace(
         {"a": [[2, 3, 5, 8, 13], [21, 34, 55, 89, 144]], "b": 7, "c": lambda i, j: 3 * i - 2 * j}, shape=(2, 5)
     )
     ps2d.evaluate(mask=(slice(None), 3))
     expected = [{"a": np.array([8, 89]), "b": np.array([7, 7]), "c": np.array([-6, -3])}]
     actual = list(ps2d.columns())
     for x, y in zip(actual, expected):
         for key in y:
             assert_array_equal(x[key], y[key])

class NestCurrentSource(BaseCurrentSource):
    """Base class for a nest source of current to be injected into a neuron."""

    def __init__(self, **parameters):
        self._device = nest.Create(self.nest_name)
        self.cell_list = []
        self.parameter_space = ParameterSpace(self.default_parameters,
                                              self.get_schema(),
                                              shape=(1,))
        if parameters:
            self.parameter_space.update(**parameters)

        self.min_delay = state.min_delay
        self.dt = state.dt

    def inject_into(self, cells):
        for id in cells:
            if id.local and not id.celltype.injectable:
                raise TypeError("Can't inject current into a spike source.")
        if isinstance(cells, (Population, PopulationView, Assembly)):
            self.cell_list = [cell for cell in cells]
        else:
            self.cell_list = cells
        nest.Connect(self._device, self.cell_list, syn_spec={"delay": state.min_delay})

    def _delay_correction(self, value):
        """
        A change in a device requires a min_delay to take effect at the target
        """
        corrected = value - self.min_delay
        # set negative times to zero
        if isinstance(value, numpy.ndarray):
            corrected = numpy.where(corrected > 0, corrected, 0.0)
        else:
            corrected = max(corrected, 0.0)
        return corrected

    def record(self):
        self.i_multimeter = nest.Create('multimeter', params={'record_from': ['I'], 'interval': state.dt})
        nest.Connect(self.i_multimeter, self._device)

    def _get_data(self):
        events = nest.GetStatus(self.i_multimeter)[0]['events']
        # Similar to recording.py: NEST does not record values at
        # the zeroth time step, so we add them here.
        t_arr = numpy.insert(numpy.array(events['times']), 0, 0.0)
        i_arr = numpy.insert(numpy.array(events['I']/1000.0), 0, 0.0)
        # NEST and pyNN have different concepts of current initiation times
        # To keep this consistent across simulators, we will have current
        # initiating at the electrode at t_start and effect on cell at next dt
        # This requires padding min_delay equivalent period with 0's
        pad_length = int(self.min_delay/self.dt)
        i_arr = numpy.insert(i_arr[:-pad_length], 0, [0]*pad_length)
        return t_arr, i_arr

 def test_columnwise_iteration(self):
     ps2d = ParameterSpace({'a': [[2, 3, 5, 8, 13], [21, 34, 55, 89, 144]],
                            'b': 7,
                            'c': lambda i, j: 3*i-2*j}, shape=(2, 5))
     ps2d.evaluate(mask=(slice(None), [1, 3, 4]))
     expected = [{'a': np.array([3, 34]), 'b': np.array([7, 7]), 'c': np.array([-2, 1])},
                 {'a': np.array([8, 89]), 'b': np.array([7, 7]), 'c': np.array([-6, -3])},
                 {'a': np.array([13, 144]), 'b': np.array([7, 7]), 'c': np.array([-8, -5])}]
     for x, y in zip(ps2d.columns(), expected):
         for key in y:
             assert_array_equal(x[key], y[key])

class BaseModelType(object):
    """Base class for standard and native cell and synapse model classes."""
    default_parameters = {}
    default_initial_values = {}
    parameter_checks = {}

    def __init__(self, **parameters):
        """
        `parameters` should be a mapping object, e.g. a dict
        """
        self.parameter_space = ParameterSpace(self.default_parameters,
                                              self.get_schema(),
                                              shape=None)
        if parameters:
            self.parameter_space.update(**parameters)

    def __repr__(self):
        return "%s(<parameters>)" % self.__class__.__name__  # should really include the parameters explicitly, to be unambiguous

    @classmethod
    def has_parameter(cls, name):
        """Does this model have a parameter with the given name?"""
        return name in cls.default_parameters

    @classmethod
    def get_parameter_names(cls):
        """Return the names of the parameters of this model."""
        return list(cls.default_parameters.keys())

    def get_schema(self):
        """
        Returns the model schema: i.e. a mapping of parameter names to allowed
        parameter types.
        """
        return dict((name, type(value))
                    for name, value in self.default_parameters.items())

    def describe(self, template='modeltype_default.txt', engine='default'):
        """
        Returns a human-readable description of the cell or synapse type.

        The output may be customized by specifying a different template
        togther with an associated template engine (see ``pyNN.descriptions``).

        If template is None, then a dictionary containing the template context
        will be returned.
        """
        context = {
            "name": self.__class__.__name__,
            "default_parameters": self.default_parameters,
            "default_initial_values": self.default_initial_values,
            "parameters": self.parameter_space._parameters,  # should add a describe() method to ParameterSpace
        }
        return descriptions.render(engine, template, context)

 def __init__(self, **parameters):
     super(StandardCurrentSource, self).__init__(**parameters)
     self.cell_list = []
     self.indices = []
     simulator.state.current_sources.append(self)
     parameter_space = ParameterSpace(self.default_parameters,
                                      self.get_schema(),
                                      shape=(1,))
     parameter_space.update(**parameters)
     parameter_space = self.translate(parameter_space)
     self.set_native_parameters(parameter_space)

 def __init__(self, **parameters):
     self._devices    = []
     self.cell_list   = []
     self._amplitudes = None
     self._times      = None
     self._h_iclamps  = {}
     parameter_space = ParameterSpace(self.default_parameters,
                                      self.get_schema(),
                                      shape=(1,))
     parameter_space.update(**parameters)
     parameter_space = self.translate(parameter_space)
     self.set_native_parameters(parameter_space)

 def __init__(self, **parameters):
     super(StandardCurrentSource, self).__init__(**parameters)
     global current_sources
     self.cell_list = []
     self.indices   = []
     self.ind = len(current_sources) # Todo use self.indices instead...
     current_sources.append(self)
     parameter_space = ParameterSpace(self.default_parameters,
                                      self.get_schema(),
                                      shape=(1,))
     parameter_space.update(**parameters)
     parameter_space = self.translate(parameter_space)
     self.set_native_parameters(parameter_space)

 def __init__(self, **parameters):
     """
     `parameters` should be a mapping object, e.g. a dict
     """
     self.parameter_space = ParameterSpace(self.default_parameters,
                                           self.get_schema(),
                                           shape=None)
     if parameters:
         self.parameter_space.update(**parameters)

    def connect(self, projection):
        """Connect-up a Projection."""
        logger.debug("conn_list (original) = \n%s", self.conn_list)
        if numpy.any(self.conn_list[:, 0] >= projection.pre.size):
            raise errors.ConnectionError("source index out of range")
        if (self.conn_list.shape[1] < 3 or self.conn_list.shape[1] > 4 or 
            (self.conn_list.shape[1] == 3 and projection.synapse_type.has_parameter('delay'))):
            raise errors.ConnectionError("incompatible number of columns for connection list requires "
                                         "4 (3 for synapse type without delay)")
        # need to do some profiling, to figure out the best way to do this:
        #  - order of sorting/filtering by local
        #  - use numpy.unique, or just do in1d(self.conn_list)?
        idx  = numpy.argsort(self.conn_list[:, 1])
        targets = numpy.unique(self.conn_list[:, 1]).astype(numpy.int)
        local = numpy.in1d(targets,
                           numpy.arange(projection.post.size)[projection.post._mask_local],
                           assume_unique=True)
        local_targets = targets[local]
        self.conn_list = self.conn_list[idx]
        left  = numpy.searchsorted(self.conn_list[:, 1], local_targets, 'left')
        right = numpy.searchsorted(self.conn_list[:, 1], local_targets, 'right')
        logger.debug("idx = %s", idx)
        logger.debug("targets = %s", targets)
        logger.debug("local_targets = %s", local_targets)
        logger.debug("conn_list (sorted by target) = \n%s", self.conn_list)
        logger.debug("left = %s", left)
        logger.debug("right = %s", right)

        schema = projection.synapse_type.get_schema()
        for tgt, l, r in zip(local_targets, left, right):
            sources = self.conn_list[l:r, 0].astype(numpy.int)
            param_dict = {'weight': self.conn_list[l:r, 2] }
            if self.conn_list.shape[1] == 4:
                param_dict['delay'] = self.conn_list[l:r, 3]
            connection_parameters = ParameterSpace(param_dict,
                                                   schema=schema,
                                                   shape=(r-l,))
            if isinstance(projection.synapse_type, StandardSynapseType):
                connection_parameters = projection.synapse_type.translate(
                                            connection_parameters)
            connection_parameters.evaluate()
            projection._convergent_connect(sources, tgt, **connection_parameters)

    def __init__(self, **parameters):
        self._device = nest.Create(self.nest_name)
        self.cell_list = []
        self.parameter_space = ParameterSpace(self.default_parameters,
                                              self.get_schema(),
                                              shape=(1,))
        if parameters:
            self.parameter_space.update(**parameters)

        self.min_delay = state.min_delay
        self.dt = state.dt

 def test_evaluate(self):
     ps = ParameterSpace({'a': [2, 3, 5, 8], 'b': 7, 'c': lambda i: 3*i+2}, shape=(4,))
     self.assertIsInstance(ps['c'], LazyArray)
     ps.evaluate()
     assert_array_equal(ps['c'], np.array([ 2,  5,  8, 11]))

 def test_iteration(self):
     ps = ParameterSpace({"a": [2, 3, 5, 8, 13], "b": 7, "c": lambda i: 3 * i + 2}, shape=(5,))
     ps.evaluate(mask=[1, 3, 4])
     self.assertEqual(list(ps), [{"a": 3, "c": 5, "b": 7}, {"a": 8, "c": 11, "b": 7}, {"a": 13, "c": 14, "b": 7}])