* Oops, forgot to cvs add the two new files in last commit.

[ginac.git] / ginac / ex.h

diff --git a/ginac/ex.h b/ginac/ex.h
index 1f4ead98ddf358ab1d3012bb960150e0b0722ce1..70ce112dd799690cbfe73e04fa54b68d2924a4fb 100644 (file)
--- a/ginac/ex.h
+++ b/ginac/ex.h
@@ -62,14 +62,14 @@ class scalar_products;
 class ex
 {
        friend class archive_node;
-       friend bool are_ex_trivially_equal(const ex &, const ex &);
-       template<class T> friend const T &ex_to(const ex &);
-       template<class T> friend bool is_a(const ex &);
-       template<class T> friend bool is_exactly_a(const ex &);
+       friend inline bool are_ex_trivially_equal(const ex &, const ex &);
+       template<class T> friend inline const T &ex_to(const ex &);
+       template<class T> friend inline bool is_a(const ex &);
+       template<class T> friend inline bool is_exactly_a(const ex &);
        
        // default constructor, copy constructor and assignment operator
 public:
-       ex();
+       ex() throw();
 #ifdef OBSCURE_CINT_HACK
        ex(const ex & other);
        ex & operator=(const ex & other);
@@ -97,35 +97,35 @@ public:
                friend class ex;
 
        public:
-               const_iterator() {}
-               const_iterator(const basic *bp_, size_t i_) : bp(bp_), i(i_) {}
+               const_iterator() throw() {}
+               const_iterator(const basic *bp_, size_t i_) throw() : bp(bp_), i(i_) {}
 
-               bool operator==(const const_iterator &other) const
+               bool operator==(const const_iterator &other) const throw()
                {
                        return bp == other.bp && i == other.i;
                }
 
-               bool operator!=(const const_iterator &other) const
+               bool operator!=(const const_iterator &other) const throw()
                {
                        return !(*this == other);
                }
 
-               bool operator<(const const_iterator &other) const
+               bool operator<(const const_iterator &other) const throw()
                {
                        return i < other.i;
                }
 
-               bool operator>(const const_iterator &other) const
+               bool operator>(const const_iterator &other) const throw()
                {
                        return other < *this;
                }
 
-               bool operator<=(const const_iterator &other) const
+               bool operator<=(const const_iterator &other) const throw()
                {
                        return !(other < *this);
                }
 
-               bool operator>=(const const_iterator &other) const
+               bool operator>=(const const_iterator &other) const throw()
                {
                        return !(*this < other);
                }
@@ -146,66 +146,67 @@ public:
                }
 #endif
 
-               const_iterator &operator++()
+               const_iterator &operator++() throw()
                {
                        ++i;
                        return *this;
                }
 
-               const_iterator operator++(int)
+               const_iterator operator++(int) throw()
                {
                        const_iterator tmp = *this;
                        ++i;
                        return tmp;
                }
 
-               const_iterator &operator+=(difference_type n)
+               const_iterator &operator+=(difference_type n) throw()
                {
                        i += n;
                        return *this;
                }
 
-               const_iterator operator+(difference_type n) const
+               const_iterator operator+(difference_type n) const throw()
                {
                        return const_iterator(bp, i + n);
                }
 
-               inline friend const_iterator operator+(difference_type n, const const_iterator &it)
+               inline friend const_iterator operator+(difference_type n, const const_iterator &it) throw()
                {
                        return const_iterator(it.bp, it.i + n);
                }
 
-               const_iterator &operator--()
+               const_iterator &operator--() throw()
                {
                        --i;
                        return *this;
                }
 
-               const_iterator operator--(int)
+               const_iterator operator--(int) throw()
                {
                        const_iterator tmp = *this;
                        --i;
                        return tmp;
                }
 
-               const_iterator &operator-=(difference_type n)
+               const_iterator &operator-=(difference_type n) throw()
                {
                        i -= n;
                        return *this;
                }
 
-               const_iterator operator-(difference_type n) const
+               const_iterator operator-(difference_type n) const throw()
                {
                        return const_iterator(bp, i - n);
                }
 
-               inline friend difference_type operator-(const const_iterator &lhs, const const_iterator &rhs)
+               inline friend difference_type operator-(const const_iterator &lhs, const const_iterator &rhs) throw()
                {
                        return lhs.i - rhs.i;
                }
 
-               reference operator[](difference_type n) const
+               ex operator[](difference_type n) const
                {
+                       return bp->op(i + n);
                }
 
        protected:
@@ -213,8 +214,8 @@ public:
                size_t i;
        };
 
-       const_iterator begin() const { return const_iterator(get_pointer(bp), 0); }
-       const_iterator end() const { return const_iterator(get_pointer(bp), bp->nops()); }
+       const_iterator begin() const throw() { return const_iterator(get_pointer(bp), 0); }
+       const_iterator end() const throw() { return const_iterator(get_pointer(bp), bp->nops()); }
 
 #if 0
        // This doesn't work because of the "reference to temporary" problem
@@ -227,7 +228,7 @@ public:
        // non-virtual functions in this class
 public:
        /** Efficiently swap the contents of two expressions. */
-       void swap(ex & other)
+       void swap(ex & other) throw()
        {
                GINAC_ASSERT(bp->flags & status_flags::dynallocated);
                GINAC_ASSERT(other.bp->flags & status_flags::dynallocated);
@@ -304,11 +305,11 @@ public:
        ex numer_denom() const;
 
        // polynomial algorithms
-       ex unit(const symbol &x) const;
-       ex content(const symbol &x) const;
+       ex unit(const ex &x) const;
+       ex content(const ex &x) const;
        numeric integer_content() const;
-       ex primpart(const symbol &x) const;
-       ex primpart(const symbol &x, const ex &cont) const;
+       ex primpart(const ex &x) const;
+       ex primpart(const ex &x, const ex &cont) const;
        ex smod(const numeric &xi) const { return bp->smod(xi); }
        numeric max_coefficient() const;
 
@@ -345,6 +346,7 @@ private:
        static basic & construct_from_double(double d);
        static ptr<basic> construct_from_string_and_lst(const std::string &s, const ex &l);
        void makewriteable();
+       void share(const ex & other) const;
 
 #ifdef OBSCURE_CINT_HACK
 public:
@@ -368,7 +370,7 @@ protected:
 // member variables
 
 private:
-       ptr<basic> bp;      ///< pointer to basic object managed by this
+       mutable ptr<basic> bp;  ///< pointer to basic object managed by this
 
 #ifdef OBSCURE_CINT_HACK
 public:
@@ -386,7 +388,7 @@ public:
 extern const basic *_num0_bp;
 
 inline
-ex::ex() : bp(*const_cast<basic *>(_num0_bp))
+ex::ex() throw() : bp(*const_cast<basic *>(_num0_bp))
 {
        GINAC_ASSERT(bp->flags & status_flags::dynallocated);
 #ifdef OBSCURE_CINT_HACK
@@ -481,7 +483,14 @@ int ex::compare(const ex & other) const
 {
        if (bp == other.bp)  // trivial case: both expressions point to same basic
                return 0;
-       return bp->compare(*other.bp);
+       const int cmpval = bp->compare(*other.bp);
+       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.
+               share(other);
+       }
+       return cmpval;
 }
 
 inline