ASD/test.py
2018-01-23 17:57:53 +01:00

436 lines
13 KiB
Python

"""Test des fonctions du TL.
Pour tester la question x_y : `python3 test.py x_y`.
Donc pour la question 3_4 : `python3 test.py 3_4`.
"""
import sys
import random
import graphe
import graphique
import copy
import numpy as np
import matplotlib.pyplot as pl
import time
def creerGrapheFigure1():
""" Crée le graphe de la figure 1 """
g = graphe.Graphe("Graphe de la figure 1")
s1 = g.ajouteSommet(1.0, 1.0)
s2 = g.ajouteSommet(2.0, 3.5)
s3 = g.ajouteSommet(2.5, 2.5)
s4 = g.ajouteSommet(5.0, 2.0)
s1.couleur = (1., 1., 0.)
s2.couleur = (0., 0., 1.)
s3.couleur = (1., 0., 0.)
s4.couleur = (1., 1., 0.)
a = g.connecte(s1, s2, 4.0, 90.)
a.couleur = (1., 1., 0.)
g.connecte(s1, s4, 5.2, 124.)
g.connecte(s2, s3, 2.0, 54.)
g.connecte(s2, s4, 5.0, 90.)
return g
def testQuestion1_2():
"""' Teste que la création d ' un graphe ne plante pas
print ”Question 1.2 :"""
creerGrapheFigure1()
print("Ok. Pas de plantage")
def testQuestion1_3():
""" Teste l ' affichage d ' un graphe dans la console"""
print("Question 1.3 :")
g = creerGrapheFigure1()
print(g)
def testQuestion1_4():
""" Teste du dessin d'un graphe."""
print("Question 1.4:")
graphique.affiche(creerGrapheFigure1(), (3., 2.), 100.)
def testQuestion2_2():
"""Teste de génération aléatoire de graphe."""
print("Question 2.2:")
graphique.affiche(graphe.pointsAleatoires(5, 30), (0, 0), 10.)
def testQuestion2_4():
"""Teste de gabriel et gvr."""
print("Question 2.4")
g = graphe.pointsAleatoires(30, 30)
g.renomme("Gabriel")
g1 = copy.deepcopy(g)
g1.renomme("GVR")
graphe.gabriel(g)
graphe.gvr(g1)
graphique.affiche(g, (0, 0), 10., blocage=False)
graphique.affiche(g1, (0, 0), 10.)
def testQuestion2_5():
"""Teste de la création de réseau."""
g = graphe.pointsAleatoires(30, 30)
graphe.reseau(g)
graphique.affiche(g, (0, 0), 10.)
def chronometre(fonctionTest, fonctionPreparation, parametres):
''' Mesure le temps d ' exécution fonctionTest pour différentes valeurs d '
un paramètres '''
temps = []
# Pour chaque valeur de paramètre
for p in parametres:
# Génère les entrées du test pour la valeur p
entrees = fonctionPreparation(p)
# Lance le test pour ces entrées
print("t({}) = ".format(p), end="", flush=True)
debut = time.time()
fonctionTest(entrees)
fin = time.time()
# Mesure le temps d ' exécution
t = (fin - debut)
print("{:.2f} s".format(t))
temps.append(t)
return temps
def testQuestion2_6():
"""Mesure la performance de graphe.reseau"""
prepare = lambda p : graphe.pointsAleatoires(p, 10)
valeurs_n = list(map(int, np.logspace(1, 2.7, 100)))
temps = chronometre(graphe.reseau, prepare, valeurs_n)
pl.close('all')
pl.title("Mesure du temps d'exécution de `reseau`.")
pl.plot(valeurs_n, temps)
pl.xlabel("n")
pl.ylabel("temps")
pl.show()
pl.title("Mesure du temps d'exécution de `reseau`.")
pl.loglog(valeurs_n, temps, label='temps de calcul')
pl.loglog(valeurs_n, (lambda x : x**3)(valeurs_n), label='$x\mapsto x^3$')
pl.legend(loc='best')
pl.xlabel("n")
pl.ylabel("temps")
pl.show()
def testQuestion2_7():
"""Compare la création de graphe de gabriel et ed delaunay."""
prepare = lambda p : graphe.pointsAleatoires(p, 10)
valeurs_n = np.arange(1, 200)
temps1 = chronometre(graphe.gabriel, prepare, valeurs_n)
temps2 = chronometre(graphe.delaunay, prepare, valeurs_n)
pl.close('all')
pl.title("Comparaison du temps pour `delaunay` et `gabriel`")
pl.plot(valeurs_n, temps1, label='gabriel')
pl.plot(valeurs_n, temps2, label='delaunay')
pl.legend(loc='best')
pl.xlabel('n')
pl.ylabel('temps')
pl.show()
def testQuestion2_8():
"""Compare le reseau naif et non naif."""
g = graphe.pointsAleatoires(30, 30)
g1 = copy.deepcopy(g)
g.renomme("Naïf")
g1.renomme("Non naïf")
graphe.reseau(g)
graphe.reseauRapide(g1)
graphique.affiche(g, (0, 0), 10.)
graphique.affiche(g1, (0, 0), 10.)
def testQuestion2_9():
"""Compare le temps de création des deux méthodes de création de réseau"""
prepare = lambda p : graphe.pointsAleatoires(p, 10)
valeurs_n = list(map(lambda x: int(x), np.logspace(1, 3, 30)))
temps1 = chronometre(graphe.reseau, prepare, valeurs_n)
temps2 = chronometre(graphe.reseauRapide, prepare, valeurs_n)
pl.close('all')
pl.title("Comparaison du temps d'exécution de `reseau` et `reseauRapide`.")
pl.plot(valeurs_n, temps1, label='reseau')
pl.plot(valeurs_n, temps2, label='reseauRapide')
pl.legend(loc='best')
pl.xlabel("n")
pl.ylabel("temps")
pl.show()
pl.title("Comparaison du temps d'exécution de `reseau` et `reseauRapide`.")
pl.loglog(valeurs_n, temps1, label='reseau')
pl.loglog(valeurs_n, temps2, label='reseauRapide')
pl.legend(loc='best')
pl.xlabel("n")
pl.ylabel("temps")
pl.show()
def testQuestion3_1():
"""Trace le plus court chemin avec dijkstra."""
g = graphe.pointsAleatoires(30, 30)
g.renomme("Dijkstra")
graphe.reseauRapide(g)
g.dijkstra(g.sommets[0])
g.traceArbreDesChemins()
graphique.affiche(g, (0, 0), 10.)
def testQuestion3_2():
"""Trace le plus court chemin avec dijkstra."""
g = graphe.pointsAleatoires(30, 30)
g.renomme("Dijkstra")
graphe.reseauRapide(g)
g.fixeTempsCommeCout()
g.dijkstra(g.sommets[0])
g.traceArbreDesChemins()
g.renomme("Temps")
graphique.affiche(g, (0, 0), 10., blocage=False)
g.fixeCarburantCommeCout()
g.dijkstra(g.sommets[0])
g.traceArbreDesChemins()
g.renomme("Carburant")
graphique.affiche(g, (0, 0), 10.)
def testQuestion3_3():
"""Mesure le temps d'exécution de Dijkstra."""
prepare = lambda p : graphe.reseauRapide(graphe.pointsAleatoires(p, 100))
valeurs_n = list(map(lambda x: int(x), np.logspace(1, 4, 10)))
temps = chronometre(graphe.Graphe.dijkstra, prepare, valeurs_n)
pl.close('all')
pl.title("Temps d'exécution en fonction de la taille du graphe.")
pl.plot(valeurs_n, temps, label='reseau')
pl.legend(loc='best')
pl.xlabel("n")
pl.ylabel("temps")
pl.show()
pl.title("Temps d'exécution en fonction de la taille du graphe.")
pl.loglog(valeurs_n, temps, label='reseau')
pl.legend(loc='best')
pl.xlabel("n")
pl.ylabel("temps")
pl.show()
def testQuestion3_4():
"""Trace le plus court chemin avec dijkstra."""
g = graphe.pointsAleatoires(30, 30)
g.renomme("Plus court chemin")
graphe.reseauRapide(g)
g.fixeTempsCommeCout()
g.dijkstra(g.sommets[0])
c = g.cheminOptimal(g.sommets[-1])
g.colorieChemin(c, (0.,1.,0.))
g.renomme("Temps")
graphique.affiche(g, (0, 0), 10.)
def testQuestion3_5():
"""Trace le plus court chemin avec dijkstra."""
g = graphe.pointsAleatoires(30, 30)
g.fixeTempsCommeCout()
graphe.reseauRapide(g)
g.dijkstra(g.sommets[0])
g.traceArbreDesChemins()
g.renomme("Liste")
graphique.affiche(g, (0, 0), 10., blocage=False)
g.dijkstraAvecTas(g.sommets[0])
g.traceArbreDesChemins()
g.renomme("Tas")
graphique.affiche(g, (0, 0), 10.)
def testQuestion3_6():
"""Compare Dijkstra avec et sans tas."""
prepare = lambda p : graphe.reseauRapide(graphe.pointsAleatoires(p, 10))
valeurs_n = list(map(lambda x: int(x), np.logspace(1, 3, 10)))
temps1 = chronometre(graphe.Graphe.dijkstra, prepare, valeurs_n)
temps2 = chronometre(graphe.Graphe.dijkstraAvecTas, prepare, valeurs_n)
pl.close('all')
pl.title("Comparaison du temps d'exécution de `dijkstra` et `dijkstraAvecTas`.")
pl.plot(valeurs_n, temps1, label='Dijkstra')
pl.plot(valeurs_n, temps2, label='Dijkstra avec tas')
pl.legend(loc='best')
pl.xlabel("n")
pl.ylabel("temps")
pl.show()
pl.title("Comparaison du temps d'exécution de `reseau` et `reseauRapide`.")
pl.loglog(valeurs_n, temps1, label='Dijkstra')
pl.loglog(valeurs_n, temps2, label='Dijkstra avec tas')
pl.legend(loc='best')
pl.xlabel("n")
pl.ylabel("temps")
pl.show()
def testQuestion3_7():
"""Trace le plus court chemin avec dijkstra."""
g = graphe.pointsAleatoires(30, 30)
g.fixeTempsCommeCout()
graphe.reseauRapide(g)
g.dijkstraPartiel(g.sommets[0], g.sommets[-1])
g.traceArbreDesChemins()
g.renomme("Dijkstra partiel")
graphique.affiche(g, (0, 0), 10.)
def testQuestion3_8():
"""Trace le plus court chemin avec dijkstra."""
g = graphe.pointsAleatoires(30, 30)
g.fixeCarburantCommeCout()
graphe.reseauRapide(g)
g.astar(g.sommets[0], g.sommets[-1])
g.traceArbreDesChemins()
g.renomme("A*")
graphique.affiche(g, (0, 0), 10., blocage=False)
g.dijkstraPartiel(g.sommets[0], g.sommets[-1])
g.traceArbreDesChemins()
g.renomme("Dijkstra partiel")
graphique.affiche(g, (0, 0), 10.)
def testQuestion3_9():
"""Compare Dijkstra avec et sans tas et A*."""
prepare = lambda p : graphe.reseauRapide(graphe.pointsAleatoires(p, 10))
valeurs_n = list(map(lambda x: int(x), np.logspace(1, 3, 50)))
temps1 = chronometre(graphe.Graphe.dijkstra, prepare, valeurs_n)
temps2 = chronometre(graphe.Graphe.dijkstraPartiel, prepare, valeurs_n)
temps3 = chronometre(graphe.Graphe.astar, prepare, valeurs_n)
pl.close('all')
pl.title("Comparaison du temps d'exécution de `dijkstra`, `dijkstraPartiel` et `astar`.")
pl.plot(valeurs_n, temps1, label='Dijkstra')
pl.plot(valeurs_n, temps2, label='Dijkstra partiel avec tas')
pl.plot(valeurs_n, temps3, label='A*')
pl.legend(loc='best')
pl.xlabel("n")
pl.ylabel("temps")
pl.show()
pl.title("Comparaison du temps d'exécution de `dijkstra`, `dijkstraPartiel` et `astar`.")
pl.loglog(valeurs_n, temps1, label='Dijkstra')
pl.loglog(valeurs_n, temps2, label='Dijkstra partiel avec tas')
pl.loglog(valeurs_n, temps3, label='A*')
pl.legend(loc='best')
pl.xlabel("n")
pl.ylabel("temps")
pl.show()
def testQuestion4_1():
"""Trace le plus court chemin avec dijkstra."""
g = graphe.pointsAleatoires(30, 30)
graphe.reseauRapide(g)
g.renomme("graphe")
print("Points 0,1 et 2")
tournee = [g.sommets[i] for i in (0, 1, 2)]
print(g.matriceCout(tournee))
graphique.affiche(g, (0, 0), 10.)
def testQuestion4_2():
g = graphe.pointsAleatoires(30, 30)
graphe.reseauRapide(g)
g.renomme("graphe")
print("Points 0,1,2 et 7")
tournee = [g.sommets[i] for i in (0, 1, 2, 7)]
cout,iti = g.voyageurDeCommerceNaif(tournee)
g.traceItineraire(iti)
graphique.affiche(g, (0, 0), 10.)
def testQuestion4_3():
"""Mesure le temps de calcul."""
g = graphe.reseauRapide(graphe.pointsAleatoires(1000, 1000))
prepare = lambda p : random.sample(g.sommets, p)
valeurs_n = list(map(int, np.linspace(1, 15, 10)))
temps = chronometre(g.voyageurDeCommerceNaif, prepare, valeurs_n)
pl.close('all')
pl.title("Temps d'exécution pour le voyageur de commerce.")
pl.plot(valeurs_n, temps)
pl.xlabel("n (nombre de points de la tournée)")
pl.ylabel("temps")
pl.show()
pl.title("Temps d'exécution pour le voyageur de commerce.")
pl.loglog(valeurs_n, temps)
pl.xlabel("n (nombre de points de la tournée)")
pl.ylabel("temps")
pl.show()
def testQuestion4_6():
g = graphe.pointsAleatoires(30, 30)
graphe.reseauRapide(g)
g.fixeTempsCommeCout()
g.renomme("Algorithme de Prim (cout=temps)")
p = g.Prim()
print("Poids de prim:", p)
g.colorieSelection()
graphique.affiche(g, (0, 0), 10.)
def testQuestion4_7():
g = graphe.pointsAleatoires(30, 30)
graphe.reseauRapide(g)
g.fixeTempsCommeCout()
g.renomme("Graphe de test (cout=temps)")
tournee = [g.sommets[i] for i in (0, 1, 2, 7)]
g1 = g.grapheDeCout(tournee)
graphique.affiche(g, (0, 0), 10., blocage=False)
graphique.affiche(g1, (0, 0), 10.)
def testQuestion4_8():
g = graphe.pointsAleatoires(30, 30)
graphe.reseauRapide(g)
g.fixeTempsCommeCout()
g.renomme("Graphe de test (cout=temps)")
g1 = copy.deepcopy(g)
print("Tournée 0, 1, 2, 7")
tournee = [g.sommets[i] for i in (0, 1, 2, 7)]
iti = g.tourneeApproximative(tournee)
g.traceItineraire(iti)
tournee = [g1.sommets[i] for i in (0, 1, 2, 7)]
cout,iti = g1.voyageurDeCommerceNaif(tournee)
g1.traceItineraire(iti)
graphique.affiche(g, (0, 0), 10., blocage=False)
graphique.affiche(g1, (0, 0), 10.)
def testQuestion4_9():
"""Mesure le temps de calcul."""
g = graphe.reseauRapide(graphe.pointsAleatoires(1000, 1000))
prepare = lambda p : random.sample(g.sommets, p)
valeurs_n = list(map(int, np.logspace(1, 2, 30)))
temps = chronometre(g.tourneeApproximative, prepare, valeurs_n)
pl.close('all')
pl.title("Temps d'exécution pour le voyageur de commerce approximatif.")
pl.plot(valeurs_n, temps)
pl.xlabel("n (nombre de points de la tournée)")
pl.ylabel("temps")
pl.show()
pl.title("Temps d'exécution pour le voyageur de commerce approximatif.")
pl.loglog(valeurs_n, temps)
pl.xlabel("n (nombre de points de la tournée)")
pl.ylabel("temps")
pl.show()
if __name__ == '__main__':
n = sys.argv[1]
if n in ('--help', '-h'):
print(__doc__)
else:
print('Question ', n)
locals()['testQuestion'+n]()