Générateur de nombres aléatoires

**oxygar** · 25/03/2012, 19h33

Bonjours, je travaille sur un programme qui a besoin de générer aléatoirement plusieurs nombres rapidement (plus d'une fois par seconde).
Avant j'utilisait ce bout de code

Code :

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

1
2
3
4
5
6
7
8
9
10
 
#include <ctime>
 
int Random(int a, int b)
{
	int nombre_aleatoire = 0;
	srand(time(NULL));
	nombre_aleatoire = rand();
		return rand()%(b-a) +a;
	}

Cependant il est basé sur l'horloge interne et cela ne suffit pas pour ce projet. Comment générer de nombreux nombres par seconde?

Merci d'avance

**Jean-Marc.Bourguet** · 25/03/2012, 19h51

srand se fait une fois par execution du programme, pas par nombre généré.

**oxygar** · 25/03/2012, 19h52

Encore pire alors... Comment avoir un bon générateur?

**pyros** · 26/03/2012, 09h13

Salut,

Ce que Jean-Marc.Bourguet veut dire, c'est que tu doit appeler srand(time(NULL)); seulement au début du programme. Après, rand(); te renverra une suite de valeur pseudo-aléatoire. Si tu n'execute pas ton programme plus d'une fois par seconde, ça marchera

.

**Bousk** · 26/03/2012, 09h24

Bonjour,

si tu ne souhaites modifier que ta fonction Random, tu peux tricher en y ajoutant une variable static qui définira ou non si le rand a déjà été seedé/initialisé ou non.

**Ehonn** · 26/03/2012, 09h54

Voici un petit "programme" qui génére des séries de 300 000 000 nombres pseudo aléatoire avec C++11 et Boost et son log (pour le temps) (compilé avec g++ 4.6)

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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
// g++ -Wall -Wextra -std=c++0x -O3 -lboost_random-mt -lboost_date_time-mt random_with_boost.cpp -o random_with_boost
 
#include <iostream>
#include <string>
#include <cstdlib>
#include <ctime>
 
#include <boost/date_time.hpp>
#include <boost/random.hpp>
 
 
int main()
{
	// Numbers of iterations (generate)
	unsigned int const NB_ITERATIONS = 300*1000*1000;
	// Number of runs
	unsigned int const NB_RUNS = 10;
 
	std::cout << "Numbers of iterations (generate) = " << NB_ITERATIONS << "\n" << std::endl;
 
	std::cout << "std way with generator: " << std::endl;
	for (unsigned int i = 0 ; i < NB_RUNS; ++i)
	{
		// Distibution
		std::uniform_int_distribution<int> distribution(0, 99);
		// Mersenne twister MT19937
		std::mt19937 engine;
 
		// Generator
		auto generator = std::bind(distribution, engine);
 
		// Benchmark starts
		boost::posix_time::ptime t0 = boost::posix_time::microsec_clock::local_time();
 
		// Generate !
		for (unsigned int j = 0; j < NB_ITERATIONS; ++j)
		{
			// Generate a uniform integral variate between 0 and 99
			generator();
		}
 
		// Benchmark ends
		boost::posix_time::ptime t1 = boost::posix_time::microsec_clock::local_time();
		boost::posix_time::time_duration time = boost::posix_time::time_period(t0, t1).length();
		std::cout << "\t" << time << " => " << (static_cast<double>(time.hours()*60*60*1000*1000+time.minutes()*60*1000*1000+time.seconds()*1000*1000+time.fractional_seconds()) / NB_ITERATIONS) << " fractional seconds per number" << std::endl;
	}
	std::cout << std::endl;
 
	std::cout << "std way using the distribution and the engine objects: " << std::endl;
	for (unsigned int i = 0 ; i < NB_RUNS; ++i)
	{
		// Distibution
		std::uniform_int_distribution<int> distribution(0, 99);
		// Mersenne twister MT19937
		std::mt19937 engine;
 
		// Benchmark starts
		boost::posix_time::ptime t0 = boost::posix_time::microsec_clock::local_time();
 
		// Generate !
		for (unsigned int j = 0; j < NB_ITERATIONS; ++j)
		{
			// Generate another sample directly using the distribution and the engine objects
			distribution(engine);
		}
 
		// Benchmark ends
		boost::posix_time::ptime t1 = boost::posix_time::microsec_clock::local_time();
		boost::posix_time::time_duration time = boost::posix_time::time_period(t0, t1).length();
		std::cout << "\t" << time << " => " << (static_cast<double>(time.hours()*60*60*1000*1000+time.minutes()*60*1000*1000+time.seconds()*1000*1000+time.fractional_seconds()) / NB_ITERATIONS) << " fractional seconds per number" << std::endl;
	}
	std::cout << std::endl;
 
	std::cout << "Boost mt19937 using the distribution and the engine objects: " << std::endl;
	std::cout << "(good uniform distribution in up to 623 dimensions) " << std::endl;
	for (unsigned int i = 0 ; i < NB_RUNS; ++i)
	{
		// Distibution
		boost::random::uniform_int_distribution<int> distribution(0, 99);
		// Mersenne twister MT19937
		boost::random::mt19937 engine;
 
		// Benchmark starts
		boost::posix_time::ptime t0 = boost::posix_time::microsec_clock::local_time();
 
		// Generate !
		for (unsigned int j = 0; j < NB_ITERATIONS; ++j)
		{
			// Generate another sample directly using the distribution and the engine objects
			distribution(engine);
		}
 
		// Benchmark ends
		boost::posix_time::ptime t1 = boost::posix_time::microsec_clock::local_time();
		boost::posix_time::time_duration time = boost::posix_time::time_period(t0, t1).length();
		std::cout << "\t" << time << " => " << (static_cast<double>(time.hours()*60*60*1000*1000+time.minutes()*60*1000*1000+time.seconds()*1000*1000+time.fractional_seconds()) / NB_ITERATIONS) << " fractional seconds per number" << std::endl;
	}
	std::cout << std::endl;
 
	std::cout << "Boost mt19937_64 using the distribution and the engine objects: " << std::endl;
	std::cout << "(good uniform distribution in up to 311 dimensions) " << std::endl;
	for (unsigned int i = 0 ; i < NB_RUNS; ++i)
	{
		// Distibution
		boost::random::uniform_int_distribution<int> distribution(0, 99);
		// Mersenne twister MT19937
		boost::random::mt19937_64 engine;
 
		// Benchmark starts
		boost::posix_time::ptime t0 = boost::posix_time::microsec_clock::local_time();
 
		// Generate !
		for (unsigned int j = 0; j < NB_ITERATIONS; ++j)
		{
			// Generate another sample directly using the distribution and the engine objects
			distribution(engine);
		}
 
		// Benchmark ends
		boost::posix_time::ptime t1 = boost::posix_time::microsec_clock::local_time();
		boost::posix_time::time_duration time = boost::posix_time::time_period(t0, t1).length();
		std::cout << "\t" << time << " => " << (static_cast<double>(time.hours()*60*60*1000*1000+time.minutes()*60*1000*1000+time.seconds()*1000*1000+time.fractional_seconds()) / NB_ITERATIONS) << " fractional seconds per number" << std::endl;
	}
	std::cout << std::endl;
 
	std::cout << "Boost mt11213b using the distribution and the engine objects: " << std::endl;
	std::cout << "(good uniform distribution in up to 350 dimensions) " << std::endl;
	for (unsigned int i = 0 ; i < NB_RUNS; ++i)
	{
		// Distibution
		boost::random::uniform_int_distribution<int> distribution(0, 99);
		// mt11213b
		boost::random::mt11213b engine;
 
		// Benchmark starts
		boost::posix_time::ptime t0 = boost::posix_time::microsec_clock::local_time();
 
		// Generate !
		for (unsigned int j = 0; j < NB_ITERATIONS; ++j)
		{
			// Generate another sample directly using the distribution and the engine objects
			distribution(engine);
		}
 
		// Benchmark ends
		boost::posix_time::ptime t1 = boost::posix_time::microsec_clock::local_time();
		boost::posix_time::time_duration time = boost::posix_time::time_period(t0, t1).length();
		std::cout << "\t" << time << " => " << (static_cast<double>(time.hours()*60*60*1000*1000+time.minutes()*60*1000*1000+time.seconds()*1000*1000+time.fractional_seconds()) / NB_ITERATIONS) << " fractional seconds per number" << std::endl;
	}
	std::cout << std::endl;
 
	std::cout << "Boost taus88 using the distribution and the engine objects: " << std::endl;
	for (unsigned int i = 0 ; i < NB_RUNS; ++i)
	{
		// Distibution
		boost::random::uniform_int_distribution<int> distribution(0, 99);
		// taus88
		boost::random::taus88 engine;
 
		// Benchmark starts
		boost::posix_time::ptime t0 = boost::posix_time::microsec_clock::local_time();
 
		// Generate !
		for (unsigned int j = 0; j < NB_ITERATIONS; ++j)
		{
			// Generate another sample directly using the distribution and the engine objects
			distribution(engine);
		}
 
		// Benchmark ends
		boost::posix_time::ptime t1 = boost::posix_time::microsec_clock::local_time();
		boost::posix_time::time_duration time = boost::posix_time::time_period(t0, t1).length();
		std::cout << "\t" << time << " => " << (static_cast<double>(time.hours()*60*60*1000*1000+time.minutes()*60*1000*1000+time.seconds()*1000*1000+time.fractional_seconds()) / NB_ITERATIONS) << " fractional seconds per number" << std::endl;
	}
	std::cout << std::endl;
 
	std::cout << "Boost hellekalek1995 using the distribution and the engine objects: " << std::endl;
	std::cout << "(good uniform distribution in several dimensions) " << std::endl;
	for (unsigned int i = 0 ; i < NB_RUNS; ++i)
	{
		// Distibution
		boost::random::uniform_int_distribution<int> distribution(0, 99);
		// Mersenne twister MT19937
		boost::random::hellekalek1995 engine;
 
		// Benchmark starts
		boost::posix_time::ptime t0 = boost::posix_time::microsec_clock::local_time();
 
		// Generate !
		for (unsigned int j = 0; j < NB_ITERATIONS; ++j)
		{
			// Generate another sample directly using the distribution and the engine objects
			distribution(engine);
		}
 
		// Benchmark ends
		boost::posix_time::ptime t1 = boost::posix_time::microsec_clock::local_time();
		boost::posix_time::time_duration time = boost::posix_time::time_period(t0, t1).length();
		std::cout << "\t" << time << " => " << (static_cast<double>(time.hours()*60*60*1000*1000+time.minutes()*60*1000*1000+time.seconds()*1000*1000+time.fractional_seconds()) / NB_ITERATIONS) << " fractional seconds per number" << std::endl;
	}
	std::cout << std::endl;
 
	std::cout << "Boost rand48 using the distribution and the engine objects: " << std::endl;
	for (unsigned int i = 0 ; i < NB_RUNS; ++i)
	{
		// Distibution
		boost::random::uniform_int_distribution<int> distribution(0, 99);
		// Mersenne twister MT19937
		boost::random::rand48 engine;
 
		// Benchmark starts
		boost::posix_time::ptime t0 = boost::posix_time::microsec_clock::local_time();
 
		// Generate !
		for (unsigned int j = 0; j < NB_ITERATIONS; ++j)
		{
			// Generate another sample directly using the distribution and the engine objects
			distribution(engine);
		}
 
		// Benchmark ends
		boost::posix_time::ptime t1 = boost::posix_time::microsec_clock::local_time();
		boost::posix_time::time_duration time = boost::posix_time::time_period(t0, t1).length();
		std::cout << "\t" << time << " => " << (static_cast<double>(time.hours()*60*60*1000*1000+time.minutes()*60*1000*1000+time.seconds()*1000*1000+time.fractional_seconds()) / NB_ITERATIONS) << " fractional seconds per number" << std::endl;
	}
	std::cout << std::endl;
 
	std::cout << "rand() C (not uniform)" << std::endl;
	for (unsigned int i = 0 ; i < NB_RUNS; ++i)
	{
		// Init seed
		srand(time(0));
 
		// Benchmark starts
		boost::posix_time::ptime t0 = boost::posix_time::microsec_clock::local_time();
 
		// Generate !
		for (unsigned int j = 0; j < NB_ITERATIONS; ++j)
		{
			rand();
		}
 
		// Benchmark ends
		boost::posix_time::ptime t1 = boost::posix_time::microsec_clock::local_time();
		boost::posix_time::time_duration time = boost::posix_time::time_period(t0, t1).length();
		std::cout << "\t" << time << " => " << (static_cast<double>(time.hours()*60*60*1000*1000+time.minutes()*60*1000*1000+time.seconds()*1000*1000+time.fractional_seconds()) / NB_ITERATIONS) << " fractional seconds per number" << std::endl;
	}
	std::cout << std::endl;
 
	std::cout << "rand() C (uniform)" << std::endl;
	for (unsigned int i = 0 ; i < NB_RUNS; ++i)
	{
		// Init seed
		srand(time(0));
 
		// Benchmark starts
		boost::posix_time::ptime t0 = boost::posix_time::microsec_clock::local_time();
 
		// Generate !
		for (unsigned int j = 0; j < NB_ITERATIONS; ++j)
		{
			rand() / static_cast<int>(((unsigned int)RAND_MAX + 1) / 100);
		}
 
		// Benchmark ends
		boost::posix_time::ptime t1 = boost::posix_time::microsec_clock::local_time();
		boost::posix_time::time_duration time = boost::posix_time::time_period(t0, t1).length();
		std::cout << "\t" << time << " => " << (static_cast<double>(time.hours()*60*60*1000*1000+time.minutes()*60*1000*1000+time.seconds()*1000*1000+time.fractional_seconds()) / NB_ITERATIONS) << " fractional seconds per number" << std::endl;
	}
	std::cout << std::endl;
 
	return 0;
}

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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
$ ./random_with_boost 
Numbers of iterations (generate) = 300000000
 
std way with generator: 
        00:00:12.235693 => 0.0407856 fractional seconds per number
        00:00:12.229781 => 0.0407659 fractional seconds per number
        00:00:12.237954 => 0.0407932 fractional seconds per number
        00:00:12.236913 => 0.0407897 fractional seconds per number
        00:00:12.209662 => 0.0406989 fractional seconds per number
        00:00:12.218766 => 0.0407292 fractional seconds per number
        00:00:12.221103 => 0.040737 fractional seconds per number
        00:00:12.209020 => 0.0406967 fractional seconds per number
        00:00:12.227114 => 0.040757 fractional seconds per number
        00:00:12.230510 => 0.0407684 fractional seconds per number
 
std way using the distribution and the engine objects: 
        00:00:12.236971 => 0.0407899 fractional seconds per number
        00:00:12.240194 => 0.0408006 fractional seconds per number
        00:00:12.236063 => 0.0407869 fractional seconds per number
        00:00:12.257284 => 0.0408576 fractional seconds per number
        00:00:12.312273 => 0.0410409 fractional seconds per number
        00:00:12.238539 => 0.0407951 fractional seconds per number
        00:00:12.233851 => 0.0407795 fractional seconds per number
        00:00:12.231100 => 0.0407703 fractional seconds per number
        00:00:12.246313 => 0.040821 fractional seconds per number
        00:00:12.238724 => 0.0407957 fractional seconds per number
 
Boost mt19937 using the distribution and the engine objects: 
(good uniform distribution in up to 623 dimensions) 
        00:00:02.099571 => 0.00699857 fractional seconds per number
        00:00:02.097383 => 0.00699128 fractional seconds per number
        00:00:02.096195 => 0.00698732 fractional seconds per number
        00:00:02.097780 => 0.0069926 fractional seconds per number
        00:00:02.093299 => 0.00697766 fractional seconds per number
        00:00:02.093257 => 0.00697752 fractional seconds per number
        00:00:02.099024 => 0.00699675 fractional seconds per number
        00:00:02.095079 => 0.0069836 fractional seconds per number
        00:00:02.096816 => 0.00698939 fractional seconds per number
        00:00:02.095166 => 0.00698389 fractional seconds per number
 
Boost mt19937_64 using the distribution and the engine objects:                                                                                             
(good uniform distribution in up to 311 dimensions)                                                                                                         
        00:00:12.899464 => 0.0429982 fractional seconds per number                                                                                          
        00:00:12.897733 => 0.0429924 fractional seconds per number                                                                                          
        00:00:12.904572 => 0.0430152 fractional seconds per number                                                                                          
        00:00:12.995296 => 0.0433177 fractional seconds per number                                                                                          
        00:00:12.911522 => 0.0430384 fractional seconds per number                                                                                          
        00:00:12.913597 => 0.0430453 fractional seconds per number                                                                                          
        00:00:12.909714 => 0.0430324 fractional seconds per number                                                                                          
        00:00:12.924398 => 0.0430813 fractional seconds per number                                                                                          
        00:00:12.922247 => 0.0430742 fractional seconds per number                                                                                          
        00:00:12.921794 => 0.0430726 fractional seconds per number                                                                                          
 
Boost mt11213b using the distribution and the engine objects:                                                                                               
(good uniform distribution in up to 350 dimensions)                                                                                                         
        00:00:02.045992 => 0.00681997 fractional seconds per number                                                                                         
        00:00:02.040450 => 0.0068015 fractional seconds per number                                                                                          
        00:00:02.038793 => 0.00679598 fractional seconds per number                                                                                         
        00:00:02.041030 => 0.00680343 fractional seconds per number                                                                                         
        00:00:02.037519 => 0.00679173 fractional seconds per number                                                                                         
        00:00:02.035079 => 0.0067836 fractional seconds per number                                                                                          
        00:00:02.038874 => 0.00679625 fractional seconds per number                                                                                         
        00:00:02.037677 => 0.00679226 fractional seconds per number                                                                                         
        00:00:02.037807 => 0.00679269 fractional seconds per number                                                                                         
        00:00:02.038259 => 0.0067942 fractional seconds per number                                                                                          
 
Boost taus88 using the distribution and the engine objects:                                                                                                 
        00:00:01.423849 => 0.00474616 fractional seconds per number                                                                                         
        00:00:01.427411 => 0.00475804 fractional seconds per number                                                                                         
        00:00:01.427113 => 0.00475704 fractional seconds per number                                                                                         
        00:00:01.429120 => 0.00476373 fractional seconds per number                                                                                         
        00:00:01.427980 => 0.00475993 fractional seconds per number                                                                                         
        00:00:01.428401 => 0.00476134 fractional seconds per number                                                                                         
        00:00:01.430246 => 0.00476749 fractional seconds per number                                                                                         
        00:00:01.426620 => 0.0047554 fractional seconds per number                                                                                          
        00:00:01.431298 => 0.00477099 fractional seconds per number                                                                                         
        00:00:01.430916 => 0.00476972 fractional seconds per number                                                                                         
 
Boost hellekalek1995 using the distribution and the engine objects:                                                                                         
(good uniform distribution in several dimensions)                                                                                                           
        00:01:09.428275 => 0.231428 fractional seconds per number                                                                                           
        00:01:09.578160 => 0.231927 fractional seconds per number                                                                                           
        00:01:09.408205 => 0.231361 fractional seconds per number                                                                                           
        00:01:09.439403 => 0.231465 fractional seconds per number                                                                                           
        00:01:09.361174 => 0.231204 fractional seconds per number                                                                                           
        00:01:09.334417 => 0.231115 fractional seconds per number                                                                                           
        00:01:09.359006 => 0.231197 fractional seconds per number                                                                                           
        00:01:09.487160 => 0.231624 fractional seconds per number                                                                                           
        00:01:09.389659 => 0.231299 fractional seconds per number                                                                                           
        00:01:09.339894 => 0.231133 fractional seconds per number                                                                                           
 
Boost rand48 using the distribution and the engine objects: 
        00:00:01.692610 => 0.00564203 fractional seconds per number
        00:00:01.691292 => 0.00563764 fractional seconds per number
        00:00:01.693223 => 0.00564408 fractional seconds per number
        00:00:01.692846 => 0.00564282 fractional seconds per number
        00:00:01.692767 => 0.00564256 fractional seconds per number
        00:00:01.694532 => 0.00564844 fractional seconds per number
        00:00:01.691050 => 0.00563683 fractional seconds per number
        00:00:01.693428 => 0.00564476 fractional seconds per number
        00:00:01.689255 => 0.00563085 fractional seconds per number
        00:00:01.693609 => 0.00564536 fractional seconds per number
 
rand() C (not uniform)
        00:00:04.205507 => 0.0140184 fractional seconds per number
        00:00:04.209344 => 0.0140311 fractional seconds per number
        00:00:04.218483 => 0.0140616 fractional seconds per number
        00:00:04.215717 => 0.0140524 fractional seconds per number
        00:00:04.218569 => 0.0140619 fractional seconds per number
        00:00:04.214491 => 0.0140483 fractional seconds per number
        00:00:04.209880 => 0.0140329 fractional seconds per number
        00:00:04.208638 => 0.0140288 fractional seconds per number
        00:00:04.208381 => 0.0140279 fractional seconds per number
        00:00:04.217976 => 0.0140599 fractional seconds per number
 
rand() C (uniform)
        00:00:04.208446 => 0.0140282 fractional seconds per number
        00:00:04.211523 => 0.0140384 fractional seconds per number
        00:00:04.213089 => 0.0140436 fractional seconds per number
        00:00:04.214194 => 0.0140473 fractional seconds per number
        00:00:04.214306 => 0.0140477 fractional seconds per number
        00:00:04.206771 => 0.0140226 fractional seconds per number
        00:00:04.212156 => 0.0140405 fractional seconds per number
        00:00:04.210910 => 0.0140364 fractional seconds per number
        00:00:04.208316 => 0.0140277 fractional seconds per number
        00:00:04.207850 => 0.0140262 fractional seconds per number

**oxygar** · 26/03/2012, 14h36

Merci bien ca fonctionne! Je testerais ton générateur si j'ai besoin de plus de rapidité d'éxécution Ehonn

**Ehonn** · 26/03/2012, 14h48

Ce n'est pas qu'une question de rapidité, je pense que c'est la bonne façon de faire en C++ (norme de 2011).
Tu écris une fonction qui te donne un nombre pseudo-aléatoire sur une distribution (non uniforme) entre a et b alors que ça existe déjà.

Générateur de nombres aléatoires

C++

Discussions similaires

Partager

Partager