X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Ffunction.pl;h=3e447354d814d87c1a04e71f2f71e99c4e6106e3;hp=aadc3bccf34458477fd44d26eaf0ed7057d51bc4;hb=1222eac51cee964961d2aad889dc4ceccb144a36;hpb=217bee1d939abf7f9ed3fe75928a62f7fdc3abcf diff --git a/ginac/function.pl b/ginac/function.pl old mode 100755 new mode 100644 index aadc3bcc..3e447354 --- a/ginac/function.pl +++ b/ginac/function.pl @@ -2,7 +2,7 @@ # function.pl options: \$maxargs=${maxargs} # -# GiNaC Copyright (C) 1999-2006 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 @@ -79,6 +79,14 @@ $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 &','',''); @@ -101,6 +109,10 @@ $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",'','',''); @@ -149,6 +161,18 @@ $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}: @@ -209,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) @@ -249,7 +293,7 @@ $interface=< 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; - const basic* return_type_tinfo() const; + tinfo_t return_type_tinfo() const; // new virtual functions which can be overridden by derived classes // none @@ -512,7 +573,7 @@ $implementation=< #include #include +#include #include "function.h" #include "operators.h" @@ -581,12 +643,15 @@ void function_options::initialize() { set_name("unnamed_function", "\\\\mbox{unnamed}"); nparams = 0; - eval_f = evalf_f = conjugate_f = derivative_f = power_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; @@ -617,6 +682,8 @@ 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 @@ -640,6 +707,19 @@ 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; @@ -659,10 +739,11 @@ function_options& function_options::series_func(series_funcp_exvector s) return *this; } -function_options & function_options::set_return_type(unsigned rt) +function_options & function_options::set_return_type(unsigned rt, tinfo_t rtt) { use_return_type = true; return_type = rt; + return_type_tinfo = rtt; return *this; } @@ -904,7 +985,7 @@ ex function::eval(int level) const exvector v = seq; GINAC_ASSERT(is_a(opt.symtree)); int sig = canonicalize(v.begin(), ex_to(opt.symtree)); - if (sig != INT_MAX) { + if (sig != std::numeric_limits::max()) { // Something has changed while sorting arguments, more evaluations later if (sig == 0) return _ex0; @@ -973,6 +1054,16 @@ ${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((p_int)tinfo()) ^ serial); @@ -1048,6 +1139,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