Afin de pouvoir personnaliser ce notebook sans détruire le fichier initial, vous allez tout d'abord aller dans le menu File puis Make a copy....

Renommez le classeur en cliquant sur son nom Méthode des ... et par exemple en remplaçant copy1 par travail_1 ou autre à la fin du nom de fichier.

Refermez alors l'onglet précédent en utilisant le menu File puis Close and Halt.

On rappelle que pour exécuter une cellule activée (encadrée d'une rectangle vert ou bleu), il suffit d'appuyer simultanément sur les touches Maj et Entrée.

Problématique

On considère dans cette activité la fonction $f$ définie sur $[0 ;3]$ par $f (x) = x^2$ et $\mathscr C$ sa courbe représentative dans un repère orthonormé.

L'objectif de cette activité est de calculer l'aire du domaine délimité

  • d'une part par les droites d'équation $x=0$ et $x=1$
  • d'autre part par l'axe des asbcisses et la courbe $\mathscr C$

L'aire

En d'autre termes, nous cherchons à déterminer l'aire hachurée en rouge sous la courbe $\mathscr C$ pour $x$ compris entre 0 et 1.

In [ ]:
# On définit notre fonction f dans la mémoire de python 
def f(x):
    return x**2

Méthodes

Nous allons explorer 2 méthodes, mais il en existe bien d'autres.

La méthode de Monte-Carlo

Il s'agit d'une méthode probabiliste.

On prend des points aléatoirement dans le carré de côté 1. La proportion de points situés sous la courbe approche l'aire.

Voici une fonction python à compléter :

In [ ]:
from random import random # on importe la fonction raandom() depuis la bibliothèque random

def monte_carlo(n):
    '''Cette foncion retourne la proportion des n points générés aléatoirement 
    qui se situent sous la courbe représentant la fonction f précédemment définie'''
    compteur = 0  # on va compter au fur et à mesure de la génération des points
    for i in range(n): # on répète n fois
        x = random()   # x est une abscisse aléatoire de l'intervalle [0 ; 1] 
        y = random()   # y est une ordonnée aléatoire de l'intervalle [0 ; 1]
        if y  f(x) :  # si le point est sous la courbe
            compteur =    # On incrémente le compteur
    return (compteur / n)  # on renvoie la fréquence des points sous la courbe.  

Nous allons tester cette fonction dans la cellule ci-dessous :

In [ ]:
monte_carlo(10)

Relancez la cellule précédente.

  • Si les résultats vous paraissent incompatibles avec le dessin appelez-moi.
  • Sinon exécutez la cellule ci-dessous qui va appeler la fonction 21 fois en augmentant progressivement le nombre de points.
In [ ]:
for i in range (7):
    for j in range(3):
        print("Avec", 10**(i+1), "points, on approche l'aire ",monte_carlo(10**(i+1)))

On constate que la proportion semble converger vers une valeur qui doit être l'aire, mais que cette convergence est très lente.

En effet avec 10 millions de points, on ne semble sûr que de la troisième décimale.

Nous allons essayer de trouver une méthode plus efficace.

La méthode des rectangles

L’idée va être d’encadrer l’aire recherchée par deux aires que l’on peut calculer aisément. On utilise pour cela des figures très élémentaires : des rectangles.

Nous allons calculer un minorant de l'aire en inscrivant des rectangles sous la courbe (voir rectangles rouges) et un majorant de l'aire en construisant des rectangles au dessus de la courbe (voir rectangles bleus).

En effet, l'aire d'un rectangle est facile à calculer. Il suffit donc de faire la somme des aires de chacun des rectangles pour obtenir un encadrement de l'aire recherchée.

Rectangles inférieurs (bleus)

On cherche à déterminer l'aire du rectangle dont la base est située entre les abscisses $x$ et $x+dx$ ($dx$ désignant la largeur de chaque rectangle) et dont la hauteur est telle que le rectangle soit situé juste au dessous de la courbe $\mathscr C$.

On pourra généraliser le résultat à toute fonction croissante.

Rectangles supérieurs

  • Calculez l'aire bleue dessinée ci-dessus.
    • vous pouvez utiliser la cellule de code ci-dessous comme calculatrice avant de compléter les réponses dans la cellule suivante.
    • la fonction $f$ est déjà en mémoire
  • Exprimez l'aire de ces rectangles, en fonction de $x$, $dx$ et de la fonction $f$.
In [ ]:
0.25*f() + 

L'aire bleue des 4 rectangles est … × … + … × … + … × … + … × … = …

ici $dx$ = …

De façon générale, comme $f$ est croissante, l'aire de chacun des rectangles est $… × …$ pour $x$ allant de … à … par pas de …

In [ ]:
###################################################################
#  un premier programme à compléter pour automatiser les calculs  #
###################################################################

n = 4       # n contient le nombre de rectangles
dx =  /     # calcul de dx la largeur des rectangles
inf = 0     # la variable inf va contenir le cumul des aires au fur et à mesure  
for i in range(n):  # pour chaque rectangle
    print(i)        # inutile en théorie mais peut aider à mieux comprendre  
    x = i *        # calcul de x
    inf = inf +  * f()   # cumul des aires
print (inf)    # affichage de l'aire inférieure

Avec Geogebra

Exécutez la cellule ci-dessous.

In [1]:
%%html
<iframe scrolling="no" title="Introduction calcul integral" src="https://www.geogebra.org/material/iframe/id/cjjtwens/width/846/height/400/border/888888/sfsb/true/smb/false/stb/true/stbh/false/ai/true/asb/false/sri/false/rc/true/ld/false/sdz/false/ctl/false" width="846px" height="400px" style="border:0px;"> </iframe>

Réalisez les actions ci-dessous dans la cellule Géogebra ci-dessus.

  • Saisissez dans l'espace de saisie (à droite du signe + et à gauche du repère) puis validez
  • Créez un curseur n allant de 1 à 100 avec un incrément de 1
  • Saisissez Inf=SommeInférieure[f,0,1,n] puis validez.
  • Déplacez le curseur et observez les affichages. Complétez la conjecture ci-dessous :

Plus $n$ augmente, plus l'aire des rectangles … de l'aire cherchée, tout en restant …

Rectangles supérieurs (rouges)

On cherche à déterminer l'aire du rectangle dont la base est située entre les abscisses $x$ et $x+dx$ (dx désignant la largeur de chaque rectangle) et dont la hauteur est telle que le rectangle soit situé juste sous la courbe $\mathscr C$. Rectangles inférieurs

  • Calculez l'aire rouge dessinée ci-dessus.
  • Exprimez l'aire de ces rectangles, en fonction de $x$, $dx$ et de la fonction $f$.

ici dx = …

L'aire rouge est est … × … + … × … + … × … + … × … = …

L'aire de chacun des rectangles est $… × …$ pour x allant de 0 à …

In [ ]:
# Utiliser cette cellule pour obtenir une première automatisation des calculs
#

Avec Geogebra

Dans la cellule où Géogebra est actif :

  • Masquez l’affichage de Inf.
  • Ramenez le curseur à 4.
  • Saisissez Sup=SommeSupérieure[f,0,1,n].
  • Déplacez le curseur et observer les affichages. Complétez la conjecture ci-dessous :

Plus n augmente, plus l'aire des rectangles … tout en restant …

L'aire cherchée semble être …

Dans la cellule où Géogebra est actif :

  • Masquez l’affichage de Sup
  • Saisissez Intégrale[f,0,1].
  • Cela doit confirmer votre dernière conjecture.

Calculs avec python

In [ ]:
# définition des paramètres nécessaires

a = 0 # borne inférieure des abscisses
b = 1 # borne supérieure des abscisses
n = 4 # Nombre de rectangles
  • Complétez les pointillés de la fonction ci-dessous dont le but est de calculer la somme des aires des rectangles sous la courbe (rouges) et la somme des aires des rectangles au dessus de la courbe (bleus).
In [ ]:
def encadre(f, a, b, n): # on définit la fonction qui reçoit 4 paramètres
    # f le nom de la fonction, a et b les bornes de l'intervalle et n le nombre de rectangles
    dx =         # largeur d'un rectangle
    sommeSup = 0  # Aire des rectangles supérieurs
    sommeInf = 0  # Aire des rectangles inférieurs
    x = a         # Bord gauche du rectangle considéré
    for i in range(n):  # Répéter n fois
        sommeSup = sommeSup + dx * f() # On cumule les aires des rectangles supérieurs
        sommeInf = sommeInf + dx * f()     # On cumule les aires des rectangles inférieurs
        x = x + dx                   # On passe à l'abscisse suivante
    return(sommeInf, sommeSup) # la fonction renvoie deux nombres qui encadrent l'aire cherchée
In [ ]:
# et on appelle la fonction une fois
encadre(f,a,b,n) # Les 4 paramètres f, a, b et n existent en mémoire

Ce qui doit confirmer vos calculs précédents.

Pour voir comment se comporte cet encadrement, on le calcule plusieurs fois en augmentant le nombre de rectangles.

Validez la cellule ci-dessous pour effectuer ce travail.

In [ ]:
for i in range(7): # pour i allant de 0 à 7
    e = encadre(f,a,b,10**i) # Calculer les bornes de l'encadrement de l'aire avec 10^i rectangles
    print ("Pour", 10**i,"rectangle(s), l'aire est comprise entre", e[0], "et", e[1])

Comment semble se comporter les deux suites encadrant l'aire ?

Les deux suites semblent converger vers le même nombre proche de $\dfrac{…}{…}$

Modifiez ci-dessous le programme précédant for i in ... pour qu'il calcule et affiche l'amplitude des 7 encadrements précédants.

In [ ]:
# Modifiez le Copié collé du programme précédant ci-dessous :
for i in range(7): # pour i allant de 0 à 7
    e = encadre(f,a,b,10**i) # Calculer les bornes de l'encadrement de l'aire avec 10^i rectangles
    print ("Pour", 10**i,"rectangle(s), l'amplitude de l'encadrement est", e[]-e[])

Complétez :

En multipliant le nombre de rectangles par 10, l'amplitude de l'encadrement est divisée par …

Pour obtenir une valeur approchée de l'aire à $10^{-10}$ près, il faudrait utiliser $10^{…}$ rectangles.

Bilan

Dès qu'une fonction est positive sur un intervalle $[a ; b ]$, on peut calculer l'aire délimitée par

  • l'axe des abscisses
  • la courbe représentant la fonction
  • la droite d'équation $x=a$.
  • la droite d'équation $x=b$. Il est donc légitime d'utiliser une notation reprenant ces 4 éléments. ## Notation mathématiques

La notation indiquant l'aire hachurée sous la courbe que nous venons d'approcher est $\displaystyle \int_0^{1} x^2~ dx = \dfrac{1}{3}$

Cette notation a été inventée par Gottfried Wilhelm von Leibniz. Liebnitz

  • le symbole $\int$ peut être vu comme la première lettre "S" du mot somme.
  • 0 est la valeur de $a$, la borne inférieure de l'intervalle.
  • 1 est la valeur de $b$, la borne supérieure de l'intervalle.
  • $x^2$ est le procédé de calcul de l'image de $x$ par la fonction.
  • $dx$ joue dans cette notation,
    • le même rôle que dans la méthode des rectangles
    • la largeur du rectangle dont la hauteur est $x^2$
    • mais nous lui attribuerons plus tard une autre signification, plus fondamentale.

Application à une autre fonction

En utilisant la fonction encadre - éventuellement en définissant une nouvelle fonction - déterminez une valeur approchée de $\displaystyle \int_{0}^{\frac{\pi}{2}}sin(x)~dx$ avec une précision de l'ordre de $10^{-4}$.

In [ ]:
from math import pi
from math import sin

def g(x):
    return 
In [ ]:
encadre(g, , , ) 

D'après les encadrements obtenus l'aire correspondant à $\displaystyle \int_{0}^{\frac{\pi}{2}}sin(x)~dx = …$ à $10^{-4}$ près

Méthode des trapèzes

On peut remplacer les rectangles par des trapèzes.

On perd l'encadrement mais on accélère la convergence vers l'aire.

Si vous avez le temps, essayez ci-dessous.

In [ ]:
def trapeze(f, a, b, n): # on définit la fonction qui reçoit 4 paramètres
    # f le nom de la fonction, a et b les bornes de l'intervalle et n le nombre de rectangles
    dx =         # largeur d'un rectangle
    aire = 0      # aire des trapèzes
    x = a         # Bord gauche du trapèze considéré
    for i in range(n):  # Répéter n fois
        aire = aire + 0.5* dx * (f()+f()) # On cumule les aires des rectangles supérieurs
        x = x + dx                   # On passe à l'abscisse suivante
    return(aire) # la fonction renvoie un nombre qui approche l'aire cherchée

Testez votre fonction trapeze() et comparez avec les encadrements obtenus par la méthode des rectangles.

In [ ]:
for i in range(7): # pour i allant de 0 à 7
    print ("Pour", 10**i,"trapèze(s), l'aire est environ", trapeze(f,0,1,10**i))

Sauvegardez le document obtenu en utilisant le menu File puis Save and Checkpoint.

Fermez ce document en utilisant le menu File puis Close and Halt qui fermera le présent onglet et videra la mémoire et les processus utilisés par python.