X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Ffunction.pl;h=d97e58f674e916b0b81109afdbd7dae20b732008;hp=e2b4374f4e745701a82a87038ce7a3b23d879def;hb=383d5eb3b0f0506810d9105a268f939125bfc347;hpb=0a1b35cf1e59c9e3aae33de8febaa1c8f4bbe630 diff --git a/ginac/function.pl b/ginac/function.pl index e2b4374f..d97e58f6 100755 --- a/ginac/function.pl +++ b/ginac/function.pl @@ -1,135 +1,194 @@ -#!/usr/bin/perl -w - -$maxargs=10; +$maxargs=13; sub generate_seq { - my ($seq_template,$n)=@_; - my ($res,$N); - - $res=''; - for ($N=1; $N<=$n; $N++) { - $res .= eval('"' . $seq_template . '"'); - if ($N!=$n) { - $res .= ', '; - } - } - return $res; + my ($seq_template,$n)=@_; + my ($res,$N); + + $res=''; + for ($N=1; $N<=$n; $N++) { + $res .= eval('"' . $seq_template . '"'); + if ($N!=$n) { + $res .= ', '; + } + } + return $res; +} + +sub generate_from_to { + my ($template,$seq_template1,$seq_template2,$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); + $res .= eval('"' . $template . '"'); + $SEQ1=''; # to avoid main::SEQ1 used only once warning + $SEQ2=''; # same as above + } + return $res; } sub generate { - my ($template,$seq_template1,$seq_template2)=@_; - my ($res,$N,$SEQ); - - $res=''; - for ($N=1; $N<=$maxargs; $N++) { - $SEQ1=generate_seq($seq_template1,$N); - $SEQ2=generate_seq($seq_template2,$N); - $res .= eval('"' . $template . '"'); - $SEQ1=''; # to avoid main::SEQ1 used only once warning - $SEQ2=''; # same as above - } - return $res; -} - -$declare_function_macro_namespace=generate( - <<'END_OF_DECLARE_FUNCTION_MACRO_NAMESPACE','GiNaC::ex const & p${N}','p${N}'); + 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'; +#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_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}) { \\ - return GiNaC::function(function_index_##NAME, ${SEQ2}); \\ + return GiNaC::function(function_index_##NAME, ${SEQ2}); \\ } 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'; +#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); \ +} + +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 const unsigned function_index_##NAME; \\ inline function NAME(${SEQ1}) { \\ - return function(function_index_##NAME, ${SEQ2}); \\ + return function(function_index_##NAME, ${SEQ2}); \\ } 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 relational &, int, unsigned);'."\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) + : exprseq(${SEQ2}), serial(ser) { - debugmsg(\"function constructor from unsigned,${N}*ex\",LOGLEVEL_CONSTRUCT); - tinfo_key = TINFO_function; + debugmsg(\"function constructor from unsigned,${N}*ex\",LOGLEVEL_CONSTRUCT); + tinfo_key = TINFO_function; } END_OF_CONSTRUCTORS_IMPLEMENTATION $eval_switch_statement=generate( - <<'END_OF_EVAL_SWITCH_STATEMENT','eseq[${N}-1]',''); - case ${N}: - return ((eval_funcp_${N})(registered_functions()[serial].e))(${SEQ1}); - break; + <<'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]',''); - case ${N}: - return ((evalf_funcp_${N})(registered_functions()[serial].ef))(${SEQ1}); - break; + <<'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]',''); - case ${N}: - return ((diff_funcp_${N})(registered_functions()[serial].d))(${SEQ1},diff_param); - break; + <<'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]',''); - case ${N}: - try { - res = ((series_funcp_${N})(registered_functions()[serial].s))(${SEQ1},s,point,order); - } catch (do_taylor) { - res = basic::series(s, point, order); - } - return res; - break; + <<'END_OF_SERIES_SWITCH_STATEMENT','seq[${N}-1]',''); + case ${N}: + try { + res = ((series_funcp_${N})(registered_functions()[serial].series_f))(${SEQ1},r,order,options); + } catch (do_taylor) { + res = basic::series(r, order, options); + } + return res; 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=< #include -#ifdef __CINT__ // CINT needs to work properly with #include -#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_GINAC_NAMESPACE +#ifndef NO_NAMESPACE_GINAC -#define REGISTER_FUNCTION(NAME,E,EF,D,S) \\ -const unsigned function_index_##NAME=GiNaC::function::register_new(#NAME,E,EF,D,S); +#define REGISTER_FUNCTION(NAME,OPT) \\ +const unsigned function_index_##NAME= \\ + GiNaC::function::register_new(GiNaC::function_options(#NAME).OPT); -#else // ndef NO_GINAC_NAMESPACE +#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)); -#define REGISTER_FUNCTION(NAME,E,EF,D,S) \\ -const unsigned function_index_##NAME=function::register_new(#NAME,E,EF,D,S); +#else // ndef NO_NAMESPACE_GINAC -#endif // ndef NO_GINAC_NAMESPACE +#define REGISTER_FUNCTION(NAME,OPT) \\ +const unsigned function_index_##NAME= \\ + function::register_new(function_options(#NAME).OPT); + +#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_NAMESPACE_GINAC #define BEGIN_TYPECHECK \\ bool automatic_typecheck=true; #define TYPECHECK(VAR,TYPE) \\ if (!is_ex_exactly_of_type(VAR,TYPE)) { \\ - automatic_typecheck=false; \\ + 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; \\ + 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; \\ + automatic_typecheck=false; \\ } else -#endif // ndef NO_GINAC_NAMESPACE +#endif // ndef NO_NAMESPACE_GINAC #define END_TYPECHECK(RV) \\ {} \\ if (!automatic_typecheck) { \\ - return RV.hold(); \\ + 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; - unsigned nparams; - unsigned options; - eval_funcp e; - evalf_funcp ef; - diff_funcp d; - series_funcp s; +class function_options +{ + friend class function; +public: + function_options(); + function_options(std::string const & n, std::string const & tn=std::string()); + ~function_options(); + void initialize(void); + function_options & set_name(std::string const & n, std::string const & tn=std::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); + std::string get_name(void) const { return name; } + unsigned get_nparams(void) const { return nparams; } + +protected: + std::string name; + std::string TeX_name; + + unsigned nparams; + + 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 */ + and user defined functions */ class function : public exprseq { - GINAC_DECLARE_REGISTERED_CLASS(function, exprseq) + GINAC_DECLARE_REGISTERED_CLASS(function, exprseq) + + // CINT has a linking problem +#ifndef __MAKECINT__ + friend void ginsh_get_ginac_functions(void); +#endif // def __MAKECINT__ - // 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 + // default constructor, destructor, copy constructor assignment operator and helpers public: - function(); - ~function(); - function(function const & other); - function const & operator=(function const & other); + function(); + ~function(); + function(const function & other); + const function & operator=(const function & other); protected: - void copy(function const & other); - void destroy(bool call_parent); + void copy(const function & other); + void destroy(bool call_parent); - // other constructors + // other constructors public: - function(unsigned ser); - // the following lines have been generated for max. ${maxargs} parameters + function(unsigned ser); + // 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, exvector * vp); // vp will be deleted + // end of generated lines + 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 + // functions overriding virtual functions from bases classes public: - basic * duplicate() const; - void printraw(ostream & os) const; - void print(ostream & os, unsigned upper_precedence=0) const; - void printtree(ostream & os, unsigned indent) const; - void printcsrc(ostream & os, unsigned type, unsigned upper_precedence=0) const; - 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 thisexprseq(exvector * vp) const; + basic * duplicate() const; + void printraw(std::ostream & os) const; + void print(std::ostream & os, unsigned upper_precedence=0) const; + void printtree(std::ostream & os, unsigned indent) const; + void printcsrc(std::ostream & os, unsigned type, unsigned upper_precedence=0) const; + ex expand(unsigned options=0) const; + ex eval(int level=0) const; + ex evalf(int level=0) const; + ex series(const relational & r, int order, unsigned options = 0) 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; - unsigned return_type(void) const; - unsigned return_type_tinfo(void) const; - - // new virtual functions which can be overridden by derived classes - // none - - // non-virtual functions in this class + 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; + + // new virtual functions which can be overridden by derived classes + // none + + // 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 std::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 - unsigned getserial(void) const {return serial;} - + static unsigned register_new(function_options const & opt); + static unsigned find_function(const std::string &name, unsigned nparams); + unsigned getserial(void) const {return serial;} + // member variables protected: - unsigned serial; + unsigned serial; }; -// utility macros +// utility functions/macros +inline const function &ex_to_function(const ex &e) +{ + return static_cast(*e.bp); +} -#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) + (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) + (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 std::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__ @@ -362,7 +487,7 @@ $implementation=< #include +#include #include "function.h" #include "ex.h" +#include "lst.h" #include "archive.h" +#include "inifcns.h" #include "utils.h" #include "debugmsg.h" +#include "remember.h" -#ifndef NO_GINAC_NAMESPACE +#ifndef NO_NAMESPACE_GINAC namespace GiNaC { -#endif // ndef NO_GINAC_NAMESPACE +#endif // ndef NO_NAMESPACE_GINAC + +////////// +// helper class function_options +////////// + +function_options::function_options() +{ + initialize(); +} + +function_options::function_options(std::string const & n, std::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(std::string const & n, + std::string const & tn) +{ + name=n; + if (tn==std::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 + std::cerr << "WARNING: number of parameters (" + << n << ") differs from number set before (" + << nparams << ")" << std::endl; + } +} GINAC_IMPLEMENT_REGISTERED_CLASS(function, exprseq) @@ -402,43 +626,43 @@ GINAC_IMPLEMENT_REGISTERED_CLASS(function, exprseq) function::function() : serial(0) { - debugmsg("function default constructor",LOGLEVEL_CONSTRUCT); - tinfo_key = TINFO_function; + debugmsg("function default constructor",LOGLEVEL_CONSTRUCT); + tinfo_key = TINFO_function; } function::~function() { - debugmsg("function destructor",LOGLEVEL_DESTRUCT); - destroy(0); + debugmsg("function destructor",LOGLEVEL_DESTRUCT); + destroy(false); } -function::function(function const & other) +function::function(const function & other) { - debugmsg("function copy constructor",LOGLEVEL_CONSTRUCT); - copy(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) { - destroy(1); - copy(other); - } - return *this; + debugmsg("function operator=",LOGLEVEL_ASSIGNMENT); + if (this != &other) { + destroy(true); + copy(other); + } + return *this; } // protected -void function::copy(function const & other) +void function::copy(const function & other) { - exprseq::copy(other); - serial=other.serial; + exprseq::copy(other); + serial=other.serial; } void function::destroy(bool call_parent) { - if (call_parent) exprseq::destroy(call_parent); + if (call_parent) exprseq::destroy(call_parent); } ////////// @@ -449,32 +673,32 @@ void function::destroy(bool call_parent) function::function(unsigned ser) : serial(ser) { - debugmsg("function constructor from unsigned",LOGLEVEL_CONSTRUCT); - tinfo_key = TINFO_function; + debugmsg("function constructor from unsigned",LOGLEVEL_CONSTRUCT); + tinfo_key = TINFO_function; } // the following lines have been generated for max. ${maxargs} parameters $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; + debugmsg("function constructor from unsigned,exprseq",LOGLEVEL_CONSTRUCT); + tinfo_key = TINFO_function; } -function::function(unsigned ser, exvector const & v, bool discardable) - : exprseq(v,discardable), serial(ser) +function::function(unsigned ser, const exvector & v, bool discardable) + : exprseq(v,discardable), serial(ser) { - debugmsg("function constructor from string,exvector,bool",LOGLEVEL_CONSTRUCT); - tinfo_key = TINFO_function; + debugmsg("function constructor from string,exvector,bool",LOGLEVEL_CONSTRUCT); + tinfo_key = TINFO_function; } function::function(unsigned ser, exvector * vp) - : exprseq(vp), serial(ser) + : exprseq(vp), serial(ser) { - debugmsg("function constructor from unsigned,exvector *",LOGLEVEL_CONSTRUCT); - tinfo_key = TINFO_function; + debugmsg("function constructor from unsigned,exvector *",LOGLEVEL_CONSTRUCT); + tinfo_key = TINFO_function; } ////////// @@ -484,37 +708,37 @@ function::function(unsigned ser, exvector * vp) /** 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")); + debugmsg("function constructor from archive_node", LOGLEVEL_CONSTRUCT); + + // Find serial number by function name + std::string s; + if (n.find_string("name", s)) { + unsigned int ser = 0; + std::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); + 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); + inherited::archive(n); + GINAC_ASSERT(serial < registered_functions().size()); + n.add_string("name", registered_functions()[serial].name); } ////////// @@ -525,179 +749,238 @@ void function::archive(archive_node &n) const basic * function::duplicate() const { - debugmsg("function duplicate",LOGLEVEL_DUPLICATE); - return new function(*this); + debugmsg("function duplicate",LOGLEVEL_DUPLICATE); + return new function(*this); } -void function::printraw(ostream & os) const +void function::printraw(std::ostream & os) const { - debugmsg("function printraw",LOGLEVEL_PRINT); + debugmsg("function printraw",LOGLEVEL_PRINT); - GINAC_ASSERT(serialprint(os); - } - os << ")"; + os << "function(name=" << registered_functions()[serial].name; + for (exvector::const_iterator it=seq.begin(); it!=seq.end(); ++it) { + os << ","; + (*it).bp->print(os); + } + os << ")"; } -void function::print(ostream & os, unsigned upper_precedence) const +void function::print(std::ostream & os, unsigned upper_precedence) const { - debugmsg("function print",LOGLEVEL_PRINT); + debugmsg("function print",LOGLEVEL_PRINT); - GINAC_ASSERT(serialbp->printcsrc(os, type, 0); - it++; - if (it != itend) - os << ","; - } - os << ")"; + exvector::const_iterator it = seq.begin(); + exvector::const_iterator itend = seq.end(); + while (it != itend) { + it->bp->printcsrc(os, type, 0); + it++; + if (it != itend) + os << ","; + } + os << ")"; } ex function::expand(unsigned options) const { - return this->setflag(status_flags::expanded); + return this->setflag(status_flags::expanded); } ex function::eval(int level) const { - GINAC_ASSERT(serial1) { + // 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(); - } - switch (registered_functions()[serial].nparams) { - // the following lines have been generated for max. ${maxargs} parameters + 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 - } - throw(std::logic_error("function::eval(): invalid nparams")); + // end of generated lines + default: + 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 { - GINAC_ASSERT(serial(const_cast(other)); + GINAC_ASSERT(is_of_type(other, function)); + const function & o=static_cast(const_cast(other)); - if (serial!=o.serial) { - return serial < o.serial ? -1 : 1; - } - return exprseq::compare_same_type(o); + if (serial!=o.serial) { + return serial < o.serial ? -1 : 1; + } + 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)); + GINAC_ASSERT(is_of_type(other, function)); + const function & o=static_cast(const_cast(other)); - if (serial!=o.serial) return false; - return exprseq::is_equal_same_type(o); + if (serial!=o.serial) return false; + return exprseq::is_equal_same_type(o); } unsigned function::return_type(void) const { - if (seq.size()==0) { - return return_types::commutative; - } - return (*seq.begin()).return_type(); + if (seq.size()==0) { + return return_types::commutative; + } + return (*seq.begin()).return_type(); } unsigned function::return_type_tinfo(void) const { - if (seq.size()==0) { - return tinfo_key; - } - return (*seq.begin()).return_type_tinfo(); + if (seq.size()==0) { + return tinfo_key; + } + return (*seq.begin()).return_type_tinfo(); } ////////// @@ -712,32 +995,80 @@ 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) +{ + static std::vector * rf = new std::vector; + return *rf; +} + +bool function::lookup_remember_table(ex & result) const +{ + return remember_table::remember_tables()[serial].lookup_entry(*this,result); } -vector & function::registered_functions(void) +void function::store_remember_table(ex const & result) const { - static vector * rf=new vector; - return *rf; + remember_table::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 + std::cerr << "WARNING: function name " << opt.name + << " 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)); + } else { + remember_table::remember_tables().push_back(remember_table()); + } + return registered_functions().size()-1; +} + +/** Find serial number of function by name and number of parameters. + * Throws exception if function was not found. */ +unsigned function::find_function(const std::string &name, unsigned nparams) +{ + std::vector::const_iterator i = function::registered_functions().begin(), end = function::registered_functions().end(); + unsigned serial = 0; + while (i != end) { + if (i->get_name() == name && i->get_nparams() == nparams) + return serial; + i++; + serial++; + } + throw (std::runtime_error("no function '" + name + "' with " + ToString(nparams) + " parameters defined")); +} ////////// // static member variables @@ -750,11 +1081,11 @@ $register_new_implementation ////////// const function some_function; -type_info const & typeid_function=typeid(some_function); +const std::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