Contenu du cours
- A propos de la bibliothèque Sympy
- Installation de la bibliothèque Sympy
- Les Symboles Sympy
- Les expressions de la bibliothèque Sympy
- Opération sur les expressions de la bibliothèque Sympy
- Traitement des nombres rationnels avec Sympy
- Résoudre les équations avec la bibliothèque Sympy
- Calcul intégrale avec la bibliothèque Sympy
- Calcul des dérivées avec la bibliothèque Sympy
- Calcul matriciel avec Sympy
1. A propos de la bibliothèque Sympy
SymPy est une bibliothèque Python open-source déstinée au calcul symbolique, gratuite et est distribuée sous la nouvelle licence BSD. Elle offre des méthodes efficaces pour le calcul scientifique et elle couvre presque tous les domaines de mathématiques, analyse, algèbre linéaire et générale, géométrie, statistiques... SymPy est simple à installer et à inspecter car elle est entièrement écrite en Python avec peu de dépendances. Cette facilité d'accès combinée à une base de code simple et extensible dans un langage bien connu font de SymPy un système de calcul formel lympide et puissant. Actuellement, le noyau de la bibliothèque SymPy englobe environ 260 000 lignes de code.
2. Installation de La bibliothèque SymPy
La bibliothèque Sympy rapidement en toute aisance via l'utilitaire pip avec la commande :
|
1 2 3 |
pip install sympy |
Pour vérifier la version de Sympy installée, on utilise le code suivant:
|
1 2 3 4 5 |
>>> import sympy >>> sympy.__version__ '1.10.1' |
3. Les symbols Sympy
La bibliothèque SymPy peut être utilisé dans n'importe quel environnement où Python est disponible. Afin de pouvoir l'utiliser, nous devons préalablement l'importer:
|
1 2 3 |
>>> from sympy import * |
Pour définir un symbol x , on utilise la commande:
|
1 2 3 4 5 |
>>> x = Symbol('x') # notez le S en majuscule >>> x x |
On peut aussi utiliser la syntaxe:
|
1 2 3 4 5 6 |
>>> import sympy as sy >>> x = sy.Symbol('x') >>> x x |
Pour définir plusieurs symbols Sympy en même temps, on utilise la commande:
|
1 2 3 4 5 |
>>> x, y, z = symbols('x y z') # notez le 's' en minuscule >>> x, y, z ( x , y , z ) |
4. Les expressions sympy
Une expression sympy n'est autre qu'une combinaison de symbols à l'aides des opérations classiques de mathématiques comme l'addition, multiplication...
Exemple
|
1 2 3 4 5 6 7 8 9 10 11 |
import sympy as sy x= sy.Symbol('x') y = sy.Symbol('y') # on defint une expression exp = x*sy.sin(y) + y*sy.sin(x) print(exp) # affiche: x*sin(y) + y*sin(x) |
5. Opération sur les expressions sympy
On peut aussi faire des opérations sur les expressions comme factorisation, développement, symplification...
5.1 Développer une expression sympy à l'aide de la méthode expand()
La méthode expand() comme tous les autres langages de calcul symbolique, permet de développer une expression mathématique
Exemple (développer une expression à l'aide de la méthode expand() )
|
1 2 3 4 5 6 7 8 9 |
import sympy as sy x = sy.Symbol('x') y = sy.Symbol('y') expr = (x - y)**3 print(expr.expand()) # affiche: x**3 - 3*x**2*y + 3*x*y**2 - y**3 |
5.2 Simplification
La bibliothèque sympy est dotée de la méthode simplify() qui permet de simplifier une expression mathématique:
Exemple( simplifier une expression via la méthode simplify() )
|
1 2 3 4 5 6 7 8 9 10 |
import sympy as sy x = sy.Symbol('x') expr1 = (x + 1)**2 expr2 = x**2 + 2*x + 1 expr3 = sy.simplify( expr2 - expr1 ) print("expr2 - expr1 = " , expr3 ) # affiche: expr2 - expr1 = 0 |
5.3 Substitution des symbols dans sympy
Dans une expression sympy, on peut substituer un symbol par une valeur numérique ou par un autre grâce à la méthode subs().
Exemple(substitution d'un symbol par une valeur numérique )
|
1 2 3 4 5 6 7 8 9 10 |
import sympy as sy x = sy.Symbol('x') expr = x**2 + x + 3 # substitution de x par 1 print(expr.subs(x , 1)) # affiche 5 |
Exemple(substitution d'un symbol par un autre symbol)
|
1 2 3 4 5 6 7 8 9 10 11 |
import sympy as sy x = sy.Symbol('x') y = sy.Symbol('y') expr = x**2 + x*y + 3*x + y # substitution de x par y ( remplacement de x par y) print(expr.subs(x , y)) # affiche: 2*y**2 + 4*y |
5.4 Evalution d'une expression sympy
Pour évaluer une expression, sympy nous offre la méthode evalf()
Pour bien comprendre le mécanisme de fonctionnement de cette méthode essayons d'examiner l'affichage du nombre pi
Exemple
from sympy import pi
|
1 2 3 |
print(pi) # affiche: pi |
Comme vous l'avez remarqué, l'exemple ci-dessus ne nous permet pas d'obtenir la valeur de pi et c'est grâce à la méthode evalf() qu'on peut l'obtenir.
Exemple
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
from sympy import pi # Default value of pi print(pi.evalf()) # affiche: 3.14159265358979 # get value of pi with 3 decimal numbers print(pi.evalf(3))# affiche: 3.14 # get value of pi with 5 decimal numbers print(pi.evalf(5)) # affiche: 3.1416 |
5.5 transformer une expression sympy en une fonction
Une expression sympy par défaut ne peut jouer le rôle d'une fonction mathématique, mais elle le peut à l'aide de la méthode lambdify()
Syntaxe
|
1 2 3 |
f = lambdify(symbol , expression) |
Exemple
|
1 2 3 4 5 6 7 8 9 10 |
import sympy as sy x = sy.Symbol('x') expr = x**2 + 3*x + 5 f = sy.lambdify(x , expr) print("f(0) = " , f(0)) # affiche: f(0) = 5 |
5.6 Factoriser une expression à l'aide de la méthode sympy.factor()
A l'aide de la méthode sympy.factor(), vous pouvez factoriser toute expressions mathématiques via la syntaxe
Syntaxe
|
1 2 3 |
sympy.factor(expression) |
Exemple (factorisation d'un polynome)
|
1 2 3 4 5 6 7 8 9 10 11 |
import sympy as sy # création du symbol x x = sy.Symbol('x') P = x**2 - 2*x + 1 fact = sy.factor(P) print(fact) # affiche: (x - 1)**2 |
5.7 Code LaTeX d'une expression sympy
Le code LaTeX d'une expression sympy s'obtient facilement à l'aide de la méthode latex()
Exemple
|
1 2 3 4 5 6 7 8 |
from sympy import * x = Symbol('x') I = Integral(sin(x) , x) print(latex(I)) # affiche: \int \sin{\left(x \right)}\, dx |
6. Traitement des nombres rationnels avec sympy
Afin de pouvoir gérer et manipuler des nombres rationnels sous forme de fractions a/b , sympy nous offre la classe Rational qui permet de réaliser l'affaire:
Exemple (création d'un nombre rationnel )
|
1 2 3 4 5 6 7 |
import sympy as sy r = sy.Rational(3, 7) print("la valeur de r est r = " , r) # affiche: r = 3/7 |
On peut aussi effectuer des opérations sur les nombres rationnels avec sympy
Exemple (somme et produit de deux rationnels)
|
1 2 3 4 5 6 7 8 9 10 |
import sympy as sy r1 = sy.Rational(1, 3) r2 = sy.Rational(1, 2) s = r1 + r2 p = r1*r2 print("La somme est r1 + r2 = " , s) # affiche: La somme est r1 + r2 = 5/6 print("La produit est r1 x r2 = " , p) # affiche: La produit est r1 x r2 = 1/6 |
Exemple(transformation d'un nombre décimal en fraction)
|
1 2 3 4 5 6 |
import sympy as sy r = 1.25 print(sy.Rational(r)) # affiche 5/4 |
7. Résoudre les équations en Python avec la méthode sympy.solve()
Avec l'aide de la méthode sympy.solve(expression), vous pouvez résoudre facilement les équations mathématiques. Cette méthode renverra la liste des racines de l'équation qui est fournie comme paramètre en utilisant la méthode sympy.solve().
Syntaxe
|
1 2 3 |
sympy.solve(expression) |
Exemple
|
1 2 3 4 5 6 7 8 |
import sympy as sy x = sy.Symbol('x') # resoudre l'équation: x**2 - 3 = 0 print(sy.solve(sy.Eq(x**2 , 3))) # affiche: [-sqrt(3), sqrt(3)] |
Remarque
On peut aussi résoudre un système d'équations en utilisant la syntaxe:
|
1 2 3 |
sy.solve( (eq1 , eq2,eq3) , (x1,x2,x3,...) |
Nous allons à titre d'exemple résoudre le système:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
import sympy as sy x = sy.Symbol('x') y = sy.Symbol('y') # définir le système d'équations eq1 = sy.Eq(2*x + y , 3) eq2 = sy.Eq(x - 3*y , -2) # resoudre le système d'équation solution = sy.solve( (eq1 , eq2) , (x,y) ) print( solution ) # affiche: {x: 1, y: 1} |
8. Calcul Intégrale avec Sympy Python
Le package SymPy contient le module de calcul intégrale. Il implémente des méthodes pour calculer les intégrales définies et indéfinies des expressions mathématiques. La méthode integrate() est utilisée pour calculer les intégrales définies et indéfinies.
Pour calculer une intégrale indéfinie ou primitive, il suffit de passer la variable après l'expression dans la méthode integrate().
Syntaxe
|
1 2 3 |
primitive_expression(x) = sy.integrate( expression , x) |
Exemple
|
1 2 3 4 5 6 7 8 9 10 |
import sympy as sy x = sy.Symbol('x') expr = x**2 + 3*x + 5 # calcul de la primitive primitive = sy.integrate(expr , x) print(primitive) # affiche: x**3/3 + 3*x**2/2 + 5*x |
9. Differentiation des fonctions à l'aide de la méthode diff()
La bibliothèque sympy permet aussi de calculer la dérivée d'une expression grâce à la méthode diff().
Syntaxe
|
1 2 3 |
derivativeof_expression = sympy.diff(expression , symbol) |
Exemple
|
1 2 3 4 5 6 7 8 9 10 |
import sympy as sy x = sy.Symbol('x') expr = x**5 # drivative function derivative = sy.diff(expr , x) print(derivative) # affiche: 5*x**4 |
La même méthode diff() permet de calculer les dérivées succéssives d'une expression
Exemple
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
import sympy as sy x = sy.Symbol('x') expr = x**5 # drivative derivative1 = sy.diff(expr , x) print(derivative1) # affiche: 5*x**4 # second derivative derivative2 = sy.diff(expr , x , 2) print(derivative2) # affiche: 20*x**3 #3rd order derivative derivative3 = sy.diff(expr , x , 3) print(derivative3) # affiche: 60*x**2 |
10. Calcul matriciel avec sympy
10.1 A propos des matrices sympy
En mathématiques, une matrice (matrix en anglais) est un tableau à deux dimensions constitué de nombres, de symboles ou d'expressions.Il contient des données stockées dans les lignes et les colonnes du tableau. Dans une matrice Python, les séries horizontales d'éléments sont appelées "lignes", tandis que les séries verticales d'éléments sont appelées "colonnes".
Le package SymPy possède un module nommé matrix qui traite complètement la gestion des matrices. Il inclut la classe Matrix dont l'objet représente une matrice.
Afin de pouvoir utiliser le module matrix, vous devez au préalable importer la classe Matrix via la commande:
|
1 2 3 |
from sympy.matrices import Matrix |
Exemple ( création d'une matrice 2x2)
|
1 2 3 4 5 6 7 8 |
from sympy import Matrix # création d'une matrice du type 2x2 A = Matrix([[1, 2], [1, 1] ]) |
10.2 Opération basiques sur les matrices sympy
10.2.1 Les propriétés shape, rows et cols
Pour connaitre le type d'une matrice sympy, le nombre de lignes et de colonnes, on utilise lespropriétés: shap, rows et cols
- shape: détermine le type de la matrice 'mxn'
- rows: renvoie le nombre de lignes de la matrice
- cols: renvoie le nombre de colonnes de la matrice
Exemple
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
from sympy import Matrix A = Matrix([[1, 2], [1, 1], [3, -1], ]) Type = A.shape lignes = A.rows colonnes = A.cols print("Type de la matrice : " , Type) # affiche: Type de la matrice : (3, 2) print("Nombre de lignes de la matrice : " , lignes) # affiche: Nombre de lignes de la matrice : 3 print("Nombre de colonnes de la matrice : " , colonnes) # affiche: Nombre de colonnes de la matrice : 2 |
10.2.2 Accéder aux lignes et aux colonnes d'une matrice sympy
Pour obtenir une ligne ou une colonne d'une matrice A, on utilise row ou col. Par exemple, A.row(0) obtiendra la première ligne. A.col(-1) obtiendra la dernière colonne.
Exemple
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
from sympy import Matrix A = Matrix([[1, 2], [1, 1], [3, -1], ]) print("Première ligne :" , A.row(0)) # affiche: Première ligne : Matrix([[1, 2]]) print("Dernière ligne : " , A.row(-1)) # affiche: Dernière ligne : Matrix([[3, -1]]) print("Première colonne : " , A.col(0)) # affiche: Première colonne : Matrix([[1], [1], [3]]) |
9.2.3 Insertion des lignes et des colonnes
Pour insérer des lignes ou des colonnes dans une matrice sympy, on utilise les méthodes row_insert() ou col_insert().
Exemple
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
from sympy import Matrix A = Matrix([[1, 2], [1, 1], [3, -1], ]) # insertion d'une ligne à la position d'index = 1 A1 = A.row_insert(1, Matrix([[5, 3]])) print("A1 = " , A1) # affiche: A1 = Matrix([[1, 2], [5, 3], [1, 1], [3, -1]]) # insertion d'une colonne à la position d'index = 2 A2 = A.col_insert(2 , Matrix([11, 13 , 77])) print("A2 = " , A2) # affiche: A2 = Matrix([[1, 2, 11], [1, 1, 13], [3, -1, 77]]) |
10.3 Déterminant d'une matrice avec sympy
Pour calculer le déterminant d'une matrice sympy, on utilise la méthode det()
Exemple
|
1 2 3 4 5 6 7 8 |
from sympy import Matrix A = Matrix([[1, 2], [1, 1] ]) print(A.det()) # affiche -1 |
On peut aussi calculer le déterminant d'une matrice sympy définie à l'aide des symbols
Exemple
|
1 2 3 4 5 6 7 8 9 |
from sympy import Matrix , symbols x , y , z , t = symbols('x y z t') B = Matrix([[x, z], [y, t] ]) print(B.det()) # t*x - y*z |
10.4 Valeurs propres, vecteurs propres et diagonalisation d'une matrice sympy
10.4.1 Valeurs propres d'une matrice sympy
Pour trouver les valeurs propres d'une matrice sympy, on utilise la méthode eigenvals(). eigenvals renvoie un dictionnaire de paires eigenvalue: algebraic_multiplicity.
Exemple
|
1 2 3 4 5 6 7 8 9 10 |
from sympy import Matrix A = Matrix([[2, 2, -2], [0, 1, 1], [0, -2, 4] ]) print(A.eigenvals()) # affiche: {3: 1, 2: 2} |
L'exemple ci-dessus montre que la matrice A possède deux valeurs propres: 3 de multiplicité 1 et 2 de multiplicité 2.
10.4.2 Vecteurs propres d'une matrice sympy
Pour trouver les vecteurs propres d'une matrice, on utilise la méthode eigenvects(). eigenvects renvoie une liste de tuples de la forme (eigenvalue, algebraic_multiplicity, [eigenvectors]).
Exemple
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
from sympy import Matrix A = Matrix([[2, 2, -2], [0, 1, 1], [0, -2, 4] ]) print(A.eigenvects()) """ affiche [(2, 2, [Matrix([[1], [0], [0]]), Matrix([[0], [1], [1]])]), (3, 1, [Matrix([[ -1], [1/2], [1]])] )] """ |
Younes Derfoufi
CRMEF OUJDA