remove dead code

Signed-off-by: Lev Nachmanson <levnach@hotmail.com>

src/math/lp/lar_core_solver.h

@@ -43,12 +43,6 @@ class lar_core_solver  {
     stacked_vector<unsigned> m_r_columns_nz;
     stacked_vector<unsigned> m_r_rows_nz;
 
-    // d - solver fields, for doubles
-    stacked_vector<unsigned> m_d_pushed_basis;
-    vector<unsigned> m_d_basis;
-    vector<unsigned> m_d_nbasis;
-    vector<int> m_d_heading;
-
 
     lp_primal_core_solver<mpq, numeric_pair<mpq>> m_r_solver; // solver in rational numbers
 
@@ -123,14 +117,6 @@ class lar_core_solver  {
 
     void fill_not_improvable_zero_sum();
 
-    void pop_basis(unsigned k) {
-
-            m_d_basis = m_r_basis;
-            m_d_nbasis = m_r_nbasis;
-            m_d_heading = m_r_heading;
-
-    }
-
     void push() {
         lp_assert(m_r_solver.basis_heading_is_correct());
         lp_assert(m_column_types.size() == m_r_A.column_count());
@@ -180,7 +166,6 @@ class lar_core_solver  {
         m_r_solver.m_costs.resize(m_r_A.column_count());
         m_r_solver.m_d.resize(m_r_A.column_count());
 
-        pop_basis(k);
         m_stacked_simplex_strategy.pop(k);
         settings().set_simplex_strategy(m_stacked_simplex_strategy);
         lp_assert(m_r_solver.basis_heading_is_correct());
@@ -356,10 +341,6 @@ class lar_core_solver  {
         return delta;
     }
 
-    void init_column_row_nz_for_r_solver() {
-        m_r_solver.init_column_row_non_zeroes();
-    }
-
     bool column_is_fixed(unsigned j) const {
         return m_column_types()[j] == column_type::fixed ||
             ( m_column_types()[j] == column_type::boxed &&

src/math/lp/lar_solver.cpp

@@ -245,11 +245,7 @@ namespace lp {
             set.erase(j);
     }
 
-    void lar_solver::shrink_inf_set_after_pop(unsigned n, u_set& set) {
-        clean_popped_elements(n, set);
-        set.resize(n);
-    }
-
+
 
     void lar_solver::pop(unsigned k) {
         TRACE("lar_solver", tout << "k = " << k << std::endl;);
@@ -714,11 +710,6 @@ namespace lp {
             detect_rows_with_changed_bounds_for_column(j);
     }
 
-    void lar_solver::update_x_and_inf_costs_for_columns_with_changed_bounds() {
-        for (auto j : m_columns_with_changed_bounds)
-            update_x_and_inf_costs_for_column_with_changed_bounds(j);
-    }
-
     void lar_solver::update_x_and_inf_costs_for_columns_with_changed_bounds_tableau() {
         for (auto j : m_columns_with_changed_bounds)
             update_x_and_inf_costs_for_column_with_changed_bounds(j);
@@ -792,31 +783,6 @@ namespace lp {
     }
 
 
-    void lar_solver::fill_last_row_of_A_r(static_matrix<mpq, numeric_pair<mpq>>& A, const lar_term* ls) {
-        lp_assert(A.row_count() > 0);
-        lp_assert(A.column_count() > 0);
-        unsigned last_row = A.row_count() - 1;
-        lp_assert(A.m_rows[last_row].size() == 0);
-        for (auto t : *ls) {
-            lp_assert(!is_zero(t.coeff()));
-            var_index j = t.column();
-            A.set(last_row, j, -t.coeff());
-        }
-        unsigned basis_j = A.column_count() - 1;
-        A.set(last_row, basis_j, mpq(1));
-    }
-
-    template <typename U, typename V>
-    void lar_solver::copy_from_mpq_matrix(static_matrix<U, V>& matr) {
-        matr.m_rows.resize(A_r().row_count());
-        matr.m_columns.resize(A_r().column_count());
-        for (unsigned i = 0; i < matr.row_count(); i++) {
-            for (auto& it : A_r().m_rows[i]) {
-                matr.set(i, it.var(), convert_struct<U, mpq>::convert(it.coeff()));
-            }
-        }
-    }
-
     bool lar_solver::all_constrained_variables_are_registered(const vector<std::pair<mpq, var_index>>& left_side) {
         for (auto it : left_side) {
             if (!var_is_registered(it.second))

src/math/lp/lar_solver.h

@@ -122,7 +122,6 @@ class lar_solver : public column_namer {
     bool term_is_int(const lar_term * t) const;
     bool term_is_int(const vector<std::pair<mpq, unsigned int>> & coeffs) const;
     void add_non_basic_var_to_core_fields(unsigned ext_j, bool is_int);
-    void add_new_var_to_core_fields_for_doubles(bool register_in_basis);
     void add_new_var_to_core_fields_for_mpq(bool register_in_basis);
     mpq adjust_bound_for_int(lpvar j, lconstraint_kind&, const mpq&);
 
@@ -131,7 +130,6 @@ class lar_solver : public column_namer {
     var_index add_term_undecided(const vector<std::pair<mpq, var_index>> & coeffs);
     bool term_coeffs_are_ok(const vector<std::pair<mpq, var_index>> & coeffs);
     void push_term(lar_term* t);
-    void add_row_for_term(const lar_term * term, unsigned term_ext_index);
     void add_row_from_term_no_constraint(const lar_term * term, unsigned term_ext_index);
     void add_basic_var_to_core_fields();
     bool compare_values(impq const& lhs, lconstraint_kind k, const mpq & rhs);
@@ -187,7 +185,6 @@ class lar_solver : public column_namer {
         analyze_new_bounds_on_row_tableau(i, bp);
     }
     static void clean_popped_elements(unsigned n, u_set& set);
-    static void shrink_inf_set_after_pop(unsigned n, u_set & set);
     bool maximize_term_on_tableau(const lar_term & term,
                                   impq &term_max);
     bool costs_are_zeros_for_r_solver() const;
@@ -213,25 +210,17 @@ class lar_solver : public column_namer {
     void detect_rows_with_changed_bounds_for_column(unsigned j);
     void detect_rows_with_changed_bounds();
 
-    void update_x_and_inf_costs_for_columns_with_changed_bounds();
     void update_x_and_inf_costs_for_columns_with_changed_bounds_tableau();
     void solve_with_core_solver();
     numeric_pair<mpq> get_basic_var_value_from_row(unsigned i);
     bool x_is_correct() const;
-    void fill_last_row_of_A_r(static_matrix<mpq, numeric_pair<mpq>> & A, const lar_term * ls);
-    template <typename U, typename V>
-    void create_matrix_A(static_matrix<U, V> & matr);
-    template <typename U, typename V>
-    void copy_from_mpq_matrix(static_matrix<U, V> & matr);
-    bool try_to_set_fixed(column_info<mpq> & ci);
     bool all_constrained_variables_are_registered(const vector<std::pair<mpq, var_index>>& left_side);
     bool all_constraints_hold() const;
     bool constraint_holds(const lar_base_constraint & constr, std::unordered_map<var_index, mpq> & var_map) const;
     bool the_relations_are_of_same_type(const vector<std::pair<mpq, unsigned>> & evidence, lconstraint_kind & the_kind_of_sum) const;
     static void register_in_map(std::unordered_map<var_index, mpq> & coeffs, const lar_base_constraint & cn, const mpq & a);
     static void register_monoid_in_map(std::unordered_map<var_index, mpq> & coeffs, const mpq & a, unsigned j);
     bool the_left_sides_sum_to_zero(const vector<std::pair<mpq, unsigned>> & evidence) const;
-    bool the_right_sides_do_not_sum_to_zero(const vector<std::pair<mpq, unsigned>> & evidence);
     bool explanation_is_correct(explanation&) const;
     bool inf_explanation_is_correct() const;
     mpq sum_of_right_sides_of_explanation(explanation &) const;
@@ -251,21 +240,16 @@ class lar_solver : public column_namer {
     void remove_last_column_from_tableau();
     void pop_tableau();
     void clean_inf_set_of_r_solver_after_pop();
-    void shrink_explanation_to_minimum(vector<std::pair<mpq, constraint_index>> & explanation) const;
     inline bool column_value_is_integer(unsigned j) const { return get_column_value(j).is_int(); }
     bool model_is_int_feasible() const;
 
     bool bound_is_integer_for_integer_column(unsigned j, const mpq & right_side) const;
     inline lar_core_solver & get_core_solver() { return m_mpq_lar_core_solver; }
-    void catch_up_in_updating_int_solver();
     var_index to_column(unsigned ext_j) const;
     void fix_terms_with_rounded_columns();
-    void update_delta_for_terms(const impq & delta, unsigned j, const vector<unsigned>&);
-    void fill_vars_to_terms(vector<vector<unsigned>> & vars_to_terms);
     bool remove_from_basis(unsigned);
     lar_term get_term_to_maximize(unsigned ext_j) const;
     bool sum_first_coords(const lar_term& t, mpq & val) const;
-    void collect_rounded_rows_to_fix();
     void register_normalized_term(const lar_term&, lpvar);
     void deregister_normalized_term(const lar_term&);
 

src/math/lp/lp_core_solver_base.h

@@ -80,7 +80,7 @@ class lp_core_solver_base {
     vector<unsigned> &    m_basis;
     vector<unsigned>&     m_nbasis;
     vector<int>&          m_basis_heading;
-    vector<X> &           m_x; // a feasible solution, the fist time set in the constructor
+    vector<X> &           m_x; // a feasible solution, the first time set in the constructor
     vector<T> &           m_costs;
     lp_settings &         m_settings;