X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fexpair.h;h=4b1a42e859a8f52544806d1d5ce7227405e37b49;hp=dd0459b924f0294241ebb97c0e1f9a7d08df0dd4;hb=073bf40a73e419a3dbcb6dfa190947ce2cc3bdce;hpb=dbb36db8d02b2c25af6bbfff8135112637936e1f diff --git a/ginac/expair.h b/ginac/expair.h index dd0459b9..4b1a42e8 100644 --- a/ginac/expair.h +++ b/ginac/expair.h @@ -3,7 +3,7 @@ * Definition of expression pairs (building blocks of expairseq). */ /* - * GiNaC Copyright (C) 1999-2000 Johannes Gutenberg University Mainz, Germany + * GiNaC Copyright (C) 1999-2011 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 @@ -17,190 +17,104 @@ * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ -#ifndef __GINAC_EXPAIR_H__ -#define __GINAC_EXPAIR_H__ +#ifndef GINAC_EXPAIR_H +#define GINAC_EXPAIR_H #include "ex.h" #include "numeric.h" +#include "print.h" -#ifndef NO_GINAC_NAMESPACE namespace GiNaC { -#endif // ndef NO_GINAC_NAMESPACE /** A pair of expressions. - * This similar to, but slightly extended STL's pair<> but we need to account - * for methods like .compare() */ + * This is similar to STL's pair<>. It is slightly extended since we need to + * account for methods like .compare(). Also, since this is meant for use by + * class expairseq it must satisfy the invariance that the member coeff must + * be of type numeric. */ class expair { public: - expair() {} - ~expair() {} - expair(const expair & other) : rest(other.rest), coeff(other.coeff) - { - GINAC_ASSERT(is_ex_exactly_of_type(coeff,numeric)); - } - const expair & operator=(const expair & other) - { - if (this != &other) { - rest=other.rest; - coeff=other.coeff; - } - return *this; - } - expair(const ex & r, const ex & c) : rest(r), coeff(c) - { - GINAC_ASSERT(is_ex_exactly_of_type(coeff,numeric)); - } - - bool is_numeric_with_coeff_1(void) const - { - GINAC_ASSERT(is_ex_exactly_of_type(coeff,numeric)); - return is_ex_exactly_of_type(rest,numeric) && - (coeff.is_equal(ex(1))); - } - - bool is_equal(const expair & other) const - { - return (rest.is_equal(other.rest) && coeff.is_equal(other.coeff)); - } - bool is_less(const expair & other) const - { - return (rest.compare(other.rest)<0) || - (!(other.rest.compare(rest)<0) && (coeff.compare(other.coeff)<0)); - } - int compare(const expair & other) const - { - int cmpval=rest.compare(other.rest); - if (cmpval!=0) return cmpval; - cmpval=coeff.compare(other.coeff); - return cmpval; - } - - bool is_less_old2(const expair & other) const - { - /* - bool this_numeric_with_coeff_1=is_numeric_with_coeff_1(); - bool other_numeric_with_coeff_1=other.is_numeric_with_coeff_1(); - if (this_numeric_with_coeff_1) { - if (other_numeric_with_coeff_1) { - // both have coeff 1: compare rests - return rest.compare(other.rest)<0; - } - // only this has coeff 1: > - return false; - } else if (other_numeric_with_coeff_1) { - // only other has coeff 1: < - return true; - } - return (rest.compare(other.rest)<0) || - (!(other.rest.compare(rest)<0) && - (coeff.compare(other.coeff)<0)); - */ - if (is_ex_exactly_of_type(rest,numeric) && - is_ex_exactly_of_type(other.rest,numeric)) { - if (coeff.is_equal(ex(1))) { - if ((other.coeff).is_equal(ex(1))) { - // both have coeff 1: compare rests - return rest.compare(other.rest)<0; - } - // only this has coeff 1: > - return false; - } else if ((other.coeff).is_equal(ex(1))) { - // only other has coeff 1: < - return true; - } - // neither has coeff 1: usual compare - } - return (rest.compare(other.rest)<0) || - (!(other.rest.compare(rest)<0) && - (coeff.compare(other.coeff)<0)); - } - int compare_old2(const expair & other) const - { - if (is_ex_exactly_of_type(rest,numeric) && - is_ex_exactly_of_type(other.rest,numeric)) { - if ((coeff).is_equal(ex(1))) { - if ((other.coeff).is_equal(ex(1))) { - // both have coeff 1: compare rests - return rest.compare(other.rest); - } - // only this has coeff 1: > - return 1; - } else if ((other.coeff).is_equal(ex(1))) { - // only other has coeff 1: < - return -1; - } - // neither has coeff 1: usual compare - } - /* - bool this_numeric_with_coeff_1=is_numeric_with_coeff_1(); - bool other_numeric_with_coeff_1=other.is_numeric_with_coeff_1(); - if (this_numeric_with_coeff_1) { - if (other_numeric_with_coeff_1) { - // both have coeff 1: compare rests - return rest.compare(other.rest); - } - // only this has coeff 1: > - return 1; - } else if (other_numeric_with_coeff_1) { - // only other has coeff 1: < - return -1; - // neither has coeff 1: usual compare - } - */ - int cmpval=rest.compare(other.rest); - if (cmpval!=0) return cmpval; - return coeff.compare(other.coeff); - } - bool is_less_old(const expair & other) const - { - return (rest.compare(other.rest)<0) || - (!(other.rest.compare(rest)<0) && (coeff.compare(other.coeff)<0)); - } - int compare_old(const expair & other) const - { - int cmpval=rest.compare(other.rest); - if (cmpval!=0) return cmpval; - cmpval=coeff.compare(other.coeff); - return cmpval; - } - - void printraw(ostream & os) const - { - os << "expair("; - rest.printraw(os); - os << ","; - coeff.printraw(os); - os << ")"; - } - - ex rest; - ex coeff; + expair() : rest(0), coeff(1) { } + + /** Construct an expair from two ex. */ + expair(const ex & r, const ex & c) : rest(r), coeff(c) + { + GINAC_ASSERT(is_exactly_a(coeff)); + } + + /** Member-wise check for canonical ordering equality. */ + bool is_equal(const expair & other) const + { + return (rest.is_equal(other.rest) && coeff.is_equal(other.coeff)); + } + + /** Member-wise check for canonical ordering lessness. */ + bool is_less(const expair & other) const + { + int restcmp = rest.compare(other.rest); + return ((restcmp<0) || + (!(restcmp>0) && (coeff.compare(other.coeff)<0))); + } + + /** Member-wise check for canonical ordering. */ + int compare(const expair & other) const + { + int restcmp = rest.compare(other.rest); + if (restcmp!=0) + return restcmp; + else + return coeff.compare(other.coeff); + } + + void print(std::ostream & os) const; + + /** True if this is of the form (numeric,ex(1)). */ + bool is_canonical_numeric() const + { + GINAC_ASSERT(is_exactly_a(coeff)); + return (is_exactly_a(rest) && (coeff.is_equal(1))); + } + + /** Swap contents with other expair. */ + void swap(expair & other) + { + rest.swap(other.rest); + coeff.swap(other.coeff); + } + + const expair conjugate() const; + + ex rest; ///< first member of pair, an arbitrary expression + ex coeff; ///< second member of pair, must be numeric }; -class expair_is_less -{ -public: - bool operator()(const expair & lh, const expair & rh) const - { - return lh.is_less(rh); - } +/** Function object for insertion into third argument of STL's sort() etc. */ +struct expair_is_less : public std::binary_function { + bool operator()(const expair &lh, const expair &rh) const { return lh.is_less(rh); } }; -class expair_is_less_old -{ -public: - bool operator()(const expair & lh, const expair & rh) const - { - return lh.is_less_old(rh); - } +/** Function object not caring about the numerical coefficients for insertion + * into third argument of STL's sort(). Note that this does not define a + * strict weak ordering since for any symbol x we have neither 3*x<2*x or + * 2*x<3*x. Handle with care! */ +struct expair_rest_is_less : public std::binary_function { + bool operator()(const expair &lh, const expair &rh) const { return (lh.rest.compare(rh.rest)<0); } +}; + +struct expair_swap : public std::binary_function { + void operator()(expair &lh, expair &rh) const { lh.swap(rh); } }; -#ifndef NO_GINAC_NAMESPACE +inline void swap(expair & e1, expair & e2) +{ e1.swap(e2); } + +// This makes STL algorithms use the more efficient swap operation for ex objects +inline void iter_swap(std::vector::iterator i1, std::vector::iterator i2) +{ i1->swap(*i2); } + } // namespace GiNaC -#endif // ndef NO_GINAC_NAMESPACE -#endif // ndef __GINAC_EXPAIR_H__ +#endif // ndef GINAC_EXPAIR_H