Fix evaluation of log(p^a) -> a*log(p), if p>0 and a is real.

[ginac.git] / ginac / inifcns_trans.cpp

diff --git a/ginac/inifcns_trans.cpp b/ginac/inifcns_trans.cpp
index 3884d79c5275abda52f8917901769739c8ae9e64..56d909c6a2a40c7b48276cb98644a8da148a9b74 100644 (file)
--- a/ginac/inifcns_trans.cpp
+++ b/ginac/inifcns_trans.cpp
@@ -4,7 +4,7 @@
  *  functions. */
 
 /*
- *  GiNaC Copyright (C) 1999-2010 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
@@ -24,6 +24,8 @@
 #include "inifcns.h"
 #include "ex.h"
 #include "constant.h"
+#include "add.h"
+#include "mul.h"
 #include "numeric.h"
 #include "power.h"
 #include "operators.h"
@@ -81,6 +83,27 @@ static ex exp_eval(const ex & x)
        return exp(x).hold();
 }
 
+static ex exp_expand(const ex & arg, unsigned options)
+{
+       ex exp_arg;
+       if (options & expand_options::expand_function_args)
+               exp_arg = arg.expand(options);
+       else
+               exp_arg=arg;
+
+       if ((options & expand_options::expand_transcendental)
+               && is_exactly_a<add>(exp_arg)) {
+               exvector prodseq;
+               prodseq.reserve(exp_arg.nops());
+               for (const_iterator i = exp_arg.begin(); i != exp_arg.end(); ++i)
+                       prodseq.push_back(exp(*i));
+
+               return (new mul(prodseq))->setflag(status_flags::dynallocated | status_flags::expanded);
+       }
+
+       return exp(exp_arg).hold();
+}
+
 static ex exp_deriv(const ex & x, unsigned deriv_param)
 {
        GINAC_ASSERT(deriv_param==0);
@@ -107,6 +130,7 @@ static ex exp_conjugate(const ex & x)
 
 REGISTER_FUNCTION(exp, eval_func(exp_eval).
                        evalf_func(exp_evalf).
+                       expand_func(exp_expand).
                        derivative_func(exp_deriv).
                        real_part_func(exp_real_part).
                        imag_part_func(exp_imag_part).
@@ -150,7 +174,12 @@ static ex log_eval(const ex & x)
                if (t.info(info_flags::real))
                        return t;
        }
-       
+
+       // log(p^a) -> a*log(p), if p>0 and a is real
+       if (is_exactly_a<power>(x) && x.op(0).info(info_flags::positive) && x.op(1).info(info_flags::real)) {
+               return x.op(1)*log(x.op(0));
+       }
+
        return log(x).hold();
 }
 
@@ -265,6 +294,53 @@ static ex log_imag_part(const ex & x)
        return atan2(GiNaC::imag_part(x), GiNaC::real_part(x));
 }
 
+static ex log_expand(const ex & arg, unsigned options)
+{
+       if ((options & expand_options::expand_transcendental)
+               && is_exactly_a<mul>(arg) && !arg.info(info_flags::indefinite)) {
+               exvector sumseq;
+               exvector prodseq;
+               sumseq.reserve(arg.nops());
+               prodseq.reserve(arg.nops());
+               bool possign=true;
+
+               // searching for positive/negative factors
+               for (const_iterator i = arg.begin(); i != arg.end(); ++i) {
+                       ex e;
+                       if (options & expand_options::expand_function_args)
+                               e=i->expand(options);
+                       else
+                               e=*i;
+                       if (e.info(info_flags::positive))
+                               sumseq.push_back(log(e));
+                       else if (e.info(info_flags::negative)) {
+                               sumseq.push_back(log(-e));
+                               possign = !possign;
+                       } else
+                               prodseq.push_back(e);
+               }
+
+               if (sumseq.size() > 0) {
+                       ex newarg;
+                       if (options & expand_options::expand_function_args)
+                               newarg=((possign?_ex1:_ex_1)*mul(prodseq)).expand(options);
+                       else {
+                               newarg=(possign?_ex1:_ex_1)*mul(prodseq);
+                               ex_to<basic>(newarg).setflag(status_flags::purely_indefinite);
+                       }
+                       return add(sumseq)+log(newarg);
+               } else {
+                       if (!(options & expand_options::expand_function_args))
+                               ex_to<basic>(arg).setflag(status_flags::purely_indefinite);
+               }
+       }
+
+       if (options & expand_options::expand_function_args)
+               return log(arg.expand(options)).hold();
+       else
+               return log(arg).hold();
+}
+
 static ex log_conjugate(const ex & x)
 {
        // conjugate(log(x))==log(conjugate(x)) unless on the branch cut which
@@ -281,6 +357,7 @@ static ex log_conjugate(const ex & x)
 
 REGISTER_FUNCTION(log, eval_func(log_eval).
                        evalf_func(log_evalf).
+                       expand_func(log_expand).
                        derivative_func(log_deriv).
                        series_func(log_series).
                        real_part_func(log_real_part).
@@ -1059,11 +1136,18 @@ static ex sinh_imag_part(const ex & x)
        return cosh(GiNaC::real_part(x))*sin(GiNaC::imag_part(x));
 }
 
+static ex sinh_conjugate(const ex & x)
+{
+       // conjugate(sinh(x))==sinh(conjugate(x))
+       return sinh(x.conjugate());
+}
+
 REGISTER_FUNCTION(sinh, eval_func(sinh_eval).
                         evalf_func(sinh_evalf).
                         derivative_func(sinh_deriv).
                         real_part_func(sinh_real_part).
                         imag_part_func(sinh_imag_part).
+                        conjugate_func(sinh_conjugate).
                         latex_name("\\sinh"));
 
 //////////
@@ -1136,11 +1220,18 @@ static ex cosh_imag_part(const ex & x)
        return sinh(GiNaC::real_part(x))*sin(GiNaC::imag_part(x));
 }
 
+static ex cosh_conjugate(const ex & x)
+{
+       // conjugate(cosh(x))==cosh(conjugate(x))
+       return cosh(x.conjugate());
+}
+
 REGISTER_FUNCTION(cosh, eval_func(cosh_eval).
                         evalf_func(cosh_evalf).
                         derivative_func(cosh_deriv).
                         real_part_func(cosh_real_part).
                         imag_part_func(cosh_imag_part).
+                        conjugate_func(cosh_conjugate).
                         latex_name("\\cosh"));
 
 //////////
@@ -1233,12 +1324,19 @@ static ex tanh_imag_part(const ex & x)
        return tan(b)/(1+power(tanh(a),2)*power(tan(b),2));
 }
 
+static ex tanh_conjugate(const ex & x)
+{
+       // conjugate(tanh(x))==tanh(conjugate(x))
+       return tanh(x.conjugate());
+}
+
 REGISTER_FUNCTION(tanh, eval_func(tanh_eval).
                         evalf_func(tanh_evalf).
                         derivative_func(tanh_deriv).
                         series_func(tanh_series).
                         real_part_func(tanh_real_part).
                         imag_part_func(tanh_imag_part).
+                        conjugate_func(tanh_conjugate).
                         latex_name("\\tanh"));
 
 //////////