Introduction
Dans ce laboratoire, vous apprendrez à approximer une intégrale en utilisant la règle de Simpson en C. Le laboratoire couvre le processus étape par étape de la définition de la fonction à intégrer, de l'intervalle d'intégration, puis de la mise en œuvre de l'algorithme de la règle de Simpson pour calculer l'intégrale approximative. À la fin de ce laboratoire, vous disposerez d'un programme C fonctionnel capable d'intégrer numériquement une fonction donnée sur un intervalle spécifié en utilisant la méthode de la règle de Simpson.
Le laboratoire se compose de deux étapes principales : la définition de la fonction et de l'intervalle, puis l'utilisation de la règle de Simpson avec des sous-intervalles pairs pour calculer l'intégrale approximative. Cet exercice pratique vous aidera à acquérir une expérience pratique de l'application des techniques d'intégration numérique en programmation C.
Définition de f(x) et de l'intervalle [a,b]
Dans cette étape, nous allons configurer les composants fondamentaux pour implémenter la règle de Simpson pour l'intégration numérique en C. Nous définirons la fonction à intégrer et spécifierons l'intervalle d'intégration.
Tout d'abord, créons un nouveau fichier C dans le répertoire ~/project :
cd ~/project
nano simpson_integration.c
Maintenant, écrivons le code initial pour définir notre fonction et notre intervalle :
#include <stdio.h>
#include <math.h>
// Fonction à intégrer : f(x) = x^2
double f(double x) {
return x * x;
}
int main() {
// Définition de l'intervalle d'intégration [a, b]
double a = 0.0; // Borne inférieure
double b = 1.0; // Borne supérieure
printf("Intégration de f(x) = x^2 de %f à %f\n", a, b);
return 0;
}
Décomposons le code :
- Nous incluons les en-têtes nécessaires :
stdio.hpour l'entrée/sortie etmath.hpour les fonctions mathématiques. f(x)est définie comme une fonction quadratique simple x^2, que nous allons intégrer.- Dans
main(), nous définissons l'intervalle d'intégration de 0 à 1. - Nous affichons l'intervalle pour plus de clarté.
Compilons et exécutons le code pour vérifier :
gcc simpson_integration.c -o simpson_integration -lm
./simpson_integration
Sortie exemple :
Intégration de f(x) = x^2 de 0,000000 à 1,000000
Utilisation de la règle de Simpson avec des sous-intervalles pairs
Dans cette étape, nous allons implémenter l'algorithme de la règle de Simpson pour approximer l'intégrale définie de notre fonction. Nous ajouterons la fonction d'intégration à notre programme C existant.
Ouvrez le fichier précédent :
cd ~/project
nano simpson_integration.c
Mettez à jour le code pour inclure l'implémentation de la règle de Simpson :
#include <stdio.h>
#include <math.h>
// Fonction à intégrer : f(x) = x^2
double f(double x) {
return x * x;
}
// Implémentation de la règle de Simpson
double simpsons_rule(double a, double b, int n) {
double h = (b - a) / n; // Largeur de chaque sous-intervalle
double sum = f(a) + f(b); // Premier et dernier points
// Calcul de la somme des points pairs et impairs
for (int i = 1; i < n; i++) {
double x = a + i * h;
sum += (i % 2 == 0 ? 2 : 4) * f(x);
}
return (h / 3) * sum;
}
int main() {
// Définition de l'intervalle d'intégration [a, b]
double a = 0.0; // Borne inférieure
double b = 1.0; // Borne supérieure
int n = 100; // Nombre de sous-intervalles (doit être pair)
double integral = simpsons_rule(a, b, n);
printf("Intégrale de f(x) = x^2 de %f à %f\n", a, b);
printf("Approximation à l'aide de la règle de Simpson avec %d sous-intervalles : %f\n", n, integral);
return 0;
}
Compilons et exécutons le code :
gcc simpson_integration.c -o simpson_integration -lm
./simpson_integration
Sortie exemple :
Intégrale de f(x) = x^2 de 0,000000 à 1,000000
Approximation à l'aide de la règle de Simpson avec 100 sous-intervalles : 0,333333
Décomposons l'implémentation de la règle de Simpson :
simpsons_rule()prend les bornes de l'intervalle et le nombre de sous-intervalles.hcalcule la largeur de chaque sous-intervalle.- On commence par les premier et dernier points de l'intervalle.
- La boucle ajoute les contributions pondérées des points intermédiaires.
- Les points pairs sont multipliés par 2, les points impairs par 4.
- Le résultat final est mis à l'échelle par h/3.
Affichage de l'intégrale approximative
Dans cette dernière étape, nous allons améliorer notre implémentation de la règle de Simpson en ajoutant des résultats plus détaillés et en comparant l'approximation numérique à la valeur intégrale exacte.
Ouvrez le fichier précédent :
cd ~/project
nano simpson_integration.c
Mettez à jour le code pour inclure des résultats plus complets :
#include <stdio.h>
#include <math.h>
// Fonction à intégrer : f(x) = x^2
double f(double x) {
return x * x;
}
// Calcul de l'intégrale exacte pour f(x) = x^2 de a à b
double exact_integral(double a, double b) {
return (pow(b, 3) - pow(a, 3)) / 3.0;
}
// Implémentation de la règle de Simpson
double simpsons_rule(double a, double b, int n) {
double h = (b - a) / n; // Largeur de chaque sous-intervalle
double sum = f(a) + f(b); // Premier et dernier points
// Calcul de la somme des points pairs et impairs
for (int i = 1; i < n; i++) {
double x = a + i * h;
sum += (i % 2 == 0 ? 2 : 4) * f(x);
}
return (h / 3) * sum;
}
int main() {
// Définition de l'intervalle d'intégration [a, b]
double a = 0.0; // Borne inférieure
double b = 1.0; // Borne supérieure
int n = 100; // Nombre de sous-intervalles (doit être pair)
// Calcul de l'approximation et de l'intégrale exacte
double approx_integral = simpsons_rule(a, b, n);
double exact_value = exact_integral(a, b);
double error = fabs(exact_value - approx_integral);
// Affichage des résultats détaillés
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 sous-intervalles : %d\n\n", n);
printf("Approximation (Règle de Simpson) : %.6f\n", approx_integral);
printf("Valeur exacte : %.6f\n", exact_value);
printf("Erreur absolue : %.6f\n", error);
printf("Erreur relative : %.4f%%\n", (error / exact_value) * 100);
return 0;
}
Compilons et exécutons le code :
gcc simpson_integration.c -o simpson_integration -lm
./simpson_integration
Sortie exemple :
Résultats de l'approximation de l'intégrale :
------------------------------
Fonction : f(x) = x^2
Intervalle : [0.00, 1.00]
Nombre de sous-intervalles : 100
Approximation (Règle de Simpson) : 0.333333
Valeur exacte : 0.333333
Erreur absolue : 0.000000
Erreur relative : 0.0000%
Ajouts clés de cette étape :
- Ajout de la fonction
exact_integral()pour calculer la valeur intégrale réelle. - Calcul de l'erreur absolue et relative.
- Création d'une sortie formatée affichant les résultats d'intégration détaillés.
Résumé
Dans ce laboratoire, nous avons d'abord défini la fonction à intégrer, f(x) = x^2, et l'intervalle d'intégration [a, b] = [0, 1]. Nous avons ensuite implémenté l'algorithme de la règle de Simpson pour approximer l'intégrale définie de la fonction. La règle de Simpson implique de diviser l'intervalle en un nombre pair de sous-intervalles et de calculer la somme pondérée des valeurs de la fonction aux points extrêmes et aux points médians de ces sous-intervalles. Enfin, nous afficherons la valeur approximative de l'intégrale obtenue à l'aide de la règle de Simpson.
