Introduce PieceSquareTable[16][64]

Instead of MgPieceSquareTable[16][64] and EgPieceSquareTable[16][64]

This allows to fetch mg and eg values from adjacent words in memory.

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>

diff --git a/src/movepick.cpp b/src/movepick.cpp
index b96b799542556a7f461e29d7b1472bf631689eab..ca99e46135e157a1f5637ca7e8407e3b8bf59dcd 100644 (file)
--- a/src/movepick.cpp
+++ b/src/movepick.cpp
@@ -221,7 +221,7 @@ void MovePicker::score_noncaptures() {
           hs += 1000;
 
       // pst based scoring
-      cur->score = hs + pos.pst_delta<Position::MidGame>(piece, from, to);
+      cur->score = hs + pos.pst_delta(piece, from, to).mg();
   }
 }
 

diff --git a/src/position.cpp b/src/position.cpp
index e7a0017cb033a8e4c15ce407ca1caeb9bb8e73a8..c43cde790a4cfd225b6ebcb3990bdf6aed81adcb 100644 (file)
--- a/src/position.cpp
+++ b/src/position.cpp
@@ -52,8 +52,7 @@ Key Position::zobCastle[16];
 Key Position::zobMaterial[2][8][16];
 Key Position::zobSideToMove;
 
-Value Position::MgPieceSquareTable[16][64];
-Value Position::EgPieceSquareTable[16][64];
+Score Position::PieceSquareTable[16][64];
 
 static bool RequestPending = false;
 
@@ -213,7 +212,7 @@ void Position::from_fen(const string& fen) {
   st->key = compute_key();
   st->pawnKey = compute_pawn_key();
   st->materialKey = compute_material_key();
-  st->value = Score(compute_value<MidGame>(), compute_value<EndGame>());
+  st->value = compute_value();
   st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
   st->npMaterial[BLACK] = compute_non_pawn_material(BLACK);
 }
@@ -829,7 +828,7 @@ void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
   }
 
   // Update incremental scores
-  st->value += Score(pst_delta<MidGame>(piece, from, to), pst_delta<EndGame>(piece, from, to));
+  st->value += pst_delta(piece, from, to);
 
   if (pm) // promotion ?
   {
@@ -864,8 +863,8 @@ void Position::do_move(Move m, StateInfo& newSt, Bitboard dcCandidates) {
       st->pawnKey ^= zobrist[us][PAWN][to];
 
       // Partially revert and update incremental scores
-      st->value -= Score(pst<MidGame>(us, PAWN, to), pst<EndGame>(us, PAWN, to));
-      st->value += Score(pst<MidGame>(us, promotion, to), pst<EndGame>(us, promotion, to));
+      st->value -= pst(us, PAWN, to);
+      st->value += pst(us, promotion, to);
 
       // Update material
       st->npMaterial[us] += piece_value_midgame(promotion);
@@ -931,7 +930,7 @@ void Position::do_capture_move(Bitboard& key, PieceType capture, Color them, Squ
     key ^= zobrist[them][capture][capsq];
 
     // Update incremental scores
-    st->value -= Score(pst<MidGame>(them, capture, capsq), pst<EndGame>(them, capture, capsq));
+    st->value -= pst(them, capture, capsq);
 
     // If the captured piece was a pawn, update pawn hash key,
     // otherwise update non-pawn material.
@@ -1028,8 +1027,8 @@ void Position::do_castle_move(Move m) {
   index[rto] = tmp;
 
   // Update incremental scores
-  st->value += Score(pst_delta<MidGame>(king, kfrom, kto), pst_delta<EndGame>(king, kfrom, kto));
-  st->value += Score(pst_delta<MidGame>(rook, rfrom, rto), pst_delta<EndGame>(rook, rfrom, rto));
+  st->value += pst_delta(king, kfrom, kto);
+  st->value += pst_delta(rook, rfrom, rto);
 
   // Update hash key
   st->key ^= zobrist[us][KING][kfrom] ^ zobrist[us][KING][kto];
@@ -1630,10 +1629,9 @@ Key Position::compute_material_key() const {
 /// game and the endgame. These functions are used to initialize the incremental
 /// scores when a new position is set up, and to verify that the scores are correctly
 /// updated by do_move and undo_move when the program is running in debug mode.
-template<Position::GamePhase Phase>
-Value Position::compute_value() const {
+Score Position::compute_value() const {
 
-  Value result = Value(0);
+  Score result(0, 0);
   Bitboard b;
   Square s;
 
@@ -1645,12 +1643,11 @@ Value Position::compute_value() const {
           {
               s = pop_1st_bit(&b);
               assert(piece_on(s) == piece_of_color_and_type(c, pt));
-              result += pst<Phase>(c, pt, s);
+              result += pst(c, pt, s);
           }
       }
 
-  const Value tv = (Phase == MidGame ? TempoValue.mg() : TempoValue.eg());
-  result += (side_to_move() == WHITE)? tv / 2 : -tv / 2;
+  result += (side_to_move() == WHITE)? TempoValue / 2 : -TempoValue / 2;
   return result;
 }
 
@@ -1799,16 +1796,12 @@ void Position::init_piece_square_tables() {
       for (Piece p = WP; p <= WK; p++)
       {
           i = (r == 0)? 0 : (genrand_int32() % (r*2) - r);
-          MgPieceSquareTable[p][s] = Value(MgPST[p][s] + i);
-          EgPieceSquareTable[p][s] = Value(EgPST[p][s] + i);
+          PieceSquareTable[p][s] = Score(MgPST[p][s] + i, EgPST[p][s] + i);
       }
 
   for (Square s = SQ_A1; s <= SQ_H8; s++)
       for (Piece p = BP; p <= BK; p++)
-      {
-          MgPieceSquareTable[p][s] = -MgPieceSquareTable[p-8][flip_square(s)];
-          EgPieceSquareTable[p][s] = -EgPieceSquareTable[p-8][flip_square(s)];
-      }
+          PieceSquareTable[p][s] = -PieceSquareTable[p-8][flip_square(s)];
 }
 
 
@@ -1863,7 +1856,7 @@ void Position::flipped_copy(const Position& pos) {
   st->materialKey = compute_material_key();
 
   // Incremental scores
-  st->value = Score(compute_value<MidGame>(), compute_value<EndGame>());
+  st->value = compute_value();
 
   // Material
   st->npMaterial[WHITE] = compute_non_pawn_material(WHITE);
@@ -1990,14 +1983,8 @@ bool Position::is_ok(int* failedStep) const {
 
   // Incremental eval OK?
   if (failedStep) (*failedStep)++;
-  if (debugIncrementalEval)
-  {
-      if (st->value.mg() != compute_value<MidGame>())
-          return false;
-
-      if (st->value.eg() != compute_value<EndGame>())
-          return false;
-  }
+  if (debugIncrementalEval && st->value != compute_value())
+      return false;
 
   // Non-pawn material OK?
   if (failedStep) (*failedStep)++;

diff --git a/src/position.h b/src/position.h
index fafb55f7eb84b6f91e3591e630d7681894e425af..e2365a68f306266bb1ec4ba84c09fab8762c15c2 100644 (file)
--- a/src/position.h
+++ b/src/position.h
@@ -243,7 +243,7 @@ public:
   Score value() const;
   Value non_pawn_material(Color c) const;
   Phase game_phase() const;
-  template<GamePhase> Value pst_delta(Piece piece, Square from, Square to) const;
+  Score pst_delta(Piece piece, Square from, Square to) const;
 
   // Game termination checks
   bool is_mate() const;
@@ -295,8 +295,8 @@ private:
   Key compute_material_key() const;
 
   // Computing incremental evaluation scores and material counts
-  template<GamePhase> Value pst(Color c, PieceType pt, Square s) const;
-  template<GamePhase> Value compute_value() const;
+  Score pst(Color c, PieceType pt, Square s) const;
+  Score compute_value() const;
   Value compute_non_pawn_material(Color c) const;
 
   // Board
@@ -327,8 +327,7 @@ private:
   static Key zobCastle[16];
   static Key zobMaterial[2][8][16];
   static Key zobSideToMove;
-  static Value MgPieceSquareTable[16][64];
-  static Value EgPieceSquareTable[16][64];
+  static Score PieceSquareTable[16][64];
 };
 
 
@@ -501,16 +500,12 @@ inline Key Position::get_material_key() const {
   return st->materialKey;
 }
 
-template<Position::GamePhase Ph>
-inline Value Position::pst(Color c, PieceType pt, Square s) const {
-  return (Ph == MidGame ? MgPieceSquareTable[piece_of_color_and_type(c, pt)][s]
-                        : EgPieceSquareTable[piece_of_color_and_type(c, pt)][s]);
+inline Score Position::pst(Color c, PieceType pt, Square s) const {
+  return PieceSquareTable[piece_of_color_and_type(c, pt)][s];
 }
 
-template<Position::GamePhase Ph>
-inline Value Position::pst_delta(Piece piece, Square from, Square to) const {
-  return (Ph == MidGame ? MgPieceSquareTable[piece][to] - MgPieceSquareTable[piece][from]
-                        : EgPieceSquareTable[piece][to] - EgPieceSquareTable[piece][from]);
+inline Score Position::pst_delta(Piece piece, Square from, Square to) const {
+  return PieceSquareTable[piece][to] - PieceSquareTable[piece][from];
 }
 
 inline Score Position::value() const {

diff --git a/src/value.h b/src/value.h
index ee093a6e13dcc32ea4ef8adb1ac972812c4498be..c86430c6a06e056192ee39a7c1a0ff08887ff138 100644 (file)
--- a/src/value.h
+++ b/src/value.h
@@ -73,6 +73,9 @@ struct Score {
     Score& operator+=(const Score& s) { v.v32.mgv += s.v.v32.mgv; v.v32.egv += s.v.v32.egv; return *this; }
     Score& operator-=(const Score& s) { v.v32.mgv -= s.v.v32.mgv; v.v32.egv -= s.v.v32.egv; return *this; }
 
+    bool operator==(const Score& s) { return v.v64 == s.v.v64; }
+    bool operator!=(const Score& s) { return v.v64 != s.v.v64; }
+
     Value mg() const { return Value(v.v32.mgv); }
     Value eg() const { return Value(v.v32.egv); }
 
@@ -80,8 +83,10 @@ private:
     ScoreValue v;
 };
 
+inline Score operator-(Score s1, Score s2) { return Score(s1.mg() - s2.mg(), s1.eg() - s2.eg()); }
 inline Score operator*(int i, Score s) { return Score(i * s.mg(), i * s.eg()); }
 inline Score operator*(Score s, int i) { return s * i; }
+inline Score operator/(Score s, int i) { return Score(s.mg() / i, s.eg() / i); }
 inline Score operator-(Score s) { return Score(-s.mg(), -s.eg()); }
 
 extern std::ostream& operator<<(std::ostream& os, Score s);