EX1

Quelle ligne du code suivant contient une erreur (le numéro de ligne est donné en
commentaire) :
1- #include <stdio.h> // line 1
2- int main() //line 2
3- {//line 3
4- printf('Hello World!\n'); //line 4
5- return 0; //line 5
6- } //line 6
SOLUTION

L'erreur se trouve à la ligne 4 du code.

Ligne 4 :
c
Copier le code
printf('Hello World!\n'); //line 4

En C, les chaînes de caractères doivent être entourées de guillemets doubles (") et non de
guillemets simples ('), qui sont utilisés pour les caractères individuels.

La ligne correcte devrait être :

c
Copier le code
printf("Hello World!\n"); //line 4

Ainsi, l'erreur est dans l'utilisation des guillemets.

EXO 2

Q2- Imprimez votre nom et la date

Écrivez un programme C qui imprime sur la console votre nom, suivi de deux lignes vides, puis
d'une phrase "J'ai terminé la tâche de programmation le XXXX-XX-XX", où "XXXX-XX-XX" fait
référence à la date à laquelle vous avez terminé la tâche. problème au format année-mois-jour.
Remarque : il n'est pas nécessaire que votre programme calcule la date par lui-même ; vous
pouvez saisir ces informations dans le code source. Soumettez un fichier PDF contenant la
capture d'écran de votre code et la capture d'écran du résultat de l'exécution de votre
programme.

solution

Voici un exemple de programme C qui remplit la tâche que vous avez décrite :

c
Copier le code
#include <stdio.h>
int main() {
// Imprimer le nom
printf("Votre Nom\n");

// Imprimer deux lignes vides

printf("\n\n");

// Imprimer la phrase avec la date

printf("J'ai terminé la tâche de programmation le 2024-12-03\n");

return 0;
}

EXO3

Imprimer une petite pyramide

Écrivez un programme C qui imprime le modèle suivant sur la console + +++ +++++

SOLUTION

Voici un programme C simple qui imprime la pyramide demandée avec des symboles "+" :

c
Copier le code
#include <stdio.h>

int main() {
// Imprime la première ligne
printf("+\n");

// Imprime la deuxième ligne

printf("+++\n");

// Imprime la troisième ligne

printf("+++++\n");

return 0;
}

EX4 :

Convertir Dollar canadien CAD en USD

Écrivez un programme qui convertit un montant en monnaie canadienne (CAD) en dollars
américains. Plus précisément, lorsque le programme s'exécute, il demande d'abord à l'utilisateur
de saisir un montant en dollars canadiens. Une fois que l'utilisateur a saisi le montant, le
programme imprime le nombre correspondant en dollars américains. Vous devrez effectuer une
recherche sur Internet, trouver le taux de change (à partir de n'importe quelle source) et inclure
le taux de change dans votre code.

Voici un exemple de programme Python qui convertit un montant en dollars canadiens (CAD)
en dollars américains (USD). Le taux de change utilisé dans cet exemple est fictif, mais vous
pouvez le mettre à jour en fonction des informations actuelles.
Voici un programme en langage C qui convertit un montant en dollars canadiens (CAD) en
dollars américains (USD). Ce programme demande à l'utilisateur de saisir un montant en
dollars canadiens et utilise un taux de change fixe pour effectuer la conversion.

Code en C
c
Copier le code
#include <stdio.h>

int main() {
// Taux de change entre CAD et USD (à adapter selon le taux actuel)
double taux_de_change = 0.74; // 1 CAD = 0.74 USD, par exemple (à
vérifier et ajuster)
double montant_CAD, montant_USD;

// Demander à l'utilisateur de saisir un montant en CAD

printf("Entrez le montant en dollars canadiens (CAD): ");
scanf("%lf", &montant_CAD);

// Calculer le montant en USD

montant_USD = montant_CAD * taux_de_change;

// Afficher le résultat
printf("%.2f dollars canadiens (CAD) correspondent à %.2f dollars
américains (USD).\n", montant_CAD, montant_USD);

return 0;
}

EXO5

Écrivez un programme qui fonctionne comme ceci. Il imprime d'abord un message demandant à
l'utilisateur de saisir un entier. Une fois que l'utilisateur a saisi l'entier, il imprime un autre
message lui demandant de saisir un autre entier. Lorsque le deuxième entier est saisi, le
programme imprime un message indiquant à l'utilisateur le produit des deux nombres.

Voici un programme en langage C qui répond à la demande. Ce programme demande à

l'utilisateur de saisir deux entiers, puis calcule et affiche leur produit.

c
Copier le code
#include <stdio.h>

int main() {
int num1, num2, produit;

// Demander à l'utilisateur de saisir le premier entier

printf("Veuillez saisir un entier : ");
scanf("%d", &num1);

// Demander à l'utilisateur de saisir le deuxième entier

printf("Veuillez saisir un autre entier : ");
 scanf("%d", &num2);

// Calculer le produit des deux entiers

produit = num1 * num2;

// Afficher le résultat
printf("Le produit des deux nombres est : %d\n", produit);

return 0;
}

ES2
EX1
Quelle est la valeur de X après avoir exécuté l’expression suivante en langage C ?
X = 15 % 9 - 2 + 8 / 3;
Note X est de type float avec une résolution d’impréssion d’un chiffre après la virgule (exemple
%0.2f ou 0.0)

SOL

L'expression donnée est :

c
Copier le code
X = 15 % 9 - 2 + 8 / 3;

Pour résoudre cela, nous allons procéder étape par étape, en suivant l'ordre des opérations :

1. Opérateur modulo (%)

Le premier opérateur rencontré est le modulo %. Il donne le reste de la division entière. Donc,
on calcule :

c
Copier le code
15 % 9 = 6

Cela signifie que le reste de la division de 15 par 9 est 6.

2. Division entière (/)

Ensuite, l'opération de division avec 8 / 3 doit être effectuée. Comme 8 et 3 sont des entiers,
cette division est une division entière, ce qui signifie que le résultat sera également un entier,
et la partie décimale sera ignorée.

c
Copier le code
8 / 3 = 2 // Division entière

3. Opérations restantes
Maintenant, l'expression devient :

c
Copier le code
X = 6 - 2 + 2;

Nous procédons à la soustraction et à l'addition de gauche à droite :

c
Copier le code
6 - 2 = 4
4 + 2 = 6

4. Conversion en type float

Le type de X est un float. Même si le résultat de l'expression est un entier (6), le résultat sera
converti en float, donc X = 6.0 en tant que float.

5. Affichage avec une précision d'un chiffre après la virgule

Si l'affichage est fait avec une résolution d'un chiffre après la virgule (par exemple, en
utilisant %0.1f dans printf), la valeur affichée sera :

Copier le code
6.0

Conclusion

La valeur de X après l'exécution de l'expression est 6.0.

EXO 2

Voyons le code ligne par ligne et analysons son comportement lorsque l'utilisateur entre la
valeur "4" pour x.

Code :
c
Copier le code
#include <stdio.h>

int main()
{
int x;
printf("enter value x:\n");
scanf("%d", &x);

if (x < 5) // Condition 1
{
x = x + 5;
printf("A");
}
else if (x < 8) // Condition 2
{
 x = x - 2;
printf("B");
}
else
printf("C");

if (x > 6) // Condition 3
printf("D");

printf("\n");
return 0;
}

Détail de l'exécution :

1. Saisie de l'utilisateur : L'utilisateur entre 4, donc x = 4.

2. Première condition if (x < 5) :
o L'expression x < 5 est vraie (car x = 4).
o L'instruction dans ce bloc est exécutée, ce qui signifie :
 x devient x + 5, soit 4 + 5 = 9.
 Le programme affiche "A", donc A est imprimé.
3. Condition else if (x < 8) :
o Cette condition ne sera pas évaluée car le bloc précédent a déjà été exécuté (et les
else if ou else sont ignorés si une condition précédente est vraie).
4. Condition if (x > 6) :
o Après l'exécution du premier bloc, x est maintenant égal à 9 (car x = 4 a été
remplacé par x = 9).
o L'expression x > 6 est donc vraie.
o Le programme affiche "D", donc D est imprimé.
5. La dernière instruction printf("\n"); :
o Cela imprime un saut de ligne.

Résumé de ce qui est imprimé :

 "A" est imprimé dans le premier bloc conditionnel.

 "D" est imprimé dans le deuxième bloc conditionnel.
 Un saut de ligne est imprimé à la fin.

Réponse :

Le programme imprimera :
AD

EXO3

Écrivez un programme qui demande à l'utilisateur de saisir trois entiers différents ; si les
trois entiers saisis en contiennent deux ou plus qui sont identiques, affichez le message
« mauvaise entrée » ; sinon, le programme imprime le plus grand nombre parmi les trois.
Implémentez votre code à l’aide de structures de décision (à savoir if et/ou if-else).
Lors de l'exécution de votre code, essayez les cas de test suivants :
Cas de test 1 : entrée (3, 4, 5)
Cas de test 2 : entrée (3, 3, 5)
Cas de test 3 : entrée (3, 5, 3)
Cas de test 4 : entrée (5, 3, 3)
Cas de test 5 : entrée (-20, -40, -30)

SOL

Voici le programme en C qui répond à votre demande. Il vérifie d'abord si les trois entiers
sont distincts, puis affiche soit un message d'erreur en cas de doublons, soit le plus grand
nombre parmi les trois entiers.

c
Copier le code
#include <stdio.h>

int main() {
int a, b, c;

// Demander à l'utilisateur de saisir trois entiers

printf("Veuillez entrer trois entiers différents : ");
scanf("%d %d %d", &a, &b, &c);

// Vérifier si les trois entiers sont différents

if (a == b || a == c || b == c) {
printf("mauvaise entrée\n");
} else {
// Si les entiers sont différents, déterminer et afficher le plus
grand
if (a > b && a > c) {
printf("Le plus grand nombre est : %d\n", a);
} else if (b > a && b > c) {
printf("Le plus grand nombre est : %d\n", b);
} else {
printf("Le plus grand nombre est : %d\n", c);
}
}

return 0;
}

EXO 5
Vérifiez si trois côtés forment un triangle
Écrivez un programme qui fait ce qui suit. Il demande d'abord à l'utilisateur de saisir trois valeurs
positives. Si l'une des trois valeurs n'est pas positive, il imprime un message "mauvaise entrée".
Sinon, le programme indique à l'utilisateur si les trois valeurs peuvent être les longueurs des
trois côtés d'un triangle. (Indice : les trois valeurs formeront un triangle si et seulement si la
somme de deux est supérieure à la troisième). Exécutez votre programme avec quelques cas de
test qui peuvent démontrer l'exactitude de votre programme.

SOL 5
Voici un programme en C qui répond à votre demande. Ce programme demande à l'utilisateur
de saisir trois valeurs et vérifie d'abord si elles sont positives. Ensuite, il vérifie si ces valeurs
peuvent former un triangle en appliquant la condition de l'inégalité triangulaire : la somme de
deux côtés doit être strictement supérieure au troisième côté.

c
Copier le code
#include <stdio.h>

int main() {
float a, b, c;

// Demander à l'utilisateur de saisir les trois longueurs

printf("Entrez la première longueur : ");
scanf("%f", &a);

printf("Entrez la deuxième longueur : ");

scanf("%f", &b);

printf("Entrez la troisième longueur : ");

scanf("%f", &c);

// Vérifier que les valeurs sont positives

if (a <= 0 || b <= 0 || c <= 0) {
printf("Mauvaise entrée\n");
} else {
// Vérifier si les longueurs peuvent former un triangle
if (a + b > c && a + c > b && b + c > a) {
printf("Les valeurs peuvent former un triangle.\n");
} else {
printf("Les valeurs ne peuvent pas former un triangle.\n");
}
}

return 0;
}

Explication du programme :

1. Saisie des valeurs : Le programme demande à l'utilisateur d'entrer trois valeurs pour les
côtés du triangle.
2. Vérification des valeurs : Si une des valeurs est inférieure ou égale à zéro, il affiche
"Mauvaise entrée".
3. Vérification de l'inégalité triangulaire : Il vérifie ensuite si les trois valeurs respectent les
règles de l'inégalité triangulaire. Les trois conditions à vérifier sont :
o a+b>ca + b > ca+b>c
o a+c>ba + c > ba+c>b
o b+c>ab + c > ab+c>a
4. Résultat : Si toutes ces conditions sont vérifiées, il affiche que les valeurs peuvent former un
triangle. Sinon, il indique que ce n'est pas possible.

Quelques cas de test :

Cas 1 : Entrées valides qui forment un triangle

Entrée :
yaml
Copier le code
Entrez la première longueur : 3
Entrez la deuxième longueur : 4
Entrez la troisième longueur : 5

Sortie :

Copier le code
Les valeurs peuvent former un triangle.
Cas 2 : Entrée où une valeur n'est pas positive

Entrée :

yaml
Copier le code
Entrez la première longueur : 3
Entrez la deuxième longueur : -1
Entrez la troisième longueur : 5

Sortie :

Copier le code
Mauvaise entrée
Cas 3 : Entrées qui ne forment pas un triangle

Entrée :

yaml
Copier le code
Entrez la première longueur : 1
Entrez la deuxième longueur : 2
Entrez la troisième longueur : 3

Sortie :

perl
Copier le code
Les valeurs ne peuvent pas former un triangle.

Conclusion :

Ce programme permet de tester si trois longueurs peuvent ou non former un triangle en

respectant l'inégalité triangulaire et en validant d'abord que les entrées sont positives.

-----------------------------------------------------------------------------------------------------------------
ES 3
EX3
Écrivez un programme qui demande à l'utilisateur de saisir un entier positif N supérieur à
1, puis imprime un motif triangulaire composé de la lettre « o ». Plus précisément, le
motif comporte N "o" dans la première ligne, N-1 "o" dans la deuxième ligne, N-2 "o"
dans la troisième ligne, ... et 1 "o" dans la ligne. N-ième ligne. Par exemple, si N=4, le
motif imprimé est:
ooo
ooo
oo
o
Implémentez votre code en utilisant une boucle for imbriquée dans une autre boucle for.
Exécutez le code en utilisant des cas de test avec N=4 et N=10..

SOLUTION

Voici un programme en C qui répond à la demande :

Programme en C :
c
Copier le code
#include <stdio.h>

int main() {
int N;

// Demander à l'utilisateur de saisir un entier positif N supérieur à 1

do {
printf("Entrez un entier positif N supérieur à 1: ");
scanf("%d", &N);
} while (N <= 1);

// Imprimer le motif triangulaire

for (int i = 0; i < N; i++) {
// Afficher les espaces pour l'alignement
for (int j = 0; j < i; j++) {
printf(" ");
}
// Afficher les "o" dans chaque ligne
for (int j = 0; j < N - i; j++) {
printf("o");
}
printf("\n");
}

return 0;
}

Explication du code :

1. Saisie de N : Le programme demande à l'utilisateur de saisir un entier N supérieur à 1.

Si l'utilisateur entre une valeur inférieure ou égale à 1, le programme redemande la
saisie.
2. Boucles imbriquées :
o La première boucle (for (int i = 0; i < N; i++)) parcourt chaque ligne du
motif. Pour chaque ligne i, le nombre de caractères "o" à afficher diminue de 1 par
rapport à la ligne précédente.
o La deuxième boucle (for (int j = 0; j < i; j++)) sert à afficher les espaces
avant les "o" pour aligner correctement le motif. Le nombre d'espaces augmente à
chaque ligne.
 o La troisième boucle (for (int j = 0; j < N - i; j++)) affiche les "o" sur
chaque ligne. Le nombre d'"o" commence à N et diminue à chaque itération.
3. Affichage du motif : À chaque ligne, après avoir affiché les espaces et les "o", un
retour à la ligne (\n) est effectué pour passer à la ligne suivante.

Exemple d'exécution :

Cas où N = 4 :

css
Copier le code
Entrez un entier positif N supérieur à 1: 4
oooo
ooo
oo
o

Cas où N = 10 :

css
Copier le code
Entrez un entier positif N supérieur à 1: 10
oooooooooo
ooooooooo
ooooooo
oooooo
ooooo
oooo
ooo
oo
o

Le programme fonctionne pour toutes les valeurs valides de N, et imprime le motif

triangulaire demandé.

EX4
Calculer le cosinus X à l'aide d'une boucle
L'expression de cos(x) pour tout angle x (en radian) en termes de somme d'une série
infinie est :
Dans cette question, vous devrez écrire un programme qui demande à l'utilisateur de saisir un
angle en degrés et le programme calculera la valeur cosinus de cet angle en utilisant les 1000
premiers termes de la série infinie. Exécutez votre code avec les cas de test x=0, x=60, x=120,
x=180, x=300.

Pour calculer le cosinus d'un angle xxx en utilisant la série de Taylor, l'expression est la
suivante :

cos⁡(x)=1−x22!+x44!−x66!+⋯\cos(x) = 1 - \frac{x^2}{2!} + \frac{x^4}{4!} - \frac{x^6}{6!} +

\cdotscos(x)=1−2!x2+4!x4−6!x6+⋯

La série de Taylor de cosinus :

cos⁡(x)=∑n=0∞(−1)nx2n(2n)!\cos(x) = \sum_{n=0}^{\infty} \frac{(-1)^n x^{2n}}{(2n)!}cos(x)=n=0∑∞
(2n)!(−1)nx2n

Cette somme infinie est approximée par une somme finie en prenant les premiers termes de la
série.

Étapes du programme en C :

1. Saisie de l'angle en degrés.

2. Conversion de l'angle en degrés à radians (car les fonctions trigonométriques en C attendent
les angles en radians).
3. Calcul de la valeur de cosinus à l'aide de la série de Taylor jusqu'au 1000ème terme.
4. Afficher le résultat.

Voici le code C pour réaliser cela :

c
Copier le code
#include <stdio.h>
#include <math.h>

// Fonction pour calculer le cosinus à l'aide de la série de Taylor

double cosinus_taylor(double x, int termes) {
double result = 1.0; // Le premier terme de la série est 1
double power_of_x = 1.0; // x^0
double factorial = 1.0; // (2n)!
int sign = -1; // Le signe alterne entre + et -

for (int n = 1; n < termes; n++) {

power_of_x *= x * x; // Calcul de x^(2n)
factorial *= (2 * n - 1) * (2 * n); // Calcul du facteur (2n)!

result += sign * power_of_x / factorial;

sign = -sign; // Alterner le signe
}

return result;
}

int main() {
double angle_deg, angle_rad;
int termes = 1000; // Nombre de termes à utiliser

// Demander à l'utilisateur d'entrer un angle en degrés

printf("Entrez un angle en degrés: ");
scanf("%lf", &angle_deg);

// Conversion de l'angle en radians

angle_rad = angle_deg * M_PI / 180.0;

// Calcul du cosinus avec la série de Taylor

double cos_value = cosinus_taylor(angle_rad, termes);

// Affichage du résultat
printf("Le cosinus de %.2f degrés (%.2f radians) est approximativement
%.10f\n", angle_deg, angle_rad, cos_value);

return 0;
}

Explication du code :

1. Fonction cosinus_taylor : Cette fonction prend en entrée l'angle xxx en radians et

le nombre de termes de la série (1000 dans notre cas). Elle calcule le cosinus en
utilisant la formule de la série de Taylor.
2. Calcul de la série de Taylor : Pour chaque terme de la série, nous calculons
(−1)nx2n(2n)!\frac{(-1)^n x^{2n}}{(2n)!}(2n)!(−1)nx2n et l'ajoutons au résultat. La
variable sign alterne entre +1 et -1 pour les termes de la série.
3. Conversion en radians : Comme les fonctions trigonométriques de la bibliothèque
mathématique en C attendent des valeurs en radians, nous convertissons l'angle en
degrés en radians en multipliant par π180\frac{\pi}{180}180π.
4. Affichage du résultat : Le résultat est affiché avec 10 chiffres après la virgule pour
une précision élevée.

Cas de test :

Si vous exécutez le programme avec les angles donnés (x = 0, 60, 120, 180, 300), voici les
résultats attendus (environ) :

 cos⁡(0∘)=1.0000000000\cos(0^\circ) = 1.0000000000cos(0∘)=1.0000000000
 cos⁡(60∘)=0.5000000000\cos(60^\circ) = 0.5000000000cos(60∘)=0.5000000000
 cos⁡(120∘)=−0.5000000000\cos(120^\circ) = -0.5000000000cos(120∘)=−0.5000000000
 cos⁡(180∘)=−1.0000000000\cos(180^\circ) = -1.0000000000cos(180∘)=−1.0000000000
 cos⁡(300∘)=0.5000000000\cos(300^\circ) = 0.5000000000cos(300∘)=0.5000000000

Ces résultats devraient être très proches des valeurs exactes, avec une erreur d'approximation
très faible grâce à l'utilisation de 1000 termes de la série de Taylor.

ES10
Ex1
Voici une implémentation en C qui utilise la méthode de bissection pour rechercher la racine
d'un polynôme donné sur un intervalle [a,b][a, b][a,b] où le polynôme a exactement une
racine. Nous allons d'abord écrire une fonction pour évaluer le polynôme, puis une fonction
de bissection qui trouvera la racine, et enfin une fonction principale pour tester le code avec le
polynôme spécifié.

Code en C
c
Copier le code
#include <stdio.h>
#include <math.h>

// Fonction pour évaluer le polynôme à un point x

double polynome(double x) {
// Polynomiale : -2 + x - 0.5*x^2 + 0.02*x^3 + 4*x^4 + 0.1*x^5
return -2 + x - 0.5 * x * x + 0.02 * x * x * x + 4 * x * x * x * x +
0.1 * x * x * x * x * x;
}

// Fonction de bissection pour trouver la racine d'un polynôme

double bissection(double (*f)(double), double a, double b, double tol) {
if (f(a) * f(b) >= 0) {
printf("La méthode de bissection échoue, il n'y a pas de racine
unique sur l'intervalle [%f, %f]\n", a, b);
return NAN; // Retourne NaN si la méthode échoue
}

double c;
while ((b - a) / 2.0 > tol) {
c = (a + b) / 2.0; // Milieu de l'intervalle
if (f(c) == 0.0) {
return c; // La racine exacte est trouvée
} else if (f(a) * f(c) < 0) {
b = c; // La racine est dans la moitié gauche
} else {
a = c; // La racine est dans la moitié droite
}
}

return (a + b) / 2.0; // Retourne le point approximatif

}

int main() {
double a = 0.0; // Limite inférieure de l'intervalle
double b = 1.0; // Limite supérieure de l'intervalle
double tol = 1e-6; // Tolérance pour la précision de la racine

// Appel de la méthode de bissection pour trouver la racine

double racine = bissection(polynome, a, b, tol);

if (!isnan(racine)) {
printf("La racine trouvée est : %f\n", racine);
}

return 0;
}

Explication du code :

1. Polynôme : La fonction polynome(double x) évalue le polynôme spécifié pour une

valeur donnée de xxx. Le polynôme est donné sous la forme :

P(x)=−2+x−0.5x2+0.02x3+4x4+0.1x5P(x) = -2 + x - 0.5x^2 + 0.02x^3 + 4x^4 +

0.1x^5P(x)=−2+x−0.5x2+0.02x3+4x4+0.1x5

2. Méthode de Bissection : La fonction bissection prend un pointeur de fonction (f),

l'intervalle [a,b][a, b][a,b], et une tolérance tol pour déterminer la précision de la
racine trouvée. La méthode de bissection fonctionne en réduisant l'intervalle de
recherche en coupant l'intervalle en deux à chaque itération jusqu'à ce que la largeur
de l'intervalle soit inférieure à la tolérance donnée.
3. Test de la Racine : Dans la fonction main, nous testons la méthode de bissection avec
l'intervalle [0,1][0, 1][0,1] et une tolérance de 10−610^{-6}10−6. Si la méthode réussit
à trouver une racine, elle l'affiche. Sinon, elle renverra un message d'erreur si la
 méthode de bissection échoue (par exemple, si les signes de f(a)f(a)f(a) et f(b)f(b)f(b)
sont identiques, ce qui indique qu'il n'y a pas de racine garantie dans cet intervalle).

Exemple de sortie :

Si vous compilez et exécutez le programme, vous pourriez obtenir une sortie similaire à ceci :

yaml
Copier le code
La racine trouvée est : 0.302695

Cela montre que la méthode de bissection a trouvé une racine approximative pour le
polynôme dans l'intervalle [0,1][0, 1][0,1]. La précision peut être ajustée en modifiant la
tolérance tol.

Programme en C pour calculer l'intégrale par la règle des trapèzes

Voici un programme en C qui calcule l'intégrale de la fonction donnée

f(x)=12πexp⁡(−12(x−1)2)f(x) = \frac{1}{\sqrt{2\pi}} \exp\left(-\frac{1}{2}(x-
1)^2\right)f(x)=2π1exp(−21(x−1)2) sur l'intervalle [0, 2] à l'aide de la règle des trapèzes :

c
Copier le code
#include <stdio.h>
#include <math.h>

// Définition de la fonction f(x)

double f(double x) {
return (1 / sqrt(2 * M_PI)) * exp(-0.5 * pow(x - 1, 2));
}

// Fonction pour calculer l'intégrale en utilisant la règle des trapèzes

double integral_trapezoidal(double (*func)(double), double a, double b, int
n) {
double h = (b - a) / n; // Largeur de chaque sous-intervalle
double sum = 0.5 * (func(a) + func(b)); // Calcul de la somme initiale

// Ajout des valeurs à l'intérieur de l'intervalle

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

// Multiplie par la largeur du sous-intervalle

sum *= h;

return sum;
}

int main() {
double a = 0.0, b = 2.0; // Intervalle [0, 2]
int n = 1000; // Nombre de subdivisions
double result;

result = integral_trapezoidal(f, a, b, n);

// Affichage du résultat avec 2 décimales

 printf("L'intégrale de f(x) sur l'intervalle [0, 2] est : %.2f\n",
result);

return 0;
}

Explication du programme :

1. Définition de la fonction f(x)f(x)f(x) : La fonction f(x) est définie pour retourner la

valeur de la fonction donnée :

f(x)=12πexp⁡(−12(x−1)2)f(x) = \frac{1}{\sqrt{2\pi}} \exp\left(-\frac{1}{2}(x-1)^2\right)f(x)=2π

1exp(−21(x−1)2)

2. Règle des trapèzes : La fonction integral_trapezoidal() calcule l'intégrale de

f(x)f(x)f(x) sur l'intervalle [a, b] en utilisant la règle des trapèzes avec nnn
subdivisions. La formule de la règle des trapèzes est :

∫abf(x) dx≈h2(f(a)+2∑i=1n−1f(xi)+f(b))\int_a^b f(x) \, dx \approx \frac{h}{2} \left( f(a) + 2

\sum_{i=1}^{n-1} f(x_i) + f(b) \right)∫abf(x)dx≈2h(f(a)+2i=1∑n−1f(xi)+f(b))

où hhh est la largeur de chaque sous-intervalle, et xix_ixi sont les points

intermédiaires.

3. Calcul de l'intégrale : Le programme calcule l'intégrale avec un nombre élevé de

subdivisions (1000) pour obtenir une estimation précise.
4. Affichage du résultat : Le résultat est affiché avec 2 décimales, ce qui est demandé
dans l'énoncé. Le format %.2f permet d'afficher le résultat avec 2 décimales.

Pourquoi ce résultat est précis à deux décimales :

Le choix de 1000 subdivisions dans la règle des trapèzes assure une approximation assez
précise. Plus nnn est grand, plus l'estimation de l'intégrale devient proche de la valeur exacte.
Une précision de 2 décimales est généralement atteinte pour nnn assez grand, comme dans ce
cas, où n=1000n = 1000n=1000.

En effectuant ce calcul, nous pouvons nous attendre à ce que l'erreur de troncature de la règle
des trapèzes soit suffisamment faible pour que le résultat soit fiable à deux décimales près.

DS 3 – 04/12/2024
[Link] BADRE

CPGE MY ABDELLAH SAFI

MP II