mirror of
https://github.com/official-stockfish/Stockfish.git
synced 2026-07-23 21:27:14 +00:00
Fixed compilation errors.
This commit is contained in:
nodchip
@@ -20,237 +20,6 @@ namespace EvalLearningTools
|
||||
double Weight::eta3;
|
||||
uint64_t Weight::eta1_epoch;
|
||||
uint64_t Weight::eta2_epoch;
|
||||
|
||||
std::vector<bool> min_index_flag;
|
||||
|
||||
// --- initialization for each individual table
|
||||
|
||||
void init_min_index_flag()
|
||||
{
|
||||
// Initialization of mir_piece and inv_piece must be completed.
|
||||
assert(Eval::mir_piece(PieceSquare::PS_W_PAWN) == PieceSquare::PS_B_PAWN);
|
||||
|
||||
// Initialize the flag array for dimension reduction
|
||||
// Not involved in KPPP.
|
||||
|
||||
KK g_kk;
|
||||
g_kk.set(SQUARE_NB, PieceSquare::PS_END, 0);
|
||||
KKP g_kkp;
|
||||
g_kkp.set(SQUARE_NB, PieceSquare::PS_END, g_kk.max_index());
|
||||
KPP g_kpp;
|
||||
g_kpp.set(SQUARE_NB, PieceSquare::PS_END, g_kkp.max_index());
|
||||
|
||||
uint64_t size = g_kpp.max_index();
|
||||
min_index_flag.resize(size);
|
||||
|
||||
#pragma omp parallel
|
||||
{
|
||||
#if defined(_OPENMP)
|
||||
// To prevent the logical 64 cores from being used when there are two CPUs under Windows
|
||||
// explicitly assign to CPU here
|
||||
int thread_index = omp_get_thread_num(); // get your thread number
|
||||
WinProcGroup::bindThisThread(thread_index);
|
||||
#endif
|
||||
|
||||
#pragma omp for schedule(dynamic,20000)
|
||||
|
||||
for (int64_t index_ = 0; index_ < (int64_t)size; ++index_)
|
||||
{
|
||||
// It seems that the loop variable must be a sign type due to OpenMP restrictions, but
|
||||
// It's really difficult to use.
|
||||
uint64_t index = (uint64_t)index_;
|
||||
|
||||
if (g_kk.is_ok(index))
|
||||
{
|
||||
// Make sure that the original index will be restored by conversion from index and reverse conversion.
|
||||
// It is a process that is executed only once at startup, so write it in assert.
|
||||
assert(g_kk.fromIndex(index).toIndex() == index);
|
||||
|
||||
KK a[KK_LOWER_COUNT];
|
||||
g_kk.fromIndex(index).toLowerDimensions(a);
|
||||
|
||||
// Make sure that the first element of dimension reduction is the same as the original index.
|
||||
assert(a[0].toIndex() == index);
|
||||
|
||||
uint64_t min_index = UINT64_MAX;
|
||||
for (auto& e : a)
|
||||
min_index = std::min(min_index, e.toIndex());
|
||||
min_index_flag[index] = (min_index == index);
|
||||
}
|
||||
else if (g_kkp.is_ok(index))
|
||||
{
|
||||
assert(g_kkp.fromIndex(index).toIndex() == index);
|
||||
|
||||
KKP x = g_kkp.fromIndex(index);
|
||||
KKP a[KKP_LOWER_COUNT];
|
||||
x.toLowerDimensions(a);
|
||||
|
||||
assert(a[0].toIndex() == index);
|
||||
|
||||
uint64_t min_index = UINT64_MAX;
|
||||
for (auto& e : a)
|
||||
min_index = std::min(min_index, e.toIndex());
|
||||
min_index_flag[index] = (min_index == index);
|
||||
}
|
||||
else if (g_kpp.is_ok(index))
|
||||
{
|
||||
assert(g_kpp.fromIndex(index).toIndex() == index);
|
||||
|
||||
KPP x = g_kpp.fromIndex(index);
|
||||
KPP a[KPP_LOWER_COUNT];
|
||||
x.toLowerDimensions(a);
|
||||
|
||||
assert(a[0].toIndex() == index);
|
||||
|
||||
uint64_t min_index = UINT64_MAX;
|
||||
for (auto& e : a)
|
||||
min_index = std::min(min_index, e.toIndex());
|
||||
min_index_flag[index] = (min_index == index);
|
||||
}
|
||||
else
|
||||
{
|
||||
assert(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void learning_tools_unit_test_kpp()
|
||||
{
|
||||
|
||||
// test KPP triangulation for bugs
|
||||
// All combinations of k-p0-p1 are properly handled by KPP, and the dimension reduction at that time is
|
||||
// Determine if it is correct.
|
||||
|
||||
KK g_kk;
|
||||
g_kk.set(SQUARE_NB, PieceSquare::PS_END, 0);
|
||||
KKP g_kkp;
|
||||
g_kkp.set(SQUARE_NB, PieceSquare::PS_END, g_kk.max_index());
|
||||
KPP g_kpp;
|
||||
g_kpp.set(SQUARE_NB, PieceSquare::PS_END, g_kkp.max_index());
|
||||
|
||||
std::vector<bool> f;
|
||||
f.resize(g_kpp.max_index() - g_kpp.min_index());
|
||||
|
||||
for(auto k = SQUARE_ZERO ; k < SQUARE_NB ; ++k)
|
||||
for(auto p0 = PieceSquare::PS_NONE; p0 < PieceSquare::PS_END ; ++p0)
|
||||
for (auto p1 = PieceSquare::PS_NONE; p1 < PieceSquare::PS_END; ++p1)
|
||||
{
|
||||
KPP kpp_org = g_kpp.fromKPP(k,p0,p1);
|
||||
KPP kpp0;
|
||||
KPP kpp1 = g_kpp.fromKPP(flip_file(k), mir_piece(p0), mir_piece(p1));
|
||||
KPP kpp_array[2];
|
||||
|
||||
auto index = kpp_org.toIndex();
|
||||
assert(g_kpp.is_ok(index));
|
||||
|
||||
kpp0 = g_kpp.fromIndex(index);
|
||||
|
||||
//if (kpp0 != kpp_org)
|
||||
// std::cout << "index = " << index << "," << kpp_org << "," << kpp0 << std::endl;
|
||||
|
||||
kpp0.toLowerDimensions(kpp_array);
|
||||
|
||||
assert(kpp_array[0] == kpp0);
|
||||
assert(kpp0 == kpp_org);
|
||||
assert(kpp_array[1] == kpp1);
|
||||
|
||||
auto index2 = kpp1.toIndex();
|
||||
f[index - g_kpp.min_index()] = f[index2-g_kpp.min_index()] = true;
|
||||
}
|
||||
|
||||
// Check if there is no missing index.
|
||||
for(size_t index = 0 ; index < f.size(); index++)
|
||||
if (!f[index])
|
||||
{
|
||||
std::cout << index << g_kpp.fromIndex(index + g_kpp.min_index()) << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void learning_tools_unit_test_kppp()
|
||||
{
|
||||
// Test for missing KPPP calculations
|
||||
|
||||
KPPP g_kppp;
|
||||
g_kppp.set(15, PieceSquare::PS_END,0);
|
||||
uint64_t min_index = g_kppp.min_index();
|
||||
uint64_t max_index = g_kppp.max_index();
|
||||
|
||||
// Confirm last element.
|
||||
//KPPP x = KPPP::fromIndex(max_index-1);
|
||||
//std::cout << x << std::endl;
|
||||
|
||||
for (uint64_t index = min_index; index < max_index; ++index)
|
||||
{
|
||||
KPPP x = g_kppp.fromIndex(index);
|
||||
//std::cout << x << std::endl;
|
||||
|
||||
#if 0
|
||||
if ((index % 10000000) == 0)
|
||||
std::cout << "index = " << index << std::endl;
|
||||
|
||||
// index = 9360000000
|
||||
// done.
|
||||
|
||||
if (x.toIndex() != index)
|
||||
{
|
||||
std::cout << "assertion failed , index = " << index << std::endl;
|
||||
}
|
||||
#endif
|
||||
|
||||
assert(x.toIndex() == index);
|
||||
|
||||
// ASSERT((&kppp_ksq_pcpcpc(x.king(), x.piece0(), x.piece1(), x.piece2()) - &kppp[0][0]) == (index - min_index));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void learning_tools_unit_test_kkpp()
|
||||
{
|
||||
KKPP g_kkpp;
|
||||
g_kkpp.set(SQUARE_NB, 10000, 0);
|
||||
uint64_t n = 0;
|
||||
for (int k = 0; k<SQUARE_NB; ++k)
|
||||
for (int i = 0; i<10000; ++i) // As a test, assuming a large fe_end, try turning at 10000.
|
||||
for (int j = 0; j < i; ++j)
|
||||
{
|
||||
auto kkpp = g_kkpp.fromKKPP(k, (PieceSquare)i, (PieceSquare)j);
|
||||
auto r = kkpp.toRawIndex();
|
||||
assert(n++ == r);
|
||||
auto kkpp2 = g_kkpp.fromIndex(r + g_kkpp.min_index());
|
||||
assert(kkpp2.king() == k && kkpp2.piece0() == i && kkpp2.piece1() == j);
|
||||
}
|
||||
}
|
||||
|
||||
// Initialize this entire EvalLearningTools
|
||||
void init()
|
||||
{
|
||||
// Initialization is required only once after startup, so a flag for that.
|
||||
static bool first = true;
|
||||
|
||||
if (first)
|
||||
{
|
||||
std::cout << "EvalLearningTools init..";
|
||||
|
||||
// Make mir_piece() and inv_piece() available.
|
||||
// After this, the min_index_flag is initialized, but
|
||||
// It depends on this, so you need to do this first.
|
||||
init_mir_inv_tables();
|
||||
|
||||
//learning_tools_unit_test_kpp();
|
||||
//learning_tools_unit_test_kppp();
|
||||
//learning_tools_unit_test_kkpp();
|
||||
|
||||
// It may be the last time to execute UnitTest, but since init_min_index_flag() takes a long time,
|
||||
// I want to do this at the time of debugging.
|
||||
|
||||
init_min_index_flag();
|
||||
|
||||
std::cout << "done." << std::endl;
|
||||
|
||||
first = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
Reference in New Issue
Block a user