Approximation eines Integrals mit der Simpsonschen Regel in C

Einführung

In diesem Labor lernen Sie, wie Sie ein Integral mit der Simpsonschen Regel in C approximieren. Das Labor behandelt den schrittweisen Prozess der Definition der zu integrierenden Funktion, des Integrationsintervalls und der Implementierung des Simpsonschen Regel-Algorithmus zur Berechnung des Näherungsintegrals. Am Ende dieses Labors verfügen Sie über ein funktionierendes C-Programm, das eine gegebene Funktion über ein angegebenes Intervall mithilfe der Simpsonschen Regel numerisch integrieren kann.

Das Labor besteht aus zwei Hauptschritten: der Definition der Funktion und des Intervalls und anschließend der Verwendung der Simpsonschen Regel mit geraden Teilintervallen zur Berechnung des Näherungsintegrals. Diese praktische Übung hilft Ihnen, praktische Erfahrungen in der Anwendung numerischer Integrationstechniken in der C-Programmierung zu sammeln.

f(x) und Intervall [a, b] definieren

In diesem Schritt legen wir die grundlegenden Komponenten für die Implementierung der Simpsonschen Regel zur numerischen Integration in C fest. Wir definieren die zu integrierende Funktion und geben das Integrationsintervall an.

Erstellen Sie zunächst eine neue C-Datei im Verzeichnis ~/project:

cd ~/project
nano simpson_integration.c

Schreiben Sie nun den Anfangscode zur Definition unserer Funktion und des Intervalls:

#include <stdio.h>
#include <math.h>

// Funktion zur Integration: f(x) = x^2
double f(double x) {
    return x * x;
}

int main() {
    // Integrationsintervall [a, b] definieren
    double a = 0.0;  // Untergrenze
    double b = 1.0;  // Obergrenze

    printf("Integration von f(x) = x^2 von %f bis %f\n", a, b);

    return 0;
}

Lassen Sie uns den Code aufschlüsseln:

1. Wir inkludieren die notwendigen Header: stdio.h für Eingabe/Ausgabe und math.h für mathematische Funktionen.
2. f(x) ist als einfache quadratische Funktion x^2 definiert, die wir integrieren werden.
3. In main() legen wir das Integrationsintervall von 0 bis 1 fest.
4. Wir geben das Intervall zur besseren Übersicht aus.

Kompilieren und führen Sie den Code aus, um ihn zu überprüfen:

gcc simpson_integration.c -o simpson_integration -lm
./simpson_integration

Beispielausgabe:

Integration von f(x) = x^2 von 0.000000 bis 1.000000

Simpsonsche Regel mit geraden Teilintervallen verwenden

In diesem Schritt implementieren wir den Algorithmus der Simpsonschen Regel, um das bestimmte Integral unserer Funktion zu approximieren. Wir fügen die Integrationsfunktion unserem bestehenden C-Programm hinzu.

Öffnen Sie die vorherige Datei:

cd ~/project
nano simpson_integration.c

Aktualisieren Sie den Code, um die Implementierung der Simpsonschen Regel einzuschließen:

#include <stdio.h>
#include <math.h>

// Funktion zur Integration: f(x) = x^2
double f(double x) {
    return x * x;
}

// Implementierung der Simpsonschen Regel
double simpsons_rule(double a, double b, int n) {
    double h = (b - a) / n;  // Breite jedes Teilintervalls
    double sum = f(a) + f(b);  // Erste und letzte Punkte

    // Berechnung der Summe der geraden und ungeraden Punkte
    for (int i = 1; i < n; i++) {
        double x = a + i * h;
        sum += (i % 2 == 0 ? 2 : 4) * f(x);
    }

    return (h / 3) * sum;
}

int main() {
    // Integrationsintervall [a, b] definieren
    double a = 0.0;  // Untergrenze
    double b = 1.0;  // Obergrenze
    int n = 100;     // Anzahl der Teilintervalle (muss gerade sein)

    double integral = simpsons_rule(a, b, n);

    printf("Integral von f(x) = x^2 von %f bis %f\n", a, b);
    printf("Approximation mit der Simpsonschen Regel mit %d Teilintervallen: %f\n", n, integral);

    return 0;
}

Kompilieren und ausführen des Codes:

gcc simpson_integration.c -o simpson_integration -lm
./simpson_integration

Beispielausgabe:

Integral von f(x) = x^2 von 0.000000 bis 1.000000
Approximation mit der Simpsonschen Regel mit 100 Teilintervallen: 0.333333

Lassen Sie uns die Implementierung der Simpsonschen Regel aufschlüsseln:

1. simpsons_rule() nimmt die Intervallgrenzen und die Anzahl der Teilintervalle entgegen.
2. h berechnet die Breite jedes Teilintervalls.
3. Wir beginnen mit dem ersten und letzten Punkt des Intervalls.
4. Die Schleife addiert gewichtete Beiträge von Zwischenpunkten.
5. Gerade Punkte werden mit 2, ungerade Punkte mit 4 multipliziert.
6. Das Endergebnis wird durch h/3 skaliert.

Ausgabe des Näherungsintegrals

In diesem letzten Schritt erweitern wir unsere Implementierung der Simpsonschen Regel, indem wir detailliertere Ausgaben hinzufügen und die numerische Näherung mit dem exakten Integralwert vergleichen.

Öffnen Sie die vorherige Datei:

cd ~/project
nano simpson_integration.c

Aktualisieren Sie den Code, um umfassendere Ausgaben einzuschließen:

#include <stdio.h>
#include <math.h>

// Funktion zur Integration: f(x) = x^2
double f(double x) {
    return x * x;
}

// Exakte Integralberechnung für f(x) = x^2 von a bis b
double exact_integral(double a, double b) {
    return (pow(b, 3) - pow(a, 3)) / 3.0;
}

// Implementierung der Simpsonschen Regel
double simpsons_rule(double a, double b, int n) {
    double h = (b - a) / n;  // Breite jedes Teilintervalls
    double sum = f(a) + f(b);  // Erste und letzte Punkte

    // Berechnung der Summe der geraden und ungeraden Punkte
    for (int i = 1; i < n; i++) {
        double x = a + i * h;
        sum += (i % 2 == 0 ? 2 : 4) * f(x);
    }

    return (h / 3) * sum;
}

int main() {
    // Integrationsintervall [a, b] definieren
    double a = 0.0;  // Untergrenze
    double b = 1.0;  // Obergrenze
    int n = 100;     // Anzahl der Teilintervalle (muss gerade sein)

    // Berechnung der Näherung und des exakten Integrals
    double approx_integral = simpsons_rule(a, b, n);
    double exact_value = exact_integral(a, b);
    double error = fabs(exact_value - approx_integral);

    // Ausgabe der detaillierten Ergebnisse
    printf("Ergebnisse der Integralnäherung:\n");
    printf("------------------------------\n");
    printf("Funktion: f(x) = x^2\n");
    printf("Intervall: [%.2f, %.2f]\n", a, b);
    printf("Anzahl der Teilintervalle: %d\n\n", n);

    printf("Näherung (Simpsonsche Regel): %.6f\n", approx_integral);
    printf("Exakter Wert: %.6f\n", exact_value);
    printf("Absoluter Fehler: %.6f\n", error);
    printf("Relativer Fehler: %.4f%%\n", (error / exact_value) * 100);

    return 0;
}

Kompilieren und ausführen des Codes:

gcc simpson_integration.c -o simpson_integration -lm
./simpson_integration

Beispielausgabe:

Ergebnisse der Integralnäherung:
------------------------------
Funktion: f(x) = x^2
Intervall: [0.00, 1.00]
Anzahl der Teilintervalle: 100

Näherung (Simpsonsche Regel): 0.333333
Exakter Wert: 0.333333
Absoluter Fehler: 0.000000
Relativer Fehler: 0.0000%

Wichtige Ergänzungen in diesem Schritt:

1. Hinzufügen der Funktion exact_integral() zur Berechnung des tatsächlichen Integralwerts
2. Berechnung des absoluten und relativen Fehlers
3. Erstellung einer formatierten Ausgabe, die detaillierte Integrationsergebnisse anzeigt

Zusammenfassung

In diesem Labor haben wir zunächst die zu integrierende Funktion f(x) = x^2 und das Integrationsintervall [a, b] = [0, 1] definiert. Anschließend haben wir den Algorithmus der Simpsonschen Regel implementiert, um das bestimmte Integral der Funktion zu approximieren. Die Simpsonsche Regel beinhaltet die Unterteilung des Intervalls in eine gerade Anzahl von Teilintervallen und die Berechnung der gewichteten Summe der Funktionswerte an den Endpunkten und den Mittelpunkten dieser Teilintervalle. Schließlich geben wir den approximierten Integralwert aus, der mit der Simpsonschen Regel ermittelt wurde.