* Happy New Year(s)!
[ginac.git] / ginac / inifcns_trans.cpp
index 872308b93f54e234a99ebf493a4416b4d6b7f1a8..f0d785904176bd4519b6d35f127228d980e93d2e 100644 (file)
@@ -4,7 +4,7 @@
  *  functions. */
 
 /*
- *  GiNaC Copyright (C) 1999-2004 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2007 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
@@ -18,7 +18,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
  */
 
 #include <vector>
@@ -59,14 +59,14 @@ static ex exp_eval(const ex & x)
        // exp(n*Pi*I/2) -> {+1|+I|-1|-I}
        const ex TwoExOverPiI=(_ex2*x)/(Pi*I);
        if (TwoExOverPiI.info(info_flags::integer)) {
-               const numeric z = mod(ex_to<numeric>(TwoExOverPiI),_num4);
-               if (z.is_equal(_num0))
+               const numeric z = mod(ex_to<numeric>(TwoExOverPiI),*_num4_p);
+               if (z.is_equal(*_num0_p))
                        return _ex1;
-               if (z.is_equal(_num1))
+               if (z.is_equal(*_num1_p))
                        return ex(I);
-               if (z.is_equal(_num2))
+               if (z.is_equal(*_num2_p))
                        return _ex_1;
-               if (z.is_equal(_num3))
+               if (z.is_equal(*_num3_p))
                        return ex(-I);
        }
 
@@ -89,9 +89,21 @@ static ex exp_deriv(const ex & x, unsigned deriv_param)
        return exp(x);
 }
 
+static ex exp_real_part(const ex & x)
+{
+       return exp(GiNaC::real_part(x))*cos(GiNaC::imag_part(x));
+}
+
+static ex exp_imag_part(const ex & x)
+{
+       return exp(GiNaC::real_part(x))*sin(GiNaC::imag_part(x));
+}
+
 REGISTER_FUNCTION(exp, eval_func(exp_eval).
                        evalf_func(exp_evalf).
                        derivative_func(exp_deriv).
+                       real_part_func(exp_real_part).
+                       imag_part_func(exp_imag_part).
                        latex_name("\\exp"));
 
 //////////
@@ -111,14 +123,14 @@ static ex log_eval(const ex & x)
        if (x.info(info_flags::numeric)) {
                if (x.is_zero())         // log(0) -> infinity
                        throw(pole_error("log_eval(): log(0)",0));
-               if (x.info(info_flags::real) && x.info(info_flags::negative))
+               if (x.info(info_flags::rational) && x.info(info_flags::negative))
                        return (log(-x)+I*Pi);
                if (x.is_equal(_ex1))  // log(1) -> 0
                        return _ex0;
                if (x.is_equal(I))       // log(I) -> Pi*I/2
-                       return (Pi*I*_num1_2);
+                       return (Pi*I*_ex1_2);
                if (x.is_equal(-I))      // log(-I) -> -Pi*I/2
-                       return (Pi*I*_num_1_2);
+                       return (Pi*I*_ex_1_2);
 
                // log(float) -> float
                if (!x.info(info_flags::crational))
@@ -128,14 +140,8 @@ static ex log_eval(const ex & x)
        // log(exp(t)) -> t (if -Pi < t.imag() <= Pi):
        if (is_ex_the_function(x, exp)) {
                const ex &t = x.op(0);
-               if (is_a<symbol>(t) && t.info(info_flags::real)) {
+               if (t.info(info_flags::real))
                        return t;
-               }
-               if (t.info(info_flags::numeric)) {
-                       const numeric &nt = ex_to<numeric>(t);
-                       if (nt.is_real())
-                               return t;
-               }
        }
        
        return log(x).hold();
@@ -200,7 +206,6 @@ static ex log_series(const ex &arg,
                if (!argser.is_terminating() || argser.nops()!=1) {
                        // in this case n more (or less) terms are needed
                        // (sadly, to generate them, we have to start from the beginning)
-                       const ex newarg = ex_to<pseries>((arg/coeff).series(rel, order+n, options)).shift_exponents(-n).convert_to_poly(true);
                        if (n == 0 && coeff == 1) {
                                epvector epv;
                                ex acc = (new pseries(rel, epv))->setflag(status_flags::dynallocated);
@@ -217,6 +222,7 @@ static ex log_series(const ex &arg,
                                }
                                return acc;
                        }
+                       const ex newarg = ex_to<pseries>((arg/coeff).series(rel, order+n, options)).shift_exponents(-n).convert_to_poly(true);
                        return pseries(rel, seq).add_series(ex_to<pseries>(log(newarg).series(rel, order, options)));
                } else  // it was a monomial
                        return pseries(rel, seq);
@@ -238,10 +244,26 @@ static ex log_series(const ex &arg,
        throw do_taylor();  // caught by function::series()
 }
 
+static ex log_real_part(const ex & x)
+{
+       if (x.info(info_flags::nonnegative))
+               return log(x).hold();
+       return log(abs(x));
+}
+
+static ex log_imag_part(const ex & x)
+{
+       if (x.info(info_flags::nonnegative))
+               return 0;
+       return atan2(GiNaC::imag_part(x), GiNaC::real_part(x));
+}
+
 REGISTER_FUNCTION(log, eval_func(log_eval).
                        evalf_func(log_evalf).
                        derivative_func(log_deriv).
                        series_func(log_series).
+                       real_part_func(log_real_part).
+                       imag_part_func(log_imag_part).
                        latex_name("\\ln"));
 
 //////////
@@ -262,33 +284,33 @@ static ex sin_eval(const ex & x)
        const ex SixtyExOverPi = _ex60*x/Pi;
        ex sign = _ex1;
        if (SixtyExOverPi.info(info_flags::integer)) {
-               numeric z = mod(ex_to<numeric>(SixtyExOverPi),_num120);
-               if (z>=_num60) {
+               numeric z = mod(ex_to<numeric>(SixtyExOverPi),*_num120_p);
+               if (z>=*_num60_p) {
                        // wrap to interval [0, Pi)
-                       z -= _num60;
+                       z -= *_num60_p;
                        sign = _ex_1;
                }
-               if (z>_num30) {
+               if (z>*_num30_p) {
                        // wrap to interval [0, Pi/2)
-                       z = _num60-z;
+                       z = *_num60_p-z;
                }
-               if (z.is_equal(_num0))  // sin(0)       -> 0
+               if (z.is_equal(*_num0_p))  // sin(0)       -> 0
                        return _ex0;
-               if (z.is_equal(_num5))  // sin(Pi/12)   -> sqrt(6)/4*(1-sqrt(3)/3)
+               if (z.is_equal(*_num5_p))  // sin(Pi/12)   -> sqrt(6)/4*(1-sqrt(3)/3)
                        return sign*_ex1_4*sqrt(_ex6)*(_ex1+_ex_1_3*sqrt(_ex3));
-               if (z.is_equal(_num6))  // sin(Pi/10)   -> sqrt(5)/4-1/4
+               if (z.is_equal(*_num6_p))  // sin(Pi/10)   -> sqrt(5)/4-1/4
                        return sign*(_ex1_4*sqrt(_ex5)+_ex_1_4);
-               if (z.is_equal(_num10)) // sin(Pi/6)    -> 1/2
+               if (z.is_equal(*_num10_p)) // sin(Pi/6)    -> 1/2
                        return sign*_ex1_2;
-               if (z.is_equal(_num15)) // sin(Pi/4)    -> sqrt(2)/2
+               if (z.is_equal(*_num15_p)) // sin(Pi/4)    -> sqrt(2)/2
                        return sign*_ex1_2*sqrt(_ex2);
-               if (z.is_equal(_num18)) // sin(3/10*Pi) -> sqrt(5)/4+1/4
+               if (z.is_equal(*_num18_p)) // sin(3/10*Pi) -> sqrt(5)/4+1/4
                        return sign*(_ex1_4*sqrt(_ex5)+_ex1_4);
-               if (z.is_equal(_num20)) // sin(Pi/3)    -> sqrt(3)/2
+               if (z.is_equal(*_num20_p)) // sin(Pi/3)    -> sqrt(3)/2
                        return sign*_ex1_2*sqrt(_ex3);
-               if (z.is_equal(_num25)) // sin(5/12*Pi) -> sqrt(6)/4*(1+sqrt(3)/3)
+               if (z.is_equal(*_num25_p)) // sin(5/12*Pi) -> sqrt(6)/4*(1+sqrt(3)/3)
                        return sign*_ex1_4*sqrt(_ex6)*(_ex1+_ex1_3*sqrt(_ex3));
-               if (z.is_equal(_num30)) // sin(Pi/2)    -> 1
+               if (z.is_equal(*_num30_p)) // sin(Pi/2)    -> 1
                        return sign;
        }
 
@@ -327,9 +349,21 @@ static ex sin_deriv(const ex & x, unsigned deriv_param)
        return cos(x);
 }
 
+static ex sin_real_part(const ex & x)
+{
+       return cosh(GiNaC::imag_part(x))*sin(GiNaC::real_part(x));
+}
+
+static ex sin_imag_part(const ex & x)
+{
+       return sinh(GiNaC::imag_part(x))*cos(GiNaC::real_part(x));
+}
+
 REGISTER_FUNCTION(sin, eval_func(sin_eval).
                        evalf_func(sin_evalf).
                        derivative_func(sin_deriv).
+                       real_part_func(sin_real_part).
+                       imag_part_func(sin_imag_part).
                        latex_name("\\sin"));
 
 //////////
@@ -350,33 +384,33 @@ static ex cos_eval(const ex & x)
        const ex SixtyExOverPi = _ex60*x/Pi;
        ex sign = _ex1;
        if (SixtyExOverPi.info(info_flags::integer)) {
-               numeric z = mod(ex_to<numeric>(SixtyExOverPi),_num120);
-               if (z>=_num60) {
+               numeric z = mod(ex_to<numeric>(SixtyExOverPi),*_num120_p);
+               if (z>=*_num60_p) {
                        // wrap to interval [0, Pi)
-                       z = _num120-z;
+                       z = *_num120_p-z;
                }
-               if (z>=_num30) {
+               if (z>=*_num30_p) {
                        // wrap to interval [0, Pi/2)
-                       z = _num60-z;
+                       z = *_num60_p-z;
                        sign = _ex_1;
                }
-               if (z.is_equal(_num0))  // cos(0)       -> 1
+               if (z.is_equal(*_num0_p))  // cos(0)       -> 1
                        return sign;
-               if (z.is_equal(_num5))  // cos(Pi/12)   -> sqrt(6)/4*(1+sqrt(3)/3)
+               if (z.is_equal(*_num5_p))  // cos(Pi/12)   -> sqrt(6)/4*(1+sqrt(3)/3)
                        return sign*_ex1_4*sqrt(_ex6)*(_ex1+_ex1_3*sqrt(_ex3));
-               if (z.is_equal(_num10)) // cos(Pi/6)    -> sqrt(3)/2
+               if (z.is_equal(*_num10_p)) // cos(Pi/6)    -> sqrt(3)/2
                        return sign*_ex1_2*sqrt(_ex3);
-               if (z.is_equal(_num12)) // cos(Pi/5)    -> sqrt(5)/4+1/4
+               if (z.is_equal(*_num12_p)) // cos(Pi/5)    -> sqrt(5)/4+1/4
                        return sign*(_ex1_4*sqrt(_ex5)+_ex1_4);
-               if (z.is_equal(_num15)) // cos(Pi/4)    -> sqrt(2)/2
+               if (z.is_equal(*_num15_p)) // cos(Pi/4)    -> sqrt(2)/2
                        return sign*_ex1_2*sqrt(_ex2);
-               if (z.is_equal(_num20)) // cos(Pi/3)    -> 1/2
+               if (z.is_equal(*_num20_p)) // cos(Pi/3)    -> 1/2
                        return sign*_ex1_2;
-               if (z.is_equal(_num24)) // cos(2/5*Pi)  -> sqrt(5)/4-1/4x
+               if (z.is_equal(*_num24_p)) // cos(2/5*Pi)  -> sqrt(5)/4-1/4x
                        return sign*(_ex1_4*sqrt(_ex5)+_ex_1_4);
-               if (z.is_equal(_num25)) // cos(5/12*Pi) -> sqrt(6)/4*(1-sqrt(3)/3)
+               if (z.is_equal(*_num25_p)) // cos(5/12*Pi) -> sqrt(6)/4*(1-sqrt(3)/3)
                        return sign*_ex1_4*sqrt(_ex6)*(_ex1+_ex_1_3*sqrt(_ex3));
-               if (z.is_equal(_num30)) // cos(Pi/2)    -> 0
+               if (z.is_equal(*_num30_p)) // cos(Pi/2)    -> 0
                        return _ex0;
        }
 
@@ -415,9 +449,21 @@ static ex cos_deriv(const ex & x, unsigned deriv_param)
        return -sin(x);
 }
 
+static ex cos_real_part(const ex & x)
+{
+       return cosh(GiNaC::imag_part(x))*cos(GiNaC::real_part(x));
+}
+
+static ex cos_imag_part(const ex & x)
+{
+       return -sinh(GiNaC::imag_part(x))*sin(GiNaC::real_part(x));
+}
+
 REGISTER_FUNCTION(cos, eval_func(cos_eval).
                        evalf_func(cos_evalf).
                        derivative_func(cos_deriv).
+                       real_part_func(cos_real_part).
+                       imag_part_func(cos_imag_part).
                        latex_name("\\cos"));
 
 //////////
@@ -438,29 +484,29 @@ static ex tan_eval(const ex & x)
        const ex SixtyExOverPi = _ex60*x/Pi;
        ex sign = _ex1;
        if (SixtyExOverPi.info(info_flags::integer)) {
-               numeric z = mod(ex_to<numeric>(SixtyExOverPi),_num60);
-               if (z>=_num60) {
+               numeric z = mod(ex_to<numeric>(SixtyExOverPi),*_num60_p);
+               if (z>=*_num60_p) {
                        // wrap to interval [0, Pi)
-                       z -= _num60;
+                       z -= *_num60_p;
                }
-               if (z>=_num30) {
+               if (z>=*_num30_p) {
                        // wrap to interval [0, Pi/2)
-                       z = _num60-z;
+                       z = *_num60_p-z;
                        sign = _ex_1;
                }
-               if (z.is_equal(_num0))  // tan(0)       -> 0
+               if (z.is_equal(*_num0_p))  // tan(0)       -> 0
                        return _ex0;
-               if (z.is_equal(_num5))  // tan(Pi/12)   -> 2-sqrt(3)
+               if (z.is_equal(*_num5_p))  // tan(Pi/12)   -> 2-sqrt(3)
                        return sign*(_ex2-sqrt(_ex3));
-               if (z.is_equal(_num10)) // tan(Pi/6)    -> sqrt(3)/3
+               if (z.is_equal(*_num10_p)) // tan(Pi/6)    -> sqrt(3)/3
                        return sign*_ex1_3*sqrt(_ex3);
-               if (z.is_equal(_num15)) // tan(Pi/4)    -> 1
+               if (z.is_equal(*_num15_p)) // tan(Pi/4)    -> 1
                        return sign;
-               if (z.is_equal(_num20)) // tan(Pi/3)    -> sqrt(3)
+               if (z.is_equal(*_num20_p)) // tan(Pi/3)    -> sqrt(3)
                        return sign*sqrt(_ex3);
-               if (z.is_equal(_num25)) // tan(5/12*Pi) -> 2+sqrt(3)
+               if (z.is_equal(*_num25_p)) // tan(5/12*Pi) -> 2+sqrt(3)
                        return sign*(sqrt(_ex3)+_ex2);
-               if (z.is_equal(_num30)) // tan(Pi/2)    -> infinity
+               if (z.is_equal(*_num30_p)) // tan(Pi/2)    -> infinity
                        throw (pole_error("tan_eval(): simple pole",1));
        }
 
@@ -500,6 +546,20 @@ static ex tan_deriv(const ex & x, unsigned deriv_param)
        return (_ex1+power(tan(x),_ex2));
 }
 
+static ex tan_real_part(const ex & x)
+{
+       ex a = GiNaC::real_part(x);
+       ex b = GiNaC::imag_part(x);
+       return tan(a)/(1+power(tan(a),2)*power(tan(b),2));
+}
+
+static ex tan_imag_part(const ex & x)
+{
+       ex a = GiNaC::real_part(x);
+       ex b = GiNaC::imag_part(x);
+       return tanh(b)/(1+power(tan(a),2)*power(tan(b),2));
+}
+
 static ex tan_series(const ex &x,
                      const relational &rel,
                      int order,
@@ -520,6 +580,8 @@ REGISTER_FUNCTION(tan, eval_func(tan_eval).
                        evalf_func(tan_evalf).
                        derivative_func(tan_deriv).
                        series_func(tan_series).
+                       real_part_func(tan_real_part).
+                       imag_part_func(tan_imag_part).
                        latex_name("\\tan"));
 
 //////////
@@ -548,7 +610,7 @@ static ex asin_eval(const ex & x)
 
                // asin(1) -> Pi/2
                if (x.is_equal(_ex1))
-                       return _num1_2*Pi;
+                       return _ex1_2*Pi;
 
                // asin(-1/2) -> -Pi/6
                if (x.is_equal(_ex_1_2))
@@ -556,7 +618,7 @@ static ex asin_eval(const ex & x)
 
                // asin(-1) -> -Pi/2
                if (x.is_equal(_ex_1))
-                       return _num_1_2*Pi;
+                       return _ex_1_2*Pi;
 
                // asin(float) -> float
                if (!x.info(info_flags::crational))
@@ -758,69 +820,67 @@ static ex atan2_evalf(const ex &y, const ex &x)
 
 static ex atan2_eval(const ex & y, const ex & x)
 {
-       if (y.info(info_flags::numeric) && x.info(info_flags::numeric)) {
+       if (y.is_zero()) {
 
-               if (y.is_zero()) {
+               // atan(0, 0) -> 0
+               if (x.is_zero())
+                       return _ex0;
 
-                       // atan(0, 0) -> 0
-                       if (x.is_zero())
-                               return _ex0;
+               // atan(0, x), x real and positive -> 0
+               if (x.info(info_flags::positive))
+                       return _ex0;
 
-                       // atan(0, x), x real and positive -> 0
-                       if (x.info(info_flags::positive))
-                               return _ex0;
+               // atan(0, x), x real and negative -> -Pi
+               if (x.info(info_flags::negative))
+                       return _ex_1*Pi;
+       }
 
-                       // atan(0, x), x real and negative -> -Pi
-                       if (x.info(info_flags::negative))
-                               return _ex_1*Pi;
-               }
+       if (x.is_zero()) {
 
-               if (x.is_zero()) {
+               // atan(y, 0), y real and positive -> Pi/2
+               if (y.info(info_flags::positive))
+                       return _ex1_2*Pi;
 
-                       // atan(y, 0), y real and positive -> Pi/2
-                       if (y.info(info_flags::positive))
-                               return _ex1_2*Pi;
+               // atan(y, 0), y real and negative -> -Pi/2
+               if (y.info(info_flags::negative))
+                       return _ex_1_2*Pi;
+       }
 
-                       // atan(y, 0), y real and negative -> -Pi/2
-                       if (y.info(info_flags::negative))
-                               return _ex_1_2*Pi;
-               }
+       if (y.is_equal(x)) {
 
-               if (y.is_equal(x)) {
+               // atan(y, y), y real and positive -> Pi/4
+               if (y.info(info_flags::positive))
+                       return _ex1_4*Pi;
 
-                       // atan(y, y), y real and positive -> Pi/4
-                       if (y.info(info_flags::positive))
-                               return _ex1_4*Pi;
+               // atan(y, y), y real and negative -> -3/4*Pi
+               if (y.info(info_flags::negative))
+                       return numeric(-3, 4)*Pi;
+       }
 
-                       // atan(y, y), y real and negative -> -3/4*Pi
-                       if (y.info(info_flags::negative))
-                               return numeric(-3, 4)*Pi;
-               }
+       if (y.is_equal(-x)) {
 
-               if (y.is_equal(-x)) {
+               // atan(y, -y), y real and positive -> 3*Pi/4
+               if (y.info(info_flags::positive))
+                       return numeric(3, 4)*Pi;
 
-                       // atan(y, -y), y real and positive -> 3*Pi/4
-                       if (y.info(info_flags::positive))
-                               return numeric(3, 4)*Pi;
+               // atan(y, -y), y real and negative -> -Pi/4
+               if (y.info(info_flags::negative))
+                       return _ex_1_4*Pi;
+       }
 
-                       // atan(y, -y), y real and negative -> -Pi/4
-                       if (y.info(info_flags::negative))
-                               return _ex_1_4*Pi;
-               }
+       // atan(float, float) -> float
+       if (is_a<numeric>(y) && is_a<numeric>(x) && !y.info(info_flags::crational)
+                       && !x.info(info_flags::crational))
+               return atan(ex_to<numeric>(y), ex_to<numeric>(x));
 
-               // atan(float, float) -> float
-               if (!y.info(info_flags::crational) && !x.info(info_flags::crational))
-                       return atan(ex_to<numeric>(y), ex_to<numeric>(x));
-
-               // atan(real, real) -> atan(y/x) +/- Pi
-               if (y.info(info_flags::real) && x.info(info_flags::real)) {
-                       if (x.info(info_flags::positive))
-                               return atan(y/x);
-                       else if(y.info(info_flags::positive))
-                               return atan(y/x)+Pi;
-                       else
-                               return atan(y/x)-Pi;
-               }
+       // atan(real, real) -> atan(y/x) +/- Pi
+       if (y.info(info_flags::real) && x.info(info_flags::real)) {
+               if (x.info(info_flags::positive))
+                       return atan(y/x);
+               else if(y.info(info_flags::positive))
+                       return atan(y/x)+Pi;
+               else
+                       return atan(y/x)-Pi;
        }
 
        return atan2(y, x).hold();
@@ -902,9 +962,21 @@ static ex sinh_deriv(const ex & x, unsigned deriv_param)
        return cosh(x);
 }
 
+static ex sinh_real_part(const ex & x)
+{
+       return sinh(GiNaC::real_part(x))*cos(GiNaC::imag_part(x));
+}
+
+static ex sinh_imag_part(const ex & x)
+{
+       return cosh(GiNaC::real_part(x))*sin(GiNaC::imag_part(x));
+}
+
 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).
                         latex_name("\\sinh"));
 
 //////////
@@ -967,9 +1039,21 @@ static ex cosh_deriv(const ex & x, unsigned deriv_param)
        return sinh(x);
 }
 
+static ex cosh_real_part(const ex & x)
+{
+       return cosh(GiNaC::real_part(x))*cos(GiNaC::imag_part(x));
+}
+
+static ex cosh_imag_part(const ex & x)
+{
+       return sinh(GiNaC::real_part(x))*sin(GiNaC::imag_part(x));
+}
+
 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).
                         latex_name("\\cosh"));
 
 //////////
@@ -1048,10 +1132,26 @@ static ex tanh_series(const ex &x,
        return (sinh(x)/cosh(x)).series(rel, order, options);
 }
 
+static ex tanh_real_part(const ex & x)
+{
+       ex a = GiNaC::real_part(x);
+       ex b = GiNaC::imag_part(x);
+       return tanh(a)/(1+power(tanh(a),2)*power(tan(b),2));
+}
+
+static ex tanh_imag_part(const ex & x)
+{
+       ex a = GiNaC::real_part(x);
+       ex b = GiNaC::imag_part(x);
+       return tan(b)/(1+power(tanh(a),2)*power(tan(b),2));
+}
+
 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).
                         latex_name("\\tanh"));
 
 //////////