Added some of the strategies listed in Ashlock2009.

axelrod/strategies/_strategies.py

@@ -75,6 +75,8 @@
     Pun1,
     Raider,
     Ripoff,
+    UsuallyCooperates,
+    UsuallyDefects,
     SolutionB1,
     SolutionB5,
     Thumper,
@@ -419,6 +421,8 @@
     TrickyLevelPunisher,
     Tullock,
     TwoTitsForTat,
+    UsuallyCooperates,
+    UsuallyDefects,
     VeryBad,
     Weiner,
     White,

axelrod/strategies/finite_state_machines.py

@@ -325,6 +325,68 @@ def __init__(self) -> None:
         super().__init__(transitions=transitions, initial_state=1, initial_action=D)
 
 
+class UsuallyCooperates(FSMPlayer):
+    """
+    This strategy cooperates except after a C following a D.
+
+    Names:
+
+    - Usually Cooperates (UC): [Ashlock2009]_
+    """
+
+    name = "UsuallyCooperates"
+    classifier = {
+        "memory_depth": 2,
+        "stochastic": False,
+        "makes_use_of": set(),
+        "long_run_time": False,
+        "inspects_source": False,
+        "manipulates_source": False,
+        "manipulates_state": False,
+    }
+
+    def __init__(self) -> None:
+        transitions = (
+            (1, C, 1, C),
+            (1, D, 2, C),
+            (2, C, 1, D),
+            (2, D, 1, C),
+        )
+
+        super().__init__(transitions=transitions, initial_state=1, initial_action=C)
+
+
+class UsuallyDefects(FSMPlayer):
+    """
+    This strategy defects except after a D following a C.
+
+    Names:
+
+    - Usually Defects (UD): [Ashlock2009]_
+    """
+
+    name = "UsuallyDefects"
+    classifier = {
+        "memory_depth": 2,
+        "stochastic": False,
+        "makes_use_of": set(),
+        "long_run_time": False,
+        "inspects_source": False,
+        "manipulates_source": False,
+        "manipulates_state": False,
+    }
+
+    def __init__(self) -> None:
+        transitions = (
+            (1, C, 2, D),
+            (1, D, 1, D),
+            (2, C, 1, D),
+            (2, D, 1, C),
+        )
+
+        super().__init__(transitions=transitions, initial_state=1, initial_action=D)
+
+
 class SolutionB1(FSMPlayer):
     """
     FSM player described in http://DOI.org/10.1109/TCIAIG.2014.2326012.

axelrod/strategies/grudger.py

@@ -18,6 +18,7 @@ class Grudger(Player):
     - Grim: [Berg2015]_
     - Grim Trigger: [Banks1990]_
     - Spite: [Beaufils1997]_
+    - Vengeful: [Ashlock2009]_
     """
 
     name = "Grudger"

axelrod/strategies/titfortat.py

@@ -225,6 +225,7 @@ class AntiTitForTat(Player):
     Names:
 
     - Anti Tit For Tat: [Hilbe2013]_
+    - Psycho (PSYC): [Ashlock2009]_
     """
 
     name = "Anti Tit For Tat"

axelrod/tests/strategies/test_finite_state_machines.py

@@ -512,6 +512,72 @@ def test_strategy(self):
         self.transitions_test(state_and_actions)
 
 
+class TestUsuallyCooperates(TestFSMPlayer):
+    name = "UsuallyCooperates"
+    player = axelrod.UsuallyCooperates
+    expected_classifier = {
+        "memory_depth": 2,
+        "stochastic": False,
+        "makes_use_of": set(),
+        "long_run_time": False,
+        "inspects_source": False,
+        "manipulates_source": False,
+        "manipulates_state": False,
+    }
+    """
+    transitions = (
+            (1, C, 1, C),
+            (1, D, 2, C),
+            (2, C, 1, D),
+            (2, D, 1, C)
+        )
+    """
+
+    def test_strategy(self):
+        # Never leaves state 1 if C
+        state_and_actions = [(1, C)] * 10
+        self.transitions_test(state_and_actions)
+        # Visits state 2, but then comes back
+        state_and_actions = [(1, D), (2, D)]
+        self.transitions_test(state_and_actions)
+        # Visits state 2, but then comes back
+        state_and_actions = [(1, D), (2, C)]
+        self.transitions_test(state_and_actions)
+
+
+class TestUsuallyDefects(TestFSMPlayer):
+    name = "UsuallyDefects"
+    player = axelrod.UsuallyDefects
+    expected_classifier = {
+        "memory_depth": 2,
+        "stochastic": False,
+        "makes_use_of": set(),
+        "long_run_time": False,
+        "inspects_source": False,
+        "manipulates_source": False,
+        "manipulates_state": False,
+    }
+    """
+    transitions = (
+            (1, C, 2, D),
+            (1, D, 1, D),
+            (2, C, 1, D),
+            (2, D, 1, C)
+        )
+    """
+
+    def test_strategy(self):
+        # Never leaves state 1 if C
+        state_and_actions = [(1, D)] * 10
+        self.transitions_test(state_and_actions)
+        # Visits state 2, but then comes back
+        state_and_actions = [(1, C), (2, D)]
+        self.transitions_test(state_and_actions)
+        # Visits state 2, but then comes back
+        state_and_actions = [(1, C), (2, C)]
+        self.transitions_test(state_and_actions)
+
+
 class TestSolutionB1(TestFSMPlayer):
 
     name = "SolutionB1"

docs/tutorials/advanced/classification_of_strategies.rst

@@ -69,7 +69,7 @@ range of memory_depth values, we can use the 'min_memory_depth' and
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    59
+    61
 
 We can also identify strategies that make use of particular properties of the
 tournament. For example, here is the number of strategies that  make use of the