Computing Library › Numerical Methods
Numerical Methods

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

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.

python
# 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.