/* This function tests for divisibility of terms. */
static inline int deelbaar(struct term *mon1, struct term *mon2)
{
return(((mon1->n1 <= mon2->n1) &&
(mon1->n2 <= mon2->n2) &&
(mon1->n3 <= mon2->n3) &&
(mon1->n4 <= mon2->n4) &&
(valuation(mon1->c) <= valuation(mon2->c))));
}
/**
* Prints the condition to an output stream.
*
* @param _out The output stream, where it should print.
*/
void Condition::print( std::ostream& _out ) const
{
_out << constraint().toString( 0, true, true );
_out << " [" << mId << "]";
_out << " ";
if( flag() )
_out << "(true, ";
else
_out << "(false, ";
_out << "valuation=" << valuation();
if( recentlyAdded() )
_out << ", recently added) {";
else
_out << ") {";
if( originalConditions().empty() )
_out << "no original condition}";
else
{
for( auto oCond = originalConditions().begin(); oCond != originalConditions().end(); ++oCond )
{
if( oCond != originalConditions().begin() )
_out << ", ";
_out << "[" << (*oCond)->getId() << "]";
}
_out << " }";
}
}
void TransmitExpression(ElemType *arr)
{
valuation();
assert(arr);
Stack S;
CreateStack(&S); //创建一个栈
ElemType x= 0;
int i = 0;
int j = 0;
while (arr[i] != '\0')
{
if (judge_type(arr[i]) == 1) //判断是不是数字
{
post[j++] = arr[i]; //数字则直接存入post[]
if (judge_type(arr[i+1]) != 1)
post[j++]=' '; //以空格隔开
i++;
}
else
{
if (S.ebp == S.esp) //如果栈为空，压栈
{
push(&S, arr[i]);
i++;
}
else
{
switch (judge_priority(&S, arr[i]))
{
case '<': //如果栈顶的优先级低。则直接入栈
push(&S, arr[i]);
i++;
break;
case '>': //如果读取的优先级高，则栈顶先退栈
pop(&S, &x);
post[j++] = x;
post[j++] = ' ';
break;
case '=':
pop(&S, &x);
i++;
break;
}
}
}
}
while (pop(&S, &x))
{
if (x != '('&&x != ')')
{
post[j++] = x;
post[j++] = ' ';
}
}
printf("%s\n", post);
free(S.ebp);
}
//------------------------------------------------------------------------------
Position *new_position(char *white, char *black) {
tree[node] = (Position){};
Position *self = &tree[node];
setup_side(self, white, White);
setup_side(self, black, Black);
self->castles = castleKingside[White] | castleQueenside[White] | castleKingside[Black] | castleQueenside[Black];
if (self->pieces[E1] != King || self->pieces[H1] != Rook) {
self->castles &= ~castleKingside[White];
}
if (self->pieces[E1] != King || self->pieces[A1] != Rook) {
self->castles &= ~castleQueenside[White];
}
if (self->pieces[E8] != BlackKing || self->pieces[H8] != BlackRook) {
self->castles &= ~castleKingside[Black];
}
if (self->pieces[E8] != BlackKing || self->pieces[A8] != BlackRook) {
self->castles &= ~castleQueenside[Black];
}
for (int sq = A1; sq < len(self->pieces); sq++) {
Piece piece = self->pieces[sq];
if (piece != 0) {
self->outposts[piece] |= bit[sq];
self->outposts[color(piece)] |= bit[sq];
if (is_king(piece)) {
self->king[color(piece)] = (uint8)sq;
}
self->balance += materialBalance[piece];
}
}
self->reversible = true;
self->board = self->outposts[White] | self->outposts[Black];
polyglot(self); // Calculate self->id and self->pawnId.
valuation(self); // Calculate self->tally.
return &tree[node];
}
// Decodes FEN string and creates new position.
//------------------------------------------------------------------------------
Position *new_position_from_fen(char *fen) {
// printf("FEN [%s]\n", fen);
tree[node] = (Position){};
Position *self = &tree[node];
char *buffer = (char *)calloc(strlen(fen) + 1, 1); // strdup() the string so we could tokenize it.
strcat(buffer, fen);
// Expected matches of interest are as follows:
// [0] - Pieces (entire board).
// [1] - Color of side to move.
// [2] - Castle rights.
// [3] - En-passant square.
// [4] - Number of half-moves.
// [5] - Number of full moves.
char *matches[6] = {};
char *token = strtok(buffer, " ");
for (int i = 0; i < len(matches) && token; i++) {
matches[i] = token;
token = strtok(NULL, " ");
}
// First four parts are required.
if (!matches[4]) {
return NULL;
}
// [0] - Pieces (entire board).
int sq = A8;
for (char *ch = matches[0]; *ch; ch++) {
Piece piece = (Piece)0;
switch(*ch) {
case 'P':
piece = Pawn;
break;
case 'p':
piece = BlackPawn;
break;
case 'N':
piece = Knight;
break;
case 'n':
piece = BlackKnight;
break;
case 'B':
piece = Bishop;
break;
case 'b':
piece = BlackBishop;
break;
case 'R':
piece = Rook;
break;
case 'r':
piece = BlackRook;
break;
case 'Q':
piece = Queen;
break;
case 'q':
piece = BlackQueen;
break;
case 'K':
piece = King;
self->king[White] = (uint8)sq;
break;
case 'k':
piece = BlackKing;
self->king[Black] = (uint8)sq;
break;
case '/':
sq -= 16;
break;
case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8':
sq += *ch - '0';
}
if (piece) {
self->pieces[sq] = piece;
self->outposts[piece] |= bit[sq];
self->outposts[color(piece)] |= bit[sq];
self->balance += materialBalance[piece];
sq++;
}
}
// [1] - Color of side to move.
if (matches[1][0] == 'w') {
self->color = White;
} else {
self->color = Black;
}
// [2] - Castle rights.
for (char *ch = matches[2]; *ch; ch++) {
switch(*ch) {
case 'K':
self->castles |= castleKingside[White];
break;
case 'Q':
self->castles |= castleQueenside[White];
break;
case 'k':
self->castles |= castleKingside[Black];
break;
case 'q':
self->castles |= castleQueenside[Black];
break;
case '-':
; // No castling rights.
}
}
// [3] - En-passant square.
if (matches[3][0] != '-') {
self->enpassant = (uint8)(square(matches[3][1] - '1', matches[3][0] - 'a'));
}
self->reversible = true;
self->board = self->outposts[White] | self->outposts[Black];
polyglot(self);
valuation(self);
free(buffer);
return self;
}
