/*
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
- Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+ Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
RootMove(){}
RootMove(Move m) {
- nodes = 0;
score = prevScore = -VALUE_INFINITE;
pv.push_back(m);
pv.push_back(MOVE_NONE);
void extract_pv_from_tt(Position& pos);
void insert_pv_in_tt(Position& pos);
- int64_t nodes;
Value score;
Value prevScore;
std::vector<Move> pv;
int64_t Search::perft(Position& pos, Depth depth) {
StateInfo st;
- int64_t sum = 0;
+ int64_t cnt = 0;
MoveList<MV_LEGAL> ml(pos);
// At the last ply just return the number of moves (leaf nodes)
- if (depth <= ONE_PLY)
+ if (depth == ONE_PLY)
return ml.size();
CheckInfo ci(pos);
for ( ; !ml.end(); ++ml)
{
pos.do_move(ml.move(), st, ci, pos.move_gives_check(ml.move(), ci));
- sum += perft(pos, depth - ONE_PLY);
+ cnt += perft(pos, depth - ONE_PLY);
pos.undo_move(ml.move());
}
- return sum;
+ return cnt;
}
|| count(SearchMoves.begin(), SearchMoves.end(), ml.move()))
RootMoves.push_back(RootMove(ml.move()));
- if (Options["OwnBook"].value<bool>())
+ if (Options["OwnBook"])
{
- if (Options["Book File"].value<string>() != book.name())
- book.open(Options["Book File"].value<string>());
+ if (book.name() != (string)Options["Book File"])
+ book.open(Options["Book File"]);
- Move bookMove = book.probe(pos, Options["Best Book Move"].value<bool>());
+ Move bookMove = book.probe(pos, Options["Best Book Move"]);
if ( bookMove != MOVE_NONE
&& count(RootMoves.begin(), RootMoves.end(), bookMove))
read_evaluation_uci_options(pos.side_to_move());
Threads.read_uci_options();
- TT.set_size(Options["Hash"].value<int>());
- if (Options["Clear Hash"].value<bool>())
+ TT.set_size(Options["Hash"]);
+ if (Options["Clear Hash"])
{
Options["Clear Hash"] = false;
TT.clear();
}
- UCIMultiPV = Options["MultiPV"].value<size_t>();
- SkillLevel = Options["Skill Level"].value<int>();
+ UCIMultiPV = Options["MultiPV"];
+ SkillLevel = Options["Skill Level"];
// Do we have to play with skill handicap? In this case enable MultiPV that
// we will use behind the scenes to retrieve a set of possible moves.
SkillLevelEnabled = (SkillLevel < 20);
MultiPV = (SkillLevelEnabled ? std::max(UCIMultiPV, (size_t)4) : UCIMultiPV);
- if (Options["Use Search Log"].value<bool>())
+ if (Options["Use Search Log"])
{
- Log log(Options["Search Log Filename"].value<string>());
+ Log log(Options["Search Log Filename"]);
log << "\nSearching: " << pos.to_fen()
<< "\ninfinite: " << Limits.infinite
<< " ponder: " << Limits.ponder
Threads.set_timer(0);
Threads.set_size(1);
- if (Options["Use Search Log"].value<bool>())
+ if (Options["Use Search Log"])
{
int e = elapsed_time();
- Log log(Options["Search Log Filename"].value<string>());
+ Log log(Options["Search Log Filename"]);
log << "Nodes: " << pos.nodes_searched()
<< "\nNodes/second: " << (e > 0 ? pos.nodes_searched() * 1000 / e : 0)
<< "\nBest move: " << move_to_san(pos, RootMoves[0].pv[0]);
void id_loop(Position& pos) {
- Stack ss[PLY_MAX_PLUS_2];
+ Stack ss[MAX_PLY_PLUS_2];
int depth, prevBestMoveChanges;
Value bestValue, alpha, beta, delta;
bool bestMoveNeverChanged = true;
bestValue = delta = -VALUE_INFINITE;
ss->currentMove = MOVE_NULL; // Hack to skip update gains
- // Handle the special case of a mate/stalemate position
+ // Handle the special case of a mated/stalemate position
if (RootMoves.empty())
{
- cout << "info depth 0"
+ cout << "info depth 0 score "
<< score_to_uci(pos.in_check() ? -VALUE_MATE : VALUE_DRAW) << endl;
RootMoves.push_back(MOVE_NONE);
}
// Iterative deepening loop until requested to stop or target depth reached
- while (!Signals.stop && ++depth <= PLY_MAX && (!Limits.maxDepth || depth <= Limits.maxDepth))
+ while (!Signals.stop && ++depth <= MAX_PLY && (!Limits.maxDepth || depth <= Limits.maxDepth))
{
// Save last iteration's scores before first PV line is searched and all
// the move scores but the (new) PV are set to -VALUE_INFINITE.
if (SkillLevelEnabled && depth == 1 + SkillLevel)
skillBest = do_skill_level();
- if (Options["Use Search Log"].value<bool>())
+ if (Options["Use Search Log"])
pv_info_to_log(pos, depth, bestValue, elapsed_time(), &RootMoves[0].pv[0]);
// Filter out startup noise when monitoring best move stability
assert(pos.thread() >= 0 && pos.thread() < Threads.size());
Move movesSearched[MAX_MOVES];
- int64_t nodes;
StateInfo st;
const TTEntry *tte;
Key posKey;
// Step 2. Check for aborted search and immediate draw
if (( Signals.stop
|| pos.is_draw<false>()
- || ss->ply > PLY_MAX) && !RootNode)
+ || ss->ply > MAX_PLY) && !RootNode)
return VALUE_DRAW;
// Step 3. Mate distance pruning. Even if we mate at the next move our score
&& !inCheck
&& refinedValue + razor_margin(depth) < beta
&& ttMove == MOVE_NONE
- && abs(beta) < VALUE_MATE_IN_PLY_MAX
+ && abs(beta) < VALUE_MATE_IN_MAX_PLY
&& !pos.has_pawn_on_7th(pos.side_to_move()))
{
Value rbeta = beta - razor_margin(depth);
&& depth < RazorDepth
&& !inCheck
&& refinedValue - futility_margin(depth, 0) >= beta
- && abs(beta) < VALUE_MATE_IN_PLY_MAX
+ && abs(beta) < VALUE_MATE_IN_MAX_PLY
&& pos.non_pawn_material(pos.side_to_move()))
return refinedValue - futility_margin(depth, 0);
&& depth > ONE_PLY
&& !inCheck
&& refinedValue >= beta
- && abs(beta) < VALUE_MATE_IN_PLY_MAX
+ && abs(beta) < VALUE_MATE_IN_MAX_PLY
&& pos.non_pawn_material(pos.side_to_move()))
{
ss->currentMove = MOVE_NULL;
if (nullValue >= beta)
{
// Do not return unproven mate scores
- if (nullValue >= VALUE_MATE_IN_PLY_MAX)
+ if (nullValue >= VALUE_MATE_IN_MAX_PLY)
nullValue = beta;
if (depth < 6 * ONE_PLY)
&& !inCheck
&& !ss->skipNullMove
&& excludedMove == MOVE_NONE
- && abs(beta) < VALUE_MATE_IN_PLY_MAX)
+ && abs(beta) < VALUE_MATE_IN_MAX_PLY)
{
Value rbeta = beta + 200;
Depth rdepth = depth - ONE_PLY - 3 * ONE_PLY;
if (RootNode)
{
Signals.firstRootMove = (moveCount == 1);
- nodes = pos.nodes_searched();
if (pos.thread() == 0 && elapsed_time() > 2000)
cout << "info depth " << depth / ONE_PLY
&& !dangerous
&& move != ttMove
&& !is_castle(move)
- && (bestValue > VALUE_MATED_IN_PLY_MAX || bestValue == -VALUE_INFINITE))
+ && (bestValue > VALUE_MATED_IN_MAX_PLY || bestValue == -VALUE_INFINITE))
{
// Move count based pruning
if ( moveCount >= futility_move_count(depth)
if (RootNode && !Signals.stop)
{
RootMove& rm = *find(RootMoves.begin(), RootMoves.end(), move);
- rm.nodes += pos.nodes_searched() - nodes;
// PV move or new best move ?
if (isPvMove || value > alpha)
ss->ply = (ss-1)->ply + 1;
// Check for an instant draw or maximum ply reached
- if (pos.is_draw<true>() || ss->ply > PLY_MAX)
+ if (pos.is_draw<true>() || ss->ply > MAX_PLY)
return VALUE_DRAW;
// Decide whether or not to include checks, this fixes also the type of
// Detect non-capture evasions that are candidate to be pruned
evasionPrunable = !PvNode
&& inCheck
- && bestValue > VALUE_MATED_IN_PLY_MAX
+ && bestValue > VALUE_MATED_IN_MAX_PLY
&& !pos.is_capture(move)
&& !pos.can_castle(pos.side_to_move());
Value value_to_tt(Value v, int ply) {
- if (v >= VALUE_MATE_IN_PLY_MAX)
+ if (v >= VALUE_MATE_IN_MAX_PLY)
return v + ply;
- if (v <= VALUE_MATED_IN_PLY_MAX)
+ if (v <= VALUE_MATED_IN_MAX_PLY)
return v - ply;
return v;
Value value_from_tt(Value v, int ply) {
- if (v >= VALUE_MATE_IN_PLY_MAX)
+ if (v >= VALUE_MATE_IN_MAX_PLY)
return v - ply;
- if (v <= VALUE_MATED_IN_PLY_MAX)
+ if (v <= VALUE_MATED_IN_MAX_PLY)
return v + ply;
return v;
Value v = value_from_tt(tte->value(), ply);
return ( tte->depth() >= depth
- || v >= std::max(VALUE_MATE_IN_PLY_MAX, beta)
- || v < std::min(VALUE_MATED_IN_PLY_MAX, beta))
+ || v >= std::max(VALUE_MATE_IN_MAX_PLY, beta)
+ || v < std::min(VALUE_MATED_IN_MAX_PLY, beta))
&& ( ((tte->type() & VALUE_TYPE_LOWER) && v >= beta)
|| ((tte->type() & VALUE_TYPE_UPPER) && v < beta));
std::stringstream s;
- if (abs(v) < VALUE_MATE - PLY_MAX * ONE_PLY)
- s << " score cp " << int(v) * 100 / int(PawnValueMidgame); // Scale to centipawns
+ if (abs(v) < VALUE_MATE_IN_MAX_PLY)
+ s << "cp " << v * 100 / int(PawnValueMidgame);
else
- s << " score mate " << (v > 0 ? VALUE_MATE - v + 1 : -VALUE_MATE - v) / 2;
+ s << "mate " << (v > 0 ? VALUE_MATE - v + 1 : -VALUE_MATE - v) / 2;
s << (v >= beta ? " lowerbound" : v <= alpha ? " upperbound" : "");
cout << "info depth " << d
<< " seldepth " << selDepth
- << (i == PVIdx ? score_to_uci(v, alpha, beta) : score_to_uci(v))
+ << " score " << (i == PVIdx ? score_to_uci(v, alpha, beta) : score_to_uci(v))
<< " nodes " << pos.nodes_searched()
<< " nps " << (t > 0 ? pos.nodes_searched() * 1000 / t : 0)
<< " time " << t
std::stringstream s;
- if (v >= VALUE_MATE_IN_PLY_MAX)
+ if (v >= VALUE_MATE_IN_MAX_PLY)
s << "#" << (VALUE_MATE - v + 1) / 2;
- else if (v <= VALUE_MATED_IN_PLY_MAX)
+ else if (v <= VALUE_MATED_IN_MAX_PLY)
s << "-#" << (VALUE_MATE + v) / 2;
else
s << std::setprecision(2) << std::fixed << std::showpos
const int64_t K = 1000;
const int64_t M = 1000000;
- StateInfo state[PLY_MAX_PLUS_2], *st = state;
+ StateInfo state[MAX_PLY_PLUS_2], *st = state;
Move* m = pv;
string san, padding;
size_t length;
while (m != pv)
pos.undo_move(*--m);
- Log l(Options["Search Log Filename"].value<string>());
+ Log l(Options["Search Log Filename"]);
l << s.str() << endl;
}
void RootMove::extract_pv_from_tt(Position& pos) {
- StateInfo state[PLY_MAX_PLUS_2], *st = state;
+ StateInfo state[MAX_PLY_PLUS_2], *st = state;
TTEntry* tte;
int ply = 1;
Move m = pv[0];
&& tte->move() != MOVE_NONE
&& pos.is_pseudo_legal(tte->move())
&& pos.pl_move_is_legal(tte->move(), pos.pinned_pieces())
- && ply < PLY_MAX
+ && ply < MAX_PLY
&& (!pos.is_draw<false>() || ply < 2))
{
pv.push_back(tte->move());
void RootMove::insert_pv_in_tt(Position& pos) {
- StateInfo state[PLY_MAX_PLUS_2], *st = state;
+ StateInfo state[MAX_PLY_PLUS_2], *st = state;
TTEntry* tte;
Key k;
Value v, m = VALUE_NONE;
assert(!do_terminate);
// Copy split point position and search stack and call search()
- Stack ss[PLY_MAX_PLUS_2];
+ Stack ss[MAX_PLY_PLUS_2];
SplitPoint* tsp = splitPoint;
Position pos(*tsp->pos, threadID);
if (system_time() - lastInfoTime >= 1000 || !lastInfoTime)
{
lastInfoTime = system_time();
-
- dbg_print_mean();
- dbg_print_hit_rate();
+ dbg_print();
}
if (Limits.ponder)