(phq NSrSSKrSSKrSSKJr SSKJr SSKJ r J r J r J r J r SSKJrJr SS KJr SS KJr S r\R.S 5rS rSrSSjrSSSS\R8*\R84SSSS4 SjrSrSrSr \R8*\R84SS4Sjr!g)z'Routines for numerical differentiation.N)norm)LinearOperator)issparse csc_matrix csr_matrix coo_matrixfind) group_dense group_sparse)array_namespace)array_api_extracUS:Xa[R"U[S9nOAUS:Xa0[R"U5n[R"U[S9nO [ S5e[R "U[R*:HU[R:H-5(aX4$X-nUR5nX- n XP- n US:XaoX-n X:X:-n [R"U5[R"X5:*n XU -==S-ss'X:U )-nXU- X'X:U )-nX*U- X'X4$US:XaX:X:-nX:U)-n[R"XSX-U- 5X'SXn'X:U)-n[R"XSX-U- 5*X'SXo'[R"X5U- nU)[R"U5U:*-nUUUU'SUU'X4$) a<Adjust final difference scheme to the presence of bounds. Parameters ---------- x0 : ndarray, shape (n,) Point at which we wish to estimate derivative. h : ndarray, shape (n,) Desired absolute finite difference steps. num_steps : int Number of `h` steps in one direction required to implement finite difference scheme. For example, 2 means that we need to evaluate f(x0 + 2 * h) or f(x0 - 2 * h) scheme : {'1-sided', '2-sided'} Whether steps in one or both directions are required. In other words '1-sided' applies to forward and backward schemes, '2-sided' applies to center schemes. lb : ndarray, shape (n,) Lower bounds on independent variables. ub : ndarray, shape (n,) Upper bounds on independent variables. Returns ------- h_adjusted : ndarray, shape (n,) Adjusted absolute step sizes. Step size decreases only if a sign flip or switching to one-sided scheme doesn't allow to take a full step. use_one_sided : ndarray of bool, shape (n,) Whether to switch to one-sided scheme. Informative only for ``scheme='2-sided'``. 1-sideddtype2-sidedz(`scheme` must be '1-sided' or '2-sided'.?TF) np ones_likeboolabs zeros_like ValueErrorallinfcopymaximumminimum)x0h num_stepsschemelbub use_one_sidedh_total h_adjusted lower_dist upper_distxviolatedfittingforwardbackwardcentralmin_distadjusted_centrals J/var/www/html/venv/lib/python3.13/site-packages/scipy/optimize/_numdiff.py_adjust_scheme_to_boundsr6 s> Qd3 9  FF1I at4 CDD vvrbffW}rvv.//mGJJJ  LFqv&&&/RZZ %GGg%&",&+x7(1I= +x7 * 44y@ &  $$% 9 (Z-BC+x7 jj Jj11I=? !% +x7 " Kz33i?!A A "& ::j5 A$Hz(:h(FG'/0@'A #$*/ &'  $$cj[R"[R5RnSn[R"U[R 5(aB[R"U5Rn[R "U5RnSn[R"U[R 5(aM[R "U5RnU(a&UW:a [R"U5RnUS;aUS-$US;aUS-$[S5e)aX Calculates relative EPS step to use for a given data type and numdiff step method. Progressively smaller steps are used for larger floating point types. Parameters ---------- f0_dtype: np.dtype dtype of function evaluation x0_dtype: np.dtype dtype of parameter vector method: {'2-point', '3-point', 'cs'} Returns ------- EPS: float relative step size. May be np.float16, np.float32, np.float64 Notes ----- The default relative step will be np.float64. However, if x0 or f0 are smaller floating point types (np.float16, np.float32), then the smallest floating point type is chosen. FT)2-pointcsr)3-pointgUUUUUU?zBUnknown step method, should be one of {'2-point', '3-point', 'cs'}) rfinfofloat64eps issubdtypeinexactritemsize RuntimeError)x0_dtypef0_dtypemethodEPSx0_is_fp x0_itemsize f0_itemsizes r5_eps_for_methodrJ\s< ((2::  " "CH }}Xrzz**hhx $$hhx(11  }}Xrzz**hhx(11  k1((8$((C ""Cx ; Sz:; ;r7c US:R[5S-S- n[URURU5nUc2XT-[R "S[R "U55-nU$X-[R "U5-nX-U- n[R"US:HXT-[R "S[R "U55-U5nU$)a* Computes an absolute step from a relative step for finite difference calculation. Parameters ---------- rel_step: None or array-like Relative step for the finite difference calculation x0 : np.ndarray Parameter vector f0 : np.ndarray or scalar method : {'2-point', '3-point', 'cs'} Returns ------- h : float The absolute step size Notes ----- `h` will always be np.float64. However, if `x0` or `f0` are smaller floating point dtypes (e.g. np.float32), then the absolute step size will be calculated from the smallest floating point size. rrr ?)astypefloatrJrrr rwhere)rel_stepr"f0rEsign_x0rstepabs_stepdxs r5_compute_absolute_steprVs6Qwu%)A-G BHHbhh 7E?RZZRVVBZ%@@ O%r 2}"88B!G!ObjjbffRj.II$& Or7cSU5up#URS:Xa [R"X!R5nURS:Xa [R"X1R5nX#4$)aA Prepares new-style bounds from a two-tuple specifying the lower and upper limits for values in x0. If a value is not bound then the lower/upper bound will be expected to be -np.inf/np.inf. Examples -------- >>> _prepare_bounds([(0, 1, 2), (1, 2, np.inf)], [0.5, 1.5, 2.5]) (array([0., 1., 2.]), array([ 1., 2., inf])) c3T# UHn[R"U[S9v M g7f)rN)rasarrayrN).0bs r5 "_prepare_bounds..s 9&Qbjj%(&s&(r)ndimrresizeshape)boundsr"r&r's r5_prepare_boundsrbsQ:& 9FB ww!| YYr88 $ ww!| YYr88 $ 6Mr7c[U5(a [U5nO8[R"U5nUS:gR [R 5nUR S:wa [S5eURup#Ub[R"U5(a1[RRU5nURU5nO2[R"U5nURU4:wa [S5eUSS2U4n[U5(a"[X#URUR 5nO [#X#U5nUR%5XQ'U$)ajGroup columns of a 2-D matrix for sparse finite differencing [1]_. Two columns are in the same group if in each row at least one of them has zero. A greedy sequential algorithm is used to construct groups. Parameters ---------- A : array_like or sparse matrix, shape (m, n) Matrix of which to group columns. order : int, iterable of int with shape (n,) or None Permutation array which defines the order of columns enumeration. If int or None, a random permutation is used with `order` used as a random seed. Default is 0, that is use a random permutation but guarantee repeatability. Returns ------- groups : ndarray of int, shape (n,) Contains values from 0 to n_groups-1, where n_groups is the number of found groups. Each value ``groups[i]`` is an index of a group to which ith column assigned. The procedure was helpful only if n_groups is significantly less than n. References ---------- .. [1] A. Curtis, M. J. D. Powell, and J. Reid, "On the estimation of sparse Jacobian matrices", Journal of the Institute of Mathematics and its Applications, 13 (1974), pp. 117-120. rrz`A` must be 2-dimensional.Nz`order` has incorrect shape.)rrr atleast_2drMint32r^rr`isscalarrandom RandomState permutationrYr indicesindptrr r)Aordermnrnggroupss r5 group_columnsrrs<{{ qM MM!  !VOOBHH %vv{566 77DA } E**ii##E*" 5! ;;1$ ;< < !U( A{{aAIIqxx8Q1%KKMFM Mr7r;Fc 8^^^ ^ ^US;a[SUS35e[T5m[R"TR T5STS9n TR n TR U RS5(a U Rn TRX5mTRS:a [S5e[UT5upU RTR:wdURTR:wa [S5eU(ai[R"[R"U 55(a/[R"[R"U55(d [S 5eT c0m U UU UU4S jnUc U"T5nO1[R"U5nURS:a [S 5e[R "TU :TU:-5(a [S 5eU(a2Uc![#TRURU5n[%UTXSU5$Uc['UTXR5nOTS :R[(5S-S- nUnTU-T- n[R*"US :H[#TRURU5U-[R,"S[R."T55-U5nUS:Xa[1TUSSX5unnO!US:Xa[1TUSSX5unnOUS:XaSnUc[3UTUUWU5$[5U5(d[7U5S:XaUunnO Un[9U5n[5U5(a [;U5nO[R<"U5n[R"U5n[?UTUUWUUU5$)aCompute finite difference approximation of the derivatives of a vector-valued function. If a function maps from R^n to R^m, its derivatives form m-by-n matrix called the Jacobian, where an element (i, j) is a partial derivative of f[i] with respect to x[j]. Parameters ---------- fun : callable Function of which to estimate the derivatives. The argument x passed to this function is ndarray of shape (n,) (never a scalar even if n=1). It must return 1-D array_like of shape (m,) or a scalar. x0 : array_like of shape (n,) or float Point at which to estimate the derivatives. Float will be converted to a 1-D array. method : {'3-point', '2-point', 'cs'}, optional Finite difference method to use: - '2-point' - use the first order accuracy forward or backward difference. - '3-point' - use central difference in interior points and the second order accuracy forward or backward difference near the boundary. - 'cs' - use a complex-step finite difference scheme. This assumes that the user function is real-valued and can be analytically continued to the complex plane. Otherwise, produces bogus results. rel_step : None or array_like, optional Relative step size to use. If None (default) the absolute step size is computed as ``h = rel_step * sign(x0) * max(1, abs(x0))``, with `rel_step` being selected automatically, see Notes. Otherwise ``h = rel_step * sign(x0) * abs(x0)``. For ``method='3-point'`` the sign of `h` is ignored. The calculated step size is possibly adjusted to fit into the bounds. abs_step : array_like, optional Absolute step size to use, possibly adjusted to fit into the bounds. For ``method='3-point'`` the sign of `abs_step` is ignored. By default relative steps are used, only if ``abs_step is not None`` are absolute steps used. f0 : None or array_like, optional If not None it is assumed to be equal to ``fun(x0)``, in this case the ``fun(x0)`` is not called. Default is None. bounds : tuple of array_like, optional Lower and upper bounds on independent variables. Defaults to no bounds. 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. Bounds checking is not implemented when `as_linear_operator` is True. sparsity : {None, array_like, sparse matrix, 2-tuple}, optional Defines a sparsity structure of the Jacobian matrix. If the Jacobian matrix is known to have only few non-zero elements in each row, then it's possible to estimate its several columns by a single function evaluation [3]_. To perform such economic computations two ingredients are required: * structure : array_like or sparse matrix of shape (m, n). A zero element means that a corresponding element of the Jacobian identically equals to zero. * groups : array_like of shape (n,). A column grouping for a given sparsity structure, use `group_columns` to obtain it. A single array or a sparse matrix is interpreted as a sparsity structure, and groups are computed inside the function. A tuple is interpreted as (structure, groups). If None (default), a standard dense differencing will be used. Note, that sparse differencing makes sense only for large Jacobian matrices where each row contains few non-zero elements. as_linear_operator : bool, optional When True the function returns an `scipy.sparse.linalg.LinearOperator`. Otherwise it returns a dense array or a sparse matrix depending on `sparsity`. The linear operator provides an efficient way of computing ``J.dot(p)`` for any vector ``p`` of shape (n,), but does not allow direct access to individual elements of the matrix. By default `as_linear_operator` is False. args, kwargs : tuple and dict, optional Additional arguments passed to `fun`. Both empty by default. The calling signature is ``fun(x, *args, **kwargs)``. Returns ------- J : {ndarray, sparse matrix, LinearOperator} Finite difference approximation of the Jacobian matrix. If `as_linear_operator` is True returns a LinearOperator with shape (m, n). Otherwise it returns a dense array or sparse matrix depending on how `sparsity` is defined. If `sparsity` is None then a ndarray with shape (m, n) is returned. If `sparsity` is not None returns a csr_matrix with shape (m, n). For sparse matrices and linear operators it is always returned as a 2-D structure, for ndarrays, if m=1 it is returned as a 1-D gradient array with shape (n,). See Also -------- check_derivative : Check correctness of a function computing derivatives. Notes ----- If `rel_step` is not provided, it assigned as ``EPS**(1/s)``, where EPS is determined from the smallest floating point dtype of `x0` or `fun(x0)`, ``np.finfo(x0.dtype).eps``, s=2 for '2-point' method and s=3 for '3-point' method. Such relative step approximately minimizes a sum of truncation and round-off errors, see [1]_. Relative steps are used by default. However, absolute steps are used when ``abs_step is not None``. If any of the absolute or relative steps produces an indistinguishable difference from the original `x0`, ``(x0 + dx) - x0 == 0``, then a automatic step size is substituted for that particular entry. A finite difference scheme for '3-point' method is selected automatically. The well-known central difference scheme is used for points sufficiently far from the boundary, and 3-point forward or backward scheme is used for points near the boundary. Both schemes have the second-order accuracy in terms of Taylor expansion. Refer to [2]_ for the formulas of 3-point forward and backward difference schemes. For dense differencing when m=1 Jacobian is returned with a shape (n,), on the other hand when n=1 Jacobian is returned with a shape (m, 1). Our motivation is the following: a) It handles a case of gradient computation (m=1) in a conventional way. b) It clearly separates these two different cases. b) In all cases np.atleast_2d can be called to get 2-D Jacobian with correct dimensions. References ---------- .. [1] W. H. Press et. al. "Numerical Recipes. The Art of Scientific Computing. 3rd edition", sec. 5.7. .. [2] A. Curtis, M. J. D. Powell, and J. Reid, "On the estimation of sparse Jacobian matrices", Journal of the Institute of Mathematics and its Applications, 13 (1974), pp. 117-120. .. [3] B. Fornberg, "Generation of Finite Difference Formulas on Arbitrarily Spaced Grids", Mathematics of Computation 51, 1988. Examples -------- >>> import numpy as np >>> from scipy.optimize._numdiff import approx_derivative >>> >>> def f(x, c1, c2): ... return np.array([x[0] * np.sin(c1 * x[1]), ... x[0] * np.cos(c2 * x[1])]) ... >>> x0 = np.array([1.0, 0.5 * np.pi]) >>> approx_derivative(f, x0, args=(1, 2)) array([[ 1., 0.], [-1., 0.]]) Bounds can be used to limit the region of function evaluation. In the example below we compute left and right derivative at point 1.0. >>> def g(x): ... return x**2 if x >= 1 else x ... >>> x0 = 1.0 >>> approx_derivative(g, x0, bounds=(-np.inf, 1.0)) array([ 1.]) >>> approx_derivative(g, x0, bounds=(1.0, np.inf)) array([ 2.]) )r9r;r:zUnknown method 'z'. r )r^xp real floatingz#`x0` must have at most 1 dimension.z,Inconsistent shapes between bounds and `x0`.z7Bounds not supported when `as_linear_operator` is True.c>TRURS5(aTRUTR5n[R"T"U/TQ70TD65nUR S:a [ S5eU$)Nrvr z-`fun` return value has more than 1 dimension.)isdtyperrMr atleast_1dr^rB)r-fargsfunkwargsr"rus r5 fun_wrapped&approx_derivative..fun_wrappedsm ::agg / / !RXX&A MM#a1$1&1 2 66A: 89 9r7z&`f0` passed has more than 1 dimension.z `x0` violates bound constraints.rrrLr9rr;rr:F) rrxpx atleast_ndrYr=rxrrMr^rbr`rrisinfryanyrJ_linear_operator_differencerVrNrOr rr6_dense_differencerlenrrrrd_sparse_difference)r|r"rErPrTrQrasparsityas_linear_operatorr{r}_x_dtyper&r'r~r#rRrUr( structurerqrus`` `` @r5approx_derivativersFF11+F83788  B  2Q2 6B ZZF zz"((O,, 2 B ww{>?? VR (FB xx288rxx2883GHH266"((2,#7#7')vvbhhrl';';9: :~   z _ ]]2  77Q;EF F vvrBw27#$$;<<  &rxx6BH*;+-A A  &xR@AQw&&u-1A5GA6R-Bq(288VD !#%::c266":#>?A Y 7Aq)R - A} y 7Aq)R - A} t^!M  $["b!%2F< <H%%#h-1*<$,! 6$ &x0 ""&y1 MM)4 ]]6*F%k2r1&3Y&,f6 6r7c^^^^^TRmTRnUS:Xa UUUUU4SjnO+US:Xa UUUU4SjnOUS:Xa UUUU4SjnO [S5e[TU4U5$)Nr9c>[R"U[R"U55(a[R"T5$T[ U5- nTX--nT"U5T- nX1- $)Nr array_equalrzerosr) prUr-dfrQr|r#rnr"s r5matvec+_linear_operator_difference..matvec$sW~~aq!122xx{"T!WBRT AQ"B7Nr7r;c>[R"U[R"U55(a[R"T 5$ST-[ U5- nT US- U-- nT US- U--nT"U5nT"U5nXT- nXa- $)Nrr) rrUx1x2f1f2rr|r#rnr"s r5rr-s~~~aq!122xx{"1tAwBr!tQhBr!tQhBRBRBB7Nr7r:c>[R"U[R"U55(a[R"T5$T[ U5- nTX-S--nT"U5nUR nXA- $)N?)rrrrrimag) rrUr-rrr|r#rnr"s r5rr9s`~~aq!122xx{"T!WBRT#X AQBB7Nr7Never be here.)sizerBr)r|r"rQr#rErorrns```` @r5rrsm A A    9    4  +,, 1a&& ))r7cURnURn[R"Xv45nUR5n UR5n UR [ SS9n [ UR5GHn US:Xa#X==X<- ss'XX- n U"U 5U- nOUS:XaPXL(aGX==X<- ss'X==SX<-- ss'XX- n U"U 5nU"U 5nSU-SU--U- nOUS:XaDXL(d;X==X<-ss'X==X<- ss'XX- n U"U 5nU"U 5nUU- nO;US:Xa*X==X<S -- ss'U"U 5nURnX<n O [S 5eX- X'X=X'=X'X'GM US :Xa[R"U5nUR$) NT)rr9r;rgr:rrr ) rremptyrrMcomplexrangerrBravelT)r|r"rQr#r(rErnro J_transposedrrxcirUrrrs r5rrHs A A88QF#L B B 7 &B 166] Y  EQTMEBR2B y ]%5 EQTME EQX EBRBRBQV#b(B y )9 EQTME EQTMEBRBRBbB t^ EQTCZ ERBBB/0 0'  "%%9< Avxx - >>r7cURnURn /n /n /n [R"U5S-n [U 5GHCn[R"X5nX?-nUS:XaJUU-nUU- nU"U5U- n[R "U5un[ USS2U45unnnUUnGOUS:XGa1UR5nUR5nXO-nUU==UU- ss'UU==SUU-- ss'U)U-nUU==UU-ss'UU==UU- ss'[R"U 5nUUUU- UU'UUUU- UU'U"U5nU"U5n[R "U5un[ USS2U45unnnUUnUUn[R"U5nUUnSUU-SUU--UU- UU'UU)nUUUU- UU'OaUS:XaPU"UUS--5nURnUn[R "U5un[ USS2U45unnnUUnO [S 5eU RU5 U RU5 U RUUUU- 5 GMF [R"U 5n [R"U 5n [R"U 5n [XU 44X4S 9n [U 5$) Nr r9r;rrr:rr)r`)rrmaxrequalnonzeror rrrrrappendhstackr r)!r|r"rQr#r(rrqrErnro row_indices col_indices fractionsn_groupsgroupeh_vecr-rUrcolsrj_rrmask_1mask_2rrmaskrowsJs! r5rrts A AKKIvvf~!Hx HHU # Y U ARBQ"BJJqMED9QW-.GAq!QA y BB"&F vJ%- 'J vJ!eFm+ +J#^a'F vJ%- 'J vJ%- 'J!BFbj0BvJFbj0BvJRBRBJJqMED9QW-.GAq!QA #D!BT7DBtH}q2d8|3bh>BtHdU8D$x"T(*BtH t^R%)^$BBBJJqMED9QW-.GAq!QA-. . 11AA'}!@))K(K))K(K )$II[9:1&IA a=r7c ZUc0nU"U/UQ70UD6n[U5(a[XX6XES9n[U5nXg- n[U5upn [R "XyU 45R 5n [R"[R"U 5[R"S[R"U 55- 5$[XUXES9n[R"Xg- 5n[R"U[R"S[R"U55- 5$)a|Check correctness of a function computing derivatives (Jacobian or gradient) by comparison with a finite difference approximation. Parameters ---------- fun : callable Function of which to estimate the derivatives. The argument x passed to this function is ndarray of shape (n,) (never a scalar even if n=1). It must return 1-D array_like of shape (m,) or a scalar. jac : callable Function which computes Jacobian matrix of `fun`. It must work with argument x the same way as `fun`. The return value must be array_like or sparse matrix with an appropriate shape. x0 : array_like of shape (n,) or float Point at which to estimate the derivatives. Float will be converted to 1-D array. bounds : 2-tuple of array_like, optional Lower and upper bounds on independent variables. Defaults to no bounds. 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. args, kwargs : tuple and dict, optional Additional arguments passed to `fun` and `jac`. Both empty by default. The calling signature is ``fun(x, *args, **kwargs)`` and the same for `jac`. Returns ------- accuracy : float The maximum among all relative errors for elements with absolute values higher than 1 and absolute errors for elements with absolute values less or equal than 1. If `accuracy` is on the order of 1e-6 or lower, then it is likely that your `jac` implementation is correct. See Also -------- approx_derivative : Compute finite difference approximation of derivative. Examples -------- >>> import numpy as np >>> from scipy.optimize._numdiff import check_derivative >>> >>> >>> def f(x, c1, c2): ... return np.array([x[0] * np.sin(c1 * x[1]), ... x[0] * np.cos(c2 * x[1])]) ... >>> def jac(x, c1, c2): ... return np.array([ ... [np.sin(c1 * x[1]), c1 * x[0] * np.cos(c1 * x[1])], ... [np.cos(c2 * x[1]), -c2 * x[0] * np.sin(c2 * x[1])] ... ]) ... >>> >>> x0 = np.array([1.0, 0.5 * np.pi]) >>> check_derivative(f, jac, x0, args=(1, 2)) 2.4492935982947064e-16 )rarr{r}r )rar{r}) rrrr rrYrrrr ) r|jacr"rar{r} J_to_testJ_diffabs_errrr abs_err_data J_diff_datas r5check_derivativersz~B(((I "36(,=y) $!']ljj1.446 vvbff\*jjBFF;$789: :#36(,=&&+,vvg 1bffVn ==>>r7)r)"__doc__ functoolsnumpyr numpy.linalgrscipy.sparse.linalgrsparserrrr r _group_columnsr r scipy._lib._array_apir scipy._librrr6 lru_cacherJrVrbrrrrrrrrrsr7r5rs-.GG51-L%^ 2;2;j.b*:z'0$w&7$).RG6T&*R)XM`-/FF7BFF*;" M?r7