// field=<integer value>
void
sql_query::add_clause(const QString field, int value)
{
char valbuf[12];
sprintf(valbuf, "%d", value);
add_clause(field, valbuf);
}
void flwor_expr::add_where(expr* e)
{
where_clause* whereClause = theCCB->theEM->
create_where_clause(theSctx, e->get_loc(), e);
add_clause(whereClause);
}
/****************************************************************
...
*****************************************************************/
void handle_diplomacy_create_clause(struct packet_diplomacy_info *pa)
{
struct Diplomacy_dialog *pdialog;
if((pdialog=find_diplomacy_dialog(&game.players[pa->plrno0],
&game.players[pa->plrno1]))) {
add_clause(&pdialog->treaty, &game.players[pa->plrno_from],
pa->clause_type, pa->value);
update_diplomacy_dialog(pdialog);
}
}
//swap clause_In solver_In
extern "C" value C_add_clause(value clause_In, value solver_In)
{
CAMLparam2 (clause_In, solver_In);
solver_c s = (solver_c) Field(solver_In, 0);
int size = Wosize_val(clause_In);
init_clause (s);
int i;
for (i = 0; i < size; i++)
{
value caml_val = Field(clause_In, i);
lit_c lit = (lit_c) Field(caml_val,0);
add_lit_clause(s, lit);
}
if (add_clause(s))
{
CAMLreturn (Val_bool(1));
}
else
{CAMLreturn (Val_bool(0));}
}
/**************************************************************************
...
**************************************************************************/
void handle_diplomacy_create_clause(struct player *pplayer,
struct packet_diplomacy_info *packet)
{
struct Treaty *ptreaty;
struct player *plr0, *plr1, *pgiver;
plr0=&game.players[packet->plrno0];
plr1=&game.players[packet->plrno1];
pgiver=&game.players[packet->plrno_from];
if((ptreaty=find_treaty(plr0, plr1))) {
if(add_clause(ptreaty, pgiver, packet->clause_type, packet->value)) {
send_packet_diplomacy_info(plr0->conn,
PACKET_DIPLOMACY_CREATE_CLAUSE,
packet);
send_packet_diplomacy_info(plr1->conn,
PACKET_DIPLOMACY_CREATE_CLAUSE,
packet);
}
}
}
// field=<string value>
void sql_query::add_clause(const QString field, const QString value)
{
add_clause(field,value,"=");
}
static int build_instance(char *filename, smt_core_t *core) {
int l, n, c_idx, literal, nvars, nclauses;
char *s;
FILE *f;
ivector_t buffer;
f = fopen(filename, "r");
if (f == NULL) {
perror(filename);
return OPEN_ERROR;
}
s = fgets(line, MAX_LINE, f);
l = 1; /* line number */
if (s == NULL) {
fprintf(stderr, "%s: empty file\n", filename);
fclose(f);
return FORMAT_ERROR;
}
/* skip empty and comment lines */
while (*s == 'c' || *s == '\n') {
s = fgets(line, MAX_LINE, f);
l ++;
if (s == NULL) {
fprintf(stderr, "Format error: file %s, line %d\n", filename, l);
fclose(f);
return FORMAT_ERROR;
}
}
/* read problem size */
n = sscanf(s, "p cnf %d %d", &nvars, &nclauses);
if (n != 2 || nvars < 0 || nclauses < 0) {
fprintf(stderr, "Format error: file %s, line %d\n", filename, l);
fclose(f);
return FORMAT_ERROR;
}
/* initialize core for nvars */
init_sat_solver(core, nvars);
/* initialize the clause buffer */
init_ivector(&buffer, 10);
/* now read the clauses and translate them */
c_idx = 0;
while (c_idx < nclauses) {
for (;;) {
literal = read_literal(f, nvars);
if (literal < 0) break;
ivector_push(&buffer, literal);
}
if (literal != END_OF_CLAUSE) {
fprintf(stderr, "Format error: file %s\n", filename);
fclose(f);
return FORMAT_ERROR;
}
add_clause(core, buffer.size, buffer.data);
c_idx ++;
ivector_reset(&buffer);
}
delete_ivector(&buffer);
fclose(f);
return 0;
}
valuation solver::solve() {
if (m_remaining_clauses == -1) // not satisfiable
return { { } };
// solver has to be fully constructed in order to store pointer to `this` somewhere
if (m_options.guess == guess_mode::VSIDS) {
m_vsids_score.resize(m_assignment.size());
for (auto v = 0; v < m_assignment.size(); ++v)
m_vsids_score[v] = std::make_pair(0.0, m_vsids_heap.push({ v, this }));
}
int level = 0;
auto conflict_nb = 0;
auto max_learnt = m_clauses.size() / 3;
while (m_first || m_remaining_clauses > 0) {
m_first = false;
auto conflict = deduce(level);
if (conflict != nullptr) {
#ifdef DEBUG
std::cout << "conflict" << std::endl;
#endif
++conflict_nb;
if (level == 0) {
m_remaining_clauses = -1;
return { { } };
}
auto old_level = level;
detail::clause learnt;
if (conflict != &m_dummy_clause && can_learn()) {
auto knowledge = learn(conflict, level);
level = knowledge.second + 1;
learnt = std::move(knowledge.first);
}
if (conflict_nb % 100 == 0 && m_options.guess == guess_mode::VSIDS) {
for (auto && v : m_vsids_score)
v.first /= 2.0;
}
if (conflict != &m_dummy_clause && m_options.cdcl == cdcl_mode::INTERACTIVE)
interac(conflict, old_level, learnt.watch_0());
auto lit = backtrack(level);
--level;
#ifdef DEBUG
std::cout << "go back to level " << level << std::endl;
#endif
if (conflict != &m_dummy_clause && can_learn()) {
lit = learnt.watch_0();
auto reason = learnt.litterals().size() != 1 ?
add_clause(std::move(learnt)) : nullptr;
enqueue(lit, level, reason);
} else
enqueue(detail::neg(lit), level, nullptr);
} else {
++level;
#ifdef DEBUG
std::cout << "level " << level << std::endl;
#endif
// we have a full valuation
if (m_remaining_variables == 0 || m_remaining_clauses == 0)
break;
if (m_options.forget && m_learnt.size() > max_learnt)
remove_learnt(m_learnt.size() / 2); // remove half of the learnt clauses
if (m_options.guess == guess_mode::MOMS) {
m_min_clause = 2 * m_remaining_variables;
for (auto && c : m_clauses) {
if (c.satisfied_by() != -1)
continue;
auto size = c.count();
if (size <= m_min_clause)
m_min_clause = size;
}
}
auto lit = (this->*m_guess)();
assert(lit != -1);
#ifdef DEBUG
std::cout << "guess " << new_to_old_lit(lit) << std::endl;
#endif
enqueue(lit, level, nullptr);
}
}
m_remaining_clauses = 0;
/* compute a mapping int -> bool out of our valuation stack */
#ifdef DEBUG
std::cout << "satisfiable" << std::endl;
#endif
std::unordered_map<int, bool> result;
for (auto v = 0; v < m_assignment.size(); ++v) {
result.emplace(
m_old_variables[v],
m_assignment[v].pol == detail::polarity::VTRUE ? true : false
);
}
return result;
}
solver::solver(cnf clauses, options opt) : m_options { opt },
m_rng { std::random_device {}() } {
if (m_options.wl) {
assert(m_options.guess != guess_mode::DLIS && m_options.guess != guess_mode::MOMS);
m_backtrack_one = &solver::backtrack_one_wl;
m_deduce_one = &solver::deduce_one_wl;
} else {
m_backtrack_one = &solver::backtrack_one_default;
m_deduce_one = &solver::deduce_one_default;
}
switch (m_options.guess) {
case guess_mode::DLIS:
m_guess = &solver::guess_dlis;
break;
case guess_mode::RAND:
m_guess = &solver::guess_rand;
break;
case guess_mode::MOMS:
m_guess = &solver::guess_moms;
break;
case guess_mode::VSIDS:
assert(can_learn());
m_guess = &solver::guess_vsids;
break;
default:
m_guess = &solver::guess_linear;
}
std::unordered_map<int, int> old_to_new;
// rename variables so that they are consecutive integers
for (auto && clause : clauses) {
for (auto && l : clause) {
auto abs_l = std::abs(l);
if (old_to_new.find(abs_l) == old_to_new.end()) {
old_to_new[abs_l] = (int) m_old_variables.size();
m_old_variables.push_back(abs_l);
}
}
}
m_remaining_variables = m_old_variables.size();
m_valuation.reserve(m_remaining_variables);
m_assignment.resize(
m_remaining_variables,
detail::var_data { detail::polarity::VUNDEF, -1, nullptr }
);
m_watches.resize(2 * m_assignment.size());
if (can_learn())
m_already_seen.resize(m_assignment.size(), false);
if (m_options.guess == guess_mode::MOMS)
m_moms_counts.resize(2 * m_assignment.size(), 0);
// set up clauses
m_remaining_clauses = 0;
for (auto && cnf_clause : clauses) {
detail::clause sat_clause;
bool sat = false;
for (auto && l : cnf_clause) {
auto lit = detail::lit(old_to_new[std::abs(l)], l > 0);
auto polarity = detail::polarity_lit(m_assignment, lit);
if (polarity == detail::polarity::VUNDEF)
sat_clause.emplace(lit);
else if (polarity == detail::polarity::VTRUE) {
sat = true;
break;
}
}
// clause has been already satisfied by previous unit propagation
if (sat)
continue;
auto count = sat_clause.count();
if (count == 0) { // we have found a conflicting clause
m_remaining_clauses = -1;
return;
} else if (count == 1) { // unit clause => propagation
auto first = sat_clause.first_unassigned(m_assignment);
if (first != -1)
enqueue(first, 0, nullptr);
continue;
}
add_clause(std::move(sat_clause));
}
}
