bundles / scipy latest / scipy / interpolate / _fitpack_repro / make_splrep

function

`scipy.interpolate._fitpack_repro:make_splrep`

source: /scipy/interpolate/_fitpack_repro.py :1011

Signature

   def     make_splrep (    x    ,    y    ,  * ,     w    =  None   ,    xb    =  None   ,    xe    =  None   ,    k    =  3   ,    s    =  0   ,    t    =  None   ,    nest    =  None   ,    bc_type    =  None     )

Summary

Create a smoothing B-spline function with bounded error, minimizing derivative jumps.

Extended Summary

Given the set of data points (x[i], y[i]), determine a smooth spline approximation of degree k on the interval xb <= x <= xe.

Parameters

x, y : array_like, shape (m,)

The data points defining a curve y = f(x).

w : array_like, shape (m,), optional

Strictly positive 1D array of weights, of the same length as x and y. The weights are used in computing the weighted least-squares spline fit. If the errors in the y values have standard-deviation given by the vector d, then w should be 1/d. Default is np.ones(m).

xb, xe : float, optional

The interval to fit. If None, these default to x[0] and x[-1], respectively.

k : int, optional

The degree of the spline fit. It is recommended to use cubic splines, k=3, which is the default. Even values of k should be avoided, especially with small s values.

s : float, optional

The smoothing condition. The amount of smoothness is determined by satisfying the LSQ (least-squares) constraint

sum((w * (g(x)  - y))**2 ) <= s

where g(x) is the smoothed fit to (x, y). The user can use s to control the tradeoff between closeness to data and smoothness of fit. Larger s means more smoothing while smaller values of s indicate less smoothing. Recommended values of s depend on the weights, w. If the weights represent the inverse of the standard deviation of y, then a good s value should be found in the range (m-sqrt(2*m), m+sqrt(2*m)) where m is the number of datapoints in x, y, and w. Default is s = 0.0, i.e. interpolation.

t : array_like, optional

The spline knots. If None (default), the knots will be constructed automatically. There must be at least 2*k + 2 and at most m + k + 1 knots.

nest : int, optional

The target length of the knot vector. Should be between 2*(k + 1) (the minimum number of knots for a degree-k spline), and m + k + 1 (the number of knots of the interpolating spline). The actual number of knots returned by this routine may be slightly larger than nest. Default is None (no limit, add up to m + k + 1 knots).

periodic : bool, optional

If True, data points are considered periodic with period x[m-1] - x[0] and a smooth periodic spline approximation is returned. Values of y[m-1] and w[m-1] are not used. The default is False, corresponding to boundary condition 'not-a-knot'.

bc_type : str, optional

Boundary conditions. Default is "not-a-knot". The following boundary conditions are recognized:

"not-a-knot" (default): The first and second segments are the same polynomial. This is equivalent to having bc_type=None.
"periodic": The values and the first k-1 derivatives at the ends are equivalent.

Returns

spl : a `BSpline` instance: For s=0, spl(x) == y. For non-zero values of s the spl represents the smoothed approximation to (x, y), generally with fewer knots.

Notes

This routine constructs the smoothing spline function, $g (x)$ , to minimize the sum of jumps, $D_{j}$ , of the k-th derivative at the internal knots ( $x_{b} < t_{i} < x_{e}$ ), where

D_{i} = g^{(k)} (t_{i} + 0) - g^{(k)} (t_{i} - 0)

Specifically, the routine constructs the spline function $g (x)$ which minimizes

i \sum ∣ D_{i} ∣^{2} \to min

provided that

j = 1 \sum m (w_{j} \times (g (x_{j}) - y_{j}))^{2} ⩽ s,

where $s > 0$ is the input parameter.

In other words, we balance maximizing the smoothness (measured as the jumps of the derivative, the first criterion), and the deviation of $g (x_{j})$ from the data $y_{j}$ (the second criterion).

Note that the summation in the second criterion is over all data points, and in the first criterion it is over the internal spline knots (i.e. those with xb < t[i] < xe). The spline knots are in general a subset of data, see generate_knots for details.

Also note the difference of this routine to make_lsq_spline: the latter routine does not consider smoothness and simply solves a least-squares problem

\sum w_{j} \times (g (x_{j}) - y_{j})^{2} \to min

for a spline function $g (x)$ with a _fixed_ knot vector t.

Array API Standard Support

make_splrep has experimental support for Python Array API Standard compatible backends in addition to NumPy. Please consider testing these features by setting an environment variable SCIPY_ARRAY_API=1 and providing CuPy, PyTorch, JAX, or Dask arrays as array arguments. The following combinations of backend and device (or other capability) are supported.

====================  ====================  ====================
Library               CPU                   GPU
====================  ====================  ====================
NumPy                 ✅                     n/a                 
CuPy                  n/a                   ⛔                   
PyTorch               ✅                     ⛔                   
JAX                   ⚠️ no JIT             ⛔                   
Dask                  ⚠️ computes graph     n/a                 
====================  ====================  ====================

See dev-arrayapi for more information.

Aliases

scipy.interpolate.make_splrep