X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Ffunction.pl;h=26f37afdc29db6bd3e07cd6382bb51731749d79d;hp=b9ee78710d643a54b28914a1a9e7c36c108c350b;hb=6bff4f32e5cbe9f7e51837f392a2d0bf0d5b721d;hpb=708e9e647029af699333fceffc0a76bef70a4709 diff --git a/ginac/function.pl b/ginac/function.pl index b9ee7871..26f37afd 100755 --- a/ginac/function.pl +++ b/ginac/function.pl @@ -15,79 +15,68 @@ sub generate_seq { } sub generate_from_to { - my ($template,$seq_template1,$seq_template2,$from,$to)=@_; + my ($template,$seq_template1,$seq_template2,$seq_template3,$from,$to)=@_; my ($res,$N,$SEQ); $res=''; for ($N=$from; $N<=$to; $N++) { $SEQ1=generate_seq($seq_template1,$N); $SEQ2=generate_seq($seq_template2,$N); + $SEQ3=generate_seq($seq_template3,$N); $res .= eval('"' . $template . '"'); $SEQ1=''; # to avoid main::SEQ1 used only once warning $SEQ2=''; # same as above + $SEQ3=''; # same as above } return $res; } sub generate { - my ($template,$seq_template1,$seq_template2)=@_; - return generate_from_to($template,$seq_template1,$seq_template2,1,$maxargs); + my ($template,$seq_template1,$seq_template2,$seq_template3)=@_; + return generate_from_to($template,$seq_template1,$seq_template2,$seq_template3,1,$maxargs); } -$declare_function_macro = <<'END_OF_DECLARE_FUNCTION_1_AND_2P_MACRO'; -#define DECLARE_FUNCTION_1P(NAME) \ -extern const unsigned function_index_##NAME; \ -inline GiNaC::function NAME(const GiNaC::ex & p1) { \ - return GiNaC::function(function_index_##NAME, p1); \ -} -#define DECLARE_FUNCTION_2P(NAME) \ -extern const unsigned function_index_##NAME; \ -inline GiNaC::function NAME(const GiNaC::ex & p1, const GiNaC::ex & p2) { \ - return GiNaC::function(function_index_##NAME, p1, p2); \ -} - -END_OF_DECLARE_FUNCTION_1_AND_2P_MACRO - -$declare_function_macro .= generate_from_to( - <<'END_OF_DECLARE_FUNCTION_MACRO','const GiNaC::ex & p${N}','p${N}',3,$maxargs); +$declare_function_macro = generate( + <<'END_OF_DECLARE_FUNCTION_MACRO','typename T${N}','const T${N} & p${N}','GiNaC::ex(p${N})'); #define DECLARE_FUNCTION_${N}P(NAME) \\ extern const unsigned function_index_##NAME; \\ -inline GiNaC::function NAME(${SEQ1}) { \\ - return GiNaC::function(function_index_##NAME, ${SEQ2}); \\ +template<${SEQ1}> \\ +inline const GiNaC::function NAME(${SEQ2}) { \\ + return GiNaC::function(function_index_##NAME, ${SEQ3}); \\ } END_OF_DECLARE_FUNCTION_MACRO $typedef_eval_funcp=generate( 'typedef ex (* eval_funcp_${N})(${SEQ1});'."\n", -'const ex &',''); +'const ex &','',''); $typedef_evalf_funcp=generate( 'typedef ex (* evalf_funcp_${N})(${SEQ1});'."\n", -'const ex &',''); +'const ex &','',''); $typedef_derivative_funcp=generate( 'typedef ex (* derivative_funcp_${N})(${SEQ1}, unsigned);'."\n", -'const ex &',''); +'const ex &','',''); $typedef_series_funcp=generate( 'typedef ex (* series_funcp_${N})(${SEQ1}, const relational &, int, unsigned);'."\n", -'const ex &',''); +'const ex &','',''); -$eval_func_interface=generate(' function_options & eval_func(eval_funcp_${N} e);'."\n",'',''); +$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",'',''); +$evalf_func_interface=generate(' function_options & evalf_func(evalf_funcp_${N} ef);'."\n",'','',''); -$derivative_func_interface=generate(' function_options & derivative_func(derivative_funcp_${N} d);'."\n",'',''); +$derivative_func_interface=generate(' function_options & derivative_func(derivative_funcp_${N} d);'."\n",'','',''); -$series_func_interface=generate(' function_options & series_func(series_funcp_${N} s);'."\n",'',''); +$series_func_interface=generate(' function_options & series_func(series_funcp_${N} s);'."\n",'','',''); $constructors_interface=generate( ' function(unsigned ser, ${SEQ1});'."\n", -'const ex & param${N}',''); +'const ex & param${N}','',''); $constructors_implementation=generate( - <<'END_OF_CONSTRUCTORS_IMPLEMENTATION','const ex & param${N}','param${N}'); + <<'END_OF_CONSTRUCTORS_IMPLEMENTATION','const ex & param${N}','param${N}',''); function::function(unsigned ser, ${SEQ1}) : exprseq(${SEQ2}), serial(ser) { @@ -97,26 +86,26 @@ function::function(unsigned ser, ${SEQ1}) END_OF_CONSTRUCTORS_IMPLEMENTATION $eval_switch_statement=generate( - <<'END_OF_EVAL_SWITCH_STATEMENT','seq[${N}-1]',''); + <<'END_OF_EVAL_SWITCH_STATEMENT','seq[${N}-1]','',''); case ${N}: eval_result = ((eval_funcp_${N})(registered_functions()[serial].eval_f))(${SEQ1}); break; END_OF_EVAL_SWITCH_STATEMENT $evalf_switch_statement=generate( - <<'END_OF_EVALF_SWITCH_STATEMENT','eseq[${N}-1]',''); + <<'END_OF_EVALF_SWITCH_STATEMENT','eseq[${N}-1]','',''); case ${N}: return ((evalf_funcp_${N})(registered_functions()[serial].evalf_f))(${SEQ1}); END_OF_EVALF_SWITCH_STATEMENT $diff_switch_statement=generate( - <<'END_OF_DIFF_SWITCH_STATEMENT','seq[${N}-1]',''); + <<'END_OF_DIFF_SWITCH_STATEMENT','seq[${N}-1]','',''); case ${N}: return ((derivative_funcp_${N})(registered_functions()[serial].derivative_f))(${SEQ1},diff_param); END_OF_DIFF_SWITCH_STATEMENT $series_switch_statement=generate( - <<'END_OF_SERIES_SWITCH_STATEMENT','seq[${N}-1]',''); + <<'END_OF_SERIES_SWITCH_STATEMENT','seq[${N}-1]','',''); case ${N}: try { res = ((series_funcp_${N})(registered_functions()[serial].series_f))(${SEQ1},r,order,options); @@ -127,7 +116,7 @@ $series_switch_statement=generate( END_OF_SERIES_SWITCH_STATEMENT $eval_func_implementation=generate( - <<'END_OF_EVAL_FUNC_IMPLEMENTATION','',''); + <<'END_OF_EVAL_FUNC_IMPLEMENTATION','','',''); function_options & function_options::eval_func(eval_funcp_${N} e) { test_and_set_nparams(${N}); @@ -137,7 +126,7 @@ function_options & function_options::eval_func(eval_funcp_${N} e) END_OF_EVAL_FUNC_IMPLEMENTATION $evalf_func_implementation=generate( - <<'END_OF_EVALF_FUNC_IMPLEMENTATION','',''); + <<'END_OF_EVALF_FUNC_IMPLEMENTATION','','',''); function_options & function_options::evalf_func(evalf_funcp_${N} ef) { test_and_set_nparams(${N}); @@ -147,7 +136,7 @@ function_options & function_options::evalf_func(evalf_funcp_${N} ef) END_OF_EVALF_FUNC_IMPLEMENTATION $derivative_func_implementation=generate( - <<'END_OF_DERIVATIVE_FUNC_IMPLEMENTATION','',''); + <<'END_OF_DERIVATIVE_FUNC_IMPLEMENTATION','','',''); function_options & function_options::derivative_func(derivative_funcp_${N} d) { test_and_set_nparams(${N}); @@ -157,7 +146,7 @@ function_options & function_options::derivative_func(derivative_funcp_${N} d) END_OF_DERIVATIVE_FUNC_IMPLEMENTATION $series_func_implementation=generate( - <<'END_OF_SERIES_FUNC_IMPLEMENTATION','',''); + <<'END_OF_SERIES_FUNC_IMPLEMENTATION','','',''); function_options & function_options::series_func(series_funcp_${N} s) { test_and_set_nparams(${N}); @@ -169,7 +158,7 @@ END_OF_SERIES_FUNC_IMPLEMENTATION $interface=< #include -// CINT needs to work properly with +// CINT needs to work properly with #include #include "exprseq.h" @@ -212,6 +201,9 @@ $declare_function_macro const unsigned function_index_##NAME= \\ GiNaC::function::register_new(GiNaC::function_options(#NAME).OPT); +// The TYPECHECK-macros were used inside the _evalf() functions. They are +// considered obsolete now: (FIXME: remove them) + #define BEGIN_TYPECHECK \\ bool automatic_typecheck=true; @@ -251,6 +243,7 @@ $typedef_series_funcp class function_options { friend class function; + friend class fderivative; public: function_options(); function_options(std::string const & n, std::string const & tn=std::string()); @@ -316,7 +309,6 @@ class function : public exprseq friend class remember_table_entry; // friend class remember_table_list; // friend class remember_table; - friend ex Derivative_eval(const ex &, const ex &); // member functions @@ -330,7 +322,7 @@ $constructors_interface function(unsigned ser, const exvector & v, bool discardable = false); function(unsigned ser, exvector * vp); // vp will be deleted - // functions overriding virtual functions from bases classes + // functions overriding virtual functions from base classes public: void print(const print_context & c, unsigned level = 0) const; unsigned precedence(void) const {return 70;} @@ -387,7 +379,7 @@ template<> inline bool is_exactly_a(const basic & obj) } #define is_ex_the_function(OBJ, FUNCNAME) \\ - (is_ex_exactly_of_type(OBJ, function) && static_cast(OBJ.bp)->get_serial() == function_index_##FUNCNAME) + (is_exactly_a(OBJ) && static_cast(OBJ.bp)->get_serial() == function_index_##FUNCNAME) } // namespace GiNaC @@ -398,7 +390,7 @@ END_OF_INTERFACE $implementation=< #include "function.h" +#include "fderivative.h" #include "ex.h" #include "lst.h" #include "symmetry.h" #include "print.h" #include "archive.h" #include "inifcns.h" +#include "tostring.h" #include "utils.h" #include "debugmsg.h" #include "remember.h" @@ -629,7 +623,7 @@ function::function(const archive_node &n, const lst &sym_lst) : inherited(n, sym serial = ser; return; } - i++; ser++; + ++i; ++ser; } throw (std::runtime_error("unknown function '" + s + "' in archive")); } else @@ -651,7 +645,7 @@ void function::archive(archive_node &n) const } ////////// -// functions overriding virtual functions from bases classes +// functions overriding virtual functions from base classes ////////// // public @@ -687,7 +681,7 @@ void function::print(const print_context & c, unsigned level) const exvector::const_iterator it = seq.begin(), itend = seq.end(); while (it != itend) { it->print(c); - it++; + ++it; if (it != itend) c.s << ","; } @@ -743,7 +737,7 @@ ex function::eval(int level) const // Canonicalize argument order according to the symmetry properties if (seq.size() > 1 && !(opt.symtree.is_zero())) { exvector v = seq; - GINAC_ASSERT(is_ex_exactly_of_type(opt.symtree, symmetry)); + GINAC_ASSERT(is_a(opt.symtree)); int sig = canonicalize(v.begin(), ex_to(opt.symtree)); if (sig != INT_MAX) { // Something has changed while sorting arguments, more evaluations later @@ -788,11 +782,11 @@ ex function::evalf(int level) const throw(std::runtime_error("max recursion level reached")); else eseq.reserve(seq.size()); - level--; + --level; exvector::const_iterator it = seq.begin(), itend = seq.end(); while (it != itend) { - eseq.push_back((*it).evalf(level)); - it++; + eseq.push_back(it->evalf(level)); + ++it; } if (registered_functions()[serial].evalf_f==0) { @@ -857,25 +851,10 @@ ${series_switch_statement} ex function::derivative(const symbol & s) const { ex result; - + if (serial == function_index_Order) { // Order Term function only differentiates the argument return Order(seq[0].diff(s)); - } else if (serial == function_index_Derivative) { - // Inert derivative performs chain rule on the first argument only, and - // adds differentiation parameter to list (second argument) - GINAC_ASSERT(is_ex_exactly_of_type(seq[0], function)); - GINAC_ASSERT(is_ex_exactly_of_type(seq[1], function)); - ex fcn = seq[0]; - ex arg_diff; - for (unsigned i=0; i!=fcn.nops(); i++) { - arg_diff = fcn.op(i).diff(s); - if (!arg_diff.is_zero()) { - lst new_lst = ex_to(seq[1]); - new_lst.append(i); - result += arg_diff * Derivative(fcn, new_lst); - } - } } else { // Chain rule ex arg_diff; @@ -956,9 +935,10 @@ ex function::pderivative(unsigned diff_param) const // partial differentiation { GINAC_ASSERT(serial=opt.functions_with_same_name) { @@ -998,14 +978,14 @@ unsigned function::register_new(function_options const & opt) // usually executed before main(), so the exception could not // caught anyhow std::cerr << "WARNING: function name " << opt.name - << " already in use!" << std::endl; + << " already in use!" << std::endl; } registered_functions().push_back(opt); if (opt.use_remember) { remember_table::remember_tables(). push_back(remember_table(opt.remember_size, - opt.remember_assoc_size, - opt.remember_strategy)); + opt.remember_assoc_size, + opt.remember_strategy)); } else { remember_table::remember_tables().push_back(remember_table()); } @@ -1021,8 +1001,8 @@ unsigned function::find_function(const std::string &name, unsigned nparams) while (i != end) { if (i->get_name() == name && i->get_nparams() == nparams) return serial; - i++; - serial++; + ++i; + ++serial; } throw (std::runtime_error("no function '" + name + "' with " + ToString(nparams) + " parameters defined")); }