Numerisches Integrieren mit dem Simpson Verfahren (in Java)

Hier gibt es nun den ersten Teil einer neue Reihe, der Numerik. Ich werde hier einige Verfahren zeigen mit denen man auf numerischen Wege zu einem Ergebnis kommt, für das sonst komplexere Formeln und Umwandlungen nötig wären. Die numerischen Verfahren liefern im besten Fall genau das gleiche Ergebnis wie der Standard-Algorithmus, im schlechtesten Fall einen Näherungswert.

Wir wollen uns am Anfang auf die numerische Integration konzentrieren, also das lösen eines Integrals ohne die Gleichung selber integrieren zu müssen.

Dies geschieht in unserem Fall mit der bekannten Simpson-Regel. Wikipedia sagt dazu:

Die Simpsonregel (auch simpsonsche Formel) ist ein Verfahren der numerischen Quadratur, bei dem eine Näherung zum Integral einer Funktion f(x) im Intervall [a,b] berechnet wird, indem man die Kurve f(x) durch eine Parabel annähert.

Die Formel die wir anwenden lautet:

Die Grenzen des Intervals über das integriert werden soll werden als a und b bezeichnet. a ist dabei die untere Grenze, b die Obere.

Weiterhin gilt:

Sieht auf den ersten Blick kompliziert aus, ist aber in der Handhabung sehr einfach, vor allem wenn man die Formel in Java umsetzt, wie wir später noch sehen werden.

Als Beispiel errechnen wir zuerst das Integral:

über dem Interval von a = 0 bis b = 5.
Hierbei erhalten wir dann die Lösung 41,66666667.

Nun wenden wir das numerische Verfahren, also die Simpson Regel an:

Wir wählen n = 8 (dies ist beliebig, muss jedoch den oben genannten Kriterien entsprechen!), errechnen damit h = 5/8 (Die Grenzen des Intervals bleiben selbstverständlich gleich).

Nun erstellen wir eine Tabelle mit den Werten der xi (Werte die x0 bis xn zugeordnet werden):

xi 0 5/8 10/8 15/8 20/8 25/8 30/8 35/8 40/8
f(xi) 0 25/64 100/64 225/64 400/64 625/64 900/64 1225/64 1600/64

Einsetzen in die Simpson Formel:

Durch einsetzen der errechneten xi Werte in die oben genannte Gleichung erhalten wir als Ergebnis: 41,66666667. Also genau das gleiche wie bei der obigen normalen Integration. Die Simpson Regel scheint also ziemlich genau zu sein, was sie auch ist. Sie kann sehr gut als Ersatz für eine Integration genutzt werden, wenn zum Beispiel keine Integralrechnung zur Verfügung steht oder eine Optimierung auf Additionen und Multiplikationen erfolgt.

Die Java Umsetzung der Simpson Regel:

Das Ganze kann dann natürlich vereinfacht mit Java umgesetzt werden, dies erspart einem die langwierige Ausrechnung der Endformel, vor allem wenn es mehr als 8 Schritte (Stützstellen) werden sollten.

package simpson;
 
public class Start {
 
	public static void main(String[] args) {
 
		// Untere Grenze des Intervals
		double a = 0;
		// Obere Grenze des Intervals
		double b = 5;
		// Anzahl der Schritte (n)
		int nn = 8;
		double[] data = new double[nn + 1];
		// Berechnung von (h)
		double h = (b - a) / nn;
 
		System.out.println("Die Simpson-Regel in Java");
 
		// Füllen der Tabelle mit den xi Werten
		for (int i = 0; i <= nn; i++) {
 
			data[i] = a + i * h;
 
		}
 
		// f(x0)
		double erg = 0;
		erg += Math.pow(data[0], 2);
 
		// f(x1) bis f(xn-1)
		for (int y = 1; y < nn; y++) {
 
			if (y % 2 == 0)
				erg += 2 * (Math.pow(data[y], 2));
			else
				erg += 4 * (Math.pow(data[y], 2));
 
		}
 
		// f(xn)
		erg += Math.pow(data[nn], 2);
 
		// Ausgabe der Lösung
		System.out.println("Ergebnis: " + (h / 3) * erg);
 
	}
 
}

Hier wurde das gleiche Beispiel wie oben verwandt. Eine Anpassung an ein anderes Integral sollte keine Probleme darstellen. Ebenso nicht die Erhöhung der Schrittzahl.

4 Gedanken zu „Numerisches Integrieren mit dem Simpson Verfahren (in Java)

  • 22. Dezember 2008 um 19:49
    Permalink

    Ah wie gut das ich alles verstanden habe.

    Antworten
  • 22. Dezember 2008 um 19:51
    Permalink

    Naja, musst du ja auch nicht, ist Uni-Stoff ;)

    Antworten
  • 27. Mai 2011 um 02:06
    Permalink

    Eine bessere Implemtierung:

    private static double simpson(int n, double uG, double oG) {

    double ergUnge = 0.0,
    ergGe = 0.0;
    double erg = fkt(uG) + fkt(oG);

    double h = (oG -uG) / n;
    double xUnge = uG + h,
    xGe = uG + 2*h;

    for (int i = 1; i < n; i += 2, xUnge += 2.0 * h)
    ergUnge += fkt(xUnge);
    for (int i = 2; i < n; i += 2, xGe += 2.0 * h)
    ergGe += fkt(xGe);

    erg += ergUnge * 4.0 + ergGe * 2.0;

    return erg * h/3.0;

    }

    private static double fkt(double x) {
    return Math.sin(x);
    }

    Antworten
  • 16. Februar 2018 um 10:39
    Permalink

    Müsste die Formen nicht mit h/6 lauten
    oder N/2 stehen und dan2h/6 =h/3

    Antworten

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.

Durch die weitere Nutzung der Seite stimmst du der Verwendung von Cookies zu. Weitere Informationen zum Datenschutz...

Die Cookie-Einstellungen auf dieser Website sind auf "Cookies zulassen" eingestellt, um das beste Surferlebnis zu ermöglichen. Wenn du diese Website ohne Änderung der Cookie-Einstellungen verwendest oder auf "Akzeptieren" klickst, erklärst du sich damit einverstanden.

Schließen