Ug`ddlZddlmZddlmZmZddlm Z ddl m Z ddl m Z mZdZdd Zdd Zdd ZGd d ZGddZGddZGddeZdS)N)approx_derivative group_columns)HessianUpdateStrategy)LinearOperator) atleast_ndarray_namespace)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 g/var/www/surfInsights/venv3-11/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..wrappedCs8q Q tBGAJJ.....rc dxxdz cc<tjtjtj|gRSr!)r atleast_2drrr2s rrz_wrapper_hess..wrappedHsLq Q }RZRWQZZ0G$0G0G0G%H%HIIIrrc$t|fd|iSNr&r')rr&r(r$s rr)z_wrapper_hess..wrapped1Rs/$a"5 rr*) r+rrr0issparser1 isinstancerr6rr,) r3r$x0rr(Hrr)rs `` `` @r _wrapper_hessr=6sW~~ & 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 8t|s!|tvrtdtdt|s6|tvs-t|tstdtd|tvr|tvrtdt |x|_} t|d| } | j} | | j dr| j } t||\|_ |_ ||_||_||_||_| | | |_| |_|jj|_d |_d |_d |_d|_t6j|_i} |tvr|| d <|| d <|| d <|| d <|tvr|| d <|| d <|| d <d| d<|t?||j || \|_ |_!|"t|r.tG|||\|_$|_%|_&d|_dS|tvrntG||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:rr rDrfloat64isdtypedtyper _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***" r * * * ::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)rPris rnfevzScalarFunction.nfevz!}rc|jdSrq)rarrs rngevzScalarFunction.ngevrtrc|jdSrq)rdrrs rnhevzScalarFunction.nhev rtrct|jtr||j|_|j|_t|d|j }|j ||j |_d|_ d|_ d|_|dSt|d|j }|j ||j |_d|_ d|_ d|_dSNrrBF)r:rSrrbrrgrerhrrDrUrVrYrZr[ _update_hessrirrms r _update_xzScalarFunction._update_x s do'< = = #      &DK&DKAA$'222BW^^B 55DF"DN"DN"DN        AA$'222BW^^B 55DF"DN"DN"DNNNrc|jsH||j}||jkr|j|_||_||_d|_dSdSNT)rYrOrr^r\f)rirs rr_zScalarFunction._update_fun$sZ~ """46**BDN""!%!#DF!DNNN " "rc|jsQ|jtvr|||j|j|_d|_dSdSNrKT)rZrRr,r_r`rrrerrs rrbzScalarFunction._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[rSr,rbrcrrer<r:rupdatergrhrrs rr{zScalarFunction._update_hess5s~ "*,,!!###++DFtv+>>DO-BCC 4!!### dft{2DFT[4HIIII++DF33!DNNN " "rctj||js||||jSr*)r array_equalrr}r_rrirs rrzScalarFunction.funBsC~a((  NN1    v rctj||js||||jSr*)rrrr}rbrers rr$zScalarFunction.gradHC~a((  NN1    v rctj||js||||jSr*)rrrr}r{r<rs rr3zScalarFunction.hessNrrctj||js|||||j|jfSr*)rrrr}r_rbrrers r fun_and_gradzScalarFunction.fun_and_gradTs\~a((  NN1     vtv~rr*)__name__ __module__ __qualname____doc__ropropertyrsrvrxr}r_rbr{rr$r3rr rrr?r?ZsIIV.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 p ts!tvrtdtdts6tvs-ttstdtdtvrtvrtdt |x_} t|d| } | j} | | j dr| j } | | | _ | _ j j_d_d_d_d _d _d _itvrEd <|d <|t-|} || fd <|d <t/jj _tvr-d <|d <dd<t/jj _tvrtvrtdfdfd} | _| t/jj_jj_trj _d_xjdz c_|s|EtAj!jr,fdtAj"j_d_#nptAj!jr,fdj$_d _#n+fdt/j%j_d _#fd}ntvrtMj fdji_d_|s|FtAj!jr-fd}tAj"j_d_#nrtAj!jr-fd}j$_d _#n,fd}t/j%j_d _#|_'trj j_(d_xjdz c_tAj!j(r%fdtAj"j(_(nWtj(tRrfdn6fdt/j%t/j*j(_(fd}n}tvrfdfd}|d_nVttrA_(j(+jd d_d_,d_-fd!}|_.ttrfd"}nfd#}|_/dS)$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)rsrr")rrris r fun_wrappedz,VectorFunction.__init__..fun_wrappeds* IINII=Q(( (rc2j_dSr*)rr)rrisr update_funz+VectorFunction.__init__..update_funs [((DFFFrc^xjdz c_tj|Sr)njevr0r1rjacris 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)rrisr update_jacz+VectorFunction.__init__..update_jacs$TV,,rr&ctjtjfdji_dSr8)r_r0r1rrrrr(rrisrrz+VectorFunction.__init__..update_jacs\$$&&& ^)+tvAA$&A,?AABBDFFFrctjfdji_dSr8)r_rrrrrrsrrz+VectorFunction.__init__..update_jacsW$$&&&.{DFFFtvF1DFFFMgiiFFFrctjtjfdji_dSr8)r_rr6rrrrrsrrz+VectorFunction.__init__..update_jacs\$$&&&])+tvAA$&A,?AABBDFFFrc`xjdz c_tj||Sr)rxr0r1rvr3ris r hess_wrappedz-VectorFunction.__init__..hess_wrappeds,IINII>$$q!**555rc<xjdz c_||Sr)rxrs rrz-VectorFunction.__init__..hess_wrappeds"IINII41::%rcxjdz c_tjtj||Sr)rxrr6rrs rrz-VectorFunction.__init__..hess_wrappeds6IINII=DDAJJ)?)?@@@rc>jj_dSr*)rrr<)rrisr 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(rrisrrz,VectorFunction.__init__..update_hesssf  """*9dfB.2fhll46.B.B15 BB.ABBrr3c:j|jwjjz }jjjjjjz }j ||dSdSdSr*) rrgJ_prevrrrrrr<r)delta_xdelta_gris rrz,VectorFunction.__init__..update_hess s  """;*t{/F"ft{2G"fhll4622T[]5F5Ftv5N5NNGFMM'733333+*/F/Frc*j_j_t |dj}j|j_d_ d_ d_  dSrz) rrrgrrrrDrUrVrY J_updatedr[r{rrmris rupdate_xz)VectorFunction.__init__..update_x,s  """"f "f dg666DL99!&!&!&!!#####rct|dj}j|j_d_d_d_dSrz)rrDrUrVrrYrr[rs rrz)VectorFunction.__init__..update_x7sKdg666DL99!&!&!&r)0r+r,rr:rr rDrrLrMrNrUrrVrWrXrsrrxrYrr[rrrx_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}} WJ!6!6U UUUVV V O$*"4"4d$9::#5N@JNNNOO O *  !3!3+,, , 'r***" r * * * ::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[)rirs r _update_vzVectorFunction._update_v@s4~a(( #DF"DNNN # #rchtj||js||dSdSr*)rrrrrs rr}zVectorFunction._update_xEs<~a(( #    " " " " " # #rcN|js|d|_dSdSr)rYrrrs rr_zVectorFunction._update_funI3~ "  ! ! # # #!DNNN " "rcN|js|d|_dSdSr)rrrrs rrzVectorFunction._update_jacNrrcN|js|d|_dSdSr)r[rrrs rr{zVectorFunction._update_hessSs3~ "  " " $ $ $!DNNN " "rcb||||jSr*)r}r_rrs rrzVectorFunction.funX- q v rcb||||jSr*)r}rrrs rrzVectorFunction.jac]rrc||||||jSr*)rr}r{r<rirrs rr3zVectorFunction.hessbs? q q v rN) rrrrrorr}r_rr{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. cH|s|5tj|r!tj||_d|_ngtj|r!||_d|_n2t jt j||_d|_|jj \|_ |_ t|x|_ }t|d|}|j}||jdr|j}||||_||_|j|j|_d|_t j|j t2|_tj|j |j f|_dS)NTFrrBrE)rN)r0r9r1rrrrr6rshaperrXr rDrrLrMrNrUrrVrrrYzerosfloatrr<)riAr;rrDrmrns rrozLinearVectorFunction.__init__qsV  )o5#,q//5^A&&DF#'D \!__ )YY[[DF#(D ]2:a==11DF#(D &r***" r * * * ::bh 0 0 XF2v&& DF##$&... 011rctj||jsEt|d|j}|j||j|_d|_dSdSrz)rrrrrDrUrVrYr|s rr}zLinearVectorFunction._update_xs\~a(( #AA$'222BW^^B 55DF"DNNN # #rc|||js&|j||_d|_|jSr)r}rYrrrrs rrzLinearVectorFunction.funs? q~ "VZZ]]DF!DNv rc:|||jSr*)r}rrs rrzLinearVectorFunction.jacs qv rcH||||_|jSr*)r}rr<rs rr3zLinearVectorFunction.hesss" qv rN) rrrrror}rrr3r rrrrjsi 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)lenr0eyersuperro)rir;rrXr __class__s rrozIdentityVectorFunction.__init__sj GG  $o5%(((A"OOq A#O B00000r)rrrrro __classcell__)rs@rrrsB 111111111rr)r )Nr N)NNr N)numpyr scipy.sparsesparser0_numdiffrr_hessian_update_strategyrscipy.sparse.linalgrscipy._lib._array_apirr r,rr-r=r?rrrr rrrs{66666666;;;;;;......========* ,    (!&!&!&!&HDKKKKKKKK\99999999x11111111111r