X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Finifcns_trans.cpp;h=57d13025c3447be0bba4206e910249f70dc5f618;hp=12c0d20c25b36867e212e056f923680d8c216173;hb=ccec535ede5a414447d69fba95af194df7327bfb;hpb=22abfbe8c78e339188096a5bf749a7c2d4f0a368

diff --git a/ginac/inifcns_trans.cpp b/ginac/inifcns_trans.cpp
index 12c0d20c..57d13025 100644
--- a/ginac/inifcns_trans.cpp
+++ b/ginac/inifcns_trans.cpp
@@ -4,7 +4,7 @@
  *  functions. */
 
 /*
- *  GiNaC Copyright (C) 1999-2005 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
@@ -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"));
 
 //////////
@@ -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();
@@ -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"));
 
 //////////
@@ -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"));
 
 //////////
@@ -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"));
 
 //////////
@@ -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"));
 
 //////////
@@ -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 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) && !y.info(info_flags::crational) &&
+	    is_a<numeric>(x) && !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"));
 
 //////////