créer un tableau à partir d'une table de hachage

Version imprimable

Voir 40 message(s) de cette discussion en une page

"callback" signifie que c'est une fonction que tu passes en paramètre à une autre.

Ainsi, pour l'appel à qsort, c'est ainsi:

Code:

1
2
3
4
5
6
7
8
9
void TrierMotsCompacts(MotCompact pMotsCompacts[], size_t nbMotsCompacts)
{
	qsort(
	 pMotsCompacts, /*adresse du tableau*/
	 nbMotsCompact, /*nombre d'éléments*/
	 sizeof *pMotsCompacts, /*taille d'un élément*/
	 MotCompact_qsort_callback /*fonction de comparaison*/
	 );
}

Et pour l'appel à bsearch(), c'est ainsi:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
MotCompact* RechercherMot(MotCompact pMotsCompacts[], size_t nbMotsCompacts, char const * mot)
{
	/*Attention, bsearch() n'est pas const-correcte:
	  Elle présente les mêmes problèmes que strchr().*/
	return bsearch(
	 mot, /*clé*/
	 pMotsCompacts, /*adresse du tableau*/
	 nbMotsCompact, /*nombre d'éléments*/
	 sizeof *pMotsCompacts, /*taille d'un élément*/
	 MotCompact_bsearch_callback /*fonction de comparaison*/
	 );
}
MotCompact const* RechercherMotC(MotCompact const pcMotsCompacts[], size_t nbMotsCompacts, char const * mot)
{
	/*Attention, bsearch() n'est pas const-correcte:
	  Elle présente les mêmes problèmes que strchr().*/
	return bsearch(
	 mot, /*clé*/
	 pcMotsCompacts, /*adresse du tableau*/
	 nbMotsCompact, /*nombre d'éléments*/
	 sizeof *pcMotsCompacts, /*taille d'un élément*/
	 MotCompact_bsearch_callback /*fonction de comparaison*/
	 );
}

02/11/2009, 17h31
étoile de mer

Merci beaucoup Médinoc, pour l'explication et le temps que tu as consacré pour m'aider :)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
TableauMotsCompacts* CreerTableMotsCompacts(TableHachageMot *DblTableHash1fr)
{
	TableauMotsCompacts *pRet = malloc(TAILLEHASH * sizeof*pRet);
 
	size_t iHash=0;
	if(pRet!=NULL)
	{
	        for(iHash=0 ; iHash<TAILLEHASH ; iHash++)
	        {
			ChainonMot const *pc;
			size_t nTab=0, iTab=0;
 
			/*Premier parcours: Comptage*/
			for(pc=GetPremierC(&DblTableHash1fr[iHash][iHash]) ; pc!=NULL ; pc=GetNextC(pc))
				nTab++;
 
			pRet[iHash].nbMotsCompacts = nTab;
			pRet[iHash].pMotsCompacts = malloc(nTab * sizeof(MotCompact));
			if(pRet[iHash].pMotsCompacts != NULL)
			{
				/*Second parcours: Copie/Initialisation*/
				for(pc=GetPremierC(&DblTableHash1fr[iHash][iHash]) ; pc!=NULL ; pc=GetNextC(pc))
				{
					InitialiserMotCompact(&pRet[iHash].pMotsCompacts[iTab], pc);
					iTab++;
				}
 
 
				//quicksort
				TrierMotsCompacts(pRet, nbmots);
 
			}
		}
	}
	return pRet;
}

se/main.c|2027|attention : conflicting types for ‘TrierMotsCompacts’|
Ah oui, là y a une erreur

Code:

TrierMotsCompacts(pRet, nbmots);

faut pas mette nbmots, mais autre chose ... :roll:

02/11/2009, 18h06
étoile de mer

Ah oui, peut etre faut mettre

Code:

TrierMotsCompacts(pRet, nTab);
02/11/2009, 18h15
Médinoc

Non, il faut mettre ceci:

Code:

TrierMotsCompacts(pRet[iHash].pMotsCompacts, pRet[iHash].nbMotsCompacts);
02/11/2009, 18h17
étoile de mer

Ok, merci :)
Maintenant je passe à la génération des regles, j'espere que soit optimisé de cette façon
02/11/2009, 22h04
étoile de mer

erreur de compilation
Bonsoir,
j'ai une erreur de segmentation
Code:

1 2 3 4 5 char const *GetMotCompact(MotCompact const *This) { assert(This!=NULL); return This->sczMot; }
le compilateur stoppe à ce niveau :
Code:

1 2 m1= RechercherMotC(m1,n, pcMot);
Une idée svp?
merci
02/11/2009, 22h10
Médinoc

A-ton vérifié que toutes les allocations s'étaient bien passées?

Edit: Attends, pourquoi a-t-on m1 à la fois en entrée et en sortie de la fonction? Et d'où vient ce n?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
int ChargerTableFichier(TableHachageMot *DblTableHash1fr,TableHachageMot *DblTableHash2fr,TableHachageMot *DblTableHash1en,TableHachageMot *DblTableHash2en)
{
 
    CalculerNombreLignesDoubleTable(DblTableHash1fr);
    struct char_fbtAllocator *pAllocCaracs1=NULL, *pAllocCaracs2=NULL, *pAllocCaracs3=NULL, *pAllocCaracs4=NULL;
	struct int_fbtAllocator *pAllocLignes1=NULL, *pAllocLignes2=NULL, *pAllocLignes3=NULL, *pAllocLignes4=NULL;
	size_t *pTailles1=NULL, *pTailles2=NULL,*pTailles3=NULL,*pTailles4=NULL, nbMots1=0, nbMots2=0,nbMots3=0,nbMots4=0;
	int retour = EXIT_FAILURE;
    putchar('\n');
	/*Initialisation des allocateurs */
	{
		size_t nbCaracs1=0,nbCaracs2=0, nbCaracs3=0, nbCaracs4=0;
		int nbLignes1=0, nbLignes2=0,nbLignes3=0, nbLignes4=0;
		if(CompterToutesTablesFichBinaire1fr(&pTailles1, &nbCaracs1, &nbLignes1)<0)
			goto LNettoyage;
		if(CompterToutesTablesFichBinaire2fr(&pTailles2, &nbCaracs2, &nbLignes2)<0)
			goto LNettoyage;
			if(CompterToutesTablesFichBinaire1en(&pTailles3, &nbCaracs3, &nbLignes3)<0)
			goto LNettoyage;
		if(CompterToutesTablesFichBinaire2en(&pTailles4, &nbCaracs4, &nbLignes4)<0)
		goto LNettoyage;
		nbMots1 = SommeTailles1fr(pTailles1);
		nbMots2 = SommeTailles2fr(pTailles2);
		nbMots3 = SommeTailles1en(pTailles3);
		nbMots4 = SommeTailles2en(pTailles4);
		pAllocCaracs1 = char_CreateFbtAllocator(nbCaracs1);
		pAllocCaracs2 = char_CreateFbtAllocator(nbCaracs2);
		pAllocCaracs3 = char_CreateFbtAllocator(nbCaracs3);
		pAllocCaracs4= char_CreateFbtAllocator(nbCaracs4);
		if(pAllocCaracs1==NULL || pAllocCaracs2==NULL|| pAllocCaracs3==NULL|| pAllocCaracs4==NULL)
			goto LNettoyage;
		pAllocLignes1 = int_CreateFbtAllocator(nbLignes1);
		pAllocLignes2 = int_CreateFbtAllocator(nbLignes2);
		pAllocLignes3 = int_CreateFbtAllocator(nbLignes3);
		pAllocLignes4 = int_CreateFbtAllocator(nbLignes4);
		if(pAllocLignes1==NULL || pAllocLignes2==NULL|| pAllocLignes3==NULL|| pAllocLignes4==NULL)
			goto LNettoyage;
	}
	{
 
	MotCompact * pMots1fr = LireToutesTablesFichBinaire1fr(pTailles1, pAllocCaracs1, pAllocLignes1);
	MotCompact * pMots2fr = LireToutesTablesFichBinaire2fr(pTailles2, pAllocCaracs2, pAllocLignes2);
    MotCompact * pMots1en = LireToutesTablesFichBinaire1en(pTailles3, pAllocCaracs3, pAllocLignes3);
	MotCompact * pMots2en = LireToutesTablesFichBinaire2en(pTailles4, pAllocCaracs4, pAllocLignes4);
		if(pMots1fr==NULL || pMots2fr==NULL||pMots1en==NULL || pMots2en==NULL)
 
		{
			DetruireTableauMotsCompacts(pMots1fr), pMots1fr=NULL;
            DetruireTableauMotsCompacts(pMots2fr), pMots2fr=NULL;
			DetruireTableauMotsCompacts(pMots1en), pMots1en=NULL;
			DetruireTableauMotsCompacts(pMots2en), pMots2en=NULL;
			goto LNettoyage;
		}
 
 
 
 
 
 //  calculerlesRegles( pMots1fr,pMots1en,nbMots1,nbMots3);
  calculerlesRegles1(pMots2fr,pMots1en,nbMots1,nbMots2,nbMots3,pMots1fr);
 
 
 
		DetruireTableauMotsCompacts(pMots1fr), pMots1fr=NULL;
	DetruireTableauMotsCompacts(pMots2fr), pMots2fr=NULL;
			DetruireTableauMotsCompacts(pMots1en), pMots1en=NULL;
		DetruireTableauMotsCompacts(pMots2en), pMots2en=NULL;
		retour = EXIT_SUCCESS;
	}
  LNettoyage:
 
	free(pTailles1), pTailles1=NULL;
	free(pTailles2), pTailles2=NULL;
	free(pTailles3), pTailles3=NULL;
	free(pTailles4), pTailles4=NULL;
	char_DestroyFbtAllocator(pAllocCaracs1), pAllocCaracs1=NULL;
	char_DestroyFbtAllocator(pAllocCaracs2), pAllocCaracs2=NULL;
	char_DestroyFbtAllocator(pAllocCaracs3), pAllocCaracs3=NULL;
	char_DestroyFbtAllocator(pAllocCaracs4), pAllocCaracs4=NULL;
	int_DestroyFbtAllocator(pAllocLignes1), pAllocLignes1=NULL;
	int_DestroyFbtAllocator(pAllocLignes2), pAllocLignes2=NULL;
		int_DestroyFbtAllocator(pAllocLignes3), pAllocLignes3=NULL;
	int_DestroyFbtAllocator(pAllocLignes4), pAllocLignes4=NULL;
	return retour;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 int calculerlesRegles1( MotCompact const pcMots1[], MotCompact const pcMots2[],size_t nbmot1,size_t nbmot2, size_t nbmot3,MotCompact const pcMots1fr[])
{
	int retour = -1;
	char nomFich[FILENAME_MAX];
	FILE *pfOut;
 
	if(snprintf(nomFich, ARRAYSIZE(nomFich), "triggers2fr-1en.txt") >= ARRAYSIZE(nomFich))
		return -1;
	pfOut = fopen(nomFich, "w");
	if(pfOut!=NULL)
	{
 
		printf("Calcul du information   mutuelle    conditionnelle pour chaque couple \n");
		DoubleParcoursTable2fr1en(pfOut, pcMots1, pcMots2,nbmot1,nbmot2,nbmot3,pcMots1fr);
		printf("Calcul termine.\n");
		fclose(pfOut);
		retour = 0;
 
	}
 
	else
	{
		perror("Sortie regles");
	}
 
 
	return retour;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void DoubleParcoursTable2fr1en(FILE *pfOut, MotCompact const pcMots1[],MotCompact const pcMots2[],size_t nbmot1,size_t nbmot2,size_t  n,MotCompact const pcMots1fr[])
{
size_t iMot1,iMot2;
 
	for(iMot1=0 ; iMot1<nbmot1 ; iMot1++)
	{
 
		for(iMot2=0 ; iMot2<nbmot2 ; iMot2++)
		{
		    GenererLesRegles2fr1en(pfOut,pcMots1+iMot1,pcMots2+iMot2, pcMots1fr,n);
 
 
		}
	}
	putchar('\n');
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
void GenererLesRegles2fr1en(FILE*pfOut,  MotCompact const *pcLeft, MotCompact const *pcRight,MotCompact const pcMots3[],size_t n)
{
    int sortie=0;
    double imc=0;
    size_t iLigneLeft = 0;
	size_t iLigneRight = 0;
	int const * pcCoordLeft  = ligne_GetPremierC(pcLeft, &iLigneLeft);
	int const * pcCoordRight = ligne_GetPremierC(pcRight, &iLigneRight);
	while(pcCoordLeft!=NULL && (!sortie) && pcCoordRight!=NULL)
	{
		{
			int ligneRight = *pcCoordRight;
			while(pcCoordLeft!=NULL && (*pcCoordLeft)>ligneRight)
				pcCoordLeft = ligne_GetNextC(pcLeft, &iLigneLeft);
		}
		if(pcCoordLeft==NULL)
			break;
		{
			int ligneLeft = *pcCoordLeft;
			while(pcCoordRight!=NULL && (!sortie)&& ligneLeft<(*pcCoordRight))
				pcCoordRight = ligne_GetNextC(pcRight, &iLigneRight);
		}
		if(pcCoordRight==NULL)
			break;
 
		if(*pcCoordLeft == *pcCoordRight)
		{
		    char    const*Left=GetMotCompact(pcLeft);
		    char    const*Right=GetMotCompact(pcRight);
 
		    fprintf(pfOut,"%s",GetMotCompact(pcLeft));
		   fprintf(pfOut,"->");
		    fprintf(pfOut,"%s\n",GetMotCompact(pcRight));
            imc=info_mut_cond(pcLeft,pcRight,pcMots3,n);
            fprintf(pfOut,"IMC   =   ");
		//fprintf(pfOut,"%e  \n",imc);
		sortie=1;
		    pcCoordLeft = ligne_GetNextC(pcLeft, &iLigneLeft);
			pcCoordRight = ligne_GetNextC(pcRight, &iLigneRight);
		}
 
}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
double info_mut_cond(MotCompact const *pc, MotCompact const *pc2,MotCompact const  pcMot[],size_t n)
{
	double IM=0;
	char const * mot = GetMotCompact(pc2);
	char * mot1 = malloc(sizeof (*mot1) * 256);
	char * mot2 = malloc(sizeof (*mot2) * 256);
	double  p1,p2,p3,p4,p5;
	ChainonMot const *m1;
        ChainonMot const *m2;
 
	sscanf(mot, "%s %s", mot1, mot2);
 
	m1= RechercherMotC(m1,n, pcMot);
    m2= RechercherMotC(m2,n,pcMot);
    p1=(NbLignesCommunes(pc,pc2)/((double)596831));
	IM=p1;
	return  IM;
}

02/11/2009, 22h17
étoile de mer

Citation:

Envoyé par Médinoc

A-ton vérifié que toutes les allocations s'étaient bien passées?

Edit: Attends, pourquoi a-t-on m1 à la fois en entrée et en sortie de la fonction? Et d'où vient ce n?

n , c'est la taille de tableau MotCompact pour les 1mot Eng, car on va chercher un mot anglais dans la table de motcompact

Code:

1 2 3 4 5 6 7 ChainonMot const *m1; ChainonMot const *m2; sscanf(mot, "%s %s", mot1, mot2); m1= RechercherMotC(m1,n, pcMot); m2= RechercherMotC(m2,n,pcMot);
Boum! Tu apsses des pointeurs non-initialisés à la fonction de recherche. En clair, t'as rien compris.

02/11/2009, 22h25
étoile de mer
En plus il sont de type MotCompact , c'est pas ChaionMot
Code:

1 2 3 m1= RechercherMotC(mot1,n, pcMot); m2= RechercherMotC(mot2,n,pcMot);
02/11/2009, 22h29
Médinoc

C'est pas beaucoup mieux.
Commence peut-être par de faire une fonction pour chercher dans toute la table de MotCompact, plutôt que dans un seul sous-tableau...
02/11/2009, 22h34
étoile de mer

Citation:

Envoyé par Médinoc

C'est pas beaucoup mieux.
Commence peut-être par de faire une fonction pour chercher dans toute la table de MotCompact, plutôt que dans un seul sous-tableau...

Pourquoi on modifie la fonction , comme ca ca devient plus compliqué non?:roll:
02/11/2009, 22h36
Médinoc

Ben ça serait peut-être bien d'avoir une fonction qui fait ce que tu veux plutôt que n'importe quoi, non?
Et je n'ai jamais parlé de modifier une fonction existante...

Excuse moi, là je bloque

Code:

1
2
3
4
5
6
7
8
9
10
11
12
MotCompact const* RechercherMotC(MotCompact const pcMotsCompacts[], size_t nbMotsCompacts, char const * mot)
{
	/*Attention, bsearch() n'est pas const-correcte:
	  Elle présente les mêmes problèmes que strchr().*/
	return bsearch(
	 mot, /*clé*/
	 pcMotsCompacts, /*adresse du tableau*/
	 nbMotsCompacts, /*nombre d'éléments*/
	 sizeof *pcMotsCompacts, /*taille d'un élément*/
	 MotCompact_bsearch_callback /*fonction de comparaison*/
	 );
}

Cette fonction elle cherche un mot dans une tableau de MotComapct entier non?

02/11/2009, 22h49
Médinoc

N'oublie pas que c'est un tableau de tableaux qu'on a, puisqu'on utilise le hachage!
02/11/2009, 22h50
étoile de mer

aussi je ois à l'aide du debugger :
RechercherMotCompactC(pcMotsCompact=0*8a94c58, nbMotsCompact=12, mot=0*8a942d8 "\001" )
c'est quoi ce 001?!!
02/11/2009, 22h56
étoile de mer

Citation:

Envoyé par Médinoc

N'oublie pas que c'est un tableau de tableaux qu'on a, puisqu'on utilise le hachage!

Oula, c'est un peu costaud par rapport à mon niveau :aie:
02/11/2009, 22h58
Médinoc

En clair: Tu te fais une fonction qui prend en paramètre le tableau de structures TableauMotsCompacts et une chaîne, qui appelle la fonction de hachage dessus pour avoir un index et qui se sert de cet index pour appeler RechercherMot sur le bon tableau...

Voir 40 message(s) de cette discussion en une page