Rename SecondByDowning -> RevisedDowning.

I have moved this to it's own module/file.

Author: drvinceknight

axelrod/strategies/_strategies.py

@@ -26,7 +26,6 @@
     SecondByCave,
     SecondByChampion,
     SecondByColbert,
-    SecondByDowning,
     SecondByEatherley,
     SecondByGetzler,
     SecondByGladstein,
@@ -190,6 +189,7 @@
     Retaliate2,
     Retaliate3,
 )
+from .revised_downing import RevisedDowning
 from .selfsteem import SelfSteem
 from .sequence_player import SequencePlayer, ThueMorse, ThueMorseInverse
 from .shortmem import ShortMem
@@ -367,7 +367,7 @@
     MindReader,
     MindWarper,
     MirrorMindReader,
-    SecondByDowning,
+    RevisedDowning,
     SecondByGrofman,
     SecondByTidemanAndChieruzzi,
     Negation,

axelrod/strategies/axelrod_second.py

@@ -61,72 +61,6 @@ def strategy(self, opponent: Player) -> Action:
                 return D
         return C
 
-class SecondByDowning(Player):
-    """
-    Strategy submitted to Axelrod's second tournament by Leslie Downing.
-    (K59R).
-
-    Revised Downing attempts to determine if players are cooperative or not.
-    If so, it cooperates with them.
-
-    This strategy is a revision of the strategy submitted by Downing to
-    Axelrod's first tournament.
-
-
-    Names:
-    - Revised Downing: [Axelrod1980]_
-    """
-
-    name = "Second by Downing"
-
-    classifier = {
-        "memory_depth": float("inf"),
-        "stochastic": False,
-        "makes_use_of": set(),
-        "long_run_time": False,
-        "inspects_source": False,
-        "manipulates_source": False,
-        "manipulates_state": False,
-    }
-
-    def __init__(self) -> None:
-        super().__init__()
-        self.good = 1.0
-        self.bad = 0.0
-        self.nice1 = 0
-        self.nice2 = 0
-        self.total_C = 0  # note the same as self.cooperations
-        self.total_D = 0  # note the same as self.defections
-
-    def strategy(self, opponent: Player) -> Action:
-        round_number = len(self.history) + 1
-
-        if round_number == 1:
-            return C
-
-        # Update various counts
-        if round_number > 2:
-            if self.history[-1] == D:
-                if opponent.history[-1] == C:
-                    self.nice2 += 1
-                self.total_D += 1
-                self.bad = self.nice2 / self.total_D
-            else:
-                if opponent.history[-1] == C:
-                    self.nice1 += 1
-                self.total_C += 1
-                self.good = self.nice1 / self.total_C
-        # Make a decision based on the accrued counts
-        c = 6.0 * self.good - 8.0 * self.bad - 2
-        alt = 4.0 * self.good - 5.0 * self.bad - 1
-        if c >= 0 and c >= alt:
-            move = C
-        elif (c >= 0 and c < alt) or (alt >= 0):
-            move = self.history[-1].flip()
-        else:
-            move = D
-        return move
-
 class SecondByEatherley(Player):
     """
     Strategy submitted to Axelrod's second tournament by Graham Eatherley.

axelrod/strategies/revised_downing.py

@@ -0,0 +1,75 @@
+"""
+Revised Downing implemented from the Fortran source code for the second of
+Axelrod's tournaments.
+"""
+from axelrod.action import Action
+from axelrod.player import Player
+
+C, D = Action.C, Action.D
+
+class RevisedDowning(Player):
+    """
+    Strategy submitted to Axelrod's second tournament by Leslie Downing.
+    (K59R).
+
+    Revised Downing attempts to determine if players are cooperative or not.
+    If so, it cooperates with them.
+
+    This strategy is a revision of the strategy submitted by Downing to
+    Axelrod's first tournament.
+
+
+    Names:
+    - Revised Downing: [Axelrod1980]_
+    """
+
+    name = "Revised Downing"
+
+    classifier = {
+        "memory_depth": float("inf"),
+        "stochastic": False,
+        "makes_use_of": set(),
+        "long_run_time": False,
+        "inspects_source": False,
+        "manipulates_source": False,
+        "manipulates_state": False,
+    }
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.good = 1.0
+        self.bad = 0.0
+        self.nice1 = 0
+        self.nice2 = 0
+        self.total_C = 0  # note the same as self.cooperations
+        self.total_D = 0  # note the same as self.defections
+
+    def strategy(self, opponent: Player) -> Action:
+        round_number = len(self.history) + 1
+
+        if round_number == 1:
+            return C
+
+        # Update various counts
+        if round_number > 2:
+            if self.history[-1] == D:
+                if opponent.history[-1] == C:
+                    self.nice2 += 1
+                self.total_D += 1
+                self.bad = self.nice2 / self.total_D
+            else:
+                if opponent.history[-1] == C:
+                    self.nice1 += 1
+                self.total_C += 1
+                self.good = self.nice1 / self.total_C
+        # Make a decision based on the accrued counts
+        c = 6.0 * self.good - 8.0 * self.bad - 2
+        alt = 4.0 * self.good - 5.0 * self.bad - 1
+        if c >= 0 and c >= alt:
+            move = C
+        elif (c >= 0 and c < alt) or (alt >= 0):
+            move = self.history[-1].flip()
+        else:
+            move = D
+        return move
+

axelrod/tests/strategies/test_axelrod_second.py

@@ -2032,39 +2032,3 @@ def test_strategy(self):
         self.versus_test(axelrod.Random(0.5), expected_actions=actions, seed=7)
 
 
-class TestSeconodByDowning(TestPlayer):
-
-    name = "Second by Downing"
-    player = axelrod.SecondByDowning
-    expected_classifier = {
-        "memory_depth": float("inf"),
-        "stochastic": False,
-        "makes_use_of": set(),
-        "long_run_time": False,
-        "inspects_source": False,
-        "manipulates_source": False,
-        "manipulates_state": False,
-    }
-
-    def test_strategy(self):
-        actions = [(C, C), (C, C), (C, C)]
-        self.versus_test(axelrod.Cooperator(), expected_actions=actions)
-
-        actions = [(C, D), (C, D), (D, D)]
-        self.versus_test(axelrod.Defector(), expected_actions=actions)
-
-        opponent = axelrod.MockPlayer(actions=[D, C, C])
-        actions = [(C, D), (C, C), (C, C), (C, D)]
-        self.versus_test(opponent, expected_actions=actions)
-
-        opponent = axelrod.MockPlayer(actions=[D, D, C])
-        actions = [(C, D), (C, D), (D, C), (D, D)]
-        self.versus_test(opponent, expected_actions=actions)
-
-        opponent = axelrod.MockPlayer(actions=[C, C, D, D, C, C])
-        actions = [(C, C), (C, C), (C, D), (C, D), (D, C), (D, C), (D, C)]
-        self.versus_test(opponent, expected_actions=actions)
-
-        opponent = axelrod.MockPlayer(actions=[C, C, C, C, D, D])
-        actions = [(C, C), (C, C), (C, C), (C, C), (C, D), (C, D), (C, C)]
-        self.versus_test(opponent, expected_actions=actions)

axelrod/tests/test_revised_downing.py

@@ -0,0 +1,40 @@
+from .test_player import TestPlayer
+
+C, D = axelrod.Action.C, axelrod.Action.D
+
+class TestRevisedDowning(TestPlayer):
+
+    name = "Revised Downing"
+    player = axelrod.RevisedDowning
+    expected_classifier = {
+        "memory_depth": float("inf"),
+        "stochastic": False,
+        "makes_use_of": set(),
+        "long_run_time": False,
+        "inspects_source": False,
+        "manipulates_source": False,
+        "manipulates_state": False,
+    }
+
+    def test_strategy(self):
+        actions = [(C, C), (C, C), (C, C)]
+        self.versus_test(axelrod.Cooperator(), expected_actions=actions)
+
+        actions = [(C, D), (C, D), (D, D)]
+        self.versus_test(axelrod.Defector(), expected_actions=actions)
+
+        opponent = axelrod.MockPlayer(actions=[D, C, C])
+        actions = [(C, D), (C, C), (C, C), (C, D)]
+        self.versus_test(opponent, expected_actions=actions)
+
+        opponent = axelrod.MockPlayer(actions=[D, D, C])
+        actions = [(C, D), (C, D), (D, C), (D, D)]
+        self.versus_test(opponent, expected_actions=actions)
+
+        opponent = axelrod.MockPlayer(actions=[C, C, D, D, C, C])
+        actions = [(C, C), (C, C), (C, D), (C, D), (D, C), (D, C), (D, C)]
+        self.versus_test(opponent, expected_actions=actions)
+
+        opponent = axelrod.MockPlayer(actions=[C, C, C, C, D, D])
+        actions = [(C, C), (C, C), (C, C), (C, C), (C, D), (C, D), (C, C)]
+        self.versus_test(opponent, expected_actions=actions)