X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fevaluate.cpp;h=d5844593fe45a67ce417085012eab41054613e9f;hb=d6b6360ff5dcdffa141f50d0a81d0be7c6324c71;hp=eaad4d556722cb0b2f99d8e0984865f2c549f8c1;hpb=15ac117ac492e3147b391aa0ee3665fe8876be63;p=stockfish

diff --git a/src/evaluate.cpp b/src/evaluate.cpp
index eaad4d55..d5844593 100644
--- a/src/evaluate.cpp
+++ b/src/evaluate.cpp
@@ -1051,14 +1051,12 @@ make_v:
 Value Eval::evaluate(const Position& pos, int* complexity) {
 
   Value v;
-  Color stm = pos.side_to_move();
   Value psq = pos.psq_eg_stm();
 
-  // Deciding between classical and NNUE eval: for high PSQ imbalance we use classical,
-  // but we switch to NNUE during long shuffling or with high material on the board.
-  bool useClassical = !useNNUE ||
-                      ((pos.count<ALL_PIECES>() > 7)
-                       && abs(psq) * 5 > (856 + pos.non_pawn_material() / 64) * (10 + pos.rule50_count()));
+  // We use the much less accurate but faster Classical eval when the NNUE
+  // option is set to false. Otherwise we use the NNUE eval unless the
+  // PSQ advantage is decisive and several pieces remain. (~3 Elo)
+  bool useClassical = !useNNUE || (pos.count<ALL_PIECES>() > 7 && abs(psq) > 1760);
 
   if (useClassical)
       v = Evaluation<NO_TRACE>(pos).value();
@@ -1066,12 +1064,20 @@ Value Eval::evaluate(const Position& pos, int* complexity) {
   {
       int nnueComplexity;
       int scale = 1064 + 106 * pos.non_pawn_material() / 5120;
+
+      Color stm = pos.side_to_move();
       Value optimism = pos.this_thread()->optimism[stm];
 
       Value nnue = NNUE::evaluate(pos, true, &nnueComplexity);
+
       // Blend nnue complexity with (semi)classical complexity
-      nnueComplexity = (104 * nnueComplexity + 131 * abs(nnue - psq)) / 256;
-      if (complexity) // Return hybrid NNUE complexity to caller
+      nnueComplexity = (  416 * nnueComplexity
+                        + 424 * abs(psq - nnue)
+                        + (optimism  > 0 ? int(optimism) * int(psq - nnue) : 0)
+                        ) / 1024;
+
+      // Return hybrid NNUE complexity to caller
+      if (complexity)
           *complexity = nnueComplexity;
 
       optimism = optimism * (269 + nnueComplexity) / 256;