// best move from the previous iteration, Problem is set back to false.
const Value NoProblemMargin = Value(0x14);
- // Null move margin. A null move search will not be done if the approximate
+ // Null move margin. A null move search will not be done if the static
// evaluation of the position is more than NullMoveMargin below beta.
- const Value NullMoveMargin = Value(0x300);
+ const Value NullMoveMargin = Value(0x200);
// If the TT move is at least SingleReplyMargin better then the
// remaining ones we will extend it.
// Depth limit for razoring
const Depth RazorDepth = 4 * OnePly;
- // Remaining depth: 1 ply 1.5 ply 2 ply 2.5 ply 3 ply 3.5 ply
- const Value RazorMargins[6] = { Value(0x180), Value(0x300), Value(0x300), Value(0x3C0), Value(0x3C0), Value(0x3C0) };
-
- // Remaining depth: 1 ply 1.5 ply 2 ply 2.5 ply 3 ply 3.5 ply
- const Value RazorApprMargins[6] = { Value(0x520), Value(0x300), Value(0x300), Value(0x300), Value(0x300), Value(0x300) };
-
-
/// Variables initialized by UCI options
// Minimum number of full depth (i.e. non-reduced) moves at PV and non-PV nodes
pv[ply] = pv[ply + 1] = MOVE_NONE;
currentMove = threatMove = MOVE_NONE;
reduction = Depth(0);
+ eval = VALUE_NONE;
}
void SearchStack::initKillers() {
// If we are pondering or in infinite search, we shouldn't print the
// best move before we are told to do so.
- if (PonderSearch || InfiniteSearch)
+ if (!AbortSearch && (PonderSearch || InfiniteSearch))
wait_for_stop_or_ponderhit();
else
// Print final search statistics
{
// Try to reduce non-pv search depth by one ply if move seems not problematic,
// if the move fails high will be re-searched at full depth.
+ bool doFullDepthSearch = true;
+
if ( depth >= 3*OnePly // FIXME was newDepth
&& !dangerous
&& !captureOrPromotion
{
ss[0].reduction = Depth(int(floor(red * int(OnePly))));
value = -search(pos, ss, -alpha, newDepth-ss[0].reduction, 1, true, 0);
+ doFullDepthSearch = (value > alpha);
}
- else
- value = alpha + 1; // Just to trigger next condition
- } else
- value = alpha + 1; // Just to trigger next condition
+ }
- if (value > alpha)
+ if (doFullDepthSearch)
{
value = -search(pos, ss, -alpha, newDepth, 1, true, 0);
assert(threadID >= 0 && threadID < ActiveThreads);
Move movesSearched[256];
- EvalInfo ei;
StateInfo st;
const TTEntry* tte;
Move ttMove, move;
if (AbortSearch || thread_should_stop(threadID))
return Value(0);
- if (pos.is_draw())
+ if (pos.is_draw() || ply >= PLY_MAX - 1)
return VALUE_DRAW;
- if (ply >= PLY_MAX - 1)
- return pos.is_check() ? quick_evaluate(pos) : evaluate(pos, ei, threadID);
-
// Mate distance pruning
oldAlpha = alpha;
alpha = Max(value_mated_in(ply), alpha);
{
// Try to reduce non-pv search depth by one ply if move seems not problematic,
// if the move fails high will be re-searched at full depth.
+ bool doFullDepthSearch = true;
+
if ( depth >= 3*OnePly
&& !dangerous
&& !captureOrPromotion
{
ss[ply].reduction = Depth(int(floor(red * int(OnePly))));
value = -search(pos, ss, -alpha, newDepth-ss[ply].reduction, ply+1, true, threadID);
+ doFullDepthSearch = (value > alpha);
}
- else
- value = alpha + 1; // Just to trigger next condition
}
- else
- value = alpha + 1; // Just to trigger next condition
- if (value > alpha) // Go with full depth non-pv search
+ if (doFullDepthSearch) // Go with full depth non-pv search
{
ss[ply].reduction = Depth(0);
value = -search(pos, ss, -alpha, newDepth, ply+1, true, threadID);
const TTEntry* tte;
Move ttMove, move;
Depth ext, newDepth;
- Value staticValue, nullValue, value, futilityValue, futilityValueScaled;
+ Value bestValue, staticValue, nullValue, value, futilityValue, futilityValueScaled;
bool isCheck, useFutilityPruning, singleEvasion, moveIsCheck, captureOrPromotion, dangerous;
bool mateThreat = false;
int moveCount = 0;
- Value bestValue = -VALUE_INFINITE;
+ futilityValue = staticValue = bestValue = -VALUE_INFINITE;
if (depth < OnePly)
return qsearch(pos, ss, beta-1, beta, Depth(0), ply, threadID);
if (AbortSearch || thread_should_stop(threadID))
return Value(0);
- if (pos.is_draw())
+ if (pos.is_draw() || ply >= PLY_MAX - 1)
return VALUE_DRAW;
- if (ply >= PLY_MAX - 1)
- return pos.is_check() ? quick_evaluate(pos) : evaluate(pos, ei, threadID);
-
// Mate distance pruning
if (value_mated_in(ply) >= beta)
return beta;
}
isCheck = pos.is_check();
- ei.futilityMargin = Value(0); // Manually initialize futilityMargin
-
- // Evaluate the position statically
- if (isCheck)
- staticValue = quick_evaluate(pos);
- else if (tte && (tte->type() & VALUE_TYPE_EVAL))
- staticValue = value_from_tt(tte->value(), ply);
- else
- staticValue = evaluate(pos, ei, threadID);
// Calculate depth dependant futility pruning parameters
const int FutilityMoveCountMargin = 3 + (1 << (3 * int(depth) / 8));
const int FutilityValueMargin = 112 * bitScanReverse32(int(depth) * int(depth) / 2);
- // Enhance score accuracy with TT value if possible
- futilityValue = staticValue + FutilityValueMargin;
- staticValue = refine_eval(tte, staticValue, ply);
+ // Evaluate the position statically
+ if (isCheck)
+ ss[ply].eval = VALUE_NONE;
+ else
+ {
+ if (tte && (tte->type() & VALUE_TYPE_EVAL))
+ staticValue = value_from_tt(tte->value(), ply);
+ else
+ staticValue = evaluate(pos, ei, threadID);
+
+ ss[ply].eval = staticValue;
+ futilityValue = staticValue + FutilityValueMargin;
+ staticValue = refine_eval(tte, staticValue, ply); // Enhance accuracy with TT value if possible
+ }
// Null move search
if ( allowNullmove
}
// Null move search not allowed, try razoring
else if ( !value_is_mate(beta)
+ && !isCheck
&& depth < RazorDepth
- && staticValue < beta - RazorApprMargins[int(depth) - 2]
+ && staticValue < beta - (NullMoveMargin + 16 * depth)
&& ss[ply - 1].currentMove != MOVE_NULL
&& ttMove == MOVE_NONE
&& !pos.has_pawn_on_7th(pos.side_to_move()))
{
- Value rbeta = beta - RazorMargins[int(depth) - 2];
+ Value rbeta = beta - (NullMoveMargin + 16 * depth);
Value v = qsearch(pos, ss, rbeta-1, rbeta, Depth(0), ply, threadID);
if (v < rbeta)
return v;
// Try to reduce non-pv search depth by one ply if move seems not problematic,
// if the move fails high will be re-searched at full depth.
+ bool doFullDepthSearch = true;
+
if ( depth >= 3*OnePly
&& !dangerous
&& !captureOrPromotion
{
ss[ply].reduction = Depth(int(floor(red * int(OnePly))));
value = -search(pos, ss, -(beta-1), newDepth-ss[ply].reduction, ply+1, true, threadID);
+ doFullDepthSearch = (value >= beta);
}
- else
- value = beta; // Just to trigger next condition
}
- else
- value = beta; // Just to trigger next condition
- if (value >= beta) // Go with full depth non-pv search
+ if (doFullDepthSearch) // Go with full depth non-pv search
{
ss[ply].reduction = Depth(0);
value = -search(pos, ss, -(beta-1), newDepth, ply+1, true, threadID);
if (AbortSearch || thread_should_stop(threadID))
return Value(0);
- if (pos.is_draw())
+ if (pos.is_draw() || ply >= PLY_MAX - 1)
return VALUE_DRAW;
- if (ply >= PLY_MAX - 1)
- return pos.is_check() ? quick_evaluate(pos) : evaluate(pos, ei, threadID);
-
// Transposition table lookup. At PV nodes, we don't use the TT for
// pruning, but only for move ordering.
tte = TT.retrieve(pos.get_key());
}
isCheck = pos.is_check();
- ei.futilityMargin = Value(0); // Manually initialize futilityMargin
// Evaluate the position statically
if (isCheck)
&& !isCheck;
const int FutilityMoveCountMargin = 3 + (1 << (3 * int(sp->depth) / 8));
- const int FutilityValueMargin = 112 * bitScanReverse32(int(sp->depth) * int(sp->depth) / 2);
while ( sp->bestValue < sp->beta
&& !thread_should_stop(threadID)
continue;
// Value based pruning
- if (sp->futilityValue == VALUE_NONE)
- {
- EvalInfo ei;
- sp->futilityValue = evaluate(pos, ei, threadID) + FutilityValueMargin;
- }
-
Value futilityValueScaled = sp->futilityValue - moveCount * IncrementalFutilityMargin;
if (futilityValueScaled < sp->beta)
// Try to reduce non-pv search depth by one ply if move seems not problematic,
// if the move fails high will be re-searched at full depth.
+ bool doFullDepthSearch = true;
+
if ( !dangerous
&& !captureOrPromotion
&& !move_is_castle(move)
{
ss[sp->ply].reduction = Depth(int(floor(red * int(OnePly))));
value = -search(pos, ss, -(sp->beta-1), newDepth-ss[sp->ply].reduction, sp->ply+1, true, threadID);
+ doFullDepthSearch = (value >= sp->beta);
}
- else
- value = sp->beta; // Just to trigger next condition
}
- else
- value = sp->beta; // Just to trigger next condition
- if (value >= sp->beta) // Go with full depth non-pv search
+ if (doFullDepthSearch) // Go with full depth non-pv search
{
ss[sp->ply].reduction = Depth(0);
value = -search(pos, ss, -(sp->beta - 1), newDepth, sp->ply+1, true, threadID);
// Try to reduce non-pv search depth by one ply if move seems not problematic,
// if the move fails high will be re-searched at full depth.
+ bool doFullDepthSearch = true;
+
if ( !dangerous
&& !captureOrPromotion
&& !move_is_castle(move)
double red = 0.5 + ln(moveCount) * ln(sp->depth / 2) / 6.0;
if (red >= 1.0)
{
+ Value localAlpha = sp->alpha;
ss[sp->ply].reduction = Depth(int(floor(red * int(OnePly))));
- value = -search(pos, ss, -sp->alpha, newDepth-ss[sp->ply].reduction, sp->ply+1, true, threadID);
+ value = -search(pos, ss, -localAlpha, newDepth-ss[sp->ply].reduction, sp->ply+1, true, threadID);
+ doFullDepthSearch = (value > localAlpha);
}
- else
- value = sp->alpha + 1; // Just to trigger next condition
}
- else
- value = sp->alpha + 1; // Just to trigger next condition
- if (value > sp->alpha) // Go with full depth non-pv search
+ if (doFullDepthSearch) // Go with full depth non-pv search
{
+ Value localAlpha = sp->alpha;
ss[sp->ply].reduction = Depth(0);
- value = -search(pos, ss, -sp->alpha, newDepth, sp->ply+1, true, threadID);
+ value = -search(pos, ss, -localAlpha, newDepth, sp->ply+1, true, threadID);
- if (value > sp->alpha && value < sp->beta)
+ if (value > localAlpha && value < sp->beta)
{
// When the search fails high at ply 1 while searching the first
- // move at the root, set the flag failHighPly1. This is used for
+ // move at the root, set the flag failHighPly1. This is used for
// time managment: We don't want to stop the search early in
// such cases, because resolving the fail high at ply 1 could
// result in a big drop in score at the root.
projects / stockfish / blobdiff