X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Ffunction.pl;h=a680fc8685562b67630521aadb2dfa702eb2cc12;hp=6493042b7753d5f0583aad1805faab91fe58d33b;hb=5184d67c0ec1056ac039419e08558632793a4e2c;hpb=afdd7fa8c6c0a587f7c80789198551383e8beb7b diff --git a/ginac/function.pl b/ginac/function.pl index 6493042b..a680fc86 100755 --- a/ginac/function.pl +++ b/ginac/function.pl @@ -16,12 +16,12 @@ sub generate_seq { return $res; } -sub generate { - my ($template,$seq_template1,$seq_template2)=@_; +sub generate_from_to { + my ($template,$seq_template1,$seq_template2,$from,$to)=@_; my ($res,$N,$SEQ); $res=''; - for ($N=1; $N<=$maxargs; $N++) { + for ($N=$from; $N<=$to; $N++) { $SEQ1=generate_seq($seq_template1,$N); $SEQ2=generate_seq($seq_template2,$N); $res .= eval('"' . $template . '"'); @@ -31,8 +31,56 @@ sub generate { return $res; } -$declare_function_macro_namespace=generate( - <<'END_OF_DECLARE_FUNCTION_MACRO_NAMESPACE','GiNaC::ex const & p${N}','p${N}'); +sub generate { + my ($template,$seq_template1,$seq_template2)=@_; + return generate_from_to($template,$seq_template1,$seq_template2,1,$maxargs); +} + +$declare_function_macro_namespace = <<'END_OF_DECLARE_FUNCTION_1_AND_2P_MACRO_NAMESPACE'; +#ifdef CINT_CONVERSION_WORKAROUND + +#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); \ +} \ +inline GiNaC::function NAME(const GiNaC::basic & p1) { \ + return GiNaC::function(function_index_##NAME, GiNaC::ex(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); \ +} \ +inline GiNaC::function NAME(const GiNaC::basic & p1, const GiNaC::ex & p2) { \ + return GiNaC::function(function_index_##NAME, GiNaC::ex(p1), p2); \ +} \ +inline GiNaC::function NAME(const GiNaC::ex & p1, const GiNaC::basic & p2) { \ + return GiNaC::function(function_index_##NAME, p1, GiNaC::ex(p2)); \ +} \ +inline GiNaC::function NAME(const GiNaC::basic & p1, const GiNaC::basic & p2) { \ + return GiNaC::function(function_index_##NAME, GiNaC::ex(p1), GiNaC::ex(p2)); \ +} + +#else // def CINT_CONVERSION_WORKAROUND + +#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); \ +} + +#endif // def CINT_CONVERSION_WORKAROUND + +END_OF_DECLARE_FUNCTION_1_AND_2P_MACRO_NAMESPACE + +$declare_function_macro_namespace .= generate_from_to( + <<'END_OF_DECLARE_FUNCTION_MACRO_NAMESPACE','const GiNaC::ex & p${N}','p${N}',3,$maxargs); #define DECLARE_FUNCTION_${N}P(NAME) \\ extern const unsigned function_index_##NAME; \\ inline GiNaC::function NAME(${SEQ1}) { \\ @@ -41,10 +89,53 @@ inline GiNaC::function NAME(${SEQ1}) { \\ END_OF_DECLARE_FUNCTION_MACRO_NAMESPACE -$declare_function_macro_no_namespace=generate( - <<'END_OF_DECLARE_FUNCTION_MACRO_NO_NAMESPACE','ex const & p${N}','p${N}'); +$declare_function_macro_no_namespace = <<'END_OF_DECLARE_FUNCTION_1_AND_2P_MACRO_NO_NAMESPACE'; +#ifdef CINT_CONVERSION_WORKAROUND + +#define DECLARE_FUNCTION_1P(NAME) \ +extern const unsigned function_index_##NAME; \ +inline function NAME(const ex & p1) { \ + return function(function_index_##NAME, p1); \ +} \ +inline function NAME(const basic & p1) { \ + return function(function_index_##NAME, ex(p1)); \ +} +#define DECLARE_FUNCTION_2P(NAME) \ +extern const unsigned function_index_##NAME; \ +inline function NAME(const ex & p1, const ex & p2) { \ + return function(function_index_##NAME, p1, p2); \ +} \ +inline function NAME(const basic & p1, const ex & p2) { \ + return function(function_index_##NAME, ex(p1), p2); \ +} \ +inline function NAME(const ex & p1, const basic & p2) { \ + return function(function_index_##NAME, p1, ex(p2)); \ +} \ +inline function NAME(const basic & p1, const basic & p2) { \ + return function(function_index_##NAME, ex(p1), ex(p2)); \ +} + +#else // def CINT_CONVERSION_WORKAROUND + +#define DECLARE_FUNCTION_1P(NAME) \ +extern const unsigned function_index_##NAME; \ +inline function NAME(const ex & p1) { \ + return function(function_index_##NAME, p1); \ +} +#define DECLARE_FUNCTION_2P(NAME) \ +extern const unsigned function_index_##NAME; \ +inline function NAME(const ex & p1, const ex & p2) { \ + return function(function_index_##NAME, p1, p2); \ +} + +#endif // def CINT_CONVERSION_WORKAROUND + +END_OF_DECLARE_FUNCTION_1_AND_2P_MACRO_NO_NAMESPACE + +$declare_function_macro_no_namespace .= generate_from_to( + <<'END_OF_DECLARE_FUNCTION_MACRO_NO_NAMESPACE','const ex & p${N}','p${N}',3,$maxargs); #define DECLARE_FUNCTION_${N}P(NAME) \\ -extern unsigned function_index_##NAME; \\ +extern const unsigned function_index_##NAME; \\ inline function NAME(${SEQ1}) { \\ return function(function_index_##NAME, ${SEQ2}); \\ } @@ -53,31 +144,34 @@ END_OF_DECLARE_FUNCTION_MACRO_NO_NAMESPACE $typedef_eval_funcp=generate( 'typedef ex (* eval_funcp_${N})(${SEQ1});'."\n", -'ex const &',''); +'const ex &',''); $typedef_evalf_funcp=generate( 'typedef ex (* evalf_funcp_${N})(${SEQ1});'."\n", -'ex const &',''); +'const ex &',''); -$typedef_diff_funcp=generate( -'typedef ex (* diff_funcp_${N})(${SEQ1}, unsigned);'."\n", -'ex const &',''); +$typedef_derivative_funcp=generate( +'typedef ex (* derivative_funcp_${N})(${SEQ1}, unsigned);'."\n", +'const ex &',''); $typedef_series_funcp=generate( -'typedef ex (* series_funcp_${N})(${SEQ1}, symbol const &, ex const &, int);'."\n", -'ex const &',''); +'typedef ex (* series_funcp_${N})(${SEQ1}, const symbol &, const ex &, int);'."\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",'',''); + +$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",'',''); $constructors_interface=generate( ' function(unsigned ser, ${SEQ1});'."\n", -'ex const & param${N}',''); - -$register_new_interface=generate( -' static unsigned register_new(char const * nm, eval_funcp_${N} e,'."\n". -' evalf_funcp_${N} ef=0, diff_funcp_${N} d=0, series_funcp_${N} s=0);'. -"\n",'',''); +'const ex & param${N}',''); $constructors_implementation=generate( - <<'END_OF_CONSTRUCTORS_IMPLEMENTATION','ex const & param${N}','param${N}'); + <<'END_OF_CONSTRUCTORS_IMPLEMENTATION','const ex & param${N}','param${N}'); function::function(unsigned ser, ${SEQ1}) : exprseq(${SEQ2}), serial(ser) { @@ -87,44 +181,77 @@ function::function(unsigned ser, ${SEQ1}) END_OF_CONSTRUCTORS_IMPLEMENTATION $eval_switch_statement=generate( - <<'END_OF_EVAL_SWITCH_STATEMENT','eseq[${N}-1]',''); + <<'END_OF_EVAL_SWITCH_STATEMENT','seq[${N}-1]',''); case ${N}: - return ((eval_funcp_${N})(registered_functions()[serial].e))(${SEQ1}); + 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]',''); case ${N}: - return ((evalf_funcp_${N})(registered_functions()[serial].ef))(${SEQ1}); + return ((evalf_funcp_${N})(registered_functions()[serial].evalf_f))(${SEQ1}); break; END_OF_EVALF_SWITCH_STATEMENT $diff_switch_statement=generate( <<'END_OF_DIFF_SWITCH_STATEMENT','seq[${N}-1]',''); case ${N}: - return ((diff_funcp_${N})(registered_functions()[serial].d))(${SEQ1},diff_param); + return ((derivative_funcp_${N})(registered_functions()[serial].derivative_f))(${SEQ1},diff_param); break; END_OF_DIFF_SWITCH_STATEMENT $series_switch_statement=generate( <<'END_OF_SERIES_SWITCH_STATEMENT','seq[${N}-1]',''); case ${N}: - return ((series_funcp_${N})(registered_functions()[serial].s))(${SEQ1},s,point,order); + try { + res = ((series_funcp_${N})(registered_functions()[serial].series_f))(${SEQ1},s,point,order); + } catch (do_taylor) { + res = basic::series(s, point, order); + } + return res; break; END_OF_SERIES_SWITCH_STATEMENT -$register_new_implementation=generate( - <<'END_OF_REGISTER_NEW_IMPLEMENTATION','',''); -unsigned function::register_new(char const * nm, eval_funcp_${N} e, - evalf_funcp_${N} ef, diff_funcp_${N} d, series_funcp_${N} s) +$eval_func_implementation=generate( + <<'END_OF_EVAL_FUNC_IMPLEMENTATION','',''); +function_options & function_options::eval_func(eval_funcp_${N} e) { - registered_function_info rfi={nm,${N},0,eval_funcp(e), - evalf_funcp(ef),diff_funcp(d),series_funcp(s)}; - registered_functions().push_back(rfi); - return registered_functions().size()-1; -} -END_OF_REGISTER_NEW_IMPLEMENTATION + test_and_set_nparams(${N}); + eval_f=eval_funcp(e); + return *this; +} +END_OF_EVAL_FUNC_IMPLEMENTATION + +$evalf_func_implementation=generate( + <<'END_OF_EVALF_FUNC_IMPLEMENTATION','',''); +function_options & function_options::evalf_func(evalf_funcp_${N} ef) +{ + test_and_set_nparams(${N}); + evalf_f=evalf_funcp(ef); + return *this; +} +END_OF_EVALF_FUNC_IMPLEMENTATION + +$derivative_func_implementation=generate( + <<'END_OF_DERIVATIVE_FUNC_IMPLEMENTATION','',''); +function_options & function_options::derivative_func(derivative_funcp_${N} d) +{ + test_and_set_nparams(${N}); + derivative_f=derivative_funcp(d); + return *this; +} +END_OF_DERIVATIVE_FUNC_IMPLEMENTATION + +$series_func_implementation=generate( + <<'END_OF_SERIES_FUNC_IMPLEMENTATION','',''); +function_options & function_options::series_func(series_funcp_${N} s) +{ + test_and_set_nparams(${N}); + series_f=series_funcp(s); + return *this; +} +END_OF_SERIES_FUNC_IMPLEMENTATION $interface=< #endif // def __CINT__ -#include +#include "exprseq.h" -#ifndef NO_GINAC_NAMESPACE +#ifndef NO_NAMESPACE_GINAC // the following lines have been generated for max. ${maxargs} parameters $declare_function_macro_namespace // end of generated lines -#else // ndef NO_GINAC_NAMESPACE +#else // ndef NO_NAMESPACE_GINAC // the following lines have been generated for max. ${maxargs} parameters $declare_function_macro_no_namespace // end of generated lines -#endif // ndef NO_GINAC_NAMESPACE +#endif // ndef NO_NAMESPACE_GINAC + +#ifndef NO_NAMESPACE_GINAC -#ifndef NO_GINAC_NAMESPACE +#define REGISTER_FUNCTION(NAME,OPT) \\ +const unsigned function_index_##NAME= \\ + GiNaC::function::register_new(GiNaC::function_options(#NAME).OPT); -#define REGISTER_FUNCTION(NAME,E,EF,D,S) \\ +#define REGISTER_FUNCTION_OLD(NAME,E,EF,D,S) \\ +const unsigned function_index_##NAME= \\ + GiNaC::function::register_new(GiNaC::function_options(#NAME). \\ + eval_func(E). \\ + evalf_func(EF). \\ + derivative_func(D). \\ + series_func(S)); -const unsigned function_index_##NAME=GiNaC::function::register_new(#NAME,E,EF,D,S); +#else // ndef NO_NAMESPACE_GINAC -#else // ndef NO_GINAC_NAMESPACE +#define REGISTER_FUNCTION(NAME,OPT) \\ +const unsigned function_index_##NAME= \\ + function::register_new(function_options(#NAME).OPT); -const unsigned function_index_##NAME=function::register_new(#NAME,E,EF,D,S); +#define REGISTER_FUNCTION_OLD(NAME,E,EF,D,S) \\ +const unsigned function_index_##NAME= \\ + function::register_new(function_options(#NAME). \\ + eval_func(E). \\ + evalf_func(EF). \\ + derivative_func(D). \\ + series_func(S)); -#endif // ndef NO_GINAC_NAMESPACE +#endif // ndef NO_NAMESPACE_GINAC #define BEGIN_TYPECHECK \\ bool automatic_typecheck=true; @@ -200,21 +345,21 @@ if (!is_ex_exactly_of_type(VAR,TYPE)) { \\ automatic_typecheck=false; \\ } else -#ifndef NO_GINAC_NAMESPACE +#ifndef NO_NAMESPACE_GINAC #define TYPECHECK_INTEGER(VAR) \\ if (!(VAR).info(GiNaC::info_flags::integer)) { \\ automatic_typecheck=false; \\ } else -#else // ndef NO_GINAC_NAMESPACE +#else // ndef NO_NAMESPACE_GINAC #define TYPECHECK_INTEGER(VAR) \\ if (!(VAR).info(info_flags::integer)) { \\ automatic_typecheck=false; \\ } else -#endif // ndef NO_GINAC_NAMESPACE +#endif // ndef NO_NAMESPACE_GINAC #define END_TYPECHECK(RV) \\ {} \\ @@ -222,51 +367,96 @@ if (!automatic_typecheck) { \\ return RV.hold(); \\ } -#ifndef NO_GINAC_NAMESPACE +#ifndef NO_NAMESPACE_GINAC namespace GiNaC { -#endif // ndef NO_GINAC_NAMESPACE +#endif // ndef NO_NAMESPACE_GINAC class function; typedef ex (* eval_funcp)(); typedef ex (* evalf_funcp)(); -typedef ex (* diff_funcp)(); +typedef ex (* derivative_funcp)(); typedef ex (* series_funcp)(); // the following lines have been generated for max. ${maxargs} parameters $typedef_eval_funcp $typedef_evalf_funcp -$typedef_diff_funcp +$typedef_derivative_funcp $typedef_series_funcp // end of generated lines -struct registered_function_info { - char const * name; +class function_options +{ + friend class function; +public: + function_options(); + function_options(string const & n, string const & tn=string()); + ~function_options(); + void initialize(void); + function_options & set_name(string const & n, string const & tn=string()); +// the following lines have been generated for max. ${maxargs} parameters +$eval_func_interface +$evalf_func_interface +$derivative_func_interface +$series_func_interface +// end of generated lines + function_options & set_return_type(unsigned rt, unsigned rtt=0); + function_options & do_not_evalf_params(void); + function_options & remember(unsigned size, unsigned assoc_size=0, + unsigned strategy=remember_strategies::delete_never); + function_options & overloaded(unsigned o); + void test_and_set_nparams(unsigned n); + string get_name(void) const { return name; } + unsigned get_nparams(void) const { return nparams; } + +protected: + string name; + string TeX_name; + unsigned nparams; - unsigned options; - eval_funcp e; - evalf_funcp ef; - diff_funcp d; - series_funcp s; + + eval_funcp eval_f; + evalf_funcp evalf_f; + derivative_funcp derivative_f; + series_funcp series_f; + + bool evalf_params_first; + + bool use_return_type; + unsigned return_type; + unsigned return_type_tinfo; + + bool use_remember; + unsigned remember_size; + unsigned remember_assoc_size; + unsigned remember_strategy; + + unsigned functions_with_same_name; }; /** The class function is used to implement builtin functions like sin, cos... and user defined functions */ class function : public exprseq { + GINAC_DECLARE_REGISTERED_CLASS(function, exprseq) + // CINT has a linking problem friend void ginsh_get_ginac_functions(void); + friend class remember_table_entry; + // friend class remember_table_list; + // friend class remember_table; + // member functions // default constructor, destructor, copy constructor assignment operator and helpers public: function(); ~function(); - function(function const & other); - function const & operator=(function const & other); + function(const function & other); + const function & operator=(const function & other); protected: - void copy(function const & other); + void copy(const function & other); void destroy(bool call_parent); // other constructors @@ -275,8 +465,8 @@ public: // the following lines have been generated for max. ${maxargs} parameters $constructors_interface // end of generated lines - function(unsigned ser, exprseq const & es); - function(unsigned ser, exvector const & v, bool discardable=0); + function(unsigned ser, const exprseq & es); + function(unsigned ser, const exvector & v, bool discardable=0); function(unsigned ser, exvector * vp); // vp will be deleted // functions overriding virtual functions from bases classes @@ -289,13 +479,13 @@ public: ex expand(unsigned options=0) const; ex eval(int level=0) const; ex evalf(int level=0) const; - ex diff(symbol const & s) const; - ex series(symbol const & s, ex const & point, int order) const; - ex thisexprseq(exvector const & v) const; + ex series(const symbol & s, const ex & point, int order) const; + ex thisexprseq(const exvector & v) const; ex thisexprseq(exvector * vp) const; protected: - int compare_same_type(basic const & other) const; - bool is_equal_same_type(basic const & other) const; + ex derivative(const symbol & s) const; + int compare_same_type(const basic & other) const; + bool is_equal_same_type(const basic & other) const; unsigned return_type(void) const; unsigned return_type_tinfo(void) const; @@ -304,12 +494,12 @@ protected: // non-virtual functions in this class protected: - ex pdiff(unsigned diff_param) const; // partial differentiation - static vector & registered_functions(void); + ex pderivative(unsigned diff_param) const; // partial differentiation + static vector & registered_functions(void); + bool lookup_remember_table(ex & result) const; + void store_remember_table(ex const & result) const; public: - // the following lines have been generated for max. ${maxargs} parameters -$register_new_interface - // end of generated lines + static unsigned register_new(function_options const & opt); unsigned getserial(void) const {return serial;} // member variables @@ -320,26 +510,26 @@ protected: // utility macros -#ifndef NO_GINAC_NAMESPACE +#ifndef NO_NAMESPACE_GINAC #define is_ex_the_function(OBJ, FUNCNAME) \\ (is_ex_exactly_of_type(OBJ, function) && static_cast(OBJ.bp)->getserial() == function_index_##FUNCNAME) -#else // ndef NO_GINAC_NAMESPACE +#else // ndef NO_NAMESPACE_GINAC #define is_ex_the_function(OBJ, FUNCNAME) \\ (is_ex_exactly_of_type(OBJ, function) && static_cast(OBJ.bp)->getserial() == function_index_##FUNCNAME) -#endif // ndef NO_GINAC_NAMESPACE +#endif // ndef NO_NAMESPACE_GINAC // global constants extern const function some_function; -extern type_info const & typeid_function; +extern const type_info & typeid_function; -#ifndef NO_GINAC_NAMESPACE +#ifndef NO_NAMESPACE_GINAC } // namespace GiNaC -#endif // ndef NO_GINAC_NAMESPACE +#endif // ndef NO_NAMESPACE_GINAC #endif // ndef __GINAC_FUNCTION_H__ @@ -355,7 +545,7 @@ $implementation=< #include +#include #include "function.h" #include "ex.h" +#include "archive.h" +#include "inifcns.h" +#include "utils.h" #include "debugmsg.h" -#ifndef NO_GINAC_NAMESPACE +#ifndef NO_NAMESPACE_GINAC namespace GiNaC { -#endif // ndef NO_GINAC_NAMESPACE +#endif // ndef NO_NAMESPACE_GINAC + +function_options::function_options() +{ + initialize(); +} + +function_options::function_options(string const & n, string const & tn) +{ + initialize(); + set_name(n,tn); +} + +function_options::~function_options() +{ + // nothing to clean up at the moment +} + +void function_options::initialize(void) +{ + set_name("unnamed_function","\\\\operatorname{unnamed}"); + nparams=0; + eval_f=evalf_f=derivative_f=series_f=0; + evalf_params_first=true; + use_return_type=false; + use_remember=false; + functions_with_same_name=1; +} + +function_options & function_options::set_name(string const & n, + string const & tn) +{ + name=n; + if (tn==string()) { + TeX_name="\\\\operatorname{"+name+"}"; + } else { + TeX_name=tn; + } + return *this; +} + +// the following lines have been generated for max. ${maxargs} parameters +$eval_func_implementation +$evalf_func_implementation +$derivative_func_implementation +$series_func_implementation +// end of generated lines + +function_options & function_options::set_return_type(unsigned rt, unsigned rtt) +{ + use_return_type=true; + return_type=rt; + return_type_tinfo=rtt; + return *this; +} + +function_options & function_options::do_not_evalf_params(void) +{ + evalf_params_first=false; + return *this; +} + +function_options & function_options::remember(unsigned size, + unsigned assoc_size, + unsigned strategy) +{ + use_remember=true; + remember_size=size; + remember_assoc_size=assoc_size; + remember_strategy=strategy; + return *this; +} + +function_options & function_options::overloaded(unsigned o) +{ + functions_with_same_name=o; + return *this; +} + +void function_options::test_and_set_nparams(unsigned n) +{ + if (nparams==0) { + nparams=n; + } 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 + cerr << "WARNING: number of parameters (" + << n << ") differs from number set before (" + << nparams << ")" << endl; + } +} + +class remember_table_entry { +public: + remember_table_entry(function const & f, ex const & r) : + hashvalue(f.gethash()), seq(f.seq), result(r) + { + last_access=0; + successful_hits=0; + } + bool is_equal(function const & f) const + { + GINAC_ASSERT(f.seq.size()==seq.size()); + if (f.gethash()!=hashvalue) return false; + for (unsigned i=0; i { +public: + remember_table_list() + { + max_assoc_size=0; + delete_strategy=0; + } + remember_table_list(unsigned as, unsigned strat) + { + max_assoc_size=as; + delete_strategy=strat; + } + void add_entry(function const & f, ex const & result) + { + push_back(remember_table_entry(f,result)); + } + bool lookup_entry(function const & f, ex & result) const + { + for (const_iterator cit=begin(); cit!=end(); ++cit) { + if (cit->is_equal(f)) { + result=cit->result; + return true; + } + } + return false; + } +protected: + unsigned max_assoc_size; + unsigned delete_strategy; +}; + + +class remember_table : public vector { +public: + remember_table() + { + } + remember_table(unsigned s, unsigned as, unsigned strat) + { + calc_size(s); + reserve(table_size); + for (unsigned i=0; i=size()) { + cerr << "entry=" << entry << ",size=" << size() << endl; + } + GINAC_ASSERT(entry & remember_tables(void) +{ + static vector * rt=new vector; + return *rt; +} + +GINAC_IMPLEMENT_REGISTERED_CLASS(function, exprseq) ////////// // default constructor, destructor, copy constructor assignment operator and helpers @@ -401,13 +795,13 @@ function::~function() destroy(0); } -function::function(function const & other) +function::function(const function & other) { debugmsg("function copy constructor",LOGLEVEL_CONSTRUCT); copy(other); } -function const & function::operator=(function const & other) +const function & function::operator=(const function & other) { debugmsg("function operator=",LOGLEVEL_ASSIGNMENT); if (this != &other) { @@ -419,7 +813,7 @@ function const & function::operator=(function const & other) // protected -void function::copy(function const & other) +void function::copy(const function & other) { exprseq::copy(other); serial=other.serial; @@ -446,13 +840,13 @@ function::function(unsigned ser) : serial(ser) $constructors_implementation // end of generated lines -function::function(unsigned ser, exprseq const & es) : exprseq(es), serial(ser) +function::function(unsigned ser, const exprseq & es) : exprseq(es), serial(ser) { debugmsg("function constructor from unsigned,exprseq",LOGLEVEL_CONSTRUCT); tinfo_key = TINFO_function; } -function::function(unsigned ser, exvector const & v, bool discardable) +function::function(unsigned ser, const exvector & v, bool discardable) : exprseq(v,discardable), serial(ser) { debugmsg("function constructor from string,exvector,bool",LOGLEVEL_CONSTRUCT); @@ -466,6 +860,46 @@ function::function(unsigned ser, exvector * vp) tinfo_key = TINFO_function; } +////////// +// archiving +////////// + +/** Construct object from archive_node. */ +function::function(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst) +{ + debugmsg("function constructor from archive_node", LOGLEVEL_CONSTRUCT); + + // Find serial number by function name + string s; + if (n.find_string("name", s)) { + unsigned int ser = 0; + vector::const_iterator i = registered_functions().begin(), iend = registered_functions().end(); + while (i != iend) { + if (s == i->name) { + serial = ser; + return; + } + i++; ser++; + } + throw (std::runtime_error("unknown function '" + s + "' in archive")); + } else + throw (std::runtime_error("unnamed function in archive")); +} + +/** Unarchive the object. */ +ex function::unarchive(const archive_node &n, const lst &sym_lst) +{ + return (new function(n, sym_lst))->setflag(status_flags::dynallocated); +} + +/** Archive the object. */ +void function::archive(archive_node &n) const +{ + inherited::archive(n); + GINAC_ASSERT(serial < registered_functions().size()); + n.add_string("name", registered_functions()[serial].name); +} + ////////// // functions overriding virtual functions from bases classes ////////// @@ -513,7 +947,7 @@ void function::printtree(ostream & os, unsigned indent) const << ", hash=" << hashvalue << " (0x" << hex << hashvalue << dec << ")" << ", flags=" << flags << ", nops=" << nops() << endl; - for (int i=0; i1) { + // first evaluate children, then we will end up here again + return function(serial,evalchildren(level)); + } - if (registered_functions()[serial].e==0) { - return function(serial,eseq).hold(); + if (registered_functions()[serial].eval_f==0) { + return this->hold(); } + + bool use_remember=registered_functions()[serial].use_remember; + ex eval_result; + if (use_remember && lookup_remember_table(eval_result)) { + return eval_result; + } + switch (registered_functions()[serial].nparams) { // the following lines have been generated for max. ${maxargs} parameters ${eval_switch_statement} // end of generated lines + default: + throw(std::logic_error("function::eval(): invalid nparams")); } - throw(std::logic_error("function::eval(): invalid nparams")); + if (use_remember) { + store_remember_table(eval_result); + } + return eval_result; } ex function::evalf(int level) const @@ -572,7 +1021,7 @@ ex function::evalf(int level) const exvector eseq=evalfchildren(level); - if (registered_functions()[serial].ef==0) { + if (registered_functions()[serial].evalf_f==0) { return function(serial,eseq).hold(); } switch (registered_functions()[serial].nparams) { @@ -583,7 +1032,7 @@ ${evalf_switch_statement} throw(std::logic_error("function::evalf(): invalid nparams")); } -ex function::thisexprseq(exvector const & v) const +ex function::thisexprseq(const exvector & v) const { return function(serial,v); } @@ -595,13 +1044,14 @@ ex function::thisexprseq(exvector * vp) const /** Implementation of ex::series for functions. * \@see ex::series */ -ex function::series(symbol const & s, ex const & point, int order) const +ex function::series(const symbol & s, const ex & point, int order) const { GINAC_ASSERT(serial(const_cast(other)); + const function & o=static_cast(const_cast(other)); if (serial!=o.serial) { return serial < o.serial ? -1 : 1; @@ -623,10 +1101,10 @@ int function::compare_same_type(basic const & other) const return exprseq::compare_same_type(o); } -bool function::is_equal_same_type(basic const & other) const +bool function::is_equal_same_type(const basic & other) const { GINAC_ASSERT(is_of_type(other, function)); - function const & o=static_cast(const_cast(other)); + const function & o=static_cast(const_cast(other)); if (serial!=o.serial) return false; return exprseq::is_equal_same_type(o); @@ -660,32 +1138,64 @@ unsigned function::return_type_tinfo(void) const // protected -ex function::pdiff(unsigned diff_param) const // partial differentiation +ex function::pderivative(unsigned diff_param) const // partial differentiation { GINAC_ASSERT(serial & function::registered_functions(void) +vector & function::registered_functions(void) { - static vector * rf=new vector; + static vector * rf=new vector; return *rf; } +bool function::lookup_remember_table(ex & result) const +{ + return remember_tables()[serial].lookup_entry(*this,result); +} + +void function::store_remember_table(ex const & result) const +{ + remember_tables()[serial].add_entry(*this,result); +} + // public -// the following lines have been generated for max. ${maxargs} parameters -$register_new_implementation -// end of generated lines +unsigned function::register_new(function_options const & opt) +{ + unsigned same_name=0; + for (unsigned i=0; i=opt.functions_with_same_name) { + // we do not throw an exception here because this code is + // usually executed before main(), so the exception could not + // caught anyhow + cerr << "WARNING: function name " << opt.name + << " already in use!" << endl; + } + registered_functions().push_back(opt); + if (opt.use_remember) { + remember_tables().push_back(remember_table(opt.remember_size, + opt.remember_assoc_size, + opt.remember_strategy)); + } else { + remember_tables().push_back(remember_table()); + } + return registered_functions().size()-1; +} ////////// // static member variables @@ -698,11 +1208,11 @@ $register_new_implementation ////////// const function some_function; -type_info const & typeid_function=typeid(some_function); +const type_info & typeid_function=typeid(some_function); -#ifndef NO_GINAC_NAMESPACE +#ifndef NO_NAMESPACE_GINAC } // namespace GiNaC -#endif // ndef NO_GINAC_NAMESPACE +#endif // ndef NO_NAMESPACE_GINAC END_OF_IMPLEMENTATION