hXddlZddlmZddlmZmZddlm Z ddl m Z dZ GddZ Gd d ZGd d ZGd deZdS)N)approx_derivative group_columns)HessianUpdateStrategy)LinearOperator)z2-pointz3-pointcscFeZdZdZ d dZdZdZdZdZdZ d Z d Z 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  ts!tvrtdtdts6tvs-ttstdtdtvrtvrtdt j|t_ j j _ d_ d_ d_d_d_d_d_t j_i tvr d<| d<| d <| d <tvr d<| d<| d <d d <fd fd} | _trfdfd} ntvr fd} | _trt j|gR_d _xjdz c_t7jjr&fdt7jj_nYtjt<rfdn7fdt jt j j_fd} nxtvr fd} | d _nVttrA_j!j dd _d_"d_#fd} | _$ttrfd} nfd} | _%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_stepabs_stepboundsTas_linear_operatorcZxjdz c_tj|gR}tj|sQ tj|}n)#t tf$r}td|d}~wwxYw|jkr|_ |_|S)Nrz@The user-provided objective function must return a scalar value.) nfevnpcopyisscalarasarrayitem TypeError ValueError _lowest_f _lowest_x)xfxeargsfunselfs d/var/www/html/Sam_Eipo/venv/lib/python3.11/site-packages/scipy/optimize/_differentiable_functions.py fun_wrappedz,ScalarFunction.__init__..fun_wrappeds IINIIRWQZZ'$'''B;r?? B,,..BB!:.$6 DN""!"!#Is&A))B:B  Bc2j_dSNrfr$r"sr# update_funz+ScalarFunction.__init__..update_fun [((DFFFc~xjdz c_tjtj|gRSNr)ngevr atleast_1dr)rr gradr"s r# grad_wrappedz-ScalarFunction.__init__..grad_wrappeds< Q }TT"'!**%.update_grad%df--r,cxjdz c_tjfdji_dS)Nrf0) _update_funr/rrr(r4finite_diff_optionsr$r"sr#r5z,ScalarFunction.__init__..update_gradsZ  """ Q *;BB46B-@BBr,rc~xjdz c_tjtj|gRSr.)nhevsps csr_matrixrrrr hessr"s r# hess_wrappedz-ScalarFunction.__init__..hess_wrappeds<IINII>$$rwqzz*AD*A*A*ABBBr,cZxjdz c_tj|gRSr.)r=rrr@s r#rBz-ScalarFunction.__init__..hess_wrappeds2IINII4 2T2222r,c xjdz c_tjtjtj|gRSr.)r=r atleast_2drrr@s r#rBz-ScalarFunction.__init__..hess_wrappedsFIINII=DD4Kd4K4K4K)L)LMMMr,c2j_dSr&)rHrBr"sr# update_hessz,ScalarFunction.__init__..update_hessr6r,cxtjfdji_jSNr8) _update_gradrrr4rG)r;r2r"sr#rIz,ScalarFunction.__init__..update_hesssN!!###*<BBDFB-@BBv r,rAcjjjz jjz dSr&)rLrGupdaterx_prevr4g_prevr"sr#rIz,ScalarFunction.__init__..update_hesssC!!### dft{2DFT[4HIIIIIr,cj_j_t j|t_d_ d_ d_  dSNF) rLrrOr4rPrr0astypefloat f_updated g_updated H_updated _update_hessrr"s r#update_xz)ScalarFunction.__init__..update_xsu!!###"f "f q))0077!&!&!&!!#####r,ctj|t_d_d_d_dSrS)rr0rTrUrrVrWrXrZs r#r[z)ScalarFunction.__init__..update_xs=q))0077!&!&!&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"8IJIII  $*"4"4d$9::#5,(,,,  :  $*"4"4899 9 r""))%00     :  ,0  ).B  +.5  +,>  ) :  ,0  ).B  +.5  +8<  4 5       , ) ) ) ) ) )!+  D>> B > > > > > > > . . . . . . .Z   B B B B B B B "-  D>>+ JT"'"++----DF!DN IINII|DF## ;CCCCCCC//DFN33 ;33333333 NNNNNNNrz$&'9'9:: . . . . . . .Z          KMMM!DNN 3 4 4 JDF F  dff - - -!DNDKDK J J J J J"- d1 2 2 ' $ $ $ $ $ $ ' ' ' ' ''r,cN|js|d|_dSdSNTrVrcrQs r#r9zScalarFunction._update_fun3~ "  ! ! # # #!DNNN " "r,cN|js|d|_dSdSro)rWrdrQs r#rLzScalarFunction._update_grad3~ "  " " $ $ $!DNNN " "r,cN|js|d|_dSdSrorXrgrQs r#rYzScalarFunction._update_hessrsr,ctj||js||||jSr&)r array_equalrrhr9r(r"rs r#r!zScalarFunction.funsE~a(( #    " " " v r,ctj||js||||jSr&)rrwrrhrLr4rxs r#r1zScalarFunction.gradE~a(( #    " " " v r,ctj||js||||jSr&)rrwrrhrYrGrxs r#rAzScalarFunction.hessrzr,ctj||js|||||j|jfSr&)rrwrrhr9rLr(r4rxs r# fun_and_gradzScalarFunction.fun_and_grads^~a(( #    " " "  vtv~r,r&) __name__ __module__ __qualname____doc__rmr9rLrYr!r1rAr}r,r#r r sIIV.2a'a'a'a'F""" """ """    r,r cHeZdZdZdZdZdZdZdZdZ dZ d Z d Z d S) 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 ( ts0tvr'tdttsEtvs.fun_wrappedes* IINII=Q(( (r,c2j_dSr&r'r)sr#r*z+VectorFunction.__init__..update_funir+r,rc^xjdz c_tj|Sr.)njevr>r?rjacr"s r# jac_wrappedz,VectorFunction.__init__..jac_wrappedzs*IINII>##a&&111r,c^xjdz c_|Sr.)rtoarrayrs r#rz,VectorFunction.__init__..jac_wrappeds*IINII3q66>>+++r,c^xjdz c_tj|Sr.)rrrErs r#rz,VectorFunction.__init__..jac_wrappeds*IINII=Q000r,c2j_dSr&)rJ)rr"sr# update_jacz+VectorFunction.__init__..update_jacs$TV,,r,r8ctjtjfdji_dSrK)r9r>r?rrr(rr:sr#rz+VectorFunction.__init__..update_jacs\$$&&& ^)+tvAA$&A,?AABBDFFFr,ctjfdji_dSrK)r9rrr(rrr:sr#rz+VectorFunction.__init__..update_jacsW$$&&&.{DFFFtvF1DFFFMgiiFFFr,ctjtjfdji_dSrK)r9rrErrr(rr:sr#rz+VectorFunction.__init__..update_jacs\$$&&&])+tvAA$&A,?AABBDFFFr,c`xjdz c_tj||Sr.)r=r>r?rvrAr"s r#rBz-VectorFunction.__init__..hess_wrappeds,IINII>$$q!**555r,c<xjdz c_||Sr.)r=rs r#rBz-VectorFunction.__init__..hess_wrappeds"IINII41::%r,cxjdz c_tjtj||Sr.)r=rrErrs r#rBz-VectorFunction.__init__..hess_wrappeds6IINII=DDAJJ)?)?@@@r,c>jj_dSr&)rrrGrHsr#rIz,VectorFunction.__init__..update_hesss%dfdf55r,cJ|j|Sr&)Tdot)rrrs r# jac_dot_vz*VectorFunction.__init__..jac_dot_vs""{1~~'++A...r,ctjfjjjjfd_dS)N)r8r ) _update_jacrrrrrrrG)r;rr"sr#rIz,VectorFunction.__init__..update_hesssf  """*9dfB.2fhll46.B.B15 BB.ABBr,rAc:j|jwjjz }jjjjjjz }j ||dSdSdSr&) rrOJ_prevrrrrrrGrN)delta_xdelta_gr"s r#rIz,VectorFunction.__init__..update_hesss  """;*t{/F"ft{2G"fhll4622T[]5F5Ftv5N5NNGFMM'733333+*/F/Fr,cj_j_t j|t_d_ d_ d_  dSrS) rrrOrrrr0rTrUrV J_updatedrXrYrZs r#r[z)VectorFunction.__init__..update_xss  """"f "f q))0077!&!&!&!!#####r,ctj|t_d_d_d_dSrS)rr0rTrUrrVrrXrZs r#r[z)VectorFunction.__init__..update_xs;q))0077!&!&!&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__3sI}} 2J!6!6J$fZ0022 2 2$*"4"4d$9::#5C$fZ0022 2 *  !3!3+,, , r""))%00     *  ,/  ).B  +'3"/0H"I"I3K3B3D#J/,>  )'$&//DK :  ,0  ).B  +8<  4 5'$&//DK *  !3!3+,, ,  ) ) ) ) ) ) ) ) ) ) ) )!+ tv&& C==< -S[[DF!DN IINII -#+ TV0D0D+222222//'+$$df%% -,,,,,,))',$$111111tv..',$ - - - - - - -J  &{DF>>tv>)<>>DF!DN -#+ TV0D0D+BBBBBBB //'+$$df%% -PPPPPPP))',$$BBBBBBB tv..',$ * D>>2 4T$&$&))DF!DN IINII|DF## ;666666//DFN33 ;&&&&&&& AAAAAArz$&'9'9:: 6 6 6 6 6 6 6 Z   / / / / / B B B B B B B KMMM!DNN 3 4 4 4DF F  dff - - -!DNDKDK 4 4 4 4 4"- d1 2 2 ' $ $ $ $ $ $ ' ' ' ' ' 'r,cZtj||js||_d|_dSdSrS)rrwrrX)r"rs r# _update_vzVectorFunction._update_vs4~a(( #DF"DNNN # #r,chtj||js||dSdSr&)rrwrrhrxs r# _update_xzVectorFunction._update_xs<~a(( #    " " " " " # #r,cN|js|d|_dSdSrorprQs r#r9zVectorFunction._update_funrqr,cN|js|d|_dSdSro)rrrQs r#rzVectorFunction._update_jac rqr,cN|js|d|_dSdSrorurQs r#rYzVectorFunction._update_hessrsr,cb||||jSr&)rr9r(rxs r#r!zVectorFunction.fun- q v r,cb||||jSr&)rrrrxs r#rzVectorFunction.jacrr,c||||||jSr&)rrrYrGr"rrs r#rAzVectorFunction.hesss? q q v r,N) r~rrrrmrrr9rrYr!rrArr,r#rr"s H'H'H'T### ###""" """ """   r,rc0eZdZdZdZdZdZdZdZdS)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|5tj|r!tj||_d|_ngtj|r!||_d|_n2t jt j||_d|_|jj \|_ |_ t j | t|_|j|j|_d|_t j|j t|_tj|j |j f|_dS)NTF)dtype)r>rer?rrrrrErshaperrar0rTrUrrr(rVzerosrrG)r"Arirs r#rmzLinearVectorFunction.__init__.s   )o5#,q//5^A&&DF#'D \!__ )YY[[DF#(D ]2:a==11DF#(D r""))%00DF##$&... 011r,ctj||js:tj|t |_d|_dSdSrS)rrwrr0rTrUrVrxs r#rzLinearVectorFunction._update_xCsL~a(( #]1%%,,U33DF"DNNN # #r,c|||js&|j||_d|_|jSro)rrVrrr(rxs r#r!zLinearVectorFunction.funHs? q~ "VZZ]]DF!DNv r,c:|||jSr&)rrrxs r#rzLinearVectorFunction.jacOs qv r,cH||||_|jSr&)rrrGrs r#rAzLinearVectorFunction.hessSs" qv r,N) r~rrrrmrr!rrArr,r#rr'si 222*### 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 |||dS)Ncsr)rTF)lenr>eyersuperrm)r"rirrar __class__s r#rmzIdentityVectorFunction.__init__`sj GG  $o5%(((A"OOq A#O B00000r,)r~rrrrm __classcell__)rs@r#rrYsB 111111111r,r)numpyr scipy.sparsesparser>_numdiffrr_hessian_update_strategyrscipy.sparse.linalgrr^r rrrrr,r#rs&66666666;;;;;;......* TTTTTTTTnBBBBBBBBJ////////d11111111111r,