Addition of Random TitForTat Strategy (#1136)

* Built rand_titfortat strategy in its own file, added rand_titfortat info to _strategies.py, rand.py, and all_strategies.rst.

* Added rand_titfortat info to all_strategies.rst.  Yet to build tests.

* Passing 12 of 13 tests.  Tests need more thought and work.

* Added tests for cooperator and p=0, and defector and p=1.  Fixed expected classifier stochastic in test file.

* Added tests for cooperator and p=0, and defector and p=1.  Fixed expected classifier stochastic in test file.

* Built test for no p input (dafault 0.5) against defector.

* Deleted bipoler from name.  Deleted commented out pdb line.  Refactored unnecessary else statement. Moved test and strategy into existing titfortat files.  Removed automodule for deleted rand_titfortat file.

* Deleted bipoler from name.  Deleted commented out pdb line.  Refactored unnecessary else statement. Moved test and strategy into existing titfortat files.  Removed automodule for deleted rand_titfortat file.

* Updated classification_of_strategies.rst, passing those doctests.

* Extended tests for four more turns.

* Deleting accidentally added return before __init__

* Modified strategy to begin with cooporation.

* Passing meta test

* Updated number of strategies in doctests.

* Fixed inline comment.

Author: ztaylor2

axelrod/strategies/_strategies.py

@@ -77,7 +77,8 @@
     TitForTat, TitFor2Tats, TwoTitsForTat, Bully, SneakyTitForTat,
     SuspiciousTitForTat, AntiTitForTat, HardTitForTat, HardTitFor2Tats,
     OmegaTFT, Gradual, ContriteTitForTat, AdaptiveTitForTat,
-    SpitefulTitForTat, SlowTitForTwoTats2, Alexei, EugineNier, DynamicTwoTitsForTat, NTitsForMTats, Michaelos)
+    SpitefulTitForTat, SlowTitForTwoTats2, Alexei, EugineNier,
+    DynamicTwoTitsForTat, NTitsForMTats, Michaelos, RandomTitForTat)
 from .verybad import VeryBad
 from .worse_and_worse import (WorseAndWorse, KnowledgeableWorseAndWorse,
                               WorseAndWorse2, WorseAndWorse3)
@@ -224,6 +225,7 @@
     Raider,
     Random,
     RandomHunter,
+    RandomTitForTat,
     RemorsefulProber,
     Resurrection,
     Retaliate,

axelrod/strategies/titfortat.py

@@ -790,3 +790,50 @@ def strategy(self, opponent: Player) -> Action:
                 return D
 
         return opponent.history[-1]
+
+
+class RandomTitForTat(Player):
+    """
+    A player starts by cooperating and then follows by copying its
+    opponent (tit for tat style).  From then on the player
+    will switch between copying its opponent and randomly
+    responding every other iteration.
+
+    Name:
+
+    - Random TitForTat: Original name by Zachary M. Taylor
+    """
+
+    # These are various properties for the strategy
+    name = 'Random Tit for Tat'
+    classifier = {
+        'memory_depth': 1,
+        'stochastic': True,
+        'makes_use_of': set(),
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+
+    def __init__(self, p: float=0.5) -> None:
+        """
+        Parameters
+        ----------
+        p, float
+            The probability to cooperate
+        """
+        super().__init__()
+        self.p = p
+        if p in [0, 1]:
+            self.classifier['stochastic'] = False
+
+
+    def strategy(self, opponent: Player) -> Action:
+        """This is the actual strategy"""
+        if not self.history:
+            return C
+        if len(opponent.history) % 2 == 0:
+            return random_choice(self.p)
+        return opponent.history[-1]

axelrod/tests/strategies/test_meta.py

@@ -294,7 +294,7 @@ class TestMetaMajorityMemoryOne(TestMetaPlayer):
     }
 
     def test_strategy(self):
-        actions = [(C, C), (C, D), (C, C), (C, D), (D, C)]
+        actions = [(C, C), (C, D), (D, C), (C, D), (D, C)]
         self.versus_test(opponent=axelrod.Alternator(),
                          expected_actions=actions)
 

axelrod/tests/strategies/test_titfortat.py

@@ -768,3 +768,60 @@ def test_strategy(self):
         self.versus_test(axelrod.Alternator(), expected_actions=actions,
                          attrs={"is_defector": True},
                          match_attributes={"length": float("inf")}, seed=1)
+
+
+class TestRandomTitForTat(TestPlayer):
+    """Tests for random tit for tat strategy."""
+
+    name = "Random Tit for Tat: 0.5"
+    player = axelrod.RandomTitForTat
+    expected_classifier = {
+        'memory_depth': 1,
+        'stochastic': True,
+        'makes_use_of': set(),
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def test_strategy(self):
+        """
+        Test that strategy reacts to opponent, and controlled by
+        probability every other iteration.  Also reacts randomly if no
+        probability input.
+        """
+        actions = [(C, C), (C, C), (C, C)]
+        self.versus_test(axelrod.Cooperator(), expected_actions=actions,
+                         init_kwargs={"p": 1})
+
+        actions = [(C, D), (D, D), (D, D)]
+        self.versus_test(axelrod.Defector(), expected_actions=actions,
+                         init_kwargs={"p": 0})
+
+        actions = [(C, C), (C, C), (D, C), (C, C)]
+        self.versus_test(axelrod.Cooperator(), expected_actions=actions,
+                         init_kwargs={"p": 0})
+
+        actions = [(C, D), (D, D), (C, D), (D, D)]
+        self.versus_test(axelrod.Defector(), expected_actions=actions,
+                         init_kwargs={"p": 1})
+
+        actions = [(C, C), (C, C), (D, C), (C, C), (D, C), (C, C)]
+        self.versus_test(axelrod.Cooperator(), expected_actions=actions,
+                         seed=2)
+
+        actions = [(C, D), (D, D), (C, D), (D, D), (D, D), (D, D)]
+        self.versus_test(axelrod.Defector(), expected_actions=actions,
+                         seed=1)
+
+    def test_deterministic_classification(self):
+        """
+        Test classification when probability input is 0 or 1.
+        Should change stochastic to false, because actions are no
+        longer random.
+
+        """
+        for p in [0, 1]:
+            player = axelrod.RandomTitForTat(p=p)
+            self.assertFalse(player.classifier['stochastic'])

docs/tutorials/advanced/classification_of_strategies.rst

@@ -47,7 +47,7 @@ strategies::
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    75
+    76
 
 Or, to find out how many strategies only use 1 turn worth of memory to
 make a decision::
@@ -57,7 +57,7 @@ make a decision::
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    31
+    32
 
 Multiple filters can be specified within the filterset dictionary. To specify a
 range of memory_depth values, we can use the 'min_memory_depth' and
@@ -69,7 +69,7 @@ range of memory_depth values, we can use the 'min_memory_depth' and
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    55
+    56
 
 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