X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Ffunction.pl;h=26f37afdc29db6bd3e07cd6382bb51731749d79d;hp=cfb9e813d9622289332ac45d71efa7c012f2e0bb;hb=5041748e650b3a2da73ae6128c83f88698d38dcf;hpb=0cf43f3096cbcfc7472ff9c8927c6eb74f2eeb8c

diff --git a/ginac/function.pl b/ginac/function.pl
index cfb9e813..26f37afd 100755
--- a/ginac/function.pl
+++ b/ginac/function.pl
@@ -15,79 +15,68 @@ sub generate_seq {
 }
 
 sub generate_from_to {
-	my ($template,$seq_template1,$seq_template2,$from,$to)=@_;
+	my ($template,$seq_template1,$seq_template2,$seq_template3,$from,$to)=@_;
 	my ($res,$N,$SEQ);
 
 	$res='';
 	for ($N=$from; $N<=$to; $N++) {
 		$SEQ1=generate_seq($seq_template1,$N);
 		$SEQ2=generate_seq($seq_template2,$N);
+		$SEQ3=generate_seq($seq_template3,$N);
 		$res .= eval('"' . $template . '"');
 		$SEQ1=''; # to avoid main::SEQ1 used only once warning
 		$SEQ2=''; # same as above
+		$SEQ3=''; # same as above
 	}
 	return $res;
 }
 
 sub generate {
-	my ($template,$seq_template1,$seq_template2)=@_;
-	return generate_from_to($template,$seq_template1,$seq_template2,1,$maxargs);
+	my ($template,$seq_template1,$seq_template2,$seq_template3)=@_;
+	return generate_from_to($template,$seq_template1,$seq_template2,$seq_template3,1,$maxargs);
 }
 
-$declare_function_macro = <<'END_OF_DECLARE_FUNCTION_1_AND_2P_MACRO';
-#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
-
-$declare_function_macro .= generate_from_to(
-	<<'END_OF_DECLARE_FUNCTION_MACRO','const GiNaC::ex & p${N}','p${N}',3,$maxargs);
+$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) \\
 extern const unsigned function_index_##NAME; \\
-inline GiNaC::function NAME(${SEQ1}) { \\
-	return GiNaC::function(function_index_##NAME, ${SEQ2}); \\
+template<${SEQ1}> \\
+inline const GiNaC::function NAME(${SEQ2}) { \\
+	return GiNaC::function(function_index_##NAME, ${SEQ3}); \\
 }
 
 END_OF_DECLARE_FUNCTION_MACRO
 
 $typedef_eval_funcp=generate(
 'typedef ex (* eval_funcp_${N})(${SEQ1});'."\n",
-'const ex &','');
+'const ex &','','');
 
 $typedef_evalf_funcp=generate(
 'typedef ex (* evalf_funcp_${N})(${SEQ1});'."\n",
-'const ex &','');
+'const ex &','','');
 
 $typedef_derivative_funcp=generate(
 'typedef ex (* derivative_funcp_${N})(${SEQ1}, unsigned);'."\n",
-'const ex &','');
+'const ex &','','');
 
 $typedef_series_funcp=generate(
 'typedef ex (* series_funcp_${N})(${SEQ1}, const relational &, int, unsigned);'."\n",
-'const ex &','');
+'const ex &','','');
 
-$eval_func_interface=generate('    function_options & eval_func(eval_funcp_${N} e);'."\n",'','');
+$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",'','');
+$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",'','');
+$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",'','');
+$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}','');
+'const ex & param${N}','','');
 
 $constructors_implementation=generate(
-	<<'END_OF_CONSTRUCTORS_IMPLEMENTATION','const ex & param${N}','param${N}');
+	<<'END_OF_CONSTRUCTORS_IMPLEMENTATION','const ex & param${N}','param${N}','');
 function::function(unsigned ser, ${SEQ1})
 	: exprseq(${SEQ2}), serial(ser)
 {
@@ -97,26 +86,26 @@ function::function(unsigned ser, ${SEQ1})
 END_OF_CONSTRUCTORS_IMPLEMENTATION
 
 $eval_switch_statement=generate(
-	<<'END_OF_EVAL_SWITCH_STATEMENT','seq[${N}-1]','');
+	<<'END_OF_EVAL_SWITCH_STATEMENT','seq[${N}-1]','','');
 	case ${N}:
-		eval_result=((eval_funcp_${N})(registered_functions()[serial].eval_f))(${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]','');
+	<<'END_OF_EVALF_SWITCH_STATEMENT','eseq[${N}-1]','','');
 	case ${N}:
 		return ((evalf_funcp_${N})(registered_functions()[serial].evalf_f))(${SEQ1});
 END_OF_EVALF_SWITCH_STATEMENT
 
 $diff_switch_statement=generate(
-	<<'END_OF_DIFF_SWITCH_STATEMENT','seq[${N}-1]','');
+	<<'END_OF_DIFF_SWITCH_STATEMENT','seq[${N}-1]','','');
 	case ${N}:
 		return ((derivative_funcp_${N})(registered_functions()[serial].derivative_f))(${SEQ1},diff_param);
 END_OF_DIFF_SWITCH_STATEMENT
 
 $series_switch_statement=generate(
-	<<'END_OF_SERIES_SWITCH_STATEMENT','seq[${N}-1]','');
+	<<'END_OF_SERIES_SWITCH_STATEMENT','seq[${N}-1]','','');
 	case ${N}:
 		try {
 			res = ((series_funcp_${N})(registered_functions()[serial].series_f))(${SEQ1},r,order,options);
@@ -127,49 +116,49 @@ $series_switch_statement=generate(
 END_OF_SERIES_SWITCH_STATEMENT
 
 $eval_func_implementation=generate(
-	<<'END_OF_EVAL_FUNC_IMPLEMENTATION','','');
+	<<'END_OF_EVAL_FUNC_IMPLEMENTATION','','','');
 function_options & function_options::eval_func(eval_funcp_${N} e)
 {
 	test_and_set_nparams(${N});
-	eval_f=eval_funcp(e);
+	eval_f = eval_funcp(e);
 	return *this;
-}        
+}
 END_OF_EVAL_FUNC_IMPLEMENTATION
 
 $evalf_func_implementation=generate(
-	<<'END_OF_EVALF_FUNC_IMPLEMENTATION','','');
+	<<'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);
+	evalf_f = evalf_funcp(ef);
 	return *this;
-}        
+}
 END_OF_EVALF_FUNC_IMPLEMENTATION
 
 $derivative_func_implementation=generate(
-	<<'END_OF_DERIVATIVE_FUNC_IMPLEMENTATION','','');
+	<<'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);
+	derivative_f = derivative_funcp(d);
 	return *this;
-}        
+}
 END_OF_DERIVATIVE_FUNC_IMPLEMENTATION
 
 $series_func_implementation=generate(
-	<<'END_OF_SERIES_FUNC_IMPLEMENTATION','','');
+	<<'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);
+	series_f = series_funcp(s);
 	return *this;
-}        
+}
 END_OF_SERIES_FUNC_IMPLEMENTATION
 
 $interface=<<END_OF_INTERFACE;
 /** \@file function.h
  *
- *  Interface to abstract class function (new function concept). */
+ *  Interface to class of symbolic functions. */
 
 /*
  *  This file was generated automatically by function.pl.
@@ -199,7 +188,7 @@ $interface=<<END_OF_INTERFACE;
 #include <string>
 #include <vector>
 
-// CINT needs <algorithm> to work properly with <vector> 
+// CINT needs <algorithm> to work properly with <vector>
 #include <algorithm>
 
 #include "exprseq.h"
@@ -212,13 +201,8 @@ $declare_function_macro
 const unsigned function_index_##NAME= \\
 	GiNaC::function::register_new(GiNaC::function_options(#NAME).OPT);
 
-#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));
+// The TYPECHECK-macros were used inside the _evalf() functions.  They are
+// considered obsolete now:  (FIXME: remove them)
 
 #define BEGIN_TYPECHECK \\
 bool automatic_typecheck=true;
@@ -259,6 +243,7 @@ $typedef_series_funcp
 class function_options
 {
 	friend class function;
+	friend class fderivative;
 public:
 	function_options();
 	function_options(std::string const & n, std::string const & tn=std::string());
@@ -281,6 +266,7 @@ $series_func_interface
 	void test_and_set_nparams(unsigned n);
 	std::string get_name(void) const { return name; }
 	unsigned get_nparams(void) const { return nparams; }
+	bool has_derivative(void) const { return derivative_f != NULL; }
 
 protected:
 	std::string name;
@@ -333,10 +319,10 @@ public:
 $constructors_interface
 	// end of generated lines
 	function(unsigned ser, const exprseq & es);
-	function(unsigned ser, const exvector & v, bool discardable=0);
+	function(unsigned ser, const exvector & v, bool discardable = false);
 	function(unsigned ser, exvector * vp); // vp will be deleted
 
-	// functions overriding virtual functions from bases classes
+	// functions overriding virtual functions from base classes
 public:
 	void print(const print_context & c, unsigned level = 0) const;
 	unsigned precedence(void) const {return 70;}
@@ -348,12 +334,12 @@ public:
 	ex evalf(int level=0) const;
 	unsigned calchash(void) const;
 	ex series(const relational & r, int order, unsigned options = 0) const;
-	bool match(const ex & pattern, lst & repl_lst) const;
 	ex thisexprseq(const exvector & v) const;
 	ex thisexprseq(exvector * vp) 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(void) const;
 	unsigned return_type_tinfo(void) const;
 	
@@ -393,7 +379,7 @@ template<> inline bool is_exactly_a<function>(const basic & obj)
 }
 
 #define is_ex_the_function(OBJ, FUNCNAME) \\
-	(is_ex_exactly_of_type(OBJ, function) && static_cast<GiNaC::function *>(OBJ.bp)->get_serial() == function_index_##FUNCNAME)
+	(is_exactly_a<function>(OBJ) && static_cast<GiNaC::function *>(OBJ.bp)->get_serial() == function_index_##FUNCNAME)
 
 } // namespace GiNaC
 
@@ -404,7 +390,7 @@ END_OF_INTERFACE
 $implementation=<<END_OF_IMPLEMENTATION;
 /** \@file function.cpp
  *
- *  Implementation of class function. */
+ *  Implementation of class of symbolic functions. */
 
 /*
  *  This file was generated automatically by function.pl.
@@ -433,12 +419,14 @@ $implementation=<<END_OF_IMPLEMENTATION;
 #include <list>
 
 #include "function.h"
+#include "fderivative.h"
 #include "ex.h"
 #include "lst.h"
 #include "symmetry.h"
 #include "print.h"
 #include "archive.h"
 #include "inifcns.h"
+#include "tostring.h"
 #include "utils.h"
 #include "debugmsg.h"
 #include "remember.h"
@@ -468,12 +456,12 @@ function_options::~function_options()
 void function_options::initialize(void)
 {
 	set_name("unnamed_function","\\\\mbox{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;
+	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;
 	symtree = 0;
 }
 
@@ -481,11 +469,10 @@ function_options & function_options::set_name(std::string const & n,
                                               std::string const & tn)
 {
 	name=n;
-	if (tn==std::string()) {
-		TeX_name="\\\\mbox{"+name+"}";
-	} else {
-		TeX_name=tn;
-	}
+	if (tn==std::string())
+		TeX_name = "\\\\mbox{"+name+"}";
+	else
+		TeX_name = tn;
 	return *this;
 }
 
@@ -504,15 +491,15 @@ $series_func_implementation
 
 function_options & function_options::set_return_type(unsigned rt, unsigned rtt)
 {
-	use_return_type=true;
-	return_type=rt;
-	return_type_tinfo=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;
+	evalf_params_first = false;
 	return *this;
 }
 
@@ -520,16 +507,16 @@ 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;
+	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;
+	functions_with_same_name = o;
 	return *this;
 }
 
@@ -542,7 +529,7 @@ function_options & function_options::set_symmetry(const symmetry & s)
 void function_options::test_and_set_nparams(unsigned n)
 {
 	if (nparams==0) {
-		nparams=n;
+		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
@@ -571,13 +558,14 @@ function::function() : serial(0)
 
 void function::copy(const function & other)
 {
-	exprseq::copy(other);
-	serial=other.serial;
+	inherited::copy(other);
+	serial = other.serial;
 }
 
 void function::destroy(bool call_parent)
 {
-	if (call_parent) exprseq::destroy(call_parent);
+	if (call_parent)
+		inherited::destroy(call_parent);
 }
 
 //////////
@@ -635,7 +623,7 @@ function::function(const archive_node &n, const lst &sym_lst) : inherited(n, sym
 				serial = ser;
 				return;
 			}
-			i++; ser++;
+			++i; ++ser;
 		}
 		throw (std::runtime_error("unknown function '" + s + "' in archive"));
 	} else
@@ -657,7 +645,7 @@ void function::archive(archive_node &n) const
 }
 
 //////////
-// functions overriding virtual functions from bases classes
+// functions overriding virtual functions from base classes
 //////////
 
 // public
@@ -676,7 +664,7 @@ void function::print(const print_context & c, unsigned level) const
 		    << ", nops=" << nops()
 		    << std::endl;
 		unsigned delta_indent = static_cast<const print_tree &>(c).delta_indent;
-		for (unsigned i=0; i<nops(); ++i)
+		for (unsigned i=0; i<seq.size(); ++i)
 			seq[i].print(c, level + delta_indent);
 		c.s << std::string(level + delta_indent, ' ') << "=====" << std::endl;
 
@@ -684,7 +672,8 @@ void function::print(const print_context & c, unsigned level) const
 
 		// Print function name in lowercase
 		std::string lname = registered_functions()[serial].name;
-		for (unsigned i=0; i<lname.size(); i++)
+		unsigned num = lname.size();
+		for (unsigned i=0; i<num; i++)
 			lname[i] = tolower(lname[i]);
 		c.s << lname << "(";
 
@@ -692,7 +681,7 @@ void function::print(const print_context & c, unsigned level) const
 		exvector::const_iterator it = seq.begin(), itend = seq.end();
 		while (it != itend) {
 			it->print(c);
-			it++;
+			++it;
 			if (it != itend)
 				c.s << ",";
 		}
@@ -709,7 +698,11 @@ void function::print(const print_context & c, unsigned level) const
 
 ex function::expand(unsigned options) const
 {
-	return this->setflag(status_flags::expanded);
+	// Only expand arguments when asked to do so
+	if (options & expand_options::expand_function_args)
+		return inherited::expand(options);
+	else
+		return (options == 0) ? setflag(status_flags::expanded) : *this;
 }
 
 int function::degree(const ex & s) const
@@ -744,8 +737,8 @@ ex function::eval(int level) const
 	// Canonicalize argument order according to the symmetry properties
 	if (seq.size() > 1 && !(opt.symtree.is_zero())) {
 		exvector v = seq;
-		GINAC_ASSERT(is_ex_exactly_of_type(opt.symtree, symmetry));
-		int sig = canonicalize(v.begin(), ex_to_symmetry(opt.symtree));
+		GINAC_ASSERT(is_a<symmetry>(opt.symtree));
+		int sig = canonicalize(v.begin(), ex_to<symmetry>(opt.symtree));
 		if (sig != INT_MAX) {
 			// Something has changed while sorting arguments, more evaluations later
 			if (sig == 0)
@@ -758,7 +751,7 @@ ex function::eval(int level) const
 		return this->hold();
 	}
 
-	bool use_remember=opt.use_remember;
+	bool use_remember = opt.use_remember;
 	ex eval_result;
 	if (use_remember && lookup_remember_table(eval_result)) {
 		return eval_result;
@@ -781,7 +774,20 @@ ex function::evalf(int level) const
 {
 	GINAC_ASSERT(serial<registered_functions().size());
 
-	exvector eseq=evalfchildren(level);
+	// Evaluate children first
+	exvector eseq;
+	if (level == 1)
+		eseq = seq;
+	else if (level == -max_recursion_level)
+		throw(std::runtime_error("max recursion level reached"));
+	else
+		eseq.reserve(seq.size());
+	--level;
+	exvector::const_iterator it = seq.begin(), itend = seq.end();
+	while (it != itend) {
+		eseq.push_back(it->evalf(level));
+		++it;
+	}
 	
 	if (registered_functions()[serial].evalf_f==0) {
 		return function(serial,eseq).hold();
@@ -837,46 +843,23 @@ ${series_switch_statement}
 	throw(std::logic_error("function::series(): invalid nparams"));
 }
 
-bool function::match(const ex & pattern, lst & repl_lst) const
-{
-	// Serial number must match
-	if (is_ex_of_type(pattern, function) && serial != ex_to_function(pattern).serial)
-		return false;
-	return inherited::match(pattern, repl_lst);
-}
-
 // protected
 
-
 /** Implementation of ex::diff() for functions. It applies the chain rule,
  *  except for the Order term function.
  *  \@see ex::diff */
 ex function::derivative(const symbol & s) const
 {
 	ex result;
-	
+
 	if (serial == function_index_Order) {
 		// Order Term function only differentiates the argument
 		return Order(seq[0].diff(s));
-	} else if (serial == function_index_Derivative) {
-		// Inert derivative performs chain rule on the first argument only, and
-		// adds differentiation parameter to list (second argument)
-		GINAC_ASSERT(is_ex_exactly_of_type(seq[0], function));
-		GINAC_ASSERT(is_ex_exactly_of_type(seq[1], function));
-		ex fcn = seq[0];
-		ex arg_diff;
-		for (unsigned i=0; i!=fcn.nops(); i++) {
-			arg_diff = fcn.op(i).diff(s);
-			if (!arg_diff.is_zero()) {
-				lst new_lst = ex_to_lst(seq[1]);
-				new_lst.append(i);
-				result += arg_diff * Derivative(fcn, new_lst);
-			}
-		}
 	} else {
 		// Chain rule
 		ex arg_diff;
-		for (unsigned i=0; i!=seq.size(); i++) {
+		unsigned num = seq.size();
+		for (unsigned i=0; i<num; i++) {
 			arg_diff = seq[i].diff(s);
 			// We apply the chain rule only when it makes sense.  This is not
 			// just for performance reasons but also to allow functions to
@@ -893,37 +876,47 @@ ex function::derivative(const symbol & s) const
 int function::compare_same_type(const basic & other) const
 {
 	GINAC_ASSERT(is_of_type(other, function));
-	const function & o=static_cast<function &>(const_cast<basic &>(other));
+	const function & o = static_cast<const function &>(other);
 
-	if (serial!=o.serial) {
+	if (serial != o.serial)
 		return serial < o.serial ? -1 : 1;
-	}
-	return exprseq::compare_same_type(o);
+	else
+		return exprseq::compare_same_type(o);
 }
 
 bool function::is_equal_same_type(const basic & other) const
 {
 	GINAC_ASSERT(is_of_type(other, function));
-	const function & o=static_cast<function &>(const_cast<basic &>(other));
+	const function & o = static_cast<const function &>(other);
 
-	if (serial!=o.serial) return false;
-	return exprseq::is_equal_same_type(o);
+	if (serial != o.serial)
+		return false;
+	else
+		return exprseq::is_equal_same_type(o);
+}
+
+bool function::match_same_type(const basic & other) const
+{
+	GINAC_ASSERT(is_of_type(other, function));
+	const function & o = static_cast<const function &>(other);
+
+	return serial == o.serial;
 }
 
 unsigned function::return_type(void) const
 {
-	if (seq.size()==0) {
+	if (seq.empty())
 		return return_types::commutative;
-	}
-	return (*seq.begin()).return_type();
+	else
+		return seq.begin()->return_type();
 }
-   
+
 unsigned function::return_type_tinfo(void) const
 {
-	if (seq.size()==0) {
+	if (seq.empty())
 		return tinfo_key;
-	}
-	return (*seq.begin()).return_type_tinfo();
+	else
+		return seq.begin()->return_type_tinfo();
 }
 
 //////////
@@ -942,14 +935,15 @@ ex function::pderivative(unsigned diff_param) const // partial differentiation
 {
 	GINAC_ASSERT(serial<registered_functions().size());
 	
-	if (registered_functions()[serial].derivative_f==0) {
-		return Derivative(*this, lst(ex(diff_param)));
-	}
+	// No derivative defined? Then return abstract derivative object
+	if (registered_functions()[serial].derivative_f == NULL)
+		return fderivative(serial, diff_param, seq);
+
 	switch (registered_functions()[serial].nparams) {
 		// the following lines have been generated for max. ${maxargs} parameters
 ${diff_switch_statement}
 		// end of generated lines
-	}        
+	}
 	throw(std::logic_error("function::pderivative(): no diff function defined"));
 }
 
@@ -973,10 +967,10 @@ void function::store_remember_table(ex const & result) const
 
 unsigned function::register_new(function_options const & opt)
 {
-	unsigned same_name=0;
+	unsigned same_name = 0;
 	for (unsigned i=0; i<registered_functions().size(); ++i) {
 		if (registered_functions()[i].name==opt.name) {
-			same_name++;
+			++same_name;
 		}
 	}
 	if (same_name>=opt.functions_with_same_name) {
@@ -984,14 +978,14 @@ unsigned function::register_new(function_options const & opt)
 		// usually executed before main(), so the exception could not
 		// caught anyhow
 		std::cerr << "WARNING: function name " << opt.name
-				  << " already in use!" << std::endl;
+		          << " 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));
+			                         opt.remember_assoc_size,
+			                         opt.remember_strategy));
 	} else {
 		remember_table::remember_tables().push_back(remember_table());
 	}
@@ -1007,8 +1001,8 @@ unsigned function::find_function(const std::string &name, unsigned nparams)
 	while (i != end) {
 		if (i->get_name() == name && i->get_nparams() == nparams)
 			return serial;
-		i++;
-		serial++;
+		++i;
+		++serial;
 	}
 	throw (std::runtime_error("no function '" + name + "' with " + ToString(nparams) + " parameters defined"));
 }