New mutation method for Moran processes

Author: marcharper

axelrod/graph.py

@@ -66,7 +66,9 @@ def _add_edges(self, edges):
             self._add_edge(*edge)
 
     def add_loops(self):
-        """Add all loops to edges."""
+        """
+        Add all loops to edges
+        """
         self._add_edges((x, x) for x in self.vertices)
 
     @property
@@ -120,25 +122,42 @@ def cycle(length, directed=False):
     return Graph(edges=edges, directed=directed)
 
 
-def complete_graph(size, loops=True):
-    """ Produces a complete graph of specificies size.
-
-    See https://en.wikipedia.org/wiki/Complete_graph for details.
+def complete_graph(size, loops=True, directed=False):
+    """
+    Produces a complete graph of size `length`.
+    https://en.wikipedia.org/wiki/Complete_graph
 
     Parameters
     ----------
     size: int
         Number of vertices in the cycle
     loops: bool, True
-        Should the graph contain cycles?
+        attach loops at each node?
+    directed: bool, False
+        Is the graph directed?
 
     Returns
     -------
     a Graph object for the complete graph
     """
     edges = [(i, j) for i in range(size) for j in range(i + 1, size)]
-    graph = Graph(edges=edges, directed=False)
+    graph = Graph(directed=directed, edges=edges)
+    if loops:
+        graph.add_loops()
+    return graph
+
 
+def attached_complete_graphs(length, loops=True, directed=False):
+    edges = []
+    # Two complete graphs
+    for cluster in range(2):
+        for i in range(length):
+            for j in range(i + 1, length):
+                edges.append(("{}:{}".format(cluster, i),
+                              "{}:{}".format(cluster, j)))
+    # Attach at one node
+    edges.append(("0:0", "1:0"))
+    graph = Graph(directed=directed, edges=edges)
     if loops:
         graph.add_loops()
 

axelrod/moran.py

@@ -56,6 +56,7 @@ def __init__(
         interaction_graph: Graph = None,
         reproduction_graph: Graph = None,
         fitness_transformation: Callable = None,
+        mutation_method="transition"
     ) -> None:
         """
         An agent based Moran process class. In each round, each player plays a
@@ -120,6 +121,11 @@ def __init__(
         self.score_history = []  # type: List
         self.winning_strategy_name = None  # type: Optional[str]
         self.mutation_rate = mutation_rate
+        m = mutation_method.lower()
+        if m in ["atomic", "transition"]:
+            self.mutation_method = m
+        else:
+            raise ValueError("Invalid mutation method {}".format(mutation_method))
         assert (mutation_rate >= 0) and (mutation_rate <= 1)
         assert (noise >= 0) and (noise <= 1)
         mode = mode.lower()
@@ -176,6 +182,12 @@ def mutate(self, index: int) -> Player:
         index:
             The index of the player to be mutated
         """
+
+        if self.mutation_method == "atomic":
+            mutant = self.players[index].clone()
+            mutant.mutate()
+            return mutant
+
         # Choose another strategy at random from the initial population
         r = random.random()
         if r < self.mutation_rate: