Approximation de la fonction exponentielle par des polynomes

Approximation de la fonction
exponentielle par des
polynomes
Un exemple d'utilisation de Python pour
des calculs sur les polynomes et sur les
fonctions mathématiques
http://people.via.ecp.fr/~dhorv/form
ations
Plan
●
●
Représentation d'un polynome
Calcul de la valeur d'un polynome en un
point
●
Création du polynome exponentiel
●
Ecriture du programme complet
●
Comparaison avec les valeurs attendues,
limites de la méthode
Représentation d'un polynome
Un polynome s'écrit de la façon suivante :
a + bx + cx² + ...
Dans notre exemple, on codera le polynome comme une liste de coefficients :
p = [a,b,c...]
p[i] est donc le coefficient du terme de degré i. (Rappel : on commence à 0)
Ceci permet :
●
●
●
Un calcul simple des additions et soustractions par exemple
Une représentation proche de la représentation classique
Une utilisation naturelle des indices dans le parcours de la liste
Calcul de la valeur d'un
polynome en un point
def calculePolynome(p,x):
'''
Cette fonction permet de calculer la valeur d'un polynome P en un point x
'''
#Sert à stocker les valeurs des puissances successives de x
accumulateur = 1
#Contiendra le résultat
resultat = 0
#L'indice de boucle
i=0
#On parcourt la liste qui décrit le polynome
while i < len(p):
#On ajoute à chaque étape le terme de puissance i
resultat += p[i] * accumulateur
#On prépare la puissance suivante de x
accumulateur *= x
#On passe à l'étape suivante
i += 1
#Le résultat est renvoyé
return resultat
Création du polynome
exponentiel
def creeExp(n):
'''
Cette fonction donne le polynome de degré n associé à la fonction exponentielle
'''
#On initialise la liste qui sera renvoyée
p = range(n)
#On stocke les factorielles successives.
#Note : on prend le type float pour pouvoir utiliser les grands nombres
factorielle = 1.0
#L'indice de boucle
i=0
while i < n:
#La valeur du coefficient pour le degré i
p[i] = 1 / factorielle
#On prépare la factorielle suivante
factorielle *= (i+1)
i += 1
return p
Ecriture du programme complet
def exp(x):
'''
Ceci est la fonction qui rend une approximation de l'exponentielle
'''
#Le degré du polynome qui va approximer
#On pourrait calculer n à partir de x pour conserver la précision
n = 50
#On créé notre polynome
p = creeExp(n)
#On calcule l'approximation de exp(x)
resultat = calculePolynome(p,x)
#On renvoie le résultat
return(resultat)
def exp2(x):
''' Ceci est la version compressée de la fonction précédente '''
return(calculePolynome(creeExp(50),x))
Comparaison avec les valeurs
attendues, limites de la
méthode
#Import du module math de Python, qui contient cos, sin, exp...
Import math
#Le point où l'on va faire l'approximation
#On le demande à l'utilisateur
x = float(raw_input("Valeur de x : "))
#Affichage de la différence relative entre la valeur voulue et la valeur exacte
Print 100 * (exp(x) – math.exp(x)) / math.exp(x)
Résultats et limites :
Une erreur inférieure à 1% pour des valeurs faibles de x (x < 10)
●
Une erreur qui augmente très fort avec la valeur de x
●
Un calcul répétitif du polynome (qui pourrait être défini une fois pour toutes)
●
Un dépassement rapide de la capacité en mémoire (même avec le type float) à cause de la
factorielle et des puissances. Une solution est envisageable (division par k après
multiplication par x à chaque boucle).
●