X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Ffunction.pl;h=88be68d89e129308ce6a5ac18d53eb766f9f2ef6;hp=318e46c19bda4143f4f77908f19928de6cbdf203;hb=12fefbca9b424cb8e9ae05d83883b96e17c7b96e;hpb=c734f9bb6a1ce0aad913aa19a56542d84d86c60d

diff --git a/ginac/function.pl b/ginac/function.pl
old mode 100755
new mode 100644
index 318e46c1..88be68d8
--- 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;
 
@@ -79,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 &','','');
@@ -97,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(
@@ -120,7 +138,7 @@ $constructors_implementation=generate(
 function::function(unsigned ser, ${SEQ1})
 	: exprseq(${SEQ2}), serial(ser)
 {
-	tinfo_key = TINFO_function;
+	tinfo_key = &function::tinfo_static;
 }
 END_OF_CONSTRUCTORS_IMPLEMENTATION
 
@@ -143,12 +161,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}:
@@ -197,6 +233,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)
@@ -207,6 +263,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)
@@ -227,7 +293,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
@@ -241,7 +307,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__
@@ -271,7 +337,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)();
 
@@ -279,7 +348,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
@@ -289,7 +361,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 &);
 
@@ -312,14 +387,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)
@@ -329,7 +410,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);
@@ -341,6 +422,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);
 
@@ -352,7 +434,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;
 
@@ -360,7 +445,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;
@@ -370,7 +455,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;
 
@@ -419,17 +507,20 @@ 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;
 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
@@ -441,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);
@@ -455,12 +547,6 @@ protected:
 
 // 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)
 {
@@ -487,7 +573,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
@@ -501,13 +587,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"
@@ -516,6 +603,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"
@@ -555,13 +643,17 @@ 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;
@@ -590,7 +682,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
 
@@ -612,12 +707,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;
@@ -625,11 +739,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;
 }
 
@@ -697,7 +814,7 @@ GINAC_IMPLEMENT_REGISTERED_CLASS(function, exprseq)
 
 function::function() : serial(0)
 {
-	tinfo_key = TINFO_function;
+	tinfo_key = &function::tinfo_static;
 }
 
 //////////
@@ -708,7 +825,7 @@ function::function() : serial(0)
 
 function::function(unsigned ser) : serial(ser)
 {
-	tinfo_key = TINFO_function;
+	tinfo_key = &function::tinfo_static;
 }
 
 // the following lines have been generated for max. ${maxargs} parameters
@@ -717,7 +834,7 @@ $constructors_implementation
 
 function::function(unsigned ser, const exprseq & es) : exprseq(es), serial(ser)
 {
-	tinfo_key = TINFO_function;
+	tinfo_key = &function::tinfo_static;
 
 	// Force re-evaluation even if the exprseq was already evaluated
 	// (the exprseq copy constructor copies the flags)
@@ -727,13 +844,13 @@ 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;
+	tinfo_key = &function::tinfo_static;
 }
 
 function::function(unsigned ser, std::auto_ptr<exvector> vp) 
   : exprseq(vp), serial(ser)
 {
-	tinfo_key = TINFO_function;
+	tinfo_key = &function::tinfo_static;
 }
 
 //////////
@@ -871,7 +988,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;
@@ -940,9 +1057,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();
@@ -1015,6 +1143,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,
@@ -1093,7 +1261,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];
@@ -1105,7 +1273,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();
 	}
@@ -1143,10 +1311,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