◆ core25 min

Forward Euler, and why it is not enough

The simplest possible integrator. Worth studying not because you will use it, but because every failure mode of every later method is already visible here in its purest form.

assumes you already have

Differentiating a function you can only sample

An initial value problem gives you the slope everywhere and the state at one moment:

\frac{d y}{d t} = f (t, y), y (t_{0}) = y_{0}

You know which way the trajectory is heading from any point. You want the trajectory.

The obvious move is to trust the slope for a short while:

y_{n + 1} = y_{n} + h f (t_{n}, y_{n})

That is forward Euler, and it is the finite difference from the previous chapter rearranged. It is also, in code, almost nothing:

export const forwardEuler = {
  step: (f, t, y, h) => axpy(h, f(t, y), y),   // y + h·f(t, y)
};

That is the actual implementation this page runs. Every curve below comes from it.

Two kinds of error, and the factor that connects them

Taylor again. Over one step, assuming $y_{n}$ was exact:

y (t_{n + 1}) = y_{n} + h f (t_{n}, y_{n}) + \frac{h ^{2}}{2} y^{''} (ξ)

So a single step is wrong by $\frac{h ^{2}}{2} y^{''}$ — the local truncation error, which is $O (h^{2})$ .

But you do not take one step. To cross a fixed interval $T$ you take $N = T / h$ of them, and the errors accumulate:

global error \approx N \times O (h^{2}) = \frac{T}{h} \times O (h^{2}) = O (h)

The global error is one order worse than the local error. That factor of $1/ h$ is the reason a method described as " $O (h^{p + 1})$ per step" is called a $p$ -th order method. It applies to every integrator in this chapter.

convergence — Exponential decay (λ = 1)

Forward Euler (excluded)Forward Euler — fitted slope 0.972

integrators

Forward Euler · theory 1measured 0.972

Endpoint error against step size for y' = −y. Forward Euler's fitted slope is 1: halving h halves the error, and no more. Switch on the others to see what higher order looks like — but note the vertical scale before you conclude anything about cost.

Slope 1. Ten times the work buys ten times the accuracy — a terrible exchange rate, and the reason nobody integrates anything serious with Euler.

predictcommit first

You integrate y' = −y from t = 0 to t = 5 with forward Euler. Where in the run is the error largest?

The failure that is not about accuracy

Here is the part that matters more than the order.

Apply forward Euler to $y^{'} = - λ y$ with $λ > 0$ . The exact solution decays to zero. The numerical one satisfies

y_{n + 1} = y_{n} - hλ y_{n} = (1 - hλ) y_{n}

so after $n$ steps, $y_{n} = (1 - hλ)^{n} y_{0}$ . This decays only if $∣1 - hλ ∣ < 1$ , which means

h < \frac{2}{λ}

Cross that threshold and the computed solution does not merely become inaccurate — it grows without bound, oscillating in sign, while the true solution decays quietly to zero. There is no warning and no partial credit. It is a cliff.

tunefind the threshold

This is y' = −50y, whose exact solution (dashed) is essentially zero after t = 0.2. Find the step size where forward Euler stops decaying and starts blowing up.

forward Euler, h = 0.010exact

step sizeh = 0.0100

hλ0.500

peak |y|1.00e+0

behaviourdecaying

That distinction is the whole reason the rest of this chapter exists:

Accuracy asks how close you are, and improves smoothly as $h$ shrinks.
Stability asks whether you are bounded at all, and fails discontinuously.

When $λ$ is large — a stiff problem — the stability limit can force a step size thousands of times smaller than accuracy alone would need. You end up spending all your computation resolving a transient that decayed to nothing in the first microsecond. That is the problem implicit methods exist to solve.

recallscheduled for review

For y' = −λy, what step size does forward Euler require, and is it an accuracy limit or a stability limit?

Build it yourself

Now write the step function. It is graded by measuring the order of accuracy your implementation actually achieves — so any correct formulation passes, and a plausible one that is secretly wrong does not.

implementgraded on measured order

Implement one forward Euler step. You are given f(t, y) → State, the current time t, the current state y (an array), and the step size h. Return the new state.

step(f, t, y, h) → State

What to carry forward

Forward Euler is not a bad method because someone made a mistake. It is the honest consequence of using the only information you have — the slope at the point you are standing on. Everything that follows is an answer to a specific complaint about it:

first order is too slow → sample the slope more than once per step (Heun, RK4)
the stability limit is intolerable → evaluate the slope at the destination (implicit methods)
a fixed h is wasteful → estimate the error and resize (adaptive stepping)
energy drifts on long runs → preserve the geometry, not the trajectory (symplectic methods)

Next: the first of those.