}
constexpr int futility_move_count(bool improving, Depth depth) {
- return (5 + depth * depth) * (1 + improving) / 2 - 1;
+ return (4 + depth * depth) / (2 - improving);
}
// History and stats update bonus, based on depth
Value value_from_tt(Value v, int ply, int r50c);
void update_pv(Move* pv, Move move, Move* childPv);
void update_continuation_histories(Stack* ss, Piece pc, Square to, int bonus);
- void update_quiet_stats(const Position& pos, Stack* ss, Move move, int bonus);
+ void update_quiet_stats(const Position& pos, Stack* ss, Move move, int bonus, int depth);
void update_all_stats(const Position& pos, Stack* ss, Move bestMove, Value bestValue, Value beta, Square prevSq,
Move* quietsSearched, int quietCount, Move* capturesSearched, int captureCount, Depth depth);
void Search::init() {
for (int i = 1; i < MAX_MOVES; ++i)
- Reductions[i] = int((24.8 + std::log(Threads.size()) / 2) * std::log(i));
+ Reductions[i] = int((24.8 + std::log(Threads.size())) * std::log(i));
}
std::map<Move, int64_t> votes;
Value minScore = this->rootMoves[0].score;
- // Find out minimum score
+ // Find minimum score
for (Thread* th: Threads)
minScore = std::min(minScore, th->rootMoves[0].score);
votes[th->rootMoves[0].pv[0]] +=
(th->rootMoves[0].score - minScore + 14) * int(th->completedDepth);
- if (bestThread->rootMoves[0].score >= VALUE_MATE_IN_MAX_PLY)
+ if (abs(bestThread->rootMoves[0].score) >= VALUE_TB_WIN_IN_MAX_PLY)
{
- // Make sure we pick the shortest mate
+ // Make sure we pick the shortest mate / TB conversion or stave off mate the longest
if (th->rootMoves[0].score > bestThread->rootMoves[0].score)
bestThread = th;
}
- else if ( th->rootMoves[0].score >= VALUE_MATE_IN_MAX_PLY
- || votes[th->rootMoves[0].pv[0]] > votes[bestThread->rootMoves[0].pv[0]])
+ else if ( th->rootMoves[0].score >= VALUE_TB_WIN_IN_MAX_PLY
+ || ( th->rootMoves[0].score > VALUE_TB_LOSS_IN_MAX_PLY
+ && votes[th->rootMoves[0].pv[0]] > votes[bestThread->rootMoves[0].pv[0]]))
bestThread = th;
}
}
- previousScore = bestThread->rootMoves[0].score;
+ bestPreviousScore = bestThread->rootMoves[0].score;
// Send again PV info if we have a new best thread
if (bestThread != this)
if (mainThread)
{
- if (mainThread->previousScore == VALUE_INFINITE)
+ if (mainThread->bestPreviousScore == VALUE_INFINITE)
for (int i=0; i<4; ++i)
mainThread->iterValue[i] = VALUE_ZERO;
else
for (int i=0; i<4; ++i)
- mainThread->iterValue[i] = mainThread->previousScore;
+ mainThread->iterValue[i] = mainThread->bestPreviousScore;
}
size_t multiPV = Options["MultiPV"];
// for match (TC 60+0.6) results spanning a wide range of k values.
PRNG rng(now());
double floatLevel = Options["UCI_LimitStrength"] ?
- clamp(std::pow((Options["UCI_Elo"] - 1346.6) / 143.4, 1 / 0.806), 0.0, 20.0) :
+ Utility::clamp(std::pow((Options["UCI_Elo"] - 1346.6) / 143.4, 1 / 0.806), 0.0, 20.0) :
double(Options["Skill Level"]);
int intLevel = int(floatLevel) +
((floatLevel - int(floatLevel)) * 1024 > rng.rand<unsigned>() % 1024 ? 1 : 0);
// Reset aspiration window starting size
if (rootDepth >= 4)
{
- Value previousScore = rootMoves[pvIdx].previousScore;
- delta = Value(21 + abs(previousScore) / 256);
- alpha = std::max(previousScore - delta,-VALUE_INFINITE);
- beta = std::min(previousScore + delta, VALUE_INFINITE);
+ Value prev = rootMoves[pvIdx].previousScore;
+ delta = Value(21);
+ alpha = std::max(prev - delta,-VALUE_INFINITE);
+ beta = std::min(prev + delta, VALUE_INFINITE);
// Adjust contempt based on root move's previousScore (dynamic contempt)
- int dct = ct + (102 - ct / 2) * previousScore / (abs(previousScore) + 157);
+ int dct = ct + (102 - ct / 2) * prev / (abs(prev) + 157);
contempt = (us == WHITE ? make_score(dct, dct / 2)
: -make_score(dct, dct / 2));
&& !Threads.stop
&& !mainThread->stopOnPonderhit)
{
- double fallingEval = (332 + 6 * (mainThread->previousScore - bestValue)
+ double fallingEval = (332 + 6 * (mainThread->bestPreviousScore - bestValue)
+ 6 * (mainThread->iterValue[iterIdx] - bestValue)) / 704.0;
- fallingEval = clamp(fallingEval, 0.5, 1.5);
+ fallingEval = Utility::clamp(fallingEval, 0.5, 1.5);
// If the bestMove is stable over several iterations, reduce time accordingly
timeReduction = lastBestMoveDepth + 9 < completedDepth ? 1.94 : 0.91;
Move ttMove, move, excludedMove, bestMove;
Depth extension, newDepth;
Value bestValue, value, ttValue, eval, maxValue;
- bool ttHit, ttPv, inCheck, givesCheck, improving, didLMR, priorCapture;
+ bool ttHit, ttPv, formerPv, inCheck, givesCheck, improving, didLMR, priorCapture;
bool captureOrPromotion, doFullDepthSearch, moveCountPruning, ttCapture, singularLMR;
Piece movedPiece;
int moveCount, captureCount, quietCount;
ttMove = rootNode ? thisThread->rootMoves[thisThread->pvIdx].pv[0]
: ttHit ? tte->move() : MOVE_NONE;
ttPv = PvNode || (ttHit && tte->is_pv());
+ formerPv = ttPv && !PvNode;
+
+ if (ttPv && depth > 12 && ss->ply - 1 < MAX_LPH && !pos.captured_piece() && is_ok((ss-1)->currentMove))
+ thisThread->lowPlyHistory[ss->ply - 1][from_to((ss-1)->currentMove)] << stat_bonus(depth - 5);
+
// thisThread->ttHitAverage can be used to approximate the running average of ttHit
thisThread->ttHitAverage = (ttHitAverageWindow - 1) * thisThread->ttHitAverage / ttHitAverageWindow
+ ttHitAverageResolution * ttHit;
if (ttValue >= beta)
{
if (!pos.capture_or_promotion(ttMove))
- update_quiet_stats(pos, ss, ttMove, stat_bonus(depth));
+ update_quiet_stats(pos, ss, ttMove, stat_bonus(depth), depth);
// Extra penalty for early quiet moves of the previous ply
if ((ss-1)->moveCount <= 2 && !priorCapture)
int drawScore = TB::UseRule50 ? 1 : 0;
- value = wdl < -drawScore ? -VALUE_MATE + MAX_PLY + ss->ply + 1
- : wdl > drawScore ? VALUE_MATE - MAX_PLY - ss->ply - 1
- : VALUE_DRAW + 2 * wdl * drawScore;
+ // use the range VALUE_MATE_IN_MAX_PLY to VALUE_TB_WIN_IN_MAX_PLY to score
+ value = wdl < -drawScore ? VALUE_MATED_IN_MAX_PLY + ss->ply + 1
+ : wdl > drawScore ? VALUE_MATE_IN_MAX_PLY - ss->ply - 1
+ : VALUE_DRAW + 2 * wdl * drawScore;
Bound b = wdl < -drawScore ? BOUND_UPPER
: wdl > drawScore ? BOUND_LOWER : BOUND_EXACT;
}
}
+ CapturePieceToHistory& captureHistory = thisThread->captureHistory;
+
// Step 6. Static evaluation of the position
if (inCheck)
{
ss->staticEval = eval = evaluate(pos) + bonus;
}
else
- ss->staticEval = eval = -(ss-1)->staticEval + 2 * Eval::Tempo;
+ ss->staticEval = eval = -(ss-1)->staticEval + 2 * Tempo;
tte->save(posKey, VALUE_NONE, ttPv, BOUND_NONE, DEPTH_NONE, MOVE_NONE, eval);
}
// Step 7. Razoring (~1 Elo)
if ( !rootNode // The required rootNode PV handling is not available in qsearch
- && depth < 2
+ && depth == 1
&& eval <= alpha - RazorMargin)
return qsearch<NT>(pos, ss, alpha, beta);
- improving = (ss-2)->staticEval == VALUE_NONE ? (ss->staticEval >= (ss-4)->staticEval
- || (ss-4)->staticEval == VALUE_NONE) : ss->staticEval >= (ss-2)->staticEval;
+ improving = (ss-2)->staticEval == VALUE_NONE ? (ss->staticEval > (ss-4)->staticEval
+ || (ss-4)->staticEval == VALUE_NONE) : ss->staticEval > (ss-2)->staticEval;
// Step 8. Futility pruning: child node (~50 Elo)
if ( !PvNode
&& (ss-1)->statScore < 23397
&& eval >= beta
&& eval >= ss->staticEval
- && ss->staticEval >= beta - 32 * depth + 292 - improving * 30
+ && ss->staticEval >= beta - 32 * depth - 30 * improving + 120 * ttPv + 292
&& !excludedMove
&& pos.non_pawn_material(us)
&& (ss->ply >= thisThread->nmpMinPly || us != thisThread->nmpColor))
if (nullValue >= beta)
{
- // Do not return unproven mate scores
- if (nullValue >= VALUE_MATE_IN_MAX_PLY)
+ // Do not return unproven mate or TB scores
+ if (nullValue >= VALUE_TB_WIN_IN_MAX_PLY)
nullValue = beta;
if (thisThread->nmpMinPly || (abs(beta) < VALUE_KNOWN_WIN && depth < 13))
// much above beta, we can (almost) safely prune the previous move.
if ( !PvNode
&& depth >= 5
- && abs(beta) < VALUE_MATE_IN_MAX_PLY)
+ && abs(beta) < VALUE_TB_WIN_IN_MAX_PLY)
{
- Value raisedBeta = std::min(beta + 189 - 45 * improving, VALUE_INFINITE);
- MovePicker mp(pos, ttMove, raisedBeta - ss->staticEval, &thisThread->captureHistory);
+ Value raisedBeta = beta + 189 - 45 * improving;
+ assert(raisedBeta < VALUE_INFINITE);
+ MovePicker mp(pos, ttMove, raisedBeta - ss->staticEval, &captureHistory);
int probCutCount = 0;
- while ( (move = mp.next_move()) != MOVE_NONE
- && probCutCount < 2 + 2 * cutNode)
+ while ( (move = mp.next_move()) != MOVE_NONE
+ && probCutCount < 2 + 2 * cutNode
+ && !( move == ttMove
+ && (tte->bound() & BOUND_LOWER)
+ && tte->depth() >= depth - 4
+ && ttValue < raisedBeta))
if (move != excludedMove && pos.legal(move))
{
assert(pos.capture_or_promotion(move));
Move countermove = thisThread->counterMoves[pos.piece_on(prevSq)][prevSq];
MovePicker mp(pos, ttMove, depth, &thisThread->mainHistory,
- &thisThread->captureHistory,
+ &thisThread->lowPlyHistory,
+ &captureHistory,
contHist,
countermove,
- ss->killers);
+ ss->killers,
+ depth > 12 ? ss->ply : MAX_PLY);
value = bestValue;
singularLMR = moveCountPruning = false;
// Step 13. Pruning at shallow depth (~200 Elo)
if ( !rootNode
&& pos.non_pawn_material(us)
- && bestValue > VALUE_MATED_IN_MAX_PLY)
+ && bestValue > VALUE_TB_LOSS_IN_MAX_PLY)
{
// Skip quiet moves if movecount exceeds our FutilityMoveCount threshold
moveCountPruning = moveCount >= futility_move_count(improving, depth);
+ // Reduced depth of the next LMR search
+ int lmrDepth = std::max(newDepth - reduction(improving, depth, moveCount), 0);
+
if ( !captureOrPromotion
&& !givesCheck)
{
- // Reduced depth of the next LMR search
- int lmrDepth = std::max(newDepth - reduction(improving, depth, moveCount), 0);
-
// Countermoves based pruning (~20 Elo)
if ( lmrDepth < 4 + ((ss-1)->statScore > 0 || (ss-1)->moveCount == 1)
&& (*contHist[0])[movedPiece][to_sq(move)] < CounterMovePruneThreshold
if ( lmrDepth < 6
&& !inCheck
&& ss->staticEval + 235 + 172 * lmrDepth <= alpha
- && thisThread->mainHistory[us][from_to(move)]
- + (*contHist[0])[movedPiece][to_sq(move)]
+ && (*contHist[0])[movedPiece][to_sq(move)]
+ (*contHist[1])[movedPiece][to_sq(move)]
- + (*contHist[3])[movedPiece][to_sq(move)] < 25000)
+ + (*contHist[3])[movedPiece][to_sq(move)] < 27400)
continue;
// Prune moves with negative SEE (~20 Elo)
if (!pos.see_ge(move, Value(-(32 - std::min(lmrDepth, 18)) * lmrDepth * lmrDepth)))
continue;
}
- else if (!pos.see_ge(move, Value(-194) * depth)) // (~25 Elo)
+ else
+ {
+ // Capture history based pruning when the move doesn't give check
+ if ( !givesCheck
+ && lmrDepth < 1
+ && captureHistory[movedPiece][to_sq(move)][type_of(pos.piece_on(to_sq(move)))] < 0)
continue;
+
+ // See based pruning
+ if (!pos.see_ge(move, Value(-194) * depth)) // (~25 Elo)
+ continue;
+ }
}
// Step 14. Extensions (~75 Elo)
&& tte->depth() >= depth - 3
&& pos.legal(move))
{
- Value singularBeta = ttValue - 2 * depth;
- Depth halfDepth = depth / 2;
+ Value singularBeta = ttValue - ((formerPv + 4) * depth) / 2;
+ Depth singularDepth = (depth - 1 + 3 * formerPv) / 2;
ss->excludedMove = move;
- value = search<NonPV>(pos, ss, singularBeta - 1, singularBeta, halfDepth, cutNode);
+ value = search<NonPV>(pos, ss, singularBeta - 1, singularBeta, singularDepth, cutNode);
ss->excludedMove = MOVE_NONE;
if (value < singularBeta)
if (type_of(move) == CASTLING)
extension = 1;
+ // Late irreversible move extension
+ if ( move == ttMove
+ && pos.rule50_count() > 80
+ && (captureOrPromotion || type_of(movedPiece) == PAWN))
+ extension = 2;
+
// Add extension to new depth
newDepth += extension;
// Step 16. Reduced depth search (LMR, ~200 Elo). If the move fails high it will be
// re-searched at full depth.
if ( depth >= 3
- && moveCount > 1 + rootNode + (rootNode && bestValue < alpha)
+ && moveCount > 1 + 2 * rootNode
&& (!rootNode || thisThread->best_move_count(move) == 0)
&& ( !captureOrPromotion
|| moveCountPruning
if (ttPv)
r -= 2;
+ if (moveCountPruning && !formerPv)
+ r++;
+
// Decrease reduction if opponent's move count is high (~5 Elo)
if ((ss-1)->moveCount > 14)
r--;
// Decrease reduction if ttMove has been singularly extended (~3 Elo)
if (singularLMR)
- r -= 2;
+ r -= 1 + formerPv;
if (!captureOrPromotion)
{
// hence break make_move(). (~2 Elo)
else if ( type_of(move) == NORMAL
&& !pos.see_ge(reverse_move(move)))
- r -= 2;
+ r -= 2 + ttPv;
ss->statScore = thisThread->mainHistory[us][from_to(move)]
+ (*contHist[0])[movedPiece][to_sq(move)]
+ (*contHist[3])[movedPiece][to_sq(move)]
- 4926;
- // Reset statScore to zero if negative and most stats shows >= 0
- if ( ss->statScore < 0
- && (*contHist[0])[movedPiece][to_sq(move)] >= 0
- && (*contHist[1])[movedPiece][to_sq(move)] >= 0
- && thisThread->mainHistory[us][from_to(move)] >= 0)
- ss->statScore = 0;
-
// Decrease/increase reduction by comparing opponent's stat score (~10 Elo)
if (ss->statScore >= -102 && (ss-1)->statScore < -114)
r--;
r++;
// Decrease/increase reduction for moves with a good/bad history (~30 Elo)
- r -= ss->statScore / 16384;
+ r -= ss->statScore / 16434;
+ }
+ else
+ {
+ // Increase reduction for captures/promotions if late move and at low depth
+ if (depth < 8 && moveCount > 2)
+ r++;
+
+ // Unless giving check, this capture is likely bad
+ if ( !givesCheck
+ && ss->staticEval + PieceValue[EG][pos.captured_piece()] + 200 * depth <= alpha)
+ r++;
}
- // Increase reduction for captures/promotions if late move and at low depth
- else if (depth < 8 && moveCount > 2)
- r++;
-
- Depth d = clamp(newDepth - r, 1, newDepth);
+ Depth d = Utility::clamp(newDepth - r, 1, newDepth);
value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, d, true);
- doFullDepthSearch = (value > alpha && d != newDepth), didLMR = true;
+ doFullDepthSearch = value > alpha && d != newDepth;
+
+ didLMR = true;
}
else
- doFullDepthSearch = !PvNode || moveCount > 1, didLMR = false;
+ {
+ doFullDepthSearch = !PvNode || moveCount > 1;
+
+ didLMR = false;
+ }
// Step 17. Full depth search when LMR is skipped or fails high
if (doFullDepthSearch)
if (PvNode)
bestValue = std::min(bestValue, maxValue);
- if (!excludedMove)
+ if (!excludedMove && !(rootNode && thisThread->pvIdx))
tte->save(posKey, value_to_tt(bestValue, ss->ply), ttPv,
bestValue >= beta ? BOUND_LOWER :
PvNode && bestMove ? BOUND_EXACT : BOUND_UPPER,
Move ttMove, move, bestMove;
Depth ttDepth;
Value bestValue, value, ttValue, futilityValue, futilityBase, oldAlpha;
- bool ttHit, pvHit, inCheck, givesCheck, captureOrPromotion, evasionPrunable;
+ bool ttHit, pvHit, inCheck, givesCheck, captureOrPromotion;
int moveCount;
if (PvNode)
else
ss->staticEval = bestValue =
(ss-1)->currentMove != MOVE_NULL ? evaluate(pos)
- : -(ss-1)->staticEval + 2 * Eval::Tempo;
+ : -(ss-1)->staticEval + 2 * Tempo;
// Stand pat. Return immediately if static value is at least beta
if (bestValue >= beta)
{
if (!ttHit)
- tte->save(posKey, value_to_tt(bestValue, ss->ply), pvHit, BOUND_LOWER,
+ tte->save(posKey, value_to_tt(bestValue, ss->ply), false, BOUND_LOWER,
DEPTH_NONE, MOVE_NONE, ss->staticEval);
return bestValue;
}
}
- // Detect non-capture evasions that are candidates to be pruned
- evasionPrunable = inCheck
- && (depth != 0 || moveCount > 2)
- && bestValue > VALUE_MATED_IN_MAX_PLY
- && !pos.capture(move);
-
// Don't search moves with negative SEE values
- if ( (!inCheck || evasionPrunable) && !pos.see_ge(move))
+ if ( !inCheck && !pos.see_ge(move))
continue;
// Speculative prefetch as early as possible
}
- // value_to_tt() adjusts a mate score from "plies to mate from the root" to
- // "plies to mate from the current position". Non-mate scores are unchanged.
+ // value_to_tt() adjusts a mate or TB score from "plies to mate from the root" to
+ // "plies to mate from the current position". standard scores are unchanged.
// The function is called before storing a value in the transposition table.
Value value_to_tt(Value v, int ply) {
assert(v != VALUE_NONE);
- return v >= VALUE_MATE_IN_MAX_PLY ? v + ply
- : v <= VALUE_MATED_IN_MAX_PLY ? v - ply : v;
+ return v >= VALUE_TB_WIN_IN_MAX_PLY ? v + ply
+ : v <= VALUE_TB_LOSS_IN_MAX_PLY ? v - ply : v;
}
- // value_from_tt() is the inverse of value_to_tt(): It adjusts a mate score
+ // value_from_tt() is the inverse of value_to_tt(): It adjusts a mate or TB score
// from the transposition table (which refers to the plies to mate/be mated
- // from current position) to "plies to mate/be mated from the root".
+ // from current position) to "plies to mate/be mated (TB win/loss) from the root".
+ // However, for mate scores, to avoid potentially false mate scores related to the 50 moves rule,
+ // and the graph history interaction, return an optimal TB score instead.
Value value_from_tt(Value v, int ply, int r50c) {
- return v == VALUE_NONE ? VALUE_NONE
- : v >= VALUE_MATE_IN_MAX_PLY ? VALUE_MATE - v > 99 - r50c ? VALUE_MATE_IN_MAX_PLY : v - ply
- : v <= VALUE_MATED_IN_MAX_PLY ? VALUE_MATE + v > 99 - r50c ? VALUE_MATED_IN_MAX_PLY : v + ply : v;
+ if (v == VALUE_NONE)
+ return VALUE_NONE;
+
+ if (v >= VALUE_TB_WIN_IN_MAX_PLY) // TB win or better
+ {
+ if (v >= VALUE_MATE_IN_MAX_PLY && VALUE_MATE - v > 99 - r50c)
+ return VALUE_MATE_IN_MAX_PLY - 1; // do not return a potentially false mate score
+
+ return v - ply;
+ }
+
+ if (v <= VALUE_TB_LOSS_IN_MAX_PLY) // TB loss or worse
+ {
+ if (v <= VALUE_MATED_IN_MAX_PLY && VALUE_MATE + v > 99 - r50c)
+ return VALUE_MATED_IN_MAX_PLY + 1; // do not return a potentially false mate score
+
+ return v + ply;
+ }
+
+ return v;
}
if (!pos.capture_or_promotion(bestMove))
{
- update_quiet_stats(pos, ss, bestMove, bonus2);
+ update_quiet_stats(pos, ss, bestMove, bonus2, depth);
// Decrease all the non-best quiet moves
for (int i = 0; i < quietCount; ++i)
// update_continuation_histories() updates histories of the move pairs formed
- // by moves at ply -1, -2, and -4 with current move.
+ // by moves at ply -1, -2, -4, and -6 with current move.
void update_continuation_histories(Stack* ss, Piece pc, Square to, int bonus) {
// update_quiet_stats() updates move sorting heuristics
- void update_quiet_stats(const Position& pos, Stack* ss, Move move, int bonus) {
+ void update_quiet_stats(const Position& pos, Stack* ss, Move move, int bonus, int depth) {
if (ss->killers[0] != move)
{
Square prevSq = to_sq((ss-1)->currentMove);
thisThread->counterMoves[pos.piece_on(prevSq)][prevSq] = move;
}
+
+ if (depth > 12 && ss->ply < MAX_LPH)
+ thisThread->lowPlyHistory[ss->ply][from_to(move)] << stat_bonus(depth - 7);
}
// When playing with strength handicap, choose best move among a set of RootMoves
Depth d = updated ? depth : depth - 1;
Value v = updated ? rootMoves[i].score : rootMoves[i].previousScore;
- bool tb = TB::RootInTB && abs(v) < VALUE_MATE - MAX_PLY;
+ bool tb = TB::RootInTB && abs(v) < VALUE_MATE_IN_MAX_PLY;
v = tb ? rootMoves[i].tbScore : v;
if (ss.rdbuf()->in_avail()) // Not at first line
projects / stockfish / blobdiff