X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fbasic.cpp;h=fb73096fa70a4796e301ade46306d53849d25068;hp=6415f33fde5a79456ebb97ba0e81f36139110c97;hb=0e6b43220f4059f5f298865c3f9a2e28854ca3fd;hpb=9d8d0f4924171b0acb7ec6a333897fe1ec545707 diff --git a/ginac/basic.cpp b/ginac/basic.cpp index 6415f33f..fb73096f 100644 --- a/ginac/basic.cpp +++ b/ginac/basic.cpp @@ -3,7 +3,7 @@ * Implementation of GiNaC's ABC. */ /* - * GiNaC Copyright (C) 1999-2001 Johannes Gutenberg University Mainz, Germany + * GiNaC Copyright (C) 1999-2002 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 @@ -21,8 +21,10 @@ */ #include -#include #include +#ifdef DO_GINAC_ASSERT +# include +#endif #include "basic.h" #include "ex.h" @@ -31,29 +33,29 @@ #include "symbol.h" #include "lst.h" #include "ncmul.h" +#include "relational.h" +#include "wildcard.h" +#include "print.h" #include "archive.h" #include "utils.h" -#include "debugmsg.h" namespace GiNaC { GINAC_IMPLEMENT_REGISTERED_CLASS_NO_CTORS(basic, void) ////////// -// default ctor, dtor, copy ctor assignment operator and helpers +// default ctor, dtor, copy ctor, assignment operator and helpers ////////// // public basic::basic(const basic & other) : tinfo_key(TINFO_basic), flags(0), refcount(0) { - debugmsg("basic copy ctor", LOGLEVEL_CONSTRUCT); copy(other); } const basic & basic::operator=(const basic & other) { - debugmsg("basic operator=", LOGLEVEL_ASSIGNMENT); if (this != &other) { destroy(true); copy(other); @@ -78,8 +80,6 @@ const basic & basic::operator=(const basic & other) /** Construct object from archive_node. */ basic::basic(const archive_node &n, const lst &sym_lst) : flags(0), refcount(0) { - debugmsg("basic ctor from archive_node", LOGLEVEL_CONSTRUCT); - // Reconstruct tinfo_key from class name std::string class_name; if (n.find_string("class", class_name)) @@ -89,10 +89,7 @@ basic::basic(const archive_node &n, const lst &sym_lst) : flags(0), refcount(0) } /** Unarchive the object. */ -ex basic::unarchive(const archive_node &n, const lst &sym_lst) -{ - return (new basic(n, sym_lst))->setflag(status_flags::dynallocated); -} +DEFAULT_UNARCHIVE(basic) /** Archive the object. */ void basic::archive(archive_node &n) const @@ -100,79 +97,56 @@ void basic::archive(archive_node &n) const n.add_string("class", class_name()); } -////////// -// functions overriding virtual functions from bases classes -////////// - -// none - ////////// // new virtual functions which can be overridden by derived classes ////////// // public -/** Output to ostream formatted as parsable (as in ginsh) input. - * Generally, superfluous parenthesis should be avoided as far as possible. */ -void basic::print(std::ostream & os, unsigned upper_precedence) const +/** Output to stream. + * @param c print context object that describes the output formatting + * @param level value that is used to identify the precedence or indentation + * level for placing parentheses and formatting */ +void basic::print(const print_context & c, unsigned level) const { - debugmsg("basic print",LOGLEVEL_PRINT); - os << "[" << class_name() << " object]"; -} + if (is_of_type(c, print_tree)) { -/** Output to ostream in ugly raw format, so brave developers can have a look - * at the underlying structure. */ -void basic::printraw(std::ostream & os) const -{ - debugmsg("basic printraw",LOGLEVEL_PRINT); - os << "[" << class_name() << " object]"; -} + c.s << std::string(level, ' ') << class_name() + << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec + << ", nops=" << nops() + << std::endl; + for (unsigned i=0; i(c).delta_indent); -/** Output to ostream formatted in tree- (indented-) form, so developers can - * have a look at the underlying structure. */ -void basic::printtree(std::ostream & os, unsigned indent) const -{ - debugmsg("basic printtree",LOGLEVEL_PRINT); - os << std::string(indent,' ') << "type=" << class_name() - << ", hash=" << hashvalue - << " (0x" << std::hex << hashvalue << std::dec << ")" - << ", flags=" << flags - << ", nops=" << nops() << std::endl; - for (unsigned i=0; iprint(std::cerr); std::cerr << std::endl; } -/** Little wrapper arount printtree to be called within a debugger. +/** Little wrapper around printtree to be called within a debugger. * * @see basic::dbgprint * @see basic::printtree */ void basic::dbgprinttree(void) const { - this->printtree(std::cerr,0); + this->print(print_tree(std::cerr)); +} + +/** Return relative operator precedence (for parenthizing output). */ +unsigned basic::precedence(void) const +{ + return 70; } /** Create a new copy of this on the heap. One can think of this as simulating @@ -180,7 +154,6 @@ void basic::dbgprinttree(void) const * construction of an ex from a basic. */ basic * basic::duplicate() const { - debugmsg("basic duplicate",LOGLEVEL_DUPLICATE); return new basic(*this); } @@ -216,9 +189,9 @@ ex & basic::let_op(int i) ex basic::operator[](const ex & index) const { - if (is_exactly_of_type(*index.bp,numeric)) - return op(static_cast(*index.bp).to_int()); - + if (is_ex_exactly_of_type(index,numeric)) + return op(ex_to(index).to_int()); + throw(std::invalid_argument("non-numeric indices not supported by this type")); } @@ -227,64 +200,189 @@ ex basic::operator[](int i) const return op(i); } -/** Search ocurrences. An object 'has' an expression if it is the expression - * itself or one of the children 'has' it. As a consequence (according to - * the definition of children) given e=x+y+z, e.has(x) is true but e.has(x+y) - * is false. */ -bool basic::has(const ex & other) const +/** Test for occurrence of a pattern. An object 'has' a pattern if it matches + * the pattern itself or one of the children 'has' it. As a consequence + * (according to the definition of children) given e=x+y+z, e.has(x) is true + * but e.has(x+y) is false. */ +bool basic::has(const ex & pattern) const { - GINAC_ASSERT(other.bp!=0); - if (is_equal(*other.bp)) return true; - if (nops()>0) { - for (unsigned i=0; isetflag(status_flags::dynallocated); + copy->clearflag(status_flags::hash_calculated | status_flags::expanded); + ex e(*copy); + for (unsigned i=0; i(s)) ? 1 : 0; +} + +/** Return degree of lowest power in object s. */ +int basic::ldegree(const ex & s) const +{ + return is_equal(ex_to(s)) ? 1 : 0; } -/** Return coefficient of degree n in symbol s. */ -ex basic::coeff(const symbol & s, int n) const +/** Return coefficient of degree n in object s. */ +ex basic::coeff(const ex & s, int n) const { - return n==0 ? *this : _ex0(); + if (is_equal(ex_to(s))) + return n==1 ? _ex1 : _ex0; + else + return n==0 ? *this : _ex0; } -/** Sort expression in terms of powers of some symbol. - * @param s symbol to sort in. */ -ex basic::collect(const symbol & s) const +/** Sort expanded expression in terms of powers of some object(s). + * @param s object(s) to sort in + * @param distributed recursive or distributed form (only used when s is a list) */ +ex basic::collect(const ex & s, bool distributed) const { ex x; - for (int n=this->ldegree(s); n<=this->degree(s); n++) - x += this->coeff(s,n)*power(s,n); + if (is_ex_of_type(s, lst)) { + + // List of objects specified + if (s.nops() == 0) + return *this; + if (s.nops() == 1) + return collect(s.op(0)); + + else if (distributed) { + + // Get lower/upper degree of all symbols in list + int num = s.nops(); + struct sym_info { + ex sym; + int ldeg, deg; + int cnt; // current degree, 'counter' + ex coeff; // coefficient for degree 'cnt' + }; + sym_info *si = new sym_info[num]; + ex c = *this; + for (int i=0; ildegree(si[i].sym); + si[i].deg = this->degree(si[i].sym); + c = si[i].coeff = c.coeff(si[i].sym, si[i].cnt); + } + + while (true) { + + // Calculate coeff*x1^c1*...*xn^cn + ex y = _ex1; + for (int i=0; i=0; n--) + x = x.collect(s[n]); + } + + } else { + + // Only one object specified + for (int n=this->ldegree(s); n<=this->degree(s); ++n) + x += this->coeff(s,n)*power(s,n); + } - return x; + // correct for lost fractional arguments and return + return x + (*this - x).expand(); } -/** Perform automatic non-interruptive symbolic evaluation on expression. */ +/** Perform automatic non-interruptive term rewriting rules. */ ex basic::eval(int level) const { // There is nothing to do for basic objects: return this->hold(); } +/** Function object to be applied by basic::evalf(). */ +struct evalf_map_function : public map_function { + int level; + evalf_map_function(int l) : level(l) {} + ex operator()(const ex & e) { return evalf(e, level); } +}; + /** Evaluate object numerically. */ ex basic::evalf(int level) const { - // There is nothing to do for basic objects: - return *this; + if (nops() == 0) + return *this; + else { + if (level == 1) + return *this; + else if (level == -max_recursion_level) + throw(std::runtime_error("max recursion level reached")); + else { + evalf_map_function map_evalf(level - 1); + return map(map_evalf); + } + } +} + +/** Function object to be applied by basic::evalm(). */ +struct evalm_map_function : public map_function { + ex operator()(const ex & e) { return evalm(e); } +} map_evalm; + +/** Evaluate sums, products and integer powers of matrices. */ +ex basic::evalm(void) const +{ + if (nops() == 0) + return *this; + else + return map(map_evalm); } /** Perform automatic symbolic evaluations on indexed expression that @@ -310,6 +408,18 @@ ex basic::add_indexed(const ex & self, const ex & other) const return self + other; } +/** Multiply an indexed expression with a scalar. This function is used + * internally by simplify_indexed(). + * + * @param self Indexed expression; it's base object is *this + * @param other Numeric value + * @return product of self and other + * @see ex::simplify_indexed() */ +ex basic::scalar_mul_indexed(const ex & self, const numeric & other) const +{ + return self * other; +} + /** Try to contract two indexed expressions that appear in the same product. * If a contraction exists, the function overwrites one or both of the * expressions and returns true. Otherwise it returns false. It is @@ -328,10 +438,87 @@ bool basic::contract_with(exvector::iterator self, exvector::iterator other, exv return false; } -/** Substitute a set of symbols by arbitrary expressions. The ex returned +/** Check whether the expression matches a given pattern. For every wildcard + * object in the pattern, an expression of the form "wildcard == matching_expression" + * is added to repl_lst. */ +bool basic::match(const ex & pattern, lst & repl_lst) const +{ +/* + Sweet sweet shapes, sweet sweet shapes, + That's the key thing, right right. + Feed feed face, feed feed shapes, + But who is the king tonight? + Who is the king tonight? + Pattern is the thing, the key thing-a-ling, + But who is the king of Pattern? + But who is the king, the king thing-a-ling, + Who is the king of Pattern? + Bog is the king, the king thing-a-ling, + Bog is the king of Pattern. + Ba bu-bu-bu-bu bu-bu-bu-bu-bu-bu bu-bu + Bog is the king of Pattern. +*/ + + if (is_ex_exactly_of_type(pattern, wildcard)) { + + // Wildcard matches anything, but check whether we already have found + // a match for that wildcard first (if so, it the earlier match must + // be the same expression) + for (unsigned i=0; i(repl_lst.op(i).op(1))); + } + repl_lst.append(pattern == *this); + return true; + + } else { + + // Expression must be of the same type as the pattern + if (tinfo() != ex_to(pattern).tinfo()) + return false; + + // Number of subexpressions must match + if (nops() != pattern.nops()) + return false; + + // No subexpressions? Then just compare the objects (there can't be + // wildcards in the pattern) + if (nops() == 0) + return is_equal_same_type(ex_to(pattern)); + + // Check whether attributes that are not subexpressions match + if (!match_same_type(ex_to(pattern))) + return false; + + // Otherwise the subexpressions must match one-to-one + for (unsigned i=0; i(ls.op(i)))) + return lr.op(i); + } + } else { + for (unsigned i=0; i(ls.op(i)), repl_lst)) + return lr.op(i).subs(repl_lst, true); // avoid infinite recursion when re-substituting the wildcards + } + } + return *this; } @@ -374,13 +561,25 @@ ex basic::simplify_ncmul(const exvector & v) const // protected -/** Default implementation of ex::diff(). It simply throws an error message. +/** Function object to be applied by basic::derivative(). */ +struct derivative_map_function : public map_function { + const symbol &s; + derivative_map_function(const symbol &sym) : s(sym) {} + ex operator()(const ex & e) { return diff(e, s); } +}; + +/** Default implementation of ex::diff(). It maps the operation on the + * operands (or returns 0 when the object has no operands). * - * @exception logic_error (differentiation not supported by this type) * @see ex::diff */ ex basic::derivative(const symbol & s) const { - throw(std::logic_error("differentiation not supported by this type")); + if (nops() == 0) + return _ex0; + else { + derivative_map_function map_derivative(s); + return map(map_derivative); + } } /** Returns order relation between two objects of same type. This needs to be @@ -400,7 +599,24 @@ int basic::compare_same_type(const basic & other) const * than an order relation and then it can be overridden. */ bool basic::is_equal_same_type(const basic & other) const { - return this->compare_same_type(other)==0; + return compare_same_type(other)==0; +} + +/** Returns true if the attributes of two objects are similar enough for + * a match. This function must not match subexpressions (this is already + * done by basic::match()). Only attributes not accessible by op() should + * be compared. This is also the reason why this function doesn't take the + * wildcard replacement list from match() as an argument: only subexpressions + * are subject to wildcard matches. Also, this function only needs to be + * implemented for container classes because is_equal_same_type() is + * automatically used instead of match_same_type() if nops() == 0. + * + * @see basic::match */ +bool basic::match_same_type(const basic & other) const +{ + // The default is to only consider subexpressions, but not any other + // attributes + return true; } unsigned basic::return_type(void) const @@ -439,11 +655,23 @@ unsigned basic::calchash(void) const return v; } +/** Function object to be applied by basic::expand(). */ +struct expand_map_function : public map_function { + unsigned options; + expand_map_function(unsigned o) : options(o) {} + ex operator()(const ex & e) { return expand(e, options); } +}; + /** Expand expression, i.e. multiply it out and return the result as a new * expression. */ ex basic::expand(unsigned options) const { - return this->setflag(status_flags::expanded); + if (nops() == 0) + return (options == 0) ? setflag(status_flags::expanded) : *this; + else { + expand_map_function map_expand(options); + return ex_to(map(map_expand)).setflag(options == 0 ? status_flags::expanded : 0); + } } @@ -453,15 +681,15 @@ ex basic::expand(unsigned options) const // public -/** Substitute symbols in expression and return the result as a new expression. - * There are two valid types of replacement arguments: 1) a relational like - * symbol==ex and 2) a list of relationals lst(symbol1==ex1,symbol2==ex2,...), - * which is converted to subs(lst(symbol1,symbol2,...),lst(ex1,ex2,...)). - * In addition, an object of class idx can be used instead of a symbol. */ -ex basic::subs(const ex & e) 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,...), which is converted to + * subs(lst(object1,object2,...),lst(ex1,ex2,...)). */ +ex basic::subs(const ex & e, bool no_pattern) const { if (e.info(info_flags::relation_equal)) { - return subs(lst(e)); + return subs(lst(e), no_pattern); } if (!e.info(info_flags::list)) { throw(std::invalid_argument("basic::subs(ex): argument must be a list")); @@ -469,18 +697,14 @@ ex basic::subs(const ex & e) const lst ls; lst lr; for (unsigned i=0; iprintraw(std::cout); +// this->print(print_tree(std::cout)); // std::cout << " and "; -// other.printraw(std::cout); +// other.print(print_tree(std::cout)); // std::cout << std::endl; return -1; } if (typeid_this>typeid_other) { // std::cout << "hash collision, different types: " // << *this << " and " << other << std::endl; -// this->printraw(std::cout); +// this->print(print_tree(std::cout)); // std::cout << " and "; -// other.printraw(std::cout); +// other.print(print_tree(std::cout)); // std::cout << std::endl; return 1; } @@ -522,9 +746,9 @@ int basic::compare(const basic & other) const // if ((cmpval!=0) && (hash_this<0x80000000U)) { // std::cout << "hash collision, same type: " // << *this << " and " << other << std::endl; -// this->printraw(std::cout); +// this->print(print_tree(std::cout)); // std::cout << " and "; -// other.printraw(std::cout); +// other.print(print_tree(std::cout)); // std::cout << std::endl; // } // return cmpval; @@ -547,7 +771,7 @@ bool basic::is_equal(const basic & other) const GINAC_ASSERT(typeid(*this)==typeid(other)); - return this->is_equal_same_type(other); + return is_equal_same_type(other); } // protected @@ -557,7 +781,7 @@ bool basic::is_equal(const basic & other) const * @see basic::eval */ const basic & basic::hold(void) const { - return this->setflag(status_flags::evaluated); + return setflag(status_flags::evaluated); } /** Ensure the object may be modified without hurting others, throws if this @@ -566,17 +790,9 @@ void basic::ensure_if_modifiable(void) const { if (this->refcount>1) throw(std::runtime_error("cannot modify multiply referenced object")); + clearflag(status_flags::hash_calculated); } -////////// -// static member variables -////////// - -// protected - -unsigned basic::precedence = 70; -unsigned basic::delta_indent = 4; - ////////// // global variables //////////