ibex::SystemFactory * contractor_ibex_polytope::build_system_factory(
vector<Enode *> const & vars, vector<shared_ptr<nonlinear_constraint>> const & ctrs) {
DREAL_LOG_DEBUG << "build_system_factory:";
ibex::SystemFactory * sf = new ibex::SystemFactory();
map<string, ibex::ExprSymbol const *> var_map; // Needed for translateEnodeToExprCtr
// Construct System: add Variables
for (Enode * e : vars) {
string const & name = e->getCar()->getNameFull();
DREAL_LOG_INFO << "build_system_factory: Add Variable " << name;
auto var_it = m_var_cache.find(e);
ibex::ExprSymbol const * var = nullptr;
if (var_it == m_var_cache.end()) {
// Not found
var = &ibex::ExprSymbol::new_(name.c_str(), ibex::Dim::scalar());
DREAL_LOG_INFO << "Added: var " << var << endl;
m_var_cache.emplace(e, var);
} else {
// Found
var = var_it->second;
}
var_map.emplace(name, var);
sf->add_var(*var);
}
DREAL_LOG_DEBUG << "build_system_factory: Add Variable: DONE";
// Construct System: add constraints
for (shared_ptr<nonlinear_constraint> const ctr : ctrs) {
if (ctr->is_neq()) {
continue;
}
DREAL_LOG_INFO << "build_system_factory: Add Constraint: " << *ctr;
Enode * e = ctr->get_enode();
auto p = e->getPolarity();
assert(p == l_True || p == l_False);
auto & m_exprctr_cache = (p == l_True) ? m_exprctr_cache_pos : m_exprctr_cache_neg;
auto exprctr_it = m_exprctr_cache.find(e);
ibex::ExprCtr const * exprctr = nullptr;
if (exprctr_it == m_exprctr_cache.end()) {
// Not found
exprctr = translate_enode_to_exprctr(var_map, e);
m_exprctr_cache.emplace(e, exprctr);
DREAL_LOG_INFO << "Added: exprctr " << p << " " << *exprctr << endl;
} else {
// Found
exprctr = exprctr_it->second;
}
if (exprctr) {
DREAL_LOG_INFO << "build_system_factory: Add Constraint: expr: " << *exprctr;
sf->add_ctr(*exprctr);
}
}
DREAL_LOG_DEBUG << "build_system_factory: Add Constraint: "
<< "DONE";
DREAL_LOG_DEBUG << "build_system_factory: DONE";
return sf;
}
void nonlinear_constraint::build_maps() const {
std::thread::id const tid = std::this_thread::get_id();
assert(m_numctr_map.find(tid) == m_numctr_map.cend());
assert(m_var_array_map.find(tid) == m_var_array_map.cend());
// Build var_array_map
map<string, ibex::ExprSymbol const *> var_map = build_var_map(m_domain_vars);
ibex::Array<ibex::ExprSymbol const> & var_array = m_var_array_map[tid];
var_array.resize(var_map.size());
int i = 0;
for (auto const item : var_map) {
var_array.set_ref(i++, *(item.second));
}
// The use of unique_ptr is to free the returned exprctr* from translate_enode_to_exprctr
unique_ptr<ibex::ExprCtr const> exprctr(
translate_enode_to_exprctr(var_map, get_enode(), m_polarity, m_subst));
m_numctr_map[tid].reset(new ibex::NumConstraint(var_array, *exprctr));
}
// ====================================================
// Nonlinear constraint
// ====================================================
nonlinear_constraint::nonlinear_constraint(Enode * const e,
unordered_set<Enode*> const & var_set,
lbool const p, unordered_map<Enode*, ibex::Interval> const & subst)
: constraint(constraint_type::Nonlinear, e), m_is_neq(p == l_False && e->isEq()),
m_numctr(nullptr), m_var_array(var_set.size()) {
// Build var_map and var_array
// Need to pass a fresh copy of var_array everytime it builds NumConstraint
auto var_map = build_var_map(var_set);
m_var_array.resize(var_map.size());
unsigned i = 0;
for (auto const item : var_map) {
m_var_array.set_ref(i++, item.second);
}
unique_ptr<ibex::ExprCtr const> exprctr(translate_enode_to_exprctr(var_map, e, p, subst));
m_numctr.reset(new ibex::NumConstraint(m_var_array, *exprctr));
DREAL_LOG_INFO << "nonlinear_constraint: "<< *this;
}
// ====================================================
// Nonlinear constraint
// ====================================================
nonlinear_constraint::nonlinear_constraint(Enode * const e, lbool p, std::unordered_map<Enode*, ibex::Interval> const & subst)
: constraint(constraint_type::Nonlinear, e), m_exprctr(nullptr), m_numctr(nullptr), m_numctr_ineq(nullptr), m_subst(subst) {
unordered_map<string, ibex::Variable const> var_map;
bool is_ineq = (p == l_False && e->isEq());
p = is_ineq ? true : p;
m_exprctr = translate_enode_to_exprctr(var_map, e, p, m_subst);
assert(m_exprctr);
m_var_array.resize(var_map.size());
unsigned i = 0;
for (auto const p : var_map) {
m_var_array.set_ref(i, p.second);
i++;
}
if (is_ineq) {
m_numctr_ineq = new ibex::NumConstraint(m_var_array, *m_exprctr);
} else {
m_numctr = new ibex::NumConstraint(m_var_array, *m_exprctr);
}
DREAL_LOG_INFO << "nonlinear_constraint: "<< *this;
}
