nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 /* GLIB - Library of useful routines for C programming
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
16 */
17  
18 /* Originally developed and coded by Makoto Matsumoto and Takuji
19 * Nishimura. Please mail <matumoto@math.keio.ac.jp>, if you're using
20 * code from this file in your own programs or libraries.
21 * Further information on the Mersenne Twister can be found at
22 * http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
23 * This code was adapted to glib by Sebastian Wilhelmi.
24 */
25  
26 /*
27 * Modified by the GLib Team and others 1997-2000. See the AUTHORS
28 * file for a list of people on the GLib Team. See the ChangeLog
29 * files for a list of changes. These files are distributed with
30 * GLib at ftp://ftp.gtk.org/pub/gtk/.
31 */
32  
33 /*
34 * MT safe
35 */
36  
37 #include "config.h"
38 #define _CRT_RAND_S
39  
40 #include <math.h>
41 #include <errno.h>
42 #include <stdio.h>
43 #include <string.h>
44 #include <sys/types.h>
45 #include "grand.h"
46  
47 #include "genviron.h"
48 #include "gmain.h"
49 #include "gmem.h"
50 #include "gtestutils.h"
51 #include "gthread.h"
52  
53 #ifdef G_OS_UNIX
54 #include <unistd.h>
55 #endif
56  
57 #ifdef G_OS_WIN32
58 #include <stdlib.h>
59 #include <process.h> /* For getpid() */
60 #endif
61  
62 /**
63 * SECTION:random_numbers
64 * @title: Random Numbers
65 * @short_description: pseudo-random number generator
66 *
67 * The following functions allow you to use a portable, fast and good
68 * pseudo-random number generator (PRNG).
69 *
70 * Do not use this API for cryptographic purposes such as key
71 * generation, nonces, salts or one-time pads.
72 *
73 * This PRNG is suitable for non-cryptographic use such as in games
74 * (shuffling a card deck, generating levels), generating data for
75 * a test suite, etc. If you need random data for cryptographic
76 * purposes, it is recommended to use platform-specific APIs such
77 * as `/dev/random` on UNIX, or CryptGenRandom() on Windows.
78 *
79 * GRand uses the Mersenne Twister PRNG, which was originally
80 * developed by Makoto Matsumoto and Takuji Nishimura. Further
81 * information can be found at
82 * [this page](http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html).
83 *
84 * If you just need a random number, you simply call the g_random_*
85 * functions, which will create a globally used #GRand and use the
86 * according g_rand_* functions internally. Whenever you need a
87 * stream of reproducible random numbers, you better create a
88 * #GRand yourself and use the g_rand_* functions directly, which
89 * will also be slightly faster. Initializing a #GRand with a
90 * certain seed will produce exactly the same series of random
91 * numbers on all platforms. This can thus be used as a seed for
92 * e.g. games.
93 *
94 * The g_rand*_range functions will return high quality equally
95 * distributed random numbers, whereas for example the
96 * `(g_random_int()%max)` approach often
97 * doesn't yield equally distributed numbers.
98 *
99 * GLib changed the seeding algorithm for the pseudo-random number
100 * generator Mersenne Twister, as used by #GRand. This was necessary,
101 * because some seeds would yield very bad pseudo-random streams.
102 * Also the pseudo-random integers generated by g_rand*_int_range()
103 * will have a slightly better equal distribution with the new
104 * version of GLib.
105 *
106 * The original seeding and generation algorithms, as found in
107 * GLib 2.0.x, can be used instead of the new ones by setting the
108 * environment variable `G_RANDOM_VERSION` to the value of '2.0'.
109 * Use the GLib-2.0 algorithms only if you have sequences of numbers
110 * generated with Glib-2.0 that you need to reproduce exactly.
111 */
112  
113 /**
114 * GRand:
115 *
116 * The GRand struct is an opaque data structure. It should only be
117 * accessed through the g_rand_* functions.
118 **/
119  
120 G_LOCK_DEFINE_STATIC (global_random);
121  
122 /* Period parameters */
123 #define N 624
124 #define M 397
125 #define MATRIX_A 0x9908b0df /* constant vector a */
126 #define UPPER_MASK 0x80000000 /* most significant w-r bits */
127 #define LOWER_MASK 0x7fffffff /* least significant r bits */
128  
129 /* Tempering parameters */
130 #define TEMPERING_MASK_B 0x9d2c5680
131 #define TEMPERING_MASK_C 0xefc60000
132 #define TEMPERING_SHIFT_U(y) (y >> 11)
133 #define TEMPERING_SHIFT_S(y) (y << 7)
134 #define TEMPERING_SHIFT_T(y) (y << 15)
135 #define TEMPERING_SHIFT_L(y) (y >> 18)
136  
137 static guint
138 get_random_version (void)
139 {
140 static gsize initialized = FALSE;
141 static guint random_version;
142  
143 if (g_once_init_enter (&initialized))
144 {
145 const gchar *version_string = g_getenv ("G_RANDOM_VERSION");
146 if (!version_string || version_string[0] == '\000' ||
147 strcmp (version_string, "2.2") == 0)
148 random_version = 22;
149 else if (strcmp (version_string, "2.0") == 0)
150 random_version = 20;
151 else
152 {
153 g_warning ("Unknown G_RANDOM_VERSION \"%s\". Using version 2.2.",
154 version_string);
155 random_version = 22;
156 }
157 g_once_init_leave (&initialized, TRUE);
158 }
159  
160 return random_version;
161 }
162  
163 struct _GRand
164 {
165 guint32 mt[N]; /* the array for the state vector */
166 guint mti;
167 };
168  
169 /**
170 * g_rand_new_with_seed:
171 * @seed: a value to initialize the random number generator
172 *
173 * Creates a new random number generator initialized with @seed.
174 *
175 * Returns: the new #GRand
176 **/
177 GRand*
178 g_rand_new_with_seed (guint32 seed)
179 {
180 GRand *rand = g_new0 (GRand, 1);
181 g_rand_set_seed (rand, seed);
182 return rand;
183 }
184  
185 /**
186 * g_rand_new_with_seed_array:
187 * @seed: an array of seeds to initialize the random number generator
188 * @seed_length: an array of seeds to initialize the random number
189 * generator
190 *
191 * Creates a new random number generator initialized with @seed.
192 *
193 * Returns: the new #GRand
194 *
195 * Since: 2.4
196 */
197 GRand*
198 g_rand_new_with_seed_array (const guint32 *seed,
199 guint seed_length)
200 {
201 GRand *rand = g_new0 (GRand, 1);
202 g_rand_set_seed_array (rand, seed, seed_length);
203 return rand;
204 }
205  
206 /**
207 * g_rand_new:
208 *
209 * Creates a new random number generator initialized with a seed taken
210 * either from `/dev/urandom` (if existing) or from the current time
211 * (as a fallback).
212 *
213 * On Windows, the seed is taken from rand_s().
214 *
215 * Returns: the new #GRand
216 */
217 GRand*
218 g_rand_new (void)
219 {
220 guint32 seed[4];
221 #ifdef G_OS_UNIX
222 static gboolean dev_urandom_exists = TRUE;
223 GTimeVal now;
224  
225 if (dev_urandom_exists)
226 {
227 FILE* dev_urandom;
228  
229 do
230 {
231 dev_urandom = fopen("/dev/urandom", "rb");
232 }
233 while G_UNLIKELY (dev_urandom == NULL && errno == EINTR);
234  
235 if (dev_urandom)
236 {
237 int r;
238  
239 setvbuf (dev_urandom, NULL, _IONBF, 0);
240 do
241 {
242 errno = 0;
243 r = fread (seed, sizeof (seed), 1, dev_urandom);
244 }
245 while G_UNLIKELY (errno == EINTR);
246  
247 if (r != 1)
248 dev_urandom_exists = FALSE;
249  
250 fclose (dev_urandom);
251 }
252 else
253 dev_urandom_exists = FALSE;
254 }
255  
256 if (!dev_urandom_exists)
257 {
258 g_get_current_time (&now);
259 seed[0] = now.tv_sec;
260 seed[1] = now.tv_usec;
261 seed[2] = getpid ();
262 seed[3] = getppid ();
263 }
264 #else /* G_OS_WIN32 */
265 /* rand_s() is only available since Visual Studio 2005 and
266 * MinGW-w64 has a wrapper that will emulate rand_s() if it's not in msvcrt
267 */
268 #if (defined(_MSC_VER) && _MSC_VER >= 1400) || defined(__MINGW64_VERSION_MAJOR)
269 gint i;
270  
271 for (i = 0; i < G_N_ELEMENTS (seed); i++)
272 rand_s (&seed[i]);
273 #else
274 #warning Using insecure seed for random number generation because of missing rand_s() in Windows XP
275 GTimeVal now;
276  
277 g_get_current_time (&now);
278 seed[0] = now.tv_sec;
279 seed[1] = now.tv_usec;
280 seed[2] = getpid ();
281 seed[3] = 0;
282 #endif
283  
284 #endif
285  
286 return g_rand_new_with_seed_array (seed, 4);
287 }
288  
289 /**
290 * g_rand_free:
291 * @rand_: a #GRand
292 *
293 * Frees the memory allocated for the #GRand.
294 */
295 void
296 g_rand_free (GRand *rand)
297 {
298 g_return_if_fail (rand != NULL);
299  
300 g_free (rand);
301 }
302  
303 /**
304 * g_rand_copy:
305 * @rand_: a #GRand
306 *
307 * Copies a #GRand into a new one with the same exact state as before.
308 * This way you can take a snapshot of the random number generator for
309 * replaying later.
310 *
311 * Returns: the new #GRand
312 *
313 * Since: 2.4
314 */
315 GRand*
316 g_rand_copy (GRand *rand)
317 {
318 GRand* new_rand;
319  
320 g_return_val_if_fail (rand != NULL, NULL);
321  
322 new_rand = g_new0 (GRand, 1);
323 memcpy (new_rand, rand, sizeof (GRand));
324  
325 return new_rand;
326 }
327  
328 /**
329 * g_rand_set_seed:
330 * @rand_: a #GRand
331 * @seed: a value to reinitialize the random number generator
332 *
333 * Sets the seed for the random number generator #GRand to @seed.
334 */
335 void
336 g_rand_set_seed (GRand *rand,
337 guint32 seed)
338 {
339 g_return_if_fail (rand != NULL);
340  
341 switch (get_random_version ())
342 {
343 case 20:
344 /* setting initial seeds to mt[N] using */
345 /* the generator Line 25 of Table 1 in */
346 /* [KNUTH 1981, The Art of Computer Programming */
347 /* Vol. 2 (2nd Ed.), pp102] */
348  
349 if (seed == 0) /* This would make the PRNG produce only zeros */
350 seed = 0x6b842128; /* Just set it to another number */
351  
352 rand->mt[0]= seed;
353 for (rand->mti=1; rand->mti<N; rand->mti++)
354 rand->mt[rand->mti] = (69069 * rand->mt[rand->mti-1]);
355  
356 break;
357 case 22:
358 /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
359 /* In the previous version (see above), MSBs of the */
360 /* seed affect only MSBs of the array mt[]. */
361  
362 rand->mt[0]= seed;
363 for (rand->mti=1; rand->mti<N; rand->mti++)
364 rand->mt[rand->mti] = 1812433253UL *
365 (rand->mt[rand->mti-1] ^ (rand->mt[rand->mti-1] >> 30)) + rand->mti;
366 break;
367 default:
368 g_assert_not_reached ();
369 }
370 }
371  
372 /**
373 * g_rand_set_seed_array:
374 * @rand_: a #GRand
375 * @seed: array to initialize with
376 * @seed_length: length of array
377 *
378 * Initializes the random number generator by an array of longs.
379 * Array can be of arbitrary size, though only the first 624 values
380 * are taken. This function is useful if you have many low entropy
381 * seeds, or if you require more then 32 bits of actual entropy for
382 * your application.
383 *
384 * Since: 2.4
385 */
386 void
387 g_rand_set_seed_array (GRand *rand,
388 const guint32 *seed,
389 guint seed_length)
390 {
391 int i, j, k;
392  
393 g_return_if_fail (rand != NULL);
394 g_return_if_fail (seed_length >= 1);
395  
396 g_rand_set_seed (rand, 19650218UL);
397  
398 i=1; j=0;
399 k = (N>seed_length ? N : seed_length);
400 for (; k; k--)
401 {
402 rand->mt[i] = (rand->mt[i] ^
403 ((rand->mt[i-1] ^ (rand->mt[i-1] >> 30)) * 1664525UL))
404 + seed[j] + j; /* non linear */
405 rand->mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
406 i++; j++;
407 if (i>=N)
408 {
409 rand->mt[0] = rand->mt[N-1];
410 i=1;
411 }
412 if (j>=seed_length)
413 j=0;
414 }
415 for (k=N-1; k; k--)
416 {
417 rand->mt[i] = (rand->mt[i] ^
418 ((rand->mt[i-1] ^ (rand->mt[i-1] >> 30)) * 1566083941UL))
419 - i; /* non linear */
420 rand->mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
421 i++;
422 if (i>=N)
423 {
424 rand->mt[0] = rand->mt[N-1];
425 i=1;
426 }
427 }
428  
429 rand->mt[0] = 0x80000000UL; /* MSB is 1; assuring non-zero initial array */
430 }
431  
432 /**
433 * g_rand_boolean:
434 * @rand_: a #GRand
435 *
436 * Returns a random #gboolean from @rand_.
437 * This corresponds to a unbiased coin toss.
438 *
439 * Returns: a random #gboolean
440 */
441 /**
442 * g_rand_int:
443 * @rand_: a #GRand
444 *
445 * Returns the next random #guint32 from @rand_ equally distributed over
446 * the range [0..2^32-1].
447 *
448 * Returns: a random number
449 */
450 guint32
451 g_rand_int (GRand *rand)
452 {
453 guint32 y;
454 static const guint32 mag01[2]={0x0, MATRIX_A};
455 /* mag01[x] = x * MATRIX_A for x=0,1 */
456  
457 g_return_val_if_fail (rand != NULL, 0);
458  
459 if (rand->mti >= N) { /* generate N words at one time */
460 int kk;
461  
462 for (kk = 0; kk < N - M; kk++) {
463 y = (rand->mt[kk]&UPPER_MASK)|(rand->mt[kk+1]&LOWER_MASK);
464 rand->mt[kk] = rand->mt[kk+M] ^ (y >> 1) ^ mag01[y & 0x1];
465 }
466 for (; kk < N - 1; kk++) {
467 y = (rand->mt[kk]&UPPER_MASK)|(rand->mt[kk+1]&LOWER_MASK);
468 rand->mt[kk] = rand->mt[kk+(M-N)] ^ (y >> 1) ^ mag01[y & 0x1];
469 }
470 y = (rand->mt[N-1]&UPPER_MASK)|(rand->mt[0]&LOWER_MASK);
471 rand->mt[N-1] = rand->mt[M-1] ^ (y >> 1) ^ mag01[y & 0x1];
472  
473 rand->mti = 0;
474 }
475  
476 y = rand->mt[rand->mti++];
477 y ^= TEMPERING_SHIFT_U(y);
478 y ^= TEMPERING_SHIFT_S(y) & TEMPERING_MASK_B;
479 y ^= TEMPERING_SHIFT_T(y) & TEMPERING_MASK_C;
480 y ^= TEMPERING_SHIFT_L(y);
481  
482 return y;
483 }
484  
485 /* transform [0..2^32] -> [0..1] */
486 #define G_RAND_DOUBLE_TRANSFORM 2.3283064365386962890625e-10
487  
488 /**
489 * g_rand_int_range:
490 * @rand_: a #GRand
491 * @begin: lower closed bound of the interval
492 * @end: upper open bound of the interval
493 *
494 * Returns the next random #gint32 from @rand_ equally distributed over
495 * the range [@begin..@end-1].
496 *
497 * Returns: a random number
498 */
499 gint32
500 g_rand_int_range (GRand *rand,
501 gint32 begin,
502 gint32 end)
503 {
504 guint32 dist = end - begin;
505 guint32 random;
506  
507 g_return_val_if_fail (rand != NULL, begin);
508 g_return_val_if_fail (end > begin, begin);
509  
510 switch (get_random_version ())
511 {
512 case 20:
513 if (dist <= 0x10000L) /* 2^16 */
514 {
515 /* This method, which only calls g_rand_int once is only good
516 * for (end - begin) <= 2^16, because we only have 32 bits set
517 * from the one call to g_rand_int ().
518 *
519 * We are using (trans + trans * trans), because g_rand_int only
520 * covers [0..2^32-1] and thus g_rand_int * trans only covers
521 * [0..1-2^-32], but the biggest double < 1 is 1-2^-52.
522 */
523  
524 gdouble double_rand = g_rand_int (rand) *
525 (G_RAND_DOUBLE_TRANSFORM +
526 G_RAND_DOUBLE_TRANSFORM * G_RAND_DOUBLE_TRANSFORM);
527  
528 random = (gint32) (double_rand * dist);
529 }
530 else
531 {
532 /* Now we use g_rand_double_range (), which will set 52 bits
533 * for us, so that it is safe to round and still get a decent
534 * distribution
535 */
536 random = (gint32) g_rand_double_range (rand, 0, dist);
537 }
538 break;
539 case 22:
540 if (dist == 0)
541 random = 0;
542 else
543 {
544 /* maxvalue is set to the predecessor of the greatest
545 * multiple of dist less or equal 2^32.
546 */
547 guint32 maxvalue;
548 if (dist <= 0x80000000u) /* 2^31 */
549 {
550 /* maxvalue = 2^32 - 1 - (2^32 % dist) */
551 guint32 leftover = (0x80000000u % dist) * 2;
552 if (leftover >= dist) leftover -= dist;
553 maxvalue = 0xffffffffu - leftover;
554 }
555 else
556 maxvalue = dist - 1;
557  
558 do
559 random = g_rand_int (rand);
560 while (random > maxvalue);
561  
562 random %= dist;
563 }
564 break;
565 default:
566 random = 0; /* Quiet GCC */
567 g_assert_not_reached ();
568 }
569  
570 return begin + random;
571 }
572  
573 /**
574 * g_rand_double:
575 * @rand_: a #GRand
576 *
577 * Returns the next random #gdouble from @rand_ equally distributed over
578 * the range [0..1).
579 *
580 * Returns: a random number
581 */
582 gdouble
583 g_rand_double (GRand *rand)
584 {
585 /* We set all 52 bits after the point for this, not only the first
586 32. Thats why we need two calls to g_rand_int */
587 gdouble retval = g_rand_int (rand) * G_RAND_DOUBLE_TRANSFORM;
588 retval = (retval + g_rand_int (rand)) * G_RAND_DOUBLE_TRANSFORM;
589  
590 /* The following might happen due to very bad rounding luck, but
591 * actually this should be more than rare, we just try again then */
592 if (retval >= 1.0)
593 return g_rand_double (rand);
594  
595 return retval;
596 }
597  
598 /**
599 * g_rand_double_range:
600 * @rand_: a #GRand
601 * @begin: lower closed bound of the interval
602 * @end: upper open bound of the interval
603 *
604 * Returns the next random #gdouble from @rand_ equally distributed over
605 * the range [@begin..@end).
606 *
607 * Returns: a random number
608 */
609 gdouble
610 g_rand_double_range (GRand *rand,
611 gdouble begin,
612 gdouble end)
613 {
614 gdouble r;
615  
616 r = g_rand_double (rand);
617  
618 return r * end - (r - 1) * begin;
619 }
620  
621 static GRand *
622 get_global_random (void)
623 {
624 static GRand *global_random;
625  
626 /* called while locked */
627 if (!global_random)
628 global_random = g_rand_new ();
629  
630 return global_random;
631 }
632  
633 /**
634 * g_random_boolean:
635 *
636 * Returns a random #gboolean.
637 * This corresponds to a unbiased coin toss.
638 *
639 * Returns: a random #gboolean
640 */
641 /**
642 * g_random_int:
643 *
644 * Return a random #guint32 equally distributed over the range
645 * [0..2^32-1].
646 *
647 * Returns: a random number
648 */
649 guint32
650 g_random_int (void)
651 {
652 guint32 result;
653 G_LOCK (global_random);
654 result = g_rand_int (get_global_random ());
655 G_UNLOCK (global_random);
656 return result;
657 }
658  
659 /**
660 * g_random_int_range:
661 * @begin: lower closed bound of the interval
662 * @end: upper open bound of the interval
663 *
664 * Returns a random #gint32 equally distributed over the range
665 * [@begin..@end-1].
666 *
667 * Returns: a random number
668 */
669 gint32
670 g_random_int_range (gint32 begin,
671 gint32 end)
672 {
673 gint32 result;
674 G_LOCK (global_random);
675 result = g_rand_int_range (get_global_random (), begin, end);
676 G_UNLOCK (global_random);
677 return result;
678 }
679  
680 /**
681 * g_random_double:
682 *
683 * Returns a random #gdouble equally distributed over the range [0..1).
684 *
685 * Returns: a random number
686 */
687 gdouble
688 g_random_double (void)
689 {
690 double result;
691 G_LOCK (global_random);
692 result = g_rand_double (get_global_random ());
693 G_UNLOCK (global_random);
694 return result;
695 }
696  
697 /**
698 * g_random_double_range:
699 * @begin: lower closed bound of the interval
700 * @end: upper open bound of the interval
701 *
702 * Returns a random #gdouble equally distributed over the range
703 * [@begin..@end).
704 *
705 * Returns: a random number
706 */
707 gdouble
708 g_random_double_range (gdouble begin,
709 gdouble end)
710 {
711 double result;
712 G_LOCK (global_random);
713 result = g_rand_double_range (get_global_random (), begin, end);
714 G_UNLOCK (global_random);
715 return result;
716 }
717  
718 /**
719 * g_random_set_seed:
720 * @seed: a value to reinitialize the global random number generator
721 *
722 * Sets the seed for the global random number generator, which is used
723 * by the g_random_* functions, to @seed.
724 */
725 void
726 g_random_set_seed (guint32 seed)
727 {
728 G_LOCK (global_random);
729 g_rand_set_seed (get_global_random (), seed);
730 G_UNLOCK (global_random);
731 }