X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fmaterial.cpp;h=ef7bb14333aa51b0190f19264c30abe268ef3839;hp=f73977b5f369641dfc427507ae66fcc035c58928;hb=bc3b148d5712ef9ea00e74d3ff5aea10a4d3cabe;hpb=d4af15f682c1967450233ab62cba1a6c5d601df6 diff --git a/src/material.cpp b/src/material.cpp index f73977b5..ef7bb143 100644 --- a/src/material.cpp +++ b/src/material.cpp @@ -2,7 +2,7 @@ Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad - Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad + Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, 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 @@ -31,21 +31,18 @@ namespace { // Polynomial material imbalance parameters - // pair pawn knight bishop rook queen - const int Linear[6] = { 1667, -168, -1027, -166, 238, -138 }; - - const int QuadraticOurs[][PIECE_TYPE_NB] = { + constexpr int QuadraticOurs[][PIECE_TYPE_NB] = { // OUR PIECES // pair pawn knight bishop rook queen - { 0 }, // Bishop pair - { 40, 2 }, // Pawn - { 32, 255, -3 }, // Knight OUR PIECES + {1438 }, // Bishop pair + { 40, 38 }, // Pawn + { 32, 255, -62 }, // Knight OUR PIECES { 0, 104, 4, 0 }, // Bishop - { -26, -2, 47, 105, -149 }, // Rook - {-185, 24, 122, 137, -134, 0 } // Queen + { -26, -2, 47, 105, -208 }, // Rook + {-189, 24, 117, 133, -134, -6 } // Queen }; - const int QuadraticTheirs[][PIECE_TYPE_NB] = { + constexpr int QuadraticTheirs[][PIECE_TYPE_NB] = { // THEIR PIECES // pair pawn knight bishop rook queen { 0 }, // Bishop pair @@ -53,7 +50,7 @@ namespace { { 9, 63, 0 }, // Knight OUR PIECES { 59, 65, 42, 0 }, // Bishop { 46, 39, 24, -24, 0 }, // Rook - { 101, 100, -37, 141, 268, 0 } // Queen + { 97, 100, -42, 137, 268, 0 } // Queen }; // Endgame evaluation and scaling functions are accessed directly and not through @@ -71,7 +68,7 @@ namespace { && pos.non_pawn_material(us) >= RookValueMg; } - bool is_KBPsKs(const Position& pos, Color us) { + bool is_KBPsK(const Position& pos, Color us) { return pos.non_pawn_material(us) == BishopValueMg && pos.count(us) == 1 && pos.count(us) >= 1; @@ -80,7 +77,7 @@ namespace { bool is_KQKRPs(const Position& pos, Color us) { return !pos.count(us) && pos.non_pawn_material(us) == QueenValueMg - && pos.count(us) == 1 + && pos.count(us) == 1 && pos.count(~us) == 1 && pos.count(~us) >= 1; } @@ -90,17 +87,17 @@ namespace { template int imbalance(const int pieceCount[][PIECE_TYPE_NB]) { - const Color Them = (Us == WHITE ? BLACK : WHITE); + constexpr Color Them = (Us == WHITE ? BLACK : WHITE); int bonus = 0; - // Second-degree polynomial material imbalance by Tord Romstad + // Second-degree polynomial material imbalance, by Tord Romstad for (int pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; ++pt1) { if (!pieceCount[Us][pt1]) continue; - int v = Linear[pt1]; + int v = 0; for (int pt2 = NO_PIECE_TYPE; pt2 <= pt1; ++pt2) v += QuadraticOurs[pt1][pt2] * pieceCount[Us][pt2] @@ -132,7 +129,13 @@ Entry* probe(const Position& pos) { std::memset(e, 0, sizeof(Entry)); e->key = key; e->factor[WHITE] = e->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL; - e->gamePhase = pos.game_phase(); + + Value npm_w = pos.non_pawn_material(WHITE); + Value npm_b = pos.non_pawn_material(BLACK); + Value npm = std::max(EndgameLimit, std::min(npm_w + npm_b, MidgameLimit)); + + // Map total non-pawn material into [PHASE_ENDGAME, PHASE_MIDGAME] + e->gamePhase = Phase(((npm - EndgameLimit) * PHASE_MIDGAME) / (MidgameLimit - EndgameLimit)); // Let's look if we have a specialized evaluation function for this particular // material configuration. Firstly we look for a fixed configuration one, then @@ -149,11 +152,11 @@ Entry* probe(const Position& pos) { // OK, we didn't find any special evaluation function for the current material // configuration. Is there a suitable specialized scaling function? - EndgameBase* sf; + const EndgameBase* sf; if ((sf = pos.this_thread()->endgames.probe(key)) != nullptr) { - e->scalingFunction[sf->strong_side()] = sf; // Only strong color assigned + e->scalingFunction[sf->strongSide] = sf; // Only strong color assigned return e; } @@ -162,16 +165,13 @@ Entry* probe(const Position& pos) { // case we don't return after setting the function. for (Color c = WHITE; c <= BLACK; ++c) { - if (is_KBPsKs(pos, c)) + if (is_KBPsK(pos, c)) e->scalingFunction[c] = &ScaleKBPsK[c]; else if (is_KQKRPs(pos, c)) e->scalingFunction[c] = &ScaleKQKRPs[c]; } - Value npm_w = pos.non_pawn_material(WHITE); - Value npm_b = pos.non_pawn_material(BLACK); - if (npm_w + npm_b == VALUE_ZERO && pos.pieces(PAWN)) // Only pawns on the board { if (!pos.count(BLACK)) @@ -206,22 +206,16 @@ Entry* probe(const Position& pos) { e->factor[BLACK] = uint8_t(npm_b < RookValueMg ? SCALE_FACTOR_DRAW : npm_w <= BishopValueMg ? 4 : 14); - if (pos.count(WHITE) == 1 && npm_w - npm_b <= BishopValueMg) - e->factor[WHITE] = (uint8_t) SCALE_FACTOR_ONEPAWN; - - if (pos.count(BLACK) == 1 && npm_b - npm_w <= BishopValueMg) - e->factor[BLACK] = (uint8_t) SCALE_FACTOR_ONEPAWN; - // Evaluate the material imbalance. We use PIECE_TYPE_NONE as a place holder // for the bishop pair "extended piece", which allows us to be more flexible // in defining bishop pair bonuses. - const int PieceCount[COLOR_NB][PIECE_TYPE_NB] = { + const int pieceCount[COLOR_NB][PIECE_TYPE_NB] = { { pos.count(WHITE) > 1, pos.count(WHITE), pos.count(WHITE), pos.count(WHITE) , pos.count(WHITE), pos.count(WHITE) }, { pos.count(BLACK) > 1, pos.count(BLACK), pos.count(BLACK), pos.count(BLACK) , pos.count(BLACK), pos.count(BLACK) } }; - e->value = int16_t((imbalance(PieceCount) - imbalance(PieceCount)) / 16); + e->value = int16_t((imbalance(pieceCount) - imbalance(pieceCount)) / 16); return e; }