New Strategy FirmButFair

Author: marcharper

axelrod/strategies/_strategies.py

@@ -28,9 +28,10 @@
 from .inverse import Inverse
 from .lookerup import LookerUp, EvolvedLookerUp
 from .mathematicalconstants import Golden, Pi, e
-from .memoryone import (ALLCorALLD,
-    MemoryOnePlayer, GTFT, SoftJoss, StochasticCooperator, StochasticWSLS,
-    ZDExtort2, ZDExtort2v2, ZDExtort4, ZDGen2, ZDGTFT2, ZDSet2, WinStayLoseShift)
+from .memoryone import (
+    MemoryOnePlayer, ALLCorALLD, FirmButFair, GTFT, SoftJoss,
+    StochasticCooperator, StochasticWSLS, ZDExtort2, ZDExtort2v2, ZDExtort4,
+    ZDGen2, ZDGTFT2, ZDSet2, WinStayLoseShift)
 from .mindcontrol import MindController, MindWarper, MindBender
 from .mindreader import MindReader, ProtectedMindReader, MirrorMindReader
 from .oncebitten import OnceBitten, FoolMeOnce, ForgetfulFoolMeOnce, FoolMeForever
@@ -80,6 +81,7 @@
     Eatherley,
     EventualCycleHunter,
     Feld,
+    FirmButFair,
     FoolMeForever,
     FoolMeOnce,
     ForgetfulFoolMeOnce,

axelrod/strategies/memoryone.py

@@ -119,6 +119,19 @@ def __repr__(self):
         return "%s: %s" % (self.name, round(self.p, 2))
 
 
+class FirmButFair(MemoryOnePlayer):
+    """A Classical Strategy described in this paper (and earlier):
+    http://www.math.ubc.ca/~hauert/publications/reprints/hauert_jtb02b.pdf"""
+
+    name = 'Firm But Fair'
+
+    @init_args
+    def __init__(self):
+        four_vector = (1, 0, 1, 2./3)
+        super(FirmButFair, self).__init__(four_vector)
+        self.set_four_vector(four_vector)
+
+
 class StochasticCooperator(MemoryOnePlayer):
     """Stochastic Cooperator, http://www.nature.com/ncomms/2013/130801/ncomms3193/full/ncomms3193.html."""
 

axelrod/tests/unit/test_memoryone.py

@@ -61,6 +61,31 @@ def test_allow_for_zero_probability(self):
         self.assertAlmostEqual(player._four_vector, expected)
 
 
+class TestFirmButFair(TestPlayer):
+
+    name = "Firm But Fair"
+    player = axelrod.FirmButFair
+    expected_classifier = {
+        'memory_depth': 1,
+        'stochastic': True,
+        'makes_use_of': set(),
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def test_four_vector(self):
+        expected_dictionary = {(C, C): 1, (C, D): 0, (D, C): 1, (D, D): 2./3}
+        test_four_vector(self, expected_dictionary)
+
+    def test_strategy(self):
+        self.first_play_test(C)
+        self.responses_test([C], [C], [C])
+        self.responses_test([C], [D], [D])
+        self.responses_test([D], [C], [C])
+        self.responses_test([D], [D], [C], random_seed=1)
+        self.responses_test([D], [D], [D], random_seed=2)
+
 class TestStochasticCooperator(TestPlayer):
 
     name = "Stochastic Cooperator"

docs/tutorials/further_topics/classification_of_strategies.rst

@@ -24,13 +24,13 @@ This allows us to, for example, quickly identify all the stochastic
 strategies::
 
     >>> len([s for s in axl.strategies if s().classifier['stochastic']])
-    37
+    38
 
 Or indeed find out how many strategy only use 1 turn worth of memory to
 make a decision::
 
     >>> len([s for s in axl.strategies if s().classifier['memory_depth']==1])
-    17
+    18
 
 We can also identify strategies that make use of particular properties of the
 tournament. For example, here is the number of strategies that  make use of the