* Nishimura. Please mail <matumoto@math.keio.ac.jp>, if you're using
* code from this file in your own programs or libraries.
* Further information on the Mersenne Twister can be found at
- * http://www.math.keio.ac.jp/~matumoto/emt.html
- * This code was adapted to glib by Sebastian Wilhelmi <wilhelmi@ira.uka.de>.
+ * http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
+ * This code was adapted to glib by Sebastian Wilhelmi.
*/
/*
#include "config.h"
#include <math.h>
+#include <errno.h>
#include <stdio.h>
#include <string.h>
+#include <sys/types.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
#include "glib.h"
+#include "gthreadprivate.h"
+#include "galias.h"
+
+#ifdef G_OS_WIN32
+#include <process.h> /* For getpid() */
+#endif
+
+/**
+ * SECTION: random_numbers
+ * @title: Random Numbers
+ * @short_description: pseudo-random number generator
+ *
+ * The following functions allow you to use a portable, fast and good
+ * pseudo-random number generator (PRNG). It uses the Mersenne Twister
+ * PRNG, which was originally developed by Makoto Matsumoto and Takuji
+ * Nishimura. Further information can be found at
+ * <ulink url="http://www.math.keio.ac.jp/~matumoto/emt.html">
+ * www.math.keio.ac.jp/~matumoto/emt.html</ulink>.
+ *
+ * If you just need a random number, you simply call the
+ * <function>g_random_*</function> functions, which will create a
+ * globally used #GRand and use the according
+ * <function>g_rand_*</function> functions internally. Whenever you
+ * need a stream of reproducible random numbers, you better create a
+ * #GRand yourself and use the <function>g_rand_*</function> functions
+ * directly, which will also be slightly faster. Initializing a #GRand
+ * with a certain seed will produce exactly the same series of random
+ * numbers on all platforms. This can thus be used as a seed for e.g.
+ * games.
+ *
+ * The <function>g_rand*_range</function> functions will return high
+ * quality equally distributed random numbers, whereas for example the
+ * <literal>(g_random_int()%max)</literal> approach often
+ * doesn't yield equally distributed numbers.
+ *
+ * GLib changed the seeding algorithm for the pseudo-random number
+ * generator Mersenne Twister, as used by
+ * <structname>GRand</structname> and <structname>GRandom</structname>.
+ * This was necessary, because some seeds would yield very bad
+ * pseudo-random streams. Also the pseudo-random integers generated by
+ * <function>g_rand*_int_range()</function> will have a slightly better
+ * equal distribution with the new version of GLib.
+ *
+ * The original seeding and generation algorithms, as found in GLib
+ * 2.0.x, can be used instead of the new ones by setting the
+ * environment variable <envar>G_RANDOM_VERSION</envar> to the value of
+ * '2.0'. Use the GLib-2.0 algorithms only if you have sequences of
+ * numbers generated with Glib-2.0 that you need to reproduce exactly.
+ **/
+/**
+ * GRand:
+ *
+ * The #GRand struct is an opaque data structure. It should only be
+ * accessed through the <function>g_rand_*</function> functions.
+ **/
G_LOCK_DEFINE_STATIC (global_random);
static GRand* global_random = NULL;
* initialize some static data in a threadsafe way.
*/
void
-g_rand_init (void)
+_g_rand_thread_init (void)
{
(void)get_random_version ();
}
}
/**
+ * g_rand_new_with_seed_array:
+ * @seed: an array of seeds to initialize the random number generator.
+ * @seed_length: an array of seeds to initialize the random number generator.
+ *
+ * Creates a new random number generator initialized with @seed.
+ *
+ * Return value: the new #GRand.
+ *
+ * Since: 2.4
+ **/
+GRand*
+g_rand_new_with_seed_array (const guint32 *seed, guint seed_length)
+{
+ GRand *rand = g_new0 (GRand, 1);
+ g_rand_set_seed_array (rand, seed, seed_length);
+ return rand;
+}
+
+/**
* g_rand_new:
*
* Creates a new random number generator initialized with a seed taken
GRand*
g_rand_new (void)
{
- guint32 seed;
+ guint32 seed[4];
GTimeVal now;
#ifdef G_OS_UNIX
static gboolean dev_urandom_exists = TRUE;
if (dev_urandom_exists)
{
- FILE* dev_urandom = fopen("/dev/urandom", "rb");
+ FILE* dev_urandom;
+
+ do
+ {
+ errno = 0;
+ dev_urandom = fopen("/dev/urandom", "rb");
+ }
+ while G_UNLIKELY (errno == EINTR);
+
if (dev_urandom)
{
- if (fread (&seed, sizeof (seed), 1, dev_urandom) != 1)
+ int r;
+
+ setvbuf (dev_urandom, NULL, _IONBF, 0);
+ do
+ {
+ errno = 0;
+ r = fread (seed, sizeof (seed), 1, dev_urandom);
+ }
+ while G_UNLIKELY (errno == EINTR);
+
+ if (r != 1)
dev_urandom_exists = FALSE;
+
fclose (dev_urandom);
}
else
if (!dev_urandom_exists)
{
g_get_current_time (&now);
- seed = now.tv_sec ^ now.tv_usec;
+ seed[0] = now.tv_sec;
+ seed[1] = now.tv_usec;
+ seed[2] = getpid ();
+#ifdef G_OS_UNIX
+ seed[3] = getppid ();
+#else
+ seed[3] = 0;
+#endif
}
- return g_rand_new_with_seed (seed);
+ return g_rand_new_with_seed_array (seed, 4);
}
/**
}
/**
+ * g_rand_copy:
+ * @rand_: a #GRand.
+ *
+ * Copies a #GRand into a new one with the same exact state as before.
+ * This way you can take a snapshot of the random number generator for
+ * replaying later.
+ *
+ * Return value: the new #GRand.
+ *
+ * Since: 2.4
+ **/
+GRand *
+g_rand_copy (GRand* rand)
+{
+ GRand* new_rand;
+
+ g_return_val_if_fail (rand != NULL, NULL);
+
+ new_rand = g_new0 (GRand, 1);
+ memcpy (new_rand, rand, sizeof (GRand));
+
+ return new_rand;
+}
+
+/**
* g_rand_set_seed:
* @rand_: a #GRand.
* @seed: a value to reinitialize the random number generator.
}
/**
+ * g_rand_set_seed_array:
+ * @rand_: a #GRand.
+ * @seed: array to initialize with
+ * @seed_length: length of array
+ *
+ * Initializes the random number generator by an array of
+ * longs. Array can be of arbitrary size, though only the
+ * first 624 values are taken. This function is useful
+ * if you have many low entropy seeds, or if you require more then
+ * 32bits of actual entropy for your application.
+ *
+ * Since: 2.4
+ **/
+void
+g_rand_set_seed_array (GRand* rand, const guint32 *seed, guint seed_length)
+{
+ int i, j, k;
+
+ g_return_if_fail (rand != NULL);
+ g_return_if_fail (seed_length >= 1);
+
+ g_rand_set_seed (rand, 19650218UL);
+
+ i=1; j=0;
+ k = (N>seed_length ? N : seed_length);
+ for (; k; k--)
+ {
+ rand->mt[i] = (rand->mt[i] ^
+ ((rand->mt[i-1] ^ (rand->mt[i-1] >> 30)) * 1664525UL))
+ + seed[j] + j; /* non linear */
+ rand->mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
+ i++; j++;
+ if (i>=N)
+ {
+ rand->mt[0] = rand->mt[N-1];
+ i=1;
+ }
+ if (j>=seed_length)
+ j=0;
+ }
+ for (k=N-1; k; k--)
+ {
+ rand->mt[i] = (rand->mt[i] ^
+ ((rand->mt[i-1] ^ (rand->mt[i-1] >> 30)) * 1566083941UL))
+ - i; /* non linear */
+ rand->mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
+ i++;
+ if (i>=N)
+ {
+ rand->mt[0] = rand->mt[N-1];
+ i=1;
+ }
+ }
+
+ rand->mt[0] = 0x80000000UL; /* MSB is 1; assuring non-zero initial array */
+}
+
+/**
+ * g_rand_boolean:
+ * @rand_: a #GRand.
+ * @Returns: a random #gboolean.
+ *
+ * Returns a random #gboolean from @rand_. This corresponds to a
+ * unbiased coin toss.
+ **/
+/**
* g_rand_int:
* @rand_: a #GRand.
*
}
/**
+ * g_random_boolean:
+ * @Returns: a random #gboolean.
+ *
+ * Returns a random #gboolean. This corresponds to a unbiased coin toss.
+ **/
+/**
* g_random_int:
*
* Return a random #guint32 equally distributed over the range
G_UNLOCK (global_random);
}
+
+#define __G_RAND_C__
+#include "galiasdef.c"
projects / platform / upstream / glib.git / blobdiff