+ nDjo |Rt^RIt^RIt^RIHt^RIHt^RIH t H t H t H t H t Ht^RIHtHt^RIHtHt^RIHt^RIHtR t]P6R 4tR tR tRR ltRRRR]P@)]P@3RRRRRR3 Rlt!Rt"Rt#Rt$!RR4t%]P@)]P@3RR3Rlt&R#)z'Routines for numerical differentiation.N)norm)LinearOperator)issparsespmatrixfind csc_array csr_array csr_matrix) group_dense group_sparse)array_namespacexp_result_type) MapWrapper)array_api_extracVR8Xd\P!V\R7pMEVR8Xd4\P!V4p\P!V\R7pM \ R4h\P !V\P)8HV\P8H,4'dW3#W,pVP4pW, p WP, p VR8XdW,p W8W8,p \P!V4\P!W48*p WV ,;;,R,uu&W8V (,pW,V, W&W8V (,pW,)V, W&W3#VR8XdW8W8,pW8V(,p\P!W,RW,,V, 4W&RWn&W8V(,p\P!W,RW,,V, 4)W&RWo&\P!W4V, pV(\P!V4V8*,pVV,VV&RVV&W3#) 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&&&&&& Q/data/cameron/venvs/s3viz/lib/python3.14/site-packages/scipy/optimize/_numdiff.py_adjust_scheme_to_boundsr6s> 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 #$*/ &'  $$c\P!\P4PpRp\P!V\P 4'dC\P!V4Pp\P !V4PpRp\P!V\P 4'dP\P !V4PpV'd(VX8d!\P!V4PpVR9d VR,#VR9d VR,#\R4h)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. FTrzBUnknown step method, should be one of {'2-point', '3-point', 'cs'})2-pointcs)3-pointgUUUUUU?) 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:; ;r7cV^8PVP4^,^, p\VPVPV4pWT,\P!R\P !V44,PVP4pVfTpV#W,\P !V4,PVP4pW,V, p\P !V^8HVV4pV#)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 : np.array The absolute step size, ``h.dtype==x0.dtype``. Notes ----- `h` has the same dtype as `x0` because dx is later calculated as ``(x0 + h) - x0``, and problems would occur if ``x0.dtype==np.float16`` with ``h.dtype==np.float64``. If `rel_step is None`, then a default relative step is calculated using the smallest floating point type of `x0` and `f0`, see _eps_for_method. ?)astyperrJrr rwhere) rel_stepr"f0rEsign_x0rstepdefault_abs_stepabs_stepdxs &&&& r5_compute_absolute_steprVs<Qwrxx(1,q0G BHHbhh 7E "**S"&&*55 fRXX#$ O   + &   }"88 !G    Or7cRV4wr#VP^8Xd!\P!W!P4pVP^8Xd!\P!W1P4pW#3#)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])) c3Z"TF!p\P!V\R7xK# R#5i)rN)rasarrayfloat).0bs& r5 "_prepare_bounds..s 9&Qbjj%((&s)+)ndimrresizeshape)boundsr"r&r's&& r5_prepare_boundsrcsQ:& 9FB ww!| YYr88 $ ww!| YYr88 $ 6Mr7c\V4'd \V4pM8\P!V4pV^8gP \P 4pVP ^8wd \R4hVPwr#Ve\P!V4'd2\PPV4pVPV4pM3\P!V4pVPV38wd \R4hVRV3,p\V4'd#\W#VPVP 4pM \#W#V4pVP%4WQ&V#)aiGroup 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 array, 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. z`A` must be 2-dimensional.z`order` has incorrect shape.NNN)rrr atleast_2drMint32r_rraisscalarrandom RandomState permutationrYr indicesindptrr r)Aordermnrnggroupss&& r5 group_columnsrts<{{ aL MM!  !VOOBHH %vv{566 77DA } E**ii##E*" 5! ;;1$ ;< < !U( A{{aAIIqxx8Q1%KKMFM Mr7r;Fc VR9d\RV R24hRR/p \V4p\P!VP V4^VR7pVP pVP VPR 4'd VPpVPVV4pVP^8d \R 4h\Wa4wppVPVP8wgVPVP8wd \R 4hV'dl\P!\P!V44'd1\P!\P!V44'g \R 4hV f/p \WW4p^;ppVf V!V4p^pM2\P !V4pVP^8d \R 4h\P"!VV8VV8,4'd \R4hV'd9Vf"\%VPVPV4p\'VVWSV4wppEMVf\)W1WR4pMV^8PVP4^,^, pTpVV,V, p\P*!V^8H\%VPVPV4V,\P,!R\P.!V44,V4pVPVP4pVR8Xd\1VV^RVV4wppM$VR8Xd\1VV^RVV4wppM VR8XdRpT ;'g\2p \5V 4;_uu_4pVf\7VWVXVV4wppM\9V4'g\;V4^8XdVwppM Tp\=V4p\9V4'dVP?4pM\P@!V4p\P !V4p\CVWVXVVVV4 wppRRR4V 'dVV, pVV R&XV 3#X# +'giL,;i)u_)Compute 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))).astype(x0.dtype)``, with `rel_step` being selected automatically, see Notes. Otherwise ``h = (rel_step * sign(x0) * abs(x0)).astype(x0.dtype)``. 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. `abs_step` is coerced to the dtype of `x0` during calculation. 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 array, 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 array 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 array 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 array 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)``. full_output : bool, optional If True then the function also returns a dictionary with extra information about the calculation. workers : int or map-like callable, optional Supply a map-like callable, such as `multiprocessing.Pool.map` for evaluating the population in parallel. This evaluation is carried out as ``workers(fun, iterable)``. Alternatively, if `workers` is an int the task is subdivided into `workers` sections and the fun evaluated in parallel (uses `multiprocessing.Pool `). Supply -1 to use all available CPU cores. It is recommended that a map-like be used instead of int, as repeated calls to `approx_derivative` will incur large overhead from setting up new processes. Returns ------- J : {ndarray, sparse array, 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 array depending on how `sparsity` is defined. If `sparsity` is None then an ndarray with shape (m, n) is returned. If `sparsity` is not None returns a csr_array or csr_matrix with shape (m, n) following the array/matrix type of the incoming structure. For sparse arrays 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,). `J.dtype` is the promoted type of ``fun(x0)`` and `x0`. info_dict : dict Dictionary containing extra information about the calculation. The keys include: - `nfev`, number of function evaluations. If `as_linear_operator` is True then `fun` is expected to track the number of evaluations itself. This is because multiple calls may be made to the linear operator which are not trackable here. See Also -------- check_derivative : Check correctness of a function computing derivatives. Notes ----- If `rel_step` is not provided, it is 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. This 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. The calculated absolute step size, `h`, is coerced to have the same dtype as `x0`. The floating point precision of `J` is the promoted type of ``fun(x0)`` and `x0`. If `rel_step` and `abs_step` are None, then the overall accuracy of `J` depends on the smallest floating point dtype of `x0` and ``fun(x0)``, as that dtype is used to calculate the default step size. 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.]) We can also parallelize the derivative calculation using the workers keyword. >>> from multiprocessing import Pool >>> import time >>> def fun2(x): # import from an external file for use with multiprocessing ... time.sleep(0.002) ... return rosen(x) >>> rng = np.random.default_rng() >>> x0 = rng.uniform(high=10, size=(2000,)) >>> f0 = rosen(x0) >>> %timeit approx_derivative(fun2, x0, f0=f0) # may vary 10.5 s ± 5.91 ms per loop (mean ± std. dev. of 7 runs, 1 loop each) >>> elapsed = [] >>> with Pool() as workers: ... for i in range(10): ... t = time.perf_counter() ... approx_derivative(fun2, x0, workers=workers.map, f0=f0) ... et = time.perf_counter() ... elapsed.append(et - t) >>> np.mean(elapsed) # may vary np.float64(1.442545195999901) Create a map-like vectorized version. `x` is a generator, so first of all a 2-D array, `xx`, is reconstituted. Here `xx` has shape `(Y, N)` where `Y` is the number of function evaluations to perform and `N` is the dimensionality of the objective function. The underlying objective function is `rosen`, which requires `xx` to have shape `(N, Y)`, so a transpose is required. >>> def fun(f, x, *args, **kwds): ... xx = np.r_[[xs for xs in x]] ... return f(xx.T) >>> %timeit approx_derivative(fun2, x0, workers=fun, f0=f0) # may vary 91.8 ms ± 755 μs per loop (mean ± std. dev. of 7 runs, 10 loops each) r9r;r:zUnknown method 'z'. nfevN)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.z&`f0` passed has more than 1 dimension.z `x0` violates bound constraints.rLrrF)r9r;r:)"rr xpx atleast_ndrYr=isdtyperrMr_rcrarrisinf _Fun_Wrapper atleast_1danyrJ_linear_operator_differencerVrNr rr6mapr_dense_differencerlenrttocscrf_sparse_difference)funr"rErOrTrPrbsparsityas_linear_operatorargskwargs full_outputworkers info_dictrw_x_dtyper&r' fun_wrappedrv_nfevJ_r#rQrUr(mf structurerss&&&&&&&&&&&&& r5approx_derivativer sT11+F83788I  B  2Q2 6B ZZF zz"((O,, 2v B ww{>?? V (FB xx288rxx2883GHH266"((2,#7#7')vvbhhrl';';9: :~s5KD5 z _ ]]2  77Q;EF F vvrBw27#$$;<<  &rxx6BH*;+-A1  &xR@AQw&&rxx014q8GA6R-Bq(288VD !#%::c266":#>?A"A Y 7Aq)R - A} y 7Aq)R - A} t^!M..S  B,["!)6)+-5 ))c(mq.@(0%Iv (I*84FI&& ) 1I " i 8Iv.-k21-:I-3VRA5#!*   &)|5! s B0Q Q$ c aaaaaaSPoSPp\SSR\R7oVR8Xd VVVVVV3RlpM/VR8Xd VVVVV3RlpMVR8Xd VVVVV3RlpM \R4h\ SV3VSR 7^3#) Tforce_floatingrwr9c<\P!V\P!V44'd\P!SSR7#S\ V4, pS W,,pS!V4S, pW1, #rr array_equalrzerosr) prUr-dfrPrr#rp result_dtyper"s & r5matvec+_linear_operator_difference..matvecsZ~~aq!122xx66T!WBRT AQ"B7Nr7r;cd<\P!V\P!V44'd\P!S S R7#^S,\ V4, pS V^, V,, pS V^, V,,pS!V4pS!V4pWT, pWa, #rr) rrUx1x2f1f2rrr#rprr"s & r5rrs~~aq!122xx661tAwBr!tQhBr!tQhBRBRBB7Nr7r:c<\P!V\P!V44'd\P!SSR7#S\ V4, pS W,R,,pS!V4pVP pWA, #)r?)rrrrrimag) rrUr-rrrr#rprr"s & r5rrsc~~aq!122xx66T!WBRT#X AQBB7Nr7Never be here.)rarr)sizer rrBr) rr"rPr#rErqrrprs ffff& @@r5rr~s A A!"b"EL    9    4  +,, Av\ JA MMr7c >aVPpVPo^p\WR\R7p \P!SV3V R7p VR8XdV3Rlp V!W !W44p \ S4U u.uF%qV ,W=,,W,, NK' pp V Uu.uF qV, NK pp\ VV4UUu.uFwppVV, NK pppV\ V4, pEMVR8XEdVRp\V!VV!WV444p V!WV4p\4p\4p\V4Fwp p\V4p\V4p\V 4p\V 4pV'dUVPVV ,W,, 4VPR V,^V,,V, 4KVPVV ,VV ,, 4VPVV, 4K \ VV4UUu.uFwppVV, NK pppV^\ V4,, pMsVR8XdbV3R lp\V!VV!W444p \ W4UUu.uFwppVPV, NK pppV\ V4, pM \R 4h\V4F wp pVW&K V^8Xd\P!V 4p V PV3#uup iuupiuuppiuuppiuuppi) Trrr9c3<"\S4F4p\P!V4pW,W,,W2&VxK6 R#5iN)rangerr)r"r#irrqs&& r5 x_generator2'_dense_difference..x_generator2s71XWWR[ sAA r;c3v"\V4Fwr4\P!V4p\P!V4pV'd7W,W,,WS&W,^W,,,Wc&M.W,W,, WS&W,W,,Wc&VxVxK R#5iN) enumeraterr)r"r#r(r one_sidedrrs&&& r5 x_generator3'_dense_difference..x_generator3s} )- 8 WWR[WWR[EADLBEEAadFNBEEADLBEEADLBE!9sB7B9r:c3<"\S4F?pVP\RR7pW2;;,W,R,, uu&VxKA R#5i)TrrN)rrMcomplex)r"r#rxcrqs&& r5x_generator_cs)_dense_difference..x_generator_css=1XYYwTY2#sAArg)rr remptyrzipriterlistrnextappendrrBravelT)rr"rPr#r(rErrprv result_type J_transposedrf_evalsrrUf_evalrdelfdelxdf_dxrgenrlurrrhivrqs&&&&&&& @r5rrs A A D!DK88QF+6L  #|B23.3Ah 7h!uqt|ru$$h 7(/ 0frkk 0/22r{;{t{; E  9  wsL $FGH2-0 V V%m4LAyS AS AgBgB !A$,' $)a"f,r12 !A$1+& "r'"5032r{;{t{; CJ 4  wsN2$9:;,/O>4 u8 0;F<=s0+L!LL L?Lc 0aaaaa$a%VPp SPp .p .p .p \SVR\R7p\P!S4^,o%^pVV%3Rlo$V$VV3RlpV$VVV3RlpV$VV3RlpVR8Xd \ V!VV!444pV!4pMDVR8Xd \ V!VV!444pV!4pMVR8Xd\ V!VV!444pS$!4EF+p\P !V4wp\ VR V3,4wpppVV,pVR8Xd0\X4S, p\X4V, pV^, pEMpVR8XEd-\X4p\V4pSV,pS(V,p\P!V SPR 7pVV,SV,, VV&VV,VV,, VV&\X4p \V4p!V^, pSV,p"\P!WPR 7pVV",p#R VV#,,^V V#,,,V!V#,, VV#&VV"(,p#V!V#,V V#,, VV#&M.e_generators%8_E((5&) )%.1c3\<"S!4pVFpSV,pSV,pVxK R#5ir)e_geneh_vecr-rr#r"s r5r(_sparse_difference..x_generator2s. AEEU AGs),c3<"S!4pVFpSV,pS P4pS P4pS V,pW5;;,W%,, uu&WE;;,^W%,,, uu&S (V,pW6;;,W&,,uu&WF;;,W&,, uu&VxVxK R#5irr) rrrrrmask_1mask_2rr#r(r"s r5r(_sparse_difference..x_generator3s AEEBB"Q&F J%- 'J J!em+ +J#^a'F J%- 'J J%- 'JHHsCC c3f<"S!4pVFpSV,pSVR,,xK R#5i)rNr)rrrrr#r"s r5r*_sparse_difference..x_generator_cs+s/ AEEus{" "rr9r;r:rerr)rar)rr rmaxrnonzerorrrrrrrrhstack isinstancerr r)&rr"rPr#r(rrsrErrprq row_indices col_indices fractionsrrvrrrrxsrcolsrjrrUrrrrrrrmaskrowsrrs&&f&ff&f&& @@r5rrs* A AKKI RDKvvf~!H D* "#wsLN34 ^ 9 wsLN34 ^ 4wsN$456 ] 1 yD)*1a G Y bBBg#B AID y bBbB"Q&F#^a'F!288,BFbj0BvJFbj0BvJgBgB AID #D!88,BT7DBtH}q2d8|3bh>BtHdU8D$x"T(*BtH t^gB AIDBQB-. . 11AA'eh))K(K))K(K )$I)X&& k2 3&      +./f    r7c,a]tRtRtoRtRtRtVtR#)r}ic6WnW nW0nW@nR#r)rr"rr)selfrr"rrs&&&&&r5__init___Fun_Wrapper.__init__s  r7cr\VP4pVPVPR4'd&VP WPP4p\ P !VP!V.VPO5/VPB4pVP^8d \R4hV#)rxz-`fun` return value has more than 1 dimension.) r r"r{rrMrr~rrrr_rB)rr-rwfs&& r5__call___Fun_Wrapper.__call__sTWW % ::agg / / !WW]]+A MM$((1@tyy@DKK@ A 66A: 89 9r7)rrrr"N)__name__ __module__ __qualname____firstlineno__rr__static_attributes____classdictcell__) __classdict__s@r5r}r}s  r7r}c Vf/pV!V.VO5/VBp\V4'd\WW6WER7p\V4pWg, p\V4wrp \P !WyV 3,4P 4p \P!\P!V 4\P!^\P!V 44, 4#\WVWER7p\P!Wg, 4p\P!V\P!^\P!V44, 4#)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 array 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 )rbrrr)rbrr) rrrrrrYrrrr ) rjacr"rbrr J_to_testJ_diffabs_errrr abs_err_data J_diff_datas &&&&&& r5check_derivativersz~B(((I "36(,=i( $!']ljj1.446 vvbff\*jjBFF;$789: :#36(,=&&+,vvg 1bffVn ==>>r7)rr)'__doc__ functoolsnumpyr numpy.linalgrscipy.sparse.linalgrsparserrrrrr _group_columnsr r scipy._lib._array_apir r scipy._lib._utilrscipy._externalrryr6 lru_cacherJrVrcrtrrrrrr}rrr7r5rs-.OO5A'2L%^ 2;2;j8v*:z'0$w&7$).R"'[| *NZT n{ |.-/FF7BFF*;" M?r7