X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fexpair.h;h=74744e0213e3d7f1ea65af0936412602fa76ca8a;hp=0a9867750ade0ca86a456bbf78de604f47f83ced;hb=a4294a62590d45ad81e66ce59101982dc83dba51;hpb=9eab44408b9213d8909b7a9e525f404ad06064dd diff --git a/ginac/expair.h b/ginac/expair.h index 0a986775..74744e02 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-2001 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,178 +23,93 @@ #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) - { - 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); - } - - 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; - } - - 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 << ")"; - } - - ex rest; - ex coeff; + expair() : rest(0), coeff(1) { } + ~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; + } + + /** Construct an expair from two ex. */ + expair(const ex & r, const ex & c) : rest(r), coeff(c) + { + GINAC_ASSERT(is_ex_exactly_of_type(coeff,numeric)); + } + + /** 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 + { + os << "expair:"; + print_tree c(os); + rest.print(c, c.delta_indent); + coeff.print(c, c.delta_indent); + } + + /** True if this is of the form (numeric,ex(1)). */ + bool is_canonical_numeric(void) const + { + GINAC_ASSERT(is_ex_exactly_of_type(coeff,numeric)); + return (is_ex_exactly_of_type(rest,numeric) && + (coeff.is_equal(1))); + } + + ex rest; ///< first member of pair, an arbitrary expression + ex coeff; ///< second member of pair, must be numeric }; +/** Function object for insertion into third argument of STL's sort() etc. */ class expair_is_less { public: - bool operator()(expair const & lh, expair const & 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); - } + bool operator()(const expair &lh, const expair &rh) const + { + return lh.is_less(rh); + } }; } // namespace GiNaC