X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Frelational.cpp;h=d779c632bd49e5bbf8b5bb236deb2b6980c74c01;hp=8f7b4b65effc7a5d2dba3388b6060998f6e0fde6;hb=0c718e0dda0d2de1224f39ec5e3c39720e0abfc2;hpb=1bd972bf8e4eeeb8aec6081100876e81a7f18450 diff --git a/ginac/relational.cpp b/ginac/relational.cpp index 8f7b4b65..d779c632 100644 --- a/ginac/relational.cpp +++ b/ginac/relational.cpp @@ -3,7 +3,7 @@ * Implementation of relations between expressions */ /* - * GiNaC Copyright (C) 1999-2001 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 @@ -20,32 +20,24 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ +#include #include #include "relational.h" #include "numeric.h" +#include "print.h" #include "archive.h" #include "utils.h" -#include "debugmsg.h" -#ifndef NO_NAMESPACE_GINAC namespace GiNaC { -#endif // ndef NO_NAMESPACE_GINAC GINAC_IMPLEMENT_REGISTERED_CLASS(relational, basic) ////////// -// default constructor, destructor, copy constructor assignment operator and helpers +// default ctor, dtor, copy ctor, assignment operator and helpers ////////// -// public - -relational::relational() : basic(TINFO_relational) -{ - debugmsg("relational default constructor",LOGLEVEL_CONSTRUCT); -} - -// protected +relational::relational() : basic(TINFO_relational) {} void relational::copy(const relational & other) { @@ -55,33 +47,22 @@ void relational::copy(const relational & other) o=other.o; } -void relational::destroy(bool call_parent) -{ - if (call_parent) basic::destroy(call_parent); -} +DEFAULT_DESTROY(relational) ////////// -// other constructors +// other ctors ////////// // public -relational::relational(const ex & lhs, const ex & rhs, operators oper) : basic(TINFO_relational) -{ - debugmsg("relational constructor ex,ex,operator",LOGLEVEL_CONSTRUCT); - lh=lhs; - rh=rhs; - o=oper; -} +relational::relational(const ex & lhs, const ex & rhs, operators oper) : basic(TINFO_relational), lh(lhs), rh(rhs), o(oper) {} ////////// // archiving ////////// -/** Construct object from archive_node. */ relational::relational(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst) { - debugmsg("relational constructor from archive_node", LOGLEVEL_CONSTRUCT); unsigned int opi; if (!(n.find_unsigned("op", opi))) throw (std::runtime_error("unknown relational operator in archive")); @@ -90,13 +71,6 @@ relational::relational(const archive_node &n, const lst &sym_lst) : inherited(n, n.find_ex("rh", rh, sym_lst); } -/** Unarchive the object. */ -ex relational::unarchive(const archive_node &n, const lst &sym_lst) -{ - return (new relational(n, sym_lst))->setflag(status_flags::dynallocated); -} - -/** Archive the object. */ void relational::archive(archive_node &n) const { inherited::archive(n); @@ -105,134 +79,82 @@ void relational::archive(archive_node &n) const n.add_unsigned("op", o); } +DEFAULT_UNARCHIVE(relational) + ////////// -// functions overriding virtual functions from bases classes +// functions overriding virtual functions from base classes ////////// // public -void relational::print(std::ostream & os, unsigned upper_precedence) const +void relational::print(const print_context & c, unsigned level) const { - debugmsg("relational print",LOGLEVEL_PRINT); - if (precedence<=upper_precedence) os << "("; - lh.print(os,precedence); - switch (o) { - case equal: - os << "=="; - break; - case not_equal: - os << "!="; - break; - case less: - os << "<"; - break; - case less_or_equal: - os << "<="; - break; - case greater: - os << ">"; - break; - case greater_or_equal: - os << ">="; - break; - default: - os << "(INVALID RELATIONAL OPERATOR)"; + if (is_a(c)) { + + inherited::print(c, level); + + } else { + + if (is_a(c)) { + c.s << class_name() << '('; + lh.print(c); + c.s << ','; + rh.print(c); + c.s << ",'"; + } else { + if (precedence() <= level) + c.s << "("; + lh.print(c, precedence()); + } + switch (o) { + case equal: + c.s << "=="; + break; + case not_equal: + c.s << "!="; + break; + case less: + c.s << "<"; + break; + case less_or_equal: + c.s << "<="; + break; + case greater: + c.s << ">"; + break; + case greater_or_equal: + c.s << ">="; + break; + default: + c.s << "(INVALID RELATIONAL OPERATOR)"; + } + if (is_a(c)) + c.s << "')"; + else { + rh.print(c, precedence()); + if (precedence() <= level) + c.s << ")"; + } } - rh.print(os,precedence); - if (precedence<=upper_precedence) os << ")"; -} - -void relational::printraw(std::ostream & os) const -{ - debugmsg("relational printraw",LOGLEVEL_PRINT); - os << "RELATIONAL("; - lh.printraw(os); - os << ","; - rh.printraw(os); - os << ","; - switch (o) { - case equal: - os << "=="; - break; - case not_equal: - os << "!="; - break; - case less: - os << "<"; - break; - case less_or_equal: - os << "<="; - break; - case greater: - os << ">"; - break; - case greater_or_equal: - os << ">="; - break; - default: - os << "(INVALID RELATIONAL OPERATOR)"; - } - os << ")"; -} - -void relational::printcsrc(std::ostream & os, unsigned type, unsigned upper_precedence) const -{ - debugmsg("relational print csrc", LOGLEVEL_PRINT); - if (precedence<=upper_precedence) - os << "("; - - // Print left-hand expression - lh.bp->printcsrc(os, type, precedence); - - // Print relational operator - switch (o) { - case equal: - os << "=="; - break; - case not_equal: - os << "!="; - break; - case less: - os << "<"; - break; - case less_or_equal: - os << "<="; - break; - case greater: - os << ">"; - break; - case greater_or_equal: - os << ">="; - break; - default: - os << "(INVALID RELATIONAL OPERATOR)"; - break; - } - - // Print right-hand operator - rh.bp->printcsrc(os, type, precedence); - - if (precedence <= upper_precedence) - os << ")"; } bool relational::info(unsigned inf) const { switch (inf) { - case info_flags::relation: - return 1; - case info_flags::relation_equal: - return o==equal; - case info_flags::relation_not_equal: - return o==not_equal; - case info_flags::relation_less: - return o==less; - case info_flags::relation_less_or_equal: - return o==less_or_equal; - case info_flags::relation_greater: - return o==greater; - case info_flags::relation_greater_or_equal: - return o==greater_or_equal; + case info_flags::relation: + return 1; + case info_flags::relation_equal: + return o==equal; + case info_flags::relation_not_equal: + return o==not_equal; + case info_flags::relation_less: + return o==less; + case info_flags::relation_less_or_equal: + return o==less_or_equal; + case info_flags::relation_greater: + return o==greater; + case info_flags::relation_greater_or_equal: + return o==greater_or_equal; } return 0; } @@ -249,27 +171,27 @@ ex & relational::let_op(int i) return i==0 ? lh : rh; } - + ex relational::eval(int level) const { - if (level==1) { + if (level==1) return this->hold(); - } - if (level == -max_recursion_level) { + + if (level == -max_recursion_level) throw(std::runtime_error("max recursion level reached")); - } + return (new relational(lh.eval(level-1),rh.eval(level-1),o))->setflag(status_flags::dynallocated | status_flags::evaluated); } -ex relational::evalf(int level) const +ex relational::subs(const lst & ls, const lst & lr, bool no_pattern) const { - if (level==1) - return *this; - - if (level==-max_recursion_level) - throw(std::runtime_error("max recursion level reached")); - - return (new relational(lh.eval(level-1),rh.eval(level-1),o))->setflag(status_flags::dynallocated); + const ex & subsed_lh = lh.subs(ls, lr, no_pattern); + const ex & subsed_rh = rh.subs(ls, lr, no_pattern); + + if (!are_ex_trivially_equal(lh, subsed_lh) || !are_ex_trivially_equal(rh, subsed_rh)) + return relational(subsed_lh, subsed_rh, o).basic::subs(ls, lr, no_pattern); + else + return basic::subs(ls, lr, no_pattern); } ex relational::simplify_ncmul(const exvector & v) const @@ -281,22 +203,43 @@ ex relational::simplify_ncmul(const exvector & v) const int relational::compare_same_type(const basic & other) const { - GINAC_ASSERT(is_exactly_of_type(other, relational)); - const relational & oth=static_cast(const_cast(other)); - - int cmpval; - - if (o == oth.o) { - cmpval = lh.compare(oth.lh); - if (cmpval==0) - return rh.compare(oth.rh); - else - return cmpval; + GINAC_ASSERT(is_exactly_a(other)); + const relational &oth = static_cast(other); + if (o==oth.o && lh.is_equal(oth.lh) && rh.is_equal(oth.rh)) + return 0; + switch (o) { + case equal: + case not_equal: + if (oth.o!=o) + return (o < oth.o) ? -1 : 1; + break; + case less: + if (oth.o!=greater) + return (o < oth.o) ? -1 : 1; + break; + case less_or_equal: + if (oth.o!=greater_or_equal) + return (o < oth.o) ? -1 : 1; + break; + case greater: + if (oth.o!=less) + return (o < oth.o) ? -1 : 1; + break; + case greater_or_equal: + if (oth.o!=less_or_equal) + return (o < oth.o) ? -1 : 1; + break; } - if (o(other)); + const relational &oth = static_cast(other); + + return o == oth.o; } unsigned relational::return_type(void) const @@ -311,6 +254,48 @@ unsigned relational::return_type_tinfo(void) const return lh.return_type_tinfo(); } +unsigned relational::calchash(void) const +{ + unsigned v = golden_ratio_hash(tinfo()); + unsigned lhash = lh.gethash(); + unsigned rhash = rh.gethash(); + + v = rotate_left_31(v); + switch(o) { + case equal: + case not_equal: + if (lhash>rhash) { + v ^= lhash; + lhash = rhash; + } else { + v ^= rhash; + } + break; + case less: + case less_or_equal: + v ^= rhash; + break; + case greater: + case greater_or_equal: + v ^= lhash; + lhash = rhash; + break; + } + v = rotate_left_31(v); + v ^= lhash; + + // mask out numeric hashes: + v &= 0x7FFFFFFFU; + + // store calculated hash value only if object is already evaluated + if (flags & status_flags::evaluated) { + setflag(status_flags::hash_calculated); + hashvalue = v; + } + + return v; +} + ////////// // new virtual functions which can be overridden by derived classes ////////// @@ -331,43 +316,34 @@ ex relational::rhs(void) const // non-virtual functions in this class ////////// +/** Cast the relational into a boolean, mainly for evaluation within an + * if-statement. Note that (a=b) == true in + * the general symbolic case. A false result means the comparison is either + * false or undecidable (except of course for !=, where true means either + * unequal or undecidable). */ relational::operator bool() const { - // please note that (a=b) == true - // a false result means the comparison is either false or undecidable - // (except for !=, where true means unequal or undecidable) - ex df = lh-rh; + const ex df = lh-rh; if (!is_ex_exactly_of_type(df,numeric)) // cannot decide on non-numerical results return o==not_equal ? true : false; - int cmpval = ex_to_numeric(df).compare(_num0()); switch (o) { - case equal: - return cmpval==0; - case not_equal: - return cmpval!=0; - case less: - return cmpval<0; - case less_or_equal: - return cmpval<=0; - case greater: - return cmpval>0; - case greater_or_equal: - return cmpval>=0; - default: - throw(std::logic_error("invalid relational operator")); + case equal: + return ex_to(df).is_zero(); + case not_equal: + return !ex_to(df).is_zero(); + case less: + return ex_to(df)<_num0; + case less_or_equal: + return ex_to(df)<=_num0; + case greater: + return ex_to(df)>_num0; + case greater_or_equal: + return ex_to(df)>=_num0; + default: + throw(std::logic_error("invalid relational operator")); } } -////////// -// static member variables -////////// - -// protected - -unsigned relational::precedence=20; - -#ifndef NO_NAMESPACE_GINAC } // namespace GiNaC -#endif // ndef NO_NAMESPACE_GINAC