Added comments to the functions

euclide.py

-'''
-	Description : Calcule le PGCD de deux nombres et leurs
-	coefficients de bezout
-	Return : PGCD, Coef de X, Coef de Y 
-	(X est le nombre le plus grand)
-'''
 def pgcd_etendu(a, b):
+	''' Calcule le PGCD de deux nombres et leurs
+	coefficients de bezout
+
+	Args:
+		a (int): Nombre a
+		b (int): Nombre b
+
+	Returns:
+		[int]: PGCD
+		[int]: Coefficient X
+		[int]: Coefficient Y
+	'''	
+
 	a, b = abs(a), abs(b)
 	# On s'assure que le plus grand nombre est a
 	if b > a:
@@ -50,6 +57,6 @@ if __name__ == '__main__':
 	a = 4991
 	b = 1197
 
-	print(pgcd_etendu(a, b))
+	print(pgcd_etendu(b, a))
 	pgcd, x, y = pgcd_etendu(a, b)
-	print(pgcd_etendu_verif(a, b, x, y, pgcd))
\ No newline at end of file
+	# print(pgcd_etendu_verif(a, b, x, y, pgcd))
\ No newline at end of file

inverse_mult.py

@@ -3,10 +3,17 @@
 
 from euclide import *
 
-# Get the multiplicvative inverse of a Mod p
-# x = Multiplicative inverse of a mod p:
-# a * x mod p = 1
+
 def inverse_mult(a, p) :
+	""" Calcule l'inverse multiplicatif de a mod p
+
+	Args:
+		a (int): a
+		p (int): Modulo p
+
+	Returns:
+		[int]: Inverse Modulaire
+	"""	
 	pgcd, x, y =  pgcd_etendu(a, p)
 	if pgcd != 1:
 		return None

main.py

@@ -3,13 +3,7 @@
 from polynome import *
 from reed_solomon import *
 
-def correct_list(len_list: int, p: polynome):
-	corrected = []
 
-	for x in range(len_list):
-		corrected.append(p.evaluate(x))
-
-	return corrected
 
 
 if __name__ == "__main__":
@@ -26,6 +20,7 @@ if __name__ == "__main__":
 
 	l_ok = correct_list(len(l), reed_solomon)
 
+	# Print les messages 
 	print("Message recu   : " + "".join(map(chr, l[:MSG_LEN])))
 	print("Message décodé : " + "".join(map(chr, l_ok[:MSG_LEN])))
 

polynome.py

@@ -42,7 +42,7 @@ class polynome():
 		return polynome(coeff_poly_res)
 	
 	def evaluate(self, x):
-		# Using horner method
+		# Utilise la méthode de Horner
 		res = 0
 		for i in range(len(self.coefs) - 1, -1, -1):
 			res = (res * x + self.coefs[i])

reed_solomon.py

@@ -11,6 +11,15 @@ ERROR_MAX = 9
 
 
 def get_possibilities(l_og: list, index: int):
+	''' Génère une liste qui contient des listes de points
+
+	Args:
+		l_og (list): liste de tous les points
+		index (int): index à partir duquel les points sont forcément juste
+
+	Returns:
+		[list]: Liste de toutes les possibilitées de points
+	'''	
 	l = l_og.copy()
 	# Transforme the list in list of tupples with their indexes
 	for x, _ in enumerate(l):
@@ -28,6 +37,16 @@ def get_possibilities(l_og: list, index: int):
 	return p
 
 def lagrange_compute(l: list) -> polynome:
+	''' Retourne le polynome de Lagrange pour une 
+	liste de points données
+
+	Args:
+		l (list): La liste de points
+
+	Returns:
+		polynome: Le polynome de Lagrange correspondant
+	'''	
+
 	poly_l = [0] * len(l)
 	poly = polynome(poly_l)
 	for x_i, y_i in enumerate(l):
@@ -40,8 +59,18 @@ def lagrange_compute(l: list) -> polynome:
 		poly = poly.add(poly_n)
 	return poly
 
+
 def check_nb_error(l: list, p: polynome) -> int:
-	
+	''' Compte le nombre d'erreure entre le polynome et les points de la liste
+
+	Args:
+		l (list): La liste de points à tester
+		p (polynome): Le polynome avec lequel tester la liste
+
+	Returns:
+		int: [description]
+	'''		
+
 	nbr_error = 0
 	for counter, item in enumerate(l):
 		if (item % p.prime_mod) != (p.evaluate(counter) % p.prime_mod):
@@ -50,9 +79,40 @@ def check_nb_error(l: list, p: polynome) -> int:
 
 
 def reed_decode(l: list) -> polynome:
+	''' Teste toutes les listes de points et retourne le polynome de lagrange 
+	lorsque la liste à moins de 9 erreurs
+
+	Args:
+		l (list): Liste de liste de points
+
+	Returns:
+		polynome: Polynome de Lagrange
+	'''	
+
 	for points in get_possibilities(l, INDEX_MAX):
 		err = check_nb_error(l, lagrange_compute(points))
 		if ((err) <= ERROR_MAX):
 			# ? Chercher un polynome avec moins de 9 erreurs ?
 			# Possibilité d'optimiser en evitant de compute 2 fois le poly
-			return lagrange_compute(points)
\ No newline at end of file
+			return lagrange_compute(points)
+
+
+
+
+def correct_list(len_list: int, p: polynome) -> list:
+	''' Corrige la liste reçue en utilisant le bon polynome de Lagrange
+
+	Args:
+		len_list (int): Liste avec des erreurs
+		p (polynome): Le bon polynome de Lagrange
+
+	Returns:
+		list: La liste corrigée
+	'''	
+	
+	corrected = []
+
+	for x in range(len_list):
+		corrected.append(p.evaluate(x))
+
+	return corrected
\ No newline at end of file