Small cleanups

closes https://github.com/official-stockfish/Stockfish/pull/2628

No functional change

diff --git a/src/evaluate.cpp b/src/evaluate.cpp
index cbcebd045f684d392975bbe7373648d6e152b09c..9d7728c4511f4cb39e9245a10d6399640995b8c1 100644 (file)
--- a/src/evaluate.cpp
+++ b/src/evaluate.cpp
@@ -740,7 +740,7 @@ namespace {
     // Now apply the bonus: note that we find the attacking side by extracting the
     // sign of the midgame or endgame values, and that we carefully cap the bonus
     // so that the midgame and endgame scores do not change sign after the bonus.
     // Now apply the bonus: note that we find the attacking side by extracting the
     // sign of the midgame or endgame values, and that we carefully cap the bonus
     // so that the midgame and endgame scores do not change sign after the bonus.

-    int u = ((mg > 0) - (mg < 0)) * std::max(std::min(complexity + 50, 0), -abs(mg));
+    int u = ((mg > 0) - (mg < 0)) * Utility::clamp(complexity + 50, -abs(mg), 0);

     int v = ((eg > 0) - (eg < 0)) * std::max(complexity, -abs(eg));
 
     if (T)
     int v = ((eg > 0) - (eg < 0)) * std::max(complexity, -abs(eg));
 
     if (T)


@@ -815,7 +815,8 @@ namespace {
     initialize<WHITE>();
     initialize<BLACK>();
 
     initialize<WHITE>();
     initialize<BLACK>();
 

-    // Pieces should be evaluated first (populate attack tables)
+    // Pieces evaluated first (also populates attackedBy, attackedBy2).
+    // Note that the order of evaluation of the terms is left unspecified

     score +=  pieces<WHITE, KNIGHT>() - pieces<BLACK, KNIGHT>()
             + pieces<WHITE, BISHOP>() - pieces<BLACK, BISHOP>()
             + pieces<WHITE, ROOK  >() - pieces<BLACK, ROOK  >()
     score +=  pieces<WHITE, KNIGHT>() - pieces<BLACK, KNIGHT>()
             + pieces<WHITE, BISHOP>() - pieces<BLACK, BISHOP>()
             + pieces<WHITE, ROOK  >() - pieces<BLACK, ROOK  >()


@@ -823,6 +824,7 @@ namespace {
 
     score += mobility[WHITE] - mobility[BLACK];
 
 
     score += mobility[WHITE] - mobility[BLACK];
 

+    // More complex interactions that require fully populated attack bitboards

     score +=  king<   WHITE>() - king<   BLACK>()
             + threats<WHITE>() - threats<BLACK>()
             + passed< WHITE>() - passed< BLACK>()
     score +=  king<   WHITE>() - king<   BLACK>()
             + threats<WHITE>() - threats<BLACK>()
             + passed< WHITE>() - passed< BLACK>()

diff --git a/src/pawns.cpp b/src/pawns.cpp
index 066146e20b48d7400dab2753674615229fd36e38..7b266e779cc5fb7c76bcd91f28403ff5aeb43aa2 100644 (file)
--- a/src/pawns.cpp
+++ b/src/pawns.cpp
@@ -86,7 +86,6 @@ namespace {
     e->passedPawns[Us] = 0;
     e->kingSquares[Us] = SQ_NONE;
     e->pawnAttacks[Us] = e->pawnAttacksSpan[Us] = pawn_attacks_bb<Us>(ourPawns);
     e->passedPawns[Us] = 0;
     e->kingSquares[Us] = SQ_NONE;
     e->pawnAttacks[Us] = e->pawnAttacksSpan[Us] = pawn_attacks_bb<Us>(ourPawns);

-    e->blockedCount[Us] = 0;

 
     // Loop through all pawns of the current color and score each pawn
     while ((s = *pl++) != SQ_NONE)
 
     // Loop through all pawns of the current color and score each pawn
     while ((s = *pl++) != SQ_NONE)


@@ -106,7 +105,7 @@ namespace {
         phalanx    = neighbours & rank_bb(s);
         support    = neighbours & rank_bb(s - Up);
 
         phalanx    = neighbours & rank_bb(s);
         support    = neighbours & rank_bb(s - Up);
 

-        e->blockedCount[Us] += blocked || more_than_one(leverPush);
+        e->blockedCount += blocked || more_than_one(leverPush);

 
         // A pawn is backward when it is behind all pawns of the same color on
         // the adjacent files and cannot safely advance.
 
         // A pawn is backward when it is behind all pawns of the same color on
         // the adjacent files and cannot safely advance.


@@ -178,6 +177,7 @@ Entry* probe(const Position& pos) {
       return e;
 
   e->key = key;
       return e;
 
   e->key = key;

+  e->blockedCount = 0;

   e->scores[WHITE] = evaluate<WHITE>(pos, e);
   e->scores[BLACK] = evaluate<BLACK>(pos, e);
 
   e->scores[WHITE] = evaluate<WHITE>(pos, e);
   e->scores[BLACK] = evaluate<BLACK>(pos, e);
 

diff --git a/src/pawns.h b/src/pawns.h
index 41a88c6f3936935a4475df4e0a28b3a63ffca55d..a3284a0fc64771b8fed6b5bb1fb87572f20b902f 100644 (file)
--- a/src/pawns.h
+++ b/src/pawns.h
@@ -38,7 +38,7 @@ struct Entry {
   Bitboard passed_pawns(Color c) const { return passedPawns[c]; }
   Bitboard pawn_attacks_span(Color c) const { return pawnAttacksSpan[c]; }
   int passed_count() const { return popcount(passedPawns[WHITE] | passedPawns[BLACK]); }
   Bitboard passed_pawns(Color c) const { return passedPawns[c]; }
   Bitboard pawn_attacks_span(Color c) const { return pawnAttacksSpan[c]; }
   int passed_count() const { return popcount(passedPawns[WHITE] | passedPawns[BLACK]); }

-  int blocked_count() const { return blockedCount[WHITE] + blockedCount[BLACK]; }
+  int blocked_count() const { return blockedCount; }

 
   template<Color Us>
   Score king_safety(const Position& pos) {
 
   template<Color Us>
   Score king_safety(const Position& pos) {


@@ -60,7 +60,7 @@ struct Entry {
   Square kingSquares[COLOR_NB];
   Score kingSafety[COLOR_NB];
   int castlingRights[COLOR_NB];
   Square kingSquares[COLOR_NB];
   Score kingSafety[COLOR_NB];
   int castlingRights[COLOR_NB];

-  int blockedCount[COLOR_NB];
+  int blockedCount;

 };
 
 typedef HashTable<Entry, 131072> Table;
 };
 
 typedef HashTable<Entry, 131072> Table;

diff --git a/src/position.cpp b/src/position.cpp
index 6bbb7914ae805e2a6302c0fa6106c9f0f923f483..40ebb959575fd457985b19554b8bd988bc77bc6d 100644 (file)
--- a/src/position.cpp
+++ b/src/position.cpp
@@ -306,7 +306,7 @@ void Position::set_castling_right(Color c, Square rfrom) {
   Square rto = relative_square(c, cr & KING_SIDE ? SQ_F1 : SQ_D1);
 
   castlingPath[cr] =   (between_bb(rfrom, rto) | between_bb(kfrom, kto) | rto | kto)
   Square rto = relative_square(c, cr & KING_SIDE ? SQ_F1 : SQ_D1);
 
   castlingPath[cr] =   (between_bb(rfrom, rto) | between_bb(kfrom, kto) | rto | kto)

-                    & ~(square_bb(kfrom) | rfrom);
+                    & ~(kfrom | rfrom);

 }
 
 
 }
 
 

diff --git a/src/position.h b/src/position.h
index f79c5463a7a92060642c1cb5c4d6c067ae716cc8..34a6abc3b5ede3baefe849de93549afc31a852d0 100644 (file)
--- a/src/position.h
+++ b/src/position.h
@@ -269,7 +269,7 @@ inline bool Position::can_castle(CastlingRights cr) const {
 }
 
 inline int Position::castling_rights(Color c) const {
 }
 
 inline int Position::castling_rights(Color c) const {

-  return st->castlingRights & (c == WHITE ? WHITE_CASTLING : BLACK_CASTLING);
+  return c & CastlingRights(st->castlingRights);

 }
 
 inline bool Position::castling_impeded(CastlingRights cr) const {
 }
 
 inline bool Position::castling_impeded(CastlingRights cr) const {

diff --git a/src/search.cpp b/src/search.cpp
index 55c520a4b0fcb65db715dbd65beea3fcedc6c08e..7f29f771c0a9eb3e05f8881502182c822e0f1e0f 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -61,8 +61,8 @@ namespace {
   // Different node types, used as a template parameter
   enum NodeType { NonPV, PV };
 
   // Different node types, used as a template parameter
   enum NodeType { NonPV, PV };
 

-  constexpr uint64_t ttHitAverageWindow     = 4096;
-  constexpr uint64_t ttHitAverageResolution = 1024;
+  constexpr uint64_t TtHitAverageWindow     = 4096;
+  constexpr uint64_t TtHitAverageResolution = 1024;

 
   // Razor and futility margins
   constexpr int RazorMargin = 531;
 
   // Razor and futility margins
   constexpr int RazorMargin = 531;


@@ -378,7 +378,7 @@ void Thread::search() {
       multiPV = std::max(multiPV, (size_t)4);
 
   multiPV = std::min(multiPV, rootMoves.size());
       multiPV = std::max(multiPV, (size_t)4);
 
   multiPV = std::min(multiPV, rootMoves.size());

-  ttHitAverage = ttHitAverageWindow * ttHitAverageResolution / 2;
+  ttHitAverage = TtHitAverageWindow * TtHitAverageResolution / 2;

 
   int ct = int(Options["Contempt"]) * PawnValueEg / 100; // From centipawns
 
 
   int ct = int(Options["Contempt"]) * PawnValueEg / 100; // From centipawns
 


@@ -702,8 +702,8 @@ namespace {
         thisThread->lowPlyHistory[ss->ply - 1][from_to((ss-1)->currentMove)] << stat_bonus(depth - 5);
 
     // thisThread->ttHitAverage can be used to approximate the running average of ttHit
         thisThread->lowPlyHistory[ss->ply - 1][from_to((ss-1)->currentMove)] << stat_bonus(depth - 5);
 
     // thisThread->ttHitAverage can be used to approximate the running average of ttHit

-    thisThread->ttHitAverage =   (ttHitAverageWindow - 1) * thisThread->ttHitAverage / ttHitAverageWindow
-                                + ttHitAverageResolution * ttHit;
+    thisThread->ttHitAverage =   (TtHitAverageWindow - 1) * thisThread->ttHitAverage / TtHitAverageWindow
+                                + TtHitAverageResolution * ttHit;

 
     // At non-PV nodes we check for an early TT cutoff
     if (  !PvNode
 
     // At non-PV nodes we check for an early TT cutoff
     if (  !PvNode


@@ -1170,12 +1170,12 @@ moves_loop: // When in check, search starts from here
               || moveCountPruning
               || ss->staticEval + PieceValue[EG][pos.captured_piece()] <= alpha
               || cutNode
               || moveCountPruning
               || ss->staticEval + PieceValue[EG][pos.captured_piece()] <= alpha
               || cutNode

-              || thisThread->ttHitAverage < 375 * ttHitAverageResolution * ttHitAverageWindow / 1024))
+              || thisThread->ttHitAverage < 375 * TtHitAverageResolution * TtHitAverageWindow / 1024))

       {
           Depth r = reduction(improving, depth, moveCount);
 
           // Decrease reduction if the ttHit running average is large
       {
           Depth r = reduction(improving, depth, moveCount);
 
           // Decrease reduction if the ttHit running average is large

-          if (thisThread->ttHitAverage > 500 * ttHitAverageResolution * ttHitAverageWindow / 1024)
+          if (thisThread->ttHitAverage > 500 * TtHitAverageResolution * TtHitAverageWindow / 1024)

               r--;
 
           // Reduction if other threads are searching this position.
               r--;
 
           // Reduction if other threads are searching this position.