From: Marco Costalba Date: Thu, 12 Feb 2009 13:59:46 +0000 (+0100) Subject: Use template for endgame scaling functions X-Git-Url: https://git.sesse.net/?p=stockfish;a=commitdiff_plain;h=67375f4693c97fb1321864bb4d143812cd824f9b Use template for endgame scaling functions Also integrate scaling and evaluation in a single base class. Nice use of templates here :-) No functional change. Signed-off-by: Marco Costalba --- diff --git a/src/endgame.cpp b/src/endgame.cpp index f01f75a0..01f4101e 100644 --- a/src/endgame.cpp +++ b/src/endgame.cpp @@ -51,41 +51,15 @@ EvaluationFunction EvaluateKBBKN(WHITE), EvaluateKNKBB(BLACK); // KBB vs /// Scaling functions -// KBP vs K -KBPKScalingFunction ScaleKBPK = KBPKScalingFunction(WHITE); -KBPKScalingFunction ScaleKKBP = KBPKScalingFunction(BLACK); - -// KQ vs KRP -KQKRPScalingFunction ScaleKQKRP = KQKRPScalingFunction(WHITE); -KQKRPScalingFunction ScaleKRPKQ = KQKRPScalingFunction(BLACK); - -// KRP vs KR -KRPKRScalingFunction ScaleKRPKR = KRPKRScalingFunction(WHITE); -KRPKRScalingFunction ScaleKRKRP = KRPKRScalingFunction(BLACK); - -// KRPP vs KRP -KRPPKRPScalingFunction ScaleKRPPKRP = KRPPKRPScalingFunction(WHITE); -KRPPKRPScalingFunction ScaleKRPKRPP = KRPPKRPScalingFunction(BLACK); - -// King and pawns vs king -KPsKScalingFunction ScaleKPsK = KPsKScalingFunction(WHITE); -KPsKScalingFunction ScaleKKPs = KPsKScalingFunction(BLACK); - -// KBP vs KB -KBPKBScalingFunction ScaleKBPKB = KBPKBScalingFunction(WHITE); -KBPKBScalingFunction ScaleKBKBP = KBPKBScalingFunction(BLACK); - -// KBP vs KN -KBPKNScalingFunction ScaleKBPKN = KBPKNScalingFunction(WHITE); -KBPKNScalingFunction ScaleKNKBP = KBPKNScalingFunction(BLACK); - -// KNP vs K -KNPKScalingFunction ScaleKNPK = KNPKScalingFunction(WHITE); -KNPKScalingFunction ScaleKKNP = KNPKScalingFunction(BLACK); - -// KPKP -KPKPScalingFunction ScaleKPKPw = KPKPScalingFunction(WHITE); -KPKPScalingFunction ScaleKPKPb = KPKPScalingFunction(BLACK); +ScalingFunction ScaleKBPK(WHITE), ScaleKKBP(BLACK); // KBP vs K +ScalingFunction ScaleKQKRP(WHITE), ScaleKRPKQ(BLACK); // KQ vs KRP +ScalingFunction ScaleKRPKR(WHITE), ScaleKRKRP(BLACK); // KRP vs KR +ScalingFunction ScaleKRPPKRP(WHITE), ScaleKRPKRPP(BLACK); // KRPP vs KRP +ScalingFunction ScaleKPsK(WHITE), ScaleKKPs(BLACK); // King and pawns vs king +ScalingFunction ScaleKBPKB(WHITE), ScaleKBKBP(BLACK); // KBP vs KB +ScalingFunction ScaleKBPKN(WHITE), ScaleKNKBP(BLACK); // KBP vs KN +ScalingFunction ScaleKNPK(WHITE), ScaleKKNP(BLACK); // KNP vs K +ScalingFunction ScaleKPKPw(WHITE), ScaleKPKPb(BLACK); // KPKP //// @@ -158,27 +132,6 @@ namespace { //// Functions //// -/// Constructors - -EndgameEvaluationFunction::EndgameEvaluationFunction(Color c) : strongerSide(c) { - weakerSide = opposite_color(strongerSide); -} - -ScalingFunction::ScalingFunction(Color c) : strongerSide(c) { - weakerSide = opposite_color(c); -} - -KBPKScalingFunction::KBPKScalingFunction(Color c) : ScalingFunction(c) {} -KQKRPScalingFunction::KQKRPScalingFunction(Color c) : ScalingFunction(c) {} -KRPKRScalingFunction::KRPKRScalingFunction(Color c) : ScalingFunction(c) {} -KRPPKRPScalingFunction::KRPPKRPScalingFunction(Color c) : ScalingFunction(c) {} -KPsKScalingFunction::KPsKScalingFunction(Color c) : ScalingFunction(c) {} -KBPKBScalingFunction::KBPKBScalingFunction(Color c) : ScalingFunction(c) {} -KBPKNScalingFunction::KBPKNScalingFunction(Color c) : ScalingFunction(c) {} -KNPKScalingFunction::KNPKScalingFunction(Color c) : ScalingFunction(c) {} -KPKPScalingFunction::KPKPScalingFunction(Color c) : ScalingFunction(c) {} - - /// Mate with KX vs K. This function is used to evaluate positions with /// King and plenty of material vs a lone king. It simply gives the /// attacking side a bonus for driving the defending king towards the edge @@ -439,8 +392,8 @@ Value EvaluationFunction::apply(const Position &pos) { /// bishop of the wrong color. If such a draw is detected, ScaleFactor(0) is /// returned. If not, the return value is SCALE_FACTOR_NONE, i.e. no scaling /// will be used. - -ScaleFactor KBPKScalingFunction::apply(const Position& pos) { +template<> +ScaleFactor ScalingFunction::apply(const Position& pos) { assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame); assert(pos.piece_count(strongerSide, BISHOP) == 1); @@ -494,8 +447,8 @@ ScaleFactor KBPKScalingFunction::apply(const Position& pos) { /// king and queen, while the weaker side has at least a rook and a pawn. /// It tests for fortress draws with a rook on the third rank defended by /// a pawn. - -ScaleFactor KQKRPScalingFunction::apply(const Position& pos) { +template<> +ScaleFactor ScalingFunction::apply(const Position& pos) { assert(pos.non_pawn_material(strongerSide) == QueenValueMidgame); assert(pos.piece_count(strongerSide, QUEEN) == 1); @@ -525,8 +478,8 @@ ScaleFactor KQKRPScalingFunction::apply(const Position& pos) { /// /// It would also be nice to rewrite the actual code for this function, /// which is mostly copied from Glaurung 1.x, and not very pretty. - -ScaleFactor KRPKRScalingFunction::apply(const Position &pos) { +template<> +ScaleFactor ScalingFunction::apply(const Position &pos) { assert(pos.non_pawn_material(strongerSide) == RookValueMidgame); assert(pos.piece_count(strongerSide, PAWN) == 1); @@ -643,8 +596,8 @@ ScaleFactor KRPKRScalingFunction::apply(const Position &pos) { /// KRPPKRPScalingFunction scales KRPP vs KRP endgames. There is only a /// single pattern: If the stronger side has no pawns and the defending king /// is actively placed, the position is drawish. - -ScaleFactor KRPPKRPScalingFunction::apply(const Position &pos) { +template<> +ScaleFactor ScalingFunction::apply(const Position &pos) { assert(pos.non_pawn_material(strongerSide) == RookValueMidgame); assert(pos.piece_count(strongerSide, PAWN) == 2); @@ -682,8 +635,8 @@ ScaleFactor KRPPKRPScalingFunction::apply(const Position &pos) { /// KPsKScalingFunction scales endgames with king and two or more pawns /// against king. There is just a single rule here: If all pawns are on /// the same rook file and are blocked by the defending king, it's a draw. - -ScaleFactor KPsKScalingFunction::apply(const Position &pos) { +template<> +ScaleFactor ScalingFunction::apply(const Position &pos) { assert(pos.non_pawn_material(strongerSide) == Value(0)); assert(pos.piece_count(strongerSide, PAWN) >= 2); @@ -728,8 +681,8 @@ ScaleFactor KPsKScalingFunction::apply(const Position &pos) { /// square of the king is not of the same color as the stronger side's bishop, /// it's a draw. If the two bishops have opposite color, it's almost always /// a draw. - -ScaleFactor KBPKBScalingFunction::apply(const Position &pos) { +template<> +ScaleFactor ScalingFunction::apply(const Position &pos) { assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame); assert(pos.piece_count(strongerSide, BISHOP) == 1); @@ -783,8 +736,8 @@ ScaleFactor KBPKBScalingFunction::apply(const Position &pos) { /// If the defending king is somewhere along the path of the pawn, and the /// square of the king is not of the same color as the stronger side's bishop, /// it's a draw. - -ScaleFactor KBPKNScalingFunction::apply(const Position &pos) { +template<> +ScaleFactor ScalingFunction::apply(const Position &pos) { assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame); assert(pos.piece_count(strongerSide, BISHOP) == 1); @@ -810,8 +763,8 @@ ScaleFactor KBPKNScalingFunction::apply(const Position &pos) { /// KNPKScalingFunction scales KNP vs K endgames. There is a single rule: /// If the pawn is a rook pawn on the 7th rank and the defending king prevents /// the pawn from advancing, the position is drawn. - -ScaleFactor KNPKScalingFunction::apply(const Position &pos) { +template<> +ScaleFactor ScalingFunction::apply(const Position &pos) { assert(pos.non_pawn_material(strongerSide) == KnightValueMidgame); assert(pos.piece_count(strongerSide, KNIGHT) == 1); @@ -840,8 +793,8 @@ ScaleFactor KNPKScalingFunction::apply(const Position &pos) { /// the pawn as well. The exception is when the stronger side's pawn is far /// advanced and not on a rook file; in this case it is often possible to win /// (e.g. 8/4k3/3p4/3P4/6K1/8/8/8 w - - 0 1). - -ScaleFactor KPKPScalingFunction::apply(const Position &pos) { +template<> +ScaleFactor ScalingFunction::apply(const Position &pos) { assert(pos.non_pawn_material(strongerSide) == Value(0)); assert(pos.non_pawn_material(weakerSide) == Value(0)); diff --git a/src/endgame.h b/src/endgame.h index 21e8ab6d..cb087b4b 100644 --- a/src/endgame.h +++ b/src/endgame.h @@ -34,23 +34,9 @@ //// Types //// -/// Abstract base class for all special endgame evaluation functions - -class EndgameEvaluationFunction { -public: - EndgameEvaluationFunction(Color c); - virtual ~EndgameEvaluationFunction() { } - - virtual Value apply(const Position &pos) = 0; - -protected: - Color strongerSide, weakerSide; -}; - - -/// Template subclass for various concrete endgames - enum EndgameType { + + // Evaluation functions KXK, // Generic "mate lone king" eval KBNK, // KBN vs K KPK, // KP vs K @@ -59,93 +45,49 @@ enum EndgameType { KRKN, // KR vs KN KQKR, // KQ vs KR KBBKN, // KBB vs KN - KmmKm // K and two minors vs K and one or two minors + KmmKm, // K and two minors vs K and one or two minors + + // Scaling functions + KBPK, // KBP vs K + KQKRP, // KQ vs KRP + KRPKR, // KRP vs KR + KRPPKRP, // KRPP vs KRP + KPsK, // King and pawns vs king + KBPKB, // KBP vs KB + KBPKN, // KBP vs KN + KNPK, // KNP vs K + KPKP // KP vs KP }; -template -class EvaluationFunction : public EndgameEvaluationFunction { -public: - explicit EvaluationFunction(Color c): EndgameEvaluationFunction(c) {} - Value apply(const Position& pos); -}; - -/// Abstract base class for all evaluation scaling functions: +/// Template abstract base class for all special endgame functions -class ScalingFunction { +template +class EndgameFunctionBase { public: - ScalingFunction(Color c); - virtual ~ScalingFunction() { } - - virtual ScaleFactor apply(const Position &pos) =0; + EndgameFunctionBase(Color c) : strongerSide(c) { weakerSide = opposite_color(strongerSide); } + virtual ~EndgameFunctionBase() {} + virtual T apply(const Position&) = 0; protected: Color strongerSide, weakerSide; }; +typedef EndgameFunctionBase EndgameEvaluationFunctionBase; +typedef EndgameFunctionBase EndgameScalingFunctionBase; -/// Subclasses for various concrete endgames: - -// KBP vs K: -class KBPKScalingFunction : public ScalingFunction { -public: - KBPKScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; - -// KQ vs KRP: -class KQKRPScalingFunction: public ScalingFunction { -public: - KQKRPScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; -// KRP vs KR: -class KRPKRScalingFunction : public ScalingFunction { -public: - KRPKRScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; +/// Templates subclass for various concrete endgames -// KRPP vs KRP: -class KRPPKRPScalingFunction : public ScalingFunction { -public: - KRPPKRPScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; - -// King and pawns vs king: -class KPsKScalingFunction : public ScalingFunction { -public: - KPsKScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; - -// KBP vs KB: -class KBPKBScalingFunction : public ScalingFunction { -public: - KBPKBScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; - -// KBP vs KN: -class KBPKNScalingFunction : public ScalingFunction { -public: - KBPKNScalingFunction(Color c); - ScaleFactor apply(const Position &pos); -}; - -// KNP vs K: -class KNPKScalingFunction : public ScalingFunction { -public: - KNPKScalingFunction(Color c); - ScaleFactor apply(const Position &pos); +template +struct EvaluationFunction : public EndgameEvaluationFunctionBase { + explicit EvaluationFunction(Color c): EndgameEvaluationFunctionBase(c) {} + Value apply(const Position&); }; -// KP vs KP: -class KPKPScalingFunction : public ScalingFunction { -public: - KPKPScalingFunction(Color c); - ScaleFactor apply(const Position &pos); +template +struct ScalingFunction : public EndgameScalingFunctionBase { + explicit ScalingFunction(Color c) : EndgameScalingFunctionBase(c) {} + ScaleFactor apply(const Position&); }; @@ -163,33 +105,15 @@ extern EvaluationFunction EvaluateKQKR, EvaluateKRKQ; // KQ vs KR extern EvaluationFunction EvaluateKBBKN, EvaluateKNKBB; // KBB vs KN extern EvaluationFunction EvaluateKmmKm; // K and two minors vs K and one or two minors: -// KBP vs K: -extern KBPKScalingFunction ScaleKBPK, ScaleKKBP; - -// KQ vs KRP: -extern KQKRPScalingFunction ScaleKQKRP, ScaleKRPKQ; - -// KRP vs KR: -extern KRPKRScalingFunction ScaleKRPKR, ScaleKRKRP; - -// KRPP vs KRP: -extern KRPPKRPScalingFunction ScaleKRPPKRP, ScaleKRPKRPP; - -// King and pawns vs king: -extern KPsKScalingFunction ScaleKPsK, ScaleKKPs; - -// KBP vs KB: -extern KBPKBScalingFunction ScaleKBPKB, ScaleKBKBP; - -// KBP vs KN: -extern KBPKNScalingFunction ScaleKBPKN, ScaleKNKBP; - -// KNP vs K: -extern KNPKScalingFunction ScaleKNPK, ScaleKKNP; - -// KP vs KP: -extern KPKPScalingFunction ScaleKPKPw, ScaleKPKPb; - +extern ScalingFunction ScaleKBPK, ScaleKKBP; // KBP vs K +extern ScalingFunction ScaleKQKRP, ScaleKRPKQ; // KQ vs KRP +extern ScalingFunction ScaleKRPKR, ScaleKRKRP; // KRP vs KR +extern ScalingFunction ScaleKRPPKRP, ScaleKRPKRPP; // KRPP vs KRP +extern ScalingFunction ScaleKPsK, ScaleKKPs; // King and pawns vs king +extern ScalingFunction ScaleKBPKB, ScaleKBKBP; // KBP vs KB +extern ScalingFunction ScaleKBPKN, ScaleKNKBP; // KBP vs KN +extern ScalingFunction ScaleKNPK, ScaleKKNP; // KNP vs K +extern ScalingFunction ScaleKPKPw, ScaleKPKPb; // KP vs KP //// //// Prototypes diff --git a/src/material.cpp b/src/material.cpp index b180f797..845bc90d 100644 --- a/src/material.cpp +++ b/src/material.cpp @@ -54,20 +54,20 @@ class EndgameFunctions { public: EndgameFunctions(); - EndgameEvaluationFunction* getEEF(Key key) const; - ScalingFunction* getESF(Key key, Color* c) const; + EndgameEvaluationFunctionBase* getEEF(Key key) const; + EndgameScalingFunctionBase* getESF(Key key, Color* c) const; private: - void add(Key k, EndgameEvaluationFunction* f); - void add(Key k, Color c, ScalingFunction* f); + void add(Key k, EndgameEvaluationFunctionBase* f); + void add(Key k, Color c, EndgameScalingFunctionBase* f); struct ScalingInfo { Color col; - ScalingFunction* fun; + EndgameScalingFunctionBase* fun; }; - std::map EEFmap; + std::map EEFmap; std::map ESFmap; }; @@ -187,7 +187,7 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) { // are several conflicting applicable scaling functions and we need to // decide which one to use. Color c; - ScalingFunction* sf; + EndgameScalingFunctionBase* sf; if ((sf = funcs->getESF(key, &c)) != NULL) { @@ -355,24 +355,24 @@ EndgameFunctions::EndgameFunctions() { add(z[W][ROOK][1] ^ z[W][PAWN][1] ^ z[B][ROOK][1] ^ z[B][PAWN][1] ^ z[B][PAWN][2], B, &ScaleKRPKRPP); } -void EndgameFunctions::add(Key k, EndgameEvaluationFunction* f) { +void EndgameFunctions::add(Key k, EndgameEvaluationFunctionBase* f) { - EEFmap.insert(std::pair(k, f)); + EEFmap.insert(std::pair(k, f)); } -void EndgameFunctions::add(Key k, Color c, ScalingFunction* f) { +void EndgameFunctions::add(Key k, Color c, EndgameScalingFunctionBase* f) { ScalingInfo s = {c, f}; ESFmap.insert(std::pair(k, s)); } -EndgameEvaluationFunction* EndgameFunctions::getEEF(Key key) const { +EndgameEvaluationFunctionBase* EndgameFunctions::getEEF(Key key) const { - std::map::const_iterator it(EEFmap.find(key)); + std::map::const_iterator it(EEFmap.find(key)); return (it != EEFmap.end() ? it->second : NULL); } -ScalingFunction* EndgameFunctions::getESF(Key key, Color* c) const { +EndgameScalingFunctionBase* EndgameFunctions::getESF(Key key, Color* c) const { std::map::const_iterator it(ESFmap.find(key)); if (it == ESFmap.end()) diff --git a/src/material.h b/src/material.h index 5877cd75..7ba3b7de 100644 --- a/src/material.h +++ b/src/material.h @@ -63,8 +63,8 @@ private: int16_t mgValue; int16_t egValue; uint8_t factor[2]; - EndgameEvaluationFunction* evaluationFunction; - ScalingFunction* scalingFunction[2]; + EndgameEvaluationFunctionBase* evaluationFunction; + EndgameScalingFunctionBase* scalingFunction[2]; uint8_t spaceWeight; };