From: Gary Linscott Date: Mon, 23 Jun 2014 16:14:03 +0000 (-0700) Subject: Merge pull request #5 from glinscott/authors X-Git-Url: https://git.sesse.net/?a=commitdiff_plain;h=ab580106fd995c23aaa7c297e9cbd210cfd33f11;hp=58bb23d0c3a7ef85c0f70a1c33890b1e6bc9ba2a;p=stockfish Merge pull request #5 from glinscott/authors Add AUTHORS --- diff --git a/src/material.cpp b/src/material.cpp index 9a120661..b7db134b 100644 --- a/src/material.cpp +++ b/src/material.cpp @@ -29,10 +29,10 @@ namespace { // Polynomial material balance parameters - // pair pawn knight bishop rook queen - const int LinearCoefficients[6] = { 1852, -162, -1122, -183, 249, -154 }; + // pair pawn knight bishop rook queen + const int Linear[6] = { 1852, -162, -1122, -183, 249, -154 }; - const int QuadraticCoefficientsSameSide[][PIECE_TYPE_NB] = { + const int QuadraticSameSide[][PIECE_TYPE_NB] = { // OUR PIECES // pair pawn knight bishop rook queen { 0 }, // Bishop pair @@ -43,7 +43,7 @@ namespace { {-177, 25, 129, 142, -137, 0 } // Queen }; - const int QuadraticCoefficientsOppositeSide[][PIECE_TYPE_NB] = { + const int QuadraticOppositeSide[][PIECE_TYPE_NB] = { // THEIR PIECES // pair pawn knight bishop rook queen { 0 }, // Bishop pair @@ -66,8 +66,7 @@ namespace { // Helper templates used to detect a given material distribution template bool is_KXK(const Position& pos) { const Color Them = (Us == WHITE ? BLACK : WHITE); - return !pos.count(Them) - && pos.non_pawn_material(Them) == VALUE_ZERO + return !more_than_one(pos.pieces(Them)) && pos.non_pawn_material(Us) >= RookValueMg; } @@ -94,26 +93,24 @@ namespace { const Color Them = (Us == WHITE ? BLACK : WHITE); - int pt1, pt2, pc, v; - int value = 0; + int bonus = 0; // Second-degree polynomial material imbalance by Tord Romstad - for (pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; ++pt1) + for (int pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; ++pt1) { - pc = pieceCount[Us][pt1]; - if (!pc) + if (!pieceCount[Us][pt1]) continue; - v = LinearCoefficients[pt1]; + int v = Linear[pt1]; - for (pt2 = NO_PIECE_TYPE; pt2 <= pt1; ++pt2) - v += QuadraticCoefficientsSameSide[pt1][pt2] * pieceCount[Us][pt2] - + QuadraticCoefficientsOppositeSide[pt1][pt2] * pieceCount[Them][pt2]; + for (int pt2 = NO_PIECE_TYPE; pt2 <= pt1; ++pt2) + v += QuadraticSameSide[pt1][pt2] * pieceCount[Us][pt2] + + QuadraticOppositeSide[pt1][pt2] * pieceCount[Them][pt2]; - value += pc * v; + bonus += pieceCount[Us][pt1] * v; } - return value; + return bonus; } } // namespace @@ -139,7 +136,7 @@ Entry* probe(const Position& pos, Table& entries, Endgames& endgames) { std::memset(e, 0, sizeof(Entry)); e->key = key; e->factor[WHITE] = e->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL; - e->gamePhase = game_phase(pos); + e->gamePhase = pos.game_phase(); // Let's look if we have a specialized evaluation function for this particular // material configuration. Firstly we look for a fixed configuration one, then @@ -248,18 +245,4 @@ Entry* probe(const Position& pos, Table& entries, Endgames& endgames) { return e; } - -/// 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 game_phase(const Position& pos) { - - Value npm = pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK); - - return npm >= MidgameLimit ? PHASE_MIDGAME - : npm <= EndgameLimit ? PHASE_ENDGAME - : Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit)); -} - } // namespace Material diff --git a/src/material.h b/src/material.h index 91163610..f05541cc 100644 --- a/src/material.h +++ b/src/material.h @@ -68,7 +68,6 @@ struct Entry { typedef HashTable Table; Entry* probe(const Position& pos, Table& entries, Endgames& endgames); -Phase game_phase(const Position& pos); } // namespace Material diff --git a/src/pawns.cpp b/src/pawns.cpp index aa3139e2..4d878e20 100644 --- a/src/pawns.cpp +++ b/src/pawns.cpp @@ -57,7 +57,7 @@ namespace { S( 0, 0), S( 6, 13), S(6,13), S(14,29), S(34,68), S(83,166), S(0, 0), S( 0, 0) }; - // Levers bonus by rank + // Levers bonus by rank const Score Lever[RANK_NB] = { S( 0, 0), S( 0, 0), S(0, 0), S(0, 0), S(20,20), S(40,40), S(0, 0), S(0, 0) }; @@ -74,7 +74,7 @@ namespace { // Danger of enemy pawns moving toward our king indexed by // [no friendly pawn | pawn unblocked | pawn blocked][rank of enemy pawn] - const Value StormDanger[3][RANK_NB] = { + const Value StormDanger[][RANK_NB] = { { V( 0), V(64), V(128), V(51), V(26) }, { V(26), V(32), V( 96), V(38), V(20) }, { V( 0), V( 0), V(160), V(25), V(13) } }; @@ -223,20 +223,19 @@ namespace Pawns { void init() { - const int bonusesByFile[8] = { 1, 3, 3, 4, 4, 3, 3, 1 }; - int bonus; + const int bonusByFile[] = { 1, 3, 3, 4, 4, 3, 3, 1 }; for (Rank r = RANK_1; r < RANK_8; ++r) for (File f = FILE_A; f <= FILE_H; ++f) { - bonus = r * (r-1) * (r-2) + bonusesByFile[f] * (r/2 + 1); + int bonus = r * (r - 1) * (r - 2) + bonusByFile[f] * (r / 2 + 1); Connected[f][r] = make_score(bonus, bonus); } } -/// probe() takes a position object as input, computes a Entry object, and returns -/// a pointer to it. The result is also stored in a hash table, so we don't have +/// probe() takes a position as input, computes a Entry object, and returns a +/// pointer to it. The result is also stored in a hash table, so we don't have /// to recompute everything when the same pawn structure occurs again. Entry* probe(const Position& pos, Table& entries) { @@ -260,30 +259,30 @@ template Value Entry::shelter_storm(const Position& pos, Square ksq) { const Color Them = (Us == WHITE ? BLACK : WHITE); - static const Bitboard MiddleEdges = (FileABB | FileHBB) & (Rank2BB | Rank3BB); + const Bitboard Edges = (FileABB | FileHBB) & (Rank2BB | Rank3BB); - Value safety = MaxSafetyBonus; Bitboard b = pos.pieces(PAWN) & (in_front_bb(Us, rank_of(ksq)) | rank_bb(ksq)); Bitboard ourPawns = b & pos.pieces(Us); Bitboard theirPawns = b & pos.pieces(Them); - Rank rkUs, rkThem; + Value safety = MaxSafetyBonus; File kf = std::max(FILE_B, std::min(FILE_G, file_of(ksq))); for (File f = kf - File(1); f <= kf + File(1); ++f) { b = ourPawns & file_bb(f); - rkUs = b ? relative_rank(Us, backmost_sq(Us, b)) : RANK_1; + Rank rkUs = b ? relative_rank(Us, backmost_sq(Us, b)) : RANK_1; b = theirPawns & file_bb(f); - rkThem = b ? relative_rank(Us, frontmost_sq(Them, b)) : RANK_1; + Rank rkThem = b ? relative_rank(Us, frontmost_sq(Them, b)) : RANK_1; - if ( (MiddleEdges & make_square(f, rkThem)) + if ( (Edges & make_square(f, rkThem)) && file_of(ksq) == f && relative_rank(Us, ksq) == rkThem - 1) safety += 200; else - safety -= ShelterWeakness[rkUs] - + StormDanger[rkUs == RANK_1 ? 0 : rkThem == rkUs + 1 ? 2 : 1][rkThem]; + safety -= ShelterWeakness[rkUs] + + StormDanger[rkUs == RANK_1 ? 0 : + rkThem != rkUs + 1 ? 1 : 2][rkThem]; } return safety; diff --git a/src/position.cpp b/src/position.cpp index 2d511938..bdbfea80 100644 --- a/src/position.cpp +++ b/src/position.cpp @@ -465,6 +465,19 @@ const string Position::pretty(Move m) const { } +/// Position::game_phase() calculates the game phase interpolating total non-pawn +/// material between endgame and midgame limits. + +Phase Position::game_phase() const { + + Value npm = st->npMaterial[WHITE] + st->npMaterial[BLACK]; + + npm = std::max(EndgameLimit, std::min(npm, MidgameLimit)); + + return Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit)); +} + + /// Position::check_blockers() returns a bitboard of all the pieces with color /// 'c' that are blocking check on the king with color 'kingColor'. A piece /// blocks a check if removing that piece from the board would result in a diff --git a/src/position.h b/src/position.h index 0f88944c..d950411f 100644 --- a/src/position.h +++ b/src/position.h @@ -156,6 +156,7 @@ public: // Other properties of the position Color side_to_move() const; + Phase game_phase() const; int game_ply() const; bool is_chess960() const; Thread* this_thread() const; diff --git a/src/search.cpp b/src/search.cpp index acd042c0..24fde88f 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -700,6 +700,7 @@ moves_loop: // When in check and at SpNode search starts from here && depth >= 8 * ONE_PLY && abs(beta) < VALUE_KNOWN_WIN && ttMove != MOVE_NONE + && ttValue != VALUE_NONE && !excludedMove // Recursive singular search is not allowed && (tte->bound() & BOUND_LOWER) && tte->depth() >= depth - 3 * ONE_PLY; @@ -766,8 +767,6 @@ moves_loop: // When in check and at SpNode search starts from here && !ext && pos.legal(move, ci.pinned)) { - assert(ttValue != VALUE_NONE); - Value rBeta = ttValue - int(depth); ss->excludedMove = move; ss->skipNullMove = true;