X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fbasic.cpp;h=16d0dfddafe37419f7e2fe911c1e5afa07cd2579;hp=8eec72b1f9e4b7c6046c28056f0214baaf6eaab8;hb=b617b5cf86e6f8ac01a339d9747c535257fcf8d0;hpb=aff6beb8e799e6827c40975ed2f22b51976b1cb8 diff --git a/ginac/basic.cpp b/ginac/basic.cpp index 8eec72b1..16d0dfdd 100644 --- a/ginac/basic.cpp +++ b/ginac/basic.cpp @@ -3,7 +3,7 @@ * Implementation of GiNaC's ABC. */ /* - * 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 @@ -21,8 +21,10 @@ */ #include -#include #include +#ifdef DO_GINAC_ASSERT +# include +#endif #include "basic.h" #include "ex.h" @@ -31,75 +33,47 @@ #include "symbol.h" #include "lst.h" #include "ncmul.h" +#include "relational.h" +#include "print.h" #include "archive.h" #include "utils.h" #include "debugmsg.h" -#ifndef NO_NAMESPACE_GINAC namespace GiNaC { -#endif // ndef NO_NAMESPACE_GINAC -GINAC_IMPLEMENT_REGISTERED_CLASS(basic, void) +GINAC_IMPLEMENT_REGISTERED_CLASS_NO_CTORS(basic, void) ////////// -// default constructor, destructor, copy constructor assignment operator and helpers +// default ctor, dtor, copy ctor assignment operator and helpers ////////// // public -#ifndef INLINE_BASIC_CONSTRUCTORS -basic::basic() : flags(0), refcount(0), tinfo_key(TINFO_BASIC) -{ - debugmsg("basic default constructor", LOGLEVEL_CONSTRUCT); - // nothing to do -} - -basic::~basic() +basic::basic(const basic & other) : tinfo_key(TINFO_basic), flags(0), refcount(0) { - debugmsg("basic destructor", LOGLEVEL_DESTRUCT); - destroy(0); - GINAC_ASSERT((!(flags & status_flags::dynallocated))||(refcount==0)); + debugmsg("basic copy ctor", LOGLEVEL_CONSTRUCT); + copy(other); } -basic::basic(const basic & other) : flags(0), refcount(0), tinfo_key(TINFO_BASIC) -{ - debugmsg("basic copy constructor", LOGLEVEL_CONSTRUCT); - copy(other); -} -#endif - const basic & basic::operator=(const basic & other) { - debugmsg("basic operator=", LOGLEVEL_ASSIGNMENT); - if (this != &other) { - destroy(1); - copy(other); - } - return *this; + debugmsg("basic operator=", LOGLEVEL_ASSIGNMENT); + if (this != &other) { + destroy(true); + copy(other); + } + return *this; } // protected -#if 0 -void basic::copy(const basic & other) -{ - flags=other.flags & ~ status_flags::dynallocated; - hashvalue=other.hashvalue; - tinfo_key=other.tinfo_key; -} -#endif +// none (all conditionally inlined) ////////// -// other constructors +// other ctors ////////// -#ifndef INLINE_BASIC_CONSTRUCTORS -basic::basic(unsigned ti) : flags(0), refcount(0), tinfo_key(ti) -{ - debugmsg("basic constructor with tinfo_key", LOGLEVEL_CONSTRUCT); - // nothing to do -} -#endif +// none (all conditionally inlined) ////////// // archiving @@ -108,26 +82,23 @@ basic::basic(unsigned ti) : flags(0), refcount(0), tinfo_key(ti) /** Construct object from archive_node. */ basic::basic(const archive_node &n, const lst &sym_lst) : flags(0), refcount(0) { - debugmsg("basic constructor from archive_node", LOGLEVEL_CONSTRUCT); + debugmsg("basic ctor from archive_node", LOGLEVEL_CONSTRUCT); - // Reconstruct tinfo_key from class name - string class_name; - if (n.find_string("class", class_name)) - tinfo_key = find_tinfo_key(class_name); - else - throw (std::runtime_error("archive node contains no class name")); + // Reconstruct tinfo_key from class name + std::string class_name; + if (n.find_string("class", class_name)) + tinfo_key = find_tinfo_key(class_name); + else + throw (std::runtime_error("archive node contains no class name")); } /** 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 { - n.add_string("class", class_name()); + n.add_string("class", class_name()); } ////////// @@ -142,63 +113,61 @@ void basic::archive(archive_node &n) const // public -/** Output to stream formatted to be useful as ginsh input. */ -void basic::print(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 << "[basic object]"; -} + debugmsg("basic print", LOGLEVEL_PRINT); -/** Output to stream in ugly raw format, so brave developers can have a look - * at the underlying structure. */ -void basic::printraw(ostream & os) const -{ - debugmsg("basic printraw",LOGLEVEL_PRINT); - os << "[basic object]"; -} + if (is_of_type(c, print_tree)) { -/** Output to stream formatted in tree- (indented-) form, so developers can - * have a look at the underlying structure. */ -void basic::printtree(ostream & os, unsigned indent) const -{ - debugmsg("basic printtree",LOGLEVEL_PRINT); - os << string(indent,' ') << "type=" << typeid(*this).name() - << ", hash=" << hashvalue << " (0x" << hex << hashvalue << dec << ")" - << ", flags=" << flags - << ", nops=" << nops() << endl; - for (unsigned i=0; iprint(std::cerr); + std::cerr << std::endl; } -/** Little wrapper arount print to be called within a debugger. */ -void basic::dbgprint(void) const +/** Little wrapper around printtree to be called within a debugger. + * + * @see basic::dbgprint + * @see basic::printtree */ +void basic::dbgprinttree(void) const { - print(cerr); - cerr << endl; + this->print(print_tree(std::cerr)); } -/** Little wrapper arount printtree to be called within a debugger. */ -void basic::dbgprinttree(void) const +/** Return relative operator precedence (for parenthizing output). */ +unsigned basic::precedence(void) const { - printtree(cerr,0); + return 70; } +/** Create a new copy of this on the heap. One can think of this as simulating + * a virtual copy constructor which is needed for instance by the refcounted + * construction of an ex from a basic. */ basic * basic::duplicate() const { - debugmsg("basic duplicate",LOGLEVEL_DUPLICATE); - return new basic(*this); + debugmsg("basic duplicate",LOGLEVEL_DUPLICATE); + return new basic(*this); } /** Information about the object. @@ -206,94 +175,334 @@ basic * basic::duplicate() const * @see class info_flags */ bool basic::info(unsigned inf) const { - return false; // all possible properties are false for basic objects + // all possible properties are false for basic objects + return false; } /** Number of operands/members. */ unsigned basic::nops() const { - return 0; + // iterating from 0 to nops() on atomic objects should be an empty loop, + // and accessing their elements is a range error. Container objects should + // override this. + return 0; } /** Return operand/member at position i. */ ex basic::op(int i) const { - return (const_cast(this))->let_op(i); + return (const_cast(this))->let_op(i); } /** Return modifyable operand/member at position i. */ ex & basic::let_op(int i) { - throw(std::out_of_range("op() out of range")); + throw(std::out_of_range("op() out of range")); } ex basic::operator[](const ex & index) const { - if (is_exactly_of_type(*index.bp,numeric)) - return op(static_cast(*index.bp).to_int()); - - throw(std::invalid_argument("non-numeric indices not supported by this type")); + if (is_exactly_of_type(*index.bp,numeric)) + return op(static_cast(*index.bp).to_int()); + + throw(std::invalid_argument("non-numeric indices not supported by this type")); } ex basic::operator[](int i) const { - return op(i); + return op(i); } -/** Search ocurrences. An object 'has' an expression if it is the expression - * itself or one of the children 'has' it. */ +/** 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. The expression can also contain wildcards. */ bool basic::has(const ex & other) 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); + ex e(*copy); + for (unsigned 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); + } + + // correct for lost fractional arguments and return + return x + (*this - x).expand(); +} + +/** Perform automatic non-interruptive symbolic evaluation on expression. */ +ex basic::eval(int level) const +{ + // There is nothing to do for basic objects: + return this->hold(); } -int basic::degree(const symbol & s) const +/** Evaluate object numerically. */ +ex basic::evalf(int level) const { - return 0; + // There is nothing to do for basic objects: + return *this; } -int basic::ldegree(const symbol & s) const +/** Evaluate sums and products of matrices. */ +ex basic::evalm(void) const { - return 0; + if (nops() == 0) + return *this; + else + return map(GiNaC::evalm); } -ex basic::coeff(const symbol & s, int n) const +/** Perform automatic symbolic evaluations on indexed expression that + * contains this object as the base expression. */ +ex basic::eval_indexed(const basic & i) const + // this function can't take a "const ex & i" because that would result + // in an infinite eval() loop { - return n==0 ? *this : _ex0(); + // There is nothing to do for basic objects + return i.hold(); } -ex basic::collect(const symbol & s) const +/** Add two indexed expressions. They are guaranteed to be of class indexed + * (or a subclass) and their indices are compatible. This function is used + * internally by simplify_indexed(). + * + * @param self First indexed expression; it's base object is *this + * @param other Second indexed expression + * @return sum of self and other + * @see ex::simplify_indexed() */ +ex basic::add_indexed(const ex & self, const ex & other) const { - ex x; - int ldeg=ldegree(s); - int deg=degree(s); - for (int n=ldeg; n<=deg; n++) { - x += coeff(s,n)*power(s,n); - } - return x; + return self + other; } -ex basic::eval(int level) const +/** 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 this->hold(); + return self * other; } -/** Evaluate object numerically. */ -ex basic::evalf(int level) const +/** 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 + * guaranteed that both expressions are of class indexed (or a subclass) + * and that at least one dummy index has been found. This functions is + * used internally by simplify_indexed(). + * + * @param self Pointer to first indexed expression; it's base object is *this + * @param other Pointer to second indexed expression + * @param v The complete vector of factors + * @return true if the contraction was successful, false otherwise + * @see ex::simplify_indexed() */ +bool basic::contract_with(exvector::iterator self, exvector::iterator other, exvector & v) const { - return *this; + // Do nothing + return false; } -ex basic::subs(const lst & ls, const lst & lr) const +/** 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 { - return *this; +/* + 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; itinfo()) + 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(*pattern.bp); + + // Otherwise the subexpressions must match one-to-one + for (unsigned i=0; isubs(repl_lst, true); // avoid infinite recursion when re-substituting the wildcards + } + } + + return *this; } /** Default interface of nth derivative ex::diff(s, n). It should be called @@ -305,31 +514,32 @@ ex basic::subs(const lst & ls, const lst & lr) const * @see ex::diff */ ex basic::diff(const symbol & s, unsigned nth) const { - // trivial: zeroth derivative - if (!nth) - return ex(*this); - - // evaluate unevalueted *this before differentiating - if (!(flags & status_flags::evaluated)) - return ex(*this).diff(s, nth); - - ex ndiff = derivative(s); - while (!ndiff.is_zero() && // stop differentiating zeros - nth>1) { - ndiff = ndiff.diff(s); - --nth; - } - return ndiff; + // trivial: zeroth derivative + if (nth==0) + return ex(*this); + + // evaluate unevaluated *this before differentiating + if (!(flags & status_flags::evaluated)) + return ex(*this).diff(s, nth); + + ex ndiff = this->derivative(s); + while (!ndiff.is_zero() && // stop differentiating zeros + nth>1) { + ndiff = ndiff.diff(s); + --nth; + } + return ndiff; } -exvector basic::get_indices(void) const +/** Return a vector containing the free indices of an expression. */ +exvector basic::get_free_indices(void) const { - return exvector(); // return an empty exvector + return exvector(); // return an empty exvector } ex basic::simplify_ncmul(const exvector & v) const { - return simplified_ncmul(v); + return simplified_ncmul(v); } // protected @@ -340,51 +550,70 @@ ex basic::simplify_ncmul(const exvector & v) const * @see ex::diff */ ex basic::derivative(const symbol & s) const { - throw(std::logic_error("differentiation not supported by this type")); + throw(std::logic_error("differentiation not supported by this type")); } +/** Returns order relation between two objects of same type. This needs to be + * implemented by each class. It may never return anything else than 0, + * signalling equality, or +1 and -1 signalling inequality and determining + * the canonical ordering. (Perl hackers will wonder why C++ doesn't feature + * the spaceship operator <=> for denoting just this.) */ int basic::compare_same_type(const basic & other) const { - return compare_pointers(this, &other); + return compare_pointers(this, &other); } +/** Returns true if two objects of same type are equal. Normally needs + * not be reimplemented as long as it wasn't overwritten by some parent + * class, since it just calls compare_same_type(). The reason why this + * function exists is that sometimes it is easier to determine equality + * than an order relation and then it can be overridden. */ bool basic::is_equal_same_type(const basic & other) const { - return compare_same_type(other)==0; + return this->compare_same_type(other)==0; } unsigned basic::return_type(void) const { - return return_types::commutative; + return return_types::commutative; } unsigned basic::return_type_tinfo(void) const { - return tinfo(); + return tinfo(); } +/** Compute the hash value of an object and if it makes sense to store it in + * the objects status_flags, do so. The method inherited from class basic + * computes a hash value based on the type and hash values of possible + * members. For this reason it is well suited for container classes but + * atomic classes should override this implementation because otherwise they + * would all end up with the same hashvalue. */ unsigned basic::calchash(void) const { - unsigned v=golden_ratio_hash(tinfo()); - for (unsigned i=0; i(this))->op(i).gethash(); - } - - v = v & 0x7FFFFFFFU; - - // store calculated hash value only if object is already evaluated - if (flags & status_flags::evaluated) { - setflag(status_flags::hash_calculated); - hashvalue=v; - } - - return v; -} - + unsigned v = golden_ratio_hash(tinfo()); + for (unsigned i=0; i(this))->op(i).gethash(); + } + + // mask out numeric hashes: + v &= 0x7FFFFFFFU; + + // store calculated hash value only if object is already evaluated + if (flags & status_flags::evaluated) { + setflag(status_flags::hash_calculated); + hashvalue = v; + } + + return v; +} + +/** 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); + return this->setflag(status_flags::expanded); } @@ -394,142 +623,121 @@ ex basic::expand(unsigned options) const // public -ex basic::subs(const ex & e) const -{ - // accept 2 types of replacement expressions: - // - symbol==ex - // - lst(symbol1==ex1,symbol2==ex2,...) - // convert to subs(lst(symbol1,symbol2,...),lst(ex1,ex2,...)) - // additionally, idx can be used instead of symbol - if (e.info(info_flags::relation_equal)) { - return subs(lst(e)); - } - if (!e.info(info_flags::list)) { - throw(std::invalid_argument("basic::subs(ex): argument must be a list")); - } - lst ls; - lst lr; - for (unsigned i=0; ihash_other) return 1; - - unsigned typeid_this = tinfo(); - unsigned typeid_other = other.tinfo(); - - if (typeid_thisprintraw(cout); - cout << " and "; - other.printraw(cout); - cout << endl; - */ - return -1; - } - if (typeid_this>typeid_other) { - /* - cout << "hash collision, different types: " - << *this << " and " << other << endl; - this->printraw(cout); - cout << " and "; - other.printraw(cout); - cout << endl; - */ - return 1; - } - - GINAC_ASSERT(typeid(*this)==typeid(other)); - - int cmpval=compare_same_type(other); - if ((cmpval!=0)&&(hash_this<0x80000000U)) { - /* - cout << "hash collision, same type: " - << *this << " and " << other << endl; - this->printraw(cout); - cout << " and "; - other.printraw(cout); - cout << endl; - */ - } - return cmpval; -} - + unsigned hash_this = gethash(); + unsigned hash_other = other.gethash(); + + if (hash_thishash_other) return 1; + + unsigned typeid_this = tinfo(); + unsigned typeid_other = other.tinfo(); + + if (typeid_thisprint(print_tree(std::cout)); +// std::cout << " and "; +// 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->print(print_tree(std::cout)); +// std::cout << " and "; +// other.print(print_tree(std::cout)); +// std::cout << std::endl; + return 1; + } + + GINAC_ASSERT(typeid(*this)==typeid(other)); + +// int cmpval = compare_same_type(other); +// if ((cmpval!=0) && (hash_this<0x80000000U)) { +// std::cout << "hash collision, same type: " +// << *this << " and " << other << std::endl; +// this->print(print_tree(std::cout)); +// std::cout << " and "; +// other.print(print_tree(std::cout)); +// std::cout << std::endl; +// } +// return cmpval; + + return compare_same_type(other); +} + +/** Test for equality. + * This is only a quick test, meaning objects should be in the same domain. + * You might have to .expand(), .normal() objects first, depending on the + * domain of your computation, to get a more reliable answer. + * + * @see is_equal_same_type */ bool basic::is_equal(const basic & other) const { - unsigned hash_this = gethash(); - unsigned hash_other = other.gethash(); - - if (hash_this!=hash_other) return false; - - unsigned typeid_this = tinfo(); - unsigned typeid_other = other.tinfo(); - - if (typeid_this!=typeid_other) return false; - - GINAC_ASSERT(typeid(*this)==typeid(other)); - - return is_equal_same_type(other); + if (this->gethash()!=other.gethash()) + return false; + if (this->tinfo()!=other.tinfo()) + return false; + + GINAC_ASSERT(typeid(*this)==typeid(other)); + + return this->is_equal_same_type(other); } // protected +/** Stop further evaluation. + * + * @see basic::eval */ const basic & basic::hold(void) const { - return setflag(status_flags::evaluated); + return this->setflag(status_flags::evaluated); } +/** Ensure the object may be modified without hurting others, throws if this + * is not the case. */ void basic::ensure_if_modifiable(void) const { - if (refcount>1) { - throw(std::runtime_error("cannot modify multiply referenced object")); - } + if (this->refcount>1) + throw(std::runtime_error("cannot modify multiply referenced object")); } -////////// -// static member variables -////////// - -// protected - -unsigned basic::precedence=70; -unsigned basic::delta_indent=4; - -////////// -// global constants -////////// - -const basic some_basic; -const type_info & typeid_basic=typeid(some_basic); - ////////// // global variables ////////// -int max_recursion_level=1024; +int max_recursion_level = 1024; -#ifndef NO_NAMESPACE_GINAC } // namespace GiNaC -#endif // ndef NO_NAMESPACE_GINAC