Rename ValueType to Bound
authorMarco Costalba <mcostalba@gmail.com>
Fri, 27 Jan 2012 18:47:56 +0000 (19:47 +0100)
committerMarco Costalba <mcostalba@gmail.com>
Fri, 27 Jan 2012 18:49:38 +0000 (19:49 +0100)
It is a more conventional and common naming.

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
src/search.cpp
src/tt.cpp
src/tt.h
src/types.h

index 6f3d6df2fcfb65e690c3a585ad2100ba003c3bcd..36bd0869301327d5cba8130e20ff824f4eeb246c 100644 (file)
@@ -554,7 +554,7 @@ namespace {
     Key posKey;
     Move ttMove, move, excludedMove, threatMove;
     Depth ext, newDepth;
-    ValueType vt;
+    Bound bt;
     Value bestValue, value, oldAlpha;
     Value refinedValue, nullValue, futilityBase, futilityValue;
     bool isPvMove, inCheck, singularExtensionNode, givesCheck;
@@ -630,7 +630,7 @@ namespace {
     // a fail high/low. Biggest advantage at probing at PV nodes is to have a
     // smooth experience in analysis mode. We don't probe at Root nodes otherwise
     // we should also update RootMoveList to avoid bogus output.
-    if (!RootNode && tte && (PvNode ? tte->depth() >= depth && tte->type() == VALUE_TYPE_EXACT
+    if (!RootNode && tte && (PvNode ? tte->depth() >= depth && tte->type() == BOUND_EXACT
                                     : can_return_tt(tte, depth, beta, ss->ply)))
     {
         TT.refresh(tte);
@@ -662,7 +662,7 @@ namespace {
     else
     {
         refinedValue = ss->eval = evaluate(pos, ss->evalMargin);
-        TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, ss->evalMargin);
+        TT.store(posKey, VALUE_NONE, BOUND_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, ss->evalMargin);
     }
 
     // Update gain for the parent non-capture move given the static position
@@ -824,7 +824,7 @@ split_point_start: // At split points actual search starts from here
                            && depth >= SingularExtensionDepth[PvNode]
                            && ttMove != MOVE_NONE
                            && !excludedMove // Recursive singular search is not allowed
-                           && (tte->type() & VALUE_TYPE_LOWER)
+                           && (tte->type() & BOUND_LOWER)
                            && tte->depth() >= depth - 3 * ONE_PLY;
 
     // Step 11. Loop through moves
@@ -1098,10 +1098,10 @@ split_point_start: // At split points actual search starts from here
     if (!SpNode && !Signals.stop && !thread.cutoff_occurred())
     {
         move = bestValue <= oldAlpha ? MOVE_NONE : ss->bestMove;
-        vt   = bestValue <= oldAlpha ? VALUE_TYPE_UPPER
-             : bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT;
+        bt   = bestValue <= oldAlpha ? BOUND_UPPER
+             : bestValue >= beta ? BOUND_LOWER : BOUND_EXACT;
 
-        TT.store(posKey, value_to_tt(bestValue, ss->ply), vt, depth, move, ss->eval, ss->evalMargin);
+        TT.store(posKey, value_to_tt(bestValue, ss->ply), bt, depth, move, ss->eval, ss->evalMargin);
 
         // Update killers and history for non capture cut-off moves
         if (    bestValue >= beta
@@ -1154,7 +1154,7 @@ split_point_start: // At split points actual search starts from here
     bool inCheck, enoughMaterial, givesCheck, evasionPrunable;
     const TTEntry* tte;
     Depth ttDepth;
-    ValueType vt;
+    Bound bt;
     Value oldAlpha = alpha;
 
     ss->bestMove = ss->currentMove = MOVE_NONE;
@@ -1204,7 +1204,7 @@ split_point_start: // At split points actual search starts from here
         if (bestValue >= beta)
         {
             if (!tte)
-                TT.store(pos.key(), value_to_tt(bestValue, ss->ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, evalMargin);
+                TT.store(pos.key(), value_to_tt(bestValue, ss->ply), BOUND_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, evalMargin);
 
             return bestValue;
         }
@@ -1322,10 +1322,10 @@ split_point_start: // At split points actual search starts from here
 
     // Update transposition table
     move = bestValue <= oldAlpha ? MOVE_NONE : ss->bestMove;
-    vt   = bestValue <= oldAlpha ? VALUE_TYPE_UPPER
-         : bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT;
+    bt   = bestValue <= oldAlpha ? BOUND_UPPER
+         : bestValue >= beta ? BOUND_LOWER : BOUND_EXACT;
 
-    TT.store(pos.key(), value_to_tt(bestValue, ss->ply), vt, ttDepth, move, ss->eval, evalMargin);
+    TT.store(pos.key(), value_to_tt(bestValue, ss->ply), bt, ttDepth, move, ss->eval, evalMargin);
 
     assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
 
@@ -1525,8 +1525,8 @@ split_point_start: // At split points actual search starts from here
               || v >= std::max(VALUE_MATE_IN_MAX_PLY, beta)
               || v < std::min(VALUE_MATED_IN_MAX_PLY, beta))
 
-          && (   ((tte->type() & VALUE_TYPE_LOWER) && v >= beta)
-              || ((tte->type() & VALUE_TYPE_UPPER) && v < beta));
+          && (   ((tte->type() & BOUND_LOWER) && v >= beta)
+              || ((tte->type() & BOUND_UPPER) && v < beta));
   }
 
 
@@ -1539,8 +1539,8 @@ split_point_start: // At split points actual search starts from here
 
       Value v = value_from_tt(tte->value(), ply);
 
-      if (   ((tte->type() & VALUE_TYPE_LOWER) && v >= defaultEval)
-          || ((tte->type() & VALUE_TYPE_UPPER) && v < defaultEval))
+      if (   ((tte->type() & BOUND_LOWER) && v >= defaultEval)
+          || ((tte->type() & BOUND_UPPER) && v < defaultEval))
           return v;
 
       return defaultEval;
@@ -1759,9 +1759,9 @@ split_point_start: // At split points actual search starts from here
 
 
 /// RootMove::extract_pv_from_tt() builds a PV by adding moves from the TT table.
-/// We consider also failing high nodes and not only VALUE_TYPE_EXACT nodes so
-/// to allow to always have a ponder move even when we fail high at root, and
-/// long PV to print that is important for position analysis.
+/// We consider also failing high nodes and not only BOUND_EXACT nodes so to
+/// allow to always have a ponder move even when we fail high at root, and a
+/// long PV to print that is important for position analysis.
 
 void RootMove::extract_pv_from_tt(Position& pos) {
 
@@ -1815,7 +1815,7 @@ void RootMove::insert_pv_in_tt(Position& pos) {
       if (!tte || tte->move() != pv[ply])
       {
           v = (pos.in_check() ? VALUE_NONE : evaluate(pos, m));
-          TT.store(k, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, pv[ply], v, m);
+          TT.store(k, VALUE_NONE, BOUND_NONE, DEPTH_NONE, pv[ply], v, m);
       }
       pos.do_move(pv[ply], *st++);
 
index fdded2a5610bf4c6e7b8a801c7776e952ec560ca..09a74d2d5936273b1a97d25358dd7c45ae63e5f4 100644 (file)
@@ -84,7 +84,7 @@ void TranspositionTable::clear() {
 /// more valuable than a TTEntry t2 if t1 is from the current search and t2 is from
 /// a previous search, or if the depth of t1 is bigger than the depth of t2.
 
-void TranspositionTable::store(const Key posKey, Value v, ValueType t, Depth d, Move m, Value statV, Value kingD) {
+void TranspositionTable::store(const Key posKey, Value v, Bound t, Depth d, Move m, Value statV, Value kingD) {
 
   int c1, c2, c3;
   TTEntry *tte, *replace;
@@ -106,7 +106,7 @@ void TranspositionTable::store(const Key posKey, Value v, ValueType t, Depth d,
 
       // Implement replace strategy
       c1 = (replace->generation() == generation ?  2 : 0);
-      c2 = (tte->generation() == generation || tte->type() == VALUE_TYPE_EXACT ? -2 : 0);
+      c2 = (tte->generation() == generation || tte->type() == BOUND_EXACT ? -2 : 0);
       c3 = (tte->depth() < replace->depth() ?  1 : 0);
 
       if (c1 + c2 + c3 > 0)
index 707bb0f0db19807d2cba0c4ee2d1b66afa8fff5e..39c161df1660575a8017e3e368337476b040c3e8 100644 (file)
--- a/src/tt.h
+++ b/src/tt.h
 class TTEntry {
 
 public:
-  void save(uint32_t k, Value v, ValueType t, Depth d, Move m, int g, Value statV, Value statM) {
+  void save(uint32_t k, Value v, Bound b, Depth d, Move m, int g, Value statV, Value statM) {
 
     key32        = (uint32_t)k;
     move16       = (uint16_t)m;
-    valueType    = (uint8_t)t;
+    bound        = (uint8_t)b;
     generation8  = (uint8_t)g;
     value16      = (int16_t)v;
     depth16      = (int16_t)d;
@@ -64,7 +64,7 @@ public:
   Depth depth() const               { return (Depth)depth16; }
   Move move() const                 { return (Move)move16; }
   Value value() const               { return (Value)value16; }
-  ValueType type() const            { return (ValueType)valueType; }
+  Bound type() const                { return (Bound)bound; }
   int generation() const            { return (int)generation8; }
   Value static_value() const        { return (Value)staticValue; }
   Value static_value_margin() const { return (Value)staticMargin; }
@@ -72,7 +72,7 @@ public:
 private:
   uint32_t key32;
   uint16_t move16;
-  uint8_t valueType, generation8;
+  uint8_t bound, generation8;
   int16_t value16, depth16, staticValue, staticMargin;
 };
 
@@ -103,7 +103,7 @@ public:
   ~TranspositionTable();
   void set_size(size_t mbSize);
   void clear();
-  void store(const Key posKey, Value v, ValueType type, Depth d, Move m, Value statV, Value kingD);
+  void store(const Key posKey, Value v, Bound type, Depth d, Move m, Value statV, Value kingD);
   TTEntry* probe(const Key posKey) const;
   void new_search();
   TTEntry* first_entry(const Key posKey) const;
index 8ce7dab55df09cc92a9ba14ebd2ef4c48de94fad..eaa9a25b56137a6e44716cdacdec4609d4d8ea78 100644 (file)
@@ -162,11 +162,11 @@ enum ScaleFactor {
   SCALE_FACTOR_NONE   = 255
 };
 
-enum ValueType {
-  VALUE_TYPE_NONE  = 0,
-  VALUE_TYPE_UPPER = 1,
-  VALUE_TYPE_LOWER = 2,
-  VALUE_TYPE_EXACT = VALUE_TYPE_UPPER | VALUE_TYPE_LOWER
+enum Bound {
+  BOUND_NONE  = 0,
+  BOUND_UPPER = 1,
+  BOUND_LOWER = 2,
+  BOUND_EXACT = BOUND_UPPER | BOUND_LOWER
 };
 
 enum Value {