mirror of
https://github.com/Z3Prover/z3
synced 2025-04-23 17:15:31 +00:00
dealing with compilers that don't take typename in non-template classes
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner
parent
2800049dd4
commit
0708ecb543
9 changed files with 59 additions and 417 deletions
|
|
@ -1,201 +0,0 @@
|
|||
/*
|
||||
Copyright (c) 2017 Microsoft Corporation
|
||||
Author: Nikolaj Bjorner, Lev Nachmanson
|
||||
*/
|
||||
#pragma once
|
||||
#include "util/vector.h"
|
||||
#include "util/trace.h"
|
||||
#include "util/lp/lp_settings.h"
|
||||
namespace lp {
|
||||
template <typename T>
|
||||
class cut_solver {
|
||||
|
||||
struct ineq { // we only have less or equal, which is enough for integral variables
|
||||
mpq m_bound;
|
||||
vector<std::pair<T, var_index>> m_term;
|
||||
ineq(vector<std::pair<T, var_index>>& term, mpq bound):m_bound(bound),m_term(term) {
|
||||
}
|
||||
};
|
||||
|
||||
vector<ineq> m_ineqs;
|
||||
|
||||
enum class lbool {
|
||||
l_false, // false
|
||||
l_true, // true
|
||||
l_undef // undef
|
||||
};
|
||||
|
||||
enum class literal_type {
|
||||
BOOL,
|
||||
INEQ,
|
||||
BOUND
|
||||
};
|
||||
|
||||
struct literal {
|
||||
literal_type m_tag;
|
||||
bool m_sign; // true means the pointed inequality is negated, or bound is negated, or boolean value is negated
|
||||
|
||||
unsigned m_id;
|
||||
unsigned m_index_of_ineq; // index into m_ineqs
|
||||
bool m_bool_val; // used if m_tag is equal to BOOL
|
||||
mpq m_bound; // used if m_tag is BOUND
|
||||
literal(bool sign, bool val): m_tag(literal_type::BOOL),
|
||||
m_bool_val(val){
|
||||
}
|
||||
literal(bool sign, unsigned index_of_ineq) : m_tag(literal_type::INEQ), m_index_of_ineq(index_of_ineq) {}
|
||||
};
|
||||
|
||||
bool lhs_is_int(const vector<std::pair<mpq, var_index>> & lhs) const {
|
||||
for (auto & p : lhs)
|
||||
if (p.first.is_int() == false) return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
public:
|
||||
void add_ineq(vector<std::pair<mpq, var_index>> & lhs, mpq rhs) {
|
||||
lp_assert(lhs_is_int(lhs));
|
||||
lp_assert(rhs.is_int());
|
||||
m_ineqs.push_back(ineq(lhs, rhs));
|
||||
}
|
||||
|
||||
|
||||
bool m_inconsistent; // tracks if state is consistent
|
||||
unsigned m_scope_lvl; // tracks the number of case splits
|
||||
|
||||
svector<literal> m_trail;
|
||||
// backtracking state from the SAT solver:
|
||||
struct scope {
|
||||
unsigned m_trail_lim; // pointer into assignment stack
|
||||
unsigned m_clauses_to_reinit_lim; // ignore for now
|
||||
bool m_inconsistent; // really needed?
|
||||
};
|
||||
|
||||
svector<scope> m_scopes;
|
||||
|
||||
bool at_base_lvl() const { return m_scope_lvl == 0; }
|
||||
|
||||
lbool check() {
|
||||
init_search();
|
||||
propagate();
|
||||
while (true) {
|
||||
lbool r = bounded_search();
|
||||
if (r != lbool::l_undef)
|
||||
return r;
|
||||
|
||||
restart();
|
||||
simplify_problem();
|
||||
if (check_inconsistent()) return lbool::l_false;
|
||||
gc();
|
||||
}
|
||||
}
|
||||
|
||||
cut_solver() {
|
||||
}
|
||||
|
||||
void init_search() {
|
||||
// TBD
|
||||
// initialize data-structures
|
||||
}
|
||||
|
||||
void simplify_problem() {
|
||||
// no-op
|
||||
}
|
||||
|
||||
void gc() {
|
||||
// no-op
|
||||
}
|
||||
|
||||
void restart() {
|
||||
// no-op for now
|
||||
}
|
||||
|
||||
bool check_inconsistent() {
|
||||
// TBD
|
||||
return false;
|
||||
}
|
||||
|
||||
lbool bounded_search() {
|
||||
while (true) {
|
||||
checkpoint();
|
||||
bool done = false;
|
||||
while (!done) {
|
||||
lbool is_sat = propagate_and_backjump_step(done);
|
||||
if (is_sat != lbool::l_true) return is_sat;
|
||||
}
|
||||
|
||||
gc();
|
||||
|
||||
if (!decide()) {
|
||||
lbool is_sat = final_check();
|
||||
if (is_sat != lbool::l_undef) {
|
||||
return is_sat;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void checkpoint() {
|
||||
// check for cancelation
|
||||
}
|
||||
|
||||
void cleanup() {
|
||||
}
|
||||
|
||||
lbool propagate_and_backjump_step(bool& done) {
|
||||
done = true;
|
||||
propagate();
|
||||
if (!inconsistent())
|
||||
return lbool::l_true;
|
||||
if (!resolve_conflict())
|
||||
return lbool::l_false;
|
||||
if (at_base_lvl()) {
|
||||
cleanup(); // cleaner may propagate frozen clauses
|
||||
if (inconsistent()) {
|
||||
TRACE("sat", tout << "conflict at level 0\n";);
|
||||
return lbool::l_false;
|
||||
}
|
||||
gc();
|
||||
}
|
||||
done = false;
|
||||
return lbool::l_true;
|
||||
}
|
||||
|
||||
lbool final_check() {
|
||||
// there are no more case splits, and all clauses are satisfied.
|
||||
// prepare the model for external consumption.
|
||||
return lbool::l_true;
|
||||
}
|
||||
|
||||
|
||||
bool resolve_conflict() {
|
||||
while (true) {
|
||||
bool r = resolve_conflict_core();
|
||||
// after pop, clauses are reinitialized,
|
||||
// this may trigger another conflict.
|
||||
if (!r)
|
||||
return false;
|
||||
if (!inconsistent())
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
bool resolve_conflict_core() {
|
||||
// this is where the main action is.
|
||||
return true;
|
||||
}
|
||||
|
||||
void propagate() {
|
||||
// this is where the main action is.
|
||||
}
|
||||
|
||||
bool decide() {
|
||||
// this is where the main action is.
|
||||
// pick the next variable and bound or value on the variable.
|
||||
// return false if all variables have been assigned.
|
||||
return false;
|
||||
}
|
||||
|
||||
bool inconsistent() const { return m_inconsistent; }
|
||||
|
||||
};
|
||||
}
|
||||
|
|
@ -1,157 +0,0 @@
|
|||
/*
|
||||
Copyright (c) 2017 Microsoft Corporation
|
||||
Author: Lev Nachmanson
|
||||
*/
|
||||
#pragma once
|
||||
#include "util/lp/lp_settings.h"
|
||||
#include "util/lp/static_matrix.h"
|
||||
#include "util/lp/iterator_on_row.h"
|
||||
#include "util/lp/int_set.h"
|
||||
#include "util/lp/lar_term.h"
|
||||
#include "util/lp/cut_solver.h"
|
||||
#include "util/lp/lar_constraints.h"
|
||||
|
||||
namespace lp {
|
||||
class lar_solver;
|
||||
template <typename T, typename X>
|
||||
struct lp_constraint;
|
||||
enum class lia_move {
|
||||
ok,
|
||||
branch,
|
||||
cut,
|
||||
conflict,
|
||||
continue_with_check,
|
||||
give_up
|
||||
};
|
||||
|
||||
struct explanation {
|
||||
vector<std::pair<mpq, constraint_index>> m_explanation;
|
||||
void push_justification(constraint_index j, const mpq& v) {
|
||||
m_explanation.push_back(std::make_pair(v, j));
|
||||
}
|
||||
};
|
||||
|
||||
class int_solver {
|
||||
public:
|
||||
// fields
|
||||
lar_solver *m_lar_solver;
|
||||
int_set m_old_values_set;
|
||||
vector<impq> m_old_values_data;
|
||||
unsigned m_branch_cut_counter;
|
||||
|
||||
// methods
|
||||
int_solver(lar_solver* lp);
|
||||
int_set& inf_int_set();
|
||||
const int_set& inf_int_set() const;
|
||||
// main function to check that solution provided by lar_solver is valid for integral values,
|
||||
// or provide a way of how it can be adjusted.
|
||||
lia_move check(lar_term& t, mpq& k, explanation& ex);
|
||||
bool move_non_basic_column_to_bounds(unsigned j);
|
||||
lia_move check_wrapper(lar_term& t, mpq& k, explanation& ex);
|
||||
private:
|
||||
|
||||
// how to tighten bounds for integer variables.
|
||||
|
||||
bool gcd_test_for_row(static_matrix<mpq, numeric_pair<mpq>> & A, unsigned i, explanation &);
|
||||
|
||||
// gcd test
|
||||
// 5*x + 3*y + 6*z = 5
|
||||
// suppose x is fixed at 2.
|
||||
// so we have 10 + 3(y + 2z) = 5
|
||||
// 5 = -3(y + 2z)
|
||||
// this is unsolvable because 5/3 is not an integer.
|
||||
// so we create a lemma that rules out this condition.
|
||||
//
|
||||
bool gcd_test(explanation & ); // returns false in case of failure. Creates a theory lemma in case of failure.
|
||||
|
||||
// create goromy cuts
|
||||
// either creates a conflict or a bound.
|
||||
|
||||
// branch and bound:
|
||||
// decide what to branch and bound on
|
||||
// creates a fresh inequality.
|
||||
|
||||
bool branch(const lp_constraint<mpq, mpq> & new_inequality);
|
||||
bool ext_gcd_test(iterator_on_row<mpq> & it,
|
||||
mpq const & least_coeff,
|
||||
mpq const & lcm_den,
|
||||
mpq const & consts,
|
||||
explanation & ex);
|
||||
void fill_explanation_from_fixed_columns(iterator_on_row<mpq> & it, explanation &);
|
||||
void add_to_explanation_from_fixed_or_boxed_column(unsigned j, explanation &);
|
||||
void patch_int_infeasible_non_basic_column(unsigned j);
|
||||
void patch_int_infeasible_nbasic_columns();
|
||||
bool get_freedom_interval_for_column(unsigned j, bool & inf_l, impq & l, bool & inf_u, impq & u, mpq & m);
|
||||
linear_combination_iterator<mpq> * get_column_iterator(unsigned j);
|
||||
const impq & low_bound(unsigned j) const;
|
||||
const impq & upper_bound(unsigned j) const;
|
||||
bool is_int(unsigned j) const;
|
||||
bool is_real(unsigned j) const;
|
||||
bool is_base(unsigned j) const;
|
||||
bool is_boxed(unsigned j) const;
|
||||
bool is_fixed(unsigned j) const;
|
||||
bool is_free(unsigned j) const;
|
||||
bool value_is_int(unsigned j) const;
|
||||
void set_value_for_nbasic_column(unsigned j, const impq & new_val);
|
||||
void set_value_for_nbasic_column_ignore_old_values(unsigned j, const impq & new_val);
|
||||
bool non_basic_columns_are_at_bounds() const;
|
||||
void failed();
|
||||
bool is_feasible() const;
|
||||
const impq & get_value(unsigned j) const;
|
||||
void display_column(std::ostream & out, unsigned j) const;
|
||||
bool inf_int_set_is_correct() const;
|
||||
void update_column_in_int_inf_set(unsigned j);
|
||||
bool column_is_int_inf(unsigned j) const;
|
||||
void trace_inf_rows() const;
|
||||
int find_inf_int_base_column();
|
||||
int find_inf_int_boxed_base_column_with_smallest_range();
|
||||
lp_settings& settings();
|
||||
bool move_non_basic_columns_to_bounds();
|
||||
void branch_infeasible_int_var(unsigned);
|
||||
lia_move mk_gomory_cut(lar_term& t, mpq& k,explanation & ex, unsigned inf_col, linear_combination_iterator<mpq>& iter);
|
||||
lia_move report_conflict_from_gomory_cut(mpq & k);
|
||||
void adjust_term_and_k_for_some_ints_case_gomory(lar_term& t, mpq& k, mpq& lcm_den);
|
||||
void init_check_data();
|
||||
bool constrain_free_vars(linear_combination_iterator<mpq> * r);
|
||||
lia_move proceed_with_gomory_cut(lar_term& t, mpq& k, explanation& ex, unsigned j);
|
||||
int find_free_var_in_gomory_row(linear_combination_iterator<mpq>& iter);
|
||||
bool is_gomory_cut_target(linear_combination_iterator<mpq> &iter);
|
||||
bool at_bound(unsigned j) const;
|
||||
bool at_low(unsigned j) const;
|
||||
bool at_upper(unsigned j) const;
|
||||
bool has_low(unsigned j) const;
|
||||
bool has_upper(unsigned j) const;
|
||||
unsigned row_of_basic_column(unsigned j) const;
|
||||
inline static bool is_rational(const impq & n) {
|
||||
return is_zero(n.y);
|
||||
}
|
||||
|
||||
inline static
|
||||
mpq fractional_part(const impq & n) {
|
||||
lp_assert(is_rational(n));
|
||||
return n.x - floor(n.x);
|
||||
}
|
||||
void real_case_in_gomory_cut(const mpq & a, unsigned x_j, mpq & k, lar_term& t, explanation & ex, unsigned inf_column);
|
||||
void int_case_in_gomory_cut(const mpq & a, unsigned x_j, mpq & k, lar_term& t, explanation& ex, mpq & lcm_den, unsigned inf_column);
|
||||
constraint_index column_upper_bound_constraint(unsigned j) const;
|
||||
constraint_index column_low_bound_constraint(unsigned j) const;
|
||||
void display_row_info(std::ostream & out, unsigned row_index) const;
|
||||
void gomory_cut_adjust_t_and_k(vector<std::pair<mpq, unsigned>> & pol, lar_term & t, mpq &k, bool num_ints, mpq &lcm_den);
|
||||
bool current_solution_is_inf_on_cut(const lar_term& t, const mpq& k) const;
|
||||
public:
|
||||
bool shift_var(unsigned j, unsigned range);
|
||||
private:
|
||||
unsigned random();
|
||||
bool has_inf_int() const;
|
||||
lia_move create_branch_on_column(int j, lar_term& t, mpq& k, bool free_column) const;
|
||||
public:
|
||||
void display_inf_or_int_inf_columns(std::ostream & out) const;
|
||||
template <typename T>
|
||||
void fill_cut_solver(cut_solver<T> & cs);
|
||||
template <typename T>
|
||||
void fill_cut_solver_for_constraint(const lar_base_constraint*, cut_solver<T>& );
|
||||
template <typename T>
|
||||
void get_int_coeffs_from_constraint(const lar_base_constraint* c, vector<std::pair<T, var_index>>& coeff, T & rs);
|
||||
|
||||
};
|
||||
}
|
||||
|
|
@ -141,8 +141,8 @@ Notes:
|
|||
// Described in Abio et.al. CP 2013.
|
||||
template<class psort_expr>
|
||||
class psort_nw {
|
||||
typedef typename psort_expr::literal literal;
|
||||
typedef typename psort_expr::literal_vector literal_vector;
|
||||
typedef typename psort_expr::pliteral literal;
|
||||
typedef typename psort_expr::pliteral_vector literal_vector;
|
||||
sorting_network_config m_cfg;
|
||||
|
||||
class vc {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue