tKg`ddlZddlmZddlmZmZddlm Z ddl m Z ddl m Z mZdZddZdd Zdd ZGd d ZGd dZGddZGddeZy)N)approx_derivative group_columns)HessianUpdateStrategy)LinearOperator) atleast_ndarray_namespace)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 l/home/alanp/www/video.onchill/myenv/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..wrappedCs(q Q BGGAJ...rc dxxdz cc<tjtjtj|gSr!)r atleast_2drrr2s rrz_wrapper_hess..wrappedHs:q Q }}RZZRWWQZ0G$0G%HIIrrc"t|fd|iSNr&r')rr&r(r$s rr)z_wrapper_hess..wrapped1Rs%$a"5 rr*) r+r rr0issparser1 isinstancerr6rr,) r3r$x0rr(Hrr)rs `` `` @r _wrapper_hessr=6s~  $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|_} t|d| } | j} | j| jdr | j} t||\|_ |_ ||_||_||_||_| j%| | |_| |_|j&j*|_d |_d |_d |_d|_t6j8|_i} |tvr|| d <|| d <|| d <|| d <|tvr|| d <|| d <|| d <d| d<|j=t?||j|| \|_ |_!|jEt|r)tG|||\|_$|_%|_&d|_y|tvrptG||j@|| \|_$|_%|_&|jE|jI|j&|jN|_&d|_yt|trK||_&|jLjQ|j,dd|_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:rr rDrfloat64isdtypedtyper _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)rPris rnfevzScalarFunction.nfevzz!}rc |jdSrq)rarrs rngevzScalarFunction.ngevrtrc |jdSrq)rdrrs rnhevzScalarFunction.nhev rtrct|jtr|j|j|_|j |_t|d|j}|jj||j|_d|_ d|_ d|_|jyt|d|j}|jj||j|_d|_ d|_ d|_yNrrBF)r:rSrrbrrgrerhrrDrUrVrYrZr[ _update_hessrirrms r _update_xzScalarFunction._update_x s doo'< =    &&DK&&DKAA$''2BWW^^B 5DF"DN"DN"DN    AA$''2BWW^^B 5DF"DN"DN"DNrc|jsQ|j|j}||jkr|j|_||_||_d|_yyNT)rYrOrr^r\f)rirs rr_zScalarFunction._update_fun$sN~~""466*BDNN"!%!#DF!DNrc|jsV|jtvr|j|j |j |j |_d|_yyNrKT)rZrRr,r_r`rrrerrs rrbzScalarFunction._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[rSr,rbrcrrer<r:rupdatergrhrrs rr{zScalarFunction._update_hess5s~~*,!!#++DFFtvv+>DOO-BC!!# dfft{{2DFFT[[4HI++DFF3!DNrctj||js|j||j |j Sr*)r array_equalrr}r_rrirs rrzScalarFunction.funBs5~~a( NN1  vv rctj||js|j||j |j Sr*)r rrr}rbrers rr$zScalarFunction.gradH5~~a( NN1  vv rctj||js|j||j |j Sr*)r rrr}r{r<rs rr3zScalarFunction.hessNrrctj||js|j||j |j |j |jfSr*)r rrr}r_rbrrers r fun_and_gradzScalarFunction.fun_and_gradTsJ~~a( NN1   vvtvv~rr*)__name__ __module__ __qualname____doc__ropropertyrsrvrxr}r_rbr{rr$r3rrrrr?r?ZsyIV.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  tstvrtdtdts+tvs#ttstdtdtvrtvr tdt |x_} t|d| } | j} | j| jdr | j} | j| | _ | _ jj_d_d_d_d _d _d _itvrGd <|d <|t-|} || fd <|d <t/j0j_tvr3d <|d <dd<t/j0j_tvrtvr tdfdfd} | _| t/j6j8_j:j_tr j_d_xj"dz c_|s!|QtAjBj>r2fdtAjDj>_d_#n}tAjBj>r-fdj>jI_d _#n1fdt/jJj>_d _#fd}n tvrtMjfdj8i_d_|s!|RtAjBj>r3fd}tAjDj>_d_#ntAjBj>r.fd}j>jI_d _#n2fd}t/jJj>_d _#_'trjj:_(d_xj$dz c_tAjBjPr+fdtAjDjP_(n^tjPtRrfdn=fdt/jJt/jTjP_(fd}nztvrfdfd}|d_nWttrG_(jPjWjd d_d_,d_-fd!}_.ttr fd"}|_/yfd#}|_/y)$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)rsr r")rrris r fun_wrappedz,VectorFunction.__init__..fun_wrappeds# IINI==Q( (rc4j_yr*)rr)rrisr update_funz+VectorFunction.__init__..update_funs (DFrcdxjdz c_tj|Sr)njevr0r1rjacris 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)rrisr update_jacz+VectorFunction.__init__..update_jacs$TVV,rr&cjtjtjfdj i_yr8)r_r0r1rrrrr(rrisrrz+VectorFunction.__init__..update_jacsF$$& ^^)+tvvA$&&A,?ABDFrcjtjfdjij _yr8)r_rrrrrrsrrz+VectorFunction.__init__..update_jacsC$$&.{DFFFtvvF1DFFMgiFrcjtjtjfdj i_yr8)r_r r6rrrrrsrrz+VectorFunction.__init__..update_jacsF$$&]])+tvvA$&&A,?ABDFrcfxjdz c_tj||Sr)rxr0r1rvr3ris r hess_wrappedz-VectorFunction.__init__..hess_wrappeds%IINI>>$q!*55rc@xjdz c_||Sr)rxrs rrz-VectorFunction.__init__..hess_wrappedsIINI1:%rcxjdz c_tjtj||Sr)rxr r6rrs rrz-VectorFunction.__init__..hess_wrappeds.IINI==DAJ)?@@rcJjj_yr*)rrr<)rrisr 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(rrisrrz,VectorFunction.__init__..update_hesssW  "*9dffB.2ffhhll466.B15 B.ABrr3cjjjjjz }jj j jjj j jz }jj||yyyr*) rrgJ_prevrrrrrr<r)delta_xdelta_gris rrz,VectorFunction.__init__..update_hess s  ";;*t{{/F"fft{{2G"ffhhll4662T[[]]5F5Ftvv5NNGFFMM'730G*rc:jj_j_t |dj }j j|j_d_ d_ d_ jyrz) rrrgrrrrDrUrVrY J_updatedr[r{rrmris rupdate_xz)VectorFunction.__init__..update_x,sr  ""ff "ff dgg6DLL9!&!&!&!!#rct|dj}jj|j_d_d_d_yrz)rrDrUrVrrYrr[rs rrz)VectorFunction.__init__..update_x7sDdgg6DLL9!&!&!&r)0r+r,rr:rr rDrrLrMrNrUrrVrWrXrsrrxrYrr[rr rx_diff_update_fun_impl zeros_likerrmrr0r9r1sparse_jacobianrr6r_update_jac_implr<rrrfrgr_update_hess_impl_update_x_impl)rirr;rr3rjfinite_diff_jac_sparsityrkrrDrmrnsparsity_groupsrrrrr(rrrrs`` `` @@@@@rrozVectorFunction.__init__ms}J!6G |STUV V$*"4d$9:@@J|1NO O * !3+, , 'r**" r * ::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[)rirs r _update_vzVectorFunction._update_v@s'~~a(DF"DN)rchtj||js|j|yyr*)r rrrrs rr}zVectorFunction._update_xEs'~~a(    ")rcL|js|jd|_yyr)rYrrrs rr_zVectorFunction._update_funI!~~  ! ! #!DNrcL|js|jd|_yyr)rrrrs rrzVectorFunction._update_jacNrrcL|js|jd|_yyr)r[rrrs rr{zVectorFunction._update_hessSs!~~  " " $!DNrc\|j||j|jSr*)r}r_rrs rrzVectorFunction.funX# q vv rc\|j||j|jSr*)r}rrrs rrzVectorFunction.jac]rrc~|j||j||j|jSr*)rr}r{r<rirrs rr3zVectorFunction.hessbs/ q q vv rN) rrrrrorr}r_rr{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|_ }t|d|}|j}|j!|j"dr |j"}|j%|||_||_|jj+|j&|_d|_t j0|jt2|_tj|j|jf|_y)NTFrrBrE)rN)r0r9r1rrrr r6rshaperrXr rDrrLrMrNrUrrVrrrYzerosfloatrr<)riAr;rrDrmrns rrozLinearVectorFunction.__init__qs3 o5#,,q/^^A&DF#'D \\!_YY[DF#(D ]]2::a=1DF#(D &r**" r * ::bhh 0XXF2v& DFF#$&&. 01rctj||jsKt|d|j}|jj ||j |_d|_yyrz)r rrrrDrUrVrYr|s rr}zLinearVectorFunction._update_xsL~~a(AA$''2BWW^^B 5DF"DN)rc|j||js'|jj||_d|_|jSr)r}rYrrrrs rrzLinearVectorFunction.funs8 q~~VVZZ]DF!DNvv rc<|j||jSr*)r}rrs rrzLinearVectorFunction.jacs qvv rcJ|j|||_|jSr*)r}rr<rs rr3zLinearVectorFunction.hesss qvv rN) rrrrror}rrr3rrrrrjs  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 superro)rir;rrXr __class__s rrozIdentityVectorFunction.__init__sL G o5%(A"Oq A#O B0r)rrrrro __classcell__)rs@rrrs 11rr)r)NrN)NNrN)numpyr scipy.sparsesparser0_numdiffrr_hessian_update_strategyrscipy.sparse.linalgrscipy._lib._array_apirr r,rr-r=r?rrrrrrrs`6;.=* , (!&HDKK\99x111r