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 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_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 strategy(opponent): cycle = detect_cycle(opponent.history, min_size=2) if cycle: if len(set(cycle)) > 1: return D return C