X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Ffunction.pl;h=d4a03cec8289f94e09177eebb056ef5ef903cdc2;hp=1f944f1a4f9c74a07dc13bb815c34f1dec61a65f;hb=f320e27e9cfe287168c879af5991babffaa1e9c8;hpb=6d7bf9ee5a7ce05cb3a23dae664e781d7325d7b8

diff --git a/ginac/function.pl b/ginac/function.pl
old mode 100755
new mode 100644
index 1f944f1a..d4a03cec
--- a/ginac/function.pl
+++ b/ginac/function.pl
@@ -1,4 +1,24 @@
-$maxargs=13;
+#  This perl script automatically generates function.h and function.cpp
+
+#  function.pl options: \$maxargs=${maxargs}
+# 
+#  GiNaC Copyright (C) 1999-2011 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
+#  the Free Software Foundation; either version 2 of the License, or
+#  (at your option) any later version.
+# 
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+# 
+#  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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+$maxargs=14;
 
 sub generate_seq {
 	my ($seq_template,$n)=@_;
@@ -40,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}); \\
 }
@@ -54,10 +75,26 @@ $typedef_evalf_funcp=generate(
 'typedef ex (* evalf_funcp_${N})(${SEQ1});'."\n",
 'const ex &','','');
 
+$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 &','','');
@@ -70,8 +107,16 @@ $eval_func_interface=generate('    function_options & eval_func(eval_funcp_${N}
 
 $evalf_func_interface=generate('    function_options & evalf_func(evalf_funcp_${N} ef);'."\n",'','','');
 
+$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(
@@ -93,7 +138,6 @@ $constructors_implementation=generate(
 function::function(unsigned ser, ${SEQ1})
 	: exprseq(${SEQ2}), serial(ser)
 {
-	tinfo_key = TINFO_function;
 }
 END_OF_CONSTRUCTORS_IMPLEMENTATION
 
@@ -110,12 +154,36 @@ $evalf_switch_statement=generate(
 		return ((evalf_funcp_${N})(opt.evalf_f))(${SEQ1});
 END_OF_EVALF_SWITCH_STATEMENT
 
+$conjugate_switch_statement=generate(
+	<<'END_OF_DIFF_SWITCH_STATEMENT','seq[${N}-1]','','');
+	case ${N}:
+		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}:
@@ -154,6 +222,36 @@ function_options & function_options::evalf_func(evalf_funcp_${N} ef)
 }
 END_OF_EVALF_FUNC_IMPLEMENTATION
 
+$conjugate_func_implementation=generate(
+	<<'END_OF_CONJUGATE_FUNC_IMPLEMENTATION','','','');
+function_options & function_options::conjugate_func(conjugate_funcp_${N} c)
+{
+	test_and_set_nparams(${N});
+	conjugate_f = conjugate_funcp(c);
+	return *this;
+}
+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)
@@ -164,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)
@@ -184,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-2003 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2011 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
@@ -198,19 +306,18 @@ $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__
-#define __GINAC_FUNCTION_H__
+#ifndef GINAC_FUNCTION_H
+#define GINAC_FUNCTION_H
 
-#include <string>
-#include <vector>
+#include "exprseq.h"
 
 // CINT needs <algorithm> to work properly with <vector>
 #include <algorithm>
-
-#include "exprseq.h"
+#include <string>
+#include <vector>
 
 // the following lines have been generated for max. ${maxargs} parameters
 $declare_function_macro
@@ -218,7 +325,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 {
 
@@ -227,14 +334,22 @@ 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)();
 
 // the following lines have been generated for max. ${maxargs} parameters
 $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
@@ -243,7 +358,11 @@ $typedef_print_funcp
 // of individual ex objects.  Then, the number of arguments is not limited.
 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 &);
 
@@ -255,20 +374,31 @@ 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();
+
+	function_options & dummy() { return *this; }
 	function_options & set_name(std::string const & n, std::string const & tn=std::string());
 	function_options & latex_name(std::string const & tn);
 // the following lines have been generated for max. ${maxargs} parameters
 $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)
@@ -278,7 +408,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);
@@ -290,6 +420,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);
 
@@ -300,7 +431,11 @@ 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;
 
@@ -308,7 +443,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;
@@ -317,7 +452,11 @@ 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;
 
@@ -366,16 +505,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
@@ -387,6 +532,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);
@@ -398,15 +544,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)
 {
@@ -419,7 +560,7 @@ inline bool is_the_function(const ex & x)
 
 } // namespace GiNaC
 
-#endif // ndef __GINAC_FUNCTION_H__
+#endif // ndef GINAC_FUNCTION_H
 
 END_OF_INTERFACE
 
@@ -433,7 +574,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-2003 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2011 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
@@ -447,14 +588,9 @@ $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 "function.h"
 #include "operators.h"
 #include "fderivative.h"
@@ -462,12 +598,20 @@ $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"
 #include "utils.h"
+#include "hash_seed.h"
 #include "remember.h"
 
+#include <iostream>
+#include <limits>
+#include <list>
+#include <stdexcept>
+#include <string>
+
 namespace GiNaC {
 
 //////////
@@ -482,7 +626,14 @@ function_options::function_options()
 function_options::function_options(std::string const & n, std::string const & tn)
 {
 	initialize();
-	set_name(n,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()
@@ -492,14 +643,19 @@ function_options::~function_options()
 
 void function_options::initialize()
 {
-	set_name("unnamed_function","\\\\mbox{unnamed}");
+	set_name("unnamed_function", "\\\\mbox{unnamed}");
 	nparams = 0;
-	eval_f = evalf_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;
@@ -527,7 +683,11 @@ function_options & function_options::latex_name(std::string const & tn)
 // the following lines have been generated for max. ${maxargs} parameters
 $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
 
@@ -543,12 +703,37 @@ function_options& function_options::evalf_func(evalf_funcp_exvector ef)
 	evalf_f = evalf_funcp(ef);
 	return *this;
 }
+function_options& function_options::conjugate_func(conjugate_funcp_exvector c)
+{
+	conjugate_use_exvector_args = true;
+	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;
@@ -556,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;
 }
 
@@ -628,7 +816,6 @@ GINAC_IMPLEMENT_REGISTERED_CLASS(function, exprseq)
 
 function::function() : serial(0)
 {
-	tinfo_key = TINFO_function;
 }
 
 //////////
@@ -639,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
@@ -648,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)
@@ -658,13 +843,14 @@ 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;
+	if ( ser >= registered_functions().size() ) {
+		throw std::runtime_error("function does not exist");
+	}
 }
 
 function::function(unsigned ser, std::auto_ptr<exvector> vp) 
   : exprseq(vp), serial(ser)
 {
-	tinfo_key = TINFO_function;
 }
 
 //////////
@@ -672,8 +858,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)) {
@@ -691,12 +878,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
 {
@@ -705,6 +886,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
 //////////
@@ -802,7 +985,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;
@@ -871,9 +1054,19 @@ ${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);
+	unsigned v = golden_ratio_hash(make_hash_seed(typeid(*this)) ^ serial);
 	for (size_t i=0; i<nops(); i++) {
 		v = rotate_left(v);
 		v ^= this->op(i).gethash();
@@ -924,6 +1117,68 @@ ${series_switch_statement}
 	throw(std::logic_error("function::series(): invalid nparams"));
 }
 
+/** Implementation of ex::conjugate for functions. */
+ex function::conjugate() const
+{
+	GINAC_ASSERT(serial<registered_functions().size());
+	const function_options & opt = registered_functions()[serial];
+
+	if (opt.conjugate_f==0) {
+		return conjugate_function(*this).hold();
+	}
+
+	if (opt.conjugate_use_exvector_args) {
+		return ((conjugate_funcp_exvector)(opt.conjugate_f))(seq);
+	}
+
+	switch (opt.nparams) {
+		// the following lines have been generated for max. ${maxargs} parameters
+${conjugate_switch_statement}
+		// end of generated lines
+	}
+	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,
@@ -1002,7 +1257,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];
@@ -1014,7 +1269,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();
 	}
@@ -1052,10 +1307,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 GiNaC::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
@@ -1115,7 +1391,9 @@ unsigned function::find_function(const std::string &name, unsigned nparams)
 /** Return the print name of the function. */
 std::string function::get_name() const
 {
-	GINAC_ASSERT(serial<registered_functions().size());
+	if ( serial >= registered_functions().size() ) {
+		throw std::runtime_error("unknown function");
+	}
 	return registered_functions()[serial].name;
 }