Sync compute_xxx implementations

Also refactored Position::pos_is_ok() while there.

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>

diff --git a/src/position.cpp b/src/position.cpp
index e89477ea534d654658244d890c53d9ead3e87b07..e5e0ab06d6eff97946b800ae8ff7bbf159cfa198 100644 (file)
--- a/src/position.cpp
+++ b/src/position.cpp
@@ -1332,19 +1332,21 @@ void Position::put_piece(Piece p, Square s) {
 
 Key Position::compute_key() const {
 
 
 Key Position::compute_key() const {
 

-  Key result = zobCastle[st->castleRights];
+  Key k = zobCastle[st->castleRights];

 
 

-  for (Square s = SQ_A1; s <= SQ_H8; s++)
-      if (!square_empty(s))
-          result ^= zobrist[color_of(piece_on(s))][type_of(piece_on(s))][s];
+  for (Bitboard b = pieces(); b; )
+  {
+      Square s = pop_1st_bit(&b);
+      k ^= zobrist[color_of(piece_on(s))][type_of(piece_on(s))][s];
+  }

 
   if (ep_square() != SQ_NONE)
 
   if (ep_square() != SQ_NONE)

-      result ^= zobEp[file_of(ep_square())];
+      k ^= zobEp[file_of(ep_square())];

 
   if (sideToMove == BLACK)
 
   if (sideToMove == BLACK)

-      result ^= zobSideToMove;
+      k ^= zobSideToMove;

 
 

-  return result;
+  return k;

 }
 
 
 }
 
 


@@ -1356,16 +1358,15 @@ Key Position::compute_key() const {
 
 Key Position::compute_pawn_key() const {
 
 
 Key Position::compute_pawn_key() const {
 

-  Bitboard b;
-  Key result = 0;
+  Key k = 0;

 
 

-  for (Color c = WHITE; c <= BLACK; c++)
+  for (Bitboard b = pieces(PAWN); b; )

   {
   {

-      b = pieces(PAWN, c);
-      while (b)
-          result ^= zobrist[c][PAWN][pop_1st_bit(&b)];
+      Square s = pop_1st_bit(&b);
+      k ^= zobrist[color_of(piece_on(s))][PAWN][s];

   }
   }

-  return result;
+
+  return k;

 }
 
 
 }
 
 


@@ -1377,14 +1378,14 @@ Key Position::compute_pawn_key() const {
 
 Key Position::compute_material_key() const {
 
 
 Key Position::compute_material_key() const {
 

-  Key result = 0;
+  Key k = 0;

 
   for (Color c = WHITE; c <= BLACK; c++)
       for (PieceType pt = PAWN; pt <= QUEEN; pt++)
 
   for (Color c = WHITE; c <= BLACK; c++)
       for (PieceType pt = PAWN; pt <= QUEEN; pt++)

-          for (int i = 0; i < piece_count(c, pt); i++)
-              result ^= zobrist[c][pt][i];
+          for (int cnt = 0; cnt < piece_count(c, pt); cnt++)
+              k ^= zobrist[c][pt][cnt];

 
 

-  return result;
+  return k;

 }
 
 
 }
 
 


@@ -1394,16 +1395,15 @@ Key Position::compute_material_key() const {
 /// updated by do_move and undo_move when the program is running in debug mode.
 Score Position::compute_psq_score() const {
 
 /// updated by do_move and undo_move when the program is running in debug mode.
 Score Position::compute_psq_score() const {
 

-  Score result = SCORE_ZERO;
-  Bitboard b = pieces();
+  Score score = SCORE_ZERO;

 
 

-  while (b)
+  for (Bitboard b = pieces(); b; )

   {
       Square s = pop_1st_bit(&b);
   {
       Square s = pop_1st_bit(&b);

-      result += pieceSquareTable[piece_on(s)][s];
+      score += pieceSquareTable[piece_on(s)][s];

   }
 
   }
 

-  return result;
+  return score;

 }
 
 
 }
 
 


@@ -1414,12 +1414,12 @@ Score Position::compute_psq_score() const {
 
 Value Position::compute_non_pawn_material(Color c) const {
 
 
 Value Position::compute_non_pawn_material(Color c) const {
 

-  Value result = VALUE_ZERO;
+  Value value = VALUE_ZERO;

 
   for (PieceType pt = KNIGHT; pt <= QUEEN; pt++)
 
   for (PieceType pt = KNIGHT; pt <= QUEEN; pt++)

-      result += piece_count(c, pt) * PieceValueMidgame[pt];
+      value += piece_count(c, pt) * PieceValueMidgame[pt];

 
 

-  return result;
+  return value;

 }
 
 
 }
 
 


@@ -1498,14 +1498,14 @@ void Position::init() {
   zobSideToMove = rk.rand<Key>();
   zobExclusion  = rk.rand<Key>();
 
   zobSideToMove = rk.rand<Key>();
   zobExclusion  = rk.rand<Key>();
 

-  for (Piece p = W_PAWN; p <= W_KING; p++)
+  for (PieceType pt = PAWN; pt <= KING; pt++)

   {
   {

-      Score ps = make_score(PieceValueMidgame[p], PieceValueEndgame[p]);
+      Score v = make_score(PieceValueMidgame[pt], PieceValueEndgame[pt]);

 
       for (Square s = SQ_A1; s <= SQ_H8; s++)
       {
 
       for (Square s = SQ_A1; s <= SQ_H8; s++)
       {

-          pieceSquareTable[p][s] = ps + PSQT[p][s];
-          pieceSquareTable[p+8][~s] = -pieceSquareTable[p][s];
+          pieceSquareTable[make_piece(WHITE, pt)][ s] =  (v + PSQT[pt][s]);
+          pieceSquareTable[make_piece(BLACK, pt)][~s] = -(v + PSQT[pt][s]);

       }
   }
 }
       }
   }
 }


@@ -1542,11 +1542,12 @@ void Position::flip() {
   if (pos.st->epSquare != SQ_NONE)
       st->epSquare = ~pos.st->epSquare;
 
   if (pos.st->epSquare != SQ_NONE)
       st->epSquare = ~pos.st->epSquare;
 

+  st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove);
+

   st->key = compute_key();
   st->pawnKey = compute_pawn_key();
   st->materialKey = compute_material_key();
   st->psqScore = compute_psq_score();
   st->key = compute_key();
   st->pawnKey = compute_pawn_key();
   st->materialKey = compute_material_key();
   st->psqScore = compute_psq_score();

-  st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove);

   st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
   st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
 
   st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
   st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
 


@@ -1559,42 +1560,39 @@ void Position::flip() {
 
 bool Position::pos_is_ok(int* failedStep) const {
 
 
 bool Position::pos_is_ok(int* failedStep) const {
 

+  int dummy, *step = failedStep ? failedStep : &dummy;
+

   // What features of the position should be verified?
   // What features of the position should be verified?

-  const bool debugAll = false;
-
-  const bool debugBitboards       = debugAll || false;
-  const bool debugKingCount       = debugAll || false;
-  const bool debugKingCapture     = debugAll || false;
-  const bool debugCheckerCount    = debugAll || false;
-  const bool debugKey             = debugAll || false;
-  const bool debugMaterialKey     = debugAll || false;
-  const bool debugPawnKey         = debugAll || false;
-  const bool debugIncrementalEval = debugAll || false;
-  const bool debugNonPawnMaterial = debugAll || false;
-  const bool debugPieceCounts     = debugAll || false;
-  const bool debugPieceList       = debugAll || false;
-  const bool debugCastleSquares   = debugAll || false;
-
-  if (failedStep) *failedStep = 1;
-
-  // Side to move OK?
+  const bool all = false;
+
+  const bool debugBitboards       = all || false;
+  const bool debugKingCount       = all || false;
+  const bool debugKingCapture     = all || false;
+  const bool debugCheckerCount    = all || false;
+  const bool debugKey             = all || false;
+  const bool debugMaterialKey     = all || false;
+  const bool debugPawnKey         = all || false;
+  const bool debugIncrementalEval = all || false;
+  const bool debugNonPawnMaterial = all || false;
+  const bool debugPieceCounts     = all || false;
+  const bool debugPieceList       = all || false;
+  const bool debugCastleSquares   = all || false;
+
+  *step = 1;
+

   if (sideToMove != WHITE && sideToMove != BLACK)
       return false;
 
   if (sideToMove != WHITE && sideToMove != BLACK)
       return false;
 

-  // Are the king squares in the position correct?
-  if (failedStep) (*failedStep)++;
-  if (piece_on(king_square(WHITE)) != W_KING)
+  if ((*step)++, piece_on(king_square(WHITE)) != W_KING)

       return false;
 
       return false;
 

-  if (failedStep) (*failedStep)++;
-  if (piece_on(king_square(BLACK)) != B_KING)
+  if ((*step)++, piece_on(king_square(BLACK)) != B_KING)

       return false;
 
       return false;
 

-  // Do both sides have exactly one king?
-  if (failedStep) (*failedStep)++;
-  if (debugKingCount)
+  if ((*step)++, debugKingCount)

   {
   {

-      int kingCount[2] = {0, 0};
+      int kingCount[2] = {};
+

       for (Square s = SQ_A1; s <= SQ_H8; s++)
           if (type_of(piece_on(s)) == KING)
               kingCount[color_of(piece_on(s))]++;
       for (Square s = SQ_A1; s <= SQ_H8; s++)
           if (type_of(piece_on(s)) == KING)
               kingCount[color_of(piece_on(s))]++;


@@ -1603,25 +1601,14 @@ bool Position::pos_is_ok(int* failedStep) const {
           return false;
   }
 
           return false;
   }
 

-  // Can the side to move capture the opponent's king?
-  if (failedStep) (*failedStep)++;
-  if (debugKingCapture)
-  {
-      Color us = sideToMove;
-      Color them = ~us;
-      Square ksq = king_square(them);
-      if (attackers_to(ksq) & pieces(us))
+  if ((*step)++, debugKingCapture)
+      if (attackers_to(king_square(~sideToMove)) & pieces(sideToMove))

           return false;
           return false;

-  }

 
 

-  // Is there more than 2 checkers?
-  if (failedStep) (*failedStep)++;
-  if (debugCheckerCount && popcount<Full>(st->checkersBB) > 2)
+  if ((*step)++, debugCheckerCount && popcount<Full>(st->checkersBB) > 2)

       return false;
 
       return false;
 

-  // Bitboards OK?
-  if (failedStep) (*failedStep)++;
-  if (debugBitboards)
+  if ((*step)++, debugBitboards)

   {
       // The intersection of the white and black pieces must be empty
       if (pieces(WHITE) & pieces(BLACK))
   {
       // The intersection of the white and black pieces must be empty
       if (pieces(WHITE) & pieces(BLACK))


@@ -1639,57 +1626,35 @@ bool Position::pos_is_ok(int* failedStep) const {
                   return false;
   }
 
                   return false;
   }
 

-  // En passant square OK?
-  if (failedStep) (*failedStep)++;
-  if (ep_square() != SQ_NONE)
-  {
-      // The en passant square must be on rank 6, from the point of view of the
-      // side to move.
-      if (relative_rank(sideToMove, ep_square()) != RANK_6)
-          return false;
-  }
+  if ((*step)++, ep_square() != SQ_NONE && relative_rank(sideToMove, ep_square()) != RANK_6)
+      return false;

 
 

-  // Hash key OK?
-  if (failedStep) (*failedStep)++;
-  if (debugKey && st->key != compute_key())
+  if ((*step)++, debugKey && st->key != compute_key())

       return false;
 
       return false;
 

-  // Pawn hash key OK?
-  if (failedStep) (*failedStep)++;
-  if (debugPawnKey && st->pawnKey != compute_pawn_key())
+  if ((*step)++, debugPawnKey && st->pawnKey != compute_pawn_key())

       return false;
 
       return false;
 

-  // Material hash key OK?
-  if (failedStep) (*failedStep)++;
-  if (debugMaterialKey && st->materialKey != compute_material_key())
+  if ((*step)++, debugMaterialKey && st->materialKey != compute_material_key())

       return false;
 
       return false;
 

-  // Incremental eval OK?
-  if (failedStep) (*failedStep)++;
-  if (debugIncrementalEval && st->psqScore != compute_psq_score())
+  if ((*step)++, debugIncrementalEval && st->psqScore != compute_psq_score())

       return false;
 
       return false;
 

-  // Non-pawn material OK?
-  if (failedStep) (*failedStep)++;
-  if (debugNonPawnMaterial)
+  if ((*step)++, debugNonPawnMaterial)

   {
   {

-      if (st->npMaterial[WHITE] != compute_non_pawn_material(WHITE))
-          return false;
-
-      if (st->npMaterial[BLACK] != compute_non_pawn_material(BLACK))
+      if (   st->npMaterial[WHITE] != compute_non_pawn_material(WHITE)
+          || st->npMaterial[BLACK] != compute_non_pawn_material(BLACK))

           return false;
   }
 
           return false;
   }
 

-  // Piece counts OK?
-  if (failedStep) (*failedStep)++;
-  if (debugPieceCounts)
+  if ((*step)++, debugPieceCounts)

       for (Color c = WHITE; c <= BLACK; c++)
           for (PieceType pt = PAWN; pt <= KING; pt++)
               if (pieceCount[c][pt] != popcount<Full>(pieces(pt, c)))
                   return false;
 
       for (Color c = WHITE; c <= BLACK; c++)
           for (PieceType pt = PAWN; pt <= KING; pt++)
               if (pieceCount[c][pt] != popcount<Full>(pieces(pt, c)))
                   return false;
 

-  if (failedStep) (*failedStep)++;
-  if (debugPieceList)
+  if ((*step)++, debugPieceList)

       for (Color c = WHITE; c <= BLACK; c++)
           for (PieceType pt = PAWN; pt <= KING; pt++)
               for (int i = 0; i < pieceCount[c][pt]; i++)
       for (Color c = WHITE; c <= BLACK; c++)
           for (PieceType pt = PAWN; pt <= KING; pt++)
               for (int i = 0; i < pieceCount[c][pt]; i++)


@@ -1701,19 +1666,23 @@ bool Position::pos_is_ok(int* failedStep) const {
                       return false;
               }
 
                       return false;
               }
 

-  if (failedStep) (*failedStep)++;
-  if (debugCastleSquares)
+  if ((*step)++, debugCastleSquares)

       for (Color c = WHITE; c <= BLACK; c++)
           for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s + 1))
           {
       for (Color c = WHITE; c <= BLACK; c++)
           for (CastlingSide s = KING_SIDE; s <= QUEEN_SIDE; s = CastlingSide(s + 1))
           {

-              if (!can_castle(make_castle_right(c, s)))
+              CastleRight cr = make_castle_right(c, s);
+
+              if (!can_castle(cr))

                   continue;
 
                   continue;
 

+              if ((castleRightsMask[king_square(c)] & cr) != cr)
+                  return false;
+

               if (   piece_on(castleRookSquare[c][s]) != make_piece(c, ROOK)
               if (   piece_on(castleRookSquare[c][s]) != make_piece(c, ROOK)

-                  || castleRightsMask[castleRookSquare[c][s]] != make_castle_right(c, s))
+                  || castleRightsMask[castleRookSquare[c][s]] != cr)

                   return false;
           }
 
                   return false;
           }
 

-  if (failedStep) *failedStep = 0;
+  *step = 0;

   return true;
 }
   return true;
 }