U ¤»|e¿Xã@s~ddlZddlmZddlmZmZddlm Z ddl m Z dZ Gdd„dƒZ Gd d „d ƒZGd d „d ƒZGd d„deƒZdS)éNé)Úapprox_derivativeÚ group_columns)ÚHessianUpdateStrategy)ÚLinearOperator)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 sØtˆƒs ˆtkr tdt›dƒ‚tˆƒsJˆtksJtˆtƒsJtdt›dƒ‚ˆtkrbˆtkrbtdƒ‚t |¡ t¡ˆ_ ˆj j ˆ_ dˆ_ dˆ_ dˆ_dˆ_dˆ_dˆ_dˆ_tjˆ_i‰ˆtkr܈ˆd<|ˆd<|ˆd <|ˆd <ˆtkrˆˆd<|ˆd<|ˆd <d ˆd <‡‡‡fd d„‰‡‡fdd„} | ˆ_ˆ ¡tˆƒr\‡‡‡fdd„‰‡‡fdd„} nˆtkrv‡‡‡fdd„} | ˆ_ˆ ¡tˆƒr:ˆt |¡fˆžŽˆ_d ˆ_ˆjd7_t ˆj¡r懇‡fdd„‰t ˆj¡ˆ_nDtˆjtƒr‡‡‡fdd„‰n$‡‡‡fdd„‰t t  ˆj¡¡ˆ_‡‡fdd„} nhˆtkrb‡‡‡fdd„} | ƒd ˆ_n@tˆtƒr¢ˆˆ_ˆj !ˆj d¡d ˆ_dˆ_"dˆ_#‡fdd„} | ˆ_$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.rFÚmethodÚrel_stepÚabs_stepÚboundsTÚas_linear_operatorc sŠˆjd7_ˆt |¡fˆžŽ}t |¡spzt |¡ ¡}Wn0ttfk rn}ztdƒ|‚W5d}~XYnX|ˆjkr†|ˆ_ |ˆ_|S)Nrz@The user-provided objective function must return a scalar value.) ÚnfevÚnpÚcopyÚisscalarÚasarrayÚitemÚ TypeErrorÚ ValueErrorÚ _lowest_fÚ _lowest_x)ÚxÚfxÚe)ÚargsÚfunÚself©úe/var/www/website-v5/atlas_env/lib/python3.8/site-packages/scipy/optimize/_differentiable_functions.pyÚ fun_wrapped„s ÿý z,ScalarFunction.__init__..fun_wrappedcsˆˆjƒˆ_dS©N©rÚfr©r!rrr Ú update_funšsz+ScalarFunction.__init__..update_funcs(ˆjd7_t ˆt |¡fˆžŽ¡S©Nr)ÚngevrÚ atleast_1dr©r)rÚgradrrr Ú grad_wrapped¢sz-ScalarFunction.__init__..grad_wrappedcsˆˆjƒˆ_dSr")rÚgr)r,rrr Ú update_grad¦sz,ScalarFunction.__init__..update_gradcs6ˆ ¡ˆjd7_tˆˆjfdˆjiˆ—Žˆ_dS)NrÚf0)Ú _update_funr(rrr$r-r©Úfinite_diff_optionsr!rrr r.ªs ÿrcs(ˆjd7_t ˆt |¡fˆžŽ¡Sr')ÚnhevÚspsÚ csr_matrixrrr*©rÚhessrrr Ú hess_wrappedºsz-ScalarFunction.__init__..hess_wrappedcs"ˆjd7_ˆt |¡fˆžŽSr')r3rrr*r6rr r8Àscs.ˆjd7_t t ˆt |¡fˆžŽ¡¡Sr')r3rÚ atleast_2drrr*r6rr r8Åscsˆˆjƒˆ_dSr")rÚHr©r8rrr Ú update_hessÊsz,ScalarFunction.__init__..update_hesscs*ˆ ¡tˆˆjfdˆjiˆ—Žˆ_ˆjS©Nr/)Ú _update_gradrrr-r:r)r2r,rrr r<Îs ÿr7cs*ˆ ¡ˆj ˆjˆjˆjˆj¡dSr")r>r:ÚupdaterÚx_prevr-Úg_prevr©rrr r<ÝscsHˆ ¡ˆjˆ_ˆjˆ_t |¡ t¡ˆ_dˆ_ dˆ_ dˆ_ ˆ  ¡dS©NF) r>rr@r-rArr)ÚastypeÚfloatÚ f_updatedÚ g_updatedÚ H_updatedÚ _update_hessr*rBrr Úupdate_xäsz)ScalarFunction.__init__..update_xcs(t |¡ t¡ˆ_dˆ_dˆ_dˆ_dSrC)rr)rDrErrFrGrHr*rBrr rJðs)&ÚcallableÚ FD_METHODSrÚ isinstancerrr)rDrErÚsizeÚnrr(r3rFrGrHrÚinfrÚ_update_fun_implr0Ú_update_grad_implr>rr:r4Úissparser5rr9rÚ initializer@rAÚ_update_hess_implÚ_update_x_impl) rrÚx0rr+r7Úfinite_diff_rel_stepÚfinite_diff_boundsÚepsilonr&r.r<rJr) rr2rr!r+r,r7r8rr Ú__init__Vs ÿÿ ÿ          zScalarFunction.__init__cCs|js| ¡d|_dS©NT©rFrQrBrrr r0ùszScalarFunction._update_funcCs|js| ¡d|_dSr\)rGrRrBrrr r>þszScalarFunction._update_gradcCs|js| ¡d|_dSr\©rHrUrBrrr rIszScalarFunction._update_hesscCs&t ||j¡s| |¡| ¡|jSr")rÚ array_equalrrVr0r$©rrrrr rs zScalarFunction.funcCs&t ||j¡s| |¡| ¡|jSr")rr_rrVr>r-r`rrr r+s zScalarFunction.gradcCs&t ||j¡s| |¡| ¡|jSr")rr_rrVrIr:r`rrr r7s zScalarFunction.hesscCs4t ||j¡s| |¡| ¡| ¡|j|jfSr")rr_rrVr0r>r$r-r`rrr Ú fun_and_grads  zScalarFunction.fun_and_grad)N) Ú__name__Ú __module__Ú __qualname__Ú__doc__r[r0r>rIrr+r7rarrrr r sKÿ $rc@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 sftˆƒsˆtkrtd t¡ƒ‚tˆƒsFˆtksFtˆtƒsFtd t¡ƒ‚ˆtkr^ˆtkr^tdƒ‚t |¡ t ¡ˆ_ ˆj j ˆ_ dˆ_ dˆ_dˆ_dˆ_dˆ_dˆ_i‰ˆtkr숈d<|ˆd<|dk rÖt|ƒ} || fˆd<|ˆd <t ˆj ¡ˆ_ˆtkrˆˆd<|ˆd<d ˆd <t ˆj ¡ˆ_ˆtkr8ˆtkr8tdƒ‚‡‡fd d „‰‡‡fdd„} | ˆ_| ƒt ˆj¡ˆ_ˆjj ˆ_tˆƒrFˆˆj ƒˆ_d ˆ_ˆjd7_|sÀ|dkrät ˆj¡r䇇fdd„‰t ˆj¡ˆ_d ˆ_nRt ˆj¡r‡‡fdd„‰ˆj  ¡ˆ_dˆ_n"‡‡fdd„‰t !ˆj¡ˆ_dˆ_‡‡fdd„} nƈtkr t"ˆˆj fdˆjiˆ—Žˆ_d ˆ_|s|dkr¶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$¡rl‡‡fdd„‰t ˆj$¡ˆ_$n@tˆj$t%ƒrŠ‡‡fdd„‰n"‡‡fdd„‰t !t &ˆj$¡¡ˆ_$‡‡fdd „} ntˆtkrð‡fd!d"„‰‡‡‡fd#d „} | ƒd ˆ_n@tˆtƒr0ˆˆ_$ˆj$ 'ˆj d$¡d ˆ_dˆ_(dˆ_)‡fd%d „} | ˆ_*tˆtƒrP‡fd&d'„} n ‡fd(d'„} | ˆ_+dS))Nz+`jac` must be either callable or one of {}.zB`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.rFr r Úsparsityr Trcsˆjd7_t ˆ|ƒ¡Sr')rrr)r*)rrrr r!esz,VectorFunction.__init__..fun_wrappedcsˆˆjƒˆ_dSr"r#rr%rr r&isz+VectorFunction.__init__..update_funrcsˆjd7_t ˆ|ƒ¡Sr')Únjevr4r5r*©Újacrrr Ú jac_wrappedzsz,VectorFunction.__init__..jac_wrappedcsˆjd7_ˆ|ƒ ¡Sr')rhÚtoarrayr*rirr rkscsˆjd7_t ˆ|ƒ¡Sr')rhrr9r*rirr rkˆscsˆˆjƒˆ_dSr")rÚJr)rkrrr Ú update_jacŽsz+VectorFunction.__init__..update_jacr/cs.ˆ ¡t tˆˆjfdˆjiˆ—Ž¡ˆ_dSr=)r0r4r5rrr$rmrr1rr rn˜s ÿÿcs,ˆ ¡tˆˆjfdˆjiˆ—Ž ¡ˆ_dSr=)r0rrr$rlrmrr1rr rn¡sÿcs.ˆ ¡t tˆˆjfdˆjiˆ—Ž¡ˆ_dSr=)r0rr9rrr$rmrr1rr rn©s ÿÿcsˆjd7_t ˆ||ƒ¡Sr')r3r4r5©rÚv©r7rrr r8ºsz-VectorFunction.__init__..hess_wrappedcsˆjd7_ˆ||ƒSr')r3rorqrr r8Àscs$ˆjd7_t t ˆ||ƒ¡¡Sr')r3rr9rrorqrr r8Åscsˆˆjˆjƒˆ_dSr")rrpr:rr;rr r<Êsz,VectorFunction.__init__..update_hesscsˆ|ƒj |¡Sr")ÚTÚdotro)rkrr Ú jac_dot_vÍsz*VectorFunction.__init__..jac_dot_vcs8ˆ ¡tˆˆjfˆjj ˆj¡ˆjfdœˆ—Žˆ_dS)N)r/r)Ú _update_jacrrrmrrrsrpr:r)r2rtrrr r<Ðs þýr7csZˆ ¡ˆjdk rVˆjdk rVˆjˆj}ˆjj ˆj¡ˆjj ˆj¡}ˆj  ||¡dSr") rur@ÚJ_prevrrmrrrsrpr:r?)Údelta_xZdelta_grBrr r<ßs   csHˆ ¡ˆjˆ_ˆjˆ_t |¡ t¡ˆ_dˆ_ dˆ_ dˆ_ ˆ  ¡dSrC) rurr@rmrvrr)rDrErFÚ J_updatedrHrIr*rBrr rJësz)VectorFunction.__init__..update_xcs(t |¡ t¡ˆ_dˆ_dˆ_dˆ_dSrC)rr)rDrErrFrxrHr*rBrr rJõs),rKrLrÚformatrMrrr)rDrErrNrOrrhr3rFrxrHrrZx_diffrQÚ zeros_liker$rpÚmrmr4rSr5Úsparse_jacobianrlr9rÚ_update_jac_implr:rrrTr@rvrUrV)rrrWrjr7rXZfinite_diff_jac_sparsityrYr|Zsparsity_groupsr&rnr<rJr) r2rr!r7r8rjrtrkrr r[3säÿÿþ ÿ    ÿ ÿ  ÿÿ ÿ        zVectorFunction.__init__cCst ||j¡s||_d|_dSrC)rr_rprH)rrprrr Ú _update_výszVectorFunction._update_vcCst ||j¡s| |¡dSr")rr_rrVr`rrr Ú _update_xszVectorFunction._update_xcCs|js| ¡d|_dSr\r]rBrrr r0szVectorFunction._update_funcCs|js| ¡d|_dSr\)rxr}rBrrr ru szVectorFunction._update_jaccCs|js| ¡d|_dSr\r^rBrrr rIszVectorFunction._update_hesscCs| |¡| ¡|jSr")rr0r$r`rrr rs zVectorFunction.funcCs| |¡| ¡|jSr")rrurmr`rrr rjs zVectorFunction.jaccCs"| |¡| |¡| ¡|jSr")r~rrIr:©rrrprrr r7s  zVectorFunction.hessN) rbrcrdrer[r~rr0rurIrrjr7rrrr rf"sKrfc@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|dkr*t |¡r*t |¡|_d|_n4t |¡rF| ¡|_d|_nt t |¡¡|_d|_|jj \|_ |_ t  |¡  t¡|_|j |j¡|_d|_tj|j td|_t |j |j f¡|_dS)NTF)Údtype)r4rSr5rmr|rlrr9rÚshaper{rOr)rDrErrsr$rFÚzerosrpr:)rÚArWr|rrr r[.s   zLinearVectorFunction.__init__cCs*t ||j¡s&t |¡ t¡|_d|_dSrC)rr_rr)rDrErFr`rrr rCszLinearVectorFunction._update_xcCs*| |¡|js$|j |¡|_d|_|jSr\)rrFrmrsr$r`rrr rHs  zLinearVectorFunction.funcCs| |¡|jSr")rrmr`rrr rjOs zLinearVectorFunction.jaccCs| |¡||_|jSr")rrpr:r€rrr r7Ss zLinearVectorFunction.hessN) rbrcrdrer[rrrjr7rrrr r's rcs 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|dkr(tj|dd}d}nt |¡}d}tƒ |||¡dS)NÚcsr)ryTF)Úlenr4ÚeyerÚsuperr[)rrWr|rOr…©Ú __class__rr r[`s  zIdentityVectorFunction.__init__)rbrcrdrer[Ú __classcell__rrr‹r r†Ysr†)ÚnumpyrÚ scipy.sparseÚsparser4Ú_numdiffrrÚ_hessian_update_strategyrÚscipy.sparse.linalgrrLrrfrr†rrrr Ús   2