Multistep Methods
Multistep methods reuse several past values to advance a step, with Adams families for nonstiff problems and BDF families for stiff ones.
Using history to step forward
Single-step methods like Runge-Kutta discard past information each step. Multistep methods instead reuse several previous solution and slope values to build a high-order estimate with only one or two new function evaluations per step, making them efficient when f is expensive.
Adams methods
- Adams-Bashforth is explicit: it fits a polynomial through past slopes and extrapolates. Cheap but conditionally stable.
- Adams-Moulton is implicit: it includes the new point, giving better stability and accuracy for the same order.
- A predictor-corrector pair uses Adams-Bashforth to predict and Adams-Moulton to correct, estimating error from their difference.
Backward differentiation formulas
BDF methods fit a polynomial through past solution values and require its derivative at the new point to match f, producing implicit formulas with excellent stability for stiff problems. BDF1 is backward Euler; BDF2 through BDF6 raise the order while retaining strong stability, though A-stability is lost above order 2. BDF is the standard for large stiff systems.
Starting and changing order
Multistep methods are not self-starting: they need several initial values, usually generated by a Runge-Kutta method. Practical implementations vary both step size and order adaptively, monitoring error to choose the most efficient combination. This variable-step variable-order strategy is what makes production BDF codes robust.
# Adams-Bashforth 2-step (explicit)
def ab2(f, y0, y1, t1, h, steps):
ys=[y0, y1]; t=t1; f_prev=f(t-h, y0); f_cur=f(t, y1)
for _ in range(steps):
y = ys[-1] + h*(1.5*f_cur - 0.5*f_prev)
t += h; f_prev, f_cur = f_cur, f(t, y); ys.append(y)
return ys
BDF integrators handle the stiff transport and reaction systems in breeder Hyperion models efficiently, reusing history to keep the number of expensive right-hand-side evaluations low.