mirror of
https://github.com/Z3Prover/z3
synced 2025-04-23 00:55:31 +00:00
call it data instead of c_ptr for approaching C++11 std::vector convention.
This commit is contained in:
Nikolaj Bjorner
parent
524dcd35f9
commit
4a6083836a
456 changed files with 2802 additions and 2802 deletions
|
|
@ -343,7 +343,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.c_ptr(), compute_def);
|
||||
vector<opt::model_based_opt::def> defs = mbo.project(real_vars.size(), real_vars.data(), compute_def);
|
||||
|
||||
vector<row> rows;
|
||||
mbo.get_live_rows(rows);
|
||||
|
|
|
|||
|
|
@ -102,7 +102,7 @@ namespace {
|
|||
for (expr* e : v)
|
||||
sorts.push_back (e->get_sort());
|
||||
}
|
||||
m_decl = m.mk_func_decl (symbol (PARTIAL_EQ), sorts.size (), sorts.c_ptr (), m.mk_bool_sort ());
|
||||
m_decl = m.mk_func_decl (symbol (PARTIAL_EQ), sorts.size (), sorts.data (), m.mk_bool_sort ());
|
||||
}
|
||||
|
||||
expr_ref lhs () { return m_lhs; }
|
||||
|
|
@ -117,9 +117,9 @@ namespace {
|
|||
args.push_back (m_lhs);
|
||||
args.push_back (m_rhs);
|
||||
for (auto const& v : m_diff_indices) {
|
||||
args.append (v.size(), v.c_ptr());
|
||||
args.append (v.size(), v.data());
|
||||
}
|
||||
m_peq = m.mk_app (m_decl, args.size (), args.c_ptr ());
|
||||
m_peq = m.mk_app (m_decl, args.size (), args.data ());
|
||||
}
|
||||
return m_peq;
|
||||
}
|
||||
|
|
@ -135,7 +135,7 @@ namespace {
|
|||
for (expr_ref_vector const& diff : m_diff_indices) {
|
||||
ptr_vector<expr> store_args;
|
||||
store_args.push_back (rhs);
|
||||
store_args.append (diff.size(), diff.c_ptr());
|
||||
store_args.append (diff.size(), diff.data());
|
||||
app_ref val(m.mk_fresh_const ("diff", val_sort), m);
|
||||
store_args.push_back (val);
|
||||
aux_consts.push_back (val);
|
||||
|
|
@ -306,7 +306,7 @@ namespace mbp {
|
|||
if (!all_done) continue;
|
||||
todo.pop_back ();
|
||||
|
||||
expr_ref a_new (m.mk_app (a->get_decl (), args.size (), args.c_ptr ()), m);
|
||||
expr_ref a_new (m.mk_app (a->get_decl (), args.size (), args.data ()), m);
|
||||
|
||||
// if a_new is select on m_v, introduce new constant
|
||||
if (m_arr_u.is_select (a) &&
|
||||
|
|
@ -358,7 +358,7 @@ namespace mbp {
|
|||
// mk val term
|
||||
ptr_vector<expr> sel_args;
|
||||
sel_args.push_back (arr);
|
||||
sel_args.append(I[i].size(), I[i].c_ptr());
|
||||
sel_args.append(I[i].size(), I[i].data());
|
||||
expr_ref val_term (m_arr_u.mk_select (sel_args), m);
|
||||
// evaluate and assign to ith diff_val_const
|
||||
val = (*m_mev)(val_term);
|
||||
|
|
@ -452,7 +452,7 @@ namespace mbp {
|
|||
// arr1[idx] == x
|
||||
ptr_vector<expr> sel_args;
|
||||
sel_args.push_back (arr1);
|
||||
sel_args.append(idxs.size(), idxs.c_ptr());
|
||||
sel_args.append(idxs.size(), idxs.data());
|
||||
expr_ref arr1_idx (m_arr_u.mk_select (sel_args), m);
|
||||
expr_ref eq (m.mk_eq (arr1_idx, x), m);
|
||||
m_aux_lits_v.push_back (eq);
|
||||
|
|
@ -774,7 +774,7 @@ namespace mbp {
|
|||
todo.pop_back ();
|
||||
|
||||
if (dirty) {
|
||||
r = m.mk_app (a->get_decl (), args.size (), args.c_ptr ());
|
||||
r = m.mk_app (a->get_decl (), args.size (), args.data ());
|
||||
m_pinned.push_back (r);
|
||||
}
|
||||
else {
|
||||
|
|
@ -1073,7 +1073,7 @@ namespace mbp {
|
|||
for (unsigned i = start; i < m_idxs.size(); ++i) {
|
||||
xs.append(m_idxs[i].idx);
|
||||
}
|
||||
m_idx_lits.push_back(m.mk_distinct(xs.size(), xs.c_ptr()));
|
||||
m_idx_lits.push_back(m.mk_distinct(xs.size(), xs.data()));
|
||||
}
|
||||
else {
|
||||
datatype::util dt(m);
|
||||
|
|
@ -1085,7 +1085,7 @@ namespace mbp {
|
|||
name << "get" << (i++);
|
||||
acc.push_back(mk_accessor_decl(m, symbol(name.str()), type_ref(x->get_sort())));
|
||||
}
|
||||
constructor_decl* constrs[1] = { mk_constructor_decl(symbol("tuple"), symbol("is-tuple"), acc.size(), acc.c_ptr()) };
|
||||
constructor_decl* constrs[1] = { mk_constructor_decl(symbol("tuple"), symbol("is-tuple"), acc.size(), acc.data()) };
|
||||
datatype::def* dts = mk_datatype_decl(dt, symbol("tuple"), 0, nullptr, 1, constrs);
|
||||
VERIFY(dt.plugin().mk_datatypes(1, &dts, 0, nullptr, srts));
|
||||
del_datatype_decl(dts);
|
||||
|
|
@ -1093,9 +1093,9 @@ namespace mbp {
|
|||
ptr_vector<func_decl> const & decls = *dt.get_datatype_constructors(tuple);
|
||||
expr_ref_vector xs(m);
|
||||
for (unsigned i = start; i < m_idxs.size(); ++i) {
|
||||
xs.push_back(m.mk_app(decls[0], m_idxs[i].idx.size(), m_idxs[i].idx.c_ptr()));
|
||||
xs.push_back(m.mk_app(decls[0], m_idxs[i].idx.size(), m_idxs[i].idx.data()));
|
||||
}
|
||||
m_idx_lits.push_back(m.mk_distinct(xs.size(), xs.c_ptr()));
|
||||
m_idx_lits.push_back(m.mk_distinct(xs.size(), xs.data()));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1273,7 +1273,7 @@ namespace mbp {
|
|||
|
||||
args[0] = result;
|
||||
args.push_back(var);
|
||||
result = a.mk_store(args.size(), args.c_ptr());
|
||||
result = a.mk_store(args.size(), args.data());
|
||||
}
|
||||
expr_safe_replace sub(m);
|
||||
sub.insert(s, result);
|
||||
|
|
|
|||
|
|
@ -81,7 +81,7 @@ namespace mbp {
|
|||
model.register_decl(arg->get_decl(), m_val->get_arg(i));
|
||||
args.push_back(arg);
|
||||
}
|
||||
val = m.mk_app(f, args.size(), args.c_ptr());
|
||||
val = m.mk_app(f, args.size(), args.data());
|
||||
TRACE("qe", tout << mk_pp(m_var->x(), m) << " |-> " << val << "\n";);
|
||||
reduce(val, lits);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -424,7 +424,7 @@ namespace mbp {
|
|||
for (expr * arg : *a) {
|
||||
kids.push_back (mk_app(arg));
|
||||
}
|
||||
app* res = m.mk_app(a->get_decl(), a->get_num_args(), kids.c_ptr());
|
||||
app* res = m.mk_app(a->get_decl(), a->get_num_args(), kids.data());
|
||||
m_pinned.push_back(res);
|
||||
return res;
|
||||
}
|
||||
|
|
@ -610,7 +610,7 @@ namespace mbp {
|
|||
}
|
||||
TRACE("qe_verbose", tout << *ch << " -> " << mk_pp(e, m) << "\n";);
|
||||
}
|
||||
expr* pure = m.mk_app(a->get_decl(), kids.size(), kids.c_ptr());
|
||||
expr* pure = m.mk_app(a->get_decl(), kids.size(), kids.data());
|
||||
m_pinned.push_back(pure);
|
||||
add_term2app(t, pure);
|
||||
return pure;
|
||||
|
|
@ -712,7 +712,7 @@ namespace mbp {
|
|||
}
|
||||
}
|
||||
if (diff.size() > 1) {
|
||||
res.push_back(m.mk_distinct(diff.size(), diff.c_ptr()));
|
||||
res.push_back(m.mk_distinct(diff.size(), diff.data()));
|
||||
}
|
||||
else {
|
||||
TRACE("qe", tout << "skipping " << mk_pp(lit, m) << "\n";);
|
||||
|
|
@ -802,7 +802,7 @@ namespace mbp {
|
|||
args.push_back(r);
|
||||
}
|
||||
TRACE("qe", tout << "function: " << d->get_name() << "\n";);
|
||||
res.push_back(m.mk_distinct(args.size(), args.c_ptr()));
|
||||
res.push_back(m.mk_distinct(args.size(), args.data()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -915,7 +915,7 @@ namespace mbp {
|
|||
|
||||
// -- sort representatives, call mk_distinct on any range
|
||||
// -- of the same sort longer than 1
|
||||
std::sort(reps.c_ptr(), reps.c_ptr() + reps.size(), sort_lt_proc());
|
||||
std::sort(reps.data(), reps.data() + reps.size(), sort_lt_proc());
|
||||
unsigned i = 0;
|
||||
unsigned sz = reps.size();
|
||||
while (i < sz) {
|
||||
|
|
@ -928,7 +928,7 @@ namespace mbp {
|
|||
if (!m.is_true(d)) res.push_back(d);
|
||||
}
|
||||
else if (j - i > 2)
|
||||
res.push_back(m.mk_distinct(j - i, reps.c_ptr() + i));
|
||||
res.push_back(m.mk_distinct(j - i, reps.data() + i));
|
||||
i = j;
|
||||
}
|
||||
TRACE("qe", tout << "after distinct: " << res << "\n";);
|
||||
|
|
|
|||
|
|
@ -528,7 +528,7 @@ namespace nlarith {
|
|||
tout << " 0 [-oo] --> " << mk_pp(t1.get(), m()) << "\n";);
|
||||
}
|
||||
TRACE("nlarith", tout << "inf-branch\n";);
|
||||
bc.add_branch(mk_and(es.size(), es.c_ptr()), m().mk_true(), subst, mk_inf(bc), z(), z(), z());
|
||||
bc.add_branch(mk_and(es.size(), es.data()), m().mk_true(), subst, mk_inf(bc), z(), z(), z());
|
||||
}
|
||||
|
||||
void create_branch_l(unsigned j, unsigned i, polys const& polys, comps const& comps,
|
||||
|
|
@ -552,7 +552,7 @@ namespace nlarith {
|
|||
rp->set_substitution(&sub);
|
||||
if (a != z()) es.push_back(mk_eq(a));
|
||||
es.push_back(mk_ne(b));
|
||||
cond = mk_and(es.size(), es.c_ptr());
|
||||
cond = mk_and(es.size(), es.data());
|
||||
es.push_back(bc.preds(i));
|
||||
for (unsigned k = 0; k < polys.size(); ++k) {
|
||||
mk_subst(cmp, polys[k], comps[k], e0, t1);
|
||||
|
|
@ -560,7 +560,7 @@ namespace nlarith {
|
|||
es.push_back(m().mk_implies(bc.preds(k), t2));
|
||||
subst.push_back(t1);
|
||||
}
|
||||
bc.add_branch(mk_and(es.size(), es.c_ptr()), cond, subst, mk_def(cmp, abc_poly(*this, z(), b, c), e0), a, b, c);
|
||||
bc.add_branch(mk_and(es.size(), es.data()), cond, subst, mk_def(cmp, abc_poly(*this, z(), b, c), e0), a, b, c);
|
||||
}
|
||||
|
||||
if (i == j && a != z()) {
|
||||
|
|
@ -579,7 +579,7 @@ namespace nlarith {
|
|||
es.push_back(m().mk_implies(bc.preds(k), t1));
|
||||
subst.push_back(t1);
|
||||
}
|
||||
bc.add_branch(mk_and(es.size(), es.c_ptr()), cond, subst, mk_def(cmp, abc_poly(*this, a2, b, z()),e1), a, b, c);
|
||||
bc.add_branch(mk_and(es.size(), es.data()), cond, subst, mk_def(cmp, abc_poly(*this, a2, b, z()),e1), a, b, c);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -616,7 +616,7 @@ namespace nlarith {
|
|||
rp->set_substitution(&sub);
|
||||
if (a != z()) es.push_back(mk_eq(a));
|
||||
es.push_back(mk_ne(b));
|
||||
cond = mk_and(es.size(), es.c_ptr());
|
||||
cond = mk_and(es.size(), es.data());
|
||||
es.push_back(bc.preds(i));
|
||||
for (unsigned j = 0; j < polys.size(); ++j) {
|
||||
mk_subst(cmp, polys[j], comps[j], e0, t1);
|
||||
|
|
@ -624,7 +624,7 @@ namespace nlarith {
|
|||
es.push_back(m().mk_implies(bc.preds(j), t2));
|
||||
subst.push_back(t2);
|
||||
}
|
||||
branch = mk_and(es.size(), es.c_ptr());
|
||||
branch = mk_and(es.size(), es.data());
|
||||
bc.add_branch(branch, cond, subst, mk_def(cmp, abc_poly(*this, z(), b, c), e0), a, b, c);
|
||||
}
|
||||
|
||||
|
|
@ -635,14 +635,14 @@ namespace nlarith {
|
|||
subst.reset();
|
||||
es.push_back(mk_ne(a));
|
||||
es.push_back(mk_ge(d));
|
||||
cond = mk_and(es.size(), es.c_ptr());
|
||||
cond = mk_and(es.size(), es.data());
|
||||
es.push_back(bc.preds(i));
|
||||
for (unsigned j = 0; j < polys.size(); ++j) {
|
||||
mk_subst(cmp, polys[j], comps[j], e1, t1);
|
||||
es.push_back(m().mk_implies(bc.preds(j), t1));
|
||||
subst.push_back(t1);
|
||||
}
|
||||
branch = mk_and(es.size(), es.c_ptr());
|
||||
branch = mk_and(es.size(), es.data());
|
||||
bc.add_branch(branch, cond, subst, mk_def(cmp, abc_poly(*this, a, b, c), e1), a, b, c);
|
||||
TRACE("nlarith", tout << mk_pp(branch,m()) << "\n";);
|
||||
|
||||
|
|
@ -657,7 +657,7 @@ namespace nlarith {
|
|||
es.push_back(m().mk_implies(bc.preds(j), t1));
|
||||
subst.push_back(t1);
|
||||
}
|
||||
branch = mk_and(es.size(), es.c_ptr());
|
||||
branch = mk_and(es.size(), es.data());
|
||||
bc.add_branch(branch, cond, subst, mk_def(cmp, abc_poly(*this, a, b, c), e2), a, b, c);
|
||||
TRACE("nlarith", tout << mk_pp(branch,m()) << "\n";);
|
||||
}
|
||||
|
|
@ -953,7 +953,7 @@ namespace nlarith {
|
|||
}
|
||||
TRACE("nlarith_verbose", display(tout, r); display(tout <<" * ", other); display(tout << " = ", result); tout <<"\n";);
|
||||
r.reset();
|
||||
r.append(result.size(), result.c_ptr());
|
||||
r.append(result.size(), result.data());
|
||||
}
|
||||
|
||||
void mk_mul(poly& p, expr* e) {
|
||||
|
|
@ -1261,13 +1261,13 @@ namespace nlarith {
|
|||
tmp.push_back(mk_mul(xx.get(), p[i]));
|
||||
xx = mk_mul(x, xx.get());
|
||||
}
|
||||
result = mk_add(tmp.size(), tmp.c_ptr());
|
||||
result = mk_add(tmp.size(), tmp.data());
|
||||
}
|
||||
|
||||
app* mk_zero(poly const& p) {
|
||||
app_ref_vector tmp(m());
|
||||
mk_zero(p, tmp);
|
||||
return mk_and(tmp.size(), reinterpret_cast<expr*const*>(tmp.c_ptr()));
|
||||
return mk_and(tmp.size(), reinterpret_cast<expr*const*>(tmp.data()));
|
||||
}
|
||||
|
||||
void mk_zero(poly const& p, app_ref_vector& zeros) {
|
||||
|
|
@ -1495,7 +1495,7 @@ namespace nlarith {
|
|||
equivs.push_back(m().mk_implies(literals.literal(i), tmp));
|
||||
new_atoms.push_back(tmp);
|
||||
}
|
||||
fml = mk_and(equivs.size(), equivs.c_ptr());
|
||||
fml = mk_and(equivs.size(), equivs.data());
|
||||
}
|
||||
void mk_plus_inf_sign(util::literal_set const& literals, app_ref& fml, app_ref_vector& new_atoms) {
|
||||
plus_inf_subst sub(*this);
|
||||
|
|
@ -1520,7 +1520,7 @@ namespace nlarith {
|
|||
mk_same_sign (literals, false, conjs, new_atoms);
|
||||
mk_lt(literals.x(), literals.x_inf(), conjs, new_atoms);
|
||||
mk_lt(literals.x_sup(), literals.x(), conjs, new_atoms);
|
||||
fml = mk_and(conjs.size(), conjs.c_ptr());
|
||||
fml = mk_and(conjs.size(), conjs.data());
|
||||
}
|
||||
void mk_lt(app* x, app* y, expr_ref_vector& conjs, app_ref_vector& new_atoms) {
|
||||
app* atm = mk_lt(mk_sub(x,y));
|
||||
|
|
@ -1545,7 +1545,7 @@ namespace nlarith {
|
|||
new_atoms.push_back(fml);
|
||||
ors.push_back(fml);
|
||||
}
|
||||
conjs.push_back(mk_or(ors.size(), ors.c_ptr()));
|
||||
conjs.push_back(mk_or(ors.size(), ors.data()));
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -1831,7 +1831,7 @@ namespace nlarith {
|
|||
// p'(x) > 0 -> r(y+epsilon) > 0 & r(z-epsilon) > 0
|
||||
mk_bound_ext(p1_lt0, p1, p, lits.x_sup(), lits.x_inf(), conjs, new_atoms);
|
||||
mk_bound_ext(p1_gt0, p1_m, p, lits.x_sup(), lits.x_inf(), conjs, new_atoms);
|
||||
fml = mk_and(conjs.size(), conjs.c_ptr());
|
||||
fml = mk_and(conjs.size(), conjs.data());
|
||||
simple_branch* br = alloc(simple_branch, m(), fml);
|
||||
swap_atoms(br, lits.lits(), new_atoms);
|
||||
return br;
|
||||
|
|
|
|||
|
|
@ -209,13 +209,13 @@ namespace qe {
|
|||
}
|
||||
|
||||
void display_assumptions(std::ostream& out) {
|
||||
m_solver.display(out << "assumptions: ", m_asms.size(), m_asms.c_ptr());
|
||||
m_solver.display(out << "assumptions: ", m_asms.size(), m_asms.data());
|
||||
out << "\n";
|
||||
}
|
||||
|
||||
void display_preds(std::ostream& out) {
|
||||
for (unsigned i = 0; i < m_preds.size(); ++i) {
|
||||
m_solver.display(out << i << ": ", m_preds[i]->size(), m_preds[i]->c_ptr());
|
||||
m_solver.display(out << i << ": ", m_preds[i]->size(), m_preds[i]->data());
|
||||
out << "\n";
|
||||
}
|
||||
}
|
||||
|
|
@ -361,8 +361,8 @@ namespace qe {
|
|||
out << "(declare-const x" << kv.m_key << " Real)\n";
|
||||
}
|
||||
s.m_solver.display(out << "(assert (not (exists ((", v) << " Real)) \n";
|
||||
s.m_solver.display_smt2(out << "(and ", r1.size(), r1.c_ptr()) << "))))\n";
|
||||
s.m_solver.display_smt2(out << "(assert (and ", r2.size(), r2.c_ptr()); out << "))\n";
|
||||
s.m_solver.display_smt2(out << "(and ", r1.size(), r1.data()) << "))))\n";
|
||||
s.m_solver.display_smt2(out << "(assert (and ", r2.size(), r2.data()); out << "))\n";
|
||||
out << "(check-sat)\n(reset)\n";
|
||||
}
|
||||
|
||||
|
|
@ -380,13 +380,13 @@ namespace qe {
|
|||
result.push_back(lit);
|
||||
}
|
||||
}
|
||||
TRACE("qe", s.m_solver.display(tout, result.size(), result.c_ptr()); tout << "\n";);
|
||||
TRACE("qe", s.m_solver.display(tout, result.size(), result.data()); tout << "\n";);
|
||||
// project quantified real variables.
|
||||
// They are sorted by size, so we project the largest variables first to avoid
|
||||
// renaming variables.
|
||||
for (unsigned i = vars.size(); i-- > 0;) {
|
||||
new_result.reset();
|
||||
ex.project(vars[i], result.size(), result.c_ptr(), new_result);
|
||||
ex.project(vars[i], result.size(), result.data(), new_result);
|
||||
TRACE("qe", display_project(tout, vars[i], result, new_result););
|
||||
TRACE("qe", display_project(std::cout, vars[i], result, new_result););
|
||||
result.swap(new_result);
|
||||
|
|
@ -413,12 +413,12 @@ namespace qe {
|
|||
cl.push_back(~s.m_solver.mk_true());
|
||||
}
|
||||
SASSERT(!cl.empty());
|
||||
nlsat::literal_vector lits(cl.size(), cl.c_ptr());
|
||||
s.m_solver.mk_clause(lits.size(), lits.c_ptr());
|
||||
nlsat::literal_vector lits(cl.size(), cl.data());
|
||||
s.m_solver.mk_clause(lits.size(), lits.data());
|
||||
}
|
||||
|
||||
max_level get_level(clause const& cl) {
|
||||
return get_level(cl.size(), cl.c_ptr());
|
||||
return get_level(cl.size(), cl.data());
|
||||
}
|
||||
|
||||
max_level get_level(unsigned n, nlsat::literal const* ls) {
|
||||
|
|
@ -857,7 +857,7 @@ namespace qe {
|
|||
ptr_vector<expr> fmls;
|
||||
expr_ref fml(m);
|
||||
in->get_formulas(fmls);
|
||||
fml = mk_and(m, fmls.size(), fmls.c_ptr());
|
||||
fml = mk_and(m, fmls.size(), fmls.data());
|
||||
if (m_mode == elim_t) {
|
||||
fml = m.mk_not(fml);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -144,9 +144,9 @@ namespace qe {
|
|||
}
|
||||
}
|
||||
bool_rewriter rewriter(m);
|
||||
rewriter.mk_and(conjs_closed.size(), conjs_closed.c_ptr(), fml_closed);
|
||||
rewriter.mk_and(conjs_mixed.size(), conjs_mixed.c_ptr(), fml_mixed);
|
||||
rewriter.mk_and(conjs_open.size(), conjs_open.c_ptr(), fml_open);
|
||||
rewriter.mk_and(conjs_closed.size(), conjs_closed.data(), fml_closed);
|
||||
rewriter.mk_and(conjs_mixed.size(), conjs_mixed.data(), fml_mixed);
|
||||
rewriter.mk_and(conjs_open.size(), conjs_open.data(), fml_open);
|
||||
|
||||
TRACE("qe",
|
||||
tout << "closed\n" << mk_ismt2_pp(fml_closed, m) << "\n";
|
||||
|
|
@ -699,7 +699,7 @@ namespace qe {
|
|||
}
|
||||
}
|
||||
if (all_visit) {
|
||||
m_cache.insert(e, m.mk_app(e->get_decl(), m_args.size(), m_args.c_ptr()));
|
||||
m_cache.insert(e, m.mk_app(e->get_decl(), m_args.size(), m_args.data()));
|
||||
}
|
||||
}
|
||||
else if (m.is_not(e, f)) {
|
||||
|
|
@ -1105,7 +1105,7 @@ namespace qe {
|
|||
search_tree* st = alloc(search_tree, this, m, m.mk_true());
|
||||
m_children.push_back(st);
|
||||
st->init(fml);
|
||||
st->m_vars.append(m_vars.size(), m_vars.c_ptr());
|
||||
st->m_vars.append(m_vars.size(), m_vars.data());
|
||||
SASSERT(invariant());
|
||||
TRACE("qe", display_node(tout); st->display_node(tout););
|
||||
return st;
|
||||
|
|
@ -1119,7 +1119,7 @@ namespace qe {
|
|||
search_tree* st = alloc(search_tree, this, m, assignment);
|
||||
m_children.push_back(st);
|
||||
m_branch_index.insert(branch_id, index);
|
||||
st->m_vars.append(m_vars.size(), m_vars.c_ptr());
|
||||
st->m_vars.append(m_vars.size(), m_vars.data());
|
||||
SASSERT(invariant());
|
||||
TRACE("qe", display_node(tout); st->display_node(tout););
|
||||
return st;
|
||||
|
|
@ -1182,7 +1182,7 @@ namespace qe {
|
|||
if (fml) {
|
||||
// abstract free variables in children.
|
||||
ptr_vector<app> child_vars, new_vars;
|
||||
child_vars.append(child.m_vars.size(), child.m_vars.c_ptr());
|
||||
child_vars.append(child.m_vars.size(), child.m_vars.data());
|
||||
if (child.m_var) {
|
||||
child_vars.push_back(child.m_var);
|
||||
}
|
||||
|
|
@ -1196,7 +1196,7 @@ namespace qe {
|
|||
fmls.push_back(fml);
|
||||
}
|
||||
}
|
||||
bool_rewriter(m).mk_or(fmls.size(), fmls.c_ptr(), fml);
|
||||
bool_rewriter(m).mk_or(fmls.size(), fmls.data(), fml);
|
||||
|
||||
fml = mk_not(m, m.mk_iff(q, fml));
|
||||
ast_smt_pp pp(m);
|
||||
|
|
@ -1467,7 +1467,7 @@ namespace qe {
|
|||
if (!get_first) {
|
||||
expr_ref_vector result(m);
|
||||
m_root.get_leaves(result);
|
||||
m_bool_rewriter.mk_or(result.size(), result.c_ptr(), fml);
|
||||
m_bool_rewriter.mk_or(result.size(), result.data(), fml);
|
||||
}
|
||||
|
||||
if (defs) {
|
||||
|
|
@ -1634,12 +1634,12 @@ namespace qe {
|
|||
expr_ref tmp(r_args[0], m);
|
||||
get_max_relevant(is_relevant, tmp, subfml);
|
||||
i_args.push_back(tmp);
|
||||
fml = m.mk_app(a->get_decl(), i_args.size(), i_args.c_ptr());
|
||||
fml = m.mk_app(a->get_decl(), i_args.size(), i_args.data());
|
||||
}
|
||||
else {
|
||||
subfml = m.mk_app(a->get_decl(), r_args.size(), r_args.c_ptr());
|
||||
subfml = m.mk_app(a->get_decl(), r_args.size(), r_args.data());
|
||||
i_args.push_back(subfml);
|
||||
fml = m.mk_app(a->get_decl(), i_args.size(), i_args.c_ptr());
|
||||
fml = m.mk_app(a->get_decl(), i_args.size(), i_args.data());
|
||||
}
|
||||
}
|
||||
else {
|
||||
|
|
@ -1735,10 +1735,10 @@ namespace qe {
|
|||
cont.push_back(&contains(i));
|
||||
vars.push_back(m_current->free_var(i));
|
||||
}
|
||||
m_conjs.get_partition(fml, num_vars, vars.c_ptr(), fml_closed, fml_mixed, fml_open);
|
||||
m_conjs.get_partition(fml, num_vars, vars.data(), fml_closed, fml_mixed, fml_open);
|
||||
if (m.is_and(fml_open) &&
|
||||
m_conjs.partition_vars(
|
||||
num_vars, cont.c_ptr(),
|
||||
num_vars, cont.data(),
|
||||
to_app(fml_open)->get_num_args(), to_app(fml_open)->get_args(),
|
||||
m_partition)) {
|
||||
process_partition();
|
||||
|
|
@ -1940,7 +1940,7 @@ namespace qe {
|
|||
ptr_vector<app> vars;
|
||||
bool closed = true;
|
||||
while (extract_partition(vars)) {
|
||||
lbool r = m_qe.eliminate_exists(vars.size(), vars.c_ptr(), fml, m_free_vars, m_get_first, m_defs);
|
||||
lbool r = m_qe.eliminate_exists(vars.size(), vars.data(), fml, m_free_vars, m_get_first, m_defs);
|
||||
vars.reset();
|
||||
closed = closed && (r != l_undef);
|
||||
}
|
||||
|
|
@ -2078,7 +2078,7 @@ namespace qe {
|
|||
}
|
||||
if (!free_vars.empty()) {
|
||||
expr_ref tmp = expr_abstract(free_vars, fml);
|
||||
fml = m.mk_exists(free_vars.size(), sorts.c_ptr(), names.c_ptr(), tmp, 1);
|
||||
fml = m.mk_exists(free_vars.size(), sorts.data(), names.data(), tmp, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -2189,7 +2189,7 @@ namespace qe {
|
|||
checkpoint();
|
||||
app_ref_vector free_vars(m);
|
||||
eliminate_exists(num_vars, vars, fml, free_vars, false, nullptr);
|
||||
bind_variables(free_vars.size(), free_vars.c_ptr(), fml);
|
||||
bind_variables(free_vars.size(), free_vars.data(), fml);
|
||||
}
|
||||
|
||||
void eliminate_forall_bind(unsigned num_vars, app* const* vars, expr_ref& fml) {
|
||||
|
|
@ -2230,7 +2230,7 @@ namespace qe {
|
|||
elim(result);
|
||||
m_trail.reset();
|
||||
m_visited.reset();
|
||||
abstract_expr(bound.size(), bound.c_ptr(), result);
|
||||
abstract_expr(bound.size(), bound.data(), result);
|
||||
TRACE("qe", tout << "elim result\n" << mk_ismt2_pp(result, m) << "\n";);
|
||||
}
|
||||
|
||||
|
|
@ -2262,7 +2262,7 @@ namespace qe {
|
|||
bound.push_back(m.mk_fresh_const("bound", fv[i]));
|
||||
}
|
||||
var_subst subst(m);
|
||||
fml = subst(fml, bound.size(), bound.c_ptr());
|
||||
fml = subst(fml, bound.size(), bound.data());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -2279,7 +2279,7 @@ namespace qe {
|
|||
for (unsigned i = 0; i < nd; ++i) {
|
||||
vars.push_back(m.mk_fresh_const("x",q->get_decl_sort(i)));
|
||||
}
|
||||
expr* const* exprs = (expr* const*)(vars.c_ptr());
|
||||
expr* const* exprs = (expr* const*)(vars.data());
|
||||
var_subst subst(m);
|
||||
tmp = subst(new_body, vars.size(), exprs);
|
||||
inv_var_shifter shift(m);
|
||||
|
|
@ -2316,7 +2316,7 @@ namespace qe {
|
|||
}
|
||||
}
|
||||
if (all_visited) {
|
||||
r = m.mk_app(a->get_decl(), args.size(), args.c_ptr());
|
||||
r = m.mk_app(a->get_decl(), args.size(), args.data());
|
||||
todo.pop_back();
|
||||
m_trail.push_back(r);
|
||||
m_visited.insert(e, r);
|
||||
|
|
@ -2336,7 +2336,7 @@ namespace qe {
|
|||
elim(tmp);
|
||||
init_qe();
|
||||
m_qe->set_assumption(m_assumption);
|
||||
m_qe->eliminate(is_fa, vars.size(), vars.c_ptr(), tmp);
|
||||
m_qe->eliminate(is_fa, vars.size(), vars.data(), tmp);
|
||||
}
|
||||
m_trail.push_back(tmp);
|
||||
m_visited.insert(e, tmp);
|
||||
|
|
@ -2449,7 +2449,7 @@ namespace qe {
|
|||
names.push_back(vars[i]->get_decl()->get_name());
|
||||
}
|
||||
if (num_bound > 0) {
|
||||
tmp = m.mk_exists(num_bound, sorts.c_ptr(), names.c_ptr(), tmp, 1);
|
||||
tmp = m.mk_exists(num_bound, sorts.data(), names.data(), tmp, 1);
|
||||
}
|
||||
fml = tmp;
|
||||
}
|
||||
|
|
@ -2642,7 +2642,7 @@ namespace qe {
|
|||
names.push_back(v->get_decl()->get_name());
|
||||
}
|
||||
if (!vars.empty()) {
|
||||
result = m.mk_quantifier(old_q->get_kind(), vars.size(), sorts.c_ptr(), names.c_ptr(), result, 1);
|
||||
result = m.mk_quantifier(old_q->get_kind(), vars.size(), sorts.data(), names.data(), result, 1);
|
||||
}
|
||||
result_pr = nullptr;
|
||||
return true;
|
||||
|
|
|
|||
|
|
@ -200,7 +200,7 @@ namespace qe {
|
|||
rest = mk_zero(x);
|
||||
}
|
||||
else {
|
||||
rest = m_arith.mk_add(restl.size(), restl.c_ptr());
|
||||
rest = m_arith.mk_add(restl.size(), restl.data());
|
||||
}
|
||||
if (contains_x(rest)) {
|
||||
return false;
|
||||
|
|
@ -246,7 +246,7 @@ namespace qe {
|
|||
rest = mk_zero(p);
|
||||
}
|
||||
else {
|
||||
rest = m_arith.mk_add(restl.size(), restl.c_ptr());
|
||||
rest = m_arith.mk_add(restl.size(), restl.data());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -492,7 +492,7 @@ namespace qe {
|
|||
ptr_vector<expr> conjs;
|
||||
add_and(e1, conjs);
|
||||
add_and(e2, conjs);
|
||||
m_bool_rewriter.mk_and(conjs.size(), conjs.c_ptr(), result);
|
||||
m_bool_rewriter.mk_and(conjs.size(), conjs.data(), result);
|
||||
}
|
||||
|
||||
void mk_or(unsigned sz, expr*const* args, expr_ref& result) {
|
||||
|
|
@ -635,7 +635,7 @@ namespace qe {
|
|||
args.push_back(to_app(p)->get_arg(i));
|
||||
}
|
||||
std::sort(args.begin(), args.end(), mul_lt(*this));
|
||||
p = m_arith.mk_add(args.size(), args.c_ptr());
|
||||
p = m_arith.mk_add(args.size(), args.data());
|
||||
}
|
||||
|
||||
void pp_div(std::ostream& out, app* x, div_constraint const& div) {
|
||||
|
|
@ -846,7 +846,7 @@ namespace qe {
|
|||
ors.push_back(result);
|
||||
++index;
|
||||
}
|
||||
mk_or(ors.size(), ors.c_ptr(), result);
|
||||
mk_or(ors.size(), ors.data(), result);
|
||||
TRACE("qe",
|
||||
tout
|
||||
<< "[0 " << up << "] "
|
||||
|
|
@ -1007,7 +1007,7 @@ namespace qe {
|
|||
unsigned num_vars = m_ctx.get_num_vars();
|
||||
app_ref_vector const& vars = m_ctx.get_vars();
|
||||
|
||||
if (!is_linear(p, num_vars, vars.c_ptr(), values)) {
|
||||
if (!is_linear(p, num_vars, vars.data(), values)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -1112,7 +1112,7 @@ namespace qe {
|
|||
for (unsigned i = 0; i <= num_vars; ++i) {
|
||||
values.push_back(numeral(0));
|
||||
}
|
||||
numeral* vars_ptr = values.c_ptr() + 1;
|
||||
numeral* vars_ptr = values.data() + 1;
|
||||
ptr_vector<expr> todo;
|
||||
numeral k;
|
||||
expr* e1, *e2;
|
||||
|
|
@ -1215,35 +1215,35 @@ namespace qe {
|
|||
unsigned e_size(bool is_l) { return is_l?le_size():ge_size(); }
|
||||
unsigned size(bool is_strict, bool is_l) { return is_strict?t_size(is_l):e_size(is_l); }
|
||||
|
||||
expr* const* lt() { return m_lt_terms.c_ptr(); }
|
||||
expr* const* le() { return m_le_terms.c_ptr(); }
|
||||
expr* const* gt() { return m_gt_terms.c_ptr(); }
|
||||
expr* const* ge() { return m_ge_terms.c_ptr(); }
|
||||
expr* const* lt() { return m_lt_terms.data(); }
|
||||
expr* const* le() { return m_le_terms.data(); }
|
||||
expr* const* gt() { return m_gt_terms.data(); }
|
||||
expr* const* ge() { return m_ge_terms.data(); }
|
||||
expr* const* t(bool is_l) { return is_l?lt():gt(); }
|
||||
expr* const* e(bool is_l) { return is_l?le():ge(); }
|
||||
expr* const* exprs(bool is_strict, bool is_l) { return is_strict?t(is_l):e(is_l);}
|
||||
|
||||
rational const* lt_coeffs() { return m_lt_coeffs.c_ptr(); }
|
||||
rational const* le_coeffs() { return m_le_coeffs.c_ptr(); }
|
||||
rational const* gt_coeffs() { return m_gt_coeffs.c_ptr(); }
|
||||
rational const* ge_coeffs() { return m_ge_coeffs.c_ptr(); }
|
||||
rational const* lt_coeffs() { return m_lt_coeffs.data(); }
|
||||
rational const* le_coeffs() { return m_le_coeffs.data(); }
|
||||
rational const* gt_coeffs() { return m_gt_coeffs.data(); }
|
||||
rational const* ge_coeffs() { return m_ge_coeffs.data(); }
|
||||
rational const* t_coeffs(bool is_l) { return is_l?lt_coeffs():gt_coeffs(); }
|
||||
rational const* e_coeffs(bool is_l) { return is_l?le_coeffs():ge_coeffs(); }
|
||||
rational const* coeffs(bool is_strict, bool is_l) { return is_strict?t_coeffs(is_l):e_coeffs(is_l); }
|
||||
|
||||
app* const* lt_atoms() { return m_lt_atoms.c_ptr(); }
|
||||
app* const* le_atoms() { return m_le_atoms.c_ptr(); }
|
||||
app* const* gt_atoms() { return m_gt_atoms.c_ptr(); }
|
||||
app* const* ge_atoms() { return m_ge_atoms.c_ptr(); }
|
||||
app* const* lt_atoms() { return m_lt_atoms.data(); }
|
||||
app* const* le_atoms() { return m_le_atoms.data(); }
|
||||
app* const* gt_atoms() { return m_gt_atoms.data(); }
|
||||
app* const* ge_atoms() { return m_ge_atoms.data(); }
|
||||
app* const* t_atoms(bool is_l) { return is_l?lt_atoms():gt_atoms(); }
|
||||
app* const* e_atoms(bool is_l) { return is_l?le_atoms():ge_atoms(); }
|
||||
app* const* atoms(bool is_strict, bool is_l) { return is_strict?t_atoms(is_l):e_atoms(is_l); }
|
||||
|
||||
unsigned div_size() const { return m_div_terms.size(); }
|
||||
app* const* div_atoms() { return m_div_atoms.c_ptr(); }
|
||||
rational const* div_coeffs() { return m_div_coeffs.c_ptr(); }
|
||||
expr* const* div_terms() { return m_div_terms.c_ptr(); }
|
||||
rational const* divisors() { return m_div_divisors.c_ptr(); }
|
||||
app* const* div_atoms() { return m_div_atoms.data(); }
|
||||
rational const* div_coeffs() { return m_div_coeffs.data(); }
|
||||
expr* const* div_terms() { return m_div_terms.data(); }
|
||||
rational const* divisors() { return m_div_divisors.data(); }
|
||||
|
||||
bool div_z(rational & d, app_ref& z_bv, app_ref& z) {
|
||||
if (m_div_z.get()) {
|
||||
|
|
@ -1503,7 +1503,7 @@ public:
|
|||
m_result(r),
|
||||
m_coeff(coeff),
|
||||
m_term(term),
|
||||
m_vars(vars.size(), vars.c_ptr())
|
||||
m_vars(vars.size(), vars.data())
|
||||
{}
|
||||
|
||||
unsigned mk_hash() const {
|
||||
|
|
@ -1829,10 +1829,10 @@ public:
|
|||
terms.push_back(term);
|
||||
}
|
||||
if (is_lower) {
|
||||
def = m_util.mk_min(terms.size(), terms.c_ptr());
|
||||
def = m_util.mk_min(terms.size(), terms.data());
|
||||
}
|
||||
else {
|
||||
def = m_util.mk_max(terms.size(), terms.c_ptr());
|
||||
def = m_util.mk_max(terms.size(), terms.data());
|
||||
}
|
||||
|
||||
if (x_t.get_term()) {
|
||||
|
|
@ -2503,7 +2503,7 @@ public:
|
|||
brs = alloc(nlarith::branch_conditions, m);
|
||||
|
||||
TRACE("nlarith", tout << mk_pp(fml, m) << "\n";);
|
||||
if (!m_util.create_branches(x.x(), lits.size(), lits.c_ptr(), *brs)) {
|
||||
if (!m_util.create_branches(x.x(), lits.size(), lits.data(), *brs)) {
|
||||
TRACE("nlarith", tout << "no branches for " << mk_pp(x.x(), m) << "\n";);
|
||||
dealloc(brs);
|
||||
return false;
|
||||
|
|
|
|||
|
|
@ -93,7 +93,7 @@ namespace qe {
|
|||
expr_ref save(m);
|
||||
save = lhs = args[i].get();
|
||||
args[i] = arith.mk_numeral(rational(0), lhs->get_sort());
|
||||
rhs = arith.mk_uminus(arith.mk_add(args.size(), args.c_ptr()));
|
||||
rhs = arith.mk_uminus(arith.mk_add(args.size(), args.data()));
|
||||
if (arith.is_mul(lhs, e1, e2) &&
|
||||
arith.is_numeral(e1, r) &&
|
||||
r.is_minus_one()) {
|
||||
|
|
@ -173,7 +173,7 @@ namespace qe {
|
|||
}
|
||||
args2.push_back(rhs);
|
||||
|
||||
store_B_i_t = m.mk_app(m_fid, OP_STORE, args2.size(), args2.c_ptr());
|
||||
store_B_i_t = m.mk_app(m_fid, OP_STORE, args2.size(), args2.data());
|
||||
|
||||
TRACE("qe",
|
||||
tout << "fml: " << mk_pp(fml, m) << "\n";
|
||||
|
|
@ -236,13 +236,13 @@ namespace qe {
|
|||
args2.push_back(store_T);
|
||||
args2.append(args[i]);
|
||||
|
||||
select_t = m.mk_app(m_fid, OP_SELECT, args2.size()-1, args2.c_ptr());
|
||||
select_t = m.mk_app(m_fid, OP_SELECT, args2.size()-1, args2.data());
|
||||
fml = m.mk_and(fml, m.mk_eq(select_t, args2.back()));
|
||||
store_T = m.mk_app(m_fid, OP_STORE, args2.size(), args2.c_ptr());
|
||||
store_T = m.mk_app(m_fid, OP_STORE, args2.size(), args2.data());
|
||||
|
||||
args2[0] = store_t;
|
||||
args2.back() = w;
|
||||
store_t = m.mk_app(m_fid, OP_STORE, args2.size(), args2.c_ptr());
|
||||
store_t = m.mk_app(m_fid, OP_STORE, args2.size(), args2.data());
|
||||
|
||||
m_ctx.add_var(w);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -169,7 +169,7 @@ namespace qe {
|
|||
|
||||
unsigned num_neq_terms() const { return m_neqs.size(); }
|
||||
expr* neq_term(unsigned i) const { return m_neqs[i]; }
|
||||
expr* const* neq_terms() const { return m_neqs.c_ptr(); }
|
||||
expr* const* neq_terms() const { return m_neqs.data(); }
|
||||
|
||||
unsigned num_recognizers() { return m_recognizers.size(); }
|
||||
app* recognizer(unsigned i) { return m_recognizers[i].get(); }
|
||||
|
|
@ -388,7 +388,7 @@ namespace qe {
|
|||
expr* l_i = l->get_arg(i);
|
||||
conj.push_back(m.mk_eq(l_i, r_i));
|
||||
}
|
||||
expr* e = m.mk_and(conj.size(), conj.c_ptr());
|
||||
expr* e = m.mk_and(conj.size(), conj.data());
|
||||
m_map.insert(a, e, nullptr);
|
||||
TRACE("qe", tout << "replace: " << mk_pp(a, m) << " ==> \n" << mk_pp(e, m) << "\n";);
|
||||
return true;
|
||||
|
|
@ -541,7 +541,7 @@ namespace qe {
|
|||
vars.push_back(fresh_x.get());
|
||||
sub->second.push_back(fresh_x.get());
|
||||
}
|
||||
app_ref t(m.mk_app(c, vars.size(), vars.c_ptr()), m);
|
||||
app_ref t(m.mk_app(c, vars.size(), vars.data()), m);
|
||||
m_trail.push_back(x.x());
|
||||
m_trail.push_back(c);
|
||||
m_trail.push_back(t);
|
||||
|
|
@ -735,7 +735,7 @@ namespace qe {
|
|||
sort* s = x->get_sort();
|
||||
ptr_vector<sort> sorts;
|
||||
sorts.resize(eqs.num_neq_terms(), s);
|
||||
func_decl* diag = m.mk_func_decl(symbol("diag"), sorts.size(), sorts.c_ptr(), s);
|
||||
func_decl* diag = m.mk_func_decl(symbol("diag"), sorts.size(), sorts.data(), s);
|
||||
expr_ref t(m);
|
||||
t = m.mk_app(diag, eqs.num_neq_terms(), eqs.neq_terms());
|
||||
add_def(t, def);
|
||||
|
|
|
|||
|
|
@ -337,7 +337,7 @@ namespace qel {
|
|||
m_subst_map.reset();
|
||||
m_subst_map.resize(sz, nullptr);
|
||||
m_subst.reset();
|
||||
m_subst.set_inv_bindings(sz, m_subst_map.c_ptr());
|
||||
m_subst.set_inv_bindings(sz, m_subst_map.data());
|
||||
for (unsigned idx : m_order) {
|
||||
// do all the previous substitutions before inserting
|
||||
expr* cur = m_map[idx];
|
||||
|
|
@ -389,33 +389,33 @@ namespace qel {
|
|||
expr_ref t(m);
|
||||
switch (q->get_kind()) {
|
||||
case forall_k:
|
||||
rw.mk_or(m_new_args.size(), m_new_args.c_ptr(), t);
|
||||
rw.mk_or(m_new_args.size(), m_new_args.data(), t);
|
||||
break;
|
||||
case exists_k:
|
||||
rw.mk_and(m_new_args.size(), m_new_args.c_ptr(), t);
|
||||
rw.mk_and(m_new_args.size(), m_new_args.data(), t);
|
||||
break;
|
||||
default:
|
||||
t = e;
|
||||
break;
|
||||
}
|
||||
expr_ref new_e = m_subst(t, m_subst_map.size(), m_subst_map.c_ptr());
|
||||
expr_ref new_e = m_subst(t, m_subst_map.size(), m_subst_map.data());
|
||||
TRACE("qe_lite", tout << new_e << "\n";);
|
||||
|
||||
// don't forget to update the quantifier patterns
|
||||
expr_ref_buffer new_patterns(m);
|
||||
expr_ref_buffer new_no_patterns(m);
|
||||
for (unsigned j = 0; j < q->get_num_patterns(); j++) {
|
||||
expr_ref new_pat = m_subst(q->get_pattern(j), m_subst_map.size(), m_subst_map.c_ptr());
|
||||
expr_ref new_pat = m_subst(q->get_pattern(j), m_subst_map.size(), m_subst_map.data());
|
||||
new_patterns.push_back(new_pat);
|
||||
}
|
||||
|
||||
for (unsigned j = 0; j < q->get_num_no_patterns(); j++) {
|
||||
expr_ref new_nopat = m_subst(q->get_no_pattern(j), m_subst_map.size(), m_subst_map.c_ptr());
|
||||
expr_ref new_nopat = m_subst(q->get_no_pattern(j), m_subst_map.size(), m_subst_map.data());
|
||||
new_no_patterns.push_back(new_nopat);
|
||||
}
|
||||
|
||||
r = m.update_quantifier(q, new_patterns.size(), new_patterns.c_ptr(),
|
||||
new_no_patterns.size(), new_no_patterns.c_ptr(), new_e);
|
||||
r = m.update_quantifier(q, new_patterns.size(), new_patterns.data(),
|
||||
new_no_patterns.size(), new_no_patterns.data(), new_e);
|
||||
}
|
||||
|
||||
void reduce_quantifier1(quantifier * q, expr_ref & r, proof_ref & pr) {
|
||||
|
|
@ -548,7 +548,7 @@ namespace qel {
|
|||
void flatten_definitions(expr_ref_vector& conjs) {
|
||||
TRACE("qe_lite",
|
||||
expr_ref tmp(m);
|
||||
tmp = m.mk_and(conjs.size(), conjs.c_ptr());
|
||||
tmp = m.mk_and(conjs.size(), conjs.data());
|
||||
tout << mk_pp(tmp, m) << "\n";);
|
||||
for (unsigned i = 0; i < conjs.size(); ++i) {
|
||||
expr* c = conjs[i].get();
|
||||
|
|
@ -584,7 +584,7 @@ namespace qel {
|
|||
}
|
||||
TRACE("qe_lite",
|
||||
expr_ref tmp(m);
|
||||
tmp = m.mk_and(conjs.size(), conjs.c_ptr());
|
||||
tmp = m.mk_and(conjs.size(), conjs.data());
|
||||
tout << "after flatten\n" << mk_pp(tmp, m) << "\n";);
|
||||
}
|
||||
|
||||
|
|
@ -655,7 +655,7 @@ namespace qel {
|
|||
|
||||
flatten_definitions(conjs);
|
||||
|
||||
find_definitions(conjs.size(), conjs.c_ptr(), true, def_count, largest_vinx);
|
||||
find_definitions(conjs.size(), conjs.data(), true, def_count, largest_vinx);
|
||||
|
||||
if (def_count > 0) {
|
||||
get_elimination_order();
|
||||
|
|
@ -663,9 +663,9 @@ namespace qel {
|
|||
|
||||
if (!m_order.empty()) {
|
||||
expr_ref r(m), new_r(m);
|
||||
r = m.mk_and(conjs.size(), conjs.c_ptr());
|
||||
r = m.mk_and(conjs.size(), conjs.data());
|
||||
create_substitution(largest_vinx + 1);
|
||||
new_r = m_subst(r, m_subst_map.size(), m_subst_map.c_ptr());
|
||||
new_r = m_subst(r, m_subst_map.size(), m_subst_map.data());
|
||||
m_rewriter(new_r);
|
||||
conjs.reset();
|
||||
flatten_and(new_r, conjs);
|
||||
|
|
@ -802,7 +802,7 @@ namespace qel {
|
|||
args.push_back(A);
|
||||
args.append(a1->get_num_args()-1, a1->get_args()+1);
|
||||
args.push_back(e2);
|
||||
expr* B = a.mk_store(args.size(), args.c_ptr());
|
||||
expr* B = a.mk_store(args.size(), args.data());
|
||||
expr_safe_replace rep(m);
|
||||
rep.insert(A, B);
|
||||
expr_ref tmp(m);
|
||||
|
|
@ -1145,7 +1145,7 @@ namespace fm {
|
|||
}
|
||||
|
||||
void reset_constraints() {
|
||||
del_constraints(m_constraints.size(), m_constraints.c_ptr());
|
||||
del_constraints(m_constraints.size(), m_constraints.data());
|
||||
m_constraints.reset();
|
||||
}
|
||||
|
||||
|
|
@ -1518,7 +1518,7 @@ namespace fm {
|
|||
if (c.m_num_vars == 1)
|
||||
lhs = ms[0];
|
||||
else
|
||||
lhs = m_util.mk_add(ms.size(), ms.c_ptr());
|
||||
lhs = m_util.mk_add(ms.size(), ms.data());
|
||||
expr * rhs = m_util.mk_numeral(c.m_c, int_cnstr);
|
||||
if (c.m_strict) {
|
||||
ineq = m.mk_not(m_util.mk_ge(lhs, rhs));
|
||||
|
|
@ -1548,7 +1548,7 @@ namespace fm {
|
|||
if (lits.size() == 1)
|
||||
return to_app(lits[0]);
|
||||
else
|
||||
return m.mk_or(lits.size(), lits.c_ptr());
|
||||
return m.mk_or(lits.size(), lits.data());
|
||||
}
|
||||
|
||||
var mk_var(expr * t) {
|
||||
|
|
@ -1683,7 +1683,7 @@ namespace fm {
|
|||
if (!is_int(xs.back()))
|
||||
all_int = false;
|
||||
}
|
||||
mk_int(as.size(), as.c_ptr(), c);
|
||||
mk_int(as.size(), as.data(), c);
|
||||
if (all_int && strict) {
|
||||
strict = false;
|
||||
c--;
|
||||
|
|
@ -1694,10 +1694,10 @@ namespace fm {
|
|||
TRACE("qe_lite", tout << "before mk_constraint: "; for (unsigned i = 0; i < xs.size(); i++) tout << " " << xs[i]; tout << "\n";);
|
||||
|
||||
constraint * new_c = mk_constraint(lits.size(),
|
||||
lits.c_ptr(),
|
||||
lits.data(),
|
||||
xs.size(),
|
||||
xs.c_ptr(),
|
||||
as.c_ptr(),
|
||||
xs.data(),
|
||||
as.data(),
|
||||
c,
|
||||
strict,
|
||||
dep);
|
||||
|
|
@ -2032,10 +2032,10 @@ namespace fm {
|
|||
}
|
||||
|
||||
constraint * new_cnstr = mk_constraint(new_lits.size(),
|
||||
new_lits.c_ptr(),
|
||||
new_lits.data(),
|
||||
new_xs.size(),
|
||||
new_xs.c_ptr(),
|
||||
new_as.c_ptr(),
|
||||
new_xs.data(),
|
||||
new_as.data(),
|
||||
new_c,
|
||||
new_strict,
|
||||
new_dep);
|
||||
|
|
@ -2092,7 +2092,7 @@ namespace fm {
|
|||
for (unsigned j = 0; j < num_uppers; j++) {
|
||||
if (m_inconsistent || num_new_cnstrs > limit) {
|
||||
TRACE("qe_lite", tout << "too many new constraints: " << num_new_cnstrs << "\n";);
|
||||
del_constraints(new_constraints.size(), new_constraints.c_ptr());
|
||||
del_constraints(new_constraints.size(), new_constraints.data());
|
||||
return false;
|
||||
}
|
||||
constraint const & l_c = *(l[i]);
|
||||
|
|
@ -2303,14 +2303,14 @@ public:
|
|||
quantifier_ref q(m);
|
||||
proof_ref pr(m);
|
||||
symbol qe_lite("QE");
|
||||
expr_abstract(m, 0, vars.size(), (expr*const*)vars.c_ptr(), fml, tmp);
|
||||
expr_abstract(m, 0, vars.size(), (expr*const*)vars.data(), fml, tmp);
|
||||
ptr_vector<sort> sorts;
|
||||
svector<symbol> names;
|
||||
for (unsigned i = 0; i < vars.size(); ++i) {
|
||||
sorts.push_back(vars[i]->get_sort());
|
||||
names.push_back(vars[i]->get_decl()->get_name());
|
||||
}
|
||||
q = m.mk_exists(vars.size(), sorts.c_ptr(), names.c_ptr(), tmp, 1, qe_lite);
|
||||
q = m.mk_exists(vars.size(), sorts.data(), names.data(), tmp, 1, qe_lite);
|
||||
m_der.reduce_quantifier(q, tmp, pr);
|
||||
// assumes m_der just updates the quantifier and does not change things more.
|
||||
if (is_exists(tmp) && to_quantifier(tmp)->get_qid() == qe_lite) {
|
||||
|
|
@ -2318,7 +2318,7 @@ public:
|
|||
tmp = to_quantifier(tmp)->get_expr();
|
||||
used.process(tmp);
|
||||
var_subst vs(m, true);
|
||||
fml = vs(tmp, vars.size(), (expr*const*)vars.c_ptr());
|
||||
fml = vs(tmp, vars.size(), (expr*const*)vars.data());
|
||||
// collect set of variables that were used.
|
||||
unsigned j = 0;
|
||||
for (unsigned i = 0; i < vars.size(); ++i) {
|
||||
|
|
@ -2350,10 +2350,10 @@ public:
|
|||
conjs.reset();
|
||||
conjs.push_back(disjs[i].get());
|
||||
(*this)(index_set, index_of_bound, conjs);
|
||||
bool_rewriter(m).mk_and(conjs.size(), conjs.c_ptr(), fml);
|
||||
bool_rewriter(m).mk_and(conjs.size(), conjs.data(), fml);
|
||||
disjs[i] = std::move(fml);
|
||||
}
|
||||
bool_rewriter(m).mk_or(disjs.size(), disjs.c_ptr(), fml);
|
||||
bool_rewriter(m).mk_or(disjs.size(), disjs.data(), fml);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -428,7 +428,7 @@ namespace qe {
|
|||
(x->get_depth() > y->get_depth()) ||
|
||||
(x->get_depth() == y->get_depth() && x->get_id() > y->get_id());
|
||||
};
|
||||
std::sort(avars.c_ptr(), avars.c_ptr() + avars.size(), compare_depth);
|
||||
std::sort(avars.data(), avars.data() + avars.size(), compare_depth);
|
||||
TRACE("qe", tout << "avars:" << avars << "\n";);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -401,7 +401,7 @@ namespace qe {
|
|||
app_ref r(m);
|
||||
ptr_vector<expr> args;
|
||||
unsigned sz0 = todo.size();
|
||||
todo.append(fmls.size(), (expr*const*)fmls.c_ptr());
|
||||
todo.append(fmls.size(), (expr*const*)fmls.data());
|
||||
while (sz0 != todo.size()) {
|
||||
app* a = to_app(todo.back());
|
||||
if (cache.contains(a)) {
|
||||
|
|
@ -1083,7 +1083,7 @@ namespace qe {
|
|||
return expr_ref(m);
|
||||
}
|
||||
reset();
|
||||
fml = ::mk_exists(m, vars.size(), vars.c_ptr(), fml);
|
||||
fml = ::mk_exists(m, vars.size(), vars.data(), fml);
|
||||
fml = ::push_not(fml);
|
||||
hoist(fml);
|
||||
if (!is_ground(fml)) {
|
||||
|
|
@ -1107,7 +1107,7 @@ namespace qe {
|
|||
}
|
||||
m_free_vars.shrink(j);
|
||||
if (!m_free_vars.empty()) {
|
||||
fml = ::mk_exists(m, m_free_vars.size(), m_free_vars.c_ptr(), fml);
|
||||
fml = ::mk_exists(m, m_free_vars.size(), m_free_vars.data(), fml);
|
||||
}
|
||||
return fml;
|
||||
default:
|
||||
|
|
@ -1274,7 +1274,7 @@ namespace qe {
|
|||
expr_ref_vector defs(m);
|
||||
expr_ref fml(m);
|
||||
in->get_formulas(fmls);
|
||||
fml = mk_and(m, fmls.size(), fmls.c_ptr());
|
||||
fml = mk_and(m, fmls.size(), fmls.data());
|
||||
|
||||
// for now:
|
||||
// fail if cores. (TBD)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue