#include <algorithm>
#include <cassert>
#include <cmath>
-#include <cstdio>
#include <cstring>
#include <iomanip>
+#include <iostream>
#include <sstream>
#include <vector>
}
using std::string;
+using std::cout;
+using std::endl;
using namespace Search;
namespace {
MovePickerExt(const Position& p, Move ttm, Depth d, const History& h, Stack* ss, Value b)
: MovePicker(p, ttm, d, h, ss, b), mp(ss->sp->mp) {}
- Move get_next_move() { return mp->get_next_move(); }
+ Move next_move() { return mp->next_move(); }
MovePicker* mp;
};
// is given, with the subset of legal moves to search.
for (MoveList<MV_LEGAL> ml(pos); !ml.end(); ++ml)
if ( SearchMoves.empty()
- || std::count(SearchMoves.begin(), SearchMoves.end(), ml.move()))
+ || count(SearchMoves.begin(), SearchMoves.end(), ml.move()))
RootMoves.push_back(RootMove(ml.move()));
if (Options["OwnBook"].value<bool>())
Move bookMove = book.probe(pos, Options["Best Book Move"].value<bool>());
if ( bookMove != MOVE_NONE
- && std::count(RootMoves.begin(), RootMoves.end(), bookMove))
+ && count(RootMoves.begin(), RootMoves.end(), bookMove))
{
- std::swap(RootMoves[0], *std::find(RootMoves.begin(), RootMoves.end(), bookMove));
+ std::swap(RootMoves[0], *find(RootMoves.begin(), RootMoves.end(), bookMove));
goto finish;
}
}
<< " time: " << Limits.time
<< " increment: " << Limits.increment
<< " moves to go: " << Limits.movesToGo
- << std::endl;
+ << endl;
}
for (int i = 0; i < Threads.size(); i++)
StateInfo st;
pos.do_move(RootMoves[0].pv[0], st);
- log << "\nPonder move: " << move_to_san(pos, RootMoves[0].pv[1]) << std::endl;
+ log << "\nPonder move: " << move_to_san(pos, RootMoves[0].pv[1]) << endl;
pos.undo_move(RootMoves[0].pv[0]);
}
Threads.wait_for_stop_or_ponderhit();
// Best move could be MOVE_NONE when searching on a stalemate position
- printf("bestmove %s ponder %s\n",
- move_to_uci(RootMoves[0].pv[0], Chess960).c_str(),
- move_to_uci(RootMoves[0].pv[1], Chess960).c_str());
+ cout << "bestmove " << move_to_uci(RootMoves[0].pv[0], Chess960)
+ << " ponder " << move_to_uci(RootMoves[0].pv[1], Chess960) << endl;
}
// Handle the special case of a mate/stalemate position
if (RootMoves.empty())
{
- printf("info depth 0%s\n",
- score_to_uci(pos.in_check() ? -VALUE_MATE : VALUE_DRAW).c_str());
+ cout << "info depth 0"
+ << score_to_uci(pos.in_check() ? -VALUE_MATE : VALUE_DRAW) << endl;
RootMoves.push_back(MOVE_NONE);
return;
// If search has been stopped exit the aspiration window loop.
// Sorting and writing PV back to TT is safe becuase RootMoves
- // is still valid, although refers to previous iteration.
+ // is still valid, although refers to previous iteration.
if (Signals.stop)
break;
if (skillBest == MOVE_NONE) // Still unassigned ?
skillBest = do_skill_level();
- std::swap(RootMoves[0], *std::find(RootMoves.begin(), RootMoves.end(), skillBest));
+ std::swap(RootMoves[0], *find(RootMoves.begin(), RootMoves.end(), skillBest));
}
}
// We don't want the score of a partial search to overwrite a previous full search
// TT value, so we use a different position key in case of an excluded move.
excludedMove = ss->excludedMove;
- posKey = excludedMove ? pos.get_exclusion_key() : pos.get_key();
+ posKey = excludedMove ? pos.exclusion_key() : pos.key();
tte = TT.probe(posKey);
ttMove = RootNode ? RootMoves[PVIdx].pv[0] : tte ? tte->move() : MOVE_NONE;
MovePicker mp(pos, ttMove, H, pos.captured_piece_type());
CheckInfo ci(pos);
- while ((move = mp.get_next_move()) != MOVE_NONE)
+ while ((move = mp.next_move()) != MOVE_NONE)
if (pos.pl_move_is_legal(move, ci.pinned))
{
pos.do_move(move, st, ci, pos.move_gives_check(move, ci));
// Step 11. Loop through moves
// Loop through all pseudo-legal moves until no moves remain or a beta cutoff occurs
while ( bestValue < beta
- && (move = mp.get_next_move()) != MOVE_NONE
+ && (move = mp.next_move()) != MOVE_NONE
&& !thread.cutoff_occurred())
{
assert(is_ok(move));
// At root obey the "searchmoves" option and skip moves not listed in Root
// Move List, as a consequence any illegal move is also skipped. In MultiPV
// mode we also skip PV moves which have been already searched.
- if (RootNode && !std::count(RootMoves.begin() + PVIdx, RootMoves.end(), move))
+ if (RootNode && !count(RootMoves.begin() + PVIdx, RootMoves.end(), move))
continue;
// At PV and SpNode nodes we want all moves to be legal since the beginning
nodes = pos.nodes_searched();
if (pos.thread() == 0 && elapsed_time() > 2000)
- printf("info depth %i currmove %s currmovenumber %i\n", depth / ONE_PLY,
- move_to_uci(move, Chess960).c_str(), moveCount + PVIdx);
+ cout << "info depth " << depth / ONE_PLY
+ << " currmove " << move_to_uci(move, Chess960)
+ << " currmovenumber " << moveCount + PVIdx << endl;
}
isPvMove = (PvNode && moveCount <= 1);
// be trusted, and we don't update the best move and/or PV.
if (RootNode && !Signals.stop)
{
- RootMove& rm = *std::find(RootMoves.begin(), RootMoves.end(), move);
+ RootMove& rm = *find(RootMoves.begin(), RootMoves.end(), move);
rm.nodes += pos.nodes_searched() - nodes;
// PV move or new best move ?
TT.store(posKey, value_to_tt(bestValue, ss->ply), vt, depth, move, ss->eval, ss->evalMargin);
// Update killers and history for non capture cut-off moves
- if (bestValue >= beta && !pos.is_capture_or_promotion(move))
+ if ( bestValue >= beta
+ && !pos.is_capture_or_promotion(move)
+ && !inCheck)
{
if (move != ss->killers[0])
{
// Transposition table lookup. At PV nodes, we don't use the TT for
// pruning, but only for move ordering.
- tte = TT.probe(pos.get_key());
+ tte = TT.probe(pos.key());
ttMove = (tte ? tte->move() : MOVE_NONE);
if (!PvNode && tte && can_return_tt(tte, ttDepth, beta, ss->ply))
if (bestValue >= beta)
{
if (!tte)
- TT.store(pos.get_key(), value_to_tt(bestValue, ss->ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, evalMargin);
+ TT.store(pos.key(), value_to_tt(bestValue, ss->ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, evalMargin);
return bestValue;
}
// Loop through the moves until no moves remain or a beta cutoff occurs
while ( bestValue < beta
- && (move = mp.get_next_move()) != MOVE_NONE)
+ && (move = mp.next_move()) != MOVE_NONE)
{
assert(is_ok(move));
vt = bestValue <= oldAlpha ? VALUE_TYPE_UPPER
: bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT;
- TT.store(pos.get_key(), value_to_tt(bestValue, ss->ply), vt, ttDepth, move, ss->eval, evalMargin);
+ TT.store(pos.key(), value_to_tt(bestValue, ss->ply), vt, ttDepth, move, ss->eval, evalMargin);
assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
// value_to_tt() adjusts a mate score from "plies to mate from the root" to
- // "plies to mate from the current ply". Non-mate scores are unchanged.
- // The function is called before storing a value to the transposition table.
+ // "plies to mate from the current ply". Non-mate scores are unchanged. The
+ // function is called before storing a value to the transposition table.
Value value_to_tt(Value v, int ply) {
static int searchStartTime;
if (reset)
- searchStartTime = get_system_time();
+ searchStartTime = system_time();
- return get_system_time() - searchStartTime;
+ return system_time() - searchStartTime;
}
int t = elapsed_time();
int selDepth = 0;
- std::stringstream s;
for (int i = 0; i < Threads.size(); i++)
if (Threads[i].maxPly > selDepth)
int d = (updated ? depth : depth - 1);
Value v = (updated ? RootMoves[i].score : RootMoves[i].prevScore);
-
- s << "info depth " << d
- << " seldepth " << selDepth
- << (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
- << " multipv " << i + 1 << " pv";
+ std::stringstream s;
for (int j = 0; RootMoves[i].pv[j] != MOVE_NONE; j++)
s << " " << move_to_uci(RootMoves[i].pv[j], Chess960);
- printf("%s\n", s.str().c_str()); // Much faster than std::cout
+ cout << "info depth " << d
+ << " seldepth " << selDepth
+ << (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
+ << " multipv " << i + 1
+ << " pv" << s.str() << endl;
}
}
pos.undo_move(*--m);
Log l(Options["Search Log Filename"].value<string>());
- l << s.str() << std::endl;
+ l << s.str() << endl;
}
static RKISS rk;
// PRNG sequence should be not deterministic
- for (int i = abs(get_system_time() % 50); i > 0; i--)
+ for (int i = abs(system_time() % 50); i > 0; i--)
rk.rand<unsigned>();
// RootMoves are already sorted by score in descending order
pv.push_back(m);
pos.do_move(m, *st++);
- while ( (tte = TT.probe(pos.get_key())) != NULL
+ while ( (tte = TT.probe(pos.key())) != NULL
&& tte->move() != MOVE_NONE
&& pos.is_pseudo_legal(tte->move())
&& pos.pl_move_is_legal(tte->move(), pos.pinned_pieces())
assert(pv[ply] != MOVE_NONE && pos.is_pseudo_legal(pv[ply]));
do {
- k = pos.get_key();
+ k = pos.key();
tte = TT.probe(k);
// Don't overwrite existing correct entries
static int lastInfoTime;
int e = elapsed_time();
- if (get_system_time() - lastInfoTime >= 1000 || !lastInfoTime)
+ if (system_time() - lastInfoTime >= 1000 || !lastInfoTime)
{
- lastInfoTime = get_system_time();
+ lastInfoTime = system_time();
dbg_print_mean();
dbg_print_hit_rate();
projects / stockfish / blobdiff