La méthode des rectangles est une méthode algorithmique permettant d’encadrer l’aire d’un domaine sous une courbe représentative de fonction et sur un intervalle donné.

Principe mathématique de la méthode des rectangles

Considérons une fonction f continue sur un intervalle [a ; b], et subdivisons cet intervalle en n, c’est-à-dire coupons-le en n petits intervalles de même amplitude. Ces subdivisions seront les “bases” de rectangles.

Notons:$$x_k = a + \frac{b-a}{n}k$$ pour \(k\) entier compris entre 0 et n inclus, et considérons les rectangles:

  • \(I_k\), de base \([x_k;x_{k+1}]\) et de hauteur \(f(x_k)\) pour \(0 \leqslant k \leqslant n-1\);
  • (S_k), de base ([x_k;x_{k+1}]) et de hauteur (f(x_{k+1})) pour \( 0\leqslant k \leqslant n-1).
méthode des rectangles python
À gauche : les rectangles \(I_k\) sur [0;1] subdivisé en n = 5
À droite : les rectangles \(S_k\) sur [0;1] subdivisé en n = 5

Intuitivement, plus le nombre de rectangles grandit, plus les sommes des aires des rectangles vont se rapprocher vers l’intégrale de la fonction sur le même intervalle.

Autrement écrit, si \(\mathcal{A}_n(I)\) et \(\mathcal{A}_n(S)\) représentent respectivement la somme des aires des rectangles I et S, alors:$$\lim\limits_{n\to+\infty}\mathcal{A}_n(I) = \lim\limits_{n\to+\infty}\mathcal{A}_n(J) = \int_a^b f(x)\text{d}x.$$De plus, si f est strictement croissante sur [a ; b]:$$\mathcal{A}_n(I) \leqslant \int_a^b f(x)\text{d}x \leqslant \mathcal{A}_n(J).$$Si la fonction est strictement décroissante, l’encadrement est bien entendu inversé.

Ainsi, si on arrive à calculer \(\mathcal{A}_n(I)\) et \(\mathcal{A}_n(J)\), on aura un encadrement de l’intégrale.

Implémentation en Python

def integrale(f,a,b,n):
    longueur = (b - a) / n
    aire_inf , aire_sup = 0 , 0
    for k in range (n):
        aire_inf = aire_inf + longueur * f(a + k * longueur )
        aire_sup = aire_sup + longueur * f(a + (k+1) * longueur )
    return aire_inf , aire_sup

aire_inf , aire_sup = integrale( lambda x: x*x , 0 , 1 , 100 )
print("{} < integrale < {}".format(aire_inf,aire_sup))

Il n’y a rien de bien compliqué du point de vue algorithmique; en effet,

  • on commence par définir l’amplitude des subdivisions → ligne 2
  • ensuite, on initialise les deux aires à calculer à 0 → ligne 3
  • puis on fait une boucle en k (pour k variant de 0 à n-1 → ligne 4) dans laquelle on ajoute aux variables représentant les deux aires l’aire du rectangle \(I_k\) et celle du rectangle \(S_k\) (→lignes 5 et 6)
  • À la fin de la boucle, on retourne les valeurs stockées dans les variables représentant les deux aires (→ ligne 7)

Il est à noter la syntaxe particulière de la fonction en Python: j’utilise ici l’opérateur lambda, qui me semble très pratique. Cela étant dit, on peut aussi utiliser une autre syntaxe peut-être plus naturelle:

 def integrale(a,b,n):
    longueur = (b - a) / n
    aire_inf , aire_sup = 0 , 0
    for k in range (n):
        aire_inf = aire_inf + longueur * f(a + k * longueur )
        aire_sup = aire_sup + longueur * f(a + (k+1) * longueur )
    return aire_inf , aire_sup

def f(x):
    return x**2

aire_inf , aire_sup = integrale( 0 , 1 , 100 )
print("{} < integrale < {}".format(aire_inf,aire_sup))

Dans ce dernier script, la fonction est définie à part. On enlève donc l’argument représentant la fonction f de la fonction Python integrale.

Pour information, en lançant ce script, s’affiche le résultat suivant:

0.32835000000000014 < integrale < 0.33835000000000015

Et en augmentant considérablement la valeur de n à 1000000, on arrive (mais à quel coût !) à:

0.3333328333334962 < integrale < 0.3333338333334962

Sachant que la valeur exacte est \(\frac{1}{3}\), cette méthode ne semble pas réellement efficace. En effet, pour \(n=10^6\), nous n’avons qu’une valeur approchée à \(10^{-6}\), ce qui laisse à penser que la complexité de cette méthode est linéaire, ce qui peut poser problème pour de très grandes valeurs de n. D’ailleurs, lancez le script et voyez le temps que cela prend pour \(n=10^{12}\)… Spoiler alert: soyez très patient·e·s !

Il existe d’autres méthodes permettant d’obtenir une valeur approchée d’une intégrale. Je vous en présente une sur cette page, tout aussi lente. Il en existe tout de même des plus rapides comme celle utilisée par certaines calculatrices : la méthode de Simpson.

Et n’oubliez pas que si vous avez des difficultés en mathématiques, je peux vous aider par wecam !