mirror of
https://github.com/Z3Prover/z3
synced 2025-04-06 17:44:08 +00:00
convert def into expression tree
prior data-structure could not represent ((1 + x) div 2) * 2 It is possible to have nested expressions with div. To deal with this, replace original def by an expression tree data-structure.
This commit is contained in:
Nikolaj Bjorner
parent
f977b48161
commit
f8f26788ad
|
|
@ -44,74 +44,109 @@ namespace opt {
|
|||
* satisfy the equality with value, and such that value satisfies
|
||||
* the row constraint ( = , <= , < , mod)
|
||||
*/
|
||||
model_based_opt::def::def(row const& r, unsigned x) {
|
||||
model_based_opt::def* model_based_opt::def::from_row(row const& r, unsigned x) {
|
||||
rational div(1), lc(denominator(r.m_coeff));
|
||||
|
||||
for (var const & v : r.m_vars) {
|
||||
if (v.m_id != x) {
|
||||
m_vars.push_back(v);
|
||||
}
|
||||
else {
|
||||
m_div = -v.m_coeff;
|
||||
lc = lcm(lc, denominator(v.m_coeff));
|
||||
if (v.m_id == x) {
|
||||
div = -v.m_coeff;
|
||||
break;
|
||||
}
|
||||
}
|
||||
m_coeff = r.m_coeff;
|
||||
div *= lc;
|
||||
bool sign = div < 0;
|
||||
auto coeff = lc * r.m_coeff;
|
||||
switch (r.m_type) {
|
||||
case opt::t_lt:
|
||||
m_coeff += m_div;
|
||||
coeff += div;
|
||||
break;
|
||||
case opt::t_le:
|
||||
// for: ax >= t, then x := (t + a - 1) div a
|
||||
if (m_div.is_pos()) {
|
||||
m_coeff += m_div;
|
||||
m_coeff -= rational::one();
|
||||
// for: ax <= t, then x := (t + a - 1) div a
|
||||
if (!sign) {
|
||||
coeff += div;
|
||||
coeff -= rational::one();
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
normalize();
|
||||
SASSERT(m_div.is_pos());
|
||||
}
|
||||
|
||||
model_based_opt::def model_based_opt::def::operator+(def const& other) const {
|
||||
def result;
|
||||
vector<var> const& vs1 = m_vars;
|
||||
vector<var> const& vs2 = other.m_vars;
|
||||
vector<var> & vs = result.m_vars;
|
||||
rational c1(1), c2(1);
|
||||
if (m_div != other.m_div) {
|
||||
c1 = other.m_div;
|
||||
c2 = m_div;
|
||||
if (div < 0) {
|
||||
sign = true;
|
||||
div.neg();
|
||||
lc.neg();
|
||||
coeff.neg();
|
||||
}
|
||||
unsigned i = 0, j = 0;
|
||||
while (i < vs1.size() || j < vs2.size()) {
|
||||
unsigned v1 = UINT_MAX, v2 = UINT_MAX;
|
||||
if (i < vs1.size()) v1 = vs1[i].m_id;
|
||||
if (j < vs2.size()) v2 = vs2[j].m_id;
|
||||
if (v1 == v2) {
|
||||
vs.push_back(vs1[i]);
|
||||
vs.back().m_coeff *= c1;
|
||||
vs.back().m_coeff += c2 * vs2[j].m_coeff;
|
||||
++i; ++j;
|
||||
if (vs.back().m_coeff.is_zero()) {
|
||||
vs.pop_back();
|
||||
def* result = alloc(const_def, coeff);
|
||||
for (var const& v : r.m_vars) {
|
||||
if (v.m_id != x)
|
||||
result = *result + *alloc(var_def, v * lc);
|
||||
}
|
||||
}
|
||||
else if (v1 < v2) {
|
||||
vs.push_back(vs1[i]);
|
||||
vs.back().m_coeff *= c1;
|
||||
++i;
|
||||
}
|
||||
else {
|
||||
vs.push_back(vs2[j]);
|
||||
vs.back().m_coeff *= c2;
|
||||
++j;
|
||||
}
|
||||
}
|
||||
result.m_div = c1*m_div;
|
||||
result.m_coeff = (m_coeff*c1) + (other.m_coeff*c2);
|
||||
result.normalize();
|
||||
if (div > 1)
|
||||
result = *result / div;
|
||||
return result;
|
||||
}
|
||||
void model_based_opt::def::dec_ref() {
|
||||
SASSERT(m_ref_count > 0);
|
||||
++m_ref_count;
|
||||
if (m_ref_count == 0)
|
||||
dealloc(this);
|
||||
}
|
||||
|
||||
model_based_opt::def* model_based_opt::def::operator+(def& other) {
|
||||
return alloc(add_def, this, &other);
|
||||
}
|
||||
model_based_opt::def* model_based_opt::def::operator*(def& other) {
|
||||
return alloc(mul_def, this, &other);
|
||||
}
|
||||
model_based_opt::def* model_based_opt::def::operator/(rational const& r) {
|
||||
if (r == 1)
|
||||
return this;
|
||||
return alloc(div_def, this, r);
|
||||
}
|
||||
model_based_opt::def* model_based_opt::def::operator*(rational const& n) {
|
||||
if (n == 1)
|
||||
return this;
|
||||
return alloc(mul_def, this, alloc(const_def, n));
|
||||
}
|
||||
model_based_opt::def* model_based_opt::def::operator+(rational const& n) {
|
||||
if (n == 0)
|
||||
return this;
|
||||
return alloc(add_def, this, alloc(const_def, n));
|
||||
}
|
||||
model_based_opt::add_def& model_based_opt::def::to_add() {
|
||||
return *static_cast<add_def*>(this);
|
||||
}
|
||||
model_based_opt::mul_def& model_based_opt::def::to_mul() {
|
||||
return *static_cast<mul_def*>(this);
|
||||
}
|
||||
model_based_opt::div_def& model_based_opt::def::to_div() {
|
||||
return *static_cast<div_def*>(this);
|
||||
}
|
||||
model_based_opt::var_def& model_based_opt::def::to_var() {
|
||||
return *static_cast<var_def*>(this);
|
||||
}
|
||||
model_based_opt::const_def& model_based_opt::def::to_const() {
|
||||
return *static_cast<const_def*>(this);
|
||||
}
|
||||
model_based_opt::add_def const& model_based_opt::def::to_add() const {
|
||||
return *static_cast<add_def const*>(this);
|
||||
}
|
||||
model_based_opt::mul_def const& model_based_opt::def::to_mul() const {
|
||||
return *static_cast<mul_def const*>(this);
|
||||
}
|
||||
model_based_opt::div_def const& model_based_opt::def::to_div() const {
|
||||
return *static_cast<div_def const*>(this);
|
||||
}
|
||||
model_based_opt::var_def const& model_based_opt::def::to_var() const {
|
||||
return *static_cast<var_def const*>(this);
|
||||
}
|
||||
model_based_opt::const_def const& model_based_opt::def::to_const() const {
|
||||
return *static_cast<const_def const*>(this);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
a1*x1 + a2*x2 + a3*x3 + coeff1 / c1
|
||||
|
|
@ -121,116 +156,38 @@ namespace opt {
|
|||
------------------------------------------------------------------------
|
||||
(c2*a1*x1 + a2*b1*x1 + a2*b4*x4 + c2*a3*x3 + c2*coeff1 + coeff2) / c1*c2
|
||||
*/
|
||||
void model_based_opt::def::substitute(unsigned v, def const& other) {
|
||||
vector<var> const& vs1 = m_vars;
|
||||
rational coeff(0);
|
||||
for (auto const& [id, c] : vs1) {
|
||||
if (id == v) {
|
||||
coeff = c;
|
||||
break;
|
||||
model_based_opt::def* model_based_opt::def::substitute(unsigned v, def& other) {
|
||||
if (is_add()) {
|
||||
auto x = to_add().x->substitute(v, other);
|
||||
auto y = to_add().y->substitute(v, other);
|
||||
if (x == to_add().x && y == to_add().y)
|
||||
return this;
|
||||
return *x + *y;
|
||||
}
|
||||
if (is_mul()) {
|
||||
auto x = to_mul().x->substitute(v, other);
|
||||
auto y = to_mul().y->substitute(v, other);
|
||||
if (x == to_mul().x && y == to_mul().y)
|
||||
return this;
|
||||
return *x * *y;
|
||||
}
|
||||
if (coeff == 0)
|
||||
return;
|
||||
|
||||
rational c1 = m_div;
|
||||
rational c2 = other.m_div;
|
||||
|
||||
vector<var> const& vs2 = other.m_vars;
|
||||
vector<var> vs;
|
||||
unsigned i = 0, j = 0;
|
||||
while (i < vs1.size() || j < vs2.size()) {
|
||||
unsigned v1 = UINT_MAX, v2 = UINT_MAX;
|
||||
if (i < vs1.size()) v1 = vs1[i].m_id;
|
||||
if (j < vs2.size()) v2 = vs2[j].m_id;
|
||||
if (v1 == v)
|
||||
++i;
|
||||
else if (v1 == v2) {
|
||||
vs.push_back(vs1[i]);
|
||||
vs.back().m_coeff *= c2;
|
||||
vs.back().m_coeff += coeff * vs2[j].m_coeff;
|
||||
++i; ++j;
|
||||
if (vs.back().m_coeff.is_zero())
|
||||
vs.pop_back();
|
||||
if (is_div()) {
|
||||
auto x = to_div().x->substitute(v, other);
|
||||
if (x == to_div().x)
|
||||
return this;
|
||||
return *x / to_div().m_div;
|
||||
}
|
||||
else if (v1 < v2) {
|
||||
vs.push_back(vs1[i]);
|
||||
vs.back().m_coeff *= c2;
|
||||
++i;
|
||||
}
|
||||
else {
|
||||
vs.push_back(vs2[j]);
|
||||
vs.back().m_coeff *= coeff;
|
||||
++j;
|
||||
}
|
||||
}
|
||||
m_div *= other.m_div;
|
||||
m_coeff *= c2;
|
||||
m_coeff += coeff*other.m_coeff;
|
||||
m_vars.reset();
|
||||
m_vars.append(vs);
|
||||
normalize();
|
||||
}
|
||||
|
||||
model_based_opt::def model_based_opt::def::operator/(rational const& r) const {
|
||||
def result(*this);
|
||||
result.m_div *= r;
|
||||
result.normalize();
|
||||
return result;
|
||||
}
|
||||
|
||||
model_based_opt::def model_based_opt::def::operator*(rational const& n) const {
|
||||
def result(*this);
|
||||
for (var& v : result.m_vars) {
|
||||
v.m_coeff *= n;
|
||||
}
|
||||
result.m_coeff *= n;
|
||||
result.normalize();
|
||||
return result;
|
||||
}
|
||||
|
||||
model_based_opt::def model_based_opt::def::operator+(rational const& n) const {
|
||||
def result(*this);
|
||||
result.m_coeff += n * result.m_div;
|
||||
result.normalize();
|
||||
return result;
|
||||
}
|
||||
|
||||
void model_based_opt::def::normalize() {
|
||||
if (!m_div.is_int()) {
|
||||
rational den = denominator(m_div);
|
||||
SASSERT(den > 1);
|
||||
for (var& v : m_vars)
|
||||
v.m_coeff *= den;
|
||||
m_coeff *= den;
|
||||
m_div *= den;
|
||||
|
||||
}
|
||||
if (m_div.is_neg()) {
|
||||
for (var& v : m_vars)
|
||||
v.m_coeff.neg();
|
||||
m_coeff.neg();
|
||||
m_div.neg();
|
||||
}
|
||||
if (m_div.is_one())
|
||||
return;
|
||||
rational g(m_div);
|
||||
if (!m_coeff.is_int())
|
||||
return;
|
||||
g = gcd(g, m_coeff);
|
||||
for (var const& v : m_vars) {
|
||||
if (!v.m_coeff.is_int())
|
||||
return;
|
||||
g = gcd(g, abs(v.m_coeff));
|
||||
if (g.is_one())
|
||||
break;
|
||||
}
|
||||
if (!g.is_one()) {
|
||||
for (var& v : m_vars)
|
||||
v.m_coeff /= g;
|
||||
m_coeff /= g;
|
||||
m_div /= g;
|
||||
if (is_var()) {
|
||||
if (to_var().v.m_id != v)
|
||||
return this;
|
||||
if (to_var().v.m_coeff == 1)
|
||||
return &other;
|
||||
return other * to_var().v.m_coeff;
|
||||
}
|
||||
if (is_const())
|
||||
return this;
|
||||
UNREACHABLE();
|
||||
return this;
|
||||
}
|
||||
|
||||
model_based_opt::model_based_opt() {
|
||||
|
|
@ -487,13 +444,18 @@ namespace opt {
|
|||
}
|
||||
|
||||
rational model_based_opt::eval(def const& d) const {
|
||||
vector<var> const& vars = d.m_vars;
|
||||
rational val = d.m_coeff;
|
||||
for (var const& v : vars) {
|
||||
val += v.m_coeff * eval(v.m_id);
|
||||
}
|
||||
val /= d.m_div;
|
||||
return val;
|
||||
if (d.is_add())
|
||||
return eval(*d.to_add().x) + eval(*d.to_add().y);
|
||||
else if (d.is_div())
|
||||
return eval(*d.to_div().x) / d.to_div().m_div;
|
||||
else if (d.is_mul())
|
||||
return eval(*d.to_mul().x) * eval(*d.to_mul().y);
|
||||
else if (d.is_var())
|
||||
return d.to_var().v.m_coeff * eval(d.to_var().v.m_id);
|
||||
else if (d.is_const())
|
||||
return d.to_const().c;
|
||||
UNREACHABLE();
|
||||
return rational::zero();
|
||||
}
|
||||
|
||||
rational model_based_opt::eval(row const& r) const {
|
||||
|
|
@ -597,7 +559,7 @@ namespace opt {
|
|||
rational a2 = get_coefficient(row_dst, x);
|
||||
if (is_int(x)) {
|
||||
TRACE("opt",
|
||||
tout << x << ": " << a1 << " " << a2 << ": ";
|
||||
tout << "v" << x << ": " << a1 << " " << a2 << ":\n";
|
||||
display(tout, m_rows[row_dst]);
|
||||
display(tout, m_rows[row_src]););
|
||||
if (a1.is_pos() != a2.is_pos() || m_rows[row_src].m_type == opt::t_eq) {
|
||||
|
|
@ -942,10 +904,17 @@ namespace opt {
|
|||
}
|
||||
|
||||
std::ostream& model_based_opt::display(std::ostream& out, def const& r) {
|
||||
display(out, r.m_vars, r.m_coeff);
|
||||
if (!r.m_div.is_one()) {
|
||||
out << " / " << r.m_div;
|
||||
}
|
||||
if (r.is_add())
|
||||
return out << "(" << * r.to_add().x << " + " << *r.to_add().y << ")";
|
||||
if (r.is_mul())
|
||||
return out << "(" << * r.to_mul().x << " * " << *r.to_mul().y << ")";
|
||||
if (r.is_var())
|
||||
return out << r.to_var().v.m_coeff << "* v" << r.to_var().v.m_id;
|
||||
if (r.is_div())
|
||||
return out << "(" << * r.to_div().x << " / " << r.to_div().m_div << ")";
|
||||
if (r.is_const())
|
||||
return out << r.to_const().c;
|
||||
UNREACHABLE();
|
||||
return out;
|
||||
}
|
||||
|
||||
|
|
@ -1101,7 +1070,7 @@ namespace opt {
|
|||
// t0 <= s for each s (M inequalities).
|
||||
// If N >= M the construction is symmetric.
|
||||
//
|
||||
model_based_opt::def model_based_opt::project(unsigned x, bool compute_def) {
|
||||
model_based_opt::def_ref model_based_opt::project(unsigned x, bool compute_def) {
|
||||
unsigned_vector& lub_rows = m_lub;
|
||||
unsigned_vector& glb_rows = m_glb;
|
||||
unsigned_vector& divide_rows = m_divides;
|
||||
|
|
@ -1175,7 +1144,7 @@ namespace opt {
|
|||
if (eq_row != UINT_MAX)
|
||||
return solve_for(eq_row, x, compute_def);
|
||||
|
||||
def result;
|
||||
def_ref result(nullptr);
|
||||
unsigned lub_size = lub_rows.size();
|
||||
unsigned glb_size = glb_rows.size();
|
||||
unsigned row_index = (lub_size <= glb_size) ? lub_index : glb_index;
|
||||
|
|
@ -1188,8 +1157,8 @@ namespace opt {
|
|||
else if (glb_index != UINT_MAX)
|
||||
result = solve_for(glb_index, x, true);
|
||||
else
|
||||
result = def() + m_var2value[x];
|
||||
SASSERT(eval(result) == eval(x));
|
||||
result = alloc(const_def, m_var2value[x]);
|
||||
SASSERT(eval(*result) == eval(x));
|
||||
}
|
||||
else {
|
||||
for (unsigned row_id : lub_rows) retire_row(row_id);
|
||||
|
|
@ -1202,9 +1171,10 @@ namespace opt {
|
|||
SASSERT(glb_index != UINT_MAX);
|
||||
if (compute_def) {
|
||||
if (lub_size <= glb_size)
|
||||
result = def(m_rows[lub_index], x);
|
||||
result = def::from_row(m_rows[lub_index], x);
|
||||
else
|
||||
result = def(m_rows[glb_index], x);
|
||||
result = def::from_row(m_rows[glb_index], x);
|
||||
TRACE("opt1", display(tout << "resolution result:", *result) << "\n");
|
||||
}
|
||||
|
||||
// The number of matching lower and upper bounds is small.
|
||||
|
|
@ -1297,8 +1267,8 @@ namespace opt {
|
|||
// where k is between 0 and g
|
||||
// when gcd(a, K) = 1, then there are only two cases.
|
||||
//
|
||||
model_based_opt::def model_based_opt::solve_mod_div(unsigned x, unsigned_vector const& _mod_rows, unsigned_vector const& _div_rows, bool compute_def) {
|
||||
def result;
|
||||
model_based_opt::def_ref model_based_opt::solve_mod_div(unsigned x, unsigned_vector const& _mod_rows, unsigned_vector const& _div_rows, bool compute_def) {
|
||||
def_ref result(nullptr);
|
||||
unsigned_vector div_rows(_div_rows), mod_rows(_mod_rows);
|
||||
SASSERT(!div_rows.empty() || !mod_rows.empty());
|
||||
TRACE("opt", display(tout << "solve_div v" << x << "\n"));
|
||||
|
|
@ -1341,7 +1311,6 @@ namespace opt {
|
|||
}
|
||||
mod_rows.shrink(j);
|
||||
|
||||
|
||||
// replace x by K*y + z in other rows.
|
||||
for (unsigned ri : m_var2row_ids[x]) {
|
||||
if (visited.contains(ri))
|
||||
|
|
@ -1355,7 +1324,6 @@ namespace opt {
|
|||
add_lower_bound(z, rational::zero());
|
||||
add_upper_bound(z, K - 1);
|
||||
|
||||
|
||||
// solve for x_value = K*y_value + z_value, 0 <= z_value < K.
|
||||
|
||||
unsigned_vector vs;
|
||||
|
|
@ -1510,25 +1478,25 @@ namespace opt {
|
|||
|
||||
|
||||
for (unsigned v : vs) {
|
||||
def v_def = project(v, compute_def);
|
||||
def_ref v_def = project(v, compute_def);
|
||||
if (compute_def)
|
||||
eliminate(v, v_def);
|
||||
eliminate(v, *v_def);
|
||||
}
|
||||
|
||||
// project internal variables.
|
||||
def z_def = project(z, compute_def);
|
||||
def y_def = project(y, compute_def); // may depend on z
|
||||
def_ref z_def = project(z, compute_def);
|
||||
def_ref y_def = project(y, compute_def); // may depend on z
|
||||
|
||||
if (compute_def) {
|
||||
z_def.substitute(y, y_def);
|
||||
eliminate(y, y_def);
|
||||
eliminate(z, z_def);
|
||||
z_def = z_def->substitute(y, *y_def);
|
||||
eliminate(y, *y_def);
|
||||
eliminate(z, *z_def);
|
||||
|
||||
result = (y_def * K) + z_def;
|
||||
m_var2value[x] = eval(result);
|
||||
TRACE("opt", tout << y << " := " << y_def << "\n";
|
||||
tout << z << " := " << z_def << "\n";
|
||||
tout << x << " := " << result << "\n");
|
||||
result = *(*y_def * K) + *z_def;
|
||||
m_var2value[x] = eval(*result);
|
||||
TRACE("opt", tout << y << " := " << *y_def << "\n";
|
||||
tout << z << " := " << *z_def << "\n";
|
||||
tout << x << " := " << *result << "\n");
|
||||
}
|
||||
TRACE("opt", display(tout << "solve_div done v" << x << "\n"));
|
||||
return result;
|
||||
|
|
@ -1549,7 +1517,7 @@ namespace opt {
|
|||
// x := D*x' + u
|
||||
//
|
||||
|
||||
model_based_opt::def model_based_opt::solve_divides(unsigned x, unsigned_vector const& divide_rows, bool compute_def) {
|
||||
model_based_opt::def_ref model_based_opt::solve_divides(unsigned x, unsigned_vector const& divide_rows, bool compute_def) {
|
||||
SASSERT(!divide_rows.empty());
|
||||
rational D(1);
|
||||
for (unsigned idx : divide_rows) {
|
||||
|
|
@ -1591,13 +1559,13 @@ namespace opt {
|
|||
visited.insert(row_id);
|
||||
normalize(row_id);
|
||||
}
|
||||
TRACE("opt1", display(tout << "tableau after replace x by y := v" << y << "\n"););
|
||||
def result = project(y, compute_def);
|
||||
TRACE("opt1", display(tout << "tableau after replace v" << x << " := " << D << " * v" << y << "\n"););
|
||||
def_ref result = project(y, compute_def);
|
||||
if (compute_def) {
|
||||
result = (result * D) + u;
|
||||
m_var2value[x] = eval(result);
|
||||
result = *(*result * D) + u;
|
||||
m_var2value[x] = eval(*result);
|
||||
}
|
||||
TRACE("opt1", display(tout << "tableau after project y" << y << "\n"););
|
||||
TRACE("opt1", display(tout << "tableau after project v" << y << "\n"););
|
||||
|
||||
return result;
|
||||
}
|
||||
|
|
@ -1662,7 +1630,7 @@ namespace opt {
|
|||
// 3x + t = 0 & 7 | (c*x + s) & ax <= u
|
||||
// 3 | -t & 21 | (-ct + 3s) & a-t <= 3u
|
||||
|
||||
model_based_opt::def model_based_opt::solve_for(unsigned row_id1, unsigned x, bool compute_def) {
|
||||
model_based_opt::def_ref model_based_opt::solve_for(unsigned row_id1, unsigned x, bool compute_def) {
|
||||
TRACE("opt", tout << "v" << x << " := " << eval(x) << "\n" << m_rows[row_id1] << "\n";
|
||||
display(tout));
|
||||
rational a = get_coefficient(row_id1, x), b;
|
||||
|
|
@ -1718,10 +1686,10 @@ namespace opt {
|
|||
break;
|
||||
}
|
||||
}
|
||||
def result;
|
||||
def_ref result(nullptr);
|
||||
if (compute_def) {
|
||||
result = def(m_rows[row_id1], x);
|
||||
m_var2value[x] = eval(result);
|
||||
result = def::from_row(m_rows[row_id1], x);
|
||||
m_var2value[x] = eval(*result);
|
||||
TRACE("opt1", tout << "updated eval " << x << " := " << eval(x) << "\n";);
|
||||
}
|
||||
retire_row(row_id1);
|
||||
|
|
@ -1729,16 +1697,18 @@ namespace opt {
|
|||
return result;
|
||||
}
|
||||
|
||||
void model_based_opt::eliminate(unsigned v, def const& new_def) {
|
||||
void model_based_opt::eliminate(unsigned v, def& new_def) {
|
||||
for (auto & d : m_result)
|
||||
d.substitute(v, new_def);
|
||||
if (d)
|
||||
d = d->substitute(v, new_def);
|
||||
}
|
||||
|
||||
vector<model_based_opt::def> model_based_opt::project(unsigned num_vars, unsigned const* vars, bool compute_def) {
|
||||
vector<model_based_opt::def_ref> model_based_opt::project(unsigned num_vars, unsigned const* vars, bool compute_def) {
|
||||
m_result.reset();
|
||||
for (unsigned i = 0; i < num_vars; ++i) {
|
||||
m_result.push_back(project(vars[i], compute_def));
|
||||
eliminate(vars[i], m_result.back());
|
||||
if (compute_def)
|
||||
eliminate(vars[i], *(m_result.back()));
|
||||
TRACE("opt", display(tout << "After projecting: v" << vars[i] << "\n"););
|
||||
}
|
||||
return m_result;
|
||||
|
|
|
|||
|
|
@ -23,6 +23,7 @@ Revision History:
|
|||
#include "util/util.h"
|
||||
#include "util/rational.h"
|
||||
#include "util/inf_eps_rational.h"
|
||||
#include <variant>
|
||||
|
||||
namespace opt {
|
||||
|
||||
|
|
@ -58,6 +59,7 @@ namespace opt {
|
|||
bool operator!=(var const& other) const {
|
||||
return !(*this == other);
|
||||
}
|
||||
var operator*(rational const& c) const { return var(m_id, m_coeff * c); }
|
||||
};
|
||||
struct row {
|
||||
vector<var> m_vars; // variables with coefficients
|
||||
|
|
@ -75,19 +77,93 @@ namespace opt {
|
|||
};
|
||||
|
||||
// A definition is a linear term of the form (vars + coeff) / div
|
||||
struct add_def;
|
||||
struct mul_def;
|
||||
struct div_def;
|
||||
struct const_def;
|
||||
struct var_def;
|
||||
struct const_def;
|
||||
enum def_t { add_t, mul_t, div_t, const_t, var_t};
|
||||
struct def {
|
||||
def() = default;
|
||||
def(row const& r, unsigned x);
|
||||
vector<var> m_vars;
|
||||
rational m_coeff;
|
||||
static def* from_row(row const& r, unsigned x);
|
||||
def_t m_type;
|
||||
unsigned m_ref_count = 0;
|
||||
bool is_add() const { return m_type == add_t; }
|
||||
bool is_mul() const { return m_type == mul_t; }
|
||||
bool is_div() const { return m_type == div_t; }
|
||||
bool is_const() const { return m_type == const_t; }
|
||||
bool is_var() const { return m_type == var_t; }
|
||||
void inc_ref() { ++m_ref_count; }
|
||||
void dec_ref();
|
||||
add_def& to_add();
|
||||
mul_def& to_mul();
|
||||
div_def& to_div();
|
||||
const_def& to_const();
|
||||
var_def& to_var();
|
||||
add_def const& to_add() const;
|
||||
mul_def const& to_mul() const;
|
||||
div_def const& to_div() const;
|
||||
const_def const& to_const() const;
|
||||
var_def const& to_var() const;
|
||||
def* operator+(def& other);
|
||||
def* operator*(def& other);
|
||||
def* operator/(unsigned n) { return *this / rational(n); }
|
||||
def* operator/(rational const& n);
|
||||
def* operator*(rational const& n);
|
||||
def* operator+(rational const& n);
|
||||
def* substitute(unsigned v, def& other);
|
||||
};
|
||||
class def_ref {
|
||||
def* m_def = nullptr;
|
||||
public:
|
||||
def_ref(def* d) {
|
||||
if (d) d->inc_ref();
|
||||
m_def = d;
|
||||
}
|
||||
def_ref& operator=(def* d) {
|
||||
if (d) d->inc_ref();
|
||||
if (m_def) m_def->dec_ref();
|
||||
m_def = d;
|
||||
return *this;
|
||||
}
|
||||
|
||||
def_ref& operator=(def_ref const& d) {
|
||||
if (&d == this)
|
||||
return *this;
|
||||
if (d.m_def) d.m_def->inc_ref();
|
||||
if (m_def) m_def->dec_ref();
|
||||
m_def = d.m_def;
|
||||
return *this;
|
||||
}
|
||||
|
||||
def& operator*() { return *m_def; }
|
||||
def* operator->() { return m_def; }
|
||||
def const& operator*() const { return *m_def; }
|
||||
operator bool() const { return !!m_def; }
|
||||
|
||||
~def_ref() { if (m_def) m_def->dec_ref(); };
|
||||
};
|
||||
struct add_def : public def {
|
||||
def* x, *y;
|
||||
add_def(def* x, def* y) : x(x), y(y) { m_type = add_t; x->inc_ref(); y->inc_ref(); }
|
||||
};
|
||||
struct mul_def : public def {
|
||||
def* x, *y;
|
||||
mul_def(def* x, def* y) : x(x), y(y) { m_type = mul_t; x->inc_ref(); y->inc_ref(); }
|
||||
};
|
||||
struct div_def : public def {
|
||||
def* x;
|
||||
rational m_div{ 1 };
|
||||
def operator+(def const& other) const;
|
||||
def operator/(unsigned n) const { return *this / rational(n); }
|
||||
def operator/(rational const& n) const;
|
||||
def operator*(rational const& n) const;
|
||||
def operator+(rational const& n) const;
|
||||
void substitute(unsigned v, def const& other);
|
||||
void normalize();
|
||||
div_def(def* x, rational const& d) : x(x), m_div(d) { m_type = div_t; x->inc_ref(); }
|
||||
};
|
||||
struct var_def : public def {
|
||||
var v;
|
||||
var_def(var const& v) : v(v) { m_type = var_t; }
|
||||
};
|
||||
struct const_def : public def {
|
||||
rational c;
|
||||
const_def(rational const& c) : c(c) { m_type = const_t; }
|
||||
};
|
||||
|
||||
private:
|
||||
|
|
@ -101,9 +177,9 @@ namespace opt {
|
|||
unsigned_vector m_lub, m_glb, m_divides, m_mod, m_div;
|
||||
unsigned_vector m_above, m_below;
|
||||
unsigned_vector m_retired_rows;
|
||||
vector<model_based_opt::def> m_result;
|
||||
vector<model_based_opt::def_ref> m_result;
|
||||
|
||||
void eliminate(unsigned v, def const& d);
|
||||
void eliminate(unsigned v, def& d);
|
||||
|
||||
bool invariant();
|
||||
bool invariant(unsigned index, row const& r);
|
||||
|
|
@ -164,13 +240,13 @@ namespace opt {
|
|||
|
||||
void update_value(unsigned x, rational const& val);
|
||||
|
||||
def project(unsigned var, bool compute_def);
|
||||
def_ref project(unsigned var, bool compute_def);
|
||||
|
||||
def solve_for(unsigned row_id, unsigned x, bool compute_def);
|
||||
def_ref solve_for(unsigned row_id, unsigned x, bool compute_def);
|
||||
|
||||
def solve_divides(unsigned x, unsigned_vector const& divide_rows, bool compute_def);
|
||||
def_ref solve_divides(unsigned x, unsigned_vector const& divide_rows, bool compute_def);
|
||||
|
||||
def solve_mod_div(unsigned x, unsigned_vector const& mod_rows, unsigned_vector const& divide_rows, bool compute_def);
|
||||
def_ref solve_mod_div(unsigned x, unsigned_vector const& mod_rows, unsigned_vector const& divide_rows, bool compute_def);
|
||||
|
||||
bool is_int(unsigned x) const { return m_var2is_int[x]; }
|
||||
|
||||
|
|
@ -219,7 +295,7 @@ namespace opt {
|
|||
//
|
||||
// Project set of variables from inequalities.
|
||||
//
|
||||
vector<def> project(unsigned num_vars, unsigned const* vars, bool compute_def);
|
||||
vector<def_ref> project(unsigned num_vars, unsigned const* vars, bool compute_def);
|
||||
|
||||
//
|
||||
// Extract current rows (after projection).
|
||||
|
|
|
|||
|
|
@ -258,7 +258,7 @@ namespace mbp {
|
|||
rational c0 = add_def(t1, mul1, coeffs);
|
||||
tids.insert(t, mbo.add_div(coeffs, c0, mul1));
|
||||
}
|
||||
else if (a.is_mod(t, t1, t2) && is_numeral(t2, mul1) && !mul1.is_zero()) {
|
||||
else if (a.is_mod(t, t1, t2) && is_numeral(t2, mul1) && mul1 > 0) {
|
||||
rational r;
|
||||
val = eval(t);
|
||||
if (!a.is_numeral(val, r)) {
|
||||
|
|
@ -417,7 +417,7 @@ namespace mbp {
|
|||
TRACE("qe", tout << "remaining vars: " << vars << "\n";
|
||||
for (unsigned v : real_vars) tout << "v" << v << " " << mk_pp(index2expr[v], m) << "\n";
|
||||
mbo.display(tout););
|
||||
vector<opt::model_based_opt::def> defs = mbo.project(real_vars.size(), real_vars.data(), compute_def);
|
||||
vector<opt::model_based_opt::def_ref> defs = mbo.project(real_vars.size(), real_vars.data(), compute_def);
|
||||
|
||||
|
||||
vector<row> rows;
|
||||
|
|
@ -431,7 +431,7 @@ namespace mbp {
|
|||
}
|
||||
rows2fmls(def_vars, rows, index2expr, fmls);
|
||||
TRACE("qe", mbo.display(tout << "mbo result\n");
|
||||
for (auto const& d : defs) tout << "def: " << d << "\n";
|
||||
for (auto const& d : defs) if (d) tout << "def: " << *d << "\n";
|
||||
tout << fmls << "\n";);
|
||||
|
||||
if (compute_def)
|
||||
|
|
@ -448,29 +448,45 @@ namespace mbp {
|
|||
return true;
|
||||
}
|
||||
|
||||
void optdefs2mbpdef(u_map<row> const& def_vars, vector<opt::model_based_opt::def> const& defs, ptr_vector<expr> const& index2expr, unsigned_vector const& real_vars, vector<def>& result) {
|
||||
expr_ref from_def(u_map<row> const& def_vars, opt::model_based_opt::def const& d, bool is_int, ptr_vector<expr> const& index2expr) {
|
||||
if (d.is_add()) {
|
||||
return expr_ref(
|
||||
a.mk_add(from_def(def_vars, *d.to_add().x, is_int, index2expr),
|
||||
from_def(def_vars, *d.to_add().y, is_int, index2expr)), m);
|
||||
|
||||
}
|
||||
if (d.is_mul()) {
|
||||
return expr_ref(
|
||||
a.mk_mul(from_def(def_vars, *d.to_mul().x, is_int, index2expr),
|
||||
from_def(def_vars, *d.to_mul().y, is_int, index2expr)), m);
|
||||
}
|
||||
if (d.is_const())
|
||||
return expr_ref(a.mk_numeral(d.to_const().c, is_int), m);
|
||||
if (d.is_var()) {
|
||||
auto t = id2expr(def_vars, index2expr, d.to_var().v.m_id);
|
||||
if (d.to_var().v.m_coeff != 1)
|
||||
t = a.mk_mul(a.mk_numeral(d.to_var().v.m_coeff, is_int), t);
|
||||
return expr_ref(t, m);
|
||||
}
|
||||
if (d.is_div()) {
|
||||
auto t = from_def(def_vars, *d.to_div().x, is_int, index2expr);
|
||||
if (is_int)
|
||||
t = a.mk_idiv(t, a.mk_numeral(d.to_div().m_div, is_int));
|
||||
else
|
||||
t = a.mk_div(t, a.mk_numeral(d.to_div().m_div, is_int));
|
||||
return expr_ref(t, m);
|
||||
}
|
||||
UNREACHABLE();
|
||||
return expr_ref(nullptr, m);
|
||||
}
|
||||
|
||||
void optdefs2mbpdef(u_map<row> const& def_vars, vector<opt::model_based_opt::def_ref> const& defs, ptr_vector<expr> const& index2expr, unsigned_vector const& real_vars, vector<def>& result) {
|
||||
SASSERT(defs.size() == real_vars.size());
|
||||
for (unsigned i = 0; i < defs.size(); ++i) {
|
||||
auto const& d = defs[i];
|
||||
expr* x = index2expr[real_vars[i]];
|
||||
bool is_int = a.is_int(x);
|
||||
expr_ref_vector ts(m);
|
||||
expr_ref t(m);
|
||||
for (var const& v : d.m_vars) {
|
||||
t = id2expr(def_vars, index2expr, v.m_id);
|
||||
if (v.m_coeff != 1)
|
||||
t = a.mk_mul(a.mk_numeral(v.m_coeff, a.is_int(t)), t);
|
||||
ts.push_back(t);
|
||||
}
|
||||
if (!d.m_coeff.is_zero())
|
||||
ts.push_back(a.mk_numeral(d.m_coeff, is_int));
|
||||
if (ts.empty())
|
||||
ts.push_back(a.mk_numeral(rational(0), is_int));
|
||||
t = mk_add(ts);
|
||||
if (!d.m_div.is_one() && is_int)
|
||||
t = a.mk_idiv(t, a.mk_numeral(d.m_div, is_int));
|
||||
else if (!d.m_div.is_one() && !is_int)
|
||||
t = a.mk_div(t, a.mk_numeral(d.m_div, is_int));
|
||||
auto t = from_def(def_vars, *d, is_int, index2expr);
|
||||
result.push_back({ expr_ref(x, m), t });
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue