X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmaterial.cpp;h=3474ccd576c5e613c7fd3373b0e71edf6fd1ca1c;hp=323611779963de5f62baf564e8ae98e920a9160b;hb=3e4dfb49a747be902d25ae06783f98ba29fb5030;hpb=b84af67f4c88f3e3f7b61bf2035475f79fb3e62e
diff --git a/src/material.cpp b/src/material.cpp
index 32361177..3474ccd5 100644
--- a/src/material.cpp
+++ b/src/material.cpp
@@ -1,7 +1,7 @@
/*
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
+ Copyright (C) 2008-2013 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
@@ -17,7 +17,7 @@
along with this program. If not, see .
*/
-#include
+#include // For std::min
#include
#include
@@ -38,15 +38,29 @@ namespace {
const Value RedundantQueenPenalty = Value(320);
const Value RedundantRookPenalty = Value(554);
- const int LinearCoefficients[6] = { 1617, -162, -1172, -190, 105, 26 };
-
- const int QuadraticCoefficientsSameColor[][8] = {
- { 7, 7, 7, 7, 7, 7 }, { 39, 2, 7, 7, 7, 7 }, { 35, 271, -4, 7, 7, 7 },
- { 7, 25, 4, 7, 7, 7 }, { -27, -2, 46, 100, 56, 7 }, { 58, 29, 83, 148, -3, -25 } };
-
- const int QuadraticCoefficientsOppositeColor[][8] = {
- { 41, 41, 41, 41, 41, 41 }, { 37, 41, 41, 41, 41, 41 }, { 10, 62, 41, 41, 41, 41 },
- { 57, 64, 39, 41, 41, 41 }, { 50, 40, 23, -22, 41, 41 }, { 106, 101, 3, 151, 171, 41 } };
+ // pair pawn knight bishop rook queen
+ const int LinearCoefficients[6] = { 1617, -162, -1172, -62, 105, 26 };
+
+ const int QuadraticCoefficientsSameColor[][PIECE_TYPE_NB] = {
+ // pair pawn knight bishop rook queen
+ { 7 }, // Bishop pair
+ { 39, 2 }, // Pawn
+ { 35, 271, -4 }, // Knight
+ { 7, 25, 4, 7 }, // Bishop
+ { -27, -2, 46, 100, 56 }, // Rook
+ { 58, 29, 83, 148, -3, -25 } // Queen
+ };
+
+ const int QuadraticCoefficientsOppositeColor[][PIECE_TYPE_NB] = {
+ // THEIR PIECES
+ // pair pawn knight bishop rook queen
+ { 41 }, // Bishop pair
+ { 37, 41 }, // Pawn
+ { 10, 62, 41 }, // Knight OUR PIECES
+ { 57, 64, 39, 41 }, // Bishop
+ { 50, 40, 23, -22, 41 }, // Rook
+ { 106, 101, 3, 151, 171, 41 } // Queen
+ };
// Endgame evaluation and scaling functions accessed direcly and not through
// the function maps because correspond to more then one material hash key.
@@ -81,18 +95,54 @@ namespace {
&& pos.piece_count(Them, PAWN) >= 1;
}
+ /// imbalance() calculates imbalance comparing piece count of each
+ /// piece type for both colors.
+
+ template
+ int imbalance(const int pieceCount[][PIECE_TYPE_NB]) {
+
+ const Color Them = (Us == WHITE ? BLACK : WHITE);
+
+ int pt1, pt2, pc, v;
+ int value = 0;
+
+ // Redundancy of major pieces, formula based on Kaufman's paper
+ // "The Evaluation of Material Imbalances in Chess"
+ if (pieceCount[Us][ROOK] > 0)
+ value -= RedundantRookPenalty * (pieceCount[Us][ROOK] - 1)
+ + RedundantQueenPenalty * pieceCount[Us][QUEEN];
+
+ // Second-degree polynomial material imbalance by Tord Romstad
+ for (pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; pt1++)
+ {
+ pc = pieceCount[Us][pt1];
+ if (!pc)
+ continue;
+
+ v = LinearCoefficients[pt1];
+
+ for (pt2 = NO_PIECE_TYPE; pt2 <= pt1; pt2++)
+ v += QuadraticCoefficientsSameColor[pt1][pt2] * pieceCount[Us][pt2]
+ + QuadraticCoefficientsOppositeColor[pt1][pt2] * pieceCount[Them][pt2];
+
+ value += pc * v;
+ }
+ return value;
+ }
+
} // namespace
+namespace Material {
-/// MaterialTable::probe() takes a position object as input, looks up a MaterialEntry
+/// Material::probe() takes a position object as input, looks up a MaterialEntry
/// object, and returns a pointer to it. If the material configuration is not
/// already present in the table, it is computed and stored there, so we don't
/// have to recompute everything when the same material configuration occurs again.
-MaterialEntry* MaterialTable::probe(const Position& pos) {
+Entry* probe(const Position& pos, Table& entries, Endgames& endgames) {
Key key = pos.material_key();
- MaterialEntry* e = entries[key];
+ Entry* e = entries[key];
// If e->key matches the position's material hash key, it means that we
// have analysed this material configuration before, and we can simply
@@ -100,10 +150,10 @@ MaterialEntry* MaterialTable::probe(const Position& pos) {
if (e->key == key)
return e;
- memset(e, 0, sizeof(MaterialEntry));
+ memset(e, 0, sizeof(Entry));
e->key = key;
e->factor[WHITE] = e->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL;
- e->gamePhase = MaterialTable::game_phase(pos);
+ e->gamePhase = game_phase(pos);
// Let's look if we have a specialized evaluation function for this
// particular material configuration. First we look for a fixed
@@ -215,7 +265,7 @@ MaterialEntry* MaterialTable::probe(const Position& pos) {
// 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] = {
+ const int pieceCount[COLOR_NB][PIECE_TYPE_NB] = {
{ 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),
@@ -226,47 +276,11 @@ MaterialEntry* MaterialTable::probe(const Position& pos) {
}
-/// MaterialTable::imbalance() calculates imbalance comparing piece count of each
-/// piece type for both colors.
-
-template
-int MaterialTable::imbalance(const int pieceCount[][8]) {
-
- const Color Them = (Us == WHITE ? BLACK : WHITE);
-
- int pt1, pt2, pc, v;
- int value = 0;
-
- // Redundancy of major pieces, formula based on Kaufman's paper
- // "The Evaluation of Material Imbalances in Chess"
- if (pieceCount[Us][ROOK] > 0)
- value -= RedundantRookPenalty * (pieceCount[Us][ROOK] - 1)
- + RedundantQueenPenalty * pieceCount[Us][QUEEN];
-
- // Second-degree polynomial material imbalance by Tord Romstad
- for (pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; pt1++)
- {
- pc = pieceCount[Us][pt1];
- if (!pc)
- continue;
-
- v = LinearCoefficients[pt1];
-
- for (pt2 = NO_PIECE_TYPE; pt2 <= pt1; pt2++)
- v += QuadraticCoefficientsSameColor[pt1][pt2] * pieceCount[Us][pt2]
- + QuadraticCoefficientsOppositeColor[pt1][pt2] * pieceCount[Them][pt2];
-
- value += pc * v;
- }
- return value;
-}
-
-
-/// MaterialTable::game_phase() calculates the phase given the current
+/// Material::game_phase() calculates the phase given the current
/// position. Because the phase is strictly a function of the material, it
/// is stored in MaterialEntry.
-Phase MaterialTable::game_phase(const Position& pos) {
+Phase game_phase(const Position& pos) {
Value npm = pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK);
@@ -274,3 +288,5 @@ Phase MaterialTable::game_phase(const Position& pos) {
: npm <= EndgameLimit ? PHASE_ENDGAME
: Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit));
}
+
+} // namespace Material