Stockfish 1.9

Signature is:

stockfish bench 128 1 12 default depth

Node counts: 10914593

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

Readme.txt

@@ -3,7 +3,7 @@
 
 Stockfish is a free UCI chess engine derived from Glaurung 2.1. It is
 not a complete chess program, but requires some UCI compatible GUI
-(like XBoard with PolyGlot, eboard, Jos�, Arena, Sigma Chess, Shredder,
+(like XBoard with PolyGlot, eboard, Josè, Arena, Sigma Chess, Shredder,
 Chess Partner, or Fritz) in order to be used comfortably.  Read the
 documentation for your GUI of choice for information about how to use
 Stockfish with your GUI.
@@ -83,8 +83,3 @@ source code, these changes must also be made available under the GPL.
 For full details, read the copy of the GPL found in the file named
 Copying.txt.
 
-
-6. Feedback
------------
-
-The author's e-mail address is mcostalba@gmail.com

src/Makefile

@@ -35,8 +35,8 @@ PGOBENCH = ./$(EXE) bench 32 1 10 default depth
 ### Object files
 OBJS = application.o bitboard.o pawns.o material.o endgame.o evaluate.o main.o \
 	misc.o move.o movegen.o history.o movepick.o search.o piece.o \
-	position.o direction.o tt.o value.o uci.o ucioption.o \
+	position.o direction.o tt.o uci.o ucioption.o \
-	mersenne.o book.o bitbase.o san.o benchmark.o
+	mersenne.o book.o bitbase.o san.o benchmark.o timeman.o
 
 
 ### ==========================================================================
@@ -219,7 +219,7 @@ ifeq ($(COMP),icc)
 endif
 
 ### 3.2 General compiler settings
-CXXFLAGS += -g -Wall -fno-exceptions -fno-rtti $(EXTRACXXFLAGS)
+CXXFLAGS = -g -Wall -fno-exceptions -fno-rtti $(EXTRACXXFLAGS)
 
 ifeq ($(comp),icc)
 	CXXFLAGS += -wd383,869,981,10187,10188,11505,11503
@@ -230,7 +230,7 @@ ifeq ($(os),osx)
 endif
 
 ### 3.3 General linker settings
-LDFLAGS += -lpthread $(EXTRALDFLAGS)
+LDFLAGS = -lpthread $(EXTRALDFLAGS)
 
 ifeq ($(os),osx)
 	LDFLAGS += -arch $(arch)
@@ -408,7 +408,7 @@ install:
 	-strip $(BINDIR)/$(EXE)
 
 clean:
-	$(RM) $(EXE) *.o .depend *~ core bench.txt
+	$(RM) $(EXE) *.o .depend *~ core bench.txt *.gcda
 
 testrun:
 	@$(PGOBENCH)
@@ -500,7 +500,7 @@ icc-profile-clean:
 
 hpux:
 	$(MAKE) \
-	CXX='/opt/aCC/bin/aCC -AA +hpxstd98 -DBIGENDIAN -mt +O3 -DNDEBUG' \
+	CXX='/opt/aCC/bin/aCC -AA +hpxstd98 -DBIGENDIAN -mt +O3 -DNDEBUG -DNO_PREFETCH' \
 	CXXFLAGS="" \
 	LDFLAGS="" \
 	all

src/benchmark.cpp

@@ -51,7 +51,7 @@ const string BenchmarkPositions[] = {
   "r1bq1r1k/b1p1npp1/p2p3p/1p6/3PP3/1B2NN2/PP3PPP/R2Q1RK1 w - - 1 16",
   "3r1rk1/p5pp/bpp1pp2/8/q1PP1P2/b3P3/P2NQRPP/1R2B1K1 b - - 6 22",
   "r1q2rk1/2p1bppp/2Pp4/p6b/Q1PNp3/4B3/PP1R1PPP/2K4R w - - 2 18",
-  "4k2r/1pb2ppp/1p2p3/1R1p4/3P4/2r1PN2/P4PPP/1R4K1 b  - 3 22",
+  "4k2r/1pb2ppp/1p2p3/1R1p4/3P4/2r1PN2/P4PPP/1R4K1 b - - 3 22",
   "3q2k1/pb3p1p/4pbp1/2r5/PpN2N2/1P2P2P/5PP1/Q2R2K1 b - - 4 26"
 };
 
@@ -155,11 +155,11 @@ void benchmark(const string& commandLine) {
       cerr << "\nBench position: " << cnt << '/' << positions.size() << endl << endl;
       if (limitType == "perft")
       {
-          int64_t perftCnt = perft(pos, maxDepth * OnePly);
+          int64_t perftCnt = perft(pos, maxDepth * ONE_PLY);
           cerr << "\nPerft " << maxDepth << " result (nodes searched): " << perftCnt << endl << endl;
           totalNodes += perftCnt;
       } else {
-          if (!think(pos, false, false, 0, dummy, dummy, 0, maxDepth, maxNodes, secsPerPos, moves))
+          if (!think(pos, false, false, dummy, dummy, 0, maxDepth, maxNodes, secsPerPos, moves))
               break;
           totalNodes += nodes_searched();
       }

src/bitbase.cpp

@@ -26,7 +26,6 @@
 
 #include "bitbase.h"
 #include "bitboard.h"
-#include "move.h"
 #include "square.h"
 
 
@@ -46,30 +45,22 @@ namespace {
 
   struct KPKPosition {
     void from_index(int index);
-    int to_index() const;
     bool is_legal() const;
     bool is_immediate_draw() const;
     bool is_immediate_win() const;
-    Bitboard wk_attacks() const;
+    Bitboard wk_attacks()   const { return StepAttackBB[WK][whiteKingSquare]; }
-    Bitboard bk_attacks() const;
+    Bitboard bk_attacks()   const { return StepAttackBB[BK][blackKingSquare]; }
-    Bitboard pawn_attacks() const;
+    Bitboard pawn_attacks() const { return StepAttackBB[WP][pawnSquare]; }
 
     Square whiteKingSquare, blackKingSquare, pawnSquare;
     Color sideToMove;
   };
 
+  const int IndexMax = 2 * 24 * 64 * 64;
 
-  Result *Bitbase;
+  Result classify_wtm(const KPKPosition& pos, const Result bb[]);
-  const int IndexMax = 2*24*64*64;
+  Result classify_btm(const KPKPosition& pos, const Result bb[]);
-  int UnknownCount = 0;
-
-  void initialize();
-  bool next_iteration();
-  Result classify_wtm(const KPKPosition &p);
-  Result classify_btm(const KPKPosition &p);
   int compute_index(Square wksq, Square bksq, Square psq, Color stm);
-  int compress_result(Result r);
-
 }
 
 
@@ -78,273 +69,252 @@ namespace {
 ////
 
 void generate_kpk_bitbase(uint8_t bitbase[]) {
-  // Allocate array and initialize:
-  Bitbase = new Result[IndexMax];
-  initialize();
 
-  // Iterate until all positions are classified:
+  bool repeat;
-  while(next_iteration());
-
-  // Compress bitbase into the supplied parameter:
   int i, j, b;
-  for(i = 0; i < 24576; i++) {
+  KPKPosition pos;
-    for(b = 0, j = 0; j < 8; b |= (compress_result(Bitbase[8*i+j]) << j), j++);
+  Result bb[IndexMax];
-    assert(b == int(uint8_t(b)));
+
-    bitbase[i] = (uint8_t)b;
+  // Initialize table
+  for (i = 0; i < IndexMax; i++)
+  {
+      pos.from_index(i);
+      bb[i] = !pos.is_legal()          ? RESULT_INVALID
+             : pos.is_immediate_draw() ? RESULT_DRAW
+             : pos.is_immediate_win()  ? RESULT_WIN : RESULT_UNKNOWN;
   }
 
-  // Release allocated memory:
+  // Iterate until all positions are classified (30 cycles needed)
-  delete [] Bitbase;
+  do {
+      repeat = false;
+
+      for (i = 0; i < IndexMax; i++)
+          if (bb[i] == RESULT_UNKNOWN)
+          {
+              pos.from_index(i);
+
+              bb[i] = (pos.sideToMove == WHITE) ? classify_wtm(pos, bb)
+                                                : classify_btm(pos, bb);
+              if (bb[i] != RESULT_UNKNOWN)
+                  repeat = true;
+          }
+
+  } while (repeat);
+
+  // Compress result and map into supplied bitbase parameter
+  for (i = 0; i < 24576; i++)
+  {
+      b = 0;
+      for (j = 0; j < 8; j++)
+          if (bb[8*i+j] == RESULT_WIN || bb[8*i+j] == RESULT_LOSS)
+              b |= (1 << j);
+
+      bitbase[i] = (uint8_t)b;
+  }
 }
 
 
 namespace {
 
+  int compute_index(Square wksq, Square bksq, Square psq, Color stm) {
+
+      int p = int(square_file(psq)) + (int(square_rank(psq)) - 1) * 4;
+      int r = int(stm) + 2 * int(bksq) + 128 * int(wksq) + 8192 * p;
+
+      assert(r >= 0 && r < IndexMax);
+
+      return r;
+  }
+
   void KPKPosition::from_index(int index) {
-    int s;
+
+    int s = (index / 8192) % 24;
+
     sideToMove = Color(index % 2);
     blackKingSquare = Square((index / 2) % 64);
     whiteKingSquare = Square((index / 128) % 64);
-    s = (index / 8192) % 24;
     pawnSquare = make_square(File(s % 4), Rank(s / 4 + 1));
   }
 
-
-  int KPKPosition::to_index() const {
-    return compute_index(whiteKingSquare, blackKingSquare, pawnSquare,
-                         sideToMove);
-  }
-
-
   bool KPKPosition::is_legal() const {
-    if(whiteKingSquare == pawnSquare || whiteKingSquare == blackKingSquare ||
+
-       pawnSquare == blackKingSquare)
+    if (   whiteKingSquare == pawnSquare
-      return false;
+        || whiteKingSquare == blackKingSquare
-    if(sideToMove == WHITE) {
+        || pawnSquare == blackKingSquare)
-      if(bit_is_set(this->wk_attacks(), blackKingSquare))
-        return false;
-      if(bit_is_set(this->pawn_attacks(), blackKingSquare))
         return false;
+
+    if (sideToMove == WHITE)
+    {
+        if (   bit_is_set(wk_attacks(), blackKingSquare)
+            || bit_is_set(pawn_attacks(), blackKingSquare))
+            return false;
     }
-    else {
+    else if (bit_is_set(bk_attacks(), whiteKingSquare))
-      if(bit_is_set(this->bk_attacks(), whiteKingSquare))
         return false;
-    }
+
     return true;
   }
 
-
   bool KPKPosition::is_immediate_draw() const {
-    if(sideToMove == BLACK) {
-      Bitboard wka = this->wk_attacks();
-      Bitboard bka = this->bk_attacks();
 
-      // Case 1: Stalemate
+    if (sideToMove == BLACK)
-      if((bka & ~(wka | this->pawn_attacks())) == EmptyBoardBB)
+    {
-        return true;
+        Bitboard wka = wk_attacks();
+        Bitboard bka = bk_attacks();
 
-      // Case 2: King can capture pawn
+        // Case 1: Stalemate
-      if(bit_is_set(bka, pawnSquare) && !bit_is_set(wka, pawnSquare))
+        if ((bka & ~(wka | pawn_attacks())) == EmptyBoardBB)
-        return true;
+            return true;
+
+        // Case 2: King can capture pawn
+        if (bit_is_set(bka, pawnSquare) && !bit_is_set(wka, pawnSquare))
+            return true;
     }
-    else {
+    else
-      // Case 1: Stalemate
+    {
-      if(whiteKingSquare == SQ_A8 && pawnSquare == SQ_A7 &&
+        // Case 1: Stalemate
-         (blackKingSquare == SQ_C7 || blackKingSquare == SQ_C8))
+        if (   whiteKingSquare == SQ_A8
-        return true;
+            && pawnSquare == SQ_A7
+            && (blackKingSquare == SQ_C7 || blackKingSquare == SQ_C8))
+            return true;
     }
-
     return false;
   }
 
-
   bool KPKPosition::is_immediate_win() const {
-    // The position is an immediate win if it is white to move and the white
+
-    // pawn can be promoted without getting captured:
+    // The position is an immediate win if it is white to move and the
-    return
+    // white pawn can be promoted without getting captured.
-      sideToMove == WHITE &&
+    return   sideToMove == WHITE
-      square_rank(pawnSquare) == RANK_7 &&
+          && square_rank(pawnSquare) == RANK_7
-      (square_distance(blackKingSquare, pawnSquare+DELTA_N) > 1 ||
+          && (   square_distance(blackKingSquare, pawnSquare + DELTA_N) > 1
-       bit_is_set(this->wk_attacks(), pawnSquare+DELTA_N));
+              || bit_is_set(wk_attacks(), pawnSquare + DELTA_N));
   }
 
-
+  Result classify_wtm(const KPKPosition& pos, const Result bb[]) {
-  Bitboard KPKPosition::wk_attacks() const {
-    return StepAttackBB[WK][whiteKingSquare];
-  }
-
-
-  Bitboard KPKPosition::bk_attacks() const {
-    return StepAttackBB[BK][blackKingSquare];
-  }
-
-
-  Bitboard KPKPosition::pawn_attacks() const {
-    return StepAttackBB[WP][pawnSquare];
-  }
-
-
-  void initialize() {
-    KPKPosition p;
-    for(int i = 0; i < IndexMax; i++) {
-      p.from_index(i);
-      if(!p.is_legal())
-        Bitbase[i] = RESULT_INVALID;
-      else if(p.is_immediate_draw())
-        Bitbase[i] = RESULT_DRAW;
-      else if(p.is_immediate_win())
-        Bitbase[i] = RESULT_WIN;
-      else {
-        Bitbase[i] = RESULT_UNKNOWN;
-        UnknownCount++;
-      }
-    }
-  }
-
-
-  bool next_iteration() {
-    KPKPosition p;
-    int previousUnknownCount = UnknownCount;
-
-    for(int i = 0; i < IndexMax; i++)
-      if(Bitbase[i] == RESULT_UNKNOWN) {
-        p.from_index(i);
-
-        Bitbase[i] = (p.sideToMove == WHITE)? classify_wtm(p) : classify_btm(p);
-
-        if(Bitbase[i] == RESULT_WIN || Bitbase[i] == RESULT_LOSS ||
-           Bitbase[i] == RESULT_DRAW)
-          UnknownCount--;
-      }
-
-    return UnknownCount != previousUnknownCount;
-  }
-
-
-  Result classify_wtm(const KPKPosition &p) {
 
     // If one move leads to a position classified as RESULT_LOSS, the result
-    // of the current position is RESULT_WIN.  If all moves lead to positions
+    // of the current position is RESULT_WIN. If all moves lead to positions
-    // classified as RESULT_DRAW, the current position is classified as
+    // classified as RESULT_DRAW, the current position is classified RESULT_DRAW
-    // RESULT_DRAW.  Otherwise, the current position is classified as
+    // otherwise the current position is classified as RESULT_UNKNOWN.
-    // RESULT_UNKNOWN.
 
     bool unknownFound = false;
     Bitboard b;
     Square s;
+    int idx;
 
     // King moves
-    b = p.wk_attacks();
+    b = pos.wk_attacks();
-    while(b) {
+    while (b)
-      s = pop_1st_bit(&b);
+    {
-      switch(Bitbase[compute_index(s, p.blackKingSquare, p.pawnSquare,
+        s = pop_1st_bit(&b);
-                                   BLACK)]) {
+        idx = compute_index(s, pos.blackKingSquare, pos.pawnSquare, BLACK);
-      case RESULT_LOSS:
-        return RESULT_WIN;
 
-      case RESULT_UNKNOWN:
+        switch (bb[idx]) {
-        unknownFound = true;
-        break;
 
-      case RESULT_DRAW: case RESULT_INVALID:
+        case RESULT_LOSS:
-        break;
+            return RESULT_WIN;
 
-      default:
+        case RESULT_UNKNOWN:
-        assert(false);
+            unknownFound = true;
-      }
+
+        case RESULT_DRAW:
+        case RESULT_INVALID:
+             break;
+
+         default:
+             assert(false);
+        }
     }
 
     // Pawn moves
-    if(square_rank(p.pawnSquare) < RANK_7) {
+    if (square_rank(pos.pawnSquare) < RANK_7)
-      s = p.pawnSquare + DELTA_N;
+    {
-      switch(Bitbase[compute_index(p.whiteKingSquare, p.blackKingSquare, s,
+        s = pos.pawnSquare + DELTA_N;
-                                   BLACK)]) {
+        idx = compute_index(pos.whiteKingSquare, pos.blackKingSquare, s, BLACK);
-      case RESULT_LOSS:
-        return RESULT_WIN;
 
-      case RESULT_UNKNOWN:
+        switch (bb[idx]) {
-        unknownFound = true;
-        break;
 
-      case RESULT_DRAW: case RESULT_INVALID:
-        break;
-
-      default:
-        assert(false);
-      }
-
-      if(square_rank(s) == RANK_3 &&
-         s != p.whiteKingSquare && s != p.blackKingSquare) {
-        s += DELTA_N;
-        switch(Bitbase[compute_index(p.whiteKingSquare, p.blackKingSquare, s,
-                                     BLACK)]) {
         case RESULT_LOSS:
-          return RESULT_WIN;
+            return RESULT_WIN;
 
         case RESULT_UNKNOWN:
-          unknownFound = true;
+            unknownFound = true;
-          break;
 
-        case RESULT_DRAW: case RESULT_INVALID:
+        case RESULT_DRAW:
-          break;
+        case RESULT_INVALID:
+            break;
 
         default:
-          assert(false);
+            assert(false);
         }
-      }
-    }
 
-    return unknownFound? RESULT_UNKNOWN : RESULT_DRAW;
+        // Double pawn push
+        if (   square_rank(s) == RANK_3
+            && s != pos.whiteKingSquare
+            && s != pos.blackKingSquare)
+        {
+            s += DELTA_N;
+            idx = compute_index(pos.whiteKingSquare, pos.blackKingSquare, s, BLACK);
+
+            switch (bb[idx]) {
+
+            case RESULT_LOSS:
+                return RESULT_WIN;
+
+            case RESULT_UNKNOWN:
+                unknownFound = true;
+
+            case RESULT_DRAW:
+            case RESULT_INVALID:
+                break;
+
+            default:
+                assert(false);
+            }
+        }
+    }
+    return unknownFound ? RESULT_UNKNOWN : RESULT_DRAW;
   }
 
 
-  Result classify_btm(const KPKPosition &p) {
+  Result classify_btm(const KPKPosition& pos, const Result bb[]) {
 
     // If one move leads to a position classified as RESULT_DRAW, the result
-    // of the current position is RESULT_DRAW.  If all moves lead to positions
+    // of the current position is RESULT_DRAW. If all moves lead to positions
     // classified as RESULT_WIN, the current position is classified as
-    // RESULT_LOSS.  Otherwise, the current position is classified as
+    // RESULT_LOSS. Otherwise, the current position is classified as
     // RESULT_UNKNOWN.
 
     bool unknownFound = false;
     Bitboard b;
     Square s;
+    int idx;
 
     // King moves
-    b = p.bk_attacks();
+    b = pos.bk_attacks();
-    while(b) {
+    while (b)
-      s = pop_1st_bit(&b);
+    {
-      switch(Bitbase[compute_index(p.whiteKingSquare, s, p.pawnSquare,
+        s = pop_1st_bit(&b);
-                                   WHITE)]) {
+        idx = compute_index(pos.whiteKingSquare, s, pos.pawnSquare, WHITE);
-      case RESULT_DRAW:
-        return RESULT_DRAW;
 
-      case RESULT_UNKNOWN:
+        switch (bb[idx]) {
-        unknownFound = true;
-        break;
 
-      case RESULT_WIN: case RESULT_INVALID:
+        case RESULT_DRAW:
-        break;
+            return RESULT_DRAW;
 
-      default:
+        case RESULT_UNKNOWN:
-        assert(false);
+            unknownFound = true;
-      }
+
+        case RESULT_WIN:
+        case RESULT_INVALID:
+            break;
+
+        default:
+            assert(false);
+        }
     }
-
+    return unknownFound ? RESULT_UNKNOWN : RESULT_LOSS;
-    return unknownFound? RESULT_UNKNOWN : RESULT_LOSS;
-  }
-
-
-  int compute_index(Square wksq, Square bksq, Square psq, Color stm) {
-    int p = int(square_file(psq)) + (int(square_rank(psq)) - 1) * 4;
-    int result = int(stm) + 2*int(bksq) + 128*int(wksq) + 8192*p;
-    assert(result >= 0 && result < IndexMax);
-    return result;
-  }
-
-
-  int compress_result(Result r) {
-    return (r == RESULT_WIN || r == RESULT_LOSS)? 1 : 0;
   }
 
 }

src/bitboard.cpp

@@ -163,7 +163,10 @@ const int RShift[64] = {
 
 #endif // defined(IS_64BIT)
 
-const Bitboard SquaresByColorBB[2] = { BlackSquaresBB, WhiteSquaresBB };
+const Bitboard LightSquaresBB = 0x55AA55AA55AA55AAULL;
+const Bitboard DarkSquaresBB  = 0xAA55AA55AA55AA55ULL;
+
+const Bitboard SquaresByColorBB[2] = { DarkSquaresBB, LightSquaresBB };
 
 const Bitboard FileBB[8] = {
   FileABB, FileBBB, FileCBB, FileDBB, FileEBB, FileFBB, FileGBB, FileHBB

src/bitboard.h

@@ -36,28 +36,25 @@
 //// Constants and variables
 ////
 
-const Bitboard EmptyBoardBB = 0ULL;
+const Bitboard EmptyBoardBB = 0;
-
-const Bitboard WhiteSquaresBB = 0x55AA55AA55AA55AAULL;
-const Bitboard BlackSquaresBB = 0xAA55AA55AA55AA55ULL;
 
 const Bitboard FileABB = 0x0101010101010101ULL;
-const Bitboard FileBBB = 0x0202020202020202ULL;
+const Bitboard FileBBB = FileABB << 1;
-const Bitboard FileCBB = 0x0404040404040404ULL;
+const Bitboard FileCBB = FileABB << 2;
-const Bitboard FileDBB = 0x0808080808080808ULL;
+const Bitboard FileDBB = FileABB << 3;
-const Bitboard FileEBB = 0x1010101010101010ULL;
+const Bitboard FileEBB = FileABB << 4;
-const Bitboard FileFBB = 0x2020202020202020ULL;
+const Bitboard FileFBB = FileABB << 5;
-const Bitboard FileGBB = 0x4040404040404040ULL;
+const Bitboard FileGBB = FileABB << 6;
-const Bitboard FileHBB = 0x8080808080808080ULL;
+const Bitboard FileHBB = FileABB << 7;
 
-const Bitboard Rank1BB = 0xFFULL;
+const Bitboard Rank1BB = 0xFF;
-const Bitboard Rank2BB = 0xFF00ULL;
+const Bitboard Rank2BB = Rank1BB << (8 * 1);
-const Bitboard Rank3BB = 0xFF0000ULL;
+const Bitboard Rank3BB = Rank1BB << (8 * 2);
-const Bitboard Rank4BB = 0xFF000000ULL;
+const Bitboard Rank4BB = Rank1BB << (8 * 3);
-const Bitboard Rank5BB = 0xFF00000000ULL;
+const Bitboard Rank5BB = Rank1BB << (8 * 4);
-const Bitboard Rank6BB = 0xFF0000000000ULL;
+const Bitboard Rank6BB = Rank1BB << (8 * 5);
-const Bitboard Rank7BB = 0xFF000000000000ULL;
+const Bitboard Rank7BB = Rank1BB << (8 * 6);
-const Bitboard Rank8BB = 0xFF00000000000000ULL;
+const Bitboard Rank8BB = Rank1BB << (8 * 7);
 
 extern const Bitboard SquaresByColorBB[2];
 extern const Bitboard FileBB[8];

src/book.cpp

@@ -366,7 +366,7 @@ void Book::open(const string& fName) {
 
   // Get the book size in number of entries
   seekg(0, ios::end);
-  bookSize = tellg() / EntrySize;
+  bookSize = long(tellg()) / EntrySize;
   seekg(0, ios::beg);
 
   if (!good())

src/color.h

@@ -21,6 +21,7 @@
 #if !defined(COLOR_H_INCLUDED)
 #define COLOR_H_INCLUDED
 
+#include "types.h"
 
 ////
 //// Types
@@ -32,13 +33,18 @@ enum Color {
   COLOR_NONE
 };
 
+enum SquareColor {
+  DARK,
+  LIGHT
+};
+
+ENABLE_OPERATORS_ON(Color);
+
 
 ////
 //// Inline functions
 ////
 
-inline void operator++ (Color &c, int) { c = Color(int(c) + 1); }
-
 inline Color opposite_color(Color c) {
   return Color(int(c) ^ 1);
 }

src/depth.h

@@ -21,41 +21,20 @@
 #if !defined(DEPTH_H_INCLUDED)
 #define DEPTH_H_INCLUDED
 
+#include "types.h"
+
 ////
 //// Types
 ////
 
 enum Depth {
+
+  ONE_PLY = 2,
+
   DEPTH_ZERO = 0,
-  DEPTH_MAX = 200, // 100 * OnePly;
+  DEPTH_NONE = -127 * ONE_PLY
-  DEPTH_ENSURE_SIGNED = -1
 };
 
-
+ENABLE_OPERATORS_ON(Depth);
-////
-//// Constants
-////
-
-const Depth OnePly = Depth(2);
-
-
-////
-//// Inline functions
-////
-
-inline Depth operator+ (Depth d, int i) { return Depth(int(d) + i); }
-inline Depth operator+ (Depth d1, Depth d2) { return Depth(int(d1) + int(d2)); }
-inline void operator+= (Depth &d, int i) { d = Depth(int(d) + i); }
-inline void operator+= (Depth &d1, Depth d2) { d1 += int(d2); }
-inline Depth operator- (Depth d, int i) { return Depth(int(d) - i); }
-inline Depth operator- (Depth d1, Depth d2) { return Depth(int(d1) - int(d2)); }
-inline void operator-= (Depth &d, int i) { d = Depth(int(d) - i); }
-inline void operator-= (Depth &d1, Depth d2) { d1 -= int(d2); }
-inline Depth operator* (Depth d, int i) { return Depth(int(d) * i); }
-inline Depth operator* (int i, Depth d) { return Depth(int(d) * i); }
-inline void operator*= (Depth &d, int i) { d = Depth(int(d) * i); }
-inline Depth operator/ (Depth d, int i) { return Depth(int(d) / i); }
-inline void operator/= (Depth &d, int i) { d = Depth(int(d) / i); }
-
 
 #endif // !defined(DEPTH_H_INCLUDED)

src/direction.h

@@ -45,6 +45,8 @@ enum SignedDirection {
   SIGNED_DIR_NONE = 8
 };
 
+ENABLE_OPERATORS_ON(SignedDirection);
+
 
 ////
 //// Variables
@@ -58,14 +60,6 @@ extern uint8_t SignedDirectionTable[64][64];
 //// Inline functions
 ////
 
-inline void operator++ (Direction& d, int) {
-  d = Direction(int(d) + 1);
-}
-
-inline void operator++ (SignedDirection& d, int) {
-  d = SignedDirection(int(d) + 1);
-}
-
 inline Direction direction_between_squares(Square s1, Square s2) {
   return Direction(DirectionTable[s1][s2]);
 }

src/endgame.cpp

@@ -65,13 +65,13 @@ namespace {
   // the two kings in basic endgames.
   const int DistanceBonus[8] = { 0, 0, 100, 80, 60, 40, 20, 10 };
 
-  // Bitbase for KP vs K
-  uint8_t KPKBitbase[24576];
-
   // Penalty for big distance between king and knight for the defending king
   // and knight in KR vs KN endgames.
   const int KRKNKingKnightDistancePenalty[8] = { 0, 0, 4, 10, 20, 32, 48, 70 };
 
+  // Bitbase for KP vs K
+  uint8_t KPKBitbase[24576];
+
   // Various inline functions for accessing the above arrays
   inline Value mate_table(Square s) {
     return Value(MateTable[s]);
@@ -99,6 +99,15 @@ namespace {
 //// Functions
 ////
 
+/// init_bitbases() is called during program initialization, and simply loads
+/// bitbases from disk into memory.  At the moment, there is only the bitbase
+/// for KP vs K, but we may decide to add other bitbases later.
+
+void init_bitbases() {
+  generate_kpk_bitbase(KPKBitbase);
+}
+
+
 /// Mate with KX vs K. This function is used to evaluate positions with
 /// King and plenty of material vs a lone king. It simply gives the
 /// attacking side a bonus for driving the defending king towards the edge
@@ -106,8 +115,8 @@ namespace {
 template<>
 Value EvaluationFunction<KXK>::apply(const Position& pos) const {
 
-  assert(pos.non_pawn_material(weakerSide) == Value(0));
+  assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
-  assert(pos.piece_count(weakerSide, PAWN) == Value(0));
+  assert(pos.piece_count(weakerSide, PAWN) == VALUE_ZERO);
 
   Square winnerKSq = pos.king_square(strongerSide);
   Square loserKSq = pos.king_square(weakerSide);
@@ -117,13 +126,13 @@ Value EvaluationFunction<KXK>::apply(const Position& pos) const {
                  + mate_table(loserKSq)
                  + distance_bonus(square_distance(winnerKSq, loserKSq));
 
-  if (   pos.piece_count(strongerSide, QUEEN) > 0
+  if (   pos.piece_count(strongerSide, QUEEN)
-      || pos.piece_count(strongerSide, ROOK) > 0
+      || pos.piece_count(strongerSide, ROOK)
       || pos.piece_count(strongerSide, BISHOP) > 1)
       // TODO: check for two equal-colored bishops!
       result += VALUE_KNOWN_WIN;
 
-  return (strongerSide == pos.side_to_move() ? result : -result);
+  return strongerSide == pos.side_to_move() ? result : -result;
 }
 
 
@@ -132,8 +141,8 @@ Value EvaluationFunction<KXK>::apply(const Position& pos) const {
 template<>
 Value EvaluationFunction<KBNK>::apply(const Position& pos) const {
 
-  assert(pos.non_pawn_material(weakerSide) == Value(0));
+  assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
-  assert(pos.piece_count(weakerSide, PAWN) == Value(0));
+  assert(pos.piece_count(weakerSide, PAWN) == VALUE_ZERO);
   assert(pos.non_pawn_material(strongerSide) == KnightValueMidgame + BishopValueMidgame);
   assert(pos.piece_count(strongerSide, BISHOP) == 1);
   assert(pos.piece_count(strongerSide, KNIGHT) == 1);
@@ -143,7 +152,10 @@ Value EvaluationFunction<KBNK>::apply(const Position& pos) const {
   Square loserKSq = pos.king_square(weakerSide);
   Square bishopSquare = pos.piece_list(strongerSide, BISHOP, 0);
 
-  if (square_color(bishopSquare) == BLACK)
+  // kbnk_mate_table() tries to drive toward corners A1 or H8,
+  // if we have a bishop that cannot reach the above squares we
+  // mirror the kings so to drive enemy toward corners A8 or H1.
+  if (!same_color_squares(bishopSquare, SQ_A1))
   {
       winnerKSq = flop_square(winnerKSq);
       loserKSq = flop_square(loserKSq);
@@ -153,7 +165,7 @@ Value EvaluationFunction<KBNK>::apply(const Position& pos) const {
                 + distance_bonus(square_distance(winnerKSq, loserKSq))
                 + kbnk_mate_table(loserKSq);
 
-  return (strongerSide == pos.side_to_move() ? result : -result);
+  return strongerSide == pos.side_to_move() ? result : -result;
 }
 
 
@@ -161,8 +173,8 @@ Value EvaluationFunction<KBNK>::apply(const Position& pos) const {
 template<>
 Value EvaluationFunction<KPK>::apply(const Position& pos) const {
 
-  assert(pos.non_pawn_material(strongerSide) == Value(0));
+  assert(pos.non_pawn_material(strongerSide) == VALUE_ZERO);
-  assert(pos.non_pawn_material(weakerSide) == Value(0));
+  assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
   assert(pos.piece_count(strongerSide, PAWN) == 1);
   assert(pos.piece_count(weakerSide, PAWN) == 0);
 
@@ -186,9 +198,9 @@ Value EvaluationFunction<KPK>::apply(const Position& pos) const {
 
   if (square_file(wpsq) >= FILE_E)
   {
-    wksq = flop_square(wksq);
+      wksq = flop_square(wksq);
-    bksq = flop_square(bksq);
+      bksq = flop_square(bksq);
-    wpsq = flop_square(wpsq);
+      wpsq = flop_square(wpsq);
   }
 
   if (!probe_kpk(wksq, wpsq, bksq, stm))
@@ -198,7 +210,7 @@ Value EvaluationFunction<KPK>::apply(const Position& pos) const {
                 + PawnValueEndgame
                 + Value(square_rank(wpsq));
 
-  return (strongerSide == pos.side_to_move() ? result : -result);
+  return strongerSide == pos.side_to_move() ? result : -result;
 }
 
 
@@ -239,7 +251,7 @@ Value EvaluationFunction<KRKP>::apply(const Position& pos) const {
 
   // If the weaker side's king is too far from the pawn and the rook,
   // it's a win
-  else if (   square_distance(bksq, bpsq) - (tempo^1) >= 3
+  else if (   square_distance(bksq, bpsq) - (tempo ^ 1) >= 3
            && square_distance(bksq, wrsq) >= 3)
       result = RookValueEndgame - Value(square_distance(wksq, bpsq));
 
@@ -257,7 +269,7 @@ Value EvaluationFunction<KRKP>::apply(const Position& pos) const {
               + Value(square_distance(bksq, bpsq + DELTA_S) * 8)
               + Value(square_distance(bpsq, queeningSq) * 8);
 
-  return (strongerSide == pos.side_to_move() ? result : -result);
+  return strongerSide == pos.side_to_move() ? result : -result;
 }
 
 
@@ -273,7 +285,7 @@ Value EvaluationFunction<KRKB>::apply(const Position& pos) const {
   assert(pos.piece_count(weakerSide, BISHOP) == 1);
 
   Value result = mate_table(pos.king_square(weakerSide));
-  return (pos.side_to_move() == strongerSide ? result : -result);
+  return strongerSide == pos.side_to_move() ? result : -result;
 }
 
 
@@ -291,10 +303,12 @@ Value EvaluationFunction<KRKN>::apply(const Position& pos) const {
   Square defendingKSq = pos.king_square(weakerSide);
   Square nSq = pos.piece_list(weakerSide, KNIGHT, 0);
 
-  Value result = Value(10) + mate_table(defendingKSq) +
+  int d = square_distance(defendingKSq, nSq);
-    krkn_king_knight_distance_penalty(square_distance(defendingKSq, nSq));
+  Value result =   Value(10)
+                 + mate_table(defendingKSq)
+                 + krkn_king_knight_distance_penalty(d);
 
-  return (strongerSide == pos.side_to_move())? result : -result;
+  return strongerSide == pos.side_to_move() ? result : -result;
 }
 
 
@@ -319,7 +333,7 @@ Value EvaluationFunction<KQKR>::apply(const Position& pos) const {
                 + mate_table(loserKSq)
                 + distance_bonus(square_distance(winnerKSq, loserKSq));
 
-  return (strongerSide == pos.side_to_move())? result : -result;
+  return strongerSide == pos.side_to_move() ? result : -result;
 }
 
 template<>
@@ -345,7 +359,7 @@ Value EvaluationFunction<KBBKN>::apply(const Position& pos) const {
   // Bonus for restricting the knight's mobility
   result += Value((8 - count_1s_max_15(pos.attacks_from<KNIGHT>(nsq))) * 8);
 
-  return (strongerSide == pos.side_to_move() ? result : -result);
+  return strongerSide == pos.side_to_move() ? result : -result;
 }
 
 
@@ -353,17 +367,17 @@ Value EvaluationFunction<KBBKN>::apply(const Position& pos) const {
 /// king alone are always draw.
 template<>
 Value EvaluationFunction<KmmKm>::apply(const Position&) const {
-  return Value(0);
+  return VALUE_ZERO;
 }
 
 template<>
 Value EvaluationFunction<KNNK>::apply(const Position&) const {
-  return Value(0);
+  return VALUE_ZERO;
 }
 
 /// KBPKScalingFunction scales endgames where the stronger side has king,
 /// bishop and one or more pawns. It checks for draws with rook pawns and a
-/// bishop of the wrong color. If such a draw is detected, ScaleFactor(0) is
+/// bishop of the wrong color. If such a draw is detected, SCALE_FACTOR_ZERO is
 /// returned. If not, the return value is SCALE_FACTOR_NONE, i.e. no scaling
 /// will be used.
 template<>
@@ -387,7 +401,7 @@ ScaleFactor ScalingFunction<KBPsK>::apply(const Position& pos) const {
       Square queeningSq = relative_square(strongerSide, make_square(pawnFile, RANK_8));
       Square kingSq = pos.king_square(weakerSide);
 
-      if (   square_color(queeningSq) != square_color(bishopSq)
+      if (  !same_color_squares(queeningSq, bishopSq)
           && file_distance(square_file(kingSq), pawnFile) <= 1)
       {
           // The bishop has the wrong color, and the defending king is on the
@@ -401,15 +415,15 @@ ScaleFactor ScalingFunction<KBPsK>::apply(const Position& pos) const {
           }
           else
           {
-              for(rank = RANK_2; (rank_bb(rank) & pawns) == EmptyBoardBB; rank++) {}
+              for (rank = RANK_2; (rank_bb(rank) & pawns) == EmptyBoardBB; rank++) {}
-              rank = Rank(rank^7);  // HACK to get the relative rank
+              rank = Rank(rank ^ 7);  // HACK to get the relative rank
               assert(rank >= RANK_2 && rank <= RANK_7);
           }
           // If the defending king has distance 1 to the promotion square or
           // is placed somewhere in front of the pawn, it's a draw.
           if (   square_distance(kingSq, queeningSq) <= 1
               || relative_rank(strongerSide, kingSq) >= rank)
-              return ScaleFactor(0);
+              return SCALE_FACTOR_ZERO;
       }
   }
   return SCALE_FACTOR_NONE;
@@ -438,7 +452,7 @@ ScaleFactor ScalingFunction<KQKRPs>::apply(const Position& pos) const {
   {
       Square rsq = pos.piece_list(weakerSide, ROOK, 0);
       if (pos.attacks_from<PAWN>(rsq, strongerSide) & pos.pieces(PAWN, weakerSide))
-          return ScaleFactor(0);
+          return SCALE_FACTOR_ZERO;
   }
   return SCALE_FACTOR_NONE;
 }
@@ -495,7 +509,7 @@ ScaleFactor ScalingFunction<KRPKR>::apply(const Position& pos) const {
       && square_distance(bksq, queeningSq) <= 1
       && wksq <= SQ_H5
       && (square_rank(brsq) == RANK_6 || (r <= RANK_3 && square_rank(wrsq) != RANK_6)))
-      return ScaleFactor(0);
+      return SCALE_FACTOR_ZERO;
 
   // The defending side saves a draw by checking from behind in case the pawn
   // has advanced to the 6th rank with the king behind.
@@ -503,13 +517,13 @@ ScaleFactor ScalingFunction<KRPKR>::apply(const Position& pos) const {
       && square_distance(bksq, queeningSq) <= 1
       && square_rank(wksq) + tempo <= RANK_6
       && (square_rank(brsq) == RANK_1 || (!tempo && abs(square_file(brsq) - f) >= 3)))
-      return ScaleFactor(0);
+      return SCALE_FACTOR_ZERO;
 
   if (   r >= RANK_6
       && bksq == queeningSq
       && square_rank(brsq) == RANK_1
       && (!tempo || square_distance(wksq, wpsq) >= 2))
-      return ScaleFactor(0);
+      return SCALE_FACTOR_ZERO;
 
   // White pawn on a7 and rook on a8 is a draw if black's king is on g7 or h7
   // and the black rook is behind the pawn.
@@ -518,7 +532,7 @@ ScaleFactor ScalingFunction<KRPKR>::apply(const Position& pos) const {
       && (bksq == SQ_H7 || bksq == SQ_G7)
       && square_file(brsq) == FILE_A
       && (square_rank(brsq) <= RANK_3 || square_file(wksq) >= FILE_D || square_rank(wksq) <= RANK_5))
-      return ScaleFactor(0);
+      return SCALE_FACTOR_ZERO;
 
   // If the defending king blocks the pawn and the attacking king is too far
   // away, it's a draw.
@@ -526,7 +540,7 @@ ScaleFactor ScalingFunction<KRPKR>::apply(const Position& pos) const {
       && bksq == wpsq + DELTA_N
       && square_distance(wksq, wpsq) - tempo >= 2
       && square_distance(wksq, brsq) - tempo >= 2)
-      return ScaleFactor(0);
+      return SCALE_FACTOR_ZERO;
 
   // Pawn on the 7th rank supported by the rook from behind usually wins if the
   // attacking king is closer to the queening square than the defending king,
@@ -549,8 +563,8 @@ ScaleFactor ScalingFunction<KRPKR>::apply(const Position& pos) const {
           || (    square_distance(wksq, queeningSq) < square_distance(bksq, wrsq) + tempo
               && (square_distance(wksq, wpsq + DELTA_N) < square_distance(bksq, wrsq) + tempo))))
       return ScaleFactor(  SCALE_FACTOR_MAX
-                         - (8 * square_distance(wpsq, queeningSq)
+                         - 8 * square_distance(wpsq, queeningSq)
-                         + 2 * square_distance(wksq, queeningSq)));
+                         - 2 * square_distance(wksq, queeningSq));
 
   // If the pawn is not far advanced, and the defending king is somewhere in
   // the pawn's path, it's probably a draw.
@@ -611,41 +625,33 @@ ScaleFactor ScalingFunction<KRPPKRP>::apply(const Position& pos) const {
 template<>
 ScaleFactor ScalingFunction<KPsK>::apply(const Position& pos) const {
 
-  assert(pos.non_pawn_material(strongerSide) == Value(0));
+  assert(pos.non_pawn_material(strongerSide) == VALUE_ZERO);
   assert(pos.piece_count(strongerSide, PAWN) >= 2);
-  assert(pos.non_pawn_material(weakerSide) == Value(0));
+  assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
   assert(pos.piece_count(weakerSide, PAWN) == 0);
 
+  Square ksq = pos.king_square(weakerSide);
   Bitboard pawns = pos.pieces(PAWN, strongerSide);
 
   // Are all pawns on the 'a' file?
   if ((pawns & ~FileABB) == EmptyBoardBB)
   {
       // Does the defending king block the pawns?
-      Square ksq = pos.king_square(weakerSide);
+      if (   square_distance(ksq, relative_square(strongerSide, SQ_A8)) <= 1
-      if (square_distance(ksq, relative_square(strongerSide, SQ_A8)) <= 1)
+          || (   square_file(ksq) == FILE_A
-          return ScaleFactor(0);
+              && (in_front_bb(strongerSide, ksq) & pawns) == EmptyBoardBB))
-      else if(   square_file(ksq) == FILE_A
+          return SCALE_FACTOR_ZERO;
-              && (in_front_bb(strongerSide, ksq) & pawns) == EmptyBoardBB)
-          return ScaleFactor(0);
-      else
-          return SCALE_FACTOR_NONE;
   }
   // Are all pawns on the 'h' file?
   else if ((pawns & ~FileHBB) == EmptyBoardBB)
   {
     // Does the defending king block the pawns?
-    Square ksq = pos.king_square(weakerSide);
+    if (   square_distance(ksq, relative_square(strongerSide, SQ_H8)) <= 1
-    if (square_distance(ksq, relative_square(strongerSide, SQ_H8)) <= 1)
+        || (   square_file(ksq) == FILE_H
-        return ScaleFactor(0);
+            && (in_front_bb(strongerSide, ksq) & pawns) == EmptyBoardBB))
-    else if (   square_file(ksq) == FILE_H
+        return SCALE_FACTOR_ZERO;
-             && (in_front_bb(strongerSide, ksq) & pawns) == EmptyBoardBB)
-        return ScaleFactor(0);
-    else
-        return SCALE_FACTOR_NONE;
   }
-  else
+  return SCALE_FACTOR_NONE;
-      return SCALE_FACTOR_NONE;
 }
 
 
@@ -672,12 +678,12 @@ ScaleFactor ScalingFunction<KBPKB>::apply(const Position& pos) const {
   // Case 1: Defending king blocks the pawn, and cannot be driven away
   if (   square_file(weakerKingSq) == square_file(pawnSq)
       && relative_rank(strongerSide, pawnSq) < relative_rank(strongerSide, weakerKingSq)
-      && (   square_color(weakerKingSq) != square_color(strongerBishopSq)
+      && (  !same_color_squares(weakerKingSq, strongerBishopSq)
           || relative_rank(strongerSide, weakerKingSq) <= RANK_6))
-      return ScaleFactor(0);
+      return SCALE_FACTOR_ZERO;
 
   // Case 2: Opposite colored bishops
-  if (square_color(strongerBishopSq) != square_color(weakerBishopSq))
+  if (!same_color_squares(strongerBishopSq, weakerBishopSq))
   {
       // We assume that the position is drawn in the following three situations:
       //
@@ -690,15 +696,16 @@ ScaleFactor ScalingFunction<KBPKB>::apply(const Position& pos) const {
       // reasonably well.
 
       if (relative_rank(strongerSide, pawnSq) <= RANK_5)
-          return ScaleFactor(0);
+          return SCALE_FACTOR_ZERO;
       else
       {
           Bitboard ray = ray_bb(pawnSq, (strongerSide == WHITE)? SIGNED_DIR_N : SIGNED_DIR_S);
           if (ray & pos.pieces(KING, weakerSide))
-              return ScaleFactor(0);
+              return SCALE_FACTOR_ZERO;
-          if(  (pos.attacks_from<BISHOP>(weakerBishopSq) & ray)
+
-             && square_distance(weakerBishopSq, pawnSq) >= 3)
+          if (  (pos.attacks_from<BISHOP>(weakerBishopSq) & ray)
-              return ScaleFactor(0);
+              && square_distance(weakerBishopSq, pawnSq) >= 3)
+              return SCALE_FACTOR_ZERO;
       }
   }
   return SCALE_FACTOR_NONE;
@@ -720,7 +727,7 @@ ScaleFactor ScalingFunction<KBPPKB>::apply(const Position& pos) const {
   Square wbsq = pos.piece_list(strongerSide, BISHOP, 0);
   Square bbsq = pos.piece_list(weakerSide, BISHOP, 0);
 
-  if (square_color(wbsq) == square_color(bbsq))
+  if (same_color_squares(wbsq, bbsq))
       // Not opposite-colored bishops, no scaling
       return SCALE_FACTOR_NONE;
 
@@ -749,8 +756,8 @@ ScaleFactor ScalingFunction<KBPPKB>::apply(const Position& pos) const {
     // some square in the frontmost pawn's path.
     if (   square_file(ksq) == square_file(blockSq1)
         && relative_rank(strongerSide, ksq) >= relative_rank(strongerSide, blockSq1)
-        && square_color(ksq) != square_color(wbsq))
+        && !same_color_squares(ksq, wbsq))
-        return ScaleFactor(0);
+        return SCALE_FACTOR_ZERO;
     else
         return SCALE_FACTOR_NONE;
 
@@ -759,16 +766,17 @@ ScaleFactor ScalingFunction<KBPPKB>::apply(const Position& pos) const {
     // in front of the frontmost pawn's path, and the square diagonally behind
     // this square on the file of the other pawn.
     if (   ksq == blockSq1
-        && square_color(ksq) != square_color(wbsq)
+        && !same_color_squares(ksq, wbsq)
         && (   bbsq == blockSq2
             || (pos.attacks_from<BISHOP>(blockSq2) & pos.pieces(BISHOP, weakerSide))
             || rank_distance(r1, r2) >= 2))
-        return ScaleFactor(0);
+        return SCALE_FACTOR_ZERO;
+
     else if (   ksq == blockSq2
-             && square_color(ksq) != square_color(wbsq)
+             && !same_color_squares(ksq, wbsq)
              && (   bbsq == blockSq1
                  || (pos.attacks_from<BISHOP>(blockSq1) & pos.pieces(BISHOP, weakerSide))))
-        return ScaleFactor(0);
+        return SCALE_FACTOR_ZERO;
     else
         return SCALE_FACTOR_NONE;
 
@@ -799,9 +807,9 @@ ScaleFactor ScalingFunction<KBPKN>::apply(const Position& pos) const {
 
   if (   square_file(weakerKingSq) == square_file(pawnSq)
       && relative_rank(strongerSide, pawnSq) < relative_rank(strongerSide, weakerKingSq)
-      && (   square_color(weakerKingSq) != square_color(strongerBishopSq)
+      && (  !same_color_squares(weakerKingSq, strongerBishopSq)
           || relative_rank(strongerSide, weakerKingSq) <= RANK_6))
-      return ScaleFactor(0);
+      return SCALE_FACTOR_ZERO;
 
   return SCALE_FACTOR_NONE;
 }
@@ -816,7 +824,7 @@ ScaleFactor ScalingFunction<KNPK>::apply(const Position& pos) const {
   assert(pos.non_pawn_material(strongerSide) == KnightValueMidgame);
   assert(pos.piece_count(strongerSide, KNIGHT) == 1);
   assert(pos.piece_count(strongerSide, PAWN) == 1);
-  assert(pos.non_pawn_material(weakerSide) == Value(0));
+  assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
   assert(pos.piece_count(weakerSide, PAWN) == 0);
 
   Square pawnSq = pos.piece_list(strongerSide, PAWN, 0);
@@ -824,11 +832,11 @@ ScaleFactor ScalingFunction<KNPK>::apply(const Position& pos) const {
 
   if (   pawnSq == relative_square(strongerSide, SQ_A7)
       && square_distance(weakerKingSq, relative_square(strongerSide, SQ_A8)) <= 1)
-      return ScaleFactor(0);
+      return SCALE_FACTOR_ZERO;
 
   if (   pawnSq == relative_square(strongerSide, SQ_H7)
       && square_distance(weakerKingSq, relative_square(strongerSide, SQ_H8)) <= 1)
-      return ScaleFactor(0);
+      return SCALE_FACTOR_ZERO;
 
   return SCALE_FACTOR_NONE;
 }
@@ -843,8 +851,8 @@ ScaleFactor ScalingFunction<KNPK>::apply(const Position& pos) const {
 template<>
 ScaleFactor ScalingFunction<KPKP>::apply(const Position& pos) const {
 
-  assert(pos.non_pawn_material(strongerSide) == Value(0));
+  assert(pos.non_pawn_material(strongerSide) == VALUE_ZERO);
-  assert(pos.non_pawn_material(weakerSide) == Value(0));
+  assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO);
   assert(pos.piece_count(WHITE, PAWN) == 1);
   assert(pos.piece_count(BLACK, PAWN) == 1);
 
@@ -881,32 +889,21 @@ ScaleFactor ScalingFunction<KPKP>::apply(const Position& pos) const {
 
   // Probe the KPK bitbase with the weakest side's pawn removed. If it's a
   // draw, it's probably at least a draw even with the pawn.
-  if (probe_kpk(wksq, wpsq, bksq, stm))
+  return probe_kpk(wksq, wpsq, bksq, stm) ? SCALE_FACTOR_NONE : SCALE_FACTOR_ZERO;
-      return SCALE_FACTOR_NONE;
-  else
-      return ScaleFactor(0);
-}
-
-
-/// init_bitbases() is called during program initialization, and simply loads
-/// bitbases from disk into memory.  At the moment, there is only the bitbase
-/// for KP vs K, but we may decide to add other bitbases later.
-
-void init_bitbases() {
-  generate_kpk_bitbase(KPKBitbase);
 }
 
 
 namespace {
 
-  // Probe the KP vs K bitbase:
+  // Probe the KP vs K bitbase
 
   int probe_kpk(Square wksq, Square wpsq, Square bksq, Color stm) {
 
-    int wp = int(square_file(wpsq)) + (int(square_rank(wpsq)) - 1) * 4;
+    int wp = square_file(wpsq) + 4 * (square_rank(wpsq) - 1);
-    int index = int(stm) + 2*int(bksq) + 128*int(wksq) + 8192*wp;
+    int index = int(stm) + 2 * bksq + 128 * wksq + 8192 * wp;
 
-    assert(index >= 0 && index < 24576*8);
+    assert(index >= 0 && index < 24576 * 8);
-    return KPKBitbase[index/8] & (1 << (index&7));
+
+    return KPKBitbase[index / 8] & (1 << (index & 7));
   }
 }

src/endgame.h

@@ -26,7 +26,6 @@
 ////
 
 #include "position.h"
-#include "scale.h"
 #include "value.h"
 
 

src/evaluate.h

@@ -21,90 +21,14 @@
 #if !defined(EVALUATE_H_INCLUDED)
 #define EVALUATE_H_INCLUDED
 
-////
+#include "color.h"
-//// Includes
+#include "value.h"
-////
 
-#include <iostream>
-
-#include "material.h"
-#include "pawns.h"
-
-
-////
-//// Types
-////
-
-
-/// The EvalInfo struct contains various information computed and collected
-/// by the evaluation function. An EvalInfo object is passed as one of the
-/// arguments to the evaluation function, and the search can make use of its
-/// contents to make intelligent search decisions.
-///
-/// At the moment, this is not utilized very much: The only part of the
-/// EvalInfo object which is used by the search is futilityMargin.
 class Position;
 
-struct EvalInfo {
+extern Value evaluate(const Position& pos, Value& margin);
-
-  EvalInfo() { kingDanger[0] = kingDanger[1] = Value(0); }
-
-  // Middle game and endgame evaluations
-  Score value;
-
-  // Pointers to material and pawn hash table entries
-  MaterialInfo* mi;
-  PawnInfo* pi;
-
-  // attackedBy[color][piece type] is a bitboard representing all squares
-  // attacked by a given color and piece type, attackedBy[color][0] contains
-  // all squares attacked by the given color.
-  Bitboard attackedBy[2][8];
-  Bitboard attacked_by(Color c) const { return attackedBy[c][0]; }
-  Bitboard attacked_by(Color c, PieceType pt) const { return attackedBy[c][pt]; }
-
-  // kingZone[color] is the zone around the enemy king which is considered
-  // by the king safety evaluation. This consists of the squares directly
-  // adjacent to the king, and the three (or two, for a king on an edge file)
-  // squares two ranks in front of the king. For instance, if black's king
-  // is on g8, kingZone[WHITE] is a bitboard containing the squares f8, h8,
-  // f7, g7, h7, f6, g6 and h6.
-  Bitboard kingZone[2];
-
-  // kingAttackersCount[color] is the number of pieces of the given color
-  // which attack a square in the kingZone of the enemy king.
-  int kingAttackersCount[2];
-
-  // kingAttackersWeight[color] is the sum of the "weight" of the pieces of the
-  // given color which attack a square in the kingZone of the enemy king. The
-  // weights of the individual piece types are given by the variables
-  // QueenAttackWeight, RookAttackWeight, BishopAttackWeight and
-  // KnightAttackWeight in evaluate.cpp
-  int kingAttackersWeight[2];
-
-  // kingAdjacentZoneAttacksCount[color] is the number of attacks to squares
-  // directly adjacent to the king of the given color. Pieces which attack
-  // more than one square are counted multiple times. For instance, if black's
-  // king is on g8 and there's a white knight on g5, this knight adds
-  // 2 to kingAdjacentZoneAttacksCount[BLACK].
-  int kingAdjacentZoneAttacksCount[2];
-
-  // Middle game and endgame mobility scores
-  Score mobility;
-
-  // Value of the danger for the king of the given color
-  Value kingDanger[2];
-};
-
-
-////
-//// Prototypes
-////
-
-extern Value evaluate(const Position& pos, EvalInfo& ei);
 extern void init_eval(int threads);
 extern void quit_eval();
 extern void read_weights(Color sideToMove);
 
-
 #endif // !defined(EVALUATE_H_INCLUDED)

src/history.cpp

@@ -41,8 +41,8 @@ History::History() { clear(); }
 /// History::clear() clears the history tables
 
 void History::clear() {
-  memset(history, 0, 2 * 8 * 64 * sizeof(int));
+  memset(history, 0, 16 * 64 * sizeof(int));
-  memset(maxStaticValueDelta, 0, 2 * 8 * 64 * sizeof(int));
+  memset(maxStaticValueDelta, 0, 16 * 64 * sizeof(int));
 }
 
 
@@ -85,31 +85,14 @@ void History::failure(Piece p, Square to, Depth d) {
 }
 
 
-/// History::move_ordering_score() returns an integer value used to order the
-/// non-capturing moves in the MovePicker class.
-
-int History::move_ordering_score(Piece p, Square to) const {
-
-  assert(piece_is_ok(p));
-  assert(square_is_ok(to));
-
-  return history[p][to];
-}
-
-
 /// History::set_gain() and History::gain() store and retrieve the
 /// gain of a move given the delta of the static position evaluations
 /// before and after the move.
 
-void History::set_gain(Piece p, Square to, Value delta)
+void History::set_gain(Piece p, Square to, Value delta) {
-{
+
   if (delta >= maxStaticValueDelta[p][to])
       maxStaticValueDelta[p][to] = delta;
   else
       maxStaticValueDelta[p][to]--;
 }
-
-Value History::gain(Piece p, Square to) const
-{
-  return Value(maxStaticValueDelta[p][to]);
-}

src/history.h

@@ -49,7 +49,7 @@ public:
   void clear();
   void success(Piece p, Square to, Depth d);
   void failure(Piece p, Square to, Depth d);
-  int move_ordering_score(Piece p, Square to) const;
+  int value(Piece p, Square to) const;
   void set_gain(Piece p, Square to, Value delta);
   Value gain(Piece p, Square to) const;
 
@@ -71,7 +71,19 @@ private:
 /// recently have a bigger importance for move ordering than the moves which
 /// have been searched a long time ago.
 
-const int HistoryMax = 50000 * OnePly;
+const int HistoryMax = 50000 * ONE_PLY;
 
 
+////
+//// Inline functions
+////
+
+inline int History::value(Piece p, Square to) const {
+  return history[p][to];
+}
+
+inline Value History::gain(Piece p, Square to) const {
+  return Value(maxStaticValueDelta[p][to]);
+}
+
 #endif // !defined(HISTORY_H_INCLUDED)

src/lock.h

@@ -22,63 +22,13 @@
 #define LOCK_H_INCLUDED
 
 
-// x86 assembly language locks or OS spin locks may perform faster than
+#if !defined(_MSC_VER)
-// mutex locks on some platforms. On my machine, mutexes seem to be the
-// best.
-
-//#define ASM_LOCK
-//#define OS_SPIN_LOCK
-
-
-#if defined(ASM_LOCK)
-
-
-typedef volatile int Lock;
-
-static inline void LockX86(Lock *lock) {
-  int dummy;
-  asm __volatile__("1:          movl    $1, %0" "\n\t"
-      "            xchgl   (%1), %0" "\n\t" "            testl   %0, %0" "\n\t"
-      "            jz      3f" "\n\t" "2:          pause" "\n\t"
-      "            movl    (%1), %0" "\n\t" "            testl   %0, %0" "\n\t"
-      "            jnz     2b" "\n\t" "            jmp     1b" "\n\t" "3:"
-      "\n\t":"=&q"(dummy)
-      :"q"(lock)
-      :"cc");
-}
-
-static inline void UnlockX86(Lock *lock) {
-  int dummy;
-  asm __volatile__("movl    $0, (%1)":"=&q"(dummy)
-      :"q"(lock));
-}
-
-#  define lock_init(x, y) (*(x) = 0)
-#  define lock_grab(x) LockX86(x)
-#  define lock_release(x) UnlockX86(x)
-#  define lock_destroy(x)
-
-
-#elif defined(OS_SPIN_LOCK)
-
-
-#  include <libkern/OSAtomic.h>
-
-typedef OSSpinLock Lock;
-
-#  define lock_init(x, y) (*(x) = 0)
-#  define lock_grab(x) OSSpinLockLock(x)
-#  define lock_release(x) OSSpinLockUnlock(x)
-#  define lock_destroy(x)
-
-
-#elif !defined(_MSC_VER)
 
 #  include <pthread.h>
 
 typedef pthread_mutex_t Lock;
 
-#  define lock_init(x, y) pthread_mutex_init(x, y)
+#  define lock_init(x) pthread_mutex_init(x, NULL)
 #  define lock_grab(x) pthread_mutex_lock(x)
 #  define lock_release(x) pthread_mutex_unlock(x)
 #  define lock_destroy(x) pthread_mutex_destroy(x)
@@ -91,7 +41,7 @@ typedef pthread_mutex_t Lock;
 #undef WIN32_LEAN_AND_MEAN
 
 typedef CRITICAL_SECTION Lock;
-#  define lock_init(x, y) InitializeCriticalSection(x)
+#  define lock_init(x) InitializeCriticalSection(x)
 #  define lock_grab(x) EnterCriticalSection(x)
 #  define lock_release(x) LeaveCriticalSection(x)
 #  define lock_destroy(x) DeleteCriticalSection(x)

src/material.cpp

@@ -23,6 +23,7 @@
 ////
 
 #include <cassert>
+#include <cstring>
 #include <sstream>
 #include <map>
 
@@ -57,6 +58,8 @@ namespace {
 
   typedef EndgameEvaluationFunctionBase EF;
   typedef EndgameScalingFunctionBase SF;
+  typedef map<Key, EF*> EFMap;
+  typedef map<Key, SF*> SFMap;
 
   // Endgame evaluation and scaling functions accessed direcly and not through
   // the function maps because correspond to more then one material hash key.
@@ -70,7 +73,7 @@ namespace {
   // Helper templates used to detect a given material distribution
   template<Color Us> bool is_KXK(const Position& pos) {
     const Color Them = (Us == WHITE ? BLACK : WHITE);
-    return   pos.non_pawn_material(Them) == Value(0)
+    return   pos.non_pawn_material(Them) == VALUE_ZERO
           && pos.piece_count(Them, PAWN) == 0
           && pos.non_pawn_material(Us)   >= RookValueMidgame;
   }
@@ -113,21 +116,17 @@ private:
   static Key buildKey(const string& keyCode);
   static const string swapColors(const string& keyCode);
 
-  // Here we store two maps, for evaluate and scaling functions
+  // Here we store two maps, for evaluate and scaling functions...
-  pair<map<Key, EF*>, map<Key, SF*> > maps;
+  pair<EFMap, SFMap> maps;
 
-  // Maps accessing functions returning const and non-const references
+  // ...and here is the accessing template function
-  template<typename T> const map<Key, T*>& get() const { return maps.first; }
+  template<typename T> const map<Key, T*>& get() const;
-  template<typename T> map<Key, T*>& get() { return maps.first; }
 };
 
 // Explicit specializations of a member function shall be declared in
 // the namespace of which the class template is a member.
-template<> const map<Key, SF*>&
+template<> const EFMap& EndgameFunctions::get<EF>() const { return maps.first; }
-EndgameFunctions::get<SF>() const { return maps.second; }
+template<> const SFMap& EndgameFunctions::get<SF>() const { return maps.second; }
-
-template<> map<Key, SF*>&
-EndgameFunctions::get<SF>() { return maps.second; }
 
 
 ////
@@ -136,15 +135,14 @@ EndgameFunctions::get<SF>() { return maps.second; }
 
 /// MaterialInfoTable c'tor and d'tor, called once by each thread
 
-MaterialInfoTable::MaterialInfoTable(unsigned int numOfEntries) {
+MaterialInfoTable::MaterialInfoTable() {
 
-  size = numOfEntries;
+  entries = new MaterialInfo[MaterialTableSize];
-  entries = new MaterialInfo[size];
   funcs = new EndgameFunctions();
 
   if (!entries || !funcs)
   {
-      cerr << "Failed to allocate " << numOfEntries * sizeof(MaterialInfo)
+      cerr << "Failed to allocate " << MaterialTableSize * sizeof(MaterialInfo)
            << " bytes for material hash table." << endl;
       Application::exit_with_failure();
   }
@@ -167,7 +165,8 @@ Phase MaterialInfoTable::game_phase(const Position& pos) {
 
   if (npm >= MidgameLimit)
       return PHASE_MIDGAME;
-  else if (npm <= EndgameLimit)
+
+  if (npm <= EndgameLimit)
       return PHASE_ENDGAME;
 
   return Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit));
@@ -182,7 +181,7 @@ Phase MaterialInfoTable::game_phase(const Position& pos) {
 MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
 
   Key key = pos.get_material_key();
-  int index = key & (size - 1);
+  unsigned index = unsigned(key & (MaterialTableSize - 1));
   MaterialInfo* mi = entries + index;
 
   // If mi->key matches the position's material hash key, it means that we
@@ -192,7 +191,8 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
       return mi;
 
   // Clear the MaterialInfo object, and set its key
-  mi->clear();
+  memset(mi, 0, sizeof(MaterialInfo));
+  mi->factor[WHITE] = mi->factor[BLACK] = uint8_t(SCALE_FACTOR_NORMAL);
   mi->key = key;
 
   // Store game phase
@@ -204,14 +204,15 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
   if ((mi->evaluationFunction = funcs->get<EF>(key)) != NULL)
       return mi;
 
-  else if (is_KXK<WHITE>(pos) || is_KXK<BLACK>(pos))
+  if (is_KXK<WHITE>(pos) || is_KXK<BLACK>(pos))
   {
       mi->evaluationFunction = is_KXK<WHITE>(pos) ? &EvaluateKXK[WHITE] : &EvaluateKXK[BLACK];
       return mi;
   }
-  else if (   pos.pieces(PAWN)  == EmptyBoardBB
+
-           && pos.pieces(ROOK)  == EmptyBoardBB
+  if (   pos.pieces(PAWN)  == EmptyBoardBB
-           && pos.pieces(QUEEN) == EmptyBoardBB)
+      && pos.pieces(ROOK)  == EmptyBoardBB
+      && pos.pieces(QUEEN) == EmptyBoardBB)
   {
       // Minor piece endgame with at least one minor piece per side and
       // no pawns. Note that the case KmmK is already handled by KXK.
@@ -254,7 +255,7 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
   else if (is_KQKRPs<BLACK>(pos))
       mi->scalingFunction[BLACK] = &ScaleKQKRPs[BLACK];
 
-  if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) == Value(0))
+  if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) == VALUE_ZERO)
   {
       if (pos.piece_count(BLACK, PAWN) == 0)
       {
@@ -334,7 +335,7 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
     //
     // We use NO_PIECE_TYPE as a place holder for the bishop pair "extended piece",
     // this allow us to be more flexible in defining bishop pair bonuses.
-    for (pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; pt1++)
+    for (pt1 = PIECE_TYPE_NONE; pt1 <= QUEEN; pt1++)
     {
         pc = pieceCount[c][pt1];
         if (!pc)
@@ -342,7 +343,7 @@ MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
 
         vv = LinearCoefficients[pt1];
 
-        for (pt2 = NO_PIECE_TYPE; pt2 <= pt1; pt2++)
+        for (pt2 = PIECE_TYPE_NONE; pt2 <= pt1; pt2++)
             vv +=  pieceCount[c][pt2] * QuadraticCoefficientsSameColor[pt1][pt2]
                  + pieceCount[them][pt2] * QuadraticCoefficientsOppositeColor[pt1][pt2];
 
@@ -378,11 +379,11 @@ EndgameFunctions::EndgameFunctions() {
 
 EndgameFunctions::~EndgameFunctions() {
 
-    for (map<Key, EF*>::iterator it = maps.first.begin(); it != maps.first.end(); ++it)
+    for (EFMap::const_iterator it = maps.first.begin(); it != maps.first.end(); ++it)
-        delete (*it).second;
+        delete it->second;
 
-    for (map<Key, SF*>::iterator it = maps.second.begin(); it != maps.second.end(); ++it)
+    for (SFMap::const_iterator it = maps.second.begin(); it != maps.second.end(); ++it)
-        delete (*it).second;
+        delete it->second;
 }
 
 Key EndgameFunctions::buildKey(const string& keyCode) {
@@ -400,9 +401,9 @@ Key EndgameFunctions::buildKey(const string& keyCode) {
         if (keyCode[i] == 'K')
             upcase = !upcase;
 
-        s << char(upcase? toupper(keyCode[i]) : tolower(keyCode[i]));
+        s << char(upcase ? toupper(keyCode[i]) : tolower(keyCode[i]));
     }
-    s << 8 - keyCode.length() << "/8/8/8/8/8/8/8 w -";
+    s << 8 - keyCode.length() << "/8/8/8/8/8/8/8 w - -";
     return Position(s.str(), 0).get_material_key();
 }
 
@@ -417,14 +418,15 @@ template<class T>
 void EndgameFunctions::add(const string& keyCode) {
 
   typedef typename T::Base F;
+  typedef map<Key, F*> M;
 
-  get<F>().insert(pair<Key, F*>(buildKey(keyCode), new T(WHITE)));
+  const_cast<M&>(get<F>()).insert(pair<Key, F*>(buildKey(keyCode), new T(WHITE)));
-  get<F>().insert(pair<Key, F*>(buildKey(swapColors(keyCode)), new T(BLACK)));
+  const_cast<M&>(get<F>()).insert(pair<Key, F*>(buildKey(swapColors(keyCode)), new T(BLACK)));
 }
 
 template<class T>
 T* EndgameFunctions::get(Key key) const {
 
-  typename map<Key, T*>::const_iterator it(get<T>().find(key));
+  typename map<Key, T*>::const_iterator it = get<T>().find(key);
-  return (it != get<T>().end() ? it->second : NULL);
+  return it != get<T>().end() ? it->second : NULL;
 }

src/material.h

@@ -27,13 +27,14 @@
 
 #include "endgame.h"
 #include "position.h"
-#include "scale.h"
 
 
 ////
 //// Types
 ////
 
+const int MaterialTableSize = 1024;
+
 /// MaterialInfo is a class which contains various information about a
 /// material configuration. It contains a material balance evaluation,
 /// a function pointer to a special endgame evaluation function (which in
@@ -49,8 +50,6 @@ class MaterialInfo {
   friend class MaterialInfoTable;
 
 public:
-  MaterialInfo() : key(0) { clear(); }
-
   Score material_value() const;
   ScaleFactor scale_factor(const Position& pos, Color c) const;
   int space_weight() const;
@@ -59,8 +58,6 @@ public:
   Value evaluate(const Position& pos) const;
 
 private:
-  inline void clear();
-
   Key key;
   int16_t value;
   uint8_t factor[2];
@@ -79,14 +76,13 @@ class EndgameFunctions;
 class MaterialInfoTable {
 
 public:
-  MaterialInfoTable(unsigned numOfEntries);
+  MaterialInfoTable();
   ~MaterialInfoTable();
   MaterialInfo* get_material_info(const Position& pos);
 
   static Phase game_phase(const Position& pos);
 
 private:
-  unsigned size;
   MaterialInfo* entries;
   EndgameFunctions* funcs;
 };
@@ -105,20 +101,6 @@ inline Score MaterialInfo::material_value() const {
   return make_score(value, value);
 }
 
-
-/// MaterialInfo::clear() resets a MaterialInfo object to an empty state,
-/// with all slots at their default values but the key.
-
-inline void MaterialInfo::clear() {
-
-  value = 0;
-  factor[WHITE] = factor[BLACK] = uint8_t(SCALE_FACTOR_NORMAL);
-  evaluationFunction = NULL;
-  scalingFunction[WHITE] = scalingFunction[BLACK] = NULL;
-  spaceWeight = 0;
-}
-
-
 /// MaterialInfo::scale_factor takes a position and a color as input, and
 /// returns a scale factor for the given color. We have to provide the
 /// position in addition to the color, because the scale factor need not

src/misc.cpp

@@ -58,7 +58,7 @@ using namespace std;
 /// Version number. If this is left empty, the current date (in the format
 /// YYMMDD) is used as a version number.
 
-static const string EngineVersion = "1.8";
+static const string EngineVersion = "1.9";
 static const string AppName = "Stockfish";
 static const string AppTag  = "";
 
@@ -67,8 +67,6 @@ static const string AppTag  = "";
 //// Variables
 ////
 
-bool Chess960;
-
 uint64_t dbg_cnt0 = 0;
 uint64_t dbg_cnt1 = 0;
 

src/misc.h

@@ -40,13 +40,6 @@
 #define Max(x, y) (((x) < (y))? (y) : (x))
 
 
-////
-//// Variables
-////
-
-extern bool Chess960;
-
-
 ////
 //// Prototypes
 ////
@@ -56,6 +49,7 @@ extern int get_system_time();
 extern int cpu_count();
 extern int Bioskey();
 extern void prefetch(char* addr);
+extern void prefetchPawn(Key, int);
 
 
 ////

src/move.cpp

@@ -104,11 +104,11 @@ Move move_from_string(const Position& pos, const std::string& str) {
 
 
 /// move_to_string() converts a move to a string in coordinate notation
-/// (g1f3, a7a8q, etc.).  The only special case is castling moves, where we
+/// (g1f3, a7a8q, etc.). The only special case is castling moves, where we
 /// print in the e1g1 notation in normal chess mode, and in e1h1 notation in
 /// Chess960 mode.
 
-const std::string move_to_string(Move move) {
+const std::string move_to_string(Move move, bool chess960) {
 
   std::string str;
   Square from = move_from(move);
@@ -120,14 +120,12 @@ const std::string move_to_string(Move move) {
       str = "0000";
   else
   {
-      if (!Chess960)
+      if (move_is_short_castle(move) && !chess960)
-      {
+          return (from == SQ_E1 ? "e1g1" : "e8g8");
-          if (move_is_short_castle(move))
+
-              return (from == SQ_E1 ? "e1g1" : "e8g8");
+      if (move_is_long_castle(move) && !chess960)
+          return (from == SQ_E1 ? "e1c1" : "e8c8");
 
-          if (move_is_long_castle(move))
-              return (from == SQ_E1 ? "e1c1" : "e8c8");
-      }
       str = square_to_string(from) + square_to_string(to);
       if (move_is_promotion(move))
           str += piece_type_to_char(move_promotion_piece(move), false);
@@ -138,9 +136,10 @@ const std::string move_to_string(Move move) {
 
 /// Overload the << operator, to make it easier to print moves.
 
-std::ostream &operator << (std::ostream& os, Move m) {
+std::ostream& operator << (std::ostream& os, Move m) {
 
-  return os << move_to_string(m);
+  bool chess960 = (os.iword(0) != 0); // See set960()
+  return os << move_to_string(m, chess960);
 }
 
 

src/move.h

@@ -201,9 +201,9 @@ inline Move make_ep_move(Square from, Square to) {
 //// Prototypes
 ////
 
-extern std::ostream& operator<<(std::ostream &os, Move m);
+extern std::ostream& operator<<(std::ostream& os, Move m);
-extern Move move_from_string(const Position &pos, const std::string &str);
+extern Move move_from_string(const Position& pos, const std::string &str);
-extern const std::string move_to_string(Move m);
+extern const std::string move_to_string(Move m, bool chess960);
 extern bool move_is_ok(Move m);
 
 

src/movegen.cpp

@@ -140,6 +140,32 @@ MoveStack* generate_noncaptures(const Position& pos, MoveStack* mlist) {
 }
 
 
+/// generate_non_evasions() generates all pseudo-legal captures and
+/// non-captures. Returns a pointer to the end of the move list.
+
+MoveStack* generate_non_evasions(const Position& pos, MoveStack* mlist) {
+
+  assert(pos.is_ok());
+  assert(!pos.is_check());
+
+  Color us = pos.side_to_move();
+  Bitboard target = pos.pieces_of_color(opposite_color(us));
+
+  mlist = generate_piece_moves<PAWN, CAPTURE>(pos, mlist, us, target);
+  mlist = generate_piece_moves<PAWN, NON_CAPTURE>(pos, mlist, us, pos.empty_squares());
+
+  target |= pos.empty_squares();
+
+  mlist = generate_piece_moves<KNIGHT>(pos, mlist, us, target);
+  mlist = generate_piece_moves<BISHOP>(pos, mlist, us, target);
+  mlist = generate_piece_moves<ROOK>(pos, mlist, us, target);
+  mlist = generate_piece_moves<QUEEN>(pos, mlist, us, target);
+  mlist = generate_piece_moves<KING>(pos, mlist, us, target);
+  mlist = generate_castle_moves<KING_SIDE>(pos, mlist);
+  return  generate_castle_moves<QUEEN_SIDE>(pos, mlist);
+}
+
+
 /// generate_non_capture_checks() generates all pseudo-legal non-captures and knight
 /// underpromotions that give check. Returns a pointer to the end of the move list.
 
@@ -260,11 +286,8 @@ MoveStack* generate_moves(const Position& pos, MoveStack* mlist, bool pseudoLega
   Bitboard pinned = pos.pinned_pieces(pos.side_to_move());
 
   // Generate pseudo-legal moves
-  if (pos.is_check())
+  last = pos.is_check() ? generate_evasions(pos, mlist)
-      last = generate_evasions(pos, mlist);
+                        : generate_non_evasions(pos, mlist);
-  else
-      last = generate_noncaptures(pos, generate_captures(pos, mlist));
-
   if (pseudoLegal)
       return last;
 
@@ -406,10 +429,13 @@ namespace {
     Square from;
     const Square* ptr = pos.piece_list_begin(us, Piece);
 
-    while ((from = *ptr++) != SQ_NONE)
+    if (*ptr != SQ_NONE)
     {
-        b = pos.attacks_from<Piece>(from) & target;
+        do {
-        SERIALIZE_MOVES(b);
+            from = *ptr;
+            b = pos.attacks_from<Piece>(from) & target;
+            SERIALIZE_MOVES(b);
+        } while (*++ptr != SQ_NONE);
     }
     return mlist;
   }

src/movegen.h

@@ -36,6 +36,7 @@ extern MoveStack* generate_captures(const Position& pos, MoveStack* mlist);
 extern MoveStack* generate_noncaptures(const Position& pos, MoveStack* mlist);
 extern MoveStack* generate_non_capture_checks(const Position& pos, MoveStack* mlist);
 extern MoveStack* generate_evasions(const Position& pos, MoveStack* mlist);
+extern MoveStack* generate_non_evasions(const Position& pos, MoveStack* mlist);
 extern MoveStack* generate_moves(const Position& pos, MoveStack* mlist, bool pseudoLegal = false);
 extern bool move_is_legal(const Position& pos, const Move m, Bitboard pinned);
 extern bool move_is_legal(const Position& pos, const Move m);

src/movepick.cpp

@@ -75,7 +75,7 @@ MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const History& h,
   int searchTT = ttm;
   ttMoves[0].move = ttm;
   badCaptureThreshold = 0;
-  lastBadCapture = badCaptures;
+  badCaptures = moves + 256;
 
   pinned = p.pinned_pieces(pos.side_to_move());
 
@@ -90,16 +90,16 @@ MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const History& h,
 
   if (p.is_check())
       phasePtr = EvasionsPhaseTable;
-  else if (d > Depth(0))
+  else if (d > DEPTH_ZERO)
   {
       // Consider sligtly negative captures as good if at low
       // depth and far from beta.
-      if (ss && ss->eval < beta - PawnValueMidgame && d < 3 * OnePly)
+      if (ss && ss->eval < beta - PawnValueMidgame && d < 3 * ONE_PLY)
           badCaptureThreshold = -PawnValueMidgame;
 
       phasePtr = MainSearchPhaseTable;
   }
-  else if (d == Depth(0))
+  else if (d == DEPTH_ZERO)
       phasePtr = QsearchWithChecksPhaseTable;
   else
   {
@@ -148,16 +148,16 @@ void MovePicker::go_next_phase() {
       return;
 
   case PH_BAD_CAPTURES:
-      // Bad captures SEE value is already calculated so just sort them
+      // Bad captures SEE value is already calculated so just pick
-      // to get SEE move ordering.
+      // them in order to get SEE move ordering.
       curMove = badCaptures;
-      lastMove = lastBadCapture;
+      lastMove = moves + 256;
       return;
 
   case PH_EVASIONS:
       assert(pos.is_check());
       lastMove = generate_evasions(pos, moves);
-      score_evasions_or_checks();
+      score_evasions();
       return;
 
   case PH_QCAPTURES:
@@ -167,7 +167,6 @@ void MovePicker::go_next_phase() {
 
   case PH_QCHECKS:
       lastMove = generate_non_capture_checks(pos, moves);
-      score_evasions_or_checks();
       return;
 
   case PH_STOP:
@@ -221,7 +220,6 @@ void MovePicker::score_noncaptures() {
   Move m;
   Piece piece;
   Square from, to;
-  int hs;
 
   for (MoveStack* cur = moves; cur != lastMove; cur++)
   {
@@ -229,18 +227,11 @@ void MovePicker::score_noncaptures() {
       from = move_from(m);
       to = move_to(m);
       piece = pos.piece_on(from);
-      hs = H.move_ordering_score(piece, to);
+      cur->score = H.value(piece, to) + H.gain(piece, to);
-
-      // Ensure history has always highest priority
-      if (hs > 0)
-          hs += 10000;
-
-      // Gain table based scoring
-      cur->score = hs + 16 * H.gain(piece, to);
   }
 }
 
-void MovePicker::score_evasions_or_checks() {
+void MovePicker::score_evasions() {
   // Try good captures ordered by MVV/LVA, then non-captures if
   // destination square is not under attack, ordered by history
   // value, and at the end bad-captures and non-captures with a
@@ -261,7 +252,7 @@ void MovePicker::score_evasions_or_checks() {
           cur->score =  pos.midgame_value_of_piece_on(move_to(m))
                       - pos.type_of_piece_on(move_from(m)) + HistoryMax;
       else
-          cur->score = H.move_ordering_score(pos.piece_on(move_from(m)), move_to(m));
+          cur->score = H.value(pos.piece_on(move_from(m)), move_to(m));
   }
 }
 
@@ -301,12 +292,10 @@ Move MovePicker::get_next_move() {
                   if (seeValue >= badCaptureThreshold)
                       return move;
 
-                  // Losing capture, move it to the badCaptures[] array, note
+                  // Losing capture, move it to the tail of the array, note
                   // that move has now been already checked for legality.
-                  assert(int(lastBadCapture - badCaptures) < 63);
+                  (--badCaptures)->move = move;
-                  lastBadCapture->move = move;
+                  badCaptures->score = seeValue;
-                  lastBadCapture->score = seeValue;
-                  lastBadCapture++;
               }
               break;
 

src/movepick.h

@@ -56,7 +56,7 @@ public:
 private:
   void score_captures();
   void score_noncaptures();
-  void score_evasions_or_checks();
+  void score_evasions();
   void go_next_phase();
 
   const Position& pos;
@@ -65,8 +65,8 @@ private:
   MoveStack ttMoves[2], killers[2];
   int badCaptureThreshold, phase;
   const uint8_t* phasePtr;
-  MoveStack *curMove, *lastMove, *lastGoodNonCapture, *lastBadCapture;
+  MoveStack *curMove, *lastMove, *lastGoodNonCapture, *badCaptures;
-  MoveStack moves[256], badCaptures[64];
+  MoveStack moves[256];
 };
 
 

src/pawns.cpp

@@ -70,36 +70,6 @@ namespace {
     S(34,68), S(83,166), S(0, 0), S( 0, 0)
   };
 
-  // Pawn storm tables for positions with opposite castling
-  const int QStormTable[64] = {
-    0,  0,  0,  0, 0, 0, 0, 0,
-  -22,-22,-22,-14,-6, 0, 0, 0,
-   -6,-10,-10,-10,-6, 0, 0, 0,
-    4, 12, 16, 12, 4, 0, 0, 0,
-   16, 23, 23, 16, 0, 0, 0, 0,
-   23, 31, 31, 23, 0, 0, 0, 0,
-   23, 31, 31, 23, 0, 0, 0, 0,
-    0,  0,  0,  0, 0, 0, 0, 0
-  };
-
-  const int KStormTable[64] = {
-    0, 0, 0,  0,  0,  0,  0,  0,
-    0, 0, 0,-10,-19,-28,-33,-33,
-    0, 0, 0,-10,-15,-19,-24,-24,
-    0, 0, 0,  0,  1,  1,  1,  1,
-    0, 0, 0,  0,  1, 10, 19, 19,
-    0, 0, 0,  0,  1, 19, 31, 27,
-    0, 0, 0,  0,  0, 22, 31, 22,
-    0, 0, 0,  0,  0,  0,  0,  0
-  };
-
-  // Pawn storm open file bonuses by file
-  const int16_t QStormOpenFileBonus[8] = { 31, 31, 18, 0, 0, 0, 0, 0 };
-  const int16_t KStormOpenFileBonus[8] = { 0, 0, 0, 0, 0, 26, 42, 26 };
-
-  // Pawn storm lever bonuses by file
-  const int StormLeverBonus[8] = { -8, -8, -13, 0, 0, -13, -8, -8 };
-
   #undef S
 }
 
@@ -110,12 +80,13 @@ namespace {
 
 /// PawnInfoTable c'tor and d'tor instantiated one each thread
 
-PawnInfoTable::PawnInfoTable(unsigned numOfEntries) : size(numOfEntries) {
+PawnInfoTable::PawnInfoTable() {
+
+  entries = new PawnInfo[PawnTableSize];
 
-  entries = new PawnInfo[size];
   if (!entries)
   {
-      std::cerr << "Failed to allocate " << (numOfEntries * sizeof(PawnInfo))
+      std::cerr << "Failed to allocate " << (PawnTableSize * sizeof(PawnInfo))
                 << " bytes for pawn hash table." << std::endl;
       Application::exit_with_failure();
   }
@@ -128,16 +99,6 @@ PawnInfoTable::~PawnInfoTable() {
 }
 
 
-/// PawnInfo::clear() resets to zero the PawnInfo entry. Note that
-/// kingSquares[] is initialized to SQ_NONE instead.
-
-void PawnInfo::clear() {
-
-  memset(this, 0, sizeof(PawnInfo));
-  kingSquares[WHITE] = kingSquares[BLACK] = SQ_NONE;
-}
-
-
 /// PawnInfoTable::get_pawn_info() takes a position object as input, computes
 /// a PawnInfo 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
@@ -148,7 +109,7 @@ PawnInfo* PawnInfoTable::get_pawn_info(const Position& pos) const {
   assert(pos.is_ok());
 
   Key key = pos.get_pawn_key();
-  int index = int(key & (size - 1));
+  unsigned index = unsigned(key & (PawnTableSize - 1));
   PawnInfo* pi = entries + index;
 
   // If pi->key matches the position's pawn hash key, it means that we
@@ -158,7 +119,8 @@ PawnInfo* PawnInfoTable::get_pawn_info(const Position& pos) const {
       return pi;
 
   // Clear the PawnInfo object, and set the key
-  pi->clear();
+  memset(pi, 0, sizeof(PawnInfo));
+  pi->kingSquares[WHITE] = pi->kingSquares[BLACK] = SQ_NONE;
   pi->key = key;
 
   // Calculate pawn attacks
@@ -183,38 +145,25 @@ Score PawnInfoTable::evaluate_pawns(const Position& pos, Bitboard ourPawns,
   Square s;
   File f;
   Rank r;
-  int bonus;
   bool passed, isolated, doubled, opposed, chain, backward, candidate;
-  Score value = make_score(0, 0);
+  Score value = SCORE_ZERO;
   const Square* ptr = pos.piece_list_begin(Us, PAWN);
 
-  // Initialize pawn storm scores by giving bonuses for open files
+  // Initialize halfOpenFiles[]
   for (f = FILE_A; f <= FILE_H; f++)
       if (!(ourPawns & file_bb(f)))
-      {
-          pi->ksStormValue[Us] += KStormOpenFileBonus[f];
-          pi->qsStormValue[Us] += QStormOpenFileBonus[f];
           pi->halfOpenFiles[Us] |= (1 << f);
-      }
 
   // Loop through all pawns of the current color and score each pawn
   while ((s = *ptr++) != SQ_NONE)
   {
+      assert(pos.piece_on(s) == piece_of_color_and_type(Us, PAWN));
+
       f = square_file(s);
       r = square_rank(s);
 
-      assert(pos.piece_on(s) == piece_of_color_and_type(Us, PAWN));
-
-      // Calculate kingside and queenside pawn storm scores for both colors to be
-      // used when evaluating middle game positions with opposite side castling.
-      bonus = (f >= FILE_F ? evaluate_pawn_storm<Us, KingSide>(s, r, f, theirPawns) : 0);
-      pi->ksStormValue[Us] += KStormTable[relative_square(Us, s)] + bonus;
-
-      bonus = (f <= FILE_C ? evaluate_pawn_storm<Us, QueenSide>(s, r, f, theirPawns) : 0);
-      pi->qsStormValue[Us] += QStormTable[relative_square(Us, s)] + bonus;
-
       // Our rank plus previous one. Used for chain detection.
-      b = rank_bb(r) | rank_bb(r + (Us == WHITE ? -1 : 1));
+      b = rank_bb(r) | rank_bb(Us == WHITE ? r - Rank(1) : r + Rank(1));
 
       // Passed, isolated, doubled or member of a pawn
       // chain (but not the backward one) ?
@@ -226,15 +175,15 @@ Score PawnInfoTable::evaluate_pawns(const Position& pos, Bitboard ourPawns,
 
       // Test for backward pawn
       //
+      backward = false;
+
       // If the pawn is passed, isolated, or member of a pawn chain
       // it cannot be backward. If can capture an enemy pawn or if
       // there are friendly pawns behind on neighboring files it cannot
       // be backward either.
-      if (   (passed | isolated | chain)
+      if (   !(passed | isolated | chain)
-          || (ourPawns & attack_span_mask(opposite_color(Us), s))
+          && !(ourPawns & attack_span_mask(opposite_color(Us), s))
-          || (pos.attacks_from<PAWN>(s, Us) & theirPawns))
+          && !(pos.attacks_from<PAWN>(s, Us) & theirPawns))
-          backward = false;
-      else
       {
           // We now know that there are no friendly pawns beside or behind this
           // pawn on neighboring files. We now check whether the pawn is
@@ -268,13 +217,13 @@ Score PawnInfoTable::evaluate_pawns(const Position& pos, Bitboard ourPawns,
       // Mark the pawn as passed. Pawn will be properly scored in evaluation
       // because we need full attack info to evaluate passed pawns.
       if (passed)
-          set_bit(&(pi->passedPawns), s);
+          set_bit(&(pi->passedPawns[Us]), s);
 
       // Score this pawn
       if (isolated)
       {
           value -= IsolatedPawnPenalty[f];
-          if (!(theirPawns & file_bb(f)))
+          if (!opposed)
               value -= IsolatedPawnPenalty[f] / 2;
       }
       if (doubled)
@@ -283,7 +232,7 @@ Score PawnInfoTable::evaluate_pawns(const Position& pos, Bitboard ourPawns,
       if (backward)
       {
           value -= BackwardPawnPenalty[f];
-          if (!(theirPawns & file_bb(f)))
+          if (!opposed)
               value -= BackwardPawnPenalty[f] / 2;
       }
       if (chain)
@@ -296,54 +245,3 @@ Score PawnInfoTable::evaluate_pawns(const Position& pos, Bitboard ourPawns,
   return value;
 }
 
-
-/// PawnInfoTable::evaluate_pawn_storm() evaluates each pawn which seems
-/// to have good chances of creating an open file by exchanging itself
-/// against an enemy pawn on an adjacent file.
-
-template<Color Us, PawnInfoTable::SideType Side>
-int PawnInfoTable::evaluate_pawn_storm(Square s, Rank r, File f, Bitboard theirPawns) const {
-
-  const Bitboard StormFilesBB = (Side == KingSide ? FileFBB | FileGBB | FileHBB
-                                                  : FileABB | FileBBB | FileCBB);
-  const int K = (Side == KingSide ? 2 : 4);
-  const File RookFile = (Side == KingSide ? FILE_H : FILE_A);
-
-  Bitboard b = attack_span_mask(Us, s) & theirPawns & StormFilesBB;
-  int bonus = 0;
-
-  while (b)
-  {
-      // Give a bonus according to the distance of the nearest enemy pawn
-      Square s2 = pop_1st_bit(&b);
-      Rank r2 = square_rank(s2);
-      int v = StormLeverBonus[f] - K * rank_distance(r, r2);
-
-      // If enemy pawn has no pawn beside itself is particularly vulnerable.
-      // Big bonus, especially against a weakness on the rook file
-      if (!(theirPawns & neighboring_files_bb(s2) & rank_bb(s2)))
-          v *= (square_file(s2) == RookFile ? 4 : 2);
-
-      bonus += v;
-  }
-  return bonus;
-}
-
-
-/// PawnInfo::updateShelter calculates and caches king shelter. It is called
-/// only when king square changes, about 20% of total get_king_shelter() calls.
-int PawnInfo::updateShelter(const Position& pos, Color c, Square ksq) {
-
-  Bitboard pawns = pos.pieces(PAWN, c) & this_and_neighboring_files_bb(ksq);
-  unsigned shelter = 0;
-  unsigned r = ksq & (7 << 3);
-
-  for (int i = 1, k = (c ? -8 : 8); i < 4; i++)
-  {
-      r += k;
-      shelter += BitCount8Bit[(pawns >> r) & 0xFF] * (128 >> i);
-  }
-  kingSquares[c] = ksq;
-  kingShelters[c] = shelter;
-  return shelter;
-}

src/pawns.h

@@ -26,49 +26,47 @@
 ////
 
 #include "bitboard.h"
+#include "position.h"
 #include "value.h"
 
 ////
 //// Types
 ////
 
+const int PawnTableSize = 16384;
+
 /// PawnInfo is a class which contains various information about a pawn
 /// structure. Currently, it only includes a middle game and an end game
 /// pawn structure evaluation, and a bitboard of passed pawns. We may want
 /// to add further information in the future. A lookup to the pawn hash table
 /// (performed by calling the get_pawn_info method in a PawnInfoTable object)
 /// returns a pointer to a PawnInfo object.
-class Position;
-
 class PawnInfo {
 
   friend class PawnInfoTable;
 
 public:
-  PawnInfo() { clear(); }
-
   Score pawns_value() const;
-  Value kingside_storm_value(Color c) const;
-  Value queenside_storm_value(Color c) const;
   Bitboard pawn_attacks(Color c) const;
-  Bitboard passed_pawns() const;
+  Bitboard passed_pawns(Color c) const;
   int file_is_half_open(Color c, File f) const;
   int has_open_file_to_left(Color c, File f) const;
   int has_open_file_to_right(Color c, File f) const;
-  int get_king_shelter(const Position& pos, Color c, Square ksq);
+
+  template<Color Us>
+  Score king_shelter(const Position& pos, Square ksq);
 
 private:
-  void clear();
+  template<Color Us>
-  int updateShelter(const Position& pos, Color c, Square ksq);
+  Score updateShelter(const Position& pos, Square ksq);
 
   Key key;
-  Bitboard passedPawns;
+  Bitboard passedPawns[2];
   Bitboard pawnAttacks[2];
   Square kingSquares[2];
   Score value;
-  int16_t ksStormValue[2], qsStormValue[2];
+  int halfOpenFiles[2];
-  uint8_t halfOpenFiles[2];
+  Score kingShelters[2];
-  uint8_t kingShelters[2];
 };
 
 /// The PawnInfoTable class represents a pawn hash table.  It is basically
@@ -81,18 +79,15 @@ class PawnInfoTable {
   enum SideType { KingSide, QueenSide };
 
 public:
-  PawnInfoTable(unsigned numOfEntries);
+  PawnInfoTable();
   ~PawnInfoTable();
   PawnInfo* get_pawn_info(const Position& pos) const;
+  void prefetch(Key key) const;
 
 private:
   template<Color Us>
   Score evaluate_pawns(const Position& pos, Bitboard ourPawns, Bitboard theirPawns, PawnInfo* pi) const;
 
-  template<Color Us, SideType Side>
-  int evaluate_pawn_storm(Square s, Rank r, File f, Bitboard theirPawns) const;
-
-  unsigned size;
   PawnInfo* entries;
 };
 
@@ -101,24 +96,23 @@ private:
 //// Inline functions
 ////
 
-inline Score PawnInfo::pawns_value() const {
+inline void PawnInfoTable::prefetch(Key key) const {
-  return value;
+
+    unsigned index = unsigned(key & (PawnTableSize - 1));
+    PawnInfo* pi = entries + index;
+    ::prefetch((char*) pi);
 }
 
-inline Bitboard PawnInfo::passed_pawns() const {
+inline Score PawnInfo::pawns_value() const {
-  return passedPawns;
+  return value;
 }
 
 inline Bitboard PawnInfo::pawn_attacks(Color c) const {
   return pawnAttacks[c];
 }
 
-inline Value PawnInfo::kingside_storm_value(Color c) const {
+inline Bitboard PawnInfo::passed_pawns(Color c) const {
-  return Value(ksStormValue[c]);
+  return passedPawns[c];
-}
-
-inline Value PawnInfo::queenside_storm_value(Color c) const {
-  return Value(qsStormValue[c]);
 }
 
 inline int PawnInfo::file_is_half_open(Color c, File f) const {
@@ -133,8 +127,34 @@ inline int PawnInfo::has_open_file_to_right(Color c, File f) const {
   return halfOpenFiles[c] & ~((1 << int(f+1)) - 1);
 }
 
-inline int PawnInfo::get_king_shelter(const Position& pos, Color c, Square ksq) {
+/// PawnInfo::updateShelter() calculates and caches king shelter. It is called
-  return (kingSquares[c] == ksq ? kingShelters[c] : updateShelter(pos, c, ksq));
+/// only when king square changes, about 20% of total king_shelter() calls.
+template<Color Us>
+Score PawnInfo::updateShelter(const Position& pos, Square ksq) {
+
+  const int Shift = (Us == WHITE ? 8 : -8);
+
+  Bitboard pawns;
+  int r, shelter = 0;
+
+  if (relative_rank(Us, ksq) <= RANK_4)
+  {
+      pawns = pos.pieces(PAWN, Us) & this_and_neighboring_files_bb(ksq);
+      r = square_rank(ksq) * 8;
+      for (int i = 1; i < 4; i++)
+      {
+          r += Shift;
+          shelter += BitCount8Bit[(pawns >> r) & 0xFF] * (128 >> i);
+      }
+  }
+  kingSquares[Us] = ksq;
+  kingShelters[Us] = make_score(shelter, 0);
+  return kingShelters[Us];
+}
+
+template<Color Us>
+inline Score PawnInfo::king_shelter(const Position& pos, Square ksq) {
+  return kingSquares[Us] == ksq ? kingShelters[Us] : updateShelter<Us>(pos, ksq);
 }
 
 #endif // !defined(PAWNS_H_INCLUDED)

src/piece.cpp

@@ -28,6 +28,33 @@
 
 using namespace std;
 
+// Tables indexed by Piece
+
+const Value PieceValueMidgame[17] = {
+  VALUE_ZERO,
+  PawnValueMidgame, KnightValueMidgame, BishopValueMidgame,
+  RookValueMidgame, QueenValueMidgame,
+  VALUE_ZERO, VALUE_ZERO, VALUE_ZERO,
+  PawnValueMidgame, KnightValueMidgame, BishopValueMidgame,
+  RookValueMidgame, QueenValueMidgame,
+  VALUE_ZERO, VALUE_ZERO, VALUE_ZERO
+};
+
+const Value PieceValueEndgame[17] = {
+  VALUE_ZERO,
+  PawnValueEndgame, KnightValueEndgame, BishopValueEndgame,
+  RookValueEndgame, QueenValueEndgame,
+  VALUE_ZERO, VALUE_ZERO, VALUE_ZERO,
+  PawnValueEndgame, KnightValueEndgame, BishopValueEndgame,
+  RookValueEndgame, QueenValueEndgame,
+  VALUE_ZERO, VALUE_ZERO, VALUE_ZERO
+};
+
+const int SlidingArray[18] = {
+  0, 0, 0, 1, 2, 3, 0, 0, 0, 0, 0, 1, 2, 3, 0, 0, 0, 0
+};
+
+
 ////
 //// Functions
 ////
@@ -45,5 +72,5 @@ PieceType piece_type_from_char(char c) {
 
   size_t idx = PieceChars.find(c);
 
-  return idx != string::npos ? PieceType(idx % 7) : NO_PIECE_TYPE;
+  return idx != string::npos ? PieceType(idx % 7) : PIECE_TYPE_NONE;
 }

src/piece.h

@@ -27,6 +27,7 @@
 
 #include "color.h"
 #include "square.h"
+#include "value.h"
 
 
 ////
@@ -34,39 +35,49 @@
 ////
 
 enum PieceType {
-  NO_PIECE_TYPE = 0,
+  PIECE_TYPE_NONE = 0,
   PAWN = 1, KNIGHT = 2, BISHOP = 3, ROOK = 4, QUEEN = 5, KING = 6
 };
 
 enum Piece {
-  NO_PIECE = 0, WP = 1, WN = 2, WB = 3, WR = 4, WQ = 5, WK = 6,
+  PIECE_NONE_DARK_SQ = 0, WP = 1, WN = 2, WB = 3, WR = 4, WQ = 5, WK = 6,
-  BP = 9, BN = 10, BB = 11, BR = 12, BQ = 13, BK = 14,
+  BP = 9, BN = 10, BB = 11, BR = 12, BQ = 13, BK = 14, PIECE_NONE = 16
-  EMPTY = 16, OUTSIDE = 17
 };
 
+ENABLE_OPERATORS_ON(PieceType);
+ENABLE_OPERATORS_ON(Piece);
+
 
 ////
 //// Constants
 ////
 
-const int SlidingArray[18] = {
+/// Important: If the material values are changed, one must also
-  0, 0, 0, 1, 2, 3, 0, 0, 0, 0, 0, 1, 2, 3, 0, 0, 0, 0
+/// adjust the piece square tables, and the method game_phase() in the
-};
+/// Position class!
+///
+/// Values modified by Joona Kiiski
+
+const Value PawnValueMidgame   = Value(0x0C6);
+const Value PawnValueEndgame   = Value(0x102);
+const Value KnightValueMidgame = Value(0x331);
+const Value KnightValueEndgame = Value(0x34E);
+const Value BishopValueMidgame = Value(0x344);
+const Value BishopValueEndgame = Value(0x359);
+const Value RookValueMidgame   = Value(0x4F6);
+const Value RookValueEndgame   = Value(0x4FE);
+const Value QueenValueMidgame  = Value(0x9D9);
+const Value QueenValueEndgame  = Value(0x9FE);
+
+extern const Value PieceValueMidgame[17];
+extern const Value PieceValueEndgame[17];
+extern const int SlidingArray[18];
 
 
 ////
 //// Inline functions
 ////
 
-inline Piece operator+ (Piece p, int i) { return Piece(int(p) + i); }
-inline void operator++ (Piece &p, int) { p = Piece(int(p) + 1); }
-inline Piece operator- (Piece p, int i) { return Piece(int(p) - i); }
-inline void operator-- (Piece &p, int) { p = Piece(int(p) - 1); }
-inline PieceType operator+ (PieceType p, int i) {return PieceType(int(p) + i);}
-inline void operator++ (PieceType &p, int) { p = PieceType(int(p) + 1); }
-inline PieceType operator- (PieceType p, int i) {return PieceType(int(p) - i);}
-inline void operator-- (PieceType &p, int) { p = PieceType(int(p) - 1); }
-
 inline PieceType type_of_piece(Piece p)  {
   return PieceType(int(p) & 7);
 }
@@ -80,7 +91,7 @@ inline Piece piece_of_color_and_type(Color c, PieceType pt) {
 }
 
 inline int piece_is_slider(Piece p) {
-  return SlidingArray[int(p)];
+  return SlidingArray[p];
 }
 
 inline SquareDelta pawn_push(Color c) {

src/position.h

@@ -50,9 +50,6 @@
 //// Constants
 ////
 
-/// FEN string for the initial position
-const std::string StartPosition = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
-
 /// Maximum number of plies per game (220 should be enough, because the
 /// maximum search depth is 100, and during position setup we reset the
 /// move counter for every non-reversible move).
@@ -78,12 +75,12 @@ struct CheckInfo {
 /// Castle rights, encoded as bit fields
 
 enum CastleRights {
-  NO_CASTLES  = 0,
+  CASTLES_NONE = 0,
-  WHITE_OO    = 1,
+  WHITE_OO     = 1,
-  BLACK_OO    = 2,
+  BLACK_OO     = 2,
-  WHITE_OOO   = 4,
+  WHITE_OOO    = 4,
-  BLACK_OOO   = 8,
+  BLACK_OOO    = 8,
-  ALL_CASTLES = 15
+  ALL_CASTLES  = 15
 };
 
 /// Game phase
@@ -105,7 +102,7 @@ struct StateInfo {
   Score value;
   Value npMaterial[2];
 
-  PieceType capture;
+  PieceType capturedType;
   Key key;
   Bitboard checkersBB;
   StateInfo* previous;
@@ -227,7 +224,7 @@ public:
   bool move_attacks_square(Move m, Square s) const;
 
   // Piece captured with previous moves
-  PieceType captured_piece() const;
+  PieceType captured_piece_type() const;
 
   // Information about pawns
   bool pawn_is_passed(Color c, Square s) const;
@@ -246,7 +243,6 @@ public:
   // Static exchange evaluation
   int see(Square from, Square to) const;
   int see(Move m) const;
-  int see(Square to) const;
   int see_sign(Move m) const;
 
   // Accessing hash keys
@@ -258,21 +254,24 @@ public:
   // Incremental evaluation
   Score value() const;
   Value non_pawn_material(Color c) const;
-  Score pst_delta(Piece piece, Square from, Square to) const;
+  static Score pst_delta(Piece piece, Square from, Square to);
 
   // Game termination checks
   bool is_mate() const;
   bool is_draw() const;
 
-  // Check if one side threatens a mate in one
+  // Check if side to move could be mated in one
-  bool has_mate_threat(Color c);
+  bool has_mate_threat();
 
   // Number of plies since the last non-reversible move
   int rule_50_counter() const;
 
+  int startpos_ply_counter() const;
+
   // Other properties of the position
   bool opposite_colored_bishops() const;
   bool has_pawn_on_7th(Color c) const;
+  bool is_chess960() const;
 
   // Current thread ID searching on the position
   int thread() const;
@@ -280,6 +279,8 @@ public:
   // Reset the gamePly variable to 0
   void reset_game_ply();
 
+  void inc_startpos_ply_counter();
+
   // Position consistency check, for debugging
   bool is_ok(int* failedStep = NULL) const;
 
@@ -294,6 +295,7 @@ private:
   void put_piece(Piece p, Square s);
   void allow_oo(Color c);
   void allow_ooo(Color c);
+  bool set_castling_rights(char token);
 
   // Helper functions for doing and undoing moves
   void do_capture_move(Key& key, PieceType capture, Color them, Square to, bool ep);
@@ -310,7 +312,7 @@ private:
   Key compute_material_key() const;
 
   // Computing incremental evaluation scores and material counts
-  Score pst(Color c, PieceType pt, Square s) const;
+  static Score pst(Color c, PieceType pt, Square s);
   Score compute_value() const;
   Value compute_non_pawn_material(Color c) const;
 
@@ -333,6 +335,8 @@ private:
   int castleRightsMask[64];
   StateInfo startState;
   File initialKFile, initialKRFile, initialQRFile;
+  bool isChess960;
+  int startPosPlyCounter;
   int threadID;
   StateInfo* st;
 
@@ -343,6 +347,7 @@ private:
   static Key zobSideToMove;
   static Score PieceSquareTable[16][64];
   static Key zobExclusion;
+  static const Value seeValues[8];
 };
 
 
@@ -363,7 +368,7 @@ inline PieceType Position::type_of_piece_on(Square s) const {
 }
 
 inline bool Position::square_is_empty(Square s) const {
-  return piece_on(s) == EMPTY;
+  return piece_on(s) == PIECE_NONE;
 }
 
 inline bool Position::square_is_occupied(Square s) const {
@@ -371,11 +376,11 @@ inline bool Position::square_is_occupied(Square s) const {
 }
 
 inline Value Position::midgame_value_of_piece_on(Square s) const {
-  return piece_value_midgame(piece_on(s));
+  return PieceValueMidgame[piece_on(s)];
 }
 
 inline Value Position::endgame_value_of_piece_on(Square s) const {
-  return piece_value_endgame(piece_on(s));
+  return PieceValueEndgame[piece_on(s)];
 }
 
 inline Color Position::side_to_move() const {
@@ -507,11 +512,11 @@ inline Key Position::get_material_key() const {
   return st->materialKey;
 }
 
-inline Score Position::pst(Color c, PieceType pt, Square s) const {
+inline Score Position::pst(Color c, PieceType pt, Square s) {
   return PieceSquareTable[piece_of_color_and_type(c, pt)][s];
 }
 
-inline Score Position::pst_delta(Piece piece, Square from, Square to) const {
+inline Score Position::pst_delta(Piece piece, Square from, Square to) {
   return PieceSquareTable[piece][to] - PieceSquareTable[piece][from];
 }
 
@@ -535,11 +540,16 @@ inline int Position::rule_50_counter() const {
   return st->rule50;
 }
 
+inline int Position::startpos_ply_counter() const {
+
+  return startPosPlyCounter;
+}
+
 inline bool Position::opposite_colored_bishops() const {
 
   return   piece_count(WHITE, BISHOP) == 1
         && piece_count(BLACK, BISHOP) == 1
-        && square_color(piece_list(WHITE, BISHOP, 0)) != square_color(piece_list(BLACK, BISHOP, 0));
+        && !same_color_squares(piece_list(WHITE, BISHOP, 0), piece_list(BLACK, BISHOP, 0));
 }
 
 inline bool Position::has_pawn_on_7th(Color c) const {
@@ -547,6 +557,11 @@ inline bool Position::has_pawn_on_7th(Color c) const {
   return pieces(PAWN, c) & relative_rank_bb(c, RANK_7);
 }
 
+inline bool Position::is_chess960() const {
+
+  return isChess960;
+}
+
 inline bool Position::move_is_capture(Move m) const {
 
   // Move must not be MOVE_NONE !
@@ -559,8 +574,8 @@ inline bool Position::move_is_capture_or_promotion(Move m) const {
   return (m & (0x1F << 12)) ? !move_is_castle(m) : !square_is_empty(move_to(m));
 }
 
-inline PieceType Position::captured_piece() const {
+inline PieceType Position::captured_piece_type() const {
-  return st->capture;
+  return st->capturedType;
 }
 
 inline int Position::thread() const {

src/san.cpp

@@ -138,7 +138,7 @@ Move move_from_san(const Position& pos, const string& movestr) {
 
   assert(pos.is_ok());
 
-  MovePicker mp = MovePicker(pos, MOVE_NONE, OnePly, H);
+  MovePicker mp = MovePicker(pos, MOVE_NONE, ONE_PLY, H);
   Bitboard pinned = pos.pinned_pieces(pos.side_to_move());
 
   // Castling moves
@@ -164,7 +164,7 @@ Move move_from_san(const Position& pos, const string& movestr) {
   // Normal moves. We use a simple FSM to parse the san string.
   enum { START, TO_FILE, TO_RANK, PROMOTION_OR_CHECK, PROMOTION, CHECK, END };
   static const string pieceLetters = "KQRBN";
-  PieceType pt = NO_PIECE_TYPE, promotion = NO_PIECE_TYPE;
+  PieceType pt = PIECE_TYPE_NONE, promotion = PIECE_TYPE_NONE;
   File fromFile = FILE_NONE, toFile = FILE_NONE;
   Rank fromRank = RANK_NONE, toRank = RANK_NONE;
   Square to;
@@ -368,7 +368,7 @@ namespace {
     if (type_of_piece(pc) == KING)
         return AMBIGUITY_NONE;
 
-    MovePicker mp = MovePicker(pos, MOVE_NONE, OnePly, H);
+    MovePicker mp = MovePicker(pos, MOVE_NONE, ONE_PLY, H);
     Bitboard pinned = pos.pinned_pieces(pos.side_to_move());
     Move mv, moveList[8];
 

src/search.h

@@ -36,7 +36,6 @@
 
 const int PLY_MAX = 100;
 const int PLY_MAX_PLUS_2 = 102;
-const int KILLER_MAX = 2;
 
 
 ////
@@ -52,16 +51,12 @@ struct EvalInfo;
 struct SearchStack {
   Move currentMove;
   Move mateKiller;
-  Move threatMove;
   Move excludedMove;
   Move bestMove;
-  Move killers[KILLER_MAX];
+  Move killers[2];
   Depth reduction;
   Value eval;
   bool skipNullMove;
-
-  void init();
-  void initKillers();
 };
 
 
@@ -72,11 +67,9 @@ struct SearchStack {
 extern void init_search();
 extern void init_threads();
 extern void exit_threads();
-extern bool think(const Position &pos, bool infinite, bool ponder, int side_to_move,
+extern int perft(Position& pos, Depth depth);
-                  int time[], int increment[], int movesToGo, int maxDepth,
-                  int maxNodes, int maxTime, Move searchMoves[]);
-extern int perft(Position &pos, Depth depth);
 extern int64_t nodes_searched();
-
+extern bool think(const Position& pos, bool infinite, bool ponder, int time[], int increment[],
+                  int movesToGo, int maxDepth, int maxNodes, int maxTime, Move searchMoves[]);
 
 #endif // !defined(SEARCH_H_INCLUDED)

src/square.h

@@ -64,6 +64,11 @@ enum SquareDelta {
   DELTA_NN = 020, DELTA_NNE = 021
 };
 
+ENABLE_OPERATORS_ON(Square);
+ENABLE_OPERATORS_ON(File);
+ENABLE_OPERATORS_ON(Rank);
+ENABLE_OPERATORS_ON(SquareDelta);
+
 
 ////
 //// Constants
@@ -77,35 +82,10 @@ const int FlopMask = 07;
 //// Inline functions
 ////
 
-inline File operator+ (File x, int i) { return File(int(x) + i); }
+inline Square operator+ (Square x, SquareDelta i) { return x + Square(i); }
-inline File operator+ (File x, File y) { return x + int(y); }
+inline void operator+= (Square& x, SquareDelta i) { x = x + Square(i); }
-inline void operator++ (File &x, int) { x = File(int(x) + 1); }
+inline Square operator- (Square x, SquareDelta i) { return x - Square(i); }
-inline void operator+= (File &x, int i) { x = File(int(x) + i); }
+inline void operator-= (Square& x, SquareDelta i) { x = x - Square(i); }
-inline File operator- (File x, int i) { return File(int(x) - i); }
-inline void operator-- (File &x, int) { x = File(int(x) - 1); }
-inline void operator-= (File &x, int i) { x = File(int(x) - i); }
-
-inline Rank operator+ (Rank x, int i) { return Rank(int(x) + i); }
-inline Rank operator+ (Rank x, Rank y) { return x + int(y); }
-inline void operator++ (Rank &x, int) { x = Rank(int(x) + 1); }
-inline void operator+= (Rank &x, int i) { x = Rank(int(x) + i); }
-inline Rank operator- (Rank x, int i) { return Rank(int(x) - i); }
-inline void operator-- (Rank &x, int) { x = Rank(int(x) - 1); }
-inline void operator-= (Rank &x, int i) { x = Rank(int(x) - i); }
-
-inline Square operator+ (Square x, int i) { return Square(int(x) + i); }
-inline void operator++ (Square &x, int) { x = Square(int(x) + 1); }
-inline void operator+= (Square &x, int i) { x = Square(int(x) + i); }
-inline Square operator- (Square x, int i) { return Square(int(x) - i); }
-inline void operator-- (Square &x, int) { x = Square(int(x) - 1); }
-inline void operator-= (Square &x, int i) { x = Square(int(x) - i); }
-inline Square operator+ (Square x, SquareDelta i) { return Square(int(x) + i); }
-inline void operator+= (Square &x, SquareDelta i) { x = Square(int(x) + i); }
-inline Square operator- (Square x, SquareDelta i) { return Square(int(x) - i); }
-inline void operator-= (Square &x, SquareDelta i) { x = Square(int(x) - i); }
-inline SquareDelta operator- (Square x, Square y) {
-  return SquareDelta(int(x) - int(y));
-}
 
 inline Square make_square(File f, Rank r) {
   return Square(int(f) | (int(r) << 3));
@@ -135,8 +115,13 @@ inline Rank relative_rank(Color c, Square s) {
   return square_rank(relative_square(c, s));
 }
 
-inline Color square_color(Square s) {
+inline SquareColor square_color(Square s) {
-  return Color((int(square_file(s)) + int(square_rank(s))) & 1);
+  return SquareColor((int(square_file(s)) + int(square_rank(s))) & 1);
+}
+
+inline bool same_color_squares(Square s1, Square s2) {
+  int s = int(s1) ^ int(s2);
+  return (((s >> 3) ^ s) & 1) == 0;
 }
 
 inline int file_distance(File f1, File f2) {
@@ -180,10 +165,8 @@ inline Square square_from_string(const std::string& str) {
 }
 
 inline const std::string square_to_string(Square s) {
-  std::string str;
+  return  std::string(1, file_to_char(square_file(s)))
-  str += file_to_char(square_file(s));
+        + std::string(1, rank_to_char(square_rank(s)));
-  str += rank_to_char(square_rank(s));
-  return str;
 }
 
 inline bool file_is_ok(File f) {

src/thread.h

@@ -39,7 +39,7 @@
 ////
 
 const int MAX_THREADS = 8;
-const int ACTIVE_SPLIT_POINTS_MAX = 8;
+const int MAX_ACTIVE_SPLIT_POINTS = 8;
 
 
 ////
@@ -55,6 +55,7 @@ struct SplitPoint {
   bool pvNode, mateThreat;
   Value beta;
   int ply;
+  Move threatMove;
   SearchStack sstack[MAX_THREADS][PLY_MAX_PLUS_2];
 
   // Const pointers to shared data
@@ -83,12 +84,11 @@ enum ThreadState
 };
 
 struct Thread {
+  uint64_t nodes;
+  volatile ThreadState state;
   SplitPoint* volatile splitPoint;
   volatile int activeSplitPoints;
-  uint64_t nodes;
+  SplitPoint splitPoints[MAX_ACTIVE_SPLIT_POINTS];
-  uint64_t betaCutOffs[2];
-  volatile ThreadState state;
-  unsigned char pad[64]; // set some distance among local data for each thread
 };
 
 

src/timeman.cpp

@@ -0,0 +1,170 @@
+/*
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
+
+  Stockfish is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  Stockfish is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+
+////
+//// Includes
+////
+
+#include <cmath>
+
+#include "misc.h"
+#include "timeman.h"
+#include "ucioption.h"
+
+////
+//// Local definitions
+////
+
+namespace {
+
+  /// Constants
+
+  const int MoveHorizon  = 50;    // Plan time management at most this many moves ahead
+  const float MaxRatio   = 3.0f;  // When in trouble, we can step over reserved time with this ratio
+  const float StealRatio = 0.33f; // However we must not steal time from remaining moves over this ratio
+
+
+  // MoveImportance[] is based on naive statistical analysis of "how many games are still undecided
+  // after n half-moves". Game is considered "undecided" as long as neither side has >275cp advantage.
+  // Data was extracted from CCRL game database with some simple filtering criteria.
+  const int MoveImportance[512] = {
+    7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780, 7780,
+    7780, 7780, 7780, 7780, 7778, 7778, 7776, 7776, 7776, 7773, 7770, 7768, 7766, 7763, 7757, 7751,
+    7743, 7735, 7724, 7713, 7696, 7689, 7670, 7656, 7627, 7605, 7571, 7549, 7522, 7493, 7462, 7425,
+    7385, 7350, 7308, 7272, 7230, 7180, 7139, 7094, 7055, 7010, 6959, 6902, 6841, 6778, 6705, 6651,
+    6569, 6508, 6435, 6378, 6323, 6253, 6152, 6085, 5995, 5931, 5859, 5794, 5717, 5646, 5544, 5462,
+    5364, 5282, 5172, 5078, 4988, 4901, 4831, 4764, 4688, 4609, 4536, 4443, 4365, 4293, 4225, 4155,
+    4085, 4005, 3927, 3844, 3765, 3693, 3634, 3560, 3479, 3404, 3331, 3268, 3207, 3146, 3077, 3011,
+    2947, 2894, 2828, 2776, 2727, 2676, 2626, 2589, 2538, 2490, 2442, 2394, 2345, 2302, 2243, 2192,
+    2156, 2115, 2078, 2043, 2004, 1967, 1922, 1893, 1845, 1809, 1772, 1736, 1702, 1674, 1640, 1605,
+    1566, 1536, 1509, 1479, 1452, 1423, 1388, 1362, 1332, 1304, 1289, 1266, 1250, 1228, 1206, 1180,
+    1160, 1134, 1118, 1100, 1080, 1068, 1051, 1034, 1012, 1001, 980, 960, 945, 934, 916, 900, 888,
+    878, 865, 852, 828, 807, 787, 770, 753, 744, 731, 722, 706, 700, 683, 676, 671, 664, 652, 641,
+    634, 627, 613, 604, 591, 582, 568, 560, 552, 540, 534, 529, 519, 509, 495, 484, 474, 467, 460,
+    450, 438, 427, 419, 410, 406, 399, 394, 387, 382, 377, 372, 366, 359, 353, 348, 343, 337, 333,
+    328, 321, 315, 309, 303, 298, 293, 287, 284, 281, 277, 273, 265, 261, 255, 251, 247, 241, 240,
+    235, 229, 218, 217, 213, 212, 208, 206, 197, 193, 191, 189, 185, 184, 180, 177, 172, 170, 170,
+    170, 166, 163, 159, 158, 156, 155, 151, 146, 141, 138, 136, 132, 130, 128, 125, 123, 122, 118,
+    118, 118, 117, 115, 114, 108, 107, 105, 105, 105, 102, 97, 97, 95, 94, 93, 91, 88, 86, 83, 80,
+    80, 79, 79, 79, 78, 76, 75, 72, 72, 71, 70, 68, 65, 63, 61, 61, 59, 59, 59, 58, 56, 55, 54, 54,
+    52, 49, 48, 48, 48, 48, 45, 45, 45, 44, 43, 41, 41, 41, 41, 40, 40, 38, 37, 36, 34, 34, 34, 33,
+    31, 29, 29, 29, 28, 28, 28, 28, 28, 28, 28, 27, 27, 27, 27, 27, 24, 24, 23, 23, 22, 21, 20, 20,
+    19, 19, 19, 19, 19, 18, 18, 18, 18, 17, 17, 17, 17, 17, 16, 16, 15, 15, 14, 14, 14, 12, 12, 11,
+    9, 9, 9, 9, 9, 9, 9, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+    8, 8, 8, 8, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+    4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 2, 2, 2, 2,
+    2, 1, 1, 1, 1, 1, 1, 1 };
+
+  int move_importance(int ply) { return MoveImportance[Min(ply, 511)]; }
+
+
+  /// Function Prototypes
+
+  enum TimeType { OptimumTime, MaxTime };
+
+  template<TimeType>
+  int remaining(int myTime, int movesToGo, int currentPly);
+}
+
+
+////
+//// Functions
+////
+
+void TimeManager::pv_unstability(int curChanges, int prevChanges) {
+
+    unstablePVExtraTime =  curChanges  * (optimumSearchTime / 2)
+                         + prevChanges * (optimumSearchTime / 3);
+}
+
+void TimeManager::init(int myTime, int myInc, int movesToGo, int currentPly)
+{
+  /* We support four different kind of time controls:
+
+      Inc == 0 && movesToGo == 0 means: x basetime  [sudden death!]
+      Inc == 0 && movesToGo != 0 means: (x moves) / (y minutes)
+      Inc > 0  && movesToGo == 0 means: x basetime + z inc.
+      Inc > 0  && movesToGo != 0 means: (x moves) / (y minutes) + z inc
+
+    Time management is adjusted by following UCI parameters:
+
+      emergencyMoveHorizon :Be prepared to always play at least this many moves
+      emergencyBaseTime    :Always attempt to keep at least this much time (in ms) at clock
+      emergencyMoveTime    :Plus attempt to keep at least this much time for each remaining emergency move
+      minThinkingTime      :No matter what, use at least this much thinking before doing the move
+  */
+
+  int hypMTG, hypMyTime, t1, t2;
+
+  // Read uci parameters
+  int emergencyMoveHorizon = get_option_value_int("Emergency Move Horizon");
+  int emergencyBaseTime    = get_option_value_int("Emergency Base Time");
+  int emergencyMoveTime    = get_option_value_int("Emergency Move Time");
+  int minThinkingTime      = get_option_value_int("Minimum Thinking Time");
+
+  // Initialize to maximum values but unstablePVExtraTime that is reset
+  unstablePVExtraTime = 0;
+  optimumSearchTime = maximumSearchTime = myTime;
+
+  // We calculate optimum time usage for different hypothetic "moves to go"-values and choose the
+  // minimum of calculated search time values. Usually the greatest hypMTG gives the minimum values.
+  for (hypMTG = 1; hypMTG <= (movesToGo ? Min(movesToGo, MoveHorizon) : MoveHorizon); hypMTG++)
+  {
+      // Calculate thinking time for hypothetic "moves to go"-value
+      hypMyTime = Max(myTime + (hypMTG - 1) * myInc - emergencyBaseTime - Min(hypMTG, emergencyMoveHorizon) * emergencyMoveTime, 0);
+
+      t1 = minThinkingTime + remaining<OptimumTime>(hypMyTime, hypMTG, currentPly);
+      t2 = minThinkingTime + remaining<MaxTime>(hypMyTime, hypMTG, currentPly);
+
+      optimumSearchTime = Min(optimumSearchTime, t1);
+      maximumSearchTime = Min(maximumSearchTime, t2);
+  }
+
+  if (get_option_value_bool("Ponder"))
+      optimumSearchTime += optimumSearchTime / 4;
+
+  // Make sure that maxSearchTime is not over absoluteMaxSearchTime
+  optimumSearchTime = Min(optimumSearchTime, maximumSearchTime);
+}
+
+////
+//// Local functions
+////
+
+namespace {
+
+  template<TimeType T>
+  int remaining(int myTime, int movesToGo, int currentPly)
+  {
+    const float TMaxRatio   = (T == OptimumTime ? 1 : MaxRatio);
+    const float TStealRatio = (T == OptimumTime ? 0 : StealRatio);
+
+    int thisMoveImportance = move_importance(currentPly);
+    int otherMovesImportance = 0;
+
+    for (int i = 1; i < movesToGo; i++)
+        otherMovesImportance += move_importance(currentPly + 2 * i);
+
+    float ratio1 = (TMaxRatio * thisMoveImportance) / float(TMaxRatio * thisMoveImportance + otherMovesImportance);
+    float ratio2 = (thisMoveImportance + TStealRatio * otherMovesImportance) / float(thisMoveImportance + otherMovesImportance);
+
+    return int(floor(myTime * Min(ratio1, ratio2)));
+  }
+}

src/timeman.h

@@ -18,35 +18,25 @@
 */
 
 
-#if !defined(SCALE_H_INCLUDED)
+#if !defined(TIMEMAN_H_INCLUDED)
-#define SCALE_H_INCLUDED
+#define TIMEMAN_H_INCLUDED
 
 ////
-//// Includes
+//// Prototypes
 ////
 
-#include "value.h"
+class TimeManager {
+public:
 
+  void init(int myTime, int myInc, int movesToGo, int currentPly);
+  void pv_unstability(int curChanges, int prevChanges);
+  int available_time() const { return optimumSearchTime + unstablePVExtraTime; }
+  int maximum_time() const { return maximumSearchTime; }
 
-////
+private:
-//// Types
+  int optimumSearchTime;
-////
+  int maximumSearchTime;
-
+  int unstablePVExtraTime;
-enum ScaleFactor {
-  SCALE_FACTOR_ZERO = 0,
-  SCALE_FACTOR_NORMAL = 64,
-  SCALE_FACTOR_MAX = 128,
-  SCALE_FACTOR_NONE = 255
 };
 
-
+#endif // !defined(TIMEMAN_H_INCLUDED)
-////
-//// Inline functions
-////
-
-inline Value apply_scale_factor(Value v, ScaleFactor f) {
-  return Value((v * f) / int(SCALE_FACTOR_NORMAL));
-}
-
-
-#endif // !defined(SCALE_H_INCLUDED)

src/tt.cpp

@@ -23,10 +23,8 @@
 ////
 
 #include <cassert>
-#include <cmath>
 #include <cstring>
 
-#include "movegen.h"
 #include "tt.h"
 
 // The main transposition table
@@ -38,7 +36,7 @@ TranspositionTable TT;
 
 TranspositionTable::TranspositionTable() {
 
-  size = overwrites = 0;
+  size = 0;
   entries = 0;
   generation = 0;
 }
@@ -56,8 +54,10 @@ void TranspositionTable::set_size(size_t mbSize) {
 
   size_t newSize = 1024;
 
-  // We store a cluster of ClusterSize number of TTEntry for each position
+  // Transposition table consists of clusters and
-  // and newSize is the maximum number of storable positions.
+  // each cluster consists of ClusterSize number of TTEntries.
+  // Each non-empty entry contains information of exactly one position.
+  // newSize is the number of clusters we are going to allocate.
   while ((2 * newSize) * sizeof(TTCluster) <= (mbSize << 20))
       newSize *= 2;
 
@@ -72,7 +72,6 @@ void TranspositionTable::set_size(size_t mbSize) {
                     << " MB for transposition table." << std::endl;
           Application::exit_with_failure();
       }
-      clear();
   }
 }
 
@@ -80,7 +79,7 @@ void TranspositionTable::set_size(size_t mbSize) {
 /// TranspositionTable::clear overwrites the entire transposition table
 /// with zeroes. It is called whenever the table is resized, or when the
 /// user asks the program to clear the table (from the UCI interface).
-/// Perhaps we should also clear it when the "ucinewgame" command is recieved?
+/// Perhaps we should also clear it when the "ucinewgame" command is received?
 
 void TranspositionTable::clear() {
 
@@ -88,15 +87,15 @@ void TranspositionTable::clear() {
 }
 
 
-/// TranspositionTable::store writes a new entry containing a position,
+/// TranspositionTable::store writes a new entry containing position key and
-/// a value, a value type, a search depth, and a best move to the
+/// valuable information of current position.
-/// transposition table. Transposition table is organized in clusters of
+/// The Lowest order bits of position key are used to decide on which cluster
-/// four TTEntry objects, and when a new entry is written, it replaces
+/// the position will be placed.
-/// the least valuable of the four entries in a cluster. A TTEntry t1 is
+/// When a new entry is written and there are no empty entries available in cluster,
-/// considered to be more valuable than a TTEntry t2 if t1 is from the
+/// it replaces the least valuable of entries.
+/// A TTEntry t1 is considered to be 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. A TTEntry of type VALUE_TYPE_EVAL
+/// is bigger than the depth of t2.
-/// never replaces another entry for the same position.
 
 void TranspositionTable::store(const Key posKey, Value v, ValueType t, Depth d, Move m, Value statV, Value kingD) {
 
@@ -109,7 +108,7 @@ void TranspositionTable::store(const Key posKey, Value v, ValueType t, Depth d,
   {
       if (!tte->key() || tte->key() == posKey32) // empty or overwrite old
       {
-          // Preserve any exsisting ttMove
+          // Preserve any existing ttMove
           if (m == MOVE_NONE)
               m = tte->move();
 
@@ -117,7 +116,7 @@ void TranspositionTable::store(const Key posKey, Value v, ValueType t, Depth d,
           return;
       }
 
-      if (i == 0)  // replace would be a no-op in this common case
+      if (i == 0)  // Replacing first entry is default and already set before entering for-loop
           continue;
 
       c1 = (replace->generation() == generation ?  2 : 0);
@@ -128,7 +127,6 @@ void TranspositionTable::store(const Key posKey, Value v, ValueType t, Depth d,
           replace = tte;
   }
   replace->save(posKey32, v, t, d, m, generation, statV, kingD);
-  overwrites++;
 }
 
 
@@ -155,72 +153,5 @@ TTEntry* TranspositionTable::retrieve(const Key posKey) const {
 /// entries from the current search.
 
 void TranspositionTable::new_search() {
-
   generation++;
-  overwrites = 0;
-}
-
-
-/// TranspositionTable::insert_pv() is called at the end of a search
-/// iteration, and inserts the PV back into the PV. This makes sure
-/// the old PV moves are searched first, even if the old TT entries
-/// have been overwritten.
-
-void TranspositionTable::insert_pv(const Position& pos, Move pv[]) {
-
-  StateInfo st;
-  Position p(pos, pos.thread());
-
-  for (int i = 0; pv[i] != MOVE_NONE; i++)
-  {
-      TTEntry *tte = retrieve(p.get_key());
-      if (!tte || tte->move() != pv[i])
-          store(p.get_key(), VALUE_NONE, VALUE_TYPE_NONE, Depth(-127*OnePly), pv[i], VALUE_NONE, VALUE_NONE);
-      p.do_move(pv[i], st);
-  }
-}
-
-
-/// TranspositionTable::extract_pv() extends a PV by adding moves from the
-/// transposition table at the end. This should ensure that the PV is almost
-/// always at least two plies long, which is important, because otherwise we
-/// will often get single-move PVs when the search stops while failing high,
-/// and a single-move PV means that we don't have a ponder move.
-
-void TranspositionTable::extract_pv(const Position& pos, Move bestMove, Move pv[], const int PLY_MAX) {
-
-  const TTEntry* tte;
-  StateInfo st;
-  Position p(pos, pos.thread());
-  int ply = 0;
-
-  assert(bestMove != MOVE_NONE);
-
-  pv[ply] = bestMove;
-  p.do_move(pv[ply++], st);
-
-  // Extract moves from TT when possible. We try hard to always
-  // get a ponder move, that's the reason of ply < 2 conditions.
-  while (   (tte = retrieve(p.get_key())) != NULL
-         && tte->move() != MOVE_NONE
-         && (tte->type() == VALUE_TYPE_EXACT || ply < 2)
-         && move_is_legal(p, tte->move())
-         && (!p.is_draw() || ply < 2)
-         && ply < PLY_MAX)
-  {
-      pv[ply] = tte->move();
-      p.do_move(pv[ply++], st);
-  }
-  pv[ply] = MOVE_NONE;
-}
-
-
-/// TranspositionTable::full() returns the permill of all transposition table
-/// entries which have received at least one overwrite during the current search.
-/// It is used to display the "info hashfull ..." information in UCI.
-
-int TranspositionTable::full() const {
-
-  double N = double(size) * ClusterSize;
-  return int(1000 * (1 - exp(overwrites * log(1.0 - 1.0/N))));
 }

src/tt.h

@@ -26,7 +26,7 @@
 ////
 
 #include "depth.h"
-#include "position.h"
+#include "move.h"
 #include "value.h"
 
 
@@ -36,18 +36,20 @@
 
 /// The TTEntry class is the class of transposition table entries
 ///
-/// A TTEntry needs 96 bits to be stored
+/// A TTEntry needs 128 bits to be stored
 ///
 /// bit  0-31: key
 /// bit 32-63: data
 /// bit 64-79: value
 /// bit 80-95: depth
+/// bit 96-111: static value
+/// bit 112-127: margin of static value
 ///
 /// the 32 bits of the data field are so defined
 ///
 /// bit  0-16: move
-/// bit 17-19: not used
+/// bit 17-20: not used
-/// bit 20-22: value type
+/// bit 21-22: value type
 /// bit 23-31: generation
 
 class TTEntry {
@@ -56,21 +58,21 @@ public:
   void save(uint32_t k, Value v, ValueType t, Depth d, Move m, int g, Value statV, Value kd) {
 
       key32 = k;
-      data = (m & 0x1FFFF) | (t << 20) | (g << 23);
+      data = (m & 0x1FFFF) | (t << 21) | (g << 23);
       value16     = int16_t(v);
       depth16     = int16_t(d);
       staticValue = int16_t(statV);
-      kingDanger  = int16_t(kd);
+      staticValueMargin  = int16_t(kd);
   }
 
   uint32_t key() const { return key32; }
   Depth depth() const { return Depth(depth16); }
   Move move() const { return Move(data & 0x1FFFF); }
   Value value() const { return Value(value16); }
-  ValueType type() const { return ValueType((data >> 20) & 7); }
+  ValueType type() const { return ValueType((data >> 21) & 3); }
   int generation() const { return data >> 23; }
   Value static_value() const { return Value(staticValue); }
-  Value king_danger() const { return Value(kingDanger); }
+  Value static_value_margin() const { return Value(staticValueMargin); }
 
 private:
   uint32_t key32;
@@ -78,17 +80,16 @@ private:
   int16_t value16;
   int16_t depth16;
   int16_t staticValue;
-  int16_t kingDanger;
+  int16_t staticValueMargin;
 };
 
 
-/// This is the number of TTEntry slots for each position
+/// This is the number of TTEntry slots for each cluster
 const int ClusterSize = 4;
 
-/// Each group of ClusterSize number of TTEntry form a TTCluster
+/// TTCluster consists of ClusterSize number of TTEntries.
-/// that is indexed by a single position key. TTCluster size must
+/// Size of TTCluster must not be bigger than a cache line size.
-///  be not bigger then a cache line size, in case it is less then
+/// In case it is less, it should be padded to guarantee always aligned accesses.
-/// it should be padded to guarantee always aligned accesses.
 
 struct TTCluster {
   TTEntry data[ClusterSize];
@@ -96,7 +97,7 @@ struct TTCluster {
 
 
 /// The transposition table class. This is basically just a huge array
-/// containing TTEntry objects, and a few methods for writing new entries
+/// containing TTCluster objects, and a few methods for writing new entries
 /// and reading new ones.
 
 class TranspositionTable {
@@ -109,18 +110,9 @@ public:
   void store(const Key posKey, Value v, ValueType type, Depth d, Move m, Value statV, Value kingD);
   TTEntry* retrieve(const Key posKey) const;
   void new_search();
-  void insert_pv(const Position& pos, Move pv[]);
-  void extract_pv(const Position& pos, Move bestMove, Move pv[], const int PLY_MAX);
-  int full() const;
   TTEntry* first_entry(const Key posKey) const;
 
 private:
-  // Be sure 'overwrites' is at least one cache line away
-  // from read only variables.
-  unsigned char pad_before[64 - sizeof(unsigned)];
-  unsigned overwrites; // heavy SMP read/write access here
-  unsigned char pad_after[64];
-
   size_t size;
   TTCluster* entries;
   uint8_t generation;
@@ -130,8 +122,8 @@ extern TranspositionTable TT;
 
 
 /// TranspositionTable::first_entry returns a pointer to the first
-/// entry of a cluster given a position. The low 32 bits of the key
+/// entry of a cluster given a position. The lowest order bits of the key
-/// are used to get the index in the table.
+/// are used to get the index of the cluster.
 
 inline TTEntry* TranspositionTable::first_entry(const Key posKey) const {
 

src/types.h

@@ -109,4 +109,64 @@ inline void __cpuid(int CPUInfo[4], int)
 }
 #endif
 
+
+// Templetized operators used by enum types like Depth, Piece, Square and so on.
+// We don't want to write the same inline for each different enum. Note that we
+// pass by value to silence scaring warnings when using volatiles.
+// Because these templates override common operators and are included in all the
+// files, there is a possibility that the compiler silently performs some unwanted
+// overrides. To avoid possible very nasty bugs the templates are disabled by default
+// and must be enabled for each type on a case by case base. The enabling trick
+// uses template specialization, namely we just declare following struct.
+template<typename T> struct TempletizedOperator;
+
+// Then to enable the enum type we use following macro that defines a specialization
+// of TempletizedOperator for the given enum T. Here is defined typedef Not_Enabled.
+// Name of typedef is chosen to produce somewhat informative compile error messages.
+#define ENABLE_OPERATORS_ON(T)  \
+        template<> struct TempletizedOperator<T> { typedef T Not_Enabled; }
+
+// Finally we use macro OK(T) to check if type T is enabled. The macro simply
+// tries to use Not_Enabled, if was not previously defined a compile error occurs.
+// The check is done fully at compile time and there is zero overhead at runtime.
+#define OK(T) typedef typename TempletizedOperator<T>::Not_Enabled Type
+
+template<typename T>
+inline T operator+ (const T d1, const T d2) { OK(T); return T(int(d1) + int(d2)); }
+
+template<typename T>
+inline T operator- (const T d1, const T d2) { OK(T); return T(int(d1) - int(d2)); }
+
+template<typename T>
+inline T operator* (int i, const T d) { OK(T); return T(i * int(d)); }
+
+template<typename T>
+inline T operator* (const T d, int i) { OK(T); return T(int(d) * i); }
+
+template<typename T>
+inline T operator/ (const T d, int i) { OK(T); return T(int(d) / i); }
+
+template<typename T>
+inline T operator- (const T d) { OK(T); return T(-int(d)); }
+
+template<typename T>
+inline void operator++ (T& d, int) { OK(T); d = T(int(d) + 1); }
+
+template<typename T>
+inline void operator-- (T& d, int) { OK(T); d = T(int(d) - 1); }
+
+template<typename T>
+inline void operator+= (T& d1, const T d2) { OK(T); d1 = d1 + d2; }
+
+template<typename T>
+inline void operator-= (T& d1, const T d2) { OK(T); d1 = d1 - d2; }
+
+template<typename T>
+inline void operator*= (T& d, int i) { OK(T); d = T(int(d) * i); }
+
+template<typename T>
+inline void operator/= (T& d, int i) { OK(T); d = T(int(d) / i); }
+
+#undef OK
+
 #endif // !defined(TYPES_H_INCLUDED)

src/uci.cpp

@@ -46,6 +46,9 @@ using namespace std;
 
 namespace {
 
+  // FEN string for the initial position
+  const string StartPositionFEN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
+
   // UCIInputParser is a class for parsing UCI input. The class
   // is actually a string stream built on a given input string.
 
@@ -79,7 +82,7 @@ namespace {
 
 void uci_main_loop() {
 
-  RootPosition.from_fen(StartPosition);
+  RootPosition.from_fen(StartPositionFEN);
   string command;
 
   do {
@@ -126,8 +129,7 @@ namespace {
     else if (token == "ucinewgame")
     {
         push_button("New Game");
-        Position::init_piece_square_tables();
+        RootPosition.from_fen(StartPositionFEN);
-        RootPosition.from_fen(StartPosition);
     }
     else if (token == "isready")
         cout << "readyok" << endl;
@@ -148,10 +150,10 @@ namespace {
     }
     else if (token == "eval")
     {
-        EvalInfo ei;
+        Value evalMargin;
-        cout << "Incremental mg: " << mg_value(RootPosition.value())
+        cout << "Incremental mg: "   << mg_value(RootPosition.value())
              << "\nIncremental eg: " << eg_value(RootPosition.value())
-             << "\nFull eval: " << evaluate(RootPosition, ei) << endl;
+             << "\nFull eval: "      << evaluate(RootPosition, evalMargin) << endl;
     }
     else if (token == "key")
         cout << "key: " << hex << RootPosition.get_key()
@@ -180,7 +182,7 @@ namespace {
         return;
 
     if (token == "startpos")
-        RootPosition.from_fen(StartPosition);
+        RootPosition.from_fen(StartPositionFEN);
     else if (token == "fen")
     {
         string fen;
@@ -207,9 +209,11 @@ namespace {
                 RootPosition.do_move(move, st);
                 if (RootPosition.rule_50_counter() == 0)
                     RootPosition.reset_game_ply();
+
+                RootPosition.inc_startpos_ply_counter(); //FIXME: make from_fen to support this and rule50
             }
             // Our StateInfo st is about going out of scope so copy
-            // its content inside RootPosition before they disappear.
+            // its content inside RootPosition before it disappears.
             RootPosition.detach();
         }
     }
@@ -300,8 +304,8 @@ namespace {
 
     assert(RootPosition.is_ok());
 
-    return think(RootPosition, infinite, ponder, RootPosition.side_to_move(),
+    return think(RootPosition, infinite, ponder, time, inc, movesToGo,
-                 time, inc, movesToGo, depth, nodes, moveTime, searchMoves);
+                 depth, nodes, moveTime, searchMoves);
   }
 
   void perft(UCIInputParser& uip) {
@@ -315,7 +319,7 @@ namespace {
 
     tm = get_system_time();
 
-    n = perft(pos, depth * OnePly);
+    n = perft(pos, depth * ONE_PLY);
 
     tm = get_system_time() - tm;
     std::cout << "\nNodes " << n

src/ucioption.cpp

@@ -34,6 +34,8 @@
 #include "ucioption.h"
 
 using std::string;
+using std::cout;
+using std::endl;
 
 ////
 //// Local definitions
@@ -41,13 +43,9 @@ using std::string;
 
 namespace {
 
-  ///
-  /// Types
-  ///
-
   enum OptionType { SPIN, COMBO, CHECK, STRING, BUTTON };
 
-  typedef std::vector<string> ComboValues;
+  typedef std::vector<string> StrVector;
 
   struct Option {
 
@@ -55,23 +53,42 @@ namespace {
     OptionType type;
     size_t idx;
     int minValue, maxValue;
-    ComboValues comboValues;
+    StrVector comboValues;
 
     Option();
     Option(const char* defaultValue, OptionType = STRING);
     Option(bool defaultValue, OptionType = CHECK);
     Option(int defaultValue, int minValue, int maxValue);
 
-    bool operator<(const Option& o) const { return this->idx < o.idx; }
+    bool operator<(const Option& o) const { return idx < o.idx; }
   };
 
+  typedef std::vector<Option> OptionsVector;
   typedef std::map<string, Option> Options;
 
-  ///
+  Options options;
-  /// Constants
-  ///
 
-  // load_defaults populates the options map with the hard
+  // stringify() converts a value of type T to a std::string
+  template<typename T>
+  string stringify(const T& v) {
+
+     std::ostringstream ss;
+     ss << v;
+     return ss.str();
+  }
+
+  Option::Option() {} // To allow insertion in a std::map
+
+  Option::Option(const char* def, OptionType t)
+  : defaultValue(def), currentValue(def), type(t), idx(options.size()), minValue(0), maxValue(0) {}
+
+  Option::Option(bool def, OptionType t)
+  : defaultValue(stringify(def)), currentValue(stringify(def)), type(t), idx(options.size()), minValue(0), maxValue(0) {}
+
+  Option::Option(int def, int minv, int maxv)
+  : defaultValue(stringify(def)), currentValue(stringify(def)), type(SPIN), idx(options.size()), minValue(minv), maxValue(maxv) {}
+
+  // load_defaults() populates the options map with the hard
   // coded names and default values.
 
   void load_defaults(Options& o) {
@@ -101,7 +118,6 @@ namespace {
     o["Passed Pawn Extension (non-PV nodes)"] = Option(0, 0, 2);
     o["Pawn Endgame Extension (PV nodes)"] = Option(2, 0, 2);
     o["Pawn Endgame Extension (non-PV nodes)"] = Option(2, 0, 2);
-    o["Randomness"] = Option(0, 0, 10);
     o["Minimum Split Depth"] = Option(4, 4, 7);
     o["Maximum Number of Threads per Split Point"] = Option(5, 4, 8);
     o["Threads"] = Option(1, 1, MAX_THREADS);
@@ -111,7 +127,10 @@ namespace {
     o["Ponder"] = Option(true);
     o["OwnBook"] = Option(true);
     o["MultiPV"] = Option(1, 1, 500);
-    o["UCI_Chess960"] = Option(false);
+    o["Emergency Move Horizon"] = Option(40, 0, 50);
+    o["Emergency Base Time"] = Option(200, 0, 60000);
+    o["Emergency Move Time"] = Option(70, 0, 5000);
+    o["Minimum Thinking Time"] = Option(20, 0, 5000);
     o["UCI_AnalyseMode"] = Option(false);
 
     // Any option should know its name so to be easily printed
@@ -119,25 +138,8 @@ namespace {
         it->second.name = it->first;
   }
 
-  ///
+  // get_option_value() implements the various get_option_value_<type>
-  /// Variables
+  // functions defined later.
-  ///
-
-  Options options;
-
-  // stringify converts a value of type T to a std::string
-  template<typename T>
-  string stringify(const T& v) {
-
-     std::ostringstream ss;
-     ss << v;
-     return ss.str();
-  }
-
-
-  // get_option_value implements the various get_option_value_<type>
-  // functions defined later, because only the option value
-  // type changes a template seems a proper solution.
 
   template<typename T>
   T get_option_value(const string& optionName) {
@@ -151,9 +153,8 @@ namespace {
       return ret;
   }
 
-  // Specialization for std::string where instruction 'ss >> ret;'
+  // Specialization for std::string where instruction 'ss >> ret'
   // would erroneusly tokenize a string with spaces.
-
   template<>
   string get_option_value<string>(const string& optionName) {
 
@@ -165,20 +166,15 @@ namespace {
 
 }
 
-////
-//// Functions
-////
 
-/// init_uci_options() initializes the UCI options.  Currently, the only
+/// init_uci_options() initializes the UCI options. Currently, the only thing
-/// thing this function does is to initialize the default value of the
+/// this function does is to initialize the default value of "Threads" and
-/// "Threads" parameter to the number of available CPU cores.
+/// "Minimum Split Depth" parameters according to the number of CPU cores.
 
 void init_uci_options() {
 
   load_defaults(options);
 
-  // Set optimal value for parameter "Minimum Split Depth"
-  // according to number of available cores.
   assert(options.find("Threads") != options.end());
   assert(options.find("Minimum Split Depth") != options.end());
 
@@ -197,39 +193,40 @@ void init_uci_options() {
 
 void print_uci_options() {
 
-  static const char optionTypeName[][16] = {
+  const char OptTypeName[][16] = {
     "spin", "combo", "check", "string", "button"
   };
 
   // Build up a vector out of the options map and sort it according to idx
   // field, that is the chronological insertion order in options map.
-  std::vector<Option> vec;
+  OptionsVector vec;
   for (Options::const_iterator it = options.begin(); it != options.end(); ++it)
       vec.push_back(it->second);
 
   std::sort(vec.begin(), vec.end());
 
-  for (std::vector<Option>::const_iterator it = vec.begin(); it != vec.end(); ++it)
+  for (OptionsVector::const_iterator it = vec.begin(); it != vec.end(); ++it)
   {
-      std::cout << "\noption name " << it->name
+      cout << "\noption name " << it->name << " type " << OptTypeName[it->type];
-                << " type "         << optionTypeName[it->type];
 
       if (it->type == BUTTON)
           continue;
 
       if (it->type == CHECK)
-          std::cout << " default " << (it->defaultValue == "1" ? "true" : "false");
+          cout << " default " << (it->defaultValue == "1" ? "true" : "false");
       else
-          std::cout << " default " << it->defaultValue;
+          cout << " default " << it->defaultValue;
 
       if (it->type == SPIN)
-          std::cout << " min " << it->minValue << " max " << it->maxValue;
+          cout << " min " << it->minValue << " max " << it->maxValue;
       else if (it->type == COMBO)
-          for (ComboValues::const_iterator itc = it->comboValues.begin();
+      {
-              itc != it->comboValues.end(); ++itc)
+          StrVector::const_iterator itc;
-              std::cout << " var " << *itc;
+          for (itc = it->comboValues.begin(); itc != it->comboValues.end(); ++itc)
+              cout << " var " << *itc;
+      }
   }
-  std::cout << std::endl;
+  cout << endl;
 }
 
 
@@ -262,12 +259,16 @@ string get_option_value_string(const string& optionName) {
 }
 
 
-/// set_option_value() inserts a new value for a UCI parameter. Note that
+/// set_option_value() inserts a new value for a UCI parameter
-/// the function does not check that the new value is legal for the given
-/// parameter: This is assumed to be the responsibility of the GUI.
 
 void set_option_value(const string& name, const string& value) {
 
+  if (options.find(name) == options.end())
+  {
+      cout << "No such option: " << name << endl;
+      return;
+  }
+
   // UCI protocol uses "true" and "false" instead of "1" and "0", so convert
   // value according to standard C++ convention before to store it.
   string v(value);
@@ -276,12 +277,6 @@ void set_option_value(const string& name, const string& value) {
   else if (v == "false")
       v = "0";
 
-  if (options.find(name) == options.end())
-  {
-      std::cout << "No such option: " << name << std::endl;
-      return;
-  }
-
   // Normally it's up to the GUI to check for option's limits,
   // but we could receive the new value directly from the user
   // by teminal window. So let's check the bounds anyway.
@@ -296,7 +291,6 @@ void set_option_value(const string& name, const string& value) {
       if (val < opt.minValue || val > opt.maxValue)
           return;
   }
-
   opt.currentValue = v;
 }
 
@@ -322,21 +316,3 @@ bool button_was_pressed(const string& buttonName) {
   set_option_value(buttonName, "false");
   return true;
 }
-
-
-namespace {
-
-  // Define constructors of Option class.
-
-  Option::Option() {} // To allow insertion in a std::map
-
-  Option::Option(const char* def, OptionType t)
-  : defaultValue(def), currentValue(def), type(t), idx(options.size()), minValue(0), maxValue(0) {}
-
-  Option::Option(bool def, OptionType t)
-  : defaultValue(stringify(def)), currentValue(stringify(def)), type(t), idx(options.size()), minValue(0), maxValue(0) {}
-
-  Option::Option(int def, int minv, int maxv)
-  : defaultValue(stringify(def)), currentValue(stringify(def)), type(SPIN), idx(options.size()), minValue(minv), maxValue(maxv) {}
-
-}

src/value.cpp

@@ -1,96 +0,0 @@
-/*
-  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
-
-  Stockfish is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  Stockfish is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-////
-//// Includes
-////
-
-#include <sstream>
-#include <string>
-
-#include "value.h"
-
-
-////
-//// Functions
-////
-
-/// value_to_tt() adjusts a mate score from "plies to mate from the root" to
-/// "plies to mate from the current ply".  Non-mate scores are unchanged.
-/// The function is called before storing a value to the transposition table.
-
-Value value_to_tt(Value v, int ply) {
-  if(v >= value_mate_in(100))
-    return v + ply;
-  else if(v <= value_mated_in(100))
-    return v - ply;
-  else
-    return v;
-}
-
-
-/// value_from_tt() is the inverse of value_to_tt():  It adjusts a mate score
-/// from the transposition table to a mate score corrected for the current
-/// ply depth.
-
-Value value_from_tt(Value v, int ply) {
-  if(v >= value_mate_in(100))
-    return v - ply;
-  else if(v <= value_mated_in(100))
-    return v + ply;
-  else
-    return v;
-}
-
-
-/// value_to_centipawns() converts a value from Stockfish's somewhat unusual
-/// scale of pawn = 256 to the more conventional pawn = 100.
-
-int value_to_centipawns(Value v) {
-  return (int(v) * 100) / int(PawnValueMidgame);
-}
-
-
-/// value_from_centipawns() converts a centipawn value to Stockfish's internal
-/// evaluation scale.  It's used when reading the values of UCI options
-/// containing material values (e.g. futility pruning margins).
-
-Value value_from_centipawns(int cp) {
-  return Value((cp * 256) / 100);
-}
-
-
-/// value_to_string() converts a value to a string suitable for use with the
-/// UCI protocol.
-
-const std::string value_to_string(Value v) {
-  std::stringstream s;
-
-  if(abs(v) < VALUE_MATE - 200)
-    s << "cp " << value_to_centipawns(v);
-  else {
-    s << "mate ";
-    if(v > 0)
-      s << (VALUE_MATE - v + 1) / 2;
-    else
-      s << -(VALUE_MATE + v) / 2;
-  }
-  return s.str();
-}

src/value.h

@@ -21,13 +21,6 @@
 #if !defined(VALUE_H_INCLUDED)
 #define VALUE_H_INCLUDED
 
-////
-//// Includes
-////
-
-#include "piece.h"
-
-
 ////
 //// Types
 ////
@@ -41,14 +34,25 @@ enum ValueType {
 
 
 enum Value {
-  VALUE_DRAW = 0,
+  VALUE_ZERO      = 0,
+  VALUE_DRAW      = 0,
   VALUE_KNOWN_WIN = 15000,
-  VALUE_MATE = 30000,
+  VALUE_MATE      = 30000,
-  VALUE_INFINITE = 30001,
+  VALUE_INFINITE  = 30001,
-  VALUE_NONE = 30002,
+  VALUE_NONE      = 30002,
   VALUE_ENSURE_SIGNED = -1
 };
 
+ENABLE_OPERATORS_ON(Value);
+
+
+enum ScaleFactor {
+  SCALE_FACTOR_ZERO   = 0,
+  SCALE_FACTOR_NORMAL = 64,
+  SCALE_FACTOR_MAX    = 128,
+  SCALE_FACTOR_NONE   = 255
+};
+
 
 /// Score enum keeps a midgame and an endgame value in a single
 /// integer (enum), first LSB 16 bits are used to store endgame
@@ -56,7 +60,14 @@ enum Value {
 
 // Compiler is free to choose the enum type as long as can keep
 // its data, so ensure Score to be an integer type.
-enum Score { ENSURE_32_BITS_SIZE_P = (1 << 16), ENSURE_32_BITS_SIZE_N = -(1 << 16)};
+enum Score {
+    SCORE_ZERO = 0,
+    SCORE_ENSURE_32_BITS_SIZE_P =  (1 << 16),
+    SCORE_ENSURE_32_BITS_SIZE_N = -(1 << 16)
+};
+
+ENABLE_OPERATORS_ON(Score);
+
 
 // Extracting the _signed_ lower and upper 16 bits it not so trivial
 // because according to the standard a simple cast to short is
@@ -73,13 +84,6 @@ inline Value eg_value(Score s) { return Value((int)(unsigned(s) & 0x7fffu) - (in
 
 inline Score make_score(int mg, int eg) { return Score((mg << 16) + eg); }
 
-inline Score operator-(Score s) { return Score(-int(s)); }
-inline Score operator+(Score s1, Score s2) { return Score(int(s1) + int(s2)); }
-inline Score operator-(Score s1, Score s2) { return Score(int(s1) - int(s2)); }
-inline void operator+=(Score& s1, Score s2) { s1 = Score(int(s1) + int(s2)); }
-inline void operator-=(Score& s1, Score s2) { s1 = Score(int(s1) - int(s2)); }
-inline Score operator*(int i, Score s) { return Score(i * int(s)); }
-
 // Division must be handled separately for each term
 inline Score operator/(Score s, int i) { return make_score(mg_value(s) / i, eg_value(s) / i); }
 
@@ -88,118 +92,20 @@ inline Score operator/(Score s, int i) { return make_score(mg_value(s) / i, eg_v
 inline Score operator*(Score s1, Score s2);
 
 
-////
-//// Constants and variables
-////
-
-/// Piece values, middle game and endgame
-
-/// Important: If the material values are changed, one must also
-/// adjust the piece square tables, and the method game_phase() in the
-/// Position class!
-///
-/// Values modified by Joona Kiiski
-
-const Value PawnValueMidgame   = Value(0x0C6);
-const Value PawnValueEndgame   = Value(0x102);
-const Value KnightValueMidgame = Value(0x331);
-const Value KnightValueEndgame = Value(0x34E);
-const Value BishopValueMidgame = Value(0x344);
-const Value BishopValueEndgame = Value(0x359);
-const Value RookValueMidgame   = Value(0x4F6);
-const Value RookValueEndgame   = Value(0x4FE);
-const Value QueenValueMidgame  = Value(0x9D9);
-const Value QueenValueEndgame  = Value(0x9FE);
-
-const Value PieceValueMidgame[17] = {
-  Value(0),
-  PawnValueMidgame, KnightValueMidgame, BishopValueMidgame,
-  RookValueMidgame, QueenValueMidgame,
-  Value(0), Value(0), Value(0),
-  PawnValueMidgame, KnightValueMidgame, BishopValueMidgame,
-  RookValueMidgame, QueenValueMidgame,
-  Value(0), Value(0), Value(0)
-};
-
-const Value PieceValueEndgame[17] = {
-  Value(0),
-  PawnValueEndgame, KnightValueEndgame, BishopValueEndgame,
-  RookValueEndgame, QueenValueEndgame,
-  Value(0), Value(0), Value(0),
-  PawnValueEndgame, KnightValueEndgame, BishopValueEndgame,
-  RookValueEndgame, QueenValueEndgame,
-  Value(0), Value(0), Value(0)
-};
-
-/// Bonus for having the side to move (modified by Joona Kiiski)
-
-const Score TempoValue = make_score(48, 22);
-
-
 ////
 //// Inline functions
 ////
 
 inline Value operator+ (Value v, int i) { return Value(int(v) + i); }
-inline Value operator+ (Value v1, Value v2) { return Value(int(v1) + int(v2)); }
-inline void operator+= (Value &v1, Value v2) {
-  v1 = Value(int(v1) + int(v2));
-}
 inline Value operator- (Value v, int i) { return Value(int(v) - i); }
-inline Value operator- (Value v) { return Value(-int(v)); }
-inline Value operator- (Value v1, Value v2) { return Value(int(v1) - int(v2)); }
-inline void operator-= (Value &v1, Value v2) {
-  v1 = Value(int(v1) - int(v2));
-}
-inline Value operator* (Value v, int i) { return Value(int(v) * i); }
-inline void operator*= (Value &v, int i) { v = Value(int(v) * i); }
-inline Value operator* (int i, Value v) { return Value(int(v) * i); }
-inline Value operator/ (Value v, int i) { return Value(int(v) / i); }
-inline void operator/= (Value &v, int i) { v = Value(int(v) / i); }
 
 
 inline Value value_mate_in(int ply) {
-  return Value(VALUE_MATE - Value(ply));
+  return VALUE_MATE - ply;
 }
 
 inline Value value_mated_in(int ply) {
-  return Value(-VALUE_MATE + Value(ply));
+  return -VALUE_MATE + ply;
 }
 
-inline bool is_upper_bound(ValueType vt) {
-  return (int(vt) & int(VALUE_TYPE_UPPER)) != 0;
-}
-
-inline bool is_lower_bound(ValueType vt) {
-  return (int(vt) & int(VALUE_TYPE_LOWER)) != 0;
-}
-
-inline Value piece_value_midgame(PieceType pt) {
-  return PieceValueMidgame[pt];
-}
-
-inline Value piece_value_endgame(PieceType pt) {
-  return PieceValueEndgame[pt];
-}
-
-inline Value piece_value_midgame(Piece p) {
-  return PieceValueMidgame[p];
-}
-
-inline Value piece_value_endgame(Piece p) {
-  return PieceValueEndgame[p];
-}
-
-
-////
-//// Prototypes
-////
-
-extern Value value_to_tt(Value v, int ply);
-extern Value value_from_tt(Value v, int ply);
-extern int value_to_centipawns(Value v);
-extern Value value_from_centipawns(int cp);
-extern const std::string value_to_string(Value v);
-
-
 #endif // !defined(VALUE_H_INCLUDED)