mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-06-06 14:13:23 +00:00
Code Activity

remove lp_assert

Browse source
This commit is contained in:
Nikolaj Bjorner 2025-04-14 11:10:26 -07:00
parent 1510b3112e
commit 8035edbe65
35 changed files with 332 additions and 329 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/math/lp/bound_analyzer_on_row.h
View file

@ -92,12 +92,12 @@ namespace lp {
} }
const impq & ub(unsigned j) const { const impq & ub(unsigned j) const {
lp_assert(upper_bound_is_available(j)); SASSERT(upper_bound_is_available(j));
return get_upper_bound(j); return get_upper_bound(j);
} }
const impq & lb(unsigned j) const { const impq & lb(unsigned j) const {
lp_assert(lower_bound_is_available(j)); SASSERT(lower_bound_is_available(j));
return get_lower_bound(j); return get_lower_bound(j);
} }
@ -287,7 +287,7 @@ namespace lp {
// mpq a; unsigned j; // mpq a; unsigned j;
// while (it->next(a, j)) { // while (it->next(a, j)) {
// if (be.m_j == j) continue; // if (be.m_j == j) continue;
// lp_assert(bound_is_available(j, is_neg(a) ? lower_bound : !lower_bound)); // SASSERT(bound_is_available(j, is_neg(a) ? lower_bound : !lower_bound));
// be.m_vector_of_bound_signatures.emplace_back(a, j, numeric_traits<impq>:: // be.m_vector_of_bound_signatures.emplace_back(a, j, numeric_traits<impq>::
// is_neg(a)? lower_bound: !lower_bound); // is_neg(a)? lower_bound: !lower_bound);
// } // }

4
src/math/lp/core_solver_pretty_printer_def.h
View file

@ -326,7 +326,7 @@ template <typename T, typename X> void core_solver_pretty_printer<T, X>::print_g
if (m_squash_blanks && string_is_trivial(s)) if (m_squash_blanks && string_is_trivial(s))
continue; continue;
int number_of_blanks = width - static_cast<unsigned>(s.size()); int number_of_blanks = width - static_cast<unsigned>(s.size());
lp_assert(number_of_blanks >= 0); SASSERT(number_of_blanks >= 0);
m_out << signs[col] << ' '; m_out << signs[col] << ' ';
print_blanks_local(number_of_blanks, m_out); print_blanks_local(number_of_blanks, m_out);
m_out << s << ' '; m_out << s << ' ';
@ -335,7 +335,7 @@ template <typename T, typename X> void core_solver_pretty_printer<T, X>::print_g
string rs = T_to_string(rst); string rs = T_to_string(rst);
int nb = m_rs_width - static_cast<int>(rs.size()); int nb = m_rs_width - static_cast<int>(rs.size());
lp_assert(nb >= 0); SASSERT(nb >= 0);
print_blanks_local(nb + 1, m_out); print_blanks_local(nb + 1, m_out);
m_out << rs << std::endl; m_out << rs << std::endl;
} }

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

@ -47,7 +47,7 @@ public:
dense_matrix(unsigned m, unsigned n); dense_matrix(unsigned m, unsigned n);
dense_matrix operator*=(matrix<T, X> const & a) { dense_matrix operator*=(matrix<T, X> const & a) {
lp_assert(column_count() == a.row_count()); SASSERT(column_count() == a.row_count());
dense_matrix c(row_count(), a.column_count()); dense_matrix c(row_count(), a.column_count());
for (unsigned i = 0; i < row_count(); i++) { for (unsigned i = 0; i < row_count(); i++) {
for (unsigned j = 0; j < a.column_count(); j++) { for (unsigned j = 0; j < a.column_count(); j++) {

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

@ -175,7 +175,7 @@ template <typename T, typename X> void dense_matrix<T, X>::multiply_row_by_const
template <typename T, typename X> template <typename T, typename X>
dense_matrix<T, X> operator* (matrix<T, X> & a, matrix<T, X> & b){ dense_matrix<T, X> operator* (matrix<T, X> & a, matrix<T, X> & b){
lp_assert(a.column_count() == b.row_count()); SASSERT(a.column_count() == b.row_count());
dense_matrix<T, X> ret(a.row_count(), b.column_count()); dense_matrix<T, X> ret(a.row_count(), b.column_count());
for (unsigned i = 0; i < ret.m_m; i++) for (unsigned i = 0; i < ret.m_m; i++)
for (unsigned j = 0; j< ret.m_n; j++) { for (unsigned j = 0; j< ret.m_n; j++) {

16
src/math/lp/general_matrix.h
View file

@ -98,16 +98,16 @@ public:
void clear() { m_data.clear(); } void clear() { m_data.clear(); }
bool row_is_initialized_correctly(const vector<mpq>& row) { bool row_is_initialized_correctly(const vector<mpq>& row) {
lp_assert(row.size() == column_count()); SASSERT(row.size() == column_count());
for (unsigned j = 0; j < row.size(); j ++) for (unsigned j = 0; j < row.size(); j ++)
lp_assert(is_zero(row[j])); SASSERT(is_zero(row[j]));
return true; return true;
} }
template <typename T> template <typename T>
void init_row_from_container(int i, const T & c, std::function<unsigned (unsigned)> column_fix, const mpq& sign) { void init_row_from_container(int i, const T & c, std::function<unsigned (unsigned)> column_fix, const mpq& sign) {
auto & row = m_data[adjust_row(i)]; auto & row = m_data[adjust_row(i)];
lp_assert(row_is_initialized_correctly(row)); SASSERT(row_is_initialized_correctly(row));
for (lp::lar_term::ival p : c) { for (lp::lar_term::ival p : c) {
unsigned j = adjust_column(column_fix(p.j())); unsigned j = adjust_column(column_fix(p.j()));
row[j] = sign * p.coeff(); row[j] = sign * p.coeff();
@ -115,7 +115,7 @@ public:
} }
general_matrix operator*(const general_matrix & m) const { general_matrix operator*(const general_matrix & m) const {
lp_assert(m.row_count() == column_count()); SASSERT(m.row_count() == column_count());
general_matrix ret(row_count(), m.column_count()); general_matrix ret(row_count(), m.column_count());
for (unsigned i = 0; i < row_count(); i ++) { for (unsigned i = 0; i < row_count(); i ++) {
for (unsigned j = 0; j < m.column_count(); j++) { for (unsigned j = 0; j < m.column_count(); j++) {
@ -158,7 +158,7 @@ public:
vector<mpq> operator*(const vector<mpq> & x) const { vector<mpq> operator*(const vector<mpq> & x) const {
vector<mpq> r; vector<mpq> r;
lp_assert(x.size() == column_count()); SASSERT(x.size() == column_count());
for (unsigned i = 0; i < row_count(); i++) { for (unsigned i = 0; i < row_count(); i++) {
mpq v(0); mpq v(0);
for (unsigned j = 0; j < column_count(); j++) { for (unsigned j = 0; j < column_count(); j++) {
@ -171,12 +171,12 @@ public:
void transpose_rows(unsigned i, unsigned l) { void transpose_rows(unsigned i, unsigned l) {
lp_assert(i != l); SASSERT(i != l);
m_row_permutation.transpose_from_right(i, l); m_row_permutation.transpose_from_right(i, l);
} }
void transpose_columns(unsigned j, unsigned k) { void transpose_columns(unsigned j, unsigned k) {
lp_assert(j != k); SASSERT(j != k);
m_column_permutation.transpose_from_left(j, k); m_column_permutation.transpose_from_left(j, k);
} }
@ -210,7 +210,7 @@ public:
// used for debug only // used for debug only
general_matrix take_first_n_columns(unsigned n) const { general_matrix take_first_n_columns(unsigned n) const {
lp_assert(n <= column_count()); SASSERT(n <= column_count());
if (n == column_count()) if (n == column_count())
return *this; return *this;
general_matrix ret(row_count(), n); general_matrix ret(row_count(), n);

16
src/math/lp/gomory.cpp
View file

@ -58,7 +58,7 @@ struct create_cut {
} }
void int_case_in_gomory_cut(unsigned j) { void int_case_in_gomory_cut(unsigned j) {
lp_assert(is_int(j) && m_fj.is_pos()); SASSERT(is_int(j) && m_fj.is_pos());
TRACE("gomory_cut_detail", TRACE("gomory_cut_detail",
tout << " k = " << m_k; tout << " k = " << m_k;
tout << ", fj: " << m_fj << ", "; tout << ", fj: " << m_fj << ", ";
@ -68,15 +68,15 @@ struct create_cut {
if (at_lower(j)) { if (at_lower(j)) {
// here we have the product of new_a*(xj - lb(j)), so new_a*lb(j) is added to m_k // here we have the product of new_a*(xj - lb(j)), so new_a*lb(j) is added to m_k
new_a = m_fj <= m_one_minus_f ? m_fj / m_one_minus_f : ((1 - m_fj) / m_f); new_a = m_fj <= m_one_minus_f ? m_fj / m_one_minus_f : ((1 - m_fj) / m_f);
lp_assert(new_a.is_pos()); SASSERT(new_a.is_pos());
m_k.addmul(new_a, lower_bound(j).x); m_k.addmul(new_a, lower_bound(j).x);
push_explanation(column_lower_bound_constraint(j)); push_explanation(column_lower_bound_constraint(j));
} }
else { else {
lp_assert(at_upper(j)); SASSERT(at_upper(j));
// here we have the expression new_a*(xj - ub), so new_a*ub(j) is added to m_k // here we have the expression new_a*(xj - ub), so new_a*ub(j) is added to m_k
new_a = - (m_fj <= m_f ? m_fj / m_f : ((1 - m_fj) / m_one_minus_f)); new_a = - (m_fj <= m_f ? m_fj / m_f : ((1 - m_fj) / m_one_minus_f));
lp_assert(new_a.is_neg()); SASSERT(new_a.is_neg());
m_k.addmul(new_a, upper_bound(j).x); m_k.addmul(new_a, upper_bound(j).x);
push_explanation(column_upper_bound_constraint(j)); push_explanation(column_upper_bound_constraint(j));
} }
@ -111,7 +111,7 @@ struct create_cut {
push_explanation(column_lower_bound_constraint(j)); push_explanation(column_lower_bound_constraint(j));
} }
else { else {
lp_assert(at_upper(j)); SASSERT(at_upper(j));
if (a.is_pos()) { if (a.is_pos()) {
// the delta is works again m_f // the delta is works again m_f
new_a = - a / m_f; new_a = - a / m_f;
@ -134,7 +134,7 @@ struct create_cut {
} }
lia_move report_conflict_from_gomory_cut() { lia_move report_conflict_from_gomory_cut() {
lp_assert(m_k.is_pos()); SASSERT(m_k.is_pos());
// conflict 0 >= k where k is positive // conflict 0 >= k where k is positive
return lia_move::conflict; return lia_move::conflict;
} }
@ -204,7 +204,7 @@ struct create_cut {
else if (at_lower(j)) else if (at_lower(j))
dump_lower_bound_expl(out, j); dump_lower_bound_expl(out, j);
else { else {
lp_assert(at_upper(j)); SASSERT(at_upper(j));
dump_upper_bound_expl(out, j); dump_upper_bound_expl(out, j);
} }
} }
@ -259,7 +259,7 @@ public:
m_found_big = false; m_found_big = false;
TRACE("gomory_cut_detail", tout << "m_f: " << m_f << ", "; TRACE("gomory_cut_detail", tout << "m_f: " << m_f << ", ";
tout << "1 - m_f: " << 1 - m_f << ", get_value(m_inf_col).x - m_f = " << get_value(m_inf_col).x - m_f << "\n";); tout << "1 - m_f: " << 1 - m_f << ", get_value(m_inf_col).x - m_f = " << get_value(m_inf_col).x - m_f << "\n";);
lp_assert(m_f.is_pos() && (get_value(m_inf_col).x - m_f).is_int()); SASSERT(m_f.is_pos() && (get_value(m_inf_col).x - m_f).is_int());
auto set_polarity_for_int = [&](const mpq & a, lpvar j) { auto set_polarity_for_int = [&](const mpq & a, lpvar j) {
if (a.is_pos()) { if (a.is_pos()) {
if (at_lower(j)) if (at_lower(j))

50
src/math/lp/hnf.h
View file

@ -78,31 +78,31 @@ void extended_gcd_minimal_uv(const mpq & a, const mpq & b, mpq & d, mpq & u, mpq
k -= one_of_type<mpq>(); k -= one_of_type<mpq>();
} }
lp_assert(v == k * a_over_d + r); SASSERT(v == k * a_over_d + r);
if (is_pos(b)) { if (is_pos(b)) {
v = r - a_over_d; // v -= (k + 1) * a_over_d; v = r - a_over_d; // v -= (k + 1) * a_over_d;
lp_assert(- a_over_d < v && v <= zero_of_type<mpq>()); SASSERT(- a_over_d < v && v <= zero_of_type<mpq>());
if (is_pos(a)) { if (is_pos(a)) {
u += (k + 1) * (b / d); u += (k + 1) * (b / d);
lp_assert( one_of_type<mpq>() <= u && u <= abs(b)/d); SASSERT( one_of_type<mpq>() <= u && u <= abs(b)/d);
} else { } else {
u -= (k + 1) * (b / d); u -= (k + 1) * (b / d);
lp_assert( one_of_type<mpq>() <= -u && -u <= abs(b)/d); SASSERT( one_of_type<mpq>() <= -u && -u <= abs(b)/d);
} }
} else { } else {
v = r; // v -= k * a_over_d; v = r; // v -= k * a_over_d;
lp_assert(- a_over_d < -v && -v <= zero_of_type<mpq>()); SASSERT(- a_over_d < -v && -v <= zero_of_type<mpq>());
if (is_pos(a)) { if (is_pos(a)) {
u += k * (b / d); u += k * (b / d);
lp_assert( one_of_type<mpq>() <= u && u <= abs(b)/d); SASSERT( one_of_type<mpq>() <= u && u <= abs(b)/d);
} else { } else {
u -= k * (b / d); u -= k * (b / d);
lp_assert( one_of_type<mpq>() <= -u && -u <= abs(b)/d); SASSERT( one_of_type<mpq>() <= -u && -u <= abs(b)/d);
} }
} }
lp_assert(d == u * a + v * b); SASSERT(d == u * a + v * b);
} }
@ -127,7 +127,7 @@ bool prepare_pivot_for_lower_triangle(M &m, unsigned r) {
template <typename M> template <typename M>
void pivot_column_non_fractional(M &m, unsigned r, bool & overflow, const mpq & big_number) { void pivot_column_non_fractional(M &m, unsigned r, bool & overflow, const mpq & big_number) {
lp_assert(!is_zero(m[r][r])); SASSERT(!is_zero(m[r][r]));
for (unsigned j = r + 1; j < m.column_count(); j++) { for (unsigned j = r + 1; j < m.column_count(); j++) {
for (unsigned i = r + 1; i < m.row_count(); i++) { for (unsigned i = r + 1; i < m.row_count(); i++) {
if ( if (
@ -137,7 +137,7 @@ void pivot_column_non_fractional(M &m, unsigned r, bool & overflow, const mpq &
overflow = true; overflow = true;
return; return;
} }
lp_assert(is_integer(m[i][j])); SASSERT(is_integer(m[i][j]));
} }
} }
} }
@ -154,7 +154,7 @@ unsigned to_lower_triangle_non_fractional(M &m, bool & overflow, const mpq& big_
if (overflow) if (overflow)
return 0; return 0;
} }
lp_assert(i == m.row_count()); SASSERT(i == m.row_count());
return i; return i;
} }
@ -168,7 +168,7 @@ mpq gcd_of_row_starting_from_diagonal(const M& m, unsigned i) {
if (!is_zero(t)) if (!is_zero(t))
g = abs(t); g = abs(t);
} }
lp_assert(!is_zero(g)); SASSERT(!is_zero(g));
for (; j < m.column_count(); j++) { for (; j < m.column_count(); j++) {
const auto & t = m[i][j]; const auto & t = m[i][j];
if (!is_zero(t)) if (!is_zero(t))
@ -249,7 +249,7 @@ class hnf {
} }
void buffer_p_col_i_plus_q_col_j_W_modulo(const mpq & p, const mpq & q) { void buffer_p_col_i_plus_q_col_j_W_modulo(const mpq & p, const mpq & q) {
lp_assert(zeros_in_column_W_above(m_i)); SASSERT(zeros_in_column_W_above(m_i));
for (unsigned k = m_i; k < m_m; k++) { for (unsigned k = m_i; k < m_m; k++) {
m_buffer[k] = mod_R_balanced(mod_R_balanced(p * m_W[k][m_i]) + mod_R_balanced(q * m_W[k][m_j])); m_buffer[k] = mod_R_balanced(mod_R_balanced(p * m_W[k][m_i]) + mod_R_balanced(q * m_W[k][m_j]));
} }
@ -262,7 +262,7 @@ class hnf {
} }
void pivot_column_i_to_column_j_H(mpq u, unsigned i, mpq v, unsigned j) { void pivot_column_i_to_column_j_H(mpq u, unsigned i, mpq v, unsigned j) {
lp_assert(is_zero(u * m_H[i][i] + v * m_H[i][j])); SASSERT(is_zero(u * m_H[i][i] + v * m_H[i][j]));
m_H[i][j] = zero_of_type<mpq>(); m_H[i][j] = zero_of_type<mpq>();
for (unsigned k = i + 1; k < m_m; k ++) for (unsigned k = i + 1; k < m_m; k ++)
m_H[k][j] = u * m_H[k][i] + v * m_H[k][j]; m_H[k][j] = u * m_H[k][i] + v * m_H[k][j];
@ -270,7 +270,7 @@ class hnf {
} }
#endif #endif
void pivot_column_i_to_column_j_W_modulo(mpq u, mpq v) { void pivot_column_i_to_column_j_W_modulo(mpq u, mpq v) {
lp_assert(is_zero((u * m_W[m_i][m_i] + v * m_W[m_i][m_j]) % m_R)); SASSERT(is_zero((u * m_W[m_i][m_i] + v * m_W[m_i][m_j]) % m_R));
m_W[m_i][m_j] = zero_of_type<mpq>(); m_W[m_i][m_j] = zero_of_type<mpq>();
for (unsigned k = m_i + 1; k < m_m; k ++) for (unsigned k = m_i + 1; k < m_m; k ++)
m_W[k][m_j] = mod_R_balanced(mod_R_balanced(u * m_W[k][m_i]) + mod_R_balanced(v * m_W[k][m_j])); m_W[k][m_j] = mod_R_balanced(mod_R_balanced(u * m_W[k][m_i]) + mod_R_balanced(v * m_W[k][m_j]));
@ -364,14 +364,14 @@ class hnf {
} }
void replace_column_j_by_j_minus_u_col_i_H(unsigned i, unsigned j, const mpq & u) { void replace_column_j_by_j_minus_u_col_i_H(unsigned i, unsigned j, const mpq & u) {
lp_assert(j < i); SASSERT(j < i);
for (unsigned k = i; k < m_m; k++) { for (unsigned k = i; k < m_m; k++) {
m_H[k][j] -= u * m_H[k][i]; m_H[k][j] -= u * m_H[k][i];
} }
} }
void replace_column_j_by_j_minus_u_col_i_U(unsigned i, unsigned j, const mpq & u) { void replace_column_j_by_j_minus_u_col_i_U(unsigned i, unsigned j, const mpq & u) {
lp_assert(j < i); SASSERT(j < i);
for (unsigned k = 0; k < m_n; k++) { for (unsigned k = 0; k < m_n; k++) {
m_U[k][j] -= u * m_U[k][i]; m_U[k][j] -= u * m_U[k][i];
} }
@ -405,7 +405,7 @@ class hnf {
process_row_column(i, j); process_row_column(i, j);
} }
if (i >= m_n) { if (i >= m_n) {
lp_assert(m_H == m_A_orig * m_U); SASSERT(m_H == m_A_orig * m_U);
return; return;
} }
if (is_neg(m_H[i][i])) if (is_neg(m_H[i][i]))
@ -427,7 +427,7 @@ class hnf {
m_U_reverse = m_U; m_U_reverse = m_U;
lp_assert(m_H == m_A_orig * m_U); SASSERT(m_H == m_A_orig * m_U);
} }
bool row_is_correct_form(unsigned i) const { bool row_is_correct_form(unsigned i) const {
@ -489,7 +489,7 @@ private:
} }
void replace_column_j_by_j_minus_u_col_i_W(unsigned j, const mpq & u) { void replace_column_j_by_j_minus_u_col_i_W(unsigned j, const mpq & u) {
lp_assert(j < m_i); SASSERT(j < m_i);
for (unsigned k = m_i; k < m_m; k++) { for (unsigned k = m_i; k < m_m; k++) {
m_W[k][j] -= u * m_W[k][m_i]; m_W[k][j] -= u * m_W[k][m_i];
// m_W[k][j] = mod_R_balanced(m_W[k][j]); // m_W[k][j] = mod_R_balanced(m_W[k][j]);
@ -546,7 +546,7 @@ private:
if (is_zero(mii)) if (is_zero(mii))
mii = d; mii = d;
lp_assert(is_pos(mii)); SASSERT(is_pos(mii));
// adjust column m_i // adjust column m_i
for (unsigned k = m_i + 1; k < m_m; k++) { for (unsigned k = m_i + 1; k < m_m; k++) {
@ -554,7 +554,7 @@ private:
m_W[k][m_i] = mod_R_balanced(m_W[k][m_i]); m_W[k][m_i] = mod_R_balanced(m_W[k][m_i]);
} }
lp_assert(is_pos(mii)); SASSERT(is_pos(mii));
for (unsigned j = 0; j < m_i; j++) { for (unsigned j = 0; j < m_i; j++) {
const mpq & mij = m_W[m_i][j]; const mpq & mij = m_W[m_i][j];
if (!is_pos(mij) && - mij < mii) if (!is_pos(mij) && - mij < mii)
@ -575,9 +575,9 @@ private:
void calculate_by_modulo() { void calculate_by_modulo() {
for (m_i = 0; m_i < m_m; m_i ++) { for (m_i = 0; m_i < m_m; m_i ++) {
process_row_modulo(); process_row_modulo();
lp_assert(is_pos(m_W[m_i][m_i])); SASSERT(is_pos(m_W[m_i][m_i]));
m_R /= m_W[m_i][m_i]; m_R /= m_W[m_i][m_i];
lp_assert(is_integer(m_R)); SASSERT(is_integer(m_R));
m_half_R = floor(m_R / 2); m_half_R = floor(m_R / 2);
} }
} }
@ -609,7 +609,7 @@ public:
tout << "A = "; m_A_orig.print(tout, 4); tout << std::endl; tout << "A = "; m_A_orig.print(tout, 4); tout << std::endl;
tout << "H = "; m_H.print(tout, 4); tout << std::endl; tout << "H = "; m_H.print(tout, 4); tout << std::endl;
tout << "W = "; m_W.print(tout, 4); tout << std::endl;); tout << "W = "; m_W.print(tout, 4); tout << std::endl;);
lp_assert (m_H == m_W); SASSERT (m_H == m_W);
#endif #endif
} }

6
src/math/lp/hnf_cutter.cpp
View file

@ -99,7 +99,7 @@ namespace lp {
if (is_integer(b[i])) if (is_integer(b[i]))
continue; continue;
if (n == 0) { if (n == 0) {
lp_assert(ret == -1); SASSERT(ret == -1);
n = 1; n = 1;
ret = i; ret = i;
} }
@ -202,7 +202,7 @@ branch y_i >= ceil(y0_i) is impossible.
hnf<general_matrix> h(m_A, d); hnf<general_matrix> h(m_A, d);
vector<mpq> b = create_b(basis_rows); vector<mpq> b = create_b(basis_rows);
#ifdef Z3DEBUG #ifdef Z3DEBUG
lp_assert(m_A * x0 == b); SASSERT(m_A * x0 == b);
#endif #endif
find_h_minus_1_b(h.W(), b); find_h_minus_1_b(h.W(), b);
@ -274,7 +274,7 @@ branch y_i >= ceil(y0_i) is impossible.
for (auto ci : lra.flatten(dep)) for (auto ci : lra.flatten(dep))
lra.constraints().display(tout, ci); lra.constraints().display(tout, ci);
); );
lp_assert(lia.current_solution_is_inf_on_cut()); SASSERT(lia.current_solution_is_inf_on_cut());
lia.settings().stats().m_hnf_cuts++; lia.settings().stats().m_hnf_cuts++;
lia.expl()->clear(); lia.expl()->clear();
for (u_dependency* dep : constraints_for_explanation()) for (u_dependency* dep : constraints_for_explanation())

8
src/math/lp/incremental_vector.h
View file

@ -43,7 +43,7 @@ public:
template <typename T> template <typename T>
void pop_tail(vector<T> & v, unsigned k) { void pop_tail(vector<T> & v, unsigned k) {
lp_assert(v.size() >= k); SASSERT(v.size() >= k);
v.shrink(v.size() - k); v.shrink(v.size() - k);
} }
@ -53,8 +53,8 @@ public:
} }
void pop_scope(unsigned k) { void pop_scope(unsigned k) {
lp_assert(m_stack_of_vector_sizes.size() >= k); SASSERT(m_stack_of_vector_sizes.size() >= k);
lp_assert(k > 0); SASSERT(k > 0);
m_vector.shrink(peek_size(k)); m_vector.shrink(peek_size(k));
unsigned new_st_size = m_stack_of_vector_sizes.size() - k; unsigned new_st_size = m_stack_of_vector_sizes.size() - k;
m_stack_of_vector_sizes.shrink(new_st_size); m_stack_of_vector_sizes.shrink(new_st_size);
@ -65,7 +65,7 @@ public:
} }
unsigned peek_size(unsigned k) const { unsigned peek_size(unsigned k) const {
lp_assert(k > 0 && k <= m_stack_of_vector_sizes.size()); SASSERT(k > 0 && k <= m_stack_of_vector_sizes.size());
return m_stack_of_vector_sizes[m_stack_of_vector_sizes.size() - k]; return m_stack_of_vector_sizes[m_stack_of_vector_sizes.size() - k];
} }
}; };

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

@ -39,7 +39,7 @@ void indexed_vector<T>::resize(unsigned data_size) {
template <typename T> template <typename T>
void indexed_vector<T>::set_value(const T& value, unsigned index) { void indexed_vector<T>::set_value(const T& value, unsigned index) {
m_data[index] = value; m_data[index] = value;
lp_assert(std::find(m_index.begin(), m_index.end(), index) == m_index.end()); SASSERT(std::find(m_index.begin(), m_index.end(), index) == m_index.end());
m_index.push_back(index); m_index.push_back(index);
} }

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

@ -33,7 +33,7 @@ lia_move int_branch::create_branch_on_column(int j) {
TRACE("check_main_int", tout << "branching" << std::endl;); TRACE("check_main_int", tout << "branching" << std::endl;);
lia.get_term().clear(); lia.get_term().clear();
lp_assert(j != -1); SASSERT(j != -1);
lia.get_term().add_monomial(mpq(1), j); lia.get_term().add_monomial(mpq(1), j);
if (lia.is_free(j)) { if (lia.is_free(j)) {
lia.is_upper() = lia.settings().random_next() % 2; lia.is_upper() = lia.settings().random_next() % 2;

4
src/math/lp/int_cube.cpp
View file

@ -50,7 +50,7 @@ namespace lp {
lra.pop(); lra.pop();
lra.round_to_integer_solution(); lra.round_to_integer_solution();
lra.set_status(lp_status::FEASIBLE); lra.set_status(lp_status::FEASIBLE);
lp_assert(lia.settings().get_cancel_flag() || lia.is_feasible()); SASSERT(lia.settings().get_cancel_flag() || lia.is_feasible());
TRACE("cube", tout << "success";); TRACE("cube", tout << "success";);
lia.settings().stats().m_cube_success++; lia.settings().stats().m_cube_success++;
return lia_move::sat; return lia_move::sat;
@ -78,7 +78,7 @@ namespace lp {
void int_cube::find_feasible_solution() { void int_cube::find_feasible_solution() {
lra.find_feasible_solution(); lra.find_feasible_solution();
lp_assert(lp_status::OPTIMAL == lra.get_status() || lp_status::FEASIBLE == lra.get_status()); SASSERT(lp_status::OPTIMAL == lra.get_status() || lp_status::FEASIBLE == lra.get_status());
} }
impq int_cube::get_cube_delta_for_term(const lar_term& t) const { impq int_cube::get_cube_delta_for_term(const lar_term& t) const {

20
src/math/lp/int_solver.cpp
View file

@ -113,7 +113,7 @@ namespace lp {
} }
// if bj == v, then, because we are patching the lra.get_value(v), // if bj == v, then, because we are patching the lra.get_value(v),
// we just need to assert that the lra.get_value(v) would be integral. // we just need to assert that the lra.get_value(v) would be integral.
lp_assert(bj != v || lra.from_model_in_impq_to_mpq(new_val).is_int()); SASSERT(bj != v || lra.from_model_in_impq_to_mpq(new_val).is_int());
} }
lra.set_value_for_nbasic_column(j, lia.get_value(j) + impq(delta)); lra.set_value_for_nbasic_column(j, lia.get_value(j) + impq(delta));
@ -142,8 +142,8 @@ namespace lp {
return false; return false;
mpq a = fractional_part(c.coeff()); mpq a = fractional_part(c.coeff());
mpq r = fractional_part(lra.get_value(v)); mpq r = fractional_part(lra.get_value(v));
lp_assert(0 < r && r < 1); SASSERT(0 < r && r < 1);
lp_assert(0 < a && a < 1); SASSERT(0 < a && a < 1);
mpq delta_plus, delta_minus; mpq delta_plus, delta_minus;
if (!get_patching_deltas(r, a, delta_plus, delta_minus)) if (!get_patching_deltas(r, a, delta_plus, delta_minus))
return false; return false;
@ -159,7 +159,7 @@ namespace lp {
lia_move patch_basic_columns() { lia_move patch_basic_columns() {
lia.settings().stats().m_patches++; lia.settings().stats().m_patches++;
lra.remove_fixed_vars_from_base(); lra.remove_fixed_vars_from_base();
lp_assert(lia.is_feasible()); SASSERT(lia.is_feasible());
for (unsigned j : lra.r_basis()) for (unsigned j : lra.r_basis())
if (!lra.get_value(j).is_int() && lra.column_is_int(j) && !lia.is_fixed(j)) if (!lra.get_value(j).is_int() && lra.column_is_int(j) && !lia.is_fixed(j))
patch_basic_column(j); patch_basic_column(j);
@ -405,16 +405,16 @@ namespace lp {
// coprime. We can find u and v such that u*a1 + v*x2 = 1. // coprime. We can find u and v such that u*a1 + v*x2 = 1.
rational u, v; rational u, v;
gcd(a1, x2, u, v); gcd(a1, x2, u, v);
lp_assert(gcd(a1, x2, u, v).is_one()); SASSERT(gcd(a1, x2, u, v).is_one());
lp_assert((x + (a1 / a2) * (-u * t) * x1).is_int()); SASSERT((x + (a1 / a2) * (-u * t) * x1).is_int());
// 1 = (u- l*x2 ) * a1 + (v + l*a1)*x2, for every integer l. // 1 = (u- l*x2 ) * a1 + (v + l*a1)*x2, for every integer l.
rational d = u * t * x1; rational d = u * t * x1;
// We can prove that x+alpha*d is integral, // We can prove that x+alpha*d is integral,
// and any other delta, satisfying x+alpha*delta, is equal to d modulo a2. // and any other delta, satisfying x+alpha*delta, is equal to d modulo a2.
delta_plus = mod(d, a2); delta_plus = mod(d, a2);
lp_assert(delta_plus > 0); SASSERT(delta_plus > 0);
delta_minus = delta_plus - a2; delta_minus = delta_plus - a2;
lp_assert(delta_minus < 0); SASSERT(delta_minus < 0);
return true; return true;
} }
@ -551,7 +551,7 @@ namespace lp {
const mpq & a = c.coeff(); const mpq & a = c.coeff();
unsigned i = lrac.m_r_basis[row_index]; unsigned i = lrac.m_r_basis[row_index];
impq const & xi = get_value(i); impq const & xi = get_value(i);
lp_assert(lrac.m_r_solver.column_is_feasible(i)); SASSERT(lrac.m_r_solver.column_is_feasible(i));
if (column_is_int(i) && !a.is_int() && xi.is_int()) if (column_is_int(i) && !a.is_int() && xi.is_int())
m = lcm(m, denominator(a)); m = lcm(m, denominator(a));
@ -591,7 +591,7 @@ namespace lp {
bool int_solver::is_feasible() const { bool int_solver::is_feasible() const {
lp_assert( SASSERT(
lrac.m_r_solver.calc_current_x_is_feasible_include_non_basis() == lrac.m_r_solver.calc_current_x_is_feasible_include_non_basis() ==
lrac.m_r_solver.current_x_is_feasible()); lrac.m_r_solver.current_x_is_feasible());
return lrac.m_r_solver.current_x_is_feasible(); return lrac.m_r_solver.current_x_is_feasible();

20
src/math/lp/lar_core_solver.h
View file

@ -117,8 +117,8 @@ public:
void fill_not_improvable_zero_sum(); void fill_not_improvable_zero_sum();
void push() { void push() {
lp_assert(m_r_solver.basis_heading_is_correct()); SASSERT(m_r_solver.basis_heading_is_correct());
lp_assert(m_column_types.size() == m_r_A.column_count()); SASSERT(m_column_types.size() == m_r_A.column_count());
m_stacked_simplex_strategy = settings().simplex_strategy(); m_stacked_simplex_strategy = settings().simplex_strategy();
m_stacked_simplex_strategy.push(); m_stacked_simplex_strategy.push();
m_column_types.push(); m_column_types.push();
@ -140,20 +140,20 @@ public:
m_stacked_simplex_strategy.pop(k); m_stacked_simplex_strategy.pop(k);
m_r_solver.m_settings.simplex_strategy() = m_stacked_simplex_strategy; m_r_solver.m_settings.simplex_strategy() = m_stacked_simplex_strategy;
m_infeasible_linear_combination.reset(); m_infeasible_linear_combination.reset();
lp_assert(m_r_solver.basis_heading_is_correct()); SASSERT(m_r_solver.basis_heading_is_correct());
} }
bool r_basis_is_OK() const { bool r_basis_is_OK() const {
#ifdef Z3DEBUG #ifdef Z3DEBUG
for (unsigned j : m_r_solver.m_basis) { for (unsigned j : m_r_solver.m_basis) {
lp_assert(m_r_solver.m_A.m_columns[j].size() == 1); SASSERT(m_r_solver.m_A.m_columns[j].size() == 1);
} }
for (unsigned j =0; j < m_r_solver.m_basis_heading.size(); j++) { for (unsigned j =0; j < m_r_solver.m_basis_heading.size(); j++) {
if (m_r_solver.m_basis_heading[j] >= 0) continue; if (m_r_solver.m_basis_heading[j] >= 0) continue;
if (m_r_solver.m_column_types[j] == column_type::fixed) continue; if (m_r_solver.m_column_types[j] == column_type::fixed) continue;
lp_assert(static_cast<unsigned>(- m_r_solver.m_basis_heading[j] - 1) < m_r_solver.m_column_types.size()); SASSERT(static_cast<unsigned>(- m_r_solver.m_basis_heading[j] - 1) < m_r_solver.m_column_types.size());
lp_assert( m_r_solver.m_basis_heading[j] <= -1); SASSERT( m_r_solver.m_basis_heading[j] <= -1);
} }
#endif #endif
return true; return true;
@ -191,14 +191,14 @@ public:
} }
void update_delta(mpq& delta, numeric_pair<mpq> const& l, numeric_pair<mpq> const& u) const { void update_delta(mpq& delta, numeric_pair<mpq> const& l, numeric_pair<mpq> const& u) const {
lp_assert(l <= u); SASSERT(l <= u);
if (l.x < u.x && l.y > u.y) { if (l.x < u.x && l.y > u.y) {
mpq delta1 = (u.x - l.x) / (l.y - u.y); mpq delta1 = (u.x - l.x) / (l.y - u.y);
if (delta1 < delta) { if (delta1 < delta) {
delta = delta1; delta = delta1;
} }
} }
lp_assert(l.x + delta * l.y <= u.x + delta * u.y); SASSERT(l.x + delta * l.y <= u.x + delta * u.y);
} }
@ -234,14 +234,14 @@ public:
const impq & lower_bound(unsigned j) const { const impq & lower_bound(unsigned j) const {
lp_assert(m_column_types()[j] == column_type::fixed || SASSERT(m_column_types()[j] == column_type::fixed ||
m_column_types()[j] == column_type::boxed || m_column_types()[j] == column_type::boxed ||
m_column_types()[j] == column_type::lower_bound); m_column_types()[j] == column_type::lower_bound);
return m_r_lower_bounds[j]; return m_r_lower_bounds[j];
} }
const impq & upper_bound(unsigned j) const { const impq & upper_bound(unsigned j) const {
lp_assert(m_column_types()[j] == column_type::fixed || SASSERT(m_column_types()[j] == column_type::fixed ||
m_column_types()[j] == column_type::boxed || m_column_types()[j] == column_type::boxed ||
m_column_types()[j] == column_type::upper_bound); m_column_types()[j] == column_type::upper_bound);
return m_r_upper_bounds[j]; return m_r_upper_bounds[j];

14
src/math/lp/lar_core_solver_def.h
View file

@ -84,8 +84,8 @@ unsigned lar_core_solver::get_number_of_non_ints() const {
void lar_core_solver::solve() { void lar_core_solver::solve() {
TRACE("lar_solver", tout << m_r_solver.get_status() << "\n";); TRACE("lar_solver", tout << m_r_solver.get_status() << "\n";);
lp_assert(m_r_solver.non_basic_columns_are_set_correctly()); SASSERT(m_r_solver.non_basic_columns_are_set_correctly());
lp_assert(m_r_solver.inf_heap_is_correct()); SASSERT(m_r_solver.inf_heap_is_correct());
TRACE("find_feas_stats", tout << "infeasibles = " << m_r_solver.inf_heap_size() << ", int_infs = " << get_number_of_non_ints() << std::endl;); TRACE("find_feas_stats", tout << "infeasibles = " << m_r_solver.inf_heap_size() << ", int_infs = " << get_number_of_non_ints() << std::endl;);
if (m_r_solver.current_x_is_feasible() && m_r_solver.m_look_for_feasible_solution_only) { if (m_r_solver.current_x_is_feasible() && m_r_solver.m_look_for_feasible_solution_only) {
m_r_solver.set_status(lp_status::OPTIMAL); m_r_solver.set_status(lp_status::OPTIMAL);
@ -93,14 +93,14 @@ void lar_core_solver::solve() {
return; return;
} }
++m_r_solver.m_settings.stats().m_need_to_solve_inf; ++m_r_solver.m_settings.stats().m_need_to_solve_inf;
lp_assert( r_basis_is_OK()); SASSERT( r_basis_is_OK());
if (m_r_solver.m_look_for_feasible_solution_only) //todo : should it be set? if (m_r_solver.m_look_for_feasible_solution_only) //todo : should it be set?
m_r_solver.find_feasible_solution(); m_r_solver.find_feasible_solution();
else else
m_r_solver.solve(); m_r_solver.solve();
lp_assert(r_basis_is_OK()); SASSERT(r_basis_is_OK());
switch (m_r_solver.get_status()) switch (m_r_solver.get_status())
{ {
@ -114,9 +114,9 @@ void lar_core_solver::solve() {
m_r_solver.set_status(lp_status::OPTIMAL); m_r_solver.set_status(lp_status::OPTIMAL);
break; break;
} }
lp_assert(r_basis_is_OK()); SASSERT(r_basis_is_OK());
lp_assert(m_r_solver.non_basic_columns_are_set_correctly()); SASSERT(m_r_solver.non_basic_columns_are_set_correctly());
lp_assert(m_r_solver.inf_heap_is_correct()); SASSERT(m_r_solver.inf_heap_is_correct());
TRACE("lar_solver", tout << m_r_solver.get_status() << "\n";); TRACE("lar_solver", tout << m_r_solver.get_status() << "\n";);
} }

151
src/math/lp/lar_solver.cpp
View file

@ -43,9 +43,9 @@ namespace lp {
} }
bool lar_solver::sizes_are_correct() const { bool lar_solver::sizes_are_correct() const {
lp_assert(A_r().column_count() == m_mpq_lar_core_solver.m_r_solver.m_column_types.size()); SASSERT(A_r().column_count() == m_mpq_lar_core_solver.m_r_solver.m_column_types.size());
lp_assert(A_r().column_count() == m_mpq_lar_core_solver.m_r_solver.m_costs.size()); SASSERT(A_r().column_count() == m_mpq_lar_core_solver.m_r_solver.m_costs.size());
lp_assert(A_r().column_count() == m_mpq_lar_core_solver.r_x().size()); SASSERT(A_r().column_count() == m_mpq_lar_core_solver.r_x().size());
return true; return true;
} }
@ -90,7 +90,7 @@ namespace lp {
else if (kind == LE || kind == LT) n_of_L++; else if (kind == LE || kind == LT) n_of_L++;
rs_of_evidence += coeff * constr.rhs(); rs_of_evidence += coeff * constr.rhs();
} }
lp_assert(n_of_G == 0 || n_of_L == 0); SASSERT(n_of_G == 0 || n_of_L == 0);
lconstraint_kind kind = n_of_G ? GE : (n_of_L ? LE : EQ); lconstraint_kind kind = n_of_G ? GE : (n_of_L ? LE : EQ);
if (strict) if (strict)
kind = static_cast<lconstraint_kind>((static_cast<int>(kind) / 2)); kind = static_cast<lconstraint_kind>((static_cast<int>(kind) / 2));
@ -221,10 +221,10 @@ namespace lp {
unsigned n = m_columns.size(); unsigned n = m_columns.size();
m_var_register.shrink(n); m_var_register.shrink(n);
lp_assert(m_mpq_lar_core_solver.m_r_solver.m_costs.size() == A_r().column_count()); SASSERT(m_mpq_lar_core_solver.m_r_solver.m_costs.size() == A_r().column_count());
lp_assert(m_mpq_lar_core_solver.m_r_solver.m_basis.size() == A_r().row_count()); SASSERT(m_mpq_lar_core_solver.m_r_solver.m_basis.size() == A_r().row_count());
lp_assert(m_mpq_lar_core_solver.m_r_solver.basis_heading_is_correct()); SASSERT(m_mpq_lar_core_solver.m_r_solver.basis_heading_is_correct());
lp_assert(A_r().column_count() == n); SASSERT(A_r().column_count() == n);
TRACE("lar_solver_details", for (unsigned j = 0; j < n; j++) print_column_info(j, tout) << "\n";); TRACE("lar_solver_details", for (unsigned j = 0; j < n; j++) print_column_info(j, tout) << "\n";);
m_mpq_lar_core_solver.pop(k); m_mpq_lar_core_solver.pop(k);
@ -242,8 +242,8 @@ namespace lp {
m_constraints.pop(k); m_constraints.pop(k);
m_simplex_strategy.pop(k); m_simplex_strategy.pop(k);
m_settings.simplex_strategy() = m_simplex_strategy; m_settings.simplex_strategy() = m_simplex_strategy;
lp_assert(sizes_are_correct()); SASSERT(sizes_are_correct());
lp_assert(m_mpq_lar_core_solver.m_r_solver.reduced_costs_are_correct_tableau()); SASSERT(m_mpq_lar_core_solver.m_r_solver.reduced_costs_are_correct_tableau());
m_usage_in_terms.pop(k); m_usage_in_terms.pop(k);
m_dependencies.pop_scope(k); m_dependencies.pop_scope(k);
// init the nbasis sorting // init the nbasis sorting
@ -351,13 +351,13 @@ namespace lp {
bool lar_solver::costs_are_zeros_for_r_solver() const { bool lar_solver::costs_are_zeros_for_r_solver() const {
for (unsigned j = 0; j < m_mpq_lar_core_solver.m_r_solver.m_costs.size(); j++) { for (unsigned j = 0; j < m_mpq_lar_core_solver.m_r_solver.m_costs.size(); j++) {
lp_assert(is_zero(m_mpq_lar_core_solver.m_r_solver.m_costs[j])); SASSERT(is_zero(m_mpq_lar_core_solver.m_r_solver.m_costs[j]));
} }
return true; return true;
} }
bool lar_solver::reduced_costs_are_zeroes_for_r_solver() const { bool lar_solver::reduced_costs_are_zeroes_for_r_solver() const {
for (unsigned j = 0; j < m_mpq_lar_core_solver.m_r_solver.m_d.size(); j++) { for (unsigned j = 0; j < m_mpq_lar_core_solver.m_r_solver.m_d.size(); j++) {
lp_assert(is_zero(m_mpq_lar_core_solver.m_r_solver.m_d[j])); SASSERT(is_zero(m_mpq_lar_core_solver.m_r_solver.m_d[j]));
} }
return true; return true;
} }
@ -377,15 +377,15 @@ namespace lp {
d[rc.var()] = zero_of_type<mpq>(); d[rc.var()] = zero_of_type<mpq>();
} }
lp_assert(reduced_costs_are_zeroes_for_r_solver()); SASSERT(reduced_costs_are_zeroes_for_r_solver());
lp_assert(costs_are_zeros_for_r_solver()); SASSERT(costs_are_zeros_for_r_solver());
} }
void lar_solver::prepare_costs_for_r_solver(const lar_term& term) { void lar_solver::prepare_costs_for_r_solver(const lar_term& term) {
TRACE("lar_solver", print_term(term, tout << "prepare: ") << "\n";); TRACE("lar_solver", print_term(term, tout << "prepare: ") << "\n";);
auto& rslv = m_mpq_lar_core_solver.m_r_solver; auto& rslv = m_mpq_lar_core_solver.m_r_solver;
lp_assert(costs_are_zeros_for_r_solver()); SASSERT(costs_are_zeros_for_r_solver());
lp_assert(reduced_costs_are_zeroes_for_r_solver()); SASSERT(reduced_costs_are_zeroes_for_r_solver());
move_non_basic_columns_to_bounds(); move_non_basic_columns_to_bounds();
rslv.m_costs.resize(A_r().column_count(), zero_of_type<mpq>()); rslv.m_costs.resize(A_r().column_count(), zero_of_type<mpq>());
for (lar_term::ival p : term) { for (lar_term::ival p : term) {
@ -398,7 +398,7 @@ namespace lp {
} }
if (settings().backup_costs) if (settings().backup_costs)
rslv.m_costs_backup = rslv.m_costs; rslv.m_costs_backup = rslv.m_costs;
lp_assert(rslv.reduced_costs_are_correct_tableau()); SASSERT(rslv.reduced_costs_are_correct_tableau());
} }
void lar_solver::move_non_basic_columns_to_bounds() { void lar_solver::move_non_basic_columns_to_bounds() {
@ -457,7 +457,7 @@ namespace lp {
} }
void lar_solver::set_value_for_nbasic_column(unsigned j, const impq& new_val) { void lar_solver::set_value_for_nbasic_column(unsigned j, const impq& new_val) {
lp_assert(!is_base(j)); SASSERT(!is_base(j));
auto& x = m_mpq_lar_core_solver.r_x(j); auto& x = m_mpq_lar_core_solver.r_x(j);
auto delta = new_val - x; auto delta = new_val - x;
x = new_val; x = new_val;
@ -493,7 +493,7 @@ namespace lp {
// returns true iff the row of j has a non-fixed column different from j // returns true iff the row of j has a non-fixed column different from j
bool lar_solver::remove_from_basis(unsigned j) { bool lar_solver::remove_from_basis(unsigned j) {
lp_assert(is_base(j)); SASSERT(is_base(j));
unsigned i = row_of_basic_column(j); unsigned i = row_of_basic_column(j);
for (const auto & c : A_r().m_rows[i]) for (const auto & c : A_r().m_rows[i])
if (j != c.var() && !column_is_fixed(c.var())) if (j != c.var() && !column_is_fixed(c.var()))
@ -783,14 +783,14 @@ namespace lp {
continue; continue;
} }
lp_assert(is_base(j) && column_is_fixed(j)); SASSERT(is_base(j) && column_is_fixed(j));
auto const& r = basic2row(j); auto const& r = basic2row(j);
for (auto const& c : r) { for (auto const& c : r) {
unsigned j_entering = c.var(); unsigned j_entering = c.var();
if (!column_is_fixed(j_entering)) { if (!column_is_fixed(j_entering)) {
pivot(j_entering, j); pivot(j_entering, j);
to_remove.push_back(j); to_remove.push_back(j);
lp_assert(is_base(j_entering)); SASSERT(is_base(j_entering));
break; break;
} }
} }
@ -798,7 +798,7 @@ namespace lp {
for (unsigned j : to_remove) { for (unsigned j : to_remove) {
m_fixed_base_var_set.remove(j); m_fixed_base_var_set.remove(j);
} }
lp_assert(fixed_base_removed_correctly()); SASSERT(fixed_base_removed_correctly());
} }
#ifdef Z3DEBUG #ifdef Z3DEBUG
bool lar_solver::fixed_base_removed_correctly() const { bool lar_solver::fixed_base_removed_correctly() const {
@ -912,7 +912,7 @@ namespace lp {
update_x_and_inf_costs_for_columns_with_changed_bounds_tableau(); update_x_and_inf_costs_for_columns_with_changed_bounds_tableau();
m_mpq_lar_core_solver.solve(); m_mpq_lar_core_solver.solve();
set_status(m_mpq_lar_core_solver.m_r_solver.get_status()); set_status(m_mpq_lar_core_solver.m_r_solver.get_status());
lp_assert(((stats().m_make_feasible% 100) != 0) || m_status != lp_status::OPTIMAL || all_constraints_hold()); SASSERT(((stats().m_make_feasible% 100) != 0) || m_status != lp_status::OPTIMAL || all_constraints_hold());
} }
@ -1006,7 +1006,7 @@ namespace lp {
bool lar_solver::the_left_sides_sum_to_zero(const vector<std::pair<mpq, unsigned>>& evidence) const { bool lar_solver::the_left_sides_sum_to_zero(const vector<std::pair<mpq, unsigned>>& evidence) const {
std::unordered_map<lpvar, mpq> coeff_map; std::unordered_map<lpvar, mpq> coeff_map;
for (auto const & [coeff, con_ind] : evidence) { for (auto const & [coeff, con_ind] : evidence) {
lp_assert(m_constraints.valid_index(con_ind)); SASSERT(m_constraints.valid_index(con_ind));
register_in_map(coeff_map, m_constraints[con_ind], coeff); register_in_map(coeff_map, m_constraints[con_ind], coeff);
} }
@ -1024,18 +1024,18 @@ namespace lp {
// disabled: kind is uninitialized // disabled: kind is uninitialized
#ifdef Z3DEBUG #ifdef Z3DEBUG
lconstraint_kind kind; lconstraint_kind kind;
lp_assert(the_left_sides_sum_to_zero(explanation)); SASSERT(the_left_sides_sum_to_zero(explanation));
mpq rs = sum_of_right_sides_of_explanation(explanation); mpq rs = sum_of_right_sides_of_explanation(explanation);
switch (kind) { switch (kind) {
case LE: lp_assert(rs < zero_of_type<mpq>()); case LE: SASSERT(rs < zero_of_type<mpq>());
break; break;
case LT: lp_assert(rs <= zero_of_type<mpq>()); case LT: SASSERT(rs <= zero_of_type<mpq>());
break; break;
case GE: lp_assert(rs > zero_of_type<mpq>()); case GE: SASSERT(rs > zero_of_type<mpq>());
break; break;
case GT: lp_assert(rs >= zero_of_type<mpq>()); case GT: SASSERT(rs >= zero_of_type<mpq>());
break; break;
case EQ: lp_assert(rs != zero_of_type<mpq>()); case EQ: SASSERT(rs != zero_of_type<mpq>());
break; break;
default: default:
UNREACHABLE(); UNREACHABLE();
@ -1060,7 +1060,7 @@ namespace lp {
for (auto it : exp) { for (auto it : exp) {
mpq coeff = it.coeff(); mpq coeff = it.coeff();
constraint_index con_ind = it.ci(); constraint_index con_ind = it.ci();
lp_assert(m_constraints.valid_index(con_ind)); SASSERT(m_constraints.valid_index(con_ind));
ret += (m_constraints[con_ind].rhs() - m_constraints[con_ind].get_free_coeff_of_left_side()) * coeff; ret += (m_constraints[con_ind].rhs() - m_constraints[con_ind].get_free_coeff_of_left_side()) * coeff;
} }
return ret; return ret;
@ -1142,7 +1142,7 @@ namespace lp {
int inf_sign; int inf_sign;
auto inf_row = m_mpq_lar_core_solver.get_infeasibility_info(inf_sign); auto inf_row = m_mpq_lar_core_solver.get_infeasibility_info(inf_sign);
get_infeasibility_explanation_for_inf_sign(exp, inf_row, inf_sign); get_infeasibility_explanation_for_inf_sign(exp, inf_row, inf_sign);
lp_assert(explanation_is_correct(exp)); SASSERT(explanation_is_correct(exp));
} }
void lar_solver::get_infeasibility_explanation_for_inf_sign( void lar_solver::get_infeasibility_explanation_for_inf_sign(
@ -1161,7 +1161,7 @@ namespace lp {
svector<constraint_index> deps; svector<constraint_index> deps;
m_dependencies.linearize(bound_constr_i, deps); m_dependencies.linearize(bound_constr_i, deps);
for (auto d : deps) { for (auto d : deps) {
lp_assert(m_constraints.valid_index(d)); SASSERT(m_constraints.valid_index(d));
exp.add_pair(d, coeff); exp.add_pair(d, coeff);
} }
} }
@ -1184,9 +1184,10 @@ namespace lp {
bool lar_solver::init_model() const { bool lar_solver::init_model() const {
auto& rslv = m_mpq_lar_core_solver.m_r_solver; auto& rslv = m_mpq_lar_core_solver.m_r_solver;
lp_assert(A_r().column_count() == rslv.m_costs.size()); (void)rslv;
lp_assert(A_r().column_count() == m_mpq_lar_core_solver.r_x().size()); SASSERT(A_r().column_count() == rslv.m_costs.size());
lp_assert(A_r().column_count() == rslv.m_d.size()); SASSERT(A_r().column_count() == m_mpq_lar_core_solver.r_x().size());
SASSERT(A_r().column_count() == rslv.m_d.size());
CTRACE("lar_solver_model",!m_columns_with_changed_bounds.empty(), tout << "non-empty changed bounds\n"); CTRACE("lar_solver_model",!m_columns_with_changed_bounds.empty(), tout << "non-empty changed bounds\n");
TRACE("lar_solver_model", tout << get_status() << "\n"); TRACE("lar_solver_model", tout << get_status() << "\n");
auto status = get_status(); auto status = get_status();
@ -1331,7 +1332,7 @@ namespace lp {
for (auto& it : cns.coeffs()) { for (auto& it : cns.coeffs()) {
lpvar j = it.second; lpvar j = it.second;
auto vi = var_map.find(j); auto vi = var_map.find(j);
lp_assert(vi != var_map.end()); SASSERT(vi != var_map.end());
ret += it.first * vi->second; ret += it.first * vi->second;
} }
return ret; return ret;
@ -1376,7 +1377,7 @@ namespace lp {
void lar_solver::make_sure_that_the_bottom_right_elem_not_zero_in_tableau(unsigned i, unsigned j) { void lar_solver::make_sure_that_the_bottom_right_elem_not_zero_in_tableau(unsigned i, unsigned j) {
// i, j - is the indices of the bottom-right element of the tableau // i, j - is the indices of the bottom-right element of the tableau
lp_assert(A_r().row_count() == i + 1 && A_r().column_count() == j + 1); SASSERT(A_r().row_count() == i + 1 && A_r().column_count() == j + 1);
auto& last_column = A_r().m_columns[j]; auto& last_column = A_r().m_columns[j];
int non_zero_column_cell_index = -1; int non_zero_column_cell_index = -1;
for (unsigned k = static_cast<unsigned>(last_column.size()); k-- > 0;) { for (unsigned k = static_cast<unsigned>(last_column.size()); k-- > 0;) {
@ -1386,13 +1387,13 @@ namespace lp {
non_zero_column_cell_index = k; non_zero_column_cell_index = k;
} }
lp_assert(non_zero_column_cell_index != -1); SASSERT(non_zero_column_cell_index != -1);
lp_assert(static_cast<unsigned>(non_zero_column_cell_index) != i); SASSERT(static_cast<unsigned>(non_zero_column_cell_index) != i);
m_mpq_lar_core_solver.m_r_solver.transpose_rows_tableau(last_column[non_zero_column_cell_index].var(), i); m_mpq_lar_core_solver.m_r_solver.transpose_rows_tableau(last_column[non_zero_column_cell_index].var(), i);
} }
void lar_solver::remove_last_row_and_column_from_tableau(unsigned j) { void lar_solver::remove_last_row_and_column_from_tableau(unsigned j) {
lp_assert(A_r().column_count() == m_mpq_lar_core_solver.m_r_solver.m_costs.size()); SASSERT(A_r().column_count() == m_mpq_lar_core_solver.m_r_solver.m_costs.size());
auto& slv = m_mpq_lar_core_solver.m_r_solver; auto& slv = m_mpq_lar_core_solver.m_r_solver;
unsigned i = A_r().row_count() - 1; //last row index unsigned i = A_r().row_count() - 1; //last row index
make_sure_that_the_bottom_right_elem_not_zero_in_tableau(i, j); make_sure_that_the_bottom_right_elem_not_zero_in_tableau(i, j);
@ -1410,8 +1411,8 @@ namespace lp {
} }
A_r().remove_element(last_row, rc); A_r().remove_element(last_row, rc);
} }
lp_assert(last_row.size() == 0); SASSERT(last_row.size() == 0);
lp_assert(A_r().m_columns[j].size() == 0); SASSERT(A_r().m_columns[j].size() == 0);
A_r().m_rows.pop_back(); A_r().m_rows.pop_back();
A_r().m_columns.pop_back(); A_r().m_columns.pop_back();
CASSERT("check_static_matrix", A_r().is_correct()); CASSERT("check_static_matrix", A_r().is_correct());
@ -1419,7 +1420,7 @@ namespace lp {
void lar_solver::remove_last_column_from_A() { void lar_solver::remove_last_column_from_A() {
// the last column has to be empty // the last column has to be empty
lp_assert(A_r().m_columns.back().size() == 0); SASSERT(A_r().m_columns.back().size() == 0);
A_r().m_columns.pop_back(); A_r().m_columns.pop_back();
} }
@ -1428,7 +1429,7 @@ namespace lp {
int i = rslv.m_basis_heading[j]; int i = rslv.m_basis_heading[j];
if (i >= 0) { // j is a basic var if (i >= 0) { // j is a basic var
int last_pos = static_cast<int>(rslv.m_basis.size()) - 1; int last_pos = static_cast<int>(rslv.m_basis.size()) - 1;
lp_assert(last_pos >= 0); SASSERT(last_pos >= 0);
if (i != last_pos) { if (i != last_pos) {
unsigned j_at_last_pos = rslv.m_basis[last_pos]; unsigned j_at_last_pos = rslv.m_basis[last_pos];
rslv.m_basis[i] = j_at_last_pos; rslv.m_basis[i] = j_at_last_pos;
@ -1438,7 +1439,7 @@ namespace lp {
} }
else { else {
int last_pos = static_cast<int>(rslv.m_nbasis.size()) - 1; int last_pos = static_cast<int>(rslv.m_nbasis.size()) - 1;
lp_assert(last_pos >= 0); SASSERT(last_pos >= 0);
i = -1 - i; i = -1 - i;
if (i != last_pos) { if (i != last_pos) {
unsigned j_at_last_pos = rslv.m_nbasis[last_pos]; unsigned j_at_last_pos = rslv.m_nbasis[last_pos];
@ -1448,14 +1449,14 @@ namespace lp {
rslv.m_nbasis.pop_back(); // remove j from the basis rslv.m_nbasis.pop_back(); // remove j from the basis
} }
rslv.m_basis_heading.pop_back(); rslv.m_basis_heading.pop_back();
lp_assert(rslv.m_basis.size() == A_r().row_count()); SASSERT(rslv.m_basis.size() == A_r().row_count());
lp_assert(rslv.basis_heading_is_correct()); SASSERT(rslv.basis_heading_is_correct());
} }
void lar_solver::remove_last_column_from_tableau() { void lar_solver::remove_last_column_from_tableau() {
auto& rslv = m_mpq_lar_core_solver.m_r_solver; auto& rslv = m_mpq_lar_core_solver.m_r_solver;
unsigned j = A_r().column_count() - 1; unsigned j = A_r().column_count() - 1;
lp_assert(A_r().column_count() == rslv.m_costs.size()); SASSERT(A_r().column_count() == rslv.m_costs.size());
if (column_represents_row_in_tableau(j)) { if (column_represents_row_in_tableau(j)) {
remove_last_row_and_column_from_tableau(j); remove_last_row_and_column_from_tableau(j);
if (rslv.m_basis_heading[j] < 0) if (rslv.m_basis_heading[j] < 0)
@ -1469,10 +1470,10 @@ namespace lp {
rslv.m_costs.pop_back(); rslv.m_costs.pop_back();
remove_last_column_from_basis_tableau(j); remove_last_column_from_basis_tableau(j);
lp_assert(m_mpq_lar_core_solver.r_basis_is_OK()); SASSERT(m_mpq_lar_core_solver.r_basis_is_OK());
lp_assert(A_r().column_count() == rslv.m_costs.size()); SASSERT(A_r().column_count() == rslv.m_costs.size());
lp_assert(A_r().column_count() == m_mpq_lar_core_solver.r_x().size()); SASSERT(A_r().column_count() == m_mpq_lar_core_solver.r_x().size());
lp_assert(A_r().column_count() == rslv.m_d.size()); SASSERT(A_r().column_count() == rslv.m_d.size());
} }
@ -1496,14 +1497,14 @@ namespace lp {
} }
for (unsigned j : became_feas) { for (unsigned j : became_feas) {
lp_assert(m_mpq_lar_core_solver.m_r_solver.m_basis_heading[j] < 0); SASSERT(m_mpq_lar_core_solver.m_r_solver.m_basis_heading[j] < 0);
m_mpq_lar_core_solver.m_r_solver.m_d[j] -= m_mpq_lar_core_solver.m_r_solver.m_costs[j]; m_mpq_lar_core_solver.m_r_solver.m_d[j] -= m_mpq_lar_core_solver.m_r_solver.m_costs[j];
m_mpq_lar_core_solver.m_r_solver.m_costs[j] = zero_of_type<mpq>(); m_mpq_lar_core_solver.m_r_solver.m_costs[j] = zero_of_type<mpq>();
m_mpq_lar_core_solver.m_r_solver.remove_column_from_inf_heap(j); m_mpq_lar_core_solver.m_r_solver.remove_column_from_inf_heap(j);
} }
became_feas.clear(); became_feas.clear();
for (unsigned j : m_mpq_lar_core_solver.m_r_solver.inf_heap()) { for (unsigned j : m_mpq_lar_core_solver.m_r_solver.inf_heap()) {
lp_assert(m_mpq_lar_core_solver.m_r_heading[j] >= 0); SASSERT(m_mpq_lar_core_solver.m_r_heading[j] >= 0);
if (column_is_feasible(j)) if (column_is_feasible(j))
became_feas.push_back(j); became_feas.push_back(j);
} }
@ -1586,14 +1587,14 @@ namespace lp {
lpvar local_j; lpvar local_j;
if (m_var_register.external_is_used(ext_j, local_j)) if (m_var_register.external_is_used(ext_j, local_j))
return local_j; return local_j;
lp_assert(m_columns.size() == A_r().column_count()); SASSERT(m_columns.size() == A_r().column_count());
local_j = A_r().column_count(); local_j = A_r().column_count();
m_columns.push_back(column()); m_columns.push_back(column());
m_trail.push(undo_add_column(*this)); m_trail.push(undo_add_column(*this));
while (m_usage_in_terms.size() <= local_j) while (m_usage_in_terms.size() <= local_j)
m_usage_in_terms.push_back(0); m_usage_in_terms.push_back(0);
add_non_basic_var_to_core_fields(ext_j, is_int); add_non_basic_var_to_core_fields(ext_j, is_int);
lp_assert(sizes_are_correct()); SASSERT(sizes_are_correct());
return local_j; return local_j;
} }
@ -1602,7 +1603,7 @@ namespace lp {
} }
void lar_solver::register_new_external_var(unsigned ext_v, bool is_int) { void lar_solver::register_new_external_var(unsigned ext_v, bool is_int) {
lp_assert(!m_var_register.external_is_used(ext_v)); SASSERT(!m_var_register.external_is_used(ext_v));
m_var_register.add_var(ext_v, is_int); m_var_register.add_var(ext_v, is_int);
} }
@ -1620,8 +1621,8 @@ namespace lp {
unsigned j = A_r().column_count(); unsigned j = A_r().column_count();
TRACE("add_var", tout << "j = " << j << std::endl;); TRACE("add_var", tout << "j = " << j << std::endl;);
A_r().add_column(); A_r().add_column();
lp_assert(m_mpq_lar_core_solver.r_x().size() == j); SASSERT(m_mpq_lar_core_solver.r_x().size() == j);
// lp_assert(m_mpq_lar_core_solver.m_r_lower_bounds.size() == j && m_mpq_lar_core_solver.m_r_upper_bounds.size() == j); // restore later // SASSERT(m_mpq_lar_core_solver.m_r_lower_bounds.size() == j && m_mpq_lar_core_solver.m_r_upper_bounds.size() == j); // restore later
m_mpq_lar_core_solver.resize_x(j + 1); m_mpq_lar_core_solver.resize_x(j + 1);
auto& rslv = m_mpq_lar_core_solver.m_r_solver; auto& rslv = m_mpq_lar_core_solver.m_r_solver;
m_mpq_lar_core_solver.m_r_lower_bounds.increase_size_by_one(); m_mpq_lar_core_solver.m_r_lower_bounds.increase_size_by_one();
@ -1629,7 +1630,7 @@ namespace lp {
rslv.inf_heap_increase_size_by_one(); rslv.inf_heap_increase_size_by_one();
rslv.m_costs.resize(j + 1); rslv.m_costs.resize(j + 1);
rslv.m_d.resize(j + 1); rslv.m_d.resize(j + 1);
lp_assert(m_mpq_lar_core_solver.m_r_heading.size() == j); // as A().column_count() on the entry to the method SASSERT(m_mpq_lar_core_solver.m_r_heading.size() == j); // as A().column_count() on the entry to the method
if (register_in_basis) { if (register_in_basis) {
A_r().add_row(); A_r().add_row();
m_mpq_lar_core_solver.m_r_heading.push_back(m_mpq_lar_core_solver.m_r_basis.size()); m_mpq_lar_core_solver.m_r_heading.push_back(m_mpq_lar_core_solver.m_r_basis.size());
@ -1704,7 +1705,7 @@ namespace lp {
lpvar ret = A_r().column_count(); lpvar ret = A_r().column_count();
add_row_from_term_no_constraint(t, ext_i); add_row_from_term_no_constraint(t, ext_i);
lp_assert(m_var_register.size() == A_r().column_count()); SASSERT(m_var_register.size() == A_r().column_count());
if (m_need_register_terms) if (m_need_register_terms)
register_normalized_term(*t, A_r().column_count() - 1); register_normalized_term(*t, A_r().column_count() - 1);
if (m_add_term_callback) if (m_add_term_callback)
@ -1850,13 +1851,13 @@ namespace lp {
constraint_index ci; constraint_index ci;
if (!column_has_term(j)) { if (!column_has_term(j)) {
mpq rs = adjust_bound_for_int(j, kind, right_side); mpq rs = adjust_bound_for_int(j, kind, right_side);
lp_assert(bound_is_integer_for_integer_column(j, rs)); SASSERT(bound_is_integer_for_integer_column(j, rs));
ci = m_constraints.add_var_constraint(j, kind, rs); ci = m_constraints.add_var_constraint(j, kind, rs);
} }
else { else {
ci = add_var_bound_on_constraint_for_term(j, kind, right_side); ci = add_var_bound_on_constraint_for_term(j, kind, right_side);
} }
lp_assert(sizes_are_correct()); SASSERT(sizes_are_correct());
return ci; return ci;
} }
@ -2061,8 +2062,8 @@ namespace lp {
} }
void lar_solver::update_bound_with_ub_lb(lpvar j, lconstraint_kind kind, const mpq& right_side, u_dependency* dep) { void lar_solver::update_bound_with_ub_lb(lpvar j, lconstraint_kind kind, const mpq& right_side, u_dependency* dep) {
lp_assert(column_has_lower_bound(j) && column_has_upper_bound(j)); SASSERT(column_has_lower_bound(j) && column_has_upper_bound(j));
lp_assert(m_mpq_lar_core_solver.m_column_types[j] == column_type::boxed || SASSERT(m_mpq_lar_core_solver.m_column_types[j] == column_type::boxed ||
m_mpq_lar_core_solver.m_column_types[j] == column_type::fixed); m_mpq_lar_core_solver.m_column_types[j] == column_type::fixed);
mpq y_of_bound(0); mpq y_of_bound(0);
@ -2129,8 +2130,8 @@ namespace lp {
} }
void lar_solver::update_bound_with_no_ub_lb(lpvar j, lconstraint_kind kind, const mpq& right_side, u_dependency* dep) { void lar_solver::update_bound_with_no_ub_lb(lpvar j, lconstraint_kind kind, const mpq& right_side, u_dependency* dep) {
lp_assert(column_has_lower_bound(j) && !column_has_upper_bound(j)); SASSERT(column_has_lower_bound(j) && !column_has_upper_bound(j));
lp_assert(m_mpq_lar_core_solver.m_column_types[j] == column_type::lower_bound); SASSERT(m_mpq_lar_core_solver.m_column_types[j] == column_type::lower_bound);
mpq y_of_bound(0); mpq y_of_bound(0);
switch (kind) { switch (kind) {
@ -2183,8 +2184,8 @@ namespace lp {
} }
void lar_solver::update_bound_with_ub_no_lb(lpvar j, lconstraint_kind kind, const mpq& right_side, u_dependency* dep) { void lar_solver::update_bound_with_ub_no_lb(lpvar j, lconstraint_kind kind, const mpq& right_side, u_dependency* dep) {
lp_assert(!column_has_lower_bound(j) && column_has_upper_bound(j)); SASSERT(!column_has_lower_bound(j) && column_has_upper_bound(j));
lp_assert(m_mpq_lar_core_solver.m_column_types[j] == column_type::upper_bound); SASSERT(m_mpq_lar_core_solver.m_column_types[j] == column_type::upper_bound);
mpq y_of_bound(0); mpq y_of_bound(0);
switch (kind) { switch (kind) {
case LT: case LT:
@ -2238,7 +2239,7 @@ namespace lp {
} }
void lar_solver::update_bound_with_no_ub_no_lb(lpvar j, lconstraint_kind kind, const mpq& right_side, u_dependency* dep) { void lar_solver::update_bound_with_no_ub_no_lb(lpvar j, lconstraint_kind kind, const mpq& right_side, u_dependency* dep) {
lp_assert(!column_has_lower_bound(j) && !column_has_upper_bound(j)); SASSERT(!column_has_lower_bound(j) && !column_has_upper_bound(j));
mpq y_of_bound(0); mpq y_of_bound(0);
switch (kind) { switch (kind) {
@ -2388,7 +2389,7 @@ namespace lp {
} }
bool lar_solver::get_equality_and_right_side_for_term_on_current_x(lpvar j, mpq& rs, u_dependency*& ci, bool& upper_bound) const { bool lar_solver::get_equality_and_right_side_for_term_on_current_x(lpvar j, mpq& rs, u_dependency*& ci, bool& upper_bound) const {
lp_assert(column_has_term(j)); SASSERT(column_has_term(j));
if (!column_is_int(j)) // todo - allow for the next version of hnf if (!column_is_int(j)) // todo - allow for the next version of hnf
return false; return false;
bool rs_is_calculated = false; bool rs_is_calculated = false;
@ -2396,7 +2397,7 @@ namespace lp {
bool is_strict; bool is_strict;
const lar_term& term = get_term(j); const lar_term& term = get_term(j);
if (has_upper_bound(j, ci, b, is_strict) && !is_strict) { if (has_upper_bound(j, ci, b, is_strict) && !is_strict) {
lp_assert(b.is_int()); SASSERT(b.is_int());
if (!sum_first_coords(term, rs)) if (!sum_first_coords(term, rs))
return false; return false;
rs_is_calculated = true; rs_is_calculated = true;
@ -2410,7 +2411,7 @@ namespace lp {
if (!sum_first_coords(term, rs)) if (!sum_first_coords(term, rs))
return false; return false;
} }
lp_assert(b.is_int()); SASSERT(b.is_int());
if (rs == b) { if (rs == b) {
upper_bound = false; upper_bound = false;
@ -2471,7 +2472,7 @@ namespace lp {
// a_j.second givis the column // a_j.second givis the column
bool lar_solver::fetch_normalized_term_column(const lar_term& c, std::pair<mpq, lpvar>& a_j) const { bool lar_solver::fetch_normalized_term_column(const lar_term& c, std::pair<mpq, lpvar>& a_j) const {
TRACE("lar_solver_terms", print_term_as_indices(c, tout << "looking for term ") << "\n";); TRACE("lar_solver_terms", print_term_as_indices(c, tout << "looking for term ") << "\n";);
lp_assert(c.is_normalized()); SASSERT(c.is_normalized());
auto it = m_normalized_terms_to_columns.find(c); auto it = m_normalized_terms_to_columns.find(c);
if (it != m_normalized_terms_to_columns.end()) { if (it != m_normalized_terms_to_columns.end()) {
TRACE("lar_solver_terms", tout << "got " << it->second << "\n";); TRACE("lar_solver_terms", tout << "got " << it->second << "\n";);

4
src/math/lp/lar_solver.h
View file

@ -335,7 +335,7 @@ public:
int sign = j_sign * a_sign; int sign = j_sign * a_sign;
const column& ul = m_columns[j]; const column& ul = m_columns[j];
auto* witness = sign > 0 ? ul.upper_bound_witness() : ul.lower_bound_witness(); auto* witness = sign > 0 ? ul.upper_bound_witness() : ul.lower_bound_witness();
lp_assert(witness); SASSERT(witness);
for (auto ci : flatten(witness)) for (auto ci : flatten(witness))
bp.consume(a, ci); bp.consume(a, ci);
} }
@ -453,7 +453,7 @@ public:
void set_value_for_nbasic_column_report(unsigned j, void set_value_for_nbasic_column_report(unsigned j,
const impq& new_val, const impq& new_val,
const ChangeReport& after) { const ChangeReport& after) {
lp_assert(!is_base(j)); SASSERT(!is_base(j));
auto& x = m_mpq_lar_core_solver.r_x(j); auto& x = m_mpq_lar_core_solver.r_x(j);
auto delta = new_val - x; auto delta = new_val - x;
x = new_val; x = new_val;

28
src/math/lp/lp_bound_propagator.h
View file

@ -81,11 +81,11 @@ private:
if (v1 == v2) if (v1 == v2)
return; return;
#if Z3DEBUG #if Z3DEBUG
lp_assert(val(v1) == val(v2)); SASSERT(val(v1) == val(v2));
unsigned debv1, debv2; unsigned debv1, debv2;
lp_assert(only_one_nfixed(r1, debv1) && only_one_nfixed(r2, debv2)); SASSERT(only_one_nfixed(r1, debv1) && only_one_nfixed(r2, debv2));
lp_assert(debv1 == v1 && debv2 == v2); SASSERT(debv1 == v1 && debv2 == v2);
lp_assert(ival(v1).y == ival(v2).y); SASSERT(ival(v1).y == ival(v2).y);
#endif #endif
explanation ex; explanation ex;
explain_fixed_in_row(r1, ex); explain_fixed_in_row(r1, ex);
@ -214,8 +214,8 @@ public:
} }
bool add_eq_on_columns(const explanation& exp, lpvar je, lpvar ke, bool is_fixed) { bool add_eq_on_columns(const explanation& exp, lpvar je, lpvar ke, bool is_fixed) {
lp_assert(je != ke && is_int(je) == is_int(ke)); SASSERT(je != ke && is_int(je) == is_int(ke));
lp_assert(ival(je) == ival(ke)); SASSERT(ival(je) == ival(ke));
TRACE("eq", TRACE("eq",
tout << "reported idx " << je << ", " << ke << "\n"; tout << "reported idx " << je << ", " << ke << "\n";
@ -315,7 +315,7 @@ public:
continue; continue;
if (++nf > 2) if (++nf > 2)
return nf; return nf;
lp_assert(is_not_set(y)); SASSERT(is_not_set(y));
y = j; y = j;
if (c.coeff().is_one()) { if (c.coeff().is_one()) {
y_sign = 1; y_sign = 1;
@ -332,8 +332,8 @@ public:
} }
void try_add_equation_with_lp_fixed_tables(unsigned row_index, unsigned v_j) { void try_add_equation_with_lp_fixed_tables(unsigned row_index, unsigned v_j) {
lp_assert(lp().get_base_column_in_row(row_index) == v_j); SASSERT(lp().get_base_column_in_row(row_index) == v_j);
lp_assert(num_of_non_fixed_in_row(row_index) == 1 || column_is_fixed(v_j)); SASSERT(num_of_non_fixed_in_row(row_index) == 1 || column_is_fixed(v_j));
if (column_is_fixed(v_j)) { if (column_is_fixed(v_j)) {
return; return;
} }
@ -366,7 +366,7 @@ public:
if (nf == 0 || nf > 2) if (nf == 0 || nf > 2)
return; return;
if (nf == 1) { if (nf == 1) {
lp_assert(is_not_set(y)); SASSERT(is_not_set(y));
try_add_equation_with_lp_fixed_tables(row_index, x); try_add_equation_with_lp_fixed_tables(row_index, x);
return; return;
} }
@ -374,8 +374,8 @@ public:
// the coefficient before y is not 1 or -1 // the coefficient before y is not 1 or -1
return; return;
} }
lp_assert(y_sign == -1 || y_sign == 1); SASSERT(y_sign == -1 || y_sign == 1);
lp_assert(lp().is_base(y) == false); SASSERT(lp().is_base(y) == false);
auto& table = y_sign == 1 ? m_row2index_pos : m_row2index_neg; auto& table = y_sign == 1 ? m_row2index_pos : m_row2index_neg;
table.insert(val(x), row_index); table.insert(val(x), row_index);
TRACE("eq", tout << "y = " << y << "\n";); TRACE("eq", tout << "y = " << y << "\n";);
@ -391,8 +391,8 @@ public:
if (nf != 2 || y_sign == 0) if (nf != 2 || y_sign == 0)
continue; continue;
lp_assert(y_nb == y); SASSERT(y_nb == y);
lp_assert(y_sign == 1 || y_sign == -1); SASSERT(y_sign == 1 || y_sign == -1);
auto& table = y_sign == 1 ? m_row2index_pos : m_row2index_neg; auto& table = y_sign == 1 ? m_row2index_pos : m_row2index_neg;
const auto& v = val(x); const auto& v = val(x);
unsigned found_i;; unsigned found_i;;

22
src/math/lp/lp_core_solver_base.h
View file

@ -38,7 +38,7 @@ struct lpvar_lt {
typedef heap<lpvar_lt> lpvar_heap; typedef heap<lpvar_lt> lpvar_heap;
template <typename T, typename X> template <typename T, typename X>
X dot_product(const vector<T> & a, const vector<X> & b) { X dot_product(const vector<T> & a, const vector<X> & b) {
lp_assert(a.size() == b.size()); SASSERT(a.size() == b.size());
auto r = zero_of_type<X>(); auto r = zero_of_type<X>();
for (unsigned i = 0; i < a.size(); i++) { for (unsigned i = 0; i < a.size(); i++) {
r += a[i] * b[i]; r += a[i] * b[i];
@ -180,7 +180,7 @@ public:
unsigned m = m_A.row_count(); unsigned m = m_A.row_count();
for (unsigned i = 0; i < m; i++) { for (unsigned i = 0; i < m; i++) {
unsigned bj = m_basis[i]; unsigned bj = m_basis[i];
lp_assert(m_A.m_columns[bj].size() > 0); SASSERT(m_A.m_columns[bj].size() > 0);
if (m_A.m_columns[bj].size() > 1) if (m_A.m_columns[bj].size() > 1)
return true; return true;
for (const auto & c : m_A.m_columns[bj]) { for (const auto & c : m_A.m_columns[bj]) {
@ -293,11 +293,11 @@ public:
bool make_column_feasible(unsigned j, numeric_pair<mpq> & delta) { bool make_column_feasible(unsigned j, numeric_pair<mpq> & delta) {
bool ret = false; bool ret = false;
lp_assert(m_basis_heading[j] < 0); SASSERT(m_basis_heading[j] < 0);
const auto & x = m_x[j]; const auto & x = m_x[j];
switch (m_column_types[j]) { switch (m_column_types[j]) {
case column_type::fixed: case column_type::fixed:
lp_assert(m_lower_bounds[j] == m_upper_bounds[j]); SASSERT(m_lower_bounds[j] == m_upper_bounds[j]);
if (x != m_lower_bounds[j]) { if (x != m_lower_bounds[j]) {
delta = m_lower_bounds[j] - x; delta = m_lower_bounds[j] - x;
ret = true; ret = true;
@ -365,7 +365,7 @@ public:
void change_basis_unconditionally(unsigned entering, unsigned leaving) { void change_basis_unconditionally(unsigned entering, unsigned leaving) {
TRACE("lar_solver", tout << "entering = " << entering << ", leaving = " << leaving << "\n";); TRACE("lar_solver", tout << "entering = " << entering << ", leaving = " << leaving << "\n";);
lp_assert(m_basis_heading[entering] < 0); SASSERT(m_basis_heading[entering] < 0);
int place_in_non_basis = -1 - m_basis_heading[entering]; int place_in_non_basis = -1 - m_basis_heading[entering];
if (static_cast<unsigned>(place_in_non_basis) >= m_nbasis.size()) { if (static_cast<unsigned>(place_in_non_basis) >= m_nbasis.size()) {
// entering variable in not in m_nbasis, we need to put it back; // entering variable in not in m_nbasis, we need to put it back;
@ -385,8 +385,8 @@ public:
void change_basis(unsigned entering, unsigned leaving) { void change_basis(unsigned entering, unsigned leaving) {
TRACE("lar_solver", tout << "entering = " << entering << ", leaving = " << leaving << "\n";); TRACE("lar_solver", tout << "entering = " << entering << ", leaving = " << leaving << "\n";);
lp_assert(m_basis_heading[entering] < 0); SASSERT(m_basis_heading[entering] < 0);
lp_assert(m_basis_heading[leaving] >= 0); SASSERT(m_basis_heading[leaving] >= 0);
int place_in_basis = m_basis_heading[leaving]; int place_in_basis = m_basis_heading[leaving];
int place_in_non_basis = - m_basis_heading[entering] - 1; int place_in_non_basis = - m_basis_heading[entering] - 1;
@ -573,14 +573,14 @@ public:
m_inf_heap.insert(j); m_inf_heap.insert(j);
TRACE("lar_solver_inf_heap", tout << "insert into inf_heap j = " << j << "\n";); TRACE("lar_solver_inf_heap", tout << "insert into inf_heap j = " << j << "\n";);
} }
lp_assert(!column_is_feasible(j)); SASSERT(!column_is_feasible(j));
} }
void remove_column_from_inf_heap(unsigned j) { void remove_column_from_inf_heap(unsigned j) {
if (m_inf_heap.contains(j)) { if (m_inf_heap.contains(j)) {
TRACE("lar_solver_inf_heap", tout << "erase from heap j = " << j << "\n";); TRACE("lar_solver_inf_heap", tout << "erase from heap j = " << j << "\n";);
m_inf_heap.erase(j); m_inf_heap.erase(j);
} }
lp_assert(column_is_feasible(j)); SASSERT(column_is_feasible(j));
} }
void clear_inf_heap() { void clear_inf_heap() {
@ -589,10 +589,10 @@ public:
} }
bool costs_on_nbasis_are_zeros() const { bool costs_on_nbasis_are_zeros() const {
lp_assert(this->basis_heading_is_correct()); SASSERT(this->basis_heading_is_correct());
for (unsigned j = 0; j < this->m_n(); j++) { for (unsigned j = 0; j < this->m_n(); j++) {
if (this->m_basis_heading[j] < 0) if (this->m_basis_heading[j] < 0)
lp_assert(is_zero(this->m_costs[j])); SASSERT(is_zero(this->m_costs[j]));
} }
return true; return true;
} }

20
src/math/lp/lp_core_solver_base_def.h
View file

@ -60,7 +60,7 @@ lp_core_solver_base(static_matrix<T, X> & A,
m_tracing_basis_changes(false), m_tracing_basis_changes(false),
m_touched_rows(nullptr), m_touched_rows(nullptr),
m_look_for_feasible_solution_only(false) { m_look_for_feasible_solution_only(false) {
lp_assert(bounds_for_boxed_are_set_correctly()); SASSERT(bounds_for_boxed_are_set_correctly());
init(); init();
init_basis_heading_and_non_basic_columns_vector(); init_basis_heading_and_non_basic_columns_vector();
} }
@ -68,7 +68,7 @@ lp_core_solver_base(static_matrix<T, X> & A,
template <typename T, typename X> void lp_core_solver_base<T, X>:: template <typename T, typename X> void lp_core_solver_base<T, X>::
allocate_basis_heading() { // the rest of initialization will be handled by the factorization class allocate_basis_heading() { // the rest of initialization will be handled by the factorization class
init_basis_heading_and_non_basic_columns_vector(); init_basis_heading_and_non_basic_columns_vector();
lp_assert(basis_heading_is_correct()); SASSERT(basis_heading_is_correct());
} }
template <typename T, typename X> void lp_core_solver_base<T, X>:: template <typename T, typename X> void lp_core_solver_base<T, X>::
init() { init() {
@ -267,7 +267,7 @@ pivot_column_tableau(unsigned j, unsigned piv_row_index) {
return false; return false;
if (pivot_col_cell_index != 0) { if (pivot_col_cell_index != 0) {
lp_assert(column.size() > 1); SASSERT(column.size() > 1);
// swap the pivot column cell with the head cell // swap the pivot column cell with the head cell
auto c = column[0]; auto c = column[0];
column[0] = column[pivot_col_cell_index]; column[0] = column[pivot_col_cell_index];
@ -278,7 +278,7 @@ pivot_column_tableau(unsigned j, unsigned piv_row_index) {
} }
while (column.size() > 1) { while (column.size() > 1) {
auto & c = column.back(); auto & c = column.back();
lp_assert(c.var() != piv_row_index); SASSERT(c.var() != piv_row_index);
if(! m_A.pivot_row_to_row_given_cell(piv_row_index, c, j)) { if(! m_A.pivot_row_to_row_given_cell(piv_row_index, c, j)) {
return false; return false;
} }
@ -324,7 +324,7 @@ non_basis_is_correctly_represented_in_heading(std::list<unsigned>* non_basis_lis
for (unsigned j = 0; j < m_A.column_count(); j++) for (unsigned j = 0; j < m_A.column_count(); j++)
if (m_basis_heading[j] >= 0) if (m_basis_heading[j] >= 0)
lp_assert(static_cast<unsigned>(m_basis_heading[j]) < m_A.row_count() && m_basis[m_basis_heading[j]] == j); SASSERT(static_cast<unsigned>(m_basis_heading[j]) < m_A.row_count() && m_basis[m_basis_heading[j]] == j);
if (non_basis_list == nullptr) return true; if (non_basis_list == nullptr) return true;
@ -361,9 +361,9 @@ template <typename T, typename X> bool lp_core_solver_base<T, X>::
if ( m_A.column_count() > 10 ) // for the performance reason if ( m_A.column_count() > 10 ) // for the performance reason
return true; return true;
lp_assert(m_basis_heading.size() == m_A.column_count()); SASSERT(m_basis_heading.size() == m_A.column_count());
lp_assert(m_basis.size() == m_A.row_count()); SASSERT(m_basis.size() == m_A.row_count());
lp_assert(m_nbasis.size() <= m_A.column_count() - m_A.row_count()); // for the dual the size of non basis can be smaller SASSERT(m_nbasis.size() <= m_A.column_count() - m_A.row_count()); // for the dual the size of non basis can be smaller
if (!basis_has_no_doubles()) if (!basis_has_no_doubles())
return false; return false;
@ -391,8 +391,8 @@ template <typename T, typename X> void lp_core_solver_base<T, X>::transpose_row
} }
// entering is the new base column, leaving - the column leaving the basis // entering is the new base column, leaving - the column leaving the basis
template <typename T, typename X> bool lp_core_solver_base<T, X>::pivot_column_general(unsigned entering, unsigned leaving, indexed_vector<T> & w) { template <typename T, typename X> bool lp_core_solver_base<T, X>::pivot_column_general(unsigned entering, unsigned leaving, indexed_vector<T> & w) {
lp_assert(m_basis_heading[entering] < 0); SASSERT(m_basis_heading[entering] < 0);
lp_assert(m_basis_heading[leaving] >= 0); SASSERT(m_basis_heading[leaving] >= 0);
unsigned row_index = m_basis_heading[leaving]; unsigned row_index = m_basis_heading[leaving];
// the tableau case // the tableau case
if (!pivot_column_tableau(entering, row_index)) if (!pivot_column_tableau(entering, row_index))

38
src/math/lp/lp_primal_core_solver.h
View file

@ -56,7 +56,7 @@ namespace lp {
int choose_entering_column_tableau(); int choose_entering_column_tableau();
bool needs_to_grow(unsigned bj) const { bool needs_to_grow(unsigned bj) const {
lp_assert(!this->column_is_feasible(bj)); SASSERT(!this->column_is_feasible(bj));
switch (this->m_column_types[bj]) { switch (this->m_column_types[bj]) {
case column_type::free_column: case column_type::free_column:
return false; return false;
@ -72,7 +72,7 @@ namespace lp {
} }
int inf_sign_of_column(unsigned bj) const { int inf_sign_of_column(unsigned bj) const {
lp_assert(!this->column_is_feasible(bj)); SASSERT(!this->column_is_feasible(bj));
switch (this->m_column_types[bj]) { switch (this->m_column_types[bj]) {
case column_type::free_column: case column_type::free_column:
return 0; return 0;
@ -90,7 +90,7 @@ namespace lp {
bool monoid_can_decrease(const row_cell<T> &rc) const { bool monoid_can_decrease(const row_cell<T> &rc) const {
unsigned j = rc.var(); unsigned j = rc.var();
lp_assert(this->column_is_feasible(j)); SASSERT(this->column_is_feasible(j));
switch (this->m_column_types[j]) { switch (this->m_column_types[j]) {
case column_type::free_column: case column_type::free_column:
return true; return true;
@ -113,7 +113,7 @@ namespace lp {
bool monoid_can_increase(const row_cell<T> &rc) const { bool monoid_can_increase(const row_cell<T> &rc) const {
unsigned j = rc.var(); unsigned j = rc.var();
lp_assert(this->column_is_feasible(j)); SASSERT(this->column_is_feasible(j));
switch (this->m_column_types[j]) { switch (this->m_column_types[j]) {
case column_type::free_column: case column_type::free_column:
return true; return true;
@ -247,25 +247,25 @@ namespace lp {
void limit_theta_on_basis_column_for_inf_case_m_neg_upper_bound( void limit_theta_on_basis_column_for_inf_case_m_neg_upper_bound(
unsigned j, const T &m, X &theta, bool &unlimited) { unsigned j, const T &m, X &theta, bool &unlimited) {
lp_assert(m < 0 && this->m_column_types[j] == column_type::upper_bound); SASSERT(m < 0 && this->m_column_types[j] == column_type::upper_bound);
limit_inf_on_upper_bound_m_neg(m, this->m_x[j], this->m_upper_bounds[j], theta, unlimited); limit_inf_on_upper_bound_m_neg(m, this->m_x[j], this->m_upper_bounds[j], theta, unlimited);
} }
void limit_theta_on_basis_column_for_inf_case_m_neg_lower_bound( void limit_theta_on_basis_column_for_inf_case_m_neg_lower_bound(
unsigned j, const T &m, X &theta, bool &unlimited) { unsigned j, const T &m, X &theta, bool &unlimited) {
lp_assert(m < 0 && this->m_column_types[j] == column_type::lower_bound); SASSERT(m < 0 && this->m_column_types[j] == column_type::lower_bound);
limit_inf_on_bound_m_neg(m, this->m_x[j], this->m_lower_bounds[j], theta, unlimited); limit_inf_on_bound_m_neg(m, this->m_x[j], this->m_lower_bounds[j], theta, unlimited);
} }
void limit_theta_on_basis_column_for_inf_case_m_pos_lower_bound( void limit_theta_on_basis_column_for_inf_case_m_pos_lower_bound(
unsigned j, const T &m, X &theta, bool &unlimited) { unsigned j, const T &m, X &theta, bool &unlimited) {
lp_assert(m > 0 && this->m_column_types[j] == column_type::lower_bound); SASSERT(m > 0 && this->m_column_types[j] == column_type::lower_bound);
limit_inf_on_lower_bound_m_pos(m, this->m_x[j], this->m_lower_bounds[j], theta, unlimited); limit_inf_on_lower_bound_m_pos(m, this->m_x[j], this->m_lower_bounds[j], theta, unlimited);
} }
void limit_theta_on_basis_column_for_inf_case_m_pos_upper_bound( void limit_theta_on_basis_column_for_inf_case_m_pos_upper_bound(
unsigned j, const T &m, X &theta, bool &unlimited) { unsigned j, const T &m, X &theta, bool &unlimited) {
lp_assert(m > 0 && this->m_column_types[j] == column_type::upper_bound); SASSERT(m > 0 && this->m_column_types[j] == column_type::upper_bound);
limit_inf_on_bound_m_pos(m, this->m_x[j], this->m_upper_bounds[j], theta, unlimited); limit_inf_on_bound_m_pos(m, this->m_x[j], this->m_upper_bounds[j], theta, unlimited);
}; };
@ -294,7 +294,7 @@ namespace lp {
if (this->m_settings.simplex_strategy() == if (this->m_settings.simplex_strategy() ==
simplex_strategy_enum::tableau_rows) simplex_strategy_enum::tableau_rows)
return false; return false;
// lp_assert(calc_current_x_is_feasible() == // SASSERT(calc_current_x_is_feasible() ==
// current_x_is_feasible()); // current_x_is_feasible());
return this->current_x_is_feasible() == this->using_infeas_costs(); return this->current_x_is_feasible() == this->using_infeas_costs();
} }
@ -326,7 +326,7 @@ namespace lp {
} }
void update_basis_and_x_tableau_rows(int entering, int leaving, X const &tt) { void update_basis_and_x_tableau_rows(int entering, int leaving, X const &tt) {
lp_assert(entering != leaving); SASSERT(entering != leaving);
update_x_tableau_rows(entering, leaving, tt); update_x_tableau_rows(entering, leaving, tt);
this->pivot_column_tableau(entering, this->m_basis_heading[leaving]); this->pivot_column_tableau(entering, this->m_basis_heading[leaving]);
this->change_basis(entering, leaving); this->change_basis(entering, leaving);
@ -346,7 +346,7 @@ namespace lp {
} }
const X &get_val_for_leaving(unsigned j) const { const X &get_val_for_leaving(unsigned j) const {
lp_assert(!this->column_is_feasible(j)); SASSERT(!this->column_is_feasible(j));
switch (this->m_column_types[j]) { switch (this->m_column_types[j]) {
case column_type::fixed: case column_type::fixed:
case column_type::upper_bound: case column_type::upper_bound:
@ -411,7 +411,7 @@ namespace lp {
void limit_theta_on_basis_column_for_feas_case_m_neg_no_check( void limit_theta_on_basis_column_for_feas_case_m_neg_no_check(
unsigned j, const T &m, X &theta, bool &unlimited) { unsigned j, const T &m, X &theta, bool &unlimited) {
lp_assert(m < 0); SASSERT(m < 0);
limit_theta((this->m_lower_bounds[j] - this->m_x[j]) / m, theta, unlimited); limit_theta((this->m_lower_bounds[j] - this->m_x[j]) / m, theta, unlimited);
if (theta < zero_of_type<X>()) if (theta < zero_of_type<X>())
theta = zero_of_type<X>(); theta = zero_of_type<X>();
@ -420,7 +420,7 @@ namespace lp {
bool limit_inf_on_bound_m_neg(const T &m, const X &x, const X &bound, bool limit_inf_on_bound_m_neg(const T &m, const X &x, const X &bound,
X &theta, bool &unlimited) { X &theta, bool &unlimited) {
// x gets smaller // x gets smaller
lp_assert(m < 0); SASSERT(m < 0);
if (this->below_bound(x, bound)) if (this->below_bound(x, bound))
return false; return false;
if (this->above_bound(x, bound)) { if (this->above_bound(x, bound)) {
@ -435,7 +435,7 @@ namespace lp {
bool limit_inf_on_bound_m_pos(const T &m, const X &x, const X &bound, bool limit_inf_on_bound_m_pos(const T &m, const X &x, const X &bound,
X &theta, bool &unlimited) { X &theta, bool &unlimited) {
// x gets larger // x gets larger
lp_assert(m > 0); SASSERT(m > 0);
if (this->above_bound(x, bound)) if (this->above_bound(x, bound))
return false; return false;
if (this->below_bound(x, bound)) { if (this->below_bound(x, bound)) {
@ -451,7 +451,7 @@ namespace lp {
void limit_inf_on_lower_bound_m_pos(const T &m, const X &x, const X &bound, void limit_inf_on_lower_bound_m_pos(const T &m, const X &x, const X &bound,
X &theta, bool &unlimited) { X &theta, bool &unlimited) {
// x gets larger // x gets larger
lp_assert(m > 0); SASSERT(m > 0);
if (this->below_bound(x, bound)) { if (this->below_bound(x, bound)) {
limit_theta((bound - x) / m, theta, unlimited); limit_theta((bound - x) / m, theta, unlimited);
} }
@ -460,7 +460,7 @@ namespace lp {
void limit_inf_on_upper_bound_m_neg(const T &m, const X &x, const X &bound, void limit_inf_on_upper_bound_m_neg(const T &m, const X &x, const X &bound,
X &theta, bool &unlimited) { X &theta, bool &unlimited) {
// x gets smaller // x gets smaller
lp_assert(m < 0); SASSERT(m < 0);
if (this->above_bound(x, bound)) { if (this->above_bound(x, bound)) {
limit_theta((bound - x) / m, theta, unlimited); limit_theta((bound - x) / m, theta, unlimited);
} }
@ -490,7 +490,7 @@ namespace lp {
const T &m, const T &m,
X &theta, X &theta,
bool &unlimited) { bool &unlimited) {
// lp_assert(m < 0 && this->m_column_type[j] == column_type::boxed); // SASSERT(m < 0 && this->m_column_type[j] == column_type::boxed);
const X &x = this->m_x[j]; const X &x = this->m_x[j];
const X &ubound = this->m_upper_bounds[j]; const X &ubound = this->m_upper_bounds[j];
if (this->above_bound(x, ubound)) { if (this->above_bound(x, ubound)) {
@ -508,7 +508,7 @@ namespace lp {
void limit_theta_on_basis_column_for_feas_case_m_pos_no_check( void limit_theta_on_basis_column_for_feas_case_m_pos_no_check(
unsigned j, const T &m, X &theta, bool &unlimited) { unsigned j, const T &m, X &theta, bool &unlimited) {
lp_assert(m > 0); SASSERT(m > 0);
limit_theta((this->m_upper_bounds[j] - this->m_x[j]) / m, theta, unlimited); limit_theta((this->m_upper_bounds[j] - this->m_x[j]) / m, theta, unlimited);
if (theta < zero_of_type<X>()) { if (theta < zero_of_type<X>()) {
theta = zero_of_type<X>(); theta = zero_of_type<X>();
@ -617,7 +617,7 @@ namespace lp {
// the delta is between the old and the new cost (old - new) // the delta is between the old and the new cost (old - new)
void update_reduced_cost_for_basic_column_cost_change(const T &delta, void update_reduced_cost_for_basic_column_cost_change(const T &delta,
unsigned j) { unsigned j) {
lp_assert(this->m_basis_heading[j] >= 0); SASSERT(this->m_basis_heading[j] >= 0);
unsigned i = static_cast<unsigned>(this->m_basis_heading[j]); unsigned i = static_cast<unsigned>(this->m_basis_heading[j]);
for (const row_cell<T> &rc : this->m_A.m_rows[i]) { for (const row_cell<T> &rc : this->m_A.m_rows[i]) {
unsigned k = rc.var(); unsigned k = rc.var();

8
src/math/lp/lp_primal_core_solver_def.h
View file

@ -179,7 +179,7 @@ lp_primal_core_solver<T, X>::get_bound_on_variable_and_update_leaving_precisely(
template <typename T, typename X> void lp_primal_core_solver<T, X>::check_Ax_equal_b() { template <typename T, typename X> void lp_primal_core_solver<T, X>::check_Ax_equal_b() {
dense_matrix<T, X> d(this->m_A); dense_matrix<T, X> d(this->m_A);
T * ls = d.apply_from_left_with_different_dims(this->m_x); T * ls = d.apply_from_left_with_different_dims(this->m_x);
lp_assert(vectors_are_equal<T>(ls, this->m_b, this->m_m())); SASSERT(vectors_are_equal<T>(ls, this->m_b, this->m_m()));
delete [] ls; delete [] ls;
} }
template <typename T, typename X> void lp_primal_core_solver<T, X>::check_the_bounds() { template <typename T, typename X> void lp_primal_core_solver<T, X>::check_the_bounds() {
@ -189,8 +189,8 @@ template <typename T, typename X> void lp_primal_core_solver<T, X>::check_the
} }
template <typename T, typename X> void lp_primal_core_solver<T, X>::check_bound(unsigned i) { template <typename T, typename X> void lp_primal_core_solver<T, X>::check_bound(unsigned i) {
lp_assert (!(this->column_has_lower_bound(i) && (numeric_traits<T>::zero() > this->m_x[i]))); SASSERT (!(this->column_has_lower_bound(i) && (numeric_traits<T>::zero() > this->m_x[i])));
lp_assert (!(this->column_has_upper_bound(i) && (this->m_upper_bounds[i] < this->m_x[i]))); SASSERT (!(this->column_has_upper_bound(i) && (this->m_upper_bounds[i] < this->m_x[i])));
} }
template <typename T, typename X> void lp_primal_core_solver<T, X>::check_correctness() { template <typename T, typename X> void lp_primal_core_solver<T, X>::check_correctness() {
@ -231,7 +231,7 @@ template <typename T, typename X> unsigned lp_primal_core_solver<T, X>::get_num
// calling it stage1 is too cryptic // calling it stage1 is too cryptic
template <typename T, typename X> void lp_primal_core_solver<T, X>::find_feasible_solution() { template <typename T, typename X> void lp_primal_core_solver<T, X>::find_feasible_solution() {
this->m_look_for_feasible_solution_only = true; this->m_look_for_feasible_solution_only = true;
lp_assert(this->non_basic_columns_are_set_correctly()); SASSERT(this->non_basic_columns_are_set_correctly());
this->set_status(lp_status::UNKNOWN); this->set_status(lp_status::UNKNOWN);
solve(); solve();
} }

28
src/math/lp/lp_primal_core_solver_tableau_def.h
View file

@ -30,7 +30,7 @@ template <typename T, typename X> void lp_primal_core_solver<T, X>::one_iteratio
else { else {
advance_on_entering_tableau(entering); advance_on_entering_tableau(entering);
} }
lp_assert(this->inf_heap_is_correct()); SASSERT(this->inf_heap_is_correct());
} }
template <typename T, typename X> void lp_primal_core_solver<T, X>::advance_on_entering_tableau(int entering) { template <typename T, typename X> void lp_primal_core_solver<T, X>::advance_on_entering_tableau(int entering) {
@ -116,7 +116,7 @@ unsigned lp_primal_core_solver<T, X>::solve() {
UNREACHABLE(); UNREACHABLE();
break; break;
case lp_status::UNBOUNDED: case lp_status::UNBOUNDED:
lp_assert (this->current_x_is_feasible()); SASSERT (this->current_x_is_feasible());
break; break;
case lp_status::UNSTABLE: case lp_status::UNSTABLE:
@ -143,7 +143,7 @@ unsigned lp_primal_core_solver<T, X>::solve() {
!(this->current_x_is_feasible() && this->m_look_for_feasible_solution_only) !(this->current_x_is_feasible() && this->m_look_for_feasible_solution_only)
); );
lp_assert( SASSERT(
this->get_status() == lp_status::CANCELLED this->get_status() == lp_status::CANCELLED
|| ||
this->current_x_is_feasible() == false this->current_x_is_feasible() == false
@ -153,12 +153,12 @@ unsigned lp_primal_core_solver<T, X>::solve() {
} }
template <typename T, typename X>void lp_primal_core_solver<T, X>::advance_on_entering_and_leaving_tableau(int entering, int leaving, X & t) { template <typename T, typename X>void lp_primal_core_solver<T, X>::advance_on_entering_and_leaving_tableau(int entering, int leaving, X & t) {
lp_assert(leaving >= 0 && entering >= 0); SASSERT(leaving >= 0 && entering >= 0);
lp_assert((this->m_settings.simplex_strategy() == SASSERT((this->m_settings.simplex_strategy() ==
simplex_strategy_enum::tableau_rows) || simplex_strategy_enum::tableau_rows) ||
m_non_basis_list.back() == static_cast<unsigned>(entering)); m_non_basis_list.back() == static_cast<unsigned>(entering));
lp_assert(!is_neg(t)); SASSERT(!is_neg(t));
lp_assert(entering != leaving || !is_zero(t)); // otherwise nothing changes SASSERT(entering != leaving || !is_zero(t)); // otherwise nothing changes
if (entering == leaving) { if (entering == leaving) {
advance_on_entering_equal_leaving_tableau(entering, t); advance_on_entering_equal_leaving_tableau(entering, t);
return; return;
@ -206,7 +206,7 @@ template <typename T, typename X> int lp_primal_core_solver<T, X>::find_leaving_
const column_cell & c = col[k]; const column_cell & c = col[k];
unsigned i = c.var(); unsigned i = c.var();
const T & ed = this->m_A.get_val(c); const T & ed = this->m_A.get_val(c);
lp_assert(!numeric_traits<T>::is_zero(ed)); SASSERT(!numeric_traits<T>::is_zero(ed));
unsigned j = this->m_basis[i]; unsigned j = this->m_basis[i];
limit_theta_on_basis_column(j, - ed * m_sign_of_entering_delta, t, unlimited); limit_theta_on_basis_column(j, - ed * m_sign_of_entering_delta, t, unlimited);
if (!unlimited) { if (!unlimited) {
@ -225,7 +225,7 @@ template <typename T, typename X> int lp_primal_core_solver<T, X>::find_leaving_
const column_cell & c = col[k]; const column_cell & c = col[k];
unsigned i = c.var(); unsigned i = c.var();
const T & ed = this->m_A.get_val(c); const T & ed = this->m_A.get_val(c);
lp_assert(!numeric_traits<T>::is_zero(ed)); SASSERT(!numeric_traits<T>::is_zero(ed));
unsigned j = this->m_basis[i]; unsigned j = this->m_basis[i];
unlimited = true; unlimited = true;
limit_theta_on_basis_column(j, -ed * m_sign_of_entering_delta, ratio, unlimited); limit_theta_on_basis_column(j, -ed * m_sign_of_entering_delta, ratio, unlimited);
@ -254,9 +254,9 @@ template <typename T, typename X> int lp_primal_core_solver<T, X>::find_leaving_
return m_leaving_candidates[k]; return m_leaving_candidates[k];
} }
template <typename T, typename X> void lp_primal_core_solver<T, X>::init_run_tableau() { template <typename T, typename X> void lp_primal_core_solver<T, X>::init_run_tableau() {
lp_assert(basis_columns_are_set_correctly()); SASSERT(basis_columns_are_set_correctly());
this->iters_with_no_cost_growing() = 0; this->iters_with_no_cost_growing() = 0;
lp_assert(this->inf_heap_is_correct()); SASSERT(this->inf_heap_is_correct());
if (this->current_x_is_feasible() && this->m_look_for_feasible_solution_only) if (this->current_x_is_feasible() && this->m_look_for_feasible_solution_only)
return; return;
if (this->m_settings.backup_costs) if (this->m_settings.backup_costs)
@ -264,13 +264,13 @@ template <typename T, typename X> void lp_primal_core_solver<T, X>::init_run_tab
if (this->m_settings.simplex_strategy() == simplex_strategy_enum::tableau_rows) if (this->m_settings.simplex_strategy() == simplex_strategy_enum::tableau_rows)
init_tableau_rows(); init_tableau_rows();
lp_assert(this->reduced_costs_are_correct_tableau()); SASSERT(this->reduced_costs_are_correct_tableau());
lp_assert(!this->need_to_pivot_to_basis_tableau()); SASSERT(!this->need_to_pivot_to_basis_tableau());
} }
template <typename T, typename X> bool lp_primal_core_solver<T, X>:: template <typename T, typename X> bool lp_primal_core_solver<T, X>::
update_basis_and_x_tableau(int entering, int leaving, X const & tt) { update_basis_and_x_tableau(int entering, int leaving, X const & tt) {
lp_assert(entering != leaving); SASSERT(entering != leaving);
update_x_tableau(entering, tt); update_x_tableau(entering, tt);
this->pivot_column_tableau(entering, this->m_basis_heading[leaving]); this->pivot_column_tableau(entering, this->m_basis_heading[leaving]);
this->change_basis(entering, leaving); this->change_basis(entering, leaving);

4
src/math/lp/lp_settings.h
View file

@ -376,7 +376,7 @@ inline void print_blanks(int n, std::ostream & out) {
// after a push of the last element we ensure that the vector increases // after a push of the last element we ensure that the vector increases
// we also suppose that before the last push the vector was increasing // we also suppose that before the last push the vector was increasing
inline void ensure_increasing(vector<unsigned> & v) { inline void ensure_increasing(vector<unsigned> & v) {
lp_assert(v.size() > 0); SASSERT(v.size() > 0);
unsigned j = v.size() - 1; unsigned j = v.size() - 1;
for (; j > 0; j-- ) for (; j > 0; j-- )
if (v[j] <= v[j - 1]) { if (v[j] <= v[j - 1]) {
@ -392,7 +392,7 @@ inline void ensure_increasing(vector<unsigned> & v) {
inline static bool is_rational(const impq & n) { return is_zero(n.y); } inline static bool is_rational(const impq & n) { return is_zero(n.y); }
inline static mpq fractional_part(const impq & n) { inline static mpq fractional_part(const impq & n) {
lp_assert(is_rational(n)); SASSERT(is_rational(n));
return n.x - floor(n.x); return n.x - floor(n.x);
} }
inline static mpq fractional_part(const mpq & n) { inline static mpq fractional_part(const mpq & n) {

1
src/math/lp/lp_utils.h
View file

@ -151,7 +151,6 @@ inline void throw_exception(std::string && str) {
} }
typedef z3_exception exception; typedef z3_exception exception;
#define lp_assert(_x_) { SASSERT(_x_); }
template <typename X> inline X zero_of_type() { return numeric_traits<X>::zero(); } template <typename X> inline X zero_of_type() { return numeric_traits<X>::zero(); }
template <typename X> inline X one_of_type() { return numeric_traits<X>::one(); } template <typename X> inline X one_of_type() { return numeric_traits<X>::one(); }
template <typename X> inline bool is_zero(const X & v) { return numeric_traits<X>::is_zero(v); } template <typename X> inline bool is_zero(const X & v) { return numeric_traits<X>::is_zero(v); }

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

@ -69,7 +69,7 @@ class permutation_matrix
unsigned operator[](unsigned i) const { return m_permutation[i]; } unsigned operator[](unsigned i) const { return m_permutation[i]; }
void set_val(unsigned i, unsigned pi) { void set_val(unsigned i, unsigned pi) {
lp_assert(i < size() && pi < size()); m_permutation[i] = pi; m_rev[pi] = i; } SASSERT(i < size() && pi < size()); m_permutation[i] = pi; m_rev[pi] = i; }
void transpose_from_left(unsigned i, unsigned j); void transpose_from_left(unsigned i, unsigned j);

4
src/math/lp/permutation_matrix_def.h
View file

@ -60,7 +60,7 @@ template <typename T, typename X> void permutation_matrix<T, X>::print(std::ostr
template <typename T, typename X> void permutation_matrix<T, X>::transpose_from_left(unsigned i, unsigned j) { template <typename T, typename X> void permutation_matrix<T, X>::transpose_from_left(unsigned i, unsigned j) {
// the result will be this = (i,j)*this // the result will be this = (i,j)*this
lp_assert(i < size() && j < size() && i != j); SASSERT(i < size() && j < size() && i != j);
auto pi = m_rev[i]; auto pi = m_rev[i];
auto pj = m_rev[j]; auto pj = m_rev[j];
set_val(pi, j); set_val(pi, j);
@ -69,7 +69,7 @@ template <typename T, typename X> void permutation_matrix<T, X>::transpose_from_
template <typename T, typename X> void permutation_matrix<T, X>::transpose_from_right(unsigned i, unsigned j) { template <typename T, typename X> void permutation_matrix<T, X>::transpose_from_right(unsigned i, unsigned j) {
// the result will be this = this * (i,j) // the result will be this = this * (i,j)
lp_assert(i < size() && j < size() && i != j); SASSERT(i < size() && j < size() && i != j);
auto pi = m_permutation[i]; auto pi = m_permutation[i];
auto pj = m_permutation[j]; auto pj = m_permutation[j];
set_val(i, pj); set_val(i, pj);

14
src/math/lp/stacked_vector.h
View file

@ -38,7 +38,7 @@ public:
unsigned m_i; unsigned m_i;
public: public:
ref(stacked_vector<B> &m, unsigned key): m_vec(m), m_i(key) { ref(stacked_vector<B> &m, unsigned key): m_vec(m), m_i(key) {
lp_assert(key < m.size()); SASSERT(key < m.size());
} }
ref & operator=(const B & b) { ref & operator=(const B & b) {
m_vec.emplace_replace(m_i, b); m_vec.emplace_replace(m_i, b);
@ -81,7 +81,7 @@ public:
unsigned m_i; unsigned m_i;
public: public:
ref_const(const stacked_vector<B> &m, unsigned key) :m_vec(m), m_i(key) { ref_const(const stacked_vector<B> &m, unsigned key) :m_vec(m), m_i(key) {
lp_assert(key < m.size()); SASSERT(key < m.size());
} }
operator const B&() const { operator const B&() const {
return m_vec.m_vector[m_i]; return m_vec.m_vector[m_i];
@ -120,7 +120,7 @@ public:
/* /*
const B & operator[](unsigned a) const { const B & operator[](unsigned a) const {
lp_assert(a < m_vector.size()); SASSERT(a < m_vector.size());
return m_vector[a]; return m_vector[a];
} }
*/ */
@ -139,7 +139,7 @@ public:
template <typename T> template <typename T>
void pop_tail(svector<T> & v, unsigned k) { void pop_tail(svector<T> & v, unsigned k) {
lp_assert(v.size() >= k); SASSERT(v.size() >= k);
v.resize(v.size() - k); v.resize(v.size() - k);
} }
@ -149,8 +149,8 @@ public:
} }
void pop(unsigned k) { void pop(unsigned k) {
lp_assert(m_stack_of_vector_sizes.size() >= k); SASSERT(m_stack_of_vector_sizes.size() >= k);
lp_assert(k > 0); SASSERT(k > 0);
m_vector.resize(m_stack_of_vector_sizes[m_stack_of_vector_sizes.size() - k]); m_vector.resize(m_stack_of_vector_sizes[m_stack_of_vector_sizes.size() - k]);
m_last_update.resize(m_stack_of_vector_sizes[m_stack_of_vector_sizes.size() - k]); m_last_update.resize(m_stack_of_vector_sizes[m_stack_of_vector_sizes.size() - k]);
pop_tail(m_stack_of_vector_sizes, k); pop_tail(m_stack_of_vector_sizes, k);
@ -179,7 +179,7 @@ public:
} }
unsigned peek_size(unsigned k) const { unsigned peek_size(unsigned k) const {
lp_assert(k > 0 && k <= m_stack_of_vector_sizes.size()); SASSERT(k > 0 && k <= m_stack_of_vector_sizes.size());
return m_stack_of_vector_sizes[m_stack_of_vector_sizes.size() - k]; return m_stack_of_vector_sizes[m_stack_of_vector_sizes.size() - k];
} }

16
src/math/lp/static_matrix.h
View file

@ -236,7 +236,7 @@ public:
for (auto & c : row) { for (auto & c : row) {
unsigned j = c.var(); unsigned j = c.var();
auto & col = m_columns[j]; auto & col = m_columns[j];
lp_assert(col[col.size() - 1].var() == m_rows.size() -1 ); // todo : start here!!!! SASSERT(col[col.size() - 1].var() == m_rows.size() -1 ); // todo : start here!!!!
col.pop_back(); col.pop_back();
} }
} }
@ -263,7 +263,7 @@ public:
m_columns.pop_back(); // delete the last column m_columns.pop_back(); // delete the last column
m_stack.pop(); m_stack.pop();
} }
lp_assert(is_correct()); SASSERT(is_correct());
} }
void multiply_row(unsigned row, T const & alpha) { void multiply_row(unsigned row, T const & alpha) {
@ -279,7 +279,7 @@ public:
} }
T dot_product_with_column(const std_vector<T> & y, unsigned j) const { T dot_product_with_column(const std_vector<T> & y, unsigned j) const {
lp_assert(j < column_count()); SASSERT(j < column_count());
T ret = numeric_traits<T>::zero(); T ret = numeric_traits<T>::zero();
for (auto & it : m_columns[j]) { for (auto & it : m_columns[j]) {
ret += y[it.var()] * get_val(it); // get_value_of_column_cell(it); ret += y[it.var()] * get_val(it); // get_value_of_column_cell(it);
@ -302,12 +302,12 @@ public:
// now fix the columns // now fix the columns
for (auto & rc : m_rows[i]) { for (auto & rc : m_rows[i]) {
column_cell & cc = m_columns[rc.var()][rc.offset()]; column_cell & cc = m_columns[rc.var()][rc.offset()];
lp_assert(cc.var() == ii); SASSERT(cc.var() == ii);
cc.var() = i; cc.var() = i;
} }
for (auto & rc : m_rows[ii]) { for (auto & rc : m_rows[ii]) {
column_cell & cc = m_columns[rc.var()][rc.offset()]; column_cell & cc = m_columns[rc.var()][rc.offset()];
lp_assert(cc.var() == i); SASSERT(cc.var() == i);
cc.var() = ii; cc.var() = ii;
} }
@ -345,7 +345,7 @@ public:
void fill_last_row_with_pivoting(const term& row, void fill_last_row_with_pivoting(const term& row,
unsigned bj, // the index of the basis column unsigned bj, // the index of the basis column
const std_vector<int> & basis_heading) { const std_vector<int> & basis_heading) {
lp_assert(row_count() > 0); SASSERT(row_count() > 0);
m_work_vector.clear(); m_work_vector.clear();
m_work_vector.resize(column_count()); m_work_vector.resize(column_count());
T a; T a;
@ -366,7 +366,7 @@ public:
for (unsigned j : m_work_vector.m_index) { for (unsigned j : m_work_vector.m_index) {
set (last_row, j, m_work_vector.m_data[j]); set (last_row, j, m_work_vector.m_data[j]);
} }
lp_assert(column_count() > 0); SASSERT(column_count() > 0);
set(last_row, column_count() - 1, one_of_type<T>()); set(last_row, column_count() - 1, one_of_type<T>());
} }
@ -382,7 +382,7 @@ public:
template <typename L> template <typename L>
L dot_product_with_row(unsigned row, const std_vector<L> & w) const { L dot_product_with_row(unsigned row, const std_vector<L> & w) const {
L ret = zero_of_type<L>(); L ret = zero_of_type<L>();
lp_assert(row < m_rows.size()); SASSERT(row < m_rows.size());
for (auto & it : m_rows[row]) { for (auto & it : m_rows[row]) {
ret += w[it.var()] * it.coeff(); ret += w[it.var()] * it.coeff();
} }

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

@ -87,7 +87,7 @@ namespace lp {
template <typename T, typename X> void static_matrix<T, X>::add_rows(const mpq& alpha, unsigned i, unsigned k) { template <typename T, typename X> void static_matrix<T, X>::add_rows(const mpq& alpha, unsigned i, unsigned k) {
lp_assert(i < row_count() && k < row_count() && i != k); SASSERT(i < row_count() && k < row_count() && i != k);
auto & rowk = m_rows[k]; auto & rowk = m_rows[k];
scan_row_strip_to_work_vector(rowk); scan_row_strip_to_work_vector(rowk);
unsigned prev_size_k = static_cast<unsigned>(rowk.size()); unsigned prev_size_k = static_cast<unsigned>(rowk.size());

4
src/math/lp/test_bound_analyzer.h
View file

@ -89,7 +89,7 @@ public :
void analyze_i_for_upper(unsigned i) { void analyze_i_for_upper(unsigned i) {
mpq l; mpq l;
bool strict = false; bool strict = false;
lp_assert(is_zero(l)); SASSERT(is_zero(l));
for (unsigned k = 0; k < m_index.size(); k++) { for (unsigned k = 0; k < m_index.size(); k++) {
if (k == i) if (k == i)
continue; continue;
@ -179,7 +179,7 @@ public :
void analyze_i_for_lower(unsigned i) { void analyze_i_for_lower(unsigned i) {
mpq l; mpq l;
lp_assert(is_zero(l)); SASSERT(is_zero(l));
bool strict = false; bool strict = false;
for (unsigned k = 0; k < m_index.size(); k++) { for (unsigned k = 0; k < m_index.size(); k++) {
if (k == i) if (k == i)

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

@ -91,7 +91,7 @@ public:
unsigned external_to_local(unsigned j) const { unsigned external_to_local(unsigned j) const {
auto it = m_external_to_local.find(j); auto it = m_external_to_local.find(j);
lp_assert(it != m_external_to_local.end()); SASSERT(it != m_external_to_local.end());
return it->second; return it->second;
} }

20
src/test/lp/gomory_test.h
View file

@ -72,7 +72,7 @@ struct gomory_test {
expl.add_pair(column_lower_bound_constraint(x_j), new_a); expl.add_pair(column_lower_bound_constraint(x_j), new_a);
} }
else { else {
lp_assert(at_upper(x_j)); SASSERT(at_upper(x_j));
if (a.is_pos()) { if (a.is_pos()) {
new_a = a / f_0; new_a = a / f_0;
new_a.neg(); // the upper terms are inverted. new_a.neg(); // the upper terms are inverted.
@ -88,9 +88,9 @@ struct gomory_test {
} }
void int_case_in_gomory_cut(const mpq & a, unsigned x_j, mpq & k, lar_term & t, explanation& expl, mpq & lcm_den, const mpq& f_0, const mpq& one_minus_f_0) { void int_case_in_gomory_cut(const mpq & a, unsigned x_j, mpq & k, lar_term & t, explanation& expl, mpq & lcm_den, const mpq& f_0, const mpq& one_minus_f_0) {
lp_assert(is_integer(x_j)); SASSERT(is_integer(x_j));
lp_assert(!a.is_int()); SASSERT(!a.is_int());
lp_assert(f_0 > zero_of_type<mpq>() && f_0 < one_of_type<mpq>()); SASSERT(f_0 > zero_of_type<mpq>() && f_0 < one_of_type<mpq>());
mpq f_j = fractional_part(a); mpq f_j = fractional_part(a);
TRACE("gomory_cut_detail", TRACE("gomory_cut_detail",
tout << a << " x_j = " << x_j << ", k = " << k << "\n"; tout << a << " x_j = " << x_j << ", k = " << k << "\n";
@ -99,7 +99,7 @@ struct gomory_test {
tout << "1 - f_0: " << one_minus_f_0 << "\n"; tout << "1 - f_0: " << one_minus_f_0 << "\n";
tout << "at_low(" << x_j << ") = " << at_low(x_j) << std::endl; tout << "at_low(" << x_j << ") = " << at_low(x_j) << std::endl;
); );
lp_assert (!f_j.is_zero()); SASSERT (!f_j.is_zero());
mpq new_a; mpq new_a;
if (at_low(x_j)) { if (at_low(x_j)) {
if (f_j <= one_minus_f_0) { if (f_j <= one_minus_f_0) {
@ -112,7 +112,7 @@ struct gomory_test {
expl.add_pair(column_lower_bound_constraint(x_j), new_a); expl.add_pair(column_lower_bound_constraint(x_j), new_a);
} }
else { else {
lp_assert(at_upper(x_j)); SASSERT(at_upper(x_j));
if (f_j <= f_0) { if (f_j <= f_0) {
new_a = f_j / f_0; new_a = f_j / f_0;
} }
@ -134,13 +134,13 @@ struct gomory_test {
} }
void adjust_term_and_k_for_some_ints_case_gomory(lar_term& t, mpq& k, mpq &lcm_den) { void adjust_term_and_k_for_some_ints_case_gomory(lar_term& t, mpq& k, mpq &lcm_den) {
lp_assert(!t.is_empty()); SASSERT(!t.is_empty());
auto pol = t.coeffs_as_vector(); auto pol = t.coeffs_as_vector();
t.clear(); t.clear();
if (pol.size() == 1) { if (pol.size() == 1) {
TRACE("gomory_cut_detail", tout << "pol.size() is 1" << std::endl;); TRACE("gomory_cut_detail", tout << "pol.size() is 1" << std::endl;);
unsigned v = pol[0].second; unsigned v = pol[0].second;
lp_assert(is_integer(v)); SASSERT(is_integer(v));
const mpq& a = pol[0].first; const mpq& a = pol[0].first;
k /= a; k /= a;
if (a.is_pos()) { // we have av >= k if (a.is_pos()) { // we have av >= k
@ -162,7 +162,7 @@ struct gomory_test {
tout << pol[i].first << " " << pol[i].second << "\n"; tout << pol[i].first << " " << pol[i].second << "\n";
} }
tout << "k: " << k << "\n";); tout << "k: " << k << "\n";);
lp_assert(lcm_den.is_pos()); SASSERT(lcm_den.is_pos());
if (!lcm_den.is_one()) { if (!lcm_den.is_one()) {
// normalize coefficients of integer parameters to be integers. // normalize coefficients of integer parameters to be integers.
for (auto & pi: pol) { for (auto & pi: pol) {
@ -183,7 +183,7 @@ struct gomory_test {
k.neg(); k.neg();
} }
TRACE("gomory_cut_detail", tout << "k = " << k << std::endl;); TRACE("gomory_cut_detail", tout << "k = " << k << std::endl;);
lp_assert(k.is_int()); SASSERT(k.is_int());
} }
void print_term(lar_term & t, std::ostream & out) { void print_term(lar_term & t, std::ostream & out) {

95
src/test/lp/lp.cpp
View file

@ -384,7 +384,7 @@ vector<int> allocate_basis_heading(
void init_basic_part_of_basis_heading(vector<unsigned> &basis, void init_basic_part_of_basis_heading(vector<unsigned> &basis,
vector<int> &basis_heading) { vector<int> &basis_heading) {
lp_assert(basis_heading.size() >= basis.size()); SASSERT(basis_heading.size() >= basis.size());
unsigned m = basis.size(); unsigned m = basis.size();
for (unsigned i = 0; i < m; i++) { for (unsigned i = 0; i < m; i++) {
unsigned column = basis[i]; unsigned column = basis[i];
@ -577,7 +577,7 @@ void test_stacked_unsigned() {
v = 3; v = 3;
v = 4; v = 4;
v.pop(); v.pop();
lp_assert(v == 2); SASSERT(v == 2);
v++; v++;
v++; v++;
std::cout << "before push v=" << v << std::endl; std::cout << "before push v=" << v << std::endl;
@ -587,7 +587,7 @@ void test_stacked_unsigned() {
v += 1; v += 1;
std::cout << "v = " << v << std::endl; std::cout << "v = " << v << std::endl;
v.pop(2); v.pop(2);
lp_assert(v == 4); SASSERT(v == 4);
const unsigned &rr = v; const unsigned &rr = v;
std::cout << rr << std::endl; std::cout << rr << std::endl;
} }
@ -751,22 +751,23 @@ void test_numeric_pair() {
numeric_pair<lp::mpq> c(0.1, 0.5); numeric_pair<lp::mpq> c(0.1, 0.5);
a += 2 * c; a += 2 * c;
a -= c; a -= c;
lp_assert(a == b + c); SASSERT(a == b + c);
numeric_pair<lp::mpq> d = a * 2; numeric_pair<lp::mpq> d = a * 2;
std::cout << a << std::endl; std::cout << a << std::endl;
lp_assert(b == b); SASSERT(b == b);
lp_assert(b < a); SASSERT(b < a);
lp_assert(b <= a); SASSERT(b <= a);
lp_assert(a > b); SASSERT(a > b);
lp_assert(a != b); SASSERT(a != b);
lp_assert(a >= b); SASSERT(a >= b);
lp_assert(-a < b); SASSERT(-a < b);
lp_assert(a < 2 * b); SASSERT(a < 2 * b);
lp_assert(b + b > a); SASSERT(b + b > a);
lp_assert(lp::mpq(2.1) * b + b > a); SASSERT(lp::mpq(2.1) * b + b > a);
lp_assert(-b * lp::mpq(2.1) - b < lp::mpq(0.99) * a); SASSERT(-b * lp::mpq(2.1) - b < lp::mpq(0.99) * a);
std::cout << -b * lp::mpq(2.1) - b << std::endl; std::cout << -b * lp::mpq(2.1) - b << std::endl;
lp_assert(-b * (lp::mpq(2.1) + 1) == -b * lp::mpq(2.1) - b); SASSERT(-b * (lp::mpq(2.1) + 1) == -b * lp::mpq(2.1) - b);
std::cout << -b * (lp::mpq(2.1) + 1) << std::endl;
} }
void get_matrix_dimensions(std::ifstream &f, unsigned &m, unsigned &n) { void get_matrix_dimensions(std::ifstream &f, unsigned &m, unsigned &n) {
@ -829,7 +830,7 @@ void test_term() {
<< t.second.get_double() << ","; << t.second.get_double() << ",";
} }
std::cout << "\ntableu after cube\n"; std::cout << "\ntableau after cube\n";
solver.pp(std::cout).print(); solver.pp(std::cout).print();
std::cout << "Ax_is_correct = " << solver.ax_is_correct() << "\n"; std::cout << "Ax_is_correct = " << solver.ax_is_correct() << "\n";
} }
@ -854,7 +855,7 @@ void test_evidence_for_total_inf_simple(argument_parser &args_parser) {
auto status = solver.solve(); auto status = solver.solve();
std::cout << lp_status_to_string(status) << std::endl; std::cout << lp_status_to_string(status) << std::endl;
std::unordered_map<lpvar, mpq> model; std::unordered_map<lpvar, mpq> model;
lp_assert(solver.get_status() == lp_status::INFEASIBLE); SASSERT(solver.get_status() == lp_status::INFEASIBLE);
} }
void test_bound_propagation_one_small_sample1() { void test_bound_propagation_one_small_sample1() {
/* /*
@ -1060,8 +1061,8 @@ void test_total_case_l() {
// ls.solve(); // ls.solve();
// my_bound_propagator bp(ls); // my_bound_propagator bp(ls);
// ls.propagate_bounds_for_touched_rows(bp); // ls.propagate_bounds_for_touched_rows(bp);
// lp_assert(ev.size() == 4); // SASSERT(ev.size() == 4);
// lp_assert(contains_j_kind(x, GE, - one_of_type<mpq>(), ev)); // SASSERT(contains_j_kind(x, GE, - one_of_type<mpq>(), ev));
} }
void test_bound_propagation() { void test_bound_propagation() {
test_total_case_u(); test_total_case_u();
@ -1077,14 +1078,14 @@ void test_int_set() {
indexed_uint_set s; indexed_uint_set s;
s.insert(1); s.insert(1);
s.insert(2); s.insert(2);
lp_assert(s.contains(2)); SASSERT(s.contains(2));
lp_assert(s.size() == 2); SASSERT(s.size() == 2);
s.remove(2); s.remove(2);
lp_assert(s.size() == 1); SASSERT(s.size() == 1);
s.insert(3); s.insert(3);
s.insert(2); s.insert(2);
s.reset(); s.reset();
lp_assert(s.size() == 0); SASSERT(s.size() == 0);
std::cout << "done test_int_set\n"; std::cout << "done test_int_set\n";
} }
@ -1192,13 +1193,13 @@ void get_random_interval(bool &neg_inf, bool &pos_inf, int &x, int &y) {
pos_inf = false; pos_inf = false;
if (!neg_inf) { if (!neg_inf) {
y = x + my_random() % (101 - x); y = x + my_random() % (101 - x);
lp_assert(y >= x); SASSERT(y >= x);
} else { } else {
y = my_random() % 100; y = my_random() % 100;
} }
} }
lp_assert((neg_inf || (0 <= x && x <= 100)) && SASSERT((neg_inf || (0 <= x && x <= 100)) &&
(pos_inf || (0 <= y && y <= 100))); (pos_inf || (0 <= y && y <= 100)));
} }
void test_gomory_cut_0() { void test_gomory_cut_0() {
@ -1628,7 +1629,7 @@ void test_maximize_term() {
solver.add_var_bound(term_x_min_y, LE, zero_of_type<mpq>()); solver.add_var_bound(term_x_min_y, LE, zero_of_type<mpq>());
solver.add_var_bound(term_2x_pl_2y, LE, mpq(5)); solver.add_var_bound(term_2x_pl_2y, LE, mpq(5));
solver.find_feasible_solution(); solver.find_feasible_solution();
lp_assert(solver.get_status() == lp_status::OPTIMAL); SASSERT(solver.get_status() == lp_status::OPTIMAL);
std::cout << solver.constraints(); std::cout << solver.constraints();
std::unordered_map<lpvar, mpq> model; std::unordered_map<lpvar, mpq> model;
solver.get_model(model); solver.get_model(model);
@ -1671,7 +1672,8 @@ void test_dio() {
lpvar fx_7 = solver.add_var(_fx_7, true); lpvar fx_7 = solver.add_var(_fx_7, true);
lpvar fx_17 = solver.add_var(_fx_17, true); lpvar fx_17 = solver.add_var(_fx_17, true);
vector<std::pair<mpq, lpvar>> term_ls; vector<std::pair<mpq, lpvar>> term_ls;
/* 3x1 + 3x2 + 14x3 − 7 */ /* 3x1 + 3x2 +```cpp
14x3 − 7 */
term_ls.push_back(std::pair<mpq, lpvar>(mpq(3), x1)); term_ls.push_back(std::pair<mpq, lpvar>(mpq(3), x1));
term_ls.push_back(std::pair<mpq, lpvar>(mpq(3), x2)); term_ls.push_back(std::pair<mpq, lpvar>(mpq(3), x2));
term_ls.push_back(std::pair<mpq, lpvar>(mpq(14), x3)); term_ls.push_back(std::pair<mpq, lpvar>(mpq(14), x3));
@ -1701,7 +1703,7 @@ void test_dio() {
solver.add_var_bound(t1, LE, mpq(0)); solver.add_var_bound(t1, LE, mpq(0));
solver.add_var_bound(t1, GE, mpq(0)); solver.add_var_bound(t1, GE, mpq(0));
// solver.find_feasible_solution(); // solver.find_feasible_solution();
//lp_assert(solver.get_status() == lp_status::OPTIMAL); //SASSERT(solver.get_status() == lp_status::OPTIMAL);
enable_trace("dioph_eq"); enable_trace("dioph_eq");
enable_trace("dioph_eq_fresh"); enable_trace("dioph_eq_fresh");
#ifdef Z3DEBUG #ifdef Z3DEBUG
@ -1908,13 +1910,13 @@ void asserts_on_patching(const rational &x, const rational &alpha) {
auto a2 = denominator(alpha); auto a2 = denominator(alpha);
auto x1 = numerator(x); auto x1 = numerator(x);
auto x2 = denominator(x); auto x2 = denominator(x);
lp_assert(a1.is_pos()); SASSERT(a1.is_pos());
lp_assert(abs(a1) < abs(a2)); SASSERT(abs(a1) < abs(a2));
lp_assert(coprime(a1, a2)); SASSERT(coprime(a1, a2));
lp_assert(x1.is_pos()); SASSERT(x1.is_pos());
lp_assert(x1 < x2); SASSERT(x1 < x2);
lp_assert(coprime(x1, x2)); SASSERT(coprime(x1, x2));
lp_assert((a2 / x2).is_int()); SASSERT((a2 / x2).is_int());
} }
void get_patching_deltas(const rational &x, const rational &alpha, rational &delta_0, rational &delta_1) { void get_patching_deltas(const rational &x, const rational &alpha, rational &delta_0, rational &delta_1) {
std::cout << "get_patching_deltas(" << x << ", " << alpha << ")" << std::endl; std::cout << "get_patching_deltas(" << x << ", " << alpha << ")" << std::endl;
@ -1922,7 +1924,7 @@ void get_patching_deltas(const rational &x, const rational &alpha, rational &del
auto a2 = denominator(alpha); auto a2 = denominator(alpha);
auto x1 = numerator(x); auto x1 = numerator(x);
auto x2 = denominator(x); auto x2 = denominator(x);
lp_assert(divides(x2, a2)); SASSERT(divides(x2, a2));
// delta has to be integral. // delta has to be integral.
// We need to find delta such that x1/x2 + (a1/a2)*delta is integral. // We need to find delta such that x1/x2 + (a1/a2)*delta is integral.
// Then a2*x1/x2 + a1*delta is integral, that means that t = a2/x2 is integral. // Then a2*x1/x2 + a1*delta is integral, that means that t = a2/x2 is integral.
@ -1936,17 +1938,17 @@ void get_patching_deltas(const rational &x, const rational &alpha, rational &del
// We know that a2 and a1 are coprime, and x2 divides a2, so x2 and a1 are coprime. // We know that a2 and a1 are coprime, and x2 divides a2, so x2 and a1 are coprime.
rational u, v; rational u, v;
auto g = gcd(a1, x2, u, v); auto g = gcd(a1, x2, u, v);
lp_assert(g.is_one() && u.is_int() && v.is_int() && g == u * a1 + v * x2); SASSERT(g.is_one() && u.is_int() && v.is_int() && g == u * a1 + v * x2);
std::cout << "u = " << u << ", v = " << v << std::endl; std::cout << "u = " << u << ", v = " << v << std::endl;
std::cout << "x= " << (x1 / x2) << std::endl; std::cout << "x= " << (x1 / x2) << std::endl;
std::cout << "x + (a1 / a2) * (-u * t) * x1 = " << x + (a1 / a2) * (-u * t) * x1 << std::endl; std::cout << "x + (a1 / a2) * (-u * t) * x1 = " << x + (a1 / a2) * (-u * t) * x1 << std::endl;
lp_assert((x + (a1 / a2) * (-u * t) * x1).is_int()); SASSERT((x + (a1 / a2) * (-u * t) * x1).is_int());
// 1 = (u- l*x2 ) * a1 + (v + l*a1)*x2, for every integer l. // 1 = (u- l*x2 ) * a1 + (v + l*a1)*x2, for every integer l.
rational d = u * t * x1; rational d = u * t * x1;
delta_0 = mod(d, a2); delta_0 = mod(d, a2);
lp_assert(delta_0 > 0); SASSERT(delta_0 > 0);
delta_1 = delta_0 - a2; delta_1 = delta_0 - a2;
lp_assert(delta_1 < 0); SASSERT(delta_1 < 0);
std::cout << "delta_0 = " << delta_0 << std::endl; std::cout << "delta_0 = " << delta_0 << std::endl;
std::cout << "delta_1 = " << delta_1 << std::endl; std::cout << "delta_1 = " << delta_1 << std::endl;
} }
@ -1974,10 +1976,10 @@ void test_patching_alpha(const rational &x, const rational &alpha) {
rational delta_0, delta_1; rational delta_0, delta_1;
get_patching_deltas(x, alpha, delta_0, delta_1); get_patching_deltas(x, alpha, delta_0, delta_1);
lp_assert(delta_0 * delta_1 < 0); SASSERT(delta_0 * delta_1 < 0);
lp_assert((x - alpha * delta_0).is_int()); SASSERT((x - alpha * delta_0).is_int());
lp_assert((x - alpha * delta_1).is_int()); SASSERT((x - alpha * delta_1).is_int());
try_find_smaller_delta(x, alpha, delta_0, delta_1); try_find_smaller_delta(x, alpha, delta_0, delta_1);
// std::cout << "delta_minus = " << delta_minus << ", delta_1 = " << delta_1 << "\n"; // std::cout << "delta_minus = " << delta_minus << ", delta_1 = " << delta_1 << "\n";
// std::cout << "x + alpha*delta_minus = " << x + alpha * delta_minus << "\n"; // std::cout << "x + alpha*delta_minus = " << x + alpha * delta_minus << "\n";
@ -1988,7 +1990,7 @@ void find_a1_x1_x2_and_fix_a2(int &x1, int &x2, int &a1, int &a2) {
x2 = (rand() % a2) + (int)(a2 / 3); x2 = (rand() % a2) + (int)(a2 / 3);
auto g = gcd(rational(a2), rational(x2)); auto g = gcd(rational(a2), rational(x2));
a2 *= (x2 / numerator(g).get_int32()); a2 *= (x2 / numerator(g).get_int32());
lp_assert(rational(a2, x2).is_int()); SASSERT(rational(a2, x2).is_int());
do { do {
x1 = rand() % (unsigned)x2 + 1; x1 = rand() % (unsigned)x2 + 1;
} while (!coprime(x1, x2)); } while (!coprime(x1, x2));
@ -1998,6 +2000,7 @@ void find_a1_x1_x2_and_fix_a2(int &x1, int &x2, int &a1, int &a2) {
} while (!coprime(a1, a2)); } while (!coprime(a1, a2));
} }
void test_patching() { void test_patching() {
srand(1); srand(1);
// repeat the test 100 times // repeat the test 100 times

26
src/test/lp/smt_reader.h
View file

@ -117,13 +117,13 @@ namespace lp {
void fill_simple_elem(lisp_elem & lm) { void fill_simple_elem(lisp_elem & lm) {
int separator = first_separator(); int separator = first_separator();
lp_assert(-1 != separator && separator != 0); SASSERT(-1 != separator && separator != 0);
lm.m_head = m_line.substr(0, separator); lm.m_head = m_line.substr(0, separator);
m_line = m_line.substr(separator); m_line = m_line.substr(separator);
} }
void fill_nested_elem(lisp_elem & lm) { void fill_nested_elem(lisp_elem & lm) {
lp_assert(m_line[0] == '('); SASSERT(m_line[0] == '(');
m_line = m_line.substr(1); m_line = m_line.substr(1);
int separator = first_separator(); int separator = first_separator();
lm.m_head = m_line.substr(0, separator); lm.m_head = m_line.substr(0, separator);
@ -190,11 +190,11 @@ namespace lp {
} }
void adjust_right_side(formula_constraint & /* c*/, lisp_elem & /*el*/) { void adjust_right_side(formula_constraint & /* c*/, lisp_elem & /*el*/) {
// lp_assert(el.m_head == "0"); // do nothing for the time being // SASSERT(el.m_head == "0"); // do nothing for the time being
} }
void set_constraint_coeffs(formula_constraint & c, lisp_elem & el) { void set_constraint_coeffs(formula_constraint & c, lisp_elem & el) {
lp_assert(el.m_elems.size() == 2); SASSERT(el.m_elems.size() == 2);
set_constraint_coeffs_on_coeff_element(c, el.m_elems[0]); set_constraint_coeffs_on_coeff_element(c, el.m_elems[0]);
adjust_right_side(c, el.m_elems[1]); adjust_right_side(c, el.m_elems[1]);
} }
@ -210,7 +210,7 @@ namespace lp {
add_mult_elem(c, el.m_elems); add_mult_elem(c, el.m_elems);
} else if (el.m_head == "~") { } else if (el.m_head == "~") {
lisp_elem & minel = el.m_elems[0]; lisp_elem & minel = el.m_elems[0];
lp_assert(minel.is_simple()); SASSERT(minel.is_simple());
c.m_right_side += mpq(str_to_int(minel.m_head)); c.m_right_side += mpq(str_to_int(minel.m_head));
} else { } else {
std::cout << "unexpected input " << el.m_head << std::endl; std::cout << "unexpected input " << el.m_head << std::endl;
@ -220,14 +220,14 @@ namespace lp {
} }
std::string get_name(lisp_elem & name) { std::string get_name(lisp_elem & name) {
lp_assert(name.is_simple()); SASSERT(name.is_simple());
lp_assert(!is_integer(name.m_head)); SASSERT(!is_integer(name.m_head));
return name.m_head; return name.m_head;
} }
void add_mult_elem(formula_constraint & c, std::vector<lisp_elem> & els) { void add_mult_elem(formula_constraint & c, std::vector<lisp_elem> & els) {
lp_assert(els.size() == 2); SASSERT(els.size() == 2);
mpq coeff = get_coeff(els[0]); mpq coeff = get_coeff(els[0]);
std::string col_name = get_name(els[1]); std::string col_name = get_name(els[1]);
c.add_pair(coeff, col_name); c.add_pair(coeff, col_name);
@ -237,16 +237,16 @@ namespace lp {
if (le.is_simple()) { if (le.is_simple()) {
return mpq(str_to_int(le.m_head)); return mpq(str_to_int(le.m_head));
} else { } else {
lp_assert(le.m_head == "~"); SASSERT(le.m_head == "~");
lp_assert(le.size() == 1); SASSERT(le.size() == 1);
lisp_elem & el = le.m_elems[0]; lisp_elem & el = le.m_elems[0];
lp_assert(el.is_simple()); SASSERT(el.is_simple());
return -mpq(str_to_int(el.m_head)); return -mpq(str_to_int(el.m_head));
} }
} }
int str_to_int(std::string & s) { int str_to_int(std::string & s) {
lp_assert(is_integer(s)); SASSERT(is_integer(s));
return atoi(s.c_str()); return atoi(s.c_str());
} }
@ -254,7 +254,7 @@ namespace lp {
if (el.size()) { if (el.size()) {
add_complex_sum_elem(c, el); add_complex_sum_elem(c, el);
} else { } else {
lp_assert(is_integer(el.m_head)); SASSERT(is_integer(el.m_head));
int v = atoi(el.m_head.c_str()); int v = atoi(el.m_head.c_str());
mpq vr(v); mpq vr(v);
c.m_right_side -= vr; c.m_right_side -= vr;