Tests Belgique + param tolerance
This commit is contained in:
parent
a5b553e712
commit
3095e3e08c
1 changed files with 142 additions and 133 deletions
|
@ -40,7 +40,9 @@ public abstract class ShortestPathAlgorithmTest {
|
|||
static ArrayList<String> Maps = new ArrayList<String>(Arrays.asList("../Maps/carre.mapgr",
|
||||
"../Maps/insa.mapgr",
|
||||
"../Maps/toulouse.mapgr",
|
||||
"../Maps/midi-pyrenees.mapgr"));
|
||||
"../Maps/midi-pyrenees.mapgr",
|
||||
"../Maps/belgium.mapgr"
|
||||
));
|
||||
|
||||
@BeforeClass
|
||||
/*
|
||||
|
@ -148,6 +150,78 @@ public abstract class ShortestPathAlgorithmTest {
|
|||
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
|
||||
/*
|
||||
|
@ -252,7 +326,7 @@ public abstract class ShortestPathAlgorithmTest {
|
|||
nTestsWithBellman(myGraph, origin, destination, arcInspector, size_graph, 2000);
|
||||
}
|
||||
|
||||
//@Test
|
||||
@Test
|
||||
/*
|
||||
* 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)
|
||||
|
@ -282,7 +356,7 @@ public abstract class ShortestPathAlgorithmTest {
|
|||
* 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,
|
||||
* on va être obligé de trouver une autre solution (principale difficulté).
|
||||
* Mode: LENGTH
|
||||
* Mode: TIME
|
||||
* Carte utilisée : ../Maps/toulouse.mapgr
|
||||
*/
|
||||
public void cheminsToulouseTIME() {
|
||||
|
@ -353,15 +427,14 @@ public abstract class ShortestPathAlgorithmTest {
|
|||
|
||||
@Test
|
||||
/*
|
||||
* 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 dont il a été extrait.
|
||||
* 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: LENGTH
|
||||
* Carte utilisée : ../Maps/midi_pyrenees.mapgr
|
||||
|
@ -371,76 +444,20 @@ public abstract class ShortestPathAlgorithmTest {
|
|||
ArcInspector arcInspector = ArcInspectorFactory.getAllFilters().get(0);
|
||||
Node origin = 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++) {
|
||||
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());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
TestsCheminsTropLongs(myGraph, origin, destination, arcInspector, 10, 25, 1);
|
||||
}
|
||||
|
||||
@Test
|
||||
// @Test
|
||||
/*
|
||||
* Cette fois-ci, Bellman est trop long à utiliser un grand nombre de fois.
|
||||
* On va donc utiliser quelques techniques pour se rassurer:
|
||||
* -Le temps mis est plus grand que le temps à vitesse maximale permise.
|
||||
* -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é.
|
||||
* -un plus court chemin de coût inférieur au chemin dont il a été extrait.
|
||||
* 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/midi_pyrenees.mapgr
|
||||
|
@ -450,62 +467,54 @@ public abstract class ShortestPathAlgorithmTest {
|
|||
ArcInspector arcInspector = ArcInspectorFactory.getAllFilters().get(2);
|
||||
Node origin = 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++) {
|
||||
origin = myGraph.get(Math.abs(rand.nextInt()) % size_graph);
|
||||
destination = myGraph.get(Math.abs(rand.nextInt()) % size_graph);
|
||||
TestsCheminsTropLongs(myGraph, origin, destination, arcInspector, 10, 25, 1);
|
||||
}
|
||||
|
||||
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);
|
||||
final ShortestPathSolution path = algo.doRun();
|
||||
TestsCheminsTropLongs(myGraph, origin, destination, arcInspector, 1, 10, 10);
|
||||
}
|
||||
|
||||
if (path.getPath() != null) {
|
||||
assert(path.getPath().isValid());
|
||||
assert(path.isFeasible());
|
||||
assert((Math.abs(algo.getCostPath() - path.getPath().getMinimumTravelTime())) < 10.0);
|
||||
@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 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());
|
||||
|
||||
// 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());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
TestsCheminsTropLongs(myGraph, origin, destination, arcInspector, 1, 10, 10);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
Loading…
Reference in a new issue