X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Frelational.cpp;h=92b54318392afd8ea89120522a0345ba6dc2f5b5;hp=87acde42fe24b89e975167da4dd243716d411fe3;hb=f7884835d397de85e648d1957c058b7d4c0948ba;hpb=96af2609db413ddf70371e0423e6c07ecb5ee813 diff --git a/ginac/relational.cpp b/ginac/relational.cpp index 87acde42..92b54318 100644 --- a/ginac/relational.cpp +++ b/ginac/relational.cpp @@ -3,7 +3,7 @@ * Implementation of relations between expressions */ /* - * GiNaC Copyright (C) 1999-2004 Johannes Gutenberg University Mainz, Germany + * GiNaC Copyright (C) 1999-2019 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,17 +17,18 @@ * * 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 -#include - #include "relational.h" #include "operators.h" #include "numeric.h" #include "archive.h" #include "utils.h" +#include "hash_seed.h" + +#include +#include namespace GiNaC { @@ -40,7 +41,7 @@ GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(relational, basic, // default constructor ////////// -relational::relational() : basic(TINFO_relational) {} +relational::relational() { } ////////// // other constructors @@ -48,14 +49,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")); @@ -63,6 +66,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 { @@ -72,8 +76,6 @@ void relational::archive(archive_node &n) const n.add_unsigned("op", o); } -DEFAULT_UNARCHIVE(relational) - ////////// // functions overriding virtual functions from base classes ////////// @@ -164,18 +166,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); -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 (!are_ex_trivially_equal(lh, mapped_lh) + || !are_ex_trivially_equal(rh, mapped_rh)) + return dynallocate(mapped_lh, mapped_rh, o); + else + return *this; } ex relational::subs(const exmap & m, unsigned options) const @@ -242,8 +240,8 @@ unsigned relational::return_type() const GINAC_ASSERT(lh.return_type()==rh.return_type()); 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 +249,7 @@ unsigned relational::return_type_tinfo() const unsigned relational::calchash() const { - unsigned v = golden_ratio_hash(tinfo()); + unsigned v = make_hash_seed(typeid(*this)); unsigned lhash = lh.gethash(); unsigned rhash = rh.gethash(); @@ -272,7 +270,7 @@ unsigned relational::calchash() const break; case greater: case greater_or_equal: - v ^= lhash; + v ^= lhash; lhash = rhash; break; } @@ -292,17 +290,7 @@ unsigned relational::calchash() const // new virtual functions which can be overridden by derived classes ////////// -/** Left hand side of relational. */ -ex relational::lhs() const -{ - return lh; -} - -/** Right hand side of relational. */ -ex relational::rhs() const -{ - return rh; -} +// none ////////// // non-virtual functions in this class @@ -310,10 +298,10 @@ ex relational::rhs() const relational::safe_bool relational::make_safe_bool(bool cond) const { - return cond? &safe_bool_helper::nonnull : 0; + return cond? &safe_bool_helper::nonnull : nullptr; } -/** Cast the relational into a boolean, mainly for evaluation within an +/** 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 @@ -331,13 +319,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")); }