X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?a=blobdiff_plain;f=ginac%2Frelational.cpp;h=d345943c26cc2bbea2157efbe0ff9894d220d0ad;hb=556ea59d4be5f0e2e8d3760501b8b9cb8587c1ec;hp=453b4c00a9b18b278db2f830eac5d2e8f758d1bd;hpb=5ef801553eb39aed7bd2df9dd1aff9d752c3ea9d;p=ginac.git diff --git a/ginac/relational.cpp b/ginac/relational.cpp index 453b4c00..d345943c 100644 --- a/ginac/relational.cpp +++ b/ginac/relational.cpp @@ -3,7 +3,7 @@ * Implementation of relations between expressions */ /* - * GiNaC Copyright (C) 1999-2003 Johannes Gutenberg University Mainz, Germany + * GiNaC Copyright (C) 1999-2008 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 @@ -17,7 +17,7 @@ * * 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 */ #include @@ -26,19 +26,21 @@ #include "relational.h" #include "operators.h" #include "numeric.h" -#include "print.h" #include "archive.h" #include "utils.h" namespace GiNaC { -GINAC_IMPLEMENT_REGISTERED_CLASS(relational, basic) +GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(relational, basic, + print_func(&relational::do_print). + print_func(&relational::do_print_tree). + print_func(&relational::do_print_python_repr)) ////////// // default constructor ////////// -relational::relational() : basic(TINFO_relational) {} +relational::relational() { } ////////// // other constructors @@ -46,14 +48,16 @@ relational::relational() : basic(TINFO_relational) {} // public -relational::relational(const ex & lhs, const ex & rhs, operators oper) : basic(TINFO_relational), lh(lhs), rh(rhs), o(oper) {} +relational::relational(const ex & lhs, const ex & rhs, operators oper) : + lh(lhs), rh(rhs), o(oper) { } ////////// // archiving ////////// -relational::relational(const archive_node &n, lst &sym_lst) : inherited(n, sym_lst) +void relational::read_archive(const archive_node& n, lst& sym_lst) { + inherited::read_archive(n, sym_lst); unsigned int opi; if (!(n.find_unsigned("op", opi))) throw (std::runtime_error("unknown relational operator in archive")); @@ -61,6 +65,7 @@ relational::relational(const archive_node &n, lst &sym_lst) : inherited(n, sym_l n.find_ex("lh", lh, sym_lst); n.find_ex("rh", rh, sym_lst); } +GINAC_BIND_UNARCHIVER(relational); void relational::archive(archive_node &n) const { @@ -70,65 +75,61 @@ void relational::archive(archive_node &n) const n.add_unsigned("op", o); } -DEFAULT_UNARCHIVE(relational) - ////////// // functions overriding virtual functions from base classes ////////// // public -void relational::print(const print_context & c, unsigned level) const +static void print_operator(const print_context & c, relational::operators o) { - 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 << ")"; - } + switch (o) { + case relational::equal: + c.s << "=="; + break; + case relational::not_equal: + c.s << "!="; + break; + case relational::less: + c.s << "<"; + break; + case relational::less_or_equal: + c.s << "<="; + break; + case relational::greater: + c.s << ">"; + break; + case relational::greater_or_equal: + c.s << ">="; + break; + default: + c.s << "(INVALID RELATIONAL OPERATOR)"; + break; } } +void relational::do_print(const print_context & c, unsigned level) const +{ + if (precedence() <= level) + c.s << "("; + lh.print(c, precedence()); + print_operator(c, o); + rh.print(c, precedence()); + if (precedence() <= level) + c.s << ")"; +} + +void relational::do_print_python_repr(const print_python_repr & c, unsigned level) const +{ + c.s << class_name() << '('; + lh.print(c); + c.s << ','; + rh.print(c); + c.s << ",'"; + print_operator(c, o); + c.s << "')"; +} + bool relational::info(unsigned inf) const { switch (inf) { @@ -164,7 +165,14 @@ ex relational::op(size_t i) const ex relational::map(map_function & f) const { - return (new relational(f(lh), f(rh), o))->setflag(status_flags::dynallocated); + const ex &mapped_lh = f(lh); + const ex &mapped_rh = f(rh); + + if (!are_ex_trivially_equal(lh, mapped_lh) + || !are_ex_trivially_equal(rh, mapped_rh)) + return (new relational(mapped_lh, mapped_rh, o))->setflag(status_flags::dynallocated); + else + return *this; } ex relational::eval(int level) const @@ -243,7 +251,7 @@ unsigned relational::return_type() const return lh.return_type(); } -unsigned relational::return_type_tinfo() const +return_type_t relational::return_type_tinfo() const { GINAC_ASSERT(lh.return_type_tinfo()==rh.return_type_tinfo()); return lh.return_type_tinfo(); @@ -251,7 +259,8 @@ unsigned relational::return_type_tinfo() const unsigned relational::calchash() const { - unsigned v = golden_ratio_hash(tinfo()); + const void* this_tinfo = (const void*)typeid(*this).name(); + unsigned v = golden_ratio_hash((p_int)this_tinfo); unsigned lhash = lh.gethash(); unsigned rhash = rh.gethash(); @@ -331,13 +340,13 @@ relational::operator relational::safe_bool() const case not_equal: return make_safe_bool(!ex_to(df).is_zero()); case less: - return make_safe_bool(ex_to(df)<_num0); + return make_safe_bool(ex_to(df)<(*_num0_p)); case less_or_equal: - return make_safe_bool(ex_to(df)<=_num0); + return make_safe_bool(ex_to(df)<=(*_num0_p)); case greater: - return make_safe_bool(ex_to(df)>_num0); + return make_safe_bool(ex_to(df)>(*_num0_p)); case greater_or_equal: - return make_safe_bool(ex_to(df)>=_num0); + return make_safe_bool(ex_to(df)>=(*_num0_p)); default: throw(std::logic_error("invalid relational operator")); }