mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-06 17:44:08 +00:00
Code Activity

debug dio

Browse source 
Signed-off-by: Lev Nachmanson <levnach@hotmail.com>
This commit is contained in:
Lev Nachmanson 2025-01-27 15:43:04 -08:00 committed by Lev Nachmanson
parent bb869fd020
commit b027761845
4 changed files with 624 additions and 472 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

222
src/math/lp/dioph_eq.cpp
View file

@ -135,6 +135,18 @@ namespace lp {
m_data[b] = val;
}
unsigned get_second_of_key(unsigned a) const {
return m_bij[a];
}
void erase_by_second_key(unsigned b) {
SASSERT(m_bij.has_val(b));
m_bij.erase_val(b);
auto it = m_data.find(b);
SASSERT(it != m_data.end());
m_data.erase(it);
}
bool has_key(unsigned j) const { return m_bij.has_key(j); }
// Get the data by 'a', look up b in m_bij, then read from m_data
@ -322,25 +334,19 @@ namespace lp {
lar_term m_tmp_l;
bijection m_k2s;
// it seems it is only needed for debug
struct fresh_def{
unsigned m_xt;
lar_term m_term;
fresh_def() {}
fresh_def(unsigned xt, const lar_term& t) :m_xt(xt), m_term(t) {}
};
bij_map<fresh_def> m_fresh_k2xt_terms;
indexed_uint_set m_changed_rows;
indexed_uint_set m_changed_columns;
// m_column_to_terms[j] is the set of all k such lra.get_term(k) depends on j
std::unordered_map<unsigned, std::unordered_set<unsigned>> m_columns_to_terms;
bij_map<lar_term> m_fresh_k2xt_terms;
// m_row2fresh_defs[i] is the set of all k
// such that pairs (k, m_fresh_k2xt_terms[k]) is a fresh definition introduced for row i.
// When row i is changed all entries depending on m_fresh_k2xt_terms[k].m_xt should be recalculated,
// and the corresponding fresh definitions disregarded. These definitions should not be persisted in Release mode.
std::unordered_map<unsigned, std_vector<unsigned>> m_row2fresh_defs;
indexed_uint_set m_changed_rows;
indexed_uint_set m_changed_columns;
// m_column_to_terms[j] is the set of all k such lra.get_term(k) depends on j
std::unordered_map<unsigned, std::unordered_set<unsigned>> m_columns_to_terms;
unsigned m_conflict_index = -1; // m_entries[m_conflict_index] gives the conflict
unsigned m_max_number_of_iterations = 100;
unsigned m_number_of_iterations;
@ -647,6 +653,7 @@ namespace lp {
}
void subs_entry(unsigned ei) {
if (ei >= m_entries.size()) return;
// q is the queue of variables that can be substituted in ei
std::queue<unsigned> q;
for (const auto& p: m_e_matrix.m_rows[ei]) {
if (can_substitute(p.var()))
@ -657,6 +664,34 @@ namespace lp {
SASSERT(entry_invariant(ei));
}
void substitute_on_q_with_entry_in_S(std::queue<unsigned> & q, unsigned ei, unsigned j, const mpq & alpha, std::unordered_set<unsigned> & in_queue) {
unsigned ei_to_sub = m_k2s[j];
int sign_j = get_sign_in_e_row(ei_to_sub, j);
// we need to eliminate alpha*j in ei's row
add_two_entries(-mpq(sign_j)*alpha, ei_to_sub, ei);
for (const auto& p: m_e_matrix.m_rows[ei]) {
unsigned jj = p.var();
if (can_substitute(jj) && !contains(in_queue, jj)) {
q.push(jj);
in_queue.insert(jj);
}
}
}
void substitute_with_fresh_def(std::queue<unsigned> & q, unsigned ei, unsigned j, const mpq & alpha, std::unordered_set<unsigned> & in_queue) {
const lar_term& sub_term = m_fresh_k2xt_terms.get_by_key(j);
SASSERT(sub_term.get_coeff(j).is_one());
// we need to eliminate alpha*j in ei's row
add_term_to_entry(- alpha, sub_term, ei);
for (const auto& p: m_e_matrix.m_rows[ei]) {
unsigned jj = p.var();
if (can_substitute(jj) && !contains(in_queue, jj)) {
q.push(jj);
in_queue.insert(jj);
}
}
}
// q is the queue of variables that can be substituted in ei
void substitute_on_q(std::queue<unsigned> & q, unsigned ei) {
// Track queued items
std::unordered_set<unsigned> in_queue;
@ -673,19 +708,25 @@ namespace lp {
in_queue.erase(j);
mpq alpha = get_coeff_in_e_row(ei, j);
if (alpha.is_zero()) continue;
unsigned ei_to_sub = m_k2s[j];
int sign_j = get_sign_in_e_row(ei_to_sub, j);
// we need to eliminate alpha*j in ei's row
add_two_entries(-mpq(sign_j)*alpha, ei_to_sub, ei);
for (const auto& p: m_e_matrix.m_rows[ei]) {
unsigned jj = p.var();
if (can_substitute(jj) && !contains(in_queue, jj)) {
q.push(jj);
in_queue.insert(jj);
}
if (m_k2s.has_key(j)) {
substitute_on_q_with_entry_in_S(q, ei, j, alpha, in_queue);
} else {
substitute_with_fresh_def(q, ei, j, alpha,in_queue);
}
}
}
bool term_is_in_range(const lar_term& t) const {
for (const auto & p: t) {
if (p.var() >= m_e_matrix.column_count())
return false;
}
return true;
}
// adds the term multiplied by coeff to m_e_matrix row i
void add_term_to_entry(const mpq& coeff, const lar_term& t, unsigned i ) {
SASSERT(term_is_in_range(t));
m_e_matrix.add_term_to_row(coeff, t, i);
}
// adds entry i0 multiplied by coeff to entry i1
void add_two_entries(const mpq& coeff, unsigned i0, unsigned i1 ) {
@ -741,15 +782,7 @@ namespace lp {
SASSERT(entry_invariant(ei));
}
void process_changed_columns() {
for (unsigned j : m_changed_columns) {
if (j >= this->lra.column_count()) {
delete_column(j);
}
}
std::unordered_set<unsigned> changed_terms; // a term is signified by the term column, like j in lra.get_term(j)
std_vector<unsigned> fresh_entries_to_remove;
void find_changed_terms_and_more_changed_rows(std::unordered_set<unsigned> & changed_terms) {
for (unsigned j : m_changed_columns) {
const auto it = m_columns_to_terms.find(j);
if (it != m_columns_to_terms.end())
@ -759,9 +792,30 @@ namespace lp {
if (!m_var_register.external_is_used(j))
continue;
for (const auto& p : m_e_matrix.column(this->lar_solver_to_local(j))) {
m_changed_rows.insert(p.var());
m_changed_rows.insert(p.var()); // TODO: is it necessary?
}
}
}
void remove_irrelevant_fresh_defs() {
for (unsigned ei : m_changed_rows) {
auto it = m_row2fresh_defs.find(ei);
if (it == m_row2fresh_defs.end()) continue;
for (unsigned xt: it->second) {
m_fresh_k2xt_terms.erase_by_second_key(xt);
}
m_row2fresh_defs.erase(it);
}
}
void process_changed_columns() {
for (unsigned j : m_changed_columns) {
if (j >= this->lra.column_count()) {
delete_column(j);
}
}
std::unordered_set<unsigned> changed_terms; // a term is signified by the term column, like j in lra.get_term(j)
find_changed_terms_and_more_changed_rows(changed_terms);
for (unsigned j : changed_terms) {
for (const auto & cs: m_l_matrix.column(j)) {
m_changed_rows.insert(cs.var());
@ -773,8 +827,7 @@ namespace lp {
for (unsigned ei : m_changed_rows) {
auto it = m_row2fresh_defs.find(ei);
if (it == m_row2fresh_defs.end()) continue;
for (unsigned k : it->second) {
unsigned xt = m_fresh_k2xt_terms.get_by_key(k).m_xt;
for (unsigned xt : it->second) {
SASSERT(var_is_fresh(xt));
for (const auto &p :m_e_matrix.m_columns[xt]) {
more_changed_rows.push_back(p.var());
@ -786,6 +839,9 @@ namespace lp {
m_changed_rows.insert(ei);
}
remove_irrelevant_fresh_defs();
for(unsigned ei : m_changed_rows) {
if (ei >= m_e_matrix.row_count())
continue;;
@ -1009,16 +1065,37 @@ namespace lp {
t.c() = -c.rhs();
}
// We look at term e.m_e: it is in form (+-)x_k + sum {a_i*x_i} + c = 0.
// We substitute x_k in t by (+-)coeff*(sum {a_i*x_i} + c), where coeff is
// the coefficient of x_k in t.
void subs_front_in_indexed_vector(std::queue<unsigned>& q) {
unsigned k = pop_front(q);
if (m_indexed_work_vector[k].is_zero())
return;
void subs_front_in_indexed_vector_by_fresh(unsigned k, std::queue<unsigned> &q) {
const lar_term& e = m_fresh_k2xt_terms.get_by_key(k);
TRACE("dioph_eq", tout << "k:" << k << ", in ";
print_term_o(create_term_from_ind_c(), tout) << std::endl;
tout << "subs with e:";
print_lar_term_L(e, tout) << std::endl;);
mpq coeff = - m_indexed_work_vector[k]; // need to copy since it will be zeroed
m_indexed_work_vector.erase(k); // m_indexed_work_vector[k] = 0;
SASSERT(e.get_coeff(k).is_one());
for (const auto& p : e) {
unsigned j = p.var();
if (j == k)
continue;
m_indexed_work_vector.add_value_at_index(j, p.coeff()*coeff);
// do we need to add j to the queue?
if (!var_is_fresh(j) && !m_indexed_work_vector[j].is_zero() &&
can_substitute(j))
q.push(j);
}
// there is no change in m_l_matrix
TRACE("dioph_eq", tout << "after subs k:" << k << "\n";
print_term_o(create_term_from_ind_c(), tout) << std::endl;
tout << "m_tmp_l:{"; print_lar_term_L(m_tmp_l, tout);
tout << "}, opened:"; print_ml(m_tmp_l, tout) << std::endl;);
}
void subs_front_in_indexed_vector_by_S(unsigned k, std::queue<unsigned> &q) {
const entry& e = entry_for_subs(k);
SASSERT(can_substitute(k));
TRACE("dioph_eq", tout << "k:" << k << ", in ";
print_term_o(create_term_from_ind_c(), tout) << std::endl;
tout << "subs with e:";
@ -1056,6 +1133,26 @@ namespace lp {
tout << "}, opened:"; print_ml(m_tmp_l, tout) << std::endl;);
}
bool is_substituted_by_fresh(unsigned k) const {
return m_fresh_k2xt_terms.has_key(k);
}
// The term giving the substitution is in form (+-)x_k + sum {a_i*x_i} + c = 0.
// We substitute x_k in t by (+-)coeff*(sum {a_i*x_i} + c), where coeff is
// the coefficient of x_k in t.
void subs_front_in_indexed_vector(std::queue<unsigned>& q) {
unsigned k = pop_front(q);
if (m_indexed_work_vector[k].is_zero())
return;
// we might substitute with a term from S or a fresh term
SASSERT(can_substitute(k));
if (is_substituted_by_fresh(k)) {
subs_front_in_indexed_vector_by_fresh(k, q);
} else {
subs_front_in_indexed_vector_by_S(k, q);
}
}
lar_term l_term_from_row(unsigned k) const {
lar_term ret;
for (const auto & p: m_l_matrix.m_rows[k])
@ -1188,6 +1285,10 @@ namespace lp {
tout << "m_tmp_l:";
print_lar_term_L(m_tmp_l, tout) << std::endl;);
subs_indexed_vector_with_S(q);
// if(
// fix_vars(term_to_tighten + open_ml(m_tmp_l)) !=
// term_to_lar_solver(remove_fresh_vars(create_term_from_ind_c())))
// enable_trace("dioph_eq");
TRACE("dioph_eq", tout << "after subs\n";
print_term_o(create_term_from_ind_c(), tout) << std::endl;
@ -1199,8 +1300,14 @@ namespace lp {
tout << "term_to_tighten + open_ml:";
print_term_o(term_to_tighten + open_ml(m_tmp_l), tout)
<< std::endl;
tout << "ls:"; print_term_o(fix_vars(term_to_tighten + open_ml(m_tmp_l)),tout) << std::endl;
tout << "rs:"; print_term_o(term_to_lar_solver(remove_fresh_vars(create_term_from_ind_c())), tout ) << std::endl;
term_o ls = fix_vars(term_to_tighten + open_ml(m_tmp_l));
tout << "ls:"; print_term_o(ls,tout) << std::endl;
term_o rs = term_to_lar_solver(remove_fresh_vars(create_term_from_ind_c()));
tout << "rs:"; print_term_o(rs, tout ) << std::endl;
term_o diff = ls - rs;
if (!diff.is_empty()) {
tout << "diff:"; print_term_o(diff, tout ) << std::endl;
}
);
SASSERT(
@ -1426,9 +1533,9 @@ namespace lp {
lia_move fix_var(unsigned j) {
SASSERT(is_fixed(local_to_lar_solver(j)));
/*
We only can get a conflict when j is substituted, and the entry m_k2s[j], the entry defining the substitution becomes infeaseable, that is the gcd of the monomial coeffitients does not dive the free coefficient. In other cases the gcd of the monomials will remain to be 1.
We only can get a conflict when j is substituted, and the entry m_k2s[j], the entry defining the substitution becomes infeaseable, that is the gcd of the monomial coeffitients does not divide the free coefficient. In other cases the gcd of the monomials will remain to be 1.
*/
if (can_substitute(j)) {
if (m_k2s.has_key(j)) { // j is substituted but using an entry
TRACE("dio_br",
tout << "fixed j:" << j <<", was substited by "; print_entry(m_k2s[j], tout););
if (check_fixing(j) == lia_move::conflict) {
@ -1921,11 +2028,9 @@ namespace lp {
}
}
while (!q.empty()) {
unsigned k = pop_front(q);
const auto & fd = m_fresh_k2xt_terms.get_by_key(k);
const lar_term& fresh_t = fd.m_term;
unsigned xt = pop_front(q); // xt is a fresh var
const lar_term& fresh_t = m_fresh_k2xt_terms.get_by_val(xt);
TRACE("dioph_eq", print_lar_term_L(fresh_t, tout););
unsigned xt = fd.m_xt;
SASSERT(fresh_t.get_coeff(xt).is_minus_one());
if (!t.contains(xt))
continue;
@ -1985,6 +2090,17 @@ namespace lp {
clear_e_row(ei);
}
// The idea is to remove this fresh definition when the row h changes.
// The row can change if it depends on the term that is deleted, or on a variable that becomes fixed/unfixed
void register_var_in_fresh_defs(unsigned h, unsigned fr_j) {
auto it = m_row2fresh_defs.find(h);
if (it == m_row2fresh_defs.end()) {
m_row2fresh_defs[h].push_back(fr_j);
} else {
it->second.push_back(fr_j);
}
}
// k is the variable to substitute
void fresh_var_step(unsigned h, unsigned k, const mpq& ahk) {
// step 7 from the paper
@ -2012,9 +2128,9 @@ namespace lp {
fresh_t.add_monomial(q, i.var());
}
fresh_def fd(xt, fresh_t);
m_fresh_k2xt_terms.add(k, xt, fd);
m_fresh_k2xt_terms.add(k, xt, fresh_t);
SASSERT(var_is_fresh(xt));
register_var_in_fresh_defs(h, xt);
eliminate_var_in_f_with_term(fresh_t, k, 1);
}

71
src/math/lp/static_matrix.cpp
View file

@ -1,22 +1,22 @@
/*++
Copyright (c) 2017 Microsoft Corporation
Copyright (c) 2017 Microsoft Corporation
Module Name:
Module Name:
<name>
<name>
Abstract:
Abstract:
<abstract>
<abstract>
Author:
Author:
Lev Nachmanson (levnach)
Lev Nachmanson (levnach)
Revision History:
Revision History:
--*/
--*/
#include <memory>
#include "util/vector.h"
#include <set>
@ -27,36 +27,37 @@ Revision History:
#include "math/lp/lar_solver.h"
namespace lp {
template std::set<std::pair<unsigned, unsigned>> lp::static_matrix<lp::mpq, lp::mpq>::get_domain();
template std::set<std::pair<unsigned, unsigned>> lp::static_matrix<lp::mpq, lp::numeric_pair<lp::mpq> >::get_domain();
template void static_matrix<mpq, mpq>::add_column_to_vector(mpq const&, unsigned int, mpq*) const;
template bool static_matrix<mpq, mpq>::is_correct() const;
template std::set<std::pair<unsigned, unsigned>> static_matrix<mpq, mpq>::get_domain();
template std::set<std::pair<unsigned, unsigned>> static_matrix<mpq, numeric_pair<mpq> >::get_domain();
template void static_matrix<mpq, mpq>::add_column_to_vector(mpq const&, unsigned int, mpq*) const;
template bool static_matrix<mpq, mpq>::is_correct() const;
template mpq static_matrix<mpq, mpq>::get_balance() const;
template mpq static_matrix<mpq, mpq>::get_elem(unsigned int, unsigned int) const;
template mpq static_matrix<mpq, mpq>::get_max_abs_in_column(unsigned int) const;
template mpq static_matrix<mpq, mpq>::get_max_abs_in_row(unsigned int) const;
template mpq static_matrix<mpq, mpq>::get_min_abs_in_column(unsigned int) const;
template mpq static_matrix<mpq, mpq>::get_min_abs_in_row(unsigned int) const;
template void static_matrix<mpq, mpq>::init_row_columns(unsigned int, unsigned int);
template static_matrix<mpq, mpq>::ref& static_matrix<mpq, mpq>::ref::operator=(mpq const&);
template void static_matrix<mpq, mpq>::set(unsigned int, unsigned int, mpq const&);
template mpq static_matrix<mpq, mpq>::get_balance() const;
template mpq static_matrix<mpq, mpq>::get_elem(unsigned int, unsigned int) const;
template mpq static_matrix<mpq, mpq>::get_max_abs_in_column(unsigned int) const;
template mpq static_matrix<mpq, mpq>::get_max_abs_in_row(unsigned int) const;
template mpq static_matrix<mpq, mpq>::get_min_abs_in_column(unsigned int) const;
template mpq static_matrix<mpq, mpq>::get_min_abs_in_row(unsigned int) const;
template void static_matrix<mpq, mpq>::init_row_columns(unsigned int, unsigned int);
template static_matrix<mpq, mpq>::ref& static_matrix<mpq, mpq>::ref::operator=(mpq const&);
template void static_matrix<mpq, mpq>::set(unsigned int, unsigned int, mpq const&);
template static_matrix<mpq, mpq>::static_matrix(unsigned int, unsigned int);
template static_matrix<mpq, mpq>::static_matrix(unsigned int, unsigned int);
#ifdef Z3DEBUG
template bool static_matrix<mpq, numeric_pair<mpq> >::is_correct() const;
template bool static_matrix<mpq, numeric_pair<mpq> >::is_correct() const;
#endif
template mpq static_matrix<mpq, numeric_pair<mpq> >::get_elem(unsigned int, unsigned int) const;
template void static_matrix<mpq, numeric_pair<mpq> >::init_empty_matrix(unsigned int, unsigned int);
template void static_matrix<mpq, numeric_pair<mpq> >::set(unsigned int, unsigned int, mpq const&);
template mpq static_matrix<mpq, numeric_pair<mpq> >::get_elem(unsigned int, unsigned int) const;
template void static_matrix<mpq, numeric_pair<mpq> >::init_empty_matrix(unsigned int, unsigned int);
template void static_matrix<mpq, numeric_pair<mpq> >::set(unsigned int, unsigned int, mpq const&);
template bool lp::static_matrix<lp::mpq, lp::mpq>::pivot_row_to_row_given_cell(unsigned int, column_cell& , unsigned int);
template bool lp::static_matrix<lp::mpq, lp::numeric_pair<lp::mpq> >::pivot_row_to_row_given_cell(unsigned int, column_cell&, unsigned int);
template void lp::static_matrix<lp::mpq, lp::numeric_pair<lp::mpq> >::pivot_row_to_row_given_cell_with_sign(unsigned int, column_cell&, unsigned int, int);
template void lp::static_matrix<mpq, mpq>::pivot_row_to_row_given_cell_with_sign(unsigned int, lp::row_cell<lp::empty_struct>&, unsigned int, int);
template void lp::static_matrix<lp::mpq, lp::numeric_pair<lp::mpq> >::add_rows(mpq const&, unsigned int, unsigned int);
template void lp::static_matrix<lp::mpq,lp::mpq>::add_rows(class rational const &,unsigned int,unsigned int);
template void lp::static_matrix<mpq, mpq>:: pivot_term_to_row_given_cell<lar_term>(lar_term const & term, column_cell&c, unsigned j, int j_sign);
template void lp::static_matrix<rational, lp::numeric_pair<rational> >::remove_element(std::vector<lp::row_cell<rational>, std_allocator<lp::row_cell<rational> > >&, lp::row_cell<rational>&);
template bool static_matrix<mpq, mpq>::pivot_row_to_row_given_cell(unsigned int, column_cell& , unsigned int);
template bool static_matrix<mpq, numeric_pair<mpq> >::pivot_row_to_row_given_cell(unsigned int, column_cell&, unsigned int);
template void static_matrix<mpq, numeric_pair<mpq> >::pivot_row_to_row_given_cell_with_sign(unsigned int, column_cell&, unsigned int, int);
template void static_matrix<mpq, mpq>::pivot_row_to_row_given_cell_with_sign(unsigned int, row_cell<empty_struct>&, unsigned int, int);
template void static_matrix<mpq, numeric_pair<mpq> >::add_rows(mpq const&, unsigned int, unsigned int);
template void static_matrix<mpq,mpq>::add_rows(mpq const &,unsigned int,unsigned int);
template void static_matrix<mpq, mpq>:: pivot_term_to_row_given_cell<lar_term>(lar_term const & term, column_cell&c, unsigned j, int j_sign);
template void static_matrix<mpq, mpq>::add_term_to_row<lar_term>(const mpq& alpha, lar_term const & term, unsigned ii);
template void static_matrix<mpq, numeric_pair<mpq> >::remove_element(std::vector<row_cell<mpq>, std_allocator<row_cell<mpq> > >&, row_cell<mpq>&);
}

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

@ -292,7 +292,11 @@ public:
}
template <typename TTerm>
void pivot_term_to_row_given_cell(TTerm const & term, column_cell&c, unsigned j, int j_sign);
// pivot row i to row ii
template <typename TTerm>
void add_term_to_row(const mpq& coeff, TTerm const & term, unsigned i);
// pivot row i to row ii
bool pivot_row_to_row_given_cell(unsigned i, column_cell& c, unsigned j);
void pivot_row_to_row_given_cell_with_sign(unsigned piv_row_index, column_cell& c, unsigned j, int j_sign);
void transpose_rows(unsigned i, unsigned ii) {

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

@ -1,22 +1,22 @@
/*++
Copyright (c) 2017 Microsoft Corporation
Copyright (c) 2017 Microsoft Corporation
Module Name:
Module Name:
<name>
<name>
Abstract:
Abstract:
<abstract>
<abstract>
Author:
Author:
Lev Nachmanson (levnach)
Lev Nachmanson (levnach)
Revision History:
Revision History:
--*/
--*/
#pragma once
#include "util/vector.h"
@ -27,430 +27,461 @@ Revision History:
namespace lp {
// each assignment for this matrix should be issued only once!!!
inline void addmul(double& r, double a, double b) { r += a*b; }
inline void addmul(mpq& r, mpq const& a, mpq const& b) { r.addmul(a, b); }
inline void addmul(double& r, double a, double b) { r += a*b; }
inline void addmul(mpq& r, mpq const& a, mpq const& b) { r.addmul(a, b); }
template <typename T, typename X>
void static_matrix<T, X>::init_row_columns(unsigned m, unsigned n) {
SASSERT(m_rows.size() == 0 && m_columns.size() == 0);
for (unsigned i = 0; i < m; i++) {
m_rows.push_back(row_strip<T>());
}
for (unsigned j = 0; j < n; j++) {
m_columns.push_back(column_strip());
}
}
template <typename T, typename X> void static_matrix<T, X>:: scan_row_strip_to_work_vector(const row_strip<T> & rvals) {
for (unsigned j = 0; j < rvals.size(); j++)
m_work_vector_of_row_offsets[rvals[j].var()] = j;
}
template <typename T, typename X> bool static_matrix<T, X>::pivot_row_to_row_given_cell(unsigned i,
column_cell & c, unsigned pivot_col) {
unsigned ii = c.var();
SASSERT(i < row_count() && ii < column_count() && i != ii);
T alpha = -get_val(c);
SASSERT(!is_zero(alpha));
auto & rowii = m_rows[ii];
remove_element(rowii, rowii[c.offset()]);
scan_row_strip_to_work_vector(rowii);
unsigned prev_size_ii = rowii.size();
// run over the pivot row and update row ii
for (const auto & iv : m_rows[i]) {
unsigned j = iv.var();
if (j == pivot_col) continue;
SASSERT(!is_zero(iv.coeff()));
int j_offs = m_work_vector_of_row_offsets[j];
if (j_offs == -1) { // it is a new element
T alv = alpha * iv.coeff();
add_new_element(ii, j, alv);
template <typename T, typename X>
void static_matrix<T, X>::init_row_columns(unsigned m, unsigned n) {
SASSERT(m_rows.size() == 0 && m_columns.size() == 0);
for (unsigned i = 0; i < m; i++) {
m_rows.push_back(row_strip<T>());
}
else {
addmul(rowii[j_offs].coeff(), iv.coeff(), alpha);
for (unsigned j = 0; j < n; j++) {
m_columns.push_back(column_strip());
}
}
// clean the work vector
for (unsigned k = 0; k < prev_size_ii; k++) {
m_work_vector_of_row_offsets[rowii[k].var()] = -1;
template <typename T, typename X> void static_matrix<T, X>:: scan_row_strip_to_work_vector(const row_strip<T> & rvals) {
for (unsigned j = 0; j < rvals.size(); j++)
m_work_vector_of_row_offsets[rvals[j].var()] = j;
}
// remove zeroes
for (unsigned k = rowii.size(); k-- > 0; ) {
if (is_zero(rowii[k].coeff()))
remove_element(rowii, rowii[k]);
template <typename T, typename X> bool static_matrix<T, X>::pivot_row_to_row_given_cell(unsigned i,
column_cell & c, unsigned pivot_col) {
unsigned ii = c.var();
SASSERT(i < row_count() && ii < column_count() && i != ii);
T alpha = -get_val(c);
SASSERT(!is_zero(alpha));
auto & rowii = m_rows[ii];
remove_element(rowii, rowii[c.offset()]);
scan_row_strip_to_work_vector(rowii);
unsigned prev_size_ii = rowii.size();
// run over the pivot row and update row ii
for (const auto & iv : m_rows[i]) {
unsigned j = iv.var();
if (j == pivot_col) continue;
SASSERT(!is_zero(iv.coeff()));
int j_offs = m_work_vector_of_row_offsets[j];
if (j_offs == -1) { // it is a new element
T alv = alpha * iv.coeff();
add_new_element(ii, j, alv);
}
else {
addmul(rowii[j_offs].coeff(), iv.coeff(), alpha);
}
}
// clean the work vector
for (unsigned k = 0; k < prev_size_ii; k++) {
m_work_vector_of_row_offsets[rowii[k].var()] = -1;
}
// remove zeroes
for (unsigned k = rowii.size(); k-- > 0; ) {
if (is_zero(rowii[k].coeff()))
remove_element(rowii, rowii[k]);
}
return !rowii.empty();
}
return !rowii.empty();
}
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 < column_count() && i != k);
auto & rowk = m_rows[k];
scan_row_strip_to_work_vector(rowk);
unsigned prev_size_k = rowk.size();
// run over the pivot row and update row k
for (const auto & iv : m_rows[i]) {
unsigned j = iv.var();
int j_offs = m_work_vector_of_row_offsets[j];
if (j_offs == -1) { // it is a new element
T alv = alpha * iv.coeff();
add_new_element(k, j, alv);
lp_assert(i < row_count() && k < column_count() && i != k);
auto & rowk = m_rows[k];
scan_row_strip_to_work_vector(rowk);
unsigned prev_size_k = rowk.size();
// run over the pivot row and update row k
for (const auto & iv : m_rows[i]) {
unsigned j = iv.var();
int j_offs = m_work_vector_of_row_offsets[j];
if (j_offs == -1) { // it is a new element
T alv = alpha * iv.coeff();
add_new_element(k, j, alv);
}
else {
addmul(rowk[j_offs].coeff(), iv.coeff(), alpha);
}
}
else {
addmul(rowk[j_offs].coeff(), iv.coeff(), alpha);
// clean the work vector
for (unsigned k = 0; k < prev_size_k; k++) {
m_work_vector_of_row_offsets[rowk[k].var()] = -1;
}
// remove zeroes
for (unsigned k = rowk.size(); k-- > 0; ) {
if (is_zero(rowk[k].coeff()))
remove_element(rowk, rowk[k]);
}
}
// clean the work vector
for (unsigned k = 0; k < prev_size_k; k++) {
m_work_vector_of_row_offsets[rowk[k].var()] = -1;
}
// remove zeroes
for (unsigned k = rowk.size(); k-- > 0; ) {
if (is_zero(rowk[k].coeff()))
remove_element(rowk, rowk[k]);
}
}
template <typename T, typename X>
inline void static_matrix<T, X>::pivot_row_to_row_given_cell_with_sign(unsigned piv_row_index,
column_cell& c, unsigned pivot_col, int pivot_sign) {
unsigned ii = c.var();
SASSERT(ii != piv_row_index);
T alpha = - get_val(c) * pivot_sign;
SASSERT(!is_zero(alpha));
auto & rowii = m_rows[ii];
remove_element(rowii, rowii[c.offset()]);
scan_row_strip_to_work_vector(rowii);
unsigned prev_size_ii = rowii.size();
// run over the pivot row and update row ii
for (const auto & iv : m_rows[piv_row_index]) {
unsigned j = iv.var();
if (j == pivot_col) continue;
SASSERT(!is_zero(iv.coeff()));
int j_offs = m_work_vector_of_row_offsets[j];
if (j_offs == -1) { // it is a new element
T alv = alpha * iv.coeff();
add_new_element(ii, j, alv);
template <typename T, typename X>
inline void static_matrix<T, X>::pivot_row_to_row_given_cell_with_sign(unsigned piv_row_index,
column_cell& c, unsigned pivot_col, int pivot_sign) {
unsigned ii = c.var();
SASSERT(ii != piv_row_index);
T alpha = - get_val(c) * pivot_sign;
SASSERT(!is_zero(alpha));
auto & rowii = m_rows[ii];
remove_element(rowii, rowii[c.offset()]);
scan_row_strip_to_work_vector(rowii);
unsigned prev_size_ii = rowii.size();
// run over the pivot row and update row ii
for (const auto & iv : m_rows[piv_row_index]) {
unsigned j = iv.var();
if (j == pivot_col) continue;
SASSERT(!is_zero(iv.coeff()));
int j_offs = m_work_vector_of_row_offsets[j];
if (j_offs == -1) { // it is a new element
T alv = alpha * iv.coeff();
add_new_element(ii, j, alv);
}
else {
addmul(rowii[j_offs].coeff(), iv.coeff(), alpha);
}
}
else {
addmul(rowii[j_offs].coeff(), iv.coeff(), alpha);
// clean the work vector
for (unsigned k = 0; k < prev_size_ii; k++) {
m_work_vector_of_row_offsets[rowii[k].var()] = -1;
}
// remove zeroes
for (unsigned k = rowii.size(); k-- > 0; ) {
if (is_zero(rowii[k].coeff()))
remove_element(rowii, rowii[k]);
}
}
// clean the work vector
for (unsigned k = 0; k < prev_size_ii; k++) {
m_work_vector_of_row_offsets[rowii[k].var()] = -1;
}
// remove zeroes
for (unsigned k = rowii.size(); k-- > 0; ) {
if (is_zero(rowii[k].coeff()))
remove_element(rowii, rowii[k]);
}
}
template<typename T, typename X>
template<typename TTerm>
void static_matrix<T, X>::pivot_term_to_row_given_cell(TTerm const & term, column_cell&c, unsigned pivot_col, int j_sign) {
unsigned ii = c.var();
T alpha = - get_val(c) * j_sign;
SASSERT(!is_zero(alpha));
auto & rowii = m_rows[ii];
remove_element(rowii, rowii[c.offset()]);
scan_row_strip_to_work_vector(rowii);
unsigned prev_size_ii = rowii.size();
// run over the pivot row and update row ii
for (const auto & iv : term) {
unsigned j = iv.var();
if (j == pivot_col) continue;
SASSERT(!is_zero(iv.coeff()));
int j_offs = m_work_vector_of_row_offsets[j];
if (j_offs == -1) { // it is a new element
T alv = alpha * iv.coeff();
add_new_element(ii, j, alv);
template<typename T, typename X>
template<typename TTerm>
void static_matrix<T, X>::add_term_to_row(const mpq& alpha, TTerm const & term, unsigned ii) {
auto & rowii = m_rows[ii];
scan_row_strip_to_work_vector(rowii);
unsigned prev_size_ii = rowii.size();
// run over the term and update row ii
for (const auto & iv : term) {
unsigned j = iv.var();
SASSERT(!is_zero(iv.coeff()));
int j_offs = m_work_vector_of_row_offsets[j];
if (j_offs == -1) { // it is a new element
T alv = alpha * iv.coeff();
add_new_element(ii, j, alv);
}
else {
addmul(rowii[j_offs].coeff(), iv.coeff(), alpha);
}
}
else {
addmul(rowii[j_offs].coeff(), iv.coeff(), alpha);
// clean the work vector
for (unsigned k = 0; k < prev_size_ii; k++) {
m_work_vector_of_row_offsets[rowii[k].var()] = -1;
}
}
// clean the work vector
for (unsigned k = 0; k < prev_size_ii; k++) {
m_work_vector_of_row_offsets[rowii[k].var()] = -1;
}
// remove zeroes
for (unsigned k = rowii.size(); k-- > 0; ) {
if (is_zero(rowii[k].coeff()))
remove_element(rowii, rowii[k]);
}
}
template <typename T, typename X> void static_matrix<T, X>::clear() {
m_work_vector_of_row_offsets.clear();
m_rows.clear();
m_columns.clear();
}
template <typename T, typename X> void static_matrix<T, X>::init_vector_of_row_offsets() {
m_work_vector_of_row_offsets.clear();
m_work_vector_of_row_offsets.resize(column_count(), -1);
}
template <typename T, typename X> void static_matrix<T, X>::init_empty_matrix(unsigned m, unsigned n) {
init_row_columns(m, n);
init_vector_of_row_offsets();
}
template <typename T, typename X> unsigned static_matrix<T, X>::lowest_row_in_column(unsigned col) {
SASSERT(col < column_count());
column_strip & colstrip = m_columns[col];
SASSERT(colstrip.size() > 0);
unsigned ret = 0;
for (auto & t : colstrip) {
if (t.var() > ret) {
ret = t.var();
// remove zeroes
for (unsigned k = rowii.size(); k-- > 0; ) {
if (is_zero(rowii[k].coeff()))
remove_element(rowii, rowii[k]);
}
}
return ret;
}
template <typename T, typename X> void static_matrix<T, X>::set(unsigned row, unsigned col, T const & val) {
if (numeric_traits<T>::is_zero(val)) return;
SASSERT(row < row_count() && col < column_count());
auto & r = m_rows[row];
unsigned offs_in_cols = m_columns[col].size();
m_columns[col].push_back(make_column_cell(row, r.size()));
r.push_back(make_row_cell(col, offs_in_cols, val));
}
template <typename T, typename X>
std::set<std::pair<unsigned, unsigned>> static_matrix<T, X>::get_domain() {
std::set<std::pair<unsigned, unsigned>> ret;
for (unsigned i = 0; i < m_rows.size(); i++) {
for (auto &cell : m_rows[i]) {
ret.insert(std::make_pair(i, cell.var()));
template<typename T, typename X>
template<typename TTerm>
void static_matrix<T, X>::pivot_term_to_row_given_cell(TTerm const & term, column_cell&c, unsigned pivot_col, int j_sign) {
unsigned ii = c.var();
T alpha = - get_val(c) * j_sign;
SASSERT(!is_zero(alpha));
auto & rowii = m_rows[ii];
remove_element(rowii, rowii[c.offset()]);
scan_row_strip_to_work_vector(rowii);
unsigned prev_size_ii = rowii.size();
// run over the pivot row and update row ii
for (const auto & iv : term) {
unsigned j = iv.var();
if (j == pivot_col) continue;
SASSERT(!is_zero(iv.coeff()));
int j_offs = m_work_vector_of_row_offsets[j];
if (j_offs == -1) { // it is a new element
T alv = alpha * iv.coeff();
add_new_element(ii, j, alv);
}
else {
addmul(rowii[j_offs].coeff(), iv.coeff(), alpha);
}
}
}
return ret;
}
template <typename T, typename X> T static_matrix<T, X>::get_max_abs_in_row(unsigned row) const {
T ret = numeric_traits<T>::zero();
for (auto & t : m_rows[row]) {
T a = abs(t.coeff());
if (a > ret) {
ret = a;
// clean the work vector
for (unsigned k = 0; k < prev_size_ii; k++) {
m_work_vector_of_row_offsets[rowii[k].var()] = -1;
}
}
return ret;
}
template <typename T, typename X> T static_matrix<T, X>::get_min_abs_in_row(unsigned row) const {
bool first_time = true;
T ret = numeric_traits<T>::zero();
for (auto & t : m_rows[row]) {
T a = abs(t.coeff());
if (first_time) {
ret = a;
first_time = false;
} else if (a < ret) {
ret = a;
// remove zeroes
for (unsigned k = rowii.size(); k-- > 0; ) {
if (is_zero(rowii[k].coeff()))
remove_element(rowii, rowii[k]);
}
}
return ret;
}
template <typename T, typename X> T static_matrix<T, X>::get_max_abs_in_column(unsigned column) const {
T ret = numeric_traits<T>::zero();
for (const auto & t : m_columns[column]) {
T a = abs(get_val(t));
if (a > ret) {
ret = a;
template <typename T, typename X> void static_matrix<T, X>::clear() {
m_work_vector_of_row_offsets.clear();
m_rows.clear();
m_columns.clear();
}
template <typename T, typename X> void static_matrix<T, X>::init_vector_of_row_offsets() {
m_work_vector_of_row_offsets.clear();
m_work_vector_of_row_offsets.resize(column_count(), -1);
}
template <typename T, typename X> void static_matrix<T, X>::init_empty_matrix(unsigned m, unsigned n) {
init_row_columns(m, n);
init_vector_of_row_offsets();
}
template <typename T, typename X> unsigned static_matrix<T, X>::lowest_row_in_column(unsigned col) {
SASSERT(col < column_count());
column_strip & colstrip = m_columns[col];
SASSERT(colstrip.size() > 0);
unsigned ret = 0;
for (auto & t : colstrip) {
if (t.var() > ret) {
ret = t.var();
}
}
return ret;
}
return ret;
}
template <typename T, typename X> T static_matrix<T, X>::get_min_abs_in_column(unsigned column) const {
bool first_time = true;
T ret = numeric_traits<T>::zero();
for (auto & t : m_columns[column]) {
T a = abs(get_val(t));
if (first_time) {
first_time = false;
ret = a;
} else if (a < ret) {
ret = a;
}
template <typename T, typename X> void static_matrix<T, X>::set(unsigned row, unsigned col, T const & val) {
if (numeric_traits<T>::is_zero(val)) return;
SASSERT(row < row_count() && col < column_count());
auto & r = m_rows[row];
unsigned offs_in_cols = m_columns[col].size();
m_columns[col].push_back(make_column_cell(row, r.size()));
r.push_back(make_row_cell(col, offs_in_cols, val));
}
template <typename T, typename X>
std::set<std::pair<unsigned, unsigned>> static_matrix<T, X>::get_domain() {
std::set<std::pair<unsigned, unsigned>> ret;
for (unsigned i = 0; i < m_rows.size(); i++) {
for (auto &cell : m_rows[i]) {
ret.insert(std::make_pair(i, cell.var()));
}
}
return ret;
}
template <typename T, typename X> T static_matrix<T, X>::get_max_abs_in_row(unsigned row) const {
T ret = numeric_traits<T>::zero();
for (auto & t : m_rows[row]) {
T a = abs(t.coeff());
if (a > ret) {
ret = a;
}
}
return ret;
}
template <typename T, typename X> T static_matrix<T, X>::get_min_abs_in_row(unsigned row) const {
bool first_time = true;
T ret = numeric_traits<T>::zero();
for (auto & t : m_rows[row]) {
T a = abs(t.coeff());
if (first_time) {
ret = a;
first_time = false;
} else if (a < ret) {
ret = a;
}
}
return ret;
}
template <typename T, typename X> T static_matrix<T, X>::get_max_abs_in_column(unsigned column) const {
T ret = numeric_traits<T>::zero();
for (const auto & t : m_columns[column]) {
T a = abs(get_val(t));
if (a > ret) {
ret = a;
}
}
return ret;
}
template <typename T, typename X> T static_matrix<T, X>::get_min_abs_in_column(unsigned column) const {
bool first_time = true;
T ret = numeric_traits<T>::zero();
for (auto & t : m_columns[column]) {
T a = abs(get_val(t));
if (first_time) {
first_time = false;
ret = a;
} else if (a < ret) {
ret = a;
}
}
return ret;
}
return ret;
}
#ifdef Z3DEBUG
template <typename T, typename X> void static_matrix<T, X>::check_consistency() {
std::unordered_map<std::pair<unsigned, unsigned>, T> by_rows;
for (unsigned i = 0; i < m_rows.size(); i++) {
template <typename T, typename X> void static_matrix<T, X>::check_consistency() {
std::unordered_map<std::pair<unsigned, unsigned>, T> by_rows;
for (unsigned i = 0; i < m_rows.size(); i++) {
for (auto & t : m_rows[i]) {
std::pair<unsigned, unsigned> p(i, t.var());
SASSERT(by_rows.find(p) == by_rows.end());
by_rows[p] = t.coeff();
}
}
std::unordered_map<std::pair<unsigned, unsigned>, T> by_cols;
for (unsigned i = 0; i < m_columns.size(); i++) {
for (auto & t : m_columns[i]) {
std::pair<unsigned, unsigned> p(t.var(), i);
SASSERT(by_cols.find(p) == by_cols.end());
by_cols[p] = get_val(t);
}
}
SASSERT(by_rows.size() == by_cols.size());
for (auto & t : by_rows) {
auto ic = by_cols.find(t.first);
SASSERT(ic != by_cols.end());
SASSERT(t.second == ic->second);
}
}
#endif
template <typename T, typename X> void static_matrix<T, X>::cross_out_row(unsigned k) {
#ifdef Z3DEBUG
check_consistency();
#endif
cross_out_row_from_columns(k, m_rows[k]);
fix_row_indices_in_each_column_for_crossed_row(k);
m_rows.erase(m_rows.begin() + k);
#ifdef Z3DEBUG
regen_domain();
check_consistency();
#endif
}
template <typename T, typename X> void static_matrix<T, X>::fix_row_indices_in_each_column_for_crossed_row(unsigned k) {
for (auto & column : m_columns)
for (auto& cell : column)
if (cell.var() > k)
cell.var()--;
}
template <typename T, typename X> void static_matrix<T, X>::cross_out_row_from_columns(unsigned k, row_strip<T> & row) {
for (auto & t : row) {
cross_out_row_from_column(t.var(), k);
}
}
template <typename T, typename X> void static_matrix<T, X>::cross_out_row_from_column(unsigned col, unsigned k) {
auto & s = m_columns[col];
for (unsigned i = 0; i < s.size(); i++) {
if (s[i].var() == k) {
s.erase(s.begin() + i);
break;
}
}
}
template <typename T, typename X> T static_matrix<T, X>::get_elem(unsigned i, unsigned j) const { // should not be used in efficient code !!!!
for (auto & t : m_rows[i]) {
std::pair<unsigned, unsigned> p(i, t.var());
SASSERT(by_rows.find(p) == by_rows.end());
by_rows[p] = t.coeff();
if (t.var() == j) {
return t.coeff();
}
}
return numeric_traits<T>::zero();
}
std::unordered_map<std::pair<unsigned, unsigned>, T> by_cols;
for (unsigned i = 0; i < m_columns.size(); i++) {
for (auto & t : m_columns[i]) {
std::pair<unsigned, unsigned> p(t.var(), i);
SASSERT(by_cols.find(p) == by_cols.end());
by_cols[p] = get_val(t);
template <typename T, typename X> T static_matrix<T, X>::get_balance() const {
T ret = zero_of_type<T>();
for (unsigned i = 0; i < row_count(); i++) {
ret += get_row_balance(i);
}
return ret;
}
SASSERT(by_rows.size() == by_cols.size());
for (auto & t : by_rows) {
auto ic = by_cols.find(t.first);
SASSERT(ic != by_cols.end());
SASSERT(t.second == ic->second);
}
}
#endif
template <typename T, typename X> void static_matrix<T, X>::cross_out_row(unsigned k) {
#ifdef Z3DEBUG
check_consistency();
#endif
cross_out_row_from_columns(k, m_rows[k]);
fix_row_indices_in_each_column_for_crossed_row(k);
m_rows.erase(m_rows.begin() + k);
#ifdef Z3DEBUG
regen_domain();
check_consistency();
#endif
}
template <typename T, typename X> void static_matrix<T, X>::fix_row_indices_in_each_column_for_crossed_row(unsigned k) {
for (auto & column : m_columns)
for (auto& cell : column)
if (cell.var() > k)
cell.var()--;
}
template <typename T, typename X> void static_matrix<T, X>::cross_out_row_from_columns(unsigned k, row_strip<T> & row) {
for (auto & t : row) {
cross_out_row_from_column(t.var(), k);
}
}
template <typename T, typename X> void static_matrix<T, X>::cross_out_row_from_column(unsigned col, unsigned k) {
auto & s = m_columns[col];
for (unsigned i = 0; i < s.size(); i++) {
if (s[i].var() == k) {
s.erase(s.begin() + i);
break;
template <typename T, typename X> T static_matrix<T, X>::get_row_balance(unsigned row) const {
T ret = zero_of_type<T>();
for (auto & t : m_rows[row]) {
if (numeric_traits<T>::is_zero(t.coeff())) continue;
T a = abs(t.coeff());
numeric_traits<T>::log(a);
ret += a * a;
}
return ret;
}
}
template <typename T, typename X> T static_matrix<T, X>::get_elem(unsigned i, unsigned j) const { // should not be used in efficient code !!!!
for (auto & t : m_rows[i]) {
if (t.var() == j) {
return t.coeff();
template <typename T, typename X> bool static_matrix<T, X>::is_correct() const {
for (auto & row : m_rows) {
std::unordered_set<unsigned> s;
for (auto & rc : row) {
if (s.find(rc.var()) != s.end())
return false;
s.insert(rc.var());
if (rc.var() >= m_columns.size())
return false;
if (rc.offset() >= m_columns[rc.var()].size())
return false;
if (rc.coeff() != get_val(m_columns[rc.var()][rc.offset()]))
return false;
if (is_zero(rc.coeff()))
return false;
}
}
}
return numeric_traits<T>::zero();
}
template <typename T, typename X> T static_matrix<T, X>::get_balance() const {
T ret = zero_of_type<T>();
for (unsigned i = 0; i < row_count(); i++) {
ret += get_row_balance(i);
}
return ret;
}
template <typename T, typename X> T static_matrix<T, X>::get_row_balance(unsigned row) const {
T ret = zero_of_type<T>();
for (auto & t : m_rows[row]) {
if (numeric_traits<T>::is_zero(t.coeff())) continue;
T a = abs(t.coeff());
numeric_traits<T>::log(a);
ret += a * a;
}
return ret;
}
template <typename T, typename X> bool static_matrix<T, X>::is_correct() const {
for (auto & row : m_rows) {
std::unordered_set<unsigned> s;
for (auto & rc : row) {
if (s.find(rc.var()) != s.end())
return false;
s.insert(rc.var());
if (rc.var() >= m_columns.size())
return false;
if (rc.offset() >= m_columns[rc.var()].size())
return false;
if (rc.coeff() != get_val(m_columns[rc.var()][rc.offset()]))
return false;
if (is_zero(rc.coeff()))
return false;
for (auto & column : m_columns) {
std::unordered_set<unsigned> s;
for (auto & cc : column) {
if (s.find(cc.var()) != s.end())
return false;
s.insert(cc.var());
if (cc.var() >= m_rows.size())
return false;
if (cc.offset() >= m_rows[cc.var()].size())
return false;
if (get_val(cc) != m_rows[cc.var()][cc.offset()].coeff())
return false;
}
}
return true;
}
for (auto & column : m_columns) {
std::unordered_set<unsigned> s;
for (auto & cc : column) {
if (s.find(cc.var()) != s.end())
return false;
s.insert(cc.var());
if (cc.var() >= m_rows.size())
return false;
if (cc.offset() >= m_rows[cc.var()].size())
return false;
if (get_val(cc) != m_rows[cc.var()][cc.offset()].coeff())
return false;
template <typename T, typename X>
void static_matrix<T, X>::remove_element(std_vector<row_cell<T>> & row_vals, row_cell<T> & row_el_iv) {
unsigned column_offset = row_el_iv.offset();
auto & column_vals = m_columns[row_el_iv.var()];
column_cell& cs = m_columns[row_el_iv.var()][column_offset];
unsigned row_offset = cs.offset();
if (column_offset != column_vals.size() - 1) {
auto & cc = column_vals[column_offset] = column_vals.back(); // copy from the tail
m_rows[cc.var()][cc.offset()].offset() = column_offset;
}
}
return true;
}
template <typename T, typename X>
void static_matrix<T, X>::remove_element(std_vector<row_cell<T>> & row_vals, row_cell<T> & row_el_iv) {
unsigned column_offset = row_el_iv.offset();
auto & column_vals = m_columns[row_el_iv.var()];
column_cell& cs = m_columns[row_el_iv.var()][column_offset];
unsigned row_offset = cs.offset();
if (column_offset != column_vals.size() - 1) {
auto & cc = column_vals[column_offset] = column_vals.back(); // copy from the tail
m_rows[cc.var()][cc.offset()].offset() = column_offset;
if (row_offset != row_vals.size() - 1) {
auto & rc = row_vals[row_offset] = row_vals.back(); // copy from the tail
m_columns[rc.var()][rc.offset()].offset() = row_offset;
}
column_vals.pop_back();
row_vals.pop_back();
}
if (row_offset != row_vals.size() - 1) {
auto & rc = row_vals[row_offset] = row_vals.back(); // copy from the tail
m_columns[rc.var()][rc.offset()].offset() = row_offset;
template <typename T, typename X>
void static_matrix<T, X>::add_new_element(unsigned row, unsigned col, const T& val) {
auto & row_vals = m_rows[row];
auto & col_vals = m_columns[col];
unsigned row_el_offs = row_vals.size();
unsigned col_el_offs = col_vals.size();
row_vals.push_back(row_cell<T>(col, col_el_offs, val));
col_vals.push_back(column_cell(row, row_el_offs));
}
column_vals.pop_back();
row_vals.pop_back();
}
template <typename T, typename X>
void static_matrix<T, X>::add_new_element(unsigned row, unsigned col, const T& val) {
auto & row_vals = m_rows[row];
auto & col_vals = m_columns[col];
unsigned row_el_offs = row_vals.size();
unsigned col_el_offs = col_vals.size();
row_vals.push_back(row_cell<T>(col, col_el_offs, val));
col_vals.push_back(column_cell(row, row_el_offs));
}
}