Implemented WmAdams strategy (k44r from Axelrod's second)

Author: gaffney2010

axelrod/strategies/_strategies.py

@@ -9,7 +9,7 @@
     UnnamedStrategy, SteinAndRapoport, TidemanAndChieruzzi)
 from .axelrod_second import (
     Champion, Eatherley, Tester, Gladstein, Tranquilizer, MoreGrofman,
-    Kluepfel, Borufsen, Cave)
+    Kluepfel, Borufsen, Cave, WmAdams)
 from .backstabber import BackStabber, DoubleCrosser
 from .better_and_better import BetterAndBetter
 from .bush_mosteller import BushMosteller
@@ -274,6 +274,7 @@
     Winner21,
     WinShiftLoseStay,
     WinStayLoseShift,
+    WmAdams,
     WorseAndWorse,
     WorseAndWorse2,
     WorseAndWorse3,

axelrod/strategies/axelrod_second.py

@@ -771,3 +771,40 @@ def strategy(self, opponent: Player) -> Action:
                 return random_choice(0.5)
         else:
             return C
+
+class WmAdams(Player):
+    """
+    Strategy submitted to Axelrod's second tournament by William Adams (K49R),
+    and came in fifth in that tournament.
+
+    Count the number of opponent defects after their first move, call 
+    `c_defect`.  Defect if c_defect equals 4, 7, or 9.  If c_defect > 9,
+    then defect immediately after opponent defect with probability = 
+    (0.5)^(c_defect-1).  Otherwise cooperate.
+
+    Names:
+
+    - WmAdams: [Axelrod1980b]_
+    """
+
+    name = "WmAdams"
+    classifier = {
+        'memory_depth': float('inf'),
+        'stochastic': True,
+        'makes_use_of': set(),
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def strategy(self, opponent: Player) -> Action:
+        if len(self.history) <=1:
+            return C
+        did_d = np.vectorize(lambda action: float(action == D))
+        number_defects = np.sum(did_d(opponent.history[1:]))
+
+        if number_defects == 4 or number_defects == 7 or number_defects == 9: return D
+        if number_defects > 9 and opponent.history[-1] == D:
+            return random_choice((0.5)**(number_defects-9))
+        return C

axelrod/tests/strategies/test_axelrod_second.py

@@ -542,3 +542,39 @@ def test_strategy(self):
         actions += [(D, C), (C, D), (D, C)] # 17 D have come, so tit for tat for a while
         actions += [(D, D), (D, C)] * 100 # Random finally detected
         self.versus_test(axelrod.Alternator(), expected_actions=actions)
+
+class TestCave(TestPlayer):
+    name = "WmAdams"
+    player = axelrod.WmAdams
+    expected_classifier = {
+        'memory_depth': float('inf'),
+        'stochastic': True,
+        'makes_use_of': set(),
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def test_strategy(self):
+        actions = [(C, C)] * 100  # Cooperate forever
+        self.versus_test(axelrod.Cooperator(), expected_actions=actions)
+
+        # Will ignore the first four defects
+        opponent_actions = [D] * 4 + [C] * 100
+        defect_four = axelrod.MockPlayer(actions=opponent_actions)
+        actions = [(C, D)] * 4 + [(C, C)] * 100
+        self.versus_test(defect_four, expected_actions=actions)
+
+        actions = [(C, D), (C, D), (C, D), (C, D), (C, D), (D, D), (C, D), (C, D), (D, D), (C, D), (D, D), (C, D), (D, D), (D, D), (D, D), (D, D)]
+        self.versus_test(axelrod.Defector(), expected_actions=actions, seed=1)
+        actions = [(C, D), (C, D), (C, D), (C, D), (C, D), (D, D), (C, D), (C, D), (D, D), (C, D), (D, D), (D, D), (D, D), (C, D), (D, D), (D, D)]
+        self.versus_test(axelrod.Defector(), expected_actions=actions, seed=2)
+
+        # After responding to the 11th D (counted as 10 D), just start cooperating
+        opponent_actions = [D] * 11 + [C] * 100
+        changed_man = axelrod.MockPlayer(actions=opponent_actions)
+        actions = [(C, D), (C, D), (C, D), (C, D), (C, D), (D, D), (C, D), (C, D), (D, D), (C, D), (D, D), (C, C)]
+        actions += [(C,C)] * 99
+        self.versus_test(changed_man, expected_actions=actions, seed=1)
+

docs/reference/overview_of_strategies.rst

@@ -114,7 +114,7 @@ repository.
    "K41R_", "Herb Weiner", "Not Implemented"
    "K42R_", "Otto Borufsen", ":class:`Borufsen <axelrod.strategies.axelrod_second.Borufsen>`"
    "K43R_", "R D Anderson", "Not Implemented"
-   "K44R_", "William Adams", "Not Implemented"
+   "K44R_", "William Adams", ":class:`WmAdams <axelrod.strategies.axelrod_second.WmAdams>`"
    "K45R_", "Michael F McGurrin", "Not Implemented"
    "K46R_", "Graham J Eatherley", ":class:`Eatherley <axelrod.strategies.axelrod_second.Eatherley>`"
    "K47R_", "Richard Hufford", "Not Implemented"

docs/tutorials/advanced/classification_of_strategies.rst

@@ -47,7 +47,7 @@ strategies::
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    77
+    78
 
 Or, to find out how many strategies only use 1 turn worth of memory to
 make a decision::