o g1@sddlmZddlmZmZmZmZmZmZddl Z ddl Z ddl Z ddl Z ddlZddlmZddl mZddlmZddlmZmZddlmZgd Zd d ZeeZejraejd d e_dddZGdddeZerddlmZGdddeZ neZ dddZ!e!ddZ"e#e"_$dd d!Z%dd#d$Z& & (dd)d*Z'd+d,Z(dd-d.Z)dd/d0Z*d1d2Z+dd4d5Z,dd6d7Z-dd8d9Z.d:d;Z/dd?Z1 " "ddBdCZ2d(dDd(d(gddEfd(dFgdGddHfdFdIgdJdKdLfdDdMgdNdOdPfddQgdRdSdTfd(dUgdVdWdXfdYdZgd[d\d]fd^d_gd`dadbfdcddgdedfdgfddhgdidjdkfdldmgdndodpfd(dqgdrdsdtfdudvgdwdxdyfdYdzgd{d|d}fd~Z3dddZ4ddZ5edddgZ6ddIdd"ddddZ7dS)) annotations) TYPE_CHECKINGCallableDictTupleAnycastN) namedtuple)trapz)roots_legendre)gammaln logsumexp) _rng_spawn) fixed_quad quadraturerombergromb trapezoidr simpssimpsoncumulative_trapezoidcumtrapz newton_cotesAccuracyWarningcCs6tj|j|j|j|j|jd}t||}|j |_ |S)zBBased on http://stackoverflow.com/a/6528148/190597 (Glenn Maynard))nameargdefsclosure) types FunctionType__code__ __globals____name__ __defaults__ __closure__ functoolsupdate_wrapper__kwdefaults__)fgr)Y/home/ubuntu/cloudmapper/venv/lib/python3.10/site-packages/scipy/integrate/_quadrature.py _copy_funcs  r+z sum, cumsumz numpy.cumsum?cCst||||dS)z}An alias of `trapezoid`. `trapz` is kept for backwards compatibility. For new code, prefer `trapezoid` instead. )xdxaxis)r)yr.r/r0r)r)r*r +sr c@s eZdZdS)rN)r! __module__ __qualname__r)r)r)r*r4sr)Protocolc@seZdZUded<dS)CacheAttributeszDict[int, Tuple[Any, Any]]cacheN)r!r2r3__annotations__r)r)r)r*r5=s r5funcrreturncCs tt|SN)rr5r8r)r)r*cache_decoratorCs r<cCs,|tjvr tj|St|tj|<tj|S)zX Cache roots_legendre results to speed up calls of the fixed_quad function. )_cached_roots_legendrer6r )nr)r)r*r=Gs   r=r)cCsxt|\}}t|}t|st|rtd|||dd|}||dtj|||g|RdddfS)a Compute a definite integral using fixed-order Gaussian quadrature. Integrate `func` from `a` to `b` using Gaussian quadrature of order `n`. Parameters ---------- func : callable A Python function or method to integrate (must accept vector inputs). If integrating a vector-valued function, the returned array must have shape ``(..., len(x))``. a : float Lower limit of integration. b : float Upper limit of integration. args : tuple, optional Extra arguments to pass to function, if any. n : int, optional Order of quadrature integration. Default is 5. Returns ------- val : float Gaussian quadrature approximation to the integral none : None Statically returned value of None See Also -------- quad : adaptive quadrature using QUADPACK dblquad : double integrals tplquad : triple integrals romberg : adaptive Romberg quadrature quadrature : adaptive Gaussian quadrature romb : integrators for sampled data simpson : integrators for sampled data cumulative_trapezoid : cumulative integration for sampled data ode : ODE integrator odeint : ODE integrator Examples -------- >>> from scipy import integrate >>> import numpy as np >>> f = lambda x: x**8 >>> integrate.fixed_quad(f, 0.0, 1.0, n=4) (0.1110884353741496, None) >>> integrate.fixed_quad(f, 0.0, 1.0, n=5) (0.11111111111111102, None) >>> print(1/9.0) # analytical result 0.1111111111111111 >>> integrate.fixed_quad(np.cos, 0.0, np.pi/2, n=4) (0.9999999771971152, None) >>> integrate.fixed_quad(np.cos, 0.0, np.pi/2, n=5) (1.000000000039565, None) >>> np.sin(np.pi/2)-np.sin(0) # analytical result 1.0 z8Gaussian quadrature is only available for finite limits.@r-r0N)r=nprealisinf ValueErrorsum)r8abargsr>r.wr1r)r)r*rWs > .rFcs(|r fdd}|Sfdd}|S)aoVectorize the call to a function. This is an internal utility function used by `romberg` and `quadrature` to create a vectorized version of a function. If `vec_func` is True, the function `func` is assumed to take vector arguments. Parameters ---------- func : callable User defined function. args : tuple, optional Extra arguments for the function. vec_func : bool, optional True if the function func takes vector arguments. Returns ------- vfunc : callable A function that will take a vector argument and return the result. cs|gRSr:r)r.rJr8r)r*vfunczvectorize1..vfunccst|r |gRSt|}|dgR}t|}t|dt|}tj|f|d}||d<td|D]}||gR||<q9|S)NrdtyperPr@)rCisscalarasarraylengetattrtypeemptyrange)r.y0r>rPoutputirMr)r*rNs  r))r8rJvec_funcrNr)rMr* vectorize1s  r]"\O>2Tr@c Cst|ts|f}t|||d} tj} tj} t|d|}t||dD]%} t| ||d| d} t| | } | } | |ksC| |t| krH| | fSq#t d|| ft | | fS)a Compute a definite integral using fixed-tolerance Gaussian quadrature. Integrate `func` from `a` to `b` using Gaussian quadrature with absolute tolerance `tol`. Parameters ---------- func : function A Python function or method to integrate. a : float Lower limit of integration. b : float Upper limit of integration. args : tuple, optional Extra arguments to pass to function. tol, rtol : float, optional Iteration stops when error between last two iterates is less than `tol` OR the relative change is less than `rtol`. maxiter : int, optional Maximum order of Gaussian quadrature. vec_func : bool, optional True or False if func handles arrays as arguments (is a "vector" function). Default is True. miniter : int, optional Minimum order of Gaussian quadrature. Returns ------- val : float Gaussian quadrature approximation (within tolerance) to integral. err : float Difference between last two estimates of the integral. See Also -------- romberg : adaptive Romberg quadrature fixed_quad : fixed-order Gaussian quadrature quad : adaptive quadrature using QUADPACK dblquad : double integrals tplquad : triple integrals romb : integrator for sampled data simpson : integrator for sampled data cumulative_trapezoid : cumulative integration for sampled data ode : ODE integrator odeint : ODE integrator Examples -------- >>> from scipy import integrate >>> import numpy as np >>> f = lambda x: x**8 >>> integrate.quadrature(f, 0.0, 1.0) (0.11111111111111106, 4.163336342344337e-17) >>> print(1/9.0) # analytical result 0.1111111111111111 >>> integrate.quadrature(np.cos, 0.0, np.pi/2) (0.9999999999999536, 3.9611425250996035e-11) >>> np.sin(np.pi/2)-np.sin(0) # analytical result 1.0 r\r@r)rz-maxiter (%d) exceeded. Latest difference = %e) isinstancetupler]rCinfmaxrXrabswarningswarnr)r8rHrIrJtolrtolmaxiterr\miniterrNvalerrr>newvalr)r)r*rs& A  rcCst|}|||<t|Sr:)listrb)tr[valuelr)r)r*tupleset srscCt|||||dS)zAn alias of `cumulative_trapezoid`. `cumtrapz` is kept for backwards compatibility. For new code, prefer `cumulative_trapezoid` instead. )r.r/r0initial)r)r1r.r/r0rur)r)r*r(rc CsTt|}|dur |}nDt|}|jdkr+t|}dg|j}d||<||}nt|jt|jkr9tdtj||d}|j||j|dkrPtdt|j}tt df||t dd}tt df||t dd} tj ||||| d|d} |durt |stdt | j}d||<tj tj||| jd | g|d} | S) a Cumulatively integrate y(x) using the composite trapezoidal rule. Parameters ---------- y : array_like Values to integrate. x : array_like, optional The coordinate to integrate along. If None (default), use spacing `dx` between consecutive elements in `y`. dx : float, optional Spacing between elements of `y`. Only used if `x` is None. axis : int, optional Specifies the axis to cumulate. Default is -1 (last axis). initial : scalar, optional If given, insert this value at the beginning of the returned result. Typically this value should be 0. Default is None, which means no value at ``x[0]`` is returned and `res` has one element less than `y` along the axis of integration. Returns ------- res : ndarray The result of cumulative integration of `y` along `axis`. If `initial` is None, the shape is such that the axis of integration has one less value than `y`. If `initial` is given, the shape is equal to that of `y`. See Also -------- numpy.cumsum, numpy.cumprod quad : adaptive quadrature using QUADPACK romberg : adaptive Romberg quadrature quadrature : adaptive Gaussian quadrature fixed_quad : fixed-order Gaussian quadrature dblquad : double integrals tplquad : triple integrals romb : integrators for sampled data ode : ODE integrators odeint : ODE integrators Examples -------- >>> from scipy import integrate >>> import numpy as np >>> import matplotlib.pyplot as plt >>> x = np.linspace(-2, 2, num=20) >>> y = x >>> y_int = integrate.cumulative_trapezoid(y, x, initial=0) >>> plt.plot(x, y_int, 'ro', x, y[0] + 0.5 * x**2, 'b-') >>> plt.show() Nr@r-2If given, shape of x must be 1-D or the same as y.rB7If given, length of x along axis must be the same as y.rAz'`initial` parameter should be a scalar.rQ)rCrSndimdiffreshaperTshaperFrsslicecumsumrRro concatenatefullrP) r1r.r/r0rudr|ndslice1slice2resr)r)r*r1s6 7      "  rc Cst|j}|dur d}d}tdf|}t||t|||} t||t|d|d|} t||t|d|d|} |durYtj|| d|| || |d} | |d9} | Stj||d} t||t|||}t||t|d|d|}t| |}t| |}||}||}tj||t ||dkd}|d|| d tjd |t ||dkd|| |tj||t ||dkd|| d |}tj||d} | S) Nrr@@rB@)outwhereg@rAr,) rTr|r}rsrCrGrzfloat64 true_divide zeros_like)r1startstopr.r/r0rstep slice_allslice0rrresulthsl0sl1h0h1hsumhprodh0divh1tmpr)r)r*_basic_simpsonsJ &    ravgcCrt)zyAn alias of `simpson`. `simps` is kept for backwards compatibility. For new code, prefer `simpson` instead. )r.r/r0even)r)r1r.r/r0rr)r)r*rrvrcCst|}t|j}|j|}|}|}d} |durWt|}t|jdkr>dg|} |jd| |<|j} d} |t| }nt|jt|jkrLtd|j||krWtd|ddkrd} d} tdf|}tdf|}|dvrwtd |d vrt||d }t||d }|dur||||}| d |||||7} t |d|d|||} |dvrt||d}t||d}|dur|t||t|}| d |||||7} | t |d|d|||7} |dkr| d} | d} | | } n t |d|d|||} | r || }| S)a Integrate y(x) using samples along the given axis and the composite Simpson's rule. If x is None, spacing of dx is assumed. If there are an even number of samples, N, then there are an odd number of intervals (N-1), but Simpson's rule requires an even number of intervals. The parameter 'even' controls how this is handled. Parameters ---------- y : array_like Array to be integrated. x : array_like, optional If given, the points at which `y` is sampled. dx : float, optional Spacing of integration points along axis of `x`. Only used when `x` is None. Default is 1. axis : int, optional Axis along which to integrate. Default is the last axis. even : str {'avg', 'first', 'last'}, optional 'avg' : Average two results:1) use the first N-2 intervals with a trapezoidal rule on the last interval and 2) use the last N-2 intervals with a trapezoidal rule on the first interval. 'first' : Use Simpson's rule for the first N-2 intervals with a trapezoidal rule on the last interval. 'last' : Use Simpson's rule for the last N-2 intervals with a trapezoidal rule on the first interval. Returns ------- float The estimated integral computed with the composite Simpson's rule. See Also -------- quad : adaptive quadrature using QUADPACK romberg : adaptive Romberg quadrature quadrature : adaptive Gaussian quadrature fixed_quad : fixed-order Gaussian quadrature dblquad : double integrals tplquad : triple integrals romb : integrators for sampled data cumulative_trapezoid : cumulative integration for sampled data ode : ODE integrators odeint : ODE integrators Notes ----- For an odd number of samples that are equally spaced the result is exact if the function is a polynomial of order 3 or less. If the samples are not equally spaced, then the result is exact only if the function is a polynomial of order 2 or less. Examples -------- >>> from scipy import integrate >>> import numpy as np >>> x = np.arange(0, 10) >>> y = np.arange(0, 10) >>> integrate.simpson(y, x) 40.5 >>> y = np.power(x, 3) >>> integrate.simpson(y, x) 1642.5 >>> integrate.quad(lambda x: x**3, 0, 9)[0] 1640.25 >>> integrate.simpson(y, x, even='first') 1644.5 rNr@rwrxrg)rlastfirstz3Parameter 'even' must be 'avg', 'last', or 'first'.)rrr-?)rrrrA) rCrSrTr|r{rbrFr}rsr)r1r.r/r0rrNlast_dxfirst_dx returnshapeshapex saveshaperlrrrr)r)r*rs^ L           rc Cst|}t|j}|j|}|d}d}d}||kr'|dK}|d7}||ks||kr/tdi} tdf|} t| |d} t| |d} |tj|td} || || d| | d<| }|}}}td|dD]\}|dL}t||t|||}|dL}d | |ddf| ||j |d | |df<td|dD]$}| ||df}||| |d|dfdd |>d| ||f<q| d} qj|r=t | dst d ngz|d}Wn t t fyd }Ynwz|d}Wn t t fyd}Ynwd||f}d}t |dt|dddt|dD]}t|dD]}t || ||fddq t qt dt|| ||fS)a Romberg integration using samples of a function. Parameters ---------- y : array_like A vector of ``2**k + 1`` equally-spaced samples of a function. dx : float, optional The sample spacing. Default is 1. axis : int, optional The axis along which to integrate. Default is -1 (last axis). show : bool, optional When `y` is a single 1-D array, then if this argument is True print the table showing Richardson extrapolation from the samples. Default is False. Returns ------- romb : ndarray The integrated result for `axis`. See Also -------- quad : adaptive quadrature using QUADPACK romberg : adaptive Romberg quadrature quadrature : adaptive Gaussian quadrature fixed_quad : fixed-order Gaussian quadrature dblquad : double integrals tplquad : triple integrals simpson : integrators for sampled data cumulative_trapezoid : cumulative integration for sampled data ode : ODE integrators odeint : ODE integrators Examples -------- >>> from scipy import integrate >>> import numpy as np >>> x = np.arange(10, 14.25, 0.25) >>> y = np.arange(3, 12) >>> integrate.romb(y) 56.0 >>> y = np.sin(np.power(x, 2.5)) >>> integrate.romb(y) -0.742561336672229 >>> integrate.romb(y, show=True) Richardson Extrapolation Table for Romberg Integration ====================================================== -0.81576 4.63862 6.45674 -1.10581 -3.02062 -3.65245 -2.57379 -3.06311 -3.06595 -3.05664 -1.34093 -0.92997 -0.78776 -0.75160 -0.74256 ====================================================== -0.742561336672229 # may vary r@rz=Number of samples must be one plus a non-negative power of 2.Nr-rQrA)rrrrBrzE*** Printing table only supported for integrals of a single data set.r?z%%%d.%dfz6Richardson Extrapolation Table for Romberg Integration= )sepend r)rCrSrTr|rFr}rsfloatrXrGrRprint TypeError IndexError)r1r/r0showrNsampsNintervr>kRrrslicem1rslice_Rrrrr[jprevpreciswidthformstrtitler)r)r*rAsf =     06       rcCs|dkrtd|dkrd||d||dS|d}t|d|d|}|dd|}||t|}tj||dd}|S)aU Perform part of the trapezoidal rule to integrate a function. Assume that we had called difftrap with all lower powers-of-2 starting with 1. Calling difftrap only returns the summation of the new ordinates. It does _not_ multiply by the width of the trapezoids. This must be performed by the caller. 'function' is the function to evaluate (must accept vector arguments). 'interval' is a sequence with lower and upper limits of integration. 'numtraps' is the number of trapezoids to use (must be a power-of-2). rz#numtraps must be > 0 in difftrap().r@rrrB)rFrrCarangerG)functionintervalnumtrapsnumtosumrloxpointssr)r)r* _difftraps rcCsd|}||||dS)z Compute the differences for the Romberg quadrature corrections. See Forman Acton's "Real Computing Made Real," p 143. rr,r))rIcrrr)r)r* _romberg_diffsrcCsd}}tdt|ddtd|tdtddtt|D]1}td d ||d |dd |fddt|d D]}td |||ddq@tdq"tdtd|||ddtdd t|d d ddS)NrzRomberg integration ofrrfromz %6s %9s %9s)StepsStepSizeResultsz%6d %9frr@rAz%9fzThe final result isafterzfunction evaluations.)rreprrXrT)rrresmatr[rr)r)r* _printresmats  ,  r`sbO> c  CsDt|s t|rtdt|||d} d} ||g} ||} t| | | } | | }|gg}tj}|d}td|dD]R}| d9} | t| | | 7} | | | g}t|D]}|t|||||dqT||}||d}|rw||t ||}||ks||t |krn |}q;t d||ft |rt | | ||S)a Romberg integration of a callable function or method. Returns the integral of `function` (a function of one variable) over the interval (`a`, `b`). If `show` is 1, the triangular array of the intermediate results will be printed. If `vec_func` is True (default is False), then `function` is assumed to support vector arguments. Parameters ---------- function : callable Function to be integrated. a : float Lower limit of integration. b : float Upper limit of integration. Returns ------- results : float Result of the integration. Other Parameters ---------------- args : tuple, optional Extra arguments to pass to function. Each element of `args` will be passed as a single argument to `func`. Default is to pass no extra arguments. tol, rtol : float, optional The desired absolute and relative tolerances. Defaults are 1.48e-8. show : bool, optional Whether to print the results. Default is False. divmax : int, optional Maximum order of extrapolation. Default is 10. vec_func : bool, optional Whether `func` handles arrays as arguments (i.e., whether it is a "vector" function). Default is False. See Also -------- fixed_quad : Fixed-order Gaussian quadrature. quad : Adaptive quadrature using QUADPACK. dblquad : Double integrals. tplquad : Triple integrals. romb : Integrators for sampled data. simpson : Integrators for sampled data. cumulative_trapezoid : Cumulative integration for sampled data. ode : ODE integrator. odeint : ODE integrator. References ---------- .. [1] 'Romberg's method' https://en.wikipedia.org/wiki/Romberg%27s_method Examples -------- Integrate a gaussian from 0 to 1 and compare to the error function. >>> from scipy import integrate >>> from scipy.special import erf >>> import numpy as np >>> gaussian = lambda x: 1/np.sqrt(np.pi) * np.exp(-x**2) >>> result = integrate.romberg(gaussian, 0, 1, show=True) Romberg integration of from [0, 1] :: Steps StepSize Results 1 1.000000 0.385872 2 0.500000 0.412631 0.421551 4 0.250000 0.419184 0.421368 0.421356 8 0.125000 0.420810 0.421352 0.421350 0.421350 16 0.062500 0.421215 0.421350 0.421350 0.421350 0.421350 32 0.031250 0.421317 0.421350 0.421350 0.421350 0.421350 0.421350 The final result is 0.421350396475 after 33 function evaluations. >>> print("%g %g" % (2*result, erf(1))) 0.842701 0.842701 z5Romberg integration only available for finite limits.r`r@rrz,divmax (%d) exceeded. Latest difference = %e)rCrErFr]rrcrXappendrrerfrgrr)rrHrIrJrhrirdivmaxr\rNr>rintrangeordsumrrrmlast_rowr[rowr lastresultr)r)r*rs@U        rr r)r@r@Zr)r@rrr@P-) rrriii )Kr_r_rrii@/))irrriixriC) + rrrri iri_7) `)iDrrrrii?# i^) ) }=8Krrrrriiip) ><sB(:ihrrrrriii0 i0) I"!jmirrrrrrl& l7iR0P) @7@!!Nd7ipRr r r r r ri$MY(rrrrrrrl`:l@ Al@d@*)i`p`*oFg!f\a LRl@`rrrrrrrlx=l7-)r@rrrr?rrrrrrrcCszt|d}|rt|d}n tt|dkrd}Wnty2|}t|d}d}Ynw|rU|tvrUt|\}}}}}|tj|td|}|t||fS|ddksa|d|kret d|t|} d| d} t|d} | | ddtj f} tj | } t dD]}d| | | | } qd| dddd}| dddddf||d}|ddkr|r||d }|d}n ||d}|d}|t| ||}|d}|t|t|}t|}|||fS) a Return weights and error coefficient for Newton-Cotes integration. Suppose we have (N+1) samples of f at the positions x_0, x_1, ..., x_N. Then an N-point Newton-Cotes formula for the integral between x_0 and x_N is: :math:`\int_{x_0}^{x_N} f(x)dx = \Delta x \sum_{i=0}^{N} a_i f(x_i) + B_N (\Delta x)^{N+2} f^{N+1} (\xi)` where :math:`\xi \in [x_0,x_N]` and :math:`\Delta x = \frac{x_N-x_0}{N}` is the average samples spacing. If the samples are equally-spaced and N is even, then the error term is :math:`B_N (\Delta x)^{N+3} f^{N+2}(\xi)`. Parameters ---------- rn : int The integer order for equally-spaced data or the relative positions of the samples with the first sample at 0 and the last at N, where N+1 is the length of `rn`. N is the order of the Newton-Cotes integration. equal : int, optional Set to 1 to enforce equally spaced data. Returns ------- an : ndarray 1-D array of weights to apply to the function at the provided sample positions. B : float Error coefficient. Notes ----- Normally, the Newton-Cotes rules are used on smaller integration regions and a composite rule is used to return the total integral. Examples -------- Compute the integral of sin(x) in [0, :math:`\pi`]: >>> from scipy.integrate import newton_cotes >>> import numpy as np >>> def f(x): ... return np.sin(x) >>> a = 0 >>> b = np.pi >>> exact = 2 >>> for N in [2, 4, 6, 8, 10]: ... x = np.linspace(a, b, N + 1) ... an, B = newton_cotes(N, 1) ... dx = (b - a) / N ... quad = dx * np.sum(an * f(x)) ... error = abs(quad - exact) ... print('{:2d} {:10.9f} {:.5e}'.format(N, quad, error)) ... 2 2.094395102 9.43951e-02 4 1.998570732 1.42927e-03 6 2.000017814 1.78136e-05 8 1.999999835 1.64725e-07 10 2.000000001 1.14677e-09 r@rQrr-z1The sample positions must start at 0 and end at NrNrAr)rTrCrallrz Exception_builtincoeffsarrayrrFnewaxislinalginvrXdotmathlogr exp)rnequalrnadavinbdbanyitinvecCCinvr[vecaiBNpowerp1facr)r)r*rsJA       $     rc sttdsddlm}|t_ntj}tsd}t|t|}t|}t ||\}}|j d} z ||dWnt yT} zd}t || d} ~ wwz t ||g} Wn%t y} zd| d}tj|d d fd d } WYd} ~ nd} ~ wwt|} || krd }t|t|} || krd}t||dur|j| }n t||jjsd}t||j|j dkrd}t |t|dd}|j|}|dvrd}t|| ||| | ||||f S)Nqmcr)statsz`func` must be callable.rz`func` must evaluate the integrand at points within the integration range; e.g. `func( (a + b) / 2)` must return the integrand at the centroid of the integration volume.zAException encountered when attempting vectorized call to `func`: z. `func` should accept two-dimensional array with shape `(n_points, len(a))` and return an array with the integrand value at each of the `n_points` for better performance.r stacklevelcstjd|dS)Nr-)r0arr)rCapply_along_axisrLr;r)r*rN@rOz_qmc_quad_iv..vfuncz`n_points` must be an integer.z!`n_estimates` must be an integer.z8`qrng` must be an instance of scipy.stats.qmc.QMCEngine.z`qrng` must be initialized with dimensionality equal to the number of variables in `a`, i.e., `qrng.random().shape[-1]` must equal `a.shape[0]`.rng_seed>FTz*`log` must be boolean (`True` or `False`).)hasattr _qmc_quadscipyr>callablerrC atleast_1dcopybroadcast_arraysr|r rFr"rfrgint64r=Haltonra QMCEnginerrU_qmccheck_random_state)r8rHrIn_points n_estimatesqrngr(r>messagedimerN n_points_intn_estimates_intrCrngr)r;r* _qmc_quad_ivsf        rY QMCQuadResultintegralstandard_errori)rPrQrRr(rJc Cs|t|||||||}|\ }}}}}}}}} t||kr2d} tj| ddt|r.tj dSddS||k} d| jdd} || || || <|| <t||} | |}t |}t |j |}t |D]8}| |}| j|||}||}|rt|t|}nt||}|||<t|d d||i|j}qet|}|r| dkr|tjdn|| }| |}t||S) a Compute an integral in N-dimensions using Quasi-Monte Carlo quadrature. Parameters ---------- func : callable The integrand. Must accept a single arguments `x`, an array which specifies the point at which to evaluate the integrand. For efficiency, the function should be vectorized to compute the integrand for each element an array of shape ``(n_points, n)``, where ``n`` is number of variables. a, b : array-like One-dimensional arrays specifying the lower and upper integration limits, respectively, of each of the ``n`` variables. n_points, n_estimates : int, optional One QMC sample of `n_points` (default: 256) points will be generated by `qrng`, and `n_estimates` (default: 8) statistically independent estimates of the integral will be produced. The total number of points at which the integrand `func` will be evaluated is ``n_points * n_estimates``. See Notes for details. qrng : `~scipy.stats.qmc.QMCEngine`, optional An instance of the QMCEngine from which to sample QMC points. The QMCEngine must be initialized to a number of dimensions corresponding with the number of variables ``x0, ..., xn`` passed to `func`. The provided QMCEngine is used to produce the first integral estimate. If `n_estimates` is greater than one, additional QMCEngines are spawned from the first (with scrambling enabled, if it is an option.) If a QMCEngine is not provided, the default `scipy.stats.qmc.Halton` will be initialized with the number of dimensions determine from `a`. log : boolean, default: False When set to True, `func` returns the log of the integrand, and the result object contains the log of the integral. Returns ------- result : object A result object with attributes: integral : float The estimate of the integral. standard_error : The error estimate. See Notes for interpretation. Notes ----- Values of the integrand at each of the `n_points` points of a QMC sample are used to produce an estimate of the integral. This estimate is drawn from a population of possible estimates of the integral, the value of which we obtain depends on the particular points at which the integral was evaluated. We perform this process `n_estimates` times, each time evaluating the integrand at different scrambled QMC points, effectively drawing i.i.d. random samples from the population of integral estimates. The sample mean :math:`m` of these integral estimates is an unbiased estimator of the true value of the integral, and the standard error of the mean :math:`s` of these estimates may be used to generate confidence intervals using the t distribution with ``n_estimates - 1`` degrees of freedom. Perhaps counter-intuitively, increasing `n_points` while keeping the total number of function evaluation points ``n_points * n_estimates`` fixed tends to reduce the actual error, whereas increasing `n_estimates` tends to decrease the error estimate. Examples -------- QMC quadrature is particularly useful for computing integrals in higher dimensions. An example integrand is the probability density function of a multivariate normal distribution. >>> import numpy as np >>> from scipy import stats >>> dim = 8 >>> mean = np.zeros(dim) >>> cov = np.eye(dim) >>> def func(x): ... return stats.multivariate_normal.pdf(x, mean, cov) To compute the integral over the unit hypercube: >>> from scipy.integrate import qmc_quad >>> a = np.zeros(dim) >>> b = np.ones(dim) >>> rng = np.random.default_rng() >>> qrng = stats.qmc.Halton(d=dim, seed=rng) >>> n_estimates = 8 >>> res = qmc_quad(func, a, b, n_estimates=n_estimates, qrng=qrng) >>> res.integral, res.standard_error (0.00018441088533413305, 1.1255608140911588e-07) A two-sided, 99% confidence interval for the integral may be estimated as: >>> t = stats.t(df=n_estimates-1, loc=res.integral, ... scale=res.standard_error) >>> t.interval(0.99) (0.00018401699720722663, 0.00018480477346103947) Indeed, the value reported by `scipy.stats.multivariate_normal` is within this range. >>> stats.multivariate_normal.cdf(b, mean, cov, lower_limit=a) 0.00018430867675187443 z^A lower limit was equal to an upper limit, so the value of the integral is zero by definition.rr?rr-rBseedy?Nr))rYrCanyrfrgrZrcrGprodzerosrrXrXrandomr=scaler r(rV _init_quadmeanpisem)r8rHrIrPrQrRr(rJrXr>rSi_swapsignAdA estimatesrngsr[sampler. integrandsestimater[r\r)r)r*rEfs4j     "  rE)Nr,r-)r8rr9r5)r)r?)r)F)r)r^r^r_Tr@)Nr,r-N)Nr,r-r)r,r-F)r)rrFrF)r)8 __future__rtypingrrrrrrr$numpyrCr'rrf collectionsr r r scipy.specialr r r scipy._lib._utilr__all__r+__doc__replaceWarningrr4r5r<r=dictr6rr]rrsrrrrrrrrrrr!rrYrZrEr)r)r)r*s             G- U  ] '            #mJ