SteinAndRapoport Strategy

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/_strategies.py

@@ -6,7 +6,7 @@
 from .averagecopier import AverageCopier, NiceAverageCopier
 from .axelrod_first import (
     Davis, RevisedDowning, Feld, Grofman, Nydegger, Joss, Shubik, Tullock,
-    UnnamedStrategy)
+    UnnamedStrategy, SteinAndRapoport)
 from .axelrod_second import Champion, Eatherley, Tester
 from .backstabber import BackStabber, DoubleCrosser
 from .better_and_better import BetterAndBetter
@@ -232,6 +232,7 @@
     SolutionB5,
     SpitefulTitForTat,
     Stalker,
+    SteinAndRapoport,
     StochasticCooperator,
     StochasticWSLS,
     SuspiciousTitForTat,

axelrod/strategies/axelrod_first.py

@@ -8,6 +8,8 @@
 from axelrod.player import Player
 from axelrod.random_ import random_choice
 from.memoryone import MemoryOnePlayer
+from axelrod.strategy_transformers import FinalTransformer
+from scipy.stats import chisquare
 
 from typing import List, Dict, Tuple
 
@@ -487,3 +489,67 @@ class UnnamedStrategy(Player):
     def strategy(opponent: Player) -> Action:
         r = random.uniform(3, 7) / 10
         return random_choice(r)
+
+@FinalTransformer((D, D), name_prefix=None)
+class SteinAndRapoport(Player):
+    """
+    A player who plays according to statistic methods.
+    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
+    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': {"length"},
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def __init__(self, alpha: float=0.05) -> None:
+        """
+        Parameters
+        ----------
+        alpha, float
+            The significant level of pvalue from chi-squared test
+            0.05 by default according to literature
+        """
+        super().__init__()
+        self.alpha = alpha
+        self.opponent_is_random = None
+
+    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]
+
+        if round_number % 15 == 0:
+            p_value = chisquare([opponent.cooperations,
+                                 opponent.defections]).pvalue
+            self.opponent_is_random = p_value >= self.alpha
+
+        if self.opponent_is_random:
+            # Defect if opponent plays randomly
+            return D
+        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

@@ -387,3 +387,80 @@ def test_strategy(self):
         actions = [(C, C), (C, C), (D, C), (C, C), (C, C), (D, C)]
         self.versus_test(axelrod.Cooperator(), expected_actions=actions,
                          seed=10)
+
+
+class SteinAndRapoport(TestPlayer):
+
+    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': {'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,
+                         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.Defector()
+        actions = [(C, D)] * 4 + [(D, D)] * 15
+        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)]
+
+        # 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/conf.py

@@ -18,10 +18,10 @@
 import mock
 
 MOCK_MODULES = [
-    'numpy', 'numpy.linalg', 'numpy.random', 'matplotlib.pyplot', 'matplotlib',
-    'matplotlib.transforms', 'mpl_toolkits.axes_grid1', 'dill', 'multiprocess',
-    'prompt_toolkit', 'prompt_toolkit.token', 'prompt_toolkit.styles',
-    'prompt_toolkit.validation']
+    'scipy', 'scipy.stats','numpy', 'numpy.linalg', 'numpy.random',
+    'matplotlib.pyplot', 'matplotlib','matplotlib.transforms',
+    'mpl_toolkits.axes_grid1', 'dill', 'multiprocess','prompt_toolkit',
+    'prompt_toolkit.token', 'prompt_toolkit.styles','prompt_toolkit.validation']
 for mod_name in MOCK_MODULES:
     sys.modules[mod_name] = mock.Mock()
 

docs/reference/overview_of_strategies.rst

@@ -28,7 +28,7 @@ Strategies in the Axelrod's first tournament:
 +--------------------------+-------------------------------------------+--------------------------+
 | `Shubik`_                | Shubik (author's name)                    | :code:`Shubik`           |
 +--------------------------+-------------------------------------------+--------------------------+
-| `Stein and Rapoport`_    | Stein and Rapoport (authors' names)       | Not Implemented          |
+| `Stein and Rapoport`_    | Stein and Rapoport (authors' names)       | :code:`SteinAndRapoport` |
 +--------------------------+-------------------------------------------+--------------------------+
 | `Grudger`_               | Grudger (by Friedman)                     | :code:`Grudger`          |
 +--------------------------+-------------------------------------------+--------------------------+

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

requirements.txt

@@ -3,3 +3,4 @@ matplotlib>=1.4.2
 hypothesis>=3.2
 tqdm>=3.4.0
 prompt-toolkit>=1.0.7
+scipy>=0.19.0