def benchmark(maxdepth=6):
""" Times a search of a static list of positions. """
suite_time = time()
suite_nodes = lsearch.nodes
lsearch.endtime = sys.maxsize
lsearch.searching = True
for i, fen in enumerate(benchmarkPositions):
lsearch.table.clear()
clearPawnTable()
board = LBoard(NORMALCHESS)
board.applyFen(fen)
pos_start_time = time()
pos_start_nodes = lsearch.nodes
for depth in range(1, maxdepth):
mvs, scr = lsearch.alphaBeta(board, depth)
pos_time = time() - pos_start_time
pos_nodes = lsearch.nodes - pos_start_nodes
pv = " ".join(listToSan(board, mvs))
time_cs = int(100 * pos_time)
print(depth, scr, time_cs, pos_nodes, pv)
print("Searched position", i, "at", int(pos_nodes / pos_time) if pos_time > 0 else pos_nodes, "n/s")
suite_time = time() - suite_time
suite_nodes = lsearch.nodes - suite_nodes
print("Total:", suite_nodes, "nodes in", suite_time, "s: ", suite_nodes /
suite_time, "n/s")
lsearch.nodes = 0
def benchmark(maxdepth=6):
""" Times a search of a static list of positions. """
suite_time = time()
suite_nodes = lsearch.nodes
lsearch.endtime = sys.maxsize
lsearch.searching = True
for i, fen in enumerate(benchmarkPositions):
lsearch.table.clear()
clearPawnTable()
board = LBoard(NORMALCHESS)
board.applyFen(fen)
pos_start_time = time()
pos_start_nodes = lsearch.nodes
for depth in range(1, maxdepth):
mvs, scr = lsearch.alphaBeta(board, depth)
pos_time = time() - pos_start_time
pos_nodes = lsearch.nodes - pos_start_nodes
pv = " ".join(listToSan(board, mvs))
time_cs = int(100 * pos_time)
print(depth, scr, time_cs, pos_nodes, pv)
print("Searched position", i, "at",
int(pos_nodes / pos_time) if pos_time > 0 else pos_nodes, "n/s")
suite_time = time() - suite_time
suite_nodes = lsearch.nodes - suite_nodes
print("Total:", suite_nodes, "nodes in", suite_time, "s: ",
suite_nodes / suite_time, "n/s")
lsearch.nodes = 0
def __analyze(self):
""" Searches, and prints info from, the position as stated in the cecp
protocol """
start = time()
lsearch.endtime = sys.maxsize
lsearch.searching = True
for depth in range(1, self.sd):
if not lsearch.searching:
break
board = self.board.clone()
mvs, scr = alphaBeta(board, depth)
pv1 = " ".join(listToSan(board, mvs))
time_cs = int(100 * (time() - start))
print("%s %s %s %s %s" % (depth, scr, time_cs, lsearch.nodes, pv1))
lsearch.nodes = 0
def __analyze(self):
""" Searches, and prints info from, the position as stated in the cecp
protocol """
start = time()
lsearch.endtime = sys.maxsize
lsearch.searching = True
for depth in range(1, self.sd):
if not lsearch.searching:
break
board = self.board.clone()
mvs, scr = alphaBeta(board, depth)
pv1 = " ".join(listToSan(board, mvs))
time_cs = int(100 * (time() - start))
self.print("%s %s %s %s %s" % (depth, scr, time_cs, lsearch.nodes, pv1))
lsearch.nodes = 0
def __go(self, ondone=None):
""" Finds and prints the best move from the current position """
mv = False if self.outOfBook else self.__getBestOpening()
if mv:
mvs = [mv]
if not mv:
lsearch.skipPruneChance = self.skipPruneChance
lsearch.searching = True
timed = self.basetime > 0
if self.searchtime > 0:
usetime = self.searchtime
else:
usetime = self.clock[self.playingAs] / self.__remainingMovesA()
if self.clock[self.playingAs] > 10:
# If we have time, we assume 40 moves rather than 80
usetime *= 2
# The increment is a constant. We'll use this always
usetime += self.increment[self.playingAs]
prevtime = 0
starttime = time()
lsearch.endtime = starttime + usetime if timed else sys.maxsize
if self.debug:
if timed:
print("# Time left: %3.2f s; Planing to think for %3.2f s" %
(self.clock[self.playingAs], usetime))
else:
print("# Searching to depth %d without timelimit" % self.sd)
for depth in range(1, self.sd + 1):
# Heuristic time saving
# Don't waste time, if the estimated isn't enough to complete
# next depth
if timed and usetime <= prevtime * 4 and usetime > 1:
break
lsearch.timecheck_counter = lsearch.TIMECHECK_FREQ
search_result = alphaBeta(self.board, depth)
if lsearch.searching:
mvs, self.scr = search_result
if time() > lsearch.endtime:
break
if self.post:
pv1 = " ".join(listToSan(self.board, mvs))
time_cs = int(100 * (time() - starttime))
print("%s %s %s %s %s" % (
depth, self.scr, time_cs, lsearch.nodes, pv1))
else:
# We were interrupted
if depth == 1:
mvs, self.scr = search_result
break
prevtime = time() - starttime - prevtime
self.clock[self.playingAs] -= time(
) - starttime - self.increment[self.playingAs]
if not mvs:
if not lsearch.searching:
# We were interupted
lsearch.nodes = 0
return
# This should only happen in terminal mode
if self.scr == 0:
print("result %s" % reprResult[DRAW])
elif self.scr < 0:
if self.board.color == WHITE:
print("result %s" % reprResult[BLACKWON])
else:
print("result %s" % reprResult[WHITEWON])
else:
if self.board.color == WHITE:
print("result %s" % reprResult[WHITEWON])
else:
print("result %s" % reprResult[BLACKWON])
return
lsearch.nodes = 0
lsearch.searching = False
move = mvs[0]
sanmove = toSAN(self.board, move)
if ondone:
ondone(sanmove)
return sanmove
def __go (self, ondone=None):
""" Finds and prints the best move from the current position """
mv = self.__getBestOpening()
if mv:
mvs = [mv]
if not mv:
lsearch.skipPruneChance = self.skipPruneChance
lsearch.searching = True
timed = self.basetime > 0
if self.searchtime > 0:
usetime = self.searchtime
else:
usetime = self.clock[self.playingAs] / self.__remainingMovesA()
if self.clock[self.playingAs] < 6*60+self.increment[self.playingAs]*40:
# If game is blitz, we assume 40 moves rather than 80
usetime *= 2
# The increment is a constant. We'll use this always
usetime += self.increment[self.playingAs]
if usetime < 0.5:
# We don't wan't to search for e.g. 0 secs
usetime = 0.5
prevtime = 0
starttime = time()
lsearch.endtime = starttime + usetime if timed else sys.maxint
if self.debug:
if timed:
print "# Time left: %3.2f s; Planing to think for %3.2f s" % (self.clock[self.playingAs], usetime)
else:
print "# Searching to depth %d without timelimit" % self.sd
for depth in range(1, self.sd+1):
# Heuristic time saving
# Don't waste time, if the estimated isn't enough to complete next depth
if timed and usetime <= prevtime*4 and usetime > 1:
break
lsearch.timecheck_counter = lsearch.TIMECHECK_FREQ
search_result = alphaBeta(self.board, depth)
if lsearch.searching:
mvs, self.scr = search_result
if time() > lsearch.endtime:
break
if self.post:
pv = " ".join(listToSan(self.board, mvs))
time_cs = int(100 * (time()-starttime))
print depth, self.scr, time_cs, lsearch.nodes, pv
else:
# We were interrupted
if depth == 1:
mvs, self.scr = search_result
break
prevtime = time()-starttime - prevtime
self.clock[self.playingAs] -= time() - starttime - self.increment[self.playingAs]
if not mvs:
if not lsearch.searching:
# We were interupted
lsearch.nodes = 0
return
# This should only happen in terminal mode
if self.scr == 0:
print "result %s" % reprResult[DRAW]
elif self.scr < 0:
if self.board.color == WHITE:
print "result %s" % reprResult[BLACKWON]
else: print "result %s" % reprResult[WHITEWON]
else:
if self.board.color == WHITE:
print "result %s" % reprResult[WHITEWON]
else: print "result %s" % reprResult[BLACKWON]
return
lsearch.nodes = 0
lsearch.searching = False
move = mvs[0]
sanmove = toSAN(self.board, move)
if ondone: ondone(sanmove)
return sanmove
(reprColor[color], fen, repr(data)))
self.table[(fen, color)] = [] # Don't try again.
if (fen, board.color) in self.table:
return self.table[(fen, board.color)]
return []
def scoreGame(self, board, omitDepth, probeSoft):
scores = self.scoreAllMoves(board, probeSoft)
if scores:
return scores[0][1], scores[0][2]
return None, None
if __name__ == "__main__":
from pychess.Utils.lutils.LBoard import LBoard
from pychess.Utils.lutils.lmove import listToSan
board = LBoard(NORMALCHESS)
board.applyFen("8/k2P4/8/8/8/8/8/4K2R w - - 0 1")
moves = probeEndGameTable(board)
assert len(moves) == 18, listToSan(board, (move[0] for move in moves))
board.applyFen("8/p7/6kp/3K4/6PP/8/8/8 b - - 0 1")
moves = probeEndGameTable(board)
assert len(moves) == 7, listToSan(board, (move[0] for move in moves))
board.applyFen("8/p6k/2K5/7R/6PP/8/8/8 b - - 0 66")
moves = probeEndGameTable(board)
assert len(moves) == 3, listToSan(board, (move[0] for move in moves))
log.warning("Couldn't parse %s data for position %s.\nData was: %s" %
(reprColor[color], fen, repr(data)))
self.table[(fen, color)] = [] # Don't try again.
if (fen,board.color) in self.table:
return self.table[(fen,board.color)]
return []
def scoreGame(self, board, omitDepth, probeSoft):
scores = self.scoreAllMoves(board, probeSoft)
if scores:
return scores[0][1], scores[0][2]
return None, None
if __name__ == "__main__":
from pychess.Utils.lutils.LBoard import LBoard
from pychess.Utils.lutils.lmove import listToSan
board = LBoard(NORMALCHESS)
board.applyFen("8/k2P4/8/8/8/8/8/4K2R w - - 0 1")
moves = probeEndGameTable(board)
assert len(moves) == 18, listToSan(board, (move[0] for move in moves))
board.applyFen("8/p7/6kp/3K4/6PP/8/8/8 b - - 0 1")
moves = probeEndGameTable(board)
assert len(moves) == 7, listToSan(board, (move[0] for move in moves))
board.applyFen("8/p6k/2K5/7R/6PP/8/8/8 b - - 0 66")
moves = probeEndGameTable(board)
assert len(moves) == 3, listToSan(board, (move[0] for move in moves))
