Introduce ratio operation

Just like in Physics, the ratio of 2 things in the same unit, should be
without unit.

Example use case:
- Ratio of a Depth by a Depth (eg. ONE_PLY) should be an int.
- Ratio of a Value by a Value (eg. PawnValueEg) should be an int.

Remove a bunch of useless const while there.

No functional change.

Resolves #128

diff --git a/src/search.cpp b/src/search.cpp
index 711680818a2ba4cbb61c7ee3a8d25338a34af07f..0901187acee2af63bebbc120bed03e33948962da 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -112,7 +112,7 @@ namespace {
     }
 
     size_t candidates_size() const { return candidates; }
     }
 
     size_t candidates_size() const { return candidates; }

-    bool time_to_pick(Depth depth) const { return depth == 1 + level; }
+    bool time_to_pick(Depth depth) const { return depth / ONE_PLY == 1 + level; }

     Move pick_move();
 
     int level;
     Move pick_move();
 
     int level;


@@ -660,7 +660,7 @@ namespace {
         assert(eval - beta >= 0);
 
         // Null move dynamic reduction based on depth and value
         assert(eval - beta >= 0);
 
         // Null move dynamic reduction based on depth and value

-        Depth R = (3 + depth / 4 + std::min(int(eval - beta) / PawnValueMg, 3)) * ONE_PLY;
+        Depth R = (3 + depth / 4 + std::min((eval - beta) / PawnValueMg, 3)) * ONE_PLY;

 
         pos.do_null_move(st);
         (ss+1)->skipNullMove = true;
 
         pos.do_null_move(st);
         (ss+1)->skipNullMove = true;


@@ -793,7 +793,7 @@ moves_loop: // When in check and at SpNode search starts from here
           Signals.firstRootMove = (moveCount == 1);
 
           if (thisThread == Threads.main() && Time::now() - SearchTime > 3000)
           Signals.firstRootMove = (moveCount == 1);
 
           if (thisThread == Threads.main() && Time::now() - SearchTime > 3000)

-              sync_cout << "info depth " << depth
+              sync_cout << "info depth " << depth / ONE_PLY

                         << " currmove " << UCI::format_move(move, pos.is_chess960())
                         << " currmovenumber " << moveCount + PVIdx << sync_endl;
       }
                         << " currmove " << UCI::format_move(move, pos.is_chess960())
                         << " currmovenumber " << moveCount + PVIdx << sync_endl;
       }


@@ -826,7 +826,7 @@ moves_loop: // When in check and at SpNode search starts from here
           && !ext
           &&  pos.legal(move, ci.pinned))
       {
           && !ext
           &&  pos.legal(move, ci.pinned))
       {

-          Value rBeta = ttValue - int(2 * depth);
+          Value rBeta = ttValue - 2 * depth / ONE_PLY;

           ss->excludedMove = move;
           ss->skipNullMove = true;
           value = search<NonPV, false>(pos, ss, rBeta - 1, rBeta, depth / 2, cutNode);
           ss->excludedMove = move;
           ss->skipNullMove = true;
           value = search<NonPV, false>(pos, ss, rBeta - 1, rBeta, depth / 2, cutNode);


@@ -1362,7 +1362,7 @@ moves_loop: // When in check and at SpNode search starts from here
 
     // Increase history value of the cut-off move and decrease all the other
     // played quiet moves.
 
     // Increase history value of the cut-off move and decrease all the other
     // played quiet moves.

-    Value bonus = Value(int(depth) * int(depth));
+    Value bonus = Value((depth / ONE_PLY) * (depth / ONE_PLY));

     History.update(pos.moved_piece(move), to_sq(move), bonus);
     for (int i = 0; i < quietsCnt; ++i)
     {
     History.update(pos.moved_piece(move), to_sq(move), bonus);
     for (int i = 0; i < quietsCnt; ++i)
     {


@@ -1445,7 +1445,7 @@ moves_loop: // When in check and at SpNode search starts from here
     {
         bool updated = (i <= PVIdx);
 
     {
         bool updated = (i <= PVIdx);
 

-        if (depth == 1 && !updated)
+        if (depth == ONE_PLY && !updated)

             continue;
 
         Depth d = updated ? depth : depth - ONE_PLY;
             continue;
 
         Depth d = updated ? depth : depth - ONE_PLY;

diff --git a/src/types.h b/src/types.h
index 43f2d4e756521ecdf15b439747865277aa2aa9f5..3cfaa072ae5f2bf71f0693c7e9d998d0135226e4 100644 (file)
--- a/src/types.h
+++ b/src/types.h
@@ -275,23 +275,24 @@ inline Value eg_value(Score s) {
   return Value((int)(unsigned(s) & 0x7FFFU) - (int)(unsigned(s) & 0x8000U));
 }
 
   return Value((int)(unsigned(s) & 0x7FFFU) - (int)(unsigned(s) & 0x8000U));
 }
 

-#define ENABLE_BASE_OPERATORS_ON(T)                                         \
-inline T operator+(const T d1, const T d2) { return T(int(d1) + int(d2)); } \
-inline T operator-(const T d1, const T d2) { return T(int(d1) - int(d2)); } \
-inline T operator*(int i, const T d) { return T(i * int(d)); }              \
-inline T operator*(const T d, int i) { return T(int(d) * i); }              \
-inline T operator-(const T d) { return T(-int(d)); }                        \
-inline T& operator+=(T& d1, const T d2) { return d1 = d1 + d2; }            \
-inline T& operator-=(T& d1, const T d2) { return d1 = d1 - d2; }            \
+#define ENABLE_BASE_OPERATORS_ON(T)                             \
+inline T operator+(T d1, T d2) { return T(int(d1) + int(d2)); } \
+inline T operator-(T d1, T d2) { return T(int(d1) - int(d2)); } \
+inline T operator*(int i, T d) { return T(i * int(d)); }        \
+inline T operator*(T d, int i) { return T(int(d) * i); }        \
+inline T operator-(T d) { return T(-int(d)); }                  \
+inline T& operator+=(T& d1, T d2) { return d1 = d1 + d2; }      \
+inline T& operator-=(T& d1, T d2) { return d1 = d1 - d2; }      \

 inline T& operator*=(T& d, int i) { return d = T(int(d) * i); }
 
 ENABLE_BASE_OPERATORS_ON(Score)
 
 inline T& operator*=(T& d, int i) { return d = T(int(d) * i); }
 
 ENABLE_BASE_OPERATORS_ON(Score)
 

-#define ENABLE_FULL_OPERATORS_ON(T)                                         \
-ENABLE_BASE_OPERATORS_ON(T)                                                 \
-inline T& operator++(T& d) { return d = T(int(d) + 1); }                    \
-inline T& operator--(T& d) { return d = T(int(d) - 1); }                    \
-inline T operator/(const T d, int i) { return T(int(d) / i); }              \
+#define ENABLE_FULL_OPERATORS_ON(T)                             \
+ENABLE_BASE_OPERATORS_ON(T)                                     \
+inline T& operator++(T& d) { return d = T(int(d) + 1); }        \
+inline T& operator--(T& d) { return d = T(int(d) - 1); }        \
+inline T operator/(T d, int i) { return T(int(d) / i); }        \
+inline int operator/(T d1, T d2) { return int(d1) / int(d2); }  \

 inline T& operator/=(T& d, int i) { return d = T(int(d) / i); }
 
 ENABLE_FULL_OPERATORS_ON(Value)
 inline T& operator/=(T& d, int i) { return d = T(int(d) / i); }
 
 ENABLE_FULL_OPERATORS_ON(Value)