Merge pull request #461 from Axelrod-Python/37

37 - Adding probabilistic ending to the match class

Author: meatballs

.hypothesis/examples.db

@@ -1,4 +1,6 @@
 # -*- coding: utf-8 -*-
+import random
+from math import log, ceil
 
 
 def sparkline(actions, c_symbol=u'█', d_symbol=u' '):
@@ -9,7 +11,7 @@ def sparkline(actions, c_symbol=u'█', d_symbol=u' '):
 class Match(object):
 
     def __init__(self, players, turns, deterministic_cache=None,
-                 cache_mutable=True, noise=0):
+                 cache_mutable=True, noise=0, prob_end=None):
         """
         Parameters
         ----------
@@ -29,6 +31,7 @@ def __init__(self, players, turns, deterministic_cache=None,
         self._player2 = players[1]
         self._classes = (players[0].__class__, players[1].__class__)
         self._turns = turns
+        self._prob_end = prob_end
         if deterministic_cache is None:
             self._cache = {}
         else:
@@ -43,16 +46,18 @@ def _stochastic(self):
         stochastic
         """
         return (
+            self._prob_end or
             self._noise or
             self._player1.classifier['stochastic'] or
             self._player2.classifier['stochastic'])
 
     @property
     def _cache_update_required(self):
         """
-        A boolean to show whether the determinstic cache should be updated
+        A boolean to show whether the deterministic cache should be updated
         """
         return (
+            not self._prob_end and
             not self._noise and
             self._cache_mutable and not (
                 self._player1.classifier['stochastic'] or
@@ -77,11 +82,29 @@ def play(self):
 
         i.e. One entry per turn containing a pair of actions.
         """
+        if self._prob_end is not None:
+            # If using a probabilistic end: sample the length of the game.
+            # This is using inverse random sample on a pdf given by:
+            # f(n) = p_end * (1 - p_end) ^ (n - 1)
+            # Which gives cdf:
+            # F(n) = 1 - (1 - p) ^ n
+            # Which gives for given x = F(n) (ie the random sample) gives n:
+            # n = ceil((ln(1-x)/ln(1-p)))
+            try:
+                x = random.random()
+                end_turn = ceil(log(1 - x) / log(1 - self._prob_end))
+            except ZeroDivisionError:
+                end_turn = float("inf")
+            except ValueError:
+                end_turn = 1
+        else:
+            end_turn = float("inf")
+
         if (self._stochastic or self._classes not in self._cache):
             turn = 0
             self._player1.reset()
             self._player2.reset()
-            while turn < self._turns:
+            while turn < min(self._turns, end_turn):
                 turn += 1
                 self._player1.play(self._player2, self._noise)
             result = list(zip(self._player1.history, self._player2.history))

axelrod/match.py

@@ -4,39 +4,75 @@
 import axelrod
 from axelrod import Actions
 
+from hypothesis import given, example
+from hypothesis.strategies import integers, floats, random_module, assume
+
 C, D = Actions.C, Actions.D
 
 
 class TestMatch(unittest.TestCase):
 
-    def test_init(self):
+    @given(turns=integers(min_value=1, max_value=200),
+           prob_end=floats(min_value=0, max_value=1))
+    @example(turns=5, prob_end=None)
+    def test_init(self, turns, prob_end):
         p1, p2 = axelrod.Cooperator(), axelrod.Cooperator()
-        match = axelrod.Match((p1, p2), 5)
+        match = axelrod.Match((p1, p2), turns, prob_end=prob_end)
+        self.assertEqual(match.result, [])
+        self.assertEqual(match._player1, p1)
+        self.assertEqual(match._player2, p2)
+        self.assertEqual(
+            match._classes, (axelrod.Cooperator, axelrod.Cooperator))
+        self.assertEqual(match._turns, turns)
+        self.assertEqual(match._prob_end, prob_end)
+        self.assertEqual(match._cache, {})
+        self.assertEqual(match._cache_mutable, True)
+        self.assertEqual(match._noise, 0)
+
+        # Checking that prob_end has default None
+        match = axelrod.Match((p1, p2), turns)
         self.assertEqual(match.result, [])
         self.assertEqual(match._player1, p1)
         self.assertEqual(match._player2, p2)
         self.assertEqual(
             match._classes, (axelrod.Cooperator, axelrod.Cooperator))
-        self.assertEqual(match._turns, 5)
+        self.assertEqual(match._turns, turns)
+        self.assertEqual(match._prob_end, None)
         self.assertEqual(match._cache, {})
         self.assertEqual(match._cache_mutable, True)
         self.assertEqual(match._noise, 0)
 
-    def test_stochastic(self):
+    @given(p=floats(min_value=0, max_value=1),
+           rm=random_module())
+    def test_stochastic(self, p, rm):
+
+        assume(0 < p < 1)
+
         p1, p2 = axelrod.Cooperator(), axelrod.Cooperator()
         match = axelrod.Match((p1, p2), 5)
         self.assertFalse(match._stochastic)
 
-        match = axelrod.Match((p1, p2), 5, noise=0.2)
+        match = axelrod.Match((p1, p2), 5, noise=p)
+        self.assertTrue(match._stochastic)
+
+        match = axelrod.Match((p1, p2), 5, prob_end=p)
         self.assertTrue(match._stochastic)
 
         p1 = axelrod.Random()
         match = axelrod.Match((p1, p2), 5)
         self.assertTrue(match._stochastic)
 
-    def test_cache_update_required(self):
+    @given(p=floats(min_value=0, max_value=1),
+           rm=random_module())
+    def test_cache_update_required(self, p, rm):
+
+        assume(0 < p < 1)
+
         p1, p2 = axelrod.Cooperator(), axelrod.Cooperator()
-        match = axelrod.Match((p1, p2), 5, noise=0.2)
+        match = axelrod.Match((p1, p2), 5, noise=p)
+        self.assertFalse(match._cache_update_required)
+
+        match = axelrod.Match((p1, p2), 5, prob_end=p)
         self.assertFalse(match._cache_update_required)
 
         match = axelrod.Match((p1, p2), 5, cache_mutable=False)
@@ -64,6 +100,30 @@ def test_play(self):
         match = axelrod.Match(players, 3, cache)
         self.assertEqual(match.play(), expected_result)
 
+    @given(turns=integers(min_value=1, max_value=200),
+           prob_end=floats(min_value=0, max_value=1),
+           rm=random_module())
+    def test_prob_end_play(self, turns, prob_end, rm):
+
+        players = (axelrod.Cooperator(), axelrod.Defector())
+        match = axelrod.Match(players, turns, prob_end=prob_end)
+        self.assertTrue(0 <= len(match.play()))
+
+        # If game has no ending the length will be turns
+        match = axelrod.Match(players, turns, prob_end=0)
+        self.assertEqual(len(match.play()), turns)
+
+        # If game has 1 prob of ending it lasts only one turn
+        match = axelrod.Match(players, turns, prob_end=1)
+        self.assertEqual(len(match.play()), 1)
+
+    @given(prob_end=floats(min_value=0.25, max_value=0.75),
+           rm=random_module())
+    def test_prob_end_play_with_no_turns(self, prob_end, rm):
+        players = (axelrod.Cooperator(), axelrod.Defector())
+        match = axelrod.Match(players, float("inf"), prob_end=prob_end)
+        self.assertTrue(0 <= len(match.play()))
+
     def test_sparklines(self):
         players = (axelrod.Cooperator(), axelrod.Alternator())
         match = axelrod.Match(players, 4)
@@ -72,4 +132,3 @@ def test_sparklines(self):
         self.assertEqual(match.sparklines(), expected_sparklines)
         expected_sparklines = u'XXXX\nXYXY'
         self.assertEqual(match.sparklines('X', 'Y'), expected_sparklines)
-

axelrod/tests/unit/test_match.py

@@ -64,3 +64,19 @@ but you can use any characters you like::
     >>> print(match.sparklines(c_symbol='|', d_symbol='-'))
     |||||||||||||||||||||||||
     |-|-|-|-|-|-|-|-|-|-|-|-|
+
+It is also possible to create matches that that have a given probability of
+ending after certain number of turns::
+
+    >>> import axelrod as axl
+    >>> players = (axl.Cooperator(), axl.Alternator())
+    >>> match = axl.Match(players, 25, prob_end=.4)
+    >>> match.play() # doctest: +SKIP
+    [('C', 'C'), ('C', 'D'), ('C', 'C'), ('C', 'D'), ('C', 'C')]
+
+In that particular instance the probability of any turn being the last is .4 so the mean length of a match would in fact be :math:`1/0.6\approx 1.667`. Note that you can also pass an infinite amount of turns when passing an ending probability::
+
+    >>> players = (axl.Cooperator(), axl.Alternator())
+    >>> match = axl.Match(players, turns=float("inf"), prob_end=.4)
+    >>> match.play() # doctest: +SKIP
+    [('C', 'C'), ('C', 'D')]

docs/tutorials/further_topics/creating_matches.rst

@@ -1,3 +1,3 @@
 #!/usr/bin/env bash
 python -m unittest discover axelrod/tests/
-./doctest
+python doctests.py