xfXddlZddlmZddlmZmZddlm Z ddl m Z dZ GddZ Gd d ZGd d ZGd deZy)N)approx_derivative group_columns)HessianUpdateStrategy)LinearOperator)z2-pointz3-pointcscDeZdZdZ d dZdZdZdZdZdZ d Z d Z y) 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  tstvrtdtdts+tvs#ttstdtdtvrtvr tdt j |jt_ jj_ d_ d_ d_d_d_d_d_t j&_i tvr d<| d<| d <| d <tvr d<| d<| d <d d <fd fd} | _j-trfdfd} ntvr fd}  _j1trt j2|g_d _xjdz c_t7j8j4r,fdt7j:j4_n`tj4t<rfdn>fdt j>t j@j4_fd} nutvr fd} | d _nWttrG_j4jCjdd _d_"d_#fd}  _$ttr fd} | _%yfd} | _%y)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_stepabs_stepboundsTas_linear_operatorc\xjdz c_tj|g}tj|s$ tj|j }|jkr|_ |_|S#t tf$r}td|d}~wwxYw)Nrz@The user-provided objective function must return a scalar value.) nfevnpcopyisscalarasarrayitem TypeError ValueError _lowest_f _lowest_x)xfxeargsfunselfs J/usr/lib/python3/dist-packages/scipy/optimize/_differentiable_functions.py fun_wrappedz,ScalarFunction.__init__..fun_wrappeds IINIRWWQZ'$'B;;r?B,,.BDNN"!"!#I":.$6s #B B+ B&&B+c4j_yNrfr$r"sr# update_funz+ScalarFunction.__init__..update_fun (DFcxjdz c_tjtj|gSNr)ngevr atleast_1dr)rr gradr"s r# grad_wrappedz-ScalarFunction.__init__..grad_wrappeds1 Q }}T"''!*%.update_grad%dff-r,cjxjdz c_tjfdji_y)Nrf0) _update_funr/rrr(r4finite_diff_optionsr$r"sr#r5z,ScalarFunction.__init__..update_gradsF  " Q *;B466B-@Br,rcxjdz c_tjtj|gSr.)nhevsps csr_matrixrrrr hessr"s r# hess_wrappedz-ScalarFunction.__init__..hess_wrappeds1IINI>>$rwwqz*AD*ABBr,cfxjdz c_tj|gSr.)r=rrr@s r#rBz-ScalarFunction.__init__..hess_wrappeds(IINI 2T22r,c xjdz c_tjtjtj|gSr.)r=r atleast_2drrr@s r#rBz-ScalarFunction.__init__..hess_wrappeds:IINI==D4Kd4K)LMMr,c4j_yr&)rHrBr"sr# update_hessz,ScalarFunction.__init__..update_hessr6r,cjtjfdji_jSNr8) _update_gradrrr4rG)r;r2r"sr#rIz,ScalarFunction.__init__..update_hesssB!!#*<BDFFB-@Bvv r,rAcjjjjjz j j z yr&)rLrGupdaterx_prevr4g_prevr"sr#rIz,ScalarFunction.__init__..update_hesss;!!# dfft{{2DFFT[[4HIr,cjj_j_t j |jt_d_ d_ d_ jyNF) rLrrOr4rPrr0astypefloat f_updated g_updated H_updated _update_hessrr"s r#update_xz)ScalarFunction.__init__..update_xsc!!#"ff "ff q)007!&!&!&!!#r,ctj|jt_d_d_d_yrS)rr0rTrUrrVrWrXrZs r#r[z)ScalarFunction.__init__..update_xs5q)007!&!&!&r,)&callable FD_METHODSr isinstancerrr0rTrUrsizenrr/r=rVrWrXrinfr_update_fun_implr9_update_grad_implrLrrGr>issparser?rrEr initializerOrP_update_hess_impl_update_x_impl)r"r!x0r r1rAfinite_diff_rel_stepfinite_diff_boundsepsilonr*r5rIr[r;r$r2rBs`` ``` @@@@r#__init__zScalarFunction.__init__Vs~$j"8;J  ) : ,0  ).B  +.5  +8<  4 5 , )!+  D> > .Z  B "-  D>"''"+--DF!DN IINI||DFF#C/DFFN33 Nrzz$&&'9: .Z   M!DN 3 4DF FF  dfff -!DNDKDK J"- d1 2 $&' ''r,cL|js|jd|_yyNTrVrcrQs r#r9zScalarFunction._update_fun!~~  ! ! #!DNr,cL|js|jd|_yyro)rWrdrQs r#rLzScalarFunction._update_grad!~~  " " $!DNr,cL|js|jd|_yyrorXrgrQs r#rYzScalarFunction._update_hessrsr,ctj||js|j||j |j Sr&)r array_equalrrhr9r(r"rs r#r!zScalarFunction.funs7~~a(    " vv r,ctj||js|j||j |j Sr&)rrwrrhrLr4rxs r#r1zScalarFunction.grad7~~a(    " vv r,ctj||js|j||j |j Sr&)rrwrrhrYrGrxs r#rAzScalarFunction.hessrzr,ctj||js|j||j |j |j |jfSr&)rrwrrhr9rLr(r4rxs r# fun_and_gradzScalarFunction.fun_and_gradsL~~a(    "  vvtvv~r,r&) __name__ __module__ __qualname____doc__rmr9rLrYr!r1rAr}r,r#r r s8IV.2a'F" " "    r,r cFeZdZdZdZdZdZdZdZdZ dZ d Z d Z y ) 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  ts&tvrtdjtts6tvs.t t stdjttvrtvr tdt j|jt_ jj_ d_ d_d_d_d_d_itvrGd<|d<|t'|} || fd<|d <t j(j_tvr3d<|d<d d <t j(j_tvrtvr tdfd fd } | _| t j.j0_j2j_tr j_d _xjdz c_|s!|Qt9j:j6r2fdt9j<j6_d _n}t9j:j6r-fdj6jA_d_n1fdt jBj6_d_fd} n tvrtEjfdj0i_d _|s!|Rt9j:j6r3fd} t9j<j6_d _nt9j:j6r.fd} j6jA_d_n2fd} t jBj6_d_ _#trjj2_$d _xjdz c_t9j:jHr+fdt9j<jH_$n^t jHtJrfdn=fdt jBt jLjH_$fd} nztvrfdfd} | d _nWt t rG_$jHjOjdd _d_(d_)fd}  _*t t r fd} | _+yfd } | _+y)!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 rsparsityrTrcdxjdz c_tj|Sr.)rrr0)rr!r"s r#r$z,VectorFunction.__init__..fun_wrappedes# IINI==Q( (r,c4j_yr&r'r)sr#r*z+VectorFunction.__init__..update_funir+r,rcdxjdz c_tj|Sr.)njevr>r?rjacr"s r# jac_wrappedz,VectorFunction.__init__..jac_wrappedzs#IINI>>#a&11r,cZxjdz c_|jSr.)rtoarrayrs r#rz,VectorFunction.__init__..jac_wrappeds!IINIq6>>++r,cdxjdz c_tj|Sr.)rrrErs r#rz,VectorFunction.__init__..jac_wrappeds#IINI==Q00r,c4j_yr&)rJ)rr"sr# update_jacz+VectorFunction.__init__..update_jacs$TVV,r,r8cjtjtjfdj i_yrK)r9r>r?rrr(rr:sr#rz+VectorFunction.__init__..update_jacsF$$& ^^)+tvvA$&&A,?ABDFr,cjtjfdjij _yrK)r9rrr(rrr:sr#rz+VectorFunction.__init__..update_jacsC$$&.{DFFFtvvF1DFFMgiFr,cjtjtjfdj i_yrK)r9rrErrr(rr:sr#rz+VectorFunction.__init__..update_jacsF$$&]])+tvvA$&&A,?ABDFr,cfxjdz c_tj||Sr.)r=r>r?rvrAr"s r#rBz-VectorFunction.__init__..hess_wrappeds%IINI>>$q!*55r,c@xjdz c_||Sr.)r=rs r#rBz-VectorFunction.__init__..hess_wrappedsIINI1:%r,cxjdz c_tjtj||Sr.)r=rrErrs r#rBz-VectorFunction.__init__..hess_wrappeds.IINI==DAJ)?@@r,cJjj_yr&)rrrGrHsr#rIz,VectorFunction.__init__..update_hesss%dffdff5r,cF|jj|Sr&)Tdot)rrrs r# jac_dot_vz*VectorFunction.__init__..jac_dot_vs"1~''++A..r,cjtjfjjj j j fd_y)N)r8r ) _update_jacrrrrrrrG)r;rr"sr#rIz,VectorFunction.__init__..update_hesssW  "*9dffB.2ffhhll466.B15 B.ABr,rAcjjjjjz }jj j jjj j jz }jj||yyyr&) rrOJ_prevrrrrrrGrN)delta_xdelta_gr"s r#rIz,VectorFunction.__init__..update_hesss  ";;*t{{/F"fft{{2G"ffhhll4662T[[]]5F5Ftvv5NNGFFMM'730G*r,cjj_j_t j |jt_d_ d_ d_ jyrS) rrrOrrrr0rTrUrV J_updatedrXrYrZs r#r[z)VectorFunction.__init__..update_xsa  ""ff "ff q)007!&!&!&!!#r,ctj|jt_d_d_d_yrS)rr0rTrUrrVrrXrZs r#r[z)VectorFunction.__init__..update_xs3q)007!&!&!&r,),r]r^rformatr_rrr0rTrUrr`rarrr=rVrrXrrx_diffrc zeros_liker(rmrr>rer?sparse_jacobianrrEr_update_jac_implrGrrrfrOrrgrh)r"r!rirrArjfinite_diff_jac_sparsityrkrsparsity_groupsr*rrIr[r;r$rBrrs`` `` @@@@@r#rmzVectorFunction.__init__3s}J!6J$fZ02 2$*"4d$9:C$fZ02 2 * !3+, , r"))%0     * ,/  ).B  +'3"/0H"I3K3B3D#J/,>  )''$&&/DK : ,0  ).B  +8<  4 5''$&&/DK * !3+, ,  ) )!+ tvv& C=[DF!DN IINI#+ TVV0D2/'+$dff%,)',$1tvv.',$ -J &{DFF>tvv>)<>DF!DN#+ TVV0DB /'+$dff%P)',$B tvv.',$ * D>$&&$&&)DF!DN IINI||DFF#6/DFFN3& Arzz$&&'9: 6 Z  / B M!DN 3 4DF FF  dfff -!DNDKDK 4"- d1 2 $ '  ' 'r,cbtj||js||_d|_yyrS)rrwrrX)r"rs r# _update_vzVectorFunction._update_vs'~~a(DF"DN)r,chtj||js|j|yyr&)rrwrrhrxs r# _update_xzVectorFunction._update_xs'~~a(    ")r,cL|js|jd|_yyrorprQs r#r9zVectorFunction._update_funrqr,cL|js|jd|_yyro)rrrQs r#rzVectorFunction._update_jac rqr,cL|js|jd|_yyrorurQs r#rYzVectorFunction._update_hessrsr,c\|j||j|jSr&)rr9r(rxs r#r!zVectorFunction.fun# q vv r,c\|j||j|jSr&)rrrrxs r#rzVectorFunction.jacrr,c~|j||j||j|jSr&)rrrYrGr"rrs r#rAzVectorFunction.hesss/ q q vv r,N) r~rrrrmrrr9rrYr!rrArr,r#rr"s6 H'T# #" " "   r,rc.eZdZdZdZdZdZdZdZy)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. c|s|7tj|r"tj||_d|_nftj|r|j |_d|_n4t jt j||_d|_|jj\|_ |_ t j|jt|_|jj!|j|_d|_t j&|jt|_tj|j|jf|_y)NTF)dtype)r>rer?rrrrrErshaperrar0rTrUrrr(rVzerosrrG)r"Arirs r#rmzLinearVectorFunction.__init__.s o5#,,q/^^A&DF#'D \\!_YY[DF#(D ]]2::a=1DF#(D r"))%0DFF#$&&. 01r,ctj||js5tj|j t |_d|_yyrS)rrwrr0rTrUrVrxs r#rzLinearVectorFunction._update_xCs;~~a(]]1%,,U3DF"DN)r,c|j||js'|jj||_d|_|jSro)rrVrrr(rxs r#r!zLinearVectorFunction.funHs8 q~~VVZZ]DF!DNvv r,c<|j||jSr&)rrrxs r#rzLinearVectorFunction.jacOs qvv r,cJ|j|||_|jSr&)rrrGrs r#rAzLinearVectorFunction.hessSs qvv r,N) r~rrrrmrr!rrArr,r#rr's  2*# r,rc"eZdZdZfdZxZS)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. ct|}|s|tj|d}d}ntj|}d}t||||y)Ncsr)rTF)lenr>eyersuperrm)r"rirrar __class__s r#rmzIdentityVectorFunction.__init__`sL G o5%(A"Oq A#O B0r,)r~rrrrm __classcell__)rs@r#rrYs 11r,r)numpyr scipy.sparsesparser>_numdiffrr_hessian_update_strategyrscipy.sparse.linalgrr^r rrrrr,r#rsM6;.* TTnBBJ//d111r,