L idZddlmZddlZddlmZmZddlm Z ddl m Z gdZ dd Z Gd d e ZGd d eZddZGddeZGddeZy)z;Interpolation algorithms using piecewise cubic polynomials.)LiteralN)solve solve_banded)PPoly) _isscalar)CubicHermiteSplinePchipInterpolatorpchip_interpolateAkima1DInterpolator CubicSplinecxttj||f\}}tj|jtj r t d|jt}tj|jtj rt}nt}|tj|}|j|jk7r t dtj|jtj rt}|j|d}|j|d}||jz}|jdk7r t d|jddkr t d |jd|j|k7rt d |d tjtj|s t d tjtj|s t d |3tjtj|s t dtj|}tj|dkr t dtj ||d}|tj ||d}|||||fS)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 ^/mnt/ssd/data/python-lab/Trading/venv/lib/python3.12/site-packages/scipy/interpolate/_cubic.py prepare_inputr)s! rzzAq6 "DAq }}QWWb001899 A }}QWWb001 zz$ 77djj NO O ==R%7%7 8E{{5u{- U#A !&&=Dvv{566wwqzA~@AAwwqzQWWT]":4&A334 4 66"++a. !?@@ 66"++a. !?@@ r{{4'8 9BCC B vvbAgDEE AtQA {{4q) b!T4 c$eZdZdZdfd ZxZS)r a Piecewise cubic interpolator to fit values and first derivatives (C1 smooth). 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 solve 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|d}t||||\}}}}}|j|jdgdg|jdz zz}t j |d|z }|dd|ddzd|zz |z } t j dt|dz f|jddz| j} | |z | d<||ddz |z | z | d<|dd| d<|dd| d <t |)| || ||_ y) NTrrr%rr) extrapolate) r)reshaperrrr emptylenrsuper__init__r%) selfr#r$r&r%r2r'dxrslopetc __class__s r(r7zCubicHermiteSpline.__init__s!  K,Q4>2q$jj"((1+! );;<"S( #2Yab !AI - 4 HHaQ!_qwwqr{2!'' B3w!Sb !S(1,!CRy!"v! A;7 r*rN)__name__ __module__ __qualname____doc__r7 __classcell__r=s@r(r r HsAFr*r cDeZdZdZdfd ZedZedZxZS)r al PCHIP shape-preserving interpolator (C1 smooth). ``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 integrate solve 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.t|||\}}}}}tj|r d}t||j |j dfd|j dz zz}|j||}t |%|||d|||_ y)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`.rrrr%r2) r)r iscomplexobjrr3rr_find_derivativesr6r7r%) r8r#r$r%r2_msgxpdkr=s r(r7zPchipInterpolator.__init__s(At41aq ??1 WCS/ ! YY }tQVVAX6 7  # #B * Ar{C r*cjd|z|z|z||zz ||zz }tj|tj|k7}tj|tj|k7tj|dtj|zkDz}||z}d||<d||z||<|S)Nrg@)rsignabs)h0h1m0m1dmaskmask2mmms r( _edge_casezPchipInterpolator._edge_casesdRi^be #R 0wwqzRWWR[( +q BrvvbzM0IJuo$BsG#r*cL|j}|jdk(r|dddf}|dddf}|dd|ddz }|dd|ddz |z }|jddk(r0tj|}||d<||d<|j |Stj |}|dd|ddk7|dddk(z|dddk(z}d|ddz|ddz}|ddd|ddzz} tj dd5||ddz | |ddz z|| zz } dddtj|}d|dd|<d |z |dd|<tj|d|d|d|d|d<tj|d|d |d|d |d<|j |S#1swYxYw) Nrr.rrignore)divideinvalidrP?) rrr zeros_liker3rQerrstater r[) r#r$y_shapehkmkrNsmk conditionw1w2whmeans r(rJz#PchipInterpolator._find_derivatives s'' 66Q;!T' A!T' A qrUQsV^eafn " 771:?q!BBqEBqE::g& &ggbkWCR(RVq[9RW\J r!"vX3B  Va3Bi [[( ; :CRj2bf9,b9F :]]1 !1R"VYJ%771R)",,RUBqE2a5"Q%H1"--bfbfbfbfM2zz'"" : :s .FF#r>) r?r@rArBr7 staticmethodr[rJrCrDs@r(r r s7L\   .#.#r*r ct|||}|dk(r||St|r|j||S|Dcgc]}|j||c}Scc}w)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. 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 <seh "bt,A axt 3 q||C ##.12  R #222sA#cneZdZdZd ddddeddedzffdZd d Zedd Z edd Z xZ S)r aAkima "visually pleasing" interpolator (C1 smooth). 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 integrate solve 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)methodr2rv)rumakimar2c2|dvrtd|dt|||\}}}}}tj|r d}t ||dn|}|j ddk(rg|j |j dfd|jd z zz} | d d| dd z } |d d|dd z | z } tj|} | | d <ntj|jd zf|j d dz} |tdfd |jd z zz}tj|d|z | ddd| dz| d z | d <d| d z| dz | d<d| dz| dz | d<d| dz| dz | d <d| d d| ddzz} tjtj| d}|dk(r;tj| d d| dd z}|ddd|ddzz}|ddd|ddzz}n |dd}|dd}||z}tj|dtj|tj zkD}|d|d d}}||| |d zf|zz||| |dzf|zzz||z | |<t"|I||| d|||_y)N>rurwz `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`.FrrrGrr..r1Nr-rag@?rwg& .>)initialrH)NotImplementedErrorr)rrIrrr3rrbr4sizeslicer rRnonzeromaxinfr6r7r%)r8r#r$r%rvr2r'rKrLrMrerfr;mdmpmf1f2f12indx_indy_indr=s r(r7zAkima1DInterpolator.__init__s , ,% &9I&JK K*!Q52q$ ??1 ,CS/ ! +2e 771:?AGGAJ=4?:;BAB"Sb'!BAB%!CR&.B&B a AAcF!&&1*!''!"+56AU4[Oh!&&1*&==>Bggaa(2-AaG!9qt#AaD!9qt#AaD2J2&AbE2J2&AbEaeafn%A*+B!VVAabEAcrFN+VcBqrFl*WsRW},VWr'C**S4"&&rvvg*F#FFGCq63qr75Eg519,"6 77sGa u 45569>> 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 t|||\}}}}}t|}|j|||jdd|\} }| | ddk(rd}nd}|jdk(rt j |} n|j|jdgdg|jdz zz} t j|d| z } |dk(r"| ddvr d| df| d<| ddvr d| df| d<|dk(r | dd k(r| dd k(rt jd } t jd |jddz|j }d| d <d| d<|d| d<d|d|dzz| d<|d| d<d| d<d| d<d| dz|d<d| d| dz| d| dzzz|d<d| dz|d<|jd}t| |j|ddddj|j} nd|dk(rZ| ddk(rR| | z jdd| z jdz }t j||f|jddz} nt jd|f} t j|f|jddz|j }d|dd|ddzz| dddf<|dd| dddf<|dd| dddf<d| dd| ddz| dd| ddzzz|dd| \}}|dk(r| ddddf} d|d|dzz| d<|d| d<|dd}|d}|d}d|d|dzz}|d}|d}d| d| dz| d| dzzz|d<d| d| dz| d| dzzz|d<| ddddf}|dd}t j |}| |d<| |d<|jd}t!d||j|dddd}|j|j}|jd}t!d||j|dddd}|j|j}|d||dzz ||dzz |||dzz||dzzz }t j|f|jddz|j } |||zz| dd|| d<| d| d<n|d k(rN|d| d<|d|dz | d<|d|dz }| dd|zz| dz| dz| ddz| dzz|z |d<nY|ddk(rd| d<d| d<|d|d<n>|ddk(r6d|dz| d<|d| d<d|dz|ddzzd|d|dz zz|d<|d k(rN|d| d<|d|dz | d<|d|dz }| ddz| dzd|z| dz| dz| dzz|z |d<nY|ddk(rd| d<d| d<|d|d<n>|ddk(r6d|dz| d<|d| d<d|dz|ddzzd|d|dz zz|d<|jd}t!d| |j|dddd} | j|j} t"|I||| d|||_y) NrrperiodicTr-r not-a-knotrr1r)r1r1)r1r0rr)rr)rr)rrrr)rr)rrr.F) overwrite_a overwrite_b check_finiter`rarz) overwrite_abrrg)rr.)r.rar|rH)r)r5 _validate_bcrrrrbr3rr zerosr4rrsum broadcast_torr6r7r%) r8r#r$r%bc_typer2r'rKnbcsr9r:Abrr;bc_startbc_enda_m1_0a_m1_m2a_m1_m1a_m2_m1a_0_m1Acb1b2s1s2s_m1rWr=s r(r7zCubicSpline.__init__s")!Q52q$ F!!'1aggabk4@A  !u "( " 66Q; a A**bhhqk]aSAFFQJ-??@CGGAA&,E Ava566aMBqEa566aMBqE Av"Q%</BqE\4IHHV$HHTAGGABK/qww?$$Q%$r!ur!u}-$Q%$$$58|!CFU1X-Aq0AAB!58|!GGAJ!QYYq"-4T',..5gagg.>aBqEZ/S[%%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 A%fb"**Q2CRW27eMBBHH-B A%fb"**Q2CRW27eMBBHH-BrUVbe^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" A$VQ !R0@t15EKA !''*A AqqkB r*ct|tr8|dk(r.tj|d|dddst d|d||f}n(t |dk7r t d d|vr t d g}|D]=}t|tr}|d k(r'|j d tj|f@|d k(r'|j dtj|fl|dvr|j |t d|d |\}}|dvr t dtj|}|j|k7rt d|jd|dtj|jtjr|jtd}|j ||f@||fS#t$r}t d|d}~wwxYw)a(Validate 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) isinstancestrrallcloserr5appendr Exceptionrrrrrrr) rr$expected_deriv_shaper% validated_bcr deriv_order deriv_valuees r(rzCubicSpline._validate_bcs! 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!2B4F4FGu5A##[+$>?C! @FQ-!$<sF:: G GG)rrN)r?r@rArBr7rlrrCrDs@r(r r 9s'dLgRCCr*r ryr)rBtypingrnumpyr scipy.linalgrrr_polyintr__all__r)r r r r r r*r(rshA, 15 pUUpY#*Y#x;3||<,|<~T$Tr*