X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fex.cpp;h=a5ede054b13eeb35ebb3b50fc90d4b3166a04a94;hp=944285d188ee3345910e85096413df5701433413;hb=0160f9ab1da453641e30539abcf0eaa4162582eb;hpb=cfea748404dec5fb2f2e3310d36eeb6640f13824 diff --git a/ginac/ex.cpp b/ginac/ex.cpp index 944285d1..a5ede054 100644 --- a/ginac/ex.cpp +++ b/ginac/ex.cpp @@ -3,7 +3,7 @@ * Implementation of GiNaC's light-weight expression handles. */ /* - * GiNaC Copyright (C) 1999-2001 Johannes Gutenberg University Mainz, Germany + * GiNaC Copyright (C) 1999-2005 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,7 +17,7 @@ * * 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 @@ -37,7 +37,7 @@ namespace GiNaC { ////////// -// other ctors +// other constructors ////////// // none (all inlined) @@ -48,19 +48,6 @@ namespace GiNaC { // public -/** Efficiently swap the contents of two expressions. */ -void ex::swap(ex & other) -{ - 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; -} - /** 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 @@ -68,36 +55,25 @@ void ex::swap(ex & other) * @see print_context */ void ex::print(const print_context & c, unsigned level) const { - GINAC_ASSERT(bp!=0); bp->print(c, level); } -/** Print expression to stream in a tree-like format suitable for debugging. */ -void ex::printtree(std::ostream & os) const -{ - GINAC_ASSERT(bp!=0); - bp->print(print_tree(os)); -} - /** Little wrapper arount print to be called within a debugger. */ -void ex::dbgprint(void) const +void ex::dbgprint() const { - GINAC_ASSERT(bp!=0); bp->dbgprint(); } /** Little wrapper arount printtree to be called within a debugger. */ -void ex::dbgprinttree(void) const +void ex::dbgprinttree() const { - GINAC_ASSERT(bp!=0); bp->dbgprinttree(); } ex ex::expand(unsigned options) const { - GINAC_ASSERT(bp!=0); if (options == 0 && (bp->flags & status_flags::expanded)) // The "expanded" flag only covers the standard options; someone might want to re-expand with different options - return *bp; + return *this; else return bp->expand(options); } @@ -109,8 +85,6 @@ ex ex::expand(unsigned options) const * @return partial derivative as a new expression */ ex ex::diff(const symbol & s, unsigned nth) const { - GINAC_ASSERT(bp!=0); - if (!nth) return *this; else @@ -137,46 +111,133 @@ bool ex::find(const ex & pattern, lst & found) const return true; } bool any_found = false; - for (unsigned i=0; i(*its) || is_exactly_a(*its)) + options |= subs_options::pattern_is_product; + } + if (!(options & subs_options::pattern_is_product)) + options |= subs_options::pattern_is_not_product; + + return bp->subs(m, options); } -ex ex::operator[](int i) const +/** Substitute objects in an expression (syntactic substitution) and return + * the result as a new expression. There are two valid types of + * replacement arguments: 1) a relational like object==ex and 2) a list of + * relationals lst(object1==ex1,object2==ex2,...). */ +ex ex::subs(const ex & e, unsigned options) const { - GINAC_ASSERT(bp!=0); - return (*bp)[i]; + if (e.info(info_flags::relation_equal)) { + + // Argument is a relation: convert it to a map + exmap m; + const ex & s = e.op(0); + m.insert(std::make_pair(s, e.op(1))); + + if (is_exactly_a(s) || is_exactly_a(s)) + options |= subs_options::pattern_is_product; + else + options |= subs_options::pattern_is_not_product; + + return bp->subs(m, options); + + } else if (e.info(info_flags::list)) { + + // Argument is a list: convert it to a map + exmap m; + GINAC_ASSERT(is_a(e)); + for (lst::const_iterator it = ex_to(e).begin(); it != ex_to(e).end(); ++it) { + ex r = *it; + if (!r.info(info_flags::relation_equal)) + throw(std::invalid_argument("basic::subs(ex): argument must be a list of equations")); + const ex & s = r.op(0); + m.insert(std::make_pair(s, r.op(1))); + + // Search for products and powers in the expressions to be substituted + // (for an optimization in expairseq::subs()) + if (is_exactly_a(s) || is_exactly_a(s)) + options |= subs_options::pattern_is_product; + } + if (!(options & subs_options::pattern_is_product)) + options |= subs_options::pattern_is_not_product; + + return bp->subs(m, options); + + } else + throw(std::invalid_argument("ex::subs(ex): argument must be a relation_equal or a list")); +} + +/** Traverse expression tree with given visitor, preorder traversal. */ +void ex::traverse_preorder(visitor & v) const +{ + accept(v); + + size_t n = nops(); + for (size_t i = 0; i < n; ++i) + op(i).traverse_preorder(v); +} + +/** Traverse expression tree with given visitor, postorder traversal. */ +void ex::traverse_postorder(visitor & v) const +{ + size_t n = nops(); + for (size_t i = 0; i < n; ++i) + op(i).traverse_postorder(v); + + accept(v); } /** Return modifyable operand/member at position i. */ -ex & ex::let_op(int i) +ex & ex::let_op(size_t i) { makewriteable(); - GINAC_ASSERT(bp!=0); return bp->let_op(i); } +ex & ex::operator[](const ex & index) +{ + makewriteable(); + return (*bp)[index]; +} + +ex & ex::operator[](size_t i) +{ + makewriteable(); + return (*bp)[i]; +} + /** Left hand side of relational expression. */ -ex ex::lhs(void) const +ex ex::lhs() const { - if (!is_ex_of_type(*this,relational)) + if (!is_a(*this)) throw std::runtime_error("ex::lhs(): not a relation"); - return (*static_cast(bp)).lhs(); + return bp->op(0); } /** Right hand side of relational expression. */ -ex ex::rhs(void) const +ex ex::rhs() const { - if (!is_ex_of_type(*this,relational)) + if (!is_a(*this)) throw std::runtime_error("ex::rhs(): not a relation"); - return (*static_cast(bp)).rhs(); + return bp->op(1); } // private @@ -185,419 +246,298 @@ ex ex::rhs(void) const * unlinking the object and creating an unshared copy of it. */ void ex::makewriteable() { - 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); + bp.makewritable(); + GINAC_ASSERT(bp->get_refcount() == 1); +} + +/** Share equal objects between expressions. + * @see ex::compare(const ex &) */ +void ex::share(const ex & other) const +{ + if ((bp->flags | other.bp->flags) & status_flags::not_shareable) + return; + + if (bp->get_refcount() <= other.bp->get_refcount()) + bp = other.bp; + else + other.bp = bp; } -/** Ctor from basic implementation. +/** Helper function for the ex-from-basic constructor. This is where GiNaC's + * automatic evaluator and memory management are implemented. * @see ex::ex(const basic &) */ -void ex::construct_from_basic(const basic & other) +ptr ex::construct_from_basic(const basic & other) { if (!(other.flags & status_flags::evaluated)) { - const ex & tmpex = other.eval(1); // evaluate only one (top) level - bp = tmpex.bp; - GINAC_ASSERT(bp->flags & status_flags::dynallocated); - ++bp->refcount; - if ((other.refcount==0) && (other.flags & status_flags::dynallocated)) - delete &const_cast(other); + + // The object is not yet evaluated, so call eval() to evaluate + // the top level. This will return either + // a) the original object with status_flags::evaluated set (when the + // eval() implementation calls hold()) + // or + // b) a different expression. + // + // eval() returns an ex, not a basic&, so this will go through + // construct_from_basic() a second time. In case a) we end up in + // the "else" branch below. In case b) we end up here again and + // apply eval() once more. The recursion stops when eval() calls + // hold() or returns an object that already has its "evaluated" + // flag set, such as a symbol or a numeric. + const ex & tmpex = other.eval(1); + + // Eventually, the eval() recursion goes through the "else" branch + // below, which assures that the object pointed to by tmpex.bp is + // allocated on the heap (either it was already on the heap or it + // is a heap-allocated duplicate of another object). + GINAC_ASSERT(tmpex.bp->flags & status_flags::dynallocated); + + // If the original object is not referenced but heap-allocated, + // it means that eval() hit case b) above. The original object is + // no longer needed (it evaluated into something different), so we + // delete it (because nobody else will). + if ((other.get_refcount() == 0) && (other.flags & status_flags::dynallocated)) + delete &other; // yes, you can apply delete to a const pointer + + // We can't return a basic& here because the tmpex is destroyed as + // soon as we leave the function, which would deallocate the + // evaluated object. + return tmpex.bp; + } else { + + // The easy case: making an "ex" out of an evaluated object. if (other.flags & status_flags::dynallocated) { - // ok, it is already on the heap, so just copy bp: - bp = &const_cast(other); + + // The object is already heap-allocated, so we can just make + // another reference to it. + return ptr(const_cast(other)); + } else { - // create a duplicate on the heap: - bp = other.duplicate(); + + // The object is not heap-allocated, so we create a duplicate + // on the heap. + basic *bp = other.duplicate(); bp->setflag(status_flags::dynallocated); + GINAC_ASSERT(bp->get_refcount() == 0); + return bp; } - GINAC_ASSERT(bp!=0); - ++bp->refcount; } - GINAC_ASSERT(bp!=0); - GINAC_ASSERT(bp->flags & status_flags::dynallocated); } -void ex::construct_from_int(int i) +basic & ex::construct_from_int(int i) { switch (i) { // prefer flyweights over new objects case -12: - bp = (basic*)_num_12_p; - ++bp->refcount; - break; + return *const_cast(_num_12_p); case -11: - bp = (basic*)_num_11_p; - ++bp->refcount; - break; + return *const_cast(_num_11_p); case -10: - bp = (basic*)_num_10_p; - ++bp->refcount; - break; + return *const_cast(_num_10_p); case -9: - bp = (basic*)_num_9_p; - ++bp->refcount; - break; + return *const_cast(_num_9_p); case -8: - bp = (basic*)_num_8_p; - ++bp->refcount; - break; + return *const_cast(_num_8_p); case -7: - bp = (basic*)_num_7_p; - ++bp->refcount; - break; + return *const_cast(_num_7_p); case -6: - bp = (basic*)_num_6_p; - ++bp->refcount; - break; + return *const_cast(_num_6_p); case -5: - bp = (basic*)_num_5_p; - ++bp->refcount; - break; + return *const_cast(_num_5_p); case -4: - bp = (basic*)_num_4_p; - ++bp->refcount; - break; + return *const_cast(_num_4_p); case -3: - bp = (basic*)_num_3_p; - ++bp->refcount; - break; + return *const_cast(_num_3_p); case -2: - bp = (basic*)_num_2_p; - ++bp->refcount; - break; + return *const_cast(_num_2_p); case -1: - bp = (basic*)_num_1_p; - ++bp->refcount; - break; + return *const_cast(_num_1_p); case 0: - bp = (basic*)_num0_p; - ++bp->refcount; - break; + return *const_cast(_num0_p); case 1: - bp = (basic*)_num1_p; - ++bp->refcount; - break; + return *const_cast(_num1_p); case 2: - bp = (basic*)_num2_p; - ++bp->refcount; - break; + return *const_cast(_num2_p); case 3: - bp = (basic*)_num3_p; - ++bp->refcount; - break; + return *const_cast(_num3_p); case 4: - bp = (basic*)_num4_p; - ++bp->refcount; - break; + return *const_cast(_num4_p); case 5: - bp = (basic*)_num5_p; - ++bp->refcount; - break; + return *const_cast(_num5_p); case 6: - bp = (basic*)_num6_p; - ++bp->refcount; - break; + return *const_cast(_num6_p); case 7: - bp = (basic*)_num7_p; - ++bp->refcount; - break; + return *const_cast(_num7_p); case 8: - bp = (basic*)_num8_p; - ++bp->refcount; - break; + return *const_cast(_num8_p); case 9: - bp = (basic*)_num9_p; - ++bp->refcount; - break; + return *const_cast(_num9_p); case 10: - bp = (basic*)_num10_p; - ++bp->refcount; - break; + return *const_cast(_num10_p); case 11: - bp = (basic*)_num11_p; - ++bp->refcount; - break; + return *const_cast(_num11_p); case 12: - bp = (basic*)_num12_p; - ++bp->refcount; - break; + return *const_cast(_num12_p); default: - bp = new numeric(i); + basic *bp = new numeric(i); bp->setflag(status_flags::dynallocated); - ++bp->refcount; - GINAC_ASSERT((bp->flags) & status_flags::dynallocated); - GINAC_ASSERT(bp->refcount==1); + GINAC_ASSERT(bp->get_refcount() == 0); + return *bp; } } -void ex::construct_from_uint(unsigned int i) +basic & ex::construct_from_uint(unsigned int i) { switch (i) { // prefer flyweights over new objects case 0: - bp = (basic*)_num0_p; - ++bp->refcount; - break; + return *const_cast(_num0_p); case 1: - bp = (basic*)_num1_p; - ++bp->refcount; - break; + return *const_cast(_num1_p); case 2: - bp = (basic*)_num2_p; - ++bp->refcount; - break; + return *const_cast(_num2_p); case 3: - bp = (basic*)_num3_p; - ++bp->refcount; - break; + return *const_cast(_num3_p); case 4: - bp = (basic*)_num4_p; - ++bp->refcount; - break; + return *const_cast(_num4_p); case 5: - bp = (basic*)_num5_p; - ++bp->refcount; - break; + return *const_cast(_num5_p); case 6: - bp = (basic*)_num6_p; - ++bp->refcount; - break; + return *const_cast(_num6_p); case 7: - bp = (basic*)_num7_p; - ++bp->refcount; - break; + return *const_cast(_num7_p); case 8: - bp = (basic*)_num8_p; - ++bp->refcount; - break; + return *const_cast(_num8_p); case 9: - bp = (basic*)_num9_p; - ++bp->refcount; - break; + return *const_cast(_num9_p); case 10: - bp = (basic*)_num10_p; - ++bp->refcount; - break; + return *const_cast(_num10_p); case 11: - bp = (basic*)_num11_p; - ++bp->refcount; - break; + return *const_cast(_num11_p); case 12: - bp = (basic*)_num12_p; - ++bp->refcount; - break; + return *const_cast(_num12_p); default: - bp = new numeric(i); + basic *bp = new numeric(i); bp->setflag(status_flags::dynallocated); - ++bp->refcount; - GINAC_ASSERT((bp->flags) & status_flags::dynallocated); - GINAC_ASSERT(bp->refcount==1); + GINAC_ASSERT(bp->get_refcount() == 0); + return *bp; } } -void ex::construct_from_long(long i) +basic & ex::construct_from_long(long i) { switch (i) { // prefer flyweights over new objects case -12: - bp = (basic*)_num_12_p; - ++bp->refcount; - break; + return *const_cast(_num_12_p); case -11: - bp = (basic*)_num_11_p; - ++bp->refcount; - break; + return *const_cast(_num_11_p); case -10: - bp = (basic*)_num_10_p; - ++bp->refcount; - break; + return *const_cast(_num_10_p); case -9: - bp = (basic*)_num_9_p; - ++bp->refcount; - break; + return *const_cast(_num_9_p); case -8: - bp = (basic*)_num_8_p; - ++bp->refcount; - break; + return *const_cast(_num_8_p); case -7: - bp = (basic*)_num_7_p; - ++bp->refcount; - break; + return *const_cast(_num_7_p); case -6: - bp = (basic*)_num_6_p; - ++bp->refcount; - break; + return *const_cast(_num_6_p); case -5: - bp = (basic*)_num_5_p; - ++bp->refcount; - break; + return *const_cast(_num_5_p); case -4: - bp = (basic*)_num_4_p; - ++bp->refcount; - break; + return *const_cast(_num_4_p); case -3: - bp = (basic*)_num_3_p; - ++bp->refcount; - break; + return *const_cast(_num_3_p); case -2: - bp = (basic*)_num_2_p; - ++bp->refcount; - break; + return *const_cast(_num_2_p); case -1: - bp = (basic*)_num_1_p; - ++bp->refcount; - break; + return *const_cast(_num_1_p); case 0: - bp = (basic*)_num0_p; - ++bp->refcount; - break; + return *const_cast(_num0_p); case 1: - bp = (basic*)_num1_p; - ++bp->refcount; - break; + return *const_cast(_num1_p); case 2: - bp = (basic*)_num2_p; - ++bp->refcount; - break; + return *const_cast(_num2_p); case 3: - bp = (basic*)_num3_p; - ++bp->refcount; - break; + return *const_cast(_num3_p); case 4: - bp = (basic*)_num4_p; - ++bp->refcount; - break; + return *const_cast(_num4_p); case 5: - bp = (basic*)_num5_p; - ++bp->refcount; - break; + return *const_cast(_num5_p); case 6: - bp = (basic*)_num6_p; - ++bp->refcount; - break; + return *const_cast(_num6_p); case 7: - bp = (basic*)_num7_p; - ++bp->refcount; - break; + return *const_cast(_num7_p); case 8: - bp = (basic*)_num8_p; - ++bp->refcount; - break; + return *const_cast(_num8_p); case 9: - bp = (basic*)_num9_p; - ++bp->refcount; - break; + return *const_cast(_num9_p); case 10: - bp = (basic*)_num10_p; - ++bp->refcount; - break; + return *const_cast(_num10_p); case 11: - bp = (basic*)_num11_p; - ++bp->refcount; - break; + return *const_cast(_num11_p); case 12: - bp = (basic*)_num12_p; - ++bp->refcount; - break; + return *const_cast(_num12_p); default: - bp = new numeric(i); + basic *bp = new numeric(i); bp->setflag(status_flags::dynallocated); - ++bp->refcount; - GINAC_ASSERT((bp->flags) & status_flags::dynallocated); - GINAC_ASSERT(bp->refcount==1); + GINAC_ASSERT(bp->get_refcount() == 0); + return *bp; } } -void ex::construct_from_ulong(unsigned long i) +basic & ex::construct_from_ulong(unsigned long i) { switch (i) { // prefer flyweights over new objects case 0: - bp = (basic*)_num0_p; - ++bp->refcount; - break; + return *const_cast(_num0_p); case 1: - bp = (basic*)_num1_p; - ++bp->refcount; - break; + return *const_cast(_num1_p); case 2: - bp = (basic*)_num2_p; - ++bp->refcount; - break; + return *const_cast(_num2_p); case 3: - bp = (basic*)_num3_p; - ++bp->refcount; - break; + return *const_cast(_num3_p); case 4: - bp = (basic*)_num4_p; - ++bp->refcount; - break; + return *const_cast(_num4_p); case 5: - bp = (basic*)_num5_p; - ++bp->refcount; - break; + return *const_cast(_num5_p); case 6: - bp = (basic*)_num6_p; - ++bp->refcount; - break; + return *const_cast(_num6_p); case 7: - bp = (basic*)_num7_p; - ++bp->refcount; - break; + return *const_cast(_num7_p); case 8: - bp = (basic*)_num8_p; - ++bp->refcount; - break; + return *const_cast(_num8_p); case 9: - bp = (basic*)_num9_p; - ++bp->refcount; - break; + return *const_cast(_num9_p); case 10: - bp = (basic*)_num10_p; - ++bp->refcount; - break; + return *const_cast(_num10_p); case 11: - bp = (basic*)_num11_p; - ++bp->refcount; - break; + return *const_cast(_num11_p); case 12: - bp = (basic*)_num12_p; - ++bp->refcount; - break; + return *const_cast(_num12_p); default: - bp = new numeric(i); + basic *bp = new numeric(i); bp->setflag(status_flags::dynallocated); - ++bp->refcount; - GINAC_ASSERT((bp->flags) & status_flags::dynallocated); - GINAC_ASSERT(bp->refcount==1); + GINAC_ASSERT(bp->get_refcount() == 0); + return *bp; } } -void ex::construct_from_double(double d) +basic & ex::construct_from_double(double d) { - bp = new numeric(d); + basic *bp = new numeric(d); bp->setflag(status_flags::dynallocated); - ++bp->refcount; - GINAC_ASSERT((bp->flags) & status_flags::dynallocated); - GINAC_ASSERT(bp->refcount==1); + GINAC_ASSERT(bp->get_refcount() == 0); + return *bp; } -void ex::construct_from_string_and_lst(const std::string &s, const ex &l) +ptr 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; - } + else + return parsed_ex.bp; } //////////