/* pre: size > 1 && no variable occurs twice
*/
static clause* clause_new(solver* s, lit* begin, lit* end, int learnt)
{
int size;
clause* c;
int i;
assert(end - begin > 1);
assert(learnt >= 0 && learnt < 2);
size = end - begin;
c = (clause*)malloc(sizeof(clause)
+ sizeof(lit) * size + learnt * sizeof(float));
c->size_learnt = (size << 1) | learnt;
#if 0 /* by mao; meaningless non-portable check */
assert(((unsigned int)c & 1) == 0);
#endif
for (i = 0; i < size; i++)
c->lits[i] = begin[i];
if (learnt)
*((float*)&c->lits[size]) = 0.0;
assert(begin[0] >= 0);
assert(begin[0] < s->size*2);
assert(begin[1] >= 0);
assert(begin[1] < s->size*2);
assert(lit_neg(begin[0]) < s->size*2);
assert(lit_neg(begin[1]) < s->size*2);
/* vecp_push(solver_read_wlist(s,lit_neg(begin[0])),(void*)c); */
/* vecp_push(solver_read_wlist(s,lit_neg(begin[1])),(void*)c); */
vecp_push(solver_read_wlist(s,lit_neg(begin[0])),
(void*)(size > 2 ? c : clause_from_lit(begin[1])));
vecp_push(solver_read_wlist(s,lit_neg(begin[1])),
(void*)(size > 2 ? c : clause_from_lit(begin[0])));
return c;
}
bool solver_addclause(solver* s, lit* begin, lit* end)
{
lit *i,*j;
int maxvar;
lbool* values;
lit last;
if (begin == end) return false;
/* printlits(begin,end); printf("\n"); */
/* insertion sort */
maxvar = lit_var(*begin);
for (i = begin + 1; i < end; i++){
lit l = *i;
maxvar = lit_var(l) > maxvar ? lit_var(l) : maxvar;
for (j = i; j > begin && *(j-1) > l; j--)
*j = *(j-1);
*j = l;
}
solver_setnvars(s,maxvar+1);
/* printlits(begin,end); printf("\n"); */
values = s->assigns;
/* delete duplicates */
last = lit_Undef;
for (i = j = begin; i < end; i++){
/* printf("lit: "L_LIT", value = %d\n", L_lit(*i),
(lit_sign(*i) ? -values[lit_var(*i)] : values[lit_var(*i)])); */
lbool sig = !lit_sign(*i); sig += sig - 1;
if (*i == lit_neg(last) || sig == values[lit_var(*i)])
return true; /* tautology */
else if (*i != last && values[lit_var(*i)] == l_Undef)
last = *j++ = *i;
}
/* printf("final: "); printlits(begin,j); printf("\n"); */
if (j == begin) /* empty clause */
return false;
else if (j - begin == 1) /* unit clause */
return enqueue(s,*begin,(clause*)0);
/* create new clause */
vecp_push(&s->clauses,clause_new(s,begin,j,0));
s->stats.clauses++;
s->stats.clauses_literals += j - begin;
return true;
}
static void solver_record(solver* s, veci* cls)
{
lit* begin = veci_begin(cls);
lit* end = begin + veci_size(cls);
clause* c = (veci_size(cls) > 1) ? clause_new(s,begin,end,1)
: (clause*)0;
enqueue(s,*begin,c);
assert(veci_size(cls) > 0);
if (c != 0) {
vecp_push(&s->learnts,c);
act_clause_bump(s,c);
s->stats.learnts++;
s->stats.learnts_literals += veci_size(cls);
}
}
bool solver_addclause(solver* s, lit* begin, lit* end)
{
lit *i,*j;
int maxvar;
if (begin == end) return false; // Empty clause
// insertion sort
maxvar = lit_var(*begin);
for (i = begin + 1; i < end; i++){
lit l = *i;
maxvar = lit_var(l) > maxvar ? lit_var(l) : maxvar;
for (j = i; j > begin && *(j-1) > l; j--)
*j = *(j-1);
*j = l;
}
solver_setnvars(s,maxvar+1);
// create new clause
vecp_push(&s->clauses,clause_new(s,begin,end));
s->tail++; // tail == # of clauses at first.
return true;
}
clause* solver_propagate(solver* s)
{
lbool* values = s->assigns;
clause* confl = (clause*)0;
lit* lits;
/* printf("solver_propagate\n"); */
while (confl == 0 && s->qtail - s->qhead > 0){
lit p = s->trail[s->qhead++];
vecp* ws = solver_read_wlist(s,p);
clause **begin = (clause**)vecp_begin(ws);
clause **end = begin + vecp_size(ws);
clause **i, **j;
s->stats.propagations++;
s->simpdb_props--;
/* printf("checking lit %d: "L_LIT"\n", veci_size(ws),
L_lit(p)); */
for (i = j = begin; i < end; ){
if (clause_is_lit(*i)){
*j++ = *i;
if (!enqueue(s,clause_read_lit(*i),clause_from_lit(p))){
confl = s->binary;
(clause_begin(confl))[1] = lit_neg(p);
(clause_begin(confl))[0] = clause_read_lit(*i++);
/* Copy the remaining watches: */
while (i < end)
*j++ = *i++;
}
}else{
lit false_lit;
lbool sig;
lits = clause_begin(*i);
/* Make sure the false literal is data[1]: */
false_lit = lit_neg(p);
if (lits[0] == false_lit){
lits[0] = lits[1];
lits[1] = false_lit;
}
assert(lits[1] == false_lit);
/* printf("checking clause: ");
printlits(lits, lits+clause_size(*i));
printf("\n"); */
/* If 0th watch is true, then clause is already
satisfied. */
sig = !lit_sign(lits[0]); sig += sig - 1;
if (values[lit_var(lits[0])] == sig){
*j++ = *i;
}else{
/* Look for new watch: */
lit* stop = lits + clause_size(*i);
lit* k;
for (k = lits + 2; k < stop; k++){
lbool sig = lit_sign(*k); sig += sig - 1;
if (values[lit_var(*k)] != sig){
lits[1] = *k;
*k = false_lit;
vecp_push(solver_read_wlist(s,
lit_neg(lits[1])),*i);
goto next; }
}
*j++ = *i;
/* Clause is unit under assignment: */
if (!enqueue(s,lits[0], *i)){
confl = *i++;
/* Copy the remaining watches: */
while (i < end)
*j++ = *i++;
}
}
}
next:
i++;
}
s->stats.inspects += j - (clause**)vecp_begin(ws);
vecp_resize(ws,j - (clause**)vecp_begin(ws));
}
return confl;
}
