Euler's Method for Numerical ODEs

The simplest numerical ODE method

Most ODEs you meet in the wild — especially non-linear ones — have no closed-form solution. Numerical methods approximate the solution by stepping along the slope field in small increments. Euler's method is the most basic such method, and understanding it well sets you up for every more-sophisticated solver (Runge-Kutta, Adams, adaptive steppers).

The idea: given $y' = f(x, y)$ and $y(x_0) = y_0$, you know the slope at every point. Start at $(x_0, y_0)$, take a short step of width $h$ along the tangent line, then recompute the slope at the new point and step again.

The update rule is $\boxed{\, y_{n+1} = y_n + h \cdot f(x_n, y_n), \qquad x_{n+1} = x_n + h \,}$

Geometrically: replace each infinitesimal tangent segment of the true solution with a finite chord of length $h$.

The given IVP

$y' = x + y, \qquad y(0) = 1, \qquad h = 0.2, \qquad x \in [0, 1].$

So $f(x, y) = x + y$. Five steps to reach $x = 1$.

Step-by-step Euler computation

Start at $(x_0, y_0) = (0, 1)$.

Step 1 ($x_0 = 0$):

• slope = $f(0, 1) = 0 + 1 = 1$.
• $y_1 = y_0 + h \cdot \text{slope} = 1 + 0.2 \cdot 1 = 1.200$.
• $x_1 = 0.2$.

Step 2 ($x_1 = 0.2$):

• slope = $f(0.2, 1.2) = 0.2 + 1.2 = 1.4$.
• $y_2 = 1.2 + 0.2 \cdot 1.4 = 1.480$.
• $x_2 = 0.4$.

Step 3 ($x_2 = 0.4$):

• slope = $f(0.4, 1.48) = 1.88$.
• $y_3 = 1.48 + 0.2 \cdot 1.88 = 1.856$.
• $x_3 = 0.6$.

Step 4 ($x_3 = 0.6$):

• slope = $f(0.6, 1.856) = 2.456$.
• $y_4 = 1.856 + 0.2 \cdot 2.456 = 2.347$.
• $x_4 = 0.8$.

Step 5 ($x_4 = 0.8$):

• slope = $f(0.8, 2.347) = 3.147$.
• $y_5 = 2.347 + 0.2 \cdot 3.147 = 2.977$.
• $x_5 = 1.0$.

Numerical estimate: $y(1) \approx 2.977$.

Exact solution — compare

$y' - y = x$ is a first-order linear ODE (#174, #175). Integrating factor $\mu = e^{-x}$: $(e^{-x} y)' = e^{-x} \cdot x$

Integrate by parts: $e^{-x} y = -(x + 1) e^{-x} + C \implies y = -(x + 1) + C e^{x}.$

Apply $y(0) = 1$: $1 = -1 + C \implies C = 2$. $y(x) = 2 e^{x} - x - 1.$

Exact value at $x = 1$: $y(1) = 2e - 1 - 1 = 2e - 2 \approx 3.4366$.

Error: $3.4366 - 2.977 = 0.4596$, or about 13% relative error. Ouch — Euler's method is crude.

Why the error is so large — local vs global

Each step introduces a local truncation error that scales as $O(h^2)$ (it's the neglected second-derivative term in the Taylor expansion): $y(x_{n+1}) = y(x_n) + h y'(x_n) + \tfrac{h^2}{2} y''(\xi_n)$

We keep the first two terms (that's Euler) and drop the $O(h^2)$. Accumulated over $N = (x_{\text{final}} - x_0)/h$ steps, errors compound to a global error of $O(h)$. Euler is first-order accurate: halving $h$ halves the error (roughly).

How to do better

• RK2 (midpoint / improved Euler): use the slope at the midpoint or an average of start/end slopes. Global error $O(h^2)$.
• RK4 (classic Runge-Kutta): weighted average of 4 slopes per step. Global error $O(h^4)$. Standard workhorse.
• Adaptive step size (RK45, Dormand-Prince): adjust $h$ on the fly to keep the estimated error under a target. Used by scipy odeint, MATLAB ode45, etc.
• Implicit methods (backward Euler, BDF): for stiff ODEs where explicit methods require extremely small $h$ to stay stable.

Euler is almost never used in production — but it's the conceptual foundation for everything else.

Stability — not just accuracy

For $y' = -\lambda y$ with $\lambda > 0$ (a decaying ODE), Euler gives $y_{n+1} = (1 - \lambda h) y_n$. If $h > 2/\lambda$, the factor $|1 - \lambda h| > 1$ and the numerical solution grows without bound — completely wrong. Stability requires $h < 2/\lambda$, which can force absurdly small $h$ for stiff ODEs with large $\lambda$. This is why implicit methods exist.

Error halves when $h$ halves

If you run the same problem with $h = 0.1$ (10 steps), the error at $x = 1$ is roughly half what it was with $h = 0.2$. With $h = 0.05$, another factor of 2. This linear-in-$h$ decay is the signature of a first-order method.

(Contrast RK4, where halving $h$ cuts the error by a factor of $16$.)

Where Euler's method shows up pedagogically

• Teaching the concept of numerical integration without the machinery of higher-order methods.
• Simple game-physics simulations: for objects with small velocities and short time steps, Euler is fine. Most game engines start with Euler and graduate to Verlet or RK2 when stability matters.
• First-pass sanity checks: "does the ODE behave qualitatively as I expect?" A quick Euler run answers that.
• Inside more complex methods: multi-step methods like Adams-Bashforth use past Euler-like evaluations.

Common mistakes

• Using $f(x_n, y_{n+1})$ instead of $f(x_n, y_n)$. That would be backward Euler (implicit), a different and more stable method, but not what "Euler's method" normally means.
• Forgetting to advance $x$. Each step must update both $y_n \to y_{n+1}$ and $x_n \to x_{n+1}$.
• Comparing to exact solution at intermediate $x_n$ assuming the exact is at $y_n$. The numerical $y_n$ is an approximation; the exact value at $x_n$ is different.
• Not matching units. If your ODE is physical (units of $t$ = seconds, units of $y$ = metres), your step size $h$ is in seconds and your $f$ has units of metres/second.

Try it in the visualization

Draw the slope field for $y' = x + y$, overlay the exact solution $y = 2e^x - x - 1$, and plot the Euler "stairstep" of tangent segments. Slide $h$ down from 0.5 toward 0.02 and watch the stairstep hug the exact curve more tightly. Overlay an error curve $|y_{\text{exact}}(x_n) - y_n|$ to see the global error shrinking.