Merge pull request #990 from eric-s-s/884-gbm

#884 gobymajority

Author: meatballs

axelrod/strategies/gobymajority.py

@@ -1,7 +1,7 @@
 from axelrod.actions import Actions, Action
 from axelrod.player import Player
 
-from typing import Dict, Any
+from typing import Dict, Any, Union
 
 import copy
 
@@ -30,23 +30,24 @@ class GoByMajority(Player):
         'manipulates_source': False,
         'manipulates_state': False,
         'memory_depth': float('inf')
-    } # type: Dict[str, Any]
+    }  # type: Dict[str, Any]
 
-    def __init__(self, memory_depth: int = float('inf'), soft: bool = True) -> None:
+    def __init__(self, memory_depth: Union[int, float] = float('inf'),
+                 soft: bool = True) -> None:
         """
         Parameters
         ----------
-        memory_depth, int >= 0
+        memory_depth: int >= 0
             The number of rounds to use for the calculation of the cooperation
             and defection probabilities of the opponent.
-        soft, bool
+        soft: bool
             Indicates whether to cooperate or not in the case that the
             cooperation and defection probabilities are equal.
         """
 
         super().__init__()
         self.soft = soft
-        self.classifier['memory_depth']  = memory_depth
+        self.classifier['memory_depth'] = memory_depth
         if self.classifier['memory_depth'] < float('inf'):
             self.memory = self.classifier['memory_depth']
         else:
@@ -140,7 +141,7 @@ class HardGoByMajority(GoByMajority):
     """
     name = 'Hard Go By Majority'
 
-    def __init__(self, memory_depth: int = float('inf')) -> None:
+    def __init__(self, memory_depth: Union[int, float] = float('inf')) -> None:
         super().__init__(memory_depth=memory_depth, soft=False)
 
 

axelrod/tests/strategies/test_gobymajority.py

@@ -2,6 +2,7 @@
 
 import axelrod
 from .test_player import TestPlayer
+from axelrod import MockPlayer
 
 C, D = axelrod.Actions.C, axelrod.Actions.D
 
@@ -11,7 +12,6 @@ class TestHardGoByMajority(TestPlayer):
     name = "Hard Go By Majority"
     player = axelrod.HardGoByMajority
     default_soft = False
-    eq_play = D
 
     expected_classifier = {
         'stochastic': False,
@@ -23,62 +23,99 @@ class TestHardGoByMajority(TestPlayer):
         'manipulates_state': False
     }
 
-    def test_strategy(self):
-        # Starts by defecting.
-        self.first_play_test(self.eq_play)
-        # If opponent cooperates at least as often as they defect then the
-        # player defects.
-        self.responses_test([self.eq_play], [C, D, D, D], [D, D, C, C])
-        # If opponent defects strictly more often than they defect then the
-        # player defects.
-        self.responses_test([D], [C, C, D, D, C], [D, D, C, C, D])
-        # If opponent cooperates strictly more often than they defect then the
-        # player cooperates.
-        self.responses_test([C], [C, C, D, D, C], [D, C, C, C, D])
-
-    def test_default_soft(self):
+    def test_first_play(self):
+        self.first_play_test(D)
+
+    def test_memory_depth_infinite_soft_is_false(self):
+        init_kwargs = {}
+        if self.default_soft:
+            init_kwargs['soft'] = False
+
+        opponent_actions = [C] * 50 + [D] * 100 + [C] * 52
+        actions = ([(D, C)] + [(C, C)] * 49 + [(C, D)] * 50 + [(D, D)] * 50 +
+                   [(D, C)] * 51 + [(C, C)])
+        opponent = MockPlayer(actions=opponent_actions)
+        self.versus_test(opponent, expected_actions=actions,
+                         init_kwargs=init_kwargs)
+
+    def test_memory_depth_even_soft_is_false(self):
+        memory_depth = 4
+        init_kwargs = {'memory_depth': memory_depth}
+        if self.default_soft:
+            init_kwargs['soft'] = False
+
+        opponent = MockPlayer(actions=[C] * memory_depth + [D] * memory_depth)
+        actions = ([(D, C)] + [(C, C)] * 3 + [(C, D)] * 2 + [(D, D)] * 2 +
+                   [(D, C)] * 3 + [(C, C)])
+        self.versus_test(opponent, expected_actions=actions,
+                         init_kwargs=init_kwargs)
+
+    def test_memory_depth_odd(self):
+        memory_depth = 5
+        init_kwargs = {'memory_depth': memory_depth}
+        if self.default_soft:
+            first_action = [(C, C)]
+        else:
+            first_action = [(D, C)]
+        opponent = MockPlayer(actions=[C] * memory_depth + [D] * memory_depth)
+        actions = (first_action + [(C, C)] * 4 + [(C, D)] * 3 + [(D, D)] * 2 +
+                   [(D, C)] * 3 + [(C, C)] * 2)
+        self.versus_test(opponent, expected_actions=actions,
+                         init_kwargs=init_kwargs)
+
+    def test_default_values(self):
         player = self.player()
         self.assertEqual(player.soft, self.default_soft)
+        self.assertEqual(player.memory, 0)
 
 
 class TestGoByMajority(TestHardGoByMajority):
 
     name = "Soft Go By Majority"
     player = axelrod.GoByMajority
     default_soft = True
-    eq_play = C
 
-    def test_strategy(self):
-        # In case of equality (including first play), cooperates.
-        super().test_strategy()
+    def test_first_play(self):
+        self.first_play_test(C)
 
-        # Test tie break rule for soft=False
-        player = self.player(soft=False)
-        opponent = axelrod.Cooperator()
-        self.assertEqual('D', player.strategy(opponent))
+    def test_memory_depth_infinite_soft_is_true(self):
+        opponent_actions = [C] * 50 + [D] * 100 + [C] * 52
+        actions = ([(C, C)] * 50 + [(C, D)] * 51 + [(D, D)] * 49 +
+                   [(D, C)] * 50 + [(C, C)] * 2)
+        opponent = MockPlayer(actions=opponent_actions)
+        self.versus_test(opponent, expected_actions=actions)
 
-    def test_soft(self):
-        player = self.player(soft=True)
-        self.assertTrue(player.soft)
-        player = self.player(soft=False)
-        self.assertFalse(player.soft)
+    def test_memory_depth_even_soft_is_true(self):
+        memory_depth = 4
+        init_kwargs = {'memory_depth': memory_depth}
+
+        opponent = MockPlayer([C] * memory_depth + [D] * memory_depth)
+        actions = ([(C, C)] * 4 + [(C, D)] * 3 + [(D, D)] +
+                   [(D, C)] * 2 + [(C, C)] * 2)
+        self.versus_test(opponent, expected_actions=actions,
+                         init_kwargs=init_kwargs)
 
     def test_name(self):
         player = self.player(soft=True)
         self.assertEqual(player.name, "Soft Go By Majority")
         player = self.player(soft=False)
         self.assertEqual(player.name, "Hard Go By Majority")
+        player = self.player(memory_depth=5)
+        self.assertEqual(player.name, "Soft Go By Majority: 5")
 
-    def test_repr(self):
+    def test_str(self):
         player = self.player(soft=True)
         name = str(player)
         self.assertEqual(name, "Soft Go By Majority")
         player = self.player(soft=False)
         name = str(player)
         self.assertEqual(name, "Hard Go By Majority")
+        player = self.player(memory_depth=5)
+        name = str(player)
+        self.assertEqual(name, "Soft Go By Majority: 5")
 
 
-def factory_TestGoByRecentMajority(L, soft=True):
+def factory_TestGoByRecentMajority(memory_depth, soft=True):
 
     prefix = "Hard"
     prefix2 = "Hard"
@@ -88,12 +125,13 @@ def factory_TestGoByRecentMajority(L, soft=True):
 
     class TestGoByRecentMajority(TestPlayer):
 
-        name = "{} Go By Majority: {}".format(prefix, L)
-        player = getattr(axelrod, "{}GoByMajority{}".format(prefix2, L))
+        name = "{} Go By Majority: {}".format(prefix, memory_depth)
+        player = getattr(axelrod, "{}GoByMajority{}".format(prefix2,
+                                                            memory_depth))
 
         expected_classifier = {
             'stochastic': False,
-            'memory_depth': L,
+            'memory_depth': memory_depth,
             'makes_use_of': set(),
             'long_run_time': False,
             'inspects_source': False,
@@ -102,27 +140,31 @@ class TestGoByRecentMajority(TestPlayer):
         }
 
         def test_strategy(self):
-            # Test initial play.
+
             if soft:
                 self.first_play_test(C)
             else:
                 self.first_play_test(D)
 
-            self.responses_test([C], [C] * L,
-                                [C] * (L // 2 + 1) + [D] * (L // 2 - 1))
-            self.responses_test([D], [C] * L,
-                                [D] * (L // 2 + 1) + [C] * (L // 2 - 1))
-
-            # Test 50:50 play difference with soft
-            k = L
-            if L % 2 == 1:
-                k -= 1
+            # for example memory_depth=2 plays against [C, C, D, D]
+            # soft actions = [(C, C), (C, C), (C, D), (C, D)]
+            # hard actions = [(D, C), (C, C), (C, D), (D, D)]
+            opponent_actions = [C] * memory_depth + [D] * memory_depth
+            opponent = MockPlayer(actions=opponent_actions)
             if soft:
-                self.responses_test([C], [C] * k,
-                                    [C] * (k // 2) + [D] * (k // 2))
+                first_player_action = [C]
             else:
-                self.responses_test([D], [C] * k,
-                                    [C] * (k // 2) + [D] * (k // 2))
+                first_player_action = [D]
+            if memory_depth % 2 == 1 or soft:
+                cooperations = int(memory_depth * 1.5)
+            else:
+                cooperations = int(memory_depth * 1.5) - 1
+            defections = len(opponent_actions) - cooperations - 1
+            player_actions = (first_player_action + [C] * cooperations +
+                              [D] * defections)
+
+            actions = list(zip(player_actions, opponent_actions))
+            self.versus_test(opponent, expected_actions=actions)
 
     return TestGoByRecentMajority