inline HexColor StoneBoard::WhoseTurn() const
{
BenzeneAssert(IsStandardPosition());
bitset_t mask = GetPlayed() & Const().GetCells();
std::size_t first = (GetColor(FIRST_TO_PLAY) & mask).count();
std::size_t second = (GetColor(!FIRST_TO_PLAY) & mask).count();
return (first > second) ? !FIRST_TO_PLAY : FIRST_TO_PLAY;
}
NODE * Div( NODE *n1, NODE *n2 )
{
if( n1 == 0 ) return BinaryOp( DIV, Const(1), n2 );
if( n2 == 0 ) return n1;
if( IsConst( n2, 1 ) ) {
n2->sign *= n1->sign;
FreeNode( n2 );
return n1;
}
return BinaryOp( DIV, n1, n2 );
}
static void initConst (void)
{ static const struct {
const char * name;
double value;
} constants [] = {
{ "PI", 3.14159265358979323846 },
{ "E", 2.71828182845904523536 },
{ "GAMMA", 0.57721566490153286060 }, /* Euler */
{ "DEG", 57.29577951308232087680 }, /* deg/radian */
{ "PHI", 1.61803398874989484820 }, /* golden ratio */
{ 0 }}, * cp = constants;
while (cp -> name)
install(table, new(Const(), cp -> name, CONST, cp -> value)),
++ cp;
}
void initialize_resolve_macro() {
g_resolve_macro_name = new name("resolve");
g_resolve_opcode = new std::string("Res");
g_or = new expr(Const(get_or_name()));
g_not = new expr(Const(get_not_name()));
g_false = new expr(Const(get_false_name()));
g_or_elim = new expr(Const(get_or_elim_name()));
g_or_intro_left = new expr(Const(get_or_intro_left_name()));
g_or_intro_right = new expr(Const(get_or_intro_right_name()));
g_absurd_elim = new expr(Const(get_absurd_name()));
g_var_0 = new expr(mk_var(0));
g_resolve_macro_definition = new macro_definition(new resolve_macro_definition_cell());
register_macro_deserializer(*g_resolve_opcode,
[](deserializer &, unsigned num, expr const * args) {
if (num != 3)
throw corrupted_stream_exception();
return mk_resolve_macro(args[0], args[1], args[2]);
});
}
void initialize_string() {
g_string_macro = new name("string_macro");
g_string_opcode = new std::string("Str");
g_nat = new expr(Const(get_nat_name()));
g_char = new expr(Const(get_char_name()));
g_char_of_nat = new expr(Const(get_char_of_nat_name()));
g_string = new expr(Const(get_string_name()));
g_empty = new expr(Const(get_string_empty_name()));
g_str = new expr(Const(get_string_str_name()));
g_fin_mk = new expr(Const(get_fin_mk_name()));
g_list_char = new expr(mk_app(mk_constant(get_list_name(), {mk_level_one()}), *g_char));
g_list_cons = new expr(mk_constant(get_list_cons_name(), {mk_level_one()}));
g_list_nil_char = new expr(mk_app(mk_constant(get_list_nil_name(), {mk_level_one()}), *g_char));
register_macro_deserializer(*g_string_opcode,
[](deserializer & d, unsigned num, expr const *) {
if (num != 0)
throw corrupted_stream_exception();
std::string v = d.read_string();
return mk_string_macro(v);
});
}
inline bool StoneBoard::IsPlayed(HexPoint cell) const
{
BenzeneAssert(Const().IsValid(cell));
return m_played.test(cell);
}
inline bool StoneBoard::IsOccupied(HexPoint cell) const
{
BenzeneAssert(Const().IsLocation(cell));
return (IsBlack(cell) || IsWhite(cell));
}
inline bool StoneBoard::IsEmpty(HexPoint cell) const
{
BenzeneAssert(Const().IsLocation(cell));
return !IsOccupied(cell);
}
inline bool StoneBoard::IsColor(HexPoint cell, HexColor color) const
{
BenzeneAssert(HexColorUtil::isBlackWhite(color));
BenzeneAssert(Const().IsLocation(cell));
return m_stones[color].test(cell);
}
inline bool StoneBoard::IsWhite(HexPoint cell) const
{
BenzeneAssert(Const().IsValid(cell));
return m_stones[WHITE].test(cell);
}
inline bitset_t StoneBoard::GetEmpty() const
{
return Const().GetLocations() - GetOccupied();
}
inline bitset_t StoneBoard::GetColor(HexColor color) const
{
BenzeneAssert(HexColorUtil::isValidColor(color));
if (color == EMPTY) return GetEmpty();
return m_stones[color] & Const().GetLocations();
}
inline bitset_t StoneBoard::GetWhite() const
{
return m_stones[WHITE] & Const().GetLocations();
}
inline bitset_t StoneBoard::GetBlack() const
{
return m_stones[BLACK] & Const().GetLocations();
}
Types WhileLoop::allowedTypes(int _index) const
{
if (_index == Condition)
return Type(Bool).topWith(Const());
return Super::allowedTypes(_index);
}
int operator=(double a) { return Const(a); }; // C = a (all entries equal a)
inline std::size_t StoneBoard::NumStones() const
{
return (GetOccupied() & GetPlayed() & Const().GetCells()).count();
}
int intraFont_init(lua_State *L)
{
intraFontInit();
UserdataRegister("intraFont", intraFont_methods, intraFont_metamethods)
lua_pushstring(L, "intraFont");
lua_gettable(L, LUA_GLOBALSINDEX);
Const("CENTER", INTRAFONT_ALIGN_CENTER)
Const("LEFT", INTRAFONT_ALIGN_LEFT)
Const("RIGHT", INTRAFONT_ALIGN_RIGHT)
Const("G_UP", GRAD_UP)
Const("G_RIGHT", GRAD_RIGHT)
Const("G_DOWN", GRAD_DOWN)
Const("G_LEFT", GRAD_LEFT)
Const("G_UP_LEFT", GRAD_UP_LEFT)
Const("G_UP_RIGHT", GRAD_UP_RIGHT)
Const("G_DOWN_LEFT", GRAD_DOWN_LEFT)
Const("G_DOWN_RIGHT", GRAD_DOWN_RIGHT)
return 1;
}
bool EllipseFitting(POINT* rgPoints, int nPoints, double &a, double &b, double &c, double &d, double &e, double &f)
{
int i, j;
int np = nPoints;
int nrot=0;
Matrix<double> D(np+1,7); //Design matrix
Matrix<double> S(7,7); //Scatter matrix
Matrix<double> Const(7,7); //Constraint matrix
Matrix<double> temp(7,7);
Matrix<double> L(7,7); //The lower triangular matrix L * L' = S
Matrix<double> C(7,7);
Matrix<double> invL(7,7); //Inverse matrix of L
Matrix<double> V(7,7); //The eigen vectors
Matrix<double> sol(7,7); //The GVE solution
double ev[7]; //The eigen value
double pvec[7];
if (np < 6)
{
return false;
}
//Build design matrix D
for (i = 0; i < np; i++)
{
D[i][1] = rgPoints[i].x * rgPoints[i].x;
D[i][2] = rgPoints[i].x * rgPoints[i].y;
D[i][3] = rgPoints[i].y * rgPoints[i].y;
D[i][4] = rgPoints[i].x;
D[i][5] = rgPoints[i].y;
D[i][6] = 1.0;
}
//Build Scatter matrix S
A_TperB(D, D, S, np, 6, np, 6);
//Build 6*6 constraint matrix
Const[1][3] = -2;
Const[2][2] = 1;
Const[3][1] = -2;
//Sovle generalized eigen system
choldc(S, 6, L);
if (!inverse(L, invL, 6))
{
return false;
}
AperB_T(Const, invL, temp, 6, 6, 6, 6);
AperB(invL, temp, C, 6, 6, 6, 6);
jacobi(C, 6, ev, V, nrot);
A_TperB(invL, V, sol, 6, 6, 6, 6);
//Normalize the solution
for (j = 1; j <= 6; j++)
{
double mod = 0.0;
for (i = 1; i <= 6; i++)
{
mod += sol[i][j] * sol[i][j];
}
mod = sqrt(mod);
for (i = 1 ; i <= 6; i++)
{
sol[i][j] /= mod;
}
}
double zero = 10e-20;
int solind = 0;
//Find the only negative eigen value
for (i = 1; i <= 6; i++)
{
if ((ev[i] < 0) && (fabs(ev[i]) > zero))
{
solind = i;
}
}
//Get the fitted parameters
for (j = 1; j <= 6; j++)
{
pvec[j] = sol[j][solind];
}
a = pvec[1];
b = pvec[2];
c = pvec[3];
d = pvec[4];
e = pvec[5];
f = pvec[6];
return true;
}
inline bool StoneBoard::IsBlack(HexPoint cell) const
{
BenzeneAssert(Const().IsValid(cell));
return m_stones[BLACK].test(cell);
}
inline bitset_t StoneBoard::GetOccupied() const
{
return (GetBlack() | GetWhite()) & Const().GetLocations();
}
}
void initialize_with_options_tactic() {
g_options_name = new name("options");
g_options_opcode = new std::string("OPTM");
register_macro_deserializer(*g_options_opcode,
[](deserializer & d, unsigned num, expr const *) {
if (num > 0)
throw corrupted_stream_exception();
options info;
d >> info;
return mk_options_expr(info);
});
name with_options_tac_name{"tactic", "with_options_tac"};
g_with_options_tac = new expr(Const(with_options_tac_name));
register_tac(with_options_tac_name,
[=](type_checker & tc, elaborate_fn const & fn, expr const & e, pos_info_provider const * p) {
buffer<expr> args;
get_app_args(e, args);
if (args.size() != 2)
throw expr_to_tactic_exception(e, "invalid 'with_options' tactical, it must have two arguments");
check_tactic_expr(args[0], "invalid 'with_options' tactical, invalid argument");
expr opts = get_tactic_expr_expr(args[0]);
if (!is_options_expr(opts))
throw expr_to_tactic_exception(args[0], "invalid 'with_options' tactical, invalid argument");
tactic t = expr_to_tactic(tc, fn, args[1], p);
return with_options(get_options_expr_options(opts), t);
});
}
