mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-08-24 03:57: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

8
src/sat/dimacs.cpp
View file

@ -126,7 +126,7 @@ static bool parse_dimacs_core(Buffer & in, std::ostream& err, sat::solver & solv
}
else {
read_clause(in, err, solver, lits);
solver.mk_clause(lits.size(), lits.c_ptr());
solver.mk_clause(lits.size(), lits.data());
}
}
}
@ -176,7 +176,7 @@ namespace dimacs {
++in;
}
m_buffer.push_back(0);
return m_buffer.c_ptr();
return m_buffer.data();
}
char const* drat_parser::parse_quoted_symbol() {
@ -195,7 +195,7 @@ namespace dimacs {
++in;
m_buffer.push_back(c);
m_buffer.push_back(0);
return m_buffer.c_ptr();
return m_buffer.data();
}
escape = (c == '\\');
m_buffer.push_back(c);
@ -221,7 +221,7 @@ namespace dimacs {
++in;
}
m_buffer.push_back(0);
return m_buffer.c_ptr();
return m_buffer.data();
}
int drat_parser::read_theory_id() {

4
src/sat/sat_aig_cuts.cpp
View file

@ -354,7 +354,7 @@ namespace sat {
m_literals.append(sz, args);
for (unsigned i = 0; i < sz; ++i) reserve(args[i].var());
if (op == and_op || op == xor_op) {
std::sort(m_literals.c_ptr() + offset, m_literals.c_ptr() + offset + sz);
std::sort(m_literals.data() + offset, m_literals.data() + offset + sz);
}
add_node(v, n);
}
@ -424,7 +424,7 @@ namespace sat {
}
}
if (changed && (n.is_and() || n.is_xor())) {
std::sort(m_literals.c_ptr() + n.offset(), m_literals.c_ptr() + n.offset() + n.size());
std::sort(m_literals.data() + n.offset(), m_literals.data() + n.offset() + n.size());
}
return true;
}

2
src/sat/sat_anf_simplifier.cpp
View file

@ -363,7 +363,7 @@ namespace sat {
svector<std::pair<unsigned, unsigned>> vl(nv);
for (unsigned i = 0; i < nv; ++i) var2id[i] = i;
shuffle(var2id.size(), var2id.c_ptr(), s.rand());
shuffle(var2id.size(), var2id.data(), s.rand());
for (unsigned i = 0; i < nv; ++i) id2var[var2id[i]] = i;
for (unsigned i = 0; i < nv; ++i) vl[i] = std::make_pair(i, var2id[i]);
std::sort(vl.begin(), vl.end());

6
src/sat/sat_big.cpp
View file

@ -51,7 +51,7 @@ namespace sat {
s.m_ext->is_extended_binary(w.get_ext_constraint_idx(), r)) {
seen_idx.insert(w.get_ext_constraint_idx(), true);
for (unsigned i = 0; i < std::min(4u, r.size()); ++i) {
shuffle<literal>(r.size(), r.c_ptr(), m_rand);
shuffle<literal>(r.size(), r.data(), m_rand);
literal u = r[0];
for (unsigned j = 1; j < r.size(); ++j) {
literal v = ~r[j];
@ -91,7 +91,7 @@ namespace sat {
void big::done_adding_edges() {
for (auto& edges : m_dag) {
shuffle<literal>(edges.size(), edges.c_ptr(), m_rand);
shuffle<literal>(edges.size(), edges.data(), m_rand);
}
init_dfs_num();
}
@ -128,7 +128,7 @@ namespace sat {
todo.push_back(pframe(null_literal, u));
}
}
shuffle<pframe>(todo.size(), todo.c_ptr(), m_rand);
shuffle<pframe>(todo.size(), todo.data(), m_rand);
int dfs_num = 0;
while (!todo.empty()) {
literal u = todo.back().child();

12
src/sat/sat_cut_simplifier.cpp
View file

@ -70,7 +70,7 @@ namespace sat {
IF_VERBOSE(10, verbose_stream() << "validate: " << clause << "\n");
m_assumptions.reset();
for (literal lit : clause) m_assumptions.push_back(~lit);
lbool r = s.check(clause.size(), m_assumptions.c_ptr());
lbool r = s.check(clause.size(), m_assumptions.data());
if (r != l_false) {
IF_VERBOSE(0,
verbose_stream() << "not validated: " << clause << "\n";
@ -131,7 +131,7 @@ namespace sat {
m_lits.reset();
m_lits.append(sz, lits);
for (unsigned i = 0; i < sz; ++i) m_lits[i].neg();
m_aig_cuts.add_node(~head, and_op, sz, m_lits.c_ptr());
m_aig_cuts.add_node(~head, and_op, sz, m_lits.data());
m_stats.m_num_ands++;
}
@ -188,7 +188,7 @@ namespace sat {
std::function<void (literal head, literal_vector const& ands)> on_and =
[&,this](literal head, literal_vector const& ands) {
m_aig_cuts.add_node(head, and_op, ands.size(), ands.c_ptr());
m_aig_cuts.add_node(head, and_op, ands.size(), ands.data());
m_stats.m_xands++;
};
std::function<void (literal head, literal c, literal t, literal e)> on_ite =
@ -228,7 +228,7 @@ namespace sat {
if (i != index)
m_lits.push_back(xors[i]);
}
m_aig_cuts.add_node(head, xor_op, sz, m_lits.c_ptr());
m_aig_cuts.add_node(head, xor_op, sz, m_lits.data());
m_lits.reset();
m_stats.m_xxors++;
};
@ -242,7 +242,7 @@ namespace sat {
[&,this](uint64_t lut, bool_var_vector const& vars, bool_var v) {
m_stats.m_xluts++;
// m_aig_cuts.add_cut(v, lut, vars);
m_aig_cuts.add_node(v, lut, vars.size(), vars.c_ptr());
m_aig_cuts.add_node(v, lut, vars.size(), vars.data());
};
if (s.m_config.m_cut_npn3) {
@ -580,7 +580,7 @@ namespace sat {
for (; i < sz; ++i) {
auto const& clause = clauses[i];
if (clause[0].sign()) {
literal_vector cl(clause.size() - 1, clause.c_ptr() + 1);
literal_vector cl(clause.size() - 1, clause.data() + 1);
clauses.push_back(cl);
s.m_drat.add(cl);
}

4
src/sat/sat_ddfw.cpp
View file

@ -147,7 +147,7 @@ namespace sat {
unsigned trail_sz = s.init_trail_size();
for (unsigned i = 0; i < trail_sz; ++i) {
add(1, s.m_trail.c_ptr() + i);
add(1, s.m_trail.data() + i);
}
unsigned sz = s.m_watches.size();
for (unsigned l_idx = 0; l_idx < sz; ++l_idx) {
@ -171,7 +171,7 @@ namespace sat {
void ddfw::add_assumptions() {
for (unsigned i = 0; i < m_assumptions.size(); ++i) {
add(1, m_assumptions.c_ptr() + i);
add(1, m_assumptions.data() + i);
}
}

4
src/sat/sat_ddfw.h
View file

@ -106,8 +106,8 @@ namespace sat {
public:
use_list(ddfw& p, literal lit):
p(p), i(lit.index()) {}
unsigned const* begin() { return p.m_flat_use_list.c_ptr() + p.m_use_list_index[i]; }
unsigned const* end() { return p.m_flat_use_list.c_ptr() + p.m_use_list_index[i + 1]; }
unsigned const* begin() { return p.m_flat_use_list.data() + p.m_use_list_index[i]; }
unsigned const* end() { return p.m_flat_use_list.data() + p.m_use_list_index[i + 1]; }
};
void flatten_use_list();

8
src/sat/sat_drat.cpp
View file

@ -390,7 +390,7 @@ namespace sat {
for (unsigned i = num_units; i < m_units.size(); ++i) {
m_assignment[m_units[i].var()] = l_undef;
}
units.append(m_units.size() - num_units, m_units.c_ptr() + num_units);
units.append(m_units.size() - num_units, m_units.data() + num_units);
m_units.shrink(num_units);
bool ok = m_inconsistent;
m_inconsistent = false;
@ -517,7 +517,7 @@ namespace sat {
if (j != c.size()) {
lits.append(j, c.begin());
lits.append(c.size() - j - 1, c.begin() + j + 1);
if (!is_drup(lits.size(), lits.c_ptr()))
if (!is_drup(lits.size(), lits.data()))
return false;
lits.resize(n);
}
@ -788,7 +788,7 @@ namespace sat {
}
}
void drat::add(literal_vector const& lits, status st) {
add(lits.size(), lits.c_ptr(), st);
add(lits.size(), lits.data(), st);
}
void drat::add(unsigned sz, literal const* lits, status st) {
@ -822,7 +822,7 @@ namespace sat {
case 1: append(c[0], status::redundant()); break;
default: {
verify(c.size(), c.begin());
clause* cl = m_alloc.mk_clause(c.size(), c.c_ptr(), true);
clause* cl = m_alloc.mk_clause(c.size(), c.data(), true);
append(*cl, status::redundant());
break;
}

4
src/sat/sat_elim_vars.cpp
View file

@ -184,7 +184,7 @@ namespace sat{
s.m_stats.m_mk_ter_clause++;
else
s.m_stats.m_mk_clause++;
clause* cp = s.alloc_clause(c.size(), c.c_ptr(), false);
clause* cp = s.alloc_clause(c.size(), c.data(), false);
s.m_clauses.push_back(cp);
simp.m_use_list.insert(*cp);
if (simp.m_sub_counter > 0)
@ -213,7 +213,7 @@ namespace sat{
}
if (b.is_false()) {
if (lits.size() > 1) {
clause* c = s.alloc_clause(lits.size(), lits.c_ptr(), false);
clause* c = s.alloc_clause(lits.size(), lits.data(), false);
clauses.push_back(c);
}
else {

4
src/sat/sat_local_search.cpp
View file

@ -28,7 +28,7 @@ namespace sat {
flet<bool> _init(m_initializing, true);
m_unsat_stack.reset();
for (unsigned i = 0; i < m_assumptions.size(); ++i) {
add_clause(1, m_assumptions.c_ptr() + i);
add_clause(1, m_assumptions.data() + i);
}
if (m_is_unsat)
return;
@ -388,7 +388,7 @@ namespace sat {
// copy units
unsigned trail_sz = s.init_trail_size();
for (unsigned i = 0; i < trail_sz; ++i) {
add_clause(1, s.m_trail.c_ptr() + i);
add_clause(1, s.m_trail.data() + i);
}
// copy binary clauses

2
src/sat/sat_model_converter.cpp
View file

@ -395,7 +395,7 @@ namespace sat {
unsigned csz = p.first;
literal lit = p.second;
swap(lit.var(), csz, clause);
update_stack.append(csz, clause.c_ptr());
update_stack.append(csz, clause.data());
update_stack.push_back(null_literal);
}
}

6
src/sat/sat_mus.cpp
View file

@ -89,7 +89,7 @@ namespace sat {
flet<unsigned> _restart_bound(s.m_config.m_restart_max, m_max_num_restarts);
scoped_append _sa(mus, core);
mus.push_back(~lit);
is_sat = s.check(mus.size(), mus.c_ptr());
is_sat = s.check(mus.size(), mus.data());
TRACE("sat", tout << "mus: " << mus << "\n";);
}
IF_VERBOSE(1, verbose_stream() << "(sat.mus " << is_sat << ")\n";);
@ -150,7 +150,7 @@ namespace sat {
lbool is_sat = l_true;
if (has_support) {
scoped_append _sa(m_mus, support.to_vector());
is_sat = s.check(m_mus.size(), m_mus.c_ptr());
is_sat = s.check(m_mus.size(), m_mus.data());
switch (is_sat) {
case l_false: {
literal_set core(s.get_core());
@ -230,7 +230,7 @@ namespace sat {
}
void mus::verify_core(literal_vector const& core) {
lbool is_sat = s.check(core.size(), core.c_ptr());
lbool is_sat = s.check(core.size(), core.data());
IF_VERBOSE(3, verbose_stream() << "core verification: " << is_sat << " " << core << "\n";);
}

4
src/sat/sat_parallel.cpp
View file

@ -130,7 +130,7 @@ namespace sat {
lock_guard lock(m_mux);
if (limit < m_units.size()) {
// this might repeat some literals.
out.append(m_units.size() - limit, m_units.c_ptr() + limit);
out.append(m_units.size() - limit, m_units.data() + limit);
}
for (unsigned i = 0; i < in.size(); ++i) {
literal lit = in[i];
@ -192,7 +192,7 @@ namespace sat {
IF_VERBOSE(3, verbose_stream() << s.m_par_id << ": retrieve " << m_lits << "\n";);
SASSERT(n >= 2);
if (usable_clause) {
s.mk_clause_core(m_lits.size(), m_lits.c_ptr(), sat::status::redundant());
s.mk_clause_core(m_lits.size(), m_lits.data(), sat::status::redundant());
}
}
}

2
src/sat/sat_parallel.h
View file

@ -39,7 +39,7 @@ namespace sat {
void next(unsigned& index);
unsigned get_owner(unsigned index) const { return m_vectors[index]; }
unsigned get_length(unsigned index) const { return m_vectors[index+1]; }
unsigned const* get_ptr(unsigned index) const { return m_vectors.c_ptr() + index + 2; }
unsigned const* get_ptr(unsigned index) const { return m_vectors.data() + index + 2; }
public:
vector_pool() {}
void reserve(unsigned num_owners, unsigned sz);

2
src/sat/sat_prob.cpp
View file

@ -126,7 +126,7 @@ namespace sat {
m_values.reserve(s.num_vars(), false);
unsigned trail_sz = s.init_trail_size();
for (unsigned i = 0; i < trail_sz; ++i) {
add(1, s.m_trail.c_ptr() + i);
add(1, s.m_trail.data() + i);
}
unsigned sz = s.m_watches.size();
for (unsigned l_idx = 0; l_idx < sz; ++l_idx) {

4
src/sat/sat_prob.h
View file

@ -80,8 +80,8 @@ namespace sat {
public:
use_list(prob& p, literal lit):
p(p), i(lit.index()) {}
unsigned const* begin() { return p.m_flat_use_list.c_ptr() + p.m_use_list_index[i]; }
unsigned const* end() { return p.m_flat_use_list.c_ptr() + p.m_use_list_index[i+1]; }
unsigned const* begin() { return p.m_flat_use_list.data() + p.m_use_list_index[i]; }
unsigned const* end() { return p.m_flat_use_list.data() + p.m_use_list_index[i+1]; }
};
void flatten_use_list();

4
src/sat/sat_simplifier.cpp
View file

@ -1376,7 +1376,7 @@ namespace sat {
bool first = true;
unsigned sz = 0, sz0 = m_covered_clause.size();
for (literal l : m_covered_clause) s.mark_visited(l);
shuffle<literal>(m_covered_clause.size(), m_covered_clause.c_ptr(), s.s.m_rand);
shuffle<literal>(m_covered_clause.size(), m_covered_clause.data(), s.s.m_rand);
m_tautology.reset();
m_mc.stackv().reset();
m_ala_qhead = 0;
@ -2003,7 +2003,7 @@ namespace sat {
s.m_stats.m_mk_ter_clause++;
else
s.m_stats.m_mk_clause++;
clause * new_c = s.alloc_clause(m_new_cls.size(), m_new_cls.c_ptr(), false);
clause * new_c = s.alloc_clause(m_new_cls.size(), m_new_cls.data(), false);
if (s.m_config.m_drat) s.m_drat.add(*new_c, status::redundant());
s.m_clauses.push_back(new_c);

24
src/sat/sat_solver.cpp
View file

@ -220,7 +220,7 @@ namespace sat {
if (c->glue() <= 2 || (c->size() <= 40 && c->glue() <= 8) || copy_learned) {
buffer.reset();
for (literal l : *c) buffer.push_back(l);
clause* c1 = mk_clause_core(buffer.size(), buffer.c_ptr(), sat::status::redundant());
clause* c1 = mk_clause_core(buffer.size(), buffer.data(), sat::status::redundant());
if (c1) {
++num_learned;
c1->set_glue(c->glue());
@ -358,7 +358,7 @@ namespace sat {
m_aux_literals.reset();
m_aux_literals.append(num_lits, lits);
m_aux_literals.append(m_user_scope_literals);
return mk_clause_core(m_aux_literals.size(), m_aux_literals.c_ptr(), st);
return mk_clause_core(m_aux_literals.size(), m_aux_literals.data(), st);
}
}
@ -983,7 +983,7 @@ namespace sat {
__builtin_prefetch((const char*)((m_watches[l.index()].c_ptr())));
#else
#if !defined(_M_ARM) && !defined(_M_ARM64)
_mm_prefetch((const char*)((m_watches[l.index()].c_ptr())), _MM_HINT_T1);
_mm_prefetch((const char*)((m_watches[l.index()].data())), _MM_HINT_T1);
#endif
#endif
}
@ -1402,7 +1402,7 @@ namespace sat {
m_local_search->add(*this);
m_local_search->updt_params(m_params);
scoped_rl.push_child(&(m_local_search->rlimit()));
lbool r = m_local_search->check(_lits.size(), _lits.c_ptr(), nullptr);
lbool r = m_local_search->check(_lits.size(), _lits.data(), nullptr);
if (r == l_true) {
m_model = m_local_search->get_model();
m_model_is_current = true;
@ -2589,7 +2589,7 @@ namespace sat {
}
}
unsigned glue = num_diff_levels(m_lemma.size(), m_lemma.c_ptr());
unsigned glue = num_diff_levels(m_lemma.size(), m_lemma.data());
m_fast_glue_avg.update(glue);
m_slow_glue_avg.update(glue);
@ -2605,7 +2605,7 @@ namespace sat {
++m_stats.m_backtracks;
pop_reinit(m_scope_lvl - backtrack_lvl + 1);
}
clause * lemma = mk_clause_core(m_lemma.size(), m_lemma.c_ptr(), sat::status::redundant());
clause * lemma = mk_clause_core(m_lemma.size(), m_lemma.data(), sat::status::redundant());
if (lemma) {
lemma->set_glue(glue);
}
@ -3557,7 +3557,7 @@ namespace sat {
tout << "clauses to reinit: " << (m_clauses_to_reinit.size() - old_sz) << "\n";
tout << "new level: " << new_lvl << "\n";
tout << "vars to reinit: " << m_vars_to_reinit << "\n";
tout << "free vars: " << bool_var_vector(m_free_vars.size() - free_vars_head, m_free_vars.c_ptr() + free_vars_head) << "\n";
tout << "free vars: " << bool_var_vector(m_free_vars.size() - free_vars_head, m_free_vars.data() + free_vars_head) << "\n";
for (unsigned i = m_clauses_to_reinit.size(); i-- > old_sz; )
tout << "reinit: " << m_clauses_to_reinit[i] << "\n";
display(tout););
@ -4234,7 +4234,7 @@ namespace sat {
for (literal lit : gamma) {
sat::literal_vector asms1(asms);
asms1.push_back(~lit);
lbool r = s.check(asms1.size(), asms1.c_ptr());
lbool r = s.check(asms1.size(), asms1.data());
if (r == l_false) {
conseq.push_back(s.get_core());
}
@ -4258,7 +4258,7 @@ namespace sat {
while (true) {
sat::literal_vector asms1(asms);
asms1.append(omegaN);
lbool r = s.check(asms1.size(), asms1.c_ptr());
lbool r = s.check(asms1.size(), asms1.data());
if (r == l_true) {
IF_VERBOSE(1, verbose_stream() << "(sat) " << omegaN << "\n";);
prune_unfixed(lambda, s.get_model());
@ -4308,7 +4308,7 @@ namespace sat {
return get_bounded_consequences(asms, vars, conseq);
}
if (!m_model_is_current) {
is_sat = check(asms.size(), asms.c_ptr());
is_sat = check(asms.size(), asms.data());
}
if (is_sat != l_true) {
return is_sat;
@ -4379,7 +4379,7 @@ namespace sat {
init_assumptions(1, &lit);
}
else {
init_assumptions(asms.size(), asms.c_ptr());
init_assumptions(asms.size(), asms.data());
}
propagate(false);
if (check_inconsistent()) return l_false;
@ -4438,7 +4438,7 @@ namespace sat {
init_assumptions(1, &lit);
}
else {
init_assumptions(asms.size(), asms.c_ptr());
init_assumptions(asms.size(), asms.data());
}
propagate(false);
if (check_inconsistent()) return l_false;

4
src/sat/sat_solver.h
View file

@ -264,7 +264,7 @@ namespace sat {
bool_var mk_var(bool ext = false, bool dvar = true);
clause* mk_clause(literal_vector const& lits, sat::status st = sat::status::asserted()) { return mk_clause(lits.size(), lits.c_ptr(), st); }
clause* mk_clause(literal_vector const& lits, sat::status st = sat::status::asserted()) { return mk_clause(lits.size(), lits.data(), st); }
clause* mk_clause(unsigned num_lits, literal * lits, sat::status st = sat::status::asserted());
clause* mk_clause(literal l1, literal l2, sat::status st = sat::status::asserted());
clause* mk_clause(literal l1, literal l2, literal l3, sat::status st = sat::status::asserted());
@ -284,7 +284,7 @@ namespace sat {
bool memory_pressure();
void del_clause(clause & c);
clause * mk_clause_core(unsigned num_lits, literal * lits, sat::status st);
clause * mk_clause_core(literal_vector const& lits) { return mk_clause_core(lits.size(), lits.c_ptr()); }
clause * mk_clause_core(literal_vector const& lits) { return mk_clause_core(lits.size(), lits.data()); }
clause * mk_clause_core(unsigned num_lits, literal * lits) { return mk_clause_core(num_lits, lits, sat::status::asserted()); }
void mk_clause_core(literal l1, literal l2) { literal lits[2] = { l1, l2 }; mk_clause_core(2, lits); }
void mk_bin_clause(literal l1, literal l2, sat::status st);

16
src/sat/sat_solver/inc_sat_solver.cpp
View file

@ -165,13 +165,13 @@ public:
asms.push_back(a);
}
VERIFY(l_true == internalize_formulas());
VERIFY(l_true == internalize_assumptions(sz, asms.c_ptr()));
VERIFY(l_true == internalize_assumptions(sz, asms.data()));
svector<unsigned> nweights;
for (unsigned i = 0; i < m_asms.size(); ++i) {
nweights.push_back((unsigned) m_weights[i]);
}
m_weights.reset();
m_solver.display_wcnf(out, m_asms.size(), m_asms.c_ptr(), nweights.c_ptr());
m_solver.display_wcnf(out, m_asms.size(), m_asms.data(), nweights.data());
}
bool is_literal(expr* e) const {
@ -204,7 +204,7 @@ public:
m_dep2asm.reset();
lbool r = internalize_formulas();
if (r != l_true) return r;
r = internalize_assumptions(sz, _assumptions.c_ptr());
r = internalize_assumptions(sz, _assumptions.data());
if (r != l_true) return r;
init_reason_unknown();
@ -212,7 +212,7 @@ public:
bool reason_set = false;
try {
// IF_VERBOSE(0, m_solver.display(verbose_stream()));
r = m_solver.check(m_asms.size(), m_asms.c_ptr());
r = m_solver.check(m_asms.size(), m_asms.data());
}
catch (z3_exception& ex) {
IF_VERBOSE(1, verbose_stream() << "exception: " << ex.msg() << "\n";);
@ -337,7 +337,7 @@ public:
expr_ref_vector args(m);
args.push_back(::mk_not(m, a));
args.append(to_app(t)->get_num_args(), to_app(t)->get_args());
assert_expr_core(m.mk_or(args.size(), args.c_ptr()));
assert_expr_core(m.mk_or(args.size(), args.data()));
}
else {
m_is_cnf = false;
@ -377,7 +377,7 @@ public:
}
void get_unsat_core(expr_ref_vector & r) override {
r.reset();
r.append(m_core.size(), m_core.c_ptr());
r.append(m_core.size(), m_core.data());
}
void get_levels(ptr_vector<expr> const& vars, unsigned_vector& depth) override {
@ -475,7 +475,7 @@ public:
if (r != l_true) return r;
r = internalize_vars(vars, bvars);
if (r != l_true) return r;
r = internalize_assumptions(assumptions.size(), assumptions.c_ptr());
r = internalize_assumptions(assumptions.size(), assumptions.data());
if (r != l_true) return r;
r = m_solver.get_consequences(m_asms, bvars, lconseq);
if (r == l_false) {
@ -1090,7 +1090,7 @@ void inc_sat_display(std::ostream& out, solver& _s, unsigned sz, expr*const* sof
}
weights.push_back(_weights[i].get_unsigned());
}
s.display_weighted(out, sz, soft, weights.c_ptr());
s.display_weighted(out, sz, soft, weights.data());
}

2
src/sat/sat_types.h
View file

@ -234,7 +234,7 @@ namespace sat {
}
inline std::ostream & operator<<(std::ostream & out, literal_vector const & ls) {
return out << mk_lits_pp(ls.size(), ls.c_ptr());
return out << mk_lits_pp(ls.size(), ls.data());
}
class i_local_search {

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);

8
src/sat/tactic/goal2sat.cpp
View file

@ -419,7 +419,7 @@ struct goal2sat::imp : public sat::sat_internalizer {
}
}
else {
mk_root_clause(m_result_stack.size(), m_result_stack.c_ptr());
mk_root_clause(m_result_stack.size(), m_result_stack.data());
}
m_result_stack.shrink(old_sz);
}
@ -442,7 +442,7 @@ struct goal2sat::imp : public sat::sat_internalizer {
// I have to execute it after the binary mk_clause above.
mk_clause(num+1, lits);
if (aig())
aig()->add_or(l, num, aig_lits.c_ptr());
aig()->add_or(l, num, aig_lits.data());
m_solver.set_phase(~l);
m_result_stack.shrink(old_sz);
@ -463,7 +463,7 @@ struct goal2sat::imp : public sat::sat_internalizer {
for (unsigned i = 0; i < num; ++i) {
m_result_stack[i].neg();
}
mk_root_clause(m_result_stack.size(), m_result_stack.c_ptr());
mk_root_clause(m_result_stack.size(), m_result_stack.data());
}
else {
for (unsigned i = 0; i < num; ++i) {
@ -495,7 +495,7 @@ struct goal2sat::imp : public sat::sat_internalizer {
}
mk_clause(num+1, lits);
if (aig()) {
aig()->add_and(l, num, aig_lits.c_ptr());
aig()->add_and(l, num, aig_lits.data());
}
m_solver.set_phase(l);
if (sign)

2
src/sat/tactic/sat_tactic.cpp
View file

@ -63,7 +63,7 @@ class sat_tactic : public tactic {
IF_VERBOSE(TACTIC_VERBOSITY_LVL, m_solver->display_status(verbose_stream()););
TRACE("sat_dimacs", m_solver->display_dimacs(tout););
dep2assumptions(dep2asm, assumptions);
lbool r = m_solver->check(assumptions.size(), assumptions.c_ptr());
lbool r = m_solver->check(assumptions.size(), assumptions.data());
TRACE("sat", tout << "result of checking: " << r << " ";
if (r == l_undef) tout << m_solver->get_reason_unknown(); tout << "\n";);
if (r == l_false) {