X-Git-Url: https://ginac.de/ginac.git//ginac.git?a=blobdiff_plain;ds=sidebyside;f=ginac%2Fex.h;h=1c1e799d577d2c4a2616ce0b26db35c6fccfee72;hb=c3bfa19e36bcff8f103651547e5ea4d83599bdb4;hp=ee891a2fb9c431e0c66f7440a00ad5bc74c6e654;hpb=c69b9bb178e6445aae2cc19b2f188875a16e476b;p=ginac.git

diff --git a/ginac/ex.h b/ginac/ex.h
index ee891a2f..1c1e799d 100644
--- 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
@@ -26,6 +26,7 @@
 #include <iosfwd>
 #include <iterator>
 #include <functional>
+#include <stack>
 
 #include "basic.h"
 #include "ptr.h"
@@ -53,14 +54,16 @@ static library_init library_initializer;
 
 
 class scalar_products;
+class const_iterator;
+class const_preorder_iterator;
+class const_postorder_iterator;
 
 
 /** Lightweight wrapper for GiNaC's symbolic objects.  Basically all it does is
  *  to hold a pointer to the other objects, manage the reference counting and
  *  provide methods for manipulation of these objects.  (Some people call such
  *  a thing a proxy class.) */
-class ex
-{
+class ex {
 	friend class archive_node;
 	friend inline bool are_ex_trivially_equal(const ex &, const ex &);
 	template<class T> friend inline const T &ex_to(const ex &);
@@ -69,7 +72,7 @@ class 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);
@@ -91,154 +94,30 @@ public:
 	ex(const std::string &s, const ex &l);
 	
 public:
-	// Iterators
-	class const_iterator : public std::iterator<std::random_access_iterator_tag, ex, ptrdiff_t, const ex *, const ex &>
-	{
-		friend class ex;
-
-	public:
-		const_iterator() {}
-		const_iterator(const basic *bp_, size_t i_) : bp(bp_), i(i_) {}
-
-		bool operator==(const const_iterator &other) const
-		{
-			return bp == other.bp && i == other.i;
-		}
-
-		bool operator!=(const const_iterator &other) const
-		{
-			return !(*this == other);
-		}
-
-		bool operator<(const const_iterator &other) const
-		{
-			return i < other.i;
-		}
-
-		bool operator>(const const_iterator &other) const
-		{
-			return other < *this;
-		}
-
-		bool operator<=(const const_iterator &other) const
-		{
-			return !(other < *this);
-		}
-
-		bool operator>=(const const_iterator &other) const
-		{
-			return !(*this < other);
-		}
-
-		// This should return an ex&, but that would be a reference to a
-		// temporary value
-		ex operator*() const
-		{
-			return bp->op(i);
-		}
-
-#if 0
-		// How do we make this work in the context of the "reference to
-		// temporary" problem? Return an auto_ptr?
-		pointer operator->() const
-		{
-			return &(operator*());
-		}
-#endif
-
-		const_iterator &operator++()
-		{
-			++i;
-			return *this;
-		}
-
-		const_iterator operator++(int)
-		{
-			const_iterator tmp = *this;
-			++i;
-			return tmp;
-		}
-
-		const_iterator &operator+=(difference_type n)
-		{
-			i += n;
-			return *this;
-		}
-
-		const_iterator operator+(difference_type n) const
-		{
-			return const_iterator(bp, i + n);
-		}
-
-		inline friend const_iterator operator+(difference_type n, const const_iterator &it)
-		{
-			return const_iterator(it.bp, it.i + n);
-		}
-
-		const_iterator &operator--()
-		{
-			--i;
-			return *this;
-		}
-
-		const_iterator operator--(int)
-		{
-			const_iterator tmp = *this;
-			--i;
-			return tmp;
-		}
-
-		const_iterator &operator-=(difference_type n)
-		{
-			i -= n;
-			return *this;
-		}
-
-		const_iterator operator-(difference_type n) const
-		{
-			return const_iterator(bp, i - n);
-		}
-
-		inline friend difference_type operator-(const const_iterator &lhs, const const_iterator &rhs)
-		{
-			return lhs.i - rhs.i;
-		}
-
-		reference operator[](difference_type n) const
-		{
-		}
-
-	protected:
-		const basic *bp;
-		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()); }
-
-#if 0
-	// This doesn't work because of the "reference to temporary" problem
-	// in operator*()
-	typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-	const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
-	const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
-#endif
-
 	// 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);
 		bp.swap(other.bp);
 	}
 
+	// iterators
+	const_iterator begin() const throw();
+	const_iterator end() const throw();
+	const_preorder_iterator preorder_begin() const;
+	const_preorder_iterator preorder_end() const throw();
+	const_postorder_iterator postorder_begin() const;
+	const_postorder_iterator postorder_end() const throw();
+
 	// evaluation
 	ex eval(int level = 0) const { return bp->eval(level); }
 	ex evalf(int level = 0) const { return bp->evalf(level); }
 	ex evalm() const { return bp->evalm(); }
 	ex eval_ncmul(const exvector & v) const { return bp->eval_ncmul(v); }
+	ex eval_integ() const { return bp->eval_integ(); }
 
 	// printing
 	void print(const print_context & c, unsigned level = 0) const;
@@ -259,6 +138,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;
@@ -297,8 +179,10 @@ public:
 
 	// rational functions
 	ex normal(int level = 0) const;
-	ex to_rational(lst &repl_lst) const;
-	ex to_polynomial(lst &repl_lst) const;
+	ex to_rational(exmap & repl) const;
+	ex to_rational(lst & repl_lst) const;
+	ex to_polynomial(exmap & repl) const;
+	ex to_polynomial(lst & repl_lst) const;
 	ex numer() const;
 	ex denom() const;
 	ex numer_denom() const;
@@ -309,13 +193,14 @@ public:
 	numeric integer_content() const;
 	ex primpart(const ex &x) const;
 	ex primpart(const ex &x, const ex &cont) const;
+	void unitcontprim(const ex &x, ex &u, ex &c, ex &p) const;
 	ex smod(const numeric &xi) const { return bp->smod(xi); }
 	numeric max_coefficient() const;
 
 	// 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;
@@ -387,7 +272,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
@@ -480,24 +365,357 @@ 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;
+}
+
+
+// Iterators
+
+class const_iterator : public std::iterator<std::random_access_iterator_tag, ex, ptrdiff_t, const ex *, const ex &> {
+	friend class ex;
+	friend class const_preorder_iterator;
+	friend class const_postorder_iterator;
+
+public:
+	const_iterator() throw() {}
+
+private:
+	const_iterator(const ex &e_, size_t i_) throw() : e(e_), i(i_) {}
+
+public:
+	// This should return an ex&, but that would be a reference to a
+	// temporary value
+	ex operator*() const
+	{
+		return e.op(i);
+	}
+
+	// This should return an ex*, but that would be a pointer to a
+	// temporary value
+	std::auto_ptr<ex> operator->() const
+	{
+		return std::auto_ptr<ex>(new ex(operator*()));
+	}
+
+	ex operator[](difference_type n) const
+	{
+		return e.op(i + n);
+	}
+
+	const_iterator &operator++() throw()
+	{
+		++i;
+		return *this;
+	}
+
+	const_iterator operator++(int) throw()
+	{
+		const_iterator tmp = *this;
+		++i;
+		return tmp;
+	}
+
+	const_iterator &operator+=(difference_type n) throw()
+	{
+		i += n;
+		return *this;
+	}
+
+	const_iterator operator+(difference_type n) const throw()
+	{
+		return const_iterator(e, i + n);
+	}
+
+	inline friend const_iterator operator+(difference_type n, const const_iterator &it) throw()
+	{
+		return const_iterator(it.e, it.i + n);
+	}
+
+	const_iterator &operator--() throw()
+	{
+		--i;
+		return *this;
+	}
+
+	const_iterator operator--(int) throw()
+	{
+		const_iterator tmp = *this;
+		--i;
+		return tmp;
+	}
+
+	const_iterator &operator-=(difference_type n) throw()
+	{
+		i -= n;
+		return *this;
+	}
+
+	const_iterator operator-(difference_type n) const throw()
+	{
+		return const_iterator(e, i - n);
+	}
+
+	inline friend difference_type operator-(const const_iterator &lhs, const const_iterator &rhs) throw()
+	{
+		return lhs.i - rhs.i;
+	}
+
+	bool operator==(const const_iterator &other) const throw()
+	{
+		return are_ex_trivially_equal(e, other.e) && i == other.i;
+	}
+
+	bool operator!=(const const_iterator &other) const throw()
+	{
+		return !(*this == other);
+	}
+
+	bool operator<(const const_iterator &other) const throw()
+	{
+		return i < other.i;
+	}
+
+	bool operator>(const const_iterator &other) const throw()
+	{
+		return other < *this;
+	}
+
+	bool operator<=(const const_iterator &other) const throw()
+	{
+		return !(other < *this);
+	}
+
+	bool operator>=(const const_iterator &other) const throw()
+	{
+		return !(*this < other);
+	}
+
+protected:
+	ex e; // this used to be a "const basic *", but in view of object fusion that wouldn't be safe
+	size_t i;
+};
+
+namespace internal {
+
+struct _iter_rep {
+	_iter_rep(const ex &e_, size_t i_, size_t i_end_) : e(e_), i(i_), i_end(i_end_) {}
+
+	bool operator==(const _iter_rep &other) const throw()
+	{
+		return are_ex_trivially_equal(e, other.e) && i == other.i;
+	}
+
+	bool operator!=(const _iter_rep &other) const throw()
+	{
+		return !(*this == other);
+	}
+
+	ex e;
+	size_t i;
+	size_t i_end;
+};
+
+} // namespace internal
+
+class const_preorder_iterator : public std::iterator<std::forward_iterator_tag, ex, ptrdiff_t, const ex *, const ex &> {
+public:
+	const_preorder_iterator() throw() {}
+
+	const_preorder_iterator(const ex &e, size_t n)
+	{
+		s.push(internal::_iter_rep(e, 0, n));
+	}
+
+public:
+	reference operator*() const
+	{
+		return s.top().e;
+	}
+
+	pointer operator->() const
+	{
+		return &(s.top().e);
+	}
+
+	const_preorder_iterator &operator++()
+	{
+		increment();
+		return *this;
+	}
+
+	const_preorder_iterator operator++(int)
+	{
+		const_preorder_iterator tmp = *this;
+		increment();
+		return tmp;
+	}
+
+	bool operator==(const const_preorder_iterator &other) const throw()
+	{
+		return s == other.s;
+	}
+
+	bool operator!=(const const_preorder_iterator &other) const throw()
+	{
+		return !(*this == other);
+	}
+
+private:
+	std::stack<internal::_iter_rep, std::vector<internal::_iter_rep> > s;
+
+	void increment()
+	{
+		while (!s.empty() && s.top().i == s.top().i_end) {
+			s.pop();
+			if (s.empty())
+				return;
+			++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()));
+		}
+	}
+};
+
+class const_postorder_iterator : public std::iterator<std::forward_iterator_tag, ex, ptrdiff_t, const ex *, const ex &> {
+public:
+	const_postorder_iterator() throw() {}
+
+	const_postorder_iterator(const ex &e, size_t n)
+	{
+		s.push(internal::_iter_rep(e, 0, n));
+		descend();
+	}
+
+public:
+	reference operator*() const
+	{
+		return s.top().e;
+	}
+
+	pointer operator->() const
+	{
+		return &(s.top().e);
+	}
+
+	const_postorder_iterator &operator++()
+	{
+		increment();
+		return *this;
+	}
+
+	const_postorder_iterator operator++(int)
+	{
+		const_postorder_iterator tmp = *this;
+		increment();
+		return tmp;
+	}
+
+	bool operator==(const const_postorder_iterator &other) const throw()
+	{
+		return s == other.s;
+	}
+
+	bool operator!=(const const_postorder_iterator &other) const throw()
+	{
+		return !(*this == other);
+	}
+
+private:
+	std::stack<internal::_iter_rep, std::vector<internal::_iter_rep> > s;
+
+	void descend()
+	{
+		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()));
+		}
+	}
+
+	void increment()
+	{
+		if (s.top().i == s.top().i_end)
+			s.pop();
+		if (!s.empty()) {
+			++s.top().i;
+			descend();
+		}
+	}
+};
+
+inline const_iterator ex::begin() const throw()
+{
+	return const_iterator(*this, 0);
+}
+
+inline const_iterator ex::end() const throw()
+{
+	return const_iterator(*this, nops());
+}
+
+inline const_preorder_iterator ex::preorder_begin() const
+{
+	return const_preorder_iterator(*this, nops());
+}
+
+inline const_preorder_iterator ex::preorder_end() const throw()
+{
+	return const_preorder_iterator();
+}
+
+inline const_postorder_iterator ex::postorder_begin() const
+{
+	return const_postorder_iterator(*this, nops());
+}
+
+inline const_postorder_iterator ex::postorder_end() const throw()
+{
+	return const_postorder_iterator();
 }
 
 
@@ -512,6 +730,23 @@ inline bool are_ex_trivially_equal(const ex &e1, const ex &e2)
 	return e1.bp == e2.bp;
 }
 
+/* Function objects for STL sort() etc. */
+struct ex_is_less : public std::binary_function<ex, ex, bool> {
+	bool operator() (const ex &lh, const ex &rh) const { return lh.compare(rh) < 0; }
+};
+
+struct ex_is_equal : public std::binary_function<ex, ex, bool> {
+	bool operator() (const ex &lh, const ex &rh) const { return lh.is_equal(rh); }
+};
+
+struct op0_is_equal : public std::binary_function<ex, ex, bool> {
+	bool operator() (const ex &lh, const ex &rh) const { return lh.op(0).is_equal(rh.op(0)); }
+};
+
+struct ex_swap : public std::binary_function<ex, ex, void> {
+	void operator() (ex &lh, ex &rh) const { lh.swap(rh); }
+};
+
 // wrapper functions around member functions
 inline size_t nops(const ex & thisex)
 { return thisex.nops(); }
@@ -519,6 +754,9 @@ inline size_t nops(const ex & thisex)
 inline ex expand(const ex & thisex, unsigned options = 0)
 { return thisex.expand(options); }
 
+inline ex conjugate(const ex & thisex)
+{ return thisex.conjugate(); }
+
 inline bool has(const ex & thisex, const ex & pattern)
 { return thisex.has(pattern); }
 
@@ -549,6 +787,12 @@ inline ex normal(const ex & thisex, int level=0)
 inline ex to_rational(const ex & thisex, lst & repl_lst)
 { return thisex.to_rational(repl_lst); }
 
+inline ex to_rational(const ex & thisex, exmap & repl)
+{ return thisex.to_rational(repl); }
+
+inline ex to_polynomial(const ex & thisex, exmap & repl)
+{ return thisex.to_polynomial(repl); }
+
 inline ex to_polynomial(const ex & thisex, lst & repl_lst)
 { return thisex.to_polynomial(repl_lst); }
 
@@ -564,6 +808,9 @@ inline ex evalf(const ex & thisex, int level = 0)
 inline ex evalm(const ex & thisex)
 { return thisex.evalm(); }
 
+inline ex eval_integ(const ex & thisex)
+{ return thisex.eval_integ(); }
+
 inline ex diff(const ex & thisex, const symbol & s, unsigned nth = 1)
 { return thisex.diff(s, nth); }
 
@@ -573,11 +820,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(); }
@@ -612,23 +859,6 @@ inline bool is_zero(const ex & thisex)
 inline void swap(ex & e1, ex & e2)
 { e1.swap(e2); }
 
-/* Function objects for STL sort() etc. */
-struct ex_is_less : public std::binary_function<ex, ex, bool> {
-	bool operator() (const ex &lh, const ex &rh) const { return lh.compare(rh) < 0; }
-};
-
-struct ex_is_equal : public std::binary_function<ex, ex, bool> {
-	bool operator() (const ex &lh, const ex &rh) const { return lh.is_equal(rh); }
-};
-
-struct op0_is_equal : public std::binary_function<ex, ex, bool> {
-	bool operator() (const ex &lh, const ex &rh) const { return lh.op(0).is_equal(rh.op(0)); }
-};
-
-struct ex_swap : public std::binary_function<ex, ex, void> {
-	void operator() (ex &lh, ex &rh) const { lh.swap(rh); }
-};
-
 inline ex ex::subs(const exmap & m, unsigned options) const
 {
 	return bp->subs(m, options);
@@ -711,7 +941,9 @@ inline bool is_exactly_a(const ex &obj)
 /** Return a reference to the basic-derived class T object embedded in an
  *  expression.  This is fast but unsafe: the result is undefined if the
  *  expression does not contain a T object at its top level.  Hence, you
- *  should generally check the type of e first.
+ *  should generally check the type of e first.  Also, you shouldn't cache
+ *  the returned reference because GiNaC's garbage collector may destroy
+ *  the referenced object any time it's used in another expression.
  *
  *  @param e expression
  *  @return reference to object of class T