(ph^ bSr/SQrSSKrSSKJr SSKJrJrJrJ r J r SSKr SSK J r SSK Jr \R R"R$r\"5rS S S S S .rSSSSSSSSS.r"SS5r"SS\5rSr"SS\5r"SS5rSSSSSSS S!.r"S"S#\5r"S$S%\5r"S&S'\5r"S(S)\5r "S*S+\5r!\RE5r#S,\#S-'S.\#S/'"S0S1\5r$"S2S3\$5r%"S4S5\$5r&\RE5r'S6\'S-'"S7S8\$5r(g)9z fitpack --- curve and surface fitting with splines fitpack is based on a collection of Fortran routines DIERCKX by P. Dierckx (see http://www.netlib.org/dierckx/) transformed to double routines by Pearu Peterson. ) UnivariateSplineInterpolatedUnivariateSplineLSQUnivariateSplineBivariateSplineLSQBivariateSplineSmoothBivariateSplineLSQSphereBivariateSplineSmoothSphereBivariateSplineRectBivariateSplineRectSphereBivariateSplineN)Lock)zeros concatenateraveldiffarray) _fitpack_impl) _dfitpacka The required storage space exceeds the available storage space, as specified by the parameter nest: nest too small. If nest is already large (say nest > m/2), it may also indicate that s is too small. The approximation returned is the weighted least-squares spline according to the knots t[0],t[1],...,t[n-1]. (n=nest) the parameter fp gives the corresponding weighted sum of squared residuals (fp>s). a A theoretically impossible result was found during the iteration process for finding a smoothing spline with fp = s: 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.a The maximal number of iterations maxit (set to 20 by the program) allowed for finding a smoothing spline with fp=s has been reached: 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.z Error on entry, no approximation returned. The following conditions must hold: xb<=x[0]0, i=0..m-1 if iopt=-1: xb>> import numpy as np >>> from scipy.interpolate import UnivariateSpline >>> x, y = np.array([1, 2, 3, 4]), np.array([1, np.nan, 3, 4]) >>> w = np.isnan(y) >>> y[w] = 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.) References ---------- Based on algorithms described in [1]_, [2]_, [3]_, and [4]_: .. [1] P. Dierckx, "An algorithm for smoothing, differentiation and integration of experimental data using spline functions", J.Comp.Appl.Maths 1 (1975) 165-184. .. [2] P. Dierckx, "A fast algorithm for smoothing data on a rectangular grid while using spline functions", SIAM J.Numer.Anal. 19 (1982) 1286-1304. .. [3] P. Dierckx, "An improved algorithm for curve fitting with spline functions", report tw54, Dept. Computer Science,K.U. Leuven, 1981. .. [4] P. Dierckx, "Curve and surface fitting with splines", Monographs on Numerical Analysis, Oxford University Press, 1993. Examples -------- >>> import numpy as np >>> import matplotlib.pyplot as plt >>> from scipy.interpolate import UnivariateSpline >>> rng = np.random.default_rng() >>> x = np.linspace(-3, 3, 50) >>> y = np.exp(-x**2) + 0.1 * rng.standard_normal(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() Nrrr Fc URXX4XVUU5upp4Ul[ [R"XXSUSUSUS9n SSS5 W SS:XaUR U 5n XlUR5 g!,(df  N?=f)Nr rwxbxes)validate_inputext FITPACK_LOCKdfitpackfpcurf0 _reset_nest_data _reset_class) selfxyr bboxkr#r& check_finitedatas N/var/www/html/venv/lib/python3.13/site-packages/scipy/interpolate/_fitpack2.py__init__UnivariateSpline.__init__s#'"5"5aAQ36B#Datx##A!T!W'+Aw!5D 8q=##D)D  \s A== B cn[R"U5[R"U5[R"U5p1nUb[R"U5nU(aUb$[R"U5R5OSn[R"U5R5(a0[R"U5R5(aU(d [ S5eUbUS:a3[R"[ U5S:5(d [ S5eO2[R"[ U5S:5(d [ S5eUR UR :wa [ S5eUb8UR UR s=:XaUR :Xd O [ S5eURS :wa [ S 5eS Us=::aS ::d O [ S 5eUbUS:d [ S5e[UnXX#U4$![an [ SUS35U eSn A ff=f)NTz,x and y array must not contain NaNs or infs.r zx must be increasing if s > 0z&x must be strictly increasing if s = 0z!x and y should have a same lengthz%x, y, and w should have a same length)rzbbox shape should be (2,)rzk should be 1 <= k <= 5s should be s >= 0.0Unknown extrapolation mode .) npasarrayisfiniteall ValueErrorrsizeshape _extrap_modesKeyError) r.r/r r0r1r#r&r2w_finitees r4r%UnivariateSpline.validate_inputsZZ]BJJqM2::d3Cd = 1 A /0}r{{1~))+$HKKN&&(( A0B0B0D0D  "122 9A66$q'S.)) !@AA*66$q'C-(( !IJJ 66QVV @A A ]166QVV#=qvv#=DE E ZZ4 89 9q+A+67 7 ]1834 4 J$CQc!! J:3%qAB I Js H H4H//H4cURU5nUupEnXlSSSSSUS[U5UUSSSS4UlX#lU$)z(Construct a spline object from given tckN)__new__ _eval_argslenr+r&)clstckr&r-tcr1s r4 _from_tckUnivariateSpline._from_tcksU{{3aD$dAtSVQtT41  cURnUSUSUSUSUS4up#pEnUSUUSUU4UlUS:XagUS:XaUR[5 gUS:XaUR[5 gUS:XaUR[5 [ R US U35n[R"US S 9 g) N r9r$r rier=r stacklevel) r+rK _set_classrr_curfit_messagesgetwarningswarn)r-r3nrOrPr1iermessages r4r,UnivariateSpline._reset_class*szzq'47DGT!Wd2hFaCBQ%2A/ !8  BY OO8 9 BY OO/ 0ax 34&**3$se =G MM'a 0rSc\XlUR[[[4;aXlggN) _spline_class __class__rrr)r-rMs r4r\UnivariateSpline._set_classBs,  >>.0L13 3 N rSc^^TSnTcTS[TS5pTXT-S-mOUT::d [S5eUU4SjS5upgpTSSXgX8U TS 4-n [ [R"U 6mSSS5 T$!,(df  T$=f) Nrr9r rz`nest` can only be increasedc3X># UHn[R"TUT5v M! g7frf)r=resize).0jr3nests r4 /UnivariateSpline._reset_nest..Ss*/-=>ryya$77-s'*)rVrW rV )rLrAr'r(fpcurf1) r-r3rorar1mrOrPfpintnrdataargss `` r4r*UnivariateSpline._reset_nestKs H <7CQLq3q5D9 !?@@/-/eBQx1648<< ##T*D \ s A99 Bc>URnUSS:Xa[R"SSS9 gUSSU4-USS-n[ [R "U6nSSS5 USS:XaUR U5nX lUR5 g!,(df  N?=f) zContinue spline computation with the given smoothing factor s and with the knots found at the last call. This routine modifies the spline in place. r$z9smoothing factor unchanged forLSQ spline with fixed knotsrrZNrUr)r+r_r`r'r(rur*r,)r-r#r3rys r4set_smoothing_factor%UnivariateSpline.set_smoothing_factor[szz 7b= MM8%& ( BQx1$ab) ##T*D 8q=##D)D   \s B Bc\[R"U5nURS:Xa [/5$Uc URnO [ Un[ [R"XRX#S9sSSS5 $![ an[SUS35UeSnAff=f!,(df  g=f)a Evaluate spline (or its nu-th derivative) at positions x. Parameters ---------- x : array_like A 1-D array of points at which to return the value of the smoothed spline or its derivatives. Note: `x` can be unordered but the evaluation is more efficient if `x` is (partially) ordered. nu : int The order of derivative of the spline to compute. ext : int Controls the value returned for elements of `x` 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 or 'const', return the boundary value. The default value is 0, passed from the initialization of UnivariateSpline. r Nr;r<)derr&) r=r>rBrr&rDrErAr'rsplevrK)r-r.nur&rGs r4__call__UnivariateSpline.__call__qs2 JJqM 66Q;9  ;((C N#C( &&q//rK\ N #>se1!EFAM N \s$ A;B; BBB B+c@URnUSUSp2USX#U- $)z{Return positions of interior knots of the spline. Internally, the knot vector contains ``2*k`` additional boundary knots. r9rUrVr+r-r3r1ras r4 get_knotsUnivariateSpline.get_knotss. zzAwQ1Awq1~rScFURnUSUSp2USSX2- S- $)Return spline coefficients.r9rUrWNrrrs r4 get_coeffsUnivariateSpline.get_coeffss0zzAwQ1AwvArSc URS$)zReturn weighted sum of squared residuals of the spline approximation. This is equivalent to:: sum((w[i] * (y[i]-spl(x[i])))**2, axis=0) rrr-s r4 get_residualUnivariateSpline.get_residualszz"~rSc[ [R"XUR5sSSS5 $!,(df  g=f)aReturn 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 -------- >>> import numpy as np >>> 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 N)r'rsplintrK)r-abs r4integralUnivariateSpline.integrals&J ''doo>\\s !2 Ac[ [R"XR5sSSS5 $!,(df  g=f)aReturn 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 -------- >>> import numpy as np >>> 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]) N)r'rspalderK)r-r.s r4 derivativesUnivariateSpline.derivativess#0 ''??;\\s 1 ?cURSnUS:XaOURSnS[U5S- -n[ [R "URUS9sSSS5 $[ S5e!,(df  N=f)a?Return the zeros of the spline. Notes ----- Restriction: only cubic splines are supported by FITPACK. For non-cubic splines, use `PPoly.root` (see below for an example). Examples -------- For some data, this method may miss a root. This happens when one of the spline knots (which FITPACK places automatically) happens to coincide with the true root. A workaround is to convert to `PPoly`, which uses a different root-finding algorithm. For example, >>> x = [1.96, 1.97, 1.98, 1.99, 2.00, 2.01, 2.02, 2.03, 2.04, 2.05] >>> y = [-6.365470e-03, -4.790580e-03, -3.204320e-03, -1.607270e-03, ... 4.440892e-16, 1.616930e-03, 3.243000e-03, 4.877670e-03, ... 6.520430e-03, 8.170770e-03] >>> from scipy.interpolate import UnivariateSpline >>> spl = UnivariateSpline(x, y, s=0) >>> spl.roots() array([], dtype=float64) Converting to a PPoly object does find the roots at `x=2`: >>> from scipy.interpolate import splrep, PPoly >>> tck = splrep(x, y, s=0) >>> ppoly = PPoly.from_spline(tck) >>> ppoly.roots(extrapolate=False) array([2.]) See Also -------- sproot PPoly.roots r9rr rU)mestNz/finding roots unsupported for non-cubic splines)r+rKrLr'rsprootNotImplementedError)r-r1rOrs r4rootsUnivariateSpline.rootssqR JJqM 6"AA #D$++DOO$G!#67 7s A00 A>c[ [R"URU5nSSS5 URS:XaSO URn[ R WUS9$!,(df  N@=f)a 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: >>> import numpy as np >>> 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)`. Nrr)r&)r'rsplderrKr&rrQ)r-rarNr&s r4 derivativeUnivariateSpline.derivative&sXZ&&t:C88q=adhh))#3)77 \s "A## A1c[ [R"URU5nSSS5 [R WUR 5$!,(df  N.=f)ap 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 -------- >>> import numpy as np >>> 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 N)r'r splantiderrKrrQr&)r-rarNs r4antiderivativeUnivariateSpline.antiderivativeYsBh**4??A>C))#txx88\s "A A)rhr+rKrgr&)r rf)r N)r)__name__ __module__ __qualname____firstlineno____doc__r5 staticmethodr% classmethodrQr,r\r*r}rrrrrrrrr__static_attributes__rSr4rrIs_B $4&(a4U  " "D  10 ,%LN &?P<607d18f69rSrc4\rSrSrSrSS/S-SSS4SjrS rg) ria 1-D interpolating spline for a given set of data points. .. legacy:: class Specifically, we recommend using `make_interp_spline` instead. Fits a spline y = spl(x) of degree `k` to the provided `x`, `y` data. Spline function passes through all provided points. Equivalent to `UnivariateSpline` with `s` = 0. Parameters ---------- x : (N,) array_like Input dimension of data points -- must be strictly increasing y : (N,) array_like input dimension of data points w : (N,) array_like, optional Weights for spline fitting. Must be positive. If None (default), weights are all 1. 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. 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 -------- UnivariateSpline : a smooth univariate spline to fit a given set of data points. LSQUnivariateSpline : a spline for which knots are user-selected SmoothBivariateSpline : a smoothing bivariate spline through the given points LSQBivariateSpline : a bivariate spline using weighted least-squares fitting splrep : a function to find the B-spline representation of a 1-D curve splev : a function to evaluate a B-spline or its derivatives sproot : a function to find the roots of a cubic B-spline splint : a function to evaluate the definite integral of a B-spline between two given points spalde : a function to evaluate all derivatives of a B-spline Notes ----- The number of data points must be larger than the spline degree `k`. Examples -------- >>> import numpy as np >>> import matplotlib.pyplot as plt >>> from scipy.interpolate import InterpolatedUnivariateSpline >>> rng = np.random.default_rng() >>> x = np.linspace(-3, 3, 50) >>> y = np.exp(-x**2) + 0.1 * rng.standard_normal(50) >>> spl = InterpolatedUnivariateSpline(x, y) >>> plt.plot(x, y, 'ro', ms=5) >>> xs = np.linspace(-3, 3, 1000) >>> plt.plot(xs, spl(xs), 'g', lw=3, alpha=0.7) >>> plt.show() Notice that the ``spl(x)`` interpolates `y`: >>> spl.get_residual() 0.0 Nrrr Fc JURXX4USXg5upp4Ul[R"[ U5S:5(d [ S5e[  [R"XXSUSUSSS9Ul SSS5 UR5 g!,(df  N=f)Nr8x must be strictly increasingr rr) r%r&r=r@rrAr'r(r)r+r,)r-r.r/r r0r1r&r2s r4r5%InterpolatedUnivariateSpline.__init__s#'"5"5aAQ,/#?atxvvd1gm$$<= =!))!47-1!W;DJ \s $B B"r+r&rrrrrr5rrrSr4rrs"Yv $4&(aU rSraThe input parameters have been rejected by fpchec. This means that at least one of the following conditions is violated: 1) k+1 <= n-k-1 <= m 2) t(1) <= t(2) <= ... <= t(k+1) t(n-k) <= t(n-k+1) <= ... <= t(n) 3) t(k+1) < t(k+2) < ... < t(n-k) 4) t(k+1) <= x(i) <= t(n-k) 5) The conditions specified by Schoenberg and Whitney must hold for at least one subset of data points, i.e., there must be a subset of data points y(j) such that t(j) < y(j) < t(j+k+1), j=1,2,...,n-k-1 c4\rSrSrSrSS/S-SSS4SjrS rg) ri a 1-D spline with explicit internal knots. .. legacy:: class Specifically, we recommend using `make_lsq_spline` instead. Fits a spline y = spl(x) of degree `k` to the provided `x`, `y` data. `t` specifies the internal knots of the spline Parameters ---------- x : (N,) array_like Input dimension of data points -- must be increasing y : (N,) array_like Input dimension of data points t : (M,) array_like interior knots of the spline. Must be in ascending order and:: bbox[0] < t[0] < ... < t[-1] < bbox[-1] w : (N,) array_like, optional weights for spline fitting. Must be positive. If None (default), weights are all 1. 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. 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. Raises ------ ValueError If the interior knots do not satisfy the Schoenberg-Whitney conditions See Also -------- UnivariateSpline : a smooth univariate spline to fit a given set of data points. InterpolatedUnivariateSpline : a interpolating univariate spline for a given set of data points. splrep : a function to find the B-spline representation of a 1-D curve splev : a function to evaluate a B-spline or its derivatives sproot : a function to find the roots of a cubic B-spline splint : a function to evaluate the definite integral of a B-spline between two given points spalde : a function to evaluate all derivatives of a B-spline 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 -------- >>> import numpy as np >>> from scipy.interpolate import LSQUnivariateSpline, UnivariateSpline >>> import matplotlib.pyplot as plt >>> rng = np.random.default_rng() >>> x = np.linspace(-3, 3, 50) >>> y = np.exp(-x**2) + 0.1 * rng.standard_normal(50) Fit a smoothing spline with a pre-defined internal knots: >>> t = [-1, 0, 1] >>> spl = LSQUnivariateSpline(x, y, t) >>> xs = np.linspace(-3, 3, 1000) >>> plt.plot(x, y, 'ro', ms=5) >>> plt.plot(xs, spl(xs), 'g-', lw=3) >>> plt.show() Check the knot vector: >>> spl.get_knots() array([-3., -1., 0., 1., 3.]) Constructing lsq spline using the knots from another spline: >>> x = np.arange(10) >>> s = UnivariateSpline(x, x, s=0) >>> s.get_knots() array([ 0., 2., 3., 4., 5., 6., 7., 9.]) >>> knt = s.get_knots() >>> s1 = LSQUnivariateSpline(x, x, knt[1:-1]) # Chop 1st and last knot >>> s1.get_knots() array([ 0., 2., 3., 4., 5., 6., 7., 9.]) Nrrr Fc URXXEUSXx5uppEUl[R"[ U5S:5(d [ S5eUSn USn U cUSn U cUSn [ U /US--X:/US--45n[U5n [R"X6S-X- X6X- S- - S:SS9(d [ S5e[ [R"XU5S:Xd[ [5e[R"XXcXIU S9n SSS5 W SS SSU S4-Ul UR5 g!,(df  N2=f) Nr8zx must be increasingr rr$)axisz;Interior knots t must satisfy Schoenberg-Whitney conditions)r r!r")r%r&r=r@rrArrLr'r(fpchec_fpchec_error_stringfpcurfm1r+r,) r-r.r/rOr r0r1r&r2r!r"rar3s r4r5LSQUnivariateSpline.__init__sV#'"5"5aAQ69#Iatxvvd1gn%%34 4!W !W :1B :2B "qsQac 3 4 Fvva!ACjQSU+a/a8=> > ??1+q0 !566$$Q11CD#2Y$d2h!77   \s AD>> E rrrrSr4rr s"sj#'dVAXUrSrcJ\rSrSrSr\S5rSrSrSr S Sjr Sr S r g ) _BivariateSplineBaseiaBase class for Bivariate spline s(x,y) interpolation on the rectangle [xb,xe] x [yb, ye] calculated from a given set of data points (x,y,z). See Also -------- bisplrep : a function to find a bivariate B-spline representation of a surface bisplev : a function to evaluate a bivariate B-spline and its derivatives BivariateSpline : a base class for bivariate splines. SphereBivariateSpline : a bivariate spline on a spherical grid cURU5n[U5S:wa [S5eUSSUlUSSUlU$)z3Construct a spline object from given tck and degreer9z4tck should be a 5 element tuple of tx, ty, c, kx, kyNr)rJrLrArNdegrees)rMrNr-s r4rQ_BivariateSplineBase._from_tcksN{{3 s8q=./ /r712w  rScUR$)zqReturn weighted sum of squared residuals of the spline approximation: sum ((w[i]*(z[i]-s(x[i],y[i])))**2,axis=0) )fprs r4r!_BivariateSplineBase.get_residuals wwrSc URSS$)zReturn a tuple (tx,ty) where tx,ty contain knots positions of the spline with respect to x-, y-variable, respectively. The position of interior and additional knots are given as t[k+1:-k-1] and t[:k+1]=b, t[-k-1:]=e, respectively. NrrNrs r4r_BivariateSplineBase.get_knotss xx|rSc URS$)rrrrs r4r_BivariateSplineBase.get_coeffssxx{rSc [R"U5n[R"U5nURSSupgnURupU(GaURS:XdURS:XaB[R "URUR4URSR S9$URS:a=[R"[R"U5S:5(d [S5eURS:a=[R"[R"U5S:5(d [S5eU(dU(aB[ [R"XgXXXAU5 upSSS5 W S:Xd[S U 35eW $[ [R"XgXXU5upSSS5 W S:Xd[S U 35eW $URUR:wa[R"X5upURn UR!5nUR!5nURS:XdURS:Xa+[R "XRSR S9$U(dU(a@[ [R""XgXXXAU5 upSSS5 W S:Xd[S U 35eO>[ [R$"XgXXU5upSSS5 W S:Xd[S U 35eW R'U 5n U $!,(df  GN=f!,(df  GN=f!,(df  N=f!,(df  Nj=f) ag Evaluate the spline or its derivatives at given positions. Parameters ---------- x, y : array_like Input coordinates. If `grid` is False, evaluate the spline at points ``(x[i], y[i]), i=0, ..., len(x)-1``. Standard Numpy broadcasting is obeyed. If `grid` is True: evaluate spline at the grid points defined by the coordinate arrays x, y. The arrays must be sorted to increasing order. The ordering of axes is consistent with ``np.meshgrid(..., indexing="ij")`` and inconsistent with the default ordering ``np.meshgrid(..., indexing="xy")``. dx : int Order of x-derivative .. versionadded:: 0.14.0 dy : int Order of y-derivative .. versionadded:: 0.14.0 grid : bool Whether to evaluate the results on a grid spanned by the input arrays, or at points specified by the input arrays. .. versionadded:: 0.14.0 Examples -------- Suppose that we want to bilinearly interpolate an exponentially decaying function in 2 dimensions. >>> import numpy as np >>> from scipy.interpolate import RectBivariateSpline We sample the function on a coarse grid. Note that the default indexing="xy" of meshgrid would result in an unexpected (transposed) result after interpolation. >>> xarr = np.linspace(-3, 3, 100) >>> yarr = np.linspace(-3, 3, 100) >>> xgrid, ygrid = np.meshgrid(xarr, yarr, indexing="ij") The function to interpolate decays faster along one axis than the other. >>> zdata = np.exp(-np.sqrt((xgrid / 2) ** 2 + ygrid**2)) Next we sample on a finer grid using interpolation (kx=ky=1 for bilinear). >>> rbs = RectBivariateSpline(xarr, yarr, zdata, kx=1, ky=1) >>> xarr_fine = np.linspace(-3, 3, 200) >>> yarr_fine = np.linspace(-3, 3, 200) >>> xgrid_fine, ygrid_fine = np.meshgrid(xarr_fine, yarr_fine, indexing="ij") >>> zdata_interp = rbs(xgrid_fine, ygrid_fine, grid=False) And check that the result agrees with the input by plotting both. >>> import matplotlib.pyplot as plt >>> fig = plt.figure() >>> ax1 = fig.add_subplot(1, 2, 1, aspect="equal") >>> ax2 = fig.add_subplot(1, 2, 2, aspect="equal") >>> ax1.imshow(zdata) >>> ax2.imshow(zdata_interp) >>> plt.show() Nrr rdtyper8z1x must be strictly increasing when `grid` is Truez1y must be strictly increasing when `grid` is TruezError code returned by parder: zError code returned by bispev: zError code returned by pardeu: zError code returned by bispeu: )r=r>rNrrBrrr@rrAr'r(parderbispevrCbroadcast_arraysrpardeubispeureshape)r-r.r/dxdygridtxtyrPkxkyzrbrCs r4r_BivariateSplineBase.__call__sP JJqM JJqMHHRaL  vv{affkxx 0 8I8IJJ! bffRWWQZ3->&?&? !TUU! bffRWWQZ3->&?&? !TUUR!%__RQBB1MFA"ax$'Fse%LMM >9"%__RQB1EFA"ax$'Fse%LMM 4-ww!''!**10GGE A Avv{affkxxXXa[->->??R!%__RQBB1MFA"ax$'Fse%LMM "%__RQB1EFA"ax$'Fse%LMM % AC"\ "\""\ "\s0%L*'L<MM* L9< M  M M-c US:XaUS:XaU$URup4US:aUS:d [S5eX:aX$:d [S5eURSSupVn[ [R "XVXsXAU5upSSS5 W S:wa[SU -5e[ U5n [ U5n XQX- n XbX- n X1- XB- pX- U- S- X- U- S- -n[RXWSUX45$!,(df  N{=f)aConstruct a new spline representing a partial derivative of this spline. Parameters ---------- dx, dy : int Orders of the derivative in x and y respectively. They must be non-negative integers and less than the respective degree of the original spline (self) in that direction (``kx``, ``ky``). Returns ------- spline : A new spline of degrees (``kx - dx``, ``ky - dy``) representing the derivative of this spline. Notes ----- .. versionadded:: 1.9.0 r z,order of derivative must be positive or zeroz6order of derivative must be less than degree of splineNrz,Unexpected error code returned by pardtc: %dr) rrArNr'r(pardtcrL_DerivedBivariateSplinerQ)r-rrrrrrrPnewcrbnxnynewtxnewtynewkxnewkynewclens r4partial_derivative'_BivariateSplineBase.partial_derivativeHs1. 7rQwK\\FB!Ga ")**G "566! IBA$OOBA22F ax "/14"566RBRB"'NE"'NE7BG5w|a'BGbL1,<=G*44e6:8Gn6;6DE Es !C22 D)rrNNr r T) rrrrrrrQrrrrrrrrSr4rrs7  xt0ErSrz The required storage space exceeds the available storage space: nxest or nyest too small, or s too small. The weighted least-squares spline corresponds to the current set of knots.z A theoretically impossible result was found during the iteration process for finding a smoothing spline with fp = s: s too small or badly chosen eps. Weighted sum of squared residuals does not satisfy abs(fp-s)/s < tol.z the maximal number of iterations maxit (set to 20 by the program) allowed for finding a smoothing spline with fp=s has been reached: s too small. Weighted sum of squared residuals does not satisfy abs(fp-s)/s < tol.z No more knots can be added because the number of b-spline coefficients (nx-kx-1)*(ny-ky-1) already exceeds the number of data points m: either s or m too small. The weighted least-squares spline corresponds to the current set of knots.z No more knots can be added because the additional knot would (quasi) coincide with an old one: s too small or too large a weight to an inaccurate data point. The weighted least-squares spline corresponds to the current set of knots.z Error on entry, no approximation returned. The following conditions must hold: xb<=x[i]<=xe, yb<=y[i]<=ye, w[i]>0, i=0..m-1 If iopt==-1, then xb>> import numpy as np >>> from scipy.interpolate import RectBivariateSpline >>> def f(x, y): ... return np.exp(-np.sqrt((x / 2) ** 2 + y**2)) We sample the function on a coarse grid and set up the interpolator. Note that the default ``indexing="xy"`` of meshgrid would result in an unexpected (transposed) result after interpolation. >>> xarr = np.linspace(-3, 3, 21) >>> yarr = np.linspace(-3, 3, 21) >>> xgrid, ygrid = np.meshgrid(xarr, yarr, indexing="ij") >>> zdata = f(xgrid, ygrid) >>> rbs = RectBivariateSpline(xarr, yarr, zdata, kx=1, ky=1) Next we sample the function along a diagonal slice through the coordinate space on a finer grid using interpolation. >>> xinterp = np.linspace(-3, 3, 201) >>> yinterp = np.linspace(3, -3, 201) >>> zinterp = rbs.ev(xinterp, yinterp) And check that the interpolation passes through the function evaluations as a function of the distance from the origin along the slice. >>> import matplotlib.pyplot as plt >>> fig = plt.figure() >>> ax1 = fig.add_subplot(1, 1, 1) >>> ax1.plot(np.sqrt(xarr**2 + yarr**2), np.diag(zdata), "or") >>> ax1.plot(np.sqrt(xinterp**2 + yinterp**2), zinterp, "-b") >>> plt.show() Frrrr)r-xiyirrs r4evBivariateSpline.evsx}}R}>>rSc URSSupVnURup[ [R"XVXxXX#U5 sSSS5 $!,(df  g=f)a$ Evaluate the integral of the spline over area [xa,xb] x [ya,yb]. Parameters ---------- xa, xb : float The end-points of the x integration interval. ya, yb : float The end-points of the y integration interval. Returns ------- integ : float The value of the resulting integral. Nr)rNrr'r(dblint) r-xar!yaybrrrPrrs r4rBivariateSpline.integralsC"HHRaL  ??21"""E\\s A  AcL[R"U5[R"U5[R"U5p!nURURs=:XaUR:Xd O [S5eUbd[R"U5nURUR:wa [S5e[R"US:5(d [S5eUbSUs=:aS:d O [S5eURUS-US--:d [S5eXX#4$) Nz%x, y, and z should have a same lengthz(x, y, z, and w should have a same lengthr8w should be positive?eps should be between (0, 1)rz;The length of x, y and z should be at least (kx+1) * (ky+1))r=r>rBrAr@)r.r/rr rrepss r4_validate_inputBivariateSpline._validate_inputs**Q-A 1 avv)166)DE E = 1 Avv !KLLVVAH%% !788 OcCo#o;< <vv"q&R!V,,01 1QzrSrNr r ) rrrrrrrrrrrrSr4rrs( D<?|F,rSrc2\rSrSrSrSr\S5rSrSr g)ri0aBivariate spline constructed from the coefficients and knots of another spline. Notes ----- The class is not meant to be instantiated directly from the data to be interpolated or smoothed. As a result, its ``fp`` attribute and ``get_residual`` method are inherited but overridden; ``AttributeError`` is raised when they are accessed. The other inherited attributes can be used as usual. zis unavailable, because _DerivedBivariateSpline instance is not constructed from data that are to be interpolated or smoothed, but derived from the underlying knots and coefficients of another spline objectc2[SUR35e)Nzattribute "fp" AttributeError _invalid_whyrs r4r_DerivedBivariateSpline.fpCs01B1B0CDEErSc2[SUR35e)Nzmethod "get_residual" rrs r4r$_DerivedBivariateSpline.get_residualGs78I8I7JKLLrSrN) rrrrrr propertyrrrrrSr4rr0s* L FFMrSrc6\rSrSrSrSS/S-SSSS4SjrSrg) riKaY Smooth bivariate spline approximation. Parameters ---------- x, y, z : array_like 1-D sequences of data points (order is not important). w : array_like, optional Positive 1-D sequence of weights, of same length as `x`, `y` and `z`. bbox : array_like, optional Sequence of length 4 specifying the boundary of the rectangular approximation domain. By default, ``bbox=[min(x), max(x), min(y), max(y)]``. kx, ky : ints, optional Degrees of the bivariate spline. Default is 3. s : float, optional Positive smoothing factor defined for estimation condition: ``sum((w[i]*(z[i]-s(x[i], y[i])))**2, axis=0) <= s`` Default ``s=len(w)`` which should be a good value if ``1/w[i]`` is an estimate of the standard deviation of ``z[i]``. eps : float, optional A threshold for determining the effective rank of an over-determined linear system of equations. `eps` should have a value within the open interval ``(0, 1)``, the default is 1e-16. See Also -------- BivariateSpline : a base class for bivariate splines. UnivariateSpline : a smooth univariate spline to fit a given set of data points. LSQBivariateSpline : a bivariate spline using weighted least-squares fitting RectSphereBivariateSpline : a bivariate spline over a rectangular mesh on a sphere SmoothSphereBivariateSpline : a smoothing bivariate spline in spherical coordinates LSQSphereBivariateSpline : a bivariate spline in spherical coordinates using weighted least-squares fitting RectBivariateSpline : a bivariate spline over a rectangular mesh bisplrep : a function to find a bivariate B-spline representation of a surface bisplev : a function to evaluate a bivariate B-spline and its derivatives Notes ----- The length of `x`, `y` and `z` should be at least ``(kx+1) * (ky+1)``. If the input data is such that input dimensions have incommensurate units and differ by many orders of magnitude, the interpolant may have numerical artifacts. Consider rescaling the data before interpolating. This routine constructs spline knot vectors automatically via the FITPACK algorithm. The spline knots may be placed away from the data points. For some data sets, this routine may fail to construct an interpolating spline, even if one is requested via ``s=0`` parameter. In such situations, it is recommended to use `bisplrep` / `bisplev` directly instead of this routine and, if needed, increase the values of ``nxest`` and ``nyest`` parameters of `bisplrep`. For linear interpolation, prefer `LinearNDInterpolator`. See ``https://gist.github.com/ev-br/8544371b40f414b7eaf3fe6217209bff`` for discussion. Nrr缉ؗҜr@rrArBrCr'r( regrid_smthrr^rrNr)r-r.r/rr0rrr#r!r"rrrrrrrPrrbmsgs r4r5RectBivariateSpline.__init__Js1XuQxtd JJqMvvd1gm$$<= =vvd1gm$$<= =vv#-. .vv#-. .zzT!89 9 =c34 4 !H )1)=)=aA2<>B*K &BBAr3 k !"&&sd3%L9CS/ !cr7BsGQ'E11(E%FFv \s 0!F33 GrrrrSr4r r s5n'+VaZA!qrSr a ERROR. On entry, the input data are controlled on validity. The following restrictions must be satisfied: -1<=iopt<=1, m>=2, ntest>=8 ,npest >=8, 00, i=1,...,m lwrk1 >= 185+52*v+10*u+14*u*v+8*(u-1)*v**2+8*m kwrk >= m+(ntest-7)*(npest-7) if iopt=-1: 8<=nt<=ntest , 9<=np<=npest 0=0: s>=0 if one of these conditions is found to be violated,control is immediately repassed to the calling program. in that case there is no approximation returned.ra WARNING. The coefficients of the spline returned have been computed as the minimal norm least-squares solution of a (numerically) rank deficient system (deficiency=%i, rank=%i). Especially if the rank deficiency, which is computed by 6+(nt-8)*(np-7)+ier, is large, the results may be inaccurate. They could also seriously depend on the value of eps.rc,\rSrSrSrSSjrSSjrSrg) SphereBivariateSplineia5 Bivariate spline s(x,y) of degrees 3 on a sphere, calculated from a given set of data points (theta,phi,r). .. versionadded:: 0.11.0 See Also -------- bisplrep : a function to find a bivariate B-spline representation of a surface bisplev : a function to evaluate a bivariate B-spline and its derivatives UnivariateSpline : a smooth univariate spline to fit a given set of data points. SmoothBivariateSpline : a smoothing bivariate spline through the given points LSQUnivariateSpline : a univariate spline using weighted least-squares fitting c ([R"U5n[R"U5nURS:aAUR5S:d"UR 5[R :a [ S5e[RXUX4US9$)a Evaluate the spline or its derivatives at given positions. Parameters ---------- theta, phi : array_like Input coordinates. If `grid` is False, evaluate the spline at points ``(theta[i], phi[i]), i=0, ..., len(x)-1``. Standard Numpy broadcasting is obeyed. If `grid` is True: evaluate spline at the grid points defined by the coordinate arrays theta, phi. The arrays must be sorted to increasing order. The ordering of axes is consistent with ``np.meshgrid(..., indexing="ij")`` and inconsistent with the default ordering ``np.meshgrid(..., indexing="xy")``. dtheta : int, optional Order of theta-derivative .. versionadded:: 0.14.0 dphi : int Order of phi-derivative .. versionadded:: 0.14.0 grid : bool Whether to evaluate the results on a grid spanned by the input arrays, or at points specified by the input arrays. .. versionadded:: 0.14.0 Examples -------- Suppose that we want to use splines to interpolate a bivariate function on a sphere. The value of the function is known on a grid of longitudes and colatitudes. >>> import numpy as np >>> from scipy.interpolate import RectSphereBivariateSpline >>> def f(theta, phi): ... return np.sin(theta) * np.cos(phi) We evaluate the function on the grid. Note that the default indexing="xy" of meshgrid would result in an unexpected (transposed) result after interpolation. >>> thetaarr = np.linspace(0, np.pi, 22)[1:-1] >>> phiarr = np.linspace(0, 2 * np.pi, 21)[:-1] >>> thetagrid, phigrid = np.meshgrid(thetaarr, phiarr, indexing="ij") >>> zdata = f(thetagrid, phigrid) We next set up the interpolator and use it to evaluate the function on a finer grid. >>> rsbs = RectSphereBivariateSpline(thetaarr, phiarr, zdata) >>> thetaarr_fine = np.linspace(0, np.pi, 200) >>> phiarr_fine = np.linspace(0, 2 * np.pi, 200) >>> zdata_fine = rsbs(thetaarr_fine, phiarr_fine) Finally we plot the coarsly-sampled input data alongside the finely-sampled interpolated data to check that they agree. >>> import matplotlib.pyplot as plt >>> fig = plt.figure() >>> ax1 = fig.add_subplot(1, 2, 1) >>> ax2 = fig.add_subplot(1, 2, 2) >>> ax1.imshow(zdata) >>> ax2.imshow(zdata_fine) >>> plt.show() r r8zrequested theta out of bounds.r) r=r>rBminrpirArrr-thetaphidthetadphirs r4rSphereBivariateSpline.__call__sxR 5!jjo ::>uyy{R/599;3F=> >#,,T#06d-L LrSc$URXX4SS9$)a Evaluate the spline at points Returns the interpolated value at ``(theta[i], phi[i]), i=0,...,len(theta)-1``. Parameters ---------- theta, phi : array_like Input coordinates. Standard Numpy broadcasting is obeyed. The ordering of axes is consistent with np.meshgrid(..., indexing="ij") and inconsistent with the default ordering np.meshgrid(..., indexing="xy"). dtheta : int, optional Order of theta-derivative .. versionadded:: 0.14.0 dphi : int, optional Order of phi-derivative .. versionadded:: 0.14.0 Examples -------- Suppose that we want to use splines to interpolate a bivariate function on a sphere. The value of the function is known on a grid of longitudes and colatitudes. >>> import numpy as np >>> from scipy.interpolate import RectSphereBivariateSpline >>> def f(theta, phi): ... return np.sin(theta) * np.cos(phi) We evaluate the function on the grid. Note that the default indexing="xy" of meshgrid would result in an unexpected (transposed) result after interpolation. >>> thetaarr = np.linspace(0, np.pi, 22)[1:-1] >>> phiarr = np.linspace(0, 2 * np.pi, 21)[:-1] >>> thetagrid, phigrid = np.meshgrid(thetaarr, phiarr, indexing="ij") >>> zdata = f(thetagrid, phigrid) We next set up the interpolator and use it to evaluate the function at points not on the original grid. >>> rsbs = RectSphereBivariateSpline(thetaarr, phiarr, zdata) >>> thetainterp = np.linspace(thetaarr[0], thetaarr[-1], 200) >>> phiinterp = np.linspace(phiarr[0], phiarr[-1], 200) >>> zinterp = rsbs.ev(thetainterp, phiinterp) Finally we plot the original data for a diagonal slice through the initial grid, and the spline approximation along the same slice. >>> import matplotlib.pyplot as plt >>> fig = plt.figure() >>> ax1 = fig.add_subplot(1, 1, 1) >>> ax1.plot(np.sin(thetaarr) * np.sin(phiarr), np.diag(zdata), "or") >>> ax1.plot(np.sin(thetainterp) * np.sin(phiinterp), zinterp, "-b") >>> plt.show() Fr2r3rr)r-r0r1r2r3s r4rSphereBivariateSpline.evsz}}U}NNrSrNrr)rrrrrrrrrrSr4r+r+s(PLd=OrSr+c,\rSrSrSrSSjrSSjrSrg) r i*a Smooth bivariate spline approximation in spherical coordinates. .. versionadded:: 0.11.0 Parameters ---------- theta, phi, r : array_like 1-D sequences of data points (order is not important). Coordinates must be given in radians. Theta must lie within the interval ``[0, pi]``, and phi must lie within the interval ``[0, 2pi]``. w : array_like, optional Positive 1-D sequence of weights. s : float, optional Positive smoothing factor defined for estimation condition: ``sum((w(i)*(r(i) - s(theta(i), phi(i))))**2, axis=0) <= s`` Default ``s=len(w)`` which should be a good value if ``1/w[i]`` is an estimate of the standard deviation of ``r[i]``. eps : float, optional A threshold for determining the effective rank of an over-determined linear system of equations. `eps` should have a value within the open interval ``(0, 1)``, the default is 1e-16. See Also -------- BivariateSpline : a base class for bivariate splines. UnivariateSpline : a smooth univariate spline to fit a given set of data points. SmoothBivariateSpline : a smoothing bivariate spline through the given points LSQBivariateSpline : a bivariate spline using weighted least-squares fitting RectSphereBivariateSpline : a bivariate spline over a rectangular mesh on a sphere LSQSphereBivariateSpline : a bivariate spline in spherical coordinates using weighted least-squares fitting RectBivariateSpline : a bivariate spline over a rectangular mesh. bisplrep : a function to find a bivariate B-spline representation of a surface bisplev : a function to evaluate a bivariate B-spline and its derivatives Notes ----- For more information, see the FITPACK_ site about this function. .. _FITPACK: http://www.netlib.org/dierckx/sphere.f Examples -------- Suppose we have global data on a coarse grid (the input data does not have to be on a grid): >>> import numpy as np >>> theta = np.linspace(0., np.pi, 7) >>> phi = np.linspace(0., 2*np.pi, 9) >>> data = np.empty((theta.shape[0], phi.shape[0])) >>> data[:,0], data[0,:], data[-1,:] = 0., 0., 0. >>> data[1:-1,1], data[1:-1,-1] = 1., 1. >>> data[1,1:-1], data[-2,1:-1] = 1., 1. >>> data[2:-2,2], data[2:-2,-2] = 2., 2. >>> data[2,2:-2], data[-3,2:-2] = 2., 2. >>> data[3,3:-2] = 3. >>> data = np.roll(data, 4, 1) We need to set up the interpolator object >>> lats, lons = np.meshgrid(theta, phi) >>> from scipy.interpolate import SmoothSphereBivariateSpline >>> lut = SmoothSphereBivariateSpline(lats.ravel(), lons.ravel(), ... data.T.ravel(), s=3.5) As a first test, we'll see what the algorithm returns when run on the input coordinates >>> data_orig = lut(theta, phi) Finally we interpolate the data to a finer grid >>> fine_lats = np.linspace(0., np.pi, 70) >>> fine_lons = np.linspace(0., 2 * np.pi, 90) >>> data_smth = lut(fine_lats, fine_lons) >>> import matplotlib.pyplot as plt >>> fig = plt.figure() >>> ax1 = fig.add_subplot(131) >>> ax1.imshow(data, interpolation='nearest') >>> ax2 = fig.add_subplot(132) >>> ax2.imshow(data_orig, interpolation='nearest') >>> ax3 = fig.add_subplot(133) >>> ax3.imshow(data_smth, interpolation='nearest') >>> plt.show() Nc [R"U5[R"U5[R"U5p2nSU:*R5(a&U[R:*R5(d [ S5eSU:*R5(a)US[R-:*R5(d [ S5eUb9[R"U5nUS:R5(d [ S5eUS:d [ S5eSUs=:aS:d O [ S5e[  [ R"XX4UUS 9upxppn SSS5 W S ;a$[RU S U 35n[ U5eW Ul WSWW SW W SUS - U S - -4Ul S Ul g!,(df  Nc=f)Nr8theta should be between [0, pi]@phi should be between [0, 2pi]rs should be positiverr)r r#rrrYrrr) r=r>r@r.rAr'r( spherfit_smth_spherefit_messagesr^rrNr)r-r0r1rr r#rnt_tt_np_tp_rPrrbrcs r4r5$SmoothSphereBivariateSpline.__init__s 5)2::c?BJJqMA""$$%255.)=)=)?)?>? ?  ""sRUU{(:'?'?'A'A=> > = 1 AH>>## !788Cx34 4S3;< < -5-C-CEDEaHK.M *Ccs k !)--cT#<@GW% %t9c$3i+AS1Wq,A)BB \s F>> G c ,[R"U5n[R"U5nURS:aDUR5S:d%UR 5S[R -:a [ S5e[RXX#XES9$Nr r8r;zrequested phi out of bounds.r6 r=r>rBr-rr.rAr+rr/s r4r$SmoothSphereBivariateSpline.__call__v 5!jjo 88a>> from scipy.interpolate import LSQSphereBivariateSpline >>> import numpy as np >>> import matplotlib.pyplot as plt >>> theta = np.linspace(0, np.pi, num=7) >>> phi = np.linspace(0, 2*np.pi, num=9) >>> data = np.empty((theta.shape[0], phi.shape[0])) >>> data[:,0], data[0,:], data[-1,:] = 0., 0., 0. >>> data[1:-1,1], data[1:-1,-1] = 1., 1. >>> data[1,1:-1], data[-2,1:-1] = 1., 1. >>> data[2:-2,2], data[2:-2,-2] = 2., 2. >>> data[2,2:-2], data[-3,2:-2] = 2., 2. >>> data[3,3:-2] = 3. >>> data = np.roll(data, 4, 1) We need to set up the interpolator object. Here, we must also specify the coordinates of the knots to use. >>> lats, lons = np.meshgrid(theta, phi) >>> knotst, knotsp = theta.copy(), phi.copy() >>> knotst[0] += .0001 >>> knotst[-1] -= .0001 >>> knotsp[0] += .0001 >>> knotsp[-1] -= .0001 >>> lut = LSQSphereBivariateSpline(lats.ravel(), lons.ravel(), ... data.T.ravel(), knotst, knotsp) As a first test, we'll see what the algorithm returns when run on the input coordinates >>> data_orig = lut(theta, phi) Finally we interpolate the data to a finer grid >>> fine_lats = np.linspace(0., np.pi, 70) >>> fine_lons = np.linspace(0., 2*np.pi, 90) >>> data_lsq = lut(fine_lats, fine_lons) >>> fig = plt.figure() >>> ax1 = fig.add_subplot(131) >>> ax1.imshow(data, interpolation='nearest') >>> ax2 = fig.add_subplot(132) >>> ax2.imshow(data_orig, interpolation='nearest') >>> ax3 = fig.add_subplot(133) >>> ax3.imshow(data_lsq, interpolation='nearest') >>> plt.show() Nc [R"U5[R"U5[R"U5p2n[R"U5[R"U5pTSU:*R5(a&U[R:*R5(d [ S5eSU:*R5(a)US[R-:*R5(d [ S5eSU:R5(a&U[R:R5(d [ S5eSU:R5(a)US[R-:R5(d [ S5eUb9[R"U5nUS:R5(d [ S5eSUs=:aS:d O [ S 5eS [ U5-S [ U5-p[ U4[5[ U 4[5pXEsU S S &U S S &[RS [R-sU S S&U S S&[ [R"XX:U XgS9uppnSSS5 WS:a$[RUSU35n[ U5eW Ul XW 4UlSUlg!,(df  NP=f)Nr8r:rr<ztt should be between (0, pi)ztp should be between (0, 2pi)rrrrVrr;)r rr rYr>)r=r>r@r.rArLrrr'r( spherfit_lsqr@r^rrNr)r-r0r1rAtttpr rrBrDrCrErPrrbrcs r4r5!LSQSphereBivariateSpline.__init__$s; 5)2::c?BJJqMABBB""$$%255.)=)=)?)?>? ?  ""qw';';'='==> >r  b255j%5%5%7%7;< <r  b1RUU7l%7%7%9%9<= = = 1 AH>>## !788S3;< <s2w;CG S#'vu)=S!Ab 3q9UUBJBC#bc( #+#8#8QS:;$F CaS 7)--cT#<@GW% %Q; \s #K  Kc ,[R"U5n[R"U5nURS:aDUR5S:d%UR 5S[R -:a [ S5e[RXX#XES9$rHrIr/s r4r!LSQSphereBivariateSpline.__call__GrKrSr)NrrrLrrSr4rrsiV!F DrSra ERROR: on entry, the input data are controlled on validity the following restrictions must be satisfied. -1<=iopt(1)<=1, 0<=iopt(2)<=1, 0<=iopt(3)<=1, -1<=ider(1)<=1, 0<=ider(2)<=1, ider(2)=0 if iopt(2)=0. -1<=ider(3)<=1, 0<=ider(4)<=1, ider(4)=0 if iopt(3)=0. mu >= mumin (see above), mv >= 4, nuest >=8, nvest >= 8, kwrk>=5+mu+mv+nuest+nvest, lwrk >= 12+nuest*(mv+nvest+3)+nvest*24+4*mu+8*mv+max(nuest,mv+nvest) 0< u(i-1)=0: s>=0 if s=0: nuest>=mu+6+iopt(2)+iopt(3), nvest>=mv+7 if one of these conditions is found to be violated,control is immediately repassed to the calling program. in that case there is no approximation returned.c0\rSrSrSrSSjrSSjrSrg) r ipa Bivariate spline approximation over a rectangular mesh on a sphere. Can be used for smoothing data. .. versionadded:: 0.11.0 Parameters ---------- u : array_like 1-D array of colatitude coordinates in strictly ascending order. Coordinates must be given in radians and lie within the open interval ``(0, pi)``. v : array_like 1-D array of longitude coordinates in strictly ascending order. Coordinates must be given in radians. First element (``v[0]``) must lie within the interval ``[-pi, pi)``. Last element (``v[-1]``) must satisfy ``v[-1] <= v[0] + 2*pi``. r : array_like 2-D array of data with shape ``(u.size, v.size)``. s : float, optional Positive smoothing factor defined for estimation condition (``s=0`` is for interpolation). pole_continuity : bool or (bool, bool), optional Order of continuity at the poles ``u=0`` (``pole_continuity[0]``) and ``u=pi`` (``pole_continuity[1]``). The order of continuity at the pole will be 1 or 0 when this is True or False, respectively. Defaults to False. pole_values : float or (float, float), optional Data values at the poles ``u=0`` and ``u=pi``. Either the whole parameter or each individual element can be None. Defaults to None. pole_exact : bool or (bool, bool), optional Data value exactness at the poles ``u=0`` and ``u=pi``. If True, the value is considered to be the right function value, and it will be fitted exactly. If False, the value will be considered to be a data value just like the other data values. Defaults to False. pole_flat : bool or (bool, bool), optional For the poles at ``u=0`` and ``u=pi``, specify whether or not the approximation has vanishing derivatives. Defaults to False. See Also -------- BivariateSpline : a base class for bivariate splines. UnivariateSpline : a smooth univariate spline to fit a given set of data points. SmoothBivariateSpline : a smoothing bivariate spline through the given points LSQBivariateSpline : a bivariate spline using weighted least-squares fitting SmoothSphereBivariateSpline : a smoothing bivariate spline in spherical coordinates LSQSphereBivariateSpline : a bivariate spline in spherical coordinates using weighted least-squares fitting RectBivariateSpline : a bivariate spline over a rectangular mesh. bisplrep : a function to find a bivariate B-spline representation of a surface bisplev : a function to evaluate a bivariate B-spline and its derivatives Notes ----- Currently, only the smoothing spline approximation (``iopt[0] = 0`` and ``iopt[0] = 1`` in the FITPACK routine) is supported. The exact least-squares spline approximation is not implemented yet. When actually performing the interpolation, the requested `v` values must lie within the same length 2pi interval that the original `v` values were chosen from. For more information, see the FITPACK_ site about this function. .. _FITPACK: http://www.netlib.org/dierckx/spgrid.f Examples -------- Suppose we have global data on a coarse grid >>> import numpy as np >>> lats = np.linspace(10, 170, 9) * np.pi / 180. >>> lons = np.linspace(0, 350, 18) * np.pi / 180. >>> data = np.dot(np.atleast_2d(90. - np.linspace(-80., 80., 18)).T, ... np.atleast_2d(180. - np.abs(np.linspace(0., 350., 9)))).T We want to interpolate it to a global one-degree grid >>> new_lats = np.linspace(1, 180, 180) * np.pi / 180 >>> new_lons = np.linspace(1, 360, 360) * np.pi / 180 >>> new_lats, new_lons = np.meshgrid(new_lats, new_lons) We need to set up the interpolator object >>> from scipy.interpolate import RectSphereBivariateSpline >>> lut = RectSphereBivariateSpline(lats, lons, data) Finally we interpolate the data. The `RectSphereBivariateSpline` object only takes 1-D arrays as input, therefore we need to do some reshaping. >>> data_interp = lut.ev(new_lats.ravel(), ... new_lons.ravel()).reshape((360, 180)).T Looking at the original and the interpolated data, one can see that the interpolant reproduces the original data very well: >>> import matplotlib.pyplot as plt >>> fig = plt.figure() >>> ax1 = fig.add_subplot(211) >>> ax1.imshow(data, interpolation='nearest') >>> ax2 = fig.add_subplot(212) >>> ax2.imshow(data_interp, interpolation='nearest') >>> plt.show() Choosing the optimal value of ``s`` can be a delicate task. Recommended values for ``s`` depend on the accuracy of the data values. If the user has an idea of the statistical errors on the data, she can also find a proper estimate for ``s``. By assuming that, if she specifies the right ``s``, the interpolator will use a spline ``f(u,v)`` which exactly reproduces the function underlying the data, she can evaluate ``sum((r(i,j)-s(u(i),v(j)))**2)`` to find a good estimate for this ``s``. For example, if she knows that the statistical errors on her ``r(i,j)``-values are not greater than 0.1, she may expect that a good ``s`` should have a value not larger than ``u.size * v.size * (0.1)**2``. If nothing is known about the statistical error in ``r(i,j)``, ``s`` must be determined by trial and error. The best is then to start with a very large value of ``s`` (to determine the least-squares polynomial and the corresponding upper bound ``fp0`` for ``s``) and then to progressively decrease the value of ``s`` (say by a factor 10 in the beginning, i.e. ``s = fp0 / 10, fp0 / 100, ...`` and more carefully as the approximation shows more detail) to obtain closer fits. The interpolation results for different values of ``s`` give some insight into this process: >>> fig2 = plt.figure() >>> s = [3e9, 2e9, 1e9, 1e8] >>> for idx, sval in enumerate(s, 1): ... lut = RectSphereBivariateSpline(lats, lons, data, s=sval) ... data_interp = lut.ev(new_lats.ravel(), ... new_lons.ravel()).reshape((360, 180)).T ... ax = fig2.add_subplot(2, 2, idx) ... ax.imshow(data_interp, interpolation='nearest') ... ax.set_title(f"s = {sval:g}") >>> plt.show() Nc h[R"/SQ[S9n [R"/SQ[S9n UcSnO7[U[[R [R 45(aXf4n[U[5(aXU4n[U[5(aXw4n[U[5(aX4nUupXYSS&U cSU S'OUSU S'U cSU S'OUSU S'UuU S'U S '[R"U5[R"U5p![R"U5nS US:aUS[R:d [S 5e[R*USs=::a[R:d O [S 5eUSUSS[R--::d [S 5e[R"[R"U5S :5(d [S5e[R"[R"U5S :5(d [S5eURURS:Xd [S5eURURS:Xd [S5eUSSLaUSSLa [S5eUSSLaUSSLa [S5eUS :d [S5e[R"U5n[  ["R$"XUR'5UR'5UR'5XU5upnnnnnSSS5 WS;a$[(R+USU35n[U5eWUlWSW WSWWSU S- US- -4UlSUlUSUlg!,(df  Nm=f)N)r r r r)r$r r$r )NNrr$r rrr8zu should be between (0, pi)z v[0] should be between [-pi, pi)z#v[-1] should be v[0] + 2pi or less zu must be strictly increasingzv must be strictly increasingz7u dimension of r must have same number of elements as uz7v dimension of r must have same number of elements as vFTz1if pole_continuity is False, so must be pole_flatr=rrYrr>)r=r dfitpack_int isinstancerfloat32float64boolrr>r.rAr@rrBrCr'r(regrid_smth_sphercopy_spfit_messagesr^rrNrv0)r-uvrAr#pole_continuity pole_values pole_exact pole_flatioptiderr0r1rtunvtvrPrrbr(s r4r5"RectSphereBivariateSpline.__init__ sXxx 6xxl;  &K  eRZZ%D E E&4K ot , ,.@O j$ ' '$1J i & &".I"QR :DG mDG :DG mDG$Qaxx{BHHQK1 JJqMad quruu}:; ;v1%%?@ @u!qw&BC Cvvbggaj3&''<= =vvbggaj3&''<= =vv#-. .vv#-. . 1  &9Q<4+?)* * 1  &9Q<4+?)* *Cx34 4 HHQK )1)C)CDDEFFHDEFFHDEFFHDFA *O &BBAr3 k !!%%cT#<8CS/ !cr7BsGQ'9aBqD(9%:: A$\s /A N## N1c [R"U5n[R"U5n[RXX#XES9$)Nr6)r=r>r+rr/s r4r"RectSphereBivariateSpline.__call__T s> 5!jjo$--d337.D DrS)rrrNr`)r8FNFFrrLrrSr4r r ps SjJN-2L\DrSr ))r__all__r_ threadingr numpyrrrrrr=rrr(typesintvarrrXr'r]rDrrrrrrrrrrr r^r@r+r rr_r rrSr4rws !88#~~$$** v J J &':a# F 9F 9Rh#3hV O*OhXEXEv I I   -CE'TH*HVM2M6`O`FaaHV/Vr'++- 8BBdO0dONKD"7KD\XD4XDv#'')"8jD 5jDrS