mirror of
https://github.com/HChaZZY/Stockfish.git
synced 2025-12-25 19:46:55 +08:00
55a6b2bdc4
# Conflicts: # README.md # Readme.md # src/Makefile # src/evaluate.cpp # src/evaluate.h # src/misc.cpp # src/nnue/architectures/halfkp_256x2-32-32.h # src/nnue/evaluate_nnue.cpp # src/nnue/evaluate_nnue.h # src/nnue/features/feature_set.h # src/nnue/features/features_common.h # src/nnue/features/half_kp.cpp # src/nnue/features/half_kp.h # src/nnue/features/index_list.h # src/nnue/layers/affine_transform.h # src/nnue/layers/clipped_relu.h # src/nnue/layers/input_slice.h # src/nnue/nnue_accumulator.h # src/nnue/nnue_architecture.h # src/nnue/nnue_common.h # src/nnue/nnue_feature_transformer.h # src/position.cpp # src/position.h # src/types.h # src/ucioption.cpp # stockfish.md
1035 lines
39 KiB
C++
1035 lines
39 KiB
C++
#ifndef __LEARN_WEIGHT_H__
|
||
#define __LEARN_WEIGHT_H__
|
||
|
||
// A set of machine learning tools related to the weight array used for machine learning of evaluation functions
|
||
|
||
#include "learn.h"
|
||
#if defined (EVAL_LEARN)
|
||
#include <array>
|
||
|
||
#include "../eval/evaluate_mir_inv_tools.h"
|
||
|
||
#if defined(SGD_UPDATE) || defined(USE_KPPP_MIRROR_WRITE)
|
||
#include "../misc.h" // PRNG , my_insertion_sort
|
||
#endif
|
||
|
||
#include <cmath> // std::sqrt()
|
||
|
||
namespace EvalLearningTools
|
||
{
|
||
// -------------------------------------------------
|
||
// Initialization
|
||
// -------------------------------------------------
|
||
|
||
// Initialize the tables in this EvalLearningTools namespace.
|
||
// Be sure to call once before learning starts.
|
||
// In this function, we also call init_mir_inv_tables().
|
||
// (It is not necessary to call init_mir_inv_tables() when calling this function.)
|
||
void init();
|
||
|
||
// -------------------------------------------------
|
||
// flags
|
||
// -------------------------------------------------
|
||
|
||
// When the dimension is lowered, it may become the smallest index among them
|
||
// A flag array that is true for the known index.
|
||
// This array is also initialized by init().
|
||
// KPPP is not involved.
|
||
// Therefore, the valid index range of this array is from KK::min_index() to KPP::max_index().
|
||
extern std::vector<bool> min_index_flag;
|
||
|
||
// -------------------------------------------------
|
||
// Array for learning that stores gradients etc.
|
||
// -------------------------------------------------
|
||
|
||
#if defined(_MSC_VER)
|
||
#pragma pack(push,2)
|
||
#elif defined(__GNUC__)
|
||
#pragma pack(2)
|
||
#endif
|
||
struct Weight
|
||
{
|
||
// cumulative value of one mini-batch gradient
|
||
LearnFloatType g = LearnFloatType(0);
|
||
|
||
// When ADA_GRAD_UPDATE. LearnFloatType == float,
|
||
// total 4*2 + 4*2 + 1*2 = 18 bytes
|
||
// It suffices to secure a Weight array that is 4.5 times the size of the evaluation function parameter of 1GB.
|
||
// However, sizeof(Weight)==20 code is generated if the structure alignment is in 4-byte units, so
|
||
// Specify pragma pack(2).
|
||
|
||
// For SGD_UPDATE, this structure is reduced by 10 bytes to 8 bytes.
|
||
|
||
// Learning rate η(eta) such as AdaGrad.
|
||
// It is assumed that eta1,2,3,eta1_epoch,eta2_epoch have been set by the time updateFV() is called.
|
||
// The epoch of update_weights() gradually changes from eta1 to eta2 until eta1_epoch.
|
||
// After eta2_epoch, gradually change from eta2 to eta3.
|
||
static double eta;
|
||
static double eta1;
|
||
static double eta2;
|
||
static double eta3;
|
||
static uint64_t eta1_epoch;
|
||
static uint64_t eta2_epoch;
|
||
|
||
// Batch initialization of eta. If 0 is passed, the default value will be set.
|
||
static void init_eta(double eta1, double eta2, double eta3, uint64_t eta1_epoch, uint64_t eta2_epoch)
|
||
{
|
||
Weight::eta1 = (eta1 != 0) ? eta1 : 30.0;
|
||
Weight::eta2 = (eta2 != 0) ? eta2 : 30.0;
|
||
Weight::eta3 = (eta3 != 0) ? eta3 : 30.0;
|
||
Weight::eta1_epoch = (eta1_epoch != 0) ? eta1_epoch : 0;
|
||
Weight::eta2_epoch = (eta2_epoch != 0) ? eta2_epoch : 0;
|
||
}
|
||
|
||
// Set eta according to epoch.
|
||
static void calc_eta(uint64_t epoch)
|
||
{
|
||
if (Weight::eta1_epoch == 0) // Exclude eta2
|
||
Weight::eta = Weight::eta1;
|
||
else if (epoch < Weight::eta1_epoch)
|
||
// apportion
|
||
Weight::eta = Weight::eta1 + (Weight::eta2 - Weight::eta1) * epoch / Weight::eta1_epoch;
|
||
else if (Weight::eta2_epoch == 0) // Exclude eta3
|
||
Weight::eta = Weight::eta2;
|
||
else if (epoch < Weight::eta2_epoch)
|
||
Weight::eta = Weight::eta2 + (Weight::eta3 - Weight::eta2) * (epoch - Weight::eta1_epoch) / (Weight::eta2_epoch - Weight::eta1_epoch);
|
||
else
|
||
Weight::eta = Weight::eta3;
|
||
}
|
||
|
||
template <typename T> void updateFV(T& v) { updateFV(v, 1.0); }
|
||
|
||
#if defined (ADA_GRAD_UPDATE)
|
||
|
||
// Since the maximum value that can be accurately calculated with float is INT16_MAX*256-1
|
||
// Keep the small value as a marker.
|
||
const LearnFloatType V0_NOT_INIT = (INT16_MAX * 128);
|
||
|
||
// What holds v internally. The previous implementation kept a fixed decimal with only a fractional part to save memory,
|
||
// Since it is doubtful in accuracy and the visibility is bad, it was abolished.
|
||
LearnFloatType v0 = LearnFloatType(V0_NOT_INIT);
|
||
|
||
// AdaGrad g2
|
||
LearnFloatType g2 = LearnFloatType(0);
|
||
|
||
// update with AdaGrad
|
||
// When executing this function, the value of g and the member do not change
|
||
// Guaranteed by the caller. It does not have to be an atomic operation.
|
||
// k is a coefficient for eta. 1.0 is usually sufficient. If you want to lower eta for your turn item, set this to 1/8.0 etc.
|
||
template <typename T>
|
||
void updateFV(T& v,double k)
|
||
{
|
||
// AdaGrad update formula
|
||
// Gradient vector is g, vector to be updated is v, η(eta) is a constant,
|
||
// g2 = g2 + g^2
|
||
// v = v - ηg/sqrt(g2)
|
||
|
||
constexpr double epsilon = 0.000001;
|
||
|
||
if (g == LearnFloatType(0))
|
||
return;
|
||
|
||
g2 += g * g;
|
||
|
||
// If v0 is V0_NOT_INIT, it means that the value is not initialized with the value of KK/KKP/KPP array,
|
||
// In this case, read the value of v from the one passed in the argument.
|
||
double V = (v0 == V0_NOT_INIT) ? v : v0;
|
||
|
||
V -= k * eta * (double)g / sqrt((double)g2 + epsilon);
|
||
|
||
// Limit the value of V to be within the range of types.
|
||
// By the way, windows.h defines the min and max macros, so to avoid it,
|
||
// Here, it is enclosed in parentheses so that it is not treated as a function-like macro.
|
||
V = (std::min)((double)(std::numeric_limits<T>::max)() , V);
|
||
V = (std::max)((double)(std::numeric_limits<T>::min)() , V);
|
||
|
||
v0 = (LearnFloatType)V;
|
||
v = (T)round(V);
|
||
|
||
// Clear g because one update of mini-batch for this element is over
|
||
// g[i] = 0;
|
||
// → There is a problem of dimension reduction, so this will be done by the caller.
|
||
}
|
||
|
||
#elif defined(SGD_UPDATE)
|
||
|
||
// See only the sign of the gradient Update with SGD
|
||
// When executing this function, the value of g and the member do not change
|
||
// Guaranteed by the caller. It does not have to be an atomic operation.
|
||
template <typename T>
|
||
void updateFV(T & v , double k)
|
||
{
|
||
if (g == 0)
|
||
return;
|
||
|
||
// See only the sign of g and update.
|
||
// If g <0, add v a little.
|
||
// If g> 0, subtract v slightly.
|
||
|
||
// Since we only add integers, no decimal part is required.
|
||
|
||
// It's a good idea to move around 0-5.
|
||
// It is better to have a Gaussian distribution, so generate a 5-bit random number (each bit has a 1/2 probability of 1),
|
||
// Pop_count() it. At this time, it has a binomial distribution.
|
||
//int16_t diff = (int16_t)POPCNT32((u32)prng.rand(31));
|
||
// → If I do this with 80 threads, this AsyncPRNG::rand() locks, so I slowed down. This implementation is not good.
|
||
int16_t diff = 1;
|
||
|
||
double V = v;
|
||
if (g > 0.0)
|
||
V-= diff;
|
||
else
|
||
V+= diff;
|
||
|
||
V = (std::min)((double)(std::numeric_limits<T>::max)(), V);
|
||
V = (std::max)((double)(std::numeric_limits<T>::min)(), V);
|
||
|
||
v = (T)V;
|
||
}
|
||
|
||
#endif
|
||
|
||
// grad setting
|
||
template <typename T> void set_grad(const T& g_) { g = g_; }
|
||
|
||
// Add grad
|
||
template <typename T> void add_grad(const T& g_) { g += g_; }
|
||
|
||
LearnFloatType get_grad() const { return g; }
|
||
};
|
||
#if defined(_MSC_VER)
|
||
#pragma pack(pop)
|
||
#elif defined(__GNUC__)
|
||
#pragma pack(0)
|
||
#endif
|
||
|
||
// Turned weight array
|
||
// In order to be able to handle it transparently, let's have the same member as Weight.
|
||
struct Weight2
|
||
{
|
||
Weight w[2];
|
||
|
||
//Evaluate your turn, eta 1/8.
|
||
template <typename T> void updateFV(std::array<T, 2>& v) { w[0].updateFV(v[0] , 1.0); w[1].updateFV(v[1],1.0/8.0); }
|
||
|
||
template <typename T> void set_grad(const std::array<T, 2>& g) { for (int i = 0; i<2; ++i) w[i].set_grad(g[i]); }
|
||
template <typename T> void add_grad(const std::array<T, 2>& g) { for (int i = 0; i<2; ++i) w[i].add_grad(g[i]); }
|
||
|
||
std::array<LearnFloatType, 2> get_grad() const { return std::array<LearnFloatType, 2>{w[0].get_grad(), w[1].get_grad()}; }
|
||
};
|
||
|
||
// ------------------------------------------------ -
|
||
// A helper that calculates the index when the Weight array is serialized.
|
||
// ------------------------------------------------ -
|
||
|
||
// Base class for KK,KKP,KPP,KKPP
|
||
// How to use these classes
|
||
//
|
||
// 1. Initialize with set() first. Example) KK g_kk; g_kk.set(SQUARE_NB,fe_end,0);
|
||
// 2. Next create an instance with fromIndex(), fromKK(), etc.
|
||
// 3. Access using properties such as king(), piece0(), piece1().
|
||
//
|
||
// It may be difficult to understand just by this explanation, but if you look at init_grad(), add_grad(), update_weights() etc. in the learning part
|
||
// I think you can understand it including the necessity.
|
||
//
|
||
// Note: this derived class may indirectly reference the above inv_piece/mir_piece for dimension reduction, so
|
||
// Initialize by calling EvalLearningTools::init() or init_mir_inv_tables() first.
|
||
//
|
||
// Remarks) /*final*/ is written for the function name that should not be overridden on the derived class side.
|
||
// The function that should be overridden on the derived class side is a pure virtual function with "= 0".
|
||
// Only virtual functions are added to the derived class that may or may not be overridden.
|
||
//
|
||
struct SerializerBase
|
||
{
|
||
|
||
// Minimum value and maximum value of serial number +1 when serializing KK, KKP, KPP arrays.
|
||
/*final*/ uint64_t min_index() const { return min_index_; }
|
||
/*final*/ uint64_t max_index() const { return min_index() + max_raw_index_; }
|
||
|
||
// max_index() - min_index() the value of.
|
||
// Calculate the value from max_king_sq_,fe_end_ etc. on the derived class side and return it.
|
||
virtual uint64_t size() const = 0;
|
||
|
||
// Determine if the given index is more than min_index() and less than max_index().
|
||
/*final*/ bool is_ok(uint64_t index) { return min_index() <= index && index < max_index(); }
|
||
|
||
// Make sure to call this set(). Otherwise, construct an instance using fromKK()/fromIndex() etc. on the derived class side.
|
||
virtual void set(int max_king_sq, uint64_t fe_end, uint64_t min_index)
|
||
{
|
||
max_king_sq_ = max_king_sq;
|
||
fe_end_ = fe_end;
|
||
min_index_ = min_index;
|
||
max_raw_index_ = size();
|
||
}
|
||
|
||
// Get the index when serialized, based on the value of the current member.
|
||
/*final*/ uint64_t toIndex() const {
|
||
return min_index() + toRawIndex();
|
||
}
|
||
|
||
// Returns the index when serializing. (The value of min_index() is before addition)
|
||
virtual uint64_t toRawIndex() const = 0;
|
||
|
||
protected:
|
||
// The value of min_index() returned by this class
|
||
uint64_t min_index_;
|
||
|
||
// The value of max_index() returned by this class = min_index() + max_raw_index_
|
||
// This variable is calculated by size() of the derived class.
|
||
uint64_t max_raw_index_;
|
||
|
||
// The number of balls to support (normally SQUARE_NB)
|
||
int max_king_sq_;
|
||
|
||
// Maximum PieceSquare value supported
|
||
uint64_t fe_end_;
|
||
|
||
};
|
||
|
||
struct KK : public SerializerBase
|
||
{
|
||
protected:
|
||
KK(Square king0, Square king1,bool inverse) : king0_(king0), king1_(king1) , inverse_sign(inverse) {}
|
||
public:
|
||
KK() {}
|
||
|
||
virtual uint64_t size() const { return max_king_sq_ * max_king_sq_; }
|
||
|
||
// builder that creates KK object from index (serial number)
|
||
KK fromIndex(uint64_t index) const { assert(index >= min_index()); return fromRawIndex(index - min_index()); }
|
||
|
||
// builder that creates KK object from raw_index (number starting from 0, not serial number)
|
||
KK fromRawIndex(uint64_t raw_index) const
|
||
{
|
||
int king1 = (int)(raw_index % SQUARE_NB);
|
||
raw_index /= SQUARE_NB;
|
||
int king0 = (int)(raw_index /* % SQUARE_NB */);
|
||
assert(king0 < SQUARE_NB);
|
||
return fromKK((Square)king0, (Square)king1 , false);
|
||
}
|
||
KK fromKK(Square king0, Square king1 , bool inverse) const
|
||
{
|
||
// The variable name kk is used in the Eval::kk array etc., so it needs to be different. (The same applies to KKP, KPP classes, etc.)
|
||
KK my_kk(king0, king1, inverse);
|
||
my_kk.set(max_king_sq_, fe_end_, min_index());
|
||
return my_kk;
|
||
}
|
||
KK fromKK(Square king0, Square king1) const { return fromKK(king0, king1, false); }
|
||
|
||
// When you construct this object using fromIndex(), you can get information with the following accessors.
|
||
Square king0() const { return king0_; }
|
||
Square king1() const { return king1_; }
|
||
|
||
// number of dimension reductions
|
||
#if defined(USE_KK_INVERSE_WRITE)
|
||
#define KK_LOWER_COUNT 4
|
||
#elif defined(USE_KK_MIRROR_WRITE)
|
||
#define KK_LOWER_COUNT 2
|
||
#else
|
||
#define KK_LOWER_COUNT 1
|
||
#endif
|
||
|
||
#if defined(USE_KK_INVERSE_WRITE) && !defined(USE_KK_MIRROR_WRITE)
|
||
// USE_KK_INVERSE_WRITE If you use it, please also define USE_KK_MIRROR_WRITE.
|
||
static_assert(false, "define also USE_KK_MIRROR_WRITE!");
|
||
#endif
|
||
|
||
// Get the index of the low-dimensional array.
|
||
// When USE_KK_INVERSE_WRITE is enabled, the inverse of them will be in [2] and [3].
|
||
// Note that the sign of grad must be reversed for this dimension reduction.
|
||
// You can use is_inverse() because it can be determined.
|
||
void toLowerDimensions(/*out*/KK kk_[KK_LOWER_COUNT]) const {
|
||
kk_[0] = fromKK(king0_, king1_,false);
|
||
#if defined(USE_KK_MIRROR_WRITE)
|
||
kk_[1] = fromKK(flip_file(king0_),flip_file(king1_),false);
|
||
#if defined(USE_KK_INVERSE_WRITE)
|
||
kk_[2] = fromKK(rotate180(king1_), rotate180(king0_),true);
|
||
kk_[3] = fromKK(rotate180(flip_file(king1_)) , rotate180(flip_file(king0_)),true);
|
||
#endif
|
||
#endif
|
||
}
|
||
|
||
// Get the index when counting the value of min_index() of this class as 0.
|
||
virtual uint64_t toRawIndex() const {
|
||
return (uint64_t)king0_ * (uint64_t)max_king_sq_ + (uint64_t)king1_;
|
||
}
|
||
|
||
// Returns whether or not the dimension lowered with toLowerDimensions is inverse.
|
||
bool is_inverse() const {
|
||
return inverse_sign;
|
||
}
|
||
|
||
// When is_inverse() == true, reverse the sign that is not grad's turn and return it.
|
||
template <typename T>
|
||
std::array<T, 2> apply_inverse_sign(const std::array<T, 2>& rhs)
|
||
{
|
||
return !is_inverse() ? rhs : std::array<T, 2>{-rhs[0], rhs[1]};
|
||
}
|
||
|
||
// comparison operator
|
||
bool operator==(const KK& rhs) { return king0() == rhs.king0() && king1() == rhs.king1(); }
|
||
bool operator!=(const KK& rhs) { return !(*this == rhs); }
|
||
|
||
private:
|
||
Square king0_, king1_ ;
|
||
bool inverse_sign;
|
||
};
|
||
|
||
// Output for debugging.
|
||
static std::ostream& operator<<(std::ostream& os, KK rhs)
|
||
{
|
||
os << "KK(" << rhs.king0() << "," << rhs.king1() << ")";
|
||
return os;
|
||
}
|
||
|
||
// Same as KK. For KKP.
|
||
struct KKP : public SerializerBase
|
||
{
|
||
protected:
|
||
KKP(Square king0, Square king1, PieceSquare p) : king0_(king0), king1_(king1), piece_(p), inverse_sign(false) {}
|
||
KKP(Square king0, Square king1, PieceSquare p, bool inverse) : king0_(king0), king1_(king1), piece_(p),inverse_sign(inverse) {}
|
||
public:
|
||
KKP() {}
|
||
|
||
virtual uint64_t size() const { return (uint64_t)max_king_sq_*(uint64_t)max_king_sq_*(uint64_t)fe_end_; }
|
||
|
||
// builder that creates KKP object from index (serial number)
|
||
KKP fromIndex(uint64_t index) const { assert(index >= min_index()); return fromRawIndex(index - min_index()); }
|
||
|
||
// A builder that creates a KKP object from raw_index (a number that starts from 0, not a serial number)
|
||
KKP fromRawIndex(uint64_t raw_index) const
|
||
{
|
||
int piece = (int)(raw_index % PieceSquare::PS_END);
|
||
raw_index /= PieceSquare::PS_END;
|
||
int king1 = (int)(raw_index % SQUARE_NB);
|
||
raw_index /= SQUARE_NB;
|
||
int king0 = (int)(raw_index /* % SQUARE_NB */);
|
||
assert(king0 < SQUARE_NB);
|
||
return fromKKP((Square)king0, (Square)king1, (PieceSquare)piece,false);
|
||
}
|
||
|
||
KKP fromKKP(Square king0, Square king1, PieceSquare p, bool inverse) const
|
||
{
|
||
KKP my_kkp(king0, king1, p, inverse);
|
||
my_kkp.set(max_king_sq_,fe_end_,min_index());
|
||
return my_kkp;
|
||
}
|
||
KKP fromKKP(Square king0, Square king1, PieceSquare p) const { return fromKKP(king0, king1, p, false); }
|
||
|
||
// When you construct this object using fromIndex(), you can get information with the following accessors.
|
||
Square king0() const { return king0_; }
|
||
Square king1() const { return king1_; }
|
||
PieceSquare piece() const { return piece_; }
|
||
|
||
// Number of KKP dimension reductions
|
||
#if defined(USE_KKP_INVERSE_WRITE)
|
||
#define KKP_LOWER_COUNT 4
|
||
#elif defined(USE_KKP_MIRROR_WRITE)
|
||
#define KKP_LOWER_COUNT 2
|
||
#else
|
||
#define KKP_LOWER_COUNT 1
|
||
#endif
|
||
|
||
#if defined(USE_KKP_INVERSE_WRITE) && !defined(USE_KKP_MIRROR_WRITE)
|
||
// USE_KKP_INVERSE_WRITE If you use it, please also define USE_KKP_MIRROR_WRITE.
|
||
static_assert(false, "define also USE_KKP_MIRROR_WRITE!");
|
||
#endif
|
||
|
||
// Get the index of the low-dimensional array. The mirrored one is returned to kkp_[1].
|
||
// When USE_KKP_INVERSE_WRITE is enabled, the inverse of them will be in [2] and [3].
|
||
// Note that the sign of grad must be reversed for this dimension reduction.
|
||
// You can use is_inverse() because it can be determined.
|
||
void toLowerDimensions(/*out*/ KKP kkp_[KKP_LOWER_COUNT]) const {
|
||
kkp_[0] = fromKKP(king0_, king1_, piece_,false);
|
||
#if defined(USE_KKP_MIRROR_WRITE)
|
||
kkp_[1] = fromKKP(flip_file(king0_), flip_file(king1_), Eval::mir_piece(piece_),false);
|
||
#if defined(USE_KKP_INVERSE_WRITE)
|
||
kkp_[2] = fromKKP( rotate180(king1_), rotate180(king0_), Eval::inv_piece(piece_),true);
|
||
kkp_[3] = fromKKP( rotate180(flip_file(king1_)), rotate180(flip_file(king0_)) , Eval::inv_piece(Eval::mir_piece(piece_)),true);
|
||
#endif
|
||
#endif
|
||
}
|
||
|
||
// Get the index when counting the value of min_index() of this class as 0.
|
||
virtual uint64_t toRawIndex() const {
|
||
return ((uint64_t)king0_ * (uint64_t)max_king_sq_ + (uint64_t)king1_) * (uint64_t)fe_end_ + (uint64_t)piece_;
|
||
}
|
||
|
||
// Returns whether or not the dimension lowered with toLowerDimensions is inverse.
|
||
bool is_inverse() const {
|
||
return inverse_sign;
|
||
}
|
||
|
||
// When is_inverse() == true, reverse the sign that is not grad's turn and return it.
|
||
template <typename T>
|
||
std::array<T, 2> apply_inverse_sign(const std::array<T, 2>& rhs)
|
||
{
|
||
return !is_inverse() ? rhs : std::array<T, 2>{-rhs[0], rhs[1]};
|
||
}
|
||
|
||
// comparison operator
|
||
bool operator==(const KKP& rhs) { return king0() == rhs.king0() && king1() == rhs.king1() && piece() == rhs.piece(); }
|
||
bool operator!=(const KKP& rhs) { return !(*this == rhs); }
|
||
|
||
private:
|
||
Square king0_, king1_;
|
||
PieceSquare piece_;
|
||
bool inverse_sign;
|
||
};
|
||
|
||
// Output for debugging.
|
||
static std::ostream& operator<<(std::ostream& os, KKP rhs)
|
||
{
|
||
os << "KKP(" << rhs.king0() << "," << rhs.king1() << "," << rhs.piece() << ")";
|
||
return os;
|
||
}
|
||
|
||
|
||
// Same as KK and KKP. For KPP
|
||
struct KPP : public SerializerBase
|
||
{
|
||
protected:
|
||
KPP(Square king, PieceSquare p0, PieceSquare p1) : king_(king), piece0_(p0), piece1_(p1) {}
|
||
|
||
public:
|
||
KPP() {}
|
||
|
||
// The minimum and maximum KPP values of serial numbers when serializing KK, KKP, KPP arrays.
|
||
#if !defined(USE_TRIANGLE_WEIGHT_ARRAY)
|
||
virtual uint64_t size() const { return (uint64_t)max_king_sq_*(uint64_t)fe_end_*(uint64_t)fe_end_; }
|
||
#else
|
||
// Triangularize the square array part of [fe_end][fe_end] of kpp[SQUARE_NB][fe_end][fe_end].
|
||
// If kpp[SQUARE_NB][triangle_fe_end], the first row of this triangular array has one element, the second row has two elements, and so on.
|
||
// hence triangle_fe_end = 1 + 2 + .. + fe_end = fe_end * (fe_end + 1) / 2
|
||
virtual uint64_t size() const { return (uint64_t)max_king_sq_*(uint64_t)triangle_fe_end; }
|
||
#endif
|
||
|
||
virtual void set(int max_king_sq, uint64_t fe_end, uint64_t min_index)
|
||
{
|
||
// This value is used in size(), and size() is used in SerializerBase::set(), so calculate first.
|
||
triangle_fe_end = (uint64_t)fe_end*((uint64_t)fe_end + 1) / 2;
|
||
|
||
SerializerBase::set(max_king_sq, fe_end, min_index);
|
||
}
|
||
|
||
// builder that creates KPP object from index (serial number)
|
||
KPP fromIndex(uint64_t index) const { assert(index >= min_index()); return fromRawIndex(index - min_index()); }
|
||
|
||
// A builder that creates KPP objects from raw_index (a number that starts from 0, not a serial number)
|
||
KPP fromRawIndex(uint64_t raw_index) const
|
||
{
|
||
const uint64_t triangle_fe_end = (uint64_t)fe_end_*((uint64_t)fe_end_ + 1) / 2;
|
||
|
||
#if !defined(USE_TRIANGLE_WEIGHT_ARRAY)
|
||
int piece1 = (int)(raw_index % fe_end_);
|
||
raw_index /= fe_end_;
|
||
int piece0 = (int)(raw_index % fe_end_);
|
||
raw_index /= fe_end_;
|
||
#else
|
||
uint64_t index2 = raw_index % triangle_fe_end;
|
||
|
||
// Write the expression to find piece0, piece1 from index2 here.
|
||
// This is the inverse function of index2 = i * (i+1) / 2 + j.
|
||
// If j = 0, i^2 + i-2 * index2 == 0
|
||
// From the solution formula of the quadratic equation i = (sqrt(8*index2+1)-1) / 2.
|
||
// After i is converted into an integer, j can be calculated as j = index2-i * (i + 1) / 2.
|
||
|
||
// PieceSquare assumes 32bit (may not fit in 16bit), so this multiplication must be 64bit.
|
||
int piece1 = int(sqrt(8 * index2 + 1) - 1) / 2;
|
||
int piece0 = int(index2 - (uint64_t)piece1*((uint64_t)piece1 + 1) / 2);
|
||
|
||
assert(piece1 < (int)fe_end_);
|
||
assert(piece0 < (int)fe_end_);
|
||
assert(piece0 > piece1);
|
||
|
||
raw_index /= triangle_fe_end;
|
||
#endif
|
||
int king = (int)(raw_index /* % SQUARE_NB */);
|
||
assert(king < max_king_sq_);
|
||
return fromKPP((Square)king, (PieceSquare)piece0, (PieceSquare)piece1);
|
||
}
|
||
|
||
KPP fromKPP(Square king, PieceSquare p0, PieceSquare p1) const
|
||
{
|
||
KPP my_kpp(king, p0, p1);
|
||
my_kpp.set(max_king_sq_,fe_end_,min_index());
|
||
return my_kpp;
|
||
}
|
||
|
||
// When you construct this object using fromIndex(), you can get information with the following accessors.
|
||
Square king() const { return king_; }
|
||
PieceSquare piece0() const { return piece0_; }
|
||
PieceSquare piece1() const { return piece1_; }
|
||
|
||
|
||
// number of dimension reductions
|
||
#if defined(USE_KPP_MIRROR_WRITE)
|
||
#if !defined(USE_TRIANGLE_WEIGHT_ARRAY)
|
||
#define KPP_LOWER_COUNT 4
|
||
#else
|
||
#define KPP_LOWER_COUNT 2
|
||
#endif
|
||
#else
|
||
#if !defined(USE_TRIANGLE_WEIGHT_ARRAY)
|
||
#define KPP_LOWER_COUNT 2
|
||
#else
|
||
#define KPP_LOWER_COUNT 1
|
||
#endif
|
||
#endif
|
||
|
||
// Get the index of the low-dimensional array. The ones with p1 and p2 swapped, the ones mirrored, etc. are returned.
|
||
void toLowerDimensions(/*out*/ KPP kpp_[KPP_LOWER_COUNT]) const {
|
||
|
||
#if defined(USE_TRIANGLE_WEIGHT_ARRAY)
|
||
// Note that if you use a triangular array, the swapped piece0 and piece1 will not be returned.
|
||
kpp_[0] = fromKPP(king_, piece0_, piece1_);
|
||
#if defined(USE_KPP_MIRROR_WRITE)
|
||
kpp_[1] = fromKPP(flip_file(king_), Eval::mir_piece(piece0_), Eval::mir_piece(piece1_));
|
||
#endif
|
||
|
||
#else
|
||
// When not using triangular array
|
||
kpp_[0] = fromKPP(king_, piece0_, piece1_);
|
||
kpp_[1] = fromKPP(king_, piece1_, piece0_);
|
||
#if defined(USE_KPP_MIRROR_WRITE)
|
||
kpp_[2] = fromKPP(flip_file(king_), mir_piece(piece0_), mir_piece(piece1_));
|
||
kpp_[3] = fromKPP(flip_file(king_), mir_piece(piece1_), mir_piece(piece0_));
|
||
#endif
|
||
#endif
|
||
}
|
||
|
||
// Get the index when counting the value of min_index() of this class as 0.
|
||
virtual uint64_t toRawIndex() const {
|
||
|
||
#if !defined(USE_TRIANGLE_WEIGHT_ARRAY)
|
||
|
||
return ((uint64_t)king_ * (uint64_t)fe_end_ + (uint64_t)piece0_) * (uint64_t)fe_end_ + (uint64_t)piece1_;
|
||
|
||
#else
|
||
// Macro similar to that used in Bonanza 6.0
|
||
auto PcPcOnSq = [&](Square k, PieceSquare i, PieceSquare j)
|
||
{
|
||
|
||
// (i,j) in this triangular array is the element in the i-th row and the j-th column.
|
||
// 1st row + 2 + ... + i = i * (i+1) / 2 because the i-th row and 0th column is the total of the elements up to that point
|
||
// The i-th row and the j-th column is j plus this. i*(i+1)/2+j
|
||
|
||
// PieceSquare type is assumed to be 32 bits, so if you do not pay attention to multiplication, it will overflow.
|
||
return (uint64_t)k * triangle_fe_end + (uint64_t)(uint64_t(i)*(uint64_t(i)+1) / 2 + uint64_t(j));
|
||
};
|
||
|
||
auto k = king_;
|
||
auto i = piece0_;
|
||
auto j = piece1_;
|
||
|
||
return (i >= j) ? PcPcOnSq(k, i, j) : PcPcOnSq(k, j, i);
|
||
#endif
|
||
}
|
||
|
||
// Returns whether or not the dimension lowered with toLowerDimensions is inverse.
|
||
// Prepared to match KK, KKP and interface. This method always returns false for this KPP class.
|
||
bool is_inverse() const {
|
||
return false;
|
||
}
|
||
|
||
// comparison operator
|
||
bool operator==(const KPP& rhs) {
|
||
return king() == rhs.king() &&
|
||
((piece0() == rhs.piece0() && piece1() == rhs.piece1())
|
||
#if defined(USE_TRIANGLE_WEIGHT_ARRAY)
|
||
// When using a triangular array, allow swapping of piece0 and piece1.
|
||
|| (piece0() == rhs.piece1() && piece1() == rhs.piece0())
|
||
#endif
|
||
); }
|
||
bool operator!=(const KPP& rhs) { return !(*this == rhs); }
|
||
|
||
|
||
private:
|
||
Square king_;
|
||
PieceSquare piece0_, piece1_;
|
||
|
||
uint64_t triangle_fe_end; // = (uint64_t)fe_end_*((uint64_t)fe_end_ + 1) / 2;
|
||
};
|
||
|
||
// Output for debugging.
|
||
static std::ostream& operator<<(std::ostream& os, KPP rhs)
|
||
{
|
||
os << "KPP(" << rhs.king() << "," << rhs.piece0() << "," << rhs.piece1() << ")";
|
||
return os;
|
||
}
|
||
|
||
// 4 pieces related to KPPP. However, if there is a turn and you do not consider mirrors etc., memory of 2 TB or more is required for learning.
|
||
// Even if you use a triangular array, you need 50GB x 12 bytes = 600GB for learning.
|
||
// It takes about half as much as storing only the mirrored one.
|
||
// Here, the triangular array is always used and the mirrored one is stored.
|
||
//
|
||
// Also, king() of this class is not limited to Square of the actual king, but a value from 0 to (king_sq-1) is simply returned.
|
||
// This needs to be converted to an appropriate ball position on the user side when performing compression using a mirror.
|
||
//
|
||
// Later, regarding the pieces0,1,2 returned by this class,
|
||
// piece0() >piece1() >piece2()
|
||
// It is, and it is necessary to keep this constraint when passing piece0,1,2 in the constructor.
|
||
struct KPPP : public SerializerBase
|
||
{
|
||
protected:
|
||
KPPP(int king, PieceSquare p0, PieceSquare p1, PieceSquare p2) :
|
||
king_(king), piece0_(p0), piece1_(p1), piece2_(p2)
|
||
{
|
||
assert(piece0_ > piece1_ && piece1_ > piece2_);
|
||
/* sort_piece(); */
|
||
}
|
||
|
||
public:
|
||
KPPP() {}
|
||
|
||
virtual uint64_t size() const { return (uint64_t)max_king_sq_*triangle_fe_end; }
|
||
|
||
// Set fe_end and king_sq.
|
||
// fe_end: fe_end assumed by this KPPP class
|
||
// king_sq: Number of balls to handle in KPPP.
|
||
// 3 layers x 3 mirrors = 3 layers x 5 lines = 15
|
||
// 2 steps x 2 mirrors without mirror = 18
|
||
// Set this first using set() on the side that uses this KPPP class.
|
||
virtual void set(int max_king_sq, uint64_t fe_end,uint64_t min_index) {
|
||
// This value is used in size(), and size() is used in SerializerBase::set(), so calculate first.
|
||
triangle_fe_end = fe_end * (fe_end - 1) * (fe_end - 2) / 6;
|
||
|
||
SerializerBase::set(max_king_sq, fe_end, min_index);
|
||
}
|
||
|
||
// number of dimension reductions
|
||
// For the time being, the dimension reduction of the mirror is not supported. I wonder if I'll do it here...
|
||
/*
|
||
#if defined(USE_KPPP_MIRROR_WRITE)
|
||
#define KPPP_LOWER_COUNT 2
|
||
#else
|
||
#define KPPP_LOWER_COUNT 1
|
||
#endif
|
||
*/
|
||
#define KPPP_LOWER_COUNT 1
|
||
|
||
// Get the index of the low-dimensional array.
|
||
// Note that the one with p0,p1,p2 swapped will not be returned.
|
||
// Also, the mirrored one is returned only when USE_KPPP_MIRROR_WRITE is enabled.
|
||
void toLowerDimensions(/*out*/ KPPP kppp_[KPPP_LOWER_COUNT]) const
|
||
{
|
||
kppp_[0] = fromKPPP(king_, piece0_, piece1_,piece2_);
|
||
#if KPPP_LOWER_COUNT > 1
|
||
// If mir_piece is done, it will be in a state not sorted. Need code to sort.
|
||
PieceSquare p_list[3] = { mir_piece(piece2_), mir_piece(piece1_), mir_piece(piece0_) };
|
||
my_insertion_sort(p_list, 0, 3);
|
||
kppp_[1] = fromKPPP((int)flip_file((Square)king_), p_list[2] , p_list[1], p_list[0]);
|
||
#endif
|
||
}
|
||
|
||
// builder that creates KPPP object from index (serial number)
|
||
KPPP fromIndex(uint64_t index) const { assert(index >= min_index()); return fromRawIndex(index - min_index()); }
|
||
|
||
// A builder that creates KPPP objects from raw_index (a number that starts from 0, not a serial number)
|
||
KPPP fromRawIndex(uint64_t raw_index) const
|
||
{
|
||
uint64_t index2 = raw_index % triangle_fe_end;
|
||
|
||
// Write the expression to find piece0, piece1, piece2 from index2 here.
|
||
// This is the inverse function of index2 = i(i-1)(i-2)/6-1 + j(j+1)/2 + k.
|
||
// For j = k = 0, the real root is i = ... from the solution formula of the cubic equation. (The following formula)
|
||
// However, if index2 is 0 or 1, there are multiple real solutions. You have to consider this. It is necessary to take measures against insufficient calculation accuracy.
|
||
// After i is calculated, i can be converted into an integer, then put in the first expression and then j can be calculated in the same way as in KPP.
|
||
|
||
// This process is a relatively difficult numerical calculation. Various ideas are needed.
|
||
|
||
int piece0;
|
||
if (index2 <= 1)
|
||
{
|
||
// There are multiple real solutions only when index2 == 0,1.
|
||
piece0 = (int)index2 + 2;
|
||
|
||
} else {
|
||
|
||
//double t = pow(sqrt((243 *index2 * index2-1) * 3) + 27 * index2, 1.0 / 3);
|
||
// → In this case, the content of sqrt() will overflow if index2 becomes large.
|
||
|
||
// Since the contents of sqrt() overflow, do not multiply 3.0 in sqrt, but multiply sqrt(3.0) outside sqrt.
|
||
// Since the contents of sqrt() will overflow, use an approximate expression when index2 is large.
|
||
|
||
double t;
|
||
|
||
if (index2 < 100000000)
|
||
t = pow(sqrt((243.0 *index2 * index2 - 1)) * sqrt(3.0) + 27 * index2, 1.0 / 3);
|
||
else
|
||
// If index2 is very large, we can think of the contents of sqrt as approximately √243 * index2.
|
||
t = pow( index2 * sqrt(243 * 3.0) + 27 * index2, 1.0 / 3);
|
||
|
||
// Add deltas to avoid a slight calculation error when rounding.
|
||
// If it is too large, it may increase by 1 so adjustment is necessary.
|
||
|
||
const double delta = 0.000000001;
|
||
|
||
piece0 = int(t / pow(3.0, 2.0 / 3) + 1.0 / (pow(3.0, 1.0 / 3) * t) + delta) + 1;
|
||
// Uuu. Is it really like this? ('Ω`)
|
||
}
|
||
|
||
//Since piece2 is obtained, substitute piece2 for i of i(i-1)(i-2)/6 (=a) in the above formula. Also substitute k = 0.
|
||
// j(j+1)/2 = index2-a
|
||
// This is from the solution formula of the quadratic equation..
|
||
|
||
uint64_t a = (uint64_t)piece0*((uint64_t)piece0 - 1)*((uint64_t)piece0 - 2) / 6;
|
||
int piece1 = int((1 + sqrt(8.0 * (index2 - a ) + 1)) / 2);
|
||
uint64_t b = (uint64_t)piece1 * (piece1 - 1) / 2;
|
||
int piece2 = int(index2 - a - b);
|
||
|
||
#if 0
|
||
if (!((piece0 > piece1 && piece1 > piece2)))
|
||
{
|
||
std::cout << index << " , " << index2 << "," << a << "," << sqrt(8.0 * (index2 - a) + 1);
|
||
}
|
||
#endif
|
||
|
||
assert(piece0 > piece1 && piece1 > piece2);
|
||
|
||
assert(piece2 < (int)fe_end_);
|
||
assert(piece1 < (int)fe_end_);
|
||
assert(piece0 < (int)fe_end_);
|
||
|
||
raw_index /= triangle_fe_end;
|
||
|
||
int king = (int)(raw_index /* % SQUARE_NB */);
|
||
assert(king < max_king_sq_);
|
||
|
||
// Propagate king_sq and fe_end.
|
||
return fromKPPP((Square)king, (PieceSquare)piece0, (PieceSquare)piece1 , (PieceSquare)piece2);
|
||
}
|
||
|
||
// Specify k,p0,p1,p2 to build KPPP instance.
|
||
// The king_sq and fe_end passed by set() which is internally retained are inherited.
|
||
KPPP fromKPPP(int king, PieceSquare p0, PieceSquare p1, PieceSquare p2) const
|
||
{
|
||
KPPP kppp(king, p0, p1, p2);
|
||
kppp.set(max_king_sq_, fe_end_,min_index());
|
||
return kppp;
|
||
}
|
||
|
||
// Get the index when counting the value of min_index() of this class as 0.
|
||
virtual uint64_t toRawIndex() const {
|
||
|
||
// Macro similar to the one used in Bonanza 6.0
|
||
// Precondition) i> j> k.
|
||
// NG in case of i==j,j==k.
|
||
auto PcPcPcOnSq = [this](int king, PieceSquare i, PieceSquare j , PieceSquare k)
|
||
{
|
||
// (i,j,k) in this triangular array is the element in the i-th row and the j-th column.
|
||
// 0th row 0th column 0th is the sum of the elements up to that point, so 0 + 0 + 1 + 3 + 6 + ... + (i)*(i-1)/2 = i*( i-1)*(i-2)/6
|
||
// i-th row, j-th column, 0-th is j with j added. + j*(j-1) / 2
|
||
// i-th row, j-th column and k-th row is k plus it. + k
|
||
assert(i > j && j > k);
|
||
|
||
// PieceSquare type is assumed to be 32 bits, so if you do not pay attention to multiplication, it will overflow.
|
||
return (uint64_t)king * triangle_fe_end + (uint64_t)(
|
||
uint64_t(i)*(uint64_t(i) - 1) * (uint64_t(i) - 2) / 6
|
||
+ uint64_t(j)*(uint64_t(j) - 1) / 2
|
||
+ uint64_t(k)
|
||
);
|
||
};
|
||
|
||
return PcPcPcOnSq(king_, piece0_, piece1_, piece2_);
|
||
}
|
||
|
||
// When you construct this object using fromIndex(), you can get information with the following accessors.
|
||
int king() const { return king_; }
|
||
PieceSquare piece0() const { return piece0_; }
|
||
PieceSquare piece1() const { return piece1_; }
|
||
PieceSquare piece2() const { return piece2_; }
|
||
// Returns whether or not the dimension lowered with toLowerDimensions is inverse.
|
||
// Prepared to match KK, KKP and interface. This method always returns false for this KPPP class.
|
||
bool is_inverse() const {
|
||
return false;
|
||
}
|
||
|
||
// Returns the number of elements in a triangular array. It is assumed that the kppp array is the following two-dimensional array.
|
||
// kppp[king_sq][triangle_fe_end];
|
||
uint64_t get_triangle_fe_end() const { return triangle_fe_end; }
|
||
|
||
// comparison operator
|
||
bool operator==(const KPPP& rhs) {
|
||
// piece0> piece1> piece2 is assumed, so there is no possibility of replacement.
|
||
return king() == rhs.king() && piece0() == rhs.piece0() && piece1() == rhs.piece1() && piece2() == rhs.piece2();
|
||
}
|
||
bool operator!=(const KPPP& rhs) { return !(*this == rhs); }
|
||
|
||
private:
|
||
|
||
int king_;
|
||
PieceSquare piece0_, piece1_,piece2_;
|
||
|
||
// The part of the square array of [fe_end][fe_end][fe_end] of kppp[king_sq][fe_end][fe_end][fe_end] is made into a triangular array.
|
||
// If kppp[king_sq][triangle_fe_end], the number of elements from the 0th row of this triangular array is 0,0,1,3,..., The nth row is n(n-1)/2.
|
||
// therefore,
|
||
// triangle_fe_end = Σn(n-1)/2 , n=0..fe_end-1
|
||
// = fe_end * (fe_end - 1) * (fe_end - 2) / 6
|
||
uint64_t triangle_fe_end; // ((uint64_t)PieceSquare::PS_END)*((uint64_t)PieceSquare::PS_END - 1)*((uint64_t)PieceSquare::PS_END - 2) / 6;
|
||
};
|
||
|
||
// Output for debugging.
|
||
static std::ostream& operator<<(std::ostream& os, KPPP rhs)
|
||
{
|
||
os << "KPPP(" << rhs.king() << "," << rhs.piece0() << "," << rhs.piece1() << "," << rhs.piece2() << ")";
|
||
return os;
|
||
}
|
||
|
||
// For learning about 4 pieces by KKPP.
|
||
//
|
||
// Same design as KPPP class. In KPPP class, treat as one with less p.
|
||
// The positions of the two balls are encoded as values from 0 to king_sq-1.
|
||
//
|
||
// Later, regarding the pieces0 and 1 returned by this class,
|
||
// piece0() >piece1()
|
||
// It is, and it is necessary to keep this constraint even when passing piece0,1 in the constructor.
|
||
//
|
||
// Due to this constraint, PieceSquareZero cannot be assigned to piece0 and piece1 at the same time and passed.
|
||
// If you want to support learning of dropped frames, you need to devise with evaluate().
|
||
struct KKPP: SerializerBase
|
||
{
|
||
protected:
|
||
KKPP(int king, PieceSquare p0, PieceSquare p1) :
|
||
king_(king), piece0_(p0), piece1_(p1)
|
||
{
|
||
assert(piece0_ > piece1_);
|
||
/* sort_piece(); */
|
||
}
|
||
|
||
public:
|
||
KKPP() {}
|
||
|
||
virtual uint64_t size() const { return (uint64_t)max_king_sq_*triangle_fe_end; }
|
||
|
||
// Set fe_end and king_sq.
|
||
// fe_end: fe_end assumed by this KPPP class
|
||
// king_sq: Number of balls to handle in KPPP.
|
||
// 9 steps x mirrors 9 steps x 5 squared squares (balls before and after) = 45*45 = 2025.
|
||
// Set this first using set() on the side that uses this KKPP class.
|
||
void set(int max_king_sq, uint64_t fe_end , uint64_t min_index) {
|
||
// This value is used in size(), and size() is used in SerializerBase::set(), so calculate first.
|
||
triangle_fe_end = fe_end * (fe_end - 1) / 2;
|
||
|
||
SerializerBase::set(max_king_sq, fe_end, min_index);
|
||
}
|
||
|
||
// number of dimension reductions
|
||
// For the time being, the dimension reduction of the mirror is not supported. I wonder if I'll do it here... (Because the memory for learning is a waste)
|
||
#define KKPP_LOWER_COUNT 1
|
||
|
||
// Get the index of the low-dimensional array.
|
||
//Note that the one with p0,p1,p2 swapped will not be returned.
|
||
// Also, the mirrored one is returned only when USE_KPPP_MIRROR_WRITE is enabled.
|
||
void toLowerDimensions(/*out*/ KKPP kkpp_[KPPP_LOWER_COUNT]) const
|
||
{
|
||
kkpp_[0] = fromKKPP(king_, piece0_, piece1_);
|
||
|
||
// When mirroring, mir_piece will not be sorted. Need code to sort.
|
||
// We also need to define a mirror for king_.
|
||
}
|
||
|
||
// builder that creates KKPP object from index (serial number)
|
||
KKPP fromIndex(uint64_t index) const { assert(index >= min_index()); return fromRawIndex(index - min_index()); }
|
||
|
||
// builder that creates KKPP object from raw_index (number starting from 0, not serial number)
|
||
KKPP fromRawIndex(uint64_t raw_index) const
|
||
{
|
||
uint64_t index2 = raw_index % triangle_fe_end;
|
||
|
||
// Write the expression to find piece0, piece1, piece2 from index2 here.
|
||
// This is the inverse function of index2 = i(i-1)/2 + j.
|
||
// Use the formula of the solution of the quadratic equation with j=0.
|
||
// When index2=0, it is a double root, but the smaller one does not satisfy i>j and is ignored.
|
||
|
||
int piece0 = (int(sqrt(8 * index2 + 1)) + 1)/2;
|
||
int piece1 = int(index2 - piece0 * (piece0 - 1) /2 );
|
||
|
||
assert(piece0 > piece1);
|
||
|
||
assert(piece1 < (int)fe_end_);
|
||
assert(piece0 < (int)fe_end_);
|
||
|
||
raw_index /= triangle_fe_end;
|
||
|
||
int king = (int)(raw_index /* % SQUARE_NB */);
|
||
assert(king < max_king_sq_);
|
||
|
||
// Propagate king_sq and fe_end.
|
||
return fromKKPP(king, (PieceSquare)piece0, (PieceSquare)piece1);
|
||
}
|
||
|
||
// Specify k,p0,p1 to build KKPP instance.
|
||
// The king_sq and fe_end passed by set() which is internally retained are inherited.
|
||
KKPP fromKKPP(int king, PieceSquare p0, PieceSquare p1) const
|
||
{
|
||
KKPP kkpp(king, p0, p1);
|
||
kkpp.set(max_king_sq_, fe_end_,min_index());
|
||
return kkpp;
|
||
}
|
||
|
||
// Get the index when counting the value of min_index() of this class as 0.
|
||
virtual uint64_t toRawIndex() const {
|
||
|
||
// Macro similar to the one used in Bonanza 6.0
|
||
// Precondition) i> j.
|
||
// NG in case of i==j,j==k.
|
||
auto PcPcOnSq = [this](int king, PieceSquare i, PieceSquare j)
|
||
{
|
||
assert(i > j);
|
||
|
||
// PieceSquare type is assumed to be 32 bits, so if you do not pay attention to multiplication, it will overflow.
|
||
return (uint64_t)king * triangle_fe_end + (uint64_t)(
|
||
+ uint64_t(i)*(uint64_t(i) - 1) / 2
|
||
+ uint64_t(j)
|
||
);
|
||
};
|
||
|
||
return PcPcOnSq(king_, piece0_, piece1_);
|
||
}
|
||
|
||
// When you construct this object using fromIndex(), fromKKPP(), you can get information with the following accessors.
|
||
int king() const { return king_; }
|
||
PieceSquare piece0() const { return piece0_; }
|
||
PieceSquare piece1() const { return piece1_; }
|
||
|
||
// Returns whether or not the dimension lowered with toLowerDimensions is inverse.
|
||
// Prepared to match KK, KKP and interface. In this KKPP class, this method always returns false.
|
||
bool is_inverse() const {
|
||
return false;
|
||
}
|
||
|
||
//Returns the number of elements in a triangular array. It is assumed that the kkpp array is the following two-dimensional array.
|
||
// kkpp[king_sq][triangle_fe_end];
|
||
uint64_t get_triangle_fe_end() const { return triangle_fe_end; }
|
||
|
||
// comparison operator
|
||
bool operator==(const KKPP& rhs) {
|
||
// Since piece0> piece1 is assumed, there is no possibility of replacement.
|
||
return king() == rhs.king() && piece0() == rhs.piece0() && piece1() == rhs.piece1();
|
||
}
|
||
bool operator!=(const KKPP& rhs) { return !(*this == rhs); }
|
||
|
||
private:
|
||
|
||
int king_;
|
||
PieceSquare piece0_, piece1_;
|
||
|
||
// Triangularize the square array part of [fe_end][fe_end] of kppp[king_sq][fe_end][fe_end].
|
||
uint64_t triangle_fe_end = 0;
|
||
|
||
};
|
||
|
||
// Output for debugging.
|
||
static std::ostream& operator<<(std::ostream& os, KKPP rhs)
|
||
{
|
||
os << "KKPP(" << rhs.king() << "," << rhs.piece0() << "," << rhs.piece1() << ")";
|
||
return os;
|
||
}
|
||
|
||
|
||
}
|
||
|
||
#endif // defined (EVAL_LEARN)
|
||
#endif
|