X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmovepick.h;h=b6c073782408e9b730bd8bd2c006f748ec4c1a29;hb=564456a6a824bfca26d6d9af5b35a055eb9fc6c2;hp=503bfae1d8cc9fd97145abb5d3f014d24235f7a5;hpb=12e79be91039796299187ba1b2f1559552642ea4;p=stockfish diff --git a/src/movepick.h b/src/movepick.h index 503bfae1..b6c07378 100644 --- a/src/movepick.h +++ b/src/movepick.h @@ -1,8 +1,6 @@ /* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 - Copyright (C) 2004-2008 Tord Romstad (Glaurung author) - Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad - Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad + Copyright (C) 2004-2023 The Stockfish developers (see AUTHORS file) Stockfish is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -29,6 +27,8 @@ #include "position.h" #include "types.h" +namespace Stockfish { + /// StatsEntry stores the stat table value. It is usually a number but could /// be a move or even a nested history. We use a class instead of naked value /// to directly call history update operator<<() on the entry so to use stats @@ -36,18 +36,16 @@ template class StatsEntry { - static const bool IsInt = std::is_integral::value; - typedef typename std::conditional::type TT; - T entry; public: - T* get() { return &entry; } void operator=(const T& v) { entry = v; } - operator TT() const { return entry; } + T* operator&() { return &entry; } + T* operator->() { return &entry; } + operator const T&() const { return entry; } void operator<<(int bonus) { - assert(abs(bonus) <= D); // Ensure range is [-D, D] + assert(abs(bonus) <= D); // Ensure range is [-D, D] static_assert(D <= std::numeric_limits::max(), "D overflows T"); entry += bonus - entry * abs(bonus) / D; @@ -64,51 +62,56 @@ public: template struct Stats : public std::array, Size> { - T* get() { return this->at(0).get(); } + using stats = Stats; void fill(const T& v) { - T* p = get(); - std::fill(p, p + sizeof(*this) / sizeof(*p), v); + + // For standard-layout 'this' points to first struct member + assert(std::is_standard_layout::value); + + using entry = StatsEntry; + entry* p = reinterpret_cast(this); + std::fill(p, p + sizeof(*this) / sizeof(entry), v); } }; template -struct Stats : public std::array, Size> { - T* get() { return this->at(0).get(); } -}; +struct Stats : public std::array, Size> {}; /// In stats table, D=0 means that the template parameter is not used enum StatsParams { NOT_USED = 0 }; - +enum StatsType { NoCaptures, Captures }; /// ButterflyHistory records how often quiet moves have been successful or /// unsuccessful during the current search, and is used for reduction and move /// ordering decisions. It uses 2 tables (one for each color) indexed by -/// the move's from and to squares, see chessprogramming.wikispaces.com/Butterfly+Boards -typedef Stats ButterflyHistory; +/// the move's from and to squares, see www.chessprogramming.org/Butterfly_Boards +/// (~11 elo) +using ButterflyHistory = Stats; /// CounterMoveHistory stores counter moves indexed by [piece][to] of the previous -/// move, see chessprogramming.wikispaces.com/Countermove+Heuristic -typedef Stats CounterMoveHistory; +/// move, see www.chessprogramming.org/Countermove_Heuristic +using CounterMoveHistory = Stats; /// CapturePieceToHistory is addressed by a move's [piece][to][captured piece type] -typedef Stats CapturePieceToHistory; +using CapturePieceToHistory = Stats; /// PieceToHistory is like ButterflyHistory but is addressed by a move's [piece][to] -typedef Stats PieceToHistory; +using PieceToHistory = Stats; /// ContinuationHistory is the combined history of a given pair of moves, usually /// the current one given a previous one. The nested history table is based on /// PieceToHistory instead of ButterflyBoards. -typedef Stats ContinuationHistory; +/// (~63 elo) +using ContinuationHistory = Stats; -/// MovePicker class is used to pick one pseudo legal move at a time from the +/// MovePicker class is used to pick one pseudo-legal move at a time from the /// current position. The most important method is next_move(), which returns a -/// new pseudo legal move each time it is called, until there are no moves left, -/// 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. +/// new pseudo-legal move each time it is called, until there are no moves left, +/// 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 }; @@ -116,18 +119,20 @@ class MovePicker { public: MovePicker(const MovePicker&) = delete; MovePicker& operator=(const MovePicker&) = delete; - MovePicker(const Position&, Move, Value, const CapturePieceToHistory*); MovePicker(const Position&, Move, Depth, const ButterflyHistory*, const CapturePieceToHistory*, const PieceToHistory**, - Square); + Move, + const Move*); MovePicker(const Position&, Move, Depth, const ButterflyHistory*, const CapturePieceToHistory*, const PieceToHistory**, - Move, - Move*); + Square); + MovePicker(const Position&, Move, Value, const CapturePieceToHistory*); Move next_move(bool skipQuiets = false); + Bitboard threatenedPieces; + private: template Move select(Pred); template void score(); @@ -141,11 +146,12 @@ private: Move ttMove; ExtMove refutations[3], *cur, *endMoves, *endBadCaptures; int stage; - Move move; Square recaptureSquare; Value threshold; Depth depth; ExtMove moves[MAX_MOVES]; }; +} // namespace Stockfish + #endif // #ifndef MOVEPICK_H_INCLUDED