X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fbasic.cpp;h=3a2768418c5705aa0e7cb8078e88fc70834c7254;hp=8d60fcfcc0b708e7ea202a1f4257ee8fcb5e3ae3;hb=815b86159af5d3b013b720e14ab7348f462e2db6;hpb=708e9e647029af699333fceffc0a76bef70a4709 diff --git a/ginac/basic.cpp b/ginac/basic.cpp index 8d60fcfc..3a276841 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-2004 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 @@ -34,56 +34,66 @@ #include "lst.h" #include "ncmul.h" #include "relational.h" -#include "print.h" +#include "operators.h" +#include "wildcard.h" #include "archive.h" #include "utils.h" -#include "debugmsg.h" 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 ctor, dtor, copy ctor assignment operator and helpers +// default constructor, destructor, copy constructor and assignment operator ////////// // public -basic::basic(const basic & other) : tinfo_key(TINFO_basic), flags(0), refcount(0) +/** 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) : tinfo_key(other.tinfo_key), flags(other.flags & ~status_flags::dynallocated), hashvalue(other.hashvalue) { - debugmsg("basic copy ctor", LOGLEVEL_CONSTRUCT); - copy(other); } +/** 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 (tinfo_key != other.tinfo_key) { + // 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; } // protected -// none (all conditionally inlined) +// none (all inlined) ////////// -// other ctors +// other constructors ////////// -// none (all conditionally inlined) +// none (all inlined) ////////// // archiving ////////// /** Construct object from archive_node. */ -basic::basic(const archive_node &n, const lst &sym_lst) : flags(0), refcount(0) +basic::basic(const archive_node &n, lst &sym_lst) : flags(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)) @@ -101,37 +111,91 @@ 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. +/** 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); + print_dispatch(get_class_info(), c, level); +} - if (is_of_type(c, print_tree)) { +/** 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 +{ + // 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(); - 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); +next_class: + const std::vector & pdt = reg_info->options.get_print_dispatch_table(); - } else - c.s << "[" << class_name() << " object]"; +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); + } +} + +/** Default output to stream. */ +void basic::do_print(const print_context & c, unsigned level) const +{ + c.s << "[" << class_name() << " object]"; +} + +/** Tree output to stream. */ +void basic::do_print_tree(const print_tree & c, unsigned level) const +{ + c.s << std::string(level, ' ') << class_name() << " @" << this + << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec; + if (nops()) + c.s << ", nops=" << nops(); + c.s << std::endl; + for (size_t i=0; iprint(std::cerr); std::cerr << std::endl; @@ -148,28 +213,18 @@ 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 + * @see basic::dbgprint */ +void basic::dbgprinttree() const { this->print(print_tree(std::cerr)); } -/** Return relative operator precedence (for parenthizing output). */ -unsigned basic::precedence(void) const +/** Return relative operator precedence (for parenthezing output). */ +unsigned basic::precedence() const { 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); -} - /** Information about the object. * * @see class info_flags */ @@ -180,7 +235,7 @@ bool basic::info(unsigned inf) const } /** 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 @@ -189,41 +244,54 @@ 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); } +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) const { - GINAC_ASSERT(pattern.bp!=0); lst repl_lst; - if (match(*pattern.bp, repl_lst)) + if (match(pattern, repl_lst)) return true; - for (unsigned i=0; isetflag(status_flags::dynallocated); - copy->clearflag(status_flags::hash_calculated | status_flags::expanded); - ex e(*copy); - for (unsigned i=0; ilet_op(i) = n; + } + } + + 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 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 0; + return is_equal(ex_to(s)) ? 1 : 0; } /** 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 expanded expression in terms of powers of some object(s). @@ -271,7 +352,7 @@ ex basic::coeff(const ex & s, int n) const ex basic::collect(const ex & s, bool distributed) const { ex x; - if (is_ex_of_type(s, lst)) { + if (is_a(s)) { // List of objects specified if (s.nops() == 0) @@ -282,7 +363,7 @@ ex basic::collect(const ex & s, bool distributed) const else if (distributed) { // Get lower/upper degree of all symbols in list - int num = s.nops(); + size_t num = s.nops(); struct sym_info { ex sym; int ldeg, deg; @@ -291,7 +372,7 @@ ex basic::collect(const ex & s, bool distributed) const }; 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); @@ -301,17 +382,17 @@ ex basic::collect(const ex & s, bool distributed) const while (true) { // Calculate coeff*x1^c1*...*xn^cn - ex y = _ex1(); - for (int i=0; i=0; n--) + size_t n = s.nops() - 1; + while (true) { x = x.collect(s[n]); + if (n == 0) + break; + n--; + } } } else { @@ -351,11 +437,11 @@ done: delete[] si; 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(); + return hold(); } /** Function object to be applied by basic::evalf(). */ @@ -388,7 +474,7 @@ struct evalm_map_function : public map_function { } map_evalm; /** Evaluate sums, products and integer powers of matrices. */ -ex basic::evalm(void) const +ex basic::evalm() const { if (nops() == 0) return *this; @@ -410,7 +496,7 @@ ex basic::eval_indexed(const basic & i) const * (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 self First indexed expression; its base object is *this * @param other Second indexed expression * @return sum of self and other * @see ex::simplify_indexed() */ @@ -422,7 +508,7 @@ ex basic::add_indexed(const ex & self, const ex & other) 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 self Indexed expression; its base object is *this * @param other Numeric value * @return product of self and other * @see ex::simplify_indexed() */ @@ -438,7 +524,7 @@ ex basic::scalar_mul_indexed(const ex & self, const numeric & other) const * 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 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 @@ -470,14 +556,14 @@ bool basic::match(const ex & pattern, lst & repl_lst) const Bog is the king of Pattern. */ - if (is_ex_exactly_of_type(pattern, wildcard)) { + if (is_exactly_a(pattern)) { // 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; iop(0).is_equal(pattern)) + return is_equal(ex_to(it->op(1))); } repl_lst.append(pattern == *this); return true; @@ -485,7 +571,7 @@ bool basic::match(const ex & pattern, lst & repl_lst) const } else { // Expression must be of the same type as the pattern - if (tinfo() != pattern.bp->tinfo()) + if (tinfo() != ex_to(pattern).tinfo()) return false; // Number of subexpressions must match @@ -495,14 +581,14 @@ bool basic::match(const ex & pattern, lst & repl_lst) const // No subexpressions? Then just compare the objects (there can't be // wildcards in the pattern) if (nops() == 0) - return is_equal_same_type(*pattern.bp); + return is_equal_same_type(ex_to(pattern)); // Check whether attributes that are not subexpressions match - if (!match_same_type(*pattern.bp)) + if (!match_same_type(ex_to(pattern))) return false; // Otherwise the subexpressions must match one-to-one - for (unsigned i=0; isecond; } else { - for (unsigned i=0; isubs(repl_lst, true); // avoid infinite recursion when re-substituting the wildcards + 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. @@ -560,14 +679,19 @@ ex basic::diff(const symbol & s, unsigned nth) const } /** Return a vector containing the free indices of an expression. */ -exvector basic::get_free_indices(void) const +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::eval_ncmul(const exvector & v) const { - return simplified_ncmul(v); + return hold_ncmul(v); } // protected @@ -586,7 +710,7 @@ struct derivative_map_function : public map_function { ex basic::derivative(const symbol & s) const { if (nops() == 0) - return _ex0(); + return _ex0; else { derivative_map_function map_derivative(s); return map(map_derivative); @@ -630,12 +754,12 @@ bool basic::match_same_type(const basic & other) const return true; } -unsigned basic::return_type(void) const +unsigned basic::return_type() const { return return_types::commutative; } -unsigned basic::return_type_tinfo(void) const +unsigned basic::return_type_tinfo() const { return tinfo(); } @@ -646,17 +770,14 @@ unsigned basic::return_type_tinfo(void) const * 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 basic::calchash() const { unsigned v = golden_ratio_hash(tinfo()); - for (unsigned i=0; i(this))->op(i).gethash(); + for (size_t i=0; iop(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); @@ -670,7 +791,7 @@ unsigned basic::calchash(void) const 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); } + ex operator()(const ex & e) { return e.expand(options); } }; /** Expand expression, i.e. multiply it out and return the result as a new @@ -681,7 +802,7 @@ ex basic::expand(unsigned options) const return (options == 0) ? setflag(status_flags::expanded) : *this; else { expand_map_function map_expand(options); - return map(map_expand).bp->setflag(options == 0 ? status_flags::expanded : 0); + return ex_to(map(map_expand)).setflag(options == 0 ? status_flags::expanded : 0); } } @@ -692,82 +813,52 @@ ex basic::expand(unsigned options) const // public -/** 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), no_pattern); - } - 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_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) { +#ifdef GINAC_COMPARE_STATISTICS + compare_statistics.compare_same_hashvalue++; +#endif + + const unsigned typeid_this = tinfo(); + const unsigned typeid_other = other.tinfo(); + if (typeid_this==typeid_other) { + GINAC_ASSERT(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 1; + return (typeid_thisprint(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. +/** 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. @@ -775,13 +866,22 @@ int basic::compare(const basic & other) const * @see is_equal_same_type */ bool basic::is_equal(const basic & other) const { +#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 (this->tinfo()!=other.tinfo()) return false; GINAC_ASSERT(typeid(*this)==typeid(other)); +#ifdef GINAC_COMPARE_STATISTICS + compare_statistics.is_equal_same_type++; +#endif return is_equal_same_type(other); } @@ -790,18 +890,18 @@ bool basic::is_equal(const basic & other) const /** Stop further evaluation. * * @see basic::eval */ -const basic & basic::hold(void) const +const basic & basic::hold() const { return 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 +void basic::ensure_if_modifiable() const { - if (this->refcount>1) + if (get_refcount() > 1) throw(std::runtime_error("cannot modify multiply referenced object")); - clearflag(status_flags::hash_calculated); + clearflag(status_flags::hash_calculated | status_flags::evaluated); } ////////// @@ -810,4 +910,27 @@ void basic::ensure_if_modifiable(void) const int max_recursion_level = 1024; + +#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; +} + +compare_statistics_t compare_statistics; +#endif + } // namespace GiNaC