Edit tp_2_miso_dict.py finito pipo

tp_2_miso_dict.py

+
 import matplotlib.pyplot as plt
 import numpy as np
 import time
 import sys
 
 
-
 ###### PARTIE 2 ######
 
+
 def experiment_load_factor(load_factors):
-	"""
-	Étude du facteur de charge
-	"""
-	return [],[],[]
+    """
+    Measures insertion time, memory reallocations, and final dictionary size
+    for different load factors.
+
+    Args:
+        load_factors (list): List of load factors to test.
+
+    Returns:
+        tuple: Three lists containing insertion times, number of memory reallocations, and final sizes.
+    """
+    insertion_times = []
+    num_resizes = []
+    sizes = []
+
+    for load_factor in load_factors:
+        my_dict = {}
+        num_elements = int(load_factor * 10_000)  #element qu'on insere (on a pris nombre au hasard)
+        start_time = time.time()
+        num_resize = 0
+        last_size = sys.getsizeof(my_dict)  # Taille memoire initiale
+
+        for i in range(num_elements):
+            my_dict[i] = i  # Insertion d'une clé-valeur
+            current_size = sys.getsizeof(my_dict)  # Taille actuelle du dictionnaire
+
+            if current_size > last_size:  # Détection d'une réallocation mémoire
+                num_resize += 1
+                last_size = current_size
+
+        insertion_time = time.time() - start_time  # Temps d'insertion total
+        insertion_times.append(insertion_time)
+        num_resizes.append(num_resize)
+        sizes.append(last_size)
+
+    return insertion_times, num_resizes, sizes
+
+
 
 def experiment_longest():
-	"""
-	TODO: que fait cette fonction
-	"""
-	d = {}
-	insertion_times = []
-
-	for i in range(10000):
-		key = str(i)
-		value = i
-		start_time = time.time()
-		d[key] = value
-		insertion_time = time.time() - start_time
-		insertion_times.append(insertion_time)
-	frequencies = np.histogram(insertion_times)[0]
-	return frequencies
+    """
+    elle calcul le temps que prend une insertion de valeurs dans le dictionnaire en soustrayant la créeation de clefs
+    renvoie un tableau contenant le nombre d'observations (fréquences) dans chaque intervalle de temps.
+    """
+    d = {}
+    insertion_times = []
+    count = 0
+    for i in range(10000):
+        count += 1
+        key = str(i)
+        value = i
+        start_time = time.time()
+        d[key] = value
+        insertion_time = time.time() - start_time #temps insertion d'une valeur dans un dict
+        insertion_times.append(insertion_time)
+    frequencies = np.histogram(insertion_times)[0]
+    return frequencies
+
 
 def visualisation(load_factors, insertion_times, num_resizes, sizes, frequencies):
-	"""
-	Visualisation des résultats
-	"""
-	# Temps d'insertion en fonction du facteur de charge
-
-	# Nombre de réallocations de mémoire en fonction du facteur de charge
-	
-	# Taille de mémoire occupée en fonction du nombre d'éléments
-	
-	# Deuxième étude
-	f = list()
-	plt.figure(figsize=(10, 6))
-	plt.bar(range(len(f)), f)
-	plt.xlabel('Temps d\'insertion (s)')
-	plt.ylabel('Fréquence')
-	plt.title('Histogramme des fréquences des temps d\'insertions')
-	plt.yscale('log')
-	xticks = np.logspace(-6, 1, 3)  
-	xtick_labels = [f'{x:.1e}' for x in xticks]  
-	plt.xticks(xticks, xtick_labels)    
-	plt.savefig('histogramme.png')
+    """
+    Visualisation des résultats
+    """
+    # Temps d'insertion en fonction du facteur de charge
+
+    # Nombre de réallocations de mémoire en fonction du facteur de charge
+
+    # Taille de mémoire occupée en fonction du nombre d'éléments
+
+    # Deuxième étude
+    f = list()
+    plt.figure(figsize=(10, 6))
+    plt.bar(range(len(f)), f)
+    plt.plot(load_factors, insertion_times,  label="insertion times")
+    plt.xlabel('facteur de charge')
+    plt.ylabel("temps d'insertion")
+    plt.title('Evolution des temps d insertion (s) en fonction des facteurs de charge')
+    plt.savefig("temps_insertion.png")
+    plt.close()
+
+    f = list()
+    plt.figure(figsize=(10, 6))
+    plt.bar(range(len(f)), f)
+    plt.plot(load_factors, num_resizes, label="num_resizes")
+    plt.xlabel('facteur de charge')
+    plt.ylabel('nombre de réallocations')
+    plt.title('Evolution du nombre de réallocations en fonction des facteurs de charge')
+    plt.savefig("réallocations.png")
+    plt.close()
+
+    f = list()
+    plt.figure(figsize=(10, 6))
+    plt.bar(range(len(f)), f)
+    plt.plot(load_factors, sizes, label="sizes")
+    plt.xlabel('facteurs de charge')
+    plt.ylabel('taille de la table')
+    plt.title('Evolution de la taille de la table en fonction des facteurs de charge')
+    plt.savefig("taille de table.png")
+    plt.close()
+
+    f = list()
+    plt.figure(figsize=(10, 6))
+    plt.bar(range(len(f)), f)
+    plt.hist(frequencies, label="Fréquences")
+    plt.xlabel('facteurs de charge')
+    plt.ylabel('fréquences')
+    plt.title('Histogramme des fréquences d\'insertion dans le dictionnaire')
+    plt.yscale('log')
+    plt.savefig("fréquences.png")
+    plt.close()
+
+
+
+    xticks = np.logspace(-6, 1, 3)
+    xtick_labels = [f'{x:.1e}' for x in xticks]
+    plt.xticks(xticks, xtick_labels)
+    plt.savefig('histogramme.png')
 
 load_factors = [0.01, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]
 insertion_times, num_resizes, sizes = experiment_load_factor(load_factors)
 frequencies = experiment_longest()
-visualisation(load_factors, insertion_times, num_resizes, sizes, frequencies)
\ No newline at end of file
+visualisation(load_factors, insertion_times, num_resizes, sizes, frequencies)
+
+# Commentaires des résultats
+# Le temps d'insertion est linéaire au cours du temps, donc ne dépend pas des facteurs de charge
+# Le nombre de réallocations est croissant par palliers, c'est cohérent étant donné le comportement d'une liste
+# La taille de la table augmente graduellement par palliers, plus on a de facteurs de charge, plus les collisions sont fréquentes. Le plateau correspond au maximum de collisions théoriquement possibles.
+# Il semble qu'il y ait une corrélation entre la taille de la table et les réallocations : quand la taille de la table est importante on diminue le risque de collisions.
+# 99% du temps est utilisé pour insérer la première valeur, à la création de la table. C'est donc la création du dictionnaire qui prend le plus de temps
\ No newline at end of file