maj

tp_2_miso_mphf.py

@@ -27,7 +27,7 @@ def construction_mphf(set_kmer, n, gamma=2, nb_niveaux=3):
     >>> mphf = construction_mphf(set_kmer, n)
     >>> len(mphf) == n
     True
-    >>> all(0 <= mphf[i] < n for i in range(n))
+    >>> all(0 <= pair[1] < n for pair in mphf)
     True
     >>> len(mphf) == n
     True
@@ -39,64 +39,58 @@ def construction_mphf(set_kmer, n, gamma=2, nb_niveaux=3):
 
     # Parcours des niveaux pour placer les k-mers
     for _ in range(nb_niveaux):
-        if set_kmer_courant:
+        if len(set_kmer_courant) > 0:
             l = len(set_kmer_courant)
-            # On initialise le tableau principal avec -1 (case vide)
             tableau_principal = [-1] * (gamma * l)
             for kmer in set_kmer_courant:
                 # Hacher le k-mer pour obtenir un entier positif
                 h = abs(hash(kmer))
-                # Récupérer l'adresse dans le tableau (taille = gamma * l)
+                # Récupérer l'adresse
                 adresse = h % (gamma * l)
                 # Si la case est déjà occupée, on ajoute le k-mer aux collisions
                 if tableau_principal[adresse] != -1:
                     collision.add(kmer)
                 else:
-                    # Sinon, on écrit le k-mer dans la case
-                    tableau_principal[adresse] = kmer
-            tableaux.append(tableau_principal)  # On sauvegarde le tableau de ce niveau
-            # Les k-mers en collision seront traités au niveau suivant
-            set_kmer_courant = collision.copy()
-            collision = set()
+                    # Sinon, écrire le hash à l'adresse dans le tableau principal
+                    tableau_principal[adresse] = h
+
+            tableaux.append(tableau_principal)  # On ajoute le tableau principal à la liste des tableaux
+            set_kmer_courant = collision.copy()   # Les k-mers en collision seront traités au niveau suivant
+            collision = set() # Réinitialiser l'ensemble des collisions pour le prochain niveau
 
     # Construction de la MPHF
-    # On concatène tous les tableaux pour former le grand_tableau
+
+    mphf = []
     grand_tableau = []
     for tableau in tableaux:
-        grand_tableau.extend(tableau)
+        grand_tableau.extend(
+            tableau)  # On concatène tous les tableaux pour obtenir un grand tableau regroupant tous les indices calculés
 
-    # Création d'un mapping temporaire kmer -> indice (non normalisé)
-    mp_dict = {}
-    # Pour chaque k-mer de l'ensemble initial :
+    rangs = []
+    max_rang = 0
+    i = 0
     for kmer in set_kmer:
-        if kmer in grand_tableau:
-            # On récupère l'indice de la première occurrence du k-mer dans grand_tableau
-            pos = grand_tableau.index(kmer)
-            # Le "rang" est le nombre d'apparitions du k-mer jusqu'à cette position (on commence à 0)
-            rang = grand_tableau[:pos + 1].count(kmer) - 1
-            mp_dict[kmer] = rang
-    # Pour les k-mers qui n'ont pas été placés (collision persistante), on leur affecte des indices uniques
-    max_rang = max(mp_dict.values()) if mp_dict else -1
-    for kmer in set_kmer:
-        if kmer not in mp_dict:
-            max_rang += 1
-            mp_dict[kmer] = max_rang
+        # Hacher le k-mer pour obtenir un entier positif
+        h = abs(hash(kmer))
+        # Si le hash est présent dans le grand_tableau, c'est qu'il a été placé sans collision
+        if h in grand_tableau:
+            # Récupérer l'index de la première occurrence de h dans grand_tableau
+            index = grand_tableau.index(h)
+            # Récupérer le rang en comptant le nombre d'occurrences de h jusqu'à cet index
+            rang = grand_tableau[:index + 1].count(h)
+            # Ajouter à la MPHF la paire [h, rang]
+            mphf.append([h, rang])
+            # Mettre à jour le rang maximum rencontré
+            if rang > max_rang:
+                max_rang = rang
+
+    for kmer in set_kmer_courant:  # gestion des collisions: expliquer les 3 lignes du dessous
+        max_rang += 1
+        h = abs(hash(kmer))
+        mphf.append([h, max_rang])
 
-    # Normalisation de la MPHF :
-    # On souhaite obtenir une bijection de set_kmer sur {0, ..., n-1}.
-    # Pour cela, on trie les k-mers (ordre arbitraire mais fixe) et on leur affecte des indices séquentiels.
-    sorted_kmers = sorted(list(set_kmer))
-    normalized = {}
-    for idx, kmer in enumerate(sorted_kmers):
-        normalized[kmer] = idx
-    # On construit la MPHF sous forme de liste d'entiers correspondant aux indices normalisés,
-    # dans l'ordre du tri (ainsi, la i-ème case correspond au k-mer sorted_kmers[i]).
-    mphf = [normalized[kmer] for kmer in sorted_kmers]
     return mphf
 
-
-
-
 def get_hash_mphf(mphf, kmer):
     """
     Calcule le hash d'un k-mer à l'aide d'une fonction de hachage minimale parfaite (MPHF).
@@ -117,7 +111,14 @@ def get_hash_mphf(mphf, kmer):
     >>> 0 <= hash_mphf < n
     True
     """
-    return int(kmer)
+    # Calculer le hash positif du k-mer
+    h = abs(hash(kmer))
+    # Parcourir la MPHF pour trouver le k-mer correspondant et retourner son indice (rang)
+    for entry in mphf:
+        if entry[0] == h:
+            return entry[1]
+    # Si aucun k-mer correspondant n'est trouvé, lever une exception
+    raise ValueError("K-mer non trouvé dans la MPHF")
 
 
 def create_hash_table(set_kmer, n):
@@ -145,12 +146,12 @@ def create_hash_table(set_kmer, n):
     mphf = construction_mphf(set_kmer, n)
     # Initialiser une table de taille n (liste de n cases)
     table = [None] * n
-    # Ici, nous utilisons l'ordre trié pour affecter l'adresse : le perfect hash d'un k-mer
-    # est sa position dans l'ordre trié.
+    # écrire les kmers aux adresses du tableau données par la mphf
     sorted_kmers = sorted(list(set_kmer))
     for kmer in set_kmer:
         index = sorted_kmers.index(kmer)
         table[index] = kmer
+    # retourner le tableau et la mphf
     return table, mphf