test that pivoting is correct in dioph_eq.cpp

Author: levnach

src/math/lp/dioph_eq.cpp

@@ -26,10 +26,10 @@ class explanation {
     typedef vector<std::pair<unsigned, mpq>> pair_vec;
     typedef    hashtable<unsigned, u_hash, u_eq>  ci_set;
     // Only one of the fields below is used. The first call adding an entry decides which one it is.
+public:
     vector<std::pair<constraint_index, mpq>> m_vector;
     ci_set  m_set;   
-public:
-    explanation() = default;
+    explanation() {}
 
     template <typename T>
     explanation(const T& t) {

src/math/lp/explanation.h

@@ -113,6 +113,8 @@ class indexed_vector {
             if (was_zero)
                 m_index.push_back(j);
         }
+        SASSERT(v.is_zero() == 
+        ( std::find(m_index.begin(), m_index.end(), j) == m_index.end()));
     }
 
     void erase(unsigned j);

src/math/lp/indexed_vector.h

@@ -181,7 +181,7 @@ namespace lp {
                 return lia_move::branch;
             }
 
-            m_dioph_eq_period *= 2; // the overflow is fine, maybe to try again
+            // m_dioph_eq_period *= 2;
             return lia_move::undef;
         }
 

src/math/lp/int_solver.cpp

@@ -1950,7 +1950,8 @@ namespace lp {
         // SASSERT(validate_bound(j, kind, right_side, dep));
         TRACE(
             "lar_solver_feas",
-            tout << "j" << j << " " << lconstraint_kind_string(kind) << " " << right_side << std::endl;            
+            tout << "j" << j << " " << lconstraint_kind_string(kind) << " " << right_side << std::endl;   
+            print_column_info(j, tout) << "\n";
             if (dep) {
                 tout << "dep:\n";
                 auto cs = flatten(dep);

src/math/lp/lar_solver.cpp

@@ -653,6 +653,7 @@ class lar_solver : public column_namer {
     inline int_solver* get_int_solver() { return m_int_solver; }
     inline const int_solver* get_int_solver() const { return m_int_solver; }
     inline const lar_term& get_term(lpvar j) const {
+        SASSERT(column_has_term(j));
         return *m_columns[j].term();
     }
     lp_status find_feasible_solution();

src/math/lp/lar_solver.h

@@ -51,7 +51,7 @@ class lar_term {
             return;
         auto *e = m_coeffs.find_core(j);        
         if (e == nullptr) {
-            m_coeffs.insert(j, c);
+            m_coeffs.insert(j, -c);
         } else {
             e->get_data().m_value -= c;
             if (e->get_data().m_value.is_zero())
@@ -90,6 +90,21 @@ class lar_term {
     }
     // constructors
     lar_term() = default;
+<<<<<<< HEAD
+=======
+    lar_term(lar_term&& other) noexcept = default;
+    // copy assignment operator
+    lar_term& operator=(const lar_term& other) = default;
+    // move assignment operator
+    lar_term& operator=(lar_term&& other) noexcept = default;
+    ~lar_term() = default;
+    lar_term(const lar_term& a) {
+        for (auto const& p : a) {
+            add_monomial(p.coeff(), p.var());
+        }
+    }
+    
+>>>>>>> 956229fb6 (test that pivoting is correct in dioph_eq.cpp)
     lar_term(const vector<std::pair<mpq, unsigned>>& coeffs) {
         for (auto const& p : coeffs) {
             add_monomial(p.first, p.second);
@@ -205,7 +220,16 @@ class lar_term {
         }
         return r;
     }
-   
+
+    friend lar_term operator-(const lar_term& a, const lar_term& b) {
+        lar_term r(a);
+        for (const auto& p : b) {
+            r.sub_monomial(p.coeff(), p.j());
+        }
+        return r;
+    }
+
+
     lar_term& operator+=(const lar_term& a) {
         for (const auto& p : a) {
             add_monomial(p.coeff(), p.j());

src/math/lp/lar_term.h

@@ -90,8 +90,18 @@ std::ostream& print_linear_combination_customized(const vector<std::pair<T, unsi
         out << "0";
         return out;
     }
+    // Copy term to a std_vector and sort by p.j()
+    std_vector<std::pair<T, unsigned>> sorted_coeffs;
+    sorted_coeffs.reserve(coeffs.size());
+    for (const auto& p : coeffs) {
+        sorted_coeffs.emplace_back(p.first, p.second);
+    }
+    std::sort(sorted_coeffs.begin(), sorted_coeffs.end(), 
+             [](const auto& a, const auto& b) { return a.second < b.second; });
+
+    // Print the sorted term
     bool first = true;
-    for (const auto & it : coeffs) {
+    for (const auto & it : sorted_coeffs) {
         T val = it.first;
         if (first) {
             first = false;

src/math/lp/lp_utils.h

@@ -46,6 +46,7 @@ typedef vector<column_cell> column_strip;
 template <typename T>
 using row_strip = vector<row_cell<T>>; 
 template <typename K> mpq get_denominators_lcm(const K & row) {
+    SASSERT(row.size() > 0);
     mpq r = mpq(1);
     for (const auto & c : row) 
         r = lcm(r, denominator(c.coeff()));

src/math/lp/static_matrix.h

@@ -90,7 +90,7 @@ inline void static_matrix<T, X>::pivot_row_to_row_given_cell_with_sign(unsigned
 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;
+    T alpha = - get_val(c) * pivot_sign;
     SASSERT(!is_zero(alpha));
     auto & rowii = m_rows[ii];
     remove_element(rowii, rowii[c.offset()]);