doi SrSSKrSSKrSSKrSSKJrJrJr SSK J r J r J r J r JrJrJr SSKJr SrSrS(S jrS rS rS(S jr\"SS SS9SSSSSSSS.Sj5r\4SjrSrSr"SS5r"SS5rSr"SS5r Sr!\!S-\!S-S S!.r"S"r#\4S#jr$\"SS SS9SSSSSSSSS$.S%j5r%\"SS SS9SSSSSSSSSS&. S'j5r&g))aReplicate FITPACK's logic for constructing smoothing spline functions and curves. Currently provides analogs of splrep and splprep python routines, i.e. curfit.f and parcur.f routines (the drivers are fpcurf.f and fppara.f, respectively) The Fortran sources are from https://github.com/scipy/scipy/blob/maintenance/1.11.x/scipy/interpolate/fitpack/ .. [1] P. Dierckx, "Algorithms for smoothing data with periodic and parametric splines, Computer Graphics and Image Processing", 20 (1982) 171-184. :doi:`10.1016/0146-664X(82)90043-0`. .. [2] P. Dierckx, "Curve and surface fitting with splines", Monographs on Numerical Analysis, Oxford University Press, 1993. .. [3] P. Dierckx, "An algorithm for smoothing, differentiation and integration of experimental data using spline functions", Journal of Computational and Applied Mathematics, vol. I, no 3, p. 165 (1975). https://doi.org/10.1016/0771-050X(75)90034-0 N)array_namespace concat_1dxp_capabilities) _not_a_knotmake_interp_splineBSplinefpcheck _lsq_solve_qr$_lsq_solve_qr_for_root_rati_periodic_periodic_knots)_dierckxgMbP?Fc [XX#XES9u pgn[R"UR55(a[ [ S5eX4$)Nperiodicr)r npisnansum ValueError_iermesg) xytkwr_fp residualss \/var/www/html/land-ocr/venv/lib/python3.13/site-packages/scipy/interpolate/_fitpack_repro.py_get_residualsr!-sG+1qLAq! xx   !%% =c6UcgUS;a[SU35eU$)N not-a-knot)r$rzKOnly 'not-a-knot' and 'periodic' boundary conditions are recognised, found )r)bc_types r _validate_bc_typer&>s600""),- - Nr"c[R"XX#5n[R"X5n[RUSUXAUS4nU$)aFAdd a new knot. (Approximately) replicate FITPACK's logic: 1. split the `x` array into knot intervals, ``t(j+k) <= x(i) <= t(j+k+1)`` 2. find the interval with the maximum sum of residuals 3. insert a new knot into the middle of that interval. NB: a new knot is in fact an `x` value at the middle of the interval. So *the knots are a subset of `x`*. This routine is an analog of https://github.com/scipy/scipy/blob/v1.11.4/scipy/interpolate/fitpack/fpcurf.f#L190-L215 (cf _split function) and https://github.com/scipy/scipy/blob/v1.11.4/scipy/interpolate/fitpack/fpknot.f N)rfpknotr searchsortedr_)rrrrnew_knotidx_tt_news r add_knotr.JsF"qQ2H OOA (E EE!FU)Xy0 1E Lr"c [R"U[S9n[R"U[S9nURR(dUR 5nURR(dUR 5nUc[R "U[S9nO[R"U[S9nURR(dUR 5nURS:wa[SUR<S35eUS:R5(a [S5eUR5S:Xa [S5eURS:XdURS :a[S UR<S 35e[U5nU(a/URS :wa[S UR<S U<S 35eO7URS:wa[S UR<SU<S 35eUSS2S4nURSURS:wa'[SUR<SURS 35eURSURS:wa([SUR<SUR<S 35eURS:wdUSSUSS:R5(a [S5e[R"U5nUS:a[SU<35eUc [U5nUc [!U5nU(a,[R""USUSSS9(d [S5eXX#XEU4$)zACommon input validations for generate_knots and make_splrep. dtypeNr w.ndim = z not implemented yet.rzWeights must be non-negativezAll weights are zero.z y.ndim = z not supported (must be 1 or 2.)z% != 2 not supported with parametric =.z% != 1 not supported with parametric =z"Weights is incompatible: w.shape =z != z Data is incompatible: x.shape = z and y.shape = z(Expect `x` to be an ordered 1D sequence.z"`s` must be non-negative. Got s = gV瞯<)atolzPFirst and last points does not match which is required for `bc_type='periodic'`.)rasarrayfloatflags c_contiguouscopy ones_likendimranyrboolshapeoperatorindexminmaxallclose) rrrrsxbxe parametricrs r _validate_inputsrJbs 1E"A 1E"A 77   FFH 77   FFHy LL% ( JJq &ww##A 66Q; {*?@A A E;;==;< < 557a<45 5 vv{affqjIAFF;&FGHHj!J 66Q; {*PJ>QRST T  66Q; {*PJ>QRST T agJwwqzQWWQZ>QWWKtAGG9ANOOwwqzQWWQZ!@AA z V z V AaD!B%e<56 6 qb  r"T)cpu_onlyjax_jitallow_dask_compute)rrGrHrrFnestr%c #d# [XU5n [U5nUS:Hn US:XaIUcUb [S5eU (aUS:a [X5n O [ X5n U R U 5v g[ XX%XcU[R"U5S:HU S9 upp%pcn[XX#XEXgXS9 ShvN gN7f) a Generate knot vectors until the Least SQuares (LSQ) criterion is satified. Parameters ---------- x, y : array_like The data points defining the curve ``y = f(x)``. w : array_like, optional Weights. xb : float, optional The boundary of the approximation interval. If None (default), is set to ``x[0]``. xe : float, optional The boundary of the approximation interval. If None (default), is set to ``x[-1]``. k : int, optional The spline degree. Default is cubic, ``k = 3``. s : float, optional The smoothing factor. Default is ``s = 0``. nest : int, optional Stop when at least this many knots are placed. ends are equivalent. 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. Yields ------ t : ndarray Knot vectors with an increasing number of knots. The generator is finite: it stops when the smoothing critetion is satisfied, or when then number of knots exceeds the maximum value: the user-provided `nest` or `x.size + k + 1` --- which is the knot vector for the interpolating spline. Examples -------- Generate some noisy data and fit a sequence of LSQ splines: >>> import numpy as np >>> import matplotlib.pyplot as plt >>> from scipy.interpolate import make_lsq_spline, generate_knots >>> rng = np.random.default_rng(12345) >>> x = np.linspace(-3, 3, 50) >>> y = np.exp(-x**2) + 0.1 * rng.standard_normal(size=50) >>> knots = list(generate_knots(x, y, s=1e-10)) >>> for t in knots[::3]: ... spl = make_lsq_spline(x, y, t) ... xs = xs = np.linspace(-3, 3, 201) ... plt.plot(xs, spl(xs), '-', label=f'n = {len(t)}', lw=3, alpha=0.7) >>> plt.plot(x, y, 'o', label='data') >>> plt.plot(xs, np.exp(-xs**2), '--') >>> plt.legend() Note that increasing the number of knots make the result follow the data more and more closely. Also note that a step of the generator may add multiple knots: >>> [len(t) for t in knots] [8, 9, 10, 12, 16, 24, 40, 48, 52, 54] Notes ----- The routine generates successive knots vectors of increasing length, starting from ``2*(k+1)`` to ``len(x) + k + 1``, trying to make knots more dense in the regions where the deviation of the LSQ spline from data is large. When the maximum number of knots, ``len(x) + k + 1`` is reached (this happens when ``s`` is small and ``nest`` is large), the generator stops, and the last output is the knots for the interpolation with the not-a-knot boundary condition. Knots are located at data sites, unless ``k`` is even and the number of knots is ``len(x) + k + 1``. In that case, the last output of the generator has internal knots at Greville sites, ``(x[1:] + x[:-1]) / 2``. .. versionadded:: 1.15.0 rrNzs == 0 is interpolation onlyrr3rIrxp) rr&rr rr7rJrr=_generate_knots_impl) rrrrGrHrrFrOr%rSrrs r generate_knotsrUsr q !B(G*$HAv  q};< < A%AA!Ajjm, aA2"''!*/A!r $A!QQQsB&B0(B.)B0c #v# U[-n URn Uc8U(a[U SU--SU-S-5nO=[X-S-SU-S-5nO%USUS--:a[SU<SSUS--S35eU(dSUS--n X-S-n OSUS--n U SU--n XC- nU(ax[R "U [ S9n[SUS-5H*nUSUU- U-- UU'X S- UU--UUU-S-'M, [XXX(S 9unnUU- U :dX:XaUv gOS nS nU(d+[R"U/US--U/US---[ S9nO3[R "SU-S-[ S9nX S-S-S- XS-'SnURSn[U 5GHnU(a_URSnX?U'XOUU- S- '[SUS-5H/nUUU- U- S- U- XU- 'XU-U-UUU- U-S- 'M1 U RU5v Un[XXUUS 9unnUU- n[U5U :dUS:a gUU :XaSnO>UU- nUU :a[WU-U- 5OWS-n[US-[UUS-S55n[U5Hn[XUU5nURSnUU :a4U(d [X5nO [!X5nU RU5v gUU:aU RU5v gUUS- :dM[XXX(S 9unnM GM g7f) Nr3rNr`nest` too small: nest = < 2*(k+1) = r4r0rr)rr)TOLsizerDrrzerosr8ranger!r7r@absintrCr.rr )rrrrGrHrrFrOrrSaccmnminnmaxperrirrfpoldnplusniterjrfpmsdeltanpl1s r rTrTs c'C A | q1Q3w!a(Dquqy!A#'*D !QU) 9$-1Q3yPQRS S !a%yuqy!a%y1Q3w 'C HHT 'q!a%AQ41q5C-'AaDU8a#g-Aa!eaiL!qQ1@2 6C<4<G (  JJtQqSzRD!A#J.e < HHQqS1WE *!eaZ!^$a%  Aa  AaDa!eaiL1a!e_QUQY]+c1a%#$U8c>!a%!)a- %jjm&qQQ19; 2Av IO  9EBJE05 3ut|e+,qDaT5!8Q!78EuAq),A ADy#A)A'-Ajjm#Dyjjm#519}-aAAQ 11Ez s LL9!L9cfSn[US-5HnX-U:wdM X@UXU-- -nM U$)Ng?r3)r])rrerjrresrFs r proddrps? C 1Q3Z 5A: aD1qS6M "C Jr"c URSnXU- S- X- nUSU-- S- n[R"US- US-4[S9n[ US- 5HCnXa-S-n[ US-5H'nXh-n X U-S-X - [ X Xq5- XVU4'M) ME XSU- U--n[R "[ US- 5V s/sHoPM sn [RS9n X!- S- n XZU 4$s sn f)aDiscontinuity matrix: jumps of k-th derivatives of b-splines at internal knots. See Eqs. (9)-(10) of Ref. [1], or, equivalently, Eq. (3.43) of Ref. [2]. This routine assumes internal knots are all simple (have multiplicity =1). Parameters ---------- t : ndarray, 1D, shape(n,) Knots. k : int The spline degree Returns ------- disc : ndarray, shape(n-2*k-1, k+2) The jumps of the k-th derivatives of b-splines at internal knots, ``t[k+1], ...., t[n-k-1]``. offset : ndarray, shape(2-2*k-1,) Offsets nc : int Notes ----- The normalization here follows FITPACK: (https://github.com/scipy/scipy/blob/maintenance/1.11.x/scipy/interpolate/fitpack/fpdisc.f#L36) The k-th derivative jumps are multiplied by a factor:: (delta / nrint)**k / k! where ``delta`` is the length of the interval spanned by internal knots, and ``nrint`` is one less the number of internal knots (i.e., the number of subintervals between them). References ---------- .. [1] Paul Dierckx, Algorithms for smoothing data with periodic and parametric splines, Computer Graphics and Image Processing, vol. 20, p. 171 (1982). :doi:`10.1016/0146-664X(82)90043-0` .. [2] Tom Lyche and Knut Morken, Spline methods, http://www.uio.no/studier/emner/matnat/ifi/INF-MAT5340/v05/undervisningsmateriale/ rrr3r0)r@remptyr8r]rparrayint64) rrrhrlnrintmatrjjrjiireoffsetncs r discr{s^  A !eaiL14 E !GaKE 88UQYA&e 4DEAI FQJA,BA!eaiL14/5q3DDDRL E\A DXX%a.1.Qq.1 BF B  2s C4c2\rSrSrSrSSSS.SjjrSrSrg) FiaHThe r.h.s. of ``f(p) = s``. Given scalar `p`, we solve the system of equations in the LSQ sense: | A | @ | c | = | y | | B / p | | 0 | | 0 | where `A` is the matrix of b-splines and `b` is the discontinuity matrix (the jumps of the k-th derivatives of b-spline basis elements at knots). Since we do that repeatedly while minimizing over `p`, we QR-factorize `A` only once and update the QR factorization only of the `B` rows of the augmented matrix |A, B/p|. The system of equations is Eq. (15) Ref. [1]_, the strategy and implementation follows that of FITPACK, see specific links below. References ---------- [1] P. Dierckx, Algorithms for Smoothing Data with Periodic and Parametric Splines, COMPUTER GRAPHICS AND IMAGE PROCESSING vol. 20, pp 171-184 (1982.) https://doi.org/10.1016/0146-664X(82)90043-0 N)RYcXlX lX0lX@lUc[R "U[ S9OUnURS:wa[SUR<S35eX`l XPl URS:wa[SUR<S35e[X45upn UcUc[XX4U5upx n URSU- S- n US-nURSU:wa$[S URS<S US-<S 35e[R"U RSURS4[ S9n[RUSU U4Ul[R"XRS-URS-4[ S9nUSU 2SS24USU 2SU24'UUl[R[R$"U [R&S9U 4UlXlXlg) Nr0rr2 != 1.r3&F: expected y.ndim == 2, got y.ndim = instead.rzInternal error: R.shape[1] =z != k+1 =r4)rrrrrr<r8r=rrrFr{r r@r\r*YYAAarangertryrzb)selfrrrrrFrr~rrb_offsetb_ncrrznzzrs r __init__ F.__init__s,-IBLL% (1 66Q; {&12 2 66Q;FQVVKyQR R!JT 9)!a8MA!Q WWQZ!^a  U 771: < ~Z!A#JK K HHaggaj!''!*-U ;%%#2 "XXrGGAJq1 ?"ay3B38 eeBIIb98CD r"c URR5nURR5nURnURU- X$S2SS24'UR R5n[ R"X#XEUS9 [ R"X$URURURURURU5upgn[URX`R5n XlXR - $)N)startrow)rr;ryrzrrr qr_reducefpbackrrrrrr splrF) rpABryrzQYcrrrs r __call__ F.__call__Js WW\\^!!# WWVVaZ36 WW\\^ 2r;??2466466466466466SUVbdffa(FF{r") rrrrrzryrFrrrrrN__name__ __module__ __qualname____firstlineno____doc__rr__static_attributes__r"r r}r}s0/44/br"r}c8\rSrSrSrSSSSSSS.SjjrSrSrg) Fperiodiciba Fit a smooth periodic B-spline curve to given data points. This class fits a periodic B-spline curve S(t) of degree k through data points (x, y) with knots t. The spline is smooth and repeats itself at the start and end, meaning the function and its derivatives up to order k-1 are equal at the boundaries. We want to find spline coefficients c that minimize the difference between the spline and the data, while also keeping the spline smooth. This is done by solving: minimize || W^{1/2} (Y - B c) ||^2 + s * c^T @ R @ c subject to periodic constraints on c. where: - Y is the data values, - B is the matrix of B-spline basis functions at points x, - W is a weighting matrix for the data points, - s is the smoothing parameter (larger s means smoother curve), - R is a matrix that penalizes wiggliness of the spline, - c spline coefficients to be solved for - periodic constraints ensure the spline repeats smoothly. The solution is obtained by forming augmented matrices and performing a QR factorization that incorporates these constraints, following the approach in FITPACK's `fpperi.f`. Parameters: ----------- x : array_like, shape (n,) y : array_like, shape (n, m) t : array_like, shape (nt,) Knot vector for the spline k : int Degree of the spline. s : float Controls smoothness: bigger s means smoother curve, smaller s fits data closer. w : array_like, shape (n,), optional Weights for data points. Defaults to all ones. R, Y, A1, A2, Z : arrays, optional Precomputed matrices from least squares and QR factorization steps to speed up repeated fits with the same knots and data. Attributes: ----------- G1, G2 : arrays Augmented matrices combining the original QR factors and constraints related to the spline basis and data. G1 is roughly the "upper-triangular" part; G2 contains additional constraint information for periodicity. H1, H2 : arrays Matrices associated with the discontinuity jump constraints of the k-th derivative of B-splines at the knots. These encode the periodicity conditions and are scaled by the smoothing parameter. offset : array Offset indices used for efficient indexing during QR reduction. Methods: -------- __call__(p): Perform QR reduction of augmented matrices scaled by 1/p, solve for spline coefficients, and return residual difference fp - s. References: ----------- - FITPACK's fpperi.f and fpcurf.f Fortran routines for periodic spline fitting. N)r~rA1A2Zc4XlX lX0lX@lUc[R "U[ S9OUnURS:wa[SUR<S35eX`l XPl URS:wa[SUR<S35e[X45upnU b U b U bUcUc[XX4U5upyp n[R"XU [U5U5unnnnnUUlUUlUUlUUlXlUUlg)Nr0rr2rr3rr)rrrrrr<r8r=rrrFr{r rinit_augmented_matriceslenG1_G2_H1_H2_Z_offset_)rrrrrrFrr~rrrrrrrrG1G2H1H2rys r rFperiodic.__init__s -.IBLL% (1 66Q; {&12 2 66Q;FQVVKyQR R!JT Z2: Y19(LaA( $A2!Q1"*!A!A"!SQRVUV!WBB r"c HURR5nURR5nURR5nURR5nUR R5nSU- nXG-nXW-n[ R"[UR5UR- S- URS4URS9nUS[UR5SUR-- S- 2SS24US[UR5SUR-- S- 2SS24'[R"X#XEXR[UR5UR5 [R "X#UURURS-UR"SSUR$SS2SS24URUR&SS5 upn [)URXR5n XlXR,- $)Nrr0r3r5)rr;rrrrrrrrrrr@r1rqr_reduce_augmented_matricesrfpbacprrrr rrF) rrrrrrrpinvrrrrs r rFperiodic.__call__s XX]]_ XX]]_ XX]]_ XX]]_ GGLLNs Y Y HHc$&&kDFF*Q. ;177 K,-.Is466{QtvvX/E/I.I1.L,M %3tvv;466 !A % %q () -- BA||S[$&& B ?? A FFDFFQJs TVVCRCF^ FFDFF3BK!b dffa(FF{r") rrrrrrrrFrrrrrrrrr"r rrbs$DJ64DTT6p(r"rcXU- -nX5U- -nXQU- -nU[R:Xa X&-X--*U- $X-U-X$-U--X-U--*X-X'--XH--- $)aThe root of r(p) = (u*p + v) / (p + w) given three points and values, (p1, f2), (p2, f2) and (p3, f3). The FITPACK analog adjusts the bounds, and we do not https://github.com/scipy/scipy/blob/maintenance/1.11.x/scipy/interpolate/fitpack/fprati.f NB: FITPACK uses p < 0 to encode p=infinity. We just use the infinity itself. Since the bracket is ``p1 <= p2 <= p3``, ``p3`` can be infinite (in fact, this is what the minimizer starts with, ``p3=inf``). )rinf) p1f1p2f2p3f3h1h2h3s r fpratir s BwB BwB BwB RVV|"$$ U2Xb 258 + , 0E FFr"c\rSrSrSrSrg)Bunchic <URR"S0UD6 g)Nr)__dict__update)rkwargss r rBunch.__init__s &v&r"rN)rrrrrrrr"r rrs'r"rzerror. a theoretically impossible result was found during the iteration process for finding a smoothing spline with fp = s. probably causes : s too small. z6the weighted sum of squared residuals is becoming NaN zthere is an approximation returned but the corresponding weighted sum of squared residuals does not satisfy the condition abs(fp-s)/s < tol. a7error. the maximal number of iterations maxit (set to 20 by the program) allowed for finding a smoothing spline with fp=s has been reached. probably causes : s too small there is an approximation returned but the corresponding weighted sum of squared residuals does not satisfy the condition abs(fp-s)/s < tol. )rr3rNc PSnSnSnSupxUuupupUn [[5HnX"U 5nn[U5U:aSunn OUS:Xa)UU - U::aUn Un X-n X::a X-X--n MIUS:aSnUS:Xa=U U- U::a,Un Un X- n U [R:waX::a X-X--n MUS:aSnU U::dUU ::aSunn O%[ XUUX5n US:aUUpMUUpM S unnUS:wa%[ R"[[U5S S 9 [UU WUS 9$) aSolve `f(p) = 0` using a rational function approximation. In a nutshell, since the function f(p) is known to be monotonically decreasing, we - maintain the bracket (p1, f1), (p2, f2) and (p3, f3) - at each iteration step, approximate f(p) by a rational function r(p) = (u*p + v) / (p + w) and make a step to p_new to the root of f(p): r(p_new) = 0. The coefficients u, v and w are found from the bracket values p1..3 and f1...3 The algorithm and implementation follows https://github.com/scipy/scipy/blob/maintenance/1.11.x/scipy/interpolate/fitpack/fpcurf.f#L229 and https://github.com/scipy/scipy/blob/maintenance/1.11.x/scipy/interpolate/fitpack/fppara.f#L290 Note that the latter is for parametric splines and the former is for 1D spline functions. The minimization is indentical though [modulo a summation over the dimensions in the computation of f(p)], so we reuse the minimizer for both d=1 and d>1. g?g?g{Gz?)rr)rTrr)r3F)rNFr3) stacklevel) convergedroot iterationsier) r]MAXITr^rrrwarningswarnRuntimeWarningrr)fp0bracketr`con1con9con4ich1ich3rrrrritrrrrs r root_ratir9sy, D D DJD!HRhr AElAaDB r7S=$NC  19Bw#~F727*Q6D 19Bw#~F 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 :math:`g(x_j)` from the data :math:`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 .. math:: \sum w_j \times (g(x_j) - y_j)^2 \to \mathrm{min} for a spline function :math:`g(x)` with a _fixed_ knot vector ``t``. .. versionadded:: 1.15.0 Nrs==0 is for interpolation only)rr%rFrQrR)rr7r&rrrJrr) rrrrGrHrrFrrOr%rSrrs r make_splreprsN q $B} JJqM(GAv =AMT-==> >!!!==:%H,Q18=RA!r A!d LC EE!Q$KCE Jr") ruubuerrFrrOr%c [U 5n U S:Hn [U[5(a[/UQUPUPUP76n O [XX'5n U R USS9nUcZUSS2SS24USS2SS24- S-n U R U R U RU SS955n[U SX"S- 5nUS:Xa+UcUcUb [S 5e[X RUSS 9U4$[X XXcUS U S 9 up ppcnUbU RU5n[X XXEXgXU S 9 n U RRn[!U R"XR$SS9nXRU54$)aT Create a smoothing parametric B-spline curve with bounded error, minimizing derivative jumps. Given a list of N 1D arrays, `x`, which represent a curve in N-dimensional space parametrized by `u`, find a smooth approximating spline curve ``g(u)``. Parameters ---------- x : array_like, shape (ndim, m) Sampled data points representing the curve in ``ndim`` dimensions. The typical use is a list of 1D arrays, each of length ``m``. w : array_like, shape(m,), optional Strictly positive 1D array of weights. The weights are used in computing the weighted least-squares spline fit. If the errors in the `x` values have standard deviation given by the vector d, then `w` should be 1/d. Default is ``np.ones(m)``. u : array_like, optional An array of parameter values for the curve in the parametric form. If not given, these values are calculated automatically, according to:: v[0] = 0 v[i] = v[i-1] + distance(x[i], x[i-1]) u[i] = v[i] / v[-1] ub, ue : float, optional The end-points of the parameters interval. Default to ``u[0]`` and ``u[-1]``. k : int, optional Degree of the spline. Cubic splines, ``k=3``, are recommended. Even values of `k` should be avoided especially with a small ``s`` value. Default is ``k=3`` s : float, optional A smoothing condition. The amount of smoothness is determined by satisfying the conditions:: sum((w * (g(u) - x))**2) <= s, where ``g(u)`` is the smoothed approximation to ``x``. The user can use `s` to control the trade-off between closeness 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 ``x``, 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 data points in ``x`` and ``w``. 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). 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(u) == x``. For non-zero values of ``s``, `spl` represents the smoothed approximation to ``x``, generally with fewer knots. u : ndarray The values of the parameters See Also -------- generate_knots : is used under the hood for generating the knots make_splrep : the analog of this routine 1D functions make_interp_spline : construct an interpolating spline (``s = 0``) make_lsq_spline : construct the least-squares spline given the knot vector splprep : a FITPACK analog of this routine Notes ----- Given a set of :math:`m` data points in :math:`D` dimensions, :math:`\vec{x}_j`, with :math:`j=1, ..., m` and :math:`\vec{x}_j = (x_{j; 1}, ..., x_{j; D})`, this routine constructs the parametric spline curve :math:`g_a(u)` with :math:`a=1, ..., D`, to minimize the sum of jumps, :math:`D_{i; a}`, of the ``k``-th derivative at the internal knots (:math:`u_b < t_i < u_e`), where .. math:: D_{i; a} = g_a^{(k)}(t_i + 0) - g_a^{(k)}(t_i - 0) Specifically, the routine constructs the spline function :math:`g(u)` which minimizes .. math:: \sum_i \sum_{a=1}^D | D_{i; a} |^2 \to \mathrm{min} provided that .. math:: \sum_{j=1}^m \sum_{a=1}^D (w_j \times (g_a(u_j) - x_{j; a}))^2 \leqslant s where :math:`u_j` is the value of the parameter corresponding to the data point :math:`(x_{j; 1}, ..., x_{j; D})`, and :math:`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 :math:`g(u_j)` from the data :math:`x_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 ``ub < t[i] < ue``). The spline knots are in general a subset of data, see `generate_knots` for details. .. versionadded:: 1.15.0 References ---------- .. [1] P. Dierckx, "Algorithms for smoothing data with periodic and parametric splines, Computer Graphics and Image Processing", 20 (1982) 171-184. .. [2] P. Dierckx, "Curve and surface fitting with splines", Monographs on Numerical Analysis, Oxford University Press, 1993. rr)rNr5r3rYrr)rrTrQ)rrS)r& isinstancerrstackcumulative_sumsqrtrrrrTrJr7rrr rr)rrrrrrrFrrOr%rrSdprccspl1s r make_splpreprsL (G:%H!T  )a ) )A )q ) Q1 ( A yAh3B36"Q &   rwwrvvbqv'9: < b"aB%i (Av =AMT-==> >!!SSAA699,Q18rss&MM  " 0<!~$$G"t!$mRHmR`DFC zFR``DffRG&''      "ZFxDF[|$$GDTqDtTYHYx$$G$4TdjHjr"