Merge pull request #1 from Axelrod-Python/MariosZoulias-SteinRap-vk

Correct strategy and add relevant tests.

Author: MariosZoulias

appveyor.yml

@@ -1,11 +1,18 @@
 environment:
   matrix:
-    - PYTHON: "C:\\Python35"
-    - PYTHON: "C:\\Python36"
+    - PYTHON_VERSION: "3.5"
+      MINICONDA: "C:\\Miniconda35"
+    - PYTHON_VERSION: "3.6"
+      MINICONDA: "C:\\Miniconda36"
 install:
-  - "%PYTHON%\\python.exe -m pip install -r requirements.txt"
+  - "set PATH=%MINICONDA%;%MINICONDA%\\Scripts;%PATH%"
+  - "conda config --set always_yes yes --set changeps1 no"
+  - "conda update -q conda"
+  - "conda create -q -n test-environment python=%PYTHON_VERSION% scipy>=0.19.0 numpy>=1.9.2"
+  - "activate test-environment"
+  - "python -m pip install -r requirements.txt"
 build: off
 test_script:
-  - "%PYTHON%\\python.exe -m unittest discover"
-  - "%PYTHON%\\python.exe doctests.py"
-  - "%PYTHON%\\python.exe setup.py install"
+  - "python -m unittest discover"
+  - "python doctests.py"
+  - "python setup.py install"

axelrod/player.py

@@ -241,7 +241,8 @@ def clone(self):
         return new_player
 
     def reset(self):
-        """Resets history.
+        """
+        Resets history.
         When creating strategies that create new attributes then this method
         should be re-written (in the inherited class) and should not only reset
         history but also rest all other attributes.

axelrod/strategies/axelrod_first.py

@@ -494,22 +494,23 @@ def strategy(opponent: Player) -> Action:
 class SteinAndRapoport(Player):
     """
     A player who plays according to statistic methods.
-    Begins by playing C for the first four (4) rounds , then it plays
+    Begins by playing C for the first four (4) rounds, then it plays
     tit for tat and at the last 2 round it Defects. Every 15 turns it
-    run a chi-squared test to check whether the opponent behaves randomly
-    or not . In case the opponent behaves randomly then Stein_and_Rapoport
-    Defects untill the next 15 round (where we check again), otherwise he
+    runs a chi-squared test to check whether the opponent behaves randomly
+    or not. In case the opponent behaves randomly then Stein and Rapoport
+    Defects until the next 15 round (where we check again), otherwise it
     still plays TitForTat.0
 
     Names:
+
     - SteinAndRapoport [Axelrod1980]_
     """
 
     name = 'Stein and Rapoport'
     classifier = {
         'memory_depth': 15,
         'stochastic': False,
-        'makes_use_of': set(),
+        'makes_use_of': {"length"},
         'long_run_time': False,
         'inspects_source': False,
         'manipulates_source': False,
@@ -526,34 +527,29 @@ def __init__(self, alpha: float=0.05) -> None:
         """
         super().__init__()
         self.alpha = alpha
-        if (self.alpha > 1) or (self.alpha < 0):
-            self.alpha = 0.05
+        self.opponent_is_random = None
 
-    def strategy(self , opponent: Player , chi_tests = [0]) -> Action:
+    def strategy(self , opponent: Player) -> Action:
         round_number = len(self.history) + 1
 
         # First 4 moves
         if round_number < 5:
             return C
+        # For first 15 rounds tit for tat as we do not know opponents strategy
+        elif round_number < 15:
+            return opponent.history[-1]
 
-        # For first 15 rounds tit for tat as we dont know opponents strategy
-        if round_number < 16:
-            if opponent.history[-1] == 'D':
-                return D
-            else :
-                return C
-
-        if len(self.history) % 15 == 0:
-            if chisquare([opponent.cooperations, opponent.defections]).pvalue >= self.alpha:
-                chi_tests.append(1)
-            else:
-                chi_tests.append(0)
+        if round_number % 15 == 0:
+            p_value = chisquare([opponent.cooperations,
+                                 opponent.defections]).pvalue
+            self.opponent_is_random = p_value >= self.alpha
 
-        if chi_tests[-1] == 1:
+        if self.opponent_is_random:
             # Defect if opponent plays randomly
             return D
-        else : # TitForTatat if opponent plays not randomly
-            if opponent.history[-1] == 'D':
-                return D
-            else:
-                return C
+        else: # TitForTatat if opponent plays not randomly
+            return opponent.history[-1]
+
+    def reset(self):
+        super().reset()
+        self.random_opponent = None

axelrod/tests/strategies/test_axelrod_first.py

@@ -391,37 +391,76 @@ def test_strategy(self):
 
 class SteinAndRapoport(TestPlayer):
 
-    name = "SteinAndRapoport"
+    name = "Stein and Rapoport: 0.05: ('D', 'D')"
     player = axelrod.SteinAndRapoport
     expected_classifier = {
         'memory_depth': 15,
         'long_run_time': False,
         'stochastic': False,
-        'makes_use_of': set(),
+        'makes_use_of': {'length'},
         'inspects_source': False,
         'manipulates_source': False,
         'manipulates_state': False
     }
 
+    def test_init(self):
+        player = self.player()
+        self.assertEqual(player.alpha, 0.05)
+        self.assertIsNone(player.opponent_is_random)
+
+        player = self.player(alpha=.5)
+        self.assertEqual(player.alpha, 0.5)
+        self.assertIsNone(player.opponent_is_random)
+
     def test_strategy(self):
         self.first_play_test(C)
 
         # Our Player (SteinAndRapoport) vs Cooperator
         # After 15th round (pvalue < alpha) still plays titfortat
+        # Note it always defects on the last two rounds
         opponent = axelrod.Cooperator()
         actions = [(C, C)] * 17 + [(D, C)] * 2
-        self.versus_test(opponent, expected_actions=actions)
+        self.versus_test(opponent, expected_actions=actions,
+                         attrs={"opponent_is_random": False})
+
+        actions = actions[:-2] + [(C, C)] * 2
+        self.versus_test(opponent, expected_actions=actions[:-2],
+                         match_attributes={"length": -1},
+                         attrs={"opponent_is_random": False})
 
         # Our Player (SteinAndRapoport) vs Defector
         # After 15th round (pvalue < alpha) still plays titfortat
-        opponent = axelrod.Cooperator()
+        opponent = axelrod.Defector()
         actions = [(C, D)] * 4 + [(D, D)] * 15
-        self.versus_test(opponent, expected_actions=actions)
+        self.versus_test(opponent, expected_actions=actions,
+                         attrs={"opponent_is_random": False})
 
         # Our Player (SteinAndRapoport) vs Alternator
         # After 15th round (pvalue > alpha) starts defect
         opponent = axelrod.Alternator()
-        actions = [(C, C), (C, D), (C, C), (C, D), (D, C), (C, D), (D, C),
-                  (C, D), (D, C), (C, D), (D, C), (C, D),(D, C), (C, D),
-                  (D, C), (D, D), (D, C), (D, D), (D, C)]
-        self.versus_test(opponent, expected_actions=actions)
+        actions = [(C, C), (C, D), (C, C), (C, D)]
+
+        # On 15th round carry out chisquare test
+        actions += [(D, C), (C, D)] * 5 + [(D, C)]
+
+        # Defect throughout
+        actions += [(D, D), (D, C), (D, D), (D, C)]
+
+        self.versus_test(opponent, expected_actions=actions,
+                         attrs={"opponent_is_random": True})
+
+        # The test is carried out again every 15 rounds.
+        # If the strategy alternates for the first 12 rounds and then cooperates
+        # it is no longer recognised as random
+        opponent = axelrod.MockPlayer([C, D] * 6 + [C] * 50)
+
+        actions = [(C, C), (C, D), (C, C), (C, D)]
+        # On 15th round carry out chisquare test
+        actions += [(D, C), (C, D)] * 4 + [(D, C), (C, C), (D, C)]
+        # Defect throughout and carry out chisquare test on round 30
+        # Opponent is no longer recognised as random, revert to TfT
+        actions += [(D, C)] * 14 + [(C, C)]
+        self.versus_test(opponent, expected_actions=actions,
+                         match_attributes={"length": -1},
+                         attrs={"opponent_is_random": False})
+

docs/tutorials/advanced/classification_of_strategies.rst

@@ -80,7 +80,7 @@ length of each match of the tournament::
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    26
+    27
 
 Note that in the filterset dictionary, the value for the 'makes_use_of' key
 must be a list. Here is how we might identify the number of strategies that use