B &]\@sddlmZmZmZddlZddlZddlZddlm Z ddl m Z m Z m Z mZddlmZddlmZddlmZd d d gZd d ZddZd ddZGdd d eZddZddZddZddZd!dd Zd"dd ZdS)#)divisionprint_functionabsolute_importN) string_types)get_lapack_funcs LinAlgErrorcholesky_bandedcho_solve_banded)_bspl) _fitpack_impl)_fitpackBSplinemake_interp_splinemake_lsq_splinecCst|dkrdSttj|S)zFProduct of a list of numbers; ~40x faster vs np.prod for Python tuplesrr )len functoolsreduceoperatormul)xr:lib/python3.7/site-packages/scipy/interpolate/_bsplines.pyprods rcCst|tjrtjStjSdS)z>Return np.complex128 for complex dtypes, np.float64 otherwise.N)npZ issubdtypeZcomplexfloatingZcomplex_float_)dtyperrr _get_dtypesrFcCs@t|}t|j}|j|dd}|r=n, ...) spline coefficients k : int B-spline order extrapolate : bool or 'periodic', optional whether to extrapolate beyond the base interval, ``t[k] .. t[n]``, or to return nans. If True, extrapolates the first and last polynomial pieces of b-spline functions active on the base interval. If 'periodic', periodic extrapolation is used. Default is True. axis : int, optional Interpolation axis. Default is zero. Attributes ---------- t : ndarray knot vector c : ndarray spline coefficients k : int spline degree extrapolate : bool If True, extrapolates the first and last polynomial pieces of b-spline functions active on the base interval. axis : int Interpolation axis. tck : tuple A read-only equivalent of ``(self.t, self.c, self.k)`` Methods ------- __call__ basis_element derivative antiderivative integrate construct_fast Notes ----- B-spline basis elements are defined via .. math:: B_{i, 0}(x) = 1, \textrm{if $t_i \le x < t_{i+1}$, otherwise $0$,} B_{i, k}(x) = \frac{x - t_i}{t_{i+k} - t_i} B_{i, k-1}(x) + \frac{t_{i+k+1} - x}{t_{i+k+1} - t_{i+1}} B_{i+1, k-1}(x) **Implementation details** - At least ``k+1`` coefficients are required for a spline of degree `k`, so that ``n >= k+1``. Additional coefficients, ``c[j]`` with ``j > n``, are ignored. - B-spline basis elements of degree `k` form a partition of unity on the *base interval*, ``t[k] <= x <= t[n]``. Examples -------- Translating the recursive definition of B-splines into Python code, we have: >>> def B(x, k, i, t): ... if k == 0: ... return 1.0 if t[i] <= x < t[i+1] else 0.0 ... if t[i+k] == t[i]: ... c1 = 0.0 ... else: ... c1 = (x - t[i])/(t[i+k] - t[i]) * B(x, k-1, i, t) ... if t[i+k+1] == t[i+1]: ... c2 = 0.0 ... else: ... c2 = (t[i+k+1] - x)/(t[i+k+1] - t[i+1]) * B(x, k-1, i+1, t) ... return c1 + c2 >>> def bspline(x, t, c, k): ... n = len(t) - k - 1 ... assert (n >= k+1) and (len(c) >= n) ... return sum(c[i] * B(x, k, i, t) for i in range(n)) Note that this is an inefficient (if straightforward) way to evaluate B-splines --- this spline class does it in an equivalent, but much more efficient way. Here we construct a quadratic spline function on the base interval ``2 <= x <= 4`` and compare with the naive way of evaluating the spline: >>> from scipy.interpolate import BSpline >>> k = 2 >>> t = [0, 1, 2, 3, 4, 5, 6] >>> c = [-1, 2, 0, -1] >>> spl = BSpline(t, c, k) >>> spl(2.5) array(1.375) >>> bspline(2.5, t, c, k) 1.375 Note that outside of the base interval results differ. This is because `BSpline` extrapolates the first and last polynomial pieces of b-spline functions active on the base interval. >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots() >>> xx = np.linspace(1.5, 4.5, 50) >>> ax.plot(xx, [bspline(x, t, c ,k) for x in xx], 'r-', lw=3, label='naive') >>> ax.plot(xx, spl(xx), 'b-', lw=4, alpha=0.7, label='BSpline') >>> ax.grid(True) >>> ax.legend(loc='best') >>> plt.show() References ---------- .. [1] Tom Lyche and Knut Morken, Spline methods, http://www.uio.no/studier/emner/matnat/ifi/INF-MAT5340/v05/undervisningsmateriale/ .. [2] Carl de Boor, A practical guide to splines, Springer, 2001. Trcstt|t||_t||_tj |tj d|_ |dkrH||_ n t ||_ |j jd|jd}d|kr|jjksntd||jf||_|dkrt|j||_|dkrtd|j jdkrtd||jdkrtdd |d |ft|j dkrtd tt|j ||dd krDtd t|j s^td |jjdkrttd |jjd|krtdt|jj}tj |j|d|_dS)N)rperiodicrr z%s must be between 0 and %sz Spline order cannot be negative.z$Knot vector must be one-dimensional.z$Need at least %d knots for degree %dz(Knots must be in a non-decreasing order.z!Need at least two internal knots.z#Knots should not have nans or infs.z,Coefficients must be at least 1-dimensional.z0Knots, coefficients and degree are inconsistent.)superr__init__rindexkrasarraycrZfloat64t extrapolateboolshapendimr"axisrollaxisZdiffanyruniquer r!rr)selfr-r,r*r.r2nZdt) __class__rrr(s@    " zBSpline.__init__cCs0t|}||||_|_|_||_||_|S)zConstruct a spline without making checks. Accepts same parameters as the regular constructor. Input arrays `t` and `c` must of correct shape and dtype. )object__new__r-r,r*r.r2)clsr-r,r*r.r2r6rrrconstruct_fasts  zBSpline.construct_fastcCs|j|j|jfS)z@Equivalent to ``(self.t, self.c, self.k)`` (read-only). )r-r,r*)r6rrrtcksz BSpline.tckcCsbt|d}t|}tj|ddf|||ddf|f}t|}d||<|||||S)a_Return a B-spline basis element ``B(x | t[0], ..., t[k+1])``. Parameters ---------- t : ndarray, shape (k+1,) internal knots extrapolate : bool or 'periodic', optional whether to extrapolate beyond the base interval, ``t[0] .. t[k+1]``, or to return nans. If 'periodic', periodic extrapolation is used. Default is True. Returns ------- basis_element : callable A callable representing a B-spline basis element for the knot vector `t`. Notes ----- The order of the b-spline, `k`, is inferred from the length of `t` as ``len(t)-2``. The knot vector is constructed by appending and prepending ``k+1`` elements to internal knots `t`. Examples -------- Construct a cubic b-spline: >>> from scipy.interpolate import BSpline >>> b = BSpline.basis_element([0, 1, 2, 3, 4]) >>> k = b.k >>> b.t[k:-k] array([ 0., 1., 2., 3., 4.]) >>> k 3 Construct a second order b-spline on ``[0, 1, 1, 2]``, and compare to its explicit form: >>> t = [-1, 0, 1, 1, 2] >>> b = BSpline.basis_element(t[1:]) >>> def f(x): ... return np.where(x < 1, x*x, (2. - x)**2) >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots() >>> x = np.linspace(0, 2, 51) >>> ax.plot(x, b(x), 'g', lw=3) >>> ax.plot(x, f(x), 'r', lw=8, alpha=0.4) >>> ax.grid(True) >>> plt.show() r&rr g?)rr$rr_Z zeros_liker<)r;r-r.r*r,rrr basis_elements 8 , zBSpline.basis_elementNc Cs>|dkr|j}t|}|j|j}}tj|tjd}|dkr|jj |j d}|j|j ||j|j |j||j|j }d}tj t |t |jjddf|jjd}|||||||||jjdd}|jdkr:tt|j}||||j|d||||jd}||}|S)a Evaluate a spline function. Parameters ---------- x : array_like points to evaluate the spline at. nu: int, optional derivative to evaluate (default is 0). extrapolate : bool or 'periodic', optional whether to extrapolate based on the first and last intervals or return nans. If 'periodic', periodic extrapolation is used. Default is `self.extrapolate`. Returns ------- y : array_like Shape is determined by replacing the interpolation axis in the coefficient array with the shape of `x`. N)rr%r Fr)r.rr+r0r1rZravelrr-sizer*emptyrrr,r_ensure_c_contiguous _evaluatereshaper2listrangeZ transpose) r6rnur.Zx_shapeZx_ndimr7outlrrr__call__6s&  * 0 zBSpline.__call__c Cs0t|j|j|jjdd|j||||dS)Nrr>)r evaluate_spliner-r,rEr0r*)r6ZxprHr.rIrrrrDeszBSpline._evaluatecCs0|jjjs|j|_|jjjs,|j|_dS)zs c and t may be modified by the user. The Cython code expects that they are C contiguous. N)r-flags c_contiguousrr,)r6rrrrCis   zBSpline._ensure_c_contiguousr cCsp|j}t|jt|}|dkrDtj|t|f|jddf}t|j||j f|}|j ||j |j dS)adReturn a b-spline representing the derivative. Parameters ---------- nu : int, optional Derivative order. Default is 1. Returns ------- b : BSpline object A new instance representing the derivative. See Also -------- splder, splantider rr N)r.r2) r,rr-rr?zerosr0r Zsplderr*r<r.r2)r6rHr,ctr=rrr derivativets$ zBSpline.derivativecCs|j}t|jt|}|dkrDtj|t|f|jddf}t|j||j f|}|j dkrjd}n|j }|j |||j dS)aReturn a b-spline representing the antiderivative. Parameters ---------- nu : int, optional Antiderivative order. Default is 1. Returns ------- b : BSpline object A new instance representing the antiderivative. Notes ----- 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. See Also -------- splder, splantider rr Nr%F)r.r2) r,rr-rr?rOr0r splantiderr*r.r<r2)r6rHr,rPr=r.rrrantiderivatives$ zBSpline.antiderivativec Csf|dkr|j}|d}||kr0||}}d}|jj|jd}|dkr|st||j|j}t||j|}|jjdkr|j \}}}t |||||\} } | |St j dt|jjddf|jjd} |j}t|jt|} | dkrt j|t | f|jddf}t|j||jfd\} }}|dkr|j|j|j|}}||}||}t||\}}|dkrt j||gt jd}t| ||jdd||dd| | d| d} | |9} n&t jdt|jjddf|jjd} ||||}||}||kr`t j||gt jd}t| ||jdd||dd| | | d| d7} nt j||gt jd}t| ||jdd||dd| | | d| d7} t j||||gt jd}t| ||jdd||dd| | | d| d7} nHt j||gt jd}t| ||jdd||d|| | d| d} | |9} | |jddS) aCompute a definite integral of the spline. Parameters ---------- a : float Lower limit of integration. b : float Upper limit of integration. extrapolate : bool or 'periodic', optional whether to extrapolate beyond the base interval, ``t[k] .. t[-k-1]``, or take the spline to be zero outside of the base interval. If 'periodic', periodic extrapolation is used. If None (default), use `self.extrapolate`. Returns ------- I : array_like Definite integral of the spline over the interval ``[a, b]``. Examples -------- Construct the linear spline ``x if x < 1 else 2 - x`` on the base interval :math:`[0, 2]`, and integrate it >>> from scipy.interpolate import BSpline >>> b = BSpline.basis_element([0, 1, 2]) >>> b.integrate(0, 1) array(0.5) If the integration limits are outside of the base interval, the result is controlled by the `extrapolate` parameter >>> b.integrate(-1, 1) array(0.0) >>> b.integrate(-1, 1, extrapolate=False) array(0.5) >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots() >>> ax.grid(True) >>> ax.axvline(0, c='r', lw=5, alpha=0.5) # base interval >>> ax.axvline(2, c='r', lw=5, alpha=0.5) >>> xx = [-1, 1, 2] >>> ax.plot(xx, b(xx)) >>> plt.show() Nr r>r%r&)rrF)r.rCr-rAr*maxminr,r1r=_dierckxZ_splintrrBrr0rrr?rOr rRdivmodr+rr rLrE)r6abr.Zsignr7r-r,r*ZintegralZwrkrIrPZtaZcaZkaZtsZteZperiodZintervalZ n_periodsleftrrrr integratesn0    & $     zBSpline.integrate)Tr)Tr)T)rN)r )r )N)__name__ __module__ __qualname____doc__r( classmethodr<propertyr=r@rKrDrCrQrSr[ __classcell__rr)r8rr.s/  > /  (cCstt|}|ddkr"td||dd}||d| d}tj|df|d||df|df}|S)zSGiven data x, construct the knot vector w/ not-a-knot BC. cf de Boor, XIII(12).r&r z Odd degree for now only. Got %s.rr>)rr+r"r?)rr*mr-rrr _not_a_knotBs    ,rdcCs$tj|df|||df|fS)zBConstruct a knot vector appropriate for the order-k interpolation.rr>)rr?)rr*rrr_augkntOsrecCsNt|trJ|dkr$dt|fg}n&|dkr>dt|fg}n td||S)NZclampedr Znaturalr&zUnknown boundary condition : %s) isinstancerrrOr")derivZ target_shaperrr_convert_string_aliasesTs  rhcCsR|dk rtd|j|j|d f|d||ksd|d || krptd|t||jd d}t|\} } | jd} t||jd d}t|\} }| jd}|j}|j|d }||| |krtd||| |f|}}tjd||d |ftjdd}tj||||| d| dkrbt|||d|||| |dkrtj|||d |||| ||dt|jd d}tj||f|jd }| dkr| d ||d| <| d ||| ||<|dkr | d ||||d<|r&t!tj"||f\}}t#d||f\}|||||ddd\}}} }|dkrft$dn|dkr~td| t | |f|jd d} tj|| ||d S) aCompute the (coefficients of) interpolating B-spline. Parameters ---------- x : array_like, shape (n,) Abscissas. y : array_like, shape (n, ...) Ordinates. k : int, optional B-spline degree. Default is cubic, k=3. t : array_like, shape (nt + k + 1,), optional. Knots. The number of knots needs to agree with the number of datapoints and the number of derivatives at the edges. Specifically, ``nt - n`` must equal ``len(deriv_l) + len(deriv_r)``. bc_type : 2-tuple or None Boundary conditions. Default is None, which means choosing the boundary conditions automatically. Otherwise, it must be a length-two tuple where the first element sets the boundary conditions at ``x[0]`` and the second element sets the boundary conditions at ``x[-1]``. Each of these must be an iterable of pairs ``(order, value)`` which gives the values of derivatives of specified orders at the given edge of the interpolation interval. Alternatively, the following string aliases are recognized: * ``"clamped"``: The first derivatives at the ends are zero. This is equivalent to ``bc_type=([(1, 0.0)], [(1, 0.0)])``. * ``"natural"``: The second derivatives at ends are zero. This is equivalent to ``bc_type=([(2, 0.0)], [(2, 0.0)])``. * ``"not-a-knot"`` (default): The first and second segments are the same polynomial. This is equivalent to having ``bc_type=None``. axis : int, optional Interpolation axis. Default 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) if the inputs do contain infinities or NaNs. Default is True. Returns ------- b : a BSpline object of the degree ``k`` and with knots ``t``. Examples -------- Use cubic interpolation on Chebyshev nodes: >>> def cheb_nodes(N): ... jj = 2.*np.arange(N) + 1 ... x = np.cos(np.pi * jj / 2 / N)[::-1] ... return x >>> x = cheb_nodes(20) >>> y = np.sqrt(1 - x**2) >>> from scipy.interpolate import BSpline, make_interp_spline >>> b = make_interp_spline(x, y) >>> np.allclose(b(x), y) True Note that the default is a cubic spline with a not-a-knot boundary condition >>> b.k 3 Here we use a 'natural' spline, with zero 2nd derivatives at edges: >>> l, r = [(2, 0.0)], [(2, 0.0)] >>> b_n = make_interp_spline(x, y, bc_type=(l, r)) # or, bc_type="natural" >>> np.allclose(b_n(x), y) True >>> x0, x1 = x[0], x[-1] >>> np.allclose([b_n(x0, 2), b_n(x1, 2)], [0, 0]) True Interpolation of parametric curves is also supported. As an example, we compute a discretization of a snail curve in polar coordinates >>> phi = np.linspace(0, 2.*np.pi, 40) >>> r = 0.3 + np.cos(phi) >>> x, y = r*np.cos(phi), r*np.sin(phi) # convert to Cartesian coordinates Build an interpolating curve, parameterizing it by the angle >>> from scipy.interpolate import make_interp_spline >>> spl = make_interp_spline(phi, np.c_[x, y]) Evaluate the interpolant on a finer grid (note that we transpose the result to unpack it into a pair of x- and y-arrays) >>> phi_new = np.linspace(0, 2.*np.pi, 100) >>> x_new, y_new = spl(phi_new).T Plot the result >>> import matplotlib.pyplot as plt >>> plt.plot(x, y, 'o') >>> plt.plot(x_new, y_new, '-') >>> plt.show() See Also -------- BSpline : base class representing the B-spline objects CubicSpline : a cubic spline in the polynomial basis make_lsq_spline : a similar factory function for spline fitting UnivariateSpline : a wrapper over FITPACK spline fitting routines splrep : a wrapper over FITPACK spline fitting routines Nz not-a-knot)NNzUnknown boundary condition: %szaxis {} is out of boundsrcss|]}|dk VqdS)Nr).0_rrr sz%make_interp_spline..z6Too much info for k=0: t and bc_type can only be None.r>)r)r2r z0Too much info for k=1: bc_type can only be None.r&g@z'Expect x to be a 1-D sorted array_like.zExpect non-negative k.z'Expect t to be a 1-D sorted array_like.zx and y are incompatible.zGot %d knots, need at least %d.zOut of bounds w/ x = %s.zNThe number of derivatives at boundaries does not match: expected %s, got %s+%sF)rorder)offset)gbsvT) overwrite_ab overwrite_bzCollocation matix is singular.z0illegal value in %d-th argument of internal gbsv)%rfrrjr"rr+r1formatr4r$r?r3rrrrr<rr)rdrerAr0rhrlrOrr Z_collocZ_handle_lhs_derivativesrrBrEmapZasarray_chkfiniterr)ryr*r-Zbc_typer2r#Zderiv_lZderiv_rr,Z deriv_l_ordsZ deriv_l_valsZnleftZ deriv_r_ordsZ deriv_r_valsZnrightr7ntZklZkuabextradimrhsrtZluZpivinforrrrlss                       , ,&     "          c CsXt||}t||}t||}|dk r2t||}n t|}t|}|j |kr`|jkspntd||dkr||j7}t||}|jdkst |dd|dddkrtd|j d|dkrtd|dkrtd|jdkst |dd|dddkr$td |j |j dkr>td |dkrvt |||k||| kBrvtd ||j |j krtd |j |d}d }t |j dd} tj |d|ftjdd} tj || f|jdd} t||||d| || | | |f|j dd} t| d ||d} t| |f| d |d} t| } tj|| ||dS)a Compute the (coefficients of) an LSQ B-spline. The result is a linear combination .. math:: S(x) = \sum_j c_j B_j(x; t) of the B-spline basis elements, :math:`B_j(x; t)`, which minimizes .. math:: \sum_{j} \left( w_j \times (S(x_j) - y_j) \right)^2 Parameters ---------- x : array_like, shape (m,) Abscissas. y : array_like, shape (m, ...) Ordinates. t : array_like, shape (n + k + 1,). Knots. Knots and data points must satisfy Schoenberg-Whitney conditions. k : int, optional B-spline degree. Default is cubic, k=3. w : array_like, shape (n,), optional Weights for spline fitting. Must be positive. If ``None``, then weights are all equal. Default is ``None``. axis : int, optional Interpolation axis. Default is zero. 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) if the inputs do contain infinities or NaNs. Default is True. Returns ------- b : a BSpline object of the degree `k` with knots `t`. Notes ----- The number of data points must be larger than the spline degree `k`. Knots `t` must satisfy the Schoenberg-Whitney conditions, i.e., there must be a subset of data points ``x[j]`` such that ``t[j] < x[j] < t[j+k+1]``, for ``j=0, 1,...,n-k-2``. Examples -------- Generate some noisy data: >>> x = np.linspace(-3, 3, 50) >>> y = np.exp(-x**2) + 0.1 * np.random.randn(50) Now fit a smoothing cubic spline with a pre-defined internal knots. Here we make the knot vector (k+1)-regular by adding boundary knots: >>> from scipy.interpolate import make_lsq_spline, BSpline >>> t = [-1, 0, 1] >>> k = 3 >>> t = np.r_[(x[0],)*(k+1), ... t, ... (x[-1],)*(k+1)] >>> spl = make_lsq_spline(x, y, t, k) For comparison, we also construct an interpolating spline for the same set of data: >>> from scipy.interpolate import make_interp_spline >>> spl_i = make_interp_spline(x, y) Plot both: >>> import matplotlib.pyplot as plt >>> xs = np.linspace(-3, 3, 100) >>> plt.plot(x, y, 'ro', ms=5) >>> plt.plot(xs, spl(xs), 'g-', lw=3, label='LSQ spline') >>> plt.plot(xs, spl_i(xs), 'b-', lw=3, alpha=0.7, label='interp spline') >>> plt.legend(loc='best') >>> plt.show() **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: >>> y[8] = np.nan >>> w = np.isnan(y) >>> y[w] = 0. >>> tck = make_lsq_spline(x, y, t, 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.) See Also -------- BSpline : base class representing the B-spline objects make_interp_spline : a similar factory function for interpolating splines LSQUnivariateSpline : a FITPACK-based spline fitting routine splrep : a FITPACK-based fitting routine Nzaxis {} is out of boundsrr r>z'Expect x to be a 1-D sorted array_like.zNeed more x points.zExpect non-negative k.z'Expect t to be a 1-D sorted array_like.zx & y are incompatible.zOut of bounds w/ x = %s.zIncompatible weights.Trq)rrr)rulowerr#)rvr#)r2)r$rZ ones_likerr)r1r"rwr3r4r0rArrOrrr Z _norm_eq_lsqrErr rrr<)rryr-r*wr2r#r7rr|r{r}Z cho_decompr,rrrr`sTi        ,0,     )F)rmNNrT)rmNrT) Z __future__rrrrrZnumpyrZscipy._lib.sixrZ scipy.linalgrrrr r r r rV__all__rrr$r9rrdrerhrlrrrrrrs2          t