(ph_SrSSKJr SSKrSSKJrJr SSKJ r SSK J r /SQr SS jr "S S \ 5r"S S \5rSSjr"SS\5r"SS\5rg)z;Interpolation algorithms using piecewise cubic polynomials.)LiteralN)solve solve_banded)PPoly) _isscalar)CubicHermiteSplinePchipInterpolatorpchip_interpolateAkima1DInterpolator CubicSplinec[[RX45up[R"UR[R 5(a [ S5eUR[5n[R"UR[R 5(a[nO[nUb[R"U5nURUR:wa [ S5e[R"UR[R 5(a[nURUSS9nURUSS9nX!R-nURS:wa [ S5eURSS:a [ S 5eURSURU:wa[ S US 35e[R"[R"U55(d [ S 5e[R"[R"U55(d [ S 5eUb:[R"[R"U55(d [ S5e[R"U5n[R"US:*5(a [ S5e[R "XS5nUb[R "X2S5nXXU4$)a Prepare input for cubic spline interpolators. All data are converted to numpy arrays and checked for correctness. Axes equal to `axis` of arrays `y` and `dydx` are moved to be the 0th axis. The value of `axis` is converted to lie in [0, number of dimensions of `y`). z`x` must contain real values.z/The shapes of `y` and `dydx` must be identical.Fcopyrz`x` must be 1-dimensional.rz%`x` must contain at least 2 elements.zThe length of `y` along `axis`=z doesn't match the length of `x`z$`x` must contain only finite values.z$`y` must contain only finite values.z'`dydx` must contain only finite values.z)`x` must be strictly increasing sequence.)mapnpasarray issubdtypedtypecomplexfloating ValueErrorastypefloatcomplexshapendimallisfinitediffanymoveaxis)xyaxisdydxrdxs K/var/www/html/venv/lib/python3.13/site-packages/scipy/interpolate/_cubic.py prepare_inputr)s' rzzA6 "DA }}QWWb0011899 A }}QWWb0011 zz$ 77djj NO O ==R%7%7 8 8E{{5u{- U#A &&=Dvv{566wwqzA~@AAwwqzQWWT]":4&A334 4 66"++a. ! !?@@ 66"++a. ! !?@@ r{{4'8 9 9BCC B vvbAgDEE AQA {{4q) !4 c0^\rSrSrSrSU4SjjrSrU=r$)r HaPiecewise-cubic interpolator matching values and first derivatives. The result is represented as a `PPoly` instance. Parameters ---------- x : array_like, shape (n,) 1-D array containing values of the independent variable. Values must be real, finite and in strictly increasing order. y : array_like Array containing values of the dependent variable. It can have arbitrary number of dimensions, but the length along ``axis`` (see below) must match the length of ``x``. Values must be finite. dydx : array_like Array containing derivatives of the dependent variable. It can have arbitrary number of dimensions, but the length along ``axis`` (see below) must match the length of ``x``. Values must be finite. axis : int, optional Axis along which `y` is assumed to be varying. Meaning that for ``x[i]`` the corresponding values are ``np.take(y, i, axis=axis)``. Default is 0. extrapolate : {bool, '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), it is set to True. Attributes ---------- x : ndarray, shape (n,) Breakpoints. The same ``x`` which was passed to the constructor. c : ndarray, shape (4, n-1, ...) Coefficients of the polynomials on each segment. The trailing dimensions match the dimensions of `y`, excluding ``axis``. For example, if `y` is 1-D, then ``c[k, i]`` is a coefficient for ``(x-x[i])**(3-k)`` on the segment between ``x[i]`` and ``x[i+1]``. axis : int Interpolation axis. The same axis which was passed to the constructor. Methods ------- __call__ derivative antiderivative integrate roots See Also -------- Akima1DInterpolator : Akima 1D interpolator. PchipInterpolator : PCHIP 1-D monotonic cubic interpolator. CubicSpline : Cubic spline data interpolator. PPoly : Piecewise polynomial in terms of coefficients and breakpoints Notes ----- If you want to create a higher-order spline matching higher-order derivatives, use `BPoly.from_derivatives`. References ---------- .. [1] `Cubic Hermite spline `_ on Wikipedia. c>UcSn[XXC5upp$nURURS/S/URS- --5n[R "USS9U- nUSSUSS-SU-- U- n [R "S[U5S- 4URSS-U RS9n X- U S'XSS- U- U - U S'USSU S'USSU S '[T U])XUS 9 X@l g) NTrrr%rr) extrapolate) r)reshaperrrr emptylenrsuper__init__r%) selfr#r$r&r%r3r'dxrslopetc __class__s r(r8CubicHermiteSpline.__init__s  K,Q4>qjj"((1+! );;<"S( #2Yab !AI - 4 HHaQ!_qwwqr{2!'' Bw!Sb !S(1,!CRy!"v! ;7 r*r.rN)__name__ __module__ __qualname____firstlineno____doc__r8__static_attributes__ __classcell__r>s@r(r r Hs@Dr*r cP^\rSrSrSrSU4Sjjr\S5r\S5rSr U=r $)r ac PCHIP 1-D monotonic cubic interpolation. ``x`` and ``y`` are arrays of values used to approximate some function f, with ``y = f(x)``. The interpolant uses monotonic cubic splines to find the value of new points. (PCHIP stands for Piecewise Cubic Hermite Interpolating Polynomial). Parameters ---------- x : ndarray, shape (npoints, ) A 1-D array of monotonically increasing real values. ``x`` cannot include duplicate values (otherwise f is overspecified) y : ndarray, shape (..., npoints, ...) A N-D array of real values. ``y``'s length along the interpolation axis must be equal to the length of ``x``. Use the ``axis`` parameter to select the interpolation axis. axis : int, optional Axis in the ``y`` array corresponding to the x-coordinate values. Defaults to ``axis=0``. extrapolate : bool, optional Whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. Methods ------- __call__ derivative antiderivative roots See Also -------- CubicHermiteSpline : Piecewise-cubic interpolator. Akima1DInterpolator : Akima 1D interpolator. CubicSpline : Cubic spline data interpolator. PPoly : Piecewise polynomial in terms of coefficients and breakpoints. Notes ----- The interpolator preserves monotonicity in the interpolation data and does not overshoot if the data is not smooth. The first derivatives are guaranteed to be continuous, but the second derivatives may jump at :math:`x_k`. Determines the derivatives at the points :math:`x_k`, :math:`f'_k`, by using PCHIP algorithm [1]_. Let :math:`h_k = x_{k+1} - x_k`, and :math:`d_k = (y_{k+1} - y_k) / h_k` are the slopes at internal points :math:`x_k`. If the signs of :math:`d_k` and :math:`d_{k-1}` are different or either of them equals zero, then :math:`f'_k = 0`. Otherwise, it is given by the weighted harmonic mean .. math:: \frac{w_1 + w_2}{f'_k} = \frac{w_1}{d_{k-1}} + \frac{w_2}{d_k} where :math:`w_1 = 2 h_k + h_{k-1}` and :math:`w_2 = h_k + 2 h_{k-1}`. The end slopes are set using a one-sided scheme [2]_. References ---------- .. [1] F. N. Fritsch and J. Butland, A method for constructing local monotone piecewise cubic interpolants, SIAM J. Sci. Comput., 5(2), 300-304 (1984). :doi:`10.1137/0905021`. .. [2] see, e.g., C. Moler, Numerical Computing with Matlab, 2004. :doi:`10.1137/1.9780898717952` c(>[XU5upp#n[R"U5(a Sn[U5eUR UR S4SUR S- --5nURXr5n[T U]%XUSUS9 X0l g)Nz`PchipInterpolator` only works with real values for `y`. If you are trying to use the real components of the passed array, use `np.real` on the array before passing to `PchipInterpolator`.r)rrr%r3) r)r iscomplexobjrr4rr_find_derivativesr7r8r%) r9r#r$r%r3_msgxpdkr>s r(r8PchipInterpolator.__init__s(t4aq ??1  WCS/ ! YY }tQVVAX6 7  # #B * r{C r*clSU-U-U-X-- X-- n[R"U5[R"U5:gn[R"U5[R"U5:g[R"U5S[R"U5-:-nU)U-nSXE'SX'-XG'U$)Nrg@)rsignabs)h0h1m0m1dmaskmask2mmms r( _edge_casePchipInterpolator._edge_casesdRi^be # 0wwqzRWWR[( +q BrvvbzM0IJuoBGr*cRURnURS:XaUSS2S4nUSS2S4nUSSUSS- nUSSUSS- U- nURSS:Xa/[R"U5nXES'XES'UR U5$[R "U5nUSSUSS:gUSSS:H-USSS:H-nSUSS-USS-nUSSSUSS--n [R "SSS9 XSS- XSS- -X-- n SSS5 [R"U5nSUSSU'SW U)- USSU)'[RUSUSUSUS5US'[RUSUS USUS 5US'UR U5$!,(df  N=f) Nrr/rrignore)divideinvalidrU?) rrr zeros_liker4rVerrstater r`) r#r$y_shapehkmkrRsmk conditionw1w2whmeans r(rN#PchipInterpolator._find_derivativess'' 66Q;!T' A!T' A qrUQsV^eafn " 771:?q!BqEqE::g& &ggbkWCR(RVq[9RW\J r!"vX3B  Va3Bi [[( ;CRj2f9,9F<]]1 !1R"VYJ%771R)",,RUBqE2a5"Q%H1"--bfbfbfbfM2zz'""< ;s .F F&r.r@) rArBrCrDrEr8 staticmethodr`rNrFrGrHs@r(r r s7IV   .#.#r*r c[XUS9nUS:XaU"U5$[U5(aURU5"U5$UVs/sHoeRU5"U5PM sn$s snf)a Convenience function for pchip interpolation. xi and yi are arrays of values used to approximate some function f, with ``yi = f(xi)``. The interpolant uses monotonic cubic splines to find the value of new points x and the derivatives there. See `scipy.interpolate.PchipInterpolator` for details. Parameters ---------- xi : array_like A sorted list of x-coordinates, of length N. yi : array_like A 1-D array of real values. `yi`'s length along the interpolation axis must be equal to the length of `xi`. If N-D array, use axis parameter to select correct axis. .. deprecated:: 1.13.0 Complex data is deprecated and will raise an error in SciPy 1.15.0. If you are trying to use the real components of the passed array, use ``np.real`` on `yi`. x : scalar or array_like Of length M. der : int or list, optional Derivatives to extract. The 0th derivative can be included to return the function value. axis : int, optional Axis in the yi array corresponding to the x-coordinate values. Returns ------- y : scalar or array_like The result, of length R or length M or M by R. See Also -------- PchipInterpolator : PCHIP 1-D monotonic cubic interpolator. Examples -------- We can interpolate 2D observed data using pchip interpolation: >>> import numpy as np >>> import matplotlib.pyplot as plt >>> from scipy.interpolate import pchip_interpolate >>> x_observed = np.linspace(0.0, 10.0, 11) >>> y_observed = np.sin(x_observed) >>> x = np.linspace(min(x_observed), max(x_observed), num=100) >>> y = pchip_interpolate(x_observed, y_observed, x) >>> plt.plot(x_observed, y_observed, "o", label="observation") >>> plt.plot(x, y, label="pchip interpolation") >>> plt.legend() >>> plt.show() r.r)r r derivative)xiyir#derr%Pnus r(r r 8sbt "t,A axt 3||C ##.12c R #c222s A'c^\rSrSrSrSSSS.S\SS\S-4U4S jjjjrSS jr\ SS j5r \ SS j5r S r U=r $)r i|a 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 (npoints, ) 1-D array of monotonically increasing real values. y : ndarray, shape (..., npoints, ...) N-D array of real values. The length of ``y`` along the interpolation axis must be equal to the length of ``x``. Use the ``axis`` parameter to select the interpolation axis. axis : int, optional Axis in the ``y`` array corresponding to the x-coordinate values. Defaults to ``axis=0``. method : {'akima', 'makima'}, optional If ``"makima"``, use the modified Akima interpolation [2]_. Defaults to ``"akima"``, use the Akima interpolation [1]_. .. versionadded:: 1.13.0 extrapolate : {bool, None}, optional If bool, determines whether to extrapolate to out-of-bounds points based on first and last intervals, or to return NaNs. If None, ``extrapolate`` is set to False. 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. Let :math:`\delta_i = (y_{i+1} - y_i) / (x_{i+1} - x_i)` be the slopes of the interval :math:`\left[x_i, x_{i+1}\right)`. Akima's derivative at :math:`x_i` is defined as: .. math:: d_i = \frac{w_1}{w_1 + w_2}\delta_{i-1} + \frac{w_2}{w_1 + w_2}\delta_i In the Akima interpolation [1]_ (``method="akima"``), the weights are: .. math:: \begin{aligned} w_1 &= |\delta_{i+1} - \delta_i| \\ w_2 &= |\delta_{i-1} - \delta_{i-2}| \end{aligned} In the modified Akima interpolation [2]_ (``method="makima"``), to eliminate overshoot and avoid edge cases of both numerator and denominator being equal to 0, the weights are modified as follows: .. math:: \begin{align*} w_1 &= |\delta_{i+1} - \delta_i| + |\delta_{i+1} + \delta_i| / 2 \\ w_2 &= |\delta_{i-1} - \delta_{i-2}| + |\delta_{i-1} + \delta_{i-2}| / 2 \end{align*} Examples -------- Comparison of ``method="akima"`` and ``method="makima"``: >>> import numpy as np >>> from scipy.interpolate import Akima1DInterpolator >>> import matplotlib.pyplot as plt >>> x = np.linspace(1, 7, 7) >>> y = np.array([-1, -1, -1, 0, 1, 1, 1]) >>> xs = np.linspace(min(x), max(x), num=100) >>> y_akima = Akima1DInterpolator(x, y, method="akima")(xs) >>> y_makima = Akima1DInterpolator(x, y, method="makima")(xs) >>> fig, ax = plt.subplots() >>> ax.plot(x, y, "o", label="data") >>> ax.plot(xs, y_akima, label="akima") >>> ax.plot(xs, y_makima, label="makima") >>> ax.legend() >>> fig.show() The overshoot that occurred in ``"akima"`` has been avoided in ``"makima"``. 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. :doi:`10.1145/321607.321609` .. [2] Makima Piecewise Cubic Interpolation. Cleve Moler and Cosmin Ionita, 2019. https://blogs.mathworks.com/cleve/2019/04/29/makima-piecewise-cubic-interpolation/ akimaN)methodr3r})r|makimar3c >>US;a[SUS35e[XU5upp#n[R"U5(a Sn[ U5eUcSOUn[R "UR S-4URSS-5n U[S54SURS- --n[R"US S 9U- U S S &S U S -U S- U S'S U S-U S - U S 'S U S-U S- U S 'S U S -U S- U S'SU SSU SS--n [R"[R"U S S 95n US:Xa<[R"U SSU SS-5n U S SSU S S--n U SS SU SS --nO U S Sn U SS nX-n[R"US[R"U[R*S9-:5nUS USSnnU UU US-4U--UUU US -4U---UU- U U'[TU]AXU S US9 X0lg)N>r|r~z `method`=z is unsupported.z`Akima1DInterpolator` only works with real values for `y`. If you are trying to use the real components of the passed array, use `np.real` on the array before passing to `Akima1DInterpolator`.Fr2rNrr.rrgg@r/?r~g& .>)initialrL)NotImplementedErrorr)rrMrr5sizerslicerr rWnonzeromaxinfr7r8r%)r9r#r$r%r}r3r'rOrPmr<dmpmf1f2f12indx_indy_indr>s r(r8Akima1DInterpolator.__init__s , ,% &9I&JK K*!5q ??1  ,CS/ ! +2e  HHaffqj^aggabk1 2 t(affqj"99 :''!!$r)!BAaDy1Q4!AaDy1Q4!QrU QrU""QrU QrU"" !AB%!CR&. ! VVBGGAA& ' X !"#2'BAB#12,&BCR3CR=(BABBCRBgjjtbffS266'&BBBC1vs12wuS'AuqylU233S'AuqylU23347:3x@# qqkB r*c[S5e)Nz9Extending a 1-D Akima interpolator is not yet implementedr)r9r=r#rights r(extendAkima1DInterpolator.extend!s!#45 5r*c[S5eNz:This method does not make sense for an Akima interpolator.r)clstckr3s r( from_splineAkima1DInterpolator.from_spline'!#;< >> import numpy as np >>> from scipy.interpolate import CubicSpline >>> import matplotlib.pyplot as plt >>> x = np.arange(10) >>> y = np.sin(x) >>> cs = CubicSpline(x, y) >>> xs = np.arange(-0.5, 9.6, 0.1) >>> fig, ax = plt.subplots(figsize=(6.5, 4)) >>> ax.plot(x, y, 'o', label='data') >>> ax.plot(xs, np.sin(xs), label='true') >>> ax.plot(xs, cs(xs), label="S") >>> ax.plot(xs, cs(xs, 1), label="S'") >>> ax.plot(xs, cs(xs, 2), label="S''") >>> ax.plot(xs, cs(xs, 3), label="S'''") >>> ax.set_xlim(-0.5, 9.5) >>> ax.legend(loc='lower left', ncol=2) >>> plt.show() In the second example, the unit circle is interpolated with a spline. A periodic boundary condition is used. You can see that the first derivative values, ds/dx=0, ds/dy=1 at the periodic point (1, 0) are correctly computed. Note that a circle cannot be exactly represented by a cubic spline. To increase precision, more breakpoints would be required. >>> theta = 2 * np.pi * np.linspace(0, 1, 5) >>> y = np.c_[np.cos(theta), np.sin(theta)] >>> cs = CubicSpline(theta, y, bc_type='periodic') >>> print("ds/dx={:.1f} ds/dy={:.1f}".format(cs(0, 1)[0], cs(0, 1)[1])) ds/dx=0.0 ds/dy=1.0 >>> xs = 2 * np.pi * np.linspace(0, 1, 100) >>> fig, ax = plt.subplots(figsize=(6.5, 4)) >>> ax.plot(y[:, 0], y[:, 1], 'o', label='data') >>> ax.plot(np.cos(xs), np.sin(xs), label='true') >>> ax.plot(cs(xs)[:, 0], cs(xs)[:, 1], label='spline') >>> ax.axes.set_aspect('equal') >>> ax.legend(loc='center') >>> plt.show() The third example is the interpolation of a polynomial y = x**3 on the interval 0 <= x<= 1. A cubic spline can represent this function exactly. To achieve that we need to specify values and first derivatives at endpoints of the interval. Note that y' = 3 * x**2 and thus y'(0) = 0 and y'(1) = 3. >>> cs = CubicSpline([0, 1], [0, 1], bc_type=((1, 0), (1, 3))) >>> x = np.linspace(0, 1) >>> np.allclose(x**3, cs(x)) True References ---------- .. [1] `Cubic Spline Interpolation `_ on Wikiversity. .. [2] Carl de Boor, "A Practical Guide to Splines", Springer-Verlag, 1978. c  >[XU5upp#n[U5nURXBURSSU5upUcU SS:XaSnOSnURS:Xa[ R "U5n GOURURS/S/URS- --5n [ R"USS9U - n US:Xa&U SS;a SU S4U S'U SS;a SU S4U S'US:XaU SS :XaU SS :Xa[ R"S 5n [ R"S URSS-URS 9nSU S 'SU S'USU S'SUSUS--U S'USU S'SU S'SU S'SU S-US'SU SU S-U SU S---US'SU S-US'[XSSSS9n GOUS:XaZU SS:XaQX- RS5SU - RS5- n[ R"X4URSS-5n GOR[ R"SU45n [ R"U4URSS-URS 9nSUSSUSS--U SSS24'USSU SSS24'USSU SSS24'SU SSU SS-U SSU SS---USS&U unnUS:XGaIU SS2SS24n SUSUS--U S'USU S'USSnUSnUSnSUSUS--nUSnUSnSU SU S-U SU S---US'SU SU S-U SU S---US'U SS2SS24nUSSn[ R "U5nU*US'U*US'[!SUUSSSS9n[!SUUSSSS9nUSUUS-- UUS-- UUUS--UUS--- n[ R"U4URSS-URS 9n UUU--U SS&UU S'U SU S'GOkUS :XaNUSU S'USUS- U S'USUS- nU SSU--U S-U S-U SS-U S--U- US'O[USS:XaSU S'SU S'USUS'O?USS:Xa6SUS-U S'USU S'SUS-USS--SUSUS- --US'US :XaNUSU S'USUS- U S'USUS- nU SS-U S-SU-U S-U S-U S--U- US'O[USS:XaSU S'SU S'USUS'O?USS:Xa6SUS-U S'USU S'SUS-USS--SUSUS- --US'[!SXSSSS9n ["TU]IXU SUS9 X0lg) NrrperiodicTr.r not-a-knotrr2r)r2r2)r2r1rr)rr)rr)rrrr)rr)rrF) overwrite_a overwrite_b check_finiterfr/rgr) overwrite_abrrg)rr/)r/rgrrL)r)r6 _validate_bcrrrrhr4rr zerosr5rrsum broadcast_torr7r8r%)r9r#r$r%bc_typer3r'rOnbcsr:r;Abr<bc_startbc_enda_m1_0a_m1_m2a_m1_m1a_m2_m1a_0_m1Acb1b2s1s2s_m1r\r>s r(r8CubicSpline.__init__sg)!5q F!!'aggabk4@  !u "( " 66Q; a A**bhhqk]aSAFFQJ-??@CGGAA&,E Ava566aMBqEa566aMBqE Av"Q%</BqE\4IHHV$HHTAGGABK/qww?$$Q%$r!ur!u}-$Q%$$$58|!CFU1X-Aq0AAB!58|!!Dd',.aBqEZ/[%%a(BH>>!+<<OOAtaggabk'9:HHaV$HHaTAGGABK/qww?"Sb'BqrF"23!QrT' cr7!QR%V"crc' s12ws3c#2hqr6JJK!B#% &z)!QrT' A2b6BqE>2AdG fAdG#2A VF fG2b6BrF?3G fGUFAr 2SWuQx5G GHAaDR59!4s2wr7J!JKAbE1crc6B3BBr*B#GBqE%XBrF&fb"527eMB&fb"527eMBrUVbe^3g26FF$v1~5"R&8HHJD! !3177CA$)^AcrF AbEaDAbE</"$Q%$"#A$1+$aD1Q4K!$Q!A#Q 7%( B #A E!H 4!589 :!!!)"#$"#$'{!!!)"#be)$"$Q%$#hqk1BqE1HQ Q"$VQ15EKA qqkB r*c[U[5(a;US:Xa1[R"USUSSSS9(d[ SUS35eX4nO+[ U5S:wa [ S 5eSU;a [ S 5e/nUGHQn[U[5(aUS :Xa)UR S [R"U545 MHUS :Xa)UR S[R"U545 MwUS;aUR U5 M[ SUS35eUupgUS;a [ S5e[R"U5nURU:wa[ SURSUS35e[R"UR[R5(aUR[SS9nUR Xg45 GMT XA4$![an[ S5UeSnAff=f)zValidate and prepare boundary conditions. Returns ------- validated_bc : 2-tuple Boundary conditions for a curve start and end. y : ndarray y casted to complex dtype if one of the boundary conditions has complex dtype. rrr/gV瞯<)rtolatolz(The first and last `y` point along axis zF must be identical (within machine precision) when bc_type='periodic'.rzF`bc_type` must contain 2 elements to specify start and end conditions.zf'periodic' `bc_type` is defined for both curve ends and cannot be used with other boundary conditions.clampedrnaturalrzbc_type=z is not allowed.zFA specified derivative value must be given in the form (order, value).Nrz.The specified derivative order must be 1 or 2.z`deriv_value` shape z is not the expected one .Fr) isinstancestrrallcloserr6appendr Exceptionrrrrrrr) rr$expected_deriv_shaper% validated_bcr deriv_order deriv_valuees r(rCubicSpline._validate_bczs gs # #*${{1Q42UG$B4&I..// (G7|q  "EFFW$ "899 B"c""? ''BHH5I,J(KL9_ ''BHH5I,J(KL55 ''+$xt3C%DEE/1,Kf,$&233!jj5 $$(<<$.{/@/@.AB,,@+AD ==!2!2B4F4FGGu5A##[$>?CF-!$<s G G4# G//G4r.)rrN) rArBrCrDrEr8rsrrFrGrHs@r(r r 2s'cJ`DCCr*r rr)rEtypingrnumpyr scipy.linalgrrr_polyintr__all__r)r r r r r r*r(rsiA, 15 pTTnV#*V#rA3Hs<,s