Merge pull request #748 from amkratz/master

Add Neg strategy and change 4 method names for consistency

axelrod/strategies/_strategies.py

@@ -47,6 +47,7 @@
 from .mindcontrol import MindController, MindWarper, MindBender
 from .mindreader import MindReader, ProtectedMindReader, MirrorMindReader
 from .mutual import Desperate, Hopeless, Willing
+from .negation import Negation
 from .oncebitten import OnceBitten, FoolMeOnce, ForgetfulFoolMeOnce, FoolMeForever
 from .prober import (Prober, Prober2, Prober3, Prober4, HardProber,
                      NaiveProber, RemorsefulProber)
@@ -157,6 +158,7 @@
     MindReader,
     MindWarper,
     MirrorMindReader,
+	Negation,
     NiceAverageCopier,
     Nydegger,
     OmegaTFT,

axelrod/strategies/negation.py

@@ -0,0 +1,35 @@
+import random
+from axelrod import Actions, Player, random_choice, flip_action, init_args
+from axelrod.strategy_transformers import TrackHistoryTransformer
+
+C, D = Actions.C, Actions.D
+
+class Negation(Player):
+    """
+    A player starts by cooperating or defecting randomly if it's their first move,
+     then simply doing the opposite of the opponents last move thereafter.
+
+    Names:
+
+    Negation - [http://www.prisoners-dilemma.com/competition.html]
+    """
+
+    name = "Negation"
+    classifier = {
+        'memory_depth': 1,
+        'stochastic': True,
+        'makes_use_of': set(),
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def strategy(self, opponent):
+        # Random first move
+        if not self.history:
+            return random_choice();
+
+        # Act opposite of opponent otherwise
+        return flip_action(opponent.history[-1])
+

axelrod/tests/unit/test_axelrod_first.py

@@ -247,7 +247,7 @@ def test_strategy(self):
         # Looks like Tit-For-Tat at first
         self.markov_test([C, D, C, D])
 
-    def test_affect_of_strategy(self):
+    def test_effect_of_strategy(self):
         """Plays a modified TFT."""
         self.responses_test([C, C, C], [C, C, C], [C, C, C])
         # Make sure that the retaliations are increasing

axelrod/tests/unit/test_negation.py

@@ -0,0 +1,25 @@
+"""Test for the Neg Strategy"""
+
+import axelrod
+from .test_player import TestPlayer
+
+C, D = axelrod.Actions.C, axelrod.Actions.D
+
+class TestNegation(TestPlayer):
+
+    name = "Negation"
+    player = axelrod.Negation
+    expected_classifier = {
+        'memory_depth': 1,
+        'stochastic': True,
+        'makes_use_of': set(),
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def test_effect_of_strategy(self):
+        """Repeats opposite of opponents last action."""
+        self.markov_test([D, C, D, C])
+

axelrod/tests/unit/test_titfortat.py

@@ -106,7 +106,7 @@ def test_strategy(self):
         """Starts by defecting"""
         self.first_play_test(D)
 
-    def test_affect_of_strategy(self):
+    def test_effect_of_strategy(self):
         """Will do opposite of what opponent does."""
         self.markov_test([D, C, D, C])
 
@@ -151,7 +151,7 @@ def test_strategy(self):
         """Starts by Defecting"""
         self.first_play_test(D)
 
-    def test_affect_of_strategy(self):
+    def test_effect_of_strategy(self):
         """Plays like TFT after the first move, repeating the opponents last move."""
         self.markov_test([C, D, C, D])
 
@@ -173,7 +173,7 @@ def test_strategy(self):
         """Starts by Cooperating"""
         self.first_play_test(C)
 
-    def test_affect_of_strategy(self):
+    def test_effect_of_strategy(self):
         """Will do opposite of what opponent does."""
         self.markov_test([D, C, D, C])
 

docs/reference/all_strategies.rst

@@ -102,6 +102,9 @@ Here are the docstrings of all the strategies in the library.
 .. automodule:: axelrod.strategies.mutual
    :members:
    :undoc-members:
+.. automodule:: axelrod.strategies.negation
+   :members:
+   :undoc-members:
 .. automodule:: axelrod.strategies.oncebitten
    :members:
    :undoc-members:

docs/tutorials/advanced/classification_of_strategies.rst

@@ -47,7 +47,7 @@ strategies::
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    37
+    38
 
 
 Or, to find out how many strategies only use 1 turn worth of memory to
@@ -58,7 +58,7 @@ make a decision::
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    24
+    25
 
 Multiple filters can be specified within the filterset dictionary. To specify a
 range of memory_depth values, we can use the 'min_memory_depth' and
@@ -70,7 +70,7 @@ range of memory_depth values, we can use the 'min_memory_depth' and
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    41
+    42
 
 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