Merge pull request #1151 from gaffney2010/master

Implement Getzler, K35R from Axelrod's second.

Author: drvinceknight

axelrod/strategies/_strategies.py

@@ -10,7 +10,7 @@
 from .axelrod_second import (
     Champion, Eatherley, Tester, Gladstein, Tranquilizer, MoreGrofman,
     Kluepfel, Borufsen, Cave, WmAdams, GraaskampKatzen, Weiner, Harrington,
-    MoreTidemanAndChieruzzi)
+    MoreTidemanAndChieruzzi, Getzler)
 from .backstabber import BackStabber, DoubleCrosser
 from .better_and_better import BetterAndBetter
 from .bush_mosteller import BushMosteller
@@ -164,6 +164,7 @@
     GellerCooperator,
     GellerDefector,
     GeneralSoftGrudger,
+    Getzler,
     Gladstein,
     GoByMajority,
     GoByMajority10,

axelrod/strategies/axelrod_second.py

@@ -1416,3 +1416,41 @@ def strategy(self, opponent: Player) -> Action:
                 return C  # First cooperation
 
         return D
+
+
+class Getzler(Player):
+    """
+    Strategy submitted to Axelrod's second tournament by Abraham Getzler (K35R)
+    and came in tenth in that tournament.
+
+    Strategy Defects with probability `flack`, where `flack` is calculated as
+    the sum over opponent Defections of 0.5 ^ (turns ago Defection happened).
+
+    Names:
+
+    - Getzler: [Axelrod1980b]_
+    """
+
+    name = 'Getzler'
+    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 __init__(self) -> None:
+        super().__init__()
+        self.flack = 0.0  # The relative untrustworthiness of opponent
+
+    def strategy(self, opponent: Player) -> Action:
+        if not opponent.history:
+            return C
+
+        self.flack += 1 if opponent.history[-1] == D else 0
+        self.flack *= 0.5  # Defections have half-life of one round
+
+        return random_choice(1.0 - self.flack)

axelrod/tests/strategies/test_axelrod_second.py

@@ -906,3 +906,27 @@ def test_strategy(self):
         actions += [(D, D)] # No Defection here means no Fresh Start.
         self.versus_test(C5D5_Player, expected_actions=actions)
 
+
+class TestGetzler(TestPlayer):
+    name = 'Getzler'
+    player = axelrod.Getzler
+    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
+        self.versus_test(axelrod.Cooperator(), expected_actions=actions)
+
+        actions = [(C, D), (C, D), (D, D), (D, D), (D, D)]
+        self.versus_test(axelrod.Defector(), expected_actions=actions, seed=1, attrs={"flack": 15./16.})
+
+        actions = [(C, C), (C, D), (C, C), (C, D), (D, C), (C, D)]
+        self.versus_test(axelrod.Alternator(), expected_actions=actions, seed=4, attrs={"flack": 5./16.})
+

docs/tutorials/advanced/classification_of_strategies.rst

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