Endliche Differenzenapproximationen in C berechnen

Einführung

In diesem Labor lernen Sie, wie man endliche Differenzen-Approximationen von Ableitungen in C auswertet. Das Labor umfasst die folgenden Schritte:

1. Definieren Sie eine mathematische Funktion f(x) und legen Sie die Schrittweite h für die endlichen Differenzen-Approximationen fest.
2. Berechnen Sie Vorwärts- und Rückwärts-endliche Differenzen-Approximationen der Ableitung von f(x) an einem gegebenen Auswertungspunkt x.
3. Geben Sie die berechneten Approximationen aus und vergleichen Sie sie mit der tatsächlichen Ableitung.

Am Ende dieses Labors haben Sie ein solides Verständnis dafür, wie man endliche Differenzen-Methoden in C implementiert und die Genauigkeit der Approximationen beurteilt.

f(x) definieren und Schrittweite h einstellen

In diesem Schritt lernen Sie, wie Sie eine mathematische Funktion definieren und die Schrittweite für endliche Differenzen-Approximationen in C einstellen.

Erstellen Sie zunächst eine neue C-Datei für Ihr Programm zur endlichen Differenzen-Approximation:

cd ~/project
nano finite_difference.c

Fügen Sie nun den folgenden Code hinzu, um die Funktion und die Schrittweite zu definieren:

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

// Die Funktion f(x) definieren
double f(double x) {
    return x * x;  // Beispielfunktion: f(x) = x^2
}

int main() {
    // Die Schrittweite h definieren
    double h = 0.0001;  // Kleine Schrittweite für genaue Approximation

    // Punkt, an dem die Ableitung ausgewertet werden soll
    double x = 2.0;

    printf("Funktion: f(x) = x^2\n");
    printf("Schrittweite h: %f\n", h);
    printf("Auswertungspunkt x: %f\n", x);

    return 0;
}

Beispielausgabe:

Funktion: f(x) = x^2
Schrittweite h: 0.000100
Auswertungspunkt x: 2.000000

Lassen Sie uns die wichtigsten Komponenten aufschlüsseln:

1. Funktion f(x): Wir haben eine einfache quadratische Funktion f(x) = x^2 definiert. Sie können diese Funktion ändern, um jede beliebige mathematische Funktion darzustellen, die Sie approximieren möchten.

2. Schrittweite h: Dies ist ein kleiner Wert, der in endlichen Differenzen-Approximationen verwendet wird. Eine kleinere h liefert typischerweise genauere Ergebnisse, aber extrem kleine Werte können zu numerischen Genauigkeitsproblemen führen.

3. Auswertungspunkt x: Dies ist der Punkt, an dem wir die Ableitungsapproximation berechnen.

Kompilieren Sie das Programm, um sicherzustellen, dass es funktioniert:

gcc -o finite_difference finite_difference.c -lm
./finite_difference

Beispielausgabe:

Funktion: f(x) = x^2
Schrittweite h: 0.000100
Auswertungspunkt x: 2.000000

Vorwärts- und Rückwärtsdifferenzen berechnen

In diesem Schritt lernen Sie, wie Sie Vorwärts- und Rückwärts-endliche Differenzen-Approximationen von Ableitungen berechnen.

Öffnen Sie die vorherige Datei und modifizieren Sie den Code, um die Ableitungsapproximationsmethoden einzubeziehen:

cd ~/project
nano finite_difference.c

Aktualisieren Sie den Code mit den Vorwärts- und Rückwärtsdifferenzberechnungen:

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

// Die Funktion f(x) definieren
double f(double x) {
    return x * x;  // Beispielfunktion: f(x) = x^2
}

int main() {
    // Die Schrittweite h definieren
    double h = 0.0001;  // Kleine Schrittweite für genaue Approximation

    // Punkt, an dem die Ableitung ausgewertet werden soll
    double x = 2.0;

    // Vorwärtsdifferenz-Approximation
    double forward_diff = (f(x + h) - f(x)) / h;

    // Rückwärtsdifferenz-Approximation
    double backward_diff = (f(x) - f(x - h)) / h;

    printf("Vorwärtsdifferenz-Approximation: %f\n", forward_diff);
    printf("Rückwärtsdifferenz-Approximation: %f\n", backward_diff);

    return 0;
}

Kompilieren und ausführen Sie das Programm:

gcc -o finite_difference finite_difference.c -lm
./finite_difference

Beispielausgabe:

Vorwärtsdifferenz-Approximation: 4.000100
Rückwärtsdifferenz-Approximation: 3.999900

Lassen Sie uns die endlichen Differenzen-Approximationen aufschlüsseln:

1. Vorwärtsdifferenz: Berechnet die Ableitung unter Verwendung des Punkts vor x.

   • Formel: (f(x + h) - f(x)) / h
   • Approximiert die Änderungsrate in Vorwärtsrichtung.

2. Rückwärtsdifferenz: Berechnet die Ableitung unter Verwendung des Punkts hinter x.

   • Formel: (f(x) - f(x - h)) / h
   • Approximiert die Änderungsrate in Rückwärtsrichtung.

Beachten Sie, dass die wahre Ableitung für die Funktion f(x) = x^2 2x (was bei x = 2 4 ist) ist. Die Approximationen liegen sehr nahe am tatsächlichen Ableitungswert.

Ausgabe der Approximationen

In diesem Schritt erweitern Sie das Programm, um detaillierte Approximationsergebnisse auszugeben und diese mit der tatsächlichen Ableitung zu vergleichen.

Öffnen Sie die vorherige Datei und modifizieren Sie den Code, um eine umfassende Ausgabe einzubeziehen:

cd ~/project
nano finite_difference.c

Aktualisieren Sie den Code mit der detaillierten Ausgabe der Approximationen:

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

// Die Funktion f(x) definieren
double f(double x) {
    return x * x;  // Beispielfunktion: f(x) = x^2
}

// Funktion für die tatsächliche Ableitung
double actual_derivative(double x) {
    return 2 * x;  // Ableitung von x^2 ist 2x
}

int main() {
    // Definieren Sie mehrere Schrittweiten zum Vergleich
    double step_sizes[] = {0.1, 0.01, 0.001, 0.0001};
    int num_steps = sizeof(step_sizes) / sizeof(step_sizes[0]);

    // Punkt, an dem die Ableitung ausgewertet werden soll
    double x = 2.0;

    // Tatsächlicher Ableitungswert
    double true_derivative = actual_derivative(x);

    printf("Analyse der Ableitungsapproximation\n");
    printf("------------------------------------\n");
    printf("Funktion: f(x) = x^2\n");
    printf("Auswertungspunkt: x = %f\n", x);
    printf("Wahre Ableitung: %f\n\n", true_derivative);

    printf("Schrittweite | Vorwärtsdiff | Rückwärtsdiff | Vorwärtsfehler | Rückwärtsfehler\n");
    printf("-------------------------------------------------------------------------\n");

    // Berechnen und ausgeben Sie Approximationen für verschiedene Schrittweiten
    for (int i = 0; i < num_steps; i++) {
        double h = step_sizes[i];

        // Vorwärtsdifferenz-Approximation
        double forward_diff = (f(x + h) - f(x)) / h;

        // Rückwärtsdifferenz-Approximation
        double backward_diff = (f(x) - f(x - h)) / h;

        // Absoluten Fehler berechnen
        double forward_error = fabs(forward_diff - true_derivative);
        double backward_error = fabs(backward_diff - true_derivative);

        printf("%9f | %11f | %12f | %11f | %12f\n",
               h, forward_diff, backward_diff, forward_error, backward_error);
    }

    return 0;
}

Kompilieren und ausführen Sie das Programm:

gcc -o finite_difference finite_difference.c -lm
./finite_difference

Beispielausgabe:

Analyse der Ableitungsapproximation
------------------------------------
Funktion: f(x) = x^2
Auswertungspunkt: x = 2.000000
Wahre Ableitung: 4.000000

Schrittweite | Vorwärtsdiff | Rückwärtsdiff | Vorwärtsfehler | Rückwärtsfehler
-------------------------------------------------------------------------
    0.100000 |     4.100000 |      3.900000 |      0.100000 |       0.100000
    0.010000 |     4.010000 |      3.990000 |      0.010000 |       0.010000
    0.001000 |     4.001000 |      3.999000 |      0.001000 |       0.001000
    0.000100 |     4.000100 |      3.999900 |      0.000100 |       0.000100

Wichtige Beobachtungen:

1. Mit abnehmender Schrittweite h wird die Approximation genauer.
2. Vorwärts- und Rückwärtsdifferenzen konvergieren gegen die wahre Ableitung.
3. Der Fehler verringert sich mit kleineren Schrittweiten.

Zusammenfassung

In diesem Labor haben Sie gelernt, wie man eine mathematische Funktion definiert und die Schrittweite für endliche Differenzenapproximationen in C festlegt. Sie haben auch gelernt, wie man Vorwärts- und Rückwärts-endliche Differenzenapproximationen von Ableitungen berechnet. Die wichtigsten Schritte umfassen die Definition der Funktion f(x) und der Schrittweite h sowie die Implementierung der Vorwärts- und Rückwärtsdifferenzmethoden, um die Ableitung an einem gegebenen Auswertungspunkt x zu approximieren. Dies bildet eine Grundlage für das Verständnis und die Implementierung von endlichen Differenzenmethoden in der numerischen Analysis und dem wissenschaftlichen Rechnen.