X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fexpair.h;h=94b3065a954b6750d3148f6289b71b8e8b8c133d;hp=3f98d4127d80e8a15a4282e07bf4e1c8d86974ae;hb=8cffcdf13d817a47f217f1a1043317d95969e070;hpb=a8507b8af1c08d9b27d98d57f95c7ca1a8671e27 diff --git a/ginac/expair.h b/ginac/expair.h index 3f98d412..94b3065a 100644 --- a/ginac/expair.h +++ b/ginac/expair.h @@ -1,6 +1,9 @@ /** @file expair.h * - * GiNaC Copyright (C) 1999 Johannes Gutenberg University Mainz, Germany + * Definition of expression pairs (building blocks of expairseq). */ + +/* + * GiNaC Copyright (C) 1999-2019 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 @@ -14,177 +17,100 @@ * * 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 + +#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) - { - 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) - { - ASSERT(is_ex_exactly_of_type(coeff,numeric)); - } - - bool is_numeric_with_coeff_1(void) const - { - 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; - } + /** Swap contents with other expair. */ + void swap(expair & other) + { + rest.swap(other.rest); + coeff.swap(other.coeff); + } - void printraw(ostream & os) const - { - os << "expair("; - rest.printraw(os); - os << ","; - coeff.printraw(os); - os << ")"; - } + const expair conjugate() const; - ex rest; - ex coeff; + 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()(expair const & lh, expair const & rh) const - { - return lh.is_less(rh); - } +/** Function object for insertion into third argument of STL's sort() etc. */ +struct expair_is_less { + bool operator()(const expair &lh, const expair &rh) const { return lh.is_less(rh); } }; -class expair_is_less_old -{ -public: - bool operator()(expair const & lh, expair const & 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 { + bool operator()(const expair &lh, const expair &rh) const { return (lh.rest.compare(rh.rest)<0); } }; +struct expair_swap { + void operator()(expair &lh, expair &rh) const { lh.swap(rh); } +}; + +inline void swap(expair & e1, expair & e2) +{ e1.swap(e2); } + +} // namespace GiNaC - +#endif // ndef GINAC_EXPAIR_H