Note: This page has been translated by MathWorks. Please click here

To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

Numerically evaluate integral, adaptive Simpson quadrature

`quad`

will be removed in a future release.
Use `integral`

instead.

`q = quad(fun,a,b)`

q = quad(fun,a,b,tol)

q = quad(fun,a,b,tol,trace)

[q,fcnt] = quad(...)

*Quadrature* is a numerical method used to
find the area under the graph of a function, that is, to compute a
definite integral.

$$q={\displaystyle \underset{a}{\overset{b}{\int}}f(x)dx}$$

`q = quad(fun,a,b)`

tries
to approximate the integral of function `fun`

from `a`

to `b`

to
within an error of `1e-6`

using recursive adaptive
Simpson quadrature. `fun`

is a function handle. Limits `a`

and `b`

must
be finite. The function `y = fun(x)`

should accept
a vector argument `x`

and return a vector result `y`

,
the integrand evaluated at each element of `x`

.

Parameterizing Functions explains how to provide additional
parameters to the function `fun`

, if necessary.

`q = quad(fun,a,b,tol)`

uses
an absolute error tolerance `tol`

instead of the
default which is `1.0e-6`

. Larger values of `tol`

result
in fewer function evaluations and faster computation, but less accurate
results. In MATLAB^{®} version 5.3 and earlier, the `quad`

function
used a less reliable algorithm and a default relative tolerance of `1.0e-3`

.

`q = quad(fun,a,b,tol,trace)`

with
non-zero `trace`

shows the values of `[fcnt a b-a Q]`

during
the recursion.

`[q,fcnt] = quad(...)`

returns
the number of function evaluations.

The function `quadl`

may be more efficient
with high accuracies and smooth integrands.

The list below contains information to help you determine which quadrature function in MATLAB to use:

The

`quad`

function may be most efficient for low accuracies with nonsmooth integrands.The

`quadl`

function may be more efficient than`quad`

at higher accuracies with smooth integrands.The

`quadgk`

function may be most efficient for high accuracies and oscillatory integrands. It supports infinite intervals and can handle moderate singularities at the endpoints. It also supports contour integration along piecewise linear paths.The

`quadv`

function vectorizes`quad`

for an array-valued`fun`

.If the interval is infinite, $$\left[a,\infty \right)$$, then for the integral of

`fun(x)`

to exist,`fun(x)`

must decay as`x`

approaches infinity, and`quadgk`

requires it to decay rapidly. Special methods should be used for oscillatory functions on infinite intervals, but`quadgk`

can be used if`fun(x)`

decays fast enough.The

`quadgk`

function will integrate functions that are singular at finite endpoints if the singularities are not too strong. For example, it will integrate functions that behave at an endpoint`c`

like`log|x-c|`

or`|x-c|`

for^{p}`p >= -1/2`

. If the function is singular at points inside`(a,b)`

, write the integral as a sum of integrals over subintervals with the singular points as endpoints, compute them with`quadgk`

, and add the results.

To compute the integral

$$\underset{0}{\overset{2}{\int}}\frac{1}{{x}^{3}-2x-5}dx,$$

write a function `myfun`

that computes the
integrand:

function y = myfun(x) y = 1./(x.^3-2*x-5);

Then pass `@myfun`

, a function handle to `myfun`

,
to `quad`

, along with the limits of integration, `0`

to `2`

:

Q = quad(@myfun,0,2) Q = -0.4605

Alternatively, you can pass the integrand to `quad`

as
an anonymous function handle `F`

:

F = @(x)1./(x.^3-2*x-5); Q = quad(F,0,2);

`quad`

may issue one of the following warnings:

`'Minimum step size reached'`

indicates that
the recursive interval subdivision has produced a subinterval whose
length is on the order of roundoff error in the length of the original
interval. A nonintegrable singularity is possible.

`'Maximum function count exceeded'`

indicates
that the integrand has been evaluated more than 10,000 times. A nonintegrable
singularity is likely.

`'Infinite or Not-a-Number function value encountered'`

indicates
a floating point overflow or division by zero during the evaluation
of the integrand in the interior of the interval.

[1] Gander, W. and W. Gautschi, "Adaptive
Quadrature – Revisited," BIT, Vol. 40, 2000, pp. 84-101.
This document is also available at `http://www.inf.ethz.ch/personal/gander`

.

`dblquad`

| `integral`

| `integral2`

| `integral3`

| `quad2d`

| `quadgk`

| `quadl`

| `quadv`

| `trapz`

| `triplequad`

Was this topic helpful?