X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Frelational.cpp;h=d854e47d13f5960db0eb838772d764d89dba22ee;hp=9dad5cc70c3178f6b9f3167e1fd3576c8155477a;hb=c443cf647bbac14c9c3eed2565fd2df70fab9a84;hpb=a8507b8af1c08d9b27d98d57f95c7ca1a8671e27 diff --git a/ginac/relational.cpp b/ginac/relational.cpp index 9dad5cc7..d854e47d 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 @@ -21,7 +22,17 @@ #include -#include "ginac.h" +#include "relational.h" +#include "numeric.h" +#include "archive.h" +#include "utils.h" +#include "debugmsg.h" + +#ifndef NO_GINAC_NAMESPACE +namespace GiNaC { +#endif // ndef NO_GINAC_NAMESPACE + +GINAC_IMPLEMENT_REGISTERED_CLASS(relational, basic) ////////// // default constructor, destructor, copy constructor assignment operator and helpers @@ -29,7 +40,7 @@ // public -relational::relational() : basic(TINFO_RELATIONAL) +relational::relational() : basic(TINFO_relational) { debugmsg("relational default constructor",LOGLEVEL_CONSTRUCT); } @@ -77,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(ex const & lhs, ex const & rhs, operators oper) : basic(TINFO_relational) { debugmsg("relational constructor ex,ex,operator",LOGLEVEL_CONSTRUCT); lh=lhs; @@ -85,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 ////////// @@ -97,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) { @@ -118,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) { - ASSERT(i>=0); - ASSERT(i<2); + GINAC_ASSERT(i>=0); + GINAC_ASSERT(i<2); return i==0 ? lh : rh; } @@ -165,7 +312,7 @@ ex relational::simplify_ncmul(exvector const & v) const int relational::compare_same_type(basic const & other) const { - ASSERT(is_exactly_of_type(other, relational)); + GINAC_ASSERT(is_exactly_of_type(other, relational)); relational const & oth=static_cast(const_cast(other)); int cmpval; @@ -187,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(); } @@ -218,7 +365,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; @@ -259,3 +406,6 @@ unsigned relational::precedence=20; const relational some_relational; type_info const & typeid_relational=typeid(some_relational); +#ifndef NO_GINAC_NAMESPACE +} // namespace GiNaC +#endif // ndef NO_GINAC_NAMESPACE