+ /i xRt^RIt^RIt^RIHt^RIHt^RIH t H t H t H t H t Ht^RIHtHt^RIHt^RIHt^RIHtR t]P4R 4tR tR tRR ltRRRR]P>)]P>3RRRRRR3 Rlt Rt!Rt"Rt#!RR4t$]P>)]P>3RR3Rlt%R#)z'Routines for numerical differentiation.N)norm)LinearOperator)issparse isspmatrixfind csc_array csr_array csr_matrix) group_dense group_sparse)array_namespace) 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&&&&&& U/var/www/html/photoedit/myenv/lib/python3.14/site-packages/scipy/optimize/_numdiff.py_adjust_scheme_to_boundsr5s> 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&&& r4_eps_for_methodrI]s< ((2::  " "CH }}Xrzz**hhx $$hhx(11  }}Xrzz**hhx(11  k1((8$((C ""Cx ; Sz:; ;r6c V^8P\4^,^, p\VPVPV4pVf;WT,\P !R\P !V44,pV#W,\P !V4,pW,V, p\P!V^8HWT,\P !R\P !V44,V4pV#)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. ?)astypefloatrIrrrrwhere)rel_stepr!f0rDsign_x0rstepabs_stepdxs&&&& r4_compute_absolute_steprUs6Qwu%)A-G BHHbhh 7E?RZZRVVBZ%@@ O%r 2}"88B!G!ObjjbffRj.II$& Or6cRV4wr#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)rasarrayrM).0bs& r4 "_prepare_bounds..s 9&Qbjj%((&s)+)ndimrresizeshape)boundsr!r%r&s&& r4_prepare_boundsrasQ:& 9FB ww!| YYr88 $ ww!| YYr88 $ 6Mr6c\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_2drLint32r]rr_isscalarrandom RandomState permutationrXr indicesindptrr r)Aordermnrnggroupss&& r4 group_columnsrrs<{{ aL MM!  !VOOBHH %vv{566 77DA } E**ii##E*" 5! ;;1$ ;< < !U( A{{aAIIqxx8Q1%KKMFM Mr6r: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^8P\*4^,^, pTpVV,V, p\P,!V^8H\%VPVPV4V,\P.!R\P0!V44,V4pVR8Xd\3VV^RVV4wppM$VR8Xd\3VV^RVV4wppM VR8XdRpT ;'g\4p \7V 4;_uu_4pVf\9VWVXVV4wppM\;V4'g\=V4^8XdVwppM Tp\?V4p\;V4'dVPA4pM\PB!V4p\P !V4p\EVWVXVVVV4 wppRRR4V 'dVV, pVV R&XV 3#X# +'giL,;i)uJ'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))``, 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 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 a 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,). 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 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.]) 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) r8r:r9zUnknown 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.rKrrF)r8r:r9)#rr xpx atleast_ndrXr<isdtyperrLr]rar_rrisinf _Fun_Wrapper atleast_1danyrI_linear_operator_differencerUrMrNrrr5mapr _dense_differencerlenrrtocscrd_sparse_difference)funr!rDrOrSrPr`sparsityas_linear_operatorargskwargs full_outputworkers info_dictru_x_dtyper%r& fun_wrappedrt_nfevJ_r"rQrTr'mf structurerqs&&&&&&&&&&&&& r4approx_derivativersF11+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&&u-1A5GA6R-Bq(288VD !#%::c266":#>?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 B0P33 Q caaaaaSPoSPpVR8Xd VVVVV3RlpM-VR8Xd VVVV3RlpMVR8Xd VVVV3RlpM \R4h\SV3V4^3#)r8c<\P!V\P!V44'd\P!S4#S\ V4, pSW,,pS!V4S, pW1, #Nr array_equalrzerosr) prTr,dfrPrr"rnr!s & r4matvec+_linear_operator_difference..matvecrsW~~aq!122xx{"T!WBRT AQ"B7Nr6r:c`<\P!V\P!V44'd\P!S 4#^S,\ V4, pS V^, V,, pS V^, V,,pS!V4pS!V4pWT, pWa, #)r) rrTx1x2f1f2rrr"rnr!s & r4rr|s~~~aq!122xx{"1tAwBr!tQhBr!tQhBRBRBB7Nr6r9c<\P!V\P!V44'd\P!S4#S\ V4, pSW,R,,pS!V4pVP pWA, #)?)rrrrrimag) rrTr,rrrr"rnr!s & r4rrs`~~aq!122xx{"T!WBRT#X AQBB7Nr6Never be here.)sizerAr)rr!rPr"rDrorrnsffff& @r4r~r~lsr A A    9    4  +,, 1a&& )1 ,,r6c aVPpVPo\P!SV34p^p VR8XdV3Rlp V!W !W44p \S4U u.uF%qV ,W<,,W,, NK' p p V Uu.uF qV, NK pp\ W4UUu.uFwppVV, NK pppV \ V4, p EMVR8XEdURp\ V!VV!WV444p V!WV4p\4p \4p\V4Fwp p\V4p\V4p\V 4p\V 4pV'dUV PVV ,W,, 4VPRV,^V,,V, 4KV PVV ,VV ,, 4VPVV, 4K \ W4UUu.uFwppVV, NK pppV ^\ V4,, p MsVR8XdbV3Rlp\ V!VV!W444p \ W4UUu.uFwppVPV, NK pppV \ V4, p M \R4h\V4F wp pVW&K V^8Xd\P!V4pVPV 3#uup iuupiuuppiuuppiuuppi) r8c3<"\S4F4p\P!V4pW,W,,W2&VxK6 R#5ir)rangerr)r!r"irros&& r4 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#5irN) enumeraterr)r!r"r'r one_sidedrrs&&& r4 x_generator3'_dense_difference..x_generator3s} )- 8 WWR[WWR[EADLBEEAadFNBEEADLBEEADLBE!9sB7B9r9c3<"\S4F?pVP\RR7pW2;;,W,R,, uu&VxKA R#5i)TrrN)rrLcomplex)r!r"rxcros&& r4x_generator_cs)_dense_difference..x_generator_css=1XYYwTY2#sAArg)rremptyrzipriterlistrnextappendrrAravelT)rr!rPr"r'rDrrn J_transposedrtrf_evalsrrTf_evalrdelfdelxdf_dxrgenrlurrrhivros&&&&&&& @r4rrs A A88QF#L D  #|B23.3Ah 7h!uqt|ru$$h 7(/ 0frkk 0/22{;{t{; E  9  wsL $FGH2-0 V V%m4LAyS AS AgBgB !A$,' $)a"f,r12 !A$1+& "r'"5032{;{t{; CJ 4  wsN2$9:;,/O>4 u8 0;F<=s+K- K2.K7K=)Lc aaaaa#a$VPp SPp .p .p .p \P!S4^,o$^pVV$3Rlo#V#VV3RlpV#VVV3RlpV#VV3RlpVR8Xd\V!W!444pV!4pMDVR8Xd \V!VV!444pV!4pMVR8Xd\V!VV!444pS#!4EFp\P!V4wp\ VRV3,4wpppVV,pVR8Xd0\ X4S, p\ X4V, pV^, pEMYVR8XEd\ X4p\ V4pSV,pS(V,p\P!V 4pVV,SV,, VV&VV,VV,, VV&\ X4p\ V4p V^, pSV,p!\P!V 4pVV!,p"R VV",,^VV",,,V V",, VV"&VV!(,p"V V",VV",, VV"&M.e_generators%8_E((5&) )%.1c3\<"S!4pVFpSV,pSV,pVxK R#5ir)e_geneh_vecr,rr"r!s r4r(_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 r4r(_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 r4r*_sparse_difference..x_generator_css/ AEEus{" "rr8r:r9rcr)r_)rrmaxrnonzerorrrrrrrhstackrr r)%rr!rPr"r'rrqrDrrnro row_indices col_indices fractionsrtrrrrxsrcolsrjrrTrrrrrrrmaskrowsrrs%&f&ff&f&& @@r4rrs A AKKIvvf~!H D* "#wsLN34 ^ 9 wsLN34 ^ 4wsN$456 ] 1 yD)*1a G Y bBBg#B AID y bBbB"Q&F#^a'F!BFbj0BvJFbj0BvJgBgB AID #D!BT7DBtH}q2d8|3bh>BtHdU8D$x"T(*BtH t^gB AIDBQB-. . 11AA'eh))K(K))K(K )$I)9K&@A!PRVVV i{!;>> 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 )r`rrr)r`rr) rrrrrrXrrrr) rjacr!r`rr J_to_testJ_diffabs_errrr abs_err_data J_diff_datas &&&&&& r4check_derivativervsz~B(((I "36(,=i( $!']ljj1.446 vvbff\*jjBFF;$789: :#36(,=&&+,vvg 1bffVn ==>>r6)rr)&__doc__ functoolsnumpyr numpy.linalgrscipy.sparse.linalgrsparserrrrrr _group_columnsr r scipy._lib._array_apir scipy._lib._utilr scipy._librrwr5 lru_cacherIrUrarrrrr~rrr{rrr6r4rs-.QQ51'-L%^ 2;2;j.b*:z'0$w&7$).R"'Sl (-VP frRj.-/FF7BFF*;" M?r6