Approximation de la constante e à l'aide de sa série en C

Introduction

Dans ce laboratoire, nous explorerons comment approximer la constante mathématique e en utilisant son développement en série en C. La série pour e est définie comme la somme des réciproques des factorielles : e = 1 + 1/1! + 1/2! + 1/3! + ... Nous créerons d'abord un programme C pour calculer cette approximation de la série, puis nous le modifierons pour sommer les termes jusqu'à atteindre un niveau de précision souhaité. Cela nous permettra de contrôler la précision de notre calcul et d'obtenir une approximation plus précise de e.

Utilisation de e = ∑(1/n!)

Dans cette étape, nous allons explorer comment approximer la constante mathématique e en utilisant son développement en série en C. La série pour e est définie comme la somme des réciproques des factorielles : e = 1 + 1/1! + 1/2! + 1/3! + ...

Tout d'abord, créons un programme C pour calculer cette approximation de la série. Ouvrez un nouveau fichier dans le répertoire du projet :

cd ~/project
nano e_approximation.c

Maintenant, saisissez le code C suivant :

#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 de e avec %d termes : %f\n", num_terms, e_approximation);
    return 0;
}

Compilons et exécutons le programme :

gcc e_approximation.c -o e_approximation
./e_approximation

Exemple de sortie :

Approximation de e avec 10 termes : 2,718282

Somme des termes jusqu'à une précision souhaitée

Dans cette étape, nous allons modifier notre programme précédent pour calculer l'approximation de e en additionnant les termes jusqu'à atteindre un niveau de précision souhaité. Cette approche nous permet de contrôler la précision de notre calcul.

Mettre à jour le fichier C précédent :

cd ~/project
nano e_approximation.c

Remplacez le contenu précédent par le code amélioré suivant :

#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;  // Niveau de précision souhaité
    double e_approximation = approximate_e_with_accuracy(accuracy);

    printf("Approximation de e avec une précision de %e : %f\n", accuracy, e_approximation);
    printf("Valeur de e de la bibliothèque math.h standard : %f\n", M_E);

    return 0;
}

Compiler et exécuter le programme mis à jour :

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

Exemple de sortie :

Approximation de e avec une précision de 1.000000e-06 : 2.718282
Valeur de e de la bibliothèque math.h standard : 2.718282

Cette version du programme continue d'ajouter des termes à la série jusqu'à ce que le terme suivant soit inférieur au seuil de précision spécifié. La fonction fabs() garantit que nous travaillons avec la valeur absolue du terme.

Points importants :

• Nous utilisons 1e-6 comme niveau de précision souhaité.
• Le programme détermine dynamiquement le nombre de termes nécessaires.
• Nous comparons notre approximation à la valeur standard de e de la bibliothèque mathématique.

Affichage de l'Approximation

Dans cette dernière étape, nous allons améliorer notre programme pour afficher l'approximation de e avec différents niveaux de précision et fournir une sortie plus détaillée.

Mettre à jour le fichier C une fois de plus :

cd ~/project
nano e_approximation.c

Remplacez le contenu précédent par le code complet suivant :

#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("Approximation de e avec différents niveaux de précision :\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("Précision : %e\n", accuracies[i]);
        printf("Approximation : %.10f\n", e);
        printf("Termes utilisés : %d\n", terms_used);
        printf("Différence par rapport à la valeur de e de math.h : %.10f\n\n", fabs(e - M_E));
    }
}

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

Compiler et exécuter le programme :

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

Exemple de sortie :

Approximation de e avec différents niveaux de précision :
---------------------------------------------
Précision : 1.000000e-01
Approximation : 2.7000000000
Termes utilisés : 4
Différence par rapport à la valeur de e de math.h : 0.0182818284

Précision : 1.000000e-03
Approximation : 2.7182500000
Termes utilisés : 8
Différence par rapport à la valeur de e de math.h : 0.0000318284

Précision : 1.000000e-06
Approximation : 2.7182818000
Termes utilisés : 14
Différence par rapport à la valeur de e de math.h : 0.0000000284

Précision : 1.000000e-09
Approximation : 2.7182818285
Termes utilisés : 21
Différence par rapport à la valeur de e de math.h : 0.0000000000

Améliorations clés de cette version :

• Affiche les approximations à plusieurs niveaux de précision.
• Indique le nombre de termes utilisés pour chaque approximation.
• Calcule et affiche la différence par rapport à la valeur de e de la bibliothèque mathématique standard.

Résumé

Dans ce laboratoire, nous avons appris à approximer la constante mathématique e en utilisant son développement en série en C. Nous avons d'abord implémenté une fonction pour calculer la factorielle d'un nombre, puis nous l'avons utilisée pour calculer l'approximation de e en additionnant les termes de la série jusqu'à un nombre de termes souhaité. Nous avons ensuite modifié le programme pour continuer à additionner les termes jusqu'à ce qu'un niveau de précision souhaité soit atteint, ce qui nous permet de contrôler la précision du calcul. Le programme final affiche l'approximation de e avec la précision souhaitée.