In [ ]:
from __future__ import division, print_function # Python 3
from sympy import init_printing
init_printing(use_latex='mathjax',use_unicode=False) # Affichage des résultats
Cette section concerne le calcul différentiel et intégral. On trouvera d'autres exemples dans le tutoriel de Sympy sur le même sujet: http://docs.sympy.org/latest/tutorial/calculus.html
Pour calculer la limite d'une expression lorsqu'une variable tend vers une valeur, on utilise la fonction limit de sympy avec la syntaxe limit(expression, variable, valeur). :
In [ ]:
from sympy import limit, sin, S
from sympy.abc import x
Par exemple, pour évaluer la limite lorsque x tend vers 0 de l'expression $(\sin(x)-x)/x^3$, on écrit:
In [ ]:
limit((sin(x)-x)/x**3, x, 0)
Out[ ]:
La limite de $f(x)=2x+1$ lorsque $x \to 5/2$ :
In [ ]:
limit(2*x+1, x, S(5)/2) # la fonction S permet de créer un nombre rationel
Out[ ]:
Pour calculer la limite à gauche en un point, on doit spécifier l'option dir="-" :
In [ ]:
limit(1/x, x, 0, dir="-")
Out[ ]:
Pour calculer la limite à droite en un point, on doit spécifier l'option dir="+" :
In [ ]:
limit(1/x, x, 0, dir="+")
Out[ ]:
Lorsque la direction n'est pas spécifiée, c'est la limite à droite (dir="+") qui est calculée par défaut:
In [ ]:
limit(1/x, x, 0)
Out[ ]:
En sympy, tout comme dans SageMath, le symbole oo représente l'infini $\infty$. Les deux o collés resemblent au symbole de l'infini 8 à l'horizontal. Les opérations d'addition, de soustraction, de multiplication, etc. sont possibles avec l'infini oo tant qu'elle soient bien définies. On doit l'importer pour l'utiliser:
In [ ]:
from sympy import oo
oo
Out[ ]:
In [ ]:
5 - oo
Out[ ]:
In [ ]:
oo - oo # nan signifie "Not A Number"
Out[ ]:
On peut calculer la limite d'une expression lorsque x tend vers plus l'infini:
In [ ]:
limit(1/x, x, oo)
Out[ ]:
et aussi lorsque x tend vers moins l'infini:
In [ ]:
limit(4+x*exp(x), x, -oo)
Out[ ]:
Sympy procède à des simplifications lorsque possible:
In [ ]:
limit((1+1/x)**x, x, oo)
Out[ ]:
In [ ]:
sum([1,2,3,4,5])
Out[ ]:
Cette fonction sum permet aussi de calculer une somme impliquant des variables et expressions symboliques de SymPy:
In [ ]:
from sympy import tan
from sympy.abc import x,z
sum([1,2,3,4,5,x,tan(z)])
Out[ ]:
Par contre, sum ne permet pas de calculer des sommes infinies ou encore des séries données par un terme général. En SymPy, il existe une autre fonction (summation) pour calculer des sommes possiblement infinies d'expressions symboliques:
In [ ]:
from sympy import summation
Pour calculer la somme d'une série dont le terme général est donné par une expression qui dépend de n pour toutes les valeurs entières de n entre debut et fin (debut et fin inclus), on utilise la syntaxe summation(expression (n,debut,fin)) :
In [ ]:
from sympy.abc import n
summation(n, (n,1,5))
Out[ ]:
Le début et la fin de l'intervalle des valeurs de n peut être donné par des variables symboliques:
In [ ]:
from sympy.abc import a,b
summation(n, (n,1,b))
Out[ ]:
In [ ]:
summation(n, (n,a,b))
Out[ ]:
Pour faire la somme d'une série pour tous les nombres entiers de 1 à l'infini, on utilise le symbole oo :
In [ ]:
from sympy import oo
summation(1/n**2, (n, 1, oo))
Out[ ]:
Si la série est divergente, elle sera évaluée à oo ou encore elle restera non évaluée:
In [ ]:
summation(n, (n,1,oo))
Out[ ]:
In [ ]:
summation((-1)**n, (n,1,oo))
Out[ ]:
Sympy peut aussi calculer une double somme. Il suffit de spéficier l'intervalle des valeurs pour chacune des variables en terminant avec la variable dont la somme est effectuée en dernier:
In [ ]:
from sympy.abc import m,n
summation(n*m, (n,1,m), (m,1,10))
Out[ ]:
Les doubles sommes fonctionnent aussi avec des intervalles infinis:
In [ ]:
summation(1/(n*m)**2, (n,1,oo), (m,1,oo))
Out[ ]:
In [ ]:
from sympy import product
from sympy.abc import n,b
product(n, (n,1,5))
Out[ ]:
In [ ]:
product(n, (n,1,b))
Out[ ]:
Voici un autre exemple:
In [ ]:
product(n*(n+1), (n, 1, b))
Out[ ]:
In [ ]:
from sympy import diff
Faisons quelques importations de fonctions et variables pour la suite:
In [ ]:
from sympy import sin,cos,tan,atan,pi
from sympy.abc import x,y
On calcule la dérivée de $\sin(x)$ :
In [ ]:
diff(sin(x), x)
Out[ ]:
Voici quelques autres exemples:
In [ ]:
diff(cos(x**3), x)
Out[ ]:
In [ ]:
diff(atan(2*x), x)
Out[ ]:
In [ ]:
diff(1/tan(x), x)
Out[ ]:
Pour calculer la i-ème dérivée d'une fonction, on ajoute autant de variables que nécessaire ou bien on spécifie le nombre de dérivées à faire:
In [ ]:
diff(sin(x), x, x, x)
Out[ ]:
In [ ]:
diff(sin(x), x, 3)
Out[ ]:
Cela fonctionne aussi avec des variables différentes:
In [ ]:
diff(x**2*y**3, x, y, y)
Out[ ]:
In [ ]:
from sympy import integrate
Par exemple:
In [ ]:
integrate(1/x, x)
Out[ ]:
Le calcul d'une intégrale définie se fait aussi avec la fonction integrate avec la syntaxe integrate(f, (x, a, b)) :
In [ ]:
integrate(1/x, (x, 1, 57))
Out[ ]:
Voici quelques autres exemples:
In [ ]:
from sympy import exp
integrate(cos(x)*exp(x), x)
Out[ ]:
In [ ]:
integrate(x**2, (x,0,1))
Out[ ]:
L'intégrale d'une fonction rationnelle:
In [ ]:
integrate((x+1)/(x**2+4*x+4), x)
Out[ ]:
L'intégrale d'une fonction exponentielle polynomiale:
In [ ]:
integrate(5*x**2 * exp(x) * sin(x), x)
Out[ ]:
Deux intégrales non élémentaires:
In [ ]:
from sympy import erf
integrate(exp(-x**2)*erf(x), x)
Out[ ]:
Calculer l'intégrale de $x^2 \cos(x)$ par rapport à $x$ :
In [ ]:
integrate(x**2 * cos(x), x)
Out[ ]:
Calculer l'intégrale définie de $x^2 \cos(x)$ par rapport à $x$ sur l'intervalle de $0$ à $\pi/2$ :
In [ ]:
integrate(x**2 * cos(x), (x, 0, pi/2))
Out[ ]:
Les fonctions summation, product, diff et integrate ont tous un équivalent qui retourne un résultat non évalué. Elles s'utilisent avec la même syntaxe, mais portent un autre nom et commencent avec une majuscule: Sum, Product, Derivative, Integral.
In [ ]:
from sympy import Sum, Product, Derivative, Integral, sin, oo
from sympy.abc import n, x
Sum(1/n**2, (n, 1, oo))
Out[ ]:
In [ ]:
Product(n, (n,1,10))
Out[ ]:
In [ ]:
Derivative(sin(x**2), x)
Out[ ]:
In [ ]:
Integral(1/x**2, (x,1,oo))
Out[ ]:
Pour les évaluer, on ajoute .doit() :
In [ ]:
Sum(1/n**2, (n, 1, oo)).doit()
Out[ ]:
In [ ]:
Product(n, (n,1,10)).doit()
Out[ ]:
In [ ]:
Derivative(sin(x**2), x).doit()
Out[ ]:
In [ ]:
Integral(1/x**2, (x,1,oo)).doit()
Out[ ]:
Cela est utile pour écrire des équations:
In [ ]:
A = Sum(1/n**2, (n, 1, oo))
B = Product(n, (n,1,10))
C = Derivative(sin(x**2), x)
D = Integral(1/x**2, (x,1,oo))
from sympy import Eq
Eq(A, A.doit())
Out[ ]:
In [ ]:
Eq(B, B.doit())
Out[ ]:
In [ ]:
Eq(C, C.doit())
Out[ ]:
In [ ]:
Eq(D, D.doit())
Out[ ]:
In [ ]:
from sympy.abc import x,y
integrate(integrate(x**2+y**2, x), y)
Out[ ]:
Mais, il est plus commode d'utiliser une seule fois la commande integrate et sympy permet de le faire:
In [ ]:
integrate(x**2+y**2, x, y)
Out[ ]:
Pour les intégrales définies multiples, on spécifie les intervalles pour chaque variable entre parenthèses. Ici, on fait l'intégrale sur les valeurs de x dans l'intervalle [0,y], puis pour les valeurs de y dans l'intervalle [0,10] :
In [ ]:
integrate(x**2+y**2, (x,0,y), (y,0,10))
Out[ ]:
In [ ]:
from sympy import series, cos
from sympy.abc import x
series(cos(x), x, 0, 14)
Out[ ]:
Par défaut, le développement est efféctuée en 0 et est d'ordre 6:
In [ ]:
series(cos(x), x)
Out[ ]:
De façon équivalente, on peut aussi utilise la syntaxe expression.series(x, x0, n) :
In [ ]:
(1/cos(x**2)).series(x, 0, 14)
Out[ ]:
Le développement de Taylor de $\log$ se fait en $x_0=1$ :
In [ ]:
from sympy import log
series(log(x), x, 0)
Out[ ]:
In [ ]:
series(log(x), x, 1)
Out[ ]:
In [ ]:
from sympy import Function
f = Function("f")
Déjà, cela permet d'écrire f et f(x) :
In [ ]:
f
Out[ ]:
In [ ]:
from sympy.abc import x
f(x)
Out[ ]:
On peut définir les dérivées de f à l'aide de la fonction Derivative de sympy:
In [ ]:
from sympy import Derivative
Derivative(f(x), x) # ordre 1
Out[ ]:
In [ ]:
Derivative(f(x), x, x) # ordre 2
Out[ ]:
En utilisant, Eq on peut définir une équation impliquant la fonction f et ses dérivées, c'est-à-dire une équation différentielle:
In [ ]:
Eq(f(x), Derivative(f(x),x))
Out[ ]:
Puis, on peut la résoudre avec la fonction dsolve de sympy avec la syntaxe dsolve(equation, f(x)) et trouver quelle fonction f(x) est égale à sa propre dérivée:
In [ ]:
from sympy import dsolve
dsolve(Eq(f(x), Derivative(f(x),x)), f(x))
Out[ ]:
Voici un autre exemple qui trouve une fonction égale à l'opposé de sa dérivée d'ordre 2:
In [ ]:
Eq(f(x), -Derivative(f(x),x,x))
Out[ ]:
In [ ]:
dsolve(Eq(f(x), -Derivative(f(x),x,x)), f(x))
Out[ ]:
Résoudre une équation différentielle ordinaire comme $f''(x) + 9 f(x) = 1$ :
In [ ]:
dsolve(Eq(Derivative(f(x),x,x) + 9*f(x), 1), f(x))
Out[ ]:
Pour définir la dérivée, on peut aussi utiliser .diff(). L'exemple précédent s'écrit:
In [ ]:
dsolve(Eq(f(x).diff(x, x) + 9*f(x), 1), f(x))
Out[ ]:
Finalement, voici un exemple impliquant deux équations:
In [ ]:
from sympy.abc import x,y,t
eq1 = Eq(Derivative(x(t),t), x(t)*y(t)*sin(t))
eq2 = Eq(Derivative(y(t),t), y(t)**2*sin(t))
systeme = [eq1, eq2]
systeme
Out[ ]:
In [ ]:
dsolve(systeme)
Out[ ]: