lacau/BE_Graphes
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Tests Belgique + param tolerance

Browse source
This commit is contained in:
Clement Lacau 2024-05-25 22:27:34 +02:00
parent a5b553e712
commit 3095e3e08c
1 changed files with 142 additions and 133 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

267
be-graphes-algos/src/test/java/org/insa/graphs/algorithm/shortestpath/ShortestPathAlgorithmTest.java
View file

@ -40,7 +40,9 @@ public abstract class ShortestPathAlgorithmTest {
static ArrayList<String> Maps = new ArrayList<String>(Arrays.asList("../Maps/carre.mapgr", static ArrayList<String> Maps = new ArrayList<String>(Arrays.asList("../Maps/carre.mapgr",
"../Maps/insa.mapgr", "../Maps/insa.mapgr",
"../Maps/toulouse.mapgr", "../Maps/toulouse.mapgr",
"../Maps/midi-pyrenees.mapgr")); "../Maps/midi-pyrenees.mapgr",
"../Maps/belgium.mapgr"
));
@BeforeClass @BeforeClass
/* /*
@ -148,6 +150,78 @@ public abstract class ShortestPathAlgorithmTest {
assert(path.getPath() == null); assert(path.getPath() == null);
} }
/*
* Cette fois-ci, Bellman est trop long à utiliser un grand nombre de fois.
* On va donc utiliser quelques techniques pour se rassurer:
* -Le cout en distance est au moins la distance à vol d'oiseau entre les noeuds.
* -les sous-chemins d'un PCC sont des PCC. Sachant cela, on doit être sur
* qu'en appliquant un second Dijkstra sur 2 noeuds aléatoires dans le path
* renvoyé par le premier Dijkstra (hors origine et destination), on
* obtient :
* -un plus court chemin qui est le même que le sous chemin relevé (sous PCC).
* -un plus court chemin de coût inférieur au chemin (premier dijkstra) dont il a été extrait.
* On teste 'nbrePCC' PCC et 'nbreSousPCC' sous PCC.
*/
public void TestsCheminsTropLongs(Graph graph, Node origin, Node destination, ArcInspector arcFilter, int nbrePCC, int nbreSousPCC, float tolerance) {
int longueur_path = 0;
Node noeudSelectionneOrigine = graph.get(0);
Node noeudSelectionneDestination = graph.get(0);
int size_graph = graph.size();
for (int i = 0 ; i < nbrePCC ; i++) {
origin = graph.get(Math.abs(rand.nextInt()) % size_graph);
destination = graph.get(Math.abs(rand.nextInt()) % size_graph);
ShortestPathData data = new ShortestPathData(graph, origin, destination, arcFilter);
final ShortestPathAlgorithm algo = initAlgo(data);
final ShortestPathSolution path = algo.doRun();
if (path.getPath() != null) {
assert(path.getPath().isValid());
assert(path.isFeasible());
assert((Math.abs(algo.getCostPath() - path.getPath().getLength())) < tolerance);
double distanceFromOriginToDestination = Point.distance(origin.getPoint(), destination.getPoint());
// Distance trouvée supérieure ou égale (improbable voire impossible) au chemin à vol d'oiseau.
assert(distanceFromOriginToDestination <= algo.getCostPath());
for (int j = 0; j < nbreSousPCC ; j++) {
longueur_path = path.getPath().size();
int milieu_path = longueur_path / 2;
int indiceOrigine = Math.abs(rand.nextInt()) % milieu_path;
int indiceDestination = milieu_path + Math.abs(rand.nextInt()) % milieu_path - 1;
noeudSelectionneOrigine = path.getPath().getArcs().get(indiceOrigine).getOrigin();
noeudSelectionneDestination = path.getPath().getArcs().get(indiceDestination).getOrigin();
ShortestPathData dataSousPCC = new ShortestPathData(graph, noeudSelectionneOrigine, noeudSelectionneDestination, arcFilter);
final ShortestPathAlgorithm algoSousPCC = initAlgo(dataSousPCC);
final ShortestPathSolution pathSousPCC = algoSousPCC.doRun();
if (path.getPath() != null) {
// Note: comme les chemins des arcs sont récupérés au même en droit entre pathSousPCC et path,
// on peut comparer directement les objets soit leurs adresses. Sinon, il aurait fallu comparer
// l'id des noeuds origines et destination du chemin.
for (int k = 0 ; k < pathSousPCC.getPath().size()-1; k++) {
assert(pathSousPCC.getPath().getArcs().get(k) == path.getPath().getArcs().get(indiceOrigine + k));
}
assert(pathSousPCC.getPath().isValid());
assert(pathSousPCC.isFeasible());
assert((Math.abs(algoSousPCC.getCostPath() - pathSousPCC.getPath().getLength())) < 1.0);
// sous PCC de coût inférieur au PCC
assert(algoSousPCC.getCostPath() <= algo.getCostPath());
}
}
}
}
}
@Test @Test
/* /*
@ -252,7 +326,7 @@ public abstract class ShortestPathAlgorithmTest {
nTestsWithBellman(myGraph, origin, destination, arcInspector, size_graph, 2000); nTestsWithBellman(myGraph, origin, destination, arcInspector, size_graph, 2000);
} }
//@Test @Test
/* /*
* Permet de tester les chemins moyennement longs en distance (0 - 30 km). * Permet de tester les chemins moyennement longs en distance (0 - 30 km).
* On teste 100 chemins sur la carte de Toulouse (environ 1 min d'exécution) * On teste 100 chemins sur la carte de Toulouse (environ 1 min d'exécution)
@ -282,7 +356,7 @@ public abstract class ShortestPathAlgorithmTest {
* graphe, ce test prend moins d'une minute donc on va quand même utiliser Bellman. * graphe, ce test prend moins d'une minute donc on va quand même utiliser Bellman.
* Par contre, dans le test sur la région midi_pyrenees / France qui arrive après, * Par contre, dans le test sur la région midi_pyrenees / France qui arrive après,
* on va être obligé de trouver une autre solution (principale difficulté). * on va être obligé de trouver une autre solution (principale difficulté).
* Mode: LENGTH * Mode: TIME
* Carte utilisée : ../Maps/toulouse.mapgr * Carte utilisée : ../Maps/toulouse.mapgr
*/ */
public void cheminsToulouseTIME() { public void cheminsToulouseTIME() {
@ -353,15 +427,14 @@ public abstract class ShortestPathAlgorithmTest {
@Test @Test
/* /*
* Cette fois-ci, Bellman est trop long à utiliser un grand nombre de fois. * Le principe du test est celui utilisé dans la méthode TestsCheminsTropLongues:
* On va donc utiliser quelques techniques pour se rassurer: * -On fait plusieurs PCC et pour chacun on extrait plusieurs chemins des PCC
* -Le cout en distance est au moins la distance à vol d'oiseau entre les noeuds. * et on s'assure que c'est un PCC en refaisant notre algo de l'origine à la
* -les sous-chemins d'un PCC sont des PCC. Sachant cela, on doit être sur * destination du chemin extrait. Les chemins extraits et sousPCC obtenus doivent
* qu'en appliquant un second Dijkstra sur 2 noeuds aléatoires dans le path * être les mêmes.
* renvoyé par le premier Dijkstra (hors origine et destination), on * Entres autres, on vérifie aussi que les PCC sont de distance supérieures
* obtient : * aux distances à vol d'oiseau et que les sousPCC sont de longueur
* -un plus court chemin qui est le même que le sous chemin relevé (sous PCC). * inférieures aux PCC.
* -un plus court chemin de coût inférieur au chemin dont il a été extrait.
* On teste 10 PCC et pour chaque PCC 25 sous PCC * On teste 10 PCC et pour chaque PCC 25 sous PCC
* Mode: LENGTH * Mode: LENGTH
* Carte utilisée : ../Maps/midi_pyrenees.mapgr * Carte utilisée : ../Maps/midi_pyrenees.mapgr
@ -371,76 +444,20 @@ public abstract class ShortestPathAlgorithmTest {
ArcInspector arcInspector = ArcInspectorFactory.getAllFilters().get(0); ArcInspector arcInspector = ArcInspectorFactory.getAllFilters().get(0);
Node origin = myGraph.get(0); Node origin = myGraph.get(0);
Node destination = myGraph.get(0); Node destination = myGraph.get(0);
int size_graph = myGraph.size();
int longueur_path = 0;
Node noeudSelectionneOrigine = myGraph.get(0);
Node noeudSelectionneDestination = myGraph.get(0);
for (int i = 0 ; i < 10 ; i++) { TestsCheminsTropLongs(myGraph, origin, destination, arcInspector, 10, 25, 1);
origin = myGraph.get(Math.abs(rand.nextInt()) % size_graph);
destination = myGraph.get(Math.abs(rand.nextInt()) % size_graph);
ShortestPathData data = new ShortestPathData(myGraph, origin, destination, arcInspector);
final ShortestPathAlgorithm algo = initAlgo(data);
final ShortestPathSolution path = algo.doRun();
if (path.getPath() != null) {
assert(path.getPath().isValid());
assert(path.isFeasible());
assert((Math.abs(algo.getCostPath() - path.getPath().getLength())) < 1.0);
double distanceFromOriginToDestination = Point.distance(origin.getPoint(), destination.getPoint());
// Distance trouvée supérieure ou égale (improbable voire impossible) au chemin à vol d'oiseau.
assert(distanceFromOriginToDestination <= algo.getCostPath());
for (int j = 0; j < 25 ; j++) {
longueur_path = path.getPath().size();
int milieu_path = longueur_path / 2;
int indiceOrigine = Math.abs(rand.nextInt()) % milieu_path;
int indiceDestination = milieu_path + Math.abs(rand.nextInt()) % milieu_path - 1;
noeudSelectionneOrigine = path.getPath().getArcs().get(indiceOrigine).getOrigin();
noeudSelectionneDestination = path.getPath().getArcs().get(indiceDestination).getOrigin();
ShortestPathData dataSousPCC = new ShortestPathData(myGraph, noeudSelectionneOrigine, noeudSelectionneDestination, arcInspector);
final ShortestPathAlgorithm algoSousPCC = initAlgo(dataSousPCC);
final ShortestPathSolution pathSousPCC = algoSousPCC.doRun();
if (path.getPath() != null) {
// Note: comme les chemins des arcs sont récupérés au même en droit entre pathSousPCC et path,
// on peut comparer directement les objets soit leurs adresses. Sinon, il aurait fallu comparer
// l'id des noeuds origines et destination du chemin.
for (int k = 0 ; k < pathSousPCC.getPath().size()-1; k++) {
assert(pathSousPCC.getPath().getArcs().get(k) == path.getPath().getArcs().get(indiceOrigine + k));
}
assert(pathSousPCC.getPath().isValid());
assert(pathSousPCC.isFeasible());
assert((Math.abs(algoSousPCC.getCostPath() - pathSousPCC.getPath().getLength())) < 1.0);
// sous PCC de coût inférieur au PCC
assert(algoSousPCC.getCostPath() <= algo.getCostPath());
}
}
}
}
} }
@Test // @Test
/* /*
* Cette fois-ci, Bellman est trop long à utiliser un grand nombre de fois. * Le principe du test est celui utilisé dans la méthode TestsCheminsTropLongues:
* On va donc utiliser quelques techniques pour se rassurer: * -On fait plusieurs PCC et pour chacun on extrait plusieurs chemins des PCC
* -Le temps mis est plus grand que le temps à vitesse maximale permise. * et on s'assure que c'est un PCC en refaisant notre algo de l'origine à la
* -les sous-chemins d'un PCC sont des PCC. Sachant cela, on doit être sur * destination du chemin extrait. Les chemins extraits et sousPCC obtenus doivent
* qu'en appliquant un second Dijkstra sur 2 noeuds aléatoires dans le path * être les mêmes.
* renvoyé par le premier Dijkstra (hors origine et destination), on * Entres autres, on vérifie aussi que les PCC sont de distance supérieures
* obtient : * aux distances à vol d'oiseau et que les sousPCC sont de longueur
* -un plus court chemin qui est le même que le sous chemin relevé. * inférieures aux PCC.
* -un plus court chemin de coût inférieur au chemin dont il a été extrait.
* On teste 10 PCC et pour chaque PCC 25 sous PCC * On teste 10 PCC et pour chaque PCC 25 sous PCC
* Mode: TIME * Mode: TIME
* Carte utilisée : ../Maps/midi_pyrenees.mapgr * Carte utilisée : ../Maps/midi_pyrenees.mapgr
@ -450,62 +467,54 @@ public abstract class ShortestPathAlgorithmTest {
ArcInspector arcInspector = ArcInspectorFactory.getAllFilters().get(2); ArcInspector arcInspector = ArcInspectorFactory.getAllFilters().get(2);
Node origin = myGraph.get(0); Node origin = myGraph.get(0);
Node destination = myGraph.get(0); Node destination = myGraph.get(0);
int size_graph = myGraph.size();
int longueur_path = 0;
Node noeudSelectionneOrigine;
Node noeudSelectionneDestination;
for (int i = 0 ; i < 10 ; i++) { TestsCheminsTropLongs(myGraph, origin, destination, arcInspector, 10, 25, 1);
origin = myGraph.get(Math.abs(rand.nextInt()) % size_graph); }
destination = myGraph.get(Math.abs(rand.nextInt()) % size_graph);
ShortestPathData data = new ShortestPathData(myGraph, origin, destination, arcInspector); @Test
/*
* Le principe du test est celui utilisé dans la méthode TestsCheminsTropLongues:
* -On fait plusieurs PCC et pour chacun on extrait plusieurs chemins des PCC
* et on s'assure que c'est un PCC en refaisant notre algo de l'origine à la
* destination du chemin extrait. Les chemins extraits et sousPCC obtenus doivent
* être les mêmes.
* Entres autres, on vérifie aussi que les PCC sont de distance supérieures
* aux distances à vol d'oiseau et que les sousPCC sont de longueur
* inférieures aux PCC.
* On teste 10 PCC et pour chaque PCC 25 sous PCC
* Mode: TIME
* Carte utilisée : ../Maps/belgium.mapgr
*/
public void cheminBelgiqueLENGTH() {
Graph myGraph = graph.get(4);
ArcInspector arcInspector = ArcInspectorFactory.getAllFilters().get(0);
Node origin = myGraph.get(0);
Node destination = myGraph.get(0);
final ShortestPathAlgorithm algo = initAlgo(data); TestsCheminsTropLongs(myGraph, origin, destination, arcInspector, 1, 10, 10);
final ShortestPathSolution path = algo.doRun(); }
if (path.getPath() != null) { @Test
assert(path.getPath().isValid()); /*
assert(path.isFeasible()); * Le principe du test est celui utilisé dans la méthode TestsCheminsTropLongues:
assert((Math.abs(algo.getCostPath() - path.getPath().getMinimumTravelTime())) < 10.0); * -On fait plusieurs PCC et pour chacun on extrait plusieurs chemins des PCC
* et on s'assure que c'est un PCC en refaisant notre algo de l'origine à la
* destination du chemin extrait. Les chemins extraits et sousPCC obtenus doivent
* être les mêmes.
* Entres autres, on vérifie aussi que les PCC sont de distance supérieures
* aux distances à vol d'oiseau et que les sousPCC sont de longueur
* inférieures aux PCC.
* On teste 10 PCC et pour chaque PCC 25 sous PCC
* Mode: TIME
* Carte utilisée : ../Maps/belgium.mapgr
*/
public void cheminBelgiqueTIME() {
Graph myGraph = graph.get(4);
ArcInspector arcInspector = ArcInspectorFactory.getAllFilters().get(2);
Node origin = myGraph.get(0);
Node destination = myGraph.get(0);
double tempsFromOriginToDestination = Point.distance(origin.getPoint(), destination.getPoint()) / (1000 * data.getGraph().getGraphInformation().getMaximumSpeed()); TestsCheminsTropLongs(myGraph, origin, destination, arcInspector, 1, 10, 10);
// Temps supérieur ou égal (improbable voire impossible) au chemin à vol d'oiseau à la vitesse maximale.
assert(tempsFromOriginToDestination <= algo.getCostPath());
for (int j = 0; j < 25 ; j++) {
longueur_path = path.getPath().size();
int milieu_path = longueur_path / 2;
int indiceOrigine = Math.abs(rand.nextInt()) % milieu_path;
int indiceDestination = milieu_path + Math.abs(rand.nextInt()) % milieu_path - 1;
noeudSelectionneOrigine = path.getPath().getArcs().get(indiceOrigine).getOrigin();
noeudSelectionneDestination = path.getPath().getArcs().get(indiceDestination).getOrigin();
ShortestPathData dataSousPCC = new ShortestPathData(myGraph, noeudSelectionneOrigine, noeudSelectionneDestination, arcInspector);
final ShortestPathAlgorithm algoSousPCC = initAlgo(dataSousPCC);
final ShortestPathSolution pathSousPCC = algoSousPCC.doRun();
if (path.getPath() != null) {
// Note: comme les chemins des arcs sont récupérés au même en droit entre pathSousPCC et path,
// on peut comparer directement les objets soit leurs adresses. Sinon, il aurait fallu comparer
// l'id des noeuds origines et destination du chemin.
for (int k = 0 ; k < pathSousPCC.getPath().size()-1; k++) {
assert(pathSousPCC.getPath().getArcs().get(k) == path.getPath().getArcs().get(indiceOrigine + k));
}
assert(pathSousPCC.getPath().isValid());
assert(pathSousPCC.isFeasible());
assert((Math.abs(algoSousPCC.getCostPath() - pathSousPCC.getPath().getMinimumTravelTime())) < 1.0);
// sous PCC de coût inférieur au PCC
assert(algoSousPCC.getCostPath() <= algo.getCostPath());
}
}
}
}
} }
} }