+++ /dev/null
-/*
- Stockfish, a UCI chess playing engine derived from Glaurung 2.1
- Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
- Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, 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
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
-
- Stockfish is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined(HISTORY_H_INCLUDED)
-#define HISTORY_H_INCLUDED
-
-#include <algorithm>
-#include <cstring>
-
-#include "types.h"
-
-/// The History class stores statistics about how often different moves
-/// have been successful or unsuccessful during the current search. These
-/// statistics are used for reduction and move ordering decisions. History
-/// entries are stored according only to moving piece and destination square,
-/// in particular two moves with different origin but same destination and
-/// same piece will be considered identical.
-
-class History {
-
-public:
- void clear();
- Value value(Piece p, Square to) const;
- void add(Piece p, Square to, Value bonus);
- Value gain(Piece p, Square to) const;
- void update_gain(Piece p, Square to, Value g);
-
- static const Value MaxValue = Value(2000);
-
-private:
- Value history[PIECE_NB][SQUARE_NB];
- Value maxGains[PIECE_NB][SQUARE_NB];
-};
-
-inline void History::clear() {
- memset(history, 0, 16 * 64 * sizeof(Value));
- memset(maxGains, 0, 16 * 64 * sizeof(Value));
-}
-
-inline Value History::value(Piece p, Square to) const {
- return history[p][to];
-}
-
-inline void History::add(Piece p, Square to, Value bonus) {
- if (abs(history[p][to] + bonus) < MaxValue) history[p][to] += bonus;
-}
-
-inline Value History::gain(Piece p, Square to) const {
- return maxGains[p][to];
-}
-
-inline void History::update_gain(Piece p, Square to, Value g) {
- maxGains[p][to] = std::max(g, maxGains[p][to] - 1);
-}
-
-#endif // !defined(HISTORY_H_INCLUDED)
}
+/// History class method definitions
+
+void History::clear() {
+ memset(history, 0, sizeof(history));
+ memset(gains, 0, sizeof(gains));
+}
+
+void History::update(Piece p, Square to, Value bonus) {
+ if (abs(history[p][to] + bonus) < History::Max)
+ history[p][to] += bonus;
+}
+
+void History::update_gain(Piece p, Square to, Value gain) {
+ gains[p][to] = std::max(gain, gains[p][to] - 1);
+}
+
+
/// Constructors of the MovePicker class. As arguments we pass information
/// to help it to return the presumably good moves first, to decide which
/// moves to return (in the quiescence search, for instance, we only want to
for (MoveStack* it = moves; it != end; ++it)
{
m = it->move;
- it->score = H.value(pos.piece_moved(m), to_sq(m));
+ it->score = H[pos.piece_moved(m)][to_sq(m)];
}
}
{
m = it->move;
if ((seeScore = pos.see_sign(m)) < 0)
- it->score = seeScore - History::MaxValue; // Be sure we are at the bottom
+ it->score = seeScore - History::Max; // Be sure we are at the bottom
else if (pos.is_capture(m))
it->score = PieceValue[MG][pos.piece_on(to_sq(m))]
- - type_of(pos.piece_moved(m)) + History::MaxValue;
+ - type_of(pos.piece_moved(m)) + History::Max;
else
- it->score = H.value(pos.piece_moved(m), to_sq(m));
+ it->score = H[pos.piece_moved(m)][to_sq(m)];
}
}
#if !defined MOVEPICK_H_INCLUDED
#define MOVEPICK_H_INCLUDED
-#include "history.h"
#include "position.h"
#include "search.h"
#include "types.h"
+/// The History class stores statistics about how often different moves
+/// have been successful or unsuccessful during the current search. These
+/// statistics are used for reduction and move ordering decisions. History
+/// entries are stored according only to moving piece and destination square,
+/// in particular two moves with different origin but same destination and
+/// same piece will be considered identical.
+
+class History {
+public:
+
+ static const Value Max = Value(2000);
+
+ const Value* operator[](Piece p) const { return &history[p][0]; }
+ Value gain(Piece p, Square to) const { return gains[p][to]; }
+
+ void clear();
+ void update(Piece p, Square to, Value bonus);
+ void update_gain(Piece p, Square to, Value gain);
+
+private:
+ Value history[PIECE_NB][SQUARE_NB];
+ Value gains[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
/// new pseudo legal move each time it is called, until there are no moves left,
#include "book.h"
#include "evaluate.h"
-#include "history.h"
#include "movegen.h"
#include "movepick.h"
#include "notation.h"
// Increase history value of the cut-off move
Value bonus = Value(int(depth) * int(depth));
- H.add(pos.piece_moved(bestMove), to_sq(bestMove), bonus);
+ H.update(pos.piece_moved(bestMove), to_sq(bestMove), bonus);
// Decrease history of all the other played non-capture moves
for (int i = 0; i < playedMoveCount - 1; i++)
{
Move m = movesSearched[i];
- H.add(pos.piece_moved(m), to_sq(m), -bonus);
+ H.update(pos.piece_moved(m), to_sq(m), -bonus);
}
}
}
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
+#include <algorithm> // For std::count
#include <cassert>
#include <iostream>
RootMoves.clear();
for (MoveList<LEGAL> ml(pos); !ml.end(); ++ml)
- if (searchMoves.empty() || count(searchMoves.begin(), searchMoves.end(), ml.move()))
+ if ( searchMoves.empty()
+ || std::count(searchMoves.begin(), searchMoves.end(), ml.move()))
RootMoves.push_back(RootMove(ml.move()));
main_thread()->thinking = true;