o
    Eb(                     @  s  d dl mZ d dlmZmZmZmZmZmZ d dl	Z	d dl
Zd dlZd dlZd dlZd dl
mZ d dlmZ d dlmZ g dZdd	 ZeeZejrSejd
de_dddZG dd deZerqd dlmZ G dd deZneZdddZedd Ze e_ dddZ!dd!d"Z"	$	&dd'd(Z#d)d* Z$dd+d,Z%dd-d.Z&d/d0 Z'dd2d3Z(dd4d5Z)dd6d7Z*d8d9 Z+d:d; Z,d<d= Z-	 	 dd@dAZ.d&dBd&d&gddCfd&dDg dEddFfdDdGg dHdIdJfdBdKg dLdMdNfddOg dPdQdRfd&dSg dTdUdVfdWdXg dYdZd[fd\d]g d^d_d`fdadbg dcdddefddfg dgdhdifdjdkg dldmdnfd&dog dpdqdrfdsdtg dudvdwfdWdxg dydzd{fd|Z/dd}d~Z0dS )    )annotations)TYPE_CHECKINGCallableDictTupleAnycastN)trapz)roots_legendre)gammaln)
fixed_quad
quadraturerombergromb	trapezoidr	   simpssimpsoncumulative_trapezoidcumtrapznewton_cotesAccuracyWarningc                 C  s6   t j| j| j| j| j| jd}t|| }| j	|_	|S )zBBased on http://stackoverflow.com/a/6528148/190597 (Glenn Maynard))nameZargdefsZclosure)
typesFunctionType__code____globals____name____defaults____closure__	functoolsupdate_wrapper__kwdefaults__)fg r$   =/usr/lib/python3/dist-packages/scipy/integrate/_quadrature.py
_copy_func   s   r&   zsum, cumsumznumpy.cumsum      ?c                 C  s   t | |||dS )z~`An alias of `trapezoid`.

    `trapz` is kept for backwards compatibility. For new code, prefer
    `trapezoid` instead.
    )xdxaxis)r   )yr)   r*   r+   r$   r$   r%   r	   '   s   r	   c                   @  s   e Zd ZdS )r   N)r   
__module____qualname__r$   r$   r$   r%   r   0   s    r   )Protocolc                   @  s   e Zd ZU ded< dS )CacheAttributeszDict[int, Tuple[Any, Any]]cacheN)r   r-   r.   __annotations__r$   r$   r$   r%   r0   9   s   
 r0   funcr   returnc                 C  s
   t t| S N)r   r0   )r3   r$   r$   r%   cache_decorator?   s   
r6   c                 C  s,   | t jv r
t j|  S t| t j| < t j|  S )zX
    Cache roots_legendre results to speed up calls of the fixed_quad
    function.
    )_cached_roots_legendrer1   r
   )nr$   r$   r%   r7   C   s   


r7   r$      c                 C  sx   t |\}}t|}t|st|rtd|| |d  d | }|| d tj|| |g|R   dd dfS )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
    >>> 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(   r+   N)r7   nprealisinf
ValueErrorsum)r3   abargsr8   r)   wr,   r$   r$   r%   r   S   s   >
.r   Fc                   s(   |r fdd}|S  fdd}|S )ao  Vectorize 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                   s   | g R  S r5   r$   )r)   rD   r3   r$   r%   vfunc   s   zvectorize1.<locals>.vfuncc                   s   t | r| g R  S t | } | d g R  }t| }t|dt|}t j|f|d}||d< td|D ]}| | g R  ||< q9|S )Nr   dtyperH   r:   )r=   isscalarasarraylengetattrtypeemptyrange)r)   Zy0r8   rH   outputirF   r$   r%   rG      s   

r$   )r3   rD   vec_funcrG   r$   rF   r%   
vectorize1   s
   rT   "\O>2   Tr:   c	                 C  s   t |ts|f}t| ||d}	tj}
tj}t|d |}t||d D ]%}t|	||d|d }t||
 }|}
||k sC||t|
 k rH |
|fS q#t	
d||f t |
|fS )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
    >>> 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

    rS   r:   r$   r   z-maxiter (%d) exceeded. Latest difference = %e)
isinstancetuplerT   r=   infmaxrP   r   abswarningswarnr   )r3   rB   rC   rD   tolrtolmaxiterrS   ZminiterrG   valerrr8   Znewvalr$   r$   r%   r      s&   
@
r   c                 C  s   t | }|||< t|S r5   )listrY   )trR   valuelr$   r$   r%   tupleset  s   rh   c                 C     t | ||||dS )z`An alias of `cumulative_trapezoid`.

    `cumtrapz` is kept for backwards compatibility. For new code, prefer
    `cumulative_trapezoid` instead.
    )r)   r*   r+   initial)r   )r,   r)   r*   r+   rj   r$   r$   r%   r   #     r   c                 C  sT  t | } |du r|}nDt |}|jdkr+t |}dg| j }d||< ||}nt|jt| jkr9tdt j||d}|j| | j| d krPtdt| j}tt	df| |t	dd}tt	df| |t	dd}	t j
|| | | |	   d |d}
|durt |stdt|
j}d||< t jt j|||
jd	|
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.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.r<   7If given, length of x along axis must be the same as y.r;   z'`initial` parameter should be a scalar.rI   )r=   rK   ndimdiffreshaperL   shaper@   rh   sliceZcumsumrJ   rd   ZconcatenateZfullrH   )r,   r)   r*   r+   rj   drq   ndslice1slice2resr$   r$   r%   r   ,  s6   
6



"

r   c                 C  sj  t | j}|d u rd}d}td f| }t||t|||}	t||t|d |d |}
t||t|d |d |}|d u rYtj| |	 d| |
   | |  |d}||d 9 }|S tj||d}t||t|||}t||t|d |d |}|| }|| }|| }|| }|| }|d | |	 dd|   | |
 || |   | | d|    }tj||d}|S )	Nr      r:      r<         @g      @r'   )rL   rq   rr   rh   r=   rA   ro   )r,   startstopr)   r*   r+   rt   step	slice_allslice0ru   rv   resulthZsl0Zsl1Zh0Zh1ZhsumZhprodZh0divh1tmpr$   r$   r%   _basic_simpson  s6   
&r   avgc                 C  ri   )zz`An alias of `simpson`.

    `simps` is kept for backwards compatibility. For new code, prefer
    `simpson` instead.
    )r)   r*   r+   even)r   )r,   r)   r*   r+   r   r$   r$   r%   r     rk   r   c                 C  s  t | } t| j}| j| }|}|}d}	|durWt |}t|jdkr>dg| }
|jd |
|< |j}d}	|t|
}nt|jt| jkrLtd|j| |krWtd|d dkrd}d}tdf| }tdf| }|dvrwtd	|d
v rt||d}t||d}|dur|| ||  }|d| | | | |   7 }t	| d|d |||}|dv rt||d}t||d}|dur|t| |t|  }|d| | | | |   7 }|t	| d|d |||7 }|dkr|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.

    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
    >>> 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

    r   Nr:   rl   rm   rx   g        )r   lastfirstz3Parameter 'even' must be 'avg', 'last', or 'first'.)r   r   r(         ?   )r   r   r   r;   )
r=   rK   rL   rq   rp   rY   r@   rr   rh   r   )r,   r)   r*   r+   r   rt   NZlast_dxZfirst_dxZreturnshapeZshapexZ	saveshaperb   r   ru   rv   r$   r$   r%   r     s^   
F





r   c              	   C  s  t | } t| j}| j| }|d }d}d}||k r'|dK }|d7 }||k s||kr/tdi }	tdf| }
t|
|d}t|
|d}|t j|td }| | | |  d | |	d< |
}| } }}td|d D ]\}|dL }t||t|||}|dL }d	|	|d df || | j	|d
   |	|df< td|d D ]$}|	||d f }|||	|d |d f  dd| > d   |	||f< q|d }qj|r<t 
|	d std nfz|d }W n ttfy   d}Y nw z|d }W n ttfy   d}Y nw d||f }d}td|ddddd t|d D ]}t|d D ]}t||	||f  dd q t  qtd t  |	||f S )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
    >>> 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
    r:   r   z=Number of samples must be one plus a non-negative power of 2.Nr(   rI   r;   )r   r   r   r<   rx   zE*** Printing table only supported for integrals of a single data set.r9      z%%%d.%dfz6Richardson Extrapolation Table for Romberg Integration D   zD====================================================================
)sepend r   )r=   rK   rL   rq   r@   rr   rh   floatrP   rA   rJ   print	TypeError
IndexErrorcenter)r,   r*   r+   showrt   ZNsampsZNintervr8   kRr~   r   Zslicem1r   Zslice_Rr{   r|   r}   rR   jprevZpreciswidthZformstrtitler$   r$   r%   r   /  sh   
;

06


r   c                 C  s   |dkrt d|dkrd| |d | |d   S |d }t|d |d  | }|d d|  }||t|  }tj| |d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).
    r   z#numtraps must be > 0 in difftrap().r:   r   rx   r<   )r@   r   r=   arangerA   )functionintervalZnumtrapsZnumtosumr   ZloxZpointssr$   r$   r%   	_difftrap  s   r   c                 C  s   d| }|| |  |d  S )z
    Compute the differences for the Romberg quadrature corrections.
    See Forman Acton's "Real Computing Made Real," p 143.
    g      @r'   r$   )rC   cr   r   r$   r$   r%   _romberg_diff  s   r   c                 C  s   d }}t dt| dd t d| t d t dd  tt|D ]1}t d	d
| |d |d  d|  f dd t|d D ]}t d|| |  dd q@t d q"t d t d|| | dd t dd
t|d  d d d S )Nr   zRomberg integration ofr   r   fromr   z%6s %9s %9s)ZStepsZStepSizeZResultsz%6d %9frx   r:   r;   z%9fzThe final result isZafterzfunction evaluations.)r   reprrP   rL   )r   r   resmatrR   r   r$   r$   r%   _printresmat  s   
,
 r   `sbO>
   c	              	   C  sD  t |s
t |rtdt| ||d}	d}
||g}|| }t|	||
}|| }|gg}t j}|d }td|d D ]R}|
d9 }
|t|	||
7 }|| |
 g}t|D ]}|t|| || |d  qT|| }||d  }|rw|| t	|| }||k s||t	| k r n|}q;t
d||f t |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
    >>> gaussian = lambda x: 1/np.sqrt(np.pi) * np.exp(-x**2)
    >>> result = integrate.romberg(gaussian, 0, 1, show=True)
    Romberg integration of <function vfunc at ...> 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.rW   r:   r   rx   z,divmax (%d) exceeded. Latest difference = %e)r=   r?   r@   rT   r   rZ   rP   appendr   r\   r]   r^   r   r   )r   rB   rC   rD   r_   r`   r   ZdivmaxrS   rG   r8   r   ZintrangeZordsumr   r   rc   Zlast_rowrR   rowr   Z
lastresultr$   r$   r%   r     s@   T 

r   rx      r   )r:   ry   r:   Z   r   )r:   r   r   r:   P   -   )       r   r   r   ii  i   )   K   rV   rV   r   r   ii@/     ))         i  r   r   r   iix  r   iC  )    +    r   r   r   r   i	i  ry   i_7  )	     ` )  iDr   r   r   r   ii?# 	   i ^ )
)  }=  8  K    r   r   r   r   r   ii  ip )>  < sB( :ih r   r   r   r   r   iii0	   i 0)I"!  jmi r   r   r   r   r   r   l&	 l    7 iR0P ) @ 7@!!Nd7ipRr   r   r   r   r   r   i<ic]    l    `5]v)   v[O    =H/54 +w    "- Mp:    {> $MY( r   r   r   r   r   r   r   l`: l    @	Al   @d@* )i`p`*o   Fg! f    \a LR l   @` r   r   r   r   r   r   r   lx= l   7-)r:   rx   r   ry   r9      r   r   r   r   r   r   r      c                 C  s  zt | d }|rt|d } ntt| dkrd}W n ty2   | }t|d } d}Y nw |rU|tv rUt| \}}}}}|tj|td | }|t|| fS | d dksa| d |kret	d| t| }	d|	 d }
t|d }|
|ddtj
f  }tj|}tdD ]}d| ||| }qd|ddd d  }|dddddf ||d  }|d dkr|r||d	  }|d }n
||d  }|d }|t|	| | }|d }|t| t| }t|}||| fS )
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.

    Examples
    --------
    Compute the integral of sin(x) in [0, :math:`\pi`]:

    >>> 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:   rI   r   r(   z1The sample positions must start at 0 and end at Nrx   Nr;   rz   )rL   r=   r   allro   	Exception_builtincoeffsZarrayr   r@   ZnewaxisZlinalginvrP   dotmathlogr   Zexp)ZrnZequalr   ZnadavinbZdbZanyiZtiZnvecCZCinvrR   ZvecZaiZBNZpowerZp1Zfacr$   r$   r%   r     sJ   @$

r   )Nr'   r(   )r3   r   r4   r0   )r$   r9   )r$   F)r$   rU   rU   rV   Tr:   )Nr'   r(   N)Nr'   r(   r   )r'   r(   F)r$   r   r   Fr   F)r   )1Z
__future__r   typingr   r   r   r   r   r   r   Znumpyr=   r   r   r]   r	   r   Zscipy.specialr
   r   __all__r&   __doc__replaceWarningr   Ztyping_extensionsr/   r0   r6   r7   dictr1   r   rT   r   rh   r   r   r   r   r   r   r   r   r   r   r   r   r$   r$   r$   r%   <module>   s     	
	



G-
T

	\
!
	
} 	
 






#