bool ClauseCleaner::satisfied(const Watched& watched, Lit lit)
{
assert(watched.isBinary());
if (solver.value(lit) == l_True) return true;
if (solver.value(watched.getOtherLit()) == l_True) return true;
return false;
}
bool CNF::redundant(const Watched& ws) const
{
return ( (ws.isBinary() && ws.red())
|| (ws.isTri() && ws.red())
|| (ws.isClause()
&& clAllocator.getPointer(ws.getOffset())->red()
)
);
}
bool CNF::redundant_or_removed(const Watched& ws) const
{
if (ws.isBinary() || ws.isTri()) {
return ws.red();
}
assert(ws.isClause());
const Clause* cl = clAllocator.getPointer(ws.getOffset());
return cl->red() || cl->getRemoved();
}
void CompHandler::moveClausesImplicit(
SATSolver* newSolver
, const uint32_t comp
, const vector<Var>& vars
) {
numRemovedHalfIrred = 0;
numRemovedHalfRed = 0;
numRemovedThirdIrred = 0;
numRemovedThirdRed = 0;
for(const Var var: vars) {
for(unsigned sign = 0; sign < 2; ++sign) {
const Lit lit = Lit(var, sign);
watch_subarray ws = solver->watches[lit.toInt()];
//If empty, nothing to to, skip
if (ws.empty()) {
continue;
}
Watched *i = ws.begin();
Watched *j = i;
for (Watched *end2 = ws.end()
; i != end2
; ++i
) {
//At least one variable inside comp
if (i->isBinary()
&& (compFinder->getVarComp(lit.var()) == comp
|| compFinder->getVarComp(i->lit2().var()) == comp
)
) {
move_binary_clause(newSolver, comp, i, lit);
continue;
}
if (i->isTri()
&& (compFinder->getVarComp(lit.var()) == comp
|| compFinder->getVarComp(i->lit2().var()) == comp
|| compFinder->getVarComp(i->lit3().var()) == comp
)
) {
move_tri_clause(newSolver, comp, i, lit);
continue;
}
*j++ = *i;
}
ws.shrink_(i-j);
}}
assert(numRemovedHalfIrred % 2 == 0);
solver->binTri.irredBins -= numRemovedHalfIrred/2;
assert(numRemovedThirdIrred % 3 == 0);
solver->binTri.irredTris -= numRemovedThirdIrred/3;
assert(numRemovedHalfRed % 2 == 0);
solver->binTri.redBins -= numRemovedHalfRed/2;
assert(numRemovedThirdRed % 3 == 0);
solver->binTri.redTris -= numRemovedThirdRed/3;
}
