Micro optimize pretty_pv
[stockfish] / src / san.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 #include <iomanip>
28 #include <string>
29 #include <sstream>
30
31 #include "history.h"
32 #include "movepick.h"
33 #include "san.h"
34
35 using std::string;
36
37 ////
38 //// Local definitions
39 ////
40
41 namespace {
42
43   enum Ambiguity {
44     AMBIGUITY_NONE,
45     AMBIGUITY_FILE,
46     AMBIGUITY_RANK,
47     AMBIGUITY_BOTH
48   };
49
50   const History H; // used as dummy argument for MovePicker c'tor
51
52   Ambiguity move_ambiguity(const Position& pos, Move m);
53   const string time_string(int milliseconds);
54   const string score_string(Value v);
55 }
56
57
58 ////
59 //// Functions
60 ////
61
62 /// move_to_san() takes a position and a move as input, where it is assumed
63 /// that the move is a legal move from the position. The return value is
64 /// a string containing the move in short algebraic notation.
65
66 const string move_to_san(const Position& pos, Move m) {
67
68   assert(pos.is_ok());
69   assert(move_is_ok(m));
70
71   Square from, to;
72   PieceType pt;
73
74   from = move_from(m);
75   to = move_to(m);
76   pt = type_of_piece(pos.piece_on(move_from(m)));
77
78   string san = "";
79
80   if (m == MOVE_NONE)
81       return "(none)";
82   else if (m == MOVE_NULL)
83       return "(null)";
84   else if (move_is_long_castle(m) || (int(to - from) == -2 && pt == KING))
85       san = "O-O-O";
86   else if (move_is_short_castle(m) || (int(to - from) == 2 && pt == KING))
87       san = "O-O";
88   else
89   {
90       if (pt != PAWN)
91       {
92           san += piece_type_to_char(pt, true);
93           switch (move_ambiguity(pos, m)) {
94           case AMBIGUITY_NONE:
95             break;
96           case AMBIGUITY_FILE:
97             san += file_to_char(square_file(from));
98             break;
99           case AMBIGUITY_RANK:
100             san += rank_to_char(square_rank(from));
101             break;
102           case AMBIGUITY_BOTH:
103             san += square_to_string(from);
104             break;
105           default:
106             assert(false);
107           }
108       }
109       if (pos.move_is_capture(m))
110       {
111           if (pt == PAWN)
112               san += file_to_char(square_file(move_from(m)));
113           san += "x";
114       }
115       san += square_to_string(move_to(m));
116       if (move_promotion(m))
117       {
118           san += '=';
119           san += piece_type_to_char(move_promotion(m), true);
120       }
121   }
122   // Is the move check?  We don't use pos.move_is_check(m) here, because
123   // Position::move_is_check doesn't detect all checks (not castling moves,
124   // promotions and en passant captures).
125   StateInfo st;
126   Position p(pos);
127   p.do_move(m, st);
128   if (p.is_check())
129       san += p.is_mate()? "#" : "+";
130
131   return san;
132 }
133
134
135 /// move_from_san() takes a position and a string as input, and tries to
136 /// interpret the string as a move in short algebraic notation. On success,
137 /// the move is returned.  On failure (i.e. if the string is unparsable, or
138 /// if the move is illegal or ambiguous), MOVE_NONE is returned.
139
140 Move move_from_san(const Position& pos, const string& movestr) {
141
142   assert(pos.is_ok());
143
144   MovePicker mp = MovePicker(pos, false, MOVE_NONE, OnePly, H);
145
146   // Castling moves
147   if (movestr == "O-O-O" || movestr == "O-O-O+")
148   {
149       Move m;
150       while ((m = mp.get_next_move()) != MOVE_NONE)
151           if (move_is_long_castle(m) && pos.pl_move_is_legal(m))
152               return m;
153
154       return MOVE_NONE;
155   }
156   else if (movestr == "O-O" || movestr == "O-O+")
157   {
158       Move m;
159       while ((m = mp.get_next_move()) != MOVE_NONE)
160           if (move_is_short_castle(m) && pos.pl_move_is_legal(m))
161               return m;
162
163     return MOVE_NONE;
164   }
165
166   // Normal moves. We use a simple FSM to parse the san string.
167   enum { START, TO_FILE, TO_RANK, PROMOTION_OR_CHECK, PROMOTION, CHECK, END };
168   static const string pieceLetters = "KQRBN";
169   PieceType pt = NO_PIECE_TYPE, promotion = NO_PIECE_TYPE;
170   File fromFile = FILE_NONE, toFile = FILE_NONE;
171   Rank fromRank = RANK_NONE, toRank = RANK_NONE;
172   Square to;
173   int state = START;
174
175   for (size_t i = 0; i < movestr.length(); i++)
176   {
177       char type, c = movestr[i];
178       if (pieceLetters.find(c) != string::npos)
179           type = 'P';
180       else if (c >= 'a' && c <= 'h')
181           type = 'F';
182       else if (c >= '1' && c <= '8')
183           type = 'R';
184       else
185           type = c;
186
187       switch (type) {
188       case 'P':
189           if (state == START)
190           {
191               pt = piece_type_from_char(c);
192               state = TO_FILE;
193           }
194           else if (state == PROMOTION)
195           {
196               promotion = piece_type_from_char(c);
197               state = (i < movestr.length() - 1) ? CHECK : END;
198           }
199           else
200               return MOVE_NONE;
201           break;
202       case 'F':
203           if (state == START)
204           {
205               pt = PAWN;
206               fromFile = toFile = file_from_char(c);
207               state = TO_RANK;
208           }
209           else if (state == TO_FILE)
210           {
211               toFile = file_from_char(c);
212               state = TO_RANK;
213           }
214           else if (state == TO_RANK && toFile != FILE_NONE)
215           {
216               // Previous file was for disambiguation
217               fromFile = toFile;
218               toFile = file_from_char(c);
219           }
220           else
221               return MOVE_NONE;
222           break;
223       case 'R':
224           if (state == TO_RANK)
225           {
226               toRank = rank_from_char(c);
227               state = (i < movestr.length() - 1) ? PROMOTION_OR_CHECK : END;
228           }
229           else if (state == TO_FILE && fromRank == RANK_NONE)
230           {
231               // It's a disambiguation rank instead of a file
232               fromRank = rank_from_char(c);
233           }
234           else
235               return MOVE_NONE;
236           break;
237       case 'x': case 'X':
238           if (state == TO_RANK)
239           {
240               // Previous file was for disambiguation, or it's a pawn capture
241               fromFile = toFile;
242               state = TO_FILE;
243           }
244           else if (state != TO_FILE)
245               return MOVE_NONE;
246           break;
247       case '=':
248           if (state == PROMOTION_OR_CHECK)
249               state = PROMOTION;
250           else
251               return MOVE_NONE;
252           break;
253       case '+': case '#':
254           if (state == PROMOTION_OR_CHECK || state == CHECK)
255               state = END;
256           else
257               return MOVE_NONE;
258           break;
259       default:
260           return MOVE_NONE;
261           break;
262       }
263   }
264
265   if (state != END)
266       return MOVE_NONE;
267
268   // Look for a matching move
269   Move m, move = MOVE_NONE;
270   to = make_square(toFile, toRank);
271   int matches = 0;
272
273   while ((m = mp.get_next_move()) != MOVE_NONE)
274       if (   pos.type_of_piece_on(move_from(m)) == pt
275           && move_to(m) == to
276           && move_promotion(m) == promotion
277           && (fromFile == FILE_NONE || fromFile == square_file(move_from(m)))
278           && (fromRank == RANK_NONE || fromRank == square_rank(move_from(m))))
279       {
280           move = m;
281           matches++;
282       }
283   return (matches == 1 ? move : MOVE_NONE);
284 }
285
286
287 /// line_to_san() takes a position and a line (an array of moves representing
288 /// a sequence of legal moves from the position) as input, and returns a
289 /// string containing the line in short algebraic notation.  If the boolean
290 /// parameter 'breakLines' is true, line breaks are inserted, with a line
291 /// length of 80 characters.  After a line break, 'startColumn' spaces are
292 /// inserted at the beginning of the new line.
293
294 const string line_to_san(const Position& pos, Move line[], int startColumn, bool breakLines) {
295
296   StateInfo st;
297   std::stringstream s;
298   string moveStr;
299   size_t length = 0;
300   size_t maxLength = 80 - startColumn;
301   Position p(pos);
302
303   for (int i = 0; line[i] != MOVE_NONE; i++)
304   {
305       moveStr = move_to_san(p, line[i]);
306       length += moveStr.length() + 1;
307       if (breakLines && length > maxLength)
308       {
309           s << '\n' << std::setw(startColumn) << ' ';
310           length = moveStr.length() + 1;
311       }
312       s << moveStr << ' ';
313
314       if (line[i] == MOVE_NULL)
315           p.do_null_move(st);
316       else
317           p.do_move(line[i], st);
318   }
319   return s.str();
320 }
321
322
323 /// pretty_pv() creates a human-readable string from a position and a PV.
324 /// It is used to write search information to the log file (which is created
325 /// when the UCI parameter "Use Search Log" is "true").
326
327 const string pretty_pv(const Position& pos, int time, int depth,
328                        uint64_t nodes, Value score, Move pv[]) {
329   std::stringstream s;
330
331   // Depth
332   s << std::setw(2) << depth << "  ";
333
334   // Score
335   s << std::setw(8) << score_string(score);
336
337   // Time
338   s << std::setw(8) << time_string(time) << " ";
339
340   // Nodes
341   if (nodes < 1000000ULL)
342     s << std::setw(8) << nodes << " ";
343   else if (nodes < 1000000000ULL)
344     s << std::setw(7) << nodes/1000ULL << 'k' << " ";
345   else
346     s << std::setw(7) << nodes/1000000ULL << 'M' << " ";
347
348   // PV
349   s << line_to_san(pos, pv, 30, true);
350
351   return s.str();
352 }
353
354
355 namespace {
356
357   Ambiguity move_ambiguity(const Position& pos, Move m) {
358
359     Square from = move_from(m);
360     Square to = move_to(m);
361     Piece pc = pos.piece_on(from);
362
363     // King moves are never ambiguous, because there is never two kings of
364     // the same color.
365     if (type_of_piece(pc) == KING)
366         return AMBIGUITY_NONE;
367
368     MovePicker mp = MovePicker(pos, false, MOVE_NONE, OnePly, H);
369     Move mv, moveList[8];
370
371     int n = 0;
372     while ((mv = mp.get_next_move()) != MOVE_NONE)
373         if (move_to(mv) == to && pos.piece_on(move_from(mv)) == pc && pos.pl_move_is_legal(mv))
374             moveList[n++] = mv;
375
376     if (n == 1)
377         return AMBIGUITY_NONE;
378
379     int f = 0, r = 0;
380     for (int i = 0; i < n; i++)
381     {
382         if (square_file(move_from(moveList[i])) == square_file(from))
383             f++;
384
385         if (square_rank(move_from(moveList[i])) == square_rank(from))
386             r++;
387     }
388     if (f == 1)
389         return AMBIGUITY_FILE;
390
391     if (r == 1)
392         return AMBIGUITY_RANK;
393
394     return AMBIGUITY_BOTH;
395   }
396
397
398   const string time_string(int milliseconds) {
399
400     std::stringstream s;
401     s << std::setfill('0');
402
403     int hours = milliseconds / (1000*60*60);
404     int minutes = (milliseconds - hours*1000*60*60) / (1000*60);
405     int seconds = (milliseconds - hours*1000*60*60 - minutes*1000*60) / 1000;
406
407     if (hours)
408         s << hours << ':';
409
410     s << std::setw(2) << minutes << ':' << std::setw(2) << seconds;
411     return s.str();
412   }
413
414
415   const string score_string(Value v) {
416
417     std::stringstream s;
418
419     if (v >= VALUE_MATE - 200)
420         s << "#" << (VALUE_MATE - v + 1) / 2;
421     else if(v <= -VALUE_MATE + 200)
422         s << "-#" << (VALUE_MATE + v) / 2;
423     else
424     {
425         float floatScore = float(v) / float(PawnValueMidgame);
426         if (v >= 0)
427             s << '+';
428
429         s << std::setprecision(2) << std::fixed << floatScore;
430     }
431     return s.str();
432   }
433 }