233 lines
8.0 KiB
C++
233 lines
8.0 KiB
C++
/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
|
|
|
|
/*
|
|
* Main authors:
|
|
* Guido Tack <guido.tack@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/eval_par.hh>
|
|
#include <minizinc/solver_instance_base.hh>
|
|
|
|
#ifdef _MSC_VER
|
|
#define _CRT_SECURE_NO_WARNINGS
|
|
#endif
|
|
|
|
namespace MiniZinc {
|
|
|
|
SolverInstanceBase::Status SolverInstanceBase::solve() { return SolverInstance__ERROR; }
|
|
|
|
void SolverInstanceBase::reset() { assert(false); }
|
|
|
|
void SolverInstanceBase::resetWithConstraints(Model::iterator begin, Model::iterator end) {
|
|
assert(false);
|
|
}
|
|
|
|
void SolverInstanceBase::processPermanentConstraints(Model::iterator begin, Model::iterator end) {
|
|
assert(false);
|
|
}
|
|
|
|
void Registry::add(const ASTString name, poster p) { _registry.insert(std::make_pair(name, p)); }
|
|
void Registry::add(const std::string& name, poster p) {
|
|
GCLock lock;
|
|
ASTString str(name);
|
|
return add(str, p);
|
|
}
|
|
void Registry::post(Call* c) {
|
|
auto it = _registry.find(c->id());
|
|
if (it == _registry.end()) {
|
|
std::ostringstream ss;
|
|
ss << "Error: solver backend cannot handle constraint: " << c->id();
|
|
throw InternalError(ss.str());
|
|
}
|
|
it->second(_base, c);
|
|
}
|
|
|
|
void SolverInstanceBase::printSolution() {
|
|
std::ostringstream oss;
|
|
|
|
if (_options->printStatistics) {
|
|
printStatistics(); // Insert stats before sol separator
|
|
}
|
|
if (nullptr == _pS2Out) {
|
|
getEnv()->evalOutput(std::cout, std::cerr); // deprecated
|
|
std::cout << oss.str();
|
|
if ((!oss.str().empty()) && '\n' != oss.str().back()) {
|
|
std::cout << '\n';
|
|
}
|
|
std::cout << "----------" << std::endl;
|
|
} else {
|
|
getSolns2Out()->evalOutput(oss.str());
|
|
}
|
|
}
|
|
|
|
void SolverInstanceBase2::printSolution() {
|
|
GCLock lock;
|
|
assignSolutionToOutput();
|
|
SolverInstanceBase::printSolution();
|
|
}
|
|
|
|
// void
|
|
// SolverInstanceBase::assignSolutionToOutput() {
|
|
// for (VarDeclIterator it = getEnv()->output()->vardecls().begin(); it !=
|
|
// getEnv()->output()->vardecls().end(); ++it) {
|
|
// if (it->e()->e() == NULL) {
|
|
// it->e()->e(getSolutionValue(it->e()->id()));
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
void SolverInstanceBase2::assignSolutionToOutput() {
|
|
GCLock lock;
|
|
|
|
MZN_ASSERT_HARD_MSG(
|
|
nullptr != _pS2Out,
|
|
"Setup a Solns2Out object to use default solution extraction/reporting procs");
|
|
|
|
if (_varsWithOutput.empty()) {
|
|
for (VarDeclIterator it = getEnv()->flat()->vardecls().begin();
|
|
it != getEnv()->flat()->vardecls().end(); ++it) {
|
|
if (!it->removed()) {
|
|
VarDecl* vd = it->e();
|
|
if (!vd->ann().isEmpty()) {
|
|
if (vd->ann().containsCall(constants().ann.output_array.aststr()) ||
|
|
vd->ann().contains(constants().ann.output_var)) {
|
|
_varsWithOutput.push_back(vd);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
_pS2Out->declNewOutput(); // Even for empty output decl
|
|
|
|
// iterate over set of ids that have an output annotation && obtain their right hand side from the
|
|
// flat model
|
|
for (auto* vd : _varsWithOutput) {
|
|
// std::cout << "DEBUG: Looking at var-decl with output-annotation: " << *vd << std::endl;
|
|
if (Call* output_array_ann = Expression::dynamicCast<Call>(
|
|
get_annotation(vd->ann(), constants().ann.output_array.aststr()))) {
|
|
assert(vd->e());
|
|
|
|
if (auto* al = vd->e()->dynamicCast<ArrayLit>()) {
|
|
std::vector<Expression*> array_elems;
|
|
ArrayLit& array = *al;
|
|
for (unsigned int j = 0; j < array.size(); j++) {
|
|
if (Id* id = array[j]->dynamicCast<Id>()) {
|
|
// std::cout << "DEBUG: getting solution value from " << *id << " : " << id->v() <<
|
|
// std::endl;
|
|
array_elems.push_back(getSolutionValue(id));
|
|
} else if (auto* floatLit = array[j]->dynamicCast<FloatLit>()) {
|
|
array_elems.push_back(floatLit);
|
|
} else if (auto* intLit = array[j]->dynamicCast<IntLit>()) {
|
|
array_elems.push_back(intLit);
|
|
} else if (auto* boolLit = array[j]->dynamicCast<BoolLit>()) {
|
|
array_elems.push_back(boolLit);
|
|
} else if (auto* setLit = array[j]->dynamicCast<SetLit>()) {
|
|
array_elems.push_back(setLit);
|
|
} else if (auto* strLit = array[j]->dynamicCast<StringLit>()) {
|
|
array_elems.push_back(strLit);
|
|
} else {
|
|
std::ostringstream oss;
|
|
oss << "Error: array element " << *array[j] << " is not an id nor a literal";
|
|
throw InternalError(oss.str());
|
|
}
|
|
}
|
|
GCLock lock;
|
|
ArrayLit* dims;
|
|
Expression* e = output_array_ann->arg(0);
|
|
if (auto* al = e->dynamicCast<ArrayLit>()) {
|
|
dims = al;
|
|
} else if (Id* id = e->dynamicCast<Id>()) {
|
|
dims = id->decl()->e()->cast<ArrayLit>();
|
|
} else {
|
|
throw -1;
|
|
}
|
|
std::vector<std::pair<int, int> > dims_v;
|
|
for (int i = 0; i < dims->length(); i++) {
|
|
IntSetVal* isv = eval_intset(getEnv()->envi(), (*dims)[i]);
|
|
if (isv->size() == 0) {
|
|
dims_v.emplace_back(1, 0);
|
|
} else {
|
|
dims_v.emplace_back(static_cast<int>(isv->min().toInt()),
|
|
static_cast<int>(isv->max().toInt()));
|
|
}
|
|
}
|
|
auto* array_solution = new ArrayLit(Location(), array_elems, dims_v);
|
|
KeepAlive ka(array_solution);
|
|
auto& de = getSolns2Out()->findOutputVar(vd->id()->str());
|
|
de.first->e(array_solution);
|
|
}
|
|
} else if (vd->ann().contains(constants().ann.output_var)) {
|
|
Expression* sol = getSolutionValue(vd->id());
|
|
vd->e(sol);
|
|
auto& de = getSolns2Out()->findOutputVar(vd->id()->str());
|
|
de.first->e(sol);
|
|
}
|
|
}
|
|
}
|
|
|
|
void SolverInstanceBase::flattenSearchAnnotations(const Annotation& ann,
|
|
std::vector<Expression*>& out) {
|
|
for (ExpressionSetIter i = ann.begin(); i != ann.end(); ++i) {
|
|
Expression* e = *i;
|
|
if (e->isa<Call>() &&
|
|
(e->cast<Call>()->id() == "seq_search" || e->cast<Call>()->id() == "warm_start_array")) {
|
|
Call* c = e->cast<Call>();
|
|
auto* anns = c->arg(0)->cast<ArrayLit>();
|
|
for (unsigned int i = 0; i < anns->size(); i++) {
|
|
Annotation subann;
|
|
subann.add((*anns)[i]);
|
|
flattenSearchAnnotations(subann, out);
|
|
}
|
|
} else {
|
|
out.push_back(*i);
|
|
}
|
|
}
|
|
}
|
|
|
|
void SolverInstanceBase::flattenMultipleObjectives(const Annotation& ann,
|
|
MultipleObjectives& mo) const {
|
|
int nGoalH = 0;
|
|
for (ExpressionSetIter i = ann.begin(); i != ann.end(); ++i) {
|
|
MZN_ASSERT_HARD_MSG(0 == nGoalH++, "Several goal hierarchies provided");
|
|
Expression* e = *i;
|
|
if (e->isa<Call>() && (e->cast<Call>()->id() == "goal_hierarchy")) {
|
|
MZN_ASSERT_HARD_MSG(getEnv()->flat()->solveItem()->st() == SolveI::SolveType::ST_SAT,
|
|
"goal_hierarchy provided but solve item is not SAT");
|
|
Call* c = e->cast<Call>();
|
|
auto* anns = c->arg(0)->cast<ArrayLit>();
|
|
for (unsigned int i = 0; i < anns->size(); i++) {
|
|
Annotation subann;
|
|
subann.add((*anns)[i]);
|
|
MultipleObjectives::Objective obj;
|
|
flattenMultObjComponent(subann, obj);
|
|
mo.add(obj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SolverInstanceBase::flattenMultObjComponent(const Annotation& ann,
|
|
MultipleObjectives::Objective& obj) {
|
|
MZN_ASSERT_HARD(!ann.isEmpty());
|
|
Expression* e = *ann.begin();
|
|
MZN_ASSERT_HARD(e->isa<Call>());
|
|
Call* c = e->cast<Call>();
|
|
obj.setVariable(c->arg(0));
|
|
const auto id = c->id();
|
|
if (id == "min_goal" || id == "int_min_goal" || id == "float_min_goal") {
|
|
obj.setWeight(-1.0);
|
|
} else if (id == "sat_goal" || id == "max_goal" || id == "int_max_goal" ||
|
|
id == "float_max_goal") {
|
|
obj.setWeight(1.0);
|
|
} else {
|
|
MZN_ASSERT_HARD_MSG(false, "unknown goal: " << id);
|
|
}
|
|
}
|
|
|
|
} // namespace MiniZinc
|