package scipy

  1. Overview
  2. Docs
package scipy
Legend:
Library
Module
Module type
Parameter
Class
Class type
type tag = [
  1. | `UnivariateSpline
]
type t = [ `Object | `UnivariateSpline ] Obj.t
val of_pyobject : Py.Object.t -> t
val to_pyobject : [> tag ] Obj.t -> Py.Object.t
val create : ?w:[> `Ndarray ] Np.Obj.t -> ?bbox:Py.Object.t -> ?k:int -> ?s:float -> ?ext:[ `I of int | `S of string ] -> ?check_finite:bool -> x:[> `Ndarray ] Np.Obj.t -> y:[> `Ndarray ] Np.Obj.t -> unit -> t

1-D smoothing spline fit to a given set of data points.

Fits a spline y = spl(x) of degree `k` to the provided `x`, `y` data. `s` specifies the number of knots by specifying a smoothing condition.

Parameters ---------- x : (N,) array_like 1-D array of independent input data. Must be increasing; must be strictly increasing if `s` is 0. y : (N,) array_like 1-D array of dependent input data, of the same length as `x`. w : (N,) array_like, optional Weights for spline fitting. Must be positive. If None (default), weights are all equal. bbox : (2,) array_like, optional 2-sequence specifying the boundary of the approximation interval. If None (default), ``bbox=x[0], x[-1]``. k : int, optional Degree of the smoothing spline. Must be 1 <= `k` <= 5. Default is `k` = 3, a cubic spline. s : float or None, optional Positive smoothing factor used to choose the number of knots. Number of knots will be increased until the smoothing condition is satisfied::

sum((wi * (yi-spl(xi)))**2, axis=0) <= s

If None (default), ``s = len(w)`` which should be a good value if ``1/wi`` is an estimate of the standard deviation of ``yi``. If 0, spline will interpolate through all data points. ext : int or str, optional Controls the extrapolation mode for elements not in the interval defined by the knot sequence.

* if ext=0 or 'extrapolate', return the extrapolated value. * if ext=1 or 'zeros', return 0 * if ext=2 or 'raise', raise a ValueError * if ext=3 of 'const', return the boundary value.

The default value is 0.

check_finite : bool, optional Whether to check that the input arrays contain only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination or non-sensical results) if the inputs do contain infinities or NaNs. Default is False.

See Also -------- InterpolatedUnivariateSpline : Subclass with smoothing forced to 0 LSQUnivariateSpline : Subclass in which knots are user-selected instead of being set by smoothing condition splrep : An older, non object-oriented wrapping of FITPACK splev, sproot, splint, spalde BivariateSpline : A similar class for two-dimensional spline interpolation

Notes ----- The number of data points must be larger than the spline degree `k`.

**NaN handling**: If the input arrays contain ``nan`` values, the result is not useful, since the underlying spline fitting routines cannot deal with ``nan``. A workaround is to use zero weights for not-a-number data points:

>>> from scipy.interpolate import UnivariateSpline >>> x, y = np.array(1, 2, 3, 4), np.array(1, np.nan, 3, 4) >>> w = np.isnan(y) >>> yw = 0. >>> spl = UnivariateSpline(x, y, w=~w)

Notice the need to replace a ``nan`` by a numerical value (precise value does not matter as long as the corresponding weight is zero.)

Examples -------- >>> import matplotlib.pyplot as plt >>> from scipy.interpolate import UnivariateSpline >>> x = np.linspace(-3, 3, 50) >>> y = np.exp(-x**2) + 0.1 * np.random.randn(50) >>> plt.plot(x, y, 'ro', ms=5)

Use the default value for the smoothing parameter:

>>> spl = UnivariateSpline(x, y) >>> xs = np.linspace(-3, 3, 1000) >>> plt.plot(xs, spl(xs), 'g', lw=3)

Manually change the amount of smoothing:

>>> spl.set_smoothing_factor(0.5) >>> plt.plot(xs, spl(xs), 'b', lw=3) >>> plt.show()

val antiderivative : ?n:int -> [> tag ] Obj.t -> Py.Object.t

Construct a new spline representing the antiderivative of this spline.

Parameters ---------- n : int, optional Order of antiderivative to evaluate. Default: 1

Returns ------- spline : UnivariateSpline Spline of order k2=k+n representing the antiderivative of this spline.

Notes -----

.. versionadded:: 0.13.0

See Also -------- splantider, derivative

Examples -------- >>> from scipy.interpolate import UnivariateSpline >>> x = np.linspace(0, np.pi/2, 70) >>> y = 1 / np.sqrt(1 - 0.8*np.sin(x)**2) >>> spl = UnivariateSpline(x, y, s=0)

The derivative is the inverse operation of the antiderivative, although some floating point error accumulates:

>>> spl(1.7), spl.antiderivative().derivative()(1.7) (array(2.1565429877197317), array(2.1565429877201865))

Antiderivative can be used to evaluate definite integrals:

>>> ispl = spl.antiderivative() >>> ispl(np.pi/2) - ispl(0) 2.2572053588768486

This is indeed an approximation to the complete elliptic integral :math:`K(m) = \int_0^\pi/2 1 - m\sin^2 x^

1/2

}

dx`:

>>> from scipy.special import ellipk >>> ellipk(0.8) 2.2572053268208538

val derivative : ?n:int -> [> tag ] Obj.t -> Py.Object.t

Construct a new spline representing the derivative of this spline.

Parameters ---------- n : int, optional Order of derivative to evaluate. Default: 1

Returns ------- spline : UnivariateSpline Spline of order k2=k-n representing the derivative of this spline.

See Also -------- splder, antiderivative

Notes -----

.. versionadded:: 0.13.0

Examples -------- This can be used for finding maxima of a curve:

>>> from scipy.interpolate import UnivariateSpline >>> x = np.linspace(0, 10, 70) >>> y = np.sin(x) >>> spl = UnivariateSpline(x, y, k=4, s=0)

Now, differentiate the spline and find the zeros of the derivative. (NB: `sproot` only works for order 3 splines, so we fit an order 4 spline):

>>> spl.derivative().roots() / np.pi array( 0.50000001, 1.5 , 2.49999998)

This agrees well with roots :math:`\pi/2 + n\pi` of :math:`\cos(x) = \sin'(x)`.

val derivatives : x:float -> [> tag ] Obj.t -> [ `ArrayLike | `Ndarray | `Object ] Np.Obj.t

Return all derivatives of the spline at the point x.

Parameters ---------- x : float The point to evaluate the derivatives at.

Returns ------- der : ndarray, shape(k+1,) Derivatives of the orders 0 to k.

Examples -------- >>> from scipy.interpolate import UnivariateSpline >>> x = np.linspace(0, 3, 11) >>> y = x**2 >>> spl = UnivariateSpline(x, y) >>> spl.derivatives(1.5) array(2.25, 3.0, 2.0, 0)

val get_coeffs : [> tag ] Obj.t -> Py.Object.t

Return spline coefficients.

val get_knots : [> tag ] Obj.t -> Py.Object.t

Return positions of interior knots of the spline.

Internally, the knot vector contains ``2*k`` additional boundary knots.

val get_residual : [> tag ] Obj.t -> Py.Object.t

Return weighted sum of squared residuals of the spline approximation.

This is equivalent to::

sum((wi * (yi-spl(xi)))**2, axis=0)

val integral : a:float -> b:float -> [> tag ] Obj.t -> float

Return definite integral of the spline between two given points.

Parameters ---------- a : float Lower limit of integration. b : float Upper limit of integration.

Returns ------- integral : float The value of the definite integral of the spline between limits.

Examples -------- >>> from scipy.interpolate import UnivariateSpline >>> x = np.linspace(0, 3, 11) >>> y = x**2 >>> spl = UnivariateSpline(x, y) >>> spl.integral(0, 3) 9.0

which agrees with :math:`\int x^2 dx = x^3 / 3` between the limits of 0 and 3.

A caveat is that this routine assumes the spline to be zero outside of the data limits:

>>> spl.integral(-1, 4) 9.0 >>> spl.integral(-1, 0) 0.0

val roots : [> tag ] Obj.t -> Py.Object.t

Return the zeros of the spline.

Restriction: only cubic splines are supported by fitpack.

val set_smoothing_factor : s:Py.Object.t -> [> tag ] Obj.t -> Py.Object.t

Continue spline computation with the given smoothing factor s and with the knots found at the last call.

This routine modifies the spline in place.

val to_string : t -> string

Print the object to a human-readable representation.

val show : t -> string

Print the object to a human-readable representation.

val pp : Stdlib.Format.formatter -> t -> unit

Pretty-print the object to a formatter.