Calcul approché d’une intégrale – Bac théorique – Section informatique – 2009

Bac Info 09-12-25

21 0

Sujet (Algo et programmation - Bac 2009)

Solution Algorithmique

Dans cet algorithme, On va utiliser trois fonctions et deux procédures :

- la fonction saisie()

- la fonction methode_trapezes()

- la procédure remplir()

- la procédure tri_insertion()

- la fonction methode_subdivision()

Algorithme du programme Principal

Algorithme calcule_integrale 
Debut 
     # Saisie du nombre de subdivisions
     n = saisie()
     # Méthode des trapèzes
     Ecrire("Valeur approchee par méthode des trapèzes: " + methode_trapezes(n))

     # Méthode des subdivisions aléatoires
     remplir(v, n)          # Génération de n réels aléatoires
     tri_insertion(v, n)    # Tri par insertion
     Ecrire("Valeur approchee par méthode des subdivisions: " + methode_subdivision(v, n))
Fin

Algorithme calcule_integrale

Debut

# Saisie du nombre de subdivisions

n = saisie()

# Méthode des trapèzes

Ecrire("Valeur approchee par méthode des trapèzes: " + methode_trapezes(n))

# Méthode des subdivisions aléatoires

remplir(v, n) # Génération de n réels aléatoires

tri_insertion(v, n) # Tri par insertion

Ecrire("Valeur approchee par méthode des subdivisions: " + methode_subdivision(v, n))

Fin

Déclaration des objets

Objet	Type / Nature
n	entier
v	tableau des réels

La fonction saisir

La fonction saisie() permet à l’utilisateur de saisir un entier n et de contrôler que cet entier appartient bien à l’intervalle strict : 100

Fonction saisie(): entier    
    Ecrire('donner n tel que 100<n<1000: ')
    lire (n)
    # Tant que la valeur n'est pas dans l’intervalle demandé, on redemande
    Tant que (n < 100) ou (n > 1000) faire
        Ecrire('donner n tel que 100<n<1000: ') 
        lire (n)
    Fin tant que
    retourner n
fin

Fonction saisie(): entier

Ecrire('donner n tel que 100<n<1000: ')

lire (n)

# Tant que la valeur n'est pas dans l’intervalle demandé, on redemande

Tant que (n < 100) ou (n > 1000) faire

Ecrire('donner n tel que 100<n<1000: ')

lire (n)

Fin tant que

retourner n

fin

Déclaration des objets

Objet	Type / Nature
n	entier

La fonction methode_trapezes

1- La fonction methode_trapezes(n) calcule une valeur approchée de l’intégrale en utilisant la méthode des trapèzes avec n subdivisions.

2- Elle détermine la largeur d’un sous-intervalle ℎ=(2−1) /𝑛

3- Elle calcule la somme des valeurs de la fonction exp(-x²) aux points de subdivision

4- Elle applique la formule numérique du trapèze et retourne l’approximation de l’intégrale.

Fonction methode_trapezes(n:entier):reel    
    # Bornes de l'intégrale
    a <- 1
    b <- 2             
    h <- (b - a) / n    # Pas de subdivision

    # Somme initiale f(a) + f(b)
    s <- exp(-a*a) + exp(-b*b)

    # Ajout des termes au milieu multipliés par 2
    Pour i de 1 à n-1 faire
        xi <- a + i * h
        s <- s + 2 * math.exp(-xi*xi)
    Finpour
    # Formule finale de la méthode des trapèzes
    retourner (h / 2) * s
Fin

Fonction methode_trapezes(n:entier):reel

# Bornes de l'intégrale

a <- 1

b <- 2

h <- (b - a) / n # Pas de subdivision

# Somme initiale f(a) + f(b)

s <- exp(-a*a) + exp(-b*b)

# Ajout des termes au milieu multipliés par 2

Pour i de 1 à n-1 faire

xi <- a + i * h

s <- s + 2 * math.exp(-xi*xi)

Finpour

# Formule finale de la méthode des trapèzes

retourner (h / 2) * s

Fin

Déclaration des objets

Objet	Type / Nature
a	entier
b	entier
i	entier
h	réel
s	réel
xi	réel

La procédure remplir

La procédure remplir() remplit un tableau t de taille n avec des nombres réels aléatoires compris dans l’intervalle : [1,2[

Pour chaque case du tableau, elle génère un nombre aléatoire dans [0,1[ , puis y ajoute 1, ce qui donne une valeur dans [1,2[.

Procédure remplir(t:tableau; n:entier)
     Pour i de 0 à n-1 faire
        # Aléa() donne un réel dans [0,1[
        # Donc 1 + Aléa() ∈ [1, 2[
        t[i] = 1 + Aléa()
Fin

Procédure remplir(t:tableau; n:entier)

Pour i de 0 à n-1 faire

# Aléa() donne un réel dans [0,1[

# Donc 1 + Aléa() ∈ [1, 2[

t[i] = 1 + Aléa()

Fin

Déclaration des objets

Objet	Type / Nature
i	entier

La procédure tri_insertion

La fonction test_cellule sert à :

1. Convertir deux entiers i et j en binaire en utilisant la fonction convertir_binaire pour obtenir la représentation binaire de chacun des deux nombres.

2. Gérer le cas particulier du nombre 0 : si convertir_binaire renvoie une chaîne vide (ce qui arrive généralement lorsque le nombre vaut 0), la fonction remplace cette chaîne vide par "0" pour que le binaire soit correct.

3. Comparer les deux nombres binaires bit à bit

La fonction renvoie le résultat de test_position1(binaire_i, binaire_j).

Procedure tri_insertion (t:tableau;n:entier):
    Pour i de 1 à n-1 faire
        j <- i
        e <- t[i]  # Élément à insérer au bon endroit

        # Décalage des éléments plus grands vers la droite
        Tant que (t[j-1] > e) et (j > 0) faire
            t[j] <- t[j-1]
            j <- j - 1
        Fin tant que
        # Placement de l'élément à sa bonne position
        t[j] <- e
    Fin pour
Fin

Procedure tri_insertion (t:tableau;n:entier):

Pour i de 1 à n-1 faire

j <- i

e <- t[i] # Élément à insérer au bon endroit

# Décalage des éléments plus grands vers la droite

Tant que (t[j-1] > e) et (j > 0) faire

t[j] <- t[j-1]

j <- j - 1

Fin tant que

# Placement de l'élément à sa bonne position

t[j] <- e

Fin pour

Fin

Déclaration des objets

Objet	Type / Nature
i	entier
j	entier
e	entier

La fonction methode_subdivision

La fonction methode_subdivision() calcule une valeur approchée de l’intégrale en utilisant la méthode de subdivision aléatoire.

Elle utilise un tableau v de n points triés dans l’intervalle [1,2] et applique la formule donnée dans l’énoncé.

Fonction methode_subdivision(v:tableau; n:entier):reel
    s1 <- 0
    s2 <- 0
    # Calcul des deux sommes S1 et S2
    Pour i de 0 à n-2 faire
        s1 = s1 + (v[i+1] - v[i]) * math.exp(-(v[i] ** 2))
        s2 = s2 + (v[i+1] - v[i]) * math.exp(-(v[i+1] ** 2))

    # Formule de la méthode
    retourner (s1 + s2) / 2
Fin

Fonction methode_subdivision(v:tableau; n:entier):reel

s1 <- 0

s2 <- 0

# Calcul des deux sommes S1 et S2

Pour i de 0 à n-2 faire

s1 = s1 + (v[i+1] - v[i]) * math.exp(-(v[i] ** 2))

s2 = s2 + (v[i+1] - v[i]) * math.exp(-(v[i+1] ** 2))

# Formule de la méthode

retourner (s1 + s2) / 2

Fin

Déclaration des objets

Objet	Type / Nature
s1	réel
s2	réel

Solution en Python

import math
import random
from numpy import *

# Tableau pouvant contenir jusqu'à 1000 réels
# Il servira pour stocker les points aléatoires pour la méthode 2
v = array([float()] * 1000)


# --------------------------------------------------------
# Fonction de saisie avec contrôle
# --------------------------------------------------------
def saisie():
    n = int(input('donner n telque 100<n<1000: '))

    # Tant que n n'est pas dans l'intervalle ]100,1000[ , on redemande
    while (n <= 100) or (n >= 1000):
        n = int(input('donner n telque 100<n<1000: '))
    return n    


# --------------------------------------------------------
# Méthode 1 : Méthode des trapèzes
# --------------------------------------------------------
def methode_trapezes(n):
    # Bornes de l'intégrale
    a = 1
    b = 2             
    h = (b - a) / n    # Pas de subdivision

    # Somme initiale f(a) + f(b)
    s = math.exp(-a*a) + math.exp(-b*b)

    # Ajout des termes au milieu multipliés par 2
    for i in range(1, n):
        xi = a + i * h
        s += 2 * math.exp(-xi*xi)

    # Formule finale de la méthode des trapèzes
    return (h / 2) * s


# --------------------------------------------------------
# Remplir un tableau avec n valeurs aléatoires dans [1,2]
# --------------------------------------------------------
def remplir(t, n):
    for i in range(n):
        # random.random() donne un réel dans [0,1[
        # Donc 1 + random.random() ∈ [1, 2[
        t[i] = 1 + random.random()


# --------------------------------------------------------
# Tri par insertion (tri imposé par le sujet)
# --------------------------------------------------------
def tri_insertion(t, n):
    for i in range(1, n):
        j = i
        e = t[i]  # Élément à insérer au bon endroit

        # Décalage des éléments plus grands vers la droite
        while (t[j-1] > e) and (j > 0):
            t[j] = t[j-1]
            j = j - 1

        # Placement de l'élément à sa bonne position
        t[j] = e


# --------------------------------------------------------
# Méthode 2 : Subdivision aléatoire
# --------------------------------------------------------
def methode_subdivision(v, n):

    s1 = 0
    s2 = 0

    # Calcul des deux sommes S1 et S2
    for i in range(n-1):
        s1 += (v[i+1] - v[i]) * math.exp(-(v[i] ** 2))
        s2 += (v[i+1] - v[i]) * math.exp(-(v[i+1] ** 2))

    # Formule de la méthode
    return (s1 + s2) / 2


# --------------------------------------------------------
# Programme principal
# --------------------------------------------------------

# Saisie sécurisée du nombre de subdivisions
n = saisie()

# Méthode des trapèzes
print("Valeur approchee par méthode des trapèzes: " +
      str(methode_trapezes(n)))

# Méthode des subdivisions aléatoires
remplir(v, n)          # Génération de n réels aléatoires
tri_insertion(v, n)    # Tri par insertion
print("Valeur approchee par méthode des subdivisions: " +
      str(methode_subdivision(v, n)))

100

101

102

import math

import random

from numpy import *

# Tableau pouvant contenir jusqu'à 1000 réels

# Il servira pour stocker les points aléatoires pour la méthode 2

v = array([float()] * 1000)

# --------------------------------------------------------

# Fonction de saisie avec contrôle

# --------------------------------------------------------

def saisie():

n = int(input('donner n telque 100<n<1000: '))

# Tant que n n'est pas dans l'intervalle ]100,1000[ , on redemande

while (n <= 100) or (n >= 1000):

n = int(input('donner n telque 100<n<1000: '))

return n

# --------------------------------------------------------

# Méthode 1 : Méthode des trapèzes

# --------------------------------------------------------

def methode_trapezes(n):

# Bornes de l'intégrale

a = 1

b = 2

h = (b - a) / n # Pas de subdivision

# Somme initiale f(a) + f(b)

s = math.exp(-a*a) + math.exp(-b*b)

# Ajout des termes au milieu multipliés par 2

for i in range(1, n):

xi = a + i * h

s += 2 * math.exp(-xi*xi)

# Formule finale de la méthode des trapèzes

return (h / 2) * s

# --------------------------------------------------------

# Remplir un tableau avec n valeurs aléatoires dans [1,2]

# --------------------------------------------------------

def remplir(t, n):

for i in range(n):

# random.random() donne un réel dans [0,1[

# Donc 1 + random.random() ∈ [1, 2[

t[i] = 1 + random.random()

# --------------------------------------------------------

# Tri par insertion (tri imposé par le sujet)

# --------------------------------------------------------

def tri_insertion(t, n):

for i in range(1, n):

j = i

e = t[i] # Élément à insérer au bon endroit

# Décalage des éléments plus grands vers la droite

while (t[j-1] > e) and (j > 0):

t[j] = t[j-1]

j = j - 1

# Placement de l'élément à sa bonne position

t[j] = e

# --------------------------------------------------------

# Méthode 2 : Subdivision aléatoire

# --------------------------------------------------------

def methode_subdivision(v, n):

s1 = 0

s2 = 0

# Calcul des deux sommes S1 et S2

for i in range(n-1):

s1 += (v[i+1] - v[i]) * math.exp(-(v[i] ** 2))

s2 += (v[i+1] - v[i]) * math.exp(-(v[i+1] ** 2))

# Formule de la méthode

return (s1 + s2) / 2

# --------------------------------------------------------

# Programme principal

# --------------------------------------------------------

# Saisie sécurisée du nombre de subdivisions

n = saisie()

# Méthode des trapèzes

print("Valeur approchee par méthode des trapèzes: " +

str(methode_trapezes(n)))

# Méthode des subdivisions aléatoires

remplir(v, n) # Génération de n réels aléatoires

tri_insertion(v, n) # Tri par insertion

print("Valeur approchee par méthode des subdivisions: " +

str(methode_subdivision(v, n)))

0 commentaire

laisser un commentaire

Annuler la réponse

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Nom *

Email *

Message *

Passion de robotique

Tutoriels récents

Calcul approché d’une intégrale – Bac théorique – Section informatique – 2009

Bac Info 09-12-25

Chemins Matrice – Bac théorique – Section informatique – 2009

Bac Info 08-12-25

Facteurs premiers – Bac pratique – Section informatique – 2009

Bac Info 05-12-25

Suite – Bac pratique – Section informatique- 2009

Bac Info 05-12-25

Super premier – Bac pratique – Section informatique- 2009

Bac Info 05-12-25

Atelier robotique

Tutoriels populaires

Présentation de la carte ESP32

ESP32 10424vues

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino UNO 9923vues

La carte ESP32 et l’afficheur LCD I2C 1602

ESP32 8908vues

Allumer une LED par la carte ESP32

ESP32 8571vues

La carte Arduino UNO et l’afficheur LCD I2C 2X16

Arduino UNO 8477vues

Construction des robots

Tutoriels plus commentés

Afficher la température et l’humidité mesurées par le capteur DHT11 connecté à Arduino sur l’afficheur LCD I2C

Arduino UNO 28 commentaires

Piloter un servomoteur par la carte Arduino UNO

Arduino UNO 17 commentaires

Présentation du module capteur de lumière à LDR

Composants 14 commentaires

Echange des messages entre deux cartes Micro:bit via radio

Micro:bit 14 commentaires

Présentation du buzzer

Composants 6 commentaires

Calcul approché d’une intégrale – Bac théorique – Section informatique – 2009

Sujet (Algo et programmation - Bac 2009)

Solution Algorithmique

Algorithme du programme Principal

La fonction saisir

La fonction methode_trapezes

La procédure remplir

La procédure tri_insertion

La fonction methode_subdivision

Solution en Python

0 commentaire

laisser un commentaire

Annuler la réponse

Passion de robotique

Tutoriels récents

Atelier robotique

Tutoriels populaires

Construction des robots

Tutoriels plus commentés

Bras robotique

Categories

Maison intelligente

But de ce site web

Coordonnées

Articles populaires

Photos des articles