Jip J. Dekker
f2a1c4e389
git-subtree-dir: software/mza git-subtree-split: f970a59b177c13ca3dd8aaef8cc6681d83b7e813
134 lines
3.8 KiB
C++
134 lines
3.8 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/c_interface.h>
|
|
#include <minizinc/interpreter.hh>
|
|
#include <minizinc/interpreter/primitives.hh>
|
|
#include <minizinc/solver.hh>
|
|
#include <minizinc/solvers/gecode_solverinstance.hh>
|
|
|
|
#include <cstdarg>
|
|
#include <iostream>
|
|
|
|
using namespace MiniZinc;
|
|
|
|
class Instance {
|
|
public:
|
|
Instance(std::string file, std::string data_file, std::string solver)
|
|
: slv({"--solver", solver, file, data_file}){};
|
|
|
|
MznSolver slv;
|
|
std::string result;
|
|
};
|
|
|
|
void set_rnd_seed(int seed) {
|
|
dynamic_cast<BytecodePrimitives::Uniform*>(primitiveMap()[PrimitiveMap::UNIFORM])->setSeed(seed);
|
|
}
|
|
|
|
MZNInstance minizinc_instance_init(const char* mza_file, const char* data_file,
|
|
const char* solver) {
|
|
auto inst = new Instance(mza_file, data_file, solver);
|
|
return reinterpret_cast<MZNInstance>(inst);
|
|
}
|
|
|
|
void minizinc_instance_destroy(MZNInstance _inst) {
|
|
auto inst = reinterpret_cast<Instance*>(_inst);
|
|
delete inst;
|
|
}
|
|
|
|
void minizinc_add_call(MZNInstance _inst, const char* call, ...) {
|
|
auto inst = reinterpret_cast<Instance*>(_inst);
|
|
auto it = inst->slv.resolve_call.find(call);
|
|
assert(it != inst->slv.resolve_call.end());
|
|
|
|
std::vector<Val> args;
|
|
va_list my_args;
|
|
va_start(my_args, call);
|
|
for (int i = 0; i < it->second.second; ++i) {
|
|
int num = va_arg(my_args, int);
|
|
args.emplace_back(num);
|
|
}
|
|
|
|
inst->slv.interpreter->call(it->second.first, std::move(args));
|
|
}
|
|
|
|
void minizinc_set_solution(MZNInstance _inst, int def, int sol) {
|
|
auto inst = reinterpret_cast<Instance*>(_inst);
|
|
auto it = inst->slv.interpreter->solutions.emplace(def, sol);
|
|
}
|
|
|
|
void minizinc_output_dict(MZNInstance _inst, bool b) {
|
|
auto inst = reinterpret_cast<Instance*>(_inst);
|
|
inst->slv.output_dict = b;
|
|
}
|
|
|
|
void minizinc_push_state(MZNInstance _inst) {
|
|
auto inst = reinterpret_cast<Instance*>(_inst);
|
|
inst->slv.interpreter->trail.save_state(inst->slv.interpreter);
|
|
inst->slv.pushToSolver();
|
|
}
|
|
void minizinc_pop_state(MZNInstance _inst) {
|
|
auto inst = reinterpret_cast<Instance*>(_inst);
|
|
inst->slv.interpreter->trail.untrail(inst->slv.interpreter);
|
|
inst->slv.popFromSolver();
|
|
}
|
|
|
|
void minizinc_print_hedge(MZNInstance _inst) {
|
|
auto inst = reinterpret_cast<Instance*>(_inst);
|
|
inst->slv.interpreter->dumpState(std::cerr);
|
|
}
|
|
|
|
void minizinc_set_limit(MZNInstance _inst, int limit) {
|
|
auto inst = reinterpret_cast<Instance*>(_inst);
|
|
auto opt = static_cast<GecodeOptions*>(inst->slv.getSI_OPT());
|
|
opt->nodes = limit;
|
|
}
|
|
|
|
std::string status_to_string(SolverInstance::Status s) {
|
|
switch (s) {
|
|
case SolverInstance::OPT:
|
|
return "OPT";
|
|
case SolverInstance::SAT:
|
|
return "SAT";
|
|
case SolverInstance::UNSAT:
|
|
return "UNSAT";
|
|
case SolverInstance::UNBND:
|
|
return "UNBND";
|
|
case SolverInstance::UNSATorUNBND:
|
|
return "UNSATorUNBND";
|
|
case SolverInstance::UNKNOWN:
|
|
return "UNKNOWN";
|
|
case SolverInstance::ERROR:
|
|
return "ERROR";
|
|
case SolverInstance::NONE:
|
|
return "NONE";
|
|
}
|
|
}
|
|
|
|
const char* minizinc_solve(MZNInstance _inst) {
|
|
auto inst = reinterpret_cast<Instance*>(_inst);
|
|
auto result = inst->slv.run();
|
|
|
|
std::stringstream ss;
|
|
ss << "{";
|
|
ss << "\"status\": \"" << status_to_string(result.first) << "\",";
|
|
if (result.first == MiniZinc::SolverInstance::SAT ||
|
|
result.first == MiniZinc::SolverInstance::OPT) {
|
|
ss << "\"solution\": " << result.second;
|
|
} else {
|
|
ss << R"("solution": "")";
|
|
}
|
|
ss << "}";
|
|
|
|
inst->result = ss.str();
|
|
return inst->result.c_str();
|
|
}
|