Implementing ODE solvers from scratch — Euler, RK4

5.4.23 · Coding › Scientific Computing (Python)

KAUNSA problem solve kar rahe hain?

WHY discretize? Zyaadatar real $f (t, y)$ ka koi closed-form integral nahi hota. Lekin slope $f$ hamesha compute ho sakta hai. Toh hum aage chhoti-chhoti seedhi lakeeron mein chalte hain.

Euler's Method — first principles se derive karna

$y_{n}$ se $y_{n + 1}$ tak kaise jaate hain? Derivative ki definition use karo: $y^{'} (t_{n}) = lim_{h \to 0} \frac{y ( t _{n} + h ) - y ( t _{n} )}{h} \approx \frac{y _{n + 1} - y _{n}}{h}$

Limit hatao (ek finite $h$ use karo) aur $y_{n + 1}$ solve karo:

Equivalently Taylor expansion se: $y (t_{n} + h) = y (t_{n}) + h y^{'} (t_{n}) + error jo hum chhhod dete hain \frac{h ^{2}}{2} y^{''} (ξ)$ Chhhoda hua term $O (h^{2})$ hai per step → local truncation error $O (h^{2})$ . $N = T / h$ steps mein errors accumulate hokar global error $== O (h) ==$ ban jaata hai. $h$ aadha karo → error aadha ho jaata hai. Yeh slow hai.

def euler(f, t0, y0, h, n):
    t, y = t0, y0
    ts, ys = [t], [y]
    for _ in range(n):
        y = y + h * f(t, y)   # one slope, whole step
        t = t + h
        ts.append(t); ys.append(y)
    return ts, ys

RK4 — chaar slopes ka average

Behtar kyun karein? Euler slope sirf interval ke left end par use karta hai, isliye jab curve modta hai toh consistently over/undershoot karta hai. RK4 slope ko start par, middle mein (do baar), aur end mein sample karta hai, phir ek weighted average leta hai — yeh integral $\int_{t_{n}}^{t_{n} + h} f d t$ ke liye Simpson's rule se analogous hai.

Weights $1, 2, 2, 1$ kyun? Sum $= 6$ hai, isliye $\frac{h}{6} (\dots)$ ek sach mein weighted mean slope hai. RK4 do alag midpoint slopes ( $k_{2}, k_{3}$ ) use karta hai, jinhe weight $2$ diya jaata hai, kyunki midpoint $[t_{n}, t_{n} + h]$ ke upar average behaviour best represent karta hai. Yeh Simpson's $1/3$ rule se analogous hai (jo endpoint–midpoint–endpoint ko $1, 4, 1$ weight deta hai): dono interval ke middle par extra weight daalte hain. RK4 Simpson ke ek " $4$ " ko do midpoint evaluations $k_{2}, k_{3}$ mein split karta hai jo milke weight $2 + 2 = 4$ carry karte hain. Taylor series ko $h^{4}$ tak match karna exactly yahi coefficients force karta hai.

Local truncation error $O (h^{5})$ , global error $== O (h^{4}) ==$ .
$h$ aadha karo → error $2^{4} = 16 \times$ girta hai. Isliye RK4 practical computing ka workhorse hai.

def rk4(f, t0, y0, h, n):
    t, y = t0, y0
    ts, ys = [t], [y]
    for _ in range(n):
        k1 = f(t,         y)
        k2 = f(t + h/2,   y + h/2 * k1)
        k3 = f(t + h/2,   y + h/2 * k2)
        k4 = f(t + h,     y + h   * k3)
        y = y + (h/6) * (k1 + 2*k2 + 2*k3 + k4)
        t = t + h
        ts.append(t); ys.append(y)
    return ts, ys

Figure — Implementing ODE solvers from scratch — Euler, RK4

Worked Example 1 — $y^{'} = y$ , $y (0) = 1$ (true: $e^{t}$ )

$h = 1$ lo, ek step, $y_{1}$ nikalo.

Euler: $y_{1} = y_{0} + h f (t_{0}, y_{0}) = 1 + 1 \cdot 1 = 2$ . Kyun? Ek left-slope step. True value $e^{1} \approx 2.718$ → error $0.718$ . Bahut zyaada!

RK4:

$k_{1} = f (0, 1) = 1$ — kyun? slope = $y$ = 1.
$k_{2} = f (0.5, 1 + 0.5 \cdot 1) = 1.5$ — kyun? $k_{1}$ use karke half-step se $y$ nudge karo.
$k_{3} = f (0.5, 1 + 0.5 \cdot 1.5) = 1.75$ — kyun? $k_{2}$ use karke midpoint refine karo.
$k_{4} = f (1, 1 + 1 \cdot 1.75) = 2.75$ — kyun? $k_{3}$ use karke end slope nikalo.
$y_{1} = 1 + \frac{1}{6} (1 + 3 + 3.5 + 2.75) = 1 + \frac{10.25}{6} \approx 2.7083$ .

Error $\approx 0.0099$ — same step size ke saath Euler se 70× behtar.

Worked Example 2 — error scaling check ( $y^{'} = y$ , integrate to $t = 1$ )

Method	$h = 0.1$ error	$h = 0.05$ error	ratio
Euler	$\approx 0.125$	$\approx 0.065$	$\approx 2$ (matches $O (h)$ )
RK4	$\approx 2.1 \times 1 0^{- 6}$	$\approx 1.3 \times 1 0^{- 7}$	$\approx 16$ (matches $O (h^{4})$ )

Yeh kyun matter karta hai: $h$ aadha karna Euler ko sirf do baar help karta hai lekin RK4 ko sola baar — yehi poori wajah hai ki RK4 practical computing mein dominant kyun hai.

Recall Feynman: ek 12-saal ke bachhe ko samjhao

Socho aap kohrе mein chal rahe ho jahaan ek chhota compass bilkul wahaan batata hai kaunsi taraf step karna hai jahan tum khade ho. Euler bas us ek reading par trust karta hai aur poora step chalta hai — lekin agar raasta modta hai, toh tum bhatak jaate ho. RK4 zyaada samajhdaar hai: tum middle mein jhankate ho, phir dobara jhankate ho, phir door waale end mein jhankate ho, phir step lene se pehle un saari compass readings ka average lete ho. Chaar jhankon ka average tumhe path par almost bilkul sahi rakhhta hai.

Flashcards

Euler aur RK4 kaun sa ODE form solve karte hain?

Ek IVP:

y^{'} = f (t, y)

jisme

y (t_{0}) = y_{0}

hai, spacing

h

par aage step karke.

Forward Euler update likhо.

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

Euler apna slope kahaan se leta hai?

Sirf left endpoint

(t_{n}, y_{n})

par, jo step ke upar constant maana jaata hai.

Euler ki global error order?

O (h)

(local truncation

O (h^{2})

RK4 ke chaar stages likhо.

k_{1} = f (t, y)

;

k_{2} = f (t + \frac{h}{2}, y + \frac{h}{2} k_{1})

;

k_{3} = f (t + \frac{h}{2}, y + \frac{h}{2} k_{2})

;

k_{4} = f (t + h, y + h k_{3})

RK4 final update formula?

y_{n + 1} = y_{n} + \frac{h}{6} (k_{1} + 2 k_{2} + 2 k_{3} + k_{4})

Weights 1,2,2,1 kyun?

Slopes ka weighted mean (sum 6); do midpoint slopes har ek double count hote hain (total 4) — Simpson's rule ke middle weight se analogous; Taylor series ko

h^{4}

tak match karne se exactly yahi coefficients force hote hain.

Kya RK4 weights Simpson's

(1, 4, 1)

se identical hain?

Nahi — analogous hain, identical nahi. RK4

(1, 2, 2, 1)

use karta hai do midpoint evaluations ke saath jinke weights ka sum 4 hai.

RK4 global error order?

O (h^{4})

—

h

aadha karne se error ~16× girta hai.

Har RK4 stage kis pichle stage par build karta hai?

k_{2}

k_{1}

use karta hai,

k_{3}

k_{2}

use karta hai,

k_{4}

k_{3}

use karta hai — sequential hai, sab

k_{1}

se nahi.

Equal accuracy par RK4 Euler se sasta kyun hai?

Euler cost ~

1/ ε

, RK4 ~

1/ ε^{1/4}

; char

f

-calls per step bahut zyaada accuracy khareedti hain.

Connections

Taylor Series Expansion — dono methods ise truncate karke derive hote hain.
Simpson's Rule — RK4 weights isse analogous hain.
Finite Difference Approximation of Derivatives — Euler forward difference hai.
Numerical Stability and Stiff ODEs — kyun explicit methods blow up kar sakte hain.
Adaptive Step Size (RK45 / Dormand–Prince) — RK4 ka practical extension.
scipy.integrate.solve_ivp — jo humne banaya uska library version.