X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Foperators.cpp;h=9f81e2e50a25026dd4549ce8c5372239fda727f6;hp=d588b98d995560a9f5c8850d7f5427fae685cdf1;hb=c12c8ec3c5cf0c75f061f6c52d04206277bbdcca;hpb=68fdf425abf14d016d5f95ee7b9d06a19a3c5926 diff --git a/ginac/operators.cpp b/ginac/operators.cpp index d588b98d..9f81e2e5 100644 --- a/ginac/operators.cpp +++ b/ginac/operators.cpp @@ -3,7 +3,7 @@ * Implementation of GiNaC's overloaded operators. */ /* - * GiNaC Copyright (C) 1999-2003 Johannes Gutenberg University Mainz, Germany + * GiNaC Copyright (C) 1999-2016 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 @@ -17,12 +17,9 @@ * * 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 -#include - #include "operators.h" #include "numeric.h" #include "add.h" @@ -33,31 +30,34 @@ #include "print.h" #include "utils.h" +#include + namespace GiNaC { -/** Used internally by operator+() to add two ex objects together. */ +/** Used internally by operator+() to add two ex objects. */ static inline const ex exadd(const ex & lh, const ex & rh) { - return (new add(lh,rh))->setflag(status_flags::dynallocated); + return dynallocate(lh, rh); } -/** Used internally by operator*() to multiply two ex objects together. */ +/** Used internally by operator*() to multiply two ex objects. */ static inline const ex exmul(const ex & lh, const ex & rh) { // Check if we are constructing a mul object or a ncmul object. Due to // ncmul::eval()'s rule to pull out commutative elements we need to check // only one of the elements. if (rh.return_type()==return_types::commutative || - lh.return_type()==return_types::commutative) - return (new mul(lh,rh))->setflag(status_flags::dynallocated); - else - return (new ncmul(lh,rh))->setflag(status_flags::dynallocated); + lh.return_type()==return_types::commutative) { + return dynallocate(lh, rh); + } else { + return dynallocate(lh, rh); + } } /** Used internally by operator-() and friends to change the sign of an argument. */ static inline const ex exminus(const ex & lh) { - return (new mul(lh,_ex_1))->setflag(status_flags::dynallocated); + return dynallocate(lh, _ex_1); } // binary arithmetic operators ex with ex @@ -175,7 +175,7 @@ const numeric operator+(const numeric & lh) const numeric operator-(const numeric & lh) { - return _num_1.mul(lh); + return _num_1_p->mul(lh); } @@ -214,14 +214,14 @@ const ex operator--(ex & lh, int) /** Numeric prefix increment. Adds 1 and returns incremented number. */ numeric& operator++(numeric & rh) { - rh = rh.add(_num1); + rh = rh.add(*_num1_p); return rh; } /** Numeric prefix decrement. Subtracts 1 and returns decremented number. */ numeric& operator--(numeric & rh) { - rh = rh.add(_num_1); + rh = rh.add(*_num_1_p); return rh; } @@ -230,7 +230,7 @@ numeric& operator--(numeric & rh) const numeric operator++(numeric & lh, int) { numeric tmp(lh); - lh = lh.add(_num1); + lh = lh.add(*_num1_p); return tmp; } @@ -239,7 +239,7 @@ const numeric operator++(numeric & lh, int) const numeric operator--(numeric & lh, int) { numeric tmp(lh); - lh = lh.add(_num_1); + lh = lh.add(*_num_1_p); return tmp; } @@ -247,32 +247,32 @@ const numeric operator--(numeric & lh, int) const relational operator==(const ex & lh, const ex & rh) { - return relational(lh,rh,relational::equal); + return dynallocate(lh, rh, relational::equal); } const relational operator!=(const ex & lh, const ex & rh) { - return relational(lh,rh,relational::not_equal); + return dynallocate(lh, rh, relational::not_equal); } const relational operator<(const ex & lh, const ex & rh) { - return relational(lh,rh,relational::less); + return dynallocate(lh, rh, relational::less); } const relational operator<=(const ex & lh, const ex & rh) { - return relational(lh,rh,relational::less_or_equal); + return dynallocate(lh, rh, relational::less_or_equal); } const relational operator>(const ex & lh, const ex & rh) { - return relational(lh,rh,relational::greater); + return dynallocate(lh, rh, relational::greater); } const relational operator>=(const ex & lh, const ex & rh) { - return relational(lh,rh,relational::greater_or_equal); + return dynallocate(lh, rh, relational::greater_or_equal); } // input/output stream operators and manipulators @@ -333,8 +333,8 @@ static inline unsigned get_print_options(std::ios_base & s) static void set_print_options(std::ostream & s, unsigned options) { print_context *p = get_print_context(s); - if (p == 0) - set_print_context(s, print_context(s, options)); + if (p == nullptr) + set_print_context(s, print_dflt(s, options)); else p->options = options; } @@ -342,13 +342,99 @@ static void set_print_options(std::ostream & s, unsigned options) std::ostream & operator<<(std::ostream & os, const ex & e) { print_context *p = get_print_context(os); - if (p == 0) - e.print(print_context(os)); + if (p == nullptr) + e.print(print_dflt(os)); else e.print(*p); return os; } +std::ostream & operator<<(std::ostream & os, const exvector & e) +{ + print_context *p = get_print_context(os); + exvector::const_iterator i = e.begin(); + exvector::const_iterator vend = e.end(); + + if (i==vend) { + os << "[]"; + return os; + } + + os << "["; + while (true) { + if (p == nullptr) + i -> print(print_dflt(os)); + else + i -> print(*p); + ++i; + if (i==vend) + break; + os << ","; + } + os << "]"; + + return os; +} + +std::ostream & operator<<(std::ostream & os, const exset & e) +{ + print_context *p = get_print_context(os); + exset::const_iterator i = e.begin(); + exset::const_iterator send = e.end(); + + if (i==send) { + os << "<>"; + return os; + } + + os << "<"; + while (true) { + if (p == nullptr) + i->print(print_dflt(os)); + else + i->print(*p); + ++i; + if (i == send) + break; + os << ","; + } + os << ">"; + + return os; +} + +std::ostream & operator<<(std::ostream & os, const exmap & e) +{ + print_context *p = get_print_context(os); + exmap::const_iterator i = e.begin(); + exmap::const_iterator mend = e.end(); + + if (i==mend) { + os << "{}"; + return os; + } + + os << "{"; + while (true) { + if (p == nullptr) + i->first.print(print_dflt(os)); + else + i->first.print(*p); + os << "=="; + if (p == nullptr) + i->second.print(print_dflt(os)); + else + i->second.print(*p); + ++i; + if( i==mend ) + break; + os << ","; + } + os << "}"; + + return os; +} + std::istream & operator>>(std::istream & is, ex & e) { throw (std::logic_error("expression input from streams not implemented")); @@ -356,7 +442,7 @@ std::istream & operator>>(std::istream & is, ex & e) std::ostream & dflt(std::ostream & os) { - set_print_context(os, print_context(os)); + set_print_context(os, print_dflt(os)); set_print_options(os, 0); return os; }