o iZa@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.)npcopyZisscalarasarrayitem TypeError ValueError)xfxeargsfunncallsr b/home/kim/smarthome/.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)rrrr#rr$r )rr#rrrr _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_2dr r rr+r rrIs"rcst|fd|iSNr r!r")r#rr rr$Ssz_wrapper_hess..wrapped1r%) r&r r r)issparser* isinstancerr-r r')r,rx0rr#Hrr$r )rr#rr,rr _wrapper_hess7s      r3c@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_stepZabs_stepboundsTas_linear_operator)rrr#)r1r)rr1r#r r,r)-r&r'rr0rrr8xpx atleast_ndr float64isdtypedtyper _wrapped_fun_nfevZ _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_gradr3 _wrapped_hess_nhevr2g initializex_prevg_prev) selfrr1rrr,finite_diff_rel_stepfinite_diff_boundsepsilonr8_x_dtyper#r r r__init__s       zScalarFunction.__init__cC |jdSNr)rEr]r r rnfev zScalarFunction.nfevcCrdre)rUrfr r rngevrhzScalarFunction.ngevcCrdre)rXrfr r rnhev rhzScalarFunction.nhevcCst|jtr7||j|_|j|_tj |j |d|j d}|j ||j |_d|_d|_d|_|dStj |j |d|j d}|j ||j |_d|_d|_d|_dSNrr6F)r0rGrrVrr[rYr\r?r@r8r rIrJrMrNrO _update_hessr]rrar r r _update_xs   zScalarFunction._update_xcCs>|js||j}||jkr|j|_||_||_d|_dSdSNT)rMrDrrRrPf)r]rr r rrS%s   zScalarFunction._update_funcCs:|js|jtvr ||j|j|jd|_d|_dSdSNr>T)rNrFr'rSrTrrprYrfr r rrV/s   zScalarFunction._update_gradcCs~|js=|jtvr||j|j|jd|_n!t|jt r1||j |j|j |j|j n||j|_d|_dSdSrq) rOrGr'rVrWrrYr2r0rupdater[r\rfr r rrl6s    zScalarFunction._update_hesscC&t||js ||||jSr%)r array_equalrrnrSrpr]rr r rrC zScalarFunction.funcCrsr%)r rtrrnrVrYrur r rrIrvzScalarFunction.gradcCrsr%)r rtrrnrlr2rur r rr,OrvzScalarFunction.hesscCs4t||js |||||j|jfSr%)r rtrrnrSrVrprYrur r r fun_and_gradUs   zScalarFunction.fun_and_gradr%)__name__ __module__ __qualname____doc__rcpropertyrgrirjrnrSrVrlrrr,rwr r r rr4[s$K \      r4c@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 r5z?`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.rr6r9rFr:r;Zsparsityr<Tr=cjd7_t|SNr)rgr rr)rr]r r fun_wrappedz,VectorFunction.__init__..fun_wrappedcj_dSr%)rrpr )rr]r r update_funz+VectorFunction.__init__..update_funcr~r)njevr)r*rjacr]r r jac_wrappedrz,VectorFunction.__init__..jac_wrappedcsjd7_|Sr)rtoarrayrrr rrs cr~r)rr r-rrr rrrcrr%)rJr )rr]r r update_jacrz+VectorFunction.__init__..update_jacr c.ttjfdji_dSr.)rSr)r*rrrprr r#rr]r rr  cs,tjfdji_dSr.)rSrrrprrr rr rrs crr.)rSr r-rrrprr rr rrrcsjd7_t||Sr)rjr)r*rvr,r]r r hess_wrappedsz-VectorFunction.__init__..hess_wrappedcsjd7_||Sr)rjrrr rrs cs$jd7_tt||Sr)rjr r-r rrr rrscsjj_dSr%)rrr2r )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_jacrrrrrrr2r )r#rr]r rrs  r,csbjdur-jdur/jj}jjjjjj}j ||dSdSdSr%) rr[J_prevrrrrrr2rr)Zdelta_xZdelta_grfr rr!s   csbj_j_tjj|djd}j |j _d_ d_ d_ dSrk)rrr[rrr?r@r8r rIrJrM J_updatedrOrlrrarfr rupdate_x-s z)VectorFunction.__init__..update_xcsBtjj|djd}j|j_d_d_d_ dSrk) r?r@r8r rIrJrrMrrOrrfr rr8s  )1r&r'rr0rrr8r?r@r rArBrCrIrrJrKrLrgrrjrMrrOrr r Zx_diff_update_fun_implZ zeros_likerprmrr)r/r*sparse_jacobianrr-r_update_jac_implr2rrZr[r_update_hess_impl_update_x_impl)r]rr1rr,r^Zfinite_diff_jac_sparsityr_rr8rarbZsparsity_groupsrrrrr ) r#rrr,rrrrr]rrcns               zVectorFunction.__init__cCs"t||js||_d|_dSdS)NF)r rtrrO)r]rr r r _update_vAs zVectorFunction._update_vcCs t||js||dSdSr%)r rtrrrur r rrnFszVectorFunction._update_xcC|js |d|_dSdSro)rMrrfr r rrSJ zVectorFunction._update_funcCrro)rrrfr r rrOrzVectorFunction._update_jaccCrro)rOrrfr r rrlTrzVectorFunction._update_hesscC||||jSr%)rnrSrprur r rrY zVectorFunction.funcCrr%)rnrrrur r rr^rzVectorFunction.jaccCs"||||||jSr%)rrnrlr2r]rrr r rr,cs  zVectorFunction.hessN) rxryrzr{rcrrnrSrrlrrr,r r r rr}]sT r}c@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)NTFrr6r9)rC)r)r/r*rrrr r-r shaperrLrr8r?r@rArBrCrIrrJrrprMZzerosfloatrr2)r]Ar1rr8rarbr r rrcrs(   zLinearVectorFunction.__init__cCsHt||js"tj|j|d|jd}|j||j|_d|_ dSdSrk) r rtrr?r@r8r rIrJrMrmr r rrns  zLinearVectorFunction._update_xcCs*|||js|j||_d|_|jSro)rnrMrrrprur r rrs zLinearVectorFunction.funcCs|||jSr%)rnrrur r rrs zLinearVectorFunction.jaccCs||||_|jSr%)rnrr2rr r rr,s zLinearVectorFunction.hessN) rxryrzr{rcrnrrr,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)NZcsr)formatTF)lenr)eyer superrc)r]r1rrLr __class__r rrcs  zIdentityVectorFunction.__init__)rxryrzr{rc __classcell__r r rrrsr)r )Nr N)NNr N)numpyr Z scipy.sparsesparser)Z_numdiffrrZ_hessian_update_strategyrZscipy.sparse.linalgrZscipy._lib._array_apirZ scipy._librr?r'rr(r3r4r}rrr r r rs&        $<