Add files using upload-large-folder tool

env-llmeval/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()

env-llmeval/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

env-llmeval/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

env-llmeval/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()

env-llmeval/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

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

@@ -0,0 +1,2 @@
+from . import eigen           # to set methods
+from . import eigen_symmetric # to set methods

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

@@ -0,0 +1,1807 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+##################################################################################################
+#     module for the symmetric eigenvalue problem
+#       Copyright 2013 Timo Hartmann (thartmann15 at gmail.com)
+#
+# todo:
+#  - implement balancing
+#
+##################################################################################################
+
+"""
+The symmetric eigenvalue problem.
+---------------------------------
+
+This file contains routines for the symmetric eigenvalue problem.
+
+high level routines:
+
+  eigsy : real symmetric (ordinary) eigenvalue problem
+  eighe : complex hermitian (ordinary) eigenvalue problem
+  eigh  : unified interface for eigsy and eighe
+  svd_r : singular value decomposition for real matrices
+  svd_c : singular value decomposition for complex matrices
+  svd   : unified interface for svd_r and svd_c
+
+
+low level routines:
+
+  r_sy_tridiag : reduction of real symmetric matrix to real symmetric tridiagonal matrix
+  c_he_tridiag_0 : reduction of complex hermitian matrix to real symmetric tridiagonal matrix
+  c_he_tridiag_1 : auxiliary routine to c_he_tridiag_0
+  c_he_tridiag_2 : auxiliary routine to c_he_tridiag_0
+  tridiag_eigen : solves the real symmetric tridiagonal matrix eigenvalue problem
+  svd_r_raw : raw singular value decomposition for real matrices
+  svd_c_raw : raw singular value decomposition for complex matrices
+"""
+
+from ..libmp.backend import xrange
+from .eigen import defun
+
+
+def r_sy_tridiag(ctx, A, D, E, calc_ev = True):
+    """
+    This routine transforms a real symmetric matrix A to a real symmetric
+    tridiagonal matrix T using an orthogonal similarity transformation:
+          Q' * A * Q = T     (here ' denotes the matrix transpose).
+    The orthogonal matrix Q is build up from Householder reflectors.
+
+    parameters:
+      A         (input/output) On input, A contains the real symmetric matrix of
+                dimension (n,n). On output, if calc_ev is true, A contains the
+                orthogonal matrix Q, otherwise A is destroyed.
+
+      D         (output) real array of length n, contains the diagonal elements
+                of the tridiagonal matrix
+
+      E         (output) real array of length n, contains the offdiagonal elements
+                of the tridiagonal matrix in E[0:(n-1)] where is the dimension of
+                the matrix A. E[n-1] is undefined.
+
+      calc_ev   (input) If calc_ev is true, this routine explicitly calculates the
+                orthogonal matrix Q which is then returned in A. If calc_ev is
+                false, Q is not explicitly calculated resulting in a shorter run time.
+
+    This routine is a python translation of the fortran routine tred2.f in the
+    software library EISPACK (see netlib.org) which itself is based on the algol
+    procedure tred2 described in:
+      - Num. Math. 11, p.181-195 (1968) by Martin, Reinsch and Wilkonson
+      - Handbook for auto. comp., Vol II, Linear Algebra, p.212-226 (1971)
+
+    For a good introduction to Householder reflections, see also
+      Stoer, Bulirsch - Introduction to Numerical Analysis.
+    """
+
+    # note : the vector v of the i-th houshoulder reflector is stored in a[(i+1):,i]
+    #        whereas v/<v,v> is stored in a[i,(i+1):]
+
+    n = A.rows
+    for i in xrange(n - 1, 0, -1):
+        # scale the vector
+
+        scale = 0
+        for k in xrange(0, i):
+            scale += abs(A[k,i])
+
+        scale_inv = 0
+        if scale != 0:
+            scale_inv = 1/scale
+
+        # sadly there are floating point numbers not equal to zero whose reciprocal is infinity
+
+        if i == 1 or scale == 0 or ctx.isinf(scale_inv):
+            E[i] = A[i-1,i]        # nothing to do
+            D[i] = 0
+            continue
+
+        # calculate parameters for housholder transformation
+
+        H = 0
+        for k in xrange(0, i):
+            A[k,i] *= scale_inv
+            H += A[k,i] * A[k,i]
+
+        F = A[i-1,i]
+        G = ctx.sqrt(H)
+        if F > 0:
+            G = -G
+        E[i] = scale * G
+        H -= F * G
+        A[i-1,i] = F - G
+        F = 0
+
+        # apply housholder transformation
+
+        for j in xrange(0, i):
+            if calc_ev:
+                A[i,j] = A[j,i] / H
+
+            G = 0                  # calculate A*U
+            for k in xrange(0, j + 1):
+                G += A[k,j] * A[k,i]
+            for k in xrange(j + 1, i):
+                G += A[j,k] * A[k,i]
+
+            E[j] = G / H           # calculate P
+            F += E[j] * A[j,i]
+
+        HH = F / (2 * H)
+
+        for j in xrange(0, i):     # calculate reduced A
+            F = A[j,i]
+            G = E[j] - HH * F      # calculate Q
+            E[j] = G
+
+            for k in xrange(0, j + 1):
+                A[k,j] -= F * E[k] + G * A[k,i]
+
+        D[i] = H
+
+    for i in xrange(1, n):         # better for compatibility
+        E[i-1] = E[i]
+    E[n-1] = 0
+
+    if calc_ev:
+        D[0] = 0
+        for i in xrange(0, n):
+            if D[i] != 0:
+                for j in xrange(0, i):     # accumulate transformation matrices
+                    G = 0
+                    for k in xrange(0, i):
+                        G += A[i,k] * A[k,j]
+                    for k in xrange(0, i):
+                        A[k,j] -= G * A[k,i]
+
+            D[i] = A[i,i]
+            A[i,i] = 1
+
+            for j in xrange(0, i):
+                A[j,i] = A[i,j] = 0
+    else:
+        for i in xrange(0, n):
+            D[i] = A[i,i]
+
+
+
+
+
+def c_he_tridiag_0(ctx, A, D, E, T):
+    """
+    This routine transforms a complex hermitian matrix A to a real symmetric
+    tridiagonal matrix T using an unitary similarity transformation:
+          Q' * A * Q = T     (here ' denotes the hermitian matrix transpose,
+                              i.e. transposition und conjugation).
+    The unitary matrix Q is build up from Householder reflectors and
+    an unitary diagonal matrix.
+
+    parameters:
+      A         (input/output) On input, A contains the complex hermitian matrix
+                of dimension (n,n). On output, A contains the unitary matrix Q
+                in compressed form.
+
+      D         (output) real array of length n, contains the diagonal elements
+                of the tridiagonal matrix.
+
+      E         (output) real array of length n, contains the offdiagonal elements
+                of the tridiagonal matrix in E[0:(n-1)] where is the dimension of
+                the matrix A. E[n-1] is undefined.
+
+      T         (output) complex array of length n, contains a unitary diagonal
+                matrix.
+
+    This routine is a python translation (in slightly modified form) of the fortran
+    routine htridi.f in the software library EISPACK (see netlib.org) which itself
+    is a complex version of the algol procedure tred1 described in:
+      - Num. Math. 11, p.181-195 (1968) by Martin, Reinsch and Wilkonson
+      - Handbook for auto. comp., Vol II, Linear Algebra, p.212-226 (1971)
+
+    For a good introduction to Householder reflections, see also
+      Stoer, Bulirsch - Introduction to Numerical Analysis.
+    """
+
+    n = A.rows
+    T[n-1] = 1
+    for i in xrange(n - 1, 0, -1):
+
+        # scale the vector
+
+        scale = 0
+        for k in xrange(0, i):
+            scale += abs(ctx.re(A[k,i])) + abs(ctx.im(A[k,i]))
+
+        scale_inv = 0
+        if scale != 0:
+            scale_inv = 1 / scale
+
+        # sadly there are floating point numbers not equal to zero whose reciprocal is infinity
+
+        if scale == 0 or ctx.isinf(scale_inv):
+            E[i] = 0
+            D[i] = 0
+            T[i-1] = 1
+            continue
+
+        if i == 1:
+            F = A[i-1,i]
+            f = abs(F)
+            E[i] = f
+            D[i] = 0
+            if f != 0:
+                T[i-1] = T[i] * F / f
+            else:
+                T[i-1] = T[i]
+            continue
+
+        # calculate parameters for housholder transformation
+
+        H = 0
+        for k in xrange(0, i):
+            A[k,i] *= scale_inv
+            rr = ctx.re(A[k,i])
+            ii = ctx.im(A[k,i])
+            H += rr * rr + ii * ii
+
+        F = A[i-1,i]
+        f = abs(F)
+        G = ctx.sqrt(H)
+        H += G * f
+        E[i] = scale * G
+        if f != 0:
+            F = F / f
+            TZ = - T[i] * F              # T[i-1]=-T[i]*F, but we need T[i-1] as temporary storage
+            G *= F
+        else:
+            TZ = -T[i]                   # T[i-1]=-T[i]
+        A[i-1,i] += G
+        F = 0
+
+        # apply housholder transformation
+
+        for j in xrange(0, i):
+            A[i,j] = A[j,i] / H
+
+            G = 0                        # calculate A*U
+            for k in xrange(0, j + 1):
+                G += ctx.conj(A[k,j]) * A[k,i]
+            for k in xrange(j + 1, i):
+                G += A[j,k] * A[k,i]
+
+            T[j] = G / H                 # calculate P
+            F += ctx.conj(T[j]) * A[j,i]
+
+        HH = F / (2 * H)
+
+        for j in xrange(0, i):           # calculate reduced A
+            F = A[j,i]
+            G = T[j] - HH * F            # calculate Q
+            T[j] = G
+
+            for k in xrange(0, j + 1):
+                A[k,j] -= ctx.conj(F) * T[k] + ctx.conj(G) * A[k,i]
+                # as we use the lower left part for storage
+                # we have to use the transpose of the normal formula
+
+        T[i-1] = TZ
+        D[i] = H
+
+    for i in xrange(1, n):                # better for compatibility
+        E[i-1] = E[i]
+    E[n-1] = 0
+
+    D[0] = 0
+    for i in xrange(0, n):
+        zw = D[i]
+        D[i] = ctx.re(A[i,i])
+        A[i,i] = zw
+
+
+
+
+
+
+
+def c_he_tridiag_1(ctx, A, T):
+    """
+    This routine forms the unitary matrix Q described in c_he_tridiag_0.
+
+    parameters:
+      A    (input/output) On input, A is the same matrix as delivered by
+           c_he_tridiag_0. On output, A is set to Q.
+
+      T    (input) On input, T is the same array as delivered by c_he_tridiag_0.
+
+    """
+
+    n = A.rows
+
+    for i in xrange(0, n):
+        if A[i,i] != 0:
+            for j in xrange(0, i):
+                G = 0
+                for k in xrange(0, i):
+                    G += ctx.conj(A[i,k]) * A[k,j]
+                for k in xrange(0, i):
+                    A[k,j] -= G * A[k,i]
+
+        A[i,i] = 1
+
+        for j in xrange(0, i):
+            A[j,i] = A[i,j] = 0
+
+    for i in xrange(0, n):
+        for k in xrange(0, n):
+            A[i,k] *= T[k]
+
+
+
+
+def c_he_tridiag_2(ctx, A, T, B):
+    """
+    This routine applied the unitary matrix Q described in c_he_tridiag_0
+    onto the the matrix B, i.e. it forms Q*B.
+
+    parameters:
+      A    (input) On input, A is the same matrix as delivered by c_he_tridiag_0.
+
+      T    (input) On input, T is the same array as delivered by c_he_tridiag_0.
+
+      B    (input/output) On input, B is a complex matrix. On output B is replaced
+           by Q*B.
+
+    This routine is a python translation of the fortran routine htribk.f in the
+    software library EISPACK (see netlib.org). See c_he_tridiag_0 for more
+    references.
+    """
+
+    n = A.rows
+
+    for i in xrange(0, n):
+        for k in xrange(0, n):
+            B[k,i] *= T[k]
+
+    for i in xrange(0, n):
+        if A[i,i] != 0:
+            for j in xrange(0, n):
+                G = 0
+                for k in xrange(0, i):
+                    G += ctx.conj(A[i,k]) * B[k,j]
+                for k in xrange(0, i):
+                    B[k,j] -= G * A[k,i]
+
+
+
+
+
+def tridiag_eigen(ctx, d, e, z = False):
+    """
+    This subroutine find the eigenvalues and the first components of the
+    eigenvectors of a real symmetric tridiagonal matrix using the implicit
+    QL method.
+
+    parameters:
+
+      d (input/output) real array of length n. on input, d contains the diagonal
+        elements of the input matrix. on output, d contains the eigenvalues in
+        ascending order.
+
+      e (input) real array of length n. on input, e contains the offdiagonal
+        elements of the input matrix in e[0:(n-1)]. On output, e has been
+        destroyed.
+
+      z (input/output) If z is equal to False, no eigenvectors will be computed.
+        Otherwise on input z should have the format z[0:m,0:n] (i.e. a real or
+        complex matrix of dimension (m,n) ). On output this matrix will be
+        multiplied by the matrix of the eigenvectors (i.e. the columns of this
+        matrix are the eigenvectors): z --> z*EV
+        That means if z[i,j]={1 if j==j; 0 otherwise} on input, then on output
+        z will contain the first m components of the eigenvectors. That means
+        if m is equal to n, the i-th eigenvector will be z[:,i].
+
+    This routine is a python translation (in slightly modified form) of the
+    fortran routine imtql2.f in the software library EISPACK (see netlib.org)
+    which itself is based on the algol procudure imtql2 desribed in:
+     - num. math. 12, p. 377-383(1968) by matrin and wilkinson
+     - modified in num. math. 15, p. 450(1970) by dubrulle
+     - handbook for auto. comp., vol. II-linear algebra, p. 241-248 (1971)
+    See also the routine gaussq.f in netlog.org or acm algorithm 726.
+    """
+
+    n = len(d)
+    e[n-1] = 0
+    iterlim = 2 * ctx.dps
+
+    for l in xrange(n):
+        j = 0
+        while 1:
+            m = l
+            while 1:
+                # look for a small subdiagonal element
+                if m + 1 == n:
+                    break
+                if abs(e[m]) <= ctx.eps * (abs(d[m]) + abs(d[m + 1])):
+                    break
+                m = m + 1
+            if m == l:
+                break
+
+            if j >= iterlim:
+                raise RuntimeError("tridiag_eigen: no convergence to an eigenvalue after %d iterations" % iterlim)
+
+            j += 1
+
+            # form shift
+
+            p = d[l]
+            g = (d[l + 1] - p) / (2 * e[l])
+            r = ctx.hypot(g, 1)
+
+            if g < 0:
+                s = g - r
+            else:
+                s = g + r
+
+            g = d[m] - p + e[l] / s
+
+            s, c, p = 1, 1, 0
+
+            for i in xrange(m - 1, l - 1, -1):
+                f = s * e[i]
+                b = c * e[i]
+                if abs(f) > abs(g):             # this here is a slight improvement also used in gaussq.f or acm algorithm 726.
+                    c = g / f
+                    r = ctx.hypot(c, 1)
+                    e[i + 1] = f * r
+                    s = 1 / r
+                    c = c * s
+                else:
+                    s = f / g
+                    r = ctx.hypot(s, 1)
+                    e[i + 1] = g * r
+                    c = 1 / r
+                    s = s * c
+                g = d[i + 1] - p
+                r = (d[i] - g) * s + 2 * c * b
+                p = s * r
+                d[i + 1] = g + p
+                g = c * r - b
+
+                if not isinstance(z, bool):
+                    # calculate eigenvectors
+                    for w in xrange(z.rows):
+                        f = z[w,i+1]
+                        z[w,i+1] = s * z[w,i] + c * f
+                        z[w,i  ] = c * z[w,i] - s * f
+
+            d[l] = d[l] - p
+            e[l] = g
+            e[m] = 0
+
+    for ii in xrange(1, n):
+        # sort eigenvalues and eigenvectors (bubble-sort)
+        i = ii - 1
+        k = i
+        p = d[i]
+        for j in xrange(ii, n):
+            if d[j] >= p:
+                continue
+            k = j
+            p = d[k]
+        if k == i:
+            continue
+        d[k] = d[i]
+        d[i] = p
+
+        if not isinstance(z, bool):
+            for w in xrange(z.rows):
+                p = z[w,i]
+                z[w,i] = z[w,k]
+                z[w,k] = p
+
+########################################################################################
+
+@defun
+def eigsy(ctx, A, eigvals_only = False, overwrite_a = False):
+    """
+    This routine solves the (ordinary) eigenvalue problem for a real symmetric
+    square matrix A. Given A, an orthogonal matrix Q is calculated which
+    diagonalizes A:
+
+          Q' A Q = diag(E)               and                Q Q' = Q' Q = 1
+
+    Here diag(E) is a diagonal matrix whose diagonal is E.
+    ' denotes the transpose.
+
+    The columns of Q are the eigenvectors of A and E contains the eigenvalues:
+
+          A Q[:,i] = E[i] Q[:,i]
+
+
+    input:
+
+      A: real matrix of format (n,n) which is symmetric
+         (i.e. A=A' or A[i,j]=A[j,i])
+
+      eigvals_only: if true, calculates only the eigenvalues E.
+                    if false, calculates both eigenvectors and eigenvalues.
+
+      overwrite_a: if true, allows modification of A which may improve
+                   performance. if false, A is not modified.
+
+    output:
+
+      E: vector of format (n). contains the eigenvalues of A in ascending order.
+
+      Q: orthogonal matrix of format (n,n). contains the eigenvectors
+         of A as columns.
+
+    return value:
+
+          E          if eigvals_only is true
+         (E, Q)      if eigvals_only is false
+
+    example:
+      >>> from mpmath import mp
+      >>> A = mp.matrix([[3, 2], [2, 0]])
+      >>> E = mp.eigsy(A, eigvals_only = True)
+      >>> print(E)
+      [-1.0]
+      [ 4.0]
+
+      >>> A = mp.matrix([[1, 2], [2, 3]])
+      >>> E, Q = mp.eigsy(A)
+      >>> print(mp.chop(A * Q[:,0] - E[0] * Q[:,0]))
+      [0.0]
+      [0.0]
+
+    see also: eighe, eigh, eig
+    """
+
+    if not overwrite_a:
+        A = A.copy()
+
+    d = ctx.zeros(A.rows, 1)
+    e = ctx.zeros(A.rows, 1)
+
+    if eigvals_only:
+        r_sy_tridiag(ctx, A, d, e, calc_ev = False)
+        tridiag_eigen(ctx, d, e, False)
+        return d
+    else:
+        r_sy_tridiag(ctx, A, d, e, calc_ev = True)
+        tridiag_eigen(ctx, d, e, A)
+        return (d, A)
+
+
+@defun
+def eighe(ctx, A, eigvals_only = False, overwrite_a = False):
+    """
+    This routine solves the (ordinary) eigenvalue problem for a complex
+    hermitian square matrix A. Given A, an unitary matrix Q is calculated which
+    diagonalizes A:
+
+        Q' A Q = diag(E)               and                Q Q' = Q' Q = 1
+
+    Here diag(E) a is diagonal matrix whose diagonal is E.
+    ' denotes the hermitian transpose (i.e. ordinary transposition and
+    complex conjugation).
+
+    The columns of Q are the eigenvectors of A and E contains the eigenvalues:
+
+        A Q[:,i] = E[i] Q[:,i]
+
+
+    input:
+
+      A: complex matrix of format (n,n) which is hermitian
+         (i.e. A=A' or A[i,j]=conj(A[j,i]))
+
+      eigvals_only: if true, calculates only the eigenvalues E.
+                    if false, calculates both eigenvectors and eigenvalues.
+
+      overwrite_a: if true, allows modification of A which may improve
+                   performance. if false, A is not modified.
+
+    output:
+
+      E: vector of format (n). contains the eigenvalues of A in ascending order.
+
+      Q: unitary matrix of format (n,n). contains the eigenvectors
+         of A as columns.
+
+    return value:
+
+           E         if eigvals_only is true
+          (E, Q)     if eigvals_only is false
+
+    example:
+      >>> from mpmath import mp
+      >>> A = mp.matrix([[1, -3 - 1j], [-3 + 1j, -2]])
+      >>> E = mp.eighe(A, eigvals_only = True)
+      >>> print(E)
+      [-4.0]
+      [ 3.0]
+
+      >>> A = mp.matrix([[1, 2 + 5j], [2 - 5j, 3]])
+      >>> E, Q = mp.eighe(A)
+      >>> print(mp.chop(A * Q[:,0] - E[0] * Q[:,0]))
+      [0.0]
+      [0.0]
+
+    see also: eigsy, eigh, eig
+    """
+
+    if not overwrite_a:
+        A = A.copy()
+
+    d = ctx.zeros(A.rows, 1)
+    e = ctx.zeros(A.rows, 1)
+    t = ctx.zeros(A.rows, 1)
+
+    if eigvals_only:
+        c_he_tridiag_0(ctx, A, d, e, t)
+        tridiag_eigen(ctx, d, e, False)
+        return d
+    else:
+        c_he_tridiag_0(ctx, A, d, e, t)
+        B = ctx.eye(A.rows)
+        tridiag_eigen(ctx, d, e, B)
+        c_he_tridiag_2(ctx, A, t, B)
+        return (d, B)
+
+@defun
+def eigh(ctx, A, eigvals_only = False, overwrite_a = False):
+    """
+    "eigh" is a unified interface for "eigsy" and "eighe". Depending on
+    whether A is real or complex the appropriate function is called.
+
+    This routine solves the (ordinary) eigenvalue problem for a real symmetric
+    or complex hermitian square matrix A. Given A, an orthogonal (A real) or
+    unitary (A complex) matrix Q is calculated which diagonalizes A:
+
+        Q' A Q = diag(E)               and                Q Q' = Q' Q = 1
+
+    Here diag(E) a is diagonal matrix whose diagonal is E.
+    ' denotes the hermitian transpose (i.e. ordinary transposition and
+    complex conjugation).
+
+    The columns of Q are the eigenvectors of A and E contains the eigenvalues:
+
+        A Q[:,i] = E[i] Q[:,i]
+
+    input:
+
+      A: a real or complex square matrix of format (n,n) which is symmetric
+         (i.e. A[i,j]=A[j,i]) or hermitian (i.e. A[i,j]=conj(A[j,i])).
+
+      eigvals_only: if true, calculates only the eigenvalues E.
+                    if false, calculates both eigenvectors and eigenvalues.
+
+      overwrite_a: if true, allows modification of A which may improve
+                   performance. if false, A is not modified.
+
+    output:
+
+      E: vector of format (n). contains the eigenvalues of A in ascending order.
+
+      Q: an orthogonal or unitary matrix of format (n,n). contains the
+         eigenvectors of A as columns.
+
+    return value:
+
+          E         if eigvals_only is true
+         (E, Q)     if eigvals_only is false
+
+    example:
+      >>> from mpmath import mp
+      >>> A = mp.matrix([[3, 2], [2, 0]])
+      >>> E = mp.eigh(A, eigvals_only = True)
+      >>> print(E)
+      [-1.0]
+      [ 4.0]
+
+      >>> A = mp.matrix([[1, 2], [2, 3]])
+      >>> E, Q = mp.eigh(A)
+      >>> print(mp.chop(A * Q[:,0] - E[0] * Q[:,0]))
+      [0.0]
+      [0.0]
+
+      >>> A = mp.matrix([[1, 2 + 5j], [2 - 5j, 3]])
+      >>> E, Q = mp.eigh(A)
+      >>> print(mp.chop(A * Q[:,0] - E[0] * Q[:,0]))
+      [0.0]
+      [0.0]
+
+    see also: eigsy, eighe, eig
+    """
+
+    iscomplex = any(type(x) is ctx.mpc for x in A)
+
+    if iscomplex:
+        return ctx.eighe(A, eigvals_only = eigvals_only, overwrite_a = overwrite_a)
+    else:
+        return ctx.eigsy(A, eigvals_only = eigvals_only, overwrite_a = overwrite_a)
+
+
+@defun
+def gauss_quadrature(ctx, n, qtype = "legendre", alpha = 0, beta = 0):
+    """
+    This routine calulates gaussian quadrature rules for different
+    families of orthogonal polynomials. Let (a, b) be an interval,
+    W(x) a positive weight function and n a positive integer.
+    Then the purpose of this routine is to calculate pairs (x_k, w_k)
+    for k=0, 1, 2, ... (n-1) which give
+
+      int(W(x) * F(x), x = a..b) = sum(w_k * F(x_k),k = 0..(n-1))
+
+    exact for all polynomials F(x) of degree (strictly) less than 2*n. For all
+    integrable functions F(x) the sum is a (more or less) good approximation to
+    the integral. The x_k are called nodes (which are the zeros of the
+    related orthogonal polynomials) and the w_k are called the weights.
+
+    parameters
+       n        (input) The degree of the quadrature rule, i.e. its number of
+                nodes.
+
+       qtype    (input) The family of orthogonal polynmomials for which to
+                compute the quadrature rule. See the list below.
+
+       alpha    (input) real number, used as parameter for some orthogonal
+                polynomials
+
+       beta     (input) real number, used as parameter for some orthogonal
+                polynomials.
+
+    return value
+
+      (X, W)    a pair of two real arrays where x_k = X[k] and w_k = W[k].
+
+
+    orthogonal polynomials:
+
+      qtype           polynomial
+      -----           ----------
+
+      "legendre"      Legendre polynomials, W(x)=1 on the interval (-1, +1)
+      "legendre01"    shifted Legendre polynomials, W(x)=1 on the interval (0, +1)
+      "hermite"       Hermite polynomials, W(x)=exp(-x*x) on (-infinity,+infinity)
+      "laguerre"      Laguerre polynomials, W(x)=exp(-x) on (0,+infinity)
+      "glaguerre"     generalized Laguerre polynomials, W(x)=exp(-x)*x**alpha
+                      on (0, +infinity)
+      "chebyshev1"    Chebyshev polynomials of the first kind, W(x)=1/sqrt(1-x*x)
+                      on (-1, +1)
+      "chebyshev2"    Chebyshev polynomials of the second kind, W(x)=sqrt(1-x*x)
+                      on (-1, +1)
+      "jacobi"        Jacobi polynomials, W(x)=(1-x)**alpha * (1+x)**beta on (-1, +1)
+                      with alpha>-1 and beta>-1
+
+    examples:
+      >>> from mpmath import mp
+      >>> f = lambda x: x**8 + 2 * x**6 - 3 * x**4 + 5 * x**2 - 7
+      >>> X, W = mp.gauss_quadrature(5, "hermite")
+      >>> A = mp.fdot([(f(x), w) for x, w in zip(X, W)])
+      >>> B = mp.sqrt(mp.pi) * 57 / 16
+      >>> C = mp.quad(lambda x: mp.exp(- x * x) * f(x), [-mp.inf, +mp.inf])
+      >>> mp.nprint((mp.chop(A-B, tol = 1e-10), mp.chop(A-C, tol = 1e-10)))
+      (0.0, 0.0)
+
+      >>> f = lambda x: x**5 - 2 * x**4 + 3 * x**3 - 5 * x**2 + 7 * x - 11
+      >>> X, W = mp.gauss_quadrature(3, "laguerre")
+      >>> A = mp.fdot([(f(x), w) for x, w in zip(X, W)])
+      >>> B = 76
+      >>> C = mp.quad(lambda x: mp.exp(-x) * f(x), [0, +mp.inf])
+      >>> mp.nprint(mp.chop(A-B, tol = 1e-10), mp.chop(A-C, tol = 1e-10))
+      .0
+
+      # orthogonality of the chebyshev polynomials:
+      >>> f = lambda x: mp.chebyt(3, x) * mp.chebyt(2, x)
+      >>> X, W = mp.gauss_quadrature(3, "chebyshev1")
+      >>> A = mp.fdot([(f(x), w) for x, w in zip(X, W)])
+      >>> print(mp.chop(A, tol = 1e-10))
+      0.0
+
+    references:
+      - golub and welsch, "calculations of gaussian quadrature rules", mathematics of
+        computation 23, p. 221-230 (1969)
+      - golub, "some modified matrix eigenvalue problems", siam review 15, p. 318-334 (1973)
+      - stroud and secrest, "gaussian quadrature formulas", prentice-hall (1966)
+
+    See also the routine gaussq.f in netlog.org or ACM Transactions on
+    Mathematical Software algorithm 726.
+    """
+
+    d = ctx.zeros(n, 1)
+    e = ctx.zeros(n, 1)
+    z = ctx.zeros(1, n)
+
+    z[0,0] = 1
+
+    if qtype == "legendre":
+        # legendre on the range -1 +1 , abramowitz, table 25.4, p.916
+        w = 2
+        for i in xrange(n):
+            j = i + 1
+            e[i] = ctx.sqrt(j * j / (4 * j * j - ctx.mpf(1)))
+    elif qtype == "legendre01":
+        # legendre shifted to 0 1        , abramowitz, table 25.8, p.921
+        w = 1
+        for i in xrange(n):
+            d[i] = 1 / ctx.mpf(2)
+            j = i + 1
+            e[i] = ctx.sqrt(j * j / (16 * j * j - ctx.mpf(4)))
+    elif qtype == "hermite":
+        # hermite on the range -inf +inf , abramowitz, table 25.10,p.924
+        w = ctx.sqrt(ctx.pi)
+        for i in xrange(n):
+            j = i + 1
+            e[i] = ctx.sqrt(j / ctx.mpf(2))
+    elif qtype == "laguerre":
+        # laguerre on the range 0 +inf , abramowitz, table 25.9, p. 923
+        w = 1
+        for i in xrange(n):
+            j = i + 1
+            d[i] = 2 * j - 1
+            e[i] = j
+    elif qtype=="chebyshev1":
+        # chebyshev polynimials of the first kind
+        w = ctx.pi
+        for i in xrange(n):
+            e[i] = 1 / ctx.mpf(2)
+        e[0] = ctx.sqrt(1 / ctx.mpf(2))
+    elif qtype == "chebyshev2":
+        # chebyshev polynimials of the second kind
+        w = ctx.pi / 2
+        for i in xrange(n):
+            e[i] = 1 / ctx.mpf(2)
+    elif qtype == "glaguerre":
+        # generalized laguerre on the range 0 +inf
+        w = ctx.gamma(1 + alpha)
+        for i in xrange(n):
+            j = i + 1
+            d[i] = 2 * j - 1 + alpha
+            e[i] = ctx.sqrt(j * (j + alpha))
+    elif qtype == "jacobi":
+        # jacobi polynomials
+        alpha = ctx.mpf(alpha)
+        beta = ctx.mpf(beta)
+        ab = alpha + beta
+        abi = ab + 2
+        w = (2**(ab+1)) * ctx.gamma(alpha + 1) * ctx.gamma(beta + 1) / ctx.gamma(abi)
+        d[0] = (beta - alpha) / abi
+        e[0] = ctx.sqrt(4 * (1 + alpha) * (1 + beta) / ((abi + 1) * (abi * abi)))
+        a2b2 = beta * beta - alpha * alpha
+        for i in xrange(1, n):
+            j = i + 1
+            abi = 2 * j + ab
+            d[i] = a2b2 / ((abi - 2) * abi)
+            e[i] = ctx.sqrt(4 * j * (j + alpha) * (j + beta) * (j + ab) / ((abi * abi - 1) * abi * abi))
+    elif isinstance(qtype, str):
+        raise ValueError("unknown quadrature rule \"%s\"" % qtype)
+    elif not isinstance(qtype, str):
+        w = qtype(d, e)
+    else:
+        assert 0
+
+    tridiag_eigen(ctx, d, e, z)
+
+    for i in xrange(len(z)):
+        z[i] *= z[i]
+
+    z = z.transpose()
+    return (d, w * z)
+
+##################################################################################################
+##################################################################################################
+##################################################################################################
+
+def svd_r_raw(ctx, A, V = False, calc_u = False):
+    """
+    This routine computes the singular value decomposition of a matrix A.
+    Given A, two orthogonal matrices U and V are calculated such that
+
+                    A = U S V
+
+    where S is a suitable shaped matrix whose off-diagonal elements are zero.
+    The diagonal elements of S are the singular values of A, i.e. the
+    squareroots of the eigenvalues of A' A or A A'. Here ' denotes the transpose.
+    Householder bidiagonalization and a variant of the QR algorithm is used.
+
+    overview of the matrices :
+
+      A : m*n       A gets replaced by U
+      U : m*n       U replaces A. If n>m then only the first m*m block of U is
+                    non-zero. column-orthogonal: U' U = B
+                    here B is a n*n matrix whose first min(m,n) diagonal
+                    elements are 1 and all other elements are zero.
+      S : n*n       diagonal matrix, only the diagonal elements are stored in
+                    the array S. only the first min(m,n) diagonal elements are non-zero.
+      V : n*n       orthogonal: V V' = V' V = 1
+
+    parameters:
+      A        (input/output) On input, A contains a real matrix of shape m*n.
+               On output, if calc_u is true A contains the column-orthogonal
+               matrix U; otherwise A is simply used as workspace and thus destroyed.
+
+      V        (input/output) if false, the matrix V is not calculated. otherwise
+               V must be a matrix of shape n*n.
+
+      calc_u   (input) If true, the matrix U is calculated and replaces A.
+               if false, U is not calculated and A is simply destroyed
+
+    return value:
+      S        an array of length n containing the singular values of A sorted by
+               decreasing magnitude. only the first min(m,n) elements are non-zero.
+
+    This routine is a python translation of the fortran routine svd.f in the
+    software library EISPACK (see netlib.org) which itself is based on the
+    algol procedure svd described in:
+      - num. math. 14, 403-420(1970) by golub and reinsch.
+      - wilkinson/reinsch: handbook for auto. comp., vol ii-linear algebra, 134-151(1971).
+
+    """
+
+    m, n = A.rows, A.cols
+
+    S = ctx.zeros(n, 1)
+
+    # work is a temporary array of size n
+    work = ctx.zeros(n, 1)
+
+    g = scale = anorm = 0
+    maxits = 3 * ctx.dps
+
+    for i in xrange(n):     # householder reduction to bidiagonal form
+        work[i] = scale*g
+        g = s = scale = 0
+        if i < m:
+            for k in xrange(i, m):
+                scale += ctx.fabs(A[k,i])
+            if scale != 0:
+                for k in xrange(i, m):
+                    A[k,i] /= scale
+                    s += A[k,i] * A[k,i]
+                f = A[i,i]
+                g = -ctx.sqrt(s)
+                if f < 0:
+                    g = -g
+                h = f * g - s
+                A[i,i] = f - g
+                for j in xrange(i+1, n):
+                    s = 0
+                    for k in xrange(i, m):
+                        s += A[k,i] * A[k,j]
+                    f = s / h
+                    for k in xrange(i, m):
+                        A[k,j] += f * A[k,i]
+                for k in xrange(i,m):
+                    A[k,i] *= scale
+
+        S[i] = scale * g
+        g = s = scale = 0
+
+        if i < m and i != n - 1:
+            for k in xrange(i+1, n):
+                scale += ctx.fabs(A[i,k])
+            if scale:
+                for k in xrange(i+1, n):
+                    A[i,k] /= scale
+                    s += A[i,k] * A[i,k]
+                f = A[i,i+1]
+                g = -ctx.sqrt(s)
+                if f < 0:
+                    g = -g
+                h = f * g - s
+                A[i,i+1] = f - g
+
+                for k in xrange(i+1, n):
+                    work[k] = A[i,k] / h
+
+                for j in xrange(i+1, m):
+                    s = 0
+                    for k in xrange(i+1, n):
+                        s += A[j,k] * A[i,k]
+                    for k in xrange(i+1, n):
+                        A[j,k] += s * work[k]
+
+                for k in xrange(i+1, n):
+                    A[i,k] *= scale
+
+        anorm = max(anorm, ctx.fabs(S[i]) + ctx.fabs(work[i]))
+
+    if not isinstance(V, bool):
+        for i in xrange(n-2, -1, -1):     # accumulation of right hand transformations
+            V[i+1,i+1] = 1
+
+            if work[i+1] != 0:
+                for j in xrange(i+1, n):
+                    V[i,j] = (A[i,j] / A[i,i+1]) / work[i+1]
+                for j in xrange(i+1, n):
+                    s = 0
+                    for k in xrange(i+1, n):
+                        s += A[i,k] * V[j,k]
+                    for k in xrange(i+1, n):
+                        V[j,k] += s * V[i,k]
+
+            for j in xrange(i+1, n):
+                V[j,i] = V[i,j] = 0
+
+        V[0,0] = 1
+
+    if m<n : minnm = m
+    else   : minnm = n
+
+    if calc_u:
+        for i in xrange(minnm-1, -1, -1): # accumulation of left hand transformations
+            g = S[i]
+            for j in xrange(i+1, n):
+                A[i,j] = 0
+            if g != 0:
+                g = 1 / g
+                for j in xrange(i+1, n):
+                    s = 0
+                    for k in xrange(i+1, m):
+                        s += A[k,i] * A[k,j]
+                    f = (s / A[i,i]) * g
+                    for k in xrange(i, m):
+                        A[k,j] += f * A[k,i]
+                for j in xrange(i, m):
+                    A[j,i] *= g
+            else:
+                for j in xrange(i, m):
+                    A[j,i] = 0
+            A[i,i] += 1
+
+    for k in xrange(n - 1, -1, -1):
+        # diagonalization of the bidiagonal form:
+        #   loop over singular values, and over allowed itations
+
+        its = 0
+        while 1:
+            its += 1
+            flag = True
+
+            for l in xrange(k, -1, -1):
+                nm = l-1
+
+                if ctx.fabs(work[l]) + anorm == anorm:
+                    flag = False
+                    break
+
+                if ctx.fabs(S[nm]) + anorm == anorm:
+                    break
+
+            if flag:
+                c = 0
+                s = 1
+                for i in xrange(l, k + 1):
+                    f = s * work[i]
+                    work[i] *= c
+                    if ctx.fabs(f) + anorm == anorm:
+                        break
+                    g = S[i]
+                    h = ctx.hypot(f, g)
+                    S[i] = h
+                    h = 1 / h
+                    c = g * h
+                    s = - f * h
+
+                    if calc_u:
+                        for j in xrange(m):
+                            y = A[j,nm]
+                            z = A[j,i]
+                            A[j,nm] = y * c + z * s
+                            A[j,i]  = z * c - y * s
+
+            z = S[k]
+
+            if l == k:               # convergence
+                if z < 0:            # singular value is made nonnegative
+                    S[k] = -z
+                    if not isinstance(V, bool):
+                        for j in xrange(n):
+                            V[k,j] = -V[k,j]
+                break
+
+            if its >= maxits:
+                raise RuntimeError("svd: no convergence to an eigenvalue after %d iterations" % its)
+
+            x = S[l]         # shift from bottom 2 by 2 minor
+            nm = k-1
+            y = S[nm]
+            g = work[nm]
+            h = work[k]
+            f = ((y - z) * (y + z) + (g - h) * (g + h))/(2 * h * y)
+            g = ctx.hypot(f, 1)
+            if f >= 0: f = ((x - z) * (x + z) + h * ((y / (f + g)) - h)) / x
+            else:      f = ((x - z) * (x + z) + h * ((y / (f - g)) - h)) / x
+
+            c = s = 1         # next qt transformation
+
+            for j in xrange(l, nm + 1):
+                g = work[j+1]
+                y = S[j+1]
+                h = s * g
+                g = c * g
+                z = ctx.hypot(f, h)
+                work[j] = z
+                c = f / z
+                s = h / z
+                f = x * c + g * s
+                g = g * c - x * s
+                h = y * s
+                y *= c
+                if not isinstance(V, bool):
+                    for jj in xrange(n):
+                        x = V[j  ,jj]
+                        z = V[j+1,jj]
+                        V[j    ,jj]= x * c + z * s
+                        V[j+1  ,jj]= z * c - x * s
+                z = ctx.hypot(f, h)
+                S[j] = z
+                if z != 0:            # rotation can be arbitray if z=0
+                    z = 1 / z
+                    c = f * z
+                    s = h * z
+                f = c * g + s * y
+                x = c * y - s * g
+
+                if calc_u:
+                    for jj in xrange(m):
+                        y = A[jj,j  ]
+                        z = A[jj,j+1]
+                        A[jj,j    ] = y * c + z * s
+                        A[jj,j+1  ] = z * c - y * s
+
+            work[l] = 0
+            work[k] = f
+            S[k] = x
+
+    ##########################
+
+    # Sort singular values into decreasing order (bubble-sort)
+
+    for i in xrange(n):
+        imax = i
+        s = ctx.fabs(S[i])         # s is the current maximal element
+
+        for j in xrange(i + 1, n):
+            c = ctx.fabs(S[j])
+            if c > s:
+                s = c
+                imax = j
+
+        if imax != i:
+            # swap singular values
+
+            z = S[i]
+            S[i] = S[imax]
+            S[imax] = z
+
+            if calc_u:
+                for j in xrange(m):
+                    z = A[j,i]
+                    A[j,i] = A[j,imax]
+                    A[j,imax] = z
+
+            if not isinstance(V, bool):
+                for j in xrange(n):
+                    z = V[i,j]
+                    V[i,j] = V[imax,j]
+                    V[imax,j] = z
+
+    return S
+
+#######################
+
+def svd_c_raw(ctx, A, V = False, calc_u = False):
+    """
+    This routine computes the singular value decomposition of a matrix A.
+    Given A, two unitary matrices U and V are calculated such that
+
+                    A = U S V
+
+    where S is a suitable shaped matrix whose off-diagonal elements are zero.
+    The diagonal elements of S are the singular values of A, i.e. the
+    squareroots of the eigenvalues of A' A or A A'. Here ' denotes the hermitian
+    transpose (i.e. transposition and conjugation). Householder bidiagonalization
+    and a variant of the QR algorithm is used.
+
+    overview of the matrices :
+
+      A : m*n       A gets replaced by U
+      U : m*n       U replaces A. If n>m then only the first m*m block of U is
+                    non-zero. column-unitary: U' U = B
+                    here B is a n*n matrix whose first min(m,n) diagonal
+                    elements are 1 and all other elements are zero.
+      S : n*n       diagonal matrix, only the diagonal elements are stored in
+                    the array S. only the first min(m,n) diagonal elements are non-zero.
+      V : n*n       unitary: V V' = V' V = 1
+
+    parameters:
+      A        (input/output) On input, A contains a complex matrix of shape m*n.
+               On output, if calc_u is true A contains the column-unitary
+               matrix U; otherwise A is simply used as workspace and thus destroyed.
+
+      V        (input/output) if false, the matrix V is not calculated. otherwise
+               V must be a matrix of shape n*n.
+
+      calc_u   (input) If true, the matrix U is calculated and replaces A.
+               if false, U is not calculated and A is simply destroyed
+
+    return value:
+      S        an array of length n containing the singular values of A sorted by
+               decreasing magnitude. only the first min(m,n) elements are non-zero.
+
+    This routine is a python translation of the fortran routine svd.f in the
+    software library EISPACK (see netlib.org) which itself is based on the
+    algol procedure svd described in:
+      - num. math. 14, 403-420(1970) by golub and reinsch.
+      - wilkinson/reinsch: handbook for auto. comp., vol ii-linear algebra, 134-151(1971).
+
+    """
+
+    m, n = A.rows, A.cols
+
+    S = ctx.zeros(n, 1)
+
+    # work is a temporary array of size n
+    work  = ctx.zeros(n, 1)
+    lbeta = ctx.zeros(n, 1)
+    rbeta = ctx.zeros(n, 1)
+    dwork = ctx.zeros(n, 1)
+
+    g = scale = anorm = 0
+    maxits = 3 * ctx.dps
+
+    for i in xrange(n):         # householder reduction to bidiagonal form
+        dwork[i] = scale * g    # dwork are the side-diagonal elements
+        g = s = scale = 0
+        if i < m:
+            for k in xrange(i, m):
+                scale += ctx.fabs(ctx.re(A[k,i])) + ctx.fabs(ctx.im(A[k,i]))
+            if scale != 0:
+                for k in xrange(i, m):
+                    A[k,i] /= scale
+                    ar = ctx.re(A[k,i])
+                    ai = ctx.im(A[k,i])
+                    s += ar * ar + ai * ai
+                f = A[i,i]
+                g = -ctx.sqrt(s)
+                if ctx.re(f) < 0:
+                    beta = -g - ctx.conj(f)
+                    g = -g
+                else:
+                    beta = -g + ctx.conj(f)
+                beta /= ctx.conj(beta)
+                beta += 1
+                h = 2 * (ctx.re(f) * g - s)
+                A[i,i] = f - g
+                beta /= h
+                lbeta[i] = (beta / scale) / scale
+                for j in xrange(i+1, n):
+                    s = 0
+                    for k in xrange(i, m):
+                        s += ctx.conj(A[k,i]) * A[k,j]
+                    f = beta * s
+                    for k in xrange(i, m):
+                        A[k,j] += f * A[k,i]
+                for k in xrange(i, m):
+                    A[k,i] *= scale
+
+        S[i] = scale * g     # S are the diagonal elements
+        g = s = scale = 0
+
+        if i < m and i != n - 1:
+            for k in xrange(i+1, n):
+                scale += ctx.fabs(ctx.re(A[i,k])) + ctx.fabs(ctx.im(A[i,k]))
+            if scale:
+                for k in xrange(i+1, n):
+                    A[i,k] /= scale
+                    ar = ctx.re(A[i,k])
+                    ai = ctx.im(A[i,k])
+                    s += ar * ar + ai * ai
+                f = A[i,i+1]
+                g = -ctx.sqrt(s)
+                if ctx.re(f) < 0:
+                    beta = -g - ctx.conj(f)
+                    g = -g
+                else:
+                    beta = -g + ctx.conj(f)
+
+                beta /= ctx.conj(beta)
+                beta += 1
+
+                h = 2 * (ctx.re(f) * g - s)
+                A[i,i+1] = f - g
+
+                beta /= h
+                rbeta[i] = (beta / scale) / scale
+
+                for k in xrange(i+1, n):
+                    work[k] = A[i, k]
+
+                for j in xrange(i+1, m):
+                    s = 0
+                    for k in xrange(i+1, n):
+                        s += ctx.conj(A[i,k]) * A[j,k]
+                    f = s * beta
+                    for k in xrange(i+1,n):
+                        A[j,k] += f * work[k]
+
+                for k in xrange(i+1, n):
+                    A[i,k] *= scale
+
+        anorm = max(anorm,ctx.fabs(S[i]) + ctx.fabs(dwork[i]))
+
+    if not isinstance(V, bool):
+        for i in xrange(n-2, -1, -1):     # accumulation of right hand transformations
+            V[i+1,i+1] = 1
+
+            if dwork[i+1] != 0:
+                f = ctx.conj(rbeta[i])
+                for j in xrange(i+1, n):
+                    V[i,j] = A[i,j] * f
+                for j in xrange(i+1, n):
+                    s = 0
+                    for k in xrange(i+1, n):
+                        s += ctx.conj(A[i,k]) * V[j,k]
+                    for k in xrange(i+1, n):
+                        V[j,k] += s * V[i,k]
+
+            for j in xrange(i+1,n):
+                V[j,i] = V[i,j] = 0
+
+        V[0,0] = 1
+
+    if m < n : minnm = m
+    else     : minnm = n
+
+    if calc_u:
+        for i in xrange(minnm-1, -1, -1): # accumulation of left hand transformations
+            g = S[i]
+            for j in xrange(i+1, n):
+                A[i,j] = 0
+            if g != 0:
+                g = 1 / g
+                for j in xrange(i+1, n):
+                    s = 0
+                    for k in xrange(i+1, m):
+                        s += ctx.conj(A[k,i]) * A[k,j]
+                    f = s * ctx.conj(lbeta[i])
+                    for k in xrange(i, m):
+                        A[k,j] += f * A[k,i]
+                for j in xrange(i, m):
+                    A[j,i] *= g
+            else:
+                for j in xrange(i, m):
+                    A[j,i] = 0
+            A[i,i] += 1
+
+    for k in xrange(n-1, -1, -1):
+        # diagonalization of the bidiagonal form:
+        #   loop over singular values, and over allowed itations
+
+        its = 0
+        while 1:
+            its += 1
+            flag = True
+
+            for l in xrange(k, -1, -1):
+                nm = l - 1
+
+                if ctx.fabs(dwork[l]) + anorm == anorm:
+                    flag = False
+                    break
+
+                if ctx.fabs(S[nm]) + anorm == anorm:
+                    break
+
+            if flag:
+                c = 0
+                s = 1
+                for i in xrange(l, k+1):
+                    f = s * dwork[i]
+                    dwork[i] *= c
+                    if ctx.fabs(f) + anorm == anorm:
+                        break
+                    g = S[i]
+                    h = ctx.hypot(f, g)
+                    S[i] = h
+                    h = 1 / h
+                    c = g * h
+                    s = -f * h
+
+                    if calc_u:
+                        for j in xrange(m):
+                            y = A[j,nm]
+                            z = A[j,i]
+                            A[j,nm]= y * c + z * s
+                            A[j,i] = z * c - y * s
+
+            z = S[k]
+
+            if l == k:         # convergence
+                if z < 0:    # singular value is made nonnegative
+                    S[k] = -z
+                    if not isinstance(V, bool):
+                        for j in xrange(n):
+                            V[k,j] = -V[k,j]
+                break
+
+            if its >= maxits:
+                raise RuntimeError("svd: no convergence to an eigenvalue after %d iterations" % its)
+
+            x = S[l]         # shift from bottom 2 by 2 minor
+            nm = k-1
+            y = S[nm]
+            g = dwork[nm]
+            h = dwork[k]
+            f = ((y - z) * (y + z) + (g - h) * (g + h)) / (2 * h * y)
+            g = ctx.hypot(f, 1)
+            if f >=0: f = (( x - z) *( x + z) + h *((y / (f + g)) - h)) / x
+            else:     f = (( x - z) *( x + z) + h *((y / (f - g)) - h)) / x
+
+            c = s = 1         # next qt transformation
+
+            for j in xrange(l, nm + 1):
+                g = dwork[j+1]
+                y = S[j+1]
+                h = s * g
+                g = c * g
+                z = ctx.hypot(f, h)
+                dwork[j] = z
+                c = f / z
+                s = h / z
+                f = x * c + g * s
+                g = g * c - x * s
+                h = y * s
+                y *= c
+                if not isinstance(V, bool):
+                    for jj in xrange(n):
+                        x = V[j  ,jj]
+                        z = V[j+1,jj]
+                        V[j    ,jj]= x * c + z * s
+                        V[j+1,jj  ]= z * c - x * s
+                z = ctx.hypot(f, h)
+                S[j] = z
+                if z != 0:            # rotation can be arbitray if z=0
+                    z = 1 / z
+                    c = f * z
+                    s = h * z
+                f = c * g + s * y
+                x = c * y - s * g
+                if calc_u:
+                    for jj in xrange(m):
+                        y = A[jj,j  ]
+                        z = A[jj,j+1]
+                        A[jj,j    ]= y * c + z * s
+                        A[jj,j+1  ]= z * c - y * s
+
+            dwork[l] = 0
+            dwork[k] = f
+            S[k] = x
+
+    ##########################
+
+    # Sort singular values into decreasing order (bubble-sort)
+
+    for i in xrange(n):
+        imax = i
+        s = ctx.fabs(S[i])         # s is the current maximal element
+
+        for j in xrange(i + 1, n):
+            c = ctx.fabs(S[j])
+            if c > s:
+                s = c
+                imax = j
+
+        if imax != i:
+            # swap singular values
+
+            z = S[i]
+            S[i] = S[imax]
+            S[imax] = z
+
+            if calc_u:
+                for j in xrange(m):
+                    z = A[j,i]
+                    A[j,i] = A[j,imax]
+                    A[j,imax] = z
+
+            if not isinstance(V, bool):
+                for j in xrange(n):
+                    z = V[i,j]
+                    V[i,j] = V[imax,j]
+                    V[imax,j] = z
+
+    return S
+
+##################################################################################################
+
+@defun
+def svd_r(ctx, A, full_matrices = False, compute_uv = True, overwrite_a = False):
+    """
+    This routine computes the singular value decomposition of a matrix A.
+    Given A, two orthogonal matrices U and V are calculated such that
+
+           A = U S V        and        U' U = 1         and         V V' = 1
+
+    where S is a suitable shaped matrix whose off-diagonal elements are zero.
+    Here ' denotes the transpose. The diagonal elements of S are the singular
+    values of A, i.e. the squareroots of the eigenvalues of A' A or A A'.
+
+    input:
+      A             : a real matrix of shape (m, n)
+      full_matrices : if true, U and V are of shape (m, m) and (n, n).
+                      if false, U and V are of shape (m, min(m, n)) and (min(m, n), n).
+      compute_uv    : if true, U and V are calculated. if false, only S is calculated.
+      overwrite_a   : if true, allows modification of A which may improve
+                      performance. if false, A is not modified.
+
+    output:
+      U : an orthogonal matrix: U' U = 1. if full_matrices is true, U is of
+          shape (m, m). ortherwise it is of shape (m, min(m, n)).
+
+      S : an array of length min(m, n) containing the singular values of A sorted by
+          decreasing magnitude.
+
+      V : an orthogonal matrix: V V' = 1. if full_matrices is true, V is of
+          shape (n, n). ortherwise it is of shape (min(m, n), n).
+
+    return value:
+
+           S          if compute_uv is false
+       (U, S, V)      if compute_uv is true
+
+    overview of the matrices:
+
+      full_matrices true:
+        A           : m*n
+        U           : m*m     U' U  = 1
+        S as matrix : m*n
+        V           : n*n     V  V' = 1
+
+     full_matrices false:
+        A           : m*n
+        U           : m*min(n,m)             U' U  = 1
+        S as matrix : min(m,n)*min(m,n)
+        V           : min(m,n)*n             V  V' = 1
+
+    examples:
+
+       >>> from mpmath import mp
+       >>> A = mp.matrix([[2, -2, -1], [3, 4, -2], [-2, -2, 0]])
+       >>> S = mp.svd_r(A, compute_uv = False)
+       >>> print(S)
+       [6.0]
+       [3.0]
+       [1.0]
+
+       >>> U, S, V = mp.svd_r(A)
+       >>> print(mp.chop(A - U * mp.diag(S) * V))
+       [0.0  0.0  0.0]
+       [0.0  0.0  0.0]
+       [0.0  0.0  0.0]
+
+
+    see also: svd, svd_c
+    """
+
+    m, n = A.rows, A.cols
+
+    if not compute_uv:
+        if not overwrite_a:
+            A = A.copy()
+        S = svd_r_raw(ctx, A, V = False, calc_u = False)
+        S = S[:min(m,n)]
+        return S
+
+    if full_matrices and n < m:
+        V = ctx.zeros(m, m)
+        A0 = ctx.zeros(m, m)
+        A0[:,:n] = A
+        S = svd_r_raw(ctx, A0, V, calc_u = True)
+
+        S = S[:n]
+        V = V[:n,:n]
+
+        return (A0, S, V)
+    else:
+        if not overwrite_a:
+            A = A.copy()
+        V = ctx.zeros(n, n)
+        S = svd_r_raw(ctx, A, V, calc_u = True)
+
+        if n > m:
+            if full_matrices == False:
+                V = V[:m,:]
+
+            S = S[:m]
+            A = A[:,:m]
+
+        return (A, S, V)
+
+##############################
+
+@defun
+def svd_c(ctx, A, full_matrices = False, compute_uv = True, overwrite_a = False):
+    """
+    This routine computes the singular value decomposition of a matrix A.
+    Given A, two unitary matrices U and V are calculated such that
+
+           A = U S V        and        U' U = 1         and         V V' = 1
+
+    where S is a suitable shaped matrix whose off-diagonal elements are zero.
+    Here ' denotes the hermitian transpose (i.e. transposition and complex
+    conjugation). The diagonal elements of S are the singular values of A,
+    i.e. the squareroots of the eigenvalues of A' A or A A'.
+
+    input:
+      A             : a complex matrix of shape (m, n)
+      full_matrices : if true, U and V are of shape (m, m) and (n, n).
+                      if false, U and V are of shape (m, min(m, n)) and (min(m, n), n).
+      compute_uv    : if true, U and V are calculated. if false, only S is calculated.
+      overwrite_a   : if true, allows modification of A which may improve
+                      performance. if false, A is not modified.
+
+    output:
+      U : an unitary matrix: U' U = 1. if full_matrices is true, U is of
+          shape (m, m). ortherwise it is of shape (m, min(m, n)).
+
+      S : an array of length min(m, n) containing the singular values of A sorted by
+          decreasing magnitude.
+
+      V : an unitary matrix: V V' = 1. if full_matrices is true, V is of
+          shape (n, n). ortherwise it is of shape (min(m, n), n).
+
+    return value:
+
+           S          if compute_uv is false
+       (U, S, V)      if compute_uv is true
+
+    overview of the matrices:
+
+      full_matrices true:
+        A           : m*n
+        U           : m*m     U' U  = 1
+        S as matrix : m*n
+        V           : n*n     V  V' = 1
+
+     full_matrices false:
+        A           : m*n
+        U           : m*min(n,m)             U' U  = 1
+        S as matrix : min(m,n)*min(m,n)
+        V           : min(m,n)*n             V  V' = 1
+
+    example:
+      >>> from mpmath import mp
+      >>> A = mp.matrix([[-2j, -1-3j, -2+2j], [2-2j, -1-3j, 1], [-3+1j,-2j,0]])
+      >>> S = mp.svd_c(A, compute_uv = False)
+      >>> print(mp.chop(S - mp.matrix([mp.sqrt(34), mp.sqrt(15), mp.sqrt(6)])))
+      [0.0]
+      [0.0]
+      [0.0]
+
+      >>> U, S, V = mp.svd_c(A)
+      >>> print(mp.chop(A - U * mp.diag(S) * V))
+      [0.0  0.0  0.0]
+      [0.0  0.0  0.0]
+      [0.0  0.0  0.0]
+
+    see also: svd, svd_r
+    """
+
+    m, n = A.rows, A.cols
+
+    if not compute_uv:
+        if not overwrite_a:
+            A = A.copy()
+        S = svd_c_raw(ctx, A, V = False, calc_u = False)
+        S = S[:min(m,n)]
+        return S
+
+    if full_matrices and n < m:
+        V = ctx.zeros(m, m)
+        A0 = ctx.zeros(m, m)
+        A0[:,:n] = A
+        S = svd_c_raw(ctx, A0, V, calc_u = True)
+
+        S = S[:n]
+        V = V[:n,:n]
+
+        return (A0, S, V)
+    else:
+        if not overwrite_a:
+            A = A.copy()
+        V = ctx.zeros(n, n)
+        S = svd_c_raw(ctx, A, V, calc_u = True)
+
+        if n > m:
+            if full_matrices == False:
+                V = V[:m,:]
+
+            S = S[:m]
+            A = A[:,:m]
+
+        return (A, S, V)
+
+@defun
+def svd(ctx, A, full_matrices = False, compute_uv = True, overwrite_a = False):
+    """
+    "svd" is a unified interface for "svd_r" and "svd_c". Depending on
+    whether A is real or complex the appropriate function is called.
+
+    This routine computes the singular value decomposition of a matrix A.
+    Given A, two orthogonal (A real) or unitary (A complex) matrices U and V
+    are calculated such that
+
+           A = U S V        and        U' U = 1         and         V V' = 1
+
+    where S is a suitable shaped matrix whose off-diagonal elements are zero.
+    Here ' denotes the hermitian transpose (i.e. transposition and complex
+    conjugation). The diagonal elements of S are the singular values of A,
+    i.e. the squareroots of the eigenvalues of A' A or A A'.
+
+    input:
+      A             : a real or complex matrix of shape (m, n)
+      full_matrices : if true, U and V are of shape (m, m) and (n, n).
+                      if false, U and V are of shape (m, min(m, n)) and (min(m, n), n).
+      compute_uv    : if true, U and V are calculated. if false, only S is calculated.
+      overwrite_a   : if true, allows modification of A which may improve
+                      performance. if false, A is not modified.
+
+    output:
+      U : an orthogonal or unitary matrix: U' U = 1. if full_matrices is true, U is of
+          shape (m, m). ortherwise it is of shape (m, min(m, n)).
+
+      S : an array of length min(m, n) containing the singular values of A sorted by
+          decreasing magnitude.
+
+      V : an orthogonal or unitary matrix: V V' = 1. if full_matrices is true, V is of
+          shape (n, n). ortherwise it is of shape (min(m, n), n).
+
+    return value:
+
+           S          if compute_uv is false
+       (U, S, V)      if compute_uv is true
+
+    overview of the matrices:
+
+      full_matrices true:
+        A           : m*n
+        U           : m*m     U' U  = 1
+        S as matrix : m*n
+        V           : n*n     V  V' = 1
+
+     full_matrices false:
+        A           : m*n
+        U           : m*min(n,m)             U' U  = 1
+        S as matrix : min(m,n)*min(m,n)
+        V           : min(m,n)*n             V  V' = 1
+
+    examples:
+
+       >>> from mpmath import mp
+       >>> A = mp.matrix([[2, -2, -1], [3, 4, -2], [-2, -2, 0]])
+       >>> S = mp.svd(A, compute_uv = False)
+       >>> print(S)
+       [6.0]
+       [3.0]
+       [1.0]
+
+       >>> U, S, V = mp.svd(A)
+       >>> print(mp.chop(A - U * mp.diag(S) * V))
+       [0.0  0.0  0.0]
+       [0.0  0.0  0.0]
+       [0.0  0.0  0.0]
+
+    see also: svd_r, svd_c
+    """
+
+    iscomplex = any(type(x) is ctx.mpc for x in A)
+
+    if iscomplex:
+        return ctx.svd_c(A, full_matrices = full_matrices, compute_uv = compute_uv, overwrite_a = overwrite_a)
+    else:
+        return ctx.svd_r(A, full_matrices = full_matrices, compute_uv = compute_uv, overwrite_a = overwrite_a)

env-llmeval/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

env-llmeval/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)

env-llmeval/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()

env-llmeval/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)

env-llmeval/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_

env-llmeval/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

env-llmeval/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)

env-llmeval/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)

env-llmeval/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

env-llmeval/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)

env-llmeval/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')

env-llmeval/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)