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:
- Wir inkludieren die notwendigen Header:
stdio.hfür Eingabe/Ausgabe undmath.hfür mathematische Funktionen. f(x)ist als einfache quadratische Funktion x^2 definiert, die wir integrieren werden.- In
main()legen wir das Integrationsintervall von 0 bis 1 fest. - 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:
simpsons_rule()nimmt die Intervallgrenzen und die Anzahl der Teilintervalle entgegen.hberechnet die Breite jedes Teilintervalls.- Wir beginnen mit dem ersten und letzten Punkt des Intervalls.
- Die Schleife addiert gewichtete Beiträge von Zwischenpunkten.
- Gerade Punkte werden mit 2, ungerade Punkte mit 4 multipliziert.
- 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:
- Hinzufügen der Funktion
exact_integral()zur Berechnung des tatsächlichen Integralwerts - Berechnung des absoluten und relativen Fehlers
- 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.
