# 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

[Source](https://docs.sympy.org/latest/tutorial)

Tout d'abord nous importons toutes les méthodes (`*`) depuis le module `sympy`.


```python
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.


```python
import math
math.sqrt(2)
```




    1.4142135623730951



Si nous faisons l'opération inverses, le carré, il reste une petite erreur.


```python
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.


```python
sqrt(2)
```




$\displaystyle \sqrt{2}$



Si nous faisons l'opération inverse, il n'y a pas d'erreur d'arrondi.


```python
2 - sqrt(2) ** 2
```




$\displaystyle 0$



En plus, le calcul symbolique peut être simplifié.


```python
sqrt(8)
```




$\displaystyle 2 \sqrt{2}$



## Un exemple plus intéressant.

Nous définissons deux symboles


```python
x, y = symbols('x y')
expr = x + 2*y
expr
```




$\displaystyle x + 2 y$



Voici une fonction composée.


```python
f = sin(x)*exp(x)
f
```




$\displaystyle e^{x} \sin{\left(x \right)}$



Nous pouvons la différencier par rapport à x.


```python
diff(f, x)
```




$\displaystyle e^{x} \sin{\left(x \right)} + e^{x} \cos{\left(x \right)}$



## Développement

Définissons les symboles a et b et formons une expression.


```python
a, b = symbols('a b')
e = (a + b)**5
e
```




$\displaystyle \left(a + b\right)^{5}$



La méthode `expand` permet de développer l'expression.


```python
e.expand()
```




$\displaystyle a^{5} + 5 a^{4} b + 10 a^{3} b^{2} + 10 a^{2} b^{3} + 5 a b^{4} + b^{5}$



La méthode `factor` permet de la factoriser.


```python
_.factor()
```




$\displaystyle \left(a + b\right)^{5}$



## Dérivée

Définissons deux variables x et y et formons une fonction f.


```python
x, y = symbols('x, y')
f = x**2 / y + 2 * x - ln(y)
```


```python
f
```




$\displaystyle \frac{x^{2}}{y} + 2 x - \log{\left(y \right)}$



Nous pouvons différencier la fonction par rapport à x.


```python
diff(f, x)
```




$\displaystyle \frac{2 x}{y} + 2$



Et une deuxième fois par rapport à y.


```python
diff((diff(f, x)), y)
```




$\displaystyle - \frac{2 x}{y^{2}}$



## Intégrale

Nous pouvons calculer une intégrale.


```python
a = Integral(cos(x)*exp(x), x)
Eq(a, a.doit())
```




$\displaystyle \int e^{x} \cos{\left(x \right)}\, dx = \frac{e^{x} \sin{\left(x \right)}}{2} + \frac{e^{x} \cos{\left(x \right)}}{2}$



## Expansion, factorisation

Nous définissons une expression simple.


```python
x, y = symbols('x, y')
expr = x + 2*y
expr
```




$\displaystyle x + 2 y$



Nous poumvons soustraire un terme.

expr - x

Nous pouvons multplier par un terme.


```python
x*expr
```




$\displaystyle x \left(x + 2 y\right)$



Nous pouvons développer le résultat.


```python
expand(x*expr)
```




$\displaystyle x^{2} + 2 x y$



Nous pouvons factoriser une expression.


```python
factor(x**2-y**2)
```




$\displaystyle \left(x - y\right) \left(x + y\right)$



Nous pouvons différencier une expression.


```python
x, t, z, nu = symbols('x t z nu')
diff(sin(x)*exp(x), x)
```




$\displaystyle e^{x} \sin{\left(x \right)} + e^{x} \cos{\left(x \right)}$



Et nous pouvons l'intégrer de nouveau.


```python
integrate(_, x)
```




$\displaystyle e^{x} \sin{\left(x \right)}$



Nous pouvons intégrer sur une intervalle infinie.


```python
integrate(sin(x**2), (x, -oo, oo))
```




$\displaystyle \frac{\sqrt{2} \sqrt{\pi}}{2}$



Calculer une limite.


```python
limit(sin(x)/x, x, 0)
```




$\displaystyle 1$



Résoudre une écuation quadratique


```python
solve(x**2 - 3*x - 2, x)
```




    [3/2 - sqrt(17)/2, 3/2 + sqrt(17)/2]




```python
y = Function('y')
dsolve(Eq(y(t).diff(t, t) - y(t), exp(t)), y(t))
```




$\displaystyle y{\left(t \right)} = C_{2} e^{- t} + \left(C_{1} + \frac{t}{2}\right) e^{t}$



Définir une matrice.


```python
M = Matrix([[1, 2], [2, 2]])
M
```




$\displaystyle \left[\begin{matrix}1 & 2\\2 & 2\end{matrix}\right]$



Calculer sa valeur propre.


```python
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. 


```python
e = sin(x)**2 + cos(x)**2
e
```




$\displaystyle \sin^{2}{\left(x \right)} + \cos^{2}{\left(x \right)}$




```python
e.simplify()
```




$\displaystyle 1$




```python
e2 = x**2 + 2*x + 1
e2
```




$\displaystyle x^{2} + 2 x + 1$




```python
e2.factor()
```




$\displaystyle \left(x + 1\right)^{2}$




```python
e5 = (x-1)**5
e5
```




$\displaystyle \left(x - 1\right)^{5}$




```python
e5.expand()
```




$\displaystyle x^{5} - 5 x^{4} + 10 x^{3} - 10 x^{2} + 5 x - 1$




```python
factor(x**5 + x**4 + x**3 + x**2 + x + 1)
```




$\displaystyle \left(x + 1\right) \left(x^{2} - x + 1\right) \left(x^{2} + x + 1\right)$



## Matrices
Pour créer une **matrice** en SymPy utilisez le constructeur `Matrix()` et en donnant une liste des vecteurs-ligne comme argument.


```python
M = Matrix([[1, -1], [3, 4], [0, 2]])
M
```




$\displaystyle \left[\begin{matrix}1 & -1\\3 & 4\\0 & 2\end{matrix}\right]$



Pour créer une **matrice-colonne**, une liste simple d'éléments est suffisant.


```python
Matrix([1, 2, 3])
```




$\displaystyle \left[\begin{matrix}1\\2\\3\end{matrix}\right]$



Pour créer une **matrice-ligne**, une double-liste d'éléments est nécessaire.


```python
Matrix([[1, 2, 3]])
```




$\displaystyle \left[\begin{matrix}1 & 2 & 3\end{matrix}\right]$



Matrices peuvet être multipliées avec l'opérateur `*`. 


```python
M = Matrix([[1, 2, 3], [3, 2, 1]])
M
```




$\displaystyle \left[\begin{matrix}1 & 2 & 3\\3 & 2 & 1\end{matrix}\right]$




```python
N = Matrix([0, 1, 1])
N
```




$\displaystyle \left[\begin{matrix}0\\1\\1\end{matrix}\right]$



Voici le **produit matriciel** de deux matrices.


```python
M*N
```




$\displaystyle \left[\begin{matrix}5\\3\end{matrix}\right]$



Voici le **produit avec un scalaire**.


```python
k = Symbol('k')
M*k
```




$\displaystyle \left[\begin{matrix}k & 2 k & 3 k\\3 k & 2 k & k\end{matrix}\right]$



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


```python
M = Matrix([[1, 2, 3], [-2, 0, 4]])
M
```




$\displaystyle \left[\begin{matrix}1 & 2 & 3\\-2 & 0 & 4\end{matrix}\right]$



La méthode `shape` retourne le nombre de lignes et colonnes $(n, m)$


```python
M.shape
```




    (2, 3)



La méthode `len` retourne le nombre total de coéfficients ($n \times m$)


```python
len(M)
```




    6



On peut accéder à un élément de la matrice par son indices.


```python
M[5]
```




$\displaystyle 4$



Itérer avec l'instruction `for` sur une matrice accède à tout ses éléments, lignes par ligne.


```python
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.


```python
M.row(0)
```




$\displaystyle \left[\begin{matrix}1 & 2 & 3\end{matrix}\right]$



La méthode `col` permet d'extraire une colonne.


```python
M.col(0)
```




$\displaystyle \left[\begin{matrix}1\\-2\end{matrix}\right]$



La méthode `col_del`permet de supprimer une colonne.


```python
M.col_del(0)
M
```




$\displaystyle \left[\begin{matrix}2 & 3\\0 & 4\end{matrix}\right]$



La méthode `row_del` permet de supprimer une ligne. Cette opération modifie la matrice **en place** et retourne `None`.


```python
M.row_del(1)
M
```




$\displaystyle \left[\begin{matrix}2 & 3\end{matrix}\right]$



Les méthodes `row_insert` et `col_insert` insèrent une ligne ou une colonne, mais pas en pace. Elle retournent une nouvelle matrice.


```python
M.row_insert(1, Matrix([[0, 4]]))
```




$\displaystyle \left[\begin{matrix}2 & 3\\0 & 4\end{matrix}\right]$



Vérfions que la matrice $M$ n'a pas changé.


```python
M
```




$\displaystyle \left[\begin{matrix}2 & 3\end{matrix}\right]$



Pour changer la matrice, nous devons affecter l'opération à son symbole.


```python
M = M.row_insert(1, Matrix([[0, 4]]))
M
```




$\displaystyle \left[\begin{matrix}2 & 3\\0 & 4\end{matrix}\right]$



### Opérations de base
Soient deux matrices $M$ et $N$ de taille $2 \times 2$.


```python
M = Matrix([[1, 3], [-2, 3]])
M
```




$\displaystyle \left[\begin{matrix}1 & 3\\-2 & 3\end{matrix}\right]$




```python
N = Matrix([[0, 3], [0, 7]])
N
```




$\displaystyle \left[\begin{matrix}0 & 3\\0 & 7\end{matrix}\right]$



Voici l'**addition**


```python
M+N
```




$\displaystyle \left[\begin{matrix}1 & 6\\-2 & 10\end{matrix}\right]$



Voici la **soustraction**


```python
M-N
```




$\displaystyle \left[\begin{matrix}1 & 0\\-2 & -4\end{matrix}\right]$



Voici la **multiplication**


```python
M*N
```




$\displaystyle \left[\begin{matrix}0 & 24\\0 & 15\end{matrix}\right]$



Voici la **puissance 2**


```python
M**2
```




$\displaystyle \left[\begin{matrix}-5 & 12\\-8 & 3\end{matrix}\right]$



La puissance -1 donne l'**inverse** d'une matrice.


```python
M**(-1)
```




$\displaystyle \left[\begin{matrix}\frac{1}{3} & - \frac{1}{3}\\\frac{2}{9} & \frac{1}{9}\end{matrix}\right]$



### La transposé
La méthode `T` retourne la transposé d'une matrice.


```python
M = Matrix([[1, 2, 3], [4, 5, 6]])
M
```




$\displaystyle \left[\begin{matrix}1 & 2 & 3\\4 & 5 & 6\end{matrix}\right]$




```python
M.T
```




$\displaystyle \left[\begin{matrix}1 & 4\\2 & 5\\3 & 6\end{matrix}\right]$



### Matrice particuliers
La fonction `eye(n)` retourne une **matrice d'identité**.


```python
eye(3)
```




$\displaystyle \left[\begin{matrix}1 & 0 & 0\\0 & 1 & 0\\0 & 0 & 1\end{matrix}\right]$



La fonction `zeros(n, m)` retourne une **matrice zéro**.


```python
zeros(3, 5)
```




$\displaystyle \left[\begin{matrix}0 & 0 & 0 & 0 & 0\\0 & 0 & 0 & 0 & 0\\0 & 0 & 0 & 0 & 0\end{matrix}\right]$



La fonction `ones(n, m)` retourne une matrice dont tous les éléments valent 1.


```python
ones(2, 4)
```




$\displaystyle \left[\begin{matrix}1 & 1 & 1 & 1\\1 & 1 & 1 & 1\end{matrix}\right]$



La fonction `diag` retourne une matrice diagonale.


```python
diag(1, 2, 3)
```




$\displaystyle \left[\begin{matrix}1 & 0 & 0\\0 & 2 & 0\\0 & 0 & 3\end{matrix}\right]$



Tous ces méthodes fonction aussi avec des symboles.


```python
x, y, z = symbols('x y z')
diag(x, y, z)
```




$\displaystyle \left[\begin{matrix}x & 0 & 0\\0 & y & 0\\0 & 0 & z\end{matrix}\right]$



### Déterminant
La méthode `det()` calcule le déterminant d'une matrice.


```python
M = Matrix([[1, 0, 1], [2, -1, 3], [4, 3, 2]])
M
```




$\displaystyle \left[\begin{matrix}1 & 0 & 1\\2 & -1 & 3\\4 & 3 & 2\end{matrix}\right]$




```python
M.det()
```




$\displaystyle -1$



Dans le cas d'une matrice $2 \times 2$ le déterminant est:


```python
a, b, c, d = symbols('a b c d')
M = Matrix([[a, b], [c, d]])
M.det()
```




$\displaystyle a d - b c$



Le déterminant d'une matrice identié est


```python
eye(3).det()
```




$\displaystyle 1$




```python
M.nullspace()
```




    []




```python
A = Matrix([[1, 2], [-1, 3]])
A
```




$\displaystyle \left[\begin{matrix}1 & 2\\-1 & 3\end{matrix}\right]$




```python
A.eigenvals()
```




    {2 - I: 1, 2 + I: 1}




```python
A.eigenvects()
```




    [(2 - I,
      1,
      [Matrix([
       [1 + I],
       [    1]])]),
     (2 + I,
      1,
      [Matrix([
       [1 - I],
       [    1]])])]



## Equations


```python
Eq(x, y)
```




$\displaystyle x = y$




```python
eq = Eq(x**2 + 2*x + 1, 0)
eq
```




$\displaystyle x^{2} + 2 x + 1 = 0$




```python
solveset(eq, x)
```




$\displaystyle \left\{-1\right\}$




```python
linsolve([x + y + z -1, x + y + 2*z - 3], (x, y, z))
```




$\displaystyle \left\{\left( - y - 1, \  y, \  2\right)\right\}$




```python
Eq(x + y + z -1, x + y + 2*z - 3)
```




$\displaystyle x + y + z - 1 = x + y + 2 z - 3$




```python
diag(1, 2) * M
```




$\displaystyle \left[\begin{matrix}a & b\\2 c & 2 d\end{matrix}\right]$




```python
N
```




$\displaystyle \left[\begin{matrix}0 & 3\\0 & 7\end{matrix}\right]$



## Permutation de lignes et colonnes


```python
M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
M
```




$\displaystyle \left[\begin{matrix}1 & 2 & 3\\4 & 5 & 6\\7 & 8 & 9\end{matrix}\right]$



Une matrice *anti-diagonale* permet de **basculer** une matrice.


```python
A = Matrix([[0, 0, 1], [0, 1, 0], [1, 0, 0]])
A
```




$\displaystyle \left[\begin{matrix}0 & 0 & 1\\0 & 1 & 0\\1 & 0 & 0\end{matrix}\right]$



Permutation des colonnes de $(2, 1, 0)$


```python
M * A
```




$\displaystyle \left[\begin{matrix}3 & 2 & 1\\6 & 5 & 4\\9 & 8 & 7\end{matrix}\right]$



Permutation des lignes de (2, 1, 0)


```python
A * M
```




$\displaystyle \left[\begin{matrix}7 & 8 & 9\\4 & 5 & 6\\1 & 2 & 3\end{matrix}\right]$



Horizontalement et verticalement


```python
A * M * A
```




$\displaystyle \left[\begin{matrix}9 & 8 & 7\\6 & 5 & 4\\3 & 2 & 1\end{matrix}\right]$




```python
B = Matrix([[0, 1, 0], [0, 0, 1], [1, 0, 0]])
B
```




$\displaystyle \left[\begin{matrix}0 & 1 & 0\\0 & 0 & 1\\1 & 0 & 0\end{matrix}\right]$



Les colonnes sont permuté de $(2, 0, 1)$


```python
M * B
```




$\displaystyle \left[\begin{matrix}3 & 1 & 2\\6 & 4 & 5\\9 & 7 & 8\end{matrix}\right]$



Les lignes sont permuté de $(1, 2, 0)$


```python
B * M
```




$\displaystyle \left[\begin{matrix}4 & 5 & 6\\7 & 8 & 9\\1 & 2 & 3\end{matrix}\right]$




```python
C = Matrix([[1, 0, 0], [0, 0, 1], [0, 1, 0]])
C
```




$\displaystyle \left[\begin{matrix}1 & 0 & 0\\0 & 0 & 1\\0 & 1 & 0\end{matrix}\right]$



Permutation des colonnes $(0, 2, 1)$


```python
M * C
```




$\displaystyle \left[\begin{matrix}1 & 3 & 2\\4 & 6 & 5\\7 & 9 & 8\end{matrix}\right]$




```python

```

4fc178900e572714a74e0763b3e801a6b9c492c1
ipynb
Jupyter Notebook
doc/dev/sympy.ipynb
rasql/edunum
c9e3be3dbf86a6eb6c28d46b055f8a72bff00ee5
MIT
2021-02-15T22:30:03.000Z
2021-06-16T13:28:25.000Z
doc/dev/sympy.ipynb
rasql/edunum
c9e3be3dbf86a6eb6c28d46b055f8a72bff00ee5
MIT
doc/dev/sympy.ipynb
rasql/edunum
c9e3be3dbf86a6eb6c28d46b055f8a72bff00ee5
MIT
2021-02-15T10:37:12.000Z
2021-08-10T13:25:42.000Z
Qwen/Qwen-72B
1. YES
2. YES