From: Marco Costalba Date: Tue, 27 Mar 2018 14:44:47 +0000 (+0200) Subject: Fix indentation in movepicker.cpp X-Git-Url: https://git.sesse.net/?p=stockfish;a=commitdiff_plain;h=280022baf78a52e9a5c34ef2aec6927aace3e83f Fix indentation in movepicker.cpp Fix indentation in movepicker.cpp and evaluate.cpp. Also move the PickType enum out of global space. No functional change --- diff --git a/src/evaluate.cpp b/src/evaluate.cpp index c50d14c2..5f8db741 100644 --- a/src/evaluate.cpp +++ b/src/evaluate.cpp @@ -412,7 +412,7 @@ namespace { constexpr Color Them = (Us == WHITE ? BLACK : WHITE); constexpr Bitboard Camp = (Us == WHITE ? AllSquares ^ Rank6BB ^ Rank7BB ^ Rank8BB - : AllSquares ^ Rank1BB ^ Rank2BB ^ Rank3BB); + : AllSquares ^ Rank1BB ^ Rank2BB ^ Rank3BB); const Square ksq = pos.square(Us); Bitboard weak, b, b1, b2, safe, unsafeChecks, pinned; diff --git a/src/movepick.cpp b/src/movepick.cpp index 4b8cf747..7ef7cafa 100644 --- a/src/movepick.cpp +++ b/src/movepick.cpp @@ -31,7 +31,7 @@ namespace { QSEARCH_TT, QCAPTURE_INIT, QCAPTURE, QCHECK_INIT, QCHECK }; - // Helper filter used with select_move() + // Helper filter used with select() const auto Any = [](){ return true; }; // partial_insertion_sort() sorts moves in descending order up to and including @@ -62,7 +62,7 @@ namespace { MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const ButterflyHistory* mh, const CapturePieceToHistory* cph, const PieceToHistory** ch, Move cm, Move* killers) : pos(p), mainHistory(mh), captureHistory(cph), contHistory(ch), - refutations{{killers[0], 0}, {killers[1], 0}, {cm, 0}}, depth(d){ + refutations{{killers[0], 0}, {killers[1], 0}, {cm, 0}}, depth(d) { assert(d > DEPTH_ZERO); @@ -85,7 +85,7 @@ MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const ButterflyHist stage += (ttMove == MOVE_NONE); } -/// MovePicker constructor for ProbCut: we generate captures with SEE higher +/// MovePicker constructor for ProbCut: we generate captures with SEE greater /// than or equal to the given threshold. MovePicker::MovePicker(const Position& p, Move ttm, Value th, const CapturePieceToHistory* cph) : pos(p), captureHistory(cph), threshold(th) { @@ -129,14 +129,14 @@ void MovePicker::score() { } } -/// MovePicker::select_move() returns the next move satisfying a predicate function. +/// MovePicker::select() returns the next move satisfying a predicate function. /// It never returns the TT move. -template -Move MovePicker::select_move(Pred filter) { +template +Move MovePicker::select(Pred filter) { while (cur < endMoves) { - if (T == BEST_SCORE) + if (T == Best) std::swap(*cur, *std::max_element(cur, endMoves)); move = *cur++; @@ -165,20 +165,23 @@ top: case CAPTURE_INIT: case PROBCUT_INIT: case QCAPTURE_INIT: - endBadCaptures = cur = moves; + cur = endBadCaptures = moves; endMoves = generate(pos, cur); + score(); ++stage; goto top; case GOOD_CAPTURE: - if (select_move([&](){ return pos.see_ge(move, Value(-55 * (cur-1)->value / 1024)) ? - // Move losing capture to endBadCaptures to be tried later - true : (*endBadCaptures++ = move, false); })) + if (select([&](){ + return pos.see_ge(move, Value(-55 * (cur-1)->value / 1024)) ? + // Move losing capture to endBadCaptures to be tried later + true : (*endBadCaptures++ = move, false); })) return move; // Prepare the pointers to loop over the refutations array - cur = std::begin(refutations), endMoves = std::end(refutations); + cur = std::begin(refutations); + endMoves = std::end(refutations); // If the countermove is the same as a killer, skip it if ( refutations[0].move == refutations[2].move @@ -189,9 +192,9 @@ top: /* fallthrough */ case REFUTATION: - if (select_move([&](){ return move != MOVE_NONE - && !pos.capture(move) - && pos.pseudo_legal(move); })) + if (select([&](){ return move != MOVE_NONE + && !pos.capture(move) + && pos.pseudo_legal(move); })) return move; ++stage; /* fallthrough */ @@ -199,6 +202,7 @@ top: case QUIET_INIT: cur = endBadCaptures; endMoves = generate(pos, cur); + score(); partial_insertion_sort(cur, endMoves, -4000 * depth / ONE_PLY); ++stage; @@ -206,35 +210,38 @@ top: case QUIET: if ( !skipQuiets - && select_move([&](){return move != refutations[0] - && move != refutations[1] - && move != refutations[2];})) + && select([&](){return move != refutations[0] + && move != refutations[1] + && move != refutations[2];})) return move; // Prepare the pointers to loop over the bad captures - cur = moves, endMoves = endBadCaptures; + cur = moves; + endMoves = endBadCaptures; + ++stage; /* fallthrough */ case BAD_CAPTURE: - return select_move(Any); + return select(Any); case EVASION_INIT: cur = moves; endMoves = generate(pos, cur); + score(); ++stage; /* fallthrough */ case EVASION: - return select_move(Any); + return select(Any); case PROBCUT: - return select_move([&](){ return pos.see_ge(move, threshold); }); + return select([&](){ return pos.see_ge(move, threshold); }); case QCAPTURE: - if (select_move([&](){ return depth > DEPTH_QS_RECAPTURES - || to_sq(move) == recaptureSquare; })) + if (select([&](){ return depth > DEPTH_QS_RECAPTURES + || to_sq(move) == recaptureSquare; })) return move; // If we did not find any move and we do not try checks, we have finished @@ -247,11 +254,12 @@ top: case QCHECK_INIT: cur = moves; endMoves = generate(pos, cur); + ++stage; /* fallthrough */ case QCHECK: - return select_move(Any); + return select(Any); } assert(false); diff --git a/src/movepick.h b/src/movepick.h index 60bf0b94..fc409a02 100644 --- a/src/movepick.h +++ b/src/movepick.h @@ -109,10 +109,10 @@ typedef Stats ContinuationHi /// when MOVE_NONE is returned. In order to improve the efficiency of the alpha /// beta algorithm, MovePicker attempts to return the moves which are most likely /// to get a cut-off first. +class MovePicker { -enum PickType { NEXT, BEST_SCORE }; + enum PickType { Next, Best }; -class MovePicker { public: MovePicker(const MovePicker&) = delete; MovePicker& operator=(const MovePicker&) = delete; @@ -122,7 +122,7 @@ public: Move next_move(bool skipQuiets = false); private: - template Move select_move(Pred); + template Move select(Pred); template void score(); ExtMove* begin() { return cur; } ExtMove* end() { return endMoves; }