Rename Materials and Pawns hash stuff

[stockfish] / src / pawns.cpp

diff --git a/src/pawns.cpp b/src/pawns.cpp
index 680ff198918ecc6c49471d64dff483d77f12d67f..f2e0c4c30fe4301b8c1e3fd64adea98f74154321 100644 (file)
--- a/src/pawns.cpp
+++ b/src/pawns.cpp
@@ -80,23 +80,18 @@ namespace {
 
   #undef S
   #undef V
-
-  inline Score apply_weight(Score v, Score w) {
-    return make_score((int(mg_value(v)) * mg_value(w)) / 0x100,
-                      (int(eg_value(v)) * eg_value(w)) / 0x100);
-  }
 }
 
 
-/// PawnInfoTable::pawn_info() takes a position object as input, computes
-/// a PawnInfo object, and returns a pointer to it. The result is also stored
-/// in an hash table, so we don't have to recompute everything when the same
-/// pawn structure occurs again.
+/// PawnTable::probe() takes a position object as input, computes a PawnEntry
+/// 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.
 
-PawnInfo* PawnInfoTable::pawn_info(const Position& pos) const {
+PawnEntry* PawnTable::probe(const Position& pos) const {
 
   Key key = pos.pawn_key();
-  PawnInfo* pi = probe(key);
+  PawnEntry* pi = Base::probe(key);
 
   // If pi->key matches the position's pawn hash key, it means that we
   // have analysed this pawn structure before, and we can simply return
@@ -104,19 +99,16 @@ PawnInfo* PawnInfoTable::pawn_info(const Position& pos) const {
   if (pi->key == key)
       return pi;
 
-  // Initialize PawnInfo entry
   pi->key = key;
   pi->passedPawns[WHITE] = pi->passedPawns[BLACK] = 0;
   pi->kingSquares[WHITE] = pi->kingSquares[BLACK] = SQ_NONE;
   pi->halfOpenFiles[WHITE] = pi->halfOpenFiles[BLACK] = 0xFF;
 
-  // Calculate pawn attacks
   Bitboard wPawns = pos.pieces(PAWN, WHITE);
   Bitboard bPawns = pos.pieces(PAWN, BLACK);
-  pi->pawnAttacks[WHITE] = ((wPawns << 9) & ~FileABB) | ((wPawns << 7) & ~FileHBB);
-  pi->pawnAttacks[BLACK] = ((bPawns >> 7) & ~FileABB) | ((bPawns >> 9) & ~FileHBB);
+  pi->pawnAttacks[WHITE] = ((wPawns & ~FileHBB) << 9) | ((wPawns & ~FileABB) << 7);
+  pi->pawnAttacks[BLACK] = ((bPawns & ~FileHBB) >> 7) | ((bPawns & ~FileABB) >> 9);
 
-  // Evaluate pawns for both colors and weight the result
   pi->value =  evaluate_pawns<WHITE>(pos, wPawns, bPawns, pi)
              - evaluate_pawns<BLACK>(pos, bPawns, wPawns, pi);
 
@@ -126,11 +118,11 @@ PawnInfo* PawnInfoTable::pawn_info(const Position& pos) const {
 }
 
 
-/// PawnInfoTable::evaluate_pawns() evaluates each pawn of the given color
+/// PawnTable::evaluate_pawns() evaluates each pawn of the given color
 
 template<Color Us>
-Score PawnInfoTable::evaluate_pawns(const Position& pos, Bitboard ourPawns,
-                                    Bitboard theirPawns, PawnInfo* pi) {
+Score PawnTable::evaluate_pawns(const Position& pos, Bitboard ourPawns,
+                                    Bitboard theirPawns, PawnEntry* pi) {
 
   const Color Them = (Us == WHITE ? BLACK : WHITE);
 
@@ -158,11 +150,11 @@ Score PawnInfoTable::evaluate_pawns(const Position& pos, Bitboard ourPawns,
 
       // Flag the pawn as passed, isolated, doubled or member of a pawn
       // chain (but not the backward one).
-      passed   = !(theirPawns & passed_pawn_mask(Us, s));
+      chain    =   ourPawns   & adjacent_files_bb(f) & b;
+      isolated = !(ourPawns   & adjacent_files_bb(f));
       doubled  =   ourPawns   & squares_in_front_of(Us, s);
       opposed  =   theirPawns & squares_in_front_of(Us, s);
-      isolated = !(ourPawns   & adjacent_files_bb(f));
-      chain    =   ourPawns   & adjacent_files_bb(f) & b;
+      passed   = !(theirPawns & passed_pawn_mask(Us, s));
 
       // Test for backward pawn
       backward = false;
@@ -222,15 +214,16 @@ Score PawnInfoTable::evaluate_pawns(const Position& pos, Bitboard ourPawns,
       if (candidate)
           value += CandidateBonus[relative_rank(Us, s)];
   }
+
   return value;
 }
 
 
-/// PawnInfo::shelter_storm() calculates shelter and storm penalties for the file
+/// PawnEntry::shelter_storm() calculates shelter and storm penalties for the file
 /// the king is on, as well as the two adjacent files.
 
 template<Color Us>
-Value PawnInfo::shelter_storm(const Position& pos, Square ksq) {
+Value PawnEntry::shelter_storm(const Position& pos, Square ksq) {
 
   const Color Them = (Us == WHITE ? BLACK : WHITE);
 
@@ -260,16 +253,16 @@ Value PawnInfo::shelter_storm(const Position& pos, Square ksq) {
 }
 
 
-/// PawnInfo::update_safety() calculates and caches a bonus for king safety. It is
+/// PawnEntry::update_safety() calculates and caches a bonus for king safety. It is
 /// called only when king square changes, about 20% of total king_safety() calls.
 
 template<Color Us>
-Score PawnInfo::update_safety(const Position& pos, Square ksq) {
+Score PawnEntry::update_safety(const Position& pos, Square ksq) {
 
   kingSquares[Us] = ksq;
 
   if (relative_rank(Us, ksq) > RANK_4)
-      return kingShelters[Us] = SCORE_ZERO;
+      return kingSafety[Us] = SCORE_ZERO;
 
   Value bonus = shelter_storm<Us>(pos, ksq);
 
@@ -280,9 +273,9 @@ Score PawnInfo::update_safety(const Position& pos, Square ksq) {
   if (pos.can_castle(Us == WHITE ? WHITE_OOO : BLACK_OOO))
       bonus = std::max(bonus, shelter_storm<Us>(pos, relative_square(Us, SQ_C1)));
 
-  return kingShelters[Us] = make_score(bonus, 0);
+  return kingSafety[Us] = make_score(bonus, 0);
 }
 
 // Explicit template instantiation
-template Score PawnInfo::update_safety<WHITE>(const Position& pos, Square ksq);
-template Score PawnInfo::update_safety<BLACK>(const Position& pos, Square ksq);
+template Score PawnEntry::update_safety<WHITE>(const Position& pos, Square ksq);
+template Score PawnEntry::update_safety<BLACK>(const Position& pos, Square ksq);