mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-10-06 07:53:59 +00:00
Code Activity

merge with master

Browse source 
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner 2018-03-25 14:57:01 -07:00
commit c513f3ca09
883 changed files with 13979 additions and 16480 deletions
Download patch file Download diff file Expand all files Collapse all files

18
src/tactic/arith/add_bounds_tactic.cpp
View file

@ -48,10 +48,10 @@ bool is_unbounded(goal const & g) {
class is_unbounded_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_unbounded(g);
}
virtual ~is_unbounded_probe() {}
~is_unbounded_probe() override {}
};
probe * mk_is_unbounded_probe() {
@ -138,30 +138,30 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(add_bounds_tactic, m, m_params);
}
virtual ~add_bounds_tactic() {
~add_bounds_tactic() override {
dealloc(m_imp);
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_params = p;
m_imp->updt_params(p);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
r.insert("add_bound_lower", CPK_NUMERAL, "(default: -2) lower bound to be added to unbounded variables.");
r.insert("add_bound_upper", CPK_NUMERAL, "(default: 2) upper bound to be added to unbounded variables.");
}
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result) {
void operator()(goal_ref const & g,
goal_ref_buffer & result) override {
(*m_imp)(g, result);
}
virtual void cleanup() {
void cleanup() override {
imp * d = alloc(imp, m_imp->m, m_params);
std::swap(d, m_imp);
dealloc(d);

10
src/tactic/arith/arith_bounds_tactic.cpp
View file

@ -23,12 +23,12 @@ struct arith_bounds_tactic : public tactic {
ast_manager& get_manager() { return m; }
virtual void operator()(/* in */ goal_ref const & in,
/* out */ goal_ref_buffer & result) {
void operator()(/* in */ goal_ref const & in,
/* out */ goal_ref_buffer & result) override {
bounds_arith_subsumption(in, result);
}
virtual tactic* translate(ast_manager & mgr) {
tactic* translate(ast_manager & mgr) override {
return alloc(arith_bounds_tactic, mgr);
}
@ -47,7 +47,7 @@ struct arith_bounds_tactic : public tactic {
void mk_proof(proof_ref& pr, goal_ref const& s, unsigned i, unsigned j) {
if (s->proofs_enabled()) {
proof* th_lemma = m.mk_th_lemma(a.get_family_id(), m.mk_implies(s->form(i), s->form(j)), 0, 0);
proof* th_lemma = m.mk_th_lemma(a.get_family_id(), m.mk_implies(s->form(i), s->form(j)), 0, nullptr);
pr = m.mk_modus_ponens(s->pr(i), th_lemma);
}
}
@ -143,7 +143,7 @@ struct arith_bounds_tactic : public tactic {
TRACE("arith_subsumption", s->display(tout); );
}
virtual void cleanup() {}
void cleanup() override {}
};

10
src/tactic/arith/bound_manager.cpp
View file

@ -214,22 +214,22 @@ bool bound_manager::is_disjunctive_bound(expr * f, expr_dependency * d) {
if (!m().is_or(f)) return false;
unsigned sz = to_app(f)->get_num_args();
if (sz == 0) return false;
expr * x, * y, * v = 0;
expr * x, * y, * v = nullptr;
bool is_int;
for (unsigned i = 0; i < sz; ++i) {
expr * e = to_app(f)->get_arg(i);
if (!m().is_eq(e, x, y)) return false;
if (is_uninterp_const(x) &&
is_numeral(y, n, is_int) && is_int &&
(x == v || v == 0)) {
if (v == 0) { v = x; lo = hi = n; }
(x == v || v == nullptr)) {
if (v == nullptr) { v = x; lo = hi = n; }
if (n < lo) lo = n;
if (n > hi) hi = n;
}
else if (is_uninterp_const(y) &&
is_numeral(x, n, is_int) && is_int &&
(y == v || v == 0)) {
if (v == 0) { v = y; lo = hi = n; }
(y == v || v == nullptr)) {
if (v == nullptr) { v = y; lo = hi = n; }
if (n < lo) lo = n;
if (n > hi) hi = n;
}

6
src/tactic/arith/bound_manager.h
View file

@ -52,7 +52,7 @@ public:
ast_manager & m() const { return m_util.get_manager(); }
void operator()(goal const & g);
void operator()(expr * n, expr_dependency * d = 0);
void operator()(expr * n, expr_dependency * d = nullptr);
bool has_lower(expr * c, numeral & v, bool & strict) const {
limit l;
@ -78,14 +78,14 @@ public:
expr_dependency * d;
if (m_lower_deps.find(c, d))
return d;
return 0;
return nullptr;
}
expr_dependency * upper_dep(expr * c) const {
expr_dependency * d;
if (m_upper_deps.find(c, d))
return d;
return 0;
return nullptr;
}
bool has_lower(expr * c) const {

14
src/tactic/arith/bound_propagator.cpp
View file

@ -182,7 +182,7 @@ void bound_propagator::mk_eq(unsigned sz, mpz * as, var * xs) {
}
void bound_propagator::init_eq(linear_equation * eq) {
if (eq == 0)
if (eq == nullptr)
return;
unsigned c_idx = m_constraints.size();
m_constraints.push_back(constraint());
@ -383,7 +383,7 @@ bool bound_propagator::relevant_bound(var x, double new_k) const {
if (LOWER && has_lower(x)) tout << "old: " << m.to_string(m_lowers[x]->m_k) << " | " << m_lowers[x]->m_approx_k << "\n";
if (!LOWER && has_upper(x)) tout << "old: " << m.to_string(m_uppers[x]->m_k) << " | " << m_uppers[x]->m_approx_k << "\n";);
bound * b = LOWER ? m_lowers[x] : m_uppers[x];
if (b == 0)
if (b == nullptr)
return true; // variable did not have a bound
double interval_size;
@ -537,7 +537,7 @@ bool bound_propagator::propagate_eq(unsigned c_idx) {
bound * u_i = m_uppers[x_i];
if (a_i < 0.0) {
if (!ll_failed) {
if (l_i == 0) {
if (l_i == nullptr) {
if (ll_i == UINT_MAX)
ll_i = i;
else
@ -549,7 +549,7 @@ bool bound_propagator::propagate_eq(unsigned c_idx) {
}
if (!uu_failed) {
if (u_i == 0) {
if (u_i == nullptr) {
if (uu_i == UINT_MAX)
uu_i = i;
else
@ -562,7 +562,7 @@ bool bound_propagator::propagate_eq(unsigned c_idx) {
}
else {
if (!ll_failed) {
if (u_i == 0) {
if (u_i == nullptr) {
if (ll_i == UINT_MAX)
ll_i = i;
else
@ -574,7 +574,7 @@ bool bound_propagator::propagate_eq(unsigned c_idx) {
}
if (!uu_failed) {
if (l_i == 0) {
if (l_i == nullptr) {
if (uu_i == UINT_MAX)
uu_i = i;
else
@ -780,7 +780,7 @@ bool bound_propagator::upper(var x, mpq & k, bool & strict, unsigned & ts) const
bound_propagator::bound * bound_propagator::bound::at(unsigned timestamp) {
bound * r = this;
while (r != 0 && r->m_timestamp >= timestamp)
while (r != nullptr && r->m_timestamp >= timestamp)
r = r->m_prev;
return r;
}

6
src/tactic/arith/bv2int_rewriter.cpp
View file

@ -38,7 +38,7 @@ void bv2int_rewriter_ctx::collect_power2(goal const& s) {
expr* f = s.form(j);
if (!m.is_or(f)) continue;
unsigned sz = to_app(f)->get_num_args();
expr* x, *y, *v = 0;
expr* x, *y, *v = nullptr;
rational n;
vector<rational> bounds;
bool is_int, ok = true;
@ -50,12 +50,12 @@ void bv2int_rewriter_ctx::collect_power2(goal const& s) {
break;
}
if (arith.is_numeral(y, n, is_int) && is_int &&
(x == v || v == 0)) {
(x == v || v == nullptr)) {
v = x;
bounds.push_back(n);
}
else if (arith.is_numeral(x, n, is_int) && is_int &&
(y == v || v == 0)) {
(y == v || v == nullptr)) {
v = y;
bounds.push_back(n);
}

2
src/tactic/arith/bv2int_rewriter.h
View file

@ -103,7 +103,7 @@ struct bv2int_rewriter_cfg : public default_rewriter_cfg {
bool rewrite_patterns() const { return false; }
bool flat_assoc(func_decl * f) const { return false; }
br_status reduce_app(func_decl * f, unsigned num, expr * const * args, expr_ref & result, proof_ref & result_pr) {
result_pr = 0;
result_pr = nullptr;
return m_r.mk_app_core(f, num, args, result);
}
bv2int_rewriter_cfg(ast_manager & m, bv2int_rewriter_ctx& ctx):m_r(m, ctx) {}

4
src/tactic/arith/bv2real_rewriter.h
View file

@ -181,7 +181,7 @@ struct bv2real_rewriter_cfg : public default_rewriter_cfg {
bool rewrite_patterns() const { return false; }
bool flat_assoc(func_decl * f) const { return false; }
br_status reduce_app(func_decl * f, unsigned num, expr * const * args, expr_ref & result, proof_ref & result_pr) {
result_pr = 0;
result_pr = nullptr;
return m_r.mk_app_core(f, num, args, result);
}
bv2real_rewriter_cfg(ast_manager & m, bv2real_util& u):m_r(m, u) {}
@ -216,7 +216,7 @@ struct bv2real_elim_rewriter_cfg : public default_rewriter_cfg {
bool rewrite_patterns() const { return false; }
bool flat_assoc(func_decl * f) const { return false; }
br_status reduce_app(func_decl * f, unsigned num, expr * const * args, expr_ref & result, proof_ref & result_pr) {
result_pr = 0;
result_pr = nullptr;
return m_r.mk_app_core(f, num, args, result);
}
bv2real_elim_rewriter_cfg(bv2real_util& u):m_r(u) {}

14
src/tactic/arith/card2bv_tactic.cpp
View file

@ -36,24 +36,24 @@ public:
m_params(p) {
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(card2bv_tactic, m, m_params);
}
virtual ~card2bv_tactic() {
~card2bv_tactic() override {
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_params = p;
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
r.insert("keep_cardinality_constraints", CPK_BOOL, "(default: true) retain cardinality constraints for solver");
}
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result) {
void operator()(goal_ref const & g,
goal_ref_buffer & result) override {
TRACE("card2bv-before", g->display(tout););
SASSERT(g->is_well_sorted());
result.reset();
@ -97,7 +97,7 @@ public:
SASSERT(g->is_well_sorted());
}
virtual void cleanup() {
void cleanup() override {
}
};

2
src/tactic/arith/card2bv_tactic.h
View file

@ -79,7 +79,7 @@ namespace pb {
bool rewrite_patterns() const { return false; }
bool flat_assoc(func_decl * f) const { return false; }
br_status reduce_app(func_decl * f, unsigned num, expr * const * args, expr_ref & result, proof_ref & result_pr) {
result_pr = 0;
result_pr = nullptr;
return m_r.mk_app_core(f, num, args, result);
}
card2bv_rewriter_cfg(ast_manager & m):m_r(m) {}

18
src/tactic/arith/degree_shift_tactic.cpp
View file

@ -93,7 +93,7 @@ class degree_shift_tactic : public tactic {
m_autil(_m),
m_pinned(_m),
m_one(1),
m_rw(0) {
m_rw(nullptr) {
}
@ -196,7 +196,7 @@ class degree_shift_tactic : public tactic {
void prepare_substitution(model_converter_ref & mc) {
SASSERT(!m_var2degree.empty());
generic_model_converter * xmc = 0;
generic_model_converter * xmc = nullptr;
if (m_produce_models) {
xmc = alloc(generic_model_converter, m, "degree_shift");
mc = xmc;
@ -257,12 +257,12 @@ class degree_shift_tactic : public tactic {
if (kv.m_value.is_even()) {
app * new_var = m_var2var.find(kv.m_key);
app * new_c = m_autil.mk_ge(new_var, m_autil.mk_numeral(rational(0), false));
proof * new_pr = 0;
proof * new_pr = nullptr;
if (m_produce_proofs) {
proof * pr = m_var2pr.find(kv.m_key);
new_pr = m.mk_th_lemma(m_autil.get_family_id(), new_c, 1, &pr);
}
g->assert_expr(new_c, new_pr, 0);
g->assert_expr(new_c, new_pr, nullptr);
}
}
}
@ -280,20 +280,20 @@ public:
m_imp = alloc(imp, m);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(degree_shift_tactic, m);
}
virtual ~degree_shift_tactic() {
~degree_shift_tactic() override {
dealloc(m_imp);
}
virtual void operator()(goal_ref const & in,
goal_ref_buffer & result) {
void operator()(goal_ref const & in,
goal_ref_buffer & result) override {
(*m_imp)(in, result);
}
virtual void cleanup() {
void cleanup() override {
imp * d = alloc(imp, m_imp->m);
std::swap(d, m_imp);
dealloc(d);

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

@ -95,13 +95,13 @@ class diff_neq_tactic : public tactic {
if (is_uninterp_const(lhs) && u.is_numeral(rhs, k) && m_max_neg_k <= k && k <= m_max_k) {
var x = mk_var(lhs);
int _k = static_cast<int>(k.get_int64());
m_upper[x] = _k;
m_upper[x] = std::min(m_upper[x], _k);
}
else if (is_uninterp_const(rhs) && u.is_numeral(lhs, k) && m_max_neg_k <= k && k <= m_max_k) {
var x = mk_var(rhs);
int _k = static_cast<int>(k.get_int64());
m_lower[x] = _k;
m_lower[x] = std::max(m_lower[x], _k);
}
else {
throw_not_supported();
@ -352,28 +352,28 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(diff_neq_tactic, m, m_params);
}
virtual ~diff_neq_tactic() {
~diff_neq_tactic() override {
dealloc(m_imp);
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_params = p;
m_imp->updt_params(p);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
r.insert("diff_neq_max_k", CPK_UINT, "(default: 1024) maximum variable upper bound for diff neq solver.");
}
virtual void collect_statistics(statistics & st) const {
void collect_statistics(statistics & st) const override {
st.update("conflicts", m_imp->m_num_conflicts);
}
virtual void reset_statistics() {
void reset_statistics() override {
m_imp->m_num_conflicts = 0;
}
@ -381,12 +381,12 @@ public:
\brief Fix a DL variable in s to 0.
If s is not really in the difference logic fragment, then this is a NOOP.
*/
virtual void operator()(goal_ref const & in,
goal_ref_buffer & result) {
void operator()(goal_ref const & in,
goal_ref_buffer & result) override {
(*m_imp)(in, result);
}
virtual void cleanup() {
void cleanup() override {
imp * d = alloc(imp, m_imp->m, m_params);
d->m_num_conflicts = m_imp->m_num_conflicts;
std::swap(d, m_imp);

267
src/tactic/arith/elim01_tactic.cpp Normal file
View file

@ -0,0 +1,267 @@
/*++
Copyright (c) 2013 Microsoft Corporation
Module Name:
elim01_tactic.cpp
Abstract:
Replace 0-1 integer variables by Booleans.
Author:
Nikolaj Bjorner (nbjorner) 2013-12-7
Notes:
--*/
#include "tactic/tactical.h"
#include "util/cooperate.h"
#include "tactic/arith/bound_manager.h"
#include "ast/ast_pp.h"
#include "ast/rewriter/expr_safe_replace.h"
#include "ast/arith_decl_plugin.h"
#include "tactic/arith/elim01_tactic.h"
#include "model/model_smt2_pp.h"
#include "ast/rewriter/th_rewriter.h"
class bool2int_model_converter : public model_converter {
ast_manager& m;
arith_util a;
func_decl_ref_vector m_refs;
obj_hashtable<func_decl> m_bools;
vector<ptr_vector<func_decl> > m_nums_as_bool;
ptr_vector<func_decl> m_nums_as_int;
public:
bool2int_model_converter(ast_manager& m):
m(m),
a(m),
m_refs(m)
{}
void operator()(model_ref & old_model, unsigned goal_idx) override {
SASSERT(goal_idx == 0);
model * new_model = alloc(model, m);
unsigned num = old_model->get_num_constants();
for (unsigned i = 0; i < m_nums_as_int.size(); ++i) {
func_decl* f_old = m_nums_as_int[i];
rational val(0);
rational po(1);
bool is_value = true;
for (unsigned j = 0; is_value && j < m_nums_as_bool[i].size(); ++j) {
func_decl* f = m_nums_as_bool[i][j];
expr* fi = old_model->get_const_interp(f);
if (!fi) {
is_value = false;
}
else if (m.is_true(fi)) {
val += po;
}
else if (!m.is_false(fi)) {
is_value = false;
}
po *= rational(2);
}
if (is_value) {
expr* fi = a.mk_numeral(val, true);
new_model->register_decl(f_old, fi);
}
}
for (unsigned i = 0; i < num; ++i) {
func_decl* f = old_model->get_constant(i);
expr* fi = old_model->get_const_interp(f);
if (!m_bools.contains(f)) {
new_model->register_decl(f, fi);
}
}
num = old_model->get_num_functions();
for (unsigned i = 0; i < num; i++) {
func_decl * f = old_model->get_function(i);
func_interp * fi = old_model->get_func_interp(f);
new_model->register_decl(f, fi->copy());
}
new_model->copy_usort_interps(*old_model);
old_model = new_model;
}
void insert(func_decl* x_new, func_decl* x_old) {
m_refs.push_back(x_new);
m_refs.push_back(x_old);
m_bools.insert(x_new);
m_nums_as_int.push_back(x_old);
m_nums_as_bool.push_back(ptr_vector<func_decl>());
m_nums_as_bool.back().push_back(x_new);
}
void insert(func_decl* x_old, unsigned sz, func_decl * const* x_new) {
m_nums_as_int.push_back(x_old);
m_nums_as_bool.push_back(ptr_vector<func_decl>());
m_refs.push_back(x_old);
for (unsigned i = 0; i < sz; ++i) {
m_refs.push_back(x_new[i]);
m_nums_as_bool.back().push_back(x_new[i]);
m_bools.insert(x_new[i]);
}
}
model_converter * translate(ast_translation & translator) override {
bool2int_model_converter* mc = alloc(bool2int_model_converter, translator.to());
for (unsigned i = 0; i < m_nums_as_int.size(); ++i) {
mc->insert(m_nums_as_int[i], m_nums_as_bool[i].size(), m_nums_as_bool[i].c_ptr());
}
return mc;
}
};
class elim01_tactic : public tactic {
public:
typedef obj_hashtable<expr> expr_set;
ast_manager & m;
arith_util a;
th_rewriter m_rewriter;
params_ref m_params;
unsigned m_max_hi_default;
rational m_max_hi;
elim01_tactic(ast_manager & _m, params_ref const & p):
m(_m),
a(m),
m_rewriter(m),
m_max_hi_default(8),
m_max_hi(rational(m_max_hi_default)) {
}
~elim01_tactic() override {
}
void updt_params(params_ref const & p) override {
m_max_hi = rational(p.get_uint("max_coefficient", m_max_hi_default));
m_params = p;
}
void collect_param_descrs(param_descrs & r) override {
r.insert("max_coefficient", CPK_UINT, "(default: 1) maximal upper bound for finite range -> Bool conversion");
}
void operator()(goal_ref const & g,
goal_ref_buffer & result,
model_converter_ref & mc,
proof_converter_ref & pc,
expr_dependency_ref & core) override {
SASSERT(g->is_well_sorted());
mc = nullptr; pc = nullptr; core = nullptr;
tactic_report report("elim01", *g);
expr_safe_replace sub(m);
bool2int_model_converter* b2i = alloc(bool2int_model_converter, m);
mc = b2i;
bound_manager bounds(m);
expr_ref_vector axioms(m);
bounds(*g);
rational zero(0);
bound_manager::iterator bit = bounds.begin(), bend = bounds.end();
for (; bit != bend; ++bit) {
if (!is_app(*bit)) continue;
app* x = to_app(*bit);
bool s1 = false, s2 = false;
rational lo, hi;
if (a.is_int(x) &&
bounds.has_lower(x, lo, s1) && !s1 && zero <= lo &&
bounds.has_upper(x, hi, s2) && !s2 && hi <= m_max_hi && lo <= hi) {
add_variable(b2i, sub, x, lo.get_unsigned(), hi.get_unsigned(), axioms);
}
else if (a.is_int(x)) {
TRACE("pb", tout << "Not adding variable " << mk_pp(x, m) << " has lower: "
<< bounds.has_lower(x, lo, s1) << " " << lo << " has upper: "
<< bounds.has_upper(x, hi, s2) << " " << hi << "\n";);
}
}
if (sub.empty()) {
result.push_back(g.get());
return;
}
expr_ref new_curr(m), tmp_curr(m);
proof_ref new_pr(m);
for (unsigned i = 0; i < g->size(); i++) {
expr * curr = g->form(i);
sub(curr, tmp_curr);
m_rewriter(tmp_curr, new_curr);
if (m.proofs_enabled()) {
new_pr = m.mk_rewrite(curr, new_curr);
new_pr = m.mk_modus_ponens(g->pr(i), new_pr);
}
g->update(i, new_curr, new_pr, g->dep(i));
}
for (unsigned i = 0; i < axioms.size(); ++i) {
g->assert_expr(axioms[i].get());
}
g->inc_depth();
result.push_back(g.get());
TRACE("pb", g->display(tout););
SASSERT(g->is_well_sorted());
// TBD: support proof conversion (or not..)
}
tactic * translate(ast_manager & m) override {
return alloc(elim01_tactic, m, m_params);
}
void cleanup() override {}
void add_variable(bool2int_model_converter* b2i,
expr_safe_replace& sub,
app* x,
unsigned min_value,
unsigned max_value,
expr_ref_vector& axioms) {
std::string name = x->get_decl()->get_name().str();
unsigned sh = 0;
app_ref_vector xs(m), ites(m);
func_decl_ref_vector xfs(m);
app_ref zero(m), sum(m);
zero = a.mk_numeral(rational(0), true);
while (max_value >= (1ul << sh)) {
xs.push_back(m.mk_fresh_const(name.c_str(), m.mk_bool_sort()));
xfs.push_back(xs.back()->get_decl());
ites.push_back(m.mk_ite(xs.back(), a.mk_numeral(rational(1 << sh), true), zero));
++sh;
}
switch (ites.size()) {
case 0:
sum = zero;
break;
case 1:
sum = ites[0].get();
break;
default:
sum = a.mk_add(ites.size(), (expr*const*)ites.c_ptr());
break;
}
TRACE("pb", tout << mk_pp(x, m) << " " << sum << " max: " << max_value << "\n";);
sub.insert(x, sum);
b2i->insert(x->get_decl(), xfs.size(), xfs.c_ptr());
// if max_value+1 is not a power of two:
if ((max_value & (max_value + 1)) != 0) {
axioms.push_back(a.mk_le(sum, a.mk_numeral(rational(max_value), true)));
}
if (min_value > 0) {
axioms.push_back(a.mk_ge(sum, a.mk_numeral(rational(min_value), true)));
}
}
};
tactic * mk_elim01_tactic(ast_manager & m, params_ref const & p) {
return clean(alloc(elim01_tactic, m, p));
}

20
src/tactic/arith/eq2bv_tactic.cpp
View file

@ -59,7 +59,7 @@ class eq2bv_tactic : public tactic {
bool rewrite_patterns() const { return false; }
bool flat_assoc(func_decl * f) const { return false; }
br_status reduce_app(func_decl * f, unsigned num, expr * const * args, expr_ref & result, proof_ref & result_pr) {
result_pr = 0;
result_pr = nullptr;
return mk_app_core(f, num, args, result);
}
eq_rewriter_cfg(eq2bv_tactic& t):m(t.m), t(t) {}
@ -82,7 +82,7 @@ class eq2bv_tactic : public tactic {
m_map.insert(c_new, c_old);
}
virtual void operator()(model_ref& mdl) {
void operator()(model_ref& mdl) override {
ast_manager& m = mdl->get_manager();
bv_util bv(m);
arith_util a(m);
@ -105,7 +105,7 @@ class eq2bv_tactic : public tactic {
mdl = new_m;
}
virtual model_converter* translate(ast_translation & translator) {
model_converter* translate(ast_translation & translator) override {
bvmc* v = alloc(bvmc);
for (auto const& kv : m_map) {
v->m_map.insert(translator(kv.m_key), translator(kv.m_value));
@ -144,14 +144,14 @@ public:
m_bounds(m) {
}
virtual ~eq2bv_tactic() {
~eq2bv_tactic() override {
}
void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
}
virtual void operator()(goal_ref const & g, goal_ref_buffer & result) {
void operator()(goal_ref const & g, goal_ref_buffer & result) override {
SASSERT(g->is_well_sorted());
m_trail.reset();
m_fd.reset();
@ -178,7 +178,7 @@ public:
expr_ref new_curr(m);
proof_ref new_pr(m);
if (is_bound(g->form(i))) {
g->update(i, m.mk_true(), 0, 0);
g->update(i, m.mk_true(), nullptr, nullptr);
continue;
}
m_rw(g->form(i), new_curr, new_pr);
@ -215,14 +215,14 @@ public:
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(eq2bv_tactic, m);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
}
virtual void cleanup() {
void cleanup() override {
}
void cleanup_fd(ref<bvmc>& mc) {

14
src/tactic/arith/factor_tactic.cpp
View file

@ -289,27 +289,27 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(factor_tactic, m, m_params);
}
virtual ~factor_tactic() {
~factor_tactic() override {
dealloc(m_imp);
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_params = p;
m_imp->m_rw.cfg().updt_params(p);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
r.insert("split_factors", CPK_BOOL,
"(default: true) apply simplifications such as (= (* p1 p2) 0) --> (or (= p1 0) (= p2 0)).");
polynomial::factor_params::get_param_descrs(r);
}
virtual void operator()(goal_ref const & in,
goal_ref_buffer & result) {
void operator()(goal_ref const & in,
goal_ref_buffer & result) override {
try {
(*m_imp)(in, result);
}
@ -321,7 +321,7 @@ public:
}
}
virtual void cleanup() {
void cleanup() override {
imp * d = alloc(imp, m_imp->m, m_params);
std::swap(d, m_imp);
dealloc(d);

24
src/tactic/arith/fix_dl_var_tactic.cpp
View file

@ -44,7 +44,7 @@ class fix_dl_var_tactic : public tactic {
m_util(u) {
}
void throw_failed(expr * ctx1, expr * ctx2 = 0) {
void throw_failed(expr * ctx1, expr * ctx2 = nullptr) {
TRACE("fix_dl_var", tout << mk_ismt2_pp(ctx1, m) << "\n"; if (ctx2) tout << mk_ismt2_pp(ctx2, m) << "\n";);
throw failed();
}
@ -178,7 +178,7 @@ class fix_dl_var_tactic : public tactic {
}
app * most_occs(obj_map<app, unsigned> & occs, unsigned & best) {
app * r = 0;
app * r = nullptr;
best = 0;
obj_map<app, unsigned>::iterator it = occs.begin();
obj_map<app, unsigned>::iterator end = occs.end();
@ -196,7 +196,7 @@ class fix_dl_var_tactic : public tactic {
app * most_occs() {
// We try to choose a variable that when set to 0 will generate many bounded variables.
// That is why we give preference to variables occuring in non-nested inequalities.
// That is why we give preference to variables occurring in non-nested inequalities.
unsigned best1, best2;
app * r1, * r2;
r1 = most_occs(m_non_nested_occs, best1);
@ -227,7 +227,7 @@ class fix_dl_var_tactic : public tactic {
return most_occs();
}
catch (failed) {
return 0;
return nullptr;
}
}
};
@ -256,7 +256,7 @@ class fix_dl_var_tactic : public tactic {
m_produce_models = g->models_enabled();
app * var = is_target(u)(*g);
if (var != 0) {
if (var != nullptr) {
IF_VERBOSE(TACTIC_VERBOSITY_LVL, verbose_stream() << "(fixing-at-zero " << var->get_decl()->get_name() << ")\n";);
tactic_report report("fix-dl-var", *g);
@ -299,25 +299,25 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(fix_dl_var_tactic, m, m_params);
}
virtual ~fix_dl_var_tactic() {
~fix_dl_var_tactic() override {
dealloc(m_imp);
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_params = p;
m_imp->updt_params(p);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
th_rewriter::get_param_descrs(r);
}
virtual void operator()(goal_ref const & in,
goal_ref_buffer & result) {
void operator()(goal_ref const & in,
goal_ref_buffer & result) override {
try {
(*m_imp)(in, result);
}
@ -326,7 +326,7 @@ public:
}
}
virtual void cleanup() {
void cleanup() override {
imp * d = alloc(imp, m_imp->m, m_params);
std::swap(d, m_imp);
dealloc(d);

54
src/tactic/arith/fm_tactic.cpp
View file

@ -54,7 +54,7 @@ class fm_tactic : public tactic {
bool is_false(model_ref & md, app * p) {
SASSERT(is_uninterp_const(p));
expr * val = md->get_const_interp(p->get_decl());
if (val == 0) {
if (val == nullptr) {
// if it is don't care, then set to false
md->register_decl(p->get_decl(), m.mk_false());
return true;
@ -164,7 +164,7 @@ class fm_tactic : public tactic {
public:
fm_model_converter(ast_manager & _m):m(_m) {}
virtual ~fm_model_converter() {
~fm_model_converter() override {
m.dec_array_ref(m_xs.size(), m_xs.c_ptr());
vector<clauses>::iterator it = m_clauses.begin();
vector<clauses>::iterator end = m_clauses.end();
@ -180,9 +180,9 @@ class fm_tactic : public tactic {
m_clauses.back().swap(c);
}
virtual void get_units(obj_map<expr, bool>& units) { units.reset(); }
void get_units(obj_map<expr, bool>& units) override { units.reset(); }
virtual void operator()(model_ref & md) {
void operator()(model_ref & md) override {
TRACE("fm_mc", model_v2_pp(tout, *md); display(tout););
model_evaluator ev(*(md.get()));
ev.set_model_completion(true);
@ -246,7 +246,7 @@ class fm_tactic : public tactic {
}
virtual void display(std::ostream & out) {
void display(std::ostream & out) override {
out << "(fm-model-converter";
SASSERT(m_xs.size() == m_clauses.size());
unsigned sz = m_xs.size();
@ -263,7 +263,7 @@ class fm_tactic : public tactic {
out << ")\n";
}
virtual model_converter * translate(ast_translation & translator) {
model_converter * translate(ast_translation & translator) override {
ast_manager & to_m = translator.to();
fm_model_converter * res = alloc(fm_model_converter, to_m);
unsigned sz = m_xs.size();
@ -830,7 +830,7 @@ class fm_tactic : public tactic {
reset_constraints();
m_bvar2expr.reset();
m_bvar2sign.reset();
m_bvar2expr.push_back(0); // bvar 0 is not used
m_bvar2expr.push_back(nullptr); // bvar 0 is not used
m_bvar2sign.push_back(0);
m_expr2var.reset();
m_is_int.reset();
@ -840,11 +840,11 @@ class fm_tactic : public tactic {
m_expr2var.reset();
m_lowers.reset();
m_uppers.reset();
m_new_goal = 0;
m_mc = 0;
m_new_goal = nullptr;
m_mc = nullptr;
m_counter = 0;
m_inconsistent = false;
m_inconsistent_core = 0;
m_inconsistent_core = nullptr;
init_forbidden_set(g);
}
@ -880,7 +880,7 @@ class fm_tactic : public tactic {
// 0 <= 0 -- > true
if (c.m_c.is_pos() || (!c.m_strict && c.m_c.is_zero()))
return m.mk_true();
ineq = 0;
ineq = nullptr;
}
else {
bool int_cnstr = all_int(c);
@ -1117,7 +1117,7 @@ class fm_tactic : public tactic {
}
else {
TRACE("add_constraint_bug", tout << "all variables are forbidden "; display(tout, *c); tout << "\n";);
m_new_goal->assert_expr(to_expr(*c), 0, c->m_dep);
m_new_goal->assert_expr(to_expr(*c), nullptr, c->m_dep);
del_constraint(c);
return false;
}
@ -1132,7 +1132,7 @@ class fm_tactic : public tactic {
if (is_occ(f))
add_constraint(f, g.dep(i));
else
m_new_goal->assert_expr(f, 0, g.dep(i));
m_new_goal->assert_expr(f, nullptr, g.dep(i));
}
}
@ -1369,7 +1369,7 @@ class fm_tactic : public tactic {
display(tout, l);
tout << "\n";
display(tout, u); tout << "\n";);
return 0; // no constraint needs to be created.
return nullptr; // no constraint needs to be created.
}
new_lits.reset();
@ -1413,7 +1413,7 @@ class fm_tactic : public tactic {
display(tout, l);
tout << "\n";
display(tout, u); tout << "\n";);
return 0;
return nullptr;
}
expr_dependency * new_dep = m.mk_join(l.m_dep, u.m_dep);
@ -1425,7 +1425,7 @@ class fm_tactic : public tactic {
display(tout, u); tout << "\n";);
m_inconsistent = true;
m_inconsistent_core = new_dep;
return 0;
return nullptr;
}
constraint * new_cnstr = mk_constraint(new_lits.size(),
@ -1495,7 +1495,7 @@ class fm_tactic : public tactic {
constraint const & l_c = *(l[i]);
constraint const & u_c = *(u[j]);
constraint * new_c = resolve(l_c, u_c, x);
if (new_c != 0) {
if (new_c != nullptr) {
num_new_cnstrs++;
new_constraints.push_back(new_c);
}
@ -1530,7 +1530,7 @@ class fm_tactic : public tactic {
c->m_dead = true;
expr * new_f = to_expr(*c);
TRACE("fm_bug", tout << "asserting...\n" << mk_ismt2_pp(new_f, m) << "\nnew_dep: " << c->m_dep << "\n";);
m_new_goal->assert_expr(new_f, 0, c->m_dep);
m_new_goal->assert_expr(new_f, nullptr, c->m_dep);
}
}
}
@ -1569,7 +1569,7 @@ class fm_tactic : public tactic {
if (m_inconsistent) {
m_new_goal->reset();
m_new_goal->assert_expr(m.mk_false(), 0, m_inconsistent_core);
m_new_goal->assert_expr(m.mk_false(), nullptr, m_inconsistent_core);
}
else {
TRACE("fm", display(tout););
@ -1593,7 +1593,7 @@ class fm_tactic : public tactic {
eliminated++;
if (m_inconsistent) {
m_new_goal->reset();
m_new_goal->assert_expr(m.mk_false(), 0, m_inconsistent_core);
m_new_goal->assert_expr(m.mk_false(), nullptr, m_inconsistent_core);
break;
}
}
@ -1641,20 +1641,20 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(fm_tactic, m, m_params);
}
virtual ~fm_tactic() {
~fm_tactic() override {
dealloc(m_imp);
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_params = p;
m_imp->updt_params(p);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
insert_produce_models(r);
insert_max_memory(r);
r.insert("fm_real_only", CPK_BOOL, "(default: true) consider only real variables for fourier-motzkin elimination.");
@ -1666,14 +1666,14 @@ public:
}
virtual void cleanup() {
void cleanup() override {
imp * d = alloc(imp, m_imp->m, m_params);
std::swap(d, m_imp);
dealloc(d);
}
virtual void operator()(goal_ref const & in,
goal_ref_buffer & result) {
void operator()(goal_ref const & in,
goal_ref_buffer & result) override {
(*m_imp)(in, result);
}
};

17
src/tactic/arith/lia2card_tactic.cpp
View file

@ -91,7 +91,7 @@ class lia2card_tactic : public tactic {
bool rewrite_patterns() const { return false; }
bool flat_assoc(func_decl * f) const { return false; }
br_status reduce_app(func_decl * f, unsigned num, expr * const * args, expr_ref & result, proof_ref & result_pr) {
result_pr = 0;
result_pr = nullptr;
return mk_app_core(f, num, args, result);
}
lia_rewriter_cfg(lia2card_tactic& t):m(t.m), t(t), a(m), args(m) {}
@ -129,11 +129,11 @@ public:
m_max_ub = 100;
}
virtual ~lia2card_tactic() {
~lia2card_tactic() override {
dealloc(m_todo);
}
void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_params = p;
m_compile_equality = p.get_bool("compile_equality", true);
}
@ -161,7 +161,7 @@ public:
return expr_ref(r, m);
}
virtual void operator()(goal_ref const & g, goal_ref_buffer & result) {
void operator()(goal_ref const & g, goal_ref_buffer & result) override {
SASSERT(g->is_well_sorted());
m_bounds.reset();
m_mc.reset();
@ -351,21 +351,20 @@ public:
}
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(lia2card_tactic, m, m_params);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
r.insert("compile_equality", CPK_BOOL,
"(default:false) compile equalities into pseudo-Boolean equality");
}
virtual void cleanup() {
bounds_map* d = alloc(bounds_map);
void cleanup() override {
ptr_vector<expr>* todo = alloc(ptr_vector<expr>);
std::swap(m_todo, todo);
dealloc(d);
dealloc(todo);
m_bounds.reset();
}
};

24
src/tactic/arith/lia2pb_tactic.cpp
View file

@ -244,7 +244,7 @@ class lia2pb_tactic : public tactic {
rational a(1);
unsigned num_bits = u.get_num_bits();
for (unsigned i = 0; i < num_bits; i++) {
app * x_prime = m.mk_fresh_const(0, m_util.mk_int());
app * x_prime = m.mk_fresh_const(nullptr, m_util.mk_int());
g->assert_expr(m_util.mk_le(zero, x_prime));
g->assert_expr(m_util.mk_le(x_prime, one));
if (a.is_one())
@ -257,14 +257,14 @@ class lia2pb_tactic : public tactic {
}
SASSERT(def_args.size() > 1);
expr * def = m_util.mk_add(def_args.size(), def_args.c_ptr());
expr_dependency * dep = 0;
expr_dependency * dep = nullptr;
if (m_produce_unsat_cores) {
dep = m.mk_join(m_bm.lower_dep(x), m_bm.upper_dep(x));
if (dep != 0)
if (dep != nullptr)
m_new_deps.push_back(dep);
}
TRACE("lia2pb", tout << mk_ismt2_pp(x, m) << " -> " << dep << "\n";);
subst.insert(x, def, 0, dep);
subst.insert(x, def, nullptr, dep);
if (m_produce_models) {
gmc->add(x, def);
}
@ -280,7 +280,7 @@ class lia2pb_tactic : public tactic {
unsigned size = g->size();
for (unsigned idx = 0; idx < size; idx++) {
expr * curr = g->form(idx);
expr_dependency * dep = 0;
expr_dependency * dep = nullptr;
m_rw(curr, new_curr, new_pr);
if (m_produce_unsat_cores) {
dep = m.mk_join(m_rw.get_used_dependencies(), g->dep(idx));
@ -307,27 +307,27 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(lia2pb_tactic, m, m_params);
}
virtual ~lia2pb_tactic() {
~lia2pb_tactic() override {
dealloc(m_imp);
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_params = p;
m_imp->updt_params(p);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
r.insert("lia2pb_partial", CPK_BOOL, "(default: false) partial lia2pb conversion.");
r.insert("lia2pb_max_bits", CPK_UINT, "(default: 32) maximum number of bits to be used (per variable) in lia2pb.");
r.insert("lia2pb_total_bits", CPK_UINT, "(default: 2048) total number of bits to be used (per problem) in lia2pb.");
}
virtual void operator()(goal_ref const & in,
goal_ref_buffer & result) {
void operator()(goal_ref const & in,
goal_ref_buffer & result) override {
try {
(*m_imp)(in, result);
}
@ -336,7 +336,7 @@ public:
}
}
virtual void cleanup() {
void cleanup() override {
imp * d = alloc(imp, m_imp->m, m_params);
std::swap(d, m_imp);
dealloc(d);

4
src/tactic/arith/linear_equation.cpp
View file

@ -174,7 +174,7 @@ linear_equation * linear_equation_manager::mk(unsigned sz, mpz * as, var * xs, b
}
sz = j;
if (sz <= 1)
return 0;
return nullptr;
}
else {
DEBUG_CODE({
@ -265,7 +265,7 @@ linear_equation * linear_equation_manager::mk(mpz const & b1, linear_equation co
m.del(new_a);
SASSERT(m_int_buffer.size() == m_var_buffer.size());
if (m_int_buffer.empty())
return 0;
return nullptr;
return mk_core(m_int_buffer.size(), m_int_buffer.c_ptr(), m_var_buffer.c_ptr());
}

20
src/tactic/arith/nla2bv_tactic.cpp
View file

@ -74,7 +74,7 @@ class nla2bv_tactic : public tactic {
m_vars(m),
m_defs(m),
m_trail(m),
m_fmc(0) {
m_fmc(nullptr) {
m_default_bv_size = m_num_bits = p.get_uint("nla2bv_bv_size", 4);
}
@ -406,28 +406,28 @@ class nla2bv_tactic : public tactic {
}
~scoped_set_imp() {
m_owner.m_imp = 0;
m_owner.m_imp = nullptr;
}
};
public:
nla2bv_tactic(params_ref const & p):
m_params(p),
m_imp(0) {
m_imp(nullptr) {
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(nla2bv_tactic, m_params);
}
virtual ~nla2bv_tactic() {
~nla2bv_tactic() override {
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_params = p;
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
r.insert("nla2bv_max_bv_size", CPK_UINT, "(default: inf) maximum bit-vector size used by nla2bv tactic");
r.insert("nla2bv_bv_size", CPK_UINT, "(default: 4) default bit-vector size used by nla2bv tactic.");
r.insert("nla2bv_root", CPK_UINT, "(default: 2) nla2bv tactic encodes reals into bit-vectors using expressions of the form a+b*sqrt(c), this parameter sets the value of c used in the encoding.");
@ -439,8 +439,8 @@ public:
arithmetic in place of non-linear integer arithmetic.
\return false if transformation is not possible.
*/
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result) {
void operator()(goal_ref const & g,
goal_ref_buffer & result) override {
SASSERT(g->is_well_sorted());
fail_if_proof_generation("nla2bv", g);
fail_if_unsat_core_generation("nla2bv", g);
@ -455,7 +455,7 @@ public:
SASSERT(g->is_well_sorted());
}
virtual void cleanup(void) {
void cleanup() override {
}
};

18
src/tactic/arith/normalize_bounds_tactic.cpp
View file

@ -92,7 +92,7 @@ class normalize_bounds_tactic : public tactic {
return;
}
generic_model_converter * gmc = 0;
generic_model_converter * gmc = nullptr;
if (produce_models) {
gmc = alloc(generic_model_converter, m, "normalize_bounds");
in->add(gmc);
@ -105,7 +105,7 @@ class normalize_bounds_tactic : public tactic {
if (is_target(x, val)) {
num_norm_bounds++;
sort * s = m.get_sort(x);
app * x_prime = m.mk_fresh_const(0, s);
app * x_prime = m.mk_fresh_const(nullptr, s);
expr * def = m_util.mk_add(x_prime, m_util.mk_numeral(val, s));
subst.insert(x, def);
if (produce_models) {
@ -145,25 +145,25 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(normalize_bounds_tactic, m, m_params);
}
virtual ~normalize_bounds_tactic() {
~normalize_bounds_tactic() override {
dealloc(m_imp);
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_imp->updt_params(p);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
insert_produce_models(r);
r.insert("norm_int_only", CPK_BOOL, "(default: true) normalize only the bounds of integer constants.");
}
virtual void operator()(goal_ref const & in,
goal_ref_buffer & result) {
void operator()(goal_ref const & in,
goal_ref_buffer & result) override {
try {
(*m_imp)(in, result);
}
@ -172,7 +172,7 @@ public:
}
}
virtual void cleanup() {
void cleanup() override {
ast_manager & m = m_imp->m;
imp * d = alloc(imp, m, m_params);
std::swap(d, m_imp);

4
src/tactic/arith/pb2bv_model_converter.cpp
View file

@ -38,7 +38,7 @@ pb2bv_model_converter::pb2bv_model_converter(ast_manager & _m, obj_map<func_decl
if (!c2bit.contains(d)) {
SASSERT(d->get_arity() == 0);
m.inc_ref(d);
m_c2bit.push_back(func_decl_pair(d, static_cast<func_decl*>(0)));
m_c2bit.push_back(func_decl_pair(d, static_cast<func_decl*>(nullptr)));
}
}
}
@ -62,7 +62,7 @@ void pb2bv_model_converter::operator()(model_ref & md) {
for (auto const& kv : m_c2bit) {
if (kv.second) {
expr * val = md->get_const_interp(kv.second);
if (val == 0 || m.is_false(val)) {
if (val == nullptr || m.is_false(val)) {
/* false's and don't cares get the integer 0 solution*/
md->register_decl(kv.first, a_util.mk_numeral(rational(0), true));
}

2
src/tactic/arith/pb2bv_model_converter.h
View file

@ -30,7 +30,7 @@ class pb2bv_model_converter : public model_converter {
public:
pb2bv_model_converter(ast_manager & _m);
pb2bv_model_converter(ast_manager & _m, obj_map<func_decl, expr*> const & c2bit, bound_manager const & bm);
virtual ~pb2bv_model_converter();
~pb2bv_model_converter() override;
void operator()(model_ref & md) override;
void display(std::ostream & out) override;
void get_units(obj_map<expr, bool>& units) override;

28
src/tactic/arith/pb2bv_tactic.cpp
View file

@ -216,7 +216,7 @@ private:
}
bool get_subst(expr * s, expr * & t, proof * & t_pr) {
t_pr = 0;
t_pr = nullptr;
if (owner.is_constraint_core(s)) {
owner.convert(to_app(s), m_saved_res, true, false);
t = m_saved_res;
@ -328,12 +328,12 @@ private:
func_decl * fd = x->get_decl();
obj_map<func_decl, expr*> & const2lit = sign ? m_not_const2bit : m_const2bit;
expr * r = 0;
expr * r = nullptr;
const2lit.find(fd, r);
if (r != 0)
if (r != nullptr)
return r;
r = m.mk_fresh_const(0, m.mk_bool_sort());
r = m.mk_fresh_const(nullptr, m.mk_bool_sort());
expr * not_r = m.mk_not(r);
m_const2bit.insert(fd, r);
m_not_const2bit.insert(fd, not_r);
@ -490,7 +490,7 @@ private:
for (unsigned j = 0; j < i; j++)
m_clause.push_back(monomial(numeral(1), m_p[j].m_lit));
app * new_var = m.mk_fresh_const(0, m_arith_util.mk_int());
app * new_var = m.mk_fresh_const(nullptr, m_arith_util.mk_int());
m_temporary_ints.push_back(new_var);
m_clause.push_back(monomial(numeral(1), lit(new_var, true)));
@ -943,7 +943,7 @@ private:
}
for (unsigned idx = 0; idx < size; idx++)
g->update(idx, new_exprs[idx].get(), 0, (m_produce_unsat_cores) ? new_deps[idx].get() : g->dep(idx));
g->update(idx, new_exprs[idx].get(), nullptr, (m_produce_unsat_cores) ? new_deps[idx].get() : g->dep(idx));
if (m_produce_models) {
model_converter_ref mc;
@ -980,29 +980,29 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(pb2bv_tactic, m, m_params);
}
virtual ~pb2bv_tactic() {
~pb2bv_tactic() override {
dealloc(m_imp);
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_params = p;
m_imp->updt_params(p);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
m_imp->collect_param_descrs(r);
}
virtual void operator()(goal_ref const & in,
goal_ref_buffer & result) {
void operator()(goal_ref const & in,
goal_ref_buffer & result) override {
(*m_imp)(in, result);
}
virtual void cleanup() {
void cleanup() override {
ast_manager & m = m_imp->m;
imp * d = alloc(imp, m, m_params);
std::swap(d, m_imp);
@ -1017,7 +1017,7 @@ tactic * mk_pb2bv_tactic(ast_manager & m, params_ref const & p) {
}
struct is_pb_probe : public probe {
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
try {
ast_manager & m = g.m();
bound_manager bm(m);

34
src/tactic/arith/probe_arith.cpp
View file

@ -74,7 +74,7 @@ class arith_degree_probe : public probe {
public:
arith_degree_probe(bool avg):m_avg(avg) {}
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
proc p(g.m());
for_each_expr_at(p, g);
if (m_avg)
@ -117,7 +117,7 @@ class arith_bw_probe : public probe {
public:
arith_bw_probe(bool avg):m_avg(avg) {}
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
proc p(g.m());
for_each_expr_at(p, g);
if (m_avg)
@ -269,14 +269,14 @@ static bool is_qfauflia(goal const & g) {
class is_qflia_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_qflia(g);
}
};
class is_qfauflia_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_qfauflia(g);
}
};
@ -288,7 +288,7 @@ static bool is_qflra(goal const & g) {
class is_qflra_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_qflra(g);
}
};
@ -300,7 +300,7 @@ static bool is_qflira(goal const & g) {
class is_qflira_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_qflira(g);
}
};
@ -344,14 +344,14 @@ static bool is_mip(goal const & g) {
class is_ilp_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_ilp(g);
}
};
class is_mip_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_mip(g);
}
};
@ -583,56 +583,56 @@ struct is_non_qfufnra_functor {
class is_qfnia_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_qfnia(g);
}
};
class is_qfnra_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_qfnra(g);
}
};
class is_nia_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_nia(g);
}
};
class is_nra_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_nra(g);
}
};
class is_nira_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_nira(g);
}
};
class is_lia_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_lia(g);
}
};
class is_lra_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_lra(g);
}
};
class is_lira_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_lira(g);
}
};
@ -644,7 +644,7 @@ static bool is_qfufnra(goal const& g) {
class is_qfufnra_probe : public probe {
public:
virtual result operator()(goal const & g) {
result operator()(goal const & g) override {
return is_qfufnra(g);
}
};

22
src/tactic/arith/propagate_ineqs_tactic.cpp
View file

@ -43,18 +43,18 @@ class propagate_ineqs_tactic : public tactic {
public:
propagate_ineqs_tactic(ast_manager & m, params_ref const & p);
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(propagate_ineqs_tactic, m, m_params);
}
virtual ~propagate_ineqs_tactic();
~propagate_ineqs_tactic() override;
virtual void updt_params(params_ref const & p);
virtual void collect_param_descrs(param_descrs & r) {}
void updt_params(params_ref const & p) override;
void collect_param_descrs(param_descrs & r) override {}
virtual void operator()(goal_ref const & g, goal_ref_buffer & result);
void operator()(goal_ref const & g, goal_ref_buffer & result) override;
virtual void cleanup();
void cleanup() override;
};
tactic * mk_propagate_ineqs_tactic(ast_manager & m, params_ref const & p) {
@ -354,7 +354,7 @@ struct propagate_ineqs_tactic::imp {
void find_ite_bounds(expr * root) {
TRACE("find_ite_bounds_bug", display_bounds(tout););
expr * n = root;
expr * target = 0;
expr * target = nullptr;
expr * c, * t, * e;
expr * x, * y;
bool has_l, has_u;
@ -374,7 +374,7 @@ struct propagate_ineqs_tactic::imp {
break;
}
else if (is_x_minus_y_eq_0(n, x, y)) {
n = 0;
n = nullptr;
}
else {
break;
@ -394,7 +394,7 @@ struct propagate_ineqs_tactic::imp {
break;
}
if (target == 0) {
if (target == nullptr) {
target = x;
if (lower(y, curr, curr_strict)) {
has_l = true;
@ -448,7 +448,7 @@ struct propagate_ineqs_tactic::imp {
if (!has_l && !has_u)
break;
if (n == 0) {
if (n == nullptr) {
TRACE("find_ite_bounds", tout << "found bounds for: " << mk_ismt2_pp(target, m) << "\n";
tout << "has_l: " << has_l << " " << nm.to_string(l_min) << " l_strict: " << l_strict << "\n";
tout << "has_u: " << has_u << " " << nm.to_string(u_max) << " u_strict: " << u_strict << "\n";
@ -484,7 +484,7 @@ struct propagate_ineqs_tactic::imp {
m_new_goal->inc_depth();
r = m_new_goal.get();
if (!collect_bounds(*g)) {
m_new_goal = 0;
m_new_goal = nullptr;
r = g;
return; // nothing to be done
}

26
src/tactic/arith/purify_arith_tactic.cpp
View file

@ -169,8 +169,8 @@ struct purify_arith_proc {
}
std::pair<expr*, expr*> pair;
if (!m_sin_cos.find(to_app(theta), pair)) {
pair.first = m().mk_fresh_const(0, u().mk_real());
pair.second = m().mk_fresh_const(0, u().mk_real());
pair.first = m().mk_fresh_const(nullptr, u().mk_real());
pair.second = m().mk_fresh_const(nullptr, u().mk_real());
m_sin_cos.insert(to_app(theta), pair);
m_pinned.push_back(pair.first);
m_pinned.push_back(pair.second);
@ -213,7 +213,7 @@ struct purify_arith_proc {
bool elim_inverses() const { return m_owner.m_elim_inverses; }
expr * mk_fresh_var(bool is_int) {
expr * r = m().mk_fresh_const(0, is_int ? u().mk_int() : u().mk_real());
expr * r = m().mk_fresh_const(nullptr, is_int ? u().mk_int() : u().mk_real());
m_new_vars.push_back(r);
return r;
}
@ -240,7 +240,7 @@ struct purify_arith_proc {
}
void mk_def_proof(expr * k, expr * def, proof_ref & result_pr) {
result_pr = 0;
result_pr = nullptr;
if (produce_proofs()) {
expr * eq = m().mk_eq(k, def);
proof * pr1 = m().mk_def_intro(eq);
@ -690,7 +690,7 @@ struct purify_arith_proc {
};
void process_quantifier(quantifier * q, expr_ref & result, proof_ref & result_pr) {
result_pr = 0;
result_pr = nullptr;
rw r(*this);
expr_ref new_body(m());
proof_ref new_body_pr(m());
@ -760,7 +760,7 @@ struct purify_arith_proc {
sz = r.cfg().m_new_cnstrs.size();
TRACE("purify_arith", tout << r.cfg().m_new_cnstrs << "\n";);
for (unsigned i = 0; i < sz; i++) {
m_goal.assert_expr(r.cfg().m_new_cnstrs.get(i), m_produce_proofs ? r.cfg().m_new_cnstr_prs.get(i) : 0, 0);
m_goal.assert_expr(r.cfg().m_new_cnstrs.get(i), m_produce_proofs ? r.cfg().m_new_cnstr_prs.get(i) : nullptr, nullptr);
}
// add generic_model_converter to eliminate auxiliary variables from model
@ -799,18 +799,18 @@ public:
m_params(p) {
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(purify_arith_tactic, m, m_params);
}
virtual ~purify_arith_tactic() {
~purify_arith_tactic() override {
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_params = p;
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
r.insert("complete", CPK_BOOL,
"(default: true) add constraints to make sure that any interpretation of a underspecified arithmetic operators is a function. The result will include additional uninterpreted functions/constants: /0, div0, mod0, 0^0, neg-root");
r.insert("elim_root_objects", CPK_BOOL,
@ -820,8 +820,8 @@ public:
th_rewriter::get_param_descrs(r);
}
virtual void operator()(goal_ref const & g,
goal_ref_buffer & result) {
void operator()(goal_ref const & g,
goal_ref_buffer & result) override {
try {
SASSERT(g->is_well_sorted());
tactic_report report("purify-arith", *g);
@ -845,7 +845,7 @@ public:
}
}
virtual void cleanup() {
void cleanup() override {
}
};

2
src/tactic/arith/purify_arith_tactic.h
View file

@ -16,7 +16,7 @@ Abstract:
Remarks:
- The semantics of division by zero is not specified. Thus,
uninterpreted functions are used. An ExRCF procedure may
treat the unintepreted function applications as fresh
treat the uninterpreted function applications as fresh
constants. Then, in any model produced by this procedure,
the interpretation for division by zero must be checked.

24
src/tactic/arith/recover_01_tactic.cpp
View file

@ -69,7 +69,7 @@ class recover_01_tactic : public tactic {
bool save_clause(expr * c) {
if (!m.is_or(c))
return false;
func_decl * x = 0;
func_decl * x = nullptr;
app * cls = to_app(c);
if (cls->get_num_args() <= 1 || cls->get_num_args() >= m_cls_max_size)
return false;
@ -83,7 +83,7 @@ class recover_01_tactic : public tactic {
else if (m.is_not(lit, arg) && is_uninterp_const(arg)) {
// negative literal
}
else if (x == 0 && m.is_eq(lit, lhs, rhs)) {
else if (x == nullptr && m.is_eq(lit, lhs, rhs)) {
// x = k literal
if (is_uninterp_const(lhs) && m_util.is_numeral(rhs)) {
x = to_app(lhs)->get_decl();
@ -100,7 +100,7 @@ class recover_01_tactic : public tactic {
}
}
if (x != 0) {
if (x != nullptr) {
var2clauses::obj_map_entry * entry = m_var2clauses.insert_if_not_there2(x, ptr_vector<app>());
if (entry->get_data().m_value.empty() || entry->get_data().m_value.back()->get_num_args() == cls->get_num_args()) {
entry->get_data().m_value.push_back(cls);
@ -132,7 +132,7 @@ class recover_01_tactic : public tactic {
}
}
}
return 0;
return nullptr;
}
// Find coeff (the k of literal (x = k)) of clause cls.
@ -197,7 +197,7 @@ class recover_01_tactic : public tactic {
SASSERT(is_uninterp_const(atom));
expr * var;
if (!bool2int.find(atom, var)) {
var = m.mk_fresh_const(0, m_util.mk_int());
var = m.mk_fresh_const(nullptr, m_util.mk_int());
new_goal->assert_expr(m_util.mk_le(m_util.mk_numeral(rational(0), true), var));
new_goal->assert_expr(m_util.mk_le(var, m_util.mk_numeral(rational(1), true)));
expr * bool_def = m.mk_eq(var, m_util.mk_numeral(rational(1), true));
@ -223,7 +223,7 @@ class recover_01_tactic : public tactic {
if (clauses.size() < expected_num_clauses) // using < instead of != because we tolerate duplicates
return false;
app * zero_cls = find_zero_cls(x, clauses);
if (zero_cls == 0)
if (zero_cls == nullptr)
return false;
buffer<bool> found; // marks which idx were found
@ -381,26 +381,26 @@ public:
m_imp = alloc(imp, m, p);
}
virtual tactic * translate(ast_manager & m) {
tactic * translate(ast_manager & m) override {
return alloc(recover_01_tactic, m, m_params);
}
virtual ~recover_01_tactic() {
~recover_01_tactic() override {
dealloc(m_imp);
}
virtual void updt_params(params_ref const & p) {
void updt_params(params_ref const & p) override {
m_params = p;
m_imp->updt_params(p);
}
virtual void collect_param_descrs(param_descrs & r) {
void collect_param_descrs(param_descrs & r) override {
th_rewriter::get_param_descrs(r);
r.insert("recover_01_max_bits", CPK_UINT, "(default: 10) maximum number of bits to consider in a clause.");
}
void operator()(goal_ref const & g,
goal_ref_buffer & result) {
goal_ref_buffer & result) override {
try {
(*m_imp)(g, result);
}
@ -409,7 +409,7 @@ public:
}
}
virtual void cleanup() {
void cleanup() override {
imp * d = alloc(imp, m_imp->m, m_params);
std::swap(d, m_imp);
dealloc(d);