Skip to main content
`Ctrl`+`K`
scipy.integrate.

# newton_cotes

scipy.integrate.newton_cotes(rn, equal=0)

  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:

  \(\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 \(\xi \in [x_0,x_N]\) and \(\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 \(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.

  Array API Standard Support

  `newton_cotes` has experimental support for Python Array API Standard compatible backends in addition to NumPy. Please consider testing these features by setting an environment variable `SCIPY_ARRAY_API=1` and providing CuPy, PyTorch, JAX, or Dask arrays as array arguments. The following combinations of backend and device (or other capability) are supported.

  Library | CPU | GPU
  --- | --- | ---
  NumPy | ✅ | n/a
  CuPy | n/a | ⛔
  PyTorch | ⛔ | ⛔
  JAX | ⛔ | ⛔
  Dask | ⛔ | n/a

  > See Support for the array API standard for more information.

  Examples

  Compute the integral of sin(x) in [0, \(\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