mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-11-04 13:29:11 +00:00
Code Activity

bool_vector, some spacer tidy

Browse source 
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner 2020-04-05 12:59:04 -07:00
parent 2ed26e8e73
commit b889b110ee
106 changed files with 239 additions and 266 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/ast/ast.cpp
View file

@ -3110,7 +3110,7 @@ proof * ast_manager::mk_unit_resolution(unsigned num_proofs, proof * const * pro
app const * cls = to_app(f1);
unsigned num_args = cls->get_num_args();
#ifdef Z3DEBUG
svector<bool> found;
bool_vector found;
#endif
ast_mark mark;
for (unsigned i = 0; i < num_args; i++) {

2
src/ast/expr2polynomial.h
View file

@ -100,7 +100,7 @@ protected:
};
class default_expr2polynomial : public expr2polynomial {
svector<bool> m_is_int;
bool_vector m_is_int;
public:
default_expr2polynomial(ast_manager & am, polynomial::manager & pm);
~default_expr2polynomial() override;

6
src/ast/macros/macro_util.h
View file

@ -34,9 +34,9 @@ public:
ptr_vector<func_decl> m_fs;
expr_ref_vector m_defs;
expr_ref_vector m_conds;
svector<bool> m_ineq; // true if the macro is based on an inequality instead of equality.
svector<bool> m_satisfy;
svector<bool> m_hint; // macro did not contain all universal variables in the quantifier.
bool_vector m_ineq; // true if the macro is based on an inequality instead of equality.
bool_vector m_satisfy;
bool_vector m_hint; // macro did not contain all universal variables in the quantifier.
friend class macro_util;
ast_manager & get_manager() { return m_conds.get_manager(); }

2
src/ast/static_features.h
View file

@ -112,7 +112,7 @@ struct static_features {
u_map<unsigned> m_expr2formula_depth;
unsigned m_num_theories;
svector<bool> m_theories; // mapping family_id -> bool
bool_vector m_theories; // mapping family_id -> bool
symbol m_label_sym;
symbol m_pattern_sym;

2
src/math/automata/symbolic_automata_def.h
View file

@ -440,7 +440,7 @@ typename symbolic_automata<T, M>::automaton_t* symbolic_automata<T, M>::mk_produ
inv[mv.dst()].push_back(move_t(m, mv.dst(), mv.src(), mv.t()));
}
svector<bool> back_reachable(n, false);
bool_vector back_reachable(n, false);
for (unsigned f : final) {
back_reachable[f] = true;
}

2
src/math/dd/dd_bdd.cpp
View file

@ -748,7 +748,7 @@ namespace dd {
void bdd_manager::gc() {
m_free_nodes.reset();
IF_VERBOSE(13, verbose_stream() << "(bdd :gc " << m_nodes.size() << ")\n";);
svector<bool> reachable(m_nodes.size(), false);
bool_vector reachable(m_nodes.size(), false);
for (unsigned i = m_bdd_stack.size(); i-- > 0; ) {
reachable[m_bdd_stack[i]] = true;
m_todo.push_back(m_bdd_stack[i]);

6
src/math/dd/dd_pdd.cpp
View file

@ -952,12 +952,12 @@ namespace dd {
}
bool pdd_manager::is_reachable(PDD p) {
svector<bool> reachable(m_nodes.size(), false);
bool_vector reachable(m_nodes.size(), false);
compute_reachable(reachable);
return reachable[p];
}
void pdd_manager::compute_reachable(svector<bool>& reachable) {
void pdd_manager::compute_reachable(bool_vector& reachable) {
for (unsigned i = m_pdd_stack.size(); i-- > 0; ) {
reachable[m_pdd_stack[i]] = true;
m_todo.push_back(m_pdd_stack[i]);
@ -994,7 +994,7 @@ namespace dd {
m_free_nodes.reset();
SASSERT(well_formed());
IF_VERBOSE(13, verbose_stream() << "(pdd :gc " << m_nodes.size() << ")\n";);
svector<bool> reachable(m_nodes.size(), false);
bool_vector reachable(m_nodes.size(), false);
compute_reachable(reachable);
for (unsigned i = m_nodes.size(); i-- > pdd_no_op; ) {
if (!reachable[i]) {

2
src/math/dd/dd_pdd.h
View file

@ -227,7 +227,7 @@ namespace dd {
bool var_is_leaf(PDD p, unsigned v);
bool is_reachable(PDD p);
void compute_reachable(svector<bool>& reachable);
void compute_reachable(bool_vector& reachable);
void try_gc();
void reserve_var(unsigned v);
bool well_formed();

2
src/math/hilbert/hilbert_basis.h
View file

@ -88,7 +88,7 @@ class hilbert_basis {
reslimit& m_limit;
vector<num_vector> m_ineqs; // set of asserted inequalities
svector<bool> m_iseq; // inequalities that are equalities
bool_vector m_iseq; // inequalities that are equalities
num_vector m_store; // store of vectors
svector<offset_t> m_basis; // vector of current basis
svector<offset_t> m_free_list; // free list of unused storage

2
src/math/lp/factorization.cpp
View file

@ -75,7 +75,7 @@ void const_iterator_mon::advance_mask() {
const_iterator_mon::self_type const_iterator_mon::operator++() { self_type i = *this; operator++(1); return i; }
const_iterator_mon::self_type const_iterator_mon::operator++(int) { advance_mask(); return *this; }
const_iterator_mon::const_iterator_mon(const svector<bool>& mask, const factorization_factory *f) :
const_iterator_mon::const_iterator_mon(const bool_vector& mask, const factorization_factory *f) :
m_mask(mask),
m_ff(f) ,
m_full_factorization_returned(false)

12
src/math/lp/factorization.h
View file

@ -77,7 +77,7 @@ public:
struct const_iterator_mon {
// fields
svector<bool> m_mask;
bool_vector m_mask;
const factorization_factory * m_ff;
bool m_full_factorization_returned;
@ -97,7 +97,7 @@ struct const_iterator_mon {
self_type operator++();
self_type operator++(int);
const_iterator_mon(const svector<bool>& mask, const factorization_factory *f);
const_iterator_mon(const bool_vector& mask, const factorization_factory *f);
bool operator==(const self_type &other) const;
bool operator!=(const self_type &other) const;
@ -119,15 +119,15 @@ struct factorization_factory {
m_vars(vars), m_monic(m) {
}
svector<bool> get_mask() const {
bool_vector get_mask() const {
// we keep the last element always in the first factor to avoid
// repeating a pair twice, that is why m_mask is shorter by one then m_vars
return
m_vars.size() != 2 ?
svector<bool>(m_vars.size() - 1, false)
bool_vector(m_vars.size() - 1, false)
:
svector<bool>(1, true); // init mask as in the end() since the full iteration will do the job
bool_vector(1, true); // init mask as in the end() since the full iteration will do the job
}
const_iterator_mon begin() const {
@ -135,7 +135,7 @@ struct factorization_factory {
}
const_iterator_mon end() const {
svector<bool> mask(m_vars.size() - 1, true);
bool_vector mask(m_vars.size() - 1, true);
auto it = const_iterator_mon(mask, this);
it.m_full_factorization_returned = true;
return it;

2
src/math/lp/var_eqs.h
View file

@ -74,7 +74,7 @@ class var_eqs {
trail_stack<var_eqs> m_stack;
mutable svector<var_frame> m_todo;
mutable svector<bool> m_marked;
mutable bool_vector m_marked;
mutable unsigned_vector m_marked_trail;
mutable svector<eq_justification> m_justtrail;

4
src/math/polynomial/polynomial.cpp
View file

@ -1272,7 +1272,7 @@ namespace polynomial {
SASSERT(sz == num_vars());
DEBUG_CODE({
// check whether xs is really a permutation
svector<bool> found;
bool_vector found;
found.resize(num_vars(), false);
for (unsigned i = 0; i < sz; i++) {
SASSERT(xs[i] < num_vars());
@ -3218,7 +3218,7 @@ namespace polynomial {
}
};
svector<bool> m_found_vars;
bool_vector m_found_vars;
void vars(polynomial const * p, var_vector & xs) {
xs.reset();
m_found_vars.reserve(num_vars(), false);

2
src/math/polynomial/upolynomial_factorization_int.h
View file

@ -138,7 +138,7 @@ namespace upolynomial {
// the factors to select from
factors_type const & m_factors;
// which factors are enabled
svector<bool> m_enabled;
bool_vector m_enabled;
// the size of the current selection
int m_current_size;
// the current selection: indices at positions < m_current_size, other values are maxed out

2
src/math/simplex/model_based_opt.h
View file

@ -85,7 +85,7 @@ namespace opt {
static const unsigned m_objective_id = 0;
vector<unsigned_vector> m_var2row_ids;
vector<rational> m_var2value;
svector<bool> m_var2is_int;
bool_vector m_var2is_int;
vector<var> m_new_vars;
unsigned_vector m_lub, m_glb, m_mod;
unsigned_vector m_above, m_below;

4
src/math/simplex/network_flow_def.h
View file

@ -224,7 +224,7 @@ namespace smt {
node src = m_graph.get_source(m_enter_id);
node tgt = m_graph.get_target(m_enter_id);
svector<edge_id> path;
svector<bool> against;
bool_vector against;
m_tree->get_path(src, tgt, path, against);
SASSERT(path.size() >= 1);
for (unsigned i = 0; i < path.size(); ++i) {
@ -241,7 +241,7 @@ namespace smt {
m_delta.set_invalid();
edge_id leave_id = null_edge_id;
svector<edge_id> path;
svector<bool> against;
bool_vector against;
m_tree->get_path(src, tgt, path, against);
SASSERT(path.size() >= 1);
for (unsigned i = 0; i < path.size(); ++i) {

2
src/math/subpaving/subpaving_t.h
View file

@ -476,7 +476,7 @@ private:
interval_manager m_im;
scoped_numeral_vector m_num_buffer;
svector<bool> m_is_int;
bool_vector m_is_int;
ptr_vector<definition> m_defs;
vector<watch_list> m_wlist;

8
src/muz/base/dl_rule.cpp
View file

@ -153,7 +153,7 @@ namespace datalog {
mk_rule_core(fml1, pr, rules, name);
}
void rule_manager::mk_negations(app_ref_vector& body, svector<bool>& is_negated) {
void rule_manager::mk_negations(app_ref_vector& body, bool_vector& is_negated) {
for (unsigned i = 0; i < body.size(); ++i) {
expr* e = body[i].get(), *e1;
if (m.is_not(e, e1) && m_ctx.is_predicate(e1)) {
@ -628,7 +628,7 @@ namespace datalog {
}
if (change) {
app_ref_vector tail(m);
svector<bool> tail_neg;
bool_vector tail_neg;
for (unsigned i = 0; i < ut_len; ++i) {
tail.push_back(r->get_tail(i));
tail_neg.push_back(r->is_neg_tail(i));
@ -660,7 +660,7 @@ namespace datalog {
var_counter vctr;
app_ref_vector tail(m);
svector<bool> tail_neg;
bool_vector tail_neg;
app_ref head(r->get_head(), m);
vctr.count_vars(head);
@ -811,7 +811,7 @@ namespace datalog {
expr_ref tmp(m);
app_ref new_head(m);
app_ref_vector new_tail(m);
svector<bool> tail_neg;
bool_vector tail_neg;
var_subst vs(m, false);
tmp = vs(r->get_head(), sz, es);
new_head = to_app(tmp);

4
src/muz/base/dl_rule.h
View file

@ -124,7 +124,7 @@ namespace datalog {
app_ref_vector m_body;
app_ref m_head;
expr_ref_vector m_args;
svector<bool> m_neg;
bool_vector m_neg;
hnf m_hnf;
qe_lite m_qe;
label_rewriter m_rwr;
@ -158,7 +158,7 @@ namespace datalog {
void bind_variables(expr* fml, bool is_forall, expr_ref& result);
void mk_negations(app_ref_vector& body, svector<bool>& is_negated);
void mk_negations(app_ref_vector& body, bool_vector& is_negated);
void mk_rule_core(expr* fml, proof* p, rule_set& rules, symbol const& name);

2
src/muz/base/dl_rule_transformer.cpp
View file

@ -132,7 +132,7 @@ namespace datalog {
//
//------------------------------
void rule_transformer::plugin::remove_duplicate_tails(app_ref_vector& tail, svector<bool>& tail_neg)
void rule_transformer::plugin::remove_duplicate_tails(app_ref_vector& tail, bool_vector& tail_neg)
{
//one set for positive and one for negative
obj_hashtable<app> tail_apps[2];

2
src/muz/base/dl_rule_transformer.h
View file

@ -108,7 +108,7 @@ namespace datalog {
/**
Removes duplicate tails.
*/
static void remove_duplicate_tails(app_ref_vector& tail, svector<bool>& tail_neg);
static void remove_duplicate_tails(app_ref_vector& tail, bool_vector& tail_neg);
};
};

4
src/muz/ddnf/ddnf.cpp
View file

@ -135,7 +135,7 @@ namespace datalog {
ddnf_node::hash m_hash;
ddnf_node::eq m_eq;
ddnf_nodes m_nodes;
svector<bool> m_marked;
bool_vector m_marked;
stats m_stats;
public:
ddnf_mgr(unsigned n): m_noderefs(*this), m_internalized(false), m_tbv(n),
@ -338,7 +338,7 @@ namespace datalog {
}
ptr_vector<ddnf_node> todo;
todo.push_back(m_root);
svector<bool> done(m_noderefs.size(), false);
bool_vector done(m_noderefs.size(), false);
while (!todo.empty()) {
ddnf_node& n = *todo.back();
if (done[n.get_id()]) {

2
src/muz/fp/datalog_parser.cpp
View file

@ -724,7 +724,7 @@ protected:
dtoken parse_body(app* head) {
app_ref_vector body(m_manager);
svector<bool> polarity_vect;
bool_vector polarity_vect;
dtoken tok = m_lexer->next_token();
while (tok != TK_ERROR && tok != TK_EOS) {
if (tok == TK_PERIOD) {

2
src/muz/rel/dl_base.h
View file

@ -582,7 +582,7 @@ namespace datalog {
const unsigned_vector m_cols2;
bool m_all_neg_bound; //all columns are bound at least once
bool m_overlap; //one column in negated table is bound multiple times
svector<bool> m_bound;
bool_vector m_bound;
convenient_negation_filter_fn(const base_object & tgt, const base_object & neg_t,
unsigned joined_col_cnt, const unsigned * t_cols, const unsigned * negated_cols)

20
src/muz/rel/dl_finite_product_relation.cpp
View file

@ -92,12 +92,12 @@ namespace datalog {
family_id finite_product_relation_plugin::get_relation_kind(finite_product_relation & r,
const bool * table_columns) {
const relation_signature & sig = r.get_signature();
svector<bool> table_cols_vect(sig.size(), table_columns);
bool_vector table_cols_vect(sig.size(), table_columns);
return m_spec_store.get_relation_kind(sig, rel_spec(table_cols_vect));
}
void finite_product_relation_plugin::get_all_possible_table_columns(relation_manager & rmgr,
const relation_signature & s, svector<bool> & table_columns) {
const relation_signature & s, bool_vector & table_columns) {
SASSERT(table_columns.empty());
unsigned s_sz = s.size();
for(unsigned i=0; i<s_sz; i++) {
@ -148,7 +148,7 @@ namespace datalog {
}
relation_base * finite_product_relation_plugin::mk_empty(const relation_signature & s) {
svector<bool> table_columns;
bool_vector table_columns;
get_all_possible_table_columns(s, table_columns);
#ifndef _EXTERNAL_RELEASE
unsigned s_sz = s.size();
@ -275,7 +275,7 @@ namespace datalog {
SASSERT(join_fun);
scoped_rel<table_base> res_table = (*join_fun)(t, *idx_singleton);
svector<bool> table_cols(sig.size(), true);
bool_vector table_cols(sig.size(), true);
finite_product_relation * res = mk_empty(sig, table_cols.c_ptr());
//this one does not need to be deleted -- it will be taken over by \c res in the \c init function
@ -301,7 +301,7 @@ namespace datalog {
idx_singleton_fact.push_back(0);
idx_singleton->add_fact(idx_singleton_fact);
svector<bool> table_cols(sig.size(), false);
bool_vector table_cols(sig.size(), false);
finite_product_relation * res = mk_empty(sig, table_cols.c_ptr());
relation_vector rels;
@ -378,7 +378,7 @@ namespace datalog {
scoped_ptr<table_transformer_fn> m_tjoined_second_rel_remover;
//determines which columns of the result are table columns and which are in the inner relation
svector<bool> m_res_table_columns;
bool_vector m_res_table_columns;
public:
class join_maker : public table_row_mutator_fn {
@ -529,7 +529,7 @@ namespace datalog {
scoped_ptr<relation_union_fn> m_inner_rel_union;
//determines which columns of the result are table columns and which are in the inner relation
svector<bool> m_res_table_columns;
bool_vector m_res_table_columns;
public:
project_fn(const finite_product_relation & r, unsigned col_cnt, const unsigned * removed_cols)
: convenient_relation_project_fn(r.get_signature(), col_cnt, removed_cols) {
@ -665,7 +665,7 @@ namespace datalog {
unsigned_vector m_rel_permutation;
//determines which columns of the result are table columns and which are in the inner relation
svector<bool> m_res_table_columns;
bool_vector m_res_table_columns;
public:
rename_fn(const finite_product_relation & r, unsigned cycle_len, const unsigned * permutation_cycle)
: convenient_relation_rename_fn(r.get_signature(), cycle_len, permutation_cycle) {
@ -2156,7 +2156,7 @@ namespace datalog {
return true;
}
unsigned sig_sz = rels.back()->get_signature().size();
svector<bool> table_cols(sig_sz, true);
bool_vector table_cols(sig_sz, true);
ptr_vector<finite_product_relation>::iterator it = rels.begin();
ptr_vector<finite_product_relation>::iterator end = rels.end();
@ -2221,7 +2221,7 @@ namespace datalog {
scoped_rel<relation_base> moved_cols_trel =
rmgr.get_table_relation_plugin(moved_cols_table->get_plugin()).mk_from_table(moved_cols_sig, moved_cols_table);
svector<bool> moved_cols_table_flags(moved_cols_sig.size(), false);
bool_vector moved_cols_table_flags(moved_cols_sig.size(), false);
scoped_rel<finite_product_relation> moved_cols_rel = get_plugin().mk_empty(moved_cols_sig,
moved_cols_table_flags.c_ptr());

8
src/muz/rel/dl_finite_product_relation.h
View file

@ -36,10 +36,10 @@ namespace datalog {
public:
struct rel_spec {
family_id m_inner_kind; //null_family_id means we don't care about the kind
svector<bool> m_table_cols;
bool_vector m_table_cols;
rel_spec() : m_inner_kind(null_family_id) {}
rel_spec(const svector<bool>& table_cols)
rel_spec(const bool_vector& table_cols)
: m_inner_kind(null_family_id), m_table_cols(table_cols) {}
bool operator==(const rel_spec & o) const {
@ -74,8 +74,8 @@ namespace datalog {
family_id get_relation_kind(finite_product_relation & r, const bool * table_columns);
static void get_all_possible_table_columns(relation_manager & rmgr, const relation_signature & s,
svector<bool> & table_columns);
void get_all_possible_table_columns(const relation_signature & s, svector<bool> & table_columns) {
bool_vector & table_columns);
void get_all_possible_table_columns(const relation_signature & s, bool_vector & table_columns) {
get_all_possible_table_columns(get_manager(), s, table_columns);
}

6
src/muz/rel/dl_mk_explanations.cpp
View file

@ -644,10 +644,10 @@ namespace datalog {
relation_signature sig;
rmgr.from_predicate(e_decl, sig);
svector<bool> inner_sieve(sz-1, true);
bool_vector inner_sieve(sz-1, true);
inner_sieve.push_back(false);
svector<bool> expl_sieve(sz-1, false);
bool_vector expl_sieve(sz-1, false);
expl_sieve.push_back(true);
sieve_relation_plugin & sieve_plugin = sieve_relation_plugin::get_plugin(rmgr);
@ -715,7 +715,7 @@ namespace datalog {
app_ref e_head(get_e_lit(r->get_head(), head_var), m_manager);
app_ref_vector e_tail(m_manager);
svector<bool> neg_flags;
bool_vector neg_flags;
unsigned pos_tail_sz = r->get_positive_tail_size();
for (unsigned i=0; i<pos_tail_sz; i++) {
unsigned e_var = next_var++;

2
src/muz/rel/dl_mk_similarity_compressor.cpp
View file

@ -373,7 +373,7 @@ namespace datalog {
app * new_head = r->get_head();
ptr_vector<app> new_tail;
svector<bool> new_negs;
bool_vector new_negs;
unsigned tail_sz = r->get_tail_size();
for (unsigned i=0; i<tail_sz; i++) {
new_tail.push_back(r->get_tail(i));

2
src/muz/rel/dl_mk_simple_joins.cpp
View file

@ -711,7 +711,7 @@ namespace datalog {
}
ptr_vector<app> tail(content);
svector<bool> negs(tail.size(), false);
bool_vector negs(tail.size(), false);
unsigned or_len = orig_r->get_tail_size();
for (unsigned i=orig_r->get_positive_tail_size(); i < or_len; i++) {
tail.push_back(orig_r->get_tail(i));

22
src/muz/rel/dl_sieve_relation.cpp
View file

@ -149,7 +149,7 @@ namespace datalog {
}
void sieve_relation_plugin::extract_inner_columns(const relation_signature & s, relation_plugin & inner,
svector<bool> & inner_columns) {
bool_vector & inner_columns) {
SASSERT(inner_columns.size()==s.size());
unsigned n = s.size();
relation_signature inner_sig_singleton;
@ -168,7 +168,7 @@ namespace datalog {
}
void sieve_relation_plugin::collect_inner_signature(const relation_signature & s,
const svector<bool> & inner_columns, relation_signature & inner_sig) {
const bool_vector & inner_columns, relation_signature & inner_sig) {
SASSERT(inner_columns.size()==s.size());
inner_sig.reset();
unsigned n = s.size();
@ -183,7 +183,7 @@ namespace datalog {
relation_signature & inner_sig) {
UNREACHABLE();
#if 0
svector<bool> inner_cols(s.size());
bool_vector inner_cols(s.size());
extract_inner_columns(s, inner_cols.c_ptr());
collect_inner_signature(s, inner_cols, inner_sig);
#endif
@ -228,7 +228,7 @@ namespace datalog {
UNREACHABLE();
return nullptr;
#if 0
svector<bool> inner_cols(s.size());
bool_vector inner_cols(s.size());
extract_inner_columns(s, inner_cols.c_ptr());
return mk_empty(s, inner_cols.c_ptr());
#endif
@ -236,7 +236,7 @@ namespace datalog {
sieve_relation * sieve_relation_plugin::mk_empty(const relation_signature & s, relation_plugin & inner_plugin) {
SASSERT(!inner_plugin.is_sieve_relation()); //it does not make sense to make a sieve of a sieve
svector<bool> inner_cols(s.size());
bool_vector inner_cols(s.size());
extract_inner_columns(s, inner_plugin, inner_cols);
relation_signature inner_sig;
collect_inner_signature(s, inner_cols, inner_sig);
@ -248,14 +248,14 @@ namespace datalog {
relation_signature empty_sig;
relation_plugin& plugin = get_manager().get_appropriate_plugin(s);
relation_base * inner = plugin.mk_full(p, empty_sig, null_family_id);
svector<bool> inner_cols;
bool_vector inner_cols;
inner_cols.resize(s.size(), false);
return mk_from_inner(s, inner_cols, inner);
}
sieve_relation * sieve_relation_plugin::full(func_decl* p, const relation_signature & s, relation_plugin & inner_plugin) {
SASSERT(!inner_plugin.is_sieve_relation()); //it does not make sense to make a sieve of a sieve
svector<bool> inner_cols(s.size());
bool_vector inner_cols(s.size());
extract_inner_columns(s, inner_plugin, inner_cols);
relation_signature inner_sig;
collect_inner_signature(s, inner_cols, inner_sig);
@ -267,7 +267,7 @@ namespace datalog {
sieve_relation_plugin & m_plugin;
unsigned_vector m_inner_cols_1;
unsigned_vector m_inner_cols_2;
svector<bool> m_result_inner_cols;
bool_vector m_result_inner_cols;
scoped_ptr<relation_join_fn> m_inner_join_fun;
public:
@ -347,7 +347,7 @@ namespace datalog {
class sieve_relation_plugin::transformer_fn : public convenient_relation_transformer_fn {
svector<bool> m_result_inner_cols;
bool_vector m_result_inner_cols;
scoped_ptr<relation_transformer_fn> m_inner_fun;
public:
@ -383,7 +383,7 @@ namespace datalog {
}
}
svector<bool> result_inner_cols = r.m_inner_cols;
bool_vector result_inner_cols = r.m_inner_cols;
project_out_vector_columns(result_inner_cols, col_cnt, removed_cols);
relation_signature result_sig;
@ -419,7 +419,7 @@ namespace datalog {
unsigned_vector inner_permutation;
collect_sub_permutation(permutation, r.m_sig2inner, inner_permutation, inner_identity);
svector<bool> result_inner_cols = r.m_inner_cols;
bool_vector result_inner_cols = r.m_inner_cols;
permutate_by_cycle(result_inner_cols, cycle_len, permutation_cycle);
relation_signature result_sig;

12
src/muz/rel/dl_sieve_relation.h
View file

@ -31,7 +31,7 @@ namespace datalog {
friend class sieve_relation;
public:
struct rel_spec {
svector<bool> m_inner_cols;
bool_vector m_inner_cols;
family_id m_inner_kind;
/**
@ -70,9 +70,9 @@ namespace datalog {
family_id get_relation_kind(sieve_relation & r, const bool * inner_columns);
void extract_inner_columns(const relation_signature & s, relation_plugin & inner,
svector<bool> & inner_columns);
bool_vector & inner_columns);
void extract_inner_signature(const relation_signature & s, relation_signature & inner_sig);
void collect_inner_signature(const relation_signature & s, const svector<bool> & inner_columns,
void collect_inner_signature(const relation_signature & s, const bool_vector & inner_columns,
relation_signature & inner_sig);
public:
static symbol get_name() { return symbol("sieve_relation"); }
@ -89,7 +89,7 @@ namespace datalog {
family_id get_relation_kind(const relation_signature & sig, const bool * inner_columns,
family_id inner_kind);
family_id get_relation_kind(const relation_signature & sig, const svector<bool> & inner_columns,
family_id get_relation_kind(const relation_signature & sig, const bool_vector & inner_columns,
family_id inner_kind) {
SASSERT(sig.size()==inner_columns.size());
return get_relation_kind(sig, inner_columns.c_ptr(), inner_kind);
@ -108,7 +108,7 @@ namespace datalog {
sieve_relation * mk_from_inner(const relation_signature & s, const bool * inner_columns,
relation_base * inner_rel);
sieve_relation * mk_from_inner(const relation_signature & s, const svector<bool> & inner_columns,
sieve_relation * mk_from_inner(const relation_signature & s, const bool_vector & inner_columns,
relation_base * inner_rel) {
SASSERT(inner_columns.size()==s.size());
return mk_from_inner(s, inner_columns.c_ptr(), inner_rel);
@ -148,7 +148,7 @@ namespace datalog {
friend class sieve_relation_plugin::union_fn;
friend class sieve_relation_plugin::filter_fn;
svector<bool> m_inner_cols;
bool_vector m_inner_cols;
unsigned_vector m_sig2inner;
unsigned_vector m_inner2sig;

2
src/muz/rel/udoc_relation.cpp
View file

@ -1112,7 +1112,7 @@ namespace datalog {
SASSERT(joined_col_cnt > 0 || neg.get_signature().size() == 0);
m_is_subtract = (joined_col_cnt == t.get_signature().size());
m_is_subtract &= (joined_col_cnt == neg.get_signature().size());
svector<bool> found(joined_col_cnt, false);
bool_vector found(joined_col_cnt, false);
for (unsigned i = 0; m_is_subtract && i < joined_col_cnt; ++i) {
m_is_subtract = !found[t_cols[i]] && (t_cols[i] == neg_cols[i]);
found[t_cols[i]] = true;

88
src/muz/spacer/spacer_context.cpp
View file

@ -239,9 +239,8 @@ void derivation::exist_skolemize(expr* fml, app_ref_vector &vars, expr_ref &res)
vars.shrink(j);
}
TRACE("spacer", tout << "Skolemizing: ";
for (auto v : vars) tout << " " << mk_pp(v, m) << " ";
tout << "\nfrom " << mk_pp(fml, m) << "\n";
TRACE("spacer", tout << "Skolemizing: " << vars << "\n";
tout << "from " << mk_pp(fml, m) << "\n";
);
app_ref_vector pinned(m);
@ -868,7 +867,7 @@ const datalog::rule *pred_transformer::find_rule(model &model) {
const datalog::rule *pred_transformer::find_rule(model &model,
bool& is_concrete,
vector<bool>& reach_pred_used,
bool_vector& reach_pred_used,
unsigned& num_reuse_reach)
{
// find a rule whose tag is true in the model;
@ -1188,11 +1187,10 @@ expr_ref pred_transformer::get_origin_summary (model &mdl,
// (skip quantified lemmas cause we can't validate them in the model)
// TBD: for quantified lemmas use current instances
flatten_and(summary);
for (auto* s : summary) {
if (!is_quantifier(s) && !mdl.is_true(s)) {
TRACE("spacer", tout << "Summary not true in the model: "
<< mk_pp(s, m) << "\n";);
// return expr_ref(m);
TRACE("spacer", tout << "Summary not true in the model: " << mk_pp(s, m) << "\n";);
}
}
@ -1209,12 +1207,10 @@ void pred_transformer::add_cover(unsigned level, expr* property, bool bg)
// replace bound variables by local constants.
expr_ref result(property, m), v(m), c(m);
expr_substitution sub(m);
proof_ref pr(m);
pr = m.mk_asserted(m.mk_true());
for (unsigned i = 0; i < sig_size(); ++i) {
c = m.mk_const(pm.o2n(sig(i), 0));
v = m.mk_var(i, sig(i)->get_range());
sub.insert(v, c, pr);
sub.insert(v, c);
}
scoped_ptr<expr_replacer> rep = mk_default_expr_replacer(m, false);
rep->set_substitution(&sub);
@ -1224,13 +1220,14 @@ void pred_transformer::add_cover(unsigned level, expr* property, bool bg)
// add the property.
expr_ref_vector lemmas(m);
flatten_and(result, lemmas);
for (unsigned i = 0, sz = lemmas.size(); i < sz; ++i) {
add_lemma(lemmas.get(i), level, bg);
for (expr * f: lemmas) {
add_lemma(f, level, bg);
}
}
void pred_transformer::propagate_to_infinity (unsigned level)
{m_frames.propagate_to_infinity (level);}
void pred_transformer::propagate_to_infinity (unsigned level) {
m_frames.propagate_to_infinity (level);
}
// compute a conjunction of all background facts
void pred_transformer::get_pred_bg_invs(expr_ref_vector& out) {
@ -1274,7 +1271,9 @@ bool pred_transformer::is_blocked (pob &n, unsigned &uses_level)
// XXX quic3: not all lemmas are asserted at the post-condition
lbool res = m_solver->check_assumptions (post, _aux, _aux,
0, nullptr, 0);
if (res == l_false) { uses_level = m_solver->uses_level(); }
if (res == l_false) {
uses_level = m_solver->uses_level();
}
return res == l_false;
}
@ -1298,10 +1297,9 @@ bool pred_transformer::is_qblocked (pob &n) {
// assert all lemmas
bool has_quant = false;
for (unsigned i = 0, sz = frame_lemmas.size (); i < sz; ++i)
{
has_quant = has_quant || is_quantifier(frame_lemmas.get(i));
s->assert_expr(frame_lemmas.get(i));
for (expr* f : frame_lemmas) {
has_quant |= is_quantifier(f);
s->assert_expr(f);
}
if (!has_quant) return false;
@ -1335,7 +1333,7 @@ void pred_transformer::mbp(app_ref_vector &vars, expr_ref &fml, model &mdl,
lbool pred_transformer::is_reachable(pob& n, expr_ref_vector* core,
model_ref* model, unsigned& uses_level,
bool& is_concrete, datalog::rule const*& r,
vector<bool>& reach_pred_used,
bool_vector& reach_pred_used,
unsigned& num_reuse_reach)
{
TRACE("spacer",
@ -1388,14 +1386,8 @@ lbool pred_transformer::is_reachable(pob& n, expr_ref_vector* core,
}
}
TRACE ("spacer",
if (!reach_assumps.empty ()) {
tout << "reach assumptions\n";
for (unsigned i = 0; i < reach_assumps.size (); i++) {
tout << mk_pp (reach_assumps.get (i), m) << "\n";
}
}
);
CTRACE("spacer", !reach_assumps.empty(),
tout << "reach assumptions\n" << reach_assumps << "\n";);
// check local reachability;
// result is either sat (with some reach assumps) or
@ -1404,24 +1396,15 @@ lbool pred_transformer::is_reachable(pob& n, expr_ref_vector* core,
lbool is_sat = m_solver->check_assumptions (post, reach_assumps,
m_transition_clause, 1, &bg, 0);
TRACE ("spacer",
if (!reach_assumps.empty ()) {
tout << "reach assumptions used\n";
for (unsigned i = 0; i < reach_assumps.size (); i++) {
tout << mk_pp (reach_assumps.get (i), m) << "\n";
}
}
);
CTRACE("spacer", !reach_assumps.empty(),
tout << "reach assumptions\n" << reach_assumps << "\n";);
if (is_sat == l_true || is_sat == l_undef) {
if (core) { core->reset(); }
if (model && model->get()) {
r = find_rule(**model, is_concrete, reach_pred_used, num_reuse_reach);
TRACE ("spacer", tout << "reachable "
<< "is_concrete " << is_concrete << " rused: ";
for (unsigned i = 0, sz = reach_pred_used.size (); i < sz; ++i)
tout << reach_pred_used [i];
tout << "\n";);
TRACE("spacer",
tout << "reachable " << r << " is_concrete " << is_concrete << " rused: " << reach_pred_used << "\n";);
}
return is_sat;
@ -2924,8 +2907,6 @@ expr_ref context::get_answer()
}
}
expr_ref context::mk_unsat_answer() const
{
expr_ref_vector refs(m);
@ -2935,7 +2916,6 @@ expr_ref context::mk_unsat_answer() const
return ex.to_expr();
}
proof_ref context::get_ground_refutation() const {
if (m_last_result != l_true) {
IF_VERBOSE(0, verbose_stream()
@ -3272,7 +3252,7 @@ bool context::is_reachable(pob &n)
bool is_concrete;
const datalog::rule * r = nullptr;
// denotes which predecessor's (along r) reach facts are used
vector<bool> reach_pred_used;
bool_vector reach_pred_used;
unsigned num_reuse_reach = 0;
unsigned saved = n.level ();
@ -3382,7 +3362,7 @@ lbool context::expand_pob(pob& n, pob_ref_buffer &out)
bool is_concrete;
const datalog::rule * r = nullptr;
// denotes which predecessor's (along r) reach facts are used
vector<bool> reach_pred_used;
bool_vector reach_pred_used;
unsigned num_reuse_reach = 0;
@ -3694,11 +3674,7 @@ reach_fact *pred_transformer::mk_rf(pob& n, model &mdl, const datalog::rule& r)
TRACE ("spacer",
tout << "Reach fact, before QE:\n";
tout << mk_pp (res, m) << "\n";
tout << "Vars:\n";
for (unsigned i = 0; i < vars.size(); ++i) {
tout << mk_pp(vars.get (i), m) << "\n";
}
);
tout << "Vars:\n" << vars << "\n";);
{
timeit _timer1 (is_trace_enabled("spacer_timeit"),
@ -3711,10 +3687,7 @@ reach_fact *pred_transformer::mk_rf(pob& n, model &mdl, const datalog::rule& r)
TRACE ("spacer",
tout << "Reach fact, after QE project:\n";
tout << mk_pp (res, m) << "\n";
tout << "Vars:\n";
for (unsigned i = 0; i < vars.size(); ++i) {
tout << mk_pp(vars.get (i), m) << "\n";
}
tout << "Vars:\n" << vars << "\n";
);
SASSERT (vars.empty ());
@ -3733,7 +3706,7 @@ reach_fact *pred_transformer::mk_rf(pob& n, model &mdl, const datalog::rule& r)
*/
bool context::create_children(pob& n, datalog::rule const& r,
model &mdl,
const vector<bool> &reach_pred_used,
const bool_vector &reach_pred_used,
pob_ref_buffer &out)
{
scoped_watch _w_ (m_create_children_watch);
@ -4079,9 +4052,8 @@ inline bool pob_lt_proc::operator() (const pob *pn1, const pob *pn2) const
verbose_stream()
<< "dup: " << n1.pt().head()->get_name()
<< "(" << n1.level() << ", " << n1.depth() << ") "
<< p1->get_id () << "\n";
<< p1->get_id() << "\n";);
//<< " p1: " << mk_pp (const_cast<expr*>(p1), m) << "\n"
);
}
// XXX see comment below on identical nodes

6
src/muz/spacer/spacer_context.h
View file

@ -487,7 +487,7 @@ public:
bool is_ctp_blocked(lemma *lem);
const datalog::rule *find_rule(model &mdl);
const datalog::rule *find_rule(model &mev, bool& is_concrete,
vector<bool>& reach_pred_used,
bool_vector& reach_pred_used,
unsigned& num_reuse_reach);
expr* get_transition(datalog::rule const& r) {
pt_rule *p;
@ -530,7 +530,7 @@ public:
lbool is_reachable(pob& n, expr_ref_vector* core, model_ref *model,
unsigned& uses_level, bool& is_concrete,
datalog::rule const*& r,
vector<bool>& reach_pred_used,
bool_vector& reach_pred_used,
unsigned& num_reuse_reach);
bool is_invariant(unsigned level, lemma* lem,
unsigned& solver_level,
@ -1010,7 +1010,7 @@ class context {
lbool expand_pob(pob &n, pob_ref_buffer &out);
bool create_children(pob& n, const datalog::rule &r,
model &mdl,
const vector<bool>& reach_pred_used,
const bool_vector& reach_pred_used,
pob_ref_buffer &out);
/**

4
src/muz/spacer/spacer_qe_project.cpp
View file

@ -211,8 +211,8 @@ namespace spacer_qe {
expr_ref_vector m_terms;
vector<rational> m_coeffs;
vector<rational> m_divs;
svector<bool> m_strict;
svector<bool> m_eq;
bool_vector m_strict;
bool_vector m_eq;
scoped_ptr<contains_app> m_var;
bool is_linear(rational const& mul, expr* t, rational& c, expr_ref_vector& ts) {

2
src/muz/transforms/dl_mk_backwards.cpp
View file

@ -38,7 +38,7 @@ namespace datalog {
rule_ref new_rule(rm);
app_ref_vector tail(m);
app_ref head(m);
svector<bool> neg;
bool_vector neg;
app_ref query(m);
query = m.mk_fresh_const("Q", m.mk_bool_sort());
result->set_output_predicate(query->get_decl());

4
src/muz/transforms/dl_mk_coalesce.cpp
View file

@ -64,7 +64,7 @@ namespace datalog {
expr_ref_vector revsub(m), conjs(m);
rl.get_vars(m, sorts);
revsub.resize(sorts.size());
svector<bool> valid(sorts.size(), true);
bool_vector valid(sorts.size(), true);
for (unsigned i = 0; i < sub.size(); ++i) {
expr* e = sub[i];
sort* s = m.get_sort(e);
@ -116,7 +116,7 @@ namespace datalog {
expr_ref_vector conjs1(m), conjs(m);
rule_ref res(rm);
bool_rewriter bwr(m);
svector<bool> is_neg;
bool_vector is_neg;
tgt->get_vars(m, sorts1);
src.get_vars(m, sorts2);

2
src/muz/transforms/dl_mk_coi_filter.h
View file

@ -32,7 +32,7 @@ namespace datalog {
ast_manager & m;
context & m_context;
vector<app*> m_new_tail;
svector<bool> m_new_tail_neg;
bool_vector m_new_tail_neg;
rule_set * bottom_up(rule_set const & source);
rule_set * top_down(rule_set const & source);

2
src/muz/transforms/dl_mk_filter_rules.cpp
View file

@ -106,7 +106,7 @@ namespace datalog {
m_current = r;
app * new_head = r->get_head();
app_ref_vector new_tail(m);
svector<bool> new_is_negated;
bool_vector new_is_negated;
unsigned sz = r->get_tail_size();
bool rule_modified = false;
for (unsigned i = 0; i < sz; i++) {

4
src/muz/transforms/dl_mk_interp_tail_simplifier.h
View file

@ -38,7 +38,7 @@ namespace datalog {
unifier m_unif;
app_ref m_head;
app_ref_vector m_tail;
svector<bool> m_neg;
bool_vector m_neg;
rule * m_rule;
void apply(app * a, app_ref& res);
@ -76,7 +76,7 @@ namespace datalog {
app_ref_vector m_tail;
expr_ref_vector m_itail_members;
expr_ref_vector m_conj;
svector<bool> m_tail_neg;
bool_vector m_tail_neg;
normalizer_cfg* m_cfg;
normalizer_rw* m_rw;

2
src/muz/transforms/dl_mk_karr_invariants.h
View file

@ -34,7 +34,7 @@ namespace datalog {
struct matrix {
vector<vector<rational> > A;
vector<rational> b;
svector<bool> eq;
bool_vector eq;
unsigned size() const { return A.size(); }
void reset() { A.reset(); b.reset(); eq.reset(); }
matrix& operator=(matrix const& other);

4
src/muz/transforms/dl_mk_loop_counter.cpp
View file

@ -73,7 +73,7 @@ namespace datalog {
rule_ref new_rule(rm);
app_ref_vector tail(m);
app_ref head(m);
svector<bool> neg;
bool_vector neg;
rule_counter& vc = rm.get_counter();
for (unsigned i = 0; i < sz; ++i) {
tail.reset();
@ -129,7 +129,7 @@ namespace datalog {
rule_ref new_rule(rm);
app_ref_vector tail(m);
app_ref head(m);
svector<bool> neg;
bool_vector neg;
for (unsigned i = 0; i < sz; ++i) {
tail.reset();
neg.reset();

4
src/muz/transforms/dl_mk_magic_sets.cpp
View file

@ -187,7 +187,7 @@ namespace datalog {
void mk_magic_sets::create_magic_rules(app * head, unsigned tail_cnt, app * const * tail, bool const* negated, rule_set& result) {
//TODO: maybe include relevant interpreted predicates from the original rule
ptr_vector<app> new_tail;
svector<bool> negations;
bool_vector negations;
new_tail.push_back(create_magic_literal(head));
new_tail.append(tail_cnt, tail);
negations.push_back(false);
@ -231,7 +231,7 @@ namespace datalog {
}
ptr_vector<app> new_tail;
svector<bool> negations;
bool_vector negations;
while (new_tail.size()!=processed_tail_len) {
bool intentional = false;
int curr_index = pop_bound(exten_tails, r, bound_vars);

2
src/muz/transforms/dl_mk_magic_symbolic.cpp
View file

@ -77,7 +77,7 @@ namespace datalog {
rule_ref new_rule(rm);
app_ref_vector tail(m);
app_ref head(m);
svector<bool> neg;
bool_vector neg;
for (unsigned i = 0; i < sz; ++i) {
rule & r = *source.get_rule(i);
unsigned utsz = r.get_uninterpreted_tail_size();

8
src/muz/transforms/dl_mk_quantifier_abstraction.cpp
View file

@ -39,7 +39,7 @@ namespace datalog {
func_decl_ref_vector m_new_funcs;
vector<expr_ref_vector> m_subst;
vector<sort_ref_vector> m_sorts;
vector<svector<bool> > m_bound;
vector<bool_vector > m_bound;
public:
@ -56,7 +56,7 @@ namespace datalog {
void get_units(obj_map<expr, bool>& units) override { units.reset(); }
void insert(func_decl* old_p, func_decl* new_p, expr_ref_vector& sub, sort_ref_vector& sorts, svector<bool> const& bound) {
void insert(func_decl* old_p, func_decl* new_p, expr_ref_vector& sub, sort_ref_vector& sorts, bool_vector const& bound) {
m_old_funcs.push_back(old_p);
m_new_funcs.push_back(new_p);
m_subst.push_back(sub);
@ -71,7 +71,7 @@ namespace datalog {
func_decl* q = m_old_funcs[i].get();
expr_ref_vector const& sub = m_subst[i];
sort_ref_vector const& sorts = m_sorts[i];
svector<bool> const& is_bound = m_bound[i];
bool_vector const& is_bound = m_bound[i];
func_interp* f = old_model->get_func_interp(p);
expr_ref body(m);
unsigned arity_q = q->get_arity();
@ -177,7 +177,7 @@ namespace datalog {
func_decl* new_p = nullptr;
if (!m_old2new.find(old_p, new_p)) {
expr_ref_vector sub(m), vars(m);
svector<bool> bound;
bool_vector bound;
sort_ref_vector domain(m), sorts(m);
expr_ref arg(m);
for (unsigned i = 0; i < sz; ++i) {

14
src/muz/transforms/dl_mk_rule_inliner.cpp
View file

@ -91,7 +91,7 @@ namespace datalog {
void rule_unifier::apply(
rule const& r, bool is_tgt, unsigned skipped_index,
app_ref_vector& res, svector<bool>& res_neg) {
app_ref_vector& res, bool_vector& res_neg) {
unsigned rule_len = r.get_tail_size();
for (unsigned i = 0; i < rule_len; i++) {
if (i != skipped_index) { //i can never be UINT_MAX, so we'll never skip if we're not supposed to
@ -107,7 +107,7 @@ namespace datalog {
SASSERT(m_ready);
app_ref new_head(m);
app_ref_vector tail(m);
svector<bool> tail_neg;
bool_vector tail_neg;
rule_ref simpl_rule(m_rm);
apply(tgt.get_head(), true, new_head);
apply(tgt, true, tail_index, tail, tail_neg);
@ -647,8 +647,8 @@ namespace datalog {
}
void mk_rule_inliner::add_rule(rule_set const& source, rule* r, unsigned i) {
svector<bool>& can_remove = m_head_visitor.can_remove();
svector<bool>& can_expand = m_head_visitor.can_expand();
bool_vector& can_remove = m_head_visitor.can_remove();
bool_vector& can_expand = m_head_visitor.can_expand();
app* head = r->get_head();
func_decl* headd = head->get_decl();
m_head_visitor.add_position(head, i);
@ -705,8 +705,8 @@ namespace datalog {
}
// set up unification index.
svector<bool>& can_remove = m_head_visitor.can_remove();
svector<bool>& can_expand = m_head_visitor.can_expand();
bool_vector& can_remove = m_head_visitor.can_remove();
bool_vector& can_expand = m_head_visitor.can_expand();
for (unsigned i = 0; i < sz; ++i) {
add_rule(*rules, acc[i].get(), i);
@ -727,7 +727,7 @@ namespace datalog {
m_subst.reserve_vars(max_var+1);
m_subst.reserve_offsets(std::max(m_tail_index.get_approx_num_regs(), 2+m_head_index.get_approx_num_regs()));
svector<bool> valid;
bool_vector valid;
valid.reset();
valid.resize(sz, true);

8
src/muz/transforms/dl_mk_rule_inliner.h
View file

@ -76,7 +76,7 @@ namespace datalog {
unless skipped_index is equal to UINT_MAX
*/
void apply(rule const& r, bool is_tgt, unsigned skipped_index, app_ref_vector& res,
svector<bool>& res_neg);
bool_vector& res_neg);
};
@ -85,15 +85,15 @@ namespace datalog {
class visitor : public st_visitor {
context& m_context;
unsigned_vector m_unifiers;
svector<bool> m_can_remove, m_can_expand;
bool_vector m_can_remove, m_can_expand;
obj_map<expr, unsigned_vector> m_positions;
public:
visitor(context& c, substitution & s): st_visitor(s), m_context(c) { (void) m_context; }
bool operator()(expr* e) override;
void reset() { m_unifiers.reset(); }
void reset(unsigned sz);
svector<bool>& can_remove() { return m_can_remove; }
svector<bool>& can_expand() { return m_can_expand; }
bool_vector& can_remove() { return m_can_remove; }
bool_vector& can_expand() { return m_can_expand; }
unsigned_vector const& add_position(expr* e, unsigned j);
unsigned_vector const& del_position(expr* e, unsigned j);
unsigned_vector const& get_unifiers() { return m_unifiers; }

2
src/muz/transforms/dl_mk_scale.cpp
View file

@ -127,7 +127,7 @@ namespace datalog {
rule_ref new_rule(rm);
app_ref_vector tail(m);
app_ref head(m);
svector<bool> neg;
bool_vector neg;
ptr_vector<sort> vars;
ref<scale_model_converter> smc;
if (m_ctx.get_model_converter()) {

2
src/muz/transforms/dl_mk_separate_negated_tails.cpp
View file

@ -80,7 +80,7 @@ namespace datalog {
unsigned tsz = r.get_tail_size();
app_ref_vector tail(m);
app_ref p(m);
svector<bool> neg;
bool_vector neg;
for (unsigned i = 0; i < ptsz; ++i) {
tail.push_back(r.get_tail(i));
neg.push_back(false);

6
src/muz/transforms/dl_mk_slice.h
View file

@ -35,10 +35,10 @@ namespace datalog {
context& m_ctx;
ast_manager& m;
rule_manager& rm;
svector<bool> m_input;
svector<bool> m_output;
bool_vector m_input;
bool_vector m_output;
expr_ref_vector m_solved_vars;
svector<bool> m_var_is_sliceable;
bool_vector m_var_is_sliceable;
obj_map<func_decl, func_decl*> m_predicates;
obj_map<func_decl, bit_vector> m_sliceable;
ast_ref_vector m_pinned;

2
src/muz/transforms/dl_mk_subsumption_checker.cpp
View file

@ -125,7 +125,7 @@ namespace datalog {
app_ref head(r->get_head(), m);
app_ref_vector tail(m);
svector<bool> tail_neg;
bool_vector tail_neg;
for(unsigned i=0; i<u_len; i++) {
app * tail_atom = r->get_tail(i);

8
src/muz/transforms/dl_mk_synchronize.cpp
View file

@ -101,7 +101,7 @@ namespace datalog {
app_ref replacing = product_application(apps);
ptr_vector<app> new_tail;
svector<bool> new_tail_neg;
bool_vector new_tail_neg;
unsigned n = r.get_tail_size() - apps.size() + 1;
unsigned tail_idx = 0;
new_tail.resize(n);
@ -176,7 +176,7 @@ namespace datalog {
void mk_synchronize::add_rec_tail(vector< ptr_vector<app> > & recursive_calls,
app_ref_vector & new_tail,
svector<bool> & new_tail_neg,
bool_vector & new_tail_neg,
unsigned & tail_idx) {
unsigned max_sz = 0;
for (auto &rc : recursive_calls)
@ -200,7 +200,7 @@ namespace datalog {
}
void mk_synchronize::add_non_rec_tail(rule & r, app_ref_vector & new_tail,
svector<bool> & new_tail_neg,
bool_vector & new_tail_neg,
unsigned & tail_idx) {
for (unsigned i = 0, sz = r.get_positive_tail_size(); i < sz; ++i) {
app* tail = r.get_tail(i);
@ -287,7 +287,7 @@ namespace datalog {
}
app_ref_vector new_tail(m);
svector<bool> new_tail_neg;
bool_vector new_tail_neg;
new_tail.resize(product_tail_length);
new_tail_neg.resize(product_tail_length);
unsigned tail_idx = -1;

4
src/muz/transforms/dl_mk_synchronize.h
View file

@ -109,9 +109,9 @@ namespace datalog {
void add_rec_tail(vector< ptr_vector<app> > & recursive_calls,
app_ref_vector & new_tail,
svector<bool> & new_tail_neg, unsigned & tail_idx);
bool_vector & new_tail_neg, unsigned & tail_idx);
void add_non_rec_tail(rule & r, app_ref_vector & new_tail,
svector<bool> & new_tail_neg,
bool_vector & new_tail_neg,
unsigned & tail_idx);
rule_ref product_rule(rule_ref_vector const & rules);

2
src/muz/transforms/dl_mk_unbound_compressor.cpp
View file

@ -205,7 +205,7 @@ namespace datalog {
SASSERT(dtail_args.size()==dtail_pred->get_arity());
app_ref dtail(m.mk_app(dtail_pred, dtail_args.size(), dtail_args.c_ptr()), m);
svector<bool> tails_negated;
bool_vector tails_negated;
app_ref_vector tails(m);
unsigned tail_len = r->get_tail_size();
for (unsigned i = 0; i < tail_len; i++) {

2
src/nlsat/nlsat_assignment.h
View file

@ -30,7 +30,7 @@ namespace nlsat {
*/
class assignment : public polynomial::var2anum {
scoped_anum_vector m_values;
svector<bool> m_assigned;
bool_vector m_assigned;
public:
assignment(anum_manager & _m):m_values(_m) {}
virtual ~assignment() {}

2
src/nlsat/nlsat_explain.cpp
View file

@ -258,7 +258,7 @@ namespace nlsat {
\brief Add literal p != 0 into m_result.
*/
ptr_vector<poly> m_zero_fs;
svector<bool> m_is_even;
bool_vector m_is_even;
void add_zero_assumption(polynomial_ref & p) {
// If p is of the form p1^n1 * ... * pk^nk,
// then only the factors that are zero in the current interpretation needed to be considered.

12
src/nlsat/nlsat_solver.cpp
View file

@ -114,10 +114,10 @@ namespace nlsat {
unsigned_vector m_levels; // bool_var -> level
svector<justification> m_justifications;
vector<clause_vector> m_bwatches; // bool_var (that are not attached to atoms) -> clauses where it is maximal
svector<bool> m_dead; // mark dead boolean variables
bool_vector m_dead; // mark dead boolean variables
id_gen m_bid_gen;
svector<bool> m_is_int; // m_is_int[x] is true if variable is integer
bool_vector m_is_int; // m_is_int[x] is true if variable is integer
vector<clause_vector> m_watches; // var -> clauses where variable is maximal
interval_set_vector m_infeasible; // var -> to a set of interval where the variable cannot be assigned to.
atom_vector m_var2eq; // var -> to asserted equality
@ -497,7 +497,7 @@ namespace nlsat {
SASSERT(m_is_int.size() == m_inv_perm.size());
}
svector<bool> m_found_vars;
bool_vector m_found_vars;
void vars(literal l, var_vector& vs) {
vs.reset();
atom * a = m_atoms[l.var()];
@ -835,7 +835,7 @@ namespace nlsat {
ineq_atom& ia = *to_ineq_atom(a);
unsigned sz = ia.size();
ptr_vector<poly> ps;
svector<bool> is_even;
bool_vector is_even;
for (unsigned i = 0; i < sz; ++i) {
ps.push_back(ia.p(i));
is_even.push_back(ia.is_even(i));
@ -2400,7 +2400,7 @@ namespace nlsat {
new_inv_perm[ext_x] = p[m_inv_perm[ext_x]];
m_perm.set(new_inv_perm[ext_x], ext_x);
}
svector<bool> is_int;
bool_vector is_int;
is_int.swap(m_is_int);
for (var x = 0; x < sz; x++) {
m_is_int.setx(p[x], is_int[x], false);
@ -2698,7 +2698,7 @@ namespace nlsat {
u_map<literal> b2l;
scoped_literal_vector lits(m_solver);
svector<bool> even;
bool_vector even;
unsigned num_atoms = m_atoms.size();
for (unsigned j = 0; j < num_atoms; ++j) {
atom* a = m_atoms[j];

2
src/opt/maxsmt.h
View file

@ -78,7 +78,7 @@ namespace opt {
svector<symbol> m_labels;
//const expr_ref_vector m_soft;
//vector<rational> m_weights;
//svector<bool> m_assignment; // truth assignment to soft constraints
//bool_vector m_assignment; // truth assignment to soft constraints
params_ref m_params; // config
public:

2
src/opt/opt_solver.h
View file

@ -78,7 +78,7 @@ namespace opt {
vector<inf_eps> m_objective_values;
sref_vector<model> m_models;
expr_ref_vector m_objective_terms;
svector<bool> m_valid_objectives;
bool_vector m_valid_objectives;
bool m_dump_benchmarks;
static unsigned m_dump_count;
statistics m_stats;

6
src/opt/pb_sls.cpp
View file

@ -108,8 +108,8 @@ namespace smt {
rational m_penalty; // current penalty of soft constraints
rational m_best_penalty;
vector<unsigned_vector> m_hard_occ, m_soft_occ; // variable occurrence
svector<bool> m_assignment; // current assignment.
svector<bool> m_best_assignment;
bool_vector m_assignment; // current assignment.
bool_vector m_best_assignment;
expr_ref_vector m_trail;
obj_map<expr, unsigned> m_decl2var; // map declarations to Boolean variables.
ptr_vector<expr> m_var2decl; // reverse map
@ -188,7 +188,7 @@ namespace smt {
IF_VERBOSE(1, verbose_stream() << "(pb.sls initial penalty: " << m_best_penalty << ")\n";
verbose_stream() << "(pb.sls violated: " << m_hard_false.num_elems()
<< " penalty: " << m_penalty << ")\n";);
svector<bool> assignment(m_assignment);
bool_vector assignment(m_assignment);
for (unsigned round = 0; round < 40; ++round) {
init_max_flips();
while (m_max_flips > 0) {

2
src/qe/qe.cpp
View file

@ -415,7 +415,7 @@ namespace qe {
expr_ref_vector m_trail; // trail for generated terms
expr_ref_vector m_args;
ptr_vector<expr> m_todo; // stack of formulas to visit
svector<bool> m_pols; // stack of polarities
bool_vector m_pols; // stack of polarities
bool_rewriter m_rewriter;
public:

2
src/qe/qe_mbi.cpp
View file

@ -244,7 +244,7 @@ namespace qe {
*/
app_ref_vector uflia_mbi::get_arith_vars(expr_ref_vector const& lits) {
app_ref_vector avars(m);
svector<bool> seen;
bool_vector seen;
arith_util a(m);
for (expr* e : subterms(lits)) {
if ((m.is_eq(e) && a.is_int_real(to_app(e)->get_arg(0))) || a.is_arith_expr(e)) {

2
src/sat/ba_solver.h
View file

@ -295,7 +295,7 @@ namespace sat {
bool m_clause_removed;
bool m_constraint_removed;
literal_vector m_roots;
svector<bool> m_root_vars;
bool_vector m_root_vars;
unsigned_vector m_weights;
svector<wliteral> m_wlits;
bool subsumes(card& c1, card& c2, literal_vector& comp);

4
src/sat/sat_aig_cuts.cpp
View file

@ -742,7 +742,7 @@ namespace sat {
* Assume only the first definition for a node is used for all cuts.
*/
void aig_cuts::cut2clauses(on_clause_t& on_clause, unsigned v, cut const& c) {
svector<bool> visited(m_aig.size(), false);
bool_vector visited(m_aig.size(), false);
for (unsigned u : c) visited[u] = true;
unsigned_vector todo;
todo.push_back(v);
@ -797,7 +797,7 @@ namespace sat {
reslimit lim;
solver s;
unsigned_vector vars;
svector<bool> is_var;
bool_vector is_var;
validator(aig_cuts& t):t(t),s(p, lim) {
p.set_bool("cut_simplifier", false);

4
src/sat/sat_anf_simplifier.h
View file

@ -66,12 +66,12 @@ namespace sat {
solver& s;
config m_config;
svector<bool> m_relevant;
bool_vector m_relevant;
stats m_stats;
statistics m_st;
unsigned_vector m_eval_cache;
unsigned m_eval_ts;
svector<bool> m_used_for_evaluation;
bool_vector m_used_for_evaluation;
void clauses2anf(pdd_solver& solver);
void anf2clauses(pdd_solver& solver);

2
src/sat/sat_asymm_branch.cpp
View file

@ -170,7 +170,7 @@ namespace sat {
CASSERT("asymm_branch", s.check_invariant());
TRACE("asymm_branch_detail", s.display(tout););
report rpt(*this);
svector<bool> saved_phase(s.m_phase);
bool_vector saved_phase(s.m_phase);
bool change = true;
unsigned counter = 0;

4
src/sat/sat_bcd.h
View file

@ -43,8 +43,8 @@ namespace sat {
svector<bclause> m_L, m_R, m_live_clauses, m_new_L;
clause_vector m_bin_clauses;
svector<uint64_t> m_rbits;
svector<bool> m_marked;
svector<bool> m_removed; // set of clauses removed (not considered in clause set during BCE)
bool_vector m_marked;
bool_vector m_removed; // set of clauses removed (not considered in clause set during BCE)
void init(use_list& ul);
void register_clause(clause* cls);

2
src/sat/sat_big.h
View file

@ -30,7 +30,7 @@ namespace sat {
random_gen& m_rand;
unsigned m_num_vars;
vector<literal_vector> m_dag;
svector<bool> m_roots;
bool_vector m_roots;
svector<int> m_left, m_right;
literal_vector m_root, m_parent;
bool m_learned;

2
src/sat/sat_binspr.h
View file

@ -43,7 +43,7 @@ namespace sat {
unsigned m_stopped_at;
vector<clause_vector> m_use_list;
unsigned m_limit1, m_limit2;
svector<bool> m_mark, m_mark2;
bool_vector m_mark, m_mark2;
literal_vector m_must_candidates, m_may_candidates;
unsigned m_state;

4
src/sat/sat_local_search.h
View file

@ -78,7 +78,7 @@ namespace sat {
pbcoeff(unsigned id, unsigned coeff):
m_constraint_id(id), m_coeff(coeff) {}
};
typedef svector<bool> bool_vector;
typedef bool_vector bool_vector;
typedef svector<pbcoeff> coeff_vector;
@ -139,7 +139,7 @@ namespace sat {
local_search_config m_config;
vector<var_info> m_vars; // variables
svector<bool> m_best_phase; // best value in round
bool_vector m_best_phase; // best value in round
svector<bool_var> m_units; // unit clauses
vector<constraint> m_constraints; // all constraints
literal_vector m_assumptions; // temporary assumptions

2
src/sat/sat_lookahead.cpp
View file

@ -2082,7 +2082,7 @@ namespace sat {
}
}
bool lookahead::backtrack(literal_vector& trail, svector<bool> & is_decision) {
bool lookahead::backtrack(literal_vector& trail, bool_vector & is_decision) {
m_cube_state.m_backtracks++;
while (inconsistent()) {
if (trail.empty()) return false;

4
src/sat/sat_lookahead.h
View file

@ -175,7 +175,7 @@ namespace sat {
struct cube_state {
bool m_first;
svector<bool> m_is_decision;
bool_vector m_is_decision;
literal_vector m_cube;
double m_freevars_threshold;
double m_psat_threshold;
@ -540,7 +540,7 @@ namespace sat {
void assign(literal l);
void propagated(literal l);
bool backtrack(literal_vector& trail);
bool backtrack(literal_vector& trail, svector<bool> & is_decision);
bool backtrack(literal_vector& trail, bool_vector & is_decision);
lbool search();
void init_model();
std::ostream& display_binary(std::ostream& out) const;

2
src/sat/sat_lut_finder.h
View file

@ -37,7 +37,7 @@ namespace sat {
clause_filter(unsigned f, clause* cp):
m_filter(f), m_clause(cp) {}
};
typedef svector<bool> bool_vector;
typedef bool_vector bool_vector;
unsigned m_max_lut_size;
vector<svector<clause_filter>> m_clause_filters; // index of clauses.
uint64_t m_combination; // bit-mask of parities that have been found

2
src/sat/sat_model_converter.h
View file

@ -90,7 +90,7 @@ namespace sat {
private:
vector<entry> m_entries; // entries accumulated during SAT search
unsigned m_exposed_lim; // last entry that was exposed to model converter.
svector<bool> m_mark; // literals that are used in asserted clauses.
bool_vector m_mark; // literals that are used in asserted clauses.
solver const* m_solver;
elim_stackv m_elim_stack;

2
src/sat/sat_parallel.h
View file

@ -36,7 +36,7 @@ namespace sat {
unsigned m_size;
unsigned m_tail;
unsigned_vector m_heads;
svector<bool> m_at_end;
bool_vector m_at_end;
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]; }

2
src/sat/sat_prob.h
View file

@ -59,7 +59,7 @@ namespace sat {
clause_allocator m_alloc;
clause_vector m_clause_db;
svector<clause_info> m_clauses;
svector<bool> m_values, m_best_values;
bool_vector m_values, m_best_values;
unsigned m_best_min_unsat;
vector<unsigned_vector> m_use_list;
unsigned_vector m_flat_use_list;

2
src/sat/sat_simplifier.cpp
View file

@ -1002,7 +1002,7 @@ namespace sat {
literal_vector m_intersection; // current resolution intersection
literal_vector m_tautology; // literals that are used in blocking tautology
literal_vector m_new_intersection;
svector<bool> m_in_intersection;
bool_vector m_in_intersection;
unsigned m_ala_qhead;
clause_wrapper m_clause;
unsigned m_ala_cost;

16
src/sat/sat_solver.h
View file

@ -118,11 +118,11 @@ namespace sat {
vector<watch_list> m_watches;
svector<lbool> m_assignment;
svector<justification> m_justification;
svector<bool> m_decision;
svector<bool> m_mark;
svector<bool> m_lit_mark;
svector<bool> m_eliminated;
svector<bool> m_external;
bool_vector m_decision;
bool_vector m_mark;
bool_vector m_lit_mark;
bool_vector m_eliminated;
bool_vector m_external;
unsigned_vector m_touched;
unsigned m_touch_index;
literal_vector m_replay_assign;
@ -137,9 +137,9 @@ namespace sat {
int m_action;
double m_step_size;
// phase
svector<bool> m_phase;
svector<bool> m_best_phase;
svector<bool> m_prev_phase;
bool_vector m_phase;
bool_vector m_best_phase;
bool_vector m_prev_phase;
svector<char> m_assigned_since_gc;
search_state m_search_state;
unsigned m_search_unsat_conflicts;

2
src/sat/sat_unit_walk.h
View file

@ -55,7 +55,7 @@ namespace sat {
solver& s;
local_search m_ls;
random_gen m_rand;
svector<bool> m_phase;
bool_vector m_phase;
svector<ema> m_phase_tf;
var_priority m_priorities;
unsigned m_luby_index;

2
src/sat/sat_xor_finder.h
View file

@ -37,7 +37,7 @@ namespace sat {
clause_filter(unsigned f, clause* cp):
m_filter(f), m_clause(cp) {}
};
typedef svector<bool> bool_vector;
typedef bool_vector bool_vector;
unsigned m_max_xor_size;
vector<svector<clause_filter>> m_clause_filters; // index of clauses.
unsigned m_combination; // bit-mask of parities that have been found

2
src/smt/diff_logic.h
View file

@ -1385,7 +1385,7 @@ public:
template<typename Functor>
bool find_shortest_path_aux(dl_var source, dl_var target, unsigned timestamp, Functor & f, bool zero_edge) {
svector<bfs_elem> bfs_todo;
svector<bool> bfs_mark;
bool_vector bfs_mark;
bfs_mark.resize(m_assignment.size(), false);
bfs_todo.push_back(bfs_elem(source, -1, null_edge_id));

4
src/smt/expr_context_simplifier.cpp
View file

@ -334,7 +334,7 @@ void expr_strong_context_simplifier::simplify_basic(expr* fml, expr_ref& result)
ptr_vector<expr> todo;
ptr_vector<expr> names;
svector<bool> is_checked;
bool_vector is_checked;
svector<unsigned> parent_ids, self_ids;
expr_ref_vector fresh_vars(m);
expr_ref_vector trail(m);
@ -484,7 +484,7 @@ void expr_strong_context_simplifier::simplify_model_based(expr* fml, expr_ref& r
ptr_vector<expr> todo;
ptr_vector<expr> names;
svector<bool> is_checked;
bool_vector is_checked;
svector<unsigned> parent_ids, self_ids;
expr_ref_vector fresh_vars(m);
expr_ref_vector trail(m);

6
src/smt/mam.cpp
View file

@ -797,7 +797,7 @@ namespace {
code_tree * m_tree;
unsigned m_num_choices;
bool m_is_tmp_tree;
svector<bool> m_mp_already_processed;
bool_vector m_mp_already_processed;
obj_map<expr, unsigned> m_matched_exprs;
struct pcheck_checked {
@ -3106,10 +3106,10 @@ namespace {
// m_is_plbl[f] is true, then when f(c_1, ..., c_n) becomes relevant,
// for each c_i. c_i->get_root()->lbls().insert(lbl_hash(f))
svector<bool> m_is_plbl;
bool_vector m_is_plbl;
// m_is_clbl[f] is true, then when n=f(c_1, ..., c_n) becomes relevant,
// n->get_root()->lbls().insert(lbl_hash(f))
svector<bool> m_is_clbl; // children labels
bool_vector m_is_clbl; // children labels
// auxiliary field used to update data-structures...
typedef ptr_vector<func_decl> func_decls;

2
src/smt/smt_context.cpp
View file

@ -3989,7 +3989,7 @@ namespace smt {
#ifdef Z3DEBUG
expr_ref_vector expr_lits(m);
svector<bool> expr_signs;
bool_vector expr_signs;
for (unsigned i = 0; i < num_lits; i++) {
literal l = lits[i];
if (get_assignment(l) != l_false) {

2
src/smt/smt_context.h
View file

@ -1200,7 +1200,7 @@ namespace smt {
bool is_relevant_core(expr * n) const { return m_relevancy_propagator->is_relevant(n); }
svector<bool> m_relevant_conflict_literals;
bool_vector m_relevant_conflict_literals;
void record_relevancy(unsigned n, literal const* lits);
void restore_relevancy(unsigned n, literal const* lits);

2
src/smt/smt_quick_checker.h
View file

@ -42,7 +42,7 @@ namespace smt {
ast_manager & m_manager;
bool m_conservative;
unsigned m_num_vars;
svector<bool> m_already_found; // mapping from var_idx -> bool
bool_vector m_already_found; // mapping from var_idx -> bool
vector<enode_set> m_candidates; // mapping from var_idx -> set of candidates
vector<enode_set> m_tmp_candidates; // auxiliary mapping from var_idx -> set of candidates

2
src/smt/spanning_tree.h
View file

@ -60,7 +60,7 @@ namespace smt {
void get_descendants(node_id start, svector<node_id> & descendants);
virtual void update(edge_id enter_id, edge_id leave_id);
void get_path(node_id start, node_id end, svector<edge_id> & path, svector<bool> & against);
void get_path(node_id start, node_id end, svector<edge_id> & path, bool_vector & against);
bool in_subtree_t2(node_id child);
bool check_well_formed();

2
src/smt/spanning_tree_base.h
View file

@ -43,7 +43,7 @@ namespace smt {
virtual void get_descendants(node_id start, svector<node_id> & descendants) = 0;
virtual void update(edge_id enter_id, edge_id leave_id) = 0;
virtual void get_path(node_id start, node_id end, svector<edge_id> & path, svector<bool> & against) = 0;
virtual void get_path(node_id start, node_id end, svector<edge_id> & path, bool_vector & against) = 0;
virtual bool in_subtree_t2(node_id child) = 0;
virtual bool check_well_formed() = 0;

4
src/smt/spanning_tree_def.h
View file

@ -67,7 +67,7 @@ namespace smt {
}
template<typename Ext>
void thread_spanning_tree<Ext>::get_path(node_id start, node_id end, svector<edge_id> & path, svector<bool> & against) {
void thread_spanning_tree<Ext>::get_path(node_id start, node_id end, svector<edge_id> & path, bool_vector & against) {
node_id join = get_common_ancestor(start, end);
path.reset();
while (start != join) {
@ -282,7 +282,7 @@ namespace smt {
// Check that m_thread traverses each node.
// This gets checked using union-find as well.
svector<bool> found(m_thread.size(), false);
bool_vector found(m_thread.size(), false);
found[root] = true;
for (node_id x = m_thread[root]; x != root; x = m_thread[x]) {
SASSERT(x != m_thread[x]);

4
src/smt/theory_bv.cpp
View file

@ -1850,7 +1850,7 @@ namespace smt {
if (get_context().inconsistent())
return true; // property is only valid if the context is not in a conflict.
if (is_root(v) && is_bv(v)) {
svector<bool> bits[2];
bool_vector bits[2];
unsigned num_bits = 0;
unsigned bv_sz = get_bv_size(v);
bits[0].resize(bv_sz, false);
@ -1878,7 +1878,7 @@ namespace smt {
zero_one_bits const & _bits = m_zero_one_bits[v];
SASSERT(_bits.size() == num_bits);
svector<bool> already_found;
bool_vector already_found;
already_found.resize(bv_sz, false);
for (auto & zo : _bits) {
SASSERT(find(zo.m_owner) == v);

2
src/smt/theory_dense_diff_logic.h
View file

@ -124,7 +124,7 @@ namespace smt {
atoms m_bv2atoms;
edges m_edges; // list of asserted edges
matrix m_matrix;
svector<bool> m_is_int;
bool_vector m_is_int;
vector<cell_trail> m_cell_trail;
svector<scope> m_scopes;
bool m_non_diff_logic_exprs;

4
src/smt/theory_diff_logic.h
View file

@ -175,7 +175,7 @@ namespace smt {
ptr_vector<eq_prop_info> m_eq_prop_infos;
app_ref_vector m_terms;
svector<bool> m_signs;
bool_vector m_signs;
ptr_vector<atom> m_atoms;
ptr_vector<atom> m_asserted_atoms; // set of asserted atoms
@ -337,7 +337,7 @@ namespace smt {
virtual void new_diseq_eh(theory_var v1, theory_var v2, justification& j);
bool decompose_linear(app_ref_vector& args, svector<bool>& signs);
bool decompose_linear(app_ref_vector& args, bool_vector& signs);
bool is_sign(expr* n, bool& sign);

2
src/smt/theory_diff_logic_def.h
View file

@ -399,7 +399,7 @@ void theory_diff_logic<Ext>::del_atoms(unsigned old_size) {
template<typename Ext>
bool theory_diff_logic<Ext>::decompose_linear(app_ref_vector& terms, svector<bool>& signs) {
bool theory_diff_logic<Ext>::decompose_linear(app_ref_vector& terms, bool_vector& signs) {
for (unsigned i = 0; i < terms.size(); ++i) {
app* n = terms.get(i);
bool sign;

4
src/smt/theory_pb.h
View file

@ -356,9 +356,9 @@ namespace smt {
literal_vector m_antecedents;
tracked_uint_set m_active_var_set;
expr_ref_vector m_antecedent_exprs;
svector<bool> m_antecedent_signs;
bool_vector m_antecedent_signs;
expr_ref_vector m_cardinality_exprs;
svector<bool> m_cardinality_signs;
bool_vector m_cardinality_signs;
void normalize_active_coeffs();
void inc_coeff(literal l, int offset);

2
src/smt/theory_special_relations.cpp
View file

@ -1033,7 +1033,7 @@ namespace smt {
unsigned sz = g.get_num_nodes();
svector<dl_var> nodes;
num_children.resize(sz, 0);
svector<bool> processed(sz, false);
bool_vector processed(sz, false);
for (unsigned i = 0; i < sz; ++i) nodes.push_back(i);
while (!nodes.empty()) {
dl_var v = nodes.back();

2
src/smt/theory_wmaxsat.cpp
View file

@ -47,7 +47,7 @@ namespace smt {
/**
\brief return the complement of variables that are currently assigned.
*/
void theory_wmaxsat::get_assignment(svector<bool>& result) {
void theory_wmaxsat::get_assignment(bool_vector& result) {
result.reset();
if (!m_found_optimal) {

4
src/smt/theory_wmaxsat.h
View file

@ -53,12 +53,12 @@ namespace smt {
bool m_can_propagate;
bool m_normalize;
rational m_den; // lcm of denominators for rational weights.
svector<bool> m_assigned, m_enabled;
bool_vector m_assigned, m_enabled;
stats m_stats;
public:
theory_wmaxsat(ast_manager& m, generic_model_converter& mc);
~theory_wmaxsat() override;
void get_assignment(svector<bool>& result);
void get_assignment(bool_vector& result);
expr* assert_weighted(expr* fml, rational const& w);
void disable_var(expr* var);
bool_var register_var(app* var, bool attach);

2
src/tactic/arith/diff_neq_tactic.cpp
View file

@ -202,7 +202,7 @@ class diff_neq_tactic : public tactic {
}
}
svector<bool> m_forbidden;
bool_vector m_forbidden;
// make sure m_forbidden.size() > max upper bound
void init_forbidden() {

2
src/test/bit_vector.cpp
View file

@ -23,7 +23,7 @@ Revision History:
static void tst1() {
bit_vector v1;
svector<bool> v2;
bool_vector v2;
unsigned n = rand()%10000;
for (unsigned i = 0; i < n; i++) {
int op = rand()%6;

2
src/test/diff_logic.cpp
View file

@ -86,7 +86,7 @@ static void tst2() {
ENSURE(!g.is_feasible());
TRACE("diff_logic", g.display(tout););
struct proc {
svector<bool> found;
bool_vector found;
proc():
found(7, false) {
}

Some files were not shown because too many files have changed in this diff Show more