def test_convert_original_to_current(self): expected = { Plays(self_plays=(C, C), op_plays=(D, ), op_openings=()): C, Plays(self_plays=(D, ), op_plays=(D, D), op_openings=(C, )): D } original = {('', 'CC', 'D'): C, ('C', 'D', 'DD'): D} self.assertEqual(expected, convert_original_to_current(original))
def test_convert_original_to_current(self): expected = { Plays(self_plays=(C, C), op_plays=(D, ), op_openings=()): C, Plays(self_plays=(D, ), op_plays=(D, D), op_openings=(C, )): D, } original = {("", "CC", "D"): C, ("C", "D", "DD"): D} self.assertEqual(expected, convert_original_to_current(original))
def test_pattern_and_params_init_can_still_use_regular_tuple(self): pattern = (C, C) parameters = (1, 0, 0) player = axelrod.LookerUp(pattern=pattern, parameters=parameters) expected_lookup_table = { Plays((C, ), (), ()): C, Plays((D, ), (), ()): C } self.assertEqual(player.lookup_dict, expected_lookup_table)
def test_pattern_and_params_init_only_happens_if_both_are_present(self): default = {Plays((), (D, ), ()): D, Plays((), (C, ), ()): C} pattern = "CC" parameters = Plays(self_plays=0, op_plays=1, op_openings=0) player1 = axelrod.LookerUp(pattern=pattern) player2 = axelrod.LookerUp(parameters=parameters) self.assertEqual(player1.lookup_dict, default) self.assertEqual(player2.lookup_dict, default)
def test_set_memory_depth(self): mem_depth_1 = axl.LookerUp(pattern="CC", parameters=Plays(1, 0, 0)) self.assertEqual(axl.Classifiers["memory_depth"](mem_depth_1), 1) mem_depth_3 = axl.LookerUp(pattern="C" * 16, parameters=Plays(1, 3, 0)) self.assertEqual(axl.Classifiers["memory_depth"](mem_depth_3), 3) mem_depth_inf = axl.LookerUp(pattern="CC", parameters=Plays(0, 0, 1)) self.assertEqual(axl.Classifiers["memory_depth"](mem_depth_inf), float("inf"))
def test_pattern_and_params_init_pattern_is_string(self): pattern = "CCCC" parameters = Plays(1, 1, 0) player = axl.LookerUp(pattern=pattern, parameters=parameters) expected_lookup_table = { Plays((C,), (D,), ()): C, Plays((D,), (D,), ()): C, Plays((C,), (C,), ()): C, Plays((D,), (C,), ()): C, } self.assertEqual(player.lookup_dict, expected_lookup_table)
def test_pattern_and_params_init_pattern_is_tuple(self): pattern = (C, C, C, C) parameters = Plays(1, 1, 0) player = axelrod.LookerUp(pattern=pattern, parameters=parameters) expected_lookup_table = { Plays((C, ), (D, ), ()): C, Plays((D, ), (D, ), ()): C, Plays((C, ), (C, ), ()): C, Plays((D, ), (C, ), ()): C, } self.assertEqual(player.lookup_dict, expected_lookup_table)
def test_set_memory_depth(self): mem_depth_1 = axelrod.LookerUp(pattern="CC", parameters=Plays(1, 0, 0)) self.assertEqual(mem_depth_1.classifier["memory_depth"], 1) mem_depth_3 = axelrod.LookerUp(pattern="C" * 16, parameters=Plays(1, 3, 0)) self.assertEqual(mem_depth_3.classifier["memory_depth"], 3) mem_depth_inf = axelrod.LookerUp(pattern="CC", parameters=Plays(0, 0, 1)) self.assertEqual(mem_depth_inf.classifier["memory_depth"], float("inf"))
def test_set_memory_depth(self): mem_depth_1 = axelrod.LookerUp(pattern='CC', parameters=Plays(1, 0, 0)) self.assertEqual(mem_depth_1.classifier['memory_depth'], 1) mem_depth_3 = axelrod.LookerUp(pattern='C' * 16, parameters=Plays(1, 3, 0)) self.assertEqual(mem_depth_3.classifier['memory_depth'], 3) mem_depth_inf = axelrod.LookerUp(pattern='CC', parameters=Plays(0, 0, 1)) self.assertEqual(mem_depth_inf.classifier['memory_depth'], float('inf'))
def convert_key(old_key: tuple) -> Plays: opponent_start, player, opponent = old_key return Plays( self_plays=str_to_actions(player), op_plays=str_to_actions(opponent), op_openings=str_to_actions(opponent_start), )
def tournament_score_gambler(pattern, turns, repetitions, opponents, params): """Calculates the score of a gambler in a tournament.""" parameters = Plays(self_plays=params[0], op_plays=params[1], op_openings=params[2]) size = get_lookup_table_size(params) initial_action = [ np.random.choice([C, D], p=[pattern[0], 1 - pattern[0]]) for _ in range(size) ] player = axl.Gambler( pattern=pattern[1:], parameters=parameters, initial_actions=initial_action, ) opponents = [axl.MemoryOnePlayer(q) for q in opponents] players = opponents + [player] number_of_players = len(players) edges = [(i, number_of_players - 1) for i in range(number_of_players - 1)] tournament = axl.Tournament(players=players, turns=turns, edges=edges, repetitions=repetitions) results = tournament.play(progress_bar=False) return -np.mean(results.normalised_scores[-1])
def test_initial_actions_makes_up_missing_actions_with_c(self): initial_acitons = (D, ) table_depth_three = axelrod.LookerUp( initial_actions=initial_acitons, pattern="CCCCCCCC", parameters=Plays(3, 0, 0), ) self.assertEqual(table_depth_three.initial_actions, (D, C, C))
def test_convert_key(self): opponent_starting_plays = "" player_last_plays = "CC" opponent_last_plays = "D" old_key = (opponent_starting_plays, player_last_plays, opponent_last_plays) new_key = Plays(self_plays=(C, C), op_plays=(D,), op_openings=()) self.assertEqual(new_key, convert_key(old_key))
def test_zero_tables(self): """Test the corner case where n=0.""" anti_tft_pattern = "DC" parameters = Plays(self_plays=0, op_plays=1, op_openings=0) tft_vs_alternator = [(C, C)] + [(D, D), (C, C)] * 5 self.versus_test( axl.Alternator(), expected_actions=tft_vs_alternator, init_kwargs={"parameters": parameters, "pattern": anti_tft_pattern}, )
def test_lookup_table_display(self): player = axelrod.LookerUp(pattern='CCCC', parameters=Plays(self_plays=2, op_plays=0, op_openings=0)) self.assertEqual( player.lookup_table_display( ('self_plays', 'op_plays', 'op_openings')), ("self_plays | op_plays |op_openings\n" + " C, C , , : C,\n" + " C, D , , : C,\n" + " D, C , , : C,\n" + " D, D , , : C,\n"))
def test_lookup_table_init_supersedes_pattern_init(self): lookup_table = { ((C, ), (D, ), ()): D, ((D, ), (D, ), ()): D, ((C, ), (C, ), ()): D, ((D, ), (C, ), ()): D, } pattern = "CCCCCCCC" parameters = Plays(self_plays=1, op_plays=1, op_openings=1) player = axelrod.LookerUp(lookup_dict=lookup_table, pattern=pattern, parameters=parameters) self.assertEqual(player.lookup_dict, lookup_table)
def test_lookup_table_display(self): player = axl.LookerUp( pattern="CCCC", parameters=Plays(self_plays=2, op_plays=0, op_openings=0) ) self.assertEqual( player.lookup_table_display(("self_plays", "op_plays", "op_openings")), ( "self_plays | op_plays |op_openings\n" + " C, C , , : C,\n" + " C, D , , : C,\n" + " D, C , , : C,\n" + " D, D , , : C,\n" ), )
def test_create_lookup_table_keys(self): expected = [ Plays((C, C), (C, ), ()), Plays((C, C), (D, ), ()), Plays((C, D), (C, ), ()), Plays((C, D), (D, ), ()), Plays((D, C), (C, ), ()), Plays((D, C), (D, ), ()), Plays((D, D), (C, ), ()), Plays((D, D), (D, ), ()), ] actual = create_lookup_table_keys(player_depth=2, op_depth=1, op_openings_depth=0) self.assertEqual(actual, expected) self.assertIsInstance(actual[0], Plays)
def test_init(self): table = LookupTable(self.lookup_dict) self.assertEqual(table.table_depth, 2) self.assertEqual(table.player_depth, 2) self.assertEqual(table.op_depth, 1) self.assertEqual(table.op_openings_depth, 0) self.assertEqual( table.dictionary, { Plays(self_plays=(C, C), op_plays=(C, ), op_openings=()): C, Plays(self_plays=(C, C), op_plays=(D, ), op_openings=()): D, Plays(self_plays=(C, D), op_plays=(C, ), op_openings=()): D, Plays(self_plays=(C, D), op_plays=(D, ), op_openings=()): C, Plays(self_plays=(D, C), op_plays=(C, ), op_openings=()): C, Plays(self_plays=(D, C), op_plays=(D, ), op_openings=()): D, Plays(self_plays=(D, D), op_plays=(C, ), op_openings=()): D, Plays(self_plays=(D, D), op_plays=(D, ), op_openings=()): C }) self.assertIsInstance(next(iter(table.dictionary)), Plays)
def test_plays_assign_values(self): self.assertEqual(Plays(op_plays=2, self_plays=1, op_openings=3), Plays(1, 2, 3))
def test_plays_equals_tuple(self): self.assertEqual(Plays(1, 2, 3), (1, 2, 3))
def test_default_init(self): player = self.player() expected = {Plays((), (D, ), ()): D, Plays((), (C, ), ()): C} self.assertEqual(player.lookup_dict, expected) self.assertEqual(player.initial_actions, (C, ))
def test_make_keys_into_plays_always_returns_new_dict(self): old = {Plays((C, D), (C, ), ()): 1, Plays((D, D), (D, ), ()): 2} self.assertIsNot(old, make_keys_into_plays(old))