X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fsearch.cpp;h=ee21915d149b43be8d459472d468d424155f27f5;hb=49b1c5dccd476229c06fd4a4b8dd94403c602396;hp=09b483cfc4143ec056b1ced25620245f9a925672;hpb=807844eab194adc7c5378575f81d28ce9ca66287;p=stockfish

diff --git a/src/search.cpp b/src/search.cpp
index 09b483cf..ee21915d 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -326,6 +326,13 @@ namespace {
 //// Functions
 ////
 
+//FIXME: HACK
+static double lnArray[512];
+
+inline double ln(int i)
+{
+    return lnArray[i];
+}
 
 /// perft() is our utility to verify move generation is bug free. All the legal
 /// moves up to given depth are generated and counted and the sum returned.
@@ -562,8 +569,14 @@ bool think(const Position& pos, bool infinite, bool ponder, int side_to_move,
 /// and initializes the split point stack and the global locks and condition
 /// objects.
 
+#include <cmath> //FIXME: HACK
+
 void init_threads() {
 
+  // FIXME: HACK!!
+  for (int i = 0; i < 512; i++)
+    lnArray[i] = log(double(i));
+
   volatile int i;
 
 #if !defined(_MSC_VER)
@@ -899,7 +912,7 @@ namespace {
         int64_t nodes;
         Move move;
         StateInfo st;
-        Depth ext, newDepth;
+        Depth depth, ext, newDepth;
 
         RootMoveNumber = i + 1;
         FailHigh = false;
@@ -922,8 +935,9 @@ namespace {
         bool moveIsCheck = pos.move_is_check(move);
         bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
         bool dangerous;
+        depth =  (Iteration - 2) * OnePly + InitialDepth;
         ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, false, false, &dangerous);
-        newDepth = (Iteration - 2) * OnePly + ext + InitialDepth;
+        newDepth = depth + ext;
 
         // Make the move, and search it
         pos.do_move(move, st, ci, moveIsCheck);
@@ -950,14 +964,19 @@ namespace {
         {
             // Try to reduce non-pv search depth by one ply if move seems not problematic,
             // if the move fails high will be re-searched at full depth.
-            if (   newDepth >= 3*OnePly
-                && i >= MultiPV + LMRPVMoves
+            if (   depth >= 3*OnePly // FIXME was newDepth
                 && !dangerous
                 && !captureOrPromotion
                 && !move_is_castle(move))
             {
-                ss[0].reduction = OnePly;
-                value = -search(pos, ss, -alpha, newDepth-OnePly, 1, true, 0);
+                double red = ln(RootMoveNumber - MultiPV + 1) * ln(depth / 2) / 3.0;
+                if (red >= 1.0)
+                {
+                    ss[0].reduction = Depth(int(floor(red * int(OnePly))));
+                    value = -search(pos, ss, -alpha, newDepth-ss[0].reduction, 1, true, 0);
+                }
+                else
+                    value = alpha + 1; // Just to trigger next condition
             } else
                 value = alpha + 1; // Just to trigger next condition
 
@@ -1202,14 +1221,19 @@ namespace {
         // Try to reduce non-pv search depth by one ply if move seems not problematic,
         // if the move fails high will be re-searched at full depth.
         if (    depth >= 3*OnePly
-            &&  moveCount >= LMRPVMoves
             && !dangerous
             && !captureOrPromotion
             && !move_is_castle(move)
             && !move_is_killer(move, ss[ply]))
         {
-            ss[ply].reduction = OnePly;
-            value = -search(pos, ss, -alpha, newDepth-OnePly, ply+1, true, threadID);
+          double red = ln(moveCount) * ln(depth / 2) / 3.0;
+          if (red >= 1.0)
+          {
+              ss[ply].reduction = Depth(int(floor(red * int(OnePly))));
+              value = -search(pos, ss, -alpha, newDepth-ss[ply].reduction, ply+1, true, threadID);
+          }
+          else
+              value = alpha + 1; // Just to trigger next condition
         }
         else
             value = alpha + 1; // Just to trigger next condition
@@ -1527,14 +1551,20 @@ namespace {
       // Try to reduce non-pv search depth by one ply if move seems not problematic,
       // if the move fails high will be re-searched at full depth.
       if (    depth >= 3*OnePly
-          &&  moveCount >= LMRNonPVMoves
           && !dangerous
           && !captureOrPromotion
           && !move_is_castle(move)
-          && !move_is_killer(move, ss[ply]))
+          && !move_is_killer(move, ss[ply])
+          /* && move != ttMove*/)
       {
-          ss[ply].reduction = OnePly;
-          value = -search(pos, ss, -(beta-1), newDepth-OnePly, ply+1, true, threadID);
+          double red = ln(moveCount) * ln(depth / 2) / 1.5;
+          if (red >= 1.0)
+          {
+              ss[ply].reduction = Depth(int(floor(red * int(OnePly))));
+              value = -search(pos, ss, -(beta-1), newDepth-ss[ply].reduction, ply+1, true, threadID);
+          }
+          else
+              value = beta; // Just to trigger next condition
       }
       else
           value = beta; // Just to trigger next condition
@@ -1868,13 +1898,18 @@ namespace {
       // Try to reduce non-pv search depth by one ply if move seems not problematic,
       // if the move fails high will be re-searched at full depth.
       if (   !dangerous
-          &&  moveCount >= LMRNonPVMoves
           && !captureOrPromotion
           && !move_is_castle(move)
           && !move_is_killer(move, ss[sp->ply]))
       {
-          ss[sp->ply].reduction = OnePly;
-          value = -search(pos, ss, -(sp->beta-1), newDepth - OnePly, sp->ply+1, true, threadID);
+          double red = ln(moveCount) * ln(sp->depth / 2) / 1.5;
+          if (red >= 1.0)
+          {
+              ss[sp->ply].reduction = Depth(int(floor(red * int(OnePly))));
+              value = -search(pos, ss, -(sp->beta-1), newDepth-ss[sp->ply].reduction, sp->ply+1, true, threadID);
+          }
+          else
+              value = sp->beta; // Just to trigger next condition
       }
       else
           value = sp->beta; // Just to trigger next condition
@@ -1974,13 +2009,18 @@ namespace {
       // Try to reduce non-pv search depth by one ply if move seems not problematic,
       // if the move fails high will be re-searched at full depth.
       if (   !dangerous
-          &&  moveCount >= LMRPVMoves
           && !captureOrPromotion
           && !move_is_castle(move)
           && !move_is_killer(move, ss[sp->ply]))
       {
-          ss[sp->ply].reduction = OnePly;
-          value = -search(pos, ss, -sp->alpha, newDepth - OnePly, sp->ply+1, true, threadID);
+          double red = ln(moveCount) * ln(sp->depth / 2) / 3.0;
+          if (red >= 1.0)
+          {
+              ss[sp->ply].reduction = Depth(int(floor(red * int(OnePly))));
+              value = -search(pos, ss, -sp->alpha, newDepth-ss[sp->ply].reduction, sp->ply+1, true, threadID);
+          }
+          else
+              value = sp->alpha + 1; // Just to trigger next condition
       }
       else
           value = sp->alpha + 1; // Just to trigger next condition