kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-05-01 01:03:09 +00:00
Code Issues Releases Wiki Activity

Tempeltize material imbalance

Browse source 
Speedup of almost 1%

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba 2011-04-11 11:32:55 +02:00
parent 7a84b8ca34
commit c88eebc989
4 changed files with 105 additions and 108 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

166
src/material.cpp
View file

@ -17,11 +17,6 @@
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
////
//// Includes
////
#include <cassert> #include <cassert>
#include <cstring> #include <cstring>
#include <map> #include <map>
@ -30,11 +25,6 @@
using namespace std; using namespace std;
////
//// Local definitions
////
namespace { namespace {
// Values modified by Joona Kiiski // Values modified by Joona Kiiski
@ -77,7 +67,7 @@ namespace {
&& pos.non_pawn_material(Us) >= RookValueMidgame; && pos.non_pawn_material(Us) >= RookValueMidgame;
} }
template<Color Us> bool is_KBPsK(const Position& pos) { template<Color Us> bool is_KBPsKs(const Position& pos) {
return pos.non_pawn_material(Us) == BishopValueMidgame return pos.non_pawn_material(Us) == BishopValueMidgame
&& pos.piece_count(Us, BISHOP) == 1 && pos.piece_count(Us, BISHOP) == 1
&& pos.piece_count(Us, PAWN) >= 1; && pos.piece_count(Us, PAWN) >= 1;
@ -94,10 +84,6 @@ namespace {
} }
////
//// Classes
////
/// EndgameFunctions class stores endgame evaluation and scaling functions /// EndgameFunctions class stores endgame evaluation and scaling functions
/// in two std::map. Because STL library is not guaranteed to be thread /// in two std::map. Because STL library is not guaranteed to be thread
/// safe even for read access, the maps, although with identical content, /// safe even for read access, the maps, although with identical content,
@ -128,29 +114,11 @@ template<> const EFMap& EndgameFunctions::get<EF>() const { return maps.first; }
template<> const SFMap& EndgameFunctions::get<SF>() const { return maps.second; } template<> const SFMap& EndgameFunctions::get<SF>() const { return maps.second; }
//// /// MaterialInfoTable c'tor and d'tor allocate and free the space for EndgameFunctions
//// Functions
////
MaterialInfoTable::MaterialInfoTable() { funcs = new EndgameFunctions(); } MaterialInfoTable::MaterialInfoTable() { funcs = new EndgameFunctions(); }
MaterialInfoTable::~MaterialInfoTable() { delete funcs; } MaterialInfoTable::~MaterialInfoTable() { delete funcs; }
/// MaterialInfoTable::game_phase() calculates the phase given the current
/// position. Because the phase is strictly a function of the material, it
/// is stored in MaterialInfo.
Phase MaterialInfoTable::game_phase(const Position& pos) {
Value npm = pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK);
if (npm >= MidgameLimit)
return PHASE_MIDGAME;
if (npm <= EndgameLimit)
return PHASE_ENDGAME;
return Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit));
}
/// MaterialInfoTable::get_material_info() takes a position object as input, /// MaterialInfoTable::get_material_info() takes a position object as input,
/// computes or looks up a MaterialInfo object, and returns a pointer to it. /// computes or looks up a MaterialInfo object, and returns a pointer to it.
@ -158,7 +126,7 @@ Phase MaterialInfoTable::game_phase(const Position& pos) {
/// is stored there, so we don't have to recompute everything when the /// is stored there, so we don't have to recompute everything when the
/// same material configuration occurs again. /// same material configuration occurs again.
MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) { MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) const {
Key key = pos.get_material_key(); Key key = pos.get_material_key();
MaterialInfo* mi = find(key); MaterialInfo* mi = find(key);
@ -169,10 +137,10 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
if (mi->key == key) if (mi->key == key)
return mi; return mi;
// Clear the MaterialInfo object, and set its key // Initialize MaterialInfo entry
memset(mi, 0, sizeof(MaterialInfo)); memset(mi, 0, sizeof(MaterialInfo));
mi->factor[WHITE] = mi->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL;
mi->key = key; mi->key = key;
mi->factor[WHITE] = mi->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL;
// Store game phase // Store game phase
mi->gamePhase = MaterialInfoTable::game_phase(pos); mi->gamePhase = MaterialInfoTable::game_phase(pos);
@ -183,15 +151,19 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
if ((mi->evaluationFunction = funcs->get<EF>(key)) != NULL) if ((mi->evaluationFunction = funcs->get<EF>(key)) != NULL)
return mi; return mi;
if (is_KXK<WHITE>(pos) || is_KXK<BLACK>(pos)) if (is_KXK<WHITE>(pos))
{ {
mi->evaluationFunction = is_KXK<WHITE>(pos) ? &EvaluateKXK[WHITE] : &EvaluateKXK[BLACK]; mi->evaluationFunction = &EvaluateKXK[WHITE];
return mi; return mi;
} }
if ( pos.pieces(PAWN) == EmptyBoardBB if (is_KXK<BLACK>(pos))
&& pos.pieces(ROOK) == EmptyBoardBB {
&& pos.pieces(QUEEN) == EmptyBoardBB) mi->evaluationFunction = &EvaluateKXK[BLACK];
return mi;
}
if (!pos.pieces(PAWN) && !pos.pieces(ROOK) && !pos.pieces(QUEEN))
{ {
// Minor piece endgame with at least one minor piece per side and // Minor piece endgame with at least one minor piece per side and
// no pawns. Note that the case KmmK is already handled by KXK. // no pawns. Note that the case KmmK is already handled by KXK.
@ -222,10 +194,10 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
// Generic scaling functions that refer to more then one material // Generic scaling functions that refer to more then one material
// distribution. Should be probed after the specialized ones. // distribution. Should be probed after the specialized ones.
// Note that these ones don't return after setting the function. // Note that these ones don't return after setting the function.
if (is_KBPsK<WHITE>(pos)) if (is_KBPsKs<WHITE>(pos))
mi->scalingFunction[WHITE] = &ScaleKBPsK[WHITE]; mi->scalingFunction[WHITE] = &ScaleKBPsK[WHITE];
if (is_KBPsK<BLACK>(pos)) if (is_KBPsKs<BLACK>(pos))
mi->scalingFunction[BLACK] = &ScaleKBPsK[BLACK]; mi->scalingFunction[BLACK] = &ScaleKBPsK[BLACK];
if (is_KQKRPs<WHITE>(pos)) if (is_KQKRPs<WHITE>(pos))
@ -255,32 +227,8 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
} }
} }
// Compute the space weight
if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >=
2*QueenValueMidgame + 4*RookValueMidgame + 2*KnightValueMidgame)
{
int minorPieceCount = pos.piece_count(WHITE, KNIGHT)
+ pos.piece_count(BLACK, KNIGHT)
+ pos.piece_count(WHITE, BISHOP)
+ pos.piece_count(BLACK, BISHOP);
mi->spaceWeight = minorPieceCount * minorPieceCount;
}
// Evaluate the material balance
const int pieceCount[2][8] = {
{ pos.piece_count(WHITE, BISHOP) > 1, pos.piece_count(WHITE, PAWN), pos.piece_count(WHITE, KNIGHT),
pos.piece_count(WHITE, BISHOP), pos.piece_count(WHITE, ROOK), pos.piece_count(WHITE, QUEEN) },
{ pos.piece_count(BLACK, BISHOP) > 1, pos.piece_count(BLACK, PAWN), pos.piece_count(BLACK, KNIGHT),
pos.piece_count(BLACK, BISHOP), pos.piece_count(BLACK, ROOK), pos.piece_count(BLACK, QUEEN) } };
Color c, them;
int sign, pt1, pt2, pc;
int v, vv, matValue = 0;
for (c = WHITE, sign = 1; c <= BLACK; c++, sign = -sign)
{
// No pawns makes it difficult to win, even with a material advantage // No pawns makes it difficult to win, even with a material advantage
for (Color c = WHITE; c <= BLACK; c++)
if ( pos.piece_count(c, PAWN) == 0 if ( pos.piece_count(c, PAWN) == 0
&& pos.non_pawn_material(c) - pos.non_pawn_material(opposite_color(c)) <= BishopValueMidgame) && pos.non_pawn_material(c) - pos.non_pawn_material(opposite_color(c)) <= BishopValueMidgame)
{ {
@ -303,37 +251,83 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
} }
} }
// Compute the space weight
if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >=
2*QueenValueMidgame + 4*RookValueMidgame + 2*KnightValueMidgame)
{
int minorPieceCount = pos.piece_count(WHITE, KNIGHT)
+ pos.piece_count(WHITE, BISHOP)
+ pos.piece_count(BLACK, KNIGHT)
+ pos.piece_count(BLACK, BISHOP);
mi->spaceWeight = minorPieceCount * minorPieceCount;
}
// Evaluate the material imbalance. We use PIECE_TYPE_NONE as a place holder
// for the bishop pair "extended piece", this allow us to be more flexible
// in defining bishop pair bonuses.
const int pieceCount[2][8] = {
{ pos.piece_count(WHITE, BISHOP) > 1, pos.piece_count(WHITE, PAWN), pos.piece_count(WHITE, KNIGHT),
pos.piece_count(WHITE, BISHOP), pos.piece_count(WHITE, ROOK), pos.piece_count(WHITE, QUEEN) },
{ pos.piece_count(BLACK, BISHOP) > 1, pos.piece_count(BLACK, PAWN), pos.piece_count(BLACK, KNIGHT),
pos.piece_count(BLACK, BISHOP), pos.piece_count(BLACK, ROOK), pos.piece_count(BLACK, QUEEN) } };
mi->value = (int16_t)(imbalance<WHITE>(pieceCount) - imbalance<BLACK>(pieceCount)) / 16;
return mi;
}
/// MaterialInfoTable::imbalance() calculates imbalance comparing piece count of each
/// piece type for both colors.
template<Color Us>
int MaterialInfoTable::imbalance(const int pieceCount[][8]) {
const Color Them = (Us == WHITE ? BLACK : WHITE);
int pt1, pt2, pc, vv;
int value = 0;
// Redundancy of major pieces, formula based on Kaufman's paper // Redundancy of major pieces, formula based on Kaufman's paper
// "The Evaluation of Material Imbalances in Chess" // "The Evaluation of Material Imbalances in Chess"
// http://mywebpages.comcast.net/danheisman/Articles/evaluation_of_material_imbalance.htm if (pieceCount[Us][ROOK] > 0)
if (pieceCount[c][ROOK] >= 1) value -= RedundantRookPenalty * (pieceCount[Us][ROOK] - 1)
matValue -= sign * ((pieceCount[c][ROOK] - 1) * RedundantRookPenalty + pieceCount[c][QUEEN] * RedundantQueenPenalty); + RedundantQueenPenalty * pieceCount[Us][QUEEN];
them = opposite_color(c);
v = 0;
// Second-degree polynomial material imbalance by Tord Romstad // Second-degree polynomial material imbalance by Tord Romstad
//
// We use PIECE_TYPE_NONE as a place holder for the bishop pair "extended piece",
// this allow us to be more flexible in defining bishop pair bonuses.
for (pt1 = PIECE_TYPE_NONE; pt1 <= QUEEN; pt1++) for (pt1 = PIECE_TYPE_NONE; pt1 <= QUEEN; pt1++)
{ {
pc = pieceCount[c][pt1]; pc = pieceCount[Us][pt1];
if (!pc) if (!pc)
continue; continue;
vv = LinearCoefficients[pt1]; vv = LinearCoefficients[pt1];
for (pt2 = PIECE_TYPE_NONE; pt2 <= pt1; pt2++) for (pt2 = PIECE_TYPE_NONE; pt2 <= pt1; pt2++)
vv += pieceCount[c][pt2] * QuadraticCoefficientsSameColor[pt1][pt2] vv += QuadraticCoefficientsSameColor[pt1][pt2] * pieceCount[Us][pt2]
+ pieceCount[them][pt2] * QuadraticCoefficientsOppositeColor[pt1][pt2]; + QuadraticCoefficientsOppositeColor[pt1][pt2] * pieceCount[Them][pt2];
v += pc * vv; value += pc * vv;
} }
matValue += sign * v; return value;
} }
mi->value = (int16_t)(matValue / 16);
return mi;
/// MaterialInfoTable::game_phase() calculates the phase given the current
/// position. Because the phase is strictly a function of the material, it
/// is stored in MaterialInfo.
Phase MaterialInfoTable::game_phase(const Position& pos) {
Value npm = pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK);
if (npm >= MidgameLimit)
return PHASE_MIDGAME;
if (npm <= EndgameLimit)
return PHASE_ENDGAME;
return Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit));
} }

5
src/material.h
View file

@ -68,10 +68,13 @@ class MaterialInfoTable : public SimpleHash<MaterialInfo, MaterialTableSize> {
public: public:
MaterialInfoTable(); MaterialInfoTable();
~MaterialInfoTable(); ~MaterialInfoTable();
MaterialInfo* get_material_info(const Position& pos); MaterialInfo* get_material_info(const Position& pos) const;
static Phase game_phase(const Position& pos); static Phase game_phase(const Position& pos);
private: private:
template<Color Us>
static int imbalance(const int pieceCount[][8]);
EndgameFunctions* funcs; EndgameFunctions* funcs;
}; };

2
src/pawns.cpp
View file

@ -106,7 +106,7 @@ PawnInfo* PawnInfoTable::get_pawn_info(const Position& pos) const {
template<Color Us> template<Color Us>
Score PawnInfoTable::evaluate_pawns(const Position& pos, Bitboard ourPawns, Score PawnInfoTable::evaluate_pawns(const Position& pos, Bitboard ourPawns,
Bitboard theirPawns, PawnInfo* pi) const { Bitboard theirPawns, PawnInfo* pi) {
const BitCountType Max15 = CpuIs64Bit ? CNT64_MAX15 : CNT32_MAX15; const BitCountType Max15 = CpuIs64Bit ? CNT64_MAX15 : CNT32_MAX15;
const Color Them = (Us == WHITE ? BLACK : WHITE); const Color Them = (Us == WHITE ? BLACK : WHITE);

2
src/pawns.h
View file

@ -71,7 +71,7 @@ public:
private: private:
template<Color Us> template<Color Us>
Score evaluate_pawns(const Position& pos, Bitboard ourPawns, Bitboard theirPawns, PawnInfo* pi) const; static Score evaluate_pawns(const Position& pos, Bitboard ourPawns, Bitboard theirPawns, PawnInfo* pi);
}; };