Activité d'introduction de la notion de dérivée en distinguant le point de vue local (nombre dérivé) et le point de vue global (fonction dérivée).
Le nombre dérivé d’une fonction $f$ en un point $x_0$ est la limite (lorsqu'elle existe) du taux de variation de $f$ en ce point. C'est la limite de la pente des sécantes issues du point de la courbe d'abscisse $x_0$ : $$ \lim _{h\rightarrow 0} \frac{f(x_0+h)-f(x_0)}{h}=f'(x_0).$$
La fonction coefDirSecante
calcule la pente de la sécante à la courbe représentative d'une fonction $f$ préalablement définie (ci-dessous la fonction carré) entre le point d'abscisse $x_0$ et le point d'abscisse $x_0+h$.
def f(x):
return x**2
def coefDirSecante(x0,h):
coef=(f(x0+h)-f(x0))/h
return coef
coefDirSecante(1,0.1)
2.100000000000002
Suggestions pédagogiques
Expliquer un programme
Que représentent les paramètres de la fonction coefDirSecante
?
Écrire un programme
f
.coefDirSecante
.Tester la fonction coefDirSecante
pour $x_0=1$ et pour de petites valeurs de $h$.
En déduire une valeur approchée de $f'(1)$ où $f$ désigne la fonction carré.
Sécante passant par les points $(x_0, f(x_0))$ et $(x_0+h,f(x_0+h))$
On cherche à tracer la sécante à la courbe représentative de la fonction $f$ passant par les points d'abscisses $x_0$ et $x_0+h$. La fonction secante
prend en paramètres les deux nombres flottants $x_0$ et $h$, et renvoie les listes $[x_0,x_0+h]$ et $[f(x_0),f(x_0+h)]$ afin de tracer la sécante avec matplotlib
.
def secante(x0,h):
return [x0,x0+h],[f(x0),f(x0+h)]
secante(1,0.1)
([1, 1.1], [1, 1.2100000000000002])
Liste des coefficients directeurs de sécantes en un point
On souhaite afficher la liste des pentes des sécantes à la courbe représentative de la fonction $f$ passant par les points d'abscisse $x_0$ et $x_0+h$ pour des valeurs de $h$ tendant vers $0$.
def listeCoefDir(n):
liste = [1-i/n for i in range(n)]
x_0=1
return [coefDirSecante(x_0,h) for h in liste]
listeCoefDir(10)
[3.0, 2.9, 2.8000000000000003, 2.6999999999999997, 2.600000000000001, 2.5, 2.399999999999999, 2.3000000000000003, 2.2, 2.1000000000000023]
Représentations graphiques
Tracé d'une sécante en un point
Dans cette partie, on trace la sécante à la courbe de la fonction $f$ entre le point d'abscisse $1$ et le point d'abscisse $1+h$.
Importation de la bibliothèque graphique
%matplotlib inline
import matplotlib.pyplot as plt
Fonction renvoyant la liste des éléments de la subdivision d'un intervalle $[a,b]$ en $N$ sous-intervalles de même longueur
Le nom de la fonction est subdivisionIntervalle
.
Elle prend comme paramètres :
les bornes $a$ et $b$ de l'intervalle $[a,b]$
le nombre $N$ de sous-intervalles de la subdivision
Elle renvoie la liste des éléments de la subdivision.
N.B : on considère ici des subdivisions à pas constant.
def subdivisionIntervalle(a,b,N):
pas = (b-a)/N
return [a+i*pas for i in range(N+1)]
Suggestions pédagogiques
Le programme précédent étant fourni, demander aux élèves d'expliquer :
pas
et comment elle est calculée ;pas= ...
, demander aux élèves de compléter la ligne 2.[... for i in range(N+1)]
, demander aux élèves de compléter la ligne 3.Tester la fonction subdivisionIntervalle
sur l'intervalle $[1,8]$ subdivisé en 8 parties égales.
Représentation graphique de la fonction $f$ et tracé d'une sécante
Le programme ci-dessous est séparé en trois parties :
# constantes
a = 0
b = 2
h =0.75
x0 = 0.5
nbSubdivision = 1000
# points de la courbe
abscisses = subdivisionIntervalle(a,b,nbSubdivision)
ordonnees = [f(x) for x in abscisses]
abscisseSecante,ordonneeSecante = secante(x0,h)
# paramètres figure
fig, ax1 = plt.subplots(1,figsize=(6, 6))
ax1.plot(abscisses,ordonnees,'r')
ax1.plot(abscisseSecante,ordonneeSecante,'b+-')
ax1.set_title('Sécante en x0={} pour h={}'.format(x0,h,coefDirSecante(1,h)))
plt.show()
Le programme suivant permet de créer deux animations parallèles : la première illustre la convergence des sécantes issues du point d'abscisse $1$ vers la tangente en ce point et la seconde illustre la convergence de la pente de ces sécantes vers le nombre dérivé. L'animation peut être utilisée telle quelle en classe par l'enseignant. Il peut aussi, s'il le souhaite, modifier les constantes pour changer l'animation. La compréhension et la connaissance de ce progamme ne sont pas attendues des élèves.
%matplotlib inline
import matplotlib.animation
from IPython.display import HTML
# constantes
a = 0
b = 2
nbSubdivision =1000
x0 = 1
n =30
# points de la courbe
abscisses = subdivisionIntervalle(a,b,nbSubdivision)
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,'r')
courbeSegments, = ax1.plot([],[],'.-',color="#1e7fcb")
courbeConvergence, = ax2.plot([],[],color="#1e7fcb")
#Réglage des axes
ax1.set_xlim(( x0-1, x0+1))
ax1.set_ylim(((x0-1)**2, (x0+1)**2))
ax2.set_xlim(( 0, n))
ax2.set_ylim((2*x0-0.2, 2*x0+1))
pentes=[]
# initialisation
def init():
global courbeSegments,courbeConvergence
courbeSegments.set_data([], [])
courbeConvergence.set_data([], [])
return (courbeSegments,)
# fonction d'animation
def animate(i):
global courbeSegments,courbeConvergence
#Calcul de h
h=1/(i+1)
#Nouvelles extrémités de la sécante
abscisseSecante,ordonneeSecante = secante(x0,h)
#Tracé de la sécante
courbeSegments.set_data(abscisseSecante,ordonneeSecante)
#Ajout de la pente à la liste des pentes
pentes.append(coefDirSecante(x0,h))
#Tracé de la courbe des pentes
courbeConvergence.set_data(range(1,i+2),pentes[:i+2])
# Titre de la figure 1
ax1.set_title('Sécante pour $x_0$={:.2f} et h={:.2f}'.format(x0,h))
#Ajout du tracé de la tangente et de la valeur limite de la dérivée lorsque h<0.1
if i>10:
ax1.plot([x0-1+1/(2*x0),x0+1],[(x0-1)**2,2*x0+x0**2],color="#47255f")
ax2.plot([0,n],[2*x0,2*x0],color="#47255f")
ax2.set_title('Pente de la sécante $\simeq${:.2f}'.format(pentes[-1]))
return (courbeSegments,)
plt.close ()
ani = matplotlib.animation.FuncAnimation(fig, animate, frames=n,init_func=init,blit=False,interval=500)
# l'un ou l'autre
HTML(ani.to_jshtml())
#HTML(ani.to_html5_video())
La fonction qui, à tout réel $x$, associe le nombre dérivé de $f$ en $x$ est la fonction dérivée de $f$ et se note $f'$.
La fonction suivante, nommée listeCoefDir
, renvoie la liste des coefficients directeurs des sécantes à la courbe de la fonction $f$ sur l'intervalle $[0;2]$ pour une subdivision de cet intervalle en $n$ sous-intervalles de même longueur. Elle prend en paramètre ce nombre $n$.
## Alternative en utilisant la fonction subdivisionIntervalle ##
def listeCoefDir(n):
abscisses = subdivisionIntervalle(0,2,n)
h=2/n
return [coefDirSecante(x,h) for x in abscisses]
print(listeCoefDir(10))
[0.20000000000000004, 0.6000000000000001, 1.0000000000000002, 1.4000000000000001, 1.7999999999999994, 2.1999999999999997, 2.6, 3.0000000000000004, 3.3999999999999986, 3.799999999999999, 4.200000000000004]
Suggestions pédagogiques
Remplacer les lignes 4 et 5 du programme précédent par h=...
et return [... for x in abscisses]
et demander aux élèves de les compléter.
Le programme précédent étant fourni, demander aux élèves d'expliquer :
Tester la fonction ListeCoefDir
pour $n=10$ (remplacer la ligne 7 par ...
dans le programme fourni aux élèves).
Le programme suivant trace une courbe approchée de la fonction dérivée de la fonction carré sur l'intervalle $[0;2]$ subdivisé en $n$ sous-intervalles. L'ordonnée du point d'abscisse $x$ de cette courbe est égale au taux de variation (pente de la sécante) de la fonction carré entre $x$ et $x+\dfrac{2}{n}$. La courbe approchée est la droite d'équation $y=2x+\dfrac{2}{n}$.
%matplotlib inline
n=50
abscisses = subdivisionIntervalle(0,2,n)
ordonnees = listeCoefDir(n)
#paramètres figure
fig, ax1 = plt.subplots(1,figsize=(15, 6))
ax1.plot(abscisses,ordonnees,'.', color="#1e7fcb")
ax1.set_xlim(( 0, 2))
ax1.set_ylim((0, 4))
ax1.set_title('Représentation des coefficients directeurs des sécantes pour un pas de {:.2f}'.format(2/n))
plt.show()
Suggestions pédagogiques
L'animation suivante permet de visualiser une approximation de la courbe de la dérivée de la fonction carré. Pour chaque valeur de $h$, le point d'abscisse $x$ de la courbe approchée a pour ordonnée la pente de la sécante, à savoir $\dfrac{(x+h)^2-x^2}{h}=2x+h$. Cela fournit une famille de droites qui tendent vers la droite d'équation $y=2x$ lorsque le pas $h$ tend vers $0$. Ici le pas $h$ est la longueur d'une subdivision de l'intervalle.
%matplotlib inline
#ctes:
n =60
#Création des figures
fig, ax1 = plt.subplots(1, 1,figsize=(6, 12))
courbePenteSecantes, = ax1.plot([],[],'.',color="#1e7fcb")
#Réglage des axes
ax1.set_xlim(( 0, 2))
ax1.set_ylim((0, 4))
def init():
global courbePenteSecantes
courbePenteSecantes.set_data([], [])
return (courbeSegments,)
def animate(i):
global courbePenteSecantes
abscisses = subdivisionIntervalle(0,2,i+1)
ordonnees=listeCoefDir(i+1)
#Tracé de la courbe des pentes de sécantes
courbePenteSecantes.set_data(abscisses,ordonnees)
# Titre de la figure 1
#Calcul de h
h=1/(i+1)
ax1.set_title('Courbe des pentes des sécantes de la fonction carrée pour h={:.2f}'.format(h))
return (courbePenteSecantes,)
#plt.show()
plt.close ()
ani = matplotlib.animation.FuncAnimation(fig, animate, frames=n,init_func=init,blit=False,interval=200)
# l'un ou l'autre
HTML(ani.to_jshtml())
#HTML(ani.to_html5_video())
En changeant la définition de la fonction $f$, on peut étudier de la même manière le nombre dérivé en un point et la fonction dérivée d'autres fonctions, par exemple de la fonction cube.
def cube(x):
return x**3
def coefDirSecanteCube(a,h):
coef=(cube(a+h)-cube(a))/h
return coef
print(coefDirSecante(1,0.1))
2.100000000000002
La fonction suivante, nommée listeCoefDir
, renvoie la liste des coefficients directeurs des sécantes à la courbe de la fonction cube aux points de cette courbe correspondant à une subdivision de l'intervalle $[-2;2]$ en $n$ sous-intervalles de même longueur. Elle prend en paramètre ce nombre $n$.
def listeCoefDirCube(n):
abscisse = subdivisionIntervalle(-2,2,n)
h=4/n
return [coefDirSecanteCube(x,h) for x in abscisse]
print(listeCoefDirCube(10))
[9.759999999999996, 5.920000000000001, 3.039999999999999, 1.1199999999999994, 0.1599999999999999, 0.16000000000000003, 1.1200000000000012, 3.0400000000000005, 5.920000000000001, 9.759999999999996, 14.559999999999995]
%matplotlib inline
n=50
abscisse = subdivisionIntervalle(-2,2,n)
ordonnee=listeCoefDirCube(n)
#paramètres figure
fig, ax1 = plt.subplots(1,figsize=(10, 10))
ax1.plot(abscisse,ordonnee,'.', color="#1e7fcb")
ax1.set_xlim(( -2, 2))
ax1.set_title('Courbe approchée de la dérivée de la fonction cube pour un pas de {:.3f}'.format(4/n))
plt.show()
Suggestions pédagogiques
L'animation suivante est une version dynamique de ce qui précède.
%matplotlib inline
#constantes:
n =50
#Création des figures
fig, ax1 = plt.subplots(1, 1,figsize=(6, 12))
courbePenteSecantesCube, = ax1.plot([],[],'.',color="#1e7fcb")
#Réglage des axes
ax1.set_xlim(( -2, 2))
ax1.set_ylim(( 0, 12))
pentes=[]
def init():
global courbePenteSecantesCube
courbePenteSecantesCube.set_data([], [])
return (courbePenteSecantesCube,)
def animate(i):
global courbePenteSecantesCube
#Calcul des pentes de sécante
abscisse = subdivisionIntervalle(-2,2,i+1)
ordonnee=listeCoefDirCube(i+1)
#Tracé de la courbe des pentes de sécantes
courbePenteSecantesCube.set_data(abscisse,ordonnee)
# Titre de la figure 1
#Calcul de h
h=4/(i+1)
ax1.set_title('Courbe des pentes de sécantes de la fonction cube pour h={:.2f}'.format(h))
return (courbePenteSecantesCube,)
plt.close()
ani = matplotlib.animation.FuncAnimation(fig, animate, frames=n,init_func=init,blit=False,interval=200)
# l'un ou l'autre
HTML(ani.to_jshtml())
#HTML(ani.to_html5_video())