543 lines
17 KiB
Python
543 lines
17 KiB
Python
|
"""
|
||
|
|
Implement the cmath module functions.
|
||
|
|
"""
|
||
|
|
|
||
|
|
|
||
|
|
import cmath
|
||
|
|
import math
|
||
|
|
|
||
|
|
from numba.core.imputils import Registry, impl_ret_untracked
|
||
|
|
from numba.core import types, cgutils
|
||
|
|
from numba.core.typing import signature
|
||
|
|
from numba.cpython import builtins, mathimpl
|
||
|
|
from numba.core.extending import overload
|
||
|
|
|
||
|
|
registry = Registry('cmathimpl')
|
||
|
|
lower = registry.lower
|
||
|
|
|
||
|
|
|
||
|
|
def is_nan(builder, z):
|
||
|
|
return builder.fcmp_unordered('uno', z.real, z.imag)
|
||
|
|
|
||
|
|
def is_inf(builder, z):
|
||
|
|
return builder.or_(mathimpl.is_inf(builder, z.real),
|
||
|
|
mathimpl.is_inf(builder, z.imag))
|
||
|
|
|
||
|
|
def is_finite(builder, z):
|
||
|
|
return builder.and_(mathimpl.is_finite(builder, z.real),
|
||
|
|
mathimpl.is_finite(builder, z.imag))
|
||
|
|
|
||
|
|
|
||
|
|
@lower(cmath.isnan, types.Complex)
|
||
|
|
def isnan_float_impl(context, builder, sig, args):
|
||
|
|
[typ] = sig.args
|
||
|
|
[value] = args
|
||
|
|
z = context.make_complex(builder, typ, value=value)
|
||
|
|
res = is_nan(builder, z)
|
||
|
|
return impl_ret_untracked(context, builder, sig.return_type, res)
|
||
|
|
|
||
|
|
@lower(cmath.isinf, types.Complex)
|
||
|
|
def isinf_float_impl(context, builder, sig, args):
|
||
|
|
[typ] = sig.args
|
||
|
|
[value] = args
|
||
|
|
z = context.make_complex(builder, typ, value=value)
|
||
|
|
res = is_inf(builder, z)
|
||
|
|
return impl_ret_untracked(context, builder, sig.return_type, res)
|
||
|
|
|
||
|
|
|
||
|
|
@lower(cmath.isfinite, types.Complex)
|
||
|
|
def isfinite_float_impl(context, builder, sig, args):
|
||
|
|
[typ] = sig.args
|
||
|
|
[value] = args
|
||
|
|
z = context.make_complex(builder, typ, value=value)
|
||
|
|
res = is_finite(builder, z)
|
||
|
|
return impl_ret_untracked(context, builder, sig.return_type, res)
|
||
|
|
|
||
|
|
|
||
|
|
@overload(cmath.rect)
|
||
|
|
def impl_cmath_rect(r, phi):
|
||
|
|
if all([isinstance(typ, types.Float) for typ in [r, phi]]):
|
||
|
|
def impl(r, phi):
|
||
|
|
if not math.isfinite(phi):
|
||
|
|
if not r:
|
||
|
|
# cmath.rect(0, phi={inf, nan}) = 0
|
||
|
|
return abs(r)
|
||
|
|
if math.isinf(r):
|
||
|
|
# cmath.rect(inf, phi={inf, nan}) = inf + j phi
|
||
|
|
return complex(r, phi)
|
||
|
|
real = math.cos(phi)
|
||
|
|
imag = math.sin(phi)
|
||
|
|
if real == 0. and math.isinf(r):
|
||
|
|
# 0 * inf would return NaN, we want to keep 0 but xor the sign
|
||
|
|
real /= r
|
||
|
|
else:
|
||
|
|
real *= r
|
||
|
|
if imag == 0. and math.isinf(r):
|
||
|
|
# ditto
|
||
|
|
imag /= r
|
||
|
|
else:
|
||
|
|
imag *= r
|
||
|
|
return complex(real, imag)
|
||
|
|
return impl
|
||
|
|
|
||
|
|
|
||
|
|
def intrinsic_complex_unary(inner_func):
|
||
|
|
def wrapper(context, builder, sig, args):
|
||
|
|
[typ] = sig.args
|
||
|
|
[value] = args
|
||
|
|
z = context.make_complex(builder, typ, value=value)
|
||
|
|
x = z.real
|
||
|
|
y = z.imag
|
||
|
|
# Same as above: math.isfinite() is unavailable on 2.x so we precompute
|
||
|
|
# its value and pass it to the pure Python implementation.
|
||
|
|
x_is_finite = mathimpl.is_finite(builder, x)
|
||
|
|
y_is_finite = mathimpl.is_finite(builder, y)
|
||
|
|
inner_sig = signature(sig.return_type,
|
||
|
|
*(typ.underlying_float,) * 2 + (types.boolean,) * 2)
|
||
|
|
res = context.compile_internal(builder, inner_func, inner_sig,
|
||
|
|
(x, y, x_is_finite, y_is_finite))
|
||
|
|
return impl_ret_untracked(context, builder, sig, res)
|
||
|
|
return wrapper
|
||
|
|
|
||
|
|
|
||
|
|
NAN = float('nan')
|
||
|
|
INF = float('inf')
|
||
|
|
|
||
|
|
@lower(cmath.exp, types.Complex)
|
||
|
|
@intrinsic_complex_unary
|
||
|
|
def exp_impl(x, y, x_is_finite, y_is_finite):
|
||
|
|
"""cmath.exp(x + y j)"""
|
||
|
|
if x_is_finite:
|
||
|
|
if y_is_finite:
|
||
|
|
c = math.cos(y)
|
||
|
|
s = math.sin(y)
|
||
|
|
r = math.exp(x)
|
||
|
|
return complex(r * c, r * s)
|
||
|
|
else:
|
||
|
|
return complex(NAN, NAN)
|
||
|
|
elif math.isnan(x):
|
||
|
|
if y:
|
||
|
|
return complex(x, x) # nan + j nan
|
||
|
|
else:
|
||
|
|
return complex(x, y) # nan + 0j
|
||
|
|
elif x > 0.0:
|
||
|
|
# x == +inf
|
||
|
|
if y_is_finite:
|
||
|
|
real = math.cos(y)
|
||
|
|
imag = math.sin(y)
|
||
|
|
# Avoid NaNs if math.cos(y) or math.sin(y) == 0
|
||
|
|
# (e.g. cmath.exp(inf + 0j) == inf + 0j)
|
||
|
|
if real != 0:
|
||
|
|
real *= x
|
||
|
|
if imag != 0:
|
||
|
|
imag *= x
|
||
|
|
return complex(real, imag)
|
||
|
|
else:
|
||
|
|
return complex(x, NAN)
|
||
|
|
else:
|
||
|
|
# x == -inf
|
||
|
|
if y_is_finite:
|
||
|
|
r = math.exp(x)
|
||
|
|
c = math.cos(y)
|
||
|
|
s = math.sin(y)
|
||
|
|
return complex(r * c, r * s)
|
||
|
|
else:
|
||
|
|
r = 0
|
||
|
|
return complex(r, r)
|
||
|
|
|
||
|
|
@lower(cmath.log, types.Complex)
|
||
|
|
@intrinsic_complex_unary
|
||
|
|
def log_impl(x, y, x_is_finite, y_is_finite):
|
||
|
|
"""cmath.log(x + y j)"""
|
||
|
|
a = math.log(math.hypot(x, y))
|
||
|
|
b = math.atan2(y, x)
|
||
|
|
return complex(a, b)
|
||
|
|
|
||
|
|
|
||
|
|
@lower(cmath.log, types.Complex, types.Complex)
|
||
|
|
def log_base_impl(context, builder, sig, args):
|
||
|
|
"""cmath.log(z, base)"""
|
||
|
|
[z, base] = args
|
||
|
|
|
||
|
|
def log_base(z, base):
|
||
|
|
return cmath.log(z) / cmath.log(base)
|
||
|
|
|
||
|
|
res = context.compile_internal(builder, log_base, sig, args)
|
||
|
|
return impl_ret_untracked(context, builder, sig, res)
|
||
|
|
|
||
|
|
|
||
|
|
@overload(cmath.log10)
|
||
|
|
def impl_cmath_log10(z):
|
||
|
|
if not isinstance(z, types.Complex):
|
||
|
|
return
|
||
|
|
|
||
|
|
LN_10 = 2.302585092994045684
|
||
|
|
|
||
|
|
def log10_impl(z):
|
||
|
|
"""cmath.log10(z)"""
|
||
|
|
z = cmath.log(z)
|
||
|
|
# This formula gives better results on +/-inf than cmath.log(z, 10)
|
||
|
|
# See http://bugs.python.org/issue22544
|
||
|
|
return complex(z.real / LN_10, z.imag / LN_10)
|
||
|
|
|
||
|
|
return log10_impl
|
||
|
|
|
||
|
|
|
||
|
|
@overload(cmath.phase)
|
||
|
|
def phase_impl(x):
|
||
|
|
"""cmath.phase(x + y j)"""
|
||
|
|
|
||
|
|
if not isinstance(x, types.Complex):
|
||
|
|
return
|
||
|
|
|
||
|
|
def impl(x):
|
||
|
|
return math.atan2(x.imag, x.real)
|
||
|
|
return impl
|
||
|
|
|
||
|
|
|
||
|
|
@overload(cmath.polar)
|
||
|
|
def polar_impl(x):
|
||
|
|
if not isinstance(x, types.Complex):
|
||
|
|
return
|
||
|
|
|
||
|
|
def impl(x):
|
||
|
|
r, i = x.real, x.imag
|
||
|
|
return math.hypot(r, i), math.atan2(i, r)
|
||
|
|
return impl
|
||
|
|
|
||
|
|
|
||
|
|
@lower(cmath.sqrt, types.Complex)
|
||
|
|
def sqrt_impl(context, builder, sig, args):
|
||
|
|
# We risk spurious overflow for components >= FLT_MAX / (1 + sqrt(2)).
|
||
|
|
|
||
|
|
SQRT2 = 1.414213562373095048801688724209698079E0
|
||
|
|
ONE_PLUS_SQRT2 = (1. + SQRT2)
|
||
|
|
theargflt = sig.args[0].underlying_float
|
||
|
|
# Get a type specific maximum value so scaling for overflow is based on that
|
||
|
|
MAX = mathimpl.DBL_MAX if theargflt.bitwidth == 64 else mathimpl.FLT_MAX
|
||
|
|
# THRES will be double precision, should not impact typing as it's just
|
||
|
|
# used for comparison, there *may* be a few values near THRES which
|
||
|
|
# deviate from e.g. NumPy due to rounding that occurs in the computation
|
||
|
|
# of this value in the case of a 32bit argument.
|
||
|
|
THRES = MAX / ONE_PLUS_SQRT2
|
||
|
|
|
||
|
|
def sqrt_impl(z):
|
||
|
|
"""cmath.sqrt(z)"""
|
||
|
|
# This is NumPy's algorithm, see npy_csqrt() in npy_math_complex.c.src
|
||
|
|
a = z.real
|
||
|
|
b = z.imag
|
||
|
|
if a == 0.0 and b == 0.0:
|
||
|
|
return complex(abs(b), b)
|
||
|
|
if math.isinf(b):
|
||
|
|
return complex(abs(b), b)
|
||
|
|
if math.isnan(a):
|
||
|
|
return complex(a, a)
|
||
|
|
if math.isinf(a):
|
||
|
|
if a < 0.0:
|
||
|
|
return complex(abs(b - b), math.copysign(a, b))
|
||
|
|
else:
|
||
|
|
return complex(a, math.copysign(b - b, b))
|
||
|
|
|
||
|
|
# The remaining special case (b is NaN) is handled just fine by
|
||
|
|
# the normal code path below.
|
||
|
|
|
||
|
|
# Scale to avoid overflow
|
||
|
|
if abs(a) >= THRES or abs(b) >= THRES:
|
||
|
|
a *= 0.25
|
||
|
|
b *= 0.25
|
||
|
|
scale = True
|
||
|
|
else:
|
||
|
|
scale = False
|
||
|
|
# Algorithm 312, CACM vol 10, Oct 1967
|
||
|
|
if a >= 0:
|
||
|
|
t = math.sqrt((a + math.hypot(a, b)) * 0.5)
|
||
|
|
real = t
|
||
|
|
imag = b / (2 * t)
|
||
|
|
else:
|
||
|
|
t = math.sqrt((-a + math.hypot(a, b)) * 0.5)
|
||
|
|
real = abs(b) / (2 * t)
|
||
|
|
imag = math.copysign(t, b)
|
||
|
|
# Rescale
|
||
|
|
if scale:
|
||
|
|
return complex(real * 2, imag)
|
||
|
|
else:
|
||
|
|
return complex(real, imag)
|
||
|
|
|
||
|
|
res = context.compile_internal(builder, sqrt_impl, sig, args)
|
||
|
|
return impl_ret_untracked(context, builder, sig, res)
|
||
|
|
|
||
|
|
|
||
|
|
@lower(cmath.cos, types.Complex)
|
||
|
|
def cos_impl(context, builder, sig, args):
|
||
|
|
def cos_impl(z):
|
||
|
|
"""cmath.cos(z) = cmath.cosh(z j)"""
|
||
|
|
return cmath.cosh(complex(-z.imag, z.real))
|
||
|
|
|
||
|
|
res = context.compile_internal(builder, cos_impl, sig, args)
|
||
|
|
return impl_ret_untracked(context, builder, sig, res)
|
||
|
|
|
||
|
|
@overload(cmath.cosh)
|
||
|
|
def impl_cmath_cosh(z):
|
||
|
|
if not isinstance(z, types.Complex):
|
||
|
|
return
|
||
|
|
|
||
|
|
def cosh_impl(z):
|
||
|
|
"""cmath.cosh(z)"""
|
||
|
|
x = z.real
|
||
|
|
y = z.imag
|
||
|
|
if math.isinf(x):
|
||
|
|
if math.isnan(y):
|
||
|
|
# x = +inf, y = NaN => cmath.cosh(x + y j) = inf + Nan * j
|
||
|
|
real = abs(x)
|
||
|
|
imag = y
|
||
|
|
elif y == 0.0:
|
||
|
|
# x = +inf, y = 0 => cmath.cosh(x + y j) = inf + 0j
|
||
|
|
real = abs(x)
|
||
|
|
imag = y
|
||
|
|
else:
|
||
|
|
real = math.copysign(x, math.cos(y))
|
||
|
|
imag = math.copysign(x, math.sin(y))
|
||
|
|
if x < 0.0:
|
||
|
|
# x = -inf => negate imaginary part of result
|
||
|
|
imag = -imag
|
||
|
|
return complex(real, imag)
|
||
|
|
return complex(math.cos(y) * math.cosh(x),
|
||
|
|
math.sin(y) * math.sinh(x))
|
||
|
|
return cosh_impl
|
||
|
|
|
||
|
|
|
||
|
|
@lower(cmath.sin, types.Complex)
|
||
|
|
def sin_impl(context, builder, sig, args):
|
||
|
|
def sin_impl(z):
|
||
|
|
"""cmath.sin(z) = -j * cmath.sinh(z j)"""
|
||
|
|
r = cmath.sinh(complex(-z.imag, z.real))
|
||
|
|
return complex(r.imag, -r.real)
|
||
|
|
|
||
|
|
res = context.compile_internal(builder, sin_impl, sig, args)
|
||
|
|
return impl_ret_untracked(context, builder, sig, res)
|
||
|
|
|
||
|
|
@overload(cmath.sinh)
|
||
|
|
def impl_cmath_sinh(z):
|
||
|
|
if not isinstance(z, types.Complex):
|
||
|
|
return
|
||
|
|
|
||
|
|
def sinh_impl(z):
|
||
|
|
"""cmath.sinh(z)"""
|
||
|
|
x = z.real
|
||
|
|
y = z.imag
|
||
|
|
if math.isinf(x):
|
||
|
|
if math.isnan(y):
|
||
|
|
# x = +/-inf, y = NaN => cmath.sinh(x + y j) = x + NaN * j
|
||
|
|
real = x
|
||
|
|
imag = y
|
||
|
|
else:
|
||
|
|
real = math.cos(y)
|
||
|
|
imag = math.sin(y)
|
||
|
|
if real != 0.:
|
||
|
|
real *= x
|
||
|
|
if imag != 0.:
|
||
|
|
imag *= abs(x)
|
||
|
|
return complex(real, imag)
|
||
|
|
return complex(math.cos(y) * math.sinh(x),
|
||
|
|
math.sin(y) * math.cosh(x))
|
||
|
|
return sinh_impl
|
||
|
|
|
||
|
|
|
||
|
|
@lower(cmath.tan, types.Complex)
|
||
|
|
def tan_impl(context, builder, sig, args):
|
||
|
|
def tan_impl(z):
|
||
|
|
"""cmath.tan(z) = -j * cmath.tanh(z j)"""
|
||
|
|
r = cmath.tanh(complex(-z.imag, z.real))
|
||
|
|
return complex(r.imag, -r.real)
|
||
|
|
|
||
|
|
res = context.compile_internal(builder, tan_impl, sig, args)
|
||
|
|
return impl_ret_untracked(context, builder, sig, res)
|
||
|
|
|
||
|
|
|
||
|
|
@overload(cmath.tanh)
|
||
|
|
def impl_cmath_tanh(z):
|
||
|
|
if not isinstance(z, types.Complex):
|
||
|
|
return
|
||
|
|
|
||
|
|
def tanh_impl(z):
|
||
|
|
"""cmath.tanh(z)"""
|
||
|
|
x = z.real
|
||
|
|
y = z.imag
|
||
|
|
if math.isinf(x):
|
||
|
|
real = math.copysign(1., x)
|
||
|
|
if math.isinf(y):
|
||
|
|
imag = 0.
|
||
|
|
else:
|
||
|
|
imag = math.copysign(0., math.sin(2. * y))
|
||
|
|
return complex(real, imag)
|
||
|
|
# This is CPython's algorithm (see c_tanh() in cmathmodule.c).
|
||
|
|
# XXX how to force float constants into single precision?
|
||
|
|
tx = math.tanh(x)
|
||
|
|
ty = math.tan(y)
|
||
|
|
cx = 1. / math.cosh(x)
|
||
|
|
txty = tx * ty
|
||
|
|
denom = 1. + txty * txty
|
||
|
|
return complex(
|
||
|
|
tx * (1. + ty * ty) / denom,
|
||
|
|
((ty / denom) * cx) * cx)
|
||
|
|
|
||
|
|
return tanh_impl
|
||
|
|
|
||
|
|
|
||
|
|
@lower(cmath.acos, types.Complex)
|
||
|
|
def acos_impl(context, builder, sig, args):
|
||
|
|
LN_4 = math.log(4)
|
||
|
|
THRES = mathimpl.FLT_MAX / 4
|
||
|
|
|
||
|
|
def acos_impl(z):
|
||
|
|
"""cmath.acos(z)"""
|
||
|
|
# CPython's algorithm (see c_acos() in cmathmodule.c)
|
||
|
|
if abs(z.real) > THRES or abs(z.imag) > THRES:
|
||
|
|
# Avoid unnecessary overflow for large arguments
|
||
|
|
# (also handles infinities gracefully)
|
||
|
|
real = math.atan2(abs(z.imag), z.real)
|
||
|
|
imag = math.copysign(
|
||
|
|
math.log(math.hypot(z.real * 0.5, z.imag * 0.5)) + LN_4,
|
||
|
|
-z.imag)
|
||
|
|
return complex(real, imag)
|
||
|
|
else:
|
||
|
|
s1 = cmath.sqrt(complex(1. - z.real, -z.imag))
|
||
|
|
s2 = cmath.sqrt(complex(1. + z.real, z.imag))
|
||
|
|
real = 2. * math.atan2(s1.real, s2.real)
|
||
|
|
imag = math.asinh(s2.real * s1.imag - s2.imag * s1.real)
|
||
|
|
return complex(real, imag)
|
||
|
|
|
||
|
|
res = context.compile_internal(builder, acos_impl, sig, args)
|
||
|
|
return impl_ret_untracked(context, builder, sig, res)
|
||
|
|
|
||
|
|
@overload(cmath.acosh)
|
||
|
|
def impl_cmath_acosh(z):
|
||
|
|
if not isinstance(z, types.Complex):
|
||
|
|
return
|
||
|
|
|
||
|
|
LN_4 = math.log(4)
|
||
|
|
THRES = mathimpl.FLT_MAX / 4
|
||
|
|
|
||
|
|
def acosh_impl(z):
|
||
|
|
"""cmath.acosh(z)"""
|
||
|
|
# CPython's algorithm (see c_acosh() in cmathmodule.c)
|
||
|
|
if abs(z.real) > THRES or abs(z.imag) > THRES:
|
||
|
|
# Avoid unnecessary overflow for large arguments
|
||
|
|
# (also handles infinities gracefully)
|
||
|
|
real = math.log(math.hypot(z.real * 0.5, z.imag * 0.5)) + LN_4
|
||
|
|
imag = math.atan2(z.imag, z.real)
|
||
|
|
return complex(real, imag)
|
||
|
|
else:
|
||
|
|
s1 = cmath.sqrt(complex(z.real - 1., z.imag))
|
||
|
|
s2 = cmath.sqrt(complex(z.real + 1., z.imag))
|
||
|
|
real = math.asinh(s1.real * s2.real + s1.imag * s2.imag)
|
||
|
|
imag = 2. * math.atan2(s1.imag, s2.real)
|
||
|
|
return complex(real, imag)
|
||
|
|
# Condensed formula (NumPy)
|
||
|
|
#return cmath.log(z + cmath.sqrt(z + 1.) * cmath.sqrt(z - 1.))
|
||
|
|
|
||
|
|
return acosh_impl
|
||
|
|
|
||
|
|
|
||
|
|
@lower(cmath.asinh, types.Complex)
|
||
|
|
def asinh_impl(context, builder, sig, args):
|
||
|
|
LN_4 = math.log(4)
|
||
|
|
THRES = mathimpl.FLT_MAX / 4
|
||
|
|
|
||
|
|
def asinh_impl(z):
|
||
|
|
"""cmath.asinh(z)"""
|
||
|
|
# CPython's algorithm (see c_asinh() in cmathmodule.c)
|
||
|
|
if abs(z.real) > THRES or abs(z.imag) > THRES:
|
||
|
|
real = math.copysign(
|
||
|
|
math.log(math.hypot(z.real * 0.5, z.imag * 0.5)) + LN_4,
|
||
|
|
z.real)
|
||
|
|
imag = math.atan2(z.imag, abs(z.real))
|
||
|
|
return complex(real, imag)
|
||
|
|
else:
|
||
|
|
s1 = cmath.sqrt(complex(1. + z.imag, -z.real))
|
||
|
|
s2 = cmath.sqrt(complex(1. - z.imag, z.real))
|
||
|
|
real = math.asinh(s1.real * s2.imag - s2.real * s1.imag)
|
||
|
|
imag = math.atan2(z.imag, s1.real * s2.real - s1.imag * s2.imag)
|
||
|
|
return complex(real, imag)
|
||
|
|
|
||
|
|
res = context.compile_internal(builder, asinh_impl, sig, args)
|
||
|
|
return impl_ret_untracked(context, builder, sig, res)
|
||
|
|
|
||
|
|
@lower(cmath.asin, types.Complex)
|
||
|
|
def asin_impl(context, builder, sig, args):
|
||
|
|
def asin_impl(z):
|
||
|
|
"""cmath.asin(z) = -j * cmath.asinh(z j)"""
|
||
|
|
r = cmath.asinh(complex(-z.imag, z.real))
|
||
|
|
return complex(r.imag, -r.real)
|
||
|
|
|
||
|
|
res = context.compile_internal(builder, asin_impl, sig, args)
|
||
|
|
return impl_ret_untracked(context, builder, sig, res)
|
||
|
|
|
||
|
|
@lower(cmath.atan, types.Complex)
|
||
|
|
def atan_impl(context, builder, sig, args):
|
||
|
|
def atan_impl(z):
|
||
|
|
"""cmath.atan(z) = -j * cmath.atanh(z j)"""
|
||
|
|
r = cmath.atanh(complex(-z.imag, z.real))
|
||
|
|
if math.isinf(z.real) and math.isnan(z.imag):
|
||
|
|
# XXX this is odd but necessary
|
||
|
|
return complex(r.imag, r.real)
|
||
|
|
else:
|
||
|
|
return complex(r.imag, -r.real)
|
||
|
|
|
||
|
|
res = context.compile_internal(builder, atan_impl, sig, args)
|
||
|
|
return impl_ret_untracked(context, builder, sig, res)
|
||
|
|
|
||
|
|
@lower(cmath.atanh, types.Complex)
|
||
|
|
def atanh_impl(context, builder, sig, args):
|
||
|
|
LN_4 = math.log(4)
|
||
|
|
THRES_LARGE = math.sqrt(mathimpl.FLT_MAX / 4)
|
||
|
|
THRES_SMALL = math.sqrt(mathimpl.FLT_MIN)
|
||
|
|
PI_12 = math.pi / 2
|
||
|
|
|
||
|
|
def atanh_impl(z):
|
||
|
|
"""cmath.atanh(z)"""
|
||
|
|
# CPython's algorithm (see c_atanh() in cmathmodule.c)
|
||
|
|
if z.real < 0.:
|
||
|
|
# Reduce to case where z.real >= 0., using atanh(z) = -atanh(-z).
|
||
|
|
negate = True
|
||
|
|
z = -z
|
||
|
|
else:
|
||
|
|
negate = False
|
||
|
|
|
||
|
|
ay = abs(z.imag)
|
||
|
|
if math.isnan(z.real) or z.real > THRES_LARGE or ay > THRES_LARGE:
|
||
|
|
if math.isinf(z.imag):
|
||
|
|
real = math.copysign(0., z.real)
|
||
|
|
elif math.isinf(z.real):
|
||
|
|
real = 0.
|
||
|
|
else:
|
||
|
|
# may be safe from overflow, depending on hypot's implementation...
|
||
|
|
h = math.hypot(z.real * 0.5, z.imag * 0.5)
|
||
|
|
real = z.real/4./h/h
|
||
|
|
imag = -math.copysign(PI_12, -z.imag)
|
||
|
|
elif z.real == 1. and ay < THRES_SMALL:
|
||
|
|
# C99 standard says: atanh(1+/-0.) should be inf +/- 0j
|
||
|
|
if ay == 0.:
|
||
|
|
real = INF
|
||
|
|
imag = z.imag
|
||
|
|
else:
|
||
|
|
real = -math.log(math.sqrt(ay) /
|
||
|
|
math.sqrt(math.hypot(ay, 2.)))
|
||
|
|
imag = math.copysign(math.atan2(2., -ay) / 2, z.imag)
|
||
|
|
else:
|
||
|
|
sqay = ay * ay
|
||
|
|
zr1 = 1 - z.real
|
||
|
|
real = math.log1p(4. * z.real / (zr1 * zr1 + sqay)) * 0.25
|
||
|
|
imag = -math.atan2(-2. * z.imag,
|
||
|
|
zr1 * (1 + z.real) - sqay) * 0.5
|
||
|
|
|
||
|
|
if math.isnan(z.imag):
|
||
|
|
imag = NAN
|
||
|
|
if negate:
|
||
|
|
return complex(-real, -imag)
|
||
|
|
else:
|
||
|
|
return complex(real, imag)
|
||
|
|
|
||
|
|
res = context.compile_internal(builder, atanh_impl, sig, args)
|
||
|
|
return impl_ret_untracked(context, builder, sig, res)
|