SymPy¶
La bibliothèque SymPy est spécialisée dans le calcul symbolique. Elle ne dépend d’aucune bibliothèque supplémentaire. Elle permet de faire
arithmétique
algèbre
calcul matriciel
résolution d’équations
Tout d’abord nous importons toutes les méthodes (*
) depuis le module sympy
.
from sympy import *
Exercice
Si vous rencontrez une erreur ModuleNotFoundError vous devez d’abord installer le module sympy.
Calcul symbolique ?¶
C’est quoi le calcul symbolique?
La fonction sqrt
du module math
permet de calculer une racine carrée. Le nombre affiché n’est pas la valeur exacte. La racine de 2 ne peux pas être représenté par un nombre à virgule flottante.
import math
math.sqrt(2)
1.4142135623730951
Si nous faisons l’opération inverses, le carré, il reste une petite erreur.
2 - math.sqrt(2) ** 2
-4.440892098500626e-16
Par contre si nous utilisons la fonction sqrt
que nous venons d’importer du module sympy
nous gardons une expression symbolique pour la racine.
sqrt(2)
Si nous faisons l’opération inverse, il n’y a pas d’erreur d’arrondi.
2 - sqrt(2) ** 2
En plus, le calcul symbolique peut être simplifié.
sqrt(8)
Un exemple plus intéressant.¶
Nous définissons deux symboles
x, y = symbols('x y')
expr = x + 2*y
expr
Voici une fonction composée.
f = sin(x)*exp(x)
f
Nous pouvons la différencier par rapport à x.
diff(f, x)
Développement¶
Définissons les symboles a et b et formons une expression.
a, b = symbols('a b')
e = (a + b)**5
e
La méthode expand
permet de développer l’expression.
e.expand()
La méthode factor
permet de la factoriser.
_.factor()
Dérivée¶
Définissons deux variables x et y et formons une fonction f.
x, y = symbols('x, y')
f = x**2 / y + 2 * x - ln(y)
f
Nous pouvons différencier la fonction par rapport à x.
diff(f, x)
Et une deuxième fois par rapport à y.
diff((diff(f, x)), y)
Intégrale¶
Nous pouvons calculer une intégrale.
a = Integral(cos(x)*exp(x), x)
Eq(a, a.doit())
Expansion, factorisation¶
Nous définissons une expression simple.
x, y = symbols('x, y')
expr = x + 2*y
expr
Nous poumvons soustraire un terme.
expr - x
Nous pouvons multplier par un terme.
x*expr
Nous pouvons développer le résultat.
expand(x*expr)
Nous pouvons factoriser une expression.
factor(x**2-y**2)
Nous pouvons différencier une expression.
x, t, z, nu = symbols('x t z nu')
diff(sin(x)*exp(x), x)
Et nous pouvons l’intégrer de nouveau.
integrate(_, x)
Nous pouvons intégrer sur une intervalle infinie.
integrate(sin(x**2), (x, -oo, oo))
Calculer une limite.
limit(sin(x)/x, x, 0)
Résoudre une écuation quadratique
solve(x**2 - 3*x - 2, x)
[3/2 - sqrt(17)/2, 3/2 + sqrt(17)/2]
y = Function('y')
dsolve(Eq(y(t).diff(t, t) - y(t), exp(t)), y(t))
Définir une matrice.
M = Matrix([[1, 2], [2, 2]])
M
Calculer sa valeur propre.
M.eigenvals()
{3/2 - sqrt(17)/2: 1, 3/2 + sqrt(17)/2: 1}
Simplification¶
Les méthodes simplify
, factor
et expand
permettent de transformer des expressions.
e = sin(x)**2 + cos(x)**2
e
e.simplify()
e2 = x**2 + 2*x + 1
e2
e2.factor()
e5 = (x-1)**5
e5
e5.expand()
factor(x**5 + x**4 + x**3 + x**2 + x + 1)
Matrices¶
Pour créer une matrice en SymPy utilisez le constructeur Matrix()
et en donnant une liste des vecteurs-ligne comme argument.
M = Matrix([[1, -1], [3, 4], [0, 2]])
M
Pour créer une matrice-colonne, une liste simple d’éléments est suffisant.
Matrix([1, 2, 3])
Pour créer une matrice-ligne, une double-liste d’éléments est nécessaire.
Matrix([[1, 2, 3]])
Matrices peuvet être multipliées avec l’opérateur *
.
M = Matrix([[1, 2, 3], [3, 2, 1]])
M
N = Matrix([0, 1, 1])
N
Voici le produit matriciel de deux matrices.
M*N
Voici le produit avec un scalaire.
k = Symbol('k')
M*k
Contrairement aux autres objets dans SymPy, les matrice sont mutables. Donc elles peuvent être modifiés en place.
Opérations de base¶
Considérons la matrice
M = Matrix([[1, 2, 3], [-2, 0, 4]])
M
La méthode shape
retourne le nombre de lignes et colonnes \((n, m)\)
M.shape
(2, 3)
La méthode len
retourne le nombre total de coéfficients (\(n \times m\))
len(M)
6
On peut accéder à un élément de la matrice par son indices.
M[5]
Itérer avec l’instruction for
sur une matrice accède à tout ses éléments, lignes par ligne.
for m in M:
print(m, end=' ')
1 2 3 -2 0 4
Accéder aux lignes et colonnes¶
La méthode row
permet d’extraire une ligne.
M.row(0)
La méthode col
permet d’extraire une colonne.
M.col(0)
La méthode col_del
permet de supprimer une colonne.
M.col_del(0)
M
La méthode row_del
permet de supprimer une ligne. Cette opération modifie la matrice en place et retourne None
.
M.row_del(1)
M
Les méthodes row_insert
et col_insert
insèrent une ligne ou une colonne, mais pas en pace. Elle retournent une nouvelle matrice.
M.row_insert(1, Matrix([[0, 4]]))
Vérfions que la matrice \(M\) n’a pas changé.
M
Pour changer la matrice, nous devons affecter l’opération à son symbole.
M = M.row_insert(1, Matrix([[0, 4]]))
M
Opérations de base¶
Soient deux matrices \(M\) et \(N\) de taille \(2 \times 2\).
M = Matrix([[1, 3], [-2, 3]])
M
N = Matrix([[0, 3], [0, 7]])
N
Voici l”addition
M+N
Voici la soustraction
M-N
Voici la multiplication
M*N
Voici la puissance 2
M**2
La puissance -1 donne l”inverse d’une matrice.
M**(-1)
La transposé¶
La méthode T
retourne la transposé d’une matrice.
M = Matrix([[1, 2, 3], [4, 5, 6]])
M
M.T
Matrice particuliers¶
La fonction eye(n)
retourne une matrice d’identité.
eye(3)
La fonction zeros(n, m)
retourne une matrice zéro.
zeros(3, 5)
La fonction ones(n, m)
retourne une matrice dont tous les éléments valent 1.
ones(2, 4)
La fonction diag
retourne une matrice diagonale.
diag(1, 2, 3)
Tous ces méthodes fonction aussi avec des symboles.
x, y, z = symbols('x y z')
diag(x, y, z)
Déterminant¶
La méthode det()
calcule le déterminant d’une matrice.
M = Matrix([[1, 0, 1], [2, -1, 3], [4, 3, 2]])
M
M.det()
Dans le cas d’une matrice \(2 \times 2\) le déterminant est:
a, b, c, d = symbols('a b c d')
M = Matrix([[a, b], [c, d]])
M.det()
Le déterminant d’une matrice identié est
eye(3).det()
M.nullspace()
[]
A = Matrix([[1, 2], [-1, 3]])
A
A.eigenvals()
{2 - I: 1, 2 + I: 1}
A.eigenvects()
[(2 - I,
1,
[Matrix([
[1 + I],
[ 1]])]),
(2 + I,
1,
[Matrix([
[1 - I],
[ 1]])])]
Equations¶
Eq(x, y)
eq = Eq(x**2 + 2*x + 1, 0)
eq
solveset(eq, x)
linsolve([x + y + z -1, x + y + 2*z - 3], (x, y, z))
Eq(x + y + z -1, x + y + 2*z - 3)
diag(1, 2) * M
N
Permutation de lignes et colonnes¶
M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
M
Une matrice anti-diagonale permet de basculer une matrice.
A = Matrix([[0, 0, 1], [0, 1, 0], [1, 0, 0]])
A
Permutation des colonnes de \((2, 1, 0)\)
M * A
Permutation des lignes de (2, 1, 0)
A * M
Horizontalement et verticalement
A * M * A
B = Matrix([[0, 1, 0], [0, 0, 1], [1, 0, 0]])
B
Les colonnes sont permuté de \((2, 0, 1)\)
M * B
Les lignes sont permuté de \((1, 2, 0)\)
B * M
C = Matrix([[1, 0, 0], [0, 0, 1], [0, 1, 0]])
C
Permutation des colonnes \((0, 2, 1)\)
M * C