//bool Solver::solve(const vec<Lit>& assumps) bool Solver::solve() { simplifyDB(); if (!ok) return false; SearchParams params(0.95, 0.999, 0.02); double nof_conflicts = 100; double nof_learnts = nConstrs() / 3; lbool status = l_Undef; // for (int i = 0; i < assumps.size(); i++) // if (!assume(assumps[i]) || propagate() != NULL){ // propQ.clear(); // cancelUntil(0); // return false; } root_level = decisionLevel; if (verbosity >= 1){ printf("==================================[MINISAT]===================================\n"); printf("| Conflicts | ORIGINAL | LEARNT | Progress |\n"); printf("| | Clauses Literals | Limit Clauses Literals Lit/Cl | |\n"); printf("==============================================================================\n"); } while (status == l_Undef){ if (verbosity >= 1){ printf("| %9d | %7d %8d | %7d %7d %8d %7.1f | %6.3f %% |\n", (int)stats.conflicts, nConstrs(), (int)stats.clauses_literals, (int)nof_learnts, nLearnts(), (int)stats.learnts_literals, (double)stats.learnts_literals/nLearnts(), progress_estimate*100); fflush(stdout); } status = search((int)nof_conflicts, (int)nof_learnts, params); nof_conflicts *= 1.5; nof_learnts *= 1.1; } if (verbosity >= 1) printf("==============================================================================\n"); cancelUntil(0); return status == l_True; }
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; }
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; }
/*_________________________________________________________________________________________________ | | 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; }
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; }