ó ʽ÷Xc@ südZddlmZddlZddlmZmZmZm Z m Z ddl m Z m Z ejejƒjZd„Zd „Zd „Zd d „Zd ddej ejfddid„Zd„Zd„Zej ejfdid„ZdS(s'Routines for numerical differentiation.iÿÿÿÿ(tdivisionNi(tissparset csc_matrixt csr_matrixt coo_matrixtfindi(t group_denset group_sparsecC sb|dkr$tj|dtƒ}n?|dkrWtj|ƒ}tj|dtƒ}n tdƒ‚tj|tj k|tjk@ƒr“||fS||}|jƒ}||} ||} |dkrh||} | |k| |kB} tj|ƒtj | | ƒk} || | @cd9<| | k| @}| ||||<| | k| @}| | |||td }qf|dkrWtd}qftdƒ‚n|dkjtƒd d}||tjd tj|ƒƒS( Ns2-pointgà?s3-pointiitcss(`method` must be '2-point' or '3-point'.iigð?gUUUUUUÕ?(tNonetEPSRtastypetfloatR RR (trel_stepRtmethodtsign_x0((s6/tmp/pip-build-7oUkmx/scipy/scipy/optimize/_numdiff.pyt_compute_absolute_step\s       cC s†g|D]}tj|dtƒ^q\}}|jdkrUtj||jƒ}n|jdkr|tj||jƒ}n||fS(NRi(R tasarrayR.tndimtresizetshape(tboundsRtbRR((s6/tmp/pip-build-7oUkmx/scipy/scipy/optimize/_numdiff.pyt_prepare_boundsks .icC sDt|ƒrt|ƒ}n'tj|ƒ}|dkjtjƒ}|jdkr`tdƒ‚n|j\}}|dksŠtj |ƒr®tj j |ƒ}|j |ƒ}n0tj|ƒ}|j|fkrÞtdƒ‚n|dd…|f}t|ƒrt|||j|jƒ}nt|||ƒ}|jƒ||<|S(sËGroup 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 i-th 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. iis`A` must be 2-dimensional.s`order` has incorrect shape.N(RRR t atleast_2dR-tint32R4RR6R+tisscalartrandomt RandomStatet permutationR3RtindicestindptrRR(tAtordertmtntrngtgroups((s6/tmp/pip-build-7oUkmx/scipy/scipy/optimize/_numdiff.pyt group_columnsvs&  s3-pointc   sg|dkrtd|ƒ‚ntj|ƒ}|jdkrLtdƒ‚nt||ƒ\} } | j|jks…| j|jkr”tdƒ‚n‡‡‡fd†} |dkrÄ| |ƒ}n-tj|ƒ}|jdkrñtd ƒ‚ntj|| k|| kBƒrtd ƒ‚nt|||ƒ} |dkrat || dd | | ƒ\} } nE|dkr‘t || dd | | ƒ\} } n|dkr¦t } n|dkrËt | ||| | |ƒSt |ƒ rùt |ƒd krù|\}}n|}t|ƒ}t |ƒr&t|ƒ}ntj|ƒ}tj|ƒ}t| ||| | |||ƒSdS(sÝ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'}, optional Finite difference method to use: - '2-point' - use the fist 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. The absolute step size is computed as ``h = 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 (default) then step is selected automatically, see Notes. 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. 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. 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 or csr_matrix Finite difference approximation of the Jacobian matrix. If `sparsity` is None then ndarray with shape (m, n) is returned. Although if m=1 it is returned as a gradient with shape (n,). If `sparsity` is not None, csr_matrix with shape (m, n) is returned. See Also -------- check_derivative : Check correctness of a function computing derivatives. Notes ----- If `rel_step` is not provided, it assigned to ``EPS**(1/s)``, where EPS is machine epsilon for float64 numbers, 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]_. 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 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.]) s2-points3-pointR*sUnknown method '%s'. is#`x0` must have at most 1 dimension.s,Inconsistent shapes between bounds and `x0`.c s=tjˆ|ˆˆŽƒ}|jdkr9tdƒ‚n|S(Nis-`fun` return value has more than 1 dimension.(R t atleast_1dR4t RuntimeError(R!tf(targstfuntkwargs(s6/tmp/pip-build-7oUkmx/scipy/scipy/optimize/_numdiff.pyt fun_wrappedJss&`f0` passed has more than 1 dimension.s `x0` violates bound constraints.s1-sideds2-sidediN(s2-points3-pointscs(RR RIR4R9R6R+tanyR2R)Rt_dense_differenceRtlenRHRR:t_sparse_difference(RMRR0R/tf0R7tsparsityRLRNRRRORRt structureRG((RLRMRNs6/tmp/pip-build-7oUkmx/scipy/scipy/optimize/_numdiff.pytapprox_derivative³sJ‹ $  ! !     cC sñ|j}|j}tj||fƒ}tj|ƒ} x“t|jƒD]‚} |dkr‹|| | } | | || } || ƒ|} n/|dkr|| r|| | }|d| | }|| || } ||ƒ}||ƒ}d|d||} n¶|dkrn||  rn|| | }|| | }|| || } ||ƒ}||ƒ}||} nL|dkr®||| | dƒ}|j} | | | f} n tdƒ‚| | || >> import numpy as np >>> from scipy.optimize 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 R7RURLRNiN( RRWRRR R3R]RhR R( RMtjacRR7RLRNt J_to_testtJ_difftabs_errRaRvt abs_err_datat J_diff_data((s6/tmp/pip-build-7oUkmx/scipy/scipy/optimize/_numdiff.pytcheck_derivativeñs=   (((t__doc__t __future__RtnumpyR tsparseRRRRRt_group_columnsRRtfinfotfloat64tepsR,R)R2R9RHR+RRWRQRSRƒ(((s6/tmp/pip-build-7oUkmx/scipy/scipy/optimize/_numdiff.pyts  ( O  =  Ä ( P