793 lines
31 KiB
C++
793 lines
31 KiB
C++
/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
|
|
|
|
/*
|
|
* Main authors:
|
|
* Jip J. Dekker <jip.dekker@monash.edu>
|
|
*/
|
|
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include <minizinc/solvers/geas/geas_constraints.hh>
|
|
#include <minizinc/solvers/geas_solverinstance.hh>
|
|
|
|
namespace MiniZinc {
|
|
GeasSolverInstance::GeasSolverInstance(std::ostream& log, SolverInstanceBase::Options* opt)
|
|
: SolverInstanceImpl<GeasTypes>(log, opt) {
|
|
registerConstraints();
|
|
zero = _solver.new_intvar(0, 0);
|
|
}
|
|
|
|
void GeasSolverInstance::registerConstraint(std::string name, poster p) {
|
|
_constraintRegistry.add("geas_" + name, p);
|
|
_constraintRegistry.add(name, p);
|
|
}
|
|
|
|
void GeasSolverInstance::registerConstraints() {
|
|
GCLock lock;
|
|
registerConstraint("mk_intvar", GeasConstraints::p_mk_intvar);
|
|
|
|
/* Integer Comparison Constraints */
|
|
registerConstraint("int_eq", GeasConstraints::p_int_eq);
|
|
registerConstraint("int_le", GeasConstraints::p_int_le);
|
|
registerConstraint("int_lt", GeasConstraints::p_int_lt);
|
|
|
|
/* Integer Arithmetic Constraints */
|
|
registerConstraint("int_abs", GeasConstraints::p_int_abs);
|
|
registerConstraint("int_times", GeasConstraints::p_int_times);
|
|
registerConstraint("int_div", GeasConstraints::p_int_div);
|
|
// registerConstraint("int_mod", GeasConstraints::p_int_mod);
|
|
registerConstraint("int_min", GeasConstraints::p_int_min);
|
|
registerConstraint("int_max", GeasConstraints::p_int_max);
|
|
|
|
/* Integer Linear Constraints */
|
|
registerConstraint("int_lin_eq", GeasConstraints::p_int_lin_eq);
|
|
registerConstraint("int_lin_ne", GeasConstraints::p_int_lin_ne);
|
|
registerConstraint("int_lin_le", GeasConstraints::p_int_lin_le);
|
|
registerConstraint("int_lin_eq_imp", GeasConstraints::p_int_lin_eq_imp);
|
|
registerConstraint("int_lin_ne_imp", GeasConstraints::p_int_lin_ne_imp);
|
|
registerConstraint("int_lin_le_imp", GeasConstraints::p_int_lin_le_imp);
|
|
registerConstraint("int_lin_eq_reif", GeasConstraints::p_int_lin_eq_reif);
|
|
registerConstraint("int_lin_ne_reif", GeasConstraints::p_int_lin_ne_reif);
|
|
registerConstraint("int_lin_le_reif", GeasConstraints::p_int_lin_le_reif);
|
|
|
|
/* Boolean Comparison Constraints */
|
|
registerConstraint("bool_eq", GeasConstraints::p_bool_eq);
|
|
registerConstraint("bool_ne", GeasConstraints::p_bool_ne);
|
|
registerConstraint("bool_le", GeasConstraints::p_bool_le);
|
|
registerConstraint("bool_lt", GeasConstraints::p_bool_lt);
|
|
registerConstraint("bool_eq_imp", GeasConstraints::p_bool_eq_imp);
|
|
registerConstraint("bool_ne_imp", GeasConstraints::p_bool_ne_imp);
|
|
registerConstraint("bool_le_imp", GeasConstraints::p_bool_le_imp);
|
|
registerConstraint("bool_lt_imp", GeasConstraints::p_bool_lt_imp);
|
|
registerConstraint("bool_eq_reif", GeasConstraints::p_bool_eq_reif);
|
|
registerConstraint("bool_ne_reif", GeasConstraints::p_bool_ne_reif);
|
|
registerConstraint("bool_le_reif", GeasConstraints::p_bool_le_reif);
|
|
registerConstraint("bool_lt_reif", GeasConstraints::p_bool_lt_reif);
|
|
|
|
/* Boolean Arithmetic Constraints */
|
|
registerConstraint("bool_or", GeasConstraints::p_bool_or);
|
|
registerConstraint("bool_and", GeasConstraints::p_bool_and);
|
|
registerConstraint("bool_xor", GeasConstraints::p_bool_xor);
|
|
registerConstraint("bool_not", GeasConstraints::p_bool_not);
|
|
registerConstraint("bool_or_imp", GeasConstraints::p_bool_or_imp);
|
|
registerConstraint("bool_and_imp", GeasConstraints::p_bool_and_imp);
|
|
registerConstraint("bool_xor_imp", GeasConstraints::p_bool_xor_imp);
|
|
|
|
registerConstraint("bool_clause", GeasConstraints::p_bool_clause);
|
|
registerConstraint("array_bool_or", GeasConstraints::p_array_bool_or);
|
|
registerConstraint("array_bool_and", GeasConstraints::p_array_bool_and);
|
|
registerConstraint("bool_clause_imp", GeasConstraints::p_bool_clause_imp);
|
|
registerConstraint("array_bool_or_imp", GeasConstraints::p_array_bool_or_imp);
|
|
registerConstraint("array_bool_and_imp", GeasConstraints::p_array_bool_and_imp);
|
|
registerConstraint("bool_clause_reif", GeasConstraints::p_bool_clause_reif);
|
|
|
|
/* Boolean Linear Constraints */
|
|
registerConstraint("bool_lin_eq", GeasConstraints::p_bool_lin_eq);
|
|
registerConstraint("bool_lin_ne", GeasConstraints::p_bool_lin_ne);
|
|
registerConstraint("bool_lin_le", GeasConstraints::p_bool_lin_le);
|
|
registerConstraint("bool_lin_eq_imp", GeasConstraints::p_bool_lin_eq_imp);
|
|
registerConstraint("bool_lin_ne_imp", GeasConstraints::p_bool_lin_ne_imp);
|
|
registerConstraint("bool_lin_le_imp", GeasConstraints::p_bool_lin_le_imp);
|
|
registerConstraint("bool_lin_eq_reif", GeasConstraints::p_bool_lin_eq_reif);
|
|
registerConstraint("bool_lin_ne_reif", GeasConstraints::p_bool_lin_ne_reif);
|
|
registerConstraint("bool_lin_le_reif", GeasConstraints::p_bool_lin_le_reif);
|
|
|
|
/* Coercion Constraints */
|
|
registerConstraint("bool2int", GeasConstraints::p_bool2int);
|
|
|
|
/* Element Constraints */
|
|
registerConstraint("array_int_element", GeasConstraints::p_array_int_element);
|
|
registerConstraint("array_bool_element", GeasConstraints::p_array_bool_element);
|
|
registerConstraint("array_var_int_element", GeasConstraints::p_array_var_int_element);
|
|
registerConstraint("array_var_bool_element", GeasConstraints::p_array_var_bool_element);
|
|
|
|
/* Global Constraints */
|
|
registerConstraint("all_different_int", GeasConstraints::p_all_different);
|
|
registerConstraint("alldifferent_except_0", GeasConstraints::p_all_different_except_0);
|
|
registerConstraint("at_most", GeasConstraints::p_at_most);
|
|
registerConstraint("at_most1", GeasConstraints::p_at_most1);
|
|
registerConstraint("cumulative", GeasConstraints::p_cumulative);
|
|
registerConstraint("cumulative_var", GeasConstraints::p_cumulative);
|
|
registerConstraint("disjunctive", GeasConstraints::p_disjunctive);
|
|
registerConstraint("disjunctive_var", GeasConstraints::p_disjunctive);
|
|
registerConstraint("global_cardinality", GeasConstraints::p_global_cardinality);
|
|
registerConstraint("table_int", GeasConstraints::p_table_int);
|
|
|
|
/**** TODO: NOT YET SUPPORTED: ****/
|
|
/* Boolean Arithmetic Constraints */
|
|
// registerConstraint("array_bool_xor", GeasConstraints::p_array_bool_xor);
|
|
// registerConstraint("array_bool_xor_imp", GeasConstraints::p_array_bool_xor_imp);
|
|
|
|
/* Floating Point Comparison Constraints */
|
|
// registerConstraint("float_eq", GeasConstraints::p_float_eq);
|
|
// registerConstraint("float_le", GeasConstraints::p_float_le);
|
|
// registerConstraint("float_lt", GeasConstraints::p_float_lt);
|
|
// registerConstraint("float_ne", GeasConstraints::p_float_ne);
|
|
// registerConstraint("float_eq_reif", GeasConstraints::p_float_eq_reif);
|
|
// registerConstraint("float_le_reif", GeasConstraints::p_float_le_reif);
|
|
// registerConstraint("float_lt_reif", GeasConstraints::p_float_lt_reif);
|
|
|
|
/* Floating Point Arithmetic Constraints */
|
|
// registerConstraint("float_abs", GeasConstraints::p_float_abs);
|
|
// registerConstraint("float_sqrt", GeasConstraints::p_float_sqrt);
|
|
// registerConstraint("float_times", GeasConstraints::p_float_times);
|
|
// registerConstraint("float_div", GeasConstraints::p_float_div);
|
|
// registerConstraint("float_plus", GeasConstraints::p_float_plus);
|
|
// registerConstraint("float_max", GeasConstraints::p_float_max);
|
|
// registerConstraint("float_min", GeasConstraints::p_float_min);
|
|
// registerConstraint("float_acos", GeasConstraints::p_float_acos);
|
|
// registerConstraint("float_asin", GeasConstraints::p_float_asin);
|
|
// registerConstraint("float_atan", GeasConstraints::p_float_atan);
|
|
// registerConstraint("float_cos", GeasConstraints::p_float_cos);
|
|
// registerConstraint("float_exp", GeasConstraints::p_float_exp);
|
|
// registerConstraint("float_ln", GeasConstraints::p_float_ln);
|
|
// registerConstraint("float_log10", GeasConstraints::p_float_log10);
|
|
// registerConstraint("float_log2", GeasConstraints::p_float_log2);
|
|
// registerConstraint("float_sin", GeasConstraints::p_float_sin);
|
|
// registerConstraint("float_tan", GeasConstraints::p_float_tan);
|
|
|
|
/* Floating Linear Constraints */
|
|
// registerConstraint("float_lin_eq", GeasConstraints::p_float_lin_eq);
|
|
// registerConstraint("float_lin_eq_reif", GeasConstraints::p_float_lin_eq_reif);
|
|
// registerConstraint("float_lin_le", GeasConstraints::p_float_lin_le);
|
|
// registerConstraint("float_lin_le_reif", GeasConstraints::p_float_lin_le_reif);
|
|
|
|
/* Coercion Constraints */
|
|
// registerConstraint("int2float", GeasConstraints::p_int2float);
|
|
}
|
|
|
|
void GeasSolverInstance::processFlatZinc() {
|
|
assert(false);
|
|
// auto _opt = static_cast<GeasOptions&>(*_options);
|
|
// // Create variables
|
|
// zero = _solver.new_intvar(0, 0);
|
|
// for(auto it = _flat->begin_vardecls(); it != _flat->end_vardecls(); ++it) {
|
|
// if (!it->removed() && it->e()->type().isvar() && it->e()->type().dim() == 0) {
|
|
// VarDecl* vd = it->e();
|
|
//
|
|
// if(vd->type().isbool()) {
|
|
// if(!vd->e()) {
|
|
// Expression* domain = vd->ti()->domain();
|
|
// long long int lb, ub;
|
|
// if(domain) {
|
|
// IntBounds ib = compute_int_bounds(_env.envi(), domain);
|
|
// lb = ib.l.toInt();
|
|
// ub = ib.u.toInt();
|
|
// } else {
|
|
// lb = 0;
|
|
// ub = 1;
|
|
// }
|
|
// if (lb == ub) {
|
|
// geas::patom_t val = (lb == 0) ? geas::at_False : geas::at_True;
|
|
// _variableMap.insert(vd->id(), GeasVariable(val));
|
|
// } else {
|
|
// auto var = _solver.new_boolvar();
|
|
// _variableMap.insert(vd->id(), GeasVariable(var));
|
|
// }
|
|
// } else {
|
|
// Expression* init = vd->e();
|
|
// if (init->isa<Id>() || init->isa<ArrayAccess>()) {
|
|
// GeasVariable& var = resolveVar(init);
|
|
// assert(var.isBool());
|
|
// _variableMap.insert(vd->id(), GeasVariable(var.boolVar()));
|
|
// } else {
|
|
// auto b = init->cast<BoolLit>()->v();
|
|
// geas::patom_t val = b ? geas::at_True : geas::at_False;
|
|
// _variableMap.insert(vd->id(), GeasVariable(val));
|
|
// }
|
|
// }
|
|
// } else if(vd->type().isfloat()) {
|
|
// if(!vd->e()) {
|
|
// Expression* domain = vd->ti()->domain();
|
|
// double lb, ub;
|
|
// if (domain) {
|
|
// FloatBounds fb = compute_float_bounds(_env.envi(), vd->id());
|
|
// lb = fb.l.toDouble();
|
|
// ub = fb.u.toDouble();
|
|
// } else {
|
|
// throw Error("GeasSolverInstance::processFlatZinc: Error: Unbounded variable: " +
|
|
// vd->id()->str().str());
|
|
// }
|
|
// // TODO: Error correction from double to float??
|
|
// auto var = _solver.new_floatvar(static_cast<geas::fp::val_t>(lb),
|
|
// static_cast<geas::fp::val_t>(ub)); _variableMap.insert(vd->id(), GeasVariable(var));
|
|
// } else {
|
|
// Expression* init = vd->e();
|
|
// if (init->isa<Id>() || init->isa<ArrayAccess>()) {
|
|
// GeasVariable& var = resolveVar(init);
|
|
// assert(var.isFloat());
|
|
// _variableMap.insert(vd->id(), GeasVariable(var.floatVar()));
|
|
// } else {
|
|
// double fl = init->cast<FloatLit>()->v().toDouble();
|
|
// auto var = _solver.new_floatvar(static_cast<geas::fp::val_t>(fl),
|
|
// static_cast<geas::fp::val_t>(fl)); _variableMap.insert(vd->id(),
|
|
// GeasVariable(var));
|
|
// }
|
|
// }
|
|
// } else if (vd->type().isint()) {
|
|
// if (!vd->e()) {
|
|
// Expression* domain = vd->ti()->domain();
|
|
// if (domain) {
|
|
// IntSetVal* isv = eval_intset(env().envi(), domain);
|
|
// auto var =
|
|
// _solver.new_intvar(static_cast<geas::intvar::val_t>(isv->min().toInt()),
|
|
// static_cast<geas::intvar::val_t>(isv->max().toInt())); if (isv->size() > 1) {
|
|
// vec<int> vals(static_cast<int>(isv->card().toInt()));
|
|
// int i = 0;
|
|
// for (int j = 0; j < isv->size(); ++j) {
|
|
// for (auto k = isv->min(i).toInt(); k <= isv->max(j).toInt(); ++k) {
|
|
// vals[i++] = static_cast<int>(k);
|
|
// }
|
|
// }
|
|
// assert(i == isv->card().toInt());
|
|
// auto res = geas::make_sparse(var, vals);
|
|
// assert(res);
|
|
// }
|
|
// _variableMap.insert(vd->id(), GeasVariable(var));
|
|
// } else {
|
|
// throw Error("GeasSolverInstance::processFlatZinc: Error: Unbounded variable: " +
|
|
// vd->id()->str().str());
|
|
// }
|
|
// } else {
|
|
// Expression* init = vd->e();
|
|
// if (init->isa<Id>() || init->isa<ArrayAccess>()) {
|
|
// GeasVariable& var = resolveVar(init);
|
|
// assert(var.isInt());
|
|
// _variableMap.insert(vd->id(), GeasVariable(var.intVar()));
|
|
// } else {
|
|
// auto il = init->cast<IntLit>()->v().toInt();
|
|
// auto var = _solver.new_intvar(static_cast<geas::intvar::val_t>(il),
|
|
// static_cast<geas::intvar::val_t>(il)); _variableMap.insert(vd->id(),
|
|
// GeasVariable(var));
|
|
// }
|
|
// }
|
|
// } else {
|
|
// std::stringstream ssm;
|
|
// ssm << "Type " << *vd->ti() << " is currently not supported by Geas.";
|
|
// throw InternalError(ssm.str());
|
|
// }
|
|
// }
|
|
// }
|
|
//
|
|
// // Post constraints
|
|
// for (ConstraintIterator it = _flat->begin_constraints(); it != _flat->end_constraints();
|
|
// ++it) {
|
|
// if(!it->removed()) {
|
|
// if (auto c = it->e()->dyn_cast<Call>()) {
|
|
// _constraintRegistry.post(c);
|
|
// }
|
|
// }
|
|
// }
|
|
// // Set objective
|
|
// SolveI* si = _flat->solveItem();
|
|
// if(si->e()) {
|
|
// _obj_type = si->st();
|
|
// if (_obj_type == SolveI::ST_MIN) {
|
|
// _obj_var = std::unique_ptr<GeasTypes::Variable>(new
|
|
// GeasTypes::Variable(resolveVar(si->e())));
|
|
// } else if (_obj_type == SolveI::ST_MAX) {
|
|
// _obj_type = SolveI::ST_MIN;
|
|
// _obj_var = std::unique_ptr<GeasTypes::Variable>(new
|
|
// GeasTypes::Variable(-asIntVar(si->e())));
|
|
// }
|
|
// }
|
|
// if (!si->ann().isEmpty()) {
|
|
// std::vector<Expression*> flatAnn;
|
|
// flattenSearchAnnotations(si->ann(), flatAnn);
|
|
//
|
|
// for (auto &ann : flatAnn) {
|
|
// if (ann->isa<Call>()) {
|
|
// Call* call = ann->cast<Call>();
|
|
// if (call->id().str() == "warm_start") {
|
|
// auto vars = eval_array_lit(env().envi(), call->arg(0));
|
|
// auto vals = eval_array_lit(env().envi(), call->arg(1));
|
|
// assert(vars->size() == vals->size());
|
|
// vec<geas::patom_t> ws(vars->size());
|
|
//
|
|
// if (vars->type().isintarray()) {
|
|
// assert(vals->type().isintarray());
|
|
// for (int i = 0; i < vars->size(); ++i) {
|
|
// geas::intvar var = asIntVar((*vars)[i]);
|
|
// int val = asInt((*vals)[i]);
|
|
// ws.push(var == val);
|
|
// }
|
|
// } else if (vars->type().isboolarray()) {
|
|
// assert(vals->type().isboolarray());
|
|
// for (int i = 0; i < vars->size(); ++i) {
|
|
// geas::patom_t var = asBoolVar((*vars)[i]);
|
|
// bool val = asBool((*vals)[i]);
|
|
// ws.push(val ? var : ~var);
|
|
// }
|
|
// } else {
|
|
// std::cerr << "WARNING Geas: ignoring warm start annotation of invalid type: " <<
|
|
// *ann << std::endl; continue;
|
|
// }
|
|
// _solver.data->branchers.push(geas::warmstart_brancher(ws));
|
|
// continue;
|
|
// }
|
|
//
|
|
// vec<geas::pid_t> pids;
|
|
// geas::VarChoice select = geas::Var_FirstFail;
|
|
// geas::ValChoice choice = geas::Val_Min;
|
|
// if (call->id().str() == "int_search") {
|
|
// vec<geas::intvar> iv = asIntVar(eval_array_lit(env().envi(), call->arg(0)));
|
|
// pids.growTo(iv.size());
|
|
// for (int i = 0; i < iv.size(); ++i) {
|
|
// pids[i] = iv[i].p;
|
|
// }
|
|
// } else if (call->id().str() == "bool_search") {
|
|
// vec<geas::patom_t> bv = asBoolVar(eval_array_lit(env().envi(), call->arg(0)));
|
|
// pids.growTo(bv.size());
|
|
// for (int i = 0; i < bv.size(); ++i) {
|
|
// pids[i] = bv[i].pid;
|
|
// }
|
|
// } else {
|
|
// std::cerr << "WARNING Geas: ignoring unknown search annotation: " << *ann <<
|
|
// std::endl; continue;
|
|
// }
|
|
// const std::string& select_str = call->arg(1)->cast<Id>()->str().str();
|
|
// if (select_str == "input_order") {
|
|
// select = geas::Var_InputOrder;
|
|
// } else if (select_str == "first_fail") {
|
|
// select = geas::Var_FirstFail;
|
|
// } else if (select_str == "largest") {
|
|
// select = geas::Var_Largest;
|
|
// } else if (select_str == "smallest") {
|
|
// select = geas::Var_Smallest;
|
|
// } else {
|
|
// std::cerr << "WARNING Geas: unknown variable selection '" << select_str << "', using
|
|
// default value First Fail." << std::endl;
|
|
// }
|
|
// const std::string& choice_str = call->arg(2)->cast<Id>()->str().str();
|
|
// if (choice_str == "indomain_max") {
|
|
// choice = geas::Val_Max;
|
|
// } else if (choice_str == "indomain_min") {
|
|
// choice = geas::Val_Min;
|
|
// } else if (choice_str == "indomain_split") {
|
|
// choice = geas::Val_Split;
|
|
// } else {
|
|
// std::cerr << "WARNING Geas: unknown value selection '" << choice_str << "', using
|
|
// Indomain Min." << std::endl;
|
|
// }
|
|
//
|
|
// geas::brancher* b = geas::basic_brancher(select, choice, pids);
|
|
// if (_opt.free_search) {
|
|
// vec<geas::brancher*> brv({b,_solver.data->last_branch});
|
|
// _solver.data->branchers.push(geas::toggle_brancher(brv));
|
|
// } else {
|
|
// _solver.data->branchers.push(b);
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
}
|
|
|
|
bool GeasSolverInstance::addSolutionNoGood() {
|
|
assert(!_varsWithOutput.empty());
|
|
geas::model solution = _solver.get_model();
|
|
vec<geas::clause_elt> clause;
|
|
// TODO:
|
|
assert(false);
|
|
// for (auto &var : _varsWithOutput) {
|
|
// if (Expression::dyn_cast<Call>(getAnnotation(var->ann(),
|
|
// constants().ann.output_array.aststr()))) {
|
|
// if (auto al = var->e()->dyn_cast<ArrayLit>()) {
|
|
// for(unsigned int j=0; j<al->size(); j++) {
|
|
// if(Id* id = (*al)[j]->dyn_cast<Id>()) {
|
|
// auto geas_var = resolveVar(id);
|
|
// if (geas_var.isBool()) {
|
|
// geas::patom_t bv = geas_var.boolVar();
|
|
// clause.push(solution.value(bv) ? ~bv : bv);
|
|
// } else if (geas_var.isFloat()) {
|
|
// geas::fp::fpvar fv = geas_var.floatVar();
|
|
// clause.push(fv < solution[fv]);
|
|
// clause.push(fv > solution[fv]);
|
|
// } else {
|
|
// geas::intvar iv = geas_var.intVar();
|
|
// clause.push(~(iv == solution[iv]));
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
// } else {
|
|
// auto geas_var = resolveVar(var);
|
|
// if (geas_var.isBool()) {
|
|
// geas::patom_t bv = geas_var.boolVar();
|
|
// clause.push(solution.value(bv) ? ~bv : bv);
|
|
// } else if (geas_var.isFloat()) {
|
|
// geas::fp::fpvar fv = geas_var.floatVar();
|
|
// clause.push(fv < solution[fv]);
|
|
// clause.push(fv > solution[fv]);
|
|
// } else {
|
|
// geas::intvar iv = geas_var.intVar();
|
|
// clause.push(iv != solution[iv]);
|
|
// }
|
|
// }
|
|
// }
|
|
return geas::add_clause(*_solver.data, clause);
|
|
}
|
|
|
|
SolverInstanceBase::Status MiniZinc::GeasSolverInstance::solve() {
|
|
SolverInstanceBase::Status status = SolverInstance::ERROR;
|
|
auto _opt = static_cast<GeasOptions&>(*_options);
|
|
auto remaining_time = [_opt] {
|
|
if (_opt.time == std::chrono::milliseconds(0)) {
|
|
return 0.0;
|
|
} else {
|
|
using geas_time = std::chrono::duration<double>;
|
|
static auto timeout = std::chrono::high_resolution_clock::now() + _opt.time;
|
|
return geas_time(timeout - std::chrono::high_resolution_clock::now()).count();
|
|
}
|
|
};
|
|
if (_obj_type == SolveI::ST_SAT) {
|
|
int nr_solutions = 0;
|
|
geas::solver::result res = geas::solver::UNKNOWN;
|
|
while ((_opt.all_solutions || nr_solutions < _opt.nr_solutions) && remaining_time() >= 0.0) {
|
|
res = _solver.solve({remaining_time(), _opt.conflicts - _solver.data->stats.conflicts});
|
|
// printSolution();
|
|
if (res != geas::solver::SAT) {
|
|
break;
|
|
} else {
|
|
nr_solutions++;
|
|
if (!_opt.all_solutions && nr_solutions >= _opt.nr_solutions) {
|
|
break;
|
|
}
|
|
_solver.restart();
|
|
if (!addSolutionNoGood()) {
|
|
res = geas::solver::UNSAT;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
switch (res) {
|
|
case geas::solver::SAT:
|
|
status = SolverInstance::SAT;
|
|
break;
|
|
case geas::solver::UNSAT:
|
|
if (nr_solutions > 0) {
|
|
status = SolverInstance::OPT;
|
|
} else {
|
|
status = SolverInstance::UNSAT;
|
|
}
|
|
break;
|
|
case geas::solver::UNKNOWN:
|
|
if (nr_solutions > 0) {
|
|
status = SolverInstance::SAT;
|
|
} else {
|
|
status = SolverInstance::UNKNOWN;
|
|
}
|
|
break;
|
|
default:
|
|
status = SolverInstance::ERROR;
|
|
break;
|
|
}
|
|
} else {
|
|
assert(_obj_type == SolveI::ST_MIN);
|
|
// TODO: Add float objectives
|
|
assert(_obj_var->isInt());
|
|
geas::intvar obj = _obj_var->intVar();
|
|
geas::solver::result res;
|
|
while (true) {
|
|
res = _solver.solve({remaining_time(), _opt.conflicts - _solver.data->stats.conflicts});
|
|
geas::intvar::val_t obj_val;
|
|
if (res != geas::solver::SAT) {
|
|
break;
|
|
}
|
|
status = SolverInstance::SAT;
|
|
if (_opt.all_solutions) {
|
|
printSolution();
|
|
}
|
|
obj_val = _solver.get_model()[obj];
|
|
|
|
int step = 1;
|
|
while (_opt.obj_probe_limit > 0) {
|
|
geas::intvar::val_t assumed_obj;
|
|
assumed_obj = obj_val - step;
|
|
assumed_obj = obj.lb(_solver.data) > assumed_obj ? obj.lb(_solver.data) : assumed_obj;
|
|
if (!_solver.assume(obj == assumed_obj)) {
|
|
_solver.retract();
|
|
break;
|
|
}
|
|
res = _solver.solve({remaining_time(), _opt.obj_probe_limit});
|
|
_solver.retract();
|
|
if (res != geas::solver::SAT) {
|
|
break;
|
|
}
|
|
step *= 2;
|
|
if (_opt.all_solutions) {
|
|
printSolution();
|
|
}
|
|
obj_val = _solver.get_model()[obj];
|
|
}
|
|
_solver.post(obj < obj_val);
|
|
}
|
|
if (status == SolverInstance::ERROR) {
|
|
switch (res) {
|
|
case geas::solver::UNSAT:
|
|
status = SolverInstance::UNSAT;
|
|
break;
|
|
case geas::solver::UNKNOWN:
|
|
status = SolverInstance::UNKNOWN;
|
|
break;
|
|
default:
|
|
assert(false);
|
|
status = SolverInstance::ERROR;
|
|
break;
|
|
}
|
|
} else {
|
|
if (res == geas::solver::UNSAT) {
|
|
status = SolverInstance::OPT;
|
|
}
|
|
if (!_opt.all_solutions) {
|
|
printSolution();
|
|
}
|
|
}
|
|
}
|
|
if (_opt.statistics) {
|
|
printStatistics(true);
|
|
}
|
|
return status;
|
|
}
|
|
|
|
Expression* GeasSolverInstance::getSolutionValue(Id* id) {
|
|
assert(false);
|
|
return nullptr;
|
|
// id = id->decl()->id();
|
|
// if(id->type().isvar()) {
|
|
// GeasVariable& var = resolveVar(id->decl()->id());
|
|
// geas::model solution = _solver.get_model();
|
|
// switch (id->type().bt()) {
|
|
// case Type::BT_BOOL:
|
|
// assert(var.isBool());
|
|
// return constants().boollit(solution.value(var.boolVar()));
|
|
// case Type::BT_FLOAT:
|
|
// assert(var.isFloat());
|
|
// return FloatLit::a(solution[var.floatVar()]);
|
|
// case Type::BT_INT:
|
|
// assert(var.isInt());
|
|
// return IntLit::a(solution[var.intVar()]);
|
|
// default:
|
|
// return nullptr;
|
|
// }
|
|
// } else {
|
|
// return id->decl()->e();
|
|
// }
|
|
}
|
|
|
|
void GeasSolverInstance::resetSolver() { assert(false); }
|
|
|
|
GeasTypes::Variable& GeasSolverInstance::resolveVar(Definition* def) {
|
|
auto it = _variableMap.find(def->timestamp());
|
|
assert(it != _variableMap.end());
|
|
return it->second;
|
|
}
|
|
|
|
vec<bool> GeasSolverInstance::asBoolVec(const Val& val) {
|
|
vec<bool> vec(val.size());
|
|
for (int i = 0; i < val.size(); ++i) {
|
|
vec[i] = asBool(val[i]);
|
|
}
|
|
return vec;
|
|
}
|
|
|
|
geas::patom_t GeasSolverInstance::asBoolVar(const Val& val) {
|
|
if (val.isDef()) {
|
|
GeasVariable& var = resolveVar(val.toDef());
|
|
assert(var.isBool());
|
|
return var.boolVar();
|
|
} else {
|
|
if (val.isInt()) {
|
|
return val().toInt() ? geas::at_True : geas::at_False;
|
|
} else {
|
|
std::stringstream ssm;
|
|
ssm << "Expected bool or int literal instead of: " << val.toString();
|
|
throw InternalError(ssm.str());
|
|
}
|
|
}
|
|
}
|
|
|
|
vec<geas::patom_t> GeasSolverInstance::asBoolVarVec(const Val& val) {
|
|
vec<geas::patom_t> vec(val.size());
|
|
for (int i = 0; i < val.size(); ++i) {
|
|
vec[i] = this->asBoolVar(val[i]);
|
|
}
|
|
return vec;
|
|
}
|
|
|
|
vec<int> GeasSolverInstance::asIntVec(const Val& val) {
|
|
vec<int> vec(val.size());
|
|
for (int i = 0; i < val.size(); ++i) {
|
|
vec[i] = MiniZinc::GeasSolverInstance::asInt(val[i]);
|
|
}
|
|
return vec;
|
|
}
|
|
|
|
geas::intvar GeasSolverInstance::asIntVar(const Val& val) {
|
|
if (val.isDef()) {
|
|
GeasVariable& var = resolveVar(val.toDef());
|
|
assert(var.isInt());
|
|
return var.intVar();
|
|
} else {
|
|
IntVal i;
|
|
if (val.isInt()) {
|
|
i = val().toInt();
|
|
} else {
|
|
std::stringstream ssm;
|
|
ssm << "Expected int literal instead of: " << val.toString();
|
|
throw InternalError(ssm.str());
|
|
}
|
|
if (i == 0) {
|
|
return zero;
|
|
} else {
|
|
return _solver.new_intvar(static_cast<geas::intvar::val_t>(i.toInt()),
|
|
static_cast<geas::intvar::val_t>(i.toInt()));
|
|
}
|
|
}
|
|
}
|
|
|
|
vec<geas::intvar> GeasSolverInstance::asIntVarVec(const Val& val) {
|
|
vec<geas::intvar> vec(val.size());
|
|
for (int i = 0; i < val.size(); ++i) {
|
|
vec[i] = this->asIntVar(val[i]);
|
|
}
|
|
return vec;
|
|
}
|
|
|
|
void GeasSolverInstance::printStatistics(bool fLegend) {
|
|
auto& st = _solver.data->stats;
|
|
auto& out = getSolns2Out()->getOutput();
|
|
|
|
out << "%%%mzn-stat: failures=" << st.conflicts << std::endl; // TODO: Statistic name
|
|
out << "%%%mzn-stat: solveTime=" << st.time << std::endl;
|
|
out << "%%%mzn-stat: solutions=" << st.solutions << std::endl;
|
|
out << "%%%mzn-stat: restarts=" << st.restarts << std::endl;
|
|
out << "%%%mzn-stat: nogoods=" << st.num_learnts << std::endl; // TODO: Statistic name
|
|
out << "%%%mzn-stat: learntLiterals=" << st.num_learnt_lits << std::endl; // TODO: Statistic name
|
|
}
|
|
|
|
void GeasSolverInstance::addDefinition(const std::vector<BytecodeProc>& bs, Definition* def) {
|
|
_constraintRegistry.post(bs[def->pred()].name, def);
|
|
}
|
|
|
|
Val GeasSolverInstance::getSolutionValue(Definition* def) {
|
|
GeasVariable& var = resolveVar(def);
|
|
geas::model solution = _solver.get_model();
|
|
if (var.isBool()) {
|
|
return Val(solution.value(var.boolVar()));
|
|
} else if (var.isFloat()) {
|
|
// return FloatLit::a(solution[var.floatVar()]);
|
|
assert(false);
|
|
return Val();
|
|
} else {
|
|
assert(var.isInt());
|
|
return Val(solution[var.intVar()]);
|
|
}
|
|
}
|
|
|
|
void GeasSolverInstance::pushState() {
|
|
geas::patom_t state_var = _solver.new_boolvar();
|
|
solver().assume(state_var);
|
|
stack.push_back(state_var);
|
|
}
|
|
|
|
void GeasSolverInstance::popState() {
|
|
_solver.retract();
|
|
geas::patom_t state_var = stack.back();
|
|
stack.pop_back();
|
|
solver().post(~state_var);
|
|
}
|
|
|
|
geas::patom_t GeasSolverInstance::currentState() {
|
|
if (stack.empty()) {
|
|
return geas::at_True;
|
|
}
|
|
return stack.back();
|
|
}
|
|
|
|
Geas_SolverFactory::Geas_SolverFactory() {
|
|
SolverConfig sc("org.minizinc.geas", getVersion(nullptr));
|
|
sc.name("Geas");
|
|
sc.mznlib("-Ggeas");
|
|
sc.mznlibVersion(1);
|
|
sc.supportsMzn(false);
|
|
sc.description(getDescription(nullptr));
|
|
sc.tags({
|
|
"api",
|
|
"cp",
|
|
"float",
|
|
"int",
|
|
"lcg",
|
|
});
|
|
sc.stdFlags({"-a", "-f", "-n", "-s", "-t"});
|
|
sc.extraFlags({
|
|
SolverConfig::ExtraFlag("--conflicts",
|
|
"Limit the maximum number of conflicts to be used during solving.",
|
|
"int", "0"),
|
|
SolverConfig::ExtraFlag(
|
|
"--obj-probe",
|
|
"Number of conflicts to use to probe for better solutions after a new solution is found.",
|
|
"int", "0"),
|
|
});
|
|
SolverConfigs::registerBuiltinSolver(sc);
|
|
};
|
|
|
|
SolverInstanceBase::Options* Geas_SolverFactory::createOptions() { return new GeasOptions; }
|
|
|
|
SolverInstanceBase* Geas_SolverFactory::doCreateSI(std::ostream& log,
|
|
SolverInstanceBase::Options* opt) {
|
|
return new GeasSolverInstance(log, opt);
|
|
}
|
|
|
|
bool Geas_SolverFactory::processOption(SolverInstanceBase::Options* opt, int& i,
|
|
std::vector<std::string>& argv) {
|
|
auto _opt = static_cast<GeasOptions*>(opt);
|
|
if (argv[i] == "-a" || argv[i] == "--all-solutions") {
|
|
_opt->all_solutions = true;
|
|
} else if (argv[i] == "--conflicts") {
|
|
if (++i == argv.size()) return false;
|
|
int nodes = atoi(argv[i].c_str());
|
|
if (nodes >= 0) _opt->conflicts = nodes;
|
|
} else if (argv[i] == "-f") {
|
|
_opt->free_search = true;
|
|
} else if (argv[i] == "-n") {
|
|
if (++i == argv.size()) {
|
|
return false;
|
|
}
|
|
int n = atoi(argv[i].c_str());
|
|
if (n >= 0) {
|
|
_opt->nr_solutions = n;
|
|
}
|
|
} else if (argv[i] == "--obj-probe") {
|
|
if (++i == argv.size()) {
|
|
return false;
|
|
}
|
|
int limit = atoi(argv[i].c_str());
|
|
if (limit >= 0) {
|
|
_opt->obj_probe_limit = limit;
|
|
}
|
|
} else if (argv[i] == "--solver-statistics" || argv[i] == "-s") {
|
|
_opt->statistics = true;
|
|
} else if (argv[i] == "--solver-time-limit" || argv[i] == "-t") {
|
|
if (++i == argv.size()) return false;
|
|
int time = atoi(argv[i].c_str());
|
|
if (time >= 0) _opt->time = std::chrono::milliseconds(time);
|
|
} else {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void Geas_SolverFactory::printHelp(std::ostream& os) {
|
|
os << "Geas solver plugin options:" << std::endl
|
|
<< " --conflicts <int>" << std::endl
|
|
<< " Limit the maximum number of conflicts to be used during solving." << std::endl
|
|
<< " --obj-probe <int>" << std::endl
|
|
<< " Number of conflicts to use to probe for better solutions after a new solution is "
|
|
"found."
|
|
<< std::endl
|
|
<< std::endl;
|
|
}
|
|
} // namespace MiniZinc
|