X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Frelational.cpp;h=92b54318392afd8ea89120522a0345ba6dc2f5b5;hp=9dad5cc70c3178f6b9f3167e1fd3576c8155477a;hb=8cffcdf13d817a47f217f1a1043317d95969e070;hpb=a8507b8af1c08d9b27d98d57f95c7ca1a8671e27;ds=sidebyside diff --git a/ginac/relational.cpp b/ginac/relational.cpp index 9dad5cc7..92b54318 100644 --- a/ginac/relational.cpp +++ b/ginac/relational.cpp @@ -1,8 +1,9 @@ /** @file relational.cpp * - * Implementation of relations between expressions - * - * GiNaC Copyright (C) 1999 Johannes Gutenberg University Mainz, Germany + * Implementation of relations between expressions */ + +/* + * 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 @@ -16,185 +17,273 @@ * * 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 "relational.h" +#include "operators.h" +#include "numeric.h" +#include "archive.h" +#include "utils.h" +#include "hash_seed.h" + +#include #include -#include "ginac.h" +namespace GiNaC { + +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, destructor, copy constructor assignment operator and helpers +// default constructor ////////// -// public +relational::relational() { } -relational::relational() : basic(TINFO_RELATIONAL) -{ - debugmsg("relational default constructor",LOGLEVEL_CONSTRUCT); -} - -relational::~relational() -{ - debugmsg("relational destructor",LOGLEVEL_DESTRUCT); - destroy(0); -} +////////// +// other constructors +////////// -relational::relational(relational const & other) -{ - debugmsg("relational copy constructor",LOGLEVEL_CONSTRUCT); - copy(other); -} +// public -relational const & relational::operator=(relational const & other) -{ - debugmsg("relational operator=",LOGLEVEL_ASSIGNMENT); - if (this != &other) { - destroy(1); - copy(other); - } - return *this; -} +relational::relational(const ex & lhs, const ex & rhs, operators oper) : + lh(lhs), rh(rhs), o(oper) { } -// protected +////////// +// archiving +////////// -void relational::copy(relational const & other) +void relational::read_archive(const archive_node& n, lst& sym_lst) { - basic::copy(other); - lh=other.lh; - rh=other.rh; - o=other.o; + inherited::read_archive(n, sym_lst); + 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); } +GINAC_BIND_UNARCHIVER(relational); -void relational::destroy(bool call_parent) +void relational::archive(archive_node &n) const { - if (call_parent) basic::destroy(call_parent); + inherited::archive(n); + n.add_ex("lh", lh); + n.add_ex("rh", rh); + n.add_unsigned("op", o); } ////////// -// other constructors +// functions overriding virtual functions from base classes ////////// // public -relational::relational(ex const & lhs, ex const & rhs, operators oper) : basic(TINFO_RELATIONAL) +static void print_operator(const print_context & c, relational::operators o) { - debugmsg("relational constructor ex,ex,operator",LOGLEVEL_CONSTRUCT); - lh=lhs; - rh=rhs; - o=oper; + 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; + } } -////////// -// functions overriding virtual functions from bases classes -////////// - -// public +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 << ")"; +} -basic * relational::duplicate() const +void relational::do_print_python_repr(const print_python_repr & c, unsigned level) const { - debugmsg("relational duplicate",LOGLEVEL_DUPLICATE); - return new relational(*this); + 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) { - 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 +size_t relational::nops() const { - return 2; + return 2; } -ex & relational::let_op(int const i) +ex relational::op(size_t i) const { - ASSERT(i>=0); - ASSERT(i<2); + GINAC_ASSERT(i<2); - return i==0 ? lh : rh; + return i==0 ? lh : rh; } - -ex relational::eval(int level) const + +ex relational::map(map_function & f) 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 ); + 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 dynallocate(mapped_lh, mapped_rh, o); + else + return *this; } -ex relational::evalf(int level) const +ex relational::subs(const exmap & m, unsigned options) 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(m, options); + const ex & subsed_rh = rh.subs(m, options); + + if (!are_ex_trivially_equal(lh, subsed_lh) || !are_ex_trivially_equal(rh, subsed_rh)) + return relational(subsed_lh, subsed_rh, o).subs_one_level(m, options); + else + return subs_one_level(m, options); } -ex relational::simplify_ncmul(exvector const & v) const +ex relational::eval_ncmul(const exvector & v) const { - return lh.simplify_ncmul(v); + return lh.eval_ncmul(v); } // protected -int relational::compare_same_type(basic const & other) const +int relational::compare_same_type(const basic & other) const { - 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)); + 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; + } + const int lcmpval = lh.compare(oth.rh); + return (lcmpval!=0) ? lcmpval : rh.compare(oth.lh); } -unsigned relational::return_type(void) const +bool relational::match_same_type(const basic & other) const { - ASSERT(lh.return_type()==rh.return_type()); - return lh.return_type(); + GINAC_ASSERT(is_exactly_a(other)); + const relational &oth = static_cast(other); + + return o == oth.o; } - -unsigned relational::return_type_tinfo(void) const + +unsigned relational::return_type() const +{ + GINAC_ASSERT(lh.return_type()==rh.return_type()); + return lh.return_type(); +} + +return_type_t relational::return_type_tinfo() const +{ + GINAC_ASSERT(lh.return_type_tinfo()==rh.return_type_tinfo()); + return lh.return_type_tinfo(); +} + +unsigned relational::calchash() const { - ASSERT(lh.return_type_tinfo()==rh.return_type_tinfo()); - return lh.return_type_tinfo(); + unsigned v = make_hash_seed(typeid(*this)); + unsigned lhash = lh.gethash(); + unsigned rhash = rh.gethash(); + + v = rotate_left(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(v); + v ^= lhash; + + // store calculated hash value only if object is already evaluated + if (flags & status_flags::evaluated) { + setflag(status_flags::hash_calculated); + hashvalue = v; + } + + return v; } ////////// @@ -207,55 +296,39 @@ unsigned relational::return_type_tinfo(void) const // non-virtual functions in this class ////////// -#include - -relational::operator bool() const +relational::safe_bool relational::make_safe_bool(bool cond) 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; + return cond? &safe_bool_helper::nonnull : nullptr; } -////////// -// static member variables -////////// - -// protected - -unsigned relational::precedence=20; - -////////// -// global constants -////////// - -const relational some_relational; -type_info const & typeid_relational=typeid(some_relational); +/** 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 relational::safe_bool() const +{ + const ex df = lh-rh; + if (!is_exactly_a(df)) + // cannot decide on non-numerical results + return o==not_equal ? make_safe_bool(true) : make_safe_bool(false); + + switch (o) { + case equal: + return make_safe_bool(ex_to(df).is_zero()); + case not_equal: + return make_safe_bool(!ex_to(df).is_zero()); + case less: + return make_safe_bool(ex_to(df)<(*_num0_p)); + case less_or_equal: + return make_safe_bool(ex_to(df)<=(*_num0_p)); + case greater: + return make_safe_bool(ex_to(df)>(*_num0_p)); + case greater_or_equal: + return make_safe_bool(ex_to(df)>=(*_num0_p)); + default: + throw(std::logic_error("invalid relational operator")); + } +} +} // namespace GiNaC