fixed freq analyzer test

Author: miller-ian

axelrod/strategies/_strategies.py

@@ -238,7 +238,7 @@
 )
 from .shortmem import ShortMem
 from .stalker import Stalker
-from .frequency_analyzer import FreqAnalyzer
+from .frequency_analyzer import FrequencyAnalyzer
 from .titfortat import (
     AdaptiveTitForTat,
     Alexei,
@@ -367,7 +367,7 @@
     ForgivingTitForTat,
     Fortress3,
     Fortress4,
-    FreqAnalyzer,
+    FrequencyAnalyzer,
     GTFT,
     GeneralSoftGrudger,
     GoByMajority,

axelrod/strategies/frequency_analyzer.py

@@ -7,7 +7,7 @@
 
 C, D = Action.C, Action.D
 
-class FreqAnalyzer(Player):
+class FrequencyAnalyzer(Player):
     """
     A player starts by playing TitForTat for the first 30 turns (dataset generation phase). 
 
@@ -38,11 +38,11 @@ class FreqAnalyzer(Player):
 
     Names:
 
-    - FreqAnalyzer (FREQ): Original by Ian Miller
+    - FrequencyAnalyzer (FREQ): Original by Ian Miller
     """
 
     # These are various properties for the strategy
-    name = "FreqAnalyzer"
+    name = "FrequencyAnalyzer"
     classifier = {
         "memory_depth": float("inf"),
         "stochastic": False,
@@ -59,7 +59,7 @@ def __init__(self) -> None:
             The probability to cooperate
         """
         super().__init__()
-        self.minimum_cooperation_ratio = 0.5
+        self.minimum_cooperation_ratio = 0.8
         self.frequency_table = dict()
         self.last_sequence = ''
         self.current_sequence = ''
@@ -69,7 +69,6 @@ def strategy(self, opponent: Player) -> Action:
         if len(self.history) > 5:
             self.last_sequence = str(opponent.history[-3]) + str(self.history[-3]) + str(opponent.history[-2]) + str(self.history[-2])
             self.current_sequence = str(opponent.history[-2]) + str(self.history[-2]) + str(opponent.history[-1]) + str(self.history[-1])
-
             self.update_table(opponent)
 
         if len(self.history) < 30:
@@ -97,16 +96,10 @@ def strategy(self, opponent: Player) -> Action:
                 return C
 
     def update_table(self, opponent: Player):
-        print(self.frequency_table)
-        print("___________________")
-        print("current sequence is {}", self.last_sequence)
         if self.last_sequence in self.frequency_table.keys():
-            print("seen this key before")
-            print("freq table keys = {}", self.frequency_table.keys())
             results = self.frequency_table[self.last_sequence]
             results.append(opponent.history[-1])
             self.frequency_table[self.last_sequence] = results
         else:
-            print("not seen this key ever")
             self.frequency_table[self.last_sequence] = [opponent.history[-1]]
 

axelrod/strategies/titfortat.py

@@ -950,5 +950,4 @@ def strategy(self, opponent):
             # Cooperate with 0.9
             return self._random.random_choice(0.9)
         # Else TFT. Opponent played D, so play D in return.
-        return D
-    
+        return D

axelrod/tests/strategies/test_frequency_analyzer.py

@@ -0,0 +1,54 @@
+"""Tests for the FrequencyAnalyzer strategy."""
+
+import axelrod as axl
+
+from .test_player import TestPlayer
+
+C, D = axl.Action.C, axl.Action.D
+
+
+class Test(TestPlayer):
+
+    name = "FrequencyAnalyzer"
+    player = axl.FrequencyAnalyzer
+    expected_classifier = {
+        "memory_depth": float("inf"),
+        "stochastic": False,
+        "long_run_time": False,
+        "makes_use_of": set(),
+        "inspects_source": False,
+        "manipulates_source": False,
+        "manipulates_state": False,
+    }
+
+    def test_strategy_early(self):
+        # Test games that end while still in dataset generation phase (<30 turns)
+        opponent_actions = [C, C, D, C, D]
+        expected = [(C, C), (C, C), (C, D), (D, C), (C, D)]
+        self.versus_test(
+            axl.MockPlayer(opponent_actions), expected_actions=expected, seed=4
+        )
+
+    def test_strategy_defector(self):
+        # Test against all defections
+        opponent_actions = [D] * 30
+        expected = [(C, D)] + [(D, D)] * 29
+        self.versus_test(
+            axl.MockPlayer(opponent_actions), expected_actions=expected, seed=4
+        )
+
+    def test_strategy_cooperator(self):
+        # Test games that end while still in dataset generation phase (<30 turns)
+        opponent_actions = [C] * 30
+        expected = [(C, C)] * 30
+        self.versus_test(
+            axl.MockPlayer(opponent_actions), expected_actions=expected, seed=4
+        )
+    
+    def test_strategy_random(self):
+        # Test of 50 turns against random strategy
+        opponent_actions = [C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, D, C, C, C, C, D, D, C, C, C, D, D, D, C, C, D, D, D, D]
+        expected = [(C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (C, C), (D, C), (C, D), (D, C), (C, C), (C, C), (D, C), (D, D), (D, D), (D, C), (C, C), (D, C), (D, D), (D, D), (D, D), (D, C), (D, C), (C, D), (D, D), (D, D), (D, D)]
+        self.versus_test(
+            axl.MockPlayer(opponent_actions), expected_actions=expected, seed=4
+        )

docs/reference/strategy_index.rst

@@ -48,6 +48,8 @@ Here are the docstrings of all the strategies in the library.
    :members:
 .. automodule:: axelrod.strategies.forgiver
    :members:
+.. automodule:: axelrod.strategies.frequencyanalyzer
+   :members:
 .. automodule:: axelrod.strategies.gambler
    :members:
 .. automodule:: axelrod.strategies.gobymajority