void nlopt_fill_gradient(const double * x, double * grad, void * extra) {
auto extra_info = static_cast<tuple<Enode *, box const &, bool> *>(extra);
Enode * e = get<0>(*extra_info);
box const & b = get<1>(*extra_info);
bool const polarity = get<2>(*extra_info);
unordered_map<Enode *, double> var_map;
unsigned i = 0;
vector<Enode*> forall_var_vec;
for (Enode * e : b.get_vars()) {
if (e->isForallVar()) {
var_map.emplace(e, x[i]);
i++;
forall_var_vec.push_back(e);
} else {
var_map.emplace(e, b[e].mid());
}
}
i = 0;
for (Enode * var : forall_var_vec) {
double deriv_i = deriv_enode(e->get1st(), var, var_map) - deriv_enode(e->get2nd(), var, var_map);
if (e->isGt() || e->isGeq()) {
deriv_i = - deriv_i;
}
if (!polarity) {
deriv_i = - deriv_i;
}
grad[i] = deriv_i;
i++;
}
}
double nlopt_eval_enode(const double* x, void * extra) {
auto extra_info = static_cast<tuple<Enode *, box const &, bool> *>(extra);
Enode * e = get<0>(*extra_info);
box const & b = get<1>(*extra_info);
bool const polarity = get<2>(*extra_info);
unordered_map<Enode *, double> var_map;
unsigned i = 0;
for (Enode * e : b.get_vars()) {
if (e->isForallVar()) {
var_map.emplace(e, x[i]);
i++;
} else {
var_map.emplace(e, b[e].mid());
}
}
try {
double const ret1 = eval_enode(e->get1st(), var_map);
double const ret2 = eval_enode(e->get2nd(), var_map);
double ret = 0;
if (e->isLt() || e->isLeq() || e->isEq()) {
ret = ret1 - ret2;
} else if (e->isGt() || e->isGeq()) {
ret = ret2 - ret1;
} else if (e->isEq()) {
throw runtime_error("nlopt_obj: something is wrong.");
}
if (!polarity) {
ret = - ret;
}
return ret;
} catch (exception & e) {
DREAL_LOG_FATAL << "Exception in nlopt_eval_enode: " << e.what() << endl;
throw e;
}
}
box refine_CE_with_nlopt_core(box counterexample, vector<Enode*> const & opt_ctrs, vector<Enode*> const & side_ctrs) {
// Plug-in `a` into the constraint and optimize `b` in the counterexample `M` by solving:
//
// ∃ y_opt ∈ I_y. ∀ y ∈ I_y. f(a, y_opt) >= f(a, y) — (2)
//
// using local optimizer (i.e. nlopt).
// Let `M’ = (a, b_opt)` be a model for (2).
DREAL_LOG_DEBUG << "================================" << endl;
DREAL_LOG_DEBUG << " Before Refinement " << endl;
DREAL_LOG_DEBUG << "================================" << endl;
DREAL_LOG_DEBUG << counterexample << endl;
DREAL_LOG_DEBUG << "================================" << endl;
static bool initialized = false;
static vector<double> lb, ub, init;
init.clear();
for (Enode * e : counterexample.get_vars()) {
if (e->isForallVar()) {
if (!initialized) {
lb.push_back(e->getDomainLowerBound());
ub.push_back(e->getDomainUpperBound());
}
init.push_back(counterexample[e].mid());
DREAL_LOG_DEBUG << lb.back() << " <= " << init.back() << " <= " << ub.back() << endl;
}
}
auto const n = init.size();
static nlopt::opt opt(nlopt::LD_SLSQP, n);
if (!initialized) {
opt.set_lower_bounds(lb);
opt.set_upper_bounds(ub);
// set tollerance
// TODO(soonhok): set precision
// opt.set_xtol_rel(0.0001);
opt.set_xtol_abs(0.001);
opt.set_maxtime(0.01);
initialized = true;
}
opt.remove_equality_constraints();
opt.remove_inequality_constraints();
// set objective function
vector<tuple<Enode *, box const &, bool> *> extra_vec;
Enode * e = opt_ctrs[0];
bool polarity = false;
while (e->isNot()) {
e = e->get1st();
polarity = !polarity;
}
auto extra = new tuple<Enode *, box const &, bool>(e, counterexample, polarity);
extra_vec.push_back(extra);
opt.set_min_objective(nlopt_obj, extra);
opt.add_inequality_constraint(nlopt_side_condition, extra);
DREAL_LOG_DEBUG << "objective function is added: " << e << endl;
// set side conditions
for (Enode * e : side_ctrs) {
bool polarity = false;
while (e->isNot()) {
e = e->get1st();
polarity = !polarity;
}
auto extra = new tuple<Enode *, box const &, bool>(e, counterexample, polarity);
extra_vec.push_back(extra);
DREAL_LOG_DEBUG << "refine_counterexample_with_nlopt: Side condition is added: " << e << endl;
if (e->isEq()) {
opt.add_equality_constraint(nlopt_side_condition, extra);
} else if (e->isLt() || e->isLeq() || e->isGt() || e->isGeq()) {
opt.add_inequality_constraint(nlopt_side_condition, extra);
}
}
try {
vector<double> output = opt.optimize(init);
unsigned i = 0;
for (Enode * e : counterexample.get_vars()) {
if (e->isForallVar()) {
counterexample[e] = output[i];
i++;
}
}
} catch (nlopt::roundoff_limited & e) {
} catch (std::runtime_error & e) {
DREAL_LOG_DEBUG << e.what() << endl;
}
for (auto extra : extra_vec) {
delete extra;
}
DREAL_LOG_DEBUG << "================================" << endl;
DREAL_LOG_DEBUG << " After Refinement " << endl;
DREAL_LOG_DEBUG << "================================" << endl;
DREAL_LOG_DEBUG << counterexample << endl;
DREAL_LOG_DEBUG << "================================" << endl;
return counterexample;
}