SymPy est une librairie Python de mathématiques symboliques et un outil de calcul formel. SymPy offre un ensemble riche de fonctions documentées qui facilite la modélisation de problèmes mathématiques (arithmétique, calcul symbolique, résolution d'équations, recherche de racines, dessin de fonctions, limites et séries, calcul différentiel et intégral, algèbre linéaire). La librairie offre aussi des fonctionalités de mathématiques plus avancées (géométrie différentielle et algébrique, intégration numérique, théorie des catégories) et pour la physique (optique, mécanique classique, mécanique et informatique quantique).
Le projet contient deux applications Web, SymPy Gamma et SymPy Live, permettant aux étudiants, enseignants et chercheurs d’effectuer des expériences mathématiques en ligne. SymPy Gamma est une interface d’apprentissage pour le calcul et la visualisation basée sur des exemples : algébrique, géométrique, trigonométrique et combinatoire. SymPy Live offre un terminal en ligne avec des fonctionnalités telle que l’écriture des équations en LaTeX, la manipulation symbolique avec le langage Python.
Pour plus d'informations sur SymPy:
- Tutoriel sur SymPy en français: http://docs.sympy.org/dev-py3k/tutorial/tutorial.fr.html
- Aperçu de fonctionalités de SymPy (anglais): http://www.sympy.org/en/features.html
- Documentation complète sur SymPy (anglais): http://docs.sympy.org/
Les exemples dans les sections qui suivent sont parfois nouveaux sinon inspirés de la documentation en ligne de SymPy.
In [ ]:
from __future__ import division, print_function # Python 3
In [ ]:
from sympy import Rational
Rational(53, 9)
Out[ ]:
In [ ]:
Rational(1,4) + Rational(1,3)
Out[ ]:
Une autre façon plus courte de construire un nombre rationnel en SymPy est d'utiliser la fonction raccourcie S
qui traduit des types de Python comme une chaîne de caractères ou un entier en des nombres entiers ou rationnels de SymPy:
In [ ]:
from sympy import S
S("5/2") # traduction d'une chaîne de caractères en un rationel
Out[ ]:
La division d'un nombre entier de sympy par un nombre entier retourne un nombre rationnel plutôt qu'un nombre à virgule flottante:
In [ ]:
S(5)/2 # S(5) transforme 5 (type int) en un nombre entier de sympy
Out[ ]:
In [ ]:
from sympy import I
Par exemple, le nombre complexe $2+5i$ s'écrit 2+5*I
:
In [ ]:
2 + 5*I
Out[ ]:
On vérifie que le carré du nombre imaginaire I
retourne bien -1
:
In [ ]:
I ** 2
Out[ ]:
Les opérations de base sont définies sur les nombres complexes comme pour les nombres entiers et les nombres décimaux:
In [ ]:
(13 + 34*I) + (3 + 4*I)
Out[ ]:
NOTE: Le résultat n'est pas toujours simplifié. Pour ce faire, on peut utiliser la fonction simplify
de SymPy:
In [ ]:
(13 + 34*I) / (3 + 4*I)
Out[ ]:
In [ ]:
from sympy import simplify
simplify( (13 + 34*I) / (3 + 4*I) )
Out[ ]:
La division de nombre complexes entiers de partie imaginaire nulle retourne bien un nombre rationnel:
In [ ]:
(3+0*I) / (2+0*I)
Out[ ]:
Pour obtenir les parties réelles et imaginaires d'un nombre complexe, on peut utiliser les fonctions re
et im
de SymPy:
In [ ]:
from sympy import re,im
re(3 + 7*I)
Out[ ]:
In [ ]:
im(3 + 7*I)
Out[ ]:
Pour obtenir le module et l'argument d'un nombre complexe, on utilse les fonctions arg
et abs
de SymPy. Notez qu'il n'est pas nécessaire d'importer abs
, car cette fonction qui retourne la valeur absolue d'un nombre réel est déjà dans Python et fonctionne pour les nombres complexes:
In [ ]:
from sympy import arg
arg(3 + 7*I)
Out[ ]:
In [ ]:
abs(3 + 7*I)
Out[ ]:
Quand c'est possible, SymPy procède à des simplifications:
In [ ]:
arg(1 + I)
Out[ ]:
In [ ]:
abs(3 + 4*I)
Out[ ]:
Le conjugué d'un nombre complexe s'obtient avec la fonction conjugate
:
In [ ]:
from sympy import conjugate
conjugate(3 + 7*I)
Out[ ]:
On peut aussi obtenir le conjugué d'un nombre complexe en utilisant la méthode conjugate
de la façon suivante (une méthode est une fonction définie dans la classe d'un objet, ici dans la classe des nombres complexes):
In [ ]:
a = 3 + 7*I
a.conjugate()
Out[ ]:
Utiliser la deuxième façon (méthode conjugate
) plutôt que la première (fonction globale conjugate
) permet d'éviter d'importer la fonction et aussi permet d'utiliser la touche TAB
(dans IPython ou Jupyter) pour choisir ou compléter l'écriture du nom de la méthode.
Calculer la valeur numérique d'un nombre
se fait avec la méthode evalf
ou de façon équivalente n
avec la syntaxe nombre.n(prec)
où prec
est le nombre de chiffres à afficher:
In [ ]:
from sympy import pi
pi.evalf(60)
Out[ ]:
In [ ]:
pi.n(60)
Out[ ]:
Le nombre de chiffres inclut les chiffres à gauche et à droite de la virgule:
In [ ]:
from sympy import exp, pi, sqrt
exp(pi * sqrt(163)).evalf(50)
Out[ ]:
In [ ]:
from sympy import factorint
factorint(240)
Out[ ]:
Il est possible d'afficher un résultat plus visuel de la factorisation au moyen de la fonction pprint
et de l'option visual=True
:
In [ ]:
from sympy import pprint
pprint(factorint(240, visual=True))
Out[ ]:
In [ ]:
from sympy import Rational
Rational?
Comme SymPy est un logiciel libre, on peut aussi accéder au code source en ajoutant un deuxième point d'interrogation:
In [ ]:
Rational??