X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fex.cpp;h=c69b30b08b92128a3287cbfd9961acb7e1fe4159;hp=42cde03a546c2e660bbf21bdcb843c59ea927556;hb=dbd9c306a74f1cb258c0d15a346b973b39deaad2;hpb=06eb6b761f4b9d9eed4decd8ed50d94b40b94a0e diff --git a/ginac/ex.cpp b/ginac/ex.cpp index 42cde03a..c69b30b0 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-2003 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 @@ -29,10 +29,9 @@ #include "ncmul.h" #include "numeric.h" #include "power.h" +#include "lst.h" #include "relational.h" -#include "indexed.h" #include "input_lexer.h" -#include "debugmsg.h" #include "utils.h" namespace GiNaC { @@ -43,39 +42,12 @@ namespace GiNaC { // none (all inlined) -////////// -// functions overriding virtual functions from bases classes -////////// - -// none - -////////// -// new virtual functions which can be overridden by derived classes -////////// - -// none - ////////// // non-virtual functions in this class ////////// // public - -/** Efficiently swap the contents of two expressions. */ -void ex::swap(ex & other) -{ - debugmsg("ex swap",LOGLEVEL_MEMBER_FUNCTION); - - 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 @@ -83,7 +55,6 @@ void ex::swap(ex & other) * @see print_context */ void ex::print(const print_context & c, unsigned level) const { - debugmsg("ex print", LOGLEVEL_PRINT); GINAC_ASSERT(bp!=0); bp->print(c, level); } @@ -91,7 +62,6 @@ void ex::print(const print_context & c, unsigned level) const /** Print expression to stream in a tree-like format suitable for debugging. */ void ex::printtree(std::ostream & os) const { - debugmsg("ex printtree", LOGLEVEL_PRINT); GINAC_ASSERT(bp!=0); bp->print(print_tree(os)); } @@ -99,7 +69,6 @@ void ex::printtree(std::ostream & os) const /** Little wrapper arount print to be called within a debugger. */ void ex::dbgprint(void) const { - debugmsg("ex dbgprint", LOGLEVEL_PRINT); GINAC_ASSERT(bp!=0); bp->dbgprint(); } @@ -107,73 +76,19 @@ void ex::dbgprint(void) const /** Little wrapper arount printtree to be called within a debugger. */ void ex::dbgprinttree(void) const { - debugmsg("ex dbgprinttree", LOGLEVEL_PRINT); GINAC_ASSERT(bp!=0); bp->dbgprinttree(); } -bool ex::info(unsigned inf) const -{ - return bp->info(inf); -} - -unsigned ex::nops() const -{ - GINAC_ASSERT(bp!=0); - return bp->nops(); -} - ex ex::expand(unsigned options) const { GINAC_ASSERT(bp!=0); - if (bp->flags & status_flags::expanded) + 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; else return bp->expand(options); } -bool ex::has(const ex & other) const -{ - GINAC_ASSERT(bp!=0); - return bp->has(other); -} - -int ex::degree(const ex & s) const -{ - GINAC_ASSERT(bp!=0); - return bp->degree(s); -} - -int ex::ldegree(const ex & s) const -{ - GINAC_ASSERT(bp!=0); - return bp->ldegree(s); -} - -ex ex::coeff(const ex & s, int n) const -{ - GINAC_ASSERT(bp!=0); - return bp->coeff(s,n); -} - -ex ex::collect(const ex & s) const -{ - GINAC_ASSERT(bp!=0); - return bp->collect(s); -} - -ex ex::eval(int level) const -{ - GINAC_ASSERT(bp!=0); - return bp->eval(level); -} - -ex ex::evalf(int level) const -{ - GINAC_ASSERT(bp!=0); - return bp->evalf(level); -} - /** Compute partial derivative of an expression. * * @param s symbol by which the expression is derived @@ -189,79 +104,47 @@ ex ex::diff(const symbol & s, unsigned nth) const return bp->diff(s, nth); } -ex ex::subs(const lst & ls, const lst & lr) const -{ - GINAC_ASSERT(bp!=0); - return bp->subs(ls,lr); -} - -ex ex::subs(const ex & e) const -{ - GINAC_ASSERT(bp!=0); - return bp->subs(e); -} - -/** Return a vector containing the free indices of the object. */ -exvector ex::get_free_indices(void) const -{ - GINAC_ASSERT(bp!=0); - return bp->get_free_indices(); -} - -/** 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 +/** Check whether expression matches a specified pattern. */ +bool ex::match(const ex & pattern) const { - return GiNaC::simplify_indexed(*this); + lst repl_lst; + return bp->match(pattern, repl_lst); } -/** 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 +/** Find all occurrences of a pattern. The found matches are appended to + * the "found" list. If the expression itself matches the pattern, the + * children are not further examined. This function returns true when any + * matches were found. */ +bool ex::find(const ex & pattern, lst & found) const { - return GiNaC::simplify_indexed(*this, sp); -} - -ex ex::simplify_ncmul(const exvector & v) const -{ - GINAC_ASSERT(bp!=0); - return bp->simplify_ncmul(v); + if (match(pattern)) { + found.append(*this); + found.sort(); + found.unique(); + return true; + } + bool any_found = false; + for (unsigned i=0; iop(i); -} - /** Return modifyable operand/member at position i. */ ex & ex::let_op(int i) { - debugmsg("ex let_op()",LOGLEVEL_MEMBER_FUNCTION); makewriteable(); GINAC_ASSERT(bp!=0); return bp->let_op(i); @@ -270,63 +153,25 @@ ex & ex::let_op(int i) /** Left hand side of relational expression. */ ex ex::lhs(void) const { - debugmsg("ex lhs()",LOGLEVEL_MEMBER_FUNCTION); - GINAC_ASSERT(is_ex_of_type(*this,relational)); + if (!is_ex_of_type(*this,relational)) + throw std::runtime_error("ex::lhs(): not a relation"); return (*static_cast(bp)).lhs(); } /** Right hand side of relational expression. */ ex ex::rhs(void) const { - debugmsg("ex rhs()",LOGLEVEL_MEMBER_FUNCTION); - GINAC_ASSERT(is_ex_of_type(*this,relational)); + if (!is_ex_of_type(*this,relational)) + throw std::runtime_error("ex::rhs(): not a relation"); return (*static_cast(bp)).rhs(); } -unsigned ex::return_type(void) const -{ - GINAC_ASSERT(bp!=0); - return bp->return_type(); -} - -unsigned ex::return_type_tinfo(void) const -{ - GINAC_ASSERT(bp!=0); - return bp->return_type_tinfo(); -} - -unsigned ex::gethash(void) const -{ - GINAC_ASSERT(bp!=0); - return bp->gethash(); -} - -/** Used internally by operator+() to add two ex objects together. */ -ex ex::exadd(const ex & rh) const -{ - return (new add(*this,rh))->setflag(status_flags::dynallocated); -} - -/** Used internally by operator*() to multiply two ex objects together. */ -ex ex::exmul(const ex & rh) const -{ - // 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); GINAC_ASSERT(bp!=0); GINAC_ASSERT(bp->flags & status_flags::dynallocated); if (bp->refcount > 1) { @@ -343,14 +188,12 @@ void ex::makewriteable() * @see ex::ex(const basic &) */ void ex::construct_from_basic(const basic & other) { - if ((other.flags & status_flags::evaluated)==0) { - // cf. copy ctor + if (!(other.flags & status_flags::evaluated)) { 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)) + if ((other.refcount==0) && (other.flags & status_flags::dynallocated)) delete &const_cast(other); } else { if (other.flags & status_flags::dynallocated) { @@ -370,25 +213,105 @@ void ex::construct_from_basic(const basic & other) void ex::construct_from_int(int i) { - switch (i) { // some tiny efficiency-hack + switch (i) { // prefer flyweights over new objects + case -12: + bp = (basic*)_num_12_p; + ++bp->refcount; + break; + case -11: + bp = (basic*)_num_11_p; + ++bp->refcount; + break; + case -10: + bp = (basic*)_num_10_p; + ++bp->refcount; + break; + case -9: + bp = (basic*)_num_9_p; + ++bp->refcount; + break; + case -8: + bp = (basic*)_num_8_p; + ++bp->refcount; + break; + case -7: + bp = (basic*)_num_7_p; + ++bp->refcount; + break; + case -6: + bp = (basic*)_num_6_p; + ++bp->refcount; + break; + case -5: + bp = (basic*)_num_5_p; + ++bp->refcount; + break; + case -4: + bp = (basic*)_num_4_p; + ++bp->refcount; + break; + case -3: + bp = (basic*)_num_3_p; + ++bp->refcount; + break; case -2: - bp = _ex_2().bp; + bp = (basic*)_num_2_p; ++bp->refcount; break; case -1: - bp = _ex_1().bp; + bp = (basic*)_num_1_p; ++bp->refcount; break; case 0: - bp = _ex0().bp; + bp = (basic*)_num0_p; ++bp->refcount; break; case 1: - bp = _ex1().bp; + bp = (basic*)_num1_p; ++bp->refcount; break; case 2: - bp = _ex2().bp; + bp = (basic*)_num2_p; + ++bp->refcount; + break; + case 3: + bp = (basic*)_num3_p; + ++bp->refcount; + break; + case 4: + bp = (basic*)_num4_p; + ++bp->refcount; + break; + case 5: + bp = (basic*)_num5_p; + ++bp->refcount; + break; + case 6: + bp = (basic*)_num6_p; + ++bp->refcount; + break; + case 7: + bp = (basic*)_num7_p; + ++bp->refcount; + break; + case 8: + bp = (basic*)_num8_p; + ++bp->refcount; + break; + case 9: + bp = (basic*)_num9_p; + ++bp->refcount; + break; + case 10: + bp = (basic*)_num10_p; + ++bp->refcount; + break; + case 11: + bp = (basic*)_num11_p; + ++bp->refcount; + break; + case 12: + bp = (basic*)_num12_p; ++bp->refcount; break; default: @@ -402,17 +325,57 @@ void ex::construct_from_int(int i) void ex::construct_from_uint(unsigned int i) { - switch (i) { // some tiny efficiency-hack + switch (i) { // prefer flyweights over new objects case 0: - bp = _ex0().bp; + bp = (basic*)_num0_p; ++bp->refcount; break; case 1: - bp = _ex1().bp; + bp = (basic*)_num1_p; ++bp->refcount; break; case 2: - bp = _ex2().bp; + bp = (basic*)_num2_p; + ++bp->refcount; + break; + case 3: + bp = (basic*)_num3_p; + ++bp->refcount; + break; + case 4: + bp = (basic*)_num4_p; + ++bp->refcount; + break; + case 5: + bp = (basic*)_num5_p; + ++bp->refcount; + break; + case 6: + bp = (basic*)_num6_p; + ++bp->refcount; + break; + case 7: + bp = (basic*)_num7_p; + ++bp->refcount; + break; + case 8: + bp = (basic*)_num8_p; + ++bp->refcount; + break; + case 9: + bp = (basic*)_num9_p; + ++bp->refcount; + break; + case 10: + bp = (basic*)_num10_p; + ++bp->refcount; + break; + case 11: + bp = (basic*)_num11_p; + ++bp->refcount; + break; + case 12: + bp = (basic*)_num12_p; ++bp->refcount; break; default: @@ -426,25 +389,105 @@ void ex::construct_from_uint(unsigned int i) void ex::construct_from_long(long i) { - switch (i) { // some tiny efficiency-hack + switch (i) { // prefer flyweights over new objects + case -12: + bp = (basic*)_num_12_p; + ++bp->refcount; + break; + case -11: + bp = (basic*)_num_11_p; + ++bp->refcount; + break; + case -10: + bp = (basic*)_num_10_p; + ++bp->refcount; + break; + case -9: + bp = (basic*)_num_9_p; + ++bp->refcount; + break; + case -8: + bp = (basic*)_num_8_p; + ++bp->refcount; + break; + case -7: + bp = (basic*)_num_7_p; + ++bp->refcount; + break; + case -6: + bp = (basic*)_num_6_p; + ++bp->refcount; + break; + case -5: + bp = (basic*)_num_5_p; + ++bp->refcount; + break; + case -4: + bp = (basic*)_num_4_p; + ++bp->refcount; + break; + case -3: + bp = (basic*)_num_3_p; + ++bp->refcount; + break; case -2: - bp = _ex_2().bp; + bp = (basic*)_num_2_p; ++bp->refcount; break; case -1: - bp = _ex_1().bp; + bp = (basic*)_num_1_p; ++bp->refcount; break; case 0: - bp = _ex0().bp; + bp = (basic*)_num0_p; ++bp->refcount; break; case 1: - bp = _ex1().bp; + bp = (basic*)_num1_p; ++bp->refcount; break; case 2: - bp = _ex2().bp; + bp = (basic*)_num2_p; + ++bp->refcount; + break; + case 3: + bp = (basic*)_num3_p; + ++bp->refcount; + break; + case 4: + bp = (basic*)_num4_p; + ++bp->refcount; + break; + case 5: + bp = (basic*)_num5_p; + ++bp->refcount; + break; + case 6: + bp = (basic*)_num6_p; + ++bp->refcount; + break; + case 7: + bp = (basic*)_num7_p; + ++bp->refcount; + break; + case 8: + bp = (basic*)_num8_p; + ++bp->refcount; + break; + case 9: + bp = (basic*)_num9_p; + ++bp->refcount; + break; + case 10: + bp = (basic*)_num10_p; + ++bp->refcount; + break; + case 11: + bp = (basic*)_num11_p; + ++bp->refcount; + break; + case 12: + bp = (basic*)_num12_p; ++bp->refcount; break; default: @@ -458,17 +501,57 @@ void ex::construct_from_long(long i) void ex::construct_from_ulong(unsigned long i) { - switch (i) { // some tiny efficiency-hack + switch (i) { // prefer flyweights over new objects case 0: - bp = _ex0().bp; + bp = (basic*)_num0_p; ++bp->refcount; break; case 1: - bp = _ex1().bp; + bp = (basic*)_num1_p; ++bp->refcount; break; case 2: - bp = _ex2().bp; + bp = (basic*)_num2_p; + ++bp->refcount; + break; + case 3: + bp = (basic*)_num3_p; + ++bp->refcount; + break; + case 4: + bp = (basic*)_num4_p; + ++bp->refcount; + break; + case 5: + bp = (basic*)_num5_p; + ++bp->refcount; + break; + case 6: + bp = (basic*)_num6_p; + ++bp->refcount; + break; + case 7: + bp = (basic*)_num7_p; + ++bp->refcount; + break; + case 8: + bp = (basic*)_num8_p; + ++bp->refcount; + break; + case 9: + bp = (basic*)_num9_p; + ++bp->refcount; + break; + case 10: + bp = (basic*)_num10_p; + ++bp->refcount; + break; + case 11: + bp = (basic*)_num11_p; + ++bp->refcount; + break; + case 12: + bp = (basic*)_num12_p; ++bp->refcount; break; default: