/* ctan(z) = -I * ctanh(I * z) */

z = npy_ctanh@c@(npy_cpack@c@(-npy_cimag@c@(z), npy_creal@c@(z)));

return (npy_cpack@c@(npy_cimag@c@(z), -npy_creal@c@(z)));

@type@ x, y;

@type@ t, beta, s, rho, denom;

x = npy_creal@c@(z);

y = npy_cimag@c@(z);

/*

* ctanh(NaN + i 0) = NaN + i 0

*

* ctanh(NaN + i y) = NaN + i NaN for y != 0

*

* The imaginary part has the sign of x*sin(2*y), but there's no

* special effort to get this right.

*

* ctanh(+-Inf +- i Inf) = +-1 +- 0

*

* ctanh(+-Inf + i y) = +-1 + 0 sin(2y) for y finite

*

* The imaginary part of the sign is unspecified. This special

* case is only needed to avoid a spurious invalid exception when

* y is infinite.

*/

npy_copysign@c@(0, npy_isinf(y) ? y : npy_sin@c@(y) * npy_cos@c@(y)));

/*

* ctanh(x + i NAN) = NaN + i NaN

* ctanh(x +- i Inf) = NaN + i NaN

*/

if (!npy_isfinite(y))

return (npy_cpack@c@(y - y, y - y));

/*

* ctanh(+-huge + i +-y) ~= +-1 +- i 2sin(2y)/exp(2x), using the

* approximation sinh^2(huge) ~= exp(2*huge) / 4.

* We use a modified formula to avoid spurious overflow.

*/

if (x >= TANH@C@_HUGE) {

@type@ exp_mx = npy_exp@c@(-npy_fabs@c@(x));

return (npy_cpack@c@(npy_copysign@c@(1, x),

4 * npy_sin@c@(y) * npy_cos@c@(y) * exp_mx * exp_mx));

}

/* Kahan's algorithm */

t = npy_tan@c@(y);

beta = 1.0 + t * t; /* = 1 / cos^2(y) */

s = npy_sinh@c@(x);

rho = npy_sqrt@c@(1 + s * s); /* = cosh(x) */

denom = 1 + beta * s * s;

return (npy_cpack@c@((beta * rho * s) / denom, t / denom));