def test_endgame_remain_16(self):
board = BitBoard()
endgame = _EndGame(depth=16)
key = endgame.__class__.__name__ + str(os.getpid())
Measure.elp_time[key] = {'min': 10000, 'max': 0, 'ave': 0, 'cnt': 0}
Measure.count[key] = 0
color = 'black'
board._black_bitboard = 0xC07DBF650158381C
board._white_bitboard = 0x0009A7CA6C4E0
board.update_score()
self.assertEqual(endgame.next_move(color, board), (6, 6))
print()
print(key, 'remain = 16')
print(' min :', Measure.elp_time[key]['min'], '(s)')
print(' max :', Measure.elp_time[key]['max'], '(s)')
print(' ave :', Measure.elp_time[key]['ave'], '(s)')
print('(5417116 / 1.94s)', Measure.count[key])
def test_fullreading_remain_9(self):
class Test:
pass
board = BitBoard()
fullreading = _FullReading(remain=9, base=Test())
key = fullreading.__class__.__name__ + str(os.getpid())
Measure.elp_time[key] = {'min': 10000, 'max': 0, 'ave': 0, 'cnt': 0}
color = 'white'
# pattern 1
board._black_bitboard = 0x3FFFEE3E192CC07E
board._white_bitboard = 0x400011C0E4523900
board.update_score()
self.assertEqual(fullreading.next_move(color, board), (0, 0))
# pattern 2
board._black_bitboard = 0x81878F170B470000
board._white_bitboard = 0x7C387068F4381F3F
board.update_score()
self.assertEqual(fullreading.next_move(color, board), (6, 0))
# pattern 3
board._black_bitboard = 0xF27FBF650158381E
board._white_bitboard = 0x9AFEA6C4E0
board.update_score()
self.assertEqual(fullreading.next_move(color, board), (7, 7))
# pattern 4
board._black_bitboard = 0x5C2353046C3874BA
board._white_bitboard = 0x80DCACFB93850B00
board.update_score()
self.assertEqual(fullreading.next_move(color, board), (7, 0))
# pattern 5
board._black_bitboard = 0x828522161C1C07FF
board._white_bitboard = 0x4858DC69E3E3B800
board.update_score()
self.assertEqual(fullreading.next_move(color, board), (7, 2))
print()
print(key, 'remain = 9')
print(' min :', Measure.elp_time[key]['min'], '(s)')
print(' max :', Measure.elp_time[key]['max'], '(s)')
print(' ave :', Measure.elp_time[key]['ave'], '(s)')
def test_endgame_remain_12(self):
# Windows10 Celeron 1.6GHz 4.00GB
board = BitBoard()
endgame = _EndGame(depth=12)
key = endgame.__class__.__name__ + str(os.getpid())
Measure.elp_time[key] = {'min': 10000, 'max': 0, 'ave': 0, 'cnt': 0}
Measure.count[key] = 0
color = 'black'
board._black_bitboard = 0xF07DBF650158381C
board._white_bitboard = 0x2009A7EA6C4E0
board.update_score()
self.assertEqual(endgame.next_move(color, board), (7, 0))
print()
print(key, 'remain = 12')
print(' min :', Measure.elp_time[key]['min'], '(s)')
print(' max :', Measure.elp_time[key]['max'], '(s)')
print(' ave :', Measure.elp_time[key]['ave'], '(s)')
print('(101890 / 0.03s)', Measure.count[key])
def test_fullreading_remain_12(self):
class Test:
pass
board = BitBoard()
fullreading = _FullReading(remain=12, base=Test())
key = fullreading.__class__.__name__ + str(os.getpid())
Measure.elp_time[key] = {'min': 10000, 'max': 0, 'ave': 0, 'cnt': 0}
color = 'black'
board._black_bitboard = 0xF07DBF650158380E
board._white_bitboard = 0x0009AFEA6C4E0
board.update_score()
self.assertEqual(fullreading.next_move(color, board), (7, 6))
print()
print(key, 'remain = 12')
print(' min :', Measure.elp_time[key]['min'], '(s)')
print(' max :', Measure.elp_time[key]['max'], '(s)')
print(' ave :', Measure.elp_time[key]['ave'], '(s)')
def test_fullreading_next_move(self):
class Test:
def next_move(self, color, board):
return (3, 3)
board = BitBoard()
color = 'white'
board._black_bitboard = 0x3FFFEE3E192CC07E
board._white_bitboard = 0x400011C0E4523900
board.update_score()
# remain = 9 : base
fullreading = FullReading(remain=8, base=Test())
self.assertEqual(fullreading.next_move(color, board), (3, 3))
fullreading = _FullReading(remain=8, base=Test())
self.assertEqual(fullreading.next_move(color, board), (3, 3))
# remain = 8 : fullreading
board.put_disc(color, 0, 0)
color = 'black'
self.assertEqual(fullreading.next_move(color, board), (7, 5))
def test_endgame_get_best_move(self):
endgame = _EndGame_()
# O--OOOOX
# -OOOOOOX
# OOXXOOOX
# OOXOOOXX
# OOOOOOXX
# ---OOOOX
# ----O--X
# --------
# X
board = BitBoard()
board._black_bitboard = 0x0101312303010100
board._white_bitboard = 0x9E7ECEDCFC1E0800
board.update_score()
# depth=20 : black : a2
board.put_disc('black', 0, 1)
# depth=19 : white : b1
board.put_disc('white', 1, 0)
# depth=18 : black : c1
board.put_disc('black', 2, 0)
# depth=17 : white : --
# depth=17 : black : b6
board.put_disc('black', 1, 5)
# print(board)
# print(board._black_score, board._white_score)
# depth=16 : white : c7
self.assertEqual(
endgame.get_best_move('white', board,
board.get_legal_moves('white')),
((1, 6), {
(1, 6): -38.0,
(2, 6): -38.0
}))
board.put_disc('white', 2, 6)
# depth=15 : black : a7
self.assertEqual(
endgame.get_best_move('black', board,
board.get_legal_moves('black')),
((0, 6), {
(0, 5): 16.0,
(0, 6): 38.0,
(1, 7): 38.0,
(2, 5): 30.0,
(3, 6): 38.0,
(3, 7): 38.0,
(4, 7): 38.0,
(5, 6): 38.0,
(5, 7): 38.0,
(6, 6): 38.0
})) # noqa: E501
board.put_disc('black', 0, 6)
# depth=14 : white : b7
self.assertEqual(
endgame.get_best_move('white', board,
board.get_legal_moves('white')),
((1, 6), {
(1, 6): -38.0
}))
board.put_disc('white', 1, 6)
# depth=13 : black : b8
self.assertEqual(
endgame.get_best_move('black', board,
board.get_legal_moves('black')),
((1, 7), {
(0, 5): 8.0,
(1, 7): 38.0,
(2, 5): 36.0,
(3, 6): 36.0,
(3, 7): 38.0,
(4, 7): 38.0,
(5, 6): 36.0,
(5, 7): 38.0,
(6, 6): 36.0
})) # noqa: E501
board.put_disc('black', 1, 7)
# depth=12 : white : d7
self.assertEqual(
endgame.get_best_move('white', board,
board.get_legal_moves('white')),
((3, 6), {
(2, 5): -42.0,
(3, 6): -38.0,
(3, 7): -38.0
}))
board.put_disc('white', 3, 6)
# depth=11 : black : f8
self.assertEqual(
endgame.get_best_move('black', board,
board.get_legal_moves('black')),
((5, 7), {
(0, 5): 2.0,
(2, 5): 36.0,
(2, 7): 36.0,
(3, 7): 36.0,
(4, 7): 36.0,
(5, 6): 36.0,
(5, 7): 38.0,
(6, 6): 36.0
})) # noqa: E501
board.put_disc('black', 5, 7)
# depth=10 : white : c6
self.assertEqual(
endgame.get_best_move('white', board,
board.get_legal_moves('white')),
((2, 5), {
(2, 5): -38.0,
(3, 7): -38.0,
(4, 7): -38.0,
(5, 6): -38.0
})) # noqa: E501
board.put_disc('white', 2, 5)
# depth=9 : black : f7
self.assertEqual(
endgame.get_best_move('black', board,
board.get_legal_moves('black')),
((5, 6), {
(0, 5): -8.0,
(0, 7): 38.0,
(2, 7): 38.0,
(3, 7): 38.0,
(5, 6): 38.0,
(6, 6): 38.0
})) # noqa: E501
board.put_disc('black', 5, 6)
# depth=8 : white : g7
self.assertEqual(
endgame.get_best_move('white', board,
board.get_legal_moves('white')),
((6, 6), {
(4, 7): -38.0,
(6, 6): -38.0,
(6, 7): -38.0
}))
board.put_disc('white', 6, 6)
# depth=7 : black : a8
self.assertEqual(
endgame.get_best_move('black', board,
board.get_legal_moves('black')),
((0, 7), {
(0, 5): 6.0,
(0, 7): 38.0,
(2, 7): 38.0,
(3, 7): 38.0,
(4, 7): 38.0,
(6, 7): 38.0
})) # noqa: E501
board.put_disc('black', 0, 7)
# depth=6 : white : --
# depth=6 : black : d8
self.assertEqual(
endgame.get_best_move('black', board,
board.get_legal_moves('black')),
((3, 7), {
(0, 5): 34.0,
(2, 7): 34.0,
(3, 7): 38.0,
(4, 7): 38.0,
(6, 7): 38.0
})) # noqa: E501
board.put_disc('black', 3, 7)
# depth=5 : white : e8
self.assertEqual(
endgame.get_best_move('white', board,
board.get_legal_moves('white')),
((4, 7), {
(4, 7): -38.0
}))
board.put_disc('white', 4, 7)
# depth=4 : balck : c8
self.assertEqual(
endgame.get_best_move('black', board,
board.get_legal_moves('black')),
((2, 7), {
(0, 5): 22.0,
(2, 7): 38.0,
(6, 7): 38.0,
(7, 7): 38.0
})) # noqa: E501
board.put_disc('black', 2, 7)
# depth=3 : white ; g8
self.assertEqual(
endgame.get_best_move('white', board,
board.get_legal_moves('white')),
((6, 7), {
(6, 7): -38.0
}))
board.put_disc('white', 6, 7)
# depth=2 : balck : a6
self.assertEqual(
endgame.get_best_move('black', board,
board.get_legal_moves('black')),
((0, 5), {
(0, 5): 38.0,
(7, 7): 38.0
}))
board.put_disc('black', 0, 5)
# depth=1 : white : --
# depth=1 : black : h8
self.assertEqual(
endgame.get_best_move('black', board,
board.get_legal_moves('black')),
((7, 7), {
(7, 7): 38.0
}))
def test_specific_evaluator(self):
board8 = BitBoard(8)
board8.put_disc('black', 3, 2)
board8.put_disc('white', 2, 2)
board8.put_disc('black', 2, 3)
board8.put_disc('white', 4, 2)
board8.put_disc('black', 1, 1)
board8.put_disc('white', 0, 0)
possibility_b = board8.get_bit_count(
board8.get_legal_moves_bits('black'))
possibility_w = board8.get_bit_count(
board8.get_legal_moves_bits('white'))
# Evaluator_T
evaluator = coord.Evaluator_T()
score_b = evaluator.evaluate('black', board8, None, None)
score_w = evaluator.evaluate('white', board8, None, None)
self.assertEqual(score_b, -22)
self.assertEqual(score_w, -22)
# Evaluator_P
evaluator = coord.Evaluator_P()
score_b = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
self.assertEqual(score_b, 5)
# Evaluator_O
evaluator = coord.Evaluator_O()
score_b = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
self.assertEqual(score_b, -8.25)
# Evaluator_W
evaluator = coord.Evaluator_W()
board8._black_bitboard = 0xFFFFFFFFFFFFFFFF # black win
board8._white_bitboard = 0x0000000000000000
board8.update_score()
possibility_b = board8.get_bit_count(
board8.get_legal_moves_bits('black'))
possibility_w = board8.get_bit_count(
board8.get_legal_moves_bits('white'))
score_b = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
score_w = evaluator.evaluate('white', board8, possibility_b,
possibility_w)
self.assertEqual(score_b, 10064)
self.assertEqual(score_w, 10064)
board8._black_bitboard = 0x0000000000000000
board8._white_bitboard = 0xFFFFFFFFFFFFFFFF # white win
board8.update_score()
possibility_b = board8.get_bit_count(
board8.get_legal_moves_bits('black'))
possibility_w = board8.get_bit_count(
board8.get_legal_moves_bits('white'))
score_b = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
score_w = evaluator.evaluate('white', board8, possibility_b,
possibility_w)
self.assertEqual(score_b, -10064)
self.assertEqual(score_w, -10064)
# Evaluator_N
board8 = BitBoard(8)
board8.put_disc('black', 3, 2)
board8.put_disc('white', 2, 2)
board8.put_disc('black', 2, 3)
board8.put_disc('white', 4, 2)
board8.put_disc('black', 1, 1)
board8.put_disc('white', 0, 0)
possibility_b = board8.get_bit_count(
board8.get_legal_moves_bits('black'))
possibility_w = board8.get_bit_count(
board8.get_legal_moves_bits('white'))
evaluator = coord.Evaluator_N()
score_b = evaluator.evaluate('black', board8, None, None)
self.assertEqual(score_b, -6)
# Evaluator_N_Fast
evaluator = coord.Evaluator_N_Fast()
score_b = evaluator.evaluate('black', board8, None, None)
self.assertEqual(score_b, -6)
# Evaluator_E
evaluator = coord.Evaluator_E()
score_b = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
self.assertEqual(score_b, 0)
# Evaluator_C
evaluator = coord.Evaluator_C()
score_b = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
self.assertEqual(score_b, 0)
# Evaluator_B
evaluator = coord.Evaluator_B()
score_b = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
self.assertEqual(score_b, 19)
# Evaluator_Ec
evaluator = coord.Evaluator_Ec()
score_b = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
self.assertEqual(score_b, -16)
# Evaluator_TP
evaluator = coord.Evaluator_TP()
score_b = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
self.assertEqual(score_b, -17)
# Evaluator_TPO
evaluator = coord.Evaluator_TPO()
score_b = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
self.assertEqual(score_b, -25.25)
# Evaluator_NW
evaluator = coord.Evaluator_NW()
score = evaluator.evaluate(None, board8, None, None)
self.assertEqual(score, -10006)
score = evaluator.evaluate(None, board8, possibility_b, possibility_w)
self.assertEqual(score, -6)
# Evaluator_PW
evaluator = coord.Evaluator_PW()
score = evaluator.evaluate(None, board8, None, None)
self.assertEqual(score, -10006)
score = evaluator.evaluate(None, board8, possibility_b, possibility_w)
self.assertEqual(score, 5)
# Evaluator_TPW
evaluator = coord.Evaluator_TPW()
score = evaluator.evaluate(None, board8, None, None)
self.assertEqual(score, -10006)
score = evaluator.evaluate(None, board8, possibility_b, possibility_w)
self.assertEqual(score, -17)
# Evaluator_TPW_Fast
board8 = BitBoard(8)
board8.put_disc('black', 3, 2)
board8.put_disc('white', 2, 2)
board8.put_disc('black', 2, 3)
board8.put_disc('white', 4, 2)
board8.put_disc('black', 1, 1)
possibility_b = board8.get_bit_count(
board8.get_legal_moves_bits('black'))
possibility_w = board8.get_bit_count(
board8.get_legal_moves_bits('white'))
evaluator = coord.Evaluator_TPW_Fast()
score = evaluator.evaluate(None, board8, None, None)
self.assertEqual(score, 10001)
board8.put_disc('white', 0, 0)
possibility_b = board8.get_bit_count(
board8.get_legal_moves_bits('black'))
possibility_w = board8.get_bit_count(
board8.get_legal_moves_bits('white'))
score = evaluator.evaluate(None, board8, None, None)
self.assertEqual(score, -10006)
score = evaluator.evaluate(None, board8, possibility_b, possibility_w)
self.assertEqual(score, -17)
# Evaluator_TPOW
evaluator = coord.Evaluator_TPOW()
score_b = evaluator.evaluate('black', board8, None, None)
self.assertEqual(score_b, -10006)
score_b = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
self.assertEqual(score_b, -25.25)
# Evaluator_TPWE
evaluator = coord.Evaluator_TPWE()
board8._black_bitboard = 0x0000002010003C7E
possibility_b = board8.get_bit_count(
board8.get_legal_moves_bits('black'))
possibility_w = board8.get_bit_count(
board8.get_legal_moves_bits('white'))
score = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
self.assertEqual(score, -81)
board8._black_bitboard = 0x0000002010003C7C
score = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
self.assertEqual(score, -61)
score = evaluator.evaluate('black', board8, None, None)
self.assertEqual(score, -10006)
# Evaluator_TPWE_Fast
board8 = BitBoard(8)
board8.put_disc('black', 3, 2)
board8.put_disc('white', 2, 2)
board8.put_disc('black', 2, 3)
board8.put_disc('white', 4, 2)
board8.put_disc('black', 1, 1)
possibility_b = board8.get_bit_count(
board8.get_legal_moves_bits('black'))
possibility_w = board8.get_bit_count(
board8.get_legal_moves_bits('white'))
evaluator = coord.Evaluator_TPWE_Fast()
score = evaluator.evaluate(None, board8, None, None)
self.assertEqual(score, 10001)
board8.put_disc('white', 0, 0)
board8._black_bitboard = 0x0000002010003C7E
possibility_b = board8.get_bit_count(
board8.get_legal_moves_bits('black'))
possibility_w = board8.get_bit_count(
board8.get_legal_moves_bits('white'))
score = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
self.assertEqual(score, -81)
board8._black_bitboard = 0x0000002010003C7C
score = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
self.assertEqual(score, -61)
score = evaluator.evaluate('black', board8, None, None)
self.assertEqual(score, -10006)
board4 = BitBoard(4)
possibility_b = board4.get_bit_count(
board4.get_legal_moves_bits('black'))
possibility_w = board4.get_bit_count(
board4.get_legal_moves_bits('white'))
score = evaluator.evaluate('black', board4, possibility_b,
possibility_w)
self.assertEqual(score, 0)
# -------------------------------
# Evaluator_TPWEC
evaluator = coord.Evaluator_TPWEC()
board8._black_bitboard = 0x0000002010003C7C
possibility_b = board8.get_bit_count(
board8.get_legal_moves_bits('black'))
possibility_w = board8.get_bit_count(
board8.get_legal_moves_bits('white'))
score = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
self.assertEqual(score, -61)
board8._black_bitboard = 0x0703012010003C7E
score = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
self.assertEqual(score, 422)
score = evaluator.evaluate('black', board8, None, None)
self.assertEqual(score, -10006)
# Evaluator_PWE
evaluator = coord.Evaluator_PWE()
board8._black_bitboard = 0x0000002010003C7C
possibility_b = board8.get_bit_count(
board8.get_legal_moves_bits('black'))
possibility_w = board8.get_bit_count(
board8.get_legal_moves_bits('white'))
score = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
self.assertEqual(score, 10)
board8._black_bitboard = 0x0703012010003C7E
score = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
self.assertEqual(score, 310)
score = evaluator.evaluate('black', board8, None, None)
self.assertEqual(score, -10006)
# Evaluator_BW
evaluator = coord.Evaluator_BW()
board8._black_bitboard = 0x0000002010003C7C
possibility_b = board8.get_bit_count(
board8.get_legal_moves_bits('black'))
possibility_w = board8.get_bit_count(
board8.get_legal_moves_bits('white'))
score = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
self.assertEqual(score, 2)
board8._black_bitboard = 0x0703012010003C7E
score = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
self.assertEqual(score, -2)
score = evaluator.evaluate('black', board8, None, None)
self.assertEqual(score, -10006)
# Evaluator_EcW
evaluator = coord.Evaluator_EcW()
board8._black_bitboard = 0x0000002010003C7C
possibility_b = board8.get_bit_count(
board8.get_legal_moves_bits('black'))
possibility_w = board8.get_bit_count(
board8.get_legal_moves_bits('white'))
score = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
self.assertEqual(score, -16)
board8._black_bitboard = 0x0703012010003C7E
score = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
self.assertEqual(score, 0)
score = evaluator.evaluate('black', board8, None, None)
self.assertEqual(score, -10006)
# Evaluator_BWEc
evaluator = coord.Evaluator_BWEc()
board8._black_bitboard = 0x0000002010003C7C
possibility_b = board8.get_bit_count(
board8.get_legal_moves_bits('black'))
possibility_w = board8.get_bit_count(
board8.get_legal_moves_bits('white'))
score = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
self.assertEqual(score, -14)
board8._black_bitboard = 0x0703012010003C7E
score = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
self.assertEqual(score, -2)
score = evaluator.evaluate('black', board8, None, None)
self.assertEqual(score, -10006)
def test_general_evaluator_evaluate(self):
evaluator = coord.Evaluator(
separated=[
coord.WinLoseScorer(),
],
combined=[
coord.TableScorer(),
coord.PossibilityScorer(),
coord.EdgeScorer(),
],
)
board8 = BitBoard(8)
board8._black_bitboard = 0xFFFFFFFFFFFFFFFF # black win
board8._white_bitboard = 0x0000000000000000
board8.update_score()
possibility_b = board8.get_bit_count(
board8.get_legal_moves_bits('black'))
possibility_w = board8.get_bit_count(
board8.get_legal_moves_bits('white'))
score_b = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
score_w = evaluator.evaluate('white', board8, possibility_b,
possibility_w)
self.assertEqual(score_b, 10064)
self.assertEqual(score_w, 10064)
board8._black_bitboard = 0x0000000000000000
board8._white_bitboard = 0xFFFFFFFFFFFFFFFF # white win
board8.update_score()
possibility_b = board8.get_bit_count(
board8.get_legal_moves_bits('black'))
possibility_w = board8.get_bit_count(
board8.get_legal_moves_bits('white'))
score_b = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
score_w = evaluator.evaluate('white', board8, possibility_b,
possibility_w)
self.assertEqual(score_b, -10064)
self.assertEqual(score_w, -10064)
board8 = BitBoard(8)
board8.put_disc('black', 3, 2)
board8.put_disc('white', 2, 2)
board8.put_disc('black', 2, 3)
board8.put_disc('white', 4, 2)
board8.put_disc('black', 1, 1)
board8.put_disc('white', 0, 0)
board8._black_bitboard = 0x0000002010003C7E
possibility_b = board8.get_bit_count(
board8.get_legal_moves_bits('black'))
possibility_w = board8.get_bit_count(
board8.get_legal_moves_bits('white'))
score = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
self.assertEqual(score, -81)
board8._black_bitboard = 0x0000002010003C7C
score = evaluator.evaluate('black', board8, possibility_b,
possibility_w)
self.assertEqual(score, -61)
