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

**Médinoc** · 02/11/2009, 17h25

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

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

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

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 C :

Sélectionner tout - Visualiser dans une fenêtre à part

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*/
	 );
}

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

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

**étoile de mer** · 02/11/2009, 17h42

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

TrierMotsCompacts(pRet, nbmots);

faut pas mette nbmots, mais autre chose ...

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

Ah oui, peut etre faut mettre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

	TrierMotsCompacts(pRet, nTab);

**Médinoc** · 02/11/2009, 18h15

Non, il faut mettre ceci:

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

				TrierMotsCompacts(pRet[iHash].pMotsCompacts, pRet[iHash].nbMotsCompacts);

**étoile de mer** · 02/11/2009, 18h17

Ok, merci

Maintenant je passe à la génération des regles, j'espere que soit optimisé de cette façon

**étoile de mer** · 02/11/2009, 22h04

Bonsoir,
j'ai une erreur de segmentation

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
char const *GetMotCompact(MotCompact const *This)
{
	assert(This!=NULL);
	return This->sczMot;
}

le compilateur stoppe à ce niveau :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
	m1= RechercherMotC(m1,n, pcMot);

Une idée svp?
merci

**Médinoc** · 02/11/2009, 22h10

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?

**étoile de mer** · 02/11/2009, 22h14

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}

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

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

**Médinoc** · 02/11/2009, 22h19

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

**étoile de mer** · 02/11/2009, 22h25

En plus il sont de type MotCompact , c'est pas ChaionMot

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
	m1= RechercherMotC(mot1,n, pcMot);
    m2= RechercherMotC(mot2,n,pcMot);

**Médinoc** · 02/11/2009, 22h29

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...

**étoile de mer** · 02/11/2009, 22h34

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?

**Médinoc** · 02/11/2009, 22h36

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...

**étoile de mer** · 02/11/2009, 22h41

Excuse moi, là je bloque

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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?

**Médinoc** · 02/11/2009, 22h49

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

**étoile de mer** · 02/11/2009, 22h50

aussi je ois à l'aide du debugger :
RechercherMotCompactC(pcMotsCompact=0*8a94c58, nbMotsCompact=12, mot=0*8a942d8 "\001" )
c'est quoi ce 001?!!

**étoile de mer** · 02/11/2009, 22h56

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

**Médinoc** · 02/11/2009, 22h58

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...

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

C

Discussions similaires

Partager

Partager