mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-08-22 11:07:51 +00:00
Code Activity

call it data instead of c_ptr for approaching C++11 std::vector convention.

Browse source
This commit is contained in:
Nikolaj Bjorner 2021-04-13 18:17:10 -07:00
parent 524dcd35f9
commit 4a6083836a
456 changed files with 2802 additions and 2802 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/sat/smt/arith_internalize.cpp
View file

@ -447,7 +447,7 @@ namespace arith {
vars.push_back(register_theory_var_in_lar_solver(w));
ensure_nla();
m_solver->register_existing_terms();
m_nla->add_monic(register_theory_var_in_lar_solver(v), vars.size(), vars.c_ptr());
m_nla->add_monic(register_theory_var_in_lar_solver(v), vars.size(), vars.data());
}
return v;
}
@ -470,7 +470,7 @@ namespace arith {
TRACE("arith", tout << "v" << v << " := " << mk_pp(t, m) << "\n" << vars << "\n";);
m_solver->register_existing_terms();
ensure_nla();
m_nla->add_monic(register_theory_var_in_lar_solver(v), vars.size(), vars.c_ptr());
m_nla->add_monic(register_theory_var_in_lar_solver(v), vars.size(), vars.data());
}
return v;
}
@ -572,7 +572,7 @@ namespace arith {
if (reflect(e))
for (expr* arg : *to_app(e))
args.push_back(e_internalize(arg));
n = ctx.mk_enode(e, args.size(), args.c_ptr());
n = ctx.mk_enode(e, args.size(), args.data());
ctx.attach_node(n);
}
return n;

6
src/sat/smt/arith_solver.cpp
View file

@ -613,7 +613,7 @@ namespace arith {
else
args.push_back(values.get(arg->get_root_id()));
}
value = m.mk_app(to_app(o)->get_decl(), args.size(), args.c_ptr());
value = m.mk_app(to_app(o)->get_decl(), args.size(), args.data());
ctx.get_rewriter()(value);
}
else {
@ -865,7 +865,7 @@ namespace arith {
}
}
if (!vars.empty())
lp().random_update(vars.size(), vars.c_ptr());
lp().random_update(vars.size(), vars.data());
}
bool solver::assume_eqs() {
@ -1351,7 +1351,7 @@ namespace arith {
if (args.size() == 1)
return app_ref(to_app(args[0].get()), m);
return app_ref(a.mk_add(args.size(), args.c_ptr()), m);
return app_ref(a.mk_add(args.size(), args.data()), m);
}
app_ref solver::mk_term(lp::lar_term const& term, bool is_int) {

10
src/sat/smt/array_axioms.cpp
View file

@ -319,7 +319,7 @@ namespace array {
ptr_vector<expr> sel_args(num_args, select->get_args());
sel_args[0] = arr;
expr_ref sel(a.mk_select(sel_args), m);
expr_ref val(m.mk_app(f, sel_args.size() - 1, sel_args.c_ptr() + 1), m);
expr_ref val(m.mk_app(f, sel_args.size() - 1, sel_args.data() + 1), m);
euf::enode* n1 = e_internalize(sel);
euf::enode* n2 = e_internalize(val);
return ctx.propagate(n1, n2, array_axiom());
@ -450,10 +450,10 @@ namespace array {
args1.push_back(k);
args2.push_back(k);
}
expr * sel1 = a.mk_select(dimension+1, args1.c_ptr());
expr * sel2 = a.mk_select(dimension+1, args2.c_ptr());
expr * sel1 = a.mk_select(dimension+1, args1.data());
expr * sel2 = a.mk_select(dimension+1, args2.data());
expr * eq = m.mk_eq(sel1, sel2);
expr_ref q(m.mk_forall(dimension, sorts.c_ptr(), names.c_ptr(), eq), m);
expr_ref q(m.mk_forall(dimension, sorts.data(), names.data(), eq), m);
rewrite(q);
return add_clause(~eq_internalize(e1, e2), mk_literal(q));
}
@ -573,7 +573,7 @@ namespace array {
r->mark1();
to_unmark.push_back(r);
}
TRACE("array", tout << "collecting shared vars...\n" << unsigned_vector(roots.size(), (unsigned*)roots.c_ptr()) << "\n";);
TRACE("array", tout << "collecting shared vars...\n" << unsigned_vector(roots.size(), (unsigned*)roots.data()) << "\n";);
for (auto* n : to_unmark)
n->unmark1();
}

4
src/sat/smt/array_diagnostics.cpp
View file

@ -118,8 +118,8 @@ namespace array {
args.push_back(n->get_arg(i));
for (euf::enode* n : args)
eargs.push_back(n->get_expr());
expr_ref sel(a.mk_select(eargs.size(), eargs.c_ptr()), m);
euf::enode* n1 = ctx.get_egraph().find(sel, args.size(), args.c_ptr());
expr_ref sel(a.mk_select(eargs.size(), eargs.data()), m);
euf::enode* n1 = ctx.get_egraph().find(sel, args.size(), args.data());
if (n1 && n1->get_root() == n->get_root())
return;
IF_VERBOSE(0,

2
src/sat/smt/array_model.cpp
View file

@ -95,7 +95,7 @@ namespace array {
args.reset();
for (unsigned i = 1; i < p->num_args(); ++i)
args.push_back(values.get(p->get_arg(i)->get_root_id()));
fi->insert_entry(args.c_ptr(), value);
fi->insert_entry(args.data(), value);
}
}

20
src/sat/smt/bv_internalize.cpp
View file

@ -413,7 +413,7 @@ namespace bv {
unsigned i = 0;
for (expr* b : k_bits)
args.push_back(m.mk_ite(b, m_autil.mk_int(power2(i++)), zero));
expr_ref sum(m_autil.mk_add(sz, args.c_ptr()), m);
expr_ref sum(m_autil.mk_add(sz, args.data()), m);
expr_ref eq = mk_eq(n, sum);
sat::literal lit = ctx.internalize(eq, false, false, m_is_redundant);
add_unit(lit);
@ -471,9 +471,9 @@ namespace bv {
get_arg_bits(n, Rev ? 0 : 1, arg2_bits);
expr_ref le(m);
if (Signed)
m_bb.mk_sle(arg1_bits.size(), arg1_bits.c_ptr(), arg2_bits.c_ptr(), le);
m_bb.mk_sle(arg1_bits.size(), arg1_bits.data(), arg2_bits.data(), le);
else
m_bb.mk_ule(arg1_bits.size(), arg1_bits.c_ptr(), arg2_bits.c_ptr(), le);
m_bb.mk_ule(arg1_bits.size(), arg1_bits.data(), arg2_bits.data(), le);
literal def = ctx.internalize(le, false, false, m_is_redundant);
if (Negated)
def.neg();
@ -535,7 +535,7 @@ namespace bv {
SASSERT(n->get_num_args() == 1);
expr_ref_vector arg1_bits(m), bits(m);
get_arg_bits(n, 0, arg1_bits);
fn(arg1_bits.size(), arg1_bits.c_ptr(), bits);
fn(arg1_bits.size(), arg1_bits.data(), bits);
init_bits(n, bits);
}
@ -544,7 +544,7 @@ namespace bv {
expr_ref_vector arg1_bits(m), bits(m);
get_arg_bits(n, 0, arg1_bits);
unsigned param = n->get_decl()->get_parameter(0).get_int();
fn(arg1_bits.size(), arg1_bits.c_ptr(), param, bits);
fn(arg1_bits.size(), arg1_bits.data(), param, bits);
init_bits(n, bits);
}
@ -554,7 +554,7 @@ namespace bv {
get_arg_bits(e, 0, arg1_bits);
get_arg_bits(e, 1, arg2_bits);
SASSERT(arg1_bits.size() == arg2_bits.size());
fn(arg1_bits.size(), arg1_bits.c_ptr(), arg2_bits.c_ptr(), bits);
fn(arg1_bits.size(), arg1_bits.data(), arg2_bits.data(), bits);
init_bits(e, bits);
}
@ -568,7 +568,7 @@ namespace bv {
get_arg_bits(e, i, arg_bits);
SASSERT(arg_bits.size() == bits.size());
new_bits.reset();
fn(arg_bits.size(), arg_bits.c_ptr(), bits.c_ptr(), new_bits);
fn(arg_bits.size(), arg_bits.data(), bits.data(), new_bits);
bits.swap(new_bits);
}
init_bits(e, bits);
@ -581,7 +581,7 @@ namespace bv {
get_arg_bits(n, 0, arg1_bits);
get_arg_bits(n, 1, arg2_bits);
expr_ref out(m);
fn(arg1_bits.size(), arg1_bits.c_ptr(), arg2_bits.c_ptr(), out);
fn(arg1_bits.size(), arg1_bits.data(), arg2_bits.data(), out);
sat::literal def = ctx.internalize(out, false, false, m_is_redundant);
add_def(def, expr2literal(n));
}
@ -613,7 +613,7 @@ namespace bv {
get_arg_bits(n, 1, arg2_bits);
SASSERT(arg1_bits.size() == arg2_bits.size());
expr_ref carry(m);
m_bb.mk_subtracter(arg1_bits.size(), arg1_bits.c_ptr(), arg2_bits.c_ptr(), bits, carry);
m_bb.mk_subtracter(arg1_bits.size(), arg1_bits.data(), arg2_bits.data(), bits, carry);
init_bits(n, bits);
}
@ -748,6 +748,6 @@ namespace bv {
eqs.push_back(~eq);
}
TRACE("bv", for (auto l : eqs) tout << mk_bounded_pp(literal2expr(l), m) << " "; tout << "\n";);
s().add_clause(eqs.size(), eqs.c_ptr(), sat::status::th(m_is_redundant, get_id()));
s().add_clause(eqs.size(), eqs.data(), sat::status::th(m_is_redundant, get_id()));
}
}

2
src/sat/smt/bv_solver.cpp
View file

@ -568,7 +568,7 @@ namespace bv {
hash(solver& s) :s(s) {}
bool operator()(theory_var v) const {
literal_vector const& a = s.m_bits[v];
return string_hash(reinterpret_cast<char*>(a.c_ptr()), a.size() * sizeof(sat::literal), 3);
return string_hash(reinterpret_cast<char*>(a.data()), a.size() * sizeof(sat::literal), 3);
}
};
eq eq_proc(*this);

10
src/sat/smt/euf_internalize.cpp
View file

@ -96,7 +96,7 @@ namespace euf {
if (auto* s = expr2solver(e))
s->internalize(e, m_is_redundant);
else
attach_node(m_egraph.mk(e, m_generation, num, m_args.c_ptr()));
attach_node(m_egraph.mk(e, m_generation, num, m_args.data()));
return true;
}
@ -165,9 +165,9 @@ namespace euf {
if (m.is_distinct(e)) {
enode_vector _args(args);
if (sign)
add_not_distinct_axiom(e, _args.c_ptr());
add_not_distinct_axiom(e, _args.data());
else
add_distinct_axiom(e, _args.c_ptr());
add_distinct_axiom(e, _args.data());
return true;
}
return false;
@ -192,7 +192,7 @@ namespace euf {
}
s().mk_clause(lits, st);
if (relevancy_enabled())
add_root(lits.size(), lits.c_ptr());
add_root(lits.size(), lits.data());
}
else {
// g(f(x_i)) = x_i
@ -214,7 +214,7 @@ namespace euf {
eqs.push_back(mk_eq(fapp, a));
}
pb_util pb(m);
expr_ref at_least2(pb.mk_at_least_k(eqs.size(), eqs.c_ptr(), 2), m);
expr_ref at_least2(pb.mk_at_least_k(eqs.size(), eqs.data(), 2), m);
sat::literal lit = si.internalize(at_least2, m_is_redundant);
s().mk_clause(1, &lit, st);
if (relevancy_enabled())

6
src/sat/smt/euf_model.cpp
View file

@ -35,7 +35,7 @@ namespace euf {
~user_sort() {
for (auto kv : sort2values)
mdl->register_usort(kv.m_key, kv.m_value->size(), kv.m_value->c_ptr());
mdl->register_usort(kv.m_key, kv.m_value->size(), kv.m_value->data());
}
void add(enode* r, sort* srt) {
@ -203,8 +203,8 @@ namespace euf {
args.push_back(m_values.get(arg->get_root_id()));
DEBUG_CODE(for (expr* arg : args) VERIFY(arg););
SASSERT(args.size() == arity);
if (!fi->get_entry(args.c_ptr()))
fi->insert_new_entry(args.c_ptr(), v);
if (!fi->get_entry(args.data()))
fi->insert_new_entry(args.data(), v);
}
}
}

2
src/sat/smt/euf_solver.h
View file

@ -380,7 +380,7 @@ namespace euf {
::solver::fresh_eh_t& fresh_eh);
bool watches_fixed(enode* n) const;
void assign_fixed(enode* n, expr* val, unsigned sz, literal const* explain);
void assign_fixed(enode* n, expr* val, literal_vector const& explain) { assign_fixed(n, val, explain.size(), explain.c_ptr()); }
void assign_fixed(enode* n, expr* val, literal_vector const& explain) { assign_fixed(n, val, explain.size(), explain.data()); }
void assign_fixed(enode* n, expr* val, literal explain) { assign_fixed(n, val, 1, &explain); }
void user_propagate_register_final(::solver::final_eh_t& final_eh) {

4
src/sat/smt/pb_internalize.cpp
View file

@ -263,7 +263,7 @@ namespace pb {
for (sat::literal l : c) {
lits.push_back(lit2expr(l));
}
expr_ref fml(m_pb.mk_at_least_k(c.size(), lits.c_ptr(), c.k()), m);
expr_ref fml(m_pb.mk_at_least_k(c.size(), lits.data(), c.k()), m);
if (c.lit() != sat::null_literal) {
fml = m.mk_eq(lit2expr(c.lit()), fml);
@ -279,7 +279,7 @@ namespace pb {
coeffs.push_back(rational(wl.first));
}
rational k(p.k());
expr_ref fml(m_pb.mk_ge(p.size(), coeffs.c_ptr(), lits.c_ptr(), k), m);
expr_ref fml(m_pb.mk_ge(p.size(), coeffs.data(), lits.data(), k), m);
if (p.lit() != sat::null_literal) {
fml = m.mk_eq(lit2expr(p.lit()), fml);

42
src/sat/smt/pb_solver.cpp
View file

@ -99,7 +99,7 @@ namespace pb {
}
if (p.k() == 1 && p.lit() == sat::null_literal) {
literal_vector lits(p.literals());
s().mk_clause(lits.size(), lits.c_ptr(), sat::status::th(p.learned(), get_id()));
s().mk_clause(lits.size(), lits.data(), sat::status::th(p.learned(), get_id()));
IF_VERBOSE(100, display(verbose_stream() << "add clause: " << lits << "\n", p, true););
remove_constraint(p, "implies clause");
}
@ -150,8 +150,8 @@ namespace pb {
unsigned k = p.k() - true_val;
if (k == 1 && p.lit() == sat::null_literal) {
literal_vector lits(sz, p.literals().c_ptr());
s().mk_clause(sz, lits.c_ptr(), sat::status::th(p.learned(), get_id()));
literal_vector lits(sz, p.literals().data());
s().mk_clause(sz, lits.data(), sat::status::th(p.learned(), get_id()));
remove_constraint(p, "is clause");
return;
}
@ -448,14 +448,14 @@ namespace pb {
}
else if (k == 1 && p.lit() == sat::null_literal) {
literal_vector lits(sz, p.literals().c_ptr());
s().mk_clause(sz, lits.c_ptr(), sat::status::th(p.learned(), get_id()));
literal_vector lits(sz, p.literals().data());
s().mk_clause(sz, lits.data(), sat::status::th(p.learned(), get_id()));
remove_constraint(p, "recompiled to clause");
return;
}
else if (all_units) {
literal_vector lits(sz, p.literals().c_ptr());
literal_vector lits(sz, p.literals().data());
add_at_least(p.lit(), lits, k, p.learned());
remove_constraint(p, "recompiled to cardinality");
return;
@ -1368,10 +1368,10 @@ namespace pb {
constraint* solver::add_at_least(literal lit, literal_vector const& lits, unsigned k, bool learned) {
if (k == 1 && lit == sat::null_literal) {
literal_vector _lits(lits);
s().mk_clause(_lits.size(), _lits.c_ptr(), sat::status::th(learned, get_id()));
s().mk_clause(_lits.size(), _lits.data(), sat::status::th(learned, get_id()));
return nullptr;
}
if (!learned && clausify(lit, lits.size(), lits.c_ptr(), k)) {
if (!learned && clausify(lit, lits.size(), lits.data(), k)) {
return nullptr;
}
void * mem = m_allocator.allocate(card::get_obj_size(lits.size()));
@ -2143,7 +2143,7 @@ namespace pb {
s.s().mk_clause(~m_lits[i], max);
}
m_lits.push_back(~max);
s.s().mk_clause(m_lits.size(), m_lits.c_ptr());
s.s().mk_clause(m_lits.size(), m_lits.data());
return max;
}
}
@ -2168,7 +2168,7 @@ namespace pb {
m_lits[i] = ~m_lits[i];
}
m_lits.push_back(min);
s.s().mk_clause(m_lits.size(), m_lits.c_ptr());
s.s().mk_clause(m_lits.size(), m_lits.data());
return min;
}
}
@ -2177,7 +2177,7 @@ namespace pb {
void solver::ba_sort::mk_clause(unsigned n, literal const* lits) {
m_lits.reset();
m_lits.append(n, lits);
s.s().mk_clause(n, m_lits.c_ptr());
s.s().mk_clause(n, m_lits.data());
}
std::ostream& solver::ba_sort::pp(std::ostream& out, literal l) const {
@ -2306,8 +2306,8 @@ namespace pb {
}
if (k == 1 && c.lit() == sat::null_literal) {
literal_vector lits(sz, c.literals().c_ptr());
s().mk_clause(sz, lits.c_ptr(), sat::status::th(c.learned(), get_id()));
literal_vector lits(sz, c.literals().data());
s().mk_clause(sz, lits.data(), sat::status::th(c.learned(), get_id()));
remove_constraint(c, "recompiled to clause");
return;
}
@ -2417,7 +2417,7 @@ namespace pb {
}
if (is_cardinality(p, m_lemma)) {
literal lit = m_sort.ge(is_def, p.k(), m_lemma.size(), m_lemma.c_ptr());
literal lit = m_sort.ge(is_def, p.k(), m_lemma.size(), m_lemma.data());
if (is_def) {
s().mk_clause(p.lit(), ~lit);
s().mk_clause(~p.lit(), lit);
@ -3450,7 +3450,7 @@ namespace pb {
for (wliteral wl : m_wlits) {
if (value(wl.second) == l_false) lits.push_back(wl.second);
}
unsigned glue = s().num_diff_levels(lits.size(), lits.c_ptr());
unsigned glue = s().num_diff_levels(lits.size(), lits.data());
c->set_glue(glue);
}
return c;
@ -3761,7 +3761,7 @@ namespace pb {
// ~c.lits() <= n - k
lits.reset();
for (unsigned j = 0; j < n; ++j) lits.push_back(c[j]);
add_cardinality(lits.size(), lits.c_ptr(), n - k);
add_cardinality(lits.size(), lits.data(), n - k);
}
else {
//
@ -3778,13 +3778,13 @@ namespace pb {
coeffs.reset();
for (literal l : c) lits.push_back(l), coeffs.push_back(1);
lits.push_back(~c.lit()); coeffs.push_back(n - k + 1);
add_pb(lits.size(), lits.c_ptr(), coeffs.c_ptr(), n);
add_pb(lits.size(), lits.data(), coeffs.data(), n);
lits.reset();
coeffs.reset();
for (literal l : c) lits.push_back(~l), coeffs.push_back(1);
lits.push_back(c.lit()); coeffs.push_back(k);
add_pb(lits.size(), lits.c_ptr(), coeffs.c_ptr(), n);
add_pb(lits.size(), lits.data(), coeffs.data(), n);
}
break;
}
@ -3800,7 +3800,7 @@ namespace pb {
// <=>
// ~wl + ... + ~w_n <= sum_of_weights - k
for (wliteral wl : p) lits.push_back(~(wl.second)), coeffs.push_back(wl.first);
add_pb(lits.size(), lits.c_ptr(), coeffs.c_ptr(), sum - p.k());
add_pb(lits.size(), lits.data(), coeffs.data(), sum - p.k());
}
else {
// lit <=> w1 + .. + w_n >= k
@ -3812,13 +3812,13 @@ namespace pb {
// k*lit + ~wl + ... + ~w_n <= sum
lits.push_back(p.lit()), coeffs.push_back(p.k());
for (wliteral wl : p) lits.push_back(~(wl.second)), coeffs.push_back(wl.first);
add_pb(lits.size(), lits.c_ptr(), coeffs.c_ptr(), sum);
add_pb(lits.size(), lits.data(), coeffs.data(), sum);
lits.reset();
coeffs.reset();
lits.push_back(~p.lit()), coeffs.push_back(sum + 1 - p.k());
for (wliteral wl : p) lits.push_back(wl.second), coeffs.push_back(wl.first);
add_pb(lits.size(), lits.c_ptr(), coeffs.c_ptr(), sum);
add_pb(lits.size(), lits.data(), coeffs.data(), sum);
}
break;
}

2
src/sat/smt/q_eval.cpp
View file

@ -182,7 +182,7 @@ namespace q {
todo.push_back(arg);
}
if (args.size() == to_app(t)->get_num_args()) {
euf::enode* n = ctx.get_egraph().find(t, args.size(), args.c_ptr());
euf::enode* n = ctx.get_egraph().find(t, args.size(), args.data());
if (!n)
return nullptr;
m_indirect_nodes.push_back(n);

8
src/sat/smt/q_mam.cpp
View file

@ -1012,7 +1012,7 @@ namespace q {
SASSERT(m_vars[to_var(arg)->get_idx()] != -1);
iregs.push_back(m_vars[to_var(arg)->get_idx()]);
}
m_seq.push_back(m_ct_manager.mk_is_cgr(lbl, first_app_reg, num_args, iregs.c_ptr()));
m_seq.push_back(m_ct_manager.mk_is_cgr(lbl, first_app_reg, num_args, iregs.data()));
}
else {
// Generate a BIND operation for this application.
@ -1089,7 +1089,7 @@ namespace q {
}
unsigned oreg = m_tree->m_num_regs;
m_tree->m_num_regs += 1;
m_seq.push_back(m_ct_manager.mk_get_cgr(n->get_decl(), oreg, n->get_num_args(), iregs.c_ptr()));
m_seq.push_back(m_ct_manager.mk_get_cgr(n->get_decl(), oreg, n->get_num_args(), iregs.data()));
return oreg;
}
@ -1201,7 +1201,7 @@ namespace q {
}
}
SASSERT(joints.size() == num_args);
m_seq.push_back(m_ct_manager.mk_cont(lbl, num_args, oreg, s, joints.c_ptr()));
m_seq.push_back(m_ct_manager.mk_cont(lbl, num_args, oreg, s, joints.data()));
m_num_choices++;
while (!m_todo.empty())
linearise_core();
@ -2621,7 +2621,7 @@ namespace q {
goto backtrack;
cgr_common:
m_n1 = ctx.get_egraph().get_enode_eq_to(static_cast<const get_cgr *>(m_pc)->m_label, static_cast<const get_cgr *>(m_pc)->m_num_args, m_args.c_ptr());
m_n1 = ctx.get_egraph().get_enode_eq_to(static_cast<const get_cgr *>(m_pc)->m_label, static_cast<const get_cgr *>(m_pc)->m_num_args, m_args.data());
if (!m_n1 || !ctx.is_relevant(m_n1))
goto backtrack;
update_max_generation(m_n1, nullptr);

2
src/sat/smt/q_model_fixer.cpp
View file

@ -162,7 +162,7 @@ namespace q {
bool operator()(expr* a, expr* b) const { return (*p)(a, b); }
};
lt _lt(proj);
std::sort(values.c_ptr(), values.c_ptr() + values.size(), _lt);
std::sort(values.data(), values.data() + values.size(), _lt);
unsigned j = 0;
for (unsigned i = 0; i < values.size(); ++i)
if (i == 0 || values.get(i - 1) != values.get(i))

4
src/sat/smt/q_queue.cpp
View file

@ -110,14 +110,14 @@ namespace q {
float queue::get_cost(fingerprint& f) {
set_values(f, 0);
float r = m_evaluator(m_cost_function, m_vals.size(), m_vals.c_ptr());
float r = m_evaluator(m_cost_function, m_vals.size(), m_vals.data());
f.c->m_stat->update_max_cost(r);
return r;
}
unsigned queue::get_new_gen(fingerprint& f, float cost) {
set_values(f, cost);
float r = m_evaluator(m_new_gen_function, m_vals.size(), m_vals.c_ptr());
float r = m_evaluator(m_new_gen_function, m_vals.size(), m_vals.data());
return std::max(f.m_max_generation + 1, static_cast<unsigned>(r));
}

6
src/sat/smt/sat_dual_solver.cpp
View file

@ -98,7 +98,7 @@ namespace sat {
m_lits.reset();
for (unsigned i = 0; i < sz; ++i)
m_lits.push_back(ext2lit(clause[i]));
m_solver.mk_clause(sz, m_lits.c_ptr(), status::input());
m_solver.mk_clause(sz, m_lits.data(), status::input());
}
bool dual_solver::operator()(solver const& s) {
@ -107,11 +107,11 @@ namespace sat {
if (m_roots.empty())
return true;
m_solver.user_push();
m_solver.add_clause(m_roots.size(), m_roots.c_ptr(), status::input());
m_solver.add_clause(m_roots.size(), m_roots.data(), status::input());
m_lits.reset();
for (bool_var v : m_tracked_vars)
m_lits.push_back(literal(v, l_false == s.value(m_var2ext[v])));
lbool is_sat = m_solver.check(m_lits.size(), m_lits.c_ptr());
lbool is_sat = m_solver.check(m_lits.size(), m_lits.data());
if (is_sat == l_false)
for (literal lit : m_solver.get_core())
m_core.push_back(lit2ext(lit));

12
src/sat/smt/sat_th.cpp
View file

@ -163,7 +163,7 @@ namespace euf {
bool was_true = false;
for (auto lit : lits)
was_true |= is_true(lit);
s().add_clause(lits.size(), lits.c_ptr(), mk_status());
s().add_clause(lits.size(), lits.data(), mk_status());
return !was_true;
}
@ -191,7 +191,7 @@ namespace euf {
if (!suppress_args)
for (expr* arg : *to_app(e))
m_args.push_back(expr2enode(arg));
euf::enode* n = ctx.mk_enode(e, m_args.size(), m_args.c_ptr());
euf::enode* n = ctx.mk_enode(e, m_args.size(), m_args.data());
ctx.attach_node(n);
return n;
}
@ -251,11 +251,11 @@ namespace euf {
}
th_explain* th_explain::propagate(th_euf_solver& th, sat::literal_vector const& lits, enode_pair_vector const& eqs, sat::literal consequent) {
return mk(th, lits.size(), lits.c_ptr(), eqs.size(), eqs.c_ptr(), consequent, nullptr, nullptr);
return mk(th, lits.size(), lits.data(), eqs.size(), eqs.data(), consequent, nullptr, nullptr);
}
th_explain* th_explain::propagate(th_euf_solver& th, sat::literal_vector const& lits, enode_pair_vector const& eqs, euf::enode* x, euf::enode* y) {
return mk(th, lits.size(), lits.c_ptr(), eqs.size(), eqs.c_ptr(), sat::null_literal, x, y);
return mk(th, lits.size(), lits.data(), eqs.size(), eqs.data(), sat::null_literal, x, y);
}
th_explain* th_explain::propagate(th_euf_solver& th, sat::literal lit, euf::enode* x, euf::enode* y) {
@ -263,7 +263,7 @@ namespace euf {
}
th_explain* th_explain::conflict(th_euf_solver& th, sat::literal_vector const& lits, enode_pair_vector const& eqs) {
return conflict(th, lits.size(), lits.c_ptr(), eqs.size(), eqs.c_ptr());
return conflict(th, lits.size(), lits.data(), eqs.size(), eqs.data());
}
th_explain* th_explain::conflict(th_euf_solver& th, unsigned n_lits, sat::literal const* lits, unsigned n_eqs, enode_pair const* eqs) {
@ -271,7 +271,7 @@ namespace euf {
}
th_explain* th_explain::conflict(th_euf_solver& th, enode_pair_vector const& eqs) {
return conflict(th, 0, nullptr, eqs.size(), eqs.c_ptr());
return conflict(th, 0, nullptr, eqs.size(), eqs.data());
}
th_explain* th_explain::conflict(th_euf_solver& th, sat::literal lit) {

2
src/sat/smt/sat_th.h
View file

@ -211,7 +211,7 @@ namespace euf {
public:
static th_explain* conflict(th_euf_solver& th, sat::literal_vector const& lits, enode_pair_vector const& eqs);
static th_explain* conflict(th_euf_solver& th, sat::literal_vector const& lits) { return conflict(th, lits.size(), lits.c_ptr(), 0, nullptr); }
static th_explain* conflict(th_euf_solver& th, sat::literal_vector const& lits) { return conflict(th, lits.size(), lits.data(), 0, nullptr); }
static th_explain* conflict(th_euf_solver& th, unsigned n_lits, sat::literal const* lits, unsigned n_eqs, enode_pair const* eqs);
static th_explain* conflict(th_euf_solver& th, enode_pair_vector const& eqs);
static th_explain* conflict(th_euf_solver& th, sat::literal lit);