Small cleanups (march 2021)

[stockfish] / src / evaluate.cpp

diff --git a/src/evaluate.cpp b/src/evaluate.cpp
index d4138cfaab5c78b5ee629dd40a19b75a5e8ce32b..ca86a435fbfe9bd98318b1fe4d4bed468ca0f408 100644 (file)
--- a/src/evaluate.cpp
+++ b/src/evaluate.cpp
@@ -54,7 +54,6 @@
 
 
 using namespace std;
-using namespace Stockfish::Eval::NNUE;
 
 namespace Stockfish {
 
@@ -396,7 +395,8 @@ namespace {
 
     attackedBy[Us][Pt] = 0;
 
-    while (b1) {
+    while (b1)
+    {
         Square s = pop_lsb(b1);
 
         // Find attacked squares, including x-ray attacks for bishops and rooks
@@ -1038,46 +1038,51 @@ make_v:
     return v;
   }
 
-  // specifically correct for cornered bishops to fix FRC with NNUE.
+
+  /// Fisher Random Chess: correction for cornered bishops, to fix chess960 play with NNUE
+
   Value fix_FRC(const Position& pos) {
 
-    Value bAdjust = Value(0);
+    constexpr Bitboard Corners =  1ULL << SQ_A1 | 1ULL << SQ_H1 | 1ULL << SQ_A8 | 1ULL << SQ_H8;
 
-    constexpr Value p1=Value(209), p2=Value(136), p3=Value(148);
+    if (!(pos.pieces(BISHOP) & Corners))
+        return VALUE_ZERO;
 
-    Color Us = pos.side_to_move();
-    if (   (pos.pieces(Us, BISHOP) & relative_square(Us, SQ_A1))
-        && (pos.pieces(Us, PAWN) & relative_square(Us, SQ_B2)))
-    {
-        bAdjust      -= !pos.empty(relative_square(Us,SQ_B3))                            ? p1
-                       : pos.piece_on(relative_square(Us,SQ_C3)) == make_piece(Us, PAWN) ? p2
-                                                                                         : p3;
-    }
-    if (   (pos.pieces(Us, BISHOP) & relative_square(Us, SQ_H1))
-        && (pos.pieces(Us, PAWN) & relative_square(Us, SQ_G2)))
-    {
-        bAdjust      -= !pos.empty(relative_square(Us,SQ_G3))                            ? p1
-                       : pos.piece_on(relative_square(Us,SQ_F3)) == make_piece(Us, PAWN) ? p2
-                                                                                         : p3;
-    }
-    if (   (pos.pieces(~Us, BISHOP) & relative_square(Us, SQ_A8))
-        && (pos.pieces(~Us, PAWN) & relative_square(Us, SQ_B7)))
-    {
-        bAdjust      += !pos.empty(relative_square(Us,SQ_B6))                             ? p1
-                       : pos.piece_on(relative_square(Us,SQ_C6)) == make_piece(~Us, PAWN) ? p2
-                                                                                          : p3;
-    }
-    if (   (pos.pieces(~Us, BISHOP) & relative_square(Us, SQ_H8))
-        && (pos.pieces(~Us, PAWN) & relative_square(Us, SQ_G7)))
-    {
-        bAdjust      += !pos.empty(relative_square(Us,SQ_G6))                             ? p1
-                       : pos.piece_on(relative_square(Us,SQ_F6)) == make_piece(~Us, PAWN) ? p2
-                                                                                          : p3;
-    }
-    return bAdjust;
+    constexpr int penalty1 = -209;
+    constexpr int penalty2 = -136;
+    constexpr int penalty3 = -148;
+
+    int correction = 0;
+
+    if (   pos.piece_on(SQ_A1) == W_BISHOP
+        && pos.piece_on(SQ_B2) == W_PAWN)
+        correction += !pos.empty(SQ_B3)              ? penalty1
+                     : pos.piece_on(SQ_C3) == W_PAWN ? penalty2
+                                                     : penalty3;
+
+    if (   pos.piece_on(SQ_H1) == W_BISHOP
+        && pos.piece_on(SQ_G2) == W_PAWN)
+        correction += !pos.empty(SQ_G3)              ? penalty1
+                     : pos.piece_on(SQ_F3) == W_PAWN ? penalty2
+                                                     : penalty3;
+
+    if (   pos.piece_on(SQ_A8) == B_BISHOP
+        && pos.piece_on(SQ_B7) == B_PAWN)
+        correction += !pos.empty(SQ_B6)              ? -penalty1
+                     : pos.piece_on(SQ_C6) == B_PAWN ? -penalty2
+                                                     : -penalty3;
+
+    if (   pos.piece_on(SQ_H8) == B_BISHOP
+        && pos.piece_on(SQ_G7) == B_PAWN)
+        correction += !pos.empty(SQ_G6)              ? -penalty1
+                     : pos.piece_on(SQ_F6) == B_PAWN ? -penalty2
+                                                     : -penalty3;
+
+    return pos.side_to_move() == WHITE ?  Value(correction)
+                                       : -Value(correction);
   }
 
-} // namespace
+} // namespace Eval
 
 
 /// evaluate() is the evaluator for the outer world. It returns a static
@@ -1092,14 +1097,19 @@ Value Eval::evaluate(const Position& pos) {
   else
   {
       // Scale and shift NNUE for compatibility with search and classical evaluation
-      auto  adjusted_NNUE = [&](){
-         int mat = pos.non_pawn_material() + 2 * PawnValueMg * pos.count<PAWN>();
-         Value nnueValue = NNUE::evaluate(pos) * (641 + mat / 32 - 4 * pos.rule50_count()) / 1024 + Tempo;
+      auto  adjusted_NNUE = [&]()
+      {
+         int material = pos.non_pawn_material() + 2 * PawnValueMg * pos.count<PAWN>();
+         int scale =  641
+                    + material / 32
+                    - 4 * pos.rule50_count();
+
+         Value nnue = NNUE::evaluate(pos) * scale / 1024 + Tempo;
 
          if (pos.is_chess960())
-            nnueValue += fix_FRC(pos);
+             nnue += fix_FRC(pos);
 
-         return nnueValue;
+         return nnue;
       };
 
       // If there is PSQ imbalance use classical eval, with small probability if it is small