Skip to content

GitLab

Commit b5f0cb68 authored by Nicolas Floquet's avatar Nicolas Floquet
Browse files

Rendu Pagerank

parent b07575a8
Pipeline #3168 passed with stage
in 24 seconds
Hide whitespace changes
Inline Side-by-side
pagerank/main-pagerank.c 0 → 100644
View file @ b5f0cb68
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "src/pagerank.h"
/*
dot -Tpdf pagerank.dot -o pagerank.pdf
*/
char* google = "www.google.com";
char* fichierNico = "file://C:\\Users\\Nicolas\\Homework";
char* lipn = "lipn.univ-paris13.fr/";
char* lipnA3 = "https://lipn.univ-paris13.fr/accueil/equipe/a3/";
char* lipnAOC = "https://lipn.univ-paris13.fr/accueil/equipe/aoc/";
char* lipnPresentation = "https://lipn.univ-paris13.fr/accueil/presentation/le-laboratoire/";
char* youtube = "https://www.youtube.com/";
char* youtubeHistory = "https://www.youtube.com/feed/history";
char* youtubeSubs = "https://www.youtube.com/feed/subscriptions";
int main()
{
pagerank p;
double d = 0.3;
int i = 5;
creer_pagerank(&p, 5);
pagerank_add_URL(&p, google);
pagerank_add_URL(&p, fichierNico);
pagerank_add_URL(&p, lipn);
pagerank_add_URL(&p, lipnA3);
pagerank_add_URL(&p, lipnAOC);
pagerank_add_URL(&p, lipnPresentation);
pagerank_add_URL(&p, youtube);
pagerank_add_URL(&p, youtubeHistory);
pagerank_add_URL(&p, youtubeSubs);
pagerank_relier_URL(&p, google, youtube);
pagerank_relier_URL(&p, youtube, youtubeHistory);
pagerank_relier_URL(&p, youtube, youtubeSubs);
pagerank_relier_URL(&p, lipn, lipnA3);
pagerank_relier_URL(&p, lipn, lipnAOC);
pagerank_relier_URL(&p, lipn, lipnPresentation);
pagerank_relier_URL(&p, lipnPresentation, lipnA3);
pagerank_relier_URL(&p, lipnPresentation, lipnAOC);
pagerank_relier_URL(&p, fichierNico, google);
pagerank_afficher(&p);
pagerank_ecrire_dot_avec_score(&p, "pagerank_score.dot", i, d);
pagerank_detruire(&p);
return 0;
}
pagerank/src/graphe.c
View file @ b5f0cb68
......@@ -82,7 +82,7 @@ int graphe_contains(graphe* g, int u) {
/** Donne l'indice de la première occurence d'un sommet dans le graphe
* @param g un pointeur vers un graphe alloué en mémoire
* @param u un entier, le sommet dont on veut connaître l'indice dans le graphe
* @return l'indice de le sommet si il est dans le graphe et -1 sinon
* @return l'indice du sommet si il est dans le graphe et -1 sinon
* O(n)
*/
int graphe_find(graphe* g, int u) {
......@@ -98,6 +98,48 @@ int graphe_find(graphe* g, int u) {
}
/** Donne le degre entrant d'un sommet du graphe, c'est le nombre d'arêtes qui vont vers lui
* @param g un pointeur vers un graphe alloué en mémoire
* @param u un entier, le sommet dont on veut connaître le degré entrant
* @return le degré entrant du sommet si il est dans le graphe et -1 sinon
* O(n)
*/
int graphe_get_degre_entrant(graphe* g, int u) {
int res = -1, i;
if(g && u >= 0 && u <= graphe_get_plus_grand_sommet(g))
{
res++; // res == 0
for (i = 0; i < graphe_get_premier_vide(g); i++) {
if(g->col[i] == u) {
res++;
}
}
}
return res;
}
/** Donne le degre sortant d'un sommet du graphe, c'est le nombre d'arêtes qui partent de lui
* @param g un pointeur vers un graphe alloué en mémoire
* @param u un entier, le sommet dont on veut connaître le degré sortant
* @return le degré sortant du sommet si il est dans le graphe et -1 sinon
* O(n)
*/
int graphe_get_degre_sortant(graphe* g, int u) {
int res = -1, i;
if(g && u >= 0 && u <= graphe_get_plus_grand_sommet(g))
{
res++; // res == 0
for (i = 0; i < graphe_get_premier_vide(g); i++) {
if(g->ligne[i] == u) {
res++;
}
}
}
return res;
}
/** Renvoie le plus grand indice des sommets du graphe
* @param g un pointeur vers un graphe alloué en mémoire
* @return un entier
......@@ -123,7 +165,7 @@ int graphe_get_plus_grand_sommet(graphe* g) {
* @param j un des sommets de l'arête
*/
void graphe_ajouter_arete(graphe* g, int i, int j) {
if(g) {
if(g && i >= 0 && j >= 0) {
if(graphe_get_premier_vide(g) == graphe_get_max(g)) {
g->max *= 2;
g->ligne = realloc(g->ligne, g->max * sizeof(int));
......@@ -422,12 +464,12 @@ void graphe_afficher_tableaux(graphe* g) {
/** Donne la liste des sommets du graphe, sans répétitions dans le tableau listeSommets passé en argument
* @param g un graphe alloué en mémoire
* @param flagSommet un tableau qui indique pour chacun de ces indices, si le sommet correspondant est dans le graphe
* @param flagSommets un tableau qui indique pour chacun de ces indices, si le sommet correspondant est dans le graphe
* @param listeSommets la liste des sommets du graphe, au max il y en a 2n, où n = l'indice du premierVide du graphe
* @param ptrNbSommets un pointeur vers un entier qui est le nombre de sommets distincts du graphe
* O(n)
*/
void graphe_liste_sommets_dot(graphe* g, int* flagSommet, int* listeSommets, int* ptrNbSommets) {
void graphe_liste_sommets_dot(graphe* g, int* flagSommets, int* listeSommets, int* ptrNbSommets) {
/*
On utilise 2 tableaux pour avoir une liste des sommets dans le graphe.
Soit n = graphe_get_premier_vide(g), il y a au max 2n sommets différents
......@@ -443,18 +485,71 @@ void graphe_liste_sommets_dot(graphe* g, int* flagSommet, int* listeSommets, int
listeSommets[i]--; //-1 partout
}
for(i = 0; i < n; i++) {
if(!flagSommet[g->ligne[i]]) { //g->ligne[i] valait 0, donc le sommet n'était pas découvert
flagSommet[g->ligne[i]] = 1;
if(!flagSommets[g->ligne[i]]) { //g->ligne[i] valait 0, donc le sommet n'était pas découvert
flagSommets[g->ligne[i]] = 1;
listeSommets[(*ptrNbSommets)++] = g->ligne[i];
}
if(!flagSommet[g->col[i]]) { //g->col[i] valait 0, donc le sommet n'était pas découvert
flagSommet[g->col[i]] = 1;
if(!flagSommets[g->col[i]]) { //g->col[i] valait 0, donc le sommet n'était pas découvert
flagSommets[g->col[i]] = 1;
listeSommets[(*ptrNbSommets)++] = g->col[i];
}
}
}
/** Crée le tableau flagSommets d'un graphe, qui est un initialisé à 0 pour chaque case
* La taille du tableau est de n+1 où n est le sommet à la plus grande étiquette dans le graphe
* @param g un pointeur vers un graphe alloué en mémoire
* @return un tableau d'entiers valant 0 et NULL s'il y a une erreur d'allocation
* O(n)
*/
int* graphe_creer_flagSommets(graphe* g){
int n = graphe_get_premier_vide(g), sommetMax = graphe_get_plus_grand_sommet(g);
if(!n) {
printf("Erreur premier vide = 0, graphe vide graphe_creer_flagSommets\n");
return NULL;
}
int* flagSommets = (int *) calloc(sizeof(int), sommetMax + 1);
/*
flagSommets[i] =
0 : sommet pas dans le graphe
1 : sommet dans le graphe, il faudra l'ajouter dans le fichier dot
Toutes les valeurs entières entre 0 et sommetMax inclus peuvent être dans le graphe
*/
if(!flagSommets) {
printf("Erreur allocation flagSommets graphe_creer_flagSommets\n");
}
return flagSommets;
}
/** Crée le tableau listeSommets d'un graphe, qui est un initialisé à 0 pour chaque case
* La taille du tableau est de 2n où n est la taille des tableaux du graphe
* @param g un pointeur vers un graphe alloué en mémoire
* @return un tableau d'entiers valant 0 et NULL s'il y a une erreur d'allocation
* O(n)
*/
int* graphe_creer_listeSommets(graphe* g) {
int n = graphe_get_premier_vide(g);
int* listeSommets = (int *) calloc(sizeof(int), 2*n);
if(!n) {
printf("Erreur premier vide = 0, graphe vide graphe_creer_flagSommets\n");
return NULL;
}
/*
listeSommets[i] :
-1 : sommet pas dans le graphe
>= 0 : sommet dans le graphe, il faudra l'ajouter dans le fichier dot
Il y a au max 2n sommets différents
*/
if(!listeSommets) {
printf("Erreur allocation listeSommets graphe_creer_listeSommet\n");
}
return listeSommets;
}
/** Convertit un graphe au format DOT dans un fichier
* dot -Tpdf fichier.dot -o fichier.pdf
* @param g un graphe alloué en mémoire
......@@ -465,48 +560,35 @@ void graphe_liste_sommets_dot(graphe* g, int* flagSommet, int* listeSommets, int
*/
int graphe_ecrire_dot(graphe* g, char* nomFichier) {
if(g) {
int i, nbSommets = 0, n = graphe_get_premier_vide(g), sommetMax = graphe_get_plus_grand_sommet(g);
int i, nbSommets = 0, n = graphe_get_premier_vide(g);
int* ptrNbSommets = &nbSommets;
if(!n) {
printf("Erreur premier vide = 0, graphe vide graphe_ecrire_dot\n");
return -2;
}
int* flagSommet = (int *) calloc(sizeof(int), sommetMax + 1);
/*
flagSommet[i] =
0 : sommet pas dans le graphe
1 : sommet dans le graphe, il faudra l'ajouter dans le fichier dot
Toutes les valeurs entières entre 0 et sommetMax inclus peuvent être dans le graphe
*/
if(!flagSommet) {
printf("Erreur allocation flagSommet graphe_ecrire_dot\n");
int* flagSommets = graphe_creer_flagSommets(g);
if(!flagSommets) {
printf("Erreur allocation flagSommets graphe_ecrire_dot\n");
return -2;
}
int* listeSommets = (int *) calloc(sizeof(int), 2*n);
/*
listeSommets[i] :
-1 : sommet pas dans le graphe
>= 0 : sommet dans le graphe, il faudra l'ajouter dans le fichier dot
Il y a au max 2n sommets différents
*/
int* listeSommets = graphe_creer_listeSommets(g);
if(!listeSommets) {
printf("Erreur allocation listeSommets graphe_ecrire_dot\n");
free(flagSommet);
free(flagSommets);
return -2;
}
FILE *f = fopen(nomFichier, "w");
if (!f) {
free(flagSommet);
free(flagSommets);
free(listeSommets);
printf("Erreur ouverture fichier \"%s\"graphe_ecrire_dot\n", nomFichier);
return -1;
}
graphe_liste_sommets_dot(g, flagSommet, listeSommets, ptrNbSommets);
graphe_liste_sommets_dot(g, flagSommets, listeSommets, ptrNbSommets);
//Dans flagSommet, on a tous les flags indiquant si un sommet est dans le graphe ou non
//Dans flagSommets, on a tous les flags indiquant si un sommet est dans le graphe ou non
//Dans listeSommets on a la liste des sommets distincts
fputs("graph {\n", f);
for(i = 0; i < nbSommets; i++) {
......@@ -517,7 +599,7 @@ int graphe_ecrire_dot(graphe* g, char* nomFichier) {
fprintf(f, "\t%d -- %d;\n", g->ligne[i], g->col[i]);
}
fputs("}\n", f);
free(flagSommet);
free(flagSommets);
free(listeSommets);
fclose(f);
return 0;
......
pagerank/src/graphe.h
View file @ b5f0cb68
......@@ -55,12 +55,30 @@ int graphe_contains(graphe* g, int u);
/** Donne l'indice de la première occurence d'un sommet dans le graphe
* @param g un pointeur vers un graphe alloué en mémoire
* @param u un entier, le sommet dont on veut connaître l'indice dans le graphe
* @return l'indice de le sommet si il est dans le graphe et -1 sinon
* @return l'indice di sommet si il est dans le graphe et -1 sinon
* O(n)
*/
int graphe_find(graphe* g, int u);
/** Donne le degre entrant d'un sommet du graphe, c'est le nombre d'arêtes qui vont vers lui
* @param g un pointeur vers un graphe alloué en mémoire
* @param u un entier, le sommet dont on veut connaître le degré entrant
* @return le degré entrant du sommet si il est dans le graphe et -1 sinon
* O(n)
*/
int graphe_get_degre_entrant(graphe* g, int u);
/** Donne le degre sortant d'un sommet du graphe, c'est le nombre d'arêtes qui vont vers lui
* @param g un pointeur vers un graphe alloué en mémoire
* @param u un entier, le sommet dont on veut connaître le degré sortant
* @return le degré sortant du sommet si il est dans le graphe et -1 sinon
* O(n)
*/
int graphe_get_degre_sortant(graphe* g, int u);
/** Renvoie le plus grand indice des sommets du graphe
* @param g un pointeur vers un graphe alloué en mémoire
* @return un entier
......@@ -178,12 +196,30 @@ void graphe_afficher_tableaux(graphe* g);
/** Donne la liste des sommets du graphe, sans répétitions dans le tableau listeSommets passé en argument pour les indiquer dans le fichier DOT
* @param g un graphe alloué en mémoire
* @param flagSommet un tableau qui indique pour chacun de ces indices, si le sommet correspondant est dans le graphe
* @param flagSommets un tableau qui indique pour chacun de ces indices, si le sommet correspondant est dans le graphe
* @param listeSommets la liste des sommets du graphe, au max il y en a 2n, où n = l'indice du premierVide du graphe
* @param ptrNbSommets un pointeur vers un entier qui est le nombre de sommets distincts du graphe
* O(n)
*/
void graphe_liste_sommets_dot(graphe* g, int* flagSommet, int* listeSommets, int* ptrNbSommets);
void graphe_liste_sommets_dot(graphe* g, int* flagSommets, int* listeSommets, int* ptrNbSommets);
/** Crée le tableau flagSommets d'un graphe, qui est un initialisé à 0 pour chaque case
* La taille du tableau est de n+1 où n est le sommet à la plus grande étiquette dans le graphe
* @param g un pointeur vers un graphe alloué en mémoire
* @return un tableau d'entiers valant 0 et NULL s'il y a une erreur d'allocation
* O(n)
*/
int* graphe_creer_flagSommets(graphe* g);
/** Crée le tableau listeSommets d'un graphe, qui est un initialisé à 0 pour chaque case
* La taille du tableau est de 2n où n est la taille des tableaux du graphe
* @param g un pointeur vers un graphe alloué en mémoire
* @return un tableau d'entiers valant 0 et NULL s'il y a une erreur d'allocation
* O(n)
*/
int* graphe_creer_listeSommets(graphe* g);
/** Convertit un graphe au format DOT dans un fichier
......
pagerank/src/pagerank.c 0 → 100644
View file @ b5f0cb68
#include <stdio.h>
#include <stdlib.h>
#include "pagerank.h"
#include "graphe.h"
#include "liste_url.h"
/** Fonction qui crée un pagerank pour n URLs qui est stocké à l'adresse donnée en argument, déjà allouée,
* @param p un pagerank alloué en mémoire
* @param n un entier strictement positif, la taille du graphe et de la liste du pagerank
* @return 0 si la liste a été créée et -1 si n <= 0 et -2 s'il y a eu une erreur d'allocation
* O(n)
*/
int creer_pagerank(pagerank* p, int n) {
if(n <= 0) {
printf("Erreur paramètre creer_pagerank, n <= 0\n");
return -1;
}
if(!(p->g = (graphe*) malloc(sizeof(graphe)))) {
printf("Erreur allocation creer_pagerank, malloc p->g\n");
return -2;
}
if(creer_graphe(p->g, n)) {
free(p->g);
printf("Erreur allocation creer_pagerank, creer_graphe\n");
return -2;
}
if(!(p->l = (liste_url*) malloc(sizeof(liste_url)))) {
graphe_detruire(p->g);
free(p->g);
printf("Erreur allocation creer_pagerank, malloc p->l\n");
return -2;
}
if(creer_liste(p->l, n)) {
graphe_detruire(p->g);
free(p->g);
free(p->l);
printf("Erreur allocation creer_pagerank, creer_liste\n");
return -2;
}
return 0;
}
/** Libère la mémoire allouée dans un pagerank
* @param p un pagerank alloué en mémoire
* O(n)
*/
void pagerank_detruire(pagerank* p) {
if(p) {
if(p->g) {
graphe_detruire(p->g);
free(p->g);
p->g = NULL;
}
if(p->l) {
liste_detruire(p->l);
free(p->l);
p->l = NULL;
}
}
}
/** Donne l'indice d'une url est dans la liste d'un pagerank
* @param p un pagerank alloué en mémoire
* @param s une chaîne, l'URL dont on veut connaître l'indice dans la liste
* @return l'indice de l'URL si elle est dans la liste du pagerank et -1 sinon
* O(n)
*/
int pagerank_find_indice_URL(pagerank* p, char* s) {
if(p) {
return liste_find(p->l, s);
}
return -1;
}
/** Renvoie l'url à l'indice i dans la liste d'un pagerank
* @param p un pagerank alloué en mémoire
* @param i un entier
* @return p->l->urls[i] une chaîne de caractères si 0 <= i < liste_get_max(l), NULL sinon
* O(1)
*/
char* pagerank_get_URL_i(pagerank* p, int i) {
if(p) {
return liste_get_i(p->l, i);
}
return NULL;
}
/** Ajoute une URL à la première case vide dans la liste
* @param p un pagerank alloué en mémoire
* @param s une chaîne, l'URL à ajouter
* O(1)
*/
void pagerank_add_URL(pagerank* p, char* s) {
if(p && p->l) {
liste_add(p->l, s);
}
}
/** Retire une URL du pagerank en retirant le sommet de son graphe, et l'URL de sa liste
* @param p un pagerank alloué en mémoire
* @param s une chaîne, l'URL à retirer
* O(n)
*/
void pagerank_remove_URL(pagerank* p, char* s) {
if(p && p->l && p->g) {
int x = liste_find(p->l, s);
if(x != -1) {
liste_remove(p->l, s);
graphe_retirer_sommet(p->g, x);
}
}
}
/** Relie 2 URLs du pagerank
* @param p un pagerank alloué en mémoire
* @param s1 une des URLs du pagerank
* @param s2 une des URLs du pagerank
* O(n)
*/
void pagerank_relier_URL(pagerank* p, char* s1, char* s2) {
if(p && p->l && p->g) {
if(liste_contains(p->l, s1) && liste_contains(p->l, s2)) {
graphe_ajouter_arete(p->g, liste_find(p->l, s1), liste_find(p->l, s2));
}
}
}
/** Delie 2 URLs en retirant une arête entre les sommets correspondant du graphe du pagerank s'il y en a une
* @param p un pagerank alloué en mémoire
* @param s1 une des URLs du pagerank
* @param s2 une des URLs du pagerank
* O(n)
*/
void pagerank_delier_URL(pagerank* p, char* s1, char* s2) {
if(p && p->l && p->g) {
if(liste_contains(p->l, s1) && liste_contains(p->l, s2)) {
graphe_supprimer_arete(p->g, liste_find(p->l, s1), liste_find(p->l, s2));
}
}
}
/** Indique si une URL dans le pagerank a un lien vers une autre URL
* @param p un pagerank alloué en mémoire
* @param s1 une chaîne, l'URL où peut être le lien qu'on cherche
* @param s2 une chaîne, l'URL cible
* @return 1 si il y a un lien vers s2 dans la page s1 et 0 sinon
* O(n)
*/
int pagerank_link_to(pagerank* p, char* s1, char* s2) {
if(p && s1 && s2) {
int indice1 = pagerank_find_indice_URL(p, s1);
int indice2 = pagerank_find_indice_URL(p, s2);
return graphe_est_succ(p->g, indice1, indice2);
}
return 0;
}
/** Affiche le pagerank (le graphe et la liste)
* @param p un pagerank alloué en mémoire
* O(n)
*/
void pagerank_afficher(pagerank* p) {
if(p) {
printf("Voici la liste du pagerank:\n\n");
liste_afficher(p->l);
printf("Voici le graphe du pagerank sous la forme de ces tableaux (matrice creuse):\n\n");
graphe_afficher_tableaux(p->g);
printf("Voici le graphe du pagerank sous la forme d'une matrice d'adjacence:\n\n");
graphe_afficher(p->g);
}
else {
printf("Le pagerank est NULL\n");
}
}
/** Convertit le graphe d'un pagerank au format DOT dans un fichier
* On verra un graphe avec comme sommets les URLs
* dot -Tpdf fichier.dot -o fichier.pdf
* @param p un pagerank alloué en mémoire
* @param nomFichier, le nom du fichier où l'on veut écrire le graphe
* @return 0 si le graphe a bien été écris au format DOT,
* -1 s'il y a eu une erreur d'ouverture du fichier, et -2 sinon
* O(n)
*/
int pagerank_ecrire_dot(pagerank* p, char* nomFichier) {
if(p) {
int i, nbSommets = 0, n = graphe_get_premier_vide(p->g);
int* ptrNbSommets = &nbSommets;
int* flagSommets = graphe_creer_flagSommets(p->g);
if(!flagSommets) {
printf("Erreur allocation flagSommets pagerank_ecrire_dot\n");
return -2;
}
int* listeSommets = graphe_creer_listeSommets(p->g);
if(!listeSommets) {
printf("Erreur allocation listeSommets pagerank_ecrire_dot\n");
free(flagSommets);
return -2;
}
FILE *f = fopen(nomFichier, "w");
if (!f) {
free(flagSommets);
free(listeSommets);
printf("Erreur ouverture fichier \"%s\"pagerank_ecrire_dot\n", nomFichier);
return -1;
}
graphe_liste_sommets_dot(p->g, flagSommets, listeSommets, ptrNbSommets);
//Dans flagSommets, on a tous les flags indiquant si un sommet est dans le graphe ou non
//Dans listeSommets on a la liste des sommets distincts
fputs("graph {\n", f);
for(i = 0; i < nbSommets; i++) {
fprintf(f, "\t\"%s\";\n", liste_get_i(p->l, listeSommets[i]));
}
fputs("\n", f);
for(i = 0; i < n; i++) {
fprintf(f, "\t\"%s\" -- \"%s\";\n", liste_get_i(p->l, p->g->ligne[i]), liste_get_i(p->l, p->g->col[i]));
}
fputs("}\n", f);
free(flagSommets);
free(listeSommets);
fclose(f);
return 0;
}
printf("Erreur pagerank NULL pagerank_ecrire_dot\n");
return -2;
}
/** Calcule le score de chaque page dans le pagerank
* @param p un pagerank alloué en mémoire
* @param it le nombre d'itérations qu'on va faire pour trouver le score
* @param d un facteur d'amortissement
* @return mu un taleau de nombres réels entre 0 et 1, la probabilité d'être sur un site à un instant ou NULL s'il y a une erreur
* O(n²)
*/
double* pagerank_Calcul_Score(pagerank* p, int it, double d) {
int i, j, k, nbSommets = 0, n = graphe_get_premier_vide(p->g);
int* ptrNbSommets = &nbSommets;
double* mu = NULL, *M = NULL, tmp;
int* flagSommets = graphe_creer_flagSommets(p->g);
int* listeSommets = graphe_creer_listeSommets(p->g);
if(!flagSommets || !listeSommets) {
printf("Erreur allocation 1 pagerank_Calcul_Score\n");
free(flagSommets);
free(listeSommets);
return NULL;
}
graphe_liste_sommets_dot(p->g, flagSommets, listeSommets, ptrNbSommets);