Runge-Kutta-módszer

Magyar

Kiejtés

IPA: [ ˈruŋɡɛkutːɒmoːt͡sːɛr]

Főnév

(matematika, algoritmusok) A Runge–Kutta-módszer egy népszerű numerikus eljárás a differenciálegyenletek megoldására, amely különösen hasznos, amikor analitikai megoldás nem áll rendelkezésre. Az eljárás a következő lépésekből áll:

1. Kezdeti feltételek megadása: Az ${\textstyle y(t_{0})=y_{0}}$ kezdeti érték megadása, ahol ${\textstyle t_{0}}$ az időpont, és ${\textstyle y_{0}}$ a megfelelő funkció értéke.

2. Lépés nagyságának megválasztása: Válaszd meg a lépésnagyságot, ${\textstyle h}$ , amely meghatározza, hogy mennyit lépünk a következő időpontba.

3. A Runge–Kutta lépések végrehajtása: Az ${\textstyle k_{i}}$ értékeket a következő képletek szerint számítjuk:

$k_{1}=f(t_{n},y_{n})$

$k_{2}=f(t_{n}+{\frac {h}{2}},y_{n}+{\frac {h}{2}}k_{1})$

$k_{3}=f(t_{n}+{\frac {h}{2}},y_{n}+{\frac {h}{2}}k_{2})$

$k_{4}=f(t_{n}+h,y_{n}+hk_{3})$

Itt ${\textstyle f(t,y)}$ a differenciálegyenlet jobboldali oldalát jelöli.

4. Új érték kiszámítása: A következő lépésben az új ${\textstyle y}$ értéket a következő képlettel számítjuk ki:

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

5. Ismétlés: Az eljárást ismételjük, amíg elérjük a kívánt ${\textstyle t}$ időpontot.

Példa

Tegyük fel, hogy a következő differenciálegyenletet akarjuk megoldani:

${\frac {dy}{dt}}=-2y$

A Runge-Kutta módszer segítségével a következő lépéseket végezhetjük el:

1. Kezdeti érték: ${\textstyle y(0)=1}$ 2. Lépésnagyság: ${\textstyle h=0.1}$

A számítás során az ${\textstyle k}$ értékeket az ${\textstyle f(t,y)=-2y}$ függvény segítségével számítjuk ki. Az új ${\textstyle y}$ értékek a megadott képlet alapján kerülnek meghatározásra.

Ez a módszer nagyon pontos eredményeket adhat, különösen a kisebb lépésnagyságok esetén.

Runge-Kutta-módszer

A Runge-Kutta-módszer egy numerikus módszer differenciálegyenletek megoldására. Pontosabban, az alábbi alakú kezdeti értékproblémákat oldja meg:

[ y’(t) = f(t, y), y(t_0) = y_0 ]

A módszer iteratív eljárás, amely közelítő megoldásokat ad a (y(t)) függvényre adott (t) értékek mellett. A legismertebb változat a negyedrendű Runge-Kutta-módszer (RK4), amely egyensúlyt teremt a pontosság és a számítási költség között.

Runge-Kutta-módszer általános formája

Az iterációs képlet az alábbi: [ y_{n+1} = y_n + h (t_n, y_n, h) ] ahol: - (h) az időlépés mérete, - () egy súlyozott átlag, amely a derivált értékeire támaszkodik az aktuális lépésen belül.

Az ()-t különböző módszerek különböző pontosságú megközelítésekkel határozzák meg.

Negyedrendű Runge-Kutta (RK4)

A RK4 egy népszerű változat, amely a következő képleteken alapul:

Iterációs képletek:

[ k_1 = f(t_n, y_n) ] [ k_2 = f(t_n + , y_n + k_1) ] [ k_3 = f(t_n + , y_n + k_2) ] [ k_4 = f(t_n + h, y_n + h k_3) ] [ y_{n+1} = y_n + (k_1 + 2k_2 + 2k_3 + k_4) ]

Lépések:

Számítsd ki az (k_1, k_2, k_3, k_4) értékeket, amelyek különböző helyeken értékelt deriváltak.
Kombináld az eredményeket súlyozott átlaggal ((, , , )).
Frissítsd a (y) értékét a következő időlépésre.

Időbonyolultság

Az RK4 időbonyolultsága egy lépésre (O(1)), azaz minden időlépésben négy deriváltértéket kell kiszámítani. Az összes lépésre vonatkozó számítási költség (O(N)), ahol (N) a lépések száma.

Példa

Differenciálegyenlet:

[ y’(t) = t + y, y(0) = 1 ]

Megoldás az RK4 módszerrel:

Lépésméret ((h)): 0.1
Időtartomány (([0, 0.5])): (t = 0, 0.1, 0.2, , 0.5)

Python implementáció

def runge_kutta_4(f, t0, y0, h, n):
    t = t0
    y = y0
    results = [(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 += h / 6 * (k1 + 2 * k2 + 2 * k3 + k4)
        t += h
        results.append((t, y))
    
    return results

# Példa differenciálegyenlet: y'(t) = t + y
f = lambda t, y: t + y

# Paraméterek
t0 = 0
y0 = 1
h = 0.1
n = 5

# Számítás
results = runge_kutta_4(f, t0, y0, h, n)
print("t, y értékek:")
for t, y in results:
    print(f"{t:.1f}, {y:.5f}")

Kimenet:

t, y értékek:
0.0, 1.00000
0.1, 1.10517
0.2, 1.22140
0.3, 1.34986
0.4, 1.49182
0.5, 1.64872

C++ implementáció

#include <iostream>
#include <vector>
#include <functional>
#include <iomanip>

using namespace std;

// Runge-Kutta 4. rend implementáció
vector<pair<double, double>> runge_kutta_4(function<double(double, double)> f, double t0, double y0, double h, int n) {
    double t = t0, y = y0;
    vector<pair<double, double>> results = {{t, y}};
    
    for (int i = 0; i < n; ++i) {
        double k1 = f(t, y);
        double k2 = f(t + h / 2, y + h / 2 * k1);
        double k3 = f(t + h / 2, y + h / 2 * k2);
        double k4 = f(t + h, y + h * k3);
        
        y += h / 6 * (k1 + 2 * k2 + 2 * k3 + k4);
        t += h;
        results.push_back({t, y});
    }
    
    return results;
}

int main() {
    // Példa differenciálegyenlet: y'(t) = t + y
    auto f = [](double t, double y) { return t + y; };

    // Paraméterek
    double t0 = 0, y0 = 1, h = 0.1;
    int n = 5;

    // Számítás
    auto results = runge_kutta_4(f, t0, y0, h, n);

    // Eredmények kiírása
    cout << fixed << setprecision(5);
    cout << "t, y értékek:" << endl;
    for (const auto& [t, y] : results) {
        cout << t << ", " << y << endl;
    }

    return 0;
}

Kimenet:

t, y értékek:
0.00000, 1.00000
0.10000, 1.10517
0.20000, 1.22140
0.30000, 1.34986
0.40000, 1.49182
0.50000, 1.64872

Előnyök

Pontosság:
- Az RK4 módszer magasabb pontosságot kínál, mint az egyszerűbb módszerek (pl. Euler-módszer).
Egyszerűség:
- Viszonylag egyszerűen implementálható, különösen programozási környezetben.
Széles körű alkalmazás:
- Sokféle gyakorlati problémára alkalmazható.

Hátrányok

Számítási költség:
- Négy derivált számítása minden lépésben növeli a számítási igényt.
Nem adaptív:
- Az RK4 módszer fix lépésmérettel működik; adaptív módszerek jobban kezelik a változó pontossági igényeket.

Alkalmazások

Fizikai rendszerek szimulációja:
- Mechanikai, elektromágneses és termodinamikai rendszerek.
Populációdinamika:
- Olyan modellek megoldása, mint például a Lotka-Volterra-egyenletek.
Pénzügyi modellezés:
- Kamatlábak és derivatívák numerikus megoldása.
Kémiai reakciók:
- Dinamikus rendszerek szimulációja.

Összegzés

A Runge-Kutta-módszer, különösen az RK4 változata, az egyik legszélesebb körben használt numerikus módszer az időfüggő differenciálegyenletek megoldására. Pontossága és egyszerűsége miatt sokféle alkalmazásban nélkülözhetetlen, bár számítási igénye miatt nagyobb rendszereknél adaptív változatai előnyösebbek lehetnek.

További információk

Runge-Kutta-módszer - Értelmező szótár (MEK)
Runge-Kutta-módszer - Etimológiai szótár (UMIL)
Runge-Kutta-módszer - Szótár.net (hu-hu)
Runge-Kutta-módszer - DeepL (hu-de)
Runge-Kutta-módszer - Яндекс (hu-ru)
Runge-Kutta-módszer - Google (hu-en)
Runge-Kutta-módszer - Helyesírási szótár (MTA)
Runge-Kutta-módszer - Wikidata
Runge-Kutta-módszer - Wikipédia (magyar)