X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?a=blobdiff_plain;f=ginac%2Ffunction.pl;h=3ac3c3cab9e23549b35696f951dd3e307d0df278;hb=22bf8270163ec9ec11f37c79957e18d6e6e163cd;hp=312640fe7c31d8b89b95fb47bb763148273acc8e;hpb=0e474355d56a912573dc29bcaee4a1180171b066;p=ginac.git

diff --git a/ginac/function.pl b/ginac/function.pl
old mode 100755
new mode 100644
index 312640fe..3ac3c3ca
--- a/ginac/function.pl
+++ b/ginac/function.pl
@@ -2,7 +2,7 @@
 
 #  function.pl options: \$maxargs=${maxargs}
 # 
-#  GiNaC Copyright (C) 1999-2004 Johannes Gutenberg University Mainz, Germany
+#  GiNaC Copyright (C) 1999-2008 Johannes Gutenberg University Mainz, Germany
 # 
 #  This program is free software; you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
@@ -16,7 +16,7 @@
 # 
 #  You should have received a copy of the GNU General Public License
 #  along with this program; if not, write to the Free Software
-#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 $maxargs=14;
 
@@ -60,6 +60,7 @@ $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) \\
 class NAME##_SERIAL { public: static unsigned serial; }; \\
+const unsigned NAME##_NPARAMS = ${N}; \\
 template<${SEQ1}> const GiNaC::function NAME(${SEQ2}) { \\
 	return GiNaC::function(NAME##_SERIAL::serial, ${SEQ3}); \\
 }
@@ -78,10 +79,22 @@ $typedef_conjugate_funcp=generate(
 'typedef ex (* conjugate_funcp_${N})(${SEQ1});'."\n",
 'const ex &','','');
 
+$typedef_real_part_funcp=generate(
+'typedef ex (* real_part_funcp_${N})(${SEQ1});'."\n",
+'const ex &','','');
+
+$typedef_imag_part_funcp=generate(
+'typedef ex (* imag_part_funcp_${N})(${SEQ1});'."\n",
+'const ex &','','');
+
 $typedef_derivative_funcp=generate(
 'typedef ex (* derivative_funcp_${N})(${SEQ1}, unsigned);'."\n",
 'const ex &','','');
 
+$typedef_power_funcp=generate(
+'typedef ex (* power_funcp_${N})(${SEQ1}, const ex &);'."\n",
+'const ex &','','');
+
 $typedef_series_funcp=generate(
 'typedef ex (* series_funcp_${N})(${SEQ1}, const relational &, int, unsigned);'."\n",
 'const ex &','','');
@@ -96,8 +109,14 @@ $evalf_func_interface=generate('    function_options & evalf_func(evalf_funcp_${
 
 $conjugate_func_interface=generate('    function_options & conjugate_func(conjugate_funcp_${N} d);'."\n",'','','');
 
+$real_part_func_interface=generate('    function_options & real_part_func(real_part_funcp_${N} d);'."\n",'','','');
+
+$imag_part_func_interface=generate('    function_options & imag_part_func(imag_part_funcp_${N} d);'."\n",'','','');
+
 $derivative_func_interface=generate('    function_options & derivative_func(derivative_funcp_${N} d);'."\n",'','','');
 
+$power_func_interface=generate('    function_options & power_func(power_funcp_${N} d);'."\n",'','','');
+
 $series_func_interface=generate('    function_options & series_func(series_funcp_${N} s);'."\n",'','','');
 
 $print_func_interface=generate(
@@ -119,7 +138,6 @@ $constructors_implementation=generate(
 function::function(unsigned ser, ${SEQ1})
 	: exprseq(${SEQ2}), serial(ser)
 {
-	tinfo_key = TINFO_function;
 }
 END_OF_CONSTRUCTORS_IMPLEMENTATION
 
@@ -142,12 +160,30 @@ $conjugate_switch_statement=generate(
 		return ((conjugate_funcp_${N})(opt.conjugate_f))(${SEQ1});
 END_OF_DIFF_SWITCH_STATEMENT
 
+$real_part_switch_statement=generate(
+	<<'END_OF_DIFF_SWITCH_STATEMENT','seq[${N}-1]','','');
+	case ${N}:
+		return ((real_part_funcp_${N})(opt.real_part_f))(${SEQ1});
+END_OF_DIFF_SWITCH_STATEMENT
+
+$imag_part_switch_statement=generate(
+	<<'END_OF_DIFF_SWITCH_STATEMENT','seq[${N}-1]','','');
+	case ${N}:
+		return ((imag_part_funcp_${N})(opt.imag_part_f))(${SEQ1});
+END_OF_DIFF_SWITCH_STATEMENT
+
 $diff_switch_statement=generate(
 	<<'END_OF_DIFF_SWITCH_STATEMENT','seq[${N}-1]','','');
 	case ${N}:
 		return ((derivative_funcp_${N})(opt.derivative_f))(${SEQ1},diff_param);
 END_OF_DIFF_SWITCH_STATEMENT
 
+$power_switch_statement=generate(
+	<<'END_OF_POWER_SWITCH_STATEMENT','seq[${N}-1]','','');
+	case ${N}:
+		return ((power_funcp_${N})(opt.power_f))(${SEQ1},power_param);
+END_OF_POWER_SWITCH_STATEMENT
+
 $series_switch_statement=generate(
 	<<'END_OF_SERIES_SWITCH_STATEMENT','seq[${N}-1]','','');
 	case ${N}:
@@ -196,6 +232,26 @@ function_options & function_options::conjugate_func(conjugate_funcp_${N} c)
 }
 END_OF_CONJUGATE_FUNC_IMPLEMENTATION
 
+$real_part_func_implementation=generate(
+	<<'END_OF_REAL_PART_FUNC_IMPLEMENTATION','','','');
+function_options & function_options::real_part_func(real_part_funcp_${N} c)
+{
+	test_and_set_nparams(${N});
+	real_part_f = real_part_funcp(c);
+	return *this;
+}
+END_OF_REAL_PART_FUNC_IMPLEMENTATION
+
+$imag_part_func_implementation=generate(
+	<<'END_OF_IMAG_PART_FUNC_IMPLEMENTATION','','','');
+function_options & function_options::imag_part_func(imag_part_funcp_${N} c)
+{
+	test_and_set_nparams(${N});
+	imag_part_f = imag_part_funcp(c);
+	return *this;
+}
+END_OF_IMAG_PART_FUNC_IMPLEMENTATION
+
 $derivative_func_implementation=generate(
 	<<'END_OF_DERIVATIVE_FUNC_IMPLEMENTATION','','','');
 function_options & function_options::derivative_func(derivative_funcp_${N} d)
@@ -206,6 +262,16 @@ function_options & function_options::derivative_func(derivative_funcp_${N} d)
 }
 END_OF_DERIVATIVE_FUNC_IMPLEMENTATION
 
+$power_func_implementation=generate(
+	<<'END_OF_POWER_FUNC_IMPLEMENTATION','','','');
+function_options & function_options::power_func(power_funcp_${N} d)
+{
+	test_and_set_nparams(${N});
+	power_f = power_funcp(d);
+	return *this;
+}
+END_OF_POWER_FUNC_IMPLEMENTATION
+
 $series_func_implementation=generate(
 	<<'END_OF_SERIES_FUNC_IMPLEMENTATION','','','');
 function_options & function_options::series_func(series_funcp_${N} s)
@@ -226,7 +292,7 @@ $interface=<<END_OF_INTERFACE;
  *  Please do not modify it directly, edit the perl script instead!
  *  function.pl options: \$maxargs=${maxargs}
  *
- *  GiNaC Copyright (C) 1999-2004 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2008 Johannes Gutenberg University Mainz, Germany
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -240,7 +306,7 @@ $interface=<<END_OF_INTERFACE;
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
 #ifndef __GINAC_FUNCTION_H__
@@ -260,7 +326,7 @@ $declare_function_macro
 
 #define REGISTER_FUNCTION(NAME,OPT) \\
 unsigned NAME##_SERIAL::serial = \\
-	GiNaC::function::register_new(GiNaC::function_options(#NAME).OPT);
+	GiNaC::function::register_new(GiNaC::function_options(#NAME, NAME##_NPARAMS).OPT);
 
 namespace GiNaC {
 
@@ -270,7 +336,10 @@ class symmetry;
 typedef ex (* eval_funcp)();
 typedef ex (* evalf_funcp)();
 typedef ex (* conjugate_funcp)();
+typedef ex (* real_part_funcp)();
+typedef ex (* imag_part_funcp)();
 typedef ex (* derivative_funcp)();
+typedef ex (* power_funcp)();
 typedef ex (* series_funcp)();
 typedef void (* print_funcp)();
 
@@ -278,7 +347,10 @@ typedef void (* print_funcp)();
 $typedef_eval_funcp
 $typedef_evalf_funcp
 $typedef_conjugate_funcp
+$typedef_real_part_funcp
+$typedef_imag_part_funcp
 $typedef_derivative_funcp
+$typedef_power_funcp
 $typedef_series_funcp
 $typedef_print_funcp
 // end of generated lines
@@ -288,7 +360,10 @@ $typedef_print_funcp
 typedef ex (* eval_funcp_exvector)(const exvector &);
 typedef ex (* evalf_funcp_exvector)(const exvector &);
 typedef ex (* conjugate_funcp_exvector)(const exvector &);
+typedef ex (* real_part_funcp_exvector)(const exvector &);
+typedef ex (* imag_part_funcp_exvector)(const exvector &);
 typedef ex (* derivative_funcp_exvector)(const exvector &, unsigned);
+typedef ex (* power_funcp_exvector)(const exvector &, const ex &);
 typedef ex (* series_funcp_exvector)(const exvector &, const relational &, int, unsigned);
 typedef void (* print_funcp_exvector)(const exvector &, const print_context &);
 
@@ -300,6 +375,7 @@ class function_options
 public:
 	function_options();
 	function_options(std::string const & n, std::string const & tn=std::string());
+	function_options(std::string const & n, unsigned np);
 	~function_options();
 	void initialize();
 
@@ -310,14 +386,20 @@ public:
 $eval_func_interface
 $evalf_func_interface
 $conjugate_func_interface
+$real_part_func_interface
+$imag_part_func_interface
 $derivative_func_interface
+$power_func_interface
 $series_func_interface
 $print_func_interface
 // end of generated lines
 	function_options & eval_func(eval_funcp_exvector e);
 	function_options & evalf_func(evalf_funcp_exvector ef);
 	function_options & conjugate_func(conjugate_funcp_exvector d);
+	function_options & real_part_func(real_part_funcp_exvector d);
+	function_options & imag_part_func(imag_part_funcp_exvector d);
 	function_options & derivative_func(derivative_funcp_exvector d);
+	function_options & power_func(power_funcp_exvector d);
 	function_options & series_func(series_funcp_exvector s);
 
 	template <class Ctx> function_options & print_func(print_funcp_exvector p)
@@ -327,7 +409,7 @@ $print_func_interface
 		return *this;
 	}
 
-	function_options & set_return_type(unsigned rt, unsigned rtt=0);
+	function_options & set_return_type(unsigned rt, const return_type_t* rtt = 0);
 	function_options & do_not_evalf_params();
 	function_options & remember(unsigned size, unsigned assoc_size=0,
 	                            unsigned strategy=remember_strategies::delete_never);
@@ -339,6 +421,7 @@ $print_func_interface
 
 protected:
 	bool has_derivative() const { return derivative_f != NULL; }
+	bool has_power() const { return power_f != NULL; }
 	void test_and_set_nparams(unsigned n);
 	void set_print_func(unsigned id, print_funcp f);
 
@@ -350,7 +433,10 @@ protected:
 	eval_funcp eval_f;
 	evalf_funcp evalf_f;
 	conjugate_funcp conjugate_f;
+	real_part_funcp real_part_f;
+	imag_part_funcp imag_part_f;
 	derivative_funcp derivative_f;
+	power_funcp power_f;
 	series_funcp series_f;
 	std::vector<print_funcp> print_dispatch_table;
 
@@ -358,7 +444,7 @@ protected:
 
 	bool use_return_type;
 	unsigned return_type;
-	unsigned return_type_tinfo;
+	return_type_t return_type_tinfo;
 
 	bool use_remember;
 	unsigned remember_size;
@@ -368,7 +454,10 @@ protected:
 	bool eval_use_exvector_args;
 	bool evalf_use_exvector_args;
 	bool conjugate_use_exvector_args;
+	bool real_part_use_exvector_args;
+	bool imag_part_use_exvector_args;
 	bool derivative_use_exvector_args;
+	bool power_use_exvector_args;
 	bool series_use_exvector_args;
 	bool print_use_exvector_args;
 
@@ -417,17 +506,22 @@ public:
 	ex expand(unsigned options=0) const;
 	ex eval(int level=0) const;
 	ex evalf(int level=0) const;
+	ex eval_ncmul(const exvector & v) const;
 	unsigned calchash() const;
 	ex series(const relational & r, int order, unsigned options = 0) const;
 	ex thiscontainer(const exvector & v) const;
 	ex thiscontainer(std::auto_ptr<exvector> vp) const;
 	ex conjugate() const;
+	ex real_part() const;
+	ex imag_part() const;
+	void archive(archive_node& n) const;
+	void read_archive(const archive_node& n, lst& syms);
 protected:
 	ex derivative(const symbol & s) const;
 	bool is_equal_same_type(const basic & other) const;
 	bool match_same_type(const basic & other) const;
 	unsigned return_type() const;
-	unsigned return_type_tinfo() const;
+	return_type_t return_type_tinfo() const;
 	
 	// new virtual functions which can be overridden by derived classes
 	// none
@@ -439,6 +533,7 @@ protected:
 	bool lookup_remember_table(ex & result) const;
 	void store_remember_table(ex const & result) const;
 public:
+	ex power(const ex & exp) const;
 	static unsigned register_new(function_options const & opt);
 	static unsigned current_serial;
 	static unsigned find_function(const std::string &name, unsigned nparams);
@@ -450,15 +545,10 @@ public:
 protected:
 	unsigned serial;
 };
+GINAC_DECLARE_UNARCHIVER(function);
 
 // utility functions/macros
 
-/** Specialization of is_exactly_a<function>(obj) for objects of type function. */
-template<> inline bool is_exactly_a<function>(const basic & obj)
-{
-	return obj.tinfo()==TINFO_function;
-}
-
 template <typename T>
 inline bool is_the_function(const ex & x)
 {
@@ -485,7 +575,7 @@ $implementation=<<END_OF_IMPLEMENTATION;
  *  Please do not modify it directly, edit the perl script instead!
  *  function.pl options: \$maxargs=${maxargs}
  *
- *  GiNaC Copyright (C) 1999-2004 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2008 Johannes Gutenberg University Mainz, Germany
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -499,13 +589,14 @@ $implementation=<<END_OF_IMPLEMENTATION;
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
 #include <iostream>
 #include <string>
 #include <stdexcept>
 #include <list>
+#include <limits>
 
 #include "function.h"
 #include "operators.h"
@@ -514,6 +605,7 @@ $implementation=<<END_OF_IMPLEMENTATION;
 #include "lst.h"
 #include "symmetry.h"
 #include "print.h"
+#include "power.h"
 #include "archive.h"
 #include "inifcns.h"
 #include "tostring.h"
@@ -537,6 +629,13 @@ function_options::function_options(std::string const & n, std::string const & tn
 	set_name(n, tn);
 }
 
+function_options::function_options(std::string const & n, unsigned np)
+{
+	initialize();
+	set_name(n, std::string());
+	nparams = np;
+}
+
 function_options::~function_options()
 {
 	// nothing to clean up at the moment
@@ -546,17 +645,22 @@ void function_options::initialize()
 {
 	set_name("unnamed_function", "\\\\mbox{unnamed}");
 	nparams = 0;
-	eval_f = evalf_f = conjugate_f = derivative_f = series_f = 0;
+	eval_f = evalf_f = real_part_f = imag_part_f = conjugate_f = derivative_f
+		= power_f = series_f = 0;
 	evalf_params_first = true;
 	use_return_type = false;
 	eval_use_exvector_args = false;
 	evalf_use_exvector_args = false;
 	conjugate_use_exvector_args = false;
+	real_part_use_exvector_args = false;
+	imag_part_use_exvector_args = false;
 	derivative_use_exvector_args = false;
+	power_use_exvector_args = false;
 	series_use_exvector_args = false;
 	print_use_exvector_args = false;
 	use_remember = false;
 	functions_with_same_name = 1;
+	symtree = 0;
 }
 
 function_options & function_options::set_name(std::string const & n,
@@ -580,7 +684,10 @@ function_options & function_options::latex_name(std::string const & tn)
 $eval_func_implementation
 $evalf_func_implementation
 $conjugate_func_implementation
+$real_part_func_implementation
+$imag_part_func_implementation
 $derivative_func_implementation
+$power_func_implementation
 $series_func_implementation
 // end of generated lines
 
@@ -602,12 +709,31 @@ function_options& function_options::conjugate_func(conjugate_funcp_exvector c)
 	conjugate_f = conjugate_funcp(c);
 	return *this;
 }
+function_options& function_options::real_part_func(real_part_funcp_exvector c)
+{
+	real_part_use_exvector_args = true;
+	real_part_f = real_part_funcp(c);
+	return *this;
+}
+function_options& function_options::imag_part_func(imag_part_funcp_exvector c)
+{
+	imag_part_use_exvector_args = true;
+	imag_part_f = imag_part_funcp(c);
+	return *this;
+}
+
 function_options& function_options::derivative_func(derivative_funcp_exvector d)
 {
 	derivative_use_exvector_args = true;
 	derivative_f = derivative_funcp(d);
 	return *this;
 }
+function_options& function_options::power_func(power_funcp_exvector d)
+{
+	power_use_exvector_args = true;
+	power_f = power_funcp(d);
+	return *this;
+}
 function_options& function_options::series_func(series_funcp_exvector s)
 {
 	series_use_exvector_args = true;
@@ -615,11 +741,14 @@ function_options& function_options::series_func(series_funcp_exvector s)
 	return *this;
 }
 
-function_options & function_options::set_return_type(unsigned rt, unsigned rtt)
+function_options & function_options::set_return_type(unsigned rt, const return_type_t* rtt)
 {
 	use_return_type = true;
 	return_type = rt;
-	return_type_tinfo = rtt;
+	if (rtt != 0)
+		return_type_tinfo = *rtt;
+	else
+		return_type_tinfo = make_return_type_t<function>();
 	return *this;
 }
 
@@ -687,7 +816,6 @@ GINAC_IMPLEMENT_REGISTERED_CLASS(function, exprseq)
 
 function::function() : serial(0)
 {
-	tinfo_key = TINFO_function;
 }
 
 //////////
@@ -698,7 +826,6 @@ function::function() : serial(0)
 
 function::function(unsigned ser) : serial(ser)
 {
-	tinfo_key = TINFO_function;
 }
 
 // the following lines have been generated for max. ${maxargs} parameters
@@ -707,7 +834,6 @@ $constructors_implementation
 
 function::function(unsigned ser, const exprseq & es) : exprseq(es), serial(ser)
 {
-	tinfo_key = TINFO_function;
 
 	// Force re-evaluation even if the exprseq was already evaluated
 	// (the exprseq copy constructor copies the flags)
@@ -717,13 +843,11 @@ function::function(unsigned ser, const exprseq & es) : exprseq(es), serial(ser)
 function::function(unsigned ser, const exvector & v, bool discardable) 
   : exprseq(v,discardable), serial(ser)
 {
-	tinfo_key = TINFO_function;
 }
 
 function::function(unsigned ser, std::auto_ptr<exvector> vp) 
   : exprseq(vp), serial(ser)
 {
-	tinfo_key = TINFO_function;
 }
 
 //////////
@@ -731,8 +855,9 @@ function::function(unsigned ser, std::auto_ptr<exvector> vp)
 //////////
 
 /** Construct object from archive_node. */
-function::function(const archive_node &n, lst &sym_lst) : inherited(n, sym_lst)
+void function::read_archive(const archive_node& n, lst& sym_lst)
 {
+	inherited::read_archive(n, sym_lst);
 	// Find serial number by function name
 	std::string s;
 	if (n.find_string("name", s)) {
@@ -750,12 +875,6 @@ function::function(const archive_node &n, lst &sym_lst) : inherited(n, sym_lst)
 		throw (std::runtime_error("unnamed function in archive"));
 }
 
-/** Unarchive the object. */
-ex function::unarchive(const archive_node &n, lst &sym_lst)
-{
-	return (new function(n, sym_lst))->setflag(status_flags::dynallocated);
-}
-
 /** Archive the object. */
 void function::archive(archive_node &n) const
 {
@@ -764,6 +883,8 @@ void function::archive(archive_node &n) const
 	n.add_string("name", registered_functions()[serial].name);
 }
 
+GINAC_BIND_UNARCHIVER(function);
+
 //////////
 // functions overriding virtual functions from base classes
 //////////
@@ -861,7 +982,7 @@ ex function::eval(int level) const
 		exvector v = seq;
 		GINAC_ASSERT(is_a<symmetry>(opt.symtree));
 		int sig = canonicalize(v.begin(), ex_to<symmetry>(opt.symtree));
-		if (sig != INT_MAX) {
+		if (sig != std::numeric_limits<int>::max()) {
 			// Something has changed while sorting arguments, more evaluations later
 			if (sig == 0)
 				return _ex0;
@@ -930,9 +1051,20 @@ ${evalf_switch_statement}
 	throw(std::logic_error("function::evalf(): invalid nparams"));
 }
 
+/**
+ *  This method is defined to be in line with behaviour of function::return_type()
+ */
+ex function::eval_ncmul(const exvector & v) const
+{
+	// If this function is called then the list of arguments is non-empty
+	// and the first argument is non-commutative, see  function::return_type()
+	return seq.begin()->eval_ncmul(v);
+}
+
 unsigned function::calchash() const
 {
-	unsigned v = golden_ratio_hash(golden_ratio_hash(tinfo()) ^ serial);
+	const void* this_tinfo = (const void*)typeid(*this).name();
+	unsigned v = golden_ratio_hash(golden_ratio_hash((p_int)this_tinfo) ^ serial);
 	for (size_t i=0; i<nops(); i++) {
 		v = rotate_left(v);
 		v ^= this->op(i).gethash();
@@ -1005,6 +1137,46 @@ ${conjugate_switch_statement}
 	throw(std::logic_error("function::conjugate(): invalid nparams"));
 }
 
+/** Implementation of ex::real_part for functions. */
+ex function::real_part() const
+{
+	GINAC_ASSERT(serial<registered_functions().size());
+	const function_options & opt = registered_functions()[serial];
+
+	if (opt.real_part_f==0)
+		return basic::real_part();
+
+	if (opt.real_part_use_exvector_args)
+		return ((real_part_funcp_exvector)(opt.real_part_f))(seq);
+
+	switch (opt.nparams) {
+		// the following lines have been generated for max. ${maxargs} parameters
+${real_part_switch_statement}
+		// end of generated lines
+	}
+	throw(std::logic_error("function::real_part(): invalid nparams"));
+}
+
+/** Implementation of ex::imag_part for functions. */
+ex function::imag_part() const
+{
+	GINAC_ASSERT(serial<registered_functions().size());
+	const function_options & opt = registered_functions()[serial];
+
+	if (opt.imag_part_f==0)
+		return basic::imag_part();
+
+	if (opt.imag_part_use_exvector_args)
+		return ((imag_part_funcp_exvector)(opt.imag_part_f))(seq);
+
+	switch (opt.nparams) {
+		// the following lines have been generated for max. ${maxargs} parameters
+${imag_part_switch_statement}
+		// end of generated lines
+	}
+	throw(std::logic_error("function::imag_part(): invalid nparams"));
+}
+
 // protected
 
 /** Implementation of ex::diff() for functions. It applies the chain rule,
@@ -1083,7 +1255,7 @@ unsigned function::return_type() const
 	}
 }
 
-unsigned function::return_type_tinfo() const
+return_type_t function::return_type_tinfo() const
 {
 	GINAC_ASSERT(serial<registered_functions().size());
 	const function_options &opt = registered_functions()[serial];
@@ -1095,7 +1267,7 @@ unsigned function::return_type_tinfo() const
 		// Default behavior is to use the return type of the first
 		// argument. Thus, exp() of a matrix behaves like a matrix, etc.
 		if (seq.empty())
-			return tinfo_key;
+			return make_return_type_t<function>();
 		else
 			return seq.begin()->return_type_tinfo();
 	}
@@ -1133,10 +1305,31 @@ ${diff_switch_statement}
 	throw(std::logic_error("function::pderivative(): no diff function defined"));
 }
 
+ex function::power(const ex & power_param) const // power of function
+{
+	GINAC_ASSERT(serial<registered_functions().size());
+	const function_options &opt = registered_functions()[serial];
+	
+	// No derivative defined? Then return abstract derivative object
+	if (opt.power_f == NULL)
+		return (new power::power(*this, power_param))->setflag(status_flags::dynallocated |
+	                                               status_flags::evaluated);
+
+	current_serial = serial;
+	if (opt.power_use_exvector_args)
+		return ((power_funcp_exvector)(opt.power_f))(seq,  power_param);
+	switch (opt.nparams) {
+		// the following lines have been generated for max. ${maxargs} parameters
+${power_switch_statement}
+		// end of generated lines
+	}
+	throw(std::logic_error("function::power(): no power function defined"));
+}
+
 std::vector<function_options> & function::registered_functions()
 {
-	static std::vector<function_options> * rf = new std::vector<function_options>;
-	return *rf;
+	static std::vector<function_options> rf = std::vector<function_options>();
+	return rf;
 }
 
 bool function::lookup_remember_table(ex & result) const