from ..libmp.backend import xrange
from .functions import defun, defun_wrapped
def _check_need_perturb(ctx, terms, prec, discard_known_zeros):
perturb = recompute = False
extraprec = 0
discard = []
for term_index, term in enumerate(terms):
w_s, c_s, alpha_s, beta_s, a_s, b_s, z = term
have_singular_nongamma_weight = False
# Avoid division by zero in leading factors (TODO:
# also check for near division by zero?)
for k, w in enumerate(w_s):
if not w:
if ctx.re(c_s[k]) <= 0 and c_s[k]:
perturb = recompute = True
have_singular_nongamma_weight = True
pole_count = [0, 0, 0]
# Check for gamma and series poles and near-poles
for data_index, data in enumerate([alpha_s, beta_s, b_s]):
for i, x in enumerate(data):
n, d = ctx.nint_distance(x)
# Poles
if n > 0:
continue
if d == ctx.ninf:
# OK if we have a polynomial
# ------------------------------
ok = False
if data_index == 2:
for u in a_s:
if ctx.isnpint(u) and u >= int(n):
ok = True
break
if ok:
continue
pole_count[data_index] += 1
# ------------------------------
#perturb = recompute = True
#return perturb, recompute, extraprec
elif d < -4:
extraprec += -d
recompute = True
if discard_known_zeros and pole_count[1] > pole_count[0] + pole_count[2] \
and not have_singular_nongamma_weight:
discard.append(term_index)
elif sum(pole_count):
perturb = recompute = True
return perturb, recompute, extraprec, discard
_hypercomb_msg = """
hypercomb() failed to converge to the requested %i bits of accuracy
using a working precision of %i bits. The function value may be zero or
infinite; try passing zeroprec=N or infprec=M to bound finite values between
2^(-N) and 2^M. Otherwise try a higher maxprec or maxterms.
"""
@defun
def hypercomb(ctx, function, params=[], discard_known_zeros=True, **kwargs):
orig = ctx.prec
sumvalue = ctx.zero
dist = ctx.nint_distance
ninf = ctx.ninf
orig_params = params[:]
verbose = kwargs.get('verbose', False)
maxprec = kwargs.get('maxprec', ctx._default_hyper_maxprec(orig))
kwargs['maxprec'] = maxprec # For calls to hypsum
zeroprec = kwargs.get('zeroprec')
infprec = kwargs.get('infprec')
perturbed_reference_value = None
hextra = 0
try:
while 1:
ctx.prec += 10
if ctx.prec > maxprec:
raise ValueError(_hypercomb_msg % (orig, ctx.prec))
orig2 = ctx.prec
params = orig_params[:]
terms = function(*params)
if verbose:
print()
print("ENTERING hypercomb main loop")
print("prec =", ctx.prec)
print("hextra", hextra)
perturb, recompute, extraprec, discard = \
_check_need_perturb(ctx, terms, orig, discard_known_zeros)
ctx.prec += extraprec
if perturb:
if "hmag" in kwargs:
hmag = kwargs["hmag"]
elif ctx._fixed_precision:
hmag = int(ctx.prec*0.3)
else:
hmag = orig + 10 + hextra
h = ctx.ldexp(ctx.one, -hmag)
ctx.prec = orig2 + 10 + hmag + 10
for k in range(len(params)):
params[k] += h
# Heuristically ensure that the perturbations
# are "independent" so that two perturbations
# don't accidentally cancel each other out
# in a subtraction.
h += h/(k+1)
if recompute:
terms = function(*params)
if discard_known_zeros:
terms = [term for (i, term) in enumerate(terms) if i not in discard]
if not terms:
return ctx.zero
evaluated_terms = []
for term_index, term_data in enumerate(terms):
w_s, c_s, alpha_s, beta_s, a_s, b_s, z = term_data
if verbose:
print()
print(" Evaluating term %i/%i : %iF%i" % \
(term_index+1, len(terms), len(a_s), len(b_s)))
print(" powers", ctx.nstr(w_s), ctx.nstr(c_s))
print(" gamma", ctx.nstr(alpha_s), ctx.nstr(beta_s))
print(" hyper", ctx.nstr(a_s), ctx.nstr(b_s))
print(" z", ctx.nstr(z))
#v = ctx.hyper(a_s, b_s, z, **kwargs)
#for a in alpha_s: v *= ctx.gamma(a)
#for b in beta_s: v *= ctx.rgamma(b)
#for w, c in zip(w_s, c_s): v *= ctx.power(w, c)
v = ctx.fprod([ctx.hyper(a_s, b_s, z, **kwargs)] + \
[ctx.gamma(a) for a in alpha_s] + \
[ctx.rgamma(b) for b in beta_s] + \
[ctx.power(w,c) for (w,c) in zip(w_s,c_s)])
if verbose:
print(" Value:", v)
evaluated_terms.append(v)
if len(terms) == 1 and (not perturb):
sumvalue = evaluated_terms[0]
break
if ctx._fixed_precision:
sumvalue = ctx.fsum(evaluated_terms)
break
sumvalue = ctx.fsum(evaluated_terms)
term_magnitudes = [ctx.mag(x) for x in evaluated_terms]
max_magnitude = max(term_magnitudes)
sum_magnitude = ctx.mag(sumvalue)
cancellation = max_magnitude - sum_magnitude
if verbose:
print()
print(" Cancellation:", cancellation, "bits")
print(" Increased precision:", ctx.prec - orig, "bits")
precision_ok = cancellation < ctx.prec - orig
if zeroprec is None:
zero_ok = False
else:
zero_ok = max_magnitude - ctx.prec < -zeroprec
if infprec is None:
inf_ok = False
else:
inf_ok = max_magnitude > infprec
if precision_ok and (not perturb) or ctx.isnan(cancellation):
break
elif precision_ok:
if perturbed_reference_value is None:
hextra += 20
perturbed_reference_value = sumvalue
continue
elif ctx.mag(sumvalue - perturbed_reference_value) <= \
ctx.mag(sumvalue) - orig:
break
elif zero_ok:
sumvalue = ctx.zero
break
elif inf_ok:
sumvalue = ctx.inf
break
elif 'hmag' in kwargs:
break
else:
hextra *= 2
perturbed_reference_value = sumvalue
# Increase precision
else:
increment = min(max(cancellation, orig//2), max(extraprec,orig))
ctx.prec += increment
if verbose:
print(" Must start over with increased precision")
continue
finally:
ctx.prec = orig
return +sumvalue
@defun
def hyper(ctx, a_s, b_s, z, **kwargs):
"""
Hypergeometric function, general case.
"""
z = ctx.convert(z)
p = len(a_s)
q = len(b_s)
a_s = [ctx._convert_param(a) for a in a_s]
b_s = [ctx._convert_param(b) for b in b_s]
# Reduce degree by eliminating common parameters
if kwargs.get('eliminate', True):
elim_nonpositive = kwargs.get('eliminate_all', False)
i = 0
while i < q and a_s:
b = b_s[i]
if b in a_s and (elim_nonpositive or not ctx.isnpint(b[0])):
a_s.remove(b)
b_s.remove(b)
p -= 1
q -= 1
else:
i += 1
# Handle special cases
if p == 0:
if q == 1: return ctx._hyp0f1(b_s, z, **kwargs)
elif q == 0: return ctx.exp(z)
elif p == 1:
if q == 1: return ctx._hyp1f1(a_s, b_s, z, **kwargs)
elif q == 2: return ctx._hyp1f2(a_s, b_s, z, **kwargs)
elif q == 0: return ctx._hyp1f0(a_s[0][0], z)
elif p == 2:
if q == 1: return ctx._hyp2f1(a_s, b_s, z, **kwargs)
elif q == 2: return ctx._hyp2f2(a_s, b_s, z, **kwargs)
elif q == 3: return ctx._hyp2f3(a_s, b_s, z, **kwargs)
elif q == 0: return ctx._hyp2f0(a_s, b_s, z, **kwargs)
elif p == q+1:
return ctx._hypq1fq(p, q, a_s, b_s, z, **kwargs)
elif p > q+1 and not kwargs.get('force_series'):
return ctx._hyp_borel(p, q, a_s, b_s, z, **kwargs)
coeffs, types = zip(*(a_s+b_s))
return ctx.hypsum(p, q, types, coeffs, z, **kwargs)
@defun
def hyp0f1(ctx,b,z,**kwargs):
return ctx.hyper([],[b],z,**kwargs)
@defun
def hyp1f1(ctx,a,b,z,**kwargs):
return ctx.hyper([a],[b],z,**kwargs)
@defun
def hyp1f2(ctx,a1,b1,b2,z,**kwargs):
return ctx.hyper([a1],[b1,b2],z,**kwargs)
@defun
def hyp2f1(ctx,a,b,c,z,**kwargs):
return ctx.hyper([a,b],[c],z,**kwargs)
@defun
def hyp2f2(ctx,a1,a2,b1,b2,z,**kwargs):
return ctx.hyper([a1,a2],[b1,b2],z,**kwargs)
@defun
def hyp2f3(ctx,a1,a2,b1,b2,b3,z,**kwargs):
return ctx.hyper([a1,a2],[b1,b2,b3],z,**kwargs)
@defun
def hyp2f0(ctx,a,b,z,**kwargs):
return ctx.hyper([a,b],[],z,**kwargs)
@defun
def hyp3f2(ctx,a1,a2,a3,b1,b2,z,**kwargs):
return ctx.hyper([a1,a2,a3],[b1,b2],z,**kwargs)
@defun_wrapped
def _hyp1f0(ctx, a, z):
return (1-z) ** (-a)
@defun
def _hyp0f1(ctx, b_s, z, **kwargs):
(b, btype), = b_s
if z:
magz = ctx.mag(z)
else:
magz = 0
if magz >= 8 and not kwargs.get('force_series'):
try:
# http://functions.wolfram.com/HypergeometricFunctions/
# Hypergeometric0F1/06/02/03/0004/
# TODO: handle the all-real case more efficiently!
# TODO: figure out how much precision is needed (exponential growth)
orig = ctx.prec
try:
ctx.prec += 12 + magz//2
def h():
w = ctx.sqrt(-z)
jw = ctx.j*w
u = 1/(4*jw)
c = ctx.mpq_1_2 - b
E = ctx.exp(2*jw)
T1 = ([-jw,E], [c,-1], [], [], [b-ctx.mpq_1_2, ctx.mpq_3_2-b], [], -u)
T2 = ([jw,E], [c,1], [], [], [b-ctx.mpq_1_2, ctx.mpq_3_2-b], [], u)
return T1, T2
v = ctx.hypercomb(h, [], force_series=True)
v = ctx.gamma(b)/(2*ctx.sqrt(ctx.pi))*v
finally:
ctx.prec = orig
if ctx._is_real_type(b) and ctx._is_real_type(z):
v = ctx._re(v)
return +v
except ctx.NoConvergence:
pass
return ctx.hypsum(0, 1, (btype,), [b], z, **kwargs)
@defun
def _hyp1f1(ctx, a_s, b_s, z, **kwargs):
(a, atype), = a_s
(b, btype), = b_s
if not z:
return ctx.one+z
magz = ctx.mag(z)
if magz >= 7 and not (ctx.isint(a) and ctx.re(a) <= 0):
if ctx.isinf(z):
if ctx.sign(a) == ctx.sign(b) == ctx.sign(z) == 1:
return ctx.inf
return ctx.nan * z
try:
try:
ctx.prec += magz
sector = ctx._im(z) < 0
def h(a,b):
if sector:
E = ctx.expjpi(ctx.fneg(a, exact=True))
else:
E = ctx.expjpi(a)
rz = 1/z
T1 = ([E,z], [1,-a], [b], [b-a], [a, 1+a-b], [], -rz)
T2 = ([ctx.exp(z),z], [1,a-b], [b], [a], [b-a, 1-a], [], rz)
return T1, T2
v = ctx.hypercomb(h, [a,b], force_series=True)
if ctx._is_real_type(a) and ctx._is_real_type(b) and ctx._is_real_type(z):
v = ctx._re(v)
return +v
except ctx.NoConvergence:
pass
finally:
ctx.prec -= magz
v = ctx.hypsum(1, 1, (atype, btype), [a, b], z, **kwargs)
return v
def _hyp2f1_gosper(ctx,a,b,c,z,**kwargs):
# Use Gosper's recurrence
# See http://www.math.utexas.edu/pipermail/maxima/2006/000126.html
_a,_b,_c,_z = a, b, c, z
orig = ctx.prec
maxprec = kwargs.get('maxprec', 100*orig)
extra = 10
while 1:
ctx.prec = orig + extra
#a = ctx.convert(_a)
#b = ctx.convert(_b)
#c = ctx.convert(_c)
z = ctx.convert(_z)
d = ctx.mpf(0)
e = ctx.mpf(1)
f = ctx.mpf(0)
k = 0
# Common subexpression elimination, unfortunately making
# things a bit unreadable. The formula is quite messy to begin
# with, though...
abz = a*b*z
ch = c * ctx.mpq_1_2
c1h = (c+1) * ctx.mpq_1_2
nz = 1-z
g = z/nz
abg = a*b*g
cba = c-b-a
z2 = z-2
tol = -ctx.prec - 10
nstr = ctx.nstr
nprint = ctx.nprint
mag = ctx.mag
maxmag = ctx.ninf
while 1:
kch = k+ch
kakbz = (k+a)*(k+b)*z / (4*(k+1)*kch*(k+c1h))
d1 = kakbz*(e-(k+cba)*d*g)
e1 = kakbz*(d*abg+(k+c)*e)
ft = d*(k*(cba*z+k*z2-c)-abz)/(2*kch*nz)
f1 = f + e - ft
maxmag = max(maxmag, mag(f1))
if mag(f1-f) < tol:
break
d, e, f = d1, e1, f1
k += 1
cancellation = maxmag - mag(f1)
if cancellation < extra:
break
else:
extra += cancellation
if extra > maxprec:
raise ctx.NoConvergence
return f1
@defun
def _hyp2f1(ctx, a_s, b_s, z, **kwargs):
(a, atype), (b, btype) = a_s
(c, ctype), = b_s
if z == 1:
# TODO: the following logic can be simplified
convergent = ctx.re(c-a-b) > 0
finite = (ctx.isint(a) and a <= 0) or (ctx.isint(b) and b <= 0)
zerodiv = ctx.isint(c) and c <= 0 and not \
((ctx.isint(a) and c <= a <= 0) or (ctx.isint(b) and c <= b <= 0))
#print "bz", a, b, c, z, convergent, finite, zerodiv
# Gauss's theorem gives the value if convergent
if (convergent or finite) and not zerodiv:
return ctx.gammaprod([c, c-a-b], [c-a, c-b], _infsign=True)
# Otherwise, there is a pole and we take the
# sign to be that when approaching from below
# XXX: this evaluation is not necessarily correct in all cases
return ctx.hyp2f1(a,b,c,1-ctx.eps*2) * ctx.inf
# Equal to 1 (first term), unless there is a subsequent
# division by zero
if not z:
# Division by zero but power of z is higher than
# first order so cancels
if c or a == 0 or b == 0:
return 1+z
# Indeterminate
return ctx.nan
# Hit zero denominator unless numerator goes to 0 first
if ctx.isint(c) and c <= 0:
if (ctx.isint(a) and c <= a <= 0) or \
(ctx.isint(b) and c <= b <= 0):
pass
else:
# Pole in series
return ctx.inf
absz = abs(z)
# Fast case: standard series converges rapidly,
# possibly in finitely many terms
if absz <= 0.8 or (ctx.isint(a) and a <= 0 and a >= -1000) or \
(ctx.isint(b) and b <= 0 and b >= -1000):
return ctx.hypsum(2, 1, (atype, btype, ctype), [a, b, c], z, **kwargs)
orig = ctx.prec
try:
ctx.prec += 10
# Use 1/z transformation
if absz >= 1.3:
def h(a,b):
t = ctx.mpq_1-c; ab = a-b; rz = 1/z
T1 = ([-z],[-a], [c,-ab],[b,c-a], [a,t+a],[ctx.mpq_1+ab], rz)
T2 = ([-z],[-b], [c,ab],[a,c-b], [b,t+b],[ctx.mpq_1-ab], rz)
return T1, T2
v = ctx.hypercomb(h, [a,b], **kwargs)
# Use 1-z transformation
elif abs(1-z) <= 0.75:
def h(a,b):
t = c-a-b; ca = c-a; cb = c-b; rz = 1-z
T1 = [], [], [c,t], [ca,cb], [a,b], [1-t], rz
T2 = [rz], [t], [c,a+b-c], [a,b], [ca,cb], [1+t], rz
return T1, T2
v = ctx.hypercomb(h, [a,b], **kwargs)
# Use z/(z-1) transformation
elif abs(z/(z-1)) <= 0.75:
v = ctx.hyp2f1(a, c-b, c, z/(z-1)) / (1-z)**a
# Remaining part of unit circle
else:
v = _hyp2f1_gosper(ctx,a,b,c,z,**kwargs)
finally:
ctx.prec = orig
return +v
@defun
def _hypq1fq(ctx, p, q, a_s, b_s, z, **kwargs):
r"""
Evaluates 3F2, 4F3, 5F4, ...
"""
a_s, a_types = zip(*a_s)
b_s, b_types = zip(*b_s)
a_s = list(a_s)
b_s = list(b_s)
absz = abs(z)
ispoly = False
for a in a_s:
if ctx.isint(a) and a <= 0:
ispoly = True
break
# Direct summation
if absz < 1 or ispoly:
try:
return ctx.hypsum(p, q, a_types+b_types, a_s+b_s, z, **kwargs)
except ctx.NoConvergence:
if absz > 1.1 or ispoly:
raise
# Use expansion at |z-1| -> 0.
# Reference: Wolfgang Buhring, "Generalized Hypergeometric Functions at
# Unit Argument", Proc. Amer. Math. Soc., Vol. 114, No. 1 (Jan. 1992),
# pp.145-153
# The current implementation has several problems:
# 1. We only implement it for 3F2. The expansion coefficients are
# given by extremely messy nested sums in the higher degree cases
# (see reference). Is efficient sequential generation of the coefficients
# possible in the > 3F2 case?
# 2. Although the series converges, it may do so slowly, so we need
# convergence acceleration. The acceleration implemented by
# nsum does not always help, so results returned are sometimes
# inaccurate! Can we do better?
# 3. We should check conditions for convergence, and possibly
# do a better job of cancelling out gamma poles if possible.
if z == 1:
# XXX: should also check for division by zero in the
# denominator of the series (cf. hyp2f1)
S = ctx.re(sum(b_s)-sum(a_s))
if S <= 0:
#return ctx.hyper(a_s, b_s, 1-ctx.eps*2, **kwargs) * ctx.inf
return ctx.hyper(a_s, b_s, 0.9, **kwargs) * ctx.inf
if (p,q) == (3,2) and abs(z-1) < 0.05: # and kwargs.get('sum1')
#print "Using alternate summation (experimental)"
a1,a2,a3 = a_s
b1,b2 = b_s
u = b1+b2-a3
initial = ctx.gammaprod([b2-a3,b1-a3,a1,a2],[b2-a3,b1-a3,1,u])
def term(k, _cache={0:initial}):
u = b1+b2-a3+k
if k in _cache:
t = _cache[k]
else:
t = _cache[k-1]
t *= (b1+k-a3-1)*(b2+k-a3-1)
t /= k*(u-1)
_cache[k] = t
return t * ctx.hyp2f1(a1,a2,u,z)
try:
S = ctx.nsum(term, [0,ctx.inf], verbose=kwargs.get('verbose'),
strict=kwargs.get('strict', True))
return S * ctx.gammaprod([b1,b2],[a1,a2,a3])
except ctx.NoConvergence:
pass
# Try to use convergence acceleration on and close to the unit circle.
# Problem: the convergence acceleration degenerates as |z-1| -> 0,
# except for special cases. Everywhere else, the Shanks transformation
# is very efficient.
if absz < 1.1 and ctx._re(z) <= 1:
def term(kk, _cache={0:ctx.one}):
k = int(kk)
if k != kk:
t = z ** ctx.mpf(kk) / ctx.fac(kk)
for a in a_s: t *= ctx.rf(a,kk)
for b in b_s: t /= ctx.rf(b,kk)
return t
if k in _cache:
return _cache[k]
t = term(k-1)
m = k-1
for j in xrange(p): t *= (a_s[j]+m)
for j in xrange(q): t /= (b_s[j]+m)
t *= z
t /= k
_cache[k] = t
return t
sum_method = kwargs.get('sum_method', 'r+s+e')
try:
return ctx.nsum(term, [0,ctx.inf], verbose=kwargs.get('verbose'),
strict=kwargs.get('strict', True),
method=sum_method.replace('e',''))
except ctx.NoConvergence:
if 'e' not in sum_method:
raise
pass
if kwargs.get('verbose'):
print("Attempting Euler-Maclaurin summation")
"""
Somewhat slower version (one diffs_exp for each factor).
However, this would be faster with fast direct derivatives
of the gamma function.
def power_diffs(k0):
r = 0
l = ctx.log(z)
while 1:
yield z**ctx.mpf(k0) * l**r
r += 1
def loggamma_diffs(x, reciprocal=False):
sign = (-1) ** reciprocal
yield sign * ctx.loggamma(x)
i = 0
while 1:
yield sign * ctx.psi(i,x)
i += 1
def hyper_diffs(k0):
b2 = b_s + [1]
A = [ctx.diffs_exp(loggamma_diffs(a+k0)) for a in a_s]
B = [ctx.diffs_exp(loggamma_diffs(b+k0,True)) for b in b2]
Z = [power_diffs(k0)]
C = ctx.gammaprod([b for b in b2], [a for a in a_s])
for d in ctx.diffs_prod(A + B + Z):
v = C * d
yield v
"""
def log_diffs(k0):
b2 = b_s + [1]
yield sum(ctx.loggamma(a+k0) for a in a_s) - \
sum(ctx.loggamma(b+k0) for b in b2) + k0*ctx.log(z)
i = 0
while 1:
v = sum(ctx.psi(i,a+k0) for a in a_s) - \
sum(ctx.psi(i,b+k0) for b in b2)
if i == 0:
v += ctx.log(z)
yield v
i += 1
def hyper_diffs(k0):
C = ctx.gammaprod([b for b in b_s], [a for a in a_s])
for d in ctx.diffs_exp(log_diffs(k0)):
v = C * d
yield v
tol = ctx.eps / 1024
prec = ctx.prec
try:
trunc = 50 * ctx.dps
ctx.prec += 20
for i in xrange(5):
head = ctx.fsum(term(k) for k in xrange(trunc))
tail, err = ctx.sumem(term, [trunc, ctx.inf], tol=tol,
adiffs=hyper_diffs(trunc),
verbose=kwargs.get('verbose'),
error=True,
_fast_abort=True)
if err < tol:
v = head + tail
break
trunc *= 2
# Need to increase precision because calculation of
# derivatives may be inaccurate
ctx.prec += ctx.prec//2
if i == 4:
raise ctx.NoConvergence(\
"Euler-Maclaurin summation did not converge")
finally:
ctx.prec = prec
return +v
# Use 1/z transformation
# http://functions.wolfram.com/HypergeometricFunctions/
# HypergeometricPFQ/06/01/05/02/0004/
def h(*args):
a_s = list(args[:p])
b_s = list(args[p:])
Ts = []
recz = ctx.one/z
negz = ctx.fneg(z, exact=True)
for k in range(q+1):
ak = a_s[k]
C = [negz]
Cp = [-ak]
Gn = b_s + [ak] + [a_s[j]-ak for j in range(q+1) if j != k]
Gd = a_s + [b_s[j]-ak for j in range(q)]
Fn = [ak] + [ak-b_s[j]+1 for j in range(q)]
Fd = [1-a_s[j]+ak for j in range(q+1) if j != k]
Ts.append((C, Cp, Gn, Gd, Fn, Fd, recz))
return Ts
return ctx.hypercomb(h, a_s+b_s, **kwargs)
@defun
def _hyp_borel(ctx, p, q, a_s, b_s, z, **kwargs):
if a_s:
a_s, a_types = zip(*a_s)
a_s = list(a_s)
else:
a_s, a_types = [], ()
if b_s:
b_s, b_types = zip(*b_s)
b_s = list(b_s)
else:
b_s, b_types = [], ()
kwargs['maxterms'] = kwargs.get('maxterms', ctx.prec)
try:
return ctx.hypsum(p, q, a_types+b_types, a_s+b_s, z, **kwargs)
except ctx.NoConvergence:
pass
prec = ctx.prec
try:
tol = kwargs.get('asymp_tol', ctx.eps/4)
ctx.prec += 10
# hypsum is has a conservative tolerance. So we try again:
def term(k, cache={0:ctx.one}):
if k in cache:
return cache[k]
t = term(k-1)
for a in a_s: t *= (a+(k-1))
for b in b_s: t /= (b+(k-1))
t *= z
t /= k
cache[k] = t
return t
s = ctx.one
for k in xrange(1, ctx.prec):
t = term(k)
s += t
if abs(t) <= tol:
return s
finally:
ctx.prec = prec
if p <= q+3:
contour = kwargs.get('contour')
if not contour:
if ctx.arg(z) < 0.25:
u = z / max(1, abs(z))
if ctx.arg(z) >= 0:
contour = [0, 2j, (2j+2)/u, 2/u, ctx.inf]
else:
contour = [0, -2j, (-2j+2)/u, 2/u, ctx.inf]
#contour = [0, 2j/z, 2/z, ctx.inf]
#contour = [0, 2j, 2/z, ctx.inf]
#contour = [0, 2j, ctx.inf]
else:
contour = [0, ctx.inf]
quad_kwargs = kwargs.get('quad_kwargs', {})
def g(t):
return ctx.exp(-t)*ctx.hyper(a_s, b_s+[1], t*z)
I, err = ctx.quad(g, contour, error=True, **quad_kwargs)
if err <= abs(I)*ctx.eps*8:
return I
raise ctx.NoConvergence
@defun
def _hyp2f2(ctx, a_s, b_s, z, **kwargs):
(a1, a1type), (a2, a2type) = a_s
(b1, b1type), (b2, b2type) = b_s
absz = abs(z)
magz = ctx.mag(z)
orig = ctx.prec
# Asymptotic expansion is ~ exp(z)
asymp_extraprec = magz
# Asymptotic series is in terms of 3F1
can_use_asymptotic = (not kwargs.get('force_series')) and \
(ctx.mag(absz) > 3)
# TODO: much of the following could be shared with 2F3 instead of
# copypasted
if can_use_asymptotic:
#print "using asymp"
try:
try:
ctx.prec += asymp_extraprec
# http://functions.wolfram.com/HypergeometricFunctions/
# Hypergeometric2F2/06/02/02/0002/
def h(a1,a2,b1,b2):
X = a1+a2-b1-b2
A2 = a1+a2
B2 = b1+b2
c = {}
c[0] = ctx.one
c[1] = (A2-1)*X+b1*b2-a1*a2
s1 = 0
k = 0
tprev = 0
while 1:
if k not in c:
uu1 = 1-B2+2*a1+a1**2+2*a2+a2**2-A2*B2+a1*a2+b1*b2+(2*B2-3*(A2+1))*k+2*k**2
uu2 = (k-A2+b1-1)*(k-A2+b2-1)*(k-X-2)
c[k] = ctx.one/k * (uu1*c[k-1]-uu2*c[k-2])
t1 = c[k] * z**(-k)
if abs(t1) < 0.1*ctx.eps:
#print "Convergence :)"
break
# Quit if the series doesn't converge quickly enough
if k > 5 and abs(tprev) / abs(t1) < 1.5:
#print "No convergence :("
raise ctx.NoConvergence
s1 += t1
tprev = t1
k += 1
S = ctx.exp(z)*s1
T1 = [z,S], [X,1], [b1,b2],[a1,a2],[],[],0
T2 = [-z],[-a1],[b1,b2,a2-a1],[a2,b1-a1,b2-a1],[a1,a1-b1+1,a1-b2+1],[a1-a2+1],-1/z
T3 = [-z],[-a2],[b1,b2,a1-a2],[a1,b1-a2,b2-a2],[a2,a2-b1+1,a2-b2+1],[-a1+a2+1],-1/z
return T1, T2, T3
v = ctx.hypercomb(h, [a1,a2,b1,b2], force_series=True, maxterms=4*ctx.prec)
if sum(ctx._is_real_type(u) for u in [a1,a2,b1,b2,z]) == 5:
v = ctx.re(v)
return v
except ctx.NoConvergence:
pass
finally:
ctx.prec = orig
return ctx.hypsum(2, 2, (a1type, a2type, b1type, b2type), [a1, a2, b1, b2], z, **kwargs)
@defun
def _hyp1f2(ctx, a_s, b_s, z, **kwargs):
(a1, a1type), = a_s
(b1, b1type), (b2, b2type) = b_s
absz = abs(z)
magz = ctx.mag(z)
orig = ctx.prec
# Asymptotic expansion is ~ exp(sqrt(z))
asymp_extraprec = z and magz//2
# Asymptotic series is in terms of 3F0
can_use_asymptotic = (not kwargs.get('force_series')) and \
(ctx.mag(absz) > 19) and \
(ctx.sqrt(absz) > 1.5*orig) # and \
# ctx._hyp_check_convergence([a1, a1-b1+1, a1-b2+1], [],
# 1/absz, orig+40+asymp_extraprec)
# TODO: much of the following could be shared with 2F3 instead of
# copypasted
if can_use_asymptotic:
#print "using asymp"
try:
try:
ctx.prec += asymp_extraprec
# http://functions.wolfram.com/HypergeometricFunctions/
# Hypergeometric1F2/06/02/03/
def h(a1,b1,b2):
X = ctx.mpq_1_2*(a1-b1-b2+ctx.mpq_1_2)
c = {}
c[0] = ctx.one
c[1] = 2*(ctx.mpq_1_4*(3*a1+b1+b2-2)*(a1-b1-b2)+b1*b2-ctx.mpq_3_16)
c[2] = 2*(b1*b2+ctx.mpq_1_4*(a1-b1-b2)*(3*a1+b1+b2-2)-ctx.mpq_3_16)**2+\
ctx.mpq_1_16*(-16*(2*a1-3)*b1*b2 + \
4*(a1-b1-b2)*(-8*a1**2+11*a1+b1+b2-2)-3)
s1 = 0
s2 = 0
k = 0
tprev = 0
while 1:
if k not in c:
uu1 = (3*k**2+(-6*a1+2*b1+2*b2-4)*k + 3*a1**2 - \
(b1-b2)**2 - 2*a1*(b1+b2-2) + ctx.mpq_1_4)
uu2 = (k-a1+b1-b2-ctx.mpq_1_2)*(k-a1-b1+b2-ctx.mpq_1_2)*\
(k-a1+b1+b2-ctx.mpq_5_2)
c[k] = ctx.one/(2*k)*(uu1*c[k-1]-uu2*c[k-2])
w = c[k] * (-z)**(-0.5*k)
t1 = (-ctx.j)**k * ctx.mpf(2)**(-k) * w
t2 = ctx.j**k * ctx.mpf(2)**(-k) * w
if abs(t1) < 0.1*ctx.eps:
#print "Convergence :)"
break
# Quit if the series doesn't converge quickly enough
if k > 5 and abs(tprev) / abs(t1) < 1.5:
#print "No convergence :("
raise ctx.NoConvergence
s1 += t1
s2 += t2
tprev = t1
k += 1
S = ctx.expj(ctx.pi*X+2*ctx.sqrt(-z))*s1 + \
ctx.expj(-(ctx.pi*X+2*ctx.sqrt(-z)))*s2
T1 = [0.5*S, ctx.pi, -z], [1, -0.5, X], [b1, b2], [a1],\
[], [], 0
T2 = [-z], [-a1], [b1,b2],[b1-a1,b2-a1], \
[a1,a1-b1+1,a1-b2+1], [], 1/z
return T1, T2
v = ctx.hypercomb(h, [a1,b1,b2], force_series=True, maxterms=4*ctx.prec)
if sum(ctx._is_real_type(u) for u in [a1,b1,b2,z]) == 4:
v = ctx.re(v)
return v
except ctx.NoConvergence:
pass
finally:
ctx.prec = orig
#print "not using asymp"
return ctx.hypsum(1, 2, (a1type, b1type, b2type), [a1, b1, b2], z, **kwargs)
@defun
def _hyp2f3(ctx, a_s, b_s, z, **kwargs):
(a1, a1type), (a2, a2type) = a_s
(b1, b1type), (b2, b2type), (b3, b3type) = b_s
absz = abs(z)
magz = ctx.mag(z)
# Asymptotic expansion is ~ exp(sqrt(z))
asymp_extraprec = z and magz//2
orig = ctx.prec
# Asymptotic series is in terms of 4F1
# The square root below empirically provides a plausible criterion
# for the leading series to converge
can_use_asymptotic = (not kwargs.get('force_series')) and \
(ctx.mag(absz) > 19) and (ctx.sqrt(absz) > 1.5*orig)
if can_use_asymptotic:
#print "using asymp"
try:
try:
ctx.prec += asymp_extraprec
# http://functions.wolfram.com/HypergeometricFunctions/
# Hypergeometric2F3/06/02/03/01/0002/
def h(a1,a2,b1,b2,b3):
X = ctx.mpq_1_2*(a1+a2-b1-b2-b3+ctx.mpq_1_2)
A2 = a1+a2
B3 = b1+b2+b3
A = a1*a2
B = b1*b2+b3*b2+b1*b3
R = b1*b2*b3
c = {}
c[0] = ctx.one
c[1] = 2*(B - A + ctx.mpq_1_4*(3*A2+B3-2)*(A2-B3) - ctx.mpq_3_16)
c[2] = ctx.mpq_1_2*c[1]**2 + ctx.mpq_1_16*(-16*(2*A2-3)*(B-A) + 32*R +\
4*(-8*A2**2 + 11*A2 + 8*A + B3 - 2)*(A2-B3)-3)
s1 = 0
s2 = 0
k = 0
tprev = 0
while 1:
if k not in c:
uu1 = (k-2*X-3)*(k-2*X-2*b1-1)*(k-2*X-2*b2-1)*\
(k-2*X-2*b3-1)
uu2 = (4*(k-1)**3 - 6*(4*X+B3)*(k-1)**2 + \
2*(24*X**2+12*B3*X+4*B+B3-1)*(k-1) - 32*X**3 - \
24*B3*X**2 - 4*B - 8*R - 4*(4*B+B3-1)*X + 2*B3-1)
uu3 = (5*(k-1)**2+2*(-10*X+A2-3*B3+3)*(k-1)+2*c[1])
c[k] = ctx.one/(2*k)*(uu1*c[k-3]-uu2*c[k-2]+uu3*c[k-1])
w = c[k] * ctx.power(-z, -0.5*k)
t1 = (-ctx.j)**k * ctx.mpf(2)**(-k) * w
t2 = ctx.j**k * ctx.mpf(2)**(-k) * w
if abs(t1) < 0.1*ctx.eps:
break
# Quit if the series doesn't converge quickly enough
if k > 5 and abs(tprev) / abs(t1) < 1.5:
raise ctx.NoConvergence
s1 += t1
s2 += t2
tprev = t1
k += 1
S = ctx.expj(ctx.pi*X+2*ctx.sqrt(-z))*s1 + \
ctx.expj(-(ctx.pi*X+2*ctx.sqrt(-z)))*s2
T1 = [0.5*S, ctx.pi, -z], [1, -0.5, X], [b1, b2, b3], [a1, a2],\
[], [], 0
T2 = [-z], [-a1], [b1,b2,b3,a2-a1],[a2,b1-a1,b2-a1,b3-a1], \
[a1,a1-b1+1,a1-b2+1,a1-b3+1], [a1-a2+1], 1/z
T3 = [-z], [-a2], [b1,b2,b3,a1-a2],[a1,b1-a2,b2-a2,b3-a2], \
[a2,a2-b1+1,a2-b2+1,a2-b3+1],[-a1+a2+1], 1/z
return T1, T2, T3
v = ctx.hypercomb(h, [a1,a2,b1,b2,b3], force_series=True, maxterms=4*ctx.prec)
if sum(ctx._is_real_type(u) for u in [a1,a2,b1,b2,b3,z]) == 6:
v = ctx.re(v)
return v
except ctx.NoConvergence:
pass
finally:
ctx.prec = orig
return ctx.hypsum(2, 3, (a1type, a2type, b1type, b2type, b3type), [a1, a2, b1, b2, b3], z, **kwargs)
@defun
def _hyp2f0(ctx, a_s, b_s, z, **kwargs):
(a, atype), (b, btype) = a_s
# We want to try aggressively to use the asymptotic expansion,
# and fall back only when absolutely necessary
try:
kwargsb = kwargs.copy()
kwargsb['maxterms'] = kwargsb.get('maxterms', ctx.prec)
return ctx.hypsum(2, 0, (atype,btype), [a,b], z, **kwargsb)
except ctx.NoConvergence:
if kwargs.get('force_series'):
raise
pass
def h(a, b):
w = ctx.sinpi(b)
rz = -1/z
T1 = ([ctx.pi,w,rz],[1,-1,a],[],[a-b+1,b],[a],[b],rz)
T2 = ([-ctx.pi,w,rz],[1,-1,1+a-b],[],[a,2-b],[a-b+1],[2-b],rz)
return T1, T2
return ctx.hypercomb(h, [a, 1+a-b], **kwargs)
@defun
def meijerg(ctx, a_s, b_s, z, r=1, series=None, **kwargs):
an, ap = a_s
bm, bq = b_s
n = len(an)
p = n + len(ap)
m = len(bm)
q = m + len(bq)
a = an+ap
b = bm+bq
a = [ctx.convert(_) for _ in a]
b = [ctx.convert(_) for _ in b]
z = ctx.convert(z)
if series is None:
if p < q: series = 1
if p > q: series = 2
if p == q:
if m+n == p and abs(z) > 1:
series = 2
else:
series = 1
if kwargs.get('verbose'):
print("Meijer G m,n,p,q,series =", m,n,p,q,series)
if series == 1:
def h(*args):
a = args[:p]
b = args[p:]
terms = []
for k in range(m):
bases = [z]
expts = [b[k]/r]
gn = [b[j]-b[k] for j in range(m) if j != k]
gn += [1-a[j]+b[k] for j in range(n)]
gd = [a[j]-b[k] for j in range(n,p)]
gd += [1-b[j]+b[k] for j in range(m,q)]
hn = [1-a[j]+b[k] for j in range(p)]
hd = [1-b[j]+b[k] for j in range(q) if j != k]
hz = (-ctx.one)**(p-m-n) * z**(ctx.one/r)
terms.append((bases, expts, gn, gd, hn, hd, hz))
return terms
else:
def h(*args):
a = args[:p]
b = args[p:]
terms = []
for k in range(n):
bases = [z]
if r == 1:
expts = [a[k]-1]
else:
expts = [(a[k]-1)/ctx.convert(r)]
gn = [a[k]-a[j] for j in range(n) if j != k]
gn += [1-a[k]+b[j] for j in range(m)]
gd = [a[k]-b[j] for j in range(m,q)]
gd += [1-a[k]+a[j] for j in range(n,p)]
hn = [1-a[k]+b[j] for j in range(q)]
hd = [1+a[j]-a[k] for j in range(p) if j != k]
hz = (-ctx.one)**(q-m-n) / z**(ctx.one/r)
terms.append((bases, expts, gn, gd, hn, hd, hz))
return terms
return ctx.hypercomb(h, a+b, **kwargs)
@defun_wrapped
def appellf1(ctx,a,b1,b2,c,x,y,**kwargs):
# Assume x smaller
# We will use x for the outer loop
if abs(x) > abs(y):
x, y = y, x
b1, b2 = b2, b1
def ok(x):
return abs(x) < 0.99
# Finite cases
if ctx.isnpint(a):
pass
elif ctx.isnpint(b1):
pass
elif ctx.isnpint(b2):
x, y, b1, b2 = y, x, b2, b1
else:
#print x, y
# Note: ok if |y| > 1, because
# 2F1 implements analytic continuation
if not ok(x):
u1 = (x-y)/(x-1)
if not ok(u1):
raise ValueError("Analytic continuation not implemented")
#print "Using analytic continuation"
return (1-x)**(-b1)*(1-y)**(c-a-b2)*\
ctx.appellf1(c-a,b1,c-b1-b2,c,u1,y,**kwargs)
return ctx.hyper2d({'m+n':[a],'m':[b1],'n':[b2]}, {'m+n':[c]}, x,y, **kwargs)
@defun
def appellf2(ctx,a,b1,b2,c1,c2,x,y,**kwargs):
# TODO: continuation
return ctx.hyper2d({'m+n':[a],'m':[b1],'n':[b2]},
{'m':[c1],'n':[c2]}, x,y, **kwargs)
@defun
def appellf3(ctx,a1,a2,b1,b2,c,x,y,**kwargs):
outer_polynomial = ctx.isnpint(a1) or ctx.isnpint(b1)
inner_polynomial = ctx.isnpint(a2) or ctx.isnpint(b2)
if not outer_polynomial:
if inner_polynomial or abs(x) > abs(y):
x, y = y, x
a1,a2,b1,b2 = a2,a1,b2,b1
return ctx.hyper2d({'m':[a1,b1],'n':[a2,b2]}, {'m+n':[c]},x,y,**kwargs)
@defun
def appellf4(ctx,a,b,c1,c2,x,y,**kwargs):
# TODO: continuation
return ctx.hyper2d({'m+n':[a,b]}, {'m':[c1],'n':[c2]},x,y,**kwargs)
@defun
def hyper2d(ctx, a, b, x, y, **kwargs):
r"""
Sums the generalized 2D hypergeometric series
.. math ::
\sum_{m=0}^{\infty} \sum_{n=0}^{\infty}
\frac{P((a),m,n)}{Q((b),m,n)}
\frac{x^m y^n} {m! n!}
where `(a) = (a_1,\ldots,a_r)`, `(b) = (b_1,\ldots,b_s)` and where
`P` and `Q` are products of rising factorials such as `(a_j)_n` or
`(a_j)_{m+n}`. `P` and `Q` are specified in the form of dicts, with
the `m` and `n` dependence as keys and parameter lists as values.
The supported rising factorials are given in the following table
(note that only a few are supported in `Q`):
+------------+-------------------+--------+
| Key | Rising factorial | `Q` |
+============+===================+========+
| ``'m'`` | `(a_j)_m` | Yes |
+------------+-------------------+--------+
| ``'n'`` | `(a_j)_n` | Yes |
+------------+-------------------+--------+
| ``'m+n'`` | `(a_j)_{m+n}` | Yes |
+------------+-------------------+--------+
| ``'m-n'`` | `(a_j)_{m-n}` | No |
+------------+-------------------+--------+
| ``'n-m'`` | `(a_j)_{n-m}` | No |
+------------+-------------------+--------+
| ``'2m+n'`` | `(a_j)_{2m+n}` | No |
+------------+-------------------+--------+
| ``'2m-n'`` | `(a_j)_{2m-n}` | No |
+------------+-------------------+--------+
| ``'2n-m'`` | `(a_j)_{2n-m}` | No |
+------------+-------------------+--------+
For example, the Appell F1 and F4 functions
.. math ::
F_1 = \sum_{m=0}^{\infty} \sum_{n=0}^{\infty}
\frac{(a)_{m+n} (b)_m (c)_n}{(d)_{m+n}}
\frac{x^m y^n}{m! n!}
F_4 = \sum_{m=0}^{\infty} \sum_{n=0}^{\infty}
\frac{(a)_{m+n} (b)_{m+n}}{(c)_m (d)_{n}}
\frac{x^m y^n}{m! n!}
can be represented respectively as
``hyper2d({'m+n':[a], 'm':[b], 'n':[c]}, {'m+n':[d]}, x, y)``
``hyper2d({'m+n':[a,b]}, {'m':[c], 'n':[d]}, x, y)``
More generally, :func:`~mpmath.hyper2d` can evaluate any of the 34 distinct
convergent second-order (generalized Gaussian) hypergeometric
series enumerated by Horn, as well as the Kampe de Feriet
function.
The series is computed by rewriting it so that the inner
series (i.e. the series containing `n` and `y`) has the form of an
ordinary generalized hypergeometric series and thereby can be
evaluated efficiently using :func:`~mpmath.hyper`. If possible,
manually swapping `x` and `y` and the corresponding parameters
can sometimes give better results.
**Examples**
Two separable cases: a product of two geometric series, and a
product of two Gaussian hypergeometric functions::
>>> from mpmath import *
>>> mp.dps = 25; mp.pretty = True
>>> x, y = mpf(0.25), mpf(0.5)
>>> hyper2d({'m':1,'n':1}, {}, x,y)
2.666666666666666666666667
>>> 1/(1-x)/(1-y)
2.666666666666666666666667
>>> hyper2d({'m':[1,2],'n':[3,4]}, {'m':[5],'n':[6]}, x,y)
4.164358531238938319669856
>>> hyp2f1(1,2,5,x)*hyp2f1(3,4,6,y)
4.164358531238938319669856
Some more series that can be done in closed form::
>>> hyper2d({'m':1,'n':1},{'m+n':1},x,y)
2.013417124712514809623881
>>> (exp(x)*x-exp(y)*y)/(x-y)
2.013417124712514809623881
Six of the 34 Horn functions, G1-G3 and H1-H3::
>>> from mpmath import *
>>> mp.dps = 10; mp.pretty = True
>>> x, y = 0.0625, 0.125
>>> a1,a2,b1,b2,c1,c2,d = 1.1,-1.2,-1.3,-1.4,1.5,-1.6,1.7
>>> hyper2d({'m+n':a1,'n-m':b1,'m-n':b2},{},x,y) # G1
1.139090746
>>> nsum(lambda m,n: rf(a1,m+n)*rf(b1,n-m)*rf(b2,m-n)*\
... x**m*y**n/fac(m)/fac(n), [0,inf], [0,inf])
1.139090746
>>> hyper2d({'m':a1,'n':a2,'n-m':b1,'m-n':b2},{},x,y) # G2
0.9503682696
>>> nsum(lambda m,n: rf(a1,m)*rf(a2,n)*rf(b1,n-m)*rf(b2,m-n)*\
... x**m*y**n/fac(m)/fac(n), [0,inf], [0,inf])
0.9503682696
>>> hyper2d({'2n-m':a1,'2m-n':a2},{},x,y) # G3
1.029372029
>>> nsum(lambda m,n: rf(a1,2*n-m)*rf(a2,2*m-n)*\
... x**m*y**n/fac(m)/fac(n), [0,inf], [0,inf])
1.029372029
>>> hyper2d({'m-n':a1,'m+n':b1,'n':c1},{'m':d},x,y) # H1
-1.605331256
>>> nsum(lambda m,n: rf(a1,m-n)*rf(b1,m+n)*rf(c1,n)/rf(d,m)*\
... x**m*y**n/fac(m)/fac(n), [0,inf], [0,inf])
-1.605331256
>>> hyper2d({'m-n':a1,'m':b1,'n':[c1,c2]},{'m':d},x,y) # H2
-2.35405404
>>> nsum(lambda m,n: rf(a1,m-n)*rf(b1,m)*rf(c1,n)*rf(c2,n)/rf(d,m)*\
... x**m*y**n/fac(m)/fac(n), [0,inf], [0,inf])
-2.35405404
>>> hyper2d({'2m+n':a1,'n':b1},{'m+n':c1},x,y) # H3
0.974479074
>>> nsum(lambda m,n: rf(a1,2*m+n)*rf(b1,n)/rf(c1,m+n)*\
... x**m*y**n/fac(m)/fac(n), [0,inf], [0,inf])
0.974479074
**References**
1. [SrivastavaKarlsson]_
2. [Weisstein]_ http://mathworld.wolfram.com/HornFunction.html
3. [Weisstein]_ http://mathworld.wolfram.com/AppellHypergeometricFunction.html
"""
x = ctx.convert(x)
y = ctx.convert(y)
def parse(dct, key):
args = dct.pop(key, [])
try:
args = list(args)
except TypeError:
args = [args]
return [ctx.convert(arg) for arg in args]
a_s = dict(a)
b_s = dict(b)
a_m = parse(a, 'm')
a_n = parse(a, 'n')
a_m_add_n = parse(a, 'm+n')
a_m_sub_n = parse(a, 'm-n')
a_n_sub_m = parse(a, 'n-m')
a_2m_add_n = parse(a, '2m+n')
a_2m_sub_n = parse(a, '2m-n')
a_2n_sub_m = parse(a, '2n-m')
b_m = parse(b, 'm')
b_n = parse(b, 'n')
b_m_add_n = parse(b, 'm+n')
if a: raise ValueError("unsupported key: %r" % a.keys()[0])
if b: raise ValueError("unsupported key: %r" % b.keys()[0])
s = 0
outer = ctx.one
m = ctx.mpf(0)
ok_count = 0
prec = ctx.prec
maxterms = kwargs.get('maxterms', 20*prec)
try:
ctx.prec += 10
tol = +ctx.eps
while 1:
inner_sign = 1
outer_sign = 1
inner_a = list(a_n)
inner_b = list(b_n)
outer_a = [a+m for a in a_m]
outer_b = [b+m for b in b_m]
# (a)_{m+n} = (a)_m (a+m)_n
for a in a_m_add_n:
a = a+m
inner_a.append(a)
outer_a.append(a)
# (b)_{m+n} = (b)_m (b+m)_n
for b in b_m_add_n:
b = b+m
inner_b.append(b)
outer_b.append(b)
# (a)_{n-m} = (a-m)_n / (a-m)_m
for a in a_n_sub_m:
inner_a.append(a-m)
outer_b.append(a-m-1)
# (a)_{m-n} = (-1)^(m+n) (1-a-m)_m / (1-a-m)_n
for a in a_m_sub_n:
inner_sign *= (-1)
outer_sign *= (-1)**(m)
inner_b.append(1-a-m)
outer_a.append(-a-m)
# (a)_{2m+n} = (a)_{2m} (a+2m)_n
for a in a_2m_add_n:
inner_a.append(a+2*m)
outer_a.append((a+2*m)*(1+a+2*m))
# (a)_{2m-n} = (-1)^(2m+n) (1-a-2m)_{2m} / (1-a-2m)_n
for a in a_2m_sub_n:
inner_sign *= (-1)
inner_b.append(1-a-2*m)
outer_a.append((a+2*m)*(1+a+2*m))
# (a)_{2n-m} = 4^n ((a-m)/2)_n ((a-m+1)/2)_n / (a-m)_m
for a in a_2n_sub_m:
inner_sign *= 4
inner_a.append(0.5*(a-m))
inner_a.append(0.5*(a-m+1))
outer_b.append(a-m-1)
inner = ctx.hyper(inner_a, inner_b, inner_sign*y,
zeroprec=ctx.prec, **kwargs)
term = outer * inner * outer_sign
if abs(term) < tol:
ok_count += 1
else:
ok_count = 0
if ok_count >= 3 or not outer:
break
s += term
for a in outer_a: outer *= a
for b in outer_b: outer /= b
m += 1
outer = outer * x / m
if m > maxterms:
raise ctx.NoConvergence("maxterms exceeded in hyper2d")
finally:
ctx.prec = prec
return +s
"""
@defun
def kampe_de_feriet(ctx,a,b,c,d,e,f,x,y,**kwargs):
return ctx.hyper2d({'m+n':a,'m':b,'n':c},
{'m+n':d,'m':e,'n':f}, x,y, **kwargs)
"""
@defun
def bihyper(ctx, a_s, b_s, z, **kwargs):
r"""
Evaluates the bilateral hypergeometric series
.. math ::
\,_AH_B(a_1, \ldots, a_k; b_1, \ldots, b_B; z) =
\sum_{n=-\infty}^{\infty}
\frac{(a_1)_n \ldots (a_A)_n}
{(b_1)_n \ldots (b_B)_n} \, z^n
where, for direct convergence, `A = B` and `|z| = 1`, although a
regularized sum exists more generally by considering the
bilateral series as a sum of two ordinary hypergeometric
functions. In order for the series to make sense, none of the
parameters may be integers.
**Examples**
The value of `\,_2H_2` at `z = 1` is given by Dougall's formula::
>>> from mpmath import *
>>> mp.dps = 25; mp.pretty = True
>>> a,b,c,d = 0.5, 1.5, 2.25, 3.25
>>> bihyper([a,b],[c,d],1)
-14.49118026212345786148847
>>> gammaprod([c,d,1-a,1-b,c+d-a-b-1],[c-a,d-a,c-b,d-b])
-14.49118026212345786148847
The regularized function `\,_1H_0` can be expressed as the
sum of one `\,_2F_0` function and one `\,_1F_1` function::
>>> a = mpf(0.25)
>>> z = mpf(0.75)
>>> bihyper([a], [], z)
(0.2454393389657273841385582 + 0.2454393389657273841385582j)
>>> hyper([a,1],[],z) + (hyper([1],[1-a],-1/z)-1)
(0.2454393389657273841385582 + 0.2454393389657273841385582j)
>>> hyper([a,1],[],z) + hyper([1],[2-a],-1/z)/z/(a-1)
(0.2454393389657273841385582 + 0.2454393389657273841385582j)
**References**
1. [Slater]_ (chapter 6: "Bilateral Series", pp. 180-189)
2. [Wikipedia]_ http://en.wikipedia.org/wiki/Bilateral_hypergeometric_series
"""
z = ctx.convert(z)
c_s = a_s + b_s
p = len(a_s)
q = len(b_s)
if (p, q) == (0,0) or (p, q) == (1,1):
return ctx.zero * z
neg = (p-q) % 2
def h(*c_s):
a_s = list(c_s[:p])
b_s = list(c_s[p:])
aa_s = [2-b for b in b_s]
bb_s = [2-a for a in a_s]
rp = [(-1)**neg * z] + [1-b for b in b_s] + [1-a for a in a_s]
rc = [-1] + [1]*len(b_s) + [-1]*len(a_s)
T1 = [], [], [], [], a_s + [1], b_s, z
T2 = rp, rc, [], [], aa_s + [1], bb_s, (-1)**neg / z
return T1, T2
return ctx.hypercomb(h, c_s, **kwargs)