Renaming some variables in code

Implements renaming suggestions by Marco Costalba, Günther Demetz,
Gontran Lemaire, Ronald de Man, Stéphane Nicolet, Alain Savard,
Joost VandeVondele, Jerry Donald Watson, Mike Whiteley, xoto10,
and I hope that I haven't forgotten anybody.

Perpetual renaming thread for suggestions:
https://github.com/official-stockfish/Stockfish/issues/1426

No functional change.

diff --git a/src/evaluate.cpp b/src/evaluate.cpp
index 6783ffd8595fcaa32f1e584ffdd2fca8362aeb41..fee181aeb2c61d9f564ca2d81ecad77ccefc9cf9 100644 (file)
--- a/src/evaluate.cpp
+++ b/src/evaluate.cpp
@@ -163,24 +163,24 @@ namespace {
   const Score KingProtector[] = { S(3, 5), S(4, 3), S(3, 0), S(1, -1) };
 
   // Assorted bonuses and penalties
   const Score KingProtector[] = { S(3, 5), S(4, 3), S(3, 0), S(1, -1) };
 
   // Assorted bonuses and penalties

-  const Score BishopPawns       = S(  8, 12);
-  const Score CloseEnemies      = S(  7,  0);
-  const Score Connectivity      = S(  3,  1);
-  const Score Hanging           = S( 52, 30);
-  const Score HinderPassedPawn  = S(  8,  1);
-  const Score KnightOnQueen     = S( 21, 11);
-  const Score LongRangedBishop  = S( 22,  0);
-  const Score MinorBehindPawn   = S( 16,  0);
-  const Score PawnlessFlank     = S( 20, 80);
-  const Score RookOnPawn        = S(  8, 24);
-  const Score SliderOnQueen     = S( 42, 21);
-  const Score ThreatByPawnPush  = S( 47, 26);
-  const Score ThreatByRank      = S( 16,  3);
-  const Score ThreatBySafePawn  = S(175,168);
-  const Score TrappedBishopA1H1 = S( 50, 50);
-  const Score TrappedRook       = S( 92,  0);
-  const Score WeakQueen         = S( 50, 10);
-  const Score WeakUnopposedPawn = S(  5, 25);
+  const Score BishopPawns        = S(  8, 12);
+  const Score CloseEnemies       = S(  7,  0);
+  const Score Connectivity       = S(  3,  1);
+  const Score CorneredBishop     = S( 50, 50);
+  const Score Hanging            = S( 52, 30);
+  const Score HinderPassedPawn   = S(  8,  1);
+  const Score KnightOnQueen      = S( 21, 11);
+  const Score LongDiagonalBishop = S( 22,  0);
+  const Score MinorBehindPawn    = S( 16,  0);
+  const Score PawnlessFlank      = S( 20, 80);
+  const Score RookOnPawn         = S(  8, 24);
+  const Score SliderOnQueen      = S( 42, 21);
+  const Score ThreatByPawnPush   = S( 47, 26);
+  const Score ThreatByRank       = S( 16,  3);
+  const Score ThreatBySafePawn   = S(175,168);
+  const Score TrappedRook        = S( 92,  0);
+  const Score WeakQueen          = S( 50, 10);
+  const Score WeakUnopposedPawn  = S(  5, 25);

 
 #undef S
 
 
 #undef S
 


@@ -230,18 +230,18 @@ namespace {
     // which attack a square in the kingRing of the enemy king.
     int kingAttackersCount[COLOR_NB];
 
     // which attack a square in the kingRing of the enemy king.
     int kingAttackersCount[COLOR_NB];
 

-    // kingAttackersWeight[color] is the sum of the "weights" of the pieces of the
-    // given color which attack a square in the kingRing of the enemy king. The
-    // weights of the individual piece types are given by the elements in the
-    // KingAttackWeights array.
+    // kingAttackersWeight[color] is the sum of the "weights" of the pieces of
+    // the given color which attack a square in the kingRing of the enemy king.
+    // The weights of the individual piece types are given by the elements in
+    // the KingAttackWeights array.

     int kingAttackersWeight[COLOR_NB];
 
     int kingAttackersWeight[COLOR_NB];
 

-    // kingAdjacentZoneAttacksCount[color] is the number of attacks by the given
-    // color to squares directly adjacent to the enemy king. Pieces which attack
-    // more than one square are counted multiple times. For instance, if there is
+    // kingAttacksCount[color] is the number of attacks by the given color to
+    // squares directly adjacent to the enemy king. Pieces which attack more
+    // than one square are counted multiple times. For instance, if there is

     // a white knight on g5 and black's king is on g8, this white knight adds 2
     // a white knight on g5 and black's king is on g8, this white knight adds 2

-    // to kingAdjacentZoneAttacksCount[WHITE].
-    int kingAdjacentZoneAttacksCount[COLOR_NB];
+    // to kingAttacksCount[WHITE].
+    int kingAttacksCount[COLOR_NB];

   };
 
 
   };
 
 


@@ -276,7 +276,7 @@ namespace {
             kingRing[Us] |= shift<Up>(kingRing[Us]);
 
         kingAttackersCount[Them] = popcount(attackedBy[Us][KING] & pe->pawn_attacks(Them));
             kingRing[Us] |= shift<Up>(kingRing[Us]);
 
         kingAttackersCount[Them] = popcount(attackedBy[Us][KING] & pe->pawn_attacks(Them));

-        kingAdjacentZoneAttacksCount[Them] = kingAttackersWeight[Them] = 0;
+        kingAttacksCount[Them] = kingAttackersWeight[Them] = 0;

     }
     else
         kingRing[Us] = kingAttackersCount[Them] = 0;
     }
     else
         kingRing[Us] = kingAttackersCount[Them] = 0;


@@ -316,7 +316,7 @@ namespace {
         {
             kingAttackersCount[Us]++;
             kingAttackersWeight[Us] += KingAttackWeights[Pt];
         {
             kingAttackersCount[Us]++;
             kingAttackersWeight[Us] += KingAttackWeights[Pt];

-            kingAdjacentZoneAttacksCount[Us] += popcount(b & attackedBy[Them][KING]);
+            kingAttacksCount[Us] += popcount(b & attackedBy[Them][KING]);

         }
 
         int mob = popcount(b & mobilityArea[Us]);
         }
 
         int mob = popcount(b & mobilityArea[Us]);


@@ -348,7 +348,7 @@ namespace {
 
                 // Bonus for bishop on a long diagonal which can "see" both center squares
                 if (more_than_one(Center & (attacks_bb<BISHOP>(s, pos.pieces(PAWN)) | s)))
 
                 // Bonus for bishop on a long diagonal which can "see" both center squares
                 if (more_than_one(Center & (attacks_bb<BISHOP>(s, pos.pieces(PAWN)) | s)))

-                    score += LongRangedBishop;
+                    score += LongDiagonalBishop;

             }
 
             // An important Chess960 pattern: A cornered bishop blocked by a friendly
             }
 
             // An important Chess960 pattern: A cornered bishop blocked by a friendly


@@ -360,9 +360,9 @@ namespace {
             {
                 Direction d = pawn_push(Us) + (file_of(s) == FILE_A ? EAST : WEST);
                 if (pos.piece_on(s + d) == make_piece(Us, PAWN))
             {
                 Direction d = pawn_push(Us) + (file_of(s) == FILE_A ? EAST : WEST);
                 if (pos.piece_on(s + d) == make_piece(Us, PAWN))

-                    score -= !pos.empty(s + d + pawn_push(Us))                ? TrappedBishopA1H1 * 4
-                            : pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? TrappedBishopA1H1 * 2
-                                                                              : TrappedBishopA1H1;
+                    score -= !pos.empty(s + d + pawn_push(Us))                ? CorneredBishop * 4
+                            : pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? CorneredBishop * 2
+                                                                              : CorneredBishop;

             }
         }
 
             }
         }
 


@@ -463,7 +463,7 @@ namespace {
         pinned = pos.blockers_for_king(Us) & pos.pieces(Us);
 
         kingDanger +=        kingAttackersCount[Them] * kingAttackersWeight[Them]
         pinned = pos.blockers_for_king(Us) & pos.pieces(Us);
 
         kingDanger +=        kingAttackersCount[Them] * kingAttackersWeight[Them]

-                     + 102 * kingAdjacentZoneAttacksCount[Them]
+                     + 102 * kingAttacksCount[Them]

                      + 191 * popcount(kingRing[Us] & weak)
                      + 143 * popcount(pinned | unsafeChecks)
                      - 848 * !pos.count<QUEEN>(Them)
                      + 191 * popcount(kingRing[Us] & weak)
                      + 143 * popcount(pinned | unsafeChecks)
                      - 848 * !pos.count<QUEEN>(Them)

diff --git a/src/material.cpp b/src/material.cpp
index fb392093be6987f2c56257fefe8b7a636795aadf..4cfda03e4f3dcab3ee3bfed56553ea379e775826 100644 (file)
--- a/src/material.cpp
+++ b/src/material.cpp
@@ -68,7 +68,7 @@ namespace {
           && pos.non_pawn_material(us) >= RookValueMg;
   }
 
           && 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<BISHOP>(us) == 1
           && pos.count<PAWN  >(us) >= 1;
     return   pos.non_pawn_material(us) == BishopValueMg
           && pos.count<BISHOP>(us) == 1
           && pos.count<PAWN  >(us) >= 1;


@@ -165,7 +165,7 @@ Entry* probe(const Position& pos) {
   // case we don't return after setting the function.
   for (Color c = WHITE; c <= BLACK; ++c)
   {
   // 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] = &ScaleKBPsK[c];
 
     else if (is_KQKRPs(pos, c))

diff --git a/src/position.cpp b/src/position.cpp
index d48ec18cb0d69aead115584573e135d468a9ea06..9cec2c14ff9646882a06f3abd02290248196d8f2 100644 (file)
--- a/src/position.cpp
+++ b/src/position.cpp
@@ -322,8 +322,8 @@ void Position::set_castling_right(Color c, Square rfrom) {
 
 void Position::set_check_info(StateInfo* si) const {
 
 
 void Position::set_check_info(StateInfo* si) const {
 

-  si->blockersForKing[WHITE] = slider_blockers(pieces(BLACK), square<KING>(WHITE), si->pinnersForKing[WHITE]);
-  si->blockersForKing[BLACK] = slider_blockers(pieces(WHITE), square<KING>(BLACK), si->pinnersForKing[BLACK]);
+  si->blockersForKing[WHITE] = slider_blockers(pieces(BLACK), square<KING>(WHITE), si->pinners[BLACK]);
+  si->blockersForKing[BLACK] = slider_blockers(pieces(WHITE), square<KING>(BLACK), si->pinners[WHITE]);

 
   Square ksq = square<KING>(~sideToMove);
 
 
   Square ksq = square<KING>(~sideToMove);
 


@@ -1037,7 +1037,7 @@ bool Position::see_ge(Move m, Value threshold) const {
 
       // Don't allow pinned pieces to attack (except the king) as long as
       // all pinners are on their original square.
 
       // Don't allow pinned pieces to attack (except the king) as long as
       // all pinners are on their original square.

-      if (!(st->pinnersForKing[stm] & ~occupied))
+      if (!(st->pinners[~stm] & ~occupied))

           stmAttackers &= ~st->blockersForKing[stm];
 
       // If stm has no more attackers then give up: stm loses
           stmAttackers &= ~st->blockersForKing[stm];
 
       // If stm has no more attackers then give up: stm loses

diff --git a/src/position.h b/src/position.h
index 18c783f0836ecd6b0d92157ae731472d5040f6ea..bbdab011b2696f239d1fca0d84cd9c013b85f503 100644 (file)
--- a/src/position.h
+++ b/src/position.h
@@ -52,7 +52,7 @@ struct StateInfo {
   Piece      capturedPiece;
   StateInfo* previous;
   Bitboard   blockersForKing[COLOR_NB];
   Piece      capturedPiece;
   StateInfo* previous;
   Bitboard   blockersForKing[COLOR_NB];

-  Bitboard   pinnersForKing[COLOR_NB];
+  Bitboard   pinners[COLOR_NB];

   Bitboard   checkSquares[PIECE_TYPE_NB];
 };
 
   Bitboard   checkSquares[PIECE_TYPE_NB];
 };
 

diff --git a/src/psqt.cpp b/src/psqt.cpp
index 3f447dc053705f340c34367d28bd0c32aacaee4d..cbdce81a26ed4da3c9b03f4cba5ed93f5c7325d9 100644 (file)
--- a/src/psqt.cpp
+++ b/src/psqt.cpp
@@ -112,12 +112,12 @@ void init() {
       PieceValue[MG][~pc] = PieceValue[MG][pc];
       PieceValue[EG][~pc] = PieceValue[EG][pc];
 
       PieceValue[MG][~pc] = PieceValue[MG][pc];
       PieceValue[EG][~pc] = PieceValue[EG][pc];
 

-      Score v = make_score(PieceValue[MG][pc], PieceValue[EG][pc]);
+      Score score = make_score(PieceValue[MG][pc], PieceValue[EG][pc]);

 
       for (Square s = SQ_A1; s <= SQ_H8; ++s)
       {
           File f = std::min(file_of(s), ~file_of(s));
 
       for (Square s = SQ_A1; s <= SQ_H8; ++s)
       {
           File f = std::min(file_of(s), ~file_of(s));

-          psq[ pc][ s] = v + Bonus[pc][rank_of(s)][f];
+          psq[ pc][ s] = score + Bonus[pc][rank_of(s)][f];

           psq[~pc][~s] = -psq[pc][s];
       }
   }
           psq[~pc][~s] = -psq[pc][s];
       }
   }

diff --git a/src/search.cpp b/src/search.cpp
index bf34b77e5d8bd7f8ccbe0177fe4d2ae3da6e5038..afc4a671251b03c196d1d07a565561158f9524df 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -455,12 +455,12 @@ void Thread::search() {
                      timeReduction *= 1.25;
 
               // Use part of the gained time from a previous stable move for the current move
                      timeReduction *= 1.25;
 
               // Use part of the gained time from a previous stable move for the current move

-              double unstablePvFactor = 1.0 + mainThread->bestMoveChanges;
-              unstablePvFactor *= std::pow(mainThread->previousTimeReduction, 0.528) / timeReduction;
+              double bestMoveInstability = 1.0 + mainThread->bestMoveChanges;
+              bestMoveInstability *= std::pow(mainThread->previousTimeReduction, 0.528) / timeReduction;

 
               // Stop the search if we have only one legal move, or if available time elapsed
               if (   rootMoves.size() == 1
 
               // Stop the search if we have only one legal move, or if available time elapsed
               if (   rootMoves.size() == 1

-                  || Time.elapsed() > Time.optimum() * unstablePvFactor * improvingFactor / 581)
+                  || Time.elapsed() > Time.optimum() * bestMoveInstability * improvingFactor / 581)

               {
                   // If we are allowed to ponder do not stop the search now but
                   // keep pondering until the GUI sends "ponderhit" or "stop".
               {
                   // If we are allowed to ponder do not stop the search now but
                   // keep pondering until the GUI sends "ponderhit" or "stop".


@@ -495,7 +495,7 @@ namespace {
     if (depth < ONE_PLY)
         return qsearch<NT>(pos, ss, alpha, beta);
 
     if (depth < ONE_PLY)
         return qsearch<NT>(pos, ss, alpha, beta);
 

-    const bool PvNode = NT == PV;
+    constexpr bool PvNode = NT == PV;

     const bool rootNode = PvNode && ss->ply == 0;
 
     assert(-VALUE_INFINITE <= alpha && alpha < beta && beta <= VALUE_INFINITE);
     const bool rootNode = PvNode && ss->ply == 0;
 
     assert(-VALUE_INFINITE <= alpha && alpha < beta && beta <= VALUE_INFINITE);


@@ -1156,7 +1156,7 @@ moves_loop: // When in check, search starts from here
   template <NodeType NT>
   Value qsearch(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth) {
 
   template <NodeType NT>
   Value qsearch(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth) {
 

-    const bool PvNode = NT == PV;
+    constexpr bool PvNode = NT == PV;

     const bool inCheck = bool(pos.checkers());
 
     assert(alpha >= -VALUE_INFINITE && alpha < beta && beta <= VALUE_INFINITE);
     const bool inCheck = bool(pos.checkers());
 
     assert(alpha >= -VALUE_INFINITE && alpha < beta && beta <= VALUE_INFINITE);