remove unneeded iterator functions

src/ast/euf/euf_ac_plugin.h

@@ -61,8 +61,7 @@ namespace euf {
                 node* operator*() { return m_first; }
                 iterator& operator++() { if (!m_last) m_last = m_first; m_first = m_first->next; return *this; }
                 iterator operator++(int) { iterator tmp = *this; ++*this; return tmp; }
-                bool operator==(iterator const& other) const { return m_last == other.m_last && m_first == other.m_first; }
-                bool operator!=(iterator const& other) const { return !(*this == other); }
+                bool operator!=(iterator const& other) const { return m_last != other.m_last || m_first != other.m_first; }
             };
             equiv(node& _n) :n(_n) {}
             equiv(node* _n) :n(*_n) {}

src/ast/euf/euf_enode.h

@@ -280,8 +280,7 @@ namespace euf {
             enode* operator*() { return m_first; }
             iterator& operator++() { if (!m_last) m_last = m_first; m_first = m_first->m_next; return *this; }
             iterator operator++(int) { iterator tmp = *this; ++*this; return tmp; }
-            bool operator==(iterator const& other) const { return m_last == other.m_last && m_first == other.m_first; }
-            bool operator!=(iterator const& other) const { return !(*this == other); }            
+            bool operator!=(iterator const& other) const { return m_last != other.m_last || m_first != other.m_first; }            
         };
         enode_class(enode & _n):n(_n) {}
         enode_class(enode * _n):n(*_n) {}
@@ -300,8 +299,7 @@ namespace euf {
             th_var_list const& operator*() { return *m_th_vars; }
             iterator& operator++() { m_th_vars = m_th_vars->get_next(); return *this; }
             iterator operator++(int) { iterator tmp = *this; ++* this; return tmp; }
-            bool operator==(iterator const& other) const { return m_th_vars == other.m_th_vars; }
-            bool operator!=(iterator const& other) const { return !(*this == other); }
+            bool operator!=(iterator const& other) const { return m_th_vars != other.m_th_vars; }
         };
         enode_th_vars(enode& _n) :n(_n) {}
         enode_th_vars(enode* _n) :n(*_n) {}

src/ast/for_each_expr.cpp

@@ -146,20 +146,16 @@ subterms::iterator& subterms::iterator::operator++() {
     return *this;
 }
 
-bool subterms::iterator::operator==(iterator const& other) const {
+bool subterms::iterator::operator!=(iterator const& other) const {
     // ignore state of visited
     if (other.m_esp->size() != m_esp->size()) {
-        return false;
+        return true;
     }
     for (unsigned i = m_esp->size(); i-- > 0; ) {
         if (m_esp->get(i) != other.m_esp->get(i))
-            return false;
+            return true;
     }
-    return true;
-}
-
-bool subterms::iterator::operator!=(iterator const& other) const {
-    return !(*this == other);
+    return false;
 }
 
 
@@ -216,18 +212,14 @@ subterms_postorder::iterator& subterms_postorder::iterator::operator++() {
     return *this;
 }
 
-bool subterms_postorder::iterator::operator==(iterator const& other) const {
+bool subterms_postorder::iterator::operator!=(iterator const& other) const {
     // ignore state of visited
     if (other.m_es.size() != m_es.size()) {
-        return false;
+        return true;
     }
     for (unsigned i = m_es.size(); i-- > 0; ) {
         if (m_es.get(i) != other.m_es.get(i))
-            return false;
+            return true;
     }
-    return true;
-}
-
-bool subterms_postorder::iterator::operator!=(iterator const& other) const {
-    return !(*this == other);
+    return false;
 }

src/ast/for_each_expr.h

@@ -190,7 +190,6 @@ public:
         expr* operator*();
         iterator operator++(int);
         iterator& operator++();
-        bool operator==(iterator const& other) const;
         bool operator!=(iterator const& other) const;
     };
 
@@ -220,7 +219,6 @@ public:
         expr* operator*();
         iterator operator++(int);
         iterator& operator++();
-        bool operator==(iterator const& other) const;
         bool operator!=(iterator const& other) const;
     };
     static subterms_postorder all(expr_ref_vector const& es) { return subterms_postorder(es, true); }

src/math/dd/dd_pdd.h

@@ -571,8 +571,7 @@ namespace dd {
         pdd_monomial const* operator->() const { return &m_mono; }
         pdd_iterator& operator++() { next(); return *this; }
         pdd_iterator operator++(int) { auto tmp = *this; next(); return tmp; }
-        bool operator==(pdd_iterator const& other) const { return m_nodes == other.m_nodes; }
-        bool operator!=(pdd_iterator const& other) const { return !operator==(other); }
+        bool operator!=(pdd_iterator const& other) const { return m_nodes != other.m_nodes; }
     };
 
     class pdd_linear_iterator {
@@ -591,7 +590,6 @@ namespace dd {
         pointer operator->() const { return &m_mono; }
         pdd_linear_iterator& operator++() { next(); return *this; }
         pdd_linear_iterator operator++(int) { auto tmp = *this; next(); return tmp; }
-        bool operator==(pdd_linear_iterator const& other) const { return m_next == other.m_next; }
         bool operator!=(pdd_linear_iterator const& other) const { return m_next != other.m_next; }
     };
 

src/math/hilbert/heap_trie.h

@@ -369,7 +369,6 @@ public:
         }
         iterator& operator++() { fwd(); return *this; }
         iterator operator++(int) { iterator tmp = *this; ++*this; return tmp; }
-        bool operator==(iterator const& it) const {return m_count == it.m_count; }
         bool operator!=(iterator const& it) const {return m_count != it.m_count; }
 
     private:

src/math/hilbert/hilbert_basis.cpp

@@ -455,7 +455,6 @@ public:
         offset_t operator*() const { return p.m_passive[m_idx]; }
         iterator& operator++() { ++m_idx; fwd(); return *this; }
         iterator operator++(int) { iterator tmp = *this; ++*this; return tmp; }
-        bool operator==(iterator const& it) const {return m_idx == it.m_idx; }
         bool operator!=(iterator const& it) const {return m_idx != it.m_idx; }
     };
 
@@ -614,7 +613,6 @@ public:
         offset_t sos() const { return (p.hb.vec(pas()).weight().is_pos()?p.m_neg_sos:p.m_pos_sos)[p.m_psos[m_idx]]; }
         iterator& operator++() { ++m_idx; fwd(); return *this; }
         iterator operator++(int) { iterator tmp = *this; ++*this; return tmp; }
-        bool operator==(iterator const& it) const {return m_idx == it.m_idx; }
         bool operator!=(iterator const& it) const {return m_idx != it.m_idx; }
     };
 

src/math/hilbert/hilbert_basis.h

@@ -115,7 +115,6 @@ class hilbert_basis {
         offset_t operator*() const { return hb.m_basis[m_idx]; }
         iterator& operator++() { ++m_idx; return *this; }
         iterator operator++(int) { iterator tmp = *this; ++*this; return tmp; }
-        bool operator==(iterator const& it) const {return m_idx == it.m_idx; }
         bool operator!=(iterator const& it) const {return m_idx != it.m_idx; }
     };
 

src/math/lp/emonics.h

@@ -51,9 +51,8 @@ class emonics {
         unsigned     m_index;
     };
     struct head_tail {
-        head_tail(): m_head(nullptr), m_tail(nullptr) {}
-        cell* m_head;
-        cell* m_tail;
+        cell* m_head = nullptr;
+        cell* m_tail = nullptr;
     };
     struct hash_canonical {
         emonics& em;
@@ -205,7 +204,6 @@ public:
         monic & operator*() { return m.m_monics[m_cell->m_index]; }
         iterator& operator++() { m_touched = true; m_cell = m_cell->m_next; return *this; }
         iterator operator++(int) { iterator tmp = *this; ++*this; return tmp; }
-        bool operator==(iterator const& other) const { return m_cell == other.m_cell && m_touched == other.m_touched; }
         bool operator!=(iterator const& other) const { return m_cell != other.m_cell || m_touched != other.m_touched; }
     };
         
@@ -239,7 +237,6 @@ public:
         }
         pf_iterator& operator++() { ++m_it; fast_forward(); return *this; }
         pf_iterator operator++(int) { pf_iterator tmp = *this; ++*this; return tmp; }
-        bool operator==(pf_iterator const& other) const { return m_it == other.m_it; }
         bool operator!=(pf_iterator const& other) const { return m_it != other.m_it; }
     };
 

src/math/lp/explanation.h

@@ -106,11 +106,10 @@ public:
         iterator(bool run_on_vector, pair_vec::const_iterator vi, ci_set::iterator cii) :
             m_run_on_vector(run_on_vector), m_vi(vi), m_ci(cii)
         {}
-        bool operator==(const iterator &other) const {
+        bool operator!=(const iterator &other) const {
             SASSERT(m_run_on_vector == other.m_run_on_vector);
-            return  m_run_on_vector? m_vi == other.m_vi : m_ci == other.m_ci;
+            return  m_run_on_vector ? m_vi != other.m_vi : m_ci != other.m_ci;
         }
-        bool operator!=(const iterator &other) const { return !(*this == other); }
     };
 
     iterator begin() const {

src/math/lp/factorization.cpp

@@ -97,14 +97,12 @@ const_iterator_mon::const_iterator_mon(const bool_vector& mask, const factorizat
     m_ff(f) ,
     m_full_factorization_returned(false)
 {}
-            
-bool const_iterator_mon::operator==(const const_iterator_mon::self_type &other) const {
-    return
-        m_full_factorization_returned == other.m_full_factorization_returned &&
-        m_mask == other.m_mask;
-}
 
-bool const_iterator_mon::operator!=(const const_iterator_mon::self_type &other) const { return !(*this == other); }
+bool const_iterator_mon::operator!=(const const_iterator_mon::self_type &other) const {
+    return
+        m_full_factorization_returned != other.m_full_factorization_returned ||
+        m_mask != other.m_mask;
+}
             
 factorization const_iterator_mon::create_binary_factorization(factor j, factor k) const {
     factorization f(nullptr);

src/math/lp/factorization.h

@@ -88,8 +88,7 @@ struct const_iterator_mon {
     self_type operator++(int);
 
     const_iterator_mon(const bool_vector& mask, const factorization_factory *f);
-    
-    bool operator==(const self_type &other) const;
+
     bool operator!=(const self_type &other) const;
             
     factorization create_binary_factorization(factor j, factor k) const;

src/math/lp/lar_constraints.h

@@ -203,7 +203,6 @@ public:
             lar_base_constraint const* operator->() const { return &cs[m_index]; }
             iterator& operator++() { next(); return *this; }
             iterator operator++(int) { auto tmp = *this; next(); return tmp; }
-            bool operator==(iterator const& other) const { return m_index == other.m_index; }
             bool operator!=(iterator const& other) const { return m_index != other.m_index; }
         };
         iterator begin() const { return iterator(cs, 0); }
@@ -229,7 +228,6 @@ public:
             constraint_index const* operator->() const { return &m_index; }
             iterator& operator++() { next(); return *this; }
             iterator operator++(int) { auto tmp = *this; next(); return tmp; }
-            bool operator==(iterator const& other) const { return m_index == other.m_index; }
             bool operator!=(iterator const& other) const { return m_index != other.m_index; }
         };
         iterator begin() const { return iterator(cs, 0); }

src/math/lp/lar_term.h

@@ -170,8 +170,7 @@ public:
         const_iterator operator++() { const_iterator i = *this; m_it++; return i;  }
         const_iterator operator++(int) { m_it++; return *this; }
         const_iterator(u_map<mpq>::iterator it) : m_it(it) {}
-        bool operator==(const const_iterator &other) const { return m_it == other.m_it; }
-        bool operator!=(const const_iterator &other) const { return !(*this == other); }
+        bool operator!=(const const_iterator &other) const { return m_it != other.m_it; }
     };
    
     bool is_normalized() const {

src/math/lp/var_eqs.h

@@ -302,7 +302,6 @@ public:
             return signed_var(m_idx);
         }
         iterator& operator++() { m_idx = m_ve.m_uf.next(m_idx); m_touched = true; return *this; }
-        bool operator==(iterator const& other) const { return m_idx == other.m_idx && m_touched == other.m_touched; }
         bool operator!=(iterator const& other) const { return m_idx != other.m_idx || m_touched != other.m_touched; }
     };
 

src/math/simplex/bit_matrix.h

@@ -71,7 +71,6 @@ public:
         unsigned const* operator->() const { return &m_column; }
         col_iterator& operator++() { next(); return *this; }
         col_iterator operator++(int) { auto tmp = *this; next(); return tmp; }
-        bool operator==(col_iterator const& other) const { return m_column == other.m_column; }
         bool operator!=(col_iterator const& other) const { return m_column != other.m_column; }  
     };
 
@@ -88,7 +87,6 @@ public:
         row* operator->() { return &m_row; }
         row_iterator& operator++() { next(); return *this; }
         row_iterator operator++(int) { auto tmp = *this; next(); return tmp; }
-        bool operator==(row_iterator const& other) const { return m_index == other.m_index; }
         bool operator!=(row_iterator const& other) const { return m_index != other.m_index; }  
     };
 

src/math/simplex/sparse_matrix.h

@@ -198,7 +198,6 @@ namespace simplex {
             row_entry * operator->() const { return &(operator*()); }
             row_iterator & operator++() { ++m_curr; move_to_used(); return *this; }
             row_iterator operator++(int) { row_iterator tmp = *this; ++*this; return tmp; }
-            bool operator==(row_iterator const & it) const { return m_curr == it.m_curr; }
             bool operator!=(row_iterator const & it) const { return m_curr != it.m_curr; }           
         };
 
@@ -308,7 +307,6 @@ namespace simplex {
             row operator*() { return row(m_curr); }
             all_row_iterator & operator++() { m_curr++; move_to_next(); return *this; }
             all_row_iterator operator++(int) { all_row_iterator tmp = *this; ++*this; return tmp; }
-            bool operator==(all_row_iterator const& it) const { return m_curr == it.m_curr; }
             bool operator!=(all_row_iterator const& it) const { return m_curr != it.m_curr; }
         };
         

src/muz/rel/dl_table.cpp

@@ -122,7 +122,7 @@ namespace datalog {
             m_end(t.m_data.end()), m_row_obj(*this) {}
 
         bool is_finished() const override {
-            return m_inner==m_end;
+            return !(m_inner != m_end);
         }
 
         row_interface & operator*() override {

src/qe/qe.h

@@ -123,7 +123,6 @@ namespace qe {
             iterator(conj_enum& c, bool first) : m_super(&c), m_index(first?0:c.m_conjs.size()) {}
             expr* operator*() { return m_super->m_conjs[m_index].get(); }
             iterator& operator++() { m_index++; return *this; }
-            bool operator==(iterator const& it) const { return m_index == it.m_index; }
             bool operator!=(iterator const& it) const { return m_index != it.m_index; }
         };
 

src/sat/dimacs.h

@@ -94,7 +94,6 @@ namespace dimacs {
             iterator(drat_parser& p, bool is_eof):p(p), m_eof(is_eof) { if (!m_eof) m_eof = !p.next(); }
             drat_record const& operator*() { return p.m_record; }
             iterator& operator++() { if (!p.next()) m_eof = true; return *this;}
-            bool operator==(iterator const& other) const { return m_eof == other.m_eof; }
             bool operator!=(iterator const& other) const { return m_eof != other.m_eof; }
         };
         

src/sat/sat_clause.h

@@ -188,7 +188,6 @@ namespace sat {
             iterator(clause_wrapper const& c, unsigned idx): m_idx(idx), m_cw(c) {}
             iterator& operator++() { ++m_idx; return *this; }
             literal operator*() { return m_cw[m_idx]; }
-            bool operator==(iterator const& other) const { SASSERT(&m_cw == &other.m_cw); return m_idx == other.m_idx; }
             bool operator!=(iterator const& other) const { SASSERT(&m_cw == &other.m_cw); return m_idx != other.m_idx; }
         };
         iterator begin() const { return iterator(*this, 0); }

src/sat/smt/pb_constraint.h

@@ -125,7 +125,6 @@ namespace pb {
             iterator(constraint const& c, unsigned idx) : c(c), idx(idx) {}
             literal operator*() { return c.get_lit(idx); }
             iterator& operator++() { ++idx; return *this; }
-            bool operator==(iterator const& other) const { SASSERT(&c == &other.c); return idx == other.idx; }
             bool operator!=(iterator const& other) const { SASSERT(&c == &other.c); return idx != other.idx; }
         };
         

src/smt/smt_enode.h

@@ -360,8 +360,7 @@ namespace smt {
             enode* operator*() { return m_first; }
             iterator& operator++() { if (!m_last) m_last = m_first; m_first = m_first->m_next; return *this; }
             iterator operator++(int) { iterator tmp = *this; ++*this; return tmp; }
-            bool operator==(iterator const& other) const { return m_last == other.m_last && m_first == other.m_first; }
-            bool operator!=(iterator const& other) const { return !(*this == other); }            
+            bool operator!=(iterator const& other) const { return m_last != other.m_last || m_first != other.m_first; }            
         };
 
         iterator begin() { return iterator(this, nullptr); }

src/util/approx_set.h

@@ -197,10 +197,6 @@ public:
             ++*this; 
             return tmp; 
         }
-
-        bool operator==(iterator const & it) const { 
-            return m_set == it.m_set;
-        }
         
         bool operator!=(iterator const & it) const { 
             return m_set != it.m_set; 

src/util/bit_vector.h

@@ -220,7 +220,6 @@ public:
         bool operator*() const { return b.get(m_curr); }
         iterator& operator++() { ++m_curr; return *this; }
         iterator operator++(int) { iterator tmp = *this; ++* this; return tmp; }
-        bool operator==(iterator const& it) const { return m_curr == it.m_curr; }
         bool operator!=(iterator const& it) const { return m_curr != it.m_curr; }        
     };
 

src/util/chashtable.h

@@ -551,7 +551,6 @@ public:
             return *this;
         }
         iterator operator++(int) { iterator tmp = *this; ++*this; return tmp; }
-        bool operator==(iterator const & it) const { return m_list_it == it.m_list_it; }
         bool operator!=(iterator const & it) const { return m_list_it != it.m_list_it; }
     };
     

src/util/distribution.h

@@ -95,7 +95,6 @@ public:
             next_index();
             return *this;
         }
-        bool operator==(iterator const& other) const { return m_sz == other.m_sz; }
         bool operator!=(iterator const& other) const { return m_sz != other.m_sz; }
     };
 

src/util/dlist.h

@@ -213,13 +213,8 @@ public:
     T const& operator*() const {
         return *m_elem;
     }
-
-    bool operator==(dll_iterator const& other) const {
-        return m_elem == other.m_elem && m_first == other.m_first;
-    }
-
     bool operator!=(dll_iterator const& other) const {
-        return !operator==(other);
+        return m_elem != other.m_elem || m_first != other.m_first;
     }
 };
 

src/util/list.h

@@ -44,7 +44,6 @@ public:
         T const & operator*() const { return m_curr->head(); }
         iterator & operator++() { m_curr = m_curr->tail(); return *this; }
         iterator operator++(int) { iterator tmp = *this; ++*this; return tmp; }
-        bool operator==(iterator const & it) { return m_curr == it.m_curr; }
         bool operator!=(iterator const & it) { return m_curr != it.m_curr; }
     };        
 

src/util/scoped_vector.h

@@ -106,8 +106,7 @@ public:
         unsigned m_index;
     public:
         iterator(scoped_vector const& v, unsigned idx): m_vec(v), m_index(idx) {}
-        
-        bool operator==(iterator const& other) const { return &other.m_vec == &m_vec && other.m_index == m_index; }
+
         bool operator!=(iterator const& other) const { return &other.m_vec != &m_vec || other.m_index != m_index; }
         T const& operator*() { return m_vec[m_index]; }
 

src/util/uint_set.h

@@ -194,7 +194,6 @@ public:
             SASSERT(invariant());
         }
         unsigned operator*() const { return m_index; }
-        bool operator==(iterator const& it) const { return m_index == it.m_index; }
         bool operator!=(iterator const& it) const { return m_index != it.m_index; }
         iterator & operator++() { ++m_index; scan(); return *this; }
         iterator operator++(int) { iterator tmp = *this; ++*this; return tmp; }

src/util/vector.h

@@ -311,9 +311,6 @@ public:
             return *this;
         }
 
-        bool operator==(reverse_iterator const& other) const {
-            return other.v == v;
-        }
         bool operator!=(reverse_iterator const& other) const {
             return other.v != v;
         }
@@ -883,9 +880,6 @@ public:
             return *this;
         }
 
-        bool operator==(reverse_iterator const& other) const {
-            return other.v == v;
-        }
         bool operator!=(reverse_iterator const& other) const {
             return other.v != v;
         }