Microptimization in do_evaluate()
[stockfish] / src / evaluate.cpp
1 /*
2   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
3   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
4   Copyright (C) 2008-2009 Marco Costalba
5
6   Stockfish is free software: you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation, either version 3 of the License, or
9   (at your option) any later version.
10
11   Stockfish is distributed in the hope that it will be useful,
12   but WITHOUT ANY WARRANTY; without even the implied warranty of
13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   GNU General Public License for more details.
15
16   You should have received a copy of the GNU General Public License
17   along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 */
19
20
21 ////
22 //// Includes
23 ////
24
25 #include <cassert>
26 #include <cstring>
27
28 #include "bitcount.h"
29 #include "evaluate.h"
30 #include "material.h"
31 #include "pawns.h"
32 #include "scale.h"
33 #include "thread.h"
34 #include "ucioption.h"
35
36
37 ////
38 //// Local definitions
39 ////
40
41 namespace {
42
43   const int Sign[2] = { 1, -1 };
44
45   // Evaluation grain size, must be a power of 2
46   const int GrainSize = 4;
47
48   // Evaluation weights, initialized from UCI options
49   int WeightMobilityMidgame, WeightMobilityEndgame;
50   int WeightPawnStructureMidgame, WeightPawnStructureEndgame;
51   int WeightPassedPawnsMidgame, WeightPassedPawnsEndgame;
52   int WeightKingSafety[2];
53   int WeightSpace;
54
55   // Internal evaluation weights. These are applied on top of the evaluation
56   // weights read from UCI parameters. The purpose is to be able to change
57   // the evaluation weights while keeping the default values of the UCI
58   // parameters at 100, which looks prettier.
59   //
60   // Values modified by Joona Kiiski
61   const int WeightMobilityMidgameInternal      = 248;
62   const int WeightMobilityEndgameInternal      = 271;
63   const int WeightPawnStructureMidgameInternal = 233;
64   const int WeightPawnStructureEndgameInternal = 201;
65   const int WeightPassedPawnsMidgameInternal   = 252;
66   const int WeightPassedPawnsEndgameInternal   = 259;
67   const int WeightKingSafetyInternal           = 247;
68   const int WeightKingOppSafetyInternal        = 259;
69   const int WeightSpaceInternal                = 46;
70
71   // Mobility and outposts bonus modified by Joona Kiiski
72   //
73   // Visually better to define tables constants
74   typedef Value V;
75
76   // Knight mobility bonus in middle game and endgame, indexed by the number
77   // of attacked squares not occupied by friendly piecess.
78   const Value MidgameKnightMobilityBonus[] = {
79   //    0       1      2     3      4      5      6      7      8
80     V(-38), V(-25),V(-12), V(0), V(12), V(25), V(31), V(38), V(38)
81   };
82
83   const Value EndgameKnightMobilityBonus[] = {
84   //    0       1      2     3      4      5      6      7      8
85     V(-33), V(-23),V(-13), V(-3), V(7), V(17), V(22), V(27), V(27)
86   };
87
88   // Bishop mobility bonus in middle game and endgame, indexed by the number
89   // of attacked squares not occupied by friendly pieces. X-ray attacks through
90   // queens are also included.
91   const Value MidgameBishopMobilityBonus[] = {
92   //    0       1      2      3      4      5      6      7
93     V(-25), V(-11),  V(3), V(17), V(31), V(45), V(57), V(65),
94   //    8       9     10     11     12     13     14     15
95     V( 71), V( 74), V(76), V(78), V(79), V(80), V(81), V(81)
96   };
97
98   const Value EndgameBishopMobilityBonus[] = {
99   //    0       1      2      3      4      5      6      7
100     V(-30), V(-16), V(-2), V(12), V(26), V(40), V(52), V(60),
101   //    8       9     10     11     12     13     14     15
102     V( 65), V( 69), V(71), V(73), V(74), V(75), V(76), V(76)
103   };
104
105   // Rook mobility bonus in middle game and endgame, indexed by the number
106   // of attacked squares not occupied by friendly pieces. X-ray attacks through
107   // queens and rooks are also included.
108   const Value MidgameRookMobilityBonus[] = {
109   //    0       1      2      3      4      5      6      7
110     V(-20), V(-14), V(-8), V(-2),  V(4), V(10), V(14), V(19),
111   //    8       9     10     11     12     13     14     15
112     V( 23), V( 26), V(27), V(28), V(29), V(30), V(31), V(32)
113   };
114
115   const Value EndgameRookMobilityBonus[] = {
116   //    0       1      2      3      4      5      6      7
117     V(-36), V(-19), V(-3), V(13), V(29), V(46), V(62), V(79),
118   //    8       9     10     11     12     13     14     15
119     V( 95), V(106),V(111),V(114),V(116),V(117),V(118),V(118)
120   };
121
122   // Queen mobility bonus in middle game and endgame, indexed by the number
123   // of attacked squares not occupied by friendly pieces.
124   const Value MidgameQueenMobilityBonus[] = {
125   //    0      1      2      3      4      5      6      7
126     V(-10), V(-8), V(-6), V(-3), V(-1), V( 1), V( 3), V( 5),
127   //    8      9     10     11     12     13     14     15
128     V(  8), V(10), V(12), V(15), V(16), V(17), V(18), V(20),
129   //   16     17     18     19     20     21     22     23
130     V( 20), V(20), V(20), V(20), V(20), V(20), V(20), V(20),
131   //   24     25     26     27     28     29     30     31
132     V( 20), V(20), V(20), V(20), V(20), V(20), V(20), V(20)
133   };
134
135   const Value EndgameQueenMobilityBonus[] = {
136   //    0      1      2      3      4      5      6      7
137     V(-18),V(-13), V(-7), V(-2), V( 3), V (8), V(13), V(19),
138   //    8      9     10     11     12     13     14     15
139     V( 23), V(27), V(32), V(34), V(35), V(35), V(35), V(35),
140   //   16     17     18     19     20     21     22     23
141     V( 35), V(35), V(35), V(35), V(35), V(35), V(35), V(35),
142   //   24     25     26     27     28     29     30     31
143     V( 35), V(35), V(35), V(35), V(35), V(35), V(35), V(35)
144   };
145
146   // Outpost bonuses for knights and bishops, indexed by square (from white's
147   // point of view).
148   const Value KnightOutpostBonus[64] = {
149   //  A     B     C     D     E     F     G     H
150     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 1
151     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 2
152     V(0), V(0), V(4), V(8), V(8), V(4), V(0), V(0), // 3
153     V(0), V(4),V(17),V(26),V(26),V(17), V(4), V(0), // 4
154     V(0), V(8),V(26),V(35),V(35),V(26), V(8), V(0), // 5
155     V(0), V(4),V(17),V(17),V(17),V(17), V(4), V(0), // 6
156     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 7
157     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0)  // 8
158   };
159
160   const Value BishopOutpostBonus[64] = {
161   //  A     B     C     D     E     F     G     H
162     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 1
163     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 2
164     V(0), V(0), V(5), V(5), V(5), V(5), V(0), V(0), // 3
165     V(0), V(5),V(10),V(10),V(10),V(10), V(5), V(0), // 4
166     V(0),V(10),V(21),V(21),V(21),V(21),V(10), V(0), // 5
167     V(0), V(5), V(8), V(8), V(8), V(8), V(5), V(0), // 6
168     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0), // 7
169     V(0), V(0), V(0), V(0), V(0), V(0), V(0), V(0)  // 8
170   };
171
172   // Bonus for unstoppable passed pawns
173   const Value UnstoppablePawnValue = Value(0x500);
174
175   // Rooks and queens on the 7th rank (modified by Joona Kiiski)
176   const Value MidgameRookOn7thBonus  = Value(47);
177   const Value EndgameRookOn7thBonus  = Value(98);
178   const Value MidgameQueenOn7thBonus = Value(27);
179   const Value EndgameQueenOn7thBonus = Value(54);
180
181   // Rooks on open files (modified by Joona Kiiski)
182   const Value RookOpenFileBonus = Value(43);
183   const Value RookHalfOpenFileBonus = Value(19);
184
185   // Penalty for rooks trapped inside a friendly king which has lost the
186   // right to castle.
187   const Value TrappedRookPenalty = Value(180);
188
189   // Penalty for a bishop on a7/h7 (a2/h2 for black) which is trapped by
190   // enemy pawns.
191   const Value TrappedBishopA7H7Penalty = Value(300);
192
193   // Bitboard masks for detecting trapped bishops on a7/h7 (a2/h2 for black)
194   const Bitboard MaskA7H7[2] = {
195     ((1ULL << SQ_A7) | (1ULL << SQ_H7)),
196     ((1ULL << SQ_A2) | (1ULL << SQ_H2))
197   };
198
199   // Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by
200   // a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
201   // happen in Chess960 games.
202   const Value TrappedBishopA1H1Penalty = Value(100);
203
204   // Bitboard masks for detecting trapped bishops on a1/h1 (a8/h8 for black)
205   const Bitboard MaskA1H1[2] = {
206     ((1ULL << SQ_A1) | (1ULL << SQ_H1)),
207     ((1ULL << SQ_A8) | (1ULL << SQ_H8))
208   };
209
210   // The SpaceMask[color] contains area of the board which is consdered by
211   // the space evaluation. In the middle game, each side is given a bonus
212   // based on how many squares inside this area are safe and available for
213   // friendly minor pieces.
214   const Bitboard SpaceMask[2] = {
215     (1ULL<<SQ_C2) | (1ULL<<SQ_D2) | (1ULL<<SQ_E2) | (1ULL<<SQ_F2) |
216     (1ULL<<SQ_C3) | (1ULL<<SQ_D3) | (1ULL<<SQ_E3) | (1ULL<<SQ_F3) |
217     (1ULL<<SQ_C4) | (1ULL<<SQ_D4) | (1ULL<<SQ_E4) | (1ULL<<SQ_F4),
218     (1ULL<<SQ_C7) | (1ULL<<SQ_D7) | (1ULL<<SQ_E7) | (1ULL<<SQ_F7) |
219     (1ULL<<SQ_C6) | (1ULL<<SQ_D6) | (1ULL<<SQ_E6) | (1ULL<<SQ_F6) |
220     (1ULL<<SQ_C5) | (1ULL<<SQ_D5) | (1ULL<<SQ_E5) | (1ULL<<SQ_F5)
221   };
222
223   /// King safety constants and variables. The king safety scores are taken
224   /// from the array SafetyTable[]. Various little "meta-bonuses" measuring
225   /// the strength of the attack are added up into an integer, which is used
226   /// as an index to SafetyTable[].
227
228   // Attack weights for each piece type
229   const int QueenAttackWeight  = 5;
230   const int RookAttackWeight   = 3;
231   const int BishopAttackWeight = 2;
232   const int KnightAttackWeight = 2;
233
234   // Bonuses for safe checks, initialized from UCI options
235   int QueenContactCheckBonus, DiscoveredCheckBonus;
236   int QueenCheckBonus, RookCheckBonus, BishopCheckBonus, KnightCheckBonus;
237
238   // Scan for queen contact mates?
239   const bool QueenContactMates = true;
240
241   // Bonus for having a mate threat, initialized from UCI options
242   int MateThreatBonus;
243
244   // InitKingDanger[] contains bonuses based on the position of the defending
245   // king.
246   const int InitKingDanger[64] = {
247      2,  0,  2,  5,  5,  2,  0,  2,
248      2,  2,  4,  8,  8,  4,  2,  2,
249      7, 10, 12, 12, 12, 12, 10,  7,
250     15, 15, 15, 15, 15, 15, 15, 15,
251     15, 15, 15, 15, 15, 15, 15, 15,
252     15, 15, 15, 15, 15, 15, 15, 15,
253     15, 15, 15, 15, 15, 15, 15, 15,
254     15, 15, 15, 15, 15, 15, 15, 15
255   };
256
257   // SafetyTable[] contains the actual king safety scores. It is initialized
258   // in init_safety().
259   Value SafetyTable[100];
260
261   // Pawn and material hash tables, indexed by the current thread id
262   PawnInfoTable* PawnTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
263   MaterialInfoTable* MaterialTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
264
265   // Sizes of pawn and material hash tables
266   const int PawnTableSize = 16384;
267   const int MaterialTableSize = 1024;
268
269   // Array which gives the number of nonzero bits in an 8-bit integer
270   uint8_t BitCount8Bit[256];
271
272   // Function prototypes
273   template<bool HasPopCnt>
274   Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID);
275
276   template<PieceType Piece, bool HasPopCnt>
277   void evaluate_pieces(const Position& p, Color us, EvalInfo& ei);
278
279   template<bool HasPopCnt>
280   void evaluate_king(const Position& p, Color us, EvalInfo &ei);
281
282   void evaluate_passed_pawns(const Position &pos, EvalInfo &ei);
283   void evaluate_trapped_bishop_a7h7(const Position &pos, Square s, Color us,
284                                     EvalInfo &ei);
285   void evaluate_trapped_bishop_a1h1(const Position &pos, Square s, Color us,
286                                     EvalInfo &ei);
287   template<bool HasPopCnt>
288   void evaluate_space(const Position &p, Color us, EvalInfo &ei);
289   inline Value apply_weight(Value v, int w);
290   Value scale_by_game_phase(Value mv, Value ev, Phase ph, const ScaleFactor sf[]);
291
292   int compute_weight(int uciWeight, int internalWeight);
293   int weight_option(const std::string& opt, int weight);
294   void init_safety();
295
296 }
297
298
299 ////
300 //// Functions
301 ////
302
303 /// evaluate() is the main evaluation function. It always computes two
304 /// values, an endgame score and a middle game score, and interpolates
305 /// between them based on the remaining material.
306 Value evaluate(const Position& pos, EvalInfo& ei, int threadID) {
307
308     return CpuHasPOPCNT ? do_evaluate<true>(pos, ei, threadID)
309                         : do_evaluate<false>(pos, ei, threadID);
310 }
311
312 namespace {
313
314 template<bool HasPopCnt>
315 Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID) {
316
317   assert(pos.is_ok());
318   assert(threadID >= 0 && threadID < THREAD_MAX);
319
320   memset(&ei, 0, sizeof(EvalInfo));
321
322   // Initialize by reading the incrementally updated scores included in the
323   // position object (material + piece square tables)
324   ei.mgValue = pos.mg_value();
325   ei.egValue = pos.eg_value();
326
327   // Probe the material hash table
328   ei.mi = MaterialTable[threadID]->get_material_info(pos);
329   ei.mgValue += ei.mi->material_value();
330   ei.egValue += ei.mi->material_value();
331
332   // If we have a specialized evaluation function for the current material
333   // configuration, call it and return
334   if (ei.mi->specialized_eval_exists())
335       return ei.mi->evaluate(pos);
336
337   // After get_material_info() call that modifies them
338   ScaleFactor factor[2];
339   factor[WHITE] = ei.mi->scale_factor(pos, WHITE);
340   factor[BLACK] = ei.mi->scale_factor(pos, BLACK);
341
342   // Probe the pawn hash table
343   ei.pi = PawnTable[threadID]->get_pawn_info(pos);
344   ei.mgValue += apply_weight(ei.pi->mg_value(), WeightPawnStructureMidgame);
345   ei.egValue += apply_weight(ei.pi->eg_value(), WeightPawnStructureEndgame);
346
347   // Initialize king attack bitboards and king attack zones for both sides
348   ei.attackedBy[WHITE][KING] = pos.piece_attacks<KING>(pos.king_square(WHITE));
349   ei.attackedBy[BLACK][KING] = pos.piece_attacks<KING>(pos.king_square(BLACK));
350   ei.kingZone[WHITE] = ei.attackedBy[BLACK][KING] | (ei.attackedBy[BLACK][KING] >> 8);
351   ei.kingZone[BLACK] = ei.attackedBy[WHITE][KING] | (ei.attackedBy[WHITE][KING] << 8);
352
353   // Initialize pawn attack bitboards for both sides
354   ei.attackedBy[WHITE][PAWN] = ((pos.pawns(WHITE) << 9) & ~FileABB) | ((pos.pawns(WHITE) << 7) & ~FileHBB);
355   ei.attackedBy[BLACK][PAWN] = ((pos.pawns(BLACK) >> 7) & ~FileABB) | ((pos.pawns(BLACK) >> 9) & ~FileHBB);
356   Bitboard b1 = ei.attackedBy[WHITE][PAWN] & ei.attackedBy[BLACK][KING];
357   Bitboard b2 = ei.attackedBy[BLACK][PAWN] & ei.attackedBy[WHITE][KING];
358   if (b1)
359       ei.kingAttackersCount[WHITE] = count_1s_max_15<HasPopCnt>(b1)/2;
360
361   if (b2)
362       ei.kingAttackersCount[BLACK] = count_1s_max_15<HasPopCnt>(b2)/2;
363
364   // Evaluate pieces
365   for (Color c = WHITE; c <= BLACK; c++)
366   {
367       evaluate_pieces<KNIGHT, HasPopCnt>(pos, c, ei);
368       evaluate_pieces<BISHOP, HasPopCnt>(pos, c, ei);
369       evaluate_pieces<ROOK,   HasPopCnt>(pos, c, ei);
370       evaluate_pieces<QUEEN,  HasPopCnt>(pos, c, ei);
371
372       // Sum up all attacked squares
373       ei.attackedBy[c][0] =   ei.attackedBy[c][PAWN]   | ei.attackedBy[c][KNIGHT]
374                             | ei.attackedBy[c][BISHOP] | ei.attackedBy[c][ROOK]
375                             | ei.attackedBy[c][QUEEN]  | ei.attackedBy[c][KING];
376   }
377
378   // Kings. Kings are evaluated after all other pieces for both sides,
379   // because we need complete attack information for all pieces when computing
380   // the king safety evaluation.
381   for (Color c = WHITE; c <= BLACK; c++)
382       evaluate_king<HasPopCnt>(pos, c, ei);
383
384   // Evaluate passed pawns.  We evaluate passed pawns for both sides at once,
385   // because we need to know which side promotes first in positions where
386   // both sides have an unstoppable passed pawn.
387   if (ei.pi->passed_pawns())
388       evaluate_passed_pawns(pos, ei);
389
390   Phase phase = pos.game_phase();
391
392   // Middle-game specific evaluation terms
393   if (phase > PHASE_ENDGAME)
394   {
395     // Pawn storms in positions with opposite castling.
396     if (   square_file(pos.king_square(WHITE)) >= FILE_E
397         && square_file(pos.king_square(BLACK)) <= FILE_D)
398
399         ei.mgValue += ei.pi->queenside_storm_value(WHITE)
400                     - ei.pi->kingside_storm_value(BLACK);
401
402     else if (   square_file(pos.king_square(WHITE)) <= FILE_D
403              && square_file(pos.king_square(BLACK)) >= FILE_E)
404
405         ei.mgValue += ei.pi->kingside_storm_value(WHITE)
406                     - ei.pi->queenside_storm_value(BLACK);
407
408     // Evaluate space for both sides
409     if (ei.mi->space_weight() > 0)
410     {
411         evaluate_space<HasPopCnt>(pos, WHITE, ei);
412         evaluate_space<HasPopCnt>(pos, BLACK, ei);
413     }
414   }
415
416   // Mobility
417   ei.mgValue += apply_weight(ei.mgMobility, WeightMobilityMidgame);
418   ei.egValue += apply_weight(ei.egMobility, WeightMobilityEndgame);
419
420   // If we don't already have an unusual scale factor, check for opposite
421   // colored bishop endgames, and use a lower scale for those
422   if (   phase < PHASE_MIDGAME
423       && pos.opposite_colored_bishops()
424       && (   (factor[WHITE] == SCALE_FACTOR_NORMAL && ei.egValue > Value(0))
425           || (factor[BLACK] == SCALE_FACTOR_NORMAL && ei.egValue < Value(0))))
426   {
427       ScaleFactor sf;
428
429       // Only the two bishops ?
430       if (   pos.non_pawn_material(WHITE) == BishopValueMidgame
431           && pos.non_pawn_material(BLACK) == BishopValueMidgame)
432       {
433           // Check for KBP vs KB with only a single pawn that is almost
434           // certainly a draw or at least two pawns.
435           bool one_pawn = (pos.piece_count(WHITE, PAWN) + pos.piece_count(BLACK, PAWN) == 1);
436           sf = one_pawn ? ScaleFactor(8) : ScaleFactor(32);
437       }
438       else
439           // Endgame with opposite-colored bishops, but also other pieces. Still
440           // a bit drawish, but not as drawish as with only the two bishops.
441            sf = ScaleFactor(50);
442
443       if (factor[WHITE] == SCALE_FACTOR_NORMAL)
444           factor[WHITE] = sf;
445       if (factor[BLACK] == SCALE_FACTOR_NORMAL)
446           factor[BLACK] = sf;
447   }
448
449   // Interpolate between the middle game and the endgame score, and
450   // return
451   Color stm = pos.side_to_move();
452
453   Value v = Sign[stm] * scale_by_game_phase(ei.mgValue, ei.egValue, phase, factor);
454
455   return (ei.mateThreat[stm] == MOVE_NONE ? v : 8 * QueenValueMidgame - v);
456 }
457
458 } // namespace
459
460 /// quick_evaluate() does a very approximate evaluation of the current position.
461 /// It currently considers only material and piece square table scores.  Perhaps
462 /// we should add scores from the pawn and material hash tables?
463
464 Value quick_evaluate(const Position &pos) {
465
466   assert(pos.is_ok());
467
468   static const
469   ScaleFactor sf[2] = {SCALE_FACTOR_NORMAL, SCALE_FACTOR_NORMAL};
470
471   Value mgv = pos.mg_value();
472   Value egv = pos.eg_value();
473   Phase ph = pos.game_phase();
474   Color stm = pos.side_to_move();
475
476   return Sign[stm] * scale_by_game_phase(mgv, egv, ph, sf);
477 }
478
479
480 /// init_eval() initializes various tables used by the evaluation function.
481
482 void init_eval(int threads) {
483
484   assert(threads <= THREAD_MAX);
485
486   for (int i = 0; i < THREAD_MAX; i++)
487   {
488     if (i >= threads)
489     {
490         delete PawnTable[i];
491         delete MaterialTable[i];
492         PawnTable[i] = NULL;
493         MaterialTable[i] = NULL;
494         continue;
495     }
496     if (!PawnTable[i])
497         PawnTable[i] = new PawnInfoTable(PawnTableSize);
498     if (!MaterialTable[i])
499         MaterialTable[i] = new MaterialInfoTable(MaterialTableSize);
500   }
501
502   for (Bitboard b = 0ULL; b < 256ULL; b++)
503   {
504       assert(count_1s(b) == int(uint8_t(count_1s(b))));
505       BitCount8Bit[b] = (uint8_t)count_1s(b);
506   }
507 }
508
509
510 /// quit_eval() releases heap-allocated memory at program termination.
511
512 void quit_eval() {
513
514   for (int i = 0; i < THREAD_MAX; i++)
515   {
516       delete PawnTable[i];
517       delete MaterialTable[i];
518       PawnTable[i] = NULL;
519       MaterialTable[i] = NULL;
520   }
521 }
522
523
524 /// read_weights() reads evaluation weights from the corresponding UCI
525 /// parameters.
526
527 void read_weights(Color us) {
528
529   WeightMobilityMidgame      = weight_option("Mobility (Middle Game)", WeightMobilityMidgameInternal);
530   WeightMobilityEndgame      = weight_option("Mobility (Endgame)", WeightMobilityEndgameInternal);
531   WeightPawnStructureMidgame = weight_option("Pawn Structure (Middle Game)", WeightPawnStructureMidgameInternal);
532   WeightPawnStructureEndgame = weight_option("Pawn Structure (Endgame)", WeightPawnStructureEndgameInternal);
533   WeightPassedPawnsMidgame   = weight_option("Passed Pawns (Middle Game)", WeightPassedPawnsMidgameInternal);
534   WeightPassedPawnsEndgame   = weight_option("Passed Pawns (Endgame)", WeightPassedPawnsEndgameInternal);
535
536   Color them = opposite_color(us);
537
538   WeightKingSafety[us]   = weight_option("Cowardice", WeightKingSafetyInternal);
539   WeightKingSafety[them] = weight_option("Aggressiveness", WeightKingOppSafetyInternal);
540   // If running in analysis mode, make sure we use symmetrical king safety.
541   // We do this by replacing both WeightKingSafety[us] and 
542   // WeightKingSafety[them] by their average.
543   if (get_option_value_bool("UCI_AnalyseMode")) {
544       WeightKingSafety[us] = (WeightKingSafety[us] + WeightKingSafety[them]) / 2;
545       WeightKingSafety[them] = WeightKingSafety[us];
546   }
547
548   WeightSpace = weight_option("Space", WeightSpaceInternal);
549
550   init_safety();
551 }
552
553
554 namespace {
555
556   // evaluate_mobility() computes mobility and attacks for every piece
557
558   template<PieceType Piece, bool HasPopCnt>
559   int evaluate_mobility(const Position& p, const Bitboard& b, Color us, Color them, EvalInfo& ei) {
560
561     static const int AttackWeight[] = { 0, 0, KnightAttackWeight, BishopAttackWeight, RookAttackWeight, QueenAttackWeight };
562     static const Value* MgBonus[] = { 0, 0, MidgameKnightMobilityBonus, MidgameBishopMobilityBonus, MidgameRookMobilityBonus, MidgameQueenMobilityBonus };
563     static const Value* EgBonus[] = { 0, 0, EndgameKnightMobilityBonus, EndgameBishopMobilityBonus, EndgameRookMobilityBonus, EndgameQueenMobilityBonus };
564
565     // Update attack info
566     ei.attackedBy[us][Piece] |= b;
567
568     // King attacks
569     if (b & ei.kingZone[us])
570     {
571         ei.kingAttackersCount[us]++;
572         ei.kingAttackersWeight[us] += AttackWeight[Piece];
573         Bitboard bb = (b & ei.attackedBy[them][KING]);
574         if (bb)
575             ei.kingAdjacentZoneAttacksCount[us] += count_1s_max_15<HasPopCnt>(bb);
576     }
577
578     // Remove squares protected by enemy pawns
579     Bitboard bb = (b & ~ei.attackedBy[them][PAWN]);
580
581     // Mobility
582     int mob = (Piece != QUEEN ? count_1s_max_15<HasPopCnt>(bb & ~p.pieces_of_color(us))
583                               : count_1s<HasPopCnt>(bb & ~p.pieces_of_color(us)));
584
585     ei.mgMobility += Sign[us] * MgBonus[Piece][mob];
586     ei.egMobility += Sign[us] * EgBonus[Piece][mob];
587     return mob;
588   }
589
590
591   // evaluate_outposts() evaluates bishop and knight outposts squares
592
593   template<PieceType Piece>
594   void evaluate_outposts(const Position& p, Color us, Color them, EvalInfo& ei, Square s) {
595
596     // Initial bonus based on square
597     Value bonus = (Piece == BISHOP ? BishopOutpostBonus[relative_square(us, s)]
598                                    : KnightOutpostBonus[relative_square(us, s)]);
599
600     // Increase bonus if supported by pawn, especially if the opponent has
601     // no minor piece which can exchange the outpost piece
602     if (bonus && (p.pawn_attacks(them, s) & p.pawns(us)))
603     {
604         if (    p.knights(them) == EmptyBoardBB
605             && (SquaresByColorBB[square_color(s)] & p.bishops(them)) == EmptyBoardBB)
606             bonus += bonus + bonus / 2;
607         else
608             bonus += bonus / 2;
609     }
610     ei.mgValue += Sign[us] * bonus;
611     ei.egValue += Sign[us] * bonus;
612   }
613
614
615   // evaluate_pieces<>() assigns bonuses and penalties to the pieces of a given
616   // color.
617
618   template<PieceType Piece, bool HasPopCnt>
619   void evaluate_pieces(const Position& pos, Color us, EvalInfo& ei) {
620
621     Bitboard b;
622     Square s, ksq;
623     int mob;
624     File f;
625     Color them = opposite_color(us);
626
627     for (int i = 0, e = pos.piece_count(us, Piece); i < e; i++)
628     {
629         s = pos.piece_list(us, Piece, i);
630
631         if (Piece == KNIGHT || Piece == QUEEN)
632             b = pos.piece_attacks<Piece>(s);
633         else if (Piece == BISHOP)
634             b = bishop_attacks_bb(s, pos.occupied_squares() & ~pos.queens(us));
635         else if (Piece == ROOK)
636             b = rook_attacks_bb(s, pos.occupied_squares() & ~pos.rooks_and_queens(us));
637         else
638             assert(false);
639
640         // Attacks and mobility
641         mob = evaluate_mobility<Piece, HasPopCnt>(pos, b, us, them, ei);
642
643         // Bishop and knight outposts squares
644         if ((Piece == BISHOP || Piece == KNIGHT) && pos.square_is_weak(s, them))
645             evaluate_outposts<Piece>(pos, us, them, ei, s);
646
647         // Special patterns: trapped bishops on a7/h7/a2/h2
648         // and trapped bishops on a1/h1/a8/h8 in Chess960.
649         if (Piece == BISHOP)
650         {
651             if (bit_is_set(MaskA7H7[us], s))
652                 evaluate_trapped_bishop_a7h7(pos, s, us, ei);
653
654             if (Chess960 && bit_is_set(MaskA1H1[us], s))
655                 evaluate_trapped_bishop_a1h1(pos, s, us, ei);
656         }
657
658         if (Piece == ROOK || Piece == QUEEN)
659         {
660             // Queen or rook on 7th rank
661             if (   relative_rank(us, s) == RANK_7
662                 && relative_rank(us, pos.king_square(them)) == RANK_8)
663             {
664                 ei.mgValue += Sign[us] * (Piece == ROOK ? MidgameRookOn7thBonus : MidgameQueenOn7thBonus);
665                 ei.egValue += Sign[us] * (Piece == ROOK ? EndgameRookOn7thBonus : EndgameQueenOn7thBonus);
666             }
667         }
668
669         // Special extra evaluation for rooks
670         if (Piece == ROOK)
671         {
672             // Open and half-open files
673             f = square_file(s);
674             if (ei.pi->file_is_half_open(us, f))
675             {
676                 if (ei.pi->file_is_half_open(them, f))
677                 {
678                     ei.mgValue += Sign[us] * RookOpenFileBonus;
679                     ei.egValue += Sign[us] * RookOpenFileBonus;
680                 }
681                 else
682                 {
683                     ei.mgValue += Sign[us] * RookHalfOpenFileBonus;
684                     ei.egValue += Sign[us] * RookHalfOpenFileBonus;
685                 }
686             }
687
688             // Penalize rooks which are trapped inside a king. Penalize more if
689             // king has lost right to castle.
690             if (mob > 6 || ei.pi->file_is_half_open(us, f))
691                 continue;
692
693             ksq = pos.king_square(us);
694
695             if (    square_file(ksq) >= FILE_E
696                 &&  square_file(s) > square_file(ksq)
697                 && (relative_rank(us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
698             {
699                 // Is there a half-open file between the king and the edge of the board?
700                 if (!ei.pi->has_open_file_to_right(us, square_file(ksq)))
701                     ei.mgValue -= pos.can_castle(us)? Sign[us] * ((TrappedRookPenalty - mob * 16) / 2)
702                                                     : Sign[us] *  (TrappedRookPenalty - mob * 16);
703             }
704             else if (    square_file(ksq) <= FILE_D
705                     &&  square_file(s) < square_file(ksq)
706                     && (relative_rank(us, ksq) == RANK_1 || square_rank(ksq) == square_rank(s)))
707             {
708                 // Is there a half-open file between the king and the edge of the board?
709                 if (!ei.pi->has_open_file_to_left(us, square_file(ksq)))
710                     ei.mgValue -= pos.can_castle(us)? Sign[us] * ((TrappedRookPenalty - mob * 16) / 2)
711                                                     : Sign[us] * (TrappedRookPenalty - mob * 16);
712             }
713         }
714     }
715   }
716
717   inline Bitboard shiftRowsDown(const Bitboard& b, int num) {
718
719     return b >> (num << 3);
720   }
721
722   // evaluate_king<>() assigns bonuses and penalties to a king of a given color.
723
724   template<bool HasPopCnt>
725   void evaluate_king(const Position& p, Color us, EvalInfo& ei) {
726
727     int shelter = 0, sign = Sign[us];
728     Square s = p.king_square(us);
729
730     // King shelter
731     if (relative_rank(us, s) <= RANK_4)
732     {
733         // Shelter cache lookup
734         shelter = ei.pi->kingShelter(us, s);
735         if (shelter == -1)
736         {
737             shelter = 0;
738             Bitboard pawns = p.pawns(us) & this_and_neighboring_files_bb(s);
739             Rank r = square_rank(s);
740             for (int i = 1; i < 4; i++)
741                 shelter += BitCount8Bit[shiftRowsDown(pawns, r+i*sign) & 0xFF] * (128 >> i);
742
743             // Cache shelter value in pawn info
744             ei.pi->setKingShelter(us, s, shelter);
745         }
746         ei.mgValue += sign * Value(shelter);
747     }
748
749     // King safety. This is quite complicated, and is almost certainly far
750     // from optimally tuned.
751     Color them = opposite_color(us);
752
753     if (   p.piece_count(them, QUEEN) >= 1
754         && ei.kingAttackersCount[them] >= 2
755         && p.non_pawn_material(them) >= QueenValueMidgame + RookValueMidgame
756         && ei.kingAdjacentZoneAttacksCount[them])
757     {
758       // Is it the attackers turn to move?
759       bool sente = (them == p.side_to_move());
760
761       // Find the attacked squares around the king which has no defenders
762       // apart from the king itself
763       Bitboard undefended =
764              ei.attacked_by(them)       & ~ei.attacked_by(us, PAWN)
765           & ~ei.attacked_by(us, KNIGHT) & ~ei.attacked_by(us, BISHOP)
766           & ~ei.attacked_by(us, ROOK)   & ~ei.attacked_by(us, QUEEN)
767           & ei.attacked_by(us, KING);
768
769       Bitboard occ = p.occupied_squares(), b, b2;
770
771       // Initialize the 'attackUnits' variable, which is used later on as an
772       // index to the SafetyTable[] array.  The initial value is based on the
773       // number and types of the attacking pieces, the number of attacked and
774       // undefended squares around the king, the square of the king, and the
775       // quality of the pawn shelter.
776       int attackUnits =
777             Min((ei.kingAttackersCount[them] * ei.kingAttackersWeight[them]) / 2, 25)
778           + (ei.kingAdjacentZoneAttacksCount[them] + count_1s_max_15<HasPopCnt>(undefended)) * 3
779           + InitKingDanger[relative_square(us, s)] - (shelter >> 5);
780
781       // Analyse safe queen contact checks
782       b = undefended & ei.attacked_by(them, QUEEN) & ~p.pieces_of_color(them);
783       if (b)
784       {
785         Bitboard attackedByOthers =
786               ei.attacked_by(them, PAWN)   | ei.attacked_by(them, KNIGHT)
787             | ei.attacked_by(them, BISHOP) | ei.attacked_by(them, ROOK);
788
789         b &= attackedByOthers;
790         if (b)
791         {
792           // The bitboard b now contains the squares available for safe queen
793           // contact checks.
794           int count = count_1s_max_15<HasPopCnt>(b);
795           attackUnits += QueenContactCheckBonus * count * (sente ? 2 : 1);
796
797           // Is there a mate threat?
798           if (QueenContactMates && !p.is_check())
799           {
800             Bitboard escapeSquares =
801                 p.piece_attacks<KING>(s) & ~p.pieces_of_color(us) & ~attackedByOthers;
802
803             while (b)
804             {
805                 Square from, to = pop_1st_bit(&b);
806                 if (!(escapeSquares & ~queen_attacks_bb(to, occ & ClearMaskBB[s])))
807                 {
808                     // We have a mate, unless the queen is pinned or there
809                     // is an X-ray attack through the queen.
810                     for (int i = 0; i < p.piece_count(them, QUEEN); i++)
811                     {
812                         from = p.piece_list(them, QUEEN, i);
813                         if (    bit_is_set(p.piece_attacks<QUEEN>(from), to)
814                             && !bit_is_set(p.pinned_pieces(them), from)
815                             && !(rook_attacks_bb(to, occ & ClearMaskBB[from]) & p.rooks_and_queens(us))
816                             && !(bishop_attacks_bb(to, occ & ClearMaskBB[from]) & p.bishops_and_queens(us)))
817
818                             ei.mateThreat[them] = make_move(from, to);
819                     }
820                 }
821             }
822           }
823         }
824       }
825
826       // Analyse safe distance checks
827       if (QueenCheckBonus > 0 || RookCheckBonus > 0)
828       {
829           b = p.piece_attacks<ROOK>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
830
831           // Queen checks
832           b2 = b & ei.attacked_by(them, QUEEN);
833           if( b2)
834               attackUnits += QueenCheckBonus * count_1s_max_15<HasPopCnt>(b2);
835
836           // Rook checks
837           b2 = b & ei.attacked_by(them, ROOK);
838           if (b2)
839               attackUnits += RookCheckBonus * count_1s_max_15<HasPopCnt>(b2);
840       }
841       if (QueenCheckBonus > 0 || BishopCheckBonus > 0)
842       {
843           b = p.piece_attacks<BISHOP>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
844
845           // Queen checks
846           b2 = b & ei.attacked_by(them, QUEEN);
847           if (b2)
848               attackUnits += QueenCheckBonus * count_1s_max_15<HasPopCnt>(b2);
849
850           // Bishop checks
851           b2 = b & ei.attacked_by(them, BISHOP);
852           if (b2)
853               attackUnits += BishopCheckBonus * count_1s_max_15<HasPopCnt>(b2);
854       }
855       if (KnightCheckBonus > 0)
856       {
857           b = p.piece_attacks<KNIGHT>(s) & ~p.pieces_of_color(them) & ~ei.attacked_by(us);
858
859           // Knight checks
860           b2 = b & ei.attacked_by(them, KNIGHT);
861           if (b2)
862               attackUnits += KnightCheckBonus * count_1s_max_15<HasPopCnt>(b2);
863       }
864
865       // Analyse discovered checks (only for non-pawns right now, consider
866       // adding pawns later).
867       if (DiscoveredCheckBonus)
868       {
869         b = p.discovered_check_candidates(them) & ~p.pawns();
870         if (b)
871           attackUnits += DiscoveredCheckBonus * count_1s_max_15<HasPopCnt>(b) * (sente? 2 : 1);
872       }
873
874       // Has a mate threat been found?  We don't do anything here if the
875       // side with the mating move is the side to move, because in that
876       // case the mating side will get a huge bonus at the end of the main
877       // evaluation function instead.
878       if (ei.mateThreat[them] != MOVE_NONE)
879           attackUnits += MateThreatBonus;
880
881       // Ensure that attackUnits is between 0 and 99, in order to avoid array
882       // out of bounds errors:
883       if (attackUnits < 0)
884           attackUnits = 0;
885
886       if (attackUnits >= 100)
887           attackUnits = 99;
888
889       // Finally, extract the king safety score from the SafetyTable[] array.
890       // Add the score to the evaluation, and also to ei.futilityMargin.  The
891       // reason for adding the king safety score to the futility margin is
892       // that the king safety scores can sometimes be very big, and that
893       // capturing a single attacking piece can therefore result in a score
894       // change far bigger than the value of the captured piece.
895       Value v = apply_weight(SafetyTable[attackUnits], WeightKingSafety[us]);
896
897       ei.mgValue -= sign * v;
898
899       if (us == p.side_to_move())
900           ei.futilityMargin += v;
901     }
902   }
903
904
905   // evaluate_passed_pawns() evaluates the passed pawns for both sides.
906
907   void evaluate_passed_pawns(const Position &pos, EvalInfo &ei) {
908
909     bool hasUnstoppable[2] = {false, false};
910     int movesToGo[2] = {100, 100};
911
912     for (Color us = WHITE; us <= BLACK; us++)
913     {
914         Color them = opposite_color(us);
915         Square ourKingSq = pos.king_square(us);
916         Square theirKingSq = pos.king_square(them);
917         Bitboard b = ei.pi->passed_pawns() & pos.pawns(us), b2, b3, b4;
918
919         while (b)
920         {
921             Square s = pop_1st_bit(&b);
922
923             assert(pos.piece_on(s) == piece_of_color_and_type(us, PAWN));
924             assert(pos.pawn_is_passed(us, s));
925
926             int r = int(relative_rank(us, s) - RANK_2);
927             int tr = Max(0, r * (r - 1));
928             Square blockSq = s + pawn_push(us);
929
930             // Base bonus based on rank
931             Value mbonus = Value(20 * tr);
932             Value ebonus = Value(10 + r * r * 10);
933
934             // Adjust bonus based on king proximity
935             if (tr != 0)
936             {
937                 ebonus -= Value(square_distance(ourKingSq, blockSq) * 3 * tr);
938                 ebonus -= Value(square_distance(ourKingSq, blockSq + pawn_push(us)) * 1 * tr);
939                 ebonus += Value(square_distance(theirKingSq, blockSq) * 6 * tr);
940
941                 // If the pawn is free to advance, increase bonus
942                 if (pos.square_is_empty(blockSq))
943                 {
944                     b2 = squares_in_front_of(us, s);
945                     b3 = b2 & ei.attacked_by(them);
946                     b4 = b2 & ei.attacked_by(us);
947
948                     // If there is an enemy rook or queen attacking the pawn from behind,
949                     // add all X-ray attacks by the rook or queen.
950                     if (    bit_is_set(ei.attacked_by(them,ROOK) | ei.attacked_by(them,QUEEN),s)
951                         && (squares_behind(us, s) & pos.rooks_and_queens(them)))
952                         b3 = b2;
953
954                     // Squares attacked or occupied by enemy pieces
955                     b3 |= (b2 & pos.pieces_of_color(them));
956
957                     // There are no enemy pawns in the pawn's path
958                     assert((b2 & pos.pieces_of_color_and_type(them, PAWN)) == EmptyBoardBB);
959
960                     // Are any of the squares in the pawn's path attacked or occupied by the enemy?
961                     if (b3 == EmptyBoardBB)
962                         // No enemy attacks or pieces, huge bonus!
963                         ebonus += Value(tr * (b2 == b4 ? 17 : 15));
964                     else
965                         // OK, there are enemy attacks or pieces (but not pawns). Are those
966                         // squares which are attacked by the enemy also attacked by us?
967                         // If yes, big bonus (but smaller than when there are no enemy attacks),
968                         // if no, somewhat smaller bonus.
969                         ebonus += Value(tr * ((b3 & b4) == b3 ? 13 : 8));
970
971                     // At last, add a small bonus when there are no *friendly* pieces
972                     // in the pawn's path.
973                     if ((b2 & pos.pieces_of_color(us)) == EmptyBoardBB)
974                         ebonus += Value(tr);
975                 }
976             }
977
978             // If the pawn is supported by a friendly pawn, increase bonus
979             b2 = pos.pawns(us) & neighboring_files_bb(s);
980             if (b2 & rank_bb(s))
981                 ebonus += Value(r * 20);
982             else if (pos.pawn_attacks(them, s) & b2)
983                 ebonus += Value(r * 12);
984
985             // If the other side has only a king, check whether the pawn is
986             // unstoppable
987             if (pos.non_pawn_material(them) == Value(0))
988             {
989                 Square qsq;
990                 int d;
991
992                 qsq = relative_square(us, make_square(square_file(s), RANK_8));
993                 d =  square_distance(s, qsq)
994                    - square_distance(theirKingSq, qsq)
995                    + (us != pos.side_to_move());
996
997                 if (d < 0)
998                 {
999                     int mtg = RANK_8 - relative_rank(us, s);
1000                     int blockerCount = count_1s_max_15(squares_in_front_of(us,s) & pos.occupied_squares());
1001                     mtg += blockerCount;
1002                     d += blockerCount;
1003                     if (d < 0)
1004                     {
1005                         hasUnstoppable[us] = true;
1006                         movesToGo[us] = Min(movesToGo[us], mtg);
1007                     }
1008                 }
1009             }
1010             // Rook pawns are a special case: They are sometimes worse, and
1011             // sometimes better than other passed pawns. It is difficult to find
1012             // good rules for determining whether they are good or bad. For now,
1013             // we try the following: Increase the value for rook pawns if the
1014             // other side has no pieces apart from a knight, and decrease the
1015             // value if the other side has a rook or queen.
1016             if (square_file(s) == FILE_A || square_file(s) == FILE_H)
1017             {
1018                 if (   pos.non_pawn_material(them) <= KnightValueMidgame
1019                     && pos.piece_count(them, KNIGHT) <= 1)
1020                     ebonus += ebonus / 4;
1021                 else if (pos.rooks_and_queens(them))
1022                     ebonus -= ebonus / 4;
1023             }
1024
1025             // Add the scores for this pawn to the middle game and endgame eval.
1026             ei.mgValue += apply_weight(Sign[us] * mbonus, WeightPassedPawnsMidgame);
1027             ei.egValue += apply_weight(Sign[us] * ebonus, WeightPassedPawnsEndgame);
1028         }
1029     }
1030
1031     // Does either side have an unstoppable passed pawn?
1032     if (hasUnstoppable[WHITE] && !hasUnstoppable[BLACK])
1033         ei.egValue += UnstoppablePawnValue - Value(0x40 * movesToGo[WHITE]);
1034     else if (hasUnstoppable[BLACK] && !hasUnstoppable[WHITE])
1035         ei.egValue -= UnstoppablePawnValue - Value(0x40 * movesToGo[BLACK]);
1036     else if (hasUnstoppable[BLACK] && hasUnstoppable[WHITE])
1037     {
1038         // Both sides have unstoppable pawns! Try to find out who queens
1039         // first. We begin by transforming 'movesToGo' to the number of
1040         // plies until the pawn queens for both sides.
1041         movesToGo[WHITE] *= 2;
1042         movesToGo[BLACK] *= 2;
1043         movesToGo[pos.side_to_move()]--;
1044
1045         // If one side queens at least three plies before the other, that
1046         // side wins.
1047         if (movesToGo[WHITE] <= movesToGo[BLACK] - 3)
1048             ei.egValue += UnstoppablePawnValue - Value(0x40 * (movesToGo[WHITE]/2));
1049         else if(movesToGo[BLACK] <= movesToGo[WHITE] - 3)
1050             ei.egValue -= UnstoppablePawnValue - Value(0x40 * (movesToGo[BLACK]/2));
1051
1052         // We could also add some rules about the situation when one side
1053         // queens exactly one ply before the other: Does the first queen
1054         // check the opponent's king, or attack the opponent's queening square?
1055         // This is slightly tricky to get right, because it is possible that
1056         // the opponent's king has moved somewhere before the first pawn queens.
1057     }
1058   }
1059
1060
1061   // evaluate_trapped_bishop_a7h7() determines whether a bishop on a7/h7
1062   // (a2/h2 for black) is trapped by enemy pawns, and assigns a penalty
1063   // if it is.
1064
1065   void evaluate_trapped_bishop_a7h7(const Position &pos, Square s, Color us,
1066                                     EvalInfo &ei) {
1067     assert(square_is_ok(s));
1068     assert(pos.piece_on(s) == piece_of_color_and_type(us, BISHOP));
1069
1070     Square b6 = relative_square(us, (square_file(s) == FILE_A) ? SQ_B6 : SQ_G6);
1071     Square b8 = relative_square(us, (square_file(s) == FILE_A) ? SQ_B8 : SQ_G8);
1072
1073     if (   pos.piece_on(b6) == piece_of_color_and_type(opposite_color(us), PAWN)
1074         && pos.see(s, b6) < 0
1075         && pos.see(s, b8) < 0)
1076     {
1077         ei.mgValue -= Sign[us] * TrappedBishopA7H7Penalty;
1078         ei.egValue -= Sign[us] * TrappedBishopA7H7Penalty;
1079     }
1080   }
1081
1082
1083   // evaluate_trapped_bishop_a1h1() determines whether a bishop on a1/h1
1084   // (a8/h8 for black) is trapped by a friendly pawn on b2/g2 (b7/g7 for
1085   // black), and assigns a penalty if it is.  This pattern can obviously
1086   // only occur in Chess960 games.
1087
1088   void evaluate_trapped_bishop_a1h1(const Position &pos, Square s, Color us,
1089                                     EvalInfo &ei) {
1090     Piece pawn = piece_of_color_and_type(us, PAWN);
1091     Square b2, b3, c3;
1092
1093     assert(Chess960);
1094     assert(square_is_ok(s));
1095     assert(pos.piece_on(s) == piece_of_color_and_type(us, BISHOP));
1096
1097     if (square_file(s) == FILE_A)
1098     {
1099         b2 = relative_square(us, SQ_B2);
1100         b3 = relative_square(us, SQ_B3);
1101         c3 = relative_square(us, SQ_C3);
1102     }
1103     else
1104     {
1105         b2 = relative_square(us, SQ_G2);
1106         b3 = relative_square(us, SQ_G3);
1107         c3 = relative_square(us, SQ_F3);
1108     }
1109
1110     if (pos.piece_on(b2) == pawn)
1111     {
1112         Value penalty;
1113
1114         if (!pos.square_is_empty(b3))
1115             penalty = 2*TrappedBishopA1H1Penalty;
1116         else if (pos.piece_on(c3) == pawn)
1117             penalty = TrappedBishopA1H1Penalty;
1118         else
1119             penalty = TrappedBishopA1H1Penalty / 2;
1120
1121         ei.mgValue -= Sign[us] * penalty;
1122         ei.egValue -= Sign[us] * penalty;
1123     }
1124   }
1125
1126
1127   // evaluate_space() computes the space evaluation for a given side. The
1128   // space evaluation is a simple bonus based on the number of safe squares
1129   // available for minor pieces on the central four files on ranks 2--4. Safe
1130   // squares one, two or three squares behind a friendly pawn are counted
1131   // twice. Finally, the space bonus is scaled by a weight taken from the
1132   // material hash table.
1133   template<bool HasPopCnt>
1134   void evaluate_space(const Position &pos, Color us, EvalInfo &ei) {
1135
1136     Color them = opposite_color(us);
1137
1138     // Find the safe squares for our pieces inside the area defined by
1139     // SpaceMask[us]. A square is unsafe it is attacked by an enemy
1140     // pawn, or if it is undefended and attacked by an enemy piece.
1141
1142     Bitboard safeSquares =   SpaceMask[us]
1143                           & ~pos.pawns(us)
1144                           & ~ei.attacked_by(them, PAWN)
1145                           & ~(~ei.attacked_by(us) & ei.attacked_by(them));
1146
1147     // Find all squares which are at most three squares behind some friendly
1148     // pawn.
1149     Bitboard behindFriendlyPawns = pos.pawns(us);
1150     if (us == WHITE)
1151     {
1152         behindFriendlyPawns |= (behindFriendlyPawns >> 8);
1153         behindFriendlyPawns |= (behindFriendlyPawns >> 16);
1154     }
1155     else
1156     {
1157         behindFriendlyPawns |= (behindFriendlyPawns << 8);
1158         behindFriendlyPawns |= (behindFriendlyPawns << 16);
1159     }
1160
1161     int space =  count_1s_max_15<HasPopCnt>(safeSquares)
1162                + count_1s_max_15<HasPopCnt>(behindFriendlyPawns & safeSquares);
1163
1164     ei.mgValue += Sign[us] * apply_weight(Value(space * ei.mi->space_weight()), WeightSpace);
1165   }
1166
1167
1168   // apply_weight() applies an evaluation weight to a value
1169
1170   inline Value apply_weight(Value v, int w) {
1171     return (v*w) / 0x100;
1172   }
1173
1174
1175   // scale_by_game_phase() interpolates between a middle game and an endgame
1176   // score, based on game phase.  It also scales the return value by a
1177   // ScaleFactor array.
1178
1179   Value scale_by_game_phase(Value mv, Value ev, Phase ph, const ScaleFactor sf[]) {
1180
1181     assert(mv > -VALUE_INFINITE && mv < VALUE_INFINITE);
1182     assert(ev > -VALUE_INFINITE && ev < VALUE_INFINITE);
1183     assert(ph >= PHASE_ENDGAME && ph <= PHASE_MIDGAME);
1184
1185     ev = apply_scale_factor(ev, sf[(ev > Value(0) ? WHITE : BLACK)]);
1186
1187     Value result = Value(int((mv * ph + ev * (128 - ph)) / 128));
1188     return Value(int(result) & ~(GrainSize - 1));
1189   }
1190
1191
1192   // compute_weight() computes the value of an evaluation weight, by combining
1193   // an UCI-configurable weight with an internal weight.
1194
1195   int compute_weight(int uciWeight, int internalWeight) {
1196
1197     uciWeight = (uciWeight * 0x100) / 100;
1198     return (uciWeight * internalWeight) / 0x100;
1199   }
1200
1201
1202   // helper used in read_weights()
1203   int weight_option(const std::string& opt, int weight) {
1204
1205     return compute_weight(get_option_value_int(opt), weight);
1206   }
1207
1208
1209   // init_safety() initizes the king safety evaluation, based on UCI
1210   // parameters.  It is called from read_weights().
1211
1212   void init_safety() {
1213
1214     QueenContactCheckBonus = get_option_value_int("Queen Contact Check Bonus");
1215     QueenCheckBonus        = get_option_value_int("Queen Check Bonus");
1216     RookCheckBonus         = get_option_value_int("Rook Check Bonus");
1217     BishopCheckBonus       = get_option_value_int("Bishop Check Bonus");
1218     KnightCheckBonus       = get_option_value_int("Knight Check Bonus");
1219     DiscoveredCheckBonus   = get_option_value_int("Discovered Check Bonus");
1220     MateThreatBonus        = get_option_value_int("Mate Threat Bonus");
1221
1222     int maxSlope = get_option_value_int("King Safety Max Slope");
1223     int peak     = get_option_value_int("King Safety Max Value") * 256 / 100;
1224     double a     = get_option_value_int("King Safety Coefficient") / 100.0;
1225     double b     = get_option_value_int("King Safety X Intercept");
1226     bool quad    = (get_option_value_string("King Safety Curve") == "Quadratic");
1227     bool linear  = (get_option_value_string("King Safety Curve") == "Linear");
1228
1229     for (int i = 0; i < 100; i++)
1230     {
1231         if (i < b)
1232             SafetyTable[i] = Value(0);
1233         else if(quad)
1234             SafetyTable[i] = Value((int)(a * (i - b) * (i - b)));
1235         else if(linear)
1236             SafetyTable[i] = Value((int)(100 * a * (i - b)));
1237     }
1238
1239     for (int i = 0; i < 100; i++)
1240     {
1241         if (SafetyTable[i+1] - SafetyTable[i] > maxSlope)
1242             for (int j = i + 1; j < 100; j++)
1243                 SafetyTable[j] = SafetyTable[j-1] + Value(maxSlope);
1244
1245         if (SafetyTable[i]  > Value(peak))
1246             SafetyTable[i] = Value(peak);
1247     }
1248   }
1249 }