X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fexpair.h;h=2610e8fa47e3e0ec3e4fa3525aeb46f6cf54084f;hp=320de73eb78186786177728ed379d472be177aae;hb=eefedc70f63222beca918a3df89cabac700df1eb;hpb=24fe247f9ed16114a765a01c593fec5c4a2f591c diff --git a/ginac/expair.h b/ginac/expair.h index 320de73e..2610e8fa 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 Johannes Gutenberg University Mainz, Germany + * GiNaC Copyright (C) 1999-2003 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 @@ -23,180 +23,96 @@ #ifndef __GINAC_EXPAIR_H__ #define __GINAC_EXPAIR_H__ -#include -#include +#include "ex.h" +#include "numeric.h" +#include "print.h" namespace GiNaC { /** 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(expair const & other) : rest(other.rest), coeff(other.coeff) - { - GINAC_ASSERT(is_ex_exactly_of_type(coeff,numeric)); - } - expair const & operator=(expair const & other) - { - if (this != &other) { - rest=other.rest; - coeff=other.coeff; - } - return *this; - } - expair(ex const & r, ex const & 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) && - (ex_to_numeric(coeff).compare(numONE())==0); - } + expair() : rest(0), coeff(1) { } - bool is_equal(expair const & other) const - { - return (rest.is_equal(other.rest) && coeff.is_equal(other.coeff)); - } - bool is_less(expair const & other) const - { - return (rest.compare(other.rest)<0) || - (!(other.rest.compare(rest)<0) && (coeff.compare(other.coeff)<0)); - } - int compare(expair const & other) const - { - int cmpval=rest.compare(other.rest); - if (cmpval!=0) return cmpval; - cmpval=coeff.compare(other.coeff); - return cmpval; - } + /** 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))); + } - bool is_less_old2(expair const & 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 (ex_to_numeric(coeff).compare(numONE())==0) { - if (ex_to_numeric(other.coeff).compare(numONE())==0) { - // both have coeff 1: compare rests - return rest.compare(other.rest)<0; - } - // only this has coeff 1: > - return false; - } else if (ex_to_numeric(other.coeff).compare(numONE())==0) { - // 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(expair const & other) const - { - if (is_ex_exactly_of_type(rest,numeric) && - is_ex_exactly_of_type(other.rest,numeric)) { - if (ex_to_numeric(coeff).compare(numONE())==0) { - if (ex_to_numeric(other.coeff).compare(numONE())==0) { - // both have coeff 1: compare rests - return rest.compare(other.rest); - } - // only this has coeff 1: > - return 1; - } else if (ex_to_numeric(other.coeff).compare(numONE())==0) { - // 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(expair const & other) const - { - return (rest.compare(other.rest)<0) || - (!(other.rest.compare(rest)<0) && (coeff.compare(other.coeff)<0)); - } - int compare_old(expair const & 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 << ")"; - } + /** Swap contents with other expair. */ + void swap(expair & other) + { + rest.swap(other.rest); + coeff.swap(other.coeff); + } + + ex rest; ///< first member of pair, an arbitrary expression + ex coeff; ///< second member of pair, must be numeric +}; - ex rest; - ex coeff; +/** 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 -{ -public: - bool operator()(expair const & lh, expair const & rh) const - { - return lh.is_less(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); } }; -class expair_is_less_old -{ -public: - bool operator()(expair const & lh, expair const & rh) const - { - return lh.is_less_old(rh); - } +struct expair_swap : public std::binary_function { + void operator()(expair &lh, expair &rh) const { lh.swap(rh); } }; +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 __GINAC_EXPAIR_H__