////
#include <cassert>
+#include <cmath>
#include <cstring>
#include <fstream>
#include <iostream>
bool UseLogFile;
std::ofstream LogFile;
+ // Natural logarithmic lookup table and its getter function
+ double lnArray[512];
+ inline double ln(int i) { return lnArray[i]; }
+
// MP related variables
int ActiveThreads = 1;
Depth MinimumSplitDepth;
//// Functions
////
-//FIXME: HACK
-static double lnArray[512];
-
-inline double ln(int i)
-{
- return lnArray[i];
-}
/// perft() is our utility to verify move generation is bug free. All the legal
/// moves up to given depth are generated and counted and the sum returned.
/// and initializes the split point stack and the global locks and condition
/// objects.
-#include <cmath> //FIXME: HACK
-
void init_threads() {
- // FIXME: HACK!!
- for (int i = 0; i < 512; i++)
- lnArray[i] = log(double(i));
-
volatile int i;
#if !defined(_MSC_VER)
pthread_t pthread[1];
#endif
+ // Init our logarithmic lookup table
+ for (int i = 0; i < 512; i++)
+ lnArray[i] = log(double(i)); // log() returns base-e logarithm
+
for (i = 0; i < THREAD_MAX; i++)
Threads[i].activeSplitPoints = 0;
currentMove = threatMove = MOVE_NONE;
reduction = Depth(0);
eval = VALUE_NONE;
+ evalInfo = NULL;
}
void SearchStack::initKillers() {
Value root_search(Position& pos, SearchStack ss[], RootMoveList& rml, Value alpha, Value beta) {
Value oldAlpha = alpha;
- Value value;
+ Value value = -VALUE_INFINITE;
CheckInfo ci(pos);
// Loop through all the moves in the root move list
Value oldAlpha, value;
bool isCheck, mateThreat, singleEvasion, moveIsCheck, captureOrPromotion, dangerous;
int moveCount = 0;
- Value bestValue = -VALUE_INFINITE;
+ Value bestValue = value = -VALUE_INFINITE;
if (depth < OnePly)
return qsearch(pos, ss, alpha, beta, Depth(0), ply, threadID);
bool isCheck, useFutilityPruning, singleEvasion, moveIsCheck, captureOrPromotion, dangerous;
bool mateThreat = false;
int moveCount = 0;
- futilityValue = staticValue = bestValue = -VALUE_INFINITE;
+ futilityValue = staticValue = bestValue = value = -VALUE_INFINITE;
if (depth < OnePly)
return qsearch(pos, ss, beta-1, beta, Depth(0), ply, threadID);
const int FutilityValueMargin = 112 * bitScanReverse32(int(depth) * int(depth) / 2);
// Evaluate the position statically
- if (isCheck)
- ss[ply].eval = VALUE_NONE;
- else
+ if (!isCheck)
{
if (tte && (tte->type() & VALUE_TYPE_EVAL))
staticValue = value_from_tt(tte->value(), ply);
else
+ {
staticValue = evaluate(pos, ei, threadID);
+ ss[ply].evalInfo = &ei;
+ }
ss[ply].eval = staticValue;
futilityValue = staticValue + FutilityValueMargin;
// Go with internal iterative deepening if we don't have a TT move
if (UseIIDAtNonPVNodes && ttMove == MOVE_NONE && depth >= 8*OnePly &&
- !isCheck && evaluate(pos, ei, threadID) >= beta - IIDMargin)
+ !isCheck && ss[ply].eval >= beta - IIDMargin)
{
search(pos, ss, beta, Min(depth/2, depth-2*OnePly), ply, false, threadID);
ttMove = ss[ply].pv[ply];
Position pos = Position(sp->pos);
CheckInfo ci(pos);
SearchStack* ss = sp->sstack[threadID];
- Value value;
+ Value value = -VALUE_INFINITE;
Move move;
bool isCheck = pos.is_check();
bool useFutilityPruning = sp->depth < SelectiveDepth
Position pos = Position(sp->pos);
CheckInfo ci(pos);
SearchStack* ss = sp->sstack[threadID];
- Value value;
+ Value value = -VALUE_INFINITE;
Move move;
while ( sp->alpha < sp->beta