X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Frelational.cpp;h=614c1629c11382ab66db911d07a5c02bcc9a59a1;hp=252d8b350660360abfdaaa022019388c67aa53e8;hb=955cb185a85535ab328ffedbfccdc508ce80fa91;hpb=6b3768e8c544739ae53321539cb4d1e3112ded1b diff --git a/ginac/relational.cpp b/ginac/relational.cpp index 252d8b35..614c1629 100644 --- a/ginac/relational.cpp +++ b/ginac/relational.cpp @@ -2,9 +2,34 @@ * * Implementation of relations between expressions */ +/* + * GiNaC Copyright (C) 1999 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 + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * 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 + */ + #include -#include "ginac.h" +#include "relational.h" +#include "numeric.h" +#include "debugmsg.h" +#include "utils.h" + +#ifndef NO_GINAC_NAMESPACE +namespace GiNaC { +#endif // ndef NO_GINAC_NAMESPACE ////////// // default constructor, destructor, copy constructor assignment operator and helpers @@ -12,7 +37,7 @@ // public -relational::relational() : basic(TINFO_RELATIONAL) +relational::relational() : basic(TINFO_relational) { debugmsg("relational default constructor",LOGLEVEL_CONSTRUCT); } @@ -60,7 +85,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; @@ -80,6 +105,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) { @@ -108,8 +238,8 @@ int relational::nops() const 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; } @@ -148,7 +278,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; @@ -170,13 +300,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(); } @@ -201,7 +331,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; @@ -242,3 +372,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