Résumé 18

18
Approximation de racines et d’intégrales :
Numpy/Scipy et Scilab
V.
Solutions approchées d’équations : fsolve
⋄ Avec S CILAB, on utilise la fonction fsolve
sous la forme fsolve(x0,f) où f est la fonction dont on veut déterminer une racine et x0
est une valeur de départ pour l’algorithme de
recherche. La fonction fsolve retourne 3 valeurs : la valeur approchée de la racine, la valeur de la fonction en ce point (qui doit être
« assez petite » si tout s’est bien passé) et une
troisième valeur qui indique comment l’algorithme s’est déroulé (vaut 1 si tout s’est bien
passé).
⋄ Si on a seulement besoin de la première ou
des deux premières valeurs on écrit :
x=fsolve(1,f)
x =
1.4142136
deff('y=f(x)','y=x^2-2')
[x,fx,info]=fsolve(1,f)
info =
1.
fx =
- 4.441D-16
x =
1.4142136
[x,fx]=fsolve(1,f)
fx =
- 4.441D-16
x =
1.4142136
⋄ Avec N UMPY/S CIPY , on utilise la commande fsolve du package scipy.optimize
sous la forme fsolve(f,x0) (x0 est une valeur de départ pour l’algorithme et f la fonction dont on cherche une racine) :
from scipy.optimize import fsolve
print fsolve(lambda x:x**2-2,1)
[ 1.41421356]
http://alexandre.boisseau.free.fr/Prive/WWW/InfoPCSI/resume18.pdf
⋄ Le résultat obtenu est un tableau à 1 dix=fsolve(lambda x:x**2-2,1)[0]
mension (et de taille 1), pour obtenir la raprint x
cine on ne garde que la première composante.
1.41421356237
VI.
Approximations d’intégrales : intg et quad
⋄ Avec S CILAB, on utilise la fonction intg
sous la forme intg(a,b,f) où f est la fonction à intégrer et a et b sont les bornes de l’intervalle. Cette fonction retourne deux valeurs :
une approximation de l’intégrale et une estimation de l’erreur absolue commise dans l’approximation.
⋄ Si on veut uniquement connaitre l’approximation de l’intégrale, on écrit :
B Ce calcul peut échouer sur des intégrales
a priori simples (explications données en
cours). Ici intg(-1,1,g) ne marche pas. On
augmente alors la tolérance.
deff('y=f(x)','y=x^2')
[I,deltaI]=intg(0,1,f)
deltaI =
3.701D-15
I =
0.3333333
I=intg(0,1,f)
I =
0.3333333
deff('y=g(x)','y=x')
intg(-1,1,g,1e-10)
ans =
0.
⋄ Avec N UMPY/S CIPY, on utifrom scipy.integrate import quad
lise la fonction quad du paprint quad(lambda x:x**2,0,1)
ckage scipy.integrate sous
la forme quad(f,a,b).
(0.3333333333333333,
3.700743415417188e-15)
Remarque. Le résultat obtenu est un tuple. C’est un type particulier qui se rapproche des
listes à deux exceptions près : un tuple s’écrit avec des parenthèses (les listes s’écrivent avec
des crochets) et n’est pas modifiable (par exemple on ne peut pas ajouter d’élément ou
changer la valeur d’une composante).
⋄ Ici le tuple est composé de deux valeurs :
x=quad(lambda x:x**2,0,1)[0]
la valeur approchée de l’intégrale et une esprint x
timation de l’erreur absolue commise dans
l’approximation. Si on n’a besoin de de la 0.333333333333
valeur approchée, on ne conserve que la 1re
composante du tuple.
Remarque. On a donné ici une description simplifiée des fonctions de résolution d’équations et de calcul d’intégrales. Pour une présentation plus détaillée, avec S CILAB :
help fsolve, help intg ;
avec P YTHON :
help("scipy.optimize.fsolve"), help("scipy.integrate.quad").