X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Finifcns_trans.cpp;h=f0d785904176bd4519b6d35f127228d980e93d2e;hp=507e18f51639f1c003280064b982f81a7d8f27e9;hb=619d77d2676f7f1a562fb9fefc0ba6754fe2d750;hpb=d448856f20cb58f939ddbf636e7f72e3599b1468

diff --git a/ginac/inifcns_trans.cpp b/ginac/inifcns_trans.cpp
index 507e18f5..f0d78590 100644
--- a/ginac/inifcns_trans.cpp
+++ b/ginac/inifcns_trans.cpp
@@ -4,7 +4,7 @@
  *  functions. */
 
 /*
- *  GiNaC Copyright (C) 1999-2001 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>
@@ -29,6 +29,7 @@
 #include "constant.h"
 #include "numeric.h"
 #include "power.h"
+#include "operators.h"
 #include "relational.h"
 #include "symbol.h"
 #include "pseries.h"
@@ -52,26 +53,28 @@ static ex exp_eval(const ex & x)
 {
 	// exp(0) -> 1
 	if (x.is_zero()) {
-		return _ex1();
+		return _ex1;
 	}
+
 	// exp(n*Pi*I/2) -> {+1|+I|-1|-I}
-	const ex TwoExOverPiI=(_ex2()*x)/(Pi*I);
+	const ex TwoExOverPiI=(_ex2*x)/(Pi*I);
 	if (TwoExOverPiI.info(info_flags::integer)) {
-		numeric z=mod(ex_to<numeric>(TwoExOverPiI),_num4());
-		if (z.is_equal(_num0()))
-			return _ex1();
-		if (z.is_equal(_num1()))
+		const numeric z = mod(ex_to<numeric>(TwoExOverPiI),*_num4_p);
+		if (z.is_equal(*_num0_p))
+			return _ex1;
+		if (z.is_equal(*_num1_p))
 			return ex(I);
-		if (z.is_equal(_num2()))
-			return _ex_1();
-		if (z.is_equal(_num3()))
+		if (z.is_equal(*_num2_p))
+			return _ex_1;
+		if (z.is_equal(*_num3_p))
 			return ex(-I);
 	}
+
 	// exp(log(x)) -> x
 	if (is_ex_the_function(x, log))
 		return x.op(0);
 	
-	// exp(float)
+	// exp(float) -> float
 	if (x.info(info_flags::numeric) && !x.info(info_flags::crational))
 		return exp(ex_to<numeric>(x));
 	
@@ -86,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"));
 
 //////////
@@ -108,26 +123,25 @@ 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(_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());
-		// log(float)
+			return (Pi*I*_ex_1_2);
+
+		// log(float) -> float
 		if (!x.info(info_flags::crational))
 			return log(ex_to<numeric>(x));
 	}
+
 	// log(exp(t)) -> t (if -Pi < t.imag() <= Pi):
 	if (is_ex_the_function(x, exp)) {
-		ex t = x.op(0);
-		if (t.info(info_flags::numeric)) {
-			numeric nt = ex_to<numeric>(t);
-			if (nt.is_real())
-				return t;
-		}
+		const ex &t = x.op(0);
+		if (t.info(info_flags::real))
+			return t;
 	}
 	
 	return log(x).hold();
@@ -138,7 +152,7 @@ static ex log_deriv(const ex & x, unsigned deriv_param)
 	GINAC_ASSERT(deriv_param==0);
 	
 	// d/dx log(x) -> 1/x
-	return power(x, _ex_1());
+	return power(x, _ex_1);
 }
 
 static ex log_series(const ex &arg,
@@ -146,12 +160,12 @@ static ex log_series(const ex &arg,
                      int order,
                      unsigned options)
 {
-	GINAC_ASSERT(is_exactly_a<symbol>(rel.lhs()));
+	GINAC_ASSERT(is_a<symbol>(rel.lhs()));
 	ex arg_pt;
 	bool must_expand_arg = false;
 	// maybe substitution of rel into arg fails because of a pole
 	try {
-		arg_pt = arg.subs(rel);
+		arg_pt = arg.subs(rel, subs_options::no_pattern);
 	} catch (pole_error) {
 		must_expand_arg = true;
 	}
@@ -177,7 +191,7 @@ static ex log_series(const ex &arg,
 		} while (!argser.is_terminating() && argser.nops()==1);
 
 		const symbol &s = ex_to<symbol>(rel.lhs());
-		const ex point = rel.rhs();
+		const ex &point = rel.rhs();
 		const int n = argser.ldegree(s);
 		epvector seq;
 		// construct what we carelessly called the n*log(x) term above
@@ -185,13 +199,29 @@ static ex log_series(const ex &arg,
 		// expand the log, but only if coeff is real and > 0, since otherwise
 		// it would make the branch cut run into the wrong direction
 		if (coeff.info(info_flags::positive))
-			seq.push_back(expair(n*log(s-point)+log(coeff), _ex0()));
+			seq.push_back(expair(n*log(s-point)+log(coeff), _ex0));
 		else
-			seq.push_back(expair(log(coeff*pow(s-point, n)), _ex0()));
+			seq.push_back(expair(log(coeff*pow(s-point, n)), _ex0));
 
 		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)
+			if (n == 0 && coeff == 1) {
+				epvector epv;
+				ex acc = (new pseries(rel, epv))->setflag(status_flags::dynallocated);
+				epv.reserve(2);
+				epv.push_back(expair(-1, _ex0));
+				epv.push_back(expair(Order(_ex1), order));
+				ex rest = pseries(rel, epv).add_series(argser);
+				for (int i = order-1; i>0; --i) {
+					epvector cterm;
+					cterm.reserve(1);
+					cterm.push_back(expair(i%2 ? _ex1/i : _ex_1/i, _ex0));
+					acc = pseries(rel, cterm).add_series(ex_to<pseries>(acc));
+					acc = (ex_to<pseries>(rest)).mul_series(ex_to<pseries>(acc));
+				}
+				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
@@ -203,21 +233,37 @@ static ex log_series(const ex &arg,
 		// This is the branch cut: assemble the primitive series manually and
 		// then add the corresponding complex step function.
 		const symbol &s = ex_to<symbol>(rel.lhs());
-		const ex point = rel.rhs();
+		const ex &point = rel.rhs();
 		const symbol foo;
-		const ex replarg = series(log(arg), s==foo, order).subs(foo==point);
+		const ex replarg = series(log(arg), s==foo, order).subs(foo==point, subs_options::no_pattern);
 		epvector seq;
-		seq.push_back(expair(-I*csgn(arg*I)*Pi, _ex0()));
-		seq.push_back(expair(Order(_ex1()), order));
+		seq.push_back(expair(-I*csgn(arg*I)*Pi, _ex0));
+		seq.push_back(expair(Order(_ex1), order));
 		return series(replarg - I*Pi + pseries(rel, seq), rel, order);
 	}
 	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"));
 
 //////////
@@ -235,55 +281,62 @@ static ex sin_evalf(const ex & x)
 static ex sin_eval(const ex & x)
 {
 	// sin(n/d*Pi) -> { all known non-nested radicals }
-	const ex SixtyExOverPi = _ex60()*x/Pi;
-	ex sign = _ex1();
+	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();
-			sign = _ex_1();
+			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
-			return _ex0();
-		if (z.is_equal(_num5()))  // sin(Pi/12)   -> sqrt(6)/4*(1-sqrt(3)/3)
-			return sign*_ex1_4()*power(_ex6(),_ex1_2())*(_ex1()+_ex_1_3()*power(_ex3(),_ex1_2()));
-		if (z.is_equal(_num6()))  // sin(Pi/10)   -> sqrt(5)/4-1/4
-			return sign*(_ex1_4()*power(_ex5(),_ex1_2())+_ex_1_4());
-		if (z.is_equal(_num10())) // sin(Pi/6)    -> 1/2
-			return sign*_ex1_2();
-		if (z.is_equal(_num15())) // sin(Pi/4)    -> sqrt(2)/2
-			return sign*_ex1_2()*power(_ex2(),_ex1_2());
-		if (z.is_equal(_num18())) // sin(3/10*Pi) -> sqrt(5)/4+1/4
-			return sign*(_ex1_4()*power(_ex5(),_ex1_2())+_ex1_4());
-		if (z.is_equal(_num20())) // sin(Pi/3)    -> sqrt(3)/2
-			return sign*_ex1_2()*power(_ex3(),_ex1_2());
-		if (z.is_equal(_num25())) // sin(5/12*Pi) -> sqrt(6)/4*(1+sqrt(3)/3)
-			return sign*_ex1_4()*power(_ex6(),_ex1_2())*(_ex1()+_ex1_3()*power(_ex3(),_ex1_2()));
-		if (z.is_equal(_num30())) // sin(Pi/2)    -> 1
-			return sign*_ex1();
+		if (z.is_equal(*_num0_p))  // sin(0)       -> 0
+			return _ex0;
+		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_p))  // sin(Pi/10)   -> sqrt(5)/4-1/4
+			return sign*(_ex1_4*sqrt(_ex5)+_ex_1_4);
+		if (z.is_equal(*_num10_p)) // sin(Pi/6)    -> 1/2
+			return sign*_ex1_2;
+		if (z.is_equal(*_num15_p)) // sin(Pi/4)    -> sqrt(2)/2
+			return sign*_ex1_2*sqrt(_ex2);
+		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_p)) // sin(Pi/3)    -> sqrt(3)/2
+			return sign*_ex1_2*sqrt(_ex3);
+		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_p)) // sin(Pi/2)    -> 1
+			return sign;
 	}
-	
+
 	if (is_exactly_a<function>(x)) {
-		ex t = x.op(0);
+		const ex &t = x.op(0);
+
 		// sin(asin(x)) -> x
 		if (is_ex_the_function(x, asin))
 			return t;
+
 		// sin(acos(x)) -> sqrt(1-x^2)
 		if (is_ex_the_function(x, acos))
-			return power(_ex1()-power(t,_ex2()),_ex1_2());
-		// sin(atan(x)) -> x*(1+x^2)^(-1/2)
+			return sqrt(_ex1-power(t,_ex2));
+
+		// sin(atan(x)) -> x/sqrt(1+x^2)
 		if (is_ex_the_function(x, atan))
-			return t*power(_ex1()+power(t,_ex2()),_ex_1_2());
+			return t*power(_ex1+power(t,_ex2),_ex_1_2);
 	}
 	
 	// sin(float) -> float
 	if (x.info(info_flags::numeric) && !x.info(info_flags::crational))
 		return sin(ex_to<numeric>(x));
+
+	// sin() is odd
+	if (x.info(info_flags::negative))
+		return -sin(-x);
 	
 	return sin(x).hold();
 }
@@ -296,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"));
 
 //////////
@@ -316,56 +381,63 @@ static ex cos_evalf(const ex & x)
 static ex cos_eval(const ex & x)
 {
 	// cos(n/d*Pi) -> { all known non-nested radicals }
-	const ex SixtyExOverPi = _ex60()*x/Pi;
-	ex sign = _ex1();
+	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;
-			sign = _ex_1();
+			z = *_num60_p-z;
+			sign = _ex_1;
 		}
-		if (z.is_equal(_num0()))  // cos(0)       -> 1
-			return sign*_ex1();
-		if (z.is_equal(_num5()))  // cos(Pi/12)   -> sqrt(6)/4*(1+sqrt(3)/3)
-			return sign*_ex1_4()*power(_ex6(),_ex1_2())*(_ex1()+_ex1_3()*power(_ex3(),_ex1_2()));
-		if (z.is_equal(_num10())) // cos(Pi/6)    -> sqrt(3)/2
-			return sign*_ex1_2()*power(_ex3(),_ex1_2());
-		if (z.is_equal(_num12())) // cos(Pi/5)    -> sqrt(5)/4+1/4
-			return sign*(_ex1_4()*power(_ex5(),_ex1_2())+_ex1_4());
-		if (z.is_equal(_num15())) // cos(Pi/4)    -> sqrt(2)/2
-			return sign*_ex1_2()*power(_ex2(),_ex1_2());
-		if (z.is_equal(_num20())) // cos(Pi/3)    -> 1/2
-			return sign*_ex1_2();
-		if (z.is_equal(_num24())) // cos(2/5*Pi)  -> sqrt(5)/4-1/4x
-			return sign*(_ex1_4()*power(_ex5(),_ex1_2())+_ex_1_4());
-		if (z.is_equal(_num25())) // cos(5/12*Pi) -> sqrt(6)/4*(1-sqrt(3)/3)
-			return sign*_ex1_4()*power(_ex6(),_ex1_2())*(_ex1()+_ex_1_3()*power(_ex3(),_ex1_2()));
-		if (z.is_equal(_num30())) // cos(Pi/2)    -> 0
-			return sign*_ex0();
+		if (z.is_equal(*_num0_p))  // cos(0)       -> 1
+			return sign;
+		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_p)) // cos(Pi/6)    -> sqrt(3)/2
+			return sign*_ex1_2*sqrt(_ex3);
+		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_p)) // cos(Pi/4)    -> sqrt(2)/2
+			return sign*_ex1_2*sqrt(_ex2);
+		if (z.is_equal(*_num20_p)) // cos(Pi/3)    -> 1/2
+			return sign*_ex1_2;
+		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_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_p)) // cos(Pi/2)    -> 0
+			return _ex0;
 	}
-	
+
 	if (is_exactly_a<function>(x)) {
-		ex t = x.op(0);
+		const ex &t = x.op(0);
+
 		// cos(acos(x)) -> x
 		if (is_ex_the_function(x, acos))
 			return t;
-		// cos(asin(x)) -> (1-x^2)^(1/2)
+
+		// cos(asin(x)) -> sqrt(1-x^2)
 		if (is_ex_the_function(x, asin))
-			return power(_ex1()-power(t,_ex2()),_ex1_2());
-		// cos(atan(x)) -> (1+x^2)^(-1/2)
+			return sqrt(_ex1-power(t,_ex2));
+
+		// cos(atan(x)) -> 1/sqrt(1+x^2)
 		if (is_ex_the_function(x, atan))
-			return power(_ex1()+power(t,_ex2()),_ex_1_2());
+			return power(_ex1+power(t,_ex2),_ex_1_2);
 	}
 	
 	// cos(float) -> float
 	if (x.info(info_flags::numeric) && !x.info(info_flags::crational))
 		return cos(ex_to<numeric>(x));
 	
+	// cos() is even
+	if (x.info(info_flags::negative))
+		return cos(-x);
+	
 	return cos(x).hold();
 }
 
@@ -374,12 +446,24 @@ static ex cos_deriv(const ex & x, unsigned deriv_param)
 	GINAC_ASSERT(deriv_param==0);
 
 	// d/dx cos(x) -> -sin(x)
-	return _ex_1()*sin(x);
+	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"));
 
 //////////
@@ -397,46 +481,49 @@ static ex tan_evalf(const ex & x)
 static ex tan_eval(const ex & x)
 {
 	// tan(n/d*Pi) -> { all known non-nested radicals }
-	const ex SixtyExOverPi = _ex60()*x/Pi;
-	ex sign = _ex1();
+	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;
-			sign = _ex_1();
+			z = *_num60_p-z;
+			sign = _ex_1;
 		}
-		if (z.is_equal(_num0()))  // tan(0)       -> 0
-			return _ex0();
-		if (z.is_equal(_num5()))  // tan(Pi/12)   -> 2-sqrt(3)
-			return sign*(_ex2()-power(_ex3(),_ex1_2()));
-		if (z.is_equal(_num10())) // tan(Pi/6)    -> sqrt(3)/3
-			return sign*_ex1_3()*power(_ex3(),_ex1_2());
-		if (z.is_equal(_num15())) // tan(Pi/4)    -> 1
-			return sign*_ex1();
-		if (z.is_equal(_num20())) // tan(Pi/3)    -> sqrt(3)
-			return sign*power(_ex3(),_ex1_2());
-		if (z.is_equal(_num25())) // tan(5/12*Pi) -> 2+sqrt(3)
-			return sign*(power(_ex3(),_ex1_2())+_ex2());
-		if (z.is_equal(_num30())) // tan(Pi/2)    -> infinity
+		if (z.is_equal(*_num0_p))  // tan(0)       -> 0
+			return _ex0;
+		if (z.is_equal(*_num5_p))  // tan(Pi/12)   -> 2-sqrt(3)
+			return sign*(_ex2-sqrt(_ex3));
+		if (z.is_equal(*_num10_p)) // tan(Pi/6)    -> sqrt(3)/3
+			return sign*_ex1_3*sqrt(_ex3);
+		if (z.is_equal(*_num15_p)) // tan(Pi/4)    -> 1
+			return sign;
+		if (z.is_equal(*_num20_p)) // tan(Pi/3)    -> sqrt(3)
+			return sign*sqrt(_ex3);
+		if (z.is_equal(*_num25_p)) // tan(5/12*Pi) -> 2+sqrt(3)
+			return sign*(sqrt(_ex3)+_ex2);
+		if (z.is_equal(*_num30_p)) // tan(Pi/2)    -> infinity
 			throw (pole_error("tan_eval(): simple pole",1));
 	}
-	
+
 	if (is_exactly_a<function>(x)) {
-		ex t = x.op(0);
+		const ex &t = x.op(0);
+
 		// tan(atan(x)) -> x
 		if (is_ex_the_function(x, atan))
 			return t;
-		// tan(asin(x)) -> x*(1+x^2)^(-1/2)
+
+		// tan(asin(x)) -> x/sqrt(1+x^2)
 		if (is_ex_the_function(x, asin))
-			return t*power(_ex1()-power(t,_ex2()),_ex_1_2());
-		// tan(acos(x)) -> (1-x^2)^(1/2)/x
+			return t*power(_ex1-power(t,_ex2),_ex_1_2);
+
+		// tan(acos(x)) -> sqrt(1-x^2)/x
 		if (is_ex_the_function(x, acos))
-			return power(t,_ex_1())*power(_ex1()-power(t,_ex2()),_ex1_2());
+			return power(t,_ex_1)*sqrt(_ex1-power(t,_ex2));
 	}
 	
 	// tan(float) -> float
@@ -444,6 +531,10 @@ static ex tan_eval(const ex & x)
 		return tan(ex_to<numeric>(x));
 	}
 	
+	// tan() is odd
+	if (x.info(info_flags::negative))
+		return -tan(-x);
+	
 	return tan(x).hold();
 }
 
@@ -452,7 +543,21 @@ static ex tan_deriv(const ex & x, unsigned deriv_param)
 	GINAC_ASSERT(deriv_param==0);
 	
 	// d/dx tan(x) -> 1+tan(x)^2;
-	return (_ex1()+power(tan(x),_ex2()));
+	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,
@@ -460,21 +565,23 @@ static ex tan_series(const ex &x,
                      int order,
                      unsigned options)
 {
-	GINAC_ASSERT(is_exactly_a<symbol>(rel.lhs()));
+	GINAC_ASSERT(is_a<symbol>(rel.lhs()));
 	// method:
 	// Taylor series where there is no pole falls back to tan_deriv.
 	// On a pole simply expand sin(x)/cos(x).
-	const ex x_pt = x.subs(rel);
+	const ex x_pt = x.subs(rel, subs_options::no_pattern);
 	if (!(2*x_pt/Pi).info(info_flags::odd))
 		throw do_taylor();  // caught by function::series()
 	// if we got here we have to care for a simple pole
-	return (sin(x)/cos(x)).series(rel, order+2, options);
+	return (sin(x)/cos(x)).series(rel, order, options);
 }
 
 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"));
 
 //////////
@@ -492,24 +599,34 @@ static ex asin_evalf(const ex & x)
 static ex asin_eval(const ex & x)
 {
 	if (x.info(info_flags::numeric)) {
+
 		// asin(0) -> 0
 		if (x.is_zero())
 			return x;
+
 		// asin(1/2) -> Pi/6
-		if (x.is_equal(_ex1_2()))
+		if (x.is_equal(_ex1_2))
 			return numeric(1,6)*Pi;
+
 		// asin(1) -> Pi/2
-		if (x.is_equal(_ex1()))
-			return _num1_2()*Pi;
+		if (x.is_equal(_ex1))
+			return _ex1_2*Pi;
+
 		// asin(-1/2) -> -Pi/6
-		if (x.is_equal(_ex_1_2()))
+		if (x.is_equal(_ex_1_2))
 			return numeric(-1,6)*Pi;
+
 		// asin(-1) -> -Pi/2
-		if (x.is_equal(_ex_1()))
-			return _num_1_2()*Pi;
+		if (x.is_equal(_ex_1))
+			return _ex_1_2*Pi;
+
 		// asin(float) -> float
 		if (!x.info(info_flags::crational))
 			return asin(ex_to<numeric>(x));
+
+		// asin() is odd
+		if (x.info(info_flags::negative))
+			return -asin(-x);
 	}
 	
 	return asin(x).hold();
@@ -520,7 +637,7 @@ static ex asin_deriv(const ex & x, unsigned deriv_param)
 	GINAC_ASSERT(deriv_param==0);
 	
 	// d/dx asin(x) -> 1/sqrt(1-x^2)
-	return power(1-power(x,_ex2()),_ex_1_2());
+	return power(1-power(x,_ex2),_ex_1_2);
 }
 
 REGISTER_FUNCTION(asin, eval_func(asin_eval).
@@ -543,24 +660,34 @@ static ex acos_evalf(const ex & x)
 static ex acos_eval(const ex & x)
 {
 	if (x.info(info_flags::numeric)) {
+
 		// acos(1) -> 0
-		if (x.is_equal(_ex1()))
-			return _ex0();
+		if (x.is_equal(_ex1))
+			return _ex0;
+
 		// acos(1/2) -> Pi/3
-		if (x.is_equal(_ex1_2()))
-			return _ex1_3()*Pi;
+		if (x.is_equal(_ex1_2))
+			return _ex1_3*Pi;
+
 		// acos(0) -> Pi/2
 		if (x.is_zero())
-			return _ex1_2()*Pi;
+			return _ex1_2*Pi;
+
 		// acos(-1/2) -> 2/3*Pi
-		if (x.is_equal(_ex_1_2()))
+		if (x.is_equal(_ex_1_2))
 			return numeric(2,3)*Pi;
+
 		// acos(-1) -> Pi
-		if (x.is_equal(_ex_1()))
+		if (x.is_equal(_ex_1))
 			return Pi;
+
 		// acos(float) -> float
 		if (!x.info(info_flags::crational))
 			return acos(ex_to<numeric>(x));
+
+		// acos(-x) -> Pi-acos(x)
+		if (x.info(info_flags::negative))
+			return Pi-acos(-x);
 	}
 	
 	return acos(x).hold();
@@ -571,7 +698,7 @@ static ex acos_deriv(const ex & x, unsigned deriv_param)
 	GINAC_ASSERT(deriv_param==0);
 	
 	// d/dx acos(x) -> -1/sqrt(1-x^2)
-	return _ex_1()*power(1-power(x,_ex2()),_ex_1_2());
+	return -power(1-power(x,_ex2),_ex_1_2);
 }
 
 REGISTER_FUNCTION(acos, eval_func(acos_eval).
@@ -594,20 +721,29 @@ static ex atan_evalf(const ex & x)
 static ex atan_eval(const ex & x)
 {
 	if (x.info(info_flags::numeric)) {
+
 		// atan(0) -> 0
 		if (x.is_zero())
-			return _ex0();
+			return _ex0;
+
 		// atan(1) -> Pi/4
-		if (x.is_equal(_ex1()))
-			return _ex1_4()*Pi;
+		if (x.is_equal(_ex1))
+			return _ex1_4*Pi;
+
 		// atan(-1) -> -Pi/4
-		if (x.is_equal(_ex_1()))
-			return _ex_1_4()*Pi;
+		if (x.is_equal(_ex_1))
+			return _ex_1_4*Pi;
+
 		if (x.is_equal(I) || x.is_equal(-I))
 			throw (pole_error("atan_eval(): logarithmic pole",0));
+
 		// atan(float) -> float
 		if (!x.info(info_flags::crational))
 			return atan(ex_to<numeric>(x));
+
+		// atan() is odd
+		if (x.info(info_flags::negative))
+			return -atan(-x);
 	}
 	
 	return atan(x).hold();
@@ -618,7 +754,7 @@ static ex atan_deriv(const ex & x, unsigned deriv_param)
 	GINAC_ASSERT(deriv_param==0);
 
 	// d/dx atan(x) -> 1/(1+x^2)
-	return power(_ex1()+power(x,_ex2()), _ex_1());
+	return power(_ex1+power(x,_ex2), _ex_1);
 }
 
 static ex atan_series(const ex &arg,
@@ -626,7 +762,7 @@ static ex atan_series(const ex &arg,
                       int order,
                       unsigned options)
 {
-	GINAC_ASSERT(is_exactly_a<symbol>(rel.lhs()));
+	GINAC_ASSERT(is_a<symbol>(rel.lhs()));
 	// method:
 	// Taylor series where there is no pole or cut falls back to atan_deriv.
 	// There are two branch cuts, one runnig from I up the imaginary axis and
@@ -635,10 +771,10 @@ static ex atan_series(const ex &arg,
 	// On the branch cuts and the poles series expand
 	//     (log(1+I*x)-log(1-I*x))/(2*I)
 	// instead.
-	const ex arg_pt = arg.subs(rel);
+	const ex arg_pt = arg.subs(rel, subs_options::no_pattern);
 	if (!(I*arg_pt).info(info_flags::real))
 		throw do_taylor();     // Re(x) != 0
-	if ((I*arg_pt).info(info_flags::real) && abs(I*arg_pt)<_ex1())
+	if ((I*arg_pt).info(info_flags::real) && abs(I*arg_pt)<_ex1)
 		throw do_taylor();     // Re(x) == 0, but abs(x)<1
 	// care for the poles, using the defining formula for atan()...
 	if (arg_pt.is_equal(I) || arg_pt.is_equal(-I))
@@ -648,17 +784,17 @@ static ex atan_series(const ex &arg,
 		// This is the branch cut: assemble the primitive series manually and
 		// then add the corresponding complex step function.
 		const symbol &s = ex_to<symbol>(rel.lhs());
-		const ex point = rel.rhs();
+		const ex &point = rel.rhs();
 		const symbol foo;
-		const ex replarg = series(atan(arg), s==foo, order).subs(foo==point);
-		ex Order0correction = replarg.op(0)+csgn(arg)*Pi*_ex_1_2();
-		if ((I*arg_pt)<_ex0())
-			Order0correction += log((I*arg_pt+_ex_1())/(I*arg_pt+_ex1()))*I*_ex_1_2();
+		const ex replarg = series(atan(arg), s==foo, order).subs(foo==point, subs_options::no_pattern);
+		ex Order0correction = replarg.op(0)+csgn(arg)*Pi*_ex_1_2;
+		if ((I*arg_pt)<_ex0)
+			Order0correction += log((I*arg_pt+_ex_1)/(I*arg_pt+_ex1))*I*_ex_1_2;
 		else
-			Order0correction += log((I*arg_pt+_ex1())/(I*arg_pt+_ex_1()))*I*_ex1_2();
+			Order0correction += log((I*arg_pt+_ex1)/(I*arg_pt+_ex_1))*I*_ex1_2;
 		epvector seq;
-		seq.push_back(expair(Order0correction, _ex0()));
-		seq.push_back(expair(Order(_ex1()), order));
+		seq.push_back(expair(Order0correction, _ex0));
+		seq.push_back(expair(Order(_ex1), order));
 		return series(replarg - pseries(rel, seq), rel, order);
 	}
 	throw do_taylor();
@@ -677,19 +813,77 @@ REGISTER_FUNCTION(atan, eval_func(atan_eval).
 static ex atan2_evalf(const ex &y, const ex &x)
 {
 	if (is_exactly_a<numeric>(y) && is_exactly_a<numeric>(x))
-		return atan2(ex_to<numeric>(y), ex_to<numeric>(x));
+		return atan(ex_to<numeric>(y), ex_to<numeric>(x));
 	
 	return atan2(y, x).hold();
 }
 
 static ex atan2_eval(const ex & y, const ex & x)
 {
-	if (y.info(info_flags::numeric) && !y.info(info_flags::crational) &&
-		x.info(info_flags::numeric) && !x.info(info_flags::crational)) {
-		return atan2_evalf(y,x);
+	if (y.is_zero()) {
+
+		// 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 negative -> -Pi
+		if (x.info(info_flags::negative))
+			return _ex_1*Pi;
 	}
-	
-	return atan2(y,x).hold();
+
+	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 negative -> -Pi/2
+		if (y.info(info_flags::negative))
+			return _ex_1_2*Pi;
+	}
+
+	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 negative -> -3/4*Pi
+		if (y.info(info_flags::negative))
+			return numeric(-3, 4)*Pi;
+	}
+
+	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 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(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();
 }    
 
 static ex atan2_deriv(const ex & y, const ex & x, unsigned deriv_param)
@@ -698,10 +892,10 @@ static ex atan2_deriv(const ex & y, const ex & x, unsigned deriv_param)
 	
 	if (deriv_param==0) {
 		// d/dy atan(y,x)
-		return x*power(power(x,_ex2())+power(y,_ex2()),_ex_1());
+		return x*power(power(x,_ex2)+power(y,_ex2),_ex_1);
 	}
 	// d/dx atan(y,x)
-	return -y*power(power(x,_ex2())+power(y,_ex2()),_ex_1());
+	return -y*power(power(x,_ex2)+power(y,_ex2),_ex_1);
 }
 
 REGISTER_FUNCTION(atan2, eval_func(atan2_eval).
@@ -723,10 +917,18 @@ static ex sinh_evalf(const ex & x)
 static ex sinh_eval(const ex & x)
 {
 	if (x.info(info_flags::numeric)) {
-		if (x.is_zero())  // sinh(0) -> 0
-			return _ex0();        
-		if (!x.info(info_flags::crational))  // sinh(float) -> float
+
+		// sinh(0) -> 0
+		if (x.is_zero())
+			return _ex0;        
+
+		// sinh(float) -> float
+		if (!x.info(info_flags::crational))
 			return sinh(ex_to<numeric>(x));
+
+		// sinh() is odd
+		if (x.info(info_flags::negative))
+			return -sinh(-x);
 	}
 	
 	if ((x/Pi).info(info_flags::numeric) &&
@@ -734,16 +936,19 @@ static ex sinh_eval(const ex & x)
 		return I*sin(x/I);
 	
 	if (is_exactly_a<function>(x)) {
-		ex t = x.op(0);
+		const ex &t = x.op(0);
+
 		// sinh(asinh(x)) -> x
 		if (is_ex_the_function(x, asinh))
 			return t;
-		// sinh(acosh(x)) -> (x-1)^(1/2) * (x+1)^(1/2)
+
+		// sinh(acosh(x)) -> sqrt(x-1) * sqrt(x+1)
 		if (is_ex_the_function(x, acosh))
-			return power(t-_ex1(),_ex1_2())*power(t+_ex1(),_ex1_2());
-		// sinh(atanh(x)) -> x*(1-x^2)^(-1/2)
+			return sqrt(t-_ex1)*sqrt(t+_ex1);
+
+		// sinh(atanh(x)) -> x/sqrt(1-x^2)
 		if (is_ex_the_function(x, atanh))
-			return t*power(_ex1()-power(t,_ex2()),_ex_1_2());
+			return t*power(_ex1-power(t,_ex2),_ex_1_2);
 	}
 	
 	return sinh(x).hold();
@@ -757,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"));
 
 //////////
@@ -777,10 +994,18 @@ static ex cosh_evalf(const ex & x)
 static ex cosh_eval(const ex & x)
 {
 	if (x.info(info_flags::numeric)) {
-		if (x.is_zero())  // cosh(0) -> 1
-			return _ex1();
-		if (!x.info(info_flags::crational))  // cosh(float) -> float
+
+		// cosh(0) -> 1
+		if (x.is_zero())
+			return _ex1;
+
+		// cosh(float) -> float
+		if (!x.info(info_flags::crational))
 			return cosh(ex_to<numeric>(x));
+
+		// cosh() is even
+		if (x.info(info_flags::negative))
+			return cosh(-x);
 	}
 	
 	if ((x/Pi).info(info_flags::numeric) &&
@@ -788,16 +1013,19 @@ static ex cosh_eval(const ex & x)
 		return cos(x/I);
 	
 	if (is_exactly_a<function>(x)) {
-		ex t = x.op(0);
+		const ex &t = x.op(0);
+
 		// cosh(acosh(x)) -> x
 		if (is_ex_the_function(x, acosh))
 			return t;
-		// cosh(asinh(x)) -> (1+x^2)^(1/2)
+
+		// cosh(asinh(x)) -> sqrt(1+x^2)
 		if (is_ex_the_function(x, asinh))
-			return power(_ex1()+power(t,_ex2()),_ex1_2());
-		// cosh(atanh(x)) -> (1-x^2)^(-1/2)
+			return sqrt(_ex1+power(t,_ex2));
+
+		// cosh(atanh(x)) -> 1/sqrt(1-x^2)
 		if (is_ex_the_function(x, atanh))
-			return power(_ex1()-power(t,_ex2()),_ex_1_2());
+			return power(_ex1-power(t,_ex2),_ex_1_2);
 	}
 	
 	return cosh(x).hold();
@@ -811,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"));
 
 //////////
@@ -831,10 +1071,18 @@ static ex tanh_evalf(const ex & x)
 static ex tanh_eval(const ex & x)
 {
 	if (x.info(info_flags::numeric)) {
-		if (x.is_zero())  // tanh(0) -> 0
-			return _ex0();
-		if (!x.info(info_flags::crational))  // tanh(float) -> float
+
+		// tanh(0) -> 0
+		if (x.is_zero())
+			return _ex0;
+
+		// tanh(float) -> float
+		if (!x.info(info_flags::crational))
 			return tanh(ex_to<numeric>(x));
+
+		// tanh() is odd
+		if (x.info(info_flags::negative))
+			return -tanh(-x);
 	}
 	
 	if ((x/Pi).info(info_flags::numeric) &&
@@ -842,16 +1090,19 @@ static ex tanh_eval(const ex & x)
 		return I*tan(x/I);
 	
 	if (is_exactly_a<function>(x)) {
-		ex t = x.op(0);
+		const ex &t = x.op(0);
+
 		// tanh(atanh(x)) -> x
 		if (is_ex_the_function(x, atanh))
 			return t;
-		// tanh(asinh(x)) -> x*(1+x^2)^(-1/2)
+
+		// tanh(asinh(x)) -> x/sqrt(1+x^2)
 		if (is_ex_the_function(x, asinh))
-			return t*power(_ex1()+power(t,_ex2()),_ex_1_2());
-		// tanh(acosh(x)) -> (x-1)^(1/2)*(x+1)^(1/2)/x
+			return t*power(_ex1+power(t,_ex2),_ex_1_2);
+
+		// tanh(acosh(x)) -> sqrt(x-1)*sqrt(x+1)/x
 		if (is_ex_the_function(x, acosh))
-			return power(t-_ex1(),_ex1_2())*power(t+_ex1(),_ex1_2())*power(t,_ex_1());
+			return sqrt(t-_ex1)*sqrt(t+_ex1)*power(t,_ex_1);
 	}
 	
 	return tanh(x).hold();
@@ -862,7 +1113,7 @@ static ex tanh_deriv(const ex & x, unsigned deriv_param)
 	GINAC_ASSERT(deriv_param==0);
 	
 	// d/dx tanh(x) -> 1-tanh(x)^2
-	return _ex1()-power(tanh(x),_ex2());
+	return _ex1-power(tanh(x),_ex2);
 }
 
 static ex tanh_series(const ex &x,
@@ -870,21 +1121,37 @@ static ex tanh_series(const ex &x,
                       int order,
                       unsigned options)
 {
-	GINAC_ASSERT(is_exactly_a<symbol>(rel.lhs()));
+	GINAC_ASSERT(is_a<symbol>(rel.lhs()));
 	// method:
 	// Taylor series where there is no pole falls back to tanh_deriv.
 	// On a pole simply expand sinh(x)/cosh(x).
-	const ex x_pt = x.subs(rel);
+	const ex x_pt = x.subs(rel, subs_options::no_pattern);
 	if (!(2*I*x_pt/Pi).info(info_flags::odd))
 		throw do_taylor();  // caught by function::series()
 	// if we got here we have to care for a simple pole
-	return (sinh(x)/cosh(x)).series(rel, order+2, options);
+	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"));
 
 //////////
@@ -902,12 +1169,18 @@ static ex asinh_evalf(const ex & x)
 static ex asinh_eval(const ex & x)
 {
 	if (x.info(info_flags::numeric)) {
+
 		// asinh(0) -> 0
 		if (x.is_zero())
-			return _ex0();
+			return _ex0;
+
 		// asinh(float) -> float
 		if (!x.info(info_flags::crational))
 			return asinh(ex_to<numeric>(x));
+
+		// asinh() is odd
+		if (x.info(info_flags::negative))
+			return -asinh(-x);
 	}
 	
 	return asinh(x).hold();
@@ -918,7 +1191,7 @@ static ex asinh_deriv(const ex & x, unsigned deriv_param)
 	GINAC_ASSERT(deriv_param==0);
 	
 	// d/dx asinh(x) -> 1/sqrt(1+x^2)
-	return power(_ex1()+power(x,_ex2()),_ex_1_2());
+	return power(_ex1+power(x,_ex2),_ex_1_2);
 }
 
 REGISTER_FUNCTION(asinh, eval_func(asinh_eval).
@@ -940,18 +1213,26 @@ static ex acosh_evalf(const ex & x)
 static ex acosh_eval(const ex & x)
 {
 	if (x.info(info_flags::numeric)) {
+
 		// acosh(0) -> Pi*I/2
 		if (x.is_zero())
 			return Pi*I*numeric(1,2);
+
 		// acosh(1) -> 0
-		if (x.is_equal(_ex1()))
-			return _ex0();
+		if (x.is_equal(_ex1))
+			return _ex0;
+
 		// acosh(-1) -> Pi*I
-		if (x.is_equal(_ex_1()))
+		if (x.is_equal(_ex_1))
 			return Pi*I;
+
 		// acosh(float) -> float
 		if (!x.info(info_flags::crational))
 			return acosh(ex_to<numeric>(x));
+
+		// acosh(-x) -> Pi*I-acosh(x)
+		if (x.info(info_flags::negative))
+			return Pi*I-acosh(-x);
 	}
 	
 	return acosh(x).hold();
@@ -962,7 +1243,7 @@ static ex acosh_deriv(const ex & x, unsigned deriv_param)
 	GINAC_ASSERT(deriv_param==0);
 	
 	// d/dx acosh(x) -> 1/(sqrt(x-1)*sqrt(x+1))
-	return power(x+_ex_1(),_ex_1_2())*power(x+_ex1(),_ex_1_2());
+	return power(x+_ex_1,_ex_1_2)*power(x+_ex1,_ex_1_2);
 }
 
 REGISTER_FUNCTION(acosh, eval_func(acosh_eval).
@@ -984,15 +1265,22 @@ static ex atanh_evalf(const ex & x)
 static ex atanh_eval(const ex & x)
 {
 	if (x.info(info_flags::numeric)) {
+
 		// atanh(0) -> 0
 		if (x.is_zero())
-			return _ex0();
+			return _ex0;
+
 		// atanh({+|-}1) -> throw
-		if (x.is_equal(_ex1()) || x.is_equal(_ex_1()))
+		if (x.is_equal(_ex1) || x.is_equal(_ex_1))
 			throw (pole_error("atanh_eval(): logarithmic pole",0));
+
 		// atanh(float) -> float
 		if (!x.info(info_flags::crational))
 			return atanh(ex_to<numeric>(x));
+
+		// atanh() is odd
+		if (x.info(info_flags::negative))
+			return -atanh(-x);
 	}
 	
 	return atanh(x).hold();
@@ -1003,7 +1291,7 @@ static ex atanh_deriv(const ex & x, unsigned deriv_param)
 	GINAC_ASSERT(deriv_param==0);
 	
 	// d/dx atanh(x) -> 1/(1-x^2)
-	return power(_ex1()-power(x,_ex2()),_ex_1());
+	return power(_ex1-power(x,_ex2),_ex_1);
 }
 
 static ex atanh_series(const ex &arg,
@@ -1011,7 +1299,7 @@ static ex atanh_series(const ex &arg,
                        int order,
                        unsigned options)
 {
-	GINAC_ASSERT(is_exactly_a<symbol>(rel.lhs()));
+	GINAC_ASSERT(is_a<symbol>(rel.lhs()));
 	// method:
 	// Taylor series where there is no pole or cut falls back to atanh_deriv.
 	// There are two branch cuts, one runnig from 1 up the real axis and one
@@ -1019,31 +1307,31 @@ static ex atanh_series(const ex &arg,
 	// On the branch cuts and the poles series expand
 	//     (log(1+x)-log(1-x))/2
 	// instead.
-	const ex arg_pt = arg.subs(rel);
+	const ex arg_pt = arg.subs(rel, subs_options::no_pattern);
 	if (!(arg_pt).info(info_flags::real))
 		throw do_taylor();     // Im(x) != 0
-	if ((arg_pt).info(info_flags::real) && abs(arg_pt)<_ex1())
+	if ((arg_pt).info(info_flags::real) && abs(arg_pt)<_ex1)
 		throw do_taylor();     // Im(x) == 0, but abs(x)<1
 	// care for the poles, using the defining formula for atanh()...
-	if (arg_pt.is_equal(_ex1()) || arg_pt.is_equal(_ex_1()))
-		return ((log(_ex1()+arg)-log(_ex1()-arg))*_ex1_2()).series(rel, order, options);
+	if (arg_pt.is_equal(_ex1) || arg_pt.is_equal(_ex_1))
+		return ((log(_ex1+arg)-log(_ex1-arg))*_ex1_2).series(rel, order, options);
 	// ...and the branch cuts (the discontinuity at the cut being just I*Pi)
 	if (!(options & series_options::suppress_branchcut)) {
  		// method:
  		// This is the branch cut: assemble the primitive series manually and
  		// then add the corresponding complex step function.
  		const symbol &s = ex_to<symbol>(rel.lhs());
- 		const ex point = rel.rhs();
+ 		const ex &point = rel.rhs();
  		const symbol foo;
- 		const ex replarg = series(atanh(arg), s==foo, order).subs(foo==point);
-		ex Order0correction = replarg.op(0)+csgn(I*arg)*Pi*I*_ex1_2();
-		if (arg_pt<_ex0())
-			Order0correction += log((arg_pt+_ex_1())/(arg_pt+_ex1()))*_ex1_2();
+ 		const ex replarg = series(atanh(arg), s==foo, order).subs(foo==point, subs_options::no_pattern);
+		ex Order0correction = replarg.op(0)+csgn(I*arg)*Pi*I*_ex1_2;
+		if (arg_pt<_ex0)
+			Order0correction += log((arg_pt+_ex_1)/(arg_pt+_ex1))*_ex1_2;
 		else
-			Order0correction += log((arg_pt+_ex1())/(arg_pt+_ex_1()))*_ex_1_2();
+			Order0correction += log((arg_pt+_ex1)/(arg_pt+_ex_1))*_ex_1_2;
  		epvector seq;
-		seq.push_back(expair(Order0correction, _ex0()));
- 		seq.push_back(expair(Order(_ex1()), order));
+		seq.push_back(expair(Order0correction, _ex0));
+ 		seq.push_back(expair(Order(_ex1), order));
  		return series(replarg - pseries(rel, seq), rel, order);
 	}
 	throw do_taylor();