X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Frelational.cpp;h=55b705447d7ab254b6aea24ee28dc6e9e4b14036;hp=db6b5cf2bb8e3c488a93b401d88b79ac178ca949;hb=dd2a73f3fbd8d50f935f380e5d32a26b77e4cdb8;hpb=66c0f31c678e6c1938d637636b230ea376c157c1 diff --git a/ginac/relational.cpp b/ginac/relational.cpp index db6b5cf2..55b70544 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-2000 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 @@ -23,6 +24,15 @@ #include "relational.h" #include "numeric.h" +#include "archive.h" +#include "utils.h" +#include "debugmsg.h" + +#ifndef NO_NAMESPACE_GINAC +namespace GiNaC { +#endif // ndef NO_NAMESPACE_GINAC + +GINAC_IMPLEMENT_REGISTERED_CLASS(relational, basic) ////////// // default constructor, destructor, copy constructor assignment operator and helpers @@ -41,13 +51,13 @@ relational::~relational() destroy(0); } -relational::relational(relational const & other) +relational::relational(const relational & other) { debugmsg("relational copy constructor",LOGLEVEL_CONSTRUCT); copy(other); } -relational const & relational::operator=(relational const & other) +const relational & relational::operator=(const relational & other) { debugmsg("relational operator=",LOGLEVEL_ASSIGNMENT); if (this != &other) { @@ -59,7 +69,7 @@ relational const & relational::operator=(relational const & other) // protected -void relational::copy(relational const & other) +void relational::copy(const relational & other) { basic::copy(other); lh=other.lh; @@ -78,7 +88,7 @@ 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; @@ -86,6 +96,37 @@ relational::relational(ex const & lhs, ex const & rhs, operators oper) : basic(T o=oper; } +////////// +// archiving +////////// + +/** 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); +} + +/** Unarchive the object. */ +ex relational::unarchive(const archive_node &n, const lst &sym_lst) +{ + return (new relational(n, sym_lst))->setflag(status_flags::dynallocated); +} + +/** Archive the object. */ +void relational::archive(archive_node &n) const +{ + inherited::archive(n); + n.add_ex("lh", lh); + n.add_ex("rh", rh); + n.add_unsigned("op", o); +} + ////////// // functions overriding virtual functions from bases classes ////////// @@ -98,6 +139,111 @@ basic * relational::duplicate() const return new relational(*this); } +void relational::print(ostream & os, unsigned upper_precedence) 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 << ")"; +} + +void relational::printraw(ostream & os) 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 << ")"; +} + +void relational::printcsrc(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) { @@ -119,15 +265,15 @@ bool relational::info(unsigned inf) const return 0; } -int relational::nops() const +unsigned relational::nops() const { return 2; } -ex & relational::let_op(int const i) +ex & relational::let_op(int i) { - ASSERT(i>=0); - ASSERT(i<2); + GINAC_ASSERT(i>=0); + GINAC_ASSERT(i<2); return i==0 ? lh : rh; } @@ -157,17 +303,17 @@ ex relational::evalf(int level) const 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); } // 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)); + GINAC_ASSERT(is_exactly_of_type(other, relational)); + const relational & oth=static_cast(const_cast(other)); int cmpval; @@ -188,13 +334,13 @@ int relational::compare_same_type(basic const & other) const unsigned relational::return_type(void) const { - ASSERT(lh.return_type()==rh.return_type()); + GINAC_ASSERT(lh.return_type()==rh.return_type()); return lh.return_type(); } unsigned relational::return_type_tinfo(void) const { - ASSERT(lh.return_type_tinfo()==rh.return_type_tinfo()); + GINAC_ASSERT(lh.return_type_tinfo()==rh.return_type_tinfo()); return lh.return_type_tinfo(); } @@ -202,7 +348,17 @@ unsigned relational::return_type_tinfo(void) const // 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 @@ -219,7 +375,7 @@ relational::operator bool() const 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()); + int cmpval=ex_to_numeric(df).compare(_num0()); switch (o) { case equal: return cmpval==0; @@ -258,5 +414,8 @@ unsigned relational::precedence=20; ////////// const relational some_relational; -type_info const & typeid_relational=typeid(some_relational); +const type_info & typeid_relational=typeid(some_relational); +#ifndef NO_NAMESPACE_GINAC +} // namespace GiNaC +#endif // ndef NO_NAMESPACE_GINAC