Upload libhyper.py with huggingface_hub

libhyper.py

@@ -0,0 +1,1150 @@
+"""
+This module implements computation of hypergeometric and related
+functions. In particular, it provides code for generic summation
+of hypergeometric series. Optimized versions for various special
+cases are also provided.
+"""
+
+import operator
+import math
+
+from .backend import MPZ_ZERO, MPZ_ONE, BACKEND, xrange, exec_
+
+from .libintmath import gcd
+
+from .libmpf import (\
+    ComplexResult, round_fast, round_nearest,
+    negative_rnd, bitcount, to_fixed, from_man_exp, from_int, to_int,
+    from_rational,
+    fzero, fone, fnone, ftwo, finf, fninf, fnan,
+    mpf_sign, mpf_add, mpf_abs, mpf_pos,
+    mpf_cmp, mpf_lt, mpf_le, mpf_gt, mpf_min_max,
+    mpf_perturb, mpf_neg, mpf_shift, mpf_sub, mpf_mul, mpf_div,
+    sqrt_fixed, mpf_sqrt, mpf_rdiv_int, mpf_pow_int,
+    to_rational,
+)
+
+from .libelefun import (\
+    mpf_pi, mpf_exp, mpf_log, pi_fixed, mpf_cos_sin, mpf_cos, mpf_sin,
+    mpf_sqrt, agm_fixed,
+)
+
+from .libmpc import (\
+    mpc_one, mpc_sub, mpc_mul_mpf, mpc_mul, mpc_neg, complex_int_pow,
+    mpc_div, mpc_add_mpf, mpc_sub_mpf,
+    mpc_log, mpc_add, mpc_pos, mpc_shift,
+    mpc_is_infnan, mpc_zero, mpc_sqrt, mpc_abs,
+    mpc_mpf_div, mpc_square, mpc_exp
+)
+
+from .libintmath import ifac
+from .gammazeta import mpf_gamma_int, mpf_euler, euler_fixed
+
+class NoConvergence(Exception):
+    pass
+
+
+#-----------------------------------------------------------------------#
+#                                                                       #
+#                     Generic hypergeometric series                     #
+#                                                                       #
+#-----------------------------------------------------------------------#
+
+"""
+TODO:
+
+1. proper mpq parsing
+2. imaginary z special-cased (also: rational, integer?)
+3. more clever handling of series that don't converge because of stupid
+   upwards rounding
+4. checking for cancellation
+
+"""
+
+def make_hyp_summator(key):
+    """
+    Returns a function that sums a generalized hypergeometric series,
+    for given parameter types (integer, rational, real, complex).
+
+    """
+    p, q, param_types, ztype = key
+
+    pstring = "".join(param_types)
+    fname = "hypsum_%i_%i_%s_%s_%s" % (p, q, pstring[:p], pstring[p:], ztype)
+    #print "generating hypsum", fname
+
+    have_complex_param = 'C' in param_types
+    have_complex_arg = ztype == 'C'
+    have_complex = have_complex_param or have_complex_arg
+
+    source = []
+    add = source.append
+
+    aint = []
+    arat = []
+    bint = []
+    brat = []
+    areal = []
+    breal = []
+    acomplex = []
+    bcomplex = []
+
+    #add("wp = prec + 40")
+    add("MAX = kwargs.get('maxterms', wp*100)")
+    add("HIGH = MPZ_ONE<<epsshift")
+    add("LOW = -HIGH")
+
+    # Setup code
+    add("SRE = PRE = one = (MPZ_ONE << wp)")
+    if have_complex:
+        add("SIM = PIM = MPZ_ZERO")
+
+    if have_complex_arg:
+        add("xsign, xm, xe, xbc = z[0]")
+        add("if xsign: xm = -xm")
+        add("ysign, ym, ye, ybc = z[1]")
+        add("if ysign: ym = -ym")
+    else:
+        add("xsign, xm, xe, xbc = z")
+        add("if xsign: xm = -xm")
+
+    add("offset = xe + wp")
+    add("if offset >= 0:")
+    add("    ZRE = xm << offset")
+    add("else:")
+    add("    ZRE = xm >> (-offset)")
+    if have_complex_arg:
+        add("offset = ye + wp")
+        add("if offset >= 0:")
+        add("    ZIM = ym << offset")
+        add("else:")
+        add("    ZIM = ym >> (-offset)")
+
+    for i, flag in enumerate(param_types):
+        W = ["A", "B"][i >= p]
+        if flag == 'Z':
+            ([aint,bint][i >= p]).append(i)
+            add("%sINT_%i = coeffs[%i]" % (W, i, i))
+        elif flag == 'Q':
+            ([arat,brat][i >= p]).append(i)
+            add("%sP_%i, %sQ_%i = coeffs[%i]._mpq_" % (W, i, W, i, i))
+        elif flag == 'R':
+            ([areal,breal][i >= p]).append(i)
+            add("xsign, xm, xe, xbc = coeffs[%i]._mpf_" % i)
+            add("if xsign: xm = -xm")
+            add("offset = xe + wp")
+            add("if offset >= 0:")
+            add("    %sREAL_%i = xm << offset" % (W, i))
+            add("else:")
+            add("    %sREAL_%i = xm >> (-offset)" % (W, i))
+        elif flag == 'C':
+            ([acomplex,bcomplex][i >= p]).append(i)
+            add("__re, __im = coeffs[%i]._mpc_" % i)
+            add("xsign, xm, xe, xbc = __re")
+            add("if xsign: xm = -xm")
+            add("ysign, ym, ye, ybc = __im")
+            add("if ysign: ym = -ym")
+
+            add("offset = xe + wp")
+            add("if offset >= 0:")
+            add("    %sCRE_%i = xm << offset" % (W, i))
+            add("else:")
+            add("    %sCRE_%i = xm >> (-offset)" % (W, i))
+            add("offset = ye + wp")
+            add("if offset >= 0:")
+            add("    %sCIM_%i = ym << offset" % (W, i))
+            add("else:")
+            add("    %sCIM_%i = ym >> (-offset)" % (W, i))
+        else:
+            raise ValueError
+
+    l_areal = len(areal)
+    l_breal = len(breal)
+    cancellable_real = min(l_areal, l_breal)
+    noncancellable_real_num = areal[cancellable_real:]
+    noncancellable_real_den = breal[cancellable_real:]
+
+    # LOOP
+    add("for n in xrange(1,10**8):")
+
+    add("    if n in magnitude_check:")
+    add("        p_mag = bitcount(abs(PRE))")
+    if have_complex:
+        add("        p_mag = max(p_mag, bitcount(abs(PIM)))")
+    add("        magnitude_check[n] = wp-p_mag")
+
+    # Real factors
+    multiplier = " * ".join(["AINT_#".replace("#", str(i)) for i in aint] + \
+                            ["AP_#".replace("#", str(i)) for i in arat] + \
+                            ["BQ_#".replace("#", str(i)) for i in brat])
+
+    divisor    = " * ".join(["BINT_#".replace("#", str(i)) for i in bint] + \
+                            ["BP_#".replace("#", str(i)) for i in brat] + \
+                            ["AQ_#".replace("#", str(i)) for i in arat] + ["n"])
+
+    if multiplier:
+        add("    mul = " + multiplier)
+    add("    div = " + divisor)
+
+    # Check for singular terms
+    add("    if not div:")
+    if multiplier:
+        add("        if not mul:")
+        add("            break")
+    add("        raise ZeroDivisionError")
+
+    # Update product
+    if have_complex:
+
+        # TODO: when there are several real parameters and just a few complex
+        # (maybe just the complex argument), we only need to do about
+        # half as many ops if we accumulate the real factor in a single real variable
+        for k in range(cancellable_real): add("    PRE = PRE * AREAL_%i // BREAL_%i" % (areal[k], breal[k]))
+        for i in noncancellable_real_num: add("    PRE = (PRE * AREAL_#) >> wp".replace("#", str(i)))
+        for i in noncancellable_real_den: add("    PRE = (PRE << wp) // BREAL_#".replace("#", str(i)))
+        for k in range(cancellable_real): add("    PIM = PIM * AREAL_%i // BREAL_%i" % (areal[k], breal[k]))
+        for i in noncancellable_real_num: add("    PIM = (PIM * AREAL_#) >> wp".replace("#", str(i)))
+        for i in noncancellable_real_den: add("    PIM = (PIM << wp) // BREAL_#".replace("#", str(i)))
+
+        if multiplier:
+            if have_complex_arg:
+                add("    PRE, PIM = (mul*(PRE*ZRE-PIM*ZIM))//div, (mul*(PIM*ZRE+PRE*ZIM))//div")
+                add("    PRE >>= wp")
+                add("    PIM >>= wp")
+            else:
+                add("    PRE = ((mul * PRE * ZRE) >> wp) // div")
+                add("    PIM = ((mul * PIM * ZRE) >> wp) // div")
+        else:
+            if have_complex_arg:
+                add("    PRE, PIM = (PRE*ZRE-PIM*ZIM)//div, (PIM*ZRE+PRE*ZIM)//div")
+                add("    PRE >>= wp")
+                add("    PIM >>= wp")
+            else:
+                add("    PRE = ((PRE * ZRE) >> wp) // div")
+                add("    PIM = ((PIM * ZRE) >> wp) // div")
+
+        for i in acomplex:
+            add("    PRE, PIM = PRE*ACRE_#-PIM*ACIM_#, PIM*ACRE_#+PRE*ACIM_#".replace("#", str(i)))
+            add("    PRE >>= wp")
+            add("    PIM >>= wp")
+
+        for i in bcomplex:
+            add("    mag = BCRE_#*BCRE_#+BCIM_#*BCIM_#".replace("#", str(i)))
+            add("    re = PRE*BCRE_# + PIM*BCIM_#".replace("#", str(i)))
+            add("    im = PIM*BCRE_# - PRE*BCIM_#".replace("#", str(i)))
+            add("    PRE = (re << wp) // mag".replace("#", str(i)))
+            add("    PIM = (im << wp) // mag".replace("#", str(i)))
+
+    else:
+        for k in range(cancellable_real): add("    PRE = PRE * AREAL_%i // BREAL_%i" % (areal[k], breal[k]))
+        for i in noncancellable_real_num: add("    PRE = (PRE * AREAL_#) >> wp".replace("#", str(i)))
+        for i in noncancellable_real_den: add("    PRE = (PRE << wp) // BREAL_#".replace("#", str(i)))
+        if multiplier:
+            add("    PRE = ((PRE * mul * ZRE) >> wp) // div")
+        else:
+            add("    PRE = ((PRE * ZRE) >> wp) // div")
+
+    # Add product to sum
+    if have_complex:
+        add("    SRE += PRE")
+        add("    SIM += PIM")
+        add("    if (HIGH > PRE > LOW) and (HIGH > PIM > LOW):")
+        add("        break")
+    else:
+        add("    SRE += PRE")
+        add("    if HIGH > PRE > LOW:")
+        add("        break")
+
+    #add("    from mpmath import nprint, log, ldexp")
+    #add("    nprint([n, log(abs(PRE),2), ldexp(PRE,-wp)])")
+
+    add("    if n > MAX:")
+    add("        raise NoConvergence('Hypergeometric series converges too slowly. Try increasing maxterms.')")
+
+    # +1 all parameters for next loop
+    for i in aint:     add("    AINT_# += 1".replace("#", str(i)))
+    for i in bint:     add("    BINT_# += 1".replace("#", str(i)))
+    for i in arat:     add("    AP_# += AQ_#".replace("#", str(i)))
+    for i in brat:     add("    BP_# += BQ_#".replace("#", str(i)))
+    for i in areal:    add("    AREAL_# += one".replace("#", str(i)))
+    for i in breal:    add("    BREAL_# += one".replace("#", str(i)))
+    for i in acomplex: add("    ACRE_# += one".replace("#", str(i)))
+    for i in bcomplex: add("    BCRE_# += one".replace("#", str(i)))
+
+    if have_complex:
+        add("a = from_man_exp(SRE, -wp, prec, 'n')")
+        add("b = from_man_exp(SIM, -wp, prec, 'n')")
+
+        add("if SRE:")
+        add("    if SIM:")
+        add("        magn = max(a[2]+a[3], b[2]+b[3])")
+        add("    else:")
+        add("        magn = a[2]+a[3]")
+        add("elif SIM:")
+        add("    magn = b[2]+b[3]")
+        add("else:")
+        add("    magn = -wp+1")
+
+        add("return (a, b), True, magn")
+    else:
+        add("a = from_man_exp(SRE, -wp, prec, 'n')")
+
+        add("if SRE:")
+        add("    magn = a[2]+a[3]")
+        add("else:")
+        add("    magn = -wp+1")
+
+        add("return a, False, magn")
+
+    source = "\n".join(("    " + line) for line in source)
+    source = ("def %s(coeffs, z, prec, wp, epsshift, magnitude_check, **kwargs):\n" % fname) + source
+
+    namespace = {}
+
+    exec_(source, globals(), namespace)
+
+    #print source
+    return source, namespace[fname]
+
+
+if BACKEND == 'sage':
+
+    def make_hyp_summator(key):
+        """
+        Returns a function that sums a generalized hypergeometric series,
+        for given parameter types (integer, rational, real, complex).
+        """
+        from sage.libs.mpmath.ext_main import hypsum_internal
+        p, q, param_types, ztype = key
+        def _hypsum(coeffs, z, prec, wp, epsshift, magnitude_check, **kwargs):
+            return hypsum_internal(p, q, param_types, ztype, coeffs, z,
+                prec, wp, epsshift, magnitude_check, kwargs)
+
+        return "(none)", _hypsum
+
+
+#-----------------------------------------------------------------------#
+#                                                                       #
+#                              Error functions                          #
+#                                                                       #
+#-----------------------------------------------------------------------#
+
+# TODO: mpf_erf should call mpf_erfc when appropriate (currently
+#    only the converse delegation is implemented)
+
+def mpf_erf(x, prec, rnd=round_fast):
+    sign, man, exp, bc = x
+    if not man:
+        if x == fzero: return fzero
+        if x == finf: return fone
+        if x== fninf: return fnone
+        return fnan
+    size = exp + bc
+    lg = math.log
+    # The approximation erf(x) = 1 is accurate to > x^2 * log(e,2) bits
+    if size > 3 and 2*(size-1) + 0.528766 > lg(prec,2):
+        if sign:
+            return mpf_perturb(fnone, 0, prec, rnd)
+        else:
+            return mpf_perturb(fone, 1, prec, rnd)
+    # erf(x) ~ 2*x/sqrt(pi) close to 0
+    if size < -prec:
+        # 2*x
+        x = mpf_shift(x,1)
+        c = mpf_sqrt(mpf_pi(prec+20), prec+20)
+        # TODO: interval rounding
+        return mpf_div(x, c, prec, rnd)
+    wp = prec + abs(size) + 25
+    # Taylor series for erf, fixed-point summation
+    t = abs(to_fixed(x, wp))
+    t2 = (t*t) >> wp
+    s, term, k = t, 12345, 1
+    while term:
+        t = ((t * t2) >> wp) // k
+        term = t // (2*k+1)
+        if k & 1:
+            s -= term
+        else:
+            s += term
+        k += 1
+    s = (s << (wp+1)) // sqrt_fixed(pi_fixed(wp), wp)
+    if sign:
+        s = -s
+    return from_man_exp(s, -wp, prec, rnd)
+
+# If possible, we use the asymptotic series for erfc.
+# This is an alternating divergent asymptotic series, so
+# the error is at most equal to the first omitted term.
+# Here we check if the smallest term is small enough
+# for a given x and precision
+def erfc_check_series(x, prec):
+    n = to_int(x)
+    if n**2 * 1.44 > prec:
+        return True
+    return False
+
+def mpf_erfc(x, prec, rnd=round_fast):
+    sign, man, exp, bc = x
+    if not man:
+        if x == fzero: return fone
+        if x == finf: return fzero
+        if x == fninf: return ftwo
+        return fnan
+    wp = prec + 20
+    mag = bc+exp
+    # Preserve full accuracy when exponent grows huge
+    wp += max(0, 2*mag)
+    regular_erf = sign or mag < 2
+    if regular_erf or not erfc_check_series(x, wp):
+        if regular_erf:
+            return mpf_sub(fone, mpf_erf(x, prec+10, negative_rnd[rnd]), prec, rnd)
+        # 1-erf(x) ~ exp(-x^2), increase prec to deal with cancellation
+        n = to_int(x)+1
+        return mpf_sub(fone, mpf_erf(x, prec + int(n**2*1.44) + 10), prec, rnd)
+    s = term = MPZ_ONE << wp
+    term_prev = 0
+    t = (2 * to_fixed(x, wp) ** 2) >> wp
+    k = 1
+    while 1:
+        term = ((term * (2*k - 1)) << wp) // t
+        if k > 4 and term > term_prev or not term:
+            break
+        if k & 1:
+            s -= term
+        else:
+            s += term
+        term_prev = term
+        #print k, to_str(from_man_exp(term, -wp, 50), 10)
+        k += 1
+    s = (s << wp) // sqrt_fixed(pi_fixed(wp), wp)
+    s = from_man_exp(s, -wp, wp)
+    z = mpf_exp(mpf_neg(mpf_mul(x,x,wp),wp),wp)
+    y = mpf_div(mpf_mul(z, s, wp), x, prec, rnd)
+    return y
+
+
+#-----------------------------------------------------------------------#
+#                                                                       #
+#                         Exponential integrals                         #
+#                                                                       #
+#-----------------------------------------------------------------------#
+
+def ei_taylor(x, prec):
+    s = t = x
+    k = 2
+    while t:
+        t = ((t*x) >> prec) // k
+        s += t // k
+        k += 1
+    return s
+
+def complex_ei_taylor(zre, zim, prec):
+    _abs = abs
+    sre = tre = zre
+    sim = tim = zim
+    k = 2
+    while _abs(tre) + _abs(tim) > 5:
+        tre, tim = ((tre*zre-tim*zim)//k)>>prec, ((tre*zim+tim*zre)//k)>>prec
+        sre += tre // k
+        sim += tim // k
+        k += 1
+    return sre, sim
+
+def ei_asymptotic(x, prec):
+    one = MPZ_ONE << prec
+    x = t = ((one << prec) // x)
+    s = one + x
+    k = 2
+    while t:
+        t = (k*t*x) >> prec
+        s += t
+        k += 1
+    return s
+
+def complex_ei_asymptotic(zre, zim, prec):
+    _abs = abs
+    one = MPZ_ONE << prec
+    M = (zim*zim + zre*zre) >> prec
+    # 1 / z
+    xre = tre = (zre << prec) // M
+    xim = tim = ((-zim) << prec) // M
+    sre = one + xre
+    sim = xim
+    k = 2
+    while _abs(tre) + _abs(tim) > 1000:
+        #print tre, tim
+        tre, tim = ((tre*xre-tim*xim)*k)>>prec, ((tre*xim+tim*xre)*k)>>prec
+        sre += tre
+        sim += tim
+        k += 1
+        if k > prec:
+            raise NoConvergence
+    return sre, sim
+
+def mpf_ei(x, prec, rnd=round_fast, e1=False):
+    if e1:
+        x = mpf_neg(x)
+    sign, man, exp, bc = x
+    if e1 and not sign:
+        if x == fzero:
+            return finf
+        raise ComplexResult("E1(x) for x < 0")
+    if man:
+        xabs = 0, man, exp, bc
+        xmag = exp+bc
+        wp = prec + 20
+        can_use_asymp = xmag > wp
+        if not can_use_asymp:
+            if exp >= 0:
+                xabsint = man << exp
+            else:
+                xabsint = man >> (-exp)
+            can_use_asymp = xabsint > int(wp*0.693) + 10
+        if can_use_asymp:
+            if xmag > wp:
+                v = fone
+            else:
+                v = from_man_exp(ei_asymptotic(to_fixed(x, wp), wp), -wp)
+            v = mpf_mul(v, mpf_exp(x, wp), wp)
+            v = mpf_div(v, x, prec, rnd)
+        else:
+            wp += 2*int(to_int(xabs))
+            u = to_fixed(x, wp)
+            v = ei_taylor(u, wp) + euler_fixed(wp)
+            t1 = from_man_exp(v,-wp)
+            t2 = mpf_log(xabs,wp)
+            v = mpf_add(t1, t2, prec, rnd)
+    else:
+        if x == fzero: v = fninf
+        elif x == finf: v = finf
+        elif x == fninf: v = fzero
+        else: v = fnan
+    if e1:
+        v = mpf_neg(v)
+    return v
+
+def mpc_ei(z, prec, rnd=round_fast, e1=False):
+    if e1:
+        z = mpc_neg(z)
+    a, b = z
+    asign, aman, aexp, abc = a
+    bsign, bman, bexp, bbc = b
+    if b == fzero:
+        if e1:
+            x = mpf_neg(mpf_ei(a, prec, rnd))
+            if not asign:
+                y = mpf_neg(mpf_pi(prec, rnd))
+            else:
+                y = fzero
+            return x, y
+        else:
+            return mpf_ei(a, prec, rnd), fzero
+    if a != fzero:
+        if not aman or not bman:
+            return (fnan, fnan)
+    wp = prec + 40
+    amag = aexp+abc
+    bmag = bexp+bbc
+    zmag = max(amag, bmag)
+    can_use_asymp = zmag > wp
+    if not can_use_asymp:
+        zabsint = abs(to_int(a)) + abs(to_int(b))
+        can_use_asymp = zabsint > int(wp*0.693) + 20
+    try:
+        if can_use_asymp:
+            if zmag > wp:
+                v = fone, fzero
+            else:
+                zre = to_fixed(a, wp)
+                zim = to_fixed(b, wp)
+                vre, vim = complex_ei_asymptotic(zre, zim, wp)
+                v = from_man_exp(vre, -wp), from_man_exp(vim, -wp)
+            v = mpc_mul(v, mpc_exp(z, wp), wp)
+            v = mpc_div(v, z, wp)
+            if e1:
+                v = mpc_neg(v, prec, rnd)
+            else:
+                x, y = v
+                if bsign:
+                    v = mpf_pos(x, prec, rnd), mpf_sub(y, mpf_pi(wp), prec, rnd)
+                else:
+                    v = mpf_pos(x, prec, rnd), mpf_add(y, mpf_pi(wp), prec, rnd)
+            return v
+    except NoConvergence:
+        pass
+    #wp += 2*max(0,zmag)
+    wp += 2*int(to_int(mpc_abs(z, 5)))
+    zre = to_fixed(a, wp)
+    zim = to_fixed(b, wp)
+    vre, vim = complex_ei_taylor(zre, zim, wp)
+    vre += euler_fixed(wp)
+    v = from_man_exp(vre,-wp), from_man_exp(vim,-wp)
+    if e1:
+        u = mpc_log(mpc_neg(z),wp)
+    else:
+        u = mpc_log(z,wp)
+    v = mpc_add(v, u, prec, rnd)
+    if e1:
+        v = mpc_neg(v)
+    return v
+
+def mpf_e1(x, prec, rnd=round_fast):
+    return mpf_ei(x, prec, rnd, True)
+
+def mpc_e1(x, prec, rnd=round_fast):
+    return mpc_ei(x, prec, rnd, True)
+
+def mpf_expint(n, x, prec, rnd=round_fast, gamma=False):
+    """
+    E_n(x), n an integer, x real
+
+    With gamma=True, computes Gamma(n,x)   (upper incomplete gamma function)
+
+    Returns (real, None) if real, otherwise (real, imag)
+    The imaginary part is an optional branch cut term
+
+    """
+    sign, man, exp, bc = x
+    if not man:
+        if gamma:
+            if x == fzero:
+                # Actually gamma function pole
+                if n <= 0:
+                    return finf, None
+                return mpf_gamma_int(n, prec, rnd), None
+            if x == finf:
+                return fzero, None
+            # TODO: could return finite imaginary value at -inf
+            return fnan, fnan
+        else:
+            if x == fzero:
+                if n > 1:
+                    return from_rational(1, n-1, prec, rnd), None
+                else:
+                    return finf, None
+            if x == finf:
+                return fzero, None
+            return fnan, fnan
+    n_orig = n
+    if gamma:
+        n = 1-n
+    wp = prec + 20
+    xmag = exp + bc
+    # Beware of near-poles
+    if xmag < -10:
+        raise NotImplementedError
+    nmag = bitcount(abs(n))
+    have_imag = n > 0 and sign
+    negx = mpf_neg(x)
+    # Skip series if direct convergence
+    if n == 0 or 2*nmag - xmag < -wp:
+        if gamma:
+            v = mpf_exp(negx, wp)
+            re = mpf_mul(v, mpf_pow_int(x, n_orig-1, wp), prec, rnd)
+        else:
+            v = mpf_exp(negx, wp)
+            re = mpf_div(v, x, prec, rnd)
+    else:
+        # Finite number of terms, or...
+        can_use_asymptotic_series = -3*wp < n <= 0
+        # ...large enough?
+        if not can_use_asymptotic_series:
+            xi = abs(to_int(x))
+            m = min(max(1, xi-n), 2*wp)
+            siz = -n*nmag + (m+n)*bitcount(abs(m+n)) - m*xmag - (144*m//100)
+            tol = -wp-10
+            can_use_asymptotic_series = siz < tol
+        if can_use_asymptotic_series:
+            r = ((-MPZ_ONE) << (wp+wp)) // to_fixed(x, wp)
+            m = n
+            t = r*m
+            s = MPZ_ONE << wp
+            while m and t:
+                s += t
+                m += 1
+                t = (m*r*t) >> wp
+            v = mpf_exp(negx, wp)
+            if gamma:
+                # ~ exp(-x) * x^(n-1) * (1 + ...)
+                v = mpf_mul(v, mpf_pow_int(x, n_orig-1, wp), wp)
+            else:
+                # ~ exp(-x)/x * (1 + ...)
+                v = mpf_div(v, x, wp)
+            re = mpf_mul(v, from_man_exp(s, -wp), prec, rnd)
+        elif n == 1:
+            re = mpf_neg(mpf_ei(negx, prec, rnd))
+        elif n > 0 and n < 3*wp:
+            T1 = mpf_neg(mpf_ei(negx, wp))
+            if gamma:
+                if n_orig & 1:
+                    T1 = mpf_neg(T1)
+            else:
+                T1 = mpf_mul(T1, mpf_pow_int(negx, n-1, wp), wp)
+            r = t = to_fixed(x, wp)
+            facs = [1] * (n-1)
+            for k in range(1,n-1):
+                facs[k] = facs[k-1] * k
+            facs = facs[::-1]
+            s = facs[0] << wp
+            for k in range(1, n-1):
+                if k & 1:
+                    s -= facs[k] * t
+                else:
+                    s += facs[k] * t
+                t = (t*r) >> wp
+            T2 = from_man_exp(s, -wp, wp)
+            T2 = mpf_mul(T2, mpf_exp(negx, wp))
+            if gamma:
+                T2 = mpf_mul(T2, mpf_pow_int(x, n_orig, wp), wp)
+            R = mpf_add(T1, T2)
+            re = mpf_div(R, from_int(ifac(n-1)), prec, rnd)
+        else:
+            raise NotImplementedError
+    if have_imag:
+        M = from_int(-ifac(n-1))
+        if gamma:
+            im = mpf_div(mpf_pi(wp), M, prec, rnd)
+            if n_orig & 1:
+                im = mpf_neg(im)
+        else:
+            im = mpf_div(mpf_mul(mpf_pi(wp), mpf_pow_int(negx, n_orig-1, wp), wp), M, prec, rnd)
+        return re, im
+    else:
+        return re, None
+
+def mpf_ci_si_taylor(x, wp, which=0):
+    """
+    0 - Ci(x) - (euler+log(x))
+    1 - Si(x)
+    """
+    x = to_fixed(x, wp)
+    x2 = -(x*x) >> wp
+    if which == 0:
+        s, t, k = 0, (MPZ_ONE<<wp), 2
+    else:
+        s, t, k = x, x, 3
+    while t:
+        t = (t*x2//(k*(k-1)))>>wp
+        s += t//k
+        k += 2
+    return from_man_exp(s, -wp)
+
+def mpc_ci_si_taylor(re, im, wp, which=0):
+    # The following code is only designed for small arguments,
+    # and not too small arguments (for relative accuracy)
+    if re[1]:
+        mag = re[2]+re[3]
+    elif im[1]:
+        mag = im[2]+im[3]
+    if im[1]:
+        mag = max(mag, im[2]+im[3])
+    if mag > 2 or mag < -wp:
+        raise NotImplementedError
+    wp += (2-mag)
+    zre = to_fixed(re, wp)
+    zim = to_fixed(im, wp)
+    z2re = (zim*zim-zre*zre)>>wp
+    z2im = (-2*zre*zim)>>wp
+    tre = zre
+    tim = zim
+    one = MPZ_ONE<<wp
+    if which == 0:
+        sre, sim, tre, tim, k = 0, 0, (MPZ_ONE<<wp), 0, 2
+    else:
+        sre, sim, tre, tim, k = zre, zim, zre, zim, 3
+    while max(abs(tre), abs(tim)) > 2:
+        f = k*(k-1)
+        tre, tim = ((tre*z2re-tim*z2im)//f)>>wp, ((tre*z2im+tim*z2re)//f)>>wp
+        sre += tre//k
+        sim += tim//k
+        k += 2
+    return from_man_exp(sre, -wp), from_man_exp(sim, -wp)
+
+def mpf_ci_si(x, prec, rnd=round_fast, which=2):
+    """
+    Calculation of Ci(x), Si(x) for real x.
+
+    which = 0 -- returns (Ci(x), -)
+    which = 1 -- returns (Si(x), -)
+    which = 2 -- returns (Ci(x), Si(x))
+
+    Note: if x < 0, Ci(x) needs an additional imaginary term, pi*i.
+    """
+    wp = prec + 20
+    sign, man, exp, bc = x
+    ci, si = None, None
+    if not man:
+        if x == fzero:
+            return (fninf, fzero)
+        if x == fnan:
+            return (x, x)
+        ci = fzero
+        if which != 0:
+            if x == finf:
+                si = mpf_shift(mpf_pi(prec, rnd), -1)
+            if x == fninf:
+                si = mpf_neg(mpf_shift(mpf_pi(prec, negative_rnd[rnd]), -1))
+        return (ci, si)
+    # For small x: Ci(x) ~ euler + log(x), Si(x) ~ x
+    mag = exp+bc
+    if mag < -wp:
+        if which != 0:
+            si = mpf_perturb(x, 1-sign, prec, rnd)
+        if which != 1:
+            y = mpf_euler(wp)
+            xabs = mpf_abs(x)
+            ci = mpf_add(y, mpf_log(xabs, wp), prec, rnd)
+        return ci, si
+    # For huge x: Ci(x) ~ sin(x)/x, Si(x) ~ pi/2
+    elif mag > wp:
+        if which != 0:
+            if sign:
+                si = mpf_neg(mpf_pi(prec, negative_rnd[rnd]))
+            else:
+                si = mpf_pi(prec, rnd)
+            si = mpf_shift(si, -1)
+        if which != 1:
+            ci = mpf_div(mpf_sin(x, wp), x, prec, rnd)
+        return ci, si
+    else:
+        wp += abs(mag)
+    # Use an asymptotic series? The smallest value of n!/x^n
+    # occurs for n ~ x, where the magnitude is ~ exp(-x).
+    asymptotic = mag-1 > math.log(wp, 2)
+    # Case 1: convergent series near 0
+    if not asymptotic:
+        if which != 0:
+            si = mpf_pos(mpf_ci_si_taylor(x, wp, 1), prec, rnd)
+        if which != 1:
+            ci = mpf_ci_si_taylor(x, wp, 0)
+            ci = mpf_add(ci, mpf_euler(wp), wp)
+            ci = mpf_add(ci, mpf_log(mpf_abs(x), wp), prec, rnd)
+        return ci, si
+    x = mpf_abs(x)
+    # Case 2: asymptotic series for x >> 1
+    xf = to_fixed(x, wp)
+    xr = (MPZ_ONE<<(2*wp)) // xf   # 1/x
+    s1 = (MPZ_ONE << wp)
+    s2 = xr
+    t = xr
+    k = 2
+    while t:
+        t = -t
+        t = (t*xr*k)>>wp
+        k += 1
+        s1 += t
+        t = (t*xr*k)>>wp
+        k += 1
+        s2 += t
+    s1 = from_man_exp(s1, -wp)
+    s2 = from_man_exp(s2, -wp)
+    s1 = mpf_div(s1, x, wp)
+    s2 = mpf_div(s2, x, wp)
+    cos, sin = mpf_cos_sin(x, wp)
+    # Ci(x) = sin(x)*s1-cos(x)*s2
+    # Si(x) = pi/2-cos(x)*s1-sin(x)*s2
+    if which != 0:
+        si = mpf_add(mpf_mul(cos, s1), mpf_mul(sin, s2), wp)
+        si = mpf_sub(mpf_shift(mpf_pi(wp), -1), si, wp)
+        if sign:
+            si = mpf_neg(si)
+        si = mpf_pos(si, prec, rnd)
+    if which != 1:
+        ci = mpf_sub(mpf_mul(sin, s1), mpf_mul(cos, s2), prec, rnd)
+    return ci, si
+
+def mpf_ci(x, prec, rnd=round_fast):
+    if mpf_sign(x) < 0:
+        raise ComplexResult
+    return mpf_ci_si(x, prec, rnd, 0)[0]
+
+def mpf_si(x, prec, rnd=round_fast):
+    return mpf_ci_si(x, prec, rnd, 1)[1]
+
+def mpc_ci(z, prec, rnd=round_fast):
+    re, im = z
+    if im == fzero:
+        ci = mpf_ci_si(re, prec, rnd, 0)[0]
+        if mpf_sign(re) < 0:
+            return (ci, mpf_pi(prec, rnd))
+        return (ci, fzero)
+    wp = prec + 20
+    cre, cim = mpc_ci_si_taylor(re, im, wp, 0)
+    cre = mpf_add(cre, mpf_euler(wp), wp)
+    ci = mpc_add((cre, cim), mpc_log(z, wp), prec, rnd)
+    return ci
+
+def mpc_si(z, prec, rnd=round_fast):
+    re, im = z
+    if im == fzero:
+        return (mpf_ci_si(re, prec, rnd, 1)[1], fzero)
+    wp = prec + 20
+    z = mpc_ci_si_taylor(re, im, wp, 1)
+    return mpc_pos(z, prec, rnd)
+
+
+#-----------------------------------------------------------------------#
+#                                                                       #
+#                             Bessel functions                          #
+#                                                                       #
+#-----------------------------------------------------------------------#
+
+# A Bessel function of the first kind of integer order, J_n(x), is
+# given by the power series
+
+#             oo
+#             ___         k         2 k + n
+#            \        (-1)     / x \
+#    J_n(x) = )    ----------- | - |
+#            /___  k! (k + n)! \ 2 /
+#            k = 0
+
+# Simplifying the quotient between two successive terms gives the
+# ratio x^2 / (-4*k*(k+n)). Hence, we only need one full-precision
+# multiplication and one division by a small integer per term.
+# The complex version is very similar, the only difference being
+# that the multiplication is actually 4 multiplies.
+
+# In the general case, we have
+# J_v(x) = (x/2)**v / v! * 0F1(v+1, (-1/4)*z**2)
+
+# TODO: for extremely large x, we could use an asymptotic
+# trigonometric approximation.
+
+# TODO: recompute at higher precision if the fixed-point mantissa
+# is very small
+
+def mpf_besseljn(n, x, prec, rounding=round_fast):
+    prec += 50
+    negate = n < 0 and n & 1
+    mag = x[2]+x[3]
+    n = abs(n)
+    wp = prec + 20 + n*bitcount(n)
+    if mag < 0:
+        wp -= n * mag
+    x = to_fixed(x, wp)
+    x2 = (x**2) >> wp
+    if not n:
+        s = t = MPZ_ONE << wp
+    else:
+        s = t = (x**n // ifac(n)) >> ((n-1)*wp + n)
+    k = 1
+    while t:
+        t = ((t * x2) // (-4*k*(k+n))) >> wp
+        s += t
+        k += 1
+    if negate:
+        s = -s
+    return from_man_exp(s, -wp, prec, rounding)
+
+def mpc_besseljn(n, z, prec, rounding=round_fast):
+    negate = n < 0 and n & 1
+    n = abs(n)
+    origprec = prec
+    zre, zim = z
+    mag = max(zre[2]+zre[3], zim[2]+zim[3])
+    prec += 20 + n*bitcount(n) + abs(mag)
+    if mag < 0:
+        prec -= n * mag
+    zre = to_fixed(zre, prec)
+    zim = to_fixed(zim, prec)
+    z2re = (zre**2 - zim**2) >> prec
+    z2im = (zre*zim) >> (prec-1)
+    if not n:
+        sre = tre = MPZ_ONE << prec
+        sim = tim = MPZ_ZERO
+    else:
+        re, im = complex_int_pow(zre, zim, n)
+        sre = tre = (re // ifac(n)) >> ((n-1)*prec + n)
+        sim = tim = (im // ifac(n)) >> ((n-1)*prec + n)
+    k = 1
+    while abs(tre) + abs(tim) > 3:
+        p = -4*k*(k+n)
+        tre, tim = tre*z2re - tim*z2im, tim*z2re + tre*z2im
+        tre = (tre // p) >> prec
+        tim = (tim // p) >> prec
+        sre += tre
+        sim += tim
+        k += 1
+    if negate:
+        sre = -sre
+        sim = -sim
+    re = from_man_exp(sre, -prec, origprec, rounding)
+    im = from_man_exp(sim, -prec, origprec, rounding)
+    return (re, im)
+
+def mpf_agm(a, b, prec, rnd=round_fast):
+    """
+    Computes the arithmetic-geometric mean agm(a,b) for
+    nonnegative mpf values a, b.
+    """
+    asign, aman, aexp, abc = a
+    bsign, bman, bexp, bbc = b
+    if asign or bsign:
+        raise ComplexResult("agm of a negative number")
+    # Handle inf, nan or zero in either operand
+    if not (aman and bman):
+        if a == fnan or b == fnan:
+            return fnan
+        if a == finf:
+            if b == fzero:
+                return fnan
+            return finf
+        if b == finf:
+            if a == fzero:
+                return fnan
+            return finf
+        # agm(0,x) = agm(x,0) = 0
+        return fzero
+    wp = prec + 20
+    amag = aexp+abc
+    bmag = bexp+bbc
+    mag_delta = amag - bmag
+    # Reduce to roughly the same magnitude using floating-point AGM
+    abs_mag_delta = abs(mag_delta)
+    if abs_mag_delta > 10:
+        while abs_mag_delta > 10:
+            a, b = mpf_shift(mpf_add(a,b,wp),-1), \
+                mpf_sqrt(mpf_mul(a,b,wp),wp)
+            abs_mag_delta //= 2
+        asign, aman, aexp, abc = a
+        bsign, bman, bexp, bbc = b
+        amag = aexp+abc
+        bmag = bexp+bbc
+        mag_delta = amag - bmag
+    #print to_float(a), to_float(b)
+    # Use agm(a,b) = agm(x*a,x*b)/x to obtain a, b ~= 1
+    min_mag = min(amag,bmag)
+    max_mag = max(amag,bmag)
+    n = 0
+    # If too small, we lose precision when going to fixed-point
+    if min_mag < -8:
+        n = -min_mag
+    # If too large, we waste time using fixed-point with large numbers
+    elif max_mag > 20:
+        n = -max_mag
+    if n:
+        a = mpf_shift(a, n)
+        b = mpf_shift(b, n)
+    #print to_float(a), to_float(b)
+    af = to_fixed(a, wp)
+    bf = to_fixed(b, wp)
+    g = agm_fixed(af, bf, wp)
+    return from_man_exp(g, -wp-n, prec, rnd)
+
+def mpf_agm1(a, prec, rnd=round_fast):
+    """
+    Computes the arithmetic-geometric mean agm(1,a) for a nonnegative
+    mpf value a.
+    """
+    return mpf_agm(fone, a, prec, rnd)
+
+def mpc_agm(a, b, prec, rnd=round_fast):
+    """
+    Complex AGM.
+
+    TODO:
+    * check that convergence works as intended
+    * optimize
+    * select a nonarbitrary branch
+    """
+    if mpc_is_infnan(a) or mpc_is_infnan(b):
+        return fnan, fnan
+    if mpc_zero in (a, b):
+        return fzero, fzero
+    if mpc_neg(a) == b:
+        return fzero, fzero
+    wp = prec+20
+    eps = mpf_shift(fone, -wp+10)
+    while 1:
+        a1 = mpc_shift(mpc_add(a, b, wp), -1)
+        b1 = mpc_sqrt(mpc_mul(a, b, wp), wp)
+        a, b = a1, b1
+        size = mpf_min_max([mpc_abs(a,10), mpc_abs(b,10)])[1]
+        err = mpc_abs(mpc_sub(a, b, 10), 10)
+        if size == fzero or mpf_lt(err, mpf_mul(eps, size)):
+            return a
+
+def mpc_agm1(a, prec, rnd=round_fast):
+    return mpc_agm(mpc_one, a, prec, rnd)
+
+def mpf_ellipk(x, prec, rnd=round_fast):
+    if not x[1]:
+        if x == fzero:
+            return mpf_shift(mpf_pi(prec, rnd), -1)
+        if x == fninf:
+            return fzero
+        if x == fnan:
+            return x
+    if x == fone:
+        return finf
+    # TODO: for |x| << 1/2, one could use fall back to
+    # pi/2 * hyp2f1_rat((1,2),(1,2),(1,1), x)
+    wp = prec + 15
+    # Use K(x) = pi/2/agm(1,a) where a = sqrt(1-x)
+    # The sqrt raises ComplexResult if x > 0
+    a = mpf_sqrt(mpf_sub(fone, x, wp), wp)
+    v = mpf_agm1(a, wp)
+    r = mpf_div(mpf_pi(wp), v, prec, rnd)
+    return mpf_shift(r, -1)
+
+def mpc_ellipk(z, prec, rnd=round_fast):
+    re, im = z
+    if im == fzero:
+        if re == finf:
+            return mpc_zero
+        if mpf_le(re, fone):
+            return mpf_ellipk(re, prec, rnd), fzero
+    wp = prec + 15
+    a = mpc_sqrt(mpc_sub(mpc_one, z, wp), wp)
+    v = mpc_agm1(a, wp)
+    r = mpc_mpf_div(mpf_pi(wp), v, prec, rnd)
+    return mpc_shift(r, -1)
+
+def mpf_ellipe(x, prec, rnd=round_fast):
+    # http://functions.wolfram.com/EllipticIntegrals/
+    # EllipticK/20/01/0001/
+    # E = (1-m)*(K'(m)*2*m + K(m))
+    sign, man, exp, bc = x
+    if not man:
+        if x == fzero:
+            return mpf_shift(mpf_pi(prec, rnd), -1)
+        if x == fninf:
+            return finf
+        if x == fnan:
+            return x
+        if x == finf:
+            raise ComplexResult
+    if x == fone:
+        return fone
+    wp = prec+20
+    mag = exp+bc
+    if mag < -wp:
+        return mpf_shift(mpf_pi(prec, rnd), -1)
+    # Compute a finite difference for K'
+    p = max(mag, 0) - wp
+    h = mpf_shift(fone, p)
+    K = mpf_ellipk(x, 2*wp)
+    Kh = mpf_ellipk(mpf_sub(x, h), 2*wp)
+    Kdiff = mpf_shift(mpf_sub(K, Kh), -p)
+    t = mpf_sub(fone, x)
+    b = mpf_mul(Kdiff, mpf_shift(x,1), wp)
+    return mpf_mul(t, mpf_add(K, b), prec, rnd)
+
+def mpc_ellipe(z, prec, rnd=round_fast):
+    re, im = z
+    if im == fzero:
+        if re == finf:
+            return (fzero, finf)
+        if mpf_le(re, fone):
+            return mpf_ellipe(re, prec, rnd), fzero
+    wp = prec + 15
+    mag = mpc_abs(z, 1)
+    p = max(mag[2]+mag[3], 0) - wp
+    h = mpf_shift(fone, p)
+    K = mpc_ellipk(z, 2*wp)
+    Kh = mpc_ellipk(mpc_add_mpf(z, h, 2*wp), 2*wp)
+    Kdiff = mpc_shift(mpc_sub(Kh, K, wp), -p)
+    t = mpc_sub(mpc_one, z, wp)
+    b = mpc_mul(Kdiff, mpc_shift(z,1), wp)
+    return mpc_mul(t, mpc_add(K, b, wp), prec, rnd)