From e5d42cb22de80142e89e65a8d2f03505064c66ea Mon Sep 17 00:00:00 2001
From: unknown <nicolas.albanesi@etu.hesge.ch>
Date: Thu, 16 Dec 2021 13:45:10 +0100
Subject: [PATCH] Added comments to the functions
---
euclide.py | 23 +++++++++++-------
inverse_mult.py | 13 +++++++---
main.py | 7 +-----
polynome.py | 2 +-
reed_solomon.py | 64 +++++++++++++++++++++++++++++++++++++++++++++++--
5 files changed, 89 insertions(+), 20 deletions(-)
diff --git a/euclide.py b/euclide.py
index 9f6ed8c..2b0f25f 100644
--- a/euclide.py
+++ b/euclide.py
@@ -1,10 +1,17 @@
-'''
- 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
diff --git a/inverse_mult.py b/inverse_mult.py
index 8f74c4f..5b3c368 100644
--- a/inverse_mult.py
+++ b/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
diff --git a/main.py b/main.py
index 4f62319..b631808 100644
--- a/main.py
+++ b/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])))
diff --git a/polynome.py b/polynome.py
index af51ff9..8cb282a 100644
--- a/polynome.py
+++ b/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])
diff --git a/reed_solomon.py b/reed_solomon.py
index ea424ed..0625c98 100644
--- a/reed_solomon.py
+++ b/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
--
GitLab