o 4Biq\@sddlZddlmZddlmZmZddlm Z ddl m Z ddl m Z mZdZGdd d ZGd d d ZGd d d ZGdddeZdS)N)approx_derivative group_columns)HessianUpdateStrategy)LinearOperator) atleast_ndarray_namespace)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 s tstvrtdtdts%tvs%tts%tdtdtvr1tvr1tdt|_} t|d| d} | j} | | j drL| j } | | | _ | _ j j_d_d_d_d _d _d _d_tj_itvrd <|d <|d <|d <tvrd <|d <|d <dd<fddfdd} | _trȇfddfdd} n tvrԇfdd} | _tr7t|gR_d_jd7_t !jr fddt "j_n"tjt#rfddnfddt$t%j_fdd}n4tvrKfdd}|d_n ttrk_j&jd d_d_'d_(fd!d}|_)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.rndimxp real floatingrFmethodrel_stepabs_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.) nfevnpcopyisscalarasarrayitem TypeError ValueError _lowest_f _lowest_x)xfxe)argsfunselfh/var/www/html/Trade-python/venv/lib/python3.10/site-packages/scipy/optimize/_differentiable_functions.py fun_wrappeds"  z,ScalarFunction.__init__..fun_wrappedcj_dSNrfr%r'r$r%r& update_funz+ScalarFunction.__init__..update_funcs*jd7_tt|gRSNr)ngevr atleast_1drr)r"gradr$r%r& grad_wrappedz-ScalarFunction.__init__..grad_wrappedcr(r))rgr%)r4r$r%r& update_gradr.z,ScalarFunction.__init__..update_gradcs6jd7_tjfdji_dS)Nrf0) _update_funr0rrr+r6r%finite_diff_optionsr'r$r%r&r7s  cs*jd7_tt|gRSr/)nhevsps csr_matrixrrr2r"hessr$r%r& hess_wrappedr5z-ScalarFunction.__init__..hess_wrappedcs$jd7_t|gRSr/)r<rrr2r?r%r&rAcs0jd7_ttt|gRSr/)r<r atleast_2drrr2r?r%r&rAs"cr(r))rHr%rAr$r%r& update_hessr.z,ScalarFunction.__init__..update_hesscs*tjfdji_jSNr8) _update_gradrrr6rDr%)r;r4r$r%r&rFs r@cs*jjjjjdSr))rHrDupdaterx_prevr6g_prevr%r$r%r&rFs"cXj_j_t|djd}j|j_d_ d_ d_ dSNrr F) rHrrJr6rKrrastypex_dtype f_updated g_updated H_updated _update_hessr_xrLr%r&update_xs z)ScalarFunction.__init__..update_xc8t|djd}j|j_d_d_d_dSrN)rrrOrPrrQrRrSrUrLr%r&rWs  )+callable FD_METHODSr isinstancerrrrfloat64isdtypedtyperOrrPsizenrr0r<rQrRrSrrinfr_update_fun_implr9_update_grad_implrHrrDr=issparser>rrCr initializerJrK_update_hess_impl_update_x_impl)r$r#x0r"r3r@finite_diff_rel_stepfinite_diff_boundsepsilonrrV_dtyper-r7rFrWr%) r"r;r#r'r3r4r@rAr$r&__init__Ws         zScalarFunction.__init__cC|js |d|_dSdSNTrQrbrLr%r%r&r9 zScalarFunction._update_funcCrnro)rRrcrLr%r%r&rH rqzScalarFunction._update_gradcCrnrorSrfrLr%r%r&rTrqzScalarFunction._update_hesscC&t||js ||||jSr))r array_equalrrgr9r+r$rr%r%r&r# zScalarFunction.funcCrsr))rrtrrgrHr6rur%r%r&r3rvzScalarFunction.gradcCrsr))rrtrrgrTrDrur%r%r&r@rvzScalarFunction.hesscCs4t||js |||||j|jfSr))rrtrrgr9rHr+r6rur%r%r& fun_and_grad%s   zScalarFunction.fun_and_gradr)) __name__ __module__ __qualname____doc__rmr9rHrTr#r3r@rwr%r%r%r&r sK . r c@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 ststvrtdtdts%tvs%tts%tdtdtvr1tvr1tdt|_} t|d| d} | j} | | j drL| j } | | | _ | _ j j_d_d_d_d _d _d _itvrd <|d <|durt|} || fd <|d <tj _tvrd <|d <dd<tj _tvrtvrtdfddfdd} | _| tj_jj_tr=j _d_jd7_|s|dur t !jr fddt "j_d_#n)t !jr$fddj$_d _#nfddt%j_d _#fdd}nctvrt&j fdji_d_|sb|durut !jrufdd}t "j_d_#n+t !jrfdd}j$_d _#nfdd}t%j_d _#|_'trj j_(d_jd7_t !j(rЇfddt "j(_(n tj(t)r߇fd dnfd!dt%t*j(_(fd"d#}n:tvrfd$d%fd&d#}|d_n ttr2_(j(+jd'd_d_,d_-fd(d#}|_.ttrBfd)d*}nfd+d*}|_/dS),Nz(`jac` must be either callable or one of r z?`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.rr rrFrrsparsityrTrcjd7_t|Sr/)rrr1r2)r#r$r%r&r'wz,VectorFunction.__init__..fun_wrappedcr(r)r*r%r,r%r&r-{r.z+VectorFunction.__init__..update_funcr~r/)njevr=r>r2jacr$r%r& jac_wrappedrz,VectorFunction.__init__..jac_wrappedcsjd7_|Sr/)rtoarrayr2rr%r&rs cr~r/)rrrCr2rr%r&rrcr(r))rJr%)rr$r%r& update_jacr.z+VectorFunction.__init__..update_jacr8c.ttjfdji_dSrG)r9r=r>rrr+rr%r:r%r&r  cs,tjfdji_dSrG)r9rrr+rrr%r:r%r&rs crrG)r9rrCrrr+rr%r:r%r&rrcsjd7_t||Sr/)r<r=r>rvr@r$r%r&rAsz-VectorFunction.__init__..hess_wrappedcsjd7_||Sr/)r<rrr%r&rAs cs$jd7_tt||Sr/)r<rrCrrrr%r&rArBcsjj_dSr))rrrDr%rEr%r&rFsz,VectorFunction.__init__..update_hesscs|j|Sr))Tdotr)rr%r& jac_dot_vr.z*VectorFunction.__init__..jac_dot_vcs8tjfjjjjfd_dS)N)r8r") _update_jacrrrrrrrDr%)r;rr$r%r&rFs  r@csbjdur-jdur/jj}jjjjjj}j ||dSdSdSr)) rrJJ_prevrrrrrrDrI)delta_xdelta_grLr%r&rFs   crMrN) rrrJrrrrrOrPrQ J_updatedrSrTrUrLr%r&rWs z)VectorFunction.__init__..update_xcrXrN)rrrOrPrrQrrSrUrLr%r&rWs  )0rYrZrr[rrrrr\r]r^rOrrPr_r`rrr<rQrrSrrrx_diffrb zeros_liker+rmrr=rdr>sparse_jacobianrrCr_update_jac_implrDrrrerJrrfrg)r$r#rhrr@rifinite_diff_jac_sparsityrjrrrVrlsparsity_groupsr-rrFrWr%) r;r#r'r@rArrrr$r&rm>s               zVectorFunction.__init__cCs"t||js||_d|_dSdS)NF)rrtrrS)r$rr%r%r& _update_vs zVectorFunction._update_vcCs t||js||dSdSr))rrtrrgrur%r%r& _update_xszVectorFunction._update_xcCrnrorprLr%r%r&r9rqzVectorFunction._update_funcCrnro)rrrLr%r%r&rrqzVectorFunction._update_jaccCrnrorrrLr%r%r&rT$rqzVectorFunction._update_hesscC||||jSr))rr9r+rur%r%r&r#) zVectorFunction.funcCrr))rrrrur%r%r&r.rzVectorFunction.jaccCs"||||||jSr))rrrTrDr$rrr%r%r&r@3s  zVectorFunction.hessN) rxryrzr{rmrrr9rrTr#rr@r%r%r%r&r|-sT r|c@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|d|d}|j}||jdrR|j}||||_||_|j|j|_d|_tj|j td|_t|j |j f|_dS)NTFrr r)r^)r=rdr>rrrrrCrshaperr`rrrr\r]r^rOrrPrr+rQzerosfloatrrD)r$ArhrrrVrlr%r%r&rmBs(   zLinearVectorFunction.__init__cCs>t||jst|d|jd}|j||j|_d|_dSdSrN)rrtrrrrOrPrQ)r$rrVr%r%r&r`s  zLinearVectorFunction._update_xcCs*|||js|j||_d|_|jSro)rrQrrr+rur%r%r&r#fs zLinearVectorFunction.funcCs|||jSr))rrrur%r%r&rms zLinearVectorFunction.jaccCs||||_|jSr))rrrDrr%r%r&r@qs zLinearVectorFunction.hessN) rxryrzr{rmrr#rr@r%r%r%r&r;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)Ncsr)formatTF)lenr=eyersuperrm)r$rhrr`r __class__r%r&rm~s  zIdentityVectorFunction.__init__)rxryrzr{rm __classcell__r%r%rr&rwsr)numpyr scipy.sparsesparser=_numdiffrr_hessian_update_strategyrscipy.sparse.linalgrscipy._lib._array_apirrrZr r|rrr%r%r%r&s   #<