o `^hZa@sddlZddlmZddlmZmZddlm Z ddl m Z ddl m Z ddlmZdZdd d Zdd d ZdddZGdddZGdddZGdddZGdddeZdS)N)approx_derivative group_columns)HessianUpdateStrategy)LinearOperator)array_namespace)array_api_extra)z2-pointz3-pointcscsdgfdd}|fS)Nrc spdd7<t|gR}t|s6z t|}W|Sttfy5}ztd|d}~ww|S)Nrrz@The user-provided objective function must return a scalar value.)npcopyisscalarasarrayitem TypeError ValueError)xfxeargsfunncallsr f/home/air/shanriGPT/back/venv/lib/python3.10/site-packages/scipy/optimize/_differentiable_functions.pywrappeds z_wrapper_fun..wrappedr )rrrr rr _wrapper_fun srcsLdgtrfdd}|fStvr$dfdd }|fSdS)Nrcs,dd7<tt|gRSNrr)r atleast_1dr rkwds)rgradrr rr'sz_wrapper_grad..wrappedcs&dd7<t|fd|iS)Nrrf0rrr!)finite_diff_optionsrrr rwrapped1.sz_wrapper_grad..wrapped1N)callable FD_METHODS)r rrr$rr%r )rr$rr rr _wrapper_grad#sr)cstrHt|gR}dgt|r%fdd}t|}nt|tr3fdd}nfdd}tt |}||fSt vr\dgd fdd }|dfSdS) Nrcs,dd7<tt|gRSr)sps csr_matrixr r rrhessrr rr=sz_wrapper_hess..wrappedcs&dd7<t|gRSr)r r rr,r rrDscs2dd7<ttt|gRSr)r atleast_2drr rr,r rrIs"rcst|fd|iSNr!r"r#)r$r r rr%Ssz_wrapper_hess..wrapped1r&) r'r r r*issparser+ isinstancerr.rr()r-r x0rr$Hrr%r )rr$r r-rr _wrapper_hess7s      r4c@seZdZdZ dddZeddZeddZed d Zd d Z d dZ ddZ ddZ ddZ ddZddZddZdS)ScalarFunctionaScalar 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 CsFt|s|tvrtdtdt|s%|tvs%t|ts%tdtd|tvr1|tvr1tdt||_} tj| |d| d} | j } | | j drP| j } t ||d\|_|_||_||_||_||_| | | |_| |_|jj|_d |_d |_d |_d|_tj|_i} |tvr|| d <|| d <|| d <|| d <|tvr|| d <|| d <|| d <d| d<| t!||j|| d\|_"|_#|$t|rt%|||d\|_&|_'|_(d|_dS|tvrt%||j"|| d\|_&|_'|_(|$|j&|j|j)d|_(d|_dSt|tr!||_(|j(*|jdd|_d|_+d|_,dg|_'dSdS)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$)r2r)r r2r$r!r-r)-r'r(rr1rrr9xpx 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_funr) _wrapped_grad_ngev _update_gradr4 _wrapped_hess_nhevr3g initializex_prevg_prev) selfrr2rr r-finite_diff_rel_stepfinite_diff_boundsepsilonr9_x_dtyper$r r r__init__s       zScalarFunction.__init__cC |jdSNr)rGr`r r rnfev zScalarFunction.nfevcCrgrh)rXrir r rngevrkzScalarFunction.ngevcCrgrh)r[rir r rnhev rkzScalarFunction.nhevcCst|jtr7||j|_|j|_tj |j |d|j d}|j ||j |_d|_d|_d|_|dStj |j |d|j d}|j ||j |_d|_d|_d|_dSNrr7F)r1rJrrYrr^r\r_rArBr9rrLrMrPrQrR _update_hessr`rrdr r r _update_xs   zScalarFunction._update_xcCs>|js||j}||jkr|j|_||_||_d|_dSdSNT)rPrFrrUrSf)r`rr r rrV%s   zScalarFunction._update_funcCs:|js|jtvr ||j|j|jd|_d|_dSdSNr@T)rQrIr(rVrWrrsr\rir r rrY/s   zScalarFunction._update_gradcCs~|js=|jtvr||j|j|jd|_n!t|jt r1||j |j|j |j|j n||j|_d|_dSdSrt) rRrJr(rYrZrr\r3r1rupdater^r_rir r rro6s    zScalarFunction._update_hesscC&t||js ||||jSr&)r array_equalrrqrVrsr`rr r rrC zScalarFunction.funcCrvr&)r rwrrqrYr\rxr r rr IryzScalarFunction.gradcCrvr&)r rwrrqror3rxr r rr-OryzScalarFunction.hesscCs4t||js |||||j|jfSr&)r rwrrqrVrYrsr\rxr r r fun_and_gradUs   zScalarFunction.fun_and_gradr&)__name__ __module__ __qualname____doc__rfpropertyrjrlrmrqrVrYrorr r-rzr r r rr5[s$K \      r5c@sXeZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ dS)VectorFunctionaVector 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 ststvrtdtdts%tvs%tts%tdtdtvr1tvr1tdt|_} tj| |d| d} | j } | | j drP| j } | | | _| _jj_d_d_d_d _d _d _itvrd <|d <|durt|} || fd <|d <tj_tvrd <|d <dd<tj_tvrtvrtdfddfdd} | _| tj_jj_ trAj_!d_jd7_|s|durt"#j!rfddt"$j!_!d_%n)t"#j!r(fddj!&_!d _%nfddt'j!_!d _%fdd}nctvrt(jfdji_!d_|sf|duryt"#j!ryfdd}t"$j!_!d_%n+t"#j!rfdd}j!&_!d _%nfdd}t'j!_!d _%|_)trjj_*d_jd7_t"#j*rԇfddt"$j*_*n tj*t+rfd dnfd!dt't j*_*fd"d#}n:tvrfd$d%fd&d#}|d_n ttr6_*j*,jd'd_d_-d_.fd(d#}|_/ttrFfd)d*}nfd+d*}|_0dS),Nz(`jac` must be either callable or one of r6z?`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.rr7r:rFr;r<sparsityr>Tr?cjd7_t|SNr)rjr rr)rr`r r fun_wrappedz,VectorFunction.__init__..fun_wrappedcj_dSr&)rrsr )rr`r r update_funz+VectorFunction.__init__..update_funcrr)njevr*r+rjacr`r r jac_wrappedrz,VectorFunction.__init__..jac_wrappedcsjd7_|Sr)rtoarrayrrr rrs crr)rr r.rrr rrrcrr&)rJr )rr`r r update_jacrz+VectorFunction.__init__..update_jacr!c.ttjfdji_dSr/)rVr*r+rrrsrr r$rr`r rr  cs,tjfdji_dSr/)rVrrrsrrr rr rrs crr/)rVr r.rrrsrr rr rrrcsjd7_t||Sr)rmr*r+rvr-r`r r hess_wrappedsz-VectorFunction.__init__..hess_wrappedcsjd7_||Sr)rmrrr rrs cs$jd7_tt||Sr)rmr r.rrrr rrscsjj_dSr&)rrr3r )rr`r r update_hess sz,VectorFunction.__init__..update_hesscs|j|Sr&)Tdotr)rr r jac_dot_vrz*VectorFunction.__init__..jac_dot_vcs8tjfjjjjfd_dS)N)r!r) _update_jacrrrrrrr3r )r$rr`r rrs  r-csbjdur-jdur/jj}jjjjjj}j ||dSdSdSr&) rr^J_prevrrrrrr3ru)delta_xdelta_grir rr!s   csbj_j_tjj|djd}j |j _d_ d_ d_ dSrn)rrr^rrrArBr9rrLrMrP J_updatedrRrorrdrir rupdate_x-s z)VectorFunction.__init__..update_xcsBtjj|djd}j|j_d_d_d_ dSrn) rArBr9rrLrMrrPrrRrrir rr8s  )1r'r(rr1rrr9rArBrrCrDrErLrrMrNrOrjrrmrPrrRrr r x_diff_update_fun_impl zeros_likersrmrr*r0r+sparse_jacobianrr.r_update_jac_implr3rr]r^r_update_hess_impl_update_x_impl)r`rr2rr-rafinite_diff_jac_sparsityrbrr9rdresparsity_groupsrrrrr ) r$rrr-rrrrr`rrfns               zVectorFunction.__init__cCs"t||js||_d|_dSdS)NF)r rwrrR)r`rr r r _update_vAs zVectorFunction._update_vcCs t||js||dSdSr&)r rwrrrxr r rrqFszVectorFunction._update_xcC|js |d|_dSdSrr)rPrrir r rrVJ zVectorFunction._update_funcCrrr)rrrir r rrOrzVectorFunction._update_jaccCrrr)rRrrir r rroTrzVectorFunction._update_hesscC||||jSr&)rqrVrsrxr r rrY zVectorFunction.funcCrr&)rqrrrxr r rr^rzVectorFunction.jaccCs"||||||jSr&)rrqror3r`rrr r rr-cs  zVectorFunction.hessN) r{r|r}r~rfrrqrVrrorrr-r r r rr]sT rc@s8eZdZdZddZddZddZdd Zd d Zd S) LinearVectorFunctionzLinear 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. cCs|s |durt|rt||_d|_nt|r#||_d|_n tt||_d|_|jj \|_ |_ t ||_ }tj||d|d}|j}||jdrV|j}||||_||_|j|j|_d|_tj|j td|_t|j |j f|_dS)NTFrr7r:)rE)r*r0r+rrrr r.rshaperrOrr9rArBrCrDrErLrrMrrsrPzerosfloatrr3)r`Ar2rr9rdrer r rrfrs(   zLinearVectorFunction.__init__cCsHt||js"tj|j|d|jd}|j||j|_d|_ dSdSrn) r rwrrArBr9rrLrMrPrpr r rrqs  zLinearVectorFunction._update_xcCs*|||js|j||_d|_|jSrr)rqrPrrrsrxr r rrs zLinearVectorFunction.funcCs|||jSr&)rqrrxr r rrs zLinearVectorFunction.jaccCs||||_|jSr&)rqrr3rr r rr-s zLinearVectorFunction.hessN) r{r|r}r~rfrqrrr-r r r rrks rcs eZdZdZfddZZS)IdentityVectorFunctionzIdentity 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. csJt|}|s |durtj|dd}d}nt|}d}t|||dS)Ncsr)formatTF)lenr*eyer superrf)r`r2rrOr __class__r rrfs  zIdentityVectorFunction.__init__)r{r|r}r~rf __classcell__r r rrrsr)r )Nr N)NNr N)numpyr scipy.sparsesparser*_numdiffrr_hessian_update_strategyrscipy.sparse.linalgrscipy._lib._array_apir scipy._librrAr(rr)r4r5rrrr r r rs&        $<