Approximation d'une intégrale par la méthode du trapèze en C

Introduction

Dans ce laboratoire, nous apprendrons à approximer une intégrale à l'aide de la méthode du trapèze en C. Le laboratoire couvre les étapes suivantes : 1) définir la fonction f(x) et l'intervalle [a, b], 2) diviser l'intervalle et appliquer la formule du trapèze pour calculer l'intégrale approximative, et 3) afficher le résultat final. Ce laboratoire vise à fournir une compréhension pratique des techniques d'intégration numérique en utilisant le langage de programmation C.

Définition de f(x) et de l'intervalle [a,b]

Dans cette étape, nous définirons la fonction mathématique f(x) et spécifierons l'intervalle [a,b] pour l'intégration numérique à l'aide de la méthode du trapèze en C.

Tout d'abord, créons un nouveau fichier source C pour implémenter notre approximation d'intégrale :

cd ~/project
nano integral_approximation.c

Maintenant, écrivons le code initial pour définir notre fonction et notre intervalle :

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

// Définition de la fonction à intégrer f(x)
double f(double x) {
    // Exemple : f(x) = x^2
    return x * x;
}

int main() {
    // Définition de l'intervalle [a, b]
    double a = 0.0;  // Borne inférieure
    double b = 1.0;  // Borne supérieure

    printf("Approximation de l'intégrale\n");
    printf("Fonction : f(x) = x^2\n");
    printf("Intervalle : [%.2f, %.2f]\n", a, b);

    return 0;
}

Compilons et exécutons le code pour vérifier :

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

Sortie exemple :

Approximation de l'intégrale
Fonction : f(x) = x^2
Intervalle : [0.00, 1.00]

Dans ce code, nous avons défini :

• Une fonction f(x) qui retourne x^2
• Un intervalle [a, b] allant de 0 à 1
• Affiché les détails de la fonction et de l'intervalle

La fonction f(x) peut être modifiée pour représenter n'importe quelle fonction mathématique que vous souhaitez intégrer.

Subdivision de l'intervalle et application de la formule du trapèze

Dans cette étape, nous allons modifier notre code précédent pour implémenter la méthode du trapèze pour l'intégration numérique en subdivisant l'intervalle et en calculant l'intégrale approximative.

Ouvrez le fichier source précédent et mettez à jour le code :

cd ~/project
nano integral_approximation.c

Remplacez le contenu par l'implémentation suivante :

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

// Définition de la fonction à intégrer f(x)
double f(double x) {
    return x * x;
}

// Implémentation de la méthode du trapèze
double trapezoidalRule(double a, double b, int n) {
    double h = (b - a) / n;  // Largeur de chaque trapèze
    double sum = 0.5 * (f(a) + f(b));  // Premiers et derniers points

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

    return sum * h;
}

int main() {
    // Définition de l'intervalle [a, b]
    double a = 0.0;  // Borne inférieure
    double b = 1.0;  // Borne supérieure
    int n = 100;     // Nombre de trapèzes

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

    printf("Approximation de l'intégrale\n");
    printf("Fonction : f(x) = x^2\n");
    printf("Intervalle : [%.2f, %.2f]\n", a, b);
    printf("Nombre de trapèzes : %d\n", n);
    printf("Intégrale approximative : %.6f\n", approximateIntegral);

    return 0;
}

Compilez et exécutez le code mis à jour :

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

Sortie exemple :

Approximation de l'intégrale
Fonction : f(x) = x^2
Intervalle : [0.00, 1.00]
Nombre de trapèzes : 100
Intégrale approximative : 0.333333

Points clés de cette implémentation :

• La fonction trapezoidalRule() calcule l'intégrale approximative.
• h représente la largeur de chaque trapèze.
• n détermine le nombre de trapèzes pour l'approximation.
• L'augmentation de n améliore la précision de l'approximation.

Affichage de l'intégrale approximative

Dans cette étape, nous allons améliorer notre programme d'approximation d'intégrale en ajoutant des informations de sortie plus détaillées et en comparant le résultat numérique à la valeur intégrale exacte.

Ouvrez le fichier source précédent et mettez à jour le code :

cd ~/project
nano integral_approximation.c

Modifiez le code pour inclure une sortie plus complète :

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

// Définition de la fonction à intégrer f(x)
double f(double x) {
    return x * x;
}

// Calcul de l'intégrale exacte de x^2 de 0 à 1
double exactIntegral() {
    return 1.0 / 3.0;
}

// Implémentation de la méthode du trapèze
double trapezoidalRule(double a, double b, int n) {
    double h = (b - a) / n;  // Largeur de chaque trapèze
    double sum = 0.5 * (f(a) + f(b));  // Premiers et derniers points

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

    return sum * h;
}

int main() {
    // Définition de l'intervalle [a, b]
    double a = 0.0;  // Borne inférieure
    double b = 1.0;  // Borne supérieure
    int n = 100;     // Nombre de trapèzes

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

    // Sortie formatée avec des informations détaillées
    printf("Résultats de l'approximation de l'intégrale\n");
    printf("------------------------------\n");
    printf("Fonction :            f(x) = x^2\n");
    printf("Intervalle :            [%.2f, %.2f]\n", a, b);
    printf("Nombre de trapèzes : %d\n", n);
    printf("\nRésultats numériques :\n");
    printf("Intégrale approximative : %.6f\n", approximateIntegral);
    printf("Intégrale exacte :       %.6f\n", exact);
    printf("\nAnalyse d'erreur :\n");
    printf("Erreur absolue :       %.6f\n", error);
    printf("Erreur relative :        %.4f%%\n", percentError);

    return 0;
}

Compilez et exécutez le code mis à jour :

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

Sortie exemple :

Résultats de l'approximation de l'intégrale
------------------------------
Fonction :            f(x) = x^2
Intervalle :            [0.00, 1.00]
Nombre de trapèzes : 100

Résultats numériques :
Intégrale approximative : 0.333333
Intégrale exacte :       0.333333

Analyse d'erreur :
Erreur absolue :       0.000000
Erreur relative :        0.0000%

Améliorations clés de cette version :

• Ajout de la fonction exactIntegral() pour comparer le résultat numérique.
• Calcul des erreurs absolue et relative.
• Sortie plus détaillée et formatée.

Résumé

Dans ce laboratoire, nous avons appris à approximer une intégrale à l'aide de la méthode du trapèze en C. Tout d'abord, nous avons défini la fonction mathématique f(x) et l'intervalle [a, b] pour l'intégration numérique. Ensuite, nous avons implémenté la méthode du trapèze en subdivisant l'intervalle et en appliquant la formule pour calculer l'intégrale approximative. Enfin, nous avons affiché le résultat de l'approximation de l'intégrale.

Les étapes clés de ce laboratoire étaient la définition de la fonction et de l'intervalle, la subdivision de l'intervalle et l'application de la formule du trapèze pour calculer l'intégrale approximative. En suivant ces étapes, nous avons pu implémenter une technique simple et efficace d'intégration numérique en C.