Worked examples — Adaptive step-size — RK45, error control

This page is the "no surprises" drill for the parent note Adaptive step-size — RK45, error control. Every knob in the step controller can point in different directions — the error can be too big, too small, or exactly on budget; the raw step factor can want to grow, shrink, or blow past the safety clamps; the tolerance itself changes as $|y|$ grows. Below we first lay out every case that can happen, then work an example for each so you never meet a scenario you have not already seen.

Before we touch numbers, one reminder of what each symbol means, in plain words:

---

The scenario matrix

Every step the controller takes is a combination of two independent questions. Think of it as a grid:

Cell	Error vs tol ($\epsilon$ vs $\text{tol}$)	Raw factor $S(\text{tol}/\epsilon {)}^{1/5}$	Outcome we must show
C1	$\epsilon <\text{tol}$ (spare room)	between $1$ and $f_{\max }$	accept, grow moderately
C2	$\epsilon \gg \text{tol}$ (way over)	below $f_{\min }$	reject, shrink but clamp at $f_{\min }$
C3	$\epsilon \ll \text{tol}$ (tiny error)	above $f_{\max }$	accept, but clamp growth at $f_{\max }$
C4	$\epsilon >\text{tol}$ (mildly over)	between $f_{\min }$ and $1$	reject, shrink moderately, stay at $t_n$
C5	$\epsilon =\text{tol}$ exactly (boundary)	$\approx S<1$	accept, $h$ barely changes
C6	$\epsilon =0$ (degenerate: perfect step)	$\to \infty$	division danger → must clamp
C7	tolerance is relative-dominated ($|y_n|$ large, incl. negative $y$)	any	show $\text{tol}=\text{atol}+\text{rtol}|y_n|$ growing
C8	a system of ODEs (vector $y$)	any	error is a norm, not a scalar
C9	word problem / real integration to $t_{\text{end}}$	any	last step capped so we land exactly on $t_{\text{end}}$
C10	non-finite $\epsilon$ or $\text{tol}$ (NaN / Inf from overflow)	undefined	force reject + shrink, never trust the number

The examples below hit every cell. Watch the label on each.

---

Example 1 — C1: accept and grow moderately

Steps.

1. Accept or reject? Compare $\epsilon =2\times 10^{-7}$ with $\text{tol}=10^{-6}$. Since $\epsilon <\text{tol}$, the step is good → accept and advance $t$ to $t_n+h$. Why this step? The whole point of $\epsilon$ is to be a gatekeeper; under budget means the answer is trustworthy.
2. Ratio. $\text{tol}/\epsilon =10^{-6}/(2\times 10^{-7})=5$. Why this step? We form $\text{tol}/\epsilon$ because that ratio is precisely the factor by which we may enlarge the error budget; feeding it through the $h^5$ law (next step) converts "spare error" into "allowed step change." It is the one quantity that cancels the unknown constant $C$, so it drives everything.
3. Raw factor. $S(\text{tol}/\epsilon {)}^{1/5}=0.9\times 5^{0.2}=0.9\times 1.3797=1.2418$. Why this step? Error grows like $h^5$, so to spend $5\times$ more error we may only stretch $h$ by $5^{1/5}$ — a much gentler factor.
4. Clamp check. $1.2418$ sits between $f_{\min }=0.2$ and $f_{\max }=5$, so no clamp fires.
5. New step. $h_{\text{new}}=0.20\times 1.2418=0.2484$.

Verify: predicted new error $\approx C{h}_{\text{new}}^5$, using the error constant $C$ defined in the symbol list. Since $\epsilon =C{h}^5$, we have $C=\epsilon /h^5$, so $C$ cancels: predicted ${\epsilon }_{\text{new}}=\epsilon (h_{\text{new}}/h{)}^5=2\times 10^{-7}\times (1.2418{)}^5=2\times 10^{-7}\times 2.9525\approx 5.9\times 10^{-7}$. That is just under $\text{tol}=10^{-6}$ — exactly what the safety factor $S$ was aiming for. ✔ (Here $y$ is scalar, so $\epsilon =|y^{(5)}-y^{(4)}|$.)

---

Example 2 — C4: reject and shrink moderately

Steps.

1. Accept or reject? $\epsilon =4\times 10^{-6}>\text{tol}=10^{-6}$ → reject. We do not advance $t$; we stay at $t_n$. Why this step? A rejected step means $y_{n+1}$ is untrustworthy — using it would carry a too-big error forward forever (see Local vs Global Truncation Error).
2. Ratio. $\text{tol}/\epsilon =1/4=0.25$. Why this step? Same reason as always — this ratio, once passed through the $h^5$ law, tells us how much to resize $h$; a value below $1$ already signals "shrink." It also cancels the unknown $C$.
3. Raw factor. $0.9\times 0.25^{0.2}=0.9\times 0.7579=0.6821$. Why this step? A factor below $1$ means shrink — correct, since we overshot the budget.
4. Clamp check. $0.6821$ lies between $0.2$ and $5$; no clamp.
5. New step. $h_{\text{new}}=0.10\times 0.6821=0.0682$. We retry from the same $t_n$ with this.

Verify: predicted retried error $=\epsilon (h_{\text{new}}/h{)}^5=4\times 10^{-6}\times (0.6821{)}^5=4\times 10^{-6}\times 0.1476\approx 5.9\times 10^{-7}<\text{tol}$. So the retry should pass first time — the safety margin at work. ✔

---

Example 3 — C2: reject, but the shrink hits the floor clamp

Steps.

1. Reject — $\epsilon \gg \text{tol}$. Stay at $t_n$.
2. Ratio. $\text{tol}/\epsilon =10^{-6}/10^{-2}=10^{-4}$. Why this step? As before, we build $\text{tol}/\epsilon$ so the $h^5$ law can turn "how far over budget" into "how much to shrink"; a ratio far below $1$ warns of a big shrink, which the clamp will later tame.
3. Raw factor. $0.9\times (10^{-4}{)}^{0.2}=0.9\times 10^{-0.8}=0.9\times 0.1585=0.1427$. Why this step? $(10^{-4}{)}^{1/5}=10^{-0.8}$ — the fifth root tames even a huge overshoot.
4. Clamp check. $0.1427<f_{\min }=0.2$ → the floor clamp fires. Use $0.2$ instead. Why this step? The $h^5$ error model was fitted near the current $h$; a wild $0.14\times$ shrink might land in a region the model never saw, so we cap how fast we retreat and simply try again if still too big.
5. New step. $h_{\text{new}}=0.10\times 0.2=0.020$.

Verify: the unclamped prediction would have been $\epsilon (0.1427{)}^5=10^{-2}\times 5.9\times 10^{-5}=5.9\times 10^{-7}$ — under tol. With the clamp we only shrink to $0.2\times$, giving predicted $\epsilon (0.2{)}^5=10^{-2}\times 3.2\times 10^{-4}=3.2\times 10^{-6}$, still above tol. So this step will likely be rejected again and shrink once more — that is the intended, safe, gradual behaviour. ✔

---

Example 4 — C3: accept, but growth hits the ceiling clamp

Steps.

1. Accept — $\epsilon \ll \text{tol}$, advance $t$.
2. Ratio. $\text{tol}/\epsilon =10^{-6}/10^{-12}=10^6$. Why this step? We form the ratio for the same reason every time — it is the dimensionless "error headroom" that the $h^5$ law converts into a step-change factor; here it is enormous, foreshadowing a growth the ceiling clamp must cap.
3. Raw factor. $0.9\times (10^6{)}^{0.2}=0.9\times 10^{1.2}=0.9\times 15.849=14.264$.
4. Clamp check. $14.264>f_{\max }=5$ → ceiling clamp fires. Use $5$. Why this step? A $14\times$ jump could skip right over an oncoming sharp feature of the solution; we cap growth and let the next step grow again if there is still room.
5. New step. $h_{\text{new}}=0.05\times 5=0.25$.

Verify: predicted new error with the clamped step $=\epsilon (5{)}^5=10^{-12}\times 3125=3.125\times 10^{-9}$, still safely under $\text{tol}=10^{-6}$. Room to keep growing next step — exactly the "sprint gradually" behaviour. ✔

---

Example 5 — C5: sitting exactly on the tolerance boundary

Steps.

1. Accept or reject? The rule is $\epsilon \le \text{tol}$ → accept. Since $\epsilon =\text{tol}$, we accept (the boundary is inclusive). Why this step? Rejecting an exactly-on-budget step would loop forever near the boundary; the $\le$ makes the decision definite.
2. Ratio. $\text{tol}/\epsilon =1$. Why this step? We still form the ratio because the update formula demands it; a ratio of exactly $1$ means "no error headroom," so any change to $h$ comes purely from the safety factor.
3. Raw factor. $0.9\times 1^{0.2}=0.9$. Why this step? With no error headroom, the only change comes from the safety factor, which nudges $h$ slightly down so future steps keep a margin.
4. Clamp check. $0.9$ is between $0.2$ and $5$; no clamp.
5. New step. $h_{\text{new}}=0.08\times 0.9=0.072$.

Verify: the safety factor should always give $h_{\text{new}}\le h$ when $\epsilon =\text{tol}$. Indeed $0.072<0.08$. ✔ This is why $S<1$: even on-budget, we drift toward safety rather than the edge.

---

Example 6 — C6: degenerate perfect step ($\epsilon =0$)

Steps.

1. Accept — an error of $0$ is certainly $\le \text{tol}$. Why this step? Zero estimated error means the two embedded answers agree perfectly, so the step is as trustworthy as it can be.
2. Guard the division. The ratio $\text{tol}/\epsilon$ is undefined at $\epsilon =0$. Why this step? Forming the ratio is the usual move, but here it would divide by zero; we must protect it before the $h^5$ law can use it. In code we replace $\epsilon$ by $\max (\epsilon ,{\epsilon }_{\text{floor}})$, where ${\epsilon }_{\text{floor}}$ is a tiny positive number tied to machine precision — a common concrete choice is ${\epsilon }_{\text{floor}}=10^{-16}$ (roughly double-precision round-off). Then the ratio is finite and huge, so the raw factor overshoots $f_{\max }$ and the ceiling clamp takes over.
3. New step. With the floor in place the raw factor exceeds $f_{\max }$, so $h_{\text{new}}=h\cdot f_{\max }=0.1\times 5=0.5$. Why this step? The ceiling clamp already turns "wants to grow enormously" into "grow by $5\times$," so no separate rule for $\epsilon =0$ is needed.

Verify: take the limit instead of the floor and you get the same answer. As $\epsilon \to 0^{+}$, raw factor $=0.9(\text{tol}/\epsilon {)}^{1/5}\to +\infty$, and $\min (f_{\max },\text{huge})=f_{\max }=5$. So the limiting new step is $0.1\times 5=0.5$ — the $\epsilon =0$ case is just the endpoint of that limit, and the floor ${\epsilon }_{\text{floor}}$ merely makes the computer reach it without crashing. ✔

---

Example 7 — C7: relative tolerance takes over as $|y|$ grows (and stays positive for negative $y$)

Steps.

1. Take the absolute value first. The relative term uses $|y_n|=|-2000|=2000$, not $-2000$. Why this step? A tolerance is a size of allowed error; it must be $\ge 0$. The $|\cdot |$ in $\text{atol}+\text{rtol}|y_n|$ exists precisely so that a negative solution contributes its magnitude — otherwise a negative $y$ would give a negative "budget," which is meaningless (you can't allow an error smaller than zero).
2. Build the tolerance. $\text{tol}=\text{atol}+\text{rtol}|y_n|=10^{-6}+10^{-3}\times 2000=10^{-6}+2=2.000001$. Why this step? When $|y|$ is large, demanding error below a fixed $10^{-6}$ is absurdly strict; the relative part says "I care about $0.1\%$ of the magnitude of $y$", which here is about $2$.
3. Ratio. $\text{tol}/\epsilon =2.000001/1.5=1.3333$. Why this step? We form the ratio for the same reason as every example — it is the dimensionless headroom the $h^5$ law converts into a step-change factor. A value above $1$ signals the step is inside budget and $h$ may grow slightly.
4. Accept or reject? $\epsilon =1.5<\text{tol}\approx 2.0$ → accept. Why this step? Against the properly scaled budget the step is comfortably inside; only the naive absolute-only view called it bad.
5. Raw factor and new step. $0.9\times 1.3333^{0.2}=0.9\times 1.0592=0.9533$, so $h_{\text{new}}=0.1\times 0.9533=0.0953$ (a slight shrink because we are only just inside budget).

Verify: confirm the sign fix and that relative dominates. Since $|-2000|=2000>0$, the budget $\text{tol}=2.000001>0$ as required. The atol term $10^{-6}$ is $2\times 10^6$ times smaller than the rtol term $2$, so $\text{tol}\approx 2$ to 6 significant figures. With absolute-only, we would have rejected a perfectly fine step and stalled — the classic Mistake C from the parent note. ✔

---

Example 8 — C8: a system of ODEs, error is a norm

Steps.

1. Scale each component. Divide each error by its own tolerance: $e_1/{\tau }_1=3\times 10^{-7}/10^{-6}=0.3$, $e_2/{\tau }_2=4\times 10^{-7}/10^{-6}=0.4$. Why this step? Different components can live on different scales; dividing each error by its own ${\tau }_i$ turns every component into a dimensionless "fraction of its own budget," so they become comparable. A scaled value below $1$ means that component is within budget.
2. Combine with a root-mean-square norm. $\epsilon =\sqrt{\frac{1}{2}(0.3^2+0.4^2)}=\sqrt{\frac{1}{2}(0.09+0.16)}=\sqrt{0.125}=0.3536$. Why this step? This is where $\Vert \cdot \Vert$ actually does work that $|\cdot |$ cannot: the accept/reject test needs a single scalar, so we collapse the vector of scaled errors into one number. The RMS norm (used by scipy's Dormand–Prince solver) averages the squared scaled errors so no single component is ignored and no component alone can dominate unfairly.
3. Accept or reject? Because we already scaled by the tolerances, the budget is now simply $1$: a scaled $\epsilon <1$ means "every component is, on average, within its own budget." Here $\epsilon =0.3536<1$ → accept. Why this step? Scaling folded the tolerance into the error itself, so the comparison "$\epsilon$ vs $\text{tol}$" becomes the clean "$\epsilon$ vs $1$" — it is the same test, just measured in units of the budget.
4. Ratio and raw factor. With the scaled budget $1$ playing the role of tol, the ratio is $1/\epsilon =1/0.3536=2.828$, and the raw factor is $S(1/\epsilon {)}^{1/5}=0.9\times 2.828^{0.2}=0.9\times 1.2306=1.1076$. Why this step? We form the ratio $1/\epsilon$ for the exact same reason as in every scalar case — it is the error headroom the $h^5$ law converts into a step-change factor; the only difference is that "budget" is now the scaled value $1$.
5. New step. $h_{\text{new}}=0.1\times 1.1076=0.1108$ (grow, since the vector step was comfortably inside budget). Why this step? A scaled error well under $1$ means spare room in all components, so we may speed up — the fifth root keeps the growth gentle.

Verify: RMS norm check: $\frac{1}{2}(0.09+0.16)=0.125$, $\sqrt{0.125}=0.353553\dots$, and $h_{\text{new}}=0.1\times 0.9\times (1/0.353553{)}^{0.2}=0.1108$. ✔ Since $\epsilon <1$ the step grows, exactly as expected for a comfortable vector step. Note this is the same controller as the scalar case — only the meaning of "$\epsilon$" (now a norm) and "budget" (now $1$) was generalised.

---

Example 9 — C9: word problem, land exactly on $t_{\text{end}}$

Steps.

1. Check the remaining distance. $t_{\text{end}}-t_n=10-9.85=0.15$. Why this step? We must finish exactly at the requested time; overshooting would give an answer at the wrong $t$.
2. Cap the step. $h_{\text{used}}=\min (h_{\text{new}},t_{\text{end}}-t_n)=\min (0.40,0.15)=0.15$. Why this step? Capping (not rejecting) is correct because a smaller step only reduces error, so it stays acceptable.
3. Take the final step from $9.85$ to $10.00$. Integration is complete. Why this step? Once $t$ reaches $t_{\text{end}}$ exactly, the requested integration is done; there is nothing left to advance.

Verify: $9.85+0.15=10.00$ exactly — we land on the deadline. And since $0.15<0.40$, predicted error $=\epsilon (0.15/0.40{)}^5$ is smaller than the already-accepted estimate, so the capped step is guaranteed acceptable. ✔ Compare with the fixed-step RK4 method, which would need this cap hand-coded too.

---

Example 10 — C10: non-finite $\epsilon$ or $\text{tol}$ (NaN / Inf guard)

Steps.

1. Detect the non-finite value. Before comparing, test isfinite(eps) and isfinite(tol). Here $\epsilon =\text{Inf}$ fails the test. Why this step? A NaN breaks every comparison: NaN <= tol, NaN > tol, and NaN == tol are all false, so the plain accept/reject logic would silently do the wrong thing (often accept). We must catch it before the comparison, not after.
2. Force a rejection. Treat any non-finite $\epsilon$ as "infinitely over budget": reject the step and stay at $t_n$. Why this step? An overflowed error is certainly not within tolerance; the only safe reading is "the biggest possible error," which is a reject.
3. Shrink at the floor clamp. Do not feed $\text{Inf}$ into $(\text{tol}/\epsilon {)}^{1/5}$ (that gives $0$ or another NaN). Instead directly use the floor factor: $h_{\text{new}}=h\cdot f_{\min }=0.1\times 0.2=0.02$. Why this step? The step-update formula assumes a finite $\epsilon$; bypassing it and shrinking by the maximum allowed amount $f_{\min }$ is the fastest safe retreat toward a step small enough that the arithmetic no longer overflows.
4. (If $\text{tol}$ itself is non-finite — e.g. $|y_n|$ overflowed — the same rule applies: reject and shrink, because a budget you cannot compute cannot be met.)

Verify: confirm the NaN trap logic. In IEEE arithmetic NaN <= x is False for every x, so a naive if eps <= tol: accept would fail to accept and fall through unpredictably; an explicit isfinite guard is the only correct fix. Numerically the forced shrink gives $h_{\text{new}}=0.1\times 0.2=0.02$, the same floor-clamped retreat as Example 3. ✔

---

Recall Quick self-test across all cells

Which cell needs a division guard? ::: C6 ($\epsilon =0$) — guard $\text{tol}/\epsilon$ by flooring $\epsilon$ at round-off (e.g. $10^{-16}$) or return $f_{\max }$. After a rejected step, what happens to $t$? ::: Nothing — stay at $t_n$ and retry (Examples 2, 3, 10). When $|y_n|$ is huge (or negative), which tolerance term dominates and why is it positive? ::: The relative one, $\text{rtol}|y_n|$; the $|\cdot |$ keeps the budget positive even when $y_n<0$ (Example 7). How is error turned into one number for a system? ::: A scaled RMS norm $\Vert \cdot \Vert$ of per-component errors, then compared against a budget of $1$ (Example 8). When do you use $|\cdot |$ vs $\Vert \cdot \Vert$ for $\epsilon$? ::: Scalar equation → $|\cdot |$; a system (vector $y$) → the norm $\Vert \cdot \Vert$. Why cap the last step instead of rejecting it? ::: A smaller step only lowers error, so it stays acceptable while landing exactly on $t_{\text{end}}$ (Example 9). What must you do if $\epsilon$ or $\text{tol}$ is NaN/Inf? ::: Detect with an isfinite check, then force a reject and shrink by $f_{\min }$ — never trust the comparison (Example 10).

---

Connections

• Parent: Adaptive step-size — RK45, error control — the theory these examples drill.
• Runge–Kutta Methods (RK4) — the fixed-step method underneath the embedded pair.
• Local vs Global Truncation Error — why $h^{p+1}$ drives every factor above.
• Order of a Numerical Method — the $p=4$ that fixes the $1/5$ exponent.
• Taylor Series Expansion — origin of the leading error constant $C$.
• Stiff ODEs and Stability — when even a perfect controller must take tiny steps (and overflow can trigger Example 10).
• Dormand–Prince (RK45 used by scipy solve_ivp) — the RMS-norm error test in Example 8.