e!hZaddlZddlmZddlmZmZddlm Z ddl m Z ddl m Z ddlmZdZdd Zdd Zdd ZGd d ZGddZGddZGddeZy)N)approx_derivative group_columns)HessianUpdateStrategy)LinearOperator)array_namespace)array_api_extra)z2-pointz3-pointcsc$dgfd}|fS)Nrcdxxdz cc<tj|g}tj|s& tj|j }|S|S#t t f$r}t d|d}~wwxYw)Nrrz@The user-provided objective function must return a scalar value.)npcopyisscalarasarrayitem TypeError ValueError)xfxeargsfunncallss p/var/www/html/diagnosisapp-backend/venv/lib/python3.12/site-packages/scipy/optimize/_differentiable_functions.pywrappedz_wrapper_fun..wrappedsq Q  #d #{{2 ZZ^((*  r z*  2 s#A((B7 BB)rrrrs`` @r _wrapper_funr sSF F?chdgtr fd}|fStvr dfd }|fSy)Nrc|dxxdz cc<tjtj|gSNrr)r atleast_1dr)rkwdsrgradrs rrz_wrapper_grad..wrapped's1 1INI==bggaj!84!89 9rc<dxxdz cc<t|fd|iS)Nrrf0r)rr&finite_diff_optionsrrs rwrapped1z_wrapper_grad..wrapped1.s2 1INI$Q!4 rN)callable FD_METHODS)r$rrr(rr)rs```` @r _wrapper_gradr-#sASF~ :     rctrtj|g}dgtj|rfd}tj |}nGt |trfd}n/fd}tjtj|}||fStvrdgdfd }|dfSy)Nrc|dxxdz cc<tjtj|gSr!)sps csr_matrixr rrr#rhessrs rrz_wrapper_hess..wrapped=s1q Q ~~d2771:&=&=>>rcVdxxdz cc<tj|gSr!)r rr2s rrz_wrapper_hess..wrappedDs(q Q BGGAJ...rc dxxdz cc<tjtjtj|gSr!)r atleast_2drrr2s rrz_wrapper_hess..wrappedIs:q Q }}RZZRWWQZ0G$0G%HIIrrc"t|fd|iSNr&r')rr&r(r$s rr)z_wrapper_hess..wrapped1Ss%$a"5 rr*) r+r rr0issparser1 isinstancerr6rr,) r3r$x0rr(Hrr)rs `` `` @r _wrapper_hessr=7s~  $t $ <<? ?q!A > * /  J bjjm,A!!    %% rczeZdZdZ ddZedZedZedZdZ dZ d Z d Z d Z d Zd ZdZy)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 t|s|tvrtdtdt|s+|tvs#t|tstdtd|tvr|tvr tdt |x|_} tj| j|d| } | j} | j| jdr | j} t||\|_|_||_||_||_||_| j)| | |_| |_|j*j.|_d |_d |_d |_d|_t:j<|_i} |tvr|| d <|| d <|| d <|| d <|tvr|| d <|| d <|| d <d| d<|jAtC||j|| \|_"|_#|jIt|r)tK|||\|_&|_'|_(d|_y|tvrptK||jD|| \|_&|_'|_(|jI|jM|j*|jR|_(d|_yt|trK||_(|jPjU|j0dd|_d|_+d|_,dg|_'yy)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 floating)rFmethodrel_stepabs_stepboundsTas_linear_operator)rrr()r;r)r$r;r(r&r3r)-r+r,rr:rrrDxpx atleast_ndrfloat64isdtypedtyper _wrapped_fun_nfev _orig_fun _orig_grad _orig_hess_argsastyperx_dtypesizen f_updated g_updated H_updated _lowest_xr inf _lowest_f _update_funr- _wrapped_grad_ngev _update_gradr= _wrapped_hess_nhevr<g initializex_prevg_prev) selfrr;rr$r3finite_diff_rel_stepfinite_diff_boundsepsilonrD_x_dtyper(s r__init__zScalarFunction.__init__s~$j"8;J  ) : ,0  ).B  +.5  +8<  4 5 *7 !! 3 * &DJ  D>5B$6 2D  DF"DN Z 5B''$7 6 2D  DF    ''466':DF!DN 3 4DF FF  dfff -!DNDKDKDJ 5rc |jdSNr)rRrks rnfevzScalarFunction.nfevzz!}rc |jdSrs)rcrts rngevzScalarFunction.ngevrvrc |jdSrs)rfrts rnhevzScalarFunction.nhev rvrct|jtr|j|j|_|j |_tj|jj|d|j}|jj||j|_d|_d|_d|_|j#ytj|jj|d|j}|jj||j|_d|_d|_d|_yNrrBF)r:rUrrdrrirgrjrLrMrDrrWrXr[r\r] _update_hessrkrros r _update_xzScalarFunction._update_xs doo'< =    &&DK&&DK 2twwGBWW^^B 5DF"DN"DN"DN     2twwGBWW^^B 5DF"DN"DN"DNrc|jsQ|j|j}||jkr|j|_||_||_d|_yyNT)r[rQrr`r^f)rkrs rrazScalarFunction._update_fun%sN~~""466*BDNN"!%!#DF!DNrc|jsV|jtvr|j|j |j |j |_d|_yyNrKT)r\rTr,rarbrrrgrts rrdzScalarFunction._update_grad/sL~~*,  "''466':DF!DN rc|js|jtvr=|j|j |j |j |_nt|jtr[|j|jj|j |jz |j |jz n |j |j |_d|_yyr) r]rUr,rdrerrgr<r:rupdaterirjrts rr}zScalarFunction._update_hess6s~~*,!!#++DFFtvv+>DOO-BC!!# dfft{{2DFFT[[4HI++DFF3!DNrctj||js|j||j |j Sr*)r array_equalrrrarrkrs rrzScalarFunction.funCs5~~a( NN1  vv rctj||js|j||j |j Sr*)r rrrrdrgrs rr$zScalarFunction.gradI5~~a( NN1  vv rctj||js|j||j |j Sr*)r rrrr}r<rs rr3zScalarFunction.hessOrrctj||js|j||j |j |j |jfSr*)r rrrrardrrgrs r fun_and_gradzScalarFunction.fun_and_gradUsJ~~a( NN1   vvtvv~rr*)__name__ __module__ __qualname____doc__rqpropertyrurxrzrrardr}rr$r3rrrrr?r?[syIV.2Zx#."" "   rr?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 B tstvrtdtdts+tvs#ttstdtdtvrtvr tdt |x_} tj| j|d| } | j} | j| jdr | j} | j| | _| _jj _d_d_d_d _d _d _itvrGd <|d <|t1|} || fd <|d <t3j4j_tvr3d <|d <dd<t3j4j_tvrtvr tdfdfd} | _| t3j:j<_j>j _ tr j_!d_xj&dz c_|s!|QtEjFjBr2fdtEjHjB_!d_%n}tEjFjBr-fdjBjM_!d _%n1fdt3jNjB_!d _%fd}n tvrtQjfdj<i_!d_|s!|RtEjFjBr3fd}tEjHjB_!d_%ntEjFjBr.fd}jBjM_!d _%n2fd}t3jNjB_!d _%_)trjj>_*d_xj(dz c_tEjFjTr+fdtEjHjT_*n^tjTtVrfdn=fdt3jNt3jjT_*fd}nztvrfdfd}|d_nWttrG_*jTjYj"d d_d_-d_.fd!}_/ttr fd"}|_0yfd#}|_0y)$Nz(`jac` must be either callable or one of rAz?`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.rrBrErFrFrGsparsityrITrJcdxjdz c_tj|SNr)rur r")rrrks r fun_wrappedz,VectorFunction.__init__..fun_wrappeds# IINI==Q( (rc4j_yr*)rr)rrksr update_funz+VectorFunction.__init__..update_funs (DFrcdxjdz c_tj|Sr)njevr0r1rjacrks r jac_wrappedz,VectorFunction.__init__..jac_wrappeds#IINI>>#a&11rcZxjdz c_|jSr)rtoarrayrs rrz,VectorFunction.__init__..jac_wrappeds!IINIq6>>++rcdxjdz c_tj|Sr)rr r6rs rrz,VectorFunction.__init__..jac_wrappeds#IINI==Q00rc4j_yr*)rJ)rrksr update_jacz+VectorFunction.__init__..update_jacs$TVV,rr&cjtjtjfdj i_yr8)rar0r1rrrrr(rrksrrz+VectorFunction.__init__..update_jacsF$$& ^^)+tvvA$&&A,?ABDFrcjtjfdjij _yr8)rarrrrrrsrrz+VectorFunction.__init__..update_jacsC$$&.{DFFFtvvF1DFFMgiFrcjtjtjfdj i_yr8)rar r6rrrrrsrrz+VectorFunction.__init__..update_jacsF$$&]])+tvvA$&&A,?ABDFrcfxjdz c_tj||Sr)rzr0r1rvr3rks r hess_wrappedz-VectorFunction.__init__..hess_wrappeds%IINI>>$q!*55rc@xjdz c_||Sr)rzrs rrz-VectorFunction.__init__..hess_wrappedsIINI1:%rcxjdz c_tjtj||Sr)rzr r6rrs rrz-VectorFunction.__init__..hess_wrappeds.IINI==DAJ)?@@rcJjj_yr*)rrr<)rrksr update_hessz,VectorFunction.__init__..update_hess s%dffdff5rcF|jj|Sr*)Tdot)rrrs r jac_dot_vz*VectorFunction.__init__..jac_dot_vs"1~''++A..rcjtjfjjj j j fd_y)N)r&r) _update_jacrrrrrrr<)r(rrksrrz,VectorFunction.__init__..update_hesssW  "*9dffB.2ffhhll466.B15 B.ABrr3cjjjjjz }jj j jjj j jz }jj||yyyr*) rriJ_prevrrrrrr<r)delta_xdelta_grks rrz,VectorFunction.__init__..update_hess!s  ";;*t{{/F"fft{{2G"ffhhll4662T[[]]5F5Ftvv5NNGFFMM'730G*rcjj_j_t j jj|dj}jj|j_d_ d_ d_ jyr|)rrrirrrLrMrDrrWrXr[ J_updatedr]r}rrorks rupdate_xz)VectorFunction.__init__..update_x-s  ""ff "ff ^^DGGOOA$6Q477KDLL9!&!&!&!!#rctjjj|dj}jj |j _d_d_d_ yr|) rLrMrDrrWrXrr[rr]rs rrz)VectorFunction.__init__..update_x8sU^^DGGOOA$6Q477KDLL9!&!&!&r)1r+r,rr:rrrDrLrMrrNrOrPrWrrXrYrZrurrzr[rr]rr rx_diff_update_fun_impl zeros_likerrmrr0r9r1sparse_jacobianrr6r_update_jac_implr<rrhrir_update_hess_impl_update_x_impl)rkrr;rr3rlfinite_diff_jac_sparsityrmrrDrorpsparsity_groupsrrrrr(rrrrs`` `` @@@@@rrqzVectorFunction.__init__ns}J!6G |STUV V$*"4d$9:@@J|1NO O * !3+, , 'r**" ^^BJJrNr : ::bhh 0XXF2v&      * ,/  ).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 $$' ''rcbtj||js||_d|_yy)NF)r rrr])rkrs r _update_vzVectorFunction._update_vAs'~~a(DF"DN)rchtj||js|j|yyr*)r rrrrs rrzVectorFunction._update_xFs'~~a(    ")rcL|js|jd|_yyr)r[rrts rrazVectorFunction._update_funJ!~~  ! ! #!DNrcL|js|jd|_yyr)rrrts rrzVectorFunction._update_jacOrrcL|js|jd|_yyr)r]rrts rr}zVectorFunction._update_hessTs!~~  " " $!DNrc\|j||j|jSr*)rrarrs rrzVectorFunction.funY# q vv rc\|j||j|jSr*)rrrrs rrzVectorFunction.jac^rrc~|j||j||j|jSr*)rrr}r<rkrrs rr3zVectorFunction.hesscs/ q q vv rN) rrrrrqrrrarr}rrr3rrrrr]s6 Q'f# #" " "   rrc.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|x|_ }tj|j|d|}|j }|j#|j$dr |j$}|j'|||_||_|jj-|j(|_d|_t j2|jt4|_tj|j|jf|_y)NTFrrBrE)rP)r0r9r1rrrr r6rshaperrZrrDrLrMrNrOrPrWrrXrrr[zerosfloatrr<)rkAr;rrDrorps rrqzLinearVectorFunction.__init__rs? o5#,,q/^^A&DF#'D \\!_YY[DF#(D ]]2::a=1DF#(D &r**" ^^BJJrNr : ::bhh 0XXF2v& DFF#$&&. 01rc tj||jsntj|j j |d|j }|j j||j|_d|_ yyr|) r rrrLrMrDrrWrXr[r~s rrzLinearVectorFunction._update_xs]~~a( 2twwGBWW^^B 5DF"DN)rc|j||js'|jj||_d|_|jSr)rr[rrrrs rrzLinearVectorFunction.funs8 q~~VVZZ]DF!DNvv rc<|j||jSr*)rrrs rrzLinearVectorFunction.jacs qvv rcJ|j|||_|jSr*)rrr<rs rr3zLinearVectorFunction.hesss qvv rN) rrrrrqrrrr3rrrrrks  2<# rrc"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)formatTF)lenr0eyer superrq)rkr;rrZr __class__s rrqzIdentityVectorFunction.__init__sL G o5%(A"Oq A#O B0r)rrrrrq __classcell__)rs@rrrs 11rr)r)NrN)NNrN)numpyr scipy.sparsesparser0_numdiffrr_hessian_update_strategyrscipy.sparse.linalgrscipy._lib._array_apir scipy._libr rLr,rr-r=r?rrrrrrrsc6;.1-* , (!&HDKK\99x111r