package scipy

  1. Overview
  2. Docs
Legend:
Library
Module
Module type
Parameter
Class
Class type
type tag = [
  1. | `Akima1DInterpolator
]
type t = [ `Akima1DInterpolator | `Object ] Obj.t
val of_pyobject : Py.Object.t -> t
val to_pyobject : [> tag ] Obj.t -> Py.Object.t
val create : ?axis:int -> x:[> `Ndarray ] Np.Obj.t -> y:[> `Ndarray ] Np.Obj.t -> unit -> t

Akima interpolator

Fit piecewise cubic polynomials, given vectors x and y. The interpolation method by Akima uses a continuously differentiable sub-spline built from piecewise cubic polynomials. The resultant curve passes through the given data points and will appear smooth and natural.

Parameters ---------- x : ndarray, shape (m, ) 1-D array of monotonically increasing real values. y : ndarray, shape (m, ...) N-D array of real values. The length of ``y`` along the first axis must be equal to the length of ``x``. axis : int, optional Specifies the axis of ``y`` along which to interpolate. Interpolation defaults to the first axis of ``y``.

Methods ------- __call__ derivative antiderivative roots

See Also -------- PchipInterpolator : PCHIP 1-D monotonic cubic interpolator. CubicSpline : Cubic spline data interpolator. PPoly : Piecewise polynomial in terms of coefficients and breakpoints

Notes ----- .. versionadded:: 0.14

Use only for precise data, as the fitted curve passes through the given points exactly. This routine is useful for plotting a pleasingly smooth curve through a few given points for purposes of plotting.

References ---------- 1 A new method of interpolation and smooth curve fitting based on local procedures. Hiroshi Akima, J. ACM, October 1970, 17(4), 589-602.

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

Construct a new piecewise polynomial representing the antiderivative.

Antiderivative is also the indefinite integral of the function, and derivative is its inverse operation.

Parameters ---------- nu : int, optional Order of antiderivative to evaluate. Default is 1, i.e., compute the first integral. If negative, the derivative is returned.

Returns ------- pp : PPoly Piecewise polynomial of order k2 = k + n representing the antiderivative of this polynomial.

Notes ----- The antiderivative returned by this function is continuous and continuously differentiable to order n-1, up to floating point rounding error.

If antiderivative is computed and ``self.extrapolate='periodic'``, it will be set to False for the returned instance. This is done because the antiderivative is no longer periodic and its correct evaluation outside of the initially given x interval is difficult.

val construct_fast : ?extrapolate:Py.Object.t -> ?axis:Py.Object.t -> c:Py.Object.t -> x:Py.Object.t -> [> tag ] Obj.t -> Py.Object.t

Construct the piecewise polynomial without making checks.

Takes the same parameters as the constructor. Input arguments ``c`` and ``x`` must be arrays of the correct shape and type. The ``c`` array can only be of dtypes float and complex, and ``x`` array must have dtype float.

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

Construct a new piecewise polynomial representing the derivative.

Parameters ---------- nu : int, optional Order of derivative to evaluate. Default is 1, i.e., compute the first derivative. If negative, the antiderivative is returned.

Returns ------- pp : PPoly Piecewise polynomial of order k2 = k - n representing the derivative of this polynomial.

Notes ----- Derivatives are evaluated piecewise for each polynomial segment, even if the polynomial is not differentiable at the breakpoints. The polynomial intervals are considered half-open, ``a, b)``, except for the last interval which is closed ``[a, b]``.

val extend : ?right:Py.Object.t -> c:Py.Object.t -> x:Py.Object.t -> [> tag ] Obj.t -> Py.Object.t

Add additional breakpoints and coefficients to the polynomial.

Parameters ---------- c : ndarray, size (k, m, ...) Additional coefficients for polynomials in intervals. Note that the first additional interval will be formed using one of the ``self.x`` end points. x : ndarray, size (m,) Additional breakpoints. Must be sorted in the same order as ``self.x`` and either to the right or to the left of the current breakpoints. right Deprecated argument. Has no effect.

.. deprecated:: 0.19

val from_bernstein_basis : ?extrapolate:Py.Object.t -> bp:Py.Object.t -> [> tag ] Obj.t -> Py.Object.t

Construct a piecewise polynomial in the power basis from a polynomial in Bernstein basis.

Parameters ---------- bp : BPoly A Bernstein basis polynomial, as created by BPoly extrapolate : bool or 'periodic', optional If bool, determines whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. If 'periodic', periodic extrapolation is used. Default is True.

val from_spline : ?extrapolate:Py.Object.t -> tck:Py.Object.t -> [> tag ] Obj.t -> Py.Object.t

Construct a piecewise polynomial from a spline

Parameters ---------- tck A spline, as returned by `splrep` or a BSpline object. extrapolate : bool or 'periodic', optional If bool, determines whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. If 'periodic', periodic extrapolation is used. Default is True.

val integrate : ?extrapolate:[ `Periodic | `Bool of bool ] -> a:float -> b:float -> [> tag ] Obj.t -> [ `ArrayLike | `Ndarray | `Object ] Np.Obj.t

Compute a definite integral over a piecewise polynomial.

Parameters ---------- a : float Lower integration bound b : float Upper integration bound extrapolate : ool, 'periodic', None, optional If bool, determines whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. If 'periodic', periodic extrapolation is used. If None (default), use `self.extrapolate`.

Returns ------- ig : array_like Definite integral of the piecewise polynomial over a, b

val roots : ?discontinuity:bool -> ?extrapolate:[ `Periodic | `Bool of bool ] -> [> tag ] Obj.t -> [ `ArrayLike | `Ndarray | `Object ] Np.Obj.t

Find real roots of the the piecewise polynomial.

Parameters ---------- discontinuity : bool, optional Whether to report sign changes across discontinuities at breakpoints as roots. extrapolate : ool, 'periodic', None, optional If bool, determines whether to return roots from the polynomial extrapolated based on first and last intervals, 'periodic' works the same as False. If None (default), use `self.extrapolate`.

Returns ------- roots : ndarray Roots of the polynomial(s).

If the PPoly object describes multiple polynomials, the return value is an object array whose each element is an ndarray containing the roots.

See Also -------- PPoly.solve

val solve : ?y:float -> ?discontinuity:bool -> ?extrapolate:[ `Periodic | `Bool of bool ] -> [> tag ] Obj.t -> [ `ArrayLike | `Ndarray | `Object ] Np.Obj.t

Find real solutions of the the equation ``pp(x) == y``.

Parameters ---------- y : float, optional Right-hand side. Default is zero. discontinuity : bool, optional Whether to report sign changes across discontinuities at breakpoints as roots. extrapolate : ool, 'periodic', None, optional If bool, determines whether to return roots from the polynomial extrapolated based on first and last intervals, 'periodic' works the same as False. If None (default), use `self.extrapolate`.

Returns ------- roots : ndarray Roots of the polynomial(s).

If the PPoly object describes multiple polynomials, the return value is an object array whose each element is an ndarray containing the roots.

Notes ----- This routine works only on real-valued polynomials.

If the piecewise polynomial contains sections that are identically zero, the root list will contain the start point of the corresponding interval, followed by a ``nan`` value.

If the polynomial is discontinuous across a breakpoint, and there is a sign change across the breakpoint, this is reported if the `discont` parameter is True.

Examples --------

Finding roots of ``x**2 - 1, (x - 1)**2`` defined on intervals ``-2, 1, 1, 2``:

>>> from scipy.interpolate import PPoly >>> pp = PPoly(np.array([1, -4, 3], [1, 0, 0]).T, -2, 1, 2) >>> pp.solve() array(-1., 1.)

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 : Format.formatter -> t -> unit

Pretty-print the object to a formatter.

OCaml

Innovation. Community. Security.