def test_complete(self):
"""A complete graph should produce the same results as the default
case."""
seeds = range(0, 5)
players = []
N = 6
interaction_graph = axl.graph.complete_graph(N, loops=False)
reproduction_graph = axl.graph.Graph(
interaction_graph.edges, directed=interaction_graph.directed)
reproduction_graph.add_loops()
for _ in range(N // 2):
players.append(axl.Cooperator())
players.append(axl.Defector())
for seed in seeds:
mp = MoranProcess(players, seed=seed)
mp.play()
winner = mp.winning_strategy_name
mp = MoranProcess(players,
interaction_graph=interaction_graph,
reproduction_graph=reproduction_graph,
seed=seed)
mp.play()
winner2 = mp.winning_strategy_name
self.assertEqual(winner, winner2)
def test_seeding_inequality(self):
players = [axl.Random(x) for x in (0.2, 0.4, 0.6, 0.8)]
mp1 = MoranProcess(players, seed=0)
mp1.play()
mp2 = MoranProcess(players, seed=1)
mp2.play()
self.assertNotEqual(mp1, mp2)
def test_cycle_death_birth(self):
"""Test that death-birth can have different outcomes in the graph
case."""
seeds = [(1, True), (3, False)]
players = []
N = 6
graph = axl.graph.cycle(N)
for _ in range(N // 2):
players.append(axl.Cooperator())
for _ in range(N // 2):
players.append(axl.Defector())
for seed, outcome in seeds:
mp = MoranProcess(players,
interaction_graph=graph,
mode="bd",
seed=seed)
mp.play()
winner = mp.winning_strategy_name
mp = MoranProcess(players,
interaction_graph=graph,
mode="db",
seed=seed)
mp.play()
winner2 = mp.winning_strategy_name
self.assertEqual((winner == winner2), outcome)
def test_seeding_equality(self, seed):
players = [axl.Random(x) for x in (0.2, 0.4, 0.6, 0.8)]
mp1 = MoranProcess(players, seed=seed)
mp1.play()
mp2 = MoranProcess(players, seed=seed)
mp2.play()
self.assertEqual(mp1.populations, mp2.populations)
def test_mutate(self):
"""Test that a mutated player is returned"""
players = axl.Cooperator(), axl.Defector(), axl.TitForTat()
mp = MoranProcess(players, mutation_rate=0.5, seed=0)
self.assertEqual(mp.mutate(0), players[0])
mp = MoranProcess(players, mutation_rate=0.5, seed=2)
self.assertEqual(mp.mutate(0), players[2])
mp = MoranProcess(players, mutation_rate=0.5, seed=7)
self.assertEqual(mp.mutate(0), players[1])
def test_death_in_bd(self):
players = axl.Cooperator(), axl.Defector(), axl.TitForTat()
edges = [(0, 1), (2, 0), (1, 2)]
graph = axl.graph.Graph(edges, directed=True)
mp = MoranProcess(players, mode="bd", interaction_graph=graph, seed=1)
self.assertEqual(mp.death(0), 1)
mp = MoranProcess(players, mode="bd", interaction_graph=graph, seed=2)
self.assertEqual(mp.death(0), 1)
mp = MoranProcess(players, mode="bd", interaction_graph=graph, seed=3)
self.assertEqual(mp.death(0), 0)
def test_death_in_db(self):
players = axl.Cooperator(), axl.Defector(), axl.TitForTat()
mp = MoranProcess(players, mutation_rate=0.5, mode="db", seed=1)
self.assertEqual(mp.death(), 2)
self.assertEqual(mp.dead, 2)
mp = MoranProcess(players, mutation_rate=0.5, mode="db", seed=2)
self.assertEqual(mp.death(), 0)
self.assertEqual(mp.dead, 0)
mp = MoranProcess(players, mutation_rate=0.5, mode="db", seed=9)
self.assertEqual(mp.death(), 1)
self.assertEqual(mp.dead, 1)
def test_different_game(self):
# Possible for Cooperator to become fixed when using a different game
p1, p2 = axl.Cooperator(), axl.Defector()
game = axl.Game(r=4, p=2, s=1, t=6)
mp = MoranProcess((p1, p2), turns=5, game=game, seed=88)
populations = mp.play()
self.assertEqual(mp.winning_strategy_name, str(p2))
def test_mutation_method_exceptions(self):
axelrod.seed(10)
cycle_length = 5
players = [axelrod.EvolvableCycler(cycle_length=cycle_length)
for _ in range(5)]
with self.assertRaises(ValueError):
MoranProcess(players, turns=10, mutation_method="random")
axelrod.seed(0)
players = [axelrod.Cycler(cycle="CD" * random.randint(2, 10))
for _ in range(10)]
mp = MoranProcess(players, turns=10, mutation_method="atomic")
with self.assertRaises(TypeError):
for _ in range(10):
next(mp)
def test_two_prob_end(self):
p1, p2 = axl.Random(), axl.TitForTat()
mp = MoranProcess((p1, p2), prob_end=0.5, seed=10)
populations = mp.play()
self.assertEqual(len(mp), 2)
self.assertEqual(len(populations), 2)
self.assertEqual(populations, mp.populations)
self.assertEqual(mp.winning_strategy_name, str(p1))
def test_two_players(self):
p1, p2 = axl.Cooperator(), axl.Defector()
mp = MoranProcess((p1, p2), seed=99)
populations = mp.play()
self.assertEqual(len(mp), 2)
self.assertEqual(len(populations), 2)
self.assertEqual(populations, mp.populations)
self.assertEqual(mp.winning_strategy_name, str(p2))
def test_death_birth_outcomes(self):
"""Show that birth-death and death-birth can produce different
outcomes."""
seeds = [(1, True), (23, False)]
players = []
N = 6
for _ in range(N // 2):
players.append(axl.Cooperator())
players.append(axl.Defector())
for seed, outcome in seeds:
mp = MoranProcess(players, mode="bd", seed=seed)
mp.play()
winner = mp.winning_strategy_name
mp = MoranProcess(players, mode="db", seed=seed)
mp.play()
winner2 = mp.winning_strategy_name
self.assertEqual((winner == winner2), outcome)
def test_two_random_players(self):
p1, p2 = axl.Random(p=0.5), axl.Random(p=0.25)
mp = MoranProcess((p1, p2), seed=66)
populations = mp.play()
self.assertEqual(len(mp), 2)
self.assertEqual(len(populations), 2)
self.assertEqual(populations, mp.populations)
self.assertEqual(mp.winning_strategy_name, str(p1))
def test_three_players(self):
players = [axl.Cooperator(), axl.Cooperator(), axl.Defector()]
mp = MoranProcess(players, seed=11)
populations = mp.play()
self.assertEqual(len(mp), 7)
self.assertEqual(len(populations), 7)
self.assertEqual(populations, mp.populations)
self.assertEqual(mp.winning_strategy_name, str(axl.Defector()))
def test_four_players(self):
players = [axl.Cooperator() for _ in range(3)]
players.append(axl.Defector())
mp = MoranProcess(players, seed=29)
populations = mp.play()
self.assertEqual(len(mp), 8)
self.assertEqual(len(populations), 8)
self.assertEqual(populations, mp.populations)
self.assertEqual(mp.winning_strategy_name, str(axl.Defector()))
def test_atomic_mutation_cycler(self):
axelrod.seed(10)
cycle_length = 5
players = [axelrod.EvolvableCycler(cycle_length=cycle_length)
for _ in range(5)]
mp = MoranProcess(players, turns=10, mutation_method="atomic")
population = mp.play()
self.assertEqual(mp.winning_strategy_name, 'EvolvableCycler: CDCDD, 5, 0.2, 1')
self.assertEqual(len(mp.populations), 19)
self.assertTrue(mp.fixated)
def test_death_birth(self):
"""Two player death-birth should fixate after one round."""
p1, p2 = axl.Cooperator(), axl.Defector()
seeds = range(0, 20)
for seed in seeds:
mp = MoranProcess((p1, p2), mode="db", seed=seed)
mp.play()
self.assertIsNotNone(mp.winning_strategy_name)
# Number of populations is 2: the original and the one after the first round.
self.assertEqual(len(mp.populations), 2)
def test_cycle(self):
"""A cycle should sometimes produce different results vs. the default
case."""
seeds = [(1, True), (3, False)]
players = []
N = 6
graph = axl.graph.cycle(N)
for _ in range(N // 2):
players.append(axl.Cooperator())
for _ in range(N // 2):
players.append(axl.Defector())
for seed, outcome in seeds:
mp = MoranProcess(players, seed=seed)
mp.play()
winner = mp.winning_strategy_name
mp = MoranProcess(players, interaction_graph=graph, seed=seed)
mp.play()
winner2 = mp.winning_strategy_name
self.assertEqual((winner == winner2), outcome)
