Implementing numerical integration from scratch — trapezoidal, Simpson's: Question bank

Before you start, one shared vocabulary reminder so no symbol is unearned:

True or false — justify

Trapezoidal rule is always an overestimate.

False — it overestimates only when the curve is convex (bends up, like

x^{2}

), because the straight chord sits above the curve; for a concave curve the chord sits below and it underestimates.

Simpson's rule with more slices always beats Simpson's with fewer.

Mostly true but not guaranteed — smaller

h

shrinks the

O (h^{4})

term, yet for very rough or non-smooth

f

the error constant can misbehave, and rounding error grows with more evaluations.

If a rule is exact for degree-2 polynomials it must be exact for degree-3.

True for Simpson specifically — its symmetric 1-4-1 stencil kills the odd (cubic) error term by cancellation, a free bonus, so it is exact through degree 3 despite only fitting a parabola.

Trapezoidal is a special case of Simpson's.

False — they are different Newton-Cotes members (Newton-Cotes formulas): trapezoid fits a degree-1 line, Simpson a degree-2 parabola. Neither contains the other.

Doubling

n

roughly halves the trapezoidal error.

False — trapezoid error is

O (h^{2})

, and doubling

n

halves

h

, so the error drops to about one quarter, not one half.

For a straight-line function

f (x) = 3 x + 1

, trapezoid and Simpson give identical, exact answers.

True — both are exact for degree-1 polynomials, so both return the true area with zero error regardless of

n

Simpson's rule needs

n

to be even because odd

n

makes

h

negative.

False —

h = (b - a) / n

is positive for any positive

n

; the real reason is each parabola spans a pair of slices, so an odd count leaves one dangling slice with no partner.

The weights in composite trapezoid always sum to

n

True — the pattern

\frac{1}{2}, 1, 1, \dots, 1, \frac{1}{2}

over

n + 1

nodes sums to

n

, and

n \cdot h = b - a

, which is exactly the width the average height must multiply.

n \to \infty

every method converges to the true integral.

True in exact arithmetic — both are Riemann-type sums (Riemann sums) whose limit is the definite integral; in floating point, rounding eventually stops improvement.

Spot the error

A student sets Simpson weights to

1, 4, 4, 4, \dots, 4, 1

. What's wrong?

Only the odd-index (pair-centre) nodes get weight 4; even interior nodes get weight 2 because they are shared between two adjacent parabolas. Blanket-4 double-counts the shared ones.

A student writes for i in range(1, n+1) to sum interior trapezoid nodes.

This includes node

x_{n}

(the right endpoint) as an interior point, adding it twice and mis-weighting it — interior nodes are range(1, n) only, since points number

n + 1

but interior points number

n - 1

Someone claims

\int_{0}^{1} x^{3} d x

can't be exact for Simpson because it only fits parabolas.

Wrong — the fitted curve is a parabola, but Simpson's integration weights make the cubic error term cancel by symmetry, so the answer is exact for cubics anyway.

A program computes trapezoid as sum(f(a+i*h) for i in range(n+1)) * h.

It weights every node by 1, but endpoints should get

\frac{1}{2}

. The fix is subtract half of

f (a) + f (b)

, or equivalently start the sum at

0.5 (f (a) + f (b))

then add interior nodes.

Someone integrates over

[a, b]

with

b < a

and reports a positive area.

With

b < a

h = (b - a) / n

is negative, so the sum naturally comes out negative — the correct signed result; forcing it positive would contradict

\int_{b}^{a} f = - \int_{a}^{b} f

A student uses Simpson with

n = 3

and "just averages the leftover slice."

n = 3

is odd; the clean 1-4-1 stencil can't tile three slices. You must either pick even

n

or apply a separate rule (e.g. a

\frac{3}{8}

Simpson or a trapezoid) to the odd trailing slice — not merely average.

Why questions

Why do endpoints get a different weight from interior nodes?

Each endpoint belongs to only one trapezoid/parabola, while each interior node is shared between two adjacent shapes, so interior nodes are counted twice (trapezoid) or take the shared weight 2 (Simpson).

Why does Simpson's rule need points in pairs of slices rather than single slices?

A parabola is determined by three points, and three consecutive nodes span two slices; you can't fit one parabola over a single slice's two points.

Why is Simpson's error

O (h^{4})

while trapezoid is only

O (h^{2})

Taylor series expansion of the error shows the leading term of trapezoid involves

f^{''}

times

h^{2}

, while Simpson's symmetric stencil cancels the

h^{2}

and

h^{3}

terms, leaving

f^{(4)}

times

h^{4}

Why does trapezoid overestimate a convex (upward-bending) curve?

The straight chord joining two points on a convex curve lies above the curve everywhere between them, so the trapezoid area exceeds the true area under the curve.

Why is Simpson exact for

x^{2}

but not for

x^{4}

Simpson is exact up to degree 3;

x^{4}

is degree 4, so its

f^{(4)}

-driven

O (h^{4})

error term is nonzero and the rule leaves a residual.

Why can we combine trapezoid results to build Simpson?

Richardson extrapolation cancels the

O (h^{2})

term by combining

T_{n}

and

T_{2 n}

in the ratio that eliminates it; the result is algebraically identical to Simpson, which is why halving

h

and extrapolating works.

Why phrase both rules as "weighted sums

\sum_{i} w_{i} f (x_{i})

It reveals that all Newton-Cotes rules (Newton-Cotes formulas) share one skeleton and differ only in weights, so coding them means changing a weight table, not the loop structure.

Edge cases

What does trapezoid give for

n = 1

The single-trapezoid estimate

\frac{b - a}{2} [f (a) + f (b)]

— one straight chord across the whole interval, usually crude but exact if

f

is linear.

What is the smallest valid

n

for Simpson, and why?

n = 2

— exactly one pair of slices, three nodes, one parabola;

n = 1

is impossible because you can't fit a parabola through only two points.

What happens if

f

has a sharp corner (not smooth) inside

[a, b]

Both error estimates assume smoothness (

f^{''}

f^{(4)}

exists); at a corner those derivatives blow up, so the promised

O (h^{2}) / O (h^{4})

orders fail and convergence slows — place a node at the corner to recover accuracy.

What if

a = b

(zero-width interval)?

h = 0

, every slice collapses, and the sum is

0

— correct, since

\int_{a}^{a} f d x = 0

for any

f

What if

f

dips below the

x

-axis somewhere?

The rules return a signed area: regions below the axis contribute negative height

f (x_{i})

, so the result matches the true signed integral, not the geometric area.

What if you feed Simpson an odd

n

in code?

A correct implementation raises an error (as in the parent's raise ValueError); a careless one silently mis-weights the last node, producing a wrong answer that looks plausible — the most dangerous kind of bug.

What is the limiting behaviour of both rules as

n \to \infty

Both converge to the exact

\int_{a}^{b} f d x

in exact arithmetic; in floating point, rounding error eventually dominates and further increasing

n

worsens the result.

Recall One-line self-test before moving on

If you can answer "why do the edges count differently?" and "why does even $n$ matter for Simpson?" in your own words without peeking, you own this topic. Otherwise re-read the Newton-Cotes formulas and Polynomial interpolation links.

Connections

Riemann sums — the limiting sum both rules approximate.
Newton-Cotes formulas — the family these two rules open.
Polynomial interpolation — why Simpson = integrating the fitted parabola.
Taylor series — where the $O (h^{2})$ / $O (h^{4})$ orders come from.
Richardson extrapolation — combining trapezoids to build Simpson / Romberg.
scipy.integrate.quad — the adaptive production tool that hides all this.