U Gv f¿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_stepZabs_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ÚcopyZisscalarÚasarrayÚitemÚ TypeErrorÚ ValueErrorÚ _lowest_fÚ _lowest_x)ÚxZfxÚe)ÚargsÚfunÚself©úL/tmp/pip-unpacked-wheel-96ln3f52/scipy/optimize/_differentiable_functions.pyÚ fun_wrapped„s ÿý z,ScalarFunction.__init__..fun_wrappedcsˆˆjƒˆ_dS©N©rÚfr©rrrrÚ 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_optionsrrrrr+ªs ÿrcs(ˆjd7_t ˆt |¡fˆžŽ¡Sr$)ÚnhevÚspsÚ csr_matrixrrr'©rÚhessrrrÚ hess_wrappedºsz-ScalarFunction.__init__..hess_wrappedcs"ˆjd7_ˆt |¡fˆžŽSr$)r0rrr'r3rrr5Àscs.ˆjd7_t t ˆt |¡fˆžŽ¡¡Sr$)r0rÚ atleast_2drrr'r3rrr5Åscsˆˆjƒˆ_dSr)rÚHr©r5rrrÚ update_hessÊsz,ScalarFunction.__init__..update_hesscs*ˆ ¡tˆˆjfdˆjiˆ—Žˆ_ˆjS©Nr,)Ú _update_gradrrr*r7r)r/r)rrrr9Îs ÿr4cs*ˆ ¡ˆj ˆjˆjˆjˆj¡dSr)r;r7ÚupdaterÚx_prevr*Úg_prevr©rrrr9ÝscsHˆ ¡ˆjˆ_ˆjˆ_t |¡ t¡ˆ_dˆ_ dˆ_ dˆ_ ˆ  ¡dS©NF) r;rr=r*r>rr&ÚastypeÚfloatÚ f_updatedÚ g_updatedÚ H_updatedÚ _update_hessr'r?rrÚupdate_xäsz)ScalarFunction.__init__..update_xcs(t |¡ t¡ˆ_dˆ_dˆ_dˆ_dSr@)rr&rArBrrCrDrEr'r?rrrGðs)&ÚcallableÚ FD_METHODSrÚ isinstancerrr&rArBrÚsizeÚnrr%r0rCrDrErÚinfrÚ_update_fun_implr-Ú_update_grad_implr;rr7r1Úissparser2rr6rÚ initializer=r>Ú_update_hess_implÚ_update_x_impl) rrÚx0rr(r4Úfinite_diff_rel_stepÚfinite_diff_boundsÚepsilonr#r+r9rGr) rr/rrr(r)r4r5rrÚ__init__Vs ÿÿ ÿ          zScalarFunction.__init__cCs|js| ¡d|_dS©NT©rCrNr?rrrr-ùszScalarFunction._update_funcCs|js| ¡d|_dSrY)rDrOr?rrrr;þszScalarFunction._update_gradcCs|js| ¡d|_dSrY©rErRr?rrrrFszScalarFunction._update_hesscCs&t ||j¡s| |¡| ¡|jSr)rÚ array_equalrrSr-r!©rrrrrrs zScalarFunction.funcCs&t ||j¡s| |¡| ¡|jSr)rr\rrSr;r*r]rrrr(s zScalarFunction.gradcCs&t ||j¡s| |¡| ¡|jSr)rr\rrSrFr7r]rrrr4s zScalarFunction.hesscCs4t ||j¡s| |¡| ¡| ¡|j|jfSr)rr\rrSr-r;r!r*r]rrrÚ fun_and_grads  zScalarFunction.fun_and_grad)N) Ú__name__Ú __module__Ú __qualname__Ú__doc__rXr-r;rFrr(r4r^rrrrr 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 Zsparsityr Tr csˆjd7_t ˆ|ƒ¡Sr$)rrr&r')rrrrresz,VectorFunction.__init__..fun_wrappedcsˆˆjƒˆ_dSrr rr"rrr#isz+VectorFunction.__init__..update_funrcsˆjd7_t ˆ|ƒ¡Sr$)Únjevr1r2r'©ÚjacrrrÚ jac_wrappedzsz,VectorFunction.__init__..jac_wrappedcsˆjd7_ˆ|ƒ ¡Sr$)rdÚtoarrayr'rerrrgscsˆjd7_t ˆ|ƒ¡Sr$)rdrr6r'rerrrgˆscsˆˆjƒˆ_dSr)rÚJr)rgrrrÚ update_jacŽsz+VectorFunction.__init__..update_jacr,cs.ˆ ¡t tˆˆjfdˆjiˆ—Ž¡ˆ_dSr:)r-r1r2rrr!rirr.rrrj˜s ÿÿcs,ˆ ¡tˆˆjfdˆjiˆ—Ž ¡ˆ_dSr:)r-rrr!rhrirr.rrrj¡sÿcs.ˆ ¡t tˆˆjfdˆjiˆ—Ž¡ˆ_dSr:)r-rr6rrr!rirr.rrrj©s ÿÿcsˆjd7_t ˆ||ƒ¡Sr$)r0r1r2©rÚv©r4rrrr5ºsz-VectorFunction.__init__..hess_wrappedcsˆjd7_ˆ||ƒSr$)r0rkrmrrr5Àscs$ˆjd7_t t ˆ||ƒ¡¡Sr$)r0rr6rrkrmrrr5Åscsˆˆjˆjƒˆ_dSr)rrlr7rr8rrr9Êsz,VectorFunction.__init__..update_hesscsˆ|ƒj |¡Sr)ÚTÚdotrk)rgrrÚ jac_dot_vÍsz*VectorFunction.__init__..jac_dot_vcs8ˆ ¡tˆˆjfˆjj ˆj¡ˆjfdœˆ—Žˆ_dS)N)r,r)Ú _update_jacrrrirnrorlr7r)r/rprrrr9Ðs þýr4csZˆ ¡ˆjdk rVˆjdk rVˆjˆj}ˆjj ˆj¡ˆjj ˆj¡}ˆj  ||¡dSr) rqr=ÚJ_prevrrirnrorlr7r<)Zdelta_xZdelta_gr?rrr9ßs   csHˆ ¡ˆjˆ_ˆjˆ_t |¡ t¡ˆ_dˆ_ dˆ_ dˆ_ ˆ  ¡dSr@) rqrr=rirrrr&rArBrCÚ J_updatedrErFr'r?rrrGësz)VectorFunction.__init__..update_xcs(t |¡ t¡ˆ_dˆ_dˆ_dˆ_dSr@)rr&rArBrrCrsrEr'r?rrrGõs),rHrIrÚformatrJrrr&rArBrrKrLrrdr0rCrsrErrZx_diffrNZ zeros_liker!rlÚmrir1rPr2Úsparse_jacobianrhr6rÚ_update_jac_implr7rrrQr=rrrRrS)rrrTrfr4rUZfinite_diff_jac_sparsityrVrvZsparsity_groupsr#rjr9rGr) r/rrr4r5rfrprgrrrX3säÿÿþ ÿ    ÿ ÿ  ÿÿ ÿ        zVectorFunction.__init__cCst ||j¡s||_d|_dSr@)rr\rlrE)rrlrrrÚ _update_výszVectorFunction._update_vcCst ||j¡s| |¡dSr)rr\rrSr]rrrÚ _update_xszVectorFunction._update_xcCs|js| ¡d|_dSrYrZr?rrrr-szVectorFunction._update_funcCs|js| ¡d|_dSrY)rsrwr?rrrrq szVectorFunction._update_jaccCs|js| ¡d|_dSrYr[r?rrrrFszVectorFunction._update_hesscCs| |¡| ¡|jSr)ryr-r!r]rrrrs zVectorFunction.funcCs| |¡| ¡|jSr)ryrqrir]rrrrfs zVectorFunction.jaccCs"| |¡| |¡| ¡|jSr)rxryrFr7©rrrlrrrr4s  zVectorFunction.hessN) r_r`rarbrXrxryr-rqrFrrfr4rrrrrc"sKrcc@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)Zdtype)r1rPr2rirvrhrr6rÚshaperurLr&rArBrror!rCÚzerosrlr7)rÚArTrvrrrrX.s   zLinearVectorFunction.__init__cCs*t ||j¡s&t |¡ t¡|_d|_dSr@)rr\rr&rArBrCr]rrrryCszLinearVectorFunction._update_xcCs*| |¡|js$|j |¡|_d|_|jSrY)ryrCriror!r]rrrrHs  zLinearVectorFunction.funcCs| |¡|jSr)ryrir]rrrrfOs zLinearVectorFunction.jaccCs| |¡||_|jSr)ryrlr7rzrrrr4Ss zLinearVectorFunction.hessN) r_r`rarbrXryrrfr4rrrrr{'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|dkr(tj|dd}d}nt |¡}d}tƒ |||¡dS)NZcsr)rtTF)Úlenr1ZeyerÚsuperrX)rrTrvrLr~©Ú __class__rrrX`s  zIdentityVectorFunction.__init__)r_r`rarbrXÚ __classcell__rrr‚rrYsr)ZnumpyrZ scipy.sparseÚsparser1Z_numdiffrrZ_hessian_update_strategyrZscipy.sparse.linalgrrIrrcr{rrrrrÚs   2