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_TB_WIN_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_TB_WIN_IN_MAX_PLY
- || votes[th->rootMoves[0].pv[0]] > votes[bestThread->rootMoves[0].pv[0]])
+ || ( 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"];
// Reset aspiration window starting size
if (rootDepth >= 4)
{
- Value previousScore = rootMoves[pvIdx].previousScore;
+ Value prev = rootMoves[pvIdx].previousScore;
delta = Value(21);
- alpha = std::max(previousScore - delta,-VALUE_INFINITE);
- beta = std::min(previousScore + delta, VALUE_INFINITE);
+ 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 = Utility::clamp(fallingEval, 0.5, 1.5);
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);
}
}
+ CapturePieceToHistory& captureHistory = thisThread->captureHistory;
+
// Step 6. Static evaluation of the position
if (inCheck)
{
if (nullValue >= beta)
{
- // Do not return unproven mate scores
+ // Do not return unproven mate or TB scores
if (nullValue >= VALUE_TB_WIN_IN_MAX_PLY)
nullValue = beta;
&& depth >= 5
&& 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
MovePicker mp(pos, ttMove, depth, &thisThread->mainHistory,
&thisThread->lowPlyHistory,
- &thisThread->captureHistory,
+ &captureHistory,
contHist,
countermove,
ss->killers,
// 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 (!pos.see_ge(move, Value(-(32 - std::min(lmrDepth, 18)) * lmrDepth * lmrDepth)))
continue;
}
- else if (!pos.see_ge(move, Value(-194) * depth)) // (~25 Elo)
- continue;
+ 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 - (((ttPv && !PvNode) + 4) * depth) / 2;
- Depth singularDepth = (depth - 1 + 3 * (ttPv && !PvNode)) / 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, singularDepth, cutNode);
ss->excludedMove = MOVE_NONE;
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 -= 1 + (ttPv && !PvNode);
+ r -= 1 + formerPv;
if (!captureOrPromotion)
{
// Decrease/increase reduction for moves with a good/bad history (~30 Elo)
r -= ss->statScore / 16434;
}
-
- // Increase reduction for captures/promotions if late move and at low depth
- else if (depth < 8 && moveCount > 2)
- r++;
+ 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++;
+ }
Depth d = Utility::clamp(newDepth - r, 1, newDepth);