HCha/Stockfish
1
0
Fork 0
mirror of https://github.com/HChaZZY/Stockfish.git synced 2025-12-20 09:06:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Assorted English grammar changes

Browse Source 
No functional change

Resolves #567
This commit is contained in:
Lyudmil Antonov
2016-01-16 21:34:29 +00:00
committed by Joona Kiiski
parent 74e2fa97b7
commit 89723339d9
12 changed files with 103 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

88
src/search.cpp
View File

@@ -61,7 +61,7 @@ using namespace Search;
namespace {
// Different node types, used as template parameter
// Different node types, used as a template parameter
enum NodeType { Root, PV, NonPV };
// Razoring and futility margin based on depth
@@ -76,7 +76,7 @@ namespace {
return Reductions[PvNode][i][std::min(d, 63 * ONE_PLY)][std::min(mn, 63)];
}
// Skill struct is used to implement strength limiting
// Skill structure is used to implement strength limit
struct Skill {
Skill(int l) : level(l) {}
bool enabled() const { return level < 20; }
@@ -88,8 +88,8 @@ namespace {
Move best = MOVE_NONE;
};
// EasyMoveManager struct is used to detect a so called 'easy move'; when PV is
// stable across multiple search iterations we can fast return the best move.
// EasyMoveManager structure is used to detect an 'easy move'. When the PV is
// stable across multiple search iterations, we can quickly return the best move.
struct EasyMoveManager {
void clear() {
@@ -106,7 +106,7 @@ namespace {
assert(newPv.size() >= 3);
// Keep track of how many times in a row 3rd ply remains stable
// Keep track of how many times in a row the 3rd ply remains stable
stableCnt = (newPv[2] == pv[2]) ? stableCnt + 1 : 0;
if (!std::equal(newPv.begin(), newPv.begin() + 3, pv))
@@ -129,7 +129,7 @@ namespace {
EasyMoveManager EasyMove;
Value DrawValue[COLOR_NB];
CounterMovesHistoryStats CounterMovesHistory;
CounterMoveHistoryStats CounterMoveHistory;
template <NodeType NT>
Value search(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth, bool cutNode);
@@ -175,12 +175,12 @@ void Search::init() {
}
/// Search::clear() resets to zero search state, to obtain reproducible results
/// Search::clear() resets search state to zero, to obtain reproducible results
void Search::clear() {
TT.clear();
CounterMovesHistory.clear();
CounterMoveHistory.clear();
for (Thread* th : Threads)
{
@@ -193,7 +193,7 @@ void Search::clear() {
/// Search::perft() is our utility to verify move generation. All the leaf nodes
/// up to the given depth are generated and counted and the sum returned.
/// up to the given depth are generated and counted, and the sum is returned.
template<bool Root>
uint64_t Search::perft(Position& pos, Depth depth) {
@@ -223,8 +223,7 @@ template uint64_t Search::perft<true>(Position&, Depth);
/// MainThread::search() is called by the main thread when the program receives
/// the UCI 'go' command. It searches from root position and at the end prints
/// the "bestmove" to output.
/// the UCI 'go' command. It searches from the root position and outputs the "bestmove".
void MainThread::search() {
@@ -260,8 +259,8 @@ void MainThread::search() {
if (TB::Cardinality >= rootPos.count<ALL_PIECES>(WHITE)
+ rootPos.count<ALL_PIECES>(BLACK))
{
// If the current root position is in the tablebases then RootMoves
// contains only moves that preserve the draw or win.
// If the current root position is in the tablebases, then RootMoves
// contains only moves that preserve the draw or the win.
TB::RootInTB = Tablebases::root_probe(rootPos, rootMoves, TB::Score);
if (TB::RootInTB)
@@ -269,7 +268,7 @@ void MainThread::search() {
else // If DTZ tables are missing, use WDL tables as a fallback
{
// Filter out moves that do not preserve a draw or win
// Filter out moves that do not preserve the draw or the win.
TB::RootInTB = Tablebases::root_probe_wdl(rootPos, rootMoves, TB::Score);
// Only probe during search if winning
@@ -304,7 +303,7 @@ void MainThread::search() {
}
// When playing in 'nodes as time' mode, subtract the searched nodes from
// the available ones before to exit.
// the available ones before exiting.
if (Limits.npmsec)
Time.availableNodes += Limits.inc[us] - Threads.nodes_searched();
@@ -356,7 +355,7 @@ void MainThread::search() {
// Thread::search() is the main iterative deepening loop. It calls search()
// repeatedly with increasing depth until the allocated thinking time has been
// consumed, user stops the search, or the maximum search depth is reached.
// consumed, the user stops the search, or the maximum search depth is reached.
void Thread::search() {
@@ -390,11 +389,11 @@ void Thread::search() {
multiPV = std::min(multiPV, rootMoves.size());
// Iterative deepening loop until requested to stop or target depth reached
// Iterative deepening loop until requested to stop or the target depth is reached.
while (++rootDepth < DEPTH_MAX && !Signals.stop && (!Limits.depth || rootDepth <= Limits.depth))
{
// Set up the new depth for the helper threads skipping in average each
// 2nd ply (using a half density map similar to a Hadamard matrix).
// Set up the new depths for the helper threads skipping on average every
// 2nd ply (using a half-density map similar to a Hadamard matrix).
if (!mainThread)
{
int d = rootDepth + rootPos.game_ply();
@@ -452,14 +451,14 @@ void Thread::search() {
// search the already searched PV lines are preserved.
std::stable_sort(rootMoves.begin() + PVIdx, rootMoves.end());
// Write PV back to transposition table in case the relevant
// Write PV back to the transposition table in case the relevant
// entries have been overwritten during the search.
for (size_t i = 0; i <= PVIdx; ++i)
rootMoves[i].insert_pv_in_tt(rootPos);
// If search has been stopped break immediately. Sorting and
// If search has been stopped, break immediately. Sorting and
// writing PV back to TT is safe because RootMoves is still
// valid, although it refers to previous iteration.
// valid, although it refers to the previous iteration.
if (Signals.stop)
break;
@@ -536,12 +535,12 @@ void Thread::search() {
if (rootDepth > 4 * ONE_PLY && multiPV == 1)
Time.pv_instability(mainThread->bestMoveChanges);
// Stop the search if only one legal move is available or all
// of the available time has been used or we matched an easyMove
// Stop the search if only one legal move is available, or if all
// of the available time has been used, or if we matched an easyMove
// from the previous search and just did a fast verification.
if ( rootMoves.size() == 1
|| Time.elapsed() > Time.available() * ( 640 - 160 * !mainThread->failedLow
- 126 * (bestValue >= mainThread->previousMoveScore)
|| Time.elapsed() > Time.available() * ( 640 - 160 * !mainThread->failedLow
- 126 * (bestValue >= mainThread->previousMoveScore)
- 124 * (bestValue >= mainThread->previousMoveScore && !mainThread->failedLow))/640
|| ( mainThread->easyMovePlayed = ( rootMoves[0].pv[0] == easyMove
&& mainThread->bestMoveChanges < 0.03
@@ -610,7 +609,7 @@ namespace {
bestValue = -VALUE_INFINITE;
ss->ply = (ss-1)->ply + 1;
// Check for available remaining time
// Check for the available remaining time
if (thisThread->resetCalls.load(std::memory_order_relaxed))
{
thisThread->resetCalls = false;
@@ -853,7 +852,7 @@ moves_loop: // When in check search starts from here
Square prevSq = to_sq((ss-1)->currentMove);
Move cm = thisThread->counterMoves[pos.piece_on(prevSq)][prevSq];
const CounterMovesStats& cmh = CounterMovesHistory[pos.piece_on(prevSq)][prevSq];
const CounterMoveStats& cmh = CounterMoveHistory[pos.piece_on(prevSq)][prevSq];
MovePicker mp(pos, ttMove, depth, thisThread->history, cmh, cm, ss);
CheckInfo ci(pos);
@@ -1002,13 +1001,14 @@ moves_loop: // When in check search starts from here
// Decrease reduction for moves with a good history and
// increase reduction for moves with a bad history
int rDecrease = ( thisThread->history[pos.piece_on(to_sq(move))][to_sq(move)]
int rDecrease = ( thisThread->history[pos.piece_on(to_sq(move))][to_sq(move)]
+ cmh[pos.piece_on(to_sq(move))][to_sq(move)]) / 14980;
r = std::max(DEPTH_ZERO, r - rDecrease * ONE_PLY);
// Decrease reduction for moves that escape a capture. Filter out castling
// moves because are coded as "king captures rook" and break make_move().
// Also use see() instead of see_sign() because destination square is empty.
// Decrease reduction for moves that escape a capture. Filter out
// castling moves, because they are coded as "king captures rook" and
// hence break make_move(). Also use see() instead of see_sign(),
// because the destination square is empty.
if ( r
&& type_of(move) == NORMAL
&& type_of(pos.piece_on(to_sq(move))) != PAWN
@@ -1024,7 +1024,7 @@ moves_loop: // When in check search starts from here
else
doFullDepthSearch = !PvNode || moveCount > 1;
// Step 16. Full depth search, when LMR is skipped or fails high
// Step 16. Full depth search when LMR is skipped or fails high
if (doFullDepthSearch)
value = newDepth < ONE_PLY ?
givesCheck ? -qsearch<NonPV, true>(pos, ss+1, -(alpha+1), -alpha, DEPTH_ZERO)
@@ -1033,7 +1033,7 @@ moves_loop: // When in check search starts from here
// For PV nodes only, do a full PV search on the first move or after a fail
// high (in the latter case search only if value < beta), otherwise let the
// parent node fail low with value <= alpha and to try another move.
// parent node fail low with value <= alpha and try another move.
if (PvNode && (moveCount == 1 || (value > alpha && (RootNode || value < beta))))
{
(ss+1)->pv = pv;
@@ -1050,7 +1050,7 @@ moves_loop: // When in check search starts from here
assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
// Step 18. Check for new best move
// Step 18. Check for a new best move
// Finished searching the move. If a stop occurred, the return value of
// the search cannot be trusted, and we return immediately without
// updating best move, PV and TT.
@@ -1118,7 +1118,7 @@ moves_loop: // When in check search starts from here
quietsSearched[quietCount++] = move;
}
// Following condition would detect a stop only after move loop has been
// The following condition would detect a stop only after move loop has been
// completed. But in this case bestValue is valid because we have fully
// searched our subtree, and we can anyhow save the result in TT.
/*
@@ -1128,7 +1128,7 @@ moves_loop: // When in check search starts from here
// Step 20. Check for mate and stalemate
// All legal moves have been searched and if there are no legal moves, it
// must be mate or stalemate. If we are in a singular extension search then
// must be a mate or a stalemate. If we are in a singular extension search then
// return a fail low score.
if (!moveCount)
bestValue = excludedMove ? alpha
@@ -1148,7 +1148,7 @@ moves_loop: // When in check search starts from here
{
Value bonus = Value((depth / ONE_PLY) * (depth / ONE_PLY) + depth / ONE_PLY - 1);
Square prevPrevSq = to_sq((ss - 2)->currentMove);
CounterMovesStats& prevCmh = CounterMovesHistory[pos.piece_on(prevPrevSq)][prevPrevSq];
CounterMoveStats& prevCmh = CounterMoveHistory[pos.piece_on(prevPrevSq)][prevPrevSq];
prevCmh.update(pos.piece_on(prevSq), prevSq, bonus);
}
@@ -1334,7 +1334,7 @@ moves_loop: // When in check search starts from here
assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
// Check for new best move
// Check for a new best move
if (value > bestValue)
{
bestValue = value;
@@ -1425,7 +1425,7 @@ moves_loop: // When in check search starts from here
Value bonus = Value((depth / ONE_PLY) * (depth / ONE_PLY) + depth / ONE_PLY - 1);
Square prevSq = to_sq((ss-1)->currentMove);
CounterMovesStats& cmh = CounterMovesHistory[pos.piece_on(prevSq)][prevSq];
CounterMoveStats& cmh = CounterMoveHistory[pos.piece_on(prevSq)][prevSq];
Thread* thisThread = pos.this_thread();
thisThread->history.update(pos.moved_piece(move), to_sq(move), bonus);
@@ -1451,7 +1451,7 @@ moves_loop: // When in check search starts from here
&& is_ok((ss-2)->currentMove))
{
Square prevPrevSq = to_sq((ss-2)->currentMove);
CounterMovesStats& prevCmh = CounterMovesHistory[pos.piece_on(prevPrevSq)][prevPrevSq];
CounterMoveStats& prevCmh = CounterMoveHistory[pos.piece_on(prevPrevSq)][prevPrevSq];
prevCmh.update(pos.piece_on(prevSq), prevSq, -bonus - 2 * (depth + 1) / ONE_PLY);
}
}
@@ -1472,8 +1472,8 @@ moves_loop: // When in check search starts from here
int maxScore = -VALUE_INFINITE;
// Choose best move. For each move score we add two terms, both dependent on
// weakness. One deterministic and bigger for weaker levels, and one random,
// then we choose the move with the resulting highest score.
// weakness. One is deterministic and bigger for weaker levels, and one is
// random. Then we choose the move with the resulting highest score.
for (size_t i = 0; i < multiPV; ++i)
{
// This is our magic formula
@@ -1603,7 +1603,7 @@ void RootMove::insert_pv_in_tt(Position& pos) {
/// RootMove::extract_ponder_from_tt() is called in case we have no ponder move
/// before exiting the search, for instance in case we stop the search during a
/// before exiting the search, for instance, in case we stop the search during a
/// fail high at root. We try hard to have a ponder move to return to the GUI,
/// otherwise in case of 'ponder on' we have nothing to think on.