Talbot-Methode

Die Talbot Methode (oft auch Talbot-Algorithmus genannt) ist eine numerische Methode, um die inverse Laplace-Transformierte zu approximieren. $F(p)$ ist die bereits bekannte Laplace-Transformierte der gesuchten Funktion $f(t)$. Mittels der Talbot-Methode kann $f(t)$ entsprechend folgender Vorschrift näherungsweise gefunden werden:

Die Funktion cos(3*t) wird mittels Talbot Methode approximiert. Ab einem gewissen N beginnt die Näherung aufgrund limitierter Maschinengenauigkeit zu rauschen.

$f(t)\approx {\frac {r}{N}}\left({\frac {F(r)\cdot e^{rt}}{2}}+\sum _{k=1}^{N-1}\Re \left(e^{t\cdot p(\theta _{k})}\cdot F(p(\theta _{k}))\cdot \left(1+i\zeta (\theta _{k})\right)\right)\right)$

Dabei gilt:

$p(\theta )=r\cdot \theta \cdot \left(cot(\theta )+i\right)$

$r={\frac {2\cdot N}{5\cdot t}}$

$\zeta (\theta _{k})=\theta _{k}+\left(\theta _{k}\cdot cot(\theta _{k})-1\right)\cdot cot(\theta _{k})$

$\theta _{k}={\frac {k\cdot \pi }{N}}$

In Programmiersprachen, die mit komplexen Zahlen rechnen können und wo trigonometrische Funktionen vorprogrammiert sind (bsp. Python, Octave, MATLAB, Mathematica), ist die Methode einfach zu implementieren. Je größer man $N$ wählt umso größere Bereiche von $f(t)$ werden korrekt approximiert. Allerdings nimmt damit auch die Rechenzeit zu. Die Maschinengenauigkeit begrenzt das größtmögliche $N$, das rauschfreie Resultate liefert.

Geschichte

Die Methode wurde 1979 von A. Talbot publiziert.

Beispiel

Beispielimplementierung in GNU Octave:

 function endwert = talbot(N,funktion,t)

 r = 2*N/(5*t);
 summe = funktion(r)*exp(r*t)/2;
 for k = 1:N-1
     thetak = k*pi/N;
     pk = r*thetak*(cot(thetak) + I);
     zk = thetak + cot(thetak)*(thetak*cot(thetak) - 1);
     summe = summe + real( exp(t*pk)*funktion(pk)*(1+I*zk) );
 endfor

 endwert = summe*(r/N);
 return

 endfunction