Use operator~ to flip colors and squares

More natural and nicer. Idea from Critter.

No functional change.

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

diff --git a/src/endgame.cpp b/src/endgame.cpp
index 19c5b0b8c6c45c97d89d5538095ed447680c8c15..00c707267575d816c5c0d12750768b9fa9610038 100644 (file)
--- a/src/endgame.cpp
+++ b/src/endgame.cpp
@@ -205,10 +205,10 @@ Value Endgame<KPK>::operator()(const Position& pos) const {
   }
   else
   {
-      wksq = flip(pos.king_square(BLACK));
-      bksq = flip(pos.king_square(WHITE));
-      wpsq = flip(pos.piece_list(BLACK, PAWN)[0]);
-      stm = flip(pos.side_to_move());
+      wksq = ~pos.king_square(BLACK);
+      bksq = ~pos.king_square(WHITE);
+      wpsq = ~pos.piece_list(BLACK, PAWN)[0];
+      stm  = ~pos.side_to_move();
   }
 
   if (file_of(wpsq) >= FILE_E)
@@ -251,10 +251,10 @@ Value Endgame<KRKP>::operator()(const Position& pos) const {
 
   if (strongerSide == BLACK)
   {
-      wksq = flip(wksq);
-      wrsq = flip(wrsq);
-      bksq = flip(bksq);
-      bpsq = flip(bpsq);
+      wksq = ~wksq;
+      wrsq = ~wrsq;
+      bksq = ~bksq;
+      bpsq = ~bpsq;
   }
 
   Square queeningSq = make_square(file_of(bpsq), RANK_1);
@@ -491,11 +491,11 @@ ScaleFactor Endgame<KRPKR>::operator()(const Position& pos) const {
   // pawn is on the left half of the board.
   if (strongerSide == BLACK)
   {
-      wksq = flip(wksq);
-      wrsq = flip(wrsq);
-      wpsq = flip(wpsq);
-      bksq = flip(bksq);
-      brsq = flip(brsq);
+      wksq = ~wksq;
+      wrsq = ~wrsq;
+      wpsq = ~wpsq;
+      bksq = ~bksq;
+      brsq = ~brsq;
   }
   if (file_of(wpsq) > FILE_D)
   {
@@ -867,10 +867,10 @@ ScaleFactor Endgame<KPKP>::operator()(const Position& pos) const {
 
   if (strongerSide == BLACK)
   {
-      wksq = flip(wksq);
-      bksq = flip(bksq);
-      wpsq = flip(wpsq);
-      stm = flip(stm);
+      wksq = ~wksq;
+      bksq = ~bksq;
+      wpsq = ~wpsq;
+      stm  = ~stm;
   }
 
   if (file_of(wpsq) >= FILE_E)

diff --git a/src/endgame.h b/src/endgame.h
index d91ec40f8531a4bbb09a7eaec5cdeb98ee73c1b4..70f795cd19782c7a4aec23dd3c0217db51b4efd9 100644 (file)
--- a/src/endgame.h
+++ b/src/endgame.h
@@ -82,7 +82,7 @@ struct EndgameBase {
 template<EndgameType E, typename T = typename eg_family<E>::type>
 struct Endgame : public EndgameBase<T> {
 
-  explicit Endgame(Color c) : strongerSide(c), weakerSide(flip(c)) {}
+  explicit Endgame(Color c) : strongerSide(c), weakerSide(~c) {}
   Color color() const { return strongerSide; }
   T operator()(const Position&) const;
 

diff --git a/src/evaluate.cpp b/src/evaluate.cpp
index 3d2248a53c042ac4e8a1de0cb5f72c4faeb29154..6f652c0a150c209a27b2f84478951cda4f46fccf 100644 (file)
--- a/src/evaluate.cpp
+++ b/src/evaluate.cpp
@@ -887,7 +887,7 @@ namespace {
     for (c = WHITE; c <= BLACK; c++)
     {
         // Skip if other side has non-pawn pieces
-        if (pos.non_pawn_material(flip(c)))
+        if (pos.non_pawn_material(~c))
             continue;
 
         b = ei.pi->passed_pawns(c);
@@ -900,7 +900,7 @@ namespace {
 
             // Compute plies to queening and check direct advancement
             movesToGo = rank_distance(s, queeningSquare) - int(relative_rank(c, s) == RANK_2);
-            oppMovesToGo = square_distance(pos.king_square(flip(c)), queeningSquare) - int(c != pos.side_to_move());
+            oppMovesToGo = square_distance(pos.king_square(~c), queeningSquare) - int(c != pos.side_to_move());
             pathDefended = ((ei.attackedBy[c][0] & queeningPath) == queeningPath);
 
             if (movesToGo >= oppMovesToGo && !pathDefended)
@@ -928,7 +928,7 @@ namespace {
         return SCORE_ZERO;
 
     winnerSide = (pliesToQueen[WHITE] < pliesToQueen[BLACK] ? WHITE : BLACK);
-    loserSide = flip(winnerSide);
+    loserSide = ~winnerSide;
 
     // Step 3. Can the losing side possibly create a new passed pawn and thus prevent the loss?
     b = candidates = pos.pieces(PAWN, loserSide);

diff --git a/src/movegen.cpp b/src/movegen.cpp
index c7c29a4ec5f61bab915c67c1937cc513308e5999..0ec1fceabbf7a132fbd931d5e7481b37affc0c52 100644 (file)
--- a/src/movegen.cpp
+++ b/src/movegen.cpp
@@ -49,7 +49,7 @@ namespace {
     Square rfrom = pos.castle_rook_square(CR[us]);
     Square kto = relative_square(us, Side == KING_SIDE ? SQ_G1 : SQ_C1);
     Square rto = relative_square(us, Side == KING_SIDE ? SQ_F1 : SQ_D1);
-    Bitboard enemies = pos.pieces(flip(us));
+    Bitboard enemies = pos.pieces(~us);
 
     assert(!pos.in_check());
     assert(pos.piece_on(kfrom) == make_piece(us, KING));
@@ -346,13 +346,13 @@ MoveStack* generate(const Position& pos, MoveStack* mlist) {
   Bitboard target;
 
   if (Type == MV_CAPTURE)
-      target = pos.pieces(flip(us));
+      target = pos.pieces(~us);
 
   else if (Type == MV_NON_CAPTURE)
       target = pos.empty_squares();
 
   else if (Type == MV_NON_EVASION)
-      target = pos.pieces(flip(us)) | pos.empty_squares();
+      target = pos.pieces(~us) | pos.empty_squares();
 
   mlist = generate_piece_moves<PAWN, Type>(pos, mlist, us, target);
   mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target);
@@ -444,7 +444,7 @@ MoveStack* generate<MV_EVASION>(const Position& pos, MoveStack* mlist) {
       checkersCnt++;
       checksq = pop_1st_bit(&b);
 
-      assert(color_of(pos.piece_on(checksq)) == flip(us));
+      assert(color_of(pos.piece_on(checksq)) == ~us);
 
       switch (type_of(pos.piece_on(checksq)))
       {

diff --git a/src/position.cpp b/src/position.cpp
index 907357bd1f90ba09f6197f15763248970997965b..65bac1c88515768f204af9141d1e24352d7ed21b 100644 (file)
--- a/src/position.cpp
+++ b/src/position.cpp
@@ -78,7 +78,7 @@ namespace {
 
 CheckInfo::CheckInfo(const Position& pos) {
 
-  Color them = flip(pos.side_to_move());
+  Color them = ~pos.side_to_move();
   ksq = pos.king_square(them);
 
   pinned = pos.pinned_pieces();
@@ -233,7 +233,7 @@ void Position::from_fen(const string& fenStr, bool isChess960) {
   st->value = compute_value();
   st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
   st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
-  st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(flip(sideToMove));
+  st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove);
   chess960 = isChess960;
 
   assert(pos_is_ok());
@@ -356,8 +356,8 @@ Bitboard Position::hidden_checkers() const {
 
   // Pinned pieces protect our king, dicovery checks attack the enemy king
   Bitboard b, result = 0;
-  Bitboard pinners = pieces(FindPinned ? flip(sideToMove) : sideToMove);
-  Square ksq = king_square(FindPinned ? sideToMove : flip(sideToMove));
+  Bitboard pinners = pieces(FindPinned ? ~sideToMove : sideToMove);
+  Square ksq = king_square(FindPinned ? sideToMove : ~sideToMove);
 
   // Pinners are sliders, that give check when candidate pinned is removed
   pinners &=  (pieces(ROOK, QUEEN) & PseudoAttacks[ROOK][ksq])
@@ -449,7 +449,7 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
   assert(is_ok(m));
   assert(pinned == pinned_pieces());
 
-  Color us = side_to_move();
+  Color us = sideToMove;
   Square from = from_sq(m);
 
   assert(color_of(piece_on(from)) == us);
@@ -460,7 +460,7 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
   // the move is made.
   if (is_enpassant(m))
   {
-      Color them = flip(us);
+      Color them = ~us;
       Square to = to_sq(m);
       Square capsq = to + pawn_push(them);
       Square ksq = king_square(us);
@@ -483,7 +483,7 @@ bool Position::pl_move_is_legal(Move m, Bitboard pinned) const {
   // square is attacked by the opponent. Castling moves are checked
   // for legality during move generation.
   if (type_of(piece_on(from)) == KING)
-      return is_castle(m) || !(attackers_to(to_sq(m)) & pieces(flip(us)));
+      return is_castle(m) || !(attackers_to(to_sq(m)) & pieces(~us));
 
   // A non-king move is legal if and only if it is not pinned or it
   // is moving along the ray towards or away from the king.
@@ -514,7 +514,7 @@ bool Position::move_is_legal(const Move m) const {
 bool Position::is_pseudo_legal(const Move m) const {
 
   Color us = sideToMove;
-  Color them = flip(sideToMove);
+  Color them = ~sideToMove;
   Square from = from_sq(m);
   Square to = to_sq(m);
   Piece pc = piece_on(from);
@@ -612,7 +612,7 @@ bool Position::is_pseudo_legal(const Move m) const {
       {
           Bitboard b = occupied_squares();
           clear_bit(&b, from);
-          if (attackers_to(to_sq(m), b) & pieces(flip(us)))
+          if (attackers_to(to_sq(m), b) & pieces(~us))
               return false;
       }
       else
@@ -640,7 +640,7 @@ bool Position::move_gives_check(Move m, const CheckInfo& ci) const {
 
   assert(is_ok(m));
   assert(ci.dcCandidates == discovered_check_candidates());
-  assert(color_of(piece_moved(m)) == side_to_move());
+  assert(color_of(piece_moved(m)) == sideToMove);
 
   Square from = from_sq(m);
   Square to = to_sq(m);
@@ -655,7 +655,7 @@ bool Position::move_gives_check(Move m, const CheckInfo& ci) const {
   {
       // For pawn and king moves we need to verify also direction
       if (  (pt != PAWN && pt != KING)
-          || !squares_aligned(from, to, king_square(flip(side_to_move()))))
+          || !squares_aligned(from, to, king_square(~sideToMove)))
           return true;
   }
 
@@ -663,9 +663,9 @@ bool Position::move_gives_check(Move m, const CheckInfo& ci) const {
   if (!is_special(m))
       return false;
 
-  Color us = side_to_move();
+  Color us = sideToMove;
   Bitboard b = occupied_squares();
-  Square ksq = king_square(flip(us));
+  Square ksq = king_square(~us);
 
   // Promotion with check ?
   if (is_promotion(m))
@@ -763,8 +763,8 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
       return;
   }
 
-  Color us = side_to_move();
-  Color them = flip(us);
+  Color us = sideToMove;
+  Color them = ~us;
   Square from = from_sq(m);
   Square to = to_sq(m);
   Piece piece = piece_on(from);
@@ -957,7 +957,7 @@ void Position::do_move(Move m, StateInfo& newSt, const CheckInfo& ci, bool moveI
   }
 
   // Finish
-  sideToMove = flip(sideToMove);
+  sideToMove = ~sideToMove;
   st->value += (sideToMove == WHITE ?  TempoValue : -TempoValue);
 
   assert(pos_is_ok());
@@ -971,7 +971,7 @@ void Position::undo_move(Move m) {
 
   assert(is_ok(m));
 
-  sideToMove = flip(sideToMove);
+  sideToMove = ~sideToMove;
 
   if (is_castle(m))
   {
@@ -979,8 +979,8 @@ void Position::undo_move(Move m) {
       return;
   }
 
-  Color us = side_to_move();
-  Color them = flip(us);
+  Color us = sideToMove;
+  Color them = ~us;
   Square from = from_sq(m);
   Square to = to_sq(m);
   Piece piece = piece_on(to);
@@ -1075,7 +1075,7 @@ void Position::do_castle_move(Move m) {
 
   Square kto, kfrom, rfrom, rto, kAfter, rAfter;
 
-  Color us = side_to_move();
+  Color us = sideToMove;
   Square kBefore = from_sq(m);
   Square rBefore = to_sq(m);
 
@@ -1159,10 +1159,10 @@ void Position::do_castle_move(Move m) {
       st->rule50 = 0;
 
       // Update checkers BB
-      st->checkersBB = attackers_to(king_square(flip(us))) & pieces(us);
+      st->checkersBB = attackers_to(king_square(~us)) & pieces(us);
 
       // Finish
-      sideToMove = flip(sideToMove);
+      sideToMove = ~sideToMove;
       st->value += (sideToMove == WHITE ?  TempoValue : -TempoValue);
   }
   else
@@ -1193,7 +1193,7 @@ void Position::do_null_move(StateInfo& backupSt) {
   dst->rule50   = src->rule50;
   dst->pliesFromNull = src->pliesFromNull;
 
-  sideToMove = flip(sideToMove);
+  sideToMove = ~sideToMove;
 
   if (Do)
   {
@@ -1263,7 +1263,7 @@ int Position::see(Move m) const {
   // Handle en passant moves
   if (is_enpassant(m))
   {
-      Square capQq = to - pawn_push(side_to_move());
+      Square capQq = to - pawn_push(sideToMove);
 
       assert(capturedType == NO_PIECE_TYPE);
       assert(type_of(piece_on(capQq)) == PAWN);
@@ -1279,7 +1279,7 @@ int Position::see(Move m) const {
   attackers = attackers_to(to, occ);
 
   // If the opponent has no attackers we are finished
-  stm = flip(color_of(piece_on(from)));
+  stm = ~color_of(piece_on(from));
   stmAttackers = attackers & pieces(stm);
   if (!stmAttackers)
       return PieceValueMidgame[capturedType];
@@ -1317,7 +1317,7 @@ int Position::see(Move m) const {
       // Remember the value of the capturing piece, and change the side to
       // move before beginning the next iteration.
       capturedType = pt;
-      stm = flip(stm);
+      stm = ~stm;
       stmAttackers = attackers & pieces(stm);
 
       // Stop before processing a king capture
@@ -1401,7 +1401,7 @@ Key Position::compute_key() const {
   if (ep_square() != SQ_NONE)
       result ^= zobEp[ep_square()];
 
-  if (side_to_move() == BLACK)
+  if (sideToMove == BLACK)
       result ^= zobSideToMove;
 
   return result;
@@ -1465,7 +1465,7 @@ Score Position::compute_value() const {
               result += pst(make_piece(c, pt), pop_1st_bit(&b));
       }
 
-  result += (side_to_move() == WHITE ? TempoValue / 2 : -TempoValue / 2);
+  result += (sideToMove == WHITE ? TempoValue / 2 : -TempoValue / 2);
   return result;
 }
 
@@ -1561,7 +1561,7 @@ void Position::init() {
       for (Square s = SQ_A1; s <= SQ_H8; s++)
       {
           pieceSquareTable[p][s] = ps + PSQT[p][s];
-          pieceSquareTable[p+8][flip(s)] = -pieceSquareTable[p][s];
+          pieceSquareTable[p+8][~s] = -pieceSquareTable[p][s];
       }
   }
 }
@@ -1581,27 +1581,27 @@ void Position::flip_me() {
   // Board
   for (Square s = SQ_A1; s <= SQ_H8; s++)
       if (!pos.square_is_empty(s))
-          put_piece(Piece(pos.piece_on(s) ^ 8), flip(s));
+          put_piece(Piece(pos.piece_on(s) ^ 8), ~s);
 
   // Side to move
-  sideToMove = flip(pos.side_to_move());
+  sideToMove = ~pos.side_to_move();
 
   // Castling rights
   if (pos.can_castle(WHITE_OO))
-      set_castle_right(BLACK, flip(pos.castle_rook_square(WHITE_OO)));
+      set_castle_right(BLACK, ~pos.castle_rook_square(WHITE_OO));
   if (pos.can_castle(WHITE_OOO))
-      set_castle_right(BLACK, flip(pos.castle_rook_square(WHITE_OOO)));
+      set_castle_right(BLACK, ~pos.castle_rook_square(WHITE_OOO));
   if (pos.can_castle(BLACK_OO))
-      set_castle_right(WHITE, flip(pos.castle_rook_square(BLACK_OO)));
+      set_castle_right(WHITE, ~pos.castle_rook_square(BLACK_OO));
   if (pos.can_castle(BLACK_OOO))
-      set_castle_right(WHITE, flip(pos.castle_rook_square(BLACK_OOO)));
+      set_castle_right(WHITE, ~pos.castle_rook_square(BLACK_OOO));
 
   // En passant square
   if (pos.st->epSquare != SQ_NONE)
-      st->epSquare = flip(pos.st->epSquare);
+      st->epSquare = ~pos.st->epSquare;
 
   // Checkers
-  st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(flip(sideToMove));
+  st->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove);
 
   // Hash keys
   st->key = compute_key();
@@ -1643,7 +1643,7 @@ bool Position::pos_is_ok(int* failedStep) const {
   if (failedStep) *failedStep = 1;
 
   // Side to move OK?
-  if (side_to_move() != WHITE && side_to_move() != BLACK)
+  if (sideToMove != WHITE && sideToMove != BLACK)
       return false;
 
   // Are the king squares in the position correct?
@@ -1672,8 +1672,8 @@ bool Position::pos_is_ok(int* failedStep) const {
   if (failedStep) (*failedStep)++;
   if (debugKingCapture)
   {
-      Color us = side_to_move();
-      Color them = flip(us);
+      Color us = sideToMove;
+      Color them = ~us;
       Square ksq = king_square(them);
       if (attackers_to(ksq) & pieces(us))
           return false;
@@ -1710,7 +1710,7 @@ bool Position::pos_is_ok(int* failedStep) const {
   {
       // The en passant square must be on rank 6, from the point of view of the
       // side to move.
-      if (relative_rank(side_to_move(), ep_square()) != RANK_6)
+      if (relative_rank(sideToMove, ep_square()) != RANK_6)
           return false;
   }
 

diff --git a/src/position.h b/src/position.h
index f09d629f4e829f967558ad810f737d8fdf1d30a3..c391d8247c72f4530d78d942a1d087eb1d472180 100644 (file)
--- a/src/position.h
+++ b/src/position.h
@@ -392,7 +392,7 @@ inline Bitboard Position::pinned_pieces() const {
 }
 
 inline bool Position::pawn_is_passed(Color c, Square s) const {
-  return !(pieces(PAWN, flip(c)) & passed_pawn_mask(c, s));
+  return !(pieces(PAWN, ~c) & passed_pawn_mask(c, s));
 }
 
 inline Key Position::key() const {

diff --git a/src/search.cpp b/src/search.cpp
index 6f018d817b6c9b54d8c8e028803739466725d90c..3dde96d8a0c893290124e980ad7c4bfff88129d5 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -1393,7 +1393,7 @@ split_point_start: // At split points actual search starts from here
 
     from = from_sq(move);
     to = to_sq(move);
-    them = flip(pos.side_to_move());
+    them = ~pos.side_to_move();
     ksq = pos.king_square(them);
     kingAtt = pos.attacks_from<KING>(ksq);
     pc = pos.piece_on(from);

diff --git a/src/types.h b/src/types.h
index 0915d685ada89f872d8c91b2871a939384c442ba..0d2cdd3bc8cd20d4479b2cf2d5c6ba5ab0217d2e 100644 (file)
--- a/src/types.h
+++ b/src/types.h
@@ -334,6 +334,14 @@ extern const Value PieceValueMidgame[17];
 extern const Value PieceValueEndgame[17];
 extern int SquareDistance[64][64];
 
+inline Color operator~(Color c) {
+  return Color(c ^ 1);
+}
+
+inline Square operator~(Square s) {
+  return Square(s ^ 56);
+}
+
 inline Value mate_in(int ply) {
   return VALUE_MATE - ply;
 }
@@ -354,10 +362,6 @@ inline Color color_of(Piece p) {
   return Color(p >> 3);
 }
 
-inline Color flip(Color c) {
-  return Color(c ^ 1);
-}
-
 inline Square make_square(File f, Rank r) {
   return Square((r << 3) | f);
 }
@@ -374,10 +378,6 @@ inline Rank rank_of(Square s) {
   return Rank(s >> 3);
 }
 
-inline Square flip(Square s) {
-  return Square(s ^ 56);
-}
-
 inline Square mirror(Square s) {
   return Square(s ^ 7);
 }