X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?a=blobdiff_plain;ds=sidebyside;f=ginac%2Frelational.cpp;h=8f7b4b65effc7a5d2dba3388b6060998f6e0fde6;hb=1bd972bf8e4eeeb8aec6081100876e81a7f18450;hp=5784c359561c5531ad1243c0580c6d88c2a8537f;hpb=15d4b353c85f8815a95d97ab977c9ca48e155574;p=ginac.git diff --git a/ginac/relational.cpp b/ginac/relational.cpp index 5784c359..8f7b4b65 100644 --- a/ginac/relational.cpp +++ b/ginac/relational.cpp @@ -3,7 +3,7 @@ * Implementation of relations between expressions */ /* - * GiNaC Copyright (C) 1999-2000 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,12 +24,15 @@ #include "relational.h" #include "numeric.h" -#include "debugmsg.h" +#include "archive.h" #include "utils.h" +#include "debugmsg.h" -#ifndef NO_GINAC_NAMESPACE +#ifndef NO_NAMESPACE_GINAC namespace GiNaC { -#endif // ndef NO_GINAC_NAMESPACE +#endif // ndef NO_NAMESPACE_GINAC + +GINAC_IMPLEMENT_REGISTERED_CLASS(relational, basic) ////////// // default constructor, destructor, copy constructor assignment operator and helpers @@ -39,44 +42,22 @@ namespace GiNaC { relational::relational() : basic(TINFO_relational) { - debugmsg("relational default constructor",LOGLEVEL_CONSTRUCT); -} - -relational::~relational() -{ - debugmsg("relational destructor",LOGLEVEL_DESTRUCT); - destroy(0); -} - -relational::relational(relational const & other) -{ - debugmsg("relational copy constructor",LOGLEVEL_CONSTRUCT); - copy(other); -} - -relational const & relational::operator=(relational const & other) -{ - debugmsg("relational operator=",LOGLEVEL_ASSIGNMENT); - if (this != &other) { - destroy(1); - copy(other); - } - return *this; + debugmsg("relational default constructor",LOGLEVEL_CONSTRUCT); } // protected -void relational::copy(relational const & other) +void relational::copy(const relational & other) { - basic::copy(other); - lh=other.lh; - rh=other.rh; - o=other.o; + basic::copy(other); + lh=other.lh; + rh=other.rh; + o=other.o; } void relational::destroy(bool call_parent) { - if (call_parent) basic::destroy(call_parent); + if (call_parent) basic::destroy(call_parent); } ////////// @@ -85,276 +66,298 @@ void relational::destroy(bool call_parent) // public -relational::relational(ex const & lhs, ex const & rhs, operators oper) : basic(TINFO_relational) +relational::relational(const ex & lhs, const ex & rhs, operators oper) : basic(TINFO_relational) { - debugmsg("relational constructor ex,ex,operator",LOGLEVEL_CONSTRUCT); - lh=lhs; - rh=rhs; - o=oper; + debugmsg("relational constructor ex,ex,operator",LOGLEVEL_CONSTRUCT); + lh=lhs; + rh=rhs; + o=oper; } ////////// -// functions overriding virtual functions from bases classes +// archiving ////////// -// public +/** Construct object from archive_node. */ +relational::relational(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst) +{ + debugmsg("relational constructor 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); +} -basic * relational::duplicate() const +/** Unarchive the object. */ +ex relational::unarchive(const archive_node &n, const lst &sym_lst) { - debugmsg("relational duplicate",LOGLEVEL_DUPLICATE); - return new relational(*this); + return (new relational(n, sym_lst))->setflag(status_flags::dynallocated); } -void relational::print(ostream & os, unsigned upper_precedence) const +/** Archive the object. */ +void relational::archive(archive_node &n) 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 << ")"; + inherited::archive(n); + n.add_ex("lh", lh); + n.add_ex("rh", rh); + n.add_unsigned("op", o); } -void relational::printraw(ostream & os) const +////////// +// functions overriding virtual functions from bases classes +////////// + +// public + +void relational::print(std::ostream & os, unsigned upper_precedence) 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 << ")"; + 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::printcsrc(ostream & os, unsigned type, unsigned upper_precedence) const +void relational::printraw(std::ostream & os) const { - debugmsg("relational print csrc", LOGLEVEL_PRINT); - if (precedence<=upper_precedence) - os << "("; - - // Print left-hand expression - lh.bp->printcsrc(os, type, precedence); - - // Print relational operator - 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)"; - break; - } - - // Print right-hand operator - rh.bp->printcsrc(os, type, precedence); - - if (precedence <= upper_precedence) - os << ")"; + 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 << ")"; +} + +void relational::printcsrc(std::ostream & os, unsigned type, unsigned upper_precedence) const +{ + debugmsg("relational print csrc", LOGLEVEL_PRINT); + if (precedence<=upper_precedence) + os << "("; + + // Print left-hand expression + lh.bp->printcsrc(os, type, precedence); + + // Print relational operator + 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)"; + break; + } + + // Print right-hand operator + rh.bp->printcsrc(os, type, precedence); + + if (precedence <= upper_precedence) + os << ")"; } 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; } 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 { - 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); + 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(exvector const & v) const +ex relational::simplify_ncmul(const exvector & v) const { - return lh.simplify_ncmul(v); + return lh.simplify_ncmul(v); } // protected -int relational::compare_same_type(basic const & other) const +int relational::compare_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(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 - 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(_num0()); - 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; + // 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)) + // 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; + case not_equal: + return cmpval!=0; + case less: + return cmpval<0; + case less_or_equal: + return cmpval<=0; + case greater: + return cmpval>0; + case greater_or_equal: + return cmpval>=0; + default: + throw(std::logic_error("invalid relational operator")); + } } ////////// @@ -365,13 +368,6 @@ relational::operator bool() const unsigned relational::precedence=20; -////////// -// global constants -////////// - -const relational some_relational; -type_info const & typeid_relational=typeid(some_relational); - -#ifndef NO_GINAC_NAMESPACE +#ifndef NO_NAMESPACE_GINAC } // namespace GiNaC -#endif // ndef NO_GINAC_NAMESPACE +#endif // ndef NO_NAMESPACE_GINAC