X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fbasic.cpp;h=b86900795d950c542bf5f0dc9e281c6c4063fc4e;hp=595d64500c37435b1ea324b39782d07cc72f88c2;hb=6d7bf9ee5a7ce05cb3a23dae664e781d7325d7b8;hpb=f64dcc8accf3e0603d0701de0c87e36f1ee6262d diff --git a/ginac/basic.cpp b/ginac/basic.cpp index 595d6450..b8690079 100644 --- a/ginac/basic.cpp +++ b/ginac/basic.cpp @@ -36,13 +36,15 @@ #include "relational.h" #include "operators.h" #include "wildcard.h" -#include "print.h" #include "archive.h" #include "utils.h" namespace GiNaC { -GINAC_IMPLEMENT_REGISTERED_CLASS(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 and assignment operator @@ -66,7 +68,7 @@ const basic & basic::operator=(const basic & 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. - flags = 0; + 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; @@ -116,23 +118,85 @@ void basic::archive(archive_node &n) const // 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 { - if (is_a(c)) { + print_dispatch(get_class_info(), c, level); +} + +/** 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(); + +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); + } +} - c.s << std::string(level, ' ') << class_name() - << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec - << ", nops=" << nops() - << std::endl; - for (size_t i=0; i(c).delta_indent); +/** 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(print_tree(std::cerr)); } -/** Return relative operator precedence (for parenthizing output). */ +/** Return relative operator precedence (for parenthezing output). */ unsigned basic::precedence() const { return 70; @@ -524,22 +588,19 @@ bool basic::match(const ex & pattern, lst & repl_lst) const } /** Helper function for subs(). Does not recurse into subexpressions. */ -ex basic::subs_one_level(const lst & ls, const lst & lr, unsigned options) const +ex basic::subs_one_level(const exmap & m, unsigned options) const { - GINAC_ASSERT(ls.nops() == lr.nops()); + exmap::const_iterator it; - lst::const_iterator its, itr; - - if (options & subs_options::subs_no_pattern) { - for (its = ls.begin(), itr = lr.begin(); its != ls.end(); ++its, ++itr) { - if (is_equal(ex_to(*its))) - return *itr; - } + if (options & subs_options::no_pattern) { + it = m.find(*this); + if (it != m.end()) + return it->second; } else { - for (its = ls.begin(), itr = lr.begin(); its != ls.end(); ++its, ++itr) { + for (it = m.begin(); it != m.end(); ++it) { lst repl_lst; - if (match(ex_to(*its), repl_lst)) - return itr->subs(repl_lst, options | subs_options::subs_no_pattern); // 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 } } @@ -548,7 +609,7 @@ ex basic::subs_one_level(const lst & ls, const lst & lr, unsigned options) const /** Substitute a set of objects by arbitrary expressions. The ex returned * will already be evaluated. */ -ex basic::subs(const lst & ls, const lst & lr, unsigned options) const +ex basic::subs(const exmap & m, unsigned options) const { size_t num = nops(); if (num) { @@ -556,7 +617,7 @@ ex basic::subs(const lst & ls, const lst & lr, unsigned options) const // Substitute in subexpressions for (size_t i=0; ilet_op(i) = op(i).subs(ls, lr, options); + copy->let_op(i) = op(i).subs(m, options); // Perform substitutions on the new object as a whole - return copy->subs_one_level(ls, lr, options); + return copy->subs_one_level(m, options); } } } // Nothing changed or no subexpressions - return subs_one_level(ls, lr, options); + return subs_one_level(m, options); } /** Default interface of nth derivative ex::diff(s, n). It should be called @@ -699,7 +760,7 @@ unsigned basic::calchash() const unsigned v = golden_ratio_hash(tinfo()); for (size_t i=0; i(this))->op(i).gethash(); + v ^= this->op(i).gethash(); } // store calculated hash value only if object is already evaluated @@ -737,35 +798,6 @@ 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, unsigned options) const -{ - if (e.info(info_flags::relation_equal)) { - return subs(lst(e.lhs()), lst(e.rhs()), options); - } - if (!e.info(info_flags::list)) { - throw(std::invalid_argument("basic::subs(ex): argument must be a list")); - } - - // Split list into two - lst ls; - lst lr; - GINAC_ASSERT(is_a(e)); - for (lst::const_iterator it = ex_to(e).begin(); it != ex_to(e).end(); ++it) { - ex r = *it; - if (!r.info(info_flags::relation_equal)) { - throw(std::invalid_argument("basic::subs(ex): argument must be a list of equations")); - } - ls.append(r.op(0)); - lr.append(r.op(1)); - } - return subs(ls, lr, options); -} - /** Compare objects syntactically to establish canonical ordering. * All compare functions return: -1 for *this less than other, 0 equal, * 1 greater. */