Merge Connected and Candidate

These two notions are very correlated. Since connected has the most
generality, it makes sense to generalize it to encompass what is
covered by candidate.

STC:
LLR: 4.03 (-2.94,2.94) [-3.00,1.00]
Total: 11970 W: 2577 L: 2379 D: 7014

LTC:
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 13194 W: 2389 L: 2255 D: 8550

bench 7328585

diff --git a/src/evaluate.cpp b/src/evaluate.cpp
index ae52d203ffc0b565b317aa1d945de1bd468b71b3..69df7629b881f1ce9e197d4b3b1695a7437379a6 100644 (file)
--- a/src/evaluate.cpp
+++ b/src/evaluate.cpp
@@ -626,13 +626,13 @@ namespace {
   }
 
 
-  // evaluate_unstoppable_pawns() scores the most advanced among the passed and
-  // candidate pawns. In case both players have no pieces but pawns, this is
-  // somewhat related to the possibility that pawns are unstoppable.
+  // evaluate_unstoppable_pawns() scores the most advanced passed pawn. In case
+  // both players have no pieces but pawns, this is somewhat related to the
+  // possibility that pawns are unstoppable.
 
   Score evaluate_unstoppable_pawns(Color us, const EvalInfo& ei) {
 
-    Bitboard b = ei.pi->passed_pawns(us) | ei.pi->candidate_pawns(us);
+    Bitboard b = ei.pi->passed_pawns(us);
 
     return b ? Unstoppable * int(relative_rank(us, frontmost_sq(us, b))) : SCORE_ZERO;
   }

diff --git a/src/main.cpp b/src/main.cpp
index cbb260f26d9f0289785e712a22cb075d158480e6..f2d268147a733152df38b090868fa12a7fb92c4c 100644 (file)
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -36,7 +36,6 @@ int main(int argc, char* argv[]) {
   Position::init();
   Bitbases::init_kpk();
   Search::init();
-  Pawns::init();
   Eval::init();
   Threads.init();
   TT.resize(Options["Hash"]);

diff --git a/src/pawns.cpp b/src/pawns.cpp
index 401977bdf52980975576ece727f5fe824140bc4d..4693e1584f5b2161573fd42ff19643791feeef20 100644 (file)
--- a/src/pawns.cpp
+++ b/src/pawns.cpp
@@ -49,13 +49,8 @@ namespace {
   { S(20, 28), S(29, 31), S(33, 31), S(33, 31),
     S(33, 31), S(33, 31), S(29, 31), S(20, 28) } };
 
-  // Connected pawn bonus by file and rank (initialized by formula)
-  Score Connected[FILE_NB][RANK_NB];
-
-  // Candidate passed pawn bonus by rank
-  const Score CandidatePassed[RANK_NB] = {
-    S( 0, 0), S( 6, 13), S(6,13), S(14,29),
-    S(34,68), S(83,166), S(0, 0), S( 0, 0) };
+  // Connected bonus by rank
+  const int Connected[RANK_NB] = {0, 6, 15, 10, 57, 75, 135, 258};
 
   // Levers bonus by rank
   const Score Lever[RANK_NB] = {
@@ -96,8 +91,7 @@ namespace {
 
     Bitboard b, p, doubled;
     Square s;
-    File f;
-    bool passed, isolated, opposed, connected, backward, candidate, unsupported, lever;
+    bool passed, isolated, opposed, connected, backward, unsupported, lever;
     Score value = SCORE_ZERO;
     const Square* pl = pos.list<PAWN>(Us);
     const Bitboard* pawnAttacksBB = StepAttacksBB[make_piece(Us, PAWN)];
@@ -105,7 +99,7 @@ namespace {
     Bitboard ourPawns   = pos.pieces(Us  , PAWN);
     Bitboard theirPawns = pos.pieces(Them, PAWN);
 
-    e->passedPawns[Us] = e->candidatePawns[Us] = 0;
+    e->passedPawns[Us] = 0;
     e->kingSquares[Us] = SQ_NONE;
     e->semiopenFiles[Us] = 0xFF;
     e->pawnAttacks[Us] = shift_bb<Right>(ourPawns) | shift_bb<Left>(ourPawns);
@@ -117,7 +111,8 @@ namespace {
     {
         assert(pos.piece_on(s) == make_piece(Us, PAWN));
 
-        f = file_of(s);
+        Rank r = rank_of(s), rr = relative_rank(Us, s);
+        File f = file_of(s);
 
         // This file cannot be semi-open
         e->semiopenFiles[Us] &= ~(1 << f);
@@ -162,14 +157,6 @@ namespace {
 
         assert(opposed | passed | (pawn_attack_span(Us, s) & theirPawns));
 
-        // A not-passed pawn is a candidate to become passed, if it is free to
-        // advance and if the number of friendly pawns beside or behind this
-        // pawn on adjacent files is higher than or equal to the number of
-        // enemy pawns in the forward direction on the adjacent files.
-        candidate =   !(opposed | passed | backward | isolated)
-                   && (b = pawn_attack_span(Them, s + pawn_push(Us)) & ourPawns) != 0
-                   &&  popcount<Max15>(b) >= popcount<Max15>(pawn_attack_span(Us, s) & theirPawns);
-
         // Passed pawns will be properly scored in evaluation because we need
         // full attack info to evaluate passed pawns. Only the frontmost passed
         // pawn on each file is considered a true passed pawn.
@@ -189,19 +176,15 @@ namespace {
         if (backward)
             value -= Backward[opposed][f];
 
-        if (connected)
-            value += Connected[f][relative_rank(Us, s)];
+        if (connected) {
+            int bonus = Connected[rr];
+            if (ourPawns & adjacent_files_bb(f) & rank_bb(r))
+                bonus += (Connected[rr+1] - Connected[rr]) / 2;
+            value += make_score(bonus / 2, bonus >> opposed);
+        }
 
         if (lever)
-            value += Lever[relative_rank(Us, s)];
-
-        if (candidate)
-        {
-            value += CandidatePassed[relative_rank(Us, s)];
-
-            if (!doubled)
-                e->candidatePawns[Us] |= s;
-        }
+            value += Lever[rr];
     }
 
     b = e->semiopenFiles[Us] ^ 0xFF;
@@ -218,21 +201,6 @@ namespace {
 
 namespace Pawns {
 
-/// init() initializes some tables by formula instead of hard-coding their values
-
-void init() {
-
-  const int bonusByFile[] = { 1, 3, 3, 4, 4, 3, 3, 1 };
-
-  for (Rank r = RANK_1; r < RANK_8; ++r)
-      for (File f = FILE_A; f <= FILE_H; ++f)
-      {
-          int bonus = r * (r - 1) * (r - 2) + bonusByFile[f] * (r / 2 + 1);
-          Connected[f][r] = make_score(bonus, bonus);
-      }
-}
-
-
 /// probe() takes a position as input, computes a Entry object, and returns a
 /// pointer to it. The result is also stored in a hash table, so we don't have
 /// to recompute everything when the same pawn structure occurs again.

diff --git a/src/pawns.h b/src/pawns.h
index 6124246229696291b3cfa162ba7cc1f87e83c374..f24fb75ad3b8d9c2511492c72698e8de59562c2a 100644 (file)
--- a/src/pawns.h
+++ b/src/pawns.h
@@ -35,7 +35,6 @@ struct Entry {
   Score pawns_value() const { return value; }
   Bitboard pawn_attacks(Color c) const { return pawnAttacks[c]; }
   Bitboard passed_pawns(Color c) const { return passedPawns[c]; }
-  Bitboard candidate_pawns(Color c) const { return candidatePawns[c]; }
 
   int semiopen_file(Color c, File f) const {
     return semiopenFiles[c] & (1 << f);
@@ -68,7 +67,6 @@ struct Entry {
   Key key;
   Score value;
   Bitboard passedPawns[COLOR_NB];
-  Bitboard candidatePawns[COLOR_NB];
   Bitboard pawnAttacks[COLOR_NB];
   Square kingSquares[COLOR_NB];
   Score kingSafety[COLOR_NB];
@@ -81,7 +79,6 @@ struct Entry {
 
 typedef HashTable<Entry, 16384> Table;
 
-void init();
 Entry* probe(const Position& pos, Table& entries);
 
 } // namespace Pawns