Add files using upload-large-folder tool

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

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

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

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

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

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

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

@@ -0,0 +1,531 @@
+from ..libmp.backend import xrange
+
+# TODO: should use diagonalization-based algorithms
+
+class MatrixCalculusMethods(object):
+
+    def _exp_pade(ctx, a):
+        """
+        Exponential of a matrix using Pade approximants.
+
+        See G. H. Golub, C. F. van Loan 'Matrix Computations',
+        third Ed., page 572
+
+        TODO:
+         - find a good estimate for q
+         - reduce the number of matrix multiplications to improve
+           performance
+        """
+        def eps_pade(p):
+            return ctx.mpf(2)**(3-2*p) * \
+                ctx.factorial(p)**2/(ctx.factorial(2*p)**2 * (2*p + 1))
+        q = 4
+        extraq = 8
+        while 1:
+            if eps_pade(q) < ctx.eps:
+                break
+            q += 1
+        q += extraq
+        j = int(max(1, ctx.mag(ctx.mnorm(a,'inf'))))
+        extra = q
+        prec = ctx.prec
+        ctx.dps += extra + 3
+        try:
+            a = a/2**j
+            na = a.rows
+            den = ctx.eye(na)
+            num = ctx.eye(na)
+            x = ctx.eye(na)
+            c = ctx.mpf(1)
+            for k in range(1, q+1):
+                c *= ctx.mpf(q - k + 1)/((2*q - k + 1) * k)
+                x = a*x
+                cx = c*x
+                num += cx
+                den += (-1)**k * cx
+            f = ctx.lu_solve_mat(den, num)
+            for k in range(j):
+                f = f*f
+        finally:
+            ctx.prec = prec
+        return f*1
+
+    def expm(ctx, A, method='taylor'):
+        r"""
+        Computes the matrix exponential of a square matrix `A`, which is defined
+        by the power series
+
+        .. math ::
+
+            \exp(A) = I + A + \frac{A^2}{2!} + \frac{A^3}{3!} + \ldots
+
+        With method='taylor', the matrix exponential is computed
+        using the Taylor series. With method='pade', Pade approximants
+        are used instead.
+
+        **Examples**
+
+        Basic examples::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> expm(zeros(3))
+            [1.0  0.0  0.0]
+            [0.0  1.0  0.0]
+            [0.0  0.0  1.0]
+            >>> expm(eye(3))
+            [2.71828182845905               0.0               0.0]
+            [             0.0  2.71828182845905               0.0]
+            [             0.0               0.0  2.71828182845905]
+            >>> expm([[1,1,0],[1,0,1],[0,1,0]])
+            [ 3.86814500615414  2.26812870852145  0.841130841230196]
+            [ 2.26812870852145  2.44114713886289   1.42699786729125]
+            [0.841130841230196  1.42699786729125    1.6000162976327]
+            >>> expm([[1,1,0],[1,0,1],[0,1,0]], method='pade')
+            [ 3.86814500615414  2.26812870852145  0.841130841230196]
+            [ 2.26812870852145  2.44114713886289   1.42699786729125]
+            [0.841130841230196  1.42699786729125    1.6000162976327]
+            >>> expm([[1+j, 0], [1+j,1]])
+            [(1.46869393991589 + 2.28735528717884j)                        0.0]
+            [  (1.03776739863568 + 3.536943175722j)  (2.71828182845905 + 0.0j)]
+
+        Matrices with large entries are allowed::
+
+            >>> expm(matrix([[1,2],[2,3]])**25)
+            [5.65024064048415e+2050488462815550  9.14228140091932e+2050488462815550]
+            [9.14228140091932e+2050488462815550  1.47925220414035e+2050488462815551]
+
+        The identity `\exp(A+B) = \exp(A) \exp(B)` does not hold for
+        noncommuting matrices::
+
+            >>> A = hilbert(3)
+            >>> B = A + eye(3)
+            >>> chop(mnorm(A*B - B*A))
+            0.0
+            >>> chop(mnorm(expm(A+B) - expm(A)*expm(B)))
+            0.0
+            >>> B = A + ones(3)
+            >>> mnorm(A*B - B*A)
+            1.8
+            >>> mnorm(expm(A+B) - expm(A)*expm(B))
+            42.0927851137247
+
+        """
+        if method == 'pade':
+            prec = ctx.prec
+            try:
+                A = ctx.matrix(A)
+                ctx.prec += 2*A.rows
+                res = ctx._exp_pade(A)
+            finally:
+                ctx.prec = prec
+            return res
+        A = ctx.matrix(A)
+        prec = ctx.prec
+        j = int(max(1, ctx.mag(ctx.mnorm(A,'inf'))))
+        j += int(0.5*prec**0.5)
+        try:
+            ctx.prec += 10 + 2*j
+            tol = +ctx.eps
+            A = A/2**j
+            T = A
+            Y = A**0 + A
+            k = 2
+            while 1:
+                T *= A * (1/ctx.mpf(k))
+                if ctx.mnorm(T, 'inf') < tol:
+                    break
+                Y += T
+                k += 1
+            for k in xrange(j):
+                Y = Y*Y
+        finally:
+            ctx.prec = prec
+        Y *= 1
+        return Y
+
+    def cosm(ctx, A):
+        r"""
+        Gives the cosine of a square matrix `A`, defined in analogy
+        with the matrix exponential.
+
+        Examples::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> X = eye(3)
+            >>> cosm(X)
+            [0.54030230586814               0.0               0.0]
+            [             0.0  0.54030230586814               0.0]
+            [             0.0               0.0  0.54030230586814]
+            >>> X = hilbert(3)
+            >>> cosm(X)
+            [ 0.424403834569555  -0.316643413047167  -0.221474945949293]
+            [-0.316643413047167   0.820646708837824  -0.127183694770039]
+            [-0.221474945949293  -0.127183694770039   0.909236687217541]
+            >>> X = matrix([[1+j,-2],[0,-j]])
+            >>> cosm(X)
+            [(0.833730025131149 - 0.988897705762865j)  (1.07485840848393 - 0.17192140544213j)]
+            [                                     0.0               (1.54308063481524 + 0.0j)]
+        """
+        B = 0.5 * (ctx.expm(A*ctx.j) + ctx.expm(A*(-ctx.j)))
+        if not sum(A.apply(ctx.im).apply(abs)):
+            B = B.apply(ctx.re)
+        return B
+
+    def sinm(ctx, A):
+        r"""
+        Gives the sine of a square matrix `A`, defined in analogy
+        with the matrix exponential.
+
+        Examples::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> X = eye(3)
+            >>> sinm(X)
+            [0.841470984807897                0.0                0.0]
+            [              0.0  0.841470984807897                0.0]
+            [              0.0                0.0  0.841470984807897]
+            >>> X = hilbert(3)
+            >>> sinm(X)
+            [0.711608512150994  0.339783913247439  0.220742837314741]
+            [0.339783913247439  0.244113865695532  0.187231271174372]
+            [0.220742837314741  0.187231271174372  0.155816730769635]
+            >>> X = matrix([[1+j,-2],[0,-j]])
+            >>> sinm(X)
+            [(1.29845758141598 + 0.634963914784736j)  (-1.96751511930922 + 0.314700021761367j)]
+            [                                    0.0                  (0.0 - 1.1752011936438j)]
+        """
+        B = (-0.5j) * (ctx.expm(A*ctx.j) - ctx.expm(A*(-ctx.j)))
+        if not sum(A.apply(ctx.im).apply(abs)):
+            B = B.apply(ctx.re)
+        return B
+
+    def _sqrtm_rot(ctx, A, _may_rotate):
+        # If the iteration fails to converge, cheat by performing
+        # a rotation by a complex number
+        u = ctx.j**0.3
+        return ctx.sqrtm(u*A, _may_rotate) / ctx.sqrt(u)
+
+    def sqrtm(ctx, A, _may_rotate=2):
+        r"""
+        Computes a square root of the square matrix `A`, i.e. returns
+        a matrix `B = A^{1/2}` such that `B^2 = A`. The square root
+        of a matrix, if it exists, is not unique.
+
+        **Examples**
+
+        Square roots of some simple matrices::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> sqrtm([[1,0], [0,1]])
+            [1.0  0.0]
+            [0.0  1.0]
+            >>> sqrtm([[0,0], [0,0]])
+            [0.0  0.0]
+            [0.0  0.0]
+            >>> sqrtm([[2,0],[0,1]])
+            [1.4142135623731  0.0]
+            [            0.0  1.0]
+            >>> sqrtm([[1,1],[1,0]])
+            [ (0.920442065259926 - 0.21728689675164j)  (0.568864481005783 + 0.351577584254143j)]
+            [(0.568864481005783 + 0.351577584254143j)  (0.351577584254143 - 0.568864481005783j)]
+            >>> sqrtm([[1,0],[0,1]])
+            [1.0  0.0]
+            [0.0  1.0]
+            >>> sqrtm([[-1,0],[0,1]])
+            [(0.0 - 1.0j)           0.0]
+            [         0.0  (1.0 + 0.0j)]
+            >>> sqrtm([[j,0],[0,j]])
+            [(0.707106781186547 + 0.707106781186547j)                                       0.0]
+            [                                     0.0  (0.707106781186547 + 0.707106781186547j)]
+
+        A square root of a rotation matrix, giving the corresponding
+        half-angle rotation matrix::
+
+            >>> t1 = 0.75
+            >>> t2 = t1 * 0.5
+            >>> A1 = matrix([[cos(t1), -sin(t1)], [sin(t1), cos(t1)]])
+            >>> A2 = matrix([[cos(t2), -sin(t2)], [sin(t2), cos(t2)]])
+            >>> sqrtm(A1)
+            [0.930507621912314  -0.366272529086048]
+            [0.366272529086048   0.930507621912314]
+            >>> A2
+            [0.930507621912314  -0.366272529086048]
+            [0.366272529086048   0.930507621912314]
+
+        The identity `(A^2)^{1/2} = A` does not necessarily hold::
+
+            >>> A = matrix([[4,1,4],[7,8,9],[10,2,11]])
+            >>> sqrtm(A**2)
+            [ 4.0  1.0   4.0]
+            [ 7.0  8.0   9.0]
+            [10.0  2.0  11.0]
+            >>> sqrtm(A)**2
+            [ 4.0  1.0   4.0]
+            [ 7.0  8.0   9.0]
+            [10.0  2.0  11.0]
+            >>> A = matrix([[-4,1,4],[7,-8,9],[10,2,11]])
+            >>> sqrtm(A**2)
+            [  7.43715112194995  -0.324127569985474   1.8481718827526]
+            [-0.251549715716942    9.32699765900402  2.48221180985147]
+            [  4.11609388833616   0.775751877098258   13.017955697342]
+            >>> chop(sqrtm(A)**2)
+            [-4.0   1.0   4.0]
+            [ 7.0  -8.0   9.0]
+            [10.0   2.0  11.0]
+
+        For some matrices, a square root does not exist::
+
+            >>> sqrtm([[0,1], [0,0]])
+            Traceback (most recent call last):
+              ...
+            ZeroDivisionError: matrix is numerically singular
+
+        Two examples from the documentation for Matlab's ``sqrtm``::
+
+            >>> mp.dps = 15; mp.pretty = True
+            >>> sqrtm([[7,10],[15,22]])
+            [1.56669890360128  1.74077655955698]
+            [2.61116483933547  4.17786374293675]
+            >>>
+            >>> X = matrix(\
+            ...   [[5,-4,1,0,0],
+            ...   [-4,6,-4,1,0],
+            ...   [1,-4,6,-4,1],
+            ...   [0,1,-4,6,-4],
+            ...   [0,0,1,-4,5]])
+            >>> Y = matrix(\
+            ...   [[2,-1,-0,-0,-0],
+            ...   [-1,2,-1,0,-0],
+            ...   [0,-1,2,-1,0],
+            ...   [-0,0,-1,2,-1],
+            ...   [-0,-0,-0,-1,2]])
+            >>> mnorm(sqrtm(X) - Y)
+            4.53155328326114e-19
+
+        """
+        A = ctx.matrix(A)
+        # Trivial
+        if A*0 == A:
+            return A
+        prec = ctx.prec
+        if _may_rotate:
+            d = ctx.det(A)
+            if abs(ctx.im(d)) < 16*ctx.eps and ctx.re(d) < 0:
+                return ctx._sqrtm_rot(A, _may_rotate-1)
+        try:
+            ctx.prec += 10
+            tol = ctx.eps * 128
+            Y = A
+            Z = I = A**0
+            k = 0
+            # Denman-Beavers iteration
+            while 1:
+                Yprev = Y
+                try:
+                    Y, Z = 0.5*(Y+ctx.inverse(Z)), 0.5*(Z+ctx.inverse(Y))
+                except ZeroDivisionError:
+                    if _may_rotate:
+                        Y = ctx._sqrtm_rot(A, _may_rotate-1)
+                        break
+                    else:
+                        raise
+                mag1 = ctx.mnorm(Y-Yprev, 'inf')
+                mag2 = ctx.mnorm(Y, 'inf')
+                if mag1 <= mag2*tol:
+                    break
+                if _may_rotate and k > 6 and not mag1 < mag2 * 0.001:
+                    return ctx._sqrtm_rot(A, _may_rotate-1)
+                k += 1
+                if k > ctx.prec:
+                    raise ctx.NoConvergence
+        finally:
+            ctx.prec = prec
+        Y *= 1
+        return Y
+
+    def logm(ctx, A):
+        r"""
+        Computes a logarithm of the square matrix `A`, i.e. returns
+        a matrix `B = \log(A)` such that `\exp(B) = A`. The logarithm
+        of a matrix, if it exists, is not unique.
+
+        **Examples**
+
+        Logarithms of some simple matrices::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> X = eye(3)
+            >>> logm(X)
+            [0.0  0.0  0.0]
+            [0.0  0.0  0.0]
+            [0.0  0.0  0.0]
+            >>> logm(2*X)
+            [0.693147180559945                0.0                0.0]
+            [              0.0  0.693147180559945                0.0]
+            [              0.0                0.0  0.693147180559945]
+            >>> logm(expm(X))
+            [1.0  0.0  0.0]
+            [0.0  1.0  0.0]
+            [0.0  0.0  1.0]
+
+        A logarithm of a complex matrix::
+
+            >>> X = matrix([[2+j, 1, 3], [1-j, 1-2*j, 1], [-4, -5, j]])
+            >>> B = logm(X)
+            >>> nprint(B)
+            [ (0.808757 + 0.107759j)    (2.20752 + 0.202762j)   (1.07376 - 0.773874j)]
+            [ (0.905709 - 0.107795j)  (0.0287395 - 0.824993j)  (0.111619 + 0.514272j)]
+            [(-0.930151 + 0.399512j)   (-2.06266 - 0.674397j)  (0.791552 + 0.519839j)]
+            >>> chop(expm(B))
+            [(2.0 + 1.0j)           1.0           3.0]
+            [(1.0 - 1.0j)  (1.0 - 2.0j)           1.0]
+            [        -4.0          -5.0  (0.0 + 1.0j)]
+
+        A matrix `X` close to the identity matrix, for which
+        `\log(\exp(X)) = \exp(\log(X)) = X` holds::
+
+            >>> X = eye(3) + hilbert(3)/4
+            >>> X
+            [              1.25             0.125  0.0833333333333333]
+            [             0.125  1.08333333333333              0.0625]
+            [0.0833333333333333            0.0625                1.05]
+            >>> logm(expm(X))
+            [              1.25             0.125  0.0833333333333333]
+            [             0.125  1.08333333333333              0.0625]
+            [0.0833333333333333            0.0625                1.05]
+            >>> expm(logm(X))
+            [              1.25             0.125  0.0833333333333333]
+            [             0.125  1.08333333333333              0.0625]
+            [0.0833333333333333            0.0625                1.05]
+
+        A logarithm of a rotation matrix, giving back the angle of
+        the rotation::
+
+            >>> t = 3.7
+            >>> A = matrix([[cos(t),sin(t)],[-sin(t),cos(t)]])
+            >>> chop(logm(A))
+            [             0.0  -2.58318530717959]
+            [2.58318530717959                0.0]
+            >>> (2*pi-t)
+            2.58318530717959
+
+        For some matrices, a logarithm does not exist::
+
+            >>> logm([[1,0], [0,0]])
+            Traceback (most recent call last):
+              ...
+            ZeroDivisionError: matrix is numerically singular
+
+        Logarithm of a matrix with large entries::
+
+            >>> logm(hilbert(3) * 10**20).apply(re)
+            [ 45.5597513593433  1.27721006042799  0.317662687717978]
+            [ 1.27721006042799  42.5222778973542   2.24003708791604]
+            [0.317662687717978  2.24003708791604    42.395212822267]
+
+        """
+        A = ctx.matrix(A)
+        prec = ctx.prec
+        try:
+            ctx.prec += 10
+            tol = ctx.eps * 128
+            I = A**0
+            B = A
+            n = 0
+            while 1:
+                B = ctx.sqrtm(B)
+                n += 1
+                if ctx.mnorm(B-I, 'inf') < 0.125:
+                    break
+            T = X = B-I
+            L = X*0
+            k = 1
+            while 1:
+                if k & 1:
+                    L += T / k
+                else:
+                    L -= T / k
+                T *= X
+                if ctx.mnorm(T, 'inf') < tol:
+                    break
+                k += 1
+                if k > ctx.prec:
+                    raise ctx.NoConvergence
+        finally:
+            ctx.prec = prec
+        L *= 2**n
+        return L
+
+    def powm(ctx, A, r):
+        r"""
+        Computes `A^r = \exp(A \log r)` for a matrix `A` and complex
+        number `r`.
+
+        **Examples**
+
+        Powers and inverse powers of a matrix::
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = True
+            >>> A = matrix([[4,1,4],[7,8,9],[10,2,11]])
+            >>> powm(A, 2)
+            [ 63.0  20.0   69.0]
+            [174.0  89.0  199.0]
+            [164.0  48.0  179.0]
+            >>> chop(powm(powm(A, 4), 1/4.))
+            [ 4.0  1.0   4.0]
+            [ 7.0  8.0   9.0]
+            [10.0  2.0  11.0]
+            >>> powm(extraprec(20)(powm)(A, -4), -1/4.)
+            [ 4.0  1.0   4.0]
+            [ 7.0  8.0   9.0]
+            [10.0  2.0  11.0]
+            >>> chop(powm(powm(A, 1+0.5j), 1/(1+0.5j)))
+            [ 4.0  1.0   4.0]
+            [ 7.0  8.0   9.0]
+            [10.0  2.0  11.0]
+            >>> powm(extraprec(5)(powm)(A, -1.5), -1/(1.5))
+            [ 4.0  1.0   4.0]
+            [ 7.0  8.0   9.0]
+            [10.0  2.0  11.0]
+
+        A Fibonacci-generating matrix::
+
+            >>> powm([[1,1],[1,0]], 10)
+            [89.0  55.0]
+            [55.0  34.0]
+            >>> fib(10)
+            55.0
+            >>> powm([[1,1],[1,0]], 6.5)
+            [(16.5166626964253 - 0.0121089837381789j)  (10.2078589271083 + 0.0195927472575932j)]
+            [(10.2078589271083 + 0.0195927472575932j)  (6.30880376931698 - 0.0317017309957721j)]
+            >>> (phi**6.5 - (1-phi)**6.5)/sqrt(5)
+            (10.2078589271083 - 0.0195927472575932j)
+            >>> powm([[1,1],[1,0]], 6.2)
+            [ (14.3076953002666 - 0.008222855781077j)  (8.81733464837593 + 0.0133048601383712j)]
+            [(8.81733464837593 + 0.0133048601383712j)  (5.49036065189071 - 0.0215277159194482j)]
+            >>> (phi**6.2 - (1-phi)**6.2)/sqrt(5)
+            (8.81733464837593 - 0.0133048601383712j)
+
+        """
+        A = ctx.matrix(A)
+        r = ctx.convert(r)
+        prec = ctx.prec
+        try:
+            ctx.prec += 10
+            if ctx.isint(r):
+                v = A ** int(r)
+            elif ctx.isint(r*2):
+                y = int(r*2)
+                v = ctx.sqrtm(A) ** y
+            else:
+                v = ctx.expm(r*ctx.logm(A))
+        finally:
+            ctx.prec = prec
+        v *= 1
+        return v

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

@@ -0,0 +1,877 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+##################################################################################################
+#     module for the eigenvalue problem
+#       Copyright 2013 Timo Hartmann (thartmann15 at gmail.com)
+#
+# todo:
+#  - implement balancing
+#  - agressive early deflation
+#
+##################################################################################################
+
+"""
+The eigenvalue problem
+----------------------
+
+This file contains routines for the eigenvalue problem.
+
+high level routines:
+
+  hessenberg : reduction of a real or complex square matrix to upper Hessenberg form
+  schur : reduction of a real or complex square matrix to upper Schur form
+  eig : eigenvalues and eigenvectors of a real or complex square matrix
+
+low level routines:
+
+  hessenberg_reduce_0 : reduction of a real or complex square matrix to upper Hessenberg form
+  hessenberg_reduce_1 : auxiliary routine to hessenberg_reduce_0
+  qr_step : a single implicitly shifted QR step for an upper Hessenberg matrix
+  hessenberg_qr : Schur decomposition of an upper Hessenberg matrix
+  eig_tr_r : right eigenvectors of an upper triangular matrix
+  eig_tr_l : left  eigenvectors of an upper triangular matrix
+"""
+
+from ..libmp.backend import xrange
+
+class Eigen(object):
+    pass
+
+def defun(f):
+    setattr(Eigen, f.__name__, f)
+    return f
+
+def hessenberg_reduce_0(ctx, A, T):
+    """
+    This routine computes the (upper) Hessenberg decomposition of a square matrix A.
+    Given A, an unitary matrix Q is calculated such that
+
+               Q' A Q = H              and             Q' Q = Q Q' = 1
+
+    where H is an upper Hessenberg matrix, meaning that it only contains zeros
+    below the first subdiagonal. Here ' denotes the hermitian transpose (i.e.
+    transposition and conjugation).
+
+    parameters:
+      A         (input/output) On input, A contains the square matrix A of
+                dimension (n,n). On output, A contains a compressed representation
+                of Q and H.
+      T         (output) An array of length n containing the first elements of
+                the Householder reflectors.
+    """
+
+    # internally we work with householder reflections from the right.
+    # let u be a row vector (i.e. u[i]=A[i,:i]). then
+    # Q is build up by reflectors of the type (1-v'v) where v is a suitable
+    # modification of u. these reflectors are applyed to A from the right.
+    # because we work with reflectors from the right we have to start with
+    # the bottom row of A and work then upwards (this corresponds to
+    # some kind of RQ decomposition).
+    # the first part of the vectors v (i.e. A[i,:(i-1)]) are stored as row vectors
+    # in the lower left part of A (excluding the diagonal and subdiagonal).
+    # the last entry of v is stored in T.
+    # the upper right part of A (including diagonal and subdiagonal) becomes H.
+
+
+    n = A.rows
+    if n <= 2: return
+
+    for i in xrange(n-1, 1, -1):
+
+        # scale the vector
+
+        scale = 0
+        for k in xrange(0, i):
+            scale += abs(ctx.re(A[i,k])) + abs(ctx.im(A[i,k]))
+
+        scale_inv = 0
+        if scale != 0:
+            scale_inv = 1 / scale
+
+        if scale == 0 or ctx.isinf(scale_inv):
+            # sadly there are floating point numbers not equal to zero whose reciprocal is infinity
+            T[i] = 0
+            A[i,i-1] = 0
+            continue
+
+        # calculate parameters for housholder transformation
+
+        H = 0
+        for k in xrange(0, i):
+            A[i,k] *= scale_inv
+            rr = ctx.re(A[i,k])
+            ii = ctx.im(A[i,k])
+            H += rr * rr + ii * ii
+
+        F = A[i,i-1]
+        f = abs(F)
+        G = ctx.sqrt(H)
+        A[i,i-1] = - G * scale
+
+        if f == 0:
+            T[i] = G
+        else:
+            ff = F / f
+            T[i] = F + G * ff
+            A[i,i-1] *= ff
+
+        H += G * f
+        H = 1 / ctx.sqrt(H)
+
+        T[i] *= H
+        for k in xrange(0, i - 1):
+            A[i,k] *= H
+
+        for j in xrange(0, i):
+            # apply housholder transformation (from right)
+
+            G = ctx.conj(T[i]) * A[j,i-1]
+            for k in xrange(0, i-1):
+                G += ctx.conj(A[i,k]) * A[j,k]
+
+            A[j,i-1] -= G * T[i]
+            for k in xrange(0, i-1):
+                A[j,k] -= G * A[i,k]
+
+        for j in xrange(0, n):
+            # apply housholder transformation (from left)
+
+            G = T[i] * A[i-1,j]
+            for k in xrange(0, i-1):
+                G += A[i,k] * A[k,j]
+
+            A[i-1,j] -= G * ctx.conj(T[i])
+            for k in xrange(0, i-1):
+                A[k,j] -= G * ctx.conj(A[i,k])
+
+
+
+def hessenberg_reduce_1(ctx, A, T):
+    """
+    This routine forms the unitary matrix Q described in hessenberg_reduce_0.
+
+    parameters:
+      A    (input/output) On input, A is the same matrix as delivered by
+           hessenberg_reduce_0. On output, A is set to Q.
+
+      T    (input) On input, T is the same array as delivered by hessenberg_reduce_0.
+    """
+
+    n = A.rows
+
+    if n == 1:
+        A[0,0] = 1
+        return
+
+    A[0,0] = A[1,1] = 1
+    A[0,1] = A[1,0] = 0
+
+    for i in xrange(2, n):
+        if T[i] != 0:
+
+            for j in xrange(0, i):
+                G = T[i] * A[i-1,j]
+                for k in xrange(0, i-1):
+                    G += A[i,k] * A[k,j]
+
+                A[i-1,j] -= G * ctx.conj(T[i])
+                for k in xrange(0, i-1):
+                    A[k,j] -= G * ctx.conj(A[i,k])
+
+        A[i,i] = 1
+        for j in xrange(0, i):
+            A[j,i] = A[i,j] = 0
+
+
+
+@defun
+def hessenberg(ctx, A, overwrite_a = False):
+    """
+    This routine computes the Hessenberg decomposition of a square matrix A.
+    Given A, an unitary matrix Q is determined such that
+
+          Q' A Q = H                and               Q' Q = Q Q' = 1
+
+    where H is an upper right Hessenberg matrix. Here ' denotes the hermitian
+    transpose (i.e. transposition and conjugation).
+
+    input:
+      A            : a real or complex square matrix
+      overwrite_a  : if true, allows modification of A which may improve
+                     performance. if false, A is not modified.
+
+    output:
+      Q : an unitary matrix
+      H : an upper right Hessenberg matrix
+
+    example:
+      >>> from mpmath import mp
+      >>> A = mp.matrix([[3, -1, 2], [2, 5, -5], [-2, -3, 7]])
+      >>> Q, H = mp.hessenberg(A)
+      >>> mp.nprint(H, 3) # doctest:+SKIP
+      [  3.15  2.23  4.44]
+      [-0.769  4.85  3.05]
+      [   0.0  3.61   7.0]
+      >>> print(mp.chop(A - Q * H * Q.transpose_conj()))
+      [0.0  0.0  0.0]
+      [0.0  0.0  0.0]
+      [0.0  0.0  0.0]
+
+    return value:   (Q, H)
+    """
+
+    n = A.rows
+
+    if n == 1:
+        return (ctx.matrix([[1]]), A)
+
+    if not overwrite_a:
+        A = A.copy()
+
+    T = ctx.matrix(n, 1)
+
+    hessenberg_reduce_0(ctx, A, T)
+    Q = A.copy()
+    hessenberg_reduce_1(ctx, Q, T)
+
+    for x in xrange(n):
+        for y in xrange(x+2, n):
+            A[y,x] = 0
+
+    return Q, A
+
+
+###########################################################################
+
+
+def qr_step(ctx, n0, n1, A, Q, shift):
+    """
+    This subroutine executes a single implicitly shifted QR step applied to an
+    upper Hessenberg matrix A. Given A and shift as input, first an QR
+    decomposition is calculated:
+
+      Q R = A - shift * 1 .
+
+    The output is then following matrix:
+
+      R Q + shift * 1
+
+    parameters:
+      n0, n1    (input) Two integers which specify the submatrix A[n0:n1,n0:n1]
+                on which this subroutine operators. The subdiagonal elements
+                to the left and below this submatrix must be deflated (i.e. zero).
+                following restriction is imposed: n1>=n0+2
+      A         (input/output) On input, A is an upper Hessenberg matrix.
+                On output, A is replaced by "R Q + shift * 1"
+      Q         (input/output) The parameter Q is multiplied by the unitary matrix
+                Q arising from the QR decomposition. Q can also be false, in which
+                case the unitary matrix Q is not computated.
+      shift     (input) a complex number specifying the shift. idealy close to an
+                eigenvalue of the bottemmost part of the submatrix A[n0:n1,n0:n1].
+
+    references:
+      Stoer, Bulirsch - Introduction to Numerical Analysis.
+      Kresser : Numerical Methods for General and Structured Eigenvalue Problems
+    """
+
+    # implicitly shifted and bulge chasing is explained at p.398/399 in "Stoer, Bulirsch - Introduction to Numerical Analysis"
+    # for bulge chasing see also "Watkins - The Matrix Eigenvalue Problem" sec.4.5,p.173
+
+    # the Givens rotation we used is determined as follows: let c,s be two complex
+    # numbers. then we have following relation:
+    #
+    #     v = sqrt(|c|^2 + |s|^2)
+    #
+    #     1/v [ c~  s~]  [c] = [v]
+    #         [-s   c ]  [s]   [0]
+    #
+    # the matrix on the left is our Givens rotation.
+
+    n = A.rows
+
+    # first step
+
+    # calculate givens rotation
+    c = A[n0  ,n0] - shift
+    s = A[n0+1,n0]
+
+    v = ctx.hypot(ctx.hypot(ctx.re(c), ctx.im(c)), ctx.hypot(ctx.re(s), ctx.im(s)))
+
+    if v == 0:
+        v = 1
+        c = 1
+        s = 0
+    else:
+        c /= v
+        s /= v
+
+    cc = ctx.conj(c)
+    cs = ctx.conj(s)
+
+    for k in xrange(n0, n):
+        # apply givens rotation from the left
+        x = A[n0  ,k]
+        y = A[n0+1,k]
+        A[n0  ,k] = cc * x + cs * y
+        A[n0+1,k] = c * y - s * x
+
+    for k in xrange(min(n1, n0+3)):
+        # apply givens rotation from the right
+        x = A[k,n0  ]
+        y = A[k,n0+1]
+        A[k,n0  ] = c * x + s * y
+        A[k,n0+1] = cc * y - cs * x
+
+    if not isinstance(Q, bool):
+        for k in xrange(n):
+            # eigenvectors
+            x = Q[k,n0  ]
+            y = Q[k,n0+1]
+            Q[k,n0  ] = c * x + s * y
+            Q[k,n0+1] = cc * y - cs * x
+
+    # chase the bulge
+
+    for j in xrange(n0, n1 - 2):
+        # calculate givens rotation
+
+        c = A[j+1,j]
+        s = A[j+2,j]
+
+        v = ctx.hypot(ctx.hypot(ctx.re(c), ctx.im(c)), ctx.hypot(ctx.re(s), ctx.im(s)))
+
+        if v == 0:
+            A[j+1,j] = 0
+            v = 1
+            c = 1
+            s = 0
+        else:
+            A[j+1,j] = v
+            c /= v
+            s /= v
+
+        A[j+2,j] = 0
+
+        cc = ctx.conj(c)
+        cs = ctx.conj(s)
+
+        for k in xrange(j+1, n):
+            # apply givens rotation from the left
+            x = A[j+1,k]
+            y = A[j+2,k]
+            A[j+1,k] = cc * x + cs * y
+            A[j+2,k] = c * y - s * x
+
+        for k in xrange(0, min(n1, j+4)):
+            # apply givens rotation from the right
+            x = A[k,j+1]
+            y = A[k,j+2]
+            A[k,j+1] = c * x + s * y
+            A[k,j+2] = cc * y - cs * x
+
+        if not isinstance(Q, bool):
+            for k in xrange(0, n):
+                # eigenvectors
+                x = Q[k,j+1]
+                y = Q[k,j+2]
+                Q[k,j+1] = c * x + s * y
+                Q[k,j+2] = cc * y - cs * x
+
+
+
+def hessenberg_qr(ctx, A, Q):
+    """
+    This routine computes the Schur decomposition of an upper Hessenberg matrix A.
+    Given A, an unitary matrix Q is determined such that
+
+          Q' A Q = R                   and                  Q' Q = Q Q' = 1
+
+    where R is an upper right triangular matrix. Here ' denotes the hermitian
+    transpose (i.e. transposition and conjugation).
+
+    parameters:
+      A         (input/output) On input, A contains an upper Hessenberg matrix.
+                On output, A is replace by the upper right triangluar matrix R.
+
+      Q         (input/output) The parameter Q is multiplied by the unitary
+                matrix Q arising from the Schur decomposition. Q can also be
+                false, in which case the unitary matrix Q is not computated.
+    """
+
+    n = A.rows
+
+    norm = 0
+    for x in xrange(n):
+        for y in xrange(min(x+2, n)):
+            norm += ctx.re(A[y,x]) ** 2 + ctx.im(A[y,x]) ** 2
+    norm = ctx.sqrt(norm) / n
+
+    if norm == 0:
+        return
+
+    n0 = 0
+    n1 = n
+
+    eps = ctx.eps / (100 * n)
+    maxits = ctx.dps * 4
+
+    its = totalits = 0
+
+    while 1:
+        # kressner p.32 algo 3
+        # the active submatrix is A[n0:n1,n0:n1]
+
+        k = n0
+
+        while k + 1 < n1:
+            s = abs(ctx.re(A[k,k])) + abs(ctx.im(A[k,k])) + abs(ctx.re(A[k+1,k+1])) + abs(ctx.im(A[k+1,k+1]))
+            if s < eps * norm:
+                s = norm
+            if abs(A[k+1,k]) < eps * s:
+                break
+            k += 1
+
+        if k + 1 < n1:
+            # deflation found at position (k+1, k)
+
+            A[k+1,k] = 0
+            n0 = k + 1
+
+            its = 0
+
+            if n0 + 1 >= n1:
+                # block of size at most two has converged
+                n0 = 0
+                n1 = k + 1
+                if n1 < 2:
+                    # QR algorithm has converged
+                    return
+        else:
+            if (its % 30) == 10:
+                # exceptional shift
+                shift = A[n1-1,n1-2]
+            elif (its % 30) == 20:
+                # exceptional shift
+                shift = abs(A[n1-1,n1-2])
+            elif (its % 30) == 29:
+                # exceptional shift
+                shift = norm
+            else:
+                #    A = [ a b ]       det(x-A)=x*x-x*tr(A)+det(A)
+                #        [ c d ]
+                #
+                # eigenvalues bad:   (tr(A)+sqrt((tr(A))**2-4*det(A)))/2
+                #     bad because of cancellation if |c| is small and |a-d| is small, too.
+                #
+                # eigenvalues good:     (a+d+sqrt((a-d)**2+4*b*c))/2
+
+                t =  A[n1-2,n1-2] + A[n1-1,n1-1]
+                s = (A[n1-1,n1-1] - A[n1-2,n1-2]) ** 2 + 4 * A[n1-1,n1-2] * A[n1-2,n1-1]
+                if ctx.re(s) > 0:
+                    s = ctx.sqrt(s)
+                else:
+                    s = ctx.sqrt(-s) * 1j
+                a = (t + s) / 2
+                b = (t - s) / 2
+                if abs(A[n1-1,n1-1] - a) > abs(A[n1-1,n1-1] - b):
+                    shift = b
+                else:
+                    shift = a
+
+            its += 1
+            totalits += 1
+
+            qr_step(ctx, n0, n1, A, Q, shift)
+
+            if its > maxits:
+                raise RuntimeError("qr: failed to converge after %d steps" % its)
+
+
+@defun
+def schur(ctx, A, overwrite_a = False):
+    """
+    This routine computes the Schur decomposition of a square matrix A.
+    Given A, an unitary matrix Q is determined such that
+
+          Q' A Q = R                and               Q' Q = Q Q' = 1
+
+    where R is an upper right triangular matrix. Here ' denotes the
+    hermitian transpose (i.e. transposition and conjugation).
+
+    input:
+      A            : a real or complex square matrix
+      overwrite_a  : if true, allows modification of A which may improve
+                     performance. if false, A is not modified.
+
+    output:
+      Q : an unitary matrix
+      R : an upper right triangular matrix
+
+    return value:   (Q, R)
+
+    example:
+      >>> from mpmath import mp
+      >>> A = mp.matrix([[3, -1, 2], [2, 5, -5], [-2, -3, 7]])
+      >>> Q, R = mp.schur(A)
+      >>> mp.nprint(R, 3) # doctest:+SKIP
+      [2.0  0.417  -2.53]
+      [0.0    4.0  -4.74]
+      [0.0    0.0    9.0]
+      >>> print(mp.chop(A - Q * R * Q.transpose_conj()))
+      [0.0  0.0  0.0]
+      [0.0  0.0  0.0]
+      [0.0  0.0  0.0]
+
+    warning: The Schur decomposition is not unique.
+    """
+
+    n = A.rows
+
+    if n == 1:
+        return (ctx.matrix([[1]]), A)
+
+    if not overwrite_a:
+        A = A.copy()
+
+    T = ctx.matrix(n, 1)
+
+    hessenberg_reduce_0(ctx, A, T)
+    Q = A.copy()
+    hessenberg_reduce_1(ctx, Q, T)
+
+    for x in xrange(n):
+        for y in xrange(x + 2, n):
+            A[y,x] = 0
+
+    hessenberg_qr(ctx, A, Q)
+
+    return Q, A
+
+
+def eig_tr_r(ctx, A):
+    """
+    This routine calculates the right eigenvectors of an upper right triangular matrix.
+
+    input:
+      A      an upper right triangular matrix
+
+    output:
+      ER     a matrix whose columns form the right eigenvectors of A
+
+    return value: ER
+    """
+
+    # this subroutine is inspired by the lapack routines ctrevc.f,clatrs.f
+
+    n = A.rows
+
+    ER = ctx.eye(n)
+
+    eps = ctx.eps
+
+    unfl = ctx.ldexp(ctx.one, -ctx.prec * 30)
+    # since mpmath effectively has no limits on the exponent, we simply scale doubles up
+    # original double has prec*20
+
+    smlnum = unfl * (n / eps)
+    simin = 1 / ctx.sqrt(eps)
+
+    rmax = 1
+
+    for i in xrange(1, n):
+        s = A[i,i]
+
+        smin = max(eps * abs(s), smlnum)
+
+        for j in xrange(i - 1, -1, -1):
+
+            r = 0
+            for k in xrange(j + 1, i + 1):
+                r += A[j,k] * ER[k,i]
+
+            t = A[j,j] - s
+            if abs(t) < smin:
+                t = smin
+
+            r = -r / t
+            ER[j,i] = r
+
+            rmax = max(rmax, abs(r))
+            if rmax > simin:
+                for k in xrange(j, i+1):
+                    ER[k,i] /= rmax
+                rmax = 1
+
+        if rmax != 1:
+            for k in xrange(0, i + 1):
+                ER[k,i] /= rmax
+
+    return ER
+
+def eig_tr_l(ctx, A):
+    """
+    This routine calculates the left eigenvectors of an upper right triangular matrix.
+
+    input:
+      A      an upper right triangular matrix
+
+    output:
+      EL     a matrix whose rows form the left eigenvectors of A
+
+    return value:  EL
+    """
+
+    n = A.rows
+
+    EL = ctx.eye(n)
+
+    eps = ctx.eps
+
+    unfl = ctx.ldexp(ctx.one, -ctx.prec * 30)
+    # since mpmath effectively has no limits on the exponent, we simply scale doubles up
+    # original double has prec*20
+
+    smlnum = unfl * (n / eps)
+    simin = 1 / ctx.sqrt(eps)
+
+    rmax = 1
+
+    for i in xrange(0, n - 1):
+        s = A[i,i]
+
+        smin = max(eps * abs(s), smlnum)
+
+        for j in xrange(i + 1, n):
+
+            r = 0
+            for k in xrange(i, j):
+                r += EL[i,k] * A[k,j]
+
+            t = A[j,j] - s
+            if abs(t) < smin:
+                t = smin
+
+            r = -r / t
+            EL[i,j] = r
+
+            rmax = max(rmax, abs(r))
+            if rmax > simin:
+                for k in xrange(i, j + 1):
+                    EL[i,k] /= rmax
+                rmax = 1
+
+        if rmax != 1:
+            for k in xrange(i, n):
+                EL[i,k] /= rmax
+
+    return EL
+
+@defun
+def eig(ctx, A, left = False, right = True, overwrite_a = False):
+    """
+    This routine computes the eigenvalues and optionally the left and right
+    eigenvectors of a square matrix A. Given A, a vector E and matrices ER
+    and EL are calculated such that
+
+                        A ER[:,i] =         E[i] ER[:,i]
+                EL[i,:] A         = EL[i,:] E[i]
+
+    E contains the eigenvalues of A. The columns of ER contain the right eigenvectors
+    of A whereas the rows of EL contain the left eigenvectors.
+
+
+    input:
+      A           : a real or complex square matrix of shape (n, n)
+      left        : if true, the left eigenvectors are calculated.
+      right       : if true, the right eigenvectors are calculated.
+      overwrite_a : if true, allows modification of A which may improve
+                    performance. if false, A is not modified.
+
+    output:
+      E    : a list of length n containing the eigenvalues of A.
+      ER   : a matrix whose columns contain the right eigenvectors of A.
+      EL   : a matrix whose rows contain the left eigenvectors of A.
+
+    return values:
+       E            if left and right are both false.
+      (E, ER)       if right is true and left is false.
+      (E, EL)       if left is true and right is false.
+      (E, EL, ER)   if left and right are true.
+
+
+    examples:
+      >>> from mpmath import mp
+      >>> A = mp.matrix([[3, -1, 2], [2, 5, -5], [-2, -3, 7]])
+      >>> E, ER = mp.eig(A)
+      >>> print(mp.chop(A * ER[:,0] - E[0] * ER[:,0]))
+      [0.0]
+      [0.0]
+      [0.0]
+
+      >>> E, EL, ER = mp.eig(A,left = True, right = True)
+      >>> E, EL, ER = mp.eig_sort(E, EL, ER)
+      >>> mp.nprint(E)
+      [2.0, 4.0, 9.0]
+      >>> print(mp.chop(A * ER[:,0] - E[0] * ER[:,0]))
+      [0.0]
+      [0.0]
+      [0.0]
+      >>> print(mp.chop( EL[0,:] * A - EL[0,:] * E[0]))
+      [0.0  0.0  0.0]
+
+    warning:
+     - If there are multiple eigenvalues, the eigenvectors do not necessarily
+       span the whole vectorspace, i.e. ER and EL may have not full rank.
+       Furthermore in that case the eigenvectors are numerical ill-conditioned.
+     - In the general case the eigenvalues have no natural order.
+
+    see also:
+      - eigh (or eigsy, eighe) for the symmetric eigenvalue problem.
+      - eig_sort for sorting of eigenvalues and eigenvectors
+    """
+
+    n = A.rows
+
+    if n == 1:
+        if left and (not right):
+            return ([A[0]], ctx.matrix([[1]]))
+
+        if right and (not left):
+            return ([A[0]], ctx.matrix([[1]]))
+
+        return ([A[0]], ctx.matrix([[1]]), ctx.matrix([[1]]))
+
+    if not overwrite_a:
+        A = A.copy()
+
+    T = ctx.zeros(n, 1)
+
+    hessenberg_reduce_0(ctx, A, T)
+
+    if left or right:
+        Q = A.copy()
+        hessenberg_reduce_1(ctx, Q, T)
+    else:
+        Q = False
+
+    for x in xrange(n):
+        for y in xrange(x + 2, n):
+            A[y,x] = 0
+
+    hessenberg_qr(ctx, A, Q)
+
+    E = [0 for i in xrange(n)]
+    for i in xrange(n):
+        E[i] = A[i,i]
+
+    if not (left or right):
+        return E
+
+    if left:
+        EL = eig_tr_l(ctx, A)
+        EL = EL * Q.transpose_conj()
+
+    if right:
+        ER = eig_tr_r(ctx, A)
+        ER = Q * ER
+
+    if left and (not right):
+        return (E, EL)
+
+    if right and (not left):
+        return (E, ER)
+
+    return (E, EL, ER)
+
+@defun
+def eig_sort(ctx, E, EL = False, ER = False, f = "real"):
+    """
+    This routine sorts the eigenvalues and eigenvectors delivered by ``eig``.
+
+    parameters:
+      E  : the eigenvalues as delivered by eig
+      EL : the left  eigenvectors as delivered by eig, or false
+      ER : the right eigenvectors as delivered by eig, or false
+      f  : either a string ("real" sort by increasing real part, "imag" sort by
+           increasing imag part, "abs" sort by absolute value) or a function
+           mapping complexs to the reals, i.e. ``f = lambda x: -mp.re(x) ``
+           would sort the eigenvalues by decreasing real part.
+
+    return values:
+       E            if EL and ER are both false.
+      (E, ER)       if ER is not false and left is false.
+      (E, EL)       if EL is not false and right is false.
+      (E, EL, ER)   if EL and ER are not false.
+
+    example:
+      >>> from mpmath import mp
+      >>> A = mp.matrix([[3, -1, 2], [2, 5, -5], [-2, -3, 7]])
+      >>> E, EL, ER = mp.eig(A,left = True, right = True)
+      >>> E, EL, ER = mp.eig_sort(E, EL, ER)
+      >>> mp.nprint(E)
+      [2.0, 4.0, 9.0]
+      >>> E, EL, ER = mp.eig_sort(E, EL, ER,f = lambda x: -mp.re(x))
+      >>> mp.nprint(E)
+      [9.0, 4.0, 2.0]
+      >>> print(mp.chop(A * ER[:,0] - E[0] * ER[:,0]))
+      [0.0]
+      [0.0]
+      [0.0]
+      >>> print(mp.chop( EL[0,:] * A - EL[0,:] * E[0]))
+      [0.0  0.0  0.0]
+    """
+
+    if isinstance(f, str):
+        if f == "real":
+            f = ctx.re
+        elif f == "imag":
+            f = ctx.im
+        elif f == "abs":
+            f = abs
+        else:
+            raise RuntimeError("unknown function %s" % f)
+
+    n = len(E)
+
+    # Sort eigenvalues (bubble-sort)
+
+    for i in xrange(n):
+        imax = i
+        s = f(E[i])         # s is the current maximal element
+
+        for j in xrange(i + 1, n):
+            c = f(E[j])
+            if c < s:
+                s = c
+                imax = j
+
+        if imax != i:
+            # swap eigenvalues
+
+            z = E[i]
+            E[i] = E[imax]
+            E[imax] = z
+
+            if not isinstance(EL, bool):
+                for j in xrange(n):
+                    z = EL[i,j]
+                    EL[i,j] = EL[imax,j]
+                    EL[imax,j] = z
+
+            if not isinstance(ER, bool):
+                for j in xrange(n):
+                    z = ER[j,i]
+                    ER[j,i] = ER[j,imax]
+                    ER[j,imax] = z
+
+    if isinstance(EL, bool) and isinstance(ER, bool):
+        return E
+
+    if isinstance(EL, bool) and not(isinstance(ER, bool)):
+        return (E, ER)
+
+    if isinstance(ER, bool) and not(isinstance(EL, bool)):
+        return (E, EL)
+
+    return (E, EL, ER)

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

@@ -0,0 +1,790 @@
+"""
+Linear algebra
+--------------
+
+Linear equations
+................
+
+Basic linear algebra is implemented; you can for example solve the linear
+equation system::
+
+      x + 2*y = -10
+    3*x + 4*y =  10
+
+using ``lu_solve``::
+
+    >>> from mpmath import *
+    >>> mp.pretty = False
+    >>> A = matrix([[1, 2], [3, 4]])
+    >>> b = matrix([-10, 10])
+    >>> x = lu_solve(A, b)
+    >>> x
+    matrix(
+    [['30.0'],
+     ['-20.0']])
+
+If you don't trust the result, use ``residual`` to calculate the residual ||A*x-b||::
+
+    >>> residual(A, x, b)
+    matrix(
+    [['3.46944695195361e-18'],
+     ['3.46944695195361e-18']])
+    >>> str(eps)
+    '2.22044604925031e-16'
+
+As you can see, the solution is quite accurate. The error is caused by the
+inaccuracy of the internal floating point arithmetic. Though, it's even smaller
+than the current machine epsilon, which basically means you can trust the
+result.
+
+If you need more speed, use NumPy, or ``fp.lu_solve`` for a floating-point computation.
+
+    >>> fp.lu_solve(A, b)   # doctest: +ELLIPSIS
+    matrix(...)
+
+``lu_solve`` accepts overdetermined systems. It is usually not possible to solve
+such systems, so the residual is minimized instead. Internally this is done
+using Cholesky decomposition to compute a least squares approximation. This means
+that that ``lu_solve`` will square the errors. If you can't afford this, use
+``qr_solve`` instead. It is twice as slow but more accurate, and it calculates
+the residual automatically.
+
+
+Matrix factorization
+....................
+
+The function ``lu`` computes an explicit LU factorization of a matrix::
+
+    >>> P, L, U = lu(matrix([[0,2,3],[4,5,6],[7,8,9]]))
+    >>> print(P)
+    [0.0  0.0  1.0]
+    [1.0  0.0  0.0]
+    [0.0  1.0  0.0]
+    >>> print(L)
+    [              1.0                0.0  0.0]
+    [              0.0                1.0  0.0]
+    [0.571428571428571  0.214285714285714  1.0]
+    >>> print(U)
+    [7.0  8.0                9.0]
+    [0.0  2.0                3.0]
+    [0.0  0.0  0.214285714285714]
+    >>> print(P.T*L*U)
+    [0.0  2.0  3.0]
+    [4.0  5.0  6.0]
+    [7.0  8.0  9.0]
+
+Interval matrices
+-----------------
+
+Matrices may contain interval elements. This allows one to perform
+basic linear algebra operations such as matrix multiplication
+and equation solving with rigorous error bounds::
+
+    >>> a = iv.matrix([['0.1','0.3','1.0'],
+    ...             ['7.1','5.5','4.8'],
+    ...             ['3.2','4.4','5.6']])
+    >>>
+    >>> b = iv.matrix(['4','0.6','0.5'])
+    >>> c = iv.lu_solve(a, b)
+    >>> print(c)
+    [   [5.2582327113062568605927528666, 5.25823271130625686059275702219]]
+    [[-13.1550493962678375411635581388, -13.1550493962678375411635540152]]
+    [  [7.42069154774972557628979076189, 7.42069154774972557628979190734]]
+    >>> print(a*c)
+    [  [3.99999999999999999999999844904, 4.00000000000000000000000155096]]
+    [[0.599999999999999999999968898009, 0.600000000000000000000031763736]]
+    [[0.499999999999999999999979320485, 0.500000000000000000000020679515]]
+"""
+
+# TODO:
+# *implement high-level qr()
+# *test unitvector
+# *iterative solving
+
+from copy import copy
+
+from ..libmp.backend import xrange
+
+class LinearAlgebraMethods(object):
+
+    def LU_decomp(ctx, A, overwrite=False, use_cache=True):
+        """
+        LU-factorization of a n*n matrix using the Gauss algorithm.
+        Returns L and U in one matrix and the pivot indices.
+
+        Use overwrite to specify whether A will be overwritten with L and U.
+        """
+        if not A.rows == A.cols:
+            raise ValueError('need n*n matrix')
+        # get from cache if possible
+        if use_cache and isinstance(A, ctx.matrix) and A._LU:
+            return A._LU
+        if not overwrite:
+            orig = A
+            A = A.copy()
+        tol = ctx.absmin(ctx.mnorm(A,1) * ctx.eps) # each pivot element has to be bigger
+        n = A.rows
+        p = [None]*(n - 1)
+        for j in xrange(n - 1):
+            # pivoting, choose max(abs(reciprocal row sum)*abs(pivot element))
+            biggest = 0
+            for k in xrange(j, n):
+                s = ctx.fsum([ctx.absmin(A[k,l]) for l in xrange(j, n)])
+                if ctx.absmin(s) <= tol:
+                    raise ZeroDivisionError('matrix is numerically singular')
+                current = 1/s * ctx.absmin(A[k,j])
+                if current > biggest: # TODO: what if equal?
+                    biggest = current
+                    p[j] = k
+            # swap rows according to p
+            ctx.swap_row(A, j, p[j])
+            if ctx.absmin(A[j,j]) <= tol:
+                raise ZeroDivisionError('matrix is numerically singular')
+            # calculate elimination factors and add rows
+            for i in xrange(j + 1, n):
+                A[i,j] /= A[j,j]
+                for k in xrange(j + 1, n):
+                    A[i,k] -= A[i,j]*A[j,k]
+        if ctx.absmin(A[n - 1,n - 1]) <= tol:
+            raise ZeroDivisionError('matrix is numerically singular')
+        # cache decomposition
+        if not overwrite and isinstance(orig, ctx.matrix):
+            orig._LU = (A, p)
+        return A, p
+
+    def L_solve(ctx, L, b, p=None):
+        """
+        Solve the lower part of a LU factorized matrix for y.
+        """
+        if L.rows != L.cols:
+            raise RuntimeError("need n*n matrix")
+        n = L.rows
+        if len(b) != n:
+            raise ValueError("Value should be equal to n")
+        b = copy(b)
+        if p: # swap b according to p
+            for k in xrange(0, len(p)):
+                ctx.swap_row(b, k, p[k])
+        # solve
+        for i in xrange(1, n):
+            for j in xrange(i):
+                b[i] -= L[i,j] * b[j]
+        return b
+
+    def U_solve(ctx, U, y):
+        """
+        Solve the upper part of a LU factorized matrix for x.
+        """
+        if U.rows != U.cols:
+            raise RuntimeError("need n*n matrix")
+        n = U.rows
+        if len(y) != n:
+            raise ValueError("Value should be equal to n")
+        x = copy(y)
+        for i in xrange(n - 1, -1, -1):
+            for j in xrange(i + 1, n):
+                x[i] -= U[i,j] * x[j]
+            x[i] /= U[i,i]
+        return x
+
+    def lu_solve(ctx, A, b, **kwargs):
+        """
+        Ax = b => x
+
+        Solve a determined or overdetermined linear equations system.
+        Fast LU decomposition is used, which is less accurate than QR decomposition
+        (especially for overdetermined systems), but it's twice as efficient.
+        Use qr_solve if you want more precision or have to solve a very ill-
+        conditioned system.
+
+        If you specify real=True, it does not check for overdeterminded complex
+        systems.
+        """
+        prec = ctx.prec
+        try:
+            ctx.prec += 10
+            # do not overwrite A nor b
+            A, b = ctx.matrix(A, **kwargs).copy(), ctx.matrix(b, **kwargs).copy()
+            if A.rows < A.cols:
+                raise ValueError('cannot solve underdetermined system')
+            if A.rows > A.cols:
+                # use least-squares method if overdetermined
+                # (this increases errors)
+                AH = A.H
+                A = AH * A
+                b = AH * b
+                if (kwargs.get('real', False) or
+                    not sum(type(i) is ctx.mpc for i in A)):
+                    # TODO: necessary to check also b?
+                    x = ctx.cholesky_solve(A, b)
+                else:
+                    x = ctx.lu_solve(A, b)
+            else:
+                # LU factorization
+                A, p = ctx.LU_decomp(A)
+                b = ctx.L_solve(A, b, p)
+                x = ctx.U_solve(A, b)
+        finally:
+            ctx.prec = prec
+        return x
+
+    def improve_solution(ctx, A, x, b, maxsteps=1):
+        """
+        Improve a solution to a linear equation system iteratively.
+
+        This re-uses the LU decomposition and is thus cheap.
+        Usually 3 up to 4 iterations are giving the maximal improvement.
+        """
+        if A.rows != A.cols:
+            raise RuntimeError("need n*n matrix") # TODO: really?
+        for _ in xrange(maxsteps):
+            r = ctx.residual(A, x, b)
+            if ctx.norm(r, 2) < 10*ctx.eps:
+                break
+            # this uses cached LU decomposition and is thus cheap
+            dx = ctx.lu_solve(A, -r)
+            x += dx
+        return x
+
+    def lu(ctx, A):
+        """
+        A -> P, L, U
+
+        LU factorisation of a square matrix A. L is the lower, U the upper part.
+        P is the permutation matrix indicating the row swaps.
+
+        P*A = L*U
+
+        If you need efficiency, use the low-level method LU_decomp instead, it's
+        much more memory efficient.
+        """
+        # get factorization
+        A, p = ctx.LU_decomp(A)
+        n = A.rows
+        L = ctx.matrix(n)
+        U = ctx.matrix(n)
+        for i in xrange(n):
+            for j in xrange(n):
+                if i > j:
+                    L[i,j] = A[i,j]
+                elif i == j:
+                    L[i,j] = 1
+                    U[i,j] = A[i,j]
+                else:
+                    U[i,j] = A[i,j]
+        # calculate permutation matrix
+        P = ctx.eye(n)
+        for k in xrange(len(p)):
+            ctx.swap_row(P, k, p[k])
+        return P, L, U
+
+    def unitvector(ctx, n, i):
+        """
+        Return the i-th n-dimensional unit vector.
+        """
+        assert 0 < i <= n, 'this unit vector does not exist'
+        return [ctx.zero]*(i-1) + [ctx.one] + [ctx.zero]*(n-i)
+
+    def inverse(ctx, A, **kwargs):
+        """
+        Calculate the inverse of a matrix.
+
+        If you want to solve an equation system Ax = b, it's recommended to use
+        solve(A, b) instead, it's about 3 times more efficient.
+        """
+        prec = ctx.prec
+        try:
+            ctx.prec += 10
+            # do not overwrite A
+            A = ctx.matrix(A, **kwargs).copy()
+            n = A.rows
+            # get LU factorisation
+            A, p = ctx.LU_decomp(A)
+            cols = []
+            # calculate unit vectors and solve corresponding system to get columns
+            for i in xrange(1, n + 1):
+                e = ctx.unitvector(n, i)
+                y = ctx.L_solve(A, e, p)
+                cols.append(ctx.U_solve(A, y))
+            # convert columns to matrix
+            inv = []
+            for i in xrange(n):
+                row = []
+                for j in xrange(n):
+                    row.append(cols[j][i])
+                inv.append(row)
+            result = ctx.matrix(inv, **kwargs)
+        finally:
+            ctx.prec = prec
+        return result
+
+    def householder(ctx, A):
+        """
+        (A|b) -> H, p, x, res
+
+        (A|b) is the coefficient matrix with left hand side of an optionally
+        overdetermined linear equation system.
+        H and p contain all information about the transformation matrices.
+        x is the solution, res the residual.
+        """
+        if not isinstance(A, ctx.matrix):
+            raise TypeError("A should be a type of ctx.matrix")
+        m = A.rows
+        n = A.cols
+        if m < n - 1:
+            raise RuntimeError("Columns should not be less than rows")
+        # calculate Householder matrix
+        p = []
+        for j in xrange(0, n - 1):
+            s = ctx.fsum(abs(A[i,j])**2 for i in xrange(j, m))
+            if not abs(s) > ctx.eps:
+                raise ValueError('matrix is numerically singular')
+            p.append(-ctx.sign(ctx.re(A[j,j])) * ctx.sqrt(s))
+            kappa = ctx.one / (s - p[j] * A[j,j])
+            A[j,j] -= p[j]
+            for k in xrange(j+1, n):
+                y = ctx.fsum(ctx.conj(A[i,j]) * A[i,k] for i in xrange(j, m)) * kappa
+                for i in xrange(j, m):
+                    A[i,k] -= A[i,j] * y
+        # solve Rx = c1
+        x = [A[i,n - 1] for i in xrange(n - 1)]
+        for i in xrange(n - 2, -1, -1):
+            x[i] -= ctx.fsum(A[i,j] * x[j] for j in xrange(i + 1, n - 1))
+            x[i] /= p[i]
+        # calculate residual
+        if not m == n - 1:
+            r = [A[m-1-i, n-1] for i in xrange(m - n + 1)]
+        else:
+            # determined system, residual should be 0
+            r = [0]*m # maybe a bad idea, changing r[i] will change all elements
+        return A, p, x, r
+
+    #def qr(ctx, A):
+    #    """
+    #    A -> Q, R
+    #
+    #    QR factorisation of a square matrix A using Householder decomposition.
+    #    Q is orthogonal, this leads to very few numerical errors.
+    #
+    #    A = Q*R
+    #    """
+    #    H, p, x, res = householder(A)
+    # TODO: implement this
+
+    def residual(ctx, A, x, b, **kwargs):
+        """
+        Calculate the residual of a solution to a linear equation system.
+
+        r = A*x - b for A*x = b
+        """
+        oldprec = ctx.prec
+        try:
+            ctx.prec *= 2
+            A, x, b = ctx.matrix(A, **kwargs), ctx.matrix(x, **kwargs), ctx.matrix(b, **kwargs)
+            return A*x - b
+        finally:
+            ctx.prec = oldprec
+
+    def qr_solve(ctx, A, b, norm=None, **kwargs):
+        """
+        Ax = b => x, ||Ax - b||
+
+        Solve a determined or overdetermined linear equations system and
+        calculate the norm of the residual (error).
+        QR decomposition using Householder factorization is applied, which gives very
+        accurate results even for ill-conditioned matrices. qr_solve is twice as
+        efficient.
+        """
+        if norm is None:
+            norm = ctx.norm
+        prec = ctx.prec
+        try:
+            ctx.prec += 10
+            # do not overwrite A nor b
+            A, b = ctx.matrix(A, **kwargs).copy(), ctx.matrix(b, **kwargs).copy()
+            if A.rows < A.cols:
+                raise ValueError('cannot solve underdetermined system')
+            H, p, x, r = ctx.householder(ctx.extend(A, b))
+            res = ctx.norm(r)
+            # calculate residual "manually" for determined systems
+            if res == 0:
+                res = ctx.norm(ctx.residual(A, x, b))
+            return ctx.matrix(x, **kwargs), res
+        finally:
+            ctx.prec = prec
+
+    def cholesky(ctx, A, tol=None):
+        r"""
+        Cholesky decomposition of a symmetric positive-definite matrix `A`.
+        Returns a lower triangular matrix `L` such that `A = L \times L^T`.
+        More generally, for a complex Hermitian positive-definite matrix,
+        a Cholesky decomposition satisfying `A = L \times L^H` is returned.
+
+        The Cholesky decomposition can be used to solve linear equation
+        systems twice as efficiently as LU decomposition, or to
+        test whether `A` is positive-definite.
+
+        The optional parameter ``tol`` determines the tolerance for
+        verifying positive-definiteness.
+
+        **Examples**
+
+        Cholesky decomposition of a positive-definite symmetric matrix::
+
+            >>> from mpmath import *
+            >>> mp.dps = 25; mp.pretty = True
+            >>> A = eye(3) + hilbert(3)
+            >>> nprint(A)
+            [     2.0      0.5  0.333333]
+            [     0.5  1.33333      0.25]
+            [0.333333     0.25       1.2]
+            >>> L = cholesky(A)
+            >>> nprint(L)
+            [ 1.41421      0.0      0.0]
+            [0.353553  1.09924      0.0]
+            [0.235702  0.15162  1.05899]
+            >>> chop(A - L*L.T)
+            [0.0  0.0  0.0]
+            [0.0  0.0  0.0]
+            [0.0  0.0  0.0]
+
+        Cholesky decomposition of a Hermitian matrix::
+
+            >>> A = eye(3) + matrix([[0,0.25j,-0.5j],[-0.25j,0,0],[0.5j,0,0]])
+            >>> L = cholesky(A)
+            >>> nprint(L)
+            [          1.0                0.0                0.0]
+            [(0.0 - 0.25j)  (0.968246 + 0.0j)                0.0]
+            [ (0.0 + 0.5j)  (0.129099 + 0.0j)  (0.856349 + 0.0j)]
+            >>> chop(A - L*L.H)
+            [0.0  0.0  0.0]
+            [0.0  0.0  0.0]
+            [0.0  0.0  0.0]
+
+        Attempted Cholesky decomposition of a matrix that is not positive
+        definite::
+
+            >>> A = -eye(3) + hilbert(3)
+            >>> L = cholesky(A)
+            Traceback (most recent call last):
+              ...
+            ValueError: matrix is not positive-definite
+
+        **References**
+
+        1. [Wikipedia]_ http://en.wikipedia.org/wiki/Cholesky_decomposition
+
+        """
+        if not isinstance(A, ctx.matrix):
+            raise RuntimeError("A should be a type of ctx.matrix")
+        if not A.rows == A.cols:
+            raise ValueError('need n*n matrix')
+        if tol is None:
+            tol = +ctx.eps
+        n = A.rows
+        L = ctx.matrix(n)
+        for j in xrange(n):
+            c = ctx.re(A[j,j])
+            if abs(c-A[j,j]) > tol:
+                raise ValueError('matrix is not Hermitian')
+            s = c - ctx.fsum((L[j,k] for k in xrange(j)),
+                absolute=True, squared=True)
+            if s < tol:
+                raise ValueError('matrix is not positive-definite')
+            L[j,j] = ctx.sqrt(s)
+            for i in xrange(j, n):
+                it1 = (L[i,k] for k in xrange(j))
+                it2 = (L[j,k] for k in xrange(j))
+                t = ctx.fdot(it1, it2, conjugate=True)
+                L[i,j] = (A[i,j] - t) / L[j,j]
+        return L
+
+    def cholesky_solve(ctx, A, b, **kwargs):
+        """
+        Ax = b => x
+
+        Solve a symmetric positive-definite linear equation system.
+        This is twice as efficient as lu_solve.
+
+        Typical use cases:
+        * A.T*A
+        * Hessian matrix
+        * differential equations
+        """
+        prec = ctx.prec
+        try:
+            ctx.prec += 10
+            # do not overwrite A nor b
+            A, b = ctx.matrix(A, **kwargs).copy(), ctx.matrix(b, **kwargs).copy()
+            if A.rows !=  A.cols:
+                raise ValueError('can only solve determined system')
+            # Cholesky factorization
+            L = ctx.cholesky(A)
+            # solve
+            n = L.rows
+            if len(b) != n:
+                raise ValueError("Value should be equal to n")
+            for i in xrange(n):
+                b[i] -= ctx.fsum(L[i,j] * b[j] for j in xrange(i))
+                b[i] /= L[i,i]
+            x = ctx.U_solve(L.T, b)
+            return x
+        finally:
+            ctx.prec = prec
+
+    def det(ctx, A):
+        """
+        Calculate the determinant of a matrix.
+        """
+        prec = ctx.prec
+        try:
+            # do not overwrite A
+            A = ctx.matrix(A).copy()
+            # use LU factorization to calculate determinant
+            try:
+                R, p = ctx.LU_decomp(A)
+            except ZeroDivisionError:
+                return 0
+            z = 1
+            for i, e in enumerate(p):
+                if i != e:
+                    z *= -1
+            for i in xrange(A.rows):
+                z *= R[i,i]
+            return z
+        finally:
+            ctx.prec = prec
+
+    def cond(ctx, A, norm=None):
+        """
+        Calculate the condition number of a matrix using a specified matrix norm.
+
+        The condition number estimates the sensitivity of a matrix to errors.
+        Example: small input errors for ill-conditioned coefficient matrices
+        alter the solution of the system dramatically.
+
+        For ill-conditioned matrices it's recommended to use qr_solve() instead
+        of lu_solve(). This does not help with input errors however, it just avoids
+        to add additional errors.
+
+        Definition:    cond(A) = ||A|| * ||A**-1||
+        """
+        if norm is None:
+            norm = lambda x: ctx.mnorm(x,1)
+        return norm(A) * norm(ctx.inverse(A))
+
+    def lu_solve_mat(ctx, a, b):
+        """Solve a * x = b  where a and b are matrices."""
+        r = ctx.matrix(a.rows, b.cols)
+        for i in range(b.cols):
+            c = ctx.lu_solve(a, b.column(i))
+            for j in range(len(c)):
+                r[j, i] = c[j]
+        return r
+
+    def qr(ctx, A, mode = 'full', edps = 10):
+        """
+        Compute a QR factorization $A = QR$ where
+        A is an m x n matrix of real or complex numbers where m >= n
+
+        mode has following meanings:
+        (1) mode = 'raw' returns two matrixes (A, tau) in the
+            internal format used by LAPACK
+        (2) mode = 'skinny' returns the leading n columns of Q
+            and n rows of R
+        (3) Any other value returns the leading m columns of Q
+            and m rows of R
+
+        edps is the increase in mp precision used for calculations
+
+        **Examples**
+
+            >>> from mpmath import *
+            >>> mp.dps = 15
+            >>> mp.pretty = True
+            >>> A = matrix([[1, 2], [3, 4], [1, 1]])
+            >>> Q, R = qr(A)
+            >>> Q
+            [-0.301511344577764   0.861640436855329   0.408248290463863]
+            [-0.904534033733291  -0.123091490979333  -0.408248290463863]
+            [-0.301511344577764  -0.492365963917331   0.816496580927726]
+            >>> R
+            [-3.3166247903554  -4.52267016866645]
+            [             0.0  0.738548945875996]
+            [             0.0                0.0]
+            >>> Q * R
+            [1.0  2.0]
+            [3.0  4.0]
+            [1.0  1.0]
+            >>> chop(Q.T * Q)
+            [1.0  0.0  0.0]
+            [0.0  1.0  0.0]
+            [0.0  0.0  1.0]
+            >>> B = matrix([[1+0j, 2-3j], [3+j, 4+5j]])
+            >>> Q, R = qr(B)
+            >>> nprint(Q)
+            [     (-0.301511 + 0.0j)   (0.0695795 - 0.95092j)]
+            [(-0.904534 - 0.301511j)  (-0.115966 + 0.278318j)]
+            >>> nprint(R)
+            [(-3.31662 + 0.0j)  (-5.72872 - 2.41209j)]
+            [              0.0       (3.91965 + 0.0j)]
+            >>> Q * R
+            [(1.0 + 0.0j)  (2.0 - 3.0j)]
+            [(3.0 + 1.0j)  (4.0 + 5.0j)]
+            >>> chop(Q.T * Q.conjugate())
+            [1.0  0.0]
+            [0.0  1.0]
+
+        """
+
+        # check values before continuing
+        assert isinstance(A, ctx.matrix)
+        m = A.rows
+        n = A.cols
+        assert n >= 0
+        assert m >= n
+        assert edps >= 0
+
+        # check for complex data type
+        cmplx = any(type(x) is ctx.mpc for x in A)
+
+        # temporarily increase the precision and initialize
+        with ctx.extradps(edps):
+            tau = ctx.matrix(n,1)
+            A = A.copy()
+
+            # ---------------
+            # FACTOR MATRIX A
+            # ---------------
+            if cmplx:
+                one = ctx.mpc('1.0', '0.0')
+                zero = ctx.mpc('0.0', '0.0')
+                rzero = ctx.mpf('0.0')
+
+                # main loop to factor A (complex)
+                for j in xrange(0, n):
+                    alpha = A[j,j]
+                    alphr = ctx.re(alpha)
+                    alphi = ctx.im(alpha)
+
+                    if (m-j) >= 2:
+                        xnorm = ctx.fsum( A[i,j]*ctx.conj(A[i,j]) for i in xrange(j+1, m) )
+                        xnorm = ctx.re( ctx.sqrt(xnorm) )
+                    else:
+                        xnorm = rzero
+
+                    if (xnorm == rzero) and (alphi == rzero):
+                        tau[j] = zero
+                        continue
+
+                    if alphr < rzero:
+                        beta = ctx.sqrt(alphr**2 + alphi**2 + xnorm**2)
+                    else:
+                        beta = -ctx.sqrt(alphr**2 + alphi**2 + xnorm**2)
+
+                    tau[j] = ctx.mpc( (beta - alphr) / beta, -alphi / beta )
+                    t = -ctx.conj(tau[j])
+                    za = one / (alpha - beta)
+
+                    for i in xrange(j+1, m):
+                        A[i,j] *= za
+
+                    A[j,j] = one
+                    for k in xrange(j+1, n):
+                        y = ctx.fsum(A[i,j] * ctx.conj(A[i,k]) for i in xrange(j, m))
+                        temp = t * ctx.conj(y)
+                        for i in xrange(j, m):
+                            A[i,k] += A[i,j] * temp
+
+                    A[j,j] = ctx.mpc(beta, '0.0')
+            else:
+                one = ctx.mpf('1.0')
+                zero = ctx.mpf('0.0')
+
+                # main loop to factor A (real)
+                for j in xrange(0, n):
+                    alpha = A[j,j]
+
+                    if (m-j) > 2:
+                        xnorm = ctx.fsum( (A[i,j])**2 for i in xrange(j+1, m) )
+                        xnorm = ctx.sqrt(xnorm)
+                    elif (m-j) == 2:
+                        xnorm = abs( A[m-1,j] )
+                    else:
+                        xnorm = zero
+
+                    if xnorm == zero:
+                        tau[j] = zero
+                        continue
+
+                    if alpha < zero:
+                        beta = ctx.sqrt(alpha**2 + xnorm**2)
+                    else:
+                        beta = -ctx.sqrt(alpha**2 + xnorm**2)
+
+                    tau[j] = (beta - alpha) / beta
+                    t = -tau[j]
+                    da = one / (alpha - beta)
+
+                    for i in xrange(j+1, m):
+                        A[i,j] *= da
+
+                    A[j,j] = one
+                    for k in xrange(j+1, n):
+                        y = ctx.fsum( A[i,j] * A[i,k] for i in xrange(j, m) )
+                        temp = t * y
+                        for i in xrange(j,m):
+                            A[i,k] += A[i,j] * temp
+
+                    A[j,j] = beta
+
+            # return factorization in same internal format as LAPACK
+            if (mode == 'raw') or (mode == 'RAW'):
+                return A, tau
+
+            # ----------------------------------
+            # FORM Q USING BACKWARD ACCUMULATION
+            # ----------------------------------
+
+            # form R before the values are overwritten
+            R = A.copy()
+            for j in xrange(0, n):
+                for i in xrange(j+1, m):
+                    R[i,j] = zero
+
+            # set the value of p (number of columns of Q to return)
+            p = m
+            if (mode == 'skinny') or (mode == 'SKINNY'):
+                p = n
+
+            # add columns to A if needed and initialize
+            A.cols += (p-n)
+            for j in xrange(0, p):
+                A[j,j] = one
+                for i in xrange(0, j):
+                    A[i,j] = zero
+
+            # main loop to form Q
+            for j in xrange(n-1, -1, -1):
+                t = -tau[j]
+                A[j,j] += t
+
+                for k in xrange(j+1, p):
+                    if cmplx:
+                        y = ctx.fsum(A[i,j] * ctx.conj(A[i,k]) for i in xrange(j+1, m))
+                        temp = t * ctx.conj(y)
+                    else:
+                        y = ctx.fsum(A[i,j] * A[i,k] for i in xrange(j+1, m))
+                        temp = t * y
+                    A[j,k] = temp
+                    for i in xrange(j+1, m):
+                        A[i,k] += A[i,j] * temp
+
+                for i in xrange(j+1, m):
+                    A[i, j] *= t
+
+            return A, R[0:p,0:n]
+
+        # ------------------
+        # END OF FUNCTION QR
+        # ------------------

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

@@ -0,0 +1,1005 @@
+from ..libmp.backend import xrange
+import warnings
+
+# TODO: interpret list as vectors (for multiplication)
+
+rowsep = '\n'
+colsep = '  '
+
+class _matrix(object):
+    """
+    Numerical matrix.
+
+    Specify the dimensions or the data as a nested list.
+    Elements default to zero.
+    Use a flat list to create a column vector easily.
+
+    The datatype of the context (mpf for mp, mpi for iv, and float for fp) is used to store the data.
+
+    Creating matrices
+    -----------------
+
+    Matrices in mpmath are implemented using dictionaries. Only non-zero values
+    are stored, so it is cheap to represent sparse matrices.
+
+    The most basic way to create one is to use the ``matrix`` class directly.
+    You can create an empty matrix specifying the dimensions:
+
+        >>> from mpmath import *
+        >>> mp.dps = 15
+        >>> matrix(2)
+        matrix(
+        [['0.0', '0.0'],
+         ['0.0', '0.0']])
+        >>> matrix(2, 3)
+        matrix(
+        [['0.0', '0.0', '0.0'],
+         ['0.0', '0.0', '0.0']])
+
+    Calling ``matrix`` with one dimension will create a square matrix.
+
+    To access the dimensions of a matrix, use the ``rows`` or ``cols`` keyword:
+
+        >>> A = matrix(3, 2)
+        >>> A
+        matrix(
+        [['0.0', '0.0'],
+         ['0.0', '0.0'],
+         ['0.0', '0.0']])
+        >>> A.rows
+        3
+        >>> A.cols
+        2
+
+    You can also change the dimension of an existing matrix. This will set the
+    new elements to 0. If the new dimension is smaller than before, the
+    concerning elements are discarded:
+
+        >>> A.rows = 2
+        >>> A
+        matrix(
+        [['0.0', '0.0'],
+         ['0.0', '0.0']])
+
+    Internally ``mpmathify`` is used every time an element is set. This
+    is done using the syntax A[row,column], counting from 0:
+
+        >>> A = matrix(2)
+        >>> A[1,1] = 1 + 1j
+        >>> A
+        matrix(
+        [['0.0', '0.0'],
+         ['0.0', mpc(real='1.0', imag='1.0')]])
+
+    A more comfortable way to create a matrix lets you use nested lists:
+
+        >>> matrix([[1, 2], [3, 4]])
+        matrix(
+        [['1.0', '2.0'],
+         ['3.0', '4.0']])
+
+    Convenient advanced functions are available for creating various standard
+    matrices, see ``zeros``, ``ones``, ``diag``, ``eye``, ``randmatrix`` and
+    ``hilbert``.
+
+    Vectors
+    .......
+
+    Vectors may also be represented by the ``matrix`` class (with rows = 1 or cols = 1).
+    For vectors there are some things which make life easier. A column vector can
+    be created using a flat list, a row vectors using an almost flat nested list::
+
+        >>> matrix([1, 2, 3])
+        matrix(
+        [['1.0'],
+         ['2.0'],
+         ['3.0']])
+        >>> matrix([[1, 2, 3]])
+        matrix(
+        [['1.0', '2.0', '3.0']])
+
+    Optionally vectors can be accessed like lists, using only a single index::
+
+        >>> x = matrix([1, 2, 3])
+        >>> x[1]
+        mpf('2.0')
+        >>> x[1,0]
+        mpf('2.0')
+
+    Other
+    .....
+
+    Like you probably expected, matrices can be printed::
+
+        >>> print randmatrix(3) # doctest:+SKIP
+        [ 0.782963853573023  0.802057689719883  0.427895717335467]
+        [0.0541876859348597  0.708243266653103  0.615134039977379]
+        [ 0.856151514955773  0.544759264818486  0.686210904770947]
+
+    Use ``nstr`` or ``nprint`` to specify the number of digits to print::
+
+        >>> nprint(randmatrix(5), 3) # doctest:+SKIP
+        [2.07e-1  1.66e-1  5.06e-1  1.89e-1  8.29e-1]
+        [6.62e-1  6.55e-1  4.47e-1  4.82e-1  2.06e-2]
+        [4.33e-1  7.75e-1  6.93e-2  2.86e-1  5.71e-1]
+        [1.01e-1  2.53e-1  6.13e-1  3.32e-1  2.59e-1]
+        [1.56e-1  7.27e-2  6.05e-1  6.67e-2  2.79e-1]
+
+    As matrices are mutable, you will need to copy them sometimes::
+
+        >>> A = matrix(2)
+        >>> A
+        matrix(
+        [['0.0', '0.0'],
+         ['0.0', '0.0']])
+        >>> B = A.copy()
+        >>> B[0,0] = 1
+        >>> B
+        matrix(
+        [['1.0', '0.0'],
+         ['0.0', '0.0']])
+        >>> A
+        matrix(
+        [['0.0', '0.0'],
+         ['0.0', '0.0']])
+
+    Finally, it is possible to convert a matrix to a nested list. This is very useful,
+    as most Python libraries involving matrices or arrays (namely NumPy or SymPy)
+    support this format::
+
+        >>> B.tolist()
+        [[mpf('1.0'), mpf('0.0')], [mpf('0.0'), mpf('0.0')]]
+
+
+    Matrix operations
+    -----------------
+
+    You can add and subtract matrices of compatible dimensions::
+
+        >>> A = matrix([[1, 2], [3, 4]])
+        >>> B = matrix([[-2, 4], [5, 9]])
+        >>> A + B
+        matrix(
+        [['-1.0', '6.0'],
+         ['8.0', '13.0']])
+        >>> A - B
+        matrix(
+        [['3.0', '-2.0'],
+         ['-2.0', '-5.0']])
+        >>> A + ones(3) # doctest:+ELLIPSIS
+        Traceback (most recent call last):
+          ...
+        ValueError: incompatible dimensions for addition
+
+    It is possible to multiply or add matrices and scalars. In the latter case the
+    operation will be done element-wise::
+
+        >>> A * 2
+        matrix(
+        [['2.0', '4.0'],
+         ['6.0', '8.0']])
+        >>> A / 4
+        matrix(
+        [['0.25', '0.5'],
+         ['0.75', '1.0']])
+        >>> A - 1
+        matrix(
+        [['0.0', '1.0'],
+         ['2.0', '3.0']])
+
+    Of course you can perform matrix multiplication, if the dimensions are
+    compatible, using ``@`` (for Python >= 3.5) or ``*``. For clarity, ``@`` is
+    recommended (`PEP 465 <https://www.python.org/dev/peps/pep-0465/>`), because
+    the meaning of ``*`` is different in many other Python libraries such as NumPy.
+
+        >>> A @ B # doctest:+SKIP
+        matrix(
+        [['8.0', '22.0'],
+         ['14.0', '48.0']])
+        >>> A * B # same as A @ B
+        matrix(
+        [['8.0', '22.0'],
+         ['14.0', '48.0']])
+        >>> matrix([[1, 2, 3]]) * matrix([[-6], [7], [-2]])
+        matrix(
+        [['2.0']])
+
+    ..
+        COMMENT: TODO: the above "doctest:+SKIP" may be removed as soon as we
+        have dropped support for Python 3.5 and below.
+
+    You can raise powers of square matrices::
+
+        >>> A**2
+        matrix(
+        [['7.0', '10.0'],
+         ['15.0', '22.0']])
+
+    Negative powers will calculate the inverse::
+
+        >>> A**-1
+        matrix(
+        [['-2.0', '1.0'],
+         ['1.5', '-0.5']])
+        >>> A * A**-1
+        matrix(
+        [['1.0', '1.0842021724855e-19'],
+         ['-2.16840434497101e-19', '1.0']])
+
+
+
+    Matrix transposition is straightforward::
+
+        >>> A = ones(2, 3)
+        >>> A
+        matrix(
+        [['1.0', '1.0', '1.0'],
+         ['1.0', '1.0', '1.0']])
+        >>> A.T
+        matrix(
+        [['1.0', '1.0'],
+         ['1.0', '1.0'],
+         ['1.0', '1.0']])
+
+    Norms
+    .....
+
+    Sometimes you need to know how "large" a matrix or vector is. Due to their
+    multidimensional nature it's not possible to compare them, but there are
+    several functions to map a matrix or a vector to a positive real number, the
+    so called norms.
+
+    For vectors the p-norm is intended, usually the 1-, the 2- and the oo-norm are
+    used.
+
+        >>> x = matrix([-10, 2, 100])
+        >>> norm(x, 1)
+        mpf('112.0')
+        >>> norm(x, 2)
+        mpf('100.5186549850325')
+        >>> norm(x, inf)
+        mpf('100.0')
+
+    Please note that the 2-norm is the most used one, though it is more expensive
+    to calculate than the 1- or oo-norm.
+
+    It is possible to generalize some vector norms to matrix norm::
+
+        >>> A = matrix([[1, -1000], [100, 50]])
+        >>> mnorm(A, 1)
+        mpf('1050.0')
+        >>> mnorm(A, inf)
+        mpf('1001.0')
+        >>> mnorm(A, 'F')
+        mpf('1006.2310867787777')
+
+    The last norm (the "Frobenius-norm") is an approximation for the 2-norm, which
+    is hard to calculate and not available. The Frobenius-norm lacks some
+    mathematical properties you might expect from a norm.
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.__data = {}
+        # LU decompostion cache, this is useful when solving the same system
+        # multiple times, when calculating the inverse and when calculating the
+        # determinant
+        self._LU = None
+        if "force_type" in kwargs:
+            warnings.warn("The force_type argument was removed, it did not work"
+                " properly anyway. If you want to force floating-point or"
+                " interval computations, use the respective methods from `fp`"
+                " or `mp` instead, e.g., `fp.matrix()` or `iv.matrix()`."
+                " If you want to truncate values to integer, use .apply(int) instead.")
+        if isinstance(args[0], (list, tuple)):
+            if isinstance(args[0][0], (list, tuple)):
+                # interpret nested list as matrix
+                A = args[0]
+                self.__rows = len(A)
+                self.__cols = len(A[0])
+                for i, row in enumerate(A):
+                    for j, a in enumerate(row):
+                        # note: this will call __setitem__ which will call self.ctx.convert() to convert the datatype.
+                        self[i, j] = a
+            else:
+                # interpret list as row vector
+                v = args[0]
+                self.__rows = len(v)
+                self.__cols = 1
+                for i, e in enumerate(v):
+                    self[i, 0] = e
+        elif isinstance(args[0], int):
+            # create empty matrix of given dimensions
+            if len(args) == 1:
+                self.__rows = self.__cols = args[0]
+            else:
+                if not isinstance(args[1], int):
+                    raise TypeError("expected int")
+                self.__rows = args[0]
+                self.__cols = args[1]
+        elif isinstance(args[0], _matrix):
+            A = args[0]
+            self.__rows = A._matrix__rows
+            self.__cols = A._matrix__cols
+            for i in xrange(A.__rows):
+                for j in xrange(A.__cols):
+                    self[i, j] = A[i, j]
+        elif hasattr(args[0], 'tolist'):
+            A = self.ctx.matrix(args[0].tolist())
+            self.__data = A._matrix__data
+            self.__rows = A._matrix__rows
+            self.__cols = A._matrix__cols
+        else:
+            raise TypeError('could not interpret given arguments')
+
+    def apply(self, f):
+        """
+        Return a copy of self with the function `f` applied elementwise.
+        """
+        new = self.ctx.matrix(self.__rows, self.__cols)
+        for i in xrange(self.__rows):
+            for j in xrange(self.__cols):
+                new[i,j] = f(self[i,j])
+        return new
+
+    def __nstr__(self, n=None, **kwargs):
+        # Build table of string representations of the elements
+        res = []
+        # Track per-column max lengths for pretty alignment
+        maxlen = [0] * self.cols
+        for i in range(self.rows):
+            res.append([])
+            for j in range(self.cols):
+                if n:
+                    string = self.ctx.nstr(self[i,j], n, **kwargs)
+                else:
+                    string = str(self[i,j])
+                res[-1].append(string)
+                maxlen[j] = max(len(string), maxlen[j])
+        # Patch strings together
+        for i, row in enumerate(res):
+            for j, elem in enumerate(row):
+                # Pad each element up to maxlen so the columns line up
+                row[j] = elem.rjust(maxlen[j])
+            res[i] = "[" + colsep.join(row) + "]"
+        return rowsep.join(res)
+
+    def __str__(self):
+        return self.__nstr__()
+
+    def _toliststr(self, avoid_type=False):
+        """
+        Create a list string from a matrix.
+
+        If avoid_type: avoid multiple 'mpf's.
+        """
+        # XXX: should be something like self.ctx._types
+        typ = self.ctx.mpf
+        s = '['
+        for i in xrange(self.__rows):
+            s += '['
+            for j in xrange(self.__cols):
+                if not avoid_type or not isinstance(self[i,j], typ):
+                    a = repr(self[i,j])
+                else:
+                    a = "'" + str(self[i,j]) + "'"
+                s += a + ', '
+            s = s[:-2]
+            s += '],\n '
+        s = s[:-3]
+        s += ']'
+        return s
+
+    def tolist(self):
+        """
+        Convert the matrix to a nested list.
+        """
+        return [[self[i,j] for j in range(self.__cols)] for i in range(self.__rows)]
+
+    def __repr__(self):
+        if self.ctx.pretty:
+            return self.__str__()
+        s = 'matrix(\n'
+        s += self._toliststr(avoid_type=True) + ')'
+        return s
+
+    def __get_element(self, key):
+        '''
+        Fast extraction of the i,j element from the matrix
+            This function is for private use only because is unsafe:
+                1. Does not check on the value of key it expects key to be a integer tuple (i,j)
+                2. Does not check bounds
+        '''
+        if key in self.__data:
+            return self.__data[key]
+        else:
+            return self.ctx.zero
+
+    def __set_element(self, key, value):
+        '''
+        Fast assignment of the i,j element in the matrix
+            This function is unsafe:
+                1. Does not check on the value of key it expects key to be a integer tuple (i,j)
+                2. Does not check bounds
+                3. Does not check the value type
+                4. Does not reset the LU cache
+        '''
+        if value: # only store non-zeros
+            self.__data[key] = value
+        elif key in self.__data:
+            del self.__data[key]
+
+
+    def __getitem__(self, key):
+        '''
+            Getitem function for mp matrix class with slice index enabled
+            it allows the following assingments
+            scalar to a slice of the matrix
+         B = A[:,2:6]
+        '''
+        # Convert vector to matrix indexing
+        if isinstance(key, int) or isinstance(key,slice):
+            # only sufficent for vectors
+            if self.__rows == 1:
+                key = (0, key)
+            elif self.__cols == 1:
+                key = (key, 0)
+            else:
+                raise IndexError('insufficient indices for matrix')
+
+        if isinstance(key[0],slice) or isinstance(key[1],slice):
+
+            #Rows
+            if isinstance(key[0],slice):
+                #Check bounds
+                if (key[0].start is None or key[0].start >= 0) and \
+                    (key[0].stop is None or key[0].stop <= self.__rows+1):
+                    # Generate indices
+                    rows = xrange(*key[0].indices(self.__rows))
+                else:
+                    raise IndexError('Row index out of bounds')
+            else:
+                # Single row
+                rows = [key[0]]
+
+            # Columns
+            if isinstance(key[1],slice):
+                # Check bounds
+                if (key[1].start is None or key[1].start >= 0) and \
+                    (key[1].stop is None or key[1].stop <= self.__cols+1):
+                    # Generate indices
+                    columns = xrange(*key[1].indices(self.__cols))
+                else:
+                    raise IndexError('Column index out of bounds')
+
+            else:
+                # Single column
+                columns = [key[1]]
+
+            # Create matrix slice
+            m = self.ctx.matrix(len(rows),len(columns))
+
+            # Assign elements to the output matrix
+            for i,x in enumerate(rows):
+                for j,y in enumerate(columns):
+                    m.__set_element((i,j),self.__get_element((x,y)))
+
+            return m
+
+        else:
+            # single element extraction
+            if key[0] >= self.__rows or key[1] >= self.__cols:
+                raise IndexError('matrix index out of range')
+            if key in self.__data:
+                return self.__data[key]
+            else:
+                return self.ctx.zero
+
+    def __setitem__(self, key, value):
+        # setitem function for mp matrix class with slice index enabled
+        # it allows the following assingments
+        #  scalar to a slice of the matrix
+        # A[:,2:6] = 2.5
+        #  submatrix to matrix (the value matrix should be the same size as the slice size)
+        # A[3,:] = B   where A is n x m  and B is n x 1
+        # Convert vector to matrix indexing
+        if isinstance(key, int) or isinstance(key,slice):
+            # only sufficent for vectors
+            if self.__rows == 1:
+                key = (0, key)
+            elif self.__cols == 1:
+                key = (key, 0)
+            else:
+                raise IndexError('insufficient indices for matrix')
+        # Slice indexing
+        if isinstance(key[0],slice) or isinstance(key[1],slice):
+            # Rows
+            if isinstance(key[0],slice):
+                # Check bounds
+                if (key[0].start is None or key[0].start >= 0) and \
+                    (key[0].stop is None or key[0].stop <= self.__rows+1):
+                    # generate row indices
+                    rows = xrange(*key[0].indices(self.__rows))
+                else:
+                    raise IndexError('Row index out of bounds')
+            else:
+                # Single row
+                rows = [key[0]]
+            # Columns
+            if isinstance(key[1],slice):
+                # Check bounds
+                if (key[1].start is None or key[1].start >= 0) and \
+                    (key[1].stop is None or key[1].stop <= self.__cols+1):
+                    # Generate column indices
+                    columns = xrange(*key[1].indices(self.__cols))
+                else:
+                    raise IndexError('Column index out of bounds')
+            else:
+                # Single column
+                columns = [key[1]]
+            # Assign slice with a scalar
+            if isinstance(value,self.ctx.matrix):
+                # Assign elements to matrix if input and output dimensions match
+                if len(rows) == value.rows and len(columns) == value.cols:
+                    for i,x in enumerate(rows):
+                        for j,y in enumerate(columns):
+                            self.__set_element((x,y), value.__get_element((i,j)))
+                else:
+                    raise ValueError('Dimensions do not match')
+            else:
+                # Assign slice with scalars
+                value = self.ctx.convert(value)
+                for i in rows:
+                    for j in columns:
+                        self.__set_element((i,j), value)
+        else:
+            # Single element assingment
+            # Check bounds
+            if key[0] >= self.__rows or key[1] >= self.__cols:
+                raise IndexError('matrix index out of range')
+            # Convert and store value
+            value = self.ctx.convert(value)
+            if value: # only store non-zeros
+                self.__data[key] = value
+            elif key in self.__data:
+                del self.__data[key]
+
+        if self._LU:
+            self._LU = None
+        return
+
+    def __iter__(self):
+        for i in xrange(self.__rows):
+            for j in xrange(self.__cols):
+                yield self[i,j]
+
+    def __mul__(self, other):
+        if isinstance(other, self.ctx.matrix):
+            # dot multiplication
+            if self.__cols != other.__rows:
+                raise ValueError('dimensions not compatible for multiplication')
+            new = self.ctx.matrix(self.__rows, other.__cols)
+            self_zero = self.ctx.zero
+            self_get = self.__data.get
+            other_zero = other.ctx.zero
+            other_get = other.__data.get
+            for i in xrange(self.__rows):
+                for j in xrange(other.__cols):
+                    new[i, j] = self.ctx.fdot((self_get((i,k), self_zero), other_get((k,j), other_zero))
+                                     for k in xrange(other.__rows))
+            return new
+        else:
+            # try scalar multiplication
+            new = self.ctx.matrix(self.__rows, self.__cols)
+            for i in xrange(self.__rows):
+                for j in xrange(self.__cols):
+                    new[i, j] = other * self[i, j]
+            return new
+
+    def __matmul__(self, other):
+        return self.__mul__(other)
+
+    def __rmul__(self, other):
+        # assume other is scalar and thus commutative
+        if isinstance(other, self.ctx.matrix):
+            raise TypeError("other should not be type of ctx.matrix")
+        return self.__mul__(other)
+
+    def __pow__(self, other):
+        # avoid cyclic import problems
+        #from linalg import inverse
+        if not isinstance(other, int):
+            raise ValueError('only integer exponents are supported')
+        if not self.__rows == self.__cols:
+            raise ValueError('only powers of square matrices are defined')
+        n = other
+        if n == 0:
+            return self.ctx.eye(self.__rows)
+        if n < 0:
+            n = -n
+            neg = True
+        else:
+            neg = False
+        i = n
+        y = 1
+        z = self.copy()
+        while i != 0:
+            if i % 2 == 1:
+                y = y * z
+            z = z*z
+            i = i // 2
+        if neg:
+            y = self.ctx.inverse(y)
+        return y
+
+    def __div__(self, other):
+        # assume other is scalar and do element-wise divison
+        assert not isinstance(other, self.ctx.matrix)
+        new = self.ctx.matrix(self.__rows, self.__cols)
+        for i in xrange(self.__rows):
+            for j in xrange(self.__cols):
+                new[i,j] = self[i,j] / other
+        return new
+
+    __truediv__ = __div__
+
+    def __add__(self, other):
+        if isinstance(other, self.ctx.matrix):
+            if not (self.__rows == other.__rows and self.__cols == other.__cols):
+                raise ValueError('incompatible dimensions for addition')
+            new = self.ctx.matrix(self.__rows, self.__cols)
+            for i in xrange(self.__rows):
+                for j in xrange(self.__cols):
+                    new[i,j] = self[i,j] + other[i,j]
+            return new
+        else:
+            # assume other is scalar and add element-wise
+            new = self.ctx.matrix(self.__rows, self.__cols)
+            for i in xrange(self.__rows):
+                for j in xrange(self.__cols):
+                    new[i,j] += self[i,j] + other
+            return new
+
+    def __radd__(self, other):
+        return self.__add__(other)
+
+    def __sub__(self, other):
+        if isinstance(other, self.ctx.matrix) and not (self.__rows == other.__rows
+                                              and self.__cols == other.__cols):
+            raise ValueError('incompatible dimensions for subtraction')
+        return self.__add__(other * (-1))
+
+    def __pos__(self):
+        """
+        +M returns a copy of M, rounded to current working precision.
+        """
+        return (+1) * self
+
+    def __neg__(self):
+        return (-1) * self
+
+    def __rsub__(self, other):
+        return -self + other
+
+    def __eq__(self, other):
+        return self.__rows == other.__rows and self.__cols == other.__cols \
+               and self.__data == other.__data
+
+    def __len__(self):
+        if self.rows == 1:
+            return self.cols
+        elif self.cols == 1:
+            return self.rows
+        else:
+            return self.rows # do it like numpy
+
+    def __getrows(self):
+        return self.__rows
+
+    def __setrows(self, value):
+        for key in self.__data.copy():
+            if key[0] >= value:
+                del self.__data[key]
+        self.__rows = value
+
+    rows = property(__getrows, __setrows, doc='number of rows')
+
+    def __getcols(self):
+        return self.__cols
+
+    def __setcols(self, value):
+        for key in self.__data.copy():
+            if key[1] >= value:
+                del self.__data[key]
+        self.__cols = value
+
+    cols = property(__getcols, __setcols, doc='number of columns')
+
+    def transpose(self):
+        new = self.ctx.matrix(self.__cols, self.__rows)
+        for i in xrange(self.__rows):
+            for j in xrange(self.__cols):
+                new[j,i] = self[i,j]
+        return new
+
+    T = property(transpose)
+
+    def conjugate(self):
+        return self.apply(self.ctx.conj)
+
+    def transpose_conj(self):
+        return self.conjugate().transpose()
+
+    H = property(transpose_conj)
+
+    def copy(self):
+        new = self.ctx.matrix(self.__rows, self.__cols)
+        new.__data = self.__data.copy()
+        return new
+
+    __copy__ = copy
+
+    def column(self, n):
+        m = self.ctx.matrix(self.rows, 1)
+        for i in range(self.rows):
+            m[i] = self[i,n]
+        return m
+
+class MatrixMethods(object):
+
+    def __init__(ctx):
+        # XXX: subclass
+        ctx.matrix = type('matrix', (_matrix,), {})
+        ctx.matrix.ctx = ctx
+        ctx.matrix.convert = ctx.convert
+
+    def eye(ctx, n, **kwargs):
+        """
+        Create square identity matrix n x n.
+        """
+        A = ctx.matrix(n, **kwargs)
+        for i in xrange(n):
+            A[i,i] = 1
+        return A
+
+    def diag(ctx, diagonal, **kwargs):
+        """
+        Create square diagonal matrix using given list.
+
+        Example:
+        >>> from mpmath import diag, mp
+        >>> mp.pretty = False
+        >>> diag([1, 2, 3])
+        matrix(
+        [['1.0', '0.0', '0.0'],
+         ['0.0', '2.0', '0.0'],
+         ['0.0', '0.0', '3.0']])
+        """
+        A = ctx.matrix(len(diagonal), **kwargs)
+        for i in xrange(len(diagonal)):
+            A[i,i] = diagonal[i]
+        return A
+
+    def zeros(ctx, *args, **kwargs):
+        """
+        Create matrix m x n filled with zeros.
+        One given dimension will create square matrix n x n.
+
+        Example:
+        >>> from mpmath import zeros, mp
+        >>> mp.pretty = False
+        >>> zeros(2)
+        matrix(
+        [['0.0', '0.0'],
+         ['0.0', '0.0']])
+        """
+        if len(args) == 1:
+            m = n = args[0]
+        elif len(args) == 2:
+            m = args[0]
+            n = args[1]
+        else:
+            raise TypeError('zeros expected at most 2 arguments, got %i' % len(args))
+        A = ctx.matrix(m, n, **kwargs)
+        for i in xrange(m):
+            for j in xrange(n):
+                A[i,j] = 0
+        return A
+
+    def ones(ctx, *args, **kwargs):
+        """
+        Create matrix m x n filled with ones.
+        One given dimension will create square matrix n x n.
+
+        Example:
+        >>> from mpmath import ones, mp
+        >>> mp.pretty = False
+        >>> ones(2)
+        matrix(
+        [['1.0', '1.0'],
+         ['1.0', '1.0']])
+        """
+        if len(args) == 1:
+            m = n = args[0]
+        elif len(args) == 2:
+            m = args[0]
+            n = args[1]
+        else:
+            raise TypeError('ones expected at most 2 arguments, got %i' % len(args))
+        A = ctx.matrix(m, n, **kwargs)
+        for i in xrange(m):
+            for j in xrange(n):
+                A[i,j] = 1
+        return A
+
+    def hilbert(ctx, m, n=None):
+        """
+        Create (pseudo) hilbert matrix m x n.
+        One given dimension will create hilbert matrix n x n.
+
+        The matrix is very ill-conditioned and symmetric, positive definite if
+        square.
+        """
+        if n is None:
+            n = m
+        A = ctx.matrix(m, n)
+        for i in xrange(m):
+            for j in xrange(n):
+                A[i,j] = ctx.one / (i + j + 1)
+        return A
+
+    def randmatrix(ctx, m, n=None, min=0, max=1, **kwargs):
+        """
+        Create a random m x n matrix.
+
+        All values are >= min and <max.
+        n defaults to m.
+
+        Example:
+        >>> from mpmath import randmatrix
+        >>> randmatrix(2) # doctest:+SKIP
+        matrix(
+        [['0.53491598236191806', '0.57195669543302752'],
+         ['0.85589992269513615', '0.82444367501382143']])
+        """
+        if not n:
+            n = m
+        A = ctx.matrix(m, n, **kwargs)
+        for i in xrange(m):
+            for j in xrange(n):
+                A[i,j] = ctx.rand() * (max - min) + min
+        return A
+
+    def swap_row(ctx, A, i, j):
+        """
+        Swap row i with row j.
+        """
+        if i == j:
+            return
+        if isinstance(A, ctx.matrix):
+            for k in xrange(A.cols):
+                A[i,k], A[j,k] = A[j,k], A[i,k]
+        elif isinstance(A, list):
+            A[i], A[j] = A[j], A[i]
+        else:
+            raise TypeError('could not interpret type')
+
+    def extend(ctx, A, b):
+        """
+        Extend matrix A with column b and return result.
+        """
+        if not isinstance(A, ctx.matrix):
+            raise TypeError("A should be a type of ctx.matrix")
+        if A.rows != len(b):
+            raise ValueError("Value should be equal to len(b)")
+        A = A.copy()
+        A.cols += 1
+        for i in xrange(A.rows):
+            A[i, A.cols-1] = b[i]
+        return A
+
+    def norm(ctx, x, p=2):
+        r"""
+        Gives the entrywise `p`-norm of an iterable *x*, i.e. the vector norm
+        `\left(\sum_k |x_k|^p\right)^{1/p}`, for any given `1 \le p \le \infty`.
+
+        Special cases:
+
+        If *x* is not iterable, this just returns ``absmax(x)``.
+
+        ``p=1`` gives the sum of absolute values.
+
+        ``p=2`` is the standard Euclidean vector norm.
+
+        ``p=inf`` gives the magnitude of the largest element.
+
+        For *x* a matrix, ``p=2`` is the Frobenius norm.
+        For operator matrix norms, use :func:`~mpmath.mnorm` instead.
+
+        You can use the string 'inf' as well as float('inf') or mpf('inf')
+        to specify the infinity norm.
+
+        **Examples**
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> x = matrix([-10, 2, 100])
+            >>> norm(x, 1)
+            mpf('112.0')
+            >>> norm(x, 2)
+            mpf('100.5186549850325')
+            >>> norm(x, inf)
+            mpf('100.0')
+
+        """
+        try:
+            iter(x)
+        except TypeError:
+            return ctx.absmax(x)
+        if type(p) is not int:
+            p = ctx.convert(p)
+        if p == ctx.inf:
+            return max(ctx.absmax(i) for i in x)
+        elif p == 1:
+            return ctx.fsum(x, absolute=1)
+        elif p == 2:
+            return ctx.sqrt(ctx.fsum(x, absolute=1, squared=1))
+        elif p > 1:
+            return ctx.nthroot(ctx.fsum(abs(i)**p for i in x), p)
+        else:
+            raise ValueError('p has to be >= 1')
+
+    def mnorm(ctx, A, p=1):
+        r"""
+        Gives the matrix (operator) `p`-norm of A. Currently ``p=1`` and ``p=inf``
+        are supported:
+
+        ``p=1`` gives the 1-norm (maximal column sum)
+
+        ``p=inf`` gives the `\infty`-norm (maximal row sum).
+        You can use the string 'inf' as well as float('inf') or mpf('inf')
+
+        ``p=2`` (not implemented) for a square matrix is the usual spectral
+        matrix norm, i.e. the largest singular value.
+
+        ``p='f'`` (or 'F', 'fro', 'Frobenius, 'frobenius') gives the
+        Frobenius norm, which is the elementwise 2-norm. The Frobenius norm is an
+        approximation of the spectral norm and satisfies
+
+        .. math ::
+
+            \frac{1}{\sqrt{\mathrm{rank}(A)}} \|A\|_F \le \|A\|_2 \le \|A\|_F
+
+        The Frobenius norm lacks some mathematical properties that might
+        be expected of a norm.
+
+        For general elementwise `p`-norms, use :func:`~mpmath.norm` instead.
+
+        **Examples**
+
+            >>> from mpmath import *
+            >>> mp.dps = 15; mp.pretty = False
+            >>> A = matrix([[1, -1000], [100, 50]])
+            >>> mnorm(A, 1)
+            mpf('1050.0')
+            >>> mnorm(A, inf)
+            mpf('1001.0')
+            >>> mnorm(A, 'F')
+            mpf('1006.2310867787777')
+
+        """
+        A = ctx.matrix(A)
+        if type(p) is not int:
+            if type(p) is str and 'frobenius'.startswith(p.lower()):
+                return ctx.norm(A, 2)
+            p = ctx.convert(p)
+        m, n = A.rows, A.cols
+        if p == 1:
+            return max(ctx.fsum((A[i,j] for i in xrange(m)), absolute=1) for j in xrange(n))
+        elif p == ctx.inf:
+            return max(ctx.fsum((A[i,j] for j in xrange(n)), absolute=1) for i in xrange(m))
+        else:
+            raise NotImplementedError("matrix p-norm for arbitrary p")
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()

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

@@ -0,0 +1,313 @@
+"""
+Plotting (requires matplotlib)
+"""
+
+from colorsys import hsv_to_rgb, hls_to_rgb
+from .libmp import NoConvergence
+from .libmp.backend import xrange
+
+class VisualizationMethods(object):
+    plot_ignore = (ValueError, ArithmeticError, ZeroDivisionError, NoConvergence)
+
+def plot(ctx, f, xlim=[-5,5], ylim=None, points=200, file=None, dpi=None,
+    singularities=[], axes=None):
+    r"""
+    Shows a simple 2D plot of a function `f(x)` or list of functions
+    `[f_0(x), f_1(x), \ldots, f_n(x)]` over a given interval
+    specified by *xlim*. Some examples::
+
+        plot(lambda x: exp(x)*li(x), [1, 4])
+        plot([cos, sin], [-4, 4])
+        plot([fresnels, fresnelc], [-4, 4])
+        plot([sqrt, cbrt], [-4, 4])
+        plot(lambda t: zeta(0.5+t*j), [-20, 20])
+        plot([floor, ceil, abs, sign], [-5, 5])
+
+    Points where the function raises a numerical exception or
+    returns an infinite value are removed from the graph.
+    Singularities can also be excluded explicitly
+    as follows (useful for removing erroneous vertical lines)::
+
+        plot(cot, ylim=[-5, 5])   # bad
+        plot(cot, ylim=[-5, 5], singularities=[-pi, 0, pi])  # good
+
+    For parts where the function assumes complex values, the
+    real part is plotted with dashes and the imaginary part
+    is plotted with dots.
+
+    .. note :: This function requires matplotlib (pylab).
+    """
+    if file:
+        axes = None
+    fig = None
+    if not axes:
+        import pylab
+        fig = pylab.figure()
+        axes = fig.add_subplot(111)
+    if not isinstance(f, (tuple, list)):
+        f = [f]
+    a, b = xlim
+    colors = ['b', 'r', 'g', 'm', 'k']
+    for n, func in enumerate(f):
+        x = ctx.arange(a, b, (b-a)/float(points))
+        segments = []
+        segment = []
+        in_complex = False
+        for i in xrange(len(x)):
+            try:
+                if i != 0:
+                    for sing in singularities:
+                        if x[i-1] <= sing and x[i] >= sing:
+                            raise ValueError
+                v = func(x[i])
+                if ctx.isnan(v) or abs(v) > 1e300:
+                    raise ValueError
+                if hasattr(v, "imag") and v.imag:
+                    re = float(v.real)
+                    im = float(v.imag)
+                    if not in_complex:
+                        in_complex = True
+                        segments.append(segment)
+                        segment = []
+                    segment.append((float(x[i]), re, im))
+                else:
+                    if in_complex:
+                        in_complex = False
+                        segments.append(segment)
+                        segment = []
+                    if hasattr(v, "real"):
+                        v = v.real
+                    segment.append((float(x[i]), v))
+            except ctx.plot_ignore:
+                if segment:
+                    segments.append(segment)
+                segment = []
+        if segment:
+            segments.append(segment)
+        for segment in segments:
+            x = [s[0] for s in segment]
+            y = [s[1] for s in segment]
+            if not x:
+                continue
+            c = colors[n % len(colors)]
+            if len(segment[0]) == 3:
+                z = [s[2] for s in segment]
+                axes.plot(x, y, '--'+c, linewidth=3)
+                axes.plot(x, z, ':'+c, linewidth=3)
+            else:
+                axes.plot(x, y, c, linewidth=3)
+    axes.set_xlim([float(_) for _ in xlim])
+    if ylim:
+        axes.set_ylim([float(_) for _ in ylim])
+    axes.set_xlabel('x')
+    axes.set_ylabel('f(x)')
+    axes.grid(True)
+    if fig:
+        if file:
+            pylab.savefig(file, dpi=dpi)
+        else:
+            pylab.show()
+
+def default_color_function(ctx, z):
+    if ctx.isinf(z):
+        return (1.0, 1.0, 1.0)
+    if ctx.isnan(z):
+        return (0.5, 0.5, 0.5)
+    pi = 3.1415926535898
+    a = (float(ctx.arg(z)) + ctx.pi) / (2*ctx.pi)
+    a = (a + 0.5) % 1.0
+    b = 1.0 - float(1/(1.0+abs(z)**0.3))
+    return hls_to_rgb(a, b, 0.8)
+
+blue_orange_colors = [
+  (-1.0,  (0.0, 0.0, 0.0)),
+  (-0.95, (0.1, 0.2, 0.5)),   # dark blue
+  (-0.5,  (0.0, 0.5, 1.0)),   # blueish
+  (-0.05, (0.4, 0.8, 0.8)),   # cyanish
+  ( 0.0,  (1.0, 1.0, 1.0)),
+  ( 0.05, (1.0, 0.9, 0.3)),   # yellowish
+  ( 0.5,  (0.9, 0.5, 0.0)),   # orangeish
+  ( 0.95, (0.7, 0.1, 0.0)),   # redish
+  ( 1.0,  (0.0, 0.0, 0.0)),
+  ( 2.0,  (0.0, 0.0, 0.0)),
+]
+
+def phase_color_function(ctx, z):
+    if ctx.isinf(z):
+        return (1.0, 1.0, 1.0)
+    if ctx.isnan(z):
+        return (0.5, 0.5, 0.5)
+    pi = 3.1415926535898
+    w = float(ctx.arg(z)) / pi
+    w = max(min(w, 1.0), -1.0)
+    for i in range(1,len(blue_orange_colors)):
+        if blue_orange_colors[i][0] > w:
+            a, (ra, ga, ba) = blue_orange_colors[i-1]
+            b, (rb, gb, bb) = blue_orange_colors[i]
+            s = (w-a) / (b-a)
+            return ra+(rb-ra)*s, ga+(gb-ga)*s, ba+(bb-ba)*s
+
+def cplot(ctx, f, re=[-5,5], im=[-5,5], points=2000, color=None,
+    verbose=False, file=None, dpi=None, axes=None):
+    """
+    Plots the given complex-valued function *f* over a rectangular part
+    of the complex plane specified by the pairs of intervals *re* and *im*.
+    For example::
+
+        cplot(lambda z: z, [-2, 2], [-10, 10])
+        cplot(exp)
+        cplot(zeta, [0, 1], [0, 50])
+
+    By default, the complex argument (phase) is shown as color (hue) and
+    the magnitude is show as brightness. You can also supply a
+    custom color function (*color*). This function should take a
+    complex number as input and return an RGB 3-tuple containing
+    floats in the range 0.0-1.0.
+
+    Alternatively, you can select a builtin color function by passing
+    a string as *color*:
+
+      * "default" - default color scheme
+      * "phase" - a color scheme that only renders the phase of the function,
+         with white for positive reals, black for negative reals, gold in the
+         upper half plane, and blue in the lower half plane.
+
+    To obtain a sharp image, the number of points may need to be
+    increased to 100,000 or thereabout. Since evaluating the
+    function that many times is likely to be slow, the 'verbose'
+    option is useful to display progress.
+
+    .. note :: This function requires matplotlib (pylab).
+    """
+    if color is None or color == "default":
+        color = ctx.default_color_function
+    if color == "phase":
+        color = ctx.phase_color_function
+    import pylab
+    if file:
+        axes = None
+    fig = None
+    if not axes:
+        fig = pylab.figure()
+        axes = fig.add_subplot(111)
+    rea, reb = re
+    ima, imb = im
+    dre = reb - rea
+    dim = imb - ima
+    M = int(ctx.sqrt(points*dre/dim)+1)
+    N = int(ctx.sqrt(points*dim/dre)+1)
+    x = pylab.linspace(rea, reb, M)
+    y = pylab.linspace(ima, imb, N)
+    # Note: we have to be careful to get the right rotation.
+    # Test with these plots:
+    #   cplot(lambda z: z if z.real < 0 else 0)
+    #   cplot(lambda z: z if z.imag < 0 else 0)
+    w = pylab.zeros((N, M, 3))
+    for n in xrange(N):
+        for m in xrange(M):
+            z = ctx.mpc(x[m], y[n])
+            try:
+                v = color(f(z))
+            except ctx.plot_ignore:
+                v = (0.5, 0.5, 0.5)
+            w[n,m] = v
+        if verbose:
+            print(str(n) + ' of ' + str(N))
+    rea, reb, ima, imb = [float(_) for _ in [rea, reb, ima, imb]]
+    axes.imshow(w, extent=(rea, reb, ima, imb), origin='lower')
+    axes.set_xlabel('Re(z)')
+    axes.set_ylabel('Im(z)')
+    if fig:
+        if file:
+            pylab.savefig(file, dpi=dpi)
+        else:
+            pylab.show()
+
+def splot(ctx, f, u=[-5,5], v=[-5,5], points=100, keep_aspect=True, \
+          wireframe=False, file=None, dpi=None, axes=None):
+    """
+    Plots the surface defined by `f`.
+
+    If `f` returns a single component, then this plots the surface
+    defined by `z = f(x,y)` over the rectangular domain with
+    `x = u` and `y = v`.
+
+    If `f` returns three components, then this plots the parametric
+    surface `x, y, z = f(u,v)` over the pairs of intervals `u` and `v`.
+
+    For example, to plot a simple function::
+
+        >>> from mpmath import *
+        >>> f = lambda x, y: sin(x+y)*cos(y)
+        >>> splot(f, [-pi,pi], [-pi,pi])    # doctest: +SKIP
+
+    Plotting a donut::
+
+        >>> r, R = 1, 2.5
+        >>> f = lambda u, v: [r*cos(u), (R+r*sin(u))*cos(v), (R+r*sin(u))*sin(v)]
+        >>> splot(f, [0, 2*pi], [0, 2*pi])    # doctest: +SKIP
+
+    .. note :: This function requires matplotlib (pylab) 0.98.5.3 or higher.
+    """
+    import pylab
+    import mpl_toolkits.mplot3d as mplot3d
+    if file:
+        axes = None
+    fig = None
+    if not axes:
+        fig = pylab.figure()
+        axes = mplot3d.axes3d.Axes3D(fig)
+    ua, ub = u
+    va, vb = v
+    du = ub - ua
+    dv = vb - va
+    if not isinstance(points, (list, tuple)):
+        points = [points, points]
+    M, N = points
+    u = pylab.linspace(ua, ub, M)
+    v = pylab.linspace(va, vb, N)
+    x, y, z = [pylab.zeros((M, N)) for i in xrange(3)]
+    xab, yab, zab = [[0, 0] for i in xrange(3)]
+    for n in xrange(N):
+        for m in xrange(M):
+            fdata = f(ctx.convert(u[m]), ctx.convert(v[n]))
+            try:
+                x[m,n], y[m,n], z[m,n] = fdata
+            except TypeError:
+                x[m,n], y[m,n], z[m,n] = u[m], v[n], fdata
+            for c, cab in [(x[m,n], xab), (y[m,n], yab), (z[m,n], zab)]:
+                if c < cab[0]:
+                    cab[0] = c
+                if c > cab[1]:
+                    cab[1] = c
+    if wireframe:
+        axes.plot_wireframe(x, y, z, rstride=4, cstride=4)
+    else:
+        axes.plot_surface(x, y, z, rstride=4, cstride=4)
+    axes.set_xlabel('x')
+    axes.set_ylabel('y')
+    axes.set_zlabel('z')
+    if keep_aspect:
+        dx, dy, dz = [cab[1] - cab[0] for cab in [xab, yab, zab]]
+        maxd = max(dx, dy, dz)
+        if dx < maxd:
+            delta = maxd - dx
+            axes.set_xlim3d(xab[0] - delta / 2.0, xab[1] + delta / 2.0)
+        if dy < maxd:
+            delta = maxd - dy
+            axes.set_ylim3d(yab[0] - delta / 2.0, yab[1] + delta / 2.0)
+        if dz < maxd:
+            delta = maxd - dz
+            axes.set_zlim3d(zab[0] - delta / 2.0, zab[1] + delta / 2.0)
+    if fig:
+        if file:
+            pylab.savefig(file, dpi=dpi)
+        else:
+            pylab.show()
+
+
+VisualizationMethods.plot = plot
+VisualizationMethods.default_color_function = default_color_function
+VisualizationMethods.phase_color_function = phase_color_function
+VisualizationMethods.cplot = cplot
+VisualizationMethods.splot = splot

env-llmeval/lib/python3.10/site-packages/psutil-5.9.8.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

env-llmeval/lib/python3.10/site-packages/psutil-5.9.8.dist-info/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2009, Jay Loden, Dave Daeschler, Giampaolo Rodola
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+ * Neither the name of the psutil authors nor the names of its contributors
+   may be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

env-llmeval/lib/python3.10/site-packages/psutil-5.9.8.dist-info/METADATA

@@ -0,0 +1,530 @@
+Metadata-Version: 2.1
+Name: psutil
+Version: 5.9.8
+Summary: Cross-platform lib for process and system monitoring in Python.
+Home-page: https://github.com/giampaolo/psutil
+Author: Giampaolo Rodola
+Author-email: [email protected]
+License: BSD-3-Clause
+Keywords: ps,top,kill,free,lsof,netstat,nice,tty,ionice,uptime,taskmgr,process,df,iotop,iostat,ifconfig,taskset,who,pidof,pmap,smem,pstree,monitoring,ulimit,prlimit,smem,performance,metrics,agent,observability
+Platform: Platform Independent
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows :: Windows 10
+Classifier: Operating System :: Microsoft :: Windows :: Windows 7
+Classifier: Operating System :: Microsoft :: Windows :: Windows 8
+Classifier: Operating System :: Microsoft :: Windows :: Windows 8.1
+Classifier: Operating System :: Microsoft :: Windows :: Windows Server 2003
+Classifier: Operating System :: Microsoft :: Windows :: Windows Server 2008
+Classifier: Operating System :: Microsoft :: Windows :: Windows Vista
+Classifier: Operating System :: Microsoft
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX :: AIX
+Classifier: Operating System :: POSIX :: BSD :: FreeBSD
+Classifier: Operating System :: POSIX :: BSD :: NetBSD
+Classifier: Operating System :: POSIX :: BSD :: OpenBSD
+Classifier: Operating System :: POSIX :: BSD
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: POSIX :: SunOS/Solaris
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System :: Benchmark
+Classifier: Topic :: System :: Hardware :: Hardware Drivers
+Classifier: Topic :: System :: Hardware
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: System :: Networking :: Monitoring :: Hardware Watchdog
+Classifier: Topic :: System :: Networking :: Monitoring
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: System :: Operating System
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Utilities
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: ipaddress ; (python_version < "3.0") and extra == 'test'
+Requires-Dist: mock ; (python_version < "3.0") and extra == 'test'
+Requires-Dist: enum34 ; (python_version <= "3.4") and extra == 'test'
+Requires-Dist: pywin32 ; (sys_platform == "win32") and extra == 'test'
+Requires-Dist: wmi ; (sys_platform == "win32") and extra == 'test'
+
+|  |downloads| |stars| |forks| |contributors| |coverage|
+|  |version| |py-versions| |packages| |license|
+|  |github-actions-wheels|  |github-actions-bsd| |appveyor| |doc| |twitter| |tidelift|
+
+.. |downloads| image:: https://img.shields.io/pypi/dm/psutil.svg
+    :target: https://pepy.tech/project/psutil
+    :alt: Downloads
+
+.. |stars| image:: https://img.shields.io/github/stars/giampaolo/psutil.svg
+    :target: https://github.com/giampaolo/psutil/stargazers
+    :alt: Github stars
+
+.. |forks| image:: https://img.shields.io/github/forks/giampaolo/psutil.svg
+    :target: https://github.com/giampaolo/psutil/network/members
+    :alt: Github forks
+
+.. |contributors| image:: https://img.shields.io/github/contributors/giampaolo/psutil.svg
+    :target: https://github.com/giampaolo/psutil/graphs/contributors
+    :alt: Contributors
+
+.. |github-actions-wheels| image:: https://img.shields.io/github/actions/workflow/status/giampaolo/psutil/.github/workflows/build.yml?label=Linux%2C%20macOS%2C%20Windows
+    :target: https://github.com/giampaolo/psutil/actions?query=workflow%3Abuild
+    :alt: Linux, macOS, Windows
+
+.. |github-actions-bsd| image:: https://img.shields.io/github/actions/workflow/status/giampaolo/psutil/.github/workflows/bsd.yml?label=FreeBSD,%20NetBSD,%20OpenBSD
+    :target: https://github.com/giampaolo/psutil/actions?query=workflow%3Absd-tests
+    :alt: FreeBSD, NetBSD, OpenBSD
+
+.. |appveyor| image:: https://img.shields.io/appveyor/build/giampaolo/psutil/master.svg?maxAge=3600&label=Windows%20(py2)
+    :target: https://ci.appveyor.com/project/giampaolo/psutil
+    :alt: Windows (Appveyor)
+
+.. |coverage| image:: https://coveralls.io/repos/github/giampaolo/psutil/badge.svg?branch=master
+    :target: https://coveralls.io/github/giampaolo/psutil?branch=master
+    :alt: Test coverage (coverall.io)
+
+.. |doc| image:: https://readthedocs.org/projects/psutil/badge/?version=latest
+    :target: https://psutil.readthedocs.io/en/latest/
+    :alt: Documentation Status
+
+.. |version| image:: https://img.shields.io/pypi/v/psutil.svg?label=pypi
+    :target: https://pypi.org/project/psutil
+    :alt: Latest version
+
+.. |py-versions| image:: https://img.shields.io/pypi/pyversions/psutil.svg
+    :alt: Supported Python versions
+
+.. |packages| image:: https://repology.org/badge/tiny-repos/python:psutil.svg
+    :target: https://repology.org/metapackage/python:psutil/versions
+    :alt: Binary packages
+
+.. |license| image:: https://img.shields.io/pypi/l/psutil.svg
+    :target: https://github.com/giampaolo/psutil/blob/master/LICENSE
+    :alt: License
+
+.. |twitter| image:: https://img.shields.io/twitter/follow/grodola.svg?label=follow&style=flat&logo=twitter&logoColor=4FADFF
+    :target: https://twitter.com/grodola
+    :alt: Twitter Follow
+
+.. |tidelift| image:: https://tidelift.com/badges/github/giampaolo/psutil?style=flat
+    :target: https://tidelift.com/subscription/pkg/pypi-psutil?utm_source=pypi-psutil&utm_medium=referral&utm_campaign=readme
+    :alt: Tidelift
+
+-----
+
+Quick links
+===========
+
+- `Home page <https://github.com/giampaolo/psutil>`_
+- `Install <https://github.com/giampaolo/psutil/blob/master/INSTALL.rst>`_
+- `Documentation <http://psutil.readthedocs.io>`_
+- `Download <https://pypi.org/project/psutil/#files>`_
+- `Forum <http://groups.google.com/group/psutil/topics>`_
+- `StackOverflow <https://stackoverflow.com/questions/tagged/psutil>`_
+- `Blog <https://gmpy.dev/tags/psutil>`_
+- `What's new <https://github.com/giampaolo/psutil/blob/master/HISTORY.rst>`_
+
+
+Summary
+=======
+
+psutil (process and system utilities) is a cross-platform library for
+retrieving information on **running processes** and **system utilization**
+(CPU, memory, disks, network, sensors) in Python.
+It is useful mainly for **system monitoring**, **profiling and limiting process
+resources** and **management of running processes**.
+It implements many functionalities offered by classic UNIX command line tools
+such as *ps, top, iotop, lsof, netstat, ifconfig, free* and others.
+psutil currently supports the following platforms:
+
+- **Linux**
+- **Windows**
+- **macOS**
+- **FreeBSD, OpenBSD**, **NetBSD**
+- **Sun Solaris**
+- **AIX**
+
+Supported Python versions are **2.7**, **3.6+** and
+`PyPy <http://pypy.org/>`__.
+
+Funding
+=======
+
+While psutil is free software and will always be, the project would benefit
+immensely from some funding.
+Keeping up with bug reports and maintenance has become hardly sustainable for
+me alone in terms of time.
+If you're a company that's making significant use of psutil you can consider
+becoming a sponsor via `GitHub Sponsors <https://github.com/sponsors/giampaolo>`__,
+`Open Collective <https://opencollective.com/psutil>`__ or
+`PayPal <https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=A9ZS7PKKRM3S8>`__
+and have your logo displayed in here and psutil `doc <https://psutil.readthedocs.io>`__.
+
+Sponsors
+========
+
+.. image:: https://github.com/giampaolo/psutil/raw/master/docs/_static/tidelift-logo.png
+  :width: 200
+  :alt: Alternative text
+
+`Add your logo <https://github.com/sponsors/giampaolo>`__.
+
+Example usages
+==============
+
+This represents pretty much the whole psutil API.
+
+CPU
+---
+
+.. code-block:: python
+
+    >>> import psutil
+    >>>
+    >>> psutil.cpu_times()
+    scputimes(user=3961.46, nice=169.729, system=2150.659, idle=16900.540, iowait=629.59, irq=0.0, softirq=19.42, steal=0.0, guest=0, guest_nice=0.0)
+    >>>
+    >>> for x in range(3):
+    ...     psutil.cpu_percent(interval=1)
+    ...
+    4.0
+    5.9
+    3.8
+    >>>
+    >>> for x in range(3):
+    ...     psutil.cpu_percent(interval=1, percpu=True)
+    ...
+    [4.0, 6.9, 3.7, 9.2]
+    [7.0, 8.5, 2.4, 2.1]
+    [1.2, 9.0, 9.9, 7.2]
+    >>>
+    >>> for x in range(3):
+    ...     psutil.cpu_times_percent(interval=1, percpu=False)
+    ...
+    scputimes(user=1.5, nice=0.0, system=0.5, idle=96.5, iowait=1.5, irq=0.0, softirq=0.0, steal=0.0, guest=0.0, guest_nice=0.0)
+    scputimes(user=1.0, nice=0.0, system=0.0, idle=99.0, iowait=0.0, irq=0.0, softirq=0.0, steal=0.0, guest=0.0, guest_nice=0.0)
+    scputimes(user=2.0, nice=0.0, system=0.0, idle=98.0, iowait=0.0, irq=0.0, softirq=0.0, steal=0.0, guest=0.0, guest_nice=0.0)
+    >>>
+    >>> psutil.cpu_count()
+    4
+    >>> psutil.cpu_count(logical=False)
+    2
+    >>>
+    >>> psutil.cpu_stats()
+    scpustats(ctx_switches=20455687, interrupts=6598984, soft_interrupts=2134212, syscalls=0)
+    >>>
+    >>> psutil.cpu_freq()
+    scpufreq(current=931.42925, min=800.0, max=3500.0)
+    >>>
+    >>> psutil.getloadavg()  # also on Windows (emulated)
+    (3.14, 3.89, 4.67)
+
+Memory
+------
+
+.. code-block:: python
+
+    >>> psutil.virtual_memory()
+    svmem(total=10367352832, available=6472179712, percent=37.6, used=8186245120, free=2181107712, active=4748992512, inactive=2758115328, buffers=790724608, cached=3500347392, shared=787554304)
+    >>> psutil.swap_memory()
+    sswap(total=2097147904, used=296128512, free=1801019392, percent=14.1, sin=304193536, sout=677842944)
+    >>>
+
+Disks
+-----
+
+.. code-block:: python
+
+    >>> psutil.disk_partitions()
+    [sdiskpart(device='/dev/sda1', mountpoint='/', fstype='ext4', opts='rw,nosuid', maxfile=255, maxpath=4096),
+     sdiskpart(device='/dev/sda2', mountpoint='/home', fstype='ext', opts='rw', maxfile=255, maxpath=4096)]
+    >>>
+    >>> psutil.disk_usage('/')
+    sdiskusage(total=21378641920, used=4809781248, free=15482871808, percent=22.5)
+    >>>
+    >>> psutil.disk_io_counters(perdisk=False)
+    sdiskio(read_count=719566, write_count=1082197, read_bytes=18626220032, write_bytes=24081764352, read_time=5023392, write_time=63199568, read_merged_count=619166, write_merged_count=812396, busy_time=4523412)
+    >>>
+
+Network
+-------
+
+.. code-block:: python
+
+    >>> psutil.net_io_counters(pernic=True)
+    {'eth0': netio(bytes_sent=485291293, bytes_recv=6004858642, packets_sent=3251564, packets_recv=4787798, errin=0, errout=0, dropin=0, dropout=0),
+     'lo': netio(bytes_sent=2838627, bytes_recv=2838627, packets_sent=30567, packets_recv=30567, errin=0, errout=0, dropin=0, dropout=0)}
+    >>>
+    >>> psutil.net_connections(kind='tcp')
+    [sconn(fd=115, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=addr(ip='10.0.0.1', port=48776), raddr=addr(ip='93.186.135.91', port=80), status='ESTABLISHED', pid=1254),
+     sconn(fd=117, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=addr(ip='10.0.0.1', port=43761), raddr=addr(ip='72.14.234.100', port=80), status='CLOSING', pid=2987),
+     ...]
+    >>>
+    >>> psutil.net_if_addrs()
+    {'lo': [snicaddr(family=<AddressFamily.AF_INET: 2>, address='127.0.0.1', netmask='255.0.0.0', broadcast='127.0.0.1', ptp=None),
+            snicaddr(family=<AddressFamily.AF_INET6: 10>, address='::1', netmask='ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff', broadcast=None, ptp=None),
+            snicaddr(family=<AddressFamily.AF_LINK: 17>, address='00:00:00:00:00:00', netmask=None, broadcast='00:00:00:00:00:00', ptp=None)],
+     'wlan0': [snicaddr(family=<AddressFamily.AF_INET: 2>, address='192.168.1.3', netmask='255.255.255.0', broadcast='192.168.1.255', ptp=None),
+               snicaddr(family=<AddressFamily.AF_INET6: 10>, address='fe80::c685:8ff:fe45:641%wlan0', netmask='ffff:ffff:ffff:ffff::', broadcast=None, ptp=None),
+               snicaddr(family=<AddressFamily.AF_LINK: 17>, address='c4:85:08:45:06:41', netmask=None, broadcast='ff:ff:ff:ff:ff:ff', ptp=None)]}
+    >>>
+    >>> psutil.net_if_stats()
+    {'lo': snicstats(isup=True, duplex=<NicDuplex.NIC_DUPLEX_UNKNOWN: 0>, speed=0, mtu=65536, flags='up,loopback,running'),
+     'wlan0': snicstats(isup=True, duplex=<NicDuplex.NIC_DUPLEX_FULL: 2>, speed=100, mtu=1500, flags='up,broadcast,running,multicast')}
+    >>>
+
+Sensors
+-------
+
+.. code-block:: python
+
+    >>> import psutil
+    >>> psutil.sensors_temperatures()
+    {'acpitz': [shwtemp(label='', current=47.0, high=103.0, critical=103.0)],
+     'asus': [shwtemp(label='', current=47.0, high=None, critical=None)],
+     'coretemp': [shwtemp(label='Physical id 0', current=52.0, high=100.0, critical=100.0),
+                  shwtemp(label='Core 0', current=45.0, high=100.0, critical=100.0)]}
+    >>>
+    >>> psutil.sensors_fans()
+    {'asus': [sfan(label='cpu_fan', current=3200)]}
+    >>>
+    >>> psutil.sensors_battery()
+    sbattery(percent=93, secsleft=16628, power_plugged=False)
+    >>>
+
+Other system info
+-----------------
+
+.. code-block:: python
+
+    >>> import psutil
+    >>> psutil.users()
+    [suser(name='giampaolo', terminal='pts/2', host='localhost', started=1340737536.0, pid=1352),
+     suser(name='giampaolo', terminal='pts/3', host='localhost', started=1340737792.0, pid=1788)]
+    >>>
+    >>> psutil.boot_time()
+    1365519115.0
+    >>>
+
+Process management
+------------------
+
+.. code-block:: python
+
+    >>> import psutil
+    >>> psutil.pids()
+    [1, 2, 3, 4, 5, 6, 7, 46, 48, 50, 51, 178, 182, 222, 223, 224, 268, 1215,
+     1216, 1220, 1221, 1243, 1244, 1301, 1601, 2237, 2355, 2637, 2774, 3932,
+     4176, 4177, 4185, 4187, 4189, 4225, 4243, 4245, 4263, 4282, 4306, 4311,
+     4312, 4313, 4314, 4337, 4339, 4357, 4358, 4363, 4383, 4395, 4408, 4433,
+     4443, 4445, 4446, 5167, 5234, 5235, 5252, 5318, 5424, 5644, 6987, 7054,
+     7055, 7071]
+    >>>
+    >>> p = psutil.Process(7055)
+    >>> p
+    psutil.Process(pid=7055, name='python3', status='running', started='09:04:44')
+    >>> p.pid
+    7055
+    >>> p.name()
+    'python3'
+    >>> p.exe()
+    '/usr/bin/python3'
+    >>> p.cwd()
+    '/home/giampaolo'
+    >>> p.cmdline()
+    ['/usr/bin/python3', 'main.py']
+    >>>
+    >>> p.ppid()
+    7054
+    >>> p.parent()
+    psutil.Process(pid=4699, name='bash', status='sleeping', started='09:06:44')
+    >>> p.parents()
+    [psutil.Process(pid=4699, name='bash', started='09:06:44'),
+     psutil.Process(pid=4689, name='gnome-terminal-server', status='sleeping', started='0:06:44'),
+     psutil.Process(pid=1, name='systemd', status='sleeping', started='05:56:55')]
+    >>> p.children(recursive=True)
+    [psutil.Process(pid=29835, name='python3', status='sleeping', started='11:45:38'),
+     psutil.Process(pid=29836, name='python3', status='waking', started='11:43:39')]
+    >>>
+    >>> p.status()
+    'running'
+    >>> p.create_time()
+    1267551141.5019531
+    >>> p.terminal()
+    '/dev/pts/0'
+    >>>
+    >>> p.username()
+    'giampaolo'
+    >>> p.uids()
+    puids(real=1000, effective=1000, saved=1000)
+    >>> p.gids()
+    pgids(real=1000, effective=1000, saved=1000)
+    >>>
+    >>> p.cpu_times()
+    pcputimes(user=1.02, system=0.31, children_user=0.32, children_system=0.1, iowait=0.0)
+    >>> p.cpu_percent(interval=1.0)
+    12.1
+    >>> p.cpu_affinity()
+    [0, 1, 2, 3]
+    >>> p.cpu_affinity([0, 1])  # set
+    >>> p.cpu_num()
+    1
+    >>>
+    >>> p.memory_info()
+    pmem(rss=10915840, vms=67608576, shared=3313664, text=2310144, lib=0, data=7262208, dirty=0)
+    >>> p.memory_full_info()  # "real" USS memory usage (Linux, macOS, Win only)
+    pfullmem(rss=10199040, vms=52133888, shared=3887104, text=2867200, lib=0, data=5967872, dirty=0, uss=6545408, pss=6872064, swap=0)
+    >>> p.memory_percent()
+    0.7823
+    >>> p.memory_maps()
+    [pmmap_grouped(path='/lib/x8664-linux-gnu/libutil-2.15.so', rss=32768, size=2125824, pss=32768, shared_clean=0, shared_dirty=0, private_clean=20480, private_dirty=12288, referenced=32768, anonymous=12288, swap=0),
+     pmmap_grouped(path='/lib/x8664-linux-gnu/libc-2.15.so', rss=3821568, size=3842048, pss=3821568, shared_clean=0, shared_dirty=0, private_clean=0, private_dirty=3821568, referenced=3575808, anonymous=3821568, swap=0),
+     pmmap_grouped(path='[heap]',  rss=32768, size=139264, pss=32768, shared_clean=0, shared_dirty=0, private_clean=0, private_dirty=32768, referenced=32768, anonymous=32768, swap=0),
+     pmmap_grouped(path='[stack]', rss=2465792, size=2494464, pss=2465792, shared_clean=0, shared_dirty=0, private_clean=0, private_dirty=2465792, referenced=2277376, anonymous=2465792, swap=0),
+     ...]
+    >>>
+    >>> p.io_counters()
+    pio(read_count=478001, write_count=59371, read_bytes=700416, write_bytes=69632, read_chars=456232, write_chars=517543)
+    >>>
+    >>> p.open_files()
+    [popenfile(path='/home/giampaolo/monit.py', fd=3, position=0, mode='r', flags=32768),
+     popenfile(path='/var/log/monit.log', fd=4, position=235542, mode='a', flags=33793)]
+    >>>
+    >>> p.connections(kind='tcp')
+    [pconn(fd=115, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=addr(ip='10.0.0.1', port=48776), raddr=addr(ip='93.186.135.91', port=80), status='ESTABLISHED'),
+     pconn(fd=117, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=addr(ip='10.0.0.1', port=43761), raddr=addr(ip='72.14.234.100', port=80), status='CLOSING')]
+    >>>
+    >>> p.threads()
+    [pthread(id=5234, user_time=22.5, system_time=9.2891),
+     pthread(id=5237, user_time=0.0707, system_time=1.1)]
+    >>>
+    >>> p.num_threads()
+    4
+    >>> p.num_fds()
+    8
+    >>> p.num_ctx_switches()
+    pctxsw(voluntary=78, involuntary=19)
+    >>>
+    >>> p.nice()
+    0
+    >>> p.nice(10)  # set
+    >>>
+    >>> p.ionice(psutil.IOPRIO_CLASS_IDLE)  # IO priority (Win and Linux only)
+    >>> p.ionice()
+    pionice(ioclass=<IOPriority.IOPRIO_CLASS_IDLE: 3>, value=0)
+    >>>
+    >>> p.rlimit(psutil.RLIMIT_NOFILE, (5, 5))  # set resource limits (Linux only)
+    >>> p.rlimit(psutil.RLIMIT_NOFILE)
+    (5, 5)
+    >>>
+    >>> p.environ()
+    {'LC_PAPER': 'it_IT.UTF-8', 'SHELL': '/bin/bash', 'GREP_OPTIONS': '--color=auto',
+    'XDG_CONFIG_DIRS': '/etc/xdg/xdg-ubuntu:/usr/share/upstart/xdg:/etc/xdg',
+     ...}
+    >>>
+    >>> p.as_dict()
+    {'status': 'running', 'num_ctx_switches': pctxsw(voluntary=63, involuntary=1), 'pid': 5457, ...}
+    >>> p.is_running()
+    True
+    >>> p.suspend()
+    >>> p.resume()
+    >>>
+    >>> p.terminate()
+    >>> p.kill()
+    >>> p.wait(timeout=3)
+    <Exitcode.EX_OK: 0>
+    >>>
+    >>> psutil.test()
+    USER         PID %CPU %MEM     VSZ     RSS TTY        START    TIME  COMMAND
+    root           1  0.0  0.0   24584    2240            Jun17   00:00  init
+    root           2  0.0  0.0       0       0            Jun17   00:00  kthreadd
+    ...
+    giampaolo  31475  0.0  0.0   20760    3024 /dev/pts/0 Jun19   00:00  python2.4
+    giampaolo  31721  0.0  2.2  773060  181896            00:04   10:30  chrome
+    root       31763  0.0  0.0       0       0            00:05   00:00  kworker/0:1
+    >>>
+
+Further process APIs
+--------------------
+
+.. code-block:: python
+
+    >>> import psutil
+    >>> for proc in psutil.process_iter(['pid', 'name']):
+    ...     print(proc.info)
+    ...
+    {'pid': 1, 'name': 'systemd'}
+    {'pid': 2, 'name': 'kthreadd'}
+    {'pid': 3, 'name': 'ksoftirqd/0'}
+    ...
+    >>>
+    >>> psutil.pid_exists(3)
+    True
+    >>>
+    >>> def on_terminate(proc):
+    ...     print("process {} terminated".format(proc))
+    ...
+    >>> # waits for multiple processes to terminate
+    >>> gone, alive = psutil.wait_procs(procs_list, timeout=3, callback=on_terminate)
+    >>>
+
+Windows services
+----------------
+
+.. code-block:: python
+
+    >>> list(psutil.win_service_iter())
+    [<WindowsService(name='AeLookupSvc', display_name='Application Experience') at 38850096>,
+     <WindowsService(name='ALG', display_name='Application Layer Gateway Service') at 38850128>,
+     <WindowsService(name='APNMCP', display_name='Ask Update Service') at 38850160>,
+     <WindowsService(name='AppIDSvc', display_name='Application Identity') at 38850192>,
+     ...]
+    >>> s = psutil.win_service_get('alg')
+    >>> s.as_dict()
+    {'binpath': 'C:\\Windows\\System32\\alg.exe',
+     'description': 'Provides support for 3rd party protocol plug-ins for Internet Connection Sharing',
+     'display_name': 'Application Layer Gateway Service',
+     'name': 'alg',
+     'pid': None,
+     'start_type': 'manual',
+     'status': 'stopped',
+     'username': 'NT AUTHORITY\\LocalService'}
+
+Projects using psutil
+=====================
+
+Here's some I find particularly interesting:
+
+- https://github.com/google/grr
+- https://github.com/facebook/osquery/
+- https://github.com/nicolargo/glances
+- https://github.com/aristocratos/bpytop
+- https://github.com/Jahaja/psdash
+- https://github.com/ajenti/ajenti
+- https://github.com/home-assistant/home-assistant/
+
+Portings
+========
+
+- Go: https://github.com/shirou/gopsutil
+- C: https://github.com/hamon-in/cpslib
+- Rust: https://github.com/rust-psutil/rust-psutil
+- Nim: https://github.com/johnscillieri/psutil-nim
+
+
+

env-llmeval/lib/python3.10/site-packages/psutil-5.9.8.dist-info/RECORD

@@ -0,0 +1,66 @@
+psutil-5.9.8.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+psutil-5.9.8.dist-info/LICENSE,sha256=uJwGOzeG4o4MCjjxkx22H-015p3SopZvvs_-4PRsjRA,1548
+psutil-5.9.8.dist-info/METADATA,sha256=GfZ5-fidrq0yXOCgyN4funClVHk6R_zfJz-3FKx0KjU,21837
+psutil-5.9.8.dist-info/RECORD,,
+psutil-5.9.8.dist-info/WHEEL,sha256=rgpVBmjjvbINeGKCkWEGd3f40VHMTsDkQj1Lgil82zE,221
+psutil-5.9.8.dist-info/top_level.txt,sha256=gCNhn57wzksDjSAISmgMJ0aiXzQulk0GJhb2-BAyYgw,7
+psutil/__init__.py,sha256=YWf_i2ZjuJqELRfNl6nX0nZuoi09GXqMZPJVsMJMCQQ,89169
+psutil/__pycache__/__init__.cpython-310.pyc,,
+psutil/__pycache__/_common.cpython-310.pyc,,
+psutil/__pycache__/_compat.cpython-310.pyc,,
+psutil/__pycache__/_psaix.cpython-310.pyc,,
+psutil/__pycache__/_psbsd.cpython-310.pyc,,
+psutil/__pycache__/_pslinux.cpython-310.pyc,,
+psutil/__pycache__/_psosx.cpython-310.pyc,,
+psutil/__pycache__/_psposix.cpython-310.pyc,,
+psutil/__pycache__/_pssunos.cpython-310.pyc,,
+psutil/__pycache__/_pswindows.cpython-310.pyc,,
+psutil/_common.py,sha256=BTwHxdYJQynrn5i8IOs6XFxLo9L1Eg5cgDCq6Yaypr0,29393
+psutil/_compat.py,sha256=AOF0vSCWle_sbJ1Gw-CGx0aEI9yk5u70YhPYOPg3KHs,15349
+psutil/_psaix.py,sha256=1bqEwjk6IG3Y-zrDajKi8oPSYvq3NrqpPUQeDRo4Ugg,18749
+psutil/_psbsd.py,sha256=FruAJy_GrpjAfHLpb4c3IVGfy2Xii8b1BHnIjxUfbbI,31956
+psutil/_pslinux.py,sha256=QYI6yHTvRMYZlVxB068xVAEMEAGGRSU9E7-sJD3165o,88043
+psutil/_psosx.py,sha256=d_KMSzmjL6vAYQx1fQN57b3xazJGdTt4rIysODB1r2g,16209
+psutil/_psposix.py,sha256=X9rd7WHKQ6mUAn2ihb03MCnzrBtQsrPRkCouExmuagQ,8235
+psutil/_pssunos.py,sha256=Zx6eLY-0NRUFFIKP7SycktgDoottdnlA9aX8y4e74dY,25559
+psutil/_psutil_linux.abi3.so,sha256=onwm8BWn6axbKjPqB263JHm6rbDcEvMncKYhhpbu5I4,115304
+psutil/_psutil_posix.abi3.so,sha256=xNVKy1LdKcnigEe_BpaXfYEg4qad9MkedLwkYh4BaBk,71624
+psutil/_pswindows.py,sha256=BXgoASpIS6ccw5jTx4V-H2fMsIcSv_NQ6EozsxFgY-0,37734
+psutil/tests/__init__.py,sha256=gc621Vvgj2NaxusB_zGwfqwP_np3qaCQqJlyPrp1D0k,64753
+psutil/tests/__main__.py,sha256=f1YY6SZebctd5Hwb1in40nFShfJw4zA2FLidsdg_eY8,269
+psutil/tests/__pycache__/__init__.cpython-310.pyc,,
+psutil/tests/__pycache__/__main__.cpython-310.pyc,,
+psutil/tests/__pycache__/runner.cpython-310.pyc,,
+psutil/tests/__pycache__/test_aix.cpython-310.pyc,,
+psutil/tests/__pycache__/test_bsd.cpython-310.pyc,,
+psutil/tests/__pycache__/test_connections.cpython-310.pyc,,
+psutil/tests/__pycache__/test_contracts.cpython-310.pyc,,
+psutil/tests/__pycache__/test_linux.cpython-310.pyc,,
+psutil/tests/__pycache__/test_memleaks.cpython-310.pyc,,
+psutil/tests/__pycache__/test_misc.cpython-310.pyc,,
+psutil/tests/__pycache__/test_osx.cpython-310.pyc,,
+psutil/tests/__pycache__/test_posix.cpython-310.pyc,,
+psutil/tests/__pycache__/test_process.cpython-310.pyc,,
+psutil/tests/__pycache__/test_process_all.cpython-310.pyc,,
+psutil/tests/__pycache__/test_sunos.cpython-310.pyc,,
+psutil/tests/__pycache__/test_system.cpython-310.pyc,,
+psutil/tests/__pycache__/test_testutils.cpython-310.pyc,,
+psutil/tests/__pycache__/test_unicode.cpython-310.pyc,,
+psutil/tests/__pycache__/test_windows.cpython-310.pyc,,
+psutil/tests/runner.py,sha256=WtRnLZ5gS39gIysLCkeV99hw5LvodVwBGesoen9IMNs,11464
+psutil/tests/test_aix.py,sha256=8SKjFw7cR3byBShlvWAzQSOTjji5Bpnk8JyUksR0AQI,4585
+psutil/tests/test_bsd.py,sha256=kfNXLsZ1p-VoGtVX4At9qMOS_zN8OMVP9yecuHEWaC4,21245
+psutil/tests/test_connections.py,sha256=CHL65q2IYxb8ErtJAUh87RyKSCWewwmAg4VFK80arO8,21642
+psutil/tests/test_contracts.py,sha256=_TAWN7ldbgqJIdh6tMkRDivXPoH6T3jKYG47_KzDvtE,12998
+psutil/tests/test_linux.py,sha256=LPvhEPUPSQ4MdxBlARPcR4Thsd_wNqKkqj0JqlKkZCo,92530
+psutil/tests/test_memleaks.py,sha256=pzwEMUaz6Xh8AmN_qiCmYTU2yzot_dwsdbTfFdK89Vk,15012
+psutil/tests/test_misc.py,sha256=JovYMJNShu2yC3t2sfkFY5uW96TL7K5gkwXnjOR25aQ,35117
+psutil/tests/test_osx.py,sha256=MQsepO25TlfydaOxjqgEBM4Wri9SnCUkpBLEiQnKv2Q,6603
+psutil/tests/test_posix.py,sha256=sDam9vdJJWuYNddovhxi1c3K-z4AfTAD0fQyyaeD8YY,17387
+psutil/tests/test_process.py,sha256=lOq3nOyQQvKRJRaTREO0GB0ErOQGZeqxHsEbn5qs8P4,61535
+psutil/tests/test_process_all.py,sha256=qkLXnkVVYEqM2IhhID0CzEVWAmD4Ib7i0E4mUjo8J_Y,16112
+psutil/tests/test_sunos.py,sha256=NhZsHABJKjCEDzGA7ZL62s6NlqpJwpoDybaPB2Bm9HE,1310
+psutil/tests/test_system.py,sha256=rfzGP_ZuMHxzuTz3CuVxn8-zXNe5_9YCm1Z5JTKXqT8,37044
+psutil/tests/test_testutils.py,sha256=mBbsRBbUf4VmDrKTbvlSeVqo_5HTM9h4eTE_VZ_5eXc,14828
+psutil/tests/test_unicode.py,sha256=lKytzxNA72Zdhhz6jnXjVRm-3-79j1zeliPO1SMSVaE,12549
+psutil/tests/test_windows.py,sha256=D_fKdhp8rsXDF7OrBXLRPS7XMpqXAzqJzbrjPqlL5pE,35298

env-llmeval/lib/python3.10/site-packages/psutil-5.9.8.dist-info/WHEEL

@@ -0,0 +1,8 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: false
+Tag: cp36-abi3-manylinux_2_12_x86_64
+Tag: cp36-abi3-manylinux2010_x86_64
+Tag: cp36-abi3-manylinux_2_17_x86_64
+Tag: cp36-abi3-manylinux2014_x86_64
+

env-llmeval/lib/python3.10/site-packages/psutil-5.9.8.dist-info/top_level.txt

@@ -0,0 +1 @@
+psutil

env-llmeval/lib/python3.10/site-packages/pytablewriter/style/_cell.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ._style import Style
+
+
+@dataclass(frozen=True)
+class Cell:
+    """
+    A data class representing a cell in a table.
+    """
+
+    row: int
+    """row index. ``-1`` means that the table header row."""
+
+    col: int
+    """column index."""
+
+    value: Any
+    """data for the cell."""
+
+    default_style: Style
+    """default |Style| for the cell."""
+
+    def is_header_row(self) -> bool:
+        """
+        Return |True| if the cell is a header.
+        """
+
+        return self.row < 0

env-llmeval/lib/python3.10/site-packages/pytablewriter/style/_style.py

@@ -0,0 +1,376 @@
+import warnings
+from enum import Enum, unique
+from typing import Any, Dict, Optional, Union
+
+from dataproperty import Align
+from tcolorpy import Color
+
+from .._function import normalize_enum
+from ._font import FontSize, FontStyle, FontWeight
+
+
+@unique
+class DecorationLine(Enum):
+    NONE = "none"
+    LINE_THROUGH = "line_through"
+    STRIKE = "strike"
+    UNDERLINE = "underline"
+
+
+@unique
+class ThousandSeparator(Enum):
+    NONE = "none"  #: no thousands separator
+    COMMA = "comma"  #: ``','`` as thousands separator
+    SPACE = "space"  #: ``' '`` as thousands separator
+    UNDERSCORE = "underscore"  #: ``'_'`` as thousands separator
+
+
+@unique
+class VerticalAlign(Enum):
+    BASELINE = (1 << 0, "baseline")
+    TOP = (1 << 1, "top")
+    MIDDLE = (1 << 2, "middle")
+    BOTTOM = (1 << 3, "bottom")
+
+    @property
+    def align_code(self) -> int:
+        return self.__align_code
+
+    @property
+    def align_str(self) -> str:
+        return self.__align_string
+
+    def __init__(self, code: int, string: str) -> None:
+        self.__align_code = code
+        self.__align_string = string
+
+
+_s_to_ts: Dict[str, ThousandSeparator] = {
+    "": ThousandSeparator.NONE,
+    ",": ThousandSeparator.COMMA,
+    " ": ThousandSeparator.SPACE,
+    "_": ThousandSeparator.UNDERSCORE,
+}
+
+
+def _normalize_thousand_separator(value: Union[str, ThousandSeparator]) -> ThousandSeparator:
+    if isinstance(value, ThousandSeparator):
+        return value
+
+    thousand_separator = normalize_enum(
+        value,
+        ThousandSeparator,
+        default=ThousandSeparator.NONE,
+        validate=False,
+    )
+    if isinstance(thousand_separator, ThousandSeparator):
+        return thousand_separator
+
+    norm_value = _s_to_ts.get(value)
+    if norm_value is None:
+        raise ValueError(f"unknown thousand separator: {value}")
+
+    return norm_value
+
+
+class Style:
+    """Style specifier class for table elements.
+
+    Args:
+        color (Union[|str|, tcolorpy.Color, |None|]):
+            Text color for cells.
+            When using str, specify a color code (``"#XXXXXX"``) or a color name.
+
+            .. note::
+                In the current version, only applicable for part of text format writer classes.
+
+        fg_color (Union[|str|, tcolorpy.Color, |None|]):
+            Alias to :py:attr:`~.color`.
+
+        bg_color (Union[|str|, tcolorpy.Color, |None|]):
+            Background color for cells.
+            When using str, specify a color code (``"#XXXXXX"``) or a color name.
+
+            .. note::
+                In the current version, only applicable for part of text format writer classes.
+
+        align (|str| / :py:class:`~.style.Align`):
+            Horizontal text alignment for cells.
+            This can be only applied for text format writer classes.
+            Possible string values are:
+
+            - ``"auto"`` (default)
+                - Detect data type for each column and set alignment that appropriate
+                  for the type automatically
+            - ``"left"``
+            - ``"right"``
+            - ``"center"``
+
+        vertical_align (|str| / :py:class:`~.style.VerticalAlign`):
+            Vertical text alignment for cells.
+            This can be only applied for HtmlTableWriter class.
+            Possible string values are:
+
+            - ``"baseline"`` (default)
+            - ``"top"``
+            - ``"middle"``
+            - ``"bottom"``
+
+        font_size (|str| / :py:class:`~.style.FontSize`):
+            Font size specification for cells in a column.
+            This can be only applied for HTML/Latex writer classes.
+            Possible string values are:
+
+            - ``"tiny"``
+            - ``"small"``
+            - ``"medium"``
+            - ``"large"``
+            - ``"none"`` (default: no font size specification)
+
+        font_weight (|str| / :py:class:`~.style.FontWeight`):
+            Font weight specification for cells in a column.
+            This can be only applied for HTML/Latex/Markdown writer classes.
+            Possible string values are:
+
+            - ``"normal"`` (default)
+            - ``"bold"``
+
+        font_style (|str| / :py:class:`~.style.FontStyle`):
+            Font style specification for cells in a column.
+            This can be applied only for HTML/Latex/Markdown writer classes.
+            Possible string values are:
+
+            - ``"normal"`` (default)
+            - ``"italic"``
+            - ``"typewriter"`` (only for Latex writer)
+
+        decoration_line (|str| / :py:class:`~.style.DecorationLine`)
+
+            Experiental.
+            Possible string values are:
+
+            - ``"line-through"``
+            - ``"strike"`` (alias for ``"line-through"``)
+            - ``"underline"``
+            - ``"none"`` (default)
+
+        thousand_separator (|str| / :py:class:`~.style.ThousandSeparator`):
+            Thousand separator specification for numbers in a column.
+            This can be only applied for text format writer classes.
+            Possible string values are:
+
+            - ``","``/``"comma"``
+            - ``" "``/``"space"``
+            - ``"_"``/``"underscore"``
+            - ``""``/``"none"`` (default)
+
+    Example:
+        :ref:`example-style`
+    """
+
+    @property
+    def align(self) -> Align:
+        return self.__align
+
+    @align.setter
+    def align(self, value: Align) -> None:
+        self.__align = value
+
+    @property
+    def vertical_align(self) -> VerticalAlign:
+        return self.__valign
+
+    @property
+    def decoration_line(self) -> DecorationLine:
+        return self.__decoration_line
+
+    @property
+    def font_size(self) -> FontSize:
+        return self.__font_size
+
+    @property
+    def font_style(self) -> FontStyle:
+        return self.__font_style
+
+    @property
+    def font_weight(self) -> FontWeight:
+        return self.__font_weight
+
+    @property
+    def color(self) -> Optional[Color]:
+        return self.__fg_color
+
+    @property
+    def fg_color(self) -> Optional[Color]:
+        return self.__fg_color
+
+    @property
+    def bg_color(self) -> Optional[Color]:
+        return self.__bg_color
+
+    @property
+    def thousand_separator(self) -> ThousandSeparator:
+        return self.__thousand_separator
+
+    @property
+    def padding(self) -> Optional[int]:
+        return self.__padding
+
+    @padding.setter
+    def padding(self, value: Optional[int]) -> None:
+        self.__padding = value
+
+    def __init__(self, **kwargs: Any) -> None:
+        self.__kwargs = kwargs
+        self.__update_color(initialize=True)
+        self.__update_align(initialize=True)
+        self.__update_font(initialize=True)
+        self.__update_misc(initialize=True)
+
+        if self.__kwargs:
+            warnings.warn(f"unknown style attributes found: {self.__kwargs.keys()}", UserWarning)
+
+    def __repr__(self) -> str:
+        items = []
+
+        if self.align:
+            items.append(f"align={self.align.align_string}")
+        if self.padding is not None:
+            items.append(f"padding={self.padding}")
+        if self.vertical_align:
+            items.append(f"valign={self.vertical_align.align_str}")
+        if self.color:
+            items.append(f"color={self.color}")
+        if self.bg_color:
+            items.append(f"bg_color={self.bg_color}")
+        if self.decoration_line is not DecorationLine.NONE:
+            items.append(f"decoration_line={self.decoration_line.value}")
+        if self.font_size is not FontSize.NONE:
+            items.append(f"font_size={self.font_size.value}")
+        if self.font_style:
+            items.append(f"font_style={self.font_style.value}")
+        if self.font_weight:
+            items.append(f"font_weight={self.font_weight.value}")
+        if self.thousand_separator is not ThousandSeparator.NONE:
+            items.append(f"thousand_separator={self.thousand_separator.value}")
+
+        return "({})".format(", ".join(items))
+
+    def __eq__(self, other: Any) -> bool:
+        if self.__class__ is not other.__class__:
+            return False
+
+        return all(
+            [
+                self.align == other.align,
+                self.font_size == other.font_size,
+                self.font_style == other.font_style,
+                self.font_weight == other.font_weight,
+                self.thousand_separator == other.thousand_separator,
+            ]
+        )
+
+    def __ne__(self, other: Any) -> bool:
+        if self.__class__ is not other.__class__:
+            return True
+
+        return not self.__eq__(other)
+
+    def update(self, **kwargs: Any) -> None:
+        """Update specified style attributes."""
+        self.__kwargs = kwargs
+        self.__update_color(initialize=False)
+        self.__update_align(initialize=False)
+        self.__update_font(initialize=False)
+        self.__update_misc(initialize=False)
+
+        if self.__kwargs:
+            warnings.warn(f"unknown style attributes found: {self.__kwargs.keys()}", UserWarning)
+
+    def __update_color(self, initialize: bool) -> None:
+        fg_color = self.__kwargs.pop("color", None) or self.__kwargs.pop("fg_color", None)
+        if fg_color:
+            self.__fg_color: Optional[Color] = Color(fg_color)
+        elif initialize:
+            self.__fg_color = None
+
+        bg_color = self.__kwargs.pop("bg_color", None)
+        if bg_color:
+            self.__bg_color: Optional[Color] = Color(bg_color)
+        elif initialize:
+            self.__bg_color = None
+
+    def __update_font(self, initialize: bool) -> None:
+        font_size = self.__kwargs.pop("font_size", None)
+        if font_size:
+            self.__font_size = normalize_enum(
+                font_size,
+                FontSize,
+                validate=False,
+                default=FontSize.NONE,
+            )
+        elif initialize:
+            self.__font_size = FontSize.NONE
+        self.__validate_attr("font_size", (FontSize, str))
+
+        font_style = self.__kwargs.pop("font_style", None)
+        if font_style:
+            self.__font_style = normalize_enum(font_style, FontStyle, default=FontStyle.NORMAL)
+        elif initialize:
+            self.__font_style = FontStyle.NORMAL
+        self.__validate_attr("font_style", FontStyle)
+
+        font_weight = self.__kwargs.pop("font_weight", None)
+        if font_weight:
+            self.__font_weight = normalize_enum(font_weight, FontWeight, default=FontWeight.NORMAL)
+        elif initialize:
+            self.__font_weight = FontWeight.NORMAL
+        self.__validate_attr("font_weight", FontWeight)
+
+    def __update_align(self, initialize: bool) -> None:
+        align = self.__kwargs.pop("align", None)
+        if align:
+            self.__align = normalize_enum(align, Align, default=Align.AUTO)
+        elif initialize:
+            self.__align = Align.AUTO
+        self.__validate_attr("align", Align)
+
+        valign = self.__kwargs.pop("vertical_align", None)
+        if valign:
+            self.__valign = normalize_enum(valign, VerticalAlign, default=VerticalAlign.BASELINE)
+        elif initialize:
+            self.__valign = VerticalAlign.BASELINE
+        self.__validate_attr("vertical_align", VerticalAlign)
+
+    def __update_misc(self, initialize: bool) -> None:
+        padding = self.__kwargs.pop("padding", None)
+        if padding is not None:
+            self.__padding = padding
+        elif initialize:
+            self.__padding = None
+
+        decoration_line = self.__kwargs.pop("decoration_line", None)
+        if decoration_line:
+            self.__decoration_line = normalize_enum(
+                decoration_line, DecorationLine, default=DecorationLine.NONE
+            )
+        elif initialize:
+            self.__decoration_line = DecorationLine.NONE
+        self.__validate_attr("decoration_line", DecorationLine)
+
+        thousand_separator = self.__kwargs.pop("thousand_separator", None)
+        if thousand_separator:
+            self.__thousand_separator = _normalize_thousand_separator(thousand_separator)
+        elif initialize:
+            self.__thousand_separator = ThousandSeparator.NONE
+        self.__validate_attr("thousand_separator", ThousandSeparator)
+
+    def __validate_attr(self, attr_name: str, expected_type: Any) -> None:
+        value = getattr(self, attr_name)
+        if isinstance(expected_type, (list, tuple)):
+            expected = " or ".join(c.__name__ for c in expected_type)
+        else:
+            expected = expected_type.__name__
+
+        if not isinstance(value, expected_type):
+            raise TypeError(f"{attr_name} must be instance of {expected}: actual={type(value)}")

env-llmeval/lib/python3.10/site-packages/pytablewriter/style/_theme.py

@@ -0,0 +1,101 @@
+import importlib
+import pkgutil
+import re
+from typing import Any, Dict, NamedTuple, Optional, Sequence
+
+from .._logger import logger
+from ..style import Cell, Style
+
+
+try:
+    from typing import Protocol
+except ImportError:
+    # typing.Protocol is only available starting from Python 3.8.
+    from .._typing import Protocol  # type: ignore
+
+PLUGIN_NAME_PEFIX = "pytablewriter"
+PLUGIN_NAME_SUFFIX = "theme"
+KNOWN_PLUGINS = (
+    f"{PLUGIN_NAME_PEFIX}_altrow_{PLUGIN_NAME_SUFFIX}",
+    f"{PLUGIN_NAME_PEFIX}_altcol_{PLUGIN_NAME_SUFFIX}",
+)
+
+
+class StyleFilterFunc(Protocol):
+    def __call__(self, cell: Cell, **kwargs: Any) -> Optional[Style]:
+        ...
+
+
+class ColSeparatorStyleFilterFunc(Protocol):
+    def __call__(
+        self, left_cell: Optional[Cell], right_cell: Optional[Cell], **kwargs: Any
+    ) -> Optional[Style]:
+        ...
+
+
+class CheckStyleFilterKeywordArgsFunc(Protocol):
+    def __call__(self, **kwargs: Any) -> None:
+        ...
+
+
+class Theme(NamedTuple):
+    style_filter: Optional[StyleFilterFunc]
+    col_separator_style_filter: Optional[ColSeparatorStyleFilterFunc]
+    check_style_filter_kwargs: Optional[CheckStyleFilterKeywordArgsFunc]
+
+
+def list_themes() -> Sequence[str]:
+    return list(load_ptw_plugins())
+
+
+def load_ptw_plugins() -> Dict[str, Theme]:
+    plugin_regexp = re.compile(
+        rf"^{PLUGIN_NAME_PEFIX}[_-].+[_-]{PLUGIN_NAME_SUFFIX}", re.IGNORECASE
+    )
+
+    discovered_plugins = {
+        name: importlib.import_module(name)
+        for _finder, name, _ispkg in pkgutil.iter_modules()
+        if plugin_regexp.search(name) is not None
+    }
+
+    logger.debug(f"discovered_plugins: {list(discovered_plugins)}")
+
+    themes: Dict[str, Theme] = {}
+    for theme, plugin in discovered_plugins.items():
+        style_filter = plugin.style_filter if hasattr(plugin, "style_filter") else None
+        col_sep_style_filter = (
+            plugin.col_separator_style_filter
+            if hasattr(plugin, "col_separator_style_filter")
+            else None
+        )
+        check_kwargs_func = (
+            plugin.check_style_filter_kwargs
+            if hasattr(plugin, "check_style_filter_kwargs")
+            else None
+        )
+        themes[theme] = Theme(style_filter, col_sep_style_filter, check_kwargs_func)
+
+    return themes
+
+
+def fetch_theme(plugin_name: str) -> Theme:
+    loaded_themes = load_ptw_plugins()
+    theme_regexp = re.compile(
+        rf"^{PLUGIN_NAME_PEFIX}[_-]{plugin_name}[_-]{PLUGIN_NAME_SUFFIX}", re.IGNORECASE
+    )
+    matched_theme = None
+
+    for loaded_theme in loaded_themes:
+        if theme_regexp.search(loaded_theme):
+            matched_theme = loaded_theme
+            break
+    else:
+        err_msgs = [f"{plugin_name} theme is not installed."]
+
+        if plugin_name in KNOWN_PLUGINS:
+            err_msgs.append(f"try 'pip install {plugin_name}' to install the theme.")
+
+        raise RuntimeError(" ".join(err_msgs))
+
+    return loaded_themes[matched_theme]