deal with compiler warnings

src/math/lp/hnf_cutter.cpp

@@ -49,7 +49,7 @@ namespace lp  {
         
         m_constraints_for_explanation.push_back(ci);
        
-        for (const auto &p : *t) {
+        for (lar_term::ival p : *t) {
             m_var_register.add_var(p.column().index(), true); // hnf only deals with integral variables for now
             mpq t = abs(ceil(p.coeff()));
             if (t > m_abs_max)

src/math/lp/int_solver.cpp

@@ -189,7 +189,7 @@ std::ostream& int_solver::display_inf_rows(std::ostream& out) const {
 }
 
 bool int_solver::cut_indices_are_columns() const {
-    for (const auto & p: m_t) {
+    for (lar_term::ival p : m_t) {
         if (p.column().index() >= lra.A_r().column_count())
             return false;
     }
@@ -347,7 +347,7 @@ bool int_solver::get_freedom_interval_for_column(unsigned j, bool & inf_l, impq
     lp_assert(settings().use_tableau());
     const auto & A = lra.A_r();
     unsigned rounds = 0;
-    for (const auto &c : A.column(j)) {
+    for (auto c : A.column(j)) {
         row_index = c.var();
         const mpq & a = c.coeff();        
         unsigned i = lrac.m_r_basis[row_index];
@@ -357,7 +357,7 @@ bool int_solver::get_freedom_interval_for_column(unsigned j, bool & inf_l, impq
     }
     TRACE("random_update", tout <<  "m = " << m << "\n";);
     
-    for (const auto &c : A.column(j)) {
+    for (auto c : A.column(j)) {
         if (!inf_l && !inf_u && l >= u) break;       
         row_index = c.var();
         const mpq & a = c.coeff();        

src/math/lp/nla_core.cpp

@@ -55,7 +55,7 @@ bool core::compare_holds(const rational& ls, llc cmp, const rational& rs) const
 
 rational core::value(const lp::lar_term& r) const {
     rational ret(0);
-    for (const auto & t : r) {
+    for (lp::lar_term::ival t : r) {
         ret += t.coeff() * val(t.column());
     }
     return ret;
@@ -63,7 +63,7 @@ rational core::value(const lp::lar_term& r) const {
 
 lp::lar_term core::subs_terms_to_columns(const lp::lar_term& t) const {
     lp::lar_term r;
-    for (const auto& p : t) {
+    for (lp::lar_term::ival p : t) {
         lpvar j = p.column();
         if (lp::tv::is_term(j))
             j = m_lar_solver.map_term_index_to_column_index(j);
@@ -288,7 +288,7 @@ bool core::explain_upper_bound(const lp::lar_term& t, const rational& rs, lp::ex
 }
 bool core::explain_lower_bound(const lp::lar_term& t, const rational& rs, lp::explanation& e) const {
     rational b(0); // the bound
-    for (const auto& p : t) {
+    for (lp::lar_term::ival p : t) {
         rational pb;
         if (explain_coeff_lower_bound(p, pb, e)) {
             b += pb;
@@ -587,7 +587,7 @@ std::ostream & core::print_ineqs(const lemma& l, std::ostream & out) const {
             auto & in = l.ineqs()[i]; 
             print_ineq(in, out);
             if (i + 1 < l.ineqs().size()) out << " or ";
-            for (const auto & p: in.term())
+            for (lp::lar_term::ival p: in.term())
                 vars.insert(p.column());
         }
         out << std::endl;
@@ -708,7 +708,7 @@ bool core::is_octagon_term(const lp::lar_term& t, bool & sign, lpvar& i, lpvar &
     bool seen_minus = false;
     bool seen_plus = false;
     i = null_lpvar;
-    for(const auto & p : t) {
+    for(lp::lar_term::ival p : t) {
         const auto & c = p.coeff();
         if (c == 1) {
             seen_plus = true;
@@ -851,11 +851,11 @@ std::unordered_set<lpvar> core::collect_vars(const lemma& l) const {
     };
     
     for (const auto& i : l.ineqs()) {
-        for (const auto& p : i.term()) {                
+        for (lp::lar_term::ival p : i.term()) {                
             insert_j(p.column());
         }
     }
-    for (const auto& p : l.expl()) {
+    for (auto p : l.expl()) {
         const auto& c = m_lar_solver.constraints()[p.ci()];
         for (const auto& r : c.coeffs()) {
             insert_j(r.second);

src/math/lp/nra_solver.cpp

@@ -204,7 +204,7 @@ struct solver::imp {
         // variable representing the term.
         svector<polynomial::var> vars;
         rational den(1);
-        for (const auto& kv : t) {
+        for (lp::lar_term::ival kv : t) {
             vars.push_back(lp2nl(kv.column().index()));
             den = lcm(den, denominator(kv.coeff()));
         }

src/math/lp/square_sparse_matrix_def.h

@@ -27,7 +27,7 @@ template <typename T, typename X>
 template <typename M>
 void square_sparse_matrix<T, X>::copy_column_from_input(unsigned input_column, const M& A, unsigned j) {
     vector<indexed_value<T>> & new_column_vector = m_columns[j].m_values;
-    for (const auto & c : A.column(input_column)) {
+    for (auto c : A.column(input_column)) {
         unsigned col_offset = static_cast<unsigned>(new_column_vector.size());
         vector<indexed_value<T>> & row_vector = m_rows[c.var()];
         unsigned row_offset = static_cast<unsigned>(row_vector.size());
@@ -41,7 +41,7 @@ template <typename T, typename X>
 template <typename M>
 void square_sparse_matrix<T, X>::copy_column_from_input_with_possible_zeros(const M& A, unsigned j) {
     vector<indexed_value<T>> & new_column_vector = m_columns[j].m_values;
-    for (const auto & c : A.column(j)) {
+    for (auto c : A.column(j)) {
         if (is_zero(c.coeff()))
             continue;
         unsigned col_offset = static_cast<unsigned>(new_column_vector.size());