_MhlddlZddlZddlZddlZddgZGddZGddeZGddeZdS)NAAAFloaterHormannInterpolatorc<eZdZdZdZdZdZdZdZdZ dZ d S) _BarycentricRationalzABase class for Barycentric representation of a rational function.c Dtj|}tj|}|j||fi|tjtj|tj|z|jddd}||df}||}tj |d\}}||df}|jdd|_ |j ||fi|\|_ |_ |_d|_d|_d|_dS)Nraxis.T) return_index)npasarray_input_validation logical_andreduceisfiniteisnanreshapeshapeunique_shape_compute_weights_support_points_support_valuesweights_poles _residues_roots)selfxykwargszfto_keepunis `/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/scipy/interpolate/_bary_rational.py__init__z_BarycentricRational.__init__&s! JqMM JqMMq!..v....''k!nn"(1++ . 7 7 B G G(   gslO gJ140003 c3hKgabbk !D !!Q 1 1& 1 1 Ad2DL   c "|jdkrtd|jdkstd|j|jdkrtdt jt j|stddS)Nr z`x` must be 1-D.z`y` must be at least 1-D.rz3`x` be the same size as the first dimension of `y`.z`x` must be finite.)ndim ValueErrorsizerr allr)rr r!r"s r'rz&_BarycentricRational._input_validationAs 6Q;;/00 0v{{899 9 6QWQZ  RSS Svbk!nn%% 4233 3 4 4r)c tN)NotImplementedError)r#r$r"s r'rz%_BarycentricRational._compute_weightsNs!!r)ctj|}tj|}|j|jjddf}|jdtjf}tjdd5dtj ||j z }|||zz||zz }dddn #1swxYwYtj tj |rAtj||ztj|z |tj |<tjtj|d}|D]l}tj||s#tj |||j ks@||||j k||<mtj||j|jzS)zEvaluate the rational approximation at given values. Parameters ---------- z : array_like Input values. rr.ignore)invaliddivider N)r rravelrrrrnewaxiserrstatesubtractouterranyisinfsumnonzerorsqueezer) rr#zvsupport_valuesrCCriijjs r'__call__z_BarycentricRational.__call__Qs  JqMM Xa[[-55  ! ' *B /  ,sBJ/[( ; ; ; A AR[&&r4+?@@@Bg./2<@A A A A A A A A A A A A A A A A 6"(2,,   2!vg&>??!# 1AbhrllOZ $ $Q ' Q QBx2 Qrvbf8L.L'M'M Q'r"v1E'EFNNPP"z!QWt{2333s7CC C c|j|jj}tj|dz|jj}d|d<tj|tj|j|j}|j|dddf<d|dddf<tj |ddddf|jtj ||}|tj ||_|jS)zCompute the poles of the rational approximation. Returns ------- poles : array Poles of the AAA approximation, repeated according to their multiplicity but not in any specific order. Nr dtyperrr)rrr-r eyerI zeros_like result_typer fill_diagonalscipylinalgeigvalsr)rmBEpols r'polesz_BarycentricRational.poles|s ;  !Aq1uDL$6777AAdG ar~dl6:6J(L(LMMMA|AaeHAabb!eH  Qqrr122vY(< = = =,&&q!,,Cbk#../DK{r)c|jtjdd5dtj||jz |j|jzz}dtj||jz dz |jz}||z |_dddn #1swxYwY|jS)zCompute the residues of the poles of the approximation. Returns ------- residues : array Residues associated with the `poles` of the approximation Nr3r5r4r ) rr r8r9r:rVrrr)rNDdiffs r'residuesz_BarycentricRational.residuess > !Hh??? + + ))$**,,8LMMN(4<7**4::<<9MNNNQRRSl#"#U + + + + + + + + + + + + + + +~sBCC  C c|j|jj}tj|dz|jj}d|d<tj|tj|j|j|j }|j|jz|dddf<d|dddf<tj |ddddf|j tj ||}|tj||_|jS)zCompute the zeros of the rational approximation. Returns ------- zeros : array Zeros of the AAA approximation, repeated according to their multiplicity but not in any specific order. Nr rHrrJ)rrr-r rKrIrLrMrrrNrOrPrQr)rrRrSrTzers r'rootsz_BarycentricRational.rootss ;  !Aq1uDL$6777AAdG ar~dl6:6J6:6J(L(LMMMA|d&::AaeHAabb!eH  Qqrr122vY(< = = =,&&q!,,Cbk#../DK{r)N) __name__ __module__ __qualname____doc__r(rrrFrVr\r_r)r'rr$sKK6 4 4 4""")4)4)4V2*r)rcxeZdZdZdddddfd Z d fd Zed Zed Zd Z dd Z xZ S)ru % AAA real or complex rational approximation. As described in [1]_, the AAA algorithm is a greedy algorithm for approximation by rational functions on a real or complex set of points. The rational approximation is represented in a barycentric form from which the roots (zeros), poles, and residues can be computed. Parameters ---------- x : 1D array_like, shape (n,) 1-D array containing values of the independent variable. Values may be real or complex but must be finite. y : 1D array_like, shape (n,) Function values ``f(x)``. Infinite and NaN values of `values` and corresponding values of `points` will be discarded. rtol : float, optional Relative tolerance, defaults to ``eps**0.75``. If a small subset of the entries in `values` are much larger than the rest the default tolerance may be too loose. If the tolerance is too tight then the approximation may contain Froissart doublets or the algorithm may fail to converge entirely. max_terms : int, optional Maximum number of terms in the barycentric representation, defaults to ``100``. Must be greater than or equal to one. clean_up : bool, optional Automatic removal of Froissart doublets, defaults to ``True``. See notes for more details. clean_up_tol : float, optional Poles with residues less than this number times the geometric mean of `values` times the minimum distance to `points` are deemed spurious by the cleanup procedure, defaults to 1e-13. See notes for more details. Attributes ---------- support_points : array Support points of the approximation. These are a subset of the provided `x` at which the approximation strictly interpolates `y`. See notes for more details. support_values : array Value of the approximation at the `support_points`. weights : array Weights of the barycentric approximation. errors : array Error :math:`|f(z) - r(z)|_\infty` over `points` in the successive iterations of AAA. Warns ----- RuntimeWarning If `rtol` is not achieved in `max_terms` iterations. See Also -------- FloaterHormannInterpolator : Floater-Hormann barycentric rational interpolation. pade : Padé approximation. Notes ----- At iteration :math:`m` (at which point there are :math:`m` terms in the both the numerator and denominator of the approximation), the rational approximation in the AAA algorithm takes the barycentric form .. math:: r(z) = n(z)/d(z) = \frac{\sum_{j=1}^m\ w_j f_j / (z - z_j)}{\sum_{j=1}^m w_j / (z - z_j)}, where :math:`z_1,\dots,z_m` are real or complex support points selected from `x`, :math:`f_1,\dots,f_m` are the corresponding real or complex data values from `y`, and :math:`w_1,\dots,w_m` are real or complex weights. Each iteration of the algorithm has two parts: the greedy selection the next support point and the computation of the weights. The first part of each iteration is to select the next support point to be added :math:`z_{m+1}` from the remaining unselected `x`, such that the nonlinear residual :math:`|f(z_{m+1}) - n(z_{m+1})/d(z_{m+1})|` is maximised. The algorithm terminates when this maximum is less than ``rtol * np.linalg.norm(f, ord=np.inf)``. This means the interpolation property is only satisfied up to a tolerance, except at the support points where approximation exactly interpolates the supplied data. In the second part of each iteration, the weights :math:`w_j` are selected to solve the least-squares problem .. math:: \text{minimise}_{w_j}|fd - n| \quad \text{subject to} \quad \sum_{j=1}^{m+1} w_j = 1, over the unselected elements of `x`. One of the challenges with working with rational approximations is the presence of Froissart doublets, which are either poles with vanishingly small residues or pole-zero pairs that are close enough together to nearly cancel, see [2]_. The greedy nature of the AAA algorithm means Froissart doublets are rare. However, if `rtol` is set too tight then the approximation will stagnate and many Froissart doublets will appear. Froissart doublets can usually be removed by removing support points and then resolving the least squares problem. The support point :math:`z_j`, which is the closest support point to the pole :math:`a` with residue :math:`\alpha`, is removed if the following is satisfied .. math:: |\alpha| / |z_j - a| < \verb|clean_up_tol| \cdot \tilde{f}, where :math:`\tilde{f}` is the geometric mean of `support_values`. References ---------- .. [1] Y. Nakatsukasa, O. Sete, and L. N. Trefethen, "The AAA algorithm for rational approximation", SIAM J. Sci. Comp. 40 (2018), A1494-A1522. :doi:`10.1137/16M1106122` .. [2] J. Gilewicz and M. Pindor, Pade approximants and noise: rational functions, J. Comp. Appl. Math. 105 (1999), pp. 285-297. :doi:`10.1016/S0377-0427(02)00674-X` Examples -------- Here we reproduce a number of the numerical examples from [1]_ as a demonstration of the functionality offered by this method. >>> import numpy as np >>> import matplotlib.pyplot as plt >>> from scipy.interpolate import AAA >>> import warnings For the first example we approximate the gamma function on ``[-3.5, 4.5]`` by extrapolating from 100 samples in ``[-1.5, 1.5]``. >>> from scipy.special import gamma >>> sample_points = np.linspace(-1.5, 1.5, num=100) >>> r = AAA(sample_points, gamma(sample_points)) >>> z = np.linspace(-3.5, 4.5, num=1000) >>> fig, ax = plt.subplots() >>> ax.plot(z, gamma(z), label="Gamma") >>> ax.plot(sample_points, gamma(sample_points), label="Sample points") >>> ax.plot(z, r(z).real, '--', label="AAA approximation") >>> ax.set(xlabel="z", ylabel="r(z)", ylim=[-8, 8], xlim=[-3.5, 4.5]) >>> ax.legend() >>> plt.show() We can also view the poles of the rational approximation and their residues: >>> order = np.argsort(r.poles()) >>> r.poles()[order] array([-3.81591039e+00+0.j , -3.00269049e+00+0.j , -1.99999988e+00+0.j , -1.00000000e+00+0.j , 5.85842812e-17+0.j , 4.77485458e+00-3.06919376j, 4.77485458e+00+3.06919376j, 5.29095868e+00-0.97373072j, 5.29095868e+00+0.97373072j]) >>> r.residues()[order] array([ 0.03658074 +0.j , -0.16915426 -0.j , 0.49999915 +0.j , -1. +0.j , 1. +0.j , -0.81132013 -2.30193429j, -0.81132013 +2.30193429j, 0.87326839+10.70148546j, 0.87326839-10.70148546j]) For the second example, we call `AAA` with a spiral of 1000 points that wind 7.5 times around the origin in the complex plane. >>> z = np.exp(np.linspace(-0.5, 0.5 + 15j*np.pi, 1000)) >>> r = AAA(z, np.tan(np.pi*z/2), rtol=1e-13) We see that AAA takes 12 steps to converge with the following errors: >>> r.errors.size 12 >>> r.errors array([2.49261500e+01, 4.28045609e+01, 1.71346935e+01, 8.65055336e-02, 1.27106444e-02, 9.90889874e-04, 5.86910543e-05, 1.28735561e-06, 3.57007424e-08, 6.37007837e-10, 1.67103357e-11, 1.17112299e-13]) We can also plot the computed poles: >>> fig, ax = plt.subplots() >>> ax.plot(z.real, z.imag, '.', markersize=2, label="Sample points") >>> ax.plot(r.poles().real, r.poles().imag, '.', markersize=5, ... label="Computed poles") >>> ax.set(xlim=[-3.5, 3.5], ylim=[-3.5, 3.5], aspect="equal") >>> ax.legend() >>> plt.show() We now demonstrate the removal of Froissart doublets using the `clean_up` method using an example from [1]_. Here we approximate the function :math:`f(z)=\log(2 + z^4)/(1 + 16z^4)` by sampling it at 1000 roots of unity. The algorithm is run with ``rtol=0`` and ``clean_up=False`` to deliberately cause Froissart doublets to appear. >>> z = np.exp(1j*2*np.pi*np.linspace(0,1, num=1000)) >>> def f(z): ... return np.log(2 + z**4)/(1 - 16*z**4) >>> with warnings.catch_warnings(): # filter convergence warning due to rtol=0 ... warnings.simplefilter('ignore', RuntimeWarning) ... r = AAA(z, f(z), rtol=0, max_terms=50, clean_up=False) >>> mask = np.abs(r.residues()) < 1e-13 >>> fig, axs = plt.subplots(ncols=2) >>> axs[0].plot(r.poles().real[~mask], r.poles().imag[~mask], '.') >>> axs[0].plot(r.poles().real[mask], r.poles().imag[mask], 'r.') Now we call the `clean_up` method to remove Froissart doublets. >>> with warnings.catch_warnings(): ... warnings.simplefilter('ignore', RuntimeWarning) ... r.clean_up() 4 >>> mask = np.abs(r.residues()) < 1e-13 >>> axs[1].plot(r.poles().real[~mask], r.poles().imag[~mask], '.') >>> axs[1].plot(r.poles().real[mask], r.poles().imag[mask], 'r.') >>> plt.show() The left image shows the poles prior of the approximation ``clean_up=False`` with poles with residue less than ``10^-13`` in absolute value shown in red. The right image then shows the poles after the `clean_up` method has been called. NdTvIh%<=)rtol max_termsclean_up clean_up_tolct|||||r||dSdS)N)rhri)superr(rjrr r!rhrirjrk __class__s r'r(z AAA.__init__sN ADI>>>  ( MM, ' ' ' ' ' ( (r)ctj|}|dkrtd|jdkrtdt ||dS)Nr zB`max_terms` must be an integer value greater than or equal to one.z`y` must be 1-D.)operatorindexr,r+rmrrns r'rzAAA._input_validationsnN9-- q==-.. . 6Q;;/00 0 !!!Q'''''r)c|jSr0)rrs r'support_pointszAAA.support_points ##r)c|jSr0)rrts r'rAzAAA.support_valuesrvr)cD tj|}tj|tj}tj||d}|tj|jdzn|}|tj|tj z}tj ||} tj ||} tj ||f|} tj ||f|} tj || j j } tj tj||}t|D]U}tjtj||||z }|||| |<|||| |<tjdd5d||||z z | dd|f<dddn #1swxYwYd|tj|d |<tjd 5|| |z | dd|fz| dd|f<dddn #1swxYwY|}||dzkrt*j| |d|dzfdd \}}}|tj|k}||ddfd tj|z |}nft*j| |d|dzfd }|jd}|d tj|z }|d k}tjd 5| ddd|dzfdd|f||| d|dz|zz}| ddd|dzfdd|f||z}dddn #1swxYwYtj|tj|z}d||<||||<||z }tj||z tj }|| |<||krnW||dz kr t?j d|dtBd| d|dz} | d|dz} |d k}| d|dz|_"||_#||_$| || |||fS)NrH?g?)ordr3rXr Fr)r4) full_matrices check_finiter r|rzAAA failed to converge within z iterations.rY stacklevel)%r r-onesbool_rMfinfoepsrPnorminfemptyrealrIrepeatmeanrangeargmaxabsr8r>r=rOsvdminconjsqrtastype null_spacerr<rwarningswarnRuntimeWarningerrors_points_values)rr#r$rhriMmaskrIatolzjfjCArRrRrErows_sVmmwjnmi0rZDD_inf max_error i_non_zeros r'rzAAA._compute_weightss GAJJwq)))q!S)),0Lrx"D((dbinnQBFn333 Xiu - - - Xiu - - - Ha^5 1 1 1 Ha^5 1 1 1)16<888 Ibgajj! $ $y!!8 8 A26!D'AdG"34455BdGBKBqEdGBKBqEHh??? 0 0q1T72;/!!!Q$ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0-2DD!!!$R( )X... 0 0r!u9!!!Q$/!!!Q$ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 088::Dq1u}},**dGa!eGm$E+1a"&))^ffhhr111uo))q)11BGBFFHH4E4EEMMeTTL++AdGa!eGm,<5+QQWR[UUU^^bgbkk1qBX... 2 2aaa1q5jM!!!R%(BrFR!a%[_,DEaaa1q5jM!!!R%(2b61  2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 HQKK"(1++-EAeHxAeHAA q1u"&99I!F1ID  ! A   MR9RRR(Q 8 8 8 8!a%[ !a%[1W Wq1uWo   *~r*~r*~==s7;G##G' *G' & II I 3APP #P c tjtj|j}tjtjtj| |j d}tj dd5tj tj| |z ||zk}dddn #1swxYwY|dj}|dkr|Stj|dt"d tjtjtj|j| |d}tj|j||_tj|j||_tjtj|j |jd}|j|}|j |} |jj} dtj| |jz } |ddtjf| z| |jzz } tj| d \} } }tj|| dz ddf|_d|_d|_d|_ |S) aAutomatic removal of Froissart doublets. Parameters ---------- cleanup_tol : float, optional Poles with residues less than this number times the geometric mean of `values` times the minimum distance to `points` are deemed spurious by the cleanup procedure, defaults to 1e-13. Returns ------- int Number of Froissart doublets detected r r r3rXNrz Froissart doublets detected.rYr~Fr})!rOstatsgmeanr rrrr9r:rVrr8r>r\r-rrrargminrdeleterrr not_equalr7rPrrrrrr)r cleanup_tolgeom_mean_abs_f Z_distancesrDniclosest_spt_pointrr$r#rRrrrrs r'rjz AAA.clean_ups  +++BF4<,@,@AAf F2;$$TZZ\\4<@@ A A   [( ; ; ;  t}}''+5 o8UUB                UZ 77I :::N#$ & & & &I F2;$$T%94::<<;KLL M MTU    "y)=?PQQ!y)=?PQQ~$$ L  t|T-A B B%   L  L   %  !!!T%9:: : aaam q 1t';#; ;,""15"991awqQqqqz**    s*AC99C=C=)NrfTrg)rg) r`rarbrcr(rpropertyrurArrj __classcell__ros@r'rrsVVn&*S4#(((((((JN', ( ( ( ( ( ($$X$$$X$X>X>X>tCCCCCCCCr)c8eZdZdZddfd ZfdZdZxZS)ru Floater-Hormann barycentric rational interpolation. As described in [1]_, the method of Floater and Hormann computes weights for a Barycentric rational interpolant with no poles on the real axis. Parameters ---------- x : 1D array_like, shape (n,) 1-D array containing values of the independent variable. Values may be real or complex but must be finite. y : array_like, shape (n, ...) Array containing values of the dependent variable. Infinite and NaN values of `values` and corresponding values of `x` will be discarded. d : int, optional Blends ``n - d`` degree `d` polynomials together. For ``d = n - 1`` it is equivalent to polynomial interpolation. Must satisfy ``0 <= d < n``, defaults to 3. Attributes ---------- weights : array Weights of the barycentric approximation. See Also -------- AAA : Barycentric rational approximation of real and complex functions. pade : Padé approximation. Notes ----- The Floater-Hormann interpolant is a rational function that interpolates the data with approximation order :math:`O(h^{d+1})`. The rational function blends ``n - d`` polynomials of degree `d` together to produce a rational interpolant that contains no poles on the real axis, unlike `AAA`. The interpolant is given by .. math:: r(x) = \frac{\sum_{i=0}^{n-d} \lambda_i(x) p_i(x)} {\sum_{i=0}^{n-d} \lambda_i(x)}, where :math:`p_i(x)` is an interpolating polynomials of at most degree `d` through the points :math:`(x_i,y_i),\dots,(x_{i+d},y_{i+d}), and :math:`\lambda_i(z)` are blending functions defined by .. math:: \lambda_i(x) = \frac{(-1)^i}{(x - x_i)\cdots(x - x_{i+d})}. When ``d = n - 1`` this reduces to polynomial interpolation. Due to its stability following barycentric representation of the above equation is used instead for computation .. math:: r(z) = \frac{\sum_{k=1}^m\ w_k f_k / (x - x_k)}{\sum_{k=1}^m w_k / (x - x_k)}, where the weights :math:`w_j` are computed as .. math:: w_k &= (-1)^{k - d} \sum_{i \in J_k} \prod_{j = i, j \neq k}^{i + d} 1/|x_k - x_j|, \\ J_k &= \{ i \in I: k - d \leq i \leq k\},\\ I &= \{0, 1, \dots, n - d\}. References ---------- .. [1] M.S. Floater and K. Hormann, "Barycentric rational interpolation with no poles and high rates of approximation", Numer. Math. 107, 315 (2007). :doi:`10.1007/s00211-007-0093-y` Examples -------- Here we compare the method against polynomial interpolation for an example where the polynomial interpolation fails due to Runge's phenomenon. >>> import numpy as np >>> from scipy.interpolate import (FloaterHormannInterpolator, ... BarycentricInterpolator) >>> def f(z): ... return 1/(1 + z**2) >>> z = np.linspace(-5, 5, num=15) >>> r = FloaterHormannInterpolator(z, f(z)) >>> p = BarycentricInterpolator(z, f(z)) >>> zz = np.linspace(-5, 5, num=1000) >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots() >>> ax.plot(zz, r(zz), label="Floater=Hormann") >>> ax.plot(zz, p(zz), label="Polynomial") >>> ax.legend() >>> plt.show() dcPt|||dS)Nr)rmr()rpointsvaluesrros r'r(z#FloaterHormannInterpolator.__init__s( 1-----r)ctj|}d|cxkrt|ksntdt ||dS)Nrz`d` must satisfy 0 <= d < n)rqrrlenr,rmr)rr r!rros r'rz,FloaterHormannInterpolator._input_validations^ N1  QQ:;; ; !!!Q'''''r)ctj|tj|d}|j}t |D]}t t ||z dt |dz||z D]f}||xxdtjtjtj ||||||zdzz ||z z z cc<g|dtj ||z zz}|||fS)NryrHrr g) r rLrMr-rmaxrprodrrarange)rr#r$rwnkis r'rz+FloaterHormannInterpolator._compute_weightss M!2>!S#9#9 : : : Fq U UA3qsA;;AaC1 66 U U!"'"&1Q4!AA M:J3JAPQE)R)R"S"STTTT U cRYq\\A% &&!Qwr))r`rarbrcr(rrrrs@r'rrWs|__@-........(((((       r)) rrqnumpyr rO__all__rrrrdr)r'rs4  . /]]]]]]]]@PPPPP PPPf ttttt!5tttttr)