^jzddlZddlZddlZddlZddlZddlmZmZmZddl m Z m Z m Z m Z mZmZddlZddlZddl mZddlmZmZddlmZddlmZmZdd lmZdd lmZdd lm Z gd Z!Gd de"Z#dZ$dZ%dZ&dZ'e(edjSedjSZ*dZ+dZ, d=dZ-e+e- d>dZ.GddZ/GddZ0GddZ1d Z2Gd!d"e0Z3Gd#d$Z4ed%jSe*d&<Gd'd(e3Z5Gd)d*e5Z6Gd+d,e3Z7Gd-d.e3Z8Gd/d0e3Z9Gd1d2e3Z:Gd3d4e0Z;d5Z<ee   r'ct|}tj|jtjst|tj S|S)z:Return `x` as an array, of either floats or complex floatsdtype)rr+ issubdtyper3inexactfloat64r.s r( _as_inexactr7,s7 A =="** -q ++ Hr'ctj|tj|}t|d|j}||S)z;Return ndarray `x` as same array subclass and shape as `x0`__array_wrap__)r+reshapeshapegetattrr9)r/x0wraps r( _array_liker?4s8 1bhhrl#A 2')9)9 :D 7Nr'ctj|js#tjtjSt |Sr*)r+isfiniteallarrayinfr)vs r( _safe_normrF;s2 ;;q>   xx 7Nr'z F : function(x) -> f Function whose root to find; should take and return an array-like object. xin : array_like Initial guess for the solution a iter : int, optional Number of iterations to make. If omitted (default), make as many as required to meet tolerances. verbose : bool, optional Print status to stdout on every iteration. maxiter : int, optional Maximum number of iterations to make. If more are needed to meet convergence, `NoConvergence` is raised. f_tol : float, optional Absolute tolerance (in max-norm) for the residual. If omitted, default is 6e-6. f_rtol : float, optional Relative tolerance for the residual. If omitted, not used. x_tol : float, optional Absolute minimum step size, as determined from the Jacobian approximation. If the step size is smaller than this, optimization is terminated as successful. If omitted, not used. x_rtol : float, optional Relative minimum step size. If omitted, not used. tol_norm : function(vector) -> scalar, optional Norm to use in convergence check. Default is the maximum norm. line_search : {None, 'armijo' (default), 'wolfe'}, optional Which type of a line search to use to determine the step size in the direction given by the Jacobian approximation. Defaults to 'armijo'. callback : function, optional Optional callback function. It is called on every iteration as ``callback(x, f)`` where `x` is the current solution and `f` the corresponding residual. Returns ------- sol : ndarray An array (of similar array type as `x0`) containing the final solution. Raises ------ NoConvergence When a solution was not found. ) params_basic params_extracN|jr|jtz|_yyr*)r% _doc_parts)objs r(_set_docrLys {{kkJ. r'c|jr3tj}d|d<d|d<|j|z|_yy)NrGrH)r%rJcopy)rK doc_partss r(_set_doc_classrQ~s> {{OO% $& .!$& .!kkI- r'c | tn| } t|||| || }tfd}j}t j |tj }||}t|}t|}|j|j|||||dz}nd|jdzz}| durd} n| durd} | d vr td d }d }d }d}t|D]H}|j|||}|rnIt|||z}|j!|| }t|dk(r td| rt#||||| \}}}}nd}||z}||}t|}|j%|j|| r | ||||dzz|dzz }||dzz|kr t||}nt|t'|||dzz}|}|st(j*j-|d| |dd|ddt(j*j/K|rt1t3|d}| r)|j4|||dk(ddd|d}t3||fSt3|S)a Find a root of a function, in a way suitable for large-scale problems. Parameters ---------- %(params_basic)s jacobian : Jacobian A Jacobian approximation: `Jacobian` object or something that `asjacobian` can transform to one. Alternatively, a string specifying which of the builtin Jacobian approximations to use: krylov, broyden1, broyden2, anderson diagbroyden, linearmixing, excitingmixing %(params_extra)s full_output : bool If true, returns a dictionary `info` containing convergence information. raise_exception : bool If True, a `NoConvergence` exception is raise if no solution is found. See Also -------- asjacobian, Jacobian Notes ----- This algorithm implements the inexact Newton method, with backtracking or full line searches. Several Jacobian approximations are available, including Krylov and Quasi-Newton methods. References ---------- .. [KIM] C. T. Kelley, "Iterative Methods for Linear and Nonlinear Equations". Society for Industrial and Applied Mathematics. (1995) https://archive.siam.org/books/kelley/fr16/ N)f_tolf_rtolx_tolx_rtoliterrcVtt|jSr*)r7r?flatten)zFr=s r(funcznonlin_solve..funcs#1[B/0199;;r'rdTarmijoF)Nr^wolfezInvalid line searchg?gH.?g?gMbP?)tolrz[Jacobian inversion yielded zero vector. This indicates a bug in the Jacobian approximation.?z : |F(x)| = gz; step  z0A solution was found at the specified tolerance.z:The maximum number of iterations allowed has been reached.)rrb)nitfunstatussuccessmessage)r0TerminationConditionr7rYr+ full_likerDr asjacobiansetuprOsize ValueErrorrangecheckminr_nonlin_line_searchupdater-sysstdoutwriteflushr r? iteration) r[r=jacobianrWverbosemaxiterrSrTrUrVtol_norm line_searchcallback full_outputraise_exception conditionr\r/dxFxFx_normgammaeta_max eta_tresholdetanrgr`s Fx_norm_neweta_Ainfos `` r( nonlin_solversZ#*wH$5+0*.X?I RB< A a B aB2hG(#H NN1668R&  QhG166!8nGd   33.// EGL C 7^.Q+  #s7{#nnRSn) ) 8q=./ / $7aR8C%E !Aq"kABAaBr(K"%  QO Q&!3 36>L (gu%Cgs5%Q,78C  JJ  s,x|A.>gaU"M N JJ   S.V  Ar 23 3F ** !Q; , 3% & 1b!4''1b!!r'cl dg|gt|dzgttz d fd  fd}|dk(rt |dd|\}} } n|dk(rt dd | \}} d }|zz|dk(rd}n}t|} ||| fS) Nrrbc| dk(rdS |zz}|}t|dz}|r| d<|d<|d<|S)Nrrb)rF) rstorextrEprr\tmp_Fxtmp_phitmp_sr/s r(phiz _nonlin_line_search..phi"s_ a=1:  2X H qM1  E!HGAJF1Ir'c^t|zdzz}||zd|z |z S)NrF)r)abs)rdsrrdiffs_norms r(derphiz#_nonlin_line_search..derphi.s9!fvo!U *AbD&Q/255r'r_{Gz?)xtolaminr^)rra)T)rrr)r\r/rr search_typersminrrphi1phi0rrrrrrs`` ` ` @@@@@r(rsrss CETFBx{mG !WtBx F  6g,S&'!*26TC 4  &sGAJ ,024 y  AbDAE!H} AY !W2hG aW r'c*eZdZdZdddddefdZdZy)rjz Termination condition for an iteration. It is terminated if - |F| < f_rtol*|F_0|, AND - |F| < f_tol AND - |dx| < x_rtol*|x|, AND - |dx| < x_tol NcD|0tjtjjdz}|tj}|tj}|tj}||_||_||_||_||_ ||_ d|_ d|_ y)NgUUUUUU?r) r+finfor6epsrDrUrVrSrTrrWf0_normry)selfrSrTrUrVrWrs r(__init__zTerminationCondition.__init__Us =HHRZZ(,,6E >VVF =FFE >VVF       r'c|xjdz c_|j|}|j|}|j|}|j||_|dk(ry|jd|j|jkDzSt ||j kxr||j z |jkxr#||jkxr||jz |kS)Nrrrb) ryrrrWintrSrTrUrV)rfr/rf_normx_normdx_norms r(rqzTerminationCondition.checkms !11))B- << !DL Q; 99 23 3Fdjj(;t{{*dll:;4::-:#DKK/69< .__array__s'$$'A%%IJJ||~%r'NN)itemsrosetattrhasattr)rkwnamesnamevaluers r(rzJacobian.__init__si888: .KD%5  #>  8>> 1 KK1  2r'Nr) r"r#r$r% classmethodrr__annotations__rrrrtrmr&r'r(rrs3#L&1%>{>& %" r'rcReZdZUdZeeZeed<dZe dZ e dZ y)ra A simple wrapper that inverts the Jacobian using the `solve` method. .. legacy:: class See the newer, more consistent interfaces in :mod:`scipy.optimize`. Parameters ---------- jacobian : Jacobian The Jacobian to invert. Attributes ---------- shape Matrix dimensions (M, N) dtype Data type of the matrix. rc||_|j|_|j|_t |dr|j |_t |dr|j |_yy)Nrmr)rzrrrtrrmrr)rrzs r(rzInverseJacobian.__init__sN  nn oo 8W %!DJ 8X &#??DL 'r'c.|jjSr*)rzr;rs r(r;zInverseJacobian.shape}}"""r'c.|jjSr*)rzr3rs r(r3zInverseJacobian.dtyperr'N) r"r#r$r%rrrrrpropertyr;r3r&r'r(rrsF,&1%>{>+####r'rc 0tjjjt t rSt jrtt rSt tjrjdkDr tdtjtjjdjdk7r tdt fdfddfd dfd j j Stjj#r_jdjdk7r td t fd fd dfd dfd j j St%dr{t%drot%drct t'dt'dj(t'dt'dt'dj jSt+rGfddt }|St t,r6t/t0t2t4t6t8t:t<St?d)zE Convert given object to one suitable for use as a Jacobian. rbzarray must have rank <= 2rrzarray must be squarect|Sr*)rrEJs r(zasjacobian..s Qr'cLtjj|Sr*)rconjTrs r(rzasjacobian..s#affhjj!*<r'ct|Sr*)rrEr`rs r(rzasjacobian..s uQ{r'cLtjj|Sr*)rrrrs r(rzasjacobian..saffhjj!0Dr')rrrrr3r;zmatrix must be squarec|zSr*r&rs r(rzasjacobian..s Qr'c>jj|zSr*rrrs r(rzasjacobian..s!&&(**q.r'c|Sr*r&rEr`rspsolves r(rzasjacobian..s wq!}r'cFjj|Sr*rrs r(rzasjacobian..s A0Fr'r;r3rrrrrtrm)rrrrrtrmr3r;cDeZdZdZdfd ZfdZdfd ZfdZy)asjacobian..Jacc||_yr*r.rs r(rtzasjacobian..Jac.update's r'c|j}t|tjr t ||St j j|r ||StdNzUnknown matrix type) r/ isinstancer+ndarrayrscipysparseissparserorrEr`mrrs r(rzasjacobian..Jac.solve*sTdffIa, A;&\\**1-"1a=($%:;;r'c|j}t|tjr t ||St j j|r||zStdr) r/rr+rrrrrrorrErrs r(rzasjacobian..Jac.matvec3sQdffIa,q!9$\\**1-q5L$%:;;r'c:|j}t|tjr$t |j j |Stjj|r!|j j |Stdr) r/rr+rrrrrrrrors r(rzasjacobian..Jac.rsolve<sjdffIa, Q//\\**1-"1668::q11$%:;;r'c2|j}t|tjr$t |j j |Stjj|r|j j |zStdr) r/rr+rrrrrrrrors r(rzasjacobian..Jac.rmatvecEsgdffIa,qvvxzz1--\\**1-668::>)$%:;;r'Nr)r"r#r$rtrrrr)rrsr(Jacr&s  < < < >r'c:eZdZUeeZeed<dZdZdZ y)GenericBroydenrctj||||||_||_t |drC|j 6t |}|r!dtt |dz|z |_yd|_yyy)Nalpha?rra)rrmlast_flast_xrrrr-)rr=f0r\normf0s r(rmzGenericBroyden.setupbsntRT*  4 !djj&8"XF T"Xq!11F:   '9 !r'ctr*rrr/rrdfrdf_norms r(_updatezGenericBroyden._updateprr'c ||jz }||jz }|j||||t|t|||_||_yr*)rrrr)rr/rrrs r(rtzGenericBroyden.updatessH _ _ Q2r48T"X6  r'N) r"r#r$rrrrrmrrtr&r'r(rr^s!%0%>{> !"r'rceZdZUdZeeZeed<dZe dZ e dZ dZ dZ ddZdd Zd Zdd Zd ZdZdZddZy ) LowRankMatrixz A matrix represented as .. math:: \alpha I + \sum_{n=0}^{n=M} c_n d_n^\dagger However, if the rank of the matrix reaches the dimension of the vectors, full matrix representation will be used thereon. rcX||_g|_g|_||_||_d|_yr*)rcsrrr3 collapsed)rrrr3s r(rzLowRankMatrix.__init__s,  r'ctgd|dd|gz\}}}||z}t||D]#\}} || |} ||||j| }%|S)N)axpyscaldotcr)r ziprn) rErr"rr%r&r'wcdas r(_matveczLowRankMatrix._matvecsm)*B*,Ra&A3,8dD AIBK &DAqQ AQ1661%A &r'c Jt|dk(r||z Stddg|dd|gz\}}|d}|tjt||jz}t |D].\}} t |D]\} } ||| fxx|| | z cc<0tj t||j} t |D]\} } || || | <| |z} t|| } ||z } t|| D]\} }|| | | j| } | S)Evaluate w = M^-1 vrr%r'Nrr2) lenr r+identityr3 enumeratezerosrr(rn)rErr"rr%r'c0Air+jr*qr)qcs r(_solvezLowRankMatrix._solves: r7a<U7N$VV$4b!fslC d U BKKBrxx8 8bM %DAq!"  %1!A#$q!*$ % % HHSWBHH -bM DAq1:AaD  U  !QK eGQZ (EArQ166B3'A (r'c|j tj|j|Stj ||j |j |jS)zEvaluate w = M v)r#r+rr r-rr"rrrEs r(rzLowRankMatrix.matvecsD >> %66$..!, ,$$Q DGGTWWEEr'c|j8tj|jjj |St j |tj|j|j|jS)zEvaluate w = M^H v) r#r+rrrr r-rrr"r<s r(rzLowRankMatrix.rmatvecs\ >> %66$..**//115 5$$Q (;TWWdggNNr'c|jt|j|Stj||j|j |j S)r/)r#rr r:rr"rrs r(rzLowRankMatrix.solves@ >> %+ +##Atzz477DGGDDr'c|j.t|jjj|Stj |t j|j|j|jS)zEvaluate w = M^-H v) r#rrrr r:r+rrr"rs r(rzLowRankMatrix.rsolvesX >> %))..0!4 4##Arwwtzz':DGGTWWMMr'cX|j5|xj|dddf|dddfjzz c_y|jj||jj|t |j|j kDr|jyyr*)r#rr"appendrr0rncollapse)rr*r+s r(rAzLowRankMatrix.appends{ >> % NNa$i!DF)..*:: :N  q q tww~O%& (   MM99=nN%& ( >> %>> ! ZZ DFF$**= =) -DAq !AdF)Ad1fINN,, ,B - r'cntj|t|_d|_d|_d|_y)z0Collapse the low-rank matrix to a full-rank one.)rON)r+rCr r#r"rrrs r(rBzLowRankMatrix.collapses)$^< r'c|jy|dkDsJt|j|kDr|jdd=|jdd=yy)zH Reduce the rank of the matrix by dropping all vectors. Nrr#r0r"rrranks r(restart_reducezLowRankMatrix.restart_reducesG >> % axx tww<$    r'c|jy|dkDsJt|j|kDr4|jd=|jd=t|j|kDr3yy)zK Reduce the rank of the matrix by dropping oldest vectors. NrrKrLs r( simple_reducezLowRankMatrix.simple_reducesT >> % axx$''lT!  $''lT!r'c|jy|}||}n|dz }|jr"t|t|jd}t dt||dz }t|j}||kryt j |jj}t j |jj}t|d\}}t||jj}t|d\} } } t|t| }t|| jj}t|D]J} |dd| fj|j| <|dd| fj|j| <L|j|d=|j|d=y) a Reduce the rank of the matrix by retaining some SVD components. This corresponds to the "Broyden Rank Reduction Inverse" algorithm described in [1]_. Note that the SVD decomposition can be done by solving only a problem whose size is the effective rank of this matrix, which is viable even for large problems. Parameters ---------- max_rank : int Maximum rank of this matrix after reduction. to_retain : int, optional Number of SVD components to retain when reduction is done (ie. rank > max_rank). Default is ``max_rank - 2``. References ---------- .. [1] B.A. van der Rotten, PhD thesis, "A limited memory Broyden method to solve high-dimensional systems of nonlinear equations". Mathematisch Instituut, Universiteit Leiden, The Netherlands (2003). https://web.archive.org/web/20161022015821/http://www.math.leidenuniv.nl/scripties/Rotten.pdf Nrbrreconomic)modeF) full_matrices)r#r"rrr0r-r+rCrrr rrr rrprO) rmax_rank to_retainrr8rCDRUSWHks r( svd_reducezLowRankMatrix.svd_reducesh: >> %    AAA 77As4771:'A 3q!A#;  L q5  HHTWW    HHTWW   !*%1 13388: q.1b 3r7O 24499; q 'A1Q3DGGAJ1Q3DGGAJ ' GGABK GGABKr'rrr*)r"r#r$r%rrrrr staticmethodr-r:rrrrrArrBrNrPr^r&r'r(r r {s|&1%>{>6F O E N "  ?r'r a alpha : float, optional Initial guess for the Jacobian is ``(-1/alpha)``. reduction_method : str or tuple, optional Method used in ensuring that the rank of the Broyden matrix stays low. Can either be a string giving the name of the method, or a tuple of the form ``(method, param1, param2, ...)`` that gives the name of the method and values for additional parameters. Methods available: - ``restart``: drop all matrix columns. Has no extra parameters. - ``simple``: drop oldest matrix column. Has no extra parameters. - ``svd``: keep only the most significant SVD components. Takes an extra parameter, ``to_retain``, which determines the number of SVD components to retain when rank reduction is done. Default is ``max_rank - 2``. max_rank : int, optional Maximum rank for the Broyden matrix. Default is infinity (i.e., no rank reduction). broyden_paramscFeZdZdZd dZdZdZd dZdZd dZ d Z d Z y) ral Find a root of a function, using Broyden's first Jacobian approximation. This method is also known as "Broyden's good method". Parameters ---------- %(params_basic)s %(broyden_params)s %(params_extra)s See Also -------- root : Interface to root finding algorithms for multivariate functions. See ``method='broyden1'`` in particular. Notes ----- This algorithm implements the inverse Jacobian Quasi-Newton update .. math:: H_+ = H + (dx - H df) dx^\dagger H / ( dx^\dagger H df) which corresponds to Broyden's first Jacobian update .. math:: J_+ = J + (df - J dx) dx^\dagger / dx^\dagger dx References ---------- .. [1] B.A. van der Rotten, PhD thesis, "A limited memory Broyden method to solve high-dimensional systems of nonlinear equations". Mathematisch Instituut, Universiteit Leiden, The Netherlands (2003). https://math.leidenuniv.nl/scripties/Rotten.pdf Examples -------- The following functions define a system of nonlinear equations >>> def fun(x): ... return [x[0] + 0.5 * (x[0] - x[1])**3 - 1.0, ... 0.5 * (x[1] - x[0])**3 + x[1]] A solution can be obtained as follows. >>> from scipy import optimize >>> sol = optimize.broyden1(fun, [0, 0]) >>> sol array([0.84116396, 0.15883641]) NcNtj|_d_|tj }|_t|trdn |dd|d}|dz fz|dk(r fd_ y|dk(r fd_ y|dk(r fd _ ytd |d ) Nr&rrr c6jjSr*)rHr^ reduce_paramsrsr(rz'BroydenFirst.__init__..s#5477#5#5}#Er'simplec6jjSr*)rHrPrdsr(rz'BroydenFirst.__init__..s#8477#8#8-#Hr'restartc6jjSr*)rHrNrdsr(rz'BroydenFirst.__init__..s#9477#9#9=#Ir'zUnknown rank reduction method '') rrrrHr+rDrUrr_reducero)rrreduction_methodrUres` @r(rzBroydenFirst.__init__s%   vvH  & ,M,QR0M/2 !A-7 u $EDL  )HDL  *IDL>?O>PPQRS Sr'ctj||||t|j |jd|j |_y)Nr)rrmr rr;r3rHrs r(rmzBroydenFirst.setups8T1a. TZZ]DJJGr'c,t|jSr*)rrHrs r(rzBroydenFirst.todenses477|r'c|jj|}tj|j sL|j |j |j|j|jj|S|Sr*) rHrr+rArBrmrrr\)rrr`rs r(rzBroydenFirst.solves\ GGNN1 {{1~!!# JJt{{DKK ;77>>!$ $r'c8|jj|Sr*)rHrrrs r(rzBroydenFirst.matvecsww}}Qr'c8|jj|Sr*)rHrrrr`s r(rzBroydenFirst.rsolveswwq!!r'c8|jj|Sr*)rHrrrs r(rzBroydenFirst.rmatvecsww~~a  r'c|j|jj|}||jj|z }|t ||z } |jj || yr*)rkrHrrrrA rr/rrrrrrEr*r+s r(rzBroydenFirst._updatesU  GGOOB  # # R O q!r')NrhNr) r"r#r$r%rrmrrrrrrr&r'r(rrbs22hT2H "!r'rceZdZdZdZy)r aK Find a root of a function, using Broyden's second Jacobian approximation. This method is also known as "Broyden's bad method". Parameters ---------- %(params_basic)s %(broyden_params)s %(params_extra)s See Also -------- root : Interface to root finding algorithms for multivariate functions. See ``method='broyden2'`` in particular. Notes ----- This algorithm implements the inverse Jacobian Quasi-Newton update .. math:: H_+ = H + (dx - H df) df^\dagger / ( df^\dagger df) corresponding to Broyden's second method. References ---------- .. [1] B.A. van der Rotten, PhD thesis, "A limited memory Broyden method to solve high-dimensional systems of nonlinear equations". Mathematisch Instituut, Universiteit Leiden, The Netherlands (2003). https://web.archive.org/web/20161022015821/http://www.math.leidenuniv.nl/scripties/Rotten.pdf Examples -------- The following functions define a system of nonlinear equations >>> def fun(x): ... return [x[0] + 0.5 * (x[0] - x[1])**3 - 1.0, ... 0.5 * (x[1] - x[0])**3 + x[1]] A solution can be obtained as follows. >>> from scipy import optimize >>> sol = optimize.broyden2(fun, [0, 0]) >>> sol array([0.84116365, 0.15883529]) c|j|}||jj|z }||dzz } |jj|| yNrb)rkrHrrArws r(rzBroydenSecond._updatesF   # #  N q!r'N)r"r#r$r%rr&r'r(r r s 0dr'r c,eZdZdZddZddZdZdZy) r a Find a root of a function, using (extended) Anderson mixing. The Jacobian is formed by for a 'best' solution in the space spanned by last `M` vectors. As a result, only a MxM matrix inversions and MxN multiplications are required. [Ey]_ Parameters ---------- %(params_basic)s alpha : float, optional Initial guess for the Jacobian is (-1/alpha). M : float, optional Number of previous vectors to retain. Defaults to 5. w0 : float, optional Regularization parameter for numerical stability. Compared to unity, good values of the order of 0.01. %(params_extra)s See Also -------- root : Interface to root finding algorithms for multivariate functions. See ``method='anderson'`` in particular. References ---------- .. [Ey] V. Eyert, J. Comp. Phys., 124, 271 (1996). Examples -------- The following functions define a system of nonlinear equations >>> def fun(x): ... return [x[0] + 0.5 * (x[0] - x[1])**3 - 1.0, ... 0.5 * (x[1] - x[0])**3 + x[1]] A solution can be obtained as follows. >>> from scipy import optimize >>> sol = optimize.anderson(fun, [0, 0]) >>> sol array([0.84116588, 0.15883789]) Nctj|||_||_g|_g|_d|_||_yr*)rrrMrrrw0)rrr~r}s r(rzAnderson.__init__Ys:%  r'c|j |z}t|j}|dk(r|Stj||j }t |D]}t|j||||<  t|j|}t |D]7}||||j||j|j|zzzz }9|S#t$r#|jdd=|jdd=|cYSwxYwNrr2) rr0rr+emptyr3rprrrr,r ) rrr`rrdf_fr]rrs r(rzAnderson.solvebsjj[] L 6Ixx)q *A4771:q)DG * $&&$'Eq @A %(DGGAJDGGAJ)>>? ?B @    I  s;C)DDc B| |jz }t|j}|dk(r|Stj||j }t |D]}t|j||||< tj||f|j }t |D]}t |D]}t|j||j||||f<||k(s4|jdk7sD|||fxxt|j||j||jdzz|jzzcc<t||} t |D]7} || | |j| |j| |jz zzz }9|S)Nrr2rb) rr0rr+rr3rprrr~r) rrrrrr]br6r7rrs r(rzAnderson.matvecysyR ] L 6Ixx)q *A4771:q)DG * HHaV177 +q QA1X Qdggaj$''!*5!A#6dgglacFd4771:twwqz:477A:EdjjPPF Q Q aq @A %(DGGAJDJJ)>>? ?B @ r'c8|jdk(ry|jj||jj|t |j|jkDrY|jj d|jj dt |j|jkDrYt |j}t j||f|j}t|D][} t| |D]J} | | k(r|jdz} nd} d| zt|j| |j| z|| | f<L]|t j|djjz }||_y)Nrr2rbr)r}rrArr0popr+r3r3rpr~rtriurrr,) rr/rrrrrrr,r6r7wds r(rzAnderson._updates7 66Q;  r r$''lTVV# GGKKN GGKKN$''lTVV# L HHaV177 +q =A1a[ =6!BBB$TWWQZ <<!A#  = = RWWQ]__ ! ! ##r')Nrr)r"r#r$r%rrrrr&r'r(r r s+L..r'r cFeZdZdZd dZdZd dZdZd dZdZ d Z d Z y) r a, Find a root of a function, using diagonal Broyden Jacobian approximation. The Jacobian approximation is derived from previous iterations, by retaining only the diagonal of Broyden matrices. .. warning:: This algorithm may be useful for specific problems, but whether it will work may depend strongly on the problem. Parameters ---------- %(params_basic)s alpha : float, optional Initial guess for the Jacobian is (-1/alpha). %(params_extra)s See Also -------- root : Interface to root finding algorithms for multivariate functions. See ``method='diagbroyden'`` in particular. Examples -------- The following functions define a system of nonlinear equations >>> def fun(x): ... return [x[0] + 0.5 * (x[0] - x[1])**3 - 1.0, ... 0.5 * (x[1] - x[0])**3 + x[1]] A solution can be obtained as follows. >>> from scipy import optimize >>> sol = optimize.diagbroyden(fun, [0, 0]) >>> sol array([0.84116403, 0.15883384]) Nc<tj|||_yr*rrrrrs r(rzDiagBroyden.__init__% r'ctj||||tj|jdfd|j z |j |_y)Nrrr2)rrmr+fullr;rr3r+rs r(rmzDiagBroyden.setupsAT1a.$**Q-)1tzz>Lr'c"| |jz Sr*r+rts r(rzDiagBroyden.solverDFF{r'c"| |jzSr*rrrs r(rzDiagBroyden.matvecrr'c>| |jjz Sr*r+rrts r(rzDiagBroyden.rsolverDFFKKM!!r'c>| |jjzSr*rrrs r(rzDiagBroyden.rmatvecrr'cBtj|j Sr*)r+diagr+rs r(rzDiagBroyden.todenseswwwr'c`|xj||j|zz|z|dzz zc_yrzrrs r(rzDiagBroyden._updates* 2r >2%gqj00r'r*r r"r#r$r%rrmrrrrrrr&r'r(r r s1&PM"" 1r'r c@eZdZdZd dZd dZdZd dZdZdZ d Z y) r a Find a root of a function, using a scalar Jacobian approximation. .. warning:: This algorithm may be useful for specific problems, but whether it will work may depend strongly on the problem. Parameters ---------- %(params_basic)s alpha : float, optional The Jacobian approximation is (-1/alpha). %(params_extra)s See Also -------- root : Interface to root finding algorithms for multivariate functions. See ``method='linearmixing'`` in particular. Nc<tj|||_yr*rrs r(rzLinearMixing.__init__ rr'c"| |jzSr*rrts r(rzLinearMixing.solve r$**}r'c"| |jz Sr*rrrs r(rzLinearMixing.matvecrr'cH| tj|jzSr*r+rrrts r(rzLinearMixing.rsolver"''$**%%%r'cH| tj|jz Sr*rrrs r(rzLinearMixing.rmatvecrr'ctjtj|jdd|jz S)Nr)r+rrr;rrs r(rzLinearMixing.todenses,wwrwwtzz!}bm<==r'cyr*r&rs r(rzLinearMixing._updaterr'r*r) r"r#r$r%rrrrrrrr&r'r(r r s*,&&> r'r cFeZdZdZd dZdZd dZdZd dZdZ d Z d Z y) ra Find a root of a function, using a tuned diagonal Jacobian approximation. The Jacobian matrix is diagonal and is tuned on each iteration. .. warning:: This algorithm may be useful for specific problems, but whether it will work may depend strongly on the problem. Parameters ---------- %(params_basic)s alpha : float, optional Initial Jacobian approximation is (-1/alpha). alphamax : float, optional The entries of the diagonal Jacobian are kept in the range ``[alpha, alphamax]``. %(params_extra)s See Also -------- root : Interface to root finding algorithms for multivariate functions. See ``method='excitingmixing'`` in particular. NcXtj|||_||_d|_yr*)rrralphamaxbeta)rrrs r(rzExcitingMixing.__init__;s%%    r'ctj||||tj|jdf|j |j |_yr)rrmr+rr;rr3rrs r(rmzExcitingMixing.setupAs=T1a.GGTZZ],djj K r'c"| |jzSr*rrts r(rzExcitingMixing.solveEr$))|r'c"| |jz Sr*rrrs r(rzExcitingMixing.matvecHrr'c>| |jjzSr*rrrts r(rzExcitingMixing.rsolveKr$)).."""r'c>| |jjz Sr*rrrs r(rzExcitingMixing.rmatvecNrr'cFtjd|jz S)Nr)r+rrrs r(rzExcitingMixing.todenseQswwr$))|$$r'c ||jzdkD}|j|xx|jz cc<|j|j|<tj|jd|j |jy)Nr)out)rrrr+clipr)rr/rrrrrincrs r(rzExcitingMixing._updateTs\}q  $4::%:: 4%  1dmm;r')Nrarrr&r'r(rr s04 L##%>> from scipy.optimize import BroydenFirst, KrylovJacobian >>> from scipy.optimize import InverseJacobian >>> jac = BroydenFirst() >>> kjac = KrylovJacobian(inner_M=InverseJacobian(jac)) If the preconditioner has a method named 'update', it will be called as ``update(x, f)`` after each nonlinear step, with ``x`` giving the current point, and ``f`` the current function value. outer_k : int, optional Size of the subspace kept across LGMRES nonlinear iterations. See `scipy.sparse.linalg.lgmres` for details. kw : kwargs Keyword parameters for the "inner" Krylov solver (defined with `method`). Parameter names must start with the `inner_` prefix which will be stripped before passing on the inner method. See, e.g., `scipy.sparse.linalg.gmres` for details. %(params_extra)s See Also -------- root : Interface to root finding algorithms for multivariate functions. See ``method='krylov'`` in particular. scipy.sparse.linalg.gmres scipy.sparse.linalg.lgmres Notes ----- This function implements a Newton-Krylov solver. The basic idea is to compute the inverse of the Jacobian with an iterative Krylov method. These methods require only evaluating the Jacobian-vector products, which are conveniently approximated by a finite difference: .. math:: J v \approx (f(x + \omega*v/|v|) - f(x)) / \omega Due to the use of iterative matrix inverses, these methods can deal with large nonlinear problems. SciPy's `scipy.sparse.linalg` module offers a selection of Krylov solvers to choose from. The default here is `lgmres`, which is a variant of restarted GMRES iteration that reuses some of the information obtained in the previous Newton steps to invert Jacobians in subsequent steps. For a review on Newton-Krylov methods, see for example [1]_, and for the LGMRES sparse inverse method, see [2]_. References ---------- .. [1] C. T. Kelley, Solving Nonlinear Equations with Newton's Method, SIAM, pp.57-83, 2003. :doi:`10.1137/1.9780898718898.ch3` .. [2] D.A. Knoll and D.E. Keyes, J. Comp. Phys. 193, 357 (2004). :doi:`10.1016/j.jcp.2003.08.010` .. [3] A.H. Baker and E.R. Jessup and T. Manteuffel, SIAM J. Matrix Anal. Appl. 26, 962 (2005). :doi:`10.1137/S0895479803422014` Examples -------- The following functions define a system of nonlinear equations >>> def fun(x): ... return [x[0] + 0.5 * x[1] - 1.0, ... 0.5 * (x[1] - x[0]) ** 2] A solution can be obtained as follows. >>> from scipy import optimize >>> sol = optimize.newton_krylov(fun, [0, 0]) >>> sol array([0.66731771, 0.66536458]) Nc ||_||_ttjj j tjj jtjj jtjj jtjj jtjj jj|||_ t||j|_|jtjj jur<||jd<d|jd<|jjddnR|jtjj j tjj j tjj jfvr|jjddn|jtjj jur||jd<d|jd<|jjd g|jjd d |jjd d |jjddt#|jj$Dcgc]}|dvr| }}|j'D]\} } | j)dst+d| | dd|vrht-| dd|d} | r d| dd} nd} t/j0d| d|d| zt2t4j6j9t:f| |j| dd<ycc}w)N)bicgstabgmreslgmrescgsminrestfqmr)r|r}rhrr|atolrouter_kouter_vprepend_outer_vTstore_outer_AvF)rargskwargsinner_zUnknown parameter )rz Did you mean 'z'?rNzOption 'z#' is invalid for the inner method: zO. It will be ignored.Please check inner method documentation for valid options.)categoryskip_file_prefixes)preconditionerrr rrrrrrrrrgetmethod method_kw setdefaultgcrotmkr parametersr startswithrorrFrG UserWarningospathdirname__file__) rrr inner_maxiterinner_Mrrr]valid_inner_paramskeyrinner_param_suggestionssuggestion_msgs r(rzKrylovJacobian.__init__s% \\((11,,%%++<<&&-- ##''<<&&--,,%%++ c&&! mt7J7JK ;;%,,--33 3(5DNN9 %()DNN9 % NN % %fa 0 [[U\\0088"\\0099"\\004466 NN % %fa 0 [[ELL//66 6(/DNN9 %()DNN9 % NN % %i 4 NN % %&7 > NN % %&6 > NN % %fa 0!-88 22   ((* ,JC>>(+ #5cU!;<<12w00*;CG?+A'+(7)@)C(DB'HN&(N se#FvhOQQ%%)(*(A'C &+DNN3qr7 #3 ,  s< Oct|jj}t|jj}|jtd|ztd|z |_y)Nr)rr=r-rromega)rmxmfs r(_update_diff_stepz KrylovJacobian._update_diff_stepsO \    \   ZZ#a*,s1bz9 r'cft|}|dk(rd|zS|j|z }|j|j||zz|jz |z }t j t j|s3t j t j|r td|S)Nrz$Function returned non-finite results) rrr\r=rr+rBrAro)rrEnvscrps r(rzKrylovJacobian.matvecs !W 7Q3J ZZ"_ YYtwwA~ & 0B 6vvbkk!n%"&&Q*@CD Dr'cd|jvr-|j|j|fi|j\}}|S|j|j|fd|i|j\}}|S)Nrtol)rrop)rrhsr`solrs r(rzKrylovJacobian.solvesg T^^ ## DGGSCDNNCIC $ DGGSMsMdnnMIC r'c||_||_|j|j4t |jdr|jj ||yyy)Nrt)r=rrrrrt)rr/rs r(rtzKrylovJacobian.update&sZ      *t**H5##**1a06 +r'ctj||||||_||_tj j j||_|j1tj|jjdz|_ |j|j5t!|jdr|jj|||yyy)Nrrm)rrmr=rrrraslinearoperatorrrr+rr3rrrr)rr/rr\s r(rmzKrylovJacobian.setup0stQ4(,,%%66t< :: !''*..48DJ      *t**G4##))!Q55 +r')NrN r) r"r#r$r%rrrrrtrmr&r'r(rr_s3cJCE')I,V: 16r'rc Lt|j}|\}}}}}}} tt|t | d|} dj | D cgc] \} } | d| c} } } | rd| z} dj | D cgc] \} } | d| c} } }|r|dz}|rt d|d}|t|| |j|z}i}|jtt||||}|j|_ t||Scc} } wcc} } w)a Construct a solver wrapper with given name and Jacobian approx. It inspects the keyword arguments of ``jac.__init__``, and allows to use the same arguments in the wrapper function, in addition to the keyword arguments of `nonlin_solve` Nz, =zUnexpected signature a def %(name)s(F, xin, iter=None %(kw)s, verbose=False, maxiter=None, f_tol=None, f_rtol=None, x_tol=None, x_rtol=None, tol_norm=None, line_search='armijo', callback=None, **kw): jac = %(jac)s(%(kwkw)s **kw) return nonlin_solve(F, xin, jac, iter, verbose, maxiter, f_tol, f_rtol, x_tol, x_rtol, tol_norm, line_search, callback) )rrjackwkw)_getfullargspecrlistr(r0joinror r"rtglobalsexecr%rL)rrrrvarargsvarkwdefaults kwonlyargs kwdefaults_rr]rEkw_strkwkw_strwrappernsr\s r(_nonlin_wrapperrEs.  -I@I=D'5(J A #dCM>?+X6 7F YY8A1#Qqe 8 9F yy8AQCq*89Hd?0 <==G$6s||"*,,G BIIgi" d8D;;DL TN K;99s D D rrrrrrr) rNFNNNNNNr^NFT)r^g:0yE>r)DrrrurFnumpyr+rrr scipy.linalgrrrr r r scipy.sparse.linalgr scipy.sparser scipy._lib._utilr rrr _linesearchrrrdifflibrtypesr__all__ Exceptionr r0r7r?rFr striprJrLrQrrsrjrrrlrr rr r r r rrrrrrrrrrr&r'r(rs $$??'>FC% J I   "$ "($( P a1 h/ .?DKO?C48O"d FJ!*Z9<9<@HHV(#(#VY?@X:LL^ 12 * + 0m>m`9L9@U~UxA1.A1H+ >+ \8<^8<~_6X_6L)X :| 4 :} 5 :x 0~|< m[9  !1>B@ |~r'