Approximation von Wurzeln mit der Newtonschen Methode in C

Einführung

In diesem Labor lernen Sie, wie Sie Näherungswerte für die Wurzeln einer Funktion mit der Newtonschen Methode in C berechnen. Das Labor umfasst die folgenden Schritte:

Zuerst definieren Sie die Funktion f(x) und ihre Ableitung f'(x). Anschließend implementieren Sie die iterative Formel der Newtonschen Methode, um die Näherungslösung der Wurzel zu berechnen. Schließlich geben Sie die resultierende Näherungslösung der Wurzel aus.

Dieses Labor bietet ein praktisches Beispiel für die Anwendung numerischer Methoden zur Lösung mathematischer Probleme mit der C-Programmierung. Am Ende des Labors haben Sie ein besseres Verständnis dafür, wie Sie die Newtonsche Methode verwenden, um die Wurzeln einer Funktion zu finden.

f(x) und f'(x) definieren

In diesem Schritt definieren wir die mathematische Funktion f(x) und ihre Ableitung f'(x), um die Newtonsche Methode zur Approximation von Wurzeln zu implementieren.

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

cd ~/project
nano newton_method.c

Schreiben Sie nun den Anfangscode, um unsere Funktion und ihre Ableitung zu definieren:

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

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

// Die Ableitung f'(x) definieren
double f_derivative(double x) {
    return 2 * x;  // Ableitung von f(x) = 2x
}

int main() {
    printf("Funktion f(x) = x^2 - 4\n");
    printf("Ableitung f'(x) = 2x\n");
    return 0;
}

Beispielausgabe:

Funktion f(x) = x^2 - 4
Ableitung f'(x) = 2x

Zerlegung des Codes:

• f(x) ist definiert als x^2 - 4, die Wurzeln liegen bei x = 2 und x = -2
• f_derivative(x) ist die Ableitung von f(x), nämlich 2x
• Wir werden diese Funktionen in den nächsten Schritten verwenden, um die Newtonsche Methode zu implementieren.

Überprüfen Sie die Kompilierung:

gcc -o newton_method newton_method.c -lm
./newton_method

Iteration x_{n+1}=x_n - f(x_n)/f'(x_n)

In diesem Schritt implementieren wir die iterative Formel der Newtonschen Methode, um die Wurzel unserer Funktion zu approximieren.

Öffnen Sie die vorherige Datei newton_method.c:

cd ~/project
nano newton_method.c

Aktualisieren Sie den Code, um die Iteration der Newtonschen Methode einzubeziehen:

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

// Vorherige Funktionsdefinitionen bleiben gleich
double f(double x) {
    return x * x - 4;
}

double f_derivative(double x) {
    return 2 * x;
}

// Implementierung der Newtonschen Methode
double newton_method(double initial_guess, int max_iterations, double tolerance) {
    double x = initial_guess;

    for (int i = 0; i < max_iterations; i++) {
        double fx = f(x);
        double fpx = f_derivative(x);

        // Prüfung auf Division durch Null
        if (fabs(fpx) < tolerance) {
            printf("Ableitung zu nahe an Null. Fortsetzung nicht möglich.\n");
            return x;
        }

        // Iterationsformel der Newtonschen Methode
        double x_next = x - fx / fpx;

        printf("Iteration %d: x = %f\n", i + 1, x_next);

        // Prüfung auf Konvergenz
        if (fabs(x_next - x) < tolerance) {
            return x_next;
        }

        x = x_next;
    }

    printf("Maximale Iterationen erreicht.\n");
    return x;
}

int main() {
    double initial_guess = 1.0;
    int max_iterations = 10;
    double tolerance = 1e-6;

    double root = newton_method(initial_guess, max_iterations, tolerance);

    printf("\nApproximierte Wurzel: %f\n", root);
    printf("f(Wurzel) = %f\n", f(root));

    return 0;
}

Kompilieren und ausführen:

gcc -o newton_method newton_method.c -lm
./newton_method

Beispielausgabe:

Iteration 1: x = 2.500000
Iteration 2: x = 2.050000
Iteration 3: x = 2.000610
Iteration 4: x = 2.000000
Iteration 5: x = 2.000000

Approximierte Wurzel: 2.000000
f(Wurzel) = 0.000000

Wichtige Punkte der Implementierung:

• newton_method() nimmt einen Startwert, maximale Iterationen und eine Toleranz entgegen.
• Implementiert die Iterationsformel der Newtonschen Methode: x_{n+1} = x_n - f(x_n) / f'(x_n)
• Überprüft auf Konvergenz und mögliche Division durch Null.
• Gibt Zwischenschritte aus, um den Approximationsprozess zu veranschaulichen.

Ausgabe der Näherungslösung

In diesem Schritt erweitern wir unsere Implementierung der Newtonschen Methode, um detailliertere Informationen zur Approximation der Wurzel bereitzustellen.

Öffnen Sie die vorherige Datei newton_method.c:

cd ~/project
nano newton_method.c

Aktualisieren Sie den Code, um die Ausgabe der Wurzelapproximation zu verbessern:

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

// Vorherige Funktions- und Methodendefinitionen bleiben gleich
double f(double x) {
    return x * x - 4;
}

double f_derivative(double x) {
    return 2 * x;
}

double newton_method(double initial_guess, int max_iterations, double tolerance) {
    double x = initial_guess;

    printf("Approximation der Wurzel mit der Newtonschen Methode\n");
    printf("-----------------------------------------------------\n");
    printf("Startwert: %f\n", x);
    printf("Toleranz: %e\n", tolerance);
    printf("Maximale Iterationen: %d\n\n", max_iterations);

    for (int i = 0; i < max_iterations; i++) {
        double fx = f(x);
        double fpx = f_derivative(x);

        if (fabs(fpx) < tolerance) {
            printf("Fehler: Ableitung zu nahe an Null.\n");
            return x;
        }

        double x_next = x - fx / fpx;

        printf("Iteration %d:\n", i + 1);
        printf("  Aktueller x-Wert: %f\n", x_next);
        printf("  f(x): %f\n", f(x_next));
        printf("  |x_next - x|: %e\n\n", fabs(x_next - x));

        if (fabs(x_next - x) < tolerance) {
            printf("Konvergenz erreicht!\n");
            return x_next;
        }

        x = x_next;
    }

    printf("Maximale Iterationen erreicht.\n");
    return x;
}

int main() {
    double initial_guess = 1.0;
    int max_iterations = 10;
    double tolerance = 1e-6;

    double root = newton_method(initial_guess, max_iterations, tolerance);

    printf("Endergebnisse:\n");
    printf("-------------\n");
    printf("Näherungslösung der Wurzel: %f\n", root);
    printf("f(Wurzel): %f\n", f(root));
    printf("Absoluter Fehler: %e\n", fabs(f(root)));

    return 0;
}

Kompilieren und ausführen:

gcc -o newton_method newton_method.c -lm
./newton_method

Beispielausgabe:

Approximation der Wurzel mit der Newtonschen Methode
-----------------------------------------------------
Startwert: 1.000000
Toleranz: 1.000000e-06
Maximale Iterationen: 10

Iteration 1:
  Aktueller x-Wert: 2.500000
  f(x): 2.250000
  |x_next - x|: 1.500000e+00

Iteration 2:
  Aktueller x-Wert: 2.050000
  f(x): 0.202500
  |x_next - x|: 4.500000e-01

... (weitere Iterationen)

Konvergenz erreicht!

Endergebnisse:
-------------
Näherungslösung der Wurzel: 2.000000
f(Wurzel): 0.000000
Absoluter Fehler: 0.000000e+00

Wichtige Verbesserungen:

• Detaillierte Informationen zu jeder Iteration
• Anzeige der Anfangsparameter
• Darstellung des Konvergenzfortschritts
• Ausgabe der Endergebnisse mit dem absoluten Fehler

Zusammenfassung

In diesem Labor haben wir zunächst die mathematische Funktion f(x) und ihre Ableitung f'(x) definiert, um die Newtonsche Methode zur Approximation von Wurzeln zu implementieren. Anschließend haben wir die iterative Formel x_{n+1} = x_n - f(x_n)/f'(x_n) implementiert, um die Wurzel zu approximieren. Schließlich geben wir die approximierte Wurzel aus, die durch diesen Prozess erhalten wurde.

Die wichtigsten Schritte in diesem Labor waren die Definition der Zielfunktion und ihrer Ableitung und die iterative Anwendung der Formel der Newtonschen Methode, um zur Wurzel zu konvergieren. Dieser Ansatz ermöglicht es uns, effizient die Wurzeln verschiedener mathematischer Funktionen mithilfe der C-Programmierung zu finden.