a BCCf%@s.ddlmZddlmZmZmZmZddlZddl mZ ddl Z ddl Z ddl mZddlmZddlmZmZddlmZddlmZmZmZgd Zdd d ZdddZGdddeZerddlmZGdddeZneZdddddZ e ddZ!e"e!_#dddZ$dd d!Z%ed"dd'd(Z&d)d*Z'dd+d,Z(dd-d.Z)d/d0Z*dd d efd1d2Z+ed3d4dd d ed5d6d7Z,d8d8d9d8d:d;d<Z-d8d8d8d=d>d?Z.d8d8d8d=d@dAZ/dBd8dCdDdEZ0dd d ddFdGdHZ1ddIdJZ2dKdLZ3dMdNZ4dOdPZ5edQddTdUZ6d&dVd&d&gd dWfd&dXgdYd dZfdXd[gd\d]d^fdVd_gd`dadbfddcgdddedffd&dggdhdidjfdkdlgdmdndofdpdqgdrdsdtfdudvgdwdxdyfddzgd{d|d}fd~dgdddfd&dgdddfddgdddfdkdgdddfdZ7dddZ8ddZ9edddgZ:d[ddddddZ;dS)) annotations) TYPE_CHECKINGCallableAnycastN) namedtuple)roots_legendre)gammaln logsumexp) _rng_spawn)_NoValue_deprecate_positional_args _deprecated) fixed_quad quadraturerombergromb trapezoidtrapzsimpssimpsoncumulative_trapezoidcumtrapz newton_cotesqmc_quadAccuracyWarningcumulative_simpson?c Cs*t|}|dur|}nRt|}|jdkr\t|}dg|j}|jd||<||}ntj||d}|j}tdg|}tdg|}tdd||<tdd||<z*||t||t|d|} WnRt y$t |}t |}tj ||t||t|d|} Yn0| 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.]) Nraxisr@) npZ asanyarrayndimdiffshapereshapeslicetuplesum ValueErrorasarrayaddreduce) yxdxr!dr&ndslice1slice2retr7W/var/www/html/django/DPS/env/lib/python3.9/site-packages/scipy/integrate/_quadrature.pyrs,f      *  0rcCs$d}tj|tddt||||dS)z}An alias of `trapezoid`. `trapz` is kept for backwards compatibility. For new code, prefer `trapezoid` instead. zr'scipy.integrate.trapz' is deprecated in favour of 'scipy.integrate.trapezoid' and will be removed in SciPy 1.14.0 stacklevel)r0r1r!)warningswarnDeprecationWarningr)r/r0r1r!msgr7r7r8rsrc@s eZdZdS)rN)__name__ __module__ __qualname__r7r7r7r8rsr)Protocolc@seZdZUded<dS)CacheAttributeszdict[int, tuple[Any, Any]]cacheN)r@rArB__annotations__r7r7r7r8rDs rDr)funcreturncCs tt|SN)rrDrGr7r7r8cache_decoratorsrKcCs,|tjvrtj|St|tj|<tj|S)zX Cache roots_legendre results to speed up calls of the fixed_quad function. )_cached_roots_legendrerEr)nr7r7r8rLs  rLr7cCsxt|\}}t|}t|s*t|r2td|||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.rr"rr N)rLr#realisinfr+r*)rGabargsrMr0wr/r7r7r8rs >  rFcs&|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|gRSrIr7r0rSrGr7r8vfunc*szvectorize1..vfunccst|r|gRSt|}|dgR}t|}t|dt|}tj|f|d}||d<td|D]}||gR||<qr|S)NrdtyperXr)r#isscalarr,lengetattrtypeemptyrange)r0Zy0rMrXoutputirVr7r8rW-s  r7)rGrSvec_funcrWr7rVr8 vectorize1s rcz`scipy.integrate.quadrature` is deprecated as of SciPy 1.12.0and will be removed in SciPy 1.15.0. Please use`scipy.integrate.quad` instead."\O>2Trc Cst|ts|f}t|||d} tj} tj} t|d|}t||dD]D} t| ||d| d} t| | } | } | |ks| |t| krFqqFt j d|| ft dd| | fS)aZ Compute a definite integral using fixed-tolerance Gaussian quadrature. .. deprecated:: 1.12.0 This function is deprecated as of SciPy 1.12.0 and will be removed in SciPy 1.15.0. Please use `scipy.integrate.quad` instead. 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 rbrr7rz-maxiter (%d) exceeded. Latest difference = %er9r:) isinstancer)rcr#infmaxr_rabsr<r=r)rGrQrRrStolrtolmaxiterrbZminiterrWvalerrrMZnewvalr7r7r8r=s"I   rcCst|}|||<t|SrI)listr))travaluelr7r7r8tuplesetsrtcCs&d}tj|tddt|||||dS)zAn alias of `cumulative_trapezoid`. `cumtrapz` is kept for backwards compatibility. For new code, prefer `cumulative_trapezoid` instead. z'scipy.integrate.cumtrapz' is deprecated in favour of 'scipy.integrate.cumulative_trapezoid' and will be removed in SciPy 1.14.0r9r:r0r1r!initial)r<r=r>r)r/r0r1r!rvr?r7r7r8rsrc Cst|}|j|dkr td|dur.|}nt|}|jdkrlt|}dg|j}d||<||}n,t|jt|jkrtdntj||d}|j||j|dkrtdt|j}tt df||t dd}tt df||t dd} tj ||||| d |d} |dur|dkr@t j d t d d t|sTtd t| j}d||<tjtj||| 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. 0 or None are the only values accepted. Default is None, which means `res` has one element less than `y` along the axis of integration. .. deprecated:: 1.12.0 The option for non-zero inputs for `initial` will be deprecated in SciPy 1.15.0. After this time, a ValueError will be raised if `initial` is not None or 0. 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 cumulative_simpson : cumulative integration using Simpson's 1/3 rule 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() rz,At least one point is required along `axis`.Nrr2If 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"zThe option for values for `initial` other than None or 0 is deprecated as of SciPy 1.12.0 and will raise a value error in SciPy 1.15.0.r9r:z'`initial` parameter should be a scalar.rY)r#r,r&r+r$r%r'r[rtr(cumsumr<r=r>rZrp concatenatefullrX) r/r0r1r!rvr2r&r3r4r5resr7r7r8rsD<        "    rc Cst|j}|durd}d}tdf|}t||t|||} t||t|d|d|} t||t|d|d|} |durtj|| d|| || |d} | |d9} ntj||d} t||t|||}t||t|d|d|}| |jtdd}| |jtdd}||}||}tj ||t ||dkd }|d || d tj d |t ||dkd || |tj ||t ||dkd || d |}tj||d} | S) Nrr9r@r @Fcopyoutwhereg@r"r) r[r&r(rtr#r*r%astypefloat true_divide zeros_like)r/startstopr0r1r!r3step slice_allslice0r4r5resulthZsl0Zsl1Zh0Zh1ZhsumZhprodZh0divh1tmpr7r7r8_basic_simpsonsH &   rcCs&d}tj|tddt|||||dS)zyAn alias of `simpson`. `simps` is kept for backwards compatibility. For new code, prefer `simpson` instead. zp'scipy.integrate.simps' is deprecated in favour of 'scipy.integrate.simpson' and will be removed in SciPy 1.14.0r9r:r0r1r!even)r<r=r>r)r/r0r1r!rr?r7r7r8rBsrz1.14)versionrcCspt|}t|j}|j|}|}|}d} |durt|}t|jdkr|dg|} |jd| |<|j} d} |t| }nt|jt|jkrtd|j||krtd|turtj dt dd|ddkrFd } d } t df|}|tdfvr|nd }|d vrtd |dkrlt ||d }t ||d}|durL||||}| d|||||7} d}|d kr:t |d|d|||} t ||d }t ||d}t ||d}tj||gtjd}|dur.t ||t dd d}t ||t d dd}ttj||d}tj|||dtj|||dg}d|ddd|d|d}d|d|d}tj||t||dkd}|ddd|d|d}d|d}tj||t||dkd}d|dd}d|d|d|d}tj||t||dkd}| |||||||||7} |dvrt ||d }t ||d}|durv||||}| d|||||7} t |d|d|||} |dvr"t ||d}t ||d}|dur|t||t|}| d|||||7} | t |d|d|||7} |dkr<| d} | d} | | } nt |d|d|||} | rl|| }| S)ab 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 : {None, 'simpson', '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. None : equivalent to 'simpson' (default) 'simpson' : Use Simpson's rule for the first N-2 intervals with the addition of a 3-point parabolic segment for the last interval using equations outlined by Cartwright [1]_. If the axis to be integrated over only has two points then the integration falls back to a trapezoidal integration. .. versionadded:: 1.11.0 .. versionchanged:: 1.11.0 The newly added 'simpson' option is now the default as it is more accurate in most situations. .. deprecated:: 1.11.0 Parameter `even` is deprecated and will be removed in SciPy 1.14.0. After this time the behaviour for an even number of points will follow that of `even='simpson'`. 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 cumulative_simpson : cumulative integration using Simpson's 1/3 rule 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. References ---------- .. [1] Cartwright, Kenneth V. Simpson's Rule Cumulative Integration with MS Excel and Irregularly-spaced Data. Journal of Mathematical Sciences and Mathematics Education. 12 (2): 1-9 Examples -------- >>> from scipy import integrate >>> import numpy as np >>> x = np.arange(0, 10) >>> y = np.arange(0, 10) >>> integrate.simpson(y, x=x) 40.5 >>> y = np.power(x, 3) >>> integrate.simpson(y, x=x) 1640.5 >>> integrate.quad(lambda x: x**3, 0, 9)[0] 1640.25 >>> integrate.simpson(y, x=x, even='first') 1644.5 rNrrwrxzWThe 'even' keyword is deprecated as of SciPy 1.11.0 and will be removed in SciPy 1.14.0r9r:gr)avglastfirstrz>Parameter 'even' must be 'simpson', 'avg', 'last', or 'first'.r?rYr rr~)rr)rrrr")r#r,r[r&r'r)r+r r<r=r>r(rtrZfloat64r%Zsqueezerr)r/r0r1r!rr3NZlast_dxZfirst_dxZ returnshapeZshapexZ saveshapernrrr4r5Zslice3rZhm2Zhm1ZdiffsnumZdenalphabetaetar7r7r8rOsi                $  (           rz np.ndarrayz.Callable[[np.ndarray, np.ndarray], np.ndarray])r/r1integration_funcrHcCs|||}||ddddf|ddddfddddf}t|j}|dd7<t|}|ddddf|ddddf<|ddddf|ddddf<|d|d<tj|dd}|S)zCalculate cumulative sum of Simpson integrals. Takes as input the integration function to be used. The integration_func is assumed to return the cumulative sum using composite Simpson's rule. Assumes the axis of summation is -1. .Nrrr9).rr )rpr&r#r^ry)r/r1rZsub_integrals_h1Zsub_integrals_h2r&Z sub_integralsr|r7r7r8#_cumulatively_sum_simpson_integralsHs 4     r)r/r1rHcCsd|dddf}|dddf}|dddf}|dddf}|dd|d d||d S) zCalculate the Simpson integrals for all h1 intervals assuming equal interval widths. The function can also be used to calculate the integral for all h2 intervals by reversing the inputs, `y` and `dx`. .Nrrrr9rrNr7)r/r1r2f1f2f3r7r7r8#_cumulative_simpson_equal_intervalsas rcCs|dddf}|dddf}|dddf}|dddf}|dddf}||}||}||} || } d|} d| |} | } |d| || || |S) zCalculate the Simpson integrals for all h1 intervals assuming unequal interval widths. The function can also be used to calculate the integral for all h2 intervals by reversing the inputs, `y` and `dx`. .Nrrrr9rrr7)r/r1Zx21Zx32rrrZx31Zx21_x31Zx21_x32Z x21x21_x31x32Zcoeff1Zcoeff2Zcoeff3r7r7r8%_cumulative_simpson_unequal_intervalsos rz npt.ArrayLike)arrrHcCs,t|}t|jtjr(|jtdd}|S)NFr)r#r,Z issubdtyperXintegerrr)rr7r7r8_ensure_float_arrays rruc Cs0t|}|}|j}zt||d}WnBtyf}z*d|d|jd}t||WYd}~n d}~00|jddkrt||||dd} t| |d} n|dur6t|}d}|j|ks|jd krt|||kst||jd krt ||jn t||d}tj |dd }t |d kr(td t ||t } nrt|}t||||d } t||d } d }|jd ks|j| kst|t || }t||d}t ||t} |durt|}t||d } d}|jd ks|j| kst|t || }t||d}| |7} tj|| fdd } t| d|} | S)a, Cumulatively integrate y(x) using the composite Simpson's 1/3 rule. The integral of the samples at every point is calculated by assuming a quadratic relationship between each point and the two adjacent points. Parameters ---------- y : array_like Values to integrate. Requires at least one point along `axis`. If two or fewer points are provided along `axis`, Simpson's integration is not possible and the result is calculated with `cumulative_trapezoid`. x : array_like, optional The coordinate to integrate along. Must have the same shape as `y` or must be 1D with the same length as `y` along `axis`. `x` must also be strictly increasing along `axis`. If `x` is None (default), integration is performed using spacing `dx` between consecutive elements in `y`. dx : scalar or array_like, optional Spacing between elements of `y`. Only used if `x` is None. Can either be a float, or an array with the same shape as `y`, but of length one along `axis`. Default is 1.0. axis : int, optional Specifies the axis to integrate along. Default is -1 (last axis). initial : scalar or array_like, optional If given, insert this value at the beginning of the returned result, and add it to the rest of the result. 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. Can either be a float, or an array with the same shape as `y`, but of length one along `axis`. 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 cumulative_trapezoid : cumulative integration using the composite trapezoidal rule simpson : integrator for sampled data using the Composite Simpson's Rule Notes ----- .. versionadded:: 1.12.0 The composite Simpson's 1/3 method can be used to approximate the definite integral of a sampled input function :math:`y(x)` [1]_. The method assumes a quadratic relationship over the interval containing any three consecutive sampled points. Consider three consecutive points: :math:`(x_1, y_1), (x_2, y_2), (x_3, y_3)`. Assuming a quadratic relationship over the three points, the integral over the subinterval between :math:`x_1` and :math:`x_2` is given by formula (8) of [2]_: .. math:: \int_{x_1}^{x_2} y(x) dx\ &= \frac{x_2-x_1}{6}\left[\ \left\{3-\frac{x_2-x_1}{x_3-x_1}\right\} y_1 + \ \left\{3 + \frac{(x_2-x_1)^2}{(x_3-x_2)(x_3-x_1)} + \ \frac{x_2-x_1}{x_3-x_1}\right\} y_2\\ - \frac{(x_2-x_1)^2}{(x_3-x_2)(x_3-x_1)} y_3\right] The integral between :math:`x_2` and :math:`x_3` is given by swapping appearances of :math:`x_1` and :math:`x_3`. The integral is estimated separately for each subinterval and then cumulatively summed to obtain the final result. For samples that are equally spaced, the result is exact if the function is a polynomial of order three or less [1]_ and the number of subintervals is even. Otherwise, the integral is exact for polynomials of order two or less. References ---------- .. [1] Wikipedia page: https://en.wikipedia.org/wiki/Simpson's_rule .. [2] Cartwright, Kenneth V. Simpson's Rule Cumulative Integration with MS Excel and Irregularly-spaced Data. Journal of Mathematical Sciences and Mathematics Education. 12 (2): 1-9 Examples -------- >>> from scipy import integrate >>> import numpy as np >>> import matplotlib.pyplot as plt >>> x = np.linspace(-2, 2, num=20) >>> y = x**2 >>> y_int = integrate.cumulative_simpson(y, x=x, initial=0) >>> fig, ax = plt.subplots() >>> ax.plot(x, y_int, 'ro', x, x**3/3 - (x[0])**3/3, 'b-') >>> ax.grid() >>> plt.show() The output of `cumulative_simpson` is similar to that of iteratively calling `simpson` with successively higher upper limits of integration, but not identical. >>> def cumulative_simpson_reference(y, x): ... return np.asarray([integrate.simpson(y[:i], x=x[:i]) ... for i in range(2, len(y) + 1)]) >>> >>> rng = np.random.default_rng(354673834679465) >>> x, y = rng.random(size=(2, 10)) >>> x.sort() >>> >>> res = integrate.cumulative_simpson(y, x=x) >>> ref = cumulative_simpson_reference(y, x) >>> equal = np.abs(res - ref) < 1e-15 >>> equal # not equal when `simpson` has even number of subintervals array([False, True, False, True, False, True, False, True, True]) This is expected: because `cumulative_simpson` has access to more information than `simpson`, it can typically produce more accurate estimates of the underlying integral over subintervals. rz`axis=z$` is not valid for `y` with `y.ndim=z`.Nr)r1r!rvz_If given, shape of `x` must be the same as `y` or 1-D with the same length as `y` along `axis`.rr rz$Input x must be strictly increasing.zkIf provided, `dx` must either be a scalar or have the same shape as `y` but with only 1 point along `axis`.zpIf provided, `initial` must either be a scalar or have the same shape as `y` but with only 1 point along `axis`.)rr&r#Zswapaxes IndexErrorr$r+rr[Z broadcast_tor%anyrrrtrrz) r/r0r1r!rvZ original_yZoriginal_shapeemessager|Zfinal_dx_shapeZalt_input_dx_shapeZalt_initial_input_shaper7r7r8rsd{   &     rc Cst|}t|j}|j|}|d}d}d}||krH|dK}|d7}q.||krXtdi} tdf|} t| |d} t| |d} |tj|td} || || d| | d<| }|}}}td|dD]}|dL}t||t|||}|dL}d | |ddf| ||j |d | |df<td|dD]J}| ||df}||| |d|dfdd |>d| ||f<q4| d} q|r|t | dst d nz |d}Wnt t fyd }Yn0z |d}Wnt t fyd}Yn0d||f}d}t |dt|dddt|dD]8}t|dD]}t || ||fddqBt q2t 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 rrz=Number of samples must be one plus a non-negative power of 2.NrrYr")rrrr r9zE*** Printing table only supported for integrals of a single data set.rNz%%%d.%dfz6Richardson Extrapolation Table for Romberg Integration= )sepend r)r#r,r[r&r+r(rtrr_r*rZprint TypeErrorr)r/r1r!showr3ZNsampsZNintervrMkRrrZslicem1rZslice_RrrrrajprevZpreciswidthZformstrtitler7r7r8rFs`=       08        rcCs|dkrtdn||dkr6d||d||dS|d}t|d|d|}|dd|}||t|}tj||dd}|SdS)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().rrr9r N)r+rr#aranger*)functionintervalZnumtrapsZnumtosumrZloxZpointssr7r7r8 _difftraps  rcCsd|}||||dS)z Compute the differences for the Romberg quadrature corrections. See Forman Acton's "Real Computing Made Real," p 143. r}rr7)rRcrrr7r7r8 _romberg_diffsrcCsd}}tdt|ddtd|tdtddtt|D]b}td d ||d |dd |fddt|d D]}td |||ddqtdqDtdtd|||ddtdd t|d d ddS)NrzRomberg integration ofrrfromz %6s %9s %9s)ZStepsZStepSizeZResultsz%6d %9fr9rr"z%9fzThe final result isafterzfunction evaluations.)rreprr_r[)rrresmatrarr7r7r8 _printresmats  , rz`scipy.integrate.romberg` is deprecated as of SciPy 1.12.0and will be removed in SciPy 1.15.0. Please use`scipy.integrate.quad` instead.`sbO> c  CsPt|st|rtdt|||d} d} ||g} ||} t| | | } | | }|gg}tj}|d}td|dD]}| d9} | t| | | 7} | | | g}t|D]"}|t|||||dq||}||d}|r||t ||}||ks||t |krq:|}qvt j d||ft dd|rLt | | ||S)aI Romberg integration of a callable function or method. .. deprecated:: 1.12.0 This function is deprecated as of SciPy 1.12.0 and will be removed in SciPy 1.15.0. Please use `scipy.integrate.quad` instead. 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.rfrrr9z,divmax (%d) exceeded. Latest difference = %er:)r#rPr+rcrrhr_appendrrjr<r=rr)rrQrRrSrkrlrZdivmaxrbrWrMrZintrangeZordsumrrrolast_rowrarowrZ lastresultr7r7r8rs@]        rr9 r)rrrZr)rrrrrP-) rrriii )Krererrii@/))irrriixriC) + rrrri iri_7) `)iDrrrrii?# i^) ) }=8Krrrrriiip) ><sB(:ihrrrrriii0 i0) I"!jmirrrrrrl& l7iR0P) @7@!!Nd7ipRrrrrrri$MY(rrrrrrrl`:l@ Al@d@*)i`p`*oFg!f\a LRl@`r r r r rrrlx=l7-)rr9rrrNrrrrrrrrcCsz>> 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 rrYrrz1The sample positions must start at 0 and end at Nr9Nr"r~)r[r#rallr% Exception_builtincoeffsarrayrr+ZnewaxisZlinalginvr_dotmathlogr exp)ZrnequalrnadavinbdbanyitiZnvecCZCinvraZvecZaiBNpowerp1Zfacr7r7r8rsFA        $    rc sttdsddlm}|t_ntj}ts8d}t|t|}t|}t ||\}}|j d} z||dWn2t y} zd}t || WYd} ~ n d} ~ 00zt ||gj} WnLt y} z2d| d}tj|d d fd d } WYd} ~ n d} ~ 00t|} || kr@d }t|t|} || kr`d}t||durx|j| }nt||jjsd}t||j|j dkrd}t |t|dd}|j|}|dvrd}t|| ||| | ||||f S)Nqmcr)statsz`func` must be callable.r9z`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.rr:cstjd|dS)Nr)r!r)r#Zapply_along_axisrUrJr7r8rWNsz_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`).)hasattrrZscipyr%callablerr#Z atleast_1drbroadcast_arraysr&rr+rTr<r=Zint64r$ZHaltonrgZ QMCEnginer2r\Z_qmcZcheck_random_state)rGrQrRn_points n_estimatesqrngrr%rdimrrWZ n_points_intZn_estimates_intr&rngr7rJr8 _qmc_quad_iv's^    "        r0 QMCQuadResultintegralstandard_errori)r,r+r-rc st||||||}|\ }}}}}}}} ddd} dfdd dfdd dfd d } t||krd } tj| d dt|rtj nddS||k} d| jdd}|| || || <|| <t||}||}t }t |j }t D]V}| |}| j|||j}||}| |||||<t|fd||i|j}q||}| |||d}|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 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 FcSs(|rt|t|St||SdSrI)r r#rr*) integrandsdArr7r7r8 sum_productszqmc_quad..sum_productcs$|rt|tSt|SdSrI)r r#rmean) estimatesr)r,r7r8r7szqmc_quad..meanNrcs||p ||}|rjt||\}}t||tjdf}t|dd}tdtd|t|Stj||dSdS)N?rr rr9)ddof)r#r)Zvstackpir rOrstd)r8mr:rtempr%)r7r,r7r8r<s  zqmc_quad..stdcsJ|p ||}|p ||d|d}|r8|dtS|tSdS)Nr)r:rr)r#rsqrt)r8r=rrr7r,r<r7r8sems zqmc_quad..semz^A lower limit was equal to an upper limit, so the value of the integral is zero by definition.r9r:rr seed)r=rr9)F)F)NrF)NNF)r0r#rr<r=r1rhr*prodZzerosr r/r_randomr$scaler*r]Z _init_quadr;)rGrQrRr,r+r-rrSr/r%r6rArZi_swapsignAr5r8Zrngsrasampler0r4r2r3r7r@r8rts6n         &r)Nrr)Nrr)r7rN)r7F)r7rdrdreTr)NrrN)NrrN)rrF)r7rrFrF)r)< __future__rtypingrrrrnumpyr#Z numpy.typingZnptrr< collectionsrZ scipy.specialrr r Zscipy._lib._utilr Zscipy._lib.deprecationr r r__all__rrWarningrrCrDrKrLdictrErrcrrtrrrrrrrrrrrrrrrrrr0r1rr7r7r7r8s          G - [ k' y9          # mJ