Add files using upload-large-folder tool

.gitattributes

@@ -48,3 +48,6 @@ tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/__pyc
 tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Compiler/__pycache__/Optimize.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
 tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Tempita/_tempita.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Plex/Transitions.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Compiler/__pycache__/ExprNodes.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/idna/__pycache__/uts46data.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/__pycache__/_emoji_codes.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Compiler/__pycache__/ExprNodes.cpython-311.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4d0a7505b29dcf29db8e842581f65690f6434ea73c26f359db97d5eda40cdff9
+size 759350

tuning-competition-baseline/.venv/lib/python3.11/site-packages/filelock-3.13.1.dist-info/INSTALLER

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

tuning-competition-baseline/.venv/lib/python3.11/site-packages/filelock-3.13.1.dist-info/METADATA

@@ -0,0 +1,56 @@
+Metadata-Version: 2.1
+Name: filelock
+Version: 3.13.1
+Summary: A platform independent file lock.
+Project-URL: Documentation, https://py-filelock.readthedocs.io
+Project-URL: Homepage, https://github.com/tox-dev/py-filelock
+Project-URL: Source, https://github.com/tox-dev/py-filelock
+Project-URL: Tracker, https://github.com/tox-dev/py-filelock/issues
+Maintainer-email: Bernát Gábor <gaborjbernat@gmail.com>
+License-Expression: Unlicense
+License-File: LICENSE
+Keywords: application,cache,directory,log,user
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: The Unlicense (Unlicense)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System
+Requires-Python: >=3.8
+Provides-Extra: docs
+Requires-Dist: furo>=2023.9.10; extra == 'docs'
+Requires-Dist: sphinx-autodoc-typehints!=1.23.4,>=1.24; extra == 'docs'
+Requires-Dist: sphinx>=7.2.6; extra == 'docs'
+Provides-Extra: testing
+Requires-Dist: covdefaults>=2.3; extra == 'testing'
+Requires-Dist: coverage>=7.3.2; extra == 'testing'
+Requires-Dist: diff-cover>=8; extra == 'testing'
+Requires-Dist: pytest-cov>=4.1; extra == 'testing'
+Requires-Dist: pytest-mock>=3.12; extra == 'testing'
+Requires-Dist: pytest-timeout>=2.2; extra == 'testing'
+Requires-Dist: pytest>=7.4.3; extra == 'testing'
+Provides-Extra: typing
+Requires-Dist: typing-extensions>=4.8; python_version < '3.11' and extra == 'typing'
+Description-Content-Type: text/markdown
+
+# filelock
+
+[![PyPI](https://img.shields.io/pypi/v/filelock)](https://pypi.org/project/filelock/)
+[![Supported Python
+versions](https://img.shields.io/pypi/pyversions/filelock.svg)](https://pypi.org/project/filelock/)
+[![Documentation
+status](https://readthedocs.org/projects/py-filelock/badge/?version=latest)](https://py-filelock.readthedocs.io/en/latest/?badge=latest)
+[![Code style:
+black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Downloads](https://static.pepy.tech/badge/filelock/month)](https://pepy.tech/project/filelock)
+[![check](https://github.com/tox-dev/py-filelock/actions/workflows/check.yml/badge.svg)](https://github.com/tox-dev/py-filelock/actions/workflows/check.yml)
+
+For more information checkout the [official documentation](https://py-filelock.readthedocs.io/en/latest/index.html).

tuning-competition-baseline/.venv/lib/python3.11/site-packages/filelock-3.13.1.dist-info/RECORD

@@ -0,0 +1,22 @@
+filelock-3.13.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+filelock-3.13.1.dist-info/METADATA,sha256=gi7LyG-dEuOBZC32wie-OOG0OkPZHABsn9rXvxuQlcA,2784
+filelock-3.13.1.dist-info/RECORD,,
+filelock-3.13.1.dist-info/WHEEL,sha256=9QBuHhg6FNW7lppboF2vKVbCGTVzsFykgRQjjlajrhA,87
+filelock-3.13.1.dist-info/licenses/LICENSE,sha256=iNm062BXnBkew5HKBMFhMFctfu3EqG2qWL8oxuFMm80,1210
+filelock/__init__.py,sha256=wAVZ_9_-3Y14xzzupRk5BTTRewFJekR2vf9oIx4M750,1213
+filelock/__pycache__/__init__.cpython-311.pyc,,
+filelock/__pycache__/_api.cpython-311.pyc,,
+filelock/__pycache__/_error.cpython-311.pyc,,
+filelock/__pycache__/_soft.cpython-311.pyc,,
+filelock/__pycache__/_unix.cpython-311.pyc,,
+filelock/__pycache__/_util.cpython-311.pyc,,
+filelock/__pycache__/_windows.cpython-311.pyc,,
+filelock/__pycache__/version.cpython-311.pyc,,
+filelock/_api.py,sha256=UsVWPEOOgFH1pR_6WMk2b5hWZ7nWhUPT5GZX9WuYaC8,11860
+filelock/_error.py,sha256=-5jMcjTu60YAvAO1UbqDD1GIEjVkwr8xCFwDBtMeYDg,787
+filelock/_soft.py,sha256=haqtc_TB_KJbYv2a8iuEAclKuM4fMG1vTcp28sK919c,1711
+filelock/_unix.py,sha256=ViG38PgJsIhT3xaArugvw0TPP6VWoP2VJj7FEIWypkg,2157
+filelock/_util.py,sha256=dBDlIj1dHL_juXX0Qqq6bZtyE53YZTN8GFhtyTV043o,1708
+filelock/_windows.py,sha256=eMKL8dZKrgekf5VYVGR14an29JGEInRtUO8ui9ABywg,2177
+filelock/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+filelock/version.py,sha256=fmajg3X8ZdOn-UpUewARwK5cfYf4wP4Xa0DcHjigFYo,413

tuning-competition-baseline/.venv/lib/python3.11/site-packages/filelock-3.13.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.18.0
+Root-Is-Purelib: true
+Tag: py3-none-any

tuning-competition-baseline/.venv/lib/python3.11/site-packages/filelock-3.13.1.dist-info/licenses/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org>

tuning-competition-baseline/.venv/lib/python3.11/site-packages/mpmath/calculus/inverselaplace.py

@@ -0,0 +1,973 @@
+# contributed to mpmath by Kristopher L. Kuhlman, February 2017
+# contributed to mpmath by Guillermo Navas-Palencia, February 2022
+
+class InverseLaplaceTransform(object):
+    r"""
+    Inverse Laplace transform methods are implemented using this
+    class, in order to simplify the code and provide a common
+    infrastructure.
+
+    Implement a custom inverse Laplace transform algorithm by
+    subclassing :class:`InverseLaplaceTransform` and implementing the
+    appropriate methods. The subclass can then be used by
+    :func:`~mpmath.invertlaplace` by passing it as the *method*
+    argument.
+    """
+
+    def __init__(self, ctx):
+        self.ctx = ctx
+
+    def calc_laplace_parameter(self, t, **kwargs):
+        r"""
+        Determine the vector of Laplace parameter values needed for an
+        algorithm, this will depend on the choice of algorithm (de
+        Hoog is default), the algorithm-specific parameters passed (or
+        default ones), and desired time.
+        """
+        raise NotImplementedError
+
+    def calc_time_domain_solution(self, fp):
+        r"""
+        Compute the time domain solution, after computing the
+        Laplace-space function evaluations at the abscissa required
+        for the algorithm. Abscissa computed for one algorithm are
+        typically not useful for another algorithm.
+        """
+        raise NotImplementedError
+
+
+class FixedTalbot(InverseLaplaceTransform):
+
+    def calc_laplace_parameter(self, t, **kwargs):
+        r"""The "fixed" Talbot method deforms the Bromwich contour towards
+        `-\infty` in the shape of a parabola. Traditionally the Talbot
+        algorithm has adjustable parameters, but the "fixed" version
+        does not. The `r` parameter could be passed in as a parameter,
+        if you want to override the default given by (Abate & Valko,
+        2004).
+
+        The Laplace parameter is sampled along a parabola opening
+        along the negative imaginary axis, with the base of the
+        parabola along the real axis at
+        `p=\frac{r}{t_\mathrm{max}}`. As the number of terms used in
+        the approximation (degree) grows, the abscissa required for
+        function evaluation tend towards `-\infty`, requiring high
+        precision to prevent overflow.  If any poles, branch cuts or
+        other singularities exist such that the deformed Bromwich
+        contour lies to the left of the singularity, the method will
+        fail.
+
+        **Optional arguments**
+
+        :class:`~mpmath.calculus.inverselaplace.FixedTalbot.calc_laplace_parameter`
+        recognizes the following keywords
+
+        *tmax*
+            maximum time associated with vector of times
+            (typically just the time requested)
+        *degree*
+            integer order of approximation (M = number of terms)
+        *r*
+            abscissa for `p_0` (otherwise computed using rule
+            of thumb `2M/5`)
+
+        The working precision will be increased according to a rule of
+        thumb. If 'degree' is not specified, the working precision and
+        degree are chosen to hopefully achieve the dps of the calling
+        context. If 'degree' is specified, the working precision is
+        chosen to achieve maximum resulting precision for the
+        specified degree.
+
+        .. math ::
+
+            p_0=\frac{r}{t}
+
+        .. math ::
+
+            p_i=\frac{i r \pi}{Mt_\mathrm{max}}\left[\cot\left(
+            \frac{i\pi}{M}\right) + j \right] \qquad 1\le i <M
+
+        where `j=\sqrt{-1}`, `r=2M/5`, and `t_\mathrm{max}` is the
+        maximum specified time.
+
+        """
+
+        # required
+        # ------------------------------
+        # time of desired approximation
+        self.t = self.ctx.convert(t)
+
+        # optional
+        # ------------------------------
+        # maximum time desired (used for scaling) default is requested
+        # time.
+        self.tmax = self.ctx.convert(kwargs.get('tmax', self.t))
+
+        # empirical relationships used here based on a linear fit of
+        # requested and delivered dps for exponentially decaying time
+        # functions for requested dps up to 512.
+
+        if 'degree' in kwargs:
+            self.degree = kwargs['degree']
+            self.dps_goal = self.degree
+        else:
+            self.dps_goal = int(1.72*self.ctx.dps)
+            self.degree = max(12, int(1.38*self.dps_goal))
+
+        M = self.degree
+
+        # this is adjusting the dps of the calling context hopefully
+        # the caller doesn't monkey around with it between calling
+        # this routine and calc_time_domain_solution()
+        self.dps_orig = self.ctx.dps
+        self.ctx.dps = self.dps_goal
+
+        # Abate & Valko rule of thumb for r parameter
+        self.r = kwargs.get('r', self.ctx.fraction(2, 5)*M)
+
+        self.theta = self.ctx.linspace(0.0, self.ctx.pi, M+1)
+
+        self.cot_theta = self.ctx.matrix(M, 1)
+        self.cot_theta[0] = 0  # not used
+
+        # all but time-dependent part of p
+        self.delta = self.ctx.matrix(M, 1)
+        self.delta[0] = self.r
+
+        for i in range(1, M):
+            self.cot_theta[i] = self.ctx.cot(self.theta[i])
+            self.delta[i] = self.r*self.theta[i]*(self.cot_theta[i] + 1j)
+
+        self.p = self.ctx.matrix(M, 1)
+        self.p = self.delta/self.tmax
+
+        # NB: p is complex (mpc)
+
+    def calc_time_domain_solution(self, fp, t, manual_prec=False):
+        r"""The fixed Talbot time-domain solution is computed from the
+        Laplace-space function evaluations using
+
+        .. math ::
+
+            f(t,M)=\frac{2}{5t}\sum_{k=0}^{M-1}\Re \left[
+            \gamma_k \bar{f}(p_k)\right]
+
+        where
+
+        .. math ::
+
+            \gamma_0 = \frac{1}{2}e^{r}\bar{f}(p_0)
+
+        .. math ::
+
+            \gamma_k = e^{tp_k}\left\lbrace 1 + \frac{jk\pi}{M}\left[1 +
+            \cot \left( \frac{k \pi}{M} \right)^2 \right] - j\cot\left(
+            \frac{k \pi}{M}\right)\right \rbrace \qquad 1\le k<M.
+
+        Again, `j=\sqrt{-1}`.
+
+        Before calling this function, call
+        :class:`~mpmath.calculus.inverselaplace.FixedTalbot.calc_laplace_parameter`
+        to set the parameters and compute the required coefficients.
+
+        **References**
+
+        1. Abate, J., P. Valko (2004). Multi-precision Laplace
+           transform inversion. *International Journal for Numerical
+           Methods in Engineering* 60:979-993,
+           http://dx.doi.org/10.1002/nme.995
+        2. Talbot, A. (1979). The accurate numerical inversion of
+           Laplace transforms. *IMA Journal of Applied Mathematics*
+           23(1):97, http://dx.doi.org/10.1093/imamat/23.1.97
+        """
+
+        # required
+        # ------------------------------
+        self.t = self.ctx.convert(t)
+
+        # assume fp was computed from p matrix returned from
+        # calc_laplace_parameter(), so is already a list or matrix of
+        # mpmath 'mpc' types
+
+        # these were computed in previous call to
+        # calc_laplace_parameter()
+        theta = self.theta
+        delta = self.delta
+        M = self.degree
+        p = self.p
+        r = self.r
+
+        ans = self.ctx.matrix(M, 1)
+        ans[0] = self.ctx.exp(delta[0])*fp[0]/2
+
+        for i in range(1, M):
+            ans[i] = self.ctx.exp(delta[i])*fp[i]*(
+                1 + 1j*theta[i]*(1 + self.cot_theta[i]**2) -
+                1j*self.cot_theta[i])
+
+        result = self.ctx.fraction(2, 5)*self.ctx.fsum(ans)/self.t
+
+        # setting dps back to value when calc_laplace_parameter was
+        # called, unless flag is set.
+        if not manual_prec:
+            self.ctx.dps = self.dps_orig
+
+        return result.real
+
+
+# ****************************************
+
+class Stehfest(InverseLaplaceTransform):
+
+    def calc_laplace_parameter(self, t, **kwargs):
+        r"""
+        The Gaver-Stehfest method is a discrete approximation of the
+        Widder-Post inversion algorithm, rather than a direct
+        approximation of the Bromwich contour integral.
+
+        The method abscissa along the real axis, and therefore has
+        issues inverting oscillatory functions (which have poles in
+        pairs away from the real axis).
+
+        The working precision will be increased according to a rule of
+        thumb. If 'degree' is not specified, the working precision and
+        degree are chosen to hopefully achieve the dps of the calling
+        context. If 'degree' is specified, the working precision is
+        chosen to achieve maximum resulting precision for the
+        specified degree.
+
+        .. math ::
+
+            p_k = \frac{k \log 2}{t} \qquad 1 \le k \le M
+        """
+
+        # required
+        # ------------------------------
+        # time of desired approximation
+        self.t = self.ctx.convert(t)
+
+        # optional
+        # ------------------------------
+
+        # empirical relationships used here based on a linear fit of
+        # requested and delivered dps for exponentially decaying time
+        # functions for requested dps up to 512.
+
+        if 'degree' in kwargs:
+            self.degree = kwargs['degree']
+            self.dps_goal = int(1.38*self.degree)
+        else:
+            self.dps_goal = int(2.93*self.ctx.dps)
+            self.degree = max(16, self.dps_goal)
+
+        # _coeff routine requires even degree
+        if self.degree % 2 > 0:
+            self.degree += 1
+
+        M = self.degree
+
+        # this is adjusting the dps of the calling context
+        # hopefully the caller doesn't monkey around with it
+        # between calling this routine and calc_time_domain_solution()
+        self.dps_orig = self.ctx.dps
+        self.ctx.dps = self.dps_goal
+
+        self.V = self._coeff()
+        self.p = self.ctx.matrix(self.ctx.arange(1, M+1))*self.ctx.ln2/self.t
+
+        # NB: p is real (mpf)
+
+    def _coeff(self):
+        r"""Salzer summation weights (aka, "Stehfest coefficients")
+        only depend on the approximation order (M) and the precision"""
+
+        M = self.degree
+        M2 = int(M/2)  # checked earlier that M is even
+
+        V = self.ctx.matrix(M, 1)
+
+        # Salzer summation weights
+        # get very large in magnitude and oscillate in sign,
+        # if the precision is not high enough, there will be
+        # catastrophic cancellation
+        for k in range(1, M+1):
+            z = self.ctx.matrix(min(k, M2)+1, 1)
+            for j in range(int((k+1)/2), min(k, M2)+1):
+                z[j] = (self.ctx.power(j, M2)*self.ctx.fac(2*j)/
+                        (self.ctx.fac(M2-j)*self.ctx.fac(j)*
+                         self.ctx.fac(j-1)*self.ctx.fac(k-j)*
+                         self.ctx.fac(2*j-k)))
+            V[k-1] = self.ctx.power(-1, k+M2)*self.ctx.fsum(z)
+
+        return V
+
+    def calc_time_domain_solution(self, fp, t, manual_prec=False):
+        r"""Compute time-domain Stehfest algorithm solution.
+
+        .. math ::
+
+            f(t,M) = \frac{\log 2}{t} \sum_{k=1}^{M} V_k \bar{f}\left(
+            p_k \right)
+
+        where
+
+        .. math ::
+
+            V_k = (-1)^{k + N/2} \sum^{\min(k,N/2)}_{i=\lfloor(k+1)/2 \rfloor}
+            \frac{i^{\frac{N}{2}}(2i)!}{\left(\frac{N}{2}-i \right)! \, i! \,
+            \left(i-1 \right)! \, \left(k-i\right)! \, \left(2i-k \right)!}
+
+        As the degree increases, the abscissa (`p_k`) only increase
+        linearly towards `\infty`, but the Stehfest coefficients
+        (`V_k`) alternate in sign and increase rapidly in sign,
+        requiring high precision to prevent overflow or loss of
+        significance when evaluating the sum.
+
+        **References**
+
+        1. Widder, D. (1941). *The Laplace Transform*. Princeton.
+        2. Stehfest, H. (1970). Algorithm 368: numerical inversion of
+           Laplace transforms. *Communications of the ACM* 13(1):47-49,
+           http://dx.doi.org/10.1145/361953.361969
+
+        """
+
+        # required
+        self.t = self.ctx.convert(t)
+
+        # assume fp was computed from p matrix returned from
+        # calc_laplace_parameter(), so is already
+        # a list or matrix of mpmath 'mpf' types
+
+        result = self.ctx.fdot(self.V, fp)*self.ctx.ln2/self.t
+
+        # setting dps back to value when calc_laplace_parameter was called
+        if not manual_prec:
+            self.ctx.dps = self.dps_orig
+
+        # ignore any small imaginary part
+        return result.real
+
+
+# ****************************************
+
+class deHoog(InverseLaplaceTransform):
+
+    def calc_laplace_parameter(self, t, **kwargs):
+        r"""the de Hoog, Knight & Stokes algorithm is an
+        accelerated form of the Fourier series numerical
+        inverse Laplace transform algorithms.
+
+        .. math ::
+
+            p_k = \gamma + \frac{jk}{T} \qquad 0 \le k < 2M+1
+
+        where
+
+        .. math ::
+
+            \gamma = \alpha - \frac{\log \mathrm{tol}}{2T},
+
+        `j=\sqrt{-1}`, `T = 2t_\mathrm{max}` is a scaled time,
+        `\alpha=10^{-\mathrm{dps\_goal}}` is the real part of the
+        rightmost pole or singularity, which is chosen based on the
+        desired accuracy (assuming the rightmost singularity is 0),
+        and `\mathrm{tol}=10\alpha` is the desired tolerance, which is
+        chosen in relation to `\alpha`.`
+
+        When increasing the degree, the abscissa increase towards
+        `j\infty`, but more slowly than the fixed Talbot
+        algorithm. The de Hoog et al. algorithm typically does better
+        with oscillatory functions of time, and less well-behaved
+        functions. The method tends to be slower than the Talbot and
+        Stehfest algorithsm, especially so at very high precision
+        (e.g., `>500` digits precision).
+
+        """
+
+        # required
+        # ------------------------------
+        self.t = self.ctx.convert(t)
+
+        # optional
+        # ------------------------------
+        self.tmax = kwargs.get('tmax', self.t)
+
+        # empirical relationships used here based on a linear fit of
+        # requested and delivered dps for exponentially decaying time
+        # functions for requested dps up to 512.
+
+        if 'degree' in kwargs:
+            self.degree = kwargs['degree']
+            self.dps_goal = int(1.38*self.degree)
+        else:
+            self.dps_goal = int(self.ctx.dps*1.36)
+            self.degree = max(10, self.dps_goal)
+
+        # 2*M+1 terms in approximation
+        M = self.degree
+
+        # adjust alpha component of abscissa of convergence for higher
+        # precision
+        tmp = self.ctx.power(10.0, -self.dps_goal)
+        self.alpha = self.ctx.convert(kwargs.get('alpha', tmp))
+
+        # desired tolerance (here simply related to alpha)
+        self.tol = self.ctx.convert(kwargs.get('tol', self.alpha*10.0))
+        self.np = 2*self.degree+1  # number of terms in approximation
+
+        # this is adjusting the dps of the calling context
+        # hopefully the caller doesn't monkey around with it
+        # between calling this routine and calc_time_domain_solution()
+        self.dps_orig = self.ctx.dps
+        self.ctx.dps = self.dps_goal
+
+        # scaling factor (likely tun-able, but 2 is typical)
+        self.scale = kwargs.get('scale', 2)
+        self.T = self.ctx.convert(kwargs.get('T', self.scale*self.tmax))
+
+        self.p = self.ctx.matrix(2*M+1, 1)
+        self.gamma = self.alpha - self.ctx.log(self.tol)/(self.scale*self.T)
+        self.p = (self.gamma + self.ctx.pi*
+                  self.ctx.matrix(self.ctx.arange(self.np))/self.T*1j)
+
+        # NB: p is complex (mpc)
+
+    def calc_time_domain_solution(self, fp, t, manual_prec=False):
+        r"""Calculate time-domain solution for
+        de Hoog, Knight & Stokes algorithm.
+
+        The un-accelerated Fourier series approach is:
+
+        .. math ::
+
+            f(t,2M+1) = \frac{e^{\gamma t}}{T} \sum_{k=0}^{2M}{}^{'}
+            \Re\left[\bar{f}\left( p_k \right)
+            e^{i\pi t/T} \right],
+
+        where the prime on the summation indicates the first term is halved.
+
+        This simplistic approach requires so many function evaluations
+        that it is not practical. Non-linear acceleration is
+        accomplished via Pade-approximation and an analytic expression
+        for the remainder of the continued fraction. See the original
+        paper (reference 2 below) a detailed description of the
+        numerical approach.
+
+        **References**
+
+        1. Davies, B. (2005). *Integral Transforms and their
+           Applications*, Third Edition. Springer.
+        2. de Hoog, F., J. Knight, A. Stokes (1982). An improved
+           method for numerical inversion of Laplace transforms. *SIAM
+           Journal of Scientific and Statistical Computing* 3:357-366,
+           http://dx.doi.org/10.1137/0903022
+
+        """
+
+        M = self.degree
+        np = self.np
+        T = self.T
+
+        self.t = self.ctx.convert(t)
+
+        # would it be useful to try re-using
+        # space between e&q and A&B?
+        e = self.ctx.zeros(np, M+1)
+        q = self.ctx.matrix(2*M, M)
+        d = self.ctx.matrix(np, 1)
+        A = self.ctx.zeros(np+1, 1)
+        B = self.ctx.ones(np+1, 1)
+
+        # initialize Q-D table
+        e[:, 0] = 0.0 + 0j
+        q[0, 0] = fp[1]/(fp[0]/2)
+        for i in range(1, 2*M):
+            q[i, 0] = fp[i+1]/fp[i]
+
+        # rhombus rule for filling triangular Q-D table (e & q)
+        for r in range(1, M+1):
+            # start with e, column 1, 0:2*M-2
+            mr = 2*(M-r) + 1
+            e[0:mr, r] = q[1:mr+1, r-1] - q[0:mr, r-1] + e[1:mr+1, r-1]
+            if not r == M:
+                rq = r+1
+                mr = 2*(M-rq)+1 + 2
+                for i in range(mr):
+                    q[i, rq-1] = q[i+1, rq-2]*e[i+1, rq-1]/e[i, rq-1]
+
+        # build up continued fraction coefficients (d)
+        d[0] = fp[0]/2
+        for r in range(1, M+1):
+            d[2*r-1] = -q[0, r-1]  # even terms
+            d[2*r]   = -e[0, r]    # odd terms
+
+        # seed A and B for recurrence
+        A[0] = 0.0 + 0.0j
+        A[1] = d[0]
+        B[0:2] = 1.0 + 0.0j
+
+        # base of the power series
+        z = self.ctx.expjpi(self.t/T)  # i*pi is already in fcn
+
+        # coefficients of Pade approximation (A & B)
+        # using recurrence for all but last term
+        for i in range(1, 2*M):
+            A[i+1] = A[i] + d[i]*A[i-1]*z
+            B[i+1] = B[i] + d[i]*B[i-1]*z
+
+        # "improved remainder" to continued fraction
+        brem = (1 + (d[2*M-1] - d[2*M])*z)/2
+        # powm1(x,y) computes x^y - 1 more accurately near zero
+        rem = brem*self.ctx.powm1(1 + d[2*M]*z/brem,
+                                  self.ctx.fraction(1, 2))
+
+        # last term of recurrence using new remainder
+        A[np] = A[2*M] + rem*A[2*M-1]
+        B[np] = B[2*M] + rem*B[2*M-1]
+
+        # diagonal Pade approximation
+        # F=A/B represents accelerated trapezoid rule
+        result = self.ctx.exp(self.gamma*self.t)/T*(A[np]/B[np]).real
+
+        # setting dps back to value when calc_laplace_parameter was called
+        if not manual_prec:
+            self.ctx.dps = self.dps_orig
+
+        return result
+
+
+# ****************************************
+
+class Cohen(InverseLaplaceTransform):
+
+    def calc_laplace_parameter(self, t, **kwargs):
+        r"""The Cohen algorithm accelerates the convergence of the nearly
+        alternating series resulting from the application of the trapezoidal
+        rule to the Bromwich contour inversion integral.
+
+        .. math ::
+
+            p_k = \frac{\gamma}{2 t} + \frac{\pi i k}{t} \qquad 0 \le k < M
+
+        where
+
+        .. math ::
+
+            \gamma = \frac{2}{3} (d + \log(10) + \log(2 t)),
+
+        `d = \mathrm{dps\_goal}`, which is chosen based on the desired
+        accuracy using the method developed in [1] to improve numerical
+        stability. The Cohen algorithm shows robustness similar to the de Hoog
+        et al. algorithm, but it is faster than the fixed Talbot algorithm.
+
+        **Optional arguments**
+
+        *degree*
+            integer order of the approximation (M = number of terms)
+        *alpha*
+            abscissa for `p_0` (controls the discretization error)
+
+        The working precision will be increased according to a rule of
+        thumb. If 'degree' is not specified, the working precision and
+        degree are chosen to hopefully achieve the dps of the calling
+        context. If 'degree' is specified, the working precision is
+        chosen to achieve maximum resulting precision for the
+        specified degree.
+
+        **References**
+
+        1. P. Glasserman, J. Ruiz-Mata (2006). Computing the credit loss
+        distribution in the Gaussian copula model: a comparison of methods.
+        *Journal of Credit Risk* 2(4):33-66, 10.21314/JCR.2006.057
+
+        """
+        self.t = self.ctx.convert(t)
+
+        if 'degree' in kwargs:
+            self.degree = kwargs['degree']
+            self.dps_goal = int(1.5 * self.degree)
+        else:
+            self.dps_goal = int(self.ctx.dps * 1.74)
+            self.degree = max(22, int(1.31 * self.dps_goal))
+
+        M = self.degree + 1
+
+        # this is adjusting the dps of the calling context hopefully
+        # the caller doesn't monkey around with it between calling
+        # this routine and calc_time_domain_solution()
+        self.dps_orig = self.ctx.dps
+        self.ctx.dps = self.dps_goal
+
+        ttwo = 2 * self.t
+        tmp = self.ctx.dps * self.ctx.log(10) + self.ctx.log(ttwo)
+        tmp = self.ctx.fraction(2, 3) * tmp
+        self.alpha = self.ctx.convert(kwargs.get('alpha', tmp))
+
+        # all but time-dependent part of p
+        a_t = self.alpha / ttwo
+        p_t = self.ctx.pi * 1j / self.t
+
+        self.p = self.ctx.matrix(M, 1)
+        self.p[0] = a_t
+
+        for i in range(1, M):
+            self.p[i] = a_t + i * p_t
+
+    def calc_time_domain_solution(self, fp, t, manual_prec=False):
+        r"""Calculate time-domain solution for Cohen algorithm.
+
+        The accelerated nearly alternating series is:
+
+        .. math ::
+
+            f(t, M) = \frac{e^{\gamma / 2}}{t} \left[\frac{1}{2}
+            \Re\left(\bar{f}\left(\frac{\gamma}{2t}\right) \right) -
+            \sum_{k=0}^{M-1}\frac{c_{M,k}}{d_M}\Re\left(\bar{f}
+            \left(\frac{\gamma + 2(k+1) \pi i}{2t}\right)\right)\right],
+
+        where coefficients `\frac{c_{M, k}}{d_M}` are described in [1].
+
+        1. H. Cohen, F. Rodriguez Villegas, D. Zagier (2000). Convergence
+        acceleration of alternating series. *Experiment. Math* 9(1):3-12
+
+        """
+        self.t = self.ctx.convert(t)
+
+        n = self.degree
+        M = n + 1
+
+        A = self.ctx.matrix(M, 1)
+        for i in range(M):
+            A[i] = fp[i].real
+
+        d = (3 + self.ctx.sqrt(8)) ** n
+        d = (d + 1 / d) / 2
+        b = -self.ctx.one
+        c = -d
+        s = 0
+
+        for k in range(n):
+            c = b - c
+            s = s + c * A[k + 1]
+            b = 2 * (k + n) * (k - n) * b / ((2 * k + 1) * (k + self.ctx.one))
+
+        result = self.ctx.exp(self.alpha / 2) / self.t * (A[0] / 2 - s / d)
+
+        # setting dps back to value when calc_laplace_parameter was
+        # called, unless flag is set.
+        if not manual_prec:
+            self.ctx.dps = self.dps_orig
+
+        return result
+
+
+# ****************************************
+
+class LaplaceTransformInversionMethods(object):
+    def __init__(ctx, *args, **kwargs):
+        ctx._fixed_talbot = FixedTalbot(ctx)
+        ctx._stehfest = Stehfest(ctx)
+        ctx._de_hoog = deHoog(ctx)
+        ctx._cohen = Cohen(ctx)
+
+    def invertlaplace(ctx, f, t, **kwargs):
+        r"""Computes the numerical inverse Laplace transform for a
+        Laplace-space function at a given time.  The function being
+        evaluated is assumed to be a real-valued function of time.
+
+        The user must supply a Laplace-space function `\bar{f}(p)`,
+        and a desired time at which to estimate the time-domain
+        solution `f(t)`.
+
+        A few basic examples of Laplace-space functions with known
+        inverses (see references [1,2]) :
+
+        .. math ::
+
+            \mathcal{L}\left\lbrace f(t) \right\rbrace=\bar{f}(p)
+
+        .. math ::
+
+            \mathcal{L}^{-1}\left\lbrace \bar{f}(p) \right\rbrace = f(t)
+
+        .. math ::
+
+            \bar{f}(p) = \frac{1}{(p+1)^2}
+
+        .. math ::
+
+            f(t) = t e^{-t}
+
+        >>> from mpmath import *
+        >>> mp.dps = 15; mp.pretty = True
+        >>> tt = [0.001, 0.01, 0.1, 1, 10]
+        >>> fp = lambda p: 1/(p+1)**2
+        >>> ft = lambda t: t*exp(-t)
+        >>> ft(tt[0]),ft(tt[0])-invertlaplace(fp,tt[0],method='talbot')
+        (0.000999000499833375, 8.57923043561212e-20)
+        >>> ft(tt[1]),ft(tt[1])-invertlaplace(fp,tt[1],method='talbot')
+        (0.00990049833749168, 3.27007646698047e-19)
+        >>> ft(tt[2]),ft(tt[2])-invertlaplace(fp,tt[2],method='talbot')
+        (0.090483741803596, -1.75215800052168e-18)
+        >>> ft(tt[3]),ft(tt[3])-invertlaplace(fp,tt[3],method='talbot')
+        (0.367879441171442, 1.2428864009344e-17)
+        >>> ft(tt[4]),ft(tt[4])-invertlaplace(fp,tt[4],method='talbot')
+        (0.000453999297624849, 4.04513489306658e-20)
+
+        The methods also work for higher precision:
+
+        >>> mp.dps = 100; mp.pretty = True
+        >>> nstr(ft(tt[0]),15),nstr(ft(tt[0])-invertlaplace(fp,tt[0],method='talbot'),15)
+        ('0.000999000499833375', '-4.96868310693356e-105')
+        >>> nstr(ft(tt[1]),15),nstr(ft(tt[1])-invertlaplace(fp,tt[1],method='talbot'),15)
+        ('0.00990049833749168', '1.23032291513122e-104')
+
+        .. math ::
+
+            \bar{f}(p) = \frac{1}{p^2+1}
+
+        .. math ::
+
+            f(t) = \mathrm{J}_0(t)
+
+        >>> mp.dps = 15; mp.pretty = True
+        >>> fp = lambda p: 1/sqrt(p*p + 1)
+        >>> ft = lambda t: besselj(0,t)
+        >>> ft(tt[0]),ft(tt[0])-invertlaplace(fp,tt[0],method='dehoog')
+        (0.999999750000016, -6.09717765032273e-18)
+        >>> ft(tt[1]),ft(tt[1])-invertlaplace(fp,tt[1],method='dehoog')
+        (0.99997500015625, -5.61756281076169e-17)
+
+        .. math ::
+
+            \bar{f}(p) = \frac{\log p}{p}
+
+        .. math ::
+
+            f(t) = -\gamma -\log t
+
+        >>> mp.dps = 15; mp.pretty = True
+        >>> fp = lambda p: log(p)/p
+        >>> ft = lambda t: -euler-log(t)
+        >>> ft(tt[0]),ft(tt[0])-invertlaplace(fp,tt[0],method='stehfest')
+        (6.3305396140806, -1.92126634837863e-16)
+        >>> ft(tt[1]),ft(tt[1])-invertlaplace(fp,tt[1],method='stehfest')
+        (4.02795452108656, -4.81486093200704e-16)
+
+        **Options**
+
+        :func:`~mpmath.invertlaplace` recognizes the following optional
+        keywords valid for all methods:
+
+        *method*
+            Chooses numerical inverse Laplace transform algorithm
+            (described below).
+        *degree*
+            Number of terms used in the approximation
+
+        **Algorithms**
+
+        Mpmath implements four numerical inverse Laplace transform
+        algorithms, attributed to: Talbot, Stehfest, and de Hoog,
+        Knight and Stokes. These can be selected by using
+        *method='talbot'*, *method='stehfest'*, *method='dehoog'* or
+        *method='cohen'* or by passing the classes *method=FixedTalbot*,
+        *method=Stehfest*, *method=deHoog*, or *method=Cohen*. The functions
+        :func:`~mpmath.invlaptalbot`, :func:`~mpmath.invlapstehfest`,
+        :func:`~mpmath.invlapdehoog`, and :func:`~mpmath.invlapcohen`
+        are also available as shortcuts.
+
+        All four algorithms implement a heuristic balance between the
+        requested precision and the precision used internally for the
+        calculations. This has been tuned for a typical exponentially
+        decaying function and precision up to few hundred decimal
+        digits.
+
+        The Laplace transform converts the variable time (i.e., along
+        a line) into a parameter given by the right half of the
+        complex `p`-plane.  Singularities, poles, and branch cuts in
+        the complex `p`-plane contain all the information regarding
+        the time behavior of the corresponding function. Any numerical
+        method must therefore sample `p`-plane "close enough" to the
+        singularities to accurately characterize them, while not
+        getting too close to have catastrophic cancellation, overflow,
+        or underflow issues. Most significantly, if one or more of the
+        singularities in the `p`-plane is not on the left side of the
+        Bromwich contour, its effects will be left out of the computed
+        solution, and the answer will be completely wrong.
+
+        *Talbot*
+
+        The fixed Talbot method is high accuracy and fast, but the
+        method can catastrophically fail for certain classes of time-domain
+        behavior, including a Heaviside step function for positive
+        time (e.g., `H(t-2)`), or some oscillatory behaviors. The
+        Talbot method usually has adjustable parameters, but the
+        "fixed" variety implemented here does not. This method
+        deforms the Bromwich integral contour in the shape of a
+        parabola towards `-\infty`, which leads to problems
+        when the solution has a decaying exponential in it (e.g., a
+        Heaviside step function is equivalent to multiplying by a
+        decaying exponential in Laplace space).
+
+        *Stehfest*
+
+        The Stehfest algorithm only uses abscissa along the real axis
+        of the complex `p`-plane to estimate the time-domain
+        function. Oscillatory time-domain functions have poles away
+        from the real axis, so this method does not work well with
+        oscillatory functions, especially high-frequency ones. This
+        method also depends on summation of terms in a series that
+        grows very large, and will have catastrophic cancellation
+        during summation if the working precision is too low.
+
+        *de Hoog et al.*
+
+        The de Hoog, Knight, and Stokes method is essentially a
+        Fourier-series quadrature-type approximation to the Bromwich
+        contour integral, with non-linear series acceleration and an
+        analytical expression for the remainder term. This method is
+        typically one of the most robust. This method also involves the
+        greatest amount of overhead, so it is typically the slowest of the
+        four methods at high precision.
+
+        *Cohen*
+
+        The Cohen method is a trapezoidal rule approximation to the Bromwich
+        contour integral, with linear acceleration for alternating
+        series. This method is as robust as the de Hoog et al method and the
+        fastest of the four methods at high precision, and is therefore the
+        default method.
+
+        **Singularities**
+
+        All numerical inverse Laplace transform methods have problems
+        at large time when the Laplace-space function has poles,
+        singularities, or branch cuts to the right of the origin in
+        the complex plane. For simple poles in `\bar{f}(p)` at the
+        `p`-plane origin, the time function is constant in time (e.g.,
+        `\mathcal{L}\left\lbrace 1 \right\rbrace=1/p` has a pole at
+        `p=0`). A pole in `\bar{f}(p)` to the left of the origin is a
+        decreasing function of time (e.g., `\mathcal{L}\left\lbrace
+        e^{-t/2} \right\rbrace=1/(p+1/2)` has a pole at `p=-1/2`), and
+        a pole to the right of the origin leads to an increasing
+        function in time (e.g., `\mathcal{L}\left\lbrace t e^{t/4}
+        \right\rbrace = 1/(p-1/4)^2` has a pole at `p=1/4`).  When
+        singularities occur off the real `p` axis, the time-domain
+        function is oscillatory. For example `\mathcal{L}\left\lbrace
+        \mathrm{J}_0(t) \right\rbrace=1/\sqrt{p^2+1}` has a branch cut
+        starting at `p=j=\sqrt{-1}` and is a decaying oscillatory
+        function, This range of behaviors is illustrated in Duffy [3]
+        Figure 4.10.4, p. 228.
+
+        In general as `p \rightarrow \infty` `t \rightarrow 0` and
+        vice-versa. All numerical inverse Laplace transform methods
+        require their abscissa to shift closer to the origin for
+        larger times. If the abscissa shift left of the rightmost
+        singularity in the Laplace domain, the answer will be
+        completely wrong (the effect of singularities to the right of
+        the Bromwich contour are not included in the results).
+
+        For example, the following exponentially growing function has
+        a pole at `p=3`:
+
+        .. math ::
+
+            \bar{f}(p)=\frac{1}{p^2-9}
+
+        .. math ::
+
+            f(t)=\frac{1}{3}\sinh 3t
+
+        >>> mp.dps = 15; mp.pretty = True
+        >>> fp = lambda p: 1/(p*p-9)
+        >>> ft = lambda t: sinh(3*t)/3
+        >>> tt = [0.01,0.1,1.0,10.0]
+        >>> ft(tt[0]),invertlaplace(fp,tt[0],method='talbot')
+        (0.0100015000675014, 0.0100015000675014)
+        >>> ft(tt[1]),invertlaplace(fp,tt[1],method='talbot')
+        (0.101506764482381, 0.101506764482381)
+        >>> ft(tt[2]),invertlaplace(fp,tt[2],method='talbot')
+        (3.33929164246997, 3.33929164246997)
+        >>> ft(tt[3]),invertlaplace(fp,tt[3],method='talbot')
+        (1781079096920.74, -1.61331069624091e-14)
+
+        **References**
+
+        1. [DLMF]_ section 1.14 (http://dlmf.nist.gov/1.14T4)
+        2. Cohen, A.M. (2007). Numerical Methods for Laplace Transform
+           Inversion, Springer.
+        3. Duffy, D.G. (1998). Advanced Engineering Mathematics, CRC Press.
+
+        **Numerical Inverse Laplace Transform Reviews**
+
+        1. Bellman, R., R.E. Kalaba, J.A. Lockett (1966). *Numerical
+           inversion of the Laplace transform: Applications to Biology,
+           Economics, Engineering, and Physics*. Elsevier.
+        2. Davies, B., B. Martin (1979). Numerical inversion of the
+           Laplace transform: a survey and comparison of methods. *Journal
+           of Computational Physics* 33:1-32,
+           http://dx.doi.org/10.1016/0021-9991(79)90025-1
+        3. Duffy, D.G. (1993). On the numerical inversion of Laplace
+           transforms: Comparison of three new methods on characteristic
+           problems from applications. *ACM Transactions on Mathematical
+           Software* 19(3):333-359, http://dx.doi.org/10.1145/155743.155788
+        4. Kuhlman, K.L., (2013). Review of Inverse Laplace Transform
+           Algorithms for Laplace-Space Numerical Approaches, *Numerical
+           Algorithms*, 63(2):339-355.
+           http://dx.doi.org/10.1007/s11075-012-9625-3
+
+        """
+
+        rule = kwargs.get('method', 'cohen')
+        if type(rule) is str:
+            lrule = rule.lower()
+            if lrule == 'talbot':
+                rule = ctx._fixed_talbot
+            elif lrule == 'stehfest':
+                rule = ctx._stehfest
+            elif lrule == 'dehoog':
+                rule = ctx._de_hoog
+            elif rule == 'cohen':
+                rule = ctx._cohen
+            else:
+                raise ValueError("unknown invlap algorithm: %s" % rule)
+        else:
+            rule = rule(ctx)
+
+        # determine the vector of Laplace-space parameter
+        # needed for the requested method and desired time
+        rule.calc_laplace_parameter(t, **kwargs)
+
+        # compute the Laplace-space function evalutations
+        # at the required abscissa.
+        fp = [f(p) for p in rule.p]
+
+        # compute the time-domain solution from the
+        # Laplace-space function evaluations
+        return rule.calc_time_domain_solution(fp, t)
+
+    # shortcuts for the above function for specific methods
+    def invlaptalbot(ctx, *args, **kwargs):
+        kwargs['method'] = 'talbot'
+        return ctx.invertlaplace(*args, **kwargs)
+
+    def invlapstehfest(ctx, *args, **kwargs):
+        kwargs['method'] = 'stehfest'
+        return ctx.invertlaplace(*args, **kwargs)
+
+    def invlapdehoog(ctx, *args, **kwargs):
+        kwargs['method'] = 'dehoog'
+        return ctx.invertlaplace(*args, **kwargs)
+
+    def invlapcohen(ctx, *args, **kwargs):
+        kwargs['method'] = 'cohen'
+        return ctx.invertlaplace(*args, **kwargs)
+
+
+# ****************************************
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()

tuning-competition-baseline/.venv/lib/python3.11/site-packages/mpmath/functions/orthogonal.py

@@ -0,0 +1,493 @@
+from .functions import defun, defun_wrapped
+
+def _hermite_param(ctx, n, z, parabolic_cylinder):
+    """
+    Combined calculation of the Hermite polynomial H_n(z) (and its
+    generalization to complex n) and the parabolic cylinder
+    function D.
+    """
+    n, ntyp = ctx._convert_param(n)
+    z = ctx.convert(z)
+    q = -ctx.mpq_1_2
+    # For re(z) > 0, 2F0 -- http://functions.wolfram.com/
+    #     HypergeometricFunctions/HermiteHGeneral/06/02/0009/
+    # Otherwise, there is a reflection formula
+    # 2F0 + http://functions.wolfram.com/HypergeometricFunctions/
+    #           HermiteHGeneral/16/01/01/0006/
+    #
+    # TODO:
+    # An alternative would be to use
+    # http://functions.wolfram.com/HypergeometricFunctions/
+    #     HermiteHGeneral/06/02/0006/
+    #
+    # Also, the 1F1 expansion
+    # http://functions.wolfram.com/HypergeometricFunctions/
+    #     HermiteHGeneral/26/01/02/0001/
+    # should probably be used for tiny z
+    if not z:
+        T1 = [2, ctx.pi], [n, 0.5], [], [q*(n-1)], [], [], 0
+        if parabolic_cylinder:
+            T1[1][0] += q*n
+        return T1,
+    can_use_2f0 = ctx.isnpint(-n) or ctx.re(z) > 0 or \
+        (ctx.re(z) == 0 and ctx.im(z) > 0)
+    expprec = ctx.prec*4 + 20
+    if parabolic_cylinder:
+        u = ctx.fmul(ctx.fmul(z,z,prec=expprec), -0.25, exact=True)
+        w = ctx.fmul(z, ctx.sqrt(0.5,prec=expprec), prec=expprec)
+    else:
+        w = z
+    w2 = ctx.fmul(w, w, prec=expprec)
+    rw2 = ctx.fdiv(1, w2, prec=expprec)
+    nrw2 = ctx.fneg(rw2, exact=True)
+    nw = ctx.fneg(w, exact=True)
+    if can_use_2f0:
+        T1 = [2, w], [n, n], [], [], [q*n, q*(n-1)], [], nrw2
+        terms = [T1]
+    else:
+        T1 = [2, nw], [n, n], [], [], [q*n, q*(n-1)], [], nrw2
+        T2 = [2, ctx.pi, nw], [n+2, 0.5, 1], [], [q*n], [q*(n-1)], [1-q], w2
+        terms = [T1,T2]
+    # Multiply by prefactor for D_n
+    if parabolic_cylinder:
+        expu = ctx.exp(u)
+        for i in range(len(terms)):
+            terms[i][1][0] += q*n
+            terms[i][0].append(expu)
+            terms[i][1].append(1)
+    return tuple(terms)
+
+@defun
+def hermite(ctx, n, z, **kwargs):
+    return ctx.hypercomb(lambda: _hermite_param(ctx, n, z, 0), [], **kwargs)
+
+@defun
+def pcfd(ctx, n, z, **kwargs):
+    r"""
+    Gives the parabolic cylinder function in Whittaker's notation
+    `D_n(z) = U(-n-1/2, z)` (see :func:`~mpmath.pcfu`).
+    It solves the differential equation
+
+    .. math ::
+
+        y'' + \left(n + \frac{1}{2} - \frac{1}{4} z^2\right) y = 0.
+
+    and can be represented in terms of Hermite polynomials
+    (see :func:`~mpmath.hermite`) as
+
+    .. math ::
+
+        D_n(z) = 2^{-n/2} e^{-z^2/4} H_n\left(\frac{z}{\sqrt{2}}\right).
+
+    **Plots**
+
+    .. literalinclude :: /plots/pcfd.py
+    .. image :: /plots/pcfd.png
+
+    **Examples**
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> pcfd(0,0); pcfd(1,0); pcfd(2,0); pcfd(3,0)
+        1.0
+        0.0
+        -1.0
+        0.0
+        >>> pcfd(4,0); pcfd(-3,0)
+        3.0
+        0.6266570686577501256039413
+        >>> pcfd('1/2', 2+3j)
+        (-5.363331161232920734849056 - 3.858877821790010714163487j)
+        >>> pcfd(2, -10)
+        1.374906442631438038871515e-9
+
+    Verifying the differential equation::
+
+        >>> n = mpf(2.5)
+        >>> y = lambda z: pcfd(n,z)
+        >>> z = 1.75
+        >>> chop(diff(y,z,2) + (n+0.5-0.25*z**2)*y(z))
+        0.0
+
+    Rational Taylor series expansion when `n` is an integer::
+
+        >>> taylor(lambda z: pcfd(5,z), 0, 7)
+        [0.0, 15.0, 0.0, -13.75, 0.0, 3.96875, 0.0, -0.6015625]
+
+    """
+    return ctx.hypercomb(lambda: _hermite_param(ctx, n, z, 1), [], **kwargs)
+
+@defun
+def pcfu(ctx, a, z, **kwargs):
+    r"""
+    Gives the parabolic cylinder function `U(a,z)`, which may be
+    defined for `\Re(z) > 0` in terms of the confluent
+    U-function (see :func:`~mpmath.hyperu`) by
+
+    .. math ::
+
+        U(a,z) = 2^{-\frac{1}{4}-\frac{a}{2}} e^{-\frac{1}{4} z^2}
+            U\left(\frac{a}{2}+\frac{1}{4},
+            \frac{1}{2}, \frac{1}{2}z^2\right)
+
+    or, for arbitrary `z`,
+
+    .. math ::
+
+        e^{-\frac{1}{4}z^2} U(a,z) =
+            U(a,0) \,_1F_1\left(-\tfrac{a}{2}+\tfrac{1}{4};
+            \tfrac{1}{2}; -\tfrac{1}{2}z^2\right) +
+            U'(a,0) z \,_1F_1\left(-\tfrac{a}{2}+\tfrac{3}{4};
+            \tfrac{3}{2}; -\tfrac{1}{2}z^2\right).
+
+    **Examples**
+
+    Connection to other functions::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> z = mpf(3)
+        >>> pcfu(0.5,z)
+        0.03210358129311151450551963
+        >>> sqrt(pi/2)*exp(z**2/4)*erfc(z/sqrt(2))
+        0.03210358129311151450551963
+        >>> pcfu(0.5,-z)
+        23.75012332835297233711255
+        >>> sqrt(pi/2)*exp(z**2/4)*erfc(-z/sqrt(2))
+        23.75012332835297233711255
+        >>> pcfu(0.5,-z)
+        23.75012332835297233711255
+        >>> sqrt(pi/2)*exp(z**2/4)*erfc(-z/sqrt(2))
+        23.75012332835297233711255
+
+    """
+    n, _ = ctx._convert_param(a)
+    return ctx.pcfd(-n-ctx.mpq_1_2, z)
+
+@defun
+def pcfv(ctx, a, z, **kwargs):
+    r"""
+    Gives the parabolic cylinder function `V(a,z)`, which can be
+    represented in terms of :func:`~mpmath.pcfu` as
+
+    .. math ::
+
+        V(a,z) = \frac{\Gamma(a+\tfrac{1}{2}) (U(a,-z)-\sin(\pi a) U(a,z)}{\pi}.
+
+    **Examples**
+
+    Wronskian relation between `U` and `V`::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> a, z = 2, 3
+        >>> pcfu(a,z)*diff(pcfv,(a,z),(0,1))-diff(pcfu,(a,z),(0,1))*pcfv(a,z)
+        0.7978845608028653558798921
+        >>> sqrt(2/pi)
+        0.7978845608028653558798921
+        >>> a, z = 2.5, 3
+        >>> pcfu(a,z)*diff(pcfv,(a,z),(0,1))-diff(pcfu,(a,z),(0,1))*pcfv(a,z)
+        0.7978845608028653558798921
+        >>> a, z = 0.25, -1
+        >>> pcfu(a,z)*diff(pcfv,(a,z),(0,1))-diff(pcfu,(a,z),(0,1))*pcfv(a,z)
+        0.7978845608028653558798921
+        >>> a, z = 2+1j, 2+3j
+        >>> chop(pcfu(a,z)*diff(pcfv,(a,z),(0,1))-diff(pcfu,(a,z),(0,1))*pcfv(a,z))
+        0.7978845608028653558798921
+
+    """
+    n, ntype = ctx._convert_param(a)
+    z = ctx.convert(z)
+    q = ctx.mpq_1_2
+    r = ctx.mpq_1_4
+    if ntype == 'Q' and ctx.isint(n*2):
+        # Faster for half-integers
+        def h():
+            jz = ctx.fmul(z, -1j, exact=True)
+            T1terms = _hermite_param(ctx, -n-q, z, 1)
+            T2terms = _hermite_param(ctx, n-q, jz, 1)
+            for T in T1terms:
+                T[0].append(1j)
+                T[1].append(1)
+                T[3].append(q-n)
+            u = ctx.expjpi((q*n-r)) * ctx.sqrt(2/ctx.pi)
+            for T in T2terms:
+                T[0].append(u)
+                T[1].append(1)
+            return T1terms + T2terms
+        v = ctx.hypercomb(h, [], **kwargs)
+        if ctx._is_real_type(n) and ctx._is_real_type(z):
+            v = ctx._re(v)
+        return v
+    else:
+        def h(n):
+            w = ctx.square_exp_arg(z, -0.25)
+            u = ctx.square_exp_arg(z, 0.5)
+            e = ctx.exp(w)
+            l = [ctx.pi, q, ctx.exp(w)]
+            Y1 = l, [-q, n*q+r, 1], [r-q*n], [], [q*n+r], [q], u
+            Y2 = l + [z], [-q, n*q-r, 1, 1], [1-r-q*n], [], [q*n+1-r], [1+q], u
+            c, s = ctx.cospi_sinpi(r+q*n)
+            Y1[0].append(s)
+            Y2[0].append(c)
+            for Y in (Y1, Y2):
+                Y[1].append(1)
+                Y[3].append(q-n)
+            return Y1, Y2
+        return ctx.hypercomb(h, [n], **kwargs)
+
+
+@defun
+def pcfw(ctx, a, z, **kwargs):
+    r"""
+    Gives the parabolic cylinder function `W(a,z)` defined in (DLMF 12.14).
+
+    **Examples**
+
+    Value at the origin::
+
+        >>> from mpmath import *
+        >>> mp.dps = 25; mp.pretty = True
+        >>> a = mpf(0.25)
+        >>> pcfw(a,0)
+        0.9722833245718180765617104
+        >>> power(2,-0.75)*sqrt(abs(gamma(0.25+0.5j*a)/gamma(0.75+0.5j*a)))
+        0.9722833245718180765617104
+        >>> diff(pcfw,(a,0),(0,1))
+        -0.5142533944210078966003624
+        >>> -power(2,-0.25)*sqrt(abs(gamma(0.75+0.5j*a)/gamma(0.25+0.5j*a)))
+        -0.5142533944210078966003624
+
+    """
+    n, _ = ctx._convert_param(a)
+    z = ctx.convert(z)
+    def terms():
+        phi2 = ctx.arg(ctx.gamma(0.5 + ctx.j*n))
+        phi2 = (ctx.loggamma(0.5+ctx.j*n) - ctx.loggamma(0.5-ctx.j*n))/2j
+        rho = ctx.pi/8 + 0.5*phi2
+        # XXX: cancellation computing k
+        k = ctx.sqrt(1 + ctx.exp(2*ctx.pi*n)) - ctx.exp(ctx.pi*n)
+        C = ctx.sqrt(k/2) * ctx.exp(0.25*ctx.pi*n)
+        yield C * ctx.expj(rho) * ctx.pcfu(ctx.j*n, z*ctx.expjpi(-0.25))
+        yield C * ctx.expj(-rho) * ctx.pcfu(-ctx.j*n, z*ctx.expjpi(0.25))
+    v = ctx.sum_accurately(terms)
+    if ctx._is_real_type(n) and ctx._is_real_type(z):
+        v = ctx._re(v)
+    return v
+
+"""
+Even/odd PCFs. Useful?
+
+@defun
+def pcfy1(ctx, a, z, **kwargs):
+    a, _ = ctx._convert_param(n)
+    z = ctx.convert(z)
+    def h():
+        w = ctx.square_exp_arg(z)
+        w1 = ctx.fmul(w, -0.25, exact=True)
+        w2 = ctx.fmul(w, 0.5, exact=True)
+        e = ctx.exp(w1)
+        return [e], [1], [], [], [ctx.mpq_1_2*a+ctx.mpq_1_4], [ctx.mpq_1_2], w2
+    return ctx.hypercomb(h, [], **kwargs)
+
+@defun
+def pcfy2(ctx, a, z, **kwargs):
+    a, _ = ctx._convert_param(n)
+    z = ctx.convert(z)
+    def h():
+        w = ctx.square_exp_arg(z)
+        w1 = ctx.fmul(w, -0.25, exact=True)
+        w2 = ctx.fmul(w, 0.5, exact=True)
+        e = ctx.exp(w1)
+        return [e, z], [1, 1], [], [], [ctx.mpq_1_2*a+ctx.mpq_3_4], \
+            [ctx.mpq_3_2], w2
+    return ctx.hypercomb(h, [], **kwargs)
+"""
+
+@defun_wrapped
+def gegenbauer(ctx, n, a, z, **kwargs):
+    # Special cases: a+0.5, a*2 poles
+    if ctx.isnpint(a):
+        return 0*(z+n)
+    if ctx.isnpint(a+0.5):
+        # TODO: something else is required here
+        # E.g.: gegenbauer(-2, -0.5, 3) == -12
+        if ctx.isnpint(n+1):
+            raise NotImplementedError("Gegenbauer function with two limits")
+        def h(a):
+            a2 = 2*a
+            T = [], [], [n+a2], [n+1, a2], [-n, n+a2], [a+0.5], 0.5*(1-z)
+            return [T]
+        return ctx.hypercomb(h, [a], **kwargs)
+    def h(n):
+        a2 = 2*a
+        T = [], [], [n+a2], [n+1, a2], [-n, n+a2], [a+0.5], 0.5*(1-z)
+        return [T]
+    return ctx.hypercomb(h, [n], **kwargs)
+
+@defun_wrapped
+def jacobi(ctx, n, a, b, x, **kwargs):
+    if not ctx.isnpint(a):
+        def h(n):
+            return (([], [], [a+n+1], [n+1, a+1], [-n, a+b+n+1], [a+1], (1-x)*0.5),)
+        return ctx.hypercomb(h, [n], **kwargs)
+    if not ctx.isint(b):
+        def h(n, a):
+            return (([], [], [-b], [n+1, -b-n], [-n, a+b+n+1], [b+1], (x+1)*0.5),)
+        return ctx.hypercomb(h, [n, a], **kwargs)
+    # XXX: determine appropriate limit
+    return ctx.binomial(n+a,n) * ctx.hyp2f1(-n,1+n+a+b,a+1,(1-x)/2, **kwargs)
+
+@defun_wrapped
+def laguerre(ctx, n, a, z, **kwargs):
+    # XXX: limits, poles
+    #if ctx.isnpint(n):
+    #    return 0*(a+z)
+    def h(a):
+        return (([], [], [a+n+1], [a+1, n+1], [-n], [a+1], z),)
+    return ctx.hypercomb(h, [a], **kwargs)
+
+@defun_wrapped
+def legendre(ctx, n, x, **kwargs):
+    if ctx.isint(n):
+        n = int(n)
+        # Accuracy near zeros
+        if (n + (n < 0)) & 1:
+            if not x:
+                return x
+            mag = ctx.mag(x)
+            if mag < -2*ctx.prec-10:
+                return x
+            if mag < -5:
+                ctx.prec += -mag
+    return ctx.hyp2f1(-n,n+1,1,(1-x)/2, **kwargs)
+
+@defun
+def legenp(ctx, n, m, z, type=2, **kwargs):
+    # Legendre function, 1st kind
+    n = ctx.convert(n)
+    m = ctx.convert(m)
+    # Faster
+    if not m:
+        return ctx.legendre(n, z, **kwargs)
+    # TODO: correct evaluation at singularities
+    if type == 2:
+        def h(n,m):
+            g = m*0.5
+            T = [1+z, 1-z], [g, -g], [], [1-m], [-n, n+1], [1-m], 0.5*(1-z)
+            return (T,)
+        return ctx.hypercomb(h, [n,m], **kwargs)
+    if type == 3:
+        def h(n,m):
+            g = m*0.5
+            T = [z+1, z-1], [g, -g], [], [1-m], [-n, n+1], [1-m], 0.5*(1-z)
+            return (T,)
+        return ctx.hypercomb(h, [n,m], **kwargs)
+    raise ValueError("requires type=2 or type=3")
+
+@defun
+def legenq(ctx, n, m, z, type=2, **kwargs):
+    # Legendre function, 2nd kind
+    n = ctx.convert(n)
+    m = ctx.convert(m)
+    z = ctx.convert(z)
+    if z in (1, -1):
+        #if ctx.isint(m):
+        #    return ctx.nan
+        #return ctx.inf  # unsigned
+        return ctx.nan
+    if type == 2:
+        def h(n, m):
+            cos, sin = ctx.cospi_sinpi(m)
+            s = 2 * sin / ctx.pi
+            c = cos
+            a = 1+z
+            b = 1-z
+            u = m/2
+            w = (1-z)/2
+            T1 = [s, c, a, b], [-1, 1, u, -u], [], [1-m], \
+                [-n, n+1], [1-m], w
+            T2 = [-s, a, b], [-1, -u, u], [n+m+1], [n-m+1, m+1], \
+                [-n, n+1], [m+1], w
+            return T1, T2
+        return ctx.hypercomb(h, [n, m], **kwargs)
+    if type == 3:
+        # The following is faster when there only is a single series
+        # Note: not valid for -1 < z < 0 (?)
+        if abs(z) > 1:
+            def h(n, m):
+                T1 = [ctx.expjpi(m), 2, ctx.pi, z, z-1, z+1], \
+                     [1, -n-1, 0.5, -n-m-1, 0.5*m, 0.5*m], \
+                     [n+m+1], [n+1.5], \
+                     [0.5*(2+n+m), 0.5*(1+n+m)], [n+1.5], z**(-2)
+                return [T1]
+            return ctx.hypercomb(h, [n, m], **kwargs)
+        else:
+            # not valid for 1 < z < inf ?
+            def h(n, m):
+                s = 2 * ctx.sinpi(m) / ctx.pi
+                c = ctx.expjpi(m)
+                a = 1+z
+                b = z-1
+                u = m/2
+                w = (1-z)/2
+                T1 = [s, c, a, b], [-1, 1, u, -u], [], [1-m], \
+                    [-n, n+1], [1-m], w
+                T2 = [-s, c, a, b], [-1, 1, -u, u], [n+m+1], [n-m+1, m+1], \
+                    [-n, n+1], [m+1], w
+                return T1, T2
+            return ctx.hypercomb(h, [n, m], **kwargs)
+    raise ValueError("requires type=2 or type=3")
+
+@defun_wrapped
+def chebyt(ctx, n, x, **kwargs):
+    if (not x) and ctx.isint(n) and int(ctx._re(n)) % 2 == 1:
+        return x * 0
+    return ctx.hyp2f1(-n,n,(1,2),(1-x)/2, **kwargs)
+
+@defun_wrapped
+def chebyu(ctx, n, x, **kwargs):
+    if (not x) and ctx.isint(n) and int(ctx._re(n)) % 2 == 1:
+        return x * 0
+    return (n+1) * ctx.hyp2f1(-n, n+2, (3,2), (1-x)/2, **kwargs)
+
+@defun
+def spherharm(ctx, l, m, theta, phi, **kwargs):
+    l = ctx.convert(l)
+    m = ctx.convert(m)
+    theta = ctx.convert(theta)
+    phi = ctx.convert(phi)
+    l_isint = ctx.isint(l)
+    l_natural = l_isint and l >= 0
+    m_isint = ctx.isint(m)
+    if l_isint and l < 0 and m_isint:
+        return ctx.spherharm(-(l+1), m, theta, phi, **kwargs)
+    if theta == 0 and m_isint and m < 0:
+        return ctx.zero * 1j
+    if l_natural and m_isint:
+        if abs(m) > l:
+            return ctx.zero * 1j
+        # http://functions.wolfram.com/Polynomials/
+        #     SphericalHarmonicY/26/01/02/0004/
+        def h(l,m):
+            absm = abs(m)
+            C = [-1, ctx.expj(m*phi),
+                 (2*l+1)*ctx.fac(l+absm)/ctx.pi/ctx.fac(l-absm),
+                 ctx.sin(theta)**2,
+                 ctx.fac(absm), 2]
+            P = [0.5*m*(ctx.sign(m)+1), 1, 0.5, 0.5*absm, -1, -absm-1]
+            return ((C, P, [], [], [absm-l, l+absm+1], [absm+1],
+                ctx.sin(0.5*theta)**2),)
+    else:
+        # http://functions.wolfram.com/HypergeometricFunctions/
+        #     SphericalHarmonicYGeneral/26/01/02/0001/
+        def h(l,m):
+            if ctx.isnpint(l-m+1) or ctx.isnpint(l+m+1) or ctx.isnpint(1-m):
+                return (([0], [-1], [], [], [], [], 0),)
+            cos, sin = ctx.cos_sin(0.5*theta)
+            C = [0.5*ctx.expj(m*phi), (2*l+1)/ctx.pi,
+                 ctx.gamma(l-m+1), ctx.gamma(l+m+1),
+                 cos**2, sin**2]
+            P = [1, 0.5, 0.5, -0.5, 0.5*m, -0.5*m]
+            return ((C, P, [], [1-m], [-l,l+1], [1-m], sin**2),)
+    return ctx.hypercomb(h, [l,m], **kwargs)

tuning-competition-baseline/.venv/lib/python3.11/site-packages/mpmath/matrices/eigen_symmetric.py

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

tuning-competition-baseline/.venv/lib/python3.11/site-packages/packaging-24.2.dist-info/LICENSE.APACHE

@@ -0,0 +1,177 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

tuning-competition-baseline/.venv/lib/python3.11/site-packages/packaging-24.2.dist-info/LICENSE.BSD

@@ -0,0 +1,23 @@
+Copyright (c) Donald Stufft and individual contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+
+    2. 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.
+
+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 HOLDER 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.

tuning-competition-baseline/.venv/lib/python3.11/site-packages/packaging-24.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.10.1
+Root-Is-Purelib: true
+Tag: py3-none-any

tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/idna/__pycache__/uts46data.cpython-311.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:41c236e9b167a346f261473ba48db901f00476843b03f377600d8c045836aacd
+size 163197

tuning-competition-baseline/.venv/lib/python3.11/site-packages/pip/_vendor/rich/__pycache__/_emoji_codes.cpython-311.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:23e69f8f33ae5e21ea90c0254f3b9874d5c2ff6a1a59cffa1496ea60619d0702
+size 208544

tuning-competition-baseline/.venv/lib/python3.11/site-packages/pybind11/__init__.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+import sys
+
+if sys.version_info < (3, 7):  # noqa: UP036
+    msg = "pybind11 does not support Python < 3.7. v2.12 was the last release supporting Python 3.6."
+    raise ImportError(msg)
+
+
+from ._version import __version__, version_info
+from .commands import get_cmake_dir, get_include, get_pkgconfig_dir
+
+__all__ = (
+    "version_info",
+    "__version__",
+    "get_include",
+    "get_cmake_dir",
+    "get_pkgconfig_dir",
+)

tuning-competition-baseline/.venv/lib/python3.11/site-packages/pybind11/__main__.py

@@ -0,0 +1,86 @@
+# pylint: disable=missing-function-docstring
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+import sysconfig
+
+from ._version import __version__
+from .commands import get_cmake_dir, get_include, get_pkgconfig_dir
+
+# This is the conditional used for os.path being posixpath
+if "posix" in sys.builtin_module_names:
+    from shlex import quote
+elif "nt" in sys.builtin_module_names:
+    # See https://github.com/mesonbuild/meson/blob/db22551ed9d2dd7889abea01cc1c7bba02bf1c75/mesonbuild/utils/universal.py#L1092-L1121
+    # and the original documents:
+    # https://docs.microsoft.com/en-us/cpp/c-language/parsing-c-command-line-arguments and
+    # https://blogs.msdn.microsoft.com/twistylittlepassagesallalike/2011/04/23/everyone-quotes-command-line-arguments-the-wrong-way/
+    UNSAFE = re.compile("[ \t\n\r]")
+
+    def quote(s: str) -> str:
+        if s and not UNSAFE.search(s):
+            return s
+
+        # Paths cannot contain a '"' on Windows, so we don't need to worry
+        # about nuanced counting here.
+        return f'"{s}\\"' if s.endswith("\\") else f'"{s}"'
+else:
+
+    def quote(s: str) -> str:
+        return s
+
+
+def print_includes() -> None:
+    dirs = [
+        sysconfig.get_path("include"),
+        sysconfig.get_path("platinclude"),
+        get_include(),
+    ]
+
+    # Make unique but preserve order
+    unique_dirs = []
+    for d in dirs:
+        if d and d not in unique_dirs:
+            unique_dirs.append(d)
+
+    print(" ".join(quote(f"-I{d}") for d in unique_dirs))
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=__version__,
+        help="Print the version and exit.",
+    )
+    parser.add_argument(
+        "--includes",
+        action="store_true",
+        help="Include flags for both pybind11 and Python headers.",
+    )
+    parser.add_argument(
+        "--cmakedir",
+        action="store_true",
+        help="Print the CMake module directory, ideal for setting -Dpybind11_ROOT in CMake.",
+    )
+    parser.add_argument(
+        "--pkgconfigdir",
+        action="store_true",
+        help="Print the pkgconfig directory, ideal for setting $PKG_CONFIG_PATH.",
+    )
+    args = parser.parse_args()
+    if not sys.argv[1:]:
+        parser.print_help()
+    if args.includes:
+        print_includes()
+    if args.cmakedir:
+        print(quote(get_cmake_dir()))
+    if args.pkgconfigdir:
+        print(quote(get_pkgconfig_dir()))
+
+
+if __name__ == "__main__":
+    main()