BUG: Overflow in tan and tanh for large complex values

gh-2321 (trac 1726). np.tanh(1000+0j) gave nan+nan*j, should be 1.0+0j. The same bug was present in np.tan(0+1000j). Bug fixed by replacing our complex tan and tanh implementation with one from FreeBSD.
numpy · ewmoore · Feb 22, 2013 · Mar 1, 2013 · Mar 6, 2013 · Mar 8, 2013
commit 9e7be8cfe8f8e734ed3af3cbd50d9caa2ad45dc9
diff --git a/numpy/core/include/numpy/npy_math.h b/numpy/core/include/numpy/npy_math.h
@@ -420,6 +420,9 @@ npy_cdouble npy_csqrt(npy_cdouble z);
 
 npy_cdouble npy_ccos(npy_cdouble z);
 npy_cdouble npy_csin(npy_cdouble z);
+npy_cdouble npy_ctan(npy_cdouble z);
+
+npy_cdouble npy_ctanh(npy_cdouble z);
 
 /*
  * Single precision complex functions
@@ -435,6 +438,9 @@ npy_cfloat npy_csqrtf(npy_cfloat z);
 
 npy_cfloat npy_ccosf(npy_cfloat z);
 npy_cfloat npy_csinf(npy_cfloat z);
+npy_cfloat npy_ctanf(npy_cfloat z);
+
+npy_cfloat npy_ctanhf(npy_cfloat z);
 
 /*
  * Extended precision complex functions
@@ -450,6 +456,9 @@ npy_clongdouble npy_csqrtl(npy_clongdouble z);
 
 npy_clongdouble npy_ccosl(npy_clongdouble z);
 npy_clongdouble npy_csinl(npy_clongdouble z);
+npy_clongdouble npy_ctanl(npy_clongdouble z);
+
+npy_clongdouble npy_ctanhl(npy_clongdouble z);
 
 /*
  * Functions that set the floating point error

diff --git a/numpy/core/setup_common.py b/numpy/core/setup_common.py
@@ -144,7 +144,7 @@ def check_api_version(apiversion, codegen_dir):
 C99_COMPLEX_TYPES = ['complex double', 'complex float', 'complex long double']
 
 C99_COMPLEX_FUNCS = ['creal', 'cimag', 'cabs', 'carg', 'cexp', 'csqrt', 'clog',
-                  'ccos', 'csin', 'cpow']
+                  'ccos', 'csin', 'cpow', 'ctan', 'ctanh']
 
 def fname2def(name):
     return "HAVE_%s" % name.upper()

diff --git a/numpy/core/src/npymath/npy_math_complex.c.src b/numpy/core/src/npymath/npy_math_complex.c.src
@@ -4,7 +4,7 @@
  * Most of the code is taken from the msun library in FreeBSD (HEAD @ 30th June
  * 2009), under the following license:
  *
- * Copyright (c) 2007 David Schultz <[email protected]>
+ * Copyright (c) 2007, 2011 David Schultz <[email protected]>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -227,6 +227,123 @@
     return npy_cpack@c@(npy_sin@c@(x) * npy_cosh@c@(y), npy_cos@c@(x) * npy_sinh@c@(y));
 }
 #endif
+
+#ifndef HAVE_CTAN@C@
+@ctype@ npy_ctan@c@(@ctype@ z)
+{
+	/* 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)));
+}   
+#endif
+
+#ifndef HAVE_CTANH@C@
+/*
+ * Taken from the msun library in FreeBSD, rev 226600.
+ *
+ * Hyperbolic tangent of a complex argument z = x + i y.
+ *
+ * The algorithm is from:
+ *
+ *   W. Kahan.  Branch Cuts for Complex Elementary Functions or Much
+ *   Ado About Nothing's Sign Bit.  In The State of the Art in
+ *   Numerical Analysis, pp. 165 ff.  Iserles and Powell, eds., 1987.
+ *
+ * Method:
+ *
+ *   Let t    = tan(x)
+ *       beta = 1/cos^2(y)
+ *       s    = sinh(x)
+ *       rho  = cosh(x)
+ *
+ *   We have:
+ *
+ *   tanh(z) = sinh(z) / cosh(z)
+ *
+ *             sinh(x) cos(y) + i cosh(x) sin(y)
+ *           = ---------------------------------
+ *             cosh(x) cos(y) + i sinh(x) sin(y)
+ *
+ *             cosh(x) sinh(x) / cos^2(y) + i tan(y)
+ *           = -------------------------------------
+ *                    1 + sinh^2(x) / cos^2(y)
+ *
+ *             beta rho s + i t
+ *           = ----------------
+ *               1 + beta s^2
+ *
+ * Modifications:
+ *
+ *   I omitted the original algorithm's handling of overflow in tan(x) after
+ *   verifying with nearpi.c that this can't happen in IEEE single or double
+ *   precision.  I also handle large x differently.
+ */
+
+#define TANH_HUGE 22.0
+#define TANHF_HUGE 11.0F
+#define TANHL_HUGE 42.0L
+
+@ctype@ npy_ctanh@c@(@ctype@ 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.
+	 */
+        if (!npy_isfinite(x)) {
+            if (npy_isnan(x))
+                return npy_cpack@c@(x, (y == 0 ? y : x * y));
+            return npy_cpack@c@(npy_copysign@c@(1,x),
+                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));
+}
+#undef TANH_HUGE
+#undef TANHF_HUGE
+#undef TANHL_HUGE
+#endif
 /**end repeat**/
 
 /*==========================================================
@@ -254,8 +371,8 @@
 /**end repeat1**/
 
 /**begin repeat1
- * #kind = cexp,clog,csqrt,ccos,csin#
- * #KIND = CEXP,CLOG,CSQRT,CCOS,CSIN#
+ * #kind = cexp,clog,csqrt,ccos,csin,ctan,ctanh#
+ * #KIND = CEXP,CLOG,CSQRT,CCOS,CSIN,CTAN,CTANH#
  */
 #ifdef HAVE_@KIND@@C@
 @ctype@ npy_@kind@@c@(@ctype@ z)

diff --git a/numpy/core/src/umath/funcs.inc.src b/numpy/core/src/umath/funcs.inc.src
@@ -671,42 +671,14 @@ nc_sinh@c@(@ctype@ *x, @ctype@ *r)
 static void
 nc_tan@c@(@ctype@ *x, @ctype@ *r)
 {
-    @ftype@ sr,cr,shi,chi;
-    @ftype@ rs,is,rc,ic;
-    @ftype@ d;
-    @ftype@ xr=x->real, xi=x->imag;
-    sr = npy_sin@c@(xr);
-    cr = npy_cos@c@(xr);
-    shi = npy_sinh@c@(xi);
-    chi = npy_cosh@c@(xi);
-    rs = sr*chi;
-    is = cr*shi;
-    rc = cr*chi;
-    ic = -sr*shi;
-    d = rc*rc + ic*ic;
-    r->real = (rs*rc+is*ic)/d;
-    r->imag = (is*rc-rs*ic)/d;
-    return;
+   *r = npy_ctan@c@(*x);
+   return;
 }
 
 static void
 nc_tanh@c@(@ctype@ *x, @ctype@ *r)
 {
-    @ftype@ si,ci,shr,chr;
-    @ftype@ rs,is,rc,ic;
-    @ftype@ d;
-    @ftype@ xr=x->real, xi=x->imag;
-    si = npy_sin@c@(xi);
-    ci = npy_cos@c@(xi);
-    shr = npy_sinh@c@(xr);
-    chr = npy_cosh@c@(xr);
-    rs = ci*shr;
-    is = si*chr;
-    rc = ci*chr;
-    ic = si*shr;
-    d = rc*rc + ic*ic;
-    r->real = (rs*rc+is*ic)/d;
-    r->imag = (is*rc-rs*ic)/d;
+    *r = npy_ctanh@c@(*x);
     return;
 }