X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmovepick.h;h=36bf58f63ac329821156ea8539a7df20488e63af;hp=96986c84658723667b024f90627d3f221e24573f;hb=b96dd754ede60b8463606cf38eac3eab400a123d;hpb=c9dcda6ac488c0058ebd567e1f52e30b8cd0db20 diff --git a/src/movepick.h b/src/movepick.h index 96986c84..36bf58f6 100644 --- a/src/movepick.h +++ b/src/movepick.h @@ -1,7 +1,8 @@ /* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) - Copyright (C) 2008-2014 Marco Costalba, Joona Kiiski, Tord Romstad + Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad + Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -30,47 +31,61 @@ /// The Stats struct stores moves statistics. According to the template parameter -/// the class can store History, Gains and Countermoves. History records how often +/// the class can store History and Countermoves. History records how often /// different moves have been successful or unsuccessful during the current search -/// and is used for reduction and move ordering decisions. Gains records the move's -/// best evaluation gain from one ply to the next and is used for pruning decisions. +/// and is used for reduction and move ordering decisions. /// Countermoves store the move that refute a previous one. Entries are stored /// using only the moving piece and destination square, hence two moves with /// different origin but same destination and piece will be considered identical. -template +template struct Stats { - static const Value Max = Value(2000); + static const Value Max = Value(1 << 28); - const T* operator[](Piece p) const { return table[p]; } + const T* operator[](Piece pc) const { return table[pc]; } + T* operator[](Piece pc) { return table[pc]; } void clear() { std::memset(table, 0, sizeof(table)); } - void update(Piece p, Square to, Move m) { + void update(Piece pc, Square to, Move m) { table[pc][to] = m; } - if (m == table[p][to].first) - return; - - table[p][to].second = table[p][to].first; - table[p][to].first = m; - } - - void update(Piece p, Square to, Value v) { + void update(Piece pc, Square to, Value v) { - if (Gain) - table[p][to] = std::max(v, table[p][to] - 1); + if (abs(int(v)) >= 324) + return; - else if (abs(table[p][to] + v) < Max) - table[p][to] += v; + table[pc][to] -= table[pc][to] * abs(int(v)) / (CM ? 936 : 324); + table[pc][to] += int(v) * 32; } private: T table[PIECE_NB][SQUARE_NB]; }; -typedef Stats< true, Value> GainsStats; -typedef Stats HistoryStats; -typedef Stats > CountermovesStats; +typedef Stats MoveStats; +typedef Stats HistoryStats; +typedef Stats CounterMoveStats; +typedef Stats CounterMoveHistoryStats; + +struct FromToStats { + + Value get(Color c, Move m) const { return table[c][from_sq(m)][to_sq(m)]; } + void clear() { std::memset(table, 0, sizeof(table)); } + + void update(Color c, Move m, Value v) + { + if (abs(int(v)) >= 324) + return; + Square f = from_sq(m); + Square t = to_sq(m); + + table[c][f][t] -= table[c][f][t] * abs(int(v)) / 324; + table[c][f][t] += int(v) * 32; + } + +private: + Value table[COLOR_NB][SQUARE_NB][SQUARE_NB]; +}; /// 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 @@ -80,30 +95,30 @@ typedef Stats > CountermovesStats; /// to get a cut-off first. class MovePicker { - - MovePicker& operator=(const MovePicker&); // Silence a warning under MSVC - public: - MovePicker(const Position&, Move, Depth, const HistoryStats&, Square); - MovePicker(const Position&, Move, const HistoryStats&, PieceType); - MovePicker(const Position&, Move, Depth, const HistoryStats&, Move*, Search::Stack*); + MovePicker(const MovePicker&) = delete; + MovePicker& operator=(const MovePicker&) = delete; + + MovePicker(const Position&, Move, Value); + MovePicker(const Position&, Move, Depth, Square); + MovePicker(const Position&, Move, Depth, Search::Stack*); - template Move next_move(); + Move next_move(); private: template void score(); - void generate_next(); + ExtMove* begin() { return cur; } + ExtMove* end() { return endMoves; } const Position& pos; - const HistoryStats& history; - Search::Stack* ss; - Move* countermoves; + const Search::Stack* ss; + Move countermove; Depth depth; Move ttMove; - ExtMove killers[4]; Square recaptureSquare; - int captureThreshold, stage; - ExtMove *cur, *end, *endQuiets, *endBadCaptures; + Value threshold; + int stage; + ExtMove* cur, *endMoves, *endBadCaptures; ExtMove moves[MAX_MOVES]; };