(phZaSSKrSSKJr SSKJrJr SSKJ r SSK J r SSK J r SSKJr SrSS jrSS jrSS jr"S S 5r"SS5r"SS5r"SS\5rg)N)approx_derivative group_columns)HessianUpdateStrategy)LinearOperator)array_namespace)array_api_extra)z2-pointz3-pointcsc&^^^S/mUUU4SjnUT4$)Nrc(>TS==S- ss'T"[R"U5/TQ76n[R"U5(d'[R"U5R 5nU$U$![ [ 4an[ S5UeSnAff=f)Nrrz@The user-provided objective function must return a scalar value.)npcopyisscalarasarrayitem TypeError ValueError)xfxeargsfunncallss [/var/www/html/venv/lib/python3.13/site-packages/scipy/optimize/_differentiable_functions.pywrapped_wrapper_fun..wrappedsq Q  #d #{{2 ZZ^((*  r z*  2 s$A00B B  B)rrrrs`` @r _wrapper_funr sSF F?c|^^^^^S/m[T5(a UUU4SjnUT4$T[;aSUUU4SjjnUT4$g)Nrc>TS==S- ss'[R"T"[R"U5/TQ765$Nrr)r atleast_1dr)rkwdsrgradrs rr_wrapper_grad..wrapped's1 1INI==bggaj!84!89 9rc<>TS==S- ss'[TU4SU0TD6$)Nrrf0r)rr(finite_diff_optionsrrs rwrapped1_wrapper_grad..wrapped1.s2 1INI$Q!4 rN)callable FD_METHODS)r%rrr*rr+rs```` @r _wrapper_gradr0#sHSF~~ :      rc^^^^^[T5(aT"[R"U5/TQ76nS/m[R"U5(aUUU4Sjn[R "U5nOP[ U[5(a UUU4SjnO2UUU4Sjn[R"[R"U55nUTU4$T[;aS/mSUU4SjjnUTS4$g)Nrc>TS==S- ss'[R"T"[R"U5/TQ765$r")sps csr_matrixr rrr$rhessrs rr_wrapper_hess..wrapped=s1q Q ~~d2771:&=&=>>rcX>TS==S- ss'T"[R"U5/TQ76$r")r rr5s rrr7Ds(q Q BGGAJ...rc >TS==S- ss'[R"[R"T"[R"U5/TQ7655$r")r atleast_2drrr5s rrr7Is:q Q }}RZZRWWQZ0G$0G%HIIrrc">[TU4SU0TD6$Nr(r))rr(r*r%s rr+_wrapper_hess..wrapped1Ss%$a"5 rr-) r.r rr3issparser4 isinstancerr:rr/) r6r%x0rr*Hrr+rs `` `` @r _wrapper_hessrB7s~~  $t $ <<?? ?q!A > * * / /  J bjjm,A!!     %% rc\rSrSrSrSSjr\S5r\S5r\S5r Sr S r S r S r S rS rSrSrSrg)ScalarFunction[a Scalar function and its derivatives. This class defines a scalar function F: R^n->R and methods for computing or approximating its first and second derivatives. Parameters ---------- fun : callable evaluates the scalar function. Must be of the form ``fun(x, *args)``, where ``x`` is the argument in the form of a 1-D array and ``args`` is a tuple of any additional fixed parameters needed to completely specify the function. Should return a scalar. x0 : array-like Provides an initial set of variables for evaluating fun. Array of real elements of size (n,), where 'n' is the number of independent variables. args : tuple, optional Any additional fixed parameters needed to completely specify the scalar function. grad : {callable, '2-point', '3-point', 'cs'} Method for computing the gradient vector. If it is a callable, it should be a function that returns the gradient vector: ``grad(x, *args) -> array_like, shape (n,)`` where ``x`` is an array with shape (n,) and ``args`` is a tuple with the fixed parameters. Alternatively, the keywords {'2-point', '3-point', 'cs'} can be used to select a finite difference scheme for numerical estimation of the gradient with a relative step size. These finite difference schemes obey any specified `bounds`. hess : {callable, '2-point', '3-point', 'cs', HessianUpdateStrategy} Method for computing the Hessian matrix. If it is callable, it should return the Hessian matrix: ``hess(x, *args) -> {LinearOperator, spmatrix, array}, (n, n)`` where x is a (n,) ndarray and `args` is a tuple with the fixed parameters. Alternatively, the keywords {'2-point', '3-point', 'cs'} select a finite difference scheme for numerical estimation. Or, objects implementing `HessianUpdateStrategy` interface can be used to approximate the Hessian. Whenever the gradient is estimated via finite-differences, the Hessian cannot be estimated with options {'2-point', '3-point', 'cs'} and needs to be estimated using one of the quasi-Newton strategies. finite_diff_rel_step : None or array_like Relative step size to use. The absolute step size is computed as ``h = finite_diff_rel_step * sign(x0) * max(1, abs(x0))``, possibly adjusted to fit into the bounds. For ``method='3-point'`` the sign of `h` is ignored. If None then finite_diff_rel_step is selected automatically, finite_diff_bounds : tuple of array_like Lower and upper bounds on independent variables. Defaults to no bounds, (-np.inf, np.inf). Each bound must match the size of `x0` or be a scalar, in the latter case the bound will be the same for all variables. Use it to limit the range of function evaluation. epsilon : None or array_like, optional Absolute step size to use, possibly adjusted to fit into the bounds. For ``method='3-point'`` the sign of `epsilon` is ignored. By default relative steps are used, only if ``epsilon is not None`` are absolute steps used. Notes ----- This class implements a memoization logic. There are methods `fun`, `grad`, hess` and corresponding attributes `f`, `g` and `H`. The following things should be considered: 1. Use only public methods `fun`, `grad` and `hess`. 2. After one of the methods is called, the corresponding attribute will be set. However, a subsequent call with a different argument of *any* of the methods may overwrite the attribute. Nc 0[U5(dU[;a[S[S35e[U5(d2U[;d([U[5(d[S[S35eU[;aU[;a [S5e[ U5=Uln [R"U RU5SU S9n U Rn U RU RS5(a U Rn [XS9uUlUlXlX@lXPlX0lU R)X5UlXlUR*R.UlS UlS UlS UlSUl[:R<Ul0n U[;aXLS 'XlS 'XS 'X|S 'U[;aX\S 'XlS 'XS 'SU S'URA5 [CUURUU S9uUl"Ul#URI5 [U5(a%[KXRUS9uUl&Ul'Ul(SUlgU[;aj[KUURDUU S9uUl&Ul'Ul(URI5 URMUR*URRS9Ul(SUlg[U[5(aJXPl(URPRUUR0S5 SUlSUl+SUl,S/Ul'gg)Nz)`grad` must be either callable or one of .z@`hess` must be either callable, HessianUpdateStrategy or one of zWhenever the gradient is estimated via finite-differences, we require the Hessian to be estimated using one of the quasi-Newton strategies.rndimxp real floating)rFmethodrel_stepabs_stepboundsTas_linear_operator)rrr*)r@r)r%r@r*r(r6r)-r.r/rr?rrrJxpx atleast_ndrfloat64isdtypedtyper _wrapped_fun_nfev _orig_fun _orig_grad _orig_hess_argsastyperx_dtypesizen f_updated g_updated H_updated _lowest_xr inf _lowest_f _update_funr0 _wrapped_grad_ngev _update_gradrB _wrapped_hess_nhevrAg initializex_prevg_prev) selfrr@rr%r6finite_diff_rel_stepfinite_diff_boundsepsilonrJ_x_dtyper*s r__init__ScalarFunction.__init__s~~$j"8;J ) : ,0 ).B +.5 +8<  4 5 *7 !! 3 * &DJ  D>>5B$6 2D  DF"DN Z 5B''$7 6 2D  DF    ''466':DF!DN 3 4 4F FF  dfff -!DNDKDKDJ 5rc URS$Nr)rXrqs rnfevScalarFunction.nfevzz!}rc URS$rz)rir{s rngevScalarFunction.ngevr~rc URS$rz)rlr{s rnhevScalarFunction.nhev r~rc[UR[5(aUR5 URUlUR Ul[R"URRU5SURS9nURRX R5UlSUlSUlSUlUR#5 g[R"URRU5SURS9nURRX R5UlSUlSUlSUlgNrrHF)r?r[rrjrrormrprRrSrJrr]r^rarbrc _update_hessrqrrus r _update_xScalarFunction._update_xs doo'< = =    &&DK&&DK 2twwGBWW^^B 5DF"DN"DN"DN     2twwGBWW^^B 5DF"DN"DN"DNrcUR(dOURUR5nXR:aURUlXlXlSUlggNT)rarWrrfrdf)rqrs rrgScalarFunction._update_fun%sH~~""466*BNN"!%!#F!DNrcUR(dUUR[;aUR5 UR UR UR S9UlSUlggNrQT)rbrZr/rgrhrrrmr{s rrjScalarFunction._update_grad/sL~~*,  "''466':DF!DN rcUR(dUR[;a:UR5 UR UR UR S9UlO[UR[5(a[UR5 URRUR UR- UR UR- 5 O UR UR 5UlSUlggr) rcr[r/rjrkrrmrAr?rupdaterorpr{s rrScalarFunction._update_hess6s~~*,!!#++DFFtvv+>DOO-BCC!!# dfft{{2DFFT[[4HI++DFF3!DNrc[R"XR5(dURU5 UR 5 UR $r-)r array_equalrrrgrrqrs rrScalarFunction.funCs6~~a(( NN1  vv rc[R"XR5(dURU5 UR 5 UR $r-)r rrrrjrmrs rr%ScalarFunction.gradI6~~a(( NN1  vv rc[R"XR5(dURU5 UR 5 UR $r-)r rrrrrArs rr6ScalarFunction.hessOrrc[R"XR5(dURU5 UR 5 UR 5 UR UR4$r-)r rrrrgrjrrmrs r fun_and_gradScalarFunction.fun_and_gradUsK~~a(( NN1   vvtvv~r)rArcr\rfrdrXrirlrYrZr[rWrhrkrrarmrprbr`rr^rorJr-)__name__ __module__ __qualname____firstlineno____doc__rwpropertyr|rrrrgrjrrr%r6r__static_attributes__rrrrDrD[syIV.2Zx#."" "   rrDcN\rSrSrSrSrSrSrSrSr Sr S r S r S r S rg )VectorFunctioni]aaVector function and its derivatives. This class defines a vector function F: R^n->R^m and methods for computing or approximating its first and second derivatives. Notes ----- This class implements a memoization logic. There are methods `fun`, `jac`, hess` and corresponding attributes `f`, `J` and `H`. The following things should be considered: 1. Use only public methods `fun`, `jac` and `hess`. 2. After one of the methods is called, the corresponding attribute will be set. However, a subsequent call with a different argument of *any* of the methods may overwrite the attribute. c > ^^^^^^^^^[T5(dT[;a[S[S35e[T5(d2T[;d([T[5(d[S[S35eT[;aT[;a [S5e[ U5=Tln [R"U RU5SU S9n U Rn U RU RS5(a U Rn U RX5TlU TlTRR TlSTlSTlSTlS TlS TlS Tl0mT[;aITTS 'UTS 'Ub[1U5n UU 4TS 'UTS '[2R4"TR5TlT[;a4TTS 'UTS 'STS'[2R4"TR5TlT[;aT[;a [S5eUU4SjmUU4Sjn U TlU "5 [2R:"TR<5TlTR>R Tl [T5(Ga%T"TR5Tl!STlT=R&S- slU(d(UcY[DRF"TRB5(a4UU4Sjm[DRH"TRB5Tl!STl%O[DRF"TRB5(a.UU4SjmTRBRM5Tl!S Tl%O3UU4Sjm[2RN"TRB5Tl!S Tl%UU4SjnGO&T[;GaTTR4STR<0TD6Tl!STlU(d(UcZ[DRF"TRB5(a5UUU4Sjn[DRH"TRB5Tl!STl%O[DRF"TRB5(a/UUU4SjnTRBRM5Tl!S Tl%O4UUU4Sjn[2RN"TRB5Tl!S Tl%WTl)[T5(aT"TRTR>5Tl*STlT=R(S- sl[DRF"TRT5(a-UU4Sjm[DRH"TRT5Tl*Og[TRT[V5(aUU4SjmO@UU4Sjm[2RN"[2R"TRT55Tl*UU4SjnOT[;aU4SjmUUU4SjnU"5 STlO][T[5(aHTTl*TRTRYTR"S 5 STlSTl-STl.U4S!jnWTl/[T[5(aU4S"jnOU4S#jnUTl0g)$Nz(`jac` must be either callable or one of rGz?`hess` must be either callable,HessianUpdateStrategy or one of zWhenever the Jacobian is estimated via finite-differences, we require the Hessian to be estimated using one of the quasi-Newton strategies.rrHrKrFrLrMsparsityrOTrPcf>T=RS- sl[R"T"U55$Nr)r|r r#)rrrqs r fun_wrapped,VectorFunction.__init__..fun_wrappeds# IINI==Q( (rc4>T"TR5Tlgr-)rr)rrqsr update_fun+VectorFunction.__init__..update_funs (DFrcf>T=RS- sl[R"T"U55$r)njevr3r4rjacrqs r jac_wrapped,VectorFunction.__init__..jac_wrappeds#IINI>>#a&11rcZ>T=RS- slT"U5R5$r)rtoarrayrs rrrs!IINIq6>>++rcf>T=RS- sl[R"T"U55$r)rr r:rs rrrs#IINI==Q00rc4>T"TR5Tlgr-)rJ)rrqsr update_jac+VectorFunction.__init__..update_jacs$TVV,rr(c>TR5 [R"[TTR4STR 0TD65Tlgr<)rgr3r4rrrrr*rrqsrrrsF$$& ^^)+tvvA$&&A,?ABDFrc>TR5 [TTR4STR0TD6R 5Tlgr<)rgrrrrrrsrrrsC$$&.{DFFFtvvF1DFFMgiFrc>TR5 [R"[TTR4STR 0TD65Tlgr<)rgr r:rrrrrsrrrsF$$&]])+tvvA$&&A,?ABDFrcf>T=RS- sl[R"T"X55$r)rr3r4rvr6rqs r hess_wrapped-VectorFunction.__init__..hess_wrappeds#IINI>>$q*55rc>>T=RS- slT"X5$r)rrs rrrsIINI:%rc>T=RS- sl[R"[R"T"X555$r)rr r:rrs rrrs,IINI==DJ)?@@rcJ>T"TRTR5Tlgr-)rrrA)rrqsr update_hess,VectorFunction.__init__..update_hess s%dffdff5rcF>T"U5RRU5$r-)Tdot)rrrs r jac_dot_v*VectorFunction.__init__..jac_dot_vs"1~''++A..rc>TR5 [TTR4TRRR TR 5TR 4S.TD6Tlg)N)r(r) _update_jacrrrrrrrA)r*rrqsrrrsW  "*9dffB.2ffhhll466.B15 B.ABrr6c>TR5 TRbTRbTRTR- nTRR R TR5TRR R TR5- nTRRX5 gggr-) rroJ_prevrrrrrrAr)delta_xdelta_grqs rrr!s  ";;*t{{/F"fft{{2G"ffhhll4662T[[]]5F5Ftvv5NNGFFMM'30G*rc|>TR5 TRTlTRTl[ R "TRRU5STRS9nTRRUTR5TlSTl STl STl TR5 gr)rrrorrrRrSrJrr]r^ra J_updatedrcrrrurqs rupdate_x)VectorFunction.__init__..update_x-s  ""ff "ff ^^DGGOOA$6Q477KDLL9!&!&!&!!#rc>[R"TRRU5STRS9nTRR UTR 5TlSTlSTlSTl gr) rRrSrJrr]r^rrarrcrs rrr8sU^^DGGOOA$6Q477KDLL9!&!&!&r)1r.r/rr?rrrJrRrSrrTrUrVr]rr^r_r`r|rrrarrcrr rx_diff_update_fun_impl zeros_likerrmrr3r>r4sparse_jacobianrr:r_update_jac_implrArrnror_update_hess_impl_update_x_impl)rqrr@rr6rrfinite_diff_jac_sparsityrsrrJrurvsparsity_groupsrrrrr*rrrrs`` `` @@@@@rrwVectorFunction.__init__ns}}J!6G |STUV V$*"4d$9::@@J|1NO O * !3+, , 'r**" ^^BJJrNr : ::bhh 0 0XXF2&      * ,/  ).B  +'3"/0H"I3K3B3D#J/,>  )''$&&/DK : ,0  ).B  +8<  4 5''$&&/DK * !3+, ,  ) )!+ tvv& C==[DF!DN IINI#+ TVV0D0D2/'+$dff%%,)',$1tvv.',$ - -J &{DFF>tvv>)<>DF!DN#+ TVV0D0DB /'+$dff%%P)',$B tvv.',$ * D>>$&&$&&)DF!DN IINI||DFF##6/DFFN33& Arzz$&&'9: 6 Z  / B M!DN 3 4 4DF FF  dfff -!DNDKDK 4"- d1 2 2 $ ''rcj[R"XR5(dXlSUlgg)NF)r rrrc)rqrs r _update_vVectorFunction._update_vAs&~~a((F"DN)rcr[R"XR5(dURU5 ggr-)r rrrrs rrVectorFunction._update_xFs(~~a((    ")rcVUR(dUR5 SUlggr)rarr{s rrgVectorFunction._update_funJ!~~  ! ! #!DNrcVUR(dUR5 SUlggr)rrr{s rrVectorFunction._update_jacOrrcVUR(dUR5 SUlggr)rcrr{s rrVectorFunction._update_hessTs!~~  " " $!DNrc\URU5 UR5 UR$r-)rrgrrs rrVectorFunction.funY# q vv rc\URU5 UR5 UR$r-)rrrrs rrVectorFunction.jac^rrc~URU5 URU5 UR5 UR$r-)rrrrArqrrs rr6VectorFunction.hesscs/ q q vv r)rArcrrrrrrrrrarr`r|rrrrrrr^rorJN)rrrrrrwrrrgrrrrr6rrrrrr]s6 Q'f# #" " "   rrc6\rSrSrSrSrSrSrSrSr Sr g ) LinearVectorFunctionikzLinear vector function and its derivatives. Defines a linear function F = A x, where x is N-D vector and A is m-by-n matrix. The Jacobian is constant and equals to A. The Hessian is identically zero and it is returned as a csr matrix. cU(dUc>[R"U5(a#[R"U5UlSUlOn[R"U5(aUR 5UlSUlO6[ R"[ R"U55UlSUlURRuUl Ul [U5=Ul n[R"URU5SUS9nUR nUR#UR$S5(a UR$nUR'XV5UlX`lURR-UR(5UlSUl[ R2"UR[4S9Ul"URUR45Ulg)NTFrrHrK)rV)r3r>r4rrrr r:rshaperr`rrJrRrSrTrUrVr]rr^rrrazerosfloatrrA)rqAr@rrJrurvs rrwLinearVectorFunction.__init__rsB o5#,,q//^^A&DF#'D \\!__YY[DF#(D ]]2::a=1DF#(D &r**" ^^BJJrNr : ::bhh 0 0XXF2& DFF#$&&. 01rc$[R"XR5(dk[R"UR R U5SUR S9nUR RX R5UlSUl ggr) r rrrRrSrJrr]r^rars rrLinearVectorFunction._update_xs\~~a(( 2twwGBWW^^B 5DF"DN)rcURU5 UR(d'URRU5UlSUlUR$r)rrarrrrs rrLinearVectorFunction.funs8 q~~VVZZ]DF!DNvv rc<URU5 UR$r-)rrrs rrLinearVectorFunction.jacs qvv rcHURU5 X lUR$r-)rrrArs rr6LinearVectorFunction.hesss qvv r) rArrrarr`rrrr^rJN) rrrrrrwrrrr6rrrrrrks  2<# rrc,^\rSrSrSrU4SjrSrU=r$)IdentityVectorFunctionizIdentity vector function and its derivatives. The Jacobian is the identity matrix, returned as a dense array when `sparse_jacobian=False` and as a csr matrix otherwise. The Hessian is identically zero and it is returned as a csr matrix. c>[U5nU(dUc[R"USS9nSnO[R"U5nSn[TU]XAU5 g)Ncsr)formatTF)lenr3eyer superrw)rqr@rr`r __class__s rrwIdentityVectorFunction.__init__sJ G o5%(A"Oq A#O 0rr)rrrrrrwr __classcell__)rs@rrrs 11rr)r)NrN)NNrN)numpyr scipy.sparsesparser3_numdiffrr_hessian_update_strategyrscipy.sparse.linalgrscipy._lib._array_apir scipy._libr rRr/rr0rBrDrrrrrrr!sc6;.1-* , (!&HDKK\99x111r