gZaddlZddlmZddlmZmZddlm Z ddl m Z ddl m Z ddlmZdZdd Zdd Zdd ZGd dZGddZGddZGddeZdS)N)approx_derivative group_columns)HessianUpdateStrategy)LinearOperator)array_namespace)array_api_extra)z2-pointz3-pointcsc$dgfd}|fS)Nrc(dxxdz cc<tj|gR}tj|sQ tj|}n)#t t f$r}t d|d}~wwxYw|S)Nrrz@The user-provided objective function must return a scalar value.)npcopyisscalarasarrayitem TypeError ValueError)xfxeargsfunncallss ^/granary/edev/quantum/lib/python3.11/site-packages/scipy/optimize/_differentiable_functions.pywrappedz_wrapper_fun..wrappedsq Q S #d # # #{2  Z^^((**z*    2   s&A))B:B  Br )rrrrs`` @r _wrapper_funr s;SF F?ctdgtr fd}|fStvr dfd }|fSdS)Nrc~dxxdz cc<tjtj|gRSNrr)r atleast_1dr)rkwdsrgradrs rrz_wrapper_grad..wrapped'sB 1IIINIII=bgajj!84!8!8!899 9rcDdxxdz cc<t|fd|iS)Nrrf0r)rr&finite_diff_optionsrrs rwrapped1z_wrapper_grad..wrapped1.sD 1IIINIII$Q!4 rN)callable FD_METHODS)r$rrr(rr)rs```` @r _wrapper_gradr-#sSF~~  : : : : : : :              rctrtj|gR}dgtj|rfd}tj|}nJt |trfd}n-fd}tjtj |}||fStvrdgdfd }|dfSdS)Nrc~dxxdz cc<tjtj|gRSr!)sps csr_matrixrrrr#rhessrs rrz_wrapper_hess..wrapped=sBq Q ~dd271::&=&=&=&=>>>rcZdxxdz cc<tj|gRSr!)rrr2s rrz_wrapper_hess..wrappedDs8q Q tBGAJJ.....rc dxxdz cc<tjtjtj|gRSr!)r atleast_2drrr2s rrz_wrapper_hess..wrappedIsLq Q }RZRWQZZ0G$0G0G0G%H%HIIIrrc$t|fd|iSNr&r')rr&r(r$s rr)z_wrapper_hess..wrapped1Ss/$a"5 rr*) r+rrr0issparser1 isinstancerr6rr,) r3r$x0rr(Hrr)rs `` `` @r _wrapper_hessr=7sW~~ & D $t $ $ $ <?? - ? ? ? ? ? ? ?q!!AA > * * - / / / / / / / /  J J J J J J J bjmm,,A!!           %%  rceZdZdZ ddZedZedZedZdZ dZ d Z d Z d Z d Zd ZdZdS)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 ht|s!|tvrtdtdt|s6|tvs-t|tstdtd|tvr|tvrtdt |x|_} tj| |d| } | j } | | j dr| j } t||\|_|_||_||_||_||_| | | |_| |_|jj|_d |_d |_d |_d|_t:j|_i} |tvr|| d <|| d <|| d <|| d <|tvr|| d <|| d <|| d <d| d<| tC||j|| \|_"|_#|$t|r.tK|||\|_&|_'|_(d|_dS|tvrntK||j"|| \|_&|_'|_(|$|&|j|j)|_(d|_dSt|trF||_(|j(*|jdd|_d|_+d|_,dg|_'dSdS)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_xrinf _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"8IJIII  $*"4"4d$9::#5,(,,,  :  $*"4"4899 9 'r***" ^BJJrNNr : : : ::bh 0 0 XF)5St(D(D(D%4: 2v&&   :  ,0  ).B  +.5  +,>  ) :  ,0  ).B  +.5  +8<  4 5 *7 ! 3 * * * &DJ  D>> 5B$666 2D  DF"DNNN Z  5B'$7 666 2D  DF      ''46'::DF!DNNN 3 4 4 DF F  dff - - -!DNDKDKDJJJ   rc|jdSNr)rRrks rnfevzScalarFunction.nfevz!}rc|jdSrs)rcrts rngevzScalarFunction.ngevrvrc|jdSrs)rfrts rnhevzScalarFunction.nhev rvrcvt|jtr||j|_|j|_tj |j |d|j }|j ||j |_d|_d|_d|_|dStj |j |d|j }|j ||j |_d|_d|_d|_dSNrrBF)r:rUrrdrrirgrjrLrMrDrrWrXr[r\r] _update_hessrkrros r _update_xzScalarFunction._update_xs do'< = = #      &DK&DK 2 2twGGGBW^^B 55DF"DN"DN"DN         2 2twGGGBW^^B 55DF"DN"DN"DNNNrc|jsH||j}||jkr|j|_||_||_d|_dSdSNT)r[rQrr`r^f)rkrs rrazScalarFunction._update_fun%sZ~ """46**BDN""!%!#DF!DNNN " "rc|jsQ|jtvr|||j|j|_d|_dSdSNrKT)r\rTr,rarbrrrgrts rrdzScalarFunction._update_grad/s^~ "*,,  """''46'::DF!DNNN  " "rc|js|jtvr;|||j|j|_nt|jtrJ||j |j|j z |j|j z n||j|_d|_dSdSr) r]rUr,rdrerrgr<r:rupdaterirjrts rr}zScalarFunction._update_hess6s~ "*,,!!###++DFtv+>>DO-BCC 4!!### dft{2DFT[4HIIII++DF33!DNNN " "rctj||js||||jSr*)r array_equalrrrarrkrs rrzScalarFunction.funCsC~a((  NN1    v rctj||js||||jSr*)rrrrrdrgrs rr$zScalarFunction.gradIC~a((  NN1    v rctj||js||||jSr*)rrrrr}r<rs rr3zScalarFunction.hessOrrctj||js|||||j|jfSr*)rrrrrardrrgrs r fun_and_gradzScalarFunction.fun_and_gradUs\~a((  NN1     vtv~rr*)__name__ __module__ __qualname____doc__rqpropertyrurxrzrrardr}rr$r3rr rrr?r?[sIIV.2ZZZZxXXX###."""""" " " "   rr?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  ts!tvrtdtdts6tvs-ttstdtdtvrtvrtdt |x_} tj| |d| } | j } | | j dr| j } | | | _| _jj_d_d_d_d _d _d _itvrEd <|d <|t1|} || fd <|d <t3jj_tvr-d <|d <dd<t3jj_tvrtvrtdfdfd} | _| t3jj_jj_ trj_!d_xjdz c_|s|EtEj#j!r,fdtEj$j!_!d_%nptEj#j!r,fdj!&_!d _%n+fdt3j'j!_!d _%fd}ntvrtQjfdji_!d_|s|FtEj#j!r-fd}tEj$j!_!d_%nrtEj#j!r-fd}j!&_!d _%n,fd}t3j'j!_!d _%|_)trjj_*d_xjdz c_tEj#j*r%fdtEj$j*_*nWtj*tVrfdn6fdt3j't3j j*_*fd}n}tvrfdfd}|d_nVttrA_*j*,jd d_d_-d_.fd!}|_/ttrfd"}nfd#}|_0dS)$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.rrBrErFrFrGsparsityrITrJc^xjdz c_tj|SNr)rurr")rrrks r fun_wrappedz,VectorFunction.__init__..fun_wrappeds* IINII=Q(( (rc2j_dSr*)rr)rrksr update_funz+VectorFunction.__init__..update_funs [((DFFFrc^xjdz c_tj|Sr)njevr0r1rjacrks r jac_wrappedz,VectorFunction.__init__..jac_wrappeds*IINII>##a&&111rc^xjdz c_|Sr)rtoarrayrs rrz,VectorFunction.__init__..jac_wrappeds*IINII3q66>>+++rc^xjdz c_tj|Sr)rrr6rs rrz,VectorFunction.__init__..jac_wrappeds*IINII=Q000rc2j_dSr*)rJ)rrksr update_jacz+VectorFunction.__init__..update_jacs$TV,,rr&ctjtjfdji_dSr8)rar0r1rrrrr(rrksrrz+VectorFunction.__init__..update_jacs\$$&&& ^)+tvAA$&A,?AABBDFFFrctjfdji_dSr8)rarrrrrrsrrz+VectorFunction.__init__..update_jacsW$$&&&.{DFFFtvF1DFFFMgiiFFFrctjtjfdji_dSr8)rarr6rrrrrsrrz+VectorFunction.__init__..update_jacs\$$&&&])+tvAA$&A,?AABBDFFFrc`xjdz c_tj||Sr)rzr0r1rvr3rks r hess_wrappedz-VectorFunction.__init__..hess_wrappeds,IINII>$$q!**555rc<xjdz c_||Sr)rzrs rrz-VectorFunction.__init__..hess_wrappeds"IINII41::%rcxjdz c_tjtj||Sr)rzrr6rrs rrz-VectorFunction.__init__..hess_wrappeds6IINII=DDAJJ)?)?@@@rc>jj_dSr*)rrr<)rrksr update_hessz,VectorFunction.__init__..update_hess s%dfdf55rcJ|j|Sr*)Tdot)rrrs r jac_dot_vz*VectorFunction.__init__..jac_dot_vs""{1~~'++A...rctjfjjjjfd_dS)N)r&r) _update_jacrrrrrrr<)r(rrksrrz,VectorFunction.__init__..update_hesssf  """*9dfB.2fhll46.B.B15 BB.ABBrr3c:j|jwjjz }jjjjjjz }j ||dSdSdSr*) rriJ_prevrrrrrr<r)delta_xdelta_grks rrz,VectorFunction.__init__..update_hess!s  """;*t{/F"ft{2G"fhll4622T[]5F5Ftv5N5NNGFMM'733333+*/F/Frcdj_j_t jj|dj}j |j _d_ d_ d_ dSr|)rrrirrrLrMrDrrWrXr[ J_updatedr]r}rrorks rupdate_xz)VectorFunction.__init__..update_x-s  """"f "f ^DGOOA$6$6Q47KKKDL99!&!&!&!!#####rctjj|dj}j|j_d_d_d_ dSr|) rLrMrDrrWrXrr[rr]rs rrz)VectorFunction.__init__..update_x8s[^DGOOA$6$6Q47KKKDL99!&!&!&r)1r+r,rr:rrrDrLrMrrNrOrPrWrrXrYrZrurrzr[rr]rrrx_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}} WJ!6!6U UUUVV V O$*"4"4d$9::#5N@JNNNOO O *  !3!3+,, , 'r***" ^BJJrNNr : : : ::bh 0 0 XF2v&&      *  ,/  ).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 ' $ $ $ $ $ $ ' ' ' ' ''rcZtj||js||_d|_dSdS)NF)rrrr])rkrs r _update_vzVectorFunction._update_vAs4~a(( #DF"DNNN # #rchtj||js||dSdSr*)rrrrrs rrzVectorFunction._update_xFs<~a(( #    " " " " " # #rcN|js|d|_dSdSr)r[rrts rrazVectorFunction._update_funJ3~ "  ! ! # # #!DNNN " "rcN|js|d|_dSdSr)rrrts rrzVectorFunction._update_jacOrrcN|js|d|_dSdSr)r]rrts rr}zVectorFunction._update_hessTs3~ "  " " $ $ $!DNNN " "rcb||||jSr*)rrarrs rrzVectorFunction.funY- q v rcb||||jSr*)rrrrs rrzVectorFunction.jac^rrc||||||jSr*)rrr}r<rkrrs rr3zVectorFunction.hesscs? q q v rN) rrrrrqrrrarr}rrr3r rrrr]s Q'Q'Q'f### ###""" """ """   rrc0eZdZdZdZdZdZdZdZdS)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. cx|s|5tj|r!tj||_d|_ngtj|r!||_d|_n2t jt j||_d|_|jj \|_ |_ t|x|_ }tj||d|}|j}||jdr|j}||||_||_|j|j|_d|_t j|j t4|_tj|j |j f|_dS)NTFrrBrE)rP)r0r9r1rrrrr6rshaperrZrrDrLrMrNrOrPrWrrXrrr[zerosfloatrr<)rkAr;rrDrorps rrqzLinearVectorFunction.__init__rsb  )o5#,q//5^A&&DF#'D \!__ )YY[[DF#(D ]2:a==11DF#(D &r***" ^BJJrNNr : : : ::bh 0 0 XF2v&& DF##$&... 011rctj||jsbtj|j|d|j}|j||j|_d|_ dSdSr|) rrrrLrMrDrrWrXr[r~s rrzLinearVectorFunction._update_xsl~a(( # 2 2twGGGBW^^B 55DF"DNNN # #rc|||js&|j||_d|_|jSr)rr[rrrrs rrzLinearVectorFunction.funs? q~ "VZZ]]DF!DNv rc:|||jSr*)rrrs rrzLinearVectorFunction.jacs qv rcH||||_|jSr*)rrr<rs rr3zLinearVectorFunction.hesss" qv rN) rrrrrqrrrr3r rrrrksi 222<### 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 |||dS)Ncsr)formatTF)lenr0eyersuperrq)rkr;rrZr __class__s rrqzIdentityVectorFunction.__init__sj GG  $o5%(((A"OOq A#O B00000r)rrrrrq __classcell__)rs@rrrsB 111111111rr)r )Nr N)NNr N)numpyr scipy.sparsesparser0_numdiffrr_hessian_update_strategyrscipy.sparse.linalgrscipy._lib._array_apir scipy._libr rLr,rr-r=r?rrrr rrrs66666666;;;;;;......111111------* ,    (!&!&!&!&HDKKKKKKKK\99999999x11111111111r