Discussion :

[Naneba]

Bonjour a tous,
Je dois réaliser des tirages dans des lois de probabilités (par exemple loi normale). J'utilise la library boost.

Cependant le code tourne rapidement (< 1 seconde).

Mon code pour le moment:

Code :

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

1
2
3
4
5
6
7
8
9
 
double rnorm(double moy, double e_type)
{
  boost::mt19937 rng(static_cast<long unsigned int>(std::time(0)));
  boost::normal_distribution<double>  nd(moy, e_type);
  boost::variate_generator<boost::mt19937&,
                           boost::normal_distribution<double> > var_nor(rng, nd);
  return var_nor();
}

Le problème est qu'en utilisant (std::time(0)) l'aléa n'intervient que toutes les secondes, or je voudrais qu'il soit plus rapide...

Une idée??

Merci merci,
Nane

[Ehonn]

Bonjour

Ne créer qu'un seul moteur, une seule distribution et un seul générateur par thread.

Tu as plusieurs solutions (plus ou moins propre), il est assez courant de faire des variables static d'une fonction ou d'une classe voire des variables plus ou moins globales.

[Naneba]

Bonjour Ehonn,
Merci pour ta réponse,

Mais j'aurais besoin d'un peu plus de lumière.... je suis débutante et je ne comprends pas bien ce que tu as voulu dire...

il est assez courant de faire des variables static d'une fonction

Je te remercie,
Nane

[Ehonn]

Lecture de la FAQ:
FAQ C++ - Les classes en C++ - Les données et fonctions membres statiques

C'est la même chose pour la fonction. Dans cet exemple, la variable static i de la fonction fct ne sera déclaré qu'un seul fois dans le programme et sera réutilisable.

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
// g++ -Wall -Wextra -std=c++11 -pedantic main.cpp -o main && ./main
// g++ -Wall -Wextra -pedantic main.cpp -o main && ./main
 
#include <iostream>
 
void fct()
{
	static unsigned int i = 0;
 
	std::cout << i++ << std::endl;
}
 
int main()
{
	fct();
	fct();
	fct();
	fct();
	fct();
 
	return 0;
}

Voici le résultat

Code :

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

1
2
3
4
5
6
$ g++ -Wall -Wextra -std=c++11 -pedantic main.cpp -o main && ./main
0
1
2
3
4

[Naneba]

Mais en utilisant

Code :

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

1
2
boost::mt19937 rng(static_cast<long unsigned int>(std::time(0)));

le générateur n'est crée qu'une seule fois...
il me semble que le problème vient de

Code :

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

std::time(0)

qui ne change pas assez vite...

[Davidbrcz]

Ya un truc que tu ne comprends pas.

Tu as un générateur de nombre pseudo aléatoire et meme un Mersenne Twister dans ton cas. Ce dernier doit être initialisé avec une graine.

Comme le générateur est juste pseudo-aléatoire, si on utilisait une même graine dune exécution a l'autre, on aurait la même séquence de nombre aléatoire. Pas très glop.

Pour éviter ca, on utilise le temps au moment de la création de l'objet qui est globalement unique dune exécution a l'autre.

Toujours est il que la ligne (prise de ton post sur le Sdz)

Code :

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

static boost::mt19937 rng(static_cast<long unsigned int>(std::time(0)));

n'est exécutée qu'une seule fois Dire que std::time(0) ne change pas assez vite ne veut rien dire puisqu'il n'on ne l'appelle qu'une SEULE ET UNIQUE FOIS

Edit. En cas de thread, les variables sont partagées. Mais si tu utilises des threads, il faut le dire

[Naneba]

Effectivement je n'ai pas tout compris ...

Pour éviter ca, on utilise le temps au moment de la création de l'objet.
qui est globalement unique dune exécution a l'autre.

Le problème est la : lorsque je demande deux exécutions successives (en l'espace d'une seconde), les résultats sont les mêmes ...

Voila mon code:

Code :

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

1
2
3
4
5
6
7
8
9
 
void afficher(double a) {
  cout << "sortie: " << a << endl;
}
 
int main()
{
  afficher(rnorm(6, 3));
}

[Davidbrcz]

Actuellement, tu fais 100 exécutions du même programme qui chacun va appeler la fonction rnorm. Donc tu construits effectivement 100 générateurs tous initialisés avec le temps courant. Mais vu que la granularité est au niveau de la seconde, ba ca coince si plusieurs exécutions se déroulent en mois d'une seconde et tu as les mêmes valeurs

A la place, essaye d'exécuter une seule fois le programme (et donc ne construire qu'un seul générateur !) et utilise une boucle pour appeler 100 fois la fonction rnorm.

Ceci devrait marcher

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
 
double rnorm(double moy, double e_type)
{
  static boost::mt19937 rng(static_cast<long unsigned int>(std::time(0)));
  boost::normal_distribution<double>  nd(moy, e_type);
  boost::variate_generator<boost::mt19937&,
                           boost::normal_distribution<double> > var_nor(rng, nd);
  return var_nor();
}
 
void afficher(double a) {
  cout << "sortie: " << a << endl;
}
 
int main()
{
for(int i=0;i<100;++i)
  afficher(rnorm(6, 3));
}

[Naneba]

Je crois que j'y vois un peu plus clair maintenant .


Merci merci merci