added the possibility to get some statistical information from ex::compare()

[ginac.git] / ginac / ex.h

diff --git a/ginac/ex.h b/ginac/ex.h
index 2f5e8fe9d851a6e4c4e70964b2339f4b32f98794..14695fd9b1b10258a0d25cc1f8d864211f6db50b 100644 (file)
--- a/ginac/ex.h
+++ b/ginac/ex.h
@@ -3,7 +3,7 @@
  *  Interface to GiNaC's light-weight expression handles. */
 
 /*
- *  GiNaC Copyright (C) 1999-2003 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2004 Johannes Gutenberg University Mainz, Germany
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -132,6 +132,9 @@ public:
        ex lhs() const;
        ex rhs() const;
 
+       // complex conjugation
+       ex conjugate() const { return bp->conjugate(); }
+
        // pattern matching
        bool has(const ex & pattern) const { return bp->has(pattern); }
        bool find(const ex & pattern, lst & found) const;
@@ -189,8 +192,8 @@ public:
 
        // indexed objects
        exvector get_free_indices() const { return bp->get_free_indices(); }
-       ex simplify_indexed() const;
-       ex simplify_indexed(const scalar_products & sp) const;
+       ex simplify_indexed(unsigned options = 0) const;
+       ex simplify_indexed(const scalar_products & sp, unsigned options = 0) const;
 
        // comparison
        int compare(const ex & other) const;
@@ -355,24 +358,47 @@ ex::ex(const std::string &s, const ex &l) : bp(construct_from_string_and_lst(s,
 inline
 int ex::compare(const ex & other) const
 {
+#ifdef GINAC_COMPARE_STATISTICS
+       compare_statistics.total_compares++;
+#endif
        if (bp == other.bp)  // trivial case: both expressions point to same basic
                return 0;
+#ifdef GINAC_COMPARE_STATISTICS
+       compare_statistics.nontrivial_compares++;
+#endif
        const int cmpval = bp->compare(*other.bp);
+#if 1
        if (cmpval == 0) {
                // Expressions point to different, but equal, trees: conserve
                // memory and make subsequent compare() operations faster by
-               // making both expression point to the same tree.
+               // making both expressions point to the same tree.
                share(other);
        }
+#endif
        return cmpval;
 }
 
 inline
 bool ex::is_equal(const ex & other) const
 {
+#ifdef GINAC_COMPARE_STATISTICS
+       compare_statistics.total_is_equals++;
+#endif
        if (bp == other.bp)  // trivial case: both expressions point to same basic
                return true;
-       return bp->is_equal(*other.bp);
+#ifdef GINAC_COMPARE_STATISTICS
+       compare_statistics.nontrivial_is_equals++;
+#endif
+    const bool equal = bp->is_equal(*other.bp);
+#if 0
+       if (equal) {
+               // Expressions point to different, but equal, trees: conserve
+               // memory and make subsequent compare() operations faster by
+               // making both expressions point to the same tree.
+               share(other);
+       }
+#endif
+       return equal;
 }
 
 
@@ -530,8 +556,8 @@ class const_preorder_iterator : public std::iterator<std::forward_iterator_tag,
 public:
        const_preorder_iterator() throw() {}
 
-       // Provide implicit conversion from const_iterator, so begin() and
-       // end() can be used to create const_preorder_iterators
+       // Provide implicit conversion from const_iterator, so ex::begin() and
+       // ex::end() can be used to create const_preorder_iterators
        const_preorder_iterator(const const_iterator & cit)
        {
                s.push(internal::_iter_rep(cit.e, cit.i, cit.e.nops()));
@@ -540,8 +566,7 @@ public:
 public:
        ex operator*() const
        {
-               const internal::_iter_rep & r = s.top();
-               return r.e.op(r.i);
+               return s.top().e;
        }
 
        std::auto_ptr<ex> operator->() const
@@ -564,7 +589,7 @@ public:
 
        bool operator==(const const_preorder_iterator &other) const throw()
        {
-               return s == other.s;
+               return s.top() == other.s.top();
        }
 
        bool operator!=(const const_preorder_iterator &other) const throw()
@@ -573,22 +598,21 @@ public:
        }
 
 private:
-       std::stack<internal::_iter_rep> s;
+       std::stack<internal::_iter_rep, std::vector<internal::_iter_rep> > s;
 
        void increment()
        {
-               internal::_iter_rep & current = s.top();
-               const ex & child = current.e.op(current.i);
-               size_t n = child.nops();
-               if (n)
-                       s.push(internal::_iter_rep(child, 0, n));
-               else
-                       ++current.i;
-
                while (s.top().i == s.top().i_end && s.size() > 1) {
                        s.pop();
                        ++s.top().i;
                }
+
+               internal::_iter_rep & current = s.top();
+
+               if (current.i != current.i_end) {
+                       const ex & child = current.e.op(current.i);
+                       s.push(internal::_iter_rep(child, 0, child.nops()));
+               }
        }
 };
 
@@ -597,19 +621,21 @@ class const_postorder_iterator : public std::iterator<std::forward_iterator_tag,
 public:
        const_postorder_iterator() throw() {}
 
-       // Provide implicit conversion from const_iterator, so begin() and
-       // end() can be used to create const_postorder_iterators
+       // Provide implicit conversion from const_iterator, so ex::begin() and
+       // ex::end() can be used to create const_postorder_iterators
        const_postorder_iterator(const const_iterator & cit)
        {
-               s.push(internal::_iter_rep(cit.e, cit.i, cit.e.nops()));
-               descend();
+               size_t n = cit.e.nops();
+               if (cit.i != n) {
+                       s.push(internal::_iter_rep(cit.e, cit.i, n));
+                       descend();
+               }
        }
 
 public:
        ex operator*() const
        {
-               const internal::_iter_rep & r = s.top();
-               return r.e.op(r.i);
+               return s.top().e;
        }
 
        std::auto_ptr<ex> operator->() const
@@ -641,12 +667,12 @@ public:
        }
 
 private:
-       std::stack<internal::_iter_rep> s;
+       std::stack<internal::_iter_rep, std::vector<internal::_iter_rep> > s;
 
        void descend()
        {
-               while (s.top().i != s.top().i_end && s.top().e.op(s.top().i).nops() > 0) {
-                       const internal::_iter_rep & current = s.top();
+               while (s.top().i != s.top().i_end) {
+                       internal::_iter_rep & current = s.top();
                        const ex & child = current.e.op(current.i);
                        s.push(internal::_iter_rep(child, 0, child.nops()));
                }
@@ -654,10 +680,12 @@ private:
 
        void increment()
        {
-               ++s.top().i;
-               descend();
-               if (s.top().i == s.top().i_end && s.size() > 1)
+               if (s.top().i == s.top().i_end)
                        s.pop();
+               if (s.size() > 0) {
+                       ++s.top().i;
+                       descend();
+               }
        }
 };
 
@@ -767,11 +795,11 @@ inline ex series(const ex & thisex, const ex & r, int order, unsigned options =
 inline bool match(const ex & thisex, const ex & pattern, lst & repl_lst)
 { return thisex.match(pattern, repl_lst); }
 
-inline ex simplify_indexed(const ex & thisex)
-{ return thisex.simplify_indexed(); }
+inline ex simplify_indexed(const ex & thisex, unsigned options = 0)
+{ return thisex.simplify_indexed(options); }
 
-inline ex simplify_indexed(const ex & thisex, const scalar_products & sp)
-{ return thisex.simplify_indexed(sp); }
+inline ex simplify_indexed(const ex & thisex, const scalar_products & sp, unsigned options = 0)
+{ return thisex.simplify_indexed(sp, options); }
 
 inline ex symmetrize(const ex & thisex)
 { return thisex.symmetrize(); }