En classe de Seconde, le programme stipule que l’on doit savoir obtenir un encadrement de \(\sqrt2\) par balayage à l’aide de Python.

Nous allons voir sur cette page l’idée qu’il y a derrière cette opération et le script Python.

Le principe mathématique

On sait que si \(0 < a < r < b\) alors \(0 < a^2 < r^2 < b^2\).

On cherche deux nombres a et b tels que:$$a < \sqrt2 < b$$ donc tels que:$$a^2 < (\sqrt2)^2 < b^2.$$

De plus, on sait que $$1 < 2 < 3$$donc l’idée est de partir de \(a=\sqrt1=1\) et de lui ajouter un pas très petit, par exemple \(10^{-n}\) où n est un entier naturel, jusqu’à obtenir:$$a^2 < 2 < (a+10^{-n})^2.$$

Un exemple pas à pas

Posons a = 1 et b = a + 0,1. On calcule ensuite a² et b² et on regarde si a² < 2 < b². On a a² = 1 et b² = 1,1² = 1,21 donc 2 n’est pas compris entre a² et b².

Dans ce cas, on pose a = b = 1,1 puis b = a + 0,1 = 1,2 et on calcule : a² = 1,21 et b² = 1,44. « 2 » n’est pas compris entre a² et b² donc on continue.

On pose a = b = 1,2 et b = a + 1 = 1,3… On résume cela dans un tableau:

On s’arrête donc lorsque a = 1,4 et b = 1,5, ce qui signifie que:$$1,4 < \sqrt2 < 1,5.$$

Obtenir un encadrement par balayage en Python : deux programmes

def approximation(n):
    a = 1
    while ((a+10**(-n))**2 < 2):
        a = a + 10**(-n)
        
    return round(a,n) , round(a+10**(-n),n)

p , q = approximation(5)
print(f'{p} < racine(2) < {q}')

Expliquons ce programme.

J’ai défini une fonction approximation admettant un nombre en argument : n. Ce nombre va désigner l’amplitude de l’encadrement souhaité, c’est-à-dire la différence entre les deux bornes de l’encadrement.

Dans cette fonction, j’ai affecté à la variable a la valeur 1 car on commence à 1 (comme dans l’exemple précédent). Je vais ajouté aux différentes valeurs de a le nombre \(10^{-n}\), que l’on écrit en python : 10**(-n). Dans l’exemple précédent, j’ajoutais 0,1 qui correspond à \(10^{-1}\).

Tant que (a + \(10^{-n}\)) ² est plus petit que 2, cela signifie que je n’ai pas encore obtenu mon encadrement, donc je continue à ajouter \(10^{-n}\) à a.

La boucle while s’arrête quand (a + \(10^{-n}\))² > 2. Dans ce cas, la fonction approximation retourne deux nombres arrondis (round) : a et (a + \(10^{-n}\))² qui sont les deux bornes de l’encadrement.

Ensuite (ligne 8), j’affecte les deux valeurs retournées par la fonction aux variables p et q, pour ensuite les afficher à la ligne 9. En lançant le programme, on obtient:

1.41421 < racine(2) < 1.41422

Si je veux un encadrement à \(10^{-7}\), il suffira de taper:

>>> approximation(7)
1.4142135 < racine(2) < 1.4142136

Mais attention : à partir de n = 7, ça commence à être très long… Ce programme (comme tout programme de balayage) n’est pas du tout optimal pour les grandes valeurs de n (essayez avec n = 10… vous pourrez vous préparer un bon chocolat chaud en attendant tellement c’est long !).

Autre solution

def balayage(p):
    # encadrement de racine carrée de 2 d'amplitude 10^(-p)
    a, b = 1, 2
    x = 2**0.5 # racine carrée de 2
    e = 0 # exposant de 10
    while e > -p:
        e = e - 1
        # balayage de [a;b]
        while x > a:
            a = a + 10**e
        
        b = a
        a = b - 10**e
        
    return round(a,abs(e)) , round(b,abs(e))

>>> balayage(10)
(1.4142135623, 1.4142135624)

Ce programme est plus intuitif que le premier… et en plus, il est plus performant!

N’oubliez pas que si vous rencontrez des difficultés en mathématiques, je peux vous aider par webcam !

[Retourner aux ressources Python]