Activité 2 - Encadrement de $\sqrt{2}$ par balayage

Présentation de l'activité

  • Références au programme :
    • Seconde : déterminer par balayage un encadrement de $\sqrt{2}$ d’amplitude inférieure ou égale à $10^{-n}$.
    • Tronc commun de première de la voie technologique : valeur approchée d’une solution d’une équation par balayage (les listes pourront être utilisées dans ce cas).
  • Description : approximation de $\sqrt{2}$, par l'étude de la fonction $x\mapsto x^2-2$ et la recherche d'un zéro de cette fonction par balayage.

Valeur approchée par défaut

Dans cette partie, nous allons déterminer par balayage une approximation par défaut de $\sqrt{2}$ avec une erreur inférieure à $10^{-n}$ en utilisant la fonction $x\mapsto x^2-2$.

Importation des librairies graphiques

In [1]:
import matplotlib.pyplot as plt

Représentation de la fonction $x\mapsto x^2-2$ sur l'intervalle $[0,2]$.

La fonction representation trace la représentation graphique d'une fonction $f$. Elle utilise une subdivision de $[a,b]$ en $N$ intervalles de même longueur. Elle prend comme paramètres :

  • les bornes $a$ et $b$ de l'intervalle $[a,b]$.
  • le nombre $N$ d'intervalles de la subdivision.
In [2]:
def f(x):
    return x**2-2

def representation(a,b,N):
    pas = (b-a)/N
    for i in range(N+1):
        x = a+i*pas
        plt.plot(x,f(x),'b.')


representation(0,2,100)   
plt.plot([0,2],[0,0],'r--')
plt.show()
Suggestions pédagogiques
  • Expliquer un programme
    • À quoi correspond la variable pas ? Comment est-elle calculée ?
    • Expliquer la ligne 7.
    • Quelle est la première valeur de x dans la boucle de la ligne 7 ?
    • Quelle est la dernière valeur de x dans la boucle de la ligne 7 ?
    • Comment obtenir une valeur approchée de $\sqrt{2}$ à l'aide du graphique ?

  • Compléter un programme

    Le programme précédent étant fourni en remplaçant les lignes 2, 5 et 7 par return ...,pas= ... et x = ..., demander aux élèves de compléter les lignes 2, 5 et 7.

  • Tester la fonction representation pour l’intervalle $[0,2]$ divisé en 100 parties.

Remarque

Ici, la fonction plot est utilisée au fur et à mesure du calcul car la notion de liste ne figure pas au programme de la classe de seconde.

Approximation de $\sqrt{2}$

Le programme suivant donne une approximation par défaut de $\sqrt{2}$ avec une erreur inférieure à $10^{-2}$.

In [3]:
a = 0
b = 2
N = 200
pas = (b-a)/N

estimation = a        
while f(estimation)<0:
    estimation = estimation + pas
    
        
print("Estimation de racine de racine de 2:",estimation)        
print("Estimation de racine de 2 au carré:",estimation**2)

Estimation de racine de racine de 2: 1.420000000000001
Estimation de racine de 2 au carré: 2.016400000000003
Suggestions pédagogiques

  • Expliquer un programme

    Expliquer la valeur de N ligne 3.

  • Compléter un programme

    Le programme précédent étant fourni en remplaçant les lignes 6, 7 et 8 par estimation = ..., while ... et estimation = ..., demander aux élèves de compléter les lignes 6, 7 et 8.

Animation susceptible d'être présentée aux élèves

Le schéma de gauche montre le déplacement de la droite de balayage (droite verte). Sur le côté droit, la courbe représente les différentes valeurs prises par la variable de balayage $x$. Partant de la valeur 0, la variable x est, tant que $f(x)\leq0$, incrémentée à chaque étape de la valeur du pas. Dès que $f(x)>0$, la variable de balayage $x$ garde une valeur constante égale à la dernière valeur de $x$ pour laquelle $f(x)\leqslant 0$, qui constitue une valeur approchée par défaut de $\sqrt{2}$ à la précision souhaitée.

In [11]:
%matplotlib inline
import matplotlib.animation
from IPython.display import HTML


def subdivisionIntervalle(a,b,N):
    pas = (b-a)/N
    return [a+i*pas for i in range(N+1)]

# constantes
nbFrames = 30
nbSubdivision = 30
a = 0
b = 2
pas = (b-a)/nbSubdivision
estimations = [0]
evolutionAbscisse = subdivisionIntervalle(a,b,nbSubdivision)

# points de la courbe pour le tracé
abscisses = subdivisionIntervalle(a,b,100)
ordonnees = [f(x) for x in abscisses]

#Création des figures
fig, (ax1, ax2) = plt.subplots(1, 2,figsize=(15, 6))
ax1.plot(abscisses,ordonnees)
ax1.plot([a,b],[0,0],'r--')
courbeVert, = ax1.plot([],[],'g--',)
courbeConvergence, = ax2.plot([],[],color="green")

#Réglage des axes
ax2.set_xlim(( 0, 2))
ax2.set_ylim((0, 2))

def init():
    return (courbeVert,)

def animate(i):
    x =evolutionAbscisse[i]
    estim = estimations[-1]
    if f(x)<=0:
        estimations.append(x)
    else:
        ax2.plot([estim,estim],[a,b],'--',color='orange')
        ax2.plot([estim+pas,estim+pas],[a,b],'--',color='orange')
        return (courbeVert,)
        estimations.append(estim)
    courbeVert.set_data([x,x],[-2,2])
    courbeConvergence.set_data(evolutionAbscisse[:i+2],estimations)
    ax1.set_title("x $\simeq$ {0:.2f}".format(x))
    ax2.set_title("{0:.2f} $\leq$ estimation $\leq$ {1:.2f}".format(estim+pas,estim+2*pas))
    return (courbeVert,)

plt.close ()
ani = matplotlib.animation.FuncAnimation(fig, animate, frames=nbFrames,init_func=init,interval=300)
# l'un ou l'autre
HTML(ani.to_jshtml())
#HTML(ani.to_html5_video())
Out[11]:


Once Loop Reflect

Encadrement de $\sqrt{2}$ à $10^{-n}$ par balayage

On cherche à déterminer un encadrement de $\sqrt{2}$ à $10^{-2}$ près par balayage. La valeur approchée précédemment obtenue étant la plus grande valeur de $x$ pour laquelle $f(x)\leq 0$, si on ajoute à $x$ la valeur du pas (ici $10^{-2}$), on a $f(x+10^{-2})>0$ et donc $x\leq\sqrt{2}<x+10^{-2}$, ce qui donne un encadrement de $\sqrt{2}$.

In [5]:
a = 0
b = 2
N = 200

pas = (b-a)/N

x = a        
while f(x)<0:
    x = x + pas

estimationDroite = x
estimationGauche = x - pas  

print("Encadrement de racine de 2 à 10**{-2} près:",estimationGauche,estimationDroite)        

Encadrement de racine de 2 à 10**{-2} près: 1.410000000000001 1.420000000000001
Suggestions pédagogiques

  • Expliquer un programme

    Que fait l'instruction de la ligne 12 ?

  • Compléter un programme

    Le programme précédent étant fourni en remplaçant la ligne 12 par estimationDroite = ..., demander aux élèves de compléter la ligne 12.

Animation susceptible d'être présentée aux élèves

Balayage à double sens : à partir de $0$ par valeurs croissantes et à partir de $2$ par valeurs décroissantes.

In [6]:
%matplotlib inline
import matplotlib.animation
from IPython.display import HTML

# constantes
nbFrames = 20
nbSubdivision = 30
a = 0
b = 2
pas = (b-a)/nbSubdivision
estimations = [0]
estimationsD = [2]
evolutionAbscisse = subdivisionIntervalle(a,b,nbSubdivision)
evolutionAbscisseD = evolutionAbscisse[::-1]
trouve = False

# points de la courbe pour le tracé
abscisses = subdivisionIntervalle(a,b,100)
ordonnees = [f(x) for x in abscisses]

#Création des figures
fig, (ax1, ax2) = plt.subplots(1, 2,figsize=(15, 6))
ax1.plot(abscisses,ordonnees)
ax1.plot([a,b],[0,0],'r--')
courbeVert, = ax1.plot([],[],'g--',)
courbeViolette, = ax1.plot([],[],'m--',)
courbeConvergenceG, = ax2.plot([],[],color="g", label='Balayage gauche')
courbeConvergenceD, = ax2.plot([],[],color="m", label='Balayage droit')

#Réglage des axes
ax2.set_xlim(( 0, 2))
ax2.set_ylim((0, 2.1))

def init():
    trouve = False
    borneA = 0
    borneB = 2
    return (courbeVert,)

def animate(i):
    global trouve,borneA,borneB
    x1 =evolutionAbscisse[i]
    x2 = evolutionAbscisseD[i]
    estim = estimations[-1]
    estimD = estimationsD[-1]
    
    
    if trouve:
        ax2.plot([borneA,borneA],[a,b],'--',color='orange')
        ax2.plot([borneB,borneB],[a,b],'--',color='orange')
        ax2.set_title("{0:.2f} $\leq$ estimation $\leq$ {1:.2f}, pas = {2:.2f}".format(borneA,borneB,pas))
        return (courbeVert,)
    
    if f(x1)<=0:
        estimations.append(x1)
    else:
        trouve = True
        borneA = estim
        borneB =  estim+pas
    if f(x2)>=0:
        estimationsD.append(x2)
    else:
        trouve = True
        borneA = estimD-pas
        borneB =  estimD
        return (courbeVert,)
    evolutionInverse = evolutionAbscisse[:i+2]
    courbeVert.set_data([x1,x1],[-2,2])
    courbeViolette.set_data([x2,x2],[-2,2])
    courbeConvergenceG.set_data(evolutionAbscisse[:i+2],estimations)
    courbeConvergenceD.set_data(evolutionAbscisseD[:i+2],estimationsD)
    ax1.set_title("$x_1$ $\simeq$ {0:.2f}, $x_2$ $\simeq$ {1:.2f}".format(x1,x2))
    #ax2.set_title("Intervalle : [{0:.2f},{1:.2f}]".format(estim,estimD))
    ax2.set_title("{0:.2f} $\leq$ estimation $\leq$ {1:.2f}".format(estim,estimD))
    return (courbeVert,)

ax2.legend()
plt.close()
ani = matplotlib.animation.FuncAnimation(fig, animate, frames=nbFrames,init_func=init,interval=300)
# l'un ou l'autre
HTML(ani.to_jshtml())
#HTML(ani.to_html5_video())
Out[6]:


Once Loop Reflect