Calcul des aires – Bac pratique – Section informatique – 2013
Sujet (Algo et programmation - Bac 2012)
On considère la fonction continue, f définie dans IR par f(x) = x2.
On veut comparer la méthodes des trapèzes et celle des rectangles dans le calcul approximatif de l'aire A, donné par la formule :
et de chercher, dans l'intervalle [0, 3], laquelle des deux méthodes qui converge la première vers l'aire exacte a epsilon près, tout en variant N qui est le nombre de subdivisions de l'intervalle [0, 3], sachant que l'aire exacte est égale a 9.
Travail demande
Ecrire un programme Pascal intitule Aires qui permet :
- de stocker dans un fichier d'enregistrements "Caleul.dat", pour chaque nombre de subdivisions, le nombre lui-même, l'aire trouvée par la méthode des rectangles et l'aire trouvée par la méthode des trapèzes.
N.B.: Le traitement s'arrête lorsque l'aire calculée par l'une des deux méthodes converge vers l'aire exacte a epsilon près (avec 10-3 < epsilon < 10-1), d'afficher le contenu du fichier "CalcuLdat", la méthode qui converge la première vers l'aire exacte a epsilon près, le nombre de subdivisions et l'aire calculée correspondants.
Solution Algorithmique
Dans cet algorithme, On va utiliser quatre fonctions et une procédure:
- la fonction f()
- la fonction aire_rectangles()
- la fonction aire_trapezes()
- la fonction saisie_epsilon()
- la procédure remplir_fichier_calcul()
Algorithme du programme Principal
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Algorithme calcul_aires Debut # Bornes de l’intervalle a <- 0 b <- 3 # Aire exacte de l’intégrale aire_exacte <- 9 # Saisie de epsilon epsilon <- saisie_epsilon() # Remplissage du fichier et comparaison des méthodes remplir_fichier_calcul(epsilon) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| a | entier |
| b | entier |
| aire_exacte | entier |
| epsilon | réel |
La fonction carre
Cette fonction carre(x) a pour rôle de calculer et retourner le carré d’un nombre réel x.
Elle prend un nombre x en paramètre, effectue le calcul x×x, puis renvoie le résultat.
|
1 2 3 4 |
Fonction carre(x:entier):entier # Retourne le carré de x retourner x*x Fin |
La fonction aire_rectangles
Ce programme définit une fonction aire_rectangles qui calcule une approximation de l’aire sous la courbe d’une fonction à l’aide de la méthode des rectangles.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
Fonction aire_rectangles(a:entier, b:entier, n:entier):reel # Largeur de chaque subdivision h <- (b - a) / n # Somme des aires des rectangles s <- 0 # Abscisse de départ x <- a # Calcul de la somme des carre(x) aux points gauches Pour de i de 0 à n-1 faire s <- s + carre(x) x <- x + h Fin pour # Aire approximative retourner s * h Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| h | réel |
| s | entier |
| x | réel |
La fonction aire_trapezes
Ce programme définit une fonction aire_trapezes qui calcule une approximation de l’aire sous la courbe d’une fonction à l’aide de la méthode des trapèzes. Cette méthode est plus précise que celle des rectangles car elle prend en compte la pente entre les points consécutifs.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
Fonction aire_trapezes(a:entier, b:entier, n:entier):reel # Largeur de chaque subdivision h <- (b - a) / n # Somme initiale avec les bornes s <- (carre(a) + carre(b)) / 2 # Premier point intérieur x <- a + h # Ajout des valeurs intermédiaires Pour i de 1 à n-1 faire s = s + carre(x) x = x + h Fin pour # Aire approximative retourner s * h Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| h | réel |
| s | entier |
| x | réel |
La fonction saisie_epsilon
Cette fonction permet de saisir un entier strictement positif au clavier.
Plus précisément :
Elle demande à l’utilisateur de saisir un nombre entier.
Elle vérifie la validité de la saisie en s’assurant que le nombre est strictement supérieur à 0.
Tant que la valeur saisie est nulle ou négative, la fonction redemande la saisie.
Une fois une valeur correcte saisie, la fonction la retourne pour être utilisée dans la suite du programme.
|
1 2 3 4 5 6 7 8 9 10 |
Fonction saisie_epsilon(): reel Ecrire("Donner epsilon tel que 0.001 < epsilon < 0.1 : ") Lire(epsilon) # Répéter la saisie tant que epsilon est invalide Tant que non (0.001 < epsilon < 0.1) faire Ecrire("Donner epsilon tel que 0.001 < epsilon < 0.1 : ") Lire(epsilon) Fin tant que retourner epsilon Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| epsilon | réel |
La procédure remplir_fichier_calcul
La procédure remplir_fichier_circul(p, q) a pour rôle est de déterminer et enregistrer tous les nombres premiers circulaires compris entre deux entiers p et q.
Plus précisément, cette procédure :
- affiche un message indiquant le début du remplissage
- ouvre le fichier Circul.dat en mode écriture
- parcourt tous les entiers de p à q (bornes incluses)
- teste pour chaque entier s’il est premier circulaire à l’aide de la fonction test_circulaire()
- affiche chaque nombre premier circulaire trouvé
- écrit chaque nombre premier circulaire dans le fichier, un nombre par ligne
- ferme le fichier après la fin du traitement
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 |
Procédure remplir_fichier_calcul(epsilon:entier) # Ouverture du fichier en mode écriture Ouvrir(f , "Calcul.dat", "w") Ecrire('****************************************') # Initialisation du nombre de subdivisions n <- 1 # Calcul initial des aires aire_rect <- aire_rectangles(a, b, n) aire_trap <- aire_trapezes(a, b, n) # Tant qu’aucune des deux méthodes n’a convergé Tant que (abs(aire_rect - aire_exacte) > epsilon) et (abs(aire_trap - aire_exacte) > epsilon) faire # Calcul des aires pour le nombre courant de subdivisions aire_rect <- aire_rectangles(a, b, n) aire_trap <- aire_trapezes(a, b, n) # Affichage des résultats Ecrire(n + ", aire rectangulaire: " + aire_rect + ", aire trapeze: " + aire_trap) # Stockage dans le fichier Ecrire(f , n + ", aire rectangulaire: " + aire_rect + ", aire trapeze: " + aire_trap + "\n") # Passage au nombre de subdivisions suivant n <- n + 1 Fin tant que Ecrire('****************************************') # Détermination de la méthode qui converge la première Si abs(aire_rect - aire_exacte) <= epsilon alors Ecrire("La méthode qui converge la première est la méthode des rectangles") Ecrire("Nombre de subdivisions =", n - 1) Ecrire("Aire calculée =", aire_rect) Sinon Ecrire("La méthode qui converge la première est la méthode des trapèzes") Ecrire("Nombre de subdivisions =", n - 1) Ecrire("Aire calculée =", aire_trap) Fin si # Fermeture du fichier Fermer(f) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f | fichier |
| n | entier |
| aire_rect | réel |
| aire_trap | réel |
Solution en Python
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 |
# -------------------------------------------------- # Fonction mathématique f(x) = x² # -------------------------------------------------- def carre(x): # Retourne le carré de x return x * x # -------------------------------------------------- # Fonction qui calcule l’aire par la méthode des rectangles # a : borne inférieure de l’intervalle # b : borne supérieure de l’intervalle # n : nombre de subdivisions # -------------------------------------------------- def aire_rectangles(a, b, n): # Largeur de chaque subdivision h = (b - a) / n # Somme des aires des rectangles s = 0 # Abscisse de départ x = a # Calcul de la somme des carre(x) aux points gauches for i in range(n): s += carre(x) x += h # Aire approximative return s * h # -------------------------------------------------- # Fonction qui calcule l’aire par la méthode des trapèzes # -------------------------------------------------- def aire_trapezes(a, b, n): # Largeur de chaque subdivision h = (b - a) / n # Somme initiale avec les bornes s = (carre(a) + carre(b)) / 2 # Premier point intérieur x = a + h # Ajout des valeurs intermédiaires for i in range(1, n): s += carre(x) x += h # Aire approximative return s * h # -------------------------------------------------- # Fonction qui permet de saisir une valeur correcte de epsilon # avec 0.001 < epsilon < 0.1 # -------------------------------------------------- def saisie_epsilon(): epsilon = float(input("Donner epsilon tel que 0.001 < epsilon < 0.1 : ")) # Répéter la saisie tant que epsilon est invalide while not (0.001 < epsilon < 0.1): epsilon = float(input("Donner epsilon tel que 0.001 < epsilon < 0.1 : ")) return epsilon # -------------------------------------------------- # Procédure qui remplit le fichier Calcul.dat # et détermine la méthode qui converge la première # -------------------------------------------------- def remplir_fichier_calcul(epsilon): # Ouverture du fichier en mode écriture f = open("Calcul.dat", "w") print('****************************************') # Initialisation du nombre de subdivisions n = 1 # Calcul initial des aires aire_rect = aire_rectangles(a, b, n) aire_trap = aire_trapezes(a, b, n) # Tant qu’aucune des deux méthodes n’a convergé while (abs(aire_rect - aire_exacte) > epsilon) and \ (abs(aire_trap - aire_exacte) > epsilon): # Calcul des aires pour le nombre courant de subdivisions aire_rect = aire_rectangles(a, b, n) aire_trap = aire_trapezes(a, b, n) # Affichage des résultats print(str(n) + ", aire rectangulaire: " + str(aire_rect) + ", aire trapeze: " + str(aire_trap)) # Stockage dans le fichier f.write(str(n) + ", aire rectangulaire: " + str(aire_rect) + ", aire trapeze: " + str(aire_trap) + "\n") # Passage au nombre de subdivisions suivant n = n + 1 print('****************************************') # Détermination de la méthode qui converge la première if abs(aire_rect - aire_exacte) <= epsilon: print("La méthode qui converge la première est la méthode des rectangles") print("Nombre de subdivisions =", n - 1) print("Aire calculée =", aire_rect) else: print("La méthode qui converge la première est la méthode des trapèzes") print("Nombre de subdivisions =", n - 1) print("Aire calculée =", aire_trap) # Fermeture du fichier f.close() # -------------------------------------------------- # Programme principal # -------------------------------------------------- # Bornes de l’intervalle a = 0 b = 3 # Aire exacte de l’intégrale aire_exacte = 9 # Saisie de epsilon epsilon = saisie_epsilon() # Remplissage du fichier et comparaison des méthodes remplir_fichier_calcul(epsilon) |
Exécution du programme
0 commentaire
laisser un commentaire
Passion de robotique
Tutoriels récents
Atelier robotique
Tutoriels populaires
Construction des robots
Tutoriels plus commentés
Bras robotique
Categories
Maison intelligente
