/**
* \fn double Timepass( int *t, int size, void fonction( int *t, int size ) )
* \author Sylvain De baros
* \brief Cherche l'indice ou se truve la taille du tableau
* \param[in, out] t Tableau à trier
* \param[in] size Taille du tableau
* \param[in] fonction Fonction de tri à éxécuter
* \return Temps de l'éxécution
**/
double Timepass( int *t, int size, void fonction( int *t, int size ) ) {
double time;
clock_t beginning, end;
beginning = clock();
fonction(t, size);
end = clock();
return time = (double) (end - beginning) / CLOCKS_PER_SEC;
}
void tableauDynamiqueAppliqueATous(TableauDynamique tab, void(*fonction)(void * elementTableau, void * option), void * option)
{
int i;
for (i = 0; i < tab->nombre; i++)
{
fonction(tab->liste[i], option);
}
}
int main ()
{
int x,y;
x=1;
y=-1;
fonction(&x,&y);
printf("La valeur de x et y est %d et %d",x,y);
return 0;
}
void* thread(void* arg)
{
int *p;
p=(int*)malloc(sizeof(int));
(*p)=(int)arg;
pthread_setspecific(key,(void*)p);
fonction();
printf("%d:this is thread--value %d\n",(int)pthread_self(),*p);
free(p);
pthread_exit(0);
}
int fonction (int x)
{
int x1;
char chaine[128];
fprintf(stdout, "& x = %p lg = %d\n", & x, sizeof(x));
fprintf(stdout, "& x1 = %p lg = %d\n", & x1, sizeof(x1));
fprintf(stdout, "chaine = %p lg = %d\n", chaine, sizeof(chaine));
if (x > 0)
return fonction(x - 1);
return EXIT_SUCCESS;
}
void
vext_iterer(vext self, void (*fonction)(void *))
{
unsigned int i = 0;
unsigned int n = self->nombre_d_elements;
void **v = self->vecteur;
while (i < n)
{
fonction(v[i]);
i++;
}
}
double eval(double a, int id)
{
double temp = a;
double(*fonction) (double); /*l'utilisation d'un pointeur de fonction est*/
if(id !=0) /*interresante pour un tel cas */
{
switch (id)
{
case 1 : fonction = sin ;
break;
case 2 : fonction = cos ;
break;
case 3 : fonction = log10 ;
break;
case 4 : fonction = exp ;
break;
}
temp = fonction(a);
}
return temp;
}
int main(){
fonction();
return 0;
}
int main (void)
{
return fonction(1);
}
void Choix_cysteines()
{
// = 1 ===================== on entre les noms des fichiers
string nom_base_pos;
cout << "Veuillez entrer les noms des fichiers de pfa,\n";
cout << "de l'echantillon positif associÈ,\n";
cout << "de l'Èchantillon nÈgatif associÈ,\n";
cout << "et enfin le nom de l'Èchantillon test associÈ.\n\n";
cout << "Finissez en entrant le nom ." << endl;
;
map < int, PPRFA > Modele;
map < int, Sample > PosSample;
map < int, Sample > NegSample;
map < int, Sample > TestSample;
string nom;
Sample S;
PPRFA A;
cout << "Nom du fichier pfa : ";
cin >> nom;
int i;
i = -1;
while (nom != ".")
{
++i;
A.load (nom);
Modele[i] = A;
cout << "Èchantillon positif associe : ";
cin >> nom;
S.load (nom);
PosSample[i] = S;
cout << "Èchantillon negatif associe : ";
cin >> nom;
S.load (nom);
NegSample[i] = S;
cout << "Èchantillon test associe : ";
cin >> nom;
S.load (nom);
TestSample[i] = S;
cout << "\nNom du fichier pfa : ";
cin >> nom;
}
// = 2 =============== on calcule les moyennes et ecart-types
map < int, float >moyenne_pos;
map < int, float >ecartype_pos;
map < int, float >moyenne_neg;
map < int, float >ecartype_neg;
Dictionnaire dico;
map < int, float >probabilite_pos;
map < int, float >probabilite_neg;
map < int, float >::const_iterator prob_it;
map < int, float >decalage_pos;
map < int, float >decalage_neg;
Sample::const_iterator w;
int j;
float min;
float val;
for (i = 0; i < (int) Modele.size (); ++i)
{ // pour tous les modËles
Modele[i].lisse();
// 1a - on calcule la probabilite minimale les mots positifs
dico = PosSample[i].dictionnaire ();
j=0;
min = 1;
for (w = PosSample[i].begin ();
w != PosSample[i].end (); ++w)
{
probabilite_pos[j] = Modele[i].plog (w->first, &dico);
if (probabilite_pos[j] < min)
min = probabilite_pos[j];
++j;
}
decalage_pos[i] = min;
// 1b - on calcule la probabilite minimale les mots negatifs
dico = NegSample[i].dictionnaire ();
j=0;
min = 1;
for (w = NegSample[i].begin (); w != NegSample[i].end (); ++w)
{
probabilite_neg[j] = Modele[i].plog (w->first, &dico);
if (probabilite_neg[j] < min)
min = probabilite_neg[j];
++j;
}
decalage_neg[i]= min;
if (decalage_neg[i]<decalage_pos[i])
decalage_pos[i]=decalage_neg[i];
else
decalage_neg[i]=decalage_pos[i];
// --- on a calcule le decalage ---
// 2 - on calcule la moyenne pour les mots positifs
moyenne_pos[i] = 0;
for (prob_it = probabilite_pos.begin() ;
prob_it != probabilite_pos.end(); ++prob_it)
{
moyenne_pos[i] += exp (prob_it->second - decalage_pos[i]);
}
moyenne_pos[i] /= PosSample[i].size();
// 3 - on calcule l'ecartype pour les mots positifs
ecartype_pos[i] = 0;
for (prob_it = probabilite_pos.begin() ;
prob_it != probabilite_pos.end() ; ++prob_it)
{
ecartype_pos[i] +=
pow (moyenne_pos[i] - exp (prob_it->second - decalage_pos[i]), 2);
}
ecartype_pos[i] /= PosSample[i].size();
ecartype_pos[i] = sqrt(ecartype_pos[i]);
// Maintenant, moyenne_pos[i] contient la valeur moyenne de la probabilite
// des mots positifs et ecartype_pos[i] contient l'ecart-type des mots pos.
// puis pareil pour les nÈgatifs
// 2 - on calcule la moyenne
moyenne_neg[i] = 0;
for (prob_it = probabilite_neg.begin() ;
prob_it != probabilite_neg.end(); ++prob_it)
{
moyenne_neg[i] += exp (prob_it->second - decalage_neg[i]);
}
moyenne_neg[i] /= NegSample[i].size();
// 3 - on calcule l'ecartype pour les mots positifs
ecartype_neg[i] = 0;
for (prob_it = probabilite_neg.begin() ;
prob_it != probabilite_neg.end() ; ++prob_it)
{
ecartype_neg[i] +=
pow (moyenne_neg[i] - exp (prob_it->second - decalage_neg[i]), 2);
}
ecartype_neg[i] /= NegSample[i].size();
ecartype_neg[i] = sqrt( ecartype_neg[i] );
// on a fini de calculer les moyennes et les ecartype pour le modele i
cout << "µ pos : " << moyenne_pos[i];
cout << ", sigma pos : " << ecartype_pos[i];
cout << ", decalage pos : " << decalage_pos[i] << "\n";
cout << "µ neg : " << moyenne_neg[i];
cout << ", sigma neg : " << ecartype_neg[i];
cout << ", decalage neg : " << decalage_neg[i] << endl;
}
// = 3 ==================================== evaluation
double p1, p2;
bool res;
map < int, float >probapos;
Word u;
res = 0;
i = 0;
for (i = 0; i < (int) Modele.size (); ++i)
{
u = TestSample[i].begin ()->first;
dico = TestSample[i].dictionnaire ();
val = Modele[i].plog (u, &dico);
cout << "val = " << exp( val - decalage_pos[i] ) << endl;
if (moyenne_pos[i] > moyenne_neg[i])
{
p1 = fonction (exp (val - decalage_pos[i]), moyenne_pos[i], ecartype_pos[i]); // ECRIRE fonction
p2 = fonction (moyenne_neg[i], exp (val - decalage_neg[i]) , ecartype_neg[i]); // !!!!!!!!!!!!!!!
}
else
{
p1 = fonction (moyenne_pos[i], exp (val - decalage_pos[i]), ecartype_pos[i]); // ECRIRE fonction
p2 = fonction (exp (val - decalage_neg[i]), moyenne_neg[i] , ecartype_neg[i]); // !!!!!!!!!!!!!!!
}
cout << "p_pos = " << p1;
cout << ", p_neg = " << p2;
probapos[i] = (p1 + (1 - p2)) / 2; // ???????
cout << ", probapos = " << probapos[i] << endl;
}
float probaposgenerale=0;
for (i=0 ; i< (int) probapos.size() ; ++i)
probaposgenerale += probapos[i];
probaposgenerale /= i;
cout << "probabilite d'etre positif = " << probaposgenerale << endl;
}
