X-Git-Url: https://ginac.de/ginac.git//ginac.git?a=blobdiff_plain;f=ginac%2Ffunction.pl;h=f67c4b96231a0e315b7301fbb3ffb894dd34498e;hb=55d35dcf72dc411c8265628fcad2bd67d320a8c9;hp=f1b57f13db56419afbb78b6e9326c91fdd9e75dc;hpb=dbb36db8d02b2c25af6bbfff8135112637936e1f;p=ginac.git diff --git a/ginac/function.pl b/ginac/function.pl index f1b57f13..f67c4b96 100755 --- a/ginac/function.pl +++ b/ginac/function.pl @@ -1,6 +1,4 @@ -#!/usr/bin/perl -w - -$maxargs=10; +$maxargs=13; sub generate_seq { my ($seq_template,$n)=@_; @@ -16,12 +14,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 +29,27 @@ sub generate { return $res; } -$declare_function_macro_namespace=generate( - <<'END_OF_DECLARE_FUNCTION_MACRO_NAMESPACE','const GiNaC::ex & 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'; +#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}) { \\ @@ -41,8 +58,22 @@ inline GiNaC::function NAME(${SEQ1}) { \\ END_OF_DECLARE_FUNCTION_MACRO_NAMESPACE -$declare_function_macro_no_namespace=generate( - <<'END_OF_DECLARE_FUNCTION_MACRO_NO_NAMESPACE','const ex & 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}) { \\ @@ -59,23 +90,26 @@ $typedef_evalf_funcp=generate( 'typedef ex (* evalf_funcp_${N})(${SEQ1});'."\n", 'const ex &',''); -$typedef_diff_funcp=generate( -'typedef ex (* diff_funcp_${N})(${SEQ1}, unsigned);'."\n", +$typedef_derivative_funcp=generate( +'typedef ex (* derivative_funcp_${N})(${SEQ1}, unsigned);'."\n", 'const ex &',''); $typedef_series_funcp=generate( -'typedef ex (* series_funcp_${N})(${SEQ1}, const symbol &, const ex &, int);'."\n", +'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", 'const ex & param${N}',''); -$register_new_interface=generate( -' static unsigned register_new(const char * nm, eval_funcp_${N} e,'."\n". -' evalf_funcp_${N} ef=0, diff_funcp_${N} d=0, series_funcp_${N} s=0);'. -"\n",'',''); - $constructors_implementation=generate( <<'END_OF_CONSTRUCTORS_IMPLEMENTATION','const ex & param${N}','param${N}'); function::function(unsigned ser, ${SEQ1}) @@ -87,23 +121,23 @@ 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 @@ -111,25 +145,53 @@ $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); + res = ((series_funcp_${N})(registered_functions()[serial].series_f))(${SEQ1},r,order,options); } catch (do_taylor) { - res = basic::series(s, point, order); + res = basic::series(r, order, options); } return res; break; END_OF_SERIES_SWITCH_STATEMENT -$register_new_implementation=generate( - <<'END_OF_REGISTER_NEW_IMPLEMENTATION','',''); -unsigned function::register_new(const char * 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 "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; @@ -205,21 +283,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) \\ {} \\ @@ -227,32 +305,71 @@ 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 { - const char * name; +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; - 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... @@ -262,7 +379,13 @@ class function : public exprseq GINAC_DECLARE_REGISTERED_CLASS(function, exprseq) // CINT has a linking problem +#ifndef __MAKECINT__ friend void ginsh_get_ginac_functions(void); +#endif // def __MAKECINT__ + + friend class remember_table_entry; + // friend class remember_table_list; + // friend class remember_table; // member functions @@ -289,18 +412,18 @@ $constructors_interface // 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; + 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 diff(const symbol & s) const; - ex series(const symbol & s, const ex & point, int order) const; + ex series(const relational & r, int order, unsigned options = 0) const; ex thisexprseq(const exvector & v) const; ex thisexprseq(exvector * vp) const; protected: + 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; @@ -311,12 +434,13 @@ 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 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 + 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 @@ -325,28 +449,32 @@ protected: 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) -#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 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__ @@ -381,16 +509,115 @@ $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) @@ -487,10 +714,10 @@ function::function(const archive_node &n, const lst &sym_lst) : inherited(n, sym debugmsg("function constructor from archive_node", LOGLEVEL_CONSTRUCT); // Find serial number by function name - string s; + std::string s; if (n.find_string("name", s)) { unsigned int ser = 0; - vector::const_iterator i = registered_functions().begin(), iend = registered_functions().end(); + std::vector::const_iterator i = registered_functions().begin(), iend = registered_functions().end(); while (i != iend) { if (s == i->name) { serial = ser; @@ -529,7 +756,7 @@ basic * function::duplicate() const return new function(*this); } -void function::printraw(ostream & os) const +void function::printraw(std::ostream & os) const { debugmsg("function printraw",LOGLEVEL_PRINT); @@ -543,7 +770,7 @@ void function::printraw(ostream & os) const 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); @@ -553,31 +780,32 @@ void function::print(ostream & os, unsigned upper_precedence) const printseq(os,'(',',',')',exprseq::precedence,function::precedence); } -void function::printtree(ostream & os, unsigned indent) const +void function::printtree(std::ostream & os, unsigned indent) const { debugmsg("function printtree",LOGLEVEL_PRINT); 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(); + 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")); + } + if (use_remember) { + store_remember_table(eval_result); } - throw(std::logic_error("function::eval(): invalid nparams")); + return eval_result; } ex function::evalf(int level) const @@ -623,7 +866,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) { @@ -646,12 +889,12 @@ ex function::thisexprseq(exvector * vp) const /** Implementation of ex::series for functions. * \@see ex::series */ -ex function::series(const symbol & s, const ex & point, int order) const +ex function::series(const relational & r, int order, unsigned options = 0) const { GINAC_ASSERT(serial & function::registered_functions(void) +std::vector & function::registered_functions(void) { - static vector * rf=new vector; + 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); +} + +void function::store_remember_table(ex const & result) const +{ + 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 @@ -752,9 +1086,9 @@ $register_new_implementation const function 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