(phSSKrSSKrSSKrSSKrSSKJrJrJr SSKJ r J r J r J r J r Jr SSKrSSKrSSKJr SSKJr SSKJr SSKJrJr /S Qr"S S \5rS rS rSrSr \!"SRE5SRE5S9r#Sr$S9Sjr%\$"\%5 S:Sjr&"SS5r'"SS5r("SS5r)Sr*"SS\(5r+"SS 5r,S!RE5\#S"'"S#S$\+5r-"S%S&\-5r."S'S(\+5r/"S)S*\+5r0"S+S,\+5r1"S-S.\+5r2"S/S0\(5r3S1r4\4"S2\-5r5\4"S3\.5r6\4"S4\/5r7\4"S5\15r8\4"S6\05r9\4"S7\25r:\4"S8\35r;g);N)asarraydotvdot)normsolveinvqrsvd LinAlgError)get_blas_funcs)copy_if_needed)getfullargspec_no_self)scalar_search_wolfe1scalar_search_armijo) broyden1broyden2anderson linearmixing diagbroydenexcitingmixing newton_krylov BroydenFirstKrylovJacobianInverseJacobian NoConvergencec\rSrSrSrSrg)rzXException raised when nonlinear solver fails to converge within the specified `maxiter`.N)__name__ __module__ __qualname____firstlineno____doc____static_attributes__rI/var/www/html/venv/lib/python3.13/site-packages/scipy/optimize/_nonlin.pyrrs r&rcJ[R"U5R5$N)npabsolutemaxxs r'maxnormr/$s ;;q>   r&c[U5n[R"UR[R5(d[U[R S9$U$)z:Return `x` as an array, of either floats or complex floatsdtype)rr* issubdtyper2inexactfloat64r-s r' _as_inexactr6(s: A =="** - -q ++ Hr&c[R"U[R"U55n[USUR5nU"U5$)z;Return ndarray `x` as same array subclass and shape as `x0`__array_wrap__)r*reshapeshapegetattrr8)r.x0wraps r' _array_liker>0s8 1bhhrl#A 2')9)9 :D 7Nr&c[R"U5R5(d$[R"[R5$[ U5$r))r*isfiniteallarrayinfr)vs r' _safe_normrE7s5 ;;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_extracXUR(aUR[-Ulggr))r$ _doc_parts)objs r'_set_docrKus {{kkJ. r&c P^^U c[OU n [XgXX:S9n[T5mUU4SjnTR5n[R "U[R 5nU"U5n[U5n[U5nURUR5UU5 UcUbUS-nOSURS--nU SLaSn OU SLaSn U S ;a [S 5eS nS nS nSn[U5GHYnURUUU5nU(a GO[[UUU-5nUR!UUS9*n[U5S:Xa [S5eU (a[#UUUUU 5unnnnOSnUU-nU"U5n[U5nUR%UR5U5 U (a U "UU5 UUS--US-- nUUS--U:a [UU5nO[U['UUUS--55nUnU(dGM[(R*R-SUU "U5U4-5 [(R*R/5 GM\ U(a[1[3UT55eSnU (a)UR4UUUS:HSSS.US.n[3UT5U4$[3UT5$)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_rtoliterrcV>[T"[UT555R5$r))r6r>flatten)zFr<s r'funcnonlin_solve..funcs#1[B/0199;;r&rdTarmijoF)NrYwolfezInvalid line searchg?gH.?g?gMbP?)tolrz[Jacobian inversion yielded zero vector. This indicates a bug in the Jacobian approximation.?z%d: |F(x)| = %g; step %g z0A solution was found at the specified tolerance.z:The maximum number of iterations allowed has been reached.)rr])nitfunstatussuccessmessage)r/TerminationConditionr6rSr* full_likerCr asjacobiansetupcopysize ValueErrorrangecheckminr_nonlin_line_searchupdater,sysstdoutwriteflushrr> iteration) rUr<jacobianrQverbosemaxiterrMrNrOrPtol_norm line_searchcallback full_outputraise_exception conditionrVr.dxFxFx_normgammaeta_max eta_tresholdetanr`r[s Fx_norm_neweta_Ainfos `` r' nonlin_solverzsZ#*wH$5+0*.?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 7 JJ  :8B<>$$ % JJ   UX  Ar 23 3F ** !Q; , 3% & 1b!4''1b!!r&ch^^^^^ ^ ^^^S/mU/m[U5S-/m[T5[T5- m S UUUUUU4Sjjm U UU 4SjnUS:Xa[T UTSSUS9upn OUS:Xa[T TSTS*US 9upWcS nTUT--mUTS:XaTSnOT"T5n[U5n UTX+4$) Nrr]c>UT S:XaTS$T UT--nT"U5n[U5S-nU(aUT S'UTS'UTS'U$)Nrr])rE) rstorextrDpr}rVtmp_Fxtmp_phitmp_sr.s r'phi _nonlin_line_search..phis_ a=1:  2X H qM1  E!HGAJF1Ir&cV>[U5T-S-T-nT"X-SS9T"U5- U- $)NrF)r)abs)rdsrrdiffs_norms r'derphi#_nonlin_line_search..derphi#s7!fvo!U *AD&Q/255r&rZ{Gz?)xtolaminrY)rr\)T)rrr)rVr.r~r} search_typersminrrphi1phi0rrrrrrs`` ` ` @@@@@r'rmrms CETFBx{mG !WtBx F  6g,S&'!*26TC   &sGAJ ,02 y  AbDAE!H} AY !W2hG a r&c4\rSrSrSrSSSSS\4SjrSrSrg)rci=z 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 NcBUc1[R"[R5RS-nUc[RnUc[RnUc[RnX0lX@lXlX lX`l XPl SUl SUl g)NgUUUUUU?r) r*finfor5epsrCrOrPrMrNrrQf0_normrs)selfrMrNrOrPrQrs r'__init__TerminationCondition.__init__Js| =HHRZZ(,,6E >VVF =FFE >VVF       r&cU=RS- slURU5nURU5nURU5nURcX@lUS:XagURbSURUR:-$[ X@R :*=(a X@R - UR:*=(a& X`R:*=(a X`R- U:*5$)Nrrr]) rsrrrQintrMrNrOrP)rfr.r}f_normx_normdx_norms r'rkTerminationCondition.checkbs !11))B- << !L Q; 99 23 3Fjj(;{{*dll:;::-:#KK/69< .__array__s'$$'A%%IJJ||~%r&NN)itemsrisetattrhasattr)rkwnamesnamevaluers r'rJacobian.__init__s_888:KD  #>  8>> 1 KK  2r&)r2rVr:Nr) r r!r"r#r$rrrrnrfr%rr&r'rr}s!#J& %" r&rc>\rSrSrSrSr\S5r\S5rSr g)riaG 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. cXlURUlURUl[ US5(aUR Ul[ US5(aUR Ulgg)Nrfr)rtrrrnrrfrr)rrts r'rInverseJacobian.__init__sR nn oo 8W % %!DJ 8X & &#??DL 'r&c.URR$r))rtr:rs r'r:InverseJacobian.shape}}"""r&c.URR$r))rtr2rs r'r2InverseJacobian.dtyperr&)rtrrrfrnN) r r!r"r#r$rpropertyr:r2r%rr&r'rrs4(+####r&rc ^^[RRRm[ T[ 5(aT$[ R"T5(a[T[ 5(aT"5$[ T[R5(aTRS:a [S5e[R"[R"T55mTRSTRS:wa [S5e[ U4SjU4SjSU4SjjSU4S jjTR TRS 9$[RR#T5(acTRSTRS:wa [S 5e[ U4S jU4S jSUU4SjjSUU4SjjTR TRS 9$[%TS5(a[%TS5(aq[%TS5(a`[ ['TS5['TS5TR(['TS5['TS5['TS5TR TRS9$[+T5(a"UU4SjS[ 5nU"5$[ T[,5(a3[/[0[2[4[6[8[:[<S9T"5$[?S5e)z= Convert given object to one suitable for use as a Jacobian. r]zarray must have rank <= 2rrzarray must be squarec>[TU5$r))rrDJs r'asjacobian..s Qr&cL>[TR5RU5$r))rconjTrs r'rrs#affhjj!*[TU5$r))rrDr[rs r'rrs uQ{r&cL>[TR5RU5$r))rrrrs r'rrsaffhjj!0Dr&)rrrrr2r:zmatrix must be squarec>TU-$r)rrs r'rrs Qr&c>>TR5RU-$r)rrrs r'rrs!&&(**q.r&c>T"TU5$r)rrDr[rspsolves r'rrs wq!}r&cF>T"TR5RU5$r)rrs r'rrs A0Fr&r:r2rrrrrnrf)rrrrrnrfr2r:cX>\rSrSrSrS UU4SjjrU4SjrS UU4SjjrU4SjrSr g) asjacobian..JacicXlgr)r-rs r'rnasjacobian..Jac.updatesr&c>T"UR5n[U[R5(a [ X15$[ R RU5(aT"X15$[S5eNzUnknown matrix type) r. isinstancer*ndarrayrscipysparseissparserirrDr[mrrs r'rasjacobian..Jac.solvesVdffIa,, ;&\\**1--"1=($%:;;r&c>T"UR5n[U[R5(a [ X!5$[ R RU5(aX!-$[S5er) r.rr*rrrrrrirrDrrs r'rasjacobian..Jac.matvec!sSdffIa,,q9$\\**1--5L$%:;;r&cN>T"UR5n[U[R5(a$[ UR 5R U5$[RRU5(a!T"UR 5R U5$[S5er) r.rr*rrrrrrrrirs r'rasjacobian..Jac.rsolve*spdffIa,, Q//\\**1--"1668::q11$%:;;r&cF>T"UR5n[U[R5(a$[ UR 5R U5$[RRU5(aUR 5R U-$[S5er) r.rr*rrrrrrrrirs r'rasjacobian..Jac.rmatvec3smdffIa,,qvvxzz1--\\**1--668::>)$%:;;r&r-Nr) r r!r"r#rnrrrrr%)rrsr'Jacrs+  < < < < < < >r&c&\rSrSrSrSrSrSrg)GenericBroydeniLc[RXX#5 X lXl[ US5(aIUR c;[ U5nU(a!S[[ U5S5-U- UlgSUlggg)Nalpha?rr\)rrflast_flast_xrrrr,)rr<f0rVnormf0s r'rfGenericBroyden.setupMsit*  4 ! !djj&8"XF T"Xq!11F:   '9 !r&c[er)rrr.rr}dfrdf_norms r'_updateGenericBroyden._update[rr&c X R- nXR- nURXXC[U5[U55 X lXlgr))rr r(r)rr.rr&r}s r'rnGenericBroyden.update^s< _ _ Q248T"X6  r&)rrr N)r r!r"r#rfr(rnr%rr&r'rrLs !"r&rc\rSrSrSrSr\S5r\S5rSr Sr SSjr SS jr S r SS jrS rSrSrSSjrSrg ) LowRankMatrixifz 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. cRXl/Ul/UlX lX0lSUlgr))rcsrrr2 collapsed)rrrr2s r'rLowRankMatrix.__init__qs&  r&c[/SQUSSU/-5upEnX-n[X#5H!upU"X5n U"XURU 5nM# U$)N)axpyscaldotcr)r ziprh) rDrr/rr3r4r5wcdas r'_matvecLowRankMatrix._matvecys\)*B*,Ra&A3,8D IKDAQ AQ1661%A r&c 6[U5S:XaX- $[SS/USSU/-5upEUSnU[R"[U5URS9-n[ U5H-up[ U5HupXxU 4==U"X5- ss'M M/ [R "[U5URS9n [ U5HupU"X5X'M X-n [X|5n X- n [X,5HupU"XU RU*5n M U $)Evaluate w = M^-1 vrr3r5Nrr1) lenr r*identityr2 enumeratezerosrr6rh)rDrr/rr3r5c0Air9jr8qr7qcs r'_solveLowRankMatrix._solves r7a<7N$VV$4b!fslC  U BKKBrxx8 8bMDA!" A#$q*$&" HHSWBHH -bMDA:AD"  !K GZEAQ166B3'A r&cURb![R"URU5$[R XR UR UR5$)zEvaluate w = M v)r0r*rr-r;rr/rrrDs r'rLowRankMatrix.matvecsB >> %66$..!, ,$$Q DGGTWWEEr&c"URb9[R"URRR 5U5$[ R U[R"UR5URUR5$)zEvaluate w = M^H v) r0r*rrrr-r;rrr/rLs r'rLowRankMatrix.rmatvecs\ >> %66$..**//115 5$$Q (;TWWdggNNr&cURb[URU5$[RXRUR UR 5$)r>)r0rr-rIrr/rrs r'rLowRankMatrix.solves> >> %+ +##Azz477DGGDDr&c URb.[URRR5U5$[R U[ R"UR5URUR5$)zEvaluate w = M^-H v) r0rrrr-rIr*rrr/rs r'rLowRankMatrix.rsolvesX >> %))..0!4 4##Arwwtzz':DGGTWWMMr&c\URb5U=RUSS2S4USSS24R5-- slgURRU5 URRU5 [ UR5UR :aUR5 ggr))r0rr/appendrr?rhcollapse)rr8r9s r'rULowRankMatrix.appends{ >> % NNa$i!DF)..*:: :N  q q tww~O%& (   MM99=nN%& ( >> %>> ! ZZ DFF$**= =)DA AdF)Ad1fINN,, ,B* r&cj[R"U[S9UlSUlSUlSUlg)z0Collapse the low-rank matrix to a full-rank one.)rgN)r*rBr r0r/rrrs r'rVLowRankMatrix.collapses)$^< r&cURbgUS:de[UR5U:aURSS2 URSS2 gg)z8 Reduce the rank of the matrix by dropping all vectors. Nrr0r?r/rrranks r'restart_reduceLowRankMatrix.restart_reducesG >> % axx tww<$    r&cURbgUS:de[UR5U:a6URS URS [UR5U:aM5gg)z; Reduce the rank of the matrix by dropping oldest vectors. Nrrbrcs r' simple_reduceLowRankMatrix.simple_reducesT >> % axx$''lT!  $''lT!r&cURbgUnUbUnOUS- nUR(a"[U[URS55n[ S[XCS- 55n[UR5nXS:ag[ R "UR5Rn[ R "UR5Rn[USS9upx[XhRR55n[USS9upn [U[U 55n[X{RR55n[U5HKn USS2U 4R5URU 'USS2U 4R5URU 'MM URUS2 URUS2 g) al 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 Nr]rreconomic)modeF) full_matrices)r0r/rlr?r,r*rBrrr rrr rrjrg) rmax_rank to_retainrrGrCDRUSWHks r' svd_reduceLowRankMatrix.svd_reducesW: >> %    AAA 77As4771:'A 3qA#;  L 5  HHTWW    HHTWW   !*% 3388: q.b 3r7O 4499; qA1Q3DGGAJ1Q3DGGAJ GGABK GGABKr&)rr0r/rr2rrrr))r r!r"r#r$r staticmethodr;rIrrrrrUrrVrerhrwr%rr&r'r-r-fsj6F 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_paramscT\rSrSrSrS SjrSrSrSSjrSr SS jr S r S r S r g)riJa 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]) Ncf^^[RT5 UTlSTlUc[R nUTl[U[5(aSmO USSmUSnUS- 4T-mUS:Xa UU4SjTl gUS:Xa UU4SjTl gUS:Xa UU4S jTl g[S US 35e) Nrrrr c6>TRR"T6$r))r]rw reduce_paramsrsr'r'BroydenFirst.__init__..s477#5#5}#Er&simplec6>TRR"T6$r))r]rhr~sr'rrs477#8#8-#Hr&restartc6>TRR"T6$r))r]rer~sr'rrs477#9#9=#Ir&zUnknown rank reduction method '') rrrr]r*rCrnrr_reduceri)rrreduction_methodrnrs` @r'rBroydenFirst.__init__s%   vvH  & , ,M,QR0M/2 !A-7 u $EDL  )HDL  *IDL>?O>PPQRS Sr&c[RXX#5 [UR*URSUR 5Ulg)Nr)rrfr-rr:r2r]rs r'rfBroydenFirst.setups4Ta. TZZ]DJJGr&c,[UR5$r))rr]rs r'rBroydenFirst.todenses477|r&c&URRU5n[R"U5R 5(dLUR UR URUR5 URRU5$U$r)) r]rr*r@rArfr rrV)rrr[rs r'rBroydenFirst.solves_ GGNN1 {{1~!!## JJt{{DKK ;77>>!$ $r&c8URRU5$r))r]rrrs r'rBroydenFirst.matvecsww}}Qr&c8URRU5$r))r]rrrr[s r'rBroydenFirst.rsolveswwq!!r&c8URRU5$r))r]rrs r'rBroydenFirst.rmatvecsww~~a  r&cUR5 URRU5nX0RRU5- nU[ XG5- n URR X5 gr))rr]rrrrU rr.rr}r&rr'rDr8r9s r'r(BroydenFirst._updatesO  GGOOB  # # R O qr&)r]rrrn)NrNr)r r!r"r#r$rrfrrrrrr(r%rr&r'rrJs22hT2H "!r&rc\rSrSrSrSrSrg)ria 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]) cUR5 UnX0RRU5- nXvS-- n URRX5 gNr])rr]rrUrs r'r(BroydenSecond._updates@   # #  N qr&rN)r r!r"r#r$r(r%rr&r'rrs 0dr&rc8\rSrSrSrS SjrS SjrSrSrSr g) riaz 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]) Nc|[RU5 XlX0l/Ul/UlSUlX lgr))rrrMr}r&rw0)rrrrs r'rAnderson.__init__As4%  r&cUR*U-n[UR5nUS:XaU$[R"XAR S9n[ U5Hn[URUU5XV'M [URU5n[ U5H7nX7UURUURURU---- nM9 U$![a# URSS2 URSS2 Us$f=fNrr1) rr?r}r*emptyr2rjrr&rr:r ) rrr[r}rdf_frvrrs r'rAnderson.solveJsjj[] L 6Ixx)qA4771:q)DG $&&$'EqA (DGGAJDGGAJ)>>? ?B    I  s:C*DDc DU*UR- n[UR5nUS:XaU$[R"X1R S9n[ U5Hn[URUU5XE'M [R"X34UR S9n[ U5Hn[ U5Hn[URUURU5XgU4'Xx:XdM4URS:wdMFXgU4==[URUURU5URS--UR--ss'M M [Xd5n [ U5H7n X)U URU URU UR- --- nM9 U$)Nrr1r]) rr?r}r*rr2rjrr&rr) rrr}rrrvbrErFrrs r'rAnderson.matvecasOR ] L 6Ixx)qA4771:q)DG HHaV177 +qA1Xdggaj$''!*5A#6dgglcFd4771:twwqz:477A:EdjjPPF aqA (DGGAJDJJ)>>? ?B r&c>URS:XagURRU5 URRU5 [ UR5UR:a[URR S5 URR S5 [ UR5UR:aM[[ UR5n[ R"Xw4URS9n[U5H\n [X5HJn X:XaURS-n OSn SU -[URU URU 5-XU 4'ML M^ U[ R"US5RR5- nXlg)Nrr1r]r)rr}rUr&r?popr*rBr2rjrrtriurrr:) rr.rr}r&rr'rr:rErFwds r'r(Anderson._updatexs# 66Q;  r r$''lTVV# GGKKN GGKKN$''lTVV# L HHaV177 +qA1[6!BBB$TWWQZ <<A# ! RWWQ]__ ! ! ##r&)rr:rr&r}rr)Nrr) r r!r"r#r$rrrr(r%rr&r'rrs+L..r&rcT\rSrSrSrS SjrSrSSjrSrSSjr S r S r S r S r g)ria 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:[RU5 Xlgr)rrrrrs r'rDiagBroyden.__init__% r&c[RXX#5 [R"URS4SUR - UR S9Ulg)Nrrr1)rrfr*fullr:rr2r9rs r'rfDiagBroyden.setups=Ta.$**Q-)1tzz>Lr&c"U*UR- $r)r9rs r'rDiagBroyden.solverDFF{r&c"U*UR-$r)rrs r'rDiagBroyden.matvecrr&c>U*URR5- $r)r9rrs r'rDiagBroyden.rsolverDFFKKM!!r&c>U*URR5-$r)rrs r'rDiagBroyden.rmatvecrr&cD[R"UR*5$r))r*diagr9rs r'rDiagBroyden.todenseswwwr&c^U=RX@RU--U-US-- -slgrrr%s r'r(DiagBroyden._updates( 2r >2%gqj00r&)rr9r)rr r!r"r#r$rrfrrrrrr(r%rr&r'rrs1&PM"" 1r&rcN\rSrSrSrS SjrS SjrSrS SjrSr S r S r S r g)ria 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:[RU5 Xlgr)rrs r'rLinearMixing.__init__rr&c"U*UR-$r)rrs r'rLinearMixing.solver$**}r&c"U*UR- $r)rrs r'rLinearMixing.matvecrr&cJU*[R"UR5-$r)r*rrrs r'rLinearMixing.rsolver"''$**%%%r&cJU*[R"UR5- $r)rrs r'rLinearMixing.rmatvecrr&c[R"[R"URSSUR- 55$)Nr)r*rrr:rrs r'rLinearMixing.todenses,wwrwwtzz!}bm<==r&cgr)rr%s r'r(LinearMixing._updaterr&rr)r) r r!r"r#r$rrrrrrr(r%rr&r'rrs*,&&> r&rcT\rSrSrSrS SjrSrSSjrSrSSjr S r S r S r S r g)ria 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. See Also -------- root : Interface to root finding algorithms for multivariate functions. See ``method='excitingmixing'`` in particular. 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 NcT[RU5 XlX lSUlgr))rrralphamaxbeta)rrrs r'rExcitingMixing.__init__#s!%   r&c[RXX#5 [R"URS4UR UR S9Ulgr)rrfr*rr:rr2rrs r'rfExcitingMixing.setup)s9Ta.GGTZZ],djj K r&c"U*UR-$r)rrs r'rExcitingMixing.solve-r$))|r&c"U*UR- $r)rrs r'rExcitingMixing.matvec0rr&c>U*URR5-$r)rrrs r'rExcitingMixing.rsolve3r$)).."""r&c>U*URR5- $r)rrs r'rExcitingMixing.rmatvec6rr&cH[R"SUR- 5$)Nr)r*rrrs r'rExcitingMixing.todense9swwr$))|$$r&cX R-S:nURU==UR- ss'URURU)'[R"URSUR URS9 g)Nr)out)rrrr*clipr)rr.rr}r&rr'incrs r'r(ExcitingMixing._update<sZ}q  $4::%:: 4%  1dmm;r&)rrr)Nr\rrrr&r'rrs04 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. inner_kwargs : 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 DX@lXl[[RR R [RR R[RR R[RR R[RR R[RR RS9RX"5Ul [X0RS9UlUR[RR RLa;X0RS'SURS'URRSS5 GOTUR[RR R [RR R [RR R4;aURRSS5 OUR[RR RLaXPRS'SURS'URRS /5 URRS S 5 URRS S 5 URRSS5 UR#5H:upxUR%S5(d['SU35eXRUSS'M< g)N)bicgstabgmreslgmrescgsminrestfqmr)rvrrrrvatolrouter_kouter_vprepend_outer_vTstore_outer_AvFinner_zUnknown parameter )preconditionerrrrrr rrrrrrgetmethod method_kw setdefaultgcrotmkr startswithri) rrr  inner_maxiterinner_Mrrkeyrs r'rKrylovJacobian.__init__s)% \\((11,,%%++<<&&-- ##''<<&&--,,%%++ c&! m7J7JK ;;%,,--33 3(5NN9 %()DNN9 % NN % %fa 0 [[U\\0088"\\0099"\\004466 NN % %fa 0 [[ELL//66 6(/NN9 %()DNN9 % NN % %i 4 NN % %&7 > NN % %&6 > NN % %fa 0((*JC>>(++ #5cU!;<<&+NN3qr7 #%r&c[UR5R5n[UR5R5nUR[SU5-[SU5- Ulg)Nr)rr<r,r!romega)rmxmfs r'_update_diff_step KrylovJacobian._update_diff_stepsO \    \   ZZ#a*,s1bz9 r&c[U5nUS:XaSU-$URU- nURURX1--5UR- U- n[ R "[ R"U55(d:[ R "[ R"U55(a [S5eU$)Nrz$Function returned non-finite results) rrrVr<r!r*rAr@ri)rrDnvscrs r'rKrylovJacobian.matvecs !W 7Q3J ZZ"_ YYtww~ & 0B 6vvbkk!n%%"&&Q*@*@CD Dr&cSUR;a,UR"URU40URD6up4U$UR"URU4SU0URD6up4U$)Nrtol)r r op)rrhsr[solrs r'rKrylovJacobian.solves_ T^^ # DGGSCDNNCIC  DGGSMsMdnnMIC r&cXlX lUR5 URb8[ URS5(aURR X5 ggg)Nrn)r<r!rr rrn)rr.rs r'rnKrylovJacobian.updatesW      *t**H55##**106 +r&c[RXX#5 XlX l[R R RU5UlURc2[R"UR5RS-Ul UR5 URb9[!URS5(aURRXU5 ggg)Nrrf)rrfr<r!rrr aslinearoperatorr!rr*rr2rrr r)rr.rrVs r'rfKrylovJacobian.setupst(,,%%66t< :: !''*..48DJ      *t**G44##))!55 +r&)r!r r rr!r rr<)NrN r) r r!r"r#r$rrrrrnrfr%rr&r'rrGs2cJCE')-,^: 16r&rc f[UR5nUup4pVpxn [[U[ U5*SU55n SR U V V s/sH upU SU <3PM sn n 5n U (aSU -n SR U V V s/sH upU SU 3PM sn n 5nU(aUS-nU(a[ SU35eSnU[X URUS9-n0nUR[55 [UU5 UUnURUl [U5 U$s sn n fs sn n f)z 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)_getfullargspecrlistr6r?joinrirr rnglobalsexecr$rK)rr. signatureargsvarargsvarkwdefaults kwonlyargs kwdefaults_kwargsrvrDkw_strkwkw_strwrappernsrVs r'_nonlin_wrapperrBs*  -I@I=D5JA #dCM>?+X6 7F YY81#Qqe 8 9F yy8QCq*89Hd?0 <==G$s||"*,,G BIIgi" d8D;;DL TN K;99s D' D- rrrrrrr) r NFNNNNNNrYNFT)rYg:0yE>r)rErstriprIrKrrmrcrrrerr-rrrrrrrrBrrrrrrrrr&r'rLs $$??'+FC J I    (P a1 h/ ?DKO?C48P"f FJ!*Z9<9<@EEP$#$#NY?@X4IIX * + 0m>m`9L9@U~UxA1.A1H+ >+ \8<^8<~C6XC6T)X :| 4 :} 5 :x 0~|< m[9  !1>B@ r&