X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmaterial.cpp;h=27ea5923b492fc9caeb548a29e8dab6c1369da91;hp=63901d148e3e6c0a1d4b3cd1bbd1572b52c3cb5c;hb=e6863f46de3eea91a1093465959f1acd75d6d02c;hpb=1b0303b6e930babbaf41385f2a775bc57c8c8a22 diff --git a/src/material.cpp b/src/material.cpp index 63901d14..27ea5923 100644 --- a/src/material.cpp +++ b/src/material.cpp @@ -28,7 +28,7 @@ #include "material.h" -using std::string; +using namespace std; //// //// Local definitions @@ -41,17 +41,17 @@ namespace { const Value BishopPairEndgameBonus = Value(97); // Polynomial material balance parameters - const Value RedundantQueenPenalty = Value(358); - const Value RedundantRookPenalty = Value(536); - const int LinearCoefficients[6] = { 1740, -146, -1246, -197, 206, -7 }; + const Value RedundantQueenPenalty = Value(320); + const Value RedundantRookPenalty = Value(554); + const int LinearCoefficients[6] = { 1709, -137, -1185, -166, 141, 59 }; const int QuadraticCoefficientsSameColor[][6] = { - { 0, 0, 0, 0, 0, 0 }, { 31, -4, 0, 0, 0, 0 }, { 14, 267, -21, 0, 0, 0 }, - { 0, 7, -26, 0, 0, 0 }, { -3, -1, 69, 162, 80, 0 }, { 40, 27, 119, 174, -64, -49 } }; + { 0, 0, 0, 0, 0, 0 }, { 33, -6, 0, 0, 0, 0 }, { 29, 269, -12, 0, 0, 0 }, + { 0, 19, -4, 0, 0, 0 }, { -35, -10, 40, 95, 50, 0 }, { 52, 23, 78, 144, -11, -33 } }; const int QuadraticCoefficientsOppositeColor[][6] = { - { 0, 0, 0, 0, 0, 0 }, { -9, 0, 0, 0, 0, 0 }, { 49, 32, 0, 0, 0, 0 }, - { -25, 19, -5, 0, 0, 0 }, { 97, -6, 39, -88, 0, 0 }, { 77, 69, -42, 104, 116, 0 } }; + { 0, 0, 0, 0, 0, 0 }, { -5, 0, 0, 0, 0, 0 }, { -33, 23, 0, 0, 0, 0 }, + { 17, 25, -3, 0, 0, 0 }, { 10, -2, -19, -67, 0, 0 }, { 69, 64, -41, 116, 137, 0 } }; // Unmapped endgame evaluation and scaling functions, these // are accessed direcly and not through the function maps. @@ -61,8 +61,6 @@ namespace { ScalingFunction ScaleKQKRP(WHITE), ScaleKRPKQ(BLACK); ScalingFunction ScaleKPsK(WHITE), ScaleKKPs(BLACK); ScalingFunction ScaleKPKPw(WHITE), ScaleKPKPb(BLACK); - - Key KNNKMaterialKey, KKNNMaterialKey; } @@ -88,21 +86,21 @@ private: static Key buildKey(const string& keyCode); static const string swapColors(const string& keyCode); - std::map EEFmap; - std::map ESFmap; + // Here we store two maps, one for evaluate and one for scaling + pair, map > maps; // Maps accessing functions for const and non-const references - template const std::map& map() const { return EEFmap; } - template std::map& map() { return EEFmap; } + template const map& get() const { return maps.first; } + template map& get() { return maps.first; } }; // Explicit specializations of a member function shall be declared in // the namespace of which the class template is a member. -template<> const std::map& -EndgameFunctions::map() const { return ESFmap; } +template<> const map& +EndgameFunctions::get() const { return maps.second; } -template<> std::map& -EndgameFunctions::map() { return ESFmap; } +template<> map& +EndgameFunctions::get() { return maps.second; } //// @@ -119,8 +117,8 @@ MaterialInfoTable::MaterialInfoTable(unsigned int numOfEntries) { funcs = new EndgameFunctions(); if (!entries || !funcs) { - std::cerr << "Failed to allocate " << (numOfEntries * sizeof(MaterialInfo)) - << " bytes for material hash table." << std::endl; + cerr << "Failed to allocate " << (numOfEntries * sizeof(MaterialInfo)) + << " bytes for material hash table." << endl; Application::exit_with_failure(); } } @@ -157,14 +155,6 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) { mi->clear(); mi->key = key; - // A special case before looking for a specialized evaluation function - // KNN vs K is a draw. - if (key == KNNKMaterialKey || key == KKNNMaterialKey) - { - mi->factor[WHITE] = mi->factor[BLACK] = 0; - return mi; - } - // Let's look if we have a specialized evaluation function for this // particular material configuration. First we look for a fixed // configuration one, then a generic one if previous search failed. @@ -273,8 +263,10 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) { } // Evaluate the material balance - - const int bishopsPair_count[2] = { pos.piece_count(WHITE, BISHOP) > 1, pos.piece_count(BLACK, BISHOP) > 1 }; + const int pieceCount[2][6] = { { 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; int matValue = 0; @@ -307,29 +299,26 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) { // Redundancy of major pieces, formula based on Kaufman's paper // "The Evaluation of Material Imbalances in Chess" // http://mywebpages.comcast.net/danheisman/Articles/evaluation_of_material_imbalance.htm - if (pos.piece_count(c, ROOK) >= 1) - matValue -= sign * ((pos.piece_count(c, ROOK) - 1) * RedundantRookPenalty + pos.piece_count(c, QUEEN) * RedundantQueenPenalty); + if (pieceCount[c][ROOK] >= 1) + matValue -= sign * ((pieceCount[c][ROOK] - 1) * RedundantRookPenalty + pieceCount[c][QUEEN] * RedundantQueenPenalty); // Second-degree polynomial material imbalance by Tord Romstad // // We use NO_PIECE_TYPE as a place holder for the bishop pair "extended piece", // this allow us to be more flexible in defining bishop pair bonuses. them = opposite_color(c); - for (PieceType pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; pt1++) + for (int pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; pt1++) { - int c1, c2, c3; - c1 = sign * (pt1 != NO_PIECE_TYPE ? pos.piece_count(c, pt1) : bishopsPair_count[c]); + int c1 = sign * pieceCount[c][pt1]; if (!c1) continue; matValue += c1 * LinearCoefficients[pt1]; - for (PieceType pt2 = NO_PIECE_TYPE; pt2 <= pt1; pt2++) + for (int pt2 = NO_PIECE_TYPE; pt2 <= pt1; pt2++) { - c2 = (pt2 != NO_PIECE_TYPE ? pos.piece_count(c, pt2) : bishopsPair_count[c]); - c3 = (pt2 != NO_PIECE_TYPE ? pos.piece_count(them, pt2) : bishopsPair_count[them]); - matValue += c1 * c2 * QuadraticCoefficientsSameColor[pt1][pt2]; - matValue += c1 * c3 * QuadraticCoefficientsOppositeColor[pt1][pt2]; + matValue += c1 * pieceCount[c][pt2] * QuadraticCoefficientsSameColor[pt1][pt2]; + matValue += c1 * pieceCount[them][pt2] * QuadraticCoefficientsOppositeColor[pt1][pt2]; } } } @@ -348,9 +337,7 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) { EndgameFunctions::EndgameFunctions() { - KNNKMaterialKey = buildKey("KNNK"); - KKNNMaterialKey = buildKey("KKNN"); - + add >("KNNK"); add >("KPK"); add >("KBNK"); add >("KRKP"); @@ -370,10 +357,10 @@ EndgameFunctions::EndgameFunctions() { EndgameFunctions::~EndgameFunctions() { - for (std::map::iterator it = EEFmap.begin(); it != EEFmap.end(); ++it) + for (map::iterator it = maps.first.begin(); it != maps.first.end(); ++it) delete (*it).second; - for (std::map::iterator it = ESFmap.begin(); it != ESFmap.end(); ++it) + for (map::iterator it = maps.second.begin(); it != maps.second.end(); ++it) delete (*it).second; } @@ -382,7 +369,7 @@ Key EndgameFunctions::buildKey(const string& keyCode) { assert(keyCode.length() > 0 && keyCode[0] == 'K'); assert(keyCode.length() < 8); - std::stringstream s; + stringstream s; bool upcase = false; // Build up a fen substring with the given pieces, note @@ -410,13 +397,13 @@ void EndgameFunctions::add(const string& keyCode) { typedef typename T::Base F; - map().insert(std::pair(buildKey(keyCode), new T(WHITE))); - map().insert(std::pair(buildKey(swapColors(keyCode)), new T(BLACK))); + get().insert(pair(buildKey(keyCode), new T(WHITE))); + get().insert(pair(buildKey(swapColors(keyCode)), new T(BLACK))); } template T* EndgameFunctions::get(Key key) const { - typename std::map::const_iterator it(map().find(key)); - return (it != map().end() ? it->second : NULL); + typename map::const_iterator it(get().find(key)); + return (it != get().end() ? it->second : NULL); }