page1
Page 5 / 5
Mémento Python 3 pour le calcul scientifique
Calcul formel avec sympy (suite)
Sommes, finies ou infinies
Si L est une séquence d'expressions symboliques, sum(L) renvoie leur somme
Ak est une expression symbolique de k
k,n = sb.symbols("k,n", integer=True)
sb.summation(Ak,(k,kmin,kmax)) 
Exemple : sb.summation(k**2,(k,0,n)).factor() 
Il est conseillé d'utiliser un notebook jupyter (voir
https://jupyter.readthedocs.io/en/latest/)
avec en en-tête pour avoir de belles formules
mathématiques à l'écran les instructions ci-contre :
import sympy as sb
sb.init_printing()
Intégrales et primitives
Expr. symboliques A (de t) et B (de x et y)
x,y,t = sb.symbols("x,y,t", real=True)
A.integrate(t) ou sb.integrate(A,t)
 primitive de A par rapport à t
B.integrate(x,y) ou sb.integrate(B,x,y)
 primitive de B par rapport à x et à y
A.integrate((t,tinf,tsup)) ou sb.integrate(A,(t,tinf,tsup))
 intégrale de tinf à tsup de A
sb.integrate(B,(x,a,b),(y,c,d))
 intégrale double de B sur [a,b][c,d]
sb.integrate(t**x,(t,1,sb.oo)) 
sb.integrate(t**x,(t,1,sb.oo),conds="none") 
(on se place dans le cas où l'intégrale est définie)
Expression symbolique A (de x)
A.series(x,x0,n)  Développement limité de A en x0 à l'ordre n
Exemple : sb.cos(2*x).series(x,0,6)  1-2x2+2x4/3+O(x6)
A.series(x,x0,n).replace(sb.O,lambda *args : 0)
 Développement limité sans le O( (x-x0)n )
Développement limité
Réécriture par substitution
Expression symbolique A
B = A.replace(x,y)  B s'obtient en remplaçant x par y dans A
x peut être un symbole, une fonction, ou autre chose*
Exemples : f(x).replace(x,y)  f(y)
(x**2).replace(x,x+y)  (x+y)**2
(x**2).replace(2,y+1)  x**(y+1)
f(x).replace(f,g)  g(x)
sb.cos(x).replace(sb.cos,lambda t : t**2)  x**2
dico est un dictionnaire
B = A.xreplace(dico)  B s'obtient en remplaçant simultanément dans A toutes les clefs de dico par les expressions correspondantes ;
ces clefs sont des symboles, ou des « sous-expressions complètes »*
Exemples : (x+2*y).xreplace({x:y,y:x})  2*x+y
(x+2*y).xreplace({x:y,y:y+1})  3*y+2
(x+x**2).xreplace({x**2:y})  x+y
Calcul littéral V = sb.pi*r**2*h suivi d'une application numérique :
float(V.xreplace({r:0.1,h:0.2}))  6.283e-03
(*) Voir ci-dessous : « Manipulation avancée d'expressions ».
Approximation par différences finies
On cherche à approcher la
dérivée d-ième d'une fonction indéfinie f au point x à l'ordre n.
Le nombre de points discrétisés à considérer est d+n.
Ces points sont donnés dans une séquence S, par exemple (x-h,x,x+h,x+2*h)
f = sb.Function("f")
x,h = sb.symbols("x,h", real=True)
f(x).diff(x,d).as_finite_difference(S) approx. de f[d](x)
Exemple : S = [x,x+h,x+2*h]
f(x).diff(x).as_finite_difference(S).together()

Résolution algébrique d'équations
sb.solve(équations,inconnues) où équations est une séquence d'équations, ou d'expressions qui doivent s'annuler, et inconnues l'inconnue ou la liste des inconnues. Renvoie la liste des solutions, si elles sont calculables par sympy, chaque solution étant soit une expression, soit un tuple d'expressions, soit un dictionnaire (option « dict=True »).
Exemples : sb.solve(sb.Eq(x**4,1),x)  [-1,1,-i,i]
sb.solve(x**2-3,x,dict=True) 
sb.solve([x**2+y**2-5,x-y-1],[x,y])  [(−1,−2), (2,1)]
 Calcul de constantes en fonction des conditions initiales sur une expression :
a,b,x,u0,v0 = sb.symbols("a,b,x,u_0,v_0")
U = a*sb.exp(x) + b*sb.exp(-2*x)
CI = [ sb.Eq(U.replace(x,0), u0), \
sb.Eq(U.diff(x).replace(x,0),v0) ]
sb.solve(CI,[x,y],dict=True) 
 L'ensemble des équations différentielles
que sympy sait résoudre est pour l'instant assez limité.
Il faut procéder en 2 temps : 1/ Résolution des équations différentielles ;
2/ Détermination des constantes en fonction
des conditions initiales et/ou aux bords.
sb.dsolve(équations,inconnues) renvoie une équation ou une liste d'équations. De chaque équation eq, de la forme sb.Eq(f(x),solu),
on peut extraire la solution solu par eq.rhs (right-hand side).
Exemple d'équation différentielle :
r = sb.symbols("r") ; f = sb.Function("f")
EDO = sb.Eq(f(r).diff(r,2)+f(r).diff(r)/r+f(r)/r**2,0)
solu = sb.dsolve(EDO,f(r)).rhs  C1sin(log(r))+C2cos(log(r))
Exemple de système différentiel (linéaire à coefficients constants) :
x,y,z = [sb.Function(c) for c in "xyz"]
t = sb.symbols("t")
SDO = [sb.Eq(x(t).diff(t),y(t)-z(t)), \
sb.Eq(y(t).diff(t),x(t)+z(t)), \
sb.Eq(z(t).diff(t),x(t)+y(t)+z(t))]
Leq = sb.dsolve(SDO,[x(t),y(t),z(t)])
[ e.rhs for e in Leq ]  [−C1e−t−C2et−C3(t−1)et,
C1e−t+C2et+C3(t+1)et,
2C2et+C3(2t+1)et ]
Les constantes à trouver ensuite sont définies par :
sb.symbols("C1,C2,C3[etc]")
Exemple : sb.solve( [ solu.replace(r,1)-a, \
solu.diff(r).replace(r,1)-b ], \
sb.symbols("C1,C2") )  {C1:b,C2:a}
Équations différentielles
Manipulation avancée d'expressions
A = 2*a*x+y**3
sb.srepr(A) 
A.func, A.args  sympy.core.add.Add, (2*a*x, y**3)
X,Y = sb.Wild("X"),sb.Wild("Y") symboles indéfinis
A.match(a*X+Y)  {X:2*x, Y:y**3} (dictionnaire)
A.replace(y**3,4*sb.sin(y))  2ax+4sin(y)
Résultat symbolique  Fonction numérique
A est une expression symbolique contenant les symboles x,y,z
Fnum = sb.lambdify((x,y,z), A, "numpy") définit une fonction numérique des variables x, y et z
Fnum = sb.lambdify((x,y,z), A, (dico,"numpy")) indique, à l'aide du dictionnaire dico, la correspondance entre les fonctions de sympy (en chaîne de caractères) et les fonctions numéri-ques à utiliser. Des exemples sont donnés dans le tableau ci-dessous.
Tableau de correspondance de quelques fonctions
import scipy.special as sf (certaines sont automatiques avec numpy)
"factorial" : sf.factorial "atan2" : np.arctan2
"binomial" : sf.binom "besselj" : sf.jn
"erf" : np.erf ou sf.erf "bessely" : sf.yn
"erfinv" : sf.erfinv "zeta" : sf.zeta
"sinc" : lambda x : np.sinc(x/np.pi)
"lowergamma" : lambda s,x : sf.gamma(s)*sf.gammainc(s,x)
Matrices
M = sb.Matrix(liste de listes)
M.det(), M.trace(), M.inv()  déterminant, trace, inverse
M.eigenvals()  valeurs propres, avec ordres de multiplicité
sb.diag(a1,,an)  matrice diagonale de coef. diagonaux a1, , an
M+N, a*M, M@N  somme, produit par un scalaire, produit matriciel
 La notion de vecteur n'existe pas en sympy ; il est assimilé indûment et confusément à une matrice-colonne et/ou à une matrice-ligne.