Minor cleanups

simplify and relocate to position.cpp some of the recent threat calculations used in the movepicker.

passed STC:
https://tests.stockfishchess.org/tests/view/62468c301f682ea45ce3b3b9
LLR: 2.96 (-2.94,2.94) <-2.25,0.25>
Total: 76544 W: 20247 L: 20152 D: 36145
Ptnml(0-2): 327, 8113, 21317, 8168, 347

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

No functional change

diff --git a/src/misc.h b/src/misc.h
index dcef22a411c2c90276f8c993b13777f84f6f042c..2fd2b408a1261644c7b0c7315f91dcb77cc2bf54 100644 (file)
--- a/src/misc.h
+++ b/src/misc.h
@@ -90,9 +90,6 @@ static inline const bool IsLittleEndian = (Le.c[0] == 4);
 class RunningAverage {
   public:
 
-      // Constructor
-      RunningAverage() {}
-
       // Reset the running average to rational value p / q
       void set(int64_t p, int64_t q)
         { average = p * PERIOD * RESOLUTION / q; }
@@ -102,10 +99,10 @@ class RunningAverage {
         { average = RESOLUTION * v + (PERIOD - 1) * average / PERIOD; }
 
       // Test if average is strictly greater than rational a / b
-      bool is_greater(int64_t a, int64_t b)
-        { return b * average > a * PERIOD * RESOLUTION ; }
+      bool is_greater(int64_t a, int64_t b) const
+        { return b * average > a * (PERIOD * RESOLUTION); }
 
-      int64_t value()
+      int64_t value() const
         { return average / (PERIOD * RESOLUTION); }
 
   private :

diff --git a/src/movepick.cpp b/src/movepick.cpp
index ce82a59ba3dd14441f431cf42c0692d0824bcefa..b0166c6e962b55a169f75ce6f6abbee65b4e029b 100644 (file)
--- a/src/movepick.cpp
+++ b/src/movepick.cpp
@@ -18,6 +18,7 @@
 
 #include <cassert>
 
+#include "bitboard.h"
 #include "movepick.h"
 
 namespace Stockfish {
@@ -97,44 +98,6 @@ MovePicker::MovePicker(const Position& p, Move ttm, Value th, Depth d, const Cap
                              && pos.see_ge(ttm, threshold));
 }
 
-//squares threatened by pawn attacks
-template <Color Us>
-Bitboard threatsByPawn (const Position& pos)
-{
-    return pawn_attacks_bb<Us>(pos.pieces(Us, PAWN));
-}
-
-//squares threatened by minor attacks
-template <Color Us>
-Bitboard threatsByMinor (const Position& pos)
-{
-    Bitboard our = pos.pieces(Us, KNIGHT, BISHOP);
-    Bitboard threats = 0;
-    while (our)
-    {
-        Square s = pop_lsb(our);
-        if (type_of(pos.piece_on(s)) == KNIGHT)
-            threats |= attacks_bb<KNIGHT>(s, pos.pieces());
-        else
-            threats |= attacks_bb<BISHOP>(s, pos.pieces());
-    }
-    return threats;
-}
-
-//squares threatened by rook attacks
-template <Color Us>
-Bitboard threatsByRook (const Position& pos)
-{
-    Bitboard our = pos.pieces(Us, ROOK);
-    Bitboard threats = 0;
-    while (our)
-    {
-        Square s = pop_lsb(our);
-        threats |= attacks_bb<ROOK>(s, pos.pieces());
-    }
-    return threats;
-}
-
 /// MovePicker::score() assigns a numerical value to each move in a list, used
 /// for sorting. Captures are ordered by Most Valuable Victim (MVV), preferring
 /// captures with a good history. Quiets moves are ordered using the histories.
@@ -146,26 +109,22 @@ void MovePicker::score() {
   Bitboard threatened, threatenedByPawn, threatenedByMinor, threatenedByRook;
   if constexpr (Type == QUIETS)
   {
+      Color us = pos.side_to_move();
       // squares threatened by pawns
-      threatenedByPawn   = pos.side_to_move() == WHITE ? threatsByPawn<BLACK>(pos)  : threatsByPawn<WHITE>(pos);
+      threatenedByPawn  = pos.attacks_by<PAWN>(~us);
       // squares threatened by minors or pawns
-      threatenedByMinor  = pos.side_to_move() == WHITE ? threatsByMinor<BLACK>(pos) : threatsByMinor<WHITE>(pos);
-      threatenedByMinor |= threatenedByPawn;
+      threatenedByMinor = pos.attacks_by<KNIGHT>(~us) | pos.attacks_by<BISHOP>(~us) | threatenedByPawn;
       // squares threatened by rooks, minors or pawns
-      threatenedByRook   = pos.side_to_move() == WHITE ? threatsByRook<BLACK>(pos)  : threatsByRook<WHITE>(pos);
-      threatenedByRook  |= threatenedByMinor;
+      threatenedByRook  = pos.attacks_by<ROOK>(~us) | threatenedByMinor;
 
       // pieces threatened by pieces of lesser material value
-      threatened = pos.side_to_move() == WHITE ? ((pos.pieces(WHITE, QUEEN) & threatenedByRook) |
-                                                  (pos.pieces(WHITE, ROOK) & threatenedByMinor) |
-                                                  (pos.pieces(WHITE, KNIGHT, BISHOP) & threatenedByPawn))
-                                               : ((pos.pieces(BLACK, QUEEN) & threatenedByRook) |
-                                                  (pos.pieces(BLACK, ROOK) & threatenedByMinor) |
-                                                  (pos.pieces(BLACK, KNIGHT, BISHOP) & threatenedByPawn));
+      threatened =  (pos.pieces(us, QUEEN) & threatenedByRook)
+                  | (pos.pieces(us, ROOK)  & threatenedByMinor)
+                  | (pos.pieces(us, KNIGHT, BISHOP) & threatenedByPawn);
   }
   else
   {
-      // Silence unused variable warning
+      // Silence unused variable warnings
       (void) threatened;
       (void) threatenedByPawn;
       (void) threatenedByMinor;
@@ -184,11 +143,11 @@ void MovePicker::score() {
                    +     (*continuationHistory[3])[pos.moved_piece(m)][to_sq(m)]
                    +     (*continuationHistory[5])[pos.moved_piece(m)][to_sq(m)]
                    +     (threatened & from_sq(m) ?
-                           (type_of(pos.piece_on(from_sq(m))) == QUEEN && !(to_sq(m) & threatenedByRook)  ? 50000
-                          : type_of(pos.piece_on(from_sq(m))) == ROOK  && !(to_sq(m) & threatenedByMinor) ? 25000
-                          :                                               !(to_sq(m) & threatenedByPawn)  ? 15000
-                          :                                                                                 0)
-                          :                                                                                 0);
+                           (type_of(pos.moved_piece(m)) == QUEEN && !(to_sq(m) & threatenedByRook)  ? 50000
+                          : type_of(pos.moved_piece(m)) == ROOK  && !(to_sq(m) & threatenedByMinor) ? 25000
+                          :                                         !(to_sq(m) & threatenedByPawn)  ? 15000
+                          :                                                                           0)
+                          :                                                                           0);
 
       else // Type == EVASIONS
       {

diff --git a/src/position.h b/src/position.h
index 7b6165f37acf0cae45b021fef291ba46557d9c6b..e558581850f41a57a664af73a3f233b589d29665 100644 (file)
--- a/src/position.h
+++ b/src/position.h
@@ -120,12 +120,12 @@ public:
   Bitboard attackers_to(Square s) const;
   Bitboard attackers_to(Square s, Bitboard occupied) const;
   Bitboard slider_blockers(Bitboard sliders, Square s, Bitboard& pinners) const;
+  template<PieceType Pt> Bitboard attacks_by(Color c) const;
 
   // Properties of moves
   bool legal(Move m) const;
   bool pseudo_legal(const Move m) const;
   bool capture(Move m) const;
-  bool capture_or_promotion(Move m) const;
   bool gives_check(Move m) const;
   Piece moved_piece(Move m) const;
   Piece captured_piece() const;
@@ -285,6 +285,22 @@ inline Bitboard Position::attackers_to(Square s) const {
   return attackers_to(s, pieces());
 }
 
+template<PieceType Pt>
+inline Bitboard Position::attacks_by(Color c) const {
+
+  if constexpr (Pt == PAWN)
+      return c == WHITE ? pawn_attacks_bb<WHITE>(pieces(WHITE, PAWN))
+                        : pawn_attacks_bb<BLACK>(pieces(BLACK, PAWN));
+  else
+  {
+      Bitboard threats = 0;
+      Bitboard attackers = pieces(c, Pt);
+      while (attackers)
+          threats |= attacks_bb<Pt>(pop_lsb(attackers), pieces());
+      return threats;
+  }
+}
+
 inline Bitboard Position::checkers() const {
   return st->checkersBB;
 }