/**
* Dividing the box in all n dimensions producing 2^n boxes of the same size
* according to the precision vector e
*/
vector<box> box_factory::bisect(box b, map<string, pdrh::node*> e)
{
std::map<std::string, std::vector<capd::interval>> tmp_m;
std::map<std::string, capd::interval> m = b.get_map();
//cout << "BISECTING ";
for(auto it = m.cbegin(); it != m.cend(); it++)
{
//cout << it->first << ":" << it->second;
if(capd::intervals::width(it->second) > pdrh::node_to_interval(e[it->first]).leftBound())
{
//cout << " yes" << endl;
std::vector<capd::interval> tmp_v;
tmp_v.push_back(capd::interval((it->second).leftBound(), (it->second).mid().rightBound()));
tmp_v.push_back(capd::interval((it->second).mid().leftBound(), (it->second).rightBound()));
tmp_m.insert(make_pair(it->first, tmp_v));
}
else
{
//cout << " no" << endl;
}
}
return box_factory::cartesian_product(tmp_m);
}
/**
* Dividing the box in all n dimensions producing 2^n boxes of the same size
* according to the precision vector e
*/
vector<box> box_factory::bisect(box b, map<std::string, capd::interval> e)
{
if(e.empty())
{
return {b};
}
std::map<std::string, std::vector<capd::interval>> tmp_m;
std::map<std::string, capd::interval> m = b.get_map();
for(auto it = m.cbegin(); it != m.cend(); it++)
{
if(capd::intervals::width(it->second) > e[it->first].leftBound())
{
std::vector<capd::interval> tmp_v;
tmp_v.push_back(capd::interval((it->second).leftBound(), (it->second).mid().rightBound()));
tmp_v.push_back(capd::interval((it->second).mid().leftBound(), (it->second).rightBound()));
tmp_m.insert(make_pair(it->first, tmp_v));
}
else
{
tmp_m.insert(make_pair(it->first, vector<capd::interval>{it->second}));
}
}
return box_factory::cartesian_product(tmp_m);
}
int accent_box::compute_metrics(int style)
{
int r = p->compute_metrics(style);
p->compute_skew();
ab->compute_metrics(style);
printf(".nr " LEFT_WIDTH_FORMAT " 0\\n[" WIDTH_FORMAT "]/2"
">?(\\n[" WIDTH_FORMAT "]/2-\\n[" SKEW_FORMAT "])\n",
uid, p->uid, ab->uid, p->uid);
printf(".nr " WIDTH_FORMAT " 0\\n[" WIDTH_FORMAT "]/2"
">?(\\n[" WIDTH_FORMAT "]/2+\\n[" SKEW_FORMAT "])"
"+\\n[" LEFT_WIDTH_FORMAT "]\n",
uid, p->uid, ab->uid, p->uid, uid);
printf(".nr " DEPTH_FORMAT " \\n[" DEPTH_FORMAT "]\n", uid, p->uid);
printf(".nr " SUP_RAISE_FORMAT " \\n[" HEIGHT_FORMAT "]-%dM>?0\n",
uid, p->uid, x_height);
printf(".nr " HEIGHT_FORMAT " \\n[" HEIGHT_FORMAT "]+\\n["
SUP_RAISE_FORMAT "]\n",
uid, ab->uid, uid);
if (r)
printf(".nr " MARK_REG " +\\n[" LEFT_WIDTH_FORMAT "]"
"-(\\n[" WIDTH_FORMAT "]/2)'\n",
uid, p->uid);
return r;
}
/*! Return true if \p a includes \p b. */
friend pure bool includes(const sphere<T,N>& a,
const box<T,N>& b) {
const auto n = b.corner_count();
vec<T,N> c[n]; b.read_corners(c);
return std::all_of(c,c+n, [a](vec<T,N>& p) { return a.includes(p); });
}
double eval_enode_term(Enode * const e, box const & b) {
if (e->isVar()) {
return b.get_value(e).lb();
} else if (e->isConstant()) {
double const v = e->getValue();
return v;
} else if (e->isSymb()) {
throw runtime_error("eval_enode: Symb");
} else if (e->isNumb()) {
throw runtime_error("eval_enode: Numb");
} else if (e->isTerm()) {
assert(e->getArity() >= 1);
enodeid_t id = e->getCar()->getId();
double ret = 0.0;
Enode * tmp = e;
switch (id) {
case ENODE_ID_PLUS:
ret = eval_enode_term(tmp->get1st(), b);
tmp = tmp->getCdr()->getCdr(); // e is pointing to the 2nd arg
while (!tmp->isEnil()) {
ret = ret + eval_enode_term(tmp->getCar(), b);
tmp = tmp->getCdr();
}
return ret;
case ENODE_ID_MINUS:
ret = eval_enode_term(tmp->get1st(), b);
tmp = tmp->getCdr()->getCdr(); // e is pointing to the 2nd arg
while (!tmp->isEnil()) {
ret = ret - eval_enode_term(tmp->getCar(), b);
tmp = tmp->getCdr();
}
return ret;
case ENODE_ID_UMINUS:
ret = eval_enode_term(tmp->get1st(), b);
assert(tmp->getArity() == 1);
return (- ret);
case ENODE_ID_TIMES:
ret = eval_enode_term(tmp->get1st(), b);
tmp = tmp->getCdr()->getCdr(); // e is pointing to the 2nd arg
while (!tmp->isEnil()) {
ret = ret * eval_enode_term(tmp->getCar(), b);
tmp = tmp->getCdr();
}
return ret;
case ENODE_ID_DIV:
ret = eval_enode_term(tmp->get1st(), b);
tmp = tmp->getCdr()->getCdr(); // e is pointing to the 2nd arg
while (!tmp->isEnil()) {
ret = ret / eval_enode_term(tmp->getCar(), b);
tmp = tmp->getCdr();
}
return ret;
case ENODE_ID_ACOS:
assert(e->getArity() == 1);
return acos(eval_enode_term(e->get1st(), b));
case ENODE_ID_ASIN:
assert(e->getArity() == 1);
return asin(eval_enode_term(e->get1st(), b));
case ENODE_ID_ATAN:
assert(e->getArity() == 1);
return atan(eval_enode_term(e->get1st(), b));
case ENODE_ID_ATAN2:
assert(e->getArity() == 2);
return atan2(eval_enode_term(e->get1st(), b),
eval_enode_term(e->get2nd(), b));
case ENODE_ID_MIN:
assert(e->getArity() == 2);
return fmin(eval_enode_term(e->get1st(), b),
eval_enode_term(e->get2nd(), b));
case ENODE_ID_MAX:
assert(e->getArity() == 2);
return fmax(eval_enode_term(e->get1st(), b),
eval_enode_term(e->get2nd(), b));
case ENODE_ID_MATAN:
assert(e->getArity() == 1);
throw runtime_error("eval_enode: MATAN");
case ENODE_ID_SAFESQRT:
assert(e->getArity() == 1);
throw runtime_error("eval_enode: SAFESQRT");
case ENODE_ID_SQRT:
assert(e->getArity() == 1);
return sqrt(eval_enode_term(e->get1st(), b));
case ENODE_ID_EXP:
assert(e->getArity() == 1);
return exp(eval_enode_term(e->get1st(), b));
case ENODE_ID_LOG:
assert(e->getArity() == 1);
return log(eval_enode_term(e->get1st(), b));
case ENODE_ID_POW:
assert(e->getArity() == 2);
return pow(eval_enode_term(e->get1st(), b),
eval_enode_term(e->get2nd(), b));
case ENODE_ID_ABS:
assert(e->getArity() == 1);
return fabs(eval_enode_term(e->get1st(), b));
case ENODE_ID_SIN:
assert(e->getArity() == 1);
return sin(eval_enode_term(e->get1st(), b));
case ENODE_ID_COS:
assert(e->getArity() == 1);
return cos(eval_enode_term(e->get1st(), b));
case ENODE_ID_TAN:
assert(e->getArity() == 1);
return tan(eval_enode_term(e->get1st(), b));
case ENODE_ID_SINH:
assert(e->getArity() == 1);
return sinh(eval_enode_term(e->get1st(), b));
case ENODE_ID_COSH:
assert(e->getArity() == 1);
return cosh(eval_enode_term(e->get1st(), b));
case ENODE_ID_TANH:
assert(e->getArity() == 1);
return tanh(eval_enode_term(e->get1st(), b));
default:
throw runtime_error("eval_enode: Unknown Term");
}
} else if (e->isList()) {
throw runtime_error("eval_enode: List");
} else if (e->isDef()) {
throw runtime_error("eval_enode: Def");
} else if (e->isEnil()) {
throw runtime_error("eval_enode: Nil");
} else {
throw runtime_error("eval_enode: unknown case");
}
throw runtime_error("Not implemented yet: eval_enode");
}
//collision move sphere with box
bool kgmCollision::collision(vec3& start, vec3& end, float radius,
box& b, mtx4& btr)
{
int i = 0;
vec3 box_points[8];
vec3 box_sides[6][4];
b.points(box_points);
for(i = 0; i < 8; i++)
box_points[i] = btr * box_points[i];
box_sides[0][0] = box_points[0];
box_sides[0][1] = box_points[1];
box_sides[0][2] = box_points[5];
box_sides[0][3] = box_points[4];
box_sides[1][0] = box_points[1];
box_sides[1][1] = box_points[3];
box_sides[1][2] = box_points[7];
box_sides[1][3] = box_points[5];
box_sides[2][0] = box_points[3];
box_sides[2][1] = box_points[2];
box_sides[2][2] = box_points[6];
box_sides[2][3] = box_points[7];
box_sides[3][0] = box_points[2];
box_sides[3][1] = box_points[0];
box_sides[3][2] = box_points[4];
box_sides[3][3] = box_points[6];
box_sides[4][0] = box_points[0];
box_sides[4][1] = box_points[2];
box_sides[4][2] = box_points[3];
box_sides[4][3] = box_points[1];
box_sides[5][0] = box_points[4];
box_sides[5][1] = box_points[5];
box_sides[5][2] = box_points[7];
box_sides[5][3] = box_points[6];
float dist = -1.0f;
vec3 ptins;
m_collision = false;
for(i = 0; i < 6; i++)
{
if(collision(start, end, radius, box_sides[i], 4))
{
// if(collision(start, end, radius, box_sides[i][0], box_sides[i][1],box_sides[i][2], ptins) ||
// collision(start, end, radius, box_sides[i][0], box_sides[i][2],box_sides[i][3], ptins)){
ptins = m_point;
m_collision = true;
break;
if(m_collision)
{
if(start.distance(m_point) > dist)
m_point = ptins;
else
dist = start.distance(m_point);
}
else
{
dist = start.distance(m_point);
}
m_collision = true;
}
}
return m_collision;
}
box intersect(box b1, box const & b2) {
b1.intersect(b2);
return b1;
}
void prime_box::output()
{
p->output();
pb->output();
}
box ncbt_icp::solve(box b, contractor & ctc, SMTConfig & config) {
thread_local static unordered_set<shared_ptr<constraint>> used_constraints;
used_constraints.clear();
static unsigned prune_count = 0;
thread_local static vector<box> box_stack;
box_stack.clear();
box_stack.push_back(b);
do {
// Loop Invariant
DREAL_LOG_INFO << "ncbt_icp::solve - loop"
<< "\t" << "box stack Size = " << box_stack.size();
b = box_stack.back();
try {
ctc.prune(b, config);
auto const this_used_constraints = ctc.used_constraints();
used_constraints.insert(this_used_constraints.begin(), this_used_constraints.end());
if (config.nra_use_stat) { config.nra_stat.increase_prune(); }
} catch (contractor_exception & e) {
// Do nothing
}
prune_count++;
box_stack.pop_back();
if (!b.is_empty()) {
// SAT
tuple<int, box, box> splits = b.bisect(config.nra_precision);
if (config.nra_use_stat) { config.nra_stat.increase_branch(); }
int const index = get<0>(splits);
if (index >= 0) {
box const & first = get<1>(splits);
box const & second = get<2>(splits);
assert(first.get_idx_last_branched() == index);
assert(second.get_idx_last_branched() == index);
if (second.is_bisectable()) {
box_stack.push_back(second);
box_stack.push_back(first);
} else {
box_stack.push_back(first);
box_stack.push_back(second);
}
} else {
break;
}
} else {
// UNSAT (b is emptified by pruning operators)
// If this bisect_var is not used in all used
// constraints, this box is safe to be popped.
thread_local static unordered_set<Enode *> used_vars;
used_vars.clear();
for (auto used_ctr : used_constraints) {
auto this_used_vars = used_ctr->get_vars();
used_vars.insert(this_used_vars.begin(), this_used_vars.end());
}
while (box_stack.size() > 0) {
int const bisect_var = box_stack.back().get_idx_last_branched();
assert(bisect_var >= 0);
// If this bisect_var is not used in all used
// constraints, this box is safe to be popped.
if (used_vars.find(b.get_vars()[bisect_var]) != used_vars.end()) {
// DREAL_LOG_FATAL << b.get_vars()[bisect_var] << " is used in "
// << *used_ctr << " and it's not safe to skip";
break;
}
// DREAL_LOG_FATAL << b.get_vars()[bisect_var] << " is not used and it's safe to skip this box"
// << " (" << box_stack.size() << ")";
box_stack.pop_back();
}
}
} while (box_stack.size() > 0);
DREAL_LOG_DEBUG << "prune count = " << prune_count;
ctc.set_used_constraints(used_constraints);
return b;
}
void contractor_gsl::prune(box & b, SMTConfig & config) {
// TODO(soonhok): add timeout
fesetround(FE_TONEAREST); // Without this, GSL might cause a segmentation fault due to problems in floating point lib
gsl_odeiv2_step_reset(m_step);
gsl_odeiv2_evolve_reset(m_evolve);
double const T_lb = b[m_time_t].lb();
double const T_ub = b[m_time_t].ub();
double t = 0.0, old_t = 0.0; /* initialize t */
double T_next = 0.0;
double h = 1e-10; /* starting step size for ode solver */
DREAL_LOG_INFO << "GSL: prune begin "
<< m_time_t << " = ["
<< T_lb << ", " << T_ub << "]"
<< "\t" << b.max_diam();
DREAL_LOG_INFO << m_ctr->get_ic();
if (b.max_diam() < config.nra_precision) {
return;
}
bool need_to_run = false;
for (Enode * e : m_vars_0) {
if (b[e].diam() > config.nra_precision) {
need_to_run = true;
break;
}
}
if (b[m_time_t].diam() > config.nra_precision) {
need_to_run = true;
}
if (!need_to_run) { return; }
extract_sample_point(b, m_vars_0, m_values);
extract_sample_point(b, m_pars_0, m_params);
for (unsigned i = 0; i < m_vars_0.size(); i++) {
b[m_vars_0[i]] = m_values[i];
}
for (unsigned i = 0; i < m_pars_0.size(); i++) {
b[m_pars_0[i]] = m_params[i];
}
// First move to T_lb without checking m_values
while (t < T_lb) {
interruption_point();
T_next = T_lb;
// T_next = min(t + config.nra_precision, T_lb);
int status = gsl_odeiv2_evolve_apply(m_evolve, m_control, m_step,
&m_system,
&t, T_next,
&h, m_values);
if (status != GSL_SUCCESS) {
DREAL_LOG_INFO << "GSL: error, return value " << status;
throw contractor_exception("GSL FAILED");
}
}
// Now we're in the range in [T_lb, T_ub], need to check m_values.
while (t < T_ub) {
interruption_point();
T_next = min(t + config.nra_precision, T_ub);
// T_next = T_ub;
// Copy m_values to m_old_values, and t to old_t
for (unsigned i = 0; i < m_dim; i++) {
m_old_values[i] = m_values[i];
}
old_t = t;
int status = gsl_odeiv2_evolve_apply(m_evolve, m_control, m_step,
&m_system,
&t, T_next,
&h, m_values);
if (status != GSL_SUCCESS) {
DREAL_LOG_INFO << "GSL: error, return value " << status;
throw contractor_exception("GSL FAILED");
}
// print_values(t, m_values, m_dim); /* print at t */
bool values_good = true;
unsigned i = 0;
for (Enode * e : m_vars_t) {
double const old_v_i = m_old_values[i];
double const v_i = m_values[i];
auto iv = (old_v_i < v_i) ? ibex::Interval(old_v_i, v_i) : ibex::Interval(v_i, old_v_i);
auto const & iv_X_t = b[e];
iv &= iv_X_t;
if (iv.is_empty()) {
values_good = false;
DREAL_LOG_INFO << "GSL Not in Range: " << e
<< " : " << m_values[i] << " not in " << b[e] << " at t = " << t;
break;
}
i++;
}
if (values_good) {
thread_local static box old_box(b);
old_box = b;
// Update X_t with m_values
i = 0;
for (Enode * e : m_vars_t) {
double const old_v_i = m_old_values[i];
double const v_i = m_values[i];
auto iv = (old_v_i < v_i) ? ibex::Interval(old_v_i, v_i) : ibex::Interval(v_i, old_v_i);
auto const & iv_X_t = b[e];
iv &= iv_X_t;
DREAL_LOG_INFO << "GSL Update: " << e
<< " : " << b[e] << " ==> " << iv;
b[e] = iv;
i++;
}
// Update Time with T
double const new_t = t/2.0 + old_t/2.0;
DREAL_LOG_INFO << "GSL Update: time: " << b[m_time_t] << " ==> " << new_t;
b[m_time_t] = new_t;
m_eval_ctc.prune(b, config);
if (!b.is_empty()) {
DREAL_LOG_INFO << "This box satisfies other non-linear constraints";
return;
} else {
DREAL_LOG_INFO << "This box failed to satisfy other non-linear constraints";
b = old_box;
}
}
}
DREAL_LOG_INFO << "GSL failed in the end";
throw contractor_exception("GSL failed");
}
box naive_icp::solve(box b, contractor & ctc, SMTConfig & config) {
thread_local static std::unordered_set<std::shared_ptr<constraint>> used_constraints;
used_constraints.clear();
thread_local static vector<box> solns;
thread_local static vector<box> box_stack;
solns.clear();
box_stack.clear();
box_stack.push_back(b);
do {
DREAL_LOG_INFO << "naive_icp::solve - loop"
<< "\t" << "box stack Size = " << box_stack.size();
b = box_stack.back();
box_stack.pop_back();
try {
ctc.prune(b, config);
auto this_used_constraints = ctc.used_constraints();
used_constraints.insert(this_used_constraints.begin(), this_used_constraints.end());
if (config.nra_use_stat) { config.nra_stat.increase_prune(); }
} catch (contractor_exception & e) {
// Do nothing
}
if (!b.is_empty()) {
tuple<int, box, box> splits = b.bisect(config.nra_precision);
if (config.nra_use_stat) { config.nra_stat.increase_branch(); }
int const i = get<0>(splits);
if (i >= 0) {
box const & first = get<1>(splits);
box const & second = get<2>(splits);
assert(first.get_idx_last_branched() == i);
assert(second.get_idx_last_branched() == i);
if (second.is_bisectable()) {
box_stack.push_back(second);
box_stack.push_back(first);
} else {
box_stack.push_back(first);
box_stack.push_back(second);
}
if (config.nra_proof) {
config.nra_proof_out << "[branched on "
<< b.get_name(i)
<< "]" << endl;
}
} else {
config.nra_found_soln++;
if (config.nra_multiple_soln > 1) {
// If --multiple_soln is used
output_solution(b, config, config.nra_found_soln);
}
if (config.nra_found_soln >= config.nra_multiple_soln) {
break;
}
solns.push_back(b);
}
}
} while (box_stack.size() > 0);
ctc.set_used_constraints(used_constraints);
if (config.nra_multiple_soln > 1 && solns.size() > 0) {
return solns.back();
} else {
assert(!b.is_empty() || box_stack.size() == 0);
return b;
}
}
void delim_box::check_tabs(int level)
{
p->check_tabs(level);
}
void uaccent_box::check_tabs(int level)
{
ab->check_tabs(level + 1);
p->check_tabs(level + 1);
}
int script_box::compute_metrics(int style)
{
int res = p->compute_metrics(style);
p->compute_subscript_kern();
printf(".nr " SIZE_FORMAT " \\n[.ps]\n", uid);
if (!(style <= SCRIPT_STYLE && one_size_reduction_flag))
set_script_size();
printf(".nr " SMALL_SIZE_FORMAT " \\n[.ps]\n", uid);
if (sub != 0)
sub->compute_metrics(cramped_style(script_style(style)));
if (sup != 0)
sup->compute_metrics(script_style(style));
// 18a
if (p->is_char()) {
printf(".nr " SUP_RAISE_FORMAT " 0\n", uid);
printf(".nr " SUB_LOWER_FORMAT " 0\n", uid);
}
else {
printf(".nr " SUP_RAISE_FORMAT " \\n[" HEIGHT_FORMAT "]-%dM>?0\n",
uid, p->uid, sup_drop);
printf(".nr " SUB_LOWER_FORMAT " \\n[" DEPTH_FORMAT "]+%dM\n",
uid, p->uid, sub_drop);
}
printf(".ps \\n[" SIZE_FORMAT "]u\n", uid);
if (sup == 0) {
assert(sub != 0);
// 18b
printf(".nr " SUB_LOWER_FORMAT " \\n[" SUB_LOWER_FORMAT "]>?%dM>?(\\n["
HEIGHT_FORMAT "]-(%dM*4/5))\n",
uid, uid, sub1, sub->uid, x_height);
}
else {
// sup != 0
// 18c
int pos;
if (style == DISPLAY_STYLE)
pos = sup1;
else if (style & 1) // not cramped
pos = sup2;
else
pos = sup3;
printf(".nr " SUP_RAISE_FORMAT " \\n[" SUP_RAISE_FORMAT
"]>?%dM>?(\\n[" DEPTH_FORMAT "]+(%dM/4))\n",
uid, uid, pos, sup->uid, x_height);
// 18d
if (sub != 0) {
printf(".nr " SUB_LOWER_FORMAT " \\n[" SUB_LOWER_FORMAT "]>?%dM\n",
uid, uid, sub2);
// 18e
printf(".nr " TEMP_REG " \\n[" DEPTH_FORMAT "]-\\n["
SUP_RAISE_FORMAT "]+\\n[" HEIGHT_FORMAT "]-\\n["
SUB_LOWER_FORMAT "]+(4*%dM)\n",
sup->uid, uid, sub->uid, uid, default_rule_thickness);
printf(".if \\n[" TEMP_REG "] \\{");
printf(".nr " SUB_LOWER_FORMAT " +\\n[" TEMP_REG "]\n", uid);
printf(".nr " TEMP_REG " (%dM*4/5)-\\n[" SUP_RAISE_FORMAT
"]+\\n[" DEPTH_FORMAT "]>?0\n",
x_height, uid, sup->uid);
printf(".nr " SUP_RAISE_FORMAT " +\\n[" TEMP_REG "]\n", uid);
printf(".nr " SUB_LOWER_FORMAT " -\\n[" TEMP_REG "]\n", uid);
printf(".\\}\n");
}
}
printf(".nr " WIDTH_FORMAT " 0\\n[" WIDTH_FORMAT "]", uid, p->uid);
if (sub != 0 && sup != 0)
printf("+((\\n[" WIDTH_FORMAT "]-\\n[" SUB_KERN_FORMAT "]>?\\n["
WIDTH_FORMAT "])+%dM)>?0\n",
sub->uid, p->uid, sup->uid, script_space);
else if (sub != 0)
printf("+(\\n[" WIDTH_FORMAT "]-\\n[" SUB_KERN_FORMAT "]+%dM)>?0\n",
sub->uid, p->uid, script_space);
else if (sup != 0)
printf("+(\\n[" WIDTH_FORMAT "]+%dM)>?0\n", sup->uid, script_space);
else
printf("\n");
printf(".nr " HEIGHT_FORMAT " \\n[" HEIGHT_FORMAT "]",
uid, p->uid);
if (sup != 0)
printf(">?(\\n[" SUP_RAISE_FORMAT "]+\\n[" HEIGHT_FORMAT "])",
uid, sup->uid);
if (sub != 0)
printf(">?(-\\n[" SUB_LOWER_FORMAT "]+\\n[" HEIGHT_FORMAT "])",
uid, sub->uid);
printf("\n");
printf(".nr " DEPTH_FORMAT " \\n[" DEPTH_FORMAT "]",
uid, p->uid);
if (sub != 0)
printf(">?(\\n[" SUB_LOWER_FORMAT "]+\\n[" DEPTH_FORMAT "])",
uid, sub->uid);
if (sup != 0)
printf(">?(-\\n[" SUP_RAISE_FORMAT "]+\\n[" DEPTH_FORMAT "])",
uid, sup->uid);
printf("\n");
return res;
}
contractor_sample::contractor_sample(box const & b, unsigned const n, vector<shared_ptr<constraint>> const & ctrs)
: contractor_cell(contractor_kind::SAMPLE), m_num_samples(n), m_ctrs(ctrs) {
m_input = ibex::BitSet::all(b.size());
}
// Find any robots that may be in the torus range
std::vector<Uni::Robot *> QuadTree::find_in_range(const box &b)
{
std::vector<Uni::Robot *> found;
found = this->get_leaves_at(b);
if((b.min_x() >= 0.0f) && (b.min_y() >= 0.0f) && (b.max_x() <= 1.0f) && (b.max_y() <= 1.0f))
{
return found;
}
// deal with robots in torus
std::vector<Uni::Robot *> overflow;
box query;
if(b.min_x() < 0.0f)
{
query.width = b.min_x() * (-2);
query.height = b.height;
query.centre.x = 1;
query.centre.y = b.centre.y;
overflow = this->get_leaves_at(query);
if(!overflow.empty())
{
found.insert(found.end(), overflow.begin(), overflow.end());
overflow.clear();
}
}
else if(b.max_x() > 1.0f)
{
query.width = (1 - b.min_x()) * 2;
query.height = b.height;
query.centre.x = 0;
query.centre.y = b.centre.y;
overflow = this->get_leaves_at(query);
if(!overflow.empty())
{
found.insert(found.end(), overflow.begin(), overflow.end());
overflow.clear();
}
}
if(b.min_y() < 0.0f)
{
query.width = b.width;
query.height = b.min_y() * (-2);
query.centre.x = b.centre.x;
query.centre.y = 1;
overflow = this->get_leaves_at(query);
if(!overflow.empty())
{
found.insert(found.end(), overflow.begin(), overflow.end());
overflow.clear();
}
}
else if(b.max_y() > 1.0f)
{
query.width = b.width;
query.height = (1 - b.min_y()) * 2;
query.centre.x = b.centre.x;
query.centre.y = 0;
overflow = this->get_leaves_at(query);
if(!overflow.empty())
{
found.insert(found.end(), overflow.begin(), overflow.end());
overflow.clear();
}
}
if((b.min_x() < 0.0f) && (b.min_y() < 0.0f))
{
query.width = b.min_x() * (-2);
query.height = b.min_y() * (-2);
query.centre.x = 1;
query.centre.y = 1;
overflow = this->get_leaves_at(query);
if(!overflow.empty())
{
found.insert(found.end(), overflow.begin(), overflow.end());
overflow.clear();
}
}
else if((b.max_x() > 1.0f) && (b.max_y() > 1.0f))
{
query.width = (1 - b.min_x()) * 2;
query.height = (1 - b.min_y()) * 2;
query.centre.x = 0;
query.centre.y = 0;
overflow = this->get_leaves_at(query);
if(!overflow.empty())
{
found.insert(found.end(), overflow.begin(), overflow.end());
overflow.clear();
}
}
else if((b.min_x() < 0.0f) && (b.max_y() > 1.0f))
{
query.width = b.min_x() * (-2);
query.height = (1 - b.min_y()) * 2;
query.centre.x = 1;
query.centre.y = 0;
overflow = this->get_leaves_at(query);
if(!overflow.empty())
{
found.insert(found.end(), overflow.begin(), overflow.end());
overflow.clear();
}
}
else if((b.min_y() < 0.0f) && (b.max_x() > 1.0f))
{
query.width = (1 - b.min_x()) * 2;
query.height = b.min_y() * (-2);
query.centre.x = 0;
query.centre.y = 1;
overflow = this->get_leaves_at(query);
if(!overflow.empty())
{
found.insert(found.end(), overflow.begin(), overflow.end());
overflow.clear();
}
}
return found;
}
box multiprune_icp::solve(box b, contractor & ctc,
scoped_vec<shared_ptr<constraint>> const & ctrs,
SMTConfig & config, BranchHeuristic& brancher, unsigned num_try) {
#define PRUNEBOX(x) prune((x), ctc, config, used_constraints)
thread_local static unordered_set<shared_ptr<constraint>> used_constraints;
used_constraints.clear();
thread_local static vector<box> solns;
thread_local static vector<box> box_stack;
solns.clear();
box_stack.clear();
PRUNEBOX(b);
box_stack.push_back(b);
do {
DREAL_LOG_INFO << "multiprune_icp::solve - loop"
<< "\t" << "box stack Size = " << box_stack.size();
b = box_stack.back();
box_stack.pop_back();
if (!b.is_empty()) {
vector<int> sorted_dims = brancher.sort_branches(b, ctrs, config);
if (sorted_dims.size() > num_try) {
sorted_dims = vector<int>(sorted_dims.begin(), sorted_dims.begin()+num_try);
}
if (config.nra_use_stat) { config.nra_stat.increase_branch(); }
if (sorted_dims.size() > 0) {
int bisectdim = -1;
box first = b;
box second = b;
double score = -INFINITY;
for (int dim : sorted_dims) {
tuple<int, box, box> splits = b.bisect_at(dim);
box a1 = get<1>(splits);
box a2 = get<2>(splits);
PRUNEBOX(a1);
PRUNEBOX(a2);
double cscore = -a1.volume() * a2.volume();
if (cscore > score || bisectdim == -1) {
first.hull(second);
a1.intersect(first);
a2.intersect(first);
first = a1;
second = a2;
bisectdim = dim;
score = cscore;
} else {
a1.hull(a2);
first.intersect(a1);
second.intersect(a1);
}
}
assert(bisectdim != -1);
assert(first.get_idx_last_branched() == bisectdim);
assert(second.get_idx_last_branched() == bisectdim);
if (second.is_bisectable()) {
box_stack.push_back(second);
box_stack.push_back(first);
} else {
box_stack.push_back(first);
box_stack.push_back(second);
}
if (config.nra_proof) {
config.nra_proof_out << "[branched on "
<< b.get_name(bisectdim)
<< "]" << endl;
}
} else {
config.nra_found_soln++;
if (config.nra_multiple_soln > 1) {
// If --multiple_soln is used
output_solution(b, config, config.nra_found_soln);
}
if (config.nra_found_soln >= config.nra_multiple_soln) {
break;
}
solns.push_back(b);
}
}
} while (box_stack.size() > 0);
ctc.set_used_constraints(used_constraints);
if (config.nra_multiple_soln > 1 && solns.size() > 0) {
return solns.back();
} else {
assert(!b.is_empty() || box_stack.size() == 0);
return b;
}
#undef PRUNEBOX
}
receptor::receptor(istream& is, const box& b) : partitions(b.num_partitions)
{
// Initialize necessary variables for constructing a receptor.
atoms.reserve(5000); // A receptor typically consists of <= 5,000 atoms.
// Initialize helper variables for parsing.
string residue = "XXXX"; // Current residue sequence, used to track residue change, initialized to a dummy value.
vector<size_t> residues;
residues.reserve(1000); // A receptor typically consists of <= 1,000 residues, including metal ions and water molecules if any.
size_t num_lines = 0; // Used to track line number for reporting parsing errors, if any.
string line;
line.reserve(79); // According to PDBQT specification, the last item AutoDock atom type locates at 1-based [78, 79].
// Parse ATOM/HETATM.
while (getline(is, line))
{
++num_lines;
if (starts_with(line, "ATOM") || starts_with(line, "HETATM"))
{
// Parse and validate AutoDock4 atom type.
const string ad_type_string = line.substr(77, isspace(line[78]) ? 1 : 2);
const size_t ad = parse_ad_type_string(ad_type_string);
if (ad == AD_TYPE_SIZE) continue;
// Skip non-polar hydrogens.
if (ad == AD_TYPE_H) continue;
// Parse the Cartesian coordinate.
string name = line.substr(12, 4);
boost::algorithm::trim(name);
const atom a(line.substr(21, 1) + ':' + line.substr(17, 3) + right_cast<string>(line, 23, 26) + ':' + name, vec3(right_cast<fl>(line, 31, 38), right_cast<fl>(line, 39, 46), right_cast<fl>(line, 47, 54)), ad);
// For a polar hydrogen, the bonded hetero atom must be a hydrogen bond donor.
if (ad == AD_TYPE_HD)
{
const size_t residue_start = residues.back();
for (size_t i = atoms.size(); i > residue_start;)
{
atom& b = atoms[--i];
if (!b.is_hetero()) continue; // Only a hetero atom can be a hydrogen bond donor.
if (a.is_neighbor(b))
{
b.donorize();
break;
}
}
}
else // It is a heavy atom.
{
// Parse the residue sequence located at 1-based [23, 26].
if ((line[25] != residue[3]) || (line[24] != residue[2]) || (line[23] != residue[1]) || (line[22] != residue[0])) // This line is the start of a new residue.
{
residue[3] = line[25];
residue[2] = line[24];
residue[1] = line[23];
residue[0] = line[22];
residues.push_back(atoms.size());
}
atoms.push_back(a);
}
}
else if (starts_with(line, "TER"))
{
residue = "XXXX";
}
}
// Dehydrophobicize carbons if necessary.
const size_t num_residues = residues.size();
residues.push_back(atoms.size());
for (size_t r = 0; r < num_residues; ++r)
{
const size_t begin = residues[r];
const size_t end = residues[r + 1];
for (size_t i = begin; i < end; ++i)
{
const atom& a = atoms[i];
if (!a.is_hetero()) continue; // a is a hetero atom.
for (size_t j = begin; j < end; ++j)
{
atom& b = atoms[j];
if (b.is_hetero()) continue; // b is a carbon atom.
// If carbon atom b is bonded to hetero atom a, b is no longer a hydrophobic atom.
if (a.is_neighbor(b))
{
b.dehydrophobicize();
}
}
}
}
// Find all the heavy receptor atoms that are within 8A of the box.
vector<size_t> receptor_atoms_within_cutoff;
receptor_atoms_within_cutoff.reserve(atoms.size());
const size_t num_rec_atoms = atoms.size();
for (size_t i = 0; i < num_rec_atoms; ++i)
{
const atom& a = atoms[i];
if (b.project_distance_sqr(a.coordinate) < scoring_function::Cutoff_Sqr)
{
receptor_atoms_within_cutoff.push_back(i);
}
}
const size_t num_receptor_atoms_within_cutoff = receptor_atoms_within_cutoff.size();
// Allocate each nearby receptor atom to its corresponding partition.
for (size_t x = 0; x < b.num_partitions[0]; ++x)
for (size_t y = 0; y < b.num_partitions[1]; ++y)
for (size_t z = 0; z < b.num_partitions[2]; ++z)
{
vector<size_t>& par = partitions(x, y, z);
par.reserve(num_receptor_atoms_within_cutoff);
const array<size_t, 3> index1 = {{ x, y, z }};
const array<size_t, 3> index2 = {{ x + 1, y + 1, z + 1 }};
const vec3 corner1 = b.partition_corner1(index1);
const vec3 corner2 = b.partition_corner1(index2);
for (size_t l = 0; l < num_receptor_atoms_within_cutoff; ++l)
{
const size_t i = receptor_atoms_within_cutoff[l];
const atom& a = atoms[i];
const fl proj_dist_sqr = b.project_distance_sqr(corner1, corner2, a.coordinate);
if (proj_dist_sqr < scoring_function::Cutoff_Sqr)
{
par.push_back(i);
}
}
}
}
int limit_box::compute_metrics(int style)
{
printf(".nr " SIZE_FORMAT " \\n[.ps]\n", uid);
if (!(style <= SCRIPT_STYLE && one_size_reduction_flag))
set_script_size();
printf(".nr " SMALL_SIZE_FORMAT " \\n[.ps]\n", uid);
int res = 0;
int mark_uid = -1;
if (from != 0) {
res = from->compute_metrics(cramped_style(script_style(style)));
if (res)
mark_uid = from->uid;
}
if (to != 0) {
int r = to->compute_metrics(script_style(style));
if (res && r)
error("multiple marks and lineups");
else {
mark_uid = to->uid;
res = r;
}
}
printf(".ps \\n[" SIZE_FORMAT "]u\n", uid);
int r = p->compute_metrics(style);
p->compute_subscript_kern();
if (res && r)
error("multiple marks and lineups");
else {
mark_uid = p->uid;
res = r;
}
printf(".nr " LEFT_WIDTH_FORMAT " "
"0\\n[" WIDTH_FORMAT "]",
uid, p->uid);
if (from != 0)
printf(">?(\\n[" SUB_KERN_FORMAT "]+\\n[" WIDTH_FORMAT "])",
p->uid, from->uid);
if (to != 0)
printf(">?(-\\n[" SUB_KERN_FORMAT "]+\\n[" WIDTH_FORMAT "])",
p->uid, to->uid);
printf("/2\n");
printf(".nr " WIDTH_FORMAT " "
"0\\n[" WIDTH_FORMAT "]",
uid, p->uid);
if (from != 0)
printf(">?(-\\n[" SUB_KERN_FORMAT "]+\\n[" WIDTH_FORMAT "])",
p->uid, from->uid);
if (to != 0)
printf(">?(\\n[" SUB_KERN_FORMAT "]+\\n[" WIDTH_FORMAT "])",
p->uid, to->uid);
printf("/2+\\n[" LEFT_WIDTH_FORMAT "]\n", uid);
printf(".nr " WIDTH_FORMAT " 0\\n[" WIDTH_FORMAT "]", uid, p->uid);
if (to != 0)
printf(">?\\n[" WIDTH_FORMAT "]", to->uid);
if (from != 0)
printf(">?\\n[" WIDTH_FORMAT "]", from->uid);
printf("\n");
if (res)
printf(".nr " MARK_REG " +(\\n[" LEFT_WIDTH_FORMAT "]"
"-(\\n[" WIDTH_FORMAT "]/2))\n",
uid, mark_uid);
if (to != 0) {
printf(".nr " SUP_RAISE_FORMAT " %dM+\\n[" DEPTH_FORMAT
"]>?%dM+\\n[" HEIGHT_FORMAT "]\n",
uid, big_op_spacing1, to->uid, big_op_spacing3, p->uid);
printf(".nr " HEIGHT_FORMAT " \\n[" SUP_RAISE_FORMAT "]+\\n["
HEIGHT_FORMAT "]+%dM\n",
uid, uid, to->uid, big_op_spacing5);
}
else
printf(".nr " HEIGHT_FORMAT " \\n[" HEIGHT_FORMAT "]\n", uid, p->uid);
if (from != 0) {
printf(".nr " SUB_LOWER_FORMAT " %dM+\\n[" HEIGHT_FORMAT
"]>?%dM+\\n[" DEPTH_FORMAT "]\n",
uid, big_op_spacing2, from->uid, big_op_spacing4, p->uid);
printf(".nr " DEPTH_FORMAT " \\n[" SUB_LOWER_FORMAT "]+\\n["
DEPTH_FORMAT "]+%dM\n",
uid, uid, from->uid, big_op_spacing5);
}
else
printf(".nr " DEPTH_FORMAT " \\n[" DEPTH_FORMAT "]\n", uid, p->uid);
return res;
}
void contractor_parallel_all::prune(box & b, SMTConfig & config) {
DREAL_LOG_DEBUG << "contractor_parallel_all::prune";
DREAL_LOG_FATAL << "-------------------------------------------------------------";
// TODO(soonhok): implement this
if (m_vec.size() == 0) {
// Do nothing for empty vec
return;
}
// 1. Make n copies of box b
vector<box> boxes(m_vec.size(), b);
vector<pruning_thread_status> statuses(m_vec.size(), pruning_thread_status::READY);
m_index = -1;
// DREAL_LOG_FATAL << "parallel: Boxes are copied";
// 2. Trigger execution with each contractor and a copied box
vector<interruptible_thread> threads;
atomic_int tasks_to_run(m_vec.size());
// DREAL_LOG_FATAL << "parallel: tasks to run = " << tasks_to_run.load();
for (unsigned i = 0; i < m_vec.size(); ++i) {
DREAL_LOG_FATAL << "parallel : thread " << i << " / " << (tasks_to_run.load() - 1)
<< " spawning...";
threads.emplace_back(parallel_helper_fn,
i,
m_vec[i],
boxes[i],
config,
statuses[i],
m_mutex,
m_cv,
m_index,
tasks_to_run);
DREAL_LOG_FATAL << "parallel : thread " << i << " / " << (tasks_to_run.load() - 1)
<< " spawned...";
}
DREAL_LOG_FATAL << "parallel : " << m_vec.size() << " thread(s) got created";
while (true) {
DREAL_LOG_FATAL << "parallel: waiting for the lock";
unique_lock<mutex> lk(m_mutex);
DREAL_LOG_FATAL << "parallel: get a lock. " << tasks_to_run.load() << " tasks to go";
if (tasks_to_run.load() == 0) {
break;
}
DREAL_LOG_FATAL << "parallel: WAIT for CV." << tasks_to_run.load() << " tasks to go";;
m_index = -1;
m_cv.wait(lk, [&]() { return m_index != -1; });
DREAL_LOG_FATAL << "parallel: wake up" << tasks_to_run.load();
pruning_thread_status const & s = statuses[m_index];
// DREAL_LOG_FATAL << "parallel: thread " << m_index << " " << s;
if (s == pruning_thread_status::UNSAT || s == pruning_thread_status::EXCEPTION) {
// Interrupt all the rest threads
for (unsigned i = 0; i < statuses.size(); i++) {
if (i - m_index != 0 && (statuses[i] == pruning_thread_status::READY || statuses[i] == pruning_thread_status::RUNNING)) {
threads[i].interrupt();
}
}
if (s == pruning_thread_status::UNSAT) {
DREAL_LOG_FATAL << "parallel: " << m_index << " got UNSAT";
b.set_empty();
m_input.union_with(m_vec[m_index].input());
m_output.union_with(m_vec[m_index].output());
unordered_set<shared_ptr<constraint>> const & used_ctrs = m_vec[m_index].used_constraints();
m_used_constraints.insert(used_ctrs.begin(), used_ctrs.end());
lk.unlock();
for (unsigned i = 0; i < m_vec.size(); i++) {
threads[i].join();
}
DREAL_LOG_FATAL << "parallel: return UNSAT";
return;
}
if (s == pruning_thread_status::EXCEPTION) {
DREAL_LOG_FATAL << "parallel: " << m_index << " got EXCEPTION";
lk.unlock();
for (unsigned i = 0; i < m_vec.size(); i++) {
threads[i].join();
}
DREAL_LOG_FATAL << "parallel: throw exception";
throw contractor_exception("exception during parallel contraction");
}
} else {
// if (s != pruning_thread_status::SAT) {
// // DREAL_LOG_FATAL << "parallel: " << m_index << " got " << s;
// // DREAL_LOG_FATAL << "parallel: " << m_index << " got " << statuses[m_index];
assert(s == pruning_thread_status::SAT);
// }
// if (threads[m_index].joinable()) {
// threads[m_index].join();
// }
// DREAL_LOG_FATAL << "parallel: " << m_index << " got SAT";
// Why?
// - Not READY/RUNNING: It's a job already done.
// - Not UNSAT/EXCEPTION: already handled above.
// - Not KILLED: There must be one which kill the killed
// job, and this loop stops after handling
// the first one
}
}
// Assertion: All of them got SAT
// for (pruning_thread_status const & s : statuses) {
// assert(s == pruning_thread_status::SAT);
// }
// DREAL_LOG_FATAL << "All of them are SAT";
b = boxes[0];
for (unsigned i = 0; i < m_vec.size(); i++) {
contractor const & c = m_vec[i];
b.intersect(boxes[i]);
m_input.union_with(c.input());
m_output.union_with(c.output());
unordered_set<shared_ptr<constraint>> const & used_ctrs = c.used_constraints();
m_used_constraints.insert(used_ctrs.begin(), used_ctrs.end());
if (b.is_empty()) {
// DREAL_LOG_FATAL << "Found an empty while intersecting...";
for (unsigned i = 0; i < m_vec.size(); i++) {
// if (threads[i].joinable()) {
// DREAL_LOG_FATAL << "Try to join " << i << "...";
threads[i].join();
// DREAL_LOG_FATAL << "Try to join " << i << "... done";
// }
}
// DREAL_LOG_FATAL << "parallel: return UNSAT";
return;
}
}
// DREAL_LOG_FATAL << "Intersection is nonempty exiting...";
for (unsigned i = 0; i < m_vec.size(); i++) {
// if (threads[i].joinable()) {
threads[i].join();
// }
}
// DREAL_LOG_FATAL << "parallel: return SAT";
return;
}
void prime_box::handle_char_type(int st, int ft)
{
p->handle_char_type(st, ft);
pb->handle_char_type(st, ft);
}
box ncbt_icp::solve(box b, contractor const & ctc, SMTConfig & config) {
static unsigned prune_count = 0;
vector<box> box_stack;
vector<int> bisect_var_stack;
box_stack.push_back(b);
bisect_var_stack.push_back(-1); // Dummy var
do {
// Loop Invariant
assert(box_stack.size() == bisect_var_stack.size());
DREAL_LOG_INFO << "new_icp_loop()"
<< "\t" << "box stack Size = " << box_stack.size();
b = box_stack.back();
try {
b = ctc.prune(b, config);
if (config.nra_use_stat) { config.nra_stat.increase_prune(); }
} catch (contractor_exception & e) {
// Do nothing
}
prune_count++;
box_stack.pop_back();
bisect_var_stack.pop_back();
if (!b.is_empty()) {
// SAT
tuple<int, box, box> splits = b.bisect(config.nra_precision);
if (config.nra_use_stat) { config.nra_stat.increase_branch(); }
int const index = get<0>(splits);
if (index >= 0) {
box const & first = get<1>(splits);
box const & second = get<2>(splits);
if (second.is_bisectable()) {
box_stack.push_back(second);
box_stack.push_back(first);
} else {
box_stack.push_back(first);
box_stack.push_back(second);
}
bisect_var_stack.push_back(index);
bisect_var_stack.push_back(index);
} else {
break;
}
} else {
// UNSAT
while (box_stack.size() > 0) {
assert(box_stack.size() == bisect_var_stack.size());
int bisect_var = bisect_var_stack.back();
ibex::BitSet const & input = ctc.input();
DREAL_LOG_DEBUG << ctc;
if (!input[bisect_var]) {
box_stack.pop_back();
bisect_var_stack.pop_back();
} else {
break;
}
}
}
} while (box_stack.size() > 0);
DREAL_LOG_DEBUG << "prune count = " << prune_count;
b.adjust_bound(box_stack);
return b;
}
bool bounding_sphere::intersects(const box & box) const
{
return box.squared_distance_to(origin) <= std::pow(get_radius(), 2);
}
namespace brig { namespace gdal {
class provider : public brig::provider {
detail::dataset_allocator m_allocator;
public:
provider(const std::string& ds) : m_allocator(ds) {}
std::vector<identifier> get_tables() override;
std::vector<identifier> get_geometry_layers() override;
std::vector<pyramid_def> get_raster_layers() override;
table_def get_table_def(const identifier& tbl) override;
boost::box get_extent(const table_def& tbl) override;
std::shared_ptr<rowset> select(const table_def& tbl) override;
bool is_readonly() override { return true; }
table_def fit_to_create(const table_def&) override { throw std::runtime_error("GDAL error"); }
void create(const table_def&) override { throw std::runtime_error("GDAL error"); }
void drop(const table_def&) override { throw std::runtime_error("GDAL error"); }
pyramid_def fit_to_reg(const pyramid_def&) override { throw std::runtime_error("GDAL error"); }
void reg(const pyramid_def&) override { throw std::runtime_error("GDAL error"); }
void unreg(const pyramid_def&) override { throw std::runtime_error("GDAL error"); }
std::shared_ptr<inserter> get_inserter(const table_def&) override { throw std::runtime_error("GDAL error"); }
}; // provider
inline std::vector<identifier> provider::get_tables()
{
using namespace std;
using namespace detail;
dataset ds(m_allocator.allocate());
vector<identifier> res;
identifier id = { "", TableName, "" };
res.push_back(id);
return res;
}
inline std::vector<identifier> provider::get_geometry_layers()
{
using namespace std;
using namespace detail;
dataset ds(m_allocator.allocate());
vector<identifier> res;
identifier id = { "", TableName, ColumnNameWkb };
res.push_back(id);
return res;
}
inline std::vector<pyramid_def> provider::get_raster_layers()
{
using namespace std;
using namespace brig::boost;
using namespace detail;
dataset ds(m_allocator.allocate());
transform tr;
lib::check(lib::singleton().p_GDALGetGeoTransform(ds, tr.coef));
const box env(envelope(tr.pixel_to_proj(box(point(0, 0), point(1, 1)))));
vector<pyramid_def> res;
pyramid_def pyr;
tilemap_def lvl;
lvl.resolution_x = env.max_corner().get<0>() - env.min_corner().get<0>();
lvl.resolution_y = env.max_corner().get<1>() - env.min_corner().get<1>();
lvl.geometry.name = pyr.id.name = TableName;
lvl.geometry.qualifier = ColumnNameWkb;
lvl.raster.name = pyr.id.qualifier = ColumnNamePng;
lvl.raster.type = column_type::Blob;
pyr.levels.push_back(lvl);
res.push_back(pyr);
return res;
}
inline table_def provider::get_table_def(const identifier&)
{
using namespace std;
using namespace detail;
dataset ds(m_allocator.allocate());
table_def res;
res.id.name = TableName;
{
column_def col;
col.name = ColumnNameWkb;
col.type = column_type::Geometry;
auto del = [](void* ptr) { lib::singleton().p_OSRDestroySpatialReference(OGRSpatialReferenceH(ptr)); };
unique_ptr<void, decltype(del)> srs(lib::singleton().p_OSRNewSpatialReference(lib::singleton().p_GDALGetProjectionRef(ds)), del);
if (!srs.get()) throw runtime_error("GDAL error");
lib::singleton().p_OSRAutoIdentifyEPSG(srs.get());
const char* name(lib::singleton().p_OSRGetAuthorityName(srs.get(), 0));
const char* code(lib::singleton().p_OSRGetAuthorityCode(srs.get(), 0));
if (name && code && string(name).compare("EPSG") == 0)
col.epsg = atoi(code);
else
{
char* proj(0);
if (OGRERR_NONE == lib::singleton().p_OSRExportToProj4(srs.get(), &proj) && proj)
{
col.proj = proj;
lib::singleton().p_OGRFree(proj);
}
}
res.columns.push_back(col);
}
{
column_def col;
col.name = ColumnNamePng;
col.type = column_type::Blob;
res.columns.push_back(col);
}
return res;
}
inline boost::box provider::get_extent(const table_def&)
{
using namespace std;
using namespace brig::boost;
using namespace detail;
dataset ds(m_allocator.allocate());
transform tr;
lib::check(lib::singleton().p_GDALGetGeoTransform(ds, tr.coef));
return envelope(tr.pixel_to_proj(box(point(0, 0), point(lib::singleton().p_GDALGetRasterXSize(ds), lib::singleton().p_GDALGetRasterYSize(ds)))));
}
inline std::shared_ptr<rowset> provider::select(const table_def& tbl)
{
using namespace std;
if (typeid(null_t) != tbl[ColumnNamePng]->query_value.type()) throw runtime_error("GDAL error");
return make_shared<detail::rowset>(m_allocator, tbl);
} // provider::
} } // brig::gdal
box hull(box b1, box const & b2) {
b1.hull(b2);
return b1;
}
void over_box::output()
{
if (output_format == troff) {
if (reduce_size)
printf("\\s[\\n[" SMALL_SIZE_FORMAT "]u]", uid);
#ifdef USE_Z
printf("\\Z" DELIMITER_CHAR);
#endif
// move up to the numerator baseline
printf("\\v'-\\n[" SUP_RAISE_FORMAT "]u'", uid);
// move across so that it's centered
printf("\\h'\\n[" WIDTH_FORMAT "]u-\\n[" WIDTH_FORMAT "]u/2u'",
uid, num->uid);
// print the numerator
num->output();
#ifdef USE_Z
printf(DELIMITER_CHAR);
#else
// back again
printf("\\h'-\\n[" WIDTH_FORMAT "]u'", num->uid);
printf("\\h'-(\\n[" WIDTH_FORMAT "]u-\\n[" WIDTH_FORMAT "]u/2u)'",
uid, num->uid);
// down again
printf("\\v'\\n[" SUP_RAISE_FORMAT "]u'", uid);
#endif
#ifdef USE_Z
printf("\\Z" DELIMITER_CHAR);
#endif
// move down to the denominator baseline
printf("\\v'\\n[" SUB_LOWER_FORMAT "]u'", uid);
// move across so that it's centered
printf("\\h'\\n[" WIDTH_FORMAT "]u-\\n[" WIDTH_FORMAT "]u/2u'",
uid, den->uid);
// print the the denominator
den->output();
#ifdef USE_Z
printf(DELIMITER_CHAR);
#else
// back again
printf("\\h'-\\n[" WIDTH_FORMAT "]u'", den->uid);
printf("\\h'-(\\n[" WIDTH_FORMAT "]u-\\n[" WIDTH_FORMAT "]u/2u)'",
uid, den->uid);
// up again
printf("\\v'-\\n[" SUB_LOWER_FORMAT "]u'", uid);
#endif
if (reduce_size)
printf("\\s[\\n[" SIZE_FORMAT "]u]", uid);
// draw the line
printf("\\h'%dM'", null_delimiter_space);
printf("\\v'-%dM'", axis_height);
fputs(draw_flag ? "\\D'l" : "\\l'", stdout);
printf("\\n[" WIDTH_FORMAT "]u-%dM",
uid, 2*null_delimiter_space);
fputs(draw_flag ? " 0'" : "\\&\\(ru'", stdout);
printf("\\v'%dM'", axis_height);
printf("\\h'%dM'", null_delimiter_space);
}
else if (output_format == mathml) {
// FIXME: passing a displaystyle attribute doesn't validate.
printf("<mfrac>");
num->output();
den->output();
printf("</mfrac>");
}
}
contractor default_strategy::build_contractor(box const & box,
scoped_vec<shared_ptr<constraint>> const & ctrs,
bool const complete,
SMTConfig const & config) const {
bool const use_cache = true;
// 1. Categorize constraints
vector<shared_ptr<nonlinear_constraint>> nl_ctrs;
vector<shared_ptr<ode_constraint>> ode_ctrs_rev;
vector<shared_ptr<generic_forall_constraint>> generic_forall_ctrs;
for (shared_ptr<constraint> const ctr : ctrs.get_reverse()) {
switch (ctr->get_type()) {
case constraint_type::Nonlinear: {
auto nl_ctr = dynamic_pointer_cast<nonlinear_constraint>(ctr);
nl_ctrs.push_back(nl_ctr);
break;
}
case constraint_type::ODE: {
auto ode_ctr = dynamic_pointer_cast<ode_constraint>(ctr);
ode_ctrs_rev.push_back(ode_ctr);
break;
}
case constraint_type::GenericForall: {
auto gf_ctr = dynamic_pointer_cast<generic_forall_constraint>(ctr);
generic_forall_ctrs.push_back(gf_ctr);
break;
}
case constraint_type::ForallT: {
// Do nothing
break;
}
default:
DREAL_LOG_FATAL << "Unknown Constraint Type: " << ctr->get_type() << " " << *ctr << endl;
}
}
vector<shared_ptr<ode_constraint>> ode_ctrs(ode_ctrs_rev);
reverse(ode_ctrs.begin(), ode_ctrs.end());
vector<contractor> ctcs;
ctcs.reserve(ctrs.size());
// 2.0 Build Sample Contractor
if (config.nra_sample > 0 && complete) {
ctcs.push_back(mk_contractor_sample(box, config.nra_sample, ctrs.get_vec()));
}
// 2.1 Build nonlinear contractors
vector<contractor> nl_ctcs;
for (auto const & nl_ctr : nl_ctrs) {
if (!nl_ctr->is_neq()) {
nl_ctcs.push_back(mk_contractor_ibex_fwdbwd(nl_ctr, use_cache));
} else {
// Case: != (not equal), do nothing
}
}
contractor nl_ctc = mk_contractor_seq(nl_ctcs);
ctcs.insert(ctcs.end(), nl_ctcs.begin(), nl_ctcs.end());
// 2.2. Build Polytope Contractor
if (config.nra_polytope) {
ctcs.push_back(mk_contractor_ibex_polytope(config.nra_precision, box.get_vars(), nl_ctrs));
}
// 2.3. Int Contractor
ctcs.push_back(mk_contractor_int(box));
// 2.4. Build generic forall contractors
for (auto const & generic_forall_ctr : generic_forall_ctrs) {
ctcs.push_back(mk_contractor_generic_forall(box, generic_forall_ctr));
}
if (complete && ode_ctrs.size() > 0) {
// Add ODE Contractors only for complete check
// 2.5. Build GSL Contractors (using CAPD4)
vector<contractor> ode_gsl_ctcs;
if (config.nra_ODE_sampling) {
// 2.5.1 Build Eval contractors
vector<contractor> eval_ctcs;
for (auto const & nl_ctr : nl_ctrs) {
eval_ctcs.push_back(mk_contractor_eval(nl_ctr, false));
}
contractor eval_ctc = mk_contractor_seq(eval_ctcs);
if (config.nra_parallel) {
vector<contractor> nl_ctcs2;
for (auto const & nl_ctr : nl_ctrs) {
if (!nl_ctr->is_neq()) {
nl_ctcs2.push_back(mk_contractor_ibex_fwdbwd(nl_ctr, false));
} else {
// Case: != (not equal), do nothing
}
}
contractor nl_ctc2 = mk_contractor_seq(nl_ctcs2);
for (auto const & ode_ctr : ode_ctrs) {
// Add Forward ODE Pruning (Underapproximation, using GNU GSL)
ode_gsl_ctcs.push_back(mk_contractor_gsl(box, ode_ctr, eval_ctc, ode_direction::FWD, false, config.nra_ODE_fwd_timeout));
ode_gsl_ctcs.push_back(nl_ctc2);
}
} else {
for (auto const & ode_ctr : ode_ctrs) {
// Add Forward ODE Pruning (Underapproximation, using GNU GSL)
ode_gsl_ctcs.push_back(mk_contractor_gsl(box, ode_ctr, eval_ctc, ode_direction::FWD, use_cache, config.nra_ODE_fwd_timeout));
ode_gsl_ctcs.push_back(nl_ctc);
}
}
}
// 2.6. Build ODE Contractors (using CAPD4)
vector<contractor> ode_capd4_fwd_ctcs;
vector<contractor> ode_capd4_bwd_ctcs;
for (auto const & ode_ctr : ode_ctrs) {
// 2.6.1. Add Forward ODE Pruning (Overapproximation, using CAPD4)
if (config.nra_ODE_cache) {
ode_capd4_fwd_ctcs.emplace_back(
mk_contractor_cache(
mk_contractor_try(
mk_contractor_seq(mk_contractor_capd_full(box, ode_ctr, ode_direction::FWD, config.nra_ODE_taylor_order, config.nra_ODE_grid_size, use_cache, config.nra_ODE_fwd_timeout),
nl_ctc))));
} else {
ode_capd4_fwd_ctcs.emplace_back(
mk_contractor_try(
mk_contractor_seq(
mk_contractor_capd_full(box, ode_ctr, ode_direction::FWD, config.nra_ODE_taylor_order, config.nra_ODE_grid_size, use_cache, config.nra_ODE_fwd_timeout),
nl_ctc)));
}
}
if (!config.nra_ODE_forward_only) {
// 2.6.2. Add Backward ODE Pruning (Overapproximation, using CAPD4)
for (auto const & ode_ctr : ode_ctrs_rev) {
if (config.nra_ODE_cache) {
ode_capd4_bwd_ctcs.emplace_back(
mk_contractor_cache(
mk_contractor_try(
mk_contractor_seq(
mk_contractor_capd_full(box, ode_ctr, ode_direction::BWD, config.nra_ODE_taylor_order, config.nra_ODE_grid_size, use_cache, config.nra_ODE_bwd_timeout),
nl_ctc))));
} else {
ode_capd4_bwd_ctcs.emplace_back(
mk_contractor_try(
mk_contractor_seq(
mk_contractor_capd_full(box, ode_ctr, ode_direction::BWD, config.nra_ODE_taylor_order, config.nra_ODE_grid_size, use_cache, config.nra_ODE_bwd_timeout),
nl_ctc)));
}
}
}
if (config.nra_ODE_sampling) {
if (config.nra_parallel) {
ctcs.push_back(mk_contractor_parallel_any(
mk_contractor_try_or(mk_contractor_throw_if_empty(mk_contractor_seq(ode_gsl_ctcs)),
mk_contractor_empty()),
mk_contractor_seq(mk_contractor_seq(ode_capd4_fwd_ctcs),
mk_contractor_seq(ode_capd4_bwd_ctcs))));
} else {
ctcs.push_back(
mk_contractor_try_or(
// Try Underapproximation(GSL) if it fails try Overapproximation(CAPD4)
mk_contractor_throw_if_empty(mk_contractor_seq(ode_gsl_ctcs)),
mk_contractor_seq(mk_contractor_seq(ode_capd4_fwd_ctcs),
mk_contractor_seq(ode_capd4_bwd_ctcs))));
}
} else {
ctcs.insert(ctcs.end(), ode_capd4_fwd_ctcs.begin(), ode_capd4_fwd_ctcs.end());
ctcs.insert(ctcs.end(), ode_capd4_bwd_ctcs.begin(), ode_capd4_bwd_ctcs.end());
}
}
if (complete) {
// 2.7 Build Eval contractors
vector<contractor> eval_ctcs;
for (auto const & nl_ctr : nl_ctrs) {
eval_ctcs.push_back(mk_contractor_eval(nl_ctr, use_cache));
}
return mk_contractor_seq(mk_contractor_fixpoint(default_strategy::term_cond, ctcs),
mk_contractor_seq(eval_ctcs));
} else {
return mk_contractor_fixpoint(default_strategy::term_cond, ctcs);
}
}
void over_box::check_tabs(int level)
{
num->check_tabs(level + 1);
den->check_tabs(level + 1);
}
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;
}
/*! Outer Sphere of \p a scaled the factor \p f. */
template<class T, std::size_t N> inline pure sphere<T,N> outer_sphere(const box<T,N>& a, T f = 1) { return sphere<T,N>(a.cen(), f * norm(a.dim()) / 2); }