QSEARCH_RECAPTURES, QRECAPTURES
};
- // Our insertion sort, which is guaranteed to be stable, as it should be
- void insertion_sort(ExtMove* begin, ExtMove* end)
- {
- ExtMove tmp, *p, *q;
-
- for (p = begin + 1; p < end; ++p)
- {
- tmp = *p;
- for (q = p; q != begin && *(q-1) < tmp; --q)
- *q = *(q-1);
- *q = tmp;
- }
+ // partial_insertion_sort() sorts moves in descending order up to and including
+ // a given limit. The order of moves smaller than the limit is left unspecified.
+ // To keep the implementation simple, *begin is always included in the sorted moves.
+ void partial_insertion_sort(ExtMove* begin, ExtMove* end, int limit) {
+
+ for (ExtMove *sortedEnd = begin + 1, *p = begin + 1; p < end; ++p)
+ if (p->value >= limit)
+ {
+ ExtMove tmp = *p, *q;
+ *p = *sortedEnd;
+ for (q = sortedEnd; q != begin && *(q-1) < tmp; --q)
+ *q = *(q-1);
+ *q = tmp;
+ ++sortedEnd;
+ }
}
// pick_best() finds the best move in the range (begin, end) and moves it to
// the front. It's faster than sorting all the moves in advance when there
// are few moves, e.g., the possible captures.
- Move pick_best(ExtMove* begin, ExtMove* end)
- {
- std::swap(*begin, *std::max_element(begin, end));
- return *begin;
+ Move pick_best(ExtMove* begin, ExtMove* end) {
+
+ std::swap(*begin, *std::max_element(begin, end));
+ return *begin;
}
} // namespace
ttMove = ttm
&& pos.pseudo_legal(ttm)
&& pos.capture(ttm)
- && pos.see_ge(ttm, threshold)? ttm : MOVE_NONE;
+ && pos.see_ge(ttm, threshold) ? ttm : MOVE_NONE;
stage += (ttMove == MOVE_NONE);
}
cur = endBadCaptures;
endMoves = generate<QUIETS>(pos, cur);
score<QUIETS>();
- if (depth < 3 * ONE_PLY)
- {
- ExtMove* goodQuiet = std::partition(cur, endMoves, [](const ExtMove& m)
- { return m.value > VALUE_ZERO; });
- insertion_sort(cur, goodQuiet);
- } else
- insertion_sort(cur, endMoves);
+ partial_insertion_sort(cur, endMoves, -4000 * depth / ONE_PLY);
++stage;
case QUIET: