lbool Solver::solve(const vec<Lit>& assumps)
{
//start_time = getRunTime();
model.clear();
conflict.clear();
if (!ok) return false;
assumps.copyTo(assumptions);
double nof_conflicts = restart_first;
double nof_learnts = nClauses() * learntsize_factor;
lbool status = l_Undef;
if (verbosity >= 1){
reportf("============================[ Search Statistics ]==============================\n");
reportf("| Conflicts | ORIGINAL | LEARNT | Progress |\n");
reportf("| | Vars Clauses Literals | Limit Clauses Lit/Cl | |\n");
reportf("===============================================================================\n");
}
// Search:
bool reached_limit = false;
while (status == l_Undef && !reached_limit){
if (verbosity >= 1)
reportf("| %9d | %7d %8d %8d | %8d %8d %6.0f | %6.3f %% |\n", (int)conflicts, order_heap.size(), nClauses(), (int)clauses_literals, (int)nof_learnts, nLearnts(), (double)learnts_literals/nLearnts(), progress_estimate*100), fflush(stdout);
status = search((int)nof_conflicts, (int)nof_learnts);
reached_limit = limitsExpired();
nof_conflicts *= restart_inc;
nof_learnts *= learntsize_inc;
}
if (verbosity >= 1)
reportf("===============================================================================\n");
if (status == l_True){
// Extend & copy model:
model.growTo(nVars());
for (int i = 0; i < nVars(); i++) model[i] = value(i);
#ifndef NDEBUG
verifyModel();
#endif
}else if(status == l_False) {
//assert(status == l_False);
if (conflict.size() == 0)
ok = false;
} // else {
// // limit reached
// }
//cancelUntil(init_level);
return status; // == l_True;
}
lbool Solver::solve(const vec<Lit>& assumps)
{
model.clear();
conflict.clear();
if (!ok) {
return false;
}
assumps.copyTo(assumptions);
double nof_conflicts = restart_first;
double nof_learnts = nClauses() * learntsize_factor;
lbool status = l_Undef;
if (verbosity >= 1){
reportf("============================[ Search Statistics ]==============================\n");
reportf("| Conflicts | ORIGINAL | LEARNT | Progress |\n");
reportf("| | Vars Clauses Literals | Limit Clauses Lit/Cl | |\n");
reportf("===============================================================================\n");
}
// Search:
while (status == l_Undef){
if (verbosity >= 1)
reportf("| .%9d. | .%7d. .%8d. .%8d. | .%8d. .%8d. .%6.0f. | .%6.3f. %% |\n", (int)conflicts, order_heap.size(), nClauses(), (int)clauses_literals, (int)nof_learnts, nLearnts(), (double)learnts_literals/nLearnts(), progress_estimate*100), fflush(stdout);
status = search((int)nof_conflicts, (int)nof_learnts);
nof_conflicts *= restart_inc;
nof_learnts *= learntsize_inc;
}
if (verbosity >= 1)
reportf("===============================================================================\n");
if (status == l_True){
// Extend & copy model:
model.growTo(nVars());
for (int i = 0; i < nVars(); i++)
model[i] = value(i);
// printTrail();
#ifdef _DEBUG
verifyModel();
#endif
}else{
if (conflict.size() == 0) {
ok = false;
}
}
// cancelUntil(0);
return status;
}
bool Solver::solve(const vec<Lit>& assumps)
{
model.clear();
conflict.clear();
nbDecisionLevelHistory.initSize(100);
totalSumOfDecisionLevel = 0;
if (!ok) return false;
assumps.copyTo(assumptions);
double nof_conflicts = restart_first;
nof_learnts = nClauses() * learntsize_factor;
if(nof_learnts <nbclausesbeforereduce) {
nbclausesbeforereduce = (nof_learnts/2 < 5000) ? 5000 : nof_learnts/2;
}
lbool status = l_Undef;
if (verbosity >= 1){
reportf("============================[ Search Statistics ]==============================\n");
reportf("| Conflicts | ORIGINAL | LEARNT | Progress |\n");
reportf("| | Vars Clauses Literals | Limit Clauses Lit/Cl | |\n");
reportf("===============================================================================\n");
}
// Search:
while (status == l_Undef){
if (verbosity >= 1)
reportf("| %9d | %7d %8d %8d | %8d %8d %6.0f | %6.3f %% |\n", (int)conflicts, order_heap.size(), nClauses(), (int)clauses_literals, (int)nof_learnts, nLearnts(), (double)learnts_literals/nLearnts(), progress_estimate*100), fflush(stdout);
status = search((int)nof_conflicts, (int)nof_learnts);
nof_conflicts *= restart_inc;
//LS mis dans reduceDB lui meme nof_learnts *= learntsize_inc;
}
if (verbosity >= 1)
reportf("===============================================================================\n");
if (status == l_True){
// Extend & copy model:
model.growTo(nVars());
for (int i = 0; i < nVars(); i++) model[i] = value(i);
#ifndef NDEBUG
verifyModel();
#endif
}else{
assert(status == l_False);
if (conflict.size() == 0)
ok = false;
}
#ifdef LS_STATS_NBBUMP
for(int i=0;i<learnts.size();i++)
printf("## %d %d %d\n",learnts[i]->size(),learnts[i]->activity(),(unsigned int)learnts[i]->nbBump());
#endif
cancelUntil(0);
return status == l_True;
}
bool MiniSATP::solve(const vec<Lit>& assumps)
{
// Added Line
initExpDup( );
model.clear();
conflict.clear();
if (!ok) {
// Added Line
doneExpDup( );
return false;
}
assumps.copyTo(assumptions);
double nof_conflicts = restart_first;
double nof_learnts = nClauses() * learntsize_factor;
lbool status = l_Undef;
if (verbosity >= 1){
reportf("============================[ Search Statistics ]==============================\n");
reportf("| Conflicts | ORIGINAL | LEARNT | Progress |\n");
reportf("| | Vars Clauses Literals | Limit Clauses Lit/Cl | |\n");
reportf("===============================================================================\n");
}
// Search:
while (status == l_Undef){
if (verbosity >= 1)
reportf("| %9d | %7d %8d %8d | %8d %8d %6.0f | %6.3f %% |\n", (int)conflicts, order_heap.size(), nClauses(), (int)clauses_literals, (int)nof_learnts, nLearnts(), (double)learnts_literals/nLearnts(), progress_estimate*100), fflush(stdout);
status = search((int)nof_conflicts, (int)nof_learnts);
nof_conflicts *= restart_inc;
nof_learnts *= learntsize_inc;
}
if (verbosity >= 1)
reportf("===============================================================================\n");
if (status == l_True){
// Extend & copy model:
model.growTo(nVars());
for (int i = 0; i < nVars(); i++) model[i] = value(i);
#ifndef NDEBUG
verifyModel();
#endif
}else{
assert(status == l_False);
if (conflict.size() == 0)
ok = false;
}
cancelUntil(0);
// cerr << "SOLVE: Memory after: " << memUsed( ) / 1024.0 / 1024.0 << endl;
// Added Line
doneExpDup( );
assert( status == l_True || !explanation.empty( ) );
return status == l_True;
}
int getNbOfFormulas() const { return nClauses(); }
/*_________________________________________________________________________________________________
|
| solve : (assumps : const vec<Lit>&) -> [bool]
|
| Description:
| Top-level solve. If using assumptions (non-empty 'assumps' vector), you must call
| 'simplifyDB()' first to see that no top-level conflict is present (which would put the solver
| in an undefined state).
|________________________________________________________________________________________________@*/
bool Solver::solve(const vec<Lit>& assumps)
{
simplifyDB();
if (!ok) return false;
SearchParams params(default_params);
double nof_conflicts = 100;
double nof_learnts = nClauses() / 3;
lbool status = l_Undef;
// Perform assumptions:
root_level = assumps.size();
for (int i = 0; i < assumps.size(); i++){
Lit p = assumps[i];
assert(var(p) < nVars());
if (!assume(p)){
GClause r = reason[var(p)];
if (r != GClause_NULL){
Clause* confl;
if (r.isLit()){
confl = propagate_tmpbin;
(*confl)[1] = ~p;
(*confl)[0] = r.lit();
}else
confl = r.clause();
analyzeFinal(confl, true);
conflict.push(~p);
}else
conflict.clear(),
conflict.push(~p);
cancelUntil(0);
return false; }
Clause* confl = propagate();
if (confl != NULL){
analyzeFinal(confl), assert(conflict.size() > 0);
cancelUntil(0);
return false; }
}
assert(root_level == decisionLevel());
// Search:
if (verbosity >= 1){
reportf("==================================[MINISAT]===================================\n", NULL);
reportf("| Conflicts | ORIGINAL | LEARNT | Progress |\n", NULL);
reportf("| | Clauses Literals | Limit Clauses Literals Lit/Cl | |\n", NULL);
reportf("==============================================================================\n", NULL);
}
while (status == l_Undef){
if (verbosity >= 1)
reportf("| %9d | %7d %8d | %7d %7d %8d %7.1f | %6.3f %% |\n", (int)stats.conflicts, nClauses(), (int)stats.clauses_literals, (int)nof_learnts, nLearnts(), (int)stats.learnts_literals, (double)stats.learnts_literals/nLearnts(), progress_estimate*100);
status = search((int)nof_conflicts, (int)nof_learnts, params);
nof_conflicts *= 1.5;
nof_learnts *= 1.1;
}
if (verbosity >= 1)
reportf("==============================================================================\n", NULL);
cancelUntil(0);
return status == l_True;
}
