Approximation eines Integrals mit der Trapezregel in C

Einführung

In diesem Lab lernen wir, wie man ein Integral mit der Trapezregel in C approximiert. Das Lab umfasst die folgenden Schritte: 1) Definition der Funktion f(x) und des Intervalls [a, b], 2) Aufteilung des Intervalls und Anwendung der Trapezformel zur Berechnung des Näherungsintegrals und 3) Ausgabe des Endergebnisses. Dieses Lab zielt darauf ab, ein praktisches Verständnis numerischer Integrationstechniken mithilfe der C-Programmiersprache zu vermitteln.

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

In diesem Schritt definieren wir die mathematische Funktion f(x) und das Intervall [a, b] für die numerische Integration mit der Trapezregel in C.

Erstellen wir zunächst eine neue C-Quelldatei zur Implementierung unserer Integralapproximation:

cd ~/project
nano integral_approximation.c

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

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

// Definition der zu integrierenden Funktion f(x)
double f(double x) {
    // Beispiel: f(x) = x^2
    return x * x;
}

int main() {
    // Definition des Intervalls [a, b]
    double a = 0.0;  // Untere Grenze
    double b = 1.0;  // Obere Grenze

    printf("Integralapproximation\n");
    printf("Funktion: f(x) = x^2\n");
    printf("Intervall: [%.2f, %.2f]\n", a, b);

    return 0;
}

Kompilieren und ausführen wir den Code zur Überprüfung:

gcc -o integral_approximation integral_approximation.c -lm
./integral_approximation

Beispielausgabe:

Integralapproximation
Funktion: f(x) = x^2
Intervall: [0.00, 1.00]

In diesem Code haben wir definiert:

• Eine Funktion f(x), die x^2 zurückgibt
• Ein Intervall [a, b] von 0 bis 1
• Die Ausgabe der Funktions- und Intervalldetails

Die Funktion f(x) kann modifiziert werden, um jede gewünschte mathematische Funktion darzustellen, die integriert werden soll.

Intervall aufteilen und Trapezregel anwenden

In diesem Schritt erweitern wir unseren vorherigen Code, um die Trapezregel für die numerische Integration zu implementieren, indem wir das Intervall aufteilen und das Näherungsintegral berechnen.

Öffnen Sie die vorherige Quelldatei und aktualisieren Sie den Code:

cd ~/project
nano integral_approximation.c

Ersetzen Sie den Inhalt durch die folgende Implementierung:

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

// Definition der zu integrierenden Funktion f(x)
double f(double x) {
    return x * x;
}

// Implementierung der Trapezregel
double trapezoidalRule(double a, double b, int n) {
    double h = (b - a) / n;  // Breite jedes Trapezes
    double sum = 0.5 * (f(a) + f(b));  // Erste und letzte Punkte

    for (int i = 1; i < n; i++) {
        double x = a + i * h;
        sum += f(x);
    }

    return sum * h;
}

int main() {
    // Definition des Intervalls [a, b]
    double a = 0.0;  // Untere Grenze
    double b = 1.0;  // Obere Grenze
    int n = 100;     // Anzahl der Trapeze

    double approximateIntegral = trapezoidalRule(a, b, n);

    printf("Integralapproximation\n");
    printf("Funktion: f(x) = x^2\n");
    printf("Intervall: [%.2f, %.2f]\n", a, b);
    printf("Anzahl der Trapeze: %d\n", n);
    printf("Näherungsintegral: %.6f\n", approximateIntegral);

    return 0;
}

Kompilieren und ausführen Sie den aktualisierten Code:

gcc -o integral_approximation integral_approximation.c -lm
./integral_approximation

Beispielausgabe:

Integralapproximation
Funktion: f(x) = x^2
Intervall: [0.00, 1.00]
Anzahl der Trapeze: 100
Näherungsintegral: 0.333333

Wichtige Punkte dieser Implementierung:

• Die Funktion trapezoidalRule() berechnet das Näherungsintegral.
• h repräsentiert die Breite jedes Trapezes.
• n bestimmt die Anzahl der Trapeze für die Approximation.
• Eine Erhöhung von n verbessert die Genauigkeit der Approximation.

Ausgabe des Näherungsintegrals

In diesem Schritt erweitern wir unser Programm zur Integralapproximation, indem wir detailliertere Ausgaben hinzufügen und das numerische Ergebnis mit dem exakten Integralwert vergleichen.

Öffnen Sie die vorherige Quelldatei und aktualisieren Sie den Code:

cd ~/project
nano integral_approximation.c

Ändern Sie den Code, um umfassendere Ausgaben einzuschließen:

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

// Definition der zu integrierenden Funktion f(x)
double f(double x) {
    return x * x;
}

// Berechnung des exakten Integrals für x^2 von 0 bis 1
double exactIntegral() {
    return 1.0 / 3.0;
}

// Implementierung der Trapezregel
double trapezoidalRule(double a, double b, int n) {
    double h = (b - a) / n;  // Breite jedes Trapezes
    double sum = 0.5 * (f(a) + f(b));  // Erste und letzte Punkte

    for (int i = 1; i < n; i++) {
        double x = a + i * h;
        sum += f(x);
    }

    return sum * h;
}

int main() {
    // Definition des Intervalls [a, b]
    double a = 0.0;  // Untere Grenze
    double b = 1.0;  // Obere Grenze
    int n = 100;     // Anzahl der Trapeze

    double approximateIntegral = trapezoidalRule(a, b, n);
    double exact = exactIntegral();
    double error = fabs(approximateIntegral - exact);
    double percentError = (error / exact) * 100.0;

    // Formatierte Ausgabe mit detaillierten Informationen
    printf("Ergebnisse der Integralapproximation\n");
    printf("-------------------------------------\n");
    printf("Funktion:            f(x) = x^2\n");
    printf("Intervall:            [%.2f, %.2f]\n", a, b);
    printf("Anzahl der Trapeze: %d\n", n);
    printf("\nNumerische Ergebnisse:\n");
    printf("Näherungsintegral: %.6f\n", approximateIntegral);
    printf("Genaues Integral:       %.6f\n", exact);
    printf("\nFehleranalyse:\n");
    printf("Absoluter Fehler:       %.6f\n", error);
    printf("Prozentualer Fehler:    %.4f%%\n", percentError);

    return 0;
}

Kompilieren und ausführen Sie den aktualisierten Code:

gcc -o integral_approximation integral_approximation.c -lm
./integral_approximation

Beispielausgabe:

Ergebnisse der Integralapproximation
-------------------------------------
Funktion:            f(x) = x^2
Intervall:            [0.00, 1.00]
Anzahl der Trapeze: 100

Numerische Ergebnisse:
Näherungsintegral: 0.333333
Genaues Integral:       0.333333

Fehleranalyse:
Absoluter Fehler:       0.000000
Prozentualer Fehler:    0.0000%

Verbesserungen in dieser Version:

• Hinzufügen der Funktion exactIntegral() zum Vergleich mit dem numerischen Ergebnis.
• Berechnung des absoluten und prozentualen Fehlers.
• Bereitstellung einer detaillierteren und formatierten Ausgabe.

Zusammenfassung

In diesem Labor haben wir gelernt, wie man ein Integral mit der Trapezregel in C approximiert. Zuerst haben wir die mathematische Funktion f(x) und das Intervall [a, b] für die numerische Integration definiert. Anschließend haben wir die Trapezregel implementiert, indem wir das Intervall aufgeteilt und die Formel angewendet haben, um das Näherungsintegral zu berechnen. Schließlich haben wir das Ergebnis der Integralapproximation ausgegeben.

Die wichtigsten Schritte in diesem Labor waren die Definition der Funktion und des Intervalls, die Aufteilung des Intervalls und die Anwendung der Trapezregel zur Berechnung des Näherungsintegrals. Durch die Durchführung dieser Schritte konnten wir eine einfache und effektive numerische Integrationstechnik in C implementieren.