def test_has_no_cycles(self):
test_range = 100
player = AntiCycler()
for _ in range(test_range):
player.play(axelrod.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):
test_range = 100
player = AntiCycler()
for _ in range(test_range):
player.play(axelrod.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 strategy(self, opponent: Player) -> Action:
if self.cycle:
return D
cycle = detect_cycle(opponent.history, min_size=3)
if cycle:
if len(set(cycle)) > 1:
self.cycle = cycle
return D
return C
def strategy(self, opponent: Player) -> Action:
if self.cycle:
return D
cycle = detect_cycle(opponent.history, min_size=3)
if cycle:
if len(set(cycle)) > 1:
self.cycle = cycle
return D
return C
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 strategy(opponent):
if len(opponent.history) < 10:
return C
if len(opponent.history) == opponent.cooperations:
return C
if detect_cycle(opponent.history, offset=15):
return D
else:
return C
def strategy(self, opponent: Player) -> Action:
turn = len(self.history)
if turn == 20:
self.cycle = detect_cycle(opponent.history)
return self.extended_strategy(opponent)
if turn > 20:
return self.extended_strategy(opponent)
else:
play = self.joss_instance.strategy(opponent)
self.joss_instance.history.append(play)
return play
def strategy(self, opponent):
turn = len(self.history)
if turn == 20:
self.cycle = detect_cycle(opponent.history)
return self.extended_strategy(opponent)
if turn > 20:
return self.extended_strategy(opponent)
else:
play = self.joss_instance.strategy(opponent)
self.joss_instance.history.append(play)
return play
def strategy(self, opponent: Player) -> None:
if len(opponent.history) < 10:
return C
if len(opponent.history) == opponent.cooperations:
return C
if len(opponent.history) % 10 == 0:
# recheck
self.cycle = detect_cycle(opponent.history, offset=10, min_size=3)
if self.cycle:
return D
else:
return C
def test_edge_case_calculator_sees_cycles_of_size_ten(self):
seed = 3
ten_length_cycle = [C, D, C, C, D, C, C, C, D, C]
self.assertEqual(detect_cycle((ten_length_cycle * 2)),
tuple(ten_length_cycle))
ten_cycle_twenty_rounds = get_joss_strategy_actions(
ten_length_cycle * 2, indices_to_flip=[16])
opponent_actions = ten_length_cycle * 2 + [C, D, C]
expected = ten_cycle_twenty_rounds + [(D, C), (D, D), (D, C)]
self.versus_test(axelrod.MockPlayer(opponent_actions),
expected,
seed=seed)
def test_edge_case_calculator_sees_cycles_of_size_ten(self):
seed = 3
ten_length_cycle = [C, D, C, C, D, C, C, C, D, C]
self.assertEqual(detect_cycle((ten_length_cycle * 2)), tuple(ten_length_cycle))
ten_cycle_twenty_rounds = get_joss_strategy_actions(
ten_length_cycle * 2, indices_to_flip=[16]
)
opponent_actions = ten_length_cycle * 2 + [C, D, C]
expected = ten_cycle_twenty_rounds + [(D, C), (D, D), (D, C)]
self.versus_test(
axelrod.MockPlayer(actions=opponent_actions),
expected_actions=expected,
seed=seed,
)
def test_edge_case_calculator_ignores_cycles_gt_len_ten(self):
seed = 3
eleven_length_cycle = [D, D, C, C, D, C, C, C, D, C, D]
twenty_rounds_of_eleven_len_cycle = eleven_length_cycle + eleven_length_cycle[:
9]
twenty_rounds = get_joss_strategy_actions(
twenty_rounds_of_eleven_len_cycle, indices_to_flip=[19])
opponent_actions = twenty_rounds_of_eleven_len_cycle[:-1] + [D] + [
C, D
]
self.assertEqual(detect_cycle(opponent_actions),
tuple(eleven_length_cycle))
uses_tit_for_tat_after_twenty_rounds = twenty_rounds + [(D, C), (C, D)]
self.versus_test(axelrod.MockPlayer(opponent_actions),
uses_tit_for_tat_after_twenty_rounds,
seed=seed)
def test_edge_case_calculator_ignores_cycles_gt_len_ten(self):
seed = 3
eleven_length_cycle = [D, D, C, C, D, C, C, C, D, C, D]
twenty_rounds_of_eleven_len_cycle = (
eleven_length_cycle + eleven_length_cycle[:9]
)
twenty_rounds = get_joss_strategy_actions(
twenty_rounds_of_eleven_len_cycle, indices_to_flip=[19]
)
opponent_actions = twenty_rounds_of_eleven_len_cycle[:-1] + [D] + [C, D]
self.assertEqual(detect_cycle(opponent_actions), tuple(eleven_length_cycle))
uses_tit_for_tat_after_twenty_rounds = twenty_rounds + [(D, C), (C, D)]
self.versus_test(
axelrod.MockPlayer(actions=opponent_actions),
expected_actions=uses_tit_for_tat_after_twenty_rounds,
seed=seed,
)
def test_regression_test_can_detect_cycle_that_is_repeated_exactly_once(self):
self.assertEqual(detect_cycle([C, D, C, D]), (C, D))
self.assertEqual(detect_cycle([C, D, C, D, C]), (C, D))
def test_cycle_will_be_at_least_min_size(self):
self.assertEqual(detect_cycle([C, C, C, C], min_size=1), (C, ))
self.assertEqual(detect_cycle([C, C, C, C], min_size=2), (C, C))
def test_finds_cycle(self, cycle, period):
history = cycle * period
detected = detect_cycle(history)
self.assertIsNotNone(detected)
self.assertIn(''.join(map(str, detected)),
''.join(map(str, (cycle))))
def test_no_cycle(self):
history = [C, D, C, C]
self.assertIsNone(detect_cycle(history))
history = [D, D, C, C, C]
self.assertIsNone(detect_cycle(history))
def test_regression_test_can_detect_cycle_that_is_repeated_exactly_once(self):
self.assertEqual(detect_cycle([C, D, C, D]), (C, D))
self.assertEqual(detect_cycle([C, D, C, D, C]), (C, D))
def test_finds_cycle(self, cycle, period):
history = cycle * period
detected = detect_cycle(history)
self.assertIsNotNone(detected)
self.assertIn("".join(map(str, detected)), "".join(map(str, (cycle))))
def test_cycle_will_be_at_least_min_size(self):
self.assertEqual(detect_cycle([C, C, C, C], min_size=1), (C,))
self.assertEqual(detect_cycle([C, C, C, C], min_size=2), (C, C))
def test_finds_cycle(self, cycle, period):
history = cycle * period
self.assertIsNotNone(detect_cycle(history))
def test_min_size_greater_than_two_times_history_tail_returns_none(self):
self.assertIsNone(detect_cycle([C, C, C], min_size=2))
def test_cycle_that_never_fully_repeats_returns_none(self):
cycle = [C, D, D]
to_test = cycle + cycle[:-1]
self.assertIsNone(detect_cycle(to_test))
def test_min_size_greater_than_two_times_max_size_has_no_effect(self):
self.assertEqual(
detect_cycle([C, C, C, C, C, C, C, C], min_size=2, max_size=3), (C, C)
)
def test_cycle_greater_than_max_size_returns_none(self):
self.assertEqual(detect_cycle([C, C, D] * 2, min_size=1, max_size=3), (C, C, D))
self.assertIsNone(detect_cycle([C, C, D] * 2, min_size=1, max_size=2))
def test_min_size_greater_than_two_times_max_size_has_no_effect(self):
self.assertEqual(detect_cycle([C, C, C, C, C, C, C, C], min_size=2, max_size=3), (C, C))
def test_cycle_that_never_fully_repeats_returns_none(self):
cycle = [C, D, D]
to_test = cycle + cycle[:-1]
self.assertIsNone(detect_cycle(to_test))
def test_finds_cycle(self, cycle, period):
history = cycle * period
self.assertIsNotNone(detect_cycle(history))
def test_min_size_greater_than_two_times_history_tail_returns_none(self):
self.assertIsNone(detect_cycle([C, C, C], min_size=2))
def test_no_cycle(self):
history = [C, D, C, C]
self.assertIsNone(detect_cycle(history))
history = [D, D, C, C, C]
self.assertIsNone(detect_cycle(history))
def test_cycle_greater_than_max_size_returns_none(self):
self.assertEqual(detect_cycle([C, C, D] * 2, min_size=1, max_size=3), (C, C, D))
self.assertIsNone(detect_cycle([C, C, D] * 2, min_size=1, max_size=2))
def strategy(opponent):
cycle = detect_cycle(opponent.history, min_size=2)
if cycle:
if len(set(cycle)) > 1:
return D
return C
