X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fex.cpp;h=944285d188ee3345910e85096413df5701433413;hp=5414cd5a8dc195944fb96b6d3fc0d81dac8e2179;hb=3a63743e24046766b37c3d1bd38605542ee0a536;hpb=57b66d879a72c007eabe081420de11757b5bcf90 diff --git a/ginac/ex.cpp b/ginac/ex.cpp index 5414cd5a..944285d1 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-2000 Johannes Gutenberg University Mainz, Germany + * 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 @@ -29,208 +29,59 @@ #include "ncmul.h" #include "numeric.h" #include "power.h" +#include "lst.h" #include "relational.h" #include "input_lexer.h" -#include "debugmsg.h" #include "utils.h" -#ifndef NO_NAMESPACE_GINAC namespace GiNaC { -#endif // ndef NO_NAMESPACE_GINAC ////////// -// default constructor, destructor, copy constructor assignment operator and helpers +// other ctors ////////// -// public - -#ifndef INLINE_EX_CONSTRUCTORS - -ex::ex() : bp(_ex0().bp) -{ - debugmsg("ex default constructor",LOGLEVEL_CONSTRUCT); - GINAC_ASSERT(_ex0().bp!=0); - GINAC_ASSERT(_ex0().bp->flags & status_flags::dynallocated); - GINAC_ASSERT(bp!=0); - ++bp->refcount; -} - -ex::~ex() -{ - debugmsg("ex destructor",LOGLEVEL_DESTRUCT); - GINAC_ASSERT(bp!=0); - GINAC_ASSERT(bp->flags & status_flags::dynallocated); - if (--bp->refcount == 0) { - delete bp; - } -} - -ex::ex(const ex & other) : bp(other.bp) -{ - debugmsg("ex copy constructor",LOGLEVEL_CONSTRUCT); - GINAC_ASSERT(bp!=0); - GINAC_ASSERT((bp->flags) & status_flags::dynallocated); - ++bp->refcount; -} - -const ex & ex::operator=(const ex & other) -{ - debugmsg("ex operator=",LOGLEVEL_ASSIGNMENT); - GINAC_ASSERT(bp!=0); - GINAC_ASSERT(bp->flags & status_flags::dynallocated); - GINAC_ASSERT(other.bp!=0); - GINAC_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 - -////////// -// other constructors -////////// - -// public - -#ifndef INLINE_EX_CONSTRUCTORS - -ex::ex(const basic & other) -{ - debugmsg("ex constructor from basic",LOGLEVEL_CONSTRUCT); - construct_from_basic(other); -} - -ex::ex(int i) -{ - debugmsg("ex constructor from int",LOGLEVEL_CONSTRUCT); - construct_from_int(i); -} - -ex::ex(unsigned int i) -{ - debugmsg("ex constructor from unsigned int",LOGLEVEL_CONSTRUCT); - construct_from_uint(i); -} - -ex::ex(long i) -{ - debugmsg("ex constructor from long",LOGLEVEL_CONSTRUCT); - construct_from_long(i); -} - -ex::ex(unsigned long i) -{ - debugmsg("ex constructor from unsigned long",LOGLEVEL_CONSTRUCT); - construct_from_ulong(i); -} - -ex::ex(double const d) -{ - debugmsg("ex constructor from double",LOGLEVEL_CONSTRUCT); - construct_from_double(d); -} - -ex::ex(const std::string &s, const ex &l) -{ - debugmsg("ex constructor from string,lst",LOGLEVEL_CONSTRUCT); - construct_from_string_and_lst(s, l); -} - -#endif // ndef INLINE_EX_CONSTRUCTORS - -////////// -// functions overriding virtual functions from bases classes -////////// - -// none - -////////// -// new virtual functions which can be overridden by derived classes -////////// - -// none +// none (all inlined) ////////// // non-virtual functions in this class ////////// // public - -/** Swap the contents of two expressions. */ + +/** 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; -} - -/** Output formatted to be useful as ginsh input. */ -void ex::print(std::ostream & os, unsigned upper_precedence) const -{ - debugmsg("ex print",LOGLEVEL_PRINT); - GINAC_ASSERT(bp!=0); - bp->print(os,upper_precedence); + basic * tmpbp = bp; + bp = other.bp; + other.bp = tmpbp; } -void ex::printraw(std::ostream & os) 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 { - debugmsg("ex printraw",LOGLEVEL_PRINT); GINAC_ASSERT(bp!=0); - os << "ex("; - bp->printraw(os); - os << ")"; + bp->print(c, level); } -void ex::printtree(std::ostream & os, unsigned indent) 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); - // os << "refcount=" << bp->refcount << " "; - bp->printtree(os,indent); -} - -/** Print expression as a C++ statement. The output looks like - * " = ;". The "type" parameter has an effect - * on how number literals are printed. - * - * @param os output stream - * @param type variable type (one of the csrc_types) - * @param var_name variable name to be printed */ -void ex::printcsrc(std::ostream & os, unsigned type, const char *var_name) const -{ - debugmsg("ex print csrc", LOGLEVEL_PRINT); - GINAC_ASSERT(bp!=0); - switch (type) { - case csrc_types::ctype_float: - os << "float "; - break; - case csrc_types::ctype_double: - os << "double "; - break; - case csrc_types::ctype_cl_N: - os << "cl_N "; - break; - } - os << var_name << " = "; - bp->printcsrc(os, type, 0); - os << ";\n"; + bp->print(print_tree(os)); } /** 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(); } @@ -238,73 +89,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 symbol & s) const -{ - GINAC_ASSERT(bp!=0); - return bp->degree(s); -} - -int ex::ldegree(const symbol & s) const -{ - GINAC_ASSERT(bp!=0); - return bp->ldegree(s); -} - -ex ex::coeff(const symbol & s, int n) const -{ - GINAC_ASSERT(bp!=0); - return bp->coeff(s,n); -} - -ex ex::collect(const symbol & 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 @@ -320,56 +117,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 +/** Check whether expression matches a specified pattern. */ +bool ex::match(const ex & pattern) const { - GINAC_ASSERT(bp!=0); - return bp->subs(e); -} - -exvector ex::get_indices(void) const -{ - GINAC_ASSERT(bp!=0); - return bp->get_indices(); + lst repl_lst; + return bp->match(pattern, repl_lst); } -ex ex::simplify_ncmul(const exvector & v) 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 { - 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); @@ -378,83 +166,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(); } -#ifndef INLINE_EX_CONSTRUCTORS -int ex::compare(const ex & other) const -{ - GINAC_ASSERT(bp!=0); - GINAC_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); -} -#endif // ndef INLINE_EX_CONSTRUCTORS - -#ifndef INLINE_EX_CONSTRUCTORS -bool ex::is_equal(const ex & other) const -{ - GINAC_ASSERT(bp!=0); - GINAC_ASSERT(other.bp!=0); - // if both expression point to same basic they are trivially equal - if (bp==other.bp) - return true; - - return bp->is_equal(*other.bp); -} -#endif // ndef INLINE_EX_CONSTRUCTORS - -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(); -} - -ex ex::exadd(const ex & rh) const -{ - return (new add(*this,rh))->setflag(status_flags::dynallocated); -} - -ex ex::exmul(const ex & rh) const -{ - return (new mul(*this,rh))->setflag(status_flags::dynallocated); -} - -ex ex::exncmul(const ex & rh) const -{ - 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) { @@ -467,21 +197,20 @@ void ex::makewriteable() 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 constructor + 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) { - // it's on the heap, so just copy bp: + // ok, it is already on the heap, so just copy bp: bp = &const_cast(other); } else { // create a duplicate on the heap: @@ -489,7 +218,6 @@ void ex::construct_from_basic(const basic & other) bp->setflag(status_flags::dynallocated); } GINAC_ASSERT(bp!=0); - // bp->clearflag(status_flags::evaluated); ++bp->refcount; } GINAC_ASSERT(bp!=0); @@ -498,25 +226,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: @@ -530,17 +338,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: @@ -554,25 +402,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: @@ -586,17 +514,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: @@ -651,6 +619,4 @@ void ex::construct_from_string_and_lst(const std::string &s, const ex &l) // none -#ifndef NO_NAMESPACE_GINAC } // namespace GiNaC -#endif // ndef NO_NAMESPACE_GINAC