'typedef ex (* series_funcp_${N})(${SEQ1}, const relational &, int, unsigned);'."\n",
'const ex &','','');
+$typedef_print_funcp=generate(
+'typedef void (* print_funcp_${N})(${SEQ1}, const print_context &);'."\n",
+'const ex &','','');
+
$eval_func_interface=generate(' function_options & eval_func(eval_funcp_${N} e);'."\n",'','','');
$evalf_func_interface=generate(' function_options & evalf_func(evalf_funcp_${N} ef);'."\n",'','','');
$series_func_interface=generate(' function_options & series_func(series_funcp_${N} s);'."\n",'','','');
+$print_func_interface=generate(
+ <<'END_OF_PRINT_FUNC_INTERFACE','','','');
+ template <class Ctx> function_options & print_func(print_funcp_${N} p)
+ {
+ test_and_set_nparams(${N});
+ set_print_func(Ctx::reg_info.options.get_id(), print_funcp(p));
+ return *this;
+ }
+END_OF_PRINT_FUNC_INTERFACE
+
$constructors_interface=generate(
' function(unsigned ser, ${SEQ1});'."\n",
'const ex & param${N}','','');
$eval_switch_statement=generate(
<<'END_OF_EVAL_SWITCH_STATEMENT','seq[${N}-1]','','');
case ${N}:
- eval_result = ((eval_funcp_${N})(registered_functions()[serial].eval_f))(${SEQ1});
+ eval_result = ((eval_funcp_${N})(opt.eval_f))(${SEQ1});
break;
END_OF_EVAL_SWITCH_STATEMENT
$evalf_switch_statement=generate(
<<'END_OF_EVALF_SWITCH_STATEMENT','eseq[${N}-1]','','');
case ${N}:
- return ((evalf_funcp_${N})(registered_functions()[serial].evalf_f))(${SEQ1});
+ return ((evalf_funcp_${N})(opt.evalf_f))(${SEQ1});
END_OF_EVALF_SWITCH_STATEMENT
$diff_switch_statement=generate(
<<'END_OF_DIFF_SWITCH_STATEMENT','seq[${N}-1]','','');
case ${N}:
- return ((derivative_funcp_${N})(registered_functions()[serial].derivative_f))(${SEQ1},diff_param);
+ return ((derivative_funcp_${N})(opt.derivative_f))(${SEQ1},diff_param);
END_OF_DIFF_SWITCH_STATEMENT
$series_switch_statement=generate(
<<'END_OF_SERIES_SWITCH_STATEMENT','seq[${N}-1]','','');
case ${N}:
try {
- res = ((series_funcp_${N})(registered_functions()[serial].series_f))(${SEQ1},r,order,options);
+ res = ((series_funcp_${N})(opt.series_f))(${SEQ1},r,order,options);
} catch (do_taylor) {
res = basic::series(r, order, options);
}
return res;
END_OF_SERIES_SWITCH_STATEMENT
+$print_switch_statement=generate(
+ <<'END_OF_PRINT_SWITCH_STATEMENT','seq[${N}-1]','','');
+ case ${N}:
+ ((print_funcp_${N})(pdt[id]))(${SEQ1}, c);
+ break;
+END_OF_PRINT_SWITCH_STATEMENT
+
$eval_func_implementation=generate(
<<'END_OF_EVAL_FUNC_IMPLEMENTATION','','','');
function_options & function_options::eval_func(eval_funcp_${N} e)
typedef ex (* evalf_funcp)();
typedef ex (* derivative_funcp)();
typedef ex (* series_funcp)();
+typedef void (* print_funcp)();
// the following lines have been generated for max. ${maxargs} parameters
$typedef_eval_funcp
$typedef_evalf_funcp
$typedef_derivative_funcp
$typedef_series_funcp
+$typedef_print_funcp
// end of generated lines
// Alternatively, an exvector may be passed into the static function, instead
typedef ex (* evalf_funcp_exvector)(const exvector &);
typedef ex (* derivative_funcp_exvector)(const exvector &, unsigned);
typedef ex (* series_funcp_exvector)(const exvector &, const relational &, int, unsigned);
+typedef void (* print_funcp_exvector)(const exvector &, const print_context &);
class function_options
$evalf_func_interface
$derivative_func_interface
$series_func_interface
+$print_func_interface
// end of generated lines
function_options & eval_func(eval_funcp_exvector e);
function_options & evalf_func(evalf_funcp_exvector ef);
function_options & derivative_func(derivative_funcp_exvector d);
function_options & series_func(series_funcp_exvector s);
+ template <class Ctx> function_options & print_func(print_funcp_exvector p)
+ {
+ print_use_exvector_args = true;
+ set_print_func(Ctx::reg_info.options.get_id(), print_funcp(p));
+ return *this;
+ }
+
function_options & set_return_type(unsigned rt, unsigned rtt=0);
function_options & do_not_evalf_params();
function_options & remember(unsigned size, unsigned assoc_size=0,
unsigned strategy=remember_strategies::delete_never);
function_options & overloaded(unsigned o);
function_options & set_symmetry(const symmetry & s);
- void test_and_set_nparams(unsigned n);
+
std::string get_name() const { return name; }
unsigned get_nparams() const { return nparams; }
- bool has_derivative() const { return derivative_f != NULL; }
protected:
+ bool has_derivative() const { return derivative_f != NULL; }
+ void test_and_set_nparams(unsigned n);
+ void set_print_func(unsigned id, print_funcp f);
+
std::string name;
std::string TeX_name;
evalf_funcp evalf_f;
derivative_funcp derivative_f;
series_funcp series_f;
+ std::vector<print_funcp> print_dispatch_table;
bool evalf_params_first;
bool evalf_use_exvector_args;
bool derivative_use_exvector_args;
bool series_use_exvector_args;
+ bool print_use_exvector_args;
unsigned functions_with_same_name;
evalf_use_exvector_args = false;
derivative_use_exvector_args = false;
series_use_exvector_args = false;
+ print_use_exvector_args = false;
use_remember = false;
functions_with_same_name = 1;
symtree = 0;
} else if (nparams!=n) {
// we do not throw an exception here because this code is
// usually executed before main(), so the exception could not
- // caught anyhow
+ // be caught anyhow
std::cerr << "WARNING: " << name << "(): number of parameters ("
<< n << ") differs from number set before ("
<< nparams << ")" << std::endl;
}
}
+void function_options::set_print_func(unsigned id, print_funcp f)
+{
+ if (id >= print_dispatch_table.size())
+ print_dispatch_table.resize(id + 1);
+ print_dispatch_table[id] = f;
+}
+
/** This can be used as a hook for external applications. */
unsigned function::current_serial = 0;
void function::print(const print_context & c, unsigned level) const
{
GINAC_ASSERT(serial<registered_functions().size());
+ const function_options &opt = registered_functions()[serial];
+ const std::vector<print_funcp> &pdt = opt.print_dispatch_table;
- if (is_a<print_tree>(c)) {
-
- c.s << std::string(level, ' ') << class_name() << " "
- << registered_functions()[serial].name
- << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec
- << ", nops=" << nops()
- << std::endl;
- unsigned delta_indent = static_cast<const print_tree &>(c).delta_indent;
- for (size_t i=0; i<seq.size(); ++i)
- seq[i].print(c, level + delta_indent);
- c.s << std::string(level + delta_indent, ' ') << "=====" << std::endl;
+ // Dynamically dispatch on print_context type
+ const print_context_class_info *pc_info = &c.get_class_info();
- } else if (is_a<print_csrc>(c)) {
+next_context:
+ unsigned id = pc_info->options.get_id();
+ if (id >= pdt.size() || pdt[id] == NULL) {
- // Print function name in lowercase
- std::string lname = registered_functions()[serial].name;
- size_t num = lname.size();
- for (size_t i=0; i<num; i++)
- lname[i] = tolower(lname[i]);
- c.s << lname << "(";
+ // 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;
+ }
- // Print arguments, separated by commas
- exvector::const_iterator it = seq.begin(), itend = seq.end();
- while (it != itend) {
- it->print(c);
- ++it;
- if (it != itend)
- c.s << ",";
+ // Method still not found, use default output
+ if (is_a<print_tree>(c)) {
+
+ c.s << std::string(level, ' ') << class_name() << " "
+ << opt.name
+ << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec
+ << ", nops=" << nops()
+ << std::endl;
+ unsigned delta_indent = static_cast<const print_tree &>(c).delta_indent;
+ for (size_t i=0; i<seq.size(); ++i)
+ seq[i].print(c, level + delta_indent);
+ c.s << std::string(level + delta_indent, ' ') << "=====" << std::endl;
+
+ } else if (is_a<print_csrc>(c)) {
+
+ // Print function name in lowercase
+ std::string lname = opt.name;
+ size_t num = lname.size();
+ for (size_t i=0; i<num; i++)
+ lname[i] = tolower(lname[i]);
+ c.s << lname;
+ printseq(c, '(', ',', ')', exprseq::precedence(), function::precedence());
+
+ } else if (is_a<print_latex>(c)) {
+ c.s << opt.TeX_name;
+ printseq(c, '(', ',', ')', exprseq::precedence(), function::precedence());
+ } else {
+ c.s << opt.name;
+ printseq(c, '(', ',', ')', exprseq::precedence(), function::precedence());
}
- c.s << ")";
- } else if (is_a<print_latex>(c)) {
- c.s << registered_functions()[serial].TeX_name;
- printseq(c, '(', ',', ')', exprseq::precedence(), function::precedence());
} else {
- c.s << registered_functions()[serial].name;
- printseq(c, '(', ',', ')', exprseq::precedence(), function::precedence());
+
+ // Method found, call it
+ current_serial = serial;
+ if (opt.print_use_exvector_args)
+ ((print_funcp_exvector)pdt[id])(seq, c);
+ else switch (opt.nparams) {
+ // the following lines have been generated for max. ${maxargs} parameters
+${print_switch_statement}
+ // end of generated lines
+ default:
+ throw(std::logic_error("function::print(): invalid nparams"));
+ }
}
}
ex function::eval(int level) const
{
- GINAC_ASSERT(serial<registered_functions().size());
-
if (level>1) {
// first evaluate children, then we will end up here again
return function(serial,evalchildren(level));
}
+ GINAC_ASSERT(serial<registered_functions().size());
const function_options &opt = registered_functions()[serial];
// Canonicalize argument order according to the symmetry properties
return eval_result;
}
current_serial = serial;
- if (registered_functions()[serial].eval_use_exvector_args)
- eval_result = ((eval_funcp_exvector)(registered_functions()[serial].eval_f))(seq);
+ if (opt.eval_use_exvector_args)
+ eval_result = ((eval_funcp_exvector)(opt.eval_f))(seq);
else
switch (opt.nparams) {
// the following lines have been generated for max. ${maxargs} parameters
ex function::evalf(int level) const
{
GINAC_ASSERT(serial<registered_functions().size());
-
const function_options &opt = registered_functions()[serial];
// Evaluate children first
ex function::series(const relational & r, int order, unsigned options) const
{
GINAC_ASSERT(serial<registered_functions().size());
+ const function_options &opt = registered_functions()[serial];
- if (registered_functions()[serial].series_f==0) {
+ if (opt.series_f==0) {
return basic::series(r, order);
}
ex res;
current_serial = serial;
- if (registered_functions()[serial].series_use_exvector_args) {
+ if (opt.series_use_exvector_args) {
try {
- res = ((series_funcp_exvector)(registered_functions()[serial].series_f))(seq, r, order, options);
+ res = ((series_funcp_exvector)(opt.series_f))(seq, r, order, options);
} catch (do_taylor) {
res = basic::series(r, order, options);
}
return res;
}
- switch (registered_functions()[serial].nparams) {
+ switch (opt.nparams) {
// the following lines have been generated for max. ${maxargs} parameters
${series_switch_statement}
// end of generated lines
unsigned function::return_type() const
{
+ GINAC_ASSERT(serial<registered_functions().size());
const function_options &opt = registered_functions()[serial];
if (opt.use_return_type) {
unsigned function::return_type_tinfo() const
{
+ GINAC_ASSERT(serial<registered_functions().size());
const function_options &opt = registered_functions()[serial];
if (opt.use_return_type) {
ex function::pderivative(unsigned diff_param) const // partial differentiation
{
GINAC_ASSERT(serial<registered_functions().size());
+ const function_options &opt = registered_functions()[serial];
// No derivative defined? Then return abstract derivative object
- if (registered_functions()[serial].derivative_f == NULL)
+ if (opt.derivative_f == NULL)
return fderivative(serial, diff_param, seq);
current_serial = serial;
- if (registered_functions()[serial].derivative_use_exvector_args)
- return ((derivative_funcp_exvector)(registered_functions()[serial].derivative_f))(seq, diff_param);
- switch (registered_functions()[serial].nparams) {
+ if (opt.derivative_use_exvector_args)
+ return ((derivative_funcp_exvector)(opt.derivative_f))(seq, diff_param);
+ switch (opt.nparams) {
// the following lines have been generated for max. ${maxargs} parameters
${diff_switch_statement}
// end of generated lines
#include <iosfwd>
#include <string>
+#include "class_info.h"
+
namespace GiNaC {
-/*
- * The following classes remain publicly visible for compatibility
- * reasons only. New code should use the iostream manipulators defined
- * in operators.h instead.
- */
+/** This class stores information about a registered print_context class. */
+class print_context_options {
+public:
+ print_context_options(const char *n, const char *p, unsigned i)
+ : name(n), parent_name(p), id(i) {}
+
+ const char *get_name() const { return name; }
+ const char *get_parent_name() const { return parent_name; }
+ unsigned get_id() const { return id; }
+
+private:
+ const char *name; /**< Class name. */
+ const char *parent_name; /**< Name of superclass. */
+ unsigned id; /**< ID number (assigned automatically). */
+};
+
+typedef class_info<print_context_options> print_context_class_info;
/** Flags to control the behavior of a print_context. */
};
-/** Context for default (ginsh-parsable) output. */
+/** Macro for inclusion in the declaration of a print_context class.
+ * It declares some functions that are common to all classes derived
+ * from 'print_context' as well as all required stuff for the GiNaC
+ * registry. */
+#define GINAC_DECLARE_PRINT_CONTEXT(classname, supername) \
+public: \
+ typedef supername inherited; \
+ friend class function_options; \
+private: \
+ static GiNaC::print_context_class_info reg_info; \
+public: \
+ virtual const GiNaC::print_context_class_info &get_class_info() const { return reg_info; } \
+ virtual const char *class_name() const { return reg_info.options.get_name(); } \
+ \
+ classname(); \
+ classname * duplicate() const { return new classname(*this); } \
+private:
+
+/** Macro for inclusion in the implementation of each print_context class. */
+#define GINAC_IMPLEMENT_PRINT_CONTEXT(classname, supername) \
+ GiNaC::print_context_class_info classname::reg_info = GiNaC::print_context_class_info(print_context_options(#classname, #supername, next_print_context_id++));
+
+extern unsigned next_print_context_id;
+
+
+/** Base class for print_contexts. */
class print_context
{
+ GINAC_DECLARE_PRINT_CONTEXT(print_context, void)
public:
- print_context();
print_context(std::ostream &, unsigned options = 0);
virtual ~print_context() {}
- virtual print_context * duplicate() const {return new print_context(*this);}
std::ostream & s; /**< stream to output to */
unsigned options; /**< option flags */
};
+/** Context for default (ginsh-parsable) output. */
+class print_dflt : public print_context
+{
+ GINAC_DECLARE_PRINT_CONTEXT(print_dflt, print_context)
+public:
+ print_dflt(std::ostream &, unsigned options = 0);
+};
+
/** Context for latex-parsable output. */
class print_latex : public print_context
{
+ GINAC_DECLARE_PRINT_CONTEXT(print_latex, print_context)
public:
- print_latex();
print_latex(std::ostream &, unsigned options = 0);
- print_context * duplicate() const {return new print_latex(*this);}
};
/** Context for python pretty-print output. */
class print_python : public print_context
{
+ GINAC_DECLARE_PRINT_CONTEXT(print_python, print_context)
public:
- print_python();
print_python(std::ostream &, unsigned options = 0);
- print_context * duplicate() const {return new print_python(*this);}
};
/** Context for python-parsable output. */
class print_python_repr : public print_context
{
+ GINAC_DECLARE_PRINT_CONTEXT(print_python_repr, print_context)
public:
- print_python_repr();
print_python_repr(std::ostream &, unsigned options = 0);
- print_context * duplicate() const {return new print_python_repr(*this);}
};
/** Context for tree-like output for debugging. */
class print_tree : public print_context
{
+ GINAC_DECLARE_PRINT_CONTEXT(print_tree, print_context)
public:
- print_tree(unsigned d = 4);
+ print_tree(unsigned d);
print_tree(std::ostream &, unsigned options = 0, unsigned d = 4);
- print_context * duplicate() const {return new print_tree(*this);}
const unsigned delta_indent; /**< size of indentation step */
};
/** Base context for C source output. */
class print_csrc : public print_context
{
+ GINAC_DECLARE_PRINT_CONTEXT(print_csrc, print_context)
public:
- print_csrc();
print_csrc(std::ostream &, unsigned options = 0);
- print_context * duplicate() const {return new print_csrc(*this);}
};
/** Context for C source output using float precision. */
class print_csrc_float : public print_csrc
{
+ GINAC_DECLARE_PRINT_CONTEXT(print_csrc_float, print_csrc)
public:
- print_csrc_float();
print_csrc_float(std::ostream &, unsigned options = 0);
- print_context * duplicate() const {return new print_csrc_float(*this);}
};
/** Context for C source output using double precision. */
class print_csrc_double : public print_csrc
{
+ GINAC_DECLARE_PRINT_CONTEXT(print_csrc_double, print_csrc)
public:
- print_csrc_double();
print_csrc_double(std::ostream &, unsigned options = 0);
- print_context * duplicate() const {return new print_csrc_double(*this);}
};
/** Context for C source output using CLN numbers. */
class print_csrc_cl_N : public print_csrc
{
+ GINAC_DECLARE_PRINT_CONTEXT(print_csrc_cl_N, print_csrc)
public:
- print_csrc_cl_N();
print_csrc_cl_N(std::ostream &, unsigned options = 0);
- print_context * duplicate() const {return new print_csrc_cl_N(*this);}
};
/** Check if obj is a T, including base classes. */
template <class T>
inline bool is_a(const print_context & obj)
-{ return dynamic_cast<const T *>(&obj)!=0; }
+{ return dynamic_cast<const T *>(&obj) != 0; }
} // namespace GiNaC