a “ Àhq\ã@sŽddlZddlmZddlmZmZddlm Z ddl m Z ddl m Z mZdZGdd „d ƒZGd d „d ƒZGd d „d ƒZGdd„deƒZdS)éNé)Úapprox_derivativeÚ group_columns)ÚHessianUpdateStrategy)ÚLinearOperator)Ú atleast_ndÚarray_namespace)z2-pointz3-pointÚcsc@sReZdZdZddd„Zdd„Zdd„Zd d „Zd d „Zd d„Z dd„Z dd„Z dS)ÚScalarFunctiona©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 stˆƒs ˆtvr tdt›dƒ‚tˆƒsJˆtvsJtˆtƒsJtdt›dƒ‚ˆtvrbˆtvrbtdƒ‚t|ƒˆ_} t|d| d} | j} |   | j d¡r˜| j } |   | | ¡ˆ_ | ˆ_ ˆj jˆ_dˆ_dˆ_dˆ_d ˆ_d ˆ_d ˆ_dˆ_tjˆ_i‰ˆtvrˆˆd <|ˆd <|ˆd <|ˆd <ˆtvr@ˆˆd <|ˆd <|ˆd <dˆd<‡‡‡fdd„‰‡‡fdd„} | ˆ_ˆ ¡tˆƒr–‡‡‡fdd„‰‡‡fdd„} nˆtvr°‡‡‡fdd„} | ˆ_ˆ ¡tˆƒrvˆt |¡gˆ¢RŽˆ_dˆ_ˆjd7_t  !ˆj¡r"‡‡‡fdd„‰t  "ˆj¡ˆ_nDtˆjt#ƒrB‡‡‡fdd„‰n$‡‡‡fdd„‰t $t %ˆj¡¡ˆ_‡‡fdd„}nhˆtvrž‡‡‡fdd„}|ƒdˆ_n@tˆtƒrÞˆˆ_ˆj &ˆjd ¡dˆ_dˆ_'dˆ_(‡fd!d„}|ˆ_)tˆtƒrþ‡fd"d#„}n ‡fd$d#„}|ˆ_*dS)%Nz)`grad` must be either callable or one of Ú.z@`hess` must be either callable, HessianUpdateStrategy or one of z‹Whenever the gradient is estimated via finite-differences, we require the Hessian to be estimated using one of the quasi-Newton strategies.r©ÚndimÚxpú real floatingrFÚmethodÚrel_stepZabs_stepÚboundsTÚas_linear_operatorc sŽˆjd7_ˆt |¡gˆ¢RŽ}t |¡stzt |¡ ¡}Wn2ttfyr}ztdƒ|‚WYd}~n d}~00|ˆjkrŠ|ˆ_ |ˆ_|S)Nrz@The user-provided objective function must return a scalar value.) ÚnfevÚnpÚcopyZisscalarÚasarrayÚitemÚ TypeErrorÚ ValueErrorÚ _lowest_fÚ _lowest_x)ÚxZfxÚe)ÚargsÚfunÚself©úd/var/www/html/assistant/venv/lib/python3.9/site-packages/scipy/optimize/_differentiable_functions.pyÚ fun_wrappedŒs ÿý z,ScalarFunction.__init__..fun_wrappedcsˆˆjƒˆ_dS©N©rÚfr"©r$r!r"r#Ú update_fun¢sz+ScalarFunction.__init__..update_funcs*ˆjd7_t ˆt |¡gˆ¢RŽ¡S©Nr)ÚngevrÚ atleast_1dr©r)rÚgradr!r"r#Ú grad_wrappedªsz-ScalarFunction.__init__..grad_wrappedcsˆˆjƒˆ_dSr%)rÚgr")r/r!r"r#Ú update_grad®sz,ScalarFunction.__init__..update_gradcs6ˆ ¡ˆjd7_tˆˆjfdˆjiˆ¤Žˆ_dS)NrÚf0)Ú _update_funr+rrr'r0r"©Úfinite_diff_optionsr$r!r"r#r1²s ÿcs*ˆjd7_t ˆt |¡gˆ¢RŽ¡Sr*)ÚnhevÚspsÚ csr_matrixrrr-©rÚhessr!r"r#Ú hess_wrappedÂsz-ScalarFunction.__init__..hess_wrappedcs$ˆjd7_ˆt |¡gˆ¢RŽSr*)r6rrr-r9r"r#r;Èscs0ˆjd7_t t ˆt |¡gˆ¢RŽ¡¡Sr*)r6rÚ atleast_2drrr-r9r"r#r;Íscsˆˆjƒˆ_dSr%)rÚHr"©r;r!r"r#Ú update_hessÒsz,ScalarFunction.__init__..update_hesscs*ˆ ¡tˆˆjfdˆjiˆ¤Žˆ_ˆjS©Nr2)Ú _update_gradrrr0r=r")r5r/r!r"r#r?Ös ÿr:cs*ˆ ¡ˆj ˆjˆjˆjˆj¡dSr%)rAr=ÚupdaterÚx_prevr0Úg_prevr"©r!r"r#r?åscsXˆ ¡ˆjˆ_ˆjˆ_t|dˆjd}ˆj |ˆj¡ˆ_dˆ_ dˆ_ dˆ_ ˆ  ¡dS©Nrr F) rArrCr0rDrrÚastypeÚx_dtypeÚ f_updatedÚ g_updatedÚ H_updatedÚ _update_hess©rÚ_xrEr"r#Úupdate_xìsz)ScalarFunction.__init__..update_xcs8t|dˆjd}ˆj |ˆj¡ˆ_dˆ_dˆ_dˆ_dSrF)rrrGrHrrIrJrKrMrEr"r#rOús )+ÚcallableÚ FD_METHODSrÚ isinstancerrrrÚfloat64ÚisdtypeÚdtyperGrrHÚsizeÚnrr+r6rIrJrKrrÚinfrÚ_update_fun_implr3Ú_update_grad_implrArr=r7Úissparser8rr<rÚ initializerCrDÚ_update_hess_implÚ_update_x_impl)r!r Úx0rr.r:Úfinite_diff_rel_stepÚfinite_diff_boundsÚepsilonrrNÚ_dtyper)r1r?rOr") rr5r r$r.r/r:r;r!r#Ú__init__Ws  ÿÿÿÿ           zScalarFunction.__init__cCs|js| ¡d|_dS©NT©rIrYrEr"r"r#r3szScalarFunction._update_funcCs|js| ¡d|_dSre)rJrZrEr"r"r#rA szScalarFunction._update_gradcCs|js| ¡d|_dSre©rKr]rEr"r"r#rLszScalarFunction._update_hesscCs&t ||j¡s| |¡| ¡|jSr%)rÚ array_equalrr^r3r'©r!rr"r"r#r s zScalarFunction.funcCs&t ||j¡s| |¡| ¡|jSr%)rrhrr^rAr0rir"r"r#r.s zScalarFunction.gradcCs&t ||j¡s| |¡| ¡|jSr%)rrhrr^rLr=rir"r"r#r:s zScalarFunction.hesscCs4t ||j¡s| |¡| ¡| ¡|j|jfSr%)rrhrr^r3rAr'r0rir"r"r#Ú fun_and_grad%s  zScalarFunction.fun_and_grad)N) Ú__name__Ú __module__Ú __qualname__Ú__doc__rdr3rArLr r.r:rjr"r"r"r#r sKÿ .r c@sXeZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dd„Z dd„Z dS)ÚVectorFunctiona‘Vector 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 s¦tˆƒs ˆtvr tdt›dƒ‚tˆƒsJˆtvsJtˆtƒsJtdt›dƒ‚ˆtvrbˆtvrbtdƒ‚t|ƒˆ_} t|d| d} | j} |   | j d¡r˜| j } |   | | ¡ˆ_ | ˆ_ ˆj jˆ_dˆ_dˆ_dˆ_d ˆ_d ˆ_d ˆ_i‰ˆtvr,ˆˆd <|ˆd <|durt|ƒ} || fˆd <|ˆd <t ˆj ¡ˆ_ˆtvr\ˆˆd <|ˆd <dˆd<t ˆj ¡ˆ_ˆtvrxˆtvrxtdƒ‚‡‡fdd„‰‡‡fdd„} | ˆ_| ƒt ˆj¡ˆ_ˆjjˆ_tˆƒr†ˆˆj ƒˆ_dˆ_ˆjd7_|s|dur$t  !ˆj¡r$‡‡fdd„‰t  "ˆj¡ˆ_dˆ_#nRt  !ˆj¡rT‡‡fdd„‰ˆj $¡ˆ_d ˆ_#n"‡‡fdd„‰t %ˆj¡ˆ_d ˆ_#‡‡fdd„}nƈtvrLt&ˆˆj fdˆjiˆ¤Žˆ_dˆ_|sÐ|duröt  !ˆj¡rö‡‡‡fdd„}t  "ˆj¡ˆ_dˆ_#nVt  !ˆj¡r(‡‡‡fdd„}ˆj $¡ˆ_d ˆ_#n$‡‡‡fdd„}t %ˆj¡ˆ_d ˆ_#|ˆ_'tˆƒrüˆˆj ˆjƒˆ_(dˆ_ˆjd7_t  !ˆj(¡r¬‡‡fdd„‰t  "ˆj(¡ˆ_(n@tˆj(t)ƒrʇ‡fd d„‰n"‡‡fd!d„‰t %t *ˆj(¡¡ˆ_(‡‡fd"d#„}ntˆtvr0‡fd$d%„‰‡‡‡fd&d#„}|ƒdˆ_n@tˆtƒrpˆˆ_(ˆj( +ˆjd'¡dˆ_dˆ_,dˆ_-‡fd(d#„}|ˆ_.tˆtƒr‡fd)d*„}n ‡fd+d*„}|ˆ_/dS),Nz(`jac` must be either callable or one of r z?`hess` must be either callable,HessianUpdateStrategy or one of z‹Whenever the Jacobian is estimated via finite-differences, we require the Hessian to be estimated using one of the quasi-Newton strategies.rr rrFrrZsparsityrTrcsˆjd7_t ˆ|ƒ¡Sr*)rrr,r-)r r!r"r#r$wsz,VectorFunction.__init__..fun_wrappedcsˆˆjƒˆ_dSr%r&r"r(r"r#r){sz+VectorFunction.__init__..update_funcsˆjd7_t ˆ|ƒ¡Sr*)Únjevr7r8r-©Újacr!r"r#Ú jac_wrappedŒsz,VectorFunction.__init__..jac_wrappedcsˆjd7_ˆ|ƒ ¡Sr*)rpÚtoarrayr-rqr"r#rs“scsˆjd7_t ˆ|ƒ¡Sr*)rprr<r-rqr"r#rsšscsˆˆjƒˆ_dSr%)rÚJr")rsr!r"r#Ú update_jac sz+VectorFunction.__init__..update_jacr2cs.ˆ ¡t tˆˆjfdˆjiˆ¤Ž¡ˆ_dSr@)r3r7r8rrr'rur"r4r"r#rvªs ÿÿcs,ˆ ¡tˆˆjfdˆjiˆ¤Ž ¡ˆ_dSr@)r3rrr'rtrur"r4r"r#rv³sÿcs.ˆ ¡t tˆˆjfdˆjiˆ¤Ž¡ˆ_dSr@)r3rr<rrr'rur"r4r"r#rv»s ÿÿcsˆjd7_t ˆ||ƒ¡Sr*)r6r7r8©rÚv©r:r!r"r#r;Ìsz-VectorFunction.__init__..hess_wrappedcsˆjd7_ˆ||ƒSr*)r6rwryr"r#r;Òscs$ˆjd7_t t ˆ||ƒ¡¡Sr*)r6rr<rrwryr"r#r;×scsˆˆjˆjƒˆ_dSr%)rrxr=r"r>r"r#r?Üsz,VectorFunction.__init__..update_hesscsˆ|ƒj |¡Sr%)ÚTÚdotrw)rsr"r#Ú jac_dot_vßsz*VectorFunction.__init__..jac_dot_vcs8ˆ ¡tˆˆjfˆjj ˆj¡ˆjfdœˆ¤Žˆ_dS)N)r2r)Ú _update_jacrrrurzr{rxr=r")r5r|r!r"r#r?âs þýr:csZˆ ¡ˆjdurVˆjdurVˆjˆj}ˆjj ˆj¡ˆjj ˆj¡}ˆj  ||¡dSr%) r}rCÚJ_prevrrurzr{rxr=rB)Zdelta_xZdelta_grEr"r#r?ñs   csXˆ ¡ˆjˆ_ˆjˆ_t|dˆjd}ˆj |ˆj¡ˆ_dˆ_ dˆ_ dˆ_ ˆ  ¡dSrF) r}rrCrur~rrrGrHrIÚ J_updatedrKrLrMrEr"r#rOýsz)VectorFunction.__init__..update_xcs8t|dˆjd}ˆj |ˆj¡ˆ_dˆ_dˆ_dˆ_dSrF)rrrGrHrrIrrKrMrEr"r#rOs )0rPrQrrRrrrrrSrTrUrGrrHrVrWrrpr6rIrrKrrrZx_diffrYZ zeros_liker'rxÚmrur7r[r8Úsparse_jacobianrtr<rÚ_update_jac_implr=rrr\rCr~r]r^)r!r r_rrr:r`Zfinite_diff_jac_sparsityrarrrNrcZsparsity_groupsr)rvr?rOr") r5r r$r:r;rrr|rsr!r#rd>sìÿÿ    ÿ    ÿ ÿ  ÿÿ ÿ        zVectorFunction.__init__cCst ||j¡s||_d|_dS)NF)rrhrxrK)r!rxr"r"r#Ú _update_vszVectorFunction._update_vcCst ||j¡s| |¡dSr%)rrhrr^rir"r"r#Ú _update_xszVectorFunction._update_xcCs|js| ¡d|_dSrerfrEr"r"r#r3szVectorFunction._update_funcCs|js| ¡d|_dSre)rr‚rEr"r"r#r}szVectorFunction._update_jaccCs|js| ¡d|_dSrergrEr"r"r#rL$szVectorFunction._update_hesscCs| |¡| ¡|jSr%)r„r3r'rir"r"r#r )s zVectorFunction.funcCs| |¡| ¡|jSr%)r„r}rurir"r"r#rr.s zVectorFunction.jaccCs"| |¡| |¡| ¡|jSr%)rƒr„rLr=©r!rrxr"r"r#r:3s  zVectorFunction.hessN) rkrlrmrnrdrƒr„r3r}rLr rrr:r"r"r"r#ro-sTroc@s8eZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd S) ÚLinearVectorFunctionzüLinear 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|dur*t |¡r*t |¡|_d|_n4t |¡rF| ¡|_d|_nt t |¡¡|_d|_|jj \|_ |_ t |ƒ|_ }t|d|d}|j}| |jd¡r¤|j}| ||¡|_||_|j |j¡|_d|_tj|j td|_t |j |j f¡|_dS)NTFrr r)rU)r7r[r8rurrtrr<rÚshaper€rWrrrrSrTrUrGrrHr{r'rIZzerosÚfloatrxr=)r!ÚAr_rrrNrcr"r"r#rdBs(   zLinearVectorFunction.__init__cCs:t ||j¡s6t|d|jd}|j ||j¡|_d|_dSrF)rrhrrrrGrHrI)r!rrNr"r"r#r„`szLinearVectorFunction._update_xcCs*| |¡|js$|j |¡|_d|_|jSre)r„rIrur{r'rir"r"r#r fs  zLinearVectorFunction.funcCs| |¡|jSr%)r„rurir"r"r#rrms zLinearVectorFunction.jaccCs| |¡||_|jSr%)r„rxr=r…r"r"r#r:qs zLinearVectorFunction.hessN) rkrlrmrnrdr„r rrr:r"r"r"r#r†;s r†cs eZdZdZ‡fdd„Z‡ZS)ÚIdentityVectorFunctionzþIdentity 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|dur(tj|dd}d}nt |¡}d}tƒ |||¡dS)NZcsr)ÚformatTF)Úlenr7ÚeyerÚsuperrd)r!r_rrWr‰©Ú __class__r"r#rd~s  zIdentityVectorFunction.__init__)rkrlrmrnrdÚ __classcell__r"r"rr#rŠwsrŠ)ÚnumpyrZ scipy.sparseÚsparser7Z_numdiffrrZ_hessian_update_strategyrZscipy.sparse.linalgrZscipy._lib._array_apirrrQr ror†rŠr"r"r"r#Ús   #<