Adding MutateTransform

- Can pass either a prob and single player OR a distribution and list of
  players.
- Tests for simple deterministic cases
- Docs

Author: drvinceknight

axelrod/strategy_transformers.py

@@ -9,6 +9,7 @@
 import inspect
 import random
 from types import FunctionType
+from numpy.random import choice
 
 from .actions import Actions, flip_action
 from .random_ import random_choice
@@ -239,6 +240,31 @@ def apology_wrapper(player, opponent, action, myseq, opseq):
 ApologyTransformer = StrategyTransformerFactory(apology_wrapper,
                                                 name_prefix="Apologizing")
 
+
+def mutate_wrapper(player, opponent, action, probability, m_player):
+    """"""
+
+    # If a single probability, player is passed
+    if type(probability) in [float, int]:
+        m_player = [m_player]
+        probability = [probability]
+
+    # If a probability distribution, players is passed
+    if type(probability) == type(m_player) is list:
+        mutate_prob = sum(probability)  # Prob of mutation
+        if mutate_prob > 0:
+            # Distribution of choice of mutation:
+            normalised_prob = [prob / float(mutate_prob)
+                               for prob in probability]
+            if random.random() < mutate_prob:
+                p = choice(m_player, p=normalised_prob)()
+                p.history = player.history
+                return p.strategy(opponent)
+
+    return action
+
+MutateTransformer = StrategyTransformerFactory(mutate_wrapper, name_prefix="Mutated")
+
 # Strategy wrappers as classes
 
 class RetaliationWrapper(object):
@@ -260,6 +286,7 @@ def __call__(self, player, opponent, action, retaliations):
 RetaliationTransformer = StrategyTransformerFactory(
     RetaliationWrapper(), name_prefix="Retaliating")
 
+
 class RetaliationUntilApologyWrapper(object):
     """Enforces the TFT rule that the opponent pay back a defection with a
     cooperation for the player to stop defecting."""

axelrod/tests/unit/test_strategy_transformers.py

@@ -212,6 +212,53 @@ def test_apology(self):
             p1.play(p2)
         self.assertEqual(p1.history, [D, D, C, D, D, C])
 
+    def test_mutate(self):
+        """Tests the MutateTransformer."""
+        probability = 1
+        MD = MutateTransformer(probability, axelrod.Cooperator)(axelrod.Defector)
+
+        p1 = MD()
+        p2 = axelrod.Cooperator()
+        for _ in range(5):
+            p1.play(p2)
+        self.assertEqual(p1.history, [C, C, C, C, C])
+
+        probability = 0
+        MD = MutateTransformer(probability, axelrod.Cooperator)(axelrod.Defector)
+
+        p1 = MD()
+        p2 = axelrod.Cooperator()
+        for _ in range(5):
+            p1.play(p2)
+        self.assertEqual(p1.history, [D, D, D, D, D])
+
+        # Decorating with list and distribution
+
+        # Decorate a cooperator putting all weight on other strategies that are
+        # 'nice'
+        probability = [.3, .2, 0]
+        strategies = [axelrod.TitForTat, axelrod.Grudger, axelrod.Defector]
+        MD = MutateTransformer(probability, strategies)(axelrod.Cooperator)
+
+        p1 = MD()
+        # Against a cooperator we see that we only cooperate
+        p2 = axelrod.Cooperator()
+        for _ in range(5):
+            p1.play(p2)
+        self.assertEqual(p1.history, [C, C, C, C, C])
+
+        # Decorate a cooperator putting all weight on Defector
+        probability = [0, 0, 1]
+        strategies = [axelrod.TitForTat, axelrod.Grudger, axelrod.Defector]
+        MD = MutateTransformer(probability, strategies)(axelrod.Cooperator)
+
+        p1 = MD()
+        # Against a cooperator we see that we only cooperate
+        p2 = axelrod.Cooperator()
+        for _ in range(5):
+            p1.play(p2)
+        self.assertEqual(p1.history, [D, D, D, D, D])
+
     def test_deadlock(self):
         """Test the DeadlockBreakingTransformer."""
         # We can induce a deadlock by alterting TFT to defect first