X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fbasic.cpp;h=4287f263188a02697ece8f74234d4e2e4d67189b;hp=a33433daf262863df202c7e0f231b93f1ab2398d;hb=f9afb6aca6a971650dff63b11ca8c2ef18506690;hpb=c28015b35e3d6ac132a040032b28c79143a36d1f diff --git a/ginac/basic.cpp b/ginac/basic.cpp index a33433da..4287f263 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-2011 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,64 +17,64 @@ * * 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 -#include -#include - #include "basic.h" #include "ex.h" #include "numeric.h" #include "power.h" +#include "add.h" #include "symbol.h" #include "lst.h" #include "ncmul.h" +#include "relational.h" +#include "operators.h" +#include "wildcard.h" #include "archive.h" #include "utils.h" -#include "debugmsg.h" +#include "hash_seed.h" +#include "inifcns.h" + +#include +#include +#include -#ifndef NO_NAMESPACE_GINAC namespace GiNaC { -#endif // ndef NO_NAMESPACE_GINAC -GINAC_IMPLEMENT_REGISTERED_CLASS_NO_CTORS(basic, void) +GINAC_IMPLEMENT_REGISTERED_CLASS_OPT(basic, void, + print_func(&basic::do_print). + print_func(&basic::do_print_tree). + print_func(&basic::do_print_python_repr)) ////////// -// default constructor, destructor, copy constructor assignment operator and helpers +// default constructor, destructor, copy constructor and assignment operator ////////// // 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 copy constructor: implicitly assumes that the other class is of + * the exact same type (as it's used by duplicate()), so it can copy the + * tinfo_key and the hash value. */ +basic::basic(const basic & other) : flags(other.flags & ~status_flags::dynallocated), hashvalue(other.hashvalue) { - debugmsg("basic destructor", LOGLEVEL_DESTRUCT); - destroy(false); - GINAC_ASSERT((!(flags & status_flags::dynallocated))||(refcount==0)); } -basic::basic(const basic & other) : flags(0), refcount(0), tinfo_key(TINFO_BASIC) -{ - debugmsg("basic copy constructor", LOGLEVEL_CONSTRUCT); - copy(other); -} -#endif - +/** basic assignment operator: the other object might be of a derived class. */ const basic & basic::operator=(const basic & other) { - debugmsg("basic operator=", LOGLEVEL_ASSIGNMENT); - if (this != &other) { - destroy(true); - copy(other); + unsigned fl = other.flags & ~status_flags::dynallocated; + if (typeid(*this) != typeid(other)) { + // The other object is of a derived class, so clear the flags as they + // might no longer apply (especially hash_calculated). Oh, and don't + // copy the tinfo_key: it is already set correctly for this object. + fl &= ~(status_flags::evaluated | status_flags::expanded | status_flags::hash_calculated); + } else { + // The objects are of the exact same class, so copy the hash value. + hashvalue = other.hashvalue; } + flags = fl; + set_refcount(0); return *this; } @@ -86,36 +86,15 @@ const basic & basic::operator=(const basic & other) // other constructors ////////// -#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 inlined) ////////// // archiving ////////// /** 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); - - // 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); -} +void basic::read_archive(const archive_node& n, lst& syms) +{ } /** Archive the object. */ void basic::archive(archive_node &n) const @@ -123,84 +102,118 @@ 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 stream formatted to be useful as ginsh input. */ -void basic::print(std::ostream & os, unsigned upper_precedence) const +/** Output to stream. This performs double dispatch on the dynamic type of + * *this and the dynamic type of the supplied print context. + * @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]"; + print_dispatch(get_class_info(), c, level); } -/** Output to stream in ugly raw format, so brave developers can have a look - * at the underlying structure. */ -void basic::printraw(std::ostream & os) const +/** Like print(), but dispatch to the specified class. Can be used by + * implementations of print methods to dispatch to the method of the + * superclass. + * + * @see basic::print */ +void basic::print_dispatch(const registered_class_info & ri, const print_context & c, unsigned level) const { - debugmsg("basic printraw",LOGLEVEL_PRINT); - os << "[basic object]"; + // Double dispatch on object type and print_context type + const registered_class_info * reg_info = &ri; + const print_context_class_info * pc_info = &c.get_class_info(); + +next_class: + const std::vector & pdt = reg_info->options.get_print_dispatch_table(); + +next_context: + unsigned id = pc_info->options.get_id(); + if (id >= pdt.size() || !(pdt[id].is_valid())) { + + // Method not found, try parent print_context class + const print_context_class_info * parent_pc_info = pc_info->get_parent(); + if (parent_pc_info) { + pc_info = parent_pc_info; + goto next_context; + } + + // Method still not found, try parent class + const registered_class_info * parent_reg_info = reg_info->get_parent(); + if (parent_reg_info) { + reg_info = parent_reg_info; + pc_info = &c.get_class_info(); + goto next_class; + } + + // Method still not found. This shouldn't happen because basic (the + // base class of the algebraic hierarchy) registers a method for + // print_context (the base class of the print context hierarchy), + // so if we end up here, there's something wrong with the class + // registry. + throw (std::runtime_error(std::string("basic::print(): method for ") + class_name() + "/" + c.class_name() + " not found")); + + } else { + + // Call method + pdt[id](*this, c, level); + } } -/** Output to stream formatted in tree- (indented-) form, so developers can - * have a look at the underlying structure. */ -void basic::printtree(std::ostream & os, unsigned indent) const +/** Default output to stream. */ +void basic::do_print(const print_context & c, unsigned level) 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(print_dflt(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 + * @see basic::dbgprint */ +void basic::dbgprinttree() const { - printtree(std::cerr,0); + this->print(print_tree(std::cerr)); } -basic * basic::duplicate() const +/** Return relative operator precedence (for parenthezing output). */ +unsigned basic::precedence() const { - debugmsg("basic duplicate",LOGLEVEL_DUPLICATE); - return new basic(*this); + return 70; } /** Information about the object. @@ -208,11 +221,12 @@ 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 +size_t basic::nops() const { // iterating from 0 to nops() on atomic objects should be an empty loop, // and accessing their elements is a range error. Container objects should @@ -221,95 +235,419 @@ unsigned basic::nops() const } /** Return operand/member at position i. */ -ex basic::op(int i) const +ex basic::op(size_t i) const { - return (const_cast(this))->let_op(i); + throw(std::range_error(std::string("basic::op(): ") + class_name() + std::string(" has no operands"))); } /** Return modifyable operand/member at position i. */ -ex & basic::let_op(int i) +ex & basic::let_op(size_t i) { - throw(std::out_of_range("op() out of range")); + ensure_if_modifiable(); + throw(std::range_error(std::string("basic::let_op(): ") + class_name() + std::string(" has no operands"))); } 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_a(index)) + return op(static_cast(ex_to(index).to_int())); + + throw(std::invalid_argument(std::string("non-numeric indices not supported by ") + class_name())); } -ex basic::operator[](int i) const +ex basic::operator[](size_t 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. */ -bool basic::has(const ex & other) const +ex & basic::operator[](const ex & index) +{ + if (is_exactly_a(index)) + return let_op(ex_to(index).to_int()); + + throw(std::invalid_argument(std::string("non-numeric indices not supported by ") + class_name())); +} + +ex & basic::operator[](size_t i) +{ + return let_op(i); +} + +/** 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, unsigned options) const { - GINAC_ASSERT(other.bp!=0); - if (is_equal(*other.bp)) return true; - if (nops()>0) { - for (unsigned i=0; ilet_op(i) = n; } } - return false; + + if (copy) { + copy->setflag(status_flags::dynallocated); + copy->clearflag(status_flags::hash_calculated | status_flags::expanded); + return *copy; + } else + return *this; } -/** Return degree of highest power in symbol s. */ -int basic::degree(const symbol & s) const +/** Check whether this is a polynomial in the given variables. */ +bool basic::is_polynomial(const ex & var) const { - return 0; + return !has(var) || is_equal(ex_to(var)); } -/** Return degree of lowest power in symbol s. */ -int basic::ldegree(const symbol & s) const +/** Return degree of highest power in object s. */ +int basic::degree(const ex & s) const { - return 0; + return is_equal(ex_to(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; - int ldeg = this->ldegree(s); - int deg = this->degree(s); - for (int n=ldeg; n<=deg; n++) { - x += this->coeff(s,n)*power(s,n); + if (is_a(s)) { + + // List of objects specified + if (s.nops() == 0) + return *this; + if (s.nops() == 1) + return collect(s.op(0)); + + else if (distributed) { + + x = this->expand(); + if (! is_a(x)) + return x; + const lst& l(ex_to(s)); + + exmap cmap; + cmap[_ex1] = _ex0; + for (const_iterator xi=x.begin(); xi!=x.end(); ++xi) { + ex key = _ex1; + ex pre_coeff = *xi; + for (lst::const_iterator li=l.begin(); li!=l.end(); ++li) { + int cexp = pre_coeff.degree(*li); + pre_coeff = pre_coeff.coeff(*li, cexp); + key *= pow(*li, cexp); + } + exmap::iterator ci = cmap.find(key); + if (ci != cmap.end()) + ci->second += pre_coeff; + else + cmap.insert(exmap::value_type(key, pre_coeff)); + } + + exvector resv; + for (exmap::const_iterator mi=cmap.begin(); mi != cmap.end(); ++mi) + resv.push_back((mi->first)*(mi->second)); + return (new add(resv))->setflag(status_flags::dynallocated); + + } else { + + // Recursive form + x = *this; + size_t n = s.nops() - 1; + while (true) { + x = x.collect(s[n]); + if (n == 0) + break; + 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 symbolic evaluations 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(); + return 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() const +{ + if (nops() == 0) + return *this; + else + return map(map_evalm); +} + +/** Function object to be applied by basic::eval_integ(). */ +struct eval_integ_map_function : public map_function { + ex operator()(const ex & e) { return eval_integ(e); } +} map_eval_integ; + +/** Evaluate integrals, if result is known. */ +ex basic::eval_integ() const +{ + if (nops() == 0) + return *this; + else + return map(map_eval_integ); } -/* Substitute a set of symbols. */ -ex basic::subs(const lst & ls, const lst & lr) 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 { + // There is nothing to do for basic objects + return i.hold(); +} + +/** 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; its 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 +{ + return self + other; +} + +/** Multiply an indexed expression with a scalar. This function is used + * internally by simplify_indexed(). + * + * @param self Indexed expression; its 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 + * 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; its 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 +{ + // Do nothing + return false; +} + +/** Check whether the expression matches a given pattern. For every wildcard + * object in the pattern, a pair with the wildcard as a key and matching + * expression as a value is added to repl_lst. */ +bool basic::match(const ex & pattern, exmap& 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_exactly_a(pattern)) { + + // Wildcard matches anything, but check whether we already have found + // a match for that wildcard first (if so, the earlier match must be + // the same expression) + for (exmap::const_iterator it = repl_lst.begin(); it != repl_lst.end(); ++it) { + if (it->first.is_equal(pattern)) + return is_equal(ex_to(it->second)); + } + repl_lst[pattern] = *this; + return true; + + } else { + + // Expression must be of the same type as the pattern + if (typeid(*this) != typeid(ex_to(pattern))) + 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; + + // Even if the expression does not match the pattern, some of + // its subexpressions could match it. For example, x^5*y^(-1) + // does not match the pattern $0^5, but its subexpression x^5 + // does. So, save repl_lst in order to not add bogus entries. + exmap tmp_repl = repl_lst; + // Otherwise the subexpressions must match one-to-one + for (size_t i=0; isecond; + return thisex; + } else { + for (it = m.begin(); it != m.end(); ++it) { + exmap repl_lst; + if (match(ex_to(it->first), repl_lst)) + return it->second.subs(repl_lst, options | subs_options::no_pattern); + // avoid infinite recursion when re-substituting the wildcards + } + } + return *this; } +/** Substitute a set of objects by arbitrary expressions. The ex returned + * will already be evaluated. */ +ex basic::subs(const exmap & m, unsigned options) const +{ + size_t num = nops(); + if (num) { + + // Substitute in subexpressions + for (size_t i=0; isetflag(status_flags::dynallocated); + copy->clearflag(status_flags::hash_calculated | status_flags::expanded); + + // Substitute the changed operand + copy->let_op(i++) = subsed_op; + + // Substitute the other operands + for (; ilet_op(i) = op(i).subs(m, options); + + // Perform substitutions on the new object as a whole + return copy->subs_one_level(m, options); + } + } + } + + // Nothing changed or no subexpressions + return subs_one_level(m, options); +} + /** Default interface of nth derivative ex::diff(s, n). It should be called * instead of ::derivative(s) for first derivatives and for nth derivatives it * just recurses down. @@ -336,29 +674,60 @@ ex basic::diff(const symbol & s, unsigned nth) const return ndiff; } -exvector basic::get_indices(void) const +/** Return a vector containing the free indices of an expression. */ +exvector basic::get_free_indices() const { return exvector(); // return an empty exvector } -ex basic::simplify_ncmul(const exvector & v) const +ex basic::conjugate() const +{ + return *this; +} + +ex basic::real_part() const { - return simplified_ncmul(v); + return real_part_function(*this).hold(); +} + +ex basic::imag_part() const +{ + return imag_part_function(*this).hold(); +} + +ex basic::eval_ncmul(const exvector & v) const +{ + return hold_ncmul(v); } // 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. Needs to be - * implemented by each class. */ +/** 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); @@ -366,46 +735,84 @@ int basic::compare_same_type(const basic & other) const /** 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 complare_same_type(). */ + * 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; } -unsigned basic::return_type(void) const +/** 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() const { return return_types::commutative; } -unsigned basic::return_type_tinfo(void) const +return_type_t basic::return_type_tinfo() const { - return tinfo(); + return_type_t rt; + rt.tinfo = &typeid(*this); + rt.rl = 0; + return rt; } -unsigned basic::calchash(void) const +/** 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() const { - unsigned v=golden_ratio_hash(tinfo()); - for (unsigned i=0; i(this))->op(i).gethash(); + unsigned v = make_hash_seed(typeid(*this)); + for (size_t i=0; iop(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; + hashvalue = v; } 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 e.expand(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); + } } @@ -415,137 +822,121 @@ 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 -{ - 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; +#ifdef GINAC_COMPARE_STATISTICS + compare_statistics.compare_same_hashvalue++; +#endif - 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; - */ + const std::type_info& typeid_this = typeid(*this); + const std::type_info& typeid_other = typeid(other); + if (typeid_this == typeid_other) { +// int cmpval = compare_same_type(other); +// if (cmpval!=0) { +// 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; +#ifdef GINAC_COMPARE_STATISTICS + compare_statistics.compare_same_type++; +#endif + return compare_same_type(other); + } else { +// 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 (typeid_this.before(typeid_other) ? -1 : 1); } - return cmpval; } -/** Test for equality. */ +/** Test for syntactic 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)); - +#ifdef GINAC_COMPARE_STATISTICS + compare_statistics.total_basic_is_equals++; +#endif + if (this->gethash()!=other.gethash()) + return false; +#ifdef GINAC_COMPARE_STATISTICS + compare_statistics.is_equal_same_hashvalue++; +#endif + if (typeid(*this) != typeid(other)) + return false; + +#ifdef GINAC_COMPARE_STATISTICS + compare_statistics.is_equal_same_type++; +#endif return is_equal_same_type(other); } // protected /** Stop further evaluation. + * * @see basic::eval */ -const basic & basic::hold(void) const +const basic & basic::hold() const { return setflag(status_flags::evaluated); } -void basic::ensure_if_modifiable(void) const +/** Ensure the object may be modified without hurting others, throws if this + * is not the case. */ +void basic::ensure_if_modifiable() const { - if (refcount>1) + if (get_refcount() > 1) throw(std::runtime_error("cannot modify multiply referenced object")); + clearflag(status_flags::hash_calculated | status_flags::evaluated); } ////////// -// static member variables +// global variables ////////// -// protected +int max_recursion_level = 1024; -unsigned basic::precedence = 70; -unsigned basic::delta_indent = 4; -////////// -// global variables -////////// +#ifdef GINAC_COMPARE_STATISTICS +compare_statistics_t::~compare_statistics_t() +{ + std::clog << "ex::compare() called " << total_compares << " times" << std::endl; + std::clog << "nontrivial compares: " << nontrivial_compares << " times" << std::endl; + std::clog << "basic::compare() called " << total_basic_compares << " times" << std::endl; + std::clog << "same hashvalue in compare(): " << compare_same_hashvalue << " times" << std::endl; + std::clog << "compare_same_type() called " << compare_same_type << " times" << std::endl; + std::clog << std::endl; + std::clog << "ex::is_equal() called " << total_is_equals << " times" << std::endl; + std::clog << "nontrivial is_equals: " << nontrivial_is_equals << " times" << std::endl; + std::clog << "basic::is_equal() called " << total_basic_is_equals << " times" << std::endl; + std::clog << "same hashvalue in is_equal(): " << is_equal_same_hashvalue << " times" << std::endl; + std::clog << "is_equal_same_type() called " << is_equal_same_type << " times" << std::endl; + std::clog << std::endl; + std::clog << "basic::gethash() called " << total_gethash << " times" << std::endl; + std::clog << "used cached hashvalue " << gethash_cached << " times" << std::endl; +} -int max_recursion_level=1024; +compare_statistics_t compare_statistics; +#endif -#ifndef NO_NAMESPACE_GINAC } // namespace GiNaC -#endif // ndef NO_NAMESPACE_GINAC