Reformat time manager code

In particular clarify that 'sd'
parameter is used only in !movesToGo
case.

Verified with Ivan's check tool it is
equivalent to original code.

No functional change.

diff --git a/src/timeman.cpp b/src/timeman.cpp
index b5d1a66c30b05faf1d26da029ebd42ab7bbdfe8a..ea1e92d2aca5ca57ef0c6c2a6942ea2717d65753 100644 (file)
--- a/src/timeman.cpp
+++ b/src/timeman.cpp
@@ -31,17 +31,15 @@ namespace {
   enum TimeType { OptimumTime, MaxTime };
 
   int remaining(int myTime, int myInc, int moveOverhead, int movesToGo,
-                int ply, bool ponder, TimeType type) {
+                int moveNum, bool ponder, TimeType type) {
 
     if (myTime <= 0)
         return 0;
 
-    int moveNumber = (ply + 1) / 2;
-    double ratio; // Which ratio of myTime we are going to use. It's <= 1 if not ponder
-    double sd = 8.5;
+    double ratio; // Which ratio of myTime we are going to use
 
     // Usage of increment follows quadratic distribution with the maximum at move 25
-    double inc = myInc * std::max(55.0, 120.0 - 0.12 * (moveNumber - 25) * (moveNumber - 25));
+    double inc = myInc * std::max(55.0, 120 - 0.12 * (moveNum - 25) * (moveNum - 25));
 
     // In moves-to-go we distribute time according to a quadratic function with
     // the maximum around move 20 for 40 moves in y time case.
@@ -49,28 +47,26 @@ namespace {
     {
         ratio = (type == OptimumTime ? 1.0 : 6.0) / std::min(50, movesToGo);
 
-        if (moveNumber <= 40)
-            ratio *= 1.1 - 0.001 * (moveNumber - 20) * (moveNumber - 20);
+        if (moveNum <= 40)
+            ratio *= 1.1 - 0.001 * (moveNum - 20) * (moveNum - 20);
         else
             ratio *= 1.5;
+
+        ratio *= 1 + inc / (myTime * 8.5);
     }
     // Otherwise we increase usage of remaining time as the game goes on
     else
     {
-        sd = 1 + 20 * moveNumber / (500.0 + moveNumber);
-        ratio = (type == OptimumTime ? 0.017 : 0.07) * sd;
+        double k = 1 + 20 * moveNum / (500.0 + moveNum);
+        ratio = (type == OptimumTime ? 0.017 : 0.07) * (k + inc / myTime);
     }
 
-    ratio = std::min(1.0, ratio * (1 + inc / (myTime * sd)));
-
-    assert(ratio <= 1);
+    int time = int(std::min(1.0, ratio) * std::max(0, myTime - moveOverhead));
 
-    if (ponder && type == OptimumTime)
-        ratio *= 1.25;
+    if (type == OptimumTime && ponder)
+        time *= 1.25;
 
-    int time = int(ratio * (myTime - moveOverhead));
-
-    if (type == OptimumTime)
+    if (type == MaxTime)
         time -= 10; // Keep always at least 10 millisecs on the clock
 
     return std::max(0, time);
@@ -109,9 +105,11 @@ void TimeManagement::init(Search::LimitsType& limits, Color us, int ply)
       limits.npmsec = npmsec;
   }
 
+  int moveNum = (ply + 1) / 2;
+
   startTime = limits.startTime;
   optimumTime = remaining(limits.time[us], limits.inc[us], moveOverhead,
-                          limits.movestogo, ply, ponder, OptimumTime);
+                          limits.movestogo, moveNum, ponder, OptimumTime);
   maximumTime = remaining(limits.time[us], limits.inc[us], moveOverhead,
-                          limits.movestogo, ply, ponder, MaxTime);
+                          limits.movestogo, moveNum, ponder, MaxTime);
 }