Accueil / Contact

Bienvenu sur :

logo-mathetpython







ESPACE PRIVE

EXERCICES PREMIERE: SPECIALITE MATH


NOMBRE DERIVE,TANGENTE:

On donne l’algorithme suivant:
En langage naturel
Pour i allant de 1 à 4 Faire
h ← h×10^(-i)
d ←( f(1+h)-f(1)) / h
# Le symbole ^ signifiant puissance #
FIN pour

1.Que représente d en mathématique et que fait cet algorithme?
2.Ecrire ce programme en langage Python avec f définie sur R par f(x)=x²+1
3.Modifier cet algorithme pour afficher sous forme de liste les différentes valeurs de d obtenues.
4.Ecrire une fonction nommée nombre_derive d'arguments (ou de paramètres) f,a,n avec :f la fonction,a ,l'abscisse d'un point M de la courbe représentative de f et n ,(entier qui permet à h de prendre successivement les valeurs 0,1;0,01;0,001;0,0001).Cette fonction devra permettre de suggérer la valeur du nombre dérivé de f en a.
On donne l’algorithme suivant:
En langage Python
import matplotlib.pyplot as plt
import numpy as np
from math import*
def f(x):
   return x**2
def nombre_derive(f,a,h):
   return (f(a+h)-f(a))/h
plt.grid(True)
x=np.linspace(-5,5,100)
y=f(x)
plt.plot(x,y, color="black")
plt.show()

1.A quoi servent les trois premières instructions du programme?
2.Que fait ce programme ?
3.Compléter ce programme pour qu'il affiche la tangente à la courbe représentative de f au point d'abscisse 2.On définira une nouvelle fonction appelée trace_tangente avec trois arguments f,a,et h.
4.Compléter ce programme pour qu'il affiche les tangentes à la courbe représentative de f aux points d'abscisses a avec: a un entier variant de -2 à 7.On définira une nouvelle fonction appelée trace_plusieurs_tangentes
La methode de Newton pour résoudre f(x)=0.

Isaac Newton (4 janvier 1643 G – 31 mars 1727) mathématicien, physicien, alchimiste,astronome et théologien anglais,(puis britannique).
Cette méthode part du principe que les absisses des points d'intersection entre les tangentes sucessives(au voisinage de xo solution de f(x)=0) et l'axe des abscisses se rapprochent de xo.
Dans un premier temps on choisit un point A(xa,f(xa)) appartenant à la courbe représentative de f pour lequel son abscisse est proche de xo. De plus il ne doit pas avoir de changement de variation pour f entre xo et xa , puis on construit la tangente(TA) au point A.
On repère ensuite la valeur de l'abscisse du point d'intersection entre cette tangente (TA) avec l'axe des abscisses.On note par exemple x1 cette valeur
On construit ensuite la tangente à la courbe représentative de f au point d'abscisse x1 trouvé précédemment.
On réitère ensuite le principe:
Les abscisses des points d'intersection entre l'axe des abscisses et les différentes tangentes se rapprochent de la solution de l'équation f(x)= 0.

Exemple:On donne ci dessous la courbe représentative de f définie sur IR par f(x)= x² -2.
Une solution positive à l'équation f(x)= 0 est √2.
Avec la méthode de Newton on peut donc trouver une approximation de √2.
On a tracé ci dessous les deux premières tangentes au point A et C de la courbe de f.
fonction
1.Donner d'après le graphique un encadrement à une décimale près de √2.
2.On note a l'abscisse du point A et b l'abscisse du point B.Montrer que b= a- f(a)/f'(a)
3.Compléter le programme ci-dessous pour donner 15 valeurs des abscisses des points d'intersections des 15 tangentes avec l'axe des abscisses.En déduire une approximation de √2.
En langage Python
def f(x):
   return x**2-2
def derf(x) :
   return 2*x
def methode_newton(f,derf,a):
   b=.............
   for i in range (......) :
     a=.......
     b=a-f(a)/derf(a)
   print(a)
print(methode_newton(f,derf,2.0))

4.A quoi sert l'algorithme suivant:
En langage Python
def f(x):
  return x**2-2
def derf(x) :
  return 2*x
def appro_newton(f,derf,a,epsilon):
  b=a-f(a)/derf(a)
  while abs(b-a)>epsilon:
    a=b
    b=a-f(a)/derf(a)
  return a
print(appro_newton(f,derf,2.0,10**(-7)))
Soit f une fonction définie sur R par f(x)= ax²+bx+c avec a , b, c des réels. On donne l’algorithme suivant:
En langage Python
def derivee_polynome_degre2(x,a,b) :
    for x in range(10):
        d=2*a*x+b
        print ("le nombre derive de f pour x={} est {}".format(x,d))
derivee_polynome_degre2(1,-3/2,-1)

1.Que représente x,a,b?
2.Que devrait afficher ce programme?
3.Modifier ce programme pour qu'il affiche les nombre dérivés d'une fonction polynôme de degré 2 pour x variant entre -1 et 4 avec un pas de 1.
4.Modifier ce programme à l'aide d'une fonction de paramètres x,a,b,c,d pour qu'il affiche les nombre dérivés d'une fonction polynôme de degré 3 pour x variant de 0 à 5 avec un pas de 1.
Réponses possibles

Pour accéder aux réponses,Cliquez !
EX1:
Question 1: d représente le taux de variation de f entre 1+h et h.
Lorsque h se rapproche de la valeur 0, d donne une approximation du nombré derivé de f en 1.
Question 2: un programme possible:
En langage Python
def f(x):
   return x**2+1
for i in range(1,5):
    h= 10**(-i)
& nbsp  d=(f(1+h)-f(1))/h
    print(h,d)

Question 3: un programme possible:
En langage Python
def f(x):
    return x**2+1
L=[]
for i in range(1,5):
    h=10**(-i)
    d=(f(1+h)-f(1))/h
    L.append(d)
print(L)
Question 4: un programme possible:
En langage Python
def f(x):
   return x**2+1
def nombre_derive(f,a,n):
   L=[]
   for i in range(1,n+1):
     h=10**(-i)
     d=(f(a+h)-f(a))/h
     L.append(d)
   print(L)
print(nombre_derive(f,2,4))
EX2: Question 1:Ces trois lignes permettent d'importer certaines fonctions des bibliothéques pour tracer la courbe (matplotlib) ou définir x ( avec numpy). On importe toutes les fonctions de la bibliothèque math. définie par f(x)= x²+2x+3
Question 2: Ce programme affiche la courbe représentative de la fonction f définie sur [-5,5].
Question 3: un programme possible:
En langage Python
import matplotlib.pyplot as plt
import numpy as np
from math import *
def f(x):
    return x**2
def nombre_derive(f,a,h):
    return (f(a+h)-f(a))/h
plt.grid(True)
plt.ylabel("axe des ordonnées")
plt.xlabel("axe des abscisses")
x=np.linspace(-5,5)
y=f(x)
plt.plot(x,y, color="black")
def trace_tangente(f,a,h):
    y1= nombre_derive(f,a,h)*(x-a)+f(a)
    plt.plot(x,y1, color="red")
    plt.show()
trace_tangente(f,2,0.000001)
Question 4: un programme possible:
En langage Python
import matplotlib.pyplot as plt
import numpy as np
from math import *
def f(x):
    return x**2
def nombre_derive(f,a,h):
    return (f(a+h)-f(a))/h
plt.grid(True)
plt.ylabel("axe des ordonnées")
plt.xlabel("axe des abscisses")
x=np.linspace(-5,5)
y=f(x)
plt.plot(x,y, color="black")
def trace_plusieurs_tangentes(f,a,h):
  for a in range(-2,8):
    y1= nombre_derive(f,a,h)*(x-a)+f(a)
    plt.plot(x,y1, color="red")
  plt.show()
trace_plusieurs_tangentes(f,-2,0.000001)
EX3:
Question 1: Sur le graphique on peut dire que racine de deux est proche de 1,4O ou 1,41.
Question 2: l'équation de la tangente au point d'abscisse a est égale a y= f'(a)(x-a) + f(a)
on pose l'équation y= 0 <=> 0 = f'(a)(x-a) +f(a)
En isolant x dans l'équation on trouve le résultat voulu.
Question 3: un programme possible:
En langage Python
def f(x):
  return x**2-2
def derf(x) :
  return 2*x
def zeronewton(f,derf,a):
  b=a-f(a)/derf(a)
  for i in range (15) :
    a=b
    b=a-f(a)/derf(a)
    print(a)
print(zeronewton(f,derf,2.0))
Question 4: Le programmre s'arrête dès que l'écart entre les abscisses consécutives trouvées est inférieur à 0,0000001.On a alors une très bonne approximation de racine de deux.
EX4:
Question 1: x est un réel qui varie,a et b sont des réels donnés, coefficient respectivement de x² et de x dans le polynôme de degre 2.
Question 2:Ce programme donne les nombres dérivés de f pour x entier variant de 0 à 9.
Question 3: un programme possible:
En langage Python
def derivee_polynome_degre2(x,a,b) :
    for x in range (-1,5):
      d=2*a*x+b
      print("le nombre derive de {} est {}".format(x,d))
derivee_polynome_degre2(1,-3/2,-1)

Question 4: un programme possible:
En langage Python
def derivee_polynome_degre3(x,a,b,c,d) :
    for x in range (6):
      f=3*a*x**2+b*x +c
      print("le nombre derive de {} est {}".format(x,f))
derivee_polynome_degre3(1,-3/2,-1,3,1)


					
					
logotop