X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Finifcns_trans.cpp;h=239b1ea2ea1d8a3130130a9e32ee77d28458cf3b;hp=89b0454292caf4a0ec4cebe957b590b9e657e55f;hb=a49cc30f7d44e7ac93d41c4beb2d9e9a325a3728;hpb=ed21ddd5e2bc0af018c10934342f526d0ae4b7a7

diff --git a/ginac/inifcns_trans.cpp b/ginac/inifcns_trans.cpp
index 89b04542..239b1ea2 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-2003 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
@@ -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"
@@ -42,30 +43,29 @@ namespace GiNaC {
 
 static ex exp_evalf(const ex & x)
 {
-	BEGIN_TYPECHECK
-		TYPECHECK(x,numeric)
-	END_TYPECHECK(exp(x))
+	if (is_exactly_a<numeric>(x))
+		return exp(ex_to<numeric>(x));
 	
-	return exp(ex_to<numeric>(x)); // -> numeric exp(numeric)
+	return exp(x).hold();
 }
 
 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}
-	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);
+		if (z.is_equal(_num0))
+			return _ex1;
+		if (z.is_equal(_num1))
 			return ex(I);
-		if (z.is_equal(_num2()))
-			return _ex_1();
-		if (z.is_equal(_num3()))
+		if (z.is_equal(_num2))
+			return _ex_1;
+		if (z.is_equal(_num3))
 			return ex(-I);
 	}
 	// exp(log(x)) -> x
@@ -74,7 +74,7 @@ static ex exp_eval(const ex & x)
 	
 	// exp(float)
 	if (x.info(info_flags::numeric) && !x.info(info_flags::crational))
-		return exp_evalf(x);
+		return exp(ex_to<numeric>(x));
 	
 	return exp(x).hold();
 }
@@ -98,11 +98,10 @@ REGISTER_FUNCTION(exp, eval_func(exp_eval).
 
 static ex log_evalf(const ex & x)
 {
-	BEGIN_TYPECHECK
-		TYPECHECK(x,numeric)
-	END_TYPECHECK(log(x))
+	if (is_exactly_a<numeric>(x))
+		return log(ex_to<numeric>(x));
 	
-	return log(ex_to<numeric>(x)); // -> numeric log(numeric)
+	return log(x).hold();
 }
 
 static ex log_eval(const ex & x)
@@ -112,21 +111,21 @@ static ex log_eval(const ex & x)
 			throw(pole_error("log_eval(): log(0)",0));
 		if (x.info(info_flags::real) && 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*_num1_2);
 		if (x.is_equal(-I))      // log(-I) -> -Pi*I/2
-			return (Pi*I*_num_1_2());
+			return (Pi*I*_num_1_2);
 		// log(float)
 		if (!x.info(info_flags::crational))
-			return log_evalf(x);
+			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);
+		const ex &t = x.op(0);
 		if (t.info(info_flags::numeric)) {
-			numeric nt = ex_to<numeric>(t);
+			const numeric &nt = ex_to<numeric>(t);
 			if (nt.is_real())
 				return t;
 		}
@@ -140,7 +139,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,
@@ -148,12 +147,12 @@ static ex log_series(const ex &arg,
                      int order,
                      unsigned options)
 {
-	GINAC_ASSERT(is_ex_exactly_of_type(rel.lhs(),symbol));
+	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;
 	}
@@ -166,27 +165,35 @@ static ex log_series(const ex &arg,
 		// This is the branch point: Series expand the argument first, then
 		// trivially factorize it to isolate that part which has constant
 		// leading coefficient in this fashion:
-		//   x^n + Order(x^(n+m))  ->  x^n * (1 + Order(x^m)).
+		//   x^n + x^(n+1) +...+ Order(x^(n+m))  ->  x^n * (1 + x +...+ Order(x^m)).
 		// Return a plain n*log(x) for the x^n part and series expand the
 		// other part.  Add them together and reexpand again in order to have
 		// one unnested pseries object.  All this also works for negative n.
-		const pseries argser = ex_to<pseries>(arg.series(rel, order, options));
-		const symbol *s = static_cast<symbol *>(rel.lhs().bp);
-		const ex point = rel.rhs();
-		const int n = argser.ldegree(*s);
+		pseries argser;          // series expansion of log's argument
+		unsigned extra_ord = 0;  // extra expansion order
+		do {
+			// oops, the argument expanded to a pure Order(x^something)...
+			argser = ex_to<pseries>(arg.series(rel, order+extra_ord, options));
+			++extra_ord;
+		} while (!argser.is_terminating() && argser.nops()==1);
+
+		const symbol &s = ex_to<symbol>(rel.lhs());
+		const ex &point = rel.rhs();
+		const int n = argser.ldegree(s);
 		epvector seq;
 		// construct what we carelessly called the n*log(x) term above
-		ex coeff = argser.coeff(*s, n);
+		const ex coeff = argser.coeff(s, n);
 		// 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 terms are needed
+			// in this case n more (or less) terms are needed
 			// (sadly, to generate them, we have to start from the beginning)
-			ex newarg = ex_to<pseries>((arg/coeff).series(rel, order+n, options)).shift_exponents(-n).convert_to_poly(true);
+			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);
@@ -196,13 +203,13 @@ static ex log_series(const ex &arg,
 		// method:
 		// This is the branch cut: assemble the primitive series manually and
 		// then add the corresponding complex step function.
-		const symbol *s = static_cast<symbol *>(rel.lhs().bp);
-		const ex point = rel.rhs();
+		const symbol &s = ex_to<symbol>(rel.lhs());
+		const ex &point = rel.rhs();
 		const symbol foo;
-		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()
@@ -220,65 +227,64 @@ REGISTER_FUNCTION(log, eval_func(log_eval).
 
 static ex sin_evalf(const ex & x)
 {
-	BEGIN_TYPECHECK
-	   TYPECHECK(x,numeric)
-	END_TYPECHECK(sin(x))
+	if (is_exactly_a<numeric>(x))
+		return sin(ex_to<numeric>(x));
 	
-	return sin(ex_to<numeric>(x)); // -> numeric sin(numeric)
+	return sin(x).hold();
 }
 
 static ex sin_eval(const ex & x)
 {
 	// sin(n/d*Pi) -> { all known non-nested radicals }
-	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);
+		if (z>=_num60) {
 			// wrap to interval [0, Pi)
-			z -= _num60();
-			sign = _ex_1();
+			z -= _num60;
+			sign = _ex_1;
 		}
-		if (z>_num30()) {
+		if (z>_num30) {
 			// wrap to interval [0, Pi/2)
-			z = _num60()-z;
+			z = _num60-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))  // sin(0)       -> 0
+			return _ex0;
+		if (z.is_equal(_num5))  // 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
+			return sign*(_ex1_4*sqrt(_ex5)+_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*sqrt(_ex2);
+		if (z.is_equal(_num18)) // 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
+			return sign*_ex1_2*sqrt(_ex3);
+		if (z.is_equal(_num25)) // 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
+			return sign;
 	}
 	
-	if (is_ex_exactly_of_type(x, function)) {
-		ex t = x.op(0);
+	if (is_exactly_a<function>(x)) {
+		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_evalf(x);
+		return sin(ex_to<numeric>(x));
 	
 	return sin(x).hold();
 }
@@ -302,65 +308,64 @@ REGISTER_FUNCTION(sin, eval_func(sin_eval).
 
 static ex cos_evalf(const ex & x)
 {
-	BEGIN_TYPECHECK
-		TYPECHECK(x,numeric)
-	END_TYPECHECK(cos(x))
+	if (is_exactly_a<numeric>(x))
+		return cos(ex_to<numeric>(x));
 	
-	return cos(ex_to<numeric>(x)); // -> numeric cos(numeric)
+	return cos(x).hold();
 }
 
 static ex cos_eval(const ex & x)
 {
 	// cos(n/d*Pi) -> { all known non-nested radicals }
-	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);
+		if (z>=_num60) {
 			// wrap to interval [0, Pi)
-			z = _num120()-z;
+			z = _num120-z;
 		}
-		if (z>=_num30()) {
+		if (z>=_num30) {
 			// wrap to interval [0, Pi/2)
-			z = _num60()-z;
-			sign = _ex_1();
+			z = _num60-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))  // cos(0)       -> 1
+			return sign;
+		if (z.is_equal(_num5))  // 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
+			return sign*_ex1_2*sqrt(_ex3);
+		if (z.is_equal(_num12)) // 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
+			return sign*_ex1_2*sqrt(_ex2);
+		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*sqrt(_ex5)+_ex_1_4);
+		if (z.is_equal(_num25)) // 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
+			return _ex0;
 	}
 	
-	if (is_ex_exactly_of_type(x, function)) {
-		ex t = x.op(0);
+	if (is_exactly_a<function>(x)) {
+		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_evalf(x);
+		return cos(ex_to<numeric>(x));
 	
 	return cos(x).hold();
 }
@@ -370,7 +375,7 @@ 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);
 }
 
 REGISTER_FUNCTION(cos, eval_func(cos_eval).
@@ -384,61 +389,60 @@ REGISTER_FUNCTION(cos, eval_func(cos_eval).
 
 static ex tan_evalf(const ex & x)
 {
-	BEGIN_TYPECHECK
-	   TYPECHECK(x,numeric)
-	END_TYPECHECK(tan(x)) // -> numeric tan(numeric)
+	if (is_exactly_a<numeric>(x))
+		return tan(ex_to<numeric>(x));
 	
-	return tan(ex_to<numeric>(x));
+	return tan(x).hold();
 }
 
 static ex tan_eval(const ex & x)
 {
 	// tan(n/d*Pi) -> { all known non-nested radicals }
-	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);
+		if (z>=_num60) {
 			// wrap to interval [0, Pi)
-			z -= _num60();
+			z -= _num60;
 		}
-		if (z>=_num30()) {
+		if (z>=_num30) {
 			// wrap to interval [0, Pi/2)
-			z = _num60()-z;
-			sign = _ex_1();
+			z = _num60-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))  // tan(0)       -> 0
+			return _ex0;
+		if (z.is_equal(_num5))  // tan(Pi/12)   -> 2-sqrt(3)
+			return sign*(_ex2-sqrt(_ex3));
+		if (z.is_equal(_num10)) // tan(Pi/6)    -> sqrt(3)/3
+			return sign*_ex1_3*sqrt(_ex3);
+		if (z.is_equal(_num15)) // tan(Pi/4)    -> 1
+			return sign;
+		if (z.is_equal(_num20)) // tan(Pi/3)    -> sqrt(3)
+			return sign*sqrt(_ex3);
+		if (z.is_equal(_num25)) // tan(5/12*Pi) -> 2+sqrt(3)
+			return sign*(sqrt(_ex3)+_ex2);
+		if (z.is_equal(_num30)) // tan(Pi/2)    -> infinity
 			throw (pole_error("tan_eval(): simple pole",1));
 	}
 	
-	if (is_ex_exactly_of_type(x, function)) {
-		ex t = x.op(0);
+	if (is_exactly_a<function>(x)) {
+		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
 	if (x.info(info_flags::numeric) && !x.info(info_flags::crational)) {
-		return tan_evalf(x);
+		return tan(ex_to<numeric>(x));
 	}
 	
 	return tan(x).hold();
@@ -449,7 +453,7 @@ 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_series(const ex &x,
@@ -457,11 +461,11 @@ static ex tan_series(const ex &x,
                      int order,
                      unsigned options)
 {
-	GINAC_ASSERT(is_ex_exactly_of_type(rel.lhs(),symbol));
+	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
@@ -480,11 +484,10 @@ REGISTER_FUNCTION(tan, eval_func(tan_eval).
 
 static ex asin_evalf(const ex & x)
 {
-	BEGIN_TYPECHECK
-	   TYPECHECK(x,numeric)
-	END_TYPECHECK(asin(x))
+	if (is_exactly_a<numeric>(x))
+		return asin(ex_to<numeric>(x));
 	
-	return asin(ex_to<numeric>(x)); // -> numeric asin(numeric)
+	return asin(x).hold();
 }
 
 static ex asin_eval(const ex & x)
@@ -494,20 +497,20 @@ static ex asin_eval(const ex & x)
 		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 _num1_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 _num_1_2*Pi;
 		// asin(float) -> float
 		if (!x.info(info_flags::crational))
-			return asin_evalf(x);
+			return asin(ex_to<numeric>(x));
 	}
 	
 	return asin(x).hold();
@@ -518,7 +521,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).
@@ -532,34 +535,33 @@ REGISTER_FUNCTION(asin, eval_func(asin_eval).
 
 static ex acos_evalf(const ex & x)
 {
-	BEGIN_TYPECHECK
-	   TYPECHECK(x,numeric)
-	END_TYPECHECK(acos(x))
+	if (is_exactly_a<numeric>(x))
+		return acos(ex_to<numeric>(x));
 	
-	return acos(ex_to<numeric>(x)); // -> numeric acos(numeric)
+	return acos(x).hold();
 }
 
 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_evalf(x);
+			return acos(ex_to<numeric>(x));
 	}
 	
 	return acos(x).hold();
@@ -570,7 +572,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).
@@ -584,11 +586,10 @@ REGISTER_FUNCTION(acos, eval_func(acos_eval).
 
 static ex atan_evalf(const ex & x)
 {
-	BEGIN_TYPECHECK
-		TYPECHECK(x,numeric)
-	END_TYPECHECK(atan(x))
+	if (is_exactly_a<numeric>(x))
+		return atan(ex_to<numeric>(x));
 	
-	return atan(ex_to<numeric>(x)); // -> numeric atan(numeric)
+	return atan(x).hold();
 }
 
 static ex atan_eval(const ex & x)
@@ -596,18 +597,18 @@ 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_evalf(x);
+			return atan(ex_to<numeric>(x));
 	}
 	
 	return atan(x).hold();
@@ -618,7 +619,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 +627,7 @@ static ex atan_series(const ex &arg,
                       int order,
                       unsigned options)
 {
-	GINAC_ASSERT(is_ex_exactly_of_type(rel.lhs(),symbol));
+	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 +636,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))
@@ -647,18 +648,18 @@ static ex atan_series(const ex &arg,
 		// method:
 		// This is the branch cut: assemble the primitive series manually and
 		// then add the corresponding complex step function.
-		const symbol *s = static_cast<symbol *>(rel.lhs().bp);
-		const ex point = rel.rhs();
+		const symbol &s = ex_to<symbol>(rel.lhs());
+		const ex &point = rel.rhs();
 		const symbol foo;
-		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();
@@ -674,14 +675,12 @@ REGISTER_FUNCTION(atan, eval_func(atan_eval).
 // inverse tangent (atan2(y,x))
 //////////
 
-static ex atan2_evalf(const ex & y, const ex & x)
+static ex atan2_evalf(const ex &y, const ex &x)
 {
-	BEGIN_TYPECHECK
-		TYPECHECK(y,numeric)
-		TYPECHECK(x,numeric)
-	END_TYPECHECK(atan2(y,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)); // -> numeric atan(numeric)
+	return atan2(y, x).hold();
 }
 
 static ex atan2_eval(const ex & y, const ex & x)
@@ -700,10 +699,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).
@@ -716,37 +715,36 @@ REGISTER_FUNCTION(atan2, eval_func(atan2_eval).
 
 static ex sinh_evalf(const ex & x)
 {
-	BEGIN_TYPECHECK
-	   TYPECHECK(x,numeric)
-	END_TYPECHECK(sinh(x))
+	if (is_exactly_a<numeric>(x))
+		return sinh(ex_to<numeric>(x));
 	
-	return sinh(ex_to<numeric>(x)); // -> numeric sinh(numeric)
+	return sinh(x).hold();
 }
 
 static ex sinh_eval(const ex & x)
 {
 	if (x.info(info_flags::numeric)) {
 		if (x.is_zero())  // sinh(0) -> 0
-			return _ex0();        
+			return _ex0;        
 		if (!x.info(info_flags::crational))  // sinh(float) -> float
-			return sinh_evalf(x);
+			return sinh(ex_to<numeric>(x));
 	}
 	
 	if ((x/Pi).info(info_flags::numeric) &&
 		ex_to<numeric>(x/Pi).real().is_zero())  // sinh(I*x) -> I*sin(x)
 		return I*sin(x/I);
 	
-	if (is_ex_exactly_of_type(x, function)) {
-		ex t = x.op(0);
+	if (is_exactly_a<function>(x)) {
+		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();
@@ -771,37 +769,36 @@ REGISTER_FUNCTION(sinh, eval_func(sinh_eval).
 
 static ex cosh_evalf(const ex & x)
 {
-	BEGIN_TYPECHECK
-	   TYPECHECK(x,numeric)
-	END_TYPECHECK(cosh(x))
+	if (is_exactly_a<numeric>(x))
+		return cosh(ex_to<numeric>(x));
 	
-	return cosh(ex_to<numeric>(x)); // -> numeric cosh(numeric)
+	return cosh(x).hold();
 }
 
 static ex cosh_eval(const ex & x)
 {
 	if (x.info(info_flags::numeric)) {
 		if (x.is_zero())  // cosh(0) -> 1
-			return _ex1();
+			return _ex1;
 		if (!x.info(info_flags::crational))  // cosh(float) -> float
-			return cosh_evalf(x);
+			return cosh(ex_to<numeric>(x));
 	}
 	
 	if ((x/Pi).info(info_flags::numeric) &&
 		ex_to<numeric>(x/Pi).real().is_zero())  // cosh(I*x) -> cos(x)
 		return cos(x/I);
 	
-	if (is_ex_exactly_of_type(x, function)) {
-		ex t = x.op(0);
+	if (is_exactly_a<function>(x)) {
+		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();
@@ -826,37 +823,36 @@ REGISTER_FUNCTION(cosh, eval_func(cosh_eval).
 
 static ex tanh_evalf(const ex & x)
 {
-	BEGIN_TYPECHECK
-	   TYPECHECK(x,numeric)
-	END_TYPECHECK(tanh(x))
+	if (is_exactly_a<numeric>(x))
+		return tanh(ex_to<numeric>(x));
 	
-	return tanh(ex_to<numeric>(x)); // -> numeric tanh(numeric)
+	return tanh(x).hold();
 }
 
 static ex tanh_eval(const ex & x)
 {
 	if (x.info(info_flags::numeric)) {
 		if (x.is_zero())  // tanh(0) -> 0
-			return _ex0();
+			return _ex0;
 		if (!x.info(info_flags::crational))  // tanh(float) -> float
-			return tanh_evalf(x);
+			return tanh(ex_to<numeric>(x));
 	}
 	
 	if ((x/Pi).info(info_flags::numeric) &&
 		ex_to<numeric>(x/Pi).real().is_zero())  // tanh(I*x) -> I*tan(x);
 		return I*tan(x/I);
 	
-	if (is_ex_exactly_of_type(x, function)) {
-		ex t = x.op(0);
+	if (is_exactly_a<function>(x)) {
+		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();
@@ -867,7 +863,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,
@@ -875,11 +871,11 @@ static ex tanh_series(const ex &x,
                       int order,
                       unsigned options)
 {
-	GINAC_ASSERT(is_ex_exactly_of_type(rel.lhs(),symbol));
+	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
@@ -898,11 +894,10 @@ REGISTER_FUNCTION(tanh, eval_func(tanh_eval).
 
 static ex asinh_evalf(const ex & x)
 {
-	BEGIN_TYPECHECK
-	   TYPECHECK(x,numeric)
-	END_TYPECHECK(asinh(x))
+	if (is_exactly_a<numeric>(x))
+		return asinh(ex_to<numeric>(x));
 	
-	return asinh(ex_to<numeric>(x)); // -> numeric asinh(numeric)
+	return asinh(x).hold();
 }
 
 static ex asinh_eval(const ex & x)
@@ -910,10 +905,10 @@ 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_evalf(x);
+			return asinh(ex_to<numeric>(x));
 	}
 	
 	return asinh(x).hold();
@@ -924,7 +919,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).
@@ -937,11 +932,10 @@ REGISTER_FUNCTION(asinh, eval_func(asinh_eval).
 
 static ex acosh_evalf(const ex & x)
 {
-	BEGIN_TYPECHECK
-	   TYPECHECK(x,numeric)
-	END_TYPECHECK(acosh(x))
+	if (is_exactly_a<numeric>(x))
+		return acosh(ex_to<numeric>(x));
 	
-	return acosh(ex_to<numeric>(x)); // -> numeric acosh(numeric)
+	return acosh(x).hold();
 }
 
 static ex acosh_eval(const ex & x)
@@ -951,14 +945,14 @@ static ex acosh_eval(const ex & x)
 		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_evalf(x);
+			return acosh(ex_to<numeric>(x));
 	}
 	
 	return acosh(x).hold();
@@ -969,7 +963,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).
@@ -982,11 +976,10 @@ REGISTER_FUNCTION(acosh, eval_func(acosh_eval).
 
 static ex atanh_evalf(const ex & x)
 {
-	BEGIN_TYPECHECK
-	   TYPECHECK(x,numeric)
-	END_TYPECHECK(atanh(x))
+	if (is_exactly_a<numeric>(x))
+		return atanh(ex_to<numeric>(x));
 	
-	return atanh(ex_to<numeric>(x)); // -> numeric atanh(numeric)
+	return atanh(x).hold();
 }
 
 static ex atanh_eval(const ex & x)
@@ -994,13 +987,13 @@ 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_evalf(x);
+			return atanh(ex_to<numeric>(x));
 	}
 	
 	return atanh(x).hold();
@@ -1011,7 +1004,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,
@@ -1019,7 +1012,7 @@ static ex atanh_series(const ex &arg,
                        int order,
                        unsigned options)
 {
-	GINAC_ASSERT(is_ex_exactly_of_type(rel.lhs(),symbol));
+	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
@@ -1027,31 +1020,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 = static_cast<symbol *>(rel.lhs().bp);
- 		const ex point = rel.rhs();
+ 		const symbol &s = ex_to<symbol>(rel.lhs());
+ 		const ex &point = rel.rhs();
  		const symbol foo;
- 		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();