Implement __eq__ and __ne__ for PopulationView

Should fix #622.

Author: Andrew Davison

pyNN/common/populations.py

@@ -266,7 +266,7 @@ def get(self, parameter_names, gather=False, simplify=True):
         """
         Get the values of the given parameters for every local cell in the
         population, or, if gather=True, for all cells in the population.
-        
+
         Values will be expressed in the standard PyNN units (i.e. millivolts,
         nanoamps, milliseconds, microsiemens, nanofarads, event per second).
         """
@@ -429,7 +429,7 @@ def record(self, variables, to_file=None, sampling_interval=None):
 
         If specified, `to_file` should be either a filename or a Neo IO instance and `write_data()`
         will be automatically called when `end()` is called.
-        
+
         `sampling_interval` should be a value in milliseconds, and an integer
         multiple of the simulation timestep.
         """
@@ -479,7 +479,7 @@ def write_data(self, io, variables='all', gather=True, clear=False, annotations=
         simulated on that node.
 
         If `clear` is True, recorded data will be deleted from the `Population`.
-        
+
         `annotations` should be a dict containing simple data types such as
         numbers and strings. The contents will be written into the output data
         file as metadata.
@@ -533,7 +533,7 @@ def get_gsyn(self, gather=True, compatible_output=True):
     def get_spike_counts(self, gather=True):
         """
         Returns a dict containing the number of spikes for each neuron.
-        
+
         The dict keys are neuron IDs, not indices.
         """
         # arguably, we should use indices
@@ -915,6 +915,25 @@ def index_in_grandparent(self, indices):
         else:
             return indices_in_parent
 
+    def __eq__(self, other):
+        """
+        Determine whether two views are the same.
+        """
+        return not self.__ne__(other)
+
+    def __ne__(self, other):
+        """
+        Determine whether two views are different.
+        """
+        # We can't use the self.mask, as different masks can select the same cells
+        # (e.g. slices vs arrays), therefore we have to use self.all_cells
+        if isinstance(other, PopulationView):
+            return self.parent != other.parent or not numpy.array_equal(self.all_cells, other.all_cells)
+        elif isinstance(other, Population):
+            return self.parent != other or not numpy.array_equal(self.all_cells, other.all_cells)
+        else:
+            return True
+
     def describe(self, template='populationview_default.txt', engine='default'):
         """
         Returns a human-readable description of the population view.

pyNN/connectors.py

@@ -191,7 +191,7 @@ def _standard_connect(self, projection, connection_map_generator, distance_map=N
             # `source_mask` - boolean numpy array, indicating which of the pre-synaptic neurons should be connected to,
             #                 or a single boolean, meaning connect to all/none of the pre-synaptic neurons
             #                 It can also be an array of addresses
-            _proceed = False 
+            _proceed = False
             if source_mask is True or source_mask.any():
                 _proceed = True
             elif type(source_mask) == numpy.ndarray:
@@ -206,7 +206,7 @@ def _standard_connect(self, projection, connection_map_generator, distance_map=N
                     source_mask = numpy.arange(projection.pre.size, dtype=int)
                 elif source_mask.dtype == bool:
                     source_mask = source_mask.nonzero()[0]
-            
+
                 # Evaluate the lazy arrays containing the synaptic parameters
                 connection_parameters = {}
                 for name, map in parameter_space.items():
@@ -275,6 +275,10 @@ def __init__(self, allow_self_connections=True, safe=True,
     def connect(self, projection):
         if not self.allow_self_connections and projection.pre == projection.post:
             connection_map = LazyArray(lambda i, j: i != j, shape=projection.shape)
+            # there is a more complicated scenario, where we connect two different
+            # views of the same population. In this case, something other than i != j
+            # will be needed. It should at least be documented that we currently
+            # don't handle this situation.
         elif self.allow_self_connections == 'NoMutual' and projection.pre == projection.post:
             connection_map = LazyArray(lambda i, j: i > j, shape=projection.shape)
         else:
@@ -555,7 +559,7 @@ class FromFileConnector(FromListConnector):
 
                 # columns = ["i", "j", "weight", "delay", "U", "tau_rec"]
 
-            Note that the header requires `#` at the beginning of the line.            
+            Note that the header requires `#` at the beginning of the line.
 
         `distributed`:
             if this is True, then each node will read connections from a file
@@ -1011,7 +1015,7 @@ def connect(self, projection):
 
         # Assume that targets are equally distributed over processes
         targets_per_process = int(len(projection.post) / num_processes)
-            
+
         # Calculate the number of synapses on each process
         bino = RandomDistribution('binomial',
                                   [self.n, targets_per_process / len(projection.post)],
@@ -1027,7 +1031,7 @@ def connect(self, projection):
             sum_dist += targets_per_process
             sum_partitions += num_conns_on_vp[k]
 
-        # Draw random sources and targets 
+        # Draw random sources and targets
         connections = [[] for i in range(projection.post.size)]
         possible_targets = numpy.arange(projection.post.size)[projection.post._mask_local]
         for i in range(num_conns_on_vp[rank]):