Merge pull request #474 from Axelrod-Python/284

Interactions and RoundRobin

Author: drvinceknight

.gitignore

@@ -6,4 +6,7 @@ _build/
 dist/
 MANIFEST
 Axelrod.egg-info
-.hypothesis/eval_source/
+.hypothesis/
+basic_strategies.csv
+cache.txt
+test.csv

.hypothesis/examples.db

@@ -8,8 +8,8 @@
 from .player import init_args, is_basic, obey_axelrod, update_history, Player
 from .mock_player import MockPlayer, simulate_play
 from .match import Match
-from .round_robin import RoundRobin
 from .strategies import *
+from .tournament_type import *
 from .tournament import Tournament
 from .tournament_manager import TournamentManager
 from .tournament_manager_factory import TournamentManagerFactory

axelrod/__init__.py

@@ -3,13 +3,14 @@
 import collections
 import itertools
 
-from axelrod import RoundRobin, update_history
+from axelrod import update_history
 from axelrod import Actions
 
 from axelrod.strategies.cycler import Cycler
 
 C, D = Actions.C, Actions.D
 
+
 def detect_cycle(history, min_size=1, offset=0):
     """Detects cycles in the sequence history.
 
@@ -47,11 +48,23 @@ def limited_simulate_play(player_1, player_2, h1):
     update_history(player_1, h1)
     update_history(player_2, h2)
 
+
 def simulate_match(player_1, player_2, strategy, rounds=10):
     """Simulates a number of matches."""
     for match in range(rounds):
         limited_simulate_play(player_1, player_2, strategy)
 
+
+def calculate_scores(p1, p2, game):
+    """Calculates the score for two players based their history"""
+    s1, s2 = 0, 0
+    for pair in zip(p1.history, p2.history):
+        score = game.score(pair)
+        s1 += score[0]
+        s2 += score[1]
+    return s1, s2
+
+
 def look_ahead(player_1, player_2, game, rounds=10):
     """Looks ahead for `rounds` and selects the next strategy appropriately."""
     results = []
@@ -61,29 +74,28 @@ def look_ahead(player_1, player_2, game, rounds=10):
     for strategy in strategies:
         # Instead of a deepcopy, create a new opponent and play out the history
         opponent_ = player_2.clone()
-        player_ = Cycler(strategy) # Either cooperator or defector
+        player_ = Cycler(strategy)  # Either cooperator or defector
         for h1 in player_1.history:
             limited_simulate_play(player_, opponent_, h1)
 
-        round_robin = RoundRobin(players=[player_, opponent_], game=game,
-                                 turns=rounds)
         simulate_match(player_, opponent_, strategy, rounds)
-        results.append(round_robin._calculate_scores(player_, opponent_)[0])
+        results.append(calculate_scores(player_, opponent_, game))
 
     return strategies[results.index(max(results))]
 
 
 class Memoized(object):
-   """Decorator. Caches a function's return value each time it is called.
-   If called later with the same arguments, the cached value is returned
-   (not reevaluated). From:
-   https://wiki.python.org/moin/PythonDecoratorLibrary#Memoize
-   """
-   def __init__(self, func):
+    """Decorator. Caches a function's return value each time it is called.
+    If called later with the same arguments, the cached value is returned
+    (not reevaluated). From:
+    https://wiki.python.org/moin/PythonDecoratorLibrary#Memoize
+    """
+
+    def __init__(self, func):
         self.func = func
         self.cache = {}
 
-   def __call__(self, *args):
+    def __call__(self, *args):
         if not isinstance(args, collections.Hashable):
             # uncacheable. a list, for instance.
             # better to not cache than blow up.
@@ -95,11 +107,11 @@ def __call__(self, *args):
             self.cache[args] = value
             return value
 
-   def __repr__(self):
+    def __repr__(self):
         """Return the function's docstring."""
         return self.func.__doc__
 
-   def __get__(self, obj, objtype):
+    def __get__(self, obj, objtype):
         """Support instance methods."""
         return functools.partial(self.__call__, obj)
 

axelrod/_strategy_utils.py

@@ -1,12 +1,10 @@
-from math import sqrt
 from . import eigen
 from axelrod import Actions
 from axelrod.payoff import player_count
 
 C, D = Actions.C, Actions.D
 
 
-# As yet unused until RoundRobin returns interactions
 def cooperation_matrix(interactions):
     """
     The cooperation matrix from a single round robin.

axelrod/cooperation.py

@@ -27,8 +27,8 @@ def __init__(self, players, turns, deterministic_cache=None,
             The probability that a player's intended action should be flipped
         """
         self.result = []
-        self._player1 = players[0]
-        self._player2 = players[1]
+        self.player1 = players[0]
+        self.player2 = players[1]
         self._classes = (players[0].__class__, players[1].__class__)
         self._turns = turns
         self._prob_end = prob_end
@@ -48,8 +48,8 @@ def _stochastic(self):
         return (
             self._prob_end or
             self._noise or
-            self._player1.classifier['stochastic'] or
-            self._player2.classifier['stochastic'])
+            self.player1.classifier['stochastic'] or
+            self.player2.classifier['stochastic'])
 
     @property
     def _cache_update_required(self):
@@ -60,8 +60,8 @@ def _cache_update_required(self):
             not self._prob_end and
             not self._noise and
             self._cache_mutable and not (
-                self._player1.classifier['stochastic'] or
-                self._player2.classifier['stochastic'])
+                self.player1.classifier['stochastic'] or
+                self.player2.classifier['stochastic'])
         )
 
     def play(self):
@@ -102,12 +102,12 @@ def play(self):
 
         if (self._stochastic or self._classes not in self._cache):
             turn = 0
-            self._player1.reset()
-            self._player2.reset()
+            self.player1.reset()
+            self.player2.reset()
             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))
+                self.player1.play(self.player2, self._noise)
+            result = list(zip(self.player1.history, self.player2.history))
 
             if self._cache_update_required:
                 self._cache[self._classes] = result
@@ -119,6 +119,6 @@ def play(self):
 
     def sparklines(self, c_symbol=u'█', d_symbol=u' '):
         return (
-            sparkline(self._player1.history, c_symbol, d_symbol) +
+            sparkline(self.player1.history, c_symbol, d_symbol) +
             u'\n' +
-            sparkline(self._player2.history, c_symbol, d_symbol))
+            sparkline(self.player2.history, c_symbol, d_symbol))

axelrod/match.py

@@ -60,7 +60,6 @@ def player_count(interactions):
     return int((math.sqrt(len(interactions) * 8 + 1) - 1) / 2)
 
 
-# As yet unused until RoundRobin returns interactions
 def payoff_matrix(interactions, game):
     """
     The payoff matrix from a single round robin.
@@ -115,7 +114,6 @@ def payoff_matrix(interactions, game):
     return payoffs
 
 
-# As yet unused until RoundRobin returns interactions
 def interaction_payoff(actions, game):
     """
     The payoff values for a single interaction of n turns between two players.

axelrod/payoff.py

@@ -1,7 +1,5 @@
-import math
 import csv
 
-#from .eigen import *
 from axelrod import payoff as ap, cooperation as ac
 
 try:
@@ -22,7 +20,7 @@ def __init__(self, players, turns, repetitions, outcome,
             players (list): a list of player objects.
             turns (int): the number of turns per interaction.
             repetitions (int): the number of time the round robin was repeated.
-            outcome (dict): returned from the RoundRobin class and containing
+            outcome (dict): returned from the Tournament class and containing
                 various sets of results for processing by this class.
             with_morality (bool): a flag to determine whether morality metrics
                 should be calculated.