From 2512b8d8c86056f4afd7b178d5ed1671151c45ab Mon Sep 17 00:00:00 2001
From: Clara Moreno <clara.moreno.etu@univ-lille.fr>
Date: Mon, 10 Mar 2025 18:40:01 +0100
Subject: [PATCH] Edit tp_2_miso_dict.py finito pipo
---
tp_2_miso_dict.py | 164 ++++++++++++++++++++++++++++++++++------------
1 file changed, 122 insertions(+), 42 deletions(-)
diff --git a/tp_2_miso_dict.py b/tp_2_miso_dict.py
index 04a2312..ea73569 100644
--- a/tp_2_miso_dict.py
+++ b/tp_2_miso_dict.py
@@ -1,59 +1,139 @@
+
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
--
GitLab