Further simplify aspiration code

Actually after last patch it happens that delta
starts always with the fixed value of 16.

So further remove useless code.

No functional change.

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

diff --git a/src/search.cpp b/src/search.cpp
index 651478c71241cc2f197c2cad98543b08acc81e96..b160145ef4baafae8c8640a52cb60324ad960eff 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -426,8 +426,8 @@ namespace {
 
     Stack ss[PLY_MAX_PLUS_2];
     int bestMoveChanges[PLY_MAX_PLUS_2];
-    int depth, delta;
-    Value bestValue, alpha, beta;
+    int depth;
+    Value bestValue, alpha, beta, delta;
     Move bestMove, skillBest, skillPonder;
     bool bestMoveNeverChanged = true;
 
@@ -436,8 +436,8 @@ namespace {
     H.clear();
     RootMoves.clear();
     *ponderMove = bestMove = skillBest = skillPonder = MOVE_NONE;
-    depth = delta = 0;
-    bestValue = alpha = -VALUE_INFINITE, beta = VALUE_INFINITE;
+    depth = 0;
+    bestValue = alpha = -VALUE_INFINITE, beta = delta = VALUE_INFINITE;
     ss->currentMove = MOVE_NULL; // Hack to skip update gains
 
     for (MoveList<MV_LEGAL> ml(pos); !ml.end(); ++ml)
@@ -467,16 +467,11 @@ namespace {
         for (MultiPVIdx = 0; MultiPVIdx < std::min(MultiPV, RootMoves.size()); MultiPVIdx++)
         {
             // Calculate dynamic aspiration window based on previous iteration
-            if (depth >= 5 && abs(RootMoves[MultiPVIdx].score) < VALUE_KNOWN_WIN)
+            if (depth >= 5 && abs(RootMoves[MultiPVIdx].prevScore) < VALUE_KNOWN_WIN)
             {
-                delta = abs(RootMoves[MultiPVIdx].score - RootMoves[MultiPVIdx].prevScore);
-                delta = std::min(std::max(delta, 16), 24);
-                delta = (delta + 7) / 8 * 8; // Round to match grainSize
-
-                alpha = RootMoves[MultiPVIdx].score - delta;
-                beta  = RootMoves[MultiPVIdx].score + delta;
-
-                assert(alpha > -VALUE_INFINITE && beta < VALUE_INFINITE);
+                delta = Value(16);
+                alpha = RootMoves[MultiPVIdx].prevScore - delta;
+                beta  = RootMoves[MultiPVIdx].prevScore + delta;
             }
             else
             {
@@ -544,7 +539,7 @@ namespace {
                 // research, otherwise exit the fail high/low loop.
                 if (bestValue >= beta)
                 {
-                    beta = std::min(beta + delta, VALUE_INFINITE);
+                    beta += delta;
                     delta += delta / 2;
                 }
                 else if (bestValue <= alpha)
@@ -552,12 +547,14 @@ namespace {
                     Signals.failedLowAtRoot = true;
                     Signals.stopOnPonderhit = false;
 
-                    alpha = std::max(alpha - delta, -VALUE_INFINITE);
+                    alpha -= delta;
                     delta += delta / 2;
                 }
                 else
                     break;
 
+                assert(alpha >= -VALUE_INFINITE && beta <= VALUE_INFINITE);
+
             } while (abs(bestValue) < VALUE_KNOWN_WIN);
         }