Merge pull request #1097 from Axelrod-Python/new_zd

Three new ZD strategies

Author: meatballs

axelrod/strategies/_strategies.py

@@ -50,8 +50,8 @@
 from .mathematicalconstants import Golden, Pi, e
 from .memoryone import (
     MemoryOnePlayer, ALLCorALLD, FirmButFair, GTFT, SoftJoss,
-    StochasticCooperator, StochasticWSLS, ZDExtort2, ZDExtort2v2, ZDExtort4,
-    ZDGen2, ZDGTFT2, ZDSet2, WinStayLoseShift, WinShiftLoseStay, ReactivePlayer)
+    StochasticCooperator, StochasticWSLS, WinStayLoseShift, WinShiftLoseStay,
+    ReactivePlayer)
 from .memorytwo import MEM2
 from .mindcontrol import MindController, MindWarper, MindBender
 from .mindreader import MindReader, ProtectedMindReader, MirrorMindReader
@@ -76,10 +76,14 @@
     TitForTat, TitFor2Tats, TwoTitsForTat, Bully, SneakyTitForTat,
     SuspiciousTitForTat, AntiTitForTat, HardTitForTat, HardTitFor2Tats,
     OmegaTFT, Gradual, ContriteTitForTat, AdaptiveTitForTat,
-    SpitefulTitForTat, SlowTitForTwoTats2, Alexei, EugineNier, DynamicTwoTitsForTat, NTitsForMTats)
+    SpitefulTitForTat, SlowTitForTwoTats2, Alexei, EugineNier,
+    DynamicTwoTitsForTat, NTitsForMTats)
 from .verybad import VeryBad
 from .worse_and_worse import (WorseAndWorse, KnowledgeableWorseAndWorse,
                               WorseAndWorse2, WorseAndWorse3)
+from .zero_determinant import (
+    ZDExtortion, ZDExtort2, ZDExtort3, ZDExtort2v2, ZDExtort4, ZDGen2, ZDGTFT2,
+    ZDMischief, ZDSet2)
 
 # Note: Meta* strategies are handled in .__init__.py
 
@@ -259,11 +263,14 @@
     WorseAndWorse,
     WorseAndWorse2,
     WorseAndWorse3,
+    ZDExtortion,
     ZDExtort2,
+    ZDExtort3,
     ZDExtort2v2,
     ZDExtort4,
     ZDGTFT2,
     ZDGen2,
+    ZDMischief,
     ZDSet2,
     e,
     DynamicTwoTitsForTat,

axelrod/strategies/memoryone.py

@@ -1,3 +1,6 @@
+"""Memory One strategies. Note that there are Memory One strategies in other
+files, including titfortat.py and zero_determinant.py"""
+
 from axelrod.action import Action
 from axelrod.player import Player
 from axelrod.random_ import random_choice
@@ -33,7 +36,8 @@ class MemoryOnePlayer(Player):
         'manipulates_state': False
     }
 
-    def __init__(self, four_vector: type_four_vector = None, initial: Action = C) -> None:
+    def __init__(self, four_vector: type_four_vector = None,
+                 initial: Action = C) -> None:
         """
         Parameters
 
@@ -201,10 +205,10 @@ def __init__(self) -> None:
 class StochasticCooperator(MemoryOnePlayer):
     """Stochastic Cooperator.
 
-	Names:
+    Names:
 
-	- Stochastic Cooperator: [Adami2013]_
-	"""
+    - Stochastic Cooperator: [Adami2013]_
+    """
 
     name = 'Stochastic Cooperator'
 
@@ -241,247 +245,11 @@ def __init__(self, ep: float = 0.05) -> None:
         """
 
         self.ep = ep
-        four_vector = (1.-ep, ep, ep, 1.-ep)
+        four_vector = (1. - ep, ep, ep, 1. - ep)
         super().__init__(four_vector)
         self.set_four_vector(four_vector)
 
 
-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.
-
-    Names:
-
-    - Linear Relation player: [Hilbe2013]_
-    """
-
-    name = 'LinearRelation'
-    classifier = {
-        'memory_depth': 1,  # Memory-one Four-Vector
-        'stochastic': True,
-        'makes_use_of': set(["game"]),
-        'long_run_time': False,
-        'inspects_source': False,
-        'manipulates_source': False,
-        'manipulates_state': False
-    }
-
-
-    def receive_match_attributes(self, phi: float = 0, s: float = None, l: float = None):
-        """
-        Parameters
-
-        phi, s, l: floats
-            Parameter used to compute the four-vector according to the
-            parameterization of the strategies below.
-        """
-
-        (R, P, S, T) = self.match_attributes["game"].RPST()
-        if s is None:
-            s = 1
-        if l is None:
-            l = R
-
-        # Check parameters
-        s_min = - min((T-l) / (l-S), (l-S) / (T-l))
-        if (l < P) or (l > R) or (s > 1) or (s < s_min):
-            raise ValueError
-
-        p1 = 1 - phi * (1 - s) * (R - l)
-        p2 = 1 - phi * (s * (l - S) + (T - l))
-        p3 = phi * ((l - S) + s * (T - l))
-        p4 = phi * (1 - s) * (l - P)
-
-        four_vector = [p1, p2, p3, p4]
-        self.set_four_vector(four_vector)
-
-
-class ZDExtort2(LRPlayer):
-    """
-    An Extortionate Zero Determinant Strategy with l=P.
-
-    Names:
-
-    - Extort-2: [Stewart2012]_
-    """
-
-    name = 'ZD-Extort-2'
-
-    def __init__(self, phi: float = 1/9, s: float = 0.5) -> None:
-        """
-        Parameters
-
-        phi, s: floats
-            Parameters passed through to LRPlayer to determine
-            the four vector.
-        """
-        self.phi = phi
-        self.s = s
-        super().__init__()
-
-    def receive_match_attributes(self):
-        (R, P, S, T) = self.match_attributes["game"].RPST()
-        self.l = P
-        super().receive_match_attributes(
-            self.phi, self.s, self.l)
-
-
-class ZDExtort2v2(LRPlayer):
-    """
-    An Extortionate Zero Determinant Strategy with l=1.
-
-
-    Names:
-
-    - EXTORT2: [Kuhn2017]_
-    """
-
-    name = 'ZD-Extort-2 v2'
-
-    def __init__(self, phi: float = 1/8, s: float = 0.5, l: float = 1) -> None:
-        """
-        Parameters
-
-        phi, s: floats
-            Parameters passed through to LRPlayer to determine
-            the four vector.
-        """
-        self.phi = phi
-        self.s = s
-        self.l = l
-        super().__init__()
-
-    def receive_match_attributes(self):
-        super().receive_match_attributes(
-            self.phi, self.s, self.l)
-
-
-class ZDExtort4(LRPlayer):
-    """
-    An Extortionate Zero Determinant Strategy with l=1, s=1/4. TFT is the
-    other extreme (with l=3, s=1)
-
-
-    Names:
-
-    - Extort 4: Original name by Marc Harper
-    """
-
-    name = 'ZD-Extort-4'
-
-    def __init__(self, phi: float = 4/17, s: float = 0.25, l: float = 1) -> None:
-        """
-        Parameters
-
-        phi, s: floats
-            Parameters passed through to LRPlayer to determine
-            the four vector.
-        """
-        self.phi = phi
-        self.s = s
-        self.l = l
-        super().__init__()
-
-    def receive_match_attributes(self):
-        super().receive_match_attributes(
-            self.phi, self.s, self.l)
-
-
-class ZDGen2(LRPlayer):
-    """
-    A Generous Zero Determinant Strategy with l=3.
-
-    Names:
-
-    - GEN2: [Kuhn2017]_
-    """
-
-    name = 'ZD-GEN-2'
-
-    def __init__(self, phi: float = 1/8, s: float = 0.5, l: float = 3) -> None:
-        """
-        Parameters
-
-        phi, s: floats
-            Parameters passed through to LRPlayer to determine
-            the four vector.
-        """
-        self.phi = phi
-        self.s = s
-        self.l = l
-        super().__init__()
-
-    def receive_match_attributes(self):
-        super().receive_match_attributes(
-            self.phi, self.s, self.l)
-
-
-class ZDGTFT2(LRPlayer):
-    """
-    A Generous Zero Determinant Strategy with l=R.
-
-    Names:
-
-    - ZDGTFT-2: [Stewart2012]_
-    """
-
-    name = 'ZD-GTFT-2'
-
-    def __init__(self, phi: float = 0.25, s: float = 0.5) -> None:
-        """
-        Parameters
-
-        phi, s: floats
-            Parameters passed through to LRPlayer to determine
-            the four vector.
-        """
-        self.phi = phi
-        self.s = s
-        super().__init__()
-
-    def receive_match_attributes(self):
-        (R, P, S, T) = self.match_attributes["game"].RPST()
-        self.l = R
-        super().receive_match_attributes(
-            self.phi, self.s, self.l)
-
-
-class ZDSet2(LRPlayer):
-    """
-    A Generous Zero Determinant Strategy with l=2.
-
-    Names:
-
-    - SET2: [Kuhn2017]_
-    """
-
-    name = 'ZD-SET-2'
-
-    def __init__(self, phi: float = 1/4, s: float = 0., l: float = 2) -> None:
-        """
-        Parameters
-
-        phi, s: floats
-            Parameters passed through to LRPlayer to determine
-            the four vector.
-        """
-        self.phi = phi
-        self.s = s
-        self.l = l
-        super().__init__()
-
-    def receive_match_attributes(self):
-        super().receive_match_attributes(
-            self.phi, self.s, self.l)
-
-
 class SoftJoss(MemoryOnePlayer):
     """
     Defects with probability 0.9 when the opponent defects, otherwise
@@ -555,6 +323,7 @@ class ReactivePlayer(MemoryOnePlayer):
     - Reactive: [Nowak1989]_
     """
     name = "Reactive Player"
+
     def __init__(self, probabilities: Tuple[float, float]) -> None:
         four_vector = (*probabilities, *probabilities)
         super().__init__(four_vector)

axelrod/strategies/titfortat.py

@@ -649,6 +649,7 @@ def strategy(self, opponent: Player) -> Action:
         # Otherwise play previous move
         return self.history[-1]
 
+
 @FinalTransformer((D,), name_prefix=None)
 class Alexei(Player):
     """
@@ -677,6 +678,7 @@ def strategy(self, opponent: Player) -> Action:
             return D
         return C
 
+
 @FinalTransformer((D,), name_prefix=None)
 class EugineNier(Player):
     """
@@ -721,9 +723,9 @@ def reset(self):
 class NTitsForMTats(Player):
     """
     A parameterizable Tit-for-Tat,
-    The arguments are :
-    1) the number of defection before retaliation
-    2) the number of retaliations
+    The arguments are:
+    1) M: the number of defection before retaliation
+    2) N: the number of retaliations
 
     Names:
 
@@ -745,9 +747,9 @@ def __init__(self, N: int=3, M: int=2) -> None:
         """
         Parameters
         ----------
-        N
+        N: int
             Number of retaliations
-        M
+        M: int
             Number of defection before retaliation
 
         Special Cases
@@ -761,7 +763,7 @@ def __init__(self, N: int=3, M: int=2) -> None:
         super().__init__()
         self.N = N
         self.M = M
-        self.classifier['memory_depth'] = max([M,N])
+        self.classifier['memory_depth'] = max([M, N])
         self.retaliate_count = 0
 
     def strategy(self, opponent: Player) -> Action:
@@ -772,3 +774,7 @@ def strategy(self, opponent: Player) -> Action:
             self.retaliate_count -= 1
             return D
         return C
+
+    def reset(self):
+        super().reset()
+        self.retaliate_count = 0