Trapezoid Rule Explained: Approximating Definite Integrals

The error bound for the trapezoidal rule in numerical integration is given by E ≤ (b-a)h²/12 × max|f''(x)|, where h = (b-a)/n is the step size, n is the number of subintervals, and max|f''(x)| is the maximum absolute value of the second derivative of the function over the interval [a,b]; this formula allows determination of either the required step size or number of intervals to achieve a desired accuracy level.

The error in the trapezoidal rule is bounded by (b-a)^3 / (12n^2) max|f''(x)| on [a,b]. This error bound shows that the error decreases proportionally to 1/n^2 as the number of subintervals increases. The error depends on the second derivative of the function, meaning smoother functions (with smaller second derivatives) have smaller errors for the same number of subintervals.

For a function f that is twice continuously differentiable on [a,b], the error in the trapezoidal rule approximation is bounded by (b-a)^3/(12n^2) * max|f''(x)|. The derivation uses Taylor's theorem with remainder: f(x) = f(c) + f'(c)(x-c) + f''(ξ)(x-c)^2/2 for some ξ between c and x. Integrating this from a_i-1 to a_i and subtracting the trapezoidal approximation gives the error bound. This shows the error decreases proportionally to 1/n^2 as the number of subintervals increases.

For a function f of class C² (twice continuously differentiable) on [a,b], the error in the trapezoidal approximation satisfies: |T_n - ∫_a^b f(x)dx| ≤ M × (b-a)³ / (12n²), where M = sup|f''(x)| on [a,b]. As n increases, the error decreases proportionally to 1/n².

To guarantee a certain error tolerance in the trapezoidal rule approximation, calculate the second derivative of the function, determine its maximum absolute value K on the interval [a,b], then solve the inequality K(b-a)³/(12n²) ≤ tolerance for n, rounding up to the nearest whole number; for example, with f(x) = 1/x on [1,2] and tolerance 0.001, the second derivative is 2/x³ which reaches maximum K=2 at x=1, yielding n ≥ √(1/(6×0.001)) ≈ 12.9, so n=13 is required.

This section demonstrates implementing the trapezoidal rule in Python. The algorithm requires: defining the function f(x), setting parameters a (lower limit), b (upper limit), and n (number of subintervals), calculating step size h = (b-a)/n, initializing sum = f(a) + f(b), and for k from 1 to n-1, adding 2*f(a + k*h) to sum. The final result is (h/2) × sum. The implementation shows how to translate the mathematical formula into code, handling the function evaluation at partition points and applying the trapezoidal weighting scheme.

The trapezoidal rule implementation in Python computes the sum with coefficients 1 for endpoints and 2 for interior points: def trapezoid(a, b, n, f): h = (b-a)/n; integral = 0.5*f(a) + 0.5*f(b); for i in range(1, n): x = a + i*h; integral += f(x); return integral*h. This method provides intermediate accuracy between rectangle and midpoint methods.

To implement the Trapezoidal Rule algorithm: (1) Define the function f(x) and integration limits [a, b]. (2) Choose the number of segments n. (3) Calculate the step size Δx = (b - a) / n. (4) Generate the x-values: x_i = a + i × Δx for i = 0, 1, ..., n. (5) Calculate function values at all x-values. (6) Compute the total area using the formula: Area = (Δx/2) × [f(x_0) + 2f(x_1) + 2f(x_2) + ... + 2f(x_{n-1}) + f(x_n)]. The first and last function values are multiplied by 1, while all intermediate values are multiplied by 2. This accounts for the fact that each interior point serves as an endpoint for two adjacent trapezoids.

The trapezoidal rule can be efficiently implemented in Python using NumPy for numerical computations. The implementation involves: (1) defining the integration bounds a and b, (2) generating evenly spaced points between a and b, (3) evaluating the function at these points, (4) computing the width between consecutive points, (5) calculating each trapezoid's contribution using the formula (y[i] + y[i+1]) × dx / 2, and (6) summing all contributions. The code uses a loop from 0 to n-2 (since there are n-1 trapezoids for n points). This approach allows rapid computation of integrals for various functions, significantly saving time compared to manual calculations.

This tutorial demonstrates how to perform numerical integration using the trapezoidal rule in both MATLAB and Python. The trapezoidal rule approximates the definite integral of a function by dividing the area under the curve into trapezoids and summing their areas. In MATLAB, the code uses 1-based indexing (f(1) for first element, f(length(x)) for last), while Python uses 0-based indexing (f[0] for first element, f[len(x)-1] for last). The function f(x) = 400x^5 - 900x^4 + 675x^3 - 200x^2 + 25x + 0.2 is integrated from a=0 to b=0.8 with a step size of 0.01. Both languages require element-wise operations (using dot operators in MATLAB and double asterisks in Python) when working with arrays.

Adaptive quadrature methods improve numerical integration accuracy by dynamically adjusting the spacing of subintervals based on the function's local behavior, using smaller intervals where the function varies rapidly and larger intervals where the function is relatively flat, rather than applying uniform spacing across the entire integration interval.

Adaptive quadrature is a numerical integration technique that automatically adjusts the step size based on function smoothness: in smooth regions, fewer integration steps are used, while in regions with higher derivatives and more oscillations, intervals are subdivided to improve accuracy. The method uses Simpson's rule (p=4) and applies a stopping criterion where the difference between subdivided and non-subdivided integrals must be less than a tolerance threshold (ε × 2^(p-1) / (b-a)). If the criterion is not met, the algorithm recursively subdivides the interval; if met, Richardson extrapolation is applied to return the final result.

Equally spaced points in numerical integration become inefficient when functions have varying behavior across their domain. Functions that remain relatively constant over some intervals but change rapidly in others require either excessively small step sizes (wasting resources on flat regions) or risk missing rapid changes entirely. Adaptive quadrature solves this by dynamically adjusting step sizes—using larger steps where the function is smooth and smaller steps where it changes rapidly. The method begins with an initial step size H1, applies Simpson's 1/3 rule to estimate the integral, then refines the step size to H2 (typically half) and compares the two estimates to identify regions requiring further attention.

Adaptive quadrature automatically adjusts step sizes based on function behavior. Simpson's rule ∫ₐᵇ f(x)dx ≈ (h/3)[f(a) + 4f((a+b)/2) + f(b)] has error E = -(h⁴(b-a)/180)f''''(ψ). By dividing into four subintervals and applying composite Simpson's rule, the error estimate becomes |I₁ - I₂| ≈ 15|E|. If this difference divided by 15 is less than tolerance ε, accept I₂; otherwise, recursively subdivide intervals with halved tolerance. Each refinement reduces error by ~1/15, ensuring convergence.

This section covers adaptive quadrature algorithms that automatically adjust step sizes. The error has asymptotic form E(h) = C·h² + o(h²). By computing I(h) and I(h/2), the error estimate is E(h) ≈ (I(h/2) - I(h))/3. The algorithm: start with h₀, compute I(h₀) and I(h₀/2), estimate error, and if error > ε, halve h₀ and repeat. For adaptive quadrature, the interval is divided into subintervals with independent step sizes. For subinterval of length L, local tolerance is ε·L/(b-a). If E_local > ε·L/(b-a), halve L and repeat. This ensures total error ≤ ε while minimizing computational effort.