chebfun 0.4.4.1__tar.gz

chebfun-0.4.4.1/.gitignore

@@ -0,0 +1,39 @@
+*.py[cod]
+*.todo
+*.ini
+*~
+*/.ipynb_checkpoints/*
+
+# C extensions
+*.so
+
+# Packages
+*.egg
+*.egg-info
+dist
+build
+eggs
+parts
+bin
+var
+sdist
+develop-eggs
+.installed.cfg
+lib
+lib64
+
+# Installer logs
+pip-log.txt
+
+# Unit test / coverage reports
+.coverage
+.tox
+nosetests.xml
+lcov.info
+
+*.DS_Store
+*.dylib
+*.pyc
+.idea/
+docs/_*
+pdoc

chebfun-0.4.4.1/LICENSE.rst

@@ -0,0 +1,13 @@
+Copyright (c) 2016: Mark Richardson and other contributors:
+
+https://github.com/chebpy/chebpy/graphs/contributors
+
+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.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 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.

chebfun-0.4.4.1/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: chebfun
+Version: 0.4.4.1
+Summary: A Python implementation of Chebfun
+Project-URL: repository, https://github.com/chebpy/chebpy
+Author-email: Mark Richardson <mrichardson82@gmail.com>
+License-File: LICENSE.rst
+Requires-Python: >=3.10
+Requires-Dist: numpy>=2.0
+Provides-Extra: dev
+Requires-Dist: matplotlib==3.10.0; extra == 'dev'
+Requires-Dist: pre-commit>=4.2.0; extra == 'dev'
+Requires-Dist: pytest-cov>=6.2.1; extra == 'dev'
+Requires-Dist: pytest>=8.4.1; extra == 'dev'
+Description-Content-Type: text/x-rst
+
+================================================
+ChebPy - A Python implementation of Chebfun
+================================================
+
+.. image:: https://github.com/chebpy/chebpy/actions/workflows/unittest.yml/badge.svg
+    :target: https://github.com/chebpy/chebpy/actions/workflows/unittest.yml
+.. image:: https://coveralls.io/repos/github/chebpy/chebpy/badge.svg?branch=master
+    :target: https://coveralls.io/github/chebpy/chebpy?branch=master
+.. image:: https://img.shields.io/badge/python-%203.8_--%203.13-blue.svg?
+    :target: https://github.com/chebpy/chebpy/actions/workflows/unittest.yml
+.. image:: https://img.shields.io/conda/dn/conda-forge/chebfun?label=conda%20downloads
+    :target: https://anaconda.org/conda-forge/chebfun
+.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
+    :target: https://github.com/psf/black
+.. image:: https://mybinder.org/badge_logo.svg
+    :target: https://mybinder.org/v2/gh/chebpy/chebpy/v0.4.3?filepath=docs%2Fnotebook-getting-started.ipynb
+
+|
+
+
+Numerical computing with Chebyshev series approximations in Python.
+
+
+.. image:: docs/chebpy-readme-image1.png
+
+
+ChebPy is a Python implementation of `Chebfun <http://www.chebfun.org/>`_.
+
+- The software is licensed under a 3-Clause BSD License, see `LICENSE.rst <LICENSE.rst>`_.
+- For installation details, see `INSTALL.rst <INSTALL.rst>`_.
+- The code is documented in various files in the `docs <docs/>`_ folder.
+
+
+The figure above was generated with the following simple ChebPy code:
+
+.. code:: python
+
+	f = chebfun(lambda x: np.sin(x**2) + np.sin(x)**2, [0, 10])
+	g = chebfun(lambda x: np.exp(-(x-5)**2/10), [0, 10])
+	r = (f-g).roots()
+	ax = f.plot(); g.plot()
+	ax.plot(r, f(r), 'o')

chebfun-0.4.4.1/README.rst

@@ -0,0 +1,42 @@
+================================================
+ChebPy - A Python implementation of Chebfun
+================================================
+
+.. image:: https://github.com/chebpy/chebpy/actions/workflows/unittest.yml/badge.svg
+    :target: https://github.com/chebpy/chebpy/actions/workflows/unittest.yml
+.. image:: https://coveralls.io/repos/github/chebpy/chebpy/badge.svg?branch=master
+    :target: https://coveralls.io/github/chebpy/chebpy?branch=master
+.. image:: https://img.shields.io/badge/python-%203.8_--%203.13-blue.svg?
+    :target: https://github.com/chebpy/chebpy/actions/workflows/unittest.yml
+.. image:: https://img.shields.io/conda/dn/conda-forge/chebfun?label=conda%20downloads
+    :target: https://anaconda.org/conda-forge/chebfun
+.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
+    :target: https://github.com/psf/black
+.. image:: https://mybinder.org/badge_logo.svg
+    :target: https://mybinder.org/v2/gh/chebpy/chebpy/v0.4.3?filepath=docs%2Fnotebook-getting-started.ipynb
+
+|
+
+
+Numerical computing with Chebyshev series approximations in Python.
+
+
+.. image:: docs/chebpy-readme-image1.png
+
+
+ChebPy is a Python implementation of `Chebfun <http://www.chebfun.org/>`_.
+
+- The software is licensed under a 3-Clause BSD License, see `LICENSE.rst <LICENSE.rst>`_.
+- For installation details, see `INSTALL.rst <INSTALL.rst>`_.
+- The code is documented in various files in the `docs <docs/>`_ folder.
+
+
+The figure above was generated with the following simple ChebPy code:
+
+.. code:: python
+
+	f = chebfun(lambda x: np.sin(x**2) + np.sin(x)**2, [0, 10])
+	g = chebfun(lambda x: np.exp(-(x-5)**2/10), [0, 10])
+	r = (f-g).roots()
+	ax = f.plot(); g.plot()
+	ax.plot(r, f(r), 'o')

chebfun-0.4.4.1/chebpy/__init__.py

@@ -0,0 +1,4 @@
+__version__ = "0.4.3.3"
+
+from .api import chebfun, pwc
+from .core.settings import ChebPreferences as UserPreferences

chebfun-0.4.4.1/chebpy/api.py

@@ -0,0 +1,41 @@
+"""User-facing functions"""
+
+from .core.bndfun import Bndfun
+from .core.chebfun import Chebfun
+from .core.utilities import Domain
+from .core.settings import _preferences as prefs
+
+
+def chebfun(f=None, domain=None, n=None):
+    """Chebfun constructor"""
+    # chebfun()
+    if f is None:
+        return Chebfun.initempty()
+
+    domain = domain if domain is not None else prefs.domain
+
+    # chebfun(lambda x: f(x), ... )
+    if hasattr(f, "__call__"):
+        return Chebfun.initfun(f, domain, n)
+
+    # chebfun('x', ... )
+    if isinstance(f, str) and len(f) == 1 and f.isalpha():
+        if n:
+            return Chebfun.initfun(lambda x: x, domain, n)
+        else:
+            return Chebfun.initidentity(domain)
+
+    try:
+        # chebfun(3.14, ... ), chebfun('3.14', ... )
+        return Chebfun.initconst(float(f), domain)
+    except (OverflowError, ValueError):
+        raise ValueError(f"Unable to construct const function from {{{f}}}")
+
+
+def pwc(domain=[-1, 0, 1], values=[0, 1]):
+    """Initialise a piecewise-constant Chebfun"""
+    funs = []
+    intervals = [x for x in Domain(domain).intervals]
+    for interval, value in zip(intervals, values):
+        funs.append(Bndfun.initconst(value, interval))
+    return Chebfun(funs)

chebfun-0.4.4.1/chebpy/core/algorithms.py

@@ -0,0 +1,326 @@
+import warnings
+
+import numpy as np
+
+from .ffts import fft, ifft
+from .utilities import Interval, infnorm
+from .settings import _preferences as prefs
+from .decorators import preandpostprocess
+
+# supress numpy division and multiply warnings
+np.seterr(divide="ignore", invalid="ignore")
+
+# constants
+SPLITPOINT = -0.004849834917525
+
+
+# local helpers
+def find(x):
+    return np.where(x)[0]
+
+
+def rootsunit(ak, htol=None):
+    """Compute the roots of a funciton on [-1,1] using the coefficeints
+    in the associated Chebyshev series representation.
+
+    References
+    ----------
+    .. [1] I. J. Good, "The colleague matrix, a Chebyshev analogue of the
+        companion matrix", Quarterly Journal of Mathematics 12 (1961).
+
+    .. [2] J. A. Boyd, "Computing zeros on a real interval through
+        Chebyshev expansion and polynomial rootfinding", SIAM Journal on
+        Numerical Analysis 40 (2002).
+
+    .. [3] L. N. Trefethen, Approximation Theory and Approximation
+        Practice, SIAM, 2013, chapter 18.
+    """
+    htol = htol if htol is not None else 1e2 * prefs.eps
+    n = standard_chop(ak, tol=htol)
+    ak = ak[:n]
+
+    # if n > 50, we split and recurse
+    if n > 50:
+        chebpts = chebpts2(ak.size)
+        lmap = Interval(-1, SPLITPOINT)
+        rmap = Interval(SPLITPOINT, 1)
+        lpts = lmap(chebpts)
+        rpts = rmap(chebpts)
+        lval = clenshaw(lpts, ak)
+        rval = clenshaw(rpts, ak)
+        lcfs = vals2coeffs2(lval)
+        rcfs = vals2coeffs2(rval)
+        lrts = rootsunit(lcfs, 2 * htol)
+        rrts = rootsunit(rcfs, 2 * htol)
+        return np.append(lmap(lrts), rmap(rrts))
+
+    # trivial base case
+    if n <= 1:
+        return np.array([])
+
+    # nontrivial base case: either compute directly or solve
+    # a Colleague Matrix eigenvalue problem
+    if n == 2:
+        rts = np.array([-ak[0] / ak[1]])
+    elif n <= 50:
+        v = 0.5 * np.ones(n - 2)
+        C = np.diag(v, -1) + np.diag(v, 1)
+        C[0, 1] = 1
+        D = np.zeros(C.shape, dtype=ak.dtype)
+        D[-1, :] = ak[:-1]
+        E = C - 0.5 * 1.0 / ak[-1] * D
+        rts = np.linalg.eigvals(E)
+
+    # discard values with large imaginary part and treat the remaining
+    # ones as real; then sort and retain only the roots inside [-1,1]
+    mask = abs(np.imag(rts)) < htol
+    rts = np.real(rts[mask])
+    rts = rts[abs(rts) <= 1.0 + htol]
+    rts = np.sort(rts)
+    if rts.size >= 2:
+        rts[0] = max([rts[0], -1])
+        rts[-1] = min([rts[-1], 1])
+    return rts
+
+
+@preandpostprocess
+def bary(xx, fk, xk, vk):
+    """Barycentric interpolation formula. See:
+
+    J.P. Berrut, L.N. Trefethen, Barycentric Lagrange Interpolation, SIAM
+    Review (2004)
+
+    Inputs
+    ------
+    xx : numpy ndarray
+        array of evaluation points
+    fk : numpy ndarray
+        array of function values at the interpolation nodes xk
+    xk: numpy ndarray
+        array of interpolation nodes
+    vk: numpy ndarray
+        barycentric weights corresponding to the interpolation nodes xk
+    """
+
+    # either iterate over the evaluation points, or ...
+    if xx.size < 4 * xk.size:
+        out = np.zeros(xx.size)
+        for i in range(xx.size):
+            tt = vk / (xx[i] - xk)
+            out[i] = np.dot(tt, fk) / tt.sum()
+
+    # ... iterate over the barycenters
+    else:
+        numer = np.zeros(xx.size)
+        denom = np.zeros(xx.size)
+        for j in range(xk.size):
+            temp = vk[j] / (xx - xk[j])
+            numer = numer + temp * fk[j]
+            denom = denom + temp
+        out = numer / denom
+
+    # replace NaNs
+    for k in find(np.isnan(out)):
+        idx = find(xx[k] == xk)
+        if idx.size > 0:
+            out[k] = fk[idx[0]]
+
+    return out
+
+
+@preandpostprocess
+def clenshaw(xx, ak):
+    """Clenshaw's algorithm for the evaluation of a first-kind Chebyshev
+    series expansion at some array of points x"""
+    bk1 = 0 * xx
+    bk2 = 0 * xx
+    xx = 2 * xx
+    idx = range(ak.size)
+    for k in idx[ak.size : 1 : -2]:
+        bk2 = ak[k] + xx * bk1 - bk2
+        bk1 = ak[k - 1] + xx * bk2 - bk1
+    if np.mod(ak.size - 1, 2) == 1:
+        bk1, bk2 = ak[1] + xx * bk1 - bk2, bk1
+    out = ak[0] + 0.5 * xx * bk1 - bk2
+    return out
+
+
+def standard_chop(coeffs, tol=None):
+    """Chop a Chebyshev series to a given tolerance. This is a Python
+    transcription of the algorithm described in:
+
+    J. Aurentz and L.N. Trefethen, Chopping a Chebyshev series (2015)
+    (http://arxiv.org/pdf/1512.01803v1.pdf)
+    """
+
+    # check magnitude of tol:
+    tol = tol if tol is not None else prefs.eps
+    if tol >= 1:
+        cutoff = 1
+        return cutoff
+
+    # ensure length at least 17:
+    n = coeffs.size
+    cutoff = n
+    if n < 17:
+        return cutoff
+
+    # Step 1: Convert coeffs input to a new monotonically nonincreasing
+    # vector (envelope) normalized to begin with the value 1.
+    b = np.flipud(np.abs(coeffs))
+    m = np.flipud(np.maximum.accumulate(b))
+    if m[0] == 0.0:
+        # TODO: check this
+        cutoff = 1  # cutoff = 0
+        return cutoff
+    envelope = m / m[0]
+
+    # Step 2: Scan envelope for a value plateauPoint, the first point, if any,
+    # that is followed by a plateau
+    for j in np.arange(1, n):
+        j2 = round(1.25 * j + 5)
+        if j2 > n - 1:
+            # there is no plateau: exit
+            return cutoff
+        e1 = envelope[j]
+        e2 = envelope[int(j2)]
+        r = 3 * (1 - np.log(e1) / np.log(tol))
+        plateau = (e1 == 0.0) | (e2 / e1 > r)
+        if plateau:
+            # a plateau has been found: go to Step 3
+            plateauPoint = j
+            break
+
+    # Step 3: Fix cutoff at a point where envelope, plus a linear function
+    # included to bias the result towards the left end, is minimal.
+    if envelope[int(plateauPoint)] == 0.0:
+        cutoff = plateauPoint
+    else:
+        j3 = sum(envelope >= tol ** (7.0 / 6.0))
+        if j3 < j2:
+            j2 = j3 + 1
+            envelope[j2] = tol ** (7.0 / 6.0)
+        cc = np.log10(envelope[: int(j2)])
+        cc = cc + np.linspace(0, (-1.0 / 3.0) * np.log10(tol), int(j2))
+        d = np.argmin(cc)
+        # TODO: check this
+        cutoff = d  # + 2
+    return min((cutoff, n - 1))
+
+
+def adaptive(cls, fun, hscale=1, maxpow2=None):
+    """Adaptive constructor: cycle over powers of two, calling
+    standard_chop each time, the output of which determines whether or not
+    we are happy."""
+    minpow2 = 4  # 17 points
+    maxpow2 = maxpow2 if maxpow2 is not None else prefs.maxpow2
+    for k in range(minpow2, max(minpow2, maxpow2) + 1):
+        n = 2**k + 1
+        points = cls._chebpts(n)
+        values = fun(points)
+        coeffs = cls._vals2coeffs(values)
+        eps = prefs.eps
+        tol = eps * max(hscale, 1)  # scale (decrease) tolerance by hscale
+        chplen = standard_chop(coeffs, tol=tol)
+        if chplen < coeffs.size:
+            coeffs = coeffs[:chplen]
+            break
+        if k == maxpow2:
+            warnings.warn("The {} constructor did not converge: using {} points".format(cls.__name__, n))
+            break
+    return coeffs
+
+
+def coeffmult(fc, gc):
+    """Coefficient-Space multiplication of equal-length first-kind
+    Chebyshev series."""
+    Fc = np.append(2.0 * fc[:1], (fc[1:], fc[:0:-1]))
+    Gc = np.append(2.0 * gc[:1], (gc[1:], gc[:0:-1]))
+    ak = ifft(fft(Fc) * fft(Gc))
+    ak = np.append(ak[:1], ak[1:] + ak[:0:-1]) * 0.25
+    ak = ak[: fc.size]
+    inputcfs = np.append(fc, gc)
+    out = np.real(ak) if np.isreal(inputcfs).all() else ak
+    return out
+
+
+def barywts2(n):
+    """Barycentric weights for Chebyshev points of 2nd kind"""
+    if n == 0:
+        wts = np.array([])
+    elif n == 1:
+        wts = np.array([1])
+    else:
+        wts = np.append(np.ones(n - 1), 0.5)
+        wts[n - 2 :: -2] = -1
+        wts[0] = 0.5 * wts[0]
+    return wts
+
+
+def chebpts2(n):
+    """Return n Chebyshev points of the second-kind"""
+    if n == 1:
+        pts = np.array([0.0])
+    else:
+        nn = np.arange(n)
+        pts = np.cos(nn[::-1] * np.pi / (n - 1))
+    return pts
+
+
+def vals2coeffs2(vals):
+    """Map function values at Chebyshev points of 2nd kind to
+    first-kind Chebyshev polynomial coefficients"""
+    n = vals.size
+    if n <= 1:
+        coeffs = vals
+        return coeffs
+    tmp = np.append(vals[::-1], vals[1:-1])
+    if np.isreal(vals).all():
+        coeffs = ifft(tmp)
+        coeffs = np.real(coeffs)
+    elif np.isreal(1j * vals).all():
+        coeffs = ifft(np.imag(tmp))
+        coeffs = 1j * np.real(coeffs)
+    else:
+        coeffs = ifft(tmp)
+    coeffs = coeffs[:n]
+    coeffs[1 : n - 1] = 2 * coeffs[1 : n - 1]
+    return coeffs
+
+
+def coeffs2vals2(coeffs):
+    """Map first-kind Chebyshev polynomial coefficients to
+    function values at Chebyshev points of 2nd kind"""
+    n = coeffs.size
+    if n <= 1:
+        vals = coeffs
+        return vals
+    coeffs = coeffs.copy()
+    coeffs[1 : n - 1] = 0.5 * coeffs[1 : n - 1]
+    tmp = np.append(coeffs, coeffs[n - 2 : 0 : -1])
+    if np.isreal(coeffs).all():
+        vals = fft(tmp)
+        vals = np.real(vals)
+    elif np.isreal(1j * coeffs).all():
+        vals = fft(np.imag(tmp))
+        vals = 1j * np.real(vals)
+    else:
+        vals = fft(tmp)
+    vals = vals[n - 1 :: -1]
+    return vals
+
+
+def newtonroots(fun, rts, tol=None, maxiter=None):
+    """Rootfinding for a callable and differentiable fun, typically used to
+    polish already computed roots."""
+    tol = tol if tol is not None else 2 * prefs.eps
+    maxiter = maxiter if maxiter is not None else prefs.maxiter
+    if rts.size > 0:
+        dfun = fun.diff()
+        prv = np.inf * rts
+        count = 0
+        while (infnorm(rts - prv) > tol) & (count <= maxiter):
+            count += 1
+            prv = rts
+            rts = rts - fun(rts) / dfun(rts)
+    return rts

chebfun-0.4.4.1/chebpy/core/bndfun.py

@@ -0,0 +1,7 @@
+from .classicfun import Classicfun
+
+
+class Bndfun(Classicfun):
+    """Class to approximate functions on bounded intervals [a,b]"""
+
+    pass