along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
+#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstring> // For std::memset
}
// Reductions lookup table, initialized at startup
- int Reductions[64]; // [depth or moveNumber]
+ int Reductions[MAX_MOVES]; // [depth or moveNumber]
template <bool PvNode> Depth reduction(bool i, Depth d, int mn) {
- int r = Reductions[std::min(d / ONE_PLY, 63)] * Reductions[std::min(mn, 63)] / 1024;
+ int r = Reductions[d / ONE_PLY] * Reductions[mn] / 1024;
return ((r + 512) / 1024 + (!i && r > 1024) - PvNode) * ONE_PLY;
}
void Search::init() {
- for (int i = 1; i < 64; ++i)
+ for (int i = 1; i < MAX_MOVES; ++i)
Reductions[i] = int(1024 * std::log(i) / std::sqrt(1.95));
}
assert(0 <= ss->ply && ss->ply < MAX_PLY);
(ss+1)->ply = ss->ply + 1;
- ss->currentMove = (ss+1)->excludedMove = bestMove = MOVE_NONE;
- ss->continuationHistory = &thisThread->continuationHistory[NO_PIECE][0];
+ (ss+1)->excludedMove = bestMove = MOVE_NONE;
(ss+2)->killers[0] = (ss+2)->killers[1] = MOVE_NONE;
Square prevSq = to_sq((ss-1)->currentMove);
if (!pos.capture_or_promotion(ttMove))
update_quiet_stats(pos, ss, ttMove, nullptr, 0, stat_bonus(depth));
- // Extra penalty for a quiet TT or main killer move in previous ply when it gets refuted
- if ( ((ss-1)->moveCount == 1 || (ss-1)->currentMove == (ss-1)->killers[0])
- && !pos.captured_piece())
+ // Extra penalty for early quiet moves of the previous ply
+ if ((ss-1)->moveCount <= 2 && !pos.captured_piece())
update_continuation_histories(ss-1, pos.piece_on(prevSq), prevSq, -stat_bonus(depth + ONE_PLY));
}
// Penalty for a quiet ttMove that fails low
&& move == ttMove
&& !rootNode
&& !excludedMove // Avoid recursive singular search
- /* && ttValue != VALUE_NONE Already implicit in the next condition */
+ /* && ttValue != VALUE_NONE Already implicit in the next condition */
&& abs(ttValue) < VALUE_KNOWN_WIN
&& (tte->bound() & BOUND_LOWER)
&& tte->depth() >= depth - 3 * ONE_PLY
else if (type_of(move) == CASTLING)
extension = ONE_PLY;
+ // Shuffle extension
+ else if ( PvNode
+ && pos.rule50_count() > 18
+ && depth < 3 * ONE_PLY
+ && ss->ply < 3 * thisThread->rootDepth / ONE_PLY) // To avoid too deep searches
+ extension = ONE_PLY;
+
// Passed pawn extension
else if ( move == ss->killers[0]
&& pos.advanced_pawn_push(move)
}
- // qsearch() is the quiescence search function, which is called by the main
- // search function with depth zero, or recursively with depth less than ONE_PLY.
+ // qsearch() is the quiescence search function, which is called by the main search
+ // function with zero depth, or recursively with further decreasing depth per call.
template <NodeType NT>
Value qsearch(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth) {
Thread* thisThread = pos.this_thread();
(ss+1)->ply = ss->ply + 1;
- ss->currentMove = bestMove = MOVE_NONE;
- ss->continuationHistory = &thisThread->continuationHistory[NO_PIECE][0];
+ bestMove = MOVE_NONE;
inCheck = pos.checkers();
moveCount = 0;