mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-23 17:15:31 +00:00
Code Activity

Use override rather than virtual.

Browse source
This commit is contained in:
Bruce Mitchener 2018-02-10 09:15:12 +07:00
parent ce123d9dbc
commit 7167fda1dc
220 changed files with 2546 additions and 2548 deletions
Download patch file Download diff file Expand all files Collapse all files

14
src/opt/maxsmt.h
View file

@ -73,15 +73,15 @@ namespace opt {
public:
maxsmt_solver_base(maxsat_context& c, weights_t& ws, expr_ref_vector const& soft);
virtual ~maxsmt_solver_base() {}
virtual rational get_lower() const { return m_lower; }
virtual rational get_upper() const { return m_upper; }
virtual bool get_assignment(unsigned index) const { return m_assignment[index]; }
virtual void collect_statistics(statistics& st) const { }
virtual void get_model(model_ref& mdl, svector<symbol>& labels) { mdl = m_model.get(); labels = m_labels;}
~maxsmt_solver_base() override {}
rational get_lower() const override { return m_lower; }
rational get_upper() const override { return m_upper; }
bool get_assignment(unsigned index) const override { return m_assignment[index]; }
void collect_statistics(statistics& st) const override { }
void get_model(model_ref& mdl, svector<symbol>& labels) override { mdl = m_model.get(); labels = m_labels;}
virtual void commit_assignment();
void set_model() { s().get_model(m_model); s().get_labels(m_labels); }
virtual void updt_params(params_ref& p);
void updt_params(params_ref& p) override;
solver& s();
bool init();
void set_mus(bool f);

70
src/opt/opt_context.h
View file

@ -173,7 +173,7 @@ namespace opt {
std::string m_unknown;
public:
context(ast_manager& m);
virtual ~context();
~context() override;
unsigned add_soft_constraint(expr* f, rational const& w, symbol const& id);
unsigned add_objective(app* t, bool is_max);
void add_hard_constraint(expr* f);
@ -181,30 +181,30 @@ namespace opt {
void get_hard_constraints(expr_ref_vector& hard);
expr_ref get_objective(unsigned i);
virtual void push();
virtual void pop(unsigned n);
virtual bool empty() { return m_scoped_state.m_objectives.empty(); }
virtual void set_hard_constraints(ptr_vector<expr> & hard);
virtual lbool optimize();
virtual void set_model(model_ref& _m) { m_model = _m; }
virtual void get_model(model_ref& _m);
virtual void get_box_model(model_ref& _m, unsigned index);
virtual void fix_model(model_ref& _m);
virtual void collect_statistics(statistics& stats) const;
virtual proof* get_proof() { return 0; }
virtual void get_labels(svector<symbol> & r);
virtual void get_unsat_core(ptr_vector<expr> & r);
virtual std::string reason_unknown() const;
virtual void set_reason_unknown(char const* msg) { m_unknown = msg; }
void push() override;
void pop(unsigned n) override;
bool empty() override { return m_scoped_state.m_objectives.empty(); }
void set_hard_constraints(ptr_vector<expr> & hard) override;
lbool optimize() override;
void set_model(model_ref& _m) override { m_model = _m; }
void get_model(model_ref& _m) override;
void get_box_model(model_ref& _m, unsigned index) override;
void fix_model(model_ref& _m) override;
void collect_statistics(statistics& stats) const override;
proof* get_proof() override { return 0; }
void get_labels(svector<symbol> & r) override;
void get_unsat_core(ptr_vector<expr> & r) override;
std::string reason_unknown() const override;
void set_reason_unknown(char const* msg) override { m_unknown = msg; }
virtual void display_assignment(std::ostream& out);
virtual bool is_pareto() { return m_pareto.get() != 0; }
virtual void set_logic(symbol const& s) { m_logic = s; }
void display_assignment(std::ostream& out) override;
bool is_pareto() override { return m_pareto.get() != 0; }
void set_logic(symbol const& s) override { m_logic = s; }
void set_clausal(bool f) { m_is_clausal = f; }
void display(std::ostream& out);
static void collect_param_descrs(param_descrs & r);
virtual void updt_params(params_ref const& p);
void updt_params(params_ref const& p) override;
params_ref& get_params() { return m_params; }
expr_ref get_lower(unsigned idx);
@ -216,25 +216,25 @@ namespace opt {
std::string to_string() const;
virtual unsigned num_objectives() { return m_scoped_state.m_objectives.size(); }
virtual expr_ref mk_gt(unsigned i, model_ref& model);
virtual expr_ref mk_ge(unsigned i, model_ref& model);
virtual expr_ref mk_le(unsigned i, model_ref& model);
unsigned num_objectives() override { return m_scoped_state.m_objectives.size(); }
expr_ref mk_gt(unsigned i, model_ref& model) override;
expr_ref mk_ge(unsigned i, model_ref& model) override;
expr_ref mk_le(unsigned i, model_ref& model) override;
virtual smt::context& smt_context() { return m_opt_solver->get_context(); }
virtual filter_model_converter& fm() { return m_fm; }
virtual bool sat_enabled() const { return 0 != m_sat_solver.get(); }
virtual solver& get_solver();
virtual ast_manager& get_manager() const { return this->m; }
virtual params_ref& params() { return m_params; }
virtual void enable_sls(bool force);
virtual symbol const& maxsat_engine() const { return m_maxsat_engine; }
virtual void get_base_model(model_ref& _m);
smt::context& smt_context() override { return m_opt_solver->get_context(); }
filter_model_converter& fm() override { return m_fm; }
bool sat_enabled() const override { return 0 != m_sat_solver.get(); }
solver& get_solver() override;
ast_manager& get_manager() const override { return this->m; }
params_ref& params() override { return m_params; }
void enable_sls(bool force) override;
symbol const& maxsat_engine() const override { return m_maxsat_engine; }
void get_base_model(model_ref& _m) override;
virtual bool verify_model(unsigned id, model* mdl, rational const& v);
bool verify_model(unsigned id, model* mdl, rational const& v) override;
virtual void model_updated(model* mdl);
void model_updated(model* mdl) override;
private:
lbool execute(objective const& obj, bool committed, bool scoped);

8
src/opt/opt_pareto.h
View file

@ -87,9 +87,9 @@ namespace opt {
params_ref & p):
pareto_base(m, cb, s, p) {
}
virtual ~gia_pareto() {}
~gia_pareto() override {}
virtual lbool operator()();
lbool operator()() override;
};
// opportunistic improvement algorithm.
@ -101,9 +101,9 @@ namespace opt {
params_ref & p):
pareto_base(m, cb, s, p) {
}
virtual ~oia_pareto() {}
~oia_pareto() override {}
virtual lbool operator()();
lbool operator()() override;
};
}

42
src/opt/opt_solver.h
View file

@ -85,28 +85,28 @@ namespace opt {
bool m_was_unknown;
public:
opt_solver(ast_manager & m, params_ref const & p, filter_model_converter& fm);
virtual ~opt_solver();
~opt_solver() override;
virtual solver* translate(ast_manager& m, params_ref const& p);
virtual void updt_params(params_ref const& p);
virtual void collect_param_descrs(param_descrs & r);
virtual void collect_statistics(statistics & st) const;
virtual void assert_expr(expr * t);
virtual void push_core();
virtual void pop_core(unsigned n);
virtual lbool check_sat_core(unsigned num_assumptions, expr * const * assumptions);
virtual void get_unsat_core(ptr_vector<expr> & r);
virtual void get_model(model_ref & _m);
virtual proof * get_proof();
virtual std::string reason_unknown() const;
virtual void set_reason_unknown(char const* msg);
virtual void get_labels(svector<symbol> & r);
virtual void set_progress_callback(progress_callback * callback);
virtual unsigned get_num_assertions() const;
virtual expr * get_assertion(unsigned idx) const;
virtual ast_manager& get_manager() const { return m; }
virtual lbool find_mutexes(expr_ref_vector const& vars, vector<expr_ref_vector>& mutexes);
virtual lbool preferred_sat(expr_ref_vector const& asms, vector<expr_ref_vector>& cores);
solver* translate(ast_manager& m, params_ref const& p) override;
void updt_params(params_ref const& p) override;
void collect_param_descrs(param_descrs & r) override;
void collect_statistics(statistics & st) const override;
void assert_expr(expr * t) override;
void push_core() override;
void pop_core(unsigned n) override;
lbool check_sat_core(unsigned num_assumptions, expr * const * assumptions) override;
void get_unsat_core(ptr_vector<expr> & r) override;
void get_model(model_ref & _m) override;
proof * get_proof() override;
std::string reason_unknown() const override;
void set_reason_unknown(char const* msg) override;
void get_labels(svector<symbol> & r) override;
void set_progress_callback(progress_callback * callback) override;
unsigned get_num_assertions() const override;
expr * get_assertion(unsigned idx) const override;
ast_manager& get_manager() const override { return m; }
lbool find_mutexes(expr_ref_vector const& vars, vector<expr_ref_vector>& mutexes) override;
lbool preferred_sat(expr_ref_vector const& asms, vector<expr_ref_vector>& cores) override;
void set_logic(symbol const& logic);
smt::theory_var add_objective(app* term);