geddlmZddlmZmZmZmZddlZddl Z ddl Z ddl m Z ddl mZddl mZmZddlmZgdZdqd Zdqd ZGd deZerddlmZGddeZneZdrdZedZee_dsdZdtdZ dud Z d!Z!dvd"Z"dvd#Z#d$Z$dvd%Z%dvd&Z&dwd'Z'd(Z(d)Z)d*Z* dxd-Z+dd.ddgd d/fdd0gd1d d2fd0d3gd4d5d6fd.d7gd8d9d:fdd;gd<d=d>fdd?gd@dAdBfdCdDgdEdFdGfdHdIgdJdKdLfdMdNgdOdPdQfddRgdSdTdUfdVdWgdXdYdZfdd[gd\d]d^fd_d`gdadbdcfdCddgdedfdgfdhZ,dydiZ-djZ.e dkdldmgZ/d3dndddodpZ0dS)z) annotations) TYPE_CHECKINGCallableAnycastN) namedtuple)roots_legendre)gammaln logsumexp) _rng_spawn) fixed_quad quadraturerombergromb trapezoidtrapzsimpssimpsoncumulative_trapezoidcumtrapz newton_cotesqmc_quadAccuracyWarning?cttdrtj||||Stj||||S)a Integrate along the given axis using the composite trapezoidal rule. If `x` is provided, the integration happens in sequence along its elements - they are not sorted. Integrate `y` (`x`) along each 1d slice on the given axis, compute :math:`\int y(x) dx`. When `x` is specified, this integrates along the parametric curve, computing :math:`\int_t y(t) dt = \int_t y(t) \left.\frac{dx}{dt}\right|_{x=x(t)} dt`. Parameters ---------- y : array_like Input array to integrate. x : array_like, optional The sample points corresponding to the `y` values. If `x` is None, the sample points are assumed to be evenly spaced `dx` apart. The default is None. dx : scalar, optional The spacing between sample points when `x` is None. The default is 1. axis : int, optional The axis along which to integrate. Returns ------- trapezoid : float or ndarray Definite integral of `y` = n-dimensional array as approximated along a single axis by the trapezoidal rule. If `y` is a 1-dimensional array, then the result is a float. If `n` is greater than 1, then the result is an `n`-1 dimensional array. See Also -------- cumulative_trapezoid, simpson, romb Notes ----- Image [2]_ illustrates trapezoidal rule -- y-axis locations of points will be taken from `y` array, by default x-axis distances between points will be 1.0, alternatively they can be provided with `x` array or with `dx` scalar. Return value will be equal to combined area under the red lines. References ---------- .. [1] Wikipedia page: https://en.wikipedia.org/wiki/Trapezoidal_rule .. [2] Illustration image: https://en.wikipedia.org/wiki/File:Composite_trapezoidal_rule_illustration.png Examples -------- Use the trapezoidal rule on evenly spaced points: >>> import numpy as np >>> from scipy import integrate >>> integrate.trapezoid([1, 2, 3]) 4.0 The spacing between sample points can be selected by either the ``x`` or ``dx`` arguments: >>> integrate.trapezoid([1, 2, 3], x=[4, 6, 8]) 8.0 >>> integrate.trapezoid([1, 2, 3], dx=2) 8.0 Using a decreasing ``x`` corresponds to integrating in reverse: >>> integrate.trapezoid([1, 2, 3], x=[8, 6, 4]) -8.0 More generally ``x`` is used to integrate along a parametric curve. We can estimate the integral :math:`\int_0^1 x^2 = 1/3` using: >>> x = np.linspace(0, 1, num=50) >>> y = x**2 >>> integrate.trapezoid(y, x) 0.33340274885464394 Or estimate the area of a circle, noting we repeat the sample which closes the curve: >>> theta = np.linspace(0, 2 * np.pi, num=1000, endpoint=True) >>> integrate.trapezoid(np.cos(theta), x=np.sin(theta)) 3.141571941375841 ``trapezoid`` can be applied along a specified axis to do multiple computations in one call: >>> a = np.arange(6).reshape(2, 3) >>> a array([[0, 1, 2], [3, 4, 5]]) >>> integrate.trapezoid(a, axis=0) array([1.5, 2.5, 3.5]) >>> integrate.trapezoid(a, axis=1) array([2., 8.]) rxdxaxis)hasattrnprryrrr s ;lib/python3.11/site-packages/scipy/integrate/_quadrature.pyrrsIPr;2|Ar5555xQ2D1111c(t||||S)z}An alias of `trapezoid`. `trapz` is kept for backwards compatibility. For new code, prefer `trapezoid` instead. r)rr#s r%rrs Q! . . ..r&ceZdZdS)rN)__name__ __module__ __qualname__r&r%rrsDr&r)ProtocolceZdZUded<dS)CacheAttributeszdict[int, tuple[Any, Any]]cacheN)r)r*r+__annotations__r,r&r%r/r/s))))))r&r/funcrreturnc,tt|SN)rr/)r2s r%cache_decoratorr6s  & &&r&c|tjvrtj|St|tj|<tj|S)zX Cache roots_legendre results to speed up calls of the fixed_quad function. )_cached_roots_legendrer0r )ns r%r8r8sE  " (((%+A..&4Q&7&7 # ! ' **r&r,c4t|\}}tj|}tj|stj|rt d||z |dzzdz |z}||z dz tj|||g|RzdzdfS)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.@rr N)r8r"realisinf ValueErrorsum)r2abargsr9rwr$s r%r r s| "! $ $DAq  A x{{+bhqkk+*++ + 1qs C!A aC9rvaQ.R888 8$ >>r&Fc(|rfd}nfd}|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. c|gRSr5r,)rrEr2s r%vfunczvectorize1..vfuncs4>D>>> !r&cdtj|r |gRStj|}|dgR}t|}t |dt |}tj|f|}||d<td|D]}||gR||<|S)NrdtyperKr<)r"isscalarasarraylengetattrtypeemptyrange)ry0r9rKoutputirEr2s r%rIzvectorize1..vfuncs{1~~ &tA~~~~% 1 Aad"T"""BAABb22EXqd%000FF1I1a[[ . . D1----q Mr&r,)r2rEvec_funcrIs`` r% vectorize1rXsV2 " " " " " " "       Lr&"\O>2Tr<c t|ts|f}t|||} tj} tj} t |dz|}t ||dzD]M} t| ||d| d} t| | z } | } | |ks| |t| zkrn Ntj d|| fzt| | 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 rWr<r,rz-maxiter (%d) exceeded. Latest difference = %e) isinstancetuplerXr"infmaxrSr abswarningswarnr)r2rCrDrEtolrtolmaxiterrWminiterrIvalerrr9newvals r%rr#sB dE " "w tTH 5 5 5E &C &C'!)W%%G 7GAI & &  E1aQ//2&*oo 99d3s88m++ E,  ;wn L     8Or&cHt|}|||<t|Sr5)listr^)trVvaluels r%tuplesetrpxs! QA AaD 88Or&c*t|||||S)zAn alias of `cumulative_trapezoid`. `cumtrapz` is kept for backwards compatibility. For new code, prefer `cumulative_trapezoid` instead. )rrr initial)r)r$rrr rrs r%rrs Q2D' J J JJr&ctj|}||}ntj|}|jdkr:tj|}dg|jz}d||<||}nOt |jt |jkrtdtj||}|j||j|dz krtdt |j}ttdf|z|tdd}ttdf|z|tdd} tj ||||| zzdz |} |ntj |stdt| j}d||<tj tj||| j | g|} | 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<r2If given, shape of x must be 1-D or the same as y.r>7If given, length of x along axis must be the same as y.r=z'`initial` parameter should be a scalar.rL)r"rNndimdiffreshaperOshaperArpslicecumsumrMrl concatenatefullrK) r$rrr rrdryndslice1slice2ress r%rrsn 1 Ay  JqMM 6Q;; AC!&LEE$K %  AA \\S\\ ) )*++ +%%%A 74=AGDMA- - -*++ + QWB uT{{nR'uQ~~ > >F uT{{nR'uT2 ? ?F )A6QvY./#5D A A AC{7## HFGG GSYd nbgeWCIFFFL"&((( Jr&c t|j}|d}d}tdf|z}t||t|||} t||t|dz|dz|} t||t|dz|dz|} |;t j|| d|| zz|| z|} | |dz z} nxt j||} t||t|||}t||t|dz|dz|}| |td}| |td}||z}||z}t j ||t j ||dk }|d z || d t j d |t j ||dk z z|| |t j ||t j ||dk zzz|| d |z zzz}t j||} | S) Nrr<@r>@F)copyoutwhereg@r=r) rOryrzrpr"rBrwastypefloat true_divide zeros_like)r$startstoprrr rstep slice_allslice0rrresulthsl0sl1h0h1hsumhprodh0divh1tmps r%_basic_simpsonrsk QWB } Dtr!I iuUD$'?'? @ @F iuU1Wd1fd'C'C D DF iuU1Wd1fd'C'C D DFy& C& M1AfI=DIII"s( GAD ! ! !y$eT4(@(@AAy$eAgtAvt(D(DEE sV]]5u] - - sV]]5u] - -BwR.RR]2->->bAgNNN3h!F)W46M'4J4J6=l"D"D"DDEF)t')~dE:<-:M:M>> 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) 1640.5 >>> integrate.quad(lambda x: x**3, 0, 9)[0] 1640.25 >>> integrate.simpson(y, x, even='first') 1644.5 rNr<rtruzWThe 'even' keyword is deprecated as of SciPy 1.11.0 and will be removed in SciPy 1.13.0r stacklevelgr)avglastfirstrz>Parameter 'even' must be 'simpson', 'avg', 'last', or 'first'.r?r>rr)rr)rrrr=)r"rNrOryrxr^rArbrcDeprecationWarningrzrprasfarrayfloat64rwsqueezerr)r$rrr rrNlast_dxfirst_dx returnshapeshapex saveshaperhrrrrslice3rhm2hm1diffsnumdenalphabetaetas r%rrsN 1 A QWB  AGHK} JqMM qw<<1  S2XF71:F4LIK %--((AA \\S\\ ) )*++ + 74=A  *++ +   & 1     1uzz4[[NR' 'ttY : : :-  66ir22Fir22F}F)ai/ 3=AfI& $9: :CD 9  #Aq!A#q"d;;Fir22Fir22Fir22F RH%%A}y$b"a0@0@AAy$b$0B0BCC 2714#8#8#899Zc 666Zc 6668adai-!ad(QqT/1Cqtad{#CNM#&&Qh EA$!)cAaDj1Q4//Cad(C>M#&&Qh Dadai-Cad(adQqTk*C.M#&&Qh C eAfIoQvY6QvYF FF # # #ir22Fir22F}F)ai/ 3w;& !F) 34 4C#Aq!A#q"d;;F ? " "iq11Fiq11F}U6]]+af .>> 3x<61V9!45 5C nQ1Q32t<< >> 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.NrrLr=)rrrr>rzE*** Printing table only supported for integrals of a single data set.r:z%%%d.%dfz6Richardson Extrapolation Table for Romberg Integration= )sepend r)r"rNrOryrArzrprrSrBrMprint TypeError IndexError)r$rr showrNsampsNintervr9kRrrslicem1rslice_RrrrrVjprevpreciswidthformstrtitles r%rr slz 1 A QWB WT]FQhG A A g++ a Q g++ G||455 5 At#I iq ) )Fy$++G"*Ru----A6QwZ',Q.AfIG!!E!D4 1ac]] ! 7D%tT*B*BCC  AaC8q7T)B)B'BBC1a& q!A# G GAa1X;DQ!QqSz] 2ac A~FFAq!fII S ${1V9%% $ + , , , , az*     Qz*     E6?2GLE %s5zz)t > > > >1Q3ZZ  qs88A'Aq!fI-377777 #E " # # # aV9s$GG21G26G??HHcb|dkrtd|dkr&d||d||dzzS|dz }t|d|dz |z }|dd|zz}||tj|zz}tj||d}|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<rrr>)rArr"arangerB)functionintervalnumtrapsnumtosumrloxpointsss r% _difftraprs1}}>??? QHHXa[))((8A;*?*??@@A: (1+hqk) * *8 3qkC!G#q29X.... F88F##! , , ,r&c(d|z}||z|z |dz z S)z Compute the differences for the Romberg quadrature corrections. See Forman Acton's "Real Computing Made Real," p 143. rrr,)rDcrrs r% _romberg_diffrs$ q&C !GaK#) $$r&cxdx}}tdt|dtd|tdtddztt|D]t}td d |z|d |dz d |zz fzdt|d zD]"}td |||zd#tdutdtd|||dtdd t|d z zd zddS)NrzRomberg integration ofrrfromz %6s %9s %9s)StepsStepSizeResultsz%6d %9frr<r=z%9fzThe final result isafterzfunction evaluations.)rreprrSrO)rrresmatrVrs r% _printresmatrsI IA "DNN<<<< &( "III -: :;;; 3v;;   i1a4(1+hqk"9BE!BCCMMMMqs 3 3A %6!9Q<(c 2 2 2 2 2 b  "III 137777 '1s6{{1}%a')@AAAAAr&`sbO> c  tj|stj|rtdt|||} d} ||g} ||z } t | | | } | | z}|gg}tj}|d}t d|dzD]}| dz} | t | | | z } | | z| z g}t |D]5}|t|||||dz6||}||dz }|r||t||z }||ks||t|zkrn"|}tj d||fzt|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)r"r@rArXrr_rSappendrrarbrcrr)rrCrDrErdrerdivmaxrWrIr9rintrangeordsumrrrilast_rowrVrowr lastresults r%rrsj x{{/bhqkk/.// / x 9 9 9E A1vH1uH uh * *F  FhZF &CayH 1fQh   Q)E8Q///& 1$%q @ @A JJ}Xa[#a&!A#>> ? ? ? ?Qac]   MM#   &:%&& 99dS[[000 E :fc] J     .UHf--- Mr&r r)r<r<Zr)r<rrr<rP-) rrriii )KrZrZrrii@/))irrriixriC) + rrrri iri_7) `)iDr r r r ii?# i^) ) }=8Krrrrriiip) ><sB(:ihrrrrriii0 i0) I"!jmirrrrrrl& l7iR0P) @7@!!Nd7ipRr$r#r"r!r ri$MY(r,r+r*r)r(r'r&l`:l@ Al@d@*)i`p`*oFg!f\a LRl@`r3r2r1r0r/r.r-lx=l7-)r<rrrr:rrrr rrrr%c t|dz }|rtj|dz}n,tjtj|dkrd}n+#t $r|}tj|dz}d}YnwxYw|rQ|t vrHt |\}}}}}|tj|tz|z }|t||z fS|ddks |d|krtd|t|z } d| zdz } tj|dz} | | ddtj fz} tj | } tdD]0}d| z| | | z } 1d| ddddzz }| dddddf||dz z}|dzdkr|r||d zz }|dz}n ||dzz }|dz}|tj| |z|z }|dz}|tj|zt#|z }tj|}|||zfS) 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<rLrrz1The sample positions must start at 0 and end at NrNr=r)rOr"rallrw Exception_builtincoeffsarrayrrAnewaxislinalginvrSdotmathlogr exp)rnequalrnadavinbdbanyitinvecCCinvrVvecaiBNpowerp1facs r%rrxsB  GGAI  1Q3BB VBGBKK1$ % % E   Yqs^^   n$$+A.BB "(2U+++ +b 0599R< 1 2! )** * eAhhB R!B 9QqS>>D d111bj=!!A 9==  D 1XX..v --- ccc1 C aaa1f  #  !b& )B A  "X! "X! bfRY## #B qB  gbkk )C (3--C r#v:sAA%BBc ttdsddlm}|t_n tj}t sd}t |t j|}t j|}t j ||\}}|j d} ||zdz n$#t$r} d}t|| d} ~ wwxYw t j ||gj} n8#t$r+} d| d}tj|d fd } Yd} ~ nd} ~ wwxYwt j|} || krd }t |t j|} || krd }t |||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. For better performance, `func` should accept two-dimensional array `x` with shape `(len(a), n_points)` and return an array of the integrand value at each of the `n_points.rrc2tjd|S)Nr)r arr)r"apply_along_axis)rr2s r%rIz_qmc_quad_iv..vfunc s&t"!<<< FTz*`log` must be boolean (`True` or `False`).)r!rscipyrVcallablerr" atleast_1drbroadcast_arraysryr7rAr9Trbrcint64rUHaltonr] QMCEnginer~rP_qmccheck_random_state)r2rCrDn_points n_estimatesqrngr?rVmessagedimerI n_points_intn_estimates_intrZrngs` r% _qmc_quad_ivrns 8U # # D>>!,    aA aA q! $ $DAq '!*C) a!eq[ ))))!!q( ) = RXq!f        = = =,,,,  g!,,,, = = = = = = = = = = =8H%%L<2   h{++Oo%%5    |y$$ ei1 2 2!L    vH!!!tZ..H * ' ' 1 1C ->   1ac3 NNs0C C;$C66C;?&D&& E0!EE QMCQuadResultintegralstandard_errori)rfrergr?c t||||||}|\ }}}}}}}} dd} dfd dfd dfd } tj||kr7d} tj| d t |r tj nddS||k} d | d z}|| || c|| <|| <tj||z }||z }tj }t|j }tD]u}| |}| j|||j}||}| |||||<t#|dd ||i|j}v||}| |||}|r|dkr|tjdzzn||z}t ||S)a Compute an integral in N-dimensions using Quasi-Monte Carlo quadrature. Parameters ---------- func : callable The integrand. Must accept a single argument ``x``, an array which specifies the point(s) at which to evaluate the scalar-valued integrand, and return the value(s) of the integrand. For efficiency, the function should be vectorized to accept an array of shape ``(d, n_points)``, where ``d`` is the number of variables (i.e. the dimensionality of the function domain) and `n_points` is the number of quadrature points, and return an array of shape ``(n_points,)``, the integrand at each quadrature point. a, b : array-like One-dimensional arrays specifying the lower and upper integration limits, respectively, of each of the ``d`` variables. n_estimates, n_points : int, optional `n_estimates` (default: 8) statistically independent QMC samples, each of `n_points` (default: 1024) points, will be generated by `qrng`. 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 ``d`` corresponding with the number of variables ``x1, ..., xd`` 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 the length of `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): ... # `multivariate_normal` expects the _last_ axis to correspond with ... # the dimensionality of the space, so `x` must be transposed ... return stats.multivariate_normal.pdf(x.T, 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.00018429555666024108, 1.0389431116001344e-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.0001839319802536469, 0.00018465913306683527) 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 Fc||r$t|tj|zStj||zSr5)r r"r?rB) integrandsdAr?s r% sum_productzqmc_quad..sum_products9  +Z((26"::5 56*r/** *r&cx|r$t|tjz Stj|Sr5)r r"r?mean) estimatesr?rfs r%rxzqmc_quad..means8  &Y''"&*=*== =79%% %r&Nrcl|p ||}|rtj||\}}tj||tjdzzf}t |d}tjdt d|ztj|z z zStj||S)N?rr>rr)ddof)r"r^vstackpir r?r?std)rymr|r?temprwrxrfs r%rzqmc_quad..stds %i%%  0.y!<$>#?@AA A6)$/// /r&c|p ||}|p||d|}|r|dtjzz S|tjz S)Nr<)r|r?r)r"r?sqrt)ryrrr?rxrfrs r%semzqmc_quad..semsm %i%% 3Ys333  ,s26+.... .rw{+++ +r&z^A lower limit was equal to an upper limit, so the value of the integral is zero by definition.rrrr>seed)rr?r{)F)NrF)NNFr,)rnr"anyrbrcror_rBprodzerosr rmrSrandomrUscaler_rQ _init_quadr~)r2rCrDrfrergr?rErmrVrvrrhi_swapsignAruryrngsrVsamplerrtrprqrxrs ` @@r%rr2sk\ aHk4 E ED?C 2 22r&)Nrr)r2rr3r/)r,r:)r,F)r,rYrYrZTr<)NrrN)rrF)r,rrFrF)r)1 __future__rtypingrrrrnumpyr"r>rb collectionsr scipy.specialr r r scipy._lib._utilr __all__rrWarningrr-r/r6r8dictr0r rXrrprrrrrrrrrrr8rrnrorr,r&r%rs""""""555555555555 """"""((((((,,,,,,,,'''''' * * * k2k2k2k2`////     g    *****(****O'''' + + + $tvvD?D?D?D?N****ZHJ&'RRRRjKKKKZZZZz"""N8888ttttnssssB4%%%BBB"FK %vvvvh !QqE"R !GGGBr !IIIb "^^^Bs# #!!!$u- #'''40 %777fE %??? f %#V- 6777 )  H((()4l D G00016 @ \3335@    J888:E   7  FjjjjZGOGOGOT ?Z9I,JKK )*Dtr3r3r3r3r3r3r3r&