o EbX@s~ddlZddlmZddlmZmZddlm Z ddl m Z dZ GdddZ Gd d d ZGd d d ZGd ddeZdS)N)approx_derivative group_columns)HessianUpdateStrategy)LinearOperator)z2-pointz3-pointcsc@sTeZdZdZ dddZddZddZd d Zd d Zd dZ ddZ ddZ dS)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 ststvrtdtdts%tvs%tts%tdtdtvr1tvr1tdt|t_ j j _ d_ d_ d_d_d_d_d_tj_itvrnd<|d<|d <|d <tvrd<|d<|d <d d <fd dfdd} | _trfddfdd} n tvrfdd} | _trt|gR_d _jd7_tjrfddtj_n!tjtrfddnfddtt j_fdd} n4tvr-fdd} | d _n ttrM_j!j dd _d_"d_#fdd} | _$ttr]fd d!} nfd"d!} | _%dS)#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.rFmethodrel_stepZabs_stepboundsTas_linear_operatorc sjd7_t|gR}t|s4z t|}Wnttfy3}ztd|d}~ww|jkr?|_ |_|S)Nrz@The user-provided objective function must return a scalar value.) nfevnpcopyZisscalarasarrayitem TypeError ValueError _lowest_f _lowest_x)xZfxe)argsfunselfJ/usr/lib/python3/dist-packages/scipy/optimize/_differentiable_functions.py fun_wrappeds"  z,ScalarFunction.__init__..fun_wrappedcj_dSNrfrrrrr update_funz+ScalarFunction.__init__..update_funcs*jd7_tt|gRSNr)ngevr atleast_1drr)rgradrrr grad_wrappedz-ScalarFunction.__init__..grad_wrappedcrr )rgr)r+rrr update_gradr%z,ScalarFunction.__init__..update_gradcs6jd7_tjfdji_dS)Nrf0) _update_funr'rrr"r-rfinite_diff_optionsrrrrr.s  rcs*jd7_tt|gRSr&)nhevsps csr_matrixrrr)rhessrrr hess_wrappedr,z-ScalarFunction.__init__..hess_wrappedcs$jd7_t|gRSr&)r3rrr)r6rrr8cs0jd7_ttt|gRSr&)r3r atleast_2drrr)r6rrr8s"crr )rHrr8rrr update_hessr%z,ScalarFunction.__init__..update_hesscs*tjfdji_jSNr/) _update_gradrrr-r;r)r2r+rrrr=s r7cs*jjjjjdSr )r?r;updaterx_prevr-g_prevrrrrr=s"cHj_j_t|t_d_ d_ d_ dSNF) r?rrAr-rBrr(astypefloat f_updated g_updated H_updated _update_hessr)rCrrupdate_xs z)ScalarFunction.__init__..update_xc(t|t_d_d_d_dSrE)rr(rFrGrrHrIrJr)rCrrrLs )&callable FD_METHODSr isinstancerrr(rFrGrsizenrr'r3rHrIrJrinfr_update_fun_implr0_update_grad_implr?rr;r4issparser5rr:r initializerArB_update_hess_impl_update_x_impl) rrx0rr*r7finite_diff_rel_stepfinite_diff_boundsepsilonr$r.r=rLr) rr2rrr*r+r7r8rr__init__Vs          zScalarFunction.__init__cC|js |d|_dSdSNTrHrTrCrrrr0 zScalarFunction._update_funcCr_r`)rIrUrCrrrr?rbzScalarFunction._update_gradcCr_r`rJrXrCrrrrKrbzScalarFunction._update_hesscC&t||js ||||jSr )r array_equalrrYr0r"rrrrrr zScalarFunction.funcCrdr )rrerrYr?r-rfrrrr*rgzScalarFunction.gradcCrdr )rrerrYrKr;rfrrrr7rgzScalarFunction.hesscCs4t||js |||||j|jfSr )rrerrYr0r?r"r-rfrrr fun_and_grads   zScalarFunction.fun_and_gradr ) __name__ __module__ __qualname____doc__r^r0r?rKrr*r7rhrrrrr sK $ rc@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 sZtstvrtdtts#tvs#tts#tdttvr/tvr/tdt|t _ j j _ d_ d_d_d_d_d_itvrvd<|d<|durkt|} || fd<|d <tj _tvrd<|d<d d <tj _tvrtvrtdfd d fdd} | _| tj_jj _trj _d _jd7_|s|durtjrfddtj_d _n)tjrfddj _d_nfddt!j_d_fdd} nctvrt"j fdji_d _|sB|durUtjrUfdd} tj_d _n+tjrnfdd} j _d_nfdd} t!j_d_| _#tr؈j j_$d _jd7_tj$rfddtj$_$n tj$t%rfddnfddt!t&j$_$fdd } n:tvrfd!d"fd#d } | d _n ttr_$j$'j d$d _d_(d_)fd%d } | _*ttr"fd&d'} nfd(d'} | _+dS))Nz+`jac` must be either callable or one of {}.zB`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.rFr r Zsparsityr Tr cjd7_t|Sr&)rrr(r))rrrrrez,VectorFunction.__init__..fun_wrappedcrr r!rr#rrr$ir%z+VectorFunction.__init__..update_funrcrnr&)njevr4r5r)jacrrr jac_wrappedzroz,VectorFunction.__init__..jac_wrappedcsjd7_|Sr&)rptoarrayr)rqrrrss crnr&)rprr:r)rqrrrsrocrr )rJr)rsrrr update_jacr%z+VectorFunction.__init__..update_jacr/c.ttjfdji_dSr>)r0r4r5rrr"rurr1rrrv  cs,tjfdji_dSr>)r0rrr"rtrurr1rrrvs crwr>)r0rr:rrr"rurr1rrrvrxcsjd7_t||Sr&)r3r4r5rvr7rrrr8sz-VectorFunction.__init__..hess_wrappedcsjd7_||Sr&)r3ryr{rrr8s cs$jd7_tt||Sr&)r3rr:rryr{rrr8r9csjj_dSr )rrzr;rr<rrr=sz,VectorFunction.__init__..update_hesscs|j|Sr )Tdotry)rsrr jac_dot_vr%z*VectorFunction.__init__..jac_dot_vcs8tjfjjjjfd_dS)N)r/r) _update_jacrrrur|r}rzr;r)r2r~rrrr=s  r7csbjdur-jdur/jj}jjjjjj}j ||dSdSdSr ) rrAJ_prevrrur|r}rzr;r@)Zdelta_xZdelta_grCrrr=s   crDrE) rrrArurrr(rFrGrH J_updatedrJrKr)rCrrrLs z)VectorFunction.__init__..update_xcrMrE)rr(rFrGrrHrrJr)rCrrrLs ),rNrOrformatrPrrr(rFrGrrQrRrrpr3rHrrJrrZx_diffrTZ zeros_liker"rzmrur4rVr5sparse_jacobianrtr:r_update_jac_implr;rrrWrArrXrY)rrrZrrr7r[Zfinite_diff_jac_sparsityr\rZsparsity_groupsr$rvr=rLr) r2rrr7r8rrr~rsrrr^3s                zVectorFunction.__init__cCs"t||js||_d|_dSdSrE)rrerzrJ)rrzrrr _update_vs zVectorFunction._update_vcCs t||js||dSdSr )rrerrYrfrrr _update_xszVectorFunction._update_xcCr_r`rarCrrrr0rbzVectorFunction._update_funcCr_r`)rrrCrrrr rbzVectorFunction._update_jaccCr_r`rcrCrrrrKrbzVectorFunction._update_hesscC||||jSr )rr0r"rfrrrr zVectorFunction.funcCrr )rrrurfrrrrrrzVectorFunction.jaccCs"||||||jSr )rrrKr;rrrzrrrr7s  zVectorFunction.hessN) rirjrkrlr^rrr0rrKrrrr7rrrrrm"sK rmc@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 | t|_|j|j|_d|_tj|j td|_t|j |j f|_dS)NTF)Zdtype)r4rVr5rurrtrr:rshaperrRr(rFrGrr}r"rHZzerosrzr;)rArZrrrrr^.s   zLinearVectorFunction.__init__cCs.t||jst|t|_d|_dSdSrE)rrerr(rFrGrHrfrrrrCs zLinearVectorFunction._update_xcCs*|||js|j||_d|_|jSr`)rrHrur}r"rfrrrrHs zLinearVectorFunction.funcCs|||jSr )rrurfrrrrrOs zLinearVectorFunction.jaccCs||||_|jSr )rrzr;rrrrr7Ss zLinearVectorFunction.hessN) rirjrkrlr^rrrrr7rrrrr's 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)rTF)lenr4Zeyersuperr^)rrZrrRr __class__rrr^`s  zIdentityVectorFunction.__init__)rirjrkrlr^ __classcell__rrrrrYsr)ZnumpyrZ scipy.sparseZsparser4Z_numdiffrrZ_hessian_update_strategyrZscipy.sparse.linalgrrOrrmrrrrrrs   2