X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Frelational.cpp;h=c4e34ddfd34ca44958e37632d6e041969f08680b;hp=76652e980198a65a483632ce07b5614d55f9ff42;hb=5041748e650b3a2da73ae6128c83f88698d38dcf;hpb=24fe247f9ed16114a765a01c593fec5c4a2f591c diff --git a/ginac/relational.cpp b/ginac/relational.cpp index 76652e98..c4e34ddf 100644 --- a/ginac/relational.cpp +++ b/ginac/relational.cpp @@ -3,7 +3,7 @@ * Implementation of relations between expressions */ /* - * 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 @@ -24,244 +24,255 @@ #include "relational.h" #include "numeric.h" +#include "print.h" +#include "archive.h" +#include "utils.h" #include "debugmsg.h" 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); -} - -relational::~relational() -{ - debugmsg("relational destructor",LOGLEVEL_DESTRUCT); - destroy(0); + debugmsg("relational default ctor",LOGLEVEL_CONSTRUCT); } -relational::relational(relational const & other) +void relational::copy(const relational & other) { - debugmsg("relational copy constructor",LOGLEVEL_CONSTRUCT); - copy(other); + basic::copy(other); + lh=other.lh; + rh=other.rh; + o=other.o; } -relational const & relational::operator=(relational const & other) -{ - debugmsg("relational operator=",LOGLEVEL_ASSIGNMENT); - if (this != &other) { - destroy(1); - copy(other); - } - return *this; -} +DEFAULT_DESTROY(relational) -// protected +////////// +// other ctors +////////// -void relational::copy(relational const & other) -{ - basic::copy(other); - lh=other.lh; - rh=other.rh; - o=other.o; -} +// public -void relational::destroy(bool call_parent) +relational::relational(const ex & lhs, const ex & rhs, operators oper) : basic(TINFO_relational) { - if (call_parent) basic::destroy(call_parent); + debugmsg("relational ctor ex,ex,operator",LOGLEVEL_CONSTRUCT); + lh=lhs; + rh=rhs; + o=oper; } ////////// -// other constructors +// archiving ////////// -// public +relational::relational(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst) +{ + debugmsg("relational ctor from archive_node", LOGLEVEL_CONSTRUCT); + unsigned int opi; + if (!(n.find_unsigned("op", opi))) + throw (std::runtime_error("unknown relational operator in archive")); + o = (operators)opi; + n.find_ex("lh", lh, sym_lst); + n.find_ex("rh", rh, sym_lst); +} -relational::relational(ex const & lhs, ex const & rhs, operators oper) : basic(TINFO_relational) +void relational::archive(archive_node &n) const { - debugmsg("relational constructor ex,ex,operator",LOGLEVEL_CONSTRUCT); - lh=lhs; - rh=rhs; - o=oper; + inherited::archive(n); + n.add_ex("lh", lh); + n.add_ex("rh", rh); + n.add_unsigned("op", o); } +DEFAULT_UNARCHIVE(relational) + ////////// -// functions overriding virtual functions from bases classes +// functions overriding virtual functions from base classes ////////// // public -basic * relational::duplicate() const +void relational::print(const print_context & c, unsigned level) const { - debugmsg("relational duplicate",LOGLEVEL_DUPLICATE); - return new relational(*this); + debugmsg("relational print",LOGLEVEL_PRINT); + + if (is_of_type(c, print_tree)) { + + inherited::print(c, level); + + } 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)"; + } + rh.print(c, precedence()); + if (precedence() <= level) + c.s << ")"; + } } 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; - } - return 0; + 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; + } + return 0; } -int relational::nops() const +unsigned relational::nops() const { - return 2; + return 2; } -ex & relational::let_op(int const i) +ex & relational::let_op(int i) { - GINAC_ASSERT(i>=0); - GINAC_ASSERT(i<2); + GINAC_ASSERT(i>=0); + GINAC_ASSERT(i<2); - return i==0 ? lh : rh; + return i==0 ? lh : rh; } - + ex relational::eval(int level) const { - if (level==1) { - return this->hold(); - } - 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 ); + if (level==1) + return this->hold(); + + 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::simplify_ncmul(const exvector & v) 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); + return lh.simplify_ncmul(v); } -ex relational::simplify_ncmul(exvector const & v) const +// protected + +int relational::compare_same_type(const basic & other) const { - return lh.simplify_ncmul(v); + GINAC_ASSERT(is_exactly_of_type(other, relational)); + const relational &oth = static_cast(other); + + if (o == oth.o) { + int cmpval = lh.compare(oth.lh); + if (cmpval) + return cmpval; + else + return rh.compare(oth.rh); + } + return (o < oth.o) ? -1 : 1; } -// protected - -int relational::compare_same_type(basic const & other) const +bool relational::match_same_type(const basic & other) const { - GINAC_ASSERT(is_exactly_of_type(other, relational)); - relational const & 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; - } - } - if (o(other); + + return o == oth.o; } unsigned relational::return_type(void) const { - GINAC_ASSERT(lh.return_type()==rh.return_type()); - return lh.return_type(); + GINAC_ASSERT(lh.return_type()==rh.return_type()); + return lh.return_type(); } unsigned relational::return_type_tinfo(void) const { - GINAC_ASSERT(lh.return_type_tinfo()==rh.return_type_tinfo()); - return lh.return_type_tinfo(); + GINAC_ASSERT(lh.return_type_tinfo()==rh.return_type_tinfo()); + return lh.return_type_tinfo(); } ////////// // new virtual functions which can be overridden by derived classes ////////// -// none +/** Left hand side of relational. */ +ex relational::lhs(void) const +{ + return lh; +} + +/** Right hand side of relational. */ +ex relational::rhs(void) const +{ + return rh; +} ////////// // non-virtual functions in this class ////////// -#include - +/** 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; - if (!is_ex_exactly_of_type(df,numeric)) { - return o==not_equal ? true : false; // cannot decide on non-numerical results - } - int cmpval=ex_to_numeric(df).compare(numZERO()); - switch (o) { - case equal: - return cmpval==0; - break; - case not_equal: - return cmpval!=0; - break; - case less: - return cmpval<0; - break; - case less_or_equal: - return cmpval<=0; - break; - case greater: - return cmpval>0; - break; - case greater_or_equal: - return cmpval>=0; - break; - default: - throw(std::logic_error("invalid relational operator")); - } - return 0; + 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; + + switch (o) { + 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; - -////////// -// global constants -////////// - -const relational some_relational; -type_info const & typeid_relational=typeid(some_relational); - } // namespace GiNaC