def test_twenty_rounds_joss_for_noncyclers(self):
"""Uses axelrod.strategies.axelrod_first.FirstByJoss strategy for first 20 rounds"""
seed = 4
match = axl.Match((axl.FirstByJoss(), axl.AntiCycler()),
turns=20,
seed=seed)
match.play()
self.versus_test(axl.AntiCycler(),
expected_actions=match.result,
seed=seed)
def test_strategy(self):
player = self.player()
# Test against cyclers
for opponent in [
axelrod.CyclerCCD(),
axelrod.CyclerCCCD(),
axelrod.CyclerCCCCCD(),
axelrod.Alternator(),
]:
player.reset()
for i in range(50):
player.play(opponent)
self.assertEqual(player.history[-1], D)
# Test against non-cyclers and cooperators
axelrod.seed(43)
for opponent in [
axelrod.Random(),
axelrod.AntiCycler(),
axelrod.DoubleCrosser(),
axelrod.Cooperator(),
]:
player.reset()
for i in range(50):
player.play(opponent)
self.assertEqual(player.history[-1], C)
def test_strategy(self):
self.first_play_test(C)
player = self.player()
# Test against cyclers
for opponent in [
axelrod.CyclerCCD(),
axelrod.CyclerCCCD(),
axelrod.CyclerCCCCCD(),
axelrod.Alternator()
]:
player.reset()
for i in range(30):
player.play(opponent)
self.assertEqual(player.history[-1], D)
# Test against non-cyclers
axelrod.seed(40)
for opponent in [
axelrod.Random(),
axelrod.AntiCycler(),
axelrod.Cooperator(),
axelrod.Defector()
]:
player.reset()
for i in range(30):
player.play(opponent)
self.assertEqual(player.history[-1], C)
def test_has_no_cycles(self):
test_range = 100
player = axl.AntiCycler()
for _ in range(test_range):
player.play(axl.Cooperator())
contains_no_cycles = player.history
for slice_at in range(1, len(contains_no_cycles) + 1):
self.assertIsNone(detect_cycle(contains_no_cycles[:slice_at]))
def test_has_no_cycles(self):
player = axl.AntiCycler()
opponent = axl.Cooperator()
match = axl.Match((player, opponent), turns=100)
match.play()
contains_no_cycles = player.history
for slice_at in range(1, len(contains_no_cycles) + 1):
self.assertIsNone(detect_cycle(contains_no_cycles[:slice_at]))
def tft_strats():
strategies = [
axelrod.TitForTat(),
axelrod.Alternator(),
axelrod.CyclerCCD(),
axelrod.CyclerCCCD(),
axelrod.CyclerCCCCCD(),
axelrod.AntiCycler(),
axelrod.WinStayLoseShift(),
axelrod.FoolMeOnce()
]
return strategies
def main():
strategies = [
axelrod.Cooperator(),
axelrod.Defector(),
axelrod.Random(0.4),
axelrod.Random(0.5),
axelrod.Random(0.9),
axelrod.Alternator(),
axelrod.TitForTat(),
axelrod.GTFT(),
axelrod.WinStayLoseShift(),
axelrod.ZDGTFT2(),
axelrod.ZDExtort2(),
axelrod.TitFor2Tats(),
axelrod.TwoTitsForTat(),
axelrod.CyclerCCD(),
axelrod.CyclerCCCD(),
axelrod.CyclerCCCCCD(),
axelrod.HardTitForTat(),
axelrod.AntiCycler(),
axelrod.Grudger()
]
for opponent in strategies:
data_dict, test_results, estimate = infer_depth(opponent)
print opponent
print "-" * len(str(opponent))
print "Collected Data"
print_dict(data_dict)
C_count = sum(v[0] for (k, v) in data_dict.items())
D_count = sum(v[1] for (k, v) in data_dict.items())
print "C count, D count: %s, %s" % (C_count, D_count)
print "\nFisher Exact Tests"
print_dict(test_results)
print "\nEstimated Memory One Probabilities"
print_dict(estimate)
print
def test_strategy(self):
player = self.player()
# Test against cyclers
for opponent in [
axl.CyclerCCD(),
axl.CyclerCCCD(),
axl.CyclerCCCCCD(),
axl.Alternator(),
]:
player.reset()
match = Match((player, opponent), turns=50)
match.play()
self.assertEqual(player.history[-1], D)
# Test against non-cyclers and cooperators
for opponent in [
axl.Random(),
axl.AntiCycler(),
axl.DoubleCrosser(),
axl.Cooperator(),
]:
player.reset()
match = Match((player, opponent), turns=50, seed=43)
match.play()
self.assertEqual(player.history[-1], C)
