#include <array>
#include <cassert>
+#include <cmath>
#include <cstdint>
#include <cstdlib>
#include <limits>
#include "movegen.h"
#include "types.h"
+#include "position.h"
namespace Stockfish {
-class Position;
+
+constexpr int PAWN_HISTORY_SIZE = 512; // has to be a power of 2
+
+static_assert((PAWN_HISTORY_SIZE & (PAWN_HISTORY_SIZE - 1)) == 0,
+ "PAWN_HISTORY_SIZE has to be a power of 2");
+
+inline int pawn_structure(const Position& pos) { return pos.pawn_key() & (PAWN_HISTORY_SIZE - 1); }
// 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 a naked value
operator const T&() const { return entry; }
void operator<<(int bonus) {
- assert(abs(bonus) <= D); // Ensure range is [-D, D]
+ assert(std::abs(bonus) <= D); // Ensure range is [-D, D]
static_assert(D <= std::numeric_limits<T>::max(), "D overflows T");
- entry += (bonus * D - entry * abs(bonus)) / (D * 5 / 4);
+ entry += bonus - entry * std::abs(bonus) / D;
- assert(abs(entry) <= D);
+ assert(std::abs(entry) <= D);
}
};
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 www.chessprogramming.org/Butterfly_Boards
-// (~11 elo)
+// 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 www.chessprogramming.org/Butterfly_Boards (~11 elo)
using ButterflyHistory = Stats<int16_t, 7183, COLOR_NB, int(SQUARE_NB) * int(SQUARE_NB)>;
// CounterMoveHistory stores counter moves indexed by [piece][to] of the previous
// (~63 elo)
using ContinuationHistory = Stats<PieceToHistory, NOT_USED, PIECE_NB, SQUARE_NB>;
+// PawnHistory is addressed by the pawn structure and a move's [piece][to]
+using PawnHistory = Stats<int16_t, 8192, PAWN_HISTORY_SIZE, PIECE_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
const ButterflyHistory*,
const CapturePieceToHistory*,
const PieceToHistory**,
+ const PawnHistory*,
Move,
const Move*);
MovePicker(const Position&,
const ButterflyHistory*,
const CapturePieceToHistory*,
const PieceToHistory**,
- Square);
+ const PawnHistory*);
MovePicker(const Position&, Move, Value, const CapturePieceToHistory*);
Move next_move(bool skipQuiets = false);
const ButterflyHistory* mainHistory;
const CapturePieceToHistory* captureHistory;
const PieceToHistory** continuationHistory;
+ const PawnHistory* pawnHistory;
Move ttMove;
ExtMove refutations[3], *cur, *endMoves, *endBadCaptures;
int stage;
- Square recaptureSquare;
Value threshold;
Depth depth;
ExtMove moves[MAX_MOVES];