X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmaterial.cpp;h=dc5003dde5bc9eda71c29e9eaf5ce65489aebcff;hp=8380ab8f6219c48a9b53e78d91e20d7b47a99fb5;hb=55c46b2399e20276cc7db409b7a5a5be6e12fb54;hpb=044ad593b3c9fa8ab70f9b2ebfc2c36ce398eb5f diff --git a/src/material.cpp b/src/material.cpp index 8380ab8f..dc5003dd 100644 --- a/src/material.cpp +++ b/src/material.cpp @@ -28,7 +28,7 @@ #include "material.h" -using std::string; +using namespace std; //// //// Local definitions @@ -36,10 +36,6 @@ using std::string; namespace { - // Values modified by Joona Kiiski - const Value BishopPairMidgameBonus = Value(109); - const Value BishopPairEndgameBonus = Value(97); - // Polynomial material balance parameters const Value RedundantQueenPenalty = Value(320); const Value RedundantRookPenalty = Value(554); @@ -61,8 +57,6 @@ namespace { ScalingFunction ScaleKQKRP(WHITE), ScaleKRPKQ(BLACK); ScalingFunction ScaleKPsK(WHITE), ScaleKKPs(BLACK); ScalingFunction ScaleKPKPw(WHITE), ScaleKPKPb(BLACK); - - Key KNNKMaterialKey, KKNNMaterialKey; } @@ -88,21 +82,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 +113,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 +151,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 +259,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 +295,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 +333,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 +353,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 +365,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 +393,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); }