* 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
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 &);
// 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 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;
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;
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 &>
-{
+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;
} // namespace internal
-class const_preorder_iterator : public std::iterator<std::forward_iterator_tag, ex, ptrdiff_t, const ex *, const ex &>
-{
+class const_preorder_iterator : public std::iterator<std::forward_iterator_tag, ex, ptrdiff_t, const ex *, const ex &> {
public:
const_preorder_iterator() throw() {}
- // Provide implicit conversion from const_iterator, so begin() and
- // end() can be used to create const_preorder_iterators
- const_preorder_iterator(const const_iterator & cit)
+ const_preorder_iterator(const ex &e, size_t n)
{
- s.push(internal::_iter_rep(cit.e, cit.i, cit.e.nops()));
+ s.push(internal::_iter_rep(e, 0, n));
}
public:
- ex operator*() const
+ reference 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
+ pointer operator->() const
{
- return std::auto_ptr<ex>(new ex(operator*()));
+ return &(s.top().e);
}
const_preorder_iterator &operator++()
}
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) {
+ 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 &>
-{
+class const_postorder_iterator : public std::iterator<std::forward_iterator_tag, ex, ptrdiff_t, const ex *, const ex &> {
public:
const_postorder_iterator() throw() {}
- // Provide implicit conversion from const_iterator, so begin() and
- // end() can be used to create const_postorder_iterators
- const_postorder_iterator(const const_iterator & cit)
+ const_postorder_iterator(const ex &e, size_t n)
{
- s.push(internal::_iter_rep(cit.e, cit.i, cit.e.nops()));
+ s.push(internal::_iter_rep(e, 0, n));
descend();
}
public:
- ex operator*() const
+ reference 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
+ pointer operator->() const
{
- return std::auto_ptr<ex>(new ex(operator*()));
+ return &(s.top().e);
}
const_postorder_iterator &operator++()
}
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()));
}
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.empty()) {
+ ++s.top().i;
+ descend();
+ }
}
};
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();
+}
+
// utility functions
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); }
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(); }
git://www.ginac.de / ginac.git / blobdiff