Metóda Rungeho-Kuttu je rodina iteratívnych metód na aproximáciu riešení ODE. Najznámejšou z nich je metóda štvrtého rádu (RK4), ktorá sa často používa pre jej rovnováhu medzi presnosťou a výpočtovou náročnosťou.

Rovnica ODE prvého rádu sa zvyčajne zapisuje ako:

\[ \frac{dy}{dt} = f(t, y), \quad y(t_0) = y_0 \]

Metóda RK4 používa nasledujúce kroky na aproximáciu riešenia v bode \(t_{n+1} = t_n + h\):

1. \(k_1 = h f(t_n, y_n)\)
2. \(k_2 = h f(t_n + \frac{h}{2}, y_n + \frac{k_1}{2})\)
3. \(k_3 = h f(t_n + \frac{h}{2}, y_n + \frac{k_2}{2})\)
4. \(k_4 = h f(t_n + h, y_n + k_3)\)

Následne sa nové \(y_{n+1}\) vypočíta ako:

\(y_{n+1} = y_n + \frac{1}{6}(k_1 + 2k_2 + 2k_3 + k_4)\)

Prvý príklad je riešenie ODE:

\[ \frac{dy}{dt} = -2y + t, \quad y(0) = 1 \]

runge_kutta <- function(f, y0, t0, h, n) {
  t <- numeric(n + 1)
  y <- numeric(n + 1)
  t[1] <- t0
  y[1] <- y0
  
  for (i in 1:n) {
    k1 <- h * f(t[i], y[i])
    k2 <- h * f(t[i] + h / 2, y[i] + k1 / 2)
    k3 <- h * f(t[i] + h / 2, y[i] + k2 / 2)
    k4 <- h * f(t[i] + h, y[i] + k3)
    
    t[i + 1] <- t[i] + h
    y[i + 1] <- y[i] + (k1 + 2 * k2 + 2 * k3 + k4) / 6
  }
  
  data.frame(t = t, y = y)
}

f <- function(t, y) {
  -2 * y + t
}

y0 <- 1
t0 <- 0
h <- 0.1
n <- 100

result1 <- runge_kutta(f, y0, t0, h, n)
head(result1)

##     t         y
## 1 0.0 1.0000000
## 2 0.1 0.8234167
## 3 0.2 0.6879053
## 4 0.3 0.5860210
## 5 0.4 0.5116683
## 6 0.5 0.4598565

Druhý príklad je riešenie ODE:

\[ \frac{dy}{dt} = y - t^2 + 1, \quad y(0) = 0.5 \]

f2 <- function(t, y) {
  y - t^2 + 1
}

y0_2 <- 0.5
t0_2 <- 0
h_2 <- 0.1
n_2 <- 70

result2 <- runge_kutta(f2, y0_2, t0_2, h_2, n_2)
head(result2)

##     t         y
## 1 0.0 0.5000000
## 2 0.1 0.6574144
## 3 0.2 0.8292983
## 4 0.3 1.0150701
## 5 0.4 1.2140869
## 6 0.5 1.4256384

Znázornime si aproximácie spolu s presným riešením. V tomto prípade bude červený graf zodpovedať za presné riešenie a modrý graf za aproximáciu

Metóda Rungeho-Kuttu má nasledujúce vlastnosti:

• Presnosť: RK4 je metóda štvrtého rádu, čo znamená, že chyba je rádovo \(O(h^4)\).

• Jednoduchosť implementácie: Hoci je RK4 zložitejšia ako jednoduché metódy, ako je Eulerova metóda, stále je relatívne ľahká na implementáciu.

• Použiteľnosť: RK4 sa dá použiť na širokú škálu ODE bez potreby modifikácie základného algoritmu.

Runge-Kutta metóda je účinný a presný nástroj na numerické riešenie obyčajných diferenciálnych rovníc. V tomto projekte demonštrujem implementáciu a použitie metódy RK4 v jazyku R na riešenie konkrétnych problémov. Výsledky ukazujú, že metóda poskytuje dobrú aproximáciu k analytickému riešeniu.

• Wikipedia: Runge-Kutta methods ```