#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<print_context>(&basic::do_print).
+ print_func<print_tree>(&basic::do_print_tree).
+ print_func<print_python_repr>(&basic::do_print_python_repr))
//////////
// default constructor, destructor, copy constructor and assignment operator
// 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<print_tree>(c)) {
+ // Double dispatch on object type and print_context type
+ const registered_class_info * reg_info = &get_class_info();
+ 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 (size_t i=0; i<nops(); ++i)
- op(i).print(c, level + static_cast<const print_tree &>(c).delta_indent);
+next_class:
+ const std::vector<print_functor> & 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()
+ << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec
+ << ", nops=" << nops()
+ << std::endl;
+ for (size_t i=0; i<nops(); ++i)
+ op(i).print(c, level + c.delta_indent);
+}
+
+/** Python parsable output to stream. */
+void basic::do_print_python_repr(const print_python_repr & c, unsigned level) const
+{
+ c.s << class_name() << "()";
}
/** Little wrapper around print to be called within a debugger.
this->print(print_tree(std::cerr));
}
-/** Return relative operator precedence (for parenthizing output). */
+/** Return relative operator precedence (for parenthezing output). */
unsigned basic::precedence() const
{
return 70;
}
/** 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<basic>(*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<basic>(*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<basic>(it->first), repl_lst))
+ return it->second.subs(repl_lst, options | subs_options::no_pattern); // avoid infinite recursion when re-substituting the wildcards
}
}
/** 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) {
// Substitute in subexpressions
for (size_t i=0; i<num; i++) {
const ex & orig_op = op(i);
- const ex & subsed_op = orig_op.subs(ls, lr, options);
+ const ex & subsed_op = orig_op.subs(m, options);
if (!are_ex_trivially_equal(orig_op, subsed_op)) {
// Something changed, clone the object
// Substitute the other operands
for (; i<num; i++)
- copy->let_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
unsigned v = golden_ratio_hash(tinfo());
for (size_t i=0; i<nops(); i++) {
v = rotate_left(v);
- v ^= (const_cast<basic *>(this))->op(i).gethash();
+ v ^= this->op(i).gethash();
}
// store calculated hash value only if object is already evaluated
// 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), 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<lst>(e));
- for (lst::const_iterator it = ex_to<lst>(e).begin(); it != ex_to<lst>(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. */
git://www.ginac.de / ginac.git / blobdiff