Add files using upload-large-folder tool

llmeval-env/lib/python3.10/site-packages/mpmath/__init__.py

@@ -0,0 +1,468 @@
+__version__ = '1.3.0'
+
+from .usertools import monitor, timing
+
+from .ctx_fp import FPContext
+from .ctx_mp import MPContext
+from .ctx_iv import MPIntervalContext
+
+fp = FPContext()
+mp = MPContext()
+iv = MPIntervalContext()
+
+fp._mp = mp
+mp._mp = mp
+iv._mp = mp
+mp._fp = fp
+fp._fp = fp
+mp._iv = iv
+fp._iv = iv
+iv._iv = iv
+
+# XXX: extremely bad pickle hack
+from . import ctx_mp as _ctx_mp
+_ctx_mp._mpf_module.mpf = mp.mpf
+_ctx_mp._mpf_module.mpc = mp.mpc
+
+make_mpf = mp.make_mpf
+make_mpc = mp.make_mpc
+
+extraprec = mp.extraprec
+extradps = mp.extradps
+workprec = mp.workprec
+workdps = mp.workdps
+autoprec = mp.autoprec
+maxcalls = mp.maxcalls
+memoize = mp.memoize
+
+mag = mp.mag
+
+bernfrac = mp.bernfrac
+
+qfrom = mp.qfrom
+mfrom = mp.mfrom
+kfrom = mp.kfrom
+taufrom = mp.taufrom
+qbarfrom = mp.qbarfrom
+ellipfun = mp.ellipfun
+jtheta = mp.jtheta
+kleinj = mp.kleinj
+eta = mp.eta
+
+qp = mp.qp
+qhyper = mp.qhyper
+qgamma = mp.qgamma
+qfac = mp.qfac
+
+nint_distance = mp.nint_distance
+
+plot = mp.plot
+cplot = mp.cplot
+splot = mp.splot
+
+odefun = mp.odefun
+
+jacobian = mp.jacobian
+findroot = mp.findroot
+multiplicity = mp.multiplicity
+
+isinf = mp.isinf
+isnan = mp.isnan
+isnormal = mp.isnormal
+isint = mp.isint
+isfinite = mp.isfinite
+almosteq = mp.almosteq
+nan = mp.nan
+rand = mp.rand
+
+absmin = mp.absmin
+absmax = mp.absmax
+
+fraction = mp.fraction
+
+linspace = mp.linspace
+arange = mp.arange
+
+mpmathify = convert = mp.convert
+mpc = mp.mpc
+
+mpi = iv._mpi
+
+nstr = mp.nstr
+nprint = mp.nprint
+chop = mp.chop
+
+fneg = mp.fneg
+fadd = mp.fadd
+fsub = mp.fsub
+fmul = mp.fmul
+fdiv = mp.fdiv
+fprod = mp.fprod
+
+quad = mp.quad
+quadgl = mp.quadgl
+quadts = mp.quadts
+quadosc = mp.quadosc
+quadsubdiv = mp.quadsubdiv
+
+invertlaplace = mp.invertlaplace
+invlaptalbot = mp.invlaptalbot
+invlapstehfest = mp.invlapstehfest
+invlapdehoog = mp.invlapdehoog
+
+pslq = mp.pslq
+identify = mp.identify
+findpoly = mp.findpoly
+
+richardson = mp.richardson
+shanks = mp.shanks
+levin = mp.levin
+cohen_alt = mp.cohen_alt
+nsum = mp.nsum
+nprod = mp.nprod
+difference = mp.difference
+diff = mp.diff
+diffs = mp.diffs
+diffs_prod = mp.diffs_prod
+diffs_exp = mp.diffs_exp
+diffun = mp.diffun
+differint = mp.differint
+taylor = mp.taylor
+pade = mp.pade
+polyval = mp.polyval
+polyroots = mp.polyroots
+fourier = mp.fourier
+fourierval = mp.fourierval
+sumem = mp.sumem
+sumap = mp.sumap
+chebyfit = mp.chebyfit
+limit = mp.limit
+
+matrix = mp.matrix
+eye = mp.eye
+diag = mp.diag
+zeros = mp.zeros
+ones = mp.ones
+hilbert = mp.hilbert
+randmatrix = mp.randmatrix
+swap_row = mp.swap_row
+extend = mp.extend
+norm = mp.norm
+mnorm = mp.mnorm
+
+lu_solve = mp.lu_solve
+lu = mp.lu
+qr = mp.qr
+unitvector = mp.unitvector
+inverse = mp.inverse
+residual = mp.residual
+qr_solve = mp.qr_solve
+cholesky = mp.cholesky
+cholesky_solve = mp.cholesky_solve
+det = mp.det
+cond = mp.cond
+hessenberg = mp.hessenberg
+schur = mp.schur
+eig = mp.eig
+eig_sort = mp.eig_sort
+eigsy = mp.eigsy
+eighe = mp.eighe
+eigh = mp.eigh
+svd_r = mp.svd_r
+svd_c = mp.svd_c
+svd = mp.svd
+gauss_quadrature = mp.gauss_quadrature
+
+expm = mp.expm
+sqrtm = mp.sqrtm
+powm = mp.powm
+logm = mp.logm
+sinm = mp.sinm
+cosm = mp.cosm
+
+mpf = mp.mpf
+j = mp.j
+exp = mp.exp
+expj = mp.expj
+expjpi = mp.expjpi
+ln = mp.ln
+im = mp.im
+re = mp.re
+inf = mp.inf
+ninf = mp.ninf
+sign = mp.sign
+
+eps = mp.eps
+pi = mp.pi
+ln2 = mp.ln2
+ln10 = mp.ln10
+phi = mp.phi
+e = mp.e
+euler = mp.euler
+catalan = mp.catalan
+khinchin = mp.khinchin
+glaisher = mp.glaisher
+apery = mp.apery
+degree = mp.degree
+twinprime = mp.twinprime
+mertens = mp.mertens
+
+ldexp = mp.ldexp
+frexp = mp.frexp
+
+fsum = mp.fsum
+fdot = mp.fdot
+
+sqrt = mp.sqrt
+cbrt = mp.cbrt
+exp = mp.exp
+ln = mp.ln
+log = mp.log
+log10 = mp.log10
+power = mp.power
+cos = mp.cos
+sin = mp.sin
+tan = mp.tan
+cosh = mp.cosh
+sinh = mp.sinh
+tanh = mp.tanh
+acos = mp.acos
+asin = mp.asin
+atan = mp.atan
+asinh = mp.asinh
+acosh = mp.acosh
+atanh = mp.atanh
+sec = mp.sec
+csc = mp.csc
+cot = mp.cot
+sech = mp.sech
+csch = mp.csch
+coth = mp.coth
+asec = mp.asec
+acsc = mp.acsc
+acot = mp.acot
+asech = mp.asech
+acsch = mp.acsch
+acoth = mp.acoth
+cospi = mp.cospi
+sinpi = mp.sinpi
+sinc = mp.sinc
+sincpi = mp.sincpi
+cos_sin = mp.cos_sin
+cospi_sinpi = mp.cospi_sinpi
+fabs = mp.fabs
+re = mp.re
+im = mp.im
+conj = mp.conj
+floor = mp.floor
+ceil = mp.ceil
+nint = mp.nint
+frac = mp.frac
+root = mp.root
+nthroot = mp.nthroot
+hypot = mp.hypot
+fmod = mp.fmod
+ldexp = mp.ldexp
+frexp = mp.frexp
+sign = mp.sign
+arg = mp.arg
+phase = mp.phase
+polar = mp.polar
+rect = mp.rect
+degrees = mp.degrees
+radians = mp.radians
+atan2 = mp.atan2
+fib = mp.fib
+fibonacci = mp.fibonacci
+lambertw = mp.lambertw
+zeta = mp.zeta
+altzeta = mp.altzeta
+gamma = mp.gamma
+rgamma = mp.rgamma
+factorial = mp.factorial
+fac = mp.fac
+fac2 = mp.fac2
+beta = mp.beta
+betainc = mp.betainc
+psi = mp.psi
+#psi0 = mp.psi0
+#psi1 = mp.psi1
+#psi2 = mp.psi2
+#psi3 = mp.psi3
+polygamma = mp.polygamma
+digamma = mp.digamma
+#trigamma = mp.trigamma
+#tetragamma = mp.tetragamma
+#pentagamma = mp.pentagamma
+harmonic = mp.harmonic
+bernoulli = mp.bernoulli
+bernfrac = mp.bernfrac
+stieltjes = mp.stieltjes
+hurwitz = mp.hurwitz
+dirichlet = mp.dirichlet
+bernpoly = mp.bernpoly
+eulerpoly = mp.eulerpoly
+eulernum = mp.eulernum
+polylog = mp.polylog
+clsin = mp.clsin
+clcos = mp.clcos
+gammainc = mp.gammainc
+gammaprod = mp.gammaprod
+binomial = mp.binomial
+rf = mp.rf
+ff = mp.ff
+hyper = mp.hyper
+hyp0f1 = mp.hyp0f1
+hyp1f1 = mp.hyp1f1
+hyp1f2 = mp.hyp1f2
+hyp2f1 = mp.hyp2f1
+hyp2f2 = mp.hyp2f2
+hyp2f0 = mp.hyp2f0
+hyp2f3 = mp.hyp2f3
+hyp3f2 = mp.hyp3f2
+hyperu = mp.hyperu
+hypercomb = mp.hypercomb
+meijerg = mp.meijerg
+appellf1 = mp.appellf1
+appellf2 = mp.appellf2
+appellf3 = mp.appellf3
+appellf4 = mp.appellf4
+hyper2d = mp.hyper2d
+bihyper = mp.bihyper
+erf = mp.erf
+erfc = mp.erfc
+erfi = mp.erfi
+erfinv = mp.erfinv
+npdf = mp.npdf
+ncdf = mp.ncdf
+expint = mp.expint
+e1 = mp.e1
+ei = mp.ei
+li = mp.li
+ci = mp.ci
+si = mp.si
+chi = mp.chi
+shi = mp.shi
+fresnels = mp.fresnels
+fresnelc = mp.fresnelc
+airyai = mp.airyai
+airybi = mp.airybi
+airyaizero = mp.airyaizero
+airybizero = mp.airybizero
+scorergi = mp.scorergi
+scorerhi = mp.scorerhi
+ellipk = mp.ellipk
+ellipe = mp.ellipe
+ellipf = mp.ellipf
+ellippi = mp.ellippi
+elliprc = mp.elliprc
+elliprj = mp.elliprj
+elliprf = mp.elliprf
+elliprd = mp.elliprd
+elliprg = mp.elliprg
+agm = mp.agm
+jacobi = mp.jacobi
+chebyt = mp.chebyt
+chebyu = mp.chebyu
+legendre = mp.legendre
+legenp = mp.legenp
+legenq = mp.legenq
+hermite = mp.hermite
+pcfd = mp.pcfd
+pcfu = mp.pcfu
+pcfv = mp.pcfv
+pcfw = mp.pcfw
+gegenbauer = mp.gegenbauer
+laguerre = mp.laguerre
+spherharm = mp.spherharm
+besselj = mp.besselj
+j0 = mp.j0
+j1 = mp.j1
+besseli = mp.besseli
+bessely = mp.bessely
+besselk = mp.besselk
+besseljzero = mp.besseljzero
+besselyzero = mp.besselyzero
+hankel1 = mp.hankel1
+hankel2 = mp.hankel2
+struveh = mp.struveh
+struvel = mp.struvel
+angerj = mp.angerj
+webere = mp.webere
+lommels1 = mp.lommels1
+lommels2 = mp.lommels2
+whitm = mp.whitm
+whitw = mp.whitw
+ber = mp.ber
+bei = mp.bei
+ker = mp.ker
+kei = mp.kei
+coulombc = mp.coulombc
+coulombf = mp.coulombf
+coulombg = mp.coulombg
+barnesg = mp.barnesg
+superfac = mp.superfac
+hyperfac = mp.hyperfac
+loggamma = mp.loggamma
+siegeltheta = mp.siegeltheta
+siegelz = mp.siegelz
+grampoint = mp.grampoint
+zetazero = mp.zetazero
+riemannr = mp.riemannr
+primepi = mp.primepi
+primepi2 = mp.primepi2
+primezeta = mp.primezeta
+bell = mp.bell
+polyexp = mp.polyexp
+expm1 = mp.expm1
+log1p = mp.log1p
+powm1 = mp.powm1
+unitroots = mp.unitroots
+cyclotomic = mp.cyclotomic
+mangoldt = mp.mangoldt
+secondzeta = mp.secondzeta
+nzeros = mp.nzeros
+backlunds = mp.backlunds
+lerchphi = mp.lerchphi
+stirling1 = mp.stirling1
+stirling2 = mp.stirling2
+squarew = mp.squarew
+trianglew = mp.trianglew
+sawtoothw = mp.sawtoothw
+unit_triangle = mp.unit_triangle
+sigmoid = mp.sigmoid
+
+# be careful when changing this name, don't use test*!
+def runtests():
+    """
+    Run all mpmath tests and print output.
+    """
+    import os.path
+    from inspect import getsourcefile
+    from .tests import runtests as tests
+    testdir = os.path.dirname(os.path.abspath(getsourcefile(tests)))
+    importdir = os.path.abspath(testdir + '/../..')
+    tests.testit(importdir, testdir)
+
+def doctests(filter=[]):
+    import sys
+    from timeit import default_timer as clock
+    for i, arg in enumerate(sys.argv):
+        if '__init__.py' in arg:
+            filter = [sn for sn in sys.argv[i+1:] if not sn.startswith("-")]
+            break
+    import doctest
+    globs = globals().copy()
+    for obj in globs: #sorted(globs.keys()):
+        if filter:
+            if not sum([pat in obj for pat in filter]):
+                continue
+        sys.stdout.write(str(obj) + " ")
+        sys.stdout.flush()
+        t1 = clock()
+        doctest.run_docstring_examples(globs[obj], {}, verbose=("-v" in sys.argv))
+        t2 = clock()
+        print(round(t2-t1, 3))
+
+if __name__ == '__main__':
+    doctests()

llmeval-env/lib/python3.10/site-packages/mpmath/ctx_base.py

@@ -0,0 +1,494 @@
+from operator import gt, lt
+
+from .libmp.backend import xrange
+
+from .functions.functions import SpecialFunctions
+from .functions.rszeta import RSCache
+from .calculus.quadrature import QuadratureMethods
+from .calculus.inverselaplace import LaplaceTransformInversionMethods
+from .calculus.calculus import CalculusMethods
+from .calculus.optimization import OptimizationMethods
+from .calculus.odes import ODEMethods
+from .matrices.matrices import MatrixMethods
+from .matrices.calculus import MatrixCalculusMethods
+from .matrices.linalg import LinearAlgebraMethods
+from .matrices.eigen import Eigen
+from .identification import IdentificationMethods
+from .visualization import VisualizationMethods
+
+from . import libmp
+
+class Context(object):
+    pass
+
+class StandardBaseContext(Context,
+    SpecialFunctions,
+    RSCache,
+    QuadratureMethods,
+    LaplaceTransformInversionMethods,
+    CalculusMethods,
+    MatrixMethods,
+    MatrixCalculusMethods,
+    LinearAlgebraMethods,
+    Eigen,
+    IdentificationMethods,
+    OptimizationMethods,
+    ODEMethods,
+    VisualizationMethods):
+
+    NoConvergence = libmp.NoConvergence
+    ComplexResult = libmp.ComplexResult
+
+    def __init__(ctx):
+        ctx._aliases = {}
+        # Call those that need preinitialization (e.g. for wrappers)
+        SpecialFunctions.__init__(ctx)
+        RSCache.__init__(ctx)
+        QuadratureMethods.__init__(ctx)
+        LaplaceTransformInversionMethods.__init__(ctx)
+        CalculusMethods.__init__(ctx)
+        MatrixMethods.__init__(ctx)
+
+    def _init_aliases(ctx):
+        for alias, value in ctx._aliases.items():
+            try:
+                setattr(ctx, alias, getattr(ctx, value))
+            except AttributeError:
+                pass
+
+    _fixed_precision = False
+
+    # XXX
+    verbose = False
+
+    def warn(ctx, msg):
+        print("Warning:", msg)
+
+    def bad_domain(ctx, msg):
+        raise ValueError(msg)
+
+    def _re(ctx, x):
+        if hasattr(x, "real"):
+            return x.real
+        return x
+
+    def _im(ctx, x):
+        if hasattr(x, "imag"):
+            return x.imag
+        return ctx.zero
+
+    def _as_points(ctx, x):
+        return x
+
+    def fneg(ctx, x, **kwargs):
+        return -ctx.convert(x)
+
+    def fadd(ctx, x, y, **kwargs):
+        return ctx.convert(x)+ctx.convert(y)
+
+    def fsub(ctx, x, y, **kwargs):
+        return ctx.convert(x)-ctx.convert(y)
+
+    def fmul(ctx, x, y, **kwargs):
+        return ctx.convert(x)*ctx.convert(y)
+
+    def fdiv(ctx, x, y, **kwargs):
+        return ctx.convert(x)/ctx.convert(y)
+
+    def fsum(ctx, args, absolute=False, squared=False):
+        if absolute:
+            if squared:
+                return sum((abs(x)**2 for x in args), ctx.zero)
+            return sum((abs(x) for x in args), ctx.zero)
+        if squared:
+            return sum((x**2 for x in args), ctx.zero)
+        return sum(args, ctx.zero)
+
+    def fdot(ctx, xs, ys=None, conjugate=False):
+        if ys is not None:
+            xs = zip(xs, ys)
+        if conjugate:
+            cf = ctx.conj
+            return sum((x*cf(y) for (x,y) in xs), ctx.zero)
+        else:
+            return sum((x*y for (x,y) in xs), ctx.zero)
+
+    def fprod(ctx, args):
+        prod = ctx.one
+        for arg in args:
+            prod *= arg
+        return prod
+
+    def nprint(ctx, x, n=6, **kwargs):
+        """
+        Equivalent to ``print(nstr(x, n))``.
+        """
+        print(ctx.nstr(x, n, **kwargs))
+
+    def chop(ctx, x, tol=None):
+        """
+        Chops off small real or imaginary parts, or converts
+        numbers close to zero to exact zeros. The input can be a
+        single number or an iterable::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> chop(5+1e-10j, tol=1e-9)
+            mpf('5.0')
+            >>> nprint(chop([1.0, 1e-20, 3+1e-18j, -4, 2]))
+            [1.0, 0.0, 3.0, -4.0, 2.0]
+
+        The tolerance defaults to ``100*eps``.
+        """
+        if tol is None:
+            tol = 100*ctx.eps
+        try:
+            x = ctx.convert(x)
+            absx = abs(x)
+            if abs(x) < tol:
+                return ctx.zero
+            if ctx._is_complex_type(x):
+                #part_tol = min(tol, absx*tol)
+                part_tol = max(tol, absx*tol)
+                if abs(x.imag) < part_tol:
+                    return x.real
+                if abs(x.real) < part_tol:
+                    return ctx.mpc(0, x.imag)
+        except TypeError:
+            if isinstance(x, ctx.matrix):
+                return x.apply(lambda a: ctx.chop(a, tol))
+            if hasattr(x, "__iter__"):
+                return [ctx.chop(a, tol) for a in x]
+        return x
+
+    def almosteq(ctx, s, t, rel_eps=None, abs_eps=None):
+        r"""
+        Determine whether the difference between `s` and `t` is smaller
+        than a given epsilon, either relatively or absolutely.
+
+        Both a maximum relative difference and a maximum difference
+        ('epsilons') may be specified. The absolute difference is
+        defined as `|s-t|` and the relative difference is defined
+        as `|s-t|/\max(|s|, |t|)`.
+
+        If only one epsilon is given, both are set to the same value.
+        If none is given, both epsilons are set to `2^{-p+m}` where
+        `p` is the current working precision and `m` is a small
+        integer. The default setting typically allows :func:`~mpmath.almosteq`
+        to be used to check for mathematical equality
+        in the presence of small rounding errors.
+
+        **Examples**
+
+            >>> from mpmath import *
+            >>> mp.dps = 15
+            >>> almosteq(3.141592653589793, 3.141592653589790)
+            True
+            >>> almosteq(3.141592653589793, 3.141592653589700)
+            False
+            >>> almosteq(3.141592653589793, 3.141592653589700, 1e-10)
+            True
+            >>> almosteq(1e-20, 2e-20)
+            True
+            >>> almosteq(1e-20, 2e-20, rel_eps=0, abs_eps=0)
+            False
+
+        """
+        t = ctx.convert(t)
+        if abs_eps is None and rel_eps is None:
+            rel_eps = abs_eps = ctx.ldexp(1, -ctx.prec+4)
+        if abs_eps is None:
+            abs_eps = rel_eps
+        elif rel_eps is None:
+            rel_eps = abs_eps
+        diff = abs(s-t)
+        if diff <= abs_eps:
+            return True
+        abss = abs(s)
+        abst = abs(t)
+        if abss < abst:
+            err = diff/abst
+        else:
+            err = diff/abss
+        return err <= rel_eps
+
+    def arange(ctx, *args):
+        r"""
+        This is a generalized version of Python's :func:`~mpmath.range` function
+        that accepts fractional endpoints and step sizes and
+        returns a list of ``mpf`` instances. Like :func:`~mpmath.range`,
+        :func:`~mpmath.arange` can be called with 1, 2 or 3 arguments:
+
+        ``arange(b)``
+            `[0, 1, 2, \ldots, x]`
+        ``arange(a, b)``
+            `[a, a+1, a+2, \ldots, x]`
+        ``arange(a, b, h)``
+            `[a, a+h, a+h, \ldots, x]`
+
+        where `b-1 \le x < b` (in the third case, `b-h \le x < b`).
+
+        Like Python's :func:`~mpmath.range`, the endpoint is not included. To
+        produce ranges where the endpoint is included, :func:`~mpmath.linspace`
+        is more convenient.
+
+        **Examples**
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> arange(4)
+            [mpf('0.0'), mpf('1.0'), mpf('2.0'), mpf('3.0')]
+            >>> arange(1, 2, 0.25)
+            [mpf('1.0'), mpf('1.25'), mpf('1.5'), mpf('1.75')]
+            >>> arange(1, -1, -0.75)
+            [mpf('1.0'), mpf('0.25'), mpf('-0.5')]
+
+        """
+        if not len(args) <= 3:
+            raise TypeError('arange expected at most 3 arguments, got %i'
+                            % len(args))
+        if not len(args) >= 1:
+            raise TypeError('arange expected at least 1 argument, got %i'
+                            % len(args))
+        # set default
+        a = 0
+        dt = 1
+        # interpret arguments
+        if len(args) == 1:
+            b = args[0]
+        elif len(args) >= 2:
+            a = args[0]
+            b = args[1]
+        if len(args) == 3:
+            dt = args[2]
+        a, b, dt = ctx.mpf(a), ctx.mpf(b), ctx.mpf(dt)
+        assert a + dt != a, 'dt is too small and would cause an infinite loop'
+        # adapt code for sign of dt
+        if a > b:
+            if dt > 0:
+                return []
+            op = gt
+        else:
+            if dt < 0:
+                return []
+            op = lt
+        # create list
+        result = []
+        i = 0
+        t = a
+        while 1:
+            t = a + dt*i
+            i += 1
+            if op(t, b):
+                result.append(t)
+            else:
+                break
+        return result
+
+    def linspace(ctx, *args, **kwargs):
+        """
+        ``linspace(a, b, n)`` returns a list of `n` evenly spaced
+        samples from `a` to `b`. The syntax ``linspace(mpi(a,b), n)``
+        is also valid.
+
+        This function is often more convenient than :func:`~mpmath.arange`
+        for partitioning an interval into subintervals, since
+        the endpoint is included::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> linspace(1, 4, 4)
+            [mpf('1.0'), mpf('2.0'), mpf('3.0'), mpf('4.0')]
+
+        You may also provide the keyword argument ``endpoint=False``::
+
+            >>> linspace(1, 4, 4, endpoint=False)
+            [mpf('1.0'), mpf('1.75'), mpf('2.5'), mpf('3.25')]
+
+        """
+        if len(args) == 3:
+            a = ctx.mpf(args[0])
+            b = ctx.mpf(args[1])
+            n = int(args[2])
+        elif len(args) == 2:
+            assert hasattr(args[0], '_mpi_')
+            a = args[0].a
+            b = args[0].b
+            n = int(args[1])
+        else:
+            raise TypeError('linspace expected 2 or 3 arguments, got %i' \
+                            % len(args))
+        if n < 1:
+            raise ValueError('n must be greater than 0')
+        if not 'endpoint' in kwargs or kwargs['endpoint']:
+            if n == 1:
+                return [ctx.mpf(a)]
+            step = (b - a) / ctx.mpf(n - 1)
+            y = [i*step + a for i in xrange(n)]
+            y[-1] = b
+        else:
+            step = (b - a) / ctx.mpf(n)
+            y = [i*step + a for i in xrange(n)]
+        return y
+
+    def cos_sin(ctx, z, **kwargs):
+        return ctx.cos(z, **kwargs), ctx.sin(z, **kwargs)
+
+    def cospi_sinpi(ctx, z, **kwargs):
+        return ctx.cospi(z, **kwargs), ctx.sinpi(z, **kwargs)
+
+    def _default_hyper_maxprec(ctx, p):
+        return int(1000 * p**0.25 + 4*p)
+
+    _gcd = staticmethod(libmp.gcd)
+    list_primes = staticmethod(libmp.list_primes)
+    isprime = staticmethod(libmp.isprime)
+    bernfrac = staticmethod(libmp.bernfrac)
+    moebius = staticmethod(libmp.moebius)
+    _ifac = staticmethod(libmp.ifac)
+    _eulernum = staticmethod(libmp.eulernum)
+    _stirling1 = staticmethod(libmp.stirling1)
+    _stirling2 = staticmethod(libmp.stirling2)
+
+    def sum_accurately(ctx, terms, check_step=1):
+        prec = ctx.prec
+        try:
+            extraprec = 10
+            while 1:
+                ctx.prec = prec + extraprec + 5
+                max_mag = ctx.ninf
+                s = ctx.zero
+                k = 0
+                for term in terms():
+                    s += term
+                    if (not k % check_step) and term:
+                        term_mag = ctx.mag(term)
+                        max_mag = max(max_mag, term_mag)
+                        sum_mag = ctx.mag(s)
+                        if sum_mag - term_mag > ctx.prec:
+                            break
+                    k += 1
+                cancellation = max_mag - sum_mag
+                if cancellation != cancellation:
+                    break
+                if cancellation < extraprec or ctx._fixed_precision:
+                    break
+                extraprec += min(ctx.prec, cancellation)
+            return s
+        finally:
+            ctx.prec = prec
+
+    def mul_accurately(ctx, factors, check_step=1):
+        prec = ctx.prec
+        try:
+            extraprec = 10
+            while 1:
+                ctx.prec = prec + extraprec + 5
+                max_mag = ctx.ninf
+                one = ctx.one
+                s = one
+                k = 0
+                for factor in factors():
+                    s *= factor
+                    term = factor - one
+                    if (not k % check_step):
+                        term_mag = ctx.mag(term)
+                        max_mag = max(max_mag, term_mag)
+                        sum_mag = ctx.mag(s-one)
+                        #if sum_mag - term_mag > ctx.prec:
+                        #    break
+                        if -term_mag > ctx.prec:
+                            break
+                    k += 1
+                cancellation = max_mag - sum_mag
+                if cancellation != cancellation:
+                    break
+                if cancellation < extraprec or ctx._fixed_precision:
+                    break
+                extraprec += min(ctx.prec, cancellation)
+            return s
+        finally:
+            ctx.prec = prec
+
+    def power(ctx, x, y):
+        r"""Converts `x` and `y` to mpmath numbers and evaluates
+        `x^y = \exp(y \log(x))`::
+
+            >>> from mpmath import *
+            >>> mp.dps = 30; mp.pretty = True
+            >>> power(2, 0.5)
+            1.41421356237309504880168872421
+
+        This shows the leading few digits of a large Mersenne prime
+        (performing the exact calculation ``2**43112609-1`` and
+        displaying the result in Python would be very slow)::
+
+            >>> power(2, 43112609)-1
+            3.16470269330255923143453723949e+12978188
+        """
+        return ctx.convert(x) ** ctx.convert(y)
+
+    def _zeta_int(ctx, n):
+        return ctx.zeta(n)
+
+    def maxcalls(ctx, f, N):
+        """
+        Return a wrapped copy of *f* that raises ``NoConvergence`` when *f*
+        has been called more than *N* times::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15
+            >>> f = maxcalls(sin, 10)
+            >>> print(sum(f(n) for n in range(10)))
+            1.95520948210738
+            >>> f(10) # doctest: +IGNORE_EXCEPTION_DETAIL
+            Traceback (most recent call last):
+              ...
+            NoConvergence: maxcalls: function evaluated 10 times
+
+        """
+        counter = [0]
+        def f_maxcalls_wrapped(*args, **kwargs):
+            counter[0] += 1
+            if counter[0] > N:
+                raise ctx.NoConvergence("maxcalls: function evaluated %i times" % N)
+            return f(*args, **kwargs)
+        return f_maxcalls_wrapped
+
+    def memoize(ctx, f):
+        """
+        Return a wrapped copy of *f* that caches computed values, i.e.
+        a memoized copy of *f*. Values are only reused if the cached precision
+        is equal to or higher than the working precision::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> f = memoize(maxcalls(sin, 1))
+            >>> f(2)
+            0.909297426825682
+            >>> f(2)
+            0.909297426825682
+            >>> mp.dps = 25
+            >>> f(2) # doctest: +IGNORE_EXCEPTION_DETAIL
+            Traceback (most recent call last):
+              ...
+            NoConvergence: maxcalls: function evaluated 1 times
+
+        """
+        f_cache = {}
+        def f_cached(*args, **kwargs):
+            if kwargs:
+                key = args, tuple(kwargs.items())
+            else:
+                key = args
+            prec = ctx.prec
+            if key in f_cache:
+                cprec, cvalue = f_cache[key]
+                if cprec >= prec:
+                    return +cvalue
+            value = f(*args, **kwargs)
+            f_cache[key] = (prec, value)
+            return value
+        f_cached.__name__ = f.__name__
+        f_cached.__doc__ = f.__doc__
+        return f_cached

llmeval-env/lib/python3.10/site-packages/mpmath/ctx_fp.py

@@ -0,0 +1,253 @@
+from .ctx_base import StandardBaseContext
+
+import math
+import cmath
+from . import math2
+
+from . import function_docs
+
+from .libmp import mpf_bernoulli, to_float, int_types
+from . import libmp
+
+class FPContext(StandardBaseContext):
+    """
+    Context for fast low-precision arithmetic (53-bit precision, giving at most
+    about 15-digit accuracy), using Python's builtin float and complex.
+    """
+
+    def __init__(ctx):
+        StandardBaseContext.__init__(ctx)
+
+        # Override SpecialFunctions implementation
+        ctx.loggamma = math2.loggamma
+        ctx._bernoulli_cache = {}
+        ctx.pretty = False
+
+        ctx._init_aliases()
+
+    _mpq = lambda cls, x: float(x[0])/x[1]
+
+    NoConvergence = libmp.NoConvergence
+
+    def _get_prec(ctx): return 53
+    def _set_prec(ctx, p): return
+    def _get_dps(ctx): return 15
+    def _set_dps(ctx, p): return
+
+    _fixed_precision = True
+
+    prec = property(_get_prec, _set_prec)
+    dps = property(_get_dps, _set_dps)
+
+    zero = 0.0
+    one = 1.0
+    eps = math2.EPS
+    inf = math2.INF
+    ninf = math2.NINF
+    nan = math2.NAN
+    j = 1j
+
+    # Called by SpecialFunctions.__init__()
+    @classmethod
+    def _wrap_specfun(cls, name, f, wrap):
+        if wrap:
+            def f_wrapped(ctx, *args, **kwargs):
+                convert = ctx.convert
+                args = [convert(a) for a in args]
+                return f(ctx, *args, **kwargs)
+        else:
+            f_wrapped = f
+        f_wrapped.__doc__ = function_docs.__dict__.get(name, f.__doc__)
+        setattr(cls, name, f_wrapped)
+
+    def bernoulli(ctx, n):
+        cache = ctx._bernoulli_cache
+        if n in cache:
+            return cache[n]
+        cache[n] = to_float(mpf_bernoulli(n, 53, 'n'), strict=True)
+        return cache[n]
+
+    pi = math2.pi
+    e = math2.e
+    euler = math2.euler
+    sqrt2 = 1.4142135623730950488
+    sqrt5 = 2.2360679774997896964
+    phi = 1.6180339887498948482
+    ln2 = 0.69314718055994530942
+    ln10 = 2.302585092994045684
+    euler = 0.57721566490153286061
+    catalan = 0.91596559417721901505
+    khinchin = 2.6854520010653064453
+    apery = 1.2020569031595942854
+    glaisher = 1.2824271291006226369
+
+    absmin = absmax = abs
+
+    def is_special(ctx, x):
+        return x - x != 0.0
+
+    def isnan(ctx, x):
+        return x != x
+
+    def isinf(ctx, x):
+        return abs(x) == math2.INF
+
+    def isnormal(ctx, x):
+        if x:
+            return x - x == 0.0
+        return False
+
+    def isnpint(ctx, x):
+        if type(x) is complex:
+            if x.imag:
+                return False
+            x = x.real
+        return x <= 0.0 and round(x) == x
+
+    mpf = float
+    mpc = complex
+
+    def convert(ctx, x):
+        try:
+            return float(x)
+        except:
+            return complex(x)
+
+    power = staticmethod(math2.pow)
+    sqrt = staticmethod(math2.sqrt)
+    exp = staticmethod(math2.exp)
+    ln = log = staticmethod(math2.log)
+    cos = staticmethod(math2.cos)
+    sin = staticmethod(math2.sin)
+    tan = staticmethod(math2.tan)
+    cos_sin = staticmethod(math2.cos_sin)
+    acos = staticmethod(math2.acos)
+    asin = staticmethod(math2.asin)
+    atan = staticmethod(math2.atan)
+    cosh = staticmethod(math2.cosh)
+    sinh = staticmethod(math2.sinh)
+    tanh = staticmethod(math2.tanh)
+    gamma = staticmethod(math2.gamma)
+    rgamma = staticmethod(math2.rgamma)
+    fac = factorial = staticmethod(math2.factorial)
+    floor = staticmethod(math2.floor)
+    ceil = staticmethod(math2.ceil)
+    cospi = staticmethod(math2.cospi)
+    sinpi = staticmethod(math2.sinpi)
+    cbrt = staticmethod(math2.cbrt)
+    _nthroot = staticmethod(math2.nthroot)
+    _ei = staticmethod(math2.ei)
+    _e1 = staticmethod(math2.e1)
+    _zeta = _zeta_int = staticmethod(math2.zeta)
+
+    # XXX: math2
+    def arg(ctx, z):
+        z = complex(z)
+        return math.atan2(z.imag, z.real)
+
+    def expj(ctx, x):
+        return ctx.exp(ctx.j*x)
+
+    def expjpi(ctx, x):
+        return ctx.exp(ctx.j*ctx.pi*x)
+
+    ldexp = math.ldexp
+    frexp = math.frexp
+
+    def mag(ctx, z):
+        if z:
+            return ctx.frexp(abs(z))[1]
+        return ctx.ninf
+
+    def isint(ctx, z):
+        if hasattr(z, "imag"):   # float/int don't have .real/.imag in py2.5
+            if z.imag:
+                return False
+            z = z.real
+        try:
+            return z == int(z)
+        except:
+            return False
+
+    def nint_distance(ctx, z):
+        if hasattr(z, "imag"):   # float/int don't have .real/.imag in py2.5
+            n = round(z.real)
+        else:
+            n = round(z)
+        if n == z:
+            return n, ctx.ninf
+        return n, ctx.mag(abs(z-n))
+
+    def _convert_param(ctx, z):
+        if type(z) is tuple:
+            p, q = z
+            return ctx.mpf(p) / q, 'R'
+        if hasattr(z, "imag"):    # float/int don't have .real/.imag in py2.5
+            intz = int(z.real)
+        else:
+            intz = int(z)
+        if z == intz:
+            return intz, 'Z'
+        return z, 'R'
+
+    def _is_real_type(ctx, z):
+        return isinstance(z, float) or isinstance(z, int_types)
+
+    def _is_complex_type(ctx, z):
+        return isinstance(z, complex)
+
+    def hypsum(ctx, p, q, types, coeffs, z, maxterms=6000, **kwargs):
+        coeffs = list(coeffs)
+        num = range(p)
+        den = range(p,p+q)
+        tol = ctx.eps
+        s = t = 1.0
+        k = 0
+        while 1:
+            for i in num: t *= (coeffs[i]+k)
+            for i in den: t /= (coeffs[i]+k)
+            k += 1; t /= k; t *= z; s += t
+            if abs(t) < tol:
+                return s
+            if k > maxterms:
+                raise ctx.NoConvergence
+
+    def atan2(ctx, x, y):
+        return math.atan2(x, y)
+
+    def psi(ctx, m, z):
+        m = int(m)
+        if m == 0:
+            return ctx.digamma(z)
+        return (-1)**(m+1) * ctx.fac(m) * ctx.zeta(m+1, z)
+
+    digamma = staticmethod(math2.digamma)
+
+    def harmonic(ctx, x):
+        x = ctx.convert(x)
+        if x == 0 or x == 1:
+            return x
+        return ctx.digamma(x+1) + ctx.euler
+
+    nstr = str
+
+    def to_fixed(ctx, x, prec):
+        return int(math.ldexp(x, prec))
+
+    def rand(ctx):
+        import random
+        return random.random()
+
+    _erf = staticmethod(math2.erf)
+    _erfc = staticmethod(math2.erfc)
+
+    def sum_accurately(ctx, terms, check_step=1):
+        s = ctx.zero
+        k = 0
+        for term in terms():
+            s += term
+            if (not k % check_step) and term:
+                if abs(term) <= 1e-18*abs(s):
+                    break
+            k += 1
+        return s

llmeval-env/lib/python3.10/site-packages/mpmath/ctx_iv.py

@@ -0,0 +1,551 @@
+import operator
+
+from . import libmp
+
+from .libmp.backend import basestring
+
+from .libmp import (
+    int_types, MPZ_ONE,
+    prec_to_dps, dps_to_prec, repr_dps,
+    round_floor, round_ceiling,
+    fzero, finf, fninf, fnan,
+    mpf_le, mpf_neg,
+    from_int, from_float, from_str, from_rational,
+    mpi_mid, mpi_delta, mpi_str,
+    mpi_abs, mpi_pos, mpi_neg, mpi_add, mpi_sub,
+    mpi_mul, mpi_div, mpi_pow_int, mpi_pow,
+    mpi_from_str,
+    mpci_pos, mpci_neg, mpci_add, mpci_sub, mpci_mul, mpci_div, mpci_pow,
+    mpci_abs, mpci_pow, mpci_exp, mpci_log,
+    ComplexResult,
+    mpf_hash, mpc_hash)
+from .matrices.matrices import _matrix
+
+mpi_zero = (fzero, fzero)
+
+from .ctx_base import StandardBaseContext
+
+new = object.__new__
+
+def convert_mpf_(x, prec, rounding):
+    if hasattr(x, "_mpf_"): return x._mpf_
+    if isinstance(x, int_types): return from_int(x, prec, rounding)
+    if isinstance(x, float): return from_float(x, prec, rounding)
+    if isinstance(x, basestring): return from_str(x, prec, rounding)
+    raise NotImplementedError
+
+
+class ivmpf(object):
+    """
+    Interval arithmetic class. Precision is controlled by iv.prec.
+    """
+
+    def __new__(cls, x=0):
+        return cls.ctx.convert(x)
+
+    def cast(self, cls, f_convert):
+        a, b = self._mpi_
+        if a == b:
+            return cls(f_convert(a))
+        raise ValueError
+
+    def __int__(self):
+        return self.cast(int, libmp.to_int)
+
+    def __float__(self):
+        return self.cast(float, libmp.to_float)
+
+    def __complex__(self):
+        return self.cast(complex, libmp.to_float)
+
+    def __hash__(self):
+        a, b = self._mpi_
+        if a == b:
+            return mpf_hash(a)
+        else:
+            return hash(self._mpi_)
+
+    @property
+    def real(self): return self
+
+    @property
+    def imag(self): return self.ctx.zero
+
+    def conjugate(self): return self
+
+    @property
+    def a(self):
+        a, b = self._mpi_
+        return self.ctx.make_mpf((a, a))
+
+    @property
+    def b(self):
+        a, b = self._mpi_
+        return self.ctx.make_mpf((b, b))
+
+    @property
+    def mid(self):
+        ctx = self.ctx
+        v = mpi_mid(self._mpi_, ctx.prec)
+        return ctx.make_mpf((v, v))
+
+    @property
+    def delta(self):
+        ctx = self.ctx
+        v = mpi_delta(self._mpi_, ctx.prec)
+        return ctx.make_mpf((v,v))
+
+    @property
+    def _mpci_(self):
+        return self._mpi_, mpi_zero
+
+    def _compare(*args):
+        raise TypeError("no ordering relation is defined for intervals")
+
+    __gt__ = _compare
+    __le__ = _compare
+    __gt__ = _compare
+    __ge__ = _compare
+
+    def __contains__(self, t):
+        t = self.ctx.mpf(t)
+        return (self.a <= t.a) and (t.b <= self.b)
+
+    def __str__(self):
+        return mpi_str(self._mpi_, self.ctx.prec)
+
+    def __repr__(self):
+        if self.ctx.pretty:
+            return str(self)
+        a, b = self._mpi_
+        n = repr_dps(self.ctx.prec)
+        a = libmp.to_str(a, n)
+        b = libmp.to_str(b, n)
+        return "mpi(%r, %r)" % (a, b)
+
+    def _compare(s, t, cmpfun):
+        if not hasattr(t, "_mpi_"):
+            try:
+                t = s.ctx.convert(t)
+            except:
+                return NotImplemented
+        return cmpfun(s._mpi_, t._mpi_)
+
+    def __eq__(s, t): return s._compare(t, libmp.mpi_eq)
+    def __ne__(s, t): return s._compare(t, libmp.mpi_ne)
+    def __lt__(s, t): return s._compare(t, libmp.mpi_lt)
+    def __le__(s, t): return s._compare(t, libmp.mpi_le)
+    def __gt__(s, t): return s._compare(t, libmp.mpi_gt)
+    def __ge__(s, t): return s._compare(t, libmp.mpi_ge)
+
+    def __abs__(self):
+        return self.ctx.make_mpf(mpi_abs(self._mpi_, self.ctx.prec))
+    def __pos__(self):
+        return self.ctx.make_mpf(mpi_pos(self._mpi_, self.ctx.prec))
+    def __neg__(self):
+        return self.ctx.make_mpf(mpi_neg(self._mpi_, self.ctx.prec))
+
+    def ae(s, t, rel_eps=None, abs_eps=None):
+        return s.ctx.almosteq(s, t, rel_eps, abs_eps)
+
+class ivmpc(object):
+
+    def __new__(cls, re=0, im=0):
+        re = cls.ctx.convert(re)
+        im = cls.ctx.convert(im)
+        y = new(cls)
+        y._mpci_ = re._mpi_, im._mpi_
+        return y
+
+    def __hash__(self):
+        (a, b), (c,d) = self._mpci_
+        if a == b and c == d:
+            return mpc_hash((a, c))
+        else:
+            return hash(self._mpci_)
+
+    def __repr__(s):
+        if s.ctx.pretty:
+            return str(s)
+        return "iv.mpc(%s, %s)" % (repr(s.real), repr(s.imag))
+
+    def __str__(s):
+        return "(%s + %s*j)" % (str(s.real), str(s.imag))
+
+    @property
+    def a(self):
+        (a, b), (c,d) = self._mpci_
+        return self.ctx.make_mpf((a, a))
+
+    @property
+    def b(self):
+        (a, b), (c,d) = self._mpci_
+        return self.ctx.make_mpf((b, b))
+
+    @property
+    def c(self):
+        (a, b), (c,d) = self._mpci_
+        return self.ctx.make_mpf((c, c))
+
+    @property
+    def d(self):
+        (a, b), (c,d) = self._mpci_
+        return self.ctx.make_mpf((d, d))
+
+    @property
+    def real(s):
+        return s.ctx.make_mpf(s._mpci_[0])
+
+    @property
+    def imag(s):
+        return s.ctx.make_mpf(s._mpci_[1])
+
+    def conjugate(s):
+        a, b = s._mpci_
+        return s.ctx.make_mpc((a, mpf_neg(b)))
+
+    def overlap(s, t):
+        t = s.ctx.convert(t)
+        real_overlap = (s.a <= t.a <= s.b) or (s.a <= t.b <= s.b) or (t.a <= s.a <= t.b) or (t.a <= s.b <= t.b)
+        imag_overlap = (s.c <= t.c <= s.d) or (s.c <= t.d <= s.d) or (t.c <= s.c <= t.d) or (t.c <= s.d <= t.d)
+        return real_overlap and imag_overlap
+
+    def __contains__(s, t):
+        t = s.ctx.convert(t)
+        return t.real in s.real and t.imag in s.imag
+
+    def _compare(s, t, ne=False):
+        if not isinstance(t, s.ctx._types):
+            try:
+                t = s.ctx.convert(t)
+            except:
+                return NotImplemented
+        if hasattr(t, '_mpi_'):
+            tval = t._mpi_, mpi_zero
+        elif hasattr(t, '_mpci_'):
+            tval = t._mpci_
+        if ne:
+            return s._mpci_ != tval
+        return s._mpci_ == tval
+
+    def __eq__(s, t): return s._compare(t)
+    def __ne__(s, t): return s._compare(t, True)
+
+    def __lt__(s, t): raise TypeError("complex intervals cannot be ordered")
+    __le__ = __gt__ = __ge__ = __lt__
+
+    def __neg__(s): return s.ctx.make_mpc(mpci_neg(s._mpci_, s.ctx.prec))
+    def __pos__(s): return s.ctx.make_mpc(mpci_pos(s._mpci_, s.ctx.prec))
+    def __abs__(s): return s.ctx.make_mpf(mpci_abs(s._mpci_, s.ctx.prec))
+
+    def ae(s, t, rel_eps=None, abs_eps=None):
+        return s.ctx.almosteq(s, t, rel_eps, abs_eps)
+
+def _binary_op(f_real, f_complex):
+    def g_complex(ctx, sval, tval):
+        return ctx.make_mpc(f_complex(sval, tval, ctx.prec))
+    def g_real(ctx, sval, tval):
+        try:
+            return ctx.make_mpf(f_real(sval, tval, ctx.prec))
+        except ComplexResult:
+            sval = (sval, mpi_zero)
+            tval = (tval, mpi_zero)
+            return g_complex(ctx, sval, tval)
+    def lop_real(s, t):
+        if isinstance(t, _matrix): return NotImplemented
+        ctx = s.ctx
+        if not isinstance(t, ctx._types): t = ctx.convert(t)
+        if hasattr(t, "_mpi_"): return g_real(ctx, s._mpi_, t._mpi_)
+        if hasattr(t, "_mpci_"): return g_complex(ctx, (s._mpi_, mpi_zero), t._mpci_)
+        return NotImplemented
+    def rop_real(s, t):
+        ctx = s.ctx
+        if not isinstance(t, ctx._types): t = ctx.convert(t)
+        if hasattr(t, "_mpi_"): return g_real(ctx, t._mpi_, s._mpi_)
+        if hasattr(t, "_mpci_"): return g_complex(ctx, t._mpci_, (s._mpi_, mpi_zero))
+        return NotImplemented
+    def lop_complex(s, t):
+        if isinstance(t, _matrix): return NotImplemented
+        ctx = s.ctx
+        if not isinstance(t, s.ctx._types):
+            try:
+                t = s.ctx.convert(t)
+            except (ValueError, TypeError):
+                return NotImplemented
+        return g_complex(ctx, s._mpci_, t._mpci_)
+    def rop_complex(s, t):
+        ctx = s.ctx
+        if not isinstance(t, s.ctx._types):
+            t = s.ctx.convert(t)
+        return g_complex(ctx, t._mpci_, s._mpci_)
+    return lop_real, rop_real, lop_complex, rop_complex
+
+ivmpf.__add__, ivmpf.__radd__, ivmpc.__add__, ivmpc.__radd__ = _binary_op(mpi_add, mpci_add)
+ivmpf.__sub__, ivmpf.__rsub__, ivmpc.__sub__, ivmpc.__rsub__ = _binary_op(mpi_sub, mpci_sub)
+ivmpf.__mul__, ivmpf.__rmul__, ivmpc.__mul__, ivmpc.__rmul__ = _binary_op(mpi_mul, mpci_mul)
+ivmpf.__div__, ivmpf.__rdiv__, ivmpc.__div__, ivmpc.__rdiv__ = _binary_op(mpi_div, mpci_div)
+ivmpf.__pow__, ivmpf.__rpow__, ivmpc.__pow__, ivmpc.__rpow__ = _binary_op(mpi_pow, mpci_pow)
+
+ivmpf.__truediv__ = ivmpf.__div__; ivmpf.__rtruediv__ = ivmpf.__rdiv__
+ivmpc.__truediv__ = ivmpc.__div__; ivmpc.__rtruediv__ = ivmpc.__rdiv__
+
+class ivmpf_constant(ivmpf):
+    def __new__(cls, f):
+        self = new(cls)
+        self._f = f
+        return self
+    def _get_mpi_(self):
+        prec = self.ctx._prec[0]
+        a = self._f(prec, round_floor)
+        b = self._f(prec, round_ceiling)
+        return a, b
+    _mpi_ = property(_get_mpi_)
+
+class MPIntervalContext(StandardBaseContext):
+
+    def __init__(ctx):
+        ctx.mpf = type('ivmpf', (ivmpf,), {})
+        ctx.mpc = type('ivmpc', (ivmpc,), {})
+        ctx._types = (ctx.mpf, ctx.mpc)
+        ctx._constant = type('ivmpf_constant', (ivmpf_constant,), {})
+        ctx._prec = [53]
+        ctx._set_prec(53)
+        ctx._constant._ctxdata = ctx.mpf._ctxdata = ctx.mpc._ctxdata = [ctx.mpf, new, ctx._prec]
+        ctx._constant.ctx = ctx.mpf.ctx = ctx.mpc.ctx = ctx
+        ctx.pretty = False
+        StandardBaseContext.__init__(ctx)
+        ctx._init_builtins()
+
+    def _mpi(ctx, a, b=None):
+        if b is None:
+            return ctx.mpf(a)
+        return ctx.mpf((a,b))
+
+    def _init_builtins(ctx):
+        ctx.one = ctx.mpf(1)
+        ctx.zero = ctx.mpf(0)
+        ctx.inf = ctx.mpf('inf')
+        ctx.ninf = -ctx.inf
+        ctx.nan = ctx.mpf('nan')
+        ctx.j = ctx.mpc(0,1)
+        ctx.exp = ctx._wrap_mpi_function(libmp.mpi_exp, libmp.mpci_exp)
+        ctx.sqrt = ctx._wrap_mpi_function(libmp.mpi_sqrt)
+        ctx.ln = ctx._wrap_mpi_function(libmp.mpi_log, libmp.mpci_log)
+        ctx.cos = ctx._wrap_mpi_function(libmp.mpi_cos, libmp.mpci_cos)
+        ctx.sin = ctx._wrap_mpi_function(libmp.mpi_sin, libmp.mpci_sin)
+        ctx.tan = ctx._wrap_mpi_function(libmp.mpi_tan)
+        ctx.gamma = ctx._wrap_mpi_function(libmp.mpi_gamma, libmp.mpci_gamma)
+        ctx.loggamma = ctx._wrap_mpi_function(libmp.mpi_loggamma, libmp.mpci_loggamma)
+        ctx.rgamma = ctx._wrap_mpi_function(libmp.mpi_rgamma, libmp.mpci_rgamma)
+        ctx.factorial = ctx._wrap_mpi_function(libmp.mpi_factorial, libmp.mpci_factorial)
+        ctx.fac = ctx.factorial
+
+        ctx.eps = ctx._constant(lambda prec, rnd: (0, MPZ_ONE, 1-prec, 1))
+        ctx.pi = ctx._constant(libmp.mpf_pi)
+        ctx.e = ctx._constant(libmp.mpf_e)
+        ctx.ln2 = ctx._constant(libmp.mpf_ln2)
+        ctx.ln10 = ctx._constant(libmp.mpf_ln10)
+        ctx.phi = ctx._constant(libmp.mpf_phi)
+        ctx.euler = ctx._constant(libmp.mpf_euler)
+        ctx.catalan = ctx._constant(libmp.mpf_catalan)
+        ctx.glaisher = ctx._constant(libmp.mpf_glaisher)
+        ctx.khinchin = ctx._constant(libmp.mpf_khinchin)
+        ctx.twinprime = ctx._constant(libmp.mpf_twinprime)
+
+    def _wrap_mpi_function(ctx, f_real, f_complex=None):
+        def g(x, **kwargs):
+            if kwargs:
+                prec = kwargs.get('prec', ctx._prec[0])
+            else:
+                prec = ctx._prec[0]
+            x = ctx.convert(x)
+            if hasattr(x, "_mpi_"):
+                return ctx.make_mpf(f_real(x._mpi_, prec))
+            if hasattr(x, "_mpci_"):
+                return ctx.make_mpc(f_complex(x._mpci_, prec))
+            raise ValueError
+        return g
+
+    @classmethod
+    def _wrap_specfun(cls, name, f, wrap):
+        if wrap:
+            def f_wrapped(ctx, *args, **kwargs):
+                convert = ctx.convert
+                args = [convert(a) for a in args]
+                prec = ctx.prec
+                try:
+                    ctx.prec += 10
+                    retval = f(ctx, *args, **kwargs)
+                finally:
+                    ctx.prec = prec
+                return +retval
+        else:
+            f_wrapped = f
+        setattr(cls, name, f_wrapped)
+
+    def _set_prec(ctx, n):
+        ctx._prec[0] = max(1, int(n))
+        ctx._dps = prec_to_dps(n)
+
+    def _set_dps(ctx, n):
+        ctx._prec[0] = dps_to_prec(n)
+        ctx._dps = max(1, int(n))
+
+    prec = property(lambda ctx: ctx._prec[0], _set_prec)
+    dps = property(lambda ctx: ctx._dps, _set_dps)
+
+    def make_mpf(ctx, v):
+        a = new(ctx.mpf)
+        a._mpi_ = v
+        return a
+
+    def make_mpc(ctx, v):
+        a = new(ctx.mpc)
+        a._mpci_ = v
+        return a
+
+    def _mpq(ctx, pq):
+        p, q = pq
+        a = libmp.from_rational(p, q, ctx.prec, round_floor)
+        b = libmp.from_rational(p, q, ctx.prec, round_ceiling)
+        return ctx.make_mpf((a, b))
+
+    def convert(ctx, x):
+        if isinstance(x, (ctx.mpf, ctx.mpc)):
+            return x
+        if isinstance(x, ctx._constant):
+            return +x
+        if isinstance(x, complex) or hasattr(x, "_mpc_"):
+            re = ctx.convert(x.real)
+            im = ctx.convert(x.imag)
+            return ctx.mpc(re,im)
+        if isinstance(x, basestring):
+            v = mpi_from_str(x, ctx.prec)
+            return ctx.make_mpf(v)
+        if hasattr(x, "_mpi_"):
+            a, b = x._mpi_
+        else:
+            try:
+                a, b = x
+            except (TypeError, ValueError):
+                a = b = x
+            if hasattr(a, "_mpi_"):
+                a = a._mpi_[0]
+            else:
+                a = convert_mpf_(a, ctx.prec, round_floor)
+            if hasattr(b, "_mpi_"):
+                b = b._mpi_[1]
+            else:
+                b = convert_mpf_(b, ctx.prec, round_ceiling)
+        if a == fnan or b == fnan:
+            a = fninf
+            b = finf
+        assert mpf_le(a, b), "endpoints must be properly ordered"
+        return ctx.make_mpf((a, b))
+
+    def nstr(ctx, x, n=5, **kwargs):
+        x = ctx.convert(x)
+        if hasattr(x, "_mpi_"):
+            return libmp.mpi_to_str(x._mpi_, n, **kwargs)
+        if hasattr(x, "_mpci_"):
+            re = libmp.mpi_to_str(x._mpci_[0], n, **kwargs)
+            im = libmp.mpi_to_str(x._mpci_[1], n, **kwargs)
+            return "(%s + %s*j)" % (re, im)
+
+    def mag(ctx, x):
+        x = ctx.convert(x)
+        if isinstance(x, ctx.mpc):
+            return max(ctx.mag(x.real), ctx.mag(x.imag)) + 1
+        a, b = libmp.mpi_abs(x._mpi_)
+        sign, man, exp, bc = b
+        if man:
+            return exp+bc
+        if b == fzero:
+            return ctx.ninf
+        if b == fnan:
+            return ctx.nan
+        return ctx.inf
+
+    def isnan(ctx, x):
+        return False
+
+    def isinf(ctx, x):
+        return x == ctx.inf
+
+    def isint(ctx, x):
+        x = ctx.convert(x)
+        a, b = x._mpi_
+        if a == b:
+            sign, man, exp, bc = a
+            if man:
+                return exp >= 0
+            return a == fzero
+        return None
+
+    def ldexp(ctx, x, n):
+        a, b = ctx.convert(x)._mpi_
+        a = libmp.mpf_shift(a, n)
+        b = libmp.mpf_shift(b, n)
+        return ctx.make_mpf((a,b))
+
+    def absmin(ctx, x):
+        return abs(ctx.convert(x)).a
+
+    def absmax(ctx, x):
+        return abs(ctx.convert(x)).b
+
+    def atan2(ctx, y, x):
+        y = ctx.convert(y)._mpi_
+        x = ctx.convert(x)._mpi_
+        return ctx.make_mpf(libmp.mpi_atan2(y,x,ctx.prec))
+
+    def _convert_param(ctx, x):
+        if isinstance(x, libmp.int_types):
+            return x, 'Z'
+        if isinstance(x, tuple):
+            p, q = x
+            return (ctx.mpf(p) / ctx.mpf(q), 'R')
+        x = ctx.convert(x)
+        if isinstance(x, ctx.mpf):
+            return x, 'R'
+        if isinstance(x, ctx.mpc):
+            return x, 'C'
+        raise ValueError
+
+    def _is_real_type(ctx, z):
+        return isinstance(z, ctx.mpf) or isinstance(z, int_types)
+
+    def _is_complex_type(ctx, z):
+        return isinstance(z, ctx.mpc)
+
+    def hypsum(ctx, p, q, types, coeffs, z, maxterms=6000, **kwargs):
+        coeffs = list(coeffs)
+        num = range(p)
+        den = range(p,p+q)
+        #tol = ctx.eps
+        s = t = ctx.one
+        k = 0
+        while 1:
+            for i in num: t *= (coeffs[i]+k)
+            for i in den: t /= (coeffs[i]+k)
+            k += 1; t /= k; t *= z; s += t
+            if t == 0:
+                return s
+            #if abs(t) < tol:
+            #    return s
+            if k > maxterms:
+                raise ctx.NoConvergence
+
+
+# Register with "numbers" ABC
+#     We do not subclass, hence we do not use the @abstractmethod checks. While
+#     this is less invasive it may turn out that we do not actually support
+#     parts of the expected interfaces.  See
+#     http://docs.python.org/2/library/numbers.html for list of abstract
+#     methods.
+try:
+    import numbers
+    numbers.Complex.register(ivmpc)
+    numbers.Real.register(ivmpf)
+except ImportError:
+    pass

llmeval-env/lib/python3.10/site-packages/mpmath/ctx_mp.py

@@ -0,0 +1,1339 @@
+"""
+This module defines the mpf, mpc classes, and standard functions for
+operating with them.
+"""
+__docformat__ = 'plaintext'
+
+import functools
+
+import re
+
+from .ctx_base import StandardBaseContext
+
+from .libmp.backend import basestring, BACKEND
+
+from . import libmp
+
+from .libmp import (MPZ, MPZ_ZERO, MPZ_ONE, int_types, repr_dps,
+    round_floor, round_ceiling, dps_to_prec, round_nearest, prec_to_dps,
+    ComplexResult, to_pickable, from_pickable, normalize,
+    from_int, from_float, from_str, to_int, to_float, to_str,
+    from_rational, from_man_exp,
+    fone, fzero, finf, fninf, fnan,
+    mpf_abs, mpf_pos, mpf_neg, mpf_add, mpf_sub, mpf_mul, mpf_mul_int,
+    mpf_div, mpf_rdiv_int, mpf_pow_int, mpf_mod,
+    mpf_eq, mpf_cmp, mpf_lt, mpf_gt, mpf_le, mpf_ge,
+    mpf_hash, mpf_rand,
+    mpf_sum,
+    bitcount, to_fixed,
+    mpc_to_str,
+    mpc_to_complex, mpc_hash, mpc_pos, mpc_is_nonzero, mpc_neg, mpc_conjugate,
+    mpc_abs, mpc_add, mpc_add_mpf, mpc_sub, mpc_sub_mpf, mpc_mul, mpc_mul_mpf,
+    mpc_mul_int, mpc_div, mpc_div_mpf, mpc_pow, mpc_pow_mpf, mpc_pow_int,
+    mpc_mpf_div,
+    mpf_pow,
+    mpf_pi, mpf_degree, mpf_e, mpf_phi, mpf_ln2, mpf_ln10,
+    mpf_euler, mpf_catalan, mpf_apery, mpf_khinchin,
+    mpf_glaisher, mpf_twinprime, mpf_mertens,
+    int_types)
+
+from . import function_docs
+from . import rational
+
+new = object.__new__
+
+get_complex = re.compile(r'^\(?(?P<re>[\+\-]?\d*(\.\d*)?(e[\+\-]?\d+)?)??'
+                         r'(?P<im>[\+\-]?\d*(\.\d*)?(e[\+\-]?\d+)?j)?\)?$')
+
+if BACKEND == 'sage':
+    from sage.libs.mpmath.ext_main import Context as BaseMPContext
+    # pickle hack
+    import sage.libs.mpmath.ext_main as _mpf_module
+else:
+    from .ctx_mp_python import PythonMPContext as BaseMPContext
+    from . import ctx_mp_python as _mpf_module
+
+from .ctx_mp_python import _mpf, _mpc, mpnumeric
+
+class MPContext(BaseMPContext, StandardBaseContext):
+    """
+    Context for multiprecision arithmetic with a global precision.
+    """
+
+    def __init__(ctx):
+        BaseMPContext.__init__(ctx)
+        ctx.trap_complex = False
+        ctx.pretty = False
+        ctx.types = [ctx.mpf, ctx.mpc, ctx.constant]
+        ctx._mpq = rational.mpq
+        ctx.default()
+        StandardBaseContext.__init__(ctx)
+
+        ctx.mpq = rational.mpq
+        ctx.init_builtins()
+
+        ctx.hyp_summators = {}
+
+        ctx._init_aliases()
+
+        # XXX: automate
+        try:
+            ctx.bernoulli.im_func.func_doc = function_docs.bernoulli
+            ctx.primepi.im_func.func_doc = function_docs.primepi
+            ctx.psi.im_func.func_doc = function_docs.psi
+            ctx.atan2.im_func.func_doc = function_docs.atan2
+        except AttributeError:
+            # python 3
+            ctx.bernoulli.__func__.func_doc = function_docs.bernoulli
+            ctx.primepi.__func__.func_doc = function_docs.primepi
+            ctx.psi.__func__.func_doc = function_docs.psi
+            ctx.atan2.__func__.func_doc = function_docs.atan2
+
+        ctx.digamma.func_doc = function_docs.digamma
+        ctx.cospi.func_doc = function_docs.cospi
+        ctx.sinpi.func_doc = function_docs.sinpi
+
+    def init_builtins(ctx):
+
+        mpf = ctx.mpf
+        mpc = ctx.mpc
+
+        # Exact constants
+        ctx.one = ctx.make_mpf(fone)
+        ctx.zero = ctx.make_mpf(fzero)
+        ctx.j = ctx.make_mpc((fzero,fone))
+        ctx.inf = ctx.make_mpf(finf)
+        ctx.ninf = ctx.make_mpf(fninf)
+        ctx.nan = ctx.make_mpf(fnan)
+
+        eps = ctx.constant(lambda prec, rnd: (0, MPZ_ONE, 1-prec, 1),
+            "epsilon of working precision", "eps")
+        ctx.eps = eps
+
+        # Approximate constants
+        ctx.pi = ctx.constant(mpf_pi, "pi", "pi")
+        ctx.ln2 = ctx.constant(mpf_ln2, "ln(2)", "ln2")
+        ctx.ln10 = ctx.constant(mpf_ln10, "ln(10)", "ln10")
+        ctx.phi = ctx.constant(mpf_phi, "Golden ratio phi", "phi")
+        ctx.e = ctx.constant(mpf_e, "e = exp(1)", "e")
+        ctx.euler = ctx.constant(mpf_euler, "Euler's constant", "euler")
+        ctx.catalan = ctx.constant(mpf_catalan, "Catalan's constant", "catalan")
+        ctx.khinchin = ctx.constant(mpf_khinchin, "Khinchin's constant", "khinchin")
+        ctx.glaisher = ctx.constant(mpf_glaisher, "Glaisher's constant", "glaisher")
+        ctx.apery = ctx.constant(mpf_apery, "Apery's constant", "apery")
+        ctx.degree = ctx.constant(mpf_degree, "1 deg = pi / 180", "degree")
+        ctx.twinprime = ctx.constant(mpf_twinprime, "Twin prime constant", "twinprime")
+        ctx.mertens = ctx.constant(mpf_mertens, "Mertens' constant", "mertens")
+
+        # Standard functions
+        ctx.sqrt = ctx._wrap_libmp_function(libmp.mpf_sqrt, libmp.mpc_sqrt)
+        ctx.cbrt = ctx._wrap_libmp_function(libmp.mpf_cbrt, libmp.mpc_cbrt)
+        ctx.ln = ctx._wrap_libmp_function(libmp.mpf_log, libmp.mpc_log)
+        ctx.atan = ctx._wrap_libmp_function(libmp.mpf_atan, libmp.mpc_atan)
+        ctx.exp = ctx._wrap_libmp_function(libmp.mpf_exp, libmp.mpc_exp)
+        ctx.expj = ctx._wrap_libmp_function(libmp.mpf_expj, libmp.mpc_expj)
+        ctx.expjpi = ctx._wrap_libmp_function(libmp.mpf_expjpi, libmp.mpc_expjpi)
+        ctx.sin = ctx._wrap_libmp_function(libmp.mpf_sin, libmp.mpc_sin)
+        ctx.cos = ctx._wrap_libmp_function(libmp.mpf_cos, libmp.mpc_cos)
+        ctx.tan = ctx._wrap_libmp_function(libmp.mpf_tan, libmp.mpc_tan)
+        ctx.sinh = ctx._wrap_libmp_function(libmp.mpf_sinh, libmp.mpc_sinh)
+        ctx.cosh = ctx._wrap_libmp_function(libmp.mpf_cosh, libmp.mpc_cosh)
+        ctx.tanh = ctx._wrap_libmp_function(libmp.mpf_tanh, libmp.mpc_tanh)
+        ctx.asin = ctx._wrap_libmp_function(libmp.mpf_asin, libmp.mpc_asin)
+        ctx.acos = ctx._wrap_libmp_function(libmp.mpf_acos, libmp.mpc_acos)
+        ctx.atan = ctx._wrap_libmp_function(libmp.mpf_atan, libmp.mpc_atan)
+        ctx.asinh = ctx._wrap_libmp_function(libmp.mpf_asinh, libmp.mpc_asinh)
+        ctx.acosh = ctx._wrap_libmp_function(libmp.mpf_acosh, libmp.mpc_acosh)
+        ctx.atanh = ctx._wrap_libmp_function(libmp.mpf_atanh, libmp.mpc_atanh)
+        ctx.sinpi = ctx._wrap_libmp_function(libmp.mpf_sin_pi, libmp.mpc_sin_pi)
+        ctx.cospi = ctx._wrap_libmp_function(libmp.mpf_cos_pi, libmp.mpc_cos_pi)
+        ctx.floor = ctx._wrap_libmp_function(libmp.mpf_floor, libmp.mpc_floor)
+        ctx.ceil = ctx._wrap_libmp_function(libmp.mpf_ceil, libmp.mpc_ceil)
+        ctx.nint = ctx._wrap_libmp_function(libmp.mpf_nint, libmp.mpc_nint)
+        ctx.frac = ctx._wrap_libmp_function(libmp.mpf_frac, libmp.mpc_frac)
+        ctx.fib = ctx.fibonacci = ctx._wrap_libmp_function(libmp.mpf_fibonacci, libmp.mpc_fibonacci)
+
+        ctx.gamma = ctx._wrap_libmp_function(libmp.mpf_gamma, libmp.mpc_gamma)
+        ctx.rgamma = ctx._wrap_libmp_function(libmp.mpf_rgamma, libmp.mpc_rgamma)
+        ctx.loggamma = ctx._wrap_libmp_function(libmp.mpf_loggamma, libmp.mpc_loggamma)
+        ctx.fac = ctx.factorial = ctx._wrap_libmp_function(libmp.mpf_factorial, libmp.mpc_factorial)
+
+        ctx.digamma = ctx._wrap_libmp_function(libmp.mpf_psi0, libmp.mpc_psi0)
+        ctx.harmonic = ctx._wrap_libmp_function(libmp.mpf_harmonic, libmp.mpc_harmonic)
+        ctx.ei = ctx._wrap_libmp_function(libmp.mpf_ei, libmp.mpc_ei)
+        ctx.e1 = ctx._wrap_libmp_function(libmp.mpf_e1, libmp.mpc_e1)
+        ctx._ci = ctx._wrap_libmp_function(libmp.mpf_ci, libmp.mpc_ci)
+        ctx._si = ctx._wrap_libmp_function(libmp.mpf_si, libmp.mpc_si)
+        ctx.ellipk = ctx._wrap_libmp_function(libmp.mpf_ellipk, libmp.mpc_ellipk)
+        ctx._ellipe = ctx._wrap_libmp_function(libmp.mpf_ellipe, libmp.mpc_ellipe)
+        ctx.agm1 = ctx._wrap_libmp_function(libmp.mpf_agm1, libmp.mpc_agm1)
+        ctx._erf = ctx._wrap_libmp_function(libmp.mpf_erf, None)
+        ctx._erfc = ctx._wrap_libmp_function(libmp.mpf_erfc, None)
+        ctx._zeta = ctx._wrap_libmp_function(libmp.mpf_zeta, libmp.mpc_zeta)
+        ctx._altzeta = ctx._wrap_libmp_function(libmp.mpf_altzeta, libmp.mpc_altzeta)
+
+        # Faster versions
+        ctx.sqrt = getattr(ctx, "_sage_sqrt", ctx.sqrt)
+        ctx.exp = getattr(ctx, "_sage_exp", ctx.exp)
+        ctx.ln = getattr(ctx, "_sage_ln", ctx.ln)
+        ctx.cos = getattr(ctx, "_sage_cos", ctx.cos)
+        ctx.sin = getattr(ctx, "_sage_sin", ctx.sin)
+
+    def to_fixed(ctx, x, prec):
+        return x.to_fixed(prec)
+
+    def hypot(ctx, x, y):
+        r"""
+        Computes the Euclidean norm of the vector `(x, y)`, equal
+        to `\sqrt{x^2 + y^2}`. Both `x` and `y` must be real."""
+        x = ctx.convert(x)
+        y = ctx.convert(y)
+        return ctx.make_mpf(libmp.mpf_hypot(x._mpf_, y._mpf_, *ctx._prec_rounding))
+
+    def _gamma_upper_int(ctx, n, z):
+        n = int(ctx._re(n))
+        if n == 0:
+            return ctx.e1(z)
+        if not hasattr(z, '_mpf_'):
+            raise NotImplementedError
+        prec, rounding = ctx._prec_rounding
+        real, imag = libmp.mpf_expint(n, z._mpf_, prec, rounding, gamma=True)
+        if imag is None:
+            return ctx.make_mpf(real)
+        else:
+            return ctx.make_mpc((real, imag))
+
+    def _expint_int(ctx, n, z):
+        n = int(n)
+        if n == 1:
+            return ctx.e1(z)
+        if not hasattr(z, '_mpf_'):
+            raise NotImplementedError
+        prec, rounding = ctx._prec_rounding
+        real, imag = libmp.mpf_expint(n, z._mpf_, prec, rounding)
+        if imag is None:
+            return ctx.make_mpf(real)
+        else:
+            return ctx.make_mpc((real, imag))
+
+    def _nthroot(ctx, x, n):
+        if hasattr(x, '_mpf_'):
+            try:
+                return ctx.make_mpf(libmp.mpf_nthroot(x._mpf_, n, *ctx._prec_rounding))
+            except ComplexResult:
+                if ctx.trap_complex:
+                    raise
+                x = (x._mpf_, libmp.fzero)
+        else:
+            x = x._mpc_
+        return ctx.make_mpc(libmp.mpc_nthroot(x, n, *ctx._prec_rounding))
+
+    def _besselj(ctx, n, z):
+        prec, rounding = ctx._prec_rounding
+        if hasattr(z, '_mpf_'):
+            return ctx.make_mpf(libmp.mpf_besseljn(n, z._mpf_, prec, rounding))
+        elif hasattr(z, '_mpc_'):
+            return ctx.make_mpc(libmp.mpc_besseljn(n, z._mpc_, prec, rounding))
+
+    def _agm(ctx, a, b=1):
+        prec, rounding = ctx._prec_rounding
+        if hasattr(a, '_mpf_') and hasattr(b, '_mpf_'):
+            try:
+                v = libmp.mpf_agm(a._mpf_, b._mpf_, prec, rounding)
+                return ctx.make_mpf(v)
+            except ComplexResult:
+                pass
+        if hasattr(a, '_mpf_'): a = (a._mpf_, libmp.fzero)
+        else: a = a._mpc_
+        if hasattr(b, '_mpf_'): b = (b._mpf_, libmp.fzero)
+        else: b = b._mpc_
+        return ctx.make_mpc(libmp.mpc_agm(a, b, prec, rounding))
+
+    def bernoulli(ctx, n):
+        return ctx.make_mpf(libmp.mpf_bernoulli(int(n), *ctx._prec_rounding))
+
+    def _zeta_int(ctx, n):
+        return ctx.make_mpf(libmp.mpf_zeta_int(int(n), *ctx._prec_rounding))
+
+    def atan2(ctx, y, x):
+        x = ctx.convert(x)
+        y = ctx.convert(y)
+        return ctx.make_mpf(libmp.mpf_atan2(y._mpf_, x._mpf_, *ctx._prec_rounding))
+
+    def psi(ctx, m, z):
+        z = ctx.convert(z)
+        m = int(m)
+        if ctx._is_real_type(z):
+            return ctx.make_mpf(libmp.mpf_psi(m, z._mpf_, *ctx._prec_rounding))
+        else:
+            return ctx.make_mpc(libmp.mpc_psi(m, z._mpc_, *ctx._prec_rounding))
+
+    def cos_sin(ctx, x, **kwargs):
+        if type(x) not in ctx.types:
+            x = ctx.convert(x)
+        prec, rounding = ctx._parse_prec(kwargs)
+        if hasattr(x, '_mpf_'):
+            c, s = libmp.mpf_cos_sin(x._mpf_, prec, rounding)
+            return ctx.make_mpf(c), ctx.make_mpf(s)
+        elif hasattr(x, '_mpc_'):
+            c, s = libmp.mpc_cos_sin(x._mpc_, prec, rounding)
+            return ctx.make_mpc(c), ctx.make_mpc(s)
+        else:
+            return ctx.cos(x, **kwargs), ctx.sin(x, **kwargs)
+
+    def cospi_sinpi(ctx, x, **kwargs):
+        if type(x) not in ctx.types:
+            x = ctx.convert(x)
+        prec, rounding = ctx._parse_prec(kwargs)
+        if hasattr(x, '_mpf_'):
+            c, s = libmp.mpf_cos_sin_pi(x._mpf_, prec, rounding)
+            return ctx.make_mpf(c), ctx.make_mpf(s)
+        elif hasattr(x, '_mpc_'):
+            c, s = libmp.mpc_cos_sin_pi(x._mpc_, prec, rounding)
+            return ctx.make_mpc(c), ctx.make_mpc(s)
+        else:
+            return ctx.cos(x, **kwargs), ctx.sin(x, **kwargs)
+
+    def clone(ctx):
+        """
+        Create a copy of the context, with the same working precision.
+        """
+        a = ctx.__class__()
+        a.prec = ctx.prec
+        return a
+
+    # Several helper methods
+    # TODO: add more of these, make consistent, write docstrings, ...
+
+    def _is_real_type(ctx, x):
+        if hasattr(x, '_mpc_') or type(x) is complex:
+            return False
+        return True
+
+    def _is_complex_type(ctx, x):
+        if hasattr(x, '_mpc_') or type(x) is complex:
+            return True
+        return False
+
+    def isnan(ctx, x):
+        """
+        Return *True* if *x* is a NaN (not-a-number), or for a complex
+        number, whether either the real or complex part is NaN;
+        otherwise return *False*::
+
+            >>> from mpmath import *
+            >>> isnan(3.14)
+            False
+            >>> isnan(nan)
+            True
+            >>> isnan(mpc(3.14,2.72))
+            False
+            >>> isnan(mpc(3.14,nan))
+            True
+
+        """
+        if hasattr(x, "_mpf_"):
+            return x._mpf_ == fnan
+        if hasattr(x, "_mpc_"):
+            return fnan in x._mpc_
+        if isinstance(x, int_types) or isinstance(x, rational.mpq):
+            return False
+        x = ctx.convert(x)
+        if hasattr(x, '_mpf_') or hasattr(x, '_mpc_'):
+            return ctx.isnan(x)
+        raise TypeError("isnan() needs a number as input")
+
+    def isfinite(ctx, x):
+        """
+        Return *True* if *x* is a finite number, i.e. neither
+        an infinity or a NaN.
+
+            >>> from mpmath import *
+            >>> isfinite(inf)
+            False
+            >>> isfinite(-inf)
+            False
+            >>> isfinite(3)
+            True
+            >>> isfinite(nan)
+            False
+            >>> isfinite(3+4j)
+            True
+            >>> isfinite(mpc(3,inf))
+            False
+            >>> isfinite(mpc(nan,3))
+            False
+
+        """
+        if ctx.isinf(x) or ctx.isnan(x):
+            return False
+        return True
+
+    def isnpint(ctx, x):
+        """
+        Determine if *x* is a nonpositive integer.
+        """
+        if not x:
+            return True
+        if hasattr(x, '_mpf_'):
+            sign, man, exp, bc = x._mpf_
+            return sign and exp >= 0
+        if hasattr(x, '_mpc_'):
+            return not x.imag and ctx.isnpint(x.real)
+        if type(x) in int_types:
+            return x <= 0
+        if isinstance(x, ctx.mpq):
+            p, q = x._mpq_
+            if not p:
+                return True
+            return q == 1 and p <= 0
+        return ctx.isnpint(ctx.convert(x))
+
+    def __str__(ctx):
+        lines = ["Mpmath settings:",
+            ("  mp.prec = %s" % ctx.prec).ljust(30) + "[default: 53]",
+            ("  mp.dps = %s" % ctx.dps).ljust(30) + "[default: 15]",
+            ("  mp.trap_complex = %s" % ctx.trap_complex).ljust(30) + "[default: False]",
+        ]
+        return "\n".join(lines)
+
+    @property
+    def _repr_digits(ctx):
+        return repr_dps(ctx._prec)
+
+    @property
+    def _str_digits(ctx):
+        return ctx._dps
+
+    def extraprec(ctx, n, normalize_output=False):
+        """
+        The block
+
+            with extraprec(n):
+                <code>
+
+        increases the precision n bits, executes <code>, and then
+        restores the precision.
+
+        extraprec(n)(f) returns a decorated version of the function f
+        that increases the working precision by n bits before execution,
+        and restores the parent precision afterwards. With
+        normalize_output=True, it rounds the return value to the parent
+        precision.
+        """
+        return PrecisionManager(ctx, lambda p: p + n, None, normalize_output)
+
+    def extradps(ctx, n, normalize_output=False):
+        """
+        This function is analogous to extraprec (see documentation)
+        but changes the decimal precision instead of the number of bits.
+        """
+        return PrecisionManager(ctx, None, lambda d: d + n, normalize_output)
+
+    def workprec(ctx, n, normalize_output=False):
+        """
+        The block
+
+            with workprec(n):
+                <code>
+
+        sets the precision to n bits, executes <code>, and then restores
+        the precision.
+
+        workprec(n)(f) returns a decorated version of the function f
+        that sets the precision to n bits before execution,
+        and restores the precision afterwards. With normalize_output=True,
+        it rounds the return value to the parent precision.
+        """
+        return PrecisionManager(ctx, lambda p: n, None, normalize_output)
+
+    def workdps(ctx, n, normalize_output=False):
+        """
+        This function is analogous to workprec (see documentation)
+        but changes the decimal precision instead of the number of bits.
+        """
+        return PrecisionManager(ctx, None, lambda d: n, normalize_output)
+
+    def autoprec(ctx, f, maxprec=None, catch=(), verbose=False):
+        r"""
+        Return a wrapped copy of *f* that repeatedly evaluates *f*
+        with increasing precision until the result converges to the
+        full precision used at the point of the call.
+
+        This heuristically protects against rounding errors, at the cost of
+        roughly a 2x slowdown compared to manually setting the optimal
+        precision. This method can, however, easily be fooled if the results
+        from *f* depend "discontinuously" on the precision, for instance
+        if catastrophic cancellation can occur. Therefore, :func:`~mpmath.autoprec`
+        should be used judiciously.
+
+        **Examples**
+
+        Many functions are sensitive to perturbations of the input arguments.
+        If the arguments are decimal numbers, they may have to be converted
+        to binary at a much higher precision. If the amount of required
+        extra precision is unknown, :func:`~mpmath.autoprec` is convenient::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15
+            >>> mp.pretty = True
+            >>> besselj(5, 125 * 10**28)    # Exact input
+            -8.03284785591801e-17
+            >>> besselj(5, '1.25e30')   # Bad
+            7.12954868316652e-16
+            >>> autoprec(besselj)(5, '1.25e30')   # Good
+            -8.03284785591801e-17
+
+        The following fails to converge because `\sin(\pi) = 0` whereas all
+        finite-precision approximations of `\pi` give nonzero values::
+
+            >>> autoprec(sin)(pi) # doctest: +IGNORE_EXCEPTION_DETAIL
+            Traceback (most recent call last):
+              ...
+            NoConvergence: autoprec: prec increased to 2910 without convergence
+
+        As the following example shows, :func:`~mpmath.autoprec` can protect against
+        cancellation, but is fooled by too severe cancellation::
+
+            >>> x = 1e-10
+            >>> exp(x)-1; expm1(x); autoprec(lambda t: exp(t)-1)(x)
+            1.00000008274037e-10
+            1.00000000005e-10
+            1.00000000005e-10
+            >>> x = 1e-50
+            >>> exp(x)-1; expm1(x); autoprec(lambda t: exp(t)-1)(x)
+            0.0
+            1.0e-50
+            0.0
+
+        With *catch*, an exception or list of exceptions to intercept
+        may be specified. The raised exception is interpreted
+        as signaling insufficient precision. This permits, for example,
+        evaluating a function where a too low precision results in a
+        division by zero::
+
+            >>> f = lambda x: 1/(exp(x)-1)
+            >>> f(1e-30)
+            Traceback (most recent call last):
+              ...
+            ZeroDivisionError
+            >>> autoprec(f, catch=ZeroDivisionError)(1e-30)
+            1.0e+30
+
+
+        """
+        def f_autoprec_wrapped(*args, **kwargs):
+            prec = ctx.prec
+            if maxprec is None:
+                maxprec2 = ctx._default_hyper_maxprec(prec)
+            else:
+                maxprec2 = maxprec
+            try:
+                ctx.prec = prec + 10
+                try:
+                    v1 = f(*args, **kwargs)
+                except catch:
+                    v1 = ctx.nan
+                prec2 = prec + 20
+                while 1:
+                    ctx.prec = prec2
+                    try:
+                        v2 = f(*args, **kwargs)
+                    except catch:
+                        v2 = ctx.nan
+                    if v1 == v2:
+                        break
+                    err = ctx.mag(v2-v1) - ctx.mag(v2)
+                    if err < (-prec):
+                        break
+                    if verbose:
+                        print("autoprec: target=%s, prec=%s, accuracy=%s" \
+                            % (prec, prec2, -err))
+                    v1 = v2
+                    if prec2 >= maxprec2:
+                        raise ctx.NoConvergence(\
+                        "autoprec: prec increased to %i without convergence"\
+                        % prec2)
+                    prec2 += int(prec2*2)
+                    prec2 = min(prec2, maxprec2)
+            finally:
+                ctx.prec = prec
+            return +v2
+        return f_autoprec_wrapped
+
+    def nstr(ctx, x, n=6, **kwargs):
+        """
+        Convert an ``mpf`` or ``mpc`` to a decimal string literal with *n*
+        significant digits. The small default value for *n* is chosen to
+        make this function useful for printing collections of numbers
+        (lists, matrices, etc).
+
+        If *x* is a list or tuple, :func:`~mpmath.nstr` is applied recursively
+        to each element. For unrecognized classes, :func:`~mpmath.nstr`
+        simply returns ``str(x)``.
+
+        The companion function :func:`~mpmath.nprint` prints the result
+        instead of returning it.
+
+        The keyword arguments *strip_zeros*, *min_fixed*, *max_fixed*
+        and *show_zero_exponent* are forwarded to :func:`~mpmath.libmp.to_str`.
+
+        The number will be printed in fixed-point format if the position
+        of the leading digit is strictly between min_fixed
+        (default = min(-dps/3,-5)) and max_fixed (default = dps).
+
+        To force fixed-point format always, set min_fixed = -inf,
+        max_fixed = +inf. To force floating-point format, set
+        min_fixed >= max_fixed.
+
+            >>> from mpmath import *
+            >>> nstr([+pi, ldexp(1,-500)])
+            '[3.14159, 3.05494e-151]'
+            >>> nprint([+pi, ldexp(1,-500)])
+            [3.14159, 3.05494e-151]
+            >>> nstr(mpf("5e-10"), 5)
+            '5.0e-10'
+            >>> nstr(mpf("5e-10"), 5, strip_zeros=False)
+            '5.0000e-10'
+            >>> nstr(mpf("5e-10"), 5, strip_zeros=False, min_fixed=-11)
+            '0.00000000050000'
+            >>> nstr(mpf(0), 5, show_zero_exponent=True)
+            '0.0e+0'
+
+        """
+        if isinstance(x, list):
+            return "[%s]" % (", ".join(ctx.nstr(c, n, **kwargs) for c in x))
+        if isinstance(x, tuple):
+            return "(%s)" % (", ".join(ctx.nstr(c, n, **kwargs) for c in x))
+        if hasattr(x, '_mpf_'):
+            return to_str(x._mpf_, n, **kwargs)
+        if hasattr(x, '_mpc_'):
+            return "(" + mpc_to_str(x._mpc_, n, **kwargs)  + ")"
+        if isinstance(x, basestring):
+            return repr(x)
+        if isinstance(x, ctx.matrix):
+            return x.__nstr__(n, **kwargs)
+        return str(x)
+
+    def _convert_fallback(ctx, x, strings):
+        if strings and isinstance(x, basestring):
+            if 'j' in x.lower():
+                x = x.lower().replace(' ', '')
+                match = get_complex.match(x)
+                re = match.group('re')
+                if not re:
+                    re = 0
+                im = match.group('im').rstrip('j')
+                return ctx.mpc(ctx.convert(re), ctx.convert(im))
+        if hasattr(x, "_mpi_"):
+            a, b = x._mpi_
+            if a == b:
+                return ctx.make_mpf(a)
+            else:
+                raise ValueError("can only create mpf from zero-width interval")
+        raise TypeError("cannot create mpf from " + repr(x))
+
+    def mpmathify(ctx, *args, **kwargs):
+        return ctx.convert(*args, **kwargs)
+
+    def _parse_prec(ctx, kwargs):
+        if kwargs:
+            if kwargs.get('exact'):
+                return 0, 'f'
+            prec, rounding = ctx._prec_rounding
+            if 'rounding' in kwargs:
+                rounding = kwargs['rounding']
+            if 'prec' in kwargs:
+                prec = kwargs['prec']
+                if prec == ctx.inf:
+                    return 0, 'f'
+                else:
+                    prec = int(prec)
+            elif 'dps' in kwargs:
+                dps = kwargs['dps']
+                if dps == ctx.inf:
+                    return 0, 'f'
+                prec = dps_to_prec(dps)
+            return prec, rounding
+        return ctx._prec_rounding
+
+    _exact_overflow_msg = "the exact result does not fit in memory"
+
+    _hypsum_msg = """hypsum() failed to converge to the requested %i bits of accuracy
+using a working precision of %i bits. Try with a higher maxprec,
+maxterms, or set zeroprec."""
+
+    def hypsum(ctx, p, q, flags, coeffs, z, accurate_small=True, **kwargs):
+        if hasattr(z, "_mpf_"):
+            key = p, q, flags, 'R'
+            v = z._mpf_
+        elif hasattr(z, "_mpc_"):
+            key = p, q, flags, 'C'
+            v = z._mpc_
+        if key not in ctx.hyp_summators:
+            ctx.hyp_summators[key] = libmp.make_hyp_summator(key)[1]
+        summator = ctx.hyp_summators[key]
+        prec = ctx.prec
+        maxprec = kwargs.get('maxprec', ctx._default_hyper_maxprec(prec))
+        extraprec = 50
+        epsshift = 25
+        # Jumps in magnitude occur when parameters are close to negative
+        # integers. We must ensure that these terms are included in
+        # the sum and added accurately
+        magnitude_check = {}
+        max_total_jump = 0
+        for i, c in enumerate(coeffs):
+            if flags[i] == 'Z':
+                if i >= p and c <= 0:
+                    ok = False
+                    for ii, cc in enumerate(coeffs[:p]):
+                        # Note: c <= cc or c < cc, depending on convention
+                        if flags[ii] == 'Z' and cc <= 0 and c <= cc:
+                            ok = True
+                    if not ok:
+                        raise ZeroDivisionError("pole in hypergeometric series")
+                continue
+            n, d = ctx.nint_distance(c)
+            n = -int(n)
+            d = -d
+            if i >= p and n >= 0 and d > 4:
+                if n in magnitude_check:
+                    magnitude_check[n] += d
+                else:
+                    magnitude_check[n] = d
+                extraprec = max(extraprec, d - prec + 60)
+            max_total_jump += abs(d)
+        while 1:
+            if extraprec > maxprec:
+                raise ValueError(ctx._hypsum_msg % (prec, prec+extraprec))
+            wp = prec + extraprec
+            if magnitude_check:
+                mag_dict = dict((n,None) for n in magnitude_check)
+            else:
+                mag_dict = {}
+            zv, have_complex, magnitude = summator(coeffs, v, prec, wp, \
+                epsshift, mag_dict, **kwargs)
+            cancel = -magnitude
+            jumps_resolved = True
+            if extraprec < max_total_jump:
+                for n in mag_dict.values():
+                    if (n is None) or (n < prec):
+                        jumps_resolved = False
+                        break
+            accurate = (cancel < extraprec-25-5 or not accurate_small)
+            if jumps_resolved:
+                if accurate:
+                    break
+                # zero?
+                zeroprec = kwargs.get('zeroprec')
+                if zeroprec is not None:
+                    if cancel > zeroprec:
+                        if have_complex:
+                            return ctx.mpc(0)
+                        else:
+                            return ctx.zero
+
+            # Some near-singularities were not included, so increase
+            # precision and repeat until they are
+            extraprec *= 2
+            # Possible workaround for bad roundoff in fixed-point arithmetic
+            epsshift += 5
+            extraprec += 5
+
+        if type(zv) is tuple:
+            if have_complex:
+                return ctx.make_mpc(zv)
+            else:
+                return ctx.make_mpf(zv)
+        else:
+            return zv
+
+    def ldexp(ctx, x, n):
+        r"""
+        Computes `x 2^n` efficiently. No rounding is performed.
+        The argument `x` must be a real floating-point number (or
+        possible to convert into one) and `n` must be a Python ``int``.
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> ldexp(1, 10)
+            mpf('1024.0')
+            >>> ldexp(1, -3)
+            mpf('0.125')
+
+        """
+        x = ctx.convert(x)
+        return ctx.make_mpf(libmp.mpf_shift(x._mpf_, n))
+
+    def frexp(ctx, x):
+        r"""
+        Given a real number `x`, returns `(y, n)` with `y \in [0.5, 1)`,
+        `n` a Python integer, and such that `x = y 2^n`. No rounding is
+        performed.
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> frexp(7.5)
+            (mpf('0.9375'), 3)
+
+        """
+        x = ctx.convert(x)
+        y, n = libmp.mpf_frexp(x._mpf_)
+        return ctx.make_mpf(y), n
+
+    def fneg(ctx, x, **kwargs):
+        """
+        Negates the number *x*, giving a floating-point result, optionally
+        using a custom precision and rounding mode.
+
+        See the documentation of :func:`~mpmath.fadd` for a detailed description
+        of how to specify precision and rounding.
+
+        **Examples**
+
+        An mpmath number is returned::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> fneg(2.5)
+            mpf('-2.5')
+            >>> fneg(-5+2j)
+            mpc(real='5.0', imag='-2.0')
+
+        Precise control over rounding is possible::
+
+            >>> x = fadd(2, 1e-100, exact=True)
+            >>> fneg(x)
+            mpf('-2.0')
+            >>> fneg(x, rounding='f')
+            mpf('-2.0000000000000004')
+
+        Negating with and without roundoff::
+
+            >>> n = 200000000000000000000001
+            >>> print(int(-mpf(n)))
+            -200000000000000016777216
+            >>> print(int(fneg(n)))
+            -200000000000000016777216
+            >>> print(int(fneg(n, prec=log(n,2)+1)))
+            -200000000000000000000001
+            >>> print(int(fneg(n, dps=log(n,10)+1)))
+            -200000000000000000000001
+            >>> print(int(fneg(n, prec=inf)))
+            -200000000000000000000001
+            >>> print(int(fneg(n, dps=inf)))
+            -200000000000000000000001
+            >>> print(int(fneg(n, exact=True)))
+            -200000000000000000000001
+
+        """
+        prec, rounding = ctx._parse_prec(kwargs)
+        x = ctx.convert(x)
+        if hasattr(x, '_mpf_'):
+            return ctx.make_mpf(mpf_neg(x._mpf_, prec, rounding))
+        if hasattr(x, '_mpc_'):
+            return ctx.make_mpc(mpc_neg(x._mpc_, prec, rounding))
+        raise ValueError("Arguments need to be mpf or mpc compatible numbers")
+
+    def fadd(ctx, x, y, **kwargs):
+        """
+        Adds the numbers *x* and *y*, giving a floating-point result,
+        optionally using a custom precision and rounding mode.
+
+        The default precision is the working precision of the context.
+        You can specify a custom precision in bits by passing the *prec* keyword
+        argument, or by providing an equivalent decimal precision with the *dps*
+        keyword argument. If the precision is set to ``+inf``, or if the flag
+        *exact=True* is passed, an exact addition with no rounding is performed.
+
+        When the precision is finite, the optional *rounding* keyword argument
+        specifies the direction of rounding. Valid options are ``'n'`` for
+        nearest (default), ``'f'`` for floor, ``'c'`` for ceiling, ``'d'``
+        for down, ``'u'`` for up.
+
+        **Examples**
+
+        Using :func:`~mpmath.fadd` with precision and rounding control::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> fadd(2, 1e-20)
+            mpf('2.0')
+            >>> fadd(2, 1e-20, rounding='u')
+            mpf('2.0000000000000004')
+            >>> nprint(fadd(2, 1e-20, prec=100), 25)
+            2.00000000000000000001
+            >>> nprint(fadd(2, 1e-20, dps=15), 25)
+            2.0
+            >>> nprint(fadd(2, 1e-20, dps=25), 25)
+            2.00000000000000000001
+            >>> nprint(fadd(2, 1e-20, exact=True), 25)
+            2.00000000000000000001
+
+        Exact addition avoids cancellation errors, enforcing familiar laws
+        of numbers such as `x+y-x = y`, which don't hold in floating-point
+        arithmetic with finite precision::
+
+            >>> x, y = mpf(2), mpf('1e-1000')
+            >>> print(x + y - x)
+            0.0
+            >>> print(fadd(x, y, prec=inf) - x)
+            1.0e-1000
+            >>> print(fadd(x, y, exact=True) - x)
+            1.0e-1000
+
+        Exact addition can be inefficient and may be impossible to perform
+        with large magnitude differences::
+
+            >>> fadd(1, '1e-100000000000000000000', prec=inf)
+            Traceback (most recent call last):
+              ...
+            OverflowError: the exact result does not fit in memory
+
+        """
+        prec, rounding = ctx._parse_prec(kwargs)
+        x = ctx.convert(x)
+        y = ctx.convert(y)
+        try:
+            if hasattr(x, '_mpf_'):
+                if hasattr(y, '_mpf_'):
+                    return ctx.make_mpf(mpf_add(x._mpf_, y._mpf_, prec, rounding))
+                if hasattr(y, '_mpc_'):
+                    return ctx.make_mpc(mpc_add_mpf(y._mpc_, x._mpf_, prec, rounding))
+            if hasattr(x, '_mpc_'):
+                if hasattr(y, '_mpf_'):
+                    return ctx.make_mpc(mpc_add_mpf(x._mpc_, y._mpf_, prec, rounding))
+                if hasattr(y, '_mpc_'):
+                    return ctx.make_mpc(mpc_add(x._mpc_, y._mpc_, prec, rounding))
+        except (ValueError, OverflowError):
+            raise OverflowError(ctx._exact_overflow_msg)
+        raise ValueError("Arguments need to be mpf or mpc compatible numbers")
+
+    def fsub(ctx, x, y, **kwargs):
+        """
+        Subtracts the numbers *x* and *y*, giving a floating-point result,
+        optionally using a custom precision and rounding mode.
+
+        See the documentation of :func:`~mpmath.fadd` for a detailed description
+        of how to specify precision and rounding.
+
+        **Examples**
+
+        Using :func:`~mpmath.fsub` with precision and rounding control::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> fsub(2, 1e-20)
+            mpf('2.0')
+            >>> fsub(2, 1e-20, rounding='d')
+            mpf('1.9999999999999998')
+            >>> nprint(fsub(2, 1e-20, prec=100), 25)
+            1.99999999999999999999
+            >>> nprint(fsub(2, 1e-20, dps=15), 25)
+            2.0
+            >>> nprint(fsub(2, 1e-20, dps=25), 25)
+            1.99999999999999999999
+            >>> nprint(fsub(2, 1e-20, exact=True), 25)
+            1.99999999999999999999
+
+        Exact subtraction avoids cancellation errors, enforcing familiar laws
+        of numbers such as `x-y+y = x`, which don't hold in floating-point
+        arithmetic with finite precision::
+
+            >>> x, y = mpf(2), mpf('1e1000')
+            >>> print(x - y + y)
+            0.0
+            >>> print(fsub(x, y, prec=inf) + y)
+            2.0
+            >>> print(fsub(x, y, exact=True) + y)
+            2.0
+
+        Exact addition can be inefficient and may be impossible to perform
+        with large magnitude differences::
+
+            >>> fsub(1, '1e-100000000000000000000', prec=inf)
+            Traceback (most recent call last):
+              ...
+            OverflowError: the exact result does not fit in memory
+
+        """
+        prec, rounding = ctx._parse_prec(kwargs)
+        x = ctx.convert(x)
+        y = ctx.convert(y)
+        try:
+            if hasattr(x, '_mpf_'):
+                if hasattr(y, '_mpf_'):
+                    return ctx.make_mpf(mpf_sub(x._mpf_, y._mpf_, prec, rounding))
+                if hasattr(y, '_mpc_'):
+                    return ctx.make_mpc(mpc_sub((x._mpf_, fzero), y._mpc_, prec, rounding))
+            if hasattr(x, '_mpc_'):
+                if hasattr(y, '_mpf_'):
+                    return ctx.make_mpc(mpc_sub_mpf(x._mpc_, y._mpf_, prec, rounding))
+                if hasattr(y, '_mpc_'):
+                    return ctx.make_mpc(mpc_sub(x._mpc_, y._mpc_, prec, rounding))
+        except (ValueError, OverflowError):
+            raise OverflowError(ctx._exact_overflow_msg)
+        raise ValueError("Arguments need to be mpf or mpc compatible numbers")
+
+    def fmul(ctx, x, y, **kwargs):
+        """
+        Multiplies the numbers *x* and *y*, giving a floating-point result,
+        optionally using a custom precision and rounding mode.
+
+        See the documentation of :func:`~mpmath.fadd` for a detailed description
+        of how to specify precision and rounding.
+
+        **Examples**
+
+        The result is an mpmath number::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> fmul(2, 5.0)
+            mpf('10.0')
+            >>> fmul(0.5j, 0.5)
+            mpc(real='0.0', imag='0.25')
+
+        Avoiding roundoff::
+
+            >>> x, y = 10**10+1, 10**15+1
+            >>> print(x*y)
+            10000000001000010000000001
+            >>> print(mpf(x) * mpf(y))
+            1.0000000001e+25
+            >>> print(int(mpf(x) * mpf(y)))
+            10000000001000011026399232
+            >>> print(int(fmul(x, y)))
+            10000000001000011026399232
+            >>> print(int(fmul(x, y, dps=25)))
+            10000000001000010000000001
+            >>> print(int(fmul(x, y, exact=True)))
+            10000000001000010000000001
+
+        Exact multiplication with complex numbers can be inefficient and may
+        be impossible to perform with large magnitude differences between
+        real and imaginary parts::
+
+            >>> x = 1+2j
+            >>> y = mpc(2, '1e-100000000000000000000')
+            >>> fmul(x, y)
+            mpc(real='2.0', imag='4.0')
+            >>> fmul(x, y, rounding='u')
+            mpc(real='2.0', imag='4.0000000000000009')
+            >>> fmul(x, y, exact=True)
+            Traceback (most recent call last):
+              ...
+            OverflowError: the exact result does not fit in memory
+
+        """
+        prec, rounding = ctx._parse_prec(kwargs)
+        x = ctx.convert(x)
+        y = ctx.convert(y)
+        try:
+            if hasattr(x, '_mpf_'):
+                if hasattr(y, '_mpf_'):
+                    return ctx.make_mpf(mpf_mul(x._mpf_, y._mpf_, prec, rounding))
+                if hasattr(y, '_mpc_'):
+                    return ctx.make_mpc(mpc_mul_mpf(y._mpc_, x._mpf_, prec, rounding))
+            if hasattr(x, '_mpc_'):
+                if hasattr(y, '_mpf_'):
+                    return ctx.make_mpc(mpc_mul_mpf(x._mpc_, y._mpf_, prec, rounding))
+                if hasattr(y, '_mpc_'):
+                    return ctx.make_mpc(mpc_mul(x._mpc_, y._mpc_, prec, rounding))
+        except (ValueError, OverflowError):
+            raise OverflowError(ctx._exact_overflow_msg)
+        raise ValueError("Arguments need to be mpf or mpc compatible numbers")
+
+    def fdiv(ctx, x, y, **kwargs):
+        """
+        Divides the numbers *x* and *y*, giving a floating-point result,
+        optionally using a custom precision and rounding mode.
+
+        See the documentation of :func:`~mpmath.fadd` for a detailed description
+        of how to specify precision and rounding.
+
+        **Examples**
+
+        The result is an mpmath number::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> fdiv(3, 2)
+            mpf('1.5')
+            >>> fdiv(2, 3)
+            mpf('0.66666666666666663')
+            >>> fdiv(2+4j, 0.5)
+            mpc(real='4.0', imag='8.0')
+
+        The rounding direction and precision can be controlled::
+
+            >>> fdiv(2, 3, dps=3)    # Should be accurate to at least 3 digits
+            mpf('0.6666259765625')
+            >>> fdiv(2, 3, rounding='d')
+            mpf('0.66666666666666663')
+            >>> fdiv(2, 3, prec=60)
+            mpf('0.66666666666666667')
+            >>> fdiv(2, 3, rounding='u')
+            mpf('0.66666666666666674')
+
+        Checking the error of a division by performing it at higher precision::
+
+            >>> fdiv(2, 3) - fdiv(2, 3, prec=100)
+            mpf('-3.7007434154172148e-17')
+
+        Unlike :func:`~mpmath.fadd`, :func:`~mpmath.fmul`, etc., exact division is not
+        allowed since the quotient of two floating-point numbers generally
+        does not have an exact floating-point representation. (In the
+        future this might be changed to allow the case where the division
+        is actually exact.)
+
+            >>> fdiv(2, 3, exact=True)
+            Traceback (most recent call last):
+              ...
+            ValueError: division is not an exact operation
+
+        """
+        prec, rounding = ctx._parse_prec(kwargs)
+        if not prec:
+            raise ValueError("division is not an exact operation")
+        x = ctx.convert(x)
+        y = ctx.convert(y)
+        if hasattr(x, '_mpf_'):
+            if hasattr(y, '_mpf_'):
+                return ctx.make_mpf(mpf_div(x._mpf_, y._mpf_, prec, rounding))
+            if hasattr(y, '_mpc_'):
+                return ctx.make_mpc(mpc_div((x._mpf_, fzero), y._mpc_, prec, rounding))
+        if hasattr(x, '_mpc_'):
+            if hasattr(y, '_mpf_'):
+                return ctx.make_mpc(mpc_div_mpf(x._mpc_, y._mpf_, prec, rounding))
+            if hasattr(y, '_mpc_'):
+                return ctx.make_mpc(mpc_div(x._mpc_, y._mpc_, prec, rounding))
+        raise ValueError("Arguments need to be mpf or mpc compatible numbers")
+
+    def nint_distance(ctx, x):
+        r"""
+        Return `(n,d)` where `n` is the nearest integer to `x` and `d` is
+        an estimate of `\log_2(|x-n|)`. If `d < 0`, `-d` gives the precision
+        (measured in bits) lost to cancellation when computing `x-n`.
+
+            >>> from mpmath import *
+            >>> n, d = nint_distance(5)
+            >>> print(n); print(d)
+            5
+            -inf
+            >>> n, d = nint_distance(mpf(5))
+            >>> print(n); print(d)
+            5
+            -inf
+            >>> n, d = nint_distance(mpf(5.00000001))
+            >>> print(n); print(d)
+            5
+            -26
+            >>> n, d = nint_distance(mpf(4.99999999))
+            >>> print(n); print(d)
+            5
+            -26
+            >>> n, d = nint_distance(mpc(5,10))
+            >>> print(n); print(d)
+            5
+            4
+            >>> n, d = nint_distance(mpc(5,0.000001))
+            >>> print(n); print(d)
+            5
+            -19
+
+        """
+        typx = type(x)
+        if typx in int_types:
+            return int(x), ctx.ninf
+        elif typx is rational.mpq:
+            p, q = x._mpq_
+            n, r = divmod(p, q)
+            if 2*r >= q:
+                n += 1
+            elif not r:
+                return n, ctx.ninf
+            # log(p/q-n) = log((p-nq)/q) = log(p-nq) - log(q)
+            d = bitcount(abs(p-n*q)) - bitcount(q)
+            return n, d
+        if hasattr(x, "_mpf_"):
+            re = x._mpf_
+            im_dist = ctx.ninf
+        elif hasattr(x, "_mpc_"):
+            re, im = x._mpc_
+            isign, iman, iexp, ibc = im
+            if iman:
+                im_dist = iexp + ibc
+            elif im == fzero:
+                im_dist = ctx.ninf
+            else:
+                raise ValueError("requires a finite number")
+        else:
+            x = ctx.convert(x)
+            if hasattr(x, "_mpf_") or hasattr(x, "_mpc_"):
+                return ctx.nint_distance(x)
+            else:
+                raise TypeError("requires an mpf/mpc")
+        sign, man, exp, bc = re
+        mag = exp+bc
+        # |x| < 0.5
+        if mag < 0:
+            n = 0
+            re_dist = mag
+        elif man:
+            # exact integer
+            if exp >= 0:
+                n = man << exp
+                re_dist = ctx.ninf
+            # exact half-integer
+            elif exp == -1:
+                n = (man>>1)+1
+                re_dist = 0
+            else:
+                d = (-exp-1)
+                t = man >> d
+                if t & 1:
+                    t += 1
+                    man = (t<<d) - man
+                else:
+                    man -= (t<<d)
+                n = t>>1   # int(t)>>1
+                re_dist = exp+bitcount(man)
+            if sign:
+                n = -n
+        elif re == fzero:
+            re_dist = ctx.ninf
+            n = 0
+        else:
+            raise ValueError("requires a finite number")
+        return n, max(re_dist, im_dist)
+
+    def fprod(ctx, factors):
+        r"""
+        Calculates a product containing a finite number of factors (for
+        infinite products, see :func:`~mpmath.nprod`). The factors will be
+        converted to mpmath numbers.
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> fprod([1, 2, 0.5, 7])
+            mpf('7.0')
+
+        """
+        orig = ctx.prec
+        try:
+            v = ctx.one
+            for p in factors:
+                v *= p
+        finally:
+            ctx.prec = orig
+        return +v
+
+    def rand(ctx):
+        """
+        Returns an ``mpf`` with value chosen randomly from `[0, 1)`.
+        The number of randomly generated bits in the mantissa is equal
+        to the working precision.
+        """
+        return ctx.make_mpf(mpf_rand(ctx._prec))
+
+    def fraction(ctx, p, q):
+        """
+        Given Python integers `(p, q)`, returns a lazy ``mpf`` representing
+        the fraction `p/q`. The value is updated with the precision.
+
+            >>> from mpmath import *
+            >>> mp.dps = 15
+            >>> a = fraction(1,100)
+            >>> b = mpf(1)/100
+            >>> print(a); print(b)
+            0.01
+            0.01
+            >>> mp.dps = 30
+            >>> print(a); print(b)      # a will be accurate
+            0.01
+            0.0100000000000000002081668171172
+            >>> mp.dps = 15
+        """
+        return ctx.constant(lambda prec, rnd: from_rational(p, q, prec, rnd),
+            '%s/%s' % (p, q))
+
+    def absmin(ctx, x):
+        return abs(ctx.convert(x))
+
+    def absmax(ctx, x):
+        return abs(ctx.convert(x))
+
+    def _as_points(ctx, x):
+        # XXX: remove this?
+        if hasattr(x, '_mpi_'):
+            a, b = x._mpi_
+            return [ctx.make_mpf(a), ctx.make_mpf(b)]
+        return x
+
+    '''
+    def _zetasum(ctx, s, a, b):
+        """
+        Computes sum of k^(-s) for k = a, a+1, ..., b with a, b both small
+        integers.
+        """
+        a = int(a)
+        b = int(b)
+        s = ctx.convert(s)
+        prec, rounding = ctx._prec_rounding
+        if hasattr(s, '_mpf_'):
+            v = ctx.make_mpf(libmp.mpf_zetasum(s._mpf_, a, b, prec))
+        elif hasattr(s, '_mpc_'):
+            v = ctx.make_mpc(libmp.mpc_zetasum(s._mpc_, a, b, prec))
+        return v
+    '''
+
+    def _zetasum_fast(ctx, s, a, n, derivatives=[0], reflect=False):
+        if not (ctx.isint(a) and hasattr(s, "_mpc_")):
+            raise NotImplementedError
+        a = int(a)
+        prec = ctx._prec
+        xs, ys = libmp.mpc_zetasum(s._mpc_, a, n, derivatives, reflect, prec)
+        xs = [ctx.make_mpc(x) for x in xs]
+        ys = [ctx.make_mpc(y) for y in ys]
+        return xs, ys
+
+class PrecisionManager:
+    def __init__(self, ctx, precfun, dpsfun, normalize_output=False):
+        self.ctx = ctx
+        self.precfun = precfun
+        self.dpsfun = dpsfun
+        self.normalize_output = normalize_output
+    def __call__(self, f):
+        @functools.wraps(f)
+        def g(*args, **kwargs):
+            orig = self.ctx.prec
+            try:
+                if self.precfun:
+                    self.ctx.prec = self.precfun(self.ctx.prec)
+                else:
+                    self.ctx.dps = self.dpsfun(self.ctx.dps)
+                if self.normalize_output:
+                    v = f(*args, **kwargs)
+                    if type(v) is tuple:
+                        return tuple([+a for a in v])
+                    return +v
+                else:
+                    return f(*args, **kwargs)
+            finally:
+                self.ctx.prec = orig
+        return g
+    def __enter__(self):
+        self.origp = self.ctx.prec
+        if self.precfun:
+            self.ctx.prec = self.precfun(self.ctx.prec)
+        else:
+            self.ctx.dps = self.dpsfun(self.ctx.dps)
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.ctx.prec = self.origp
+        return False
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()

llmeval-env/lib/python3.10/site-packages/mpmath/ctx_mp_python.py

@@ -0,0 +1,1149 @@
+#from ctx_base import StandardBaseContext
+
+from .libmp.backend import basestring, exec_
+
+from .libmp import (MPZ, MPZ_ZERO, MPZ_ONE, int_types, repr_dps,
+    round_floor, round_ceiling, dps_to_prec, round_nearest, prec_to_dps,
+    ComplexResult, to_pickable, from_pickable, normalize,
+    from_int, from_float, from_npfloat, from_Decimal, from_str, to_int, to_float, to_str,
+    from_rational, from_man_exp,
+    fone, fzero, finf, fninf, fnan,
+    mpf_abs, mpf_pos, mpf_neg, mpf_add, mpf_sub, mpf_mul, mpf_mul_int,
+    mpf_div, mpf_rdiv_int, mpf_pow_int, mpf_mod,
+    mpf_eq, mpf_cmp, mpf_lt, mpf_gt, mpf_le, mpf_ge,
+    mpf_hash, mpf_rand,
+    mpf_sum,
+    bitcount, to_fixed,
+    mpc_to_str,
+    mpc_to_complex, mpc_hash, mpc_pos, mpc_is_nonzero, mpc_neg, mpc_conjugate,
+    mpc_abs, mpc_add, mpc_add_mpf, mpc_sub, mpc_sub_mpf, mpc_mul, mpc_mul_mpf,
+    mpc_mul_int, mpc_div, mpc_div_mpf, mpc_pow, mpc_pow_mpf, mpc_pow_int,
+    mpc_mpf_div,
+    mpf_pow,
+    mpf_pi, mpf_degree, mpf_e, mpf_phi, mpf_ln2, mpf_ln10,
+    mpf_euler, mpf_catalan, mpf_apery, mpf_khinchin,
+    mpf_glaisher, mpf_twinprime, mpf_mertens,
+    int_types)
+
+from . import rational
+from . import function_docs
+
+new = object.__new__
+
+class mpnumeric(object):
+    """Base class for mpf and mpc."""
+    __slots__ = []
+    def __new__(cls, val):
+        raise NotImplementedError
+
+class _mpf(mpnumeric):
+    """
+    An mpf instance holds a real-valued floating-point number. mpf:s
+    work analogously to Python floats, but support arbitrary-precision
+    arithmetic.
+    """
+    __slots__ = ['_mpf_']
+
+    def __new__(cls, val=fzero, **kwargs):
+        """A new mpf can be created from a Python float, an int, a
+        or a decimal string representing a number in floating-point
+        format."""
+        prec, rounding = cls.context._prec_rounding
+        if kwargs:
+            prec = kwargs.get('prec', prec)
+            if 'dps' in kwargs:
+                prec = dps_to_prec(kwargs['dps'])
+            rounding = kwargs.get('rounding', rounding)
+        if type(val) is cls:
+            sign, man, exp, bc = val._mpf_
+            if (not man) and exp:
+                return val
+            v = new(cls)
+            v._mpf_ = normalize(sign, man, exp, bc, prec, rounding)
+            return v
+        elif type(val) is tuple:
+            if len(val) == 2:
+                v = new(cls)
+                v._mpf_ = from_man_exp(val[0], val[1], prec, rounding)
+                return v
+            if len(val) == 4:
+                if val not in (finf, fninf, fnan):
+                    sign, man, exp, bc = val
+                    val = normalize(sign, MPZ(man), exp, bc, prec, rounding)
+                v = new(cls)
+                v._mpf_ = val
+                return v
+            raise ValueError
+        else:
+            v = new(cls)
+            v._mpf_ = mpf_pos(cls.mpf_convert_arg(val, prec, rounding), prec, rounding)
+            return v
+
+    @classmethod
+    def mpf_convert_arg(cls, x, prec, rounding):
+        if isinstance(x, int_types): return from_int(x)
+        if isinstance(x, float): return from_float(x)
+        if isinstance(x, basestring): return from_str(x, prec, rounding)
+        if isinstance(x, cls.context.constant): return x.func(prec, rounding)
+        if hasattr(x, '_mpf_'): return x._mpf_
+        if hasattr(x, '_mpmath_'):
+            t = cls.context.convert(x._mpmath_(prec, rounding))
+            if hasattr(t, '_mpf_'):
+                return t._mpf_
+        if hasattr(x, '_mpi_'):
+            a, b = x._mpi_
+            if a == b:
+                return a
+            raise ValueError("can only create mpf from zero-width interval")
+        raise TypeError("cannot create mpf from " + repr(x))
+
+    @classmethod
+    def mpf_convert_rhs(cls, x):
+        if isinstance(x, int_types): return from_int(x)
+        if isinstance(x, float): return from_float(x)
+        if isinstance(x, complex_types): return cls.context.mpc(x)
+        if isinstance(x, rational.mpq):
+            p, q = x._mpq_
+            return from_rational(p, q, cls.context.prec)
+        if hasattr(x, '_mpf_'): return x._mpf_
+        if hasattr(x, '_mpmath_'):
+            t = cls.context.convert(x._mpmath_(*cls.context._prec_rounding))
+            if hasattr(t, '_mpf_'):
+                return t._mpf_
+            return t
+        return NotImplemented
+
+    @classmethod
+    def mpf_convert_lhs(cls, x):
+        x = cls.mpf_convert_rhs(x)
+        if type(x) is tuple:
+            return cls.context.make_mpf(x)
+        return x
+
+    man_exp = property(lambda self: self._mpf_[1:3])
+    man = property(lambda self: self._mpf_[1])
+    exp = property(lambda self: self._mpf_[2])
+    bc = property(lambda self: self._mpf_[3])
+
+    real = property(lambda self: self)
+    imag = property(lambda self: self.context.zero)
+
+    conjugate = lambda self: self
+
+    def __getstate__(self): return to_pickable(self._mpf_)
+    def __setstate__(self, val): self._mpf_ = from_pickable(val)
+
+    def __repr__(s):
+        if s.context.pretty:
+            return str(s)
+        return "mpf('%s')" % to_str(s._mpf_, s.context._repr_digits)
+
+    def __str__(s): return to_str(s._mpf_, s.context._str_digits)
+    def __hash__(s): return mpf_hash(s._mpf_)
+    def __int__(s): return int(to_int(s._mpf_))
+    def __long__(s): return long(to_int(s._mpf_))
+    def __float__(s): return to_float(s._mpf_, rnd=s.context._prec_rounding[1])
+    def __complex__(s): return complex(float(s))
+    def __nonzero__(s): return s._mpf_ != fzero
+
+    __bool__ = __nonzero__
+
+    def __abs__(s):
+        cls, new, (prec, rounding) = s._ctxdata
+        v = new(cls)
+        v._mpf_ = mpf_abs(s._mpf_, prec, rounding)
+        return v
+
+    def __pos__(s):
+        cls, new, (prec, rounding) = s._ctxdata
+        v = new(cls)
+        v._mpf_ = mpf_pos(s._mpf_, prec, rounding)
+        return v
+
+    def __neg__(s):
+        cls, new, (prec, rounding) = s._ctxdata
+        v = new(cls)
+        v._mpf_ = mpf_neg(s._mpf_, prec, rounding)
+        return v
+
+    def _cmp(s, t, func):
+        if hasattr(t, '_mpf_'):
+            t = t._mpf_
+        else:
+            t = s.mpf_convert_rhs(t)
+            if t is NotImplemented:
+                return t
+        return func(s._mpf_, t)
+
+    def __cmp__(s, t): return s._cmp(t, mpf_cmp)
+    def __lt__(s, t): return s._cmp(t, mpf_lt)
+    def __gt__(s, t): return s._cmp(t, mpf_gt)
+    def __le__(s, t): return s._cmp(t, mpf_le)
+    def __ge__(s, t): return s._cmp(t, mpf_ge)
+
+    def __ne__(s, t):
+        v = s.__eq__(t)
+        if v is NotImplemented:
+            return v
+        return not v
+
+    def __rsub__(s, t):
+        cls, new, (prec, rounding) = s._ctxdata
+        if type(t) in int_types:
+            v = new(cls)
+            v._mpf_ = mpf_sub(from_int(t), s._mpf_, prec, rounding)
+            return v
+        t = s.mpf_convert_lhs(t)
+        if t is NotImplemented:
+            return t
+        return t - s
+
+    def __rdiv__(s, t):
+        cls, new, (prec, rounding) = s._ctxdata
+        if isinstance(t, int_types):
+            v = new(cls)
+            v._mpf_ = mpf_rdiv_int(t, s._mpf_, prec, rounding)
+            return v
+        t = s.mpf_convert_lhs(t)
+        if t is NotImplemented:
+            return t
+        return t / s
+
+    def __rpow__(s, t):
+        t = s.mpf_convert_lhs(t)
+        if t is NotImplemented:
+            return t
+        return t ** s
+
+    def __rmod__(s, t):
+        t = s.mpf_convert_lhs(t)
+        if t is NotImplemented:
+            return t
+        return t % s
+
+    def sqrt(s):
+        return s.context.sqrt(s)
+
+    def ae(s, t, rel_eps=None, abs_eps=None):
+        return s.context.almosteq(s, t, rel_eps, abs_eps)
+
+    def to_fixed(self, prec):
+        return to_fixed(self._mpf_, prec)
+
+    def __round__(self, *args):
+        return round(float(self), *args)
+
+mpf_binary_op = """
+def %NAME%(self, other):
+    mpf, new, (prec, rounding) = self._ctxdata
+    sval = self._mpf_
+    if hasattr(other, '_mpf_'):
+        tval = other._mpf_
+        %WITH_MPF%
+    ttype = type(other)
+    if ttype in int_types:
+        %WITH_INT%
+    elif ttype is float:
+        tval = from_float(other)
+        %WITH_MPF%
+    elif hasattr(other, '_mpc_'):
+        tval = other._mpc_
+        mpc = type(other)
+        %WITH_MPC%
+    elif ttype is complex:
+        tval = from_float(other.real), from_float(other.imag)
+        mpc = self.context.mpc
+        %WITH_MPC%
+    if isinstance(other, mpnumeric):
+        return NotImplemented
+    try:
+        other = mpf.context.convert(other, strings=False)
+    except TypeError:
+        return NotImplemented
+    return self.%NAME%(other)
+"""
+
+return_mpf = "; obj = new(mpf); obj._mpf_ = val; return obj"
+return_mpc = "; obj = new(mpc); obj._mpc_ = val; return obj"
+
+mpf_pow_same = """
+        try:
+            val = mpf_pow(sval, tval, prec, rounding) %s
+        except ComplexResult:
+            if mpf.context.trap_complex:
+                raise
+            mpc = mpf.context.mpc
+            val = mpc_pow((sval, fzero), (tval, fzero), prec, rounding) %s
+""" % (return_mpf, return_mpc)
+
+def binary_op(name, with_mpf='', with_int='', with_mpc=''):
+    code = mpf_binary_op
+    code = code.replace("%WITH_INT%", with_int)
+    code = code.replace("%WITH_MPC%", with_mpc)
+    code = code.replace("%WITH_MPF%", with_mpf)
+    code = code.replace("%NAME%", name)
+    np = {}
+    exec_(code, globals(), np)
+    return np[name]
+
+_mpf.__eq__ = binary_op('__eq__',
+    'return mpf_eq(sval, tval)',
+    'return mpf_eq(sval, from_int(other))',
+    'return (tval[1] == fzero) and mpf_eq(tval[0], sval)')
+
+_mpf.__add__ = binary_op('__add__',
+    'val = mpf_add(sval, tval, prec, rounding)' + return_mpf,
+    'val = mpf_add(sval, from_int(other), prec, rounding)' + return_mpf,
+    'val = mpc_add_mpf(tval, sval, prec, rounding)' + return_mpc)
+
+_mpf.__sub__ = binary_op('__sub__',
+    'val = mpf_sub(sval, tval, prec, rounding)' + return_mpf,
+    'val = mpf_sub(sval, from_int(other), prec, rounding)' + return_mpf,
+    'val = mpc_sub((sval, fzero), tval, prec, rounding)' + return_mpc)
+
+_mpf.__mul__ = binary_op('__mul__',
+    'val = mpf_mul(sval, tval, prec, rounding)' + return_mpf,
+    'val = mpf_mul_int(sval, other, prec, rounding)' + return_mpf,
+    'val = mpc_mul_mpf(tval, sval, prec, rounding)' + return_mpc)
+
+_mpf.__div__ = binary_op('__div__',
+    'val = mpf_div(sval, tval, prec, rounding)' + return_mpf,
+    'val = mpf_div(sval, from_int(other), prec, rounding)' + return_mpf,
+    'val = mpc_mpf_div(sval, tval, prec, rounding)' + return_mpc)
+
+_mpf.__mod__ = binary_op('__mod__',
+    'val = mpf_mod(sval, tval, prec, rounding)' + return_mpf,
+    'val = mpf_mod(sval, from_int(other), prec, rounding)' + return_mpf,
+    'raise NotImplementedError("complex modulo")')
+
+_mpf.__pow__ = binary_op('__pow__',
+    mpf_pow_same,
+    'val = mpf_pow_int(sval, other, prec, rounding)' + return_mpf,
+    'val = mpc_pow((sval, fzero), tval, prec, rounding)' + return_mpc)
+
+_mpf.__radd__ = _mpf.__add__
+_mpf.__rmul__ = _mpf.__mul__
+_mpf.__truediv__ = _mpf.__div__
+_mpf.__rtruediv__ = _mpf.__rdiv__
+
+
+class _constant(_mpf):
+    """Represents a mathematical constant with dynamic precision.
+    When printed or used in an arithmetic operation, a constant
+    is converted to a regular mpf at the working precision. A
+    regular mpf can also be obtained using the operation +x."""
+
+    def __new__(cls, func, name, docname=''):
+        a = object.__new__(cls)
+        a.name = name
+        a.func = func
+        a.__doc__ = getattr(function_docs, docname, '')
+        return a
+
+    def __call__(self, prec=None, dps=None, rounding=None):
+        prec2, rounding2 = self.context._prec_rounding
+        if not prec: prec = prec2
+        if not rounding: rounding = rounding2
+        if dps: prec = dps_to_prec(dps)
+        return self.context.make_mpf(self.func(prec, rounding))
+
+    @property
+    def _mpf_(self):
+        prec, rounding = self.context._prec_rounding
+        return self.func(prec, rounding)
+
+    def __repr__(self):
+        return "<%s: %s~>" % (self.name, self.context.nstr(self(dps=15)))
+
+
+class _mpc(mpnumeric):
+    """
+    An mpc represents a complex number using a pair of mpf:s (one
+    for the real part and another for the imaginary part.) The mpc
+    class behaves fairly similarly to Python's complex type.
+    """
+
+    __slots__ = ['_mpc_']
+
+    def __new__(cls, real=0, imag=0):
+        s = object.__new__(cls)
+        if isinstance(real, complex_types):
+            real, imag = real.real, real.imag
+        elif hasattr(real, '_mpc_'):
+            s._mpc_ = real._mpc_
+            return s
+        real = cls.context.mpf(real)
+        imag = cls.context.mpf(imag)
+        s._mpc_ = (real._mpf_, imag._mpf_)
+        return s
+
+    real = property(lambda self: self.context.make_mpf(self._mpc_[0]))
+    imag = property(lambda self: self.context.make_mpf(self._mpc_[1]))
+
+    def __getstate__(self):
+        return to_pickable(self._mpc_[0]), to_pickable(self._mpc_[1])
+
+    def __setstate__(self, val):
+        self._mpc_ = from_pickable(val[0]), from_pickable(val[1])
+
+    def __repr__(s):
+        if s.context.pretty:
+            return str(s)
+        r = repr(s.real)[4:-1]
+        i = repr(s.imag)[4:-1]
+        return "%s(real=%s, imag=%s)" % (type(s).__name__, r, i)
+
+    def __str__(s):
+        return "(%s)" % mpc_to_str(s._mpc_, s.context._str_digits)
+
+    def __complex__(s):
+        return mpc_to_complex(s._mpc_, rnd=s.context._prec_rounding[1])
+
+    def __pos__(s):
+        cls, new, (prec, rounding) = s._ctxdata
+        v = new(cls)
+        v._mpc_ = mpc_pos(s._mpc_, prec, rounding)
+        return v
+
+    def __abs__(s):
+        prec, rounding = s.context._prec_rounding
+        v = new(s.context.mpf)
+        v._mpf_ = mpc_abs(s._mpc_, prec, rounding)
+        return v
+
+    def __neg__(s):
+        cls, new, (prec, rounding) = s._ctxdata
+        v = new(cls)
+        v._mpc_ = mpc_neg(s._mpc_, prec, rounding)
+        return v
+
+    def conjugate(s):
+        cls, new, (prec, rounding) = s._ctxdata
+        v = new(cls)
+        v._mpc_ = mpc_conjugate(s._mpc_, prec, rounding)
+        return v
+
+    def __nonzero__(s):
+        return mpc_is_nonzero(s._mpc_)
+
+    __bool__ = __nonzero__
+
+    def __hash__(s):
+        return mpc_hash(s._mpc_)
+
+    @classmethod
+    def mpc_convert_lhs(cls, x):
+        try:
+            y = cls.context.convert(x)
+            return y
+        except TypeError:
+            return NotImplemented
+
+    def __eq__(s, t):
+        if not hasattr(t, '_mpc_'):
+            if isinstance(t, str):
+                return False
+            t = s.mpc_convert_lhs(t)
+            if t is NotImplemented:
+                return t
+        return s.real == t.real and s.imag == t.imag
+
+    def __ne__(s, t):
+        b = s.__eq__(t)
+        if b is NotImplemented:
+            return b
+        return not b
+
+    def _compare(*args):
+        raise TypeError("no ordering relation is defined for complex numbers")
+
+    __gt__ = _compare
+    __le__ = _compare
+    __gt__ = _compare
+    __ge__ = _compare
+
+    def __add__(s, t):
+        cls, new, (prec, rounding) = s._ctxdata
+        if not hasattr(t, '_mpc_'):
+            t = s.mpc_convert_lhs(t)
+            if t is NotImplemented:
+                return t
+            if hasattr(t, '_mpf_'):
+                v = new(cls)
+                v._mpc_ = mpc_add_mpf(s._mpc_, t._mpf_, prec, rounding)
+                return v
+        v = new(cls)
+        v._mpc_ = mpc_add(s._mpc_, t._mpc_, prec, rounding)
+        return v
+
+    def __sub__(s, t):
+        cls, new, (prec, rounding) = s._ctxdata
+        if not hasattr(t, '_mpc_'):
+            t = s.mpc_convert_lhs(t)
+            if t is NotImplemented:
+                return t
+            if hasattr(t, '_mpf_'):
+                v = new(cls)
+                v._mpc_ = mpc_sub_mpf(s._mpc_, t._mpf_, prec, rounding)
+                return v
+        v = new(cls)
+        v._mpc_ = mpc_sub(s._mpc_, t._mpc_, prec, rounding)
+        return v
+
+    def __mul__(s, t):
+        cls, new, (prec, rounding) = s._ctxdata
+        if not hasattr(t, '_mpc_'):
+            if isinstance(t, int_types):
+                v = new(cls)
+                v._mpc_ = mpc_mul_int(s._mpc_, t, prec, rounding)
+                return v
+            t = s.mpc_convert_lhs(t)
+            if t is NotImplemented:
+                return t
+            if hasattr(t, '_mpf_'):
+                v = new(cls)
+                v._mpc_ = mpc_mul_mpf(s._mpc_, t._mpf_, prec, rounding)
+                return v
+            t = s.mpc_convert_lhs(t)
+        v = new(cls)
+        v._mpc_ = mpc_mul(s._mpc_, t._mpc_, prec, rounding)
+        return v
+
+    def __div__(s, t):
+        cls, new, (prec, rounding) = s._ctxdata
+        if not hasattr(t, '_mpc_'):
+            t = s.mpc_convert_lhs(t)
+            if t is NotImplemented:
+                return t
+            if hasattr(t, '_mpf_'):
+                v = new(cls)
+                v._mpc_ = mpc_div_mpf(s._mpc_, t._mpf_, prec, rounding)
+                return v
+        v = new(cls)
+        v._mpc_ = mpc_div(s._mpc_, t._mpc_, prec, rounding)
+        return v
+
+    def __pow__(s, t):
+        cls, new, (prec, rounding) = s._ctxdata
+        if isinstance(t, int_types):
+            v = new(cls)
+            v._mpc_ = mpc_pow_int(s._mpc_, t, prec, rounding)
+            return v
+        t = s.mpc_convert_lhs(t)
+        if t is NotImplemented:
+            return t
+        v = new(cls)
+        if hasattr(t, '_mpf_'):
+            v._mpc_ = mpc_pow_mpf(s._mpc_, t._mpf_, prec, rounding)
+        else:
+            v._mpc_ = mpc_pow(s._mpc_, t._mpc_, prec, rounding)
+        return v
+
+    __radd__ = __add__
+
+    def __rsub__(s, t):
+        t = s.mpc_convert_lhs(t)
+        if t is NotImplemented:
+            return t
+        return t - s
+
+    def __rmul__(s, t):
+        cls, new, (prec, rounding) = s._ctxdata
+        if isinstance(t, int_types):
+            v = new(cls)
+            v._mpc_ = mpc_mul_int(s._mpc_, t, prec, rounding)
+            return v
+        t = s.mpc_convert_lhs(t)
+        if t is NotImplemented:
+            return t
+        return t * s
+
+    def __rdiv__(s, t):
+        t = s.mpc_convert_lhs(t)
+        if t is NotImplemented:
+            return t
+        return t / s
+
+    def __rpow__(s, t):
+        t = s.mpc_convert_lhs(t)
+        if t is NotImplemented:
+            return t
+        return t ** s
+
+    __truediv__ = __div__
+    __rtruediv__ = __rdiv__
+
+    def ae(s, t, rel_eps=None, abs_eps=None):
+        return s.context.almosteq(s, t, rel_eps, abs_eps)
+
+
+complex_types = (complex, _mpc)
+
+
+class PythonMPContext(object):
+
+    def __init__(ctx):
+        ctx._prec_rounding = [53, round_nearest]
+        ctx.mpf = type('mpf', (_mpf,), {})
+        ctx.mpc = type('mpc', (_mpc,), {})
+        ctx.mpf._ctxdata = [ctx.mpf, new, ctx._prec_rounding]
+        ctx.mpc._ctxdata = [ctx.mpc, new, ctx._prec_rounding]
+        ctx.mpf.context = ctx
+        ctx.mpc.context = ctx
+        ctx.constant = type('constant', (_constant,), {})
+        ctx.constant._ctxdata = [ctx.mpf, new, ctx._prec_rounding]
+        ctx.constant.context = ctx
+
+    def make_mpf(ctx, v):
+        a = new(ctx.mpf)
+        a._mpf_ = v
+        return a
+
+    def make_mpc(ctx, v):
+        a = new(ctx.mpc)
+        a._mpc_ = v
+        return a
+
+    def default(ctx):
+        ctx._prec = ctx._prec_rounding[0] = 53
+        ctx._dps = 15
+        ctx.trap_complex = False
+
+    def _set_prec(ctx, n):
+        ctx._prec = ctx._prec_rounding[0] = max(1, int(n))
+        ctx._dps = prec_to_dps(n)
+
+    def _set_dps(ctx, n):
+        ctx._prec = ctx._prec_rounding[0] = dps_to_prec(n)
+        ctx._dps = max(1, int(n))
+
+    prec = property(lambda ctx: ctx._prec, _set_prec)
+    dps = property(lambda ctx: ctx._dps, _set_dps)
+
+    def convert(ctx, x, strings=True):
+        """
+        Converts *x* to an ``mpf`` or ``mpc``. If *x* is of type ``mpf``,
+        ``mpc``, ``int``, ``float``, ``complex``, the conversion
+        will be performed losslessly.
+
+        If *x* is a string, the result will be rounded to the present
+        working precision. Strings representing fractions or complex
+        numbers are permitted.
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> mpmathify(3.5)
+            mpf('3.5')
+            >>> mpmathify('2.1')
+            mpf('2.1000000000000001')
+            >>> mpmathify('3/4')
+            mpf('0.75')
+            >>> mpmathify('2+3j')
+            mpc(real='2.0', imag='3.0')
+
+        """
+        if type(x) in ctx.types: return x
+        if isinstance(x, int_types): return ctx.make_mpf(from_int(x))
+        if isinstance(x, float): return ctx.make_mpf(from_float(x))
+        if isinstance(x, complex):
+            return ctx.make_mpc((from_float(x.real), from_float(x.imag)))
+        if type(x).__module__ == 'numpy': return ctx.npconvert(x)
+        if isinstance(x, numbers.Rational): # e.g. Fraction
+            try: x = rational.mpq(int(x.numerator), int(x.denominator))
+            except: pass
+        prec, rounding = ctx._prec_rounding
+        if isinstance(x, rational.mpq):
+            p, q = x._mpq_
+            return ctx.make_mpf(from_rational(p, q, prec))
+        if strings and isinstance(x, basestring):
+            try:
+                _mpf_ = from_str(x, prec, rounding)
+                return ctx.make_mpf(_mpf_)
+            except ValueError:
+                pass
+        if hasattr(x, '_mpf_'): return ctx.make_mpf(x._mpf_)
+        if hasattr(x, '_mpc_'): return ctx.make_mpc(x._mpc_)
+        if hasattr(x, '_mpmath_'):
+            return ctx.convert(x._mpmath_(prec, rounding))
+        if type(x).__module__ == 'decimal':
+            try: return ctx.make_mpf(from_Decimal(x, prec, rounding))
+            except: pass
+        return ctx._convert_fallback(x, strings)
+
+    def npconvert(ctx, x):
+        """
+        Converts *x* to an ``mpf`` or ``mpc``. *x* should be a numpy
+        scalar.
+        """
+        import numpy as np
+        if isinstance(x, np.integer): return ctx.make_mpf(from_int(int(x)))
+        if isinstance(x, np.floating): return ctx.make_mpf(from_npfloat(x))
+        if isinstance(x, np.complexfloating):
+            return ctx.make_mpc((from_npfloat(x.real), from_npfloat(x.imag)))
+        raise TypeError("cannot create mpf from " + repr(x))
+
+    def isnan(ctx, x):
+        """
+        Return *True* if *x* is a NaN (not-a-number), or for a complex
+        number, whether either the real or complex part is NaN;
+        otherwise return *False*::
+
+            >>> from mpmath import *
+            >>> isnan(3.14)
+            False
+            >>> isnan(nan)
+            True
+            >>> isnan(mpc(3.14,2.72))
+            False
+            >>> isnan(mpc(3.14,nan))
+            True
+
+        """
+        if hasattr(x, "_mpf_"):
+            return x._mpf_ == fnan
+        if hasattr(x, "_mpc_"):
+            return fnan in x._mpc_
+        if isinstance(x, int_types) or isinstance(x, rational.mpq):
+            return False
+        x = ctx.convert(x)
+        if hasattr(x, '_mpf_') or hasattr(x, '_mpc_'):
+            return ctx.isnan(x)
+        raise TypeError("isnan() needs a number as input")
+
+    def isinf(ctx, x):
+        """
+        Return *True* if the absolute value of *x* is infinite;
+        otherwise return *False*::
+
+            >>> from mpmath import *
+            >>> isinf(inf)
+            True
+            >>> isinf(-inf)
+            True
+            >>> isinf(3)
+            False
+            >>> isinf(3+4j)
+            False
+            >>> isinf(mpc(3,inf))
+            True
+            >>> isinf(mpc(inf,3))
+            True
+
+        """
+        if hasattr(x, "_mpf_"):
+            return x._mpf_ in (finf, fninf)
+        if hasattr(x, "_mpc_"):
+            re, im = x._mpc_
+            return re in (finf, fninf) or im in (finf, fninf)
+        if isinstance(x, int_types) or isinstance(x, rational.mpq):
+            return False
+        x = ctx.convert(x)
+        if hasattr(x, '_mpf_') or hasattr(x, '_mpc_'):
+            return ctx.isinf(x)
+        raise TypeError("isinf() needs a number as input")
+
+    def isnormal(ctx, x):
+        """
+        Determine whether *x* is "normal" in the sense of floating-point
+        representation; that is, return *False* if *x* is zero, an
+        infinity or NaN; otherwise return *True*. By extension, a
+        complex number *x* is considered "normal" if its magnitude is
+        normal::
+
+            >>> from mpmath import *
+            >>> isnormal(3)
+            True
+            >>> isnormal(0)
+            False
+            >>> isnormal(inf); isnormal(-inf); isnormal(nan)
+            False
+            False
+            False
+            >>> isnormal(0+0j)
+            False
+            >>> isnormal(0+3j)
+            True
+            >>> isnormal(mpc(2,nan))
+            False
+        """
+        if hasattr(x, "_mpf_"):
+            return bool(x._mpf_[1])
+        if hasattr(x, "_mpc_"):
+            re, im = x._mpc_
+            re_normal = bool(re[1])
+            im_normal = bool(im[1])
+            if re == fzero: return im_normal
+            if im == fzero: return re_normal
+            return re_normal and im_normal
+        if isinstance(x, int_types) or isinstance(x, rational.mpq):
+            return bool(x)
+        x = ctx.convert(x)
+        if hasattr(x, '_mpf_') or hasattr(x, '_mpc_'):
+            return ctx.isnormal(x)
+        raise TypeError("isnormal() needs a number as input")
+
+    def isint(ctx, x, gaussian=False):
+        """
+        Return *True* if *x* is integer-valued; otherwise return
+        *False*::
+
+            >>> from mpmath import *
+            >>> isint(3)
+            True
+            >>> isint(mpf(3))
+            True
+            >>> isint(3.2)
+            False
+            >>> isint(inf)
+            False
+
+        Optionally, Gaussian integers can be checked for::
+
+            >>> isint(3+0j)
+            True
+            >>> isint(3+2j)
+            False
+            >>> isint(3+2j, gaussian=True)
+            True
+
+        """
+        if isinstance(x, int_types):
+            return True
+        if hasattr(x, "_mpf_"):
+            sign, man, exp, bc = xval = x._mpf_
+            return bool((man and exp >= 0) or xval == fzero)
+        if hasattr(x, "_mpc_"):
+            re, im = x._mpc_
+            rsign, rman, rexp, rbc = re
+            isign, iman, iexp, ibc = im
+            re_isint = (rman and rexp >= 0) or re == fzero
+            if gaussian:
+                im_isint = (iman and iexp >= 0) or im == fzero
+                return re_isint and im_isint
+            return re_isint and im == fzero
+        if isinstance(x, rational.mpq):
+            p, q = x._mpq_
+            return p % q == 0
+        x = ctx.convert(x)
+        if hasattr(x, '_mpf_') or hasattr(x, '_mpc_'):
+            return ctx.isint(x, gaussian)
+        raise TypeError("isint() needs a number as input")
+
+    def fsum(ctx, terms, absolute=False, squared=False):
+        """
+        Calculates a sum containing a finite number of terms (for infinite
+        series, see :func:`~mpmath.nsum`). The terms will be converted to
+        mpmath numbers. For len(terms) > 2, this function is generally
+        faster and produces more accurate results than the builtin
+        Python function :func:`sum`.
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> fsum([1, 2, 0.5, 7])
+            mpf('10.5')
+
+        With squared=True each term is squared, and with absolute=True
+        the absolute value of each term is used.
+        """
+        prec, rnd = ctx._prec_rounding
+        real = []
+        imag = []
+        for term in terms:
+            reval = imval = 0
+            if hasattr(term, "_mpf_"):
+                reval = term._mpf_
+            elif hasattr(term, "_mpc_"):
+                reval, imval = term._mpc_
+            else:
+                term = ctx.convert(term)
+                if hasattr(term, "_mpf_"):
+                    reval = term._mpf_
+                elif hasattr(term, "_mpc_"):
+                    reval, imval = term._mpc_
+                else:
+                    raise NotImplementedError
+            if imval:
+                if squared:
+                    if absolute:
+                        real.append(mpf_mul(reval,reval))
+                        real.append(mpf_mul(imval,imval))
+                    else:
+                        reval, imval = mpc_pow_int((reval,imval),2,prec+10)
+                        real.append(reval)
+                        imag.append(imval)
+                elif absolute:
+                    real.append(mpc_abs((reval,imval), prec))
+                else:
+                    real.append(reval)
+                    imag.append(imval)
+            else:
+                if squared:
+                    reval = mpf_mul(reval, reval)
+                elif absolute:
+                    reval = mpf_abs(reval)
+                real.append(reval)
+        s = mpf_sum(real, prec, rnd, absolute)
+        if imag:
+            s = ctx.make_mpc((s, mpf_sum(imag, prec, rnd)))
+        else:
+            s = ctx.make_mpf(s)
+        return s
+
+    def fdot(ctx, A, B=None, conjugate=False):
+        r"""
+        Computes the dot product of the iterables `A` and `B`,
+
+        .. math ::
+
+            \sum_{k=0} A_k B_k.
+
+        Alternatively, :func:`~mpmath.fdot` accepts a single iterable of pairs.
+        In other words, ``fdot(A,B)`` and ``fdot(zip(A,B))`` are equivalent.
+        The elements are automatically converted to mpmath numbers.
+
+        With ``conjugate=True``, the elements in the second vector
+        will be conjugated:
+
+        .. math ::
+
+            \sum_{k=0} A_k \overline{B_k}
+
+        **Examples**
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> A = [2, 1.5, 3]
+            >>> B = [1, -1, 2]
+            >>> fdot(A, B)
+            mpf('6.5')
+            >>> list(zip(A, B))
+            [(2, 1), (1.5, -1), (3, 2)]
+            >>> fdot(_)
+            mpf('6.5')
+            >>> A = [2, 1.5, 3j]
+            >>> B = [1+j, 3, -1-j]
+            >>> fdot(A, B)
+            mpc(real='9.5', imag='-1.0')
+            >>> fdot(A, B, conjugate=True)
+            mpc(real='3.5', imag='-5.0')
+
+        """
+        if B is not None:
+            A = zip(A, B)
+        prec, rnd = ctx._prec_rounding
+        real = []
+        imag = []
+        hasattr_ = hasattr
+        types = (ctx.mpf, ctx.mpc)
+        for a, b in A:
+            if type(a) not in types: a = ctx.convert(a)
+            if type(b) not in types: b = ctx.convert(b)
+            a_real = hasattr_(a, "_mpf_")
+            b_real = hasattr_(b, "_mpf_")
+            if a_real and b_real:
+                real.append(mpf_mul(a._mpf_, b._mpf_))
+                continue
+            a_complex = hasattr_(a, "_mpc_")
+            b_complex = hasattr_(b, "_mpc_")
+            if a_real and b_complex:
+                aval = a._mpf_
+                bre, bim = b._mpc_
+                if conjugate:
+                    bim = mpf_neg(bim)
+                real.append(mpf_mul(aval, bre))
+                imag.append(mpf_mul(aval, bim))
+            elif b_real and a_complex:
+                are, aim = a._mpc_
+                bval = b._mpf_
+                real.append(mpf_mul(are, bval))
+                imag.append(mpf_mul(aim, bval))
+            elif a_complex and b_complex:
+                #re, im = mpc_mul(a._mpc_, b._mpc_, prec+20)
+                are, aim = a._mpc_
+                bre, bim = b._mpc_
+                if conjugate:
+                    bim = mpf_neg(bim)
+                real.append(mpf_mul(are, bre))
+                real.append(mpf_neg(mpf_mul(aim, bim)))
+                imag.append(mpf_mul(are, bim))
+                imag.append(mpf_mul(aim, bre))
+            else:
+                raise NotImplementedError
+        s = mpf_sum(real, prec, rnd)
+        if imag:
+            s = ctx.make_mpc((s, mpf_sum(imag, prec, rnd)))
+        else:
+            s = ctx.make_mpf(s)
+        return s
+
+    def _wrap_libmp_function(ctx, mpf_f, mpc_f=None, mpi_f=None, doc="<no doc>"):
+        """
+        Given a low-level mpf_ function, and optionally similar functions
+        for mpc_ and mpi_, defines the function as a context method.
+
+        It is assumed that the return type is the same as that of
+        the input; the exception is that propagation from mpf to mpc is possible
+        by raising ComplexResult.
+
+        """
+        def f(x, **kwargs):
+            if type(x) not in ctx.types:
+                x = ctx.convert(x)
+            prec, rounding = ctx._prec_rounding
+            if kwargs:
+                prec = kwargs.get('prec', prec)
+                if 'dps' in kwargs:
+                    prec = dps_to_prec(kwargs['dps'])
+                rounding = kwargs.get('rounding', rounding)
+            if hasattr(x, '_mpf_'):
+                try:
+                    return ctx.make_mpf(mpf_f(x._mpf_, prec, rounding))
+                except ComplexResult:
+                    # Handle propagation to complex
+                    if ctx.trap_complex:
+                        raise
+                    return ctx.make_mpc(mpc_f((x._mpf_, fzero), prec, rounding))
+            elif hasattr(x, '_mpc_'):
+                return ctx.make_mpc(mpc_f(x._mpc_, prec, rounding))
+            raise NotImplementedError("%s of a %s" % (name, type(x)))
+        name = mpf_f.__name__[4:]
+        f.__doc__ = function_docs.__dict__.get(name, "Computes the %s of x" % doc)
+        return f
+
+    # Called by SpecialFunctions.__init__()
+    @classmethod
+    def _wrap_specfun(cls, name, f, wrap):
+        if wrap:
+            def f_wrapped(ctx, *args, **kwargs):
+                convert = ctx.convert
+                args = [convert(a) for a in args]
+                prec = ctx.prec
+                try:
+                    ctx.prec += 10
+                    retval = f(ctx, *args, **kwargs)
+                finally:
+                    ctx.prec = prec
+                return +retval
+        else:
+            f_wrapped = f
+        f_wrapped.__doc__ = function_docs.__dict__.get(name, f.__doc__)
+        setattr(cls, name, f_wrapped)
+
+    def _convert_param(ctx, x):
+        if hasattr(x, "_mpc_"):
+            v, im = x._mpc_
+            if im != fzero:
+                return x, 'C'
+        elif hasattr(x, "_mpf_"):
+            v = x._mpf_
+        else:
+            if type(x) in int_types:
+                return int(x), 'Z'
+            p = None
+            if isinstance(x, tuple):
+                p, q = x
+            elif hasattr(x, '_mpq_'):
+                p, q = x._mpq_
+            elif isinstance(x, basestring) and '/' in x:
+                p, q = x.split('/')
+                p = int(p)
+                q = int(q)
+            if p is not None:
+                if not p % q:
+                    return p // q, 'Z'
+                return ctx.mpq(p,q), 'Q'
+            x = ctx.convert(x)
+            if hasattr(x, "_mpc_"):
+                v, im = x._mpc_
+                if im != fzero:
+                    return x, 'C'
+            elif hasattr(x, "_mpf_"):
+                v = x._mpf_
+            else:
+                return x, 'U'
+        sign, man, exp, bc = v
+        if man:
+            if exp >= -4:
+                if sign:
+                    man = -man
+                if exp >= 0:
+                    return int(man) << exp, 'Z'
+                if exp >= -4:
+                    p, q = int(man), (1<<(-exp))
+                    return ctx.mpq(p,q), 'Q'
+            x = ctx.make_mpf(v)
+            return x, 'R'
+        elif not exp:
+            return 0, 'Z'
+        else:
+            return x, 'U'
+
+    def _mpf_mag(ctx, x):
+        sign, man, exp, bc = x
+        if man:
+            return exp+bc
+        if x == fzero:
+            return ctx.ninf
+        if x == finf or x == fninf:
+            return ctx.inf
+        return ctx.nan
+
+    def mag(ctx, x):
+        """
+        Quick logarithmic magnitude estimate of a number. Returns an
+        integer or infinity `m` such that `|x| <= 2^m`. It is not
+        guaranteed that `m` is an optimal bound, but it will never
+        be too large by more than 2 (and probably not more than 1).
+
+        **Examples**
+
+            >>> from mpmath import *
+            >>> mp.pretty = True
+            >>> mag(10), mag(10.0), mag(mpf(10)), int(ceil(log(10,2)))
+            (4, 4, 4, 4)
+            >>> mag(10j), mag(10+10j)
+            (4, 5)
+            >>> mag(0.01), int(ceil(log(0.01,2)))
+            (-6, -6)
+            >>> mag(0), mag(inf), mag(-inf), mag(nan)
+            (-inf, +inf, +inf, nan)
+
+        """
+        if hasattr(x, "_mpf_"):
+            return ctx._mpf_mag(x._mpf_)
+        elif hasattr(x, "_mpc_"):
+            r, i = x._mpc_
+            if r == fzero:
+                return ctx._mpf_mag(i)
+            if i == fzero:
+                return ctx._mpf_mag(r)
+            return 1+max(ctx._mpf_mag(r), ctx._mpf_mag(i))
+        elif isinstance(x, int_types):
+            if x:
+                return bitcount(abs(x))
+            return ctx.ninf
+        elif isinstance(x, rational.mpq):
+            p, q = x._mpq_
+            if p:
+                return 1 + bitcount(abs(p)) - bitcount(q)
+            return ctx.ninf
+        else:
+            x = ctx.convert(x)
+            if hasattr(x, "_mpf_") or hasattr(x, "_mpc_"):
+                return ctx.mag(x)
+            else:
+                raise TypeError("requires an mpf/mpc")
+
+
+# Register with "numbers" ABC
+#     We do not subclass, hence we do not use the @abstractmethod checks. While
+#     this is less invasive it may turn out that we do not actually support
+#     parts of the expected interfaces.  See
+#     http://docs.python.org/2/library/numbers.html for list of abstract
+#     methods.
+try:
+    import numbers
+    numbers.Complex.register(_mpc)
+    numbers.Real.register(_mpf)
+except ImportError:
+    pass

llmeval-env/lib/python3.10/site-packages/mpmath/identification.py

@@ -0,0 +1,844 @@
+"""
+Implements the PSLQ algorithm for integer relation detection,
+and derivative algorithms for constant recognition.
+"""
+
+from .libmp.backend import xrange
+from .libmp import int_types, sqrt_fixed
+
+# round to nearest integer (can be done more elegantly...)
+def round_fixed(x, prec):
+    return ((x + (1<<(prec-1))) >> prec) << prec
+
+class IdentificationMethods(object):
+    pass
+
+
+def pslq(ctx, x, tol=None, maxcoeff=1000, maxsteps=100, verbose=False):
+    r"""
+    Given a vector of real numbers `x = [x_0, x_1, ..., x_n]`, ``pslq(x)``
+    uses the PSLQ algorithm to find a list of integers
+    `[c_0, c_1, ..., c_n]` such that
+
+    .. math ::
+
+        |c_1 x_1 + c_2 x_2 + ... + c_n x_n| < \mathrm{tol}
+
+    and such that `\max |c_k| < \mathrm{maxcoeff}`. If no such vector
+    exists, :func:`~mpmath.pslq` returns ``None``. The tolerance defaults to
+    3/4 of the working precision.
+
+    **Examples**
+
+    Find rational approximations for `\pi`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> pslq([-1, pi], tol=0.01)
+        [22, 7]
+        >>> pslq([-1, pi], tol=0.001)
+        [355, 113]
+        >>> mpf(22)/7; mpf(355)/113; +pi
+        3.14285714285714
+        3.14159292035398
+        3.14159265358979
+
+    Pi is not a rational number with denominator less than 1000::
+
+        >>> pslq([-1, pi])
+        >>>
+
+    To within the standard precision, it can however be approximated
+    by at least one rational number with denominator less than `10^{12}`::
+
+        >>> p, q = pslq([-1, pi], maxcoeff=10**12)
+        >>> print(p); print(q)
+        238410049439
+        75888275702
+        >>> mpf(p)/q
+        3.14159265358979
+
+    The PSLQ algorithm can be applied to long vectors. For example,
+    we can investigate the rational (in)dependence of integer square
+    roots::
+
+        >>> mp.dps = 30
+        >>> pslq([sqrt(n) for n in range(2, 5+1)])
+        >>>
+        >>> pslq([sqrt(n) for n in range(2, 6+1)])
+        >>>
+        >>> pslq([sqrt(n) for n in range(2, 8+1)])
+        [2, 0, 0, 0, 0, 0, -1]
+
+    **Machin formulas**
+
+    A famous formula for `\pi` is Machin's,
+
+    .. math ::
+
+        \frac{\pi}{4} = 4 \operatorname{acot} 5 - \operatorname{acot} 239
+
+    There are actually infinitely many formulas of this type. Two
+    others are
+
+    .. math ::
+
+        \frac{\pi}{4} = \operatorname{acot} 1
+
+        \frac{\pi}{4} = 12 \operatorname{acot} 49 + 32 \operatorname{acot} 57
+            + 5 \operatorname{acot} 239 + 12 \operatorname{acot} 110443
+
+    We can easily verify the formulas using the PSLQ algorithm::
+
+        >>> mp.dps = 30
+        >>> pslq([pi/4, acot(1)])
+        [1, -1]
+        >>> pslq([pi/4, acot(5), acot(239)])
+        [1, -4, 1]
+        >>> pslq([pi/4, acot(49), acot(57), acot(239), acot(110443)])
+        [1, -12, -32, 5, -12]
+
+    We could try to generate a custom Machin-like formula by running
+    the PSLQ algorithm with a few inverse cotangent values, for example
+    acot(2), acot(3) ... acot(10). Unfortunately, there is a linear
+    dependence among these values, resulting in only that dependence
+    being detected, with a zero coefficient for `\pi`::
+
+        >>> pslq([pi] + [acot(n) for n in range(2,11)])
+        [0, 1, -1, 0, 0, 0, -1, 0, 0, 0]
+
+    We get better luck by removing linearly dependent terms::
+
+        >>> pslq([pi] + [acot(n) for n in range(2,11) if n not in (3, 5)])
+        [1, -8, 0, 0, 4, 0, 0, 0]
+
+    In other words, we found the following formula::
+
+        >>> 8*acot(2) - 4*acot(7)
+        3.14159265358979323846264338328
+        >>> +pi
+        3.14159265358979323846264338328
+
+    **Algorithm**
+
+    This is a fairly direct translation to Python of the pseudocode given by
+    David Bailey, "The PSLQ Integer Relation Algorithm":
+    http://www.cecm.sfu.ca/organics/papers/bailey/paper/html/node3.html
+
+    The present implementation uses fixed-point instead of floating-point
+    arithmetic, since this is significantly (about 7x) faster.
+    """
+
+    n = len(x)
+    if n < 2:
+        raise ValueError("n cannot be less than 2")
+
+    # At too low precision, the algorithm becomes meaningless
+    prec = ctx.prec
+    if prec < 53:
+        raise ValueError("prec cannot be less than 53")
+
+    if verbose and prec // max(2,n) < 5:
+        print("Warning: precision for PSLQ may be too low")
+
+    target = int(prec * 0.75)
+
+    if tol is None:
+        tol = ctx.mpf(2)**(-target)
+    else:
+        tol = ctx.convert(tol)
+
+    extra = 60
+    prec += extra
+
+    if verbose:
+        print("PSLQ using prec %i and tol %s" % (prec, ctx.nstr(tol)))
+
+    tol = ctx.to_fixed(tol, prec)
+    assert tol
+
+    # Convert to fixed-point numbers. The dummy None is added so we can
+    # use 1-based indexing. (This just allows us to be consistent with
+    # Bailey's indexing. The algorithm is 100 lines long, so debugging
+    # a single wrong index can be painful.)
+    x = [None] + [ctx.to_fixed(ctx.mpf(xk), prec) for xk in x]
+
+    # Sanity check on magnitudes
+    minx = min(abs(xx) for xx in x[1:])
+    if not minx:
+        raise ValueError("PSLQ requires a vector of nonzero numbers")
+    if minx < tol//100:
+        if verbose:
+            print("STOPPING: (one number is too small)")
+        return None
+
+    g = sqrt_fixed((4<<prec)//3, prec)
+    A = {}
+    B = {}
+    H = {}
+    # Initialization
+    # step 1
+    for i in xrange(1, n+1):
+        for j in xrange(1, n+1):
+            A[i,j] = B[i,j] = (i==j) << prec
+            H[i,j] = 0
+    # step 2
+    s = [None] + [0] * n
+    for k in xrange(1, n+1):
+        t = 0
+        for j in xrange(k, n+1):
+            t += (x[j]**2 >> prec)
+        s[k] = sqrt_fixed(t, prec)
+    t = s[1]
+    y = x[:]
+    for k in xrange(1, n+1):
+        y[k] = (x[k] << prec) // t
+        s[k] = (s[k] << prec) // t
+    # step 3
+    for i in xrange(1, n+1):
+        for j in xrange(i+1, n):
+            H[i,j] = 0
+        if i <= n-1:
+            if s[i]:
+                H[i,i] = (s[i+1] << prec) // s[i]
+            else:
+                H[i,i] = 0
+        for j in range(1, i):
+            sjj1 = s[j]*s[j+1]
+            if sjj1:
+                H[i,j] = ((-y[i]*y[j])<<prec)//sjj1
+            else:
+                H[i,j] = 0
+    # step 4
+    for i in xrange(2, n+1):
+        for j in xrange(i-1, 0, -1):
+            #t = floor(H[i,j]/H[j,j] + 0.5)
+            if H[j,j]:
+                t = round_fixed((H[i,j] << prec)//H[j,j], prec)
+            else:
+                #t = 0
+                continue
+            y[j] = y[j] + (t*y[i] >> prec)
+            for k in xrange(1, j+1):
+                H[i,k] = H[i,k] - (t*H[j,k] >> prec)
+            for k in xrange(1, n+1):
+                A[i,k] = A[i,k] - (t*A[j,k] >> prec)
+                B[k,j] = B[k,j] + (t*B[k,i] >> prec)
+    # Main algorithm
+    for REP in range(maxsteps):
+        # Step 1
+        m = -1
+        szmax = -1
+        for i in range(1, n):
+            h = H[i,i]
+            sz = (g**i * abs(h)) >> (prec*(i-1))
+            if sz > szmax:
+                m = i
+                szmax = sz
+        # Step 2
+        y[m], y[m+1] = y[m+1], y[m]
+        for i in xrange(1,n+1): H[m,i], H[m+1,i] = H[m+1,i], H[m,i]
+        for i in xrange(1,n+1): A[m,i], A[m+1,i] = A[m+1,i], A[m,i]
+        for i in xrange(1,n+1): B[i,m], B[i,m+1] = B[i,m+1], B[i,m]
+        # Step 3
+        if m <= n - 2:
+            t0 = sqrt_fixed((H[m,m]**2 + H[m,m+1]**2)>>prec, prec)
+            # A zero element probably indicates that the precision has
+            # been exhausted. XXX: this could be spurious, due to
+            # using fixed-point arithmetic
+            if not t0:
+                break
+            t1 = (H[m,m] << prec) // t0
+            t2 = (H[m,m+1] << prec) // t0
+            for i in xrange(m, n+1):
+                t3 = H[i,m]
+                t4 = H[i,m+1]
+                H[i,m] = (t1*t3+t2*t4) >> prec
+                H[i,m+1] = (-t2*t3+t1*t4) >> prec
+        # Step 4
+        for i in xrange(m+1, n+1):
+            for j in xrange(min(i-1, m+1), 0, -1):
+                try:
+                    t = round_fixed((H[i,j] << prec)//H[j,j], prec)
+                # Precision probably exhausted
+                except ZeroDivisionError:
+                    break
+                y[j] = y[j] + ((t*y[i]) >> prec)
+                for k in xrange(1, j+1):
+                    H[i,k] = H[i,k] - (t*H[j,k] >> prec)
+                for k in xrange(1, n+1):
+                    A[i,k] = A[i,k] - (t*A[j,k] >> prec)
+                    B[k,j] = B[k,j] + (t*B[k,i] >> prec)
+        # Until a relation is found, the error typically decreases
+        # slowly (e.g. a factor 1-10) with each step TODO: we could
+        # compare err from two successive iterations. If there is a
+        # large drop (several orders of magnitude), that indicates a
+        # "high quality" relation was detected. Reporting this to
+        # the user somehow might be useful.
+        best_err = maxcoeff<<prec
+        for i in xrange(1, n+1):
+            err = abs(y[i])
+            # Maybe we are done?
+            if err < tol:
+                # We are done if the coefficients are acceptable
+                vec = [int(round_fixed(B[j,i], prec) >> prec) for j in \
+                range(1,n+1)]
+                if max(abs(v) for v in vec) < maxcoeff:
+                    if verbose:
+                        print("FOUND relation at iter %i/%i, error: %s" % \
+                            (REP, maxsteps, ctx.nstr(err / ctx.mpf(2)**prec, 1)))
+                    return vec
+            best_err = min(err, best_err)
+        # Calculate a lower bound for the norm. We could do this
+        # more exactly (using the Euclidean norm) but there is probably
+        # no practical benefit.
+        recnorm = max(abs(h) for h in H.values())
+        if recnorm:
+            norm = ((1 << (2*prec)) // recnorm) >> prec
+            norm //= 100
+        else:
+            norm = ctx.inf
+        if verbose:
+            print("%i/%i:  Error: %8s   Norm: %s" % \
+                (REP, maxsteps, ctx.nstr(best_err / ctx.mpf(2)**prec, 1), norm))
+        if norm >= maxcoeff:
+            break
+    if verbose:
+        print("CANCELLING after step %i/%i." % (REP, maxsteps))
+        print("Could not find an integer relation. Norm bound: %s" % norm)
+    return None
+
+def findpoly(ctx, x, n=1, **kwargs):
+    r"""
+    ``findpoly(x, n)`` returns the coefficients of an integer
+    polynomial `P` of degree at most `n` such that `P(x) \approx 0`.
+    If no polynomial having `x` as a root can be found,
+    :func:`~mpmath.findpoly` returns ``None``.
+
+    :func:`~mpmath.findpoly` works by successively calling :func:`~mpmath.pslq` with
+    the vectors `[1, x]`, `[1, x, x^2]`, `[1, x, x^2, x^3]`, ...,
+    `[1, x, x^2, .., x^n]` as input. Keyword arguments given to
+    :func:`~mpmath.findpoly` are forwarded verbatim to :func:`~mpmath.pslq`. In
+    particular, you can specify a tolerance for `P(x)` with ``tol``
+    and a maximum permitted coefficient size with ``maxcoeff``.
+
+    For large values of `n`, it is recommended to run :func:`~mpmath.findpoly`
+    at high precision; preferably 50 digits or more.
+
+    **Examples**
+
+    By default (degree `n = 1`), :func:`~mpmath.findpoly` simply finds a linear
+    polynomial with a rational root::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> findpoly(0.7)
+        [-10, 7]
+
+    The generated coefficient list is valid input to ``polyval`` and
+    ``polyroots``::
+
+        >>> nprint(polyval(findpoly(phi, 2), phi), 1)
+        -2.0e-16
+        >>> for r in polyroots(findpoly(phi, 2)):
+        ...     print(r)
+        ...
+        -0.618033988749895
+        1.61803398874989
+
+    Numbers of the form `m + n \sqrt p` for integers `(m, n, p)` are
+    solutions to quadratic equations. As we find here, `1+\sqrt 2`
+    is a root of the polynomial `x^2 - 2x - 1`::
+
+        >>> findpoly(1+sqrt(2), 2)
+        [1, -2, -1]
+        >>> findroot(lambda x: x**2 - 2*x - 1, 1)
+        2.4142135623731
+
+    Despite only containing square roots, the following number results
+    in a polynomial of degree 4::
+
+        >>> findpoly(sqrt(2)+sqrt(3), 4)
+        [1, 0, -10, 0, 1]
+
+    In fact, `x^4 - 10x^2 + 1` is the *minimal polynomial* of
+    `r = \sqrt 2 + \sqrt 3`, meaning that a rational polynomial of
+    lower degree having `r` as a root does not exist. Given sufficient
+    precision, :func:`~mpmath.findpoly` will usually find the correct
+    minimal polynomial of a given algebraic number.
+
+    **Non-algebraic numbers**
+
+    If :func:`~mpmath.findpoly` fails to find a polynomial with given
+    coefficient size and tolerance constraints, that means no such
+    polynomial exists.
+
+    We can verify that `\pi` is not an algebraic number of degree 3 with
+    coefficients less than 1000::
+
+        >>> mp.dps = 15
+        >>> findpoly(pi, 3)
+        >>>
+
+    It is always possible to find an algebraic approximation of a number
+    using one (or several) of the following methods:
+
+        1. Increasing the permitted degree
+        2. Allowing larger coefficients
+        3. Reducing the tolerance
+
+    One example of each method is shown below::
+
+        >>> mp.dps = 15
+        >>> findpoly(pi, 4)
+        [95, -545, 863, -183, -298]
+        >>> findpoly(pi, 3, maxcoeff=10000)
+        [836, -1734, -2658, -457]
+        >>> findpoly(pi, 3, tol=1e-7)
+        [-4, 22, -29, -2]
+
+    It is unknown whether Euler's constant is transcendental (or even
+    irrational). We can use :func:`~mpmath.findpoly` to check that if is
+    an algebraic number, its minimal polynomial must have degree
+    at least 7 and a coefficient of magnitude at least 1000000::
+
+        >>> mp.dps = 200
+        >>> findpoly(euler, 6, maxcoeff=10**6, tol=1e-100, maxsteps=1000)
+        >>>
+
+    Note that the high precision and strict tolerance is necessary
+    for such high-degree runs, since otherwise unwanted low-accuracy
+    approximations will be detected. It may also be necessary to set
+    maxsteps high to prevent a premature exit (before the coefficient
+    bound has been reached). Running with ``verbose=True`` to get an
+    idea what is happening can be useful.
+    """
+    x = ctx.mpf(x)
+    if n < 1:
+        raise ValueError("n cannot be less than 1")
+    if x == 0:
+        return [1, 0]
+    xs = [ctx.mpf(1)]
+    for i in range(1,n+1):
+        xs.append(x**i)
+        a = ctx.pslq(xs, **kwargs)
+        if a is not None:
+            return a[::-1]
+
+def fracgcd(p, q):
+    x, y = p, q
+    while y:
+        x, y = y, x % y
+    if x != 1:
+        p //= x
+        q //= x
+    if q == 1:
+        return p
+    return p, q
+
+def pslqstring(r, constants):
+    q = r[0]
+    r = r[1:]
+    s = []
+    for i in range(len(r)):
+        p = r[i]
+        if p:
+            z = fracgcd(-p,q)
+            cs = constants[i][1]
+            if cs == '1':
+                cs = ''
+            else:
+                cs = '*' + cs
+            if isinstance(z, int_types):
+                if z > 0: term = str(z) + cs
+                else:     term = ("(%s)" % z) + cs
+            else:
+                term = ("(%s/%s)" % z) + cs
+            s.append(term)
+    s = ' + '.join(s)
+    if '+' in s or '*' in s:
+        s = '(' + s + ')'
+    return s or '0'
+
+def prodstring(r, constants):
+    q = r[0]
+    r = r[1:]
+    num = []
+    den = []
+    for i in range(len(r)):
+        p = r[i]
+        if p:
+            z = fracgcd(-p,q)
+            cs = constants[i][1]
+            if isinstance(z, int_types):
+                if abs(z) == 1: t = cs
+                else:           t = '%s**%s' % (cs, abs(z))
+                ([num,den][z<0]).append(t)
+            else:
+                t = '%s**(%s/%s)' % (cs, abs(z[0]), z[1])
+                ([num,den][z[0]<0]).append(t)
+    num = '*'.join(num)
+    den = '*'.join(den)
+    if num and den: return "(%s)/(%s)" % (num, den)
+    if num: return num
+    if den: return "1/(%s)" % den
+
+def quadraticstring(ctx,t,a,b,c):
+    if c < 0:
+        a,b,c = -a,-b,-c
+    u1 = (-b+ctx.sqrt(b**2-4*a*c))/(2*c)
+    u2 = (-b-ctx.sqrt(b**2-4*a*c))/(2*c)
+    if abs(u1-t) < abs(u2-t):
+        if b:  s = '((%s+sqrt(%s))/%s)' % (-b,b**2-4*a*c,2*c)
+        else:  s = '(sqrt(%s)/%s)' % (-4*a*c,2*c)
+    else:
+        if b:  s = '((%s-sqrt(%s))/%s)' % (-b,b**2-4*a*c,2*c)
+        else:  s = '(-sqrt(%s)/%s)' % (-4*a*c,2*c)
+    return s
+
+# Transformation y = f(x,c), with inverse function x = f(y,c)
+# The third entry indicates whether the transformation is
+# redundant when c = 1
+transforms = [
+  (lambda ctx,x,c: x*c, '$y/$c', 0),
+  (lambda ctx,x,c: x/c, '$c*$y', 1),
+  (lambda ctx,x,c: c/x, '$c/$y', 0),
+  (lambda ctx,x,c: (x*c)**2, 'sqrt($y)/$c', 0),
+  (lambda ctx,x,c: (x/c)**2, '$c*sqrt($y)', 1),
+  (lambda ctx,x,c: (c/x)**2, '$c/sqrt($y)', 0),
+  (lambda ctx,x,c: c*x**2, 'sqrt($y)/sqrt($c)', 1),
+  (lambda ctx,x,c: x**2/c, 'sqrt($c)*sqrt($y)', 1),
+  (lambda ctx,x,c: c/x**2, 'sqrt($c)/sqrt($y)', 1),
+  (lambda ctx,x,c: ctx.sqrt(x*c), '$y**2/$c', 0),
+  (lambda ctx,x,c: ctx.sqrt(x/c), '$c*$y**2', 1),
+  (lambda ctx,x,c: ctx.sqrt(c/x), '$c/$y**2', 0),
+  (lambda ctx,x,c: c*ctx.sqrt(x), '$y**2/$c**2', 1),
+  (lambda ctx,x,c: ctx.sqrt(x)/c, '$c**2*$y**2', 1),
+  (lambda ctx,x,c: c/ctx.sqrt(x), '$c**2/$y**2', 1),
+  (lambda ctx,x,c: ctx.exp(x*c), 'log($y)/$c', 0),
+  (lambda ctx,x,c: ctx.exp(x/c), '$c*log($y)', 1),
+  (lambda ctx,x,c: ctx.exp(c/x), '$c/log($y)', 0),
+  (lambda ctx,x,c: c*ctx.exp(x), 'log($y/$c)', 1),
+  (lambda ctx,x,c: ctx.exp(x)/c, 'log($c*$y)', 1),
+  (lambda ctx,x,c: c/ctx.exp(x), 'log($c/$y)', 0),
+  (lambda ctx,x,c: ctx.ln(x*c), 'exp($y)/$c', 0),
+  (lambda ctx,x,c: ctx.ln(x/c), '$c*exp($y)', 1),
+  (lambda ctx,x,c: ctx.ln(c/x), '$c/exp($y)', 0),
+  (lambda ctx,x,c: c*ctx.ln(x), 'exp($y/$c)', 1),
+  (lambda ctx,x,c: ctx.ln(x)/c, 'exp($c*$y)', 1),
+  (lambda ctx,x,c: c/ctx.ln(x), 'exp($c/$y)', 0),
+]
+
+def identify(ctx, x, constants=[], tol=None, maxcoeff=1000, full=False,
+    verbose=False):
+    r"""
+    Given a real number `x`, ``identify(x)`` attempts to find an exact
+    formula for `x`. This formula is returned as a string. If no match
+    is found, ``None`` is returned. With ``full=True``, a list of
+    matching formulas is returned.
+
+    As a simple example, :func:`~mpmath.identify` will find an algebraic
+    formula for the golden ratio::
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> identify(phi)
+        '((1+sqrt(5))/2)'
+
+    :func:`~mpmath.identify` can identify simple algebraic numbers and simple
+    combinations of given base constants, as well as certain basic
+    transformations thereof. More specifically, :func:`~mpmath.identify`
+    looks for the following:
+
+        1. Fractions
+        2. Quadratic algebraic numbers
+        3. Rational linear combinations of the base constants
+        4. Any of the above after first transforming `x` into `f(x)` where
+           `f(x)` is `1/x`, `\sqrt x`, `x^2`, `\log x` or `\exp x`, either
+           directly or with `x` or `f(x)` multiplied or divided by one of
+           the base constants
+        5. Products of fractional powers of the base constants and
+           small integers
+
+    Base constants can be given as a list of strings representing mpmath
+    expressions (:func:`~mpmath.identify` will ``eval`` the strings to numerical
+    values and use the original strings for the output), or as a dict of
+    formula:value pairs.
+
+    In order not to produce spurious results, :func:`~mpmath.identify` should
+    be used with high precision; preferably 50 digits or more.
+
+    **Examples**
+
+    Simple identifications can be performed safely at standard
+    precision. Here the default recognition of rational, algebraic,
+    and exp/log of algebraic numbers is demonstrated::
+
+        >>> mp.dps = 15
+        >>> identify(0.22222222222222222)
+        '(2/9)'
+        >>> identify(1.9662210973805663)
+        'sqrt(((24+sqrt(48))/8))'
+        >>> identify(4.1132503787829275)
+        'exp((sqrt(8)/2))'
+        >>> identify(0.881373587019543)
+        'log(((2+sqrt(8))/2))'
+
+    By default, :func:`~mpmath.identify` does not recognize `\pi`. At standard
+    precision it finds a not too useful approximation. At slightly
+    increased precision, this approximation is no longer accurate
+    enough and :func:`~mpmath.identify` more correctly returns ``None``::
+
+        >>> identify(pi)
+        '(2**(176/117)*3**(20/117)*5**(35/39))/(7**(92/117))'
+        >>> mp.dps = 30
+        >>> identify(pi)
+        >>>
+
+    Numbers such as `\pi`, and simple combinations of user-defined
+    constants, can be identified if they are provided explicitly::
+
+        >>> identify(3*pi-2*e, ['pi', 'e'])
+        '(3*pi + (-2)*e)'
+
+    Here is an example using a dict of constants. Note that the
+    constants need not be "atomic"; :func:`~mpmath.identify` can just
+    as well express the given number in terms of expressions
+    given by formulas::
+
+        >>> identify(pi+e, {'a':pi+2, 'b':2*e})
+        '((-2) + 1*a + (1/2)*b)'
+
+    Next, we attempt some identifications with a set of base constants.
+    It is necessary to increase the precision a bit.
+
+        >>> mp.dps = 50
+        >>> base = ['sqrt(2)','pi','log(2)']
+        >>> identify(0.25, base)
+        '(1/4)'
+        >>> identify(3*pi + 2*sqrt(2) + 5*log(2)/7, base)
+        '(2*sqrt(2) + 3*pi + (5/7)*log(2))'
+        >>> identify(exp(pi+2), base)
+        'exp((2 + 1*pi))'
+        >>> identify(1/(3+sqrt(2)), base)
+        '((3/7) + (-1/7)*sqrt(2))'
+        >>> identify(sqrt(2)/(3*pi+4), base)
+        'sqrt(2)/(4 + 3*pi)'
+        >>> identify(5**(mpf(1)/3)*pi*log(2)**2, base)
+        '5**(1/3)*pi*log(2)**2'
+
+    An example of an erroneous solution being found when too low
+    precision is used::
+
+        >>> mp.dps = 15
+        >>> identify(1/(3*pi-4*e+sqrt(8)), ['pi', 'e', 'sqrt(2)'])
+        '((11/25) + (-158/75)*pi + (76/75)*e + (44/15)*sqrt(2))'
+        >>> mp.dps = 50
+        >>> identify(1/(3*pi-4*e+sqrt(8)), ['pi', 'e', 'sqrt(2)'])
+        '1/(3*pi + (-4)*e + 2*sqrt(2))'
+
+    **Finding approximate solutions**
+
+    The tolerance ``tol`` defaults to 3/4 of the working precision.
+    Lowering the tolerance is useful for finding approximate matches.
+    We can for example try to generate approximations for pi::
+
+        >>> mp.dps = 15
+        >>> identify(pi, tol=1e-2)
+        '(22/7)'
+        >>> identify(pi, tol=1e-3)
+        '(355/113)'
+        >>> identify(pi, tol=1e-10)
+        '(5**(339/269))/(2**(64/269)*3**(13/269)*7**(92/269))'
+
+    With ``full=True``, and by supplying a few base constants,
+    ``identify`` can generate almost endless lists of approximations
+    for any number (the output below has been truncated to show only
+    the first few)::
+
+        >>> for p in identify(pi, ['e', 'catalan'], tol=1e-5, full=True):
+        ...     print(p)
+        ...  # doctest: +ELLIPSIS
+        e/log((6 + (-4/3)*e))
+        (3**3*5*e*catalan**2)/(2*7**2)
+        sqrt(((-13) + 1*e + 22*catalan))
+        log(((-6) + 24*e + 4*catalan)/e)
+        exp(catalan*((-1/5) + (8/15)*e))
+        catalan*(6 + (-6)*e + 15*catalan)
+        sqrt((5 + 26*e + (-3)*catalan))/e
+        e*sqrt(((-27) + 2*e + 25*catalan))
+        log(((-1) + (-11)*e + 59*catalan))
+        ((3/20) + (21/20)*e + (3/20)*catalan)
+        ...
+
+    The numerical values are roughly as close to `\pi` as permitted by the
+    specified tolerance:
+
+        >>> e/log(6-4*e/3)
+        3.14157719846001
+        >>> 135*e*catalan**2/98
+        3.14166950419369
+        >>> sqrt(e-13+22*catalan)
+        3.14158000062992
+        >>> log(24*e-6+4*catalan)-1
+        3.14158791577159
+
+    **Symbolic processing**
+
+    The output formula can be evaluated as a Python expression.
+    Note however that if fractions (like '2/3') are present in
+    the formula, Python's :func:`~mpmath.eval()` may erroneously perform
+    integer division. Note also that the output is not necessarily
+    in the algebraically simplest form::
+
+        >>> identify(sqrt(2))
+        '(sqrt(8)/2)'
+
+    As a solution to both problems, consider using SymPy's
+    :func:`~mpmath.sympify` to convert the formula into a symbolic expression.
+    SymPy can be used to pretty-print or further simplify the formula
+    symbolically::
+
+        >>> from sympy import sympify # doctest: +SKIP
+        >>> sympify(identify(sqrt(2))) # doctest: +SKIP
+        2**(1/2)
+
+    Sometimes :func:`~mpmath.identify` can simplify an expression further than
+    a symbolic algorithm::
+
+        >>> from sympy import simplify # doctest: +SKIP
+        >>> x = sympify('-1/(-3/2+(1/2)*5**(1/2))*(3/2-1/2*5**(1/2))**(1/2)') # doctest: +SKIP
+        >>> x # doctest: +SKIP
+        (3/2 - 5**(1/2)/2)**(-1/2)
+        >>> x = simplify(x) # doctest: +SKIP
+        >>> x # doctest: +SKIP
+        2/(6 - 2*5**(1/2))**(1/2)
+        >>> mp.dps = 30 # doctest: +SKIP
+        >>> x = sympify(identify(x.evalf(30))) # doctest: +SKIP
+        >>> x # doctest: +SKIP
+        1/2 + 5**(1/2)/2
+
+    (In fact, this functionality is available directly in SymPy as the
+    function :func:`~mpmath.nsimplify`, which is essentially a wrapper for
+    :func:`~mpmath.identify`.)
+
+    **Miscellaneous issues and limitations**
+
+    The input `x` must be a real number. All base constants must be
+    positive real numbers and must not be rationals or rational linear
+    combinations of each other.
+
+    The worst-case computation time grows quickly with the number of
+    base constants. Already with 3 or 4 base constants,
+    :func:`~mpmath.identify` may require several seconds to finish. To search
+    for relations among a large number of constants, you should
+    consider using :func:`~mpmath.pslq` directly.
+
+    The extended transformations are applied to x, not the constants
+    separately. As a result, ``identify`` will for example be able to
+    recognize ``exp(2*pi+3)`` with ``pi`` given as a base constant, but
+    not ``2*exp(pi)+3``. It will be able to recognize the latter if
+    ``exp(pi)`` is given explicitly as a base constant.
+
+    """
+
+    solutions = []
+
+    def addsolution(s):
+        if verbose: print("Found: ", s)
+        solutions.append(s)
+
+    x = ctx.mpf(x)
+
+    # Further along, x will be assumed positive
+    if x == 0:
+        if full: return ['0']
+        else:    return '0'
+    if x < 0:
+        sol = ctx.identify(-x, constants, tol, maxcoeff, full, verbose)
+        if sol is None:
+            return sol
+        if full:
+            return ["-(%s)"%s for s in sol]
+        else:
+            return "-(%s)" % sol
+
+    if tol:
+        tol = ctx.mpf(tol)
+    else:
+        tol = ctx.eps**0.7
+    M = maxcoeff
+
+    if constants:
+        if isinstance(constants, dict):
+            constants = [(ctx.mpf(v), name) for (name, v) in sorted(constants.items())]
+        else:
+            namespace = dict((name, getattr(ctx,name)) for name in dir(ctx))
+            constants = [(eval(p, namespace), p) for p in constants]
+    else:
+        constants = []
+
+    # We always want to find at least rational terms
+    if 1 not in [value for (name, value) in constants]:
+        constants = [(ctx.mpf(1), '1')] + constants
+
+    # PSLQ with simple algebraic and functional transformations
+    for ft, ftn, red in transforms:
+        for c, cn in constants:
+            if red and cn == '1':
+                continue
+            t = ft(ctx,x,c)
+            # Prevent exponential transforms from wreaking havoc
+            if abs(t) > M**2 or abs(t) < tol:
+                continue
+            # Linear combination of base constants
+            r = ctx.pslq([t] + [a[0] for a in constants], tol, M)
+            s = None
+            if r is not None and max(abs(uw) for uw in r) <= M and r[0]:
+                s = pslqstring(r, constants)
+            # Quadratic algebraic numbers
+            else:
+                q = ctx.pslq([ctx.one, t, t**2], tol, M)
+                if q is not None and len(q) == 3 and q[2]:
+                    aa, bb, cc = q
+                    if max(abs(aa),abs(bb),abs(cc)) <= M:
+                        s = quadraticstring(ctx,t,aa,bb,cc)
+            if s:
+                if cn == '1' and ('/$c' in ftn):
+                    s = ftn.replace('$y', s).replace('/$c', '')
+                else:
+                    s = ftn.replace('$y', s).replace('$c', cn)
+                addsolution(s)
+                if not full: return solutions[0]
+
+            if verbose:
+                print(".")
+
+    # Check for a direct multiplicative formula
+    if x != 1:
+        # Allow fractional powers of fractions
+        ilogs = [2,3,5,7]
+        # Watch out for existing fractional powers of fractions
+        logs = []
+        for a, s in constants:
+            if not sum(bool(ctx.findpoly(ctx.ln(a)/ctx.ln(i),1)) for i in ilogs):
+                logs.append((ctx.ln(a), s))
+        logs = [(ctx.ln(i),str(i)) for i in ilogs] + logs
+        r = ctx.pslq([ctx.ln(x)] + [a[0] for a in logs], tol, M)
+        if r is not None and max(abs(uw) for uw in r) <= M and r[0]:
+            addsolution(prodstring(r, logs))
+            if not full: return solutions[0]
+
+    if full:
+        return sorted(solutions, key=len)
+    else:
+        return None
+
+IdentificationMethods.pslq = pslq
+IdentificationMethods.findpoly = findpoly
+IdentificationMethods.identify = identify
+
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()

llmeval-env/lib/python3.10/site-packages/mpmath/math2.py

@@ -0,0 +1,672 @@
+"""
+This module complements the math and cmath builtin modules by providing
+fast machine precision versions of some additional functions (gamma, ...)
+and wrapping math/cmath functions so that they can be called with either
+real or complex arguments.
+"""
+
+import operator
+import math
+import cmath
+
+# Irrational (?) constants
+pi = 3.1415926535897932385
+e = 2.7182818284590452354
+sqrt2 = 1.4142135623730950488
+sqrt5 = 2.2360679774997896964
+phi = 1.6180339887498948482
+ln2 = 0.69314718055994530942
+ln10 = 2.302585092994045684
+euler = 0.57721566490153286061
+catalan = 0.91596559417721901505
+khinchin = 2.6854520010653064453
+apery = 1.2020569031595942854
+
+logpi = 1.1447298858494001741
+
+def _mathfun_real(f_real, f_complex):
+    def f(x, **kwargs):
+        if type(x) is float:
+            return f_real(x)
+        if type(x) is complex:
+            return f_complex(x)
+        try:
+            x = float(x)
+            return f_real(x)
+        except (TypeError, ValueError):
+            x = complex(x)
+            return f_complex(x)
+    f.__name__ = f_real.__name__
+    return f
+
+def _mathfun(f_real, f_complex):
+    def f(x, **kwargs):
+        if type(x) is complex:
+            return f_complex(x)
+        try:
+            return f_real(float(x))
+        except (TypeError, ValueError):
+            return f_complex(complex(x))
+    f.__name__ = f_real.__name__
+    return f
+
+def _mathfun_n(f_real, f_complex):
+    def f(*args, **kwargs):
+        try:
+            return f_real(*(float(x) for x in args))
+        except (TypeError, ValueError):
+            return f_complex(*(complex(x) for x in args))
+    f.__name__ = f_real.__name__
+    return f
+
+# Workaround for non-raising log and sqrt in Python 2.5 and 2.4
+# on Unix system
+try:
+    math.log(-2.0)
+    def math_log(x):
+        if x <= 0.0:
+            raise ValueError("math domain error")
+        return math.log(x)
+    def math_sqrt(x):
+        if x < 0.0:
+            raise ValueError("math domain error")
+        return math.sqrt(x)
+except (ValueError, TypeError):
+    math_log = math.log
+    math_sqrt = math.sqrt
+
+pow = _mathfun_n(operator.pow, lambda x, y: complex(x)**y)
+log = _mathfun_n(math_log, cmath.log)
+sqrt = _mathfun(math_sqrt, cmath.sqrt)
+exp = _mathfun_real(math.exp, cmath.exp)
+
+cos = _mathfun_real(math.cos, cmath.cos)
+sin = _mathfun_real(math.sin, cmath.sin)
+tan = _mathfun_real(math.tan, cmath.tan)
+
+acos = _mathfun(math.acos, cmath.acos)
+asin = _mathfun(math.asin, cmath.asin)
+atan = _mathfun_real(math.atan, cmath.atan)
+
+cosh = _mathfun_real(math.cosh, cmath.cosh)
+sinh = _mathfun_real(math.sinh, cmath.sinh)
+tanh = _mathfun_real(math.tanh, cmath.tanh)
+
+floor = _mathfun_real(math.floor,
+    lambda z: complex(math.floor(z.real), math.floor(z.imag)))
+ceil = _mathfun_real(math.ceil,
+    lambda z: complex(math.ceil(z.real), math.ceil(z.imag)))
+
+
+cos_sin = _mathfun_real(lambda x: (math.cos(x), math.sin(x)),
+                        lambda z: (cmath.cos(z), cmath.sin(z)))
+
+cbrt = _mathfun(lambda x: x**(1./3), lambda z: z**(1./3))
+
+def nthroot(x, n):
+    r = 1./n
+    try:
+        return float(x) ** r
+    except (ValueError, TypeError):
+        return complex(x) ** r
+
+def _sinpi_real(x):
+    if x < 0:
+        return -_sinpi_real(-x)
+    n, r = divmod(x, 0.5)
+    r *= pi
+    n %= 4
+    if n == 0: return math.sin(r)
+    if n == 1: return math.cos(r)
+    if n == 2: return -math.sin(r)
+    if n == 3: return -math.cos(r)
+
+def _cospi_real(x):
+    if x < 0:
+        x = -x
+    n, r = divmod(x, 0.5)
+    r *= pi
+    n %= 4
+    if n == 0: return math.cos(r)
+    if n == 1: return -math.sin(r)
+    if n == 2: return -math.cos(r)
+    if n == 3: return math.sin(r)
+
+def _sinpi_complex(z):
+    if z.real < 0:
+        return -_sinpi_complex(-z)
+    n, r = divmod(z.real, 0.5)
+    z = pi*complex(r, z.imag)
+    n %= 4
+    if n == 0: return cmath.sin(z)
+    if n == 1: return cmath.cos(z)
+    if n == 2: return -cmath.sin(z)
+    if n == 3: return -cmath.cos(z)
+
+def _cospi_complex(z):
+    if z.real < 0:
+        z = -z
+    n, r = divmod(z.real, 0.5)
+    z = pi*complex(r, z.imag)
+    n %= 4
+    if n == 0: return cmath.cos(z)
+    if n == 1: return -cmath.sin(z)
+    if n == 2: return -cmath.cos(z)
+    if n == 3: return cmath.sin(z)
+
+cospi = _mathfun_real(_cospi_real, _cospi_complex)
+sinpi = _mathfun_real(_sinpi_real, _sinpi_complex)
+
+def tanpi(x):
+    try:
+        return sinpi(x) / cospi(x)
+    except OverflowError:
+        if complex(x).imag > 10:
+            return 1j
+        if complex(x).imag < 10:
+            return -1j
+        raise
+
+def cotpi(x):
+    try:
+        return cospi(x) / sinpi(x)
+    except OverflowError:
+        if complex(x).imag > 10:
+            return -1j
+        if complex(x).imag < 10:
+            return 1j
+        raise
+
+INF = 1e300*1e300
+NINF = -INF
+NAN = INF-INF
+EPS = 2.2204460492503131e-16
+
+_exact_gamma = (INF, 1.0, 1.0, 2.0, 6.0, 24.0, 120.0, 720.0, 5040.0, 40320.0,
+  362880.0, 3628800.0, 39916800.0, 479001600.0, 6227020800.0, 87178291200.0,
+  1307674368000.0, 20922789888000.0, 355687428096000.0, 6402373705728000.0,
+  121645100408832000.0, 2432902008176640000.0)
+
+_max_exact_gamma = len(_exact_gamma)-1
+
+# Lanczos coefficients used by the GNU Scientific Library
+_lanczos_g = 7
+_lanczos_p = (0.99999999999980993, 676.5203681218851, -1259.1392167224028,
+     771.32342877765313, -176.61502916214059, 12.507343278686905,
+     -0.13857109526572012, 9.9843695780195716e-6, 1.5056327351493116e-7)
+
+def _gamma_real(x):
+    _intx = int(x)
+    if _intx == x:
+        if _intx <= 0:
+            #return (-1)**_intx * INF
+            raise ZeroDivisionError("gamma function pole")
+        if _intx <= _max_exact_gamma:
+            return _exact_gamma[_intx]
+    if x < 0.5:
+        # TODO: sinpi
+        return pi / (_sinpi_real(x)*_gamma_real(1-x))
+    else:
+        x -= 1.0
+        r = _lanczos_p[0]
+        for i in range(1, _lanczos_g+2):
+            r += _lanczos_p[i]/(x+i)
+        t = x + _lanczos_g + 0.5
+        return 2.506628274631000502417 * t**(x+0.5) * math.exp(-t) * r
+
+def _gamma_complex(x):
+    if not x.imag:
+        return complex(_gamma_real(x.real))
+    if x.real < 0.5:
+        # TODO: sinpi
+        return pi / (_sinpi_complex(x)*_gamma_complex(1-x))
+    else:
+        x -= 1.0
+        r = _lanczos_p[0]
+        for i in range(1, _lanczos_g+2):
+            r += _lanczos_p[i]/(x+i)
+        t = x + _lanczos_g + 0.5
+        return 2.506628274631000502417 * t**(x+0.5) * cmath.exp(-t) * r
+
+gamma = _mathfun_real(_gamma_real, _gamma_complex)
+
+def rgamma(x):
+    try:
+        return 1./gamma(x)
+    except ZeroDivisionError:
+        return x*0.0
+
+def factorial(x):
+    return gamma(x+1.0)
+
+def arg(x):
+    if type(x) is float:
+        return math.atan2(0.0,x)
+    return math.atan2(x.imag,x.real)
+
+# XXX: broken for negatives
+def loggamma(x):
+    if type(x) not in (float, complex):
+        try:
+            x = float(x)
+        except (ValueError, TypeError):
+            x = complex(x)
+    try:
+        xreal = x.real
+        ximag = x.imag
+    except AttributeError:   # py2.5
+        xreal = x
+        ximag = 0.0
+    # Reflection formula
+    # http://functions.wolfram.com/GammaBetaErf/LogGamma/16/01/01/0003/
+    if xreal < 0.0:
+        if abs(x) < 0.5:
+            v = log(gamma(x))
+            if ximag == 0:
+                v = v.conjugate()
+            return v
+        z = 1-x
+        try:
+            re = z.real
+            im = z.imag
+        except AttributeError:   # py2.5
+            re = z
+            im = 0.0
+        refloor = floor(re)
+        if im == 0.0:
+            imsign = 0
+        elif im < 0.0:
+            imsign = -1
+        else:
+            imsign = 1
+        return (-pi*1j)*abs(refloor)*(1-abs(imsign)) + logpi - \
+            log(sinpi(z-refloor)) - loggamma(z) + 1j*pi*refloor*imsign
+    if x == 1.0 or x == 2.0:
+        return x*0
+    p = 0.
+    while abs(x) < 11:
+        p -= log(x)
+        x += 1.0
+    s = 0.918938533204672742 + (x-0.5)*log(x) - x
+    r = 1./x
+    r2 = r*r
+    s += 0.083333333333333333333*r; r *= r2
+    s += -0.0027777777777777777778*r; r *= r2
+    s += 0.00079365079365079365079*r; r *= r2
+    s += -0.0005952380952380952381*r; r *= r2
+    s += 0.00084175084175084175084*r; r *= r2
+    s += -0.0019175269175269175269*r; r *= r2
+    s += 0.0064102564102564102564*r; r *= r2
+    s += -0.02955065359477124183*r
+    return s + p
+
+_psi_coeff = [
+0.083333333333333333333,
+-0.0083333333333333333333,
+0.003968253968253968254,
+-0.0041666666666666666667,
+0.0075757575757575757576,
+-0.021092796092796092796,
+0.083333333333333333333,
+-0.44325980392156862745,
+3.0539543302701197438,
+-26.456212121212121212]
+
+def _digamma_real(x):
+    _intx = int(x)
+    if _intx == x:
+        if _intx <= 0:
+            raise ZeroDivisionError("polygamma pole")
+    if x < 0.5:
+        x = 1.0-x
+        s = pi*cotpi(x)
+    else:
+        s = 0.0
+    while x < 10.0:
+        s -= 1.0/x
+        x += 1.0
+    x2 = x**-2
+    t = x2
+    for c in _psi_coeff:
+        s -= c*t
+        if t < 1e-20:
+            break
+        t *= x2
+    return s + math_log(x) - 0.5/x
+
+def _digamma_complex(x):
+    if not x.imag:
+        return complex(_digamma_real(x.real))
+    if x.real < 0.5:
+        x = 1.0-x
+        s = pi*cotpi(x)
+    else:
+        s = 0.0
+    while abs(x) < 10.0:
+        s -= 1.0/x
+        x += 1.0
+    x2 = x**-2
+    t = x2
+    for c in _psi_coeff:
+        s -= c*t
+        if abs(t) < 1e-20:
+            break
+        t *= x2
+    return s + cmath.log(x) - 0.5/x
+
+digamma = _mathfun_real(_digamma_real, _digamma_complex)
+
+# TODO: could implement complex erf and erfc here. Need
+# to find an accurate method (avoiding cancellation)
+# for approx. 1 < abs(x) < 9.
+
+_erfc_coeff_P = [
+    1.0000000161203922312,
+    2.1275306946297962644,
+    2.2280433377390253297,
+    1.4695509105618423961,
+    0.66275911699770787537,
+    0.20924776504163751585,
+    0.045459713768411264339,
+    0.0063065951710717791934,
+    0.00044560259661560421715][::-1]
+
+_erfc_coeff_Q = [
+    1.0000000000000000000,
+    3.2559100272784894318,
+    4.9019435608903239131,
+    4.4971472894498014205,
+    2.7845640601891186528,
+    1.2146026030046904138,
+    0.37647108453729465912,
+    0.080970149639040548613,
+    0.011178148899483545902,
+    0.00078981003831980423513][::-1]
+
+def _polyval(coeffs, x):
+    p = coeffs[0]
+    for c in coeffs[1:]:
+        p = c + x*p
+    return p
+
+def _erf_taylor(x):
+    # Taylor series assuming 0 <= x <= 1
+    x2 = x*x
+    s = t = x
+    n = 1
+    while abs(t) > 1e-17:
+        t *= x2/n
+        s -= t/(n+n+1)
+        n += 1
+        t *= x2/n
+        s += t/(n+n+1)
+        n += 1
+    return 1.1283791670955125739*s
+
+def _erfc_mid(x):
+    # Rational approximation assuming 0 <= x <= 9
+    return exp(-x*x)*_polyval(_erfc_coeff_P,x)/_polyval(_erfc_coeff_Q,x)
+
+def _erfc_asymp(x):
+    # Asymptotic expansion assuming x >= 9
+    x2 = x*x
+    v = exp(-x2)/x*0.56418958354775628695
+    r = t = 0.5 / x2
+    s = 1.0
+    for n in range(1,22,4):
+        s -= t
+        t *= r * (n+2)
+        s += t
+        t *= r * (n+4)
+        if abs(t) < 1e-17:
+            break
+    return s * v
+
+def erf(x):
+    """
+    erf of a real number.
+    """
+    x = float(x)
+    if x != x:
+        return x
+    if x < 0.0:
+        return -erf(-x)
+    if x >= 1.0:
+        if x >= 6.0:
+            return 1.0
+        return 1.0 - _erfc_mid(x)
+    return _erf_taylor(x)
+
+def erfc(x):
+    """
+    erfc of a real number.
+    """
+    x = float(x)
+    if x != x:
+        return x
+    if x < 0.0:
+        if x < -6.0:
+            return 2.0
+        return 2.0-erfc(-x)
+    if x > 9.0:
+        return _erfc_asymp(x)
+    if x >= 1.0:
+        return _erfc_mid(x)
+    return 1.0 - _erf_taylor(x)
+
+gauss42 = [\
+(0.99839961899006235, 0.0041059986046490839),
+(-0.99839961899006235, 0.0041059986046490839),
+(0.9915772883408609, 0.009536220301748501),
+(-0.9915772883408609,0.009536220301748501),
+(0.97934250806374812, 0.014922443697357493),
+(-0.97934250806374812, 0.014922443697357493),
+(0.96175936533820439,0.020227869569052644),
+(-0.96175936533820439, 0.020227869569052644),
+(0.93892355735498811, 0.025422959526113047),
+(-0.93892355735498811,0.025422959526113047),
+(0.91095972490412735, 0.030479240699603467),
+(-0.91095972490412735, 0.030479240699603467),
+(0.87802056981217269,0.03536907109759211),
+(-0.87802056981217269, 0.03536907109759211),
+(0.8402859832618168, 0.040065735180692258),
+(-0.8402859832618168,0.040065735180692258),
+(0.7979620532554873, 0.044543577771965874),
+(-0.7979620532554873, 0.044543577771965874),
+(0.75127993568948048,0.048778140792803244),
+(-0.75127993568948048, 0.048778140792803244),
+(0.70049459055617114, 0.052746295699174064),
+(-0.70049459055617114,0.052746295699174064),
+(0.64588338886924779, 0.056426369358018376),
+(-0.64588338886924779, 0.056426369358018376),
+(0.58774459748510932, 0.059798262227586649),
+(-0.58774459748510932, 0.059798262227586649),
+(0.5263957499311922, 0.062843558045002565),
+(-0.5263957499311922, 0.062843558045002565),
+(0.46217191207042191, 0.065545624364908975),
+(-0.46217191207042191, 0.065545624364908975),
+(0.39542385204297503, 0.067889703376521934),
+(-0.39542385204297503, 0.067889703376521934),
+(0.32651612446541151, 0.069862992492594159),
+(-0.32651612446541151, 0.069862992492594159),
+(0.25582507934287907, 0.071454714265170971),
+(-0.25582507934287907, 0.071454714265170971),
+(0.18373680656485453, 0.072656175243804091),
+(-0.18373680656485453, 0.072656175243804091),
+(0.11064502720851986, 0.073460813453467527),
+(-0.11064502720851986, 0.073460813453467527),
+(0.036948943165351772, 0.073864234232172879),
+(-0.036948943165351772, 0.073864234232172879)]
+
+EI_ASYMP_CONVERGENCE_RADIUS = 40.0
+
+def ei_asymp(z, _e1=False):
+    r = 1./z
+    s = t = 1.0
+    k = 1
+    while 1:
+        t *= k*r
+        s += t
+        if abs(t) < 1e-16:
+            break
+        k += 1
+    v = s*exp(z)/z
+    if _e1:
+        if type(z) is complex:
+            zreal = z.real
+            zimag = z.imag
+        else:
+            zreal = z
+            zimag = 0.0
+        if zimag == 0.0 and zreal > 0.0:
+            v += pi*1j
+    else:
+        if type(z) is complex:
+            if z.imag > 0:
+                v += pi*1j
+            if z.imag < 0:
+                v -= pi*1j
+    return v
+
+def ei_taylor(z, _e1=False):
+    s = t = z
+    k = 2
+    while 1:
+        t = t*z/k
+        term = t/k
+        if abs(term) < 1e-17:
+            break
+        s += term
+        k += 1
+    s += euler
+    if _e1:
+        s += log(-z)
+    else:
+        if type(z) is float or z.imag == 0.0:
+            s += math_log(abs(z))
+        else:
+            s += cmath.log(z)
+    return s
+
+def ei(z, _e1=False):
+    typez = type(z)
+    if typez not in (float, complex):
+        try:
+            z = float(z)
+            typez = float
+        except (TypeError, ValueError):
+            z = complex(z)
+            typez = complex
+    if not z:
+        return -INF
+    absz = abs(z)
+    if absz > EI_ASYMP_CONVERGENCE_RADIUS:
+        return ei_asymp(z, _e1)
+    elif absz <= 2.0 or (typez is float and z > 0.0):
+        return ei_taylor(z, _e1)
+    # Integrate, starting from whichever is smaller of a Taylor
+    # series value or an asymptotic series value
+    if typez is complex and z.real > 0.0:
+        zref = z / absz
+        ref = ei_taylor(zref, _e1)
+    else:
+        zref = EI_ASYMP_CONVERGENCE_RADIUS * z / absz
+        ref = ei_asymp(zref, _e1)
+    C = (zref-z)*0.5
+    D = (zref+z)*0.5
+    s = 0.0
+    if type(z) is complex:
+        _exp = cmath.exp
+    else:
+        _exp = math.exp
+    for x,w in gauss42:
+        t = C*x+D
+        s += w*_exp(t)/t
+    ref -= C*s
+    return ref
+
+def e1(z):
+    # hack to get consistent signs if the imaginary part if 0
+    # and signed
+    typez = type(z)
+    if type(z) not in (float, complex):
+        try:
+            z = float(z)
+            typez = float
+        except (TypeError, ValueError):
+            z = complex(z)
+            typez = complex
+    if typez is complex and not z.imag:
+        z = complex(z.real, 0.0)
+    # end hack
+    return -ei(-z, _e1=True)
+
+_zeta_int = [\
+-0.5,
+0.0,
+1.6449340668482264365,1.2020569031595942854,1.0823232337111381915,
+1.0369277551433699263,1.0173430619844491397,1.0083492773819228268,
+1.0040773561979443394,1.0020083928260822144,1.0009945751278180853,
+1.0004941886041194646,1.0002460865533080483,1.0001227133475784891,
+1.0000612481350587048,1.0000305882363070205,1.0000152822594086519,
+1.0000076371976378998,1.0000038172932649998,1.0000019082127165539,
+1.0000009539620338728,1.0000004769329867878,1.0000002384505027277,
+1.0000001192199259653,1.0000000596081890513,1.0000000298035035147,
+1.0000000149015548284]
+
+_zeta_P = [-3.50000000087575873, -0.701274355654678147,
+-0.0672313458590012612, -0.00398731457954257841,
+-0.000160948723019303141, -4.67633010038383371e-6,
+-1.02078104417700585e-7, -1.68030037095896287e-9,
+-1.85231868742346722e-11][::-1]
+
+_zeta_Q = [1.00000000000000000, -0.936552848762465319,
+-0.0588835413263763741, -0.00441498861482948666,
+-0.000143416758067432622, -5.10691659585090782e-6,
+-9.58813053268913799e-8, -1.72963791443181972e-9,
+-1.83527919681474132e-11][::-1]
+
+_zeta_1 = [3.03768838606128127e-10, -1.21924525236601262e-8,
+2.01201845887608893e-7, -1.53917240683468381e-6,
+-5.09890411005967954e-7, 0.000122464707271619326,
+-0.000905721539353130232, -0.00239315326074843037,
+0.084239750013159168, 0.418938517907442414, 0.500000001921884009]
+
+_zeta_0 = [-3.46092485016748794e-10, -6.42610089468292485e-9,
+1.76409071536679773e-7, -1.47141263991560698e-6, -6.38880222546167613e-7,
+0.000122641099800668209, -0.000905894913516772796, -0.00239303348507992713,
+0.0842396947501199816, 0.418938533204660256, 0.500000000000000052]
+
+def zeta(s):
+    """
+    Riemann zeta function, real argument
+    """
+    if not isinstance(s, (float, int)):
+        try:
+            s = float(s)
+        except (ValueError, TypeError):
+            try:
+                s = complex(s)
+                if not s.imag:
+                    return complex(zeta(s.real))
+            except (ValueError, TypeError):
+                pass
+            raise NotImplementedError
+    if s == 1:
+        raise ValueError("zeta(1) pole")
+    if s >= 27:
+        return 1.0 + 2.0**(-s) + 3.0**(-s)
+    n = int(s)
+    if n == s:
+        if n >= 0:
+            return _zeta_int[n]
+        if not (n % 2):
+            return 0.0
+    if s <= 0.0:
+        return 2.**s*pi**(s-1)*_sinpi_real(0.5*s)*_gamma_real(1-s)*zeta(1-s)
+    if s <= 2.0:
+        if s <= 1.0:
+            return _polyval(_zeta_0,s)/(s-1)
+        return _polyval(_zeta_1,s)/(s-1)
+    z = _polyval(_zeta_P,s) / _polyval(_zeta_Q,s)
+    return 1.0 + 2.0**(-s) + 3.0**(-s) + 4.0**(-s)*z

llmeval-env/lib/python3.10/site-packages/mpmath/rational.py

@@ -0,0 +1,240 @@
+import operator
+import sys
+from .libmp import int_types, mpf_hash, bitcount, from_man_exp, HASH_MODULUS
+
+new = object.__new__
+
+def create_reduced(p, q, _cache={}):
+    key = p, q
+    if key in _cache:
+        return _cache[key]
+    x, y = p, q
+    while y:
+        x, y = y, x % y
+    if x != 1:
+        p //= x
+        q //= x
+    v = new(mpq)
+    v._mpq_ = p, q
+    # Speedup integers, half-integers and other small fractions
+    if q <= 4 and abs(key[0]) < 100:
+        _cache[key] = v
+    return v
+
+class mpq(object):
+    """
+    Exact rational type, currently only intended for internal use.
+    """
+
+    __slots__ = ["_mpq_"]
+
+    def __new__(cls, p, q=1):
+        if type(p) is tuple:
+            p, q = p
+        elif hasattr(p, '_mpq_'):
+            p, q = p._mpq_
+        return create_reduced(p, q)
+
+    def __repr__(s):
+        return "mpq(%s,%s)" % s._mpq_
+
+    def __str__(s):
+        return "(%s/%s)" % s._mpq_
+
+    def __int__(s):
+        a, b = s._mpq_
+        return a // b
+
+    def __nonzero__(s):
+        return bool(s._mpq_[0])
+
+    __bool__ = __nonzero__
+
+    def __hash__(s):
+        a, b = s._mpq_
+        if sys.version_info >= (3, 2):
+            inverse = pow(b, HASH_MODULUS-2, HASH_MODULUS)
+            if not inverse:
+                h = sys.hash_info.inf
+            else:
+                h = (abs(a) * inverse) % HASH_MODULUS
+            if a < 0: h = -h
+            if h == -1: h = -2
+            return h
+        else:
+            if b == 1:
+                return hash(a)
+            # Power of two: mpf compatible hash
+            if not (b & (b-1)):
+                return mpf_hash(from_man_exp(a, 1-bitcount(b)))
+            return hash((a,b))
+
+    def __eq__(s, t):
+        ttype = type(t)
+        if ttype is mpq:
+            return s._mpq_ == t._mpq_
+        if ttype in int_types:
+            a, b = s._mpq_
+            if b != 1:
+                return False
+            return a == t
+        return NotImplemented
+
+    def __ne__(s, t):
+        ttype = type(t)
+        if ttype is mpq:
+            return s._mpq_ != t._mpq_
+        if ttype in int_types:
+            a, b = s._mpq_
+            if b != 1:
+                return True
+            return a != t
+        return NotImplemented
+
+    def _cmp(s, t, op):
+        ttype = type(t)
+        if ttype in int_types:
+            a, b = s._mpq_
+            return op(a, t*b)
+        if ttype is mpq:
+            a, b = s._mpq_
+            c, d = t._mpq_
+            return op(a*d, b*c)
+        return NotImplementedError
+
+    def __lt__(s, t): return s._cmp(t, operator.lt)
+    def __le__(s, t): return s._cmp(t, operator.le)
+    def __gt__(s, t): return s._cmp(t, operator.gt)
+    def __ge__(s, t): return s._cmp(t, operator.ge)
+
+    def __abs__(s):
+        a, b = s._mpq_
+        if a >= 0:
+            return s
+        v = new(mpq)
+        v._mpq_ = -a, b
+        return v
+
+    def __neg__(s):
+        a, b = s._mpq_
+        v = new(mpq)
+        v._mpq_ = -a, b
+        return v
+
+    def __pos__(s):
+        return s
+
+    def __add__(s, t):
+        ttype = type(t)
+        if ttype is mpq:
+            a, b = s._mpq_
+            c, d = t._mpq_
+            return create_reduced(a*d+b*c, b*d)
+        if ttype in int_types:
+            a, b = s._mpq_
+            v = new(mpq)
+            v._mpq_ = a+b*t, b
+            return v
+        return NotImplemented
+
+    __radd__ = __add__
+
+    def __sub__(s, t):
+        ttype = type(t)
+        if ttype is mpq:
+            a, b = s._mpq_
+            c, d = t._mpq_
+            return create_reduced(a*d-b*c, b*d)
+        if ttype in int_types:
+            a, b = s._mpq_
+            v = new(mpq)
+            v._mpq_ = a-b*t, b
+            return v
+        return NotImplemented
+
+    def __rsub__(s, t):
+        ttype = type(t)
+        if ttype is mpq:
+            a, b = s._mpq_
+            c, d = t._mpq_
+            return create_reduced(b*c-a*d, b*d)
+        if ttype in int_types:
+            a, b = s._mpq_
+            v = new(mpq)
+            v._mpq_ = b*t-a, b
+            return v
+        return NotImplemented
+
+    def __mul__(s, t):
+        ttype = type(t)
+        if ttype is mpq:
+            a, b = s._mpq_
+            c, d = t._mpq_
+            return create_reduced(a*c, b*d)
+        if ttype in int_types:
+            a, b = s._mpq_
+            return create_reduced(a*t, b)
+        return NotImplemented
+
+    __rmul__ = __mul__
+
+    def __div__(s, t):
+        ttype = type(t)
+        if ttype is mpq:
+            a, b = s._mpq_
+            c, d = t._mpq_
+            return create_reduced(a*d, b*c)
+        if ttype in int_types:
+            a, b = s._mpq_
+            return create_reduced(a, b*t)
+        return NotImplemented
+
+    def __rdiv__(s, t):
+        ttype = type(t)
+        if ttype is mpq:
+            a, b = s._mpq_
+            c, d = t._mpq_
+            return create_reduced(b*c, a*d)
+        if ttype in int_types:
+            a, b = s._mpq_
+            return create_reduced(b*t, a)
+        return NotImplemented
+
+    def __pow__(s, t):
+        ttype = type(t)
+        if ttype in int_types:
+            a, b = s._mpq_
+            if t:
+                if t < 0:
+                    a, b, t = b, a, -t
+                v = new(mpq)
+                v._mpq_ = a**t, b**t
+                return v
+            raise ZeroDivisionError
+        return NotImplemented
+
+
+mpq_1 = mpq((1,1))
+mpq_0 = mpq((0,1))
+mpq_1_2 = mpq((1,2))
+mpq_3_2 = mpq((3,2))
+mpq_1_4 = mpq((1,4))
+mpq_1_16 = mpq((1,16))
+mpq_3_16 = mpq((3,16))
+mpq_5_2 = mpq((5,2))
+mpq_3_4 = mpq((3,4))
+mpq_7_4 = mpq((7,4))
+mpq_5_4 = mpq((5,4))
+
+
+# Register with "numbers" ABC
+#     We do not subclass, hence we do not use the @abstractmethod checks. While
+#     this is less invasive it may turn out that we do not actually support
+#     parts of the expected interfaces.  See
+#     http://docs.python.org/2/library/numbers.html for list of abstract
+#     methods.
+try:
+    import numbers
+    numbers.Rational.register(mpq)
+except ImportError:
+    pass

llmeval-env/lib/python3.10/site-packages/mpmath/tests/extratest_gamma.py

@@ -0,0 +1,215 @@
+from mpmath import *
+from mpmath.libmp import ifac
+
+import sys
+if "-dps" in sys.argv:
+    maxdps = int(sys.argv[sys.argv.index("-dps")+1])
+else:
+    maxdps = 1000
+
+raise_ = "-raise" in sys.argv
+
+errcount = 0
+
+def check(name, func, z, y):
+    global errcount
+    try:
+        x = func(z)
+    except:
+        errcount += 1
+        if raise_:
+            raise
+        print()
+        print(name)
+        print("EXCEPTION")
+        import traceback
+        traceback.print_tb(sys.exc_info()[2])
+        print()
+        return
+    xre = x.real
+    xim = x.imag
+    yre = y.real
+    yim = y.imag
+    tol = eps*8
+    err = 0
+    if abs(xre-yre) > abs(yre)*tol:
+        err = 1
+        print()
+        print("Error! %s (re = %s, wanted %s, err=%s)" % (name, nstr(xre,10), nstr(yre,10), nstr(abs(xre-yre))))
+        errcount += 1
+        if raise_:
+            raise SystemExit
+    if abs(xim-yim) > abs(yim)*tol:
+        err = 1
+        print()
+        print("Error! %s (im = %s, wanted %s, err=%s)" % (name, nstr(xim,10), nstr(yim,10), nstr(abs(xim-yim))))
+        errcount += 1
+        if raise_:
+            raise SystemExit
+    if not err:
+        sys.stdout.write("%s ok; " % name)
+
+def testcase(case):
+    z, result = case
+    print("Testing z =", z)
+    mp.dps = 1010
+    z = eval(z)
+    mp.dps = maxdps + 50
+    if result is None:
+        gamma_val = gamma(z)
+        loggamma_val = loggamma(z)
+        factorial_val = factorial(z)
+        rgamma_val = rgamma(z)
+    else:
+        loggamma_val = eval(result)
+        gamma_val = exp(loggamma_val)
+        factorial_val = z * gamma_val
+        rgamma_val = 1/gamma_val
+    for dps in [5, 10, 15, 25, 40, 60, 90, 120, 250, 600, 1000, 1800, 3600]:
+        if dps > maxdps:
+            break
+        mp.dps = dps
+        print("dps = %s" % dps)
+        check("gamma", gamma, z, gamma_val)
+        check("rgamma", rgamma, z, rgamma_val)
+        check("loggamma", loggamma, z, loggamma_val)
+        check("factorial", factorial, z, factorial_val)
+        print()
+        mp.dps = 15
+
+testcases = []
+
+# Basic values
+for n in list(range(1,200)) + list(range(201,2000,17)):
+    testcases.append(["%s" % n, None])
+for n in range(-200,200):
+    testcases.append(["%s+0.5" % n, None])
+    testcases.append(["%s+0.37" % n, None])
+
+testcases += [\
+["(0.1+1j)", None],
+["(-0.1+1j)", None],
+["(0.1-1j)", None],
+["(-0.1-1j)", None],
+["10j", None],
+["-10j", None],
+["100j", None],
+["10000j", None],
+["-10000000j", None],
+["(10**100)*j", None],
+["125+(10**100)*j", None],
+["-125+(10**100)*j", None],
+["(10**10)*(1+j)", None],
+["(10**10)*(-1+j)", None],
+["(10**100)*(1+j)", None],
+["(10**100)*(-1+j)", None],
+["(1.5-1j)", None],
+["(6+4j)", None],
+["(4+1j)", None],
+["(3.5+2j)", None],
+["(1.5-1j)", None],
+["(-6-4j)", None],
+["(-2-3j)", None],
+["(-2.5-2j)", None],
+["(4+1j)", None],
+["(3+3j)", None],
+["(2-2j)", None],
+["1", "0"],
+["2", "0"],
+["3", "log(2)"],
+["4", "log(6)"],
+["5", "log(24)"],
+["0.5", "log(pi)/2"],
+["1.5", "log(sqrt(pi)/2)"],
+["2.5", "log(3*sqrt(pi)/4)"],
+["mpf('0.37')", None],
+["0.25", "log(sqrt(2*sqrt(2*pi**3)/agm(1,sqrt(2))))"],
+["-0.4", None],
+["mpf('-1.9')", None],
+["mpf('12.8')", None],
+["mpf('33.7')", None],
+["mpf('95.2')", None],
+["mpf('160.3')", None],
+["mpf('2057.8')", None],
+["25", "log(ifac(24))"],
+["80", "log(ifac(79))"],
+["500", "log(ifac(500-1))"],
+["8000", "log(ifac(8000-1))"],
+["8000.5", None],
+["mpf('8000.1')", None],
+["mpf('1.37e10')", None],
+["mpf('1.37e10')*(1+j)", None],
+["mpf('1.37e10')*(-1+j)", None],
+["mpf('1.37e10')*(-1-j)", None],
+["mpf('1.37e10')*(-1+j)", None],
+["mpf('1.37e100')", None],
+["mpf('1.37e100')*(1+j)", None],
+["mpf('1.37e100')*(-1+j)", None],
+["mpf('1.37e100')*(-1-j)", None],
+["mpf('1.37e100')*(-1+j)", None],
+["3+4j",
+"mpc('"
+"-1.7566267846037841105306041816232757851567066070613445016197619371316057169"
+"4723618263960834804618463052988607348289672535780644470689771115236512106002"
+"5970873471563240537307638968509556191696167970488390423963867031934333890838"
+"8009531786948197210025029725361069435208930363494971027388382086721660805397"
+"9163230643216054580167976201709951509519218635460317367338612500626714783631"
+"7498317478048447525674016344322545858832610325861086336204591943822302971823"
+"5161814175530618223688296232894588415495615809337292518431903058265147109853"
+"1710568942184987827643886816200452860853873815413367529829631430146227470517"
+"6579967222200868632179482214312673161276976117132204633283806161971389519137"
+"1243359764435612951384238091232760634271570950240717650166551484551654327989"
+"9360285030081716934130446150245110557038117075172576825490035434069388648124"
+"6678152254554001586736120762641422590778766100376515737713938521275749049949"
+"1284143906816424244705094759339932733567910991920631339597278805393743140853"
+"391550313363278558195609260225928','"
+"4.74266443803465792819488940755002274088830335171164611359052405215840070271"
+"5906813009373171139767051863542508136875688550817670379002790304870822775498"
+"2809996675877564504192565392367259119610438951593128982646945990372179860613"
+"4294436498090428077839141927485901735557543641049637962003652638924845391650"
+"9546290137755550107224907606529385248390667634297183361902055842228798984200"
+"9591180450211798341715874477629099687609819466457990642030707080894518168924"
+"6805549314043258530272479246115112769957368212585759640878745385160943755234"
+"9398036774908108204370323896757543121853650025529763655312360354244898913463"
+"7115955702828838923393113618205074162812089732064414530813087483533203244056"
+"0546577484241423134079056537777170351934430586103623577814746004431994179990"
+"5318522939077992613855205801498201930221975721246498720895122345420698451980"
+"0051215797310305885845964334761831751370672996984756815410977750799748813563"
+"8784405288158432214886648743541773208808731479748217023665577802702269468013"
+"673719173759245720489020315779001')"],
+]
+
+for z in [4, 14, 34, 64]:
+    testcases.append(["(2+j)*%s/3" % z, None])
+    testcases.append(["(-2+j)*%s/3" % z, None])
+    testcases.append(["(1+2*j)*%s/3" % z, None])
+    testcases.append(["(2-j)*%s/3" % z, None])
+    testcases.append(["(20+j)*%s/3" % z, None])
+    testcases.append(["(-20+j)*%s/3" % z, None])
+    testcases.append(["(1+20*j)*%s/3" % z, None])
+    testcases.append(["(20-j)*%s/3" % z, None])
+    testcases.append(["(200+j)*%s/3" % z, None])
+    testcases.append(["(-200+j)*%s/3" % z, None])
+    testcases.append(["(1+200*j)*%s/3" % z, None])
+    testcases.append(["(200-j)*%s/3" % z, None])
+
+# Poles
+for n in [0,1,2,3,4,25,-1,-2,-3,-4,-20,-21,-50,-51,-200,-201,-20000,-20001]:
+    for t in ['1e-5', '1e-20', '1e-100', '1e-10000']:
+        testcases.append(["fadd(%s,'%s',exact=True)" % (n, t), None])
+        testcases.append(["fsub(%s,'%s',exact=True)" % (n, t), None])
+        testcases.append(["fadd(%s,'%sj',exact=True)" % (n, t), None])
+        testcases.append(["fsub(%s,'%sj',exact=True)" % (n, t), None])
+
+if __name__ == "__main__":
+    from timeit import default_timer as clock
+    tot_time = 0.0
+    for case in testcases:
+        t1 = clock()
+        testcase(case)
+        t2 = clock()
+        print("Test time:", t2-t1)
+        print()
+        tot_time += (t2-t1)
+    print("Total time:", tot_time)
+    print("Errors:", errcount)

llmeval-env/lib/python3.10/site-packages/mpmath/tests/extratest_zeta.py

@@ -0,0 +1,30 @@
+from mpmath import zetazero
+from timeit import default_timer as clock
+
+def test_zetazero():
+    cases = [\
+    (399999999, 156762524.6750591511),
+    (241389216, 97490234.2276711795),
+    (526196239, 202950727.691229534),
+    (542964976, 209039046.578535272),
+    (1048449112, 388858885.231056486),
+    (1048449113, 388858885.384337406),
+    (1048449114, 388858886.002285122),
+    (1048449115, 388858886.00239369),
+    (1048449116, 388858886.690745053)
+    ]
+    for n, v in cases:
+        print(n, v)
+        t1 = clock()
+        ok = zetazero(n).ae(complex(0.5,v))
+        t2 = clock()
+        print("ok =", ok, ("(time = %s)" % round(t2-t1,3)))
+    print("Now computing two huge zeros (this may take hours)")
+    print("Computing zetazero(8637740722917)")
+    ok = zetazero(8637740722917).ae(complex(0.5,2124447368584.39296466152))
+    print("ok =", ok)
+    ok = zetazero(8637740722918).ae(complex(0.5,2124447368584.39298170604))
+    print("ok =", ok)
+
+if __name__ == "__main__":
+    test_zetazero()

llmeval-env/lib/python3.10/site-packages/mpmath/tests/runtests.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python
+
+"""
+python runtests.py -py
+  Use py.test to run tests (more useful for debugging)
+
+python runtests.py -coverage
+  Generate test coverage report. Statistics are written to /tmp
+
+python runtests.py -profile
+  Generate profile stats (this is much slower)
+
+python runtests.py -nogmpy
+  Run tests without using GMPY even if it exists
+
+python runtests.py -strict
+  Enforce extra tests in normalize()
+
+python runtests.py -local
+  Insert '../..' at the beginning of sys.path to use local mpmath
+
+python runtests.py -skip ...
+  Skip tests from the listed modules
+
+Additional arguments are used to filter the tests to run. Only files that have
+one of the arguments in their name are executed.
+
+"""
+
+import sys, os, traceback
+
+profile = False
+if "-profile" in sys.argv:
+    sys.argv.remove('-profile')
+    profile = True
+
+coverage = False
+if "-coverage" in sys.argv:
+    sys.argv.remove('-coverage')
+    coverage = True
+
+if "-nogmpy" in sys.argv:
+    sys.argv.remove('-nogmpy')
+    os.environ['MPMATH_NOGMPY'] = 'Y'
+
+if "-strict" in sys.argv:
+    sys.argv.remove('-strict')
+    os.environ['MPMATH_STRICT'] = 'Y'
+
+if "-local" in sys.argv:
+    sys.argv.remove('-local')
+    importdir = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]),
+                                             '../..'))
+else:
+    importdir = ''
+
+# TODO: add a flag for this
+testdir = ''
+
+def testit(importdir='', testdir='', exit_on_fail=False):
+    """Run all tests in testdir while importing from importdir."""
+    if importdir:
+        sys.path.insert(1, importdir)
+    if testdir:
+        sys.path.insert(1, testdir)
+    import os.path
+    import mpmath
+    print("mpmath imported from %s" % os.path.dirname(mpmath.__file__))
+    print("mpmath backend: %s" % mpmath.libmp.backend.BACKEND)
+    print("mpmath mp class: %s" % repr(mpmath.mp))
+    print("mpmath version: %s" % mpmath.__version__)
+    print("Python version: %s" % sys.version)
+    print("")
+    if "-py" in sys.argv:
+        sys.argv.remove('-py')
+        import py
+        py.test.cmdline.main()
+    else:
+        import glob
+        from timeit import default_timer as clock
+        modules = []
+        args = sys.argv[1:]
+        excluded = []
+        if '-skip' in args:
+            excluded = args[args.index('-skip')+1:]
+            args = args[:args.index('-skip')]
+        # search for tests in directory of this file if not otherwise specified
+        if not testdir:
+            pattern = os.path.dirname(sys.argv[0])
+        else:
+            pattern = testdir
+        if pattern:
+            pattern += '/'
+        pattern += 'test*.py'
+        # look for tests (respecting specified filter)
+        for f in glob.glob(pattern):
+            name = os.path.splitext(os.path.basename(f))[0]
+            # If run as a script, only run tests given as args, if any are given
+            if args and __name__ == "__main__":
+                ok = False
+                for arg in args:
+                    if arg in name:
+                        ok = True
+                        break
+                if not ok:
+                    continue
+            elif name in excluded:
+                continue
+            module = __import__(name)
+            priority = module.__dict__.get('priority', 100)
+            if priority == 666:
+                modules = [[priority, name, module]]
+                break
+            modules.append([priority, name, module])
+        # execute tests
+        modules.sort()
+        tstart = clock()
+        for priority, name, module in modules:
+            print(name)
+            for f in sorted(module.__dict__.keys()):
+                if f.startswith('test_'):
+                    if coverage and ('numpy' in f):
+                        continue
+                    sys.stdout.write("    " + f[5:].ljust(25) + " ")
+                    t1 = clock()
+                    try:
+                        module.__dict__[f]()
+                    except:
+                        etype, evalue, trb = sys.exc_info()
+                        if etype in (KeyboardInterrupt, SystemExit):
+                            raise
+                        print("")
+                        print("TEST FAILED!")
+                        print("")
+                        traceback.print_exc()
+                        if exit_on_fail:
+                            return
+                    t2 = clock()
+                    print("ok " + "       " + ("%.7f" % (t2-t1)) + " s")
+        tend = clock()
+        print("")
+        print("finished tests in " + ("%.2f" % (tend-tstart)) + " seconds")
+        # clean sys.path
+        if importdir:
+            sys.path.remove(importdir)
+        if testdir:
+            sys.path.remove(testdir)
+
+if __name__ == '__main__':
+    if profile:
+        import cProfile
+        cProfile.run("testit('%s', '%s')" % (importdir, testdir), sort=1)
+    elif coverage:
+        import trace
+        tracer = trace.Trace(ignoredirs=[sys.prefix, sys.exec_prefix],
+            trace=0, count=1)
+        tracer.run('testit(importdir, testdir)')
+        r = tracer.results()
+        r.write_results(show_missing=True, summary=True, coverdir="/tmp")
+    else:
+        testit(importdir, testdir)

llmeval-env/lib/python3.10/site-packages/mpmath/tests/test_basic_ops.py

@@ -0,0 +1,451 @@
+import mpmath
+from mpmath import *
+from mpmath.libmp import *
+import random
+import sys
+
+try:
+    long = long
+except NameError:
+    long = int
+
+def test_type_compare():
+    assert mpf(2) == mpc(2,0)
+    assert mpf(0) == mpc(0)
+    assert mpf(2) != mpc(2, 0.00001)
+    assert mpf(2) == 2.0
+    assert mpf(2) != 3.0
+    assert mpf(2) == 2
+    assert mpf(2) != '2.0'
+    assert mpc(2) != '2.0'
+
+def test_add():
+    assert mpf(2.5) + mpf(3) == 5.5
+    assert mpf(2.5) + 3 == 5.5
+    assert mpf(2.5) + 3.0 == 5.5
+    assert 3 + mpf(2.5) == 5.5
+    assert 3.0 + mpf(2.5) == 5.5
+    assert (3+0j) + mpf(2.5) == 5.5
+    assert mpc(2.5) + mpf(3) == 5.5
+    assert mpc(2.5) + 3 == 5.5
+    assert mpc(2.5) + 3.0 == 5.5
+    assert mpc(2.5) + (3+0j) == 5.5
+    assert 3 + mpc(2.5) == 5.5
+    assert 3.0 + mpc(2.5) == 5.5
+    assert (3+0j) + mpc(2.5) == 5.5
+
+def test_sub():
+    assert mpf(2.5) - mpf(3) == -0.5
+    assert mpf(2.5) - 3 == -0.5
+    assert mpf(2.5) - 3.0 == -0.5
+    assert 3 - mpf(2.5) == 0.5
+    assert 3.0 - mpf(2.5) == 0.5
+    assert (3+0j) - mpf(2.5) == 0.5
+    assert mpc(2.5) - mpf(3) == -0.5
+    assert mpc(2.5) - 3 == -0.5
+    assert mpc(2.5) - 3.0 == -0.5
+    assert mpc(2.5) - (3+0j) == -0.5
+    assert 3 - mpc(2.5) == 0.5
+    assert 3.0 - mpc(2.5) == 0.5
+    assert (3+0j) - mpc(2.5) == 0.5
+
+def test_mul():
+    assert mpf(2.5) * mpf(3) == 7.5
+    assert mpf(2.5) * 3 == 7.5
+    assert mpf(2.5) * 3.0 == 7.5
+    assert 3 * mpf(2.5) == 7.5
+    assert 3.0 * mpf(2.5) == 7.5
+    assert (3+0j) * mpf(2.5) == 7.5
+    assert mpc(2.5) * mpf(3) == 7.5
+    assert mpc(2.5) * 3 == 7.5
+    assert mpc(2.5) * 3.0 == 7.5
+    assert mpc(2.5) * (3+0j) == 7.5
+    assert 3 * mpc(2.5) == 7.5
+    assert 3.0 * mpc(2.5) == 7.5
+    assert (3+0j) * mpc(2.5) == 7.5
+
+def test_div():
+    assert mpf(6) / mpf(3) == 2.0
+    assert mpf(6) / 3 == 2.0
+    assert mpf(6) / 3.0 == 2.0
+    assert 6 / mpf(3) == 2.0
+    assert 6.0 / mpf(3) == 2.0
+    assert (6+0j) / mpf(3.0) == 2.0
+    assert mpc(6) / mpf(3) == 2.0
+    assert mpc(6) / 3 == 2.0
+    assert mpc(6) / 3.0 == 2.0
+    assert mpc(6) / (3+0j) == 2.0
+    assert 6 / mpc(3) == 2.0
+    assert 6.0 / mpc(3) == 2.0
+    assert (6+0j) / mpc(3) == 2.0
+
+def test_pow():
+    assert mpf(6) ** mpf(3) == 216.0
+    assert mpf(6) ** 3 == 216.0
+    assert mpf(6) ** 3.0 == 216.0
+    assert 6 ** mpf(3) == 216.0
+    assert 6.0 ** mpf(3) == 216.0
+    assert (6+0j) ** mpf(3.0) == 216.0
+    assert mpc(6) ** mpf(3) == 216.0
+    assert mpc(6) ** 3 == 216.0
+    assert mpc(6) ** 3.0 == 216.0
+    assert mpc(6) ** (3+0j) == 216.0
+    assert 6 ** mpc(3) == 216.0
+    assert 6.0 ** mpc(3) == 216.0
+    assert (6+0j) ** mpc(3) == 216.0
+
+def test_mixed_misc():
+    assert 1 + mpf(3) == mpf(3) + 1 == 4
+    assert 1 - mpf(3) == -(mpf(3) - 1) == -2
+    assert 3 * mpf(2) == mpf(2) * 3 == 6
+    assert 6 / mpf(2) == mpf(6) / 2 == 3
+    assert 1.0 + mpf(3) == mpf(3) + 1.0 == 4
+    assert 1.0 - mpf(3) == -(mpf(3) - 1.0) == -2
+    assert 3.0 * mpf(2) == mpf(2) * 3.0 == 6
+    assert 6.0 / mpf(2) == mpf(6) / 2.0 == 3
+
+def test_add_misc():
+    mp.dps = 15
+    assert mpf(4) + mpf(-70) == -66
+    assert mpf(1) + mpf(1.1)/80 == 1 + 1.1/80
+    assert mpf((1, 10000000000)) + mpf(3) == mpf((1, 10000000000))
+    assert mpf(3) + mpf((1, 10000000000)) == mpf((1, 10000000000))
+    assert mpf((1, -10000000000)) + mpf(3) == mpf(3)
+    assert mpf(3) + mpf((1, -10000000000)) == mpf(3)
+    assert mpf(1) + 1e-15 != 1
+    assert mpf(1) + 1e-20 == 1
+    assert mpf(1.07e-22) + 0 == mpf(1.07e-22)
+    assert mpf(0) + mpf(1.07e-22) == mpf(1.07e-22)
+
+def test_complex_misc():
+    # many more tests needed
+    assert 1 + mpc(2) == 3
+    assert not mpc(2).ae(2 + 1e-13)
+    assert mpc(2+1e-15j).ae(2)
+
+def test_complex_zeros():
+    for a in [0,2]:
+        for b in [0,3]:
+            for c in [0,4]:
+                for d in [0,5]:
+                    assert mpc(a,b)*mpc(c,d) == complex(a,b)*complex(c,d)
+
+def test_hash():
+    for i in range(-256, 256):
+        assert hash(mpf(i)) == hash(i)
+    assert hash(mpf(0.5)) == hash(0.5)
+    assert hash(mpc(2,3)) == hash(2+3j)
+    # Check that this doesn't fail
+    assert hash(inf)
+    # Check that overflow doesn't assign equal hashes to large numbers
+    assert hash(mpf('1e1000')) != hash('1e10000')
+    assert hash(mpc(100,'1e1000')) != hash(mpc(200,'1e1000'))
+    from mpmath.rational import mpq
+    assert hash(mp.mpq(1,3))
+    assert hash(mp.mpq(0,1)) == 0
+    assert hash(mp.mpq(-1,1)) == hash(-1)
+    assert hash(mp.mpq(1,1)) == hash(1)
+    assert hash(mp.mpq(5,1)) == hash(5)
+    assert hash(mp.mpq(1,2)) == hash(0.5)
+    if sys.version_info >= (3, 2):
+        assert hash(mpf(1)*2**2000) == hash(2**2000)
+        assert hash(mpf(1)/2**2000) == hash(mpq(1,2**2000))
+
+# Advanced rounding test
+def test_add_rounding():
+    mp.dps = 15
+    a = from_float(1e-50)
+    assert mpf_sub(mpf_add(fone, a, 53, round_up), fone, 53, round_up) == from_float(2.2204460492503131e-16)
+    assert mpf_sub(fone, a, 53, round_up) == fone
+    assert mpf_sub(fone, mpf_sub(fone, a, 53, round_down), 53, round_down) == from_float(1.1102230246251565e-16)
+    assert mpf_add(fone, a, 53, round_down) == fone
+
+def test_almost_equal():
+    assert mpf(1.2).ae(mpf(1.20000001), 1e-7)
+    assert not mpf(1.2).ae(mpf(1.20000001), 1e-9)
+    assert not mpf(-0.7818314824680298).ae(mpf(-0.774695868667929))
+
+def test_arithmetic_functions():
+    import operator
+    ops = [(operator.add, fadd), (operator.sub, fsub), (operator.mul, fmul),
+        (operator.truediv, fdiv)]
+    a = mpf(0.27)
+    b = mpf(1.13)
+    c = mpc(0.51+2.16j)
+    d = mpc(1.08-0.99j)
+    for x in [a,b,c,d]:
+        for y in [a,b,c,d]:
+            for op, fop in ops:
+                if fop is not fdiv:
+                    mp.prec = 200
+                    z0 = op(x,y)
+                mp.prec = 60
+                z1 = op(x,y)
+                mp.prec = 53
+                z2 = op(x,y)
+                assert fop(x, y, prec=60) == z1
+                assert fop(x, y) == z2
+                if fop is not fdiv:
+                    assert fop(x, y, prec=inf) == z0
+                    assert fop(x, y, dps=inf) == z0
+                    assert fop(x, y, exact=True) == z0
+                assert fneg(fneg(z1, exact=True), prec=inf) == z1
+                assert fneg(z1) == -(+z1)
+    mp.dps = 15
+
+def test_exact_integer_arithmetic():
+    # XXX: re-fix this so that all operations are tested with all rounding modes
+    random.seed(0)
+    for prec in [6, 10, 25, 40, 100, 250, 725]:
+        for rounding in ['d', 'u', 'f', 'c', 'n']:
+            mp.dps = prec
+            M = 10**(prec-2)
+            M2 = 10**(prec//2-2)
+            for i in range(10):
+                a = random.randint(-M, M)
+                b = random.randint(-M, M)
+                assert mpf(a, rounding=rounding) == a
+                assert int(mpf(a, rounding=rounding)) == a
+                assert int(mpf(str(a), rounding=rounding)) == a
+                assert mpf(a) + mpf(b) == a + b
+                assert mpf(a) - mpf(b) == a - b
+                assert -mpf(a) == -a
+                a = random.randint(-M2, M2)
+                b = random.randint(-M2, M2)
+                assert mpf(a) * mpf(b) == a*b
+                assert mpf_mul(from_int(a), from_int(b), mp.prec, rounding) == from_int(a*b)
+    mp.dps = 15
+
+def test_odd_int_bug():
+    assert to_int(from_int(3), round_nearest) == 3
+
+def test_str_1000_digits():
+    mp.dps = 1001
+    # last digit may be wrong
+    assert str(mpf(2)**0.5)[-10:-1] == '9518488472'[:9]
+    assert str(pi)[-10:-1] == '2164201989'[:9]
+    mp.dps = 15
+
+def test_str_10000_digits():
+    mp.dps = 10001
+    # last digit may be wrong
+    assert str(mpf(2)**0.5)[-10:-1] == '5873258351'[:9]
+    assert str(pi)[-10:-1] == '5256375678'[:9]
+    mp.dps = 15
+
+def test_monitor():
+    f = lambda x: x**2
+    a = []
+    b = []
+    g = monitor(f, a.append, b.append)
+    assert g(3) == 9
+    assert g(4) == 16
+    assert a[0] == ((3,), {})
+    assert b[0] == 9
+
+def test_nint_distance():
+    assert nint_distance(mpf(-3)) == (-3, -inf)
+    assert nint_distance(mpc(-3)) == (-3, -inf)
+    assert nint_distance(mpf(-3.1)) == (-3, -3)
+    assert nint_distance(mpf(-3.01)) == (-3, -6)
+    assert nint_distance(mpf(-3.001)) == (-3, -9)
+    assert nint_distance(mpf(-3.0001)) == (-3, -13)
+    assert nint_distance(mpf(-2.9)) == (-3, -3)
+    assert nint_distance(mpf(-2.99)) == (-3, -6)
+    assert nint_distance(mpf(-2.999)) == (-3, -9)
+    assert nint_distance(mpf(-2.9999)) == (-3, -13)
+    assert nint_distance(mpc(-3+0.1j)) == (-3, -3)
+    assert nint_distance(mpc(-3+0.01j)) == (-3, -6)
+    assert nint_distance(mpc(-3.1+0.1j)) == (-3, -3)
+    assert nint_distance(mpc(-3.01+0.01j)) == (-3, -6)
+    assert nint_distance(mpc(-3.001+0.001j)) == (-3, -9)
+    assert nint_distance(mpf(0)) == (0, -inf)
+    assert nint_distance(mpf(0.01)) == (0, -6)
+    assert nint_distance(mpf('1e-100')) == (0, -332)
+
+def test_floor_ceil_nint_frac():
+    mp.dps = 15
+    for n in range(-10,10):
+        assert floor(n) == n
+        assert floor(n+0.5) == n
+        assert ceil(n) == n
+        assert ceil(n+0.5) == n+1
+        assert nint(n) == n
+        # nint rounds to even
+        if n % 2 == 1:
+            assert nint(n+0.5) == n+1
+        else:
+            assert nint(n+0.5) == n
+    assert floor(inf) == inf
+    assert floor(ninf) == ninf
+    assert isnan(floor(nan))
+    assert ceil(inf) == inf
+    assert ceil(ninf) == ninf
+    assert isnan(ceil(nan))
+    assert nint(inf) == inf
+    assert nint(ninf) == ninf
+    assert isnan(nint(nan))
+    assert floor(0.1) == 0
+    assert floor(0.9) == 0
+    assert floor(-0.1) == -1
+    assert floor(-0.9) == -1
+    assert floor(10000000000.1) == 10000000000
+    assert floor(10000000000.9) == 10000000000
+    assert floor(-10000000000.1) == -10000000000-1
+    assert floor(-10000000000.9) == -10000000000-1
+    assert floor(1e-100) == 0
+    assert floor(-1e-100) == -1
+    assert floor(1e100) == 1e100
+    assert floor(-1e100) == -1e100
+    assert ceil(0.1) == 1
+    assert ceil(0.9) == 1
+    assert ceil(-0.1) == 0
+    assert ceil(-0.9) == 0
+    assert ceil(10000000000.1) == 10000000000+1
+    assert ceil(10000000000.9) == 10000000000+1
+    assert ceil(-10000000000.1) == -10000000000
+    assert ceil(-10000000000.9) == -10000000000
+    assert ceil(1e-100) == 1
+    assert ceil(-1e-100) == 0
+    assert ceil(1e100) == 1e100
+    assert ceil(-1e100) == -1e100
+    assert nint(0.1) == 0
+    assert nint(0.9) == 1
+    assert nint(-0.1) == 0
+    assert nint(-0.9) == -1
+    assert nint(10000000000.1) == 10000000000
+    assert nint(10000000000.9) == 10000000000+1
+    assert nint(-10000000000.1) == -10000000000
+    assert nint(-10000000000.9) == -10000000000-1
+    assert nint(1e-100) == 0
+    assert nint(-1e-100) == 0
+    assert nint(1e100) == 1e100
+    assert nint(-1e100) == -1e100
+    assert floor(3.2+4.6j) == 3+4j
+    assert ceil(3.2+4.6j) == 4+5j
+    assert nint(3.2+4.6j) == 3+5j
+    for n in range(-10,10):
+        assert frac(n) == 0
+    assert frac(0.25) == 0.25
+    assert frac(1.25) == 0.25
+    assert frac(2.25) == 0.25
+    assert frac(-0.25) == 0.75
+    assert frac(-1.25) == 0.75
+    assert frac(-2.25) == 0.75
+    assert frac('1e100000000000000') == 0
+    u = mpf('1e-100000000000000')
+    assert frac(u) == u
+    assert frac(-u) == 1  # rounding!
+    u = mpf('1e-400')
+    assert frac(-u, prec=0) == fsub(1, u, exact=True)
+    assert frac(3.25+4.75j) == 0.25+0.75j
+
+def test_isnan_etc():
+    from mpmath.rational import mpq
+    assert isnan(nan) == True
+    assert isnan(3) == False
+    assert isnan(mpf(3)) == False
+    assert isnan(inf) == False
+    assert isnan(mpc(2,nan)) == True
+    assert isnan(mpc(2,nan)) == True
+    assert isnan(mpc(nan,nan)) == True
+    assert isnan(mpc(2,2)) == False
+    assert isnan(mpc(nan,inf)) == True
+    assert isnan(mpc(inf,inf)) == False
+    assert isnan(mpq((3,2))) == False
+    assert isnan(mpq((0,1))) == False
+    assert isinf(inf) == True
+    assert isinf(-inf) == True
+    assert isinf(3) == False
+    assert isinf(nan) == False
+    assert isinf(3+4j) == False
+    assert isinf(mpc(inf)) == True
+    assert isinf(mpc(3,inf)) == True
+    assert isinf(mpc(inf,3)) == True
+    assert isinf(mpc(inf,inf)) == True
+    assert isinf(mpc(nan,inf)) == True
+    assert isinf(mpc(inf,nan)) == True
+    assert isinf(mpc(nan,nan)) == False
+    assert isinf(mpq((3,2))) == False
+    assert isinf(mpq((0,1))) == False
+    assert isnormal(3) == True
+    assert isnormal(3.5) == True
+    assert isnormal(mpf(3.5)) == True
+    assert isnormal(0) == False
+    assert isnormal(mpf(0)) == False
+    assert isnormal(0.0) == False
+    assert isnormal(inf) == False
+    assert isnormal(-inf) == False
+    assert isnormal(nan) == False
+    assert isnormal(float(inf)) == False
+    assert isnormal(mpc(0,0)) == False
+    assert isnormal(mpc(3,0)) == True
+    assert isnormal(mpc(0,3)) == True
+    assert isnormal(mpc(3,3)) == True
+    assert isnormal(mpc(0,nan)) == False
+    assert isnormal(mpc(0,inf)) == False
+    assert isnormal(mpc(3,nan)) == False
+    assert isnormal(mpc(3,inf)) == False
+    assert isnormal(mpc(3,-inf)) == False
+    assert isnormal(mpc(nan,0)) == False
+    assert isnormal(mpc(inf,0)) == False
+    assert isnormal(mpc(nan,3)) == False
+    assert isnormal(mpc(inf,3)) == False
+    assert isnormal(mpc(inf,nan)) == False
+    assert isnormal(mpc(nan,inf)) == False
+    assert isnormal(mpc(nan,nan)) == False
+    assert isnormal(mpc(inf,inf)) == False
+    assert isnormal(mpq((3,2))) == True
+    assert isnormal(mpq((0,1))) == False
+    assert isint(3) == True
+    assert isint(0) == True
+    assert isint(long(3)) == True
+    assert isint(long(0)) == True
+    assert isint(mpf(3)) == True
+    assert isint(mpf(0)) == True
+    assert isint(mpf(-3)) == True
+    assert isint(mpf(3.2)) == False
+    assert isint(3.2) == False
+    assert isint(nan) == False
+    assert isint(inf) == False
+    assert isint(-inf) == False
+    assert isint(mpc(0)) == True
+    assert isint(mpc(3)) == True
+    assert isint(mpc(3.2)) == False
+    assert isint(mpc(3,inf)) == False
+    assert isint(mpc(inf)) == False
+    assert isint(mpc(3,2)) == False
+    assert isint(mpc(0,2)) == False
+    assert isint(mpc(3,2),gaussian=True) == True
+    assert isint(mpc(3,0),gaussian=True) == True
+    assert isint(mpc(0,3),gaussian=True) == True
+    assert isint(3+4j) == False
+    assert isint(3+4j, gaussian=True) == True
+    assert isint(3+0j) == True
+    assert isint(mpq((3,2))) == False
+    assert isint(mpq((3,9))) == False
+    assert isint(mpq((9,3))) == True
+    assert isint(mpq((0,4))) == True
+    assert isint(mpq((1,1))) == True
+    assert isint(mpq((-1,1))) == True
+    assert mp.isnpint(0) == True
+    assert mp.isnpint(1) == False
+    assert mp.isnpint(-1) == True
+    assert mp.isnpint(-1.1) == False
+    assert mp.isnpint(-1.0) == True
+    assert mp.isnpint(mp.mpq(1,2)) == False
+    assert mp.isnpint(mp.mpq(-1,2)) == False
+    assert mp.isnpint(mp.mpq(-3,1)) == True
+    assert mp.isnpint(mp.mpq(0,1)) == True
+    assert mp.isnpint(mp.mpq(1,1)) == False
+    assert mp.isnpint(0+0j) == True
+    assert mp.isnpint(-1+0j) == True
+    assert mp.isnpint(-1.1+0j) == False
+    assert mp.isnpint(-1+0.1j) == False
+    assert mp.isnpint(0+0.1j) == False
+
+
+def test_issue_438():
+    assert mpf(finf) == mpf('inf')
+    assert mpf(fninf) == mpf('-inf')
+    assert mpf(fnan)._mpf_ == mpf('nan')._mpf_

llmeval-env/lib/python3.10/site-packages/mpmath/tests/test_bitwise.py

@@ -0,0 +1,188 @@
+"""
+Test bit-level integer and mpf operations
+"""
+
+from mpmath import *
+from mpmath.libmp import *
+
+def test_bitcount():
+    assert bitcount(0) == 0
+    assert bitcount(1) == 1
+    assert bitcount(7) == 3
+    assert bitcount(8) == 4
+    assert bitcount(2**100) == 101
+    assert bitcount(2**100-1) == 100
+
+def test_trailing():
+    assert trailing(0) == 0
+    assert trailing(1) == 0
+    assert trailing(2) == 1
+    assert trailing(7) == 0
+    assert trailing(8) == 3
+    assert trailing(2**100) == 100
+    assert trailing(2**100-1) == 0
+
+def test_round_down():
+    assert from_man_exp(0, -4, 4, round_down)[:3] == (0, 0, 0)
+    assert from_man_exp(0xf0, -4, 4, round_down)[:3] == (0, 15, 0)
+    assert from_man_exp(0xf1, -4, 4, round_down)[:3] == (0, 15, 0)
+    assert from_man_exp(0xff, -4, 4, round_down)[:3] == (0, 15, 0)
+    assert from_man_exp(-0xf0, -4, 4, round_down)[:3] == (1, 15, 0)
+    assert from_man_exp(-0xf1, -4, 4, round_down)[:3] == (1, 15, 0)
+    assert from_man_exp(-0xff, -4, 4, round_down)[:3] == (1, 15, 0)
+
+def test_round_up():
+    assert from_man_exp(0, -4, 4, round_up)[:3] == (0, 0, 0)
+    assert from_man_exp(0xf0, -4, 4, round_up)[:3] == (0, 15, 0)
+    assert from_man_exp(0xf1, -4, 4, round_up)[:3] == (0, 1, 4)
+    assert from_man_exp(0xff, -4, 4, round_up)[:3] == (0, 1, 4)
+    assert from_man_exp(-0xf0, -4, 4, round_up)[:3] == (1, 15, 0)
+    assert from_man_exp(-0xf1, -4, 4, round_up)[:3] == (1, 1, 4)
+    assert from_man_exp(-0xff, -4, 4, round_up)[:3] == (1, 1, 4)
+
+def test_round_floor():
+    assert from_man_exp(0, -4, 4, round_floor)[:3] == (0, 0, 0)
+    assert from_man_exp(0xf0, -4, 4, round_floor)[:3] == (0, 15, 0)
+    assert from_man_exp(0xf1, -4, 4, round_floor)[:3] == (0, 15, 0)
+    assert from_man_exp(0xff, -4, 4, round_floor)[:3] == (0, 15, 0)
+    assert from_man_exp(-0xf0, -4, 4, round_floor)[:3] == (1, 15, 0)
+    assert from_man_exp(-0xf1, -4, 4, round_floor)[:3] == (1, 1, 4)
+    assert from_man_exp(-0xff, -4, 4, round_floor)[:3] == (1, 1, 4)
+
+def test_round_ceiling():
+    assert from_man_exp(0, -4, 4, round_ceiling)[:3] == (0, 0, 0)
+    assert from_man_exp(0xf0, -4, 4, round_ceiling)[:3] == (0, 15, 0)
+    assert from_man_exp(0xf1, -4, 4, round_ceiling)[:3] == (0, 1, 4)
+    assert from_man_exp(0xff, -4, 4, round_ceiling)[:3] == (0, 1, 4)
+    assert from_man_exp(-0xf0, -4, 4, round_ceiling)[:3] == (1, 15, 0)
+    assert from_man_exp(-0xf1, -4, 4, round_ceiling)[:3] == (1, 15, 0)
+    assert from_man_exp(-0xff, -4, 4, round_ceiling)[:3] == (1, 15, 0)
+
+def test_round_nearest():
+    assert from_man_exp(0, -4, 4, round_nearest)[:3] == (0, 0, 0)
+    assert from_man_exp(0xf0, -4, 4, round_nearest)[:3] == (0, 15, 0)
+    assert from_man_exp(0xf7, -4, 4, round_nearest)[:3] == (0, 15, 0)
+    assert from_man_exp(0xf8, -4, 4, round_nearest)[:3] == (0, 1, 4)    # 1111.1000 -> 10000.0
+    assert from_man_exp(0xf9, -4, 4, round_nearest)[:3] == (0, 1, 4)    # 1111.1001 -> 10000.0
+    assert from_man_exp(0xe8, -4, 4, round_nearest)[:3] == (0, 7, 1)    # 1110.1000 -> 1110.0
+    assert from_man_exp(0xe9, -4, 4, round_nearest)[:3] == (0, 15, 0)     # 1110.1001 -> 1111.0
+    assert from_man_exp(-0xf0, -4, 4, round_nearest)[:3] == (1, 15, 0)
+    assert from_man_exp(-0xf7, -4, 4, round_nearest)[:3] == (1, 15, 0)
+    assert from_man_exp(-0xf8, -4, 4, round_nearest)[:3] == (1, 1, 4)
+    assert from_man_exp(-0xf9, -4, 4, round_nearest)[:3] == (1, 1, 4)
+    assert from_man_exp(-0xe8, -4, 4, round_nearest)[:3] == (1, 7, 1)
+    assert from_man_exp(-0xe9, -4, 4, round_nearest)[:3] == (1, 15, 0)
+
+def test_rounding_bugs():
+    # 1 less than power-of-two cases
+    assert from_man_exp(72057594037927935, -56, 53, round_up) == (0, 1, 0, 1)
+    assert from_man_exp(73786976294838205979, -65, 53, round_nearest) == (0, 1, 1, 1)
+    assert from_man_exp(31, 0, 4, round_up) == (0, 1, 5, 1)
+    assert from_man_exp(-31, 0, 4, round_floor) == (1, 1, 5, 1)
+    assert from_man_exp(255, 0, 7, round_up) == (0, 1, 8, 1)
+    assert from_man_exp(-255, 0, 7, round_floor) == (1, 1, 8, 1)
+
+def test_rounding_issue_200():
+    a = from_man_exp(9867,-100)
+    b = from_man_exp(9867,-200)
+    c = from_man_exp(-1,0)
+    z = (1, 1023, -10, 10)
+    assert mpf_add(a, c, 10, 'd') == z
+    assert mpf_add(b, c, 10, 'd') == z
+    assert mpf_add(c, a, 10, 'd') == z
+    assert mpf_add(c, b, 10, 'd') == z
+
+def test_perturb():
+    a = fone
+    b = from_float(0.99999999999999989)
+    c = from_float(1.0000000000000002)
+    assert mpf_perturb(a, 0, 53, round_nearest) == a
+    assert mpf_perturb(a, 1, 53, round_nearest) == a
+    assert mpf_perturb(a, 0, 53, round_up) == c
+    assert mpf_perturb(a, 0, 53, round_ceiling) == c
+    assert mpf_perturb(a, 0, 53, round_down) == a
+    assert mpf_perturb(a, 0, 53, round_floor) == a
+    assert mpf_perturb(a, 1, 53, round_up) == a
+    assert mpf_perturb(a, 1, 53, round_ceiling) == a
+    assert mpf_perturb(a, 1, 53, round_down) == b
+    assert mpf_perturb(a, 1, 53, round_floor) == b
+    a = mpf_neg(a)
+    b = mpf_neg(b)
+    c = mpf_neg(c)
+    assert mpf_perturb(a, 0, 53, round_nearest) == a
+    assert mpf_perturb(a, 1, 53, round_nearest) == a
+    assert mpf_perturb(a, 0, 53, round_up) == a
+    assert mpf_perturb(a, 0, 53, round_floor) == a
+    assert mpf_perturb(a, 0, 53, round_down) == b
+    assert mpf_perturb(a, 0, 53, round_ceiling) == b
+    assert mpf_perturb(a, 1, 53, round_up) == c
+    assert mpf_perturb(a, 1, 53, round_floor) == c
+    assert mpf_perturb(a, 1, 53, round_down) == a
+    assert mpf_perturb(a, 1, 53, round_ceiling) == a
+
+def test_add_exact():
+    ff = from_float
+    assert mpf_add(ff(3.0), ff(2.5)) == ff(5.5)
+    assert mpf_add(ff(3.0), ff(-2.5)) == ff(0.5)
+    assert mpf_add(ff(-3.0), ff(2.5)) == ff(-0.5)
+    assert mpf_add(ff(-3.0), ff(-2.5)) == ff(-5.5)
+    assert mpf_sub(mpf_add(fone, ff(1e-100)), fone) == ff(1e-100)
+    assert mpf_sub(mpf_add(ff(1e-100), fone), fone) == ff(1e-100)
+    assert mpf_sub(mpf_add(fone, ff(-1e-100)), fone) == ff(-1e-100)
+    assert mpf_sub(mpf_add(ff(-1e-100), fone), fone) == ff(-1e-100)
+    assert mpf_add(fone, fzero) == fone
+    assert mpf_add(fzero, fone) == fone
+    assert mpf_add(fzero, fzero) == fzero
+
+def test_long_exponent_shifts():
+    mp.dps = 15
+    # Check for possible bugs due to exponent arithmetic overflow
+    # in a C implementation
+    x = mpf(1)
+    for p in [32, 64]:
+        a = ldexp(1,2**(p-1))
+        b = ldexp(1,2**p)
+        c = ldexp(1,2**(p+1))
+        d = ldexp(1,-2**(p-1))
+        e = ldexp(1,-2**p)
+        f = ldexp(1,-2**(p+1))
+        assert (x+a) == a
+        assert (x+b) == b
+        assert (x+c) == c
+        assert (x+d) == x
+        assert (x+e) == x
+        assert (x+f) == x
+        assert (a+x) == a
+        assert (b+x) == b
+        assert (c+x) == c
+        assert (d+x) == x
+        assert (e+x) == x
+        assert (f+x) == x
+        assert (x-a) == -a
+        assert (x-b) == -b
+        assert (x-c) == -c
+        assert (x-d) == x
+        assert (x-e) == x
+        assert (x-f) == x
+        assert (a-x) == a
+        assert (b-x) == b
+        assert (c-x) == c
+        assert (d-x) == -x
+        assert (e-x) == -x
+        assert (f-x) == -x
+
+def test_float_rounding():
+    mp.prec = 64
+    for x in [mpf(1), mpf(1)+eps, mpf(1)-eps, -mpf(1)+eps, -mpf(1)-eps]:
+        fa = float(x)
+        fb = float(fadd(x,0,prec=53,rounding='n'))
+        assert fa == fb
+        z = mpc(x,x)
+        ca = complex(z)
+        cb = complex(fadd(z,0,prec=53,rounding='n'))
+        assert ca == cb
+        for rnd in ['n', 'd', 'u', 'f', 'c']:
+            fa = to_float(x._mpf_, rnd=rnd)
+            fb = to_float(fadd(x,0,prec=53,rounding=rnd)._mpf_, rnd=rnd)
+            assert fa == fb
+    mp.prec = 53

llmeval-env/lib/python3.10/site-packages/mpmath/tests/test_calculus.py

@@ -0,0 +1,216 @@
+import pytest
+from mpmath import *
+
+def test_approximation():
+    mp.dps = 15
+    f = lambda x: cos(2-2*x)/x
+    p, err = chebyfit(f, [2, 4], 8, error=True)
+    assert err < 1e-5
+    for i in range(10):
+        x = 2 + i/5.
+        assert abs(polyval(p, x) - f(x)) < err
+
+def test_limits():
+    mp.dps = 15
+    assert limit(lambda x: (x-sin(x))/x**3, 0).ae(mpf(1)/6)
+    assert limit(lambda n: (1+1/n)**n, inf).ae(e)
+
+def test_polyval():
+    assert polyval([], 3) == 0
+    assert polyval([0], 3) == 0
+    assert polyval([5], 3) == 5
+    # 4x^3 - 2x + 5
+    p = [4, 0, -2, 5]
+    assert polyval(p,4) == 253
+    assert polyval(p,4,derivative=True) == (253, 190)
+
+def test_polyroots():
+    p = polyroots([1,-4])
+    assert p[0].ae(4)
+    p, q = polyroots([1,2,3])
+    assert p.ae(-1 - sqrt(2)*j)
+    assert q.ae(-1 + sqrt(2)*j)
+    #this is not a real test, it only tests a specific case
+    assert polyroots([1]) == []
+    pytest.raises(ValueError, lambda: polyroots([0]))
+
+def test_polyroots_legendre():
+    n = 64
+    coeffs = [11975573020964041433067793888190275875, 0,
+        -190100434726484311252477736051902332000, 0,
+        1437919688271127330313741595496589239248, 0,
+        -6897338342113537600691931230430793911840, 0,
+        23556405536185284408974715545252277554280, 0,
+        -60969520211303089058522793175947071316960, 0,
+        124284021969194758465450309166353645376880, 0,
+        -204721258548015217049921875719981284186016, 0,
+        277415422258095841688223780704620656114900, 0,
+        -313237834141273382807123548182995095192800, 0,
+        297432255354328395601259515935229287637200, 0,
+        -239057700565161140389797367947941296605600, 0,
+        163356095386193445933028201431093219347160, 0,
+        -95158890516229191805647495979277603503200, 0,
+        47310254620162038075933656063247634556400, 0,
+        -20071017111583894941305187420771723751200, 0,
+        7255051932731034189479516844750603752850, 0,
+        -2228176940331017311443863996901733412640, 0,
+        579006552594977616773047095969088431600, 0,
+        -126584428502545713788439446082310831200, 0,
+        23112325428835593809686977515028663000, 0,
+        -3491517141958743235617737161547844000, 0,
+        431305058712550634988073414073557200, 0,
+        -42927166660756742088912492757452000, 0,
+        3378527005707706553294038781836500, 0,
+        -205277590220215081719131470288800, 0,
+        9330799555464321896324157740400, 0,
+        -304114948474392713657972548576, 0,
+        6695289961520387531608984680, 0,
+        -91048139350447232095702560, 0,
+        659769125727878493447120, 0,
+        -1905929106580294155360, 0,
+        916312070471295267]
+
+    with mp.workdps(3):
+        with pytest.raises(mp.NoConvergence):
+            polyroots(coeffs, maxsteps=5, cleanup=True, error=False,
+                      extraprec=n*10)
+
+        roots = polyroots(coeffs, maxsteps=50, cleanup=True, error=False,
+                    extraprec=n*10)
+        roots = [str(r) for r in roots]
+        assert roots == \
+            ['-0.999', '-0.996', '-0.991', '-0.983', '-0.973', '-0.961',
+            '-0.946', '-0.93', '-0.911', '-0.889', '-0.866', '-0.841',
+            '-0.813', '-0.784', '-0.753', '-0.72', '-0.685', '-0.649',
+            '-0.611', '-0.572', '-0.531', '-0.489', '-0.446', '-0.402',
+            '-0.357', '-0.311', '-0.265', '-0.217', '-0.17', '-0.121',
+            '-0.073', '-0.0243', '0.0243', '0.073', '0.121', '0.17', '0.217',
+            '0.265', '0.311', '0.357', '0.402', '0.446', '0.489', '0.531',
+            '0.572', '0.611', '0.649', '0.685', '0.72', '0.753', '0.784',
+            '0.813', '0.841', '0.866', '0.889', '0.911', '0.93', '0.946',
+            '0.961', '0.973', '0.983', '0.991', '0.996', '0.999']
+
+def test_polyroots_legendre_init():
+    extra_prec = 100
+    coeffs = [11975573020964041433067793888190275875, 0,
+        -190100434726484311252477736051902332000, 0,
+        1437919688271127330313741595496589239248, 0,
+        -6897338342113537600691931230430793911840, 0,
+        23556405536185284408974715545252277554280, 0,
+        -60969520211303089058522793175947071316960, 0,
+        124284021969194758465450309166353645376880, 0,
+        -204721258548015217049921875719981284186016, 0,
+        277415422258095841688223780704620656114900, 0,
+        -313237834141273382807123548182995095192800, 0,
+        297432255354328395601259515935229287637200, 0,
+        -239057700565161140389797367947941296605600, 0,
+        163356095386193445933028201431093219347160, 0,
+        -95158890516229191805647495979277603503200, 0,
+        47310254620162038075933656063247634556400, 0,
+        -20071017111583894941305187420771723751200, 0,
+        7255051932731034189479516844750603752850, 0,
+        -2228176940331017311443863996901733412640, 0,
+        579006552594977616773047095969088431600, 0,
+        -126584428502545713788439446082310831200, 0,
+        23112325428835593809686977515028663000, 0,
+        -3491517141958743235617737161547844000, 0,
+        431305058712550634988073414073557200, 0,
+        -42927166660756742088912492757452000, 0,
+        3378527005707706553294038781836500, 0,
+        -205277590220215081719131470288800, 0,
+        9330799555464321896324157740400, 0,
+        -304114948474392713657972548576, 0,
+        6695289961520387531608984680, 0,
+        -91048139350447232095702560, 0,
+        659769125727878493447120, 0,
+        -1905929106580294155360, 0,
+        916312070471295267]
+
+    roots_init =  matrix(['-0.999', '-0.996',  '-0.991', '-0.983', '-0.973',
+                          '-0.961', '-0.946',  '-0.93',  '-0.911', '-0.889',
+                          '-0.866', '-0.841',  '-0.813', '-0.784', '-0.753',
+                          '-0.72',  '-0.685',  '-0.649', '-0.611', '-0.572',
+                          '-0.531', '-0.489',  '-0.446', '-0.402', '-0.357',
+                          '-0.311', '-0.265',  '-0.217', '-0.17',  '-0.121',
+                          '-0.073', '-0.0243',  '0.0243', '0.073',  '0.121',
+                          '0.17',    '0.217',   '0.265', ' 0.311',  '0.357',
+                          '0.402',   '0.446',   '0.489',  '0.531',  '0.572',
+                          '0.611',   '0.649',   '0.685',  '0.72',   '0.753',
+                          '0.784',   '0.813',   '0.841',  '0.866',  '0.889',
+                          '0.911',   '0.93',    '0.946',  '0.961',  '0.973',
+                          '0.983',   '0.991',   '0.996',  '0.999',  '1.0'])
+    with mp.workdps(2*mp.dps):
+        roots_exact = polyroots(coeffs, maxsteps=50, cleanup=True, error=False,
+                                extraprec=2*extra_prec)
+    with pytest.raises(mp.NoConvergence):
+        polyroots(coeffs, maxsteps=5, cleanup=True, error=False,
+                  extraprec=extra_prec)
+    roots,err = polyroots(coeffs, maxsteps=5, cleanup=True, error=True,
+                          extraprec=extra_prec,roots_init=roots_init)
+    assert max(matrix(roots_exact)-matrix(roots).apply(abs)) < err
+    roots1,err1 = polyroots(coeffs, maxsteps=25, cleanup=True, error=True,
+                            extraprec=extra_prec,roots_init=roots_init[:60])
+    assert max(matrix(roots_exact)-matrix(roots1).apply(abs)) < err1
+
+def test_pade():
+    one = mpf(1)
+    mp.dps = 20
+    N = 10
+    a = [one]
+    k = 1
+    for i in range(1, N+1):
+        k *= i
+        a.append(one/k)
+    p, q = pade(a, N//2, N//2)
+    for x in arange(0, 1, 0.1):
+        r = polyval(p[::-1], x)/polyval(q[::-1], x)
+        assert(r.ae(exp(x), 1.0e-10))
+    mp.dps = 15
+
+def test_fourier():
+    mp.dps = 15
+    c, s = fourier(lambda x: x+1, [-1, 2], 2)
+    #plot([lambda x: x+1, lambda x: fourierval((c, s), [-1, 2], x)], [-1, 2])
+    assert c[0].ae(1.5)
+    assert c[1].ae(-3*sqrt(3)/(2*pi))
+    assert c[2].ae(3*sqrt(3)/(4*pi))
+    assert s[0] == 0
+    assert s[1].ae(3/(2*pi))
+    assert s[2].ae(3/(4*pi))
+    assert fourierval((c, s), [-1, 2], 1).ae(1.9134966715663442)
+
+def test_differint():
+    mp.dps = 15
+    assert differint(lambda t: t, 2, -0.5).ae(8*sqrt(2/pi)/3)
+
+def test_invlap():
+    mp.dps = 15
+    t = 0.01
+    fp = lambda p: 1/(p+1)**2
+    ft = lambda t: t*exp(-t)
+    ftt = ft(t)
+    assert invertlaplace(fp,t,method='talbot').ae(ftt)
+    assert invertlaplace(fp,t,method='stehfest').ae(ftt)
+    assert invertlaplace(fp,t,method='dehoog').ae(ftt)
+    assert invertlaplace(fp,t,method='cohen').ae(ftt)
+    t = 1.0
+    ftt = ft(t)
+    assert invertlaplace(fp,t,method='talbot').ae(ftt)
+    assert invertlaplace(fp,t,method='stehfest').ae(ftt)
+    assert invertlaplace(fp,t,method='dehoog').ae(ftt)
+    assert invertlaplace(fp,t,method='cohen').ae(ftt)
+
+    t = 0.01
+    fp = lambda p: log(p)/p
+    ft = lambda t: -euler-log(t)
+    ftt = ft(t)
+    assert invertlaplace(fp,t,method='talbot').ae(ftt)
+    assert invertlaplace(fp,t,method='stehfest').ae(ftt)
+    assert invertlaplace(fp,t,method='dehoog').ae(ftt)
+    assert invertlaplace(fp,t,method='cohen').ae(ftt)
+    t = 1.0
+    ftt = ft(t)
+    assert invertlaplace(fp,t,method='talbot').ae(ftt)
+    assert invertlaplace(fp,t,method='stehfest').ae(ftt)
+    assert invertlaplace(fp,t,method='dehoog').ae(ftt)
+    assert invertlaplace(fp,t,method='cohen').ae(ftt)

llmeval-env/lib/python3.10/site-packages/mpmath/tests/test_compatibility.py

@@ -0,0 +1,77 @@
+from mpmath import *
+from random import seed, randint, random
+import math
+
+# Test compatibility with Python floats, which are
+# IEEE doubles (53-bit)
+
+N = 5000
+seed(1)
+
+# Choosing exponents between roughly -140, 140 ensures that
+# the Python floats don't overflow or underflow
+xs = [(random()-1) * 10**randint(-140, 140) for x in range(N)]
+ys = [(random()-1) * 10**randint(-140, 140) for x in range(N)]
+
+# include some equal values
+ys[int(N*0.8):] = xs[int(N*0.8):]
+
+# Detect whether Python is compiled to use 80-bit floating-point
+# instructions, in which case the double compatibility test breaks
+uses_x87 = -4.1974624032366689e+117 / -8.4657370748010221e-47 \
+    == 4.9581771393902231e+163
+
+def test_double_compatibility():
+    mp.prec = 53
+    for x, y in zip(xs, ys):
+        mpx = mpf(x)
+        mpy = mpf(y)
+        assert mpf(x) == x
+        assert (mpx < mpy) == (x < y)
+        assert (mpx > mpy) == (x > y)
+        assert (mpx == mpy) == (x == y)
+        assert (mpx != mpy) == (x != y)
+        assert (mpx <= mpy) == (x <= y)
+        assert (mpx >= mpy) == (x >= y)
+        assert mpx == mpx
+        if uses_x87:
+            mp.prec = 64
+            a = mpx + mpy
+            b = mpx * mpy
+            c = mpx / mpy
+            d = mpx % mpy
+            mp.prec = 53
+            assert +a == x + y
+            assert +b == x * y
+            assert +c == x / y
+            assert +d == x % y
+        else:
+            assert mpx + mpy == x + y
+            assert mpx * mpy == x * y
+            assert mpx / mpy == x / y
+            assert mpx % mpy == x % y
+        assert abs(mpx) == abs(x)
+        assert mpf(repr(x)) == x
+        assert ceil(mpx) == math.ceil(x)
+        assert floor(mpx) == math.floor(x)
+
+def test_sqrt():
+    # this fails quite often. it appers to be float
+    # that rounds the wrong way, not mpf
+    fail = 0
+    mp.prec = 53
+    for x in xs:
+        x = abs(x)
+        mp.prec = 100
+        mp_high = mpf(x)**0.5
+        mp.prec = 53
+        mp_low = mpf(x)**0.5
+        fp = x**0.5
+        assert abs(mp_low-mp_high) <= abs(fp-mp_high)
+        fail += mp_low != fp
+    assert fail < N/10
+
+def test_bugs():
+    # particular bugs
+    assert mpf(4.4408920985006262E-16) < mpf(1.7763568394002505E-15)
+    assert mpf(-4.4408920985006262E-16) > mpf(-1.7763568394002505E-15)

llmeval-env/lib/python3.10/site-packages/mpmath/tests/test_convert.py

@@ -0,0 +1,233 @@
+import random
+from mpmath import *
+from mpmath.libmp import *
+
+
+def test_basic_string():
+    """
+    Test basic string conversion
+    """
+    mp.dps = 15
+    assert mpf('3') == mpf('3.0') == mpf('0003.') == mpf('0.03e2') == mpf(3.0)
+    assert mpf('30') == mpf('30.0') == mpf('00030.') == mpf(30.0)
+    for i in range(10):
+        for j in range(10):
+            assert mpf('%ie%i' % (i,j)) == i * 10**j
+    assert str(mpf('25000.0')) == '25000.0'
+    assert str(mpf('2500.0')) == '2500.0'
+    assert str(mpf('250.0')) == '250.0'
+    assert str(mpf('25.0')) == '25.0'
+    assert str(mpf('2.5')) == '2.5'
+    assert str(mpf('0.25')) == '0.25'
+    assert str(mpf('0.025')) == '0.025'
+    assert str(mpf('0.0025')) == '0.0025'
+    assert str(mpf('0.00025')) == '0.00025'
+    assert str(mpf('0.000025')) == '2.5e-5'
+    assert str(mpf(0)) == '0.0'
+    assert str(mpf('2.5e1000000000000000000000')) == '2.5e+1000000000000000000000'
+    assert str(mpf('2.6e-1000000000000000000000')) == '2.6e-1000000000000000000000'
+    assert str(mpf(1.23402834e-15)) == '1.23402834e-15'
+    assert str(mpf(-1.23402834e-15)) == '-1.23402834e-15'
+    assert str(mpf(-1.2344e-15)) == '-1.2344e-15'
+    assert repr(mpf(-1.2344e-15)) == "mpf('-1.2343999999999999e-15')"
+    assert str(mpf("2163048125L")) == '2163048125.0'
+    assert str(mpf("-2163048125l")) == '-2163048125.0'
+    assert str(mpf("-2163048125L/1088391168")) == '-1.98738118113799'
+    assert str(mpf("2163048125/1088391168l")) == '1.98738118113799'
+
+def test_pretty():
+    mp.pretty = True
+    assert repr(mpf(2.5)) == '2.5'
+    assert repr(mpc(2.5,3.5)) == '(2.5 + 3.5j)'
+    mp.pretty = False
+    iv.pretty = True
+    assert repr(mpi(2.5,3.5)) == '[2.5, 3.5]'
+    iv.pretty = False
+
+def test_str_whitespace():
+    assert mpf('1.26 ') == 1.26
+
+def test_unicode():
+    mp.dps = 15
+    try:
+        unicode = unicode
+    except NameError:
+        unicode = str
+    assert mpf(unicode('2.76')) == 2.76
+    assert mpf(unicode('inf')) == inf
+
+def test_str_format():
+    assert to_str(from_float(0.1),15,strip_zeros=False) == '0.100000000000000'
+    assert to_str(from_float(0.0),15,show_zero_exponent=True) == '0.0e+0'
+    assert to_str(from_float(0.0),0,show_zero_exponent=True) == '.0e+0'
+    assert to_str(from_float(0.0),0,show_zero_exponent=False) == '.0'
+    assert to_str(from_float(0.0),1,show_zero_exponent=True) == '0.0e+0'
+    assert to_str(from_float(0.0),1,show_zero_exponent=False) == '0.0'
+    assert to_str(from_float(1.23),3,show_zero_exponent=True) == '1.23e+0'
+    assert to_str(from_float(1.23456789000000e-2),15,strip_zeros=False,min_fixed=0,max_fixed=0) == '1.23456789000000e-2'
+    assert to_str(from_float(1.23456789000000e+2),15,strip_zeros=False,min_fixed=0,max_fixed=0) == '1.23456789000000e+2'
+    assert to_str(from_float(2.1287e14), 15, max_fixed=1000) == '212870000000000.0'
+    assert to_str(from_float(2.1287e15), 15, max_fixed=1000) == '2128700000000000.0'
+    assert to_str(from_float(2.1287e16), 15, max_fixed=1000) == '21287000000000000.0'
+    assert to_str(from_float(2.1287e30), 15, max_fixed=1000) == '2128700000000000000000000000000.0'
+
+def test_tight_string_conversion():
+    mp.dps = 15
+    # In an old version, '0.5' wasn't recognized as representing
+    # an exact binary number and was erroneously rounded up or down
+    assert from_str('0.5', 10, round_floor) == fhalf
+    assert from_str('0.5', 10, round_ceiling) == fhalf
+
+def test_eval_repr_invariant():
+    """Test that eval(repr(x)) == x"""
+    random.seed(123)
+    for dps in [10, 15, 20, 50, 100]:
+        mp.dps = dps
+        for i in range(1000):
+            a = mpf(random.random())**0.5 * 10**random.randint(-100, 100)
+            assert eval(repr(a)) == a
+    mp.dps = 15
+
+def test_str_bugs():
+    mp.dps = 15
+    # Decimal rounding used to give the wrong exponent in some cases
+    assert str(mpf('1e600')) == '1.0e+600'
+    assert str(mpf('1e10000')) == '1.0e+10000'
+
+def test_str_prec0():
+    assert to_str(from_float(1.234), 0) == '.0e+0'
+    assert to_str(from_float(1e-15), 0) == '.0e-15'
+    assert to_str(from_float(1e+15), 0) == '.0e+15'
+    assert to_str(from_float(-1e-15), 0) == '-.0e-15'
+    assert to_str(from_float(-1e+15), 0) == '-.0e+15'
+
+def test_convert_rational():
+    mp.dps = 15
+    assert from_rational(30, 5, 53, round_nearest) == (0, 3, 1, 2)
+    assert from_rational(-7, 4, 53, round_nearest) == (1, 7, -2, 3)
+    assert to_rational((0, 1, -1, 1)) == (1, 2)
+
+def test_custom_class():
+    class mympf:
+        @property
+        def _mpf_(self):
+            return mpf(3.5)._mpf_
+    class mympc:
+        @property
+        def _mpc_(self):
+            return mpf(3.5)._mpf_, mpf(2.5)._mpf_
+    assert mpf(2) + mympf() == 5.5
+    assert mympf() + mpf(2) == 5.5
+    assert mpf(mympf()) == 3.5
+    assert mympc() + mpc(2) == mpc(5.5, 2.5)
+    assert mpc(2) + mympc() == mpc(5.5, 2.5)
+    assert mpc(mympc()) == (3.5+2.5j)
+
+def test_conversion_methods():
+    class SomethingRandom:
+        pass
+    class SomethingReal:
+        def _mpmath_(self, prec, rounding):
+            return mp.make_mpf(from_str('1.3', prec, rounding))
+    class SomethingComplex:
+        def _mpmath_(self, prec, rounding):
+            return mp.make_mpc((from_str('1.3', prec, rounding), \
+                from_str('1.7', prec, rounding)))
+    x = mpf(3)
+    z = mpc(3)
+    a = SomethingRandom()
+    y = SomethingReal()
+    w = SomethingComplex()
+    for d in [15, 45]:
+        mp.dps = d
+        assert (x+y).ae(mpf('4.3'))
+        assert (y+x).ae(mpf('4.3'))
+        assert (x+w).ae(mpc('4.3', '1.7'))
+        assert (w+x).ae(mpc('4.3', '1.7'))
+        assert (z+y).ae(mpc('4.3'))
+        assert (y+z).ae(mpc('4.3'))
+        assert (z+w).ae(mpc('4.3', '1.7'))
+        assert (w+z).ae(mpc('4.3', '1.7'))
+        x-y; y-x; x-w; w-x; z-y; y-z; z-w; w-z
+        x*y; y*x; x*w; w*x; z*y; y*z; z*w; w*z
+        x/y; y/x; x/w; w/x; z/y; y/z; z/w; w/z
+        x**y; y**x; x**w; w**x; z**y; y**z; z**w; w**z
+        x==y; y==x; x==w; w==x; z==y; y==z; z==w; w==z
+    mp.dps = 15
+    assert x.__add__(a) is NotImplemented
+    assert x.__radd__(a) is NotImplemented
+    assert x.__lt__(a) is NotImplemented
+    assert x.__gt__(a) is NotImplemented
+    assert x.__le__(a) is NotImplemented
+    assert x.__ge__(a) is NotImplemented
+    assert x.__eq__(a) is NotImplemented
+    assert x.__ne__(a) is NotImplemented
+    # implementation detail
+    if hasattr(x, "__cmp__"):
+        assert x.__cmp__(a) is NotImplemented
+    assert x.__sub__(a) is NotImplemented
+    assert x.__rsub__(a) is NotImplemented
+    assert x.__mul__(a) is NotImplemented
+    assert x.__rmul__(a) is NotImplemented
+    assert x.__div__(a) is NotImplemented
+    assert x.__rdiv__(a) is NotImplemented
+    assert x.__mod__(a) is NotImplemented
+    assert x.__rmod__(a) is NotImplemented
+    assert x.__pow__(a) is NotImplemented
+    assert x.__rpow__(a) is NotImplemented
+    assert z.__add__(a) is NotImplemented
+    assert z.__radd__(a) is NotImplemented
+    assert z.__eq__(a) is NotImplemented
+    assert z.__ne__(a) is NotImplemented
+    assert z.__sub__(a) is NotImplemented
+    assert z.__rsub__(a) is NotImplemented
+    assert z.__mul__(a) is NotImplemented
+    assert z.__rmul__(a) is NotImplemented
+    assert z.__div__(a) is NotImplemented
+    assert z.__rdiv__(a) is NotImplemented
+    assert z.__pow__(a) is NotImplemented
+    assert z.__rpow__(a) is NotImplemented
+
+def test_mpmathify():
+    assert mpmathify('1/2') == 0.5
+    assert mpmathify('(1.0+1.0j)') == mpc(1, 1)
+    assert mpmathify('(1.2e-10 - 3.4e5j)') == mpc('1.2e-10', '-3.4e5')
+    assert mpmathify('1j') == mpc(1j)
+
+def test_issue548():
+    try:
+        # This expression is invalid, but may trigger the ReDOS vulnerability
+        # in the regular expression for parsing complex numbers.
+        mpmathify('(' + '1' * 5000 + '!j')
+    except:
+        return
+    # The expression is invalid and should raise an exception.
+    assert False
+
+def test_compatibility():
+    try:
+        import numpy as np
+        from fractions import Fraction
+        from decimal import Decimal
+        import decimal
+    except ImportError:
+        return
+    # numpy types
+    for nptype in np.core.numerictypes.typeDict.values():
+        if issubclass(nptype, np.complexfloating):
+            x = nptype(complex(0.5, -0.5))
+        elif issubclass(nptype, np.floating):
+            x = nptype(0.5)
+        elif issubclass(nptype, np.integer):
+            x = nptype(2)
+        # Handle the weird types
+        try: diff = np.abs(type(np.sqrt(x))(sqrt(x)) - np.sqrt(x))
+        except: continue
+        assert diff < 2.0**-53
+    #Fraction and Decimal
+    oldprec = mp.prec
+    mp.prec = 1000
+    decimal.getcontext().prec = mp.dps
+    assert sqrt(Fraction(2, 3)).ae(sqrt(mpf('2/3')))
+    assert sqrt(Decimal(2)/Decimal(3)).ae(sqrt(mpf('2/3')))
+    mp.prec = oldprec

llmeval-env/lib/python3.10/site-packages/mpmath/tests/test_diff.py

@@ -0,0 +1,61 @@
+from mpmath import *
+
+def test_diff():
+    mp.dps = 15
+    assert diff(log, 2.0, n=0).ae(log(2))
+    assert diff(cos, 1.0).ae(-sin(1))
+    assert diff(abs, 0.0) == 0
+    assert diff(abs, 0.0, direction=1) == 1
+    assert diff(abs, 0.0, direction=-1) == -1
+    assert diff(exp, 1.0).ae(e)
+    assert diff(exp, 1.0, n=5).ae(e)
+    assert diff(exp, 2.0, n=5, direction=3*j).ae(e**2)
+    assert diff(lambda x: x**2, 3.0, method='quad').ae(6)
+    assert diff(lambda x: 3+x**5, 3.0, n=2, method='quad').ae(540)
+    assert diff(lambda x: 3+x**5, 3.0, n=2, method='step').ae(540)
+    assert diffun(sin)(2).ae(cos(2))
+    assert diffun(sin, n=2)(2).ae(-sin(2))
+
+def test_diffs():
+    mp.dps = 15
+    assert [chop(d) for d in diffs(sin, 0, 1)] == [0, 1]
+    assert [chop(d) for d in diffs(sin, 0, 1, method='quad')] == [0, 1]
+    assert [chop(d) for d in diffs(sin, 0, 2)] == [0, 1, 0]
+    assert [chop(d) for d in diffs(sin, 0, 2, method='quad')] == [0, 1, 0]
+
+def test_taylor():
+    mp.dps = 15
+    # Easy to test since the coefficients are exact in floating-point
+    assert taylor(sqrt, 1, 4) == [1, 0.5, -0.125, 0.0625, -0.0390625]
+
+def test_diff_partial():
+    mp.dps = 15
+    x,y,z = xyz = 2,3,7
+    f = lambda x,y,z: 3*x**2 * (y+2)**3 * z**5
+    assert diff(f, xyz, (0,0,0)).ae(25210500)
+    assert diff(f, xyz, (0,0,1)).ae(18007500)
+    assert diff(f, xyz, (0,0,2)).ae(10290000)
+    assert diff(f, xyz, (0,1,0)).ae(15126300)
+    assert diff(f, xyz, (0,1,1)).ae(10804500)
+    assert diff(f, xyz, (0,1,2)).ae(6174000)
+    assert diff(f, xyz, (0,2,0)).ae(6050520)
+    assert diff(f, xyz, (0,2,1)).ae(4321800)
+    assert diff(f, xyz, (0,2,2)).ae(2469600)
+    assert diff(f, xyz, (1,0,0)).ae(25210500)
+    assert diff(f, xyz, (1,0,1)).ae(18007500)
+    assert diff(f, xyz, (1,0,2)).ae(10290000)
+    assert diff(f, xyz, (1,1,0)).ae(15126300)
+    assert diff(f, xyz, (1,1,1)).ae(10804500)
+    assert diff(f, xyz, (1,1,2)).ae(6174000)
+    assert diff(f, xyz, (1,2,0)).ae(6050520)
+    assert diff(f, xyz, (1,2,1)).ae(4321800)
+    assert diff(f, xyz, (1,2,2)).ae(2469600)
+    assert diff(f, xyz, (2,0,0)).ae(12605250)
+    assert diff(f, xyz, (2,0,1)).ae(9003750)
+    assert diff(f, xyz, (2,0,2)).ae(5145000)
+    assert diff(f, xyz, (2,1,0)).ae(7563150)
+    assert diff(f, xyz, (2,1,1)).ae(5402250)
+    assert diff(f, xyz, (2,1,2)).ae(3087000)
+    assert diff(f, xyz, (2,2,0)).ae(3025260)
+    assert diff(f, xyz, (2,2,1)).ae(2160900)
+    assert diff(f, xyz, (2,2,2)).ae(1234800)

llmeval-env/lib/python3.10/site-packages/mpmath/tests/test_division.py

@@ -0,0 +1,143 @@
+from mpmath.libmp import *
+from mpmath import mpf, mp
+
+from random import randint, choice, seed
+
+all_modes = [round_floor, round_ceiling, round_down, round_up, round_nearest]
+
+fb = from_bstr
+fi = from_int
+ff = from_float
+
+
+def test_div_1_3():
+    a = fi(1)
+    b = fi(3)
+    c = fi(-1)
+
+    # floor rounds down, ceiling rounds up
+    assert mpf_div(a, b, 7, round_floor)   == fb('0.01010101')
+    assert mpf_div(a, b, 7, round_ceiling) == fb('0.01010110')
+    assert mpf_div(a, b, 7, round_down)    == fb('0.01010101')
+    assert mpf_div(a, b, 7, round_up)      == fb('0.01010110')
+    assert mpf_div(a, b, 7, round_nearest) == fb('0.01010101')
+
+    # floor rounds up, ceiling rounds down
+    assert mpf_div(c, b, 7, round_floor)   == fb('-0.01010110')
+    assert mpf_div(c, b, 7, round_ceiling) == fb('-0.01010101')
+    assert mpf_div(c, b, 7, round_down)    == fb('-0.01010101')
+    assert mpf_div(c, b, 7, round_up)      == fb('-0.01010110')
+    assert mpf_div(c, b, 7, round_nearest) == fb('-0.01010101')
+
+def test_mpf_divi_1_3():
+    a = 1
+    b = fi(3)
+    c = -1
+    assert mpf_rdiv_int(a, b, 7, round_floor)   == fb('0.01010101')
+    assert mpf_rdiv_int(a, b, 7, round_ceiling) == fb('0.01010110')
+    assert mpf_rdiv_int(a, b, 7, round_down)    == fb('0.01010101')
+    assert mpf_rdiv_int(a, b, 7, round_up)      == fb('0.01010110')
+    assert mpf_rdiv_int(a, b, 7, round_nearest) == fb('0.01010101')
+    assert mpf_rdiv_int(c, b, 7, round_floor)   == fb('-0.01010110')
+    assert mpf_rdiv_int(c, b, 7, round_ceiling) == fb('-0.01010101')
+    assert mpf_rdiv_int(c, b, 7, round_down)    == fb('-0.01010101')
+    assert mpf_rdiv_int(c, b, 7, round_up)      == fb('-0.01010110')
+    assert mpf_rdiv_int(c, b, 7, round_nearest) == fb('-0.01010101')
+
+
+def test_div_300():
+
+    q = fi(1000000)
+    a = fi(300499999)    # a/q is a little less than a half-integer
+    b = fi(300500000)    # b/q exactly a half-integer
+    c = fi(300500001)    # c/q is a little more than a half-integer
+
+    # Check nearest integer rounding (prec=9 as 2**8 < 300 < 2**9)
+
+    assert mpf_div(a, q, 9, round_down) == fi(300)
+    assert mpf_div(b, q, 9, round_down) == fi(300)
+    assert mpf_div(c, q, 9, round_down) == fi(300)
+    assert mpf_div(a, q, 9, round_up) == fi(301)
+    assert mpf_div(b, q, 9, round_up) == fi(301)
+    assert mpf_div(c, q, 9, round_up) == fi(301)
+
+    # Nearest even integer is down
+    assert mpf_div(a, q, 9, round_nearest) == fi(300)
+    assert mpf_div(b, q, 9, round_nearest) == fi(300)
+    assert mpf_div(c, q, 9, round_nearest) == fi(301)
+
+    # Nearest even integer is up
+    a = fi(301499999)
+    b = fi(301500000)
+    c = fi(301500001)
+    assert mpf_div(a, q, 9, round_nearest) == fi(301)
+    assert mpf_div(b, q, 9, round_nearest) == fi(302)
+    assert mpf_div(c, q, 9, round_nearest) == fi(302)
+
+
+def test_tight_integer_division():
+    # Test that integer division at tightest possible precision is exact
+    N = 100
+    seed(1)
+    for i in range(N):
+        a = choice([1, -1]) * randint(1, 1<<randint(10, 100))
+        b = choice([1, -1]) * randint(1, 1<<randint(10, 100))
+        p = a * b
+        width = bitcount(abs(b)) - trailing(b)
+        a = fi(a); b = fi(b); p = fi(p)
+        for mode in all_modes:
+            assert mpf_div(p, a, width, mode) == b
+
+
+def test_epsilon_rounding():
+    # Verify that mpf_div uses infinite precision; this result will
+    # appear to be exactly 0.101 to a near-sighted algorithm
+
+    a = fb('0.101' + ('0'*200) + '1')
+    b = fb('1.10101')
+    c = mpf_mul(a, b, 250, round_floor) # exact
+    assert mpf_div(c, b, bitcount(a[1]), round_floor) == a # exact
+
+    assert mpf_div(c, b, 2, round_down) == fb('0.10')
+    assert mpf_div(c, b, 3, round_down) == fb('0.101')
+    assert mpf_div(c, b, 2, round_up) == fb('0.11')
+    assert mpf_div(c, b, 3, round_up) == fb('0.110')
+    assert mpf_div(c, b, 2, round_floor) == fb('0.10')
+    assert mpf_div(c, b, 3, round_floor) == fb('0.101')
+    assert mpf_div(c, b, 2, round_ceiling) == fb('0.11')
+    assert mpf_div(c, b, 3, round_ceiling) == fb('0.110')
+
+    # The same for negative numbers
+    a = fb('-0.101' + ('0'*200) + '1')
+    b = fb('1.10101')
+    c = mpf_mul(a, b, 250, round_floor)
+    assert mpf_div(c, b, bitcount(a[1]), round_floor) == a
+
+    assert mpf_div(c, b, 2, round_down) == fb('-0.10')
+    assert mpf_div(c, b, 3, round_up) == fb('-0.110')
+
+    # Floor goes up, ceiling goes down
+    assert mpf_div(c, b, 2, round_floor) == fb('-0.11')
+    assert mpf_div(c, b, 3, round_floor) == fb('-0.110')
+    assert mpf_div(c, b, 2, round_ceiling) == fb('-0.10')
+    assert mpf_div(c, b, 3, round_ceiling) == fb('-0.101')
+
+
+def test_mod():
+    mp.dps = 15
+    assert mpf(234) % 1 == 0
+    assert mpf(-3) % 256 == 253
+    assert mpf(0.25) % 23490.5 == 0.25
+    assert mpf(0.25) % -23490.5 == -23490.25
+    assert mpf(-0.25) % 23490.5 == 23490.25
+    assert mpf(-0.25) % -23490.5 == -0.25
+    # Check that these cases are handled efficiently
+    assert mpf('1e10000000000') % 1 == 0
+    assert mpf('1.23e-1000000000') % 1 == mpf('1.23e-1000000000')
+    # test __rmod__
+    assert 3 % mpf('1.75') == 1.25
+
+def test_div_negative_rnd_bug():
+    mp.dps = 15
+    assert (-3) / mpf('0.1531879017645047') == mpf('-19.583791966887116')
+    assert mpf('-2.6342475750861301') / mpf('0.35126216427941814') == mpf('-7.4993775104985909')

llmeval-env/lib/python3.10/site-packages/mpmath/tests/test_eigen.py

@@ -0,0 +1,179 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+from mpmath import mp
+from mpmath import libmp
+
+xrange = libmp.backend.xrange
+
+def run_hessenberg(A, verbose = 0):
+    if verbose > 1:
+        print("original matrix (hessenberg):\n", A)
+
+    n = A.rows
+
+    Q, H = mp.hessenberg(A)
+
+    if verbose > 1:
+        print("Q:\n",Q)
+        print("H:\n",H)
+
+    B = Q * H * Q.transpose_conj()
+
+    eps = mp.exp(0.8 * mp.log(mp.eps))
+
+    err0 = 0
+    for x in xrange(n):
+        for y in xrange(n):
+            err0 += abs(A[y,x] - B[y,x])
+    err0 /= n * n
+
+    err1 = 0
+    for x in xrange(n):
+        for y in xrange(x + 2, n):
+            err1 += abs(H[y,x])
+
+    if verbose > 0:
+        print("difference (H):", err0, err1)
+
+    if verbose > 1:
+        print("B:\n", B)
+
+    assert err0 < eps
+    assert err1 == 0
+
+
+def run_schur(A, verbose = 0):
+    if verbose > 1:
+        print("original matrix (schur):\n", A)
+
+    n = A.rows
+
+    Q, R = mp.schur(A)
+
+    if verbose > 1:
+        print("Q:\n", Q)
+        print("R:\n", R)
+
+    B = Q * R * Q.transpose_conj()
+    C = Q * Q.transpose_conj()
+
+    eps = mp.exp(0.8 * mp.log(mp.eps))
+
+    err0 = 0
+    for x in xrange(n):
+        for y in xrange(n):
+            err0 += abs(A[y,x] - B[y,x])
+    err0 /= n * n
+
+    err1 = 0
+    for x in xrange(n):
+        for y in xrange(n):
+            if x == y:
+                C[y,x] -= 1
+            err1 += abs(C[y,x])
+    err1 /= n * n
+
+    err2 = 0
+    for x in xrange(n):
+        for y in xrange(x + 1, n):
+            err2 += abs(R[y,x])
+
+    if verbose > 0:
+        print("difference (S):", err0, err1, err2)
+
+    if verbose > 1:
+        print("B:\n", B)
+
+    assert err0 < eps
+    assert err1 < eps
+    assert err2 == 0
+
+def run_eig(A, verbose = 0):
+    if verbose > 1:
+        print("original matrix (eig):\n", A)
+
+    n = A.rows
+
+    E, EL, ER = mp.eig(A, left = True, right = True)
+
+    if verbose > 1:
+        print("E:\n", E)
+        print("EL:\n", EL)
+        print("ER:\n", ER)
+
+    eps = mp.exp(0.8 * mp.log(mp.eps))
+
+    err0 = 0
+    for i in xrange(n):
+        B = A * ER[:,i] - E[i] * ER[:,i]
+        err0 = max(err0, mp.mnorm(B))
+
+        B = EL[i,:] * A - EL[i,:] * E[i]
+        err0 = max(err0, mp.mnorm(B))
+
+    err0 /= n * n
+
+    if verbose > 0:
+        print("difference (E):", err0)
+
+    assert err0 < eps
+
+#####################
+
+def test_eig_dyn():
+    v = 0
+    for i in xrange(5):
+        n = 1 + int(mp.rand() * 5)
+        if mp.rand() > 0.5:
+            # real
+            A = 2 * mp.randmatrix(n, n) - 1
+            if mp.rand() > 0.5:
+                A *= 10
+                for x in xrange(n):
+                    for y in xrange(n):
+                        A[x,y] = int(A[x,y])
+        else:
+            A = (2 * mp.randmatrix(n, n) - 1) + 1j * (2 * mp.randmatrix(n, n) - 1)
+            if mp.rand() > 0.5:
+                A *= 10
+                for x in xrange(n):
+                    for y in xrange(n):
+                        A[x,y] = int(mp.re(A[x,y])) + 1j * int(mp.im(A[x,y]))
+
+        run_hessenberg(A, verbose = v)
+        run_schur(A, verbose = v)
+        run_eig(A, verbose = v)
+
+def test_eig():
+    v = 0
+    AS = []
+
+    A = mp.matrix([[2, 1, 0],  # jordan block of size 3
+                   [0, 2, 1],
+                   [0, 0, 2]])
+    AS.append(A)
+    AS.append(A.transpose())
+
+    A = mp.matrix([[2, 0, 0],  # jordan block of size 2
+                   [0, 2, 1],
+                   [0, 0, 2]])
+    AS.append(A)
+    AS.append(A.transpose())
+
+    A = mp.matrix([[2, 0, 1],  # jordan block of size 2
+                   [0, 2, 0],
+                   [0, 0, 2]])
+    AS.append(A)
+    AS.append(A.transpose())
+
+    A=  mp.matrix([[0, 0, 1],  # cyclic
+                   [1, 0, 0],
+                   [0, 1, 0]])
+    AS.append(A)
+    AS.append(A.transpose())
+
+    for A in AS:
+        run_hessenberg(A, verbose = v)
+        run_schur(A, verbose = v)
+        run_eig(A, verbose = v)

llmeval-env/lib/python3.10/site-packages/mpmath/tests/test_eigen_symmetric.py

@@ -0,0 +1,357 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+from mpmath import mp
+from mpmath import libmp
+
+xrange = libmp.backend.xrange
+
+def run_eigsy(A, verbose = False):
+    if verbose:
+        print("original matrix:\n", str(A))
+
+    D, Q = mp.eigsy(A)
+    B = Q * mp.diag(D) * Q.transpose()
+    C = A - B
+    E = Q * Q.transpose() - mp.eye(A.rows)
+
+    if verbose:
+        print("eigenvalues:\n", D)
+        print("eigenvectors:\n", Q)
+
+    NC = mp.mnorm(C)
+    NE = mp.mnorm(E)
+
+    if verbose:
+        print("difference:", NC, "\n", C, "\n")
+        print("difference:", NE, "\n", E, "\n")
+
+    eps = mp.exp( 0.8 * mp.log(mp.eps))
+
+    assert NC < eps
+    assert NE < eps
+
+    return NC
+
+def run_eighe(A, verbose = False):
+    if verbose:
+        print("original matrix:\n", str(A))
+
+    D, Q = mp.eighe(A)
+    B = Q * mp.diag(D) * Q.transpose_conj()
+    C = A - B
+    E = Q * Q.transpose_conj() - mp.eye(A.rows)
+
+    if verbose:
+        print("eigenvalues:\n", D)
+        print("eigenvectors:\n", Q)
+
+    NC = mp.mnorm(C)
+    NE = mp.mnorm(E)
+
+    if verbose:
+        print("difference:", NC, "\n", C, "\n")
+        print("difference:", NE, "\n", E, "\n")
+
+    eps = mp.exp( 0.8 * mp.log(mp.eps))
+
+    assert NC < eps
+    assert NE < eps
+
+    return NC
+
+def run_svd_r(A, full_matrices = False, verbose = True):
+
+    m, n = A.rows, A.cols
+
+    eps = mp.exp(0.8 * mp.log(mp.eps))
+
+    if verbose:
+        print("original matrix:\n", str(A))
+        print("full", full_matrices)
+
+    U, S0, V = mp.svd_r(A, full_matrices = full_matrices)
+
+    S = mp.zeros(U.cols, V.rows)
+    for j in xrange(min(m, n)):
+        S[j,j] = S0[j]
+
+    if verbose:
+        print("U:\n", str(U))
+        print("S:\n", str(S0))
+        print("V:\n", str(V))
+
+    C = U * S * V - A
+    err = mp.mnorm(C)
+    if verbose:
+        print("C\n", str(C), "\n", err)
+    assert err < eps
+
+    D = V * V.transpose() - mp.eye(V.rows)
+    err = mp.mnorm(D)
+    if verbose:
+        print("D:\n", str(D), "\n", err)
+    assert err < eps
+
+    E = U.transpose() * U - mp.eye(U.cols)
+    err = mp.mnorm(E)
+    if verbose:
+        print("E:\n", str(E), "\n", err)
+    assert err < eps
+
+def run_svd_c(A, full_matrices = False, verbose = True):
+
+    m, n = A.rows, A.cols
+
+    eps = mp.exp(0.8 * mp.log(mp.eps))
+
+    if verbose:
+        print("original matrix:\n", str(A))
+        print("full", full_matrices)
+
+    U, S0, V = mp.svd_c(A, full_matrices = full_matrices)
+
+    S = mp.zeros(U.cols, V.rows)
+    for j in xrange(min(m, n)):
+        S[j,j] = S0[j]
+
+    if verbose:
+        print("U:\n", str(U))
+        print("S:\n", str(S0))
+        print("V:\n", str(V))
+
+    C = U * S * V - A
+    err = mp.mnorm(C)
+    if verbose:
+        print("C\n", str(C), "\n", err)
+    assert err  < eps
+
+    D = V * V.transpose_conj() - mp.eye(V.rows)
+    err = mp.mnorm(D)
+    if verbose:
+        print("D:\n", str(D), "\n", err)
+    assert err < eps
+
+    E = U.transpose_conj() * U - mp.eye(U.cols)
+    err = mp.mnorm(E)
+    if verbose:
+        print("E:\n", str(E), "\n", err)
+    assert err < eps
+
+def run_gauss(qtype, a, b):
+    eps = 1e-5
+
+    d, e = mp.gauss_quadrature(len(a), qtype)
+    d -= mp.matrix(a)
+    e -= mp.matrix(b)
+
+    assert mp.mnorm(d) < eps
+    assert mp.mnorm(e) < eps
+
+def irandmatrix(n, range = 10):
+    """
+    random matrix with integer entries
+    """
+    A = mp.matrix(n, n)
+    for i in xrange(n):
+        for j in xrange(n):
+            A[i,j]=int( (2 * mp.rand() - 1) * range)
+    return A
+
+#######################
+
+def test_eighe_fixed_matrix():
+    A = mp.matrix([[2, 3], [3, 5]])
+    run_eigsy(A)
+    run_eighe(A)
+
+    A = mp.matrix([[7, -11], [-11, 13]])
+    run_eigsy(A)
+    run_eighe(A)
+
+    A = mp.matrix([[2, 11, 7], [11, 3, 13], [7, 13, 5]])
+    run_eigsy(A)
+    run_eighe(A)
+
+    A = mp.matrix([[2, 0, 7], [0, 3, 1], [7, 1, 5]])
+    run_eigsy(A)
+    run_eighe(A)
+
+    #
+
+    A = mp.matrix([[2, 3+7j], [3-7j, 5]])
+    run_eighe(A)
+
+    A = mp.matrix([[2, -11j, 0], [+11j, 3, 29j], [0, -29j, 5]])
+    run_eighe(A)
+
+    A = mp.matrix([[2, 11 + 17j, 7 + 19j], [11 - 17j, 3, -13 + 23j], [7 - 19j, -13 - 23j, 5]])
+    run_eighe(A)
+
+def test_eigsy_randmatrix():
+    N = 5
+
+    for a in xrange(10):
+        A = 2 * mp.randmatrix(N, N) - 1
+
+        for i in xrange(0, N):
+            for j in xrange(i + 1, N):
+                A[j,i] = A[i,j]
+
+        run_eigsy(A)
+
+def test_eighe_randmatrix():
+    N = 5
+
+    for a in xrange(10):
+        A = (2 * mp.randmatrix(N, N) - 1) + 1j * (2 * mp.randmatrix(N, N) - 1)
+
+        for i in xrange(0, N):
+            A[i,i] = mp.re(A[i,i])
+            for j in xrange(i + 1, N):
+                A[j,i] = mp.conj(A[i,j])
+
+        run_eighe(A)
+
+def test_eigsy_irandmatrix():
+    N = 4
+    R = 4
+
+    for a in xrange(10):
+        A=irandmatrix(N, R)
+
+        for i in xrange(0, N):
+            for j in xrange(i + 1, N):
+                A[j,i] = A[i,j]
+
+        run_eigsy(A)
+
+def test_eighe_irandmatrix():
+    N = 4
+    R = 4
+
+    for a in xrange(10):
+        A=irandmatrix(N, R) + 1j * irandmatrix(N, R)
+
+        for i in xrange(0, N):
+            A[i,i] = mp.re(A[i,i])
+            for j in xrange(i + 1, N):
+                A[j,i] = mp.conj(A[i,j])
+
+        run_eighe(A)
+
+def test_svd_r_rand():
+    for i in xrange(5):
+        full = mp.rand() > 0.5
+        m = 1 + int(mp.rand() * 10)
+        n = 1 + int(mp.rand() * 10)
+        A = 2 * mp.randmatrix(m, n) - 1
+        if mp.rand() > 0.5:
+            A *= 10
+            for x in xrange(m):
+                for y in xrange(n):
+                    A[x,y]=int(A[x,y])
+
+        run_svd_r(A, full_matrices = full, verbose = False)
+
+def test_svd_c_rand():
+    for i in xrange(5):
+        full = mp.rand() > 0.5
+        m = 1 + int(mp.rand() * 10)
+        n = 1 + int(mp.rand() * 10)
+        A = (2 * mp.randmatrix(m, n) - 1) + 1j * (2 * mp.randmatrix(m, n) - 1)
+        if mp.rand() > 0.5:
+            A *= 10
+            for x in xrange(m):
+                for y in xrange(n):
+                    A[x,y]=int(mp.re(A[x,y])) + 1j * int(mp.im(A[x,y]))
+
+        run_svd_c(A, full_matrices=full, verbose=False)
+
+def test_svd_test_case():
+    # a test case from Golub and Reinsch
+    #  (see wilkinson/reinsch: handbook for auto. comp., vol ii-linear algebra, 134-151(1971).)
+
+    eps = mp.exp(0.8 * mp.log(mp.eps))
+
+    a = [[22, 10,  2,   3,  7],
+         [14,  7, 10,   0,  8],
+         [-1, 13, -1, -11,  3],
+         [-3, -2, 13,  -2,  4],
+         [ 9,  8,  1,  -2,  4],
+         [ 9,  1, -7,   5, -1],
+         [ 2, -6,  6,   5,  1],
+         [ 4,  5,  0,  -2,  2]]
+
+    a = mp.matrix(a)
+    b = mp.matrix([mp.sqrt(1248), 20, mp.sqrt(384), 0, 0])
+
+    S = mp.svd_r(a, compute_uv = False)
+    S -= b
+    assert mp.mnorm(S) < eps
+
+    S = mp.svd_c(a, compute_uv = False)
+    S -= b
+    assert mp.mnorm(S) < eps
+
+
+def test_gauss_quadrature_static():
+    a = [-0.57735027,  0.57735027]
+    b = [ 1,  1]
+    run_gauss("legendre", a , b)
+
+    a = [ -0.906179846,  -0.538469310,   0,           0.538469310,   0.906179846]
+    b = [  0.23692689,    0.47862867,    0.56888889,  0.47862867,    0.23692689]
+    run_gauss("legendre", a , b)
+
+    a = [ 0.06943184,  0.33000948,  0.66999052,  0.93056816]
+    b = [ 0.17392742,  0.32607258,  0.32607258,  0.17392742]
+    run_gauss("legendre01", a , b)
+
+    a = [-0.70710678,  0.70710678]
+    b = [ 0.88622693,  0.88622693]
+    run_gauss("hermite", a , b)
+
+    a = [ -2.02018287,  -0.958572465,   0,           0.958572465,   2.02018287]
+    b = [  0.01995324,   0.39361932,    0.94530872,  0.39361932,    0.01995324]
+    run_gauss("hermite", a , b)
+
+    a = [ 0.41577456,  2.29428036,  6.28994508]
+    b = [ 0.71109301,  0.27851773,  0.01038926]
+    run_gauss("laguerre", a , b)
+
+def test_gauss_quadrature_dynamic(verbose = False):
+    n = 5
+
+    A = mp.randmatrix(2 * n, 1)
+
+    def F(x):
+        r = 0
+        for i in xrange(len(A) - 1, -1, -1):
+            r = r * x + A[i]
+        return r
+
+    def run(qtype, FW, R, alpha = 0, beta = 0):
+        X, W = mp.gauss_quadrature(n, qtype, alpha = alpha, beta = beta)
+
+        a = 0
+        for i in xrange(len(X)):
+            a += W[i] * F(X[i])
+
+        b = mp.quad(lambda x: FW(x) * F(x), R)
+
+        c = mp.fabs(a - b)
+
+        if verbose:
+            print(qtype, c, a, b)
+
+        assert c < 1e-5
+
+    run("legendre", lambda x: 1, [-1, 1])
+    run("legendre01", lambda x: 1, [0, 1])
+    run("hermite", lambda x: mp.exp(-x*x), [-mp.inf, mp.inf])
+    run("laguerre", lambda x: mp.exp(-x), [0, mp.inf])
+    run("glaguerre", lambda x: mp.sqrt(x)*mp.exp(-x), [0, mp.inf], alpha = 1 / mp.mpf(2))
+    run("chebyshev1", lambda x: 1/mp.sqrt(1-x*x), [-1, 1])
+    run("chebyshev2", lambda x: mp.sqrt(1-x*x), [-1, 1])
+    run("jacobi", lambda x: (1-x)**(1/mp.mpf(3)) * (1+x)**(1/mp.mpf(5)), [-1, 1], alpha = 1 / mp.mpf(3), beta = 1 / mp.mpf(5) )

llmeval-env/lib/python3.10/site-packages/mpmath/tests/test_elliptic.py

@@ -0,0 +1,670 @@
+"""
+Limited tests of the elliptic functions module.  A full suite of
+extensive testing can be found in elliptic_torture_tests.py
+
+Author of the first version: M.T. Taschuk
+
+References:
+
+[1] Abramowitz & Stegun. 'Handbook of Mathematical Functions, 9th Ed.',
+    (Dover duplicate of 1972 edition)
+[2] Whittaker 'A Course of Modern Analysis, 4th Ed.', 1946,
+    Cambridge University Press
+
+"""
+
+import mpmath
+import random
+import pytest
+
+from mpmath import *
+
+def mpc_ae(a, b, eps=eps):
+    res = True
+    res = res and a.real.ae(b.real, eps)
+    res = res and a.imag.ae(b.imag, eps)
+    return res
+
+zero = mpf(0)
+one = mpf(1)
+
+jsn = ellipfun('sn')
+jcn = ellipfun('cn')
+jdn = ellipfun('dn')
+
+calculate_nome = lambda k: qfrom(k=k)
+
+def test_ellipfun():
+    mp.dps = 15
+    assert ellipfun('ss', 0, 0) == 1
+    assert ellipfun('cc', 0, 0) == 1
+    assert ellipfun('dd', 0, 0) == 1
+    assert ellipfun('nn', 0, 0) == 1
+    assert ellipfun('sn', 0.25, 0).ae(sin(0.25))
+    assert ellipfun('cn', 0.25, 0).ae(cos(0.25))
+    assert ellipfun('dn', 0.25, 0).ae(1)
+    assert ellipfun('ns', 0.25, 0).ae(csc(0.25))
+    assert ellipfun('nc', 0.25, 0).ae(sec(0.25))
+    assert ellipfun('nd', 0.25, 0).ae(1)
+    assert ellipfun('sc', 0.25, 0).ae(tan(0.25))
+    assert ellipfun('sd', 0.25, 0).ae(sin(0.25))
+    assert ellipfun('cd', 0.25, 0).ae(cos(0.25))
+    assert ellipfun('cs', 0.25, 0).ae(cot(0.25))
+    assert ellipfun('dc', 0.25, 0).ae(sec(0.25))
+    assert ellipfun('ds', 0.25, 0).ae(csc(0.25))
+    assert ellipfun('sn', 0.25, 1).ae(tanh(0.25))
+    assert ellipfun('cn', 0.25, 1).ae(sech(0.25))
+    assert ellipfun('dn', 0.25, 1).ae(sech(0.25))
+    assert ellipfun('ns', 0.25, 1).ae(coth(0.25))
+    assert ellipfun('nc', 0.25, 1).ae(cosh(0.25))
+    assert ellipfun('nd', 0.25, 1).ae(cosh(0.25))
+    assert ellipfun('sc', 0.25, 1).ae(sinh(0.25))
+    assert ellipfun('sd', 0.25, 1).ae(sinh(0.25))
+    assert ellipfun('cd', 0.25, 1).ae(1)
+    assert ellipfun('cs', 0.25, 1).ae(csch(0.25))
+    assert ellipfun('dc', 0.25, 1).ae(1)
+    assert ellipfun('ds', 0.25, 1).ae(csch(0.25))
+    assert ellipfun('sn', 0.25, 0.5).ae(0.24615967096986145833)
+    assert ellipfun('cn', 0.25, 0.5).ae(0.96922928989378439337)
+    assert ellipfun('dn', 0.25, 0.5).ae(0.98473484156599474563)
+    assert ellipfun('ns', 0.25, 0.5).ae(4.0624038700573130369)
+    assert ellipfun('nc', 0.25, 0.5).ae(1.0317476065024692949)
+    assert ellipfun('nd', 0.25, 0.5).ae(1.0155017958029488665)
+    assert ellipfun('sc', 0.25, 0.5).ae(0.25397465134058993408)
+    assert ellipfun('sd', 0.25, 0.5).ae(0.24997558792415733063)
+    assert ellipfun('cd', 0.25, 0.5).ae(0.98425408443195497052)
+    assert ellipfun('cs', 0.25, 0.5).ae(3.9374008182374110826)
+    assert ellipfun('dc', 0.25, 0.5).ae(1.0159978158253033913)
+    assert ellipfun('ds', 0.25, 0.5).ae(4.0003906313579720593)
+
+
+
+
+def test_calculate_nome():
+    mp.dps = 100
+
+    q = calculate_nome(zero)
+    assert(q == zero)
+
+    mp.dps = 25
+    # used Mathematica's EllipticNomeQ[m]
+    math1 = [(mpf(1)/10, mpf('0.006584651553858370274473060')),
+             (mpf(2)/10, mpf('0.01394285727531826872146409')),
+             (mpf(3)/10, mpf('0.02227743615715350822901627')),
+             (mpf(4)/10, mpf('0.03188334731336317755064299')),
+             (mpf(5)/10, mpf('0.04321391826377224977441774')),
+             (mpf(6)/10, mpf('0.05702025781460967637754953')),
+             (mpf(7)/10, mpf('0.07468994353717944761143751')),
+             (mpf(8)/10, mpf('0.09927369733882489703607378')),
+             (mpf(9)/10, mpf('0.1401731269542615524091055')),
+             (mpf(9)/10, mpf('0.1401731269542615524091055'))]
+
+    for i in math1:
+        m = i[0]
+        q = calculate_nome(sqrt(m))
+        assert q.ae(i[1])
+
+    mp.dps = 15
+
+def test_jtheta():
+    mp.dps = 25
+
+    z = q = zero
+    for n in range(1,5):
+        value = jtheta(n, z, q)
+        assert(value == (n-1)//2)
+
+    for q in [one, mpf(2)]:
+        for n in range(1,5):
+            pytest.raises(ValueError, lambda: jtheta(n, z, q))
+
+    z = one/10
+    q = one/11
+
+    # Mathematical N[EllipticTheta[1, 1/10, 1/11], 25]
+    res = mpf('0.1069552990104042681962096')
+    result = jtheta(1, z, q)
+    assert(result.ae(res))
+
+    # Mathematica N[EllipticTheta[2, 1/10, 1/11], 25]
+    res = mpf('1.101385760258855791140606')
+    result = jtheta(2, z, q)
+    assert(result.ae(res))
+
+    # Mathematica N[EllipticTheta[3, 1/10, 1/11], 25]
+    res = mpf('1.178319743354331061795905')
+    result = jtheta(3, z, q)
+    assert(result.ae(res))
+
+    # Mathematica N[EllipticTheta[4, 1/10, 1/11], 25]
+    res = mpf('0.8219318954665153577314573')
+    result = jtheta(4, z, q)
+    assert(result.ae(res))
+
+    # test for sin zeros for jtheta(1, z, q)
+    # test for cos zeros for jtheta(2, z, q)
+    z1 = pi
+    z2 = pi/2
+    for i in range(10):
+        qstring = str(random.random())
+        q = mpf(qstring)
+        result = jtheta(1, z1, q)
+        assert(result.ae(0))
+        result = jtheta(2, z2, q)
+        assert(result.ae(0))
+    mp.dps = 15
+
+
+def test_jtheta_issue_79():
+    # near the circle of covergence |q| = 1 the convergence slows
+    # down; for |q| > Q_LIM the theta functions raise ValueError
+    mp.dps = 30
+    mp.dps += 30
+    q = mpf(6)/10 - one/10**6 - mpf(8)/10 * j
+    mp.dps -= 30
+    # Mathematica run first
+    # N[EllipticTheta[3, 1, 6/10 - 10^-6 - 8/10*I], 2000]
+    # then it works:
+    # N[EllipticTheta[3, 1, 6/10 - 10^-6 - 8/10*I], 30]
+    res = mpf('32.0031009628901652627099524264') + \
+          mpf('16.6153027998236087899308935624') * j
+    result = jtheta(3, 1, q)
+    # check that for abs(q) > Q_LIM a ValueError exception is raised
+    mp.dps += 30
+    q = mpf(6)/10 - one/10**7 - mpf(8)/10 * j
+    mp.dps -= 30
+    pytest.raises(ValueError, lambda: jtheta(3, 1, q))
+
+    # bug reported in issue 79
+    mp.dps = 100
+    z = (1+j)/3
+    q = mpf(368983957219251)/10**15 + mpf(636363636363636)/10**15 * j
+    # Mathematica N[EllipticTheta[1, z, q], 35]
+    res = mpf('2.4439389177990737589761828991467471') + \
+          mpf('0.5446453005688226915290954851851490') *j
+    mp.dps = 30
+    result = jtheta(1, z, q)
+    assert(result.ae(res))
+    mp.dps = 80
+    z = 3 + 4*j
+    q = 0.5 + 0.5*j
+    r1 = jtheta(1, z, q)
+    mp.dps = 15
+    r2 = jtheta(1, z, q)
+    assert r1.ae(r2)
+    mp.dps = 80
+    z = 3 + j
+    q1 = exp(j*3)
+    # longer test
+    # for n in range(1, 6)
+    for n in range(1, 2):
+        mp.dps = 80
+        q = q1*(1 - mpf(1)/10**n)
+        r1 = jtheta(1, z, q)
+        mp.dps = 15
+        r2 = jtheta(1, z, q)
+    assert r1.ae(r2)
+    mp.dps = 15
+    # issue 79 about high derivatives
+    assert jtheta(3, 4.5, 0.25, 9).ae(1359.04892680683)
+    assert jtheta(3, 4.5, 0.25, 50).ae(-6.14832772630905e+33)
+    mp.dps = 50
+    r = jtheta(3, 4.5, 0.25, 9)
+    assert r.ae('1359.048926806828939547859396600218966947753213803')
+    r = jtheta(3, 4.5, 0.25, 50)
+    assert r.ae('-6148327726309051673317975084654262.4119215720343656')
+
+def test_jtheta_identities():
+    """
+    Tests the some of the jacobi identidies found in Abramowitz,
+    Sec. 16.28, Pg. 576. The identities are tested to 1 part in 10^98.
+    """
+    mp.dps = 110
+    eps1 = ldexp(eps, 30)
+
+    for i in range(10):
+        qstring = str(random.random())
+        q = mpf(qstring)
+
+        zstring = str(10*random.random())
+        z = mpf(zstring)
+        # Abramowitz 16.28.1
+        # v_1(z, q)**2 * v_4(0, q)**2 =   v_3(z, q)**2 * v_2(0, q)**2
+        #                               - v_2(z, q)**2 * v_3(0, q)**2
+        term1 = (jtheta(1, z, q)**2) * (jtheta(4, zero, q)**2)
+        term2 = (jtheta(3, z, q)**2) * (jtheta(2, zero, q)**2)
+        term3 = (jtheta(2, z, q)**2) * (jtheta(3, zero, q)**2)
+        equality = term1 - term2 + term3
+        assert(equality.ae(0, eps1))
+
+        zstring = str(100*random.random())
+        z = mpf(zstring)
+        # Abramowitz 16.28.2
+        # v_2(z, q)**2 * v_4(0, q)**2 =   v_4(z, q)**2 * v_2(0, q)**2
+        #                               - v_1(z, q)**2 * v_3(0, q)**2
+        term1 = (jtheta(2, z, q)**2) * (jtheta(4, zero, q)**2)
+        term2 = (jtheta(4, z, q)**2) * (jtheta(2, zero, q)**2)
+        term3 = (jtheta(1, z, q)**2) * (jtheta(3, zero, q)**2)
+        equality = term1 - term2 + term3
+        assert(equality.ae(0, eps1))
+
+        # Abramowitz 16.28.3
+        # v_3(z, q)**2 * v_4(0, q)**2 =   v_4(z, q)**2 * v_3(0, q)**2
+        #                               - v_1(z, q)**2 * v_2(0, q)**2
+        term1 = (jtheta(3, z, q)**2) * (jtheta(4, zero, q)**2)
+        term2 = (jtheta(4, z, q)**2) * (jtheta(3, zero, q)**2)
+        term3 = (jtheta(1, z, q)**2) * (jtheta(2, zero, q)**2)
+        equality = term1 - term2 + term3
+        assert(equality.ae(0, eps1))
+
+        # Abramowitz 16.28.4
+        # v_4(z, q)**2 * v_4(0, q)**2 =   v_3(z, q)**2 * v_3(0, q)**2
+        #                               - v_2(z, q)**2 * v_2(0, q)**2
+        term1 = (jtheta(4, z, q)**2) * (jtheta(4, zero, q)**2)
+        term2 = (jtheta(3, z, q)**2) * (jtheta(3, zero, q)**2)
+        term3 = (jtheta(2, z, q)**2) * (jtheta(2, zero, q)**2)
+        equality = term1 - term2 + term3
+        assert(equality.ae(0, eps1))
+
+        # Abramowitz 16.28.5
+        # v_2(0, q)**4 + v_4(0, q)**4 == v_3(0, q)**4
+        term1 = (jtheta(2, zero, q))**4
+        term2 = (jtheta(4, zero, q))**4
+        term3 = (jtheta(3, zero, q))**4
+        equality = term1 + term2 - term3
+        assert(equality.ae(0, eps1))
+    mp.dps = 15
+
+def test_jtheta_complex():
+    mp.dps = 30
+    z = mpf(1)/4 + j/8
+    q = mpf(1)/3 + j/7
+    # Mathematica N[EllipticTheta[1, 1/4 + I/8, 1/3 + I/7], 35]
+    res = mpf('0.31618034835986160705729105731678285') + \
+          mpf('0.07542013825835103435142515194358975') * j
+    r = jtheta(1, z, q)
+    assert(mpc_ae(r, res))
+
+    # Mathematica N[EllipticTheta[2, 1/4 + I/8, 1/3 + I/7], 35]
+    res = mpf('1.6530986428239765928634711417951828') + \
+          mpf('0.2015344864707197230526742145361455') * j
+    r = jtheta(2, z, q)
+    assert(mpc_ae(r, res))
+
+    # Mathematica N[EllipticTheta[3, 1/4 + I/8, 1/3 + I/7], 35]
+    res = mpf('1.6520564411784228184326012700348340') + \
+          mpf('0.1998129119671271328684690067401823') * j
+    r = jtheta(3, z, q)
+    assert(mpc_ae(r, res))
+
+    # Mathematica N[EllipticTheta[4, 1/4 + I/8, 1/3 + I/7], 35]
+    res = mpf('0.37619082382228348252047624089973824') - \
+          mpf('0.15623022130983652972686227200681074') * j
+    r = jtheta(4, z, q)
+    assert(mpc_ae(r, res))
+
+    # check some theta function identities
+    mp.dos = 100
+    z = mpf(1)/4 + j/8
+    q = mpf(1)/3 + j/7
+    mp.dps += 10
+    a = [0,0, jtheta(2, 0, q), jtheta(3, 0, q), jtheta(4, 0, q)]
+    t = [0, jtheta(1, z, q), jtheta(2, z, q), jtheta(3, z, q), jtheta(4, z, q)]
+    r = [(t[2]*a[4])**2 - (t[4]*a[2])**2 + (t[1] *a[3])**2,
+        (t[3]*a[4])**2 - (t[4]*a[3])**2 + (t[1] *a[2])**2,
+        (t[1]*a[4])**2 - (t[3]*a[2])**2 + (t[2] *a[3])**2,
+        (t[4]*a[4])**2 - (t[3]*a[3])**2 + (t[2] *a[2])**2,
+        a[2]**4 + a[4]**4 - a[3]**4]
+    mp.dps -= 10
+    for x in r:
+        assert(mpc_ae(x, mpc(0)))
+    mp.dps = 15
+
+def test_djtheta():
+    mp.dps = 30
+
+    z = one/7 + j/3
+    q = one/8 + j/5
+    # Mathematica N[EllipticThetaPrime[1, 1/7 + I/3, 1/8 + I/5], 35]
+    res = mpf('1.5555195883277196036090928995803201') - \
+          mpf('0.02439761276895463494054149673076275') * j
+    result = jtheta(1, z, q, 1)
+    assert(mpc_ae(result, res))
+
+    # Mathematica N[EllipticThetaPrime[2, 1/7 + I/3, 1/8 + I/5], 35]
+    res = mpf('0.19825296689470982332701283509685662') - \
+          mpf('0.46038135182282106983251742935250009') * j
+    result = jtheta(2, z, q, 1)
+    assert(mpc_ae(result, res))
+
+    # Mathematica N[EllipticThetaPrime[3, 1/7 + I/3, 1/8 + I/5], 35]
+    res = mpf('0.36492498415476212680896699407390026') - \
+          mpf('0.57743812698666990209897034525640369') * j
+    result = jtheta(3, z, q, 1)
+    assert(mpc_ae(result, res))
+
+    # Mathematica N[EllipticThetaPrime[4, 1/7 + I/3, 1/8 + I/5], 35]
+    res = mpf('-0.38936892528126996010818803742007352') + \
+          mpf('0.66549886179739128256269617407313625') * j
+    result = jtheta(4, z, q, 1)
+    assert(mpc_ae(result, res))
+
+    for i in range(10):
+        q = (one*random.random() + j*random.random())/2
+        # identity in Wittaker, Watson &21.41
+        a = jtheta(1, 0, q, 1)
+        b = jtheta(2, 0, q)*jtheta(3, 0, q)*jtheta(4, 0, q)
+        assert(a.ae(b))
+
+    # test higher derivatives
+    mp.dps = 20
+    for q,z in [(one/3, one/5), (one/3 + j/8, one/5),
+        (one/3, one/5 + j/8), (one/3 + j/7, one/5 + j/8)]:
+        for n in [1, 2, 3, 4]:
+            r = jtheta(n, z, q, 2)
+            r1 = diff(lambda zz: jtheta(n, zz, q), z, n=2)
+            assert r.ae(r1)
+            r = jtheta(n, z, q, 3)
+            r1 = diff(lambda zz: jtheta(n, zz, q), z, n=3)
+            assert r.ae(r1)
+
+    # identity in Wittaker, Watson &21.41
+    q = one/3
+    z = zero
+    a = [0]*5
+    a[1] = jtheta(1, z, q, 3)/jtheta(1, z, q, 1)
+    for n in [2,3,4]:
+        a[n] = jtheta(n, z, q, 2)/jtheta(n, z, q)
+    equality = a[2] + a[3] + a[4] - a[1]
+    assert(equality.ae(0))
+    mp.dps = 15
+
+def test_jsn():
+    """
+    Test some special cases of the sn(z, q) function.
+    """
+    mp.dps = 100
+
+    # trival case
+    result = jsn(zero, zero)
+    assert(result == zero)
+
+    # Abramowitz Table 16.5
+    #
+    # sn(0, m) = 0
+
+    for i in range(10):
+        qstring = str(random.random())
+        q = mpf(qstring)
+
+        equality = jsn(zero, q)
+        assert(equality.ae(0))
+
+    # Abramowitz Table 16.6.1
+    #
+    # sn(z, 0) = sin(z), m == 0
+    #
+    # sn(z, 1) = tanh(z), m == 1
+    #
+    # It would be nice to test these, but I find that they run
+    # in to numerical trouble.  I'm currently treating as a boundary
+    # case for sn function.
+
+    mp.dps = 25
+    arg = one/10
+    #N[JacobiSN[1/10, 2^-100], 25]
+    res = mpf('0.09983341664682815230681420')
+    m = ldexp(one, -100)
+    result = jsn(arg, m)
+    assert(result.ae(res))
+
+    # N[JacobiSN[1/10, 1/10], 25]
+    res = mpf('0.09981686718599080096451168')
+    result = jsn(arg, arg)
+    assert(result.ae(res))
+    mp.dps = 15
+
+def test_jcn():
+    """
+    Test some special cases of the cn(z, q) function.
+    """
+    mp.dps = 100
+
+    # Abramowitz Table 16.5
+    # cn(0, q) = 1
+    qstring = str(random.random())
+    q = mpf(qstring)
+    cn = jcn(zero, q)
+    assert(cn.ae(one))
+
+    # Abramowitz Table 16.6.2
+    #
+    # cn(u, 0) = cos(u), m == 0
+    #
+    # cn(u, 1) = sech(z), m == 1
+    #
+    # It would be nice to test these, but I find that they run
+    # in to numerical trouble.  I'm currently treating as a boundary
+    # case for cn function.
+
+    mp.dps = 25
+    arg = one/10
+    m = ldexp(one, -100)
+    #N[JacobiCN[1/10, 2^-100], 25]
+    res = mpf('0.9950041652780257660955620')
+    result = jcn(arg, m)
+    assert(result.ae(res))
+
+    # N[JacobiCN[1/10, 1/10], 25]
+    res = mpf('0.9950058256237368748520459')
+    result = jcn(arg, arg)
+    assert(result.ae(res))
+    mp.dps = 15
+
+def test_jdn():
+    """
+    Test some special cases of the dn(z, q) function.
+    """
+    mp.dps = 100
+
+    # Abramowitz Table 16.5
+    # dn(0, q) = 1
+    mstring = str(random.random())
+    m = mpf(mstring)
+
+    dn = jdn(zero, m)
+    assert(dn.ae(one))
+
+    mp.dps = 25
+    # N[JacobiDN[1/10, 1/10], 25]
+    res = mpf('0.9995017055025556219713297')
+    arg = one/10
+    result = jdn(arg, arg)
+    assert(result.ae(res))
+    mp.dps = 15
+
+
+def test_sn_cn_dn_identities():
+    """
+    Tests the some of the jacobi elliptic function identities found
+    on Mathworld. Haven't found in Abramowitz.
+    """
+    mp.dps = 100
+    N = 5
+    for i in range(N):
+        qstring = str(random.random())
+        q = mpf(qstring)
+        zstring = str(100*random.random())
+        z = mpf(zstring)
+
+        # MathWorld
+        # sn(z, q)**2 + cn(z, q)**2 == 1
+        term1 = jsn(z, q)**2
+        term2 = jcn(z, q)**2
+        equality = one - term1 - term2
+        assert(equality.ae(0))
+
+    # MathWorld
+    # k**2 * sn(z, m)**2 + dn(z, m)**2 == 1
+    for i in range(N):
+        mstring = str(random.random())
+        m = mpf(qstring)
+        k = m.sqrt()
+        zstring = str(10*random.random())
+        z = mpf(zstring)
+        term1 = k**2 * jsn(z, m)**2
+        term2 = jdn(z, m)**2
+        equality = one - term1 - term2
+        assert(equality.ae(0))
+
+
+    for i in range(N):
+        mstring = str(random.random())
+        m = mpf(mstring)
+        k = m.sqrt()
+        zstring = str(random.random())
+        z = mpf(zstring)
+
+        # MathWorld
+        # k**2 * cn(z, m)**2 + (1 - k**2) = dn(z, m)**2
+        term1 = k**2 * jcn(z, m)**2
+        term2 = 1 - k**2
+        term3 = jdn(z, m)**2
+        equality = term3 - term1 - term2
+        assert(equality.ae(0))
+
+        K = ellipk(k**2)
+        # Abramowitz Table 16.5
+        # sn(K, m) = 1; K is K(k), first complete elliptic integral
+        r = jsn(K, m)
+        assert(r.ae(one))
+
+        # Abramowitz Table 16.5
+        # cn(K, q) = 0; K is K(k), first complete elliptic integral
+        equality = jcn(K, m)
+        assert(equality.ae(0))
+
+        # Abramowitz Table 16.6.3
+        # dn(z, 0) = 1, m == 0
+        z = m
+        value = jdn(z, zero)
+        assert(value.ae(one))
+
+    mp.dps = 15
+
+def test_sn_cn_dn_complex():
+    mp.dps = 30
+    # N[JacobiSN[1/4 + I/8, 1/3 + I/7], 35] in Mathematica
+    res = mpf('0.2495674401066275492326652143537') + \
+          mpf('0.12017344422863833381301051702823') * j
+    u = mpf(1)/4 + j/8
+    m = mpf(1)/3 + j/7
+    r = jsn(u, m)
+    assert(mpc_ae(r, res))
+
+    #N[JacobiCN[1/4 + I/8, 1/3 + I/7], 35]
+    res = mpf('0.9762691700944007312693721148331') - \
+          mpf('0.0307203994181623243583169154824')*j
+    r = jcn(u, m)
+    #assert r.real.ae(res.real)
+    #assert r.imag.ae(res.imag)
+    assert(mpc_ae(r, res))
+
+    #N[JacobiDN[1/4 + I/8, 1/3 + I/7], 35]
+    res = mpf('0.99639490163039577560547478589753039') - \
+          mpf('0.01346296520008176393432491077244994')*j
+    r = jdn(u, m)
+    assert(mpc_ae(r, res))
+    mp.dps = 15
+
+def test_elliptic_integrals():
+    # Test cases from Carlson's paper
+    mp.dps = 15
+    assert elliprd(0,2,1).ae(1.7972103521033883112)
+    assert elliprd(2,3,4).ae(0.16510527294261053349)
+    assert elliprd(j,-j,2).ae(0.65933854154219768919)
+    assert elliprd(0,j,-j).ae(1.2708196271909686299 + 2.7811120159520578777j)
+    assert elliprd(0,j-1,j).ae(-1.8577235439239060056 - 0.96193450888838559989j)
+    assert elliprd(-2-j,-j,-1+j).ae(1.8249027393703805305 - 1.2218475784827035855j)
+    # extra test cases
+    assert elliprg(0,0,0) == 0
+    assert elliprg(0,0,16).ae(2)
+    assert elliprg(0,16,0).ae(2)
+    assert elliprg(16,0,0).ae(2)
+    assert elliprg(1,4,0).ae(1.2110560275684595248036)
+    assert elliprg(1,0,4).ae(1.2110560275684595248036)
+    assert elliprg(0,4,1).ae(1.2110560275684595248036)
+    # should be symmetric -- fixes a bug present in the paper
+    x,y,z = 1,1j,-1+1j
+    assert elliprg(x,y,z).ae(0.64139146875812627545 + 0.58085463774808290907j)
+    assert elliprg(x,z,y).ae(0.64139146875812627545 + 0.58085463774808290907j)
+    assert elliprg(y,x,z).ae(0.64139146875812627545 + 0.58085463774808290907j)
+    assert elliprg(y,z,x).ae(0.64139146875812627545 + 0.58085463774808290907j)
+    assert elliprg(z,x,y).ae(0.64139146875812627545 + 0.58085463774808290907j)
+    assert elliprg(z,y,x).ae(0.64139146875812627545 + 0.58085463774808290907j)
+
+    for n in [5, 15, 30, 60, 100]:
+        mp.dps = n
+        assert elliprf(1,2,0).ae('1.3110287771460599052324197949455597068413774757158115814084108519003952935352071251151477664807145467230678763')
+        assert elliprf(0.5,1,0).ae('1.854074677301371918433850347195260046217598823521766905585928045056021776838119978357271861650371897277771871')
+        assert elliprf(j,-j,0).ae('1.854074677301371918433850347195260046217598823521766905585928045056021776838119978357271861650371897277771871')
+        assert elliprf(j-1,j,0).ae(mpc('0.79612586584233913293056938229563057846592264089185680214929401744498956943287031832657642790719940442165621412',
+            '-1.2138566698364959864300942567386038975419875860741507618279563735753073152507112254567291141460317931258599889'))
+        assert elliprf(2,3,4).ae('0.58408284167715170669284916892566789240351359699303216166309375305508295130412919665541330837704050454472379308')
+        assert elliprf(j,-j,2).ae('1.0441445654064360931078658361850779139591660747973017593275012615517220315993723776182276555339288363064476126')
+        assert elliprf(j-1,j,1-j).ae(mpc('0.93912050218619371196624617169781141161485651998254431830645241993282941057500174238125105410055253623847335313',
+            '-0.53296252018635269264859303449447908970360344322834582313172115220559316331271520508208025270300138589669326136'))
+        assert elliprc(0,0.25).ae(+pi)
+        assert elliprc(2.25,2).ae(+ln2)
+        assert elliprc(0,j).ae(mpc('1.1107207345395915617539702475151734246536554223439225557713489017391086982748684776438317336911913093408525532',
+            '-1.1107207345395915617539702475151734246536554223439225557713489017391086982748684776438317336911913093408525532'))
+        assert elliprc(-j,j).ae(mpc('1.2260849569072198222319655083097718755633725139745941606203839524036426936825652935738621522906572884239069297',
+            '-0.34471136988767679699935618332997956653521218571295874986708834375026550946053920574015526038040124556716711353'))
+        assert elliprc(0.25,-2).ae(ln2/3)
+        assert elliprc(j,-1).ae(mpc('0.77778596920447389875196055840799837589537035343923012237628610795937014001905822029050288316217145443865649819',
+            '0.1983248499342877364755170948292130095921681309577950696116251029742793455964385947473103628983664877025779304'))
+        assert elliprj(0,1,2,3).ae('0.77688623778582332014190282640545501102298064276022952731669118325952563819813258230708177398475643634103990878')
+        assert elliprj(2,3,4,5).ae('0.14297579667156753833233879421985774801466647854232626336218889885463800128817976132826443904216546421431528308')
+        assert elliprj(2,3,4,-1+j).ae(mpc('0.13613945827770535203521374457913768360237593025944342652613569368333226052158214183059386307242563164036672709',
+            '-0.38207561624427164249600936454845112611060375760094156571007648297226090050927156176977091273224510621553615189'))
+        assert elliprj(j,-j,0,2).ae('1.6490011662710884518243257224860232300246792717163891216346170272567376981346412066066050103935109581019055806')
+        assert elliprj(-1+j,-1-j,1,2).ae('0.94148358841220238083044612133767270187474673547917988681610772381758628963408843935027667916713866133196845063')
+        assert elliprj(j,-j,0,1-j).ae(mpc('1.8260115229009316249372594065790946657011067182850435297162034335356430755397401849070610280860044610878657501',
+            '1.2290661908643471500163617732957042849283739403009556715926326841959667290840290081010472716420690899886276961'))
+        assert elliprj(-1+j,-1-j,1,-3+j).ae(mpc('-0.61127970812028172123588152373622636829986597243716610650831553882054127570542477508023027578037045504958619422',
+            '-1.0684038390006807880182112972232562745485871763154040245065581157751693730095703406209466903752930797510491155'))
+        assert elliprj(-1+j,-2-j,-j,-1+j).ae(mpc('1.8249027393703805304622013339009022294368078659619988943515764258335975852685224202567854526307030593012768954',
+            '-1.2218475784827035854568450371590419833166777535029296025352291308244564398645467465067845461070602841312456831'))
+
+        assert elliprg(0,16,16).ae(+pi)
+        assert elliprg(2,3,4).ae('1.7255030280692277601061148835701141842692457170470456590515892070736643637303053506944907685301315299153040991')
+        assert elliprg(0,j,-j).ae('0.42360654239698954330324956174109581824072295516347109253028968632986700241706737986160014699730561497106114281')
+        assert elliprg(j-1,j,0).ae(mpc('0.44660591677018372656731970402124510811555212083508861036067729944477855594654762496407405328607219895053798354',
+            '0.70768352357515390073102719507612395221369717586839400605901402910893345301718731499237159587077682267374159282'))
+        assert elliprg(-j,j-1,j).ae(mpc('0.36023392184473309033675652092928695596803358846377334894215349632203382573844427952830064383286995172598964266',
+            '0.40348623401722113740956336997761033878615232917480045914551915169013722542827052849476969199578321834819903921'))
+        assert elliprg(0, mpf('0.0796'), 4).ae('1.0284758090288040009838871385180217366569777284430590125081211090574701293154645750017813190805144572673802094')
+    mp.dps = 15
+
+    # more test cases for the branch of ellippi / elliprj
+    assert elliprj(-1-0.5j, -10-6j, -10-3j, -5+10j).ae(0.128470516743927699 + 0.102175950778504625j, abs_eps=1e-8)
+    assert elliprj(1.987, 4.463 - 1.614j, 0, -3.965).ae(-0.341575118513811305 - 0.394703757004268486j, abs_eps=1e-8)
+    assert elliprj(0.3068, -4.037+0.632j, 1.654, -0.9609).ae(-1.14735199581485639 - 0.134450158867472264j, abs_eps=1e-8)
+    assert elliprj(0.3068, -4.037-0.632j, 1.654, -0.9609).ae(1.758765901861727 - 0.161002343366626892j, abs_eps=1e-5)
+    assert elliprj(0.3068, -4.037+0.0632j, 1.654, -0.9609).ae(-1.17157627949475577 - 0.069182614173988811j, abs_eps=1e-8)
+    assert elliprj(0.3068, -4.037+0.00632j, 1.654, -0.9609).ae(-1.17337595670549633 - 0.0623069224526925j, abs_eps=1e-8)
+
+    # these require accurate integration
+    assert elliprj(0.3068, -4.037-0.0632j, 1.654, -0.9609).ae(1.77940452391261626 + 0.0388711305592447234j)
+    assert elliprj(0.3068, -4.037-0.00632j, 1.654, -0.9609).ae(1.77806722756403055 + 0.0592749824572262329j)
+    # issue #571
+    assert ellippi(2.1 + 0.94j, 2.3 + 0.98j, 2.5 + 0.01j).ae(-0.40652414240811963438 + 2.1547659461404749309j)
+
+    assert ellippi(2.0-1.0j, 2.0+1.0j).ae(1.8578723151271115 - 1.18642180609983531j)
+    assert ellippi(2.0-0.5j, 0.5+1.0j).ae(0.936761970766645807 - 1.61876787838890786j)
+    assert ellippi(2.0, 1.0+1.0j).ae(0.999881420735506708 - 2.4139272867045391j)
+    assert ellippi(2.0+1.0j, 2.0-1.0j).ae(1.8578723151271115 + 1.18642180609983531j)
+    assert ellippi(2.0+1.0j, 2.0).ae(2.78474654927885845 + 2.02204728966993314j)
+
+def test_issue_238():
+    assert isnan(qfrom(m=nan))

llmeval-env/lib/python3.10/site-packages/mpmath/tests/test_fp.py

@@ -0,0 +1,1671 @@
+"""
+Easy-to-use test-generating code:
+
+cases = '''
+exp 2.25
+log 2.25
+'''
+
+from mpmath import *
+mp.dps = 20
+for test in cases.splitlines():
+    if not test:
+        continue
+    words = test.split()
+    fname = words[0]
+    args = words[1:]
+    argstr = ", ".join(args)
+    testline = "%s(%s)" % (fname, argstr)
+    ans = str(eval(testline))
+    print "    assert ae(fp.%s, %s)" % (testline, ans)
+
+"""
+
+from mpmath import fp
+
+def ae(x, y, tol=1e-12):
+    if x == y:
+        return True
+    return abs(x-y) <= tol*abs(y)
+
+def test_conj():
+    assert fp.conj(4) == 4
+    assert fp.conj(3+4j) == 3-4j
+    assert fp.fdot([1,2],[3,2+1j], conjugate=True) == 7-2j
+
+def test_fp_number_parts():
+    assert ae(fp.arg(3), 0.0)
+    assert ae(fp.arg(-3), 3.1415926535897932385)
+    assert ae(fp.arg(3j), 1.5707963267948966192)
+    assert ae(fp.arg(-3j), -1.5707963267948966192)
+    assert ae(fp.arg(2+3j), 0.98279372324732906799)
+    assert ae(fp.arg(-1-1j), -2.3561944901923449288)
+    assert ae(fp.re(2.5), 2.5)
+    assert ae(fp.re(2.5+3j), 2.5)
+    assert ae(fp.im(2.5), 0.0)
+    assert ae(fp.im(2.5+3j), 3.0)
+    assert ae(fp.floor(2.5), 2.0)
+    assert ae(fp.floor(2), 2.0)
+    assert ae(fp.floor(2.0+0j), (2.0 + 0.0j))
+    assert ae(fp.floor(-1.5-0.5j), (-2.0 - 1.0j))
+    assert ae(fp.ceil(2.5), 3.0)
+    assert ae(fp.ceil(2), 2.0)
+    assert ae(fp.ceil(2.0+0j), (2.0 + 0.0j))
+    assert ae(fp.ceil(-1.5-0.5j), (-1.0 + 0.0j))
+
+def test_fp_cospi_sinpi():
+    assert ae(fp.sinpi(0), 0.0)
+    assert ae(fp.sinpi(0.25), 0.7071067811865475244)
+    assert ae(fp.sinpi(0.5), 1.0)
+    assert ae(fp.sinpi(0.75), 0.7071067811865475244)
+    assert ae(fp.sinpi(1), 0.0)
+    assert ae(fp.sinpi(1.25), -0.7071067811865475244)
+    assert ae(fp.sinpi(1.5), -1.0)
+    assert ae(fp.sinpi(1.75), -0.7071067811865475244)
+    assert ae(fp.sinpi(2), 0.0)
+    assert ae(fp.sinpi(2.25), 0.7071067811865475244)
+    assert ae(fp.sinpi(0+3j), (0.0 + 6195.8238636085899556j))
+    assert ae(fp.sinpi(0.25+3j), (4381.1091260582448033 + 4381.1090689950686908j))
+    assert ae(fp.sinpi(0.5+3j), (6195.8239443081075259 + 0.0j))
+    assert ae(fp.sinpi(0.75+3j), (4381.1091260582448033 - 4381.1090689950686908j))
+    assert ae(fp.sinpi(1+3j), (0.0 - 6195.8238636085899556j))
+    assert ae(fp.sinpi(1.25+3j), (-4381.1091260582448033 - 4381.1090689950686908j))
+    assert ae(fp.sinpi(1.5+3j), (-6195.8239443081075259 + 0.0j))
+    assert ae(fp.sinpi(1.75+3j), (-4381.1091260582448033 + 4381.1090689950686908j))
+    assert ae(fp.sinpi(2+3j), (0.0 + 6195.8238636085899556j))
+    assert ae(fp.sinpi(2.25+3j), (4381.1091260582448033 + 4381.1090689950686908j))
+    assert ae(fp.sinpi(-0.75), -0.7071067811865475244)
+    assert ae(fp.sinpi(-1e-10), -3.1415926535897933529e-10)
+    assert ae(fp.sinpi(1e-10), 3.1415926535897933529e-10)
+    assert ae(fp.sinpi(1e-10+1e-10j), (3.141592653589793353e-10 + 3.1415926535897933528e-10j))
+    assert ae(fp.sinpi(1e-10-1e-10j), (3.141592653589793353e-10 - 3.1415926535897933528e-10j))
+    assert ae(fp.sinpi(-1e-10+1e-10j), (-3.141592653589793353e-10 + 3.1415926535897933528e-10j))
+    assert ae(fp.sinpi(-1e-10-1e-10j), (-3.141592653589793353e-10 - 3.1415926535897933528e-10j))
+    assert ae(fp.cospi(0), 1.0)
+    assert ae(fp.cospi(0.25), 0.7071067811865475244)
+    assert ae(fp.cospi(0.5), 0.0)
+    assert ae(fp.cospi(0.75), -0.7071067811865475244)
+    assert ae(fp.cospi(1), -1.0)
+    assert ae(fp.cospi(1.25), -0.7071067811865475244)
+    assert ae(fp.cospi(1.5), 0.0)
+    assert ae(fp.cospi(1.75), 0.7071067811865475244)
+    assert ae(fp.cospi(2), 1.0)
+    assert ae(fp.cospi(2.25), 0.7071067811865475244)
+    assert ae(fp.cospi(0+3j), (6195.8239443081075259 + 0.0j))
+    assert ae(fp.cospi(0.25+3j), (4381.1091260582448033 - 4381.1090689950686908j))
+    assert ae(fp.cospi(0.5+3j), (0.0 - 6195.8238636085899556j))
+    assert ae(fp.cospi(0.75+3j), (-4381.1091260582448033 - 4381.1090689950686908j))
+    assert ae(fp.cospi(1+3j), (-6195.8239443081075259 + 0.0j))
+    assert ae(fp.cospi(1.25+3j), (-4381.1091260582448033 + 4381.1090689950686908j))
+    assert ae(fp.cospi(1.5+3j), (0.0 + 6195.8238636085899556j))
+    assert ae(fp.cospi(1.75+3j), (4381.1091260582448033 + 4381.1090689950686908j))
+    assert ae(fp.cospi(2+3j), (6195.8239443081075259 + 0.0j))
+    assert ae(fp.cospi(2.25+3j), (4381.1091260582448033 - 4381.1090689950686908j))
+    assert ae(fp.cospi(-0.75), -0.7071067811865475244)
+    assert ae(fp.sinpi(-0.7), -0.80901699437494750611)
+    assert ae(fp.cospi(-0.7), -0.5877852522924730163)
+    assert ae(fp.cospi(-3+2j), (-267.74676148374822225 + 0.0j))
+    assert ae(fp.sinpi(-3+2j), (0.0 - 267.74489404101651426j))
+    assert ae(fp.sinpi(-0.7+2j), (-216.6116802292079471 - 157.37650009392034693j))
+    assert ae(fp.cospi(-0.7+2j), (-157.37759774921754565 + 216.61016943630197336j))
+
+def test_fp_expj():
+    assert ae(fp.expj(0), (1.0 + 0.0j))
+    assert ae(fp.expj(1), (0.5403023058681397174 + 0.84147098480789650665j))
+    assert ae(fp.expj(2), (-0.416146836547142387 + 0.9092974268256816954j))
+    assert ae(fp.expj(0.75), (0.73168886887382088631 + 0.68163876002333416673j))
+    assert ae(fp.expj(2+3j), (-0.020718731002242879378 + 0.045271253156092975488j))
+    assert ae(fp.expjpi(0), (1.0 + 0.0j))
+    assert ae(fp.expjpi(1), (-1.0 + 0.0j))
+    assert ae(fp.expjpi(2), (1.0 + 0.0j))
+    assert ae(fp.expjpi(0.75), (-0.7071067811865475244 + 0.7071067811865475244j))
+    assert ae(fp.expjpi(2+3j), (0.000080699517570304599239 + 0.0j))
+
+def test_fp_bernoulli():
+    assert ae(fp.bernoulli(0), 1.0)
+    assert ae(fp.bernoulli(1), -0.5)
+    assert ae(fp.bernoulli(2), 0.16666666666666666667)
+    assert ae(fp.bernoulli(10), 0.075757575757575757576)
+    assert ae(fp.bernoulli(11), 0.0)
+
+def test_fp_gamma():
+    assert ae(fp.gamma(1), 1.0)
+    assert ae(fp.gamma(1.5), 0.88622692545275801365)
+    assert ae(fp.gamma(10), 362880.0)
+    assert ae(fp.gamma(-0.5), -3.5449077018110320546)
+    assert ae(fp.gamma(-7.1), 0.0016478244570263333622)
+    assert ae(fp.gamma(12.3), 83385367.899970000963)
+    assert ae(fp.gamma(2+0j), (1.0 + 0.0j))
+    assert ae(fp.gamma(-2.5+0j), (-0.94530872048294188123 + 0.0j))
+    assert ae(fp.gamma(3+4j), (0.0052255384713692141947 - 0.17254707929430018772j))
+    assert ae(fp.gamma(-3-4j), (0.00001460997305874775607 - 0.000020760733311509070396j))
+    assert ae(fp.fac(0), 1.0)
+    assert ae(fp.fac(1), 1.0)
+    assert ae(fp.fac(20), 2432902008176640000.0)
+    assert ae(fp.fac(-3.5), -0.94530872048294188123)
+    assert ae(fp.fac(2+3j), (-0.44011340763700171113 - 0.06363724312631702183j))
+    assert ae(fp.loggamma(1.0), 0.0)
+    assert ae(fp.loggamma(2.0), 0.0)
+    assert ae(fp.loggamma(3.0), 0.69314718055994530942)
+    assert ae(fp.loggamma(7.25), 7.0521854507385394449)
+    assert ae(fp.loggamma(1000.0), 5905.2204232091812118)
+    assert ae(fp.loggamma(1e50), 1.1412925464970229298e+52)
+    assert ae(fp.loggamma(1e25+1e25j), (5.6125802751733671621e+26 + 5.7696599078528568383e+26j))
+    assert ae(fp.loggamma(3+4j), (-1.7566267846037841105 + 4.7426644380346579282j))
+    assert ae(fp.loggamma(-0.5), (1.2655121234846453965 - 3.1415926535897932385j))
+    assert ae(fp.loggamma(-1.25), (1.3664317612369762346 - 6.2831853071795864769j))
+    assert ae(fp.loggamma(-2.75), (0.0044878975359557733115 - 9.4247779607693797154j))
+    assert ae(fp.loggamma(-3.5), (-1.3090066849930420464 - 12.566370614359172954j))
+    assert ae(fp.loggamma(-4.5), (-2.8130840817693161197 - 15.707963267948966192j))
+    assert ae(fp.loggamma(-2+3j), (-6.776523813485657093 - 4.568791367260286402j))
+    assert ae(fp.loggamma(-1000.3), (-5912.8440347785205041 - 3144.7342462433830317j))
+    assert ae(fp.loggamma(-100-100j), (-632.35117666833135562 - 158.37641469650352462j))
+    assert ae(fp.loggamma(1e-10), 23.025850929882735237)
+    assert ae(fp.loggamma(-1e-10), (23.02585092999817837 - 3.1415926535897932385j))
+    assert ae(fp.loggamma(1e-10j), (23.025850929940456804 - 1.5707963268526181857j))
+    assert ae(fp.loggamma(1e-10j-1e-10), (22.679277339718205716 - 2.3561944902500664954j))
+
+def test_fp_psi():
+    assert ae(fp.psi(0, 3.7), 1.1671535393615114409)
+    assert ae(fp.psi(0, 0.5), -1.9635100260214234794)
+    assert ae(fp.psi(0, 1), -0.57721566490153286061)
+    assert ae(fp.psi(0, -2.5), 1.1031566406452431872)
+    assert ae(fp.psi(0, 12.9), 2.5179671503279156347)
+    assert ae(fp.psi(0, 100), 4.6001618527380874002)
+    assert ae(fp.psi(0, 2500.3), 7.8239660143238547877)
+    assert ae(fp.psi(0, 1e40), 92.103403719761827391)
+    assert ae(fp.psi(0, 1e200), 460.51701859880913677)
+    assert ae(fp.psi(0, 3.7+0j), (1.1671535393615114409 + 0.0j))
+    assert ae(fp.psi(1, 3), 0.39493406684822643647)
+    assert ae(fp.psi(3, 2+3j), (-0.05383196209159972116 + 0.0076890935247364805218j))
+    assert ae(fp.psi(4, -0.5+1j), (1.2719531355492328195 - 18.211833410936276774j))
+    assert ae(fp.harmonic(0), 0.0)
+    assert ae(fp.harmonic(1), 1.0)
+    assert ae(fp.harmonic(2), 1.5)
+    assert ae(fp.harmonic(100), 5.1873775176396202608)
+    assert ae(fp.harmonic(-2.5), 1.2803723055467760478)
+    assert ae(fp.harmonic(2+3j), (1.9390425294578375875 + 0.87336044981834544043j))
+    assert ae(fp.harmonic(-5-4j), (2.3725754822349437733 - 2.4160904444801621j))
+
+def test_fp_zeta():
+    assert ae(fp.zeta(1e100), 1.0)
+    assert ae(fp.zeta(3), 1.2020569031595942854)
+    assert ae(fp.zeta(2+0j), (1.6449340668482264365 + 0.0j))
+    assert ae(fp.zeta(0.93), -13.713619351638164784)
+    assert ae(fp.zeta(1.74), 1.9796863545771774095)
+    assert ae(fp.zeta(0.0), -0.5)
+    assert ae(fp.zeta(-1.0), -0.083333333333333333333)
+    assert ae(fp.zeta(-2.0), 0.0)
+    assert ae(fp.zeta(-3.0), 0.0083333333333333333333)
+    assert ae(fp.zeta(-500.0), 0.0)
+    assert ae(fp.zeta(-7.4), 0.0036537321227995882447)
+    assert ae(fp.zeta(2.1), 1.5602165335033620158)
+    assert ae(fp.zeta(26.9), 1.0000000079854809935)
+    assert ae(fp.zeta(26), 1.0000000149015548284)
+    assert ae(fp.zeta(27), 1.0000000074507117898)
+    assert ae(fp.zeta(28), 1.0000000037253340248)
+    assert ae(fp.zeta(27.1), 1.000000006951755045)
+    assert ae(fp.zeta(32.7), 1.0000000001433243232)
+    assert ae(fp.zeta(100), 1.0)
+    assert ae(fp.altzeta(3.5), 0.92755357777394803511)
+    assert ae(fp.altzeta(1), 0.69314718055994530942)
+    assert ae(fp.altzeta(2), 0.82246703342411321824)
+    assert ae(fp.altzeta(0), 0.5)
+    assert ae(fp.zeta(-2+3j, 1), (0.13297115587929864827 + 0.12305330040458776494j))
+    assert ae(fp.zeta(-2+3j, 5), (18.384866151867576927 - 11.377015110597711009j))
+    assert ae(fp.zeta(1.0000000001), 9999999173.1735741337)
+    assert ae(fp.zeta(0.9999999999), -9999999172.0191428039)
+    assert ae(fp.zeta(1+0.000000001j), (0.57721566490153286061 - 999999999.99999993765j))
+    assert ae(fp.primezeta(2.5+4j), (-0.16922458243438033385 - 0.010847965298387727811j))
+    assert ae(fp.primezeta(4), 0.076993139764246844943)
+    assert ae(fp.riemannr(3.7), 2.3034079839110855717)
+    assert ae(fp.riemannr(8), 3.9011860449341499474)
+    assert ae(fp.riemannr(3+4j), (2.2369653314259991796 + 1.6339943856990281694j))
+
+def test_fp_hyp2f1():
+    assert ae(fp.hyp2f1(1, (3,2), 3.25, 5.0), (-0.46600275923108143059 - 0.74393667908854842325j))
+    assert ae(fp.hyp2f1(1+1j, (3,2), 3.25, 5.0), (-5.9208875603806515987 - 2.3813557707889590686j))
+    assert ae(fp.hyp2f1(1+1j, (3,2), 3.25, 2+3j), (0.17174552030925080445 + 0.19589781970539389999j))
+
+def test_fp_erf():
+    assert fp.erf(2) == fp.erf(2.0) == fp.erf(2.0+0.0j)
+    assert fp.erf(fp.inf) == 1.0
+    assert fp.erf(fp.ninf) == -1.0
+    assert ae(fp.erf(0), 0.0)
+    assert ae(fp.erf(-0), -0.0)
+    assert ae(fp.erf(0.3), 0.32862675945912741619)
+    assert ae(fp.erf(-0.3), -0.32862675945912741619)
+    assert ae(fp.erf(0.9), 0.79690821242283213966)
+    assert ae(fp.erf(-0.9), -0.79690821242283213966)
+    assert ae(fp.erf(1.0), 0.84270079294971486934)
+    assert ae(fp.erf(-1.0), -0.84270079294971486934)
+    assert ae(fp.erf(1.1), 0.88020506957408172966)
+    assert ae(fp.erf(-1.1), -0.88020506957408172966)
+    assert ae(fp.erf(8.5), 1.0)
+    assert ae(fp.erf(-8.5), -1.0)
+    assert ae(fp.erf(9.1), 1.0)
+    assert ae(fp.erf(-9.1), -1.0)
+    assert ae(fp.erf(20.0), 1.0)
+    assert ae(fp.erf(-20.0), -1.0)
+    assert ae(fp.erf(10000.0), 1.0)
+    assert ae(fp.erf(-10000.0), -1.0)
+    assert ae(fp.erf(1e+50), 1.0)
+    assert ae(fp.erf(-1e+50), -1.0)
+    assert ae(fp.erf(1j), 1.650425758797542876j)
+    assert ae(fp.erf(-1j), -1.650425758797542876j)
+    assert ae(fp.erf((2+3j)), (-20.829461427614568389 + 8.6873182714701631444j))
+    assert ae(fp.erf(-(2+3j)), -(-20.829461427614568389 + 8.6873182714701631444j))
+    assert ae(fp.erf((8+9j)), (-1072004.2525062051158 + 364149.91954310255423j))
+    assert ae(fp.erf(-(8+9j)), -(-1072004.2525062051158 + 364149.91954310255423j))
+    assert fp.erfc(fp.inf) == 0.0
+    assert fp.erfc(fp.ninf) == 2.0
+    assert fp.erfc(0) == 1
+    assert fp.erfc(-0.0) == 1
+    assert fp.erfc(0+0j) == 1
+    assert ae(fp.erfc(0.3), 0.67137324054087258381)
+    assert ae(fp.erfc(-0.3), 1.3286267594591274162)
+    assert ae(fp.erfc(0.9), 0.20309178757716786034)
+    assert ae(fp.erfc(-0.9), 1.7969082124228321397)
+    assert ae(fp.erfc(1.0), 0.15729920705028513066)
+    assert ae(fp.erfc(-1.0), 1.8427007929497148693)
+    assert ae(fp.erfc(1.1), 0.11979493042591827034)
+    assert ae(fp.erfc(-1.1), 1.8802050695740817297)
+    assert ae(fp.erfc(8.5), 2.7623240713337714461e-33)
+    assert ae(fp.erfc(-8.5), 2.0)
+    assert ae(fp.erfc(9.1), 6.6969004279886077452e-38)
+    assert ae(fp.erfc(-9.1), 2.0)
+    assert ae(fp.erfc(20.0), 5.3958656116079009289e-176)
+    assert ae(fp.erfc(-20.0), 2.0)
+    assert ae(fp.erfc(10000.0), 0.0)
+    assert ae(fp.erfc(-10000.0), 2.0)
+    assert ae(fp.erfc(1e+50), 0.0)
+    assert ae(fp.erfc(-1e+50), 2.0)
+    assert ae(fp.erfc(1j), (1.0 - 1.650425758797542876j))
+    assert ae(fp.erfc(-1j), (1.0 + 1.650425758797542876j))
+    assert ae(fp.erfc((2+3j)), (21.829461427614568389 - 8.6873182714701631444j), 1e-13)
+    assert ae(fp.erfc(-(2+3j)), (-19.829461427614568389 + 8.6873182714701631444j), 1e-13)
+    assert ae(fp.erfc((8+9j)), (1072005.2525062051158 - 364149.91954310255423j))
+    assert ae(fp.erfc(-(8+9j)), (-1072003.2525062051158 + 364149.91954310255423j))
+    assert ae(fp.erfc(20+0j), (5.3958656116079009289e-176 + 0.0j))
+
+def test_fp_lambertw():
+    assert ae(fp.lambertw(0.0), 0.0)
+    assert ae(fp.lambertw(1.0), 0.567143290409783873)
+    assert ae(fp.lambertw(7.5), 1.5662309537823875394)
+    assert ae(fp.lambertw(-0.25), -0.35740295618138890307)
+    assert ae(fp.lambertw(-10.0), (1.3699809685212708156 + 2.140194527074713196j))
+    assert ae(fp.lambertw(0+0j), (0.0 + 0.0j))
+    assert ae(fp.lambertw(4+0j), (1.2021678731970429392 + 0.0j))
+    assert ae(fp.lambertw(1000.5), 5.2500227450408980127)
+    assert ae(fp.lambertw(1e100), 224.84310644511850156)
+    assert ae(fp.lambertw(-1000.0), (5.1501630246362515223 + 2.6641981432905204596j))
+    assert ae(fp.lambertw(1e-10), 9.9999999990000003645e-11)
+    assert ae(fp.lambertw(1e-10j), (1.0000000000000000728e-20 + 1.0000000000000000364e-10j))
+    assert ae(fp.lambertw(3+4j), (1.2815618061237758782 + 0.53309522202097107131j))
+    assert ae(fp.lambertw(-3-4j), (1.0750730665692549276 - 1.3251023817343588823j))
+    assert ae(fp.lambertw(10000+1000j), (7.2361526563371602186 + 0.087567810943839352034j))
+    assert ae(fp.lambertw(0.0, -1), -fp.inf)
+    assert ae(fp.lambertw(1.0, -1), (-1.5339133197935745079 - 4.3751851530618983855j))
+    assert ae(fp.lambertw(7.5, -1), (0.44125668415098614999 - 4.8039842008452390179j))
+    assert ae(fp.lambertw(-0.25, -1), -2.1532923641103496492)
+    assert ae(fp.lambertw(-10.0, -1), (1.3699809685212708156 - 2.140194527074713196j))
+    assert ae(fp.lambertw(0+0j, -1), -fp.inf)
+    assert ae(fp.lambertw(4+0j, -1), (-0.15730793189620765317 - 4.6787800704666656212j))
+    assert ae(fp.lambertw(1000.5, -1), (4.9153765415404024736 - 5.4465682700815159569j))
+    assert ae(fp.lambertw(1e100, -1), (224.84272130101601052 - 6.2553713838167244141j))
+    assert ae(fp.lambertw(-1000.0, -1), (5.1501630246362515223 - 2.6641981432905204596j))
+    assert ae(fp.lambertw(1e-10, -1), (-26.303186778379041521 - 3.2650939117038283975j))
+    assert ae(fp.lambertw(1e-10j, -1), (-26.297238779529035028 - 1.6328071613455765135j))
+    assert ae(fp.lambertw(3+4j, -1), (0.25856740686699741676 - 3.8521166861614355895j))
+    assert ae(fp.lambertw(-3-4j, -1), (-0.32028750204310768396 - 6.8801677192091972343j))
+    assert ae(fp.lambertw(10000+1000j, -1), (7.0255308742285435567 - 5.5177506835734067601j))
+    assert ae(fp.lambertw(0.0, 2), -fp.inf)
+    assert ae(fp.lambertw(1.0, 2), (-2.4015851048680028842 + 10.776299516115070898j))
+    assert ae(fp.lambertw(7.5, 2), (-0.38003357962843791529 + 10.960916473368746184j))
+    assert ae(fp.lambertw(-0.25, 2), (-4.0558735269061511898 + 13.852334658567271386j))
+    assert ae(fp.lambertw(-10.0, 2), (-0.34479123764318858696 + 14.112740596763592363j))
+    assert ae(fp.lambertw(0+0j, 2), -fp.inf)
+    assert ae(fp.lambertw(4+0j, 2), (-1.0070343323804262788 + 10.903476551861683082j))
+    assert ae(fp.lambertw(1000.5, 2), (4.4076185165459395295 + 11.365524591091402177j))
+    assert ae(fp.lambertw(1e100, 2), (224.84156762724875878 + 12.510785262632255672j))
+    assert ae(fp.lambertw(-1000.0, 2), (4.1984245610246530756 + 14.420478573754313845j))
+    assert ae(fp.lambertw(1e-10, 2), (-26.362258095445866488 + 9.7800247407031482519j))
+    assert ae(fp.lambertw(1e-10j, 2), (-26.384250801683084252 + 11.403535950607739763j))
+    assert ae(fp.lambertw(3+4j, 2), (-0.86554679943333993562 + 11.849956798331992027j))
+    assert ae(fp.lambertw(-3-4j, 2), (-0.55792273874679112639 + 8.7173627024159324811j))
+    assert ae(fp.lambertw(10000+1000j, 2), (6.6223802254585662734 + 11.61348646825020766j))
+
+def test_fp_stress_ei_e1():
+    # Can be tightened on recent Pythons with more accurate math/cmath
+    ATOL = 1e-13
+    PTOL = 1e-12
+    v = fp.e1(1.1641532182693481445e-10)
+    assert ae(v, 22.296641293693077672, tol=ATOL)
+    assert type(v) is float
+    v = fp.e1(0.25)
+    assert ae(v, 1.0442826344437381945, tol=ATOL)
+    assert type(v) is float
+    v = fp.e1(1.0)
+    assert ae(v, 0.21938393439552027368, tol=ATOL)
+    assert type(v) is float
+    v = fp.e1(2.0)
+    assert ae(v, 0.048900510708061119567, tol=ATOL)
+    assert type(v) is float
+    v = fp.e1(5.0)
+    assert ae(v, 0.0011482955912753257973, tol=ATOL)
+    assert type(v) is float
+    v = fp.e1(20.0)
+    assert ae(v, 9.8355252906498816904e-11, tol=ATOL)
+    assert type(v) is float
+    v = fp.e1(30.0)
+    assert ae(v, 3.0215520106888125448e-15, tol=ATOL)
+    assert type(v) is float
+    v = fp.e1(40.0)
+    assert ae(v, 1.0367732614516569722e-19, tol=ATOL)
+    assert type(v) is float
+    v = fp.e1(50.0)
+    assert ae(v, 3.7832640295504590187e-24, tol=ATOL)
+    assert type(v) is float
+    v = fp.e1(80.0)
+    assert ae(v, 2.2285432586884729112e-37, tol=ATOL)
+    assert type(v) is float
+    v = fp.e1((1.1641532182693481445e-10 + 0.0j))
+    assert ae(v, (22.296641293693077672 + 0.0j), tol=ATOL)
+    assert ae(v.real, 22.296641293693077672, tol=PTOL)
+    assert v.imag == 0
+    v = fp.e1((0.25 + 0.0j))
+    assert ae(v, (1.0442826344437381945 + 0.0j), tol=ATOL)
+    assert ae(v.real, 1.0442826344437381945, tol=PTOL)
+    assert v.imag == 0
+    v = fp.e1((1.0 + 0.0j))
+    assert ae(v, (0.21938393439552027368 + 0.0j), tol=ATOL)
+    assert ae(v.real, 0.21938393439552027368, tol=PTOL)
+    assert v.imag == 0
+    v = fp.e1((2.0 + 0.0j))
+    assert ae(v, (0.048900510708061119567 + 0.0j), tol=ATOL)
+    assert ae(v.real, 0.048900510708061119567, tol=PTOL)
+    assert v.imag == 0
+    v = fp.e1((5.0 + 0.0j))
+    assert ae(v, (0.0011482955912753257973 + 0.0j), tol=ATOL)
+    assert ae(v.real, 0.0011482955912753257973, tol=PTOL)
+    assert v.imag == 0
+    v = fp.e1((20.0 + 0.0j))
+    assert ae(v, (9.8355252906498816904e-11 + 0.0j), tol=ATOL)
+    assert ae(v.real, 9.8355252906498816904e-11, tol=PTOL)
+    assert v.imag == 0
+    v = fp.e1((30.0 + 0.0j))
+    assert ae(v, (3.0215520106888125448e-15 + 0.0j), tol=ATOL)
+    assert ae(v.real, 3.0215520106888125448e-15, tol=PTOL)
+    assert v.imag == 0
+    v = fp.e1((40.0 + 0.0j))
+    assert ae(v, (1.0367732614516569722e-19 + 0.0j), tol=ATOL)
+    assert ae(v.real, 1.0367732614516569722e-19, tol=PTOL)
+    assert v.imag == 0
+    v = fp.e1((50.0 + 0.0j))
+    assert ae(v, (3.7832640295504590187e-24 + 0.0j), tol=ATOL)
+    assert ae(v.real, 3.7832640295504590187e-24, tol=PTOL)
+    assert v.imag == 0
+    v = fp.e1((80.0 + 0.0j))
+    assert ae(v, (2.2285432586884729112e-37 + 0.0j), tol=ATOL)
+    assert ae(v.real, 2.2285432586884729112e-37, tol=PTOL)
+    assert v.imag == 0
+    v = fp.e1((4.6566128730773925781e-10 + 1.1641532182693481445e-10j))
+    assert ae(v, (20.880034622014215597 - 0.24497866301044883237j), tol=ATOL)
+    assert ae(v.real, 20.880034622014215597, tol=PTOL)
+    assert ae(v.imag, -0.24497866301044883237, tol=PTOL)
+    v = fp.e1((1.0 + 0.25j))
+    assert ae(v, (0.19731063945004229095 - 0.087366045774299963672j), tol=ATOL)
+    assert ae(v.real, 0.19731063945004229095, tol=PTOL)
+    assert ae(v.imag, -0.087366045774299963672, tol=PTOL)
+    v = fp.e1((4.0 + 1.0j))
+    assert ae(v, (0.0013106173980145506944 - 0.0034542480199350626699j), tol=ATOL)
+    assert ae(v.real, 0.0013106173980145506944, tol=PTOL)
+    assert ae(v.imag, -0.0034542480199350626699, tol=PTOL)
+    v = fp.e1((8.0 + 2.0j))
+    assert ae(v, (-0.000022278049065270225945 - 0.000029191940456521555288j), tol=ATOL)
+    assert ae(v.real, -0.000022278049065270225945, tol=PTOL)
+    assert ae(v.imag, -0.000029191940456521555288, tol=PTOL)
+    v = fp.e1((20.0 + 5.0j))
+    assert ae(v, (4.7711374515765346894e-11 + 8.2902652405126947359e-11j), tol=ATOL)
+    assert ae(v.real, 4.7711374515765346894e-11, tol=PTOL)
+    assert ae(v.imag, 8.2902652405126947359e-11, tol=PTOL)
+    v = fp.e1((80.0 + 20.0j))
+    assert ae(v, (3.8353473865788235787e-38 - 2.129247592349605139e-37j), tol=ATOL)
+    assert ae(v.real, 3.8353473865788235787e-38, tol=PTOL)
+    assert ae(v.imag, -2.129247592349605139e-37, tol=PTOL)
+    v = fp.e1((120.0 + 30.0j))
+    assert ae(v, (2.3836002337480334716e-55 + 5.6704043587126198306e-55j), tol=ATOL)
+    assert ae(v.real, 2.3836002337480334716e-55, tol=PTOL)
+    assert ae(v.imag, 5.6704043587126198306e-55, tol=PTOL)
+    v = fp.e1((160.0 + 40.0j))
+    assert ae(v, (-1.6238022898654510661e-72 - 1.104172355572287367e-72j), tol=ATOL)
+    assert ae(v.real, -1.6238022898654510661e-72, tol=PTOL)
+    assert ae(v.imag, -1.104172355572287367e-72, tol=PTOL)
+    v = fp.e1((200.0 + 50.0j))
+    assert ae(v, (6.6800061461666228487e-90 + 1.4473816083541016115e-91j), tol=ATOL)
+    assert ae(v.real, 6.6800061461666228487e-90, tol=PTOL)
+    assert ae(v.imag, 1.4473816083541016115e-91, tol=PTOL)
+    v = fp.e1((320.0 + 80.0j))
+    assert ae(v, (4.2737871527778786157e-143 + 3.1789935525785660314e-142j), tol=ATOL)
+    assert ae(v.real, 4.2737871527778786157e-143, tol=PTOL)
+    assert ae(v.imag, 3.1789935525785660314e-142, tol=PTOL)
+    v = fp.e1((1.1641532182693481445e-10 + 1.1641532182693481445e-10j))
+    assert ae(v, (21.950067703413105017 - 0.7853981632810329878j), tol=ATOL)
+    assert ae(v.real, 21.950067703413105017, tol=PTOL)
+    assert ae(v.imag, -0.7853981632810329878, tol=PTOL)
+    v = fp.e1((0.25 + 0.25j))
+    assert ae(v, (0.71092525792923287894 - 0.56491812441304194711j), tol=ATOL)
+    assert ae(v.real, 0.71092525792923287894, tol=PTOL)
+    assert ae(v.imag, -0.56491812441304194711, tol=PTOL)
+    v = fp.e1((1.0 + 1.0j))
+    assert ae(v, (0.00028162445198141832551 - 0.17932453503935894015j), tol=ATOL)
+    assert ae(v.real, 0.00028162445198141832551, tol=PTOL)
+    assert ae(v.imag, -0.17932453503935894015, tol=PTOL)
+    v = fp.e1((2.0 + 2.0j))
+    assert ae(v, (-0.033767089606562004246 - 0.018599414169750541925j), tol=ATOL)
+    assert ae(v.real, -0.033767089606562004246, tol=PTOL)
+    assert ae(v.imag, -0.018599414169750541925, tol=PTOL)
+    v = fp.e1((5.0 + 5.0j))
+    assert ae(v, (0.0007266506660356393891 + 0.00047102780163522245054j), tol=ATOL)
+    assert ae(v.real, 0.0007266506660356393891, tol=PTOL)
+    assert ae(v.imag, 0.00047102780163522245054, tol=PTOL)
+    v = fp.e1((20.0 + 20.0j))
+    assert ae(v, (-2.3824537449367396579e-11 - 6.6969873156525615158e-11j), tol=ATOL)
+    assert ae(v.real, -2.3824537449367396579e-11, tol=PTOL)
+    assert ae(v.imag, -6.6969873156525615158e-11, tol=PTOL)
+    v = fp.e1((30.0 + 30.0j))
+    assert ae(v, (1.7316045841744061617e-15 + 1.3065678019487308689e-15j), tol=ATOL)
+    assert ae(v.real, 1.7316045841744061617e-15, tol=PTOL)
+    assert ae(v.imag, 1.3065678019487308689e-15, tol=PTOL)
+    v = fp.e1((40.0 + 40.0j))
+    assert ae(v, (-7.4001043002899232182e-20 - 4.991847855336816304e-21j), tol=ATOL)
+    assert ae(v.real, -7.4001043002899232182e-20, tol=PTOL)
+    assert ae(v.imag, -4.991847855336816304e-21, tol=PTOL)
+    v = fp.e1((50.0 + 50.0j))
+    assert ae(v, (2.3566128324644641219e-24 - 1.3188326726201614778e-24j), tol=ATOL)
+    assert ae(v.real, 2.3566128324644641219e-24, tol=PTOL)
+    assert ae(v.imag, -1.3188326726201614778e-24, tol=PTOL)
+    v = fp.e1((80.0 + 80.0j))
+    assert ae(v, (9.8279750572186526673e-38 + 1.243952841288868831e-37j), tol=ATOL)
+    assert ae(v.real, 9.8279750572186526673e-38, tol=PTOL)
+    assert ae(v.imag, 1.243952841288868831e-37, tol=PTOL)
+    v = fp.e1((1.1641532182693481445e-10 + 4.6566128730773925781e-10j))
+    assert ae(v, (20.880034621664969632 - 1.3258176632023711778j), tol=ATOL)
+    assert ae(v.real, 20.880034621664969632, tol=PTOL)
+    assert ae(v.imag, -1.3258176632023711778, tol=PTOL)
+    v = fp.e1((0.25 + 1.0j))
+    assert ae(v, (-0.16868306393667788761 - 0.4858011885947426971j), tol=ATOL)
+    assert ae(v.real, -0.16868306393667788761, tol=PTOL)
+    assert ae(v.imag, -0.4858011885947426971, tol=PTOL)
+    v = fp.e1((1.0 + 4.0j))
+    assert ae(v, (0.03373591813926547318 + 0.073523452241083821877j), tol=ATOL)
+    assert ae(v.real, 0.03373591813926547318, tol=PTOL)
+    assert ae(v.imag, 0.073523452241083821877, tol=PTOL)
+    v = fp.e1((2.0 + 8.0j))
+    assert ae(v, (-0.015392833434733785143 - 0.0031747121557605415914j), tol=ATOL)
+    assert ae(v.real, -0.015392833434733785143, tol=PTOL)
+    assert ae(v.imag, -0.0031747121557605415914, tol=PTOL)
+    v = fp.e1((5.0 + 20.0j))
+    assert ae(v, (-0.00024419662286542966525 - 0.00021008322966152755674j), tol=ATOL)
+    assert ae(v.real, -0.00024419662286542966525, tol=PTOL)
+    assert ae(v.imag, -0.00021008322966152755674, tol=PTOL)
+    v = fp.e1((20.0 + 80.0j))
+    assert ae(v, (2.3255552781051330088e-11 + 8.9463918891349438007e-12j), tol=ATOL)
+    assert ae(v.real, 2.3255552781051330088e-11, tol=PTOL)
+    assert ae(v.imag, 8.9463918891349438007e-12, tol=PTOL)
+    v = fp.e1((30.0 + 120.0j))
+    assert ae(v, (-2.7068919097124652332e-16 - 7.0477762411705130239e-16j), tol=ATOL)
+    assert ae(v.real, -2.7068919097124652332e-16, tol=PTOL)
+    assert ae(v.imag, -7.0477762411705130239e-16, tol=PTOL)
+    v = fp.e1((40.0 + 160.0j))
+    assert ae(v, (-1.1695597827678024687e-20 + 2.2907401455645736661e-20j), tol=ATOL)
+    assert ae(v.real, -1.1695597827678024687e-20, tol=PTOL)
+    assert ae(v.imag, 2.2907401455645736661e-20, tol=PTOL)
+    v = fp.e1((50.0 + 200.0j))
+    assert ae(v, (9.0323746914410162531e-25 - 2.3950601790033530935e-25j), tol=ATOL)
+    assert ae(v.real, 9.0323746914410162531e-25, tol=PTOL)
+    assert ae(v.imag, -2.3950601790033530935e-25, tol=PTOL)
+    v = fp.e1((80.0 + 320.0j))
+    assert ae(v, (3.4819106748728063576e-38 - 4.215653005615772724e-38j), tol=ATOL)
+    assert ae(v.real, 3.4819106748728063576e-38, tol=PTOL)
+    assert ae(v.imag, -4.215653005615772724e-38, tol=PTOL)
+    v = fp.e1((0.0 + 1.1641532182693481445e-10j))
+    assert ae(v, (22.29664129357666235 - 1.5707963266784812974j), tol=ATOL)
+    assert ae(v.real, 22.29664129357666235, tol=PTOL)
+    assert ae(v.imag, -1.5707963266784812974, tol=PTOL)
+    v = fp.e1((0.0 + 0.25j))
+    assert ae(v, (0.82466306258094565309 - 1.3216627564751394551j), tol=ATOL)
+    assert ae(v.real, 0.82466306258094565309, tol=PTOL)
+    assert ae(v.imag, -1.3216627564751394551, tol=PTOL)
+    v = fp.e1((0.0 + 1.0j))
+    assert ae(v, (-0.33740392290096813466 - 0.62471325642771360429j), tol=ATOL)
+    assert ae(v.real, -0.33740392290096813466, tol=PTOL)
+    assert ae(v.imag, -0.62471325642771360429, tol=PTOL)
+    v = fp.e1((0.0 + 2.0j))
+    assert ae(v, (-0.4229808287748649957 + 0.034616650007798229345j), tol=ATOL)
+    assert ae(v.real, -0.4229808287748649957, tol=PTOL)
+    assert ae(v.imag, 0.034616650007798229345, tol=PTOL)
+    v = fp.e1((0.0 + 5.0j))
+    assert ae(v, (0.19002974965664387862 - 0.020865081850222481957j), tol=ATOL)
+    assert ae(v.real, 0.19002974965664387862, tol=PTOL)
+    assert ae(v.imag, -0.020865081850222481957, tol=PTOL)
+    v = fp.e1((0.0 + 20.0j))
+    assert ae(v, (-0.04441982084535331654 - 0.022554625751456779068j), tol=ATOL)
+    assert ae(v.real, -0.04441982084535331654, tol=PTOL)
+    assert ae(v.imag, -0.022554625751456779068, tol=PTOL)
+    v = fp.e1((0.0 + 30.0j))
+    assert ae(v, (0.033032417282071143779 - 0.0040397867645455082476j), tol=ATOL)
+    assert ae(v.real, 0.033032417282071143779, tol=PTOL)
+    assert ae(v.imag, -0.0040397867645455082476, tol=PTOL)
+    v = fp.e1((0.0 + 40.0j))
+    assert ae(v, (-0.019020007896208766962 + 0.016188792559887887544j), tol=ATOL)
+    assert ae(v.real, -0.019020007896208766962, tol=PTOL)
+    assert ae(v.imag, 0.016188792559887887544, tol=PTOL)
+    v = fp.e1((0.0 + 50.0j))
+    assert ae(v, (0.0056283863241163054402 - 0.019179254308960724503j), tol=ATOL)
+    assert ae(v.real, 0.0056283863241163054402, tol=PTOL)
+    assert ae(v.imag, -0.019179254308960724503, tol=PTOL)
+    v = fp.e1((0.0 + 80.0j))
+    assert ae(v, (0.012402501155070958192 + 0.0015345601175906961199j), tol=ATOL)
+    assert ae(v.real, 0.012402501155070958192, tol=PTOL)
+    assert ae(v.imag, 0.0015345601175906961199, tol=PTOL)
+    v = fp.e1((-1.1641532182693481445e-10 + 4.6566128730773925781e-10j))
+    assert ae(v, (20.880034621432138988 - 1.8157749894560994861j), tol=ATOL)
+    assert ae(v.real, 20.880034621432138988, tol=PTOL)
+    assert ae(v.imag, -1.8157749894560994861, tol=PTOL)
+    v = fp.e1((-0.25 + 1.0j))
+    assert ae(v, (-0.59066621214766308594 - 0.74474454765205036972j), tol=ATOL)
+    assert ae(v.real, -0.59066621214766308594, tol=PTOL)
+    assert ae(v.imag, -0.74474454765205036972, tol=PTOL)
+    v = fp.e1((-1.0 + 4.0j))
+    assert ae(v, (0.49739047283060471093 + 0.41543605404038863174j), tol=ATOL)
+    assert ae(v.real, 0.49739047283060471093, tol=PTOL)
+    assert ae(v.imag, 0.41543605404038863174, tol=PTOL)
+    v = fp.e1((-2.0 + 8.0j))
+    assert ae(v, (-0.8705211147733730969 + 0.24099328498605539667j), tol=ATOL)
+    assert ae(v.real, -0.8705211147733730969, tol=PTOL)
+    assert ae(v.imag, 0.24099328498605539667, tol=PTOL)
+    v = fp.e1((-5.0 + 20.0j))
+    assert ae(v, (-7.0789514293925893007 - 1.6102177171960790536j), tol=ATOL)
+    assert ae(v.real, -7.0789514293925893007, tol=PTOL)
+    assert ae(v.imag, -1.6102177171960790536, tol=PTOL)
+    v = fp.e1((-20.0 + 80.0j))
+    assert ae(v, (5855431.4907298084434 - 720920.93315409165707j), tol=ATOL)
+    assert ae(v.real, 5855431.4907298084434, tol=PTOL)
+    assert ae(v.imag, -720920.93315409165707, tol=PTOL)
+    v = fp.e1((-30.0 + 120.0j))
+    assert ae(v, (-65402491644.703470747 - 56697658399.657460294j), tol=ATOL)
+    assert ae(v.real, -65402491644.703470747, tol=PTOL)
+    assert ae(v.imag, -56697658399.657460294, tol=PTOL)
+    v = fp.e1((-40.0 + 160.0j))
+    assert ae(v, (25504929379604.776769 + 1429035198630573.2463j), tol=ATOL)
+    assert ae(v.real, 25504929379604.776769, tol=PTOL)
+    assert ae(v.imag, 1429035198630573.2463, tol=PTOL)
+    v = fp.e1((-50.0 + 200.0j))
+    assert ae(v, (18437746526988116954.0 - 17146362239046152345.0j), tol=ATOL)
+    assert ae(v.real, 18437746526988116954.0, tol=PTOL)
+    assert ae(v.imag, -17146362239046152345.0, tol=PTOL)
+    v = fp.e1((-80.0 + 320.0j))
+    assert ae(v, (3.3464697299634526706e+31 - 1.6473152633843023919e+32j), tol=ATOL)
+    assert ae(v.real, 3.3464697299634526706e+31, tol=PTOL)
+    assert ae(v.imag, -1.6473152633843023919e+32, tol=PTOL)
+    v = fp.e1((-4.6566128730773925781e-10 + 1.1641532182693481445e-10j))
+    assert ae(v, (20.880034621082893023 - 2.8966139903465137624j), tol=ATOL)
+    assert ae(v.real, 20.880034621082893023, tol=PTOL)
+    assert ae(v.imag, -2.8966139903465137624, tol=PTOL)
+    v = fp.e1((-1.0 + 0.25j))
+    assert ae(v, (-1.8942716983721074932 - 2.4689102827070540799j), tol=ATOL)
+    assert ae(v.real, -1.8942716983721074932, tol=PTOL)
+    assert ae(v.imag, -2.4689102827070540799, tol=PTOL)
+    v = fp.e1((-4.0 + 1.0j))
+    assert ae(v, (-14.806699492675420438 + 9.1384225230837893776j), tol=ATOL)
+    assert ae(v.real, -14.806699492675420438, tol=PTOL)
+    assert ae(v.imag, 9.1384225230837893776, tol=PTOL)
+    v = fp.e1((-8.0 + 2.0j))
+    assert ae(v, (54.633252667426386294 + 413.20318163814670688j), tol=ATOL)
+    assert ae(v.real, 54.633252667426386294, tol=PTOL)
+    assert ae(v.imag, 413.20318163814670688, tol=PTOL)
+    v = fp.e1((-20.0 + 5.0j))
+    assert ae(v, (-711836.97165402624643 - 24745250.939695900956j), tol=ATOL)
+    assert ae(v.real, -711836.97165402624643, tol=PTOL)
+    assert ae(v.imag, -24745250.939695900956, tol=PTOL)
+    v = fp.e1((-80.0 + 20.0j))
+    assert ae(v, (-4.2139911108612653091e+32 + 5.3367124741918251637e+32j), tol=ATOL)
+    assert ae(v.real, -4.2139911108612653091e+32, tol=PTOL)
+    assert ae(v.imag, 5.3367124741918251637e+32, tol=PTOL)
+    v = fp.e1((-120.0 + 30.0j))
+    assert ae(v, (9.7760616203707508892e+48 - 1.058257682317195792e+50j), tol=ATOL)
+    assert ae(v.real, 9.7760616203707508892e+48, tol=PTOL)
+    assert ae(v.imag, -1.058257682317195792e+50, tol=PTOL)
+    v = fp.e1((-160.0 + 40.0j))
+    assert ae(v, (8.7065541466623638861e+66 + 1.6577106725141739889e+67j), tol=ATOL)
+    assert ae(v.real, 8.7065541466623638861e+66, tol=PTOL)
+    assert ae(v.imag, 1.6577106725141739889e+67, tol=PTOL)
+    v = fp.e1((-200.0 + 50.0j))
+    assert ae(v, (-3.070744996327018106e+84 - 1.7243244846769415903e+84j), tol=ATOL)
+    assert ae(v.real, -3.070744996327018106e+84, tol=PTOL)
+    assert ae(v.imag, -1.7243244846769415903e+84, tol=PTOL)
+    v = fp.e1((-320.0 + 80.0j))
+    assert ae(v, (9.9960598637998647276e+135 - 2.6855081527595608863e+136j), tol=ATOL)
+    assert ae(v.real, 9.9960598637998647276e+135, tol=PTOL)
+    assert ae(v.imag, -2.6855081527595608863e+136, tol=PTOL)
+    v = fp.e1(-1.1641532182693481445e-10)
+    assert ae(v, (22.296641293460247028 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, 22.296641293460247028, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1(-0.25)
+    assert ae(v, (0.54254326466191372953 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, 0.54254326466191372953, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1(-1.0)
+    assert ae(v, (-1.8951178163559367555 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -1.8951178163559367555, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1(-2.0)
+    assert ae(v, (-4.9542343560018901634 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -4.9542343560018901634, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1(-5.0)
+    assert ae(v, (-40.185275355803177455 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -40.185275355803177455, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1(-20.0)
+    assert ae(v, (-25615652.66405658882 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -25615652.66405658882, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1(-30.0)
+    assert ae(v, (-368973209407.27419706 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -368973209407.27419706, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1(-40.0)
+    assert ae(v, (-6039718263611241.5784 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -6039718263611241.5784, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1(-50.0)
+    assert ae(v, (-1.0585636897131690963e+20 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -1.0585636897131690963e+20, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1(-80.0)
+    assert ae(v, (-7.0146000049047999696e+32 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -7.0146000049047999696e+32, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1((-1.1641532182693481445e-10 + 0.0j))
+    assert ae(v, (22.296641293460247028 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, 22.296641293460247028, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1((-0.25 + 0.0j))
+    assert ae(v, (0.54254326466191372953 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, 0.54254326466191372953, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1((-1.0 + 0.0j))
+    assert ae(v, (-1.8951178163559367555 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -1.8951178163559367555, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1((-2.0 + 0.0j))
+    assert ae(v, (-4.9542343560018901634 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -4.9542343560018901634, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1((-5.0 + 0.0j))
+    assert ae(v, (-40.185275355803177455 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -40.185275355803177455, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1((-20.0 + 0.0j))
+    assert ae(v, (-25615652.66405658882 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -25615652.66405658882, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1((-30.0 + 0.0j))
+    assert ae(v, (-368973209407.27419706 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -368973209407.27419706, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1((-40.0 + 0.0j))
+    assert ae(v, (-6039718263611241.5784 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -6039718263611241.5784, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1((-50.0 + 0.0j))
+    assert ae(v, (-1.0585636897131690963e+20 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -1.0585636897131690963e+20, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1((-80.0 + 0.0j))
+    assert ae(v, (-7.0146000049047999696e+32 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -7.0146000049047999696e+32, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.e1((-4.6566128730773925781e-10 - 1.1641532182693481445e-10j))
+    assert ae(v, (20.880034621082893023 + 2.8966139903465137624j), tol=ATOL)
+    assert ae(v.real, 20.880034621082893023, tol=PTOL)
+    assert ae(v.imag, 2.8966139903465137624, tol=PTOL)
+    v = fp.e1((-1.0 - 0.25j))
+    assert ae(v, (-1.8942716983721074932 + 2.4689102827070540799j), tol=ATOL)
+    assert ae(v.real, -1.8942716983721074932, tol=PTOL)
+    assert ae(v.imag, 2.4689102827070540799, tol=PTOL)
+    v = fp.e1((-4.0 - 1.0j))
+    assert ae(v, (-14.806699492675420438 - 9.1384225230837893776j), tol=ATOL)
+    assert ae(v.real, -14.806699492675420438, tol=PTOL)
+    assert ae(v.imag, -9.1384225230837893776, tol=PTOL)
+    v = fp.e1((-8.0 - 2.0j))
+    assert ae(v, (54.633252667426386294 - 413.20318163814670688j), tol=ATOL)
+    assert ae(v.real, 54.633252667426386294, tol=PTOL)
+    assert ae(v.imag, -413.20318163814670688, tol=PTOL)
+    v = fp.e1((-20.0 - 5.0j))
+    assert ae(v, (-711836.97165402624643 + 24745250.939695900956j), tol=ATOL)
+    assert ae(v.real, -711836.97165402624643, tol=PTOL)
+    assert ae(v.imag, 24745250.939695900956, tol=PTOL)
+    v = fp.e1((-80.0 - 20.0j))
+    assert ae(v, (-4.2139911108612653091e+32 - 5.3367124741918251637e+32j), tol=ATOL)
+    assert ae(v.real, -4.2139911108612653091e+32, tol=PTOL)
+    assert ae(v.imag, -5.3367124741918251637e+32, tol=PTOL)
+    v = fp.e1((-120.0 - 30.0j))
+    assert ae(v, (9.7760616203707508892e+48 + 1.058257682317195792e+50j), tol=ATOL)
+    assert ae(v.real, 9.7760616203707508892e+48, tol=PTOL)
+    assert ae(v.imag, 1.058257682317195792e+50, tol=PTOL)
+    v = fp.e1((-160.0 - 40.0j))
+    assert ae(v, (8.7065541466623638861e+66 - 1.6577106725141739889e+67j), tol=ATOL)
+    assert ae(v.real, 8.7065541466623638861e+66, tol=PTOL)
+    assert ae(v.imag, -1.6577106725141739889e+67, tol=PTOL)
+    v = fp.e1((-200.0 - 50.0j))
+    assert ae(v, (-3.070744996327018106e+84 + 1.7243244846769415903e+84j), tol=ATOL)
+    assert ae(v.real, -3.070744996327018106e+84, tol=PTOL)
+    assert ae(v.imag, 1.7243244846769415903e+84, tol=PTOL)
+    v = fp.e1((-320.0 - 80.0j))
+    assert ae(v, (9.9960598637998647276e+135 + 2.6855081527595608863e+136j), tol=ATOL)
+    assert ae(v.real, 9.9960598637998647276e+135, tol=PTOL)
+    assert ae(v.imag, 2.6855081527595608863e+136, tol=PTOL)
+    v = fp.e1((-1.1641532182693481445e-10 - 1.1641532182693481445e-10j))
+    assert ae(v, (21.950067703180274374 + 2.356194490075929607j), tol=ATOL)
+    assert ae(v.real, 21.950067703180274374, tol=PTOL)
+    assert ae(v.imag, 2.356194490075929607, tol=PTOL)
+    v = fp.e1((-0.25 - 0.25j))
+    assert ae(v, (0.21441047326710323254 + 2.0732153554307936389j), tol=ATOL)
+    assert ae(v.real, 0.21441047326710323254, tol=PTOL)
+    assert ae(v.imag, 2.0732153554307936389, tol=PTOL)
+    v = fp.e1((-1.0 - 1.0j))
+    assert ae(v, (-1.7646259855638540684 + 0.7538228020792708192j), tol=ATOL)
+    assert ae(v.real, -1.7646259855638540684, tol=PTOL)
+    assert ae(v.imag, 0.7538228020792708192, tol=PTOL)
+    v = fp.e1((-2.0 - 2.0j))
+    assert ae(v, (-1.8920781621855474089 - 2.1753697842428647236j), tol=ATOL)
+    assert ae(v.real, -1.8920781621855474089, tol=PTOL)
+    assert ae(v.imag, -2.1753697842428647236, tol=PTOL)
+    v = fp.e1((-5.0 - 5.0j))
+    assert ae(v, (13.470936071475245856 + 18.464085049321024206j), tol=ATOL)
+    assert ae(v.real, 13.470936071475245856, tol=PTOL)
+    assert ae(v.imag, 18.464085049321024206, tol=PTOL)
+    v = fp.e1((-20.0 - 20.0j))
+    assert ae(v, (-16589317.398788971896 - 5831702.3296441771206j), tol=ATOL)
+    assert ae(v.real, -16589317.398788971896, tol=PTOL)
+    assert ae(v.imag, -5831702.3296441771206, tol=PTOL)
+    v = fp.e1((-30.0 - 30.0j))
+    assert ae(v, (154596484273.69322527 + 204179357837.41389696j), tol=ATOL)
+    assert ae(v.real, 154596484273.69322527, tol=PTOL)
+    assert ae(v.imag, 204179357837.41389696, tol=PTOL)
+    v = fp.e1((-40.0 - 40.0j))
+    assert ae(v, (-287512180321448.45408 - 4203502407932314.974j), tol=ATOL)
+    assert ae(v.real, -287512180321448.45408, tol=PTOL)
+    assert ae(v.imag, -4203502407932314.974, tol=PTOL)
+    v = fp.e1((-50.0 - 50.0j))
+    assert ae(v, (-36128528616649268826.0 + 64648801861338741963.0j), tol=ATOL)
+    assert ae(v.real, -36128528616649268826.0, tol=PTOL)
+    assert ae(v.imag, 64648801861338741963.0, tol=PTOL)
+    v = fp.e1((-80.0 - 80.0j))
+    assert ae(v, (3.8674816337930010217e+32 + 3.0540709639658071041e+32j), tol=ATOL)
+    assert ae(v.real, 3.8674816337930010217e+32, tol=PTOL)
+    assert ae(v.imag, 3.0540709639658071041e+32, tol=PTOL)
+    v = fp.e1((-1.1641532182693481445e-10 - 4.6566128730773925781e-10j))
+    assert ae(v, (20.880034621432138988 + 1.8157749894560994861j), tol=ATOL)
+    assert ae(v.real, 20.880034621432138988, tol=PTOL)
+    assert ae(v.imag, 1.8157749894560994861, tol=PTOL)
+    v = fp.e1((-0.25 - 1.0j))
+    assert ae(v, (-0.59066621214766308594 + 0.74474454765205036972j), tol=ATOL)
+    assert ae(v.real, -0.59066621214766308594, tol=PTOL)
+    assert ae(v.imag, 0.74474454765205036972, tol=PTOL)
+    v = fp.e1((-1.0 - 4.0j))
+    assert ae(v, (0.49739047283060471093 - 0.41543605404038863174j), tol=ATOL)
+    assert ae(v.real, 0.49739047283060471093, tol=PTOL)
+    assert ae(v.imag, -0.41543605404038863174, tol=PTOL)
+    v = fp.e1((-2.0 - 8.0j))
+    assert ae(v, (-0.8705211147733730969 - 0.24099328498605539667j), tol=ATOL)
+    assert ae(v.real, -0.8705211147733730969, tol=PTOL)
+    assert ae(v.imag, -0.24099328498605539667, tol=PTOL)
+    v = fp.e1((-5.0 - 20.0j))
+    assert ae(v, (-7.0789514293925893007 + 1.6102177171960790536j), tol=ATOL)
+    assert ae(v.real, -7.0789514293925893007, tol=PTOL)
+    assert ae(v.imag, 1.6102177171960790536, tol=PTOL)
+    v = fp.e1((-20.0 - 80.0j))
+    assert ae(v, (5855431.4907298084434 + 720920.93315409165707j), tol=ATOL)
+    assert ae(v.real, 5855431.4907298084434, tol=PTOL)
+    assert ae(v.imag, 720920.93315409165707, tol=PTOL)
+    v = fp.e1((-30.0 - 120.0j))
+    assert ae(v, (-65402491644.703470747 + 56697658399.657460294j), tol=ATOL)
+    assert ae(v.real, -65402491644.703470747, tol=PTOL)
+    assert ae(v.imag, 56697658399.657460294, tol=PTOL)
+    v = fp.e1((-40.0 - 160.0j))
+    assert ae(v, (25504929379604.776769 - 1429035198630573.2463j), tol=ATOL)
+    assert ae(v.real, 25504929379604.776769, tol=PTOL)
+    assert ae(v.imag, -1429035198630573.2463, tol=PTOL)
+    v = fp.e1((-50.0 - 200.0j))
+    assert ae(v, (18437746526988116954.0 + 17146362239046152345.0j), tol=ATOL)
+    assert ae(v.real, 18437746526988116954.0, tol=PTOL)
+    assert ae(v.imag, 17146362239046152345.0, tol=PTOL)
+    v = fp.e1((-80.0 - 320.0j))
+    assert ae(v, (3.3464697299634526706e+31 + 1.6473152633843023919e+32j), tol=ATOL)
+    assert ae(v.real, 3.3464697299634526706e+31, tol=PTOL)
+    assert ae(v.imag, 1.6473152633843023919e+32, tol=PTOL)
+    v = fp.e1((0.0 - 1.1641532182693481445e-10j))
+    assert ae(v, (22.29664129357666235 + 1.5707963266784812974j), tol=ATOL)
+    assert ae(v.real, 22.29664129357666235, tol=PTOL)
+    assert ae(v.imag, 1.5707963266784812974, tol=PTOL)
+    v = fp.e1((0.0 - 0.25j))
+    assert ae(v, (0.82466306258094565309 + 1.3216627564751394551j), tol=ATOL)
+    assert ae(v.real, 0.82466306258094565309, tol=PTOL)
+    assert ae(v.imag, 1.3216627564751394551, tol=PTOL)
+    v = fp.e1((0.0 - 1.0j))
+    assert ae(v, (-0.33740392290096813466 + 0.62471325642771360429j), tol=ATOL)
+    assert ae(v.real, -0.33740392290096813466, tol=PTOL)
+    assert ae(v.imag, 0.62471325642771360429, tol=PTOL)
+    v = fp.e1((0.0 - 2.0j))
+    assert ae(v, (-0.4229808287748649957 - 0.034616650007798229345j), tol=ATOL)
+    assert ae(v.real, -0.4229808287748649957, tol=PTOL)
+    assert ae(v.imag, -0.034616650007798229345, tol=PTOL)
+    v = fp.e1((0.0 - 5.0j))
+    assert ae(v, (0.19002974965664387862 + 0.020865081850222481957j), tol=ATOL)
+    assert ae(v.real, 0.19002974965664387862, tol=PTOL)
+    assert ae(v.imag, 0.020865081850222481957, tol=PTOL)
+    v = fp.e1((0.0 - 20.0j))
+    assert ae(v, (-0.04441982084535331654 + 0.022554625751456779068j), tol=ATOL)
+    assert ae(v.real, -0.04441982084535331654, tol=PTOL)
+    assert ae(v.imag, 0.022554625751456779068, tol=PTOL)
+    v = fp.e1((0.0 - 30.0j))
+    assert ae(v, (0.033032417282071143779 + 0.0040397867645455082476j), tol=ATOL)
+    assert ae(v.real, 0.033032417282071143779, tol=PTOL)
+    assert ae(v.imag, 0.0040397867645455082476, tol=PTOL)
+    v = fp.e1((0.0 - 40.0j))
+    assert ae(v, (-0.019020007896208766962 - 0.016188792559887887544j), tol=ATOL)
+    assert ae(v.real, -0.019020007896208766962, tol=PTOL)
+    assert ae(v.imag, -0.016188792559887887544, tol=PTOL)
+    v = fp.e1((0.0 - 50.0j))
+    assert ae(v, (0.0056283863241163054402 + 0.019179254308960724503j), tol=ATOL)
+    assert ae(v.real, 0.0056283863241163054402, tol=PTOL)
+    assert ae(v.imag, 0.019179254308960724503, tol=PTOL)
+    v = fp.e1((0.0 - 80.0j))
+    assert ae(v, (0.012402501155070958192 - 0.0015345601175906961199j), tol=ATOL)
+    assert ae(v.real, 0.012402501155070958192, tol=PTOL)
+    assert ae(v.imag, -0.0015345601175906961199, tol=PTOL)
+    v = fp.e1((1.1641532182693481445e-10 - 4.6566128730773925781e-10j))
+    assert ae(v, (20.880034621664969632 + 1.3258176632023711778j), tol=ATOL)
+    assert ae(v.real, 20.880034621664969632, tol=PTOL)
+    assert ae(v.imag, 1.3258176632023711778, tol=PTOL)
+    v = fp.e1((0.25 - 1.0j))
+    assert ae(v, (-0.16868306393667788761 + 0.4858011885947426971j), tol=ATOL)
+    assert ae(v.real, -0.16868306393667788761, tol=PTOL)
+    assert ae(v.imag, 0.4858011885947426971, tol=PTOL)
+    v = fp.e1((1.0 - 4.0j))
+    assert ae(v, (0.03373591813926547318 - 0.073523452241083821877j), tol=ATOL)
+    assert ae(v.real, 0.03373591813926547318, tol=PTOL)
+    assert ae(v.imag, -0.073523452241083821877, tol=PTOL)
+    v = fp.e1((2.0 - 8.0j))
+    assert ae(v, (-0.015392833434733785143 + 0.0031747121557605415914j), tol=ATOL)
+    assert ae(v.real, -0.015392833434733785143, tol=PTOL)
+    assert ae(v.imag, 0.0031747121557605415914, tol=PTOL)
+    v = fp.e1((5.0 - 20.0j))
+    assert ae(v, (-0.00024419662286542966525 + 0.00021008322966152755674j), tol=ATOL)
+    assert ae(v.real, -0.00024419662286542966525, tol=PTOL)
+    assert ae(v.imag, 0.00021008322966152755674, tol=PTOL)
+    v = fp.e1((20.0 - 80.0j))
+    assert ae(v, (2.3255552781051330088e-11 - 8.9463918891349438007e-12j), tol=ATOL)
+    assert ae(v.real, 2.3255552781051330088e-11, tol=PTOL)
+    assert ae(v.imag, -8.9463918891349438007e-12, tol=PTOL)
+    v = fp.e1((30.0 - 120.0j))
+    assert ae(v, (-2.7068919097124652332e-16 + 7.0477762411705130239e-16j), tol=ATOL)
+    assert ae(v.real, -2.7068919097124652332e-16, tol=PTOL)
+    assert ae(v.imag, 7.0477762411705130239e-16, tol=PTOL)
+    v = fp.e1((40.0 - 160.0j))
+    assert ae(v, (-1.1695597827678024687e-20 - 2.2907401455645736661e-20j), tol=ATOL)
+    assert ae(v.real, -1.1695597827678024687e-20, tol=PTOL)
+    assert ae(v.imag, -2.2907401455645736661e-20, tol=PTOL)
+    v = fp.e1((50.0 - 200.0j))
+    assert ae(v, (9.0323746914410162531e-25 + 2.3950601790033530935e-25j), tol=ATOL)
+    assert ae(v.real, 9.0323746914410162531e-25, tol=PTOL)
+    assert ae(v.imag, 2.3950601790033530935e-25, tol=PTOL)
+    v = fp.e1((80.0 - 320.0j))
+    assert ae(v, (3.4819106748728063576e-38 + 4.215653005615772724e-38j), tol=ATOL)
+    assert ae(v.real, 3.4819106748728063576e-38, tol=PTOL)
+    assert ae(v.imag, 4.215653005615772724e-38, tol=PTOL)
+    v = fp.e1((1.1641532182693481445e-10 - 1.1641532182693481445e-10j))
+    assert ae(v, (21.950067703413105017 + 0.7853981632810329878j), tol=ATOL)
+    assert ae(v.real, 21.950067703413105017, tol=PTOL)
+    assert ae(v.imag, 0.7853981632810329878, tol=PTOL)
+    v = fp.e1((0.25 - 0.25j))
+    assert ae(v, (0.71092525792923287894 + 0.56491812441304194711j), tol=ATOL)
+    assert ae(v.real, 0.71092525792923287894, tol=PTOL)
+    assert ae(v.imag, 0.56491812441304194711, tol=PTOL)
+    v = fp.e1((1.0 - 1.0j))
+    assert ae(v, (0.00028162445198141832551 + 0.17932453503935894015j), tol=ATOL)
+    assert ae(v.real, 0.00028162445198141832551, tol=PTOL)
+    assert ae(v.imag, 0.17932453503935894015, tol=PTOL)
+    v = fp.e1((2.0 - 2.0j))
+    assert ae(v, (-0.033767089606562004246 + 0.018599414169750541925j), tol=ATOL)
+    assert ae(v.real, -0.033767089606562004246, tol=PTOL)
+    assert ae(v.imag, 0.018599414169750541925, tol=PTOL)
+    v = fp.e1((5.0 - 5.0j))
+    assert ae(v, (0.0007266506660356393891 - 0.00047102780163522245054j), tol=ATOL)
+    assert ae(v.real, 0.0007266506660356393891, tol=PTOL)
+    assert ae(v.imag, -0.00047102780163522245054, tol=PTOL)
+    v = fp.e1((20.0 - 20.0j))
+    assert ae(v, (-2.3824537449367396579e-11 + 6.6969873156525615158e-11j), tol=ATOL)
+    assert ae(v.real, -2.3824537449367396579e-11, tol=PTOL)
+    assert ae(v.imag, 6.6969873156525615158e-11, tol=PTOL)
+    v = fp.e1((30.0 - 30.0j))
+    assert ae(v, (1.7316045841744061617e-15 - 1.3065678019487308689e-15j), tol=ATOL)
+    assert ae(v.real, 1.7316045841744061617e-15, tol=PTOL)
+    assert ae(v.imag, -1.3065678019487308689e-15, tol=PTOL)
+    v = fp.e1((40.0 - 40.0j))
+    assert ae(v, (-7.4001043002899232182e-20 + 4.991847855336816304e-21j), tol=ATOL)
+    assert ae(v.real, -7.4001043002899232182e-20, tol=PTOL)
+    assert ae(v.imag, 4.991847855336816304e-21, tol=PTOL)
+    v = fp.e1((50.0 - 50.0j))
+    assert ae(v, (2.3566128324644641219e-24 + 1.3188326726201614778e-24j), tol=ATOL)
+    assert ae(v.real, 2.3566128324644641219e-24, tol=PTOL)
+    assert ae(v.imag, 1.3188326726201614778e-24, tol=PTOL)
+    v = fp.e1((80.0 - 80.0j))
+    assert ae(v, (9.8279750572186526673e-38 - 1.243952841288868831e-37j), tol=ATOL)
+    assert ae(v.real, 9.8279750572186526673e-38, tol=PTOL)
+    assert ae(v.imag, -1.243952841288868831e-37, tol=PTOL)
+    v = fp.e1((4.6566128730773925781e-10 - 1.1641532182693481445e-10j))
+    assert ae(v, (20.880034622014215597 + 0.24497866301044883237j), tol=ATOL)
+    assert ae(v.real, 20.880034622014215597, tol=PTOL)
+    assert ae(v.imag, 0.24497866301044883237, tol=PTOL)
+    v = fp.e1((1.0 - 0.25j))
+    assert ae(v, (0.19731063945004229095 + 0.087366045774299963672j), tol=ATOL)
+    assert ae(v.real, 0.19731063945004229095, tol=PTOL)
+    assert ae(v.imag, 0.087366045774299963672, tol=PTOL)
+    v = fp.e1((4.0 - 1.0j))
+    assert ae(v, (0.0013106173980145506944 + 0.0034542480199350626699j), tol=ATOL)
+    assert ae(v.real, 0.0013106173980145506944, tol=PTOL)
+    assert ae(v.imag, 0.0034542480199350626699, tol=PTOL)
+    v = fp.e1((8.0 - 2.0j))
+    assert ae(v, (-0.000022278049065270225945 + 0.000029191940456521555288j), tol=ATOL)
+    assert ae(v.real, -0.000022278049065270225945, tol=PTOL)
+    assert ae(v.imag, 0.000029191940456521555288, tol=PTOL)
+    v = fp.e1((20.0 - 5.0j))
+    assert ae(v, (4.7711374515765346894e-11 - 8.2902652405126947359e-11j), tol=ATOL)
+    assert ae(v.real, 4.7711374515765346894e-11, tol=PTOL)
+    assert ae(v.imag, -8.2902652405126947359e-11, tol=PTOL)
+    v = fp.e1((80.0 - 20.0j))
+    assert ae(v, (3.8353473865788235787e-38 + 2.129247592349605139e-37j), tol=ATOL)
+    assert ae(v.real, 3.8353473865788235787e-38, tol=PTOL)
+    assert ae(v.imag, 2.129247592349605139e-37, tol=PTOL)
+    v = fp.e1((120.0 - 30.0j))
+    assert ae(v, (2.3836002337480334716e-55 - 5.6704043587126198306e-55j), tol=ATOL)
+    assert ae(v.real, 2.3836002337480334716e-55, tol=PTOL)
+    assert ae(v.imag, -5.6704043587126198306e-55, tol=PTOL)
+    v = fp.e1((160.0 - 40.0j))
+    assert ae(v, (-1.6238022898654510661e-72 + 1.104172355572287367e-72j), tol=ATOL)
+    assert ae(v.real, -1.6238022898654510661e-72, tol=PTOL)
+    assert ae(v.imag, 1.104172355572287367e-72, tol=PTOL)
+    v = fp.e1((200.0 - 50.0j))
+    assert ae(v, (6.6800061461666228487e-90 - 1.4473816083541016115e-91j), tol=ATOL)
+    assert ae(v.real, 6.6800061461666228487e-90, tol=PTOL)
+    assert ae(v.imag, -1.4473816083541016115e-91, tol=PTOL)
+    v = fp.e1((320.0 - 80.0j))
+    assert ae(v, (4.2737871527778786157e-143 - 3.1789935525785660314e-142j), tol=ATOL)
+    assert ae(v.real, 4.2737871527778786157e-143, tol=PTOL)
+    assert ae(v.imag, -3.1789935525785660314e-142, tol=PTOL)
+    v = fp.ei(1.1641532182693481445e-10)
+    assert ae(v, -22.296641293460247028, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(0.25)
+    assert ae(v, -0.54254326466191372953, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(1.0)
+    assert ae(v, 1.8951178163559367555, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(2.0)
+    assert ae(v, 4.9542343560018901634, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(5.0)
+    assert ae(v, 40.185275355803177455, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(20.0)
+    assert ae(v, 25615652.66405658882, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(30.0)
+    assert ae(v, 368973209407.27419706, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(40.0)
+    assert ae(v, 6039718263611241.5784, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(50.0)
+    assert ae(v, 1.0585636897131690963e+20, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(80.0)
+    assert ae(v, 7.0146000049047999696e+32, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei((1.1641532182693481445e-10 + 0.0j))
+    assert ae(v, (-22.296641293460247028 + 0.0j), tol=ATOL)
+    assert ae(v.real, -22.296641293460247028, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((0.25 + 0.0j))
+    assert ae(v, (-0.54254326466191372953 + 0.0j), tol=ATOL)
+    assert ae(v.real, -0.54254326466191372953, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((1.0 + 0.0j))
+    assert ae(v, (1.8951178163559367555 + 0.0j), tol=ATOL)
+    assert ae(v.real, 1.8951178163559367555, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((2.0 + 0.0j))
+    assert ae(v, (4.9542343560018901634 + 0.0j), tol=ATOL)
+    assert ae(v.real, 4.9542343560018901634, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((5.0 + 0.0j))
+    assert ae(v, (40.185275355803177455 + 0.0j), tol=ATOL)
+    assert ae(v.real, 40.185275355803177455, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((20.0 + 0.0j))
+    assert ae(v, (25615652.66405658882 + 0.0j), tol=ATOL)
+    assert ae(v.real, 25615652.66405658882, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((30.0 + 0.0j))
+    assert ae(v, (368973209407.27419706 + 0.0j), tol=ATOL)
+    assert ae(v.real, 368973209407.27419706, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((40.0 + 0.0j))
+    assert ae(v, (6039718263611241.5784 + 0.0j), tol=ATOL)
+    assert ae(v.real, 6039718263611241.5784, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((50.0 + 0.0j))
+    assert ae(v, (1.0585636897131690963e+20 + 0.0j), tol=ATOL)
+    assert ae(v.real, 1.0585636897131690963e+20, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((80.0 + 0.0j))
+    assert ae(v, (7.0146000049047999696e+32 + 0.0j), tol=ATOL)
+    assert ae(v.real, 7.0146000049047999696e+32, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((4.6566128730773925781e-10 + 1.1641532182693481445e-10j))
+    assert ae(v, (-20.880034621082893023 + 0.24497866324327947603j), tol=ATOL)
+    assert ae(v.real, -20.880034621082893023, tol=PTOL)
+    assert ae(v.imag, 0.24497866324327947603, tol=PTOL)
+    v = fp.ei((1.0 + 0.25j))
+    assert ae(v, (1.8942716983721074932 + 0.67268237088273915854j), tol=ATOL)
+    assert ae(v.real, 1.8942716983721074932, tol=PTOL)
+    assert ae(v.imag, 0.67268237088273915854, tol=PTOL)
+    v = fp.ei((4.0 + 1.0j))
+    assert ae(v, (14.806699492675420438 + 12.280015176673582616j), tol=ATOL)
+    assert ae(v.real, 14.806699492675420438, tol=PTOL)
+    assert ae(v.imag, 12.280015176673582616, tol=PTOL)
+    v = fp.ei((8.0 + 2.0j))
+    assert ae(v, (-54.633252667426386294 + 416.34477429173650012j), tol=ATOL)
+    assert ae(v.real, -54.633252667426386294, tol=PTOL)
+    assert ae(v.imag, 416.34477429173650012, tol=PTOL)
+    v = fp.ei((20.0 + 5.0j))
+    assert ae(v, (711836.97165402624643 - 24745247.798103247366j), tol=ATOL)
+    assert ae(v.real, 711836.97165402624643, tol=PTOL)
+    assert ae(v.imag, -24745247.798103247366, tol=PTOL)
+    v = fp.ei((80.0 + 20.0j))
+    assert ae(v, (4.2139911108612653091e+32 + 5.3367124741918251637e+32j), tol=ATOL)
+    assert ae(v.real, 4.2139911108612653091e+32, tol=PTOL)
+    assert ae(v.imag, 5.3367124741918251637e+32, tol=PTOL)
+    v = fp.ei((120.0 + 30.0j))
+    assert ae(v, (-9.7760616203707508892e+48 - 1.058257682317195792e+50j), tol=ATOL)
+    assert ae(v.real, -9.7760616203707508892e+48, tol=PTOL)
+    assert ae(v.imag, -1.058257682317195792e+50, tol=PTOL)
+    v = fp.ei((160.0 + 40.0j))
+    assert ae(v, (-8.7065541466623638861e+66 + 1.6577106725141739889e+67j), tol=ATOL)
+    assert ae(v.real, -8.7065541466623638861e+66, tol=PTOL)
+    assert ae(v.imag, 1.6577106725141739889e+67, tol=PTOL)
+    v = fp.ei((200.0 + 50.0j))
+    assert ae(v, (3.070744996327018106e+84 - 1.7243244846769415903e+84j), tol=ATOL)
+    assert ae(v.real, 3.070744996327018106e+84, tol=PTOL)
+    assert ae(v.imag, -1.7243244846769415903e+84, tol=PTOL)
+    v = fp.ei((320.0 + 80.0j))
+    assert ae(v, (-9.9960598637998647276e+135 - 2.6855081527595608863e+136j), tol=ATOL)
+    assert ae(v.real, -9.9960598637998647276e+135, tol=PTOL)
+    assert ae(v.imag, -2.6855081527595608863e+136, tol=PTOL)
+    v = fp.ei((1.1641532182693481445e-10 + 1.1641532182693481445e-10j))
+    assert ae(v, (-21.950067703180274374 + 0.78539816351386363145j), tol=ATOL)
+    assert ae(v.real, -21.950067703180274374, tol=PTOL)
+    assert ae(v.imag, 0.78539816351386363145, tol=PTOL)
+    v = fp.ei((0.25 + 0.25j))
+    assert ae(v, (-0.21441047326710323254 + 1.0683772981589995996j), tol=ATOL)
+    assert ae(v.real, -0.21441047326710323254, tol=PTOL)
+    assert ae(v.imag, 1.0683772981589995996, tol=PTOL)
+    v = fp.ei((1.0 + 1.0j))
+    assert ae(v, (1.7646259855638540684 + 2.3877698515105224193j), tol=ATOL)
+    assert ae(v.real, 1.7646259855638540684, tol=PTOL)
+    assert ae(v.imag, 2.3877698515105224193, tol=PTOL)
+    v = fp.ei((2.0 + 2.0j))
+    assert ae(v, (1.8920781621855474089 + 5.3169624378326579621j), tol=ATOL)
+    assert ae(v.real, 1.8920781621855474089, tol=PTOL)
+    assert ae(v.imag, 5.3169624378326579621, tol=PTOL)
+    v = fp.ei((5.0 + 5.0j))
+    assert ae(v, (-13.470936071475245856 - 15.322492395731230968j), tol=ATOL)
+    assert ae(v.real, -13.470936071475245856, tol=PTOL)
+    assert ae(v.imag, -15.322492395731230968, tol=PTOL)
+    v = fp.ei((20.0 + 20.0j))
+    assert ae(v, (16589317.398788971896 + 5831705.4712368307104j), tol=ATOL)
+    assert ae(v.real, 16589317.398788971896, tol=PTOL)
+    assert ae(v.imag, 5831705.4712368307104, tol=PTOL)
+    v = fp.ei((30.0 + 30.0j))
+    assert ae(v, (-154596484273.69322527 - 204179357834.2723043j), tol=ATOL)
+    assert ae(v.real, -154596484273.69322527, tol=PTOL)
+    assert ae(v.imag, -204179357834.2723043, tol=PTOL)
+    v = fp.ei((40.0 + 40.0j))
+    assert ae(v, (287512180321448.45408 + 4203502407932318.1156j), tol=ATOL)
+    assert ae(v.real, 287512180321448.45408, tol=PTOL)
+    assert ae(v.imag, 4203502407932318.1156, tol=PTOL)
+    v = fp.ei((50.0 + 50.0j))
+    assert ae(v, (36128528616649268826.0 - 64648801861338741960.0j), tol=ATOL)
+    assert ae(v.real, 36128528616649268826.0, tol=PTOL)
+    assert ae(v.imag, -64648801861338741960.0, tol=PTOL)
+    v = fp.ei((80.0 + 80.0j))
+    assert ae(v, (-3.8674816337930010217e+32 - 3.0540709639658071041e+32j), tol=ATOL)
+    assert ae(v.real, -3.8674816337930010217e+32, tol=PTOL)
+    assert ae(v.imag, -3.0540709639658071041e+32, tol=PTOL)
+    v = fp.ei((1.1641532182693481445e-10 + 4.6566128730773925781e-10j))
+    assert ae(v, (-20.880034621432138988 + 1.3258176641336937524j), tol=ATOL)
+    assert ae(v.real, -20.880034621432138988, tol=PTOL)
+    assert ae(v.imag, 1.3258176641336937524, tol=PTOL)
+    v = fp.ei((0.25 + 1.0j))
+    assert ae(v, (0.59066621214766308594 + 2.3968481059377428687j), tol=ATOL)
+    assert ae(v.real, 0.59066621214766308594, tol=PTOL)
+    assert ae(v.imag, 2.3968481059377428687, tol=PTOL)
+    v = fp.ei((1.0 + 4.0j))
+    assert ae(v, (-0.49739047283060471093 + 3.5570287076301818702j), tol=ATOL)
+    assert ae(v.real, -0.49739047283060471093, tol=PTOL)
+    assert ae(v.imag, 3.5570287076301818702, tol=PTOL)
+    v = fp.ei((2.0 + 8.0j))
+    assert ae(v, (0.8705211147733730969 + 3.3825859385758486351j), tol=ATOL)
+    assert ae(v.real, 0.8705211147733730969, tol=PTOL)
+    assert ae(v.imag, 3.3825859385758486351, tol=PTOL)
+    v = fp.ei((5.0 + 20.0j))
+    assert ae(v, (7.0789514293925893007 + 1.5313749363937141849j), tol=ATOL)
+    assert ae(v.real, 7.0789514293925893007, tol=PTOL)
+    assert ae(v.imag, 1.5313749363937141849, tol=PTOL)
+    v = fp.ei((20.0 + 80.0j))
+    assert ae(v, (-5855431.4907298084434 - 720917.79156143806727j), tol=ATOL)
+    assert ae(v.real, -5855431.4907298084434, tol=PTOL)
+    assert ae(v.imag, -720917.79156143806727, tol=PTOL)
+    v = fp.ei((30.0 + 120.0j))
+    assert ae(v, (65402491644.703470747 - 56697658396.51586764j), tol=ATOL)
+    assert ae(v.real, 65402491644.703470747, tol=PTOL)
+    assert ae(v.imag, -56697658396.51586764, tol=PTOL)
+    v = fp.ei((40.0 + 160.0j))
+    assert ae(v, (-25504929379604.776769 + 1429035198630576.3879j), tol=ATOL)
+    assert ae(v.real, -25504929379604.776769, tol=PTOL)
+    assert ae(v.imag, 1429035198630576.3879, tol=PTOL)
+    v = fp.ei((50.0 + 200.0j))
+    assert ae(v, (-18437746526988116954.0 - 17146362239046152342.0j), tol=ATOL)
+    assert ae(v.real, -18437746526988116954.0, tol=PTOL)
+    assert ae(v.imag, -17146362239046152342.0, tol=PTOL)
+    v = fp.ei((80.0 + 320.0j))
+    assert ae(v, (-3.3464697299634526706e+31 - 1.6473152633843023919e+32j), tol=ATOL)
+    assert ae(v.real, -3.3464697299634526706e+31, tol=PTOL)
+    assert ae(v.imag, -1.6473152633843023919e+32, tol=PTOL)
+    v = fp.ei((0.0 + 1.1641532182693481445e-10j))
+    assert ae(v, (-22.29664129357666235 + 1.5707963269113119411j), tol=ATOL)
+    assert ae(v.real, -22.29664129357666235, tol=PTOL)
+    assert ae(v.imag, 1.5707963269113119411, tol=PTOL)
+    v = fp.ei((0.0 + 0.25j))
+    assert ae(v, (-0.82466306258094565309 + 1.8199298971146537833j), tol=ATOL)
+    assert ae(v.real, -0.82466306258094565309, tol=PTOL)
+    assert ae(v.imag, 1.8199298971146537833, tol=PTOL)
+    v = fp.ei((0.0 + 1.0j))
+    assert ae(v, (0.33740392290096813466 + 2.5168793971620796342j), tol=ATOL)
+    assert ae(v.real, 0.33740392290096813466, tol=PTOL)
+    assert ae(v.imag, 2.5168793971620796342, tol=PTOL)
+    v = fp.ei((0.0 + 2.0j))
+    assert ae(v, (0.4229808287748649957 + 3.1762093035975914678j), tol=ATOL)
+    assert ae(v.real, 0.4229808287748649957, tol=PTOL)
+    assert ae(v.imag, 3.1762093035975914678, tol=PTOL)
+    v = fp.ei((0.0 + 5.0j))
+    assert ae(v, (-0.19002974965664387862 + 3.1207275717395707565j), tol=ATOL)
+    assert ae(v.real, -0.19002974965664387862, tol=PTOL)
+    assert ae(v.imag, 3.1207275717395707565, tol=PTOL)
+    v = fp.ei((0.0 + 20.0j))
+    assert ae(v, (0.04441982084535331654 + 3.1190380278383364594j), tol=ATOL)
+    assert ae(v.real, 0.04441982084535331654, tol=PTOL)
+    assert ae(v.imag, 3.1190380278383364594, tol=PTOL)
+    v = fp.ei((0.0 + 30.0j))
+    assert ae(v, (-0.033032417282071143779 + 3.1375528668252477302j), tol=ATOL)
+    assert ae(v.real, -0.033032417282071143779, tol=PTOL)
+    assert ae(v.imag, 3.1375528668252477302, tol=PTOL)
+    v = fp.ei((0.0 + 40.0j))
+    assert ae(v, (0.019020007896208766962 + 3.157781446149681126j), tol=ATOL)
+    assert ae(v.real, 0.019020007896208766962, tol=PTOL)
+    assert ae(v.imag, 3.157781446149681126, tol=PTOL)
+    v = fp.ei((0.0 + 50.0j))
+    assert ae(v, (-0.0056283863241163054402 + 3.122413399280832514j), tol=ATOL)
+    assert ae(v.real, -0.0056283863241163054402, tol=PTOL)
+    assert ae(v.imag, 3.122413399280832514, tol=PTOL)
+    v = fp.ei((0.0 + 80.0j))
+    assert ae(v, (-0.012402501155070958192 + 3.1431272137073839346j), tol=ATOL)
+    assert ae(v.real, -0.012402501155070958192, tol=PTOL)
+    assert ae(v.imag, 3.1431272137073839346, tol=PTOL)
+    v = fp.ei((-1.1641532182693481445e-10 + 4.6566128730773925781e-10j))
+    assert ae(v, (-20.880034621664969632 + 1.8157749903874220607j), tol=ATOL)
+    assert ae(v.real, -20.880034621664969632, tol=PTOL)
+    assert ae(v.imag, 1.8157749903874220607, tol=PTOL)
+    v = fp.ei((-0.25 + 1.0j))
+    assert ae(v, (0.16868306393667788761 + 2.6557914649950505414j), tol=ATOL)
+    assert ae(v.real, 0.16868306393667788761, tol=PTOL)
+    assert ae(v.imag, 2.6557914649950505414, tol=PTOL)
+    v = fp.ei((-1.0 + 4.0j))
+    assert ae(v, (-0.03373591813926547318 + 3.2151161058308770603j), tol=ATOL)
+    assert ae(v.real, -0.03373591813926547318, tol=PTOL)
+    assert ae(v.imag, 3.2151161058308770603, tol=PTOL)
+    v = fp.ei((-2.0 + 8.0j))
+    assert ae(v, (0.015392833434733785143 + 3.1384179414340326969j), tol=ATOL)
+    assert ae(v.real, 0.015392833434733785143, tol=PTOL)
+    assert ae(v.imag, 3.1384179414340326969, tol=PTOL)
+    v = fp.ei((-5.0 + 20.0j))
+    assert ae(v, (0.00024419662286542966525 + 3.1413825703601317109j), tol=ATOL)
+    assert ae(v.real, 0.00024419662286542966525, tol=PTOL)
+    assert ae(v.imag, 3.1413825703601317109, tol=PTOL)
+    v = fp.ei((-20.0 + 80.0j))
+    assert ae(v, (-2.3255552781051330088e-11 + 3.1415926535987396304j), tol=ATOL)
+    assert ae(v.real, -2.3255552781051330088e-11, tol=PTOL)
+    assert ae(v.imag, 3.1415926535987396304, tol=PTOL)
+    v = fp.ei((-30.0 + 120.0j))
+    assert ae(v, (2.7068919097124652332e-16 + 3.1415926535897925337j), tol=ATOL)
+    assert ae(v.real, 2.7068919097124652332e-16, tol=PTOL)
+    assert ae(v.imag, 3.1415926535897925337, tol=PTOL)
+    v = fp.ei((-40.0 + 160.0j))
+    assert ae(v, (1.1695597827678024687e-20 + 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, 1.1695597827678024687e-20, tol=PTOL)
+    assert ae(v.imag, 3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-50.0 + 200.0j))
+    assert ae(v, (-9.0323746914410162531e-25 + 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -9.0323746914410162531e-25, tol=PTOL)
+    assert ae(v.imag, 3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-80.0 + 320.0j))
+    assert ae(v, (-3.4819106748728063576e-38 + 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -3.4819106748728063576e-38, tol=PTOL)
+    assert ae(v.imag, 3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-4.6566128730773925781e-10 + 1.1641532182693481445e-10j))
+    assert ae(v, (-20.880034622014215597 + 2.8966139905793444061j), tol=ATOL)
+    assert ae(v.real, -20.880034622014215597, tol=PTOL)
+    assert ae(v.imag, 2.8966139905793444061, tol=PTOL)
+    v = fp.ei((-1.0 + 0.25j))
+    assert ae(v, (-0.19731063945004229095 + 3.0542266078154932748j), tol=ATOL)
+    assert ae(v.real, -0.19731063945004229095, tol=PTOL)
+    assert ae(v.imag, 3.0542266078154932748, tol=PTOL)
+    v = fp.ei((-4.0 + 1.0j))
+    assert ae(v, (-0.0013106173980145506944 + 3.1381384055698581758j), tol=ATOL)
+    assert ae(v.real, -0.0013106173980145506944, tol=PTOL)
+    assert ae(v.imag, 3.1381384055698581758, tol=PTOL)
+    v = fp.ei((-8.0 + 2.0j))
+    assert ae(v, (0.000022278049065270225945 + 3.1415634616493367169j), tol=ATOL)
+    assert ae(v.real, 0.000022278049065270225945, tol=PTOL)
+    assert ae(v.imag, 3.1415634616493367169, tol=PTOL)
+    v = fp.ei((-20.0 + 5.0j))
+    assert ae(v, (-4.7711374515765346894e-11 + 3.1415926536726958909j), tol=ATOL)
+    assert ae(v.real, -4.7711374515765346894e-11, tol=PTOL)
+    assert ae(v.imag, 3.1415926536726958909, tol=PTOL)
+    v = fp.ei((-80.0 + 20.0j))
+    assert ae(v, (-3.8353473865788235787e-38 + 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -3.8353473865788235787e-38, tol=PTOL)
+    assert ae(v.imag, 3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-120.0 + 30.0j))
+    assert ae(v, (-2.3836002337480334716e-55 + 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -2.3836002337480334716e-55, tol=PTOL)
+    assert ae(v.imag, 3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-160.0 + 40.0j))
+    assert ae(v, (1.6238022898654510661e-72 + 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, 1.6238022898654510661e-72, tol=PTOL)
+    assert ae(v.imag, 3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-200.0 + 50.0j))
+    assert ae(v, (-6.6800061461666228487e-90 + 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -6.6800061461666228487e-90, tol=PTOL)
+    assert ae(v.imag, 3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-320.0 + 80.0j))
+    assert ae(v, (-4.2737871527778786157e-143 + 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -4.2737871527778786157e-143, tol=PTOL)
+    assert ae(v.imag, 3.1415926535897932385, tol=PTOL)
+    v = fp.ei(-1.1641532182693481445e-10)
+    assert ae(v, -22.296641293693077672, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(-0.25)
+    assert ae(v, -1.0442826344437381945, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(-1.0)
+    assert ae(v, -0.21938393439552027368, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(-2.0)
+    assert ae(v, -0.048900510708061119567, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(-5.0)
+    assert ae(v, -0.0011482955912753257973, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(-20.0)
+    assert ae(v, -9.8355252906498816904e-11, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(-30.0)
+    assert ae(v, -3.0215520106888125448e-15, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(-40.0)
+    assert ae(v, -1.0367732614516569722e-19, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(-50.0)
+    assert ae(v, -3.7832640295504590187e-24, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei(-80.0)
+    assert ae(v, -2.2285432586884729112e-37, tol=ATOL)
+    assert type(v) is float
+    v = fp.ei((-1.1641532182693481445e-10 + 0.0j))
+    assert ae(v, (-22.296641293693077672 + 0.0j), tol=ATOL)
+    assert ae(v.real, -22.296641293693077672, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((-0.25 + 0.0j))
+    assert ae(v, (-1.0442826344437381945 + 0.0j), tol=ATOL)
+    assert ae(v.real, -1.0442826344437381945, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((-1.0 + 0.0j))
+    assert ae(v, (-0.21938393439552027368 + 0.0j), tol=ATOL)
+    assert ae(v.real, -0.21938393439552027368, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((-2.0 + 0.0j))
+    assert ae(v, (-0.048900510708061119567 + 0.0j), tol=ATOL)
+    assert ae(v.real, -0.048900510708061119567, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((-5.0 + 0.0j))
+    assert ae(v, (-0.0011482955912753257973 + 0.0j), tol=ATOL)
+    assert ae(v.real, -0.0011482955912753257973, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((-20.0 + 0.0j))
+    assert ae(v, (-9.8355252906498816904e-11 + 0.0j), tol=ATOL)
+    assert ae(v.real, -9.8355252906498816904e-11, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((-30.0 + 0.0j))
+    assert ae(v, (-3.0215520106888125448e-15 + 0.0j), tol=ATOL)
+    assert ae(v.real, -3.0215520106888125448e-15, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((-40.0 + 0.0j))
+    assert ae(v, (-1.0367732614516569722e-19 + 0.0j), tol=ATOL)
+    assert ae(v.real, -1.0367732614516569722e-19, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((-50.0 + 0.0j))
+    assert ae(v, (-3.7832640295504590187e-24 + 0.0j), tol=ATOL)
+    assert ae(v.real, -3.7832640295504590187e-24, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((-80.0 + 0.0j))
+    assert ae(v, (-2.2285432586884729112e-37 + 0.0j), tol=ATOL)
+    assert ae(v.real, -2.2285432586884729112e-37, tol=PTOL)
+    assert v.imag == 0
+    v = fp.ei((-4.6566128730773925781e-10 - 1.1641532182693481445e-10j))
+    assert ae(v, (-20.880034622014215597 - 2.8966139905793444061j), tol=ATOL)
+    assert ae(v.real, -20.880034622014215597, tol=PTOL)
+    assert ae(v.imag, -2.8966139905793444061, tol=PTOL)
+    v = fp.ei((-1.0 - 0.25j))
+    assert ae(v, (-0.19731063945004229095 - 3.0542266078154932748j), tol=ATOL)
+    assert ae(v.real, -0.19731063945004229095, tol=PTOL)
+    assert ae(v.imag, -3.0542266078154932748, tol=PTOL)
+    v = fp.ei((-4.0 - 1.0j))
+    assert ae(v, (-0.0013106173980145506944 - 3.1381384055698581758j), tol=ATOL)
+    assert ae(v.real, -0.0013106173980145506944, tol=PTOL)
+    assert ae(v.imag, -3.1381384055698581758, tol=PTOL)
+    v = fp.ei((-8.0 - 2.0j))
+    assert ae(v, (0.000022278049065270225945 - 3.1415634616493367169j), tol=ATOL)
+    assert ae(v.real, 0.000022278049065270225945, tol=PTOL)
+    assert ae(v.imag, -3.1415634616493367169, tol=PTOL)
+    v = fp.ei((-20.0 - 5.0j))
+    assert ae(v, (-4.7711374515765346894e-11 - 3.1415926536726958909j), tol=ATOL)
+    assert ae(v.real, -4.7711374515765346894e-11, tol=PTOL)
+    assert ae(v.imag, -3.1415926536726958909, tol=PTOL)
+    v = fp.ei((-80.0 - 20.0j))
+    assert ae(v, (-3.8353473865788235787e-38 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -3.8353473865788235787e-38, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-120.0 - 30.0j))
+    assert ae(v, (-2.3836002337480334716e-55 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -2.3836002337480334716e-55, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-160.0 - 40.0j))
+    assert ae(v, (1.6238022898654510661e-72 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, 1.6238022898654510661e-72, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-200.0 - 50.0j))
+    assert ae(v, (-6.6800061461666228487e-90 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -6.6800061461666228487e-90, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-320.0 - 80.0j))
+    assert ae(v, (-4.2737871527778786157e-143 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -4.2737871527778786157e-143, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-1.1641532182693481445e-10 - 1.1641532182693481445e-10j))
+    assert ae(v, (-21.950067703413105017 - 2.3561944903087602507j), tol=ATOL)
+    assert ae(v.real, -21.950067703413105017, tol=PTOL)
+    assert ae(v.imag, -2.3561944903087602507, tol=PTOL)
+    v = fp.ei((-0.25 - 0.25j))
+    assert ae(v, (-0.71092525792923287894 - 2.5766745291767512913j), tol=ATOL)
+    assert ae(v.real, -0.71092525792923287894, tol=PTOL)
+    assert ae(v.imag, -2.5766745291767512913, tol=PTOL)
+    v = fp.ei((-1.0 - 1.0j))
+    assert ae(v, (-0.00028162445198141832551 - 2.9622681185504342983j), tol=ATOL)
+    assert ae(v.real, -0.00028162445198141832551, tol=PTOL)
+    assert ae(v.imag, -2.9622681185504342983, tol=PTOL)
+    v = fp.ei((-2.0 - 2.0j))
+    assert ae(v, (0.033767089606562004246 - 3.1229932394200426965j), tol=ATOL)
+    assert ae(v.real, 0.033767089606562004246, tol=PTOL)
+    assert ae(v.imag, -3.1229932394200426965, tol=PTOL)
+    v = fp.ei((-5.0 - 5.0j))
+    assert ae(v, (-0.0007266506660356393891 - 3.1420636813914284609j), tol=ATOL)
+    assert ae(v.real, -0.0007266506660356393891, tol=PTOL)
+    assert ae(v.imag, -3.1420636813914284609, tol=PTOL)
+    v = fp.ei((-20.0 - 20.0j))
+    assert ae(v, (2.3824537449367396579e-11 - 3.1415926535228233653j), tol=ATOL)
+    assert ae(v.real, 2.3824537449367396579e-11, tol=PTOL)
+    assert ae(v.imag, -3.1415926535228233653, tol=PTOL)
+    v = fp.ei((-30.0 - 30.0j))
+    assert ae(v, (-1.7316045841744061617e-15 - 3.141592653589794545j), tol=ATOL)
+    assert ae(v.real, -1.7316045841744061617e-15, tol=PTOL)
+    assert ae(v.imag, -3.141592653589794545, tol=PTOL)
+    v = fp.ei((-40.0 - 40.0j))
+    assert ae(v, (7.4001043002899232182e-20 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, 7.4001043002899232182e-20, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-50.0 - 50.0j))
+    assert ae(v, (-2.3566128324644641219e-24 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -2.3566128324644641219e-24, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-80.0 - 80.0j))
+    assert ae(v, (-9.8279750572186526673e-38 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -9.8279750572186526673e-38, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-1.1641532182693481445e-10 - 4.6566128730773925781e-10j))
+    assert ae(v, (-20.880034621664969632 - 1.8157749903874220607j), tol=ATOL)
+    assert ae(v.real, -20.880034621664969632, tol=PTOL)
+    assert ae(v.imag, -1.8157749903874220607, tol=PTOL)
+    v = fp.ei((-0.25 - 1.0j))
+    assert ae(v, (0.16868306393667788761 - 2.6557914649950505414j), tol=ATOL)
+    assert ae(v.real, 0.16868306393667788761, tol=PTOL)
+    assert ae(v.imag, -2.6557914649950505414, tol=PTOL)
+    v = fp.ei((-1.0 - 4.0j))
+    assert ae(v, (-0.03373591813926547318 - 3.2151161058308770603j), tol=ATOL)
+    assert ae(v.real, -0.03373591813926547318, tol=PTOL)
+    assert ae(v.imag, -3.2151161058308770603, tol=PTOL)
+    v = fp.ei((-2.0 - 8.0j))
+    assert ae(v, (0.015392833434733785143 - 3.1384179414340326969j), tol=ATOL)
+    assert ae(v.real, 0.015392833434733785143, tol=PTOL)
+    assert ae(v.imag, -3.1384179414340326969, tol=PTOL)
+    v = fp.ei((-5.0 - 20.0j))
+    assert ae(v, (0.00024419662286542966525 - 3.1413825703601317109j), tol=ATOL)
+    assert ae(v.real, 0.00024419662286542966525, tol=PTOL)
+    assert ae(v.imag, -3.1413825703601317109, tol=PTOL)
+    v = fp.ei((-20.0 - 80.0j))
+    assert ae(v, (-2.3255552781051330088e-11 - 3.1415926535987396304j), tol=ATOL)
+    assert ae(v.real, -2.3255552781051330088e-11, tol=PTOL)
+    assert ae(v.imag, -3.1415926535987396304, tol=PTOL)
+    v = fp.ei((-30.0 - 120.0j))
+    assert ae(v, (2.7068919097124652332e-16 - 3.1415926535897925337j), tol=ATOL)
+    assert ae(v.real, 2.7068919097124652332e-16, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897925337, tol=PTOL)
+    v = fp.ei((-40.0 - 160.0j))
+    assert ae(v, (1.1695597827678024687e-20 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, 1.1695597827678024687e-20, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-50.0 - 200.0j))
+    assert ae(v, (-9.0323746914410162531e-25 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -9.0323746914410162531e-25, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.ei((-80.0 - 320.0j))
+    assert ae(v, (-3.4819106748728063576e-38 - 3.1415926535897932385j), tol=ATOL)
+    assert ae(v.real, -3.4819106748728063576e-38, tol=PTOL)
+    assert ae(v.imag, -3.1415926535897932385, tol=PTOL)
+    v = fp.ei((0.0 - 1.1641532182693481445e-10j))
+    assert ae(v, (-22.29664129357666235 - 1.5707963269113119411j), tol=ATOL)
+    assert ae(v.real, -22.29664129357666235, tol=PTOL)
+    assert ae(v.imag, -1.5707963269113119411, tol=PTOL)
+    v = fp.ei((0.0 - 0.25j))
+    assert ae(v, (-0.82466306258094565309 - 1.8199298971146537833j), tol=ATOL)
+    assert ae(v.real, -0.82466306258094565309, tol=PTOL)
+    assert ae(v.imag, -1.8199298971146537833, tol=PTOL)
+    v = fp.ei((0.0 - 1.0j))
+    assert ae(v, (0.33740392290096813466 - 2.5168793971620796342j), tol=ATOL)
+    assert ae(v.real, 0.33740392290096813466, tol=PTOL)
+    assert ae(v.imag, -2.5168793971620796342, tol=PTOL)
+    v = fp.ei((0.0 - 2.0j))
+    assert ae(v, (0.4229808287748649957 - 3.1762093035975914678j), tol=ATOL)
+    assert ae(v.real, 0.4229808287748649957, tol=PTOL)
+    assert ae(v.imag, -3.1762093035975914678, tol=PTOL)
+    v = fp.ei((0.0 - 5.0j))
+    assert ae(v, (-0.19002974965664387862 - 3.1207275717395707565j), tol=ATOL)
+    assert ae(v.real, -0.19002974965664387862, tol=PTOL)
+    assert ae(v.imag, -3.1207275717395707565, tol=PTOL)
+    v = fp.ei((0.0 - 20.0j))
+    assert ae(v, (0.04441982084535331654 - 3.1190380278383364594j), tol=ATOL)
+    assert ae(v.real, 0.04441982084535331654, tol=PTOL)
+    assert ae(v.imag, -3.1190380278383364594, tol=PTOL)
+    v = fp.ei((0.0 - 30.0j))
+    assert ae(v, (-0.033032417282071143779 - 3.1375528668252477302j), tol=ATOL)
+    assert ae(v.real, -0.033032417282071143779, tol=PTOL)
+    assert ae(v.imag, -3.1375528668252477302, tol=PTOL)
+    v = fp.ei((0.0 - 40.0j))
+    assert ae(v, (0.019020007896208766962 - 3.157781446149681126j), tol=ATOL)
+    assert ae(v.real, 0.019020007896208766962, tol=PTOL)
+    assert ae(v.imag, -3.157781446149681126, tol=PTOL)
+    v = fp.ei((0.0 - 50.0j))
+    assert ae(v, (-0.0056283863241163054402 - 3.122413399280832514j), tol=ATOL)
+    assert ae(v.real, -0.0056283863241163054402, tol=PTOL)
+    assert ae(v.imag, -3.122413399280832514, tol=PTOL)
+    v = fp.ei((0.0 - 80.0j))
+    assert ae(v, (-0.012402501155070958192 - 3.1431272137073839346j), tol=ATOL)
+    assert ae(v.real, -0.012402501155070958192, tol=PTOL)
+    assert ae(v.imag, -3.1431272137073839346, tol=PTOL)
+    v = fp.ei((1.1641532182693481445e-10 - 4.6566128730773925781e-10j))
+    assert ae(v, (-20.880034621432138988 - 1.3258176641336937524j), tol=ATOL)
+    assert ae(v.real, -20.880034621432138988, tol=PTOL)
+    assert ae(v.imag, -1.3258176641336937524, tol=PTOL)
+    v = fp.ei((0.25 - 1.0j))
+    assert ae(v, (0.59066621214766308594 - 2.3968481059377428687j), tol=ATOL)
+    assert ae(v.real, 0.59066621214766308594, tol=PTOL)
+    assert ae(v.imag, -2.3968481059377428687, tol=PTOL)
+    v = fp.ei((1.0 - 4.0j))
+    assert ae(v, (-0.49739047283060471093 - 3.5570287076301818702j), tol=ATOL)
+    assert ae(v.real, -0.49739047283060471093, tol=PTOL)
+    assert ae(v.imag, -3.5570287076301818702, tol=PTOL)
+    v = fp.ei((2.0 - 8.0j))
+    assert ae(v, (0.8705211147733730969 - 3.3825859385758486351j), tol=ATOL)
+    assert ae(v.real, 0.8705211147733730969, tol=PTOL)
+    assert ae(v.imag, -3.3825859385758486351, tol=PTOL)
+    v = fp.ei((5.0 - 20.0j))
+    assert ae(v, (7.0789514293925893007 - 1.5313749363937141849j), tol=ATOL)
+    assert ae(v.real, 7.0789514293925893007, tol=PTOL)
+    assert ae(v.imag, -1.5313749363937141849, tol=PTOL)
+    v = fp.ei((20.0 - 80.0j))
+    assert ae(v, (-5855431.4907298084434 + 720917.79156143806727j), tol=ATOL)
+    assert ae(v.real, -5855431.4907298084434, tol=PTOL)
+    assert ae(v.imag, 720917.79156143806727, tol=PTOL)
+    v = fp.ei((30.0 - 120.0j))
+    assert ae(v, (65402491644.703470747 + 56697658396.51586764j), tol=ATOL)
+    assert ae(v.real, 65402491644.703470747, tol=PTOL)
+    assert ae(v.imag, 56697658396.51586764, tol=PTOL)
+    v = fp.ei((40.0 - 160.0j))
+    assert ae(v, (-25504929379604.776769 - 1429035198630576.3879j), tol=ATOL)
+    assert ae(v.real, -25504929379604.776769, tol=PTOL)
+    assert ae(v.imag, -1429035198630576.3879, tol=PTOL)
+    v = fp.ei((50.0 - 200.0j))
+    assert ae(v, (-18437746526988116954.0 + 17146362239046152342.0j), tol=ATOL)
+    assert ae(v.real, -18437746526988116954.0, tol=PTOL)
+    assert ae(v.imag, 17146362239046152342.0, tol=PTOL)
+    v = fp.ei((80.0 - 320.0j))
+    assert ae(v, (-3.3464697299634526706e+31 + 1.6473152633843023919e+32j), tol=ATOL)
+    assert ae(v.real, -3.3464697299634526706e+31, tol=PTOL)
+    assert ae(v.imag, 1.6473152633843023919e+32, tol=PTOL)
+    v = fp.ei((1.1641532182693481445e-10 - 1.1641532182693481445e-10j))
+    assert ae(v, (-21.950067703180274374 - 0.78539816351386363145j), tol=ATOL)
+    assert ae(v.real, -21.950067703180274374, tol=PTOL)
+    assert ae(v.imag, -0.78539816351386363145, tol=PTOL)
+    v = fp.ei((0.25 - 0.25j))
+    assert ae(v, (-0.21441047326710323254 - 1.0683772981589995996j), tol=ATOL)
+    assert ae(v.real, -0.21441047326710323254, tol=PTOL)
+    assert ae(v.imag, -1.0683772981589995996, tol=PTOL)
+    v = fp.ei((1.0 - 1.0j))
+    assert ae(v, (1.7646259855638540684 - 2.3877698515105224193j), tol=ATOL)
+    assert ae(v.real, 1.7646259855638540684, tol=PTOL)
+    assert ae(v.imag, -2.3877698515105224193, tol=PTOL)
+    v = fp.ei((2.0 - 2.0j))
+    assert ae(v, (1.8920781621855474089 - 5.3169624378326579621j), tol=ATOL)
+    assert ae(v.real, 1.8920781621855474089, tol=PTOL)
+    assert ae(v.imag, -5.3169624378326579621, tol=PTOL)
+    v = fp.ei((5.0 - 5.0j))
+    assert ae(v, (-13.470936071475245856 + 15.322492395731230968j), tol=ATOL)
+    assert ae(v.real, -13.470936071475245856, tol=PTOL)
+    assert ae(v.imag, 15.322492395731230968, tol=PTOL)
+    v = fp.ei((20.0 - 20.0j))
+    assert ae(v, (16589317.398788971896 - 5831705.4712368307104j), tol=ATOL)
+    assert ae(v.real, 16589317.398788971896, tol=PTOL)
+    assert ae(v.imag, -5831705.4712368307104, tol=PTOL)
+    v = fp.ei((30.0 - 30.0j))
+    assert ae(v, (-154596484273.69322527 + 204179357834.2723043j), tol=ATOL)
+    assert ae(v.real, -154596484273.69322527, tol=PTOL)
+    assert ae(v.imag, 204179357834.2723043, tol=PTOL)
+    v = fp.ei((40.0 - 40.0j))
+    assert ae(v, (287512180321448.45408 - 4203502407932318.1156j), tol=ATOL)
+    assert ae(v.real, 287512180321448.45408, tol=PTOL)
+    assert ae(v.imag, -4203502407932318.1156, tol=PTOL)
+    v = fp.ei((50.0 - 50.0j))
+    assert ae(v, (36128528616649268826.0 + 64648801861338741960.0j), tol=ATOL)
+    assert ae(v.real, 36128528616649268826.0, tol=PTOL)
+    assert ae(v.imag, 64648801861338741960.0, tol=PTOL)
+    v = fp.ei((80.0 - 80.0j))
+    assert ae(v, (-3.8674816337930010217e+32 + 3.0540709639658071041e+32j), tol=ATOL)
+    assert ae(v.real, -3.8674816337930010217e+32, tol=PTOL)
+    assert ae(v.imag, 3.0540709639658071041e+32, tol=PTOL)
+    v = fp.ei((4.6566128730773925781e-10 - 1.1641532182693481445e-10j))
+    assert ae(v, (-20.880034621082893023 - 0.24497866324327947603j), tol=ATOL)
+    assert ae(v.real, -20.880034621082893023, tol=PTOL)
+    assert ae(v.imag, -0.24497866324327947603, tol=PTOL)
+    v = fp.ei((1.0 - 0.25j))
+    assert ae(v, (1.8942716983721074932 - 0.67268237088273915854j), tol=ATOL)
+    assert ae(v.real, 1.8942716983721074932, tol=PTOL)
+    assert ae(v.imag, -0.67268237088273915854, tol=PTOL)
+    v = fp.ei((4.0 - 1.0j))
+    assert ae(v, (14.806699492675420438 - 12.280015176673582616j), tol=ATOL)
+    assert ae(v.real, 14.806699492675420438, tol=PTOL)
+    assert ae(v.imag, -12.280015176673582616, tol=PTOL)
+    v = fp.ei((8.0 - 2.0j))
+    assert ae(v, (-54.633252667426386294 - 416.34477429173650012j), tol=ATOL)
+    assert ae(v.real, -54.633252667426386294, tol=PTOL)
+    assert ae(v.imag, -416.34477429173650012, tol=PTOL)
+    v = fp.ei((20.0 - 5.0j))
+    assert ae(v, (711836.97165402624643 + 24745247.798103247366j), tol=ATOL)
+    assert ae(v.real, 711836.97165402624643, tol=PTOL)
+    assert ae(v.imag, 24745247.798103247366, tol=PTOL)
+    v = fp.ei((80.0 - 20.0j))
+    assert ae(v, (4.2139911108612653091e+32 - 5.3367124741918251637e+32j), tol=ATOL)
+    assert ae(v.real, 4.2139911108612653091e+32, tol=PTOL)
+    assert ae(v.imag, -5.3367124741918251637e+32, tol=PTOL)
+    v = fp.ei((120.0 - 30.0j))
+    assert ae(v, (-9.7760616203707508892e+48 + 1.058257682317195792e+50j), tol=ATOL)
+    assert ae(v.real, -9.7760616203707508892e+48, tol=PTOL)
+    assert ae(v.imag, 1.058257682317195792e+50, tol=PTOL)
+    v = fp.ei((160.0 - 40.0j))
+    assert ae(v, (-8.7065541466623638861e+66 - 1.6577106725141739889e+67j), tol=ATOL)
+    assert ae(v.real, -8.7065541466623638861e+66, tol=PTOL)
+    assert ae(v.imag, -1.6577106725141739889e+67, tol=PTOL)
+    v = fp.ei((200.0 - 50.0j))
+    assert ae(v, (3.070744996327018106e+84 + 1.7243244846769415903e+84j), tol=ATOL)
+    assert ae(v.real, 3.070744996327018106e+84, tol=PTOL)
+    assert ae(v.imag, 1.7243244846769415903e+84, tol=PTOL)
+    v = fp.ei((320.0 - 80.0j))
+    assert ae(v, (-9.9960598637998647276e+135 + 2.6855081527595608863e+136j), tol=ATOL)
+    assert ae(v.real, -9.9960598637998647276e+135, tol=PTOL)
+    assert ae(v.imag, 2.6855081527595608863e+136, tol=PTOL)

llmeval-env/lib/python3.10/site-packages/mpmath/tests/test_functions.py

@@ -0,0 +1,920 @@
+from mpmath.libmp import *
+from mpmath import *
+import random
+import time
+import math
+import cmath
+
+def mpc_ae(a, b, eps=eps):
+    res = True
+    res = res and a.real.ae(b.real, eps)
+    res = res and a.imag.ae(b.imag, eps)
+    return res
+
+#----------------------------------------------------------------------------
+# Constants and functions
+#
+
+tpi = "3.1415926535897932384626433832795028841971693993751058209749445923078\
+1640628620899862803482534211706798"
+te = "2.71828182845904523536028747135266249775724709369995957496696762772407\
+663035354759457138217852516642743"
+tdegree = "0.017453292519943295769236907684886127134428718885417254560971914\
+4017100911460344944368224156963450948221"
+teuler = "0.5772156649015328606065120900824024310421593359399235988057672348\
+84867726777664670936947063291746749516"
+tln2 = "0.693147180559945309417232121458176568075500134360255254120680009493\
+393621969694715605863326996418687542"
+tln10 = "2.30258509299404568401799145468436420760110148862877297603332790096\
+757260967735248023599720508959829834"
+tcatalan = "0.91596559417721901505460351493238411077414937428167213426649811\
+9621763019776254769479356512926115106249"
+tkhinchin = "2.6854520010653064453097148354817956938203822939944629530511523\
+4555721885953715200280114117493184769800"
+tglaisher = "1.2824271291006226368753425688697917277676889273250011920637400\
+2174040630885882646112973649195820237439420646"
+tapery = "1.2020569031595942853997381615114499907649862923404988817922715553\
+4183820578631309018645587360933525815"
+tphi = "1.618033988749894848204586834365638117720309179805762862135448622705\
+26046281890244970720720418939113748475"
+tmertens = "0.26149721284764278375542683860869585905156664826119920619206421\
+3924924510897368209714142631434246651052"
+ttwinprime = "0.660161815846869573927812110014555778432623360284733413319448\
+423335405642304495277143760031413839867912"
+
+def test_constants():
+    for prec in [3, 7, 10, 15, 20, 37, 80, 100, 29]:
+        mp.dps = prec
+        assert pi == mpf(tpi)
+        assert e == mpf(te)
+        assert degree == mpf(tdegree)
+        assert euler == mpf(teuler)
+        assert ln2 == mpf(tln2)
+        assert ln10 == mpf(tln10)
+        assert catalan == mpf(tcatalan)
+        assert khinchin == mpf(tkhinchin)
+        assert glaisher == mpf(tglaisher)
+        assert phi == mpf(tphi)
+        if prec < 50:
+            assert mertens == mpf(tmertens)
+            assert twinprime == mpf(ttwinprime)
+    mp.dps = 15
+    assert pi >= -1
+    assert pi > 2
+    assert pi > 3
+    assert pi < 4
+
+def test_exact_sqrts():
+    for i in range(20000):
+        assert sqrt(mpf(i*i)) == i
+    random.seed(1)
+    for prec in [100, 300, 1000, 10000]:
+        mp.dps = prec
+        for i in range(20):
+            A = random.randint(10**(prec//2-2), 10**(prec//2-1))
+            assert sqrt(mpf(A*A)) == A
+    mp.dps = 15
+    for i in range(100):
+        for a in [1, 8, 25, 112307]:
+            assert sqrt(mpf((a*a, 2*i))) == mpf((a, i))
+            assert sqrt(mpf((a*a, -2*i))) == mpf((a, -i))
+
+def test_sqrt_rounding():
+    for i in [2, 3, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15]:
+        i = from_int(i)
+        for dps in [7, 15, 83, 106, 2000]:
+            mp.dps = dps
+            a = mpf_pow_int(mpf_sqrt(i, mp.prec, round_down), 2, mp.prec, round_down)
+            b = mpf_pow_int(mpf_sqrt(i, mp.prec, round_up), 2, mp.prec, round_up)
+            assert mpf_lt(a, i)
+            assert mpf_gt(b, i)
+    random.seed(1234)
+    prec = 100
+    for rnd in [round_down, round_nearest, round_ceiling]:
+        for i in range(100):
+            a = mpf_rand(prec)
+            b = mpf_mul(a, a)
+            assert mpf_sqrt(b, prec, rnd) == a
+    # Test some extreme cases
+    mp.dps = 100
+    a = mpf(9) + 1e-90
+    b = mpf(9) - 1e-90
+    mp.dps = 15
+    assert sqrt(a, rounding='d') == 3
+    assert sqrt(a, rounding='n') == 3
+    assert sqrt(a, rounding='u') > 3
+    assert sqrt(b, rounding='d') < 3
+    assert sqrt(b, rounding='n') == 3
+    assert sqrt(b, rounding='u') == 3
+    # A worst case, from the MPFR test suite
+    assert sqrt(mpf('7.0503726185518891')) == mpf('2.655253776675949')
+
+def test_float_sqrt():
+    mp.dps = 15
+    # These should round identically
+    for x in [0, 1e-7, 0.1, 0.5, 1, 2, 3, 4, 5, 0.333, 76.19]:
+        assert sqrt(mpf(x)) == float(x)**0.5
+    assert sqrt(-1) == 1j
+    assert sqrt(-2).ae(cmath.sqrt(-2))
+    assert sqrt(-3).ae(cmath.sqrt(-3))
+    assert sqrt(-100).ae(cmath.sqrt(-100))
+    assert sqrt(1j).ae(cmath.sqrt(1j))
+    assert sqrt(-1j).ae(cmath.sqrt(-1j))
+    assert sqrt(math.pi + math.e*1j).ae(cmath.sqrt(math.pi + math.e*1j))
+    assert sqrt(math.pi - math.e*1j).ae(cmath.sqrt(math.pi - math.e*1j))
+
+def test_hypot():
+    assert hypot(0, 0) == 0
+    assert hypot(0, 0.33) == mpf(0.33)
+    assert hypot(0.33, 0) == mpf(0.33)
+    assert hypot(-0.33, 0) == mpf(0.33)
+    assert hypot(3, 4) == mpf(5)
+
+def test_exact_cbrt():
+    for i in range(0, 20000, 200):
+        assert cbrt(mpf(i*i*i)) == i
+    random.seed(1)
+    for prec in [100, 300, 1000, 10000]:
+        mp.dps = prec
+        A = random.randint(10**(prec//2-2), 10**(prec//2-1))
+        assert cbrt(mpf(A*A*A)) == A
+    mp.dps = 15
+
+def test_exp():
+    assert exp(0) == 1
+    assert exp(10000).ae(mpf('8.8068182256629215873e4342'))
+    assert exp(-10000).ae(mpf('1.1354838653147360985e-4343'))
+    a = exp(mpf((1, 8198646019315405, -53, 53)))
+    assert(a.bc == bitcount(a.man))
+    mp.prec = 67
+    a = exp(mpf((1, 1781864658064754565, -60, 61)))
+    assert(a.bc == bitcount(a.man))
+    mp.prec = 53
+    assert exp(ln2 * 10).ae(1024)
+    assert exp(2+2j).ae(cmath.exp(2+2j))
+
+def test_issue_73():
+    mp.dps = 512
+    a = exp(-1)
+    b = exp(1)
+    mp.dps = 15
+    assert (+a).ae(0.36787944117144233)
+    assert (+b).ae(2.7182818284590451)
+
+def test_log():
+    mp.dps = 15
+    assert log(1) == 0
+    for x in [0.5, 1.5, 2.0, 3.0, 100, 10**50, 1e-50]:
+        assert log(x).ae(math.log(x))
+        assert log(x, x) == 1
+    assert log(1024, 2) == 10
+    assert log(10**1234, 10) == 1234
+    assert log(2+2j).ae(cmath.log(2+2j))
+    # Accuracy near 1
+    assert (log(0.6+0.8j).real*10**17).ae(2.2204460492503131)
+    assert (log(0.6-0.8j).real*10**17).ae(2.2204460492503131)
+    assert (log(0.8-0.6j).real*10**17).ae(2.2204460492503131)
+    assert (log(1+1e-8j).real*10**16).ae(0.5)
+    assert (log(1-1e-8j).real*10**16).ae(0.5)
+    assert (log(-1+1e-8j).real*10**16).ae(0.5)
+    assert (log(-1-1e-8j).real*10**16).ae(0.5)
+    assert (log(1j+1e-8).real*10**16).ae(0.5)
+    assert (log(1j-1e-8).real*10**16).ae(0.5)
+    assert (log(-1j+1e-8).real*10**16).ae(0.5)
+    assert (log(-1j-1e-8).real*10**16).ae(0.5)
+    assert (log(1+1e-40j).real*10**80).ae(0.5)
+    assert (log(1j+1e-40).real*10**80).ae(0.5)
+    # Huge
+    assert log(ldexp(1.234,10**20)).ae(log(2)*1e20)
+    assert log(ldexp(1.234,10**200)).ae(log(2)*1e200)
+    # Some special values
+    assert log(mpc(0,0)) == mpc(-inf,0)
+    assert isnan(log(mpc(nan,0)).real)
+    assert isnan(log(mpc(nan,0)).imag)
+    assert isnan(log(mpc(0,nan)).real)
+    assert isnan(log(mpc(0,nan)).imag)
+    assert isnan(log(mpc(nan,1)).real)
+    assert isnan(log(mpc(nan,1)).imag)
+    assert isnan(log(mpc(1,nan)).real)
+    assert isnan(log(mpc(1,nan)).imag)
+
+def test_trig_hyperb_basic():
+    for x in (list(range(100)) + list(range(-100,0))):
+        t = x / 4.1
+        assert cos(mpf(t)).ae(math.cos(t))
+        assert sin(mpf(t)).ae(math.sin(t))
+        assert tan(mpf(t)).ae(math.tan(t))
+        assert cosh(mpf(t)).ae(math.cosh(t))
+        assert sinh(mpf(t)).ae(math.sinh(t))
+        assert tanh(mpf(t)).ae(math.tanh(t))
+    assert sin(1+1j).ae(cmath.sin(1+1j))
+    assert sin(-4-3.6j).ae(cmath.sin(-4-3.6j))
+    assert cos(1+1j).ae(cmath.cos(1+1j))
+    assert cos(-4-3.6j).ae(cmath.cos(-4-3.6j))
+
+def test_degrees():
+    assert cos(0*degree) == 1
+    assert cos(90*degree).ae(0)
+    assert cos(180*degree).ae(-1)
+    assert cos(270*degree).ae(0)
+    assert cos(360*degree).ae(1)
+    assert sin(0*degree) == 0
+    assert sin(90*degree).ae(1)
+    assert sin(180*degree).ae(0)
+    assert sin(270*degree).ae(-1)
+    assert sin(360*degree).ae(0)
+
+def random_complexes(N):
+    random.seed(1)
+    a = []
+    for i in range(N):
+        x1 = random.uniform(-10, 10)
+        y1 = random.uniform(-10, 10)
+        x2 = random.uniform(-10, 10)
+        y2 = random.uniform(-10, 10)
+        z1 = complex(x1, y1)
+        z2 = complex(x2, y2)
+        a.append((z1, z2))
+    return a
+
+def test_complex_powers():
+    for dps in [15, 30, 100]:
+        # Check accuracy for complex square root
+        mp.dps = dps
+        a = mpc(1j)**0.5
+        assert a.real == a.imag == mpf(2)**0.5 / 2
+    mp.dps = 15
+    random.seed(1)
+    for (z1, z2) in random_complexes(100):
+        assert (mpc(z1)**mpc(z2)).ae(z1**z2, 1e-12)
+    assert (e**(-pi*1j)).ae(-1)
+    mp.dps = 50
+    assert (e**(-pi*1j)).ae(-1)
+    mp.dps = 15
+
+def test_complex_sqrt_accuracy():
+    def test_mpc_sqrt(lst):
+        for a, b in lst:
+            z = mpc(a + j*b)
+            assert mpc_ae(sqrt(z*z), z)
+            z = mpc(-a + j*b)
+            assert mpc_ae(sqrt(z*z), -z)
+            z = mpc(a - j*b)
+            assert mpc_ae(sqrt(z*z), z)
+            z = mpc(-a - j*b)
+            assert mpc_ae(sqrt(z*z), -z)
+    random.seed(2)
+    N = 10
+    mp.dps = 30
+    dps = mp.dps
+    test_mpc_sqrt([(random.uniform(0, 10),random.uniform(0, 10)) for i in range(N)])
+    test_mpc_sqrt([(i + 0.1, (i + 0.2)*10**i) for i in range(N)])
+    mp.dps = 15
+
+def test_atan():
+    mp.dps = 15
+    assert atan(-2.3).ae(math.atan(-2.3))
+    assert atan(1e-50) == 1e-50
+    assert atan(1e50).ae(pi/2)
+    assert atan(-1e-50) == -1e-50
+    assert atan(-1e50).ae(-pi/2)
+    assert atan(10**1000).ae(pi/2)
+    for dps in [25, 70, 100, 300, 1000]:
+        mp.dps = dps
+        assert (4*atan(1)).ae(pi)
+    mp.dps = 15
+    pi2 = pi/2
+    assert atan(mpc(inf,-1)).ae(pi2)
+    assert atan(mpc(inf,0)).ae(pi2)
+    assert atan(mpc(inf,1)).ae(pi2)
+    assert atan(mpc(1,inf)).ae(pi2)
+    assert atan(mpc(0,inf)).ae(pi2)
+    assert atan(mpc(-1,inf)).ae(-pi2)
+    assert atan(mpc(-inf,1)).ae(-pi2)
+    assert atan(mpc(-inf,0)).ae(-pi2)
+    assert atan(mpc(-inf,-1)).ae(-pi2)
+    assert atan(mpc(-1,-inf)).ae(-pi2)
+    assert atan(mpc(0,-inf)).ae(-pi2)
+    assert atan(mpc(1,-inf)).ae(pi2)
+
+def test_atan2():
+    mp.dps = 15
+    assert atan2(1,1).ae(pi/4)
+    assert atan2(1,-1).ae(3*pi/4)
+    assert atan2(-1,-1).ae(-3*pi/4)
+    assert atan2(-1,1).ae(-pi/4)
+    assert atan2(-1,0).ae(-pi/2)
+    assert atan2(1,0).ae(pi/2)
+    assert atan2(0,0) == 0
+    assert atan2(inf,0).ae(pi/2)
+    assert atan2(-inf,0).ae(-pi/2)
+    assert isnan(atan2(inf,inf))
+    assert isnan(atan2(-inf,inf))
+    assert isnan(atan2(inf,-inf))
+    assert isnan(atan2(3,nan))
+    assert isnan(atan2(nan,3))
+    assert isnan(atan2(0,nan))
+    assert isnan(atan2(nan,0))
+    assert atan2(0,inf) == 0
+    assert atan2(0,-inf).ae(pi)
+    assert atan2(10,inf) == 0
+    assert atan2(-10,inf) == 0
+    assert atan2(-10,-inf).ae(-pi)
+    assert atan2(10,-inf).ae(pi)
+    assert atan2(inf,10).ae(pi/2)
+    assert atan2(inf,-10).ae(pi/2)
+    assert atan2(-inf,10).ae(-pi/2)
+    assert atan2(-inf,-10).ae(-pi/2)
+
+def test_areal_inverses():
+    assert asin(mpf(0)) == 0
+    assert asinh(mpf(0)) == 0
+    assert acosh(mpf(1)) == 0
+    assert isinstance(asin(mpf(0.5)), mpf)
+    assert isinstance(asin(mpf(2.0)), mpc)
+    assert isinstance(acos(mpf(0.5)), mpf)
+    assert isinstance(acos(mpf(2.0)), mpc)
+    assert isinstance(atanh(mpf(0.1)), mpf)
+    assert isinstance(atanh(mpf(1.1)), mpc)
+
+    random.seed(1)
+    for i in range(50):
+        x = random.uniform(0, 1)
+        assert asin(mpf(x)).ae(math.asin(x))
+        assert acos(mpf(x)).ae(math.acos(x))
+
+        x = random.uniform(-10, 10)
+        assert asinh(mpf(x)).ae(cmath.asinh(x).real)
+        assert isinstance(asinh(mpf(x)), mpf)
+        x = random.uniform(1, 10)
+        assert acosh(mpf(x)).ae(cmath.acosh(x).real)
+        assert isinstance(acosh(mpf(x)), mpf)
+        x = random.uniform(-10, 0.999)
+        assert isinstance(acosh(mpf(x)), mpc)
+
+        x = random.uniform(-1, 1)
+        assert atanh(mpf(x)).ae(cmath.atanh(x).real)
+        assert isinstance(atanh(mpf(x)), mpf)
+
+    dps = mp.dps
+    mp.dps = 300
+    assert isinstance(asin(0.5), mpf)
+    mp.dps = 1000
+    assert asin(1).ae(pi/2)
+    assert asin(-1).ae(-pi/2)
+    mp.dps = dps
+
+def test_invhyperb_inaccuracy():
+    mp.dps = 15
+    assert (asinh(1e-5)*10**5).ae(0.99999999998333333)
+    assert (asinh(1e-10)*10**10).ae(1)
+    assert (asinh(1e-50)*10**50).ae(1)
+    assert (asinh(-1e-5)*10**5).ae(-0.99999999998333333)
+    assert (asinh(-1e-10)*10**10).ae(-1)
+    assert (asinh(-1e-50)*10**50).ae(-1)
+    assert asinh(10**20).ae(46.744849040440862)
+    assert asinh(-10**20).ae(-46.744849040440862)
+    assert (tanh(1e-10)*10**10).ae(1)
+    assert (tanh(-1e-10)*10**10).ae(-1)
+    assert (atanh(1e-10)*10**10).ae(1)
+    assert (atanh(-1e-10)*10**10).ae(-1)
+
+def test_complex_functions():
+    for x in (list(range(10)) + list(range(-10,0))):
+        for y in (list(range(10)) + list(range(-10,0))):
+            z = complex(x, y)/4.3 + 0.01j
+            assert exp(mpc(z)).ae(cmath.exp(z))
+            assert log(mpc(z)).ae(cmath.log(z))
+            assert cos(mpc(z)).ae(cmath.cos(z))
+            assert sin(mpc(z)).ae(cmath.sin(z))
+            assert tan(mpc(z)).ae(cmath.tan(z))
+            assert sinh(mpc(z)).ae(cmath.sinh(z))
+            assert cosh(mpc(z)).ae(cmath.cosh(z))
+            assert tanh(mpc(z)).ae(cmath.tanh(z))
+
+def test_complex_inverse_functions():
+    mp.dps = 15
+    iv.dps = 15
+    for (z1, z2) in random_complexes(30):
+        # apparently cmath uses a different branch, so we
+        # can't use it for comparison
+        assert sinh(asinh(z1)).ae(z1)
+        #
+        assert acosh(z1).ae(cmath.acosh(z1))
+        assert atanh(z1).ae(cmath.atanh(z1))
+        assert atan(z1).ae(cmath.atan(z1))
+        # the reason we set a big eps here is that the cmath
+        # functions are inaccurate
+        assert asin(z1).ae(cmath.asin(z1), rel_eps=1e-12)
+        assert acos(z1).ae(cmath.acos(z1), rel_eps=1e-12)
+        one = mpf(1)
+    for i in range(-9, 10, 3):
+        for k in range(-9, 10, 3):
+            a = 0.9*j*10**k + 0.8*one*10**i
+            b = cos(acos(a))
+            assert b.ae(a)
+            b = sin(asin(a))
+            assert b.ae(a)
+    one = mpf(1)
+    err = 2*10**-15
+    for i in range(-9, 9, 3):
+        for k in range(-9, 9, 3):
+            a = -0.9*10**k + j*0.8*one*10**i
+            b = cosh(acosh(a))
+            assert b.ae(a, err)
+            b = sinh(asinh(a))
+            assert b.ae(a, err)
+
+def test_reciprocal_functions():
+    assert sec(3).ae(-1.01010866590799375)
+    assert csc(3).ae(7.08616739573718592)
+    assert cot(3).ae(-7.01525255143453347)
+    assert sech(3).ae(0.0993279274194332078)
+    assert csch(3).ae(0.0998215696688227329)
+    assert coth(3).ae(1.00496982331368917)
+    assert asec(3).ae(1.23095941734077468)
+    assert acsc(3).ae(0.339836909454121937)
+    assert acot(3).ae(0.321750554396642193)
+    assert asech(0.5).ae(1.31695789692481671)
+    assert acsch(3).ae(0.327450150237258443)
+    assert acoth(3).ae(0.346573590279972655)
+    assert acot(0).ae(1.5707963267948966192)
+    assert acoth(0).ae(1.5707963267948966192j)
+
+def test_ldexp():
+    mp.dps = 15
+    assert ldexp(mpf(2.5), 0) == 2.5
+    assert ldexp(mpf(2.5), -1) == 1.25
+    assert ldexp(mpf(2.5), 2) == 10
+    assert ldexp(mpf('inf'), 3) == mpf('inf')
+
+def test_frexp():
+    mp.dps = 15
+    assert frexp(0) == (0.0, 0)
+    assert frexp(9) == (0.5625, 4)
+    assert frexp(1) == (0.5, 1)
+    assert frexp(0.2) == (0.8, -2)
+    assert frexp(1000) == (0.9765625, 10)
+
+def test_aliases():
+    assert ln(7) == log(7)
+    assert log10(3.75) == log(3.75,10)
+    assert degrees(5.6) == 5.6 / degree
+    assert radians(5.6) == 5.6 * degree
+    assert power(-1,0.5) == j
+    assert fmod(25,7) == 4.0 and isinstance(fmod(25,7), mpf)
+
+def test_arg_sign():
+    assert arg(3) == 0
+    assert arg(-3).ae(pi)
+    assert arg(j).ae(pi/2)
+    assert arg(-j).ae(-pi/2)
+    assert arg(0) == 0
+    assert isnan(atan2(3,nan))
+    assert isnan(atan2(nan,3))
+    assert isnan(atan2(0,nan))
+    assert isnan(atan2(nan,0))
+    assert isnan(atan2(nan,nan))
+    assert arg(inf) == 0
+    assert arg(-inf).ae(pi)
+    assert isnan(arg(nan))
+    #assert arg(inf*j).ae(pi/2)
+    assert sign(0) == 0
+    assert sign(3) == 1
+    assert sign(-3) == -1
+    assert sign(inf) == 1
+    assert sign(-inf) == -1
+    assert isnan(sign(nan))
+    assert sign(j) == j
+    assert sign(-3*j) == -j
+    assert sign(1+j).ae((1+j)/sqrt(2))
+
+def test_misc_bugs():
+    # test that this doesn't raise an exception
+    mp.dps = 1000
+    log(1302)
+    mp.dps = 15
+
+def test_arange():
+    assert arange(10) == [mpf('0.0'), mpf('1.0'), mpf('2.0'), mpf('3.0'),
+                          mpf('4.0'), mpf('5.0'), mpf('6.0'), mpf('7.0'),
+                          mpf('8.0'), mpf('9.0')]
+    assert arange(-5, 5) == [mpf('-5.0'), mpf('-4.0'), mpf('-3.0'),
+                             mpf('-2.0'), mpf('-1.0'), mpf('0.0'),
+                             mpf('1.0'), mpf('2.0'), mpf('3.0'), mpf('4.0')]
+    assert arange(0, 1, 0.1) == [mpf('0.0'), mpf('0.10000000000000001'),
+                                 mpf('0.20000000000000001'),
+                                 mpf('0.30000000000000004'),
+                                 mpf('0.40000000000000002'),
+                                 mpf('0.5'), mpf('0.60000000000000009'),
+                                 mpf('0.70000000000000007'),
+                                 mpf('0.80000000000000004'),
+                                 mpf('0.90000000000000002')]
+    assert arange(17, -9, -3) == [mpf('17.0'), mpf('14.0'), mpf('11.0'),
+                                  mpf('8.0'), mpf('5.0'), mpf('2.0'),
+                                  mpf('-1.0'), mpf('-4.0'), mpf('-7.0')]
+    assert arange(0.2, 0.1, -0.1) == [mpf('0.20000000000000001')]
+    assert arange(0) == []
+    assert arange(1000, -1) == []
+    assert arange(-1.23, 3.21, -0.0000001) == []
+
+def test_linspace():
+    assert linspace(2, 9, 7) == [mpf('2.0'), mpf('3.166666666666667'),
+        mpf('4.3333333333333339'), mpf('5.5'), mpf('6.666666666666667'),
+        mpf('7.8333333333333339'), mpf('9.0')]
+    assert linspace(2, 9, 7, endpoint=0) == [mpf('2.0'), mpf('3.0'), mpf('4.0'),
+        mpf('5.0'), mpf('6.0'), mpf('7.0'), mpf('8.0')]
+    assert linspace(2, 7, 1) == [mpf(2)]
+
+def test_float_cbrt():
+    mp.dps = 30
+    for a in arange(0,10,0.1):
+        assert cbrt(a*a*a).ae(a, eps)
+    assert cbrt(-1).ae(0.5 + j*sqrt(3)/2)
+    one_third = mpf(1)/3
+    for a in arange(0,10,2.7) + [0.1 + 10**5]:
+        a = mpc(a + 1.1j)
+        r1 = cbrt(a)
+        mp.dps += 10
+        r2 = pow(a, one_third)
+        mp.dps -= 10
+        assert r1.ae(r2, eps)
+    mp.dps = 100
+    for n in range(100, 301, 100):
+        w = 10**n + j*10**-3
+        z = w*w*w
+        r = cbrt(z)
+        assert mpc_ae(r, w, eps)
+    mp.dps = 15
+
+def test_root():
+    mp.dps = 30
+    random.seed(1)
+    a = random.randint(0, 10000)
+    p = a*a*a
+    r = nthroot(mpf(p), 3)
+    assert r == a
+    for n in range(4, 10):
+        p = p*a
+        assert nthroot(mpf(p), n) == a
+    mp.dps = 40
+    for n in range(10, 5000, 100):
+        for a in [random.random()*10000, random.random()*10**100]:
+            r = nthroot(a, n)
+            r1 = pow(a, mpf(1)/n)
+            assert r.ae(r1)
+            r = nthroot(a, -n)
+            r1 = pow(a, -mpf(1)/n)
+            assert r.ae(r1)
+    # XXX: this is broken right now
+    # tests for nthroot rounding
+    for rnd in ['nearest', 'up', 'down']:
+        mp.rounding = rnd
+        for n in [-5, -3, 3, 5]:
+            prec = 50
+            for i in range(10):
+                mp.prec = prec
+                a = rand()
+                mp.prec = 2*prec
+                b = a**n
+                mp.prec = prec
+                r = nthroot(b, n)
+                assert r == a
+    mp.dps = 30
+    for n in range(3, 21):
+        a = (random.random() + j*random.random())
+        assert nthroot(a, n).ae(pow(a, mpf(1)/n))
+        assert mpc_ae(nthroot(a, n), pow(a, mpf(1)/n))
+        a = (random.random()*10**100 + j*random.random())
+        r = nthroot(a, n)
+        mp.dps += 4
+        r1 = pow(a, mpf(1)/n)
+        mp.dps -= 4
+        assert r.ae(r1)
+        assert mpc_ae(r, r1, eps)
+        r = nthroot(a, -n)
+        mp.dps += 4
+        r1 = pow(a, -mpf(1)/n)
+        mp.dps -= 4
+        assert r.ae(r1)
+        assert mpc_ae(r, r1, eps)
+    mp.dps = 15
+    assert nthroot(4, 1) == 4
+    assert nthroot(4, 0) == 1
+    assert nthroot(4, -1) == 0.25
+    assert nthroot(inf, 1) == inf
+    assert nthroot(inf, 2) == inf
+    assert nthroot(inf, 3) == inf
+    assert nthroot(inf, -1) == 0
+    assert nthroot(inf, -2) == 0
+    assert nthroot(inf, -3) == 0
+    assert nthroot(j, 1) == j
+    assert nthroot(j, 0) == 1
+    assert nthroot(j, -1) == -j
+    assert isnan(nthroot(nan, 1))
+    assert isnan(nthroot(nan, 0))
+    assert isnan(nthroot(nan, -1))
+    assert isnan(nthroot(inf, 0))
+    assert root(2,3) == nthroot(2,3)
+    assert root(16,4,0) == 2
+    assert root(16,4,1) == 2j
+    assert root(16,4,2) == -2
+    assert root(16,4,3) == -2j
+    assert root(16,4,4) == 2
+    assert root(-125,3,1) == -5
+
+def test_issue_136():
+    for dps in [20, 80]:
+        mp.dps = dps
+        r = nthroot(mpf('-1e-20'), 4)
+        assert r.ae(mpf(10)**(-5) * (1 + j) * mpf(2)**(-0.5))
+    mp.dps = 80
+    assert nthroot('-1e-3', 4).ae(mpf(10)**(-3./4) * (1 + j)/sqrt(2))
+    assert nthroot('-1e-6', 4).ae((1 + j)/(10 * sqrt(20)))
+    # Check that this doesn't take eternity to compute
+    mp.dps = 20
+    assert nthroot('-1e100000000', 4).ae((1+j)*mpf('1e25000000')/sqrt(2))
+    mp.dps = 15
+
+def test_mpcfun_real_imag():
+    mp.dps = 15
+    x = mpf(0.3)
+    y = mpf(0.4)
+    assert exp(mpc(x,0)) == exp(x)
+    assert exp(mpc(0,y)) == mpc(cos(y),sin(y))
+    assert cos(mpc(x,0)) == cos(x)
+    assert sin(mpc(x,0)) == sin(x)
+    assert cos(mpc(0,y)) == cosh(y)
+    assert sin(mpc(0,y)) == mpc(0,sinh(y))
+    assert cospi(mpc(x,0)) == cospi(x)
+    assert sinpi(mpc(x,0)) == sinpi(x)
+    assert cospi(mpc(0,y)).ae(cosh(pi*y))
+    assert sinpi(mpc(0,y)).ae(mpc(0,sinh(pi*y)))
+    c, s = cospi_sinpi(mpc(x,0))
+    assert c == cospi(x)
+    assert s == sinpi(x)
+    c, s = cospi_sinpi(mpc(0,y))
+    assert c.ae(cosh(pi*y))
+    assert s.ae(mpc(0,sinh(pi*y)))
+    c, s = cos_sin(mpc(x,0))
+    assert c == cos(x)
+    assert s == sin(x)
+    c, s = cos_sin(mpc(0,y))
+    assert c == cosh(y)
+    assert s == mpc(0,sinh(y))
+
+def test_perturbation_rounding():
+    mp.dps = 100
+    a = pi/10**50
+    b = -pi/10**50
+    c = 1 + a
+    d = 1 + b
+    mp.dps = 15
+    assert exp(a) == 1
+    assert exp(a, rounding='c') > 1
+    assert exp(b, rounding='c') == 1
+    assert exp(a, rounding='f') == 1
+    assert exp(b, rounding='f') < 1
+    assert cos(a) == 1
+    assert cos(a, rounding='c') == 1
+    assert cos(b, rounding='c') == 1
+    assert cos(a, rounding='f') < 1
+    assert cos(b, rounding='f') < 1
+    for f in [sin, atan, asinh, tanh]:
+        assert f(a) == +a
+        assert f(a, rounding='c') > a
+        assert f(a, rounding='f') < a
+        assert f(b) == +b
+        assert f(b, rounding='c') > b
+        assert f(b, rounding='f') < b
+    for f in [asin, tan, sinh, atanh]:
+        assert f(a) == +a
+        assert f(b) == +b
+        assert f(a, rounding='c') > a
+        assert f(b, rounding='c') > b
+        assert f(a, rounding='f') < a
+        assert f(b, rounding='f') < b
+    assert ln(c) == +a
+    assert ln(d) == +b
+    assert ln(c, rounding='c') > a
+    assert ln(c, rounding='f') < a
+    assert ln(d, rounding='c') > b
+    assert ln(d, rounding='f') < b
+    assert cosh(a) == 1
+    assert cosh(b) == 1
+    assert cosh(a, rounding='c') > 1
+    assert cosh(b, rounding='c') > 1
+    assert cosh(a, rounding='f') == 1
+    assert cosh(b, rounding='f') == 1
+
+def test_integer_parts():
+    assert floor(3.2) == 3
+    assert ceil(3.2) == 4
+    assert floor(3.2+5j) == 3+5j
+    assert ceil(3.2+5j) == 4+5j
+
+def test_complex_parts():
+    assert fabs('3') == 3
+    assert fabs(3+4j) == 5
+    assert re(3) == 3
+    assert re(1+4j) == 1
+    assert im(3) == 0
+    assert im(1+4j) == 4
+    assert conj(3) == 3
+    assert conj(3+4j) == 3-4j
+    assert mpf(3).conjugate() == 3
+
+def test_cospi_sinpi():
+    assert sinpi(0) == 0
+    assert sinpi(0.5) == 1
+    assert sinpi(1) == 0
+    assert sinpi(1.5) == -1
+    assert sinpi(2) == 0
+    assert sinpi(2.5) == 1
+    assert sinpi(-0.5) == -1
+    assert cospi(0) == 1
+    assert cospi(0.5) == 0
+    assert cospi(1) == -1
+    assert cospi(1.5) == 0
+    assert cospi(2) == 1
+    assert cospi(2.5) == 0
+    assert cospi(-0.5) == 0
+    assert cospi(100000000000.25).ae(sqrt(2)/2)
+    a = cospi(2+3j)
+    assert a.real.ae(cos((2+3j)*pi).real)
+    assert a.imag == 0
+    b = sinpi(2+3j)
+    assert b.imag.ae(sin((2+3j)*pi).imag)
+    assert b.real == 0
+    mp.dps = 35
+    x1 = mpf(10000) - mpf('1e-15')
+    x2 = mpf(10000) + mpf('1e-15')
+    x3 = mpf(10000.5) - mpf('1e-15')
+    x4 = mpf(10000.5) + mpf('1e-15')
+    x5 = mpf(10001) - mpf('1e-15')
+    x6 = mpf(10001) + mpf('1e-15')
+    x7 = mpf(10001.5) - mpf('1e-15')
+    x8 = mpf(10001.5) + mpf('1e-15')
+    mp.dps = 15
+    M = 10**15
+    assert (sinpi(x1)*M).ae(-pi)
+    assert (sinpi(x2)*M).ae(pi)
+    assert (cospi(x3)*M).ae(pi)
+    assert (cospi(x4)*M).ae(-pi)
+    assert (sinpi(x5)*M).ae(pi)
+    assert (sinpi(x6)*M).ae(-pi)
+    assert (cospi(x7)*M).ae(-pi)
+    assert (cospi(x8)*M).ae(pi)
+    assert 0.999 < cospi(x1, rounding='d') < 1
+    assert 0.999 < cospi(x2, rounding='d') < 1
+    assert 0.999 < sinpi(x3, rounding='d') < 1
+    assert 0.999 < sinpi(x4, rounding='d') < 1
+    assert -1 < cospi(x5, rounding='d') < -0.999
+    assert -1 < cospi(x6, rounding='d') < -0.999
+    assert -1 < sinpi(x7, rounding='d') < -0.999
+    assert -1 < sinpi(x8, rounding='d') < -0.999
+    assert (sinpi(1e-15)*M).ae(pi)
+    assert (sinpi(-1e-15)*M).ae(-pi)
+    assert cospi(1e-15) == 1
+    assert cospi(1e-15, rounding='d') < 1
+
+def test_expj():
+    assert expj(0) == 1
+    assert expj(1).ae(exp(j))
+    assert expj(j).ae(exp(-1))
+    assert expj(1+j).ae(exp(j*(1+j)))
+    assert expjpi(0) == 1
+    assert expjpi(1).ae(exp(j*pi))
+    assert expjpi(j).ae(exp(-pi))
+    assert expjpi(1+j).ae(exp(j*pi*(1+j)))
+    assert expjpi(-10**15 * j).ae('2.22579818340535731e+1364376353841841')
+
+def test_sinc():
+    assert sinc(0) == sincpi(0) == 1
+    assert sinc(inf) == sincpi(inf) == 0
+    assert sinc(-inf) == sincpi(-inf) == 0
+    assert sinc(2).ae(0.45464871341284084770)
+    assert sinc(2+3j).ae(0.4463290318402435457-2.7539470277436474940j)
+    assert sincpi(2) == 0
+    assert sincpi(1.5).ae(-0.212206590789193781)
+
+def test_fibonacci():
+    mp.dps = 15
+    assert [fibonacci(n) for n in range(-5, 10)] == \
+        [5, -3, 2, -1, 1, 0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
+    assert fib(2.5).ae(1.4893065462657091)
+    assert fib(3+4j).ae(-5248.51130728372 - 14195.962288353j)
+    assert fib(1000).ae(4.3466557686937455e+208)
+    assert str(fib(10**100)) == '6.24499112864607e+2089876402499787337692720892375554168224592399182109535392875613974104853496745963277658556235103534'
+    mp.dps = 2100
+    a = fib(10000)
+    assert a % 10**10 == 9947366875
+    mp.dps = 15
+    assert fibonacci(inf) == inf
+    assert fib(3+0j) == 2
+
+def test_call_with_dps():
+    mp.dps = 15
+    assert abs(exp(1, dps=30)-e(dps=35)) < 1e-29
+
+def test_tanh():
+    mp.dps = 15
+    assert tanh(0) == 0
+    assert tanh(inf) == 1
+    assert tanh(-inf) == -1
+    assert isnan(tanh(nan))
+    assert tanh(mpc('inf', '0')) == 1
+
+def test_atanh():
+    mp.dps = 15
+    assert atanh(0) == 0
+    assert atanh(0.5).ae(0.54930614433405484570)
+    assert atanh(-0.5).ae(-0.54930614433405484570)
+    assert atanh(1) == inf
+    assert atanh(-1) == -inf
+    assert isnan(atanh(nan))
+    assert isinstance(atanh(1), mpf)
+    assert isinstance(atanh(-1), mpf)
+    # Limits at infinity
+    jpi2 = j*pi/2
+    assert atanh(inf).ae(-jpi2)
+    assert atanh(-inf).ae(jpi2)
+    assert atanh(mpc(inf,-1)).ae(-jpi2)
+    assert atanh(mpc(inf,0)).ae(-jpi2)
+    assert atanh(mpc(inf,1)).ae(jpi2)
+    assert atanh(mpc(1,inf)).ae(jpi2)
+    assert atanh(mpc(0,inf)).ae(jpi2)
+    assert atanh(mpc(-1,inf)).ae(jpi2)
+    assert atanh(mpc(-inf,1)).ae(jpi2)
+    assert atanh(mpc(-inf,0)).ae(jpi2)
+    assert atanh(mpc(-inf,-1)).ae(-jpi2)
+    assert atanh(mpc(-1,-inf)).ae(-jpi2)
+    assert atanh(mpc(0,-inf)).ae(-jpi2)
+    assert atanh(mpc(1,-inf)).ae(-jpi2)
+
+def test_expm1():
+    mp.dps = 15
+    assert expm1(0) == 0
+    assert expm1(3).ae(exp(3)-1)
+    assert expm1(inf) == inf
+    assert expm1(1e-50).ae(1e-50)
+    assert (expm1(1e-10)*1e10).ae(1.00000000005)
+
+def test_log1p():
+    mp.dps = 15
+    assert log1p(0) == 0
+    assert log1p(3).ae(log(1+3))
+    assert log1p(inf) == inf
+    assert log1p(1e-50).ae(1e-50)
+    assert (log1p(1e-10)*1e10).ae(0.99999999995)
+
+def test_powm1():
+    mp.dps = 15
+    assert powm1(2,3) == 7
+    assert powm1(-1,2) == 0
+    assert powm1(-1,0) == 0
+    assert powm1(-2,0) == 0
+    assert powm1(3+4j,0) == 0
+    assert powm1(0,1) == -1
+    assert powm1(0,0) == 0
+    assert powm1(1,0) == 0
+    assert powm1(1,2) == 0
+    assert powm1(1,3+4j) == 0
+    assert powm1(1,5) == 0
+    assert powm1(j,4) == 0
+    assert powm1(-j,4) == 0
+    assert (powm1(2,1e-100)*1e100).ae(ln2)
+    assert powm1(2,'1e-100000000000') != 0
+    assert (powm1(fadd(1,1e-100,exact=True), 5)*1e100).ae(5)
+
+def test_unitroots():
+    assert unitroots(1) == [1]
+    assert unitroots(2) == [1, -1]
+    a, b, c = unitroots(3)
+    assert a == 1
+    assert b.ae(-0.5 + 0.86602540378443864676j)
+    assert c.ae(-0.5 - 0.86602540378443864676j)
+    assert unitroots(1, primitive=True) == [1]
+    assert unitroots(2, primitive=True) == [-1]
+    assert unitroots(3, primitive=True) == unitroots(3)[1:]
+    assert unitroots(4, primitive=True) == [j, -j]
+    assert len(unitroots(17, primitive=True)) == 16
+    assert len(unitroots(16, primitive=True)) == 8
+
+def test_cyclotomic():
+    mp.dps = 15
+    assert [cyclotomic(n,1) for n in range(31)] == [1,0,2,3,2,5,1,7,2,3,1,11,1,13,1,1,2,17,1,19,1,1,1,23,1,5,1,3,1,29,1]
+    assert [cyclotomic(n,-1) for n in range(31)] == [1,-2,0,1,2,1,3,1,2,1,5,1,1,1,7,1,2,1,3,1,1,1,11,1,1,1,13,1,1,1,1]
+    assert [cyclotomic(n,j) for n in range(21)] == [1,-1+j,1+j,j,0,1,-j,j,2,-j,1,j,3,1,-j,1,2,1,j,j,5]
+    assert [cyclotomic(n,-j) for n in range(21)] == [1,-1-j,1-j,-j,0,1,j,-j,2,j,1,-j,3,1,j,1,2,1,-j,-j,5]
+    assert cyclotomic(1624,j) == 1
+    assert cyclotomic(33600,j) == 1
+    u = sqrt(j, prec=500)
+    assert cyclotomic(8, u).ae(0)
+    assert cyclotomic(30, u).ae(5.8284271247461900976)
+    assert cyclotomic(2040, u).ae(1)
+    assert cyclotomic(0,2.5) == 1
+    assert cyclotomic(1,2.5) == 2.5-1
+    assert cyclotomic(2,2.5) == 2.5+1
+    assert cyclotomic(3,2.5) == 2.5**2 + 2.5 + 1
+    assert cyclotomic(7,2.5) == 406.234375

llmeval-env/lib/python3.10/site-packages/mpmath/tests/test_functions2.py

@@ -0,0 +1,2384 @@
+import math
+import pytest
+from mpmath import *
+
+def test_bessel():
+    mp.dps = 15
+    assert j0(1).ae(0.765197686557966551)
+    assert j0(pi).ae(-0.304242177644093864)
+    assert j0(1000).ae(0.0247866861524201746)
+    assert j0(-25).ae(0.0962667832759581162)
+    assert j1(1).ae(0.440050585744933516)
+    assert j1(pi).ae(0.284615343179752757)
+    assert j1(1000).ae(0.00472831190708952392)
+    assert j1(-25).ae(0.125350249580289905)
+    assert besselj(5,1).ae(0.000249757730211234431)
+    assert besselj(5+0j,1).ae(0.000249757730211234431)
+    assert besselj(5,pi).ae(0.0521411843671184747)
+    assert besselj(5,1000).ae(0.00502540694523318607)
+    assert besselj(5,-25).ae(0.0660079953984229934)
+    assert besselj(-3,2).ae(-0.128943249474402051)
+    assert besselj(-4,2).ae(0.0339957198075684341)
+    assert besselj(3,3+2j).ae(0.424718794929639595942 + 0.625665327745785804812j)
+    assert besselj(0.25,4).ae(-0.374760630804249715)
+    assert besselj(1+2j,3+4j).ae(0.319247428741872131 - 0.669557748880365678j)
+    assert (besselj(3, 10**10) * 10**5).ae(0.76765081748139204023)
+    assert bessely(-0.5, 0) == 0
+    assert bessely(0.5, 0) == -inf
+    assert bessely(1.5, 0) == -inf
+    assert bessely(0,0) == -inf
+    assert bessely(-0.4, 0) == -inf
+    assert bessely(-0.6, 0) == inf
+    assert bessely(-1, 0) == inf
+    assert bessely(-1.4, 0) == inf
+    assert bessely(-1.6, 0) == -inf
+    assert bessely(-1, 0) == inf
+    assert bessely(-2, 0) == -inf
+    assert bessely(-3, 0) == inf
+    assert bessely(0.5, 0) == -inf
+    assert bessely(1, 0) == -inf
+    assert bessely(1.5, 0) == -inf
+    assert bessely(2, 0) == -inf
+    assert bessely(2.5, 0) == -inf
+    assert bessely(3, 0) == -inf
+    assert bessely(0,0.5).ae(-0.44451873350670655715)
+    assert bessely(1,0.5).ae(-1.4714723926702430692)
+    assert bessely(-1,0.5).ae(1.4714723926702430692)
+    assert bessely(3.5,0.5).ae(-138.86400867242488443)
+    assert bessely(0,3+4j).ae(4.6047596915010138655-8.8110771408232264208j)
+    assert bessely(0,j).ae(-0.26803248203398854876+1.26606587775200833560j)
+    assert (bessely(3, 10**10) * 10**5).ae(0.21755917537013204058)
+    assert besseli(0,0) == 1
+    assert besseli(1,0) == 0
+    assert besseli(2,0) == 0
+    assert besseli(-1,0) == 0
+    assert besseli(-2,0) == 0
+    assert besseli(0,0.5).ae(1.0634833707413235193)
+    assert besseli(1,0.5).ae(0.25789430539089631636)
+    assert besseli(-1,0.5).ae(0.25789430539089631636)
+    assert besseli(3.5,0.5).ae(0.00068103597085793815863)
+    assert besseli(0,3+4j).ae(-3.3924877882755196097-1.3239458916287264815j)
+    assert besseli(0,j).ae(besselj(0,1))
+    assert (besseli(3, 10**10) * mpf(10)**(-4342944813)).ae(4.2996028505491271875)
+    assert besselk(0,0) == inf
+    assert besselk(1,0) == inf
+    assert besselk(2,0) == inf
+    assert besselk(-1,0) == inf
+    assert besselk(-2,0) == inf
+    assert besselk(0,0.5).ae(0.92441907122766586178)
+    assert besselk(1,0.5).ae(1.6564411200033008937)
+    assert besselk(-1,0.5).ae(1.6564411200033008937)
+    assert besselk(3.5,0.5).ae(207.48418747548460607)
+    assert besselk(0,3+4j).ae(-0.007239051213570155013+0.026510418350267677215j)
+    assert besselk(0,j).ae(-0.13863371520405399968-1.20196971531720649914j)
+    assert (besselk(3, 10**10) * mpf(10)**4342944824).ae(1.1628981033356187851)
+    # test for issue 331, bug reported by Michael Hartmann
+    for n in range(10,100,10):
+        mp.dps = n
+        assert besseli(91.5,24.7708).ae("4.00830632138673963619656140653537080438462342928377020695738635559218797348548092636896796324190271316137982810144874264e-41")
+
+def test_bessel_zeros():
+    mp.dps = 15
+    assert besseljzero(0,1).ae(2.40482555769577276869)
+    assert besseljzero(2,1).ae(5.1356223018406825563)
+    assert besseljzero(1,50).ae(157.86265540193029781)
+    assert besseljzero(10,1).ae(14.475500686554541220)
+    assert besseljzero(0.5,3).ae(9.4247779607693797153)
+    assert besseljzero(2,1,1).ae(3.0542369282271403228)
+    assert besselyzero(0,1).ae(0.89357696627916752158)
+    assert besselyzero(2,1).ae(3.3842417671495934727)
+    assert besselyzero(1,50).ae(156.29183520147840108)
+    assert besselyzero(10,1).ae(12.128927704415439387)
+    assert besselyzero(0.5,3).ae(7.8539816339744830962)
+    assert besselyzero(2,1,1).ae(5.0025829314460639452)
+
+def test_hankel():
+    mp.dps = 15
+    assert hankel1(0,0.5).ae(0.93846980724081290423-0.44451873350670655715j)
+    assert hankel1(1,0.5).ae(0.2422684576748738864-1.4714723926702430692j)
+    assert hankel1(-1,0.5).ae(-0.2422684576748738864+1.4714723926702430692j)
+    assert hankel1(1.5,0.5).ae(0.0917016996256513026-2.5214655504213378514j)
+    assert hankel1(1.5,3+4j).ae(0.0066806866476728165382-0.0036684231610839127106j)
+    assert hankel2(0,0.5).ae(0.93846980724081290423+0.44451873350670655715j)
+    assert hankel2(1,0.5).ae(0.2422684576748738864+1.4714723926702430692j)
+    assert hankel2(-1,0.5).ae(-0.2422684576748738864-1.4714723926702430692j)
+    assert hankel2(1.5,0.5).ae(0.0917016996256513026+2.5214655504213378514j)
+    assert hankel2(1.5,3+4j).ae(14.783528526098567526-7.397390270853446512j)
+
+def test_struve():
+    mp.dps = 15
+    assert struveh(2,3).ae(0.74238666967748318564)
+    assert struveh(-2.5,3).ae(0.41271003220971599344)
+    assert struvel(2,3).ae(1.7476573277362782744)
+    assert struvel(-2.5,3).ae(1.5153394466819651377)
+
+def test_whittaker():
+    mp.dps = 15
+    assert whitm(2,3,4).ae(49.753745589025246591)
+    assert whitw(2,3,4).ae(14.111656223052932215)
+
+def test_kelvin():
+    mp.dps = 15
+    assert ber(2,3).ae(0.80836846563726819091)
+    assert ber(3,4).ae(-0.28262680167242600233)
+    assert ber(-3,2).ae(-0.085611448496796363669)
+    assert bei(2,3).ae(-0.89102236377977331571)
+    assert bei(-3,2).ae(-0.14420994155731828415)
+    assert ker(2,3).ae(0.12839126695733458928)
+    assert ker(-3,2).ae(-0.29802153400559142783)
+    assert ker(0.5,3).ae(-0.085662378535217097524)
+    assert kei(2,3).ae(0.036804426134164634000)
+    assert kei(-3,2).ae(0.88682069845786731114)
+    assert kei(0.5,3).ae(0.013633041571314302948)
+
+def test_hyper_misc():
+    mp.dps = 15
+    assert hyp0f1(1,0) == 1
+    assert hyp1f1(1,2,0) == 1
+    assert hyp1f2(1,2,3,0) == 1
+    assert hyp2f1(1,2,3,0) == 1
+    assert hyp2f2(1,2,3,4,0) == 1
+    assert hyp2f3(1,2,3,4,5,0) == 1
+    # Degenerate case: 0F0
+    assert hyper([],[],0) == 1
+    assert hyper([],[],-2).ae(exp(-2))
+    # Degenerate case: 1F0
+    assert hyper([2],[],1.5) == 4
+    #
+    assert hyp2f1((1,3),(2,3),(5,6),mpf(27)/32).ae(1.6)
+    assert hyp2f1((1,4),(1,2),(3,4),mpf(80)/81).ae(1.8)
+    assert hyp2f1((2,3),(1,1),(3,2),(2+j)/3).ae(1.327531603558679093+0.439585080092769253j)
+    mp.dps = 25
+    v = mpc('1.2282306665029814734863026', '-0.1225033830118305184672133')
+    assert hyper([(3,4),2+j,1],[1,5,j/3],mpf(1)/5+j/8).ae(v)
+    mp.dps = 15
+
+def test_elliptic_integrals():
+    mp.dps = 15
+    assert ellipk(0).ae(pi/2)
+    assert ellipk(0.5).ae(gamma(0.25)**2/(4*sqrt(pi)))
+    assert ellipk(1) == inf
+    assert ellipk(1+0j) == inf
+    assert ellipk(-1).ae('1.3110287771460599052')
+    assert ellipk(-2).ae('1.1714200841467698589')
+    assert isinstance(ellipk(-2), mpf)
+    assert isinstance(ellipe(-2), mpf)
+    assert ellipk(-50).ae('0.47103424540873331679')
+    mp.dps = 30
+    n1 = +fraction(99999,100000)
+    n2 = +fraction(100001,100000)
+    mp.dps = 15
+    assert ellipk(n1).ae('7.1427724505817781901')
+    assert ellipk(n2).ae(mpc('7.1427417367963090109', '-1.5707923998261688019'))
+    assert ellipe(n1).ae('1.0000332138990829170')
+    v = ellipe(n2)
+    assert v.real.ae('0.999966786328145474069137')
+    assert (v.imag*10**6).ae('7.853952181727432')
+    assert ellipk(2).ae(mpc('1.3110287771460599052', '-1.3110287771460599052'))
+    assert ellipk(50).ae(mpc('0.22326753950210985451', '-0.47434723226254522087'))
+    assert ellipk(3+4j).ae(mpc('0.91119556380496500866', '0.63133428324134524388'))
+    assert ellipk(3-4j).ae(mpc('0.91119556380496500866', '-0.63133428324134524388'))
+    assert ellipk(-3+4j).ae(mpc('0.95357894880405122483', '0.23093044503746114444'))
+    assert ellipk(-3-4j).ae(mpc('0.95357894880405122483', '-0.23093044503746114444'))
+    assert isnan(ellipk(nan))
+    assert isnan(ellipe(nan))
+    assert ellipk(inf) == 0
+    assert isinstance(ellipk(inf), mpc)
+    assert ellipk(-inf) == 0
+    assert ellipk(1+0j) == inf
+    assert ellipe(0).ae(pi/2)
+    assert ellipe(0.5).ae(pi**(mpf(3)/2)/gamma(0.25)**2 +gamma(0.25)**2/(8*sqrt(pi)))
+    assert ellipe(1) == 1
+    assert ellipe(1+0j) == 1
+    assert ellipe(inf) == mpc(0,inf)
+    assert ellipe(-inf) == inf
+    assert ellipe(3+4j).ae(1.4995535209333469543-1.5778790079127582745j)
+    assert ellipe(3-4j).ae(1.4995535209333469543+1.5778790079127582745j)
+    assert ellipe(-3+4j).ae(2.5804237855343377803-0.8306096791000413778j)
+    assert ellipe(-3-4j).ae(2.5804237855343377803+0.8306096791000413778j)
+    assert ellipe(2).ae(0.59907011736779610372+0.59907011736779610372j)
+    assert ellipe('1e-1000000000').ae(pi/2)
+    assert ellipk('1e-1000000000').ae(pi/2)
+    assert ellipe(-pi).ae(2.4535865983838923)
+    mp.dps = 50
+    assert ellipk(1/pi).ae('1.724756270009501831744438120951614673874904182624739673')
+    assert ellipe(1/pi).ae('1.437129808135123030101542922290970050337425479058225712')
+    assert ellipk(-10*pi).ae('0.5519067523886233967683646782286965823151896970015484512')
+    assert ellipe(-10*pi).ae('5.926192483740483797854383268707108012328213431657645509')
+    v = ellipk(pi)
+    assert v.real.ae('0.973089521698042334840454592642137667227167622330325225')
+    assert v.imag.ae('-1.156151296372835303836814390793087600271609993858798016')
+    v = ellipe(pi)
+    assert v.real.ae('0.4632848917264710404078033487934663562998345622611263332')
+    assert v.imag.ae('1.0637961621753130852473300451583414489944099504180510966')
+    mp.dps = 15
+
+def test_exp_integrals():
+    mp.dps = 15
+    x = +e
+    z = e + sqrt(3)*j
+    assert ei(x).ae(8.21168165538361560)
+    assert li(x).ae(1.89511781635593676)
+    assert si(x).ae(1.82104026914756705)
+    assert ci(x).ae(0.213958001340379779)
+    assert shi(x).ae(4.11520706247846193)
+    assert chi(x).ae(4.09647459290515367)
+    assert fresnels(x).ae(0.437189718149787643)
+    assert fresnelc(x).ae(0.401777759590243012)
+    assert airyai(x).ae(0.0108502401568586681)
+    assert airybi(x).ae(8.98245748585468627)
+    assert ei(z).ae(3.72597969491314951 + 7.34213212314224421j)
+    assert li(z).ae(2.28662658112562502 + 1.50427225297269364j)
+    assert si(z).ae(2.48122029237669054 + 0.12684703275254834j)
+    assert ci(z).ae(0.169255590269456633 - 0.892020751420780353j)
+    assert shi(z).ae(1.85810366559344468 + 3.66435842914920263j)
+    assert chi(z).ae(1.86787602931970484 + 3.67777369399304159j)
+    assert fresnels(z/3).ae(0.034534397197008182 + 0.754859844188218737j)
+    assert fresnelc(z/3).ae(1.261581645990027372 + 0.417949198775061893j)
+    assert airyai(z).ae(-0.0162552579839056062 - 0.0018045715700210556j)
+    assert airybi(z).ae(-4.98856113282883371 + 2.08558537872180623j)
+    assert li(0) == 0.0
+    assert li(1) == -inf
+    assert li(inf) == inf
+    assert isinstance(li(0.7), mpf)
+    assert si(inf).ae(pi/2)
+    assert si(-inf).ae(-pi/2)
+    assert ci(inf) == 0
+    assert ci(0) == -inf
+    assert isinstance(ei(-0.7), mpf)
+    assert airyai(inf) == 0
+    assert airybi(inf) == inf
+    assert airyai(-inf) == 0
+    assert airybi(-inf) == 0
+    assert fresnels(inf) == 0.5
+    assert fresnelc(inf) == 0.5
+    assert fresnels(-inf) == -0.5
+    assert fresnelc(-inf) == -0.5
+    assert shi(0) == 0
+    assert shi(inf) == inf
+    assert shi(-inf) == -inf
+    assert chi(0) == -inf
+    assert chi(inf) == inf
+
+def test_ei():
+    mp.dps = 15
+    assert ei(0) == -inf
+    assert ei(inf) == inf
+    assert ei(-inf) == -0.0
+    assert ei(20+70j).ae(6.1041351911152984397e6 - 2.7324109310519928872e6j)
+    # tests for the asymptotic expansion
+    # values checked with Mathematica ExpIntegralEi
+    mp.dps = 50
+    r = ei(20000)
+    s = '3.8781962825045010930273870085501819470698476975019e+8681'
+    assert str(r) == s
+    r = ei(-200)
+    s = '-6.8852261063076355977108174824557929738368086933303e-90'
+    assert str(r) == s
+    r =ei(20000 + 10*j)
+    sre = '-3.255138234032069402493850638874410725961401274106e+8681'
+    sim = '-2.1081929993474403520785942429469187647767369645423e+8681'
+    assert str(r.real) == sre and str(r.imag) == sim
+    mp.dps = 15
+    # More asymptotic expansions
+    assert chi(-10**6+100j).ae('1.3077239389562548386e+434288 + 7.6808956999707408158e+434287j')
+    assert shi(-10**6+100j).ae('-1.3077239389562548386e+434288 - 7.6808956999707408158e+434287j')
+    mp.dps = 15
+    assert ei(10j).ae(-0.0454564330044553726+3.2291439210137706686j)
+    assert ei(100j).ae(-0.0051488251426104921+3.1330217936839529126j)
+    u = ei(fmul(10**20, j, exact=True))
+    assert u.real.ae(-6.4525128526578084421345e-21, abs_eps=0, rel_eps=8*eps)
+    assert u.imag.ae(pi)
+    assert ei(-10j).ae(-0.0454564330044553726-3.2291439210137706686j)
+    assert ei(-100j).ae(-0.0051488251426104921-3.1330217936839529126j)
+    u = ei(fmul(-10**20, j, exact=True))
+    assert u.real.ae(-6.4525128526578084421345e-21, abs_eps=0, rel_eps=8*eps)
+    assert u.imag.ae(-pi)
+    assert ei(10+10j).ae(-1576.1504265768517448+436.9192317011328140j)
+    u = ei(-10+10j)
+    assert u.real.ae(7.6698978415553488362543e-7, abs_eps=0, rel_eps=8*eps)
+    assert u.imag.ae(3.141595611735621062025)
+
+def test_e1():
+    mp.dps = 15
+    assert e1(0) == inf
+    assert e1(inf) == 0
+    assert e1(-inf) == mpc(-inf, -pi)
+    assert e1(10j).ae(0.045456433004455372635 + 0.087551267423977430100j)
+    assert e1(100j).ae(0.0051488251426104921444 - 0.0085708599058403258790j)
+    assert e1(fmul(10**20, j, exact=True)).ae(6.4525128526578084421e-21 - 7.6397040444172830039e-21j, abs_eps=0, rel_eps=8*eps)
+    assert e1(-10j).ae(0.045456433004455372635 - 0.087551267423977430100j)
+    assert e1(-100j).ae(0.0051488251426104921444 + 0.0085708599058403258790j)
+    assert e1(fmul(-10**20, j, exact=True)).ae(6.4525128526578084421e-21 + 7.6397040444172830039e-21j, abs_eps=0, rel_eps=8*eps)
+
+def test_expint():
+    mp.dps = 15
+    assert expint(0,0) == inf
+    assert expint(0,1).ae(1/e)
+    assert expint(0,1.5).ae(2/exp(1.5)/3)
+    assert expint(1,1).ae(-ei(-1))
+    assert expint(2,0).ae(1)
+    assert expint(3,0).ae(1/2.)
+    assert expint(4,0).ae(1/3.)
+    assert expint(-2, 0.5).ae(26/sqrt(e))
+    assert expint(-1,-1) == 0
+    assert expint(-2,-1).ae(-e)
+    assert expint(5.5, 0).ae(2/9.)
+    assert expint(2.00000001,0).ae(100000000./100000001)
+    assert expint(2+3j,4-j).ae(0.0023461179581675065414+0.0020395540604713669262j)
+    assert expint('1.01', '1e-1000').ae(99.9999999899412802)
+    assert expint('1.000000000001', 3.5).ae(0.00697013985754701819446)
+    assert expint(2,3).ae(3*ei(-3)+exp(-3))
+    assert (expint(10,20)*10**10).ae(0.694439055541231353)
+    assert expint(3,inf) == 0
+    assert expint(3.2,inf) == 0
+    assert expint(3.2+2j,inf) == 0
+    assert expint(1,3j).ae(-0.11962978600800032763 + 0.27785620120457163717j)
+    assert expint(1,3).ae(0.013048381094197037413)
+    assert expint(1,-3).ae(-ei(3)-pi*j)
+    #assert expint(3) == expint(1,3)
+    assert expint(1,-20).ae(-25615652.66405658882 - 3.1415926535897932385j)
+    assert expint(1000000,0).ae(1./999999)
+    assert expint(0,2+3j).ae(-0.025019798357114678171 + 0.027980439405104419040j)
+    assert expint(-1,2+3j).ae(-0.022411973626262070419 + 0.038058922011377716932j)
+    assert expint(-1.5,0) == inf
+
+def test_trig_integrals():
+    mp.dps = 30
+    assert si(mpf(1)/1000000).ae('0.000000999999999999944444444444446111')
+    assert ci(mpf(1)/1000000).ae('-13.2382948930629912435014366276')
+    assert si(10**10).ae('1.5707963267075846569685111517747537')
+    assert ci(10**10).ae('-4.87506025174822653785729773959e-11')
+    assert si(10**100).ae(pi/2)
+    assert (ci(10**100)*10**100).ae('-0.372376123661276688262086695553')
+    assert si(-3) == -si(3)
+    assert ci(-3).ae(ci(3) + pi*j)
+    # Test complex structure
+    mp.dps = 15
+    assert mp.ci(50).ae(-0.0056283863241163054402)
+    assert mp.ci(50+2j).ae(-0.018378282946133067149+0.070352808023688336193j)
+    assert mp.ci(20j).ae(1.28078263320282943611e7+1.5707963267949j)
+    assert mp.ci(-2+20j).ae(-4.050116856873293505e6+1.207476188206989909e7j)
+    assert mp.ci(-50+2j).ae(-0.0183782829461330671+3.0712398455661049023j)
+    assert mp.ci(-50).ae(-0.0056283863241163054+3.1415926535897932385j)
+    assert mp.ci(-50-2j).ae(-0.0183782829461330671-3.0712398455661049023j)
+    assert mp.ci(-2-20j).ae(-4.050116856873293505e6-1.207476188206989909e7j)
+    assert mp.ci(-20j).ae(1.28078263320282943611e7-1.5707963267949j)
+    assert mp.ci(50-2j).ae(-0.018378282946133067149-0.070352808023688336193j)
+    assert mp.si(50).ae(1.5516170724859358947)
+    assert mp.si(50+2j).ae(1.497884414277228461-0.017515007378437448j)
+    assert mp.si(20j).ae(1.2807826332028294459e7j)
+    assert mp.si(-2+20j).ae(-1.20747603112735722103e7-4.050116856873293554e6j)
+    assert mp.si(-50+2j).ae(-1.497884414277228461-0.017515007378437448j)
+    assert mp.si(-50).ae(-1.5516170724859358947)
+    assert mp.si(-50-2j).ae(-1.497884414277228461+0.017515007378437448j)
+    assert mp.si(-2-20j).ae(-1.20747603112735722103e7+4.050116856873293554e6j)
+    assert mp.si(-20j).ae(-1.2807826332028294459e7j)
+    assert mp.si(50-2j).ae(1.497884414277228461+0.017515007378437448j)
+    assert mp.chi(50j).ae(-0.0056283863241163054+1.5707963267948966192j)
+    assert mp.chi(-2+50j).ae(-0.0183782829461330671+1.6411491348185849554j)
+    assert mp.chi(-20).ae(1.28078263320282943611e7+3.1415926535898j)
+    assert mp.chi(-20-2j).ae(-4.050116856873293505e6+1.20747571696809187053e7j)
+    assert mp.chi(-2-50j).ae(-0.0183782829461330671-1.6411491348185849554j)
+    assert mp.chi(-50j).ae(-0.0056283863241163054-1.5707963267948966192j)
+    assert mp.chi(2-50j).ae(-0.0183782829461330671-1.500443518771208283j)
+    assert mp.chi(20-2j).ae(-4.050116856873293505e6-1.20747603112735722951e7j)
+    assert mp.chi(20).ae(1.2807826332028294361e7)
+    assert mp.chi(2+50j).ae(-0.0183782829461330671+1.500443518771208283j)
+    assert mp.shi(50j).ae(1.5516170724859358947j)
+    assert mp.shi(-2+50j).ae(0.017515007378437448+1.497884414277228461j)
+    assert mp.shi(-20).ae(-1.2807826332028294459e7)
+    assert mp.shi(-20-2j).ae(4.050116856873293554e6-1.20747603112735722103e7j)
+    assert mp.shi(-2-50j).ae(0.017515007378437448-1.497884414277228461j)
+    assert mp.shi(-50j).ae(-1.5516170724859358947j)
+    assert mp.shi(2-50j).ae(-0.017515007378437448-1.497884414277228461j)
+    assert mp.shi(20-2j).ae(-4.050116856873293554e6-1.20747603112735722103e7j)
+    assert mp.shi(20).ae(1.2807826332028294459e7)
+    assert mp.shi(2+50j).ae(-0.017515007378437448+1.497884414277228461j)
+    def ae(x,y,tol=1e-12):
+        return abs(x-y) <= abs(y)*tol
+    assert fp.ci(fp.inf) == 0
+    assert ae(fp.ci(fp.ninf), fp.pi*1j)
+    assert ae(fp.si(fp.inf), fp.pi/2)
+    assert ae(fp.si(fp.ninf), -fp.pi/2)
+    assert fp.si(0) == 0
+    assert ae(fp.ci(50), -0.0056283863241163054402)
+    assert ae(fp.ci(50+2j), -0.018378282946133067149+0.070352808023688336193j)
+    assert ae(fp.ci(20j), 1.28078263320282943611e7+1.5707963267949j)
+    assert ae(fp.ci(-2+20j), -4.050116856873293505e6+1.207476188206989909e7j)
+    assert ae(fp.ci(-50+2j), -0.0183782829461330671+3.0712398455661049023j)
+    assert ae(fp.ci(-50), -0.0056283863241163054+3.1415926535897932385j)
+    assert ae(fp.ci(-50-2j), -0.0183782829461330671-3.0712398455661049023j)
+    assert ae(fp.ci(-2-20j), -4.050116856873293505e6-1.207476188206989909e7j)
+    assert ae(fp.ci(-20j), 1.28078263320282943611e7-1.5707963267949j)
+    assert ae(fp.ci(50-2j), -0.018378282946133067149-0.070352808023688336193j)
+    assert ae(fp.si(50), 1.5516170724859358947)
+    assert ae(fp.si(50+2j), 1.497884414277228461-0.017515007378437448j)
+    assert ae(fp.si(20j), 1.2807826332028294459e7j)
+    assert ae(fp.si(-2+20j), -1.20747603112735722103e7-4.050116856873293554e6j)
+    assert ae(fp.si(-50+2j), -1.497884414277228461-0.017515007378437448j)
+    assert ae(fp.si(-50), -1.5516170724859358947)
+    assert ae(fp.si(-50-2j), -1.497884414277228461+0.017515007378437448j)
+    assert ae(fp.si(-2-20j), -1.20747603112735722103e7+4.050116856873293554e6j)
+    assert ae(fp.si(-20j), -1.2807826332028294459e7j)
+    assert ae(fp.si(50-2j), 1.497884414277228461+0.017515007378437448j)
+    assert ae(fp.chi(50j), -0.0056283863241163054+1.5707963267948966192j)
+    assert ae(fp.chi(-2+50j), -0.0183782829461330671+1.6411491348185849554j)
+    assert ae(fp.chi(-20), 1.28078263320282943611e7+3.1415926535898j)
+    assert ae(fp.chi(-20-2j), -4.050116856873293505e6+1.20747571696809187053e7j)
+    assert ae(fp.chi(-2-50j), -0.0183782829461330671-1.6411491348185849554j)
+    assert ae(fp.chi(-50j), -0.0056283863241163054-1.5707963267948966192j)
+    assert ae(fp.chi(2-50j), -0.0183782829461330671-1.500443518771208283j)
+    assert ae(fp.chi(20-2j), -4.050116856873293505e6-1.20747603112735722951e7j)
+    assert ae(fp.chi(20), 1.2807826332028294361e7)
+    assert ae(fp.chi(2+50j), -0.0183782829461330671+1.500443518771208283j)
+    assert ae(fp.shi(50j), 1.5516170724859358947j)
+    assert ae(fp.shi(-2+50j), 0.017515007378437448+1.497884414277228461j)
+    assert ae(fp.shi(-20), -1.2807826332028294459e7)
+    assert ae(fp.shi(-20-2j), 4.050116856873293554e6-1.20747603112735722103e7j)
+    assert ae(fp.shi(-2-50j), 0.017515007378437448-1.497884414277228461j)
+    assert ae(fp.shi(-50j), -1.5516170724859358947j)
+    assert ae(fp.shi(2-50j), -0.017515007378437448-1.497884414277228461j)
+    assert ae(fp.shi(20-2j), -4.050116856873293554e6-1.20747603112735722103e7j)
+    assert ae(fp.shi(20), 1.2807826332028294459e7)
+    assert ae(fp.shi(2+50j), -0.017515007378437448+1.497884414277228461j)
+
+def test_airy():
+    mp.dps = 15
+    assert (airyai(10)*10**10).ae(1.1047532552898687)
+    assert (airybi(10)/10**9).ae(0.45564115354822515)
+    assert (airyai(1000)*10**9158).ae(9.306933063179556004)
+    assert (airybi(1000)/10**9154).ae(5.4077118391949465477)
+    assert airyai(-1000).ae(0.055971895773019918842)
+    assert airybi(-1000).ae(-0.083264574117080633012)
+    assert (airyai(100+100j)*10**188).ae(2.9099582462207032076 + 2.353013591706178756j)
+    assert (airybi(100+100j)/10**185).ae(1.7086751714463652039 - 3.1416590020830804578j)
+
+def test_hyper_0f1():
+    mp.dps = 15
+    v = 8.63911136507950465
+    assert hyper([],[(1,3)],1.5).ae(v)
+    assert hyper([],[1/3.],1.5).ae(v)
+    assert hyp0f1(1/3.,1.5).ae(v)
+    assert hyp0f1((1,3),1.5).ae(v)
+    # Asymptotic expansion
+    assert hyp0f1(3,1e9).ae('4.9679055380347771271e+27455')
+    assert hyp0f1(3,1e9j).ae('-2.1222788784457702157e+19410 + 5.0840597555401854116e+19410j')
+
+def test_hyper_1f1():
+    mp.dps = 15
+    v = 1.2917526488617656673
+    assert hyper([(1,2)],[(3,2)],0.7).ae(v)
+    assert hyper([(1,2)],[(3,2)],0.7+0j).ae(v)
+    assert hyper([0.5],[(3,2)],0.7).ae(v)
+    assert hyper([0.5],[1.5],0.7).ae(v)
+    assert hyper([0.5],[(3,2)],0.7+0j).ae(v)
+    assert hyper([0.5],[1.5],0.7+0j).ae(v)
+    assert hyper([(1,2)],[1.5+0j],0.7).ae(v)
+    assert hyper([0.5+0j],[1.5],0.7).ae(v)
+    assert hyper([0.5+0j],[1.5+0j],0.7+0j).ae(v)
+    assert hyp1f1(0.5,1.5,0.7).ae(v)
+    assert hyp1f1((1,2),1.5,0.7).ae(v)
+    # Asymptotic expansion
+    assert hyp1f1(2,3,1e10).ae('2.1555012157015796988e+4342944809')
+    assert (hyp1f1(2,3,1e10j)*10**10).ae(-0.97501205020039745852 - 1.7462392454512132074j)
+    # Shouldn't use asymptotic expansion
+    assert hyp1f1(-2, 1, 10000).ae(49980001)
+    # Bug
+    assert hyp1f1(1j,fraction(1,3),0.415-69.739j).ae(25.857588206024346592 + 15.738060264515292063j)
+
+def test_hyper_2f1():
+    mp.dps = 15
+    v = 1.0652207633823291032
+    assert hyper([(1,2), (3,4)], [2], 0.3).ae(v)
+    assert hyper([(1,2), 0.75], [2], 0.3).ae(v)
+    assert hyper([0.5, 0.75], [2.0], 0.3).ae(v)
+    assert hyper([0.5, 0.75], [2.0], 0.3+0j).ae(v)
+    assert hyper([0.5+0j, (3,4)], [2.0], 0.3+0j).ae(v)
+    assert hyper([0.5+0j, (3,4)], [2.0], 0.3).ae(v)
+    assert hyper([0.5, (3,4)], [2.0+0j], 0.3).ae(v)
+    assert hyper([0.5+0j, 0.75+0j], [2.0+0j], 0.3+0j).ae(v)
+    v = 1.09234681096223231717 + 0.18104859169479360380j
+    assert hyper([(1,2),0.75+j], [2], 0.5).ae(v)
+    assert hyper([0.5,0.75+j], [2.0], 0.5).ae(v)
+    assert hyper([0.5,0.75+j], [2.0], 0.5+0j).ae(v)
+    assert hyper([0.5,0.75+j], [2.0+0j], 0.5+0j).ae(v)
+    v = 0.9625 - 0.125j
+    assert hyper([(3,2),-1],[4], 0.1+j/3).ae(v)
+    assert hyper([1.5,-1.0],[4], 0.1+j/3).ae(v)
+    assert hyper([1.5,-1.0],[4+0j], 0.1+j/3).ae(v)
+    assert hyper([1.5+0j,-1.0+0j],[4+0j], 0.1+j/3).ae(v)
+    v = 1.02111069501693445001 - 0.50402252613466859521j
+    assert hyper([(2,10),(3,10)],[(4,10)],1.5).ae(v)
+    assert hyper([0.2,(3,10)],[0.4+0j],1.5).ae(v)
+    assert hyper([0.2,(3,10)],[0.4+0j],1.5+0j).ae(v)
+    v = 0.76922501362865848528 + 0.32640579593235886194j
+    assert hyper([(2,10),(3,10)],[(4,10)],4+2j).ae(v)
+    assert hyper([0.2,(3,10)],[0.4+0j],4+2j).ae(v)
+    assert hyper([0.2,(3,10)],[(4,10)],4+2j).ae(v)
+
+def test_hyper_2f1_hard():
+    mp.dps = 15
+    # Singular cases
+    assert hyp2f1(2,-1,-1,3).ae(7)
+    assert hyp2f1(2,-1,-1,3,eliminate_all=True).ae(0.25)
+    assert hyp2f1(2,-2,-2,3).ae(34)
+    assert hyp2f1(2,-2,-2,3,eliminate_all=True).ae(0.25)
+    assert hyp2f1(2,-2,-3,3) == 14
+    assert hyp2f1(2,-3,-2,3) == inf
+    assert hyp2f1(2,-1.5,-1.5,3) == 0.25
+    assert hyp2f1(1,2,3,0) == 1
+    assert hyp2f1(0,1,0,0) == 1
+    assert hyp2f1(0,0,0,0) == 1
+    assert isnan(hyp2f1(1,1,0,0))
+    assert hyp2f1(2,-1,-5, 0.25+0.25j).ae(1.1+0.1j)
+    assert hyp2f1(2,-5,-5, 0.25+0.25j, eliminate=False).ae(163./128 + 125./128*j)
+    assert hyp2f1(0.7235, -1, -5, 0.3).ae(1.04341)
+    assert hyp2f1(0.7235, -5, -5, 0.3, eliminate=False).ae(1.2939225017815903812)
+    assert hyp2f1(-1,-2,4,1) == 1.5
+    assert hyp2f1(1,2,-3,1) == inf
+    assert hyp2f1(-2,-2,1,1) == 6
+    assert hyp2f1(1,-2,-4,1).ae(5./3)
+    assert hyp2f1(0,-6,-4,1) == 1
+    assert hyp2f1(0,-3,-4,1) == 1
+    assert hyp2f1(0,0,0,1) == 1
+    assert hyp2f1(1,0,0,1,eliminate=False) == 1
+    assert hyp2f1(1,1,0,1) == inf
+    assert hyp2f1(1,-6,-4,1) == inf
+    assert hyp2f1(-7.2,-0.5,-4.5,1) == 0
+    assert hyp2f1(-7.2,-1,-2,1).ae(-2.6)
+    assert hyp2f1(1,-0.5,-4.5, 1) == inf
+    assert hyp2f1(1,0.5,-4.5, 1) == -inf
+    # Check evaluation on / close to unit circle
+    z = exp(j*pi/3)
+    w = (nthroot(2,3)+1)*exp(j*pi/12)/nthroot(3,4)**3
+    assert hyp2f1('1/2','1/6','1/3', z).ae(w)
+    assert hyp2f1('1/2','1/6','1/3', z.conjugate()).ae(w.conjugate())
+    assert hyp2f1(0.25, (1,3), 2, '0.999').ae(1.06826449496030635)
+    assert hyp2f1(0.25, (1,3), 2, '1.001').ae(1.06867299254830309446-0.00001446586793975874j)
+    assert hyp2f1(0.25, (1,3), 2, -1).ae(0.96656584492524351673)
+    assert hyp2f1(0.25, (1,3), 2, j).ae(0.99041766248982072266+0.03777135604180735522j)
+    assert hyp2f1(2,3,5,'0.99').ae(27.699347904322690602)
+    assert hyp2f1((3,2),-0.5,3,'0.99').ae(0.68403036843911661388)
+    assert hyp2f1(2,3,5,1j).ae(0.37290667145974386127+0.59210004902748285917j)
+    assert fsum([hyp2f1((7,10),(2,3),(-1,2), 0.95*exp(j*k)) for k in range(1,15)]).ae(52.851400204289452922+6.244285013912953225j)
+    assert fsum([hyp2f1((7,10),(2,3),(-1,2), 1.05*exp(j*k)) for k in range(1,15)]).ae(54.506013786220655330-3.000118813413217097j)
+    assert fsum([hyp2f1((7,10),(2,3),(-1,2), exp(j*k)) for k in range(1,15)]).ae(55.792077935955314887+1.731986485778500241j)
+    assert hyp2f1(2,2.5,-3.25,0.999).ae(218373932801217082543180041.33)
+    # Branches
+    assert hyp2f1(1,1,2,1.01).ae(4.5595744415723676911-3.1104877758314784539j)
+    assert hyp2f1(1,1,2,1.01+0.1j).ae(2.4149427480552782484+1.4148224796836938829j)
+    assert hyp2f1(1,1,2,3+4j).ae(0.14576709331407297807+0.48379185417980360773j)
+    assert hyp2f1(1,1,2,4).ae(-0.27465307216702742285 - 0.78539816339744830962j)
+    assert hyp2f1(1,1,2,-4).ae(0.40235947810852509365)
+    # Other:
+    # Cancellation with a large parameter involved (bug reported on sage-devel)
+    assert hyp2f1(112, (51,10), (-9,10), -0.99999).ae(-1.6241361047970862961e-24, abs_eps=0, rel_eps=eps*16)
+
+def test_hyper_3f2_etc():
+    assert hyper([1,2,3],[1.5,8],-1).ae(0.67108992351533333030)
+    assert hyper([1,2,3,4],[5,6,7], -1).ae(0.90232988035425506008)
+    assert hyper([1,2,3],[1.25,5], 1).ae(28.924181329701905701)
+    assert hyper([1,2,3,4],[5,6,7],5).ae(1.5192307344006649499-1.1529845225075537461j)
+    assert hyper([1,2,3,4,5],[6,7,8,9],-1).ae(0.96288759462882357253)
+    assert hyper([1,2,3,4,5],[6,7,8,9],1).ae(1.0428697385885855841)
+    assert hyper([1,2,3,4,5],[6,7,8,9],5).ae(1.33980653631074769423-0.07143405251029226699j)
+    assert hyper([1,2.79,3.08,4.37],[5.2,6.1,7.3],5).ae(1.0996321464692607231-1.7748052293979985001j)
+    assert hyper([1,1,1],[1,2],1) == inf
+    assert hyper([1,1,1],[2,(101,100)],1).ae(100.01621213528313220)
+    # slow -- covered by doctests
+    #assert hyper([1,1,1],[2,3],0.9999).ae(1.2897972005319693905)
+
+def test_hyper_u():
+    mp.dps = 15
+    assert hyperu(2,-3,0).ae(0.05)
+    assert hyperu(2,-3.5,0).ae(4./99)
+    assert hyperu(2,0,0) == 0.5
+    assert hyperu(-5,1,0) == -120
+    assert hyperu(-5,2,0) == inf
+    assert hyperu(-5,-2,0) == 0
+    assert hyperu(7,7,3).ae(0.00014681269365593503986)  #exp(3)*gammainc(-6,3)
+    assert hyperu(2,-3,4).ae(0.011836478100271995559)
+    assert hyperu(3,4,5).ae(1./125)
+    assert hyperu(2,3,0.0625) == 256
+    assert hyperu(-1,2,0.25+0.5j) == -1.75+0.5j
+    assert hyperu(0.5,1.5,7.25).ae(2/sqrt(29))
+    assert hyperu(2,6,pi).ae(0.55804439825913399130)
+    assert (hyperu((3,2),8,100+201j)*10**4).ae(-0.3797318333856738798 - 2.9974928453561707782j)
+    assert (hyperu((5,2),(-1,2),-5000)*10**10).ae(-5.6681877926881664678j)
+    # XXX: fails because of undetected cancellation in low level series code
+    # Alternatively: could use asymptotic series here, if convergence test
+    # tweaked back to recognize this one
+    #assert (hyperu((5,2),(-1,2),-500)*10**7).ae(-1.82526906001593252847j)
+
+def test_hyper_2f0():
+    mp.dps = 15
+    assert hyper([1,2],[],3) == hyp2f0(1,2,3)
+    assert hyp2f0(2,3,7).ae(0.0116108068639728714668 - 0.0073727413865865802130j)
+    assert hyp2f0(2,3,0) == 1
+    assert hyp2f0(0,0,0) == 1
+    assert hyp2f0(-1,-1,1).ae(2)
+    assert hyp2f0(-4,1,1.5).ae(62.5)
+    assert hyp2f0(-4,1,50).ae(147029801)
+    assert hyp2f0(-4,1,0.0001).ae(0.99960011997600240000)
+    assert hyp2f0(0.5,0.25,0.001).ae(1.0001251174078538115)
+    assert hyp2f0(0.5,0.25,3+4j).ae(0.85548875824755163518 + 0.21636041283392292973j)
+    # Important: cancellation check
+    assert hyp2f0((1,6),(5,6),-0.02371708245126284498).ae(0.996785723120804309)
+    # Should be exact; polynomial case
+    assert hyp2f0(-2,1,0.5+0.5j,zeroprec=200) == 0
+    assert hyp2f0(1,-2,0.5+0.5j,zeroprec=200) == 0
+    # There used to be a bug in thresholds that made one of the following hang
+    for d in [15, 50, 80]:
+        mp.dps = d
+        assert hyp2f0(1.5, 0.5, 0.009).ae('1.006867007239309717945323585695344927904000945829843527398772456281301440034218290443367270629519483 + 1.238277162240704919639384945859073461954721356062919829456053965502443570466701567100438048602352623e-46j')
+
+def test_hyper_1f2():
+    mp.dps = 15
+    assert hyper([1],[2,3],4) == hyp1f2(1,2,3,4)
+    a1,b1,b2 = (1,10),(2,3),1./16
+    assert hyp1f2(a1,b1,b2,10).ae(298.7482725554557568)
+    assert hyp1f2(a1,b1,b2,100).ae(224128961.48602947604)
+    assert hyp1f2(a1,b1,b2,1000).ae(1.1669528298622675109e+27)
+    assert hyp1f2(a1,b1,b2,10000).ae(2.4780514622487212192e+86)
+    assert hyp1f2(a1,b1,b2,100000).ae(1.3885391458871523997e+274)
+    assert hyp1f2(a1,b1,b2,1000000).ae('9.8851796978960318255e+867')
+    assert hyp1f2(a1,b1,b2,10**7).ae('1.1505659189516303646e+2746')
+    assert hyp1f2(a1,b1,b2,10**8).ae('1.4672005404314334081e+8685')
+    assert hyp1f2(a1,b1,b2,10**20).ae('3.6888217332150976493e+8685889636')
+    assert hyp1f2(a1,b1,b2,10*j).ae(-16.163252524618572878 - 44.321567896480184312j)
+    assert hyp1f2(a1,b1,b2,100*j).ae(61938.155294517848171 + 637349.45215942348739j)
+    assert hyp1f2(a1,b1,b2,1000*j).ae(8455057657257695958.7 + 6261969266997571510.6j)
+    assert hyp1f2(a1,b1,b2,10000*j).ae(-8.9771211184008593089e+60 + 4.6550528111731631456e+59j)
+    assert hyp1f2(a1,b1,b2,100000*j).ae(2.6398091437239324225e+193 + 4.1658080666870618332e+193j)
+    assert hyp1f2(a1,b1,b2,1000000*j).ae('3.5999042951925965458e+613 + 1.5026014707128947992e+613j')
+    assert hyp1f2(a1,b1,b2,10**7*j).ae('-8.3208715051623234801e+1939 - 3.6752883490851869429e+1941j')
+    assert hyp1f2(a1,b1,b2,10**8*j).ae('2.0724195707891484454e+6140 - 1.3276619482724266387e+6141j')
+    assert hyp1f2(a1,b1,b2,10**20*j).ae('-1.1734497974795488504e+6141851462 + 1.1498106965385471542e+6141851462j')
+
+def test_hyper_2f3():
+    mp.dps = 15
+    assert hyper([1,2],[3,4,5],6) == hyp2f3(1,2,3,4,5,6)
+    a1,a2,b1,b2,b3 = (1,10),(2,3),(3,10), 2, 1./16
+    # Check asymptotic expansion
+    assert hyp2f3(a1,a2,b1,b2,b3,10).ae(128.98207160698659976)
+    assert hyp2f3(a1,a2,b1,b2,b3,1000).ae(6.6309632883131273141e25)
+    assert hyp2f3(a1,a2,b1,b2,b3,10000).ae(4.6863639362713340539e84)
+    assert hyp2f3(a1,a2,b1,b2,b3,100000).ae(8.6632451236103084119e271)
+    assert hyp2f3(a1,a2,b1,b2,b3,10**6).ae('2.0291718386574980641e865')
+    assert hyp2f3(a1,a2,b1,b2,b3,10**7).ae('7.7639836665710030977e2742')
+    assert hyp2f3(a1,a2,b1,b2,b3,10**8).ae('3.2537462584071268759e8681')
+    assert hyp2f3(a1,a2,b1,b2,b3,10**20).ae('1.2966030542911614163e+8685889627')
+    assert hyp2f3(a1,a2,b1,b2,b3,10*j).ae(-18.551602185587547854 - 13.348031097874113552j)
+    assert hyp2f3(a1,a2,b1,b2,b3,100*j).ae(78634.359124504488695 + 74459.535945281973996j)
+    assert hyp2f3(a1,a2,b1,b2,b3,1000*j).ae(597682550276527901.59 - 65136194809352613.078j)
+    assert hyp2f3(a1,a2,b1,b2,b3,10000*j).ae(-1.1779696326238582496e+59 + 1.2297607505213133872e+59j)
+    assert hyp2f3(a1,a2,b1,b2,b3,100000*j).ae(2.9844228969804380301e+191 + 7.5587163231490273296e+190j)
+    assert hyp2f3(a1,a2,b1,b2,b3,1000000*j).ae('7.4859161049322370311e+610 - 2.8467477015940090189e+610j')
+    assert hyp2f3(a1,a2,b1,b2,b3,10**7*j).ae('-1.7477645579418800826e+1938 - 1.7606522995808116405e+1938j')
+    assert hyp2f3(a1,a2,b1,b2,b3,10**8*j).ae('-1.6932731942958401784e+6137 - 2.4521909113114629368e+6137j')
+    assert hyp2f3(a1,a2,b1,b2,b3,10**20*j).ae('-2.0988815677627225449e+6141851451 + 5.7708223542739208681e+6141851452j')
+
+def test_hyper_2f2():
+    mp.dps = 15
+    assert hyper([1,2],[3,4],5) == hyp2f2(1,2,3,4,5)
+    a1,a2,b1,b2 = (3,10),4,(1,2),1./16
+    assert hyp2f2(a1,a2,b1,b2,10).ae(448225936.3377556696)
+    assert hyp2f2(a1,a2,b1,b2,10000).ae('1.2012553712966636711e+4358')
+    assert hyp2f2(a1,a2,b1,b2,-20000).ae(-0.04182343755661214626)
+    assert hyp2f2(a1,a2,b1,b2,10**20).ae('1.1148680024303263661e+43429448190325182840')
+
+def test_orthpoly():
+    mp.dps = 15
+    assert jacobi(-4,2,3,0.7).ae(22800./4913)
+    assert jacobi(3,2,4,5.5) == 4133.125
+    assert jacobi(1.5,5/6.,4,0).ae(-1.0851951434075508417)
+    assert jacobi(-2, 1, 2, 4).ae(-0.16)
+    assert jacobi(2, -1, 2.5, 4).ae(34.59375)
+    #assert jacobi(2, -1, 2, 4) == 28.5
+    assert legendre(5, 7) == 129367
+    assert legendre(0.5,0).ae(0.53935260118837935667)
+    assert legendre(-1,-1) == 1
+    assert legendre(0,-1) == 1
+    assert legendre(0, 1) == 1
+    assert legendre(1, -1) == -1
+    assert legendre(7, 1) == 1
+    assert legendre(7, -1) == -1
+    assert legendre(8,1.5).ae(15457523./32768)
+    assert legendre(j,-j).ae(2.4448182735671431011 + 0.6928881737669934843j)
+    assert chebyu(5,1) == 6
+    assert chebyt(3,2) == 26
+    assert legendre(3.5,-1) == inf
+    assert legendre(4.5,-1) == -inf
+    assert legendre(3.5+1j,-1) == mpc(inf,inf)
+    assert legendre(4.5+1j,-1) == mpc(-inf,-inf)
+    assert laguerre(4, -2, 3).ae(-1.125)
+    assert laguerre(3, 1+j, 0.5).ae(0.2291666666666666667 + 2.5416666666666666667j)
+
+def test_hermite():
+    mp.dps = 15
+    assert hermite(-2, 0).ae(0.5)
+    assert hermite(-1, 0).ae(0.88622692545275801365)
+    assert hermite(0, 0).ae(1)
+    assert hermite(1, 0) == 0
+    assert hermite(2, 0).ae(-2)
+    assert hermite(0, 2).ae(1)
+    assert hermite(1, 2).ae(4)
+    assert hermite(1, -2).ae(-4)
+    assert hermite(2, -2).ae(14)
+    assert hermite(0.5, 0).ae(0.69136733903629335053)
+    assert hermite(9, 0) == 0
+    assert hermite(4,4).ae(3340)
+    assert hermite(3,4).ae(464)
+    assert hermite(-4,4).ae(0.00018623860287512396181)
+    assert hermite(-3,4).ae(0.0016540169879668766270)
+    assert hermite(9, 2.5j).ae(13638725j)
+    assert hermite(9, -2.5j).ae(-13638725j)
+    assert hermite(9, 100).ae(511078883759363024000)
+    assert hermite(9, -100).ae(-511078883759363024000)
+    assert hermite(9, 100j).ae(512922083920643024000j)
+    assert hermite(9, -100j).ae(-512922083920643024000j)
+    assert hermite(-9.5, 2.5j).ae(-2.9004951258126778174e-6 + 1.7601372934039951100e-6j)
+    assert hermite(-9.5, -2.5j).ae(-2.9004951258126778174e-6 - 1.7601372934039951100e-6j)
+    assert hermite(-9.5, 100).ae(1.3776300722767084162e-22, abs_eps=0, rel_eps=eps)
+    assert hermite(-9.5, -100).ae('1.3106082028470671626e4355')
+    assert hermite(-9.5, 100j).ae(-9.7900218581864768430e-23 - 9.7900218581864768430e-23j, abs_eps=0, rel_eps=eps)
+    assert hermite(-9.5, -100j).ae(-9.7900218581864768430e-23 + 9.7900218581864768430e-23j, abs_eps=0, rel_eps=eps)
+    assert hermite(2+3j, -1-j).ae(851.3677063883687676 - 1496.4373467871007997j)
+
+def test_gegenbauer():
+    mp.dps = 15
+    assert gegenbauer(1,2,3).ae(12)
+    assert gegenbauer(2,3,4).ae(381)
+    assert gegenbauer(0,0,0) == 0
+    assert gegenbauer(2,-1,3) == 0
+    assert gegenbauer(-7, 0.5, 3).ae(8989)
+    assert gegenbauer(1, -0.5, 3).ae(-3)
+    assert gegenbauer(1, -1.5, 3).ae(-9)
+    assert gegenbauer(1, -0.5, 3).ae(-3)
+    assert gegenbauer(-0.5, -0.5, 3).ae(-2.6383553159023906245)
+    assert gegenbauer(2+3j, 1-j, 3+4j).ae(14.880536623203696780 + 20.022029711598032898j)
+    #assert gegenbauer(-2, -0.5, 3).ae(-12)
+
+def test_legenp():
+    mp.dps = 15
+    assert legenp(2,0,4) == legendre(2,4)
+    assert legenp(-2, -1, 0.5).ae(0.43301270189221932338)
+    assert legenp(-2, -1, 0.5, type=3).ae(0.43301270189221932338j)
+    assert legenp(-2, 1, 0.5).ae(-0.86602540378443864676)
+    assert legenp(2+j, 3+4j, -j).ae(134742.98773236786148 + 429782.72924463851745j)
+    assert legenp(2+j, 3+4j, -j, type=3).ae(802.59463394152268507 - 251.62481308942906447j)
+    assert legenp(2,4,3).ae(0)
+    assert legenp(2,4,3,type=3).ae(0)
+    assert legenp(2,1,0.5).ae(-1.2990381056766579701)
+    assert legenp(2,1,0.5,type=3).ae(1.2990381056766579701j)
+    assert legenp(3,2,3).ae(-360)
+    assert legenp(3,3,3).ae(240j*2**0.5)
+    assert legenp(3,4,3).ae(0)
+    assert legenp(0,0.5,2).ae(0.52503756790433198939 - 0.52503756790433198939j)
+    assert legenp(-1,-0.5,2).ae(0.60626116232846498110 + 0.60626116232846498110j)
+    assert legenp(-2,0.5,2).ae(1.5751127037129959682 - 1.5751127037129959682j)
+    assert legenp(-2,0.5,-0.5).ae(-0.85738275810499171286)
+
+def test_legenq():
+    mp.dps = 15
+    f = legenq
+    # Evaluation at poles
+    assert isnan(f(3,2,1))
+    assert isnan(f(3,2,-1))
+    assert isnan(f(3,2,1,type=3))
+    assert isnan(f(3,2,-1,type=3))
+    # Evaluation at 0
+    assert f(0,1,0,type=2).ae(-1)
+    assert f(-2,2,0,type=2,zeroprec=200).ae(0)
+    assert f(1.5,3,0,type=2).ae(-2.2239343475841951023)
+    assert f(0,1,0,type=3).ae(j)
+    assert f(-2,2,0,type=3,zeroprec=200).ae(0)
+    assert f(1.5,3,0,type=3).ae(2.2239343475841951022*(1-1j))
+    # Standard case, degree 0
+    assert f(0,0,-1.5).ae(-0.8047189562170501873 + 1.5707963267948966192j)
+    assert f(0,0,-0.5).ae(-0.54930614433405484570)
+    assert f(0,0,0,zeroprec=200).ae(0)
+    assert f(0,0,0.5).ae(0.54930614433405484570)
+    assert f(0,0,1.5).ae(0.8047189562170501873 - 1.5707963267948966192j)
+    assert f(0,0,-1.5,type=3).ae(-0.80471895621705018730)
+    assert f(0,0,-0.5,type=3).ae(-0.5493061443340548457 - 1.5707963267948966192j)
+    assert f(0,0,0,type=3).ae(-1.5707963267948966192j)
+    assert f(0,0,0.5,type=3).ae(0.5493061443340548457 - 1.5707963267948966192j)
+    assert f(0,0,1.5,type=3).ae(0.80471895621705018730)
+    # Standard case, degree 1
+    assert f(1,0,-1.5).ae(0.2070784343255752810 - 2.3561944901923449288j)
+    assert f(1,0,-0.5).ae(-0.72534692783297257715)
+    assert f(1,0,0).ae(-1)
+    assert f(1,0,0.5).ae(-0.72534692783297257715)
+    assert f(1,0,1.5).ae(0.2070784343255752810 - 2.3561944901923449288j)
+    # Standard case, degree 2
+    assert f(2,0,-1.5).ae(-0.0635669991240192885 + 4.5160394395353277803j)
+    assert f(2,0,-0.5).ae(0.81866326804175685571)
+    assert f(2,0,0,zeroprec=200).ae(0)
+    assert f(2,0,0.5).ae(-0.81866326804175685571)
+    assert f(2,0,1.5).ae(0.0635669991240192885 - 4.5160394395353277803j)
+    # Misc orders and degrees
+    assert f(2,3,1.5,type=2).ae(-5.7243340223994616228j)
+    assert f(2,3,1.5,type=3).ae(-5.7243340223994616228)
+    assert f(2,3,0.5,type=2).ae(-12.316805742712016310)
+    assert f(2,3,0.5,type=3).ae(-12.316805742712016310j)
+    assert f(2,3,-1.5,type=2).ae(-5.7243340223994616228j)
+    assert f(2,3,-1.5,type=3).ae(5.7243340223994616228)
+    assert f(2,3,-0.5,type=2).ae(-12.316805742712016310)
+    assert f(2,3,-0.5,type=3).ae(-12.316805742712016310j)
+    assert f(2+3j, 3+4j, 0.5, type=3).ae(0.0016119404873235186807 - 0.0005885900510718119836j)
+    assert f(2+3j, 3+4j, -1.5, type=3).ae(0.008451400254138808670 + 0.020645193304593235298j)
+    assert f(-2.5,1,-1.5).ae(3.9553395527435335749j)
+    assert f(-2.5,1,-0.5).ae(1.9290561746445456908)
+    assert f(-2.5,1,0).ae(1.2708196271909686299)
+    assert f(-2.5,1,0.5).ae(-0.31584812990742202869)
+    assert f(-2.5,1,1.5).ae(-3.9553395527435335742 + 0.2993235655044701706j)
+    assert f(-2.5,1,-1.5,type=3).ae(0.29932356550447017254j)
+    assert f(-2.5,1,-0.5,type=3).ae(-0.3158481299074220287 - 1.9290561746445456908j)
+    assert f(-2.5,1,0,type=3).ae(1.2708196271909686292 - 1.2708196271909686299j)
+    assert f(-2.5,1,0.5,type=3).ae(1.9290561746445456907 + 0.3158481299074220287j)
+    assert f(-2.5,1,1.5,type=3).ae(-0.29932356550447017254)
+
+def test_agm():
+    mp.dps = 15
+    assert agm(0,0) == 0
+    assert agm(0,1) == 0
+    assert agm(1,1) == 1
+    assert agm(7,7) == 7
+    assert agm(j,j) == j
+    assert (1/agm(1,sqrt(2))).ae(0.834626841674073186)
+    assert agm(1,2).ae(1.4567910310469068692)
+    assert agm(1,3).ae(1.8636167832448965424)
+    assert agm(1,j).ae(0.599070117367796104+0.599070117367796104j)
+    assert agm(2) == agm(1,2)
+    assert agm(-3,4).ae(0.63468509766550907+1.3443087080896272j)
+
+def test_gammainc():
+    mp.dps = 15
+    assert gammainc(2,5).ae(6*exp(-5))
+    assert gammainc(2,0,5).ae(1-6*exp(-5))
+    assert gammainc(2,3,5).ae(-6*exp(-5)+4*exp(-3))
+    assert gammainc(-2.5,-0.5).ae(-0.9453087204829418812-5.3164237738936178621j)
+    assert gammainc(0,2,4).ae(0.045121158298212213088)
+    assert gammainc(0,3).ae(0.013048381094197037413)
+    assert gammainc(0,2+j,1-j).ae(0.00910653685850304839-0.22378752918074432574j)
+    assert gammainc(0,1-j).ae(0.00028162445198141833+0.17932453503935894015j)
+    assert gammainc(3,4,5,True).ae(0.11345128607046320253)
+    assert gammainc(3.5,0,inf).ae(gamma(3.5))
+    assert gammainc(-150.5,500).ae('6.9825435345798951153e-627')
+    assert gammainc(-150.5,800).ae('4.6885137549474089431e-788')
+    assert gammainc(-3.5, -20.5).ae(0.27008820585226911 - 1310.31447140574997636j)
+    assert gammainc(-3.5, -200.5).ae(0.27008820585226911 - 5.3264597096208368435e76j) # XXX real part
+    assert gammainc(0,0,2) == inf
+    assert gammainc(1,b=1).ae(0.6321205588285576784)
+    assert gammainc(3,2,2) == 0
+    assert gammainc(2,3+j,3-j).ae(-0.28135485191849314194j)
+    assert gammainc(4+0j,1).ae(5.8860710587430771455)
+    # GH issue #301
+    assert gammainc(-1,-1).ae(-0.8231640121031084799 + 3.1415926535897932385j)
+    assert gammainc(-2,-1).ae(1.7707229202810768576 - 1.5707963267948966192j)
+    assert gammainc(-3,-1).ae(-1.4963349162467073643 + 0.5235987755982988731j)
+    assert gammainc(-4,-1).ae(1.05365418617643814992 - 0.13089969389957471827j)
+    # Regularized upper gamma
+    assert isnan(gammainc(0, 0, regularized=True))
+    assert gammainc(-1, 0, regularized=True) == inf
+    assert gammainc(1, 0, regularized=True) == 1
+    assert gammainc(0, 5, regularized=True) == 0
+    assert gammainc(0, 2+3j, regularized=True) == 0
+    assert gammainc(0, 5000, regularized=True) == 0
+    assert gammainc(0, 10**30, regularized=True) == 0
+    assert gammainc(-1, 5, regularized=True) == 0
+    assert gammainc(-1, 5000, regularized=True) == 0
+    assert gammainc(-1, 10**30, regularized=True) == 0
+    assert gammainc(-1, -5, regularized=True) == 0
+    assert gammainc(-1, -5000, regularized=True) == 0
+    assert gammainc(-1, -10**30, regularized=True) == 0
+    assert gammainc(-1, 3+4j, regularized=True) == 0
+    assert gammainc(1, 5, regularized=True).ae(exp(-5))
+    assert gammainc(1, 5000, regularized=True).ae(exp(-5000))
+    assert gammainc(1, 10**30, regularized=True).ae(exp(-10**30))
+    assert gammainc(1, 3+4j, regularized=True).ae(exp(-3-4j))
+    assert gammainc(-1000000,2).ae('1.3669297209397347754e-301037', abs_eps=0, rel_eps=8*eps)
+    assert gammainc(-1000000,2,regularized=True) == 0
+    assert gammainc(-1000000,3+4j).ae('-1.322575609404222361e-698979 - 4.9274570591854533273e-698978j', abs_eps=0, rel_eps=8*eps)
+    assert gammainc(-1000000,3+4j,regularized=True) == 0
+    assert gammainc(2+3j, 4+5j, regularized=True).ae(0.085422013530993285774-0.052595379150390078503j)
+    assert gammainc(1000j, 1000j, regularized=True).ae(0.49702647628921131761 + 0.00297355675013575341j)
+    # Generalized
+    assert gammainc(3,4,2) == -gammainc(3,2,4)
+    assert gammainc(4, 2, 3).ae(1.2593494302978947396)
+    assert gammainc(4, 2, 3, regularized=True).ae(0.20989157171631578993)
+    assert gammainc(0, 2, 3).ae(0.035852129613864082155)
+    assert gammainc(0, 2, 3, regularized=True) == 0
+    assert gammainc(-1, 2, 3).ae(0.015219822548487616132)
+    assert gammainc(-1, 2, 3, regularized=True) == 0
+    assert gammainc(0, 2, 3).ae(0.035852129613864082155)
+    assert gammainc(0, 2, 3, regularized=True) == 0
+    # Should use upper gammas
+    assert gammainc(5, 10000, 12000).ae('1.1359381951461801687e-4327', abs_eps=0, rel_eps=8*eps)
+    # Should use lower gammas
+    assert gammainc(10000, 2, 3).ae('8.1244514125995785934e4765')
+    # GH issue 306
+    assert gammainc(3,-1-1j) == 0
+    assert gammainc(3,-1+1j) == 0
+    assert gammainc(2,-1) == 0
+    assert gammainc(2,-1+0j) == 0
+    assert gammainc(2+0j,-1) == 0
+
+def test_gammainc_expint_n():
+    # These tests are intended to check all cases of the low-level code
+    # for upper gamma and expint with small integer index.
+    # Need to cover positive/negative arguments; small/large/huge arguments
+    # for both positive and negative indices, as well as indices 0 and 1
+    # which may be special-cased
+    mp.dps = 15
+    assert expint(-3,3.5).ae(0.021456366563296693987)
+    assert expint(-2,3.5).ae(0.014966633183073309405)
+    assert expint(-1,3.5).ae(0.011092916359219041088)
+    assert expint(0,3.5).ae(0.0086278238349481430685)
+    assert expint(1,3.5).ae(0.0069701398575483929193)
+    assert expint(2,3.5).ae(0.0058018939208991255223)
+    assert expint(3,3.5).ae(0.0049453773495857807058)
+    assert expint(-3,-3.5).ae(-4.6618170604073311319)
+    assert expint(-2,-3.5).ae(-5.5996974157555515963)
+    assert expint(-1,-3.5).ae(-6.7582555017739415818)
+    assert expint(0,-3.5).ae(-9.4615577024835182145)
+    assert expint(1,-3.5).ae(-13.925353995152335292 - 3.1415926535897932385j)
+    assert expint(2,-3.5).ae(-15.62328702434085977 - 10.995574287564276335j)
+    assert expint(3,-3.5).ae(-10.783026313250347722 - 19.242255003237483586j)
+    assert expint(-3,350).ae(2.8614825451252838069e-155, abs_eps=0, rel_eps=8*eps)
+    assert expint(-2,350).ae(2.8532837224504675901e-155, abs_eps=0, rel_eps=8*eps)
+    assert expint(-1,350).ae(2.8451316155828634555e-155, abs_eps=0, rel_eps=8*eps)
+    assert expint(0,350).ae(2.8370258275042797989e-155, abs_eps=0, rel_eps=8*eps)
+    assert expint(1,350).ae(2.8289659656701459404e-155, abs_eps=0, rel_eps=8*eps)
+    assert expint(2,350).ae(2.8209516419468505006e-155, abs_eps=0, rel_eps=8*eps)
+    assert expint(3,350).ae(2.8129824725501272171e-155, abs_eps=0, rel_eps=8*eps)
+    assert expint(-3,-350).ae(-2.8528796154044839443e+149)
+    assert expint(-2,-350).ae(-2.8610072121701264351e+149)
+    assert expint(-1,-350).ae(-2.8691813842677537647e+149)
+    assert expint(0,-350).ae(-2.8774025343659421709e+149)
+    u = expint(1,-350)
+    assert u.ae(-2.8856710698020863568e+149)
+    assert u.imag.ae(-3.1415926535897932385)
+    u = expint(2,-350)
+    assert u.ae(-2.8939874026504650534e+149)
+    assert u.imag.ae(-1099.5574287564276335)
+    u = expint(3,-350)
+    assert u.ae(-2.9023519497915044349e+149)
+    assert u.imag.ae(-192422.55003237483586)
+    assert expint(-3,350000000000000000000000).ae('2.1592908471792544286e-152003068666138139677919', abs_eps=0, rel_eps=8*eps)
+    assert expint(-2,350000000000000000000000).ae('2.1592908471792544286e-152003068666138139677919', abs_eps=0, rel_eps=8*eps)
+    assert expint(-1,350000000000000000000000).ae('2.1592908471792544286e-152003068666138139677919', abs_eps=0, rel_eps=8*eps)
+    assert expint(0,350000000000000000000000).ae('2.1592908471792544286e-152003068666138139677919', abs_eps=0, rel_eps=8*eps)
+    assert expint(1,350000000000000000000000).ae('2.1592908471792544286e-152003068666138139677919', abs_eps=0, rel_eps=8*eps)
+    assert expint(2,350000000000000000000000).ae('2.1592908471792544286e-152003068666138139677919', abs_eps=0, rel_eps=8*eps)
+    assert expint(3,350000000000000000000000).ae('2.1592908471792544286e-152003068666138139677919', abs_eps=0, rel_eps=8*eps)
+    assert expint(-3,-350000000000000000000000).ae('-3.7805306852415755699e+152003068666138139677871')
+    assert expint(-2,-350000000000000000000000).ae('-3.7805306852415755699e+152003068666138139677871')
+    assert expint(-1,-350000000000000000000000).ae('-3.7805306852415755699e+152003068666138139677871')
+    assert expint(0,-350000000000000000000000).ae('-3.7805306852415755699e+152003068666138139677871')
+    u = expint(1,-350000000000000000000000)
+    assert u.ae('-3.7805306852415755699e+152003068666138139677871')
+    assert u.imag.ae(-3.1415926535897932385)
+    u = expint(2,-350000000000000000000000)
+    assert u.imag.ae(-1.0995574287564276335e+24)
+    assert u.ae('-3.7805306852415755699e+152003068666138139677871')
+    u = expint(3,-350000000000000000000000)
+    assert u.imag.ae(-1.9242255003237483586e+47)
+    assert u.ae('-3.7805306852415755699e+152003068666138139677871')
+    # Small case; no branch cut
+    assert gammainc(-3,3.5).ae(0.00010020262545203707109)
+    assert gammainc(-2,3.5).ae(0.00040370427343557393517)
+    assert gammainc(-1,3.5).ae(0.0016576839773997501492)
+    assert gammainc(0,3.5).ae(0.0069701398575483929193)
+    assert gammainc(1,3.5).ae(0.03019738342231850074)
+    assert gammainc(2,3.5).ae(0.13588822540043325333)
+    assert gammainc(3,3.5).ae(0.64169439772426814072)
+    # Small case; with branch cut
+    assert gammainc(-3,-3.5).ae(0.03595832954467563286 + 0.52359877559829887308j)
+    assert gammainc(-2,-3.5).ae(-0.88024704597962022221 - 1.5707963267948966192j)
+    assert gammainc(-1,-3.5).ae(4.4637962926688170771 + 3.1415926535897932385j)
+    assert gammainc(0,-3.5).ae(-13.925353995152335292 - 3.1415926535897932385j)
+    assert gammainc(1,-3.5).ae(33.115451958692313751)
+    assert gammainc(2,-3.5).ae(-82.788629896730784377)
+    assert gammainc(3,-3.5).ae(240.08702670051927469)
+    # Asymptotic case; no branch cut
+    assert gammainc(-3,350).ae(6.5424095113340358813e-163, abs_eps=0, rel_eps=8*eps)
+    assert gammainc(-2,350).ae(2.296312222489899769e-160, abs_eps=0, rel_eps=8*eps)
+    assert gammainc(-1,350).ae(8.059861834133858573e-158, abs_eps=0, rel_eps=8*eps)
+    assert gammainc(0,350).ae(2.8289659656701459404e-155, abs_eps=0, rel_eps=8*eps)
+    assert gammainc(1,350).ae(9.9295903962649792963e-153, abs_eps=0, rel_eps=8*eps)
+    assert gammainc(2,350).ae(3.485286229089007733e-150, abs_eps=0, rel_eps=8*eps)
+    assert gammainc(3,350).ae(1.2233453960006379793e-147, abs_eps=0, rel_eps=8*eps)
+    # Asymptotic case; branch cut
+    u = gammainc(-3,-350)
+    assert u.ae(6.7889565783842895085e+141)
+    assert u.imag.ae(0.52359877559829887308)
+    u = gammainc(-2,-350)
+    assert u.ae(-2.3692668977889832121e+144)
+    assert u.imag.ae(-1.5707963267948966192)
+    u = gammainc(-1,-350)
+    assert u.ae(8.2685354361441858669e+146)
+    assert u.imag.ae(3.1415926535897932385)
+    u = gammainc(0,-350)
+    assert u.ae(-2.8856710698020863568e+149)
+    assert u.imag.ae(-3.1415926535897932385)
+    u = gammainc(1,-350)
+    assert u.ae(1.0070908870280797598e+152)
+    assert u.imag == 0
+    u = gammainc(2,-350)
+    assert u.ae(-3.5147471957279983618e+154)
+    assert u.imag == 0
+    u = gammainc(3,-350)
+    assert u.ae(1.2266568422179417091e+157)
+    assert u.imag == 0
+    # Extreme asymptotic case
+    assert gammainc(-3,350000000000000000000000).ae('5.0362468738874738859e-152003068666138139677990', abs_eps=0, rel_eps=8*eps)
+    assert gammainc(-2,350000000000000000000000).ae('1.7626864058606158601e-152003068666138139677966', abs_eps=0, rel_eps=8*eps)
+    assert gammainc(-1,350000000000000000000000).ae('6.1694024205121555102e-152003068666138139677943', abs_eps=0, rel_eps=8*eps)
+    assert gammainc(0,350000000000000000000000).ae('2.1592908471792544286e-152003068666138139677919', abs_eps=0, rel_eps=8*eps)
+    assert gammainc(1,350000000000000000000000).ae('7.5575179651273905e-152003068666138139677896', abs_eps=0, rel_eps=8*eps)
+    assert gammainc(2,350000000000000000000000).ae('2.645131287794586675e-152003068666138139677872', abs_eps=0, rel_eps=8*eps)
+    assert gammainc(3,350000000000000000000000).ae('9.2579595072810533625e-152003068666138139677849', abs_eps=0, rel_eps=8*eps)
+    u = gammainc(-3,-350000000000000000000000)
+    assert u.ae('8.8175642804468234866e+152003068666138139677800')
+    assert u.imag.ae(0.52359877559829887308)
+    u = gammainc(-2,-350000000000000000000000)
+    assert u.ae('-3.0861474981563882203e+152003068666138139677824')
+    assert u.imag.ae(-1.5707963267948966192)
+    u = gammainc(-1,-350000000000000000000000)
+    assert u.ae('1.0801516243547358771e+152003068666138139677848')
+    assert u.imag.ae(3.1415926535897932385)
+    u = gammainc(0,-350000000000000000000000)
+    assert u.ae('-3.7805306852415755699e+152003068666138139677871')
+    assert u.imag.ae(-3.1415926535897932385)
+    assert gammainc(1,-350000000000000000000000).ae('1.3231857398345514495e+152003068666138139677895')
+    assert gammainc(2,-350000000000000000000000).ae('-4.6311500894209300731e+152003068666138139677918')
+    assert gammainc(3,-350000000000000000000000).ae('1.6209025312973255256e+152003068666138139677942')
+
+def test_incomplete_beta():
+    mp.dps = 15
+    assert betainc(-2,-3,0.5,0.75).ae(63.4305673311255413583969)
+    assert betainc(4.5,0.5+2j,2.5,6).ae(0.2628801146130621387903065 + 0.5162565234467020592855378j)
+    assert betainc(4,5,0,6).ae(90747.77142857142857142857)
+
+def test_erf():
+    mp.dps = 15
+    assert erf(0) == 0
+    assert erf(1).ae(0.84270079294971486934)
+    assert erf(3+4j).ae(-120.186991395079444098 - 27.750337293623902498j)
+    assert erf(-4-3j).ae(-0.99991066178539168236 + 0.00004972026054496604j)
+    assert erf(pi).ae(0.99999112385363235839)
+    assert erf(1j).ae(1.6504257587975428760j)
+    assert erf(-1j).ae(-1.6504257587975428760j)
+    assert isinstance(erf(1), mpf)
+    assert isinstance(erf(-1), mpf)
+    assert isinstance(erf(0), mpf)
+    assert isinstance(erf(0j), mpc)
+    assert erf(inf) == 1
+    assert erf(-inf) == -1
+    assert erfi(0) == 0
+    assert erfi(1/pi).ae(0.371682698493894314)
+    assert erfi(inf) == inf
+    assert erfi(-inf) == -inf
+    assert erf(1+0j) == erf(1)
+    assert erfc(1+0j) == erfc(1)
+    assert erf(0.2+0.5j).ae(1 - erfc(0.2+0.5j))
+    assert erfc(0) == 1
+    assert erfc(1).ae(1-erf(1))
+    assert erfc(-1).ae(1-erf(-1))
+    assert erfc(1/pi).ae(1-erf(1/pi))
+    assert erfc(-10) == 2
+    assert erfc(-1000000) == 2
+    assert erfc(-inf) == 2
+    assert erfc(inf) == 0
+    assert isnan(erfc(nan))
+    assert (erfc(10**4)*mpf(10)**43429453).ae('3.63998738656420')
+    assert erf(8+9j).ae(-1072004.2525062051158 + 364149.91954310255423j)
+    assert erfc(8+9j).ae(1072005.2525062051158 - 364149.91954310255423j)
+    assert erfc(-8-9j).ae(-1072003.2525062051158 + 364149.91954310255423j)
+    mp.dps = 50
+    # This one does not use the asymptotic series
+    assert (erfc(10)*10**45).ae('2.0884875837625447570007862949577886115608181193212')
+    # This one does
+    assert (erfc(50)*10**1088).ae('2.0709207788416560484484478751657887929322509209954')
+    mp.dps = 15
+    assert str(erfc(10**50)) == '3.66744826532555e-4342944819032518276511289189166050822943970058036665661144537831658646492088707747292249493384317534'
+    assert erfinv(0) == 0
+    assert erfinv(0.5).ae(0.47693627620446987338)
+    assert erfinv(-0.5).ae(-0.47693627620446987338)
+    assert erfinv(1) == inf
+    assert erfinv(-1) == -inf
+    assert erf(erfinv(0.95)).ae(0.95)
+    assert erf(erfinv(0.999999999995)).ae(0.999999999995)
+    assert erf(erfinv(-0.999999999995)).ae(-0.999999999995)
+    mp.dps = 50
+    assert erf(erfinv('0.99999999999999999999999999999995')).ae('0.99999999999999999999999999999995')
+    assert erf(erfinv('0.999999999999999999999999999999995')).ae('0.999999999999999999999999999999995')
+    assert erf(erfinv('-0.999999999999999999999999999999995')).ae('-0.999999999999999999999999999999995')
+    mp.dps = 15
+    # Complex asymptotic expansions
+    v = erfc(50j)
+    assert v.real == 1
+    assert v.imag.ae('-6.1481820666053078736e+1083')
+    assert erfc(-100+5j).ae(2)
+    assert (erfc(100+5j)*10**4335).ae(2.3973567853824133572 - 3.9339259530609420597j)
+    assert erfc(100+100j).ae(0.00065234366376857698698 - 0.0039357263629214118437j)
+
+def test_pdf():
+    mp.dps = 15
+    assert npdf(-inf) == 0
+    assert npdf(inf) == 0
+    assert npdf(5,0,2).ae(npdf(5+4,4,2))
+    assert quadts(lambda x: npdf(x,-0.5,0.8), [-inf, inf]) == 1
+    assert ncdf(0) == 0.5
+    assert ncdf(3,3) == 0.5
+    assert ncdf(-inf) == 0
+    assert ncdf(inf) == 1
+    assert ncdf(10) == 1
+    # Verify that this is computed accurately
+    assert (ncdf(-10)*10**24).ae(7.619853024160526)
+
+def test_lambertw():
+    mp.dps = 15
+    assert lambertw(0) == 0
+    assert lambertw(0+0j) == 0
+    assert lambertw(inf) == inf
+    assert isnan(lambertw(nan))
+    assert lambertw(inf,1).real == inf
+    assert lambertw(inf,1).imag.ae(2*pi)
+    assert lambertw(-inf,1).real == inf
+    assert lambertw(-inf,1).imag.ae(3*pi)
+    assert lambertw(0,-1) == -inf
+    assert lambertw(0,1) == -inf
+    assert lambertw(0,3) == -inf
+    assert lambertw(e).ae(1)
+    assert lambertw(1).ae(0.567143290409783873)
+    assert lambertw(-pi/2).ae(j*pi/2)
+    assert lambertw(-log(2)/2).ae(-log(2))
+    assert lambertw(0.25).ae(0.203888354702240164)
+    assert lambertw(-0.25).ae(-0.357402956181388903)
+    assert lambertw(-1./10000,0).ae(-0.000100010001500266719)
+    assert lambertw(-0.25,-1).ae(-2.15329236411034965)
+    assert lambertw(0.25,-1).ae(-3.00899800997004620-4.07652978899159763j)
+    assert lambertw(-0.25,-1).ae(-2.15329236411034965)
+    assert lambertw(0.25,1).ae(-3.00899800997004620+4.07652978899159763j)
+    assert lambertw(-0.25,1).ae(-3.48973228422959210+7.41405453009603664j)
+    assert lambertw(-4).ae(0.67881197132094523+1.91195078174339937j)
+    assert lambertw(-4,1).ae(-0.66743107129800988+7.76827456802783084j)
+    assert lambertw(-4,-1).ae(0.67881197132094523-1.91195078174339937j)
+    assert lambertw(1000).ae(5.24960285240159623)
+    assert lambertw(1000,1).ae(4.91492239981054535+5.44652615979447070j)
+    assert lambertw(1000,-1).ae(4.91492239981054535-5.44652615979447070j)
+    assert lambertw(1000,5).ae(3.5010625305312892+29.9614548941181328j)
+    assert lambertw(3+4j).ae(1.281561806123775878+0.533095222020971071j)
+    assert lambertw(-0.4+0.4j).ae(-0.10396515323290657+0.61899273315171632j)
+    assert lambertw(3+4j,1).ae(-0.11691092896595324+5.61888039871282334j)
+    assert lambertw(3+4j,-1).ae(0.25856740686699742-3.85211668616143559j)
+    assert lambertw(-0.5,-1).ae(-0.794023632344689368-0.770111750510379110j)
+    assert lambertw(-1./10000,1).ae(-11.82350837248724344+6.80546081842002101j)
+    assert lambertw(-1./10000,-1).ae(-11.6671145325663544)
+    assert lambertw(-1./10000,-2).ae(-11.82350837248724344-6.80546081842002101j)
+    assert lambertw(-1./100000,4).ae(-14.9186890769540539+26.1856750178782046j)
+    assert lambertw(-1./100000,5).ae(-15.0931437726379218666+32.5525721210262290086j)
+    assert lambertw((2+j)/10).ae(0.173704503762911669+0.071781336752835511j)
+    assert lambertw((2+j)/10,1).ae(-3.21746028349820063+4.56175438896292539j)
+    assert lambertw((2+j)/10,-1).ae(-3.03781405002993088-3.53946629633505737j)
+    assert lambertw((2+j)/10,4).ae(-4.6878509692773249+23.8313630697683291j)
+    assert lambertw(-(2+j)/10).ae(-0.226933772515757933-0.164986470020154580j)
+    assert lambertw(-(2+j)/10,1).ae(-2.43569517046110001+0.76974067544756289j)
+    assert lambertw(-(2+j)/10,-1).ae(-3.54858738151989450-6.91627921869943589j)
+    assert lambertw(-(2+j)/10,4).ae(-4.5500846928118151+20.6672982215434637j)
+    mp.dps = 50
+    assert lambertw(pi).ae('1.073658194796149172092178407024821347547745350410314531')
+    mp.dps = 15
+    # Former bug in generated branch
+    assert lambertw(-0.5+0.002j).ae(-0.78917138132659918344 + 0.76743539379990327749j)
+    assert lambertw(-0.5-0.002j).ae(-0.78917138132659918344 - 0.76743539379990327749j)
+    assert lambertw(-0.448+0.4j).ae(-0.11855133765652382241 + 0.66570534313583423116j)
+    assert lambertw(-0.448-0.4j).ae(-0.11855133765652382241 - 0.66570534313583423116j)
+    assert lambertw(-0.65475+0.0001j).ae(-0.61053421111385310898+1.0396534993944097723803j)
+    # Huge branch index
+    w = lambertw(1,10**20)
+    assert w.real.ae(-47.889578926290259164)
+    assert w.imag.ae(6.2831853071795864769e+20)
+
+def test_lambertw_hard():
+    def check(x,y):
+        y = convert(y)
+        type_ok = True
+        if isinstance(y, mpf):
+            type_ok = isinstance(x, mpf)
+        real_ok = abs(x.real-y.real) <= abs(y.real)*8*eps
+        imag_ok = abs(x.imag-y.imag) <= abs(y.imag)*8*eps
+        #print x, y, abs(x.real-y.real), abs(x.imag-y.imag)
+        return real_ok and imag_ok
+    # Evaluation near 0
+    mp.dps = 15
+    assert check(lambertw(1e-10), 9.999999999000000000e-11)
+    assert check(lambertw(-1e-10), -1.000000000100000000e-10)
+    assert check(lambertw(1e-10j), 9.999999999999999999733e-21 + 9.99999999999999999985e-11j)
+    assert check(lambertw(-1e-10j), 9.999999999999999999733e-21 - 9.99999999999999999985e-11j)
+    assert check(lambertw(1e-10,1), -26.303186778379041559 + 3.265093911703828397j)
+    assert check(lambertw(-1e-10,1), -26.326236166739163892 + 6.526183280686333315j)
+    assert check(lambertw(1e-10j,1), -26.312931726911421551 + 4.896366881798013421j)
+    assert check(lambertw(-1e-10j,1), -26.297238779529035066 + 1.632807161345576513j)
+    assert check(lambertw(1e-10,-1), -26.303186778379041559 - 3.265093911703828397j)
+    assert check(lambertw(-1e-10,-1), -26.295238819246925694)
+    assert check(lambertw(1e-10j,-1), -26.297238779529035028 - 1.6328071613455765135j)
+    assert check(lambertw(-1e-10j,-1), -26.312931726911421551 - 4.896366881798013421j)
+    # Test evaluation very close to the branch point -1/e
+    # on the -1, 0, and 1 branches
+    add = lambda x, y: fadd(x,y,exact=True)
+    sub = lambda x, y: fsub(x,y,exact=True)
+    addj = lambda x, y: fadd(x,fmul(y,1j,exact=True),exact=True)
+    subj = lambda x, y: fadd(x,fmul(y,-1j,exact=True),exact=True)
+    mp.dps = 1500
+    a = -1/e + 10*eps
+    d3 = mpf('1e-3')
+    d10 = mpf('1e-10')
+    d20 = mpf('1e-20')
+    d40 = mpf('1e-40')
+    d80 = mpf('1e-80')
+    d300 = mpf('1e-300')
+    d1000 = mpf('1e-1000')
+    mp.dps = 15
+    # ---- Branch 0 ----
+    # -1/e + eps
+    assert check(lambertw(add(a,d3)), -0.92802015005456704876)
+    assert check(lambertw(add(a,d10)), -0.99997668374140088071)
+    assert check(lambertw(add(a,d20)), -0.99999999976683560186)
+    assert lambertw(add(a,d40)) == -1
+    assert lambertw(add(a,d80)) == -1
+    assert lambertw(add(a,d300)) == -1
+    assert lambertw(add(a,d1000)) == -1
+    # -1/e - eps
+    assert check(lambertw(sub(a,d3)), -0.99819016149860989001+0.07367191188934638577j)
+    assert check(lambertw(sub(a,d10)), -0.9999999998187812114595992+0.0000233164398140346109194j)
+    assert check(lambertw(sub(a,d20)), -0.99999999999999999998187+2.331643981597124203344e-10j)
+    assert check(lambertw(sub(a,d40)), -1.0+2.33164398159712420336e-20j)
+    assert check(lambertw(sub(a,d80)), -1.0+2.33164398159712420336e-40j)
+    assert check(lambertw(sub(a,d300)), -1.0+2.33164398159712420336e-150j)
+    assert check(lambertw(sub(a,d1000)), mpc(-1,'2.33164398159712420336e-500'))
+    # -1/e + eps*j
+    assert check(lambertw(addj(a,d3)), -0.94790387486938526634+0.05036819639190132490j)
+    assert check(lambertw(addj(a,d10)), -0.9999835127872943680999899+0.0000164870314895821225256j)
+    assert check(lambertw(addj(a,d20)), -0.999999999835127872929987+1.64872127051890935830e-10j)
+    assert check(lambertw(addj(a,d40)), -0.9999999999999999999835+1.6487212707001281468305e-20j)
+    assert check(lambertw(addj(a,d80)), -1.0 + 1.64872127070012814684865e-40j)
+    assert check(lambertw(addj(a,d300)), -1.0 + 1.64872127070012814684865e-150j)
+    assert check(lambertw(addj(a,d1000)), mpc(-1.0,'1.64872127070012814684865e-500'))
+    # -1/e - eps*j
+    assert check(lambertw(subj(a,d3)), -0.94790387486938526634-0.05036819639190132490j)
+    assert check(lambertw(subj(a,d10)), -0.9999835127872943680999899-0.0000164870314895821225256j)
+    assert check(lambertw(subj(a,d20)), -0.999999999835127872929987-1.64872127051890935830e-10j)
+    assert check(lambertw(subj(a,d40)), -0.9999999999999999999835-1.6487212707001281468305e-20j)
+    assert check(lambertw(subj(a,d80)), -1.0 - 1.64872127070012814684865e-40j)
+    assert check(lambertw(subj(a,d300)), -1.0 - 1.64872127070012814684865e-150j)
+    assert check(lambertw(subj(a,d1000)), mpc(-1.0,'-1.64872127070012814684865e-500'))
+    # ---- Branch 1 ----
+    assert check(lambertw(addj(a,d3),1), -3.088501303219933378005990 + 7.458676867597474813950098j)
+    assert check(lambertw(addj(a,d80),1), -3.088843015613043855957087 + 7.461489285654254556906117j)
+    assert check(lambertw(addj(a,d300),1), -3.088843015613043855957087 + 7.461489285654254556906117j)
+    assert check(lambertw(addj(a,d1000),1), -3.088843015613043855957087 + 7.461489285654254556906117j)
+    assert check(lambertw(subj(a,d3),1), -1.0520914180450129534365906 + 0.0539925638125450525673175j)
+    assert check(lambertw(subj(a,d10),1), -1.0000164872127056318529390 + 0.000016487393927159250398333077j)
+    assert check(lambertw(subj(a,d20),1), -1.0000000001648721270700128 + 1.64872127088134693542628e-10j)
+    assert check(lambertw(subj(a,d40),1), -1.000000000000000000016487 + 1.64872127070012814686677e-20j)
+    assert check(lambertw(subj(a,d80),1), -1.0 + 1.64872127070012814684865e-40j)
+    assert check(lambertw(subj(a,d300),1), -1.0 + 1.64872127070012814684865e-150j)
+    assert check(lambertw(subj(a,d1000),1), mpc(-1.0, '1.64872127070012814684865e-500'))
+    # ---- Branch -1 ----
+    # -1/e + eps
+    assert check(lambertw(add(a,d3),-1), -1.075608941186624989414945)
+    assert check(lambertw(add(a,d10),-1), -1.000023316621036696460620)
+    assert check(lambertw(add(a,d20),-1), -1.000000000233164398177834)
+    assert lambertw(add(a,d40),-1) == -1
+    assert lambertw(add(a,d80),-1) == -1
+    assert lambertw(add(a,d300),-1) == -1
+    assert lambertw(add(a,d1000),-1) == -1
+    # -1/e - eps
+    assert check(lambertw(sub(a,d3),-1), -0.99819016149860989001-0.07367191188934638577j)
+    assert check(lambertw(sub(a,d10),-1), -0.9999999998187812114595992-0.0000233164398140346109194j)
+    assert check(lambertw(sub(a,d20),-1), -0.99999999999999999998187-2.331643981597124203344e-10j)
+    assert check(lambertw(sub(a,d40),-1), -1.0-2.33164398159712420336e-20j)
+    assert check(lambertw(sub(a,d80),-1), -1.0-2.33164398159712420336e-40j)
+    assert check(lambertw(sub(a,d300),-1), -1.0-2.33164398159712420336e-150j)
+    assert check(lambertw(sub(a,d1000),-1), mpc(-1,'-2.33164398159712420336e-500'))
+    # -1/e + eps*j
+    assert check(lambertw(addj(a,d3),-1), -1.0520914180450129534365906 - 0.0539925638125450525673175j)
+    assert check(lambertw(addj(a,d10),-1), -1.0000164872127056318529390 - 0.0000164873939271592503983j)
+    assert check(lambertw(addj(a,d20),-1), -1.0000000001648721270700 - 1.64872127088134693542628e-10j)
+    assert check(lambertw(addj(a,d40),-1), -1.00000000000000000001648 - 1.6487212707001281468667726e-20j)
+    assert check(lambertw(addj(a,d80),-1), -1.0 - 1.64872127070012814684865e-40j)
+    assert check(lambertw(addj(a,d300),-1), -1.0 - 1.64872127070012814684865e-150j)
+    assert check(lambertw(addj(a,d1000),-1), mpc(-1.0,'-1.64872127070012814684865e-500'))
+    # -1/e - eps*j
+    assert check(lambertw(subj(a,d3),-1), -3.088501303219933378005990-7.458676867597474813950098j)
+    assert check(lambertw(subj(a,d10),-1), -3.088843015579260686911033-7.461489285372968780020716j)
+    assert check(lambertw(subj(a,d20),-1), -3.088843015613043855953708-7.461489285654254556877988j)
+    assert check(lambertw(subj(a,d40),-1), -3.088843015613043855957087-7.461489285654254556906117j)
+    assert check(lambertw(subj(a,d80),-1), -3.088843015613043855957087 - 7.461489285654254556906117j)
+    assert check(lambertw(subj(a,d300),-1), -3.088843015613043855957087 - 7.461489285654254556906117j)
+    assert check(lambertw(subj(a,d1000),-1), -3.088843015613043855957087 - 7.461489285654254556906117j)
+    # One more case, testing higher precision
+    mp.dps = 500
+    x = -1/e + mpf('1e-13')
+    ans = "-0.99999926266961377166355784455394913638782494543377383"\
+    "744978844374498153493943725364881490261187530235150668593869563"\
+    "168276697689459394902153960200361935311512317183678882"
+    mp.dps = 15
+    assert lambertw(x).ae(ans)
+    mp.dps = 50
+    assert lambertw(x).ae(ans)
+    mp.dps = 150
+    assert lambertw(x).ae(ans)
+
+def test_meijerg():
+    mp.dps = 15
+    assert meijerg([[2,3],[1]],[[0.5,2],[3,4]], 2.5).ae(4.2181028074787439386)
+    assert meijerg([[],[1+j]],[[1],[1]], 3+4j).ae(271.46290321152464592 - 703.03330399954820169j)
+    assert meijerg([[0.25],[1]],[[0.5],[2]],0) == 0
+    assert meijerg([[0],[]],[[0,0,'1/3','2/3'], []], '2/27').ae(2.2019391389653314120)
+    # Verify 1/z series being used
+    assert meijerg([[-3],[-0.5]], [[-1],[-2.5]], -0.5).ae(-1.338096165935754898687431)
+    assert meijerg([[1-(-1)],[1-(-2.5)]], [[1-(-3)],[1-(-0.5)]], -2.0).ae(-1.338096165935754898687431)
+    assert meijerg([[-3],[-0.5]], [[-1],[-2.5]], -1).ae(-(pi+4)/(4*pi))
+    a = 2.5
+    b = 1.25
+    for z in [mpf(0.25), mpf(2)]:
+        x1 = hyp1f1(a,b,z)
+        x2 = gamma(b)/gamma(a)*meijerg([[1-a],[]],[[0],[1-b]],-z)
+        x3 = gamma(b)/gamma(a)*meijerg([[1-0],[1-(1-b)]],[[1-(1-a)],[]],-1/z)
+        assert x1.ae(x2)
+        assert x1.ae(x3)
+
+def test_appellf1():
+    mp.dps = 15
+    assert appellf1(2,-2,1,1,2,3).ae(-1.75)
+    assert appellf1(2,1,-2,1,2,3).ae(-8)
+    assert appellf1(2,1,-2,1,0.5,0.25).ae(1.5)
+    assert appellf1(-2,1,3,2,3,3).ae(19)
+    assert appellf1(1,2,3,4,0.5,0.125).ae( 1.53843285792549786518)
+
+def test_coulomb():
+    # Note: most tests are doctests
+    # Test for a bug:
+    mp.dps = 15
+    assert coulombg(mpc(-5,0),2,3).ae(20.087729487721430394)
+
+def test_hyper_param_accuracy():
+    mp.dps = 15
+    As = [n+1e-10 for n in range(-5,-1)]
+    Bs = [n+1e-10 for n in range(-12,-5)]
+    assert hyper(As,Bs,10).ae(-381757055858.652671927)
+    assert legenp(0.5, 100, 0.25).ae(-2.4124576567211311755e+144)
+    assert (hyp1f1(1000,1,-100)*10**24).ae(5.2589445437370169113)
+    assert (hyp2f1(10, -900, 10.5, 0.99)*10**24).ae(1.9185370579660768203)
+    assert (hyp2f1(1000,1.5,-3.5,-1.5)*10**385).ae(-2.7367529051334000764)
+    assert hyp2f1(-5, 10, 3, 0.5, zeroprec=500) == 0
+    assert (hyp1f1(-10000, 1000, 100)*10**424).ae(-3.1046080515824859974)
+    assert (hyp2f1(1000,1.5,-3.5,-0.75,maxterms=100000)*10**231).ae(-4.0534790813913998643)
+    assert legenp(2, 3, 0.25) == 0
+    pytest.raises(ValueError, lambda: hypercomb(lambda a: [([],[],[],[],[a],[-a],0.5)], [3]))
+    assert hypercomb(lambda a: [([],[],[],[],[a],[-a],0.5)], [3], infprec=200) == inf
+    assert meijerg([[],[]],[[0,0,0,0],[]],0.1).ae(1.5680822343832351418)
+    assert (besselk(400,400)*10**94).ae(1.4387057277018550583)
+    mp.dps = 5
+    (hyp1f1(-5000.5, 1500, 100)*10**185).ae(8.5185229673381935522)
+    (hyp1f1(-5000, 1500, 100)*10**185).ae(9.1501213424563944311)
+    mp.dps = 15
+    (hyp1f1(-5000.5, 1500, 100)*10**185).ae(8.5185229673381935522)
+    (hyp1f1(-5000, 1500, 100)*10**185).ae(9.1501213424563944311)
+    assert hyp0f1(fadd(-20,'1e-100',exact=True), 0.25).ae(1.85014429040102783e+49)
+    assert hyp0f1((-20*10**100+1, 10**100), 0.25).ae(1.85014429040102783e+49)
+
+def test_hypercomb_zero_pow():
+    # check that 0^0 = 1
+    assert hypercomb(lambda a: (([0],[a],[],[],[],[],0),), [0]) == 1
+    assert meijerg([[-1.5],[]],[[0],[-0.75]],0).ae(1.4464090846320771425)
+
+def test_spherharm():
+    mp.dps = 15
+    t = 0.5; r = 0.25
+    assert spherharm(0,0,t,r).ae(0.28209479177387814347)
+    assert spherharm(1,-1,t,r).ae(0.16048941205971996369 - 0.04097967481096344271j)
+    assert spherharm(1,0,t,r).ae(0.42878904414183579379)
+    assert spherharm(1,1,t,r).ae(-0.16048941205971996369 - 0.04097967481096344271j)
+    assert spherharm(2,-2,t,r).ae(0.077915886919031181734 - 0.042565643022253962264j)
+    assert spherharm(2,-1,t,r).ae(0.31493387233497459884 - 0.08041582001959297689j)
+    assert spherharm(2,0,t,r).ae(0.41330596756220761898)
+    assert spherharm(2,1,t,r).ae(-0.31493387233497459884 - 0.08041582001959297689j)
+    assert spherharm(2,2,t,r).ae(0.077915886919031181734 + 0.042565643022253962264j)
+    assert spherharm(3,-3,t,r).ae(0.033640236589690881646 - 0.031339125318637082197j)
+    assert spherharm(3,-2,t,r).ae(0.18091018743101461963 - 0.09883168583167010241j)
+    assert spherharm(3,-1,t,r).ae(0.42796713930907320351 - 0.10927795157064962317j)
+    assert spherharm(3,0,t,r).ae(0.27861659336351639787)
+    assert spherharm(3,1,t,r).ae(-0.42796713930907320351 - 0.10927795157064962317j)
+    assert spherharm(3,2,t,r).ae(0.18091018743101461963 + 0.09883168583167010241j)
+    assert spherharm(3,3,t,r).ae(-0.033640236589690881646 - 0.031339125318637082197j)
+    assert spherharm(0,-1,t,r) == 0
+    assert spherharm(0,-2,t,r) == 0
+    assert spherharm(0,1,t,r) == 0
+    assert spherharm(0,2,t,r) == 0
+    assert spherharm(1,2,t,r) == 0
+    assert spherharm(1,3,t,r) == 0
+    assert spherharm(1,-2,t,r) == 0
+    assert spherharm(1,-3,t,r) == 0
+    assert spherharm(2,3,t,r) == 0
+    assert spherharm(2,4,t,r) == 0
+    assert spherharm(2,-3,t,r) == 0
+    assert spherharm(2,-4,t,r) == 0
+    assert spherharm(3,4.5,0.5,0.25).ae(-22.831053442240790148 + 10.910526059510013757j)
+    assert spherharm(2+3j, 1-j, 1+j, 3+4j).ae(-2.6582752037810116935 - 1.0909214905642160211j)
+    assert spherharm(-6,2.5,t,r).ae(0.39383644983851448178 + 0.28414687085358299021j)
+    assert spherharm(-3.5, 3, 0.5, 0.25).ae(0.014516852987544698924 - 0.015582769591477628495j)
+    assert spherharm(-3, 3, 0.5, 0.25) == 0
+    assert spherharm(-6, 3, 0.5, 0.25).ae(-0.16544349818782275459 - 0.15412657723253924562j)
+    assert spherharm(-6, 1.5, 0.5, 0.25).ae(0.032208193499767402477 + 0.012678000924063664921j)
+    assert spherharm(3,0,0,1).ae(0.74635266518023078283)
+    assert spherharm(3,-2,0,1) == 0
+    assert spherharm(3,-2,1,1).ae(-0.16270707338254028971 - 0.35552144137546777097j)
+
+def test_qfunctions():
+    mp.dps = 15
+    assert qp(2,3,100).ae('2.7291482267247332183e2391')
+
+def test_issue_239():
+    mp.prec = 150
+    x = ldexp(2476979795053773,-52)
+    assert betainc(206, 385, 0, 0.55, 1).ae('0.99999999999999999999996570910644857895771110649954')
+    mp.dps = 15
+    pytest.raises(ValueError, lambda: hyp2f1(-5,5,0.5,0.5))
+
+# Extra stress testing for Bessel functions
+# Reference zeros generated with the aid of scipy.special
+# jn_zero, jnp_zero, yn_zero, ynp_zero
+
+V = 15
+M = 15
+
+jn_small_zeros = \
+[[2.4048255576957728,
+  5.5200781102863106,
+  8.6537279129110122,
+  11.791534439014282,
+  14.930917708487786,
+  18.071063967910923,
+  21.211636629879259,
+  24.352471530749303,
+  27.493479132040255,
+  30.634606468431975,
+  33.775820213573569,
+  36.917098353664044,
+  40.058425764628239,
+  43.19979171317673,
+  46.341188371661814],
+ [3.8317059702075123,
+  7.0155866698156188,
+  10.173468135062722,
+  13.323691936314223,
+  16.470630050877633,
+  19.615858510468242,
+  22.760084380592772,
+  25.903672087618383,
+  29.046828534916855,
+  32.189679910974404,
+  35.332307550083865,
+  38.474766234771615,
+  41.617094212814451,
+  44.759318997652822,
+  47.901460887185447],
+ [5.1356223018406826,
+  8.4172441403998649,
+  11.619841172149059,
+  14.795951782351261,
+  17.959819494987826,
+  21.116997053021846,
+  24.270112313573103,
+  27.420573549984557,
+  30.569204495516397,
+  33.7165195092227,
+  36.86285651128381,
+  40.008446733478192,
+  43.153453778371463,
+  46.297996677236919,
+  49.442164110416873],
+ [6.3801618959239835,
+  9.7610231299816697,
+  13.015200721698434,
+  16.223466160318768,
+  19.409415226435012,
+  22.582729593104442,
+  25.748166699294978,
+  28.908350780921758,
+  32.064852407097709,
+  35.218670738610115,
+  38.370472434756944,
+  41.520719670406776,
+  44.669743116617253,
+  47.817785691533302,
+  50.965029906205183],
+ [7.5883424345038044,
+  11.064709488501185,
+  14.37253667161759,
+  17.615966049804833,
+  20.826932956962388,
+  24.01901952477111,
+  27.199087765981251,
+  30.371007667117247,
+  33.537137711819223,
+  36.699001128744649,
+  39.857627302180889,
+  43.01373772335443,
+  46.167853512924375,
+  49.320360686390272,
+  52.471551398458023],
+ [8.771483815959954,
+  12.338604197466944,
+  15.700174079711671,
+  18.980133875179921,
+  22.217799896561268,
+  25.430341154222704,
+  28.626618307291138,
+  31.811716724047763,
+  34.988781294559295,
+  38.159868561967132,
+  41.326383254047406,
+  44.489319123219673,
+  47.649399806697054,
+  50.80716520300633,
+  53.963026558378149],
+ [9.9361095242176849,
+  13.589290170541217,
+  17.003819667816014,
+  20.320789213566506,
+  23.58608443558139,
+  26.820151983411405,
+  30.033722386570469,
+  33.233041762847123,
+  36.422019668258457,
+  39.603239416075404,
+  42.778481613199507,
+  45.949015998042603,
+  49.11577372476426,
+  52.279453903601052,
+  55.440592068853149],
+ [11.086370019245084,
+  14.821268727013171,
+  18.287582832481726,
+  21.641541019848401,
+  24.934927887673022,
+  28.191188459483199,
+  31.42279419226558,
+  34.637089352069324,
+  37.838717382853611,
+  41.030773691585537,
+  44.21540850526126,
+  47.394165755570512,
+  50.568184679795566,
+  53.738325371963291,
+  56.905249991978781],
+ [12.225092264004655,
+  16.037774190887709,
+  19.554536430997055,
+  22.94517313187462,
+  26.266814641176644,
+  29.54565967099855,
+  32.795800037341462,
+  36.025615063869571,
+  39.240447995178135,
+  42.443887743273558,
+  45.638444182199141,
+  48.825930381553857,
+  52.007691456686903,
+  55.184747939289049,
+  58.357889025269694],
+ [13.354300477435331,
+  17.241220382489128,
+  20.807047789264107,
+  24.233885257750552,
+  27.583748963573006,
+  30.885378967696675,
+  34.154377923855096,
+  37.400099977156589,
+  40.628553718964528,
+  43.843801420337347,
+  47.048700737654032,
+  50.245326955305383,
+  53.435227157042058,
+  56.619580266508436,
+  59.799301630960228],
+ [14.475500686554541,
+  18.433463666966583,
+  22.046985364697802,
+  25.509450554182826,
+  28.887375063530457,
+  32.211856199712731,
+  35.499909205373851,
+  38.761807017881651,
+  42.004190236671805,
+  45.231574103535045,
+  48.447151387269394,
+  51.653251668165858,
+  54.851619075963349,
+  58.043587928232478,
+  61.230197977292681],
+ [15.589847884455485,
+  19.61596690396692,
+  23.275853726263409,
+  26.773322545509539,
+  30.17906117878486,
+  33.526364075588624,
+  36.833571341894905,
+  40.111823270954241,
+  43.368360947521711,
+  46.608132676274944,
+  49.834653510396724,
+  53.050498959135054,
+  56.257604715114484,
+  59.457456908388002,
+  62.651217388202912],
+ [16.698249933848246,
+  20.789906360078443,
+  24.494885043881354,
+  28.026709949973129,
+  31.45996003531804,
+  34.829986990290238,
+  38.156377504681354,
+  41.451092307939681,
+  44.721943543191147,
+  47.974293531269048,
+  51.211967004101068,
+  54.437776928325074,
+  57.653844811906946,
+  60.8618046824805,
+  64.062937824850136],
+ [17.801435153282442,
+  21.95624406783631,
+  25.705103053924724,
+  29.270630441874802,
+  32.731053310978403,
+  36.123657666448762,
+  39.469206825243883,
+  42.780439265447158,
+  46.06571091157561,
+  49.330780096443524,
+  52.579769064383396,
+  55.815719876305778,
+  59.040934037249271,
+  62.257189393731728,
+  65.465883797232125],
+ [18.899997953174024,
+  23.115778347252756,
+  26.907368976182104,
+  30.505950163896036,
+  33.993184984781542,
+  37.408185128639695,
+  40.772827853501868,
+  44.100590565798301,
+  47.400347780543231,
+  50.678236946479898,
+  53.93866620912693,
+  57.184898598119301,
+  60.419409852130297,
+  63.644117508962281,
+  66.860533012260103]]
+
+jnp_small_zeros = \
+[[0.0,
+  3.8317059702075123,
+  7.0155866698156188,
+  10.173468135062722,
+  13.323691936314223,
+  16.470630050877633,
+  19.615858510468242,
+  22.760084380592772,
+  25.903672087618383,
+  29.046828534916855,
+  32.189679910974404,
+  35.332307550083865,
+  38.474766234771615,
+  41.617094212814451,
+  44.759318997652822],
+ [1.8411837813406593,
+  5.3314427735250326,
+  8.5363163663462858,
+  11.706004902592064,
+  14.863588633909033,
+  18.015527862681804,
+  21.16436985918879,
+  24.311326857210776,
+  27.457050571059246,
+  30.601922972669094,
+  33.746182898667383,
+  36.889987409236811,
+  40.033444053350675,
+  43.176628965448822,
+  46.319597561173912],
+ [3.0542369282271403,
+  6.7061331941584591,
+  9.9694678230875958,
+  13.170370856016123,
+  16.347522318321783,
+  19.512912782488205,
+  22.671581772477426,
+  25.826037141785263,
+  28.977672772993679,
+  32.127327020443474,
+  35.275535050674691,
+  38.422654817555906,
+  41.568934936074314,
+  44.714553532819734,
+  47.859641607992093],
+ [4.2011889412105285,
+  8.0152365983759522,
+  11.345924310743006,
+  14.585848286167028,
+  17.78874786606647,
+  20.9724769365377,
+  24.144897432909265,
+  27.310057930204349,
+  30.470268806290424,
+  33.626949182796679,
+  36.781020675464386,
+  39.933108623659488,
+  43.083652662375079,
+  46.232971081836478,
+  49.381300092370349],
+ [5.3175531260839944,
+  9.2823962852416123,
+  12.681908442638891,
+  15.964107037731551,
+  19.196028800048905,
+  22.401032267689004,
+  25.589759681386733,
+  28.767836217666503,
+  31.938539340972783,
+  35.103916677346764,
+  38.265316987088158,
+  41.423666498500732,
+  44.579623137359257,
+  47.733667523865744,
+  50.886159153182682],
+ [6.4156163757002403,
+  10.519860873772308,
+  13.9871886301403,
+  17.312842487884625,
+  20.575514521386888,
+  23.803581476593863,
+  27.01030789777772,
+  30.20284907898166,
+  33.385443901010121,
+  36.560777686880356,
+  39.730640230067416,
+  42.896273163494417,
+  46.058566273567043,
+  49.218174614666636,
+  52.375591529563596],
+ [7.501266144684147,
+  11.734935953042708,
+  15.268181461097873,
+  18.637443009666202,
+  21.931715017802236,
+  25.183925599499626,
+  28.409776362510085,
+  31.617875716105035,
+  34.81339298429743,
+  37.999640897715301,
+  41.178849474321413,
+  44.352579199070217,
+  47.521956905768113,
+  50.687817781723741,
+  53.85079463676896],
+ [8.5778364897140741,
+  12.932386237089576,
+  16.529365884366944,
+  19.941853366527342,
+  23.268052926457571,
+  26.545032061823576,
+  29.790748583196614,
+  33.015178641375142,
+  36.224380548787162,
+  39.422274578939259,
+  42.611522172286684,
+  45.793999658055002,
+  48.971070951900596,
+  52.143752969301988,
+  55.312820330403446],
+ [9.6474216519972168,
+  14.115518907894618,
+  17.774012366915256,
+  21.229062622853124,
+  24.587197486317681,
+  27.889269427955092,
+  31.155326556188325,
+  34.39662855427218,
+  37.620078044197086,
+  40.830178681822041,
+  44.030010337966153,
+  47.221758471887113,
+  50.407020967034367,
+  53.586995435398319,
+  56.762598475105272],
+ [10.711433970699945,
+  15.28673766733295,
+  19.004593537946053,
+  22.501398726777283,
+  25.891277276839136,
+  29.218563499936081,
+  32.505247352375523,
+  35.763792928808799,
+  39.001902811514218,
+  42.224638430753279,
+  45.435483097475542,
+  48.636922645305525,
+  51.830783925834728,
+  55.01844255063594,
+  58.200955824859509],
+ [11.770876674955582,
+  16.447852748486498,
+  20.223031412681701,
+  23.760715860327448,
+  27.182021527190532,
+  30.534504754007074,
+  33.841965775135715,
+  37.118000423665604,
+  40.371068905333891,
+  43.606764901379516,
+  46.828959446564562,
+  50.040428970943456,
+  53.243223214220535,
+  56.438892058982552,
+  59.628631306921512],
+ [12.826491228033465,
+  17.600266557468326,
+  21.430854238060294,
+  25.008518704644261,
+  28.460857279654847,
+  31.838424458616998,
+  35.166714427392629,
+  38.460388720328256,
+  41.728625562624312,
+  44.977526250903469,
+  48.211333836373288,
+  51.433105171422278,
+  54.645106240447105,
+  57.849056857839799,
+  61.046288512821078],
+ [13.878843069697276,
+  18.745090916814406,
+  22.629300302835503,
+  26.246047773946584,
+  29.72897816891134,
+  33.131449953571661,
+  36.480548302231658,
+  39.791940718940855,
+  43.075486800191012,
+  46.337772104541405,
+  49.583396417633095,
+  52.815686826850452,
+  56.037118687012179,
+  59.249577075517968,
+  62.454525995970462],
+ [14.928374492964716,
+  19.88322436109951,
+  23.81938909003628,
+  27.474339750968247,
+  30.987394331665278,
+  34.414545662167183,
+  37.784378506209499,
+  41.113512376883377,
+  44.412454519229281,
+  47.688252845993366,
+  50.945849245830813,
+  54.188831071035124,
+  57.419876154678179,
+  60.641030026538746,
+  63.853885828967512],
+ [15.975438807484321,
+  21.015404934568315,
+  25.001971500138194,
+  28.694271223110755,
+  32.236969407878118,
+  35.688544091185301,
+  39.078998185245057,
+  42.425854432866141,
+  45.740236776624833,
+  49.029635055514276,
+  52.299319390331728,
+  55.553127779547459,
+  58.793933759028134,
+  62.02393848337554,
+  65.244860767043859]]
+
+yn_small_zeros = \
+[[0.89357696627916752,
+  3.9576784193148579,
+  7.0860510603017727,
+  10.222345043496417,
+  13.361097473872763,
+  16.500922441528091,
+  19.64130970088794,
+  22.782028047291559,
+  25.922957653180923,
+  29.064030252728398,
+  32.205204116493281,
+  35.346452305214321,
+  38.487756653081537,
+  41.629104466213808,
+  44.770486607221993],
+ [2.197141326031017,
+  5.4296810407941351,
+  8.5960058683311689,
+  11.749154830839881,
+  14.897442128336725,
+  18.043402276727856,
+  21.188068934142213,
+  24.331942571356912,
+  27.475294980449224,
+  30.618286491641115,
+  33.761017796109326,
+  36.90355531614295,
+  40.045944640266876,
+  43.188218097393211,
+  46.330399250701687],
+ [3.3842417671495935,
+  6.7938075132682675,
+  10.023477979360038,
+  13.209986710206416,
+  16.378966558947457,
+  19.539039990286384,
+  22.69395593890929,
+  25.845613720902269,
+  28.995080395650151,
+  32.143002257627551,
+  35.289793869635804,
+  38.435733485446343,
+  41.581014867297885,
+  44.725777117640461,
+  47.870122696676504],
+ [4.5270246611496439,
+  8.0975537628604907,
+  11.396466739595867,
+  14.623077742393873,
+  17.81845523294552,
+  20.997284754187761,
+  24.166235758581828,
+  27.328799850405162,
+  30.486989604098659,
+  33.642049384702463,
+  36.794791029185579,
+  39.945767226378749,
+  43.095367507846703,
+  46.2438744334407,
+  49.391498015725107],
+ [5.6451478942208959,
+  9.3616206152445429,
+  12.730144474090465,
+  15.999627085382479,
+  19.22442895931681,
+  22.424810599698521,
+  25.610267054939328,
+  28.785893657666548,
+  31.954686680031668,
+  35.118529525584828,
+  38.278668089521758,
+  41.435960629910073,
+  44.591018225353424,
+  47.744288086361052,
+  50.896105199722123],
+ [6.7471838248710219,
+  10.597176726782031,
+  14.033804104911233,
+  17.347086393228382,
+  20.602899017175335,
+  23.826536030287532,
+  27.030134937138834,
+  30.220335654231385,
+  33.401105611047908,
+  36.574972486670962,
+  39.743627733020277,
+  42.908248189569535,
+  46.069679073215439,
+  49.228543693445843,
+  52.385312123112282],
+ [7.8377378223268716,
+  11.811037107609447,
+  15.313615118517857,
+  18.670704965906724,
+  21.958290897126571,
+  25.206207715021249,
+  28.429037095235496,
+  31.634879502950644,
+  34.828638524084437,
+  38.013473399691765,
+  41.19151880917741,
+  44.364272633271975,
+  47.53281875312084,
+  50.697961822183806,
+  53.860312300118388],
+ [8.919605734873789,
+  13.007711435388313,
+  16.573915129085334,
+  19.974342312352426,
+  23.293972585596648,
+  26.5667563757203,
+  29.809531451608321,
+  33.031769327150685,
+  36.239265816598239,
+  39.435790312675323,
+  42.623910919472727,
+  45.805442883111651,
+  48.981708325514764,
+  52.153694518185572,
+  55.322154420959698],
+ [9.9946283820824834,
+  14.190361295800141,
+  17.817887841179873,
+  21.26093227125945,
+  24.612576377421522,
+  27.910524883974868,
+  31.173701563441602,
+  34.412862242025045,
+  37.634648706110989,
+  40.843415321050884,
+  44.04214994542435,
+  47.232978012841169,
+  50.417456447370186,
+  53.596753874948731,
+  56.771765754432457],
+ [11.064090256031013,
+  15.361301343575925,
+  19.047949646361388,
+  22.532765416313869,
+  25.91620496332662,
+  29.2394205079349,
+  32.523270869465881,
+  35.779715464475261,
+  39.016196664616095,
+  42.237627509803703,
+  45.4474001519274,
+  48.647941127433196,
+  51.841036928216499,
+  55.028034667184916,
+  58.209970905250097],
+ [12.128927704415439,
+  16.522284394784426,
+  20.265984501212254,
+  23.791669719454272,
+  27.206568881574774,
+  30.555020011020762,
+  33.859683872746356,
+  37.133649760307504,
+  40.385117593813002,
+  43.619533085646856,
+  46.840676630553575,
+  50.051265851897857,
+  53.253310556711732,
+  56.448332488918971,
+  59.637507005589829],
+ [13.189846995683845,
+  17.674674253171487,
+  21.473493977824902,
+  25.03913093040942,
+  28.485081336558058,
+  31.858644293774859,
+  35.184165245422787,
+  38.475796636190897,
+  41.742455848758449,
+  44.990096293791186,
+  48.222870660068338,
+  51.443777308699826,
+  54.655042589416311,
+  57.858358441436511,
+  61.055036135780528],
+ [14.247395665073945,
+  18.819555894710682,
+  22.671697117872794,
+  26.276375544903892,
+  29.752925495549038,
+  33.151412708998983,
+  36.497763772987645,
+  39.807134090704376,
+  43.089121522203808,
+  46.350163579538652,
+  49.594769786270069,
+  52.82620892320143,
+  56.046916910756961,
+  59.258751140598783,
+  62.463155567737854],
+ [15.30200785858925,
+  19.957808654258601,
+  23.861599172945054,
+  27.504429642227545,
+  31.011103429019229,
+  34.434283425782942,
+  37.801385632318459,
+  41.128514139788358,
+  44.425913324440663,
+  47.700482714581842,
+  50.957073905278458,
+  54.199216028087261,
+  57.429547607017405,
+  60.65008661807661,
+  63.862406280068586],
+ [16.354034360047551,
+  21.090156519983806,
+  25.044040298785627,
+  28.724161640881914,
+  32.260472459522644,
+  35.708083982611664,
+  39.095820003878235,
+  42.440684315990936,
+  45.75353669045622,
+  49.041718113283529,
+  52.310408280968073,
+  55.56338698149062,
+  58.803488508906895,
+  62.032886550960831,
+  65.253280088312461]]
+
+ynp_small_zeros = \
+[[2.197141326031017,
+  5.4296810407941351,
+  8.5960058683311689,
+  11.749154830839881,
+  14.897442128336725,
+  18.043402276727856,
+  21.188068934142213,
+  24.331942571356912,
+  27.475294980449224,
+  30.618286491641115,
+  33.761017796109326,
+  36.90355531614295,
+  40.045944640266876,
+  43.188218097393211,
+  46.330399250701687],
+ [3.6830228565851777,
+  6.9414999536541757,
+  10.123404655436613,
+  13.285758156782854,
+  16.440058007293282,
+  19.590241756629495,
+  22.738034717396327,
+  25.884314618788867,
+  29.029575819372535,
+  32.174118233366201,
+  35.318134458192094,
+  38.461753870997549,
+  41.605066618873108,
+  44.74813744908079,
+  47.891014070791065],
+ [5.0025829314460639,
+  8.3507247014130795,
+  11.574195465217647,
+  14.760909306207676,
+  17.931285939466855,
+  21.092894504412739,
+  24.249231678519058,
+  27.402145837145258,
+  30.552708880564553,
+  33.70158627151572,
+  36.849213419846257,
+  39.995887376143356,
+  43.141817835750686,
+  46.287157097544201,
+  49.432018469138281],
+ [6.2536332084598136,
+  9.6987879841487711,
+  12.972409052292216,
+  16.19044719506921,
+  19.38238844973613,
+  22.559791857764261,
+  25.728213194724094,
+  28.890678419054777,
+  32.048984005266337,
+  35.204266606440635,
+  38.357281675961019,
+  41.508551443818436,
+  44.658448731963676,
+  47.807246956681162,
+  50.95515126455207],
+ [7.4649217367571329,
+  11.005169149809189,
+  14.3317235192331,
+  17.58443601710272,
+  20.801062338411128,
+  23.997004122902644,
+  27.179886689853435,
+  30.353960608554323,
+  33.521797098666792,
+  36.685048382072301,
+  39.844826969405863,
+  43.001910515625288,
+  46.15685955107263,
+  49.310088614282257,
+  52.461911043685864],
+ [8.6495562436971983,
+  12.280868725807848,
+  15.660799304540377,
+  18.949739756016503,
+  22.192841809428241,
+  25.409072788867674,
+  28.608039283077593,
+  31.795195353138159,
+  34.973890634255288,
+  38.14630522169358,
+  41.313923188794905,
+  44.477791768537617,
+  47.638672065035628,
+  50.797131066967842,
+  53.953600129601663],
+ [9.8147970120105779,
+  13.532811875789828,
+  16.965526446046053,
+  20.291285512443867,
+  23.56186260680065,
+  26.799499736027237,
+  30.015665481543419,
+  33.216968050039509,
+  36.407516858984748,
+  39.590015243560459,
+  42.766320595957378,
+  45.937754257017323,
+  49.105283450953203,
+  52.269633324547373,
+  55.431358715604255],
+ [10.965152105242974,
+  14.765687379508912,
+  18.250123150217555,
+  21.612750053384621,
+  24.911310600813573,
+  28.171051927637585,
+  31.40518108895689,
+  34.621401012564177,
+  37.824552065973114,
+  41.017847386464902,
+  44.203512240871601,
+  47.3831408366063,
+  50.557907466622796,
+  53.728697478957026,
+  56.896191727313342],
+ [12.103641941939539,
+  15.982840905145284,
+  19.517731005559611,
+  22.916962141504605,
+  26.243700855690533,
+  29.525960140695407,
+  32.778568197561124,
+  36.010261572392516,
+  39.226578757802172,
+  42.43122493258747,
+  45.626783824134354,
+  48.815117837929515,
+  51.997606404328863,
+  55.175294723956816,
+  58.348990221754937],
+ [13.232403808592215,
+  17.186756572616758,
+  20.770762917490496,
+  24.206152448722253,
+  27.561059462697153,
+  30.866053571250639,
+  34.137476603379774,
+  37.385039772270268,
+  40.614946085165892,
+  43.831373184731238,
+  47.037251786726299,
+  50.234705848765229,
+  53.425316228549359,
+  56.610286079882087,
+  59.790548623216652],
+ [14.35301374369987,
+  18.379337301642568,
+  22.011118775283494,
+  25.482116178696707,
+  28.865046588695164,
+  32.192853922166294,
+  35.483296655830277,
+  38.747005493021857,
+  41.990815194320955,
+  45.219355876831731,
+  48.435892856078888,
+  51.642803925173029,
+  54.84186659475857,
+  58.034439083840155,
+  61.221578745109862],
+ [15.466672066554263,
+  19.562077985759503,
+  23.240325531101082,
+  26.746322986645901,
+  30.157042415639891,
+  33.507642948240263,
+  36.817212798512775,
+  40.097251300178642,
+  43.355193847719752,
+  46.596103410173672,
+  49.823567279972794,
+  53.040208868780832,
+  56.247996968470062,
+  59.448441365714251,
+  62.642721301357187],
+ [16.574317035530872,
+  20.73617763753932,
+  24.459631728238804,
+  27.999993668839644,
+  31.438208790267783,
+  34.811512070805535,
+  38.140243708611251,
+  41.436725143893739,
+  44.708963264433333,
+  47.962435051891027,
+  51.201037321915983,
+  54.427630745992975,
+  57.644369734615238,
+  60.852911791989989,
+  64.054555435720397],
+ [17.676697936439624,
+  21.9026148697762,
+  25.670073356263225,
+  29.244155124266438,
+  32.709534477396028,
+  36.105399554497548,
+  39.453272918267025,
+  42.766255701958017,
+  46.052899215578358,
+  49.319076602061401,
+  52.568982147952547,
+  55.805705507386287,
+  59.031580956740466,
+  62.248409689597653,
+  65.457606670836759],
+ [18.774423978290318,
+  23.06220035979272,
+  26.872520985976736,
+  30.479680663499762,
+  33.971869047372436,
+  37.390118854896324,
+  40.757072537673599,
+  44.086572292170345,
+  47.387688809191869,
+  50.66667461073936,
+  53.928009929563275,
+  57.175005343085052,
+  60.410169281219877,
+  63.635442539153021,
+  66.85235358587768]]
+
+@pytest.mark.slow
+def test_bessel_zeros_extra():
+    mp.dps = 15
+    for v in range(V):
+        for m in range(1,M+1):
+            print(v, m, "of", V, M)
+            # Twice to test cache (if used)
+            assert besseljzero(v,m).ae(jn_small_zeros[v][m-1])
+            assert besseljzero(v,m).ae(jn_small_zeros[v][m-1])
+            assert besseljzero(v,m,1).ae(jnp_small_zeros[v][m-1])
+            assert besseljzero(v,m,1).ae(jnp_small_zeros[v][m-1])
+            assert besselyzero(v,m).ae(yn_small_zeros[v][m-1])
+            assert besselyzero(v,m).ae(yn_small_zeros[v][m-1])
+            assert besselyzero(v,m,1).ae(ynp_small_zeros[v][m-1])
+            assert besselyzero(v,m,1).ae(ynp_small_zeros[v][m-1])

llmeval-env/lib/python3.10/site-packages/mpmath/tests/test_gammazeta.py

@@ -0,0 +1,698 @@
+from mpmath import *
+from mpmath.libmp import round_up, from_float, mpf_zeta_int
+
+def test_zeta_int_bug():
+    assert mpf_zeta_int(0, 10) == from_float(-0.5)
+
+def test_bernoulli():
+    assert bernfrac(0) == (1,1)
+    assert bernfrac(1) == (-1,2)
+    assert bernfrac(2) == (1,6)
+    assert bernfrac(3) == (0,1)
+    assert bernfrac(4) == (-1,30)
+    assert bernfrac(5) == (0,1)
+    assert bernfrac(6) == (1,42)
+    assert bernfrac(8) == (-1,30)
+    assert bernfrac(10) == (5,66)
+    assert bernfrac(12) == (-691,2730)
+    assert bernfrac(18) == (43867,798)
+    p, q = bernfrac(228)
+    assert p % 10**10 == 164918161
+    assert q == 625170
+    p, q = bernfrac(1000)
+    assert p % 10**10 == 7950421099
+    assert q == 342999030
+    mp.dps = 15
+    assert bernoulli(0) == 1
+    assert bernoulli(1) == -0.5
+    assert bernoulli(2).ae(1./6)
+    assert bernoulli(3) == 0
+    assert bernoulli(4).ae(-1./30)
+    assert bernoulli(5) == 0
+    assert bernoulli(6).ae(1./42)
+    assert str(bernoulli(10)) == '0.0757575757575758'
+    assert str(bernoulli(234)) == '7.62772793964344e+267'
+    assert str(bernoulli(10**5)) == '-5.82229431461335e+376755'
+    assert str(bernoulli(10**8+2)) == '1.19570355039953e+676752584'
+
+    mp.dps = 50
+    assert str(bernoulli(10)) == '0.075757575757575757575757575757575757575757575757576'
+    assert str(bernoulli(234)) == '7.6277279396434392486994969020496121553385863373331e+267'
+    assert str(bernoulli(10**5)) == '-5.8222943146133508236497045360612887555320691004308e+376755'
+    assert str(bernoulli(10**8+2)) == '1.1957035503995297272263047884604346914602088317782e+676752584'
+
+    mp.dps = 1000
+    assert bernoulli(10).ae(mpf(5)/66)
+
+    mp.dps = 50000
+    assert bernoulli(10).ae(mpf(5)/66)
+
+    mp.dps = 15
+
+def test_bernpoly_eulerpoly():
+    mp.dps = 15
+    assert bernpoly(0,-1).ae(1)
+    assert bernpoly(0,0).ae(1)
+    assert bernpoly(0,'1/2').ae(1)
+    assert bernpoly(0,'3/4').ae(1)
+    assert bernpoly(0,1).ae(1)
+    assert bernpoly(0,2).ae(1)
+    assert bernpoly(1,-1).ae('-3/2')
+    assert bernpoly(1,0).ae('-1/2')
+    assert bernpoly(1,'1/2').ae(0)
+    assert bernpoly(1,'3/4').ae('1/4')
+    assert bernpoly(1,1).ae('1/2')
+    assert bernpoly(1,2).ae('3/2')
+    assert bernpoly(2,-1).ae('13/6')
+    assert bernpoly(2,0).ae('1/6')
+    assert bernpoly(2,'1/2').ae('-1/12')
+    assert bernpoly(2,'3/4').ae('-1/48')
+    assert bernpoly(2,1).ae('1/6')
+    assert bernpoly(2,2).ae('13/6')
+    assert bernpoly(3,-1).ae(-3)
+    assert bernpoly(3,0).ae(0)
+    assert bernpoly(3,'1/2').ae(0)
+    assert bernpoly(3,'3/4').ae('-3/64')
+    assert bernpoly(3,1).ae(0)
+    assert bernpoly(3,2).ae(3)
+    assert bernpoly(4,-1).ae('119/30')
+    assert bernpoly(4,0).ae('-1/30')
+    assert bernpoly(4,'1/2').ae('7/240')
+    assert bernpoly(4,'3/4').ae('7/3840')
+    assert bernpoly(4,1).ae('-1/30')
+    assert bernpoly(4,2).ae('119/30')
+    assert bernpoly(5,-1).ae(-5)
+    assert bernpoly(5,0).ae(0)
+    assert bernpoly(5,'1/2').ae(0)
+    assert bernpoly(5,'3/4').ae('25/1024')
+    assert bernpoly(5,1).ae(0)
+    assert bernpoly(5,2).ae(5)
+    assert bernpoly(10,-1).ae('665/66')
+    assert bernpoly(10,0).ae('5/66')
+    assert bernpoly(10,'1/2').ae('-2555/33792')
+    assert bernpoly(10,'3/4').ae('-2555/34603008')
+    assert bernpoly(10,1).ae('5/66')
+    assert bernpoly(10,2).ae('665/66')
+    assert bernpoly(11,-1).ae(-11)
+    assert bernpoly(11,0).ae(0)
+    assert bernpoly(11,'1/2').ae(0)
+    assert bernpoly(11,'3/4').ae('-555731/4194304')
+    assert bernpoly(11,1).ae(0)
+    assert bernpoly(11,2).ae(11)
+    assert eulerpoly(0,-1).ae(1)
+    assert eulerpoly(0,0).ae(1)
+    assert eulerpoly(0,'1/2').ae(1)
+    assert eulerpoly(0,'3/4').ae(1)
+    assert eulerpoly(0,1).ae(1)
+    assert eulerpoly(0,2).ae(1)
+    assert eulerpoly(1,-1).ae('-3/2')
+    assert eulerpoly(1,0).ae('-1/2')
+    assert eulerpoly(1,'1/2').ae(0)
+    assert eulerpoly(1,'3/4').ae('1/4')
+    assert eulerpoly(1,1).ae('1/2')
+    assert eulerpoly(1,2).ae('3/2')
+    assert eulerpoly(2,-1).ae(2)
+    assert eulerpoly(2,0).ae(0)
+    assert eulerpoly(2,'1/2').ae('-1/4')
+    assert eulerpoly(2,'3/4').ae('-3/16')
+    assert eulerpoly(2,1).ae(0)
+    assert eulerpoly(2,2).ae(2)
+    assert eulerpoly(3,-1).ae('-9/4')
+    assert eulerpoly(3,0).ae('1/4')
+    assert eulerpoly(3,'1/2').ae(0)
+    assert eulerpoly(3,'3/4').ae('-11/64')
+    assert eulerpoly(3,1).ae('-1/4')
+    assert eulerpoly(3,2).ae('9/4')
+    assert eulerpoly(4,-1).ae(2)
+    assert eulerpoly(4,0).ae(0)
+    assert eulerpoly(4,'1/2').ae('5/16')
+    assert eulerpoly(4,'3/4').ae('57/256')
+    assert eulerpoly(4,1).ae(0)
+    assert eulerpoly(4,2).ae(2)
+    assert eulerpoly(5,-1).ae('-3/2')
+    assert eulerpoly(5,0).ae('-1/2')
+    assert eulerpoly(5,'1/2').ae(0)
+    assert eulerpoly(5,'3/4').ae('361/1024')
+    assert eulerpoly(5,1).ae('1/2')
+    assert eulerpoly(5,2).ae('3/2')
+    assert eulerpoly(10,-1).ae(2)
+    assert eulerpoly(10,0).ae(0)
+    assert eulerpoly(10,'1/2').ae('-50521/1024')
+    assert eulerpoly(10,'3/4').ae('-36581523/1048576')
+    assert eulerpoly(10,1).ae(0)
+    assert eulerpoly(10,2).ae(2)
+    assert eulerpoly(11,-1).ae('-699/4')
+    assert eulerpoly(11,0).ae('691/4')
+    assert eulerpoly(11,'1/2').ae(0)
+    assert eulerpoly(11,'3/4').ae('-512343611/4194304')
+    assert eulerpoly(11,1).ae('-691/4')
+    assert eulerpoly(11,2).ae('699/4')
+    # Potential accuracy issues
+    assert bernpoly(10000,10000).ae('5.8196915936323387117e+39999')
+    assert bernpoly(200,17.5).ae(3.8048418524583064909e244)
+    assert eulerpoly(200,17.5).ae(-3.7309911582655785929e275)
+
+def test_gamma():
+    mp.dps = 15
+    assert gamma(0.25).ae(3.6256099082219083119)
+    assert gamma(0.0001).ae(9999.4228832316241908)
+    assert gamma(300).ae('1.0201917073881354535e612')
+    assert gamma(-0.5).ae(-3.5449077018110320546)
+    assert gamma(-7.43).ae(0.00026524416464197007186)
+    #assert gamma(Rational(1,2)) == gamma(0.5)
+    #assert gamma(Rational(-7,3)).ae(gamma(mpf(-7)/3))
+    assert gamma(1+1j).ae(0.49801566811835604271 - 0.15494982830181068512j)
+    assert gamma(-1+0.01j).ae(-0.422733904013474115 + 99.985883082635367436j)
+    assert gamma(20+30j).ae(-1453876687.5534810 + 1163777777.8031573j)
+    # Should always give exact factorials when they can
+    # be represented as mpfs under the current working precision
+    fact = 1
+    for i in range(1, 18):
+        assert gamma(i) == fact
+        fact *= i
+    for dps in [170, 600]:
+        fact = 1
+        mp.dps = dps
+        for i in range(1, 105):
+            assert gamma(i) == fact
+            fact *= i
+    mp.dps = 100
+    assert gamma(0.5).ae(sqrt(pi))
+    mp.dps = 15
+    assert factorial(0) == fac(0) == 1
+    assert factorial(3) == 6
+    assert isnan(gamma(nan))
+    assert gamma(1100).ae('4.8579168073569433667e2866')
+    assert rgamma(0) == 0
+    assert rgamma(-1) == 0
+    assert rgamma(2) == 1.0
+    assert rgamma(3) == 0.5
+    assert loggamma(2+8j).ae(-8.5205176753667636926 + 10.8569497125597429366j)
+    assert loggamma('1e10000').ae('2.302485092994045684017991e10004')
+    assert loggamma('1e10000j').ae(mpc('-1.570796326794896619231322e10000','2.302485092994045684017991e10004'))
+
+def test_fac2():
+    mp.dps = 15
+    assert [fac2(n) for n in range(10)] == [1,1,2,3,8,15,48,105,384,945]
+    assert fac2(-5).ae(1./3)
+    assert fac2(-11).ae(-1./945)
+    assert fac2(50).ae(5.20469842636666623e32)
+    assert fac2(0.5+0.75j).ae(0.81546769394688069176-0.34901016085573266889j)
+    assert fac2(inf) == inf
+    assert isnan(fac2(-inf))
+
+def test_gamma_quotients():
+    mp.dps = 15
+    h = 1e-8
+    ep = 1e-4
+    G = gamma
+    assert gammaprod([-1],[-3,-4]) == 0
+    assert gammaprod([-1,0],[-5]) == inf
+    assert abs(gammaprod([-1],[-2]) - G(-1+h)/G(-2+h)) < 1e-4
+    assert abs(gammaprod([-4,-3],[-2,0]) - G(-4+h)*G(-3+h)/G(-2+h)/G(0+h)) < 1e-4
+    assert rf(3,0) == 1
+    assert rf(2.5,1) == 2.5
+    assert rf(-5,2) == 20
+    assert rf(j,j).ae(gamma(2*j)/gamma(j))
+    assert rf('-255.5815971722918','-0.5119253100282322').ae('-0.1952720278805729485')  # issue 421
+    assert ff(-2,0) == 1
+    assert ff(-2,1) == -2
+    assert ff(4,3) == 24
+    assert ff(3,4) == 0
+    assert binomial(0,0) == 1
+    assert binomial(1,0) == 1
+    assert binomial(0,-1) == 0
+    assert binomial(3,2) == 3
+    assert binomial(5,2) == 10
+    assert binomial(5,3) == 10
+    assert binomial(5,5) == 1
+    assert binomial(-1,0) == 1
+    assert binomial(-2,-4) == 3
+    assert binomial(4.5, 1.5) == 6.5625
+    assert binomial(1100,1) == 1100
+    assert binomial(1100,2) == 604450
+    assert beta(1,1) == 1
+    assert beta(0,0) == inf
+    assert beta(3,0) == inf
+    assert beta(-1,-1) == inf
+    assert beta(1.5,1).ae(2/3.)
+    assert beta(1.5,2.5).ae(pi/16)
+    assert (10**15*beta(10,100)).ae(2.3455339739604649879)
+    assert beta(inf,inf) == 0
+    assert isnan(beta(-inf,inf))
+    assert isnan(beta(-3,inf))
+    assert isnan(beta(0,inf))
+    assert beta(inf,0.5) == beta(0.5,inf) == 0
+    assert beta(inf,-1.5) == inf
+    assert beta(inf,-0.5) == -inf
+    assert beta(1+2j,-1-j/2).ae(1.16396542451069943086+0.08511695947832914640j)
+    assert beta(-0.5,0.5) == 0
+    assert beta(-3,3).ae(-1/3.)
+    assert beta('-255.5815971722918','-0.5119253100282322').ae('18.157330562703710339')  # issue 421
+
+def test_zeta():
+    mp.dps = 15
+    assert zeta(2).ae(pi**2 / 6)
+    assert zeta(2.0).ae(pi**2 / 6)
+    assert zeta(mpc(2)).ae(pi**2 / 6)
+    assert zeta(100).ae(1)
+    assert zeta(0).ae(-0.5)
+    assert zeta(0.5).ae(-1.46035450880958681)
+    assert zeta(-1).ae(-mpf(1)/12)
+    assert zeta(-2) == 0
+    assert zeta(-3).ae(mpf(1)/120)
+    assert zeta(-4) == 0
+    assert zeta(-100) == 0
+    assert isnan(zeta(nan))
+    assert zeta(1e-30).ae(-0.5)
+    assert zeta(-1e-30).ae(-0.5)
+    # Zeros in the critical strip
+    assert zeta(mpc(0.5, 14.1347251417346937904)).ae(0)
+    assert zeta(mpc(0.5, 21.0220396387715549926)).ae(0)
+    assert zeta(mpc(0.5, 25.0108575801456887632)).ae(0)
+    assert zeta(mpc(1e-30,1e-40)).ae(-0.5)
+    assert zeta(mpc(-1e-30,1e-40)).ae(-0.5)
+    mp.dps = 50
+    im = '236.5242296658162058024755079556629786895294952121891237'
+    assert zeta(mpc(0.5, im)).ae(0, 1e-46)
+    mp.dps = 15
+    # Complex reflection formula
+    assert (zeta(-60+3j) / 10**34).ae(8.6270183987866146+15.337398548226238j)
+    # issue #358
+    assert zeta(0,0.5) == 0
+    assert zeta(0,0) == 0.5
+    assert zeta(0,0.5,1).ae(-0.34657359027997265)
+    # see issue #390
+    assert zeta(-1.5,0.5j).ae(-0.13671400162512768475 + 0.11411333638426559139j)
+
+def test_altzeta():
+    mp.dps = 15
+    assert altzeta(-2) == 0
+    assert altzeta(-4) == 0
+    assert altzeta(-100) == 0
+    assert altzeta(0) == 0.5
+    assert altzeta(-1) == 0.25
+    assert altzeta(-3) == -0.125
+    assert altzeta(-5) == 0.25
+    assert altzeta(-21) == 1180529130.25
+    assert altzeta(1).ae(log(2))
+    assert altzeta(2).ae(pi**2/12)
+    assert altzeta(10).ae(73*pi**10/6842880)
+    assert altzeta(50) < 1
+    assert altzeta(60, rounding='d') < 1
+    assert altzeta(60, rounding='u') == 1
+    assert altzeta(10000, rounding='d') < 1
+    assert altzeta(10000, rounding='u') == 1
+    assert altzeta(3+0j) == altzeta(3)
+    s = 3+4j
+    assert altzeta(s).ae((1-2**(1-s))*zeta(s))
+    s = -3+4j
+    assert altzeta(s).ae((1-2**(1-s))*zeta(s))
+    assert altzeta(-100.5).ae(4.58595480083585913e+108)
+    assert altzeta(1.3).ae(0.73821404216623045)
+    assert altzeta(1e-30).ae(0.5)
+    assert altzeta(-1e-30).ae(0.5)
+    assert altzeta(mpc(1e-30,1e-40)).ae(0.5)
+    assert altzeta(mpc(-1e-30,1e-40)).ae(0.5)
+
+def test_zeta_huge():
+    mp.dps = 15
+    assert zeta(inf) == 1
+    mp.dps = 50
+    assert zeta(100).ae('1.0000000000000000000000000000007888609052210118073522')
+    assert zeta(40*pi).ae('1.0000000000000000000000000000000000000148407238666182')
+    mp.dps = 10000
+    v = zeta(33000)
+    mp.dps = 15
+    assert str(v-1) == '1.02363019598118e-9934'
+    assert zeta(pi*1000, rounding=round_up) > 1
+    assert zeta(3000, rounding=round_up) > 1
+    assert zeta(pi*1000) == 1
+    assert zeta(3000) == 1
+
+def test_zeta_negative():
+    mp.dps = 150
+    a = -pi*10**40
+    mp.dps = 15
+    assert str(zeta(a)) == '2.55880492708712e+1233536161668617575553892558646631323374078'
+    mp.dps = 50
+    assert str(zeta(a)) == '2.5588049270871154960875033337384432038436330847333e+1233536161668617575553892558646631323374078'
+    mp.dps = 15
+
+def test_polygamma():
+    mp.dps = 15
+    psi0 = lambda z: psi(0,z)
+    psi1 = lambda z: psi(1,z)
+    assert psi0(3) == psi(0,3) == digamma(3)
+    #assert psi2(3) == psi(2,3) == tetragamma(3)
+    #assert psi3(3) == psi(3,3) == pentagamma(3)
+    assert psi0(pi).ae(0.97721330794200673)
+    assert psi0(-pi).ae(7.8859523853854902)
+    assert psi0(-pi+1).ae(7.5676424992016996)
+    assert psi0(pi+j).ae(1.04224048313859376 + 0.35853686544063749j)
+    assert psi0(-pi-j).ae(1.3404026194821986 - 2.8824392476809402j)
+    assert findroot(psi0, 1).ae(1.4616321449683622)
+    assert psi0(1e-10).ae(-10000000000.57722)
+    assert psi0(1e-40).ae(-1.000000000000000e+40)
+    assert psi0(1e-10+1e-10j).ae(-5000000000.577215 + 5000000000.000000j)
+    assert psi0(1e-40+1e-40j).ae(-5.000000000000000e+39 + 5.000000000000000e+39j)
+    assert psi0(inf) == inf
+    assert psi1(inf) == 0
+    assert psi(2,inf) == 0
+    assert psi1(pi).ae(0.37424376965420049)
+    assert psi1(-pi).ae(53.030438740085385)
+    assert psi1(pi+j).ae(0.32935710377142464 - 0.12222163911221135j)
+    assert psi1(-pi-j).ae(-0.30065008356019703 + 0.01149892486928227j)
+    assert (10**6*psi(4,1+10*pi*j)).ae(-6.1491803479004446 - 0.3921316371664063j)
+    assert psi0(1+10*pi*j).ae(3.4473994217222650 + 1.5548808324857071j)
+    assert isnan(psi0(nan))
+    assert isnan(psi0(-inf))
+    assert psi0(-100.5).ae(4.615124601338064)
+    assert psi0(3+0j).ae(psi0(3))
+    assert psi0(-100+3j).ae(4.6106071768714086321+3.1117510556817394626j)
+    assert isnan(psi(2,mpc(0,inf)))
+    assert isnan(psi(2,mpc(0,nan)))
+    assert isnan(psi(2,mpc(0,-inf)))
+    assert isnan(psi(2,mpc(1,inf)))
+    assert isnan(psi(2,mpc(1,nan)))
+    assert isnan(psi(2,mpc(1,-inf)))
+    assert isnan(psi(2,mpc(inf,inf)))
+    assert isnan(psi(2,mpc(nan,nan)))
+    assert isnan(psi(2,mpc(-inf,-inf)))
+    mp.dps = 30
+    # issue #534
+    assert digamma(-0.75+1j).ae(mpc('0.46317279488182026118963809283042317', '2.4821070143037957102007677817351115'))
+    mp.dps = 15
+
+def test_polygamma_high_prec():
+    mp.dps = 100
+    assert str(psi(0,pi)) == "0.9772133079420067332920694864061823436408346099943256380095232865318105924777141317302075654362928734"
+    assert str(psi(10,pi)) == "-12.98876181434889529310283769414222588307175962213707170773803550518307617769657562747174101900659238"
+
+def test_polygamma_identities():
+    mp.dps = 15
+    psi0 = lambda z: psi(0,z)
+    psi1 = lambda z: psi(1,z)
+    psi2 = lambda z: psi(2,z)
+    assert psi0(0.5).ae(-euler-2*log(2))
+    assert psi0(1).ae(-euler)
+    assert psi1(0.5).ae(0.5*pi**2)
+    assert psi1(1).ae(pi**2/6)
+    assert psi1(0.25).ae(pi**2 + 8*catalan)
+    assert psi2(1).ae(-2*apery)
+    mp.dps = 20
+    u = -182*apery+4*sqrt(3)*pi**3
+    mp.dps = 15
+    assert psi(2,5/6.).ae(u)
+    assert psi(3,0.5).ae(pi**4)
+
+def test_foxtrot_identity():
+    # A test of the complex digamma function.
+    # See http://mathworld.wolfram.com/FoxTrotSeries.html and
+    # http://mathworld.wolfram.com/DigammaFunction.html
+    psi0 = lambda z: psi(0,z)
+    mp.dps = 50
+    a = (-1)**fraction(1,3)
+    b = (-1)**fraction(2,3)
+    x = -psi0(0.5*a) - psi0(-0.5*b) + psi0(0.5*(1+a)) + psi0(0.5*(1-b))
+    y = 2*pi*sech(0.5*sqrt(3)*pi)
+    assert x.ae(y)
+    mp.dps = 15
+
+def test_polygamma_high_order():
+    mp.dps = 100
+    assert str(psi(50, pi)) == "-1344100348958402765749252447726432491812.641985273160531055707095989227897753035823152397679626136483"
+    assert str(psi(50, pi + 14*e)) == "-0.00000000000000000189793739550804321623512073101895801993019919886375952881053090844591920308111549337295143780341396"
+    assert str(psi(50, pi + 14*e*j)) == ("(-0.0000000000000000522516941152169248975225472155683565752375889510631513244785"
+        "9377385233700094871256507814151956624433 - 0.00000000000000001813157041407010184"
+        "702414110218205348527862196327980417757665282244728963891298080199341480881811613j)")
+    mp.dps = 15
+    assert str(psi(50, pi)) == "-1.34410034895841e+39"
+    assert str(psi(50, pi + 14*e)) == "-1.89793739550804e-18"
+    assert str(psi(50, pi + 14*e*j)) == "(-5.2251694115217e-17 - 1.81315704140701e-17j)"
+
+def test_harmonic():
+    mp.dps = 15
+    assert harmonic(0) == 0
+    assert harmonic(1) == 1
+    assert harmonic(2) == 1.5
+    assert harmonic(3).ae(1. + 1./2 + 1./3)
+    assert harmonic(10**10).ae(23.603066594891989701)
+    assert harmonic(10**1000).ae(2303.162308658947)
+    assert harmonic(0.5).ae(2-2*log(2))
+    assert harmonic(inf) == inf
+    assert harmonic(2+0j) == 1.5+0j
+    assert harmonic(1+2j).ae(1.4918071802755104+0.92080728264223022j)
+
+def test_gamma_huge_1():
+    mp.dps = 500
+    x = mpf(10**10) / 7
+    mp.dps = 15
+    assert str(gamma(x)) == "6.26075321389519e+12458010678"
+    mp.dps = 50
+    assert str(gamma(x)) == "6.2607532138951929201303779291707455874010420783933e+12458010678"
+    mp.dps = 15
+
+def test_gamma_huge_2():
+    mp.dps = 500
+    x = mpf(10**100) / 19
+    mp.dps = 15
+    assert str(gamma(x)) == (\
+        "1.82341134776679e+5172997469323364168990133558175077136829182824042201886051511"
+        "9656908623426021308685461258226190190661")
+    mp.dps = 50
+    assert str(gamma(x)) == (\
+        "1.82341134776678875374414910350027596939980412984e+5172997469323364168990133558"
+        "1750771368291828240422018860515119656908623426021308685461258226190190661")
+
+def test_gamma_huge_3():
+    mp.dps = 500
+    x = 10**80 // 3 + 10**70*j / 7
+    mp.dps = 15
+    y = gamma(x)
+    assert str(y.real) == (\
+        "-6.82925203918106e+2636286142112569524501781477865238132302397236429627932441916"
+        "056964386399485392600")
+    assert str(y.imag) == (\
+        "8.54647143678418e+26362861421125695245017814778652381323023972364296279324419160"
+        "56964386399485392600")
+    mp.dps = 50
+    y = gamma(x)
+    assert str(y.real) == (\
+        "-6.8292520391810548460682736226799637356016538421817e+26362861421125695245017814"
+        "77865238132302397236429627932441916056964386399485392600")
+    assert str(y.imag) == (\
+        "8.5464714367841748507479306948130687511711420234015e+263628614211256952450178147"
+        "7865238132302397236429627932441916056964386399485392600")
+
+def test_gamma_huge_4():
+    x = 3200+11500j
+    mp.dps = 15
+    assert str(gamma(x)) == \
+        "(8.95783268539713e+5164 - 1.94678798329735e+5164j)"
+    mp.dps = 50
+    assert str(gamma(x)) == (\
+        "(8.9578326853971339570292952697675570822206567327092e+5164"
+        " - 1.9467879832973509568895402139429643650329524144794e+51"
+        "64j)")
+    mp.dps = 15
+
+def test_gamma_huge_5():
+    mp.dps = 500
+    x = 10**60 * j / 3
+    mp.dps = 15
+    y = gamma(x)
+    assert str(y.real) == "-3.27753899634941e-227396058973640224580963937571892628368354580620654233316839"
+    assert str(y.imag) == "-7.1519888950416e-227396058973640224580963937571892628368354580620654233316841"
+    mp.dps = 50
+    y = gamma(x)
+    assert str(y.real) == (\
+        "-3.2775389963494132168950056995974690946983219123935e-22739605897364022458096393"
+        "7571892628368354580620654233316839")
+    assert str(y.imag) == (\
+        "-7.1519888950415979749736749222530209713136588885897e-22739605897364022458096393"
+        "7571892628368354580620654233316841")
+    mp.dps = 15
+
+def test_gamma_huge_7():
+    mp.dps = 100
+    a = 3 + j/mpf(10)**1000
+    mp.dps = 15
+    y = gamma(a)
+    assert str(y.real) == "2.0"
+    # wrong
+    #assert str(y.imag) == "2.16735365342606e-1000"
+    assert str(y.imag) == "1.84556867019693e-1000"
+    mp.dps = 50
+    y = gamma(a)
+    assert str(y.real) == "2.0"
+    #assert str(y.imag) == "2.1673536534260596065418805612488708028522563689298e-1000"
+    assert str(y.imag) ==  "1.8455686701969342787869758198351951379156813281202e-1000"
+
+def test_stieltjes():
+    mp.dps = 15
+    assert stieltjes(0).ae(+euler)
+    mp.dps = 25
+    assert stieltjes(1).ae('-0.07281584548367672486058637587')
+    assert stieltjes(2).ae('-0.009690363192872318484530386035')
+    assert stieltjes(3).ae('0.002053834420303345866160046543')
+    assert stieltjes(4).ae('0.002325370065467300057468170178')
+    mp.dps = 15
+    assert stieltjes(1).ae(-0.07281584548367672486058637587)
+    assert stieltjes(2).ae(-0.009690363192872318484530386035)
+    assert stieltjes(3).ae(0.002053834420303345866160046543)
+    assert stieltjes(4).ae(0.0023253700654673000574681701775)
+
+def test_barnesg():
+    mp.dps = 15
+    assert barnesg(0) == barnesg(-1) == 0
+    assert [superfac(i) for i in range(8)] == [1, 1, 2, 12, 288, 34560, 24883200, 125411328000]
+    assert str(superfac(1000)) == '3.24570818422368e+1177245'
+    assert isnan(barnesg(nan))
+    assert isnan(superfac(nan))
+    assert isnan(hyperfac(nan))
+    assert barnesg(inf) == inf
+    assert superfac(inf) == inf
+    assert hyperfac(inf) == inf
+    assert isnan(superfac(-inf))
+    assert barnesg(0.7).ae(0.8068722730141471)
+    assert barnesg(2+3j).ae(-0.17810213864082169+0.04504542715447838j)
+    assert [hyperfac(n) for n in range(7)] == [1, 1, 4, 108, 27648, 86400000, 4031078400000]
+    assert [hyperfac(n) for n in range(0,-7,-1)] == [1,1,-1,-4,108,27648,-86400000]
+    a = barnesg(-3+0j)
+    assert a == 0 and isinstance(a, mpc)
+    a = hyperfac(-3+0j)
+    assert a == -4 and isinstance(a, mpc)
+
+def test_polylog():
+    mp.dps = 15
+    zs = [mpmathify(z) for z in [0, 0.5, 0.99, 4, -0.5, -4, 1j, 3+4j]]
+    for z in zs: assert polylog(1, z).ae(-log(1-z))
+    for z in zs: assert polylog(0, z).ae(z/(1-z))
+    for z in zs: assert polylog(-1, z).ae(z/(1-z)**2)
+    for z in zs: assert polylog(-2, z).ae(z*(1+z)/(1-z)**3)
+    for z in zs: assert polylog(-3, z).ae(z*(1+4*z+z**2)/(1-z)**4)
+    assert polylog(3, 7).ae(5.3192579921456754382-5.9479244480803301023j)
+    assert polylog(3, -7).ae(-4.5693548977219423182)
+    assert polylog(2, 0.9).ae(1.2997147230049587252)
+    assert polylog(2, -0.9).ae(-0.75216317921726162037)
+    assert polylog(2, 0.9j).ae(-0.17177943786580149299+0.83598828572550503226j)
+    assert polylog(2, 1.1).ae(1.9619991013055685931-0.2994257606855892575j)
+    assert polylog(2, -1.1).ae(-0.89083809026228260587)
+    assert polylog(2, 1.1*sqrt(j)).ae(0.58841571107611387722+1.09962542118827026011j)
+    assert polylog(-2, 0.9).ae(1710)
+    assert polylog(-2, -0.9).ae(-90/6859.)
+    assert polylog(3, 0.9).ae(1.0496589501864398696)
+    assert polylog(-3, 0.9).ae(48690)
+    assert polylog(-3, -4).ae(-0.0064)
+    assert polylog(0.5+j/3, 0.5+j/2).ae(0.31739144796565650535 + 0.99255390416556261437j)
+    assert polylog(3+4j,1).ae(zeta(3+4j))
+    assert polylog(3+4j,-1).ae(-altzeta(3+4j))
+    # issue 390
+    assert polylog(1.5, -48.910886523731889).ae(-6.272992229311817)
+    assert polylog(1.5, 200).ae(-8.349608319033686529 - 8.159694826434266042j)
+    assert polylog(-2+0j, -2).ae(mpf(1)/13.5)
+    assert polylog(-2+0j, 1.25).ae(-180)
+
+def test_bell_polyexp():
+    mp.dps = 15
+    # TODO: more tests for polyexp
+    assert (polyexp(0,1e-10)*10**10).ae(1.00000000005)
+    assert (polyexp(1,1e-10)*10**10).ae(1.0000000001)
+    assert polyexp(5,3j).ae(-607.7044517476176454+519.962786482001476087j)
+    assert polyexp(-1,3.5).ae(12.09537536175543444)
+    # bell(0,x) = 1
+    assert bell(0,0) == 1
+    assert bell(0,1) == 1
+    assert bell(0,2) == 1
+    assert bell(0,inf) == 1
+    assert bell(0,-inf) == 1
+    assert isnan(bell(0,nan))
+    # bell(1,x) = x
+    assert bell(1,4) == 4
+    assert bell(1,0) == 0
+    assert bell(1,inf) == inf
+    assert bell(1,-inf) == -inf
+    assert isnan(bell(1,nan))
+    # bell(2,x) = x*(1+x)
+    assert bell(2,-1) == 0
+    assert bell(2,0) == 0
+    # large orders / arguments
+    assert bell(10) == 115975
+    assert bell(10,1) == 115975
+    assert bell(10, -8) == 11054008
+    assert bell(5,-50) == -253087550
+    assert bell(50,-50).ae('3.4746902914629720259e74')
+    mp.dps = 80
+    assert bell(50,-50) == 347469029146297202586097646631767227177164818163463279814268368579055777450
+    assert bell(40,50) == 5575520134721105844739265207408344706846955281965031698187656176321717550
+    assert bell(74) == 5006908024247925379707076470957722220463116781409659160159536981161298714301202
+    mp.dps = 15
+    assert bell(10,20j) == 7504528595600+15649605360020j
+    # continuity of the generalization
+    assert bell(0.5,0).ae(sinc(pi*0.5))
+
+def test_primezeta():
+    mp.dps = 15
+    assert primezeta(0.9).ae(1.8388316154446882243 + 3.1415926535897932385j)
+    assert primezeta(4).ae(0.076993139764246844943)
+    assert primezeta(1) == inf
+    assert primezeta(inf) == 0
+    assert isnan(primezeta(nan))
+
+def test_rs_zeta():
+    mp.dps = 15
+    assert zeta(0.5+100000j).ae(1.0730320148577531321 + 5.7808485443635039843j)
+    assert zeta(0.75+100000j).ae(1.837852337251873704 + 1.9988492668661145358j)
+    assert zeta(0.5+1000000j, derivative=3).ae(1647.7744105852674733 - 1423.1270943036622097j)
+    assert zeta(1+1000000j, derivative=3).ae(3.4085866124523582894 - 18.179184721525947301j)
+    assert zeta(1+1000000j, derivative=1).ae(-0.10423479366985452134 - 0.74728992803359056244j)
+    assert zeta(0.5-1000000j, derivative=1).ae(11.636804066002521459 + 17.127254072212996004j)
+    # Additional sanity tests using fp arithmetic.
+    # Some more high-precision tests are found in the docstrings
+    def ae(x, y, tol=1e-6):
+        return abs(x-y) < tol*abs(y)
+    assert ae(fp.zeta(0.5-100000j), 1.0730320148577531321 - 5.7808485443635039843j)
+    assert ae(fp.zeta(0.75-100000j), 1.837852337251873704 - 1.9988492668661145358j)
+    assert ae(fp.zeta(0.5+1e6j), 0.076089069738227100006 + 2.8051021010192989554j)
+    assert ae(fp.zeta(0.5+1e6j, derivative=1), 11.636804066002521459 - 17.127254072212996004j)
+    assert ae(fp.zeta(1+1e6j), 0.94738726251047891048 + 0.59421999312091832833j)
+    assert ae(fp.zeta(1+1e6j, derivative=1), -0.10423479366985452134 - 0.74728992803359056244j)
+    assert ae(fp.zeta(0.5+100000j, derivative=1), 10.766962036817482375 - 30.92705282105996714j)
+    assert ae(fp.zeta(0.5+100000j, derivative=2), -119.40515625740538429 + 217.14780631141830251j)
+    assert ae(fp.zeta(0.5+100000j, derivative=3), 1129.7550282628460881 - 1685.4736895169690346j)
+    assert ae(fp.zeta(0.5+100000j, derivative=4), -10407.160819314958615 + 13777.786698628045085j)
+    assert ae(fp.zeta(0.75+100000j, derivative=1), -0.41742276699594321475 - 6.4453816275049955949j)
+    assert ae(fp.zeta(0.75+100000j, derivative=2), -9.214314279161977266 + 35.07290795337967899j)
+    assert ae(fp.zeta(0.75+100000j, derivative=3), 110.61331857820103469 - 236.87847130518129926j)
+    assert ae(fp.zeta(0.75+100000j, derivative=4), -1054.334275898559401 + 1769.9177890161596383j)
+
+def test_siegelz():
+    mp.dps = 15
+    assert siegelz(100000).ae(5.87959246868176504171)
+    assert siegelz(100000, derivative=2).ae(-54.1172711010126452832)
+    assert siegelz(100000, derivative=3).ae(-278.930831343966552538)
+    assert siegelz(100000+j,derivative=1).ae(678.214511857070283307-379.742160779916375413j)
+
+
+
+def test_zeta_near_1():
+    # Test for a former bug in mpf_zeta and mpc_zeta
+    mp.dps = 15
+    s1 = fadd(1, '1e-10', exact=True)
+    s2 = fadd(1, '-1e-10', exact=True)
+    s3 = fadd(1, '1e-10j', exact=True)
+    assert zeta(s1).ae(1.000000000057721566490881444e10)
+    assert zeta(s2).ae(-9.99999999942278433510574872e9)
+    z = zeta(s3)
+    assert z.real.ae(0.57721566490153286060)
+    assert z.imag.ae(-9.9999999999999999999927184e9)
+    mp.dps = 30
+    s1 = fadd(1, '1e-50', exact=True)
+    s2 = fadd(1, '-1e-50', exact=True)
+    s3 = fadd(1, '1e-50j', exact=True)
+    assert zeta(s1).ae('1e50')
+    assert zeta(s2).ae('-1e50')
+    z = zeta(s3)
+    assert z.real.ae('0.57721566490153286060651209008240243104215933593992')
+    assert z.imag.ae('-1e50')

llmeval-env/lib/python3.10/site-packages/mpmath/tests/test_hp.py

@@ -0,0 +1,291 @@
+"""
+Check that the output from irrational functions is accurate for
+high-precision input, from 5 to 200 digits. The reference values were
+verified with Mathematica.
+"""
+
+import time
+from mpmath import *
+
+precs = [5, 15, 28, 35, 57, 80, 100, 150, 200]
+
+# sqrt(3) + pi/2
+a = \
+"3.302847134363773912758768033145623809041389953497933538543279275605"\
+"841220051904536395163599428307109666700184672047856353516867399774243594"\
+"67433521615861420725323528325327484262075464241255915238845599752675"
+
+# e + 1/euler**2
+b = \
+"5.719681166601007617111261398629939965860873957353320734275716220045750"\
+"31474116300529519620938123730851145473473708966080207482581266469342214"\
+"824842256999042984813905047895479210702109260221361437411947323431"
+
+# sqrt(a)
+sqrt_a = \
+"1.817373691447021556327498239690365674922395036495564333152483422755"\
+"144321726165582817927383239308173567921345318453306994746434073691275094"\
+"484777905906961689902608644112196725896908619756404253109722911487"
+
+# sqrt(a+b*i).real
+sqrt_abi_real = \
+"2.225720098415113027729407777066107959851146508557282707197601407276"\
+"89160998185797504198062911768240808839104987021515555650875977724230130"\
+"3584116233925658621288393930286871862273400475179312570274423840384"
+
+# sqrt(a+b*i).imag
+sqrt_abi_imag = \
+"1.2849057639084690902371581529110949983261182430040898147672052833653668"\
+"0629534491275114877090834296831373498336559849050755848611854282001250"\
+"1924311019152914021365263161630765255610885489295778894976075186"
+
+# log(a)
+log_a = \
+"1.194784864491089550288313512105715261520511949410072046160598707069"\
+"4336653155025770546309137440687056366757650909754708302115204338077595203"\
+"83005773986664564927027147084436553262269459110211221152925732612"
+
+# log(a+b*i).real
+log_abi_real = \
+"1.8877985921697018111624077550443297276844736840853590212962006811663"\
+"04949387789489704203167470111267581371396245317618589339274243008242708"\
+"014251531496104028712866224020066439049377679709216784954509456421"
+
+# log(a+b*i).imag
+log_abi_imag = \
+"1.0471204952840802663567714297078763189256357109769672185219334169734948"\
+"4265809854092437285294686651806426649541504240470168212723133326542181"\
+"8300136462287639956713914482701017346851009323172531601894918640"
+
+# exp(a)
+exp_a = \
+"27.18994224087168661137253262213293847994194869430518354305430976149"\
+"382792035050358791398632888885200049857986258414049540376323785711941636"\
+"100358982497583832083513086941635049329804685212200507288797531143"
+
+# exp(a+b*i).real
+exp_abi_real = \
+"22.98606617170543596386921087657586890620262522816912505151109385026"\
+"40160179326569526152851983847133513990281518417211964710397233157168852"\
+"4963130831190142571659948419307628119985383887599493378056639916701"
+
+# exp(a+b*i).imag
+exp_abi_imag = \
+"-14.523557450291489727214750571590272774669907424478129280902375851196283"\
+"3377162379031724734050088565710975758824441845278120105728824497308303"\
+"6065619788140201636218705414429933685889542661364184694108251449"
+
+# a**b
+pow_a_b = \
+"928.7025342285568142947391505837660251004990092821305668257284426997"\
+"361966028275685583421197860603126498884545336686124793155581311527995550"\
+"580229264427202446131740932666832138634013168125809402143796691154"
+
+# (a**(a+b*i)).real
+pow_a_abi_real = \
+"44.09156071394489511956058111704382592976814280267142206420038656267"\
+"67707916510652790502399193109819563864568986234654864462095231138500505"\
+"8197456514795059492120303477512711977915544927440682508821426093455"
+
+# (a**(a+b*i)).imag
+pow_a_abi_imag = \
+"27.069371511573224750478105146737852141664955461266218367212527612279886"\
+"9322304536553254659049205414427707675802193810711302947536332040474573"\
+"8166261217563960235014674118610092944307893857862518964990092301"
+
+# ((a+b*i)**(a+b*i)).real
+pow_abi_abi_real = \
+"-0.15171310677859590091001057734676423076527145052787388589334350524"\
+"8084195882019497779202452975350579073716811284169068082670778986235179"\
+"0813026562962084477640470612184016755250592698408112493759742219150452"\
+
+# ((a+b*i)**(a+b*i)).imag
+pow_abi_abi_imag = \
+"1.2697592504953448936553147870155987153192995316950583150964099070426"\
+"4736837932577176947632535475040521749162383347758827307504526525647759"\
+"97547638617201824468382194146854367480471892602963428122896045019902"
+
+# sin(a)
+sin_a = \
+"-0.16055653857469062740274792907968048154164433772938156243509084009"\
+"38437090841460493108570147191289893388608611542655654723437248152535114"\
+"528368009465836614227575701220612124204622383149391870684288862269631"
+
+# sin(1000*a)
+sin_1000a = \
+"-0.85897040577443833776358106803777589664322997794126153477060795801"\
+"09151695416961724733492511852267067419573754315098042850381158563024337"\
+"216458577140500488715469780315833217177634490142748614625281171216863"
+
+# sin(a+b*i)
+sin_abi_real = \
+"-24.4696999681556977743346798696005278716053366404081910969773939630"\
+"7149215135459794473448465734589287491880563183624997435193637389884206"\
+"02151395451271809790360963144464736839412254746645151672423256977064"
+
+sin_abi_imag = \
+"-150.42505378241784671801405965872972765595073690984080160750785565810981"\
+"8314482499135443827055399655645954830931316357243750839088113122816583"\
+"7169201254329464271121058839499197583056427233866320456505060735"
+
+# cos
+cos_a = \
+"-0.98702664499035378399332439243967038895709261414476495730788864004"\
+"05406821549361039745258003422386169330787395654908532996287293003581554"\
+"257037193284199198069707141161341820684198547572456183525659969145501"
+
+cos_1000a = \
+"-0.51202523570982001856195696460663971099692261342827540426136215533"\
+"52686662667660613179619804463250686852463876088694806607652218586060613"\
+"951310588158830695735537073667299449753951774916401887657320950496820"
+
+# tan
+tan_a = \
+"0.162666873675188117341401059858835168007137819495998960250142156848"\
+"639654718809412181543343168174807985559916643549174530459883826451064966"\
+"7996119428949951351938178809444268785629011625179962457123195557310"
+
+tan_abi_real = \
+"6.822696615947538488826586186310162599974827139564433912601918442911"\
+"1026830824380070400102213741875804368044342309515353631134074491271890"\
+"467615882710035471686578162073677173148647065131872116479947620E-6"
+
+tan_abi_imag = \
+"0.9999795833048243692245661011298447587046967777739649018690797625964167"\
+"1446419978852235960862841608081413169601038230073129482874832053357571"\
+"62702259309150715669026865777947502665936317953101462202542168429"
+
+
+def test_hp():
+    for dps in precs:
+        mp.dps = dps + 8
+        aa = mpf(a)
+        bb = mpf(b)
+        a1000 = 1000*mpf(a)
+        abi = mpc(aa, bb)
+        mp.dps = dps
+        assert (sqrt(3) + pi/2).ae(aa)
+        assert (e + 1/euler**2).ae(bb)
+
+        assert sqrt(aa).ae(mpf(sqrt_a))
+        assert sqrt(abi).ae(mpc(sqrt_abi_real, sqrt_abi_imag))
+
+        assert log(aa).ae(mpf(log_a))
+        assert log(abi).ae(mpc(log_abi_real, log_abi_imag))
+
+        assert exp(aa).ae(mpf(exp_a))
+        assert exp(abi).ae(mpc(exp_abi_real, exp_abi_imag))
+
+        assert (aa**bb).ae(mpf(pow_a_b))
+        assert (aa**abi).ae(mpc(pow_a_abi_real, pow_a_abi_imag))
+        assert (abi**abi).ae(mpc(pow_abi_abi_real, pow_abi_abi_imag))
+
+        assert sin(a).ae(mpf(sin_a))
+        assert sin(a1000).ae(mpf(sin_1000a))
+        assert sin(abi).ae(mpc(sin_abi_real, sin_abi_imag))
+
+        assert cos(a).ae(mpf(cos_a))
+        assert cos(a1000).ae(mpf(cos_1000a))
+
+        assert tan(a).ae(mpf(tan_a))
+        assert tan(abi).ae(mpc(tan_abi_real, tan_abi_imag))
+
+        # check that complex cancellation is avoided so that both
+        # real and imaginary parts have high relative accuracy.
+        # abs_eps should be 0, but has to be set to 1e-205 to pass the
+        # 200-digit case, probably due to slight inaccuracy in the
+        # precomputed input
+        assert (tan(abi).real).ae(mpf(tan_abi_real), abs_eps=1e-205)
+        assert (tan(abi).imag).ae(mpf(tan_abi_imag), abs_eps=1e-205)
+    mp.dps = 460
+    assert str(log(3))[-20:] == '02166121184001409826'
+    mp.dps = 15
+
+# Since str(a) can differ in the last digit from rounded a, and I want
+# to compare the last digits of big numbers with the results in Mathematica,
+# I made this hack to get the last 20 digits of rounded a
+
+def last_digits(a):
+    r = repr(a)
+    s = str(a)
+    #dps = mp.dps
+    #mp.dps += 3
+    m = 10
+    r = r.replace(s[:-m],'')
+    r = r.replace("mpf('",'').replace("')",'')
+    num0 = 0
+    for c in r:
+        if c == '0':
+            num0 += 1
+        else:
+            break
+    b = float(int(r))/10**(len(r) - m)
+    if b >= 10**m - 0.5:  # pragma: no cover
+        raise NotImplementedError
+    n = int(round(b))
+    sn = str(n)
+    s = s[:-m] + '0'*num0 + sn
+    return s[-20:]
+
+# values checked with Mathematica
+def test_log_hp():
+    mp.dps = 2000
+    a = mpf(10)**15000/3
+    r = log(a)
+    res = last_digits(r)
+    # Mathematica N[Log[10^15000/3], 2000]
+    # ...7443804441768333470331
+    assert res == '43804441768333470331'
+
+    # see issue 145
+    r = log(mpf(3)/2)
+    # Mathematica N[Log[3/2], 2000]
+    # ...69653749808140753263288
+    res = last_digits(r)
+    assert res == '53749808140753263288'
+
+    mp.dps = 10000
+    r = log(2)
+    res = last_digits(r)
+    # Mathematica  N[Log[2], 10000]
+    # ...695615913401856601359655561
+    assert res == '13401856601359655561'
+    r = log(mpf(10)**10/3)
+    res = last_digits(r)
+    # Mathematica N[Log[10^10/3], 10000]
+    # ...587087654020631943060007154
+    assert res == '54020631943060007154', res
+    r = log(mpf(10)**100/3)
+    res = last_digits(r)
+    # Mathematica N[Log[10^100/3], 10000]
+    # ,,,59246336539088351652334666
+    assert res == '36539088351652334666', res
+    mp.dps += 10
+    a = 1 - mpf(1)/10**10
+    mp.dps -= 10
+    r = log(a)
+    res = last_digits(r)
+    # ...3310334360482956137216724048322957404
+    # 372167240483229574038733026370
+    # Mathematica N[Log[1 - 10^-10]*10^10, 10000]
+    # ...60482956137216724048322957404
+    assert res == '37216724048322957404', res
+    mp.dps = 10000
+    mp.dps += 100
+    a = 1 + mpf(1)/10**100
+    mp.dps -= 100
+
+    r = log(a)
+    res = last_digits(+r)
+    # Mathematica N[Log[1 + 10^-100]*10^10, 10030]
+    # ...3994733877377412241546890854692521568292338268273 10^-91
+    assert res == '39947338773774122415', res
+
+    mp.dps = 15
+
+def test_exp_hp():
+    mp.dps = 4000
+    r = exp(mpf(1)/10)
+    # IntegerPart[N[Exp[1/10] * 10^4000, 4000]]
+    # ...92167105162069688129
+    assert int(r * 10**mp.dps) % 10**20 == 92167105162069688129

llmeval-env/lib/python3.10/site-packages/mpmath/tests/test_identify.py

@@ -0,0 +1,19 @@
+from mpmath import *
+
+def test_pslq():
+    mp.dps = 15
+    assert pslq([3*pi+4*e/7, pi, e, log(2)]) == [7, -21, -4, 0]
+    assert pslq([4.9999999999999991, 1]) == [1, -5]
+    assert pslq([2,1]) == [1, -2]
+
+def test_identify():
+    mp.dps = 20
+    assert identify(zeta(4), ['log(2)', 'pi**4']) == '((1/90)*pi**4)'
+    mp.dps = 15
+    assert identify(exp(5)) == 'exp(5)'
+    assert identify(exp(4)) == 'exp(4)'
+    assert identify(log(5)) == 'log(5)'
+    assert identify(exp(3*pi), ['pi']) == 'exp((3*pi))'
+    assert identify(3, full=True) == ['3', '3', '1/(1/3)', 'sqrt(9)',
+        '1/sqrt((1/9))', '(sqrt(12)/2)**2', '1/(sqrt(12)/6)**2']
+    assert identify(pi+1, {'a':+pi}) == '(1 + 1*a)'

llmeval-env/lib/python3.10/site-packages/mpmath/tests/test_interval.py

@@ -0,0 +1,453 @@
+from mpmath import *
+
+def test_interval_identity():
+    iv.dps = 15
+    assert mpi(2) == mpi(2, 2)
+    assert mpi(2) != mpi(-2, 2)
+    assert not (mpi(2) != mpi(2, 2))
+    assert mpi(-1, 1) == mpi(-1, 1)
+    assert str(mpi('0.1')) == "[0.099999999999999991673, 0.10000000000000000555]"
+    assert repr(mpi('0.1')) == "mpi('0.099999999999999992', '0.10000000000000001')"
+    u = mpi(-1, 3)
+    assert -1 in u
+    assert 2 in u
+    assert 3 in u
+    assert -1.1 not in u
+    assert 3.1 not in u
+    assert mpi(-1, 3) in u
+    assert mpi(0, 1) in u
+    assert mpi(-1.1, 2) not in u
+    assert mpi(2.5, 3.1) not in u
+    w = mpi(-inf, inf)
+    assert mpi(-5, 5) in w
+    assert mpi(2, inf) in w
+    assert mpi(0, 2) in mpi(0, 10)
+    assert not (3 in mpi(-inf, 0))
+
+def test_interval_hash():
+    assert hash(mpi(3)) == hash(3)
+    assert hash(mpi(3.25)) == hash(3.25)
+    assert hash(mpi(3,4)) == hash(mpi(3,4))
+    assert hash(iv.mpc(3)) == hash(3)
+    assert hash(iv.mpc(3,4)) == hash(3+4j)
+    assert hash(iv.mpc((1,3),(2,4))) == hash(iv.mpc((1,3),(2,4)))
+
+def test_interval_arithmetic():
+    iv.dps = 15
+    assert mpi(2) + mpi(3,4) == mpi(5,6)
+    assert mpi(1, 2)**2 == mpi(1, 4)
+    assert mpi(1) + mpi(0, 1e-50) == mpi(1, mpf('1.0000000000000002'))
+    x = 1 / (1 / mpi(3))
+    assert x.a < 3 < x.b
+    x = mpi(2) ** mpi(0.5)
+    iv.dps += 5
+    sq = iv.sqrt(2)
+    iv.dps -= 5
+    assert x.a < sq < x.b
+    assert mpi(1) / mpi(1, inf)
+    assert mpi(2, 3) / inf == mpi(0, 0)
+    assert mpi(0) / inf == 0
+    assert mpi(0) / 0 == mpi(-inf, inf)
+    assert mpi(inf) / 0 == mpi(-inf, inf)
+    assert mpi(0) * inf == mpi(-inf, inf)
+    assert 1 / mpi(2, inf) == mpi(0, 0.5)
+    assert str((mpi(50, 50) * mpi(-10, -10)) / 3) == \
+        '[-166.66666666666668561, -166.66666666666665719]'
+    assert mpi(0, 4) ** 3 == mpi(0, 64)
+    assert mpi(2,4).mid == 3
+    iv.dps = 30
+    a = mpi(iv.pi)
+    iv.dps = 15
+    b = +a
+    assert b.a < a.a
+    assert b.b > a.b
+    a = mpi(iv.pi)
+    assert a == +a
+    assert abs(mpi(-1,2)) == mpi(0,2)
+    assert abs(mpi(0.5,2)) == mpi(0.5,2)
+    assert abs(mpi(-3,2)) == mpi(0,3)
+    assert abs(mpi(-3,-0.5)) == mpi(0.5,3)
+    assert mpi(0) * mpi(2,3) == mpi(0)
+    assert mpi(2,3) * mpi(0) == mpi(0)
+    assert mpi(1,3).delta == 2
+    assert mpi(1,2) - mpi(3,4) == mpi(-3,-1)
+    assert mpi(-inf,0) - mpi(0,inf) == mpi(-inf,0)
+    assert mpi(-inf,0) - mpi(-inf,inf) == mpi(-inf,inf)
+    assert mpi(0,inf) - mpi(-inf,1) == mpi(-1,inf)
+
+def test_interval_mul():
+    assert mpi(-1, 0) * inf == mpi(-inf, 0)
+    assert mpi(-1, 0) * -inf == mpi(0, inf)
+    assert mpi(0, 1) * inf == mpi(0, inf)
+    assert mpi(0, 1) * mpi(0, inf) == mpi(0, inf)
+    assert mpi(-1, 1) * inf == mpi(-inf, inf)
+    assert mpi(-1, 1) * mpi(0, inf) == mpi(-inf, inf)
+    assert mpi(-1, 1) * mpi(-inf, inf) == mpi(-inf, inf)
+    assert mpi(-inf, 0) * mpi(0, 1) == mpi(-inf, 0)
+    assert mpi(-inf, 0) * mpi(0, 0) * mpi(-inf, 0)
+    assert mpi(-inf, 0) * mpi(-inf, inf) == mpi(-inf, inf)
+    assert mpi(-5,0)*mpi(-32,28) == mpi(-140,160)
+    assert mpi(2,3) * mpi(-1,2) == mpi(-3,6)
+    # Should be undefined?
+    assert mpi(inf, inf) * 0 == mpi(-inf, inf)
+    assert mpi(-inf, -inf) * 0 == mpi(-inf, inf)
+    assert mpi(0) * mpi(-inf,2) == mpi(-inf,inf)
+    assert mpi(0) * mpi(-2,inf) == mpi(-inf,inf)
+    assert mpi(-2,inf) * mpi(0) == mpi(-inf,inf)
+    assert mpi(-inf,2) * mpi(0) == mpi(-inf,inf)
+
+def test_interval_pow():
+    assert mpi(3)**2 == mpi(9, 9)
+    assert mpi(-3)**2 == mpi(9, 9)
+    assert mpi(-3, 1)**2 == mpi(0, 9)
+    assert mpi(-3, -1)**2 == mpi(1, 9)
+    assert mpi(-3, -1)**3 == mpi(-27, -1)
+    assert mpi(-3, 1)**3 == mpi(-27, 1)
+    assert mpi(-2, 3)**2 == mpi(0, 9)
+    assert mpi(-3, 2)**2 == mpi(0, 9)
+    assert mpi(4) ** -1 == mpi(0.25, 0.25)
+    assert mpi(-4) ** -1 == mpi(-0.25, -0.25)
+    assert mpi(4) ** -2 == mpi(0.0625, 0.0625)
+    assert mpi(-4) ** -2 == mpi(0.0625, 0.0625)
+    assert mpi(0, 1) ** inf == mpi(0, 1)
+    assert mpi(0, 1) ** -inf == mpi(1, inf)
+    assert mpi(0, inf) ** inf == mpi(0, inf)
+    assert mpi(0, inf) ** -inf == mpi(0, inf)
+    assert mpi(1, inf) ** inf == mpi(1, inf)
+    assert mpi(1, inf) ** -inf == mpi(0, 1)
+    assert mpi(2, 3) ** 1 == mpi(2, 3)
+    assert mpi(2, 3) ** 0 == 1
+    assert mpi(1,3) ** mpi(2) == mpi(1,9)
+
+def test_interval_sqrt():
+    assert mpi(4) ** 0.5 == mpi(2)
+
+def test_interval_div():
+    assert mpi(0.5, 1) / mpi(-1, 0) == mpi(-inf, -0.5)
+    assert mpi(0, 1) / mpi(0, 1) == mpi(0, inf)
+    assert mpi(inf, inf) / mpi(inf, inf) == mpi(0, inf)
+    assert mpi(inf, inf) / mpi(2, inf) == mpi(0, inf)
+    assert mpi(inf, inf) / mpi(2, 2) == mpi(inf, inf)
+    assert mpi(0, inf) / mpi(2, inf) == mpi(0, inf)
+    assert mpi(0, inf) / mpi(2, 2) == mpi(0, inf)
+    assert mpi(2, inf) / mpi(2, 2) == mpi(1, inf)
+    assert mpi(2, inf) / mpi(2, inf) == mpi(0, inf)
+    assert mpi(-4, 8) / mpi(1, inf) == mpi(-4, 8)
+    assert mpi(-4, 8) / mpi(0.5, inf) == mpi(-8, 16)
+    assert mpi(-inf, 8) / mpi(0.5, inf) == mpi(-inf, 16)
+    assert mpi(-inf, inf) / mpi(0.5, inf) == mpi(-inf, inf)
+    assert mpi(8, inf) / mpi(0.5, inf) == mpi(0, inf)
+    assert mpi(-8, inf) / mpi(0.5, inf) == mpi(-16, inf)
+    assert mpi(-4, 8) / mpi(inf, inf) == mpi(0, 0)
+    assert mpi(0, 8) / mpi(inf, inf) == mpi(0, 0)
+    assert mpi(0, 0) / mpi(inf, inf) == mpi(0, 0)
+    assert mpi(-inf, 0) / mpi(inf, inf) == mpi(-inf, 0)
+    assert mpi(-inf, 8) / mpi(inf, inf) == mpi(-inf, 0)
+    assert mpi(-inf, inf) / mpi(inf, inf) == mpi(-inf, inf)
+    assert mpi(-8, inf) / mpi(inf, inf) == mpi(0, inf)
+    assert mpi(0, inf) / mpi(inf, inf) == mpi(0, inf)
+    assert mpi(8, inf) / mpi(inf, inf) == mpi(0, inf)
+    assert mpi(inf, inf) / mpi(inf, inf) == mpi(0, inf)
+    assert mpi(-1, 2) / mpi(0, 1) == mpi(-inf, +inf)
+    assert mpi(0, 1) / mpi(0, 1) == mpi(0.0, +inf)
+    assert mpi(-1, 0) / mpi(0, 1) == mpi(-inf, 0.0)
+    assert mpi(-0.5, -0.25) / mpi(0, 1) == mpi(-inf, -0.25)
+    assert mpi(0.5, 1) / mpi(0, 1) == mpi(0.5, +inf)
+    assert mpi(0.5, 4) / mpi(0, 1) == mpi(0.5, +inf)
+    assert mpi(-1, -0.5) / mpi(0, 1) == mpi(-inf, -0.5)
+    assert mpi(-4, -0.5) / mpi(0, 1) == mpi(-inf, -0.5)
+    assert mpi(-1, 2) / mpi(-2, 0.5) == mpi(-inf, +inf)
+    assert mpi(0, 1) / mpi(-2, 0.5) == mpi(-inf, +inf)
+    assert mpi(-1, 0) / mpi(-2, 0.5) == mpi(-inf, +inf)
+    assert mpi(-0.5, -0.25) / mpi(-2, 0.5) == mpi(-inf, +inf)
+    assert mpi(0.5, 1) / mpi(-2, 0.5) == mpi(-inf, +inf)
+    assert mpi(0.5, 4) / mpi(-2, 0.5) == mpi(-inf, +inf)
+    assert mpi(-1, -0.5) / mpi(-2, 0.5) == mpi(-inf, +inf)
+    assert mpi(-4, -0.5) / mpi(-2, 0.5) == mpi(-inf, +inf)
+    assert mpi(-1, 2) / mpi(-1, 0) == mpi(-inf, +inf)
+    assert mpi(0, 1) / mpi(-1, 0) == mpi(-inf, 0.0)
+    assert mpi(-1, 0) / mpi(-1, 0) == mpi(0.0, +inf)
+    assert mpi(-0.5, -0.25) / mpi(-1, 0) == mpi(0.25, +inf)
+    assert mpi(0.5, 1) / mpi(-1, 0) == mpi(-inf, -0.5)
+    assert mpi(0.5, 4) / mpi(-1, 0) == mpi(-inf, -0.5)
+    assert mpi(-1, -0.5) / mpi(-1, 0) == mpi(0.5, +inf)
+    assert mpi(-4, -0.5) / mpi(-1, 0) == mpi(0.5, +inf)
+    assert mpi(-1, 2) / mpi(0.5, 1) == mpi(-2.0, 4.0)
+    assert mpi(0, 1) / mpi(0.5, 1) == mpi(0.0, 2.0)
+    assert mpi(-1, 0) / mpi(0.5, 1) == mpi(-2.0, 0.0)
+    assert mpi(-0.5, -0.25) / mpi(0.5, 1) == mpi(-1.0, -0.25)
+    assert mpi(0.5, 1) / mpi(0.5, 1) == mpi(0.5, 2.0)
+    assert mpi(0.5, 4) / mpi(0.5, 1) == mpi(0.5, 8.0)
+    assert mpi(-1, -0.5) / mpi(0.5, 1) == mpi(-2.0, -0.5)
+    assert mpi(-4, -0.5) / mpi(0.5, 1) == mpi(-8.0, -0.5)
+    assert mpi(-1, 2) / mpi(-2, -0.5) == mpi(-4.0, 2.0)
+    assert mpi(0, 1) / mpi(-2, -0.5) == mpi(-2.0, 0.0)
+    assert mpi(-1, 0) / mpi(-2, -0.5) == mpi(0.0, 2.0)
+    assert mpi(-0.5, -0.25) / mpi(-2, -0.5) == mpi(0.125, 1.0)
+    assert mpi(0.5, 1) / mpi(-2, -0.5) == mpi(-2.0, -0.25)
+    assert mpi(0.5, 4) / mpi(-2, -0.5) == mpi(-8.0, -0.25)
+    assert mpi(-1, -0.5) / mpi(-2, -0.5) == mpi(0.25, 2.0)
+    assert mpi(-4, -0.5) / mpi(-2, -0.5) == mpi(0.25, 8.0)
+    # Should be undefined?
+    assert mpi(0, 0) / mpi(0, 0) == mpi(-inf, inf)
+    assert mpi(0, 0) / mpi(0, 1) == mpi(-inf, inf)
+
+def test_interval_cos_sin():
+    iv.dps = 15
+    cos = iv.cos
+    sin = iv.sin
+    tan = iv.tan
+    pi = iv.pi
+    # Around 0
+    assert cos(mpi(0)) == 1
+    assert sin(mpi(0)) == 0
+    assert cos(mpi(0,1)) == mpi(0.54030230586813965399, 1.0)
+    assert sin(mpi(0,1)) == mpi(0, 0.8414709848078966159)
+    assert cos(mpi(1,2)) == mpi(-0.4161468365471424069, 0.54030230586813976501)
+    assert sin(mpi(1,2)) == mpi(0.84147098480789650488, 1.0)
+    assert sin(mpi(1,2.5)) == mpi(0.59847214410395643824, 1.0)
+    assert cos(mpi(-1, 1)) == mpi(0.54030230586813965399, 1.0)
+    assert cos(mpi(-1, 0.5)) == mpi(0.54030230586813965399, 1.0)
+    assert cos(mpi(-1, 1.5)) == mpi(0.070737201667702906405, 1.0)
+    assert sin(mpi(-1,1)) == mpi(-0.8414709848078966159, 0.8414709848078966159)
+    assert sin(mpi(-1,0.5)) == mpi(-0.8414709848078966159, 0.47942553860420300538)
+    assert mpi(-0.8414709848078966159, 1.00000000000000002e-100) in sin(mpi(-1,1e-100))
+    assert mpi(-2.00000000000000004e-100, 1.00000000000000002e-100) in sin(mpi(-2e-100,1e-100))
+    # Same interval
+    assert cos(mpi(2, 2.5))
+    assert cos(mpi(3.5, 4)) == mpi(-0.93645668729079634129, -0.65364362086361182946)
+    assert cos(mpi(5, 5.5)) == mpi(0.28366218546322624627, 0.70866977429126010168)
+    assert mpi(0.59847214410395654927, 0.90929742682568170942) in sin(mpi(2, 2.5))
+    assert sin(mpi(3.5, 4)) == mpi(-0.75680249530792831347, -0.35078322768961983646)
+    assert sin(mpi(5, 5.5)) == mpi(-0.95892427466313856499, -0.70554032557039181306)
+    # Higher roots
+    iv.dps = 55
+    w = 4*10**50 + mpi(0.5)
+    for p in [15, 40, 80]:
+        iv.dps = p
+        assert 0 in sin(4*mpi(pi))
+        assert 0 in sin(4*10**50*mpi(pi))
+        assert 0 in cos((4+0.5)*mpi(pi))
+        assert 0 in cos(w*mpi(pi))
+        assert 1 in cos(4*mpi(pi))
+        assert 1 in cos(4*10**50*mpi(pi))
+    iv.dps = 15
+    assert cos(mpi(2,inf)) == mpi(-1,1)
+    assert sin(mpi(2,inf)) == mpi(-1,1)
+    assert cos(mpi(-inf,2)) == mpi(-1,1)
+    assert sin(mpi(-inf,2)) == mpi(-1,1)
+    u = tan(mpi(0.5,1))
+    assert mpf(u.a).ae(mp.tan(0.5))
+    assert mpf(u.b).ae(mp.tan(1))
+    v = iv.cot(mpi(0.5,1))
+    assert mpf(v.a).ae(mp.cot(1))
+    assert mpf(v.b).ae(mp.cot(0.5))
+    # Sanity check of evaluation at n*pi and (n+1/2)*pi
+    for n in range(-5,7,2):
+        x = iv.cos(n*iv.pi)
+        assert -1 in x
+        assert x >= -1
+        assert x != -1
+        x = iv.sin((n+0.5)*iv.pi)
+        assert -1 in x
+        assert x >= -1
+        assert x != -1
+    for n in range(-6,8,2):
+        x = iv.cos(n*iv.pi)
+        assert 1 in x
+        assert x <= 1
+        if n:
+            assert x != 1
+        x = iv.sin((n+0.5)*iv.pi)
+        assert 1 in x
+        assert x <= 1
+        assert x != 1
+    for n in range(-6,7):
+        x = iv.cos((n+0.5)*iv.pi)
+        assert x.a < 0 < x.b
+        x = iv.sin(n*iv.pi)
+        if n:
+            assert x.a < 0 < x.b
+
+def test_interval_complex():
+    # TODO: many more tests
+    iv.dps = 15
+    mp.dps = 15
+    assert iv.mpc(2,3) == 2+3j
+    assert iv.mpc(2,3) != 2+4j
+    assert iv.mpc(2,3) != 1+3j
+    assert 1+3j in iv.mpc([1,2],[3,4])
+    assert 2+5j not in iv.mpc([1,2],[3,4])
+    assert iv.mpc(1,2) + 1j == 1+3j
+    assert iv.mpc([1,2],[2,3]) + 2+3j == iv.mpc([3,4],[5,6])
+    assert iv.mpc([2,4],[4,8]) / 2 == iv.mpc([1,2],[2,4])
+    assert iv.mpc([1,2],[2,4]) * 2j == iv.mpc([-8,-4],[2,4])
+    assert iv.mpc([2,4],[4,8]) / 2j == iv.mpc([2,4],[-2,-1])
+    assert iv.exp(2+3j).ae(mp.exp(2+3j))
+    assert iv.log(2+3j).ae(mp.log(2+3j))
+    assert (iv.mpc(2,3) ** iv.mpc(0.5,2)).ae(mp.mpc(2,3) ** mp.mpc(0.5,2))
+    assert 1j in (iv.mpf(-1) ** 0.5)
+    assert 1j in (iv.mpc(-1) ** 0.5)
+    assert abs(iv.mpc(0)) == 0
+    assert abs(iv.mpc(inf)) == inf
+    assert abs(iv.mpc(3,4)) == 5
+    assert abs(iv.mpc(4)) == 4
+    assert abs(iv.mpc(0,4)) == 4
+    assert abs(iv.mpc(0,[2,3])) == iv.mpf([2,3])
+    assert abs(iv.mpc(0,[-3,2])) == iv.mpf([0,3])
+    assert abs(iv.mpc([3,5],[4,12])) == iv.mpf([5,13])
+    assert abs(iv.mpc([3,5],[-4,12])) == iv.mpf([3,13])
+    assert iv.mpc(2,3) ** 0 == 1
+    assert iv.mpc(2,3) ** 1 == (2+3j)
+    assert iv.mpc(2,3) ** 2 == (2+3j)**2
+    assert iv.mpc(2,3) ** 3 == (2+3j)**3
+    assert iv.mpc(2,3) ** 4 == (2+3j)**4
+    assert iv.mpc(2,3) ** 5 == (2+3j)**5
+    assert iv.mpc(2,2) ** (-1) == (2+2j) ** (-1)
+    assert iv.mpc(2,2) ** (-2) == (2+2j) ** (-2)
+    assert iv.cos(2).ae(mp.cos(2))
+    assert iv.sin(2).ae(mp.sin(2))
+    assert iv.cos(2+3j).ae(mp.cos(2+3j))
+    assert iv.sin(2+3j).ae(mp.sin(2+3j))
+
+def test_interval_complex_arg():
+    mp.dps = 15
+    iv.dps = 15
+    assert iv.arg(3) == 0
+    assert iv.arg(0) == 0
+    assert iv.arg([0,3]) == 0
+    assert iv.arg(-3).ae(pi)
+    assert iv.arg(2+3j).ae(iv.arg(2+3j))
+    z = iv.mpc([-2,-1],[3,4])
+    t = iv.arg(z)
+    assert t.a.ae(mp.arg(-1+4j))
+    assert t.b.ae(mp.arg(-2+3j))
+    z = iv.mpc([-2,1],[3,4])
+    t = iv.arg(z)
+    assert t.a.ae(mp.arg(1+3j))
+    assert t.b.ae(mp.arg(-2+3j))
+    z = iv.mpc([1,2],[3,4])
+    t = iv.arg(z)
+    assert t.a.ae(mp.arg(2+3j))
+    assert t.b.ae(mp.arg(1+4j))
+    z = iv.mpc([1,2],[-2,3])
+    t = iv.arg(z)
+    assert t.a.ae(mp.arg(1-2j))
+    assert t.b.ae(mp.arg(1+3j))
+    z = iv.mpc([1,2],[-4,-3])
+    t = iv.arg(z)
+    assert t.a.ae(mp.arg(1-4j))
+    assert t.b.ae(mp.arg(2-3j))
+    z = iv.mpc([-1,2],[-4,-3])
+    t = iv.arg(z)
+    assert t.a.ae(mp.arg(-1-3j))
+    assert t.b.ae(mp.arg(2-3j))
+    z = iv.mpc([-2,-1],[-4,-3])
+    t = iv.arg(z)
+    assert t.a.ae(mp.arg(-2-3j))
+    assert t.b.ae(mp.arg(-1-4j))
+    z = iv.mpc([-2,-1],[-3,3])
+    t = iv.arg(z)
+    assert t.a.ae(-mp.pi)
+    assert t.b.ae(mp.pi)
+    z = iv.mpc([-2,2],[-3,3])
+    t = iv.arg(z)
+    assert t.a.ae(-mp.pi)
+    assert t.b.ae(mp.pi)
+
+def test_interval_ae():
+    iv.dps = 15
+    x = iv.mpf([1,2])
+    assert x.ae(1) is None
+    assert x.ae(1.5) is None
+    assert x.ae(2) is None
+    assert x.ae(2.01) is False
+    assert x.ae(0.99) is False
+    x = iv.mpf(3.5)
+    assert x.ae(3.5) is True
+    assert x.ae(3.5+1e-15) is True
+    assert x.ae(3.5-1e-15) is True
+    assert x.ae(3.501) is False
+    assert x.ae(3.499) is False
+    assert x.ae(iv.mpf([3.5,3.501])) is None
+    assert x.ae(iv.mpf([3.5,4.5+1e-15])) is None
+
+def test_interval_nstr():
+    iv.dps = n = 30
+    x = mpi(1, 2)
+    # FIXME: error_dps should not be necessary
+    assert iv.nstr(x, n, mode='plusminus', error_dps=6) == '1.5 +- 0.5'
+    assert iv.nstr(x, n, mode='plusminus', use_spaces=False, error_dps=6) == '1.5+-0.5'
+    assert iv.nstr(x, n, mode='percent') == '1.5 (33.33%)'
+    assert iv.nstr(x, n, mode='brackets', use_spaces=False) == '[1.0,2.0]'
+    assert iv.nstr(x, n, mode='brackets' , brackets=('<', '>')) == '<1.0, 2.0>'
+    x = mpi('5.2582327113062393041', '5.2582327113062749951')
+    assert iv.nstr(x, n, mode='diff') == '5.2582327113062[393041, 749951]'
+    assert iv.nstr(iv.cos(mpi(1)), n, mode='diff', use_spaces=False) == '0.54030230586813971740093660744[2955,3053]'
+    assert iv.nstr(mpi('1e123', '1e129'), n, mode='diff') == '[1.0e+123, 1.0e+129]'
+    exp = iv.exp
+    assert iv.nstr(iv.exp(mpi('5000.1')), n, mode='diff') == '3.2797365856787867069110487[0926, 1191]e+2171'
+    iv.dps = 15
+
+def test_mpi_from_str():
+    iv.dps = 15
+    assert iv.convert('1.5 +- 0.5') == mpi(mpf('1.0'), mpf('2.0'))
+    assert mpi(1, 2) in iv.convert('1.5 (33.33333333333333333333333333333%)')
+    assert iv.convert('[1, 2]') == mpi(1, 2)
+    assert iv.convert('1[2, 3]') == mpi(12, 13)
+    assert iv.convert('1.[23,46]e-8') == mpi('1.23e-8', '1.46e-8')
+    assert iv.convert('12[3.4,5.9]e4') == mpi('123.4e+4', '125.9e4')
+
+def test_interval_gamma():
+    mp.dps = 15
+    iv.dps = 15
+    # TODO: need many more tests
+    assert iv.rgamma(0) == 0
+    assert iv.fac(0) == 1
+    assert iv.fac(1) == 1
+    assert iv.fac(2) == 2
+    assert iv.fac(3) == 6
+    assert iv.gamma(0) == [-inf,inf]
+    assert iv.gamma(1) == 1
+    assert iv.gamma(2) == 1
+    assert iv.gamma(3) == 2
+    assert -3.5449077018110320546 in iv.gamma(-0.5)
+    assert iv.loggamma(1) == 0
+    assert iv.loggamma(2) == 0
+    assert 0.69314718055994530942 in iv.loggamma(3)
+    # Test tight log-gamma endpoints based on monotonicity
+    xs = [iv.mpc([2,3],[1,4]),
+          iv.mpc([2,3],[-4,-1]),
+          iv.mpc([2,3],[-1,4]),
+          iv.mpc([2,3],[-4,1]),
+          iv.mpc([2,3],[-4,4]),
+          iv.mpc([-3,-2],[2,4]),
+          iv.mpc([-3,-2],[-4,-2])]
+    for x in xs:
+        ys = [mp.loggamma(mp.mpc(x.a,x.c)),
+              mp.loggamma(mp.mpc(x.b,x.c)),
+              mp.loggamma(mp.mpc(x.a,x.d)),
+              mp.loggamma(mp.mpc(x.b,x.d))]
+        if 0 in x.imag:
+            ys += [mp.loggamma(x.a), mp.loggamma(x.b)]
+        min_real = min([y.real for y in ys])
+        max_real = max([y.real for y in ys])
+        min_imag = min([y.imag for y in ys])
+        max_imag = max([y.imag for y in ys])
+        z = iv.loggamma(x)
+        assert z.a.ae(min_real)
+        assert z.b.ae(max_real)
+        assert z.c.ae(min_imag)
+        assert z.d.ae(max_imag)
+
+def test_interval_conversions():
+    mp.dps = 15
+    iv.dps = 15
+    for a, b in ((-0.0, 0), (0.0, 0.5), (1.0, 1), \
+                 ('-inf', 20.5), ('-inf', float(sqrt(2)))):
+        r = mpi(a, b)
+        assert int(r.b) == int(b)
+        assert float(r.a) == float(a)
+        assert float(r.b) == float(b)
+        assert complex(r.a) == complex(a)
+        assert complex(r.b) == complex(b)

llmeval-env/lib/python3.10/site-packages/mpmath/tests/test_levin.py

@@ -0,0 +1,153 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+from mpmath import mp
+from mpmath import libmp
+
+xrange = libmp.backend.xrange
+
+# Attention:
+#   These tests run with 15-20 decimal digits precision. For higher precision the
+#   working precision must be raised.
+
+def test_levin_0():
+    mp.dps = 17
+    eps = mp.mpf(mp.eps)
+    with mp.extraprec(2 * mp.prec):
+        L = mp.levin(method = "levin", variant = "u")
+        S, s, n = [], 0, 1
+        while 1:
+            s += mp.one / (n * n)
+            n += 1
+            S.append(s)
+            v, e = L.update_psum(S)
+            if e < eps:
+                break
+            if n > 1000: raise RuntimeError("iteration limit exceeded")
+    eps = mp.exp(0.9 * mp.log(eps))
+    err = abs(v - mp.pi ** 2 / 6)
+    assert err < eps
+    w = mp.nsum(lambda n: 1/(n * n), [1, mp.inf], method = "levin", levin_variant = "u")
+    err = abs(v - w)
+    assert err < eps
+
+def test_levin_1():
+    mp.dps = 17
+    eps = mp.mpf(mp.eps)
+    with mp.extraprec(2 * mp.prec):
+        L = mp.levin(method = "levin", variant = "v")
+        A, n = [], 1
+        while 1:
+            s = mp.mpf(n) ** (2 + 3j)
+            n += 1
+            A.append(s)
+            v, e = L.update(A)
+            if e < eps:
+                break
+            if n > 1000: raise RuntimeError("iteration limit exceeded")
+    eps = mp.exp(0.9 * mp.log(eps))
+    err = abs(v - mp.zeta(-2-3j))
+    assert err < eps
+    w = mp.nsum(lambda n: n ** (2 + 3j), [1, mp.inf], method = "levin", levin_variant = "v")
+    err = abs(v - w)
+    assert err < eps
+
+def test_levin_2():
+    # [2] A. Sidi - "Pratical Extrapolation Methods" p.373
+    mp.dps = 17
+    z=mp.mpf(10)
+    eps = mp.mpf(mp.eps)
+    with mp.extraprec(2 * mp.prec):
+        L = mp.levin(method = "sidi", variant = "t")
+        n = 0
+        while 1:
+            s = (-1)**n * mp.fac(n) * z ** (-n)
+            v, e = L.step(s)
+            n += 1
+            if e < eps:
+                break
+            if n > 1000: raise RuntimeError("iteration limit exceeded")
+    eps = mp.exp(0.9 * mp.log(eps))
+    exact = mp.quad(lambda x: mp.exp(-x)/(1+x/z),[0,mp.inf])
+    # there is also a symbolic expression for the integral:
+    #   exact = z * mp.exp(z) * mp.expint(1,z)
+    err = abs(v - exact)
+    assert err < eps
+    w = mp.nsum(lambda n: (-1) ** n * mp.fac(n) * z ** (-n), [0, mp.inf], method = "sidi", levin_variant = "t")
+    assert err < eps
+
+def test_levin_3():
+    mp.dps = 17
+    z=mp.mpf(2)
+    eps = mp.mpf(mp.eps)
+    with mp.extraprec(7*mp.prec):  # we need copious amount of precision to sum this highly divergent series
+        L = mp.levin(method = "levin", variant = "t")
+        n, s = 0, 0
+        while 1:
+            s += (-z)**n * mp.fac(4 * n) / (mp.fac(n) * mp.fac(2 * n) * (4 ** n))
+            n += 1
+            v, e = L.step_psum(s)
+            if e < eps:
+                break
+            if n > 1000: raise RuntimeError("iteration limit exceeded")
+    eps = mp.exp(0.8 * mp.log(eps))
+    exact = mp.quad(lambda x: mp.exp( -x * x / 2 - z * x ** 4), [0,mp.inf]) * 2 / mp.sqrt(2 * mp.pi)
+    # there is also a symbolic expression for the integral:
+    #   exact = mp.exp(mp.one / (32 * z)) * mp.besselk(mp.one / 4, mp.one / (32 * z)) / (4 * mp.sqrt(z * mp.pi))
+    err = abs(v - exact)
+    assert err < eps
+    w = mp.nsum(lambda n: (-z)**n * mp.fac(4 * n) / (mp.fac(n) * mp.fac(2 * n) * (4 ** n)), [0, mp.inf], method = "levin", levin_variant = "t", workprec = 8*mp.prec, steps = [2] + [1 for x in xrange(1000)])
+    err = abs(v - w)
+    assert err < eps
+
+def test_levin_nsum():
+    mp.dps = 17
+
+    with mp.extraprec(mp.prec):
+        z = mp.mpf(10) ** (-10)
+        a = mp.nsum(lambda n: n**(-(1+z)), [1, mp.inf], method = "l") - 1 / z
+        assert abs(a - mp.euler) < 1e-10
+
+    eps = mp.exp(0.8 * mp.log(mp.eps))
+
+    a = mp.nsum(lambda n: (-1)**(n-1) / n, [1, mp.inf], method = "sidi")
+    assert abs(a - mp.log(2)) < eps
+
+    z = 2 + 1j
+    f = lambda n: mp.rf(2 / mp.mpf(3), n) * mp.rf(4 / mp.mpf(3), n) * z**n / (mp.rf(1 / mp.mpf(3), n) * mp.fac(n))
+    v = mp.nsum(f, [0, mp.inf], method = "levin", steps = [10 for x in xrange(1000)])
+    exact = mp.hyp2f1(2 / mp.mpf(3), 4 / mp.mpf(3), 1 / mp.mpf(3), z)
+    assert abs(exact - v) < eps
+
+def test_cohen_alt_0():
+    mp.dps = 17
+    AC = mp.cohen_alt()
+    S, s, n = [], 0, 1
+    while 1:
+        s += -((-1) ** n) * mp.one / (n * n)
+        n += 1
+        S.append(s)
+        v, e = AC.update_psum(S)
+        if e < mp.eps:
+            break
+        if n > 1000: raise RuntimeError("iteration limit exceeded")
+    eps = mp.exp(0.9 * mp.log(mp.eps))
+    err = abs(v - mp.pi ** 2 / 12)
+    assert err < eps
+
+def test_cohen_alt_1():
+    mp.dps = 17
+    A = []
+    AC = mp.cohen_alt()
+    n = 1
+    while 1:
+        A.append( mp.loggamma(1 + mp.one / (2 * n - 1)))
+        A.append(-mp.loggamma(1 + mp.one / (2 * n)))
+        n += 1
+        v, e = AC.update(A)
+        if e < mp.eps:
+            break
+        if n > 1000: raise RuntimeError("iteration limit exceeded")
+    v = mp.exp(v)
+    err = abs(v - 1.06215090557106)
+    assert err < 1e-12

llmeval-env/lib/python3.10/site-packages/mpmath/tests/test_linalg.py

@@ -0,0 +1,332 @@
+# TODO: don't use round
+
+from __future__ import division
+
+import pytest
+from mpmath import *
+xrange = libmp.backend.xrange
+
+# XXX: these shouldn't be visible(?)
+LU_decomp = mp.LU_decomp
+L_solve = mp.L_solve
+U_solve = mp.U_solve
+householder = mp.householder
+improve_solution = mp.improve_solution
+
+A1 = matrix([[3, 1, 6],
+             [2, 1, 3],
+             [1, 1, 1]])
+b1 = [2, 7, 4]
+
+A2 = matrix([[ 2, -1, -1,  2],
+             [ 6, -2,  3, -1],
+             [-4,  2,  3, -2],
+             [ 2,  0,  4, -3]])
+b2 = [3, -3, -2, -1]
+
+A3 = matrix([[ 1,  0, -1, -1,  0],
+             [ 0,  1,  1,  0, -1],
+             [ 4, -5,  2,  0,  0],
+             [ 0,  0, -2,  9,-12],
+             [ 0,  5,  0,  0, 12]])
+b3 = [0, 0, 0, 0, 50]
+
+A4 = matrix([[10.235, -4.56,   0.,   -0.035,  5.67],
+             [-2.463,  1.27,   3.97, -8.63,   1.08],
+             [-6.58,   0.86,  -0.257, 9.32, -43.6 ],
+             [ 9.83,   7.39, -17.25,  0.036, 24.86],
+             [-9.31,  34.9,   78.56,  1.07,  65.8 ]])
+b4 = [8.95, 20.54, 7.42, 5.60, 58.43]
+
+A5 = matrix([[ 1,  2, -4],
+             [-2, -3,  5],
+             [ 3,  5, -8]])
+
+A6 = matrix([[ 1.377360,  2.481400,   5.359190],
+             [ 2.679280, -1.229560,  25.560210],
+             [-1.225280+1.e6,  9.910180, -35.049900-1.e6]])
+b6 = [23.500000, -15.760000, 2.340000]
+
+A7 = matrix([[1, -0.5],
+             [2, 1],
+             [-2, 6]])
+b7 = [3, 2, -4]
+
+A8 = matrix([[1, 2, 3],
+             [-1, 0, 1],
+             [-1, -2, -1],
+             [1, 0, -1]])
+b8 = [1, 2, 3, 4]
+
+A9 = matrix([[ 4,  2, -2],
+             [ 2,  5, -4],
+             [-2, -4, 5.5]])
+b9 = [10, 16, -15.5]
+
+A10 = matrix([[1.0 + 1.0j, 2.0, 2.0],
+            [4.0, 5.0, 6.0],
+            [7.0, 8.0, 9.0]])
+b10 = [1.0, 1.0 + 1.0j, 1.0]
+
+
+def test_LU_decomp():
+    A = A3.copy()
+    b = b3
+    A, p = LU_decomp(A)
+    y = L_solve(A, b, p)
+    x = U_solve(A, y)
+    assert p == [2, 1, 2, 3]
+    assert [round(i, 14) for i in x] == [3.78953107960742, 2.9989094874591098,
+            -0.081788440567070006, 3.8713195201744801, 2.9171210468920399]
+    A = A4.copy()
+    b = b4
+    A, p = LU_decomp(A)
+    y = L_solve(A, b, p)
+    x = U_solve(A, y)
+    assert p == [0, 3, 4, 3]
+    assert [round(i, 14) for i in x] == [2.6383625899619201, 2.6643834462368399,
+            0.79208015947958998, -2.5088376454101899, -1.0567657691375001]
+    A = randmatrix(3)
+    bak = A.copy()
+    LU_decomp(A, overwrite=1)
+    assert A != bak
+
+def test_inverse():
+    for A in [A1, A2, A5]:
+        inv = inverse(A)
+        assert mnorm(A*inv - eye(A.rows), 1) < 1.e-14
+
+def test_householder():
+    mp.dps = 15
+    A, b = A8, b8
+    H, p, x, r = householder(extend(A, b))
+    assert H == matrix(
+    [[mpf('3.0'), mpf('-2.0'), mpf('-1.0'), 0],
+     [-1.0,mpf('3.333333333333333'),mpf('-2.9999999999999991'),mpf('2.0')],
+     [-1.0, mpf('-0.66666666666666674'),mpf('2.8142135623730948'),
+      mpf('-2.8284271247461898')],
+     [1.0, mpf('-1.3333333333333333'),mpf('-0.20000000000000018'),
+      mpf('4.2426406871192857')]])
+    assert p == [-2, -2, mpf('-1.4142135623730949')]
+    assert round(norm(r, 2), 10) == 4.2426406870999998
+
+    y = [102.102, 58.344, 36.463, 24.310, 17.017, 12.376, 9.282, 7.140, 5.610,
+         4.488, 3.6465, 3.003]
+
+    def coeff(n):
+        # similiar to Hilbert matrix
+        A = []
+        for i in range(1, 13):
+            A.append([1. / (i + j - 1) for j in range(1, n + 1)])
+        return matrix(A)
+
+    residuals = []
+    refres = []
+    for n in range(2, 7):
+        A = coeff(n)
+        H, p, x, r = householder(extend(A, y))
+        x = matrix(x)
+        y = matrix(y)
+        residuals.append(norm(r, 2))
+        refres.append(norm(residual(A, x, y), 2))
+    assert [round(res, 10) for res in residuals] == [15.1733888877,
+           0.82378073210000002, 0.302645887, 0.0260109244,
+           0.00058653999999999998]
+    assert norm(matrix(residuals) - matrix(refres), inf) < 1.e-13
+
+    def hilbert_cmplx(n):
+        # Complexified  Hilbert matrix
+        A = hilbert(2*n,n)
+        v = randmatrix(2*n, 2, min=-1, max=1)
+        v = v.apply(lambda x: exp(1J*pi()*x))
+        A = diag(v[:,0])*A*diag(v[:n,1])
+        return A
+
+    residuals_cmplx = []
+    refres_cmplx = []
+    for n in range(2, 10):
+        A = hilbert_cmplx(n)
+        H, p, x, r = householder(A.copy())
+        residuals_cmplx.append(norm(r, 2))
+        refres_cmplx.append(norm(residual(A[:,:n-1], x, A[:,n-1]), 2))
+    assert norm(matrix(residuals_cmplx) - matrix(refres_cmplx), inf) < 1.e-13
+
+def test_factorization():
+    A = randmatrix(5)
+    P, L, U = lu(A)
+    assert mnorm(P*A - L*U, 1) < 1.e-15
+
+def test_solve():
+    assert norm(residual(A6, lu_solve(A6, b6), b6), inf) < 1.e-10
+    assert norm(residual(A7, lu_solve(A7, b7), b7), inf) < 1.5
+    assert norm(residual(A8, lu_solve(A8, b8), b8), inf) <= 3 + 1.e-10
+    assert norm(residual(A6, qr_solve(A6, b6)[0], b6), inf) < 1.e-10
+    assert norm(residual(A7, qr_solve(A7, b7)[0], b7), inf) < 1.5
+    assert norm(residual(A8, qr_solve(A8, b8)[0], b8), 2) <= 4.3
+    assert norm(residual(A10, lu_solve(A10, b10), b10), 2) < 1.e-10
+    assert norm(residual(A10, qr_solve(A10, b10)[0], b10), 2) < 1.e-10
+
+def test_solve_overdet_complex():
+    A = matrix([[1, 2j], [3, 4j], [5, 6]])
+    b = matrix([1 + j, 2, -j])
+    assert norm(residual(A, lu_solve(A, b), b)) < 1.0208
+
+def test_singular():
+    mp.dps = 15
+    A = [[5.6, 1.2], [7./15, .1]]
+    B = repr(zeros(2))
+    b = [1, 2]
+    for i in ['lu_solve(%s, %s)' % (A, b), 'lu_solve(%s, %s)' % (B, b),
+              'qr_solve(%s, %s)' % (A, b), 'qr_solve(%s, %s)' % (B, b)]:
+        pytest.raises((ZeroDivisionError, ValueError), lambda: eval(i))
+
+def test_cholesky():
+    assert fp.cholesky(fp.matrix(A9)) == fp.matrix([[2, 0, 0], [1, 2, 0], [-1, -3/2, 3/2]])
+    x = fp.cholesky_solve(A9, b9)
+    assert fp.norm(fp.residual(A9, x, b9), fp.inf) == 0
+
+def test_det():
+    assert det(A1) == 1
+    assert round(det(A2), 14) == 8
+    assert round(det(A3)) == 1834
+    assert round(det(A4)) == 4443376
+    assert det(A5) == 1
+    assert round(det(A6)) == 78356463
+    assert det(zeros(3)) == 0
+
+def test_cond():
+    mp.dps = 15
+    A = matrix([[1.2969, 0.8648], [0.2161, 0.1441]])
+    assert cond(A, lambda x: mnorm(x,1)) == mpf('327065209.73817754')
+    assert cond(A, lambda x: mnorm(x,inf)) == mpf('327065209.73817754')
+    assert cond(A, lambda x: mnorm(x,'F')) == mpf('249729266.80008656')
+
+@extradps(50)
+def test_precision():
+    A = randmatrix(10, 10)
+    assert mnorm(inverse(inverse(A)) - A, 1) < 1.e-45
+
+def test_interval_matrix():
+    mp.dps = 15
+    iv.dps = 15
+    a = iv.matrix([['0.1','0.3','1.0'],['7.1','5.5','4.8'],['3.2','4.4','5.6']])
+    b = iv.matrix(['4','0.6','0.5'])
+    c = iv.lu_solve(a, b)
+    assert c[0].delta < 1e-13
+    assert c[1].delta < 1e-13
+    assert c[2].delta < 1e-13
+    assert 5.25823271130625686059275 in c[0]
+    assert -13.155049396267837541163 in c[1]
+    assert 7.42069154774972557628979 in c[2]
+
+def test_LU_cache():
+    A = randmatrix(3)
+    LU = LU_decomp(A)
+    assert A._LU == LU_decomp(A)
+    A[0,0] = -1000
+    assert A._LU is None
+
+def test_improve_solution():
+    A = randmatrix(5, min=1e-20, max=1e20)
+    b = randmatrix(5, 1, min=-1000, max=1000)
+    x1 = lu_solve(A, b) + randmatrix(5, 1, min=-1e-5, max=1.e-5)
+    x2 = improve_solution(A, x1, b)
+    assert norm(residual(A, x2, b), 2) < norm(residual(A, x1, b), 2)
+
+def test_exp_pade():
+    for i in range(3):
+        dps = 15
+        extra = 15
+        mp.dps = dps + extra
+        dm = 0
+        N = 3
+        dg = range(1,N+1)
+        a = diag(dg)
+        expa = diag([exp(x) for x in dg])
+        # choose a random matrix not close to be singular
+        # to avoid adding too much extra precision in computing
+        # m**-1 * M * m
+        while abs(dm) < 0.01:
+            m = randmatrix(N)
+            dm = det(m)
+        m = m/dm
+        a1 = m**-1 * a * m
+        e2 = m**-1 * expa * m
+        mp.dps = dps
+        e1 = expm(a1, method='pade')
+        mp.dps = dps + extra
+        d = e2 - e1
+        #print d
+        mp.dps = dps
+        assert norm(d, inf).ae(0)
+    mp.dps = 15
+
+def test_qr():
+    mp.dps = 15                     # used default value for dps
+    lowlimit = -9                   # lower limit of matrix element value
+    uplimit = 9                     # uppter limit of matrix element value
+    maxm = 4                        # max matrix size
+    flg = False                     # toggle to create real vs complex matrix
+    zero = mpf('0.0')
+
+    for k in xrange(0,10):
+        exdps = 0
+        mode = 'full'
+        flg = bool(k % 2)
+
+        # generate arbitrary matrix size (2 to maxm)
+        num1 = nint(maxm*rand())
+        num2 = nint(maxm*rand())
+        m = int(max(num1, num2))
+        n = int(min(num1, num2))
+
+        # create matrix
+        A = mp.matrix(m,n)
+
+        # populate matrix values with arbitrary integers
+        if flg:
+            flg = False
+            dtype = 'complex'
+            for j in xrange(0,n):
+                for i in xrange(0,m):
+                    val = nint(lowlimit + (uplimit-lowlimit)*rand())
+                    val2 = nint(lowlimit + (uplimit-lowlimit)*rand())
+                    A[i,j] = mpc(val, val2)
+        else:
+            flg = True
+            dtype = 'real'
+            for j in xrange(0,n):
+                for i in xrange(0,m):
+                    val = nint(lowlimit + (uplimit-lowlimit)*rand())
+                    A[i,j] = mpf(val)
+
+        # perform A -> QR decomposition
+        Q, R = qr(A, mode, edps = exdps)
+
+        #print('\n\n A = \n', nstr(A, 4))
+        #print('\n Q = \n', nstr(Q, 4))
+        #print('\n R = \n', nstr(R, 4))
+        #print('\n Q*R = \n', nstr(Q*R, 4))
+
+        maxnorm = mpf('1.0E-11')
+        n1 = norm(A - Q * R)
+        #print '\n Norm of A - Q * R = ', n1
+        assert n1 <= maxnorm
+
+        if dtype == 'real':
+            n1 = norm(eye(m) - Q.T * Q)
+            #print ' Norm of I - Q.T * Q = ', n1
+            assert n1 <= maxnorm
+
+            n1 = norm(eye(m) - Q * Q.T)
+            #print ' Norm of I - Q * Q.T = ', n1
+            assert n1 <= maxnorm
+
+        if dtype == 'complex':
+            n1 = norm(eye(m) - Q.T * Q.conjugate())
+            #print ' Norm of I - Q.T * Q.conjugate() = ', n1
+            assert n1 <= maxnorm
+
+            n1 = norm(eye(m) - Q.conjugate() * Q.T)
+            #print ' Norm of I - Q.conjugate() * Q.T = ', n1
+            assert n1 <= maxnorm

llmeval-env/lib/python3.10/site-packages/mpmath/tests/test_matrices.py

@@ -0,0 +1,253 @@
+import pytest
+import sys
+from mpmath import *
+
+def test_matrix_basic():
+    A1 = matrix(3)
+    for i in range(3):
+        A1[i,i] = 1
+    assert A1 == eye(3)
+    assert A1 == matrix(A1)
+    A2 = matrix(3, 2)
+    assert not A2._matrix__data
+    A3 = matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    assert list(A3) == list(range(1, 10))
+    A3[1,1] = 0
+    assert not (1, 1) in A3._matrix__data
+    A4 = matrix([[1, 2, 3], [4, 5, 6]])
+    A5 = matrix([[6, -1], [3, 2], [0, -3]])
+    assert A4 * A5 == matrix([[12, -6], [39, -12]])
+    assert A1 * A3 == A3 * A1 == A3
+    pytest.raises(ValueError, lambda: A2*A2)
+    l = [[10, 20, 30], [40, 0, 60], [70, 80, 90]]
+    A6 = matrix(l)
+    assert A6.tolist() == l
+    assert A6 == eval(repr(A6))
+    A6 = fp.matrix(A6)
+    assert A6 == eval(repr(A6))
+    assert A6*1j == eval(repr(A6*1j))
+    assert A3 * 10 == 10 * A3 == A6
+    assert A2.rows == 3
+    assert A2.cols == 2
+    A3.rows = 2
+    A3.cols = 2
+    assert len(A3._matrix__data) == 3
+    assert A4 + A4 == 2*A4
+    pytest.raises(ValueError, lambda: A4 + A2)
+    assert sum(A1 - A1) == 0
+    A7 = matrix([[1, 2], [3, 4], [5, 6], [7, 8]])
+    x = matrix([10, -10])
+    assert A7*x == matrix([-10, -10, -10, -10])
+    A8 = ones(5)
+    assert sum((A8 + 1) - (2 - zeros(5))) == 0
+    assert (1 + ones(4)) / 2 - 1 == zeros(4)
+    assert eye(3)**10 == eye(3)
+    pytest.raises(ValueError, lambda: A7**2)
+    A9 = randmatrix(3)
+    A10 = matrix(A9)
+    A9[0,0] = -100
+    assert A9 != A10
+    assert nstr(A9)
+
+def test_matmul():
+    """
+    Test the PEP465 "@" matrix multiplication syntax.
+    To avoid syntax errors when importing this file in Python 3.5 and below, we have to use exec() - sorry for that.
+    """
+    # TODO remove exec() wrapper as soon as we drop support for Python <= 3.5
+    if sys.hexversion < 0x30500f0:
+        # we are on Python < 3.5
+        pytest.skip("'@' (__matmul__) is only supported in Python 3.5 or newer")
+    A4 = matrix([[1, 2, 3], [4, 5, 6]])
+    A5 = matrix([[6, -1], [3, 2], [0, -3]])
+    exec("assert A4 @ A5 == A4 * A5")
+
+def test_matrix_slices():
+    A = matrix([    [1, 2, 3],
+                        [4, 5 ,6],
+                        [7, 8 ,9]])
+    V = matrix([1,2,3,4,5])
+
+    # Get slice
+    assert A[:,:] == A
+    assert A[:,1] == matrix([[2],[5],[8]])
+    assert A[2,:] == matrix([[7, 8 ,9]])
+    assert A[1:3,1:3] == matrix([[5,6],[8,9]])
+    assert V[2:4] == matrix([3,4])
+    pytest.raises(IndexError, lambda: A[:,1:6])
+
+    # Assign slice with matrix
+    A1 = matrix(3)
+    A1[:,:] = A
+    assert A1[:,:] == matrix([[1, 2, 3],
+                                        [4, 5 ,6],
+                                        [7, 8 ,9]])
+    A1[0,:] = matrix([[10, 11, 12]])
+    assert A1 == matrix([ [10, 11, 12],
+                                    [4, 5 ,6],
+                                    [7, 8 ,9]])
+    A1[:,2] = matrix([[13], [14], [15]])
+    assert A1 == matrix([ [10, 11, 13],
+                                    [4, 5 ,14],
+                                    [7, 8 ,15]])
+    A1[:2,:2] = matrix([[16, 17], [18 , 19]])
+    assert A1 == matrix([ [16, 17, 13],
+                                    [18, 19 ,14],
+                                    [7, 8 ,15]])
+    V[1:3] = 10
+    assert V == matrix([1,10,10,4,5])
+    with pytest.raises(ValueError):
+        A1[2,:] = A[:,1]
+
+    with pytest.raises(IndexError):
+        A1[2,1:20] = A[:,:]
+
+    # Assign slice with scalar
+    A1[:,2] = 10
+    assert A1 == matrix([ [16, 17, 10],
+                                    [18, 19 ,10],
+                                    [7, 8 ,10]])
+    A1[:,:] = 40
+    for x in A1:
+        assert x == 40
+
+
+def test_matrix_power():
+    A = matrix([[1, 2], [3, 4]])
+    assert A**2 == A*A
+    assert A**3 == A*A*A
+    assert A**-1 == inverse(A)
+    assert A**-2 == inverse(A*A)
+
+def test_matrix_transform():
+    A = matrix([[1, 2], [3, 4], [5, 6]])
+    assert A.T == A.transpose() == matrix([[1, 3, 5], [2, 4, 6]])
+    swap_row(A, 1, 2)
+    assert A == matrix([[1, 2], [5, 6], [3, 4]])
+    l = [1, 2]
+    swap_row(l, 0, 1)
+    assert l == [2, 1]
+    assert extend(eye(3), [1,2,3]) == matrix([[1,0,0,1],[0,1,0,2],[0,0,1,3]])
+
+def test_matrix_conjugate():
+    A = matrix([[1 + j, 0], [2, j]])
+    assert A.conjugate() == matrix([[mpc(1, -1), 0], [2, mpc(0, -1)]])
+    assert A.transpose_conj() == A.H == matrix([[mpc(1, -1), 2],
+                                                [0, mpc(0, -1)]])
+
+def test_matrix_creation():
+    assert diag([1, 2, 3]) == matrix([[1, 0, 0], [0, 2, 0], [0, 0, 3]])
+    A1 = ones(2, 3)
+    assert A1.rows == 2 and A1.cols == 3
+    for a in A1:
+        assert a == 1
+    A2 = zeros(3, 2)
+    assert A2.rows == 3 and A2.cols == 2
+    for a in A2:
+        assert a == 0
+    assert randmatrix(10) != randmatrix(10)
+    one = mpf(1)
+    assert hilbert(3) == matrix([[one, one/2, one/3],
+                                 [one/2, one/3, one/4],
+                                 [one/3, one/4, one/5]])
+
+def test_norms():
+    # matrix norms
+    A = matrix([[1, -2], [-3, -1], [2, 1]])
+    assert mnorm(A,1) == 6
+    assert mnorm(A,inf) == 4
+    assert mnorm(A,'F') == sqrt(20)
+    # vector norms
+    assert norm(-3) == 3
+    x = [1, -2, 7, -12]
+    assert norm(x, 1) == 22
+    assert round(norm(x, 2), 10) == 14.0712472795
+    assert round(norm(x, 10), 10) == 12.0054633727
+    assert norm(x, inf) == 12
+
+def test_vector():
+    x = matrix([0, 1, 2, 3, 4])
+    assert x == matrix([[0], [1], [2], [3], [4]])
+    assert x[3] == 3
+    assert len(x._matrix__data) == 4
+    assert list(x) == list(range(5))
+    x[0] = -10
+    x[4] = 0
+    assert x[0] == -10
+    assert len(x) == len(x.T) == 5
+    assert x.T*x == matrix([[114]])
+
+def test_matrix_copy():
+    A = ones(6)
+    B = A.copy()
+    C = +A
+    assert A == B
+    assert A == C
+    B[0,0] = 0
+    assert A != B
+    C[0,0] = 42
+    assert A != C
+
+def test_matrix_numpy():
+    try:
+        import numpy
+    except ImportError:
+        return
+    l = [[1, 2], [3, 4], [5, 6]]
+    a = numpy.array(l)
+    assert matrix(l) == matrix(a)
+
+def test_interval_matrix_scalar_mult():
+    """Multiplication of iv.matrix and any scalar type"""
+    a = mpi(-1, 1)
+    b = a + a * 2j
+    c = mpf(42)
+    d = c + c * 2j
+    e = 1.234
+    f = fp.convert(e)
+    g = e + e * 3j
+    h = fp.convert(g)
+    M = iv.ones(1)
+    for x in [a, b, c, d, e, f, g, h]:
+        assert x * M == iv.matrix([x])
+        assert M * x == iv.matrix([x])
+
+@pytest.mark.xfail()
+def test_interval_matrix_matrix_mult():
+    """Multiplication of iv.matrix and other matrix types"""
+    A = ones(1)
+    B = fp.ones(1)
+    M = iv.ones(1)
+    for X in [A, B, M]:
+        assert X * M == iv.matrix(X)
+        assert X * M == X
+        assert M * X == iv.matrix(X)
+        assert M * X == X
+
+def test_matrix_conversion_to_iv():
+    # Test that matrices with foreign datatypes are properly converted
+    for other_type_eye in [eye(3), fp.eye(3), iv.eye(3)]:
+        A = iv.matrix(other_type_eye)
+        B = iv.eye(3)
+        assert type(A[0,0]) == type(B[0,0])
+        assert A.tolist() == B.tolist()
+
+def test_interval_matrix_mult_bug():
+    # regression test for interval matrix multiplication:
+    # result must be nonzero-width and contain the exact result
+    x = convert('1.00000000000001') # note: this is implicitly rounded to some near mpf float value
+    A = matrix([[x]])
+    B = iv.matrix(A)
+    C = iv.matrix([[x]])
+    assert B == C
+    B = B * B
+    C = C * C
+    assert B == C
+    assert B[0, 0].delta > 1e-16
+    assert B[0, 0].delta < 3e-16
+    assert C[0, 0].delta > 1e-16
+    assert C[0, 0].delta < 3e-16
+    assert mp.mpf('1.00000000000001998401444325291756783368705994138804689654') in B[0, 0]
+    assert mp.mpf('1.00000000000001998401444325291756783368705994138804689654') in C[0, 0]
+    # the following caused an error before the bug was fixed
+    assert iv.matrix(mp.eye(2)) * (iv.ones(2) + mpi(1, 2)) == iv.matrix([[mpi(2, 3), mpi(2, 3)], [mpi(2, 3), mpi(2, 3)]])

llmeval-env/lib/python3.10/site-packages/mpmath/tests/test_mpmath.py

@@ -0,0 +1,7 @@
+from mpmath.libmp import *
+from mpmath import *
+
+def test_newstyle_classes():
+    for cls in [mp, fp, iv, mpf, mpc]:
+        for s in cls.__class__.__mro__:
+            assert isinstance(s, type)

llmeval-env/lib/python3.10/site-packages/mpmath/tests/test_ode.py

@@ -0,0 +1,73 @@
+#from mpmath.calculus import ODE_step_euler, ODE_step_rk4, odeint, arange
+from mpmath import odefun, cos, sin, mpf, sinc, mp
+
+'''
+solvers = [ODE_step_euler, ODE_step_rk4]
+
+def test_ode1():
+    """
+    Let's solve:
+
+    x'' + w**2 * x = 0
+
+    i.e. x1 = x, x2 = x1':
+
+    x1' =  x2
+    x2' = -x1
+    """
+    def derivs((x1, x2), t):
+        return x2, -x1
+
+    for solver in solvers:
+        t = arange(0, 3.1415926, 0.005)
+        sol = odeint(derivs, (0., 1.), t, solver)
+        x1 = [a[0] for a in sol]
+        x2 = [a[1] for a in sol]
+        # the result is x1 = sin(t), x2 = cos(t)
+        # let's just check the end points for t = pi
+        assert abs(x1[-1]) < 1e-2
+        assert abs(x2[-1] - (-1)) < 1e-2
+
+def test_ode2():
+    """
+    Let's solve:
+
+    x' - x = 0
+
+    i.e. x = exp(x)
+
+    """
+    def derivs((x), t):
+        return x
+
+    for solver in solvers:
+        t = arange(0, 1, 1e-3)
+        sol = odeint(derivs, (1.,), t, solver)
+        x = [a[0] for a in sol]
+        # the result is x = exp(t)
+        # let's just check the end point for t = 1, i.e. x = e
+        assert abs(x[-1] - 2.718281828) < 1e-2
+'''
+
+def test_odefun_rational():
+    mp.dps = 15
+    # A rational function
+    f = lambda t: 1/(1+mpf(t)**2)
+    g = odefun(lambda x, y: [-2*x*y[0]**2], 0, [f(0)])
+    assert f(2).ae(g(2)[0])
+
+def test_odefun_sinc_large():
+    mp.dps = 15
+    # Sinc function; test for large x
+    f = sinc
+    g = odefun(lambda x, y: [(cos(x)-y[0])/x], 1, [f(1)], tol=0.01, degree=5)
+    assert abs(f(100) - g(100)[0])/f(100) < 0.01
+
+def test_odefun_harmonic():
+    mp.dps = 15
+    # Harmonic oscillator
+    f = odefun(lambda x, y: [-y[1], y[0]], 0, [1, 0])
+    for x in [0, 1, 2.5, 8, 3.7]:    #  we go back to 3.7 to check caching
+        c, s = f(x)
+        assert c.ae(cos(x))
+        assert s.ae(sin(x))

llmeval-env/lib/python3.10/site-packages/mpmath/tests/test_pickle.py

@@ -0,0 +1,27 @@
+import os
+import tempfile
+import pickle
+
+from mpmath import *
+
+def pickler(obj):
+    fn = tempfile.mktemp()
+
+    f = open(fn, 'wb')
+    pickle.dump(obj, f)
+    f.close()
+
+    f = open(fn, 'rb')
+    obj2 = pickle.load(f)
+    f.close()
+    os.remove(fn)
+
+    return obj2
+
+def test_pickle():
+
+    obj = mpf('0.5')
+    assert obj == pickler(obj)
+
+    obj = mpc('0.5','0.2')
+    assert obj == pickler(obj)

llmeval-env/lib/python3.10/site-packages/mpmath/tests/test_power.py

@@ -0,0 +1,156 @@
+from mpmath import *
+from mpmath.libmp import *
+
+import random
+
+def test_fractional_pow():
+    mp.dps = 15
+    assert mpf(16) ** 2.5 == 1024
+    assert mpf(64) ** 0.5 == 8
+    assert mpf(64) ** -0.5 == 0.125
+    assert mpf(16) ** -2.5 == 0.0009765625
+    assert (mpf(10) ** 0.5).ae(3.1622776601683791)
+    assert (mpf(10) ** 2.5).ae(316.2277660168379)
+    assert (mpf(10) ** -0.5).ae(0.31622776601683794)
+    assert (mpf(10) ** -2.5).ae(0.0031622776601683794)
+    assert (mpf(10) ** 0.3).ae(1.9952623149688795)
+    assert (mpf(10) ** -0.3).ae(0.50118723362727224)
+
+def test_pow_integer_direction():
+    """
+    Test that inexact integer powers are rounded in the right
+    direction.
+    """
+    random.seed(1234)
+    for prec in [10, 53, 200]:
+        for i in range(50):
+            a = random.randint(1<<(prec-1), 1<<prec)
+            b = random.randint(2, 100)
+            ab = a**b
+            # note: could actually be exact, but that's very unlikely!
+            assert to_int(mpf_pow(from_int(a), from_int(b), prec, round_down)) < ab
+            assert to_int(mpf_pow(from_int(a), from_int(b), prec, round_up)) > ab
+
+
+def test_pow_epsilon_rounding():
+    """
+    Stress test directed rounding for powers with integer exponents.
+    Basically, we look at the following cases:
+
+    >>> 1.0001 ** -5 # doctest: +SKIP
+    0.99950014996500702
+    >>> 0.9999 ** -5 # doctest: +SKIP
+    1.000500150035007
+    >>> (-1.0001) ** -5 # doctest: +SKIP
+    -0.99950014996500702
+    >>> (-0.9999) ** -5 # doctest: +SKIP
+    -1.000500150035007
+
+    >>> 1.0001 ** -6 # doctest: +SKIP
+    0.99940020994401269
+    >>> 0.9999 ** -6 # doctest: +SKIP
+    1.0006002100560125
+    >>> (-1.0001) ** -6 # doctest: +SKIP
+    0.99940020994401269
+    >>> (-0.9999) ** -6 # doctest: +SKIP
+    1.0006002100560125
+
+    etc.
+
+    We run the tests with values a very small epsilon away from 1:
+    small enough that the result is indistinguishable from 1 when
+    rounded to nearest at the output precision. We check that the
+    result is not erroneously rounded to 1 in cases where the
+    rounding should be done strictly away from 1.
+    """
+
+    def powr(x, n, r):
+        return make_mpf(mpf_pow_int(x._mpf_, n, mp.prec, r))
+
+    for (inprec, outprec) in [(100, 20), (5000, 3000)]:
+
+        mp.prec = inprec
+
+        pos10001 = mpf(1) + mpf(2)**(-inprec+5)
+        pos09999 = mpf(1) - mpf(2)**(-inprec+5)
+        neg10001 = -pos10001
+        neg09999 = -pos09999
+
+        mp.prec = outprec
+        r = round_up
+        assert powr(pos10001, 5, r) > 1
+        assert powr(pos09999, 5, r) == 1
+        assert powr(neg10001, 5, r) < -1
+        assert powr(neg09999, 5, r) == -1
+        assert powr(pos10001, 6, r) > 1
+        assert powr(pos09999, 6, r) == 1
+        assert powr(neg10001, 6, r) > 1
+        assert powr(neg09999, 6, r) == 1
+
+        assert powr(pos10001, -5, r) == 1
+        assert powr(pos09999, -5, r) > 1
+        assert powr(neg10001, -5, r) == -1
+        assert powr(neg09999, -5, r) < -1
+        assert powr(pos10001, -6, r) == 1
+        assert powr(pos09999, -6, r) > 1
+        assert powr(neg10001, -6, r) == 1
+        assert powr(neg09999, -6, r) > 1
+
+        r = round_down
+        assert powr(pos10001, 5, r) == 1
+        assert powr(pos09999, 5, r) < 1
+        assert powr(neg10001, 5, r) == -1
+        assert powr(neg09999, 5, r) > -1
+        assert powr(pos10001, 6, r) == 1
+        assert powr(pos09999, 6, r) < 1
+        assert powr(neg10001, 6, r) == 1
+        assert powr(neg09999, 6, r) < 1
+
+        assert powr(pos10001, -5, r) < 1
+        assert powr(pos09999, -5, r) == 1
+        assert powr(neg10001, -5, r) > -1
+        assert powr(neg09999, -5, r) == -1
+        assert powr(pos10001, -6, r) < 1
+        assert powr(pos09999, -6, r) == 1
+        assert powr(neg10001, -6, r) < 1
+        assert powr(neg09999, -6, r) == 1
+
+        r = round_ceiling
+        assert powr(pos10001, 5, r) > 1
+        assert powr(pos09999, 5, r) == 1
+        assert powr(neg10001, 5, r) == -1
+        assert powr(neg09999, 5, r) > -1
+        assert powr(pos10001, 6, r) > 1
+        assert powr(pos09999, 6, r) == 1
+        assert powr(neg10001, 6, r) > 1
+        assert powr(neg09999, 6, r) == 1
+
+        assert powr(pos10001, -5, r) == 1
+        assert powr(pos09999, -5, r) > 1
+        assert powr(neg10001, -5, r) > -1
+        assert powr(neg09999, -5, r) == -1
+        assert powr(pos10001, -6, r) == 1
+        assert powr(pos09999, -6, r) > 1
+        assert powr(neg10001, -6, r) == 1
+        assert powr(neg09999, -6, r) > 1
+
+        r = round_floor
+        assert powr(pos10001, 5, r) == 1
+        assert powr(pos09999, 5, r) < 1
+        assert powr(neg10001, 5, r) < -1
+        assert powr(neg09999, 5, r) == -1
+        assert powr(pos10001, 6, r) == 1
+        assert powr(pos09999, 6, r) < 1
+        assert powr(neg10001, 6, r) == 1
+        assert powr(neg09999, 6, r) < 1
+
+        assert powr(pos10001, -5, r) < 1
+        assert powr(pos09999, -5, r) == 1
+        assert powr(neg10001, -5, r) == -1
+        assert powr(neg09999, -5, r) < -1
+        assert powr(pos10001, -6, r) < 1
+        assert powr(pos09999, -6, r) == 1
+        assert powr(neg10001, -6, r) < 1
+        assert powr(neg09999, -6, r) == 1
+
+    mp.dps = 15

llmeval-env/lib/python3.10/site-packages/mpmath/tests/test_quad.py

@@ -0,0 +1,95 @@
+import pytest
+from mpmath import *
+
+def ae(a, b):
+    return abs(a-b) < 10**(-mp.dps+5)
+
+def test_basic_integrals():
+    for prec in [15, 30, 100]:
+        mp.dps = prec
+        assert ae(quadts(lambda x: x**3 - 3*x**2, [-2, 4]), -12)
+        assert ae(quadgl(lambda x: x**3 - 3*x**2, [-2, 4]), -12)
+        assert ae(quadts(sin, [0, pi]), 2)
+        assert ae(quadts(sin, [0, 2*pi]), 0)
+        assert ae(quadts(exp, [-inf, -1]), 1/e)
+        assert ae(quadts(lambda x: exp(-x), [0, inf]), 1)
+        assert ae(quadts(lambda x: exp(-x*x), [-inf, inf]), sqrt(pi))
+        assert ae(quadts(lambda x: 1/(1+x*x), [-1, 1]), pi/2)
+        assert ae(quadts(lambda x: 1/(1+x*x), [-inf, inf]), pi)
+        assert ae(quadts(lambda x: 2*sqrt(1-x*x), [-1, 1]), pi)
+    mp.dps = 15
+
+def test_multiple_intervals():
+    y,err = quad(lambda x: sign(x), [-0.5, 0.9, 1], maxdegree=2, error=True)
+    assert abs(y-0.5) < 2*err
+
+def test_quad_symmetry():
+    assert quadts(sin, [-1, 1]) == 0
+    assert quadgl(sin, [-1, 1]) == 0
+
+def test_quad_infinite_mirror():
+    # Check mirrored infinite interval
+    assert ae(quad(lambda x: exp(-x*x), [inf,-inf]), -sqrt(pi))
+    assert ae(quad(lambda x: exp(x), [0,-inf]), -1)
+
+def test_quadgl_linear():
+    assert quadgl(lambda x: x, [0, 1], maxdegree=1).ae(0.5)
+
+def test_complex_integration():
+    assert quadts(lambda x: x, [0, 1+j]).ae(j)
+
+def test_quadosc():
+    mp.dps = 15
+    assert quadosc(lambda x: sin(x)/x, [0, inf], period=2*pi).ae(pi/2)
+
+# Double integrals
+def test_double_trivial():
+    assert ae(quadts(lambda x, y: x, [0, 1], [0, 1]), 0.5)
+    assert ae(quadts(lambda x, y: x, [-1, 1], [-1, 1]), 0.0)
+
+def test_double_1():
+    assert ae(quadts(lambda x, y: cos(x+y/2), [-pi/2, pi/2], [0, pi]), 4)
+
+def test_double_2():
+    assert ae(quadts(lambda x, y: (x-1)/((1-x*y)*log(x*y)), [0, 1], [0, 1]), euler)
+
+def test_double_3():
+    assert ae(quadts(lambda x, y: 1/sqrt(1+x*x+y*y), [-1, 1], [-1, 1]), 4*log(2+sqrt(3))-2*pi/3)
+
+def test_double_4():
+    assert ae(quadts(lambda x, y: 1/(1-x*x * y*y), [0, 1], [0, 1]), pi**2 / 8)
+
+def test_double_5():
+    assert ae(quadts(lambda x, y: 1/(1-x*y), [0, 1], [0, 1]), pi**2 / 6)
+
+def test_double_6():
+    assert ae(quadts(lambda x, y: exp(-(x+y)), [0, inf], [0, inf]), 1)
+
+def test_double_7():
+    assert ae(quadts(lambda x, y: exp(-x*x-y*y), [-inf, inf], [-inf, inf]), pi)
+
+
+# Test integrals from "Experimentation in Mathematics" by Borwein,
+# Bailey & Girgensohn
+def test_expmath_integrals():
+    for prec in [15, 30, 50]:
+        mp.dps = prec
+        assert ae(quadts(lambda x: x/sinh(x), [0, inf]),                    pi**2 / 4)
+        assert ae(quadts(lambda x: log(x)**2 / (1+x**2), [0, inf]),         pi**3 / 8)
+        assert ae(quadts(lambda x: (1+x**2)/(1+x**4), [0, inf]),            pi/sqrt(2))
+        assert ae(quadts(lambda x: log(x)/cosh(x)**2, [0, inf]),            log(pi)-2*log(2)-euler)
+        assert ae(quadts(lambda x: log(1+x**3)/(1-x+x**2), [0, inf]),       2*pi*log(3)/sqrt(3))
+        assert ae(quadts(lambda x: log(x)**2 / (x**2+x+1), [0, 1]),         8*pi**3 / (81*sqrt(3)))
+        assert ae(quadts(lambda x: log(cos(x))**2, [0, pi/2]),              pi/2 * (log(2)**2+pi**2/12))
+        assert ae(quadts(lambda x: x**2 / sin(x)**2, [0, pi/2]),            pi*log(2))
+        assert ae(quadts(lambda x: x**2/sqrt(exp(x)-1), [0, inf]),          4*pi*(log(2)**2 + pi**2/12))
+        assert ae(quadts(lambda x: x*exp(-x)*sqrt(1-exp(-2*x)), [0, inf]),  pi*(1+2*log(2))/8)
+    mp.dps = 15
+
+# Do not reach full accuracy
+@pytest.mark.xfail
+def test_expmath_fail():
+    assert ae(quadts(lambda x: sqrt(tan(x)), [0, pi/2]),          pi*sqrt(2)/2)
+    assert ae(quadts(lambda x: atan(x)/(x*sqrt(1-x**2)), [0, 1]), pi*log(1+sqrt(2))/2)
+    assert ae(quadts(lambda x: log(1+x**2)/x**2, [0, 1]),         pi/2-log(2))
+    assert ae(quadts(lambda x: x**2/((1+x**4)*sqrt(1-x**4)), [0, 1]),     pi/8)