scipy 1.15.2__cp313-cp313t-macosx_12_0_arm64.whl → 1.16.0rc1__cp313-cp313t-macosx_12_0_arm64.whl

scipy/integrate/tests/test_quadrature.py

@@ -13,7 +13,7 @@ from scipy.integrate import (romb, newton_cotes,
 from scipy.integrate._quadrature import _cumulative_simpson_unequal_intervals
 
 from scipy import stats, special, integrate
-from scipy.conftest import array_api_compatible, skip_xp_invalid_arg
+from scipy.conftest import skip_xp_invalid_arg
 from scipy._lib._array_api_no_0d import xp_assert_close
 
 skip_xp_backends = pytest.mark.skip_xp_backends
@@ -269,7 +269,6 @@ class TestCumulative_trapezoid:
             cumulative_trapezoid(y=[])
 
 
-@array_api_compatible
 class TestTrapezoid:
     def test_simple(self, xp):
         x = xp.arange(-10, 10, .1)
@@ -278,8 +277,7 @@ class TestTrapezoid:
         xp_assert_close(r, xp.asarray(1.0))
 
     @skip_xp_backends('jax.numpy',
-                      reasons=["JAX arrays do not support item assignment"])
-    @pytest.mark.usefixtures("skip_xp_backends")
+                      reason="JAX arrays do not support item assignment")
     def test_ndim(self, xp):
         x = xp.linspace(0, 1, 3)
         y = xp.linspace(0, 2, 8)
@@ -318,8 +316,7 @@ class TestTrapezoid:
         xp_assert_close(r, qz)
 
     @skip_xp_backends('jax.numpy',
-                      reasons=["JAX arrays do not support item assignment"])
-    @pytest.mark.usefixtures("skip_xp_backends")
+                      reason="JAX arrays do not support item assignment")
     def test_gh21908(self, xp):
         # extended testing for n-dim arrays
         x = xp.reshape(xp.linspace(0, 29, 30), (3, 10))
@@ -362,8 +359,7 @@ class TestTrapezoid:
         assert_allclose(trapezoid(y, xm), r)
 
     @skip_xp_backends(np_only=True,
-                      reasons=['array-likes only supported for NumPy backend'])
-    @pytest.mark.usefixtures("skip_xp_backends")
+                      reason='array-likes only supported for NumPy backend')
     def test_array_like(self, xp):
         x = list(range(5))
         y = [t * t for t in x]
@@ -635,6 +631,7 @@ class TestCumulativeSimpson:
         # `simpson` uses the trapezoidal rule
         return theoretical_difference
 
+    @pytest.mark.fail_slow(10)
     @pytest.mark.thread_unsafe
     @pytest.mark.slow
     @given(
@@ -666,6 +663,7 @@ class TestCumulativeSimpson:
             res[..., 1:], ref[..., 1:] + theoretical_difference[..., 1:], atol=1e-16
         )
 
+    @pytest.mark.fail_slow(10)
     @pytest.mark.thread_unsafe
     @pytest.mark.slow
     @given(

scipy/integrate/tests/test_tanhsinh.py

@@ -6,7 +6,6 @@ import math
 import numpy as np
 from numpy.testing import assert_allclose
 
-from scipy.conftest import array_api_compatible
 import scipy._lib._elementwise_iterative_method as eim
 from scipy._lib._array_api_no_0d import xp_assert_close, xp_assert_equal
 from scipy._lib._array_api import array_namespace, xp_size, xp_ravel, xp_copy, is_numpy
@@ -20,6 +19,7 @@ def norm_pdf(x, xp=None):
     xp = array_namespace(x) if xp is None else xp
     return 1/(2*xp.pi)**0.5 * xp.exp(-x**2/2)
 
+
 def norm_logpdf(x, xp=None):
     xp = array_namespace(x) if xp is None else xp
     return -0.5*math.log(2*xp.pi) - x**2/2
@@ -43,11 +43,12 @@ def _vectorize(xp):
     return decorator
 
 
-@array_api_compatible
-@pytest.mark.usefixtures("skip_xp_backends")
 @pytest.mark.skip_xp_backends(
     'array_api_strict', reason='Currently uses fancy indexing assignment.'
 )
+@pytest.mark.skip_xp_backends(
+    'dask.array', reason='boolean indexing assignment'
+)
 @pytest.mark.skip_xp_backends(
     'jax.numpy', reason='JAX arrays do not support item assignment.'
 )
@@ -233,11 +234,11 @@ class TestTanhSinh:
         logres = _tanhsinh(norm_logpdf, *limits, log=True)
         xp_assert_close(xp.exp(logres.integral), ref, check_dtype=False)
         # Transformation should not make the result complex unnecessarily
-        xp_test = array_namespace(*limits)  # we need xp.isdtype
-        assert (xp_test.isdtype(logres.integral.dtype, "real floating") if ref > 0
-                else xp_test.isdtype(logres.integral.dtype, "complex floating"))
+        assert (xp.isdtype(logres.integral.dtype, "real floating") if ref > 0
+                else xp.isdtype(logres.integral.dtype, "complex floating"))
 
-        xp_assert_close(xp.exp(logres.error), res.error, atol=1e-16, check_dtype=False)
+        atol = 2 * xp.finfo(res.error.dtype).eps
+        xp_assert_close(xp.exp(logres.error), res.error, atol=atol, check_dtype=False)
 
     # 15 skipped intentionally; it's very difficult numerically
     @pytest.mark.skip_xp_backends(np_only=True,
@@ -248,7 +249,7 @@ class TestTanhSinh:
         rtol = 2e-8
         res = _tanhsinh(f, 0, f.b, rtol=rtol)
         assert_allclose(res.integral, f.ref, rtol=rtol)
-        if f_number not in {14}:  # mildly underestimates error here
+        if f_number not in {7, 12, 14}:  # mildly underestimates error here
             true_error = abs(self.error(res.integral, f.ref)/res.integral)
             assert true_error < res.error
 
@@ -299,18 +300,17 @@ class TestTanhSinh:
         res = _tanhsinh(f, a, b, args=(p,))
         refs = _tanhsinh_single(a, b, p)
 
-        xp_test = array_namespace(a)  # need xp.stack, isdtype
         attrs = ['integral', 'error', 'success', 'status', 'nfev', 'maxlevel']
         for attr in attrs:
-            ref_attr = xp_test.stack([getattr(ref, attr) for ref in refs])
+            ref_attr = xp.stack([getattr(ref, attr) for ref in refs])
             res_attr = xp_ravel(getattr(res, attr))
             xp_assert_close(res_attr, ref_attr, rtol=1e-15)
             assert getattr(res, attr).shape == shape
 
-        assert xp_test.isdtype(res.success.dtype, 'bool')
-        assert xp_test.isdtype(res.status.dtype, 'integral')
-        assert xp_test.isdtype(res.nfev.dtype, 'integral')
-        assert xp_test.isdtype(res.maxlevel.dtype, 'integral')
+        assert xp.isdtype(res.success.dtype, 'bool')
+        assert xp.isdtype(res.status.dtype, 'integral')
+        assert xp.isdtype(res.nfev.dtype, 'integral')
+        assert xp.isdtype(res.maxlevel.dtype, 'integral')
         assert xp.max(res.nfev) == f.feval
         # maxlevel = 2 -> 3 function calls (2 initialization, 1 work)
         assert xp.max(res.maxlevel) >= 2
@@ -383,12 +383,10 @@ class TestTanhSinh:
     def test_options_and_result_attributes(self, xp):
         # demonstrate that options are behaving as advertised and status
         # messages are as intended
-        xp_test = array_namespace(xp.asarray(1.))  # need xp.atan
-
         def f(x):
             f.calls += 1
             f.feval += xp_size(xp.asarray(x))
-            return x**2 * xp_test.atan(x)
+            return x**2 * xp.atan(x)
 
         f.ref = xp.asarray((math.pi - 2 + 2 * math.log(2)) / 12, dtype=xp.float64)
 
@@ -560,21 +558,18 @@ class TestTanhSinh:
         # integrand is evaluated or the integral/error estimates, only the
         # number of function calls
 
-        # need `xp.concat`, `xp.atan`, and `xp.sort`
-        xp_test = array_namespace(xp.asarray(1.))
-
         def f(x):
             f.calls += 1
             f.feval += xp_size(xp.asarray(x))
-            f.x = xp_test.concat((f.x, xp_ravel(x)))
-            return x**2 * xp_test.atan(x)
+            f.x = xp.concat((f.x, xp_ravel(x)))
+            return x**2 * xp.atan(x)
 
         f.feval, f.calls, f.x = 0, 0, xp.asarray([])
 
         a = xp.asarray(0, dtype=xp.float64)
         b = xp.asarray(1, dtype=xp.float64)
         ref = _tanhsinh(f, a, b, minlevel=0, maxlevel=maxlevel)
-        ref_x = xp_test.sort(f.x)
+        ref_x = xp.sort(f.x)
 
         for minlevel in range(0, maxlevel + 1):
             f.feval, f.calls, f.x = 0, 0, xp.asarray([])
@@ -587,7 +582,7 @@ class TestTanhSinh:
             assert res.nfev == f.feval == f.x.shape[0]
             assert f.calls == maxlevel - minlevel + 1 + 1  # 1 validation call
             assert res.status == ref.status
-            xp_assert_equal(ref_x, xp_test.sort(f.x))
+            xp_assert_equal(ref_x, xp.sort(f.x))
 
     def test_improper_integrals(self, xp):
         # Test handling of infinite limits of integration (mixed with finite limits)
@@ -679,10 +674,9 @@ class TestTanhSinh:
     def test_special_cases(self, xp):
         # Test edge cases and other special cases
         a, b = xp.asarray(0), xp.asarray(1)
-        xp_test = array_namespace(a, b)  # need `xp.isdtype`
 
         def f(x):
-            assert xp_test.isdtype(x.dtype, "real floating")
+            assert xp.isdtype(x.dtype, "real floating")
             return x
 
         res = _tanhsinh(f, a, b)
@@ -753,11 +747,30 @@ class TestTanhSinh:
         x[-1] = 1000
         _tanhsinh(np.sin, 1, x)
 
+    def test_gh_22681_finite_error(self, xp):
+        # gh-22681 noted a case in which the error was NaN on some platforms;
+        # check that this does in fact fail in CI.
+        c1 = complex(12, -10)
+        c2 = complex(12, 39)
+        def f(t):
+            return xp.sin(c1 * (1 - t) + c2 * t)
+        a, b = xp.asarray(0., dtype=xp.float64), xp.asarray(1., dtype=xp.float64)
+        ref = _tanhsinh(f, a, b, atol=0, rtol=0, maxlevel=10)
+        assert xp.isfinite(ref.error)
+        # Previously, tanhsinh would not detect convergence
+        res = _tanhsinh(f, a, b, rtol=1e-14)
+        assert res.success
+        assert res.maxlevel < 5
+        xp_assert_close(res.integral, ref.integral, rtol=1e-15)
+
 
-@array_api_compatible
-@pytest.mark.usefixtures("skip_xp_backends")
+@pytest.mark.skip_xp_backends('torch', reason='data-apis/array-api-compat#271')
 @pytest.mark.skip_xp_backends('array_api_strict', reason='No fancy indexing.')
 @pytest.mark.skip_xp_backends('jax.numpy', reason='No mutation.')
+@pytest.mark.skip_xp_backends(
+    'dask.array',
+    reason='Data-dependent shapes in boolean index assignment'
+)
 class TestNSum:
     rng = np.random.default_rng(5895448232066142650)
     p = rng.uniform(1, 10, size=10).tolist()
@@ -812,13 +825,21 @@ class TestNSum:
         with pytest.raises(ValueError, match=message):
             nsum(f, a, b, tolerances=dict(rtol=pytest))
 
-        with np.errstate(all='ignore'):
+        with (np.errstate(all='ignore')):
             res = nsum(f, xp.asarray([np.nan, np.inf]), xp.asarray(1.))
-            assert xp.all((res.status == -1) & xp.isnan(res.sum)
-                          & xp.isnan(res.error) & ~res.success & res.nfev == 1)
+            assert (res.status[0] == -1) and not res.success[0]
+            assert xp.isnan(res.sum[0]) and xp.isnan(res.error[0])
+            assert (res.status[1] == 0) and res.success[1]
+            assert res.sum[1] == res.error[1]
+            assert xp.all(res.nfev[0] == 1)
+
             res = nsum(f, xp.asarray(10.), xp.asarray([np.nan, 1]))
-            assert xp.all((res.status == -1) & xp.isnan(res.sum)
-                          & xp.isnan(res.error) & ~res.success & res.nfev == 1)
+            assert (res.status[0] == -1) and not res.success[0]
+            assert xp.isnan(res.sum[0]) and xp.isnan(res.error[0])
+            assert (res.status[1] == 0) and res.success[1]
+            assert res.sum[1] == res.error[1]
+            assert xp.all(res.nfev[0] == 1)
+
             res = nsum(f, xp.asarray(1.), xp.asarray(10.),
                        step=xp.asarray([xp.nan, -xp.inf, xp.inf, -1, 0]))
             assert xp.all((res.status == -1) & xp.isnan(res.sum)
@@ -852,8 +873,7 @@ class TestNSum:
         res = nsum(f, a, b, args=args)
         xp_assert_close(res.sum, ref)
         xp_assert_equal(res.status, xp.zeros(ref.shape, dtype=xp.int32))
-        xp_test = array_namespace(a)  # CuPy doesn't have `bool`
-        xp_assert_equal(res.success, xp.ones(ref.shape, dtype=xp_test.bool))
+        xp_assert_equal(res.success, xp.ones(ref.shape, dtype=xp.bool))
 
         with np.errstate(divide='ignore'):
             logres = nsum(lambda *args: xp.log(f(*args)),
@@ -891,8 +911,7 @@ class TestNSum:
         ref_err = (high - low)/2  # error (assuming perfect quadrature)
 
         # correct reference values where number of terms < maxterms
-        xp_test = array_namespace(a)  # torch needs broadcast_arrays
-        a, b, step = xp_test.broadcast_arrays(a, b, step)
+        a, b, step = xp.broadcast_arrays(a, b, step)
         for i in np.ndindex(a.shape):
             ai, bi, stepi = float(a[i]), float(b[i]), float(step[i])
             if (bi - ai)/stepi + 1 <= maxterms:
@@ -949,10 +968,9 @@ class TestNSum:
             xp_assert_close(xp_ravel(res_attr), xp.asarray(ref_attr), rtol=1e-15)
             assert res_attr.shape == shape
 
-        xp_test = array_namespace(xp.asarray(1.))
-        assert xp_test.isdtype(res.success.dtype, 'bool')
-        assert xp_test.isdtype(res.status.dtype, 'integral')
-        assert xp_test.isdtype(res.nfev.dtype, 'integral')
+        assert xp.isdtype(res.success.dtype, 'bool')
+        assert xp.isdtype(res.status.dtype, 'integral')
+        assert xp.isdtype(res.nfev.dtype, 'integral')
         if is_numpy(xp):  # other libraries might have different number
             assert int(xp.max(res.nfev)) == f.feval
 
@@ -1074,8 +1092,8 @@ class TestNSum:
                 return 1 / x
 
         res = nsum(f, xp.asarray(0), xp.asarray(10), maxterms=0)
-        assert xp.isnan(res.sum)
-        assert xp.isnan(res.error)
+        assert xp.isinf(res.sum)
+        assert xp.isinf(res.error)
         assert res.status == -2
 
         res = nsum(f, xp.asarray(0), xp.asarray(10), maxterms=1)

scipy/interpolate/__init__.py

@@ -5,13 +5,11 @@ Interpolation (:mod:`scipy.interpolate`)
 
 .. currentmodule:: scipy.interpolate
 
-Sub-package for objects used in interpolation.
+Sub-package for functions and objects used in interpolation.
+
+See the :ref:`user guide <tutorial-interpolate>` for recommendations on choosing a
+routine, and other usage details.
 
-As listed below, this sub-package contains spline functions and classes,
-1-D and multidimensional (univariate and multivariate)
-interpolation classes, Lagrange and Taylor polynomial interpolators, and
-wrappers for `FITPACK <http://www.netlib.org/dierckx/>`__
-and DFITPACK functions.
 
 Univariate interpolation
 ========================
@@ -19,51 +17,53 @@ Univariate interpolation
 .. autosummary::
    :toctree: generated/
 
-   interp1d
+   make_interp_spline
+   CubicSpline
+   PchipInterpolator
+   Akima1DInterpolator
+   FloaterHormannInterpolator
    BarycentricInterpolator
    KroghInterpolator
-   barycentric_interpolate
-   krogh_interpolate
-   pchip_interpolate
    CubicHermiteSpline
-   PchipInterpolator
-   Akima1DInterpolator
-   CubicSpline
+
+**Low-level data structures for univariate interpolation:**
+
+.. autosummary::
+   :toctree: generated/
+
    PPoly
    BPoly
-   FloaterHormannInterpolator
+   BSpline
 
 
 Multivariate interpolation
 ==========================
 
-Unstructured data:
+**Unstructured data**
 
 .. autosummary::
    :toctree: generated/
 
-   griddata
    LinearNDInterpolator
    NearestNDInterpolator
    CloughTocher2DInterpolator
    RBFInterpolator
-   Rbf
-   interp2d
 
-For data on a grid:
+**For data on a grid:**
 
 .. autosummary::
    :toctree: generated/
 
-   interpn
    RegularGridInterpolator
-   RectBivariateSpline
 
 .. seealso::
 
-    `scipy.ndimage.map_coordinates`
+    `scipy.ndimage.map_coordinates`,
+    :ref:`An example wrapper for map_coordinates <tutorial-interpolate_cartesian-grids>`
+
+
+**Low-level data structures for tensor product polynomials and splines:**
 
-Tensor product polynomials:
 
 .. autosummary::
    :toctree: generated/
@@ -71,21 +71,44 @@ Tensor product polynomials:
    NdPPoly
    NdBSpline
 
-1-D Splines
-===========
+
+1-D spline smoothing and approximation
+======================================
 
 .. autosummary::
    :toctree: generated/
 
-   BSpline
-   make_interp_spline
    make_lsq_spline
    make_smoothing_spline
-   generate_knots
    make_splrep
    make_splprep
+   generate_knots
+
+Rational Approximation
+======================
+
+.. autosummary::
+   :toctree: generated/
+
+   AAA
+
+
+Interfaces to FITPACK routines for 1D and 2D spline fitting
+===========================================================
+
+This section lists wrappers for `FITPACK <http://www.netlib.org/dierckx/>`__
+functionality for 1D and 2D smoothing splines. In most cases, users are better off
+using higher-level routines listed in previous sections.
+
+
+1D FITPACK splines
+------------------
+
+This package provides two sets of functionally equivalent wrappers: object-oriented and
+functional.
+
+**Functional FITPACK interface:**
 
-Functional interface to FITPACK routines:
 
 .. autosummary::
    :toctree: generated/
@@ -100,7 +123,7 @@ Functional interface to FITPACK routines:
    splantider
    insert
 
-Object-oriented FITPACK interface:
+**Object-oriented FITPACK interface:**
 
 .. autosummary::
    :toctree: generated/
@@ -110,11 +133,10 @@ Object-oriented FITPACK interface:
    LSQUnivariateSpline
 
 
+2D FITPACK splines
+------------------
 
-2-D Splines
-===========
-
-For data on a grid:
+**For data on a grid:**
 
 .. autosummary::
    :toctree: generated/
@@ -122,7 +144,7 @@ For data on a grid:
    RectBivariateSpline
    RectSphereBivariateSpline
 
-For unstructured data:
+**For unstructured data (OOP interface):**
 
 .. autosummary::
    :toctree: generated/
@@ -133,7 +155,7 @@ For unstructured data:
    LSQBivariateSpline
    LSQSphereBivariateSpline
 
-Low-level interface to FITPACK functions:
+**For unstructured data (functional interface):**
 
 .. autosummary::
    :toctree: generated/
@@ -141,14 +163,6 @@ Low-level interface to FITPACK functions:
    bisplrep
    bisplev
 
-Rational Approximation
-======================
-
-.. autosummary::
-   :toctree: generated/
-
-   pade
-   AAA
 
 Additional tools
 ================
@@ -158,28 +172,26 @@ Additional tools
 
    lagrange
    approximate_taylor_polynomial
+   pade
+
+   interpn
+   griddata
+   barycentric_interpolate
+   krogh_interpolate
+   pchip_interpolate
+   Rbf
+   interp1d
+   interp2d
 
 .. seealso::
 
    `scipy.ndimage.map_coordinates`,
    `scipy.ndimage.spline_filter`,
-   `scipy.signal.resample`,
-   `scipy.signal.bspline`,
-   `scipy.signal.gauss_spline`,
-   `scipy.signal.qspline1d`,
-   `scipy.signal.cspline1d`,
-   `scipy.signal.qspline1d_eval`,
-   `scipy.signal.cspline1d_eval`,
-   `scipy.signal.qspline2d`,
-   `scipy.signal.cspline2d`.
-
-``pchip`` is an alias of `PchipInterpolator` for backward compatibility
-(should not be used in new code).
-"""
+
+"""  # noqa: E501
 from ._interpolate import *
 from ._fitpack_py import *
 
-# New interface to fitpack library:
 from ._fitpack2 import *
 
 from ._rbf import Rbf

scipy/interpolate/_bary_rational.py

@@ -34,7 +34,7 @@ __all__ = ["AAA", "FloaterHormannInterpolator"]
 
 
 class _BarycentricRational:
-    """Base class for Barycentric representation of a rational function."""
+    """Base class for barycentric representation of a rational function."""
     def __init__(self, x, y, **kwargs):
         # input validation
         z = np.asarray(x)
@@ -399,7 +399,7 @@ class AAA(_BarycentricRational):
     >>> with warnings.catch_warnings():
     ...     warnings.simplefilter('ignore', RuntimeWarning)
     ...     r.clean_up()
-    4
+    4  # may vary
     >>> mask = np.abs(r.residues()) < 1e-13
     >>> axs[1].plot(r.poles().real[~mask], r.poles().imag[~mask], '.')
     >>> axs[1].plot(r.poles().real[mask], r.poles().imag[mask], 'r.')
@@ -597,11 +597,10 @@ class AAA(_BarycentricRational):
 
 
 class FloaterHormannInterpolator(_BarycentricRational):
-    r"""
-    Floater-Hormann barycentric rational interpolation.
+    r"""Floater-Hormann barycentric rational interpolator (C∞ smooth on real axis).
 
     As described in [1]_, the method of Floater and Hormann computes weights for a
-    Barycentric rational interpolant with no poles on the real axis.
+    barycentric rational interpolant with no poles on the real axis.
 
     Parameters
     ----------
@@ -610,11 +609,11 @@ class FloaterHormannInterpolator(_BarycentricRational):
         complex but must be finite.
     y : array_like, shape (n, ...)
         Array containing values of the dependent variable. Infinite and NaN values
-        of `values` and corresponding values of `x` will be discarded.
-    d : int, optional
-        Blends ``n - d`` degree `d` polynomials together. For ``d = n - 1`` it is
-        equivalent to polynomial interpolation. Must satisfy ``0 <= d < n``,
-        defaults to 3.
+        of `y` and corresponding values of `x` will be discarded.
+    d : int, default: 3
+        Integer satisfying ``0 <= d < n``. Floater-Hormann interpolation blends
+        ``n - d`` polynomials of degree `d` together; for ``d = n - 1``, this is
+        equivalent to polynomial interpolation.
 
     Attributes
     ----------
@@ -639,8 +638,8 @@ class FloaterHormannInterpolator(_BarycentricRational):
         r(x) = \frac{\sum_{i=0}^{n-d} \lambda_i(x) p_i(x)}
         {\sum_{i=0}^{n-d} \lambda_i(x)},
 
-    where :math:`p_i(x)` is an interpolating polynomials of at most degree `d` through
-    the points :math:`(x_i,y_i),\dots,(x_{i+d},y_{i+d}), and :math:`\lambda_i(z)` are
+    where :math:`p_i(x)` is an interpolating polynomial of at most degree `d` through
+    the points :math:`(x_i,y_i),\dots,(x_{i+d},y_{i+d})`, and :math:`\lambda_i(z)` are
     blending functions defined by
 
     .. math::
@@ -649,8 +648,8 @@ class FloaterHormannInterpolator(_BarycentricRational):
 
     When ``d = n - 1`` this reduces to polynomial interpolation.
 
-    Due to its stability following barycentric representation of the above equation
-    is used instead for computation
+    Due to its stability, the following barycentric representation of the above equation
+    is used for computation
 
     .. math::
 
@@ -680,16 +679,17 @@ class FloaterHormannInterpolator(_BarycentricRational):
     >>> import numpy as np
     >>> from scipy.interpolate import (FloaterHormannInterpolator,
     ...                                BarycentricInterpolator)
-    >>> def f(z):
-    ...     return 1/(1 + z**2)
-    >>> z = np.linspace(-5, 5, num=15)
-    >>> r = FloaterHormannInterpolator(z, f(z))
-    >>> p = BarycentricInterpolator(z, f(z))
-    >>> zz = np.linspace(-5, 5, num=1000)
+    >>> def f(x):
+    ...     return 1/(1 + x**2)
+    >>> x = np.linspace(-5, 5, num=15)
+    >>> r = FloaterHormannInterpolator(x, f(x))
+    >>> p = BarycentricInterpolator(x, f(x))
+    >>> xx = np.linspace(-5, 5, num=1000)
     >>> import matplotlib.pyplot as plt
     >>> fig, ax = plt.subplots()
-    >>> ax.plot(zz, r(zz), label="Floater=Hormann")
-    >>> ax.plot(zz, p(zz), label="Polynomial")
+    >>> ax.plot(xx, f(xx), label="f(x)")
+    >>> ax.plot(xx, r(xx), "--", label="Floater-Hormann")
+    >>> ax.plot(xx, p(xx), "--", label="Polynomial")
     >>> ax.legend()
     >>> plt.show()
     """