Merge branch 'master' of https://github.com/Axelrod-Python/Axelrod

Author: gaffney2010

axelrod/result_set.py

@@ -2,7 +2,6 @@
 import csv
 import itertools
 from multiprocessing import cpu_count
-from typing import List
 import warnings
 
 import numpy as np
@@ -118,12 +117,9 @@ def _reshape_out(
             alternative=0,
         )
 
-        self.wins = self._reshape_two_dim_list(
-            sum_per_player_repetition_df["Win"])
-        self.scores = self._reshape_two_dim_list(
-            sum_per_player_repetition_df["Score"])
-        self.normalised_scores = self._reshape_two_dim_list(
-            normalised_scores_series)
+        self.wins = self._reshape_two_dim_list(sum_per_player_repetition_df["Win"])
+        self.scores = self._reshape_two_dim_list(sum_per_player_repetition_df["Score"])
+        self.normalised_scores = self._reshape_two_dim_list(normalised_scores_series)
 
         self.cooperation = self._build_cooperation(
             sum_per_player_opponent_df["Cooperation count"]
@@ -170,8 +166,7 @@ def _reshape_out(
         self.ranked_names = self._build_ranked_names()
 
         self.payoff_matrix = self._build_summary_matrix(self.payoffs)
-        self.payoff_stddevs = self._build_summary_matrix(self.payoffs,
-                                                         func=np.std)
+        self.payoff_stddevs = self._build_summary_matrix(self.payoffs, func=np.std)
 
         self.payoff_diffs_means = self._build_payoff_diffs_means()
         self.cooperating_rating = self._build_cooperating_rating()
@@ -271,9 +266,7 @@ def _build_good_partner_matrix(self, good_partner_series):
                     # interactions.
                     row.append(0)
                 else:
-                    row.append(
-                        good_partner_dict.get((player_index, opponent_index),
-                                              0))
+                    row.append(good_partner_dict.get((player_index, opponent_index), 0))
             good_partner_matrix.append(row)
         return good_partner_matrix
 
@@ -341,15 +334,13 @@ def _build_normalised_state_distribution(self):
             for counter in player:
                 total = sum(counter.values())
                 counters.append(
-                    Counter(
-                        {key: value / total for key, value in counter.items()})
+                    Counter({key: value / total for key, value in counter.items()})
                 )
             normalised_state_distribution.append(counters)
         return normalised_state_distribution
 
     @update_progress_bar
-    def _build_state_to_action_distribution(self,
-                                            state_to_action_distribution_series):
+    def _build_state_to_action_distribution(self, state_to_action_distribution_series):
         state_to_action_key_map = {
             "CC to C count": ((C, C), C),
             "CC to D count": ((C, C), D),
@@ -405,8 +396,7 @@ def _build_normalised_state_to_action_distribution(self):
         return normalised_state_to_action_distribution
 
     @update_progress_bar
-    def _build_initial_cooperation_count(self,
-                                         initial_cooperation_count_series):
+    def _build_initial_cooperation_count(self, initial_cooperation_count_series):
         initial_cooperation_count_dict = initial_cooperation_count_series.to_dict()
         initial_cooperation_count = [
             initial_cooperation_count_dict.get(player_index, 0)
@@ -421,7 +411,7 @@ def _build_normalised_cooperation(self):
             normalised_cooperation = [
                 list(np.nan_to_num(row))
                 for row in np.array(self.cooperation)
-                           / sum(map(np.array, self.match_lengths))
+                / sum(map(np.array, self.match_lengths))
             ]
             return normalised_cooperation
 
@@ -436,8 +426,7 @@ def _build_initial_cooperation_rate(self, interactions_series):
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
             initial_cooperation_rate = list(
-                np.nan_to_num(np.array(
-                    self.initial_cooperation_count) / interactions_array)
+                np.nan_to_num(np.array(self.initial_cooperation_count) / interactions_array)
             )
             return initial_cooperation_rate
 
@@ -462,8 +451,7 @@ def _build_eigenmoses_rating(self):
         The eigenmoses rating as defined in:
         http://www.scottaaronson.com/morality.pdf
         """
-        eigenvector, eigenvalue = eigen.principal_eigenvector(
-            self.vengeful_cooperation)
+        eigenvector, eigenvalue = eigen.principal_eigenvector(self.vengeful_cooperation)
 
         return eigenvector.tolist()
 
@@ -587,8 +575,7 @@ def _build_tasks(self, df):
         ]
         sum_per_player_opponent_task = df.groupby(groups)[columns].sum()
 
-        ignore_self_interactions_task = df["Player index"] != df[
-            "Opponent index"]
+        ignore_self_interactions_task = df["Player index"] != df["Opponent index"]
         adf = df[ignore_self_interactions_task]
 
         groups = ["Player index", "Repetition"]
@@ -602,8 +589,7 @@ def _build_tasks(self, df):
         groups = ["Player index"]
         column = "Initial cooperation"
         initial_cooperation_count_task = adf.groupby(groups)[column].sum()
-        interactions_count_task = adf.groupby("Player index")[
-            "Player index"].count()
+        interactions_count_task = adf.groupby("Player index")["Player index"].count()
 
         return (
             mean_per_reps_player_opponent_task,
@@ -623,18 +609,6 @@ def __eq__(self, other):
             other : axelrod.ResultSet
                 Another results set against which to check equality
         """
-
-        def list_equal_with_nans(v1: List[float], v2: List[float]) -> bool:
-            """Matches lists, accounting for NaNs."""
-            if len(v1) != len(v2):
-                return False
-            for i1, i2 in zip(v1, v2):
-                if np.isnan(i1) and np.isnan(i2):
-                    continue
-                if i1 != i2:
-                    return False
-            return True
-
         return all(
             [
                 self.wins == other.wins,
@@ -654,10 +628,8 @@ def list_equal_with_nans(v1: List[float], v2: List[float]) -> bool:
                 self.cooperating_rating == other.cooperating_rating,
                 self.good_partner_matrix == other.good_partner_matrix,
                 self.good_partner_rating == other.good_partner_rating,
-                list_equal_with_nans(self.eigenmoses_rating,
-                                     other.eigenmoses_rating),
-                list_equal_with_nans(self.eigenjesus_rating,
-                                     other.eigenjesus_rating),
+                self.eigenmoses_rating == other.eigenmoses_rating,
+                self.eigenjesus_rating == other.eigenjesus_rating,
             ]
         )
 
@@ -727,8 +699,7 @@ def summarise(self):
             rates = []
             for state in states:
                 counts = [
-                    counter[(state, C)] for counter in player if
-                    counter[(state, C)] > 0
+                    counter[(state, C)] for counter in player if counter[(state, C)] > 0
                 ]
 
                 if len(counts) > 0:
@@ -751,8 +722,7 @@ def summarise(self):
 
         summary_data = []
         for rank, i in enumerate(self.ranking):
-            data = list(summary_measures[i]) + state_prob[i] + state_to_C_prob[
-                i]
+            data = list(summary_measures[i]) + state_prob[i] + state_to_C_prob[i]
             summary_data.append(self.player(rank, *data))
 
         return summary_data

axelrod/strategies/zero_determinant.py

@@ -6,15 +6,44 @@
 
 
 class LRPlayer(MemoryOnePlayer):
-    """Abstraction for Linear Relation players. These players enforce a linear
-    difference in stationary payoffs s * (S_xy - l) = S_yx - l, with 0 <= l <= R.
-    The parameter `s` is called the slope and the parameter `l` the
-    baseline payoff. For extortionate strategies, the extortion factor is the
-    inverse of the slope.
-
-    This parameterization is Equation 14 in
-    http://journals.plos.org/plosone/article?id=10.1371/journal.pone.0077886.
-    See Figure 2 of the article for a more in-depth explanation.
+    """
+    Abstraction for Linear Relation players. These players enforce a linear
+    difference in stationary payoffs :math:`s (S_{xy} - l) = S_{yx} - l.`
+
+    The parameter :math:`s` is called the slope and the parameter :math:`l` the
+    baseline payoff. For extortionate strategies, the extortion factor
+    :math:`\chi` is the inverse of the slope :math:`s`.
+
+    For the standard prisoner's dilemma where :math:`T > R > P > S` and
+    :math:`R > (T + S) / 2 > P`, a pair :math:`(l, s)` is enforceable iff
+
+    .. math::
+       :nowrap:
+
+       \\begin{eqnarray}
+       &P &<= l <= R \\\\
+       &s_{min} &= -\min\\left( \\frac{T - l}{l - S}, \\frac{l - S}{T - l}\\right) <= s <= 1
+       \\end{eqnarray}
+
+    And also that there exists :math:`\\phi` such that
+
+    .. math::
+       :nowrap:
+
+       \\begin{eqnarray}
+          p_1 &= P(C|CC) &= 1 - \\phi (1 - s)(R - l) \\\\
+          p_2 &= P(C|CD) &= 1 - \\phi (s(l - S) + (T - l)) \\\\
+          p_3 &= P(C|DC) &= \\phi ((l - S) + s(T - l)) \\\\
+          p_4 &= P(C|DD) &= \\phi (1 - s)(l - P)
+       \\end{eqnarray}
+
+
+    These conditions also force :math:`\\phi >= 0`. For a given pair :math:`(l, s)`
+    there may be multiple such :math:`\\phi`.
+
+    This parameterization is Equation 14 in [Hilbe2013]_.
+    See Figure 2 of the article for a more in-depth explanation. Other game
+    parameters can alter the relations and bounds above.
 
     Names:
 

axelrod/tests/unit/test_eigen.py

@@ -15,13 +15,6 @@ def test_identity_matrices(self):
             self.assertAlmostEqual(evalue, 1)
             assert_array_almost_equal(evector, _normalise(numpy.ones(size)))
 
-    def test_zero_matrix(self):
-        mat = numpy.array([[0, 0], [0, 0]])
-        evector, evalue = principal_eigenvector(mat)
-        self.assertTrue(numpy.isnan(evalue))
-        self.assertTrue(numpy.isnan(evector[0]))
-        self.assertTrue(numpy.isnan(evector[1]))
-
     def test_2x2_matrix(self):
         mat = numpy.array([[2, 1], [1, 2]])
         evector, evalue = principal_eigenvector(mat)

axelrod/tests/unit/test_resultset.py

@@ -7,7 +7,7 @@
 import pandas as pd
 from axelrod.result_set import create_counter_dict
 from axelrod.tests.property import prob_end_tournaments, tournaments
-from numpy import mean, nan, nanmedian, std
+from numpy import mean, nanmedian, std
 
 from dask.dataframe.core import DataFrame
 from hypothesis import given, settings
@@ -190,52 +190,6 @@ def test_init(self):
         self.assertEqual(rs.players, self.players)
         self.assertEqual(rs.num_players, len(self.players))
 
-    def _clear_matrix(self, matrix):
-        for i in range(len(matrix)):
-            for j in range(len(matrix[i])):
-                matrix[i][j] = 0
-
-    def test_ne_vectors(self):
-        rs_1 = axelrod.ResultSet(
-            self.filename,
-            self.players,
-            self.repetitions
-        )
-
-        rs_2 = axelrod.ResultSet(
-            self.filename,
-            self.players,
-            self.repetitions
-        )
-
-        # A different vector
-        rs_2.eigenmoses_rating = (-1, -1, -1)
-
-        self.assertNotEqual(rs_1, rs_2)
-
-    def test_nan_vectors(self):
-        rs_1 = axelrod.ResultSet(
-            self.filename,
-            self.players,
-            self.repetitions
-        )
-        # Force a broken eigenmoses, by replacing vengeful_cooperation with
-        # zeroes.
-        self._clear_matrix(rs_1.vengeful_cooperation)
-        rs_1.eigenmoses_rating = rs_1._build_eigenmoses_rating()
-
-        rs_2 = axelrod.ResultSet(
-            self.filename,
-            self.players,
-            self.repetitions
-        )
-        # Force a broken eigenmoses, by replacing vengeful_cooperation with
-        # zeroes.
-        self._clear_matrix(rs_2.vengeful_cooperation)
-        rs_2.eigenmoses_rating = rs_2._build_eigenmoses_rating()
-
-        self.assertEqual(rs_1, rs_2)
-
     def test_init_multiprocessing(self):
         rs = axelrod.ResultSet(
             self.filename,