B &]\x@sddlmZmZmZddlZddlZddlZddlmZddl m Z ddl m Z ddl m Z ddd d d d d dgZGdddeZddZee_dddZdddZdddZddZdd"d Zd#d$Zdd&d Zdd'd Zd(d)Zd*d+Zd,d-Zdd0d Zdd1ddgd!d2fdd3dd4dgd!d5fd3d6dd3d3dgd7d8fd1d9d:d;d2d;d:gdd?d@ddd@d?gdAdBfddCdDdEdFdGdFdEdDgdHdIfd:dJdKdLdMdNdNdMdLdKgdOdPfd4dQdRdSdTdUdVdUdTdSdRg dWdXfdYdZd[d\d]d^d_d_d^d]d\d[g d`dafddbdcdddedfdgdhdgdfdedddcg didjfdkdldmdndodpdqdrdrdqdpdodndmg dsdtfddudvdwdxdydzd{d|d{dzdydxdwdvg d}d~fddddddddddddddddgddfd:ddddddddddddddddgddfdZ dddZ!dS))divisionprint_functionabsolute_importN)trapz)roots_legendre)gammaln)xrange fixed_quad quadraturerombergrsimpsrombcumtrapz newton_cotesc@s eZdZdS)AccuracyWarningN)__name__ __module__ __qualname__rr9lib/python3.7/site-packages/scipy/integrate/quadrature.pyrsrcCs,|tjkrtj|St|tj|<tj|S)zX Cache roots_legendre results to speed up calls of the fixed_quad function. )_cached_roots_legendrecacher)nrrrrs  rrcCsvt|\}}t|}t|s*t|r2td|||dd|}||dtj|||f|dddfS)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 simps : integrators for sampled data cumtrapz : cumulative integration for sampled data ode : ODE integrator odeint : ODE integrator Examples -------- >>> from scipy import integrate >>> 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.g@)axisN)rnprealisinf ValueErrorsum)funcabargsrxwyrrrr %s >  Fcs&|rfdd}nfdd}|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|fS)Nr)r&)r%r"rrvfuncszvectorize1..vfunccst|r|fSt|}|df}t|}t|dt|}tj|f|d}||d<x(td|D]}||f||<qpW|S)Nrdtype)r*r)risscalarasarraylengetattrtypeemptyr)r&Zy0rr*outputi)r%r"rrr)s  r)r"r%vec_funcr)r)r%r"r vectorize1ls r4"\O>2Trc Cst|ts|f}t|||d} tj} tj} t|d|}xht||dD]B} t| ||d| d} t| | } | } | |ks| |t| krHPqHWt d|| ft | | fS)aw 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 simps: integrator for sampled data cumtrapz: cumulative integration for sampled data ode: ODE integrator odeint: ODE integrator Examples -------- >>> from scipy import integrate >>> 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 )r3rrrz-maxiter (%d) exceeded. Latest difference = %e) isinstancetupler4rinfmaxrr abswarningswarnr)r"r#r$r%tolrtolmaxiterr3Zminiterr)valerrrZnewvalrrrr s @   cCst|}|||<t|S)N)listr8)tr2valuelrrrtuplesetsrG?rc CsZt|}|dkr|}nt|}|jdkrVt|}dg|j}d||<||}n,t|jt|jkrttdntj||d}|j||j|dkrtdt|j}tt df||t dd}tt df||t dd} tj ||||| d|d} |dk rVt |s$tdt | 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 matplotlib.pyplot as plt >>> x = np.linspace(-2, 2, num=20) >>> y = x >>> y_int = integrate.cumtrapz(y, x, initial=0) >>> plt.plot(x, y_int, 'ro', x, y[0] + 0.5 * x**2, 'b-') >>> plt.show() Nrrz2If given, shape of x must be 1-d or the same as y.)rz7If given, length of x along axis must be the same as y.g@z'`initial` parameter should be a scalar.)r*)rr,ndimdiffreshaper-shaper rGsliceZcumsumr+rCZ concatenateZfullr*) r(r&dxrinitialdrLndslice1slice2Zresrrrrs46        "   cCsdt|j}|dkrd}d}tdf|}t||t|||} t||t|d|d|} t||t|d|d|} |dkrtj|d|| d|| || |d} ntj||d} t||t|||}t||t|d|d|}| |}| |}||}||}||}|d|| dd||| ||||| d|}tj||d} | S) Nrrg@)rg@g?)r-rLrMrGrr!rJ)r(startstopr&rNrrQstep slice_allslice0rRrSresulthZsl0Zsl1Zh0Zh1ZhsumZhprodZh0divh1tmprrr _basic_simpsOs0 & &r^avgcCs&t|}t|j}|j|}|}|}d} |dk rt|}t|jdkr|dg|} |jd| |<|j} d} |t| }nt|jt|jkrtd|j||krtd|ddkrd} d} tdf|}tdf|}|dkrtd |d kr^t||d }t||d }|dk r,||||}| d |||||7} t |d|d|||} |dkrt||d}t||d}|dk r|t||t|}| d |||||7} | t |d|d|||7} |dkr| d} | d} | | } nt |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 : int, optional Spacing of integration points along axis of `y`. 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. 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 cumtrapz: 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 >>> x = np.arange(0, 10) >>> y = np.arange(0, 10) >>> integrate.simps(y, x) 40.5 >>> y = np.power(x, 3) >>> integrate.simps(y, x) 1642.5 >>> integrate.quad(lambda x: x**3, 0, 9)[0] 1640.25 >>> integrate.simps(y, x, even='first') 1644.5 rNrz2If given, shape of x must be 1-d or the same as y.z7If given, length of x along axis must be the same as y.rTg)r_lastfirstz3Parameter 'even' must be 'avg', 'last', or 'first'.)r_rarg?)r_r`r_g@) rr,r-rLrKr8r rMrGr^)r(r&rNrZevenrQNZlast_dxZfirst_dxZ returnshapeZshapexZ saveshaperAr[rRrSrrrr ns^F                c Cst|}t|j}|j|}|d}d}d}x||krJ|dK}|d7}q0W||kr\tdi} tdf|} t| |d} t| |d} |tj|td} || || d| | d<| }|}}}xtd|dD]}|dL}t||t|||}|dL}d | |ddf| ||j |d | |df<x\td|dD]J}| ||df}||| |d|dfdd |>d| ||f<q>> from scipy import integrate >>> 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 rrz=Number of samples must be one plus a non-negative power of 2.Nr)r*g@)rrg?)rrTzE*** Printing table only supported for integrals of a single data set.rz%%%d.%dfz6Richardson Extrapolation Table for Romberg IntegrationDzD==================================================================== )sepend )rj)rr,r-rLr rMrGfloatrr!r+print TypeError IndexErrorcenter)r(rNrshowrQZNsampsZNintervrkRrYrZZslicem1r\Zslice_RrVrWrXr2jprevZpreciswidthZformstrtitlerrrr sb;        0:        cCs|dkrtdn||dkr6d||d||dS|d}t|d|d|}|dd|}||t|}tj||dd}|SdS)aX 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().rg?rT)rN)r rlraranger!)functionintervalZnumtrapsZnumtosumr\ZloxZpointssrrr _difftrapks  r|cCsd|}||||dS)z Compute the differences for the Romberg quadrature corrections. See Forman Acton's "Real Computing Made Real," p 143. g@g?r)r$crrr]rrr _romberg_diffsr~cCsd}}tdt|ddtd|tdtddxvtt|D]f}td d ||d |dd |fddx,t|d D]}td |||ddqWtdqFWtdtd|||ddtdd t|d d ddS)NrzRomberg integration ofrk)rjfromrfz %6s %9s %9s)ZStepsZStepSizeZResultsz%6d %9frTrg@z%9fzThe final result isZafterzfunction evaluations.)rmreprrr-)ryrzresmatr2rtrrr _printresmats  , r`sbO> c  CsPt|st|rtdt|||d} d} ||g} ||} t| | | } | | }|gg}tj}|d}xtd|dD]}| d9} | t| | | 7} | | | g}x.t|D]"}|t|||||dqW||}||d}|r||t ||}||ks||t |krP|}qxWt d||ft |rLt | | ||S)ap 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. simps : Integrators for sampled data. cumtrapz : 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 >>> 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.)r3rrrTz,divmax (%d) exceeded. Latest difference = %e)rrr r4r|r9rappendr~r;r<r=rr)ryr#r$r%r>r?rqZdivmaxr3r)rrzZintrangeZordsumr[rrBZlast_rowr2rowrrZ lastresultrrrr s>T "     rT rcrUZreP- iii Kii@/)iiixiCii i+i i ii_7iii`i)iDii?# i^i) i}=i8iKiiiipi>i<isBi(i:ihiii0 i0iI"!iiiijmiil& l7iR0Pii@i7i@!i!Nid7ipRil$MY(l`:l@ Al@d@*ii`ip`*iolFg!lfl\a lLRl@`lx=l7-)rrTrcrUrrrerrrrrcCsy>> from scipy.integrate import newton_cotes >>> 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 Notes ----- Normally, the Newton-Cotes rules are used on smaller integration regions and a composite rule is used to return the total integral. r)r*rrz1The sample positions must start at 0 and end at NrTNg@g@)r-rrxallrJ Exception_builtincoeffsZarrayrlr ZnewaxisZlinalginvrangedotmathlogrZexp)ZrnZequalrdZnaZdaZviZnbZdbZanZyiZtiZnvecCZCinvr2ZvecZaiZBNZpowerZp1ZfacrrrrTsF@      $    )rr)rF)rr5r5r6Tr)NrHrN)Nrrr_)rHrF)rrrFrF)r)"Z __future__rrrZnumpyrrr<rZ scipy.specialrrZscipy._lib.sixr__all__Warningrrdictrr r4r rGrr^r r r|r~rr rrrrrrsx       G - S \ }