X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fex.cpp;h=42cde03a546c2e660bbf21bdcb843c59ea927556;hp=c30efddac37b449193263f329d367f7a915fdd78;hb=3ab9a310275c0289ec5ae6deaf3b970aca6904e9;hpb=66c0f31c678e6c1938d637636b230ea376c157c1 diff --git a/ginac/ex.cpp b/ginac/ex.cpp index c30efdda..42cde03a 100644 --- a/ginac/ex.cpp +++ b/ginac/ex.cpp @@ -1,8 +1,9 @@ /** @file ex.cpp * - * Implementation of GiNaC's light-weight expression handles. - * - * GiNaC Copyright (C) 1999 Johannes Gutenberg University Mainz, Germany + * Implementation of GiNaC's light-weight expression handles. */ + +/* + * 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 @@ -20,6 +21,7 @@ */ #include +#include #include "ex.h" #include "add.h" @@ -27,104 +29,20 @@ #include "ncmul.h" #include "numeric.h" #include "power.h" +#include "relational.h" +#include "indexed.h" +#include "input_lexer.h" +#include "debugmsg.h" +#include "utils.h" -////////// -// default constructor, destructor, copy constructor assignment operator and helpers -////////// - -// public - -#ifndef INLINE_EX_CONSTRUCTORS - -ex::ex() : bp(exZERO().bp) -{ - debugmsg("ex default constructor",LOGLEVEL_CONSTRUCT); - ASSERT(exZERO().bp!=0); - ASSERT(exZERO().bp->flags & status_flags::dynallocated); - ASSERT(bp!=0); - ++bp->refcount; -} - -ex::~ex() -{ - debugmsg("ex destructor",LOGLEVEL_DESTRUCT); - ASSERT(bp!=0); - ASSERT(bp->flags & status_flags::dynallocated); - if (--bp->refcount == 0) { - delete bp; - } -} - -ex::ex(ex const & other) : bp(other.bp) -{ - debugmsg("ex copy constructor",LOGLEVEL_CONSTRUCT); - ASSERT(bp!=0); - ASSERT((bp->flags) & status_flags::dynallocated); - ++bp->refcount; -} - -ex const & ex::operator=(ex const & other) -{ - debugmsg("ex operator=",LOGLEVEL_ASSIGNMENT); - ASSERT(bp!=0); - ASSERT(bp->flags & status_flags::dynallocated); - ASSERT(other.bp!=0); - ASSERT(other.bp->flags & status_flags::dynallocated); - ++other.bp->refcount; - basic * tmpbp=other.bp; - if (--bp->refcount==0) { - delete bp; - } - bp=tmpbp; - return *this; -} - -#endif // ndef INLINE_EX_CONSTRUCTORS +namespace GiNaC { ////////// -// other constructors +// other ctors ////////// -// public +// none (all inlined) -#ifndef INLINE_EX_CONSTRUCTORS -ex::ex(basic const & other) -{ - debugmsg("ex constructor from basic",LOGLEVEL_CONSTRUCT); - construct_from_basic(other); -} -#endif - -ex::ex(int const i) -{ - debugmsg("ex constructor from int",LOGLEVEL_CONSTRUCT); - construct_from_basic(numeric(i)); -} - -ex::ex(unsigned int const i) -{ - debugmsg("ex constructor from unsigned int",LOGLEVEL_CONSTRUCT); - construct_from_basic(numeric(i)); -} - -ex::ex(long const i) -{ - debugmsg("ex constructor from long",LOGLEVEL_CONSTRUCT); - construct_from_basic(numeric(i)); -} - -ex::ex(unsigned long const i) -{ - debugmsg("ex constructor from unsigned long",LOGLEVEL_CONSTRUCT); - construct_from_basic(numeric(i)); -} - -ex::ex(double const d) -{ - debugmsg("ex constructor from double",LOGLEVEL_CONSTRUCT); - construct_from_basic(numeric(d)); -} - ////////// // functions overriding virtual functions from bases classes ////////// @@ -143,315 +61,449 @@ ex::ex(double const d) // public +/** Efficiently swap the contents of two expressions. */ void ex::swap(ex & other) { - debugmsg("ex swap",LOGLEVEL_MEMBER_FUNCTION); + debugmsg("ex swap",LOGLEVEL_MEMBER_FUNCTION); - ASSERT(bp!=0); - ASSERT(bp->flags & status_flags::dynallocated); - ASSERT(other.bp!=0); - ASSERT(other.bp->flags & status_flags::dynallocated); - - basic * tmpbp=bp; - bp=other.bp; - other.bp=tmpbp; + GINAC_ASSERT(bp!=0); + GINAC_ASSERT(bp->flags & status_flags::dynallocated); + GINAC_ASSERT(other.bp!=0); + GINAC_ASSERT(other.bp->flags & status_flags::dynallocated); + + basic * tmpbp = bp; + bp = other.bp; + other.bp = tmpbp; } -bool ex::info(unsigned inf) const +/** Print expression to stream. The formatting of the output is determined + * by the kind of print_context object that is passed. Possible formattings + * include ginsh-parsable output (the default), tree-like output for + * debugging, and C++ source. + * @see print_context */ +void ex::print(const print_context & c, unsigned level) const { - if (inf == info_flags::normal_form) { - - // Polynomials are in normal form - if (info(info_flags::polynomial)) - return true; - - // polynomial^(-int) is in normal form - if (is_ex_exactly_of_type(*this, power)) - return op(1).info(info_flags::negint); - - // polynomial^(int) * polynomial^(int) * ... is in normal form - if (!is_ex_exactly_of_type(*this, mul)) - return false; - for (int i=0; iinfo(inf); - } + debugmsg("ex print", LOGLEVEL_PRINT); + GINAC_ASSERT(bp!=0); + bp->print(c, level); } -int ex::nops() const +/** Print expression to stream in a tree-like format suitable for debugging. */ +void ex::printtree(std::ostream & os) const { - ASSERT(bp!=0); - return bp->nops(); + debugmsg("ex printtree", LOGLEVEL_PRINT); + GINAC_ASSERT(bp!=0); + bp->print(print_tree(os)); } -ex ex::expand(unsigned options) const +/** Little wrapper arount print to be called within a debugger. */ +void ex::dbgprint(void) const { - ASSERT(bp!=0); - return bp->expand(options); + debugmsg("ex dbgprint", LOGLEVEL_PRINT); + GINAC_ASSERT(bp!=0); + bp->dbgprint(); } -bool ex::has(ex const & other) const +/** Little wrapper arount printtree to be called within a debugger. */ +void ex::dbgprinttree(void) const { - ASSERT(bp!=0); - return bp->has(other); + debugmsg("ex dbgprinttree", LOGLEVEL_PRINT); + GINAC_ASSERT(bp!=0); + bp->dbgprinttree(); } -int ex::degree(symbol const & s) const +bool ex::info(unsigned inf) const { - ASSERT(bp!=0); - return bp->degree(s); + return bp->info(inf); } -int ex::ldegree(symbol const & s) const +unsigned ex::nops() const { - ASSERT(bp!=0); - return bp->ldegree(s); + GINAC_ASSERT(bp!=0); + return bp->nops(); } -ex ex::coeff(symbol const & s, int const n) const +ex ex::expand(unsigned options) const { - ASSERT(bp!=0); - return bp->coeff(s,n); + GINAC_ASSERT(bp!=0); + if (bp->flags & status_flags::expanded) + return *bp; + else + return bp->expand(options); } -ex ex::numer(bool normalize) const +bool ex::has(const ex & other) const { - ex n; - if (normalize && !info(info_flags::normal_form)) - n = normal(); - else - n = *this; - - // polynomial - if (n.info(info_flags::polynomial)) - return n; + GINAC_ASSERT(bp!=0); + return bp->has(other); +} - // something^(-int) - if (is_ex_exactly_of_type(n, power) && n.op(1).info(info_flags::negint)) - return exONE(); +int ex::degree(const ex & s) const +{ + GINAC_ASSERT(bp!=0); + return bp->degree(s); +} - // something^(int) * something^(int) * ... - if (!is_ex_exactly_of_type(n, mul)) - return n; - ex res = exONE(); - for (int i=0; ildegree(s); } -ex ex::denom(bool normalize) const +ex ex::coeff(const ex & s, int n) const { - ex n; - if (normalize && !info(info_flags::normal_form)) - n = normal(); - else - n = *this; + GINAC_ASSERT(bp!=0); + return bp->coeff(s,n); +} - // polynomial - if (n.info(info_flags::polynomial)) - return exONE(); +ex ex::collect(const ex & s) const +{ + GINAC_ASSERT(bp!=0); + return bp->collect(s); +} - // something^(-int) - if (is_ex_exactly_of_type(n, power) && n.op(1).info(info_flags::negint)) - return power(n.op(0), -(n.op(1))); +ex ex::eval(int level) const +{ + GINAC_ASSERT(bp!=0); + return bp->eval(level); +} - // something^(int) * something^(int) * ... - if (!is_ex_exactly_of_type(n, mul)) - return exONE(); - ex res = exONE(); - for (int i=0; ievalf(level); } -ex ex::collect(symbol const & s) const +/** Compute partial derivative of an expression. + * + * @param s symbol by which the expression is derived + * @param nth order of derivative (default 1) + * @return partial derivative as a new expression */ +ex ex::diff(const symbol & s, unsigned nth) const { - ASSERT(bp!=0); - return bp->collect(s); + GINAC_ASSERT(bp!=0); + + if (!nth) + return *this; + else + return bp->diff(s, nth); } -ex ex::eval(int level) const +ex ex::subs(const lst & ls, const lst & lr) const { - ASSERT(bp!=0); - return bp->eval(level); + GINAC_ASSERT(bp!=0); + return bp->subs(ls,lr); } -ex ex::evalf(int level) const +ex ex::subs(const ex & e) const { - ASSERT(bp!=0); - return bp->evalf(level); + GINAC_ASSERT(bp!=0); + return bp->subs(e); } -ex ex::subs(lst const & ls, lst const & lr) const +/** Return a vector containing the free indices of the object. */ +exvector ex::get_free_indices(void) const { - ASSERT(bp!=0); - return bp->subs(ls,lr); + GINAC_ASSERT(bp!=0); + return bp->get_free_indices(); } -ex ex::subs(ex const & e) const +/** Simplify/canonicalize expression containing indexed objects. This + * performs contraction of dummy indices where possible and checks whether + * the free indices in sums are consistent. + * + * @return simplified expression */ +ex ex::simplify_indexed(void) const { - ASSERT(bp!=0); - return bp->subs(e); + return GiNaC::simplify_indexed(*this); } -exvector ex::get_indices(void) const +/** Simplify/canonicalize expression containing indexed objects. This + * performs contraction of dummy indices where possible, checks whether + * the free indices in sums are consistent, and automatically replaces + * scalar products by known values if desired. + * + * @param sp Scalar products to be replaced automatically + * @return simplified expression */ +ex ex::simplify_indexed(const scalar_products & sp) const { - ASSERT(bp!=0); - return bp->get_indices(); + return GiNaC::simplify_indexed(*this, sp); } -ex ex::simplify_ncmul(exvector const & v) const +ex ex::simplify_ncmul(const exvector & v) const { - ASSERT(bp!=0); - return bp->simplify_ncmul(v); + GINAC_ASSERT(bp!=0); + return bp->simplify_ncmul(v); } -ex ex::operator[](ex const & index) const +ex ex::operator[](const ex & index) const { - debugmsg("ex operator[ex]",LOGLEVEL_OPERATOR); - ASSERT(bp!=0); - return (*bp)[index]; + debugmsg("ex operator[ex]",LOGLEVEL_OPERATOR); + GINAC_ASSERT(bp!=0); + return (*bp)[index]; } -ex ex::operator[](int const i) const +ex ex::operator[](int i) const { - debugmsg("ex operator[int]",LOGLEVEL_OPERATOR); - ASSERT(bp!=0); - return (*bp)[i]; + debugmsg("ex operator[int]",LOGLEVEL_OPERATOR); + GINAC_ASSERT(bp!=0); + return (*bp)[i]; } -ex ex::op(int const i) const +/** Return operand/member at position i. */ +ex ex::op(int i) const { - debugmsg("ex op()",LOGLEVEL_MEMBER_FUNCTION); - ASSERT(bp!=0); - return bp->op(i); + debugmsg("ex op()",LOGLEVEL_MEMBER_FUNCTION); + GINAC_ASSERT(bp!=0); + return bp->op(i); } -ex & ex::let_op(int const i) +/** Return modifyable operand/member at position i. */ +ex & ex::let_op(int i) { - debugmsg("ex let_op()",LOGLEVEL_MEMBER_FUNCTION); - makewriteable(); - ASSERT(bp!=0); - return bp->let_op(i); + debugmsg("ex let_op()",LOGLEVEL_MEMBER_FUNCTION); + makewriteable(); + GINAC_ASSERT(bp!=0); + return bp->let_op(i); } -#ifndef INLINE_EX_CONSTRUCTORS -int ex::compare(ex const & other) const +/** Left hand side of relational expression. */ +ex ex::lhs(void) const { - ASSERT(bp!=0); - ASSERT(other.bp!=0); - if (bp==other.bp) { - // special case: both expression point to same basic, trivially equal - return 0; - } - return bp->compare(*other.bp); + debugmsg("ex lhs()",LOGLEVEL_MEMBER_FUNCTION); + GINAC_ASSERT(is_ex_of_type(*this,relational)); + return (*static_cast(bp)).lhs(); } -#endif // ndef INLINE_EX_CONSTRUCTORS -#ifndef INLINE_EX_CONSTRUCTORS -bool ex::is_equal(ex const & other) const +/** Right hand side of relational expression. */ +ex ex::rhs(void) const { - ASSERT(bp!=0); - ASSERT(other.bp!=0); - if (bp==other.bp) { - // special case: both expression point to same basic, trivially equal - return true; - } - return bp->is_equal(*other.bp); + debugmsg("ex rhs()",LOGLEVEL_MEMBER_FUNCTION); + GINAC_ASSERT(is_ex_of_type(*this,relational)); + return (*static_cast(bp)).rhs(); } -#endif // ndef INLINE_EX_CONSTRUCTORS unsigned ex::return_type(void) const { - ASSERT(bp!=0); - return bp->return_type(); + GINAC_ASSERT(bp!=0); + return bp->return_type(); } unsigned ex::return_type_tinfo(void) const { - ASSERT(bp!=0); - return bp->return_type_tinfo(); + GINAC_ASSERT(bp!=0); + return bp->return_type_tinfo(); } unsigned ex::gethash(void) const { - ASSERT(bp!=0); - return bp->gethash(); -} - -ex ex::exadd(ex const & rh) const -{ - return (new add(*this,rh))->setflag(status_flags::dynallocated); + GINAC_ASSERT(bp!=0); + return bp->gethash(); } -ex ex::exmul(ex const & rh) const +/** Used internally by operator+() to add two ex objects together. */ +ex ex::exadd(const ex & rh) const { - return (new mul(*this,rh))->setflag(status_flags::dynallocated); + return (new add(*this,rh))->setflag(status_flags::dynallocated); } -ex ex::exncmul(ex const & rh) const +/** Used internally by operator*() to multiply two ex objects together. */ +ex ex::exmul(const ex & rh) const { - return (new ncmul(*this,rh))->setflag(status_flags::dynallocated); + // 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.bp->return_type()==return_types::commutative || + bp->return_type()==return_types::commutative) + return (new mul(*this,rh))->setflag(status_flags::dynallocated); + else + return (new ncmul(*this,rh))->setflag(status_flags::dynallocated); } // private +/** Make this ex writable (if more than one ex handle the same basic) by + * unlinking the object and creating an unshared copy of it. */ void ex::makewriteable() { - debugmsg("ex makewriteable",LOGLEVEL_MEMBER_FUNCTION); - ASSERT(bp!=0); - ASSERT(bp->flags & status_flags::dynallocated); - if (bp->refcount > 1) { - basic * bp2=bp->duplicate(); - ++bp2->refcount; - bp2->setflag(status_flags::dynallocated); - --bp->refcount; - bp=bp2; - } - ASSERT(bp->refcount == 1); -} - -void ex::construct_from_basic(basic const & other) -{ - if ( (other.flags & status_flags::evaluated)==0 ) { - // cf. copy constructor - ex const & tmpex = other.eval(1); // evaluate only one (top) level - bp = tmpex.bp; - ASSERT(bp!=0); - ASSERT(bp->flags & status_flags::dynallocated); - ++bp->refcount; - if ((other.flags & status_flags::dynallocated)&&(other.refcount==0)) { - delete &const_cast(other); - } - } else { - if (other.flags & status_flags::dynallocated) { - bp=&const_cast(other); - } else { - bp=other.duplicate(); - bp->setflag(status_flags::dynallocated); - } - ASSERT(bp!=0); - // bp->clearflag(status_flags::evaluated); - ++bp->refcount; - } - ASSERT(bp!=0); - ASSERT(bp->flags & status_flags::dynallocated); -} - + debugmsg("ex makewriteable",LOGLEVEL_MEMBER_FUNCTION); + GINAC_ASSERT(bp!=0); + GINAC_ASSERT(bp->flags & status_flags::dynallocated); + if (bp->refcount > 1) { + basic * bp2 = bp->duplicate(); + ++bp2->refcount; + bp2->setflag(status_flags::dynallocated); + --bp->refcount; + bp = bp2; + } + GINAC_ASSERT(bp->refcount==1); +} + +/** Ctor from basic implementation. + * @see ex::ex(const basic &) */ +void ex::construct_from_basic(const basic & other) +{ + if ((other.flags & status_flags::evaluated)==0) { + // cf. copy ctor + const ex & tmpex = other.eval(1); // evaluate only one (top) level + bp = tmpex.bp; + GINAC_ASSERT(bp!=0); + GINAC_ASSERT(bp->flags & status_flags::dynallocated); + ++bp->refcount; + if ((other.flags & status_flags::dynallocated)&&(other.refcount==0)) + delete &const_cast(other); + } else { + if (other.flags & status_flags::dynallocated) { + // ok, it is already on the heap, so just copy bp: + bp = &const_cast(other); + } else { + // create a duplicate on the heap: + bp = other.duplicate(); + bp->setflag(status_flags::dynallocated); + } + GINAC_ASSERT(bp!=0); + ++bp->refcount; + } + GINAC_ASSERT(bp!=0); + GINAC_ASSERT(bp->flags & status_flags::dynallocated); +} + +void ex::construct_from_int(int i) +{ + switch (i) { // some tiny efficiency-hack + case -2: + bp = _ex_2().bp; + ++bp->refcount; + break; + case -1: + bp = _ex_1().bp; + ++bp->refcount; + break; + case 0: + bp = _ex0().bp; + ++bp->refcount; + break; + case 1: + bp = _ex1().bp; + ++bp->refcount; + break; + case 2: + bp = _ex2().bp; + ++bp->refcount; + break; + default: + bp = new numeric(i); + bp->setflag(status_flags::dynallocated); + ++bp->refcount; + GINAC_ASSERT((bp->flags) & status_flags::dynallocated); + GINAC_ASSERT(bp->refcount==1); + } +} + +void ex::construct_from_uint(unsigned int i) +{ + switch (i) { // some tiny efficiency-hack + case 0: + bp = _ex0().bp; + ++bp->refcount; + break; + case 1: + bp = _ex1().bp; + ++bp->refcount; + break; + case 2: + bp = _ex2().bp; + ++bp->refcount; + break; + default: + bp = new numeric(i); + bp->setflag(status_flags::dynallocated); + ++bp->refcount; + GINAC_ASSERT((bp->flags) & status_flags::dynallocated); + GINAC_ASSERT(bp->refcount==1); + } +} + +void ex::construct_from_long(long i) +{ + switch (i) { // some tiny efficiency-hack + case -2: + bp = _ex_2().bp; + ++bp->refcount; + break; + case -1: + bp = _ex_1().bp; + ++bp->refcount; + break; + case 0: + bp = _ex0().bp; + ++bp->refcount; + break; + case 1: + bp = _ex1().bp; + ++bp->refcount; + break; + case 2: + bp = _ex2().bp; + ++bp->refcount; + break; + default: + bp = new numeric(i); + bp->setflag(status_flags::dynallocated); + ++bp->refcount; + GINAC_ASSERT((bp->flags) & status_flags::dynallocated); + GINAC_ASSERT(bp->refcount==1); + } +} + +void ex::construct_from_ulong(unsigned long i) +{ + switch (i) { // some tiny efficiency-hack + case 0: + bp = _ex0().bp; + ++bp->refcount; + break; + case 1: + bp = _ex1().bp; + ++bp->refcount; + break; + case 2: + bp = _ex2().bp; + ++bp->refcount; + break; + default: + bp = new numeric(i); + bp->setflag(status_flags::dynallocated); + ++bp->refcount; + GINAC_ASSERT((bp->flags) & status_flags::dynallocated); + GINAC_ASSERT(bp->refcount==1); + } +} + +void ex::construct_from_double(double d) +{ + bp = new numeric(d); + bp->setflag(status_flags::dynallocated); + ++bp->refcount; + GINAC_ASSERT((bp->flags) & status_flags::dynallocated); + GINAC_ASSERT(bp->refcount==1); +} + +void ex::construct_from_string_and_lst(const std::string &s, const ex &l) +{ + set_lexer_string(s); + set_lexer_symbols(l); + ginac_yyrestart(NULL); + if (ginac_yyparse()) + throw (std::runtime_error(get_parser_error())); + else { + bp = parsed_ex.bp; + GINAC_ASSERT(bp!=0); + GINAC_ASSERT((bp->flags) & status_flags::dynallocated); + ++bp->refcount; + } +} + ////////// // static member variables ////////// @@ -468,45 +520,7 @@ void ex::construct_from_basic(basic const & other) // global functions ////////// -ex const & exZERO(void) -{ - static ex * eZERO=new ex(numZERO()); - return *eZERO; -} - -ex const & exONE(void) -{ - static ex * eONE=new ex(numONE()); - return *eONE; -} - -ex const & exTWO(void) -{ - static ex * eTWO=new ex(numTWO()); - return *eTWO; -} - -ex const & exTHREE(void) -{ - static ex * eTHREE=new ex(numTHREE()); - return *eTHREE; -} - -ex const & exMINUSONE(void) -{ - static ex * eMINUSONE=new ex(numMINUSONE()); - return *eMINUSONE; -} - -ex const & exHALF(void) -{ - static ex * eHALF=new ex(ex(1)/ex(2)); - return *eHALF; -} +// none -ex const & exMINUSHALF(void) -{ - static ex * eMINUSHALF=new ex(numeric(-1,2)); - return *eMINUSHALF; -} +} // namespace GiNaC