Stockfish 1.5

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

Readme.txt

@@ -1,33 +1,28 @@
 1. Introduction
 ---------------
 
-Glaurung is a free UCI chess engine.  It is not a complete chess
+Stockfish is a free UCI chess engine derived from Glaurung 2.1. It is
-program, but requires some UCI compatible GUI (like XBoard with
+not a complete chess program, but requires some UCI compatible GUI
-PolyGlot, eboard, José, Arena, Sigma Chess, Shredder, Chess Partner,
+(like XBoard with PolyGlot, eboard, Jos�, Arena, Sigma Chess, Shredder,
-or Fritz) in order to be used comfortably.  Read the documentation for
+Chess Partner, or Fritz) in order to be used comfortably.  Read the
-your GUI of choice for information about how to use Glaurung with your
+documentation for your GUI of choice for information about how to use
-GUI.
+Stockfish with your GUI.
 
-Glaurung 2 is a completely rewritten version of Glaurung.  Apart from
+This version of Stockfish supports up to 8 CPUs, but has not been
-the parallel search code, almost no code is shared with Glaurung
-1.2.1, the previous stable version.  The new program is clearly
-stronger than the old, but has a less attractive style of play,
-because there are still a few major holes in its evaluation function
-(most notably space and development).
-
-This version of Glaurung supports up to 8 CPUs, but has not been
 tested thoroughly with more than 2.  The program tries to detect the
 number of CPUs on your computer and set the number of search threads
 accordingly, but please be aware that the detection is not always
 correct.  It is therefore recommended to inspect the value of the
 "Threads" UCI parameter, and to make sure it equals the number of CPU
-cores on your computer.
+cores on your computer. If you are using more than four threads, it
+is recommended to raise the value of "Minimum Split Depth" UCI parameter
+to 6.
 
 
 2. Files
 --------
 
-This distribution of Glaurung consists of the following files:
+This distribution of Stockfish consists of the following files:
 
   * Readme.txt, the file you are currently reading.
 
@@ -35,284 +30,53 @@ This distribution of Glaurung consists of the following files:
     License.
 
   * src/, a subdirectory containing the full source code, including a
-    Makefile that can be used to compile Glaurung on Unix-like
+    Makefile that can be used to compile Stockfish on Unix-like
-    systems.  For further information about how to compile Glaurung
+    systems.  For further information about how to compile Stockfish
     yourself, read section 4 below.
 
-  * MacOSX/, a subdirectory containing excutables for Apple Macintosh
+  * polyglot.ini, for using Stockfish with Fabien Letouzey's PolyGlot
-    computers running Mac OS X 10.4 (Tiger) and newer.  There are two
-    executables, one for OS X 10.4, and one for OS X 10.5.  The
-    executable for OS X 10.4 will work in 10.5 as well, but the one
-    for 10.5 is faster.
-
-  * LinuxX86/, a subdirectory containing 32-bit and 64-bit x86 GNU/Linux
-    executables.
-
-  * Windows/, a subdirectory containing 32-bit and 64-bit Windows
-    executables.
-
-  * polyglot.ini, for using Glaurung with Fabien Letouzey's PolyGlot
     adapter.
 
 
 3. Opening books
 ----------------
 
-This version of Glaurung has experimental support for PolyGlot opening
+This version of Stockfish has experimental support for PolyGlot opening
 books. For information about how to create such books, consult the
 PolyGlot documentation.  The book file can be selected by setting the
 UCI parameter "Book File".
 
-A book file contributed by Salvo Spitaleri can be found on the
-Glaurung web page.
-
 
 4. Compiling it yourself
 ------------------------
 
 On Unix-like systems, it should usually be possible to compile
-Glaurung directly from the source code with the included Makefile.
+Stockfish directly from the source code with the included Makefile.
 The exception is computer with big-endian CPUs, like PowerPC
 Macintoshes. Some of the bitboard routines in the current version of
-Glaurung are endianness-sensitive, and won't work on a big-endian CPU.
+Stockfish are endianness-sensitive, and won't work on a big-endian CPU.
-Ensuring that the line with #define USE_32BIT_ATTACKS" near the top
-of bitboard.h is commented out should solve this problem.
-Commenting out the line with "#define USE_32BIT_ATTACKS" near the
 
-There is also a problem with compiling Glaurung on certain 64-bit 
+Stockfish has POPCNT instruction runtime detection and support. This can
-systems, regardless of the endianness.  If Glaurung segfaults 
+give an extra speed on Core i7 or similar systems. To enable this feature
-immediately after startup, try to comment out the line with 
+(disabled by default) simply uncomment #define USE_POPCNT in bitcount.h
-"#define USE_FOLDED_BITSCAN" near the beginning of bitboard.h and
+before to compile.
-recompile.
 
-Finally, even if Glaurung does work without any changes on your
+On 64 bit Unix-like systems the 'bsfq' assembly instruction will be used
-computer, it might be possible to improve the performance by changing
+for bit counting. Detection is automatic at compile time, but in case you
-some of the #define directives in bitboard.h.  The default settings
+experience compile problems you can comment out #define USE_BSFQ line in types.h
-are optimized for 64-bit CPUs.  On 32-bit CPUs, it is probably better
-to switch on USE_32BIT_ATTACKS, and to use BITCOUNT_SWAR_32 instead of
-BITCOUNT_SWAR_64.  For computers with very little memory (like
-handheld devices), it is possible to conserve memory by defining
-USE_COMPACT_ROOK_ATTACKS. 
 
 
-
+5. Terms of use
-5. History
-----------
-
-2007-05-06: Glaurung 2 - epsilon
---------------------------------
-
-The first public release, and the first version of my new program
-which is able to match the old Glaurung 1.2.1 on a single CPU.  Lots
-of features and chess knowledge is still missing.
-
-2007-05-10: Glaurung 2 - epsilon/2
-----------------------------------
-
-This version is very close to 2 - epsilon.  The major changes are:
-
-  * A number of compatibility problems which appeared when trying to
-    compile Glaurung 2 - epsilon on various operating systems and CPUs
-    have been solved.
-
-  * Fixed a major bug in the detection of rooks trapped inside a
-    friendly king.
-
-  * Added knowledge about several types of drawn endgames.
-
-  * Fixed a few FRC related bugs.  FRC now works, but because of
-    serious holes in the evaluation function the program plays very
-    badly.
-
-  * A slightly more sophisticated king safety evaluation.
-
-2007-06-07: Glaurung 2 - epsilon/3
-----------------------------------
-
-The first public version with support for multiple CPUs.  Unless you
-have a dual-core (or better) computer, use Glaurung with a PolyGlot
-book, or runs games with ponder on, you may want to skip this version,
-which is almost certainly no stronger than 2 - epsilon/2 when running
-on a single CPU.  The main changes compared to the previous version
-are:
-
-  * Parallel search, with support for 1-4 CPUs.  The program currently
-    always allocates a separate pawn hash table and material hash
-    table for four threads, which is a pure waste of RAM if your
-    computer has just a single CPU.  This will be fixed in a future
-    version.
-
-  * Fixed a bug in book randomization.  When using Polyglot books, the
-    previous version would always select exactly the same move in the
-    same position after a restart of the program.  Thanks to Pavel
-    Háse for pointing this out.
-
-  * Fixed a UCI pondering bug: Glaurung no longer instantly prints its
-    best move when the maximum depth is reached during a ponder
-    search, as the previous version did.  According to the UCI
-    protocol, it is not allowed to print the best move before the
-    engine has received the "stop" or "quit" command.
-
-  * Additional search information:  The new version displays hash
-    saturation and the current line(s) of search.
-
-  * Several minor bug fixes and optimizations in the search and
-    evaluation. 
-
-2007-06-08: Glaurung 2 - epsilon/4
-----------------------------------
-
-A bugfix release, with only a single important change:
-
-   * Fixed a very serious pondering bug.  As pointed out by Marc
-     Lacrosse, the previous version would lose on time in almost every
-     single game with pondering enabled.  The new version handles
-     pondering correctly (or so I hope).  When playing with ponder
-     off, the new version is identical to version 2 - epsilon/3.
-
-2007-06-25: Glaurung 2 - epsilon/5
-----------------------------------
-
-Another minor update, including the following improvements and bug
-fixes:
-
-   * As Werner Schüle discovered, the previous version would sometimes
-     stop thinking and lose on time right before delivering checkmate
-     (which is of course a very unfortunate moment to lose on time).
-     I haven't been able to reproduce Werner's problem on my computer
-     (probably because I run a different OS), but I have fixed the bug
-     which I suspect caused the time losses.  I hope the time losses
-     will no longer occur with 2 - epsilon/5.
-
-   * The program is now slightly less resource-hungry on computers
-     with less than 4 CPU cores: The previous version would always
-     allocated separate pawn and material hash tables for four
-     threads, even when running on a single-core CPU.  The new version
-     only allocates pawn and material hash tables for the threads
-     which are actually used.
-
-   * A minor reorganization of the memory layout has made the parallel
-     search about 10% more efficient (at least on my computer, but the
-     results are likely to vary considerably on different systems).
-
-   * The Intel Mac OS X binary is much faster than before, thanks to
-     the Intel C++ compiler (previous versions were compiled with
-     GCC).
-
-   * A few other very minor bug fixes and enhancements.
-
-2007-11-21: Glaurung 2.0
-------------------------
-
-The first stable (or so I hope) and feature-complete version of
-Glaurung 2.  The following are the main changes compared to the
-previous version:
-
-   * The license has been changed from GPL version 2 to GPL version 3.
-
-   * MultiPV mode.
-
-   * Support for the "searchmoves" option in the UCI "go" command.
-     This means that it is possible to ask Glaurung to exclude some
-     moves from its analysis, or to restrict its analysis to just a
-     handful of moves selected by the user.  This feature must also be
-     supported by the GUI under which Glaurung is run.  Glaurung's own
-     GUI does currently not support this feature.
-
-   * Chess960 support now works.  The program still plays this game 
-     very badly, because of lack of opening knowledge.
-
-   * Much more aggressive pruning in the last few plies of the main
-     search.
-
-   * Somewhat better scaling on multi-CPU systems, and support for up
-     to 8 CPUs.
-
-   * Lots of new UCI parameters.
-
-   * Improved time managment, especially in games with pondering on 
-     (i.e. when the engine is allowed to think when it's the
-     opponent's turn to move).
-
-   * Some evaluation improvements, and some new basic endgame
-     patterns.
-
-   * The program should no longer crash if the game lasts longer than
-     1000 plies.
- 
-   * Many minor bug fixes and other tiny improvements throughout the
-     code.  
- 
-   * More generously commented code, and numerous cosmetic changes in
-     coding style.
-
-2007-11-22: Glaurung 2.0.1
---------------------------
-
-   * Fixed (or so I hope) a bug which would occasionally cause one of
-     the search threads to get stuck forever in its idle loop.
-
-2008-05-14: Glaurung 2.1
-------------------------
-
-This version contains far too many changes to list them all, but most
-of them are minor and cosmetic.  The most important and noticable
-changes are a lot of new UCI parameters, and many improvements in the
-evaluation function.  The highlights are:
-
-   * Extensive changes in the evaluation function.  The addition of
-     king safety is the most important improvement, but there are also
-     numerous little improvements elsewhere in the evaluation.  There
-     is still much work left to do in the evaluation function, though.
-     Space and development are still missing, and the tuning is likely
-     to be very poor.  Currently, the program is optimized for an
-     entertaining style rather than maximum strength.
-
-   * More accurate forward pruning.  The previous version used the
-     null move refutation move to improve the pruning accuracy by
-     means of a very simple trick: It did not allow pruning of any
-     moves with the piece captured by the null move refutation move.
-     In Glaurung 2.1, this has been enhanced: It does not allow
-     pruning of moves which defend the destination square of the null
-     move refutation move, nor of moves which block the ray of the
-     piece in the case that the moving piece in the null move
-     refutation move is a slider.
-
-   * More conservative use of LMR at PV nodes.  The previous version
-     searched the first 6 moves with full depth, 2.1 by default
-     searches the first 14 moves with full depth (but there is a new
-     UCI parameter for configuring this).  I am not at all sure
-     whether this is an improvement.  More thorough testing is
-     required. 
-
-   * Feedback from the evaluation to the search.  The search passes an
-     object of type 'EvalInfo' to the eval, and the eval fills this
-     struct with various potentially useful information (like the sets
-     of squares attacked by each piece type, the middle game and
-     endgame components of the eval, etc.).  At the moment, almost
-     none of this information is actually used by the search.  The
-     only exception is that the evaluation function is now used to
-     adjust the futility pruning margin in the quiescence search.
-
-   * Less extensions.  This hurts the programs performance a lot in most
-     test suites, but I hope it improves the branching factor in deep
-     searches.
-
-   * A very long list of new UCI parameters, especially for tuning the
-     evaluation. 
-
-
-6. Terms of use
 ---------------
 
-Glaurung is free, and distributed under the GNU General Public License
+Stockfish is free, and distributed under the GNU General Public License
 (GPL).  Essentially, this means that you are free to do almost exactly
 what you want with the program, including distributing it among your
 friends, making it available for download from your web site, selling
 it (either by itself or as part of some bigger software package), or
 using it as the starting point for a software project of your own.
 
-The only real limitation is that whenever you distribute Glaurung in
+The only real limitation is that whenever you distribute Stockfish in
 some way, you must always include the full source code, or a pointer
 to where the source code can be found.  If you make any changes to the
 source code, these changes must also be made available under the GPL.
@@ -321,8 +85,7 @@ For full details, read the copy of the GPL found in the file named
 Copying.txt.
 
 
-7. Feedback
+6. Feedback
 -----------
 
-The author's e-mail address is tord@glaurungchess.com
+The author's e-mail address is mcostalba@gmail.com
-

polyglot.ini

@@ -2,13 +2,13 @@
 [PolyGlot]
 
 EngineDir = .
-EngineCommand = ./glaurung
+EngineCommand = ./stockfish
 
 Book = false
 BookFile = book.bin
 
 Log = true
-LogFile = glaurung.log
+LogFile = stockfish.log
 
 Resign = true
 ResignScore = 600
@@ -34,8 +34,7 @@ King Safety Coefficient = 40
 King Safety X Intercept = 0
 King Safety Max Slope = 30
 King Safety Max Value = 500
-Queen Contact Check Bonus = 4
+Queen Contact Check Bonus = 3
-Rook Contact Check Bonus = 2
 Queen Check Bonus = 2
 Rook Check Bonus = 1
 Bishop Check Bonus = 1
@@ -57,14 +56,8 @@ Pawn Endgame Extension (non-PV nodes) = 2
 Full Depth Moves (PV nodes) = 14
 Full Depth Moves (non-PV nodes) = 3
 Threat Depth = 5
-Selective Plies = 7
 Futility Pruning (Main Search) = true
 Futility Pruning (Quiescence Search) = true
-Futility Margin 0 = 50
-Futility Margin 1 = 100
-Futility Margin 2 = 300
-Maximum Razoring Depth = 3
-Razoring Margin = 300
 Randomness = 0
 Minimum Split Depth = 4
 Maximum Number of Threads per Split Point = 5

src/Makefile

@@ -1,14 +1,15 @@
-# Glaurung, a UCI chess playing engine.
+# Stockfish, a UCI chess playing engine derived from Glaurung 2.1
 # Copyright (C) 2004-2007 Tord Romstad
+# Copyright (C) 2008 Marco Costalba
 
-# This file is part of Glaurung.
+# This file is part of Stockfish.
 #
-# Glaurung is free software: you can redistribute it and/or modify
+# 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.
 #
-# Glaurung is distributed in the hope that it will be useful,
+# 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.
@@ -17,129 +18,246 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
-###
+### Executable name. Do not change
-### Files
+EXE = stockfish
-###
 
-EXE = glaurung
 
-OBJS = bitboard.o color.o pawns.o material.o endgame.o evaluate.o main.o \
+### ==========================================================================
+### Compiler speed switches for both GCC and ICC. These settings are generally
+### fast on a broad range of systems, but may be changed experimentally
+### ==========================================================================
+GCCFLAGS = -O3 -msse
+ICCFLAGS = -fast -msse
+ICCFLAGS-OSX = -fast -mdynamic-no-pic
+
+
+### ==========================================================================
+### Enable/disable debugging, disabled by default
+### ==========================================================================
+GCCFLAGS += -DNDEBUG
+ICCFLAGS += -DNDEBUG
+ICCFLAGS-OSX += -DNDEBUG
+
+
+### ==========================================================================
+### Run built-in benchmark for pgo-builds with:  32MB hash  1 thread  10 depth
+### These settings are generally fast, but may be changed experimentally
+### ==========================================================================
+PGOBENCH = ./$(EXE) bench 32 1 10 default depth
+
+
+### General compiler settings. Do not change
+GCCFLAGS += -g -Wall -fno-exceptions -fno-rtti -fno-strict-aliasing
+ICCFLAGS += -g -Wall -fno-exceptions -fno-rtti -fno-strict-aliasing -wd383,869,981,10187,10188,11505,11503
+ICCFLAGS-OSX += -g -Wall -fno-exceptions -fno-rtti -fno-strict-aliasing -wd383,869,981,10187,10188,11505,11503
+
+
+### General linker settings. Do not change
+LDFLAGS  = -lpthread
+
+
+### Object files. Do not change
+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 square.o direction.o tt.o value.o uci.o ucioption.o \
+	position.o direction.o tt.o value.o uci.o ucioption.o \
 	mersenne.o book.o bitbase.o san.o benchmark.o
 
 
-###
+### General rules. Do not change
-### Rules
+default:
-###
+	$(MAKE) gcc
+
+help:
+	@echo ""
+	@echo "Makefile options:"
+	@echo ""
+	@echo "make                >  Default: Compiler = g++"
+	@echo "make icc            >  Compiler = icpc"
+	@echo "make icc-profile    >  Compiler = icpc + automatic pgo-build"
+	@echo "make osx-ppc32      >  PPC-Mac OS X 32 bit. Compiler = g++"
+	@echo "make osx-ppc64      >  PPC-Mac OS X 64 bit. Compiler = g++"
+	@echo "make osx-x86        >  x86-Mac OS X 32 bit. Compiler = g++"
+	@echo "make osx-x86_64     >  x86-Mac OS X 64 bit. Compiler = g++"
+	@echo "make osx-icc32      >  x86-Mac OS X 32 bit. Compiler = icpc"
+	@echo "make osx-icc64      >  x86-Mac OS X 64 bit. Compiler = icpc"
+	@echo "make osx-icc32-profile > OSX 32 bit. Compiler = icpc + automatic pgo-build"
+	@echo "make osx-icc64-profile > OSX 64 bit. Compiler = icpc + automatic pgo-build"
+	@echo "make strip          >  Strip executable"
+	@echo "make clean          >  Clean up"
+	@echo ""
 
 all: $(EXE) .depend
 
 clean:
-	$(RM) *.o .depend glaurung
+	$(RM) *.o .depend *~ $(EXE)
 
 
-###
+### Possible targets. You may add your own ones here
-### Compiler:
+gcc:
-###
+	$(MAKE) \
+	CXX='g++' \
+	CXXFLAGS="$(GCCFLAGS)" \
+	all
 
-CXX = g++
+icc:
-# CXX = g++-4.2
+	$(MAKE) \
-# CXX = icpc
+	CXX='icpc' \
+	CXXFLAGS="$(ICCFLAGS)" \
+	all
+
+icc-profile-make:
+	$(MAKE) \
+	CXX='icpc' \
+	CXXFLAGS="$(ICCFLAGS)" \
+	CXXFLAGS+='-prof-gen=srcpos -prof_dir ./profdir' \
+	all
+
+icc-profile-use:
+	$(MAKE) \
+	CXX='icpc' \
+	CXXFLAGS="$(ICCFLAGS)" \
+	CXXFLAGS+='-prof_use -prof_dir ./profdir' \
+	all
+
+icc-profile:
+	@rm -rf profdir
+	@mkdir profdir
+	@touch *.cpp *.h
+	$(MAKE) icc-profile-make
+	@echo ""
+	@echo "Running benchmark for pgo-build ..."
+	@$(PGOBENCH) > /dev/null
+	@echo "Benchmark finished. Build final executable now ..."
+	@echo ""
+	@touch *.cpp *.h
+	$(MAKE) icc-profile-use
+	@rm -rf profdir bench.txt
+
+osx-ppc32:
+	$(MAKE) \
+	CXX='g++' \
+	CXXFLAGS="$(GCCFLAGS)" \
+	CXXFLAGS+='-arch ppc' \
+	LDFLAGS+='-arch ppc' \
+	all
+
+osx-ppc64:
+	$(MAKE) \
+	CXX='g++' \
+	CXXFLAGS="$(GCCFLAGS)" \
+	CXXFLAGS+='-arch ppc64' \
+	LDFLAGS+='-arch ppc64' \
+	all
+
+osx-x86:
+	$(MAKE) \
+	CXX='g++' \
+	CXXFLAGS="$(GCCFLAGS)" \
+	CXXFLAGS+='-arch i386' \
+	LDFLAGS+='-arch i386' \
+	all
+
+osx-x86_64:
+	$(MAKE) \
+	CXX='g++' \
+	CXXFLAGS="$(GCCFLAGS)" \
+	CXXFLAGS+='-arch x86_64' \
+	LDFLAGS+='-arch x86_64' \
+	all
+	
+osx-icc32:
+	$(MAKE) \
+	CXX='icpc' \
+	CXXFLAGS="$(ICCFLAGS-OSX)" \
+	CXXFLAGS+='-arch i386' \
+	LDFLAGS+='-arch i386' \
+	all
+
+osx-icc64:
+	$(MAKE) \
+	CXX='icpc' \
+	CXXFLAGS="$(ICCFLAGS-OSX)" \
+	CXXFLAGS+='-arch x86_64' \
+	LDFLAGS+='-arch x86_64' \
+	all
+
+osx-icc32-profile-make:
+	$(MAKE) \
+	CXX='icpc' \
+	CXXFLAGS="$(ICCFLAGS-OSX)" \
+	CXXFLAGS+='-arch i386' \
+	CXXFLAGS+='-prof_gen -prof_dir ./profdir' \
+	LDFLAGS+='-arch i386' \
+	all
+
+osx-icc32-profile-use:
+	$(MAKE) \
+	CXX='icpc' \
+	CXXFLAGS="$(ICCFLAGS-OSX)" \
+	CXXFLAGS+='-arch i386' \
+	CXXFLAGS+='-prof_use -prof_dir ./profdir' \
+	LDFLAGS+='-arch i386' \
+	all
+
+osx-icc32-profile:
+	@rm -rf profdir
+	@mkdir profdir
+	@touch *.cpp *.h
+	$(MAKE) osx-icc32-profile-make
+	@echo ""
+	@echo "Running benchmark for pgo-build ..."
+	@$(PGOBENCH) > /dev/null
+	@echo "Benchmark finished. Build final executable now ..."
+	@echo ""
+	@touch *.cpp *.h
+	$(MAKE) osx-icc32-profile-use
+	@rm -rf profdir bench.txt
+
+osx-icc64-profile-make:
+	$(MAKE) \
+	CXX='icpc' \
+	CXXFLAGS="$(ICCFLAGS-OSX)" \
+	CXXFLAGS+='-arch x86_64' \
+	CXXFLAGS+='-prof_gen -prof_dir ./profdir' \
+	LDFLAGS+='-arch x86_64' \
+	all
+
+osx-icc64-profile-use:
+	$(MAKE) \
+	CXX='icpc' \
+	CXXFLAGS="$(ICCFLAGS-OSX)" \
+	CXXFLAGS+='-arch x86_64' \
+	CXXFLAGS+='-prof_use -prof_dir ./profdir' \
+	LDFLAGS+='-arch x86_64' \
+	all
+
+osx-icc64-profile:
+	@rm -rf profdir
+	@mkdir profdir
+	@touch *.cpp *.h
+	$(MAKE) osx-icc64-profile-make
+	@echo ""
+	@echo "Running benchmark for pgo-build ..."
+	@$(PGOBENCH) > /dev/null
+	@echo "Benchmark finished. Build final executable now ..."
+	@echo ""
+	@touch *.cpp *.h
+	$(MAKE) osx-icc64-profile-use
+	@rm -rf profdir bench.txt
 
 
-###
-### Dependencies
-###
 
+strip:
+	strip $(EXE)
+
+
+### Compilation. Do not change
 $(EXE): $(OBJS)
 	$(CXX) $(LDFLAGS) -o $@ $(OBJS)
 
+
+### Dependencies. Do not change
 .depend:
-	$(CXX) -MM $(OBJS:.o=.cpp) > $@
+	$(CXX) -msse -MM $(OBJS:.o=.cpp) > $@
 
 include .depend
-
-
-###
-### Compiler and linker switches
-###
-
-# Enable/disable debugging:
-
-CXXFLAGS += -DNDEBUG
-
-
-# Compile with full warnings, and symbol names
-
-CXXFLAGS += -Wall -g
-
-
-# General optimization flags.  Note that -O2 might be faster than -O3 on some
-# systems; this requires testing.
-
-CXXFLAGS += -O3 -fno-exceptions -fomit-frame-pointer -fno-rtti -fstrict-aliasing
-
-
-# Compiler optimization flags for the Intel C++ compiler in Mac OS X:
-
-# CXXFLAGS += -mdynamic-no-pic -no-prec-div -ipo -static -xP
-
-
-# Profiler guided optimization with the Intel C++ compiler.  To use it, first
-# create the directory ./profdata if it does not already exist, and delete its
-# contents if it does exist.  Then compile with -prof_gen, and run the 
-# resulting binary for a while (for instance, do ./glaurung bench 128 1, and
-# wait 15 minutes for the benchmark to complete).  Then do a 'make clean', and 
-# recompile with -prof_use.
-
-# CXXFLAGS += -prof_gen -prof_dir ./profdata
-# CXXFLAGS += -prof_use -prof_dir ./profdata
-
-
-# Profiler guided optimization with GCC.  I've never been able to make this 
-# work.
-
-# CXXFLAGS += -fprofile-generate
-# LDFLAGS += -fprofile-generate
-# CXXFLAGS += -fprofile-use
-# CXXFLAGS += -fprofile-use
-
-
-# General linker flags
-
-LDFLAGS += -lm -lpthread
-
-
-# Compiler switches for generating binaries for various CPUs in Mac OS X.
-# Note that 'arch ppc' and 'arch ppc64' only works with g++, and not with
-# the intel compiler.
-
-# CXXFLAGS += -arch ppc
-# CXXFLAGS += -arch ppc64
-# CXXFLAGS += -arch i386
-# CXXFLAGS += -arch x86_64
-# LDFLAGS += -arch ppc
-# LDFLAGS += -arch ppc64
-# LDFLAGS += -arch i386
-# LDFLAGS += -arch x86_64
-
-
-# Backwards compatibility with Mac OS X 10.4 when compiling under 10.5 with 
-# GCC 4.0.  I haven't found a way to make it work with GCC 4.2.
-
-# CXXFLAGS += -isysroot /Developer/SDKs/MacOSX10.4u.sdk
-# CXXFLAGS += -mmacosx-version-min=10.4
-# LDFLAGS += -isysroot /Developer/SDKs/MacOSX10.4u.sdk
-# LDFLAGS += -Wl,-syslibroot /Developer/SDKs/MacOSX10.4u.sdk
-# LDFLAGS += -mmacosx-version-min=10.4
-
-
-# Backwards compatibility with Mac OS X 10.4 when compiling with ICC.  Doesn't
-# work yet. :-(
-
-# CXXFLAGS += -DMAC_OS_X_VERSION_MIN_REQUIRED=1040
-# CXXFLAGS += -DMAC_OS_X_VERSION_MAX_ALLOWED=1040
-# CXXFLAGS += -D__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__=1040
-# CXXFLAGS += -F/Developer/SDKs/MacOSX10.4u.sdk/
-# LDFLAGS += -Wl,-syslibroot -Wl,/Developer/SDKs/MacOSX10.4u.sdk

src/application.cpp

@@ -0,0 +1,75 @@
+/*
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
+
+  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 "bitboard.h"
+#include "direction.h"
+#include "endgame.h"
+#include "evaluate.h"
+#include "material.h"
+#include "mersenne.h"
+#include "misc.h"
+#include "movepick.h"
+#include "position.h"
+#include "search.h"
+#include "thread.h"
+#include "ucioption.h"
+
+
+/// Application class is in charge of initializing global resources
+/// at startup and cleanly releases them when program terminates.
+
+Application::Application() {
+
+    init_mersenne();
+    init_direction_table();
+    init_bitboards();
+    init_uci_options();
+    Position::init_zobrist();
+    Position::init_piece_square_tables();
+    init_eval(1);
+    init_bitbases();
+    init_threads();
+
+    // Make random number generation less deterministic, for book moves
+    for (int i = abs(get_system_time() % 10000); i > 0; i--)
+        genrand_int32();
+}
+
+Application::~Application() {
+
+  stop_threads();
+  quit_eval();
+}
+
+void Application::initialize() {
+
+  // A static Application object is allocated
+  // once only when this function is called.
+  static Application singleton;
+}
+
+void Application::exit_with_failure() {
+
+  exit(EXIT_FAILURE); // d'tor will be called automatically
+}

src/application.h

@@ -0,0 +1,39 @@
+/*
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
+
+  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/>.
+*/
+
+
+#if !defined(APPLICATION_H_INCLUDED)
+#define APPLICATION_H_INCLUDED
+
+
+/// Singleton class used to housekeep memory and global resources
+/// so to be sure we always leave in a clean state.
+
+class Application {
+
+  Application();
+  Application(const Application&);
+ ~Application();
+
+public:
+  static void initialize();
+  static void exit_with_failure();
+};
+
+#endif // !defined(APPLICATION_H_INCLUDED)

src/benchmark.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -20,18 +21,23 @@
 ////
 //// Includes
 ////
+#include <fstream>
+#include <sstream>
+#include <vector>
 
 #include "benchmark.h"
 #include "search.h"
 #include "thread.h"
 #include "ucioption.h"
 
+using namespace std;
 
 ////
 //// Variables
 ////
 
-const std::string BenchmarkPositions[15] = {
+const string BenchmarkPositions[] = {
+  "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1",
   "r4rk1/1b2qppp/p1n1p3/1p6/1b1PN3/3BRN2/PP3PPP/R2Q2K1 b - - 7 16",
   "4r1k1/ppq3pp/3b4/2pP4/2Q1p3/4B1P1/PP5P/R5K1 b - - 0 20",
   "4rrk1/pp1n3p/3q2pQ/2p1pb2/2PP4/2P3N1/P2B2PP/4RRK1 b - - 7 19",
@@ -54,38 +60,120 @@ const std::string BenchmarkPositions[15] = {
 //// Functions
 ////
 
-/// benchmark() runs a simple benchmark by letting Glaurung analyze 15
+/// benchmark() runs a simple benchmark by letting Stockfish analyze a set
-/// positions for 60 seconds each.  There are two parameters; the
+/// of positions for a given time each.  There are four parameters; the
-/// transposition table size and the number of search threads that should
+/// transposition table size, the number of search threads that should
-/// be used.  The analysis is written to a file named bench.txt.
+/// be used, the time in seconds spent for each position (optional, default
+/// is 60) and an optional file name where to look for positions in fen
+/// format (default are the BenchmarkPositions defined above).
+/// The analysis is written to a file named bench.txt.
 
-void benchmark(const std::string &ttSize, const std::string &threads) {
+void benchmark(const string& commandLine) {
-  Position pos;
-  Move moves[1] = {MOVE_NONE};
-  int i;
 
-  i = atoi(ttSize.c_str());
+  istringstream csVal(commandLine);
-  if(i < 4 || i > 1024) {
+  istringstream csStr(commandLine);
-    std::cerr << "The hash table size must be between 4 and 1024" << std::endl;
+  string ttSize, threads, fileName, limitType, timFile;
-    exit(EXIT_FAILURE);
+  int val, secsPerPos, maxDepth, maxNodes;
+
+  csStr >> ttSize;
+  csVal >> val;
+  if (val < 4 || val > 1024)
+  {
+      cerr << "The hash table size must be between 4 and 1024" << endl;
+      Application::exit_with_failure();
   }
-
+  csStr >> threads;
-  i = atoi(threads.c_str());
+  csVal >> val;
-  if(i < 1 || i > THREAD_MAX) {
+  if (val < 1 || val > THREAD_MAX)
-    std::cerr << "The number of threads must be between 1 and " << THREAD_MAX
+  {
-              << std::endl;
+      cerr << "The number of threads must be between 1 and " << THREAD_MAX << endl;
-    exit(EXIT_FAILURE);
+      Application::exit_with_failure();
   }
-  
   set_option_value("Hash", ttSize);
   set_option_value("Threads", threads);
   set_option_value("OwnBook", "false");
   set_option_value("Use Search Log", "true");
   set_option_value("Search Log Filename", "bench.txt");
 
-  for(i = 0; i < 15; i++) {
+  csVal >> val;
-    pos.from_fen(BenchmarkPositions[i]);
+  csVal >> fileName;
-    think(pos, true, false, 0, 0, 0, 0, 0, 60000, moves);
+  csVal >> limitType;
+  csVal >> timFile;
+
+  secsPerPos = maxDepth = maxNodes = 0;
+
+  if (limitType == "time")
+      secsPerPos = val * 1000;
+  else if (limitType == "depth")
+      maxDepth = val;
+  else
+      maxNodes = val;
+
+  vector<string> positions;
+
+  if (fileName != "default")
+  {
+      ifstream fenFile(fileName.c_str());
+      if (!fenFile.is_open())
+      {
+          cerr << "Unable to open positions file " << fileName << endl;
+          Application::exit_with_failure();
+      }
+      string pos;
+      while (fenFile.good())
+      {
+          getline(fenFile, pos);
+          if (!pos.empty())
+              positions.push_back(pos);
+      }
+      fenFile.close();
+  } else
+      for (int i = 0; i < 16; i++)
+          positions.push_back(string(BenchmarkPositions[i]));
+
+  ofstream timingFile;
+  if (!timFile.empty())
+  {
+      timingFile.open(timFile.c_str(), ios::out | ios::app);
+      if (!timingFile.is_open())
+      {
+          cerr << "Unable to open timing file " << timFile << endl;
+          Application::exit_with_failure();
+      }
   }
 
+  vector<string>::iterator it;
+  int cnt = 1;
+  int64_t totalNodes = 0;
+  int startTime = get_system_time();
+
+  for (it = positions.begin(); it != positions.end(); ++it, ++cnt)
+  {
+      Move moves[1] = {MOVE_NONE};
+      int dummy[2] = {0, 0};
+      Position pos(*it);
+      cerr << "\nBench position: " << cnt << '/' << positions.size() << endl << endl;
+      if (!think(pos, true, false, 0, dummy, dummy, 0, maxDepth, maxNodes, secsPerPos, moves))
+          break;
+      totalNodes += nodes_searched();
+  }
+
+  cnt = get_system_time() - startTime;
+  cerr << "==============================="
+       << "\nTotal time (ms) : " << cnt
+       << "\nNodes searched  : " << totalNodes
+       << "\nNodes/second    : " << (int)(totalNodes/(cnt/1000.0)) << endl << endl;
+
+  if (!timFile.empty())
+  {
+      timingFile << cnt << endl << endl;
+      timingFile.close();
+  }
+
+  // Under MS Visual C++ debug window always unconditionally closes
+  // when program exits, this is bad because we want to read results before.
+  #if (defined(WINDOWS) || defined(WIN32) || defined(WIN64))
+  cerr << "Press any key to exit" << endl;
+  cin >> fileName;
+  #endif
 }

src/benchmark.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -31,7 +32,6 @@
 //// Prototypes
 ////
 
-extern void benchmark(const std::string &ttSize, const std::string &threads);
+extern void benchmark(const std::string& commandLine);
-
 
 #endif // !defined(BENCHMARK_H_INCLUDED)

src/bitbase.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -88,7 +89,8 @@ void generate_kpk_bitbase(uint8_t bitbase[]) {
   int i, j, b;
   for(i = 0; i < 24576; i++) {
     for(b = 0, j = 0; j < 8; b |= (compress_result(Bitbase[8*i+j]) << j), j++);
-    bitbase[i] = b;
+    assert(b == int(uint8_t(b)));
+    bitbase[i] = (uint8_t)b;
   }
 
   // Release allocated memory:

src/bitbase.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.

src/bitboard.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -24,182 +25,11 @@
 #include <iostream>
 
 #include "bitboard.h"
+#include "bitcount.h"
 #include "direction.h"
 
 
-////
+#if defined(IS_64BIT)
-//// Constants and variables
-////
-
-const Bitboard SquaresByColorBB[2] = {BlackSquaresBB, WhiteSquaresBB};
-
-const Bitboard FileBB[8] = {
-  FileABB, FileBBB, FileCBB, FileDBB, FileEBB, FileFBB, FileGBB, FileHBB
-};
-
-const Bitboard NeighboringFilesBB[8] = {
-  FileBBB, FileABB|FileCBB, FileBBB|FileDBB, FileCBB|FileEBB, 
-  FileDBB|FileFBB, FileEBB|FileGBB, FileFBB|FileHBB, FileGBB
-};
-
-const Bitboard ThisAndNeighboringFilesBB[8] = {
-  FileABB|FileBBB, FileABB|FileBBB|FileCBB,
-  FileBBB|FileCBB|FileDBB, FileCBB|FileDBB|FileEBB,
-  FileDBB|FileEBB|FileFBB, FileEBB|FileFBB|FileGBB,
-  FileFBB|FileGBB|FileHBB, FileGBB|FileHBB
-};  
-
-const Bitboard RankBB[8] = {
-  Rank1BB, Rank2BB, Rank3BB, Rank4BB, Rank5BB, Rank6BB, Rank7BB, Rank8BB
-};
-
-const Bitboard RelativeRankBB[2][8] = {
-  {
-    Rank1BB, Rank2BB, Rank3BB, Rank4BB, Rank5BB, Rank6BB, Rank7BB, Rank8BB
-  },
-  {
-    Rank8BB, Rank7BB, Rank6BB, Rank5BB, Rank4BB, Rank3BB, Rank2BB, Rank1BB
-  }
-};
-
-const Bitboard InFrontBB[2][8] = {
-  {
-    Rank2BB | Rank3BB | Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
-    Rank3BB | Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
-    Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
-    Rank5BB | Rank6BB | Rank7BB | Rank8BB,
-    Rank6BB | Rank7BB | Rank8BB,
-    Rank7BB | Rank8BB,
-    Rank8BB,
-    EmptyBoardBB
-  },
-  {
-    EmptyBoardBB,
-    Rank1BB,
-    Rank2BB | Rank1BB,
-    Rank3BB | Rank2BB | Rank1BB,
-    Rank4BB | Rank3BB | Rank2BB | Rank1BB,
-    Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB,
-    Rank6BB | Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB,
-    Rank7BB | Rank6BB | Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB
-  }
-};
-
-#if defined(USE_COMPACT_ROOK_ATTACKS)
-
-Bitboard RankAttacks[8][64], FileAttacks[8][64];
-
-#elif defined(USE_32BIT_ATTACKS)
-
-const uint64_t RMult[64] = {
-  0xd7445cdec88002c0ULL, 0xd0a505c1f2001722ULL, 0xe065d1c896002182ULL,
-  0x9a8c41e75a000892ULL, 0x8900b10c89002aa8ULL, 0x9b28d1c1d60005a2ULL,
-  0x15d6c88de002d9aULL, 0xb1dbfc802e8016a9ULL, 0x149a1042d9d60029ULL,
-  0xb9c08050599e002fULL, 0x132208c3af300403ULL, 0xc1000ce2e9c50070ULL,
-  0x9d9aa13c99020012ULL, 0xb6b078daf71e0046ULL, 0x9d880182fb6e002eULL,
-  0x52889f467e850037ULL, 0xda6dc008d19a8480ULL, 0x468286034f902420ULL,
-  0x7140ac09dc54c020ULL, 0xd76ffffa39548808ULL, 0xea901c4141500808ULL,
-  0xc91004093f953a02ULL, 0x2882afa8f6bb402ULL, 0xaebe335692442c01ULL,
-  0xe904a22079fb91eULL, 0x13a514851055f606ULL, 0x76c782018c8fe632ULL,
-  0x1dc012a9d116da06ULL, 0x3c9e0037264fffa6ULL, 0x2036002853c6e4a2ULL,
-  0xe3fe08500afb47d4ULL, 0xf38af25c86b025c2ULL, 0xc0800e2182cf9a40ULL,
-  0x72002480d1f60673ULL, 0x2500200bae6e9b53ULL, 0xc60018c1eefca252ULL,
-  0x600590473e3608aULL, 0x46002c4ab3fe51b2ULL, 0xa200011486bcc8d2ULL,
-  0xb680078095784c63ULL, 0x2742002639bf11aeULL, 0xc7d60021a5bdb142ULL,
-  0xc8c04016bb83d820ULL, 0xbd520028123b4842ULL, 0x9d1600344ac2a832ULL,
-  0x6a808005631c8a05ULL, 0x604600a148d5389aULL, 0xe2e40103d40dea65ULL,
-  0x945b5a0087c62a81ULL, 0x12dc200cd82d28eULL, 0x2431c600b5f9ef76ULL,
-  0xfb142a006a9b314aULL, 0x6870e00a1c97d62ULL, 0x2a9db2004a2689a2ULL,
-  0xd3594600caf5d1a2ULL, 0xee0e4900439344a7ULL, 0x89c4d266ca25007aULL,
-  0x3e0013a2743f97e3ULL, 0x180e31a0431378aULL, 0x3a9e465a4d42a512ULL,
-  0x98d0a11a0c0d9cc2ULL, 0x8e711c1aba19b01eULL, 0x8dcdc836dd201142ULL,
-  0x5ac08a4735370479ULL,
-};
-
-const int RShift[64] = {
-  20, 21, 21, 21, 21, 21, 21, 20, 21, 22, 22, 22, 22, 22, 22, 21,
-  21, 22, 22, 22, 22, 22, 22, 21, 21, 22, 22, 22, 22, 22, 22, 21,
-  21, 22, 22, 22, 22, 22, 22, 21, 21, 22, 22, 22, 22, 22, 22, 21,
-  21, 22, 22, 22, 22, 22, 22, 21, 20, 21, 21, 21, 21, 21, 21, 20
-};
-
-#else // if defined(USE_32BIT_ATTACKS)
-
-const uint64_t RMult[64] = {
-  0xa8002c000108020ULL, 0x4440200140003000ULL, 0x8080200010011880ULL, 
-  0x380180080141000ULL, 0x1a00060008211044ULL, 0x410001000a0c0008ULL, 
-  0x9500060004008100ULL, 0x100024284a20700ULL, 0x802140008000ULL, 
-  0x80c01002a00840ULL, 0x402004282011020ULL, 0x9862000820420050ULL, 
-  0x1001448011100ULL, 0x6432800200800400ULL, 0x40100010002000cULL, 
-  0x2800d0010c080ULL, 0x90c0008000803042ULL, 0x4010004000200041ULL, 
-  0x3010010200040ULL, 0xa40828028001000ULL, 0x123010008000430ULL, 
-  0x24008004020080ULL, 0x60040001104802ULL, 0x582200028400d1ULL, 
-  0x4000802080044000ULL, 0x408208200420308ULL, 0x610038080102000ULL, 
-  0x3601000900100020ULL, 0x80080040180ULL, 0xc2020080040080ULL, 
-  0x80084400100102ULL, 0x4022408200014401ULL, 0x40052040800082ULL, 
-  0xb08200280804000ULL, 0x8a80a008801000ULL, 0x4000480080801000ULL, 
-  0x911808800801401ULL, 0x822a003002001894ULL, 0x401068091400108aULL, 
-  0x4a10a00004cULL, 0x2000800640008024ULL, 0x1486408102020020ULL, 
-  0x100a000d50041ULL, 0x810050020b0020ULL, 0x204000800808004ULL, 
-  0x20048100a000cULL, 0x112000831020004ULL, 0x9000040810002ULL, 
-  0x440490200208200ULL, 0x8910401000200040ULL, 0x6404200050008480ULL, 
-  0x4b824a2010010100ULL, 0x4080801810c0080ULL, 0x400802a0080ULL, 
-  0x8224080110026400ULL, 0x40002c4104088200ULL, 0x1002100104a0282ULL, 
-  0x1208400811048021ULL, 0x3201014a40d02001ULL, 0x5100019200501ULL, 
-  0x101000208001005ULL, 0x2008450080702ULL, 0x1002080301d00cULL, 
-  0x410201ce5c030092ULL
-};
-
-const int RShift[64] = {
-  52, 53, 53, 53, 53, 53, 53, 52, 53, 54, 54, 54, 54, 54, 54, 53,
-  53, 54, 54, 54, 54, 54, 54, 53, 53, 54, 54, 54, 54, 54, 54, 53,
-  53, 54, 54, 54, 54, 54, 54, 53, 53, 54, 54, 54, 54, 54, 54, 53,
-  53, 54, 54, 54, 54, 54, 54, 53, 52, 53, 53, 53, 53, 53, 53, 52
-};
-
-#endif // defined(USE_32BIT_ATTACKS)
-
-#if !defined(USE_COMPACT_ROOK_ATTACKS)
-Bitboard RMask[64];
-int RAttackIndex[64];
-Bitboard RAttacks[0x19000];
-#endif
-
-#if defined(USE_32BIT_ATTACKS)
-
-const uint64_t BMult[64] = {
-  0x54142844c6a22981ULL, 0x710358a6ea25c19eULL, 0x704f746d63a4a8dcULL,
-  0xbfed1a0b80f838c5ULL, 0x90561d5631e62110ULL, 0x2804260376e60944ULL,
-  0x84a656409aa76871ULL, 0xf0267f64c28b6197ULL, 0x70764ebb762f0585ULL,
-  0x92aa09e0cfe161deULL, 0x41ee1f6bb266f60eULL, 0xddcbf04f6039c444ULL,
-  0x5a3fab7bac0d988aULL, 0xd3727877fa4eaa03ULL, 0xd988402d868ddaaeULL,
-  0x812b291afa075c7cULL, 0x94faf987b685a932ULL, 0x3ed867d8470d08dbULL,
-  0x92517660b8901de8ULL, 0x2d97e43e058814b4ULL, 0x880a10c220b25582ULL,
-  0xc7c6520d1f1a0477ULL, 0xdbfc7fbcd7656aa6ULL, 0x78b1b9bfb1a2b84fULL,
-  0x2f20037f112a0bc1ULL, 0x657171ea2269a916ULL, 0xc08302b07142210eULL,
-  0x880a4403064080bULL, 0x3602420842208c00ULL, 0x852800dc7e0b6602ULL,
-  0x595a3fbbaa0f03b2ULL, 0x9f01411558159d5eULL, 0x2b4a4a5f88b394f2ULL,
-  0x4afcbffc292dd03aULL, 0x4a4094a3b3f10522ULL, 0xb06f00b491f30048ULL,
-  0xd5b3820280d77004ULL, 0x8b2e01e7c8e57a75ULL, 0x2d342794e886c2e6ULL,
-  0xc302c410cde21461ULL, 0x111f426f1379c274ULL, 0xe0569220abb31588ULL,
-  0x5026d3064d453324ULL, 0xe2076040c343cd8aULL, 0x93efd1e1738021eeULL,
-  0xb680804bed143132ULL, 0x44e361b21986944cULL, 0x44c60170ef5c598cULL,
-  0xf4da475c195c9c94ULL, 0xa3afbb5f72060b1dULL, 0xbc75f410e41c4ffcULL,
-  0xb51c099390520922ULL, 0x902c011f8f8ec368ULL, 0x950b56b3d6f5490aULL,
-  0x3909e0635bf202d0ULL, 0x5744f90206ec10ccULL, 0xdc59fd76317abbc1ULL,
-  0x881c7c67fcbfc4f6ULL, 0x47ca41e7e440d423ULL, 0xeb0c88112048d004ULL,
-  0x51c60e04359aef1aULL, 0x1aa1fe0e957a5554ULL, 0xdd9448db4f5e3104ULL,
-  0xdc01f6dca4bebbdcULL,
-}; 
-
-const int BShift[64] = {
-  26, 27, 27, 27, 27, 27, 27, 26, 27, 27, 27, 27, 27, 27, 27, 27,
-  27, 27, 25, 25, 25, 25, 27, 27, 27, 27, 25, 23, 23, 25, 27, 27,
-  27, 27, 25, 23, 23, 25, 27, 27, 27, 27, 25, 25, 25, 25, 27, 27,
-  27, 27, 27, 27, 27, 27, 27, 27, 26, 27, 27, 27, 27, 27, 27, 26
-};
-
-#else // if defined(USE_32BIT_ATTACKS)
 
 const uint64_t BMult[64] = {
   0x440049104032280ULL, 0x1021023c82008040ULL, 0x404040082000048ULL,
@@ -226,6 +56,31 @@ const uint64_t BMult[64] = {
   0xa08520292120600ULL
 };
 
+const uint64_t RMult[64] = {
+  0xa8002c000108020ULL, 0x4440200140003000ULL, 0x8080200010011880ULL,
+  0x380180080141000ULL, 0x1a00060008211044ULL, 0x410001000a0c0008ULL,
+  0x9500060004008100ULL, 0x100024284a20700ULL, 0x802140008000ULL,
+  0x80c01002a00840ULL, 0x402004282011020ULL, 0x9862000820420050ULL,
+  0x1001448011100ULL, 0x6432800200800400ULL, 0x40100010002000cULL,
+  0x2800d0010c080ULL, 0x90c0008000803042ULL, 0x4010004000200041ULL,
+  0x3010010200040ULL, 0xa40828028001000ULL, 0x123010008000430ULL,
+  0x24008004020080ULL, 0x60040001104802ULL, 0x582200028400d1ULL,
+  0x4000802080044000ULL, 0x408208200420308ULL, 0x610038080102000ULL,
+  0x3601000900100020ULL, 0x80080040180ULL, 0xc2020080040080ULL,
+  0x80084400100102ULL, 0x4022408200014401ULL, 0x40052040800082ULL,
+  0xb08200280804000ULL, 0x8a80a008801000ULL, 0x4000480080801000ULL,
+  0x911808800801401ULL, 0x822a003002001894ULL, 0x401068091400108aULL,
+  0x4a10a00004cULL, 0x2000800640008024ULL, 0x1486408102020020ULL,
+  0x100a000d50041ULL, 0x810050020b0020ULL, 0x204000800808004ULL,
+  0x20048100a000cULL, 0x112000831020004ULL, 0x9000040810002ULL,
+  0x440490200208200ULL, 0x8910401000200040ULL, 0x6404200050008480ULL,
+  0x4b824a2010010100ULL, 0x4080801810c0080ULL, 0x400802a0080ULL,
+  0x8224080110026400ULL, 0x40002c4104088200ULL, 0x1002100104a0282ULL,
+  0x1208400811048021ULL, 0x3201014a40d02001ULL, 0x5100019200501ULL,
+  0x101000208001005ULL, 0x2008450080702ULL, 0x1002080301d00cULL,
+  0x410201ce5c030092ULL
+};
+
 const int BShift[64] = {
   58, 59, 59, 59, 59, 59, 59, 58, 59, 59, 59, 59, 59, 59, 59, 59,
   59, 59, 57, 57, 57, 57, 59, 59, 59, 59, 57, 55, 55, 57, 59, 59,
@@ -233,14 +88,139 @@ const int BShift[64] = {
   59, 59, 59, 59, 59, 59, 59, 59, 58, 59, 59, 59, 59, 59, 59, 58
 };
 
-#endif // defined(USE_32BIT_ATTACKS)
+const int RShift[64] = {
+  52, 53, 53, 53, 53, 53, 53, 52, 53, 54, 54, 54, 54, 54, 54, 53,
+  53, 54, 54, 54, 54, 54, 54, 53, 53, 54, 54, 54, 54, 54, 54, 53,
+  53, 54, 54, 54, 54, 54, 54, 53, 53, 54, 54, 54, 54, 54, 54, 53,
+  53, 54, 54, 54, 54, 54, 54, 53, 52, 53, 53, 53, 53, 53, 53, 52
+};
+
+#else // if !defined(IS_64BIT)
+
+const uint64_t BMult[64] = {
+  0x54142844c6a22981ULL, 0x710358a6ea25c19eULL, 0x704f746d63a4a8dcULL,
+  0xbfed1a0b80f838c5ULL, 0x90561d5631e62110ULL, 0x2804260376e60944ULL,
+  0x84a656409aa76871ULL, 0xf0267f64c28b6197ULL, 0x70764ebb762f0585ULL,
+  0x92aa09e0cfe161deULL, 0x41ee1f6bb266f60eULL, 0xddcbf04f6039c444ULL,
+  0x5a3fab7bac0d988aULL, 0xd3727877fa4eaa03ULL, 0xd988402d868ddaaeULL,
+  0x812b291afa075c7cULL, 0x94faf987b685a932ULL, 0x3ed867d8470d08dbULL,
+  0x92517660b8901de8ULL, 0x2d97e43e058814b4ULL, 0x880a10c220b25582ULL,
+  0xc7c6520d1f1a0477ULL, 0xdbfc7fbcd7656aa6ULL, 0x78b1b9bfb1a2b84fULL,
+  0x2f20037f112a0bc1ULL, 0x657171ea2269a916ULL, 0xc08302b07142210eULL,
+  0x880a4403064080bULL, 0x3602420842208c00ULL, 0x852800dc7e0b6602ULL,
+  0x595a3fbbaa0f03b2ULL, 0x9f01411558159d5eULL, 0x2b4a4a5f88b394f2ULL,
+  0x4afcbffc292dd03aULL, 0x4a4094a3b3f10522ULL, 0xb06f00b491f30048ULL,
+  0xd5b3820280d77004ULL, 0x8b2e01e7c8e57a75ULL, 0x2d342794e886c2e6ULL,
+  0xc302c410cde21461ULL, 0x111f426f1379c274ULL, 0xe0569220abb31588ULL,
+  0x5026d3064d453324ULL, 0xe2076040c343cd8aULL, 0x93efd1e1738021eeULL,
+  0xb680804bed143132ULL, 0x44e361b21986944cULL, 0x44c60170ef5c598cULL,
+  0xf4da475c195c9c94ULL, 0xa3afbb5f72060b1dULL, 0xbc75f410e41c4ffcULL,
+  0xb51c099390520922ULL, 0x902c011f8f8ec368ULL, 0x950b56b3d6f5490aULL,
+  0x3909e0635bf202d0ULL, 0x5744f90206ec10ccULL, 0xdc59fd76317abbc1ULL,
+  0x881c7c67fcbfc4f6ULL, 0x47ca41e7e440d423ULL, 0xeb0c88112048d004ULL,
+  0x51c60e04359aef1aULL, 0x1aa1fe0e957a5554ULL, 0xdd9448db4f5e3104ULL,
+  0xdc01f6dca4bebbdcULL,
+};
+
+const uint64_t RMult[64] = {
+  0xd7445cdec88002c0ULL, 0xd0a505c1f2001722ULL, 0xe065d1c896002182ULL,
+  0x9a8c41e75a000892ULL, 0x8900b10c89002aa8ULL, 0x9b28d1c1d60005a2ULL,
+  0x15d6c88de002d9aULL, 0xb1dbfc802e8016a9ULL, 0x149a1042d9d60029ULL,
+  0xb9c08050599e002fULL, 0x132208c3af300403ULL, 0xc1000ce2e9c50070ULL,
+  0x9d9aa13c99020012ULL, 0xb6b078daf71e0046ULL, 0x9d880182fb6e002eULL,
+  0x52889f467e850037ULL, 0xda6dc008d19a8480ULL, 0x468286034f902420ULL,
+  0x7140ac09dc54c020ULL, 0xd76ffffa39548808ULL, 0xea901c4141500808ULL,
+  0xc91004093f953a02ULL, 0x2882afa8f6bb402ULL, 0xaebe335692442c01ULL,
+  0xe904a22079fb91eULL, 0x13a514851055f606ULL, 0x76c782018c8fe632ULL,
+  0x1dc012a9d116da06ULL, 0x3c9e0037264fffa6ULL, 0x2036002853c6e4a2ULL,
+  0xe3fe08500afb47d4ULL, 0xf38af25c86b025c2ULL, 0xc0800e2182cf9a40ULL,
+  0x72002480d1f60673ULL, 0x2500200bae6e9b53ULL, 0xc60018c1eefca252ULL,
+  0x600590473e3608aULL, 0x46002c4ab3fe51b2ULL, 0xa200011486bcc8d2ULL,
+  0xb680078095784c63ULL, 0x2742002639bf11aeULL, 0xc7d60021a5bdb142ULL,
+  0xc8c04016bb83d820ULL, 0xbd520028123b4842ULL, 0x9d1600344ac2a832ULL,
+  0x6a808005631c8a05ULL, 0x604600a148d5389aULL, 0xe2e40103d40dea65ULL,
+  0x945b5a0087c62a81ULL, 0x12dc200cd82d28eULL, 0x2431c600b5f9ef76ULL,
+  0xfb142a006a9b314aULL, 0x6870e00a1c97d62ULL, 0x2a9db2004a2689a2ULL,
+  0xd3594600caf5d1a2ULL, 0xee0e4900439344a7ULL, 0x89c4d266ca25007aULL,
+  0x3e0013a2743f97e3ULL, 0x180e31a0431378aULL, 0x3a9e465a4d42a512ULL,
+  0x98d0a11a0c0d9cc2ULL, 0x8e711c1aba19b01eULL, 0x8dcdc836dd201142ULL,
+  0x5ac08a4735370479ULL,
+};
+
+const int BShift[64] = {
+  26, 27, 27, 27, 27, 27, 27, 26, 27, 27, 27, 27, 27, 27, 27, 27,
+  27, 27, 25, 25, 25, 25, 27, 27, 27, 27, 25, 23, 23, 25, 27, 27,
+  27, 27, 25, 23, 23, 25, 27, 27, 27, 27, 25, 25, 25, 25, 27, 27,
+  27, 27, 27, 27, 27, 27, 27, 27, 26, 27, 27, 27, 27, 27, 27, 26
+};
+
+const int RShift[64] = {
+  20, 21, 21, 21, 21, 21, 21, 20, 21, 22, 22, 22, 22, 22, 22, 21,
+  21, 22, 22, 22, 22, 22, 22, 21, 21, 22, 22, 22, 22, 22, 22, 21,
+  21, 22, 22, 22, 22, 22, 22, 21, 21, 22, 22, 22, 22, 22, 22, 21,
+  21, 22, 22, 22, 22, 22, 22, 21, 20, 21, 21, 21, 21, 21, 21, 20
+};
+
+#endif // defined(IS_64BIT)
+
+const Bitboard SquaresByColorBB[2] = { BlackSquaresBB, WhiteSquaresBB };
+
+const Bitboard FileBB[8] = {
+  FileABB, FileBBB, FileCBB, FileDBB, FileEBB, FileFBB, FileGBB, FileHBB
+};
+
+const Bitboard NeighboringFilesBB[8] = {
+  FileBBB, FileABB|FileCBB, FileBBB|FileDBB, FileCBB|FileEBB,
+  FileDBB|FileFBB, FileEBB|FileGBB, FileFBB|FileHBB, FileGBB
+};
+
+const Bitboard ThisAndNeighboringFilesBB[8] = {
+  FileABB|FileBBB, FileABB|FileBBB|FileCBB,
+  FileBBB|FileCBB|FileDBB, FileCBB|FileDBB|FileEBB,
+  FileDBB|FileEBB|FileFBB, FileEBB|FileFBB|FileGBB,
+  FileFBB|FileGBB|FileHBB, FileGBB|FileHBB
+};
+
+const Bitboard RankBB[8] = {
+  Rank1BB, Rank2BB, Rank3BB, Rank4BB, Rank5BB, Rank6BB, Rank7BB, Rank8BB
+};
+
+const Bitboard RelativeRankBB[2][8] = {
+  { Rank1BB, Rank2BB, Rank3BB, Rank4BB, Rank5BB, Rank6BB, Rank7BB, Rank8BB },
+  { Rank8BB, Rank7BB, Rank6BB, Rank5BB, Rank4BB, Rank3BB, Rank2BB, Rank1BB }
+};
+
+const Bitboard InFrontBB[2][8] = {
+  { Rank2BB | Rank3BB | Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
+    Rank3BB | Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
+    Rank4BB | Rank5BB | Rank6BB | Rank7BB | Rank8BB,
+    Rank5BB | Rank6BB | Rank7BB | Rank8BB,
+    Rank6BB | Rank7BB | Rank8BB,
+    Rank7BB | Rank8BB,
+    Rank8BB,
+    EmptyBoardBB
+  },
+  { EmptyBoardBB,
+    Rank1BB,
+    Rank2BB | Rank1BB,
+    Rank3BB | Rank2BB | Rank1BB,
+    Rank4BB | Rank3BB | Rank2BB | Rank1BB,
+    Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB,
+    Rank6BB | Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB,
+    Rank7BB | Rank6BB | Rank5BB | Rank4BB | Rank3BB | Rank2BB | Rank1BB
+  }
+};
+
+Bitboard RMask[64];
+int RAttackIndex[64];
+Bitboard RAttacks[0x19000];
 
 Bitboard BMask[64];
 int BAttackIndex[64];
 Bitboard BAttacks[0x1480];
 
-Bitboard SetMaskBB[64];
+Bitboard SetMaskBB[65];
-Bitboard ClearMaskBB[64];
+Bitboard ClearMaskBB[65];
 
 Bitboard StepAttackBB[16][64];
 Bitboard RayBB[64][8];
@@ -253,12 +233,15 @@ Bitboard BishopPseudoAttacks[64];
 Bitboard RookPseudoAttacks[64];
 Bitboard QueenPseudoAttacks[64];
 
+uint8_t BitCount8Bit[256];
+
 
 ////
 //// Local definitions
 ////
 
 namespace {
+
   void init_masks();
   void init_ray_bitboards();
   void init_attacks();
@@ -271,10 +254,7 @@ namespace {
                             const int shift[2], const Bitboard mult[],
                             int deltas[][2]);
   void init_pseudo_attacks();
-#if defined(USE_COMPACT_ROOK_ATTACKS)
+}
-  void init_file_and_rank_attacks();
-#endif
-};
 
 
 ////
@@ -305,49 +285,19 @@ void init_bitboards() {
   init_ray_bitboards();
   init_attacks();
   init_between_bitboards();
-#if defined(USE_COMPACT_ROOK_ATTACKS)
+  init_sliding_attacks(RAttacks, RAttackIndex, RMask, RShift, RMult, rookDeltas);
-  init_file_and_rank_attacks();
+  init_sliding_attacks(BAttacks, BAttackIndex, BMask, BShift, BMult, bishopDeltas);
-#else
-  init_sliding_attacks(RAttacks, RAttackIndex, RMask, RShift,
-                       RMult, rookDeltas);
-#endif
-  init_sliding_attacks(BAttacks, BAttackIndex, BMask, BShift,
-                       BMult, bishopDeltas);
   init_pseudo_attacks();
 }
 
 
-#if defined(USE_FOLDED_BITSCAN)
-
-static const int BitTable[64] = {
-  63, 30, 3, 32, 25, 41, 22, 33, 15, 50, 42, 13, 11, 53, 19, 34, 61, 29, 2, 
-  51, 21, 43, 45, 10, 18, 47, 1, 54, 9, 57, 0, 35, 62, 31, 40, 4, 49, 5, 52, 
-  26, 60, 6, 23, 44, 46, 27, 56, 16, 7, 39, 48, 24, 59, 14, 12, 55, 38, 28, 
-  58, 20, 37, 17, 36, 8
-};
-
-
 /// first_1() finds the least significant nonzero bit in a nonzero bitboard.
-
-Square first_1(Bitboard b) {
-  b ^= (b - 1);
-  uint32_t fold = int(b) ^ int(b >> 32);
-  return Square(BitTable[(fold * 0x783a9b23) >> 26]);
-}
-
-
 /// pop_1st_bit() finds and clears the least significant nonzero bit in a
 /// nonzero bitboard.
 
-Square pop_1st_bit(Bitboard *b) {
+#if defined(IS_64BIT) && !defined(USE_BSFQ)
-  Bitboard bb = *b ^ (*b - 1);
-  uint32_t fold = int(bb) ^ int(bb >> 32);
-  *b &= (*b - 1);
-  return Square(BitTable[(fold * 0x783a9b23) >> 26]);
-}
-
-#else
 
+CACHE_LINE_ALIGNMENT
 static const int BitTable[64] = {
   0, 1, 2, 7, 3, 13, 8, 19, 4, 25, 14, 28, 9, 34, 20, 40, 5, 17, 26, 38, 15,
   46, 29, 48, 10, 31, 35, 54, 21, 50, 41, 57, 63, 6, 12, 18, 24, 27, 33, 39,
@@ -355,25 +305,60 @@ static const int BitTable[64] = {
   51, 60, 42, 59, 58
 };
 
-
-/// first_1() finds the least significant nonzero bit in a nonzero bitboard.
-
 Square first_1(Bitboard b) {
   return Square(BitTable[((b & -b) * 0x218a392cd3d5dbfULL) >> 58]);
 }
 
-
-/// pop_1st_bit() finds and clears the least significant nonzero bit in a
-/// nonzero bitboard.
-
 Square pop_1st_bit(Bitboard* b) {
   Bitboard bb = *b;
   *b &= (*b - 1);
   return Square(BitTable[((bb & -bb) * 0x218a392cd3d5dbfULL) >> 58]);
 }
 
-#endif // defined(USE_FOLDED_BITSCAN)
+#elif !defined(USE_BSFQ)
 
+CACHE_LINE_ALIGNMENT
+static const int BitTable[64] = {
+  63, 30, 3, 32, 25, 41, 22, 33, 15, 50, 42, 13, 11, 53, 19, 34, 61, 29, 2,
+  51, 21, 43, 45, 10, 18, 47, 1, 54, 9, 57, 0, 35, 62, 31, 40, 4, 49, 5, 52,
+  26, 60, 6, 23, 44, 46, 27, 56, 16, 7, 39, 48, 24, 59, 14, 12, 55, 38, 28,
+  58, 20, 37, 17, 36, 8
+};
+
+Square first_1(Bitboard b) {
+  b ^= (b - 1);
+  uint32_t fold = int(b) ^ int(b >> 32);
+  return Square(BitTable[(fold * 0x783a9b23) >> 26]);
+}
+
+// Use type-punning
+union b_union {
+
+    Bitboard b;
+    struct {
+        uint32_t l;
+        uint32_t h;
+    } dw;
+};
+
+// WARNING: Needs -fno-strict-aliasing compiler option
+Square pop_1st_bit(Bitboard* bb) {
+
+  b_union u;
+
+  u.b = *bb;
+
+  if (u.dw.l)
+  {
+      *((uint32_t*)bb) = u.dw.l & (u.dw.l - 1);
+      return Square(BitTable[((u.dw.l ^ (u.dw.l - 1)) * 0x783a9b23) >> 26]);
+  }
+
+  *((uint32_t*)bb+1) = u.dw.h & (u.dw.h - 1); // Little endian only?
+  return Square(BitTable[((~(u.dw.h ^ (u.dw.h - 1))) * 0x783a9b23) >> 26]);
+}
+
+#endif
 
 namespace {
 
@@ -383,6 +368,8 @@ namespace {
   // be necessary to touch any of them.
 
   void init_masks() {
+    SetMaskBB[SQ_NONE] = 0ULL;
+    ClearMaskBB[SQ_NONE] = ~SetMaskBB[SQ_NONE];
     for(Square s = SQ_A1; s <= SQ_H8; s++) {
       SetMaskBB[s] = (1ULL << s);
       ClearMaskBB[s] = ~SetMaskBB[s];
@@ -393,12 +380,15 @@ namespace {
           in_front_bb(c, s) & this_and_neighboring_files_bb(s);
         OutpostMask[c][s] = in_front_bb(c, s) & neighboring_files_bb(s);
       }
+
+    for (Bitboard b = 0ULL; b < 256ULL; b++)
+        BitCount8Bit[b] = (uint8_t)count_1s(b);
   }
 
 
   void init_ray_bitboards() {
     int d[8] = {1, -1, 16, -16, 17, -17, 15, -15};
-    for(int i = 0; i < 128; i = i + 9 & ~8) {
+    for(int i = 0; i < 128; i = (i + 9) & ~8) {
       for(int j = 0; j < 8; j++) {
         RayBB[(i&7)|((i>>4)<<3)][j] = EmptyBoardBB;
         for(int k = i + d[j]; (k & 0x88) == 0; k += d[j])
@@ -484,19 +474,26 @@ namespace {
     for(i = 0; i < 64; i++) {
       attackIndex[i] = index;
       mask[i] = sliding_attacks(i, 0ULL, 4, deltas, 1, 6, 1, 6);
+
+#if defined(IS_64BIT)
       j = (1 << (64 - shift[i]));
+#else
+      j = (1 << (32 - shift[i]));
+#endif
+
       for(k = 0; k < j; k++) {
-#if defined(USE_32BIT_ATTACKS)
+
+#if defined(IS_64BIT)
+        b = index_to_bitboard(k, mask[i]);
+        attacks[index + ((b * mult[i]) >> shift[i])] =
+          sliding_attacks(i, b, 4, deltas);
+#else
         b = index_to_bitboard(k, mask[i]);
         attacks[index +
                  (unsigned(int(b) * int(mult[i]) ^
                            int(b >> 32) * int(mult[i] >> 32))
                   >> shift[i])] =
           sliding_attacks(i, b, 4, deltas);
-#else
-        b = index_to_bitboard(k, mask[i]);
-        attacks[index + ((b * mult[i]) >> shift[i])] =
-          sliding_attacks(i, b, 4, deltas);
 #endif
       }
       index += j;
@@ -513,29 +510,4 @@ namespace {
     }
   }
 
-#if defined(USE_COMPACT_ROOK_ATTACKS)
-  void init_file_and_rank_attacks() {
-    int i, j, k, l, m, s;
-    Bitboard b1, b2;
-    for(i = 0; i < 64; i++) {
-
-      for(m = 0; m <= 1; m++) {
-        b1 = 0ULL;
-        for(j = 0; j < 6; j++) if(i & (1<<j)) b1 |= (1ULL << ((j+1)*(1+m*7)));
-        for(j = 0; j < 8; j++) {
-          b2 = 0ULL;
-          for(k = 0, s = 1; k < 2; k++, s *= -1) {
-            for(l = j+s; l >= 0 && l <= 7; l += s) {
-              b2 |= (m? RankBB[l] : FileBB[l]);
-              if(b1 & (1ULL << (l*(1+m*7)))) break;
-            }
-          }
-          if(m) FileAttacks[j][(b1*0xd6e8802041d0c441ULL) >> 58] = b2;
-          else RankAttacks[j][i] = b2;
-        }
-      }
-    }
-  }
-#endif // defined(USE_COMPACT_ROOK_ATTACKS)
-    
 }

src/bitboard.h

@@ -1,13 +1,15 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+
+  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.
@@ -20,21 +22,6 @@
 #if !defined(BITBOARD_H_INCLUDED)
 #define BITBOARD_H_INCLUDED
 
-
-////
-//// Defines
-////
-
-//#define USE_COMPACT_ROOK_ATTACKS
-//#define USE_32BIT_ATTACKS 
-#define USE_FOLDED_BITSCAN
-
-#define BITCOUNT_SWAR_64
-//#define BITCOUNT_SWAR_32
-//#define BITCOUNT_LOOP
-
-
-
 ////
 //// Includes
 ////
@@ -45,13 +32,6 @@
 #include "types.h"
 
 
-////
-//// Types
-////
-
-typedef uint64_t Bitboard;
-
-
 ////
 //// Constants and variables
 ////
@@ -61,8 +41,6 @@ const Bitboard EmptyBoardBB = 0ULL;
 const Bitboard WhiteSquaresBB = 0x55AA55AA55AA55AAULL;
 const Bitboard BlackSquaresBB = 0xAA55AA55AA55AA55ULL;
 
-extern const Bitboard SquaresByColorBB[2];
-
 const Bitboard FileABB = 0x0101010101010101ULL;
 const Bitboard FileBBB = 0x0202020202020202ULL;
 const Bitboard FileCBB = 0x0404040404040404ULL;
@@ -72,10 +50,6 @@ const Bitboard FileFBB = 0x2020202020202020ULL;
 const Bitboard FileGBB = 0x4040404040404040ULL;
 const Bitboard FileHBB = 0x8080808080808080ULL;
 
-extern const Bitboard FileBB[8];
-extern const Bitboard NeighboringFilesBB[8];
-extern const Bitboard ThisAndNeighboringFilesBB[8];  
-
 const Bitboard Rank1BB = 0xFFULL;
 const Bitboard Rank2BB = 0xFF00ULL;
 const Bitboard Rank3BB = 0xFF0000ULL;
@@ -85,12 +59,16 @@ const Bitboard Rank6BB = 0xFF0000000000ULL;
 const Bitboard Rank7BB = 0xFF000000000000ULL;
 const Bitboard Rank8BB = 0xFF00000000000000ULL;
 
+extern const Bitboard SquaresByColorBB[2];
+extern const Bitboard FileBB[8];
+extern const Bitboard NeighboringFilesBB[8];
+extern const Bitboard ThisAndNeighboringFilesBB[8];
 extern const Bitboard RankBB[8];
 extern const Bitboard RelativeRankBB[2][8];
 extern const Bitboard InFrontBB[2][8];
 
-extern Bitboard SetMaskBB[64];
+extern Bitboard SetMaskBB[65];
-extern Bitboard ClearMaskBB[64];
+extern Bitboard ClearMaskBB[65];
 
 extern Bitboard StepAttackBB[16][64];
 extern Bitboard RayBB[64][8];
@@ -99,15 +77,11 @@ extern Bitboard BetweenBB[64][64];
 extern Bitboard PassedPawnMask[2][64];
 extern Bitboard OutpostMask[2][64];
 
-#if defined(USE_COMPACT_ROOK_ATTACKS)
-extern Bitboard RankAttacks[8][64], FileAttacks[8][64];
-#else
 extern const uint64_t RMult[64];
 extern const int RShift[64];
 extern Bitboard RMask[64];
 extern int RAttackIndex[64];
 extern Bitboard RAttacks[0x19000];
-#endif // defined(USE_COMPACT_ROOK_ATTACKS)
 
 extern const uint64_t BMult[64];
 extern const int BShift[64];
@@ -119,6 +93,8 @@ extern Bitboard BishopPseudoAttacks[64];
 extern Bitboard RookPseudoAttacks[64];
 extern Bitboard QueenPseudoAttacks[64];
 
+extern uint8_t BitCount8Bit[256];
+
 
 ////
 //// Inline functions
@@ -127,29 +103,30 @@ extern Bitboard QueenPseudoAttacks[64];
 /// Functions for testing whether a given bit is set in a bitboard, and for
 /// setting and clearing bits.
 
-inline Bitboard set_mask_bb(Square s) {
-  //  return 1ULL << s;
-  return SetMaskBB[s];
-}
-
-inline Bitboard clear_mask_bb(Square s) {
-  //  return ~set_mask_bb(s);
-  return ClearMaskBB[s];
-}
-
 inline Bitboard bit_is_set(Bitboard b, Square s) {
-  return b & set_mask_bb(s);
+  return b & SetMaskBB[s];
 }
 
 inline void set_bit(Bitboard *b, Square s) {
-  *b |= set_mask_bb(s);
+  *b |= SetMaskBB[s];
 }
 
 inline void clear_bit(Bitboard *b, Square s) {
-  *b &= clear_mask_bb(s);
+  *b &= ClearMaskBB[s];
 }
 
 
+/// Functions used to update a bitboard after a move. This is faster
+/// then calling a sequence of clear_bit() + set_bit()
+
+inline Bitboard make_move_bb(Square from, Square to) {
+  return SetMaskBB[from] | SetMaskBB[to];
+}
+
+inline void do_move_bb(Bitboard *b, Bitboard move_bb) {
+  *b ^= move_bb;
+}
+
 /// rank_bb() and file_bb() gives a bitboard containing all squares on a given
 /// file or rank.  It is also possible to pass a square as input to these
 /// functions.
@@ -222,6 +199,19 @@ inline Bitboard in_front_bb(Color c, Square s) {
 }
 
 
+/// behind_bb() takes a color and a rank or square as input, and returns a
+/// bitboard representing all the squares on all ranks behind of the rank
+/// (or square), from the given color's point of view.
+
+inline Bitboard behind_bb(Color c, Rank r) {
+  return InFrontBB[opposite_color(c)][r];
+}
+
+inline Bitboard behind_bb(Color c, Square s) {
+  return in_front_bb(opposite_color(c), square_rank(s));
+}
+
+
 /// ray_bb() gives a bitboard representing all squares along the ray in a
 /// given direction from a given square.
 
@@ -235,24 +225,19 @@ inline Bitboard ray_bb(Square s, SignedDirection d) {
 /// bitboard of occupied squares as input, and return a bitboard representing
 /// all squares attacked by a rook, bishop or queen on the given square.
 
-#if defined(USE_COMPACT_ROOK_ATTACKS)
+#if defined(IS_64BIT)
-
-inline Bitboard file_attacks_bb(Square s, Bitboard blockers) {
-  Bitboard b = (blockers >> square_file(s)) & 0x01010101010100ULL;
-  return
-    FileAttacks[square_rank(s)][(b*0xd6e8802041d0c441ULL)>>58] & file_bb(s);
-}
-
-inline Bitboard rank_attacks_bb(Square s, Bitboard blockers) {
-  Bitboard b = (blockers >> ((s & 56) + 1)) & 63;
-  return RankAttacks[square_file(s)][b] & rank_bb(s);
-}
 
 inline Bitboard rook_attacks_bb(Square s, Bitboard blockers) {
-  return file_attacks_bb(s, blockers) | rank_attacks_bb(s, blockers);
+  Bitboard b = blockers & RMask[s];
+  return RAttacks[RAttackIndex[s] + ((b * RMult[s]) >> RShift[s])];
 }
 
-#elif defined(USE_32BIT_ATTACKS)
+inline Bitboard bishop_attacks_bb(Square s, Bitboard blockers) {
+  Bitboard b = blockers & BMask[s];
+  return BAttacks[BAttackIndex[s] + ((b * BMult[s]) >> BShift[s])];
+}
+
+#else // if !defined(IS_64BIT)
 
 inline Bitboard rook_attacks_bb(Square s, Bitboard blockers) {
   Bitboard b = blockers & RMask[s];
@@ -262,17 +247,6 @@ inline Bitboard rook_attacks_bb(Square s, Bitboard blockers) {
                    >> RShift[s])];
 }
 
-#else
-
-inline Bitboard rook_attacks_bb(Square s, Bitboard blockers) {
-  Bitboard b = blockers & RMask[s];
-  return RAttacks[RAttackIndex[s] + ((b * RMult[s]) >> RShift[s])];
-}
-
-#endif
-
-#if defined(USE_32BIT_ATTACKS)
-
 inline Bitboard bishop_attacks_bb(Square s, Bitboard blockers) {
   Bitboard b = blockers & BMask[s];
   return BAttacks[BAttackIndex[s] +
@@ -281,14 +255,7 @@ inline Bitboard bishop_attacks_bb(Square s, Bitboard blockers) {
                    >> BShift[s])];
 }
 
-#else // defined(USE_32BIT_ATTACKS)
+#endif
-
-inline Bitboard bishop_attacks_bb(Square s, Bitboard blockers) {
-  Bitboard b = blockers & BMask[s];
-  return BAttacks[BAttackIndex[s] + ((b * BMult[s]) >> BShift[s])];
-}
-
-#endif // defined(USE_32BIT_ATTACKS)
 
 inline Bitboard queen_attacks_bb(Square s, Bitboard blockers) {
   return rook_attacks_bb(s, blockers) | bishop_attacks_bb(s, blockers);
@@ -350,62 +317,30 @@ inline Bitboard isolated_pawn_mask(Square s) {
 }
 
 
-/// count_1s() counts the number of nonzero bits in a bitboard.
+/// first_1() finds the least significant nonzero bit in a nonzero bitboard.
+/// pop_1st_bit() finds and clears the least significant nonzero bit in a
+/// nonzero bitboard.
 
-#if defined(BITCOUNT_LOOP)
+#if defined(USE_BSFQ) // Assembly code by Heinz van Saanen
 
-inline int count_1s(Bitboard b) {
+inline Square first_1(Bitboard b) {
-  int r;
+  Bitboard dummy;
-  for(r = 0; b; r++, b &= b - 1);
+  __asm__("bsfq %1, %0": "=r"(dummy): "rm"(b) );
-  return r;
+  return (Square)(dummy);
 }
 
-inline int count_1s_max_15(Bitboard b) {
+inline Square pop_1st_bit(Bitboard* b) {
-  return count_1s(b);
+  const Square s = first_1(*b);
+  *b &= ~(1ULL<<s);
+  return s;
 }
 
-#elif defined(BITCOUNT_SWAR_32)
+#else // if !defined(USE_BSFQ)
 
-inline int count_1s(Bitboard b) {
+extern Square first_1(Bitboard b);
-  unsigned w = unsigned(b >> 32), v = unsigned(b);
+extern Square pop_1st_bit(Bitboard* b);
-  v = v - ((v >> 1) & 0x55555555);
-  w = w - ((w >> 1) & 0x55555555);
-  v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
-  w = (w & 0x33333333) + ((w >> 2) & 0x33333333);
-  v = (v + (v >> 4)) & 0x0F0F0F0F;
-  w = (w + (w >> 4)) & 0x0F0F0F0F;
-  v = ((v+w) * 0x01010101) >> 24; // mul is fast on amd procs
-  return int(v);
-}
 
-inline int count_1s_max_15(Bitboard b) {
+#endif
-  unsigned w = unsigned(b >> 32), v = unsigned(b);
-  v = v - ((v >> 1) & 0x55555555);
-  w = w - ((w >> 1) & 0x55555555);
-  v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
-  w = (w & 0x33333333) + ((w >> 2) & 0x33333333);
-  v = ((v+w) * 0x11111111) >> 28;
-  return int(v);
-}
-
-#elif defined(BITCOUNT_SWAR_64)
-
-inline int count_1s(Bitboard b) {
-  b -= ((b>>1) & 0x5555555555555555ULL);
-  b = ((b>>2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
-  b = ((b>>4) + b) & 0x0F0F0F0F0F0F0F0FULL;
-  b *= 0x0101010101010101ULL;
-  return int(b >> 56);
-}
-
-inline int count_1s_max_15(Bitboard b) {
-  b -= (b>>1) & 0x5555555555555555ULL;
-  b = ((b>>2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
-  b *= 0x1111111111111111ULL;
-  return int(b >> 60);
-}
-
-#endif // BITCOUNT
 
 
 ////
@@ -414,8 +349,6 @@ inline int count_1s_max_15(Bitboard b) {
 
 extern void print_bitboard(Bitboard b);
 extern void init_bitboards();
-extern Square first_1(Bitboard b);
-extern Square pop_1st_bit(Bitboard *b);
 
 
 #endif // !defined(BITBOARD_H_INCLUDED)

src/bitcount.h

@@ -0,0 +1,161 @@
+/*
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
+
+  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/>.
+*/
+
+
+#if !defined(BITCOUNT_H_INCLUDED)
+#define BITCOUNT_H_INCLUDED
+
+// To enable POPCNT support uncomment USE_POPCNT define. For PGO compile on a Core i7
+// you may want to collect profile data first with USE_POPCNT disabled and then, in a
+// second profiling session, with USE_POPCNT enabled so to exercise both paths. Don't
+// forget to leave USE_POPCNT enabled for the final optimized compile though ;-)
+
+//#define USE_POPCNT
+
+
+#include "types.h"
+
+// Select type of intrinsic bit count instruction to use
+
+#if defined(__INTEL_COMPILER) && defined(IS_64BIT) && defined(USE_POPCNT) // Intel compiler
+
+#include <nmmintrin.h>
+
+inline bool cpu_has_popcnt() {
+
+  int CPUInfo[4] = {-1};
+  __cpuid(CPUInfo, 0x00000001);
+  return (CPUInfo[2] >> 23) & 1;
+}
+
+// Define a dummy template to workaround a compile error if _mm_popcnt_u64() is not defined.
+//
+// If _mm_popcnt_u64() is defined in <nmmintrin.h> it will be choosen first due to
+// C++ overload rules that always prefer a function to a template with the same name.
+// If not, we avoid a compile error and because cpu_has_popcnt() should return false,
+// our templetized _mm_popcnt_u64() is never called anyway.
+template<typename T> inline unsigned _mm_popcnt_u64(T) { return 0; } // Is never called
+
+#define POPCNT_INTRINSIC(x) _mm_popcnt_u64(x)
+
+#elif defined(_MSC_VER) && defined(IS_64BIT) && defined(USE_POPCNT) // Microsoft compiler
+
+#include <intrin.h>
+
+inline bool cpu_has_popcnt() {
+
+  int CPUInfo[4] = {-1};
+  __cpuid(CPUInfo, 0x00000001);
+  return (CPUInfo[2] >> 23) & 1;
+}
+
+// See comment of _mm_popcnt_u64<>() few lines above for an explanation.
+template<typename T> inline unsigned __popcnt64(T) { return 0; } // Is never called
+
+#define POPCNT_INTRINSIC(x) __popcnt64(x)
+
+#else // Safe fallback for unsupported compilers or when USE_POPCNT is disabled
+
+inline bool cpu_has_popcnt() { return false; }
+
+#define POPCNT_INTRINSIC(x) 0
+
+#endif // cpu_has_popcnt() and POPCNT_INTRINSIC() definitions
+
+
+/// Software implementation of bit count functions
+
+#if defined(IS_64BIT)
+
+inline int count_1s(Bitboard b) {
+  b -= ((b>>1) & 0x5555555555555555ULL);
+  b = ((b>>2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
+  b = ((b>>4) + b) & 0x0F0F0F0F0F0F0F0FULL;
+  b *= 0x0101010101010101ULL;
+  return int(b >> 56);
+}
+
+inline int count_1s_max_15(Bitboard b) {
+  b -= (b>>1) & 0x5555555555555555ULL;
+  b = ((b>>2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL);
+  b *= 0x1111111111111111ULL;
+  return int(b >> 60);
+}
+
+#else // if !defined(IS_64BIT)
+
+inline int count_1s(Bitboard b) {
+  unsigned w = unsigned(b >> 32), v = unsigned(b);
+  v -= (v >> 1) & 0x55555555; // 0-2 in 2 bits
+  w -= (w >> 1) & 0x55555555;
+  v = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits
+  w = ((w >> 2) & 0x33333333) + (w & 0x33333333);
+  v = ((v >> 4) + v) & 0x0F0F0F0F; // 0-8 in 8 bits
+  v += (((w >> 4) + w) & 0x0F0F0F0F);  // 0-16 in 8 bits
+  v *= 0x01010101; // mul is fast on amd procs
+  return int(v >> 24);
+}
+
+inline int count_1s_max_15(Bitboard b) {
+  unsigned w = unsigned(b >> 32), v = unsigned(b);
+  v -= (v >> 1) & 0x55555555; // 0-2 in 2 bits
+  w -= (w >> 1) & 0x55555555;
+  v = ((v >> 2) & 0x33333333) + (v & 0x33333333); // 0-4 in 4 bits
+  w = ((w >> 2) & 0x33333333) + (w & 0x33333333);
+  v += w; // 0-8 in 4 bits
+  v *= 0x11111111;
+  return int(v >> 28);
+}
+
+#endif // BITCOUNT
+
+
+/// count_1s() counts the number of nonzero bits in a bitboard.
+/// If template parameter is true an intrinsic is called, otherwise
+/// we fallback on a software implementation.
+
+template<bool UseIntrinsic>
+inline int count_1s(Bitboard b) {
+
+  return UseIntrinsic ? POPCNT_INTRINSIC(b) : count_1s(b);
+}
+
+template<bool UseIntrinsic>
+inline int count_1s_max_15(Bitboard b) {
+
+  return UseIntrinsic ? POPCNT_INTRINSIC(b) : count_1s_max_15(b);
+}
+
+
+// Global constant initialized at startup that is set to true if
+// CPU on which application runs supports POPCNT intrinsic. Unless
+// USE_POPCNT is not defined.
+const bool CpuHasPOPCNT = cpu_has_popcnt();
+
+
+// Global constant used to print info about the use of 64 optimized
+// functions to verify that a 64 bit compile has been correctly built.
+#if defined(IS_64BIT)
+const bool CpuHas64BitPath = true;
+#else
+const bool CpuHas64BitPath = false;
+#endif
+
+#endif // !defined(BITCOUNT_H_INCLUDED)

src/book.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -29,12 +30,12 @@
 ////
 
 #include <cassert>
-#include <cstdio>
 
 #include "book.h"
 #include "mersenne.h"
 #include "movegen.h"
 
+using namespace std;
 
 ////
 //// Global variables
@@ -49,7 +50,11 @@ Book OpeningBook;
 
 namespace {
 
-  /// Random numbers from PolyGlot, used to compute book hash keys.
+  /// Book entry size in bytes
+  const int EntrySize = 16;
+
+
+  /// Random numbers from PolyGlot, used to compute book hash keys
 
   const uint64_t Random64[781] = {
     0x9D39247E33776D41ULL, 0x2AF7398005AAA5C7ULL, 0x44DB015024623547ULL,
@@ -324,13 +329,6 @@ namespace {
   const int RandomTurn      = 780;
 
 
-  /// Convert pieces to the range 0..1
-  
-  const int PieceTo12[] = {
-    0, 0, 2, 4, 6, 8, 10, 0, 0, 1, 3, 5, 7, 9, 11
-  };
-
-
   /// Prototypes
 
   uint64_t book_key(const Position& pos);
@@ -338,9 +336,6 @@ namespace {
   uint64_t book_castle_key(const Position& pos);
   uint64_t book_ep_key(const Position& pos);
   uint64_t book_color_key(const Position& pos);
-
-  uint64_t read_integer(FILE *file, int size);
-
 }
 
 
@@ -349,89 +344,97 @@ namespace {
 ////
 
 
-/// Constructor
+/// Destructor. Be sure file is closed before we leave.
 
-Book::Book() {
+Book::~Book() {
-  bookFile = NULL;
+
-  bookSize = 0;
+  close();
 }
 
 
-/// Book::open() opens a book file with a given file name.
+/// Book::open() opens a book file with a given file name
+
+void Book::open(const string& fName) {
+
+  // Close old file before opening the new
+  close();
 
-void Book::open(const std::string &fName) {
   fileName = fName;
-  bookFile = fopen(fileName.c_str(), "rb");
+  ifstream::open(fileName.c_str(), ifstream::in | ifstream::binary);
-  if(bookFile != NULL) {
+  if (!is_open())
-    if(fseek(bookFile, 0, SEEK_END) == -1) {
+      return;
-      std::cerr << "Failed to open book file " << fileName << std::endl;
+
-      exit(EXIT_FAILURE);
+  // Get the book size in number of entries
-    }
+  seekg(0, ios::end);
-    bookSize = ftell(bookFile) / 16;
+  bookSize = tellg() / EntrySize;
-    if(bookSize == -1) {
+  seekg(0, ios::beg);
-      std::cerr << "Failed to open book file " << fileName << std::endl;
+
-      exit(EXIT_FAILURE);
+  if (!good())
-    }
+  {
+      cerr << "Failed to open book file " << fileName << endl;
+      Application::exit_with_failure();
   }
 }
 
 
-/// Book::close() closes the currently open book file.
+/// Book::close() closes the file only if it is open, otherwise
+/// we can end up in a little mess due to how std::ifstream works.
 
 void Book::close() {
-  if(bookFile != NULL && fclose(bookFile) == EOF) {
-    std::cerr << "Failed to close book file" << std::endl;
-    exit(EXIT_FAILURE);
-  }
-}
 
-
+  if (is_open())
-/// Book::is_open() tests whether a book file has been opened.
+      ifstream::close();
-
-bool Book::is_open() const {
-  return bookFile != NULL && bookSize != 0;
 }
 
 
 /// Book::file_name() returns the file name of the currently active book,
 /// or the empty string if no book is open.
 
-const std::string Book::file_name() const {
+const string Book::file_name() const {
-  return this->is_open()? fileName : "";
+
+  return is_open() ? fileName : "";
 }
 
 
 /// Book::get_move() gets a book move for a given position. Returns
 /// MOVE_NONE if no book move is found.
 
-Move Book::get_move(const Position &pos) const {
+Move Book::get_move(const Position& pos) {
-  if(this->is_open()) {
+
-    int bestMove = 0, bestScore = 0, move, score;
+  if (!is_open() || bookSize == 0)
+      return MOVE_NONE;
+
+  int bookMove = 0, scoresSum = 0;
   uint64_t key = book_key(pos);
   BookEntry entry;
 
-    for(int i = this->find_key(key); i < bookSize; i++) {
+  // Choose a book move among the possible moves for the given position
-      this->read_entry(entry, i);
+  for (int idx = find_key(key); idx < bookSize; idx++)
+  {
+      read_entry(entry, idx);
       if (entry.key != key)
           break;
-      move = entry.move;
+
-      score = entry.count;
+      int score = entry.count;
+
       assert(score > 0);
 
-      bestScore += score;
+      // Choose book move according to its score. If a move has a very
-      if(int(genrand_int32() % bestScore) < score)
+      // high score it has more probability to be choosen then a one with
-        bestMove = move;
+      // lower score. Note that first entry is always chosen.
+      scoresSum += score;
+      if (int(genrand_int32() % scoresSum) < score)
+          bookMove = entry.move;
   }
+  if (!bookMove)
+      return MOVE_NONE;
+
+  MoveStack mlist[256];
+  MoveStack* last = generate_moves(pos, mlist);
+  for (MoveStack* cur = mlist; cur != last; cur++)
+      if ((int(cur->move) & 07777) == bookMove)
+          return cur->move;
 
-    if(bestMove != 0) {
-      MoveStack moves[256];
-      int n, j;
-      n = generate_legal_moves(pos, moves);
-      for(j = 0; j < n; j++)
-        if((int(moves[j].move) & 07777) == bestMove)
-          return moves[j].move;
-    }
-  }
   return MOVE_NONE;
 }
 
@@ -441,7 +444,8 @@ Move Book::get_move(const Position &pos) const {
 /// entry with the same key as the input is returned. When the key is not
 /// found in the book file, bookSize is returned.
 
-int Book::find_key(uint64_t key) const {
+int Book::find_key(uint64_t key) {
+
   int left, right, mid;
   BookEntry entry;
 
@@ -451,12 +455,13 @@ int Book::find_key(uint64_t key) const {
 
   assert(left <= right);
 
-  while(left < right) {
+  while (left < right)
+  {
       mid = (left + right) / 2;
+
       assert(mid >= left && mid < right);
 
-    this->read_entry(entry, mid);
+      read_entry(entry, mid);
-
       if (key <= entry.key)
           right = mid;
       else
@@ -465,8 +470,7 @@ int Book::find_key(uint64_t key) const {
 
   assert(left == right);
 
-  this->read_entry(entry, left);
+  read_entry(entry, left);
-
   return (entry.key == key)? left : bookSize;
 }
 
@@ -475,20 +479,35 @@ int Book::find_key(uint64_t key) const {
 /// input, and looks up the opening book entry at the given index in the book
 /// file. The book entry is copied to the first input parameter.
 
-void Book::read_entry(BookEntry& entry, int n) const {
+void Book::read_entry(BookEntry& entry, int idx) {
-  assert(n >= 0 && n < bookSize);
-  assert(bookFile != NULL);
 
-  if(fseek(bookFile, n*16, SEEK_SET) == -1) {
+  assert(idx >= 0 && idx < bookSize);
-    std::cerr << "Failed to read book entry at index " << n << std::endl;
+  assert(is_open());
-    exit(EXIT_FAILURE);
+
+  seekg(idx * EntrySize, ios_base::beg);
+  *this >> entry;
+  if (!good())
+  {
+      cerr << "Failed to read book entry at index " << idx << endl;
+      Application::exit_with_failure();
+  }
 }
 
-  entry.key = read_integer(bookFile, 8);
+
-  entry.move = read_integer(bookFile, 2);
+/// Book::read_integer() reads size chars from the file stream
-  entry.count = read_integer(bookFile, 2);
+/// and converts them in an integer number.
-  entry.n = read_integer(bookFile, 2);
+
-  entry.sum = read_integer(bookFile, 2);
+uint64_t Book::read_integer(int size) {
+
+  char buf[8];
+  read(buf, size);
+
+  // Numbers are stored on disk as a binary byte stream
+  uint64_t n = 0ULL;
+  for (int i = 0; i < size; i++)
+      n = (n << 8) + (unsigned char)buf[i];
+
+  return n;
 }
 
 
@@ -499,80 +518,66 @@ void Book::read_entry(BookEntry& entry, int n) const {
 namespace {
 
   uint64_t book_key(const Position& pos) {
+
     uint64_t result = 0ULL;
 
-    for(Color c = WHITE; c <= BLACK; c++) {
+    for (Color c = WHITE; c <= BLACK; c++)
+    {
         Bitboard b = pos.pieces_of_color(c);
-      Square s;
+
-      Piece p;
+        while (b)
-      while(b != EmptyBoardBB) {
+        {
-        s = pop_1st_bit(&b);
+            Square s = pop_1st_bit(&b);
-        p = pos.piece_on(s);
+            Piece p = pos.piece_on(s);
+
             assert(piece_is_ok(p));
             assert(color_of_piece(p) == c);
 
             result ^= book_piece_key(p, s);
         }
     }
-
     result ^= book_castle_key(pos);
     result ^= book_ep_key(pos);
     result ^= book_color_key(pos);
-
     return result;
   }
 
 
   uint64_t book_piece_key(Piece p, Square s) {
+
+    /// Convert pieces to the range 0..11
+    static const int PieceTo12[] = { 0, 0, 2, 4, 6, 8, 10, 0, 0, 1, 3, 5, 7, 9, 11 };
+
     return Random64[RandomPiece + (PieceTo12[int(p)]^1) * 64 + int(s)];
   }
 
 
   uint64_t book_castle_key(const Position& pos) {
+
     uint64_t result = 0ULL;
 
     if (pos.can_castle_kingside(WHITE))
         result ^= Random64[RandomCastle+0];
+
     if (pos.can_castle_queenside(WHITE))
         result ^= Random64[RandomCastle+1];
+
     if (pos.can_castle_kingside(BLACK))
         result ^= Random64[RandomCastle+2];
+
     if (pos.can_castle_queenside(BLACK))
         result ^= Random64[RandomCastle+3];
+
     return result;
   }
 
 
   uint64_t book_ep_key(const Position& pos) {
-    return (pos.ep_square() == SQ_NONE)?
+    return (pos.ep_square() == SQ_NONE ? 0ULL : Random64[RandomEnPassant + square_file(pos.ep_square())]);
-      0ULL : Random64[RandomEnPassant + square_file(pos.ep_square())];
   }
 
 
   uint64_t book_color_key(const Position& pos) {
-    return (pos.side_to_move() == WHITE)? Random64[RandomTurn] : 0ULL;
+    return (pos.side_to_move() == WHITE ? Random64[RandomTurn] : 0ULL);
   }
-  
-
-  uint64_t read_integer(FILE *file, int size) {
-    uint64_t n = 0ULL;;
-    int i;
-    int b;
-
-    assert(file != NULL);
-    assert(size > 0 && size <= 8);
-
-    for(i = 0; i < size; i++) {
-      b = fgetc(file);
-      if(b == EOF) {
-        std::cerr << "Failed to read " << size << " bytes from book file"
-                  << std::endl;
-        exit(EXIT_FAILURE);
-      }
-      assert(b >= 0 && b < 256);
-      n = (n << 8) | b;
-    }
-    return n;
-  }
-
 }

src/book.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -32,6 +33,7 @@
 //// Includes
 ////
 
+#include <fstream>
 #include <string>
 
 #include "move.h"
@@ -50,31 +52,24 @@ struct BookEntry {
   uint16_t sum;
 };
 
-class Book {
+class Book : private std::ifstream {
-
 public:
-  // Constructors
+  ~Book();
-  Book();
-
-  // Open and close book files
   void open(const std::string& fName);
   void close();
-
-  // Testing if a book is opened
-  bool is_open() const;
-
-  // The file name of the currently active book
   const std::string file_name() const;
-
+  Move get_move(const Position& pos);
-  // Get a book move for a given position
-  Move get_move(const Position &pos) const;
 
 private:
-  int find_key(uint64_t key) const;
+  Book& operator>>(uint64_t& n) { n = read_integer(8); return *this; }
-  void read_entry(BookEntry &entry, int n) const;
+  Book& operator>>(uint16_t& n) { n = (uint16_t)read_integer(2); return *this; }
+  void operator>>(BookEntry& e) { *this >> e.key >> e.move >> e.count >> e.n >> e.sum; }
+
+  uint64_t read_integer(int size);
+  void read_entry(BookEntry& e, int n);
+  int find_key(uint64_t key);
 
   std::string fileName;
-  FILE *bookFile;
   int bookSize;
 };
 

src/color.cpp

@@ -1,35 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung 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.
-  
-  Glaurung 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 "color.h"
-
-
-////
-//// Functions
-////
-
-/// color_is_ok(), for debugging:
-
-bool color_is_ok(Color c) {
-  return c == WHITE || c == BLACK;
-}

src/color.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -20,12 +21,6 @@
 #if !defined(COLOR_H_INCLUDED)
 #define COLOR_H_INCLUDED
 
-////
-//// Includes
-////
-
-#include "misc.h"
-
 
 ////
 //// Types
@@ -42,19 +37,14 @@ enum Color {
 //// Inline functions
 ////
 
-inline Color operator+ (Color c, int i) { return Color(int(c) + i); }
+inline void operator++ (Color &c, int) { c = Color(int(c) + 1); }
-inline void operator++ (Color &c, int i) { c = Color(int(c) + 1); }
 
 inline Color opposite_color(Color c) {
   return Color(int(c) ^ 1);
 }
 
-
+inline bool color_is_ok(Color c) {
-////
+  return c == WHITE || c == BLACK;
-//// Prototypes
+}
-////
-
-extern bool color_is_ok(Color c);
-
 
 #endif // !defined(COLOR_H_INCLUDED)

src/depth.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -34,9 +35,6 @@ enum Depth {
 //// Constants
 ////
 
-/// Note: If OnePly is changed, the constant HistoryMax in history.h should
-/// probably also be changed.
-
 const Depth OnePly = Depth(2);
 
 

src/direction.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -25,6 +26,32 @@
 #include "square.h"
 
 
+////
+//// Local definitions
+////
+
+namespace {
+
+  const SquareDelta directionToDelta[] = {
+      DELTA_E, DELTA_W, DELTA_N, DELTA_S, DELTA_NE, DELTA_SW, DELTA_NW, DELTA_SE
+  };
+
+  bool reachable(Square orig, Square dest, SignedDirection dir) {
+
+    SquareDelta delta = directionToDelta[dir];
+    Square from = orig;
+    Square to = from + delta;
+    while (to != dest && square_distance(to, from) == 1 && square_is_ok(to))
+    {
+        from = to;
+        to += delta;
+    }
+    return (to == dest && square_distance(from, to) == 1);
+  }
+
+}
+
+
 ////
 //// Variables
 ////
@@ -38,21 +65,19 @@ uint8_t SignedDirectionTable[64][64];
 ////
 
 void init_direction_table() {
-  SquareDelta deltas[8] = {
+
-    DELTA_E, DELTA_W, DELTA_N, DELTA_S, DELTA_NE, DELTA_SW, DELTA_NW, DELTA_SE
-  };
   for (Square s1 = SQ_A1; s1 <= SQ_H8; s1++)
-    for(Square s2 = SQ_A1; s2 <= SQ_H8; s2++) {
+      for (Square s2 = SQ_A1; s2 <= SQ_H8; s2++)
+      {
           DirectionTable[s1][s2] = uint8_t(DIR_NONE);
           SignedDirectionTable[s1][s2] = uint8_t(SIGNED_DIR_NONE);
-      if(s1 == s2) continue;
+          if (s1 == s2)
-      for(SignedDirection d = SIGNED_DIR_E; d <= SIGNED_DIR_SE; d++) {
+              continue;
-        SquareDelta delta = deltas[d];
+
-        Square s3, s4;
+          for (SignedDirection d = SIGNED_DIR_E; d != SIGNED_DIR_NONE; d++)
-        for(s4 = s1 + delta, s3 = s1;
+          {
-            square_distance(s4, s3) == 1 && s4 != s2 && square_is_ok(s4);
+              if (reachable(s1, s2, d))
-            s3 = s4, s4 += delta);
+              {
-        if(s4 == s2 && square_distance(s4, s3) == 1) {
                   SignedDirectionTable[s1][s2] = uint8_t(d);
                   DirectionTable[s1][s2] = uint8_t(d / 2);
                   break;

src/direction.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -57,7 +58,9 @@ extern uint8_t SignedDirectionTable[64][64];
 //// Inline functions
 ////
 
-inline void operator++ (Direction &d, int) { d = Direction(int(d) + 1); }
+inline void operator++ (Direction& d, int) {
+  d = Direction(int(d) + 1);
+}
 
 inline void operator++ (SignedDirection& d, int) {
   d = SignedDirection(int(d) + 1);
@@ -71,6 +74,13 @@ inline SignedDirection signed_direction_between_squares(Square s1, Square s2) {
   return SignedDirection(SignedDirectionTable[s1][s2]);
 }
 
+inline int direction_is_diagonal(Square s1, Square s2) {
+  return DirectionTable[s1][s2] & 2;
+}
+
+inline bool direction_is_straight(Square s1, Square s2) {
+  return DirectionTable[s1][s2] < 2;
+}
 
 ////
 //// Prototypes

src/endgame.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -33,204 +34,67 @@
 //// Types
 ////
 
-/// Abstract base class for all special endgame evaluation functions:
+enum EndgameType {
 
-class EndgameEvaluationFunction {
+    // Evaluation functions
+    KXK,   // Generic "mate lone king" eval
+    KBNK,  // KBN vs K
+    KPK,   // KP vs K
+    KRKP,  // KR vs KP
+    KRKB,  // KR vs KB
+    KRKN,  // KR vs KN
+    KQKR,  // KQ vs KR
+    KBBKN, // KBB vs KN
+    KNNK,  // KNN vs K
+    KmmKm, // K and two minors vs K and one or two minors
+
+    // Scaling functions
+    KBPsK,   // KB+pawns vs K
+    KQKRPs,  // KQ vs KR+pawns
+    KRPKR,   // KRP vs KR
+    KRPPKRP, // KRPP vs KRP
+    KPsK,    // King and pawns vs king
+    KBPKB,   // KBP vs KB
+    KBPPKB,  // KBPP vs KB
+    KBPKN,   // KBP vs KN
+    KNPK,    // KNP vs K
+    KPKP     // KP vs KP
+};
+
+/// Template abstract base class for all special endgame functions
+
+template<typename T>
+class EndgameFunctionBase {
 public:
-  EndgameEvaluationFunction(Color c);
+  EndgameFunctionBase(Color c) : strongerSide(c), weakerSide(opposite_color(c)) {}
-  virtual ~EndgameEvaluationFunction() { }
+  virtual ~EndgameFunctionBase() {}
-
+  virtual T apply(const Position&) = 0;
-  virtual Value apply(const Position &pos) =0;
+  Color color() const { return strongerSide; }
 
 protected:
   Color strongerSide, weakerSide;
 };
 
+typedef EndgameFunctionBase<Value> EndgameEvaluationFunctionBase;
+typedef EndgameFunctionBase<ScaleFactor> EndgameScalingFunctionBase;
 
-/// Subclasses for various concrete endgames:
 
-// Generic "mate lone king" eval:
+/// Templates subclass for various concrete endgames
-class KXKEvaluationFunction : public EndgameEvaluationFunction {
+
-public:
+template<EndgameType>
-  KXKEvaluationFunction(Color c);
+struct EvaluationFunction : public EndgameEvaluationFunctionBase {
-  Value apply(const Position &pos);
+  typedef EndgameEvaluationFunctionBase Base;
+  explicit EvaluationFunction(Color c): EndgameEvaluationFunctionBase(c) {}
+  Value apply(const Position&);
 };
 
-// KBN vs K:
+template<EndgameType>
-class KBNKEvaluationFunction : public EndgameEvaluationFunction {
+struct ScalingFunction : public EndgameScalingFunctionBase {
-public:
+  typedef EndgameScalingFunctionBase Base;
-  KBNKEvaluationFunction(Color c);
+  explicit ScalingFunction(Color c) : EndgameScalingFunctionBase(c) {}
-  Value apply(const Position &pos);
+  ScaleFactor apply(const Position&);
 };
 
-// KP vs K:
-class KPKEvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KPKEvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-// KR vs KP:
-class KRKPEvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KRKPEvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-// KR vs KB:
-class KRKBEvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KRKBEvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-// KR vs KN:
-class KRKNEvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KRKNEvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-// KQ vs KR:
-class KQKREvaluationFunction : public EndgameEvaluationFunction {
-public:
-  KQKREvaluationFunction(Color c);
-  Value apply(const Position &pos);
-};
-
-
-/// Abstract base class for all evaluation scaling functions:
-
-class ScalingFunction {
-public:
-  ScalingFunction(Color c);
-  virtual ~ScalingFunction() { }
-
-  virtual ScaleFactor apply(const Position &pos) =0;
-
-protected:
-  Color strongerSide, weakerSide;
-};
-
-
-/// Subclasses for various concrete endgames:
-
-// KBP vs K:
-class KBPKScalingFunction : public ScalingFunction {
-public:
-  KBPKScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KQ vs KRP:
-class KQKRPScalingFunction: public ScalingFunction {
-public:
-  KQKRPScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KRP vs KR:
-class KRPKRScalingFunction : public ScalingFunction {
-public:
-  KRPKRScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KRPP vs KRP:
-class KRPPKRPScalingFunction : public ScalingFunction {
-public:
-  KRPPKRPScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// King and pawns vs king:
-class KPsKScalingFunction : public ScalingFunction {
-public:
-  KPsKScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KBP vs KB:
-class KBPKBScalingFunction : public ScalingFunction {
-public:
-  KBPKBScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KBP vs KN:
-class KBPKNScalingFunction : public ScalingFunction {
-public:
-  KBPKNScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KNP vs K:
-class KNPKScalingFunction : public ScalingFunction {
-public:
-  KNPKScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-// KP vs KP:
-class KPKPScalingFunction : public ScalingFunction {
-public:
-  KPKPScalingFunction(Color c);
-  ScaleFactor apply(const Position &pos);
-};
-
-
-////
-//// Constants and variables
-////
-
-// Generic "mate lone king" eval:
-extern KXKEvaluationFunction EvaluateKXK, EvaluateKKX;
-
-// KBN vs K:
-extern KBNKEvaluationFunction EvaluateKBNK, EvaluateKKBN;
-
-// KP vs K:
-extern KPKEvaluationFunction EvaluateKPK, EvaluateKKP;
-
-// KR vs KP:
-extern KRKPEvaluationFunction EvaluateKRKP, EvaluateKPKR;
-
-// KR vs KB:
-extern KRKBEvaluationFunction EvaluateKRKB, EvaluateKBKR;
-
-// KR vs KN:
-extern KRKNEvaluationFunction EvaluateKRKN, EvaluateKNKR;
-
-// KQ vs KR:
-extern KQKREvaluationFunction EvaluateKQKR, EvaluateKRKQ;
-
-// KBP vs K:
-extern KBPKScalingFunction ScaleKBPK, ScaleKKBP;
-
-// KQ vs KRP:
-extern KQKRPScalingFunction ScaleKQKRP, ScaleKRPKQ;
-
-// KRP vs KR:
-extern KRPKRScalingFunction ScaleKRPKR, ScaleKRKRP;
-
-// KRPP vs KRP:
-extern KRPPKRPScalingFunction ScaleKRPPKRP, ScaleKRPKRPP;
-
-// King and pawns vs king:
-extern KPsKScalingFunction ScaleKPsK, ScaleKKPs;
-
-// KBP vs KB:
-extern KBPKBScalingFunction ScaleKBPKB, ScaleKBKBP;
-
-// KBP vs KN:
-extern KBPKNScalingFunction ScaleKBPKN, ScaleKNKBP;
-
-// KNP vs K:
-extern KNPKScalingFunction ScaleKNPK, ScaleKKNP;
-
-// KP vs KP:
-extern KPKPScalingFunction ScaleKPKPw, ScaleKPKPb;
-
 
 ////
 //// Prototypes

src/evaluate.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -26,13 +27,13 @@
 
 #include "material.h"
 #include "pawns.h"
-#include "position.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
@@ -40,47 +41,49 @@
 ///
 /// 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 {
 
-  // Middle game and endgame evaluations:
+  // Middle game and endgame evaluations
   Value mgValue, egValue;
 
-  // Pointers to material and pawn hash table entries:
+  // 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
+  // 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]; }
-  // attackZone[color] is the zone around the enemy king which is considered
+
+  // 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, attackZone[WHITE] is a bitboard containing the squares f8, h8,
+  // is on g8, kingZone[WHITE] is a bitboard containing the squares f8, h8,
   // f7, g7, h7, f6, g6 and h6.
-  Bitboard attackZone[2];
+  Bitboard kingZone[2];
 
-  // attackCount[color] is the number of pieces of the given color which
+  // kingAttackersCount[color] is the number of pieces of the given color
-  // attack a square adjacent to the enemy king.
+  // which attack a square in the kingZone of the enemy king.
-  int attackCount[2];
+  int kingAttackersCount[2];
 
-  // attackWeight[color] is the sum of the "weight" of the pieces of the given
+  // kingAttackersWeight[color] is the sum of the "weight" of the pieces of the
-  // color which attack a square adjacent to the enemy king.  The weights of
+  // given color which attack a square in the kingZone of the enemy king. The
-  // the individual piece types are given by the variables QueenAttackWeight,
+  // weights of the individual piece types are given by the variables
-  // RookAttackWeight, BishopAttackWeight and KnightAttackWeight in
+  // QueenAttackWeight, RookAttackWeight, BishopAttackWeight and
-  // evaluate.cpp.
+  // KnightAttackWeight in evaluate.cpp
-  int attackWeight[2];
+  int kingAttackersWeight[2];
 
-  // attacked[color] is the number of enemy piece attacks to squares directly
+  // kingAdjacentZoneAttacksCount[color] is the number of attacks to squares
-  // adjacent to the king of the given color.  Pieces which attack more
+  // directly adjacent to the king of the given color. Pieces which attack
-  // than one square are counted multiple times.  For instance, if black's
+  // 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 attacked[BLACK].
+  // 2 to kingAdjacentZoneAttacksCount[BLACK].
-  int attacked[2];
+  int kingAdjacentZoneAttacksCount[2];
 
   // mateThreat[color] is a move for the given side which gives a direct mate.
   Move mateThreat[2];

src/history.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -22,6 +23,7 @@
 ////
 
 #include <cassert>
+#include <cstring>
 
 #include "history.h"
 
@@ -30,14 +32,13 @@
 //// Functions
 ////
 
+
 /// Constructor
 
-History::History() {
+History::History() { clear(); }
-  this->clear();
-}
 
 
-/// History::clear() clears the history tables.
+/// History::clear() clears the history tables
 
 void History::clear() {
   memset(history, 0, 2 * 8 * 64 * sizeof(int));
@@ -48,21 +49,22 @@ void History::clear() {
 
 /// History::success() registers a move as being successful. This is done
 /// whenever a non-capturing move causes a beta cutoff in the main search.
-/// The three parameters are the moving piece, the move itself, and the
+/// The three parameters are the moving piece, the destination square, and
-/// search depth.
+/// the search depth.
+
+void History::success(Piece p, Square to, Depth d) {
 
-void History::success(Piece p, Move m, Depth d) {
   assert(piece_is_ok(p));
-  assert(move_is_ok(m));
+  assert(square_is_ok(to));
 
-  history[p][move_to(m)] += int(d) * int(d);
+  history[p][to] += int(d) * int(d);
-  successCount[p][move_to(m)]++;
+  successCount[p][to]++;
 
-  // Prevent history overflow:
+  // Prevent history overflow
-  if(history[p][move_to(m)] >= HistoryMax)
+  if (history[p][to] >= HistoryMax)
       for (int i = 0; i < 16; i++)
           for (int j = 0; j < 64; j++)
-        history[i][j] /= 2;
+              history[i][j] /= 4;
 }
 
 
@@ -70,31 +72,34 @@ void History::success(Piece p, Move m, Depth d) {
 /// called for each non-capturing move which failed to produce a beta cutoff
 /// at a node where a beta cutoff was finally found.
 
-void History::failure(Piece p, Move m) {
+void History::failure(Piece p, Square to) {
-  assert(piece_is_ok(p));
-  assert(move_is_ok(m));
 
-  failureCount[p][move_to(m)]++;
+  assert(piece_is_ok(p));
+  assert(square_is_ok(to));
+
+  failureCount[p][to]++;
 }
 
 
 /// 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, Move m) const {
+int History::move_ordering_score(Piece p, Square to) const {
-  assert(piece_is_ok(p));
-  assert(move_is_ok(m));
 
-  return history[p][move_to(m)];
+  assert(piece_is_ok(p));
+  assert(square_is_ok(to));
+
+  return history[p][to];
 }
 
 
 /// History::ok_to_prune() decides whether a move has been sufficiently
 /// unsuccessful that it makes sense to prune it entirely.
 
-bool History::ok_to_prune(Piece p, Move m, Depth d) const {
+bool History::ok_to_prune(Piece p, Square to, Depth d) const {
-  assert(piece_is_ok(p));
-  assert(move_is_ok(m));
 
-  return (int(d) * successCount[p][move_to(m)] < failureCount[p][move_to(m)]);
+  assert(piece_is_ok(p));
+  assert(square_is_ok(to));
+
+  return (int(d) * successCount[p][to] < failureCount[p][to]);
 }

src/history.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -33,19 +34,22 @@
 //// Types
 ////
 
-/// The History class stores statistics about how often different moves have
+/// The History class stores statistics about how often different moves
-/// been successful or unsuccessful during the current search.  These
+/// have been successful or unsuccessful during the current search. These
-/// statistics are used for reduction and move ordering decisions.
+/// statistics are used for reduction and move ordering decisions. History
+/// entries are stored according only to moving piece and destination square,
+/// in particular two moves with different origin but same destination and
+/// same piece will be considered identical.
 
 class History {
 
 public:
   History();
   void clear();
-  void success(Piece p, Move m, Depth d);
+  void success(Piece p, Square to, Depth d);
-  void failure(Piece p, Move m);
+  void failure(Piece p, Square to);
-  int move_ordering_score(Piece p, Move m) const;
+  int move_ordering_score(Piece p, Square to) const;
-  bool ok_to_prune(Piece p, Move m, Depth d) const;
+  bool ok_to_prune(Piece p, Square to, Depth d) const;
 
 private:
   int history[16][64];  // [piece][square]
@@ -65,12 +69,8 @@ private:
 /// the effect that parts of the search tree which have been searched
 /// recently have a bigger importance for move ordering than the moves which
 /// have been searched a long time ago.
-///
-/// Note that HistoryMax should probably be changed whenever the constant
-/// OnePly in depth.h is changed.  This is somewhat annoying.  Perhaps it
-/// would be better to scale down the history table at regular intervals?
 
-const int HistoryMax = 50000;
+const int HistoryMax = 25000 * OnePly;
 
 
 #endif // !defined(HISTORY_H_INCLUDED)

src/lock.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -85,8 +86,9 @@ typedef pthread_mutex_t Lock;
 
 #else
 
-
+#define WIN32_LEAN_AND_MEAN
 #include <windows.h>
+#undef WIN32_LEAN_AND_MEAN
 
 typedef CRITICAL_SECTION Lock;
 #  define lock_init(x, y) InitializeCriticalSection(x)

src/main.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -16,28 +17,27 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+// To profile with callgrind uncomment following line
+//#define USE_CALLGRIND
+
 
 ////
 //// Includes
 ////
 
-#include <cstdlib>
 #include <iostream>
+#include <string>
 
 #include "benchmark.h"
-#include "bitboard.h"
+#include "bitcount.h"
-#include "direction.h"
-#include "endgame.h"
-#include "evaluate.h"
-#include "material.h"
-#include "mersenne.h"
 #include "misc.h"
-#include "movepick.h"
-#include "position.h"
-#include "search.h"
-#include "thread.h"
 #include "uci.h"
-#include "ucioption.h"
+
+#ifdef USE_CALLGRIND
+#include <valgrind/callgrind.h>
+#endif
+
+using namespace std;
 
 
 ////
@@ -47,49 +47,43 @@
 int main(int argc, char *argv[]) {
 
   // Disable IO buffering
-  setbuf(stdin, NULL);
+  cout.rdbuf()->pubsetbuf(NULL, 0);
-  setbuf(stdout, NULL);
+  cin.rdbuf()->pubsetbuf(NULL, 0);
-  std::cout.rdbuf()->pubsetbuf(NULL, 0);
-  std::cin.rdbuf()->pubsetbuf(NULL, 0);
 
-  // Initialization
+  // Initialization through global resources manager
+  Application::initialize();
 
-  init_mersenne();
+#ifdef USE_CALLGRIND
-  init_direction_table();
+  CALLGRIND_START_INSTRUMENTATION;
-  init_bitboards();
+#endif
-  init_uci_options();
-  Position::init_zobrist();
-  Position::init_piece_square_tables();
-  MaterialInfo::init();
-  MovePicker::init_phase_table();
-  init_eval(1);
-  init_bitbases();
-  init_threads();
 
-  // Make random number generation less deterministic, for book moves
+  // Process command line arguments if any
-  int i = abs(get_system_time() % 10000);
+  if (argc > 1)
-  for(int j = 0; j < i; j++)
+  {
-    genrand_int32();
+      if (string(argv[1]) != "bench" || argc < 4 || argc > 8)
-
+          cout << "Usage: stockfish bench <hash size> <threads> "
-  // Process command line arguments
+               << "[time = 60s] [fen positions file = default] "
-  if(argc >= 2) {
+               << "[time, depth or node limited = time] "
-    if(std::string(argv[1]) == "bench") {
+               << "[timing file name = none]" << endl;
-      if(argc != 4) {
+      else
-        std::cout << "Usage: glaurung bench <hash> <threads>" << std::endl;
+      {
-        exit(0);
+          string time = argc > 4 ? argv[4] : "60";
+          string fen = argc > 5 ? argv[5] : "default";
+          string lim = argc > 6 ? argv[6] : "time";
+          string tim = argc > 7 ? argv[7] : "";
+          benchmark(string(argv[2]) + " " + string(argv[3]) + " " + time + " " + fen + " " + lim + " " + tim);
       }
-      benchmark(std::string(argv[2]), std::string(argv[3]));
       return 0;
   }
-  }
 
   // Print copyright notice
-  std::cout << engine_name() << ".  "
+  cout << engine_name()
-            << "Copyright (C) 2004-2008 Tord Romstad."
+       << ". By Tord Romstad, Marco Costalba, Joona Kiiski." << endl;
-            << std::endl;
+
+  if (CpuHasPOPCNT)
+      cout << "Good! CPU has hardware POPCNT. We will use it." << endl;
 
   // Enter UCI mode
   uci_main_loop();
-
   return 0;
 }

src/material.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -22,9 +23,13 @@
 ////
 
 #include <cassert>
+#include <sstream>
+#include <map>
 
 #include "material.h"
 
+using namespace std;
+
 
 ////
 //// Local definitions
@@ -32,150 +37,98 @@
 
 namespace {
 
-  const Value BishopPairMidgameBonus = Value(100);
+  // Polynomial material balance parameters
-  const Value BishopPairEndgameBonus = Value(100);
+  const Value RedundantQueenPenalty = Value(320);
+  const Value RedundantRookPenalty  = Value(554);
+  const int LinearCoefficients[6]   = { 1617, -162, -1172, -190, 105, 26 };
 
-  Key KPKMaterialKey, KKPMaterialKey;
+  const int QuadraticCoefficientsSameColor[][6] = {
-  Key KBNKMaterialKey, KKBNMaterialKey;
+  { 7, 7, 7, 7, 7, 7 }, { 39, 2, 7, 7, 7, 7 }, { 35, 271, -4, 7, 7, 7 },
-  Key KRKPMaterialKey, KPKRMaterialKey;
+  { 7, 25, 4, 7, 7, 7 }, { -27, -2, 46, 100, 56, 7 }, { 58, 29, 83, 148, -3, -25 } };
-  Key KRKBMaterialKey, KBKRMaterialKey;
-  Key KRKNMaterialKey, KNKRMaterialKey;
-  Key KQKRMaterialKey, KRKQMaterialKey;
-  Key KRPKRMaterialKey, KRKRPMaterialKey;
-  Key KRPPKRPMaterialKey, KRPKRPPMaterialKey;
-  Key KNNKMaterialKey, KKNNMaterialKey;
-  Key KBPKBMaterialKey, KBKBPMaterialKey;
-  Key KBPKNMaterialKey, KNKBPMaterialKey;
-  Key KNPKMaterialKey, KKNPMaterialKey;
-  Key KPKPMaterialKey;
 
+  const int QuadraticCoefficientsOppositeColor[][6] = {
+  { 41, 41, 41, 41, 41, 41 }, { 37, 41, 41, 41, 41, 41 }, { 10, 62, 41, 41, 41, 41 },
+  { 57, 64, 39, 41, 41, 41 }, { 50, 40, 23, -22, 41, 41 }, { 106, 101, 3, 151, 171, 41 } };
+
+  // Named endgame evaluation and scaling functions, these
+  // are accessed direcly and not through the function maps.
+  EvaluationFunction<KmmKm> EvaluateKmmKm(WHITE);
+  EvaluationFunction<KXK>   EvaluateKXK(WHITE), EvaluateKKX(BLACK);
+  ScalingFunction<KBPsK>    ScaleKBPsK(WHITE),  ScaleKKBPs(BLACK);
+  ScalingFunction<KQKRPs>   ScaleKQKRPs(WHITE), ScaleKRPsKQ(BLACK);
+  ScalingFunction<KPsK>     ScaleKPsK(WHITE),   ScaleKKPs(BLACK);
+  ScalingFunction<KPKP>     ScaleKPKPw(WHITE),  ScaleKPKPb(BLACK);
+
+  typedef EndgameEvaluationFunctionBase EF;
+  typedef EndgameScalingFunctionBase SF;
+}
+
+
+////
+//// Classes
+////
+
+/// EndgameFunctions class stores endgame evaluation and scaling functions
+/// in two std::map. Because STL library is not guaranteed to be thread
+/// safe even for read access, the maps, although with identical content,
+/// are replicated for each thread. This is faster then using locks.
+
+class EndgameFunctions {
+public:
+  EndgameFunctions();
+  ~EndgameFunctions();
+  template<class T> T* get(Key key) const;
+
+private:
+  template<class T> void add(const string& keyCode);
+
+  static Key buildKey(const string& keyCode);
+  static const string swapColors(const string& keyCode);
+
+  // Here we store two maps, for evaluate and scaling functions
+  pair<map<Key, EF*>, map<Key, SF*> > maps;
+
+  // Maps accessing functions returning const and non-const references
+  template<typename T> const map<Key, T*>& get() const { return maps.first; }
+  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*>&
+EndgameFunctions::get<SF>() const { return maps.second; }
+
+template<> map<Key, SF*>&
+EndgameFunctions::get<SF>() { return maps.second; }
+
 
 ////
 //// Functions
 ////
 
-/// MaterialInfo::init() is called during program initialization.  It 
+/// MaterialInfoTable c'tor and d'tor, called once by each thread
-/// precomputes material hash keys for a few basic endgames, in order
-/// to make it easy to recognize such endgames when they occur.
 
-void MaterialInfo::init() {
+MaterialInfoTable::MaterialInfoTable(unsigned int numOfEntries) {
-  KPKMaterialKey = Position::zobMaterial[WHITE][PAWN][1];
-  KKPMaterialKey = Position::zobMaterial[BLACK][PAWN][1];
-  KBNKMaterialKey =
-    Position::zobMaterial[WHITE][BISHOP][1] ^
-    Position::zobMaterial[WHITE][KNIGHT][1];
-  KKBNMaterialKey =
-    Position::zobMaterial[BLACK][BISHOP][1] ^
-    Position::zobMaterial[BLACK][KNIGHT][1];
-  KRKPMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-  KPKRMaterialKey =
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[BLACK][ROOK][1];
-  KRKBMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[BLACK][BISHOP][1];
-  KBKRMaterialKey =
-    Position::zobMaterial[WHITE][BISHOP][1] ^
-    Position::zobMaterial[BLACK][ROOK][1];
-  KRKNMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[BLACK][KNIGHT][1];
-  KNKRMaterialKey =
-    Position::zobMaterial[WHITE][KNIGHT][1] ^
-    Position::zobMaterial[BLACK][ROOK][1];
-  KQKRMaterialKey =
-    Position::zobMaterial[WHITE][QUEEN][1] ^
-    Position::zobMaterial[BLACK][ROOK][1];
-  KRKQMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[BLACK][QUEEN][1];
-  KRPKRMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[BLACK][ROOK][1];
-  KRKRPMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[BLACK][ROOK][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-  KRPPKRPMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[WHITE][PAWN][2] ^
-    Position::zobMaterial[BLACK][ROOK][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-  KRPKRPPMaterialKey =
-    Position::zobMaterial[WHITE][ROOK][1] ^
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[BLACK][ROOK][1] ^
-    Position::zobMaterial[BLACK][PAWN][1] ^
-    Position::zobMaterial[BLACK][PAWN][2];
-  KNNKMaterialKey =
-    Position::zobMaterial[WHITE][KNIGHT][1] ^
-    Position::zobMaterial[WHITE][KNIGHT][2];
-  KKNNMaterialKey =
-    Position::zobMaterial[BLACK][KNIGHT][1] ^
-    Position::zobMaterial[BLACK][KNIGHT][2];
-  KBPKBMaterialKey =
-    Position::zobMaterial[WHITE][BISHOP][1] ^
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[BLACK][BISHOP][1];
-  KBKBPMaterialKey =
-    Position::zobMaterial[WHITE][BISHOP][1] ^
-    Position::zobMaterial[BLACK][BISHOP][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-  KBPKNMaterialKey =
-    Position::zobMaterial[WHITE][BISHOP][1] ^
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[BLACK][KNIGHT][1];
-  KNKBPMaterialKey =
-    Position::zobMaterial[WHITE][KNIGHT][1] ^
-    Position::zobMaterial[BLACK][BISHOP][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-  KNPKMaterialKey =
-    Position::zobMaterial[WHITE][KNIGHT][1] ^
-    Position::zobMaterial[WHITE][PAWN][1];
-  KKNPMaterialKey =
-    Position::zobMaterial[BLACK][KNIGHT][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-  KPKPMaterialKey =
-    Position::zobMaterial[WHITE][PAWN][1] ^
-    Position::zobMaterial[BLACK][PAWN][1];
-}
 
-
-/// Constructor for the MaterialInfoTable class.
-
-MaterialInfoTable::MaterialInfoTable(unsigned numOfEntries) {
   size = numOfEntries;
   entries = new MaterialInfo[size];
-  if(entries == NULL) {
+  funcs = new EndgameFunctions();
-    std::cerr << "Failed to allocate " << (numOfEntries * sizeof(MaterialInfo))
-              << " bytes for material hash table." << std::endl;
-    exit(EXIT_FAILURE);
-  }
-  this->clear();
-}
 
-
+  if (!entries || !funcs)
-/// Destructor for the MaterialInfoTable class.
+  {
+      cerr << "Failed to allocate " << numOfEntries * sizeof(MaterialInfo)
+           << " bytes for material hash table." << endl;
+      Application::exit_with_failure();
+  }
+}
 
 MaterialInfoTable::~MaterialInfoTable() {
+
+  delete funcs;
   delete [] entries;
 }
 
 
-/// MaterialInfoTable::clear() clears a material hash table by setting
-/// all entries to 0.
-
-void MaterialInfoTable::clear() {
-  memset(entries, 0, size * sizeof(MaterialInfo));
-}
-
-
 /// MaterialInfoTable::get_material_info() takes a position object as input,
 /// computes or looks up a MaterialInfo object, and returns a pointer to it.
 /// If the material configuration is not already present in the table, it
@@ -183,89 +136,57 @@ void MaterialInfoTable::clear() {
 /// same material configuration occurs again.
 
 MaterialInfo* MaterialInfoTable::get_material_info(const Position& pos) {
+
   Key key = pos.get_material_key();
   int index = key & (size - 1);
   MaterialInfo* mi = entries + index;
 
   // If mi->key matches the position's material hash key, it means that we
   // have analysed this material configuration before, and we can simply
-  // return the information we found the last time instead of recomputing it:
+  // return the information we found the last time instead of recomputing it.
   if (mi->key == key)
       return mi;
 
-  // Clear the MaterialInfo object, and set its key:
+  // Clear the MaterialInfo object, and set its key
   mi->clear();
   mi->key = key;
 
-  // A special case before looking for a specialized evaluation function:
-  // KNN vs K is a draw:
-  if(key == KNNKMaterialKey || key == KKNNMaterialKey) {
-    mi->factor[WHITE] = mi->factor[BLACK] = 0;
-    return mi;
-  }
-
   // Let's look if we have a specialized evaluation function for this
-  // particular material configuration:
+  // particular material configuration. First we look for a fixed
-  if(key == KPKMaterialKey) {
+  // configuration one, then a generic one if previous search failed.
-    mi->evaluationFunction = &EvaluateKPK;
+  if ((mi->evaluationFunction = funcs->get<EF>(key)) != NULL)
       return mi;
-  }
+
-  else if(key == KKPMaterialKey) {
+  else if (   pos.non_pawn_material(BLACK) == Value(0)
-    mi->evaluationFunction = &EvaluateKKP;
+           && pos.piece_count(BLACK, PAWN) == 0
-    return mi;
+           && pos.non_pawn_material(WHITE) >= RookValueMidgame)
-  }
+  {
-  else if(key == KBNKMaterialKey) {
-    mi->evaluationFunction = &EvaluateKBNK;
-    return mi;
-  }
-  else if(key == KKBNMaterialKey) {
-    mi->evaluationFunction = &EvaluateKKBN;
-    return mi;
-  }
-  else if(key == KRKPMaterialKey) {
-    mi->evaluationFunction = &EvaluateKRKP;
-    return mi;
-  }
-  else if(key == KPKRMaterialKey) {
-    mi->evaluationFunction = &EvaluateKPKR;
-    return mi;
-  }
-  else if(key == KRKBMaterialKey) {
-    mi->evaluationFunction = &EvaluateKRKB;
-    return mi;
-  }
-  else if(key == KBKRMaterialKey) {
-    mi->evaluationFunction = &EvaluateKBKR;
-    return mi;
-  }
-  else if(key == KRKNMaterialKey) {
-    mi->evaluationFunction = &EvaluateKRKN;
-    return mi;
-  }
-  else if(key == KNKRMaterialKey) {
-    mi->evaluationFunction = &EvaluateKNKR;
-    return mi;
-  }
-  else if(key == KQKRMaterialKey) {
-    mi->evaluationFunction = &EvaluateKQKR;
-    return mi;
-  }
-  else if(key == KRKQMaterialKey) {
-    mi->evaluationFunction = &EvaluateKRKQ;
-    return mi;
-  }
-  else if(pos.non_pawn_material(BLACK) == Value(0) &&
-          pos.pawn_count(BLACK) == 0 &&
-          pos.non_pawn_material(WHITE) >= RookValueEndgame) {
       mi->evaluationFunction = &EvaluateKXK;
       return mi;
   }
-  else if(pos.non_pawn_material(WHITE) == Value(0) &&
+  else if (   pos.non_pawn_material(WHITE) == Value(0)
-          pos.pawn_count(WHITE) == 0 &&
+           && pos.piece_count(WHITE, PAWN) == 0
-          pos.non_pawn_material(BLACK) >= RookValueEndgame) {
+           && pos.non_pawn_material(BLACK) >= RookValueMidgame)
+  {
       mi->evaluationFunction = &EvaluateKKX;
       return mi;
   }
+  else if (   pos.pieces(PAWN) == 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.
+      assert((pos.pieces(KNIGHT, WHITE) | pos.pieces(BISHOP, WHITE)));
+      assert((pos.pieces(KNIGHT, BLACK) | pos.pieces(BISHOP, BLACK)));
+
+      if (   pos.piece_count(WHITE, BISHOP) + pos.piece_count(WHITE, KNIGHT) <= 2
+          && pos.piece_count(BLACK, BISHOP) + pos.piece_count(BLACK, KNIGHT) <= 2)
+      {
+          mi->evaluationFunction = &EvaluateKmmKm;
+          return mi;
+      }
+  }
 
   // OK, we didn't find any special evaluation function for the current
   // material configuration. Is there a suitable scaling function?
@@ -274,133 +195,211 @@ MaterialInfo *MaterialInfoTable::get_material_info(const Position &pos) {
   // if we decide to add more special cases. We face problems when there
   // are several conflicting applicable scaling functions and we need to
   // decide which one to use.
+  SF* sf;
 
-  if(key == KRPKRMaterialKey) {
+  if ((sf = funcs->get<SF>(key)) != NULL)
-    mi->scalingFunction[WHITE] = &ScaleKRPKR;
+  {
-    return mi;
+      mi->scalingFunction[sf->color()] = sf;
-  }
-  if(key == KRKRPMaterialKey) {
-    mi->scalingFunction[BLACK] = &ScaleKRKRP;
-    return mi;
-  }
-  if(key == KRPPKRPMaterialKey) {
-    mi->scalingFunction[WHITE] = &ScaleKRPPKRP;
-    return mi;
-  }
-  else if(key == KRPKRPPMaterialKey) {
-    mi->scalingFunction[BLACK] = &ScaleKRPKRPP;
-    return mi;
-  }
-  if(key == KBPKBMaterialKey) {
-    mi->scalingFunction[WHITE] = &ScaleKBPKB;
-    return mi;
-  }
-  if(key == KBKBPMaterialKey) {
-    mi->scalingFunction[BLACK] = &ScaleKBKBP;
-    return mi;
-  }
-  if(key == KBPKNMaterialKey) {
-    mi->scalingFunction[WHITE] = &ScaleKBPKN;
-    return mi;
-  }
-  if(key == KNKBPMaterialKey) {
-    mi->scalingFunction[BLACK] = &ScaleKNKBP;
-    return mi;
-  }
-  if(key == KNPKMaterialKey) {
-    mi->scalingFunction[WHITE] = &ScaleKNPK;
-    return mi;
-  }
-  if(key == KKNPMaterialKey) {
-    mi->scalingFunction[BLACK] = &ScaleKKNP;
       return mi;
   }
 
-  if(pos.non_pawn_material(WHITE) == BishopValueMidgame &&
+  // Generic scaling functions that refer to more then one material
-     pos.bishop_count(WHITE) == 1 && pos.pawn_count(WHITE) >= 1)
+  // distribution. Should be probed after the specialized ones.
-    mi->scalingFunction[WHITE] = &ScaleKBPK;
+  // Note that these ones don't return after setting the function.
-  if(pos.non_pawn_material(BLACK) == BishopValueMidgame &&
+  if (   pos.non_pawn_material(WHITE) == BishopValueMidgame
-     pos.bishop_count(BLACK) == 1 && pos.pawn_count(BLACK) >= 1)
+      && pos.piece_count(WHITE, BISHOP) == 1
-    mi->scalingFunction[BLACK] = &ScaleKKBP;
+      && pos.piece_count(WHITE, PAWN) >= 1)
+      mi->scalingFunction[WHITE] = &ScaleKBPsK;
 
-  if(pos.pawn_count(WHITE) == 0 &&
+  if (   pos.non_pawn_material(BLACK) == BishopValueMidgame
-     pos.non_pawn_material(WHITE) == QueenValueMidgame &&
+      && pos.piece_count(BLACK, BISHOP) == 1
-     pos.queen_count(WHITE) == 1 &&
+      && pos.piece_count(BLACK, PAWN) >= 1)
-     pos.rook_count(BLACK) == 1 && pos.pawn_count(BLACK) >= 1)
+      mi->scalingFunction[BLACK] = &ScaleKKBPs;
-    mi->scalingFunction[WHITE] = &ScaleKQKRP;
-  else if(pos.pawn_count(BLACK) == 0 &&
-          pos.non_pawn_material(BLACK) == QueenValueMidgame &&
-          pos.queen_count(BLACK) == 1 &&
-          pos.rook_count(WHITE) == 1 && pos.pawn_count(WHITE) >= 1)
-    mi->scalingFunction[BLACK] = &ScaleKRPKQ;
 
-  if(pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) == Value(0)) {
+  if (   pos.piece_count(WHITE, PAWN) == 0
-    if(pos.pawn_count(BLACK) == 0) {
+      && pos.non_pawn_material(WHITE) == QueenValueMidgame
-      assert(pos.pawn_count(WHITE) >= 2);
+      && pos.piece_count(WHITE, QUEEN) == 1
+      && pos.piece_count(BLACK, ROOK) == 1
+      && pos.piece_count(BLACK, PAWN) >= 1)
+      mi->scalingFunction[WHITE] = &ScaleKQKRPs;
+
+  else if (   pos.piece_count(BLACK, PAWN) == 0
+           && pos.non_pawn_material(BLACK) == QueenValueMidgame
+           && pos.piece_count(BLACK, QUEEN) == 1
+           && pos.piece_count(WHITE, ROOK) == 1
+           && pos.piece_count(WHITE, PAWN) >= 1)
+      mi->scalingFunction[BLACK] = &ScaleKRPsKQ;
+
+  if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) == Value(0))
+  {
+      if (pos.piece_count(BLACK, PAWN) == 0)
+      {
+          assert(pos.piece_count(WHITE, PAWN) >= 2);
           mi->scalingFunction[WHITE] = &ScaleKPsK;
       }
-    else if(pos.pawn_count(WHITE) == 0) {
+      else if (pos.piece_count(WHITE, PAWN) == 0)
-      assert(pos.pawn_count(BLACK) >= 2);
+      {
+          assert(pos.piece_count(BLACK, PAWN) >= 2);
           mi->scalingFunction[BLACK] = &ScaleKKPs;
       }
-    else if(pos.pawn_count(WHITE) == 1 && pos.pawn_count(BLACK) == 1) {
+      else if (pos.piece_count(WHITE, PAWN) == 1 && pos.piece_count(BLACK, PAWN) == 1)
+      {
+          // This is a special case because we set scaling functions
+          // for both colors instead of only one.
           mi->scalingFunction[WHITE] = &ScaleKPKPw;
           mi->scalingFunction[BLACK] = &ScaleKPKPb;
       }
   }
 
-  // Evaluate the material balance.
+  // Compute the space weight
+  if (pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK) >=
+      2*QueenValueMidgame + 4*RookValueMidgame + 2*KnightValueMidgame)
+  {
+      int minorPieceCount =  pos.piece_count(WHITE, KNIGHT)
+                           + pos.piece_count(BLACK, KNIGHT)
+                           + pos.piece_count(WHITE, BISHOP)
+                           + pos.piece_count(BLACK, BISHOP);
 
-  Color c;
+      mi->spaceWeight = minorPieceCount * minorPieceCount;
+  }
+
+  // Evaluate the material balance
+  const int pieceCount[2][6] = { { pos.piece_count(WHITE, BISHOP) > 1, pos.piece_count(WHITE, PAWN), pos.piece_count(WHITE, KNIGHT),
+                                   pos.piece_count(WHITE, BISHOP), pos.piece_count(WHITE, ROOK), pos.piece_count(WHITE, QUEEN) },
+                                 { pos.piece_count(BLACK, BISHOP) > 1, pos.piece_count(BLACK, PAWN), pos.piece_count(BLACK, KNIGHT),
+                                   pos.piece_count(BLACK, BISHOP), pos.piece_count(BLACK, ROOK), pos.piece_count(BLACK, QUEEN) } };
+  Color c, them;
   int sign;
-  Value egValue = Value(0), mgValue = Value(0);
+  int matValue = 0;
 
-  for(c = WHITE, sign = 1; c <= BLACK; c++, sign = -sign) {
+  for (c = WHITE, sign = 1; c <= BLACK; c++, sign = -sign)
-
+  {
-    // No pawns makes it difficult to win, even with a material advantage:
+    // No pawns makes it difficult to win, even with a material advantage
-    if(pos.pawn_count(c) == 0 &&
+    if (   pos.piece_count(c, PAWN) == 0
-       pos.non_pawn_material(c) - pos.non_pawn_material(opposite_color(c))
+        && pos.non_pawn_material(c) - pos.non_pawn_material(opposite_color(c)) <= BishopValueMidgame)
-       <= BishopValueMidgame) {
+    {
-      if(pos.non_pawn_material(c) == pos.non_pawn_material(opposite_color(c)))
+        if (   pos.non_pawn_material(c) == pos.non_pawn_material(opposite_color(c))
+            || pos.non_pawn_material(c) < RookValueMidgame)
             mi->factor[c] = 0;
-      else if(pos.non_pawn_material(c) < RookValueMidgame)
+        else
-        mi->factor[c] = 0;
+        {
-      else {
+            switch (pos.piece_count(c, BISHOP)) {
-        switch(pos.bishop_count(c)) {
             case 2:
-          mi->factor[c] = 32; break;
+                mi->factor[c] = 32;
+                break;
             case 1:
-          mi->factor[c] = 12; break;
+                mi->factor[c] = 12;
+                break;
             case 0:
-          mi->factor[c] = 6; break;
+                mi->factor[c] = 6;
+                break;
             }
         }
     }
 
-    // Bishop pair:
+    // Redundancy of major pieces, formula based on Kaufman's paper
-    if(pos.bishop_count(c) >= 2) {
+    // "The Evaluation of Material Imbalances in Chess"
-      mgValue += sign * BishopPairMidgameBonus;
-      egValue += sign * BishopPairEndgameBonus;
-    }
-
-    // Knights are stronger when there are many pawns on the board.  The 
-    // formula is taken from Larry Kaufman's paper "The Evaluation of Material
-    // Imbalances in Chess": 
     // http://mywebpages.comcast.net/danheisman/Articles/evaluation_of_material_imbalance.htm
-    mgValue += sign * Value(pos.knight_count(c)*(pos.pawn_count(c)-5)*16);
+    if (pieceCount[c][ROOK] >= 1)
-    egValue += sign * Value(pos.knight_count(c)*(pos.pawn_count(c)-5)*16);
+        matValue -= sign * ((pieceCount[c][ROOK] - 1) * RedundantRookPenalty + pieceCount[c][QUEEN] * RedundantQueenPenalty);
 
-    // Redundancy of major pieces, again based on Kaufman's paper:
+    them = opposite_color(c);
-    if(pos.rook_count(c) >= 1) {
+
-      Value v = Value((pos.rook_count(c) - 1) * 32 + pos.queen_count(c) * 16);
+    // Second-degree polynomial material imbalance by Tord Romstad
-      mgValue -= sign * v;
+    //
-      egValue -= sign * v;
+    // 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 (int pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; pt1++)
+    {
+        int c1 = sign * pieceCount[c][pt1];
+        if (!c1)
+            continue;
+
+        matValue += c1 * LinearCoefficients[pt1];
+
+        for (int pt2 = NO_PIECE_TYPE; pt2 <= pt1; pt2++)
+        {
+            matValue += c1 * pieceCount[c][pt2] * QuadraticCoefficientsSameColor[pt1][pt2];
+            matValue += c1 * pieceCount[them][pt2] * QuadraticCoefficientsOppositeColor[pt1][pt2];
         }
-      
     }
-
+  }
-  mi->mgValue = int16_t(mgValue);
+  mi->value = int16_t(matValue / 16);
-  mi->egValue = int16_t(egValue);
-
   return mi;
 }
+
+
+/// EndgameFunctions member definitions.
+
+EndgameFunctions::EndgameFunctions() {
+
+  add<EvaluationFunction<KNNK>  >("KNNK");
+  add<EvaluationFunction<KPK>   >("KPK");
+  add<EvaluationFunction<KBNK>  >("KBNK");
+  add<EvaluationFunction<KRKP>  >("KRKP");
+  add<EvaluationFunction<KRKB>  >("KRKB");
+  add<EvaluationFunction<KRKN>  >("KRKN");
+  add<EvaluationFunction<KQKR>  >("KQKR");
+  add<EvaluationFunction<KBBKN> >("KBBKN");
+
+  add<ScalingFunction<KNPK>    >("KNPK");
+  add<ScalingFunction<KRPKR>   >("KRPKR");
+  add<ScalingFunction<KBPKB>   >("KBPKB");
+  add<ScalingFunction<KBPPKB>  >("KBPPKB");
+  add<ScalingFunction<KBPKN>   >("KBPKN");
+  add<ScalingFunction<KRPPKRP> >("KRPPKRP");
+  add<ScalingFunction<KRPPKRP> >("KRPPKRP");
+}
+
+EndgameFunctions::~EndgameFunctions() {
+
+    for (map<Key, EF*>::iterator it = maps.first.begin(); it != maps.first.end(); ++it)
+        delete (*it).second;
+
+    for (map<Key, SF*>::iterator it = maps.second.begin(); it != maps.second.end(); ++it)
+        delete (*it).second;
+}
+
+Key EndgameFunctions::buildKey(const string& keyCode) {
+
+    assert(keyCode.length() > 0 && keyCode[0] == 'K');
+    assert(keyCode.length() < 8);
+
+    stringstream s;
+    bool upcase = false;
+
+    // Build up a fen string with the given pieces, note that
+    // the fen string could be of an illegal position.
+    for (size_t i = 0; i < keyCode.length(); i++)
+    {
+        if (keyCode[i] == 'K')
+            upcase = !upcase;
+
+        s << char(upcase? toupper(keyCode[i]) : tolower(keyCode[i]));
+    }
+    s << 8 - keyCode.length() << "/8/8/8/8/8/8/8 w -";
+    return Position(s.str()).get_material_key();
+}
+
+const string EndgameFunctions::swapColors(const string& keyCode) {
+
+    // Build corresponding key for the opposite color: "KBPKN" -> "KNKBP"
+    size_t idx = keyCode.find("K", 1);
+    return keyCode.substr(idx) + keyCode.substr(0, idx);
+}
+
+template<class T>
+void EndgameFunctions::add(const string& keyCode) {
+
+  typedef typename T::Base F;
+
+  get<F>().insert(pair<Key, F*>(buildKey(keyCode), new T(WHITE)));
+  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));
+  return (it != get<T>().end() ? it->second : NULL);
+}

src/material.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -48,42 +49,42 @@ class MaterialInfo {
   friend class MaterialInfoTable;
 
 public:
-  Value mg_value() const;
+  MaterialInfo() : key(0) { clear(); }
-  Value eg_value() const;
+
+  Value material_value() const;
   ScaleFactor scale_factor(const Position& pos, Color c) const;
+  int space_weight() const;
   bool specialized_eval_exists() const;
   Value evaluate(const Position& pos) const;
 
-  static void init();
-
 private:
-  void clear();
+  inline void clear();
 
   Key key;
-  int16_t mgValue;
+  int16_t value;
-  int16_t egValue;
   uint8_t factor[2];
-  EndgameEvaluationFunction *evaluationFunction;
+  EndgameEvaluationFunctionBase* evaluationFunction;
-  ScalingFunction *scalingFunction[2];
+  EndgameScalingFunctionBase* scalingFunction[2];
+  int spaceWeight;
 };
 
-
 /// The MaterialInfoTable class represents a pawn hash table. It is basically
 /// just an array of MaterialInfo objects and a few methods for accessing these
 /// objects. The most important method is get_material_info, which looks up a
 /// position in the table and returns a pointer to a MaterialInfo object.
+class EndgameFunctions;
 
 class MaterialInfoTable {
 
 public:
   MaterialInfoTable(unsigned numOfEntries);
   ~MaterialInfoTable();
-  void clear();
   MaterialInfo* get_material_info(const Position& pos);
 
 private:
   unsigned size;
   MaterialInfo* entries;
+  EndgameFunctions* funcs;
 };
 
 
@@ -91,39 +92,39 @@ private:
 //// Inline functions
 ////
 
-/// MaterialInfo::mg_value and MaterialInfo::eg_value simply returns the
+/// MaterialInfo::material_value simply returns the material balance
-/// material balance evaluation for the middle game and the endgame.
+/// evaluation that is independent from game phase.
 
-inline Value MaterialInfo::mg_value() const {
+inline Value MaterialInfo::material_value() const {
-  return Value(mgValue);
-}
 
-inline Value MaterialInfo::eg_value() const {
+  return Value(value);
-  return Value(egValue);
 }
 
 
 /// MaterialInfo::clear() resets a MaterialInfo object to an empty state,
-/// with all slots at their default values.
+/// with all slots at their default values but the key.
 
 inline void MaterialInfo::clear() {
-  mgValue = egValue = 0;
+
+  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
-/// be a constant:  It can also be a function which should be applied to
+/// to be a constant: It can also be a function which should be applied to
 /// the position. For instance, in KBP vs K endgames, a scaling function
 /// which checks for draws with rook pawns and wrong-colored bishops.
 
-inline ScaleFactor MaterialInfo::scale_factor(const Position &pos, Color c)
+inline ScaleFactor MaterialInfo::scale_factor(const Position& pos, Color c) const {
-  const {
+
-  if(scalingFunction[c] != NULL) {
+  if (scalingFunction[c] != NULL)
+  {
       ScaleFactor sf = scalingFunction[c]->apply(pos);
       if (sf != SCALE_FACTOR_NONE)
           return sf;
@@ -132,20 +133,31 @@ inline ScaleFactor MaterialInfo::scale_factor(const Position &pos, Color c)
 }
 
 
+/// MaterialInfo::space_weight() simply returns the weight for the space
+/// evaluation for this material configuration.
+
+inline int MaterialInfo::space_weight() const {
+
+  return spaceWeight;
+}
+
+
 /// MaterialInfo::specialized_eval_exists decides whether there is a
 /// specialized evaluation function for the current material configuration,
 /// or if the normal evaluation function should be used.
 
 inline bool MaterialInfo::specialized_eval_exists() const {
+
   return evaluationFunction != NULL;
 }
 
 
-/// MaterialInfo::evaluate applies a specialized evaluation function to a
+/// MaterialInfo::evaluate applies a specialized evaluation function
-/// given position object.  It should only be called when
+/// to a given position object. It should only be called when
-/// this->specialized_eval_exists() returns 'true'.
+/// specialized_eval_exists() returns 'true'.
 
 inline Value MaterialInfo::evaluate(const Position& pos) const {
+
   return evaluationFunction->apply(pos);
 }
 

src/mersenne.cpp

@@ -42,6 +42,7 @@
 */
 
 #include "types.h"
+#include "mersenne.h"
 
 /* Period parameters */
 #define N 624
@@ -54,7 +55,7 @@ static unsigned long mt[N]; /* the array for the state vector  */
 static int mti=N+1; /* mti==N+1 means mt[N] is not initialized */
 
 /* initializes mt[N] with a seed */
-void init_genrand(unsigned long s)
+static void init_genrand(unsigned long s)
 {
     mt[0]= s & 0xffffffffUL;
     for (mti=1; mti<N; mti++) {
@@ -73,7 +74,7 @@ void init_genrand(unsigned long s)
 /* init_key is the array for initializing keys */
 /* key_length is its length */
 /* slight change for C++, 2004/2/26 */
-void init_by_array(unsigned long init_key[], int key_length)
+static void init_by_array(unsigned long init_key[], int key_length)
 {
     int i, j, k;
     init_genrand(19650218UL);

src/mersenne.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.

src/misc.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -29,60 +30,152 @@
 
 #else
 
+#define _CRT_SECURE_NO_DEPRECATE
 #include <windows.h>
-#  include <time.h>
+#include <sys/timeb.h>
-#  include "dos.h"
-int gettimeofday(struct timeval * tp, struct timezone * tzp);
 
 #endif
 
+#include <cassert>
 #include <cstdio>
 #include <iomanip>
+#include <iostream>
 #include <sstream>
 
+#include "bitcount.h"
 #include "misc.h"
 
+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.5";
+static const string AppName = "Stockfish";
+static const string AppTag  = "";
+
+
+////
+//// Variables
+////
+
+bool Chess960;
+
+uint64_t dbg_cnt0 = 0;
+uint64_t dbg_cnt1 = 0;
+
+bool dbg_show_mean = false;
+bool dbg_show_hit_rate = false;
+
 
 ////
 //// Functions
 ////
 
-/// engine_name() returns the full name of the current Glaurung version.
+void dbg_hit_on(bool b) {
-/// This will be either "Glaurung YYMMDD" (where YYMMDD is the date when the
+
-/// program was compiled) or "Glaurung <version number>", depending on whether
+    assert(!dbg_show_mean);
+    dbg_show_hit_rate = true;
+    dbg_cnt0++;
+    if (b)
+        dbg_cnt1++;
+}
+
+void dbg_hit_on_c(bool c, bool b) {
+
+    if (c)
+        dbg_hit_on(b);
+}
+
+void dbg_before() {
+
+    assert(!dbg_show_mean);
+    dbg_show_hit_rate = true;
+    dbg_cnt0++;
+}
+
+void dbg_after() {
+
+    assert(!dbg_show_mean);
+    dbg_show_hit_rate = true;
+    dbg_cnt1++;
+}
+
+void dbg_mean_of(int v) {
+
+    assert(!dbg_show_hit_rate);
+    dbg_show_mean = true;
+    dbg_cnt0++;
+    dbg_cnt1 += v;
+}
+
+void dbg_print_hit_rate() {
+
+  cout << "Total " << dbg_cnt0 << " Hit " << dbg_cnt1
+       << " hit rate (%) " << (dbg_cnt1*100)/(dbg_cnt0 ? dbg_cnt0 : 1) << endl;
+}
+
+void dbg_print_mean() {
+
+  cout << "Total " << dbg_cnt0 << " Mean "
+       << (float)dbg_cnt1 / (dbg_cnt0 ? dbg_cnt0 : 1) << endl;
+}
+
+void dbg_print_hit_rate(ofstream& logFile) {
+
+  logFile << "Total " << dbg_cnt0 << " Hit " << dbg_cnt1
+          << " hit rate (%) " << (dbg_cnt1*100)/(dbg_cnt0 ? dbg_cnt0 : 1) << endl;
+}
+
+void dbg_print_mean(ofstream& logFile) {
+
+  logFile << "Total " << dbg_cnt0 << " Mean "
+          << (float)dbg_cnt1 / (dbg_cnt0 ? dbg_cnt0 : 1) << endl;
+}
+
+/// engine_name() returns the full name of the current Stockfish version.
+/// This will be either "Stockfish YYMMDD" (where YYMMDD is the date when the
+/// program was compiled) or "Stockfish <version number>", depending on whether
 /// the constant EngineVersion (defined in misc.h) is empty.
 
-const std::string engine_name() {
+const string engine_name() {
-  if(EngineVersion == "") {
-    static const char monthNames[12][4] = {
-      "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"
-    };
-    const char *dateString = __DATE__;
-    std::stringstream s;
-    int month = 0, day = 0;
 
-    for(int i = 0; i < 12; i++)
+  const string cpu64(CpuHas64BitPath ? " 64bit" : "");
-      if(strncmp(dateString, monthNames[i], 3) == 0)
-        month = i + 1;
-    day = atoi(dateString+4);
 
-    s << "Glaurung " << (dateString+9) << std::setfill('0') << std::setw(2)
+  if (!EngineVersion.empty())
-      << month << std::setfill('0') << std::setw(2) << day;
+      return AppName+ " " + EngineVersion + cpu64;
+
+  string date(__DATE__); // From compiler, format is "Sep 21 2008"
+  string months("Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec");
+
+  size_t mon = 1 + months.find(date.substr(0, 3)) / 4;
+
+  stringstream s;
+  string day = (date[4] == ' ' ? date.substr(5, 1) : date.substr(4, 2));
+
+  string name = AppName + " " + AppTag + " ";
+
+  s << name << date.substr(date.length() - 2) << setfill('0')
+    << setw(2) << mon << setw(2) << day << cpu64;
 
   return s.str();
 }
-  else
-    return "Glaurung " + EngineVersion;
-}
 
 
 /// get_system_time() returns the current system time, measured in
 /// milliseconds.
 
 int get_system_time() {
+
+#if defined(_MSC_VER)
+    struct _timeb t;
+    _ftime(&t);
+    return int(t.time*1000 + t.millitm);
+#else
     struct timeval t;
     gettimeofday(&t, NULL);
     return t.tv_sec*1000 + t.tv_usec/1000;
+#endif
 }
 
 
@@ -162,8 +255,24 @@ int Bioskey()
             return 1;
         return dw;
     } else {
+        // Count the number of unread input records, including keyboard,
+        // mouse, and window-resizing input records.
         GetNumberOfConsoleInputEvents(inh, &dw);
-        return dw <= 1 ? 0 : dw;
+        if (dw <= 0)
+            return 0;
+
+        // Read data from console without removing it from the buffer
+        INPUT_RECORD rec[256];
+        DWORD recCnt;
+        if (!PeekConsoleInput(inh, rec, Min(dw, 256), &recCnt))
+            return 0;
+
+        // Search for at least one keyboard event
+        for (DWORD i = 0; i < recCnt; i++)
+            if (rec[i].EventType == KEY_EVENT)
+                return 1;
+
+        return 0;
     }
 }
 #endif

src/misc.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -25,19 +26,11 @@
 //// Includes
 ////
 
+#include <fstream>
 #include <string>
 
-
+#include "application.h"
-////
+#include "types.h"
-//// Constants
-////
-
-
-/// Version number.  If this is left empty, the current date (in the format
-/// YYMMDD) is used as a version number.
-
-const std::string EngineVersion = "2.1";
-
 
 ////
 //// Macros
@@ -47,6 +40,13 @@ const std::string EngineVersion = "2.1";
 #define Max(x, y) (((x) < (y))? (y) : (x))
 
 
+////
+//// Variables
+////
+
+extern bool Chess960;
+
+
 ////
 //// Prototypes
 ////
@@ -57,4 +57,24 @@ extern int cpu_count();
 extern int Bioskey();
 
 
+////
+//// Debug
+////
+
+extern bool dbg_show_mean;
+extern bool dbg_show_hit_rate;
+
+extern uint64_t dbg_cnt0;
+extern uint64_t dbg_cnt1;
+
+extern void dbg_hit_on(bool b);
+extern void dbg_hit_on_c(bool c, bool b);
+extern void dbg_before();
+extern void dbg_after();
+extern void dbg_mean_of(int v);
+extern void dbg_print_hit_rate();
+extern void dbg_print_mean();
+extern void dbg_print_hit_rate(std::ofstream& logFile);
+extern void dbg_print_mean(std::ofstream& logFile);
+
 #endif // !defined(MISC_H_INCLUDED)

src/move.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -26,7 +27,6 @@
 #include "move.h"
 #include "piece.h"
 #include "position.h"
-#include "ucioption.h"
 
 
 ////
@@ -40,60 +40,65 @@
 /// the input move is legal and correctly formatted.
 
 Move move_from_string(const Position& pos, const std::string& str) {
+
   Square from, to;
   Piece piece;
   Color us = pos.side_to_move();
 
-  if(str.length() < 4) return MOVE_NONE;
+  if (str.length() < 4)
+      return MOVE_NONE;
 
-  // Read the from and to squares:
+  // Read the from and to squares
   from = square_from_string(str.substr(0, 2));
   to = square_from_string(str.substr(2, 4));
 
-  // Find the moving piece:
+  // Find the moving piece
   piece = pos.piece_on(from);
 
   // If the string has more than 4 characters, try to interpret the 5th
-  // character as a promotion:
+  // character as a promotion
-  if(type_of_piece(piece) == PAWN && str.length() >= 5) {
+  if (type_of_piece(piece) == PAWN && str.length() > 4)
-    switch(str[4]) {
+  {
-    case 'n': case 'N': 
+      switch (tolower(str[4])) {
+      case 'n':
           return make_promotion_move(from, to, KNIGHT);
-    case 'b': case 'B':
+      case 'b':
           return make_promotion_move(from, to, BISHOP);
-    case 'r': case 'R':
+      case 'r':
           return make_promotion_move(from, to, ROOK);
-    case 'q': case 'Q':
+      case 'q':
           return make_promotion_move(from, to, QUEEN);
     }
   }
 
-  if(piece == king_of_color(us)) {
+  if (piece == piece_of_color_and_type(us, KING))
+  {
       // Is this a castling move? A king move is assumed to be a castling
       // move if the destination square is occupied by a friendly rook, or
       // if the distance between the source and destination squares is more
       // than 1.
-    if(pos.piece_on(to) == rook_of_color(us))
+      if (pos.piece_on(to) == piece_of_color_and_type(us, ROOK))
           return make_castle_move(from, to);
-    else if(square_distance(from, to) > 1) {
+
+      else if (square_distance(from, to) > 1)
+      {
           // This is a castling move, but we have to translate it to the
           // internal "king captures rook" representation.
-      SquareDelta delta = (to > from)? DELTA_E : DELTA_W;
+          SquareDelta delta = (to > from ? DELTA_E : DELTA_W);
-      Square s;
+          Square s = from + delta;
-      for(s = from + delta;
+          while (relative_rank(us, s) == RANK_1 && pos.piece_on(s) != piece_of_color_and_type(us, ROOK))
-          pawn_rank(us, s) == RANK_1 && pos.piece_on(s) != rook_of_color(us);
+              s += delta;
-          s += delta);
+
-      if(pawn_rank(us, s) == RANK_1 && pos.piece_on(s) == rook_of_color(us))
+          return (relative_rank(us, s) == RANK_1 ? make_castle_move(from, s) : MOVE_NONE);
-        return make_castle_move(from, s);
       }
   }
-  else if(piece == pawn_of_color(us)) {
+  else if (piece == piece_of_color_and_type(us, PAWN))
+  {
       // En passant move? We assume that a pawn move is an en passant move
       // without further testing if the destination square is epSquare.
       if (to == pos.ep_square())
           return make_ep_move(from, to);
   }
-
   return make_move(from, to);
 }
 
@@ -104,30 +109,28 @@ Move move_from_string(const Position &pos, const std::string &str) {
 /// Chess960 mode.
 
 const std::string move_to_string(Move move) {
+
   std::string str;
+  Square from = move_from(move);
+  Square to = move_to(move);
 
   if (move == MOVE_NONE)
       str = "(none)";
   else if (move == MOVE_NULL)
       str = "0000";
-  else {
+  else
-    if(!Chess960) {
+  {
-      if(move_from(move) == SQ_E1 && move_is_short_castle(move)) {
+      if (!Chess960)
-        str = "e1g1"; return str;
+      {
+          if (move_is_short_castle(move))
+              return (from == SQ_E1 ? "e1g1" : "e8g8");
+
+          if (move_is_long_castle(move))
+              return (from == SQ_E1 ? "e1c1" : "e8c8");
       }
-      else if(move_from(move) == SQ_E1 && move_is_long_castle(move)) {
+      str = square_to_string(from) + square_to_string(to);
-        str = "e1c1"; return str;
+      if (move_is_promotion(move))
-      }
+          str += piece_type_to_char(move_promotion_piece(move), false);
-      if(move_from(move) == SQ_E8 && move_is_short_castle(move)) {
-        str = "e8g8"; return str;
-      }
-      else if(move_from(move) == SQ_E8 && move_is_long_castle(move)) {
-        str = "e8c8"; return str;
-      }
-    }
-    str = square_to_string(move_from(move)) + square_to_string(move_to(move));
-    if(move_promotion(move))
-      str += piece_type_to_char(move_promotion(move), false);
   }
   return str;
 }
@@ -136,6 +139,7 @@ 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) {
+
   return os << move_to_string(m);
 }
 
@@ -143,5 +147,6 @@ std::ostream &operator << (std::ostream &os, Move m) {
 /// move_is_ok(), for debugging.
 
 bool move_is_ok(Move m) {
+
   return square_is_ok(move_from(m)) && square_is_ok(move_to(m));
 }

src/move.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -37,10 +38,22 @@
 
 class Position;
 
+/// A move needs 17 bits to be stored
+///
+/// bit  0- 5: destination square (from 0 to 63)
+/// bit  6-11: origin square (from 0 to 63)
+/// bit 12-14: promotion piece type
+/// bit    15: en passant flag
+/// bit    16: castle flag
+///
+/// Special cases are MOVE_NONE and MOVE_NULL. We can sneak these in
+/// because in any normal move destination square is always different
+/// from origin square while MOVE_NONE and MOVE_NULL have the same
+/// origin and destination square, 0 and 1 respectively.
+
 enum Move {
   MOVE_NONE = 0,
-  MOVE_NULL = 65, 
+  MOVE_NULL = 65
-  MOVE_MAX = 0xFFFFFF
 };
 
 
@@ -49,29 +62,36 @@ struct MoveStack {
   int score;
 };
 
+// Note that operator< is set up such that std::sort() will sort in descending order
+inline bool operator<(const MoveStack& f, const MoveStack& s) { return s.score < f.score; }
+
 
 ////
 //// Inline functions
 ////
 
 inline Square move_from(Move m) {
-  return Square((int(m) >> 6) & 077);
+  return Square((int(m) >> 6) & 0x3F);
 }
 
 inline Square move_to(Move m) {
-  return Square(m & 077);
+  return Square(m & 0x3F);
 }
 
-inline PieceType move_promotion(Move m) {
+inline PieceType move_promotion_piece(Move m) {
   return PieceType((int(m) >> 12) & 7);
 }
 
-inline bool move_is_ep(Move m) {
+inline int move_is_promotion(Move m) {
-  return bool((int(m) >> 15) & 1);
+  return m & (7 << 12);
 }
 
-inline bool move_is_castle(Move m) {
+inline int move_is_ep(Move m) {
-  return bool((int(m) >> 16) & 1);
+  return m & (1 << 15);
+}
+
+inline int move_is_castle(Move m) {
+  return m & (1 << 16);
 }
 
 inline bool move_is_short_castle(Move m) {

src/movegen.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -31,12 +32,13 @@
 //// Prototypes
 ////
 
-extern int generate_captures(const Position &pos, MoveStack *mlist);
+extern MoveStack* generate_captures(const Position& pos, MoveStack* mlist);
-extern int generate_noncaptures(const Position &pos, MoveStack *mlist);
+extern MoveStack* generate_noncaptures(const Position& pos, MoveStack* mlist);
-extern int generate_checks(const Position &pos, MoveStack *mlist, Bitboard dc);
+extern MoveStack* generate_non_capture_checks(const Position& pos, MoveStack* mlist, Bitboard dc);
-extern int generate_evasions(const Position &pos, MoveStack *mlist);
+extern MoveStack* generate_evasions(const Position& pos, MoveStack* mlist, Bitboard pinned);
-extern int generate_legal_moves(const Position &pos, MoveStack *mlist);
+extern MoveStack* generate_moves(const Position& pos, MoveStack* mlist, bool pseudoLegal = false);
-extern Move generate_move_if_legal(const Position &pos, Move m,
+extern bool move_is_legal(const Position& pos, const Move m, Bitboard pinned);
-                                   Bitboard pinned);
+extern bool move_is_legal(const Position& pos, const Move m);
+
 
 #endif // !defined(MOVEGEN_H_INCLUDED)

src/movepick.cpp

@@ -1,13 +1,15 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+
+  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.
@@ -21,6 +23,7 @@
 //// Includes
 ////
 
+#include <algorithm>
 #include <cassert>
 
 #include "history.h"
@@ -36,31 +39,23 @@
 
 namespace {
 
-  /// Types
-
   enum MovegenPhase {
-    PH_TT_MOVE,        // Transposition table move
+    PH_TT_MOVES,       // Transposition table move and mate killer
-    PH_MATE_KILLER,    // Mate killer from the current ply
     PH_GOOD_CAPTURES,  // Queen promotions and captures with SEE values >= 0
-    PH_BAD_CAPTURES,   // Queen promotions and captures with SEE valuse <= 0
+    PH_KILLERS,        // Killer moves from the current ply
-    PH_KILLER_1,       // Killer move 1 from the current ply (not used yet).
-    PH_KILLER_2,       // Killer move 2 from the current ply (not used yet).
     PH_NONCAPTURES,    // Non-captures and underpromotions
+    PH_BAD_CAPTURES,   // Queen promotions and captures with SEE values < 0
     PH_EVASIONS,       // Check evasions
     PH_QCAPTURES,      // Captures in quiescence search
-    PH_QCHECKS,        // Checks in quiescence search
+    PH_QCHECKS,        // Non-capture checks in quiescence search
     PH_STOP
   };
 
-
+  CACHE_LINE_ALIGNMENT
-  /// Variables
+  const uint8_t MainSearchPhaseTable[] = { PH_TT_MOVES, PH_GOOD_CAPTURES, PH_KILLERS, PH_NONCAPTURES, PH_BAD_CAPTURES, PH_STOP};
-
+  const uint8_t EvasionsPhaseTable[] = { PH_EVASIONS, PH_STOP};
-  MovegenPhase PhaseTable[32];
+  const uint8_t QsearchWithChecksPhaseTable[] = { PH_TT_MOVES, PH_QCAPTURES, PH_QCHECKS, PH_STOP};
-  int MainSearchPhaseIndex;
+  const uint8_t QsearchWithoutChecksPhaseTable[] = { PH_TT_MOVES, PH_QCAPTURES, PH_STOP};
-  int EvasionsPhaseIndex;
-  int QsearchWithChecksPhaseIndex;
-  int QsearchWithoutChecksPhaseIndex;
-
 }
 
 
@@ -76,164 +71,113 @@ namespace {
 /// search captures, promotions and some checks) and about how important good
 /// move ordering is at the current node.
 
-MovePicker::MovePicker(Position &p, bool pvnode, Move ttm, Move mk,
+MovePicker::MovePicker(const Position& p, Move ttm, Depth d,
-                       Move k1, Move k2, Depth dpth) {
+                       const History& h, SearchStack* ss) : pos(p), H(h) {
-  pos = &p;
+  int searchTT = ttm;
-  pvNode = pvnode;
+  ttMoves[0].move = ttm;
-  ttMove = ttm;
+  finished = false;
-  mateKiller = (mk == ttm)? MOVE_NONE : mk;
+  lastBadCapture = badCaptures;
-  killer1 = k1;
+
-  killer2 = k2;
+  if (ss)
-  depth = dpth;
+  {
-  movesPicked = 0;
+      ttMoves[1].move = (ss->mateKiller == ttm)? MOVE_NONE : ss->mateKiller;
-  numOfMoves = 0;
+      searchTT |= ttMoves[1].move;
-  numOfBadCaptures = 0;
+      killers[0].move = ss->killers[0];
-  dc = p.discovered_check_candidates(p.side_to_move());
+      killers[1].move = ss->killers[1];
+  } else
+      ttMoves[1].move = killers[0].move = killers[1].move = MOVE_NONE;
+
+  Color us = pos.side_to_move();
+
+  dc = p.discovered_check_candidates(us);
+  pinned = p.pinned_pieces(us);
 
   if (p.is_check())
-    phaseIndex = EvasionsPhaseIndex;
+      phasePtr = EvasionsPhaseTable;
-  else if(depth > Depth(0))
+  else if (d > Depth(0))
-    phaseIndex = MainSearchPhaseIndex;
+      phasePtr = MainSearchPhaseTable + !searchTT;
-  else if(depth == Depth(0))
+  else if (d == Depth(0))
-    phaseIndex = QsearchWithChecksPhaseIndex;
+      phasePtr = QsearchWithChecksPhaseTable + !searchTT;
   else
-    phaseIndex = QsearchWithoutChecksPhaseIndex;
+      phasePtr = QsearchWithoutChecksPhaseTable + !searchTT;
 
-  pinned = p.pinned_pieces(p.side_to_move());
+  phasePtr--;
-
+  go_next_phase();
-  finished = false;
 }
 
 
-/// MovePicker::get_next_move() is the most important method of the MovePicker
+/// MovePicker::go_next_phase() generates, scores and sorts the next bunch
-/// class.  It returns a new legal move every time it is called, until there
+/// of moves when there are no more moves to try for the current phase.
-/// are no more moves left of the types we are interested in.
 
-Move MovePicker::get_next_move() {
+void MovePicker::go_next_phase() {
-  Move move;
 
-  while(true) {
+  curMove = moves;
-    // If we already have a list of generated moves, pick the best move from
+  phase = *(++phasePtr);
-    // the list, and return it:
+  switch (phase) {
-    move = this->pick_move_from_list();
-    if(move != MOVE_NONE) {
-      assert(move_is_ok(move));
-      return move;
-    }
 
-    // Next phase:
+  case PH_TT_MOVES:
-    phaseIndex++;
+      curMove = ttMoves;
-    switch(PhaseTable[phaseIndex]) {
+      lastMove = curMove + 2;
-
+      return;
-    case PH_TT_MOVE:
-      if(ttMove != MOVE_NONE) {
-        assert(move_is_ok(ttMove));
-        Move m = generate_move_if_legal(*pos, ttMove, pinned);
-        if(m != MOVE_NONE) {
-          assert(m == ttMove);
-          return m;
-        }
-      }
-      break;
-
-    case PH_MATE_KILLER:
-      if(mateKiller != MOVE_NONE) {
-        assert(move_is_ok(mateKiller));
-        Move m = generate_move_if_legal(*pos, mateKiller, pinned);
-        if(m != MOVE_NONE) {
-          assert(m == mateKiller);
-          return m;
-        }
-      }
-      break;
 
   case PH_GOOD_CAPTURES:
-      // pinned = pos->pinned_pieces(pos->side_to_move());
+      lastMove = generate_captures(pos, moves);
-      numOfMoves = generate_captures(*pos, moves);
+      score_captures();
-      this->score_captures();
+      std::sort(moves, lastMove);
-      movesPicked = 0;
+      return;
-      break;
 
-    case PH_BAD_CAPTURES:
+  case PH_KILLERS:
-      badCapturesPicked = 0;
+      curMove = killers;
-      break;
+      lastMove = curMove + 2;
+      return;
 
   case PH_NONCAPTURES:
-      numOfMoves = generate_noncaptures(*pos, moves);
+      lastMove = generate_noncaptures(pos, moves);
-      this->score_noncaptures();
+      score_noncaptures();
-      movesPicked = 0;
+      std::sort(moves, lastMove);
-      break;
+      return;
+
+  case PH_BAD_CAPTURES:
+      // Bad captures SEE value is already calculated so just sort them
+      // to get SEE move ordering.
+      curMove = badCaptures;
+      lastMove = lastBadCapture;
+      std::sort(badCaptures, lastMove);
+      return;
 
   case PH_EVASIONS:
-      assert(pos->is_check());
+      assert(pos.is_check());
-      // pinned = pos->pinned_pieces(pos->side_to_move());
+      lastMove = generate_evasions(pos, moves, pinned);
-      numOfMoves = generate_evasions(*pos, moves);
+      score_evasions();
-      this->score_evasions();
+      std::sort(moves, lastMove);
-      movesPicked = 0;
+      return;
-      break;
 
   case PH_QCAPTURES:
-      // pinned = pos->pinned_pieces(pos->side_to_move());
+      lastMove = generate_captures(pos, moves);
-      numOfMoves = generate_captures(*pos, moves);
+      score_captures();
-      this->score_qcaptures();
+      std::sort(moves, lastMove);
-      movesPicked = 0;
+      return;
-      break;
 
   case PH_QCHECKS:
-      numOfMoves = generate_checks(*pos, moves, dc);
+      // Perhaps we should order moves move here?  FIXME
-      movesPicked = 0;
+      lastMove = generate_non_capture_checks(pos, moves, dc);
-      break;
+      return;
 
   case PH_STOP:
-      return MOVE_NONE;
+      lastMove = curMove + 1; // hack to be friendly for get_next_move()
+      return;
 
   default:
       assert(false);
-      return MOVE_NONE;
+      return;
   }
 }
 
-  assert(false);
 
-  return MOVE_NONE;
+/// MovePicker::score_captures(), MovePicker::score_noncaptures() and
-}
+/// MovePicker::score_evasions() assign a numerical move ordering score
-
+/// to each move in a move list.  The moves with highest scores will be
-
+/// picked first by get_next_move().
-/// A variant of get_next_move() which takes a lock as a parameter, used to
-/// prevent multiple threads from picking the same move at a split point.
-
-Move MovePicker::get_next_move(Lock &lock) {
-   Move m;
-
-   lock_grab(&lock);
-   if(finished) {
-     lock_release(&lock);
-     return MOVE_NONE;
-   }
-   m = this->get_next_move();
-   if(m == MOVE_NONE)
-     finished = true;
-   lock_release(&lock);
-   
-   return m;
-}
-
- 
-/// MovePicker::number_of_moves() simply returns the numOfMoves member
-/// variable.  It is intended to be used in positions where the side to move
-/// is in check, for detecting checkmates or situations where there is only
-/// a single reply to check.
-
-int MovePicker::number_of_moves() const {
-  return numOfMoves;
-}
-
-
-/// MovePicker::score_captures(), MovePicker::score_noncaptures(),
-/// MovePicker::score_evasions() and MovePicker::score_qcaptures() assign a
-/// numerical move ordering score to each move in a move list.  The moves
-/// with highest scores will be picked first by
-/// MovePicker::pick_move_from_list().
 
 void MovePicker::score_captures() {
   // Winning and equal captures in the main search are ordered by MVV/LVA.
@@ -245,259 +189,171 @@ void MovePicker::score_captures() {
   // where it is possible to recapture with the hanging piece). Exchanging
   // big pieces before capturing a hanging piece probably helps to reduce
   // the subtree size.
-  for(int i = 0; i < numOfMoves; i++) {
+  // In main search we want to push captures with negative SEE values to
-    int seeValue = pos->see(moves[i].move);
+  // badCaptures[] array, but instead of doing it now we delay till when
-    if(seeValue >= 0) {
+  // the move has been picked up in pick_move_from_list(), this way we save
-      if(move_promotion(moves[i].move))
+  // some SEE calls in case we get a cutoff (idea from Pablo Vazquez).
-        moves[i].score = QueenValueMidgame;
+  Move m;
-      else 
-        moves[i].score =
-          int(pos->midgame_value_of_piece_on(move_to(moves[i].move))) -
-          int(pos->type_of_piece_on(move_from(moves[i].move)));
-    }
-    else
-      moves[i].score = seeValue;
 
+  // Use MVV/LVA ordering
+  for (MoveStack* cur = moves; cur != lastMove; cur++)
+  {
+      m = cur->move;
+      if (move_is_promotion(m))
+          cur->score = QueenValueMidgame;
+      else
+          cur->score = int(pos.midgame_value_of_piece_on(move_to(m)))
+                      -int(pos.type_of_piece_on(move_from(m)));
   }
 }
 
 void MovePicker::score_noncaptures() {
-  for(int i = 0; i < numOfMoves; i++) {
+  // First score by history, when no history is available then use
-    Move m = moves[i].move;
+  // piece/square tables values. This seems to be better then a
-    if(m == killer1)
+  // random choice when we don't have an history for any move.
-      moves[i].score = HistoryMax + 2;
+  Move m;
-    else if(m == killer2)
+  Piece piece;
-      moves[i].score = HistoryMax + 1;
+  Square from, to;
-    else
+  int hs;
-      moves[i].score = H.move_ordering_score(pos->piece_on(move_from(m)), m);
+
+  for (MoveStack* cur = moves; cur != lastMove; cur++)
+  {
+      m = cur->move;
+      from = move_from(m);
+      to = move_to(m);
+      piece = pos.piece_on(from);
+      hs = H.move_ordering_score(piece, to);
+
+      // Ensure history is always preferred to pst
+      if (hs > 0)
+          hs += 1000;
+
+      // pst based scoring
+      cur->score = hs + pos.pst_delta<Position::MidGame>(piece, from, to);
   }
 }
 
 void MovePicker::score_evasions() {
-  for(int i = 0; i < numOfMoves; i++) {
+
-    Move m = moves[i].move;
+  Move m;
-    if(m == ttMove)
+
-      moves[i].score = 2*HistoryMax;
+  for (MoveStack* cur = moves; cur != lastMove; cur++)
-    else if(!pos->square_is_empty(move_to(m))) {
+  {
-      int seeScore = pos->see(m);
+      m = cur->move;
-      moves[i].score = (seeScore >= 0)? seeScore + HistoryMax : seeScore;
+      if (m == ttMoves[0].move)
-    }
+          cur->score = 2 * HistoryMax;
-    else
+      else if (!pos.square_is_empty(move_to(m)))
-      moves[i].score = H.move_ordering_score(pos->piece_on(move_from(m)), m);
+      {
+          int seeScore = pos.see(m);
+          cur->score = seeScore + (seeScore >= 0 ? HistoryMax : 0);
+      } else
+          cur->score = H.move_ordering_score(pos.piece_on(move_from(m)), move_to(m));
   }
 }
 
-void MovePicker::score_qcaptures() {
+/// MovePicker::get_next_move() is the most important method of the MovePicker
-  // Use MVV/LVA ordering.
+/// class. It returns a new legal move every time it is called, until there
-  for(int i = 0; i < numOfMoves; i++) {
+/// are no more moves left.
-    Move m = moves[i].move;
+/// It picks the move with the biggest score from a list of generated moves taking
-    if(move_promotion(m))
+/// care not to return the tt move if has already been searched previously.
-      moves[i].score = QueenValueMidgame;
-    else
-      moves[i].score =
-        int(pos->midgame_value_of_piece_on(move_to(m))) -
-        int(pos->midgame_value_of_piece_on(move_to(m))) / 64;
-  }
-}
 
+Move MovePicker::get_next_move() {
 
-/// MovePicker::pick_move_from_list() picks the move with the biggest score
+  assert(!pos.is_check() || *phasePtr == PH_EVASIONS || *phasePtr == PH_STOP);
-/// from a list of generated moves (moves[] or badCaptures[], depending on
+  assert( pos.is_check() || *phasePtr != PH_EVASIONS);
-/// the current move generation phase).  It takes care not to return the
-/// transposition table move if that has already been serched previously.
-/// While picking captures in the PH_GOOD_CAPTURES phase (i.e. while picking
-/// non-losing captures in the main search), it moves all captures with
-/// negative SEE values to the badCaptures[] array.
 
-Move MovePicker::pick_move_from_list() {
-  int bestScore = -10000000;
-  int bestIndex;
   Move move;
 
-  switch(PhaseTable[phaseIndex]) {
+  while (true)
+  {
+      while (curMove != lastMove)
+      {
+          move = (curMove++)->move;
+
+          switch (phase) {
+
+          case PH_TT_MOVES:
+              if (   move != MOVE_NONE
+                  && move_is_legal(pos, move, pinned))
+                  return move;
+              break;
 
           case PH_GOOD_CAPTURES:
-    assert(!pos->is_check());
+              if (   move != ttMoves[0].move
-    assert(movesPicked >= 0);
+                  && move != ttMoves[1].move
-    while(movesPicked < numOfMoves) {
+                  && pos.pl_move_is_legal(move, pinned))
-      bestScore = -10000000;
+              {
-      bestIndex = -1;
+                  // Check for a non negative SEE now
-      for(int i = movesPicked; i < numOfMoves; i++) {
+                  int seeValue = pos.see_sign(move);
-        if(moves[i].score < 0) {
+                  if (seeValue >= 0)
-          // Losing capture, move it to the badCaptures[] array
-          assert(numOfBadCaptures < 63);
-          badCaptures[numOfBadCaptures++] = moves[i];
-          moves[i--] = moves[--numOfMoves];
-        }
-        else if(moves[i].score > bestScore) {
-          bestIndex = i;
-          bestScore = moves[i].score;
-        }
-      }
-      if(bestIndex != -1) { // Found a good capture
-        MoveStack tmp = moves[movesPicked];
-        moves[movesPicked] = moves[bestIndex];
-        moves[bestIndex] = tmp;
-        move = moves[movesPicked++].move;
-        if(move != ttMove && move != mateKiller &&
-           pos->move_is_legal(move, pinned))
                       return move;
+
+                  // Losing capture, move it to the badCaptures[] array, note
+                  // that move has now been already checked for legality.
+                  assert(int(lastBadCapture - badCaptures) < 63);
+                  lastBadCapture->move = move;
+                  lastBadCapture->score = seeValue;
+                  lastBadCapture++;
               }
-    }
+              break;
+
+          case PH_KILLERS:
+              if (   move != MOVE_NONE
+                  && move != ttMoves[0].move
+                  && move != ttMoves[1].move
+                  && move_is_legal(pos, move, pinned)
+                  && !pos.move_is_capture(move))
+                  return move;
               break;
 
           case PH_NONCAPTURES:
-    assert(!pos->is_check());
+              if (   move != ttMoves[0].move
-    assert(movesPicked >= 0);
+                  && move != ttMoves[1].move
-    while(movesPicked < numOfMoves) {
+                  && move != killers[0].move
-      bestScore = -10000000;
+                  && move != killers[1].move
-
+                  && pos.pl_move_is_legal(move, pinned))
-      // If this is a PV node or we have only picked a few moves, scan
-      // the entire move list for the best move.  If many moves have already
-      // been searched and it is not a PV node, we are probably failing low
-      // anyway, so we just pick the first move from the list.
-      if(pvNode || movesPicked < 12) {
-        bestIndex = -1;
-        for(int i = movesPicked; i < numOfMoves; i++)
-          if(moves[i].score > bestScore) {
-            bestIndex = i;
-            bestScore = moves[i].score;
-          }
-      }
-      else
-        bestIndex = movesPicked;
-
-      if(bestIndex != -1) {
-        MoveStack tmp = moves[movesPicked];
-        moves[movesPicked] = moves[bestIndex];
-        moves[bestIndex] = tmp;
-        move = moves[movesPicked++].move;
-        if(move != ttMove && move != mateKiller &&
-           pos->move_is_legal(move, pinned))
                   return move;
-      }
-    }
               break;
 
           case PH_EVASIONS:
-    assert(pos->is_check());
-    assert(movesPicked >= 0);
-    while(movesPicked < numOfMoves) {
-      bestScore = -10000000;
-      bestIndex = -1;
-      for(int i = movesPicked; i < numOfMoves; i++)
-        if(moves[i].score > bestScore) {
-          bestIndex = i;
-          bestScore = moves[i].score;
-        }
-
-      if(bestIndex != -1) {
-        MoveStack tmp = moves[movesPicked];
-        moves[movesPicked] = moves[bestIndex];
-        moves[bestIndex] = tmp;
-        move = moves[movesPicked++].move;
-        return move;
-      }
-    }
-    break;
-
           case PH_BAD_CAPTURES:
-    assert(!pos->is_check());
-    assert(badCapturesPicked >= 0);
-    // It's probably a good idea to use SEE move ordering here, instead
-    // of just picking the first move.  FIXME
-    while(badCapturesPicked < numOfBadCaptures) {
-      move = badCaptures[badCapturesPicked++].move;
-      if(move != ttMove && move != mateKiller && 
-         pos->move_is_legal(move, pinned))
               return move;
-    }
-    break;
 
           case PH_QCAPTURES:
-    assert(!pos->is_check());
-    assert(movesPicked >= 0);
-    while(movesPicked < numOfMoves) {
-      bestScore = -10000000;
-      if(movesPicked < 4) {
-        bestIndex = -1;
-        for(int i = movesPicked; i < numOfMoves; i++)
-          if(moves[i].score > bestScore) {
-            bestIndex = i;
-            bestScore = moves[i].score;
-          }
-      }
-      else
-        bestIndex = movesPicked;
-
-      if(bestIndex != -1) {
-        MoveStack tmp = moves[movesPicked];
-        moves[movesPicked] = moves[bestIndex];
-        moves[bestIndex] = tmp;
-
-        move = moves[movesPicked++].move;
-        // Remember to change the line below if we decide to hash the qsearch!
-        // Maybe also postpone the legality check until after futility pruning?
-        if(/* move != ttMove && */ pos->move_is_legal(move, pinned))
-          return move;
-      }
-    }
-    break;
-
           case PH_QCHECKS:
-    assert(!pos->is_check());
+              // Maybe postpone the legality check until after futility pruning?
-    assert(movesPicked >= 0);
+              if (   move != ttMoves[0].move
-    // Perhaps we should do something better than just picking the first
+                  && pos.pl_move_is_legal(move, pinned))
-    // move here?  FIXME
-    while(movesPicked < numOfMoves) {
-      move = moves[movesPicked++].move;
-      // Remember to change the line below if we decide to hash the qsearch!
-      if(/* move != ttMove && */ pos->move_is_legal(move, pinned))
                   return move;
-    }
               break;
 
+          case PH_STOP:
+              return MOVE_NONE;
+
           default:
+              assert(false);
               break;
           }
+      }
+      go_next_phase();
+  }
+}
 
+/// A variant of get_next_move() which takes a lock as a parameter, used to
+/// prevent multiple threads from picking the same move at a split point.
+
+Move MovePicker::get_next_move(Lock &lock) {
+
+   lock_grab(&lock);
+   if (finished)
+   {
+       lock_release(&lock);
        return MOVE_NONE;
    }
+   Move m = get_next_move();
+   if (m == MOVE_NONE)
+       finished = true;
 
-
+   lock_release(&lock);
-/// MovePicker::init_phase_table() initializes the PhaseTable[],
+   return m;
-/// MainSearchPhaseIndex, EvasionPhaseIndex, QsearchWithChecksPhaseIndex
-/// and QsearchWithoutChecksPhaseIndex variables.  It is only called once
-/// during program startup, and never again while the program is running.
-
-void MovePicker::init_phase_table() {
-  int i = 0;
-
-  // Main search
-  MainSearchPhaseIndex = i - 1;
-  PhaseTable[i++] = PH_TT_MOVE;
-  PhaseTable[i++] = PH_MATE_KILLER;
-  PhaseTable[i++] = PH_GOOD_CAPTURES;
-  // PH_KILLER_1 and PH_KILLER_2 are not yet used.
-  // PhaseTable[i++] = PH_KILLER_1;
-  // PhaseTable[i++] = PH_KILLER_2;
-  PhaseTable[i++] = PH_NONCAPTURES;
-  PhaseTable[i++] = PH_BAD_CAPTURES;
-  PhaseTable[i++] = PH_STOP;
-
-  // Check evasions
-  EvasionsPhaseIndex = i - 1;
-  PhaseTable[i++] = PH_EVASIONS;
-  PhaseTable[i++] = PH_STOP;
-
-  // Quiescence search with checks
-  QsearchWithChecksPhaseIndex = i - 1;
-  PhaseTable[i++] = PH_QCAPTURES;
-  PhaseTable[i++] = PH_QCHECKS;
-  PhaseTable[i++] = PH_STOP;
-
-  // Quiescence search without checks
-  QsearchWithoutChecksPhaseIndex = i - 1;
-  PhaseTable[i++] = PH_QCAPTURES;
-  PhaseTable[i++] = PH_STOP;
 }

src/movepick.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -25,6 +26,7 @@
 ////
 
 #include "depth.h"
+#include "history.h"
 #include "lock.h"
 #include "position.h"
 
@@ -33,6 +35,8 @@
 //// Types
 ////
 
+struct SearchStack;
+
 /// MovePicker is a class which is used to pick one legal move at a time from
 /// the current position. It is initialized with a Position object and a few
 /// moves we have reason to believe are good. The most important method is
@@ -43,34 +47,30 @@
 
 class MovePicker {
 
+  MovePicker& operator=(const MovePicker&); // silence a warning under MSVC
+
 public:
-  MovePicker(Position &p, bool pvnode, Move ttm, Move mk, Move k1, Move k2,
+  MovePicker(const Position& p, Move ttm, Depth d, const History& h, SearchStack* ss = NULL);
-             Depth dpth);
   Move get_next_move();
   Move get_next_move(Lock& lock);
-  int number_of_moves() const;
+  int number_of_evasions() const;
-  int current_move_score() const;
+  Bitboard discovered_check_candidates() const;
-  Bitboard discovered_check_candidates();
-
-  static void init_phase_table();
 
 private:
   void score_captures();
   void score_noncaptures();
   void score_evasions();
-  void score_qcaptures();
+  void go_next_phase();
-  Move pick_move_from_list();
 
-  Position *pos;
+  const Position& pos;
-  Move ttMove, mateKiller, killer1, killer2;
+  const History& H;
-  Bitboard pinned, dc;
+  MoveStack ttMoves[2], killers[2];
-  MoveStack moves[256], badCaptures[64];
-  bool pvNode;
-  Depth depth;
-  int phaseIndex;
-  int numOfMoves, numOfBadCaptures;
-  int movesPicked, badCapturesPicked;
   bool finished;
+  int phase;
+  const uint8_t* phasePtr;
+  MoveStack *curMove, *lastMove, *lastBadCapture;
+  Bitboard dc, pinned;
+  MoveStack moves[256], badCaptures[64];
 };
 
 
@@ -78,11 +78,21 @@ private:
 //// Inline functions
 ////
 
+/// MovePicker::number_of_evasions() simply returns the number of moves in
+/// evasions phase. It is intended to be used in positions where the side to
+/// move is in check, for detecting checkmates or situations where there is
+/// only a single reply to check.
+/// WARNING: It works as long as PH_EVASIONS is the _only_ phase for evasions.
+
+inline int MovePicker::number_of_evasions() const {
+  return int(lastMove - moves);
+}
+
 /// MovePicker::discovered_check_candidates() returns a bitboard containing
 /// all pieces which can possibly give discovered check. This bitboard is
 /// computed by the constructor function.
 
-inline Bitboard MovePicker::discovered_check_candidates() {
+inline Bitboard MovePicker::discovered_check_candidates() const {
   return dc;
 }
 

src/pawns.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -22,8 +23,11 @@
 ////
 
 #include <cassert>
+#include <cstring>
 
+#include "bitcount.h"
 #include "pawns.h"
+#include "position.h"
 
 
 ////
@@ -34,100 +38,95 @@ namespace {
 
   /// Constants and variables
 
-  // Doubled pawn penalty by file, middle game.
+  // Doubled pawn penalty by file, middle game
   const Value DoubledPawnMidgamePenalty[8] = {
-    Value(20), Value(30), Value(34), Value(34),
+    Value(13), Value(20), Value(23), Value(23),
-    Value(34), Value(34), Value(30), Value(20)
+    Value(23), Value(23), Value(20), Value(13)
   };
 
-  // Doubled pawn penalty by file, endgame.
+  // Doubled pawn penalty by file, endgame
   const Value DoubledPawnEndgamePenalty[8] = {
-    Value(35), Value(40), Value(40), Value(40),
+    Value(43), Value(48), Value(48), Value(48),
-    Value(40), Value(40), Value(40), Value(35)
+    Value(48), Value(48), Value(48), Value(43)
   };
 
-  // Isolated pawn penalty by file, middle game.
+  // Isolated pawn penalty by file, middle game
   const Value IsolatedPawnMidgamePenalty[8] = {
-    Value(20), Value(30), Value(34), Value(34),
+    Value(25), Value(36), Value(40), Value(40),
-    Value(34), Value(34), Value(30), Value(20)
+    Value(40), Value(40), Value(36), Value(25)
   };
 
-  // Isolated pawn penalty by file, endgame.
+  // Isolated pawn penalty by file, endgame
   const Value IsolatedPawnEndgamePenalty[8] = {
-    Value(35), Value(40), Value(40), Value(40),
+    Value(30), Value(35), Value(35), Value(35),
-    Value(40), Value(40), Value(40), Value(35)
+    Value(35), Value(35), Value(35), Value(30)
   };
 
-  // Backward pawn penalty by file, middle game.
+  // Backward pawn penalty by file, middle game
   const Value BackwardPawnMidgamePenalty[8] = {
-    Value(16), Value(24), Value(27), Value(27),
+    Value(20), Value(29), Value(33), Value(33),
-    Value(27), Value(27), Value(24), Value(16)
+    Value(33), Value(33), Value(29), Value(20)
   };
 
-  // Backward pawn penalty by file, endgame.
+  // Backward pawn penalty by file, endgame
   const Value BackwardPawnEndgamePenalty[8] = {
-    Value(28), Value(32), Value(32), Value(32),
+    Value(28), Value(31), Value(31), Value(31),
-    Value(32), Value(32), Value(32), Value(28)
+    Value(31), Value(31), Value(31), Value(28)
   };
 
-  // Pawn chain membership bonus by file, middle game. 
+  // Pawn chain membership bonus by file, middle game
   const Value ChainMidgameBonus[8] = {
-    Value(14), Value(16), Value(17), Value(18),
+    Value(11), Value(13), Value(13), Value(14),
-    Value(18), Value(17), Value(16), Value(14)
+    Value(14), Value(13), Value(13), Value(11)
   };
 
-  // Pawn chain membership bonus by file, endgame. 
+  // Pawn chain membership bonus by file, endgame
   const Value ChainEndgameBonus[8] = {
-    Value(16), Value(16), Value(16), Value(16),
+    Value(-1), Value(-1), Value(-1), Value(-1),
-    Value(16), Value(16), Value(16), Value(16)
+    Value(-1), Value(-1), Value(-1), Value(-1)
   };
 
-  // Candidate passed pawn bonus by rank, middle game.
+  // Candidate passed pawn bonus by rank, middle game
   const Value CandidateMidgameBonus[8] = {
-    Value(0), Value(12), Value(12), Value(20),
+    Value( 0), Value( 6), Value(6), Value(14),
-    Value(40), Value(90), Value(0), Value(0)
+    Value(34), Value(83), Value(0), Value( 0)
   };
 
-  // Candidate passed pawn bonus by rank, endgame.
+  // Candidate passed pawn bonus by rank, endgame
   const Value CandidateEndgameBonus[8] = {
-    Value(0), Value(24), Value(24), Value(40),
+    Value( 0), Value( 13), Value(13), Value(29),
-    Value(80), Value(180), Value(0), Value(0)
+    Value(68), Value(166), Value( 0), Value( 0)
   };
 
-  // Evaluate pawn storms?
+  // Pawn storm tables for positions with opposite castling
-  const bool EvaluatePawnStorms = true;
-
-  // Pawn storm tables for positions with opposite castling:
   const int QStormTable[64] = {
     0,  0,  0,  0, 0, 0, 0, 0,
-    -22, -22, -22, -13, -4, 0, 0, 0,
+  -22,-22,-22,-14,-6, 0, 0, 0,
-    -4, -9, -9, -9, -4, 0, 0, 0,
+   -6,-10,-10,-10,-6, 0, 0, 0,
-    9, 18, 22, 18, 9, 0, 0, 0,
+    4, 12, 16, 12, 4, 0, 0, 0,
-    22, 31, 31, 22, 0, 0, 0, 0,
+   16, 23, 23, 16, 0, 0, 0, 0,
-    31, 40, 40, 31, 0, 0, 0, 0,
+   23, 31, 31, 23, 0, 0, 0, 0,
-    31, 40, 40, 31, 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, -4, -13, -22, -27, -27,
+    0, 0, 0,-10,-19,-28,-33,-33,
-    0, 0, 0, -4, -9, -13, -18, -18,
+    0, 0, 0,-10,-15,-19,-24,-24,
-    0, 0, 0, 0, 9, 9, 9, 9,
+    0, 0, 0,  0,  1,  1,  1,  1,
-    0, 0, 0, 0, 9, 18, 27, 27,
+    0, 0, 0,  0,  1, 10, 19, 19,
-    0, 0, 0, 0, 9, 27, 40, 36,
+    0, 0, 0,  0,  1, 19, 31, 27,
-    0, 0, 0, 0, 0, 31, 40, 31,
+    0, 0, 0,  0,  0, 22, 31, 22,
     0, 0, 0,  0,  0,  0,  0,  0
   };
 
-  // Pawn storm open file bonuses by file:
+  // Pawn storm open file bonuses by file
-  const int KStormOpenFileBonus[8] = {
+  const int16_t KStormOpenFileBonus[8] = { 31, 31, 18, 0, 0, 0, 0, 0 };
-    45, 45, 30, 0, 0, 0, 0, 0
+  const int16_t QStormOpenFileBonus[8] = { 0, 0, 0, 0, 0, 26, 42, 26 };
-  };
 
-  const int QStormOpenFileBonus[8] = {
+  // Pawn storm lever bonuses by file
-    0, 0, 0, 0, 0, 30, 45, 30
+  const int StormLeverBonus[8] = { -8, -8, -13, 0, 0, -13, -8, -8 };
-  };
 
 }
 
@@ -139,14 +138,15 @@ namespace {
 /// Constructor
 
 PawnInfoTable::PawnInfoTable(unsigned numOfEntries) {
+
   size = numOfEntries;
   entries = new PawnInfo[size];
-  if(entries == NULL) {
+  if (!entries)
+  {
       std::cerr << "Failed to allocate " << (numOfEntries * sizeof(PawnInfo))
                 << " bytes for pawn hash table." << std::endl;
-    exit(EXIT_FAILURE);
+      Application::exit_with_failure();
   }
-  this->clear();
 }
 
 
@@ -157,11 +157,13 @@ PawnInfoTable::~PawnInfoTable() {
 }
 
 
-/// PawnInfoTable::clear() clears the pawn hash table by setting all
+/// PawnInfo::clear() resets to zero the PawnInfo entry. Note that
-/// entries to 0.
+/// kingSquares[] is initialized to SQ_NONE instead.
 
-void PawnInfoTable::clear() {
+void PawnInfo::clear() {
-  memset(entries, 0, size * sizeof(PawnInfo));
+
+  memset(this, 0, sizeof(PawnInfo));
+  kingSquares[WHITE] = kingSquares[BLACK] = SQ_NONE;
 }
 
 
@@ -171,6 +173,7 @@ void PawnInfoTable::clear() {
 /// the same pawn structure occurs again.
 
 PawnInfo* PawnInfoTable::get_pawn_info(const Position& pos) {
+
   assert(pos.is_ok());
 
   Key key = pos.get_pawn_key();
@@ -178,208 +181,229 @@ PawnInfo *PawnInfoTable::get_pawn_info(const Position &pos) {
   PawnInfo* pi = entries + index;
 
   // If pi->key matches the position's pawn hash key, it means that we
-  // have analysed this pawn structure before, and we can simply return the
+  // have analysed this pawn structure before, and we can simply return
-  // information we found the last time instead of recomputing it:
+  // the information we found the last time instead of recomputing it.
   if (pi->key == key)
       return pi;
 
-  // Clear the PawnInfo object, and set the key:
+  // Clear the PawnInfo object, and set the key
   pi->clear();
   pi->key = key;
 
   Value mgValue[2] = {Value(0), Value(0)};
   Value egValue[2] = {Value(0), Value(0)};
 
-  // Loop through the pawns for both colors:
+  // Calculate pawn attacks
-  for(Color us = WHITE; us <= BLACK; us++) {
+  pi->pawnAttacks[WHITE] = ((pos.pieces(PAWN, WHITE) << 9) & ~FileABB) | ((pos.pieces(PAWN, WHITE) << 7) & ~FileHBB);
+  pi->pawnAttacks[BLACK] = ((pos.pieces(PAWN, BLACK) >> 7) & ~FileABB) | ((pos.pieces(PAWN, BLACK) >> 9) & ~FileHBB);
+
+  // Loop through the pawns for both colors
+  for (Color us = WHITE; us <= BLACK; us++)
+  {
     Color them = opposite_color(us);
-    Bitboard ourPawns = pos.pawns(us);
+    Bitboard ourPawns = pos.pieces(PAWN, us);
-    Bitboard theirPawns = pos.pawns(them);
+    Bitboard theirPawns = pos.pieces(PAWN, them);
     Bitboard pawns = ourPawns;
 
-    // Initialize pawn storm scores by giving bonuses for open files:
+    // Initialize pawn storm scores by giving bonuses for open files
-    if(EvaluatePawnStorms)
     for (File f = FILE_A; f <= FILE_H; f++)
-        if(pos.file_is_half_open(us, f)) {
+        if (!(pawns & 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:
+    // Loop through all pawns of the current color and score each pawn
-    while(pawns) {
+    while (pawns)
+    {
         Square s = pop_1st_bit(&pawns);
         File f = square_file(s);
         Rank r = square_rank(s);
-      bool passed, doubled, isolated, backward, chain, candidate;
-      int bonus;
 
-      assert(pos.piece_on(s) == pawn_of_color(us));
+        assert(pos.piece_on(s) == piece_of_color_and_type(us, PAWN));
-
-      // The file containing the pawn is not half open:
-      pi->halfOpenFiles[us] &= ~(1 << f);
 
         // Passed, isolated or doubled pawn?
-      passed = pos.pawn_is_passed(us, s);
+        bool passed   = Position::pawn_is_passed(theirPawns, us, s);
-      isolated = pos.pawn_is_isolated(us, s);
+        bool isolated = Position::pawn_is_isolated(ourPawns, s);
-      doubled = pos.pawn_is_doubled(us, s);
+        bool doubled  = Position::pawn_is_doubled(ourPawns, us, s);
 
-      if(EvaluatePawnStorms) {
         // We calculate kingside and queenside pawn storm
         // scores for both colors. These are used when evaluating
         // middle game positions with opposite side castling.
         //
         // Each pawn is given a base score given by a piece square table
-        // (KStormTable[] or QStormTable[]).  This score is increased if
+        // (KStormTable[] or QStormTable[]). Pawns which seem to have good
-        // there are enemy pawns on adjacent files in front of the pawn.
+        // chances of creating an open file by exchanging itself against an
-        // This is because we want to be able to open files against the
+        // enemy pawn on an adjacent file gets an additional bonus.
-        // enemy king, and to avoid blocking the pawn structure (e.g. white
-        // pawns on h6, g5, black pawns on h7, g6, f7).
 
-        // Kingside pawn storms:
+        // Kingside pawn storms
-        bonus = KStormTable[relative_square(us, s)];
+        int bonus = KStormTable[relative_square(us, s)];
-        if(bonus > 0 && outpost_mask(us, s) & theirPawns) {
+        if (f >= FILE_F)
-          switch(f) {
+        {
-
+            Bitboard b = outpost_mask(us, s) & theirPawns & (FileFBB | FileGBB | FileHBB);
-          case FILE_F:
+            while (b)
-            bonus += bonus / 4;
+            {
-            break;
+                Square s2 = pop_1st_bit(&b);
-
+                if (!(theirPawns & neighboring_files_bb(s2) & rank_bb(s2)))
-          case FILE_G:
+                {
-            bonus += bonus / 2 + bonus / 4;
+                    // The enemy pawn has no pawn beside itself, which makes it
-            break;
+                    // particularly vulnerable. Big bonus, especially against a
-
+                    // weakness on the rook file.
-          case FILE_H:
+                    if (square_file(s2) == FILE_H)
-            bonus += bonus / 2;
+                        bonus += 4*StormLeverBonus[f] - 8*square_distance(s, s2);
-            break;
+                    else
-
+                        bonus += 2*StormLeverBonus[f] - 4*square_distance(s, s2);
-          default:
+                } else
-            break;
+                    // There is at least one enemy pawn beside the enemy pawn we look
+                    // at, which means that the pawn has somewhat better chances of
+                    // defending itself by advancing. Smaller bonus.
+                    bonus += StormLeverBonus[f] - 2*square_distance(s, s2);
             }
         }
         pi->ksStormValue[us] += bonus;
 
-        // Queenside pawn storms:
+        // Queenside pawn storms
         bonus = QStormTable[relative_square(us, s)];
-        if(bonus > 0 && passed_pawn_mask(us, s) & theirPawns) {
+        if (f <= FILE_C)
-          switch(f) {
+        {
-
+            Bitboard b = outpost_mask(us, s) & theirPawns & (FileABB | FileBBB | FileCBB);
-          case FILE_A:
+            while (b)
-            bonus += bonus / 2;
+            {
-            break;
+                Square s2 = pop_1st_bit(&b);
-
+                if (!(theirPawns & neighboring_files_bb(s2) & rank_bb(s2)))
-          case FILE_B:
+                {
-            bonus += bonus / 2 + bonus / 4;
+                    // The enemy pawn has no pawn beside itself, which makes it
-            break;
+                    // particularly vulnerable. Big bonus, especially against a
-
+                    // weakness on the rook file.
-          case FILE_C:
+                    if (square_file(s2) == FILE_A)
-            bonus += bonus / 2;
+                        bonus += 4*StormLeverBonus[f] - 16*square_distance(s, s2);
-            break;
+                    else
-
+                        bonus += 2*StormLeverBonus[f] - 8*square_distance(s, s2);
-          default:
+                } else
-            break;
+                    // There is at least one enemy pawn beside the enemy pawn we look
+                    // at, which means that the pawn has somewhat better chances of
+                    // defending itself by advancing. Smaller bonus.
+                    bonus += StormLeverBonus[f] - 4*square_distance(s, s2);
             }
         }
         pi->qsStormValue[us] += bonus;
-      }
 
-      // Member of a pawn chain?  We could speed up the test a little by 
+        // Member of a pawn chain (but not the backward one)? We could speed up
-      // introducing an array of masks indexed by color and square for doing
+        // the test a little by introducing an array of masks indexed by color
-      // the test, but because everything is hashed, it probably won't make
+        // and square for doing the test, but because everything is hashed,
-      // any noticable difference.
+        // it probably won't make any noticable difference.
-      chain = (us == WHITE)?
+        bool chain =  ourPawns
-        (ourPawns & neighboring_files_bb(f) & (rank_bb(r) | rank_bb(r-1))) :
+                    & neighboring_files_bb(f)
-        (ourPawns & neighboring_files_bb(f) & (rank_bb(r) | rank_bb(r+1)));
+                    & (rank_bb(r) | rank_bb(r - (us == WHITE ? 1 : -1)));
 
-
+        // Test for backward pawn
-      // Test for backward pawn.
+        //
-
+        // If the pawn is passed, isolated, or member of a pawn chain
-      // If the pawn is isolated, passed, or member of a pawn chain, it cannot
+        // it cannot be backward. If can capture an enemy pawn or if
-      // be backward:
+        // there are friendly pawns behind on neighboring files it cannot
-      if(passed || isolated || chain)
+        // be backward either.
+        bool backward;
+        if (   passed
+            || isolated
+            || chain
+            || (pos.attacks_from<PAWN>(s, us) & theirPawns)
+            || (ourPawns & behind_bb(us, r) & neighboring_files_bb(f)))
             backward = false;
-      // If the pawn can capture an enemy pawn, it's not backward:
+        else
-      else if(pos.pawn_attacks(us, s) & theirPawns)
+        {
-        backward = false;
+            // We now know that there are no friendly pawns beside or behind this
-      // Check for friendly pawns behind on neighboring files:
-      else if(ourPawns & in_front_bb(them, r) & neighboring_files_bb(f))
-        backward = false;
-      else {
-        // We now know that there is no friendly pawns beside or behind this
             // pawn on neighboring files. We now check whether the pawn is
             // backward by looking in the forward direction on the neighboring
             // files, and seeing whether we meet a friendly or an enemy pawn first.
-        Bitboard b;
+            Bitboard b = pos.attacks_from<PAWN>(s, us);
-        if(us == WHITE) {
+            if (us == WHITE)
-          for(b=pos.pawn_attacks(us, s); !(b&(ourPawns|theirPawns)); b<<=8);
+            {
+                for ( ; !(b & (ourPawns | theirPawns)); b <<= 8);
                 backward = (b | (b << 8)) & theirPawns;
             }
-        else {
+            else
-          for(b=pos.pawn_attacks(us, s); !(b&(ourPawns|theirPawns)); b>>=8);
+            {
+                for ( ; !(b & (ourPawns | theirPawns)); b >>= 8);
                 backward = (b | (b >> 8)) & theirPawns;
             }
         }
 
-      // Test for candidate passed pawn.
+        // Test for candidate passed pawn
-      candidate =
+        bool candidate;
-        (!passed && pos.file_is_half_open(them, f) &&
+        candidate =    !passed
-         count_1s_max_15(neighboring_files_bb(f)
+                    && !(theirPawns & file_bb(f))
-                         & (in_front_bb(them, r) | rank_bb(r))
+                    && (  count_1s_max_15(neighboring_files_bb(f) & (behind_bb(us, r) | rank_bb(r)) & ourPawns)
-                         & ourPawns)
+                        - count_1s_max_15(neighboring_files_bb(f) & in_front_bb(us, r)              & theirPawns)
-         - count_1s_max_15(neighboring_files_bb(f) & in_front_bb(us, r)
-                           & theirPawns)
                         >= 0);
 
         // In order to prevent doubled passed pawns from receiving a too big
         // bonus, only the frontmost passed pawn on each file is considered as
         // a true passed pawn.
-      if(passed && (ourPawns & squares_in_front_of(us, s))) {
+        if (passed && (ourPawns & squares_in_front_of(us, s)))
-        // candidate = true;
             passed = false;
-      }
 
-      // Score this pawn:
+        // Score this pawn
-      Value mv = Value(0), ev = Value(0);
-      if(isolated) {
-        mv -= IsolatedPawnMidgamePenalty[f];
-        ev -= IsolatedPawnEndgamePenalty[f];
-        if(pos.file_is_half_open(them, f)) {
-          mv -= IsolatedPawnMidgamePenalty[f] / 2;
-          ev -= IsolatedPawnEndgamePenalty[f] / 2;
-        }
-      }
-      if(doubled)  {
-        mv -= DoubledPawnMidgamePenalty[f];
-        ev -= DoubledPawnEndgamePenalty[f];
-      }
-      if(backward)  {
-        mv -= BackwardPawnMidgamePenalty[f];
-        ev -= BackwardPawnEndgamePenalty[f];
-        if(pos.file_is_half_open(them, f)) {
-          mv -= BackwardPawnMidgamePenalty[f] / 2;
-          ev -= BackwardPawnEndgamePenalty[f] / 2;
-        }
-      }
-      if(chain) {
-        mv += ChainMidgameBonus[f];
-        ev += ChainEndgameBonus[f];
-      }
-      if(candidate) {
-        mv += CandidateMidgameBonus[pawn_rank(us, s)];
-        ev += CandidateEndgameBonus[pawn_rank(us, s)];
-      }
-
-      mgValue[us] += mv;
-      egValue[us] += ev;
-        
-      // If the pawn is passed, set the square of the pawn in the passedPawns
-      // bitboard:
         if (passed)
             set_bit(&(pi->passedPawns), s);
+
+        if (isolated)
+        {
+            mgValue[us] -= IsolatedPawnMidgamePenalty[f];
+            egValue[us] -= IsolatedPawnEndgamePenalty[f];
+            if (!(theirPawns & file_bb(f)))
+            {
+                mgValue[us] -= IsolatedPawnMidgamePenalty[f] / 2;
+                egValue[us] -= IsolatedPawnEndgamePenalty[f] / 2;
             }
         }
+        if (doubled)
+        {
+            mgValue[us] -= DoubledPawnMidgamePenalty[f];
+            egValue[us] -= DoubledPawnEndgamePenalty[f];
+        }
+        if (backward)
+        {
+            mgValue[us] -= BackwardPawnMidgamePenalty[f];
+            egValue[us] -= BackwardPawnEndgamePenalty[f];
+            if (!(theirPawns & file_bb(f)))
+            {
+                mgValue[us] -= BackwardPawnMidgamePenalty[f] / 2;
+                egValue[us] -= BackwardPawnEndgamePenalty[f] / 2;
+            }
+        }
+        if (chain)
+        {
+            mgValue[us] += ChainMidgameBonus[f];
+            egValue[us] += ChainEndgameBonus[f];
+        }
+        if (candidate)
+        {
+            mgValue[us] += CandidateMidgameBonus[relative_rank(us, s)];
+            egValue[us] += CandidateEndgameBonus[relative_rank(us, s)];
+        }
+    } // while(pawns)
+  } // for(colors)
 
   pi->mgValue = int16_t(mgValue[WHITE] - mgValue[BLACK]);
   pi->egValue = int16_t(egValue[WHITE] - egValue[BLACK]);
-
   return pi;
 }
+
+
+/// 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) {
+
+  unsigned shelter = 0;
+  Bitboard pawns = pos.pieces(PAWN, c) & this_and_neighboring_files_bb(ksq);
+  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

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -24,8 +25,8 @@
 //// Includes
 ////
 
-#include "position.h"
+#include "bitboard.h"
-
+#include "value.h"
 
 ////
 //// Types
@@ -37,32 +38,40 @@
 /// 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() : key(0) { clear(); }
+
   Value mg_value() const;
   Value eg_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;
-  bool file_is_half_open(Color c, File f) const;
+  int file_is_half_open(Color c, File f) const;
-  bool has_open_file_to_left(Color c, File f) const;
+  int has_open_file_to_left(Color c, File f) const;
-  bool has_open_file_to_right(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);
 
 private:
   void clear();
+  int updateShelter(const Position& pos, Color c, Square ksq);
 
   Key key;
   Bitboard passedPawns;
+  Bitboard pawnAttacks[2];
   int16_t mgValue, egValue;
-  int8_t ksStormValue[2], qsStormValue[2];
+  int16_t ksStormValue[2], qsStormValue[2];
   uint8_t halfOpenFiles[2];
+  Square kingSquares[2];
+  uint8_t kingShelters[2];
 };
 
-
 /// The PawnInfoTable class represents a pawn hash table.  It is basically
 /// just an array of PawnInfo objects and a few methods for accessing these
 /// objects.  The most important method is get_pawn_info, which looks up a
@@ -73,7 +82,6 @@ class PawnInfoTable {
 public:
   PawnInfoTable(unsigned numOfEntries);
   ~PawnInfoTable();
-  void clear();
   PawnInfo* get_pawn_info(const Position& pos);
 
 private:
@@ -98,6 +106,10 @@ inline Bitboard PawnInfo::passed_pawns() const {
   return passedPawns;
 }
 
+inline Bitboard PawnInfo::pawn_attacks(Color c) const {
+  return pawnAttacks[c];
+}
+
 inline Value PawnInfo::kingside_storm_value(Color c) const {
   return Value(ksStormValue[c]);
 }
@@ -106,25 +118,20 @@ inline Value PawnInfo::queenside_storm_value(Color c) const {
   return Value(qsStormValue[c]);
 }
 
-inline bool PawnInfo::file_is_half_open(Color c, File f) const {
+inline int PawnInfo::file_is_half_open(Color c, File f) const {
   return (halfOpenFiles[c] & (1 << int(f)));
 }
 
-inline bool PawnInfo::has_open_file_to_left(Color c, File f) const {
+inline int PawnInfo::has_open_file_to_left(Color c, File f) const {
   return halfOpenFiles[c] & ((1 << int(f)) - 1);
 }
 
-inline bool PawnInfo::has_open_file_to_right(Color c, File f) const {
+inline int PawnInfo::has_open_file_to_right(Color c, File f) const {
   return halfOpenFiles[c] & ~((1 << int(f+1)) - 1);
 }
 
-inline void PawnInfo::clear() {
+inline int PawnInfo::get_king_shelter(const Position& pos, Color c, Square ksq) {
-  mgValue = egValue = 0;
+  return (kingSquares[c] == ksq ? kingShelters[c] : updateShelter(pos, c, ksq));
-  passedPawns = EmptyBoardBB;
-  ksStormValue[WHITE] = ksStormValue[BLACK] = 0;
-  qsStormValue[WHITE] = qsStormValue[BLACK] = 0;
-  halfOpenFiles[WHITE] = halfOpenFiles[BLACK] = 0xFF;
 }
 
-
 #endif // !defined(PAWNS_H_INCLUDED)

src/phase.h

@@ -1,33 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung 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.
-  
-  Glaurung 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/>.
-*/
-
-
-#if !defined(PHASE_H_INCLUDED)
-#define PHASE_H_INCLUDED
-
-////
-//// Types
-////
-
-enum Phase {
-  PHASE_ENDGAME = 0,
-  PHASE_MIDGAME = 128
-};
-
-
-#endif // !defined(PHASE_H_INCLUDED)

src/piece.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -21,74 +22,28 @@
 //// Includes
 ////
 
-#include <cstring>
+#include <string>
 
 #include "piece.h"
 
-
+using namespace std;
-////
-//// Constants and variables
-////
-
-const int SlidingArray[18] = {
-  0, 0, 0, 1, 2, 3, 0, 0, 0, 0, 0, 1, 2, 3, 0, 0, 0, 0
-};
-
-const SquareDelta Directions[16][16] = {
-  {DELTA_ZERO},
-  {DELTA_NW, DELTA_NE, DELTA_ZERO},
-  {DELTA_SSW, DELTA_SSE, DELTA_SWW, DELTA_SEE,
-   DELTA_NWW, DELTA_NEE, DELTA_NNW, DELTA_NNE, DELTA_ZERO},
-  {DELTA_SE, DELTA_SW, DELTA_NE, DELTA_NW, DELTA_ZERO},
-  {DELTA_S, DELTA_E, DELTA_W, DELTA_N, DELTA_ZERO},
-  {DELTA_S, DELTA_E, DELTA_W, DELTA_N, 
-   DELTA_SE, DELTA_SW, DELTA_NE, DELTA_NW, DELTA_ZERO},
-  {DELTA_S, DELTA_E, DELTA_W, DELTA_N, 
-   DELTA_SE, DELTA_SW, DELTA_NE, DELTA_NW, DELTA_ZERO},
-  {DELTA_ZERO},
-  {DELTA_ZERO},
-  {DELTA_SW, DELTA_SE, DELTA_ZERO},
-  {DELTA_SSW, DELTA_SSE, DELTA_SWW, DELTA_SEE,
-   DELTA_NWW, DELTA_NEE, DELTA_NNW, DELTA_NNE, DELTA_ZERO},
-  {DELTA_SE, DELTA_SW, DELTA_NE, DELTA_NW, DELTA_ZERO},
-  {DELTA_S, DELTA_E, DELTA_W, DELTA_N, DELTA_ZERO},
-  {DELTA_S, DELTA_E, DELTA_W, DELTA_N, 
-   DELTA_SE, DELTA_SW, DELTA_NE, DELTA_NW, DELTA_ZERO},
-  {DELTA_S, DELTA_E, DELTA_W, DELTA_N, 
-   DELTA_SE, DELTA_SW, DELTA_NE, DELTA_NW, DELTA_ZERO},
-};   
-
-const SquareDelta PawnPush[2] = {
-  DELTA_N, DELTA_S
-};
-
 
 ////
 //// Functions
 ////
 
-/// Translating piece types to/from English piece letters:
+/// Translating piece types to/from English piece letters
 
-static const char PieceChars[] = " pnbrqk";
+static const string PieceChars(" pnbrqk PNBRQK");
 
-char piece_type_to_char(PieceType pt, bool upcase = false) {
+char piece_type_to_char(PieceType pt, bool upcase) {
-  return upcase? toupper(PieceChars[pt]) : PieceChars[pt];
+
+  return PieceChars[pt + upcase * 7];
 }
 
 PieceType piece_type_from_char(char c) {
-  const char *ch = strchr(PieceChars, tolower(c));
+
-  return ch? PieceType(ch - PieceChars) : NO_PIECE_TYPE;
+  size_t idx = PieceChars.find(c);
-}
+
-
+  return idx != string::npos ? PieceType(idx % 7) : NO_PIECE_TYPE;
-
-/// piece_is_ok() and piece_type_is_ok(), for debugging:
-
-bool piece_is_ok(Piece pc) {
-  return
-    piece_type_is_ok(type_of_piece(pc)) &&
-    color_is_ok(color_of_piece(pc));
-}
-
-bool piece_type_is_ok(PieceType pc) {
-  return pc >= PAWN && pc <= KING;
 }

src/piece.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -25,7 +26,6 @@
 ////
 
 #include "color.h"
-#include "misc.h"
 #include "square.h"
 
 
@@ -46,15 +46,12 @@ enum Piece {
 
 
 ////
-//// Constants and variables
+//// Constants
 ////
 
-const PieceType PieceTypeMin = PAWN;
+const int SlidingArray[18] = {
-const PieceType PieceTypeMax = KING;
+  0, 0, 0, 1, 2, 3, 0, 0, 0, 0, 0, 1, 2, 3, 0, 0, 0, 0
-
+};
-extern const int SlidingArray[18];
-extern const SquareDelta Directions[16][16];   
-extern const SquareDelta PawnPush[2];
 
 
 ////
@@ -82,40 +79,20 @@ inline Piece piece_of_color_and_type(Color c, PieceType pt) {
   return Piece((int(c) << 3) | int(pt));
 }
 
-inline Piece pawn_of_color(Color c) {
-  return piece_of_color_and_type(c, PAWN);
-}
-
-inline Piece knight_of_color(Color c) {
-  return piece_of_color_and_type(c, KNIGHT);
-}
-
-inline Piece bishop_of_color(Color c) {
-  return piece_of_color_and_type(c, BISHOP);
-}
-
-inline Piece rook_of_color(Color c) {
-  return piece_of_color_and_type(c, ROOK);
-}
-
-inline Piece queen_of_color(Color c) {
-  return piece_of_color_and_type(c, QUEEN);
-}
-
-inline Piece king_of_color(Color c) {
-  return piece_of_color_and_type(c, KING);
-}
-
 inline int piece_is_slider(Piece p) {
   return SlidingArray[int(p)];
 }
 
-inline int piece_type_is_slider(PieceType pt) {
+inline SquareDelta pawn_push(Color c) {
-  return SlidingArray[int(pt)];
+    return (c == WHITE ? DELTA_N : DELTA_S);
 }
 
-inline SquareDelta pawn_push(Color c) {
+inline bool piece_type_is_ok(PieceType pc) {
-  return PawnPush[c];
+  return pc >= PAWN && pc <= KING;
+}
+
+inline bool piece_is_ok(Piece pc) {
+  return piece_type_is_ok(type_of_piece(pc)) && color_is_ok(color_of_piece(pc));
 }
 
 
@@ -123,10 +100,8 @@ inline SquareDelta pawn_push(Color c) {
 //// Prototypes
 ////
 
-extern char piece_type_to_char(PieceType pt, bool upcase);
+extern char piece_type_to_char(PieceType pt, bool upcase = false);
 extern PieceType piece_type_from_char(char c);
-extern bool piece_is_ok(Piece pc);
-extern bool piece_type_is_ok(PieceType pt);
 
 
 #endif // !defined(PIECE_H_INCLUDED)

src/position.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -20,6 +21,18 @@
 #if !defined(POSITION_H_INCLUDED)
 #define POSITION_H_INCLUDED
 
+// Disable some silly and noisy warning from MSVC compiler
+#if defined(_MSC_VER)
+
+// Forcing value to bool 'true' or 'false' (performance warning)
+#pragma warning(disable: 4800)
+
+// Conditional expression is constant
+#pragma warning(disable: 4127)
+
+
+#endif
+
 ////
 //// Includes
 ////
@@ -29,7 +42,6 @@
 #include "direction.h"
 #include "move.h"
 #include "piece.h"
-#include "phase.h"
 #include "square.h"
 #include "value.h"
 
@@ -38,13 +50,12 @@
 //// Constants
 ////
 
-/// FEN string for the initial position:
+/// FEN string for the initial position
-const std::string StartPosition = 
+const std::string StartPosition = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
-  "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):
+/// move counter for every non-reversible move).
 const int MaxGameLength = 220;
 
 
@@ -52,31 +63,39 @@ const int MaxGameLength = 220;
 //// Types
 ////
 
-/// Castle rights, encoded as bit fields:
+/// Castle rights, encoded as bit fields
 
 enum CastleRights {
   NO_CASTLES  = 0,
-  WHITE_OO = 1, BLACK_OO = 2, 
+  WHITE_OO    = 1,
-  WHITE_OOO = 4, BLACK_OOO = 8,
+  BLACK_OO    = 2,
+  WHITE_OOO   = 4,
+  BLACK_OOO   = 8,
   ALL_CASTLES = 15
 };
 
+/// Game phase
+enum Phase {
+  PHASE_ENDGAME = 0,
+  PHASE_MIDGAME = 128
+};
 
-/// The UndoInfo struct stores information we need to restore a Position
+
+/// The StateInfo struct stores information we need to restore a Position
 /// object to its previous state when we retract a move. Whenever a move
-/// is made on the board (by calling Position::do_move), an UndoInfo object
+/// is made on the board (by calling Position::do_move), an StateInfo object
-/// must be passed as a parameter.  When the move is unmade (by calling
+/// must be passed as a parameter.
-/// Position::undo_move), the same UndoInfo object must be passed again.
 
-struct UndoInfo {
+struct StateInfo {
-  int castleRights;
-  Square epSquare;
-  Bitboard checkersBB;
   Key key, pawnKey, materialKey;
-  int rule50;
+  int castleRights, rule50;
-  Move lastMove;
+  Square epSquare;
-  PieceType capture;
   Value mgValue, egValue;
+  Value npMaterial[2];
+
+  PieceType capture;
+  Bitboard checkersBB;
+  StateInfo* previous;
 };
 
 
@@ -84,7 +103,7 @@ struct UndoInfo {
 ///
 ///    * For each piece type, a bitboard representing the squares occupied
 ///      by pieces of that type.
-///    * For each color, a bitboard representing the squares occupiecd by
+///    * For each color, a bitboard representing the squares occupied by
 ///      pieces of that color.
 ///    * A bitboard of all occupied squares.
 ///    * A bitboard of all checking pieces.
@@ -96,27 +115,32 @@ struct UndoInfo {
 ///    * The en passant square (which is SQ_NONE if no en passant capture is
 ///      possible).
 ///    * The squares of the kings for both sides.
-///    * The last move played.
 ///    * Hash keys for the position itself, the current pawn structure, and
 ///      the current material situation.
-///    * Hash keys for all previous positions in the game (for detecting
+///    * Hash keys for all previous positions in the game for detecting
 ///      repetition draws.
 ///    * A counter for detecting 50 move rule draws.
 
 class Position {
 
   friend class MaterialInfo;
+  friend class EndgameFunctions;
 
 public:
+  enum GamePhase {
+      MidGame,
+      EndGame
+  };
+
   // Constructors
-  Position();
+  Position() {}
   Position(const Position& pos);
   Position(const std::string& fen);
 
   // Text input/output
   void from_fen(const std::string& fen);
   const std::string to_fen() const;
-  void print() const;
+  void print(Move m = MOVE_NONE) const;
 
   // Copying
   void copy(const Position& pos);
@@ -138,124 +162,76 @@ public:
   Bitboard empty_squares() const;
   Bitboard occupied_squares() const;
   Bitboard pieces_of_color(Color c) const;
-  Bitboard pieces_of_type(PieceType pt) const;
+  Bitboard pieces(PieceType pt) const;
-  Bitboard pieces_of_color_and_type(Color c, PieceType pt) const;
+  Bitboard pieces(PieceType pt, Color c) const;
-  Bitboard pawns() const;
+  Bitboard pieces(PieceType pt1, PieceType pt2) const;
-  Bitboard knights() const;
+  Bitboard pieces(PieceType pt1, PieceType pt2, Color c) const;
-  Bitboard bishops() const;
-  Bitboard rooks() const;
-  Bitboard queens() const;
-  Bitboard kings() const;
-  Bitboard rooks_and_queens() const;
-  Bitboard bishops_and_queens() const;
-  Bitboard sliders() const;
-  Bitboard pawns(Color c) const;
-  Bitboard knights(Color c) const;
-  Bitboard bishops(Color c) const;
-  Bitboard rooks(Color c) const;
-  Bitboard queens(Color c) const;
-  Bitboard kings(Color c) const;
-  Bitboard rooks_and_queens(Color c) const;
-  Bitboard bishops_and_queens(Color c) const;
-  Bitboard sliders_of_color(Color c) const;
 
   // Number of pieces of each color and type
   int piece_count(Color c, PieceType pt) const;
-  int pawn_count(Color c) const;
-  int knight_count(Color c) const;
-  int bishop_count(Color c) const;
-  int rook_count(Color c) const;
-  int queen_count(Color c) const;
 
-  // The en passant square:
+  // The en passant square
   Square ep_square() const;
 
   // Current king position for each color
   Square king_square(Color c) const;
 
-  // Castling rights.
+  // Castling rights
   bool can_castle_kingside(Color c) const;
   bool can_castle_queenside(Color c) const;
   bool can_castle(Color c) const;
   Square initial_kr_square(Color c) const;
   Square initial_qr_square(Color c) const;
 
-  // Attack bitboards
-  Bitboard sliding_attacks(Square s, Direction d) const;
-  Bitboard ray_attacks(Square s, SignedDirection d) const;
-  Bitboard pawn_attacks(Color c, Square s) const;
-  Bitboard white_pawn_attacks(Square s) const;
-  Bitboard black_pawn_attacks(Square s) const;
-  Bitboard knight_attacks(Square s) const;
-  Bitboard bishop_attacks(Square s) const;
-  Bitboard rook_attacks(Square s) const;
-  Bitboard queen_attacks(Square s) const;
-  Bitboard king_attacks(Square s) const;
-
   // Bitboards for pinned pieces and discovered check candidates
   Bitboard discovered_check_candidates(Color c) const;
   Bitboard pinned_pieces(Color c) const;
 
-  // Checking pieces
+  // Checking pieces and under check information
   Bitboard checkers() const;
-
-  // Piece lists:
-  Square piece_list(Color c, PieceType pt, int index) const;
-  Square pawn_list(Color c, int index) const;
-  Square knight_list(Color c, int index) const;
-  Square bishop_list(Color c, int index) const;
-  Square rook_list(Color c, int index) const;
-  Square queen_list(Color c, int index) const;
-
-  // Attack information for a given square
-  bool square_is_attacked(Square s, Color c) const;
-  Bitboard attacks_to(Square s) const;
-  Bitboard attacks_to(Square s, Color c) const;
   bool is_check() const;
-  bool piece_attacks_square(Square f, Square t) const;
+
-  bool white_pawn_attacks_square(Square f, Square t) const;
+  // Piece lists
-  bool black_pawn_attacks_square(Square f, Square t) const;
+  Square piece_list(Color c, PieceType pt, int index) const;
-  bool knight_attacks_square(Square f, Square t) const;
+  const Square* piece_list_begin(Color c, PieceType pt) const;
-  bool bishop_attacks_square(Square f, Square t) const;
+
-  bool rook_attacks_square(Square f, Square t) const;
+  // Information about attacks to or from a given square
-  bool queen_attacks_square(Square f, Square t) const;
+  Bitboard attackers_to(Square s) const;
-  bool king_attacks_square(Square f, Square t) const;
+  Bitboard attacks_from(Piece p, Square s) const;
+  template<PieceType> Bitboard attacks_from(Square s) const;
+  template<PieceType> Bitboard attacks_from(Square s, Color c) const;
 
   // Properties of moves
-  bool move_is_legal(Move m) const;
+  bool pl_move_is_legal(Move m) const;
-  bool move_is_legal(Move m, Bitboard pinned) const;
+  bool pl_move_is_legal(Move m, Bitboard pinned) const;
   bool move_is_check(Move m) const;
   bool move_is_check(Move m, Bitboard dcCandidates) const;
   bool move_is_capture(Move m) const;
-  bool move_is_pawn_push_to_7th(Move m) const;
   bool move_is_passed_pawn_push(Move m) const;
-  bool move_was_passed_pawn_push(Move m) const;
   bool move_attacks_square(Move m, Square s) const;
 
   // Information about pawns
   bool pawn_is_passed(Color c, Square s) const;
-  bool pawn_is_isolated(Color c, Square s) const;
+  static bool pawn_is_passed(Bitboard theirPawns, Color c, Square s);
-  bool pawn_is_doubled(Color c, Square s) const;
+  static bool pawn_is_isolated(Bitboard ourPawns, Square s);
-
+  static bool pawn_is_doubled(Bitboard ourPawns, Color c, Square s);
-  // Open and half-open files
-  bool file_is_open(File f) const;
-  bool file_is_half_open(Color c, File f) const;
 
   // Weak squares
   bool square_is_weak(Square s, Color c) const;
 
   // Doing and undoing moves
-  void backup(UndoInfo &u) const;
+  void saveState();
-  void restore(const UndoInfo &u);
+  void do_move(Move m, StateInfo& st);
-  void do_move(Move m, UndoInfo &u);
+  void do_move(Move m, StateInfo& st, Bitboard dcCandidates);
-  void do_move(Move m, UndoInfo &u, Bitboard dcCandidates);
+  void undo_move(Move m);
-  void undo_move(Move m, const UndoInfo &u);
+  void do_null_move(StateInfo& st);
-  void do_null_move(UndoInfo &u);
+  void undo_null_move();
-  void undo_null_move(const UndoInfo &u);
 
   // 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
   Key get_key() const;
@@ -267,9 +243,10 @@ public:
   Value eg_value() const;
   Value non_pawn_material(Color c) const;
   Phase game_phase() const;
+  template<GamePhase> Value pst_delta(Piece piece, Square from, Square to) const;
 
   // Game termination checks
-  bool is_mate();
+  bool is_mate() const;
   bool is_draw() const;
 
   // Check if one side threatens a mate in one
@@ -286,13 +263,14 @@ public:
   void reset_game_ply();
 
   // Position consistency check, for debugging
-  bool is_ok() const;
+  bool is_ok(int* failedStep = NULL) const;
 
-  // Static member functions:
+  // Static member functions
   static void init_zobrist();
   static void init_piece_square_tables();
 
 private:
+
   // Initialization helper functions (used while setting up a position)
   void clear();
   void put_piece(Piece p, Square s);
@@ -300,51 +278,47 @@ private:
   void allow_ooo(Color c);
 
   // Helper functions for doing and undoing moves
+  void do_capture_move(Bitboard& key, PieceType capture, Color them, Square to, bool ep);
   void do_castle_move(Move m);
-  void do_promotion_move(Move m, UndoInfo &u);
-  void do_ep_move(Move m);
   void undo_castle_move(Move m);
-  void undo_promotion_move(Move m, const UndoInfo &u);
-  void undo_ep_move(Move m);
   void find_checkers();
 
+  template<PieceType Piece>
+  void update_checkers(Bitboard* pCheckersBB, Square ksq, Square from, Square to, Bitboard dcCandidates);
+
+  template<bool FindPinned>
+  Bitboard hidden_checkers(Color c) const;
+
   // Computing hash keys from scratch (for initialization and debugging)
   Key compute_key() const;
   Key compute_pawn_key() const;
   Key compute_material_key() const;
 
   // Computing incremental evaluation scores and material counts
-  Value mg_pst(Color c, PieceType pt, Square s) const;
+  template<GamePhase> Value pst(Color c, PieceType pt, Square s) const;
-  Value eg_pst(Color c, PieceType pt, Square s) const;
+  template<GamePhase> Value compute_value() const;
-  Value compute_mg_value() const;
-  Value compute_eg_value() const;
   Value compute_non_pawn_material(Color c) const;
 
-  // Bitboards
-  Bitboard byColorBB[2], byTypeBB[8];
-  Bitboard checkersBB;
-
   // Board
   Piece board[64];
 
+  // Bitboards
+  Bitboard byTypeBB[8], byColorBB[2];
+
   // Piece counts
   int pieceCount[2][8]; // [color][pieceType]
 
   // Piece lists
   Square pieceList[2][8][16]; // [color][pieceType][index]
-  int index[64];
+  int index[64]; // [square]
 
   // Other info
   Color sideToMove;
-  int castleRights;
+  int gamePly;
+  Key history[MaxGameLength];
   File initialKFile, initialKRFile, initialQRFile;
-  Square epSquare;
+  StateInfo startState;
-  Square kingSquare[2];
+  StateInfo* st;
-  Move lastMove;
-  Key key, pawnKey, materialKey, history[MaxGameLength];
-  int rule50, gamePly;
-  Value mgValue, egValue;
-  Value npMaterial[2];
 
   // Static variables
   static int castleRightsMask[64];
@@ -367,27 +341,27 @@ inline Piece Position::piece_on(Square s) const {
 }
 
 inline Color Position::color_of_piece_on(Square s) const {
-  return color_of_piece(this->piece_on(s));
+  return color_of_piece(piece_on(s));
 }
 
 inline PieceType Position::type_of_piece_on(Square s) const {
-  return type_of_piece(this->piece_on(s));
+  return type_of_piece(piece_on(s));
 }
 
 inline bool Position::square_is_empty(Square s) const {
-  return this->piece_on(s) == EMPTY;
+  return piece_on(s) == EMPTY;
 }
 
 inline bool Position::square_is_occupied(Square s) const {
-  return !this->square_is_empty(s);
+  return !square_is_empty(s);
 }
 
 inline Value Position::midgame_value_of_piece_on(Square s) const {
-  return piece_value_midgame(this->piece_on(s));
+  return piece_value_midgame(piece_on(s));
 }
 
 inline Value Position::endgame_value_of_piece_on(Square s) const {
-  return piece_value_endgame(this->piece_on(s));
+  return piece_value_endgame(piece_on(s));
 }
 
 inline Color Position::side_to_move() const {
@@ -399,156 +373,55 @@ inline Bitboard Position::occupied_squares() const {
 }
 
 inline Bitboard Position::empty_squares() const {
-  return ~(this->occupied_squares());
+  return ~(occupied_squares());
 }
 
 inline Bitboard Position::pieces_of_color(Color c) const {
   return byColorBB[c];
 }
 
-inline Bitboard Position::pieces_of_type(PieceType pt) const {
+inline Bitboard Position::pieces(PieceType pt) const {
   return byTypeBB[pt];
 }
 
-inline Bitboard Position::pieces_of_color_and_type(Color c, PieceType pt)
+inline Bitboard Position::pieces(PieceType pt, Color c) const {
-  const {
+  return byTypeBB[pt] & byColorBB[c];
-  return this->pieces_of_color(c) & this->pieces_of_type(pt);
 }
 
-inline Bitboard Position::pawns() const {
+inline Bitboard Position::pieces(PieceType pt1, PieceType pt2) const {
-  return this->pieces_of_type(PAWN);
+  return byTypeBB[pt1] | byTypeBB[pt2];
 }
 
-inline Bitboard Position::knights() const {
+inline Bitboard Position::pieces(PieceType pt1, PieceType pt2, Color c) const {
-  return this->pieces_of_type(KNIGHT);
+  return (byTypeBB[pt1] | byTypeBB[pt2]) & byColorBB[c];
-}
-
-inline Bitboard Position::bishops() const {
-  return this->pieces_of_type(BISHOP);
-}
-
-inline Bitboard Position::rooks() const {
-  return this->pieces_of_type(ROOK);
-}
-
-inline Bitboard Position::queens() const {
-  return this->pieces_of_type(QUEEN);
-}
-
-inline Bitboard Position::kings() const {
-  return this->pieces_of_type(KING);
-}
-
-inline Bitboard Position::rooks_and_queens() const {
-  return this->rooks() | this->queens();
-}
-
-inline Bitboard Position::bishops_and_queens() const {
-  return this->bishops() | this->queens();
-}
-
-inline Bitboard Position::sliders() const {
-  return this->bishops() | this->queens() | this->rooks();
-}
-
-inline Bitboard Position::pawns(Color c) const {
-  return this->pieces_of_color_and_type(c, PAWN);
-}
-
-inline Bitboard Position::knights(Color c) const {
-  return this->pieces_of_color_and_type(c, KNIGHT);
-}
-
-inline Bitboard Position::bishops(Color c) const {
-  return this->pieces_of_color_and_type(c, BISHOP);
-}
-
-inline Bitboard Position::rooks(Color c) const {
-  return this->pieces_of_color_and_type(c, ROOK);
-}
-
-inline Bitboard Position::queens(Color c) const {
-  return this->pieces_of_color_and_type(c, QUEEN);
-}
-
-inline Bitboard Position::kings(Color c) const {
-  return this->pieces_of_color_and_type(c, KING);
-}
-
-inline Bitboard Position::rooks_and_queens(Color c) const {
-  return this->rooks_and_queens() & this->pieces_of_color(c);
-}
-
-inline Bitboard Position::bishops_and_queens(Color c) const {
-  return this->bishops_and_queens() & this->pieces_of_color(c);
-}
-
-inline Bitboard Position::sliders_of_color(Color c) const {
-  return this->sliders() & this->pieces_of_color(c);
 }
 
 inline int Position::piece_count(Color c, PieceType pt) const {
   return pieceCount[c][pt];
 }
 
-inline int Position::pawn_count(Color c) const {
-  return this->piece_count(c, PAWN);
-}
-
-inline int Position::knight_count(Color c) const {
-  return this->piece_count(c, KNIGHT);
-}
-
-inline int Position::bishop_count(Color c) const {
-  return this->piece_count(c, BISHOP);
-}
-
-inline int Position::rook_count(Color c) const {
-  return this->piece_count(c, ROOK);
-}
-
-inline int Position::queen_count(Color c) const {
-  return this->piece_count(c, QUEEN);
-}
-
 inline Square Position::piece_list(Color c, PieceType pt, int index) const {
   return pieceList[c][pt][index];
 }
 
-inline Square Position::pawn_list(Color c, int index) const {
+inline const Square* Position::piece_list_begin(Color c, PieceType pt) const {
-  return this->piece_list(c, PAWN, index);
+  return pieceList[c][pt];
-}
-
-inline Square Position::knight_list(Color c, int index) const {
-  return this->piece_list(c, KNIGHT, index);
-}
-
-inline Square Position::bishop_list(Color c, int index) const {
-  return this->piece_list(c, BISHOP, index);
-}
-
-inline Square Position::rook_list(Color c, int index) const {
-  return this->piece_list(c, ROOK, index);
-}
-
-inline Square Position::queen_list(Color c, int index) const {
-  return this->piece_list(c, QUEEN, index);
 }
 
 inline Square Position::ep_square() const {
-  return epSquare;
+  return st->epSquare;
 }
 
 inline Square Position::king_square(Color c) const {
-  return kingSquare[c];
+  return pieceList[c][KING][0];
 }
 
 inline bool Position::can_castle_kingside(Color side) const {
-  return castleRights & (1+int(side));
+  return st->castleRights & (1+int(side));
 }
 
 inline bool Position::can_castle_queenside(Color side) const {
-  return castleRights & (4+4*int(side));
+  return st->castleRights & (4+4*int(side));
 }
 
 inline bool Position::can_castle(Color side) const {
@@ -563,140 +436,102 @@ inline Square Position::initial_qr_square(Color c) const {
   return relative_square(c, make_square(initialQRFile, RANK_1));
 }
 
-inline Bitboard Position::pawn_attacks(Color c, Square s) const {
+template<>
-  return StepAttackBB[pawn_of_color(c)][s];
+inline Bitboard Position::attacks_from<PAWN>(Square s, Color c) const {
+  return StepAttackBB[piece_of_color_and_type(c, PAWN)][s];
 }
 
-inline Bitboard Position::white_pawn_attacks(Square s) const {
+template<PieceType Piece> // Knight and King and white pawns
-  return this->pawn_attacks(WHITE, s);
+inline Bitboard Position::attacks_from(Square s) const {
+  return StepAttackBB[Piece][s];
 }
 
-inline Bitboard Position::black_pawn_attacks(Square s) const {
+template<>
-  return this->pawn_attacks(BLACK, s);
+inline Bitboard Position::attacks_from<BISHOP>(Square s) const {
+  return bishop_attacks_bb(s, occupied_squares());
 }
 
-inline Bitboard Position::knight_attacks(Square s) const {
+template<>
-  return StepAttackBB[KNIGHT][s];
+inline Bitboard Position::attacks_from<ROOK>(Square s) const {
+  return rook_attacks_bb(s, occupied_squares());
 }
 
-inline Bitboard Position::rook_attacks(Square s) const {
+template<>
-  return rook_attacks_bb(s, this->occupied_squares());
+inline Bitboard Position::attacks_from<QUEEN>(Square s) const {
-}
+  return attacks_from<ROOK>(s) | attacks_from<BISHOP>(s);
-
-inline Bitboard Position::bishop_attacks(Square s) const {
-  return bishop_attacks_bb(s, this->occupied_squares());
-}
-
-inline Bitboard Position::queen_attacks(Square s) const {
-  return this->rook_attacks(s) | this->bishop_attacks(s);
-}
-
-inline Bitboard Position::king_attacks(Square s) const {
-  return StepAttackBB[KING][s];
 }
 
 inline Bitboard Position::checkers() const {
-  return checkersBB;
+  return st->checkersBB;
 }
 
 inline bool Position::is_check() const {
-  return this->checkers() != EmptyBoardBB;
+  return st->checkersBB != EmptyBoardBB;
-}
-
-inline bool Position::white_pawn_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->white_pawn_attacks(f), t);
-}
-
-inline bool Position::black_pawn_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->black_pawn_attacks(f), t);
-}
-
-inline bool Position::knight_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->knight_attacks(f), t);
-}
-
-inline bool Position::bishop_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->bishop_attacks(f), t);
-}
-
-inline bool Position::rook_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->rook_attacks(f), t);
-}
-
-inline bool Position::queen_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->queen_attacks(f), t);
-}
-
-inline bool Position::king_attacks_square(Square f, Square t) const {
-  return bit_is_set(this->king_attacks(f), t);
 }
 
 inline bool Position::pawn_is_passed(Color c, Square s) const {
-  return !(this->pawns(opposite_color(c)) & passed_pawn_mask(c, s));
+  return !(pieces(PAWN, opposite_color(c)) & passed_pawn_mask(c, s));
 }
 
-inline bool Position::pawn_is_isolated(Color c, Square s) const {
+inline bool Position::pawn_is_passed(Bitboard theirPawns, Color c, Square s) {
-  return !(this->pawns(c) & neighboring_files_bb(s));
+  return !(theirPawns & passed_pawn_mask(c, s));
 }
 
-inline bool Position::pawn_is_doubled(Color c, Square s) const {
+inline bool Position::pawn_is_isolated(Bitboard ourPawns, Square s) {
-  return this->pawns(c) & squares_behind(c, s);
+  return !(ourPawns & neighboring_files_bb(s));
 }
 
-inline bool Position::file_is_open(File f) const {
+inline bool Position::pawn_is_doubled(Bitboard ourPawns, Color c, Square s) {
-  return !(this->pawns() & file_bb(f));
+  return ourPawns & squares_behind(c, s);
-}
-
-inline bool Position::file_is_half_open(Color c, File f) const {
-  return !(this->pawns(c) & file_bb(f));
 }
 
 inline bool Position::square_is_weak(Square s, Color c) const {
-  return !(this->pawns(c) & outpost_mask(opposite_color(c), s));
+  return !(pieces(PAWN, c) & outpost_mask(opposite_color(c), s));
 }
 
 inline Key Position::get_key() const {
-  return key;
+  return st->key;
 }
 
 inline Key Position::get_pawn_key() const {
-  return pawnKey;
+  return st->pawnKey;
 }
 
 inline Key Position::get_material_key() const {
-  return materialKey;
+  return st->materialKey;
 }
 
-inline Value Position::mg_pst(Color c, PieceType pt, Square s) const {
+template<Position::GamePhase Ph>
-  return MgPieceSquareTable[piece_of_color_and_type(c, pt)][s];
+inline Value Position::pst(Color c, PieceType pt, Square s) const {
+  return (Ph == MidGame ? MgPieceSquareTable[piece_of_color_and_type(c, pt)][s]
+                        : EgPieceSquareTable[piece_of_color_and_type(c, pt)][s]);
 }
 
-inline Value Position::eg_pst(Color c, PieceType pt, Square s) const {
+template<Position::GamePhase Ph>
-  return EgPieceSquareTable[piece_of_color_and_type(c, pt)][s];
+inline Value Position::pst_delta(Piece piece, Square from, Square to) const {
+  return (Ph == MidGame ? MgPieceSquareTable[piece][to] - MgPieceSquareTable[piece][from]
+                        : EgPieceSquareTable[piece][to] - EgPieceSquareTable[piece][from]);
 }
 
 inline Value Position::mg_value() const {
-  return mgValue;
+  return st->mgValue;
 }
 
 inline Value Position::eg_value() const {
-  return egValue;
+  return st->egValue;
 }
 
 inline Value Position::non_pawn_material(Color c) const {
-  return npMaterial[c];
+  return st->npMaterial[c];
 }
 
 inline Phase Position::game_phase() const {
 
-  // The purpose of the Value(325) terms below is to make sure the difference
+  // Values modified by Joona Kiiski
-  // between MidgameLimit and EndgameLimit is a power of 2, which should make
+  static const Value MidgameLimit = Value(15581);
-  // the division at the end of the function a bit faster.
+  static const Value EndgameLimit = Value(3998);
 
-  static const Value MidgameLimit =
+  Value npm = non_pawn_material(WHITE) + non_pawn_material(BLACK);
-    2*QueenValueMidgame+2*RookValueMidgame+6*BishopValueMidgame+Value(325);
-  static const Value EndgameLimit = 4*RookValueMidgame-Value(325);
-  Value npm = this->non_pawn_material(WHITE) + this->non_pawn_material(BLACK);
 
   if (npm >= MidgameLimit)
       return PHASE_MIDGAME;
@@ -706,41 +541,35 @@ inline Phase Position::game_phase() const {
       return Phase(((npm - EndgameLimit) * 128) / (MidgameLimit - EndgameLimit));
 }
 
-inline bool Position::move_is_pawn_push_to_7th(Move m) const {
-  Color c = this->side_to_move();
-  return 
-    this->piece_on(move_from(m)) == pawn_of_color(c) &&
-    pawn_rank(c, move_to(m)) == RANK_7;
-}
-
 inline bool Position::move_is_passed_pawn_push(Move m) const {
-  Color c = this->side_to_move();
-  return 
-    this->piece_on(move_from(m)) == pawn_of_color(c) &&
-    this->pawn_is_passed(c, move_to(m));
-}
 
-inline bool Position::move_was_passed_pawn_push(Move m) const {
+  Color c = side_to_move();
-  Color c = opposite_color(this->side_to_move());
+  return   piece_on(move_from(m)) == piece_of_color_and_type(c, PAWN)
-  return 
+        && pawn_is_passed(c, move_to(m));
-    this->piece_on(move_to(m)) == pawn_of_color(c) &&
-    this->pawn_is_passed(c, move_to(m));
 }
 
 inline int Position::rule_50_counter() const {
-  return rule50;
+
+  return st->rule50;
 }
 
 inline bool Position::opposite_colored_bishops() const {
-  return
+
-    this->bishop_count(WHITE) == 1 && this->bishop_count(BLACK) == 1 &&
+  return   piece_count(WHITE, BISHOP) == 1
-    square_color(this->bishop_list(WHITE, 0)) !=
+        && piece_count(BLACK, BISHOP) == 1
-    square_color(this->bishop_list(BLACK, 0));
+        && square_color(piece_list(WHITE, BISHOP, 0)) != square_color(piece_list(BLACK, BISHOP, 0));
 }
 
 inline bool Position::has_pawn_on_7th(Color c) const {
-  return this->pawns(c) & relative_rank_bb(c, RANK_7);
+
+  return pieces(PAWN, c) & relative_rank_bb(c, RANK_7);
 }
 
+inline bool Position::move_is_capture(Move m) const {
+
+  // Move must not be MOVE_NONE !
+
+  return (!square_is_empty(move_to(m)) && !move_is_castle(m)) || move_is_ep(m);
+}
 
 #endif // !defined(POSITION_H_INCLUDED)

src/psqtab.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -24,139 +25,162 @@
 //// Includes
 ////
 
-#include "position.h"
+#include "value.h"
 
 
 ////
-//// Variables
+//// Constants modified by Joona Kiiski
 ////
 
+static const Value MP = PawnValueMidgame;
+static const Value MK = KnightValueMidgame;
+static const Value MB = BishopValueMidgame;
+static const Value MR = RookValueMidgame;
+static const Value MQ = QueenValueMidgame;
+
 static const int MgPST[][64] = {
   { },
   {// Pawn
+   // A      B      C     D      E      F      G     H
         0,    0,     0,     0,     0,     0,    0,     0,
-    166, 192, 204, 216, 216, 204, 192, 166,
+    MP-28, MP-6, MP+ 4, MP+14, MP+14, MP+ 4, MP-6, MP-28,
-    166, 192, 210, 242, 242, 210, 192, 166, 
+    MP-28, MP-6, MP+ 9, MP+36, MP+36, MP+ 9, MP-6, MP-28,
-    166, 192, 220, 268, 268, 220, 192, 166, 
+    MP-28, MP-6, MP+17, MP+58, MP+58, MP+17, MP-6, MP-28,
-    166, 192, 220, 242, 242, 220, 192, 166, 
+    MP-28, MP-6, MP+17, MP+36, MP+36, MP+17, MP-6, MP-28,
-    166, 192, 210, 216, 216, 210, 192, 166, 
+    MP-28, MP-6, MP+ 9, MP+14, MP+14, MP+ 9, MP-6, MP-28,
-    166, 192, 204, 216, 216, 204, 192, 166, 
+    MP-28, MP-6, MP+ 4, MP+14, MP+14, MP+ 4, MP-6, MP-28,
         0,    0,     0,     0,     0,     0,    0,     0
   },
   {// Knight
-    704, 730, 756, 768, 768, 756, 730, 704, 
+   //  A      B       C      D      E      F      G       H
-    743, 768, 794, 807, 807, 794, 768, 743, 
+    MK-135, MK-107, MK-80, MK-67, MK-67, MK-80, MK-107, MK-135,
-    781, 807, 832, 844, 844, 832, 807, 781, 
+    MK- 93, MK- 67, MK-39, MK-25, MK-25, MK-39, MK- 67, MK- 93,
-    807, 832, 857, 870, 870, 857, 832, 807, 
+    MK- 53, MK- 25, MK+ 1, MK+13, MK+13, MK+ 1, MK- 25, MK- 53,
-    820, 844, 870, 883, 883, 870, 844, 820, 
+    MK- 25, MK+  1, MK+27, MK+41, MK+41, MK+27, MK+  1, MK- 25,
-    820, 844, 870, 883, 883, 870, 844, 820, 
+    MK- 11, MK+ 13, MK+41, MK+55, MK+55, MK+41, MK+ 13, MK- 11,
-    781, 807, 832, 844, 844, 832, 807, 781, 
+    MK- 11, MK+ 13, MK+41, MK+55, MK+55, MK+41, MK+ 13, MK- 11,
-    650, 768, 794, 807, 807, 794, 768, 650
+    MK- 53, MK- 25, MK+ 1, MK+13, MK+13, MK+ 1, MK- 25, MK- 53,
+    MK-193, MK- 67, MK-39, MK-25, MK-25, MK-39, MK- 67, MK-193
   },
   {// Bishop
-    786, 786, 792, 797, 797, 792, 786, 786, 
+   // A      B      C      D      E      F      G      H
-    812, 832, 827, 832, 832, 827, 832, 812, 
+    MB-40, MB-40, MB-35, MB-30, MB-30, MB-35, MB-40, MB-40,
-    817, 827, 842, 837, 837, 842, 827, 817, 
+    MB-17, MB+ 0, MB- 4, MB+ 0, MB+ 0, MB- 4, MB+ 0, MB-17,
-    822, 832, 837, 852, 852, 837, 832, 822, 
+    MB-13, MB- 4, MB+ 8, MB+ 4, MB+ 4, MB+ 8, MB- 4, MB-13,
-    822, 832, 837, 852, 852, 837, 832, 822, 
+    MB- 8, MB+ 0, MB+ 4, MB+17, MB+17, MB+ 4, MB+ 0, MB- 8,
-    817, 827, 842, 837, 837, 842, 827, 817, 
+    MB- 8, MB+ 0, MB+ 4, MB+17, MB+17, MB+ 4, MB+ 0, MB- 8,
-    812, 832, 827, 832, 832, 827, 832, 812, 
+    MB-13, MB- 4, MB+ 8, MB+ 4, MB+ 4, MB+ 8, MB- 4, MB-13,
-    812, 812, 817, 822, 822, 817, 812, 812
+    MB-17, MB+ 0, MB- 4, MB+ 0, MB+ 0, MB- 4, MB+ 0, MB-17,
+    MB-17, MB-17, MB-13, MB- 8, MB- 8, MB-13, MB-17, MB-17
   },
   {// Rook
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
+   // A      B     C     D     E     F     G     H
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
+    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
+    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
+    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
+    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
+    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267, 
+    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
-    1267, 1275, 1282, 1289, 1289, 1282, 1275, 1267
+    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12,
+    MR-12, MR-7, MR-2, MR+2, MR+2, MR-2, MR-7, MR-12
   },
   {// Queen
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
+   // A     B     C     D     E     F     G     H
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
+    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
+    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
+    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
+    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
+    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 
+    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
-    2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560
+    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8,
+    MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8, MQ+8
   },
   {// King
-    302, 328, 276, 225, 225, 276, 328, 302, 
+   //A    B    C    D    E    F    G    H
-    276, 302, 251, 200, 200, 251, 302, 276, 
+    287, 311, 262, 214, 214, 262, 311, 287,
-    225, 251, 200, 149, 149, 200, 251, 225, 
+    262, 287, 238, 190, 190, 238, 287, 262,
-    200, 225, 175, 124, 124, 175, 225, 200, 
+    214, 238, 190, 142, 142, 190, 238, 214,
-    175, 200, 149, 98, 98, 149, 200, 175, 
+    190, 214, 167, 119, 119, 167, 214, 190,
-    149, 175, 124, 72, 72, 124, 175, 149, 
+    167, 190, 142,  94,  94, 142, 190, 167,
-    124, 149, 98, 47, 47, 98, 149, 124, 
+    142, 167, 119,  69,  69, 119, 167, 142,
-    98, 124, 72, 21, 21, 72, 124, 98, 
+    119, 142,  94,  46,  46,  94, 142, 119,
+     94, 119,  69,  21,  21,  69, 119,  94
   }
 };
 
+static const Value EP = PawnValueEndgame;
+static const Value EK = KnightValueEndgame;
+static const Value EB = BishopValueEndgame;
+static const Value ER = RookValueEndgame;
+static const Value EQ = QueenValueEndgame;
 
 static const int EgPST[][64] = {
   { },
   {// Pawn
+   // A     B     C     D     E     F     G     H
        0,    0,    0,    0,    0,    0,    0,    0,
-    256, 256, 256, 256, 256, 256, 256, 256, 
+    EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8,
-    256, 256, 256, 256, 256, 256, 256, 256, 
+    EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8,
-    256, 256, 256, 256, 256, 256, 256, 256, 
+    EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8,
-    256, 256, 256, 256, 256, 256, 256, 256, 
+    EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8,
-    256, 256, 256, 256, 256, 256, 256, 256, 
+    EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8,
-    256, 256, 256, 256, 256, 256, 256, 256, 
+    EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8, EP-8,
        0,    0,    0,    0,    0,    0,    0,    0
   },
   {// Knight
-    730, 756, 781, 794, 794, 781, 756, 730, 
+   // A       B      C      D      E      F      G      H
-    756, 781, 807, 820, 820, 807, 781, 756, 
+    EK-104, EK-79, EK-55, EK-42, EK-42, EK-55, EK-79, EK-104,
-    781, 807, 832, 844, 844, 832, 807, 781, 
+    EK- 79, EK-55, EK-30, EK-17, EK-17, EK-30, EK-55, EK- 79,
-    794, 820, 844, 857, 857, 844, 820, 794, 
+    EK- 55, EK-30, EK- 6, EK+ 5, EK+ 5, EK- 6, EK-30, EK- 55,
-    794, 820, 844, 857, 857, 844, 820, 794, 
+    EK- 42, EK-17, EK+ 5, EK+18, EK+18, EK+ 5, EK-17, EK- 42,
-    781, 807, 832, 844, 844, 832, 807, 781, 
+    EK- 42, EK-17, EK+ 5, EK+18, EK+18, EK+ 5, EK-17, EK- 42,
-    756, 781, 807, 820, 820, 807, 781, 756, 
+    EK- 55, EK-30, EK- 6, EK+ 5, EK+ 5, EK- 6, EK-30, EK- 55,
-    730, 756, 781, 794, 794, 781, 756, 730
+    EK- 79, EK-55, EK-30, EK-17, EK-17, EK-30, EK-55, EK- 79,
+    EK-104, EK-79, EK-55, EK-42, EK-42, EK-55, EK-79, EK-104
   },
   {// Bishop
-    786, 802, 809, 817, 817, 809, 802, 786, 
+   // A      B      C      D      E      F      G      H
-    802, 817, 825, 832, 832, 825, 817, 802, 
+    EB-59, EB-42, EB-35, EB-26, EB-26, EB-35, EB-42, EB-59,
-    809, 825, 832, 839, 839, 832, 825, 809, 
+    EB-42, EB-26, EB-18, EB-11, EB-11, EB-18, EB-26, EB-42,
-    817, 832, 839, 847, 847, 839, 832, 817, 
+    EB-35, EB-18, EB-11, EB- 4, EB- 4, EB-11, EB-18, EB-35,
-    817, 832, 839, 847, 847, 839, 832, 817, 
+    EB-26, EB-11, EB- 4, EB+ 4, EB+ 4, EB- 4, EB-11, EB-26,
-    809, 825, 832, 839, 839, 832, 825, 809, 
+    EB-26, EB-11, EB- 4, EB+ 4, EB+ 4, EB- 4, EB-11, EB-26,
-    802, 817, 825, 832, 832, 825, 817, 802, 
+    EB-35, EB-18, EB-11, EB- 4, EB- 4, EB-11, EB-18, EB-35,
-    786, 802, 809, 817, 817, 809, 802, 786
+    EB-42, EB-26, EB-18, EB-11, EB-11, EB-18, EB-26, EB-42,
+    EB-59, EB-42, EB-35, EB-26, EB-26, EB-35, EB-42, EB-59
   },
   {// Rook
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
+   // A     B     C     D     E     F     G     H
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282, 
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
-    1282, 1282, 1282, 1282, 1282, 1282, 1282, 1282
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3,
+    ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3, ER+3
   },
   {// Queen
-    2499, 2520, 2530, 2540, 2540, 2530, 2520, 2499, 
+   // A      B      C      D      E      F      G      H
-    2520, 2540, 2550, 2560, 2560, 2550, 2540, 2520, 
+    EQ-80, EQ-54, EQ-42, EQ-30, EQ-30, EQ-42, EQ-54, EQ-80,
-    2530, 2550, 2560, 2570, 2570, 2560, 2550, 2530, 
+    EQ-54, EQ-30, EQ-18, EQ- 6, EQ- 6, EQ-18, EQ-30, EQ-54,
-    2540, 2560, 2570, 2580, 2580, 2570, 2560, 2540, 
+    EQ-42, EQ-18, EQ- 6, EQ+ 6, EQ+ 6, EQ- 6, EQ-18, EQ-42,
-    2540, 2560, 2570, 2580, 2580, 2570, 2560, 2540, 
+    EQ-30, EQ- 6, EQ+ 6, EQ+18, EQ+18, EQ+ 6, EQ- 6, EQ-30,
-    2530, 2550, 2560, 2570, 2570, 2560, 2550, 2530, 
+    EQ-30, EQ- 6, EQ+ 6, EQ+18, EQ+18, EQ+ 6, EQ- 6, EQ-30,
-    2520, 2540, 2550, 2560, 2560, 2550, 2540, 2520, 
+    EQ-42, EQ-18, EQ- 6, EQ+ 6, EQ+ 6, EQ- 6, EQ-18, EQ-42,
-    2499, 2520, 2530, 2540, 2540, 2530, 2520, 2499
+    EQ-54, EQ-30, EQ-18, EQ- 6, EQ- 6, EQ-18, EQ-30, EQ-54,
+    EQ-80, EQ-54, EQ-42, EQ-30, EQ-30, EQ-42, EQ-54, EQ-80
   },
   {// King
-    16, 78, 108, 139, 139, 108, 78, 16, 
+   //A    B    C    D    E    F    G    H
-    78, 139, 170, 200, 200, 170, 139, 78, 
+     18,  77, 105, 135, 135, 105,  77,  18,
-    108, 170, 200, 230, 230, 200, 170, 108, 
+     77, 135, 165, 193, 193, 165, 135,  77,
-    139, 200, 230, 261, 261, 230, 200, 139, 
+    105, 165, 193, 222, 222, 193, 165, 105,
-    139, 200, 230, 261, 261, 230, 200, 139, 
+    135, 193, 222, 251, 251, 222, 193, 135,
-    108, 170, 200, 230, 230, 200, 170, 108, 
+    135, 193, 222, 251, 251, 222, 193, 135,
-    78, 139, 170, 200, 200, 170, 139, 78, 
+    105, 165, 193, 222, 222, 193, 165, 105,
-    16, 78, 108, 139, 139, 108, 78, 16
+     77, 135, 165, 193, 193, 165, 135,  77,
+     18,  77, 105, 135, 135, 105,  77,  18
   }
 };
 

src/san.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -27,9 +28,11 @@
 #include <string>
 #include <sstream>
 
+#include "history.h"
 #include "movepick.h"
 #include "san.h"
 
+using std::string;
 
 ////
 //// Local definitions
@@ -37,8 +40,6 @@
 
 namespace {
 
-  /// Types
-
   enum Ambiguity {
     AMBIGUITY_NONE,
     AMBIGUITY_FILE,
@@ -46,12 +47,11 @@ namespace {
     AMBIGUITY_BOTH
   };
 
+  const History H; // used as dummy argument for MovePicker c'tor
 
-  /// Functions
+  Ambiguity move_ambiguity(const Position& pos, Move m);
-  
+  const string time_string(int milliseconds);
-  Ambiguity move_ambiguity(Position &pos, Move m);
+  const string score_string(Value v);
-  const std::string time_string(int milliseconds);
-  const std::string score_string(Value v);
 }
 
 
@@ -63,85 +63,72 @@ namespace {
 /// that the move is a legal move from the position. The return value is
 /// a string containing the move in short algebraic notation.
 
-const std::string move_to_san(Position &pos, Move m) {
+const string move_to_san(const Position& pos, Move m) {
-  std::string str;
 
   assert(pos.is_ok());
   assert(move_is_ok(m));
 
-  if(m == MOVE_NONE) {
-    str = "(none)";
-    return str;
-  }
-  else if(m == MOVE_NULL) {
-    str = "(null)";
-    return str;
-  }
-  else if(move_is_long_castle(m))
-    str = "O-O-O";
-  else if(move_is_short_castle(m))
-    str = "O-O";
-  else {
   Square from, to;
-    Piece pc;
+  PieceType pt;
 
   from = move_from(m);
   to = move_to(m);
-    pc = pos.piece_on(move_from(m));
+  pt = type_of_piece(pos.piece_on(move_from(m)));
 
-    str = "";
+  string san = "";
-
-    if(type_of_piece(pc) == PAWN) {
-      if(pos.move_is_capture(m))
-        str += file_to_char(square_file(move_from(m)));
-    }
-    else {
-      str += piece_type_to_char(type_of_piece(pc), true);
-
-      Ambiguity amb = move_ambiguity(pos, m);
-      switch(amb) {
 
+  if (m == MOVE_NONE)
+      return "(none)";
+  else if (m == MOVE_NULL)
+      return "(null)";
+  else if (move_is_long_castle(m) || (int(to - from) == -2 && pt == KING))
+      san = "O-O-O";
+  else if (move_is_short_castle(m) || (int(to - from) == 2 && pt == KING))
+      san = "O-O";
+  else
+  {
+      if (pt != PAWN)
+      {
+          san += piece_type_to_char(pt, true);
+          switch (move_ambiguity(pos, m)) {
           case AMBIGUITY_NONE:
             break;
-
           case AMBIGUITY_FILE:
-        str += file_to_char(square_file(from));
+            san += file_to_char(square_file(from));
             break;
-
           case AMBIGUITY_RANK:
-        str += rank_to_char(square_rank(from));
+            san += rank_to_char(square_rank(from));
             break;
-
           case AMBIGUITY_BOTH:
-        str += square_to_string(from);
+            san += square_to_string(from);
             break;
-
           default:
             assert(false);
           }
       }
-
       if (pos.move_is_capture(m))
-      str += "x";
+      {
-
+          if (pt == PAWN)
-    str += square_to_string(move_to(m));
+              san += file_to_char(square_file(move_from(m)));
-
+          san += "x";
-    if(move_promotion(m)) {
+      }
-      str += "=";
+      san += square_to_string(move_to(m));
-      str += piece_type_to_char(move_promotion(m), true);
+      if (move_is_promotion(m))
+      {
+          san += '=';
+          san += piece_type_to_char(move_promotion_piece(m), true);
       }
   }
-
   // Is the move check?  We don't use pos.move_is_check(m) here, because
   // Position::move_is_check doesn't detect all checks (not castling moves,
   // promotions and en passant captures).
-  UndoInfo u;
+  StateInfo st;
-  pos.do_move(m, u);
+  Position p(pos);
-  if(pos.is_check())
+  p.do_move(m, st);
-    str += pos.is_mate()? "#" : "+";
+  if (p.is_check())
-  pos.undo_move(m, u);
+      san += p.is_mate()? "#" : "+";
 
-  return str;
+  return san;
 }
 
 
@@ -150,116 +137,150 @@ const std::string move_to_san(Position &pos, Move m) {
 /// the move is returned.  On failure (i.e. if the string is unparsable, or
 /// if the move is illegal or ambiguous), MOVE_NONE is returned.
 
-Move move_from_san(Position &pos, const std::string &movestr) {
+Move move_from_san(const Position& pos, const string& movestr) {
+
   assert(pos.is_ok());
 
-  MovePicker mp = MovePicker(pos, false, MOVE_NONE, MOVE_NONE, MOVE_NONE,
+  MovePicker mp = MovePicker(pos, MOVE_NONE, OnePly, H);
-                             MOVE_NONE, OnePly);
 
   // Castling moves
-  if(movestr == "O-O-O") {
+  if (movestr == "O-O-O" || movestr == "O-O-O+")
+  {
       Move m;
       while ((m = mp.get_next_move()) != MOVE_NONE)
-      if(move_is_long_castle(m) && pos.move_is_legal(m))
+          if (move_is_long_castle(m) && pos.pl_move_is_legal(m))
               return m;
+
       return MOVE_NONE;
   }
-  else if(movestr == "O-O") {
+  else if (movestr == "O-O" || movestr == "O-O+")
+  {
       Move m;
       while ((m = mp.get_next_move()) != MOVE_NONE)
-      if(move_is_short_castle(m) && pos.move_is_legal(m))
+          if (move_is_short_castle(m) && pos.pl_move_is_legal(m))
               return m;
+
     return MOVE_NONE;
   }
 
-  // Normal moves
+  // Normal moves. We use a simple FSM to parse the san string.
-  const char *cstr = movestr.c_str();
+  enum { START, TO_FILE, TO_RANK, PROMOTION_OR_CHECK, PROMOTION, CHECK, END };
-  const char *c;
+  static const string pieceLetters = "KQRBN";
-  char *cc;
+  PieceType pt = NO_PIECE_TYPE, promotion = NO_PIECE_TYPE;
-  char str[10];
+  File fromFile = FILE_NONE, toFile = FILE_NONE;
-  int i;
+  Rank fromRank = RANK_NONE, toRank = RANK_NONE;
-
-  // Initialize str[] by making a copy of movestr with the characters
-  // 'x', '=', '+' and '#' removed.  
-  cc = str;
-  for(i=0, c=cstr; i<10 && *c!='\0' && *c!='\n' && *c!=' '; i++, c++)
-    if(!strchr("x=+#", *c)) {
-      *cc = strchr("nrq", *c)? toupper(*c) : *c;
-      cc++;
-    }
-  *cc = '\0';
-
-  int left = 0, right = strlen(str) - 1;
-  PieceType pt = NO_PIECE_TYPE, promotion;
   Square to;
-  File fromFile = FILE_NONE;
+  int state = START;
-  Rank fromRank = RANK_NONE;
 
-  // Promotion?
+  for (size_t i = 0; i < movestr.length(); i++)
-  if(strchr("BNRQ", str[right])) {
+  {
-    promotion = piece_type_from_char(str[right]);
+      char type, c = movestr[i];
-    right--;
+      if (pieceLetters.find(c) != string::npos)
-  }
+          type = 'P';
-  else
+      else if (c >= 'a' && c <= 'h')
-    promotion = NO_PIECE_TYPE;
+          type = 'F';
-
+      else if (c >= '1' && c <= '8')
-  // Find the moving piece:
+          type = 'R';
-  if(left < right) {
+      else
-    if(strchr("BNRQK", str[left])) {
+          type = c;
-      pt = piece_type_from_char(str[left]);
+
-      left++;
+      switch (type) {
+      case 'P':
+          if (state == START)
+          {
+              pt = piece_type_from_char(c);
+              state = TO_FILE;
+          }
+          else if (state == PROMOTION)
+          {
+              promotion = piece_type_from_char(c);
+              state = (i < movestr.length() - 1) ? CHECK : END;
           }
           else
+              return MOVE_NONE;
+          break;
+      case 'F':
+          if (state == START)
+          {
               pt = PAWN;
+              fromFile = toFile = file_from_char(c);
+              state = TO_RANK;
           }
-
+          else if (state == TO_FILE)
-  // Find the to square:
+          {
-  if(left < right) {
+              toFile = file_from_char(c);
-    if(str[right] < '1' || str[right] > '8' ||
+              state = TO_RANK;
-       str[right-1] < 'a' || str[right-1] > 'h')
+          }
-      return MOVE_NONE;
+          else if (state == TO_RANK && toFile != FILE_NONE)
-    to = make_square(file_from_char(str[right-1]), rank_from_char(str[right]));
+          {
-    right -= 2;
+              // Previous file was for disambiguation
+              fromFile = toFile;
+              toFile = file_from_char(c);
           }
           else
               return MOVE_NONE;
-
+          break;
-  // Find the file and/or rank of the from square:
+      case 'R':
-  if(left <= right) {
+          if (state == TO_RANK)
-    if(strchr("abcdefgh", str[left])) {
+          {
-      fromFile = file_from_char(str[left]);
+              toRank = rank_from_char(c);
-      left++;
+              state = (i < movestr.length() - 1) ? PROMOTION_OR_CHECK : END;
+          }
+          else if (state == TO_FILE && fromRank == RANK_NONE)
+          {
+              // It's a disambiguation rank instead of a file
+              fromRank = rank_from_char(c);
+          }
+          else
+              return MOVE_NONE;
+          break;
+      case 'x': case 'X':
+          if (state == TO_RANK)
+          {
+              // Previous file was for disambiguation, or it's a pawn capture
+              fromFile = toFile;
+              state = TO_FILE;
+          }
+          else if (state != TO_FILE)
+              return MOVE_NONE;
+          break;
+      case '=':
+          if (state == PROMOTION_OR_CHECK)
+              state = PROMOTION;
+          else
+              return MOVE_NONE;
+          break;
+      case '+': case '#':
+          if (state == PROMOTION_OR_CHECK || state == CHECK)
+              state = END;
+          else
+              return MOVE_NONE;
+          break;
+      default:
+          return MOVE_NONE;
+          break;
       }
-    if(strchr("12345678", str[left]))
-      fromRank = rank_from_char(str[left]);
   }
 
-  // Look for a matching move:
+  if (state != END)
+      return MOVE_NONE;
+
+  // Look for a matching move
   Move m, move = MOVE_NONE;
+  to = make_square(toFile, toRank);
   int matches = 0;
 
-  while((m = mp.get_next_move()) != MOVE_NONE) {
+  while ((m = mp.get_next_move()) != MOVE_NONE)
-    bool match = true;
+      if (   pos.type_of_piece_on(move_from(m)) == pt
-    if(pos.type_of_piece_on(move_from(m)) != pt)
+          && move_to(m) == to
-      match = false;
+          && move_promotion_piece(m) == promotion
-    else if(move_to(m) != to)
+          && (fromFile == FILE_NONE || fromFile == square_file(move_from(m)))
-      match = false;
+          && (fromRank == RANK_NONE || fromRank == square_rank(move_from(m))))
-    else if(move_promotion(m) != promotion)
+      {
-      match = false;
-    else if(fromFile != FILE_NONE && fromFile != square_file(move_from(m)))
-      match = false;
-    else if(fromRank != RANK_NONE && fromRank != square_rank(move_from(m)))
-      match = false;
-    if(match) {
           move = m;
           matches++;
       }
-  }
+  return (matches == 1 ? move : MOVE_NONE);
-  
-  if(matches == 1)
-    return move;
-  else
-    return MOVE_NONE;
 }
 
 
@@ -270,34 +291,31 @@ Move move_from_san(Position &pos, const std::string &movestr) {
 /// length of 80 characters.  After a line break, 'startColumn' spaces are
 /// inserted at the beginning of the new line.
 
-const std::string line_to_san(const Position &pos, Move line[], int startColumn,
+const string line_to_san(const Position& pos, Move line[], int startColumn, bool breakLines) {
-                              bool breakLines) {
+
-  Position p = Position(pos);
+  StateInfo st;
-  UndoInfo u;
   std::stringstream s;
-  std::string moveStr;
+  string moveStr;
-  int length, maxLength;
+  size_t length = 0;
+  size_t maxLength = 80 - startColumn;
+  Position p(pos);
 
-  length = 0;
+  for (int i = 0; line[i] != MOVE_NONE; i++)
-  maxLength = 80 - startColumn;
+  {
-
-  for(int i = 0; line[i] != MOVE_NONE; i++) {
       moveStr = move_to_san(p, line[i]);
       length += moveStr.length() + 1;
-    if(breakLines && length > maxLength) {
+      if (breakLines && length > maxLength)
-      s << "\n";
+      {
-      for(int j = 0; j < startColumn; j++)
+          s << '\n' << std::setw(startColumn) << ' ';
-        s << " ";
           length = moveStr.length() + 1;
       }
-    s << moveStr << " ";
+      s << moveStr << ' ';
 
       if (line[i] == MOVE_NULL)
-      p.do_null_move(u);
+          p.do_null_move(st);
       else
-      p.do_move(line[i], u);
+          p.do_move(line[i], st);
   }
-
   return s.str();
 }
 
@@ -306,26 +324,26 @@ const std::string line_to_san(const Position &pos, Move line[], int startColumn,
 /// It is used to write search information to the log file (which is created
 /// when the UCI parameter "Use Search Log" is "true").
 
-const std::string pretty_pv(const Position &pos, int time, int depth,
+const string pretty_pv(const Position& pos, int time, int depth,
                        uint64_t nodes, Value score, Move pv[]) {
   std::stringstream s;
 
   // Depth
-  s << std::setw(2) << std::setfill(' ') << depth << "  ";
+  s << std::setw(2) << depth << "  ";
 
   // Score
   s << std::setw(8) << score_string(score);
 
   // Time
-  s << std::setw(8) << std::setfill(' ') << time_string(time) << " ";
+  s << std::setw(8) << time_string(time) << " ";
 
   // Nodes
   if (nodes < 1000000ULL)
-    s << std::setw(8) << std::setfill(' ') << nodes << " ";
+    s << std::setw(8) << nodes << " ";
   else if (nodes < 1000000000ULL)
-    s << std::setw(7) << std::setfill(' ') << nodes/1000ULL << 'k' << " ";
+    s << std::setw(7) << nodes/1000ULL << 'k' << " ";
   else
-    s << std::setw(7) << std::setfill(' ') << nodes/1000000ULL << 'M' << " ";
+    s << std::setw(7) << nodes/1000000ULL << 'M' << " ";
 
   // PV
   s << line_to_san(pos, pv, 30, true);
@@ -336,82 +354,80 @@ const std::string pretty_pv(const Position &pos, int time, int depth,
 
 namespace {
 
-  Ambiguity move_ambiguity(Position &pos, Move m) {
+  Ambiguity move_ambiguity(const Position& pos, Move m) {
-    Square from, to;
-    Piece pc;
 
-    from = move_from(m);
+    Square from = move_from(m);
-    to = move_to(m);
+    Square to = move_to(m);
-    pc = pos.piece_on(from);
+    Piece pc = pos.piece_on(from);
 
     // King moves are never ambiguous, because there is never two kings of
     // the same color.
     if (type_of_piece(pc) == KING)
         return AMBIGUITY_NONE;
 
-    MovePicker mp = MovePicker(pos, false, MOVE_NONE, MOVE_NONE, MOVE_NONE,
+    MovePicker mp = MovePicker(pos, MOVE_NONE, OnePly, H);
-                               MOVE_NONE, OnePly);
     Move mv, moveList[8];
-    int i, j, n;
 
-    n = 0;
+    int n = 0;
     while ((mv = mp.get_next_move()) != MOVE_NONE)
-      if(move_to(mv) == to && pos.piece_on(move_from(mv)) == pc
+        if (move_to(mv) == to && pos.piece_on(move_from(mv)) == pc && pos.pl_move_is_legal(mv))
-         && pos.move_is_legal(mv))
             moveList[n++] = mv;
+
     if (n == 1)
         return AMBIGUITY_NONE;
 
-    j = 0;
+    int f = 0, r = 0;
-    for(i = 0; i < n; i++)
+    for (int i = 0; i < n; i++)
+    {
         if (square_file(move_from(moveList[i])) == square_file(from))
-        j++;
+            f++;
-    if(j == 1)
+
+        if (square_rank(move_from(moveList[i])) == square_rank(from))
+            r++;
+    }
+    if (f == 1)
         return AMBIGUITY_FILE;
 
-    j = 0;
+    if (r == 1)
-    for(i = 0; i < n; i++)
-      if(square_rank(move_from(moveList[i])) == square_rank(from))
-        j++;
-    if(j == 1)
         return AMBIGUITY_RANK;
 
     return AMBIGUITY_BOTH;
   }
 
 
-  const std::string time_string(int milliseconds) {
+  const string time_string(int milliseconds) {
+
     std::stringstream s;
+    s << std::setfill('0');
 
     int hours = milliseconds / (1000*60*60);
-    int minutes = (milliseconds - hours*1000*60*60) / (60*1000);
+    int minutes = (milliseconds - hours*1000*60*60) / (1000*60);
-    int seconds = (milliseconds - hours*1000*60*60 - minutes*60*1000) / 1000;
+    int seconds = (milliseconds - hours*1000*60*60 - minutes*1000*60) / 1000;
 
     if (hours)
         s << hours << ':';
-    s << std::setw(2) << std::setfill('0') << minutes << ':';
-    s << std::setw(2) << std::setfill('0') << seconds;
 
+    s << std::setw(2) << minutes << ':' << std::setw(2) << seconds;
     return s.str();
   }
 
 
-  const std::string score_string(Value v) {
+  const string score_string(Value v) {
+
     std::stringstream s;
 
-    if(abs(v) >= VALUE_MATE - 200) {
+    if (v >= VALUE_MATE - 200)
-      if(v < 0)
+        s << "#" << (VALUE_MATE - v + 1) / 2;
+    else if(v <= -VALUE_MATE + 200)
         s << "-#" << (VALUE_MATE + v) / 2;
     else
-        s << "#" << (VALUE_MATE - v + 1) / 2;
+    {
-    }
-    else {
         float floatScore = float(v) / float(PawnValueMidgame);
         if (v >= 0)
             s << '+';
+
         s << std::setprecision(2) << std::fixed << floatScore;
     }
     return s.str();
   }
-  
 }

src/san.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -35,12 +36,9 @@
 //// Prototypes
 ////
 
-extern const std::string move_to_san(Position &pos, Move m);
+extern const std::string move_to_san(const Position& pos, Move m);
-extern Move move_from_san(Position &pos, const std::string &str);
+extern Move move_from_san(const Position& pos, const std::string& str);
-extern const std::string line_to_san(const Position &pos, Move line[],
+extern const std::string line_to_san(const Position& pos, Move line[], int startColumn, bool breakLines);
-                                     int startColumn, bool breakLines);
+extern const std::string pretty_pv(const Position& pos, int time, int depth, uint64_t nodes, Value score, Move pv[]);
-extern const std::string pretty_pv(const Position &pos, int time, int depth,
-                                   uint64_t nodes, Value score, Move pv[]);
-
 
 #endif // !defined(SAN_H_INCLUDED)

src/scale.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.

src/search.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -24,14 +25,8 @@
 //// Includes
 ////
 
-#include "types.h"
 #include "depth.h"
-#include "history.h"
+#include "move.h"
-#include "lock.h"
-#include "movegen.h"
-#include "position.h"
-#include "tt.h"
-#include "value.h"
 
 
 ////
@@ -40,6 +35,7 @@
 
 const int PLY_MAX = 100;
 const int PLY_MAX_PLUS_2 = 102;
+const int KILLER_MAX = 2;
 
 
 ////
@@ -54,36 +50,25 @@ const int PLY_MAX_PLUS_2 = 102;
 struct SearchStack {
   Move pv[PLY_MAX];
   Move currentMove;
-  Value currentMoveCaptureValue;
+  Move mateKiller;
-  Move mateKiller, killer1, killer2;
   Move threatMove;
+  Move killers[KILLER_MAX];
   Depth reduction;
+
+  void init(int ply);
+  void initKillers();
 };
 
 
-////
-//// Global variables
-////
-
-extern TranspositionTable TT;
-
-extern int ActiveThreads;
-
-extern Lock SMPLock;
-
-// Perhaps better to make H local, and pass as parameter to MovePicker?
-extern History H;  
-
-
 ////
 //// Prototypes
 ////
 
 extern void init_threads();
 extern void stop_threads();
-extern void think(const Position &pos, bool infinite, bool ponder, int time,
+extern bool think(const Position &pos, bool infinite, bool ponder, int side_to_move,
-                  int increment, int movesToGo, int maxDepth, int maxNodes,
+                  int time[], int increment[], int movesToGo, int maxDepth,
-                  int maxTime, Move searchMoves[]);
+                  int maxNodes, int maxTime, Move searchMoves[]);
 extern int64_t nodes_searched();
 
 

src/square.cpp

@@ -1,85 +0,0 @@
-/*
-  Glaurung, a UCI chess playing engine.
-  Copyright (C) 2004-2008 Tord Romstad
-
-  Glaurung 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.
-  
-  Glaurung 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 <cassert>
-#include <cstdio>
-#include <string>
-
-#include "square.h"
-
-
-////
-//// Functions
-////
-
-
-/// Translating files, ranks and squares to/from characters and strings:
-
-File file_from_char(char c) {
-  return File(c - 'a') + FILE_A;
-}
-
-
-char file_to_char(File f) {
-  return char(f - FILE_A) + 'a';
-}
-
-
-Rank rank_from_char(char c) {
-  return Rank(c - '1') + RANK_1;
-}
-
-
-char rank_to_char(Rank r) {
-  return char(r - RANK_1) + '1';
-}
-
-
-Square square_from_string(const std::string &str) {
-  return make_square(file_from_char(str[0]), rank_from_char(str[1]));
-}
-
-
-const std::string square_to_string(Square s) {
-  std::string str;
-  str += file_to_char(square_file(s));
-  str += rank_to_char(square_rank(s));
-  return str;
-}
-
-
-/// file_is_ok(), rank_is_ok() and square_is_ok(), for debugging:
-
-bool file_is_ok(File f) {
-  return f >= FILE_A && f <= FILE_H;
-}
-
-
-bool rank_is_ok(Rank r) {
-  return r >= RANK_1 && r <= RANK_8;
-}
-
-
-bool square_is_ok(Square s) {
-  return file_is_ok(square_file(s)) && rank_is_ok(square_rank(s));
-}

src/square.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -24,6 +25,7 @@
 //// Includes
 ////
 
+#include <cstdlib> // for abs()
 #include <string>
 
 #include "color.h"
@@ -129,7 +131,7 @@ inline Square relative_square(Color c, Square s) {
   return Square(int(s) ^ (int(c) * FlipMask));
 }
 
-inline Rank pawn_rank(Color c, Square s) {
+inline Rank relative_rank(Color c, Square s) {
   return square_rank(relative_square(c, s));
 }
 
@@ -157,21 +159,43 @@ inline int square_distance(Square s1, Square s2) {
   return Max(file_distance(s1, s2), rank_distance(s1, s2));
 }
 
+inline File file_from_char(char c) {
+  return File(c - 'a') + FILE_A;
+}
 
-//// 
+inline char file_to_char(File f) {
-//// Prototypes
+  return char(f - FILE_A + int('a'));
-////
+}
 
-extern File file_from_char(char c);
+inline Rank rank_from_char(char c) {
-extern char file_to_char(File f);
+  return Rank(c - '1') + RANK_1;
-extern Rank rank_from_char(char c);
+}
-extern char rank_to_char(Rank r);
-extern Square square_from_string(const std::string &str);
-extern const std::string square_to_string(Square s);
 
-extern bool file_is_ok(File f);
+inline char rank_to_char(Rank r) {
-extern bool rank_is_ok(Rank r);
+  return char(r - RANK_1 + int('1'));
-extern bool square_is_ok(Square s);
+}
 
+inline Square square_from_string(const std::string& str) {
+  return make_square(file_from_char(str[0]), rank_from_char(str[1]));
+}
+
+inline const std::string square_to_string(Square s) {
+  std::string str;
+  str += file_to_char(square_file(s));
+  str += rank_to_char(square_rank(s));
+  return str;
+}
+
+inline bool file_is_ok(File f) {
+  return f >= FILE_A && f <= FILE_H;
+}
+
+inline bool rank_is_ok(Rank r) {
+  return r >= RANK_1 && r <= RANK_8;
+}
+
+inline bool square_is_ok(Square s) {
+  return file_is_ok(square_file(s)) && rank_is_ok(square_rank(s));
+}
 
 #endif // !defined(SQUARE_H_INCLUDED)

src/thread.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -65,13 +66,14 @@ struct Thread {
   SplitPoint *splitPoint;
   int activeSplitPoints;
   uint64_t nodes;
+  uint64_t betaCutOffs[2];
   bool failHighPly1;
   volatile bool stop;
   volatile bool running;
   volatile bool idle;
   volatile bool workIsWaiting;
   volatile bool printCurrentLine;
-  unsigned char pad[64];
+  unsigned char pad[64]; // set some distance among local data for each thread
 };
 
 

src/timeoday.cpp

@@ -1,28 +0,0 @@
-/*
-   (c) Copyright 1992 Eric Backus
-
-   This software may be used freely so long as this copyright notice is
-   left intact.  There is no warrantee on this software.
- */
-#include <windows.h>
-#include <time.h>
-#include "dos.h"
-
-
-int             gettimeofday(struct timeval * tp, struct timezone * tzp)
-{
-    SYSTEMTIME      systime;
-
-    if (tp) {
-        struct tm       tmrec;
-        time_t          theTime = time(NULL);
-
-
-        tmrec = *localtime(&theTime);
-        tp->tv_sec = mktime(&tmrec);
-        GetLocalTime(&systime); /* system time */
-
-        tp->tv_usec = systime.wMilliseconds * 1000;
-    }
-    return 0;
-}

src/tt.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -23,28 +24,28 @@
 
 #include <cassert>
 #include <cmath>
+#include <cstring>
+#include <xmmintrin.h>
 
+#include "movegen.h"
 #include "tt.h"
 
+// The main transposition table
+TranspositionTable TT;
 
 ////
 //// Functions
 ////
 
-/// Constructor
+TranspositionTable::TranspositionTable() {
 
-TranspositionTable::TranspositionTable(unsigned mbSize) {
+  size = writes = 0;
-  size = 0;
-  generation = 0;
-  writes = 0;
   entries = 0;
-  this->set_size(mbSize);
+  generation = 0;
 }
 
-
-/// Destructor
-
 TranspositionTable::~TranspositionTable() {
+
   delete [] entries;
 }
 
@@ -53,25 +54,28 @@ TranspositionTable::~TranspositionTable() {
 /// measured in megabytes.
 
 void TranspositionTable::set_size(unsigned mbSize) {
-  unsigned newSize;
 
-  assert(mbSize >= 4 && mbSize <= 1024);
+  assert(mbSize >= 4 && mbSize <= 4096);
 
-  for(newSize = 1024; newSize * 4 * (sizeof(TTEntry)) <= (mbSize << 20);
+  unsigned newSize = 1024;
-      newSize *= 2);
-  newSize /= 2;
 
-  if(newSize != size) {
+  // We store a cluster of ClusterSize number of TTEntry for each position
+  // and newSize is the maximum number of storable positions.
+  while ((2 * newSize) * sizeof(TTCluster) <= (mbSize << 20))
+      newSize *= 2;
+
+  if (newSize != size)
+  {
       size = newSize;
       delete [] entries;
-    entries = new TTEntry[size * 4];
+      entries = new TTCluster[size];
-    if(entries == NULL) {
+      if (!entries)
+      {
           std::cerr << "Failed to allocate " << mbSize
-                << " MB for transposition table."
+                    << " MB for transposition table." << std::endl;
-                << std::endl;
+          Application::exit_with_failure();
-      exit(EXIT_FAILURE);
       }
-    this->clear();
+      clear();
   }
 }
 
@@ -82,73 +86,101 @@ void TranspositionTable::set_size(unsigned mbSize) {
 /// Perhaps we should also clear it when the "ucinewgame" command is recieved?
 
 void TranspositionTable::clear() {
-  memset(entries, 0, size * 4 * sizeof(TTEntry));
+
+  memset(entries, 0, size * sizeof(TTCluster));
+}
+
+
+/// TranspositionTable::first_entry returns a pointer to the first
+/// entry of a cluster given a position. The low 32 bits of the key
+/// are used to get the index in the table.
+
+inline TTEntry* TranspositionTable::first_entry(const Key posKey) const {
+
+  return entries[uint32_t(posKey) & (size - 1)].data;
 }
 
 
 /// TranspositionTable::store writes a new entry containing a position,
 /// a value, a value type, a search depth, and a best move to the
-/// transposition table.  The transposition table is organized in clusters
+/// transposition table. Transposition table is organized in clusters of
-/// of four TTEntry objects, and when a new entry is written, it replaces
+/// four TTEntry objects, and when a new entry is written, it replaces
 /// the least valuable of the four entries in a cluster. 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.
+/// is bigger than the depth of t2. A TTEntry of type VALUE_TYPE_EVAL
+/// never replaces another entry for the same position.
+
+void TranspositionTable::store(const Key posKey, Value v, ValueType t, Depth d, Move m) {
 
-void TranspositionTable::store(const Position &pos, Value v, Depth d,
-                               Move m, ValueType type) {
   TTEntry *tte, *replace;
+  uint32_t posKey32 = posKey >> 32; // Use the high 32 bits as key
+
+  tte = replace = first_entry(posKey);
+  for (int i = 0; i < ClusterSize; i++, tte++)
+  {
+      if (!tte->key() || tte->key() == posKey32) // empty or overwrite old
+      {
+          // Do not overwrite when new type is VALUE_TYPE_EV_LO
+          if (tte->key() && t == VALUE_TYPE_EV_LO)
+              return;
 
-  tte = replace = entries + int(pos.get_key() & (size - 1)) * 4;
-  for(int i = 0; i < 4; i++) {
-    if((tte+i)->key() == pos.get_key()) {
           if (m == MOVE_NONE)
-        m = (tte+i)->move();
+              m = tte->move();
-      *(tte+i) = TTEntry(pos.get_key(), v, type, d, m, generation);
+
+          *tte = TTEntry(posKey32, v, t, d, m, generation);
           return;
       }
-    if(replace->generation() == generation) {
+      else if (i == 0)  // replace would be a no-op in this common case
-      if((tte+i)->generation() != generation ||
+          continue;
-         (tte+i)->depth() < replace->depth())
+
-        replace = tte+i;
+      int c1 = (replace->generation() == generation ?  2 : 0);
+      int c2 = (tte->generation() == generation ? -2 : 0);
+      int c3 = (tte->depth() < replace->depth() ?  1 : 0);
+
+      if (c1 + c2 + c3 > 0)
+          replace = tte;
   }
-    else if((tte+i)->generation() != generation &&
+  *replace = TTEntry(posKey32, v, t, d, m, generation);
-            (tte+i)->depth() < replace->depth())
-      replace = tte+i;
-  }
-  *replace = TTEntry(pos.get_key(), v, type, d, m, generation);
   writes++;
 }
 
 
 /// TranspositionTable::retrieve looks up the current position in the
-/// transposition table, and extracts the value, value type, depth and
+/// transposition table. Returns a pointer to the TTEntry or NULL
-/// best move if the position is found.  The return value is true if
+/// if position is not found.
-/// the position is found, and false if it isn't.
 
-bool TranspositionTable::retrieve(const Position &pos, Value *value,
+TTEntry* TranspositionTable::retrieve(const Key posKey) const {
-                                  Depth *d, Move *move,
-                                  ValueType *type) const {
-  TTEntry *tte;
-  bool found = false;
 
-  tte = entries + int(pos.get_key() & (size - 1)) * 4;
+  uint32_t posKey32 = posKey >> 32;
-  for(int i = 0; i < 4 && !found ; i++)
+  TTEntry* tte = first_entry(posKey);
-    if((tte+i)->key() == pos.get_key()) {
+
-      tte = tte + i;
+  for (int i = 0; i < ClusterSize; i++, tte++)
-      found = true;
+      if (tte->key() == posKey32)
-    }
+          return tte;
-  if(!found) {
+
-    *move = MOVE_NONE;
+  return NULL;
-    return false;
 }
 
-  *value = tte->value();
-  *type = tte->type();
-  *d = tte->depth();
-  *move = tte->move();
 
-  return true;
+/// TranspositionTable::prefetch looks up the current position in the
+/// transposition table and load it in L1/L2 cache. This is a non
+/// blocking function and do not stalls the CPU waiting for data
+/// to be loaded from RAM, that can be very slow. When we will
+/// subsequently call retrieve() the TT data will be already
+/// quickly accessible in L1/L2 CPU cache.
+
+void TranspositionTable::prefetch(const Key posKey) const {
+
+#if defined(__INTEL_COMPILER) || defined(__ICL)
+   // This hack prevents prefetches to be optimized away by the
+   // Intel compiler. Both MSVC and gcc seems not affected.
+   __asm__ ("");
+#endif
+
+   char const* addr = (char*)first_entry(posKey);
+  _mm_prefetch(addr, _MM_HINT_T2);
+  _mm_prefetch(addr+64, _MM_HINT_T2); // 64 bytes ahead
 }
 
 
@@ -158,73 +190,68 @@ bool TranspositionTable::retrieve(const Position &pos, Value *value,
 /// entries from the current search.
 
 void TranspositionTable::new_search() {
+
   generation++;
   writes = 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
+/// iteration, and inserts the PV back into the PV. This makes sure
-/// old PV moves are searched first, even if the old TT entries have been
+/// the old PV moves are searched first, even if the old TT entries
-/// overwritten.
+/// have been overwritten.
 
 void TranspositionTable::insert_pv(const Position& pos, Move pv[]) {
-  UndoInfo u;
+
+  StateInfo st;
   Position p(pos);
 
-  for(int i = 0; pv[i] != MOVE_NONE; i++) {
+  for (int i = 0; pv[i] != MOVE_NONE; i++)
-    this->store(p, VALUE_NONE, Depth(0), pv[i], VALUE_TYPE_NONE);
+  {
-    p.do_move(pv[i], u);
+      store(p.get_key(), VALUE_NONE, VALUE_TYPE_NONE, Depth(-127*OnePly), pv[i]);
+      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 pv[]) {
+
+  int ply;
+  Position p(pos);
+  StateInfo st[100];
+
+  for (ply = 0; pv[ply] != MOVE_NONE; ply++)
+      p.do_move(pv[ply], st[ply]);
+
+  bool stop;
+  const TTEntry* tte;
+  for (stop = false, tte = retrieve(p.get_key());
+       tte && tte->move() != MOVE_NONE && !stop;
+       tte = retrieve(p.get_key()), ply++)
+  {
+      if (!move_is_legal(p, tte->move()))
+          break;
+      pv[ply] = tte->move();
+      p.do_move(pv[ply], st[ply]);
+      for (int j = 0; j < ply; j++)
+          if (st[j].key == p.get_key()) stop = true;
+  }
+  pv[ply] = MOVE_NONE;
+}
+
+
 /// TranspositionTable::full() returns the permill of all transposition table
 /// entries which have received at least one write during the current search.
 /// It is used to display the "info hashfull ..." information in UCI.
 
-int TranspositionTable::full() {
+int TranspositionTable::full() const {
-  double N = double(size) * 4.0;
+
+  double N = double(size) * ClusterSize;
   return int(1000 * (1 - exp(writes * log(1.0 - 1.0/N))));
 }
-
-
-/// Constructors
-
-TTEntry::TTEntry() {
-}
-
-TTEntry::TTEntry(Key k, Value v, ValueType t, Depth d, Move m,
-                 int generation) {
-  key_ = k;
-  data = (m & 0x7FFFF) | (t << 20) | (generation << 23);
-  value_ = v;
-  depth_ = int16_t(d);
-}
-
-
-/// Functions for extracting data from TTEntry objects.
-
-Key TTEntry::key() const {
-  return key_;
-}
-
-Depth TTEntry::depth() const {
-  return Depth(depth_);
-}
-
-Move TTEntry::move() const {
-  return Move(data & 0x7FFFF);
-}
-
-Value TTEntry::value() const {
-  return Value(value_);
-}
-
-ValueType TTEntry::type() const {
-  return ValueType((data >> 20) & 3);
-}
-
-int TTEntry::generation() const {
-  return (data >> 23);
-}

src/tt.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -33,28 +34,58 @@
 //// Types
 ////
 
-/// The TTEntry class is the class of transposition table entries.
+/// The TTEntry class is the class of transposition table entries
+///
+/// A TTEntry needs 96 bits to be stored
+///
+/// bit  0-31: key
+/// bit 32-63: data
+/// bit 64-79: value
+/// bit 80-95: depth
+///
+/// the 32 bits of the data field are so defined
+///
+/// bit  0-16: move
+/// bit 17-19: not used
+/// bit 20-22: value type
+/// bit 23-31: generation
 
 class TTEntry {
 
 public:
-  TTEntry();
+  TTEntry() {}
-  TTEntry(Key k, Value v, ValueType t, Depth d, Move m, int generation);
+  TTEntry(uint32_t k, Value v, ValueType t, Depth d, Move m, int generation)
-  Key key() const;
+        : key_ (k), data((m & 0x1FFFF) | (t << 20) | (generation << 23)),
-  Depth depth() const;
+          value_(int16_t(v)), depth_(int16_t(d)) {}
-  Move move() const;
+
-  Value value() const;
+  uint32_t key() const { return key_; }
-  ValueType type() const;
+  Depth depth() const { return Depth(depth_); }
-  int generation() const;
+  Move move() const { return Move(data & 0x1FFFF); }
+  Value value() const { return Value(value_); }
+  ValueType type() const { return ValueType((data >> 20) & 7); }
+  int generation() const { return (data >> 23); }
 
 private:
-  Key key_;
+  uint32_t key_;
   uint32_t data;
   int16_t value_;
   int16_t depth_;
 };
 
 
+/// This is the number of TTEntry slots for each position
+const int ClusterSize = 5;
+
+/// Each group of ClusterSize number of TTEntry form a TTCluster
+/// that is indexed by a single position key. Cluster is padded
+/// to a cache line size so to guarantee always aligned accesses.
+
+struct TTCluster {
+  TTEntry data[ClusterSize];
+  char cache_line_padding[64 - sizeof(TTEntry[ClusterSize])];
+};
+
+
 /// The transposition table class. This is basically just a huge array
 /// containing TTEntry objects, and a few methods for writing new entries
 /// and reading new ones.
@@ -62,31 +93,32 @@ private:
 class TranspositionTable {
 
 public:
-  TranspositionTable(unsigned mbSize);
+  TranspositionTable();
   ~TranspositionTable();
   void set_size(unsigned mbSize);
   void clear();
-  void store(const Position &pos, Value v, Depth d, Move m, ValueType type);
+  void store(const Key posKey, Value v, ValueType type, Depth d, Move m);
-  bool retrieve(const Position &pos, Value *value, Depth *d, Move *move,
+  TTEntry* retrieve(const Key posKey) const;
-                ValueType *type) const;
+  void prefetch(const Key posKey) const;
   void new_search();
   void insert_pv(const Position& pos, Move pv[]);
-  int full();
+  void extract_pv(const Position& pos, Move pv[]);
+  int full() const;
 
 private:
+  inline TTEntry* first_entry(const Key posKey) const;
+
+  // Be sure 'writes' is at least one cache line away
+  // from read only variables.
+  unsigned char pad_before[64 - sizeof(unsigned)];
+  unsigned writes; // heavy SMP read/write access here
+  unsigned char pad_after[64];
+
   unsigned size;
-  int writes;
+  TTCluster* entries;
-  TTEntry* entries;
   uint8_t generation;
 };
 
-
+extern TranspositionTable TT;
-////
-//// Constants and variables
-////
-
-// Default transposition table size, in megabytes:
-const int TTDefaultSize = 32;
-
 
 #endif // !defined(TT_H_INCLUDED)

src/types.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -30,7 +31,7 @@ typedef __int8 int8_t;
 typedef unsigned __int8 uint8_t;
 typedef __int16 int16;
 typedef unsigned __int16 uint16_t;
-typedef __int32 int32;
+typedef __int32 int32_t;
 typedef unsigned __int32 uint32_t;
 typedef __int64 int64;
 typedef unsigned __int64 uint64_t;
@@ -40,7 +41,36 @@ typedef __int64 int64_t;
 
 #endif // !defined(_MSC_VER)
 
-// Hash keys:
+// Hash keys
 typedef uint64_t Key;
 
+// Bitboard type
+typedef uint64_t Bitboard;
+
+
+////
+//// Compiler specific defines
+////
+
+// Quiet a warning on Intel compiler
+#if !defined(__SIZEOF_INT__ )
+#define __SIZEOF_INT__ 0
+#endif
+
+// Check for 64 bits for different compilers: Intel, MSVC and gcc
+#if defined(__x86_64) || defined(_M_X64) || defined(_WIN64) || (__SIZEOF_INT__ > 4)
+#define IS_64BIT
+#endif
+
+#if defined(IS_64BIT) && (defined(__GNUC__) || defined(__INTEL_COMPILER))
+#define USE_BSFQ
+#endif
+
+// Cache line alignment specification
+#if defined(_MSC_VER) || defined(__INTEL_COMPILER)
+#define CACHE_LINE_ALIGNMENT __declspec(align(64))
+#else
+#define CACHE_LINE_ALIGNMENT  __attribute__ ((aligned(64)))
+#endif
+
 #endif // !defined(TYPES_H_INCLUDED)

src/uci.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -21,7 +22,9 @@
 //// Includes
 ////
 
+#include <cassert>
 #include <iostream>
+#include <sstream>
 #include <string>
 
 #include "book.h"
@@ -35,6 +38,7 @@
 #include "uci.h"
 #include "ucioption.h"
 
+using namespace std;
 
 ////
 //// Local definitions:
@@ -42,30 +46,10 @@
 
 namespace {
 
-  // UCIInputParser is a class for parsing UCI input.  The class is
+  // UCIInputParser is a class for parsing UCI input. The class
-  // very simple, and basically just consist of a constant input
+  // is actually a string stream built on a given input string.
-  // string and a current location in the string.  There are methods
-  // for checking if we are at the end of the line, for getting the
-  // next token (defined as any whitespace-delimited sequence of
-  // characters), and for getting the rest of the line as a single
-  // string.
-
-  class UCIInputParser {
-
-  public:
-    UCIInputParser(const std::string &line);
-    std::string get_next_token();
-    std::string get_rest_of_line();
-    bool at_end_of_line();
-
-  private:
-    const std::string &inputLine;
-    int length, currentIndex;
-
-    void skip_whitespace();
-
-  };
 
+  typedef istringstream UCIInputParser;
 
   // The root position. This is set up when the user (or in practice, the GUI)
   // sends the "position" UCI command. The root position is sent to the think()
@@ -73,11 +57,10 @@ namespace {
   Position RootPosition;
 
   // Local functions
-  void wait_for_command();
+  bool handle_command(const string& command);
-  void handle_command(const std::string &command);
   void set_option(UCIInputParser& uip);
   void set_position(UCIInputParser& uip);
-  void go(UCIInputParser &uip);
+  bool go(UCIInputParser& uip);
 }
 
 
@@ -88,11 +71,22 @@ namespace {
 /// uci_main_loop() is the only global function in this file. It is
 /// called immediately after the program has finished initializing.
 /// The program remains in this loop until it receives the "quit" UCI
-/// command.
+/// command. It waits for a command from the user, and passes this
+/// command to handle_command and also intercepts EOF from stdin,
+/// by translating EOF to the "quit" command. This ensures that Stockfish
+/// exits gracefully if the GUI dies unexpectedly.
 
 void uci_main_loop() {
+
   RootPosition.from_fen(StartPosition);
-  while(1) wait_for_command();
+  string command;
+
+  do {
+      // Wait for a command from stdin
+      if (!getline(cin, command))
+          command = "quit";
+
+  } while (handle_command(command));
 }
 
 
@@ -102,278 +96,213 @@ void uci_main_loop() {
 
 namespace {
 
-  ///
-  /// Implementation of the UCIInputParser class.
-  ///
-
-  // Constructor for the UCIInputParser class.  The constructor takes a 
-  // text string containing a single UCI command as input.
-
-  UCIInputParser::UCIInputParser(const std::string &line) : inputLine(line) {
-    this->currentIndex = 0;
-    this->length = line.length();
-  }
-
-
-  // UCIInputParser::skip_whitspace() skips any number of whitespace
-  // characters from the current location in an input string.
-
-  void UCIInputParser::skip_whitespace() {
-    while(isspace((int)(unsigned char)this->inputLine[this->currentIndex]))
-      this->currentIndex++;
-  }
-
-
-  // UCIInputParser::get_next_token() gets the next token in an UCI
-  // command.  A 'token' in an UCI command is simply any
-  // whitespace-delimited sequence of characters.
-
-  std::string UCIInputParser::get_next_token() {
-    int i, j;
-
-    this->skip_whitespace();
-    for(i = j = this->currentIndex; 
-        j < this->length && !isspace(this->inputLine[j]); 
-        j++);
-    this->currentIndex = j;
-    this->skip_whitespace();
-
-    std::string str = this->inputLine.substr(i, j - i);
-
-    return str;
-  }
-
-
-  // UCIInputParser::get_rest_of_line() returns the rest of the input
-  // line (from the current location) as a single string.
-
-  std::string UCIInputParser::get_rest_of_line() {
-    this->skip_whitespace();
-    return this->inputLine.substr(this->currentIndex, this->length);
-  }
-
-
-  // UCIInputParser::at_end_of_line() tests whether we have reached the
-  // end of the input string, i.e. if any more input remains to be
-  // parsed.
-
-  bool UCIInputParser::at_end_of_line() {
-    return this->currentIndex == this->length;
-  }
-
-
-  /// 
-  /// Other functions
-  ///
-
-
-  // wait_for_command() waits for a command from the user, and passes
-  // this command to handle_command.  wait_for_command also intercepts
-  // EOF from stdin, by translating EOF to the "quit" command.  This
-  // ensures that Glaurung exits gracefully if the GUI dies
-  // unexpectedly.
-
-  void wait_for_command() {
-    std::string command;
-    if(!std::getline(std::cin, command)) command = "quit";
-    handle_command(command);
-  }
-
-
   // handle_command() takes a text string as input, uses a
   // UCIInputParser object to parse this text string as a UCI command,
   // and calls the appropriate functions. In addition to the UCI
   // commands, the function also supports a few debug commands.
 
-  void handle_command(const std::string &command) {
+  bool handle_command(const string& command) {
-    UCIInputParser uip(command);
-    std::string s = uip.get_next_token();
 
-    if(s == "quit") {
+    UCIInputParser uip(command);
-      OpeningBook.close();
+    string token;
-      stop_threads();
+
-      quit_eval();
+    uip >> token; // operator>>() skips any whitespace
-      exit(0);
+
-    }
+    if (token == "quit")
-    else if(s == "uci") {
+        return false;
-      std::cout << "id name " << engine_name() << std::endl;
+
-      std::cout << "id author Tord Romstad" << std::endl;
+    if (token == "go")
+        return go(uip);
+
+    if (token == "uci")
+    {
+        cout << "id name " << engine_name()
+             << "\nid author Tord Romstad, Marco Costalba, Joona Kiiski\n";
         print_uci_options();
-      std::cout << "uciok" << std::endl;
+        cout << "uciok" << endl;
     }
-    else if(s == "ucinewgame") {
+    else if (token == "ucinewgame")
-      TT.clear();
+    {
+        push_button("Clear Hash");
         Position::init_piece_square_tables();
         RootPosition.from_fen(StartPosition);
     }
-    else if(s == "isready")
+    else if (token == "isready")
-      std::cout << "readyok" << std::endl;
+        cout << "readyok" << endl;
-    else if(s == "position")
+    else if (token == "position")
         set_position(uip);
-    else if(s == "setoption")
+    else if (token == "setoption")
         set_option(uip);
-    else if(s == "go")
-      go(uip);
 
     // The remaining commands are for debugging purposes only.
     // Perhaps they should be removed later in order to reduce the
     // size of the program binary.
-    else if(s == "d")
+    else if (token == "d")
         RootPosition.print();
-    else if(s == "flip") {
+    else if (token == "flip")
+    {
         Position p(RootPosition);
         RootPosition.flipped_copy(p);
     }
-    else if(s == "eval") {
+    else if (token == "eval")
+    {
         EvalInfo ei;
-      std::cout << "Incremental mg: " << RootPosition.mg_value()
+        cout << "Incremental mg: " << RootPosition.mg_value()
-                << std::endl;
+             << "\nIncremental eg: " << RootPosition.eg_value()
-      std::cout << "Incremental eg: " << RootPosition.eg_value()
+             << "\nFull eval: " << evaluate(RootPosition, ei, 0) << endl;
-                << std::endl;
-      std::cout << "Full eval: "
-                << evaluate(RootPosition, ei, 0)
-                << std::endl;
     }
-    else if(s == "key") {
+    else if (token == "key")
-      std::cout << "key: " << RootPosition.get_key()
+        cout << "key: " << hex << RootPosition.get_key()
-                << " material key: " << RootPosition.get_material_key()
+             << "\nmaterial key: " << RootPosition.get_material_key()
-                << " pawn key: " << RootPosition.get_pawn_key()
+             << "\npawn key: " << RootPosition.get_pawn_key() << endl;
-                << std::endl;
+    else
-    }
+    {
-    else {
+        cout << "Unknown command: " << command << endl;
-      std::cout << "Unknown command: " << command << std::endl;
+        while (!uip.eof())
-      while(!uip.at_end_of_line()) {
+        {
-        std::cout << uip.get_next_token() << std::endl;
+            uip >> token;
+            cout << token << endl;
         }
     }
+    return true;
   }
 
 
-  // set_position() is called when Glaurung receives the "position" UCI
+  // set_position() is called when Stockfish receives the "position" UCI
   // command. The input parameter is a UCIInputParser. It is assumed
   // that this parser has consumed the first token of the UCI command
   // ("position"), and is ready to read the second token ("startpos"
   // or "fen", if the input is well-formed).
 
   void set_position(UCIInputParser& uip) {
-    std::string token;
 
-    token = uip.get_next_token();
+    string token;
+
+    uip >> token; // operator>>() skips any whitespace
+
     if (token == "startpos")
         RootPosition.from_fen(StartPosition);
-    else if(token == "fen") {
+    else if (token == "fen")
-      std::string fen;
+    {
-      while(token != "moves" && !uip.at_end_of_line()) {
+        string fen;
-        token = uip.get_next_token();
+        while (token != "moves" && !uip.eof())
+        {
+            uip >> token;
             fen += token;
             fen += ' ';
         }
         RootPosition.from_fen(fen);
     }
 
-    if(!uip.at_end_of_line()) {
+    if (!uip.eof())
+    {
         if (token != "moves")
-        token = uip.get_next_token();
+          uip >> token;
-      if(token == "moves") {
+        if (token == "moves")
+        {
             Move move;
-        UndoInfo u;
+            StateInfo st;
-        while(!uip.at_end_of_line()) {
+            while (!uip.eof())
-          token = uip.get_next_token();
+            {
+                uip >> token;
                 move = move_from_string(RootPosition, token);
-          RootPosition.do_move(move, u);
+                RootPosition.do_move(move, st);
                 if (RootPosition.rule_50_counter() == 0)
                     RootPosition.reset_game_ply();
             }
+            // Our StateInfo st is about going out of scope so copy
+            // its content inside RootPosition before they disappear.
+            RootPosition.saveState();
         }
     }
   }
 
 
-  // set_option() is called when Glaurung receives the "setoption" UCI
+  // set_option() is called when Stockfish receives the "setoption" UCI
   // command. The input parameter is a UCIInputParser. It is assumed
   // that this parser has consumed the first token of the UCI command
   // ("setoption"), and is ready to read the second token ("name", if
   // the input is well-formed).
 
   void set_option(UCIInputParser& uip) {
-    std::string token;
+
-    if(!uip.at_end_of_line()) {
+    string token, name;
-      token = uip.get_next_token();
+
-      if(token == "name" && !uip.at_end_of_line()) {
+    uip >> token;
-        std::string name = uip.get_next_token();
+    if (token == "name")
-        std::string nextToken;
+    {
-        while(!uip.at_end_of_line()
+        uip >> name;
-              && (nextToken = uip.get_next_token()) != "value")
+        while (!uip.eof())
-          name += (" " + nextToken);
+        {
-        if(nextToken == "value")
+            uip >> token;
-          set_option_value(name, uip.get_rest_of_line());
+            if (token == "value")
-        else
+                break;
+
+            name += (" " + token);
+        }
+        if (token == "value")
+        {
+            // Reads until end of line and left trim white space
+            getline(uip, token);
+            token.erase(0, token.find_first_not_of(" \n\r\t"));
+
+            set_option_value(name, token);
+        } else
             push_button(name);
     }
   }
-  }
 
 
-  // go() is called when Glaurung receives the "go" UCI command.  The
+  // go() is called when Stockfish receives the "go" UCI command. The
   // input parameter is a UCIInputParser. It is assumed that this
   // parser has consumed the first token of the UCI command ("go"),
   // and is ready to read the second token. The function sets the
   // thinking time and other parameters from the input string, and
   // calls think() (defined in search.cpp) with the appropriate
-  // parameters.
+  // parameters. Returns false if a quit command is received while
+  // thinking, returns true otherwise.
 
-  void go(UCIInputParser &uip) {
+  bool go(UCIInputParser& uip) {
-    std::string token;
+
-    int time[2] = {0, 0}, inc[2] = {0, 0}, movesToGo = 0, depth = 0, nodes = 0;
+    string token;
-    int moveTime = 0;
+
+    int time[2] = {0, 0}, inc[2] = {0, 0};
+    int movesToGo = 0, depth = 0, nodes = 0, moveTime = 0;
     bool infinite = false, ponder = false;
     Move searchMoves[500];
 
     searchMoves[0] = MOVE_NONE;
 
-    while(!uip.at_end_of_line()) {
+    while (!uip.eof())
-      token = uip.get_next_token();
+    {
+        uip >> token;
 
         if (token == "infinite")
             infinite = true;
         else if (token == "ponder")
             ponder = true;
-      else if(token == "wtime") {
+        else if (token == "wtime")
-        if(!uip.at_end_of_line())
+            uip >> time[0];
-          time[0] = atoi(uip.get_next_token().c_str());
+        else if (token == "btime")
-      }
+            uip >> time[1];
-      else if(token == "btime") {
+        else if (token == "winc")
-        if(!uip.at_end_of_line())
+            uip >> inc[0];
-          time[1] = atoi(uip.get_next_token().c_str());
+        else if (token == "binc")
-      }
+            uip >> inc[1];
-      else if(token == "winc") {
+        else if (token == "movestogo")
-        if(!uip.at_end_of_line())
+            uip >> movesToGo;
-          inc[0] = atoi(uip.get_next_token().c_str());
+        else if (token == "depth")
-      }
+            uip >> depth;
-      else if(token == "binc") {
+        else if (token == "nodes")
-        if(!uip.at_end_of_line())
+            uip >> nodes;
-          inc[1] = atoi(uip.get_next_token().c_str());
+        else if (token == "movetime")
-      }
+            uip >> moveTime;
-      else if(token == "movestogo") {
+        else if (token == "searchmoves")
-        if(!uip.at_end_of_line())
+        {
-          movesToGo = atoi(uip.get_next_token().c_str());
-      }
-      else if(token == "depth") {
-        if(!uip.at_end_of_line())
-          depth = atoi(uip.get_next_token().c_str());
-      }
-      else if(token == "nodes") {
-        if(!uip.at_end_of_line())
-          nodes = atoi(uip.get_next_token().c_str());
-      }
-      else if(token == "movetime") {
-        if(!uip.at_end_of_line())
-          moveTime = atoi(uip.get_next_token().c_str());
-      }
-      else if(token == "searchmoves" && !uip.at_end_of_line()) {
             int numOfMoves = 0;
-        while(!uip.at_end_of_line()) {
+            while (!uip.eof())
-          token = uip.get_next_token();
+            {
+                uip >> token;
                 searchMoves[numOfMoves++] = move_from_string(RootPosition, token);
             }
             searchMoves[numOfMoves] = MOVE_NONE;
@@ -383,9 +312,10 @@ namespace {
     if (moveTime)
         infinite = true;  // HACK
 
-    think(RootPosition, infinite, ponder, time[RootPosition.side_to_move()],
+    assert(RootPosition.is_ok());
-          inc[RootPosition.side_to_move()], movesToGo, depth, nodes, moveTime,
+
-          searchMoves);
+    return think(RootPosition, infinite, ponder, RootPosition.side_to_move(),
+                 time, inc, movesToGo, depth, nodes, moveTime, searchMoves);
   }
 
 }

src/uci.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.

src/ucioption.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -21,21 +22,18 @@
 //// Includes
 ////
 
+#include <algorithm>
 #include <cassert>
-#include <cstdarg>
+#include <map>
-#include <cstdio>
+#include <string>
+#include <sstream>
+#include <vector>
 
 #include "misc.h"
 #include "thread.h"
 #include "ucioption.h"
 
-
+using std::string;
-////
-//// Variables
-////
-
-bool Chess960 = false;
-
 
 ////
 //// Local definitions
@@ -47,93 +45,132 @@ namespace {
   /// Types
   ///
 
-  enum OptionType { SPIN, COMBO, CHECK, STRING, BUTTON, OPTION_TYPE_NONE};
+  enum OptionType { SPIN, COMBO, CHECK, STRING, BUTTON };
+
+  typedef std::vector<string> ComboValues;
 
   struct Option {
-    char name[50], defaultValue[300], currentValue[300];
+
+    string name, defaultValue, currentValue;
     OptionType type;
+    size_t idx;
     int minValue, maxValue;
-    char comboValues[8][64];
+    ComboValues 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; }
   };
 
+  typedef std::map<string, Option> Options;
+
+  ///
+  /// Constants
+  ///
+
+  // load_defaults populates the options map with the hard
+  // coded names and default values.
+
+  void load_defaults(Options& o) {
+
+    o["Use Search Log"] = Option(false);
+    o["Search Log Filename"] = Option("SearchLog.txt");
+    o["Book File"] = Option("book.bin");
+    o["Mobility (Middle Game)"] = Option(100, 0, 200);
+    o["Mobility (Endgame)"] = Option(100, 0, 200);
+    o["Pawn Structure (Middle Game)"] = Option(100, 0, 200);
+    o["Pawn Structure (Endgame)"] = Option(100, 0, 200);
+    o["Passed Pawns (Middle Game)"] = Option(100, 0, 200);
+    o["Passed Pawns (Endgame)"] = Option(100, 0, 200);
+    o["Space"] = Option(100, 0, 200);
+    o["Aggressiveness"] = Option(100, 0, 200);
+    o["Cowardice"] = Option(100, 0, 200);
+    o["King Safety Curve"] = Option("Quadratic", COMBO);
+
+       o["King Safety Curve"].comboValues.push_back("Quadratic");
+       o["King Safety Curve"].comboValues.push_back("Linear");  /*, "From File"*/
+
+    o["King Safety Coefficient"] = Option(40, 1, 100);
+    o["King Safety X Intercept"] = Option(0, 0, 20);
+    o["King Safety Max Slope"] = Option(30, 10, 100);
+    o["King Safety Max Value"] = Option(500, 100, 1000);
+    o["Queen Contact Check Bonus"] = Option(3, 0, 8);
+    o["Queen Check Bonus"] = Option(2, 0, 4);
+    o["Rook Check Bonus"] = Option(1, 0, 4);
+    o["Bishop Check Bonus"] = Option(1, 0, 4);
+    o["Knight Check Bonus"] = Option(1, 0, 4);
+    o["Discovered Check Bonus"] = Option(3, 0, 8);
+    o["Mate Threat Bonus"] = Option(3, 0, 8);
+    o["Check Extension (PV nodes)"] = Option(2, 0, 2);
+    o["Check Extension (non-PV nodes)"] = Option(1, 0, 2);
+    o["Single Reply Extension (PV nodes)"] = Option(2, 0, 2);
+    o["Single Reply Extension (non-PV nodes)"] = Option(2, 0, 2);
+    o["Mate Threat Extension (PV nodes)"] = Option(0, 0, 2);
+    o["Mate Threat Extension (non-PV nodes)"] = Option(0, 0, 2);
+    o["Pawn Push to 7th Extension (PV nodes)"] = Option(1, 0, 2);
+    o["Pawn Push to 7th Extension (non-PV nodes)"] = Option(1, 0, 2);
+    o["Passed Pawn Extension (PV nodes)"] = Option(1, 0, 2);
+    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["Full Depth Moves (PV nodes)"] = Option(10, 1, 100);
+    o["Full Depth Moves (non-PV nodes)"] = Option(3, 1, 100);
+    o["Threat Depth"] = Option(5, 0, 100);
+    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, 8);
+    o["Hash"] = Option(32, 4, 4096);
+    o["Clear Hash"] = Option(false, BUTTON);
+    o["Ponder"] = Option(true);
+    o["OwnBook"] = Option(true);
+    o["MultiPV"] = Option(1, 1, 500);
+    o["UCI_ShowCurrLine"] = Option(false);
+    o["UCI_Chess960"] = Option(false);
+    o["UCI_AnalyseMode"] = Option(false);
+
+    // Any option should know its name so to be easily printed
+    for (Options::iterator it = o.begin(); it != o.end(); ++it)
+        it->second.name = it->first;
+  }
 
   ///
   /// Variables
   ///
 
-  Option Options[] = {
+  Options options;
-    { "Use Search Log", "false", "false", CHECK, 0, 0, {""} },
-    { "Search Log Filename", "SearchLog.txt", "SearchLog.txt", STRING, 0, 0, {""} },
-    { "Book File", "book.bin", "book.bin", STRING, 0, 0, {""} },
-    { "Mobility (Middle Game)", "100", "100", SPIN, 0, 200, {""} },
-    { "Mobility (Endgame)", "100", "100", SPIN, 0, 200, {""} },
-    { "Pawn Structure (Middle Game)", "100", "100", SPIN, 0, 200, {""} },
-    { "Pawn Structure (Endgame)", "100", "100", SPIN, 0, 200, {""} },
-    { "Passed Pawns (Middle Game)", "100", "100", SPIN, 0, 200, {""} },
-    { "Passed Pawns (Endgame)", "100", "100", SPIN, 0, 200, {""} },
-    { "Aggressiveness", "100", "100", SPIN, 0, 200, {""} },
-    { "Cowardice", "100", "100", SPIN, 0, 200, {""} },
-    { "King Safety Curve", "Quadratic", "Quadratic", COMBO, 0, 0,
-      { "Quadratic", "Linear" /*, "From File"*/ } },
-    { "King Safety Coefficient", "40", "40", SPIN, 1, 100 , {""} },
-    { "King Safety X Intercept", "0", "0", SPIN, 0, 20, {""} },
-    { "King Safety Max Slope", "30", "30", SPIN, 10, 100, {""} },
-    { "King Safety Max Value", "500", "500", SPIN, 100, 1000, {""} },
-    { "Queen Contact Check Bonus", "4", "4", SPIN, 0, 8, {""} },
-    { "Rook Contact Check Bonus", "2", "2", SPIN, 0, 4, {""} },
-    { "Queen Check Bonus", "2", "2", SPIN, 0, 4, {""} },
-    { "Rook Check Bonus", "1", "1", SPIN, 0, 4, {""} },
-    { "Bishop Check Bonus", "1", "1", SPIN, 0, 4, {""} },
-    { "Knight Check Bonus", "1", "1", SPIN, 0, 4, {""} },
-    { "Discovered Check Bonus", "3", "3", SPIN, 0, 8, {""} },
-    { "Mate Threat Bonus", "3", "3", SPIN, 0, 8, {""} },
-    { "Check Extension (PV nodes)", "2", "2", SPIN, 0, 2, {""} },
-    { "Check Extension (non-PV nodes)", "1", "1", SPIN, 0, 2, {""} },
-    { "Single Reply Extension (PV nodes)", "2", "2", SPIN, 0, 2, {""} },
-    { "Single Reply Extension (non-PV nodes)", "2", "2", SPIN, 0, 2, {""} },
-    { "Mate Threat Extension (PV nodes)", "0", "0", SPIN, 0, 2, {""} },
-    { "Mate Threat Extension (non-PV nodes)", "0", "0", SPIN, 0, 2, {""} },
-    { "Pawn Push to 7th Extension (PV nodes)", "1", "1", SPIN, 0, 2, {""} },
-    { "Pawn Push to 7th Extension (non-PV nodes)", "1", "1", SPIN, 0, 2, {""} },
-    { "Passed Pawn Extension (PV nodes)", "1", "1", SPIN, 0, 2, {""} },
-    { "Passed Pawn Extension (non-PV nodes)", "0", "0", SPIN, 0, 2, {""} },
-    { "Pawn Endgame Extension (PV nodes)", "2", "2", SPIN, 0, 2, {""} },
-    { "Pawn Endgame Extension (non-PV nodes)", "2", "2", SPIN, 0, 2, {""} },
-    { "Full Depth Moves (PV nodes)", "14", "14", SPIN, 1, 100, {""} },
-    { "Full Depth Moves (non-PV nodes)", "3", "3", SPIN, 1, 100, {""} },
-    { "Threat Depth", "5", "5", SPIN, 0, 100, {""} },
-    { "Selective Plies", "7", "7", SPIN, 0, 10, {""} },
-    { "Futility Pruning (Main Search)", "true", "true", CHECK, 0, 0, {""} },
-    { "Futility Pruning (Quiescence Search)", "true", "true", CHECK, 0, 0, {""} },
-    { "Futility Margin 0", "50", "50", SPIN, 0, 1000, {""} },
-    { "Futility Margin 1", "100", "100", SPIN, 0, 1000, {""} },
-    { "Futility Margin 2", "300", "300", SPIN, 0, 1000, {""} },
-    { "Maximum Razoring Depth", "3", "3", SPIN, 0, 4, {""} },
-    { "Razoring Margin", "300", "300", SPIN, 150, 600, {""} },
-    { "Randomness", "0", "0", SPIN, 0, 10, {""} },
-    { "Minimum Split Depth", "4", "4", SPIN, 4, 7, {""} },
-    { "Maximum Number of Threads per Split Point", "5", "5", SPIN, 4, 8, {""} },
-    { "Threads", "1", "1", SPIN, 1, 8, {""} },
-    { "Hash", "32", "32", SPIN, 4, 4096, {""} },
-    { "Clear Hash", "false", "false", BUTTON, 0, 0, {""} },
-    { "Ponder", "true", "true", CHECK, 0, 0, {""} },
-    { "OwnBook", "true", "true", CHECK, 0, 0, {""} },
-    { "MultiPV", "1", "1", SPIN, 1, 500, {""} },
-    { "UCI_ShowCurrLine", "false", "false", CHECK, 0, 0, {""} },
-    { "UCI_Chess960", "false", "false", CHECK, 0, 0, {""} },
-    { "", "", "", OPTION_TYPE_NONE, 0, 0, {""}}
-  };
 
+  // stringify converts a value of type T to a std::string
+  template<typename T>
+  string stringify(const T& v) {
 
-  ///
+     std::ostringstream ss;
-  /// Functions
+     ss << v;
-  ///
+     return ss.str();
-
-  Option *option_with_name(const char *optionName);
-
   }
 
 
+  // 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) {
+
+      T ret = T();
+      if (options.find(optionName) == options.end())
+          return ret;
+
+      std::istringstream ss(options[optionName].currentValue);
+      ss >> ret;
+      return ret;
+  }
+
+}
+
 ////
 //// Functions
 ////
@@ -143,27 +180,18 @@ namespace {
 /// "Threads" parameter to the number of available CPU cores.
 
 void init_uci_options() {
-  Option *o;
 
-  o = option_with_name("Threads");
+  load_defaults(options);
-  assert(o != NULL);
 
   // Limit the default value of "Threads" to 7 even if we have 8 CPU cores.
   // According to Ken Dail's tests, Glaurung plays much better with 7 than
   // with 8 threads.  This is weird, but it is probably difficult to find out
   // why before I have a 8-core computer to experiment with myself.
-  sprintf(o->defaultValue, "%d", Min(cpu_count(), 7));
+  assert(options.find("Threads") != options.end());
-  sprintf(o->currentValue, "%d", Min(cpu_count(), 7));
+  assert(options.find("Minimum Split Depth") != options.end());
 
-  // Increase the minimum split depth when the number of CPUs is big.
+  options["Threads"].defaultValue = stringify(Min(cpu_count(), 7));
-  // It would probably be better to let this depend on the number of threads
+  options["Threads"].currentValue = stringify(Min(cpu_count(), 7));
-  // instead.
-  o = option_with_name("Minimum Split Depth");
-  assert(o != NULL);
-  if(cpu_count() > 4) {
-    sprintf(o->defaultValue, "%d", 6);
-    sprintf(o->defaultValue, "%d", 6);
-  }
 }
 
 
@@ -171,30 +199,49 @@ void init_uci_options() {
 /// in the format defined by the UCI protocol.
 
 void print_uci_options() {
+
   static const char optionTypeName[][16] = {
     "spin", "combo", "check", "string", "button"
   };
-  for(Option *o = Options; o->type != OPTION_TYPE_NONE; o++) {
+
-    printf("option name %s type %s", o->name, optionTypeName[o->type]);
+  // Build up a vector out of the options map and sort it according to idx
-    if(o->type != BUTTON) {
+  // field, that is the chronological insertion order in options map.
-      printf(" default %s", o->defaultValue);
+  std::vector<Option> vec;
-      if(o->type == SPIN)
+  for (Options::const_iterator it = options.begin(); it != options.end(); ++it)
-        printf(" min %d max %d", o->minValue, o->maxValue);
+      vec.push_back(it->second);
-      else if(o->type == COMBO)
+
-        for(int i = 0; strlen(o->comboValues[i]) > 0; i++)
+  std::sort(vec.begin(), vec.end());
-          printf(" var %s", o->comboValues[i]);
+
-    }
+  for (std::vector<Option>::const_iterator it = vec.begin(); it != vec.end(); ++it)
-    printf("\n");
+  {
+      std::cout << "\noption name " << it->name
+                << " type "         << optionTypeName[it->type];
+
+      if (it->type == BUTTON)
+          continue;
+
+      if (it->type == CHECK)
+          std::cout << " default " << (it->defaultValue == "1" ? "true" : "false");
+      else
+          std::cout << " default " << it->defaultValue;
+
+      if (it->type == SPIN)
+          std::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)
+              std::cout << " var " << *itc;
   }
+  std::cout << std::endl;
 }
 
 
 /// get_option_value_bool() returns the current value of a UCI parameter of
 /// type "check".
 
-bool get_option_value_bool(const std::string &optionName) {
+bool get_option_value_bool(const string& optionName) {
-  Option *o = option_with_name(optionName.c_str());
+
-  return o != NULL && strcmp(o->currentValue, "true") == 0;
+  return get_option_value<bool>(optionName);
 }
 
 
@@ -203,31 +250,18 @@ bool get_option_value_bool(const std::string &optionName) {
 /// it could also be used with a "combo" parameter, where all the available
 /// values are integers.
 
-int get_option_value_int(const std::string &optionName) {
+int get_option_value_int(const string& optionName) {
-  Option *o = option_with_name(optionName.c_str());
+
-  return atoi(o->currentValue);
+  return get_option_value<int>(optionName);
 }
 
 
 /// get_option_value_string() returns the current value of a UCI parameter as
 /// a string. It is used with parameters of type "combo" and "string".
 
-const std::string get_option_value_string(const std::string &optionName) {
+string get_option_value_string(const string& optionName) {
-  Option *o = option_with_name(optionName.c_str());
-  return o->currentValue;
-}
 
-
+   return get_option_value<string>(optionName);
-/// button_was_pressed() tests whether a UCI parameter of type "button" has
-/// been selected since the last time the function was called.
-
-bool button_was_pressed(const std::string &buttonName) {
-  if(get_option_value_bool(buttonName)) {
-    set_option_value(buttonName, "false");
-    return true;
-  }
-  else
-    return false;
 }
 
 
@@ -235,36 +269,59 @@ bool button_was_pressed(const std::string &buttonName) {
 /// 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 std::string &optionName,
+void set_option_value(const string& name, const string& value) {
-                      const std::string &newValue) {
-  Option *o = option_with_name(optionName.c_str());
 
-  if(o != NULL)
+  // UCI protocol uses "true" and "false" instead of "1" and "0", so convert
-    strcpy(o->currentValue, newValue.c_str());
+  // value according to standard C++ convention before to store it.
+  string v(value);
+  if (v == "true")
+      v = "1";
+  else if (v == "false")
+      v = "0";
+
+  if (options.find(name) != options.end())
+      options[name].currentValue = v;
   else
-    std::cout << "No such option: " << optionName << std::endl;
+      std::cout << "No such option: " << name << std::endl;
 }
 
 
 /// push_button() is used to tell the engine that a UCI parameter of type
 /// "button" has been selected:
 
-void push_button(const std::string &buttonName) {
+void push_button(const string& buttonName) {
+
   set_option_value(buttonName, "true");
 }
 
 
+/// button_was_pressed() tests whether a UCI parameter of type "button" has
+/// been selected since the last time the function was called, in this case
+/// it also resets the button.
+
+bool button_was_pressed(const string& buttonName) {
+
+  if (!get_option_value<bool>(buttonName))
+	  return false;
+
+  set_option_value(buttonName, "false");
+  return true;
+}
+
+
 namespace {
 
-  // option_with_name() tries to find a UCI option with a given
+  // Define constructors of Option class.
-  // name.  It returns a pointer to the UCI option or the null pointer,
-  // depending on whether an option with the given name exists.
 
-  Option *option_with_name(const char *optionName) {
+  Option::Option() {} // To allow insertion in a std::map
-    for(Option *o = Options; o->type != OPTION_TYPE_NONE; o++)
+
-      if(strcmp(o->name, optionName) == 0)
+  Option::Option(const char* def, OptionType t)
-        return o;
+  : defaultValue(def), currentValue(def), type(t), idx(options.size()), minValue(0), maxValue(0) {}
-    return NULL;
+
-  }
+  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/ucioption.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -26,14 +27,6 @@
 
 #include <string>
 
-
-////
-//// Variables
-////
-
-extern bool Chess960;
-
-
 ////
 //// Prototypes
 ////
@@ -42,10 +35,9 @@ extern void init_uci_options();
 extern void print_uci_options();
 extern bool get_option_value_bool(const std::string& optionName);
 extern int get_option_value_int(const std::string& optionName);
-extern const std::string get_option_value_string(const std::string &optionName);
+extern std::string get_option_value_string(const std::string& optionName);
 extern bool button_was_pressed(const std::string& buttonName);
-extern void set_option_value(const std::string &optionName, 
+extern void set_option_value(const std::string& optionName,const std::string& newValue);
-                             const std::string &newValue);
 extern void push_button(const std::string& buttonName);
 
 

src/value.cpp

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -59,7 +60,7 @@ Value value_from_tt(Value v, int ply) {
 }
 
 
-/// value_to_centipawns() converts a value from Glaurung's somewhat unusual
+/// 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) {
@@ -67,7 +68,7 @@ int value_to_centipawns(Value v) {
 }
 
 
-/// value_from_centipawns() converts a centipawn value to Glaurung's internal
+/// 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).
 

src/value.h

@@ -1,13 +1,14 @@
 /*
-  Glaurung, a UCI chess playing engine.
+  Stockfish, a UCI chess playing engine derived from Glaurung 2.1
-  Copyright (C) 2004-2008 Tord Romstad
+  Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
+  Copyright (C) 2008-2009 Marco Costalba
 
-  Glaurung is free software: you can redistribute it and/or modify
+  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.
 
-  Glaurung is distributed in the hope that it will be useful,
+  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.
@@ -35,7 +36,10 @@ enum ValueType {
   VALUE_TYPE_NONE = 0,
   VALUE_TYPE_UPPER = 1,  // Upper bound
   VALUE_TYPE_LOWER = 2,  // Lower bound
-  VALUE_TYPE_EXACT = 3   // Exact score
+  VALUE_TYPE_EXACT = 3,  // Exact score
+  VALUE_TYPE_EVAL  = 4,  // Evaluation cache
+  VALUE_TYPE_EV_UP = 5,  // Evaluation cache for upper bound
+  VALUE_TYPE_EV_LO = 6   // Evaluation cache for lower bound
 };
 
 
@@ -57,17 +61,19 @@ enum Value {
 /// 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(0xCC);
+const Value PawnValueMidgame   = Value(0x0C6);
-const Value PawnValueEndgame = Value(0x100);
+const Value PawnValueEndgame   = Value(0x102);
-const Value KnightValueMidgame = Value(0x340);
+const Value KnightValueMidgame = Value(0x331);
-const Value KnightValueEndgame = Value(0x340);
+const Value KnightValueEndgame = Value(0x34E);
-const Value BishopValueMidgame = Value(0x340);
+const Value BishopValueMidgame = Value(0x344);
-const Value BishopValueEndgame = Value(0x340);
+const Value BishopValueEndgame = Value(0x359);
-const Value RookValueMidgame = Value(0x505);
+const Value RookValueMidgame   = Value(0x4F6);
-const Value RookValueEndgame = Value(0x505);
+const Value RookValueEndgame   = Value(0x4FE);
-const Value QueenValueMidgame = Value(0xA00);
+const Value QueenValueMidgame  = Value(0x9D9);
-const Value QueenValueEndgame = Value(0xA00);
+const Value QueenValueEndgame  = Value(0x9FE);
 
 const Value PieceValueMidgame[17] = {
   Value(0),
@@ -89,10 +95,10 @@ const Value PieceValueEndgame[17] = {
   Value(0), Value(0), Value(0)
 };
 
-/// Bonus for having the side to move
+/// Bonus for having the side to move (modified by Joona Kiiski)
 
-const Value TempoValueMidgame = Value(50);
+const Value TempoValueMidgame = Value(48);
-const Value TempoValueEndgame = Value(20);
+const Value TempoValueEndgame = Value(22);
 
 
 ////