* 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
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;
// 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;
// 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;
}
return e.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
+ // This should return an ex*, but that would be a pointer to a
+ // temporary value
+ std::auto_ptr<ex> operator->() const
{
- return &(operator*());
+ return std::auto_ptr<ex>(new ex(operator*()));
}
-#endif
ex operator[](difference_type n) const
{
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()));
public:
ex operator*() const
{
- const internal::_iter_rep & r = s.top();
- return r.e.op(r.i);
+ return s.top().e;
}
- // operator->() not implemented (see above)
+ std::auto_ptr<ex> operator->() const
+ {
+ return std::auto_ptr<ex>(new ex(operator*()));
+ }
const_preorder_iterator &operator++()
{
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()
}
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()));
+ }
}
};
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;
}
- // operator->() not implemented
+ std::auto_ptr<ex> operator->() const
+ {
+ return std::auto_ptr<ex>(new ex(operator*()));
+ }
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.size() > 0) {
+ ++s.top().i;
+ descend();
+ }
}
};
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(); }
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); }
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(); }
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);
/** 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
git://www.ginac.de / ginac.git / blobdiff