Approximation von e mit seiner Reihe in C

Einführung

In diesem Labor untersuchen wir, wie man die mathematische Konstante e mithilfe ihrer Reihenentwicklung in C approximiert. Die Reihe für e ist definiert als die Summe der Reziproken der Fakultäten: e = 1 + 1/1! + 1/2! + 1/3! + ... Zuerst erstellen wir ein C-Programm, um diese Reihenapproximation zu berechnen, und modifizieren es dann, um die Terme zu summieren, bis eine gewünschte Genauigkeit erreicht ist. Dies ermöglicht es uns, die Genauigkeit unserer Berechnung zu steuern und eine genauere Approximation von e zu erhalten.

Verwendung von e = ∑(1/n!)

In diesem Schritt untersuchen wir, wie man die mathematische Konstante e mithilfe ihrer Reihenentwicklung in C approximiert. Die Reihe für e ist definiert als die Summe der Reziproken der Fakultäten: e = 1 + 1/1! + 1/2! + 1/3! + ...

Erstellen wir zunächst ein C-Programm zur Berechnung dieser Reihenapproximation. Öffnen Sie eine neue Datei im Projektverzeichnis:

cd ~/project
nano e_approximation.c

Geben Sie nun folgenden C-Code ein:

#include <stdio.h>

double factorial(int n) {
    if (n == 0 || n == 1) return 1;
    double result = 1;
    for (int i = 2; i <= n; i++) {
        result *= i;
    }
    return result;
}

double approximate_e(int terms) {
    double e = 0;
    for (int n = 0; n < terms; n++) {
        e += 1.0 / factorial(n);
    }
    return e;
}

int main() {
    int num_terms = 10;
    double e_approximation = approximate_e(num_terms);
    printf("Approximation von e mit %d Termen: %f\n", num_terms, e_approximation);
    return 0;
}

Kompilieren und führen Sie das Programm aus:

gcc e_approximation.c -o e_approximation
./e_approximation

Beispielausgabe:

Approximation von e mit 10 Termen: 2.718282

Summieren der Terme bis zur gewünschten Genauigkeit

In diesem Schritt modifizieren wir unser vorheriges Programm, um die Approximation von e zu berechnen, indem wir Terme summieren, bis eine gewünschte Genauigkeit erreicht ist. Dieser Ansatz ermöglicht es uns, die Präzision unserer Berechnung zu steuern.

Aktualisieren wir die vorherige C-Datei:

cd ~/project
nano e_approximation.c

Ersetzen Sie den vorherigen Inhalt durch folgenden verbesserten Code:

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

double factorial(int n) {
    if (n == 0 || n == 1) return 1;
    double result = 1;
    for (int i = 2; i <= n; i++) {
        result *= i;
    }
    return result;
}

double approximate_e_with_accuracy(double desired_accuracy) {
    double e = 0;
    double term = 1;
    int n = 0;

    while (fabs(term) > desired_accuracy) {
        e += term;
        n++;
        term = 1.0 / factorial(n);
    }

    return e;
}

int main() {
    double accuracy = 1e-6;  // Gewünschte Genauigkeit
    double e_approximation = approximate_e_with_accuracy(accuracy);

    printf("Approximation von e mit Genauigkeit %e: %f\n", accuracy, e_approximation);
    printf("Standardwert von e aus math.h: %f\n", M_E);

    return 0;
}

Kompilieren und ausführen des aktualisierten Programms:

gcc e_approximation.c -o e_approximation -lm
./e_approximation

Beispielausgabe:

Approximation von e mit Genauigkeit 1.000000e-06: 2.718282
Standardwert von e aus math.h: 2.718282

Diese Version des Programms fügt weiterhin Terme zur Reihe hinzu, bis der nächste Term kleiner als die angegebene Genauigkeitsschwelle ist. Die Funktion fabs() stellt sicher, dass wir mit dem Absolutwert des Terms arbeiten.

Wichtige Punkte:

• Wir verwenden 1e-6 als gewünschte Genauigkeit.
• Das Programm bestimmt dynamisch, wie viele Terme benötigt werden.
• Wir vergleichen unsere Approximation mit dem Standardwert von e aus der math-Bibliothek.

Ausgabe der Approximation

In diesem letzten Schritt erweitern wir unser Programm, um die Approximation von e mit verschiedenen Genauigkeitsstufen auszugeben und eine detailliertere Ausgabe zu liefern.

Aktualisieren Sie die C-Datei erneut:

cd ~/project
nano e_approximation.c

Ersetzen Sie den vorherigen Inhalt durch folgenden umfassenden Code:

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

double factorial(int n) {
    if (n == 0 || n == 1) return 1;
    double result = 1;
    for (int i = 2; i <= n; i++) {
        result *= i;
    }
    return result;
}

void print_e_approximations() {
    double accuracies[] = {1e-1, 1e-3, 1e-6, 1e-9};
    int num_accuracies = sizeof(accuracies) / sizeof(accuracies[0]);

    printf("e-Approximation mit verschiedenen Genauigkeitsstufen:\n");
    printf("---------------------------------------------\n");

    for (int i = 0; i < num_accuracies; i++) {
        double e = 0;
        double term = 1;
        int n = 0;
        int terms_used = 0;

        while (fabs(term) > accuracies[i]) {
            e += term;
            n++;
            term = 1.0 / factorial(n);
            terms_used++;
        }

        printf("Genauigkeit: %e\n", accuracies[i]);
        printf("Approximation: %.10f\n", e);
        printf("Verwendete Terme: %d\n", terms_used);
        printf("Unterschied zu math.h e: %.10f\n\n", fabs(e - M_E));
    }
}

int main() {
    print_e_approximations();
    return 0;
}

Kompilieren und ausführen des Programms:

gcc e_approximation.c -o e_approximation -lm
./e_approximation

Beispielausgabe:

e-Approximation mit verschiedenen Genauigkeitsstufen:
---------------------------------------------
Genauigkeit: 1.000000e-01
Approximation: 2.7000000000
Verwendete Terme: 4
Unterschied zu math.h e: 0.0182818284

Genauigkeit: 1.000000e-03
Approximation: 2.7182500000
Verwendete Terme: 8
Unterschied zu math.h e: 0.0000318284

Genauigkeit: 1.000000e-06
Approximation: 2.7182818000
Verwendete Terme: 14
Unterschied zu math.h e: 0.0000000284

Genauigkeit: 1.000000e-09
Approximation: 2.7182818285
Verwendete Terme: 21
Unterschied zu math.h e: 0.0000000000

Verbesserungen in dieser Version:

• Ausgabe der Approximationen mit verschiedenen Genauigkeitsstufen
• Anzeige der Anzahl der verwendeten Terme für jede Approximation
• Berechnung und Anzeige des Unterschieds zum Standardwert von e aus der math-Bibliothek

Zusammenfassung

In diesem Labor haben wir gelernt, wie man die mathematische Konstante e mithilfe ihrer Reihenentwicklung in C approximiert. Zuerst haben wir eine Funktion implementiert, um die Fakultät einer Zahl zu berechnen, und dann verwendet, um die Approximation von e zu berechnen, indem wir die Terme der Reihe bis zu einer gewünschten Anzahl von Termen summieren. Anschließend haben wir das Programm modifiziert, um die Terme weiter zu summieren, bis eine gewünschte Genauigkeit erreicht ist, wodurch wir die Präzision der Berechnung steuern können. Das finale Programm gibt die Approximation von e mit der gewünschten Genauigkeit aus.