Merge branch 'fix-rs' of https://github.com/gaffney2010/Axelrod

Author: gaffney2010

axelrod/result_set.py

@@ -2,6 +2,7 @@
 import csv
 import itertools
 from multiprocessing import cpu_count
+from typing import List
 import warnings
 
 import numpy as np
@@ -117,9 +118,12 @@ 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"]
@@ -166,7 +170,8 @@ 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()
@@ -266,7 +271,9 @@ 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
 
@@ -334,13 +341,15 @@ 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),
@@ -396,7 +405,8 @@ 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)
@@ -411,7 +421,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
 
@@ -426,7 +436,8 @@ 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
 
@@ -451,7 +462,8 @@ 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()
 
@@ -575,7 +587,8 @@ 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"]
@@ -589,7 +602,8 @@ 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,
@@ -609,6 +623,18 @@ 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,
@@ -628,8 +654,10 @@ def __eq__(self, other):
                 self.cooperating_rating == other.cooperating_rating,
                 self.good_partner_matrix == other.good_partner_matrix,
                 self.good_partner_rating == other.good_partner_rating,
-                self.eigenmoses_rating == other.eigenmoses_rating,
-                self.eigenjesus_rating == other.eigenjesus_rating,
+                list_equal_with_nans(self.eigenmoses_rating,
+                                     other.eigenmoses_rating),
+                list_equal_with_nans(self.eigenjesus_rating,
+                                     other.eigenjesus_rating),
             ]
         )
 
@@ -699,7 +727,8 @@ 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:
@@ -722,7 +751,8 @@ 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/_strategies.py

@@ -208,6 +208,7 @@
     Michaelos,
     NTitsForMTats,
     OmegaTFT,
+    OriginalGradual,
     RandomTitForTat,
     SlowTitForTwoTats2,
     SneakyTitForTat,

axelrod/strategies/titfortat.py

@@ -384,18 +384,27 @@ def strategy(self, opponent: Player) -> Action:
         return move
 
 
-class Gradual(Player):
+class OriginalGradual(Player):
     """
     A player that punishes defections with a growing number of defections
-    but after punishing enters a calming state and cooperates no matter what
-    the opponent does for two rounds.
+    but after punishing for `punishment_limit` number of times enters a calming
+    state and cooperates no matter what the opponent does for two rounds.
+
+    The `punishment_limit` is incremented whenever the opponent defects and the
+    strategy is not in either calming or punishing state.
+
+    Note that `Gradual` appears in [CRISTAL-SMAC2018]_ however that version of
+    `Gradual` does not give the results reported in [Beaufils1997]_ which is the
+    paper that first introduced the strategy. For a longer discussion of this
+    see: https://github.com/Axelrod-Python/Axelrod/issues/1294. This is why this
+    strategy has been renamed to `OriginalGradual`.
 
     Names:
 
     - Gradual: [Beaufils1997]_
      """
 
-    name = "Gradual"
+    name = "Original Gradual"
     classifier = {
         "memory_depth": float("inf"),
         "stochastic": False,
@@ -439,6 +448,67 @@ def strategy(self, opponent: Player) -> Action:
         return C
 
 
+class Gradual(Player):
+    """
+    Similar to OriginalGradual, this is a player that punishes defections with a
+    growing number of defections but after punishing for `punishment_limit`
+    number of times enters a calming state and cooperates no matter what the
+    opponent does for two rounds.
+
+    This version of Gradual is an update of `OriginalGradual` and the difference
+    is that the `punishment_limit` is incremented whenever the opponent defects
+    (regardless of the state of the player).
+
+    Note that this version of `Gradual` appears in [CRISTAL-SMAC2018]_ however
+    this version of
+    `Gradual` does not give the results reported in [Beaufils1997]_ which is the
+    paper that first introduced the strategy. For a longer discussion of this
+    see: https://github.com/Axelrod-Python/Axelrod/issues/1294.
+
+    This version is based on  https://github.com/cristal-smac/ipd/blob/master/src/strategies.py#L224
+
+    Names:
+
+    - Gradual: [CRISTAL-SMAC2018]_
+    """
+
+    name = "Gradual"
+    classifier = {
+        "memory_depth": float("inf"),
+        "stochastic": False,
+        "makes_use_of": set(),
+        "long_run_time": False,
+        "inspects_source": False,
+        "manipulates_source": False,
+        "manipulates_state": False,
+    }
+
+    def __init__(self) -> None:
+
+        super().__init__()
+        self.calm_count = 0
+        self.punish_count = 0
+
+    def strategy(self, opponent: Player) -> Action:
+
+        if len(self.history) == 0:
+            return C
+
+        if self.punish_count > 0:
+            self.punish_count -= 1
+            return D
+
+        if self.calm_count > 0:
+            self.calm_count -= 1
+            return C
+
+        if opponent.history[-1] == D:
+            self.punish_count = opponent.defections - 1
+            self.calm_count = 2
+            return D
+        return C
+
+
 @TrackHistoryTransformer(name_prefix=None)
 class ContriteTitForTat(Player):
     """