def test_create_lookup_table_keys(self):
expected = [
(C, C, C), (C, C, D), (C, D, C), (C, D, D),
(D, C, C), (D, C, D), (D, D, C), (D, D, D)
]
actual = create_lookup_table_keys(1, 1, 1)
self.assertEqual(actual, expected)
def __init__(self,
plays,
op_plays,
op_start_plays,
initial_actions=None,
mutation_rate=None,
table=None):
self.PlayerClass = LookerUp
self.plays = plays
self.op_plays = op_plays
self.op_start_plays = op_start_plays
if not initial_actions:
table_depth = max(self.plays, self.op_plays, self.op_start_plays)
initial_actions = [choice(C, D) for _ in range(table_depth)]
self.initial_actions = initial_actions
if mutation_rate is None:
keys = create_lookup_table_keys(plays, op_plays, op_start_plays)
self.mutation_rate = 2 / len(keys)
else:
self.mutation_rate = mutation_rate
if table is None:
self.randomize()
else:
# Make sure to copy the lists
self.table = dict(table)
def parse_repr(cls, s):
elements = s.split(':')
plays, op_plays, op_start_plays = list(map(int, elements[:3]))
initial_actions, pattern = elements[-2:]
keys = create_lookup_table_keys(plays, op_plays, op_start_plays)
table = dict(zip(keys, pattern))
return cls(plays, op_plays, op_start_plays,
initial_actions=initial_actions, table=table)
def parse_repr(cls, s):
elements = s.split(':')
plays, op_plays, op_start_plays = list(map(int, elements[:3]))
initial_actions, pattern = elements[-2:]
keys = create_lookup_table_keys(plays, op_plays, op_start_plays)
table = dict(zip(keys, pattern))
return cls(plays,
op_plays,
op_start_plays,
initial_actions=initial_actions,
table=table)
def test_vector_to_instance(self):
plays, op_plays, op_start_plays = 1, 1, 1
player = axl.EvolvableGambler(parameters=(plays, op_plays,
op_start_plays))
vector = [random.random() for _ in range(8)]
player.receive_vector(vector)
keys = create_lookup_table_keys(player_depth=plays,
op_depth=op_plays,
op_openings_depth=op_start_plays)
action_dict = dict(zip(keys, vector))
self.assertEqual(player._lookup.dictionary, action_dict)
def test_player(self):
plays, op_plays, op_start_plays = 1, 1, 1
pattern = [0 for _ in range(8)]
gambler = GamblerParams(plays=plays, op_plays=op_plays,
op_start_plays=op_start_plays, pattern=pattern)
player = gambler.player()
keys = create_lookup_table_keys(player_depth=plays, op_depth=op_plays,
op_openings_depth=op_start_plays)
action_dict = dict(zip(keys, pattern))
self.assertEqual(player.lookup_dict, action_dict)
def test_zero_tables(self):
"""Test the corner case where n=0."""
pattern = "CD"
lookup_table_keys = create_lookup_table_keys(
plays=0, op_plays=2, op_start_plays=0)
lookup_table = dict(zip(lookup_table_keys, pattern))
player = axelrod.LookerUp(lookup_table)
self.assertEqual(player.plays, 0)
opp = axelrod.Cooperator()
# This shouldn't throw an exception.
for _ in range(5):
player.play(opp)
def test_zero_tables(self):
"""Test the corner case where n=0."""
pattern = "CD"
lookup_table_keys = create_lookup_table_keys(plays=0,
opponent_start_plays=1)
lookup_table = dict(zip(lookup_table_keys, pattern))
player = axelrod.LookerUp(lookup_table)
self.assertEqual(player.plays, 0)
opp = axelrod.Cooperator()
# This shouldn't throw an exception.
for _ in range(5):
player.play(opp)
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_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_vector_to_instance(self):
plays, op_plays, op_start_plays = 1, 1, 1
gambler_params = GamblerParams(plays=plays, op_plays=op_plays,
op_start_plays=op_start_plays)
vector = [random.random() for _ in range(8)]
gambler_params.receive_vector(vector)
instance = gambler_params.player()
keys = create_lookup_table_keys(player_depth=plays, op_depth=op_plays,
op_openings_depth=op_start_plays)
action_dict = dict(zip(keys, vector))
self.assertIsInstance(instance, axl.Gambler)
self.assertEqual(instance.lookup_dict, action_dict)
def __init__(self, plays, op_plays, op_start_plays, initial_actions=None,
mutation_probability=None, table=None):
self.PlayerClass = LookerUp
self.plays = plays
self.op_plays = op_plays
self.op_start_plays = op_start_plays
if not initial_actions:
table_depth = max(self.plays, self.op_plays, self.op_start_plays)
initial_actions = [random.choice([C, D]) for _ in range(table_depth)]
self.initial_actions = initial_actions
if mutation_probability is None:
keys = create_lookup_table_keys(plays, op_plays, op_start_plays)
self.mutation_probability = 2 / len(keys)
else:
self.mutation_probability = mutation_probability
if table is None:
self.randomize()
else:
# Make sure to copy the lists
self.table = dict(table)
def random_params(plays, op_plays, op_start_plays):
keys = create_lookup_table_keys(plays, op_plays, op_start_plays)
# To get a pattern, we just randomly pick between C and D for each key
pattern = ''.join([random.choice([C, D]) for _ in keys])
table = dict(zip(keys, pattern))
return table
def random_params(plays, op_plays, op_start_plays):
keys = create_lookup_table_keys(plays, op_plays, op_start_plays)
pattern = [random.random() for _ in keys]
return pattern
def random_params(plays, op_plays, op_start_plays):
keys = create_lookup_table_keys(plays, op_plays, op_start_plays)
pattern = [random.random() for _ in keys]
return pattern
def random_params(plays, op_plays, op_start_plays):
keys = create_lookup_table_keys(plays, op_plays, op_start_plays)
# To get a pattern, we just randomly pick between C and D for each key
pattern = [random.choice([C, D]) for _ in keys]
table = dict(zip(keys, pattern))
return table
