Rename FromTo -> History (#963)

Previously, we had duplicated History:

- one with (piece,to) called History
- one with (from,to) called FromTo

Now that we have only one, rename it to History, which is the generally accepted
name in the chess programming litterature for this technique.

Also correct some comments that had not been updated since the introduction of CMH.

No functional change.

diff --git a/src/movepick.cpp b/src/movepick.cpp
index 08dabe0a1eedb51af077cef8677da3a3a5938b2a..afea0fa4d5d720949d591f7c4b663546aff9722c 100644 (file)
--- a/src/movepick.cpp
+++ b/src/movepick.cpp
@@ -140,7 +140,7 @@ void MovePicker::score<CAPTURES>() {
 template<>
 void MovePicker::score<QUIETS>() {
 
-  const FromToStats& fromTo = pos.this_thread()->fromTo;
+  const HistoryStats& history = pos.this_thread()->history;
 
   const CounterMoveStats* cmh = (ss-1)->counterMoves;
   const CounterMoveStats* fmh = (ss-2)->counterMoves;
@@ -152,21 +152,21 @@ void MovePicker::score<QUIETS>() {
       m.value =  (cmh  ?  (*cmh)[pos.moved_piece(m)][to_sq(m)] : VALUE_ZERO)
                + (fmh  ?  (*fmh)[pos.moved_piece(m)][to_sq(m)] : VALUE_ZERO)
                + (fmh2 ? (*fmh2)[pos.moved_piece(m)][to_sq(m)] : VALUE_ZERO)
-               + fromTo.get(c, m);
+               + history.get(c, m);
 }
 
 template<>
 void MovePicker::score<EVASIONS>() {
   // Try captures ordered by MVV/LVA, then non-captures ordered by stats heuristics
-  const FromToStats& fromTo = pos.this_thread()->fromTo;
+  const HistoryStats& history = pos.this_thread()->history;
   Color c = pos.side_to_move();
 
   for (auto& m : *this)
       if (pos.capture(m))
           m.value =  PieceValue[MG][pos.piece_on(to_sq(m))]
-                   - Value(type_of(pos.moved_piece(m))) + FromToStats::Max;
+                   - Value(type_of(pos.moved_piece(m))) + HistoryStats::Max;
       else
-          m.value = fromTo.get(c, m);
+          m.value = history.get(c, m);
 }
 
 

diff --git a/src/movepick.h b/src/movepick.h
index b59b0e93ba33a469419a9dbbfab8ecbad3eb6c6b..6c8d9e10e3d9e05453d34424f123c47103b56b35 100644 (file)
--- a/src/movepick.h
+++ b/src/movepick.h
@@ -29,13 +29,37 @@
 #include "types.h"
 
 
-/// The Stats struct stores moves statistics. According to the template parameter
-/// the class can store History and Countermoves. History records how often
-/// different moves have been successful or unsuccessful during the current search
-/// and is used for reduction and move ordering decisions.
-/// Countermoves store the move that refute a previous one. Entries are stored
-/// using only the moving piece and destination square, hence two moves with
-/// different origin but same destination and piece will be considered identical.
+/// HistoryStats records how often quiet moves have been successful or unsuccessful
+/// during the current search, and is used for reduction and move ordering decisions.
+struct HistoryStats {
+
+  static const Value Max = Value(1 << 28);
+
+  Value get(Color c, Move m) const { return table[c][from_sq(m)][to_sq(m)]; }
+  void clear() { std::memset(table, 0, sizeof(table)); }
+  void update(Color c, Move m, Value v) {
+
+    if (abs(int(v)) >= 324)
+        return;
+
+    Square from = from_sq(m);
+    Square to = to_sq(m);
+
+    table[c][from][to] -= table[c][from][to] * abs(int(v)) / 324;
+    table[c][from][to] += int(v) * 32;
+  }
+
+private:
+  Value table[COLOR_NB][SQUARE_NB][SQUARE_NB];
+};
+
+
+/// A template struct, used to generate MoveStats and CounterMoveHistoryStats:
+/// MoveStats store the move that refute a previous one.
+/// CounterMoveHistoryStats is like HistoryStats, but with two consecutive moves.
+/// Entries are stored using only the moving piece and destination square, hence
+/// two moves with different origin but same destination and piece will be
+/// considered identical.
 template<typename T, bool CM = false>
 struct Stats {
   const T* operator[](Piece pc) const { return table[pc]; }
@@ -59,28 +83,6 @@ typedef Stats<Move> MoveStats;
 typedef Stats<Value, true> CounterMoveStats;
 typedef Stats<CounterMoveStats> CounterMoveHistoryStats;
 
-struct FromToStats {
-
-  static const Value Max = Value(1 << 28);
-
-  Value get(Color c, Move m) const { return table[c][from_sq(m)][to_sq(m)]; }
-  void clear() { std::memset(table, 0, sizeof(table)); }
-  void update(Color c, Move m, Value v) {
-
-    if (abs(int(v)) >= 324)
-        return;
-
-    Square from = from_sq(m);
-    Square to = to_sq(m);
-
-    table[c][from][to] -= table[c][from][to] * abs(int(v)) / 324;
-    table[c][from][to] += int(v) * 32;
-  }
-
-private:
-  Value table[COLOR_NB][SQUARE_NB][SQUARE_NB];
-};
-
 
 /// MovePicker class is used to pick one pseudo legal move at a time from the
 /// current position. The most important method is next_move(), which returns a

diff --git a/src/search.cpp b/src/search.cpp
index c54c1269089ed9237558f4adb18595573235b4ea..fd38671e3b0c53d8f653b446e3c1cf1c8f7158aa 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -212,7 +212,7 @@ void Search::clear() {
   for (Thread* th : Threads)
   {
       th->counterMoves.clear();
-      th->fromTo.clear();
+      th->history.clear();
       th->counterMoveHistory.clear();
       th->resetCalls = true;
   }
@@ -985,7 +985,7 @@ moves_loop: // When in check search starts from here
               ss->history =  (cmh  ? (*cmh )[moved_piece][to_sq(move)] : VALUE_ZERO)
                            + (fmh  ? (*fmh )[moved_piece][to_sq(move)] : VALUE_ZERO)
                            + (fmh2 ? (*fmh2)[moved_piece][to_sq(move)] : VALUE_ZERO)
-                           + thisThread->fromTo.get(~pos.side_to_move(), move)
+                           + thisThread->history.get(~pos.side_to_move(), move)
                            - 8000; // Correction factor
 
               // Decrease/increase reduction by comparing opponent's stat score
@@ -1415,7 +1415,7 @@ moves_loop: // When in check search starts from here
 
     Color c = pos.side_to_move();
     Thread* thisThread = pos.this_thread();
-    thisThread->fromTo.update(c, move, bonus);
+    thisThread->history.update(c, move, bonus);
     update_cm_stats(ss, pos.moved_piece(move), to_sq(move), bonus);
 
     if ((ss-1)->counterMoves)
@@ -1427,7 +1427,7 @@ moves_loop: // When in check search starts from here
     // Decrease all the other played quiet moves
     for (int i = 0; i < quietsCnt; ++i)
     {
-        thisThread->fromTo.update(c, quiets[i], -bonus);
+        thisThread->history.update(c, quiets[i], -bonus);
         update_cm_stats(ss, pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus);
     }
   }

diff --git a/src/thread.h b/src/thread.h
index a4d78571c8bd2bbbc2ebc247bbfabcf0eadd0b33..3cbd22d63ecfa4c92e470d15c72215df78057b75 100644 (file)
--- a/src/thread.h
+++ b/src/thread.h
@@ -70,7 +70,7 @@ public:
   Depth completedDepth;
   std::atomic_bool resetCalls;
   MoveStats counterMoves;
-  FromToStats fromTo;
+  HistoryStats history;
   CounterMoveHistoryStats counterMoveHistory;
 };