adds test for tree search functions. Adds doctstring for get_siblings and is_stochastic functions. Corrects syntax error when initializing history_by_cond in constructor

Author: edouardArgenson

axelrod/strategies/dbs.py

@@ -109,10 +109,10 @@ def __init__(self, discount_factor=.75, promotion_threshold=3,
         # easy and efficient
         # initial hypothesized policy is TitForTat
         self.history_by_cond = {
-            [(C, C)] = ([1], [1])
-            [(C, D)] = ([1], [1])
-            [(D, C)] = ([0], [1])
-            [(D, D)] = ([0], [1])
+            (C, C): ([1], [1]),
+            (C, D): ([1], [1]),
+            (D, C): ([0], [1]),
+            (D, D): ([0], [1])
         }
 
     def reset(self):
@@ -123,11 +123,13 @@ def reset(self):
         self.Pi = self.Rd   # policy used by MoveGen
         self.violation_counts = {}
         self.v = 0
-        self.history_by_cond = {}
-        self.history_by_cond[(C, C)] = ([1], [1])
-        self.history_by_cond[(C, D)] = ([1], [1])
-        self.history_by_cond[(D, C)] = ([0], [1])
-        self.history_by_cond[(D, D)] = ([0], [1])
+        self.history_by_cond = {
+            (C, C): ([1], [1]),
+            (C, D): ([1], [1]),
+            (D, C): ([0], [1]),
+            (D, D): ([0], [1])
+        }
+        
 
     def should_promote(self, r_plus, promotion_threshold=3):
         """
@@ -351,12 +353,20 @@ def __init__(self, own_action, pC, depth):
         self.own_action = own_action
 
     def get_siblings(self):
-        # siblings of a stochastic node get depth += 1 
+        """
+        Returns the siblings node of the current StochasticNode
+        There are two sibling which are DeterministicNodes, their depth
+        is equal to current node depth's + 1 
+        This function allows to build the tree
+        """
         opponent_c_choice = DeterministicNode(self.own_action, C, self.depth+1)
         opponent_d_choice = DeterministicNode(self.own_action, D, self.depth+1)
         return (opponent_c_choice, opponent_d_choice)
 
     def is_stochastic(self):
+        """
+        Returns True if self is a StochasticNode
+        """
         return True
 
 
@@ -373,9 +383,10 @@ def __init__(self, action1, action2, depth):
 
     def get_siblings(self, policy):
         """
-        build 2 siblings (C, X) and (D, X)
-        siblings of a DeterministicNode are Stochastic, and are of the
-        same depth
+        Returns the siblings node of the current DeterministicNode
+        Builds 2 siblings (C, X) and (D, X) that are StochasticNodes
+        Those siblings are of the same depth as the current node
+        Their probability pC are defined by the policy argument
         """
         c_choice = StochasticNode(
             C, policy[(self.action1, self.action2)], self.depth
@@ -386,6 +397,9 @@ def get_siblings(self, policy):
         return (c_choice, d_choice)
 
     def is_stochastic(self):
+        """
+        Returns True if self is a StochasticNode
+        """
         return False
 
     def get_value(self):
@@ -404,6 +418,11 @@ def create_policy(pCC, pCD, pDC, pDD):
     As defined in the reference, a Policy is a set of (prev_move, p) 
     where p is the probability to cooperate after prev_move,
     where prev_move can be (C, C), (C, D), (D, C) or (D, D)
+
+    Parameters
+
+    pCC, pCD, pDC, pDD : float
+        Must be between 0 and 1
     """
     return {(C, C): pCC, (C, D): pCD, (D, C): pDC, (D, D): pDD}
 
@@ -416,9 +435,11 @@ def action_to_int(action):
 
 def minimax_tree_search(begin_node, policy, max_depth):
     """
-    tree search function (minimax search procedure)
+    Tree search function (minimax search procedure)
     build by recursion the tree corresponding to a game against 
     opponent's policy, and solve it
+    Returns a tuple of two float, that are the utility of playing C,
+    and the utility of playing D
     """
     if begin_node.is_stochastic():
         # a stochastic node cannot has the same depth than its parent
@@ -459,7 +480,7 @@ def minimax_tree_search(begin_node, policy, max_depth):
 
 def MoveGen(outcome, policy, depth_search_tree=5):
     """
-    returns the best move considering opponent's policy and last move,
+    Returns the best move considering opponent's policy and last move,
     using tree-search procedure
     """
     current_node = DeterministicNode(outcome[0], outcome[1], depth=0)

axelrod/tests/strategies/test_dbs.py

@@ -3,6 +3,7 @@
 import axelrod
 import unittest
 from .test_player import TestPlayer
+from axelrod import dbs
 
 C, D = axelrod.Actions.C, axelrod.Actions.D
 
@@ -11,7 +12,7 @@ class TestNode(unittest.TestCase):
     """
     Test for the base class
     """
-    node = axelrod.dbs.Node()
+    node = dbs.Node()
 
     def test_get_siblings(self):
         with self.assertRaises(NotImplementedError) as context:
@@ -22,6 +23,189 @@ def test_is_stochastic(self):
             self.node.is_stochastic()
 
 
+class TestTreeSearch(unittest.TestCase):
+    """
+    A set of tests for the tree-search functions.
+    We test the answers of both minimax_tree_search and MoveGen
+    functions, against a set of classic policies (the answer being the
+    best move to play for the next turn, considering an income 
+    position (C, C), (C, D), (D, C) or (D, D))
+    For each policy, we test the answer for all income position
+    """
+    def setUp(self):
+        """
+        Initialization for tests.
+        """
+        # For each test, we check the answer againt each possible
+        # inputs, that are in self.input_pos
+        self.input_pos = [(C, C), (C, D), (D, C), (D, D)]
+        # We define the policies against which we are going to test
+        self.cooperator_policy = dbs.create_policy(1, 1, 1, 1)
+        self.defector_policy = dbs.create_policy(0, 0, 0, 0)
+        self.titForTat_policy = dbs.create_policy(1, 1, 0, 0)
+        self.alternator_policy = dbs.create_policy(0, 1, 0, 1)
+        self.grudger_policy = dbs.create_policy(1, 0, 0, 0)
+        self.random_policy = dbs.create_policy(.5, .5, .5, .5)
+
+    def test_minimaxTreeSearch_cooperator(self):
+        """
+        Tests the minimax_tree_search function when playing against a 
+        Cooperator player.
+        Output == 0 means Cooperate, 1 means Defect.
+        The best (hence expected) answer to Cooperator is to defect
+        whatever the input position is.
+        """
+        expected_output = [1, 1, 1, 1]
+        for inp, out in zip(self.input_pos, expected_output): 
+            begin_node = dbs.DeterministicNode(inp[0], inp[1], depth=0)
+            values = dbs.minimax_tree_search(begin_node, 
+                self.cooperator_policy, max_depth=5)
+            self.assertEqual(values.index(max(values)),out)
+
+    def test_MoveGen_cooperator(self):
+        """
+        Tests the MoveGen function when playing against a 
+        Cooperator player.
+        """
+        expected_output = [D, D, D, D]
+        for inp, out in zip(self.input_pos, expected_output): 
+            out_move = dbs.MoveGen(inp, self.cooperator_policy, 
+                depth_search_tree=5)
+            self.assertEqual(out_move, out)
+
+    def test_minimaxTreeSearch_defector(self):
+        """
+        Tests the minimax_tree_search function when playing against a 
+        Defector player.
+        The best answer to Defector is to always defect
+        """
+        expected_output = [1, 1, 1, 1]
+        for inp, out in zip(self.input_pos, expected_output): 
+            begin_node = dbs.DeterministicNode(inp[0], inp[1], depth=0)
+            values = dbs.minimax_tree_search(begin_node, 
+                self.defector_policy, max_depth=5)
+            self.assertEqual(values.index(max(values)),out)
+
+    def test_MoveGen_defector(self):
+        """
+        Tests the MoveGen function when playing against a 
+        Defector player.
+        """
+        expected_output = [D, D, D, D]
+        for inp, out in zip(self.input_pos, expected_output): 
+            out_move = dbs.MoveGen(inp, self.defector_policy, 
+                depth_search_tree=5)
+            self.assertEqual(out_move, out)
+
+    def test_minimaxTreeSearch_titForTat(self):
+        """
+        Tests the minimax_tree_search function when playing against a 
+        TitForTat player.
+        The best (hence expected) answer to TitFOrTat is to cooperate
+        whatever the input position is.
+        """
+        expected_output = [0, 0, 0, 0]
+        for inp, out in zip(self.input_pos, expected_output): 
+            begin_node = dbs.DeterministicNode(inp[0], inp[1], depth=0)
+            values = dbs.minimax_tree_search(begin_node, 
+                self.titForTat_policy, max_depth=5)
+            self.assertEqual(values.index(max(values)),out)
+
+    def test_last_node_titForTat(self):
+        """
+        Test that against TitForTat, for the last move, i.e. if tree
+        depth is 1, the algorithms defects for all input
+        """
+        expected_output = [1, 1, 1, 1]
+        for inp, out in zip(self.input_pos, expected_output): 
+            begin_node = dbs.DeterministicNode(inp[0], inp[1], depth=0)
+            values = dbs.minimax_tree_search(begin_node, 
+                self.titForTat_policy, max_depth=1)
+            self.assertEqual(values.index(max(values)),out)
+
+    def test_MoveGen_titForTat(self):
+        """
+        Tests the MoveGen function when playing against a 
+        TitForTat player.
+        """
+        expected_output = [C, C, C, C]
+        for inp, out in zip(self.input_pos, expected_output): 
+            out_move = dbs.MoveGen(inp, self.titForTat_policy, 
+                depth_search_tree=5)
+            self.assertEqual(out_move, out)
+
+    def test_minimaxTreeSearch_alternator(self):
+        """
+        Tests the minimax_tree_search function when playing against an 
+        Alternator player.
+        The best answer to Alternator is to always defect
+        """
+        expected_output = [1, 1, 1, 1]
+        for inp, out in zip(self.input_pos, expected_output): 
+            begin_node = dbs.DeterministicNode(inp[0], inp[1], depth=0)
+            values = dbs.minimax_tree_search(begin_node, 
+                self.alternator_policy, max_depth=5)
+            self.assertEqual(values.index(max(values)),out)
+
+    def test_MoveGen_alternator(self):
+        """
+        Tests the MoveGen function when playing against an 
+        Alternator player.
+        """
+        expected_output = [D, D, D, D]
+        for inp, out in zip(self.input_pos, expected_output): 
+            out_move = dbs.MoveGen(inp, self.random_policy, depth_search_tree=5)
+            self.assertEqual(out_move, out)
+
+    def test_minimaxTreeSearch_random(self):
+        """
+        Tests the minimax_tree_search function when playing against a 
+        Random player.
+        The best answer to Random is to always defect
+        """
+        expected_output = [1, 1, 1, 1]
+        for inp, out in zip(self.input_pos, expected_output): 
+            begin_node = dbs.DeterministicNode(inp[0], inp[1], depth=0)
+            values = dbs.minimax_tree_search(begin_node, 
+                self.random_policy, max_depth=5)
+            self.assertEqual(values.index(max(values)),out)
+
+    def test_MoveGen_random(self):
+        """
+        Tests the MoveGen function when playing against a 
+        Random player.
+        """
+        expected_output = [D, D, D, D]
+        for inp, out in zip(self.input_pos, expected_output): 
+            out_move = dbs.MoveGen(inp, self.random_policy, depth_search_tree=5)
+            self.assertEqual(out_move, out)
+
+    def test_minimaxTreeSearch_grudger(self):
+        """
+        Tests the minimax_tree_search function when playing against a 
+        Grudger player.
+        The best answer to Grudger is to cooperate if both cooperated
+        at last round, else it's to defect
+        """
+        expected_output = [0, 1, 1, 1]
+        for inp, out in zip(self.input_pos, expected_output): 
+            begin_node = dbs.DeterministicNode(inp[0], inp[1], depth=0)
+            values = dbs.minimax_tree_search(begin_node, 
+                self.grudger_policy, max_depth=5)
+            self.assertEqual(values.index(max(values)),out)
+
+    def test_MoveGen_grudger(self):
+        """
+        Tests the MoveGen function when playing against a 
+        Grudger player.
+        """
+        expected_output = [C, D, D, D]
+        for inp, out in zip(self.input_pos, expected_output): 
+            out_move = dbs.MoveGen(inp, 
+                self.grudger_policy, depth_search_tree=5)
+            self.assertEqual(out_move, out)
+
+
 class TestDBS(TestPlayer):
     name = "DBS: 0.75, 3, 4, 3, 5"
     player = axelrod.DBS