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))
