Runge-Kutta-metoder

Runge-Kutta-metoder er en familie av numeriske metoder som gir tilnærmete løsninger på differensiallikninger. Metoden ble utviklet omkring år 1900 av de tyske matematikerne Carl Runge og Martin Wilhelm Kutta.

Introduksjon 
Følgende initialverdiproblem betraktes:

Der  er  derivert med hensyn på . Det antas at  er en komplisert funksjon, og at vi ikke har en eksplisitt løsning på problemet. For å generere en løsning er det ønskelig å bevege seg fra  til , og så videre til . Da må den deriverte approksimeres. Runge-Kutta metoden gjør dette ved å gjentatte ganger sette inn forskjellige verdier i funksjonen , og velge lineære kombinasjoner slik at flest mulig ledd i Taylor-utviklingen til  stemmer overens med .

En andre ordens metode
I denne seksjonen utledes en andre-ordens metode for initialverdiproblemet:

Der  kun er en funksjon av . En Runge-Kutta metode er gitt ved:

der  er skrittlengde og ,  og  er konstanter. For å få en andre ordens metode må konstantene stemme overens med Taylor-utviklingen av .Taylor-utviklingen til  rundt  er gitt av: 

Dersom metoden ovenfor utvides, kan den skrives som:

Kravene for en andre ordens metode blir derfor at  og . En (av flere mulige) andre ordens metode er derfor gitt ved:

Metoden ovenfor samsvarer med valget ,  og .

En fjerde ordens metode
For å utlede en fjerde ordens metode må man sette opp konstanter, utvide Taylor-rekken og velge konstater slik at kun ledd med grad  og høyere gjenstår. En av de vanligste fjerde ordens metodene er:

for n = 0, 1, 2, 3, . . . , der

Dette er metoden som oftest blir forbundet med Runge-Kutta. Legg merke til at metoden ovenfor krever at vi evaluerer funksjonen  4 ganger. Grunnen til at man som oftest ikke går høyere enn fjerde orden er fordi høyere orden krever flere funksjonsevalueringer enn ordenen man får.

Implementasjon av RK4
Fjerde ordens Runge-Kutta er rimelig enkel å implementere, og gir gode resultater sammenlignet med lavere ordens metoder. Nedenfor er en implementasjon i Python av RK4
def runge_kutta4(y_n, t_n, h, f):
    '''
    Gir y_n+1 ved hjelp av Runge Kutta 4.
    '''
    # Konstanter
    k1 = f(t_n, y_n)
    k2 = f(t_n + h/2, y_n + (h/2)*k1)
    k3 = f(t_n + h/2, y_n + (h/2)*k2)
    k4 = f(t_n + h,   y_n + h * k3)
    
    # Regn ut og returner neste verdi
    return y_n + (h/6)*(k1 + 2*k2 + 2*k3 + k4)

def f(t, y):
    '''
    Funksjon til den deriverte.
    '''
    return 0.5 * y
    
# Startverdi, skrittlengde, starttid og sluttid
y_0, h, t_0, t_end = 1, 2, 0, 10 
tider = [i for i in range(t_0, t_end+h, h)] # Liste for tiden
y_verdier = [y_0]                           # Liste for y-verdier

for i in range(0, len(tider)-1):
    y_n, t_n = y_verdier[i], tider[i]               # Hent y og t
    y_verdier.append(runge_kutta4(y_n, t_n, h, f))  # Regn ut neste verdi

Generelle metoder
Generelt er en  stegs Runge-Kutta metode gitt av likningene:

Der ,  og  er konstanter. For å få ønsket orden må disse konstantene stemme overens med Taylor-utviklingen. Konstantene kan organiseres i et RK-tablå:

Kilder

Numerisk analyse