Opérations de base en Python

Les opérations de base (addition, soustraction, multiplication, division) sur les nombres se font avec les opérateurs +, -, * et /:

>>> 13.14 + 1.2
14.34
>>> 14.34 - 1.2
13.14
>>> 6 * 9
54
>>> 54 / 9
6.0

La division d'un nombre par zéro retourne une erreur:

>>> 53 / 0
Traceback (most recent call last):
...
ZeroDivisionError: division by zero

Exposant

Le calcul d'une puissance se fait avec la double astérisque **:

>>> 2 ** 8
256

ATTENTION

En Python, l'opérateur ^ ne calcule pas l'exposant, mais fait plutôt une opération sur la représentation binaire des nombres entiers (ou exclusif bit à bit):

>>> 5 ^ 3
6

Racine n-ième

Le calcul d'une puissance permet aussi de calculer la racine n-ième d'un nombre:

>>> 256 ** (1 / 8)
2.0

Reste et quotient de la division

Le reste de la division d'un nombre entier par un autre se fait avec le symbole %. Par exemple, on calcule le reste de la division du nombre 94 par 10:

>>> 94 % 10
4

L'opération a // b lorsque a et b sont des nombres entiers retourne le quotient de la division a par b:

>>> 94 // 10
9

Fonctions et constantes mathématiques en Python

Le module math de Python contient un certain nombre de fonctions et constantes mathématiques que l'on retrouve sur une calculatrice:

acos       atanh      e          factorial  hypot      log10      sin
acosh      ceil       erf        floor      isinf      log1p      sinh
asin       copysign   erfc       fmod       isnan      modf       sqrt
asinh      cos        exp        frexp      ldexp      pi         tan
atan       cosh       expm1      fsum       lgamma     pow        tanh
atan2      degrees    fabs       gamma      log        radians    trunc

On trouvera leur documentation sur https://docs.python.org/library/math.html

Pour importer quelquechose de ce module, il faut d'abord l'importer avec la syntaxe from math import quelquechose. Par exemple, pour importer la fonction factorial, on procède de la façon suivante:

>>> from math import factorial
>>> factorial(4)
24

Alternativement, on peut aussi importer le module math et procéder ainsi:

>>> import math
>>> math.factorial(4)
24

De même pour les fonctions trigonométriques, on les importe de la façon suivante:

>>> from math import sin, cos, tan, pi

Pour importer toutes les fonctions d'un module, il suffit d'écire from module import *. Par exemple, pour importer toutes les fonctions du module math, on écrit:

>>> from math import *

On vérifie que le sinus d'un angle de 90 degrés est bien égal à 1:

>>> sin(90)
0.8939966636005579

Oups, l'argument doit être écrit est en radians (90 degrés est égal à π ⁄ 2 radians) et on obtient bien 1:

>>> sin(pi/2)
1.0

La constante π du module math retourne une valeur approchée à une quinzaine de décimales:

>>> pi
3.141592653589793

Les fonctions degrees et radians permettent de passer d'une unité d'angle à l'autre:

>>> from math import degrees, radians
>>> degrees(pi)
180.0
>>> radians(180)
3.141592653589793

Extraction de la racine carrée avec la fonction sqrt:

>>> from math import sqrt
>>> sqrt(100)
10.0

Calcul des racines du polynôme 3x² + 7x + 2:

>>> from math import sqrt
>>> (- 7 + sqrt(7**2 - 4 * 3 * 2) ) / (2 * 3)
-0.3333333333333333
>>> (- 7 - sqrt(7**2 - 4 * 3 * 2) ) / (2 * 3)
-2.0

Accéder à la documentation d'une fonction

En Python, pour obtenir de l'information sur une fonction, on peut écrire help(fonction). Par exemple, si on ne sait pas à quoi peut bien servir la fonction hypot:

>>> from math import hypot
>>> help(hypot)
Help on built-in function hypot in module math:
hypot(...)
    hypot(x, y)
    Return the Euclidean distance, sqrt(x*x + y*y).

En IPython, on peut consulter la documentation d'une fonction en ajoutant un point d'interrogation avant ou après le nom de la fonction. Cela fonctionne aussi dans l'interface Jupiter, ce qui ouvre une fenêtre au bas de la page:

>>> ?hypot
Docstring:
hypot(x, y)
Return the Euclidean distance, sqrt(x*x + y*y).
Type:      builtin_function_or_method

>>> hypot?
Docstring:
hypot(x, y)
Return the Euclidean distance, sqrt(x*x + y*y).
Type:      builtin_function_or_method

Parenthèses et priorité des opérations

Les parenthèses permettent d'indiquer dans quelle ordre faire les opérations dans un calcul:

>>> 3 * (5 + 2)        # l'addition est calculée en premier
21
>>> (3 * 5) + 2        # la multiplication est calculée en premier
17

Sans les parenthèses, l'expression est évaluée selon l'ordre de priorité des opérations. En particulier, le comportement par défaut est que la multiplication est évaluée avant l'addition:

>>> 3 * 5 + 2          # la multiplication est calculée en premier
17

En général, les expressions non parenthésées utilisant les opérations de base sont évaluées en tenant compte de l'ordre décrit dans la table ci-bas.

Variables et affectation

Supposons que l'on veut évaluer le polynôme 3x⁴ + 7x³ − 3x² + x − 5 lorsque x = 1234567. On peut procéder de la façon suivante:

>>> 3 * 1234567**4 + 7 * 1234567**3 - 3 * 123467**2 + 1234567 - 5
6969164759371928046905499

Cela nous oblige à écrire quatre fois le nombre 1234567 et on peut éviter cela au moyen d'une variable.

Une variable permet de mémoriser un nombre pour le réutiliser plus tard. Par exemple, on peut mémoriser le nombre 1234567 dans la variable x:

>>> x = 1234567

Le symbole = ne doit pas être vu comme une équation à résoudre, mais plutôt comme une affectation de la valeur 1234567 dans la variable x. On peut demander la valeur de x:

>>> x
1234567

Cela nous permet de faire des calculs avec x:

>>> x + 1
1234568

Finalement, on peut utiliser la variable x pour évaluer le polynôme au point x=1234567:

>>> 3*x**4 + 7*x**3 - 3*x**2 + x - 5
6969164759367401312173299

C'est curieux. On remarque que le résultat n'est pas le même que celui que l'on avait calculé plus haut. Pourquoi? En effet, on s'était trompé en écrivant 123467 plutôt que 1234567. C'est aussi l'autre avantage d'utiliser une variable: ça permet d'éviter de se tromper lorsqu'on doit utiliser la même valeur plusieurs fois dans un calcul.

Ensuite, on peut changer la valeur de la variable x et évaluer le même polynôme lorsque x prend une autre valeur:

>>> x = 10
>>> 3*x**4 + 7*x**3 - 3*x**2 + x - 5
36705

Opérateurs de comparaison et d'égalités

Comme on l'a vu dans une section précédente, l'opérateur = est utilisé pour l'affectation de variable. Pour tester l'égalité de deux expressions, on utilise alors le l'opérateur == s'écrivant avec deux signes d'égalité:

>>> 5 * 9 == 40 + 5
True

La valeur retournée est un booléen: True pour vrai et False pour faux. Si l'égalité n'est pas vérifiée, alors c'est la valeur False qui est retournée:

>>> 5 * 9 == 40 + 6
False

Il existe d'autres opérateurs de comparaison dont la description se trouve dans la table ci-bas.

Par exemple:

>>> 5 * 9 < 1000
True
>>> 1 + 2 + 3 + 4 + 5 >= 15
True
>>> 2016 != 2016
False

Nombres rationels

Les nombres rationnels en SymPy doivent être construits à l'aide de la fonction Rational:

>>> from sympy import Rational
>>> Rational(53, 9)
53/9
>>> Rational(1,4) + Rational(1,3)
7/12

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:

>>> from sympy import S
>>> S("5/2")    # traduction d'une chaîne de caractères en un rationel
5/2

La division d'un nombre entier de sympy par un nombre entier retourne un nombre rationnel plutôt qu'un nombre à virgule flottante:

>>> S(5)/2      # S(5) transforme 5 (type int) en un nombre entier de sympy
5/2

Nombres complexes

En SymPy, les nombres complexes s'écrivent avec la lettre majuscule I pour symboliser la partie imaginaire. Il faut d'abord l'importer:

>>> from sympy import I

Par exemple, le nombre complexe 2 + 5i s'écrit 2+5*I:

>>> 2 + 5*I
2 + 5*I

On vérifie que le carré du nombre imaginaire I retourne bien -1:

>>> I ** 2
-1

Les opérations de base sont définies sur les nombres complexes comme pour les nombres entiers et les nombres décimaux:

>>> (13 + 34*I) + (3 + 4*I)
16 + 38*I

NOTE: Le résultat n'est pas toujours simplifié. Pour ce faire, on peut utiliser la fonction simplify de SymPy:

>>> (13 + 34*I) / (3 + 4*I)
(13 + 34*I)/(3 + 4*I)
>>> from sympy import simplify
>>> simplify( (13 + 34*I) / (3 + 4*I) )
7 + 2*I

La division de nombre complexes entiers de partie imaginaire nulle retourne bien un nombre rationnel:

>>> (3+0*I) / (2+0*I)
3/2

Pour obtenir les parties réelles et imaginaires d'un nombre complexe, on peut utiliser les fonctions re et im de SymPy:

>>> from sympy import re,im
>>> re(3 + 7*I)
3
>>> im(3 + 7*I)
7

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:

>>> from sympy import arg
>>> arg(3 + 7*I)
atan(7/3)
>>> abs(3 + 7*I)
sqrt(58)

Quand c'est possible, SymPy procède à des simplifications:

>>> arg(1 + I)
pi/4
>>> abs(3 + 4*I)
5

Le conjugué d'un nombre complexe s'obtient avec la fonction conjugate:

>>> from sympy import conjugate
>>> conjugate(3 + 7*I)
3 - 7*I

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):

>>> a = 3 + 7*I
>>> a.conjugate()
3 - 7*I

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 une valeur numérique

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:

>>> from sympy import pi
>>> pi.evalf(60)
3.1415926535897932384626433832795028841971693993751
>>> pi.n(60)
3.1415926535897932384626433832795028841971693993751

Le nombre de chiffres inclut les chiffres à gauche et à droite de la virgule:

>>> from sympy import exp, pi, sqrt
>>> exp(pi * sqrt(163)).evalf(50)
262537412640768743.99999999999925007259719818568888

Factoriser un nombre entier

Pour factoriser un nombre entier, il suffit d'utiliser la fonction factorint. La valeur retournée est un dictionnaire qui associe à chaque diviseur une valeur qui représente la multiplicité du diviseur:

>>> from sympy import factorint
>>> factorint(240)
{2: 4, 3: 1, 5: 1}

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:

>>> from sympy import pprint
>>> pprint(factorint(240, visual=True))
 4  1  1
2 ⋅3 ⋅5

Accéder à la documentation et au code source d'une fonction

Comme on l'a déjà vu, pour obtenir de l'aide sur une fonction f, il suffit d'écrire ?f ou f?. Par exemple:

>>> 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:

>>> Rational??

Variable symbolique

La fonction Symbol de SymPy permet de créer une variable symbolique:

>>> from sympy import Symbol
>>> a = Symbol("a")     # le symbole a est stocké dans la variable a
>>> a
a

Cette variable peut être additionnée, soustraite, multipliée et divisée:

>>> a + a + a + a * a + 1/a - a
a**2 + 2*a + 1/a

Pour plus de commodité, on peut importer les variables les plus souvent utilisées du sous-module abc:

>>> from sympy.abc import a, epsilon
>>> a + a * a + epsilon
a**2 + a + epsilon

Définir les variables symboliques x₁, x₂, ..., x_n

En SymPy, on peut créer plusieurs variables x_i indicées pour i = a, ..., b − 1 à l'aide de la fonction symbols("xa:b") où a et b sont remplacés par des nombres entiers:

>>> from sympy import symbols
>>> x4,x5,x6,x7,x8 = symbols("x4:9")
>>> x4 + x5 + x6 + x7 + x8
x4 + x5 + x6 + x7 + x8

Affichage automatique des résultats en LaTeX

Pour que les résultats soient affichés en LaTeX automatiquement, il suffit d'utiliser la commande suivante une seule fois pour le fichier:

>>> from sympy import init_printing
>>> init_printing(use_latex='mathjax')

Dans le notebook Jupyter, cette commande utilise la librairie MathJax.

Dans ces notes, on utilisera l'option init_printing(use_latex='mathjax', use_unicode=False) lorsque cela aide la lecture des formules. Pour un exemple de la section précédente, on obtient:

>>> from sympy.abc import a, epsilon
>>> a + a * a + epsilon
 2
a  + a + ε

Expressions symboliques

On peut faire des calculs impliquant plus d'une variable:

>>> from sympy.abc import a,b
>>> (a + b)**2
(a + b)**2

ou impliquant les fonctions de SymPy:

>>> from sympy import sin,cos
>>> sin(a)**2 + cos(a)**2 + b
b + sin(a)**2 + cos(a)**2

Les expressions symboliques peuvent combiner des rationels, des fonctions et des constantes de toutes sortes:

>>> from sympy import Rational,pi,exp,I
>>> from sympy.abc import x,y
>>> Rational(3,2)*pi + exp(I*x) / (x**2 + y)
3*pi/2 + exp(I*x)/(x**2 + y)

Représentation interne

Pour voir comment une expression symbolique est représentée dans la machine, on peut utiliser la fonction srepr:

>>> from sympy import srepr
>>> expr = x - y
>>> srepr(x - y)
"Add(Symbol('x'), Mul(Integer(-1), Symbol('y')))"

L'expression symbolique est représentée par un arbre d'opérations.

Pour information, l'image a été créée avec Graphviz avec le resultat de la fonction dotprint:

>>> from sympy.printing.dot import dotprint
>>> s = dotprint(expr)

Substitutions

Pour substituer certaines variables dans une expression, on utilise la méthode subs qui s'écrit après l'expressions sous la forme expressions.subs(<INPUT>). Par exemple:

>>> from sympy.abc import a,b,c
>>> expression = a + 2*b + 3*c
>>> expression.subs(a,9)
2*b + 3*c + 9

Pour faire plus d'une substitutions, on peut les indiquer dans un dictionaire ({}) comme ci-bas:

>>> expression.subs({a:9, b:4})
3*c + 17
>>> expression.subs({a:9, b:4, c:100})
317

On peut aussi substituer une variable symbolique par une expression symbolique:

>>> from sympy import log
>>> from sympy.abc import x,y,z
>>> expression.subs({a:x**2, b:log(y), c:z})
x**2 + 3*z + 2*log(y)

Constantes symboliques

Contrairement au module math de Python où le nombre pi est représenté par une approximation décimale, dans SymPy, le nombre pi est représenté symboliquement. C'est une constante symbolique:

>>> from sympy import pi
>>> pi
pi

Cela permet de faire des calculs exacts. Par exemple, le sinus d'un angle de :

>>> from sympy import sin, pi
>>> sin(pi/3)
  ___
\/ 3
-----
  2

La fonction inverse du sinus aussi appelée arc sinus et représentée par la fonction asin dans SymPy peut retourner des expressions symboliques impliquant des constantes symboliques telles que le nombre π:

>>> from sympy import asin, Rational
>>> asin(1)
pi
--
2
>>> asin(Rational(1,2))
pi
--
6

SymPy sait que les fonctions sinus et arc sinus sont inverses une de l'autre:

>>> from sympy.abc import x
>>> sin(asin(x))
x

ATTENTION

La fonction sin du module math de Python ne peut pas être appelée sur des expressions symboliques, car elle assume que l'argument est un nombre réel (type float):

>>> from sympy.abc import
>>> from math import sin
>>> sin(x)
Traceback (most recent call last):
...
TypeError: can't convert expression to float

Simplifier une expression

Les expressions ne sont pas toujours simplifiées:

>>> from sympy import sin,cos
>>> from sympy.abc import a
>>> r = sin(a)**2 + cos(a)**2
>>> r
sin(a)**2 + cos(a)**2

Pour simplifier une expression, on utilise la commande simplify:

>>> from sympy import simplify
>>> simplify(r)
1

Voici un autre exemple:

>>> simplify((x**3 + x**2 - x - 1)/(x**2 + 2*x + 1))
x - 1

La fonction simplify performe une série de simplifications dans un ordre bien choisi. Les simplifications spécifiques incluent besselsimp, combsimp, exptrigsimp, hypersimp, nsimplify, powsimp, radsimp, ratsimp, ratsimpmodprime, signsimp, simplify, simplify_logic, trigsimp et d'autres encore. Il suffit de consulter le code simplify?? pour voir ce qui se passe et dans quel ordre.

Lorsque l'on sait exactement ce qu'on veut faire sur l'expression symbolique (factoriser, mettre sur un dominateur commun, etc.), on peut utiliser directement la bonne fonction. Cela peut retourner un résultat plus rapidement. Les plus importantes fonctions de modification d'expressions symboliques sont décrites dans les sections qui suivent. On trouvera plus d'informations sur les façons de simplifier une expression dans le tutoriel de SymPy: http://docs.sympy.org/latest/tutorial/simplification.html

Développer une expression

Pour développer une expression, on utilise la fonction expand:

>>> from sympy import expand
>>> from sympy.abc import a,b
>>> (a + b)**2
(a + b)**2
>>> expand((a + b)**2)
a**2 + 2*a*b + b**2

Cela peut mener à des simplifications:

>>> (a + b)**2 - (a - b)**2
-(a - b)**2 + (a + b)**2
>>> expand(_)
4*a*b

Note: En IPython et Jupyter, la barre de soulignement (_) est une variable qui contient le dernier résultat calculé. Aussi, la double barre de soulignement (__) est une variable qui contient l'avant-dernier résultat calculé. Finalement, la triple barre de soulignement (___) est une variable qui contient l'avant-avant-dernier résultat calculé. La quadruple barre de soulignement ne contient rien.

Annuler les facteurs communs d'une fraction

Pour annuler les facteurs communs dans une fonction rationnelle, on utilise cancel:

>>> expr = (x**2 + x*y) / x
>>> expr
(x**2 + x*y)/x
>>> from sympy import cancel
>>> cancel(expr)
x + y

Factoriser un polynôme

La fonction factor de SymPy permet de factoriser un polynôme en un produit de facteurs irréductibles sur l'anneau des nombres rationnels:

>>> from sympy import factor
>>> factor(x**3 - x**2 + x - 1)
(x - 1)*(x**2 + 1)

Pour factoriser le polynôme sur les nombres de Gauss (nombres complexes à parties imaginaire et réelle entières), on ajoute l'option gaussian=True:

>>> factor(x**3 - x**2 + x - 1, gaussian=True)
(x - 1)*(x - I)*(x + I)

Pour faire la factorisation sur une extension algébrique des nombres rationnels, il suffit de spéficifier un ou des nombres algébriques qui engendrent l'extension:

>>> factor(x**2 - 5)
x**2 - 5
>>> factor(x**2 - 5, extension=sqrt(5))
(x - sqrt(5))*(x + sqrt(5))

Consulter la documentation factor? pour obtenir de l'aide sur la factorisation de polynômes sur d'autres domaines ou sur des extensions de corps.

Rassembler les termes d'une expression

La fonction collect rassemble les puissances communes d'un terme dans une expression. Par exemple:

>>> expr = x*z + x**2 + x + x*y + x**2 * w + 5 - x**3
>>> expr
w*x**2 - x**3 + x**2 + x*y + x*z + x + 5

On rassemble les termes selon les puissances de x:

>>> from sympy import collect
>>> collect(expr, x)
-x**3 + x**2*(w + 1) + x*(y + z + 1) + 5

Réduire au même dénominateur

Une somme de fonctions rationnelles reste sous forme de somme:

>>> from sympy.abc import x,y,z
>>> 1/(x+1) + 1/y + 1/z
  1     1   1
----- + - + -
x + 1   z   y

Pour la mettre au même dénominateur, on utilise ratsimp:

>>> from sympy import ratsimp
>>> ratsimp(1/(x+1) + 1/y + 1/z)
x*y + x*z + y*z + y + z
-----------------------
      x*y*z + y*z

Alternativement, on peut aussi utiliser la fonction together. À la différence de ratsimp la fonction together préserve le plus possible les termes sous la forme initiale:

>>> from sympy import together
>>> together(1/(x+1) + 1/y + 1/z)
y*z + y*(x + 1) + z*(x + 1)
---------------------------
        y*z*(x + 1)

Décomposition en fractions partielles

Soit un fraction rationnelle:

>>> expr = (3*x**2  + 52*x - 265) / ((x - 7)*(x - 1)*(x + 34))
>>> expr
      2
   3*x  + 52*x - 265
------------------------
(x - 7)*(x - 1)*(x + 34)

On peut la décomposer en somme de fractions rationnelles à l'aide de la fonction apart de SymPy:

>>> from sympy import apart
>>> apart(expr)
  1        1       1
------ + ----- + -----
x + 34   x - 1   x - 7

Rationalisation du dénominateur d'une expression

Pour rationaliser le dénominateur d'un expression, on utilise la fonction radsimp de SymPy:

>>> A = 1 / (1+sqrt(5))
>>> A
    1
---------
      ___
1 + \/ 5
>>> from sympy import radsimp
>>> radsimp(A)
       ___
-1 + \/ 5
----------
    4

Définir une équation

La fonction Eq permet de définir une équation:

>>> from sympy import Eq
>>> from sympy.abc import x,y
>>> Eq(x, 3)
x == 3
>>> Eq(x + y, 3)
x + y == 3

Résoudre une équation

La fonction solve permet de résoudre une équation:

>>> from sympy import solve
>>> solve(Eq(x, 3), x)
[3]
>>> solve(Eq(x + y, 3), x)
[-y + 3]

Dans le premier cas, indiquer la variable x n'est pas nécessaire:

>>> solve(Eq(x, 3))
[3]

Cela fonctionne aussi s'il y a plus d'une solution:

>>> solve(Eq(x**2, 3))
[-sqrt(3), sqrt(3)]

Résoudre un système d'équations

La fonction solve permet aussi de résoudre un système d'équations. Par exemple pour trouver deux variables x et y telle que leur somme vaut 47 et leur différence vaut 33:

>>> eq1 = Eq(x + y, 47)
>>> eq2 = Eq(x - y, 33)
>>> [eq1, eq2]
[x + y == 47, x - y == 33]
>>> solve([eq1, eq2])
{x: 40, y: 7}

Attention: Pour résoudre un système d'équations, il faut absoluement mettre les équations dans une liste [eq1, eq2] entre crochets []. Autrement, on obtient une erreur:

>>> solve(eq1, eq2)
Traceback (most recent call last):
...
TypeError: cannot determine truth value of x - y == 33

Cela fonctionne aussi pour des systèmes d'équations non linéaires. Par exemple pour trouver deux nombres dont la somme est 47 et dont le produit est 510:

>>> eq1 = Eq(x + y, 47)
>>> eq2 = Eq(x * y, 510)
>>> [eq1, eq2]
[x + y == 47, x*y == 510]
>>> solve([eq1, eq2])
[{x: 17, y: 30}, {x: 30, y: 17}]

Syntaxe abrégée

Souvent on désire résoudre des équations dont l'un des termes est zéro: solve(Eq(expression,0)). Pour ce cas, il est équivalent d'écrire solve(expression) et la fonction solve trouvera les valeurs des variables avec lesquelles expression est évaluée à zéro. Les exemples ci-haut s'écrivent de la façon suivante avec cette syntaxe abrégée:

>>> solve(x - 3)
[3]
>>> solve(x**2 + x - 6)
[-3, 2]
>>> solve([x + y - 47, x - y - 33])
{x: 40, y: 7}
>>> solve([x + y - 47, x * y - 510])
[{x: 17, y: 30}, {x: 30, y: 17}]

Un exemple sur un polynôme de degré 3:

>>> solve(x**3 + 2*x**2 - 1, x)
             ___      ___
       1   \/ 5     \/ 5    1
[-1, - - + -----, - ----- - -]
       2     2        2     2

La syntaxe abrégée peut aussi être utilisée pour résoudre un système d'équations. Dans l'exemple qui suit, on calcule les points d'intersection d'une ellipse et d'une droite:

>>> solve( [x**2 + 4*y**2 -2, -10*x + 2*y -15], [x, y])
            ____              ____                ____              ____
    150   \/ 23 *I   15   5*\/ 23 *I      150   \/ 23 *I   15   5*\/ 23 *I
[(- --- - --------, --- - ----------), (- --- + --------, --- + ----------)]
    101     101     202      101          101     101     202      101

Trouver les racines d'une fonction

La fonction roots permet de calculer les racines d'une fonction polynomiale univariée:

>>> from sympy import roots
>>> roots(x - 7)
{7: 1}
>>> roots(x**6)
{0: 6}

Le résultat est un dictionnaire ({}) qui associe à chaque racine sa multiplicité. La fonction roots trouve aussi les racines complexes:

>>> roots(x**5 - 7*x**4 + 2*x**3 - 14*x**2 + x - 7, x)
{7: 1, -I: 2, I: 2}

Les coefficients des polynômes peuvent être des variables symboliques:

>>> from sympy.abc import a,b,c
>>> roots(a*x + b, x)
{-b/a: 1}

Mais à ce moment-là, il faut absoluement spécifier par rapport à quelle variable on cherche les racines. Autrement, on obtient une erreur:

>>> roots(a*x + b)
Traceback (most recent call last)
...
PolynomialError: multivariate polynomials are not supported

La fonction roots trouve les formules qui expriment les racines d'un polynôme quadratique:

>>> roots(a*x**2 + b*x + c, x)
            _____________                _____________
           /           2                /           2
    b    \/  -4*a*c + b          b    \/  -4*a*c + b
{- --- - ----------------: 1, - --- + ----------------: 1}
   2*a         2*a              2*a         2*a

On trouvera d'autres exemples (résolution d'équations différentielles) et des explications plus détaillées dans la section Solver du tutoriel de SymPy: http://docs.sympy.org/latest/tutorial/solvers.html

Tracer une fonction ℝ → ℝ

On importe la fonction plot qui permet de dessiner des fonctions:

>>> from sympy import plot

Un premier exemple. Par défaut, l'intervalle pour les x est [ − 10, 10]:

>>> from sympy import sin
>>> from sympy.abc import x
>>> plot(sin(x))

Un deuxième exemple sur l'intervalle [ − 100, 100]:

>>> plot(sin(x)/x, (x,-100,100))

On trace une parabole de couleur rouge dans l'intervale [ − 5, 5] avec un titre:

>>> plot(x**2+x-6, (x,-5,5), line_color='red', title='Youpi')

Tracer plusieurs fonctions ℝ → ℝ

On trace plusieurs fonctions sur le même intervalle de la façon suivante. Dans cet exemple, on a aussi spécifier une limite inférieure et supérieure pour l'axe des y:

>>> plot(x, x**2, x**3, (x, -2, 2), ylim=(-2,2))

Pour dessiner les trois fonctions avec des couleurs différentes, il faut créer un dessin à la fois et ensuite les combiner. L'option show=False permet d'éviter d'afficher les dessins intermédiaires:

>>> p1 = plot(x,    (x, -1, 1), show=False, line_color='b')
>>> p2 = plot(x**2, (x, -1, 1), show=False, line_color='r')
>>> p3 = plot(x**3, (x, -1, 1), show=False, line_color='g')

On ajoute à p1 les graphes p2 et p3:

>>> p1.extend(p2)
>>> p1.extend(p3)

Maintenant p1 contient les trois graphes:

>>> print(p1)
Plot object containing:
[0]: cartesian line: x for x over (-1.0, 1.0)
[1]: cartesian line: x**2 for x over (-1.0, 1.0)
[2]: cartesian line: x**3 for x over (-1.0, 1.0)

On affiche le graphe des trois fonctions:

>>> p1.show()

Tracer une fonction ℝ² → ℝ

On importe la fonction plot3d du sous-module sympy.plotting:

>>> from sympy.plotting import plot3d

Un premier exemple:

>>> from sympy.abc import x,y
>>> plot3d(x**2+y**2)

Un deuxième exemple:

>>> plot3d(sin(x*10)*cos(y*4), (x, -1, 1), (y, -1, 1))

On trouvera d'autres exemples en consultant la documentation de plot? et plot3d? ou dans la section Plotting du tutoriel de Sympy: http://docs.sympy.org/latest/modules/plotting.html

Dessiner une fonction ℝ → ℝ²

Dans cette section et les suivantes, on aura utilisera les fonctions et variables symboliques suivantes:

>>> from sympy import sin, cos
>>> from sympy.abc import u, v

La fonction plot_parametric permet de tracer des fonctions paramétrés ℝ → ℝ². Par exemple, on trace la courbe de Lissajous lorsque a = 3 et b = 2:

>>> from sympy.plotting import plot_parametric
>>> plot_parametric(cos(3*u), sin(2*u), (u, -5, 5))

Dessiner une fonction ℝ → ℝ³

La fonction plot3d_parametric_line permet de tracer des courbes dans l'espace 3d. Par exemple, on trace une hélice:

>>> from sympy.plotting import plot3d_parametric_line
>>> plot3d_parametric_line(cos(u), sin(u), u, (u, -15, 15))

Dessiner une fonction ℝ² → ℝ³

La fonction plot3d_parametric_surface permet de tracer des surfaces dans ℝ³. Par exemple, on trace un tore:

>>> from sympy.plotting import plot3d_parametric_surface
>>> X = cos(u)*(5+2*cos(v))
>>> Y = sin(u)*(5+2*cos(v))
>>> Z = 2*sin(v)
>>> plot3d_parametric_surface(X, Y, Z, (u, -.5, 4), (v, -5, 5))

Dessiner les solutions d'une équation implicite

>>> from sympy import plot_implicit, Eq
>>> from sympy.abc import x, y

La fonction plot_implicit permet de tracer les solutions d'une équation implicite:

>>> eq = Eq(x**2+y**2+x*y-2*x, 5)
>>> eq
x**2 + x*y - 2*x + y**2 == 5
>>> plot_implicit(eq)

On peut modifier les étendues des variables x et y de la façon suivante (le dessin n'est pas affiché dans ces notes):

>>> plot_implicit(eq, (x,-2,5), (y,-5,3))

Tracer une région de ℝ²

La fonction plot_implicit peut aussi servir à dessiner une région de points qui satisfont une inégalité:

>>> plot_implicit(y > 2*x+1)

Pour tracer la région définie par plusieurs inégalités, on utilise la fonction And de sympy:

>>> from sympy import And
>>> plot_implicit(And(y>2*x+1, y<5*x, x+y<5))

Dessiner une fonction complexe avec mpmath

mpmath est une librairie Python pour faire des calculs en précision arbitraire sur les nombres flottants. Elle permet aussi de faire des dessins de fonctions complexes.

La façon d'importer la librairie mpmath n'est pas exactement la même selon qu'on utilise une installation normale de SymPy ou qu'on utilise SageMath:

>>> from sympy import mpmath    # Sympy (installation normale)
>>> import mpmath               # SageMath

Rappelons que sans la ligne suivante, les dessins ne s'afficheront pas:

>>> %matplotlib inline

La syntaxe des arguments n'est pas exactement la même que pour la fonction plot de SymPy. Il faut définir une fonction Python avec la commande def ou encore sur une ligne avec lambda. Par exemple, la fonction identité peut s'écrire lambda z:z en Python.

On trace la fonction identité pour comprendre la signification de l'image obtenue:

>>> mpmath.cplot(lambda z: z, [-10, 10], [-10, 10])

Les couleurs de l'arc en ciel doivent être interprétés comme l'argument d'un nombre complexe (rouge pour un nombre réel positif). Le module du nombre complexe est représenté par la transparence (0=noir opaque, ∞ = oo = blanc transparent).

De la même façon, on ne peut pas utiliser le I de sympy avec mpmath, il faut utiliser les nombres complexes de Python. Le dessin suivant illustre la multiplication par le nombre complexe i, c'est-à-dire une rotation de 90 degrés:

>>> I = complex(0,1)         # le nombre complexe I de Python
>>> mpmath.cplot(lambda z: I*z, [-10, 10], [-10, 10])

Les pixels en rouges sont envoyés sur la droite réelle positive par la fonction lambda z: I*z.

Le dessin suivant permet de voir les cinq racines cinquième de l'unité:

>>> mpmath.cplot(lambda z: z**5-1, [-2, 2], [-2, 2])

Cela permet aussi d'étudier les zéros de la fonction zeta de Riemann:

>>> from mpmath import zeta
>>> mpmath.cplot(zeta, [-10, 10], [-50, 50])

mpmath offre aussi sa propre fonction de dessin mpmath.plot ainsi qu'une fonction pour dessiner des surfaces en 3d mpmath.splot. On trouvera d'autres exemples dans la page suivante de la documentation de Sympy: http://docs.sympy.org/latest/modules/mpmath/plotting.html

Limites

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). :

>>> 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³, on écrit:

>>> limit((sin(x)-x)/x**3, x, 0)
-1/6

La limite de f(x) = 2x + 1 lorsque x → 5 ⁄ 2:

>>> limit(2*x+1, x, S(5)/2)   # la fonction S permet de créer un nombre rationel
6

Pour calculer la limite à gauche en un point, on doit spécifier l'option dir="-":

>>> limit(1/x, x, 0, dir="-")
-oo

Pour calculer la limite à droite en un point, on doit spécifier l'option dir="+":

>>> limit(1/x, x, 0, dir="+")
oo

Lorsque la direction n'est pas spécifiée, c'est la limite à droite (dir="+") qui est calculée par défaut:

>>> limit(1/x, x, 0)
oo

En sympy, tout comme dans SageMath, le symbole oo représente l'infini ∞. 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:

>>> from sympy import oo
>>> oo
oo
>>> 5 - oo
-oo
>>> oo - oo           # nan signifie "Not A Number"
nan

On peut calculer la limite d'une expression lorsque x tend vers plus l'infini:

>>> limit(1/x, x, oo)
0

et aussi lorsque x tend vers moins l'infini:

>>> limit(4+x*exp(x), x, -oo)
4

Sympy procède à des simplifications lorsque possible:

>>> limit((1+1/x)**x, x, oo)
E

Sommes

En Python, il existe une fonction (sum) que l'on a pas besoin d'importer et qui permet de calculer la somme des valeurs d'une liste:

>>> sum([1,2,3,4,5])
15

Cette fonction sum permet aussi de calculer une somme impliquant des variables et expressions symboliques de SymPy:

>>> from sympy import tan
>>> from sympy.abc import x,z
>>> sum([1,2,3,4,5,x,tan(z)])
x + tan(z) + 15

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:

>>> 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)):

>>> from sympy.abc import n
>>> summation(n, (n,1,5))
15

Le début et la fin de l'intervalle des valeurs de n peut être donné par des variables symboliques:

>>> from sympy.abc import a,b
>>> summation(n, (n,1,b))
 2
b    b
-- + -
2    2
>>> summation(n, (n,a,b))
   2        2
  a    a   b    b
- -- + - + -- + -
  2    2   2    2

Pour faire la somme d'une série pour tous les nombres entiers de 1 à l'infini, on utilise le symbole oo:

>>> from sympy import oo
>>> summation(1/n**2, (n, 1, oo))
  2
pi
---
 6

Si la série est divergente, elle sera évaluée à oo ou encore elle restera non évaluée:

>>> summation(n, (n,1,oo))
oo
>>> summation((-1)**n, (n,1,oo))
  oo
 ___
 \  `
  \       n
  /   (-1)
 /__,
n = 1

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:

>>> from sympy.abc import m,n
>>> summation(n*m, (n,1,m), (m,1,10))
1705

Les doubles sommes fonctionnent aussi avec des intervalles infinis:

>>> summation(1/(n*m)**2, (n,1,oo), (m,1,oo))
  4
pi
---
 36

Produit

Comme pour la somme, le calcul d'un produit 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 product(expression (n,debut,fin)):

>>> from sympy import product
>>> from sympy.abc import n,b
>>> product(n, (n,1,5))
120
>>> product(n, (n,1,b))
b!

Voici un autre exemple:

>>> product(n*(n+1), (n, 1, b))
RisingFactorial(2, b)*b!

Calcul différentiel

Pour dériver une fonction par rapport à une variable x, on utilise la fonction diff de sympy avec la syntaxe diff(fonction, x):

>>> from sympy import diff

Faisons quelques importations de fonctions et variables pour la suite:

>>> from sympy import sin,cos,tan,atan,pi
>>> from sympy.abc import x,y

On calcule la dérivée de sin(x):

>>> diff(sin(x), x)
cos(x)

Voici quelques autres exemples:

>>> diff(cos(x**3), x)
    2    / 3\
-3*x *sin\x /
>>> diff(atan(2*x), x)
   2
--------
   2
4*x  + 1
>>> diff(1/tan(x), x)
     2
- tan (x) - 1
-------------
      2
   tan (x)

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:

>>> diff(sin(x), x, x, x)
-cos(x)
>>> diff(sin(x), x, 3)
-cos(x)

Cela fonctionne aussi avec des variables différentes:

>>> diff(x**2*y**3, x, y, y)
12*x*y

Calcul intégral

Le calcul d'une intégrale indéfinie se fait avec la fonction integrate avec la syntaxe integrate(f, x):

>>> from sympy import integrate

Par exemple:

>>> integrate(1/x, x)
log(x)

Le calcul d'une intégrale définie se fait aussi avec la fonction integrate avec la syntaxe integrate(f, (x, a, b)):

>>> integrate(1/x, (x, 1, 57))
log(57)

Voici quelques autres exemples:

>>> from sympy import exp
>>> integrate(cos(x)*exp(x), x)
 x           x
e *sin(x)   e *cos(x)
--------- + ---------
    2           2

>>> integrate(x**2, (x,0,1))
1/3

L'intégrale d'une fonction rationnelle:

>>> integrate((x+1)/(x**2+4*x+4), x)
               1
log(x + 2) + -----
             x + 2

L'intégrale d'une fonction exponentielle polynomiale:

>>> integrate(5*x**2 * exp(x) * sin(x), x)
   2  x             2  x                             x             x
5*x *e *sin(x)   5*x *e *cos(x)        x          5*e *sin(x)   5*e *cos(x)
-------------- - -------------- + 5*x*e *cos(x) - ----------- - -----------
      2                2                               2             2

Deux intégrales non élémentaires:

>>> from sympy import erf
>>> integrate(exp(-x**2)*erf(x), x)
  ____    2
\/ pi *erf (x)
--------------
      4

Calculer l'intégrale de x²cos(x) par rapport à x:

>>> integrate(x**2 * cos(x), x)
 2
x *sin(x) + 2*x*cos(x) - 2*sin(x)

Calculer l'intégrale définie de x²cos(x) par rapport à x sur l'intervalle de 0 à π ⁄ 2:

>>> integrate(x**2 * cos(x), (x, 0, pi/2))
       2
     pi
-2 + ---
      4

Sommes, produits, dérivées et intégrales non évaluées

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.

>>> from sympy import Sum, Product, Derivative, Integral, sin, oo
>>> from sympy.abc import n, x
>>> Sum(1/n**2, (n, 1, oo))
  oo
____
\   `
 \    1
  \   --
  /    2
 /    n
/___,
n = 1
>>> Product(n, (n,1,10))
  10
_____
|   | n
|   |
n = 1
>>> Derivative(sin(x**2), x)
d /   / 2\\
--\sin\x //
dx
>>> Integral(1/x**2, (x,1,oo))
 oo
  /
 |
 |  1
 |  -- dx
 |   2
 |  x
 |
/
1

Pour les évaluer, on ajoute .doit():

>>> Sum(1/n**2, (n, 1, oo)).doit()
  2
pi
---
 6
>>> Product(n, (n,1,10)).doit()
3628800
>>> Derivative(sin(x**2), x).doit()
       / 2\
2*x*cos\x /
>>> Integral(1/x**2, (x,1,oo)).doit()
1

Cela est utile pour écrire des équations:

>>> 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())
  oo
____
\   `        2
 \    1    pi
  \   -- = ---
  /    2    6
 /    n
/___,
n = 1
>>> Eq(B, B.doit())
  10
_____
|   | n = 3628800
|   |
n = 1
>>> Eq(C, C.doit())
d /   / 2\\          / 2\
--\sin\x // = 2*x*cos\x /
dx
>>> Eq(D, D.doit())
 oo
  /
 |
 |  1
 |  -- dx = 1
 |   2
 |  x
 |
/
1

Intégrales multiples

Pour faire une intégrale double, on peut intégrer le résultat d'une première intégration comme ceci:

>>> from sympy.abc import x,y
>>> integrate(integrate(x**2+y**2, x), y)
 3        3
x *y   x*y
---- + ----
 3      3

Mais, il est plus commode d'utiliser une seule fois la commande integrate et sympy permet de le faire:

>>> integrate(x**2+y**2, x, y)
 3        3
x *y   x*y
---- + ----
 3      3

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]:

>>> integrate(x**2+y**2, (x,0,y), (y,0,10))
10000/3

Développement en séries

On calcule la série de Taylor d'une expression qui dépend de x au point x0 d'ordre n avec la syntaxe series(expression, x, x0, n). Par exemple, la série de Maclaurin (une série de Maclaurin est une série de Taylor au point x₀ = 0) de cos(x) d'ordre 14 est:

>>> from sympy import series, cos
>>> from sympy.abc import x
>>> series(cos(x), x, 0, 14)
     2    4     6      8       10         12
    x    x     x      x       x          x         / 14\
1 - -- + -- - --- + ----- - ------- + --------- + O\x  /
    2    24   720   40320   3628800   479001600

Par défaut, le développement est efféctuée en 0 et est d'ordre 6:

>>> series(cos(x), x)
     2    4
    x    x     / 6\
1 - -- + -- + O\x /
    2    24

De façon équivalente, on peut aussi utilise la syntaxe expression.series(x, x0, n):

>>> (1/cos(x**2)).series(x, 0, 14)
     4      8       12
    x    5*x    61*x      / 14\
1 + -- + ---- + ------ + O\x  /
    2     24     720

Le développement de Taylor de log se fait en x₀ = 1:

>>> from sympy import log
>>> series(log(x), x, 0)
log(x)
>>> series(log(x), x, 1)
            2          3          4          5
     (x - 1)    (x - 1)    (x - 1)    (x - 1)         /       6        \
-1 - -------- + -------- - -------- + -------- + x + O\(x - 1) ; x -> 1/
        2          3          4          5

Équations différentielles

Une équation différentielle est une relation entre une fonction inconnue et ses dérivées. Comme la fonction est inconnue, on doit la définir de façon abstraite comme ceci:

>>> from sympy import Function
>>> f = Function("f")

Déjà, cela permet d'écrire f et f(x):

>>> f
f
>>> from sympy.abc import x
>>> f(x)
f(x)

On peut définir les dérivées de f à l'aide de la fonction Derivative de sympy:

>>> from sympy import Derivative
>>> Derivative(f(x), x)             # ordre 1
d
--(f(x))
dx
>>> Derivative(f(x), x, x)          # ordre 2
  2
 d
---(f(x))
  2
dx

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:

>>> Eq(f(x), Derivative(f(x),x))
       d
f(x) = --(f(x))
       dx

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:

>>> from sympy import dsolve
>>> dsolve(Eq(f(x), Derivative(f(x),x)), f(x))
           x
f(x) = C1*e

Voici un autre exemple qui trouve une fonction égale à l'opposé de sa dérivée d'ordre 2:

>>> Eq(f(x), -Derivative(f(x),x,x))
           2
          d
f(x) = - ---(f(x))
           2
         dx
>>> dsolve(Eq(f(x), -Derivative(f(x),x,x)), f(x))
f(x) = C1*sin(x) + C2*cos(x)

Résoudre une équation différentielle ordinaire comme f’’(x) + 9f(x) = 1 :

>>> dsolve(Eq(Derivative(f(x),x,x) + 9*f(x), 1), f(x))
f(x) = C1*sin(3*x) + C2*cos(3*x) + 1/9

Pour définir la dérivée, on peut aussi utiliser .diff(). L'exemple précédent s'écrit:

>>> dsolve(Eq(f(x).diff(x, x) + 9*f(x), 1), f(x))
f(x) = C1*sin(3*x) + C2*cos(3*x) + 1/9

Finalement, voici un exemple impliquant deux équations:

>>> 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
 d                            d           2
[--(x(t)) = x(t)*y(t)*sin(t), --(y(t)) = y (t)*sin(t)]
 dt                           dt
>>> dsolve(systeme)
                   C1
                 -e                     -1
set([x(t) = ---------------, y(t) = -----------])
                C1                  C1 - cos(t)
            C2*e   - cos(t)

Définir une matrice

En SymPy, on peut créer une matrice avec la fonction Matrix:

>>> from sympy import Matrix

Il suffit d'écrire les entrées lignes par lignes avec la syntaxe suivante:

>>> Matrix([[2, 5, 6], [4, 7, 10], [1, 0, 3]])
[2  5  6 ]
[        ]
[4  7  10]
[        ]
[1  0  3 ]

Une autre façon équivalente est de spécifier le nombre de lignes, le nombre de colonnes et puis la liste des entrées:

>>> Matrix(2, 3, [1, 2, 3, 4, 5, 6])
[1  2  3]
[       ]
[4  5  6]

Par défaut, si on ne spécifie pas les dimensions de la matrice, un vecteur colonne est retourné:

>>> Matrix([1,2,3,4])
[1]
[ ]
[2]
[ ]
[3]
[ ]
[4]

Opérations de base

Les opérations de l'algèbre des matrices (addition, multiplication, multiplication par un scalaire) sont définies naturellement:

>>> M = Matrix([[5, 2], [-1, 7]])
>>> N = Matrix([[0, 4], [0, 5]])
>>> M + N
[5   6 ]
[      ]
[-1  12]
>>> M * N
[0  30]
[     ]
[0  31]
>>> 4 * M
[20  8 ]
[      ]
[-4  28]
>>> M ** 5
[-475   12242]
[            ]
[-6121  11767]

De même, on peut calculer l'inverse d'une matrice si elle est inversible:

>>> M**-1
[7/37  -2/37]
[           ]
[1/37  5/37 ]
>>> N**-1
Traceback (most recent call last):
...
ValueError: Matrix det == 0; not invertible.

La transposition d'une matrice se fait avec .transpose():

>>> from sympy import I
>>> M = Matrix(( (1,2+I,5), (3,4,0) ))
>>> M
[1  2 + I  5]
[           ]
[3    4    0]
>>> M.transpose()
[  1    3]
[        ]
[2 + I  4]
[        ]
[  5    0]

Accéder aux coefficients

>>> from sympy import I
>>> M = Matrix(( (1,2+I,5), (3,4,0) ))
>>> M
[1  2 + I  5]
[           ]
[3    4    0]

On accède à l'élément en position (i,j) en écrivant M[i,j]:

>>> M[0,1]
2 + I
>>> M[1,1]
4

Attention: Les indices des positions commencent à zéro!!

On accède aux lignes et au colonnes d'une matrices avec les méthodes row et col:

>>> M.row(1)
[3  4  0]
>>> M.col(0)
[1]
[ ]
[3]

Construction de matrices particulières

Les fonctions zeros et ones permettent de créer des matrices de zéros et de uns:

>>> from sympy import ones,zeros
>>> ones(2)
[1, 1]
[1, 1]
>>> zeros((2, 4))
[0, 0, 0, 0]
[0, 0, 0, 0]

La fonction eye de sympy permet de créer une matrice identité:

>>> from sympy import eye
>>> eye(3)
[1, 0, 0]
[0, 1, 0]
[0, 0, 1]

La fonction diag permet de créer une matrice diagonale:

>>> from sympy import diag
>>> diag(1,2,3)
[1  0  0]
[       ]
[0  2  0]
[       ]
[0  0  3]

Les éléments de la diagonales peuvent être eux-mêmes des matrices:

>>> diag(1, 2, Matrix([[7,8],[2,3]]))
[1  0  0  0]
[          ]
[0  2  0  0]
[          ]
[0  0  7  8]
[          ]
[0  0  2  3]

Matrice échelonnée réduite

On calcule la forme échelonnée réduite d'une matrice avec la méthode rref (abbréviation de reduced row echelon form en anglais):

>>> M = Matrix([[1, 2, 0, 3], [2, 6, 5, 1], [-1, -4, -5, 2]])
>>> M.rref()
([1  0  -5    8  ], [0, 1])
 [               ]
 [0  1  5/2  -5/2]
 [               ]
 [0  0   0    0  ]

Noyau

On calcule le noyau d'une matrice avec nullspace:

>>> M = Matrix([[1, 2, 0, 3], [2, 6, 5, 1], [-1, -4, -5, 2]])
>>> M.nullspace()
[[ 5  ], [-8 ]]
 [    ]  [   ]
 [-5/2]  [5/2]
 [    ]  [   ]
 [ 1  ]  [ 0 ]
 [    ]  [   ]
 [ 0  ]  [ 1 ]

Déterminant

On calcule le déterminant avec la méthode det:

>>> M = Matrix([[2, 5, 6], [4, 7, 10], [1, 0, 3]])
>>> M.det()
-10

Polynôme caractéristique

La méthode charpoly permet de calculer le polynôme caractéristique d'une matrice carrée:

>>> M = Matrix([[3, -2,  4, -2], [5,  3, -3, -2], [5, -2,  2, -2], [5, -2, -3,  3]])
>>> from sympy.abc import x
>>> M.charpoly(x)
PurePoly(x**4 - 11*x**3 + 29*x**2 + 35*x - 150, x, domain='ZZ')

On ajoute .as_expr() pour obtenir l'expression symbolique du polynôme caractéristique:

>>> M.charpoly(x).as_expr()
 4       3       2
x  - 11*x  + 29*x  + 35*x - 150
>>> from sympy import factor
>>> factor(_)
       2
(x - 5) *(x - 3)*(x + 2)

Valeurs propres et vecteurs propres

Continuons avec la même matrice M définie précédemment:

>>>  M
[3  -2  4   -2]
[             ]
[5  3   -3  -2]
[             ]
[5  -2  2   -2]
[             ]
[5  -2  -3  3 ]

Soient les vecteurs colonnes w et v suivants:

>>> w = Matrix((1,2,3,4))
>>> v = Matrix((1,1,1,0))
>>> w
[1]
[ ]
[2]
[ ]
[3]
[ ]
[4]
>>> v
[1]
[ ]
[1]
[ ]
[1]
[ ]
[0]

En général, l'image par M d'un vecteur n'a rien à voir avec ce vecteur. Par exemple, l'image par M de w n'a rien à voir avec w:

>>> M * w
[3 ]
[  ]
[-6]
[  ]
[-1]
[  ]
[4 ]

Dans certains cas particuliers, l'image par M d'un vecteur retourne un multiple scalaire de ce vecteur. C'est ce qui se produit pour le vecteur v:

>>> M * v
[5]
[ ]
[5]
[ ]
[5]
[ ]
[0]

Le résultat précédent est égal à 5 fois le vecteur v:

>>> 5 * v
[5]
[ ]
[5]
[ ]
[5]
[ ]
[0]

Un vecteur v qui satisfait l'équation Mv = λv pour un certain nombre réel (ou complexe) λ est appelé vecteur propre. Le nombre λ qui satisfait l'équation est appelé valeur propre. Il se trouve que les valeurs propres d'une matrice sont les racines de son polynôme caractéristique. Le calcul des valeurs et vecteurs propres d'une matrice est utile dans presque tous les domaines des mathématiques.

En sympy, on calcule les valeurs propres d'une matrice avec la méthode eigenvals. Le résultat est un dictionnaire qui associe à chaque valeur propre sa multiplicité algébrique (comme pour le calcul des racines):

>>> M.eigenvals()
{-2: 1, 3: 1, 5: 2}

Et on calcule les vecteurs propres d'une matrice avec la méthode eigenvects:

>>> M.eigenvects()
[(-2, 1, [[0]]), (3, 1, [[1]]), (5, 2, [[1], [0 ]])]
          [ ]            [ ]            [ ]  [  ]
          [1]            [1]            [1]  [-1]
          [ ]            [ ]            [ ]  [  ]
          [1]            [1]            [1]  [0 ]
          [ ]            [ ]            [ ]  [  ]
          [1]            [1]            [0]  [1 ]

Le calcul précédent montre bien que le vecteur colonne v = [1, 1, 1, 0]^T est bien un vecteur propre de la matrice M associé à la valeur propre 5 comme on l'avait vu plus tôt. Il permet aussi de réaliser qu'un autre vecteur colonne linéairement indépendant de v est aussi un vecteur propre associé à la valeur propre 5. Finalement, il y a deux autres vecteurs propres associés aux valeurs propres -2 et 3.

Résumé des différences entre SymPy et Mathematica

En Python, on doit importer les fonctions que l'on utilise. Une par une en écrivant from sympy import factor,pi,sin ou toutes à la fois avec from sympy import *. En Mathematica, on n'a pas besoin d'importer les fonctions avant de les utiliser.

Tout d'abord, la règle générale en Mathematica est que les fonctions commencent avec une lettre majuscule plutôt qu'avec des minuscules. On écrit donc Sin, Pi, Factor en Mathematica plutôt que sin, pi et factor en SymPy.

Les noms des fonctions sont le plus souvent les mêmes qu'en SymPy, mais on note quelques différences comme FactorInteger, ArcSin et ParametricPlot en Mathematica versus factorint, asin et plot_parametric en SymPy. On trouve quelques autres fonctions qui portent des noms différents dans les tables à la fin de ce chapitre.

Pour évaluer une fonction, on utilise les parenthèses en SymPy sin(pi) et les crochets [] en Mathematica Sin[Pi].

Pour évaluer une cellule dans Mathematica comme dans Jupyter, c'est la même chose, on appuie sur les touches MAJUSCULE + ENTRÉE.

En SymPy comme en Python, la multiplication implite 3x n'est pas possible et il faut toujours écrire 3*x en spécifiant l'opération de multiplication (*). En Mathematica, les espaces vides sont interprétés comme des multiplications et 3x sans espace est interprété comme le produit du nombre 3 par la variable x.

En Mathematica, l'exponentiation s'écrit avec le symbole chapeau ^ plutôt qu'avec ** et la division de nombres entiers retourne bien un nombre rationnel.

Les listes comme [x, 0, 2*pi] et les tuples comme (x, 0, 2*pi) en Python et SymPy sont souvent utilisés comme arguments de fonctions. De la même façon en Mathematica, les listes sont beaucoup utilisées. Toutefois, en Mathematica, on utilise les accolades { et } pour définir une liste. On écrit alors {x, 0, 2*Pi}. Par exemple, l'intégrale de sin(x) s'écrit en SymPy:

>>> integrate(sin(x), (x, 0, 2*Pi))

En Mathematica, cela devient:

>>> Integrate[Sin[x], {x, 0, 2*Pi}]

En SymPy, on doit définir les symboles avec la fonction Symbol ou bien on peut les importer du sous-module sympy.abc. En Mathematica, toute variable non définie est par défaut un symbole et prend la couleur bleue (Mathematica v.10.0) pour les identifier.

En Mathematica, contrairement à SymPy, il n'y a pas de distinction entre la variable x et le symbole x. On peut remarquer cette différence en testant le code suivant qui ne retourne pas la même chose en Mathematica et en SymPy:

>>> Clear[x]                         # Mathematica
>>> from sympy.abc import x          # SymPy
>>> expr = x + 1
>>> x = 100
>>> expr

En Mathematica, la ligne x = 100 change la valeur de la variable x et x n'est plus un symbole (sa couleur change et devient noir). Cela a un effet de bord sur l'expression expr qui retourne la valeur 101. En SymPy, expr contient le symbole x plus 1. La ligne x = 100 change la valeur de la variable x mais n'a pas d'effet sur les expressions qui contiennent le symbole x. Donc, expr retourne bien x + 1.

La complétion automatique par la touche tabulation en Jupyter a son équivalent en Mathematica. Des suggestions de noms de fonctions apparraissent à l'écran en Mathematica pour compléter les premières lettres que l'on écrit.

Pour accéder à la documentation d'une fonction en Mathematica, il suffit d'ajouter un point d'interrogation avant le nom de la fonction et d'évaluer la cellule. En Jupyter, le point d'interrogation peut être placé avant ou après le nom de la fonction pour accéder à sa documentation.

Python et SymPy sont basés sur la programmation orientée objet ce qui explique que l'on peut écrire la fonction après l'objet comme par exemple pi.n() pour calculer les décimales de pi et M.det() pour calculer le déterminant d'une matrice. En Mathematica, cela ne se produit jamais. Les fonctions s'écrivent toujours avant les objets comme N[Pi] et Det[M].

La plupart du temps, la syntaxe est exactement la même en SymPy et en Mathematica, mais il y a quelques exceptions. Par exemple, le calcul d'une limite en SymPy s'écrit:

>>> limit(sin(x)/x, x, 0)

alors, qu'en Mathematica, on utilise la flèche -> pour indiquer qu'une variable tend vers une valeur:

>>> Limit[Sin[x]/x, x->0]

On trouvera une liste des particularités du langage SymPy ici: http://docs.sympy.org/dev/tutorial/gotchas.html. On trouvera le manuel de référence de Mathematica en ligne à l'adresse http://reference.wolfram.com/language/ et des vidéos d'introduction à l'adresse https://www.wolfram.com/broadcast/screencasts/handsonstart/.

Tables de traduction entre SymPy et Mathematica

Les tables ci-bas donnent les équivalents en Mathematica pour chacune des fonctionnalités de SymPy que l'on a vu dans les chapitres 1 à 8. La plupart du temps, la syntaxe est essentiellement la même. On doit simplement ajouter des majuscules et remplacer les parenthèses par des crochets [] ou des accolades {} selon que l'on évalue une fonction ou que l'on définit une liste.

En cas de problème, il ne faut pas hésiter à consulter la documentation de Mathematica en ajoutant un point d'interrogation avant le nom de la fonction, comme ?Factor ou sinon chercher des exemples sur internet.

Le type d'un objet

Construisons le nombre entier 4 de deux façons différentes, avec Python puis avec SymPy:

>>> a = 4
>>> from sympy import S
>>> b = S(4)

Le nombre 4 est stocké dans la variable a et dans la variable b:

>>> a
4
>>> b
4

Bien qu'ils représentent tous deux le nombre 4 et qu'ils s'affichent de la même façon à l'écran, ils ne se comportent pas de la même façon:

>>> a/5
0.8
>>> b/5
4/5

C'est que les objets stockés dans les variables a et b ne sont pas du même type. La fonction type permet de connaître le type d'un objet avec la syntaxe type(objet):

>>> type(a)
<type 'int'>
>>> type(b)
<class 'sympy.core.numbers.Integer'>

Cela explique le comportement différent de a/5 qui retourne un nombre décimal et b/5 qui retourne un nombre rationel de SymPy:

>>> type(a/5)
<type 'float'>
>>> type(b/5)
<class 'sympy.core.numbers.Rational'>

Comme le comportement d'un objet dépend de son type, il est souvent pertinent de vérifier le type d'un objet avant de l'utiliser. Les autres types très communs que nous allons voir dans les sections suivantes sont ci-dessous:

>>> type(4)
<type 'int'>
>>> type(4.0)
<type 'float'>
>>> type(True)
<type 'bool'>
>>> type('bonjour')
<type 'str'>
>>> type([3,4,5])
<type 'list'>
>>> type((3,4,5))
<type 'tuple'>
>>> type({2:3, 4:5})
<type 'dict'>

Nombres entiers (type int)

Les nombres entiers sont créés simplement en Python:

>>> 4
4

Ils sont aussi obtenus par le résultat d'opérations sur les nombres entiers comme l'addition, la multiplication, la soustraction, le modulo et le quotient:

>>> 4 + 6
10
>>> 7 * 9
63
>>> 4 - 6
-2
>>> 27 % 10
7
>>> 27 // 10
2

On peut vérifier que le résultat des opérations ci-haut est bel et bien un entier Python de type int:

>>> type(27 // 10)
<type 'int'>

En Python, la fonction int permet de créer un entier de type int:

>>> int()
0
>>> int(4)
4

Cette fonction permet aussi de traduire un objet d'un autre type en un nombre entier de Python de type int:

>>> int(4.02)
4
>>> int('41234')
41234

Pour stocker des nombres entiers un peu plus grand, Python utilise une autre structure de données appelé entier long. On peut tester à partir d'où cela se produit:

>>> type(2 ** 61)
<type 'int'>
>>> type(2 ** 62)
<type 'int'>
>>> type(2 ** 63)
<type 'long'>
>>> type(2 ** 64)
<type 'long'>

Nombres flottants (type float)

Les nombres décimaux aussi appelé nombre flottants ou nombre à virgule flottante sont créés simplement en Python:

>>> 4.
4.0

Ils sont aussi obtenus par le résultat d'opérations sur les nombres flottants comme l'addition, la multiplication, la soustraction, le modulo et le quotient:

>>> 4. * 3.41
13.64

On vérifie que le type du résultat précédent est bel et bien un nombre flottant de type float:

>>> type(_)
<type 'float'>

Les nombres flottants peuvent aussi être obtenus comme résultats d'opérations impliquant des nombres d'autres types comme la multiplication par un nombre entier ou la division de deux nombres entiers:

>>> 4. * 3
12.0
>>> 4 / 5
0.8

Finalement, les nombres flottants peuvent être créés avec la fonction float qui permet aussi de transformer un objet d'un autre type en nombre flottant:

>>> float()
0.0
>>> float(34)
34.0
>>> float('1234')
1234.0
>>> float('1234.56')
1234.56

Booléens (type bool)

Les booléens permettent de représenter les valeurs vrai et faux. On les écrit en anglais avec un majuscule:

>>> True
True
>>> False
False

Les valeurs True et False sont des objets de type bool:

>>> type(False)
<type 'bool'>
>>> type(True)
<type 'bool'>

Les opérations de base sur les booléens retournent aussi des booléens:

>>> True or False
True
>>> False and True
False

Si cela est nécessaire, voici toutes les possibilités de valeurs d'entrées pour le ET logique and qui retourne vrai lorsque les deux valeurs d'entrées sont vraies:

>>> True and True
True
>>> True and False
False
>>> False and True
False
>>> False and False
False

Pareillement le OU logique (or) retourne True dès qu'une des deux valeurs est vraie:

>>> True or True
True
>>> True or False
True
>>> False or True
True
>>> False or False
False

La négation (not) retourne l'opposé d'une valeur booléenne:

>>> not True
False
>>> not False
True

Un booléen peut être retourné par des fonctions ou des tests de comparaison:

>>> 13 == 5 + 8
True
>>> 20 > 34
False

La fonction bool permet de transformer un objet en un booléen. En général, les valeurs zéro ou les listes vides sont transformées en False et les valeurs non nulles ou les listes non vides sont transformées en True:

>>> bool(113)
True
>>> bool(0)
False
>>> bool(1)
True

Chaînes de caractères (type str)

En Python, les chaînes de caractères sont définies par l'utilisation des simple guillemets (') ou des doubles guillemets ("):

>>> 'bonjour'
'bonjour'
>>> "bonjour"
'bonjour'

Si on veut utiliser les simples guillemets à l'intérieur de la chaînes de caractères, on doit utiliser les doubles pour l'entourer et vice versa:

>>> "aujourd'hui"
"aujourd'hui"
>>> 'Je suis "ici"'
'Je suis "ici"'

Pour utiliser à la fois des simples et des doubles guillemets dans la chaîne de caractères, on utilise des triple double guillemets pour entourer la chaîne de caractères:

>>> """Je suis "ici" aujourd'hui"""
'Je suis "ici" aujourd\'hui'

On peut créer des chaînes de caractères à partir d'autres objets en utilisant la fonction str:

>>> str(12345)
'12345'
>>> str(12345.789)
'12345.789'

Pour accéder aux lettres d'une chaîne de caractères, on utilise les crochets après la variable de la façon suivante:

>>> w = 'bonjour'
>>> w[0]
'b'
>>> w[1]
'o'

Comme vous remarquez, l'indexation commence à zéro et non pas à un. C'est comme ça en Python. Ainsi la septième et dernière lettre du mot bonjour est à la position 6:

>>> w[6]
'r'

On peut aussi compter à partir de la fin avec des indices négatifs. La position -1 retourne la dernière lettre:

>>> w[-1]
'r'

On peut accéder aux sous-chaînes de la position i à la position j-1 avec la syntaxe w[i:j] de la façon suivante:

>>> w[2:5]
'njo'

Si on ne spécifie pas le début ou la fin, alors le comportement par défaut est d'aller jusqu'au bout:

>>> w[:4]
'bonj'

Opérations sur les listes

D'abord, créons une liste:

>>> L = [1, 8, -4, 38, 8, 8, 4, 18]

Pour créer une sous-liste commençant à l'indice 2 jusqu'à l'indice 5-1=4:

>>> L[2:5]
[-4, 38, 8]

On peut créer une nouvelle liste avec l'opération d'addition (+) qui concatène deux listes. Ceci ne change pas les listes utilisées. Par exemple:

>>> L + [1,2,3]
[1, 8, -4, 38, 8, 8, 4, 18, 1, 2, 3]
>>> L
[1, 8, -4, 38, 8, 8, 4, 18]

La fonction len retourne la longueur d'une liste:

>>> len(L)
9

Les fonctions min et max retournent la valeur minimum et maximum d'une liste:

>>> min(L)
-4
>>> max(L)
38

Pour savoir si une valeur est dans une liste, on utilise valeur in liste. Cela retourne un booléen. Par exemple:

>>> 77 in L
False
>>> 38 in L
True