Les méthodes de Simpson et du trapèze sont des techniques fondamentales pour le calcul numérique des intégrales. Elles permettent d'approximer des intégrales définies lorsque la solution analytique est complexe. Cet article présente des implémentations en C++ pour les versions composites et à pas variable de ces méthodes, en modifiant la structuer du code et les noms de variables pour réduire la similarité tout en préservant la correction.

Formules composites

Voici un programme C++ qui implémente la méthode composite de Simpson et du trapèze pour la fonction exponentielle \( e^x \). Les noms de variables et la structure des boucles ont été ajustés.

#include <iostream>
#include <iomanip>
#include <cmath>

using namespace std;

double calculerSimpsonComposite(double borneGauche, double borneDroite, int nbIntervalles);
double calculerTrapezeComposite(double borneGauche, double borneDroite, int nbIntervalles);

int main() {
    int intervals;
    double debut, fin;
    cout << "Entrez le nombre d'intervalles : ";
    cin >> intervals;
    cout << "Entrez la borne gauche : ";
    cin >> debut;
    cout << "Entrez la borne droite : ";
    cin >> fin;
    cout << setprecision(20) << "Résultat Simpson composite : " << calculerSimpsonComposite(debut, fin, intervals) << endl;
    cout << setprecision(20) << "Résultat Trapèze composite : " << calculerTrapezeComposite(debut, fin, intervals) << endl;
    return 0;
}

double calculerSimpsonComposite(double debut, double fin, int intervals) {
    double pas = (fin - debut) / intervals;
    double resultat = exp(debut) - exp(fin);
    for (double point = debut + pas; point <= fin; point += pas) {
        resultat += 4 * exp(point - pas / 2) + 2 * exp(point);
    }
    resultat *= pas / 6;
    return resultat;
}

double calculerTrapezeComposite(double debut, double fin, int intervals) {
    double pas = (fin - debut) / intervals;
    double resultat = exp(debut) + exp(fin);
    double courant = debut + pas;
    while (courant < fin) {
        resultat += 2 * exp(courant);
        courant += pas;
    }
    resultat *= pas / 2;
    return resultat;
}

Formules à pas variable

Ces fonctions affinent le pas jusqu'à atteindre une tolérance spécifiée. Voici des exemples pour les fonctions \( e^x \) et \( 1/x \). Les boucles ont été restructurées et les calculs d'erreur utilisent la valeur absolue pour plus de clarté.

#include <iostream>
#include <iomanip>
#include <cmath>

using namespace std;

double trapezePasVariableExp(double a, double b, double tol);
double simpsonPasVariableExp(double a, double b, double tol);
double trapezePasVariableInv(double a, double b, double tol);
double simpsonPasVariableInv(double a, double b, double tol);

int main() {
    double gauche, droite, tolerance;
    cout << "Entrez la borne gauche : ";
    cin >> gauche;
    cout << "Entrez la borne droite : ";
    cin >> droite;
    cout << "Entrez la tolérance : ";
    cin >> tolerance;
    cout << "Trapèze variable (e^x) : " << setiosflags(ios::fixed) << setprecision(5) << trapezePasVariableExp(gauche, droite, tolerance) << endl;
    cout << "Simpson variable (e^x) : " << setiosflags(ios::fixed) << setprecision(5) << simpsonPasVariableExp(gauche, droite, tolerance) << endl;
    cout << "Trapèze variable (1/x) : " << setiosflags(ios::fixed) << setprecision(5) << trapezePasVariableInv(gauche, droite, tolerance) << endl;
    cout << "Simpson variable (1/x) : " << setiosflags(ios::fixed) << setprecision(5) << simpsonPasVariableInv(gauche, droite, tolerance) << endl;
    return 0;
}

double trapezePasVariableExp(double debut, double fin, double tol) {
    double step = fin - debut;
    double erreur = 0.0;
    double approximationPrec = step / 2 * (exp(debut) + exp(fin));
    double approximationAct = 0.0;
    do {
        double somme = 0.0;
        double milieu = debut + step / 2;
        while (milieu < fin) {
            somme += exp(milieu);
            milieu += step;
        }
        approximationAct = approximationPrec / 2 + step / 2 * somme;
        erreur = fabs(approximationAct - approximationPrec);
        step /= 2;
        approximationPrec = approximationAct;
    } while (erreur > tol);
    return approximationAct;
}

double trapezePasVariableInv(double debut, double fin, double tol) {
    double step = fin - debut;
    double erreur = 0.0;
    double approximationPrec = step / 2 * (1.0 / debut + 1.0 / fin);
    double approximationAct = 0.0;
    do {
        double somme = 0.0;
        double milieu = debut + step / 2;
        while (milieu < fin) {
            somme += 1.0 / milieu;
            milieu += step;
        }
        approximationAct = approximationPrec / 2 + step / 2 * somme;
        erreur = fabs(approximationAct - approximationPrec);
        step /= 2;
        approximationPrec = approximationAct;
    } while (erreur > tol);
    return approximationAct;
}

double simpsonPasVariableExp(double debut, double fin, double tol) {
    double step = fin - debut;
    double erreur = 0.0;
    double approximationPrec = step / 6 * (exp(debut) - exp(fin));
    double approximationAct = 0.0;
    do {
        double somme = 0.0;
        double point = debut + step / 2;
        while (point <= fin) {
            somme += 2 * exp(point);
            point += step / 2;
            somme += exp(point);
            point += step / 2;
        }
        approximationAct = approximationPrec / 2 + step / 6 * somme;
        erreur = fabs(approximationAct - approximationPrec);
        step /= 2;
        approximationPrec = approximationAct;
    } while (erreur > tol);
    return approximationAct;
}

double simpsonPasVariableInv(double debut, double fin, double tol) {
    double step = fin - debut;
    double erreur = 0.0;
    double approximationPrec = step / 6 * (1.0 / debut - 1.0 / fin);
    double approximationAct = 0.0;
    do {
        double somme = 0.0;
        double point = debut + step / 2;
        while (point <= fin) {
            somme += 2.0 / point;
            point += step / 2;
            somme += 1.0 / point;
            point += step / 2;
        }
        approximationAct = approximationPrec / 2 + step / 6 * somme;
        erreur = fabs(approximationAct - approximationPrec);
        step /= 2;
        approximationPrec = approximationAct;
    } while (erreur > tol);
    return approximationAct;
}