Calcul formel en Python : étendre les opérations sur les nombres entiers à d'autres objets mathématiques,

Un billet blog de Denis Hulo

[SIZE=3]I. Introduction

On souhaite étendre les opérations d'addition et de multiplication effectuées sur les nombres entiers à d'autres objets mathématiques représentant les éléments d'un anneau.

D'après Wikipedia, en algèbre, un anneau est un ensemble muni de deux lois de composition interne appelées addition et multiplication, qui vérifient des propriétés analogues à celles de ces opérations sur les entiers relatifs.

Une loi de composition interne est une application qui, à deux éléments d'un ensemble E, associe un élément de E, comme la multiplication ou l'addition dans l'ensemble des naturels.

On va d'abord montrer brièvement dans ce billet que l'ensemble des nombres complexes et celui des polynômes sont des anneaux.

Dans un second temps, on va représenter les éléments de ces ensembles à l'aide de classes en Python, puis définir les opérations d'addition et de multiplication entre ces objets mathématiques en utilisant la surcharge d'opérateur.

Enfin, on va tester le code Python en effectuant différentes opérations sur ces nouveaux objets un peu comme on le ferait sur des nombres entiers.

II. Exemples d'anneaux

De façon plus détaillée, un anneau est un ensemble E dans lequel sont données deux lois de composition interne, notées + et ×, vérifiant les propriétés suivantes :

1. La loi + est associative : pour tous a, b, c ∈ E, a + (b + c) = (a + b) + c ;
2. La loi + est commutative : pour tous a, b ∈ E, a + b = b + a ;
3. La loi + possède un élément neutre ;
4. La loi × est associative : pour tous a, b, c ∈ E, a × (b × c) = (a × b) × c ;
5. La loi × est distributive par rapport à la loi + : pour tout a, b, c ∈ E, on a a × (b + c) = a × b + a × c et (b + c) × a = b × a + c × a ;
6. La loi × possède un élément neutre ;
7. Tout élément a appartenant à l'ensemble E possède un opposé, noté –a.
   

Note : si on veut être précis, on devrait plutôt parler d'anneau unitaire.

Nous allons donc le vérifier maintenant sur deux exemples.

II-A. Ensemble ℂ des nombres complexes



En mathématiques, l'ensemble des nombres complexes, noté ℂ, est créé comme extension de l'ensemble des nombres réels, contenant en particulier un nombre imaginaire noté i, tel que i² = −1. Le carré de (−i) est aussi égal à −1 : (−i)² = −1.

Tout nombre complexe peut s'écrire sous la forme a + ib où a et b sont des nombres réels.

II-A-1. Addition de nombres complexes

L'addition de 2 nombres complexes z₁ = a + ib et z₂ = c + id écrits sous forme algébrique, est définie de la manière suivante :

(a + ib) + (c + id) = (a+b) + i(b+d)

Le résultat donne également un nombre complexe et cette opération est donc bien une loi de composition interne dans ℂ.

Soient maintenant les trois nombres complexes z₁, z₂ et z₃

1) Associativité

On vérifie facilement en utilisant l'égalité précédente la propriété d'associativité de l'addition de nombres complexes :

z₁ + (z₂ + z₃) = (z₁ + z₂) + z₃

2) et 3) On peut montrer également que l'addition est commutative et que le complexe nul est l'élément neutre pour l'addition dans ℂ.

II-A-2. Multiplication de nombres complexes

La multiplication de 2 nombres complexes z₁ = a + ib et z₂ = c + id, est définie par :

(a + ib) × (c + id) = (ac - bd) + i(ad + bc)

Le résultat de la multiplication de deux nombres complexes donne aussi un nombre complexe et cette opération est donc bien une loi de composition interne dans ℂ.

Soient maintenant les nombres complexes z₁, z₂ et z₃

4) Associativité

On vérifie facilement en utilisant l'égalité précédente la propriété d'associativité de la multiplication :

z₁ × (z₂ × z₃) = (z₁ × z₂) × z₃

5) Distributivité par rapport à l'addition

De même, on vérifie aisément la propriété de distributivité de la multiplication par rapport à l'addition :

z₁ × (z₂ + z₃) = z₁ × z₂ + z₁ × z₃

(z₂ + z₃) × z₁ = z₂ × z₁ + z₃ × z₁

6) et 7) On peut montrer enfin que le nombre 1 est l'élément neutre pour la multiplication dans ℂ et que tout élément de cet ensemble possède un opposé.

En conclusion, les opérations d'addition et de multiplication sont des lois de composition interne dans l'ensemble ℂ qui vérifient des propriétés analogues à celles de ces opérations sur les entiers relatifs.

Par conséquent l'ensemble ℂ constitue un anneau.

II-B. Ensemble ℝ[X] des polynômes



En mathématiques, un polynôme de la variable X peut s'écrire sous la forme :

P(X) = a₀ + a₁X + ... + a_n-1X^n-1 + a_nXⁿ

Où X est une variable appelée indéterminée (dans notre cas un réel), les constantes a₀, a₁, ..., a_n sont les coefficients réels du polynôme et n est un entier naturel.

II-B-1. Addition de polynômes

Soient 2 polynômes de la forme :

P₁(X) = a₀ + a₁X + ... + a_n-1X^n-1 + a_nXⁿ
P₂(X) = b₀ + b₁X + ... + b_m-1X^m-1 + b_nX^m

L'addition de ces 2 polynômes P₁(X) et P₂(X) donne pour n=m :

P₁(X) + P₂(X) = (a₀ + b₀) + (a₁ + b₁)X + ... + (a_n-1 + b_n-1)X^n-1 + (a_n + b_n)Xⁿ

Et pour n>m :

P₁(X) + P₂(X) = (a₀ + b₀) + (a₁ + b₁)X + ... + (a_m-1 + b_m-1)X^m-1 + (a_m + b_m)X^m + ... + a_nXⁿ

On additionne donc simplement les coefficients de même degré et on obtient donc un troisième polynôme.

Par conséquent, cette opération est bien une loi de composition interne dans ℝ[X].

Soient maintenant les trois polynômes P₁, P₂ et P₃

1) Associativité

On vérifie facilement en utilisant le résultat précédent la propriété d'associativité de l'addition de polynômes :

P₁ + (P₂ + P₃) = (P₁ + P₂) + P₃

2) et 3) On peut montrer également que l'addition est commutative et que le polynôme nul est l'élément neutre pour l'addition dans ℝ[X].

II-B-2. Multiplication de polynômes

Soient 2 polynômes de degré 1 :

P₁(X) = a₀ + a₁X
P₂(X) = b₀ + b₁X

La multiplication étant distributive par rapport à l'addition, le produit de ces 2 polynômes P₁(X) et P₂(X) nous donne :

P₁(X) X P₂(X) = (a₀ + a₁X)(b₀ + b₁X)
P₁(X) X P₂(X) = a₀b₀ + a₀b₁X + a₁b₀X + a₁b₁X²

On obtient donc à nouveau un troisième polynôme, et on peut ainsi généraliser facilement ce résultat à des polynômes de degrés quelconques.

Par conséquent, cette opération est bien une loi de composition interne dans ℝ[X].

Soient maintenant les polynômes P₁, P₂ et P₃

4) Associativité

On vérifie facilement en utilisant le résultat précédent la propriété d'associativité de la multiplication :

P₁ × (P₂ × P₃) = (P₁ × P₂) × P₃

5) Distributivité par rapport à l'addition

De même, on vérifie aisément la propriété de distributivité de la multiplication de polynômes par rapport à l'addition :

P₁ × (P₂ + P₃) = P₁ × P₂ + P₁ × P₃

(P₂ + P₃) × P₁ = P₂ × P₁ + P₃ × P₁

6) et 7) On peut montrer enfin que le polynôme constant 1 est l'élément neutre pour la multiplication dans ℝ[X] et que tout élément de cet ensemble possède un opposé.

En conclusion, les opérations d'addition et de multiplication sont des lois de composition interne dans l'ensemble ℝ[X] qui vérifient des propriétés analogues à celles de ces opérations sur les entiers relatifs.

Par conséquent l'ensemble ℝ[X] constitue un anneau.

III. Implémentation en Python

Les opérations d'addition et de multiplication sur ces objets mathématiques ont donc des propriétés communes avec celles sur les nombres entiers, toutefois elles ont aussi leurs particularités et ne sont pas définies de la même manière (on parle dans ce cas de polymorphisme).

On va maintenant représenter les nombres complexes et les polynômes à l'aide de classes en Python, puis définir les opérations d'addition et de multiplication entre ces objets mathématiques en utilisant la surcharge d'opérateur.

III-A. Création de la classe Complexe

Pour définir ces nombres complexes en Python et pouvoir réaliser des opérations entre eux, il nous faut créer une classe Complexe :



Notre classe comportera en plus une méthode particulière __init__() dont le code est exécuté quand la classe est instanciée.

Elle va nous permettre de définir les parties réelle et imaginaire du nombre complexe au moment de créer l'objet :


La méthode __str__ permet d'afficher un nombre complexe sous la forme a + bi.

Pour tester ces méthodes, nous ajoutons simplement deux lignes au module :


Le code affiche :

1 + 2i

III-A-1. Surcharge de l'opérateur d'addition

Pour surcharger l'opérateur « + » et pouvoir ainsi réaliser l'addition de 2 nombres complexes, nous devons ajouter une méthode __add __ () à la classe :


Cette méthode permet donc de redéfinir l'opération « + » pour les nombres complexes en utilisant l'égalité :

(a + bi) + (c + di) = (a+c) + (b+d)i

Pour tester l'opérateur d'addition portant sur 2 objets de la classe Complexe, nous ajoutons ces lignes de code :


Le code affiche :

1 + 2i ∈ ℂ
2 + 3i ∈ ℂ

(1 + 2i) + (2 + 3i) = 3 + 5i

3 + 5i ∈ ℂ


La fonction anneau(element) renvoie l'ensemble (ℂ, ℝ[X], etc.) auquel appartient l'élément, elle est présente dans le module donné à la fin du billet.

On peut également vérifier la propriété d'associativité de l'addition :


Le code affiche :

z1 = 1 + 2i
z2 = 2 + 3i
z3 = 2 + 2i

z1 + (z2 + z3) = (z1 + z2) + z3


III-A-2. Surcharge de l'opérateur de multiplication

Pour surcharger l'opérateur « * » et l'appliquer à 2 nombres complexes, nous devons également ajouter une méthode __mul __ () à la classe :


Cette méthode offre donc la possibilité de redéfinir l'opération de multiplication pour 2 nombres complexes en utilisant l'égalité :

(a + bi) x (c + di) = (ac - bd) + (ad + bc)i

Pour tester l'opérateur de multiplication portant sur 2 objets de la classe Complexe, nous ajoutons ces lignes :


Le code affiche :

1 + 2i ∈ ℂ
2 + 3i ∈ ℂ

(1 + 2i)(2 + 3i) = -4 + 7i

-4 + 7i ∈ ℂ


On peut également vérifier la propriété d'associativité de la multiplication :


Le code affiche :

z1 = 1 + 2i
z2 = 2 + 3i
z3 = 2 + 2i

z1 * (z2 * z3) = (z1 * z2) * z3


III-B. Création de la classe Polynome

Pour définir ces polynômes en Python et pouvoir réaliser des opérations entre eux, il nous faut créer une classe Polynome :



Sa méthode constructeur __init__() va nous permettre de définir la liste des coefficients du polynôme au moment de créer l'objet :


La méthode __str__ permet d'afficher un polynôme sous la forme 1 + 2.x + x^2.

Pour tester ces méthodes, nous ajoutons deux lignes au module :


Le code affiche :

1 + 2⋅X + X^2

Note importante : la liste de coefficients permettant de créer l'objet Polynome contient également les coefficients nuls.

Par exemple, le polynôme P(x) = x^2 + 2⋅X^4 sera représenté par la liste [0, 0, 1, 0, 2] .

III-B-1. Surcharge de l'opérateur d'addition

Pour surcharger l'opérateur « + » et pouvoir ainsi réaliser l'addition de 2 polynômes, nous devons ajouter une méthode __add __ () à la classe :


Cette méthode permet donc de redéfinir l'opération « + » pour les polynômes en additionnant les coefficients de même degré.

Pour tester l'opérateur d'addition portant sur 2 objets de la classe Polynome, nous ajoutons ces lignes de code :


Le code affiche :

1 + 2⋅X + X^2 ∈ ℝ[X]
1 + X ∈ ℝ[X]

(1 + 2⋅X + X^2) + (1 + X) = 2 + 3⋅X + X^2

2 + 3⋅X + X^2 ∈ ℝ[X]


III-B-2. Surcharge de l'opérateur de multiplication

Pour surcharger l'opérateur « * » et l'appliquer à 2 polynômes, nous devons également ajouter une méthode __mul __ () à la classe :


Cette méthode permet donc de redéfinir l'opération de multiplication pour 2 polynômes en utilisant la propriété de distributivité de la multiplication par rapport à l'addition.

Pour tester l'opérateur de multiplication portant sur 2 objets de la classe Polynome, nous ajoutons simplement ces lignes :


Le code affiche :

1 + X ∈ ℝ[X]
1 + 2⋅X ∈ ℝ[X]

(1 + X)(1 + 2⋅X) = 1 + 3⋅X + 2⋅X^2

1 + 3⋅X + 2⋅X^2 ∈ ℝ[X]


On peut bien sûr imaginer d'étendre à ces objets mathématiques d'autres opérations effectuées sur les nombres entiers (soustraction, puissance, etc.).

IV. Module complet

On donne pour finir le code complet du module contenant les deux classes :

[Code=Python]class Complexe:

def __init__(self, part_reel=0, part_imag=0):
# méthode constructeur de la classe

# on définit la partie réelle du nombre complexe
self.reel = part_reel

# on définit la partie imaginaire du nombre complexe
self.imag = part_imag

def __str__(self):
# permet d'afficher le nombre complexe sous la forme algébrique a + bi

return "{0} + {1}i".format(self.reel, self.imag) if self.imag>=0 else "{0} - {1}i".format(self.reel, abs(self.imag))

def __add__(self, other):
# méthode permettant de redéfinir l'opérateur « + » pour 2 nombres complexes : z1 + z2 = (a + bi) + (c + di) = (a+c) + (b+d)i

# on évalue la partie réelle du nombre complexe résultat de l'addition
part_reel = self.reel + other.reel

# on évalue la partie imaginaire du nombre complexe résultat de l'addition
part_imag = self.imag + other.imag

# renvoie le nombre complexe résultat de l'addition
return Complexe(part_reel, part_imag)

def __mul__(self, other):
# méthode permettant de redéfinir l'opérateur « * » pour 2 nombres complexes : z1 * z2 = (ac - bd) + (ad + bc)*i

# part_reel = (ac - bd)
part_reel = self.reel * other.reel - self.imag * other.imag

# part_imag = (ad + bc)
part_imag = self.reel * other.imag + self.imag * other.reel

# renvoie le nombre complexe résultat de la multiplication
return Complexe(part_reel, part_imag)

def __pow__(self, n):
# méthode permettant de redéfinir l'opérateur de puissance : self ** n

# on initialise la variable objet z avec la valeur 1 élément neutre pour la multiplication de nombres complexes
z = Complexe(1,0)

# nous multiplions n fois z par self à l'aide de l'opérateur *
for i in range(n):
z = z*self # équivalent à : z = z.__mul__(self)

# renvoie le nombre complexe résultat de l'opération (self ** n)
return z

def __eq__(self, other):
# méthode permettant de redéfinir l'opérateur « == » pour 2 nombres complexes

# renvoie True si les parties réelles et imaginaires des 2 nombres complexes sont égales
return (self.reel==other.reel) and (self.imag==other.imag)

class Polynome:

def __init__(self, liste_coefs=[0]):
# méthode constructeur de la classe

# on définit la liste des coefficients du polynôme [a0, a1, ..., an]
self.coefs = liste_coefs

# suppression si nécessaire des zéros en queue de liste de coefficients. Exemple : [2, 3, 1, 0, 0] -> [2, 3, 1]
self.reduire()

def __str__(self): # permet d'afficher le polynôme sous la forme 1 + 2x + 3x^2
s="" # initialisation de la chaîne de caractères
# on vérifie d’abord si le degré du polynôme est nul
if (len(self.coefs)-1==0):
return str(self.coefs[0])
else: # sinon
if self.coefs[0]!=0:
s=str(self.coefs[0]) + " + "
for i in range(1, len(self.coefs)): # parcours des indices des coefficients du polynôme : [a1, a2, ..., an]
if self.coefs[i]!=0: # si le coefficient de degré i n'est pas nul
if self.coefs[i]!=1: # si le coefficient de degré i est différent de 1
s+="{}⋅X^{} + ".format(self.coefs[i],i)
else: s+="X^{} + ".format(i)

# élimination des caractères en trop
s = s[:-3].replace("+ -", "- ").replace("X^1 ","X ").replace(" 1⋅X"," X")
if s[-2:]=="^1": s = s[:-2]
if s[:3]=="1⋅X": s = s[3:]

return s # on retourne l'expression du polynôme

def eval_degre(): # retourne le degré du polynôme
return (len(self.coefs)-1)

def __add__(self, other):
# méthode permettant de redéfinir l'opérateur « + » pour 2 polynômes : (1 + 2x + x^2) + (1 + x) = 2 + 3x + x^2

# p1 = self, p2 = other
if len(other.coefs) >len(self.coefs): # si degré de p2 > degré de p1
# on copie les coefs du polynôme de degré le plus élevé et la longueur de la liste de coefs la plus petite.
liste_coefs = other.coefs[:]; n = len(self.coefs)
else: liste_coefs = self.coefs[:]; n = len(other.coefs) # sinon, ...

for i in range(n): # parcours des indices de liste_coefs
liste_coefs[i] = self.coefs[i] + other.coefs[i] # addition des coefficients de degré i

# renvoie le polynôme résultat de l'addition
return Polynome(liste_coefs)

def reduire(self):
# tant que le dernier élément de la liste est nul
while self.coefs[-1] == 0 and len(self.coefs)>1:
self.coefs.pop() # supprimer le dernier élément

def __mul__(self, other):
# méthode permettant de redéfinir l'opérateur « * » pour 2 polynômes : (1 + x) * (1 + 2x) = 1 + 3x + 2x^2

# initialisation de la liste des coefficients qu'avec des zéros
liste_coefs=[0]*(len(self.coefs)+len(other.coefs)-1) # exemple : [0, 0, 0]
for i1 in range(len(self.coefs)): # parcours des indices des coefs du polynôme n°1
for i2 in range[/0, 0, 0]...