X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Frelational.cpp;h=9d50fee22ff787ecac5314b22aaae3bb9b9f6c1d;hp=b22a6387b837e4f0193d01ce5369d1a1dad92eb8;hb=27d6204effdef95a00af461fff98024e290dbaa7;hpb=4e3a4ac2bcb0837611ea31bc8fc05d84a20c33ac diff --git a/ginac/relational.cpp b/ginac/relational.cpp index b22a6387..9d50fee2 100644 --- a/ginac/relational.cpp +++ b/ginac/relational.cpp @@ -24,6 +24,7 @@ #include "relational.h" #include "numeric.h" +#include "print.h" #include "archive.h" #include "utils.h" #include "debugmsg.h" @@ -36,15 +37,11 @@ GINAC_IMPLEMENT_REGISTERED_CLASS(relational, basic) // default ctor, dtor, copy ctor assignment operator and helpers ////////// -// public - relational::relational() : basic(TINFO_relational) { debugmsg("relational default ctor",LOGLEVEL_CONSTRUCT); } -// protected - void relational::copy(const relational & other) { basic::copy(other); @@ -53,10 +50,7 @@ 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 ctors @@ -76,7 +70,6 @@ relational::relational(const ex & lhs, const ex & rhs, operators oper) : basic(T // archiving ////////// -/** Construct object from archive_node. */ relational::relational(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst) { debugmsg("relational ctor from archive_node", LOGLEVEL_CONSTRUCT); @@ -88,13 +81,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); @@ -103,115 +89,53 @@ 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)"; - } - 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 << ")"; -} + if (is_a(c)) { -void relational::printcsrc(std::ostream & os, unsigned type, unsigned upper_precedence) const -{ - debugmsg("relational print csrc", LOGLEVEL_PRINT); - if (precedence<=upper_precedence) - os << "("; + inherited::print(c, level); - // Print left-hand expression - lh.bp->printcsrc(os, type, precedence); + } else { - // Print relational operator - switch (o) { + if (precedence() <= level) + c.s << "("; + lh.print(c, precedence()); + switch (o) { case equal: - os << "=="; + c.s << "=="; break; case not_equal: - os << "!="; + c.s << "!="; break; case less: - os << "<"; + c.s << "<"; break; case less_or_equal: - os << "<="; + c.s << "<="; break; case greater: - os << ">"; + c.s << ">"; break; case greater_or_equal: - os << ">="; + c.s << ">="; break; default: - os << "(INVALID RELATIONAL OPERATOR)"; - break; + c.s << "(INVALID RELATIONAL OPERATOR)"; + } + rh.print(c, precedence()); + if (precedence() <= level) + c.s << ")"; } - - // Print right-hand operator - rh.bp->printcsrc(os, type, precedence); - - if (precedence <= upper_precedence) - os << ")"; } bool relational::info(unsigned inf) const @@ -247,7 +171,7 @@ ex & relational::let_op(int i) return i==0 ? lh : rh; } - + ex relational::eval(int level) const { if (level==1) @@ -259,17 +183,6 @@ ex relational::eval(int level) const 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 -{ - 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); -} - ex relational::simplify_ncmul(const exvector & v) const { return lh.simplify_ncmul(v); @@ -279,22 +192,25 @@ 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; + GINAC_ASSERT(is_exactly_a(other)); + const relational &oth = static_cast(other); if (o == oth.o) { - cmpval = lh.compare(oth.lh); - if (cmpval==0) - return rh.compare(oth.rh); - else + int cmpval = lh.compare(oth.lh); + if (cmpval) return cmpval; + else + return rh.compare(oth.rh); } - if (o(other)); + const relational &oth = static_cast(other); + + return o == oth.o; } unsigned relational::return_type(void) const @@ -329,41 +245,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; + return ex_to(df).is_zero(); case not_equal: - return cmpval!=0; + return !ex_to(df).is_zero(); case less: - return cmpval<0; + return ex_to(df)<_num0; case less_or_equal: - return cmpval<=0; + return ex_to(df)<=_num0; case greater: - return cmpval>0; + return ex_to(df)>_num0; case greater_or_equal: - return cmpval>=0; + return ex_to(df)>=_num0; default: throw(std::logic_error("invalid relational operator")); } } -////////// -// static member variables -////////// - -// protected - -unsigned relational::precedence = 20; - } // namespace GiNaC